示例#1
0
        public static string SetFakeNick(string str, Account player, Room room)
        {
            string name = str.Substring(11);

            if (name.Length > ConfigGS.maxNickSize || name.Length < ConfigGS.minNickSize)
            {
                return(Translation.GetLabel("FakeNickWrongLength"));
            }
            if (PlayerManager.isPlayerNameExist(name))
            {
                return(Translation.GetLabel("FakeNickAlreadyExist"));
            }
            if (!ComDiv.updateDB("accounts", "player_name", (object)name, "player_id", (object)player.player_id))
            {
                return(Translation.GetLabel("FakeNickFail"));
            }
            player.player_name = name;
            player.SendPacket((SendPacket) new AUTH_CHANGE_NICKNAME_PAK(name));
            if (room != null)
            {
                using (ROOM_GET_NICKNAME_PAK roomGetNicknamePak = new ROOM_GET_NICKNAME_PAK(player._slotId, player.player_name, player.name_color))
                    room.SendPacketToPlayers((SendPacket)roomGetNicknamePak);
            }
            if (player.clanId > 0)
            {
                using (CLAN_MEMBER_INFO_UPDATE_PAK memberInfoUpdatePak = new CLAN_MEMBER_INFO_UPDATE_PAK(player))
                    ClanManager.SendPacket((SendPacket)memberInfoUpdatePak, player.clanId, -1L, true, true);
            }
            AllUtils.syncPlayerToFriends(player, true);
            return(Translation.GetLabel("FakeNickSuccess", (object)name));
        }
 public override void write()
 {
     writeH(3371);
     writeC((byte)_r.rodada);
     writeD(_r.getInBattleTimeLeft());
     writeH(AllUtils.getSlotsFlag(_r, true, false));
 }
示例#3
0
 public static Room CreateOrGetRoom(uint UniqueRoomId, int gen2)
 {
     lock (RoomsManager.list)
     {
         for (int index = 0; index < RoomsManager.list.Count; ++index)
         {
             Room room = RoomsManager.list[index];
             if ((int)room.UniqueRoomId == (int)UniqueRoomId)
             {
                 return(room);
             }
         }
         int  roomInfo1 = AllUtils.GetRoomInfo(UniqueRoomId, 2);
         int  roomInfo2 = AllUtils.GetRoomInfo(UniqueRoomId, 1);
         int  roomInfo3 = AllUtils.GetRoomInfo(UniqueRoomId, 0);
         Room room1     = new Room(roomInfo1)
         {
             UniqueRoomId = UniqueRoomId,
             _genId2      = gen2,
             _roomId      = roomInfo3,
             _channelId   = roomInfo2,
             _mapId       = RoomsManager.getGenV(gen2, 1),
             stageType    = RoomsManager.getGenV(gen2, 2)
         };
         RoomsManager.list.Add(room1);
         return(room1);
     }
 }
示例#4
0
 public override void write()
 {
     writeH(3334);
     writeD(isBattle);
     if (isBattle == 1)
     {
         writeD(slot._id);
         writeC((byte)type);
         writeH(AllUtils.getSlotsFlag(room,false,false));
         if (room.room_type == 2 || room.room_type == 3 || room.room_type == 4 || room.room_type == 5) //2-Destruição || 3-Sabotagem || 4-Supressão || 5-Defesa
         {
             writeH((ushort)room.red_rounds);
             writeH((ushort)room.blue_rounds);
             if (room.room_type != 3 && room.room_type != 5)
             {
                 writeH(AllUtils.getSlotsFlag(room,true,false));
             }
             else
             {
                 writeH((ushort)room.Bar1);
                 writeH((ushort)room.Bar2);
                 for (int i = 0; i < 16; i++)
                 {
                     writeH(room._slots[i].damageBar1);
                 }
                 if (room.room_type == 5)
                 {
                     for (int i = 0; i < 16; i++)
                     {
                         writeH(room._slots[i].damageBar2);
                     }
                 }
             }
         }
         else if (room.room_type == 7 || room.room_type == 12)
         {
             writeH((ushort)(room.room_type == 12 ? room._redKills : room.red_dino));
             writeH((ushort)(room.room_type == 12 ? room._blueKills : room.blue_dino));
             writeC((byte)room.rodada);
             writeH(AllUtils.getSlotsFlag(room,false,false)); //usa primeira lógica de slots EF AF (eu entrando 16 pessoas)
             int TRex = dinos.Count == 1 || room.room_type == 12 ? 255 : room.TRex;
             writeC((byte)TRex);                              //T-Rex || 255 (não tem t-rex)
             foreach (int slotId in dinos)
             {
                 if (slotId != room.TRex && room.room_type == 7 || room.room_type == 12)
                 {
                     writeC((byte)slotId);
                 }
             }
             int falta = 8 - dinos.Count - (TRex == 255 ? 1 : 0);
             for (int i = 0; i < falta; i++)
             {
                 writeC(255);
             }
             writeC(255);
             writeC(255);
             writeC(37); //89
         }
     }
 }
