The first script we will look at is the GPS Location Service. Expand the Services object in the Hierarchy window and select the GPS service object. Review the object in the Inspector window and notice all the new properties and sections. Two new sections have been added to the GPS Location Service script. The first section is for map tile parameters and the second section is a new feature for simulating GPS data. We will review the purpose and properties of these two subsequent new sections.

Map tile parameters

Previously, whenever our GPS service acquired a new update from the device, that data would automatically be pushed to the map and the map would redraw itself. As you saw, that simple method worked, but it did suffer from a couple of problems. First, every time the service acquired a new location, the map would make several expensive calls to refresh itself. It didn't matter whether the device moved a meter or 100 meters. Second, if we want to show our character move across the map, then we can't refresh the map each time with every new location. Instead, we only want to refresh when the character reaches a tile boundary. Fortunately, we can solve both of these issues by allowing the GPS service to track the size of a map tile and then call a map refresh when a new GPS reading is outside the current center tile.

The following is a diagram showing how this will work:

GPS tracked on map tile boundary

In order for the GPS Location Service to be able to keep track of the tile boundary, it needs to know how the tile is generated. This is why we need to pass the same parameters we used to construct the map tiles into the service. Here is a review of those parameters and what they should be set to for the game:

• Map tile scale: This indicates the scale of the map tiles. We set this to 30 for the current map.
• Map tile size pixels: This is the map tile image size being requested from Google. This was set to 640 pixels.
• Map tile zoom level: This is the zoom level or the scale of the map. We chose a value for 17 in order to neighborhood scale map.

The Google Static Maps API throttles the number of requests an IP address or a device can make every 5 seconds and every 24 hours. Currently, the limit is 1000 requests per 24 hours.

GPS simulation settings

As you have probably already realized, testing the GPS service was going to be difficult. Sure, we set up CUDLR to allow us to view real-time updates while the application was running on the device, but that had limitations. Ideally, we want to be able to test the way our game objects consume the GPS service as it is running in the Unity editor. That way, we can see how the game will run, without having to move around the house or office every few seconds. We can accomplish this testing by generating simulated location readings from the GPS service.

The simulation service that was added to the GPS Location Service uses a simple origin offset approach to generating data points. This approach will allow us to define simple movement patterns, such as moving in a straight line or moving and turning. The following is a diagram that should help explain how the data points are calculated:

Offset data approach to simulate GPS readings

In the subsequent list, each of the GPS simulation properties are explained in more detail:

• Simulating: If checked, the GPS service will generate simulated data. Data simulation will not run on a mobile device. Check this option to turn on the GPS simulation.
• Start coordinates: This is the origin point for the simulation. Offset values will be accumulated against the origin. Use our test coordinates or some latitude or longitude coordinates that are more familiar to you.
• Rate: This is the rate in seconds at which new GPS readings will be simulated. A good value for this is 5 seconds.
• Simulation offsets: This is the offset table of array values that will be added and accumulated against the origin. These values are in latitude or longitude values, so keep these numbers small. A good starting value is around +- 0.0003. The offset values will continually loop. So, after the bottom value is added, the offset table will start at the top again.

In order to set the array type in Unity and configure the SimulationService, perform the following steps:

1. Enter the number of values in the Size field. The list will then expand to allow you to enter each of the values. The following screenshot shows the new GPS Location Service filled in with the appropriate component properties:
   

   Inspector view of GPS service object

2. Select the Player game object in the Hierarchy window. In the Inspector window, you will note that a new property was added to the Character GPS Compass Controller script component. We now need to set the GPS Location Service in this script, just like we did for the map tiles. That makes sense, because the character controller also needs to consume updates from the GPS service. Here is a screenshot of the controller script:
   

   Character GPS Compass Controller script

3. With the Player object still selected, drag the GPS object from the Hierarchy window and drop it into the Gps Location Service field on the Character GPS Compass Controller component.
4. Run the game in the editor by pressing the Play button.

Now, as the GPS data is being simulated, you will see the character move around the map. However, as you probably noticed, we now have a couple of other issues. The camera no longer remains at a fixed distance from the character, and the movement is too quick. Fortunately, these are simple fixes and can be done quickly by following the directions, as follows:

1. In the Hierarchy window, expand the Player object and select the FreeLookCameraRig. The reason the camera is not following the Player is because it is tracking the game object but not the game object's transform. This is a subtle but important difference. We will need to set the target transform in the camera to be the Player. Here is a screenshot that shows the empty transform field in the Free Look Cam script component:
   

   Free Look Cam script properties

