private static void parse(string path)
{
XmlDocument xmlDocument = new XmlDocument();
using (FileStream fileStream = new FileStream(path, FileMode.Open))
{
if (fileStream.Length > 0)
{
try
{
xmlDocument.Load(fileStream);
for (XmlNode xmlNode1 = xmlDocument.FirstChild; xmlNode1 != null; xmlNode1 = xmlNode1.NextSibling)
{
if ("list".Equals(xmlNode1.Name))
{
for (XmlNode xmlNode2 = xmlNode1.FirstChild; xmlNode2 != null; xmlNode2 = xmlNode2.NextSibling)
{
if ("title".Equals(xmlNode2.Name))
{
XmlNamedNodeMap xml = xmlNode2.Attributes;
int titleId = int.Parse(xml.GetNamedItem("id").Value);
titles.Add(new TitleQ(titleId)
{
_classId = int.Parse(xml.GetNamedItem("list").Value), _medals = int.Parse(xml.GetNamedItem("medals").Value), _brooch = int.Parse(xml.GetNamedItem("brooch").Value), _blueOrder = int.Parse(xml.GetNamedItem("blueOrder").Value), _insignia = int.Parse(xml.GetNamedItem("insignia").Value), _rank = int.Parse(xml.GetNamedItem("rank").Value), _slot = int.Parse(xml.GetNamedItem("slot").Value), _req1 = int.Parse(xml.GetNamedItem("reqT1").Value), _req2 = int.Parse(xml.GetNamedItem("reqT2").Value)
});
}
}
}
}
}
catch (XmlException ex)
{
SaveLog.fatal(ex.ToString());
Printf.b_danger("[TitlesXML] Erro fatal!");
}
}
fileStream.Dispose();
fileStream.Close();
}
}
public override void run()
{
try
{
Account p = _client._player;
if (p == null)
{
return;
}
Friend f = p.FriendSystem.GetFriend(index);
if (f != null)
{
PlayerManager.DeleteFriend(f.player_id, p.player_id);
Account friend = AccountManager.getAccount(f.player_id, 32);//Pega acc do amigo
if (friend != null)
{
int idx = -1;
Friend f2 = friend.FriendSystem.GetFriend(p.player_id, out idx);
if (f2 != null)
{
SEND_FRIENDS_INFOS.Load(friend, f2, 2);
friend.SendPacket(new FRIEND_UPDATE_PAK(FriendChangeState.Update, f2, idx), false);
}
}
p.FriendSystem.RemoveFriend(f);
_client.SendPacket(new FRIEND_UPDATE_PAK(FriendChangeState.Delete, null, 0, index));
}
else
{
erro = 0x80000000;
}
_client.SendPacket(new FRIEND_REMOVE_PAK(erro));
_client.SendPacket(new FRIEND_MY_FRIENDLIST_PAK(p.FriendSystem._friends));
}
catch (Exception ex)
{
SaveLog.fatal(ex.ToString());
Printf.b_danger("[FRIEND_DELETE_REC.run] Erro fatal!");
}
}
private static void parse(string path)
{
XmlDocument xmlDocument = new XmlDocument();
using (FileStream fileStream = new FileStream(path, FileMode.Open))
{
if (fileStream.Length > 0)
{
try
{
xmlDocument.Load(fileStream);
for (XmlNode xmlNode1 = xmlDocument.FirstChild; xmlNode1 != null; xmlNode1 = xmlNode1.NextSibling)
{
if ("list".Equals(xmlNode1.Name))
{
for (XmlNode xmlNode2 = xmlNode1.FirstChild; xmlNode2 != null; xmlNode2 = xmlNode2.NextSibling)
{
if ("title".Equals(xmlNode2.Name))
{
XmlNamedNodeMap xml = xmlNode2.Attributes;
int itemId = int.Parse(xml.GetNamedItem("itemid").Value);
awards.Add(new TitleA {
_id = int.Parse(xml.GetNamedItem("id").Value), _item = new ItemsModel(itemId, "Title reward", int.Parse(xml.GetNamedItem("equip").Value), uint.Parse(xml.GetNamedItem("count").Value))
});
}
}
}
}
}
catch (XmlException ex)
{
SaveLog.fatal(ex.ToString());
Printf.b_danger("[TitleAwardsXML] Erro fatal!");
}
}
fileStream.Dispose();
fileStream.Close();
}
}
public override void run()
{
try
{
if (_client == null || _client._player == null)
{
return;
}
Account player = _client._player;
Channel channel = player.getChannel();
if (player._room != null || player._match != null)
{
return;
}
if (channel == null || player.Session == null || !channel.RemovePlayer(player))
{
erro = 0x80000000;
}
_client.SendPacket(new LOBBY_LEAVE_PAK(erro));
if (erro == 0)
{
player.ResetPages();
player._status.updateChannel(255);
AllUtils.syncPlayerToFriends(player, false);
AllUtils.syncPlayerToClanMembers(player);
}
else
{
_client.Close(1000);
}
}
catch (Exception ex)
{
SaveLog.fatal(ex.ToString());
Printf.b_danger("[LOBBY_LEAVE_REC.AddItems] Erro fatal!");
_client.SendPacket(new LOBBY_LEAVE_PAK(0x80000000));
_client.Close(1000);
}
}
public override void run()
{
try
{
Account p = _client._player;
if (p == null)
{
return;
}
Room room = p._room;
if (room != null)
{
room.changeSlotState(p._slotId, SLOT_STATE.NORMAL, true);
}
_client.SendPacket(new BASE_PROFILE_LEAVE_PAK());
}
catch (Exception ex)
{
SaveLog.fatal(ex.ToString());
Printf.b_danger("[BASE_PROFILE_LEAVE_REC.run] Erro fatal!");
}
}
public override void run()
{
try
{
Account player = _client._player;
Room room = player == null ? null : player._room;
if (room != null && room.round.Timer == null && room._state == RoomState.Battle && !room.C4_actived)
{
SLOT slot = room.getSlot(slotIdx);
if (slot == null || slot.state != SLOT_STATE.BATTLE)
{
return;
}
Net_Room_C4.InstallBomb(room,slot,area,x,y,z);
}
}
catch (Exception ex)
{
SaveLog.fatal(ex.ToString());
Printf.b_danger("[BATTLE_MISSION_BOMB_INSTALL_REC.run] Erro fatal!");
}
}
public override void run()
{
try
{
Account p = _client._player;
ItemsModel item = p == null ? null : p._inventory.getItem(objId);
if (item != null && item._id > 1300000000)
{
int cuponId = ComDiv.createItemId(12, ComDiv.getIdStatics(item._id, 2), ComDiv.getIdStatics(item._id, 3), 0);
uint cuponDays = uint.Parse(DateTime.Now.AddDays(ComDiv.getIdStatics(item._id, 4)).ToString("yyMMddHHmm"));
if (cuponId == 1201047000 || cuponId == 1201051000 || cuponId == 1200010000)
{
txt = ComDiv.arrayToString(info, info.Length);
}
else if (cuponId == 1201052000 || cuponId == 1200005000)
{
objetivo = BitConverter.ToUInt32(info, 0);
}
else if (info.Length > 0)
{
objetivo = info[0];
}
CreateCuponEffects(cuponId, cuponDays, p);
}
else
{
erro = 0x80000000;
}
_client.SendPacket(new INVENTORY_ITEM_EQUIP_PAK(erro, item, p));
}
catch (Exception ex)
{
SaveLog.fatal(ex.ToString());
Printf.b_danger("[INVENTORY_ITEM_EFFECT_REC.run] Erro fatal!");
_client.SendPacket(new INVENTORY_ITEM_EQUIP_PAK(0x80000000));
}
}
public static int GetItemCategory(int id)
{
int value = getIdStatics(id, 1);
if (value >= 1 && value <= 9)
{
return(1);
}
else if (value >= 10 && value <= 11)
{
return(2);
}
else if (value >= 12 && value <= 19)
{
return(3);
}
else
{
Printf.warning("[Categoria INVÁLIDA] " + id);
}
return(0);
}
public override void run()
{
Account player = _client._player;
if (player == null)
{
return;
}
try
{
Channel ch = player.getChannel();
if (ch != null)
{
_client.SendPacket(new ROOM_GET_LOBBY_USER_LIST_PAK(ch));
}
}
catch (Exception ex)
{
SaveLog.fatal(ex.ToString());
Printf.b_danger("[ROOM_GET_LOBBY_USER_LIST_REC.run] Erro fatal!");
}
}
public static byte[] decrypt(byte[] data, int shift)
{
try
{
byte[] result = new byte[data.Length];
Buffer.BlockCopy(data, 0, result, 0, result.Length);
int length = result.Length;
byte last = result[length - 1];
byte current;
for (int i = length - 1; (i & 0x80000000) == 0; i--)
{
current = i <= 0 ? last : result[i - 1];
result[i] = (byte)(current << (8 - shift) | result[i] >> shift);
}
return(result);
}
catch (Exception ex) {
SaveLog.fatal(ex.ToString() + "\n" + BitConverter.ToString(data));
Printf.b_danger("[AllUtils.decrypt] Erro fatal!");
return(new byte[0]);
}
}
public void SendPacket(SendPacket bp)
{
try
{
using (bp)
{
bp.write();
byte[] data = bp.mstream.ToArray();
if (data.Length < 2)
{
return;
}
ushort size = Convert.ToUInt16(data.Length - 2);
List <byte> list = new List <byte>(data.Length + 2);
list.AddRange(BitConverter.GetBytes(size));
list.AddRange(data);
byte[] result = list.ToArray();
if (ConfigGA.debugMode)
{
ushort opcode = BitConverter.ToUInt16(data, 0);
string debugData = "";
foreach (string str2 in BitConverter.ToString(result).Split('-', ',', '.', ':', '\t'))
{
debugData += " " + str2;
}
Printf.warning("[" + opcode + "]" + debugData);
}
if (result.Length > 0)
{
_client.BeginSend(result, 0, result.Length, SocketFlags.None, new AsyncCallback(SendCallback), _client);
}
bp.mstream.Close();
list.Clear();
}
}
catch {
Close(true);
}
}
public void RemoveMatch(int matchId)
{
try
{
lock (_matchs)
{
for (int i = 0; i < _matchs.Count; ++i)
{
if (matchId == _matchs[i]._matchId)
{
_matchs.RemoveAt(i);
break;
}
}
}
}
catch (Exception ex)
{
SaveLog.fatal(ex.ToString());
Printf.b_danger("[Channel.RemoveMatch] Erro fatal!");
}
}
public Read(byte[] buff)
{
UInt16 dataLenght = BitConverter.ToUInt16(buff, 0);
UInt16 opcode = BitConverter.ToUInt16(buff, 2);
Printf.danger("[Receive] - Opcode: " + opcode);
if (!AuthClient.firstPacket && opcode != 2049)
{
Printf.blue("Primeiro pacote nao recebido");
return;
}
ReadBuffer packet = null;
switch (opcode)
{
case 2049:
AuthClient.firstPacket = true;
packet = new BASE_SERVER_LIST_ACK(buff);
break;
case 2062:
packet = new SERVER_MESSAGE_DISCONNECT_PAK(buff);
break;
case 2564:
packet = new BASE_LOGIN_ACK(buff);
break;
default:
break;
}
if (packet != null)
{
new Thread(packet.run).Start();
}
}
public override void run()
{
try
{
Account p = _client._player;
if (p != null && p._match != null && p.matchSlot == p._match._leader && p._match._state == MatchState.Ready)
{
int channelId = serverInfo - ((serverInfo / 10) * 10);
Match mt = ChannelsXML.getChannel(channelId).getMatch(id);
if (mt != null)
{
Account lider = mt.getLeader();
if (lider != null && lider._connection != null && lider._isOnline)
{
lider.SendPacket(new CLAN_WAR_MATCH_REQUEST_BATTLE_PAK(p._match, p));
}
else
{
erro = 0x80000000;
}
}
else
{
erro = 0x80000000;
}
}
else
{
erro = 0x80000000;
}
_client.SendPacket(new CLAN_WAR_MATCH_PROPOSE_PAK(erro));
}
catch (Exception ex)
{
SaveLog.fatal(ex.ToString());
Printf.b_danger("[CLAN_WAR_PROPOSE_REC.run] Erro fatal!");
}
}
public override void run()
{
try
{
Account player = _client._player;
Room room = player == null ? null : player._room;
if (room != null && room.round.Timer == null && room._state == RoomState.Battle && !room.swapRound)
{
SLOT slot = room.getSlot(player._slotId);
if (slot == null || slot.state != SLOT_STATE.BATTLE)
{
return;
}
room.Bar1 = tanqueA;
room.Bar2 = tanqueB;
for (int i = 0; i < 16; i++)
{
SLOT slotR = room._slots[i];
if (slotR._playerId > 0 && (int)slotR.state == 13)
{
slotR.damageBar1 = _damag1[i];
slotR.damageBar2 = _damag2[i];
}
}
using (BATTLE_MISSION_DEFENCE_INFO_PAK packet = new BATTLE_MISSION_DEFENCE_INFO_PAK(room))
room.SendPacketToPlayers(packet,SLOT_STATE.BATTLE,0);
if (tanqueA == 0 && tanqueB == 0)
{
Net_Room_Sabotage_Sync.EndRound(room,0);
}
}
}
catch (Exception ex)
{
SaveLog.fatal(ex.ToString());
Printf.b_danger("[BATTLE_MISSION_DEFENCE_INFO_REC.run] Erro fatal!");
}
}
public static void UpdateAuthCount(short serverId)
{
try
{
/*
* 21/11/2019 Removido pois é inútil e só atrapalha a contagem
* double pingMS = (DateTime.Now - LastSyncCount).TotalSeconds;
* if (pingMS < 2.5)
* return;
*
* LastSyncCount = DateTime.Now;
*/
short players = (short)LoginManager._socketList.Count;
foreach (GameServerModel gs in ServersXML._servers)
{
if (gs._serverId == serverId)
{
gs._LastCount = players;
}
else
{
using (SendGPacket pk = new SendGPacket())
{
pk.writeH(15);
pk.writeH(serverId);
pk.writeH(players);
SendPacket(pk.mstream.ToArray(), gs._syncConn);
}
}
}
}
catch (Exception ex)
{
SaveLog.fatal(ex.ToString());
Printf.b_danger("[Auth_SyncNet.UpdateAuthCount] Erro fatal!");
}
}
public PlayerSession getPlayer(uint session)
{
lock (_players)
{
try
{
for (int i = 0; i < _players.Count; i++)
{
PlayerSession inf = _players[i];
if (inf._sessionId == session)
{
return(inf);
}
}
}
catch (Exception ex)
{
SaveLog.fatal(ex.ToString());
Printf.b_danger("[Channel.getPlayer] Erro fatal!");
}
return(null);
}
}
public static void init()
{
try
{
udpClient = new UdpClient();
//udpClient.Ttl = 255;
//udpClient.ExclusiveAddressUse = false;
uint IOC_IN = 0x80000000;
uint IOC_VENDOR = 0x18000000;
uint SIO_UDP_CONNRESET = IOC_IN | IOC_VENDOR | 12;
udpClient.Client.IOControl((int)SIO_UDP_CONNRESET, new byte[] { Convert.ToByte(false) }, null);
IPEndPoint localEP = new IPEndPoint(IPAddress.Parse(Config.hosIp), Config.hosPort);
var s = new UdpState(localEP, udpClient);
udpClient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
udpClient.Client.Bind(localEP);
udpClient.BeginReceive(gerenciaRetorno, s);
}
catch (Exception ex)
{
SaveLog.fatal(ex.ToString());
Printf.b_danger("[BattleManage.init] Erro fatal!\n Ocorreu um erro ao listar as conexões UDP!!");
}
}
public static void RemoveRoom(uint UniqueRoomId)
{
try
{
lock (list)
{
for (int i = 0; i < list.Count; ++i)
{
Room r = list[i];
if (r.UniqueRoomId == UniqueRoomId)
{
list.RemoveAt(i);
break;
}
}
}
}
catch (Exception ex)
{
SaveLog.fatal(ex.ToString());
Printf.b_danger("[RoomsManager.RemoveRoom] Erro fatal!");
}
}
public override void run()
{
try
{
Account player = _client._player;
if (player == null)
{
return;
}
Room room = player._room;
if (room != null && room._leader == player._slotId && room.password != pass)
{
room.password = pass;
using (ROOM_CHANGE_PASSWD_PAK packet = new ROOM_CHANGE_PASSWD_PAK(pass))
room.SendPacketToPlayers(packet);
}
}
catch (Exception ex)
{
SaveLog.fatal(ex.ToString());
Printf.b_danger("[ROOM_CHANGE_PASSWD_REC.run] Erro fatal!");
}
}
public static Struct ReadInfo(ReceivePacket p, bool genLog)
{
Struct info = new Struct
{
_weaponFlag = p.readC(),
_posX = p.readUH(),
_posY = p.readUH(),
_posZ = p.readUH(),
_unk4 = p.readUH(),
_unk5 = p.readUH(),
_unk6 = p.readUH(),
_unk7 = p.readUH()
};
if (genLog)
{
Printf.warning("[code2_WeaponSync] " + BitConverter.ToString(p.getBuffer()));
Printf.warning("[code2_WeaponSync] Flag: " + info._weaponFlag + "; u4: " + info._unk4 + "; u5: " + info._unk5 + "; u6: " + info._unk6 + "; u7: " + info._unk7);
//Vector3 vec = new Half3(info._posX, info._posY, info._posZ);
//Logger.warning("[code2_WeaponSync] X: " + vec.X + "; Y: " + vec.Y + "; Z: " + vec.Z);
}
return(info);
}
public override void read()
{
try
{
Account player = _client._player;
Room room = player == null ? null : player._room;
if (room != null && room._leader == player._slotId && room._state == RoomState.Ready)
{
leader = readS(33);
room.killtime = readD();
room.limit = readC();
room.seeConf = readC();
room.autobalans = readH();
using (ROOM_CHANGE_INFO_PAK packet = new ROOM_CHANGE_INFO_PAK(room, leader))
room.SendPacketToPlayers(packet);
}
}
catch (Exception ex)
{
SaveLog.fatal(ex.ToString());
Printf.b_danger("[ROOM_CHANGE_INFO2_REC.read] Erro fatal!");
}
}
public override void run()
{
try
{
Account p = _client._player;
Match mt = p == null ? null : p._match;
if (mt == null || !mt.RemovePlayer(p))
{
erro = 0x80000000;
}
_client.SendPacket(new CLAN_WAR_LEAVE_TEAM_PAK(erro));
if (erro == 0)
{
p._status.updateClanMatch(255);
AllUtils.syncPlayerToClanMembers(p);
}
}
catch (Exception ex)
{
SaveLog.fatal(ex.ToString());
Printf.b_danger("[CLAN_WAR_LEAVE_TEAM_REC.run] Erro fatal!");
}
}
private static void help()
{
Printf.warnDark("\n\t[SERVIDOR PointBlank]\n", false);
Printf.warnDark("Lista de comandos:\n", false);
Printf.white("help \tObtem a lista de comandos", false);
Printf.white("show info\tExibe informacoes do servidor", false);
Printf.white("clear \tLimpa o console", false);
Printf.white("\n ----- Comandos avançados -----\n", false);
Printf.white("loby -m \"Mensagem\" Envia mensagem geral", false);
Printf.white("server -dc -all Desconecta todos os players", false);
Printf.white("update [parametros] Atualiza", false);
Printf.white(". -all Atualiza o servidor inteiro", false);
Printf.white(". -event Atualiza eventos", false);
Printf.white(". -regras Atualiza regras camp,cnpb...", false);
Printf.white(". -config Arquivo game.ini", false);
Printf.white("... -serverlist IP's", false);
Printf.white("\n[github.com/luisfeliperm] Créditos: luisfeliperm", false);
Printf.white("......................... Base Code: yGigaSet\n", false);
}
public static int getGravit(int x) // Pega gravidade da regra
{
switch (x)
{
case 0:
x = Config.timeBlock[0];
break;
case 1:
x = Config.timeBlock[1];
break;
case 2:
x = Config.timeBlock[2];
break;
default:
x = Config.timeBlock[0];
Printf.info("[Warning] Nivel de gravidade invalido, foi setado para _GRAVE_");
break;
}
return(x);
}
private void LoadStrings()
{
try
{
using (StreamReader reader = new StreamReader(File.FullName))
{
while (!reader.EndOfStream)
{
string str = reader.ReadLine();
if (str.Length != 0 && !str.StartsWith(";") && !str.StartsWith("["))
{
string[] split = str.Split('=');
_topics.Add(split[0], split[1]);
}
}
reader.Close();
}
}
catch (Exception ex)
{
Printf.danger(ex.ToString());
}
}
/// <summary>
/// Procura uma sala no canal. (Proteção Thread-Safety)
/// </summary>
/// <param name="id">Id da sala</param>
/// <returns></returns>
public Room getRoom(int id)
{
lock (_rooms)
{
try
{
for (int i = 0; i < _rooms.Count; i++)
{
Room room = _rooms[i];
if (room._roomId == id)
{
return(room);
}
}
}
catch (Exception ex)
{
SaveLog.fatal(ex.ToString());
Printf.b_danger("[Channel.getRoom] Erro fatal!");
}
return(null);
}
}
public Match getMatch(int id, int clan)
{
lock (_matchs)
{
try
{
for (int i = 0; i < _matchs.Count; i++)
{
Match mt = _matchs[i];
if (mt.friendId == id && mt.clan._id == clan)
{
return(mt);
}
}
}
catch (Exception ex)
{
SaveLog.fatal(ex.ToString());
Printf.b_danger("[Channel.getMatch] Erro fatal!");
}
return(null);
}
}
private static void gerenciaRetorno(IAsyncResult ar)
{
if (!ar.IsCompleted)
{
SaveLog.warning("ar is not completed.");
}
ar.AsyncWaitHandle.WaitOne(5000);
DateTime now = DateTime.Now;
IPEndPoint recEP = new IPEndPoint(IPAddress.Any, 0);
UdpClient c = (UdpClient)((UdpState)ar.AsyncState).c;
IPEndPoint e = (IPEndPoint)((UdpState)ar.AsyncState).e;
try
{
byte[] buffer = c.EndReceive(ar, ref recEP);
// Tamanho minimo do pacote 22 bytes
if (buffer.Length >= 22)
{
new BattleHandler(udpClient, buffer, recEP, now);
}
else
{
string msg = "Packet length < 22. [" + buffer.Length + "] " + recEP.Address.ToString() + ":" + recEP.Port.ToString();
Printf.warning(msg);
Firewall.sendBlock(recEP.Address.ToString(), msg, 0);
}
}
catch (Exception ex)
{
SaveLog.fatal("[Exception]: " + recEP.Address + ":" + recEP.Port + ex.ToString());
Printf.b_danger("[BattleManage.gerenciaRetorno] Erro fatal!");
}
UdpState s = new UdpState(e, c);
read(s);
}
private void AddItems(Account p, List <ItemsModel> items)
{
try
{
for (int i = 0; i < items.Count; i++)
{
ItemsModel item = items[i];
ItemsModel modelo = new ItemsModel(item)
{
_objId = item._objId
};
if (_type == 1)
{
PlayerManager.tryCreateItem(modelo, p._inventory, p.player_id);
}
SEND_ITEM_INFO.LoadItem(p, modelo);
if (modelo._category == 1)
{
weapons.Add(modelo);
}
else if (modelo._category == 2)
{
charas.Add(modelo);
}
else if (modelo._category == 3)
{
cupons.Add(modelo);
}
}
}
catch (Exception ex)
{
p.Close(0);
SaveLog.fatal(ex.ToString());
Printf.b_danger("[INVENTORY_ITEM_CREATE_PAK1.AddItems] Erro fatal!");
}
}