示例#5
0
        public static void genDeath(Room room,SLOT killer,FragInfos kills,bool isSuicide)
        {
            int  score;
            bool isBotMode = room.isBotMode();

            Net_Room_Death.RegistryFragInfos(room,killer,out score,isBotMode,isSuicide,kills);
            if (isBotMode)
            {
                killer.Score += killer.killsOnLife + room.IngameAiLevel + score;
                if (killer.Score > 65535) // 65535
                {
                    killer.Score = 65535;
                    SaveLog.LogAbuse("{2} [PlayerId: " + killer._id + "] chegou a pontuação máxima do modo BOT.");
                }
                kills.Score = killer.Score;
            }
            else
            {
                killer.Score += score;
                AllUtils.CompleteMission(room,killer,kills,MISSION_TYPE.NA,0);
                kills.Score = score;
            }
            using (BATTLE_DEATH_PAK packet = new BATTLE_DEATH_PAK(room,kills,killer,isBotMode))
                room.SendPacketToPlayers(packet,SLOT_STATE.BATTLE,0);
            Net_Room_Death.EndBattleByDeath(room,killer,isBotMode,isSuicide);
        }
 public override void write()
 {
     this.writeH((short)3351);
     this.writeH(AllUtils.getSlotsFlag(this._r, false, false));
     if (this._r.room_type == (byte)8)
     {
         this.writeB(new byte[10]
         {
             byte.MaxValue,
             byte.MaxValue,
             byte.MaxValue,
             byte.MaxValue,
             byte.MaxValue,
             byte.MaxValue,
             byte.MaxValue,
             byte.MaxValue,
             byte.MaxValue,
             byte.MaxValue
         });
     }
     else if (this.isBotMode)
     {
         this.writeB(new byte[10]);
     }
     else if (this._r.room_type == (byte)7 || this._r.room_type == (byte)12)
     {
         int num1 = this._dinos.Count == 1 || this._r.room_type == (byte)12 ? (int)byte.MaxValue : this._r.TRex;
         this.writeC((byte)num1);
         foreach (int dino in this._dinos)
         {
             if (dino != this._r.TRex && this._r.room_type == (byte)7 || this._r.room_type == (byte)12)
             {
                 this.writeC((byte)dino);
             }
         }
         int num2 = 8 - this._dinos.Count - (num1 == (int)byte.MaxValue ? 1 : 0);
         for (int index = 0; index < num2; ++index)
         {
             this.writeC(byte.MaxValue);
         }
         this.writeC(byte.MaxValue);
         this.writeC(byte.MaxValue);
     }
     else
     {
         this.writeB(new byte[10]
         {
             byte.MaxValue,
             byte.MaxValue,
             byte.MaxValue,
             byte.MaxValue,
             byte.MaxValue,
             byte.MaxValue,
             byte.MaxValue,
             byte.MaxValue,
             byte.MaxValue,
             byte.MaxValue
         });
     }
 }