2. While the FreeLookCameraRig object is still selected in the Hierarchy window, drag the Player object to the Target field in the Free Look Cam script component. This will now force the camera to follow the character's transform.
3. Select the Player object in the Hierarchy window. In the Inspector window, set the Move Speed Multiplier of the Third Person Character script component to 0.1, as shown in the next screenshot:
   

   The Third Person Character script component

4. The reason we set this to a small value is to account for our difference in map scale. The typical character controller will move a character at a speed close to walking. This is OK, when your game is at a 1:1 scale. Our game, however, is at a much grander scale. Calculating what this exact value is will depend on a number of factors. For now, we will estimate a value of 0.1 to reduce the character speed by one-tenth. We will add this as item we will discuss in Chapter 9, Finishing the Game.
5. Press the Play button to run the game in the editor. As you can see, the character moves around the map as expected. Ensure that you try other offset values for the simulation points and rerun the game in the editor. Finally, build and deploy the game to your device and take the game out for a walk or drive.

This covers the updated properties to the GPS Location Service. We won't cover the specific script changes, as that will be left to the diligent reader to do so on their own.

If you remember from above that the only new property on the character compass GPS controller was a reference to the GPS Location Service. This was needed in order to update the player's position as new GPS readings are acquired. Since we began writing the character controller script from the beginning, let's review the code to see what has changed.

Locate the Character GPS Compass Controller script in the Project window under the Assets/FoodyGO/Scripts/Controllers folder. Double-click on the script to open it in MonoDevelop or the editor of your choice. After the script opens, take a few minutes to review the changes.

Now, let's go through each section of the script and understand the changes in more detail. Starting from the top, following are the top lines of the script:

using UnityEngine; 
using UnityStandardAssets.Characters.ThirdPerson; 
using packt.FoodyGO.Mapping; 
using packt.FoodyGO.Services; 
 
