public async Task <SubmitGameEventResponse> AddPlayerGameEvent(RedisUserModel player, GameEventRequest request)
{
GameEventModel eventModel = toGameEventModel(player, request);
// Ensure the event happens after current time.
GameTick currentTick = new GameTick(DateTime.FromFileTimeUtc(RoomModel.UnixTimeStarted), DateTime.UtcNow);
if (eventModel.OccursAtTick <= currentTick.GetTick())
{
return(new SubmitGameEventResponse()
{
Status = ResponseFactory.createResponse(ResponseType.INVALID_REQUEST),
});;
}
// TODO: validate event.
HashEntry[] entries = new[]
{
new HashEntry(eventModel.EventId, eventModel.ToByteArray()),
};
await RedisConnector.Redis.HashSetAsync(GameEventsKey(), entries);
await RedisConnector.Redis.SetAddAsync(UserGameEventsKey(player), eventModel.EventId);
return(new SubmitGameEventResponse()
{
Status = ResponseFactory.createResponse(ResponseType.SUCCESS),
EventId = eventModel.EventId,
});
}
public void Setup()
{
_p = new Player("Player 1");
List <Player> playerlist = new List <Player>();
playerlist.Add(_p);
GameConfiguration config = testUtils.GetDefaultGameConfiguration(playerlist);
config.MapConfiguration.OutpostsPerPlayer = 12;
_game = new Game(config);
_tm = _game.TimeMachine;
_o1 = _tm.GetState().GetPlayerOutposts(_p)[0];
_o2 = _tm.GetState().GetPlayerOutposts(_p)[1];
_model1 = new GameEventModel()
{
EventData = new DrillMineEventData()
{
SourceId = _o1.GetComponent <IdentityManager>().GetId()
}.ToByteString(),
Id = Guid.NewGuid().ToString(),
EventType = EventType.DrillMineEvent,
OccursAtTick = 10
};
_model2 = new GameEventModel()
{
EventData = new DrillMineEventData()
{
SourceId = _o2.GetComponent <IdentityManager>().GetId()
}.ToByteString(),
Id = Guid.NewGuid().ToString(),
EventType = EventType.DrillMineEvent,
OccursAtTick = 20
};
}
public override GameEventModel ToGameEventModel()
{
GameEventModel baseModel = GetBaseGameEventModel();
baseModel.EventData = GetEventData().ToByteString();
return(baseModel);
}
public async Task <SubmitGameEventResponse> AddPlayerGameEvent(DbUserModel player, GameEventRequest request)
{
GameEventModel eventModel = toGameEventModel(player, request);
// Ensure the event happens after current time.
GameTick currentTick = new GameTick(DateTime.FromFileTimeUtc(GameConfiguration.UnixTimeStarted), DateTime.UtcNow);
if (eventModel.OccursAtTick <= currentTick.GetTick())
{
return(new SubmitGameEventResponse()
{
Status = ResponseFactory.createResponse(ResponseType.INVALID_REQUEST),
});;
}
// TODO: validate event.
await MongoConnector.GetGameEventCollection().InsertOneAsync(new GameEventModelMapper(eventModel));
return(new SubmitGameEventResponse()
{
Status = ResponseFactory.createResponse(ResponseType.SUCCESS),
EventId = eventModel.Id,
});
}
public async Task <DeleteGameEventResponse> RemovePlayerGameEvent(RedisUserModel player, string eventId)
{
Guid parsedGuid;
try
{
parsedGuid = Guid.Parse(eventId);
}
catch (FormatException)
{
return(new DeleteGameEventResponse()
{
Status = ResponseFactory.createResponse(ResponseType.GAME_EVENT_DOES_NOT_EXIST)
});
}
// Get the event to check some things...
RedisValue eventData = await RedisConnector.Redis.HashGetAsync(GameEventsKey(), parsedGuid.ToString());
if (!eventData.HasValue)
{
return(new DeleteGameEventResponse()
{
Status = ResponseFactory.createResponse(ResponseType.GAME_EVENT_DOES_NOT_EXIST)
});;
}
// Determine if the event has already passed.
GameEventModel gameEvent = GameEventModel.Parser.ParseFrom(eventData);
GameTick currentTick = new GameTick(DateTime.FromFileTimeUtc(RoomModel.UnixTimeStarted), DateTime.UtcNow);
if (gameEvent.OccursAtTick <= currentTick.GetTick())
{
return(new DeleteGameEventResponse()
{
Status = ResponseFactory.createResponse(ResponseType.INVALID_REQUEST)
});
}
if (gameEvent.IssuedBy != player.UserModel.Id)
{
return(new DeleteGameEventResponse()
{
Status = ResponseFactory.createResponse(ResponseType.PERMISSION_DENIED)
});
}
// Remove game Event
await RedisConnector.Redis.SetRemoveAsync(UserGameEventsKey(player), parsedGuid.ToString());
await RedisConnector.Redis.HashDeleteAsync(GameEventsKey(), parsedGuid.ToString());
return(new DeleteGameEventResponse()
{
Status = ResponseFactory.createResponse(ResponseType.SUCCESS),
});
}
public async Task <SubmitGameEventResponse> UpdateGameEvent(RedisUserModel player, UpdateGameEventRequest request)
{
GameEventModel gameEvent = await GetGameEventFromGuid(request.EventId);
if (gameEvent == null)
{
return(new SubmitGameEventResponse()
{
Status = ResponseFactory.createResponse(ResponseType.GAME_EVENT_DOES_NOT_EXIST)
});
}
if (gameEvent.IssuedBy != player.UserModel.Id)
{
return(new SubmitGameEventResponse()
{
Status = ResponseFactory.createResponse(ResponseType.PERMISSION_DENIED)
});
}
// Ensure the event happens after current time.
GameTick currentTick = new GameTick(DateTime.FromFileTimeUtc(RoomModel.UnixTimeStarted), DateTime.UtcNow);
if (request.EventData.OccursAtTick <= currentTick.GetTick())
{
return(new SubmitGameEventResponse()
{
Status = ResponseFactory.createResponse(ResponseType.INVALID_REQUEST)
});
}
// TODO: validate event.
gameEvent.EventData = request.EventData.EventData;
gameEvent.OccursAtTick = request.EventData.OccursAtTick;
HashEntry[] entries = new[]
{
new HashEntry(gameEvent.EventId, gameEvent.ToByteArray()),
};
await RedisConnector.Redis.HashSetAsync(GameEventsKey(), entries);
await RedisConnector.Redis.SetAddAsync(UserGameEventsKey(player), gameEvent.EventId);
return(new SubmitGameEventResponse()
{
Status = ResponseFactory.createResponse(ResponseType.SUCCESS),
EventId = gameEvent.EventId,
});
}
public IHttpActionResult CreateEvent([FromBody] GameEventModel gameEventModel)
{
try {
var gameEntity = StatsService.Games.Get(gameEventModel.GameId);
var playerEntity = StatsService.Players.Get(gameEventModel.PlayerId);
var pointValue = gameEventModel.PointValue;
var gameEventEntity = ModelFactory.Create(gameEntity, playerEntity, pointValue);
StatsService.Events.Insert(gameEventEntity);
return(Created(string.Format("http://localhost:13362/api/game/{0}", gameEntity.ID), gameEventModel));
} catch (Exception ex) {
return(InternalServerError(ex));
}
}
public static PlayerTriggeredEvent parseGameEvent(GameEventModel model)
{
switch (model.EventType)
{
case EventType.LaunchEvent:
return(new LaunchEvent(model));
case EventType.ToggleShieldEvent:
return(new ToggleShieldEvent(model));
case EventType.UnknownEvent:
return(null);
default:
return(null);
}
}
public async Task <SubmitGameEventResponse> UpdateGameEvent(DbUserModel player, UpdateGameEventRequest request)
{
GameEventModel gameEvent = await GetGameEventFromGuid(request.EventId);
if (gameEvent == null)
{
return(new SubmitGameEventResponse()
{
Status = ResponseFactory.createResponse(ResponseType.GAME_EVENT_DOES_NOT_EXIST)
});
}
if (gameEvent.IssuedBy != player.UserModel.Id)
{
return(new SubmitGameEventResponse()
{
Status = ResponseFactory.createResponse(ResponseType.PERMISSION_DENIED)
});
}
// Ensure the event happens after current time.
GameTick currentTick = new GameTick(DateTime.FromFileTimeUtc(GameConfiguration.UnixTimeStarted), DateTime.UtcNow);
if (request.EventData.OccursAtTick <= currentTick.GetTick())
{
return(new SubmitGameEventResponse()
{
Status = ResponseFactory.createResponse(ResponseType.INVALID_REQUEST)
});
}
// TODO: validate event.
// Overwrite data with request data.
gameEvent.EventData = request.EventData.EventData;
gameEvent.OccursAtTick = request.EventData.OccursAtTick;
MongoConnector.GetGameEventCollection().ReplaceOne((it => it.RoomId == GameConfiguration.Id), new GameEventModelMapper(gameEvent));
return(new SubmitGameEventResponse()
{
Status = ResponseFactory.createResponse(ResponseType.SUCCESS),
EventId = gameEvent.Id,
});
}
public LaunchEvent(GameEventModel launchData) : base(launchData)
{
}
protected PlayerTriggeredEvent(GameEventModel model)
{
this.Model = model;
}
public ToggleShieldEvent(GameEventModel model) : base(model)
{
}
public DrillMineEvent(GameEventModel miningData) : base(miningData)
{
}
