Exemplo n.º 1
0
        public void ComputePath()
        {
            if (latLon == null)
            {
                errorHandler.ReportError("Latlon missing", ErrorState.close_window);
                return;
            }
            try
            {
                // Compute path length
                int steps = latLon.Count;
                stepLengths = new float[steps];

                // Calculate total travel length
                totalLength = 0;
                for (int k = 0; k < steps - 1; k++)
                {
                    stepLengths[k] = worldMapGlobe.calc.Distance(latLon[k], latLon[k + 1]);
                    totalLength   += stepLengths[k];
                }

                Debug.Log("Total path length = " + totalLength / 1000 + " km.");
            }
            catch (System.Exception ex)
            {
                errorHandler.CatchException(ex, ErrorState.close_window);
            }
        }
        void Start()
        {
            gameManager  = interfaceFactory.GameManager;
            globeManager = interfaceFactory.GlobeManager;
            uiManager    = interfaceFactory.UIManager;
            errorHandler = interfaceFactory.ErrorHandler;
            if (gameManager == null || globeManager == null || uiManager == null || errorHandler == null)
            {
                gameObject.SetActive(false);
            }
            else
            {
                if (componentMissing)
                {
                    errorHandler.ReportError("Mouse Cell Enterer missing component", ErrorState.restart_scene);
                }

                worldMapGlobe = globeManager.WorldMapGlobe;
                if (worldMapGlobe == null)
                {
                    errorHandler.ReportError("World Map Globe missing", ErrorState.restart_scene);
                }

                try
                {
                    globeManager.WorldMapGlobe.OnCellEnter += HandleOnCellEnter;
                }
                catch (System.Exception ex)
                {
                    errorHandler.CatchException(ex, ErrorState.restart_scene);
                }
            }
        }
Exemplo n.º 3
0
        public List <Country>[] GetCountriesInRange(Cell startCell, int range)
        {
            if (range < 0 || startCell.index < 0 || worldMapGlobe.cells.Count() < startCell.index)
            {
                errorHandler.ReportError("Invalid input for GetCountriesInRange", ErrorState.close_window);
                return(null);
            }

            List <Country>[] countries      = new List <Country> [range + 1]; //provinces is an array of lists with each list containing
            List <Country>   foundCountries = new List <Country>();           //the provinces that can be reached at that distance.

            List <Province>[] provinces = provinceParser.GetProvincesInRange(startCell, range);
            if (provinces == null)
            {
                errorHandler.ReportError("Failed to parse provinces", ErrorState.close_window);
                return(null);
            }

            try
            {
                //Create lists of the countries within range based off of the provinces in range
                int i = 0;
                //Province province;
                foreach (List <Country> countryList in countries)
                {
                    foreach (Province province in provinces[i])
                    {
                        Country country = worldMapGlobe.countries[province.countryIndex];
                        if (!foundCountries.Contains(country))
                        {
                            foundCountries.Add(country);
                            countries[i].Add(country);
                        }
                    }
                    i++;
                }
            }
            catch (System.Exception ex)
            {
                errorHandler.CatchException(ex, ErrorState.close_window);
            }

            return(countries);
        }
Exemplo n.º 4
0
        public List <Landmark> GetLandmarksInCell(Cell cell)
        {
            List <Landmark> landmarks = new List <Landmark>();

            try
            {
                foreach (MappableObject mappableObject in cell.occupants)
                {
                    if (mappableObject is Landmark)
                    {
                        Landmark castedLandmark = mappableObject as Landmark;
                        landmarks.Add(castedLandmark);
                    }
                }
            }
            catch (System.Exception ex)
            {
                errorHandler.CatchException(ex, ErrorState.close_window);
                return(null);
            }
            return(landmarks);
        }
