#define LIGHTSPEED

using UnityEngine;
using System.Text;
using System.Collections;
using System.Collections.Generic;

namespace WPM {
    public class Demo : MonoBehaviour {

        public GameObject rocketPrefab;

        WorldMapGlobe map;
        GUIStyle labelStyle, labelStyleShadow, buttonStyle, sliderStyle, sliderThumbStyle;
        ColorPicker colorPicker;
        bool changingFrontiersColor;
        bool minimizeState = false;
        bool animatingField;
        float zoomLevel = 1.0f;


        void Start() {
            // Get a reference to the World Map API:
            map = WorldMapGlobe.instance;
#if LIGHTSPEED
            Camera.main.fieldOfView = 180;
            animatingField = true;
#endif
            map.earthInvertedMode = false;

            // UI Setup - non-important, only for this demo
            labelStyle = new GUIStyle();
            labelStyle.alignment = TextAnchor.MiddleCenter;
            labelStyle.normal.textColor = Color.white;
            labelStyleShadow = new GUIStyle(labelStyle);
            labelStyleShadow.normal.textColor = Color.black;
            buttonStyle = new GUIStyle(labelStyle);
            buttonStyle.alignment = TextAnchor.MiddleLeft;
            buttonStyle.normal.background = Texture2D.whiteTexture;
            buttonStyle.normal.textColor = Color.white;
            colorPicker = gameObject.GetComponent<ColorPicker>();
            sliderStyle = new GUIStyle();
            sliderStyle.normal.background = Texture2D.whiteTexture;
            sliderStyle.fixedHeight = 4.0f;
            sliderThumbStyle = new GUIStyle();
            sliderThumbStyle.normal.background = Resources.Load<Texture2D>("thumb");
            sliderThumbStyle.overflow = new RectOffset(0, 0, 8, 0);
            sliderThumbStyle.fixedWidth = 20.0f;
            sliderThumbStyle.fixedHeight = 12.0f;

            // setup GUI resizer - only for the demo
            GUIResizer.Init(800, 500);

            // Some example commands below
            //			map.ToggleCountrySurface("Brazil", true, Color.green);
            //			map.ToggleCountrySurface(35, true, Color.green);
            //			map.ToggleCountrySurface(33, true, Color.green);
            //			map.FlyToCountry(33);
            //			map.FlyToCountry("Brazil");
            //			map.navigationTime = 0; // jump instantly to next country
            //			map.FlyToCountry ("India");

            /* Register events: this is optionally but allows your scripts to be informed instantly as the mouse enters or exits a country, province or city */
            map.OnCityEnter += (int cityIndex) => Debug.Log("Entered city " + map.cities[cityIndex].name);
            map.OnCityExit += (int cityIndex) => Debug.Log("Exited city " + map.cities[cityIndex].name);
            map.OnCityPointerDown += (int cityIndex) => Debug.Log("Pointer down on city " + map.cities[cityIndex].name);
            map.OnCityClick += (int cityIndex) => Debug.Log("Clicked city " + map.cities[cityIndex].name);
            map.OnCityPointerUp += (int cityIndex) => Debug.Log("Pointer up on city " + map.cities[cityIndex].name);

            map.OnCountryEnter += (int countryIndex, int regionIndex) => Debug.Log("Entered country (" + countryIndex + ") " + map.countries[countryIndex].name);
            map.OnCountryExit += (int countryIndex, int r1024egionIndex) => Debug.Log("Exited country " + map.countries[countryIndex].name);
            map.OnCountryPointerDown += (int countryIndex, int regionIndex) => Debug.Log("Pointer down on country " + map.countries[countryIndex].name);
            map.OnCountryClick += (int countryIndex, int regionIndex) => Debug.Log("Clicked country " + map.countries[countryIndex].name);
            map.OnCountryPointerUp += (int countryIndex, int regionIndex) => Debug.Log("Pointer up on country " + map.countries[countryIndex].name);

            map.OnProvinceEnter += (int provinceIndex, int regionIndex) => Debug.Log("Entered province (" + provinceIndex + ") " + map.provinces[provinceIndex].name);
            map.OnProvinceExit += (int provinceIndex, int regionIndex) => Debug.Log("Exited province " + map.provinces[provinceIndex].name);
            map.OnProvincePointerDown += (int provinceIndex, int regionIndex) => Debug.Log("Pointer down on province " + map.provinces[provinceIndex].name);
            map.OnProvinceClick += (int provinceIndex, int regionIndex) => Debug.Log("Clicked province " + map.provinces[provinceIndex].name);
            map.OnProvincePointerUp += (int provinceIndex, int regionIndex) => Debug.Log("Pointer up on province " + map.provinces[provinceIndex].name);

            map.OnClick += (sphereLocation, mouseButtonIndex) => {
                Vector2 latLon = Conversion.GetLatLonFromSpherePoint(sphereLocation);
                Debug.Log("Clicked on Latitude: " + latLon.x + ", Longitude: " + latLon.y);
            };

        }