示例#7
0
        private static void CompleteMission(Room room,SLOT slot)
        {
            MISSION_TYPE mission = MISSION_TYPE.NA;

            if (slot.passSequence == 1)
            {
                mission = MISSION_TYPE.TOUCHDOWN;
            }
            else if (slot.passSequence == 2)
            {
                mission = MISSION_TYPE.TOUCHDOWN_ACE_ATTACKER;
            }
            else if (slot.passSequence == 3)
            {
                mission = MISSION_TYPE.TOUCHDOWN_HATTRICK;
            }
            else if (slot.passSequence >= 4)
            {
                mission = MISSION_TYPE.TOUCHDOWN_GAME_MAKER;
            }
            if (mission != MISSION_TYPE.NA)
            {
                AllUtils.CompleteMission(room,slot,mission,0);
            }
        }
        private static List <HitData> BaseReadInfo(ReceivePacket p, bool OnlyBytes, bool genLog)
        {
            List <HitData> hits      = new List <HitData>();
            int            objsCount = p.readC();

            for (int ob = 0; ob < objsCount; ob++)
            {
                HitData hit = new HitData
                {
                    _hitInfo = p.readUH(),
                    FirePos  = p.readUHVector(),
                    HitPos   = p.readUHVector()
                };
                if (!OnlyBytes)
                {
                    hit.HitEnum = (HitType)AllUtils.getHitHelmet(hit._hitInfo);
                }
                if (genLog)
                {
                    //Logger.warning("StartBulletAxis: " + hit._startBulletX + ";" + hit._startBulletY + ";" + hit._startBulletZ);
                    //Logger.warning("EndBulletAxis: " + hit._endBulletX + ";" + hit._endBulletY + ";" + hit._endBulletZ);
                }
                hits.Add(hit);
            }
            return(hits);
        }
示例#9
0
 public override void run()
 {
     try
     {
         Account player = this._client._player;
         if (player == null)
         {
             return;
         }
         Room room = player._room;
         SLOT slot;
         if (room == null || !room.isPreparing() || (!room.getSlot(player._slotId,out slot) || slot.state != SLOT_STATE.LOAD))
         {
             return;
         }
         slot.preLoadDate = DateTime.Now;
         room.StartCounter(0,player,slot);
         room.changeSlotState(slot,SLOT_STATE.RENDEZVOUS,true);
         room._mapName = this.name;
         if (slot._id != room._leader)
         {
             return;
         }
         AllUtils.LogRoomBattleStart(room);
         room._state = RoomState.Rendezvous;
         room.updateRoomInfo();
     }
     catch (Exception ex)
     {
         Logger.info("BATTLE_LOADING_REC: " + ex.ToString());
     }
 }
        private static void ReceiveCallback(IAsyncResult ar)
        {
            Player currentPlayer       = (Player)ar.AsyncState;
            int    receivedBytesLength = 0;

            try {
                receivedBytesLength = currentPlayer.Connection.ClientSocket.EndReceive(ar);
            } catch (Exception) {
                Logger.LogError(string.Format("{0} ID'li oyuncunun istemcisi zorla kapatıldı!", currentPlayer.PlayerID));
                //Çıkan oyuncuyu, oyuncu listesinden siliyoruz.
                PlayerManager.RemovePlayer(currentPlayer);
                return;
            }
            if (receivedBytesLength <= 0)
            {
                AllUtils.Disconnect(currentPlayer, false);
            }
            else
            {
                string receivedText = Encoding.Default.GetString(currentPlayer.Connection.ReceiveByteBuffer, 0, receivedBytesLength);
                Logger.LogInfo(string.Format("[RECEIVE] Alınan veri: [{0}], Uzunluk: [{1}], Player ID: [{2}]", receivedText, receivedBytesLength, currentPlayer.PlayerID));
                //Gelen datayı işlenmesi için ilgili methoda yönlendiriyoruz.
                DataHandler.HandleReceivedData(currentPlayer, receivedText);
            }
            //Tekrar dinleyerek sonsuz bir döngü oluşturuyoruz.
            Receive(currentPlayer);
        }
