public async Task <ActionResult <RoleGame> > PostRoleGame(RoleGame roleGame)
{
_context.RoleGames.Add(roleGame);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetRoleGame", new { id = roleGame.Id }, roleGame));
}
public async Task <IActionResult> PutRoleGame(int id, RoleGameDTO roleGamedto)
{
RoleGame roleGame = roleGamedto.Update(_context.RoleGames.Find(id), _context);
if (id != roleGame?.Id)
{
return(BadRequest());
}
var oldPlayings = _context.Playings.Where(x => x.RoleGameId == id).ToList();
_context.RemoveRange(oldPlayings);
_context.Entry(roleGame).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RoleGameExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
roleGamedto.Id = roleGame.Id;
return(Ok(roleGamedto));
}
public async Task <IActionResult> PutRoleGame(int id, RoleGame roleGame)
{
if (id != roleGame.Id)
{
return(BadRequest());
}
_context.Entry(roleGame).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RoleGameExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public RoleGame Update(RoleGame rg, RoleContext context)
{
RoleGame newrg = this.Convert(context);
rg.Players = newrg.Players;
rg.DungeonMaster = newrg.DungeonMaster;
rg.Game = newrg.Game;
rg.Name = newrg.Name;
rg.Dificultty = newrg.Dificultty;
return(rg);
}
public async Task <ActionResult <RoleGameDTO> > PostRoleGame(RoleGameDTO roleGamedto)
{
RoleGame roleGame = roleGamedto.Convert(_context);
_context.RoleGames.Add(roleGame);
try
{
await _context.SaveChangesAsync();
}
catch (Exception)
{
return(BadRequest());
}
roleGamedto.Id = roleGame.Id;
return(Ok(roleGamedto));
}
public RoleGameDTO(RoleGame game, RoleContext context)
{
Id = game.Id;
Name = game.Name;
Dificultty = game.Dificultty;
Game = game.Game;
DungeonMaster = context.Players
.Find(game.DungeonMasterId).Name;
var own = context.RoleGames
.Where(x => x.Id == game.Id);
if (own.Count() > 0)
{
Players = own
.Include(x => x.Players)
.ThenInclude(xn => xn.Player).FirstOrDefault()
.Players.Select(x => x.Player.Name).ToList();
}
}
public RoleGame Convert(RoleContext context)
{
RoleGame rg = new RoleGame();
rg.Id = this.Id;
rg.Name = this.Name;
rg.Dificultty = this.Dificultty;
rg.Game = this.Game;
rg.DungeonMaster = context.Players
.Where(x => x.Name.ToUpper() == this.DungeonMaster.ToUpper()).First();
rg.Players = this.Players
.SelectMany(x =>
context.Players.Where(y => y.Name.ToUpper() == x.ToUpper()))
.Select(x => new Playing()
{
Player = x, RoleGame = rg
})
.ToList();
return(rg);
}
private void InitGame()
{
if (NetworkClient != null)
{
var pkt = NetworkClient.Receive();
Trace.Assert(pkt is ConnectionResponse);
if ((pkt as ConnectionResponse).Settings.GameType == GameType.Pk1v1)
{
_game = new Pk1v1Game();
}
if ((pkt as ConnectionResponse).Settings.GameType == GameType.RoleGame)
{
_game = new RoleGame();
}
if (pkt is ConnectionResponse)
{
_game.Settings = ((ConnectionResponse)pkt).Settings;
NetworkClient.SelfId = ((ConnectionResponse)pkt).SelfId;
}
else
{
return;
}
}
if (hasSeed != null)
{
_game.RandomGenerator = new Random((int)hasSeed);
_game.IsPanorama = true;
}
Game.CurrentGameOverride = _game;
if (_networkClient == null)
{
_game.Settings = new GameSettings();
_game.Settings.Accounts = new List <Account>();
_game.Settings.NumberOfDefectors = 1;
_game.Settings.NumHeroPicks = 3;
_game.Settings.DualHeroMode = false;
_game.Settings.TotalPlayers = 8;
_game.Settings.TimeOutSeconds = 15;
for (int i = 0; i < 8; i++)
{
_game.Settings.Accounts.Add(new Account()
{
UserName = "******" + i
});
}
}
ClientNetworkProxy activeClientProxy = null;
if (NetworkClient != null)
{
for (int i = 0; i < _game.Settings.TotalPlayers; i++)
{
Player player = new Player();
player.Id = i;
_game.Players.Add(player);
}
}
else
{
for (int i = 0; i < 8; i++)
{
Player player = new Player();
player.Id = i;
_game.Players.Add(player);
}
}
if (NetworkClient != null)
{
_game.GameClient = NetworkClient;
}
else
{
_game.GlobalProxy = new GlobalDummyProxy();
}
GameViewModel gameModel = new GameViewModel();
gameModel.Game = _game;
if (NetworkClient != null)
{
gameModel.MainPlayerSeatNumber = NetworkClient.SelfId >= _game.Players.Count ? 0 : NetworkClient.SelfId;
}
else
{
gameModel.MainPlayerSeatNumber = 0;
}
_game.NotificationProxy = gameView;
List <ClientNetworkProxy> inactive = new List <ClientNetworkProxy>();
for (int i = 0; i < _game.Players.Count; i++)
{
var player = gameModel.PlayerModels[i].Player;
if (NetworkClient != null)
{
var proxy = new ClientNetworkProxy(
new AsyncProxyAdapter(gameModel.PlayerModels[i]), NetworkClient);
proxy.HostPlayer = player;
proxy.TimeOutSeconds = _game.Settings.TimeOutSeconds;
if (i == 0)
{
activeClientProxy = proxy;
}
else
{
inactive.Add(proxy);
}
_game.UiProxies.Add(player, proxy);
}
else
{
var proxy = new AsyncProxyAdapter(gameModel.PlayerModels[i]);
_game.UiProxies.Add(player, proxy);
}
}
if (NetworkClient != null)
{
_game.ActiveClientProxy = activeClientProxy;
_game.GlobalProxy = new GlobalClientProxy(_game, activeClientProxy, inactive);
_game.UpdateUiAttachStatus();
}
Application.Current.Dispatcher.Invoke((ThreadStart) delegate()
{
gameView.DataContext = gameModel;
if (BackwardNavigationService != null && !ViewModelBase.IsDetached)
{
BackwardNavigationService.Navigate(this);
BackwardNavigationService = null;
}
});
_game.Run();
}