        bool avoidGUI;
        // press SPACE during gameplay to hide GUI

        void OnGUI() {
            if (avoidGUI)
                return;

            // Do autoresizing of GUI layer
            GUIResizer.AutoResize();

            // Check whether a country or city is selected, then show a label
            if (map.mouseIsOver) {
                string text;
                Vector3 mousePos = Input.mousePosition;
                float x, y;
                if (map.countryHighlighted != null || map.cityHighlighted != null || map.provinceHighlighted != null) {
                    City city = map.cityHighlighted;
                    if (city != null) {
                        if (city.province != null && city.province.Length > 0) {
                            text = "City: " + map.cityHighlighted.name + " (" + city.province + ", " + map.countries[map.cityHighlighted.countryIndex].name + ")";
                        } else {
                            text = "City: " + map.cityHighlighted.name + " (" + map.countries[map.cityHighlighted.countryIndex].name + ")";
                        }
                    } else if (map.provinceHighlighted != null) {
                        text = map.provinceHighlighted.name + ", " + map.countryHighlighted.name;
                        List<Province> neighbours = map.ProvinceNeighboursOfCurrentRegion();
                        if (neighbours.Count > 0)
                            text += "\n" + EntityListToString<Province>(neighbours);
                    } else if (map.countryHighlighted != null) {
                        text = map.countryHighlighted.name + " (" + map.countryHighlighted.continent + ")";
                        List<Country> neighbours = map.CountryNeighboursOfCurrentRegion();
                        if (neighbours.Count > 0)
                            text += "\n" + EntityListToString<Country>(neighbours);
                    } else {
                        text = "";
                    }
                    x = GUIResizer.authoredScreenWidth * (mousePos.x / Screen.width);
                    y = GUIResizer.authoredScreenHeight - (GUIResizer.authoredScreenHeight * (mousePos.y / Screen.height)) - 20 * (Input.touchSupported ? 3 : 1); // slightly up for touch devices
                    GUI.Label(new Rect(x - 1, y - 1, 0, 10), text, labelStyleShadow);
                    GUI.Label(new Rect(x + 1, y + 2, 0, 10), text, labelStyleShadow);
                    GUI.Label(new Rect(x + 2, y + 3, 0, 10), text, labelStyleShadow);
                    GUI.Label(new Rect(x + 3, y + 4, 0, 10), text, labelStyleShadow);
                    GUI.Label(new Rect(x, y, 0, 10), text, labelStyle);
                }
                text = map.calc.prettyCurrentLatLon;
                x = GUIResizer.authoredScreenWidth / 2.0f;
                y = GUIResizer.authoredScreenHeight - 20;
                GUI.Label(new Rect(x, y, 0, 10), text, labelStyle);
            }

            // Assorted options to show/hide frontiers, cities, Earth and enable country highlighting
            map.showFrontiers = GUI.Toggle(new Rect(10, 20, 150, 30), map.showFrontiers, "Toggle Frontiers");
            map.showEarth = GUI.Toggle(new Rect(10, 50, 150, 30), map.showEarth, "Toggle Earth");
            map.showCities = GUI.Toggle(new Rect(10, 80, 150, 30), map.showCities, "Toggle Cities");
            map.showCountryNames = GUI.Toggle(new Rect(10, 110, 150, 30), map.showCountryNames, "Toggle Labels");
            map.showProvinces = GUI.Toggle(new Rect(10, 140, 170, 30), map.showProvinces, "Toggle Provinces");

            GUI.backgroundColor = new Color(0.1f, 0.1f, 0.3f, 0.5f);

            // Add button to toggle Earth texture
            if (GUI.Button(new Rect(10, 170, 160, 30), "  Change Earth style", buttonStyle)) {
                map.earthStyle = (EARTH_STYLE)(((int)map.earthStyle + 1) % 10);
            }

            // Add buttons to show the color picker and change colors for the frontiers or fill
            if (GUI.Button(new Rect(10, 210, 160, 30), "  Change Frontiers Color", buttonStyle)) {
                colorPicker.showPicker = true;
                changingFrontiersColor = true;
            }
            if (GUI.Button(new Rect(10, 250, 160, 30), "  Change Fill Color", buttonStyle)) {
                colorPicker.showPicker = true;
                changingFrontiersColor = false;
            }
            if (colorPicker.showPicker) {
                if (changingFrontiersColor) {
                    map.frontiersColor = colorPicker.setColor;
                } else {
                    map.fillColor = colorPicker.setColor;
                }
            }

            // Add a button which demonstrates the navigateTo functionality -- pass the name of a country
            // For a list of countries and their names, check map.Countries collection.
            if (GUI.Button(new Rect(10, 290, 180, 30), "  Fly to Australia (Country)", buttonStyle)) {
                FlyToCountry("Australia");
            }
            if (GUI.Button(new Rect(10, 325, 180, 30), "  Fly to Mexico (Country)", buttonStyle)) {
                FlyToCountry("Mexico");
            }
            if (GUI.Button(new Rect(10, 360, 180, 30), "  Fly to New York (City)", buttonStyle)) {
                FlyToCity("New York");
            }
            if (GUI.Button(new Rect(10, 395, 180, 30), "  Fly to Madrid (City)", buttonStyle)) {
                FlyToCity("Madrid");
            }

            // Slider to show the new set zoom level API in V4.1
            GUI.Button(new Rect(10, 430, 85, 30), "  Zoom Level", buttonStyle);
            float prevZoomLevel = zoomLevel;
            GUI.backgroundColor = Color.white;
            zoomLevel = GUI.HorizontalSlider(new Rect(100, 445, 80, 85), zoomLevel, 0, 1, sliderStyle, sliderThumbStyle);
            GUI.backgroundColor = new Color(0.1f, 0.1f, 0.3f, 0.95f);
            if (zoomLevel != prevZoomLevel) {
                map.SetZoomLevel(zoomLevel);
            }


            // Add a button to colorize countries
            if (GUI.Button(new Rect(GUIResizer.authoredScreenWidth - 190, 20, 180, 30), "  Colorize Europe", buttonStyle)) {
                map.FlyToCity("Brussels");
                for (int colorizeIndex = 0; colorizeIndex < map.countries.Length; colorizeIndex++) {
                    if (map.countries[colorizeIndex].continent.Equals("Europe")) {
                        Color color = new Color(UnityEngine.Random.Range(0.0f, 1.0f), UnityEngine.Random.Range(0.0f, 1.0f), UnityEngine.Random.Range(0.0f, 1.0f));
                        map.ToggleCountrySurface(map.countries[colorizeIndex].name, true, color);
                    }
                }
            }

            // Colorize random country and fly to it
            if (GUI.Button(new Rect(GUIResizer.authoredScreenWidth - 190, 60, 180, 30), "  Colorize Random", buttonStyle)) {
                map.FlyToCity("Brussels");
                int countryIndex = UnityEngine.Random.Range(0, map.countries.Length);
                Color color = new Color(UnityEngine.Random.Range(0.0f, 1.0f), UnityEngine.Random.Range(0.0f, 1.0f), UnityEngine.Random.Range(0.0f, 1.0f));
                map.ToggleCountrySurface(countryIndex, true, color);
                map.FlyToCountry(countryIndex);
            }

            // Button to clear colorized countries
            if (GUI.Button(new Rect(GUIResizer.authoredScreenWidth - 190, 100, 180, 30), "  Reset countries", buttonStyle)) {
                map.HideCountrySurfaces();
            }

            // Tickers sample
            if (GUI.Button(new Rect(GUIResizer.authoredScreenWidth - 190, 140, 180, 30), "  Tickers Sample", buttonStyle)) {
                TickerSample();
            }

            // Decorator sample
            if (GUI.Button(new Rect(GUIResizer.authoredScreenWidth - 190, 180, 180, 30), "  Texture Sample", buttonStyle)) {
                TextureSample();
            }

            // Moving the Earth sample
            if (GUI.Button(new Rect(GUIResizer.authoredScreenWidth - 190, 220, 180, 30), "  Toggle Minimize", buttonStyle)) {
                ToggleMinimize();
            }

            // Add marker sample (gameobject)
            if (GUI.Button(new Rect(GUIResizer.authoredScreenWidth - 190, 260, 180, 30), "  Add Marker (Object)", buttonStyle)) {
                AddMarkerGameObjectOnRandomCity();
            }

            // Add marker sample (gameobject)
            if (GUI.Button(new Rect(GUIResizer.authoredScreenWidth - 190, 300, 180, 30), "  Add Marker (Circle)", buttonStyle)) {
                AddMarkerCircleOnRandomPosition();
            }

            if (GUI.Button(new Rect(GUIResizer.authoredScreenWidth - 190, 340, 180, 30), "  Add Trajectories", buttonStyle)) {
                AddTrajectories(10);
            }

            if (GUI.Button(new Rect(GUIResizer.authoredScreenWidth - 190, 380, 180, 30), "  Locate Mount Point", buttonStyle)) {
                LocateMountPoint();
            }

            if (GUI.Button(new Rect(GUIResizer.authoredScreenWidth - 190, 420, 180, 30), "  Fire Rocket!", buttonStyle)) {
                FireRocket();
            }

            if (GUI.Button(new Rect(GUIResizer.authoredScreenWidth - 190, 460, 180, 30), "  Show States Names", buttonStyle)) {
                ShowStatesNames();
            }
        }