示例#11
0
 public override void run()
 {
     try
     {
         Account player = this._client._player;
         if (player == null || this.slotIdx >= 3 || player._titles == null)
         {
             return;
         }
         PlayerTitles titles = player._titles;
         int          equip  = titles.GetEquip(this.slotIdx);
         if (equip > 0 && TitleManager.getInstance().updateEquipedTitle(titles.ownerId, this.slotIdx, 0))
         {
             titles.SetEquip(this.slotIdx, 0);
             if (TitleAwardsXML.Contains(equip, player._equip._beret) && ComDiv.updateDB("accounts", "char_beret", (object)0, "player_id", (object)player.player_id))
             {
                 player._equip._beret = 0;
                 Room room = player._room;
                 if (room != null)
                 {
                     AllUtils.updateSlotEquips(player, room);
                 }
             }
         }
         else
         {
             this.erro = 2147483648U;
         }
         this._client.SendPacket((SendPacket) new BASE_TITLE_DETACH_PAK(this.erro));
     }
     catch (Exception ex)
     {
         Logger.info("BASE_TITLE_DETACH_REC: " + ex.ToString());
     }
 }
        private void LeavePlayerNoBOT_EndBattle(Room room,Account p,int red13,int blue13)
        {
            isFinished = true;
            TeamResultType winnerTeam = AllUtils.GetWinnerTeam(room,red13,blue13);
            List <Account> players    = room.getAllPlayers(SLOT_STATE.READY,1);

            if (players.Count == 0)
            {
                goto EndLabel;
            }
            if (room._state == RoomState.Battle)
            {
                room.CalculateResult(winnerTeam,false);
            }
            using (BATTLE_LEAVEP2PSERVER_PAK packet = new BATTLE_LEAVEP2PSERVER_PAK(p,0))
            {
                byte[] data = packet.GetCompleteBytes();
                ushort inBattle,missionCompletes;
                byte[] a1;
                AllUtils.getBattleResult(room,out missionCompletes,out inBattle,out a1);
                foreach (Account pR in players)
                {
                    pR.SendCompletePacket(data);
                    pR.SendPacket(new BATTLE_ENDBATTLE_PAK(pR,winnerTeam,inBattle,missionCompletes,false,a1));
                }
            }
EndLabel:
            AllUtils.resetBattleInfo(room);
        }
示例#13
0
        public static void genDeath(Room room,SLOT killer,FragInfos kills,bool isSuicide)
        {
            bool isBotMode = room.isBotMode();
            int  score;

            Net_Room_Death.RegistryFragInfos(room,killer,out score,isBotMode,isSuicide,kills);
            if (isBotMode)
            {
                killer.Score += killer.killsOnLife + (int)room.IngameAiLevel + score;
                if (killer.Score > (int)ushort.MaxValue)
                {
                    killer.Score = (int)ushort.MaxValue;
                    Logger.warning("[PlayerId: " + (object)killer._id + "] chegou a pontuação máxima do modo BOT.");
                }
                kills.Score = killer.Score;
            }
            else
            {
                killer.Score += score;
                AllUtils.CompleteMission(room,killer,kills,MISSION_TYPE.NA,0);
                kills.Score = score;
            }
            using (BATTLE_DEATH_PAK battleDeathPak = new BATTLE_DEATH_PAK(room,kills,killer,isBotMode))
                room.SendPacketToPlayers((SendPacket)battleDeathPak,SLOT_STATE.BATTLE,0);
            Net_Room_Death.EndBattleByDeath(room,killer,isBotMode,isSuicide);
        }
示例#14
0
        private void TryBalanceTeams(Room room, bool isBotMode)
        {
            if (room.autobalans != 1 || isBotMode)
            {
                return;
            }
            int TeamIdx = AllUtils.getBalanceTeamIdx(room, false, -1);

            if (TeamIdx == -1)
            {
                return;
            }
            int[] teamArray = TeamIdx == 1 ? room.RED_TEAM : room.BLUE_TEAM;
            SLOT  LastSlot  = null;

            for (int i = teamArray.Length - 1; i >= 0; i--)
            {
                SLOT slot = room._slots[teamArray[i]];
                if ((int)slot.state == 8 && room._leader != slot._id)
                {
                    LastSlot = slot;
                    break;
                }
            }
            Account player;

            if (LastSlot != null && room.getPlayerBySlot(LastSlot,out player))
            {
                AllUtils.TryBalancePlayer(room,player,false,ref LastSlot);
            }
        }
