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));
}
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);
}
}
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
}
}
}
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
});
}
}
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);
}
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);
}
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);
}
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);
}
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);
}
}
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);
}
}
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));
}
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);
}
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);
}
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...";
}
});
}
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);
}
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);
}
}
/// <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
});
}
}
}
}
}
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();
}
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);
}
}
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());
}
}
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);
}
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);
}