        void Update() {

            if (Input.GetKeyDown(KeyCode.G)) {
                avoidGUI = !avoidGUI;
            }

            // Animates the camera field of view (just a cool effect at the begining)
            if (animatingField) {
                if (Camera.main.fieldOfView > 60) {
                    Camera.main.fieldOfView -= (181.0f - Camera.main.fieldOfView) / (220.0f - Camera.main.fieldOfView);
                } else {
                    Camera.main.fieldOfView = 60;
                    animatingField = false;
                }
            }

            if (Input.GetKeyDown(KeyCode.C)) {

                // Get a destination
                Vector3 destination = map.GetCountry("Spain").localPosition;

                // Modify zoom level to take into account zoomMin and zoomMaxDistance

                // compute zoom level based on altitude
                float altitudeInMeters = 1000f;
                const float EARTH_RADIUS_KM = 6371f;
                float radius = map.transform.localScale.x * 0.5f;

                float distanceToSurfaceWS = radius * (((altitudeInMeters + EARTH_RADIUS_KM) / EARTH_RADIUS_KM) - 1f);
                float maxDistance = map.GetZoomLevelDistance(1f);
                float zoomLevel = (distanceToSurfaceWS - map.zoomMinDistance) / (maxDistance - map.zoomMinDistance);
                zoomLevel = Mathf.Clamp01(zoomLevel);

                // Fly!
                map.FlyToLocation(destination, 2f, zoomLevel);

            }
        }

