Example #1
0
        public async Task Reload()
        {
            DistrictWiseCummilativeCases = await GetDistrictWiseCummilativeCasesAsync();

            StateWideCummilativeCases = await GetStateWideCummilativeCasesAsync();

            ConfirmedCasesPerDay = await GetStateWideDailyCasesAsync();

            DistrictWiseDistributionOfConfirmedCases = await GetDistrictWiseDistribution();

            TotalTestsDonePerDay = await GetTotalCasesDonePerDayAsync();

            TestStats = await GetTestStatsAsync();

            NumberOfDaysForMajorMilestones = await GetNumberOfDaysForMajorMilestonesAsync();

            TotalConfirmedCases = await GetTotalConfirmedCase();

            TotalActiveCases = await GetTotalActiveCases();

            TotalFatalCases = await GetTotalFatalCases();

            RecoveryRate = await GetRecoveryRate();

            RaisePropertyChangedEventForTileProperties();
        }
Example #2
0
        public void SaveTileMatrix(TileType[,] map, string path)
        {
            IList <TileRecord> records = new List <TileRecord>();

            int cols = map.GetLength(0);
            int rows = map.GetLength(1);

            for (int x = 0; x < cols; x++)
            {
                for (int y = 0; y < rows; y++)
                {
                    TileType   type   = map[x, y];
                    TileRecord record = Mapper.Map <TileType, TileRecord>(type);

                    record.X = x;
                    record.Y = y;
                    records.Add(record);
                }
            }

            if (File.Exists(path))
            {
                File.Delete(path);
            }

            using (Stream stream = File.OpenWrite(path))
                using (TextWriter textWriter = new StreamWriter(stream))
                    using (CsvWriter csvWriter = new CsvWriter(textWriter))
                    {
                        foreach (TileRecord record in records)
                        {
                            csvWriter.WriteRecord(record);
                        }
                    }
        }
        public void QueueAdd(TileCoord coord, TileStack stack)
        {
            if (stack != null)
            {
                TileStack srcStack = null;
                if (_tileSource.InRange(coord))
                {
                    srcStack = new TileStack(_tileSource[coord]);
                }

                TileStack newStack = new TileStack(srcStack);
                foreach (Tile t in stack)
                {
                    newStack.Add(t);
                }

                if (_tiles.ContainsKey(coord))
                {
                    _tiles[coord] = new TileRecord(_tiles[coord].Original, stack);
                }
                else
                {
                    _tiles[coord] = new TileRecord(srcStack, newStack);
                }
            }
        }
        public void QueueReplacement(TileCoord coord, Tile replacement)
        {
            TileStack srcStack = null;

            if (_tileSource.InRange(coord))
            {
                srcStack = new TileStack(_tileSource[coord]);
            }

            TileStack stack = null;

            if (replacement != null)
            {
                stack = new TileStack();
                stack.Add(replacement);
            }

            if (_tiles.ContainsKey(coord))
            {
                _tiles[coord] = new TileRecord(_tiles[coord].Original, stack);
            }
            else
            {
                _tiles[coord] = new TileRecord(srcStack, stack);
            }
        }
        public void QueueAdd(TileCoord coord, Tile tile)
        {
            if (tile != null) {
                TileStack srcStack = null;
                if (_tileSource.InRange(coord))
                    srcStack = new TileStack(_tileSource[coord]);

                TileStack stack = new TileStack(srcStack);
                stack.Add(tile);

                if (_tiles.ContainsKey(coord))
                    _tiles[coord] = new TileRecord(_tiles[coord].Original, stack);
                else
                    _tiles[coord] = new TileRecord(srcStack, stack);
            }
        }
        public void QueueReplacement(TileCoord coord, TileStack replacement)
        {
            TileStack srcStack = null;

            if (_tileSource.InRange(coord))
            {
                srcStack = new TileStack(_tileSource[coord]);
            }

            replacement = (replacement != null) ? new TileStack(replacement) : null;

            if (_tiles.ContainsKey(coord))
            {
                _tiles[coord] = new TileRecord(_tiles[coord].Original, replacement);
            }
            else
            {
                _tiles[coord] = new TileRecord(srcStack, replacement);
            }
        }
        public void QueueRemove(TileCoord coord, Tile tile)
        {
            if (tile != null)
            {
                TileStack srcStack = null;
                if (_tileSource.InRange(coord))
                {
                    srcStack = new TileStack(_tileSource[coord]);
                }

                TileStack stack = new TileStack(srcStack);
                stack.Remove(tile);

                if (_tiles.ContainsKey(coord))
                {
                    _tiles[coord] = new TileRecord(_tiles[coord].Original, stack);
                }
                else
                {
                    _tiles[coord] = new TileRecord(srcStack, stack);
                }
            }
        }
        public void QueueReplacement(TileCoord coord, TileStack replacement)
        {
            TileStack srcStack = null;
            if (_tileSource.InRange(coord))
                srcStack = new TileStack(_tileSource[coord]);

            replacement = (replacement != null) ? new TileStack(replacement) : null;

            if (_tiles.ContainsKey(coord))
                _tiles[coord] = new TileRecord(_tiles[coord].Original, replacement);
            else
                _tiles[coord] = new TileRecord(srcStack, replacement);
        }
        public void QueueReplacement(TileCoord coord, Tile replacement)
        {
            TileStack srcStack = null;
            if (_tileSource.InRange(coord))
                srcStack = new TileStack(_tileSource[coord]);

            TileStack stack = null;
            if (replacement != null) {
                stack = new TileStack();
                stack.Add(replacement);
            }

            if (_tiles.ContainsKey(coord))
                _tiles[coord] = new TileRecord(_tiles[coord].Original, stack);
            else
                _tiles[coord] = new TileRecord(srcStack, stack);
        }
	void SpawnTheRoom(string roomName, int x, int y)
	{

		foreach(GameObject grid in allGrids)
		{
			if(grid.name == roomName)
			{
				GameObject obj = Instantiate(grid , TilePos(x, y), Quaternion.identity) as GameObject;
				obj.name = roomName;
				obj.transform.SetParent(emptyWorldHolder.transform);

				if(obj.name == "ELEVATOR ROOM")
				{
					roomName = "NSEW XXX";
				}

				//TODO: spawn a fog of war black cover to every room. Layer Aerial -1, with a collider to turn off when you're in the room
				TileRecord record = new TileRecord();
				record.coords = x + "," + y;
				record.name = roomName;
				record.gridObject = obj;
				firstTileRecords.Add (record);
				break;
			}
		}
	}
	void StepSix()
	{
		//decorate the rooms and redo pathfinding

		//then populate all other rooms
		foreach(TileRecord tile in goodTileRecords)
		{
			if(tile.name.ToCharArray()[0].ToString() == "R")
			{
				int rotation = Random.Range(0,4) * 90;
				GameObject prefab = Instantiate(allFurniture[Random.Range(0, allFurniture.Length)],
				            tile.gridObject.transform.position, Quaternion.Euler(0,0, rotation))as GameObject;
				prefab.transform.SetParent(tile.gridObject.transform);
				tile.furniture = prefab;

				if(tile.name != "NSEW XXX")
					roomTiles.Add(tile);
			}
		}
		//Spawn Security Room

		secRoom = roomTiles [Random.Range (0, roomTiles.Count)];
		Destroy (secRoom.furniture);
		int rot = Random.Range(0,4) * 90;
		GameObject pref = Instantiate(securityRoomPrefab, secRoom.gridObject.transform.position, Quaternion.Euler(0,0, rot))as GameObject;
		pref.transform.SetParent(secRoom.gridObject.transform);
		secRoom.furniture = pref;

		//lastly scan it all into the world pathfinding
		Invoke ("StepSeven", 0.21f);
	}