public static void HandleGameFightJoinRequestMessage(GameFightJoinRequestMessage message, WorldClient client)
        {
            var fight = client.Character.Map.Instance.GetFight(message.fightId);

            if (fight != null)
            {
                fight.TryJoin(client.Character, (int)message.fighterId);
            }
        }
Example #2
0
        public static void HandleGameFightJoinRequestMessage(WorldClient client, GameFightJoinRequestMessage message)
        {
            if (!client.Character.IsFighting())
            {
                Fight fight = Singleton <FightManager> .Instance.GetFight(message.fightId);

                if (fight == null)
                {
                    ContextHandler.SendChallengeFightJoinRefusedMessage(client, client.Character, FighterRefusedReasonEnum.TOO_LATE);
                }
                else
                {
                    if (fight.Map != client.Character.Map)
                    {
                        ContextHandler.SendChallengeFightJoinRefusedMessage(client, client.Character, FighterRefusedReasonEnum.WRONG_MAP);
                    }
                    else
                    {
                        if (fight.IsStarted)
                        {
                            if (message.fighterId == 0 && fight.CanSpectatorJoin(client.Character))
                            {
                                fight.AddSpectator(client.Character.CreateSpectator(fight));
                            }
                        }
                        else
                        {
                            FightTeam fightTeam;
                            if (fight.RedTeam.Leader.Id == message.fighterId)
                            {
                                fightTeam = fight.RedTeam;
                            }
                            else
                            {
                                if (fight.BlueTeam.Leader.Id != message.fighterId)
                                {
                                    ContextHandler.SendChallengeFightJoinRefusedMessage(client, client.Character, FighterRefusedReasonEnum.WRONG_MAP);
                                    return;
                                }
                                fightTeam = fight.BlueTeam;
                            }
                            FighterRefusedReasonEnum reason;
                            if ((reason = fightTeam.CanJoin(client.Character)) != FighterRefusedReasonEnum.FIGHTER_ACCEPTED)
                            {
                                ContextHandler.SendChallengeFightJoinRefusedMessage(client, client.Character, reason);
                            }
                            else
                            {
                                fightTeam.AddFighter(client.Character.CreateFighter(fightTeam));
                            }
                        }
                    }
                }
            }
        }
        public static void HandleFightJoin(GameFightJoinRequestMessage message, WorldClient client)
        {
            var fight = FightProvider.Instance.GetFight(message.fightId);

            if (!fight.ContainCharacterFighter(client.Character.Id))
            {
                fight.TryJoin(client, message.fighterId);
            }
            else
            {
                client.Character.NotificationError("Vous avez déja rejoint ce combat");
            }
        }
Example #4
0
        public static void PartyMemberInFightMessageTreatment(Message message, byte[] packetDatas, AccountUC account)
        {
            PartyMemberInFightMessage msg = (PartyMemberInFightMessage)message;

            using (BigEndianReader reader = new BigEndianReader(packetDatas))
            {
                msg.Deserialize(reader);
            }
            if (msg.FightMap.MapId == account.MapData.Id && msg.MemberName == account.MyGroup.GetMaster().CharacterBaseInformations.Name)
            {
                account.Wait(500, 1500);
                using (BigEndianWriter writer = new BigEndianWriter())
                {
                    GameFightJoinRequestMessage msg2 = new GameFightJoinRequestMessage(msg.MemberId, msg.FightId);
                    account.SocketManager.Send(msg2);
                }
            }
        }
Example #5
0
        public void GameFightJoinRequestMessageFrame(WorldClient client, GameFightJoinRequestMessage gameFightJoinRequestMessage)
        {
            var map = MapManager.Instance.GetMap(client.ActiveCharacter.MapId);

            if (map == null)
            {
                return;
            }

            var fight = map.GetFight((int)gameFightJoinRequestMessage.fightId);

            if (fight == null)
            {
                return;
            }

            fight.EnterFight(client);
        }
Example #6
0
        public static void HandleGameFightJoinRequestMessage(WorldClient client, GameFightJoinRequestMessage message)
        {
            if (client.Character.IsFighting())
            {
                return;
            }

            var fight = FightManager.Instance.GetFight(message.fightId);

            if (fight == null)
            {
                SendChallengeFightJoinRefusedMessage(client, client.Character, FighterRefusedReasonEnum.TOO_LATE);
                return;
            }

            if (client.Character.Map.Id != ArenaManager.KolizeumMapId && fight.Map != client.Character.Map)
            {
                SendChallengeFightJoinRefusedMessage(client, client.Character, FighterRefusedReasonEnum.WRONG_MAP);
                return;
            }

            if (message.fighterId == 0 && fight.CanSpectatorJoin(client.Character) && !client.Character.IsInFight())
            {
                if (client.Character.Map.Id == ArenaManager.KolizeumMapId)
                {
                    ContextRoleplayHandler.SendCurrentMapMessage(client, fight.Map.Id);
                }

                fight.AddSpectator(client.Character.CreateSpectator(fight));
            }

            if (fight.IsStarted)
            {
                return;
            }

            FightTeam team;

            if (fight.ChallengersTeam.Leader.Id == message.fighterId)
            {
                team = fight.ChallengersTeam;
            }
            else if (fight.DefendersTeam.Leader.Id == message.fighterId)
            {
                team = fight.DefendersTeam;
            }
            else
            {
                SendChallengeFightJoinRefusedMessage(client, client.Character, FighterRefusedReasonEnum.WRONG_MAP);
                return;
            }

            FighterRefusedReasonEnum error;

            if ((error = team.CanJoin(client.Character)) != FighterRefusedReasonEnum.FIGHTER_ACCEPTED)
            {
                SendChallengeFightJoinRefusedMessage(client, client.Character, error);
            }
            else
            {
                team.AddFighter(client.Character.CreateFighter(team));
            }
        }
Example #7
0
        public static void PartyMemberInFightMessageTreatment(Message message, byte[] packetDatas, AccountUC account)
        {
            PartyMemberInFightMessage msg = (PartyMemberInFightMessage)message;

            using (BigEndianReader reader = new BigEndianReader(packetDatas))
            {
                msg.Deserialize(reader);
            }
            if (msg.fightMap.mapId == account.Map.Id && msg.memberName == account.MyGroup.GetMaster().CharacterBaseInformations.name)
            {
                account.Wait(500, 1500);
                using (BigEndianWriter writer = new BigEndianWriter())
                {
                    GameFightJoinRequestMessage msg2 = new GameFightJoinRequestMessage(msg.memberId, msg.fightId);
                    account.SocketManager.Send(msg2);
                }
            }
        }