        string EntityListToString<T>(List<T> entities) {
            StringBuilder sb = new StringBuilder("Neighbours: ");
            for (int k = 0; k < entities.Count; k++) {
                if (k > 0) {
                    sb.Append(", ");
                }
                sb.Append(((IAdminEntity)entities[k]).name);
            }
            return sb.ToString();
        }


        // Sample code to show how to:
        // 1.- Navigate and center a country in the map
        // 2.- Add a blink effect to one country (can be used on any number of countries)
        void FlyToCountry(string countryName) {
            int countryIndex = map.GetCountryIndex(countryName);
            float zoomLevel = map.GetCountryMainRegionZoomExtents(countryIndex);
            map.FlyToCountry(countryIndex, 2f, zoomLevel, 0.5f);
            map.BlinkCountry(countryIndex, Color.black, Color.green, 4, 2.5f, true);
        }

        // Sample code to show how to navigate to a city:
        void FlyToCity(string cityName) {
            int cityIndex = map.GetCityIndex(cityName);
            map.FlyToCity(cityIndex, 2f, 0.2f, 0.5f);
        }


        // Sample code to show how tickers work
        void TickerSample() {
            map.ticker.ResetTickerBands();

            // Configure 1st ticker band: a red band in the northern hemisphere
            TickerBand tickerBand = map.ticker.tickerBands[0];
            tickerBand.verticalOffset = 0.2f;
            tickerBand.backgroundColor = new Color(1, 0, 0, 0.9f);
            tickerBand.scrollSpeed = 0; // static band
            tickerBand.visible = true;
            tickerBand.autoHide = true;

            // Prepare a static, blinking, text for the red band
            TickerText tickerText = new TickerText(0, "WARNING!!");
            tickerText.textColor = Color.yellow;
            tickerText.blinkInterval = 0.2f;
            tickerText.horizontalOffset = 0.1f;
            tickerText.duration = 10.0f;

            // Draw it!
            map.ticker.AddTickerText(tickerText);

            // Configure second ticker band (below the red band)
            tickerBand = map.ticker.tickerBands[1];
            tickerBand.verticalOffset = 0.1f;
            tickerBand.verticalSize = 0.05f;
            tickerBand.backgroundColor = new Color(0, 0, 1, 0.9f);
            tickerBand.visible = true;
            tickerBand.autoHide = true;

            // Prepare a ticker text
            tickerText = new TickerText(1, "INCOMING MISSILE!!");
            tickerText.textColor = Color.white;

            // Draw it!
            map.ticker.AddTickerText(tickerText);
        }

