public async void Run(IBackgroundTaskInstance taskInstance)
{
var deferral = taskInstance.GetDeferral();
await TileUpdate.Update();
deferral.Complete();
}
public void ChangeRoadTheme(ICity city, string oldTheme, string newTheme)
{
var updates = new Dictionary <ushort, List <TileUpdate> >();
var oldThemeIndex = ThemeRoadIndexes[oldTheme];
var newThemeIndex = ThemeRoadIndexes[newTheme];
foreach (var position in tileLocator.ForeachTile(city.PrimaryPosition.X, city.PrimaryPosition.Y, city.Radius))
{
var tileType = regionManager.GetTileType(position.X, position.Y);
if (!IsRoad(tileType))
{
continue;
}
var newRoadType = (ushort)(tileType - oldThemeIndex + newThemeIndex);
regionManager.SetTileType(position.X, position.Y, newRoadType, false);
var regionId = regionLocator.GetRegionIndex(position.X, position.Y);
var update = new TileUpdate(position.X, position.Y, newRoadType);
List <TileUpdate> list;
if (!updates.TryGetValue(regionId, out list))
{
list = new List <TileUpdate> {
update
};
updates.Add(regionId, list);
}
else
{
updates[regionId].Add(update);
}
}
SendUpdate(updates);
}
public void GetOldTile()
{
var oldTile = new Tile {
WallId = 1
};
var change = new TileUpdate(Vector.Zero, oldTile, new Tile());
Assert.That(change.OldTile, Is.EqualTo(oldTile));
}
public void GetNewTile()
{
var newTile = new Tile {
WallId = 1
};
var change = new TileUpdate(Vector.Zero, new Tile(), newTile);
Assert.That(change.NewTile, Is.EqualTo(newTile));
}
bool RuleCheck(bool Rule, TileUpdate Tile)
{
if (Tile == null)
{
return(false);
}
else
{
return(Rule == Tile.GetComponent <TileUpdate>().State());
}
}
void SafeNeighborAdd(TileUpdate Tile, TileUpdate.Neighbors Neighbor, int index, int endex)
{
if (index >= 0 && index < Width && endex >= 0 && endex < Height)
{
Tile.AssignTile(Neighbor, Tiles[index, endex]);
}
else
{
Tile.AssignTile(Neighbor, null);
}
}
public void Undo(int x, int y)
{
var position = new Vector(x, y);
var oldTile = new Tile {
WallId = 1
};
var change = new TileUpdate(position, oldTile, new Tile());
var extent = Mock.Of <Extent>(e => e.SetTile(position, It.IsAny <Tile>()));
Assert.That(change.Undo(extent));
Mock.Get(extent).Verify(e => e.SetTile(position, oldTile), Times.Once);
}
public void DestroyRoad(uint x, uint y, string themeId)
{
var tilePosition = new Position(x, y);
var tiles = new List <Position>(5)
{
tilePosition,
tilePosition.TopLeft(),
tilePosition.TopRight(),
tilePosition.BottomLeft(),
tilePosition.BottomRight()
};
var updates = new Dictionary <ushort, List <TileUpdate> >();
for (int i = 0; i < tiles.Count; i++)
{
ushort regionId = regionLocator.GetRegionIndex(tiles[i].X, tiles[i].Y);
TileUpdate update;
if (i == 0)
{
update = new TileUpdate(tiles[i].X,
tiles[i].Y,
regionManager.RevertTileType(tiles[i].X, tiles[i].Y, false));
}
else
{
update = new TileUpdate(tiles[i].X, tiles[i].Y, CalculateRoad(tiles[i].X, tiles[i].Y, false, ThemeRoadIndexes[themeId]));
}
if (!update.TileType.HasValue)
{
continue;
}
List <TileUpdate> list;
if (!updates.TryGetValue(regionId, out list))
{
list = new List <TileUpdate> {
update
};
updates.Add(regionId, list);
}
else
{
updates[regionId].Add(update);
}
}
SendUpdate(updates);
}
public void CreateRoad(uint x, uint y, string theme)
{
var tilePosition = new Position(x, y);
var tiles = new List <Position>(5)
{
tilePosition,
tilePosition.TopLeft(),
tilePosition.TopRight(),
tilePosition.BottomLeft(),
tilePosition.BottomRight()
};
var updates = new Dictionary <ushort, List <TileUpdate> >();
for (int i = 0; i < tiles.Count; i++)
{
var newRoadType = CalculateRoad(tiles[i].X, tiles[i].Y, i == 0, ThemeRoadIndexes[theme]);
if (!newRoadType.HasValue)
{
continue; // Not a road here
}
ushort regionId = regionLocator.GetRegionIndex(tiles[i].X, tiles[i].Y);
var update = new TileUpdate(tiles[i].X, tiles[i].Y, newRoadType);
List <TileUpdate> list;
if (!updates.TryGetValue(regionId, out list))
{
list = new List <TileUpdate> {
update
};
updates.Add(regionId, list);
}
else
{
updates[regionId].Add(update);
}
}
SendUpdate(updates);
}
// Use this for initialization
void Start()
{
if (DefaultTile == null)
{
Debug.LogError("Defualt Tile is Null");
}
if (DefaultTile.tag != "Tile")
{
Debug.LogError("DefualeTile was not initialized with a Tile");
}
TileUpdate.AssignPrototype(DefaultTile);
Tiles = new TileUpdate[Width, Height];
Vector3 TileDimensions = DefaultTile.transform.localScale;
for (int index = 0; index < Width; index++)
{
for (int endex = 0; endex < Height; endex++)
{
GameObject tile = (GameObject)Instantiate(DefaultTile);
tile.transform.Translate(new Vector3(index * TileDimensions.x, 0, endex * TileDimensions.z));
Color color = tile.renderer.material.GetColor("_Color");
tile.renderer.material.SetColor("_Color", color);
Tiles[index, endex] = tile.GetComponent <TileUpdate>();
if ((index * endex) % 32 == 0)
{
Tiles[index, endex].ChangeState(true);
}
}
}
for (int index = 0; index < Width; index++)
{
for (int endex = 0; endex < Height; endex++)
{
SafeNeighborAdd(Tiles[index, endex], TileUpdate.Neighbors.Top, index, endex - 1);
SafeNeighborAdd(Tiles[index, endex], TileUpdate.Neighbors.Bottom, index, endex + 1);
SafeNeighborAdd(Tiles[index, endex], TileUpdate.Neighbors.Left, index - 1, endex);
SafeNeighborAdd(Tiles[index, endex], TileUpdate.Neighbors.Right, index + 1, endex);
}
}
}
public void AssignTile(Neighbors TileNeighbor, TileUpdate Tile)
{
switch (TileNeighbor)
{
case Neighbors.Top:
TopTile = Tile;
break;
case Neighbors.Bottom:
BottomTile = Tile;
break;
case Neighbors.Left:
LeftTile = Tile;
break;
case Neighbors.Right:
RightTile = Tile;
break;
case Neighbors.TopLeft:
TopLeftTile = Tile;
break;
case Neighbors.TopRight:
BottomRightTile = Tile;
break;
case Neighbors.BottomLeft:
BottomLeftTile = Tile;
break;
case Neighbors.BottomRight:
BottomRightTile = Tile;
break;
}
}
public MainPage()
{
this.InitializeComponent();
Current = this;
App.AppFrame = MainFrame;
App.RootGrid = RootGrid;
//ApplicationView.GetForCurrentView().TryEnterFullScreenMode();
CustomTitleBar();
SystemNavigationManager.GetForCurrentView().BackRequested += App_BackRequested;
Loaded += async(s, e) =>
{
if (DeviceHelper.IsMobile())
{
await StatusBar.GetForCurrentView().HideAsync();
}
rdoCourse.IsChecked = true;
await TileUpdate.Update();
};
}
private void HandleTileUpdate(TileUpdate tile)
{
var chunk = GetChunk(tile.Tile);
chunk.UpdateNode(tile.Tile);
}
public void GetPosition(int x, int y)
{
var change = new TileUpdate(new Vector(x, y), new Tile(), new Tile());
Assert.That(change.Position, Is.EqualTo(new Vector(x, y)));
}
