protected override void ThrowUndoInternal(GameSnapshot gameSnapshot)
{
scoreBoard.SetPointsTo(Game.PlayerOnThrow, Game.PlayerOnThrow.GameData.LegPoints);
scoreBoard.SetThrowNumber(Game.PlayerOnThrow.GameData.ThrowNumber);
scoreBoard.CheckPointsHintFor(Game.PlayerOnThrow);
}
public void Restore(ISnapshot s)
{
GameSnapshot snapshot = (GameSnapshot)s;
this._currentMove = snapshot.CurrentMove;
this._gameBoard.Restore(snapshot.BoardSnapshot);
}
// Save and store a snapshot of a game state
public void SaveSnapShot(GameSnapshot snapshot)
{
snapshots.AddFirst(snapshot);
player.TravelTowardGoal();
gamemap.RandomizeMap();
//Debug.Log("Snapshot Saved!");
}
/// <summary>
/// Displays on console information about the game.
/// </summary>
/// <param name="snapshot">Game information that has to be shown on screen.</param>
public void Print(GameSnapshot snapshot)
{
Console.Clear();
var left = 0;
var top = 0;
int count = 0;
int maxCount = Console.BufferWidth / Shift;
foreach (var number in snapshot.DisplayWorlds)
{
var world = snapshot.Worlds[number - 1];
Print(number, world, new Point(left, top));
left += Shift;
count++;
if (count == maxCount)
{
left = 0;
top += Shift;
count = 0;
}
}
Console.SetCursorPosition(0, top + Shift);
PrintLine($"Total Worlds: {snapshot.TotalWorlds,4} Alive Worlds: {snapshot.TotalAliveWorlds,4} Lifes: {snapshot.TotalLifes,3}", ConsoleColor.White);
PrintLine($"You can pause the game by pressing Ctrl+C.");
}
public void AddAndUpdateEntity()
{
GameSnapshot snapshot = (GameSnapshot)LevelManager.CreateSnapshot();
ITemplateGroup templates = LevelManager.CreateTemplateGroup();
snapshot.Systems.Add(new SystemEventLogger(new Type[] { }));
IEntity entity = snapshot.CreateEntity(GameSnapshot.EntityAddTarget.Added);
IGameEngine engine = GameEngineFactory.CreateEngine(snapshot, templates).Value;
engine.Update().Wait();
engine.SynchronizeState().Wait();
List <TriggerEvent> events = new List <TriggerEvent>();
events.Add(TriggerEvent.OnAdded);
events.Add(TriggerEvent.OnGlobalPreUpdate);
events.Add(TriggerEvent.OnUpdate);
events.Add(TriggerEvent.OnGlobalPostUpdate);
Assert.Equal(events, engine.GetSystem <SystemEventLogger>().Events);
for (int i = 0; i < 20; ++i)
{
engine.Update().Wait();
engine.SynchronizeState().Wait();
events.Add(TriggerEvent.OnGlobalPreUpdate);
events.Add(TriggerEvent.OnUpdate);
events.Add(TriggerEvent.OnGlobalPostUpdate);
Assert.Equal(events, engine.GetSystem <SystemEventLogger>().Events);
}
}
public static void StoreGame(GameSnapshot snapshot, DateTime startTime)
{
using (var db = new HanksiteEntities())
{
Game game = new Game
{
Name = snapshot.Name,
StartTime = startTime,
EndTime = DateTime.Now
};
foreach (var player in snapshot.Players)
{
GameUser gameUser = new GameUser
{
Game = game,
UserID = player.User.ID,
Position = player.Position
};
db.GameUsers.Add(gameUser);
}
db.SaveChanges();
}
}
/// <summary>
/// Saves the game snapshot to file.
/// </summary>
/// <param name="gameInfo">Information about the game that has to be saved.</param>
public void Save(GameSnapshot snapshot)
{
EnsureDirectory();
string json = JsonConvert.SerializeObject(snapshot, Formatting.Indented);
File.WriteAllText(fileName, json);
}
// Checks the snapshot timer and takes a snapshot if needed
void checkSnapshotTimer()
{
timer += Time.deltaTime;
if (timer >= snapshotPeriod)
{
GameSnapshot state = TakeSnapshot();
SaveSnapShot(state);
timer = 0;
}
}
public ClientGameSnapshot CreateClientGameSnapshot(Client client, GameSnapshot gameSnapshot)
{
GameSnapshot gameSnapshotCopy = new GameSnapshot(gameSnapshot);
gameSnapshotCopy.playersInfo = AddUnseenInformationToGameSnapshot(gameSnapshotCopy, client.playerId);
int remoteControllableLastProcessedInputId = client.serverPlayer.remoteControllable.lastProcessedInputId;
Dictionary <int, int> adminPanelInformation = IsAdminPanelInformationNeeded(client.playerId) ? playGamePhase.serverSkeld.adminPanel.GeneratePlayersData(client.playerId) : new Dictionary <int, int>();
return(new ClientGameSnapshot(gameSnapshotCopy, remoteControllableLastProcessedInputId, adminPanelInformation));
}
protected override void ThrowUndoInternal(GameSnapshot gameSnapshot)
{
scoreBoard.OnThrowPointerSetOn(Game.PlayerOnThrow);
foreach (var player in Game.Players)
{
scoreBoard.SetPointsTo(player, player.GameData.LegPoints);
}
scoreBoard.SetThrowNumber(Game.PlayerOnThrow.GameData.ThrowNumber);
}
private void ProcessSnapshot()
{
GameSnapshot lastGameSnapshot = CaptureSnapshot();
SaveSnapshot(lastGameSnapshot);
if (playersManager.clients.Count != 0)
{
packetsSender.SendGameSnapshotPackets(lastGameSnapshot);
}
}
private static void SaveSnapshot(GameSnapshot gameSnapshot)
{
gameSnapshots.Add(gameSnapshot.id, gameSnapshot);
if (gameSnapshots.Count > 1000)
{
gameSnapshots.Remove(gameSnapshots.Keys.Min());
}
Logger.LogEvent(LoggerSection.GameSnapshots, $"Game snapshot captured {gameSnapshot}");
}
public void SendGameSnapshot(GameSnapshot snapshot)
{
lock (syncObject)
{
if (game != null)
{
var viewModel = snapshot.ToViewModel();
Application.Current.Dispatcher.InvokeAsync(() => game.SendGameSnapshot(viewModel));
}
}
}
public void SendGameSnapshot(GameSnapshot snapshot)
{
try
{
log("is sent a game snapshot");
callback.SendGameSnapshot(snapshot);
}
catch (Exception ex)
{
logError("sending game snapshot", ex);
}
}
public SnapshotViewModel(GameSnapshot snapshot, IPlayerImageProvider imageProvider)
{
this._snapshot = snapshot;
this._imageProvider = imageProvider;
var playerNumbers = this._snapshot.PlayerNumbers.Select(v => v).Take(5).ToList();
playerNumbers.AddRange(Enumerable.Repeat(-1, 5 - playerNumbers.Count));
this._players = playerNumbers
.Select(n => new { Number = n, Image = this._imageProvider.GetPlayerImage(n) })
.OrderBy(an => an.Number)
.Select(an => this.GetPlayerImage(an.Image, an.Number))
.ToList();
}
public void SendGameOver(GameSnapshot snapshot)
{
try
{
log("is sent game over message");
callback.SendGameOver(snapshot);
}
catch (Exception ex)
{
logError("sending game over message", ex);
}
RealPlayer = null;
}
public void SendGameSnapshotPackets(GameSnapshot gameSnapshot)
{
const ServerPacketType packetType = ServerPacketType.GameSnapshot;
foreach (Client client in playersManager.clients.Values.ToList())
{
if (!client.IsFullyInitialized())
{
continue;
}
ClientGameSnapshot clientGameSnapshot = clientGameSnapshotsManager.CreateClientGameSnapshot(client, gameSnapshot);
Packet packet = new Packet((int)packetType);
packet.Write(clientGameSnapshot);
SendUdpPacket(client.playerId, packetType, packet);
}
}
public static void Record(Square square, Direction moveDirection, Direction faceDirection)
{
if (!instance)
{
instance = FindObjectOfType <GameManager>();
}
//if a square isnt already recorded, then add a new item to the history
GameSnapshot snapshot = new GameSnapshot
{
square = square,
turn = instance.turn,
moveDirection = moveDirection,
faceDirection = faceDirection
};
//add this information
instance.snapshots.Add(snapshot);
}
public ActionResult Show(Guid gameId)
{
var game = _repository.GetGame(gameId);
var snapshot = _repository.GetGameSnapshot(game);
var playerRole = game.GetPlayerRole(_player);
ViewBag.PlayerRole = playerRole;
if (game.Player2 == null)
{
if (playerRole == PlayerRole.Spectator)
{
ViewBag.PlayerRole = playerRole = PlayerRole.Player2;
game.Lock(_player); // player1 chosen as first
var playerName = string.Format("Player {0}", _player.Id);
var message = _messageFactory.CreateJoinedMessage(gameId, playerName, game.CurrentState);
_repository.AddMessage(message);
snapshot = new GameSnapshot(game, message);
_repository.AddGameSnapshot(snapshot);
_repository.Save();
// allow player2 to receive the message too
return(View(new GameSnapshot(game)));
}
return(View(snapshot));
}
if (_player.Id != game.Player1.Id && _player.Id != game.Player2.Id)
{
return(View("AlreadyFull", gameId));
}
return(View(snapshot));
}
protected override void AppendEvent(GameLogEvent gameLogEvent, GameSnapshot gameSnapshot)
{
base.AppendEvent(gameLogEvent, gameSnapshot);
using var context = new DosDbContext();
context.ReplayMove.Add(new ReplayMove
{
TargetPlayer = gameLogEvent.TargetPlayer,
SourcePlayer = gameLogEvent.SourcePlayer,
Cards = gameLogEvent.Cards,
EventType = gameLogEvent.EventType,
ReplayId = replayId
});
context.ReplaySnapshot.Add(new ReplaySnapshot
{
CenterRow = gameSnapshot.CenterRow,
PlayerHands = gameSnapshot.PlayerHands,
ReplayId = replayId,
CurrentPlayerId = gameSnapshot.CurrentPlayerId,
});
context.SaveChanges();
}
/// <summary>
/// Loads and continues saved game.
/// </summary>
private void ContinueSavedGame()
{
GameSnapshot snapshot = gameSaver.Load();
if (snapshot == null)
{
gamePresenter.PrintNoSavedGame();
CreateGame();
}
else
{
worlds = snapshot.Worlds.Select(memento =>
{
var world = new World(new WorldGenerator());
world.RestoreState(memento);
return(world);
}).ToList(); //Restore worlds from saved mementos
displayWorlds = snapshot.DisplayWorlds;
ContinueGame();
}
}
public void CorrectUpdateCount()
{
GameSnapshot snapshot = (GameSnapshot)LevelManager.CreateSnapshot();
ITemplateGroup templates = LevelManager.CreateTemplateGroup();
for (int i = 0; i < 10; ++i)
{
IEntity entity = snapshot.CreateEntity(GameSnapshot.EntityAddTarget.Active);
entity.AddData <DataEmpty>();
}
snapshot.Systems.Add(new SystemCounter()
{
Filter = new[] { typeof(DataEmpty) }
});
IGameEngine engine = GameEngineFactory.CreateEngine(snapshot, templates).Value;
engine.Update().Wait();
engine.SynchronizeState().Wait();
Assert.Equal(snapshot.ActiveEntities.Count(), engine.GetSystem <SystemCounter>().UpdateCount);
}
public void RemoveEntityAndModifyInRemoveNotification()
{
GameSnapshot snapshot = (GameSnapshot)LevelManager.CreateSnapshot();
ITemplateGroup templates = LevelManager.CreateTemplateGroup();
snapshot.Systems.Add(new SystemEventLogger(new Type[] { }));
snapshot.Systems.Add(new ModifyOnRemovedTrigger());
{
IEntity e = snapshot.CreateEntity(GameSnapshot.EntityAddTarget.Removed);
e.AddData <DataEmpty>();
}
IGameEngine engine = GameEngineFactory.CreateEngine(snapshot, templates).Value;
engine.Update().Wait();
engine.SynchronizeState().Wait();
List <TriggerEvent> events = new List <TriggerEvent>();
events.Add(
TriggerEvent.OnRemoved,
TriggerEvent.OnGlobalPreUpdate,
TriggerEvent.OnGlobalPostUpdate);
Assert.Equal(events, engine.GetSystem <SystemEventLogger>().Events);
for (int i = 0; i < 20; ++i)
{
engine.Update().Wait();
engine.SynchronizeState().Wait();
events.Add(
TriggerEvent.OnGlobalPreUpdate,
TriggerEvent.OnGlobalPostUpdate);
Assert.Equal(events, engine.GetSystem <SystemEventLogger>().Events);
}
}
private GameSnapshot GetRawSnapshot()
{
if (_nextState != GameEngineNextState.Update)
{
throw new InvalidOperationException("You can only get a snapshot after synchronizing state");
}
GameSnapshot snapshot = new GameSnapshot();
snapshot.EntityIdGenerator = EntityIdGenerator;
snapshot.GlobalEntity = _globalEntity;
foreach (var adding in _notifiedAddingEntities.ToList())
{
snapshot.AddedEntities.Add(adding);
}
List <RuntimeEntity> removing = _notifiedRemovedEntities.ToList();
foreach (var entity in _entities)
{
bool isRemoving = removing.Contains(entity);
if (isRemoving)
{
snapshot.RemovedEntities.Add(entity);
}
else
{
snapshot.ActiveEntities.Add(entity);
}
}
snapshot.Systems = _systems;
return(snapshot);
}
public void AddGameSnapshot(GameSnapshot gameSnapshot)
{
_dbContext.GameSnapshots.Add(gameSnapshot);
}
public GameEngine(string snapshotJson, string templateJson)
{
_templateJson = templateJson;
// Create our own little island of references with its own set of templates
GameSnapshotRestorer restorer = GameSnapshotRestorer.Restore(
snapshotJson, templateJson, Maybe.Just(this));
GameSnapshot snapshot = restorer.GameSnapshot;
EntityIdGenerator = snapshot.EntityIdGenerator;
_systems = snapshot.Systems;
_entityIndex = new EntityIndex();
// TODO: ensure that when correctly restore UpdateNumber
//UpdateNumber = updateNumber;
_globalEntity = (RuntimeEntity)snapshot.GlobalEntity;
EventNotifier.Submit(EntityAddedEvent.Create(_globalEntity));
foreach (var entity in snapshot.AddedEntities)
{
AddEntity((RuntimeEntity)entity);
}
foreach (var entity in snapshot.ActiveEntities)
{
RuntimeEntity runtimeEntity = (RuntimeEntity)entity;
// add the entity
InternalAddEntity(runtimeEntity);
// TODO: verify that if the modification notifier is already triggered, we can
// ignore this
//if (((ContentEntity)entity).HasModification) {
// runtimeEntity.ModificationNotifier.Notify();
//}
// done via InternalAddEntity
//if (deserializedEntity.HasStateChange) {
// deserializedEntity.Entity.DataStateChangeNotifier.Notify();
//}
}
foreach (var entity in snapshot.RemovedEntities)
{
RuntimeEntity runtimeEntity = (RuntimeEntity)entity;
// add the entity
InternalAddEntity(runtimeEntity);
// TODO: verify that if the modification notifier is already triggered, we can
// ignore this
//if (((ContentEntity)entity).HasModification) {
// runtimeEntity.ModificationNotifier.Notify();
//}
// done via InternalAddEntity
//if (deserializedEntity.HasStateChange) {
// deserializedEntity.Entity.DataStateChangeNotifier.Notify();
//}
RemoveEntity(runtimeEntity);
}
TemplateIndex templateIndex = new TemplateIndex(restorer.Templates.Templates);
_executionGroups = new List <ExecutionGroup>();
var executionGroups = SystemExecutionGroup.GetExecutionGroups(snapshot.Systems);
foreach (var executionGroup in executionGroups)
{
List <MultithreadedSystem> multithreadedSystems = new List <MultithreadedSystem>();
foreach (var system in executionGroup.Systems)
{
MultithreadedSystem multithreaded = CreateMultithreadedSystem(system, templateIndex);
multithreadedSystems.Add(multithreaded);
}
_executionGroups.Add(new ExecutionGroup(multithreadedSystems));
}
_nextState = GameEngineNextState.SynchronizeState;
SynchronizeState().Wait();
// call of the engine loaded systems
foreach (var group in _executionGroups)
{
foreach (var system in group.Systems)
{
var onLoaded = system.System as Trigger.OnEngineLoaded;
if (onLoaded != null)
{
onLoaded.OnEngineLoaded(EventNotifier);
// TODO: verify that OnEngineLoaded didn't change any state (via hashing)
}
}
}
}
private static List<GameSnapshot> GetGameSnapShots(string csvText)
{
var snapShots = new List<GameSnapshot>();
var lines = csvText.Split(new string[] { Environment.NewLine }, StringSplitOptions.None);
if (lines.Length < 2)
return snapShots;
var header = lines.FirstOrDefault();
var hData = header.Split(',').ToList();
Func<string, string[], string> getData =
(headerText, dataLine) =>
{
var idx = hData.IndexOf(headerText);
var val = idx >= 0 && dataLine.Length > hData.IndexOf(headerText) ?
dataLine[idx] : "";
return val;
};
var data = lines.Skip(1).ToArray();
foreach (var l in data)
{
var arr = l.Split(',');
if (l.Length < 5)
{
continue;
}
var p1 = getData(CsvHandler.H_P1, arr);
var p2 = getData(CsvHandler.H_P2, arr);
var p3 = getData(CsvHandler.H_P3, arr);
var p4 = getData(CsvHandler.H_P4, arr);
var p5 = getData(CsvHandler.H_P5, arr);
var playerNumbersStr = new List<string> { p1, p2, p3, p4, p5 };
var playerNumbers = new List<int>();
foreach (var nStr in playerNumbersStr)
{
int num;
if (int.TryParse(nStr, out num))
playerNumbers.Add(num);
}
var scoreStr = getData(CsvHandler.H_TEAM_SCORE, arr);
var op_scoreStr = getData(CsvHandler.H_OPONENT_SCORE, arr);
var quarterStr = getData(CsvHandler.H_QUARTER, arr);
var timeLeftInQuarterStr = getData(CsvHandler.H_TIME_LEFT, arr);
int score = -1;
int.TryParse(scoreStr, out score);
int op_score = -1;
int.TryParse(op_scoreStr, out op_score);
int quarter = -1;
int.TryParse(quarterStr, out quarter);
TimeSpan timeLeftInQuarter = TimeSpan.FromSeconds(0);
TimeSpan.TryParseExact(timeLeftInQuarterStr, "mmss", null,out timeLeftInQuarter);
DateTime dt;
if (DateTime.TryParseExact(timeLeftInQuarterStr, "mm:ss", null, System.Globalization.DateTimeStyles.None, out dt))
{
timeLeftInQuarter = dt - dt.Date;
}
var snapshot = new GameSnapshot(playerNumbers, quarter, timeLeftInQuarter, score, op_score);
snapShots.Add(snapshot);
}
snapShots = snapShots.OrderBy(snp => snp.Quarter).ThenByDescending(snp => snp.TimeLeft).ToList();
return snapShots;
}
public void GetStateSnapshot(ref GameSnapshot snapshot)
{
// TODO: Not currently used.
}
// Loads a snapshot of a previous game state
public void LoadSnapshot(GameSnapshot snapshot)
{
//Debug.Log("snapshot loaded");
gamemap.LoadSnapshot(snapshot.mapState);
player.LoadSnapshot(snapshot.playerState);
}
private Dictionary <int, SnapshotPlayerInfo> AddUnseenInformationToGameSnapshot(GameSnapshot gameSnapshot, int currentPlayerId)
{
// Everyone sees everyone in the lobby
if (scenesManager.GetActiveScene() == Scene.Lobby)
{
return(gameSnapshot.playersInfo);
}
foreach (SnapshotPlayerInfo snapshotPlayerInfo in gameSnapshot.playersInfo.Values)
{
bool isSelfInformation = snapshotPlayerInfo.id == currentPlayerId;
bool isTooFarAway = (gameSnapshot.playersInfo[currentPlayerId].position - snapshotPlayerInfo.position).magnitude > 8;
SecurityPanel securityPanel = playGamePhase.serverSkeld.securityPanel;
bool isSeenFromSecurityCameras = securityPanel.IsPlayerLooking(currentPlayerId) && securityPanel.IsSeenFromSecurityCameras(snapshotPlayerInfo.id);
if (isTooFarAway && !isSelfInformation && !isSeenFromSecurityCameras)
{
snapshotPlayerInfo.unseen = true;
}
}
return(gameSnapshot.playersInfo);
}
protected abstract void ThrowUndoInternal(GameSnapshot gameSnapshot);
