private async Task <IGame> LoadGame(GameDataModel src)
{
var player01 = await userRepository.Get(src.Player01);
var player02 = await userRepository.Get(src.Player02);
var p1Details = await userRepository.GetDetails(player01.UserName);
var p2Details = await userRepository.GetDetails(player02.UserName);
var moves = (await gameRepository.GetMoves(src.Id))
.OrderBy(m => m.PlayStart)
.ToArray();
var playMoves = moves.Select(m => new PlayMove
{
Player = m.PlayerId,
PlayStart = m.PlayStart,
PlayFinish = m.PlayFinish,
Score = m.Score,
Letters = m.Letters.FromJson <PlayLetter[]>(),
Words = m.Words.FromJson <PlayWord[]>()
});
return(new Game
{
Id = src.Id,
Board = await boardRepository.Get(src.BoardId),
Language = src.Language,
CreationDate = src.CreationDate,
Player01 = new GamePlayer
{
UserName = player01.UserName,
FirstName = p1Details.FirstName,
LastName = p1Details.LastName,
Rack = src.Player01Rack.GetLetters(src.Language),
Score = playMoves.Where(m => m.Player == player01.UserName).Sum(m => m.Score)
},
Player02 = new GamePlayer
{
UserName = player02.UserName,
FirstName = p2Details.FirstName,
LastName = p2Details.LastName,
Rack = src.Player02Rack.GetLetters(src.Language),
Score = playMoves.Where(m => m.Player == player02.UserName).Sum(m => m.Score)
},
Status = (GameStatus)src.Status,
CurrentPlayer = src.CurrentPlayer,
CurrentStart = src.CurrentStart,
CurrentPauseStart = src.CurrentPauseStart,
LetterBag = new LetterBag(src.Language, src.LetterBag.FromJson <Letter[]>()),
Winner = src.Winner,
FinishReason = (FinishReason?)src.FinishReason,
ConsecutivePasses = src.ConsecutivePasses,
FinishDate = src.FinishDate,
P1FinalScore = src.P1FinalScore,
P2FinalScore = src.P2FinalScore,
AvailableLetters = src.Language.GetLettersOnly(),
PlayMoves = playMoves
});
}
/// <summary>
/// Get the number of fire pick-ups and if there is more
/// than 1 pick-up in inventroy and 'E' is pressed toggle on fire.
/// Fire is then toggled off after a set perio of time, and pick-up removed from inventory.
/// </summary>
void Update()
{
if (GameDataModel.PlayMode == true)
{
_noFire = GameDataModel.GetPickUp(GameDataModel.pickupTypes.Fire);
if (Input.GetKey(KeyCode.E) && !_flameOn && _noFire > 0)
{
_audio.clip = fire;
_audio.Play();
_flameOn = true;
}
if (_flameOn == true)
{
_flames.SetActive(true);
flameTime -= Time.deltaTime;
GameDataModel.QuantPickUp(GameDataModel.pickupTypes.Fire, false);
if (flameTime < 0)
{
_flameOn = false;
}
}
else
{
_flames.SetActive(false);
flameTime = 1.5f;
}
}
else
{
_flames.SetActive(false);
}
}
public IHttpActionResult Create(GameDataModel model)
{
var currentUserID = this.User.Identity.GetUserId();
var bluePlayer = "No blue player yet";
var game = new Game
{
RedPlayerNumber = model.Number,
RedPlayerId = currentUserID,
GameState = GameState.WaitingForOpponent,
DateCreated = DateTime.Now,
Name = model.Name
};
this.data.Games.Add(game);
this.data.SaveChanges();
model.Id = game.Id;
model.Red = this.data.Users.All().FirstOrDefault(user => user.Id == game.RedPlayerId).UserName;
model.Blue = game.BluePlayer != null ? game.BluePlayer.UserName : bluePlayer;
model.Number = game.Number;
model.Name = game.Name;
model.GameState = game.GameState.ToString();
model.DateCreated = game.DateCreated;
return(Ok(model));
}
// Update is called once per frame
void Update()
{
glideBar.value = GameDataModel.GlideValue;
pointText.text = GameDataModel.Points.ToString();
attempts.text = GameDataModel.Attempts.ToString();
pickUps.text = GameDataModel.GetPickUp(GameDataModel.pickupTypes.Fire).ToString();
}
public static void CopyFrom(this GameDataViewModel target, GameDataModel source)
{
if (target == null)
{
throw new ArgumentNullException(nameof(target));
}
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
// TODO: Copy fields here.
target.Round = source.Round;
target.MaxLoyaltyPoints = source.LoyaltyTrackerSize;
target.MaxWinPoints = source.WinPointTrackerSize;
target.Players.ReplaceAll(source.Players.Select(x =>
{
var viewModel = ServiceLocator.Container.Resolve <PlayerViewModel>();
// TODO: Copy fields here.
viewModel.Race = x.Race;
viewModel.LoyaltyPoints = x.LoyaltyPoints;
viewModel.WinPoints = x.WinPoints;
viewModel.Color = x.Color;
viewModel.Counselor = target.CounselorMap[x.Counselor];
return(viewModel);
}));
target.UpdateRounds();
target.UpdateIsGameCanBeFinished();
target.GetInitiativePlayer().HasInitiative = true;
}
public async Task DisconnectFromGame(string id, GameDataModel game)
{
var dbContext = getNewDBContext();
var result = game.RemovePlayer(id);
EntityEntry <GameDataModel> status;
if (result == GameResult.END)
{
status = dbContext.Remove(game);
}
else
{
if (WebSocketHelper.CountPlayers(game.PlayerIDs.Split(",")) > 0 && game.Result != GameResult.END)
{
game.Result = GameResult.DRAW;
}
status = dbContext.Update(game);
}
await dbContext.SaveChangesAsync();
dbContext.Dispose();
if (status.State != EntityState.Detached)
{
await SendNewGameStatus(game);
}
}
public async Task <GameDataModel> Update(GameDataModel game)
{
try
{
if (game == null || game.Id == null)
{
throw new ArgumentNullException(nameof(game));
}
var existing = await Get(game.Id);
if (existing == null)
{
throw new Exception($"Game doesn't exist: {game.Id}");
}
using var cnn = createdDbConnection();
cnn.Open();
string query = $"UPDATE Game SET {getSqlUpdateFields(typeof(GameDataModel))}"
.Replace("Id=@Id,", "");
query += " WHERE Id=@Id";
if (await cnn.ExecuteAsync(query, game) != 1)
{
throw new Exception($"ExecuteAsync failed: {query}");
}
return(game);
}
catch (Exception ex)
{
log?.ErrorAsync("Error updating user stats", ex);
throw;
}
}
private async Task HandleGameAdd(string json, WebSocket socket)
{
var jObject = JObject.Parse(json);
var response = jObject.ToObject <GameAddResponse>();
var dbContext = getNewDBContext();
String[] gameField = new String[9];
for (int i = 0; i < gameField.Length; i++)
{
gameField[i] = "";
}
GameDataModel gameToAdd = new GameDataModel()
{
GameName = response.Name,
GameTags = response.Tags,
GameStarted = DateTime.Now,
PlayerIDs = "",
GameFieldJSON = JsonConvert.SerializeObject(gameField)
};
dbContext.Games.Add(gameToAdd);
await dbContext.SaveChangesAsync();
dbContext.Dispose();
ServerResponse answer = new ServerResponse()
{
Type = "GameAdded",
Value = gameToAdd.GameID.ToString()
};
await WebSocketHelper.Send(JsonConvert.SerializeObject(answer), socket);
}
private void _broadcast(GameDataModel model)
{
foreach (var player in _players.Values.ToArray())
{
Task.Run(() => player.Send(model));
}
}
public void Revert()
{
// Depending on vales chosen to reset, reset variables
if (_resetPosition)
{
_transform.position = _position;
}
if (_resetRotation)
{
_transform.rotation = _rotation;
}
if (_resetScale)
{
_transform.localScale = _scale;
}
if (_resetActive)
{
_gameObject.SetActive(_active);
}
//Depending on an objects coponents reset appropriate values.
if (_rb != null)
{
_rb.isKinematic = _isKin;
_rb.velocity = Vector3.zero;
_rb.angularVelocity = Vector3.zero;
}
if (_do != null)
{
_do.objectHealth = _health;
_do.isOnFire = false;
_do.ResetFire();
_do.SetHasExploded(false);
}
if (_ren != null)
{
_ren.material.color = _color;
}
if (_playerPhysics != null)
{
_playerPhysics.collisions = 0;
_playerPhysics.ResetAimBalls();
}
if (_fireBreathing != null)
{
_fireBreathing.flameTime = 1.5f;
}
//reset pick-ups and cancael any onvokes
GameDataModel.SetPickUpVal(GameDataModel.pickupTypes.Fire, 0);
GameDataModel.Attempts = 3;
_GameManager.Single().CancelInvoke("EndTurn");
_GameManager.Single().CancelInvoke("EndInvoker");
_GameManager.Single().CancelInvoke("CheckForEnd");
}
// Use this for initialization
void Start()
{
galaxy = galaxyManager.GetComponent <GalaxyManager>();
tradeRequestManager = pathfindingManager.GetComponent <TradeRouteRequestManager>();
data = new GameDataModel();
setup = true;
GetLoadingPanel().LoadAssets();
}
public void PurchaseGame(GameDataModel game)
{
var url = game.StoreUrl;
if (url != null)
{
Tools.Generic.TryOpenUrl(url);
}
}
public void ShowInfo(GameDataModel game)
{
if (game == null)
{
throw new ArgumentNullException(nameof(game));
}
SelectedItem = game;
ShowOverlay(_gameInfoOverlay);
}
public static GameViewModel MapToViewGame(GameDataModel dataGame)
{
if (dataGame == null)
{
throw new ArgumentNullException(nameof(dataGame));
}
return(new GameViewModel {
Name = dataGame.Name, Team = dataGame.Team
});
}
public GameDataApiRequestModel(GameDataModel model)
{
Id = model.Id;
Status = model.Status;
Tank1Id = model.Tank1Id;
Tank2Id = model.Tank2Id;
MapId = model.MapId;
WinnerId = model.WinnerId;
Logs = model.Logs;
}
public GameDataApiResponseModel(GameDataModel model)
{
Id = model.Id;
Status = model.Status.ToString();
Tank1Id = model.Tank1Id;
Tank2Id = model.Tank2Id;
MapId = model.MapId;
WinnerId = model.WinnerId;
Logs = model.Logs;
}
public ActionResult <TexasGameResult> GetGameResult(GameDataModel gameData)
{
var player1 = new TexasHoldEmPlayer(gameData.PlayerOneName);
var player2 = new TexasHoldEmPlayer(gameData.PlayerTwoName);
player1.HandCards = new HandCards(gameData.PlayerOneCards);
player2.HandCards = new HandCards(gameData.PlayerTwoCards);
return(TexasGameComparer.CompareHandCards(player1, player2));
}
public override void DisplayGameData(GameDataModel gameData)
{
lock (_stdLock)
{
Console.SetCursorPosition(0, 0);
PrettyConsole.WriteLineColor(ConsoleColor.DarkRed, "Логин: {0}, Сервер API: {1}", User, ServerContext.BaseUri);
PrettyConsole.WriteLineColor(ConsoleColor.DarkGreen, "F2 - Администрирование");
PrettyConsole.WriteLineColor(ConsoleColor.DarkGreen, "F3 - Разлогиниться");
Console.SetCursorPosition(0, 3);
base.DisplayGameData(gameData);
}
}
public static WebSocket[] GetPlayerSockets(GameDataModel game, WebSocketManager manager)
{
var players = game.PlayerIDs.Split(",");
var playerCount = CountPlayers(players);
WebSocket[] playerSockets = new WebSocket[playerCount];
for (int i = 0; i < playerSockets.Length; i++)
{
playerSockets[i] = manager.GetSocketById(players[i]);
}
return(playerSockets);
}
public void Create(GameBLModel game)
{
if (string.IsNullOrWhiteSpace(game.Name) ||
string.IsNullOrWhiteSpace(game.Key)
)
{
return;
}
GameDataModel gameToCreate = Mapper.Map <GameDataModel>(game);
_unitOfWork.GameRepository.Create(gameToCreate);
}
private async Task SendNewGameStatus(GameDataModel game)
{
ServerResponse answer = new ServerResponse()
{
Type = "GameStatus",
Value = JsonConvert.SerializeObject(game)
};
WebSocket[] playerSockets = WebSocketHelper.GetPlayerSockets(game, manager);
foreach (var player in playerSockets)
{
await WebSocketHelper.Send(JsonConvert.SerializeObject(answer), player);
}
}
void HandleSettings(GameDataModel x)
{
if (x == null)
{
return;
}
// TODO: HACK For game changing from installed to not installed, resetting selected item :S
var gso = _gso;
if (gso != null && gso.IsActive)
{
ShowSettings(x);
}
}
private async Task CloseConnection(String id, WebSocket socket)
{
GameDataModel game = FindGameByPlayerID(id);
if (game != null)
{
await DisconnectFromGame(id, game);
}
manager.Remove(id);
if (socket.State == WebSocketState.Open)
{
await socket.CloseAsync(WebSocketCloseStatus.Empty, "", CancellationToken.None);
}
}
/// <summary>
/// Generates in-memory mock data for GameDataModels.
/// </summary>
/// <returns></returns>
private GameDataModel MockGameData()
{
GameDataModel mock = new GameDataModel
{
Id = Guid.NewGuid(),
Player = MockPlayerData(),
CreationDate = DateTime.UnixEpoch
};
mock.Frames = MockFrameData(mock.Id);
mock.CurrentFrameId = mock.Frames.Last().Id;
mock.CurrentThrow = 1;
return(mock);
}
public void ShowSettings(GameDataModel game)
{
if (game == null)
{
throw new ArgumentNullException(nameof(game));
}
SelectedItem = game;
_gso?.TryClose();
if (_gso == null || _gso.GameSettings.GameId != game.Id)
{
_gso = _mediator.Send(new ShowGameSettingsQuery(game.Id));
}
ShowOverlay(_gso);
}
protected override string[] GetAnswers(IGameDataParticleModel[] datas)
{
var states = GameDataModel.GetData(TypeDataModel.Capitals);
var names = new List <string>();
foreach (var gameDataParticleModel in datas)
{
var state = states.Find(g => g.GetID() == gameDataParticleModel.GetID());
names.Add(state.GetName());
}
return(names.ToArray());
}
void AfterGameDataModelMap(Game src, GameDataModel dest)
{
Map(src.MetaData, dest);
Map(src.InstalledState, dest);
dest.SupportsMissions = src.SupportsMissions();
dest.SupportsMods = src.SupportsMods();
dest.SupportsServers = src.SupportsServers();
var iHaveDlc = src as IHaveDlc;
if (iHaveDlc != null)
{
dest.Dlcs = Map <DlcDataModel[]>(iHaveDlc.Dlcs);
}
}
public async Task <GameDataModel> CreateAsync(GameDataModel model)
{
var content = new StringContent(JsonConvert.SerializeObject(new GameDataApiRequestModel(model)), Encoding.UTF8, "application/json");
var response = await _client.PostAsync($"/api/score/", content);
var responseContent = await response.Content.ReadAsStringAsync();
if (response.IsSuccessStatusCode)
{
var responseResult = JsonConvert.DeserializeObject <GameDataModel>(responseContent);
return(responseResult);
}
return(null);
}
protected override void OnInitialize()
{
base.OnInitialize();
var items = _mediator.Send(new ListGamesQuery());
items.EnableCollectionSynchronization(_itemsLock);
Items = items;
View = Items.SetupDefaultCollectionView(
new[] {
new SortDescription("IsInstalled", ListSortDirection.Descending),
new SortDescription("IsFavorite", ListSortDirection.Descending),
new SortDescription("Name", ListSortDirection.Ascending)
}, new[] { new PropertyGroupDescription("IsInstalled") },
new[] { "IsInstalled" },
Filter, true);
DoubleClickedCommand.Cast <GameDataModel>().Subscribe(ActivateGame);
DomainEvilGlobal.SelectedGame.WhenAnyValue(x => x.ActiveGame)
.Subscribe(ActivateGame);
this.WhenAnyValue(x => x.ActiveGame)
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(x => SelectedItem = x);
this.WhenAnyValue(x => x.SelectedItem)
.Where(x => x != null)
.Subscribe(x => {
ContextMenu.ShowForItem(x);
BarMenu.ShowForItem(x);
});
UserSettings.WhenAnyValue(x => x.Ready)
.Subscribe(x => ProgressState.Active = !x);
UserSettings.WhenAnyValue(x => x.GameOptions.GameSettingsController.ActiveProfile)
.Skip(1)
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ => HandleSettings());
this.WhenAnyValue(x => x.SelectedItem)
.Skip(1)
.Subscribe(HandleSettings);
}
private void Create(int mode)
{
var type = (TypeDataModel)mode;
var data = GameDataModel.GetData(type);
var nameSprite = GameDataModel.GetNameSprite(type) + "normal_";
CreatePrefabs(data.Count);
for (int i = 0; i < data.Count; i++)
{
var url = nameSprite + data[i].GetID().ToString("d2");
var name = data[i].GetName();
_prefabs[i].Setup(url, name);
}
}
