private bool LookupCharacterPosition(
RequestCache requestCache,
out string result_code)
{
bool success;
CharacterQueries.GetCharacterPosition(
requestCache.DatabaseContext,
m_character_id,
out m_current_room_key,
out m_current_character_position,
out m_current_character_angle);
// Make sure the character's current game id is valid
m_game_id = m_current_room_key.game_id;
if (m_game_id >= 0)
{
result_code = SuccessMessages.GENERAL_SUCCESS;
success = true;
}
else
{
result_code = ErrorMessages.NOT_BOUND;
success = false;
}
return(success);
}
private TypedFlags <eBindGameAction> LookupCharacterData(
RequestCache requestCache)
{
TypedFlags <eBindGameAction> actionFlags = new TypedFlags <eBindGameAction>();
actionFlags.Clear();
// Get the current state of the character before moving them to another game
m_character_state = CharacterQueries.GetFullCharacterState(requestCache.DatabaseContext, m_character_id);
// Get the previous game this character was a part of, if any
m_previous_game_id = m_character_state.game_id;
// Only bother doing anything if the character isn't already bound to this game
if (m_previous_game_id != m_game_id)
{
if (m_previous_game_id != -1)
{
actionFlags.Set(eBindGameAction.leaveGame, true);
}
actionFlags.Set(eBindGameAction.joinGame, true);
}
return(actionFlags);
}
protected override bool ProcessRequestInternal(
RequestCache requestCache,
out string result_code)
{
bool success = true;
result_code = SuccessMessages.GENERAL_SUCCESS;
CharacterQueries.UpdateCharacterLastPingTime(requestCache.DatabaseContext, m_character_id);
m_has_new_events = CharacterQueries.GetCharacterNewEventFlag(requestCache.DatabaseContext, m_character_id);
if (m_has_new_events)
{
success = LookupCharacterGameId(requestCache, out result_code);
if (success)
{
success = VerifyGameExists(requestCache, m_current_game_id, out result_code);
}
if (success)
{
LookupCharacterRecentEvents(requestCache);
}
}
return(success);
}
protected override bool ProcessRequestInternal(
RequestCache requestCache,
out string result_code)
{
bool success;
if (AccountQueries.VerifyCredentials(
requestCache.DatabaseContext,
m_username,
m_password,
out m_accountId,
out m_emailAddress,
out m_opsLevel,
out result_code))
{
CharacterQueries.GetCharacterIDList(requestCache.DatabaseContext, m_accountId, out m_characterIDs);
result_code = SuccessMessages.GENERAL_SUCCESS;
success = true;
}
else
{
m_characterIDs = new int[] {};
success = false;
}
return(success);
}
public override void WriteDirtyObjectToDatabase(AsyncRPGDataContext db_context)
{
if (IsDirty)
{
CharacterQueries.UpdatePlayer(db_context, this);
IsDirty = false;
}
}
public Player GetPlayer(AsyncRPGDataContext db_context, int playerID)
{
Player player = null;
if (!m_players.TryGetValue(playerID, out player))
{
player = CharacterQueries.GetPlayer(db_context, playerID);
m_players.Add(playerID, player);
}
return(player);
}
private bool LookupCharacterState(out string result_code)
{
bool success =
CharacterQueries.GetFullCharacterState(
this.GetCurrentConnectionString(),
m_character_id,
out m_character_state,
out result_code);
result_code = success ? SuccessMessages.GENERAL_SUCCESS : ErrorMessages.DB_ERROR + "(Unable to retrieve character state)";
return(success);
}
protected override bool ProcessRequestInternal(
RequestCache requestCache,
out string result_code)
{
bool success = true;
result_code = SuccessMessages.GENERAL_SUCCESS;
CharacterQueries.GetCharacterPosition(
requestCache.DatabaseContext,
m_character_id,
out m_current_room_key,
out m_current_character_position,
out m_current_character_angle);
success = LookupCharacterGameID(requestCache, m_character_id, out m_game_id, out result_code);
if (success)
{
success = LookupWorld(requestCache, m_game_id, out m_world, out result_code);
}
if (success)
{
success = m_world.GetRoom(requestCache.DatabaseContext, m_current_room_key, out m_room, out result_code);
}
if (success)
{
success = VerifyNavMeshConnectivity(out result_code);
}
if (success)
{
success = UpdateCharacterPosition(requestCache, out result_code);
}
if (success)
{
PostCharacterMovedEvent(requestCache);
success = ComputeAIResponse(requestCache, out result_code);
}
if (success)
{
success = PingCharacter(requestCache, m_character_id, out m_result_event_list, out result_code);
}
return(success);
}
public IEnumerable <Player> GetPlayers(AsyncRPGDataContext db_context)
{
if (!m_allPlayersCached)
{
foreach (Player player in CharacterQueries.GetPlayers(db_context, m_roomKey))
{
if (!m_players.ContainsKey(player.ID))
{
m_players.Add(player.ID, player);
}
}
}
return(m_players.Values);
}
public string GetCharacterFullState(int character_id)
{
CharacterStateResponse response = new CharacterStateResponse();
if (RestUtilities.ValidateJSONRequestHasAuthenticatedSession(Session, out response.result))
{
if (CharacterQueries.GetFullCharacterState(
ApplicationConstants.CONNECTION_STRING,
character_id,
out response.character_state,
out response.result))
{
response.result = SuccessMessages.GENERAL_SUCCESS;
}
}
return(JSONUtilities.SerializeJSONResponse <CharacterStateResponse>(response));
}
private bool LookupGameCharacterData(
RequestCache requestCache,
out string result_code)
{
bool success;
CharacterQueries.GetGameCharacterList(
requestCache.DatabaseContext,
m_game_id,
out m_characters);
m_my_character = Array.Find(m_characters, c => c.character_id == m_character_id);
success = (m_my_character != null);
result_code = success ? SuccessMessages.GENERAL_SUCCESS : ErrorMessages.DB_ERROR + "(My character not associated with game)";
return(success);
}
public string GetCharacterList(string username)
{
CharacterListResponse response = new CharacterListResponse();
if (RestUtilities.ValidateJSONRequestHasAuthenticatedSession(Session, out response.result) &&
RestUtilities.ValidateJSONRequestSessionLoggedInAsUser(Session, username, out response.result))
{
if (CharacterQueries.GetAccountCharacterList(
ApplicationConstants.CONNECTION_STRING,
RestUtilities.GetSessionAccountID(Session),
out response.character_list,
out response.result))
{
response.result = SuccessMessages.GENERAL_SUCCESS;
}
}
return(JSONUtilities.SerializeJSONResponse <CharacterListResponse>(response));
}
private bool LookupCharacterGameId(
RequestCache requestCache,
out string result_code)
{
bool success;
m_current_game_id = CharacterQueries.GetCharacterGameId(requestCache.DatabaseContext, m_character_id);
if (m_current_game_id != -1)
{
result_code = SuccessMessages.GENERAL_SUCCESS;
success = true;
}
else
{
result_code = ErrorMessages.INVALID_GAME;
success = false;
}
return(success);
}
public string GetCharacterPosition(
int character_id)
{
CharacterGetPositionResponse response = new CharacterGetPositionResponse();
if (RestUtilities.ValidateJSONRequestHasAuthenticatedSession(Session, out response.result) &&
RestUtilities.ValidateJSONRequestSessionOwnsCharacter(Session, character_id, out response.result))
{
RoomKey roomKey = null;
float response_x = 0.0f;
float response_y = 0.0f;
float response_z = 0.0f;
float response_angle = 0.0f;
if (!CharacterQueries.GetCharacterPosition(
ApplicationConstants.CONNECTION_STRING,
character_id,
out roomKey,
out response_x,
out response_y,
out response_z,
out response_angle))
{
response.x = (double)response_x;
response.y = (double)response_y;
response.z = (double)response_z;
response.angle = (double)response_angle;
response.game_id = -1;
response.room_x = 0;
response.room_y = 0;
response.room_z = 0;
response.angle = 0;
response.result = ErrorMessages.DB_ERROR;
}
}
return(JSONUtilities.SerializeJSONResponse <CharacterGetPositionResponse>(response));
}
private bool LookupCharacterGameID(
RequestCache requestCache,
out string result_code)
{
bool success;
// Get the game that the character currently belongs to
m_game_id = CharacterQueries.GetCharacterGameId(requestCache.DatabaseContext, m_character_id);
if (m_game_id >= 0)
{
result_code = SuccessMessages.GENERAL_SUCCESS;
success = true;
}
else
{
result_code = ErrorMessages.NOT_BOUND;
success = false;
}
return(success);
}
protected override bool ProcessRequestInternal(
RequestCache requestCache,
out string result_code)
{
int archetypeCount = EnumUtilities.GetEnumValues <GameConstants.eArchetype>().Count();
CharacterQueries.CreateCharacter(
requestCache.DatabaseContext,
m_account_id,
m_name,
m_gender,
m_archetype,
m_picture_id);
CharacterQueries.GetCharacterIDList(
requestCache.DatabaseContext,
m_account_id,
out m_characterIDs);
result_code = SuccessMessages.GENERAL_SUCCESS;
return(true);
}
private void LookupCharacterRecentEvents(
RequestCache requestCache)
{
int new_last_game_event_id = -1;
int last_game_event_id =
CharacterQueries.GetCharacterLastEventId(
requestCache.DatabaseContext, m_character_id);
CharacterQueries.ClearCharacterNewEventFlag(
requestCache.DatabaseContext, m_character_id);
GameEventQueries.GetGameEventsAfterId(
requestCache.DatabaseContext,
m_current_game_id,
last_game_event_id,
out m_game_events,
out new_last_game_event_id);
if (m_has_new_events && new_last_game_event_id != last_game_event_id)
{
CharacterQueries.UpdateCharacterLastEventId(
requestCache.DatabaseContext, m_character_id, new_last_game_event_id);
}
}
protected override bool ProcessRequestInternal(
RequestCache requestCache,
out string result_code)
{
bool success = true;
result_code = SuccessMessages.GENERAL_SUCCESS;
success = LookupCharacterState(out result_code);
if (success)
{
success = ClearPlayerFromCache(requestCache, out result_code);
}
if (success)
{
PostCharacterLeftGameEvent(requestCache);
CharacterQueries.DeleteCharacter(requestCache.DatabaseContext, m_character_id);
CharacterQueries.GetCharacterIDList(requestCache.DatabaseContext, m_account_id, out m_remaining_character_ids);
}
return(success);
}
override protected bool ProcessRequestInternal(
RequestCache requestCache,
out string result_code)
{
bool success = true;
bool is_touching_energy_tank = false;
result_code = SuccessMessages.GENERAL_SUCCESS;
CharacterQueries.GetCharacterPosition(
requestCache.DatabaseContext,
m_character_id,
out m_current_room_key,
out m_current_character_position,
out m_current_character_angle);
success = LookupCharacterGameID(requestCache, m_character_id, out m_game_id, out result_code);
if (success)
{
m_current_character_energy = CharacterQueries.GetCharacterEnergy(requestCache.DatabaseContext, m_character_id);
success = LookupWorld(requestCache, m_game_id, out m_world, out result_code);
}
if (success)
{
success = m_world.GetRoom(requestCache.DatabaseContext, m_current_room_key, out m_room, out result_code);
}
if (success)
{
// Goes to verifyNavMeshConnectivity if the character needs to move to reach the energy tank,
// Otherwise skips to updateEnergyTankState
// (Or failure if the energy tank can't be hacked)
success = VerifyEnergyTank(requestCache, out is_touching_energy_tank, out result_code);
}
if (success)
{
success = VerifyNavMeshConnectivity(out result_code);
if (success)
{
UpdateCharacterState(requestCache, out result_code);
}
if (success)
{
PostCharacterMovedEvent(requestCache);
}
}
if (success)
{
success = UpdateEnergyTankState(requestCache, out result_code);
}
if (success)
{
PostEnergyTankDrainedEvent(requestCache);
success = ComputeAIResponse(requestCache, out result_code);
}
if (success)
{
success = PingCharacter(requestCache, m_character_id, out m_result_event_list, out result_code);
}
return(success);
}