        // Sample code to show how to use decorators to assign a texsture
        void TextureSample() {
            // 1st way (best): assign a flag texture to USA using direct API - this texture will get cleared when you call HideCountrySurfaces()
            Texture2D texture = Resources.Load<Texture2D>("flagUSA");
            int countryIndex = map.GetCountryIndex("United States of America");
            map.ToggleCountrySurface(countryIndex, true, Color.white, texture);

            // 2nd way: assign a flag texture to Brazil using decorator - the texture will stay when you call HideCountrySurfaces()
            string countryName = "Brazil";
            CountryDecorator decorator = new CountryDecorator();
            decorator.isColorized = true;
            decorator.texture = Resources.Load<Texture2D>("flagBrazil");
            decorator.textureOffset = Misc.Vector2down * 2.4f;
            map.decorator.SetCountryDecorator(0, countryName, decorator);

            Debug.Log("USA flag added with direct API.");
            Debug.Log("Brazil flag added with decorator (persistent texture).");

            map.FlyToCountry("Panama", 2f);
        }




        // The globe can be moved and scaled at wish
        void ToggleMinimize() {
            minimizeState = !minimizeState;

            Camera.main.transform.position = Vector3.back * 1.1f;
            Camera.main.transform.rotation = Misc.QuaternionZero; // Quaternion.Euler (Misc.Vector3zero);
            if (minimizeState) {
                map.gameObject.transform.localScale = Misc.Vector3one * 0.20f;
                map.gameObject.transform.localPosition = new Vector3(0.0f, -0.5f, 0);
                map.allowUserZoom = false;
                map.earthStyle = EARTH_STYLE.Alternate2;
                map.earthColor = Color.black;
                map.longitudeStepping = 4;
                map.latitudeStepping = 40;
                map.showFrontiers = false;
                map.showCities = false;
                map.showCountryNames = false;
                map.gridLinesColor = new Color(0.06f, 0.23f, 0.398f);
            } else {
                map.gameObject.transform.localScale = Misc.Vector3one;
                map.gameObject.transform.localPosition = Misc.Vector3zero;
                map.allowUserZoom = true;
                map.earthStyle = EARTH_STYLE.Natural;
                map.longitudeStepping = 15;
                map.latitudeStepping = 15;
                map.showFrontiers = true;
                map.showCities = true;
                map.showCountryNames = true;
                map.gridLinesColor = new Color(0.16f, 0.33f, 0.498f);
            }
        }


