public async Task <CurrentBuilding> InsertCurrentBuilding(CurrentBuilding currentBuilding, City city)
{
_dbContext.CurrentBuildings.Add(currentBuilding);
city.CurrentBuilding = currentBuilding;
await _dbContext.SaveChangesAsync();
return(currentBuilding);
}
public async Task <CurrentBuilding> UpdateCurrentBuilding(CurrentBuilding currentBuilding)
{
var oldBuilding = await GetCurrentBuildingAsync(currentBuilding.Id);
_dbContext.Entry(oldBuilding).CurrentValues.SetValues(currentBuilding);
await _dbContext.SaveChangesAsync();
return(currentBuilding);
}
/// <summary>
/// Draw subprogram for <see cref="World"/> object
/// </summary>
/// <param name="spriteBatch">SpriteBatch to draw sprites</param>
public void Draw(SpriteBatch spriteBatch)
{
// Drawing appropriate data, depending whether the player is inside or outside
if (!IsInside)
{
// Drawing the various loaded chunks of the world
for (int y = 0; y < CHUNK_COUNT; ++y)
{
for (byte x = 0; x < CHUNK_COUNT; ++x)
{
loadedChunks[x, y].Draw(spriteBatch);
}
}
// Drawing the outsides of various buildings
for (int i = 0; i < buildings.Count; ++i)
{
buildings[i].DrawOutside(spriteBatch);
}
}
else
{
// Drawing the current building the player is in
CurrentBuilding.DrawInside(spriteBatch);
}
// Drawing projectiles
for (byte i = 0; i < projectiles.Count; ++i)
{
projectiles[i].Draw(spriteBatch);
}
// Drawing live items
for (short i = 0; i < liveItems.Count; ++i)
{
liveItems[i].Draw(spriteBatch);
}
// Drawing enemies
if (!IsInside)
{
for (short i = 0; i < enemies.Count; ++i)
{
enemies[i].Draw(spriteBatch);
}
}
else if (CurrentBuilding is Dungeon)
{
for (int i = 0; i < DungeonEnemies.Count; i++)
{
DungeonEnemies[i].Draw(spriteBatch);
}
}
}
private void AddFloor()
{
if (CurrentBuilding == null)
{
return;
}
var floor = new Floor(CurrentBuilding);
CurrentBuilding.AddFloor(floor);
CurrentBuilding.CurrentFloor = floor;
SelectedEntity = floor;
}
public async Task BuyBuilding(int userId, BuildingTypes buildingType)
{
var player = await _dbContext.Players
.Include(p => p.Stock)
.Include(p => p.City)
.ThenInclude(c => c.CurrentBuilding)
.Include(p => p.City)
.ThenInclude(c => c.CityBuildings)
.ThenInclude(cb => cb.Building)
.Where(p => p.UserId == userId)
.SingleOrDefaultAsync();
var cost = player.City.CityBuildings
.Where(cb => cb.Building.Type == buildingType)
.Select(cb => new { cb.Building.PearlCost, cb.Building.StoneCost })
.FirstOrDefault();
if (player.City.CurrentBuilding != null)
{
throw new GeneralGameException($"Nem építhetsz, több mint egy épületet egyszerre!");
}
if (player.Stock.PearlAmount < cost.PearlCost)
{
throw new GeneralGameException("Nincs elég gyöngyöd, hogy megépítsd ezt az épületet!");
}
if (player.Stock.StoneAmount < cost.StoneCost)
{
throw new GeneralGameException("Nincs elég köved ennek az épületnek a megépítéséhez!");
}
else
{
await _stockService.ReducePearl(player.Stock, cost.PearlCost);
await _stockService.ReduceStone(player.Stock, cost.StoneCost);
}
var currentBuilding = new CurrentBuilding
{
BuildingType = buildingType,
CityId = player.City.Id,
TurnNeed = TIME_TO_BUILD_BUILDING
};
await InsertCurrentBuilding(currentBuilding, player.City);
}
private void UpdateBuilding()
{
IBuilding b = town.IsHumanInBuilding(this);
if ((CurrentBuilding == null) && (b != null))
{
b.AddHuman(this);
CurrentBuilding = b;
return;
}
if ((CurrentBuilding != null) && (b == null))
{
CurrentBuilding.RemoveHuman(this);
CurrentBuilding = null;
return;
}
}
public MainWindowViewModel()
{
ExitCommand = new RelayCommand(param => App.Current.Shutdown());
AddBuildingCommand = new RelayCommand(param => this.AddBuilding());
AddFloorCommand = new RelayCommand(param => this.AddFloor(), param => CurrentBuilding != null);
RemoveSelectedEntityCommand = new RelayCommand(param => this.RemoveSelectedEntity(), param => CanRemoveSelectedEntity());
CalculateBlockageEvacuationRoutesCommand = new RelayCommand(param => CurrentBuilding.CalculateBlockageEvacuationRoutes(), param => CurrentBuilding != null);
CalculateFireRiskCommand = new RelayCommand(param => CurrentBuilding.CalculateFireRisk(), param => CurrentBuilding != null);
ComposeReportCommand = new RelayCommand(param => CurrentBuilding.ComposeReport(), param => CurrentBuilding != null);
SaveBuldingCommand = new RelayCommand(param => SaveBuilding(), param => CurrentBuilding != null);
LoadBuildingCommand = new RelayCommand(param => LoadBuilding());
AddFloorsConnectionSectionCommand = new RelayCommand(p => AddFloorsConnectionSection(), p => CanAddFloorsConnectionSection());
Buildings = new ObservableCollection <Building>();
Mode = ActionMode.Move;
AddBuilding();
}
public async Task UpdateCurrentBuilding(City city, CurrentBuilding currentBuilding)
{
currentBuilding.TurnNeed--;
if (currentBuilding.TurnNeed > 0)
{
await UpdateCurrentBuilding(currentBuilding);
}
else
{
var cityBuilding = city.CityBuildings
.Where(cb => cb.Building.Type == currentBuilding.BuildingType)
.SingleOrDefault();
cityBuilding.NumberOfBuildings++;
await _dbContext.SaveChangesAsync();
await DeleteCurrentBuilding(currentBuilding.Id, city);
}
}
private void RemoveSelectedEntity()
{
Mode = ActionMode.Remove;
if (SelectedEntity == null)
{
return;
}
if (SelectedEntity is Building)
{
var index = Buildings.IndexOf(SelectedEntity as Building);
Buildings.Remove(SelectedEntity as Building);
if (index >= Buildings.Count - 1)
{
CurrentBuilding = Buildings.LastOrDefault();
}
else
{
CurrentBuilding = Buildings[index];
}
SelectedEntity = CurrentBuilding;
return;
}
if (SelectedEntity is Floor)
{
CurrentBuilding.RemoveFloor(SelectedEntity as Floor);
CurrentFloor = CurrentBuilding.CurrentFloor;
SelectedEntity = CurrentFloor;
return;
}
CurrentFloor.RemoveObject(SelectedEntity);
SelectedEntity = CurrentFloor.Objects.FirstOrDefault();
if (SelectedEntity == null)
{
SelectedEntity = CurrentFloor;
}
}
/// <summary>
/// Update subprogram for <see cref="World"/>
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values</param>
public void Update(GameTime gameTime)
{
// Shifting chunk and loading chunks if needed, if current chunk is not centered
if (Player.Instance.CurrentChunk != loadedChunks[CHUNK_COUNT / 2, CHUNK_COUNT / 2].Position)
{
AdjustLoadedChunks(Player.Instance.CurrentChunk);
}
// Updating current building if inside a building
if (IsInside)
{
CurrentBuilding.Update(gameTime);
}
// Generating enemies every 3s
enemyGenerationTimer += gameTime.ElapsedGameTime.Milliseconds / 1000.0f;
if (enemyGenerationTimer > ENEMY_GENERATE_TIME)
{
chunkBounaryID = SharedData.RNG.Next(chunkBoundaries.Length);
if (!GetTileAt(chunkBoundaries[chunkBounaryID] + Player.Instance.CurrentChunk).OutsideObstructState)
{
enemies.Add(Enemy.RandomEnemy(chunkBoundaries[chunkBounaryID] + Player.Instance.CurrentTile, false));
}
enemyGenerationTimer = 0;
}
// Updating enemies
if (!IsInside)
{
for (int i = enemies.Count - 1; i >= 0; --i)
{
enemies[i].Update(gameTime);
// Removing enemies if they die and giving player corresponding loot
if (!enemies[i].Alive)
{
Player.Instance.Experience += enemies[i].Experience;
Player.Instance.Gold += enemies[i].Gold;
AddItems(enemies[i].HitBox, enemies[i].LootTable);
enemies.RemoveAt(i);
}
}
}
else
{
// Updating dungeon enemies
for (int i = DungeonEnemies.Count - 1; i >= 0; --i)
{
DungeonEnemies[i].Update(gameTime);
// Removing enemies if they die and giving player corresponding loot
if (!DungeonEnemies[i].Alive)
{
Player.Instance.Experience += DungeonEnemies[i].Experience;
Player.Instance.Gold += DungeonEnemies[i].Gold;
AddItems(DungeonEnemies[i].HitBox, DungeonEnemies[i].LootTable);
DungeonEnemies.RemoveAt(i);
}
}
}
// Updating the projectiles and collision info in the world
for (int i = projectiles.Count - 1; i >= 0; --i)
{
projectiles[i].Update(gameTime);
// Removing projectiles if they are not active
if (!projectiles[i].Active)
{
projectiles.RemoveAt(i);
continue;
}
// Inflicting damage and removing projectile if it hits a enemy
if (IsInside)
{
hitEnemies.AddRange(collisionTree.GetCollisions(projectiles[i].HitBox, DungeonEnemies));
}
else
{
hitEnemies = collisionTree.GetCollisions(projectiles[i].HitBox, enemies);
}
// Inflicting damage on enemies that are hit by the projectile and removing the projectile
for (int j = 0; j < hitEnemies.Count; ++j)
{
hitEnemies[j].Health -= projectiles[i].DamageAmount;
}
if (hitEnemies.Count > 0)
{
projectiles.RemoveAt(i);
}
}
// Updating live items
for (int i = liveItems.Count - 1; i >= 0; --i)
{
liveItems[i].Update(gameTime);
// Removing item if it despawns
if (!liveItems[i].Live)
{
liveItems.RemoveAt(i);
}
}
// Removing enemies outside of the loaded world
for (int i = enemies.Count - 1; i >= 0; --i)
{
if (!worldBoundsRect.Contains(enemies[i].HitBox))
{
enemies.RemoveAt(i);
}
}
}
private bool CanAddFloorsConnectionSection()
{
return((ContextMenuPosition != null) &&
!(CurrentBuilding == null || CurrentFloor == null || CurrentBuilding.GetFloorBelow(CurrentFloor) == null));
}