namespace packt.FoodyGO.Controllers 
{ 
    public class CharacterGPSCompassController : MonoBehaviour 
    { 
        public GPSLocationService gpsLocationService; 
        private double lastTimestamp;         
        private ThirdPersonCharacter thirdPersonCharacter; 
        private Vector3 target; 

At the very top is the using, which is standard for a C# script. The top line is standard for all Unity scripts. The next few lines import the other types this script will use. Then, the start of the script definition begins with a namespace declaration. Defining a namespace is standard when writing a C# file in other development platforms, but it is a practice Unity does not require or enforce. Unity does this in order to support a variety of scripting languages. However, as you may painfully learn, not adhering to a namespace can cause all manner of naming conflicts. For the purpose of this book, we will adhere to the packt.FoodyGO namespace.

After the namespace declaration is the class definition followed by some new variables. A variable for the GPS Location Service was added and made public so that it could be changed in the Unity editor. Then, three new private variables were added. We will review the purpose for each of those variables below in the relevant code section.

Marking a variable marked private sets the variable for internal use only within the class. If you are an experienced C# developer, you may also be asking, why we are using a public variable when it should be a property accessor. A public variable can be modified in the Unity editor, but a private or property accessor is hidden. You can, of course, still use property accessors from other types, but in general, most Unity developers will avoid them, instead prefer to just use public or private.

Here is an example of a property accessor:

public double Timestamp 
        { 
            get 
            { 
                return timestamp; 
            } 
            set 
            { 
                timestamp = value; 
            } 
        } 

The next section of the script we will look at is the Start method shown in the code listing:

// Use this for initialization 
        void Start() 
        { 
            Input.compass.enabled = true; 
            thirdPersonCharacter = GetComponent<ThirdPersonCharacter>(); 
            if (gpsLocationService != null) 
            { 
                gpsLocationService.OnMapRedraw += GpsLocationService_OnMapRedraw; 
            } 
        } 

As you can see, we added a couple more lines after the Input.compass.enabled line we wrote earlier in the chapter. After turning on the compass, the next line gets a reference to the ThirdPersonCharacter component script and stores it into that private variable thirdPersonCharacter. The ThirdPersonCharacter script controls the movement and animations of our character. As you will see, we will use that reference to move the character later in the Update method.

The following line checks whether the gpsLocationService is not null. If the value is not null, as it shouldn't be, we consume a new event on the GPS service called OnMapRedraw. OnMapRedraw fires after the center map tile is recentered and redrawn. Remember from our explanation above that the GPS service now tracks when it needs to recenter the map. After the service initiates a redraw to the map tile, the map tile requests a new map image. After the image request returns and the map tile is changed, the map tile tells the GPS service that it has refreshed itself. The GPS Service will then broadcast the OnMapRedraw event to all its consumers to let them know that they also need to recenter themselves. If you are a little lost on how this all connects, hopefully the following diagram will help:

Flow of data and events from GPS service

The next couple of lines after the Start method are for subscribing to the OnMapRedraw event. The event is a void method that passes the event source in the GameObject g, parameter:

private void GpsLocationService_OnMapRedraw(GameObject g) 
        { 
            transform.position = Vector3.zero; 
            target = Vector3.zero; 
        } 

When the OnMapRedraw fires, it tells the character controller it needs to reset its position back to the origin, as the map has finished redrawing. Inside the event handler, the Player transform position is to set to Vector3.zero; this is the same as setting the position to (0,0,0). Likewise, we do the same to the target variable. We will get to that variable shortly in the Update method.

Finally, we come to the last method and the real worker in our class, the Update method. The following is the code listing:

// Update is called once per frame 
        void Update() 
        { 
            if (gpsLocationService != null && 
                gpsLocationService.IsServiceStarted && 
                gpsLocationService.PlayerTimestamp > lastTimestamp) 
            { 
                //convert GPS lat/long to world x/y  
                var x = ((GoogleMapUtils.LonToX(gpsLocationService.Longitude) 
                    - gpsLocationService.mapWorldCenter.x) * gpsLocationService.mapScale.x); 
                var y = (GoogleMapUtils.LatToY(gpsLocationService.Latitude) 
                    - gpsLocationService.mapWorldCenter.y) * gpsLocationService.mapScale.y; 
                target = new Vector3(-x, 0, y); 
            } 
 
            //check if the character has reached the new point 
            if (Vector3.Distance(target, transform.position) > .025f) 
            { 
                var move = target - transform.position; 
                thirdPersonCharacter.Move(move, false, false); 
            } 
            else 
            { 
                //stop moving 
                thirdPersonCharacter.Move(Vector3.zero, false, false); 
 
                // Orient an object to point to magnetic north and adjust for map reversal 
                var heading = 180 + Input.compass.magneticHeading; 
                var rotation = Quaternion.AngleAxis(heading, Vector3.up); 
                transform.rotation = Quaternion.Slerp(transform.rotation, rotation, Time.fixedTime * .001f); 
            } 
        } 

As you can see, a number of lines of code were added to support the GPS movement of our character. The code may seem complex, but it is fairly straightforward if we take our time.

At the top of the method, you will see almost the same test we did in the Google Map Tile script to check whether the GPS service is set, is running, and sending new location data. Inside the if statement is a couple of complex calculations that use the GoogleMapUtils helper library to convert GPS latitude or longitude to x or y 2D world coordinates. This is then converted into 3D world coordinates in the next line and stored in that target variable. Ensure that you notice the negation on the x parameter. Remember that our map is flipped and positive x points to west and not east. The target variable stores the 3D world position we want our character to move to.

The next if/else statement checks whether the player has reached the target position. Normally, this test is done with a value of 0.1f. However, that is at a real-world 1:1 scale; again, for our purpose, we will use a much smaller number.

Inside the if statement, we know the character has not reached its destination and needs to continue moving. In order to make the character move, we need to pass the thirdPersonCharacter a move vector. The move vector is calculated by subtracting the character's current position, denoted by transform.position, from the target. The result is a vector that we then use to call the Move method on the thirdPersonCharacter. Internally, the ThirdPersonCharacter script will manage the animations and movement.

In the else section of theif statement, we know the character is not moving or at least shouldn't be. Therefore, we call the Move method on the thirdPersonCharacter again, this time with a zero vector in order to stop movement. After that, we check the compass heading and set that just as we did before. Note that we only set the compass heading if the character is not moving. After all, when the character moves, we want them facing in the direction of travel.

Well, that completes reviewing the CharacterGPSController script. This script is a good start for showing player movement around a map. However, as you play the game or allow others to play the game, you may notice some areas that may need improvement. Feel free to improve on this script as much as you like and make it your own.