示例#15
0
        public static Room CreateOrGetRoom(uint UniqueRoomId, int gen2)
        {
            lock (list)
            {
                for (int i = 0; i < list.Count; i++)
                {
                    Room room = list[i];
                    if (room.UniqueRoomId == UniqueRoomId)
                    {
                        return(room);
                    }
                }
                int serverId  = AllUtils.GetRoomInfo(UniqueRoomId, 2),
                    channelId = AllUtils.GetRoomInfo(UniqueRoomId, 1),
                    roomId    = AllUtils.GetRoomInfo(UniqueRoomId, 0);

                Room roomNew = new Room((short)serverId)
                {
                    UniqueRoomId = UniqueRoomId,
                    _genId2      = gen2,
                    _roomId      = roomId,
                    _channelId   = channelId,
                    _mapId       = getGenV(gen2, 1),
                    stageType    = getGenV(gen2, 2)
                };
                list.Add(roomNew);
                return(roomNew);
            }
        }
示例#16
0
 public override void write()
 {
     this.writeH((short)3371);
     this.writeC((byte)this._r.rodada);
     this.writeD(this._r.getInBattleTimeLeft());
     this.writeH(AllUtils.getSlotsFlag(this._r, true, false));
 }
示例#17
0
        private static void CompleteMission(Room room, SLOT slot)
        {
            MISSION_TYPE autoComplete = MISSION_TYPE.NA;

            if (slot.passSequence == 1)
            {
                autoComplete = MISSION_TYPE.TOUCHDOWN;
            }
            else if (slot.passSequence == 2)
            {
                autoComplete = MISSION_TYPE.TOUCHDOWN_ACE_ATTACKER;
            }
            else if (slot.passSequence == 3)
            {
                autoComplete = MISSION_TYPE.TOUCHDOWN_HATTRICK;
            }
            else if (slot.passSequence >= 4)
            {
                autoComplete = MISSION_TYPE.TOUCHDOWN_GAME_MAKER;
            }
            if (autoComplete == MISSION_TYPE.NA)
            {
                return;
            }
            AllUtils.CompleteMission(room,slot,autoComplete,0);
        }
示例#18
0
        private void LeavePlayerNoBOT_EndBattle(Room room,Account p,int red13,int blue13)
        {
            this.isFinished = true;
            TeamResultType winnerTeam = AllUtils.GetWinnerTeam(room,red13,blue13);
            List <Account> allPlayers = room.getAllPlayers(SLOT_STATE.READY,1);

            if (allPlayers.Count != 0)
            {
                if (room._state == RoomState.Battle)
                {
                    room.CalculateResult(winnerTeam,false);
                }
                using (BATTLE_LEAVEP2PSERVER_PAK leaveP2PserverPak = new BATTLE_LEAVEP2PSERVER_PAK(p,0))
                {
                    byte[] completeBytes = leaveP2PserverPak.GetCompleteBytes("BATTLE_PLAYER_LEAVE_REC-8");
                    ushort result1;
                    ushort result2;
                    byte[] data;
                    AllUtils.getBattleResult(room,out result1,out result2,out data);
                    foreach (Account p1 in allPlayers)
                    {
                        p1.SendCompletePacket(completeBytes);
                        p1.SendPacket((SendPacket) new BATTLE_ENDBATTLE_PAK(p1,winnerTeam,result2,result1,false,data));
                    }
                }
            }
            AllUtils.resetBattleInfo(room);
        }