Exemplo n.º 5
0
        /// <summary>
        /// Check if a given location is a correct drop off location given a desired province
        /// </summary>
        /// <param name="dropOffCell"> The cell drop off cell </param>
        /// <param name="provinceDestination"> The desired province destination </param>
        private bool AttemptProvinceDropOff(Cell dropOffCell, Province provinceDestination)
        {
            bool dropOffSuccess = false;

            if (provinceDestination == null)
            {
                errorHandler.ReportError("Drop Off Failed: Province destination not set", ErrorState.close_window);
                return(false);
            }

            List <Province> selectedProvinces = provinceParser.GetProvicesInCell(dropOffCell);

            if (selectedProvinces == null)
            {
                errorHandler.ReportError("Drop Off Failed: No provinces in cell", ErrorState.close_window);
                return(false);
            }

            foreach (Province province in selectedProvinces)
            {
                try
                {
                    if (province == provinceDestination)
                    {
                        dropOffSuccess = true;
                        break;
                    }
                }
                catch (System.Exception ex)
                {
                    errorHandler.CatchException(ex, ErrorState.close_window);
                    return(false);
                }
            }

            return(dropOffSuccess);
        }
Exemplo n.º 6
0
        /// <summary>
        /// Called when a tourist needs to be generated and added to the palyer's inventory
        /// </summary>
        public void GenerateTourist()
        {
            //Get Player Character
            IPlayerCharacter playerCharacter = playerManager.PlayerCharacter;

            if (playerCharacter == null)
            {
                errorHandler.ReportError("Player character missing", ErrorState.restart_scene);
                return;
            }
            //Intantiate tourist
            GameObject touristObject = Instantiate(touristPrefab, new Vector3(0, 0, 0), Quaternion.identity);

            touristObject.transform.parent = inventoryUI.UIObject.transform;
            IInventoryTourist tourist = touristObject.GetComponent(typeof(IInventoryTourist)) as IInventoryTourist;

            if (tourist == null)
            {
                errorHandler.ReportError("Tourist component of tourist prefab missing", ErrorState.restart_scene);
                return;
            }
            //Give tourist its image
            tourist.InventoryIcon = Resources.Load <Sprite>(touristImageFiles[touristImageIndex]);
            touristImageIndex++;
            if (touristImageIndex >= NUMBER_OF_TOURIST_IMAGES)
            {
                touristImageIndex = 0;
            }
            //Add tourist to player's inventory
            playerCharacter.Inventory.AddItem(tourist, 0);
            //Check if a region switch is needed
            touristsInCurrentRegion++;
            int rand = Random.Range(MIN_TIME_IN_REGION, MAX_TIME_IN_REGION);

            if (touristsInCurrentRegion >= rand)
            {
                //Switch regions
                try
                {
                    int newRegionNeighbourIndex = Random.Range(0, CurrentRegion.neighbouringRegions.Count - 1);
                    CurrentRegion           = CurrentRegion.neighbouringRegions[newRegionNeighbourIndex];
                    touristsInCurrentRegion = 0;
                }
                catch (System.Exception ex)
                {
                    errorHandler.CatchException(ex, ErrorState.restart_scene);
                }
            }
        }
        /// <summary>
        /// Set the terrain costs of all the cells that are reachable by the player
        /// </summary>
        public void SetCellCosts()
        {
            if (CellsInRange == null)
            {
                errorHandler.ReportError("Cells in range empty", ErrorState.restart_scene);
                return;
            }
            foreach (Cell cell in CellsInRange[0])
            {
                try
                {
                    //Get Climate From Cell
                    int      provinceIndex    = worldMapGlobe.GetProvinceNearPoint(cell.sphereCenter);
                    Province province         = worldMapGlobe.provinces[provinceIndex];
                    string   climateAttribute = province.attrib["ClimateGroup"];

                    //Loop Through Each Neighbor and Set the Cost from the Neighbor to the Cell
                    if (climateAttribute != "")
                    {
                        bool cellOccupied = false;
                        //Check if cell is occupied by something other than the player
                        if (cell.occupants.Any() && !cell.occupants.Contains(playerCharacter))
                        {
                            cellOccupied = true;
                        }
                        int cost = playerCharacter.ClimateCosts[climateAttribute];
                        if (cost == IMPASSABLE || cellOccupied)
                        {
                            worldMapGlobe.SetCellCanCross(cell.index, false);
                        }
                        else
                        {
                            worldMapGlobe.SetCellCanCross(cell.index, true);
                            foreach (Cell neighbour in worldMapGlobe.GetCellNeighbours(cell.index))
                            {
                                worldMapGlobe.SetCellNeighbourCost(neighbour.index, cell.index, cost, false);
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    errorHandler.CatchException(ex, ErrorState.close_window);
                }
            }
        }
Exemplo n.º 8
0
        /// <summary>
        /// Merge a neighboring province into a given province
        /// </summary>
        /// <param name="mainProvince"> The province absorbing its neighbor </param>
        /// <param name="neighbor"> The province being absorbed </param>
        private void MergeProvinces(Province mainProvince, Province neighbor)
        {
            try
            {
                int provinceIndex = worldMapGlobe.GetProvinceIndex(mainProvince.countryIndex, mainProvince.name);

                //Merge provinces
                worldMapGlobe.ProvinceTransferProvinceRegion(provinceIndex, neighbor.mainRegion, true);
                //Clear unused attributes
                //if (!loadedMapSettings.provinces)
                //    neighbor.attrib["PoliticalProvince"] = "";
                //if (!loadedMapSettings.terrain)
                neighbor.attrib["Terrain"] = "";
                //if (!loadedMapSettings.climate)
                neighbor.attrib["Climate"] = "";
            }
            catch (System.Exception ex)
            {
                errorHandler.CatchException(ex, ErrorState.close_window);
            }
        }
 void Start()
 {
     gameManager  = interfaceFactory.GameManager;
     globeManager = interfaceFactory.GlobeManager;
     uiManager    = interfaceFactory.UIManager;
     errorHandler = interfaceFactory.ErrorHandler;
     if (gameManager == null || globeManager == null || uiManager == null || errorHandler == null)
     {
         gameObject.SetActive(false);
     }
     else
     {
         try
         {
             globeManager.WorldMapGlobe.OnCellClick += HandleOnCellClick;
         }
         catch (System.Exception ex)
         {
             errorHandler.CatchException(ex, ErrorState.restart_scene);
         }
     }
 }
Exemplo n.º 10
0
        public List <Province> GetProvicesInCell(Cell cell)
        {
            List <Province> foundProvinces   = new List <Province>();
            List <Province> checkedProvinces = new List <Province>();
            int             provinceIndex;

            try
            {
                //Create a list of points including each vertex of the cell and its center point
                List <Vector3> cellPoints = cell.vertices.ToList();
                cellPoints.Add(cell.sphereCenter);

                foreach (Vector3 cellPoint in cellPoints)
                {
                    provinceIndex = worldMapGlobe.GetProvinceIndex(cellPoint);
                    //Check if cell point is on a province
                    if (provinceIndex == -1)
                    {
                        //Get closest province to point if it is not centered on one
                        provinceIndex = worldMapGlobe.GetProvinceNearPoint(cellPoint);
                    }
                    //Add the province, if it is not already in the province list
                    Province province = worldMapGlobe.provinces[provinceIndex];
                    if (!foundProvinces.Contains(province))
                    {
                        foundProvinces.Add(province);
                    }

                    //Check to see if neighbours of province overlap with cell
                    List <Province> provinceNeighbours = worldMapGlobe.ProvinceNeighbours(provinceIndex);
                    bool            provinceOverlaps;
                    foreach (Province neighbor in provinceNeighbours)
                    {
                        //countryIndex = neighbor.countryIndex;
                        //neighborIndex = worldMapGlobe.GetProvinceIndex(countryIndex, neighbor.name);

                        //Make sure you haven't already checked the province, this saves time
                        if (!checkedProvinces.Contains(neighbor))
                        {
                            checkedProvinces.Add(neighbor);
                            provinceOverlaps = false;

                            foreach (Region region in neighbor.regions)
                            {
                                foreach (Vector3 spherePoint in region.spherePoints)
                                {
                                    if (worldMapGlobe.GetCellIndex(spherePoint) == cell.index)
                                    {
                                        provinceOverlaps = true;
                                        break;
                                    }
                                }
                                if (provinceOverlaps)
                                {
                                    break;
                                }
                            }
                            if (provinceOverlaps && !foundProvinces.Contains(province))
                            {
                                foundProvinces.Add(neighbor);
                            }
                        }
                    }
                }
            }
            catch (System.Exception ex)
            {
                errorHandler.CatchException(ex, ErrorState.close_window);
                return(null);
            }

            return(foundProvinces);
        }