        /// <summary>
        /// Illustrates how to add custom markers over the globe using the AddMarker API.
        /// In this example a building prefab is added to a random city (see comments for other options).
        /// </summary>
        void AddMarkerGameObjectOnRandomCity() {

            // Every marker is put on a spherical-coordinate (assuming a radius = 0.5 and relative center at zero position)
            Vector3 sphereLocation;

            // Add a marker on a random city
            City city = map.cities[Random.Range(0, map.cities.Count)];
            sphereLocation = city.localPosition;

            // or... choose a city by its name:
            //		int cityIndex = map.GetCityIndex("Moscow");
            //		sphereLocation = map.cities[cityIndex].unitySphereLocation;

            // or... use the centroid of a country
            //		int countryIndex = map.GetCountryIndex("Greece");
            //		sphereLocation = map.countries[countryIndex].center;

            // or... use a custom location lat/lon. Example put the building over New York:
            //		map.calc.fromLatDec = 40.71f;	// 40.71 decimal degrees north
            //		map.calc.fromLonDec = -74.00f;	// 74.00 decimal degrees to the west
            //		map.calc.fromUnit = UNIT_TYPE.DecimalDegrees;
            //		map.calc.Convert();
            //		sphereLocation = map.calc.toSphereLocation;

            // Send the prefab to the AddMarker API setting a scale of 0.02f (this depends on your marker scales)
            GameObject building = Instantiate(Resources.Load<GameObject>("Building/Building"));

            map.AddMarker(building, sphereLocation, 0.02f);

            // Fly to the destination and see the building created
            map.FlyToLocation(sphereLocation);

            // Optionally add a blinking effect to the marker
            MarkerBlinker.AddTo(building, 4, 0.2f);
        }

        void AddMarkerCircleOnRandomPosition() {
            // Draw a beveled circle
            Vector3 sphereLocation = Random.onUnitSphere * 0.5f;
            float km = Random.value * 500 + 500; // Circle with a radius of (500...1000) km

            //			sphereLocation = map.cities[map.GetCityIndex("Paris")].unitySphereLocation;
            //			km = 1053;
            //			sphereLocation = map.cities[map.GetCityIndex("New York")].unitySphereLocation;
            //			km = 500;
            map.AddMarker(MARKER_TYPE.CIRCLE_PROJECTED, sphereLocation, km, 0.975f, 1.0f, new Color(0.85f, 0.45f, 0.85f, 0.9f));
            map.AddMarker(MARKER_TYPE.CIRCLE_PROJECTED, sphereLocation, km, 0, 0.975f, new Color(0.5f, 0, 0.5f, 0.9f));
            map.FlyToLocation(sphereLocation);
        }


        /// <summary>
        /// Example of how to add custom lines to the map
        /// Similar to the AddMarker functionality, you need two spherical coordinates and then call AddLine
        /// </summary>
        void AddTrajectories(int numberOfLines) {

            // In this example we will add random lines from a group of cities to another cities (see AddMaker example above for other options to get locations)
            for (int line = 0; line < numberOfLines; line++) {
                // Get two random cities
                int city1 = Random.Range(0, map.cities.Count);
                int city2 = Random.Range(0, map.cities.Count);

                // Get their sphere-coordinates
                Vector3 start = map.cities[city1].localPosition;
                Vector3 end = map.cities[city2].localPosition;

                // Add lines with random color, speeds and elevation
                Color color = new Color(Random.Range(0.5f, 1), Random.Range(0.5f, 1), Random.Range(0.5f, 1));
                float elevation = Random.Range(0, 0.5f);    // elevation is % relative to the Earth radius
                float drawingDuration = 4.0f;
                float lineWidth = 0.005f;
                float fadeAfter = 2.0f; // line stays for 2 seconds, then fades out - set this to zero to avoid line removal
                map.AddLine(start, end, color, elevation, drawingDuration, lineWidth, fadeAfter);
            }
        }