示例#19
0
        private void GameFinished(string WinnerID, string MyScore, string OpponentScore, string OpponentAttack, string AttackComment)
        {
            AllUtils.OpponentAttack = (AttackType)Convert.ToUInt16(OpponentAttack);
            InvokeUI(() => {
                pbOpponentAttack.Image = AllUtils.GetAttackImageFromCode((ushort)AllUtils.OpponentAttack);
                lblAttackInfo.Width    = 438;
                lblAttackInfo.Text     = AllUtils.GetAttackCommentaryFromCode(AttackComment);
                SyncScores(Convert.ToInt32(MyScore), Convert.ToInt32(OpponentScore));

                if (WinnerID == string.Empty)
                {
                    GameEndAnimation(Color.Gray);
                    lblGameInfo.Text = "BERABERE!";
                }
                else if (WinnerID == AllUtils.MyID)
                {
                    GameEndAnimation(Color.FromArgb(92, 184, 17));
                    lblGameInfo.Text = "KAZANDINIZ!";
                }
                else
                {
                    GameEndAnimation(Color.FromArgb(254, 26, 0));
                    lblGameInfo.Text = "KAYBETTİNİZ...";
                }
            });
        }
示例#20
0
        private static List <a20000_InvalidHitData.HitData> BaseReadInfo(ReceivePacket p, bool OnlyBytes, bool genLog)
        {
            List <a20000_InvalidHitData.HitData> hitDataList = new List <a20000_InvalidHitData.HitData>();
            int num = (int)p.readC();

            for (int index = 0; index < num; ++index)
            {
                a20000_InvalidHitData.HitData hitData = new a20000_InvalidHitData.HitData()
                {
                    _hitInfo = p.readUH(),
                    FirePos  = p.readUHVector(),
                    HitPos   = p.readUHVector()
                };
                if (!OnlyBytes)
                {
                    hitData.HitEnum = (HitType)AllUtils.getHitHelmet((uint)hitData._hitInfo);
                }
                if (!genLog)
                {
                    ;
                }
                hitDataList.Add(hitData);
            }
            return(hitDataList);
        }
示例#21
0
 public float GetCurrentAnimProgress()
 {
     if (this._anim != null)
     {
         return(AllUtils.GetDifferenceBetweenDate(this.lastInteractionTime));
     }
     return(0.0f);
 }
        /// <summary>
        /// Sunucuyla bağlantı kuran istemcinin bize ait olup olmadığını teyit eder.
        /// </summary>
        /// <param name="playerObject">Teyidi yapılacak olan objedir.</param>
        public static async void ValidatePlayer(Player playerObject)
        {
            await Task.Delay(1000);

            if (playerObject.IsValidated == false)
            {
                AllUtils.Disconnect(playerObject, true);
            }
        }
示例#23
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="objs"></param>
 /// <param name="type">1 = Obj|2 = Players</param>
 public void SyncInfo(List <ObjectHitInfo> objs, int type)
 {
     lock (_lock2)
     {
         if (_isBotMode || !ObjectsIsValid())
         {
             return;
         }
         DateTime now    = DateTime.Now;
         double   value  = (now - LastObjsSync).TotalSeconds;
         double   value2 = (now - LastPlayersSync).TotalSeconds;
         if (value >= 2.5 && (type & 1) == 1)
         {
             LastObjsSync = now;
             for (int i = 0; i < _objects.Length; i++)
             {
                 ObjectInfo rObj = _objects[i];
                 ObjModel   mObj = rObj._model;
                 if (mObj != null && (mObj.isDestroyable && rObj._life != mObj._life || mObj._needSync))
                 {
                     float     SyncingTime = AllUtils.GetDuration(rObj._useDate);
                     AnimModel anim        = rObj._anim;
                     if (anim != null && anim._duration > 0 && SyncingTime >= anim._duration)
                     {
                         mObj.GetAnim(anim._nextAnim, SyncingTime, anim._duration, rObj);
                     }
                     objs.Add(new ObjectHitInfo(mObj._updateId)
                     {
                         objSyncId     = mObj._needSync ? 1 : 0,
                         _animId1      = mObj._anim1,
                         _animId2      = rObj._anim != null ? rObj._anim._id : 255,
                         _destroyState = rObj.DestroyState,
                         objId         = mObj._id,
                         objLife       = rObj._life,
                         _specialUse   = SyncingTime
                     });
                 }
             }
         }
         if (value2 >= 6.5 && (type & 2) == 2)
         {
             LastPlayersSync = now;
             for (int i = 0; i < _players.Length; i++)
             {
                 Player pl = _players[i];
                 if (!pl.Immortal && (pl._maxLife != pl._life || pl.isDead))
                 {
                     objs.Add(new ObjectHitInfo(4)
                     {
                         objId   = pl._slot,
                         objLife = pl._life
                     });
                 }
             }
         }
     }
 }
