private static void OnForwardLogicRequestMessageReceived(ForwardLogicRequestMessage message)
{
PiranhaMessage logicMessage = LogicMagicMessageFactory.Instance.CreateMessageByType(message.MessageType);
if (logicMessage == null)
{
throw new Exception("logicMessage should not be NULL!");
}
logicMessage.GetByteStream().SetByteArray(message.MessageBytes, message.MessageLength);
logicMessage.SetMessageVersion(message.MessageVersion);
logicMessage.Decode();
if (!logicMessage.IsServerToClientMessage())
{
switch (logicMessage.GetMessageType())
{
case AskForJoinableAlliancesListMessage.MESSAGE_TYPE:
ServerRequestManager.Create(new AvatarRequestMessage
{
AccountId = message.AccountId
}, ServerManager.GetDocumentSocket(9, message.AccountId), 5).OnComplete = args =>
{
SearchMessageManager.OnAvatarResponseMessageReceivedForJoinableAlliancesList(message, args);
};
break;
case SearchAlliancesMessage.MESSAGE_TYPE:
SearchMessageManager.OnSearchAlliancesMessageReceived((SearchAlliancesMessage)logicMessage, message);
break;
}
}
}
private void CreateChallengeReplay()
{
string battleLog = LogicJSONParser.CreateJSONString(this.m_logicGameMode.GetLevel().GetBattleLog().GenerateAttackerJSON());
ServerRequestManager.Create(new CreateReplayStreamRequestMessage
{
JSON = LogicJSONParser.CreateJSONString(this.m_logicGameMode.GetReplay().GetJson(), 1536)
}, ServerManager.GetNextSocket(11)).OnComplete = args =>
{
LogicLong replayId = null;
if (args.ErrorCode == ServerRequestError.Success && args.ResponseMessage.Success)
{
replayId = ((CreateReplayStreamResponseMessage)args.ResponseMessage).Id;
}
ServerMessageManager.SendMessage(new AllianceChallengeReportMessage
{
AccountId = this.m_challengeAllianceId,
StreamId = this.m_challengeStreamId,
ReplayId = replayId,
BattleLog = battleLog
}, 11);
};
}
private void OnHomeBattleReplayMessageReceived(HomeBattleReplayMessage message)
{
ServerRequestManager.Create(new LoadReplayStreamRequestMessage
{
Id = message.GetReplayId()
}, ServerManager.GetDocumentSocket(11, this.m_session.AccountId), 5).OnComplete = this.OnHomeBattleReplayLoaded;
}
public AllianceSession(StartServerSessionMessage message) : base(message)
{
this.LogicMessageManager = new LogicMessageManager(this);
ServerRequestManager.Create(new AvatarRequestMessage
{
AccountId = this.AccountId
}, ServerManager.GetDocumentSocket(9, this.AccountId)).OnComplete = this.OnAvatarReceived;
}
private static void OnGameSpectateLiveReplayMessageReceived(GameSpectateLiveReplayMessage message)
{
if (GameSessionManager.TryGet(message.SessionId, out GameSession session))
{
ServerRequestManager.Create(new LiveReplayAddSpectatorRequestMessage
{
LiveReplayId = message.LiveReplayId,
SlotId = message.IsEnemy ? 1 : 0,
SessionId = session.Id
}, ServerManager.GetDocumentSocket(9, message.LiveReplayId)).OnComplete = args =>
{
if (args.ErrorCode == ServerRequestError.Success && args.ResponseMessage.Success)
{
if (session.IsDestructed())
{
ServerMessageManager.SendMessage(new LiveReplayRemoveSpectatorMessage
{
AccountId = message.LiveReplayId,
SessionId = session.Id
}, 9);
}
else
{
session.DestructGameState();
session.SpectateLiveReplayId = message.LiveReplayId;
session.SpectateLiveReplaySlotId = message.IsEnemy ? 1 : 0;
}
}
else if (!session.IsDestructed())
{
LiveReplayFailedMessage liveReplayFailedMessage = new LiveReplayFailedMessage();
if (args.ErrorCode == ServerRequestError.Success)
{
LiveReplayAddSpectatorResponseMessage responseMessage = (LiveReplayAddSpectatorResponseMessage)args.ResponseMessage;
switch (responseMessage.ErrorCode)
{
case LiveReplayAddSpectatorResponseMessage.Reason.NOT_EXISTS:
liveReplayFailedMessage.SetReason(LiveReplayFailedMessage.Reason.GENERIC);
break;
case LiveReplayAddSpectatorResponseMessage.Reason.FULL:
liveReplayFailedMessage.SetReason(LiveReplayFailedMessage.Reason.NO_FREE_SLOTS);
break;
}
}
else
{
liveReplayFailedMessage.SetReason(LiveReplayFailedMessage.Reason.GENERIC);
}
session.SendPiranhaMessage(liveReplayFailedMessage, 1);
}
};
}
}
private static void OnNewAvatarStreamMessageReceived(CreateAvatarStreamMessage message)
{
if (GameAvatarManager.TryGet(message.AccountId, out GameAvatar document))
{
ServerRequestManager.Create(new CreateAvatarStreamRequestMessage
{
OwnerId = document.Id,
Entry = message.Entry
}, ServerManager.GetDocumentSocket(11, document.Id)).OnComplete = document.OnAvatarStreamCreated;
}
}
private void OnCreateAlliance(ServerRequestArgs args)
{
if (args.ErrorCode == ServerRequestError.Success)
{
CreateAllianceResponseMessage createAllianceResponseMessage = (CreateAllianceResponseMessage)args.ResponseMessage;
if (createAllianceResponseMessage.Success)
{
LogicLong avatarId = this.m_session.GameMode.GetPlayerAvatar().GetId();
ServerRequestManager.Create(new GameJoinAllianceRequestMessage
{
AccountId = avatarId,
AllianceId = createAllianceResponseMessage.AllianceId,
Created = true
}, ServerManager.GetDocumentSocket(9, avatarId)).OnComplete = this.OnGameAllianceJoin;
}
else
{
AllianceCreateFailedMessage allianceCreateFailedMessage = new AllianceCreateFailedMessage();
switch (createAllianceResponseMessage.ErrorReason)
{
case CreateAllianceResponseMessage.Reason.GENERIC:
allianceCreateFailedMessage.SetReason(AllianceCreateFailedMessage.Reason.GENERIC);
break;
case CreateAllianceResponseMessage.Reason.INVALID_DESCRIPTION:
allianceCreateFailedMessage.SetReason(AllianceCreateFailedMessage.Reason.INVALID_DESCRIPTION);
break;
case CreateAllianceResponseMessage.Reason.INVALID_NAME:
allianceCreateFailedMessage.SetReason(AllianceCreateFailedMessage.Reason.INVALID_NAME);
break;
case CreateAllianceResponseMessage.Reason.NAME_TOO_LONG:
allianceCreateFailedMessage.SetReason(AllianceCreateFailedMessage.Reason.NAME_TOO_LONG);
break;
case CreateAllianceResponseMessage.Reason.NAME_TOO_SHORT:
allianceCreateFailedMessage.SetReason(AllianceCreateFailedMessage.Reason.NAME_TOO_SHORT);
break;
}
this.m_session.SendPiranhaMessage(allianceCreateFailedMessage, 1);
}
}
else
{
AllianceCreateFailedMessage allianceCreateFailedMessage = new AllianceCreateFailedMessage();
allianceCreateFailedMessage.SetReason(AllianceCreateFailedMessage.Reason.GENERIC);
this.m_session.SendPiranhaMessage(allianceCreateFailedMessage, 1);
}
}
private void OnRequestJoinAllianceMessageReceived(RequestJoinAllianceMessage message)
{
if (this.CanJoinAlliance())
{
LogicLong allianceId = message.RemoveAllianceId();
ServerRequestManager.Create(new RequestAllianceJoinRequestMessage
{
Avatar = this.m_session.GameMode.GetPlayerAvatar(),
AllianceId = allianceId,
Message = message.GetMessage()
}, ServerManager.GetDocumentSocket(11, allianceId)).OnComplete = this.OnRequestAlliance;
}
}
public void BindAllianceServer()
{
ServerSocket socket = ServerManager.GetDocumentSocket(11, this.GameAvatar.LogicClientAvatar.GetAllianceId());
if (socket != null)
{
ServerRequestManager.Create(new BindServerSocketRequestMessage
{
ServerType = socket.ServerType,
ServerId = socket.ServerId,
SessionId = this.Id
}, this.m_sockets[1]);
}
}
private static void OnAllianceShareReplayMessageReceivedReceived(AllianceShareReplayMessage message)
{
if (AllianceManager.TryGet(message.AccountId, out Alliance alliance) && alliance.Members.TryGetValue(message.MemberId, out AllianceMemberEntry memberEntry))
{
ServerRequestManager.Create(new LoadAvatarStreamRequestMessage
{
Id = message.ReplayId
}, ServerManager.GetDocumentSocket(11, message.ReplayId)).OnComplete = args =>
{
if (args.ErrorCode == ServerRequestError.Success && args.ResponseMessage.Success)
{
LoadAvatarStreamResponseMessage responseMessage = (LoadAvatarStreamResponseMessage)args.ResponseMessage;
if (responseMessage.Entry.GetAvatarStreamEntryType() == AvatarStreamEntryType.ATTACKER_BATTLE_REPORT ||
responseMessage.Entry.GetAvatarStreamEntryType() == AvatarStreamEntryType.DEFENDER_BATTLE_REPORT)
{
BattleReportStreamEntry battleReportStreamEntry = (BattleReportStreamEntry)responseMessage.Entry;
ReplayStreamEntry replayStreamEntry = new ReplayStreamEntry();
AllianceStreamEntryUtil.SetSenderInfo(replayStreamEntry, memberEntry);
replayStreamEntry.SetAttack(responseMessage.Entry.GetAvatarStreamEntryType() == AvatarStreamEntryType.ATTACKER_BATTLE_REPORT);
replayStreamEntry.SetBattleLogJSON(battleReportStreamEntry.GetBattleLogJSON());
replayStreamEntry.SetMajorVersion(battleReportStreamEntry.GetMajorVersion());
replayStreamEntry.SetBuildVersion(battleReportStreamEntry.GetBuildVersion());
replayStreamEntry.SetContentVersion(battleReportStreamEntry.GetContentVersion());
replayStreamEntry.SetReplayId(battleReportStreamEntry.GetReplayId());
replayStreamEntry.SetReplayShardId(battleReportStreamEntry.GetReplayShardId());
replayStreamEntry.SetOpponentName(battleReportStreamEntry.GetSenderName());
string replayMessage = message.Message;
if (replayMessage != null && replayMessage.Length > 128)
{
replayMessage = replayMessage.Substring(0, 128);
}
replayStreamEntry.SetMessage(replayMessage);
StreamManager.Create(alliance.Id, replayStreamEntry);
alliance.AddStreamEntry(replayStreamEntry);
AllianceManager.Save(alliance);
}
}
};
}
}
public void LoadGameState(GameState state)
{
if (this.GameState != null)
{
throw new Exception("GameSession.loadGameState: current game state should be NULL");
}
state.Home.GetCompressibleGlobalJSON().Set(ResourceManager.SERVER_SAVE_FILE_GLOBAL);
state.Home.GetCompressibleCalendarJSON().Set(ResourceManager.SERVER_SAVE_FILE_CALENDAR);
this.GameState = state;
if (state.GetSimulationServiceNodeType() == SimulationServiceNodeType.BATTLE)
{
ServerRequestManager.Create(new BindServerSocketRequestMessage
{
SessionId = this.Id,
ServerType = 27,
ServerId = -1
}, this.m_sockets[1], 10).OnComplete = args =>
{
if (args.ErrorCode == ServerRequestError.Success && args.ResponseMessage.Success)
{
BindServerSocketResponseMessage responseMessage = (BindServerSocketResponseMessage)args.ResponseMessage;
this.m_sockets[responseMessage.ServerType] = ServerManager.GetSocket(responseMessage.ServerType, responseMessage.ServerId);
this.SendMessage(new GameStateDataMessage
{
State = state
}, responseMessage.ServerType);
}
else
{
Logging.Error("GameSession.loadGameState: unable to bind a battle server to the session.");
this.SendMessage(new StopSessionMessage(), 1);
}
};
}
else
{
this.SendMessage(new GameStateDataMessage
{
State = state
}, 10);
}
}
private void OnJoinAllianceMessageReceived(JoinAllianceMessage message)
{
if (!this.CanJoinAlliance())
{
AllianceJoinFailedMessage allianceJoinFailedMessage = new AllianceJoinFailedMessage();
allianceJoinFailedMessage.SetReason(AllianceJoinFailedMessage.Reason.ALREADY_IN_ALLIANCE);
this.m_session.SendPiranhaMessage(allianceJoinFailedMessage, 1);
return;
}
LogicLong avatarId = this.m_session.GameMode.GetPlayerAvatar().GetId();
ServerRequestManager.Create(new GameJoinAllianceRequestMessage
{
AccountId = avatarId,
AllianceId = message.RemoveAllianceId()
}, ServerManager.GetDocumentSocket(9, avatarId)).OnComplete = this.OnGameAllianceJoin;
}
private void OnCreateAllianceMessageReceived(CreateAllianceMessage message)
{
if (!this.CanJoinAlliance())
{
AllianceCreateFailedMessage allianceCreateFailedMessage = new AllianceCreateFailedMessage();
allianceCreateFailedMessage.SetReason(AllianceCreateFailedMessage.Reason.GENERIC);
this.m_session.SendPiranhaMessage(allianceCreateFailedMessage, 1);
return;
}
LogicClientAvatar playerAvatar = this.m_session.GameMode.GetPlayerAvatar();
if (playerAvatar.GetResourceCount(LogicDataTables.GetGlobals().GetAllianceCreateResourceData()) < LogicDataTables.GetGlobals().GetAllianceCreateCost())
{
AllianceCreateFailedMessage allianceCreateFailedMessage = new AllianceCreateFailedMessage();
allianceCreateFailedMessage.SetReason(AllianceCreateFailedMessage.Reason.GENERIC);
this.m_session.SendPiranhaMessage(allianceCreateFailedMessage, 1);
return;
}
ServerSocket allianceServer = ServerManager.GetNextSocket(11);
if (allianceServer != null)
{
ServerRequestManager.Create(new CreateAllianceRequestMessage
{
AllianceName = message.GetAllianceName(),
AllianceDescription = message.GetAllianceDescription(),
AllianceType = (AllianceType)message.GetAllianceType(),
AllianceBadgeId = message.GetAllianceBadgeId(),
RequiredScore = message.GetRequiredScore(),
RequiredDuelScore = message.GetRequiredDuelScore(),
WarFrequency = message.GetWarFrequency(),
PublicWarLog = message.GetPublicWarLog(),
ArrangedWarEnabled = message.GetArrangedWarEnabled()
}, allianceServer).OnComplete = this.OnCreateAlliance;
}
else
{
AllianceCreateFailedMessage allianceCreateFailedMessage = new AllianceCreateFailedMessage();
allianceCreateFailedMessage.SetReason(AllianceCreateFailedMessage.Reason.GENERIC);
this.m_session.SendPiranhaMessage(allianceCreateFailedMessage, 1);
}
}
public GameSession(StartServerSessionMessage message) : base(message)
{
this.LogicMessageManager = new LogicMessageManager(this);
this.GameAvatar = GameAvatarManager.TryGet(this.AccountId, out GameAvatar document) ? document : GameAvatarManager.Create(this.AccountId);
if (this.GameAvatar.CurrentSession != null)
{
GameSessionManager.Remove(this.GameAvatar.CurrentSession.Id);
}
this.GameAvatar.CurrentSession = this;
GameMatchmakingManager.Dequeue(this.GameAvatar);
ServerRequestManager.Create(new BindServerSocketRequestMessage
{
SessionId = this.Id,
ServerType = 10,
ServerId = -1
}, this.m_sockets[1], 10).OnComplete = this.OnHomeServerBound;
}
private void OnJoinAllianceUsingInvitationMessageReceived(JoinAllianceUsingInvitationMessage message)
{
if (this.CanJoinAlliance())
{
ServerRequestManager.Create(new LoadAvatarStreamRequestMessage
{
Id = message.GetAvatarStreamEntryId()
}, ServerManager.GetDocumentSocket(11, this.m_session.AccountId), 5).OnComplete = args =>
{
if (this.m_session.IsDestructed())
{
return;
}
if (args.ErrorCode == ServerRequestError.Success && args.ResponseMessage.Success)
{
LoadAvatarStreamResponseMessage responseMessage = (LoadAvatarStreamResponseMessage)args.ResponseMessage;
AllianceInvitationAvatarStreamEntry allianceInvitationAvatarStreamEntry = (AllianceInvitationAvatarStreamEntry)responseMessage.Entry;
LogicLong allianceId = allianceInvitationAvatarStreamEntry.GetAllianceId();
ServerRequestManager.Create(new GameJoinAllianceRequestMessage
{
AccountId = this.m_session.AccountId,
AllianceId = allianceId,
AvatarStreamId = allianceInvitationAvatarStreamEntry.GetId(),
Invited = true
}, ServerManager.GetDocumentSocket(9, this.m_session.AccountId)).OnComplete = this.OnGameAllianceJoin;
}
else
{
AllianceJoinFailedMessage allianceJoinFailedMessage = new AllianceJoinFailedMessage();
allianceJoinFailedMessage.SetReason(AllianceJoinFailedMessage.Reason.ALREADY_IN_ALLIANCE);
this.m_session.SendPiranhaMessage(allianceJoinFailedMessage, 1);
}
};
}
else
{
AllianceJoinFailedMessage allianceJoinFailedMessage = new AllianceJoinFailedMessage();
allianceJoinFailedMessage.SetReason(AllianceJoinFailedMessage.Reason.ALREADY_IN_ALLIANCE);
this.m_session.SendPiranhaMessage(allianceJoinFailedMessage, 1);
}
}
private static async void OnSearchAlliancesMessageReceived(SearchAlliancesMessage message, ForwardLogicRequestMessage requestMessage)
{
if (message.IsJoinableOnly())
{
ServerRequestManager.Create(new AvatarRequestMessage
{
AccountId = requestMessage.AccountId
}, ServerManager.GetDocumentSocket(9, requestMessage.AccountId), 5).OnComplete = async args =>
{
LogicClientAvatar playerAvatar = null;
if (args.ErrorCode == ServerRequestError.Success && args.ResponseMessage.Success)
{
playerAvatar = ((AvatarResponseMessage)args.ResponseMessage).LogicClientAvatar;
}
AllianceListMessage allianceListMessage = new AllianceListMessage();
allianceListMessage.SetAlliances(await SearchManager.SearchAlliances(message, playerAvatar));
allianceListMessage.SetBookmarkList(new LogicArrayList <LogicLong>());
allianceListMessage.SetSearchString(message.GetSearchString());
ServerMessageManager.SendMessage(SearchMessageManager.CreateForwardLogicMessage(allianceListMessage, requestMessage.SessionId),
ServerManager.GetProxySocket(requestMessage.SessionId));
};
}
else
{
AllianceListMessage allianceListMessage = new AllianceListMessage();
allianceListMessage.SetAlliances(await SearchManager.SearchAlliances(message, null));
allianceListMessage.SetBookmarkList(new LogicArrayList <LogicLong>());
allianceListMessage.SetSearchString(message.GetSearchString());
ServerMessageManager.SendMessage(SearchMessageManager.CreateForwardLogicMessage(allianceListMessage, requestMessage.SessionId),
ServerManager.GetProxySocket(requestMessage.SessionId));
}
}
private static void OnGameJoinAllianceRequestMessageReceived(GameJoinAllianceRequestMessage message)
{
if (GameAvatarManager.TryGet(message.AccountId, out GameAvatar document))
{
if (document.LogicClientAvatar.IsInAlliance() || document.HasServerCommandOfType(LogicCommandType.JOIN_ALLIANCE))
{
ServerRequestManager.SendResponse(new GameJoinAllianceResponseMessage
{
ErrorReason = GameJoinAllianceResponseMessage.Reason.ALREADY_IN_ALLIANCE
}, message);
return;
}
if (!document.LogicClientAvatar.HasAllianceCastle())
{
ServerRequestManager.SendResponse(new GameJoinAllianceResponseMessage
{
ErrorReason = GameJoinAllianceResponseMessage.Reason.NO_CASTLE
}, message);
return;
}
if (document.PendingAllianceJoinResponse || message.AvatarStreamId != null && document.AvatarStreamList.IndexOf(message.AvatarStreamId) == -1)
{
ServerRequestManager.SendResponse(new GameJoinAllianceResponseMessage
{
ErrorReason = GameJoinAllianceResponseMessage.Reason.GENERIC
}, message);
return;
}
document.PendingAllianceJoinResponse = true;
ServerRequestManager.Create(new AllianceJoinRequestMessage
{
AllianceId = message.AllianceId,
Avatar = document.LogicClientAvatar,
Created = message.Created,
Invited = message.Invited
}, ServerManager.GetDocumentSocket(11, message.AllianceId), 15).OnComplete = args =>
{
document.PendingAllianceJoinResponse = false;
if (args.ErrorCode == ServerRequestError.Success)
{
AllianceJoinResponseMessage allianceJoinResponseMessage = (AllianceJoinResponseMessage)args.ResponseMessage;
if (allianceJoinResponseMessage.Success)
{
if (message.AvatarStreamId != null)
{
document.RemoveAvatarStreamEntry(message.AvatarStreamId);
}
LogicJoinAllianceCommand logicJoinAllianceCommand = new LogicJoinAllianceCommand();
logicJoinAllianceCommand.SetAllianceData(allianceJoinResponseMessage.AllianceId, allianceJoinResponseMessage.AllianceName, allianceJoinResponseMessage.AllianceBadgeId, allianceJoinResponseMessage.AllianceLevel, allianceJoinResponseMessage.Created);
document.AddServerCommand(logicJoinAllianceCommand);
ServerRequestManager.SendResponse(new GameJoinAllianceResponseMessage
{
Success = true
}, message);
}
else
{
GameJoinAllianceResponseMessage gameJoinAllianceResponseMessage = new GameJoinAllianceResponseMessage();
switch (allianceJoinResponseMessage.ErrorReason)
{
case AllianceJoinResponseMessage.Reason.GENERIC:
gameJoinAllianceResponseMessage.ErrorReason = GameJoinAllianceResponseMessage.Reason.GENERIC;
break;
case AllianceJoinResponseMessage.Reason.FULL:
gameJoinAllianceResponseMessage.ErrorReason = GameJoinAllianceResponseMessage.Reason.FULL;
break;
case AllianceJoinResponseMessage.Reason.CLOSED:
gameJoinAllianceResponseMessage.ErrorReason = GameJoinAllianceResponseMessage.Reason.CLOSED;
break;
case AllianceJoinResponseMessage.Reason.SCORE:
gameJoinAllianceResponseMessage.ErrorReason = GameJoinAllianceResponseMessage.Reason.SCORE;
break;
case AllianceJoinResponseMessage.Reason.BANNED:
gameJoinAllianceResponseMessage.ErrorReason = GameJoinAllianceResponseMessage.Reason.BANNED;
break;
}
ServerRequestManager.SendResponse(gameJoinAllianceResponseMessage, message);
}
}
else
{
ServerRequestManager.SendResponse(new GameJoinAllianceResponseMessage
{
ErrorReason = GameJoinAllianceResponseMessage.Reason.GENERIC
}, message);
}
};
}
}
private void CreateBattleReport()
{
LogicClientAvatar attacker = (LogicClientAvatar)this.m_logicGameMode.GetLevel().GetVisitorAvatar();
LogicClientAvatar defender = (LogicClientAvatar)this.m_logicGameMode.GetLevel().GetHomeOwnerAvatar();
string attackerBattleLogJSON = LogicJSONParser.CreateJSONString(this.m_logicGameMode.GetLevel().GetBattleLog().GenerateAttackerJSON());
string defenderBattleLogJSON = LogicJSONParser.CreateJSONString(this.m_logicGameMode.GetLevel().GetBattleLog().GenerateDefenderJSON());
ServerRequestManager.Create(new CreateReplayStreamRequestMessage
{
JSON = LogicJSONParser.CreateJSONString(this.m_logicGameMode.GetReplay().GetJson(), 1536)
}, ServerManager.GetNextSocket(11)).OnComplete = args =>
{
LogicLong replayId = null;
if (args.ErrorCode == ServerRequestError.Success && args.ResponseMessage.Success)
{
replayId = ((CreateReplayStreamResponseMessage)args.ResponseMessage).Id;
}
BattleReportStreamEntry attackerBattleReportStreamEntry = new BattleReportStreamEntry(AvatarStreamEntryType.ATTACKER_BATTLE_REPORT);
attackerBattleReportStreamEntry.SetSenderAvatarId(defender.GetId());
attackerBattleReportStreamEntry.SetSenderLevel(defender.GetExpLevel());
attackerBattleReportStreamEntry.SetSenderLeagueType(defender.GetLeagueType());
attackerBattleReportStreamEntry.SetSenderName(defender.GetName());
attackerBattleReportStreamEntry.SetMajorVersion(LogicVersion.MAJOR_VERSION);
attackerBattleReportStreamEntry.SetBuildVersion(LogicVersion.BUILD_VERSION);
attackerBattleReportStreamEntry.SetContentVersion(ResourceManager.GetContentVersion());
attackerBattleReportStreamEntry.SetBattleLogJSON(attackerBattleLogJSON);
attackerBattleReportStreamEntry.SetReplayId(replayId);
ServerRequestManager.Create(new CreateAvatarStreamRequestMessage
{
OwnerId = attacker.GetId(),
Entry = attackerBattleReportStreamEntry
}, ServerManager.GetDocumentSocket(11, attacker.GetId())).OnComplete = args2 =>
{
if (args2.ErrorCode == ServerRequestError.Success && args2.ResponseMessage.Success)
{
ServerMessageManager.SendMessage(new CreateAvatarStreamMessage
{
AccountId = attacker.GetId(),
Entry = ((CreateAvatarStreamResponseMessage)args2.ResponseMessage).Entry
}, 9);
}
};
if (this.m_gameDefenderLocked)
{
BattleReportStreamEntry defenderBattleReportStreamEntry = new BattleReportStreamEntry(AvatarStreamEntryType.DEFENDER_BATTLE_REPORT);
defenderBattleReportStreamEntry.SetSenderAvatarId(attacker.GetId());
defenderBattleReportStreamEntry.SetSenderLevel(attacker.GetExpLevel());
defenderBattleReportStreamEntry.SetSenderLeagueType(attacker.GetLeagueType());
defenderBattleReportStreamEntry.SetSenderName(attacker.GetName());
defenderBattleReportStreamEntry.SetMajorVersion(LogicVersion.MAJOR_VERSION);
defenderBattleReportStreamEntry.SetBuildVersion(LogicVersion.BUILD_VERSION);
defenderBattleReportStreamEntry.SetContentVersion(ResourceManager.GetContentVersion());
defenderBattleReportStreamEntry.SetBattleLogJSON(defenderBattleLogJSON);
defenderBattleReportStreamEntry.SetReplayId(replayId);
ServerRequestManager.Create(new CreateAvatarStreamRequestMessage
{
OwnerId = defender.GetId(),
Entry = defenderBattleReportStreamEntry
}, ServerManager.GetDocumentSocket(11, defender.GetId())).OnComplete = args2 =>
{
if (args2.ErrorCode == ServerRequestError.Success && args2.ResponseMessage.Success)
{
ServerMessageManager.SendMessage(new CreateAvatarStreamMessage
{
AccountId = defender.GetId(),
Entry = ((CreateAvatarStreamResponseMessage)args2.ResponseMessage).Entry
}, 9);
}
};
}
};
}
private void OnRespondToAllianceJoinRequestMessageReceived(RespondToAllianceJoinRequestMessage message)
{
if (this.m_session.Alliance != null)
{
Alliance alliance = this.m_session.Alliance;
AllianceMemberEntry memberEntry = alliance.Members[this.m_session.AccountId];
if (memberEntry.GetAllianceRole() == LogicAvatarAllianceRole.MEMBER)
{
AllianceInvitationSendFailedMessage allianceInvitationSendFailedMessage = new AllianceInvitationSendFailedMessage();
allianceInvitationSendFailedMessage.SetReason(AllianceInvitationSendFailedMessage.Reason.NO_RIGHTS);
this.m_session.SendPiranhaMessage(allianceInvitationSendFailedMessage, 1);
return;
}
LogicLong streamId = message.GetStreamEntryId();
if (alliance.StreamEntryList.IndexOf(streamId) != -1)
{
StreamEntry streamEntry = StreamManager.GetAllianceStream(message.GetStreamEntryId());
if (streamEntry.GetStreamEntryType() == StreamEntryType.JOIN_REQUEST)
{
JoinRequestAllianceStreamEntry joinRequestAllianceStreamEntry = (JoinRequestAllianceStreamEntry)streamEntry;
if (joinRequestAllianceStreamEntry.GetState() == 1)
{
if (message.IsAccepted())
{
ServerRequestManager.Create(new GameJoinAllianceRequestMessage
{
AccountId = joinRequestAllianceStreamEntry.GetSenderAvatarId(),
AllianceId = alliance.Id,
Invited = true
}, ServerManager.GetDocumentSocket(9, joinRequestAllianceStreamEntry.GetSenderAvatarId())).OnComplete = args =>
{
if (this.m_session.IsDestructed())
{
return;
}
if (args.ErrorCode == ServerRequestError.Success)
{
if (args.ResponseMessage.Success)
{
joinRequestAllianceStreamEntry.SetState(2);
joinRequestAllianceStreamEntry.SetResponderName(memberEntry.GetName());
alliance.UpdateStreamEntry(joinRequestAllianceStreamEntry);
StreamManager.Save(joinRequestAllianceStreamEntry);
}
else
{
GameJoinAllianceResponseMessage gameJoinAllianceResponseMessage = (GameJoinAllianceResponseMessage)args.ResponseMessage;
AllianceInvitationSendFailedMessage allianceInvitationSendFailedMessage = new AllianceInvitationSendFailedMessage();
switch (gameJoinAllianceResponseMessage.ErrorReason)
{
case GameJoinAllianceResponseMessage.Reason.NO_CASTLE:
allianceInvitationSendFailedMessage.SetReason(AllianceInvitationSendFailedMessage.Reason.NO_CASTLE);
if (joinRequestAllianceStreamEntry.GetState() == 1)
{
alliance.RemoveStreamEntry(joinRequestAllianceStreamEntry.GetId());
AllianceManager.Save(alliance);
}
break;
case GameJoinAllianceResponseMessage.Reason.ALREADY_IN_ALLIANCE:
allianceInvitationSendFailedMessage.SetReason(AllianceInvitationSendFailedMessage.Reason.ALREADY_IN_ALLIANCE);
if (joinRequestAllianceStreamEntry.GetState() == 1)
{
alliance.RemoveStreamEntry(joinRequestAllianceStreamEntry.GetId());
AllianceManager.Save(alliance);
}
break;
default:
allianceInvitationSendFailedMessage.SetReason(AllianceInvitationSendFailedMessage.Reason.GENERIC);
break;
}
this.m_session.SendPiranhaMessage(allianceInvitationSendFailedMessage, 1);
}
}
else
{
AllianceInvitationSendFailedMessage allianceInvitationSendFailedMessage = new AllianceInvitationSendFailedMessage();
allianceInvitationSendFailedMessage.SetReason(AllianceInvitationSendFailedMessage.Reason.GENERIC);
this.m_session.SendPiranhaMessage(allianceInvitationSendFailedMessage, 1);
}
};
}
else
{
joinRequestAllianceStreamEntry.SetState(0);
joinRequestAllianceStreamEntry.SetResponderName(memberEntry.GetName());
alliance.UpdateStreamEntry(joinRequestAllianceStreamEntry);
StreamManager.Save(joinRequestAllianceStreamEntry);
JoinAllianceResponseAvatarStreamEntry joinAllianceResponseAvatarStreamEntry = new JoinAllianceResponseAvatarStreamEntry();
joinAllianceResponseAvatarStreamEntry.SetSenderAvatarId(memberEntry.GetAvatarId());
joinAllianceResponseAvatarStreamEntry.SetSenderHomeId(memberEntry.GetHomeId());
joinAllianceResponseAvatarStreamEntry.SetSenderName(memberEntry.GetName());
joinAllianceResponseAvatarStreamEntry.SetSenderLevel(memberEntry.GetExpLevel());
joinAllianceResponseAvatarStreamEntry.SetSenderLeagueType(memberEntry.GetLeagueType());
joinAllianceResponseAvatarStreamEntry.SetAllianceId(alliance.Id);
joinAllianceResponseAvatarStreamEntry.SetAllianceName(alliance.Header.GetAllianceName());
joinAllianceResponseAvatarStreamEntry.SetAllianceBadgeId(alliance.Header.GetAllianceBadgeId());
ServerMessageManager.SendMessage(new CreateAvatarStreamMessage
{
AccountId = joinRequestAllianceStreamEntry.GetSenderAvatarId(),
Entry = joinAllianceResponseAvatarStreamEntry
}, 9);
}
}
}
}
}
}
private void OnSendAllianceInvitationMessageReceived(SendAllianceInvitationMessage message)
{
if (this.m_session.Alliance != null)
{
Alliance alliance = this.m_session.Alliance;
AllianceMemberEntry memberEntry = alliance.Members[this.m_session.AccountId];
if (memberEntry.GetAllianceRole() == LogicAvatarAllianceRole.MEMBER)
{
AllianceInvitationSendFailedMessage allianceInvitationSendFailedMessage = new AllianceInvitationSendFailedMessage();
allianceInvitationSendFailedMessage.SetReason(AllianceInvitationSendFailedMessage.Reason.NO_RIGHTS);
this.m_session.SendPiranhaMessage(allianceInvitationSendFailedMessage, 1);
return;
}
if (memberEntry.GetAllianceRole() == LogicAvatarAllianceRole.ELDER)
{
AllianceInvitationSendFailedMessage allianceInvitationSendFailedMessage = new AllianceInvitationSendFailedMessage();
allianceInvitationSendFailedMessage.SetReason(AllianceInvitationSendFailedMessage.Reason.USER_BANNED);
this.m_session.SendPiranhaMessage(allianceInvitationSendFailedMessage, 1);
return;
}
AllianceInvitationAvatarStreamEntry allianceInvitationAvatarStreamEntry = new AllianceInvitationAvatarStreamEntry();
allianceInvitationAvatarStreamEntry.SetSenderAvatarId(memberEntry.GetAvatarId());
allianceInvitationAvatarStreamEntry.SetSenderHomeId(memberEntry.GetHomeId());
allianceInvitationAvatarStreamEntry.SetSenderName(memberEntry.GetName());
allianceInvitationAvatarStreamEntry.SetSenderLevel(memberEntry.GetExpLevel());
allianceInvitationAvatarStreamEntry.SetSenderLeagueType(memberEntry.GetLeagueType());
allianceInvitationAvatarStreamEntry.SetAllianceId(alliance.Id);
allianceInvitationAvatarStreamEntry.SetAllianceName(alliance.Header.GetAllianceName());
allianceInvitationAvatarStreamEntry.SetAllianceBadgeId(alliance.Header.GetAllianceBadgeId());
allianceInvitationAvatarStreamEntry.SetAllianceLevel(alliance.Header.GetAllianceLevel());
ServerRequestManager.Create(new GameCreateAllianceInvitationRequestMessage
{
AccountId = message.GetAvatarId(),
Entry = allianceInvitationAvatarStreamEntry
}, ServerManager.GetDocumentSocket(9, message.GetAvatarId())).OnComplete = args =>
{
if (this.m_session.IsDestructed())
{
return;
}
if (args.ErrorCode == ServerRequestError.Success)
{
GameCreateAllianceInvitationResponseMessage responseMessage = (GameCreateAllianceInvitationResponseMessage)args.ResponseMessage;
if (responseMessage.Success)
{
this.m_session.SendPiranhaMessage(new AllianceInvitationSentOkMessage(), 1);
}
else
{
AllianceInvitationSendFailedMessage allianceInvitationSendFailedMessage = new AllianceInvitationSendFailedMessage();
switch (responseMessage.ErrorReason)
{
case GameCreateAllianceInvitationResponseMessage.Reason.GENERIC:
allianceInvitationSendFailedMessage.SetReason(AllianceInvitationSendFailedMessage.Reason.GENERIC);
break;
case GameCreateAllianceInvitationResponseMessage.Reason.NO_CASTLE:
allianceInvitationSendFailedMessage.SetReason(AllianceInvitationSendFailedMessage.Reason.NO_CASTLE);
break;
case GameCreateAllianceInvitationResponseMessage.Reason.ALREADY_IN_ALLIANCE:
allianceInvitationSendFailedMessage.SetReason(AllianceInvitationSendFailedMessage.Reason.ALREADY_IN_ALLIANCE);
break;
case GameCreateAllianceInvitationResponseMessage.Reason.ALREADY_HAS_AN_INVITE:
allianceInvitationSendFailedMessage.SetReason(AllianceInvitationSendFailedMessage.Reason.ALREADY_HAS_AN_INVITE);
break;
case GameCreateAllianceInvitationResponseMessage.Reason.HAS_TOO_MANY_INVITES:
allianceInvitationSendFailedMessage.SetReason(AllianceInvitationSendFailedMessage.Reason.HAS_TOO_MANY_INVITES);
break;
}
this.m_session.SendPiranhaMessage(allianceInvitationSendFailedMessage, 1);
}
}
else
{
AllianceInvitationSendFailedMessage allianceInvitationSendFailedMessage = new AllianceInvitationSendFailedMessage();
allianceInvitationSendFailedMessage.SetReason(AllianceInvitationSendFailedMessage.Reason.GENERIC);
this.m_session.SendPiranhaMessage(allianceInvitationSendFailedMessage, 1);
}
};
}
}
private async void LoginMessageReceived(LoginMessage message)
{
if (this.m_connection.State == ClientConnectionState.DEFAULT &&
this.CheckClientVersion(message.GetClientMajorVersion(), message.GetClientBuildVersion(), message.GetAppVersion(), message.GetResourceSha(), message.IsAndroidClient()) &&
this.CheckServerCapabilities())
{
this.m_connection.Messaging.SetScramblerSeed(message.GetScramblerSeed());
this.m_connection.SetState(ClientConnectionState.LOGIN);
AccountDocument accountDocument;
if (message.GetAccountId().IsZero() && message.GetPassToken() == null)
{
IOperationResult <ulong> incrementSeedResult = await ServerProxy.AccountDatabase.IncrementSeed();
if (!incrementSeedResult.Success)
{
LoginFailedMessage loginFailedMessage = new LoginFailedMessage();
loginFailedMessage.SetErrorCode(LoginFailedMessage.ErrorCode.SERVER_MAINTENANCE);
loginFailedMessage.SetReason("Internal server error");
this.SendMessage(loginFailedMessage);
return;
}
accountDocument = new AccountDocument((long)incrementSeedResult.Value);
accountDocument.Init();
accountDocument.Country = this.m_connection.Location;
IOperationResult <string> createAccountResult = await ServerProxy.AccountDatabase.Insert((long)incrementSeedResult.Value, CouchbaseDocument.Save(accountDocument));
if (!createAccountResult.Success)
{
LoginFailedMessage loginFailedMessage = new LoginFailedMessage();
loginFailedMessage.SetErrorCode(LoginFailedMessage.ErrorCode.SERVER_MAINTENANCE);
loginFailedMessage.SetReason("Internal server error");
this.SendMessage(loginFailedMessage);
return;
}
}
else
{
IOperationResult <string> getResult = await ServerProxy.AccountDatabase.Get(message.GetAccountId());
if (!getResult.Success)
{
if (getResult.Status == ResponseStatus.KeyNotFound)
{
LoginFailedMessage loginFailedMessage = new LoginFailedMessage();
loginFailedMessage.SetErrorCode(LoginFailedMessage.ErrorCode.ACCOUNT_NOT_EXISTS);
this.SendMessage(loginFailedMessage);
}
else
{
LoginFailedMessage loginFailedMessage = new LoginFailedMessage();
loginFailedMessage.SetErrorCode(LoginFailedMessage.ErrorCode.SERVER_MAINTENANCE);
loginFailedMessage.SetReason("Internal server error");
this.SendMessage(loginFailedMessage);
}
return;
}
accountDocument = CouchbaseDocument.Load <AccountDocument>(getResult.Value);
if (accountDocument.PassToken != message.GetPassToken())
{
LoginFailedMessage loginFailedMessage = new LoginFailedMessage();
loginFailedMessage.SetErrorCode(LoginFailedMessage.ErrorCode.ACCOUNT_NOT_EXISTS);
this.SendMessage(loginFailedMessage);
return;
}
}
if (accountDocument.State != AccountState.NORMAL)
{
switch (accountDocument.State)
{
case AccountState.BANNED:
{
LoginFailedMessage loginFailedMessage = new LoginFailedMessage();
loginFailedMessage.SetErrorCode(LoginFailedMessage.ErrorCode.BANNED);
loginFailedMessage.SetReason(accountDocument.StateArg);
this.SendMessage(loginFailedMessage);
return;
}
case AccountState.LOCKED:
{
LoginFailedMessage loginFailedMessage = new LoginFailedMessage();
loginFailedMessage.SetErrorCode(LoginFailedMessage.ErrorCode.ACCOUNT_LOCKED);
this.SendMessage(loginFailedMessage);
return;
}
}
}
ProxySession session = ProxySessionManager.Create(this.m_connection, accountDocument);
RedisValue prevSession = await ServerProxy.SessionDatabase.GetSet(accountDocument.Id, session.Id.ToString());
if (!prevSession.IsNull)
{
long prevSessionId = long.Parse(prevSession);
ServerMessageManager.SendMessage(new StopSessionMessage
{
Reason = 1,
SessionId = prevSessionId
}, ServerManager.GetProxySocket(prevSessionId));
}
session.SetSocket(ServerCore.Socket); // Proxy
LoginOkMessage loginOkMessage = new LoginOkMessage();
loginOkMessage.SetAccountId(accountDocument.Id);
loginOkMessage.SetHomeId(accountDocument.Id);
loginOkMessage.SetPassToken(accountDocument.PassToken);
loginOkMessage.SetFacebookId(accountDocument.FacebookId);
loginOkMessage.SetGamecenterId(accountDocument.GamecenterId);
loginOkMessage.SetServerMajorVersion(LogicVersion.MAJOR_VERSION);
loginOkMessage.SetServerBuildVersion(LogicVersion.BUILD_VERSION);
loginOkMessage.SetContentVersion(ResourceManager.GetContentVersion());
loginOkMessage.SetServerEnvironment(EnvironmentSettings.Environment);
loginOkMessage.SetSessionCount(accountDocument.SessionCount);
loginOkMessage.SetPlayTimeSeconds(accountDocument.PlayTimeSeconds);
loginOkMessage.SetAccountCreatedDate(accountDocument.CreateTime.ToString());
loginOkMessage.SetStartupCooldownSeconds(ServerProxy.GetStartupCooldownSeconds());
loginOkMessage.SetRegion(this.m_connection.Location);
loginOkMessage.SetFacebookAppId(ResourceSettings.FacebookAppId);
loginOkMessage.SetGoogleServiceId(ResourceSettings.GoogleServiceId);
loginOkMessage.SetContentUrlList(ResourceSettings.ContentUrlList);
loginOkMessage.SetChronosContentUrlList(ResourceSettings.ChronosContentUrlList);
this.SendMessage(loginOkMessage);
this.m_connection.SetSession(session);
this.m_connection.SetState(ClientConnectionState.LOGGED);
if (this.m_connection.State == ClientConnectionState.LOGGED)
{
accountDocument.SessionCount += 1;
accountDocument.LastSessionTime = TimeUtil.GetTimestamp();
ServerRequestManager.Create(new BindServerSocketRequestMessage
{
ServerType = 9,
ServerId = ServerManager.GetDocumentSocket(9, accountDocument.Id).ServerId,
SessionId = session.Id
}, ServerCore.Socket, 5).OnComplete = this.OnGameServerBound;
await ServerProxy.AccountDatabase.Update(accountDocument.Id, CouchbaseDocument.Save(accountDocument));
}
else
{
this.m_connection.DestructSession();
}
}
}
private static void OnChangeGameStateMessageReceived(ChangeGameStateMessage message)
{
if (GameSessionManager.TryGet(message.SessionId, out GameSession session))
{
GameAvatar document = session.GameAvatar;
switch (message.StateType)
{
case GameStateType.HOME:
session.DestructGameState();
session.LoadGameState(new GameHomeState
{
PlayerAvatar = document.LogicClientAvatar,
Home = document.LogicClientHome,
SaveTime = document.SaveTime,
MaintenanceTime = document.MaintenanceTime,
ServerCommands = document.ServerCommands,
LayoutId = message.LayoutId,
MapId = message.MapId
});
break;
case GameStateType.NPC_ATTACK:
session.DestructGameState();
session.LoadGameState(new GameNpcAttackState
{
PlayerAvatar = document.LogicClientAvatar,
Home = GameResourceManager.NpcHomes[message.NpcData.GetInstanceID()],
NpcAvatar = LogicNpcAvatar.GetNpcAvatar(message.NpcData),
SaveTime = -1
});
break;
case GameStateType.NPC_DUEL:
session.DestructGameState();
session.LoadGameState(new GameNpcDuelState
{
PlayerAvatar = document.LogicClientAvatar,
Home = GameResourceManager.NpcHomes[message.NpcData.GetInstanceID()],
NpcAvatar = LogicNpcAvatar.GetNpcAvatar(message.NpcData),
SaveTime = -1
});
break;
case GameStateType.VISIT:
ServerRequestManager.Create(new GameAvatarRequestMessage
{
AccountId = message.HomeId
}, ServerManager.GetDocumentSocket(9, message.HomeId), 5).OnComplete = args =>
{
if (!session.IsDestructed())
{
if (args.ErrorCode == ServerRequestError.Success && args.ResponseMessage.Success)
{
GameAvatarResponseMessage gameAvatarResponseMessage = (GameAvatarResponseMessage)args.ResponseMessage;
session.DestructGameState();
session.LoadGameState(new GameVisitState
{
Home = gameAvatarResponseMessage.Document.LogicClientHome,
HomeOwnerAvatar = gameAvatarResponseMessage.Document.LogicClientAvatar,
SaveTime = gameAvatarResponseMessage.Document.SaveTime,
PlayerAvatar = session.GameAvatar.LogicClientAvatar
});
}
else
{
session.SendPiranhaMessage(new VisitFailedMessage(), 1);
}
}
};
break;
case GameStateType.CHALLENGE_ATTACK:
session.DestructGameState();
LogicLong liveReplayId = LiveReplayManager.Create(session, message.ChallengeAllianceId, message.ChallengeStreamId);
LogicClientHome logicClientHome = new LogicClientHome();
logicClientHome.SetHomeId(message.ChallengeHomeId);
logicClientHome.GetCompressibleHomeJSON().Set(message.ChallengeHomeJSON);
session.LoadGameState(new GameChallengeAttackState
{
Home = logicClientHome,
PlayerAvatar = document.LogicClientAvatar,
SaveTime = -1,
LiveReplayId = liveReplayId,
AllianceId = message.ChallengeAllianceId,
StreamId = message.ChallengeStreamId,
MapId = message.ChallengeMapId
});
ServerMessageManager.SendMessage(new AllianceChallengeLiveReplayIdMessage
{
AccountId = message.ChallengeStreamId,
LiveReplayId = liveReplayId
}, 11);
break;
}
}
}
private static void OnGameStartFakeAttackMessageReceived(GameStartFakeAttackMessage message)
{
if (GameSessionManager.TryGet(message.SessionId, out GameSession session))
{
if (message.AccountId != null)
{
ServerRequestManager.Create(new GameAvatarRequestMessage
{
AccountId = message.AccountId
}, ServerManager.GetDocumentSocket(9, message.AccountId)).OnComplete = args =>
{
if (session.IsDestructed())
{
return;
}
if (args.ErrorCode == ServerRequestError.Success && args.ResponseMessage.Success)
{
GameState currentGameState = session.GameState;
if (currentGameState != null && currentGameState.GetGameStateType() == GameStateType.HOME)
{
GameAvatarResponseMessage gameAvatarResponseMessage = (GameAvatarResponseMessage)args.ResponseMessage;
GameDocument document = gameAvatarResponseMessage.Document;
AvailableServerCommandMessage availableServerCommandMessage = new AvailableServerCommandMessage();
availableServerCommandMessage.SetServerCommand(new LogicMatchmakingCommand());
session.SendPiranhaMessage(availableServerCommandMessage, 1);
session.FakeAttackState = new GameFakeAttackState
{
Home = document.LogicClientHome,
HomeOwnerAvatar = document.LogicClientAvatar,
PlayerAvatar = session.GameAvatar.LogicClientAvatar,
SaveTime = document.SaveTime,
MaintenanceTime = document.MaintenanceTime
};
}
}
else
{
AttackHomeFailedMessage attackHomeFailedMessage = new AttackHomeFailedMessage();
attackHomeFailedMessage.SetReason(AttackHomeFailedMessage.Reason.GENERIC);
session.SendPiranhaMessage(attackHomeFailedMessage, 1);
}
};
}
else
{
GameState currentGameState = session.GameState;
if (currentGameState != null && currentGameState.GetGameStateType() == GameStateType.HOME)
{
AvailableServerCommandMessage availableServerCommandMessage = new AvailableServerCommandMessage();
availableServerCommandMessage.SetServerCommand(new LogicMatchmakingCommand());
session.SendPiranhaMessage(availableServerCommandMessage, 1);
session.FakeAttackState = new GameFakeAttackState
{
Home = GameBaseGenerator.GenerateBase((LogicGameObjectData)message.ArgData),
HomeOwnerAvatar = GameBaseGenerator.HomeOwnerAvatar,
PlayerAvatar = session.GameAvatar.LogicClientAvatar,
SaveTime = TimeUtil.GetTimestamp(),
MaintenanceTime = -1
};
}
}
}
}
private static void OnGameCreateAllianceInvitationRequestMessageReceived(GameCreateAllianceInvitationRequestMessage message)
{
if (GameAvatarManager.TryGet(message.AccountId, out GameAvatar avatar))
{
if (avatar.LogicClientAvatar.IsInAlliance() || avatar.HasServerCommandOfType(LogicCommandType.JOIN_ALLIANCE) || avatar.PendingAllianceJoinResponse)
{
ServerRequestManager.SendResponse(new GameCreateAllianceInvitationResponseMessage
{
ErrorReason = GameCreateAllianceInvitationResponseMessage.Reason.ALREADY_IN_ALLIANCE
}, message);
return;
}
if (!avatar.LogicClientAvatar.HasAllianceCastle())
{
ServerRequestManager.SendResponse(new GameCreateAllianceInvitationResponseMessage
{
ErrorReason = GameCreateAllianceInvitationResponseMessage.Reason.NO_CASTLE
}, message);
return;
}
ServerRequestManager.Create(new LoadAvatarStreamOfTypeRequestMessage
{
StreamIds = avatar.AvatarStreamList,
SenderAvatarId = message.Entry.GetSenderAvatarId(),
Type = AvatarStreamEntryType.ALLIANCE_INVITATION
}, ServerManager.GetDocumentSocket(11, avatar.Id), 5).OnComplete = args =>
{
if (args.ErrorCode == ServerRequestError.Success && args.ResponseMessage.Success)
{
LoadAvatarStreamOfTypeResponseMessage loadAvatarStreamOfTypeResponseMessage = (LoadAvatarStreamOfTypeResponseMessage)args.ResponseMessage;
for (int i = 0; i < loadAvatarStreamOfTypeResponseMessage.StreamList.Size(); i++)
{
AllianceInvitationAvatarStreamEntry allianceInvitationAvatarStreamEntry = (AllianceInvitationAvatarStreamEntry)loadAvatarStreamOfTypeResponseMessage.StreamList[i];
if (allianceInvitationAvatarStreamEntry.GetAllianceId().Equals(message.Entry.GetAllianceId()))
{
ServerRequestManager.SendResponse(new GameCreateAllianceInvitationResponseMessage
{
ErrorReason = GameCreateAllianceInvitationResponseMessage.Reason.ALREADY_HAS_AN_INVITE
}, message);
return;
}
}
if (loadAvatarStreamOfTypeResponseMessage.StreamList.Size() >= 10)
{
ServerRequestManager.SendResponse(new GameCreateAllianceInvitationResponseMessage
{
ErrorReason = GameCreateAllianceInvitationResponseMessage.Reason.HAS_TOO_MANY_INVITES
}, message);
}
ServerMessageManager.SendMessage(new CreateAvatarStreamMessage
{
AccountId = message.AccountId,
Entry = message.Entry
}, 9);
ServerRequestManager.SendResponse(new GameCreateAllianceInvitationResponseMessage
{
Success = true
}, message);
}
else
{
ServerRequestManager.SendResponse(new GameCreateAllianceInvitationResponseMessage
{
ErrorReason = GameCreateAllianceInvitationResponseMessage.Reason.GENERIC
}, message);
}
};
}
else
{
ServerRequestManager.SendResponse(new GameCreateAllianceInvitationResponseMessage
{
ErrorReason = GameCreateAllianceInvitationResponseMessage.Reason.GENERIC
}, message);
}
}
private void OnSendGlobalChatLineMessageReceived(SendGlobalChatLineMessage message)
{
if (!this.CanSendGlobalChatMessage())
{
return;
}
string chatMessage = StringUtil.RemoveMultipleSpaces(message.RemoveMessage());
if (chatMessage.Length > 0)
{
if (chatMessage.Length > 128)
{
chatMessage = chatMessage.Substring(0, 128);
}
if (chatMessage.StartsWith("/op "))
{
string[] args = chatMessage.Trim().Split(' ');
if (args.Length < 3)
{
return;
}
string commandType = args[1];
string commandName = args[2];
switch (commandType)
{
case "attack":
{
if (string.Equals(commandName, "me", StringComparison.InvariantCultureIgnoreCase))
{
this.m_session.SendMessage(new GameStartFakeAttackMessage
{
AccountId = this.m_session.AccountId,
ArgData = null
}, 9);
}
else if (commandName.StartsWith("#"))
{
LogicLong accountId = HashTagCodeGenerator.m_instance.ToId(commandName.ToUpperInvariant());
if (accountId != null)
{
this.m_session.SendMessage(new GameStartFakeAttackMessage
{
AccountId = accountId,
ArgData = null
}, 9);
}
}
else if (string.Equals(commandName, "generate", StringComparison.InvariantCultureIgnoreCase))
{
if (args.Length >= 4)
{
if (int.TryParse(args[3], out int id))
{
LogicGameObjectData gameObjectData = null;
switch (id / 100)
{
case 0:
LogicBuildingData buildingData =
(LogicBuildingData)LogicDataTables.GetDataById(GlobalID.CreateGlobalID((int)LogicDataType.BUILDING + 1, id), LogicDataType.BUILDING);
if (buildingData.IsTownHall() || buildingData.IsTownHallVillage2())
{
return;
}
if (!buildingData.IsEnabledInVillageType(0))
{
return;
}
if (buildingData.IsLocked() && !buildingData.IsAllianceCastle())
{
return;
}
gameObjectData = buildingData;
break;
case 1:
gameObjectData = (LogicGameObjectData)LogicDataTables.GetDataById(GlobalID.CreateGlobalID((int)LogicDataType.TRAP + 1, id), LogicDataType.TRAP);
break;
}
if (gameObjectData != null)
{
this.m_session.SendMessage(new GameStartFakeAttackMessage
{
AccountId = null,
ArgData = gameObjectData
}, 9);
}
}
}
else
{
this.m_session.SendMessage(new GameStartFakeAttackMessage
{
AccountId = null,
ArgData = null
}, 9);
}
}
break;
}
case "village":
switch (commandName)
{
case "upgrade":
{
AvailableServerCommandMessage availableServerCommandMessage = new AvailableServerCommandMessage();
availableServerCommandMessage.SetServerCommand(new LogicDebugCommand(LogicDebugActionType.UPGRADE_ALL_BUILDINGS));
this.m_session.SendPiranhaMessage(availableServerCommandMessage, 1);
break;
}
case "obstacle":
{
AvailableServerCommandMessage availableServerCommandMessage = new AvailableServerCommandMessage();
availableServerCommandMessage.SetServerCommand(new LogicDebugCommand(LogicDebugActionType.REMOVE_OBSTACLES));
this.m_session.SendPiranhaMessage(availableServerCommandMessage, 1);
break;
}
case "preset":
// TODO: Implement this.
break;
}
break;
case "hero":
switch (commandName)
{
case "max":
{
AvailableServerCommandMessage availableServerCommandMessage = new AvailableServerCommandMessage();
availableServerCommandMessage.SetServerCommand(new LogicDebugCommand(LogicDebugActionType.SET_MAX_HERO_LEVELS));
this.m_session.SendPiranhaMessage(availableServerCommandMessage, 1);
return;
}
case "reset":
{
AvailableServerCommandMessage availableServerCommandMessage = new AvailableServerCommandMessage();
availableServerCommandMessage.SetServerCommand(new LogicDebugCommand(LogicDebugActionType.RESET_HERO_LEVELS));
this.m_session.SendPiranhaMessage(availableServerCommandMessage, 1);
return;
}
}
break;
case "unit":
switch (commandName)
{
case "max":
{
AvailableServerCommandMessage availableServerCommandMessage = new AvailableServerCommandMessage();
availableServerCommandMessage.SetServerCommand(new LogicDebugCommand(LogicDebugActionType.SET_MAX_UNIT_SPELL_LEVELS));
this.m_session.SendPiranhaMessage(availableServerCommandMessage, 1);
return;
}
}
break;
}
}
else
{
ServerRequestManager.Create(new AvatarRequestMessage
{
AccountId = this.m_session.AccountId
}, ServerManager.GetDocumentSocket(9, this.m_session.AccountId)).OnComplete = args =>
{
if (args.ErrorCode == ServerRequestError.Success && args.ResponseMessage.Success)
{
this.m_session.ChatInstance.PublishMessage(((AvatarResponseMessage)args.ResponseMessage).LogicClientAvatar, WordCensorUtil.FilterMessage(chatMessage));
this.m_previousGlobalChatMessageTime = DateTime.UtcNow;
}
};
}
}
}