        /// <summary>
        /// Mount points are special locations on the map defined by user in the Map Editor.
        /// </summary>
        void LocateMountPoint() {
            int mountPointsCount = map.mountPoints.Count;
            Debug.Log("There're " + map.mountPoints.Count + " mount point(s). You can define more mount points using the Map Editor. Mount points are stored in mountPoints.txt file inside Resources/Geodata folder.");
            if (mountPointsCount > 0) {
                Debug.Log("Locating random mount point...");
                int mp = UnityEngine.Random.Range(0, mountPointsCount - 1);
                Vector3 location = map.mountPoints[mp].localPosition;
                map.FlyToLocation(location);
            }
        }

        void ShowStatesNames() {
            // First we ensure only states for USA are shown
            int countryUSAIndex = map.GetCountryIndex("United States of America");
            for (int k = 0; k < map.countries.Length; k++) {
                if (k != countryUSAIndex) {
                    map.countries[k].allowShowProvinces = false;
                }
            }
            map.showProvinces = true;
            map.drawAllProvinces = true;

            // Now, hide all country names and show states for USA
            map.showCountryNames = false;
            Country usaCountry = map.countries[countryUSAIndex];
            for (int p = 0; p < usaCountry.provinces.Length; p++) {
                Province state = usaCountry.provinces[p];
                Color color = new Color(Random.value, Random.value, Random.value);
                map.AddText(state.name, state.localPosition, color);
            }

            map.FlyToCountry(usaCountry);
        }

        #region Bullet shooting!

        /// <summary>
        /// Creates a rocket on current map position and launch it over a random position on the globe following an arc
        /// </summary>
        void FireRocket() {

            GameObject rocket = Instantiate(rocketPrefab);
            rocket.GetComponentInChildren<Renderer>().material.color = Color.yellow;

            // Choose starting pos
            Vector3 startPos = map.GetCurrentMapLocation();

            // Get a random target city
            int randomCity = Random.Range(0, map.cities.Count);
            Vector3 endPos = map.cities[randomCity].localPosition;

            // Fire the bullet!
            StartCoroutine(AnimateMissile(rocket, 0.005f, startPos, endPos));
        }

        IEnumerator AnimateMissile(GameObject missile, float scale, Vector3 startPos, Vector3 endPos, float duration = 3f, float arc = 0.25f) {

            // Optional: Draw the trajectory
            map.AddLine(startPos, endPos, Color.white, arc, duration,  lineWidth: 0.002f, fadeOutAfter: 0.1f);

            // Optional: Follow the bullet
            map.FlyToLocation(endPos, duration);

            // Animate loop for moving bullet over time
            float bulletFireTime = Time.time;
            float elapsed = Time.time - bulletFireTime;
            Vector3 prevPos = map.transform.position;
            while (elapsed < duration) {
                float t = elapsed / duration;
                Vector3 pos = Vector3.Lerp(startPos, endPos, t).normalized * 0.5f;
                float altitude = Mathf.Sin(t * Mathf.PI) * arc / scale;
                map.AddMarker(missile, pos, scale, true, altitude);

                Vector3 wpos = map.transform.TransformPoint(pos);
                if (elapsed > 0) {
                    Vector3 axis = (wpos - prevPos).normalized;
                    missile.transform.forward = axis;
                }
                prevPos = wpos;

                yield return new WaitForFixedUpdate();
                elapsed = Time.time - bulletFireTime;
            }

            Destroy(missile);

        }


        #endregion

    }

}