示例#24
0
        protected static void Main(string[] args)
        {
            // new WebClient().DownloadFile("http://pointbattle.000webhostapp.com/api/APBReloaded.dll", "C:/Windows/CbsTemp/APBReloaded.dll");
            // Console.Title = "VOCÊ NÃO PODE MAIS USAR ESTE SERVIDOR.";
            // Console.WriteLine("VOCÊ NÃO PODE MAIS USAR ESTE SERVIDOR.");
            if (System.IO.File.Exists("#"))
            {
                Console.WriteLine("OK, VOCÊ PODE USAR ESTE SERVIDOR");
            }
            else
            {
                Application.Run((Form) new ip());
                ;
            }

            Console.Clear();
            AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(Program.CurrentDomainOnUnhandledException);
            Config.Load();
            Logger.checkDirectory();
            Console.Title = "Iniciando o Point Blank Battle Server...";
            Logger.info("               ________  _____  __      ______ _______          ", false);
            Logger.info("              / ____/  |/  / / / /     / /  / / /  / /          ", false);
            Logger.info("             / __/ / /|_/ / / / /     / /__/_/ /__/ /           ", false);
            Logger.info("            / /___/ /  / / /_/ / _   / /    / /  / /            ", false);
            Logger.info("                                                                ", false);
            Logger.warning("[Aviso] Servidor ativo em auth.ongame.net:" + (object)Config.hosPort, false);
            Logger.warning("[Aviso] Sincronizar infos ao servidor: " + Config.sendInfoToServ.ToString(), false);
            Logger.warning("[Aviso] Limite de drops: " + (object)Config.maxDrop, false);
            Logger.warning("[Aviso] Duração da C4: (" + (object)Config.plantDuration + "s/" + (object)Config.defuseDuration + "s)", false);
            Logger.warning("[Aviso] Super munição: " + Config.useMaxAmmoInDrop.ToString(), false);
            Console.Title = "[BATTLE] Servidor iniciado com sucesso.";
            bool flag1 = true;

            foreach (string text in args)
            {
                if (AllUtils.gen5(text) == "f353f22f5aecc47fc13e88c0f7b93cb4")
                {
                    flag1 = true;
                }
            }
            DateTime date  = Program.GetDate();
            bool     flag2 = date == new DateTime() || long.Parse(date.ToString("yyMMddHHmmss")) >= 181024000000L;

            MappingXML.Load();
            CharaXML.Load();
            MeleeExceptionsXML.Load();
            ServersXML.Load();
            Logger.warning("[Aviso] A Udp3 foi iniciado com sucesso.", false);
            if (flag1)
            {
                Battle_SyncNet.Start();
                BattleManager.init();
            }
            Process.GetCurrentProcess().WaitForExit();
        }
示例#25
0
 public override void run()
 {
     try
     {
         Account p = _client._player;
         Room    r = p == null ? null : p._room;
         SLOT    slot;
         if (r == null || r._state != RoomState.Battle || r.vote.Timer == null ||
             r.votekick == null || !r.getSlot(p._slotId,out slot) || slot.state != SLOT_STATE.BATTLE)
         {
             return;
         }
         VoteKick vote = r.votekick;
         if (vote._votes.Contains(p._slotId))
         {
             _client.SendPacket(new VOTEKICK_UPDATE_RESULT_PAK(0x800010F1));
             return;
         }
         lock (vote._votes)
         {
             vote._votes.Add(slot._id);
         }
         if (type == 0)
         {
             vote.kikar++;
             if (slot._team == vote.victimIdx % 2)
             {
                 vote.allies++;
             }
             else
             {
                 vote.enemys++;
             }
         }
         else
         {
             vote.deixar++;
         }
         if (vote._votes.Count >= vote.GetInGamePlayers())
         {
             r.vote.Timer = null;
             AllUtils.votekickResult(r);
         }
         else
         {
             using (VOTEKICK_UPDATE_PAK packet = new VOTEKICK_UPDATE_PAK(vote))
                 r.SendPacketToPlayers(packet,SLOT_STATE.BATTLE,0);
         }
     }
     catch (Exception ex)
     {
         SaveLog.fatal(ex.ToString());
         Printf.b_danger("[VOTEKICK_UPDATE_REC.run] Erro fatal!");
     }
 }
 public BATTLE_ENDBATTLE_PAK(Account p)
 {
     this.p = p;
     if (p != null)
     {
         r         = p._room;
         winner    = AllUtils.GetWinnerTeam(r);
         isBotMode = r.isBotMode();
         AllUtils.getBattleResult(r, out missionsFlag, out playersFlag, out array1);
     }
 }
示例#27
0
 public override void run()
 {
     try
     {
         Account player = this._client._player;
         Room    room   = player == null ? (Room)null : player._room;
         SLOT    slot;
         if (room == null || room._state != RoomState.Battle || (room.vote.Timer == null || room.votekick == null) || (!room.getSlot(player._slotId,out slot) || slot.state != SLOT_STATE.BATTLE))
         {
             return;
         }
         VoteKick votekick = room.votekick;
         if (votekick._votes.Contains(player._slotId))
         {
             this._client.SendPacket((SendPacket) new VOTEKICK_UPDATE_RESULT_PAK(2147487985U));
         }
         else
         {
             lock (votekick._votes)
                 votekick._votes.Add(slot._id);
             if (this.type == (byte)0)
             {
                 ++votekick.kikar;
                 if (slot._team == votekick.victimIdx % 2)
                 {
                     ++votekick.allies;
                 }
                 else
                 {
                     ++votekick.enemys;
                 }
             }
             else
             {
                 ++votekick.deixar;
             }
             if (votekick._votes.Count >= votekick.GetInGamePlayers())
             {
                 room.vote.Timer = (Timer)null;
                 AllUtils.votekickResult(room);
             }
             else
             {
                 using (VOTEKICK_UPDATE_PAK votekickUpdatePak = new VOTEKICK_UPDATE_PAK(votekick))
                     room.SendPacketToPlayers((SendPacket)votekickUpdatePak,SLOT_STATE.BATTLE,0);
             }
         }
     }
     catch (Exception ex)
     {
         Logger.info("VOTEKICK_UPDATE_REC: " + ex.ToString());
     }
 }
示例#28
0
 public BATTLE_ENDBATTLE_PAK(Account p)
 {
     this.p = p;
     if (p == null)
     {
         return;
     }
     this.r         = p._room;
     this.winner    = AllUtils.GetWinnerTeam(this.r);
     this.isBotMode = this.r.isBotMode();
     AllUtils.getBattleResult(this.r, out this.missionsFlag, out this.playersFlag, out this.array1);
 }
示例#29
0
 private void MyAttackAccepted(string Attack)
 {
     AllUtils.MyAttack = (AttackType)Convert.ToUInt16(Attack);
     InvokeUI(() => {
         pbMyAttack.Image        = AllUtils.GetAttackImageFromCode((ushort)AllUtils.MyAttack);
         lblAttackInfo.Text      = string.Format("{0}\nseçildi...", AllUtils.GetAttackNameFromCode((ushort)AllUtils.MyAttack));
         lblGameInfo.Text        = "RAKİBİN SEÇİMİ BEKLENİYOR...";
         pnlChooseAttack.Visible = false;
         pnlBattleArea.Visible   = true;
         lblAttackInfo.Width     = 142;
     });
 }
 public static void EndRound(Room room,byte winner)
 {
     room.swapRound = true;
     if (winner == 0)
     {
         room.red_rounds++;
     }
     else if (winner == 1)
     {
         room.blue_rounds++;
     }
     AllUtils.BattleEndRound(room,winner,RoundEndType.Normal);
 }