public static void ProcessDeleteChar(Client client, PacketReader packetReader)
{
var uid = packetReader.ReadMuid();
var index = packetReader.ReadInt32();
var name = packetReader.ReadString();
var result = Results.Accepted;
if (uid != client.GetMuid() || !Globals.AcceptedString.IsMatch(name) || index < 0 || index > 4)
{
client.Disconnect();
return;
}
var cid = Globals.GunzDatabase.GetCid(client.ClientPlayer.PlayerAccount.AccountId, index);
if (cid == 0)
{
result = Results.CharacterDeleteDisabled;
}
else
{
Globals.GunzDatabase.DeleteCharacter(client.ClientPlayer.PlayerAccount.AccountId, cid);
}
Match.ResponseDeleteCharacter(client, result);
}
public override void OnGameKill(Client killer, Client victim)
{
if (killer == CurrentBerserker && CurrentStage.GetTraits().Name.ToLower().Contains("[sb]"))
{
lock (CurrentStage.ObjectLock)
{
Battle.AssignBerserker(CurrentStage.GetTraits().Players, CurrentBerserker.GetMuid());
}
}
if (victim == CurrentBerserker || CurrentBerserker == null)
{
lock (CurrentStage.ObjectLock)
{
CurrentBerserker = killer;
Battle.AssignBerserker(CurrentStage.GetTraits().Players, CurrentBerserker.GetMuid());
}
}
if (killer.ClientPlayer.PlayerStats.Kills == CurrentStage.GetTraits().RoundCount)
{
GameInProgress = false;
ItemSpawns.Abort();
GameOver();
}
else
{
Spawn(victim, 5);
}
}
public static void ProcessCreateChar(Client client, PacketReader packetReader)
{
var uid = packetReader.ReadMuid();
var index = packetReader.ReadInt32();
var name = packetReader.ReadString();
var sex = packetReader.ReadInt32();
var hair = packetReader.ReadInt32();
var face = packetReader.ReadInt32();
var costume = packetReader.ReadInt32();
var result = Results.Accepted;
if (uid != client.GetMuid() || index < 0 || index > 4 || sex < 0 || sex > 1)
{
client.Disconnect();
return;
}
if (!Globals.AcceptedString.IsMatch(name))
result = Results.CharacterEnterName;
else if (Globals.GunzDatabase.GetCharacterCount(client.ClientPlayer.PlayerAccount.AccountId) >= 4)
result = Results.CharacterNameNonExistant;
else if (Globals.GunzDatabase.CharacterExists(name))
result = Results.CharacterNameInUse;
else if (!Globals.GunzDatabase.CreateCharacter(client.ClientPlayer.PlayerAccount.AccountId, (byte)index, name, sex, hair, face, costume))
result = Results.CharacterInvalidName;
Match.ResponseCreateChar(client, result, name);
}
public virtual void GameKillCallback(Client killer, Client victim)
{
victim.ClientPlayer.PlayerStats.Spawned = false;
if (_gameType == ObjectStageGameType.Training)
{
var uids = new Pair<Muid, Muid>(killer.GetMuid(), victim.GetMuid());
var args = new Pair<UInt32, UInt32>(0, 0);
lock (CurrentStage.ObjectLock)
{
Battle.GameDie(CurrentStage.GetTraits().Players, uids, args);
}
}
else
{
if (killer != victim)
{
var exp = ExpManager.GetExpFromKill(killer.GetCharacter().Level,
victim.GetCharacter().Level);
killer.GetCharacter().Xp += exp;
var uids = new Pair<Muid, Muid>(killer.GetMuid(), victim.GetMuid());
var args = new Pair<UInt32, UInt32>((exp << 16), 0);
lock (CurrentStage.ObjectLock)
{
Battle.GameDie(CurrentStage.GetTraits().Players, uids, args);
//killer.GetCharacter().Level =
// (Int16) ExpManager.GetLevel((Int32) killer.GetCharacter().Xp);
Log.Write("Exp Gained: {0} | Exp To Next Level: {1} | Current Exp: {2}", exp, ExpManager.GetExp(killer.GetCharacter().Level + 1), killer.GetCharacter().Xp);
if (ExpManager.Level(killer.GetCharacter().Level,
killer.GetCharacter().Xp))
{
killer.GetCharacter().Level++;
Battle.GameLevelUp(CurrentStage.GetTraits().Players, killer.GetMuid(),
killer.GetCharacter().Level);
EventManager.AddCallback(
() =>
Globals.GunzDatabase.UpdateLevel(killer.GetCharacter().CharacterId,
killer.GetCharacter().Xp,
killer.GetCharacter().Level));
}
}
killer.ClientPlayer.PlayerStats.Kills++;
victim.ClientPlayer.PlayerStats.Deaths++;
if (killer.ClientPlayer.PlayerStats.Kills%20 == 0)
{
EventManager.AddCallback(
() =>
Globals.GunzDatabase.UpdateLevel(killer.GetCharacter().CharacterId,
killer.GetCharacter().Xp,
killer.GetCharacter().Level));
}
}
}
OnGameKill(killer, victim);
}
public static void LadderPrepare(Client client, int teamNumber)
{
using (var packet = new PacketWriter(Operation.LadderPrepare, CryptFlags.Encrypt))
{
packet.Write(client.GetMuid());
packet.Write(teamNumber);
client.Send(packet);
}
}
public static void ResponseBridgePeer(Client client)
{
using (var packet = new PacketWriter(Operation.BridgeResponse, CryptFlags.Decrypt))
{
packet.Write(client.GetMuid());
packet.Write((Int32)Results.Accepted);
client.Send(packet);
}
}
public static void Announce(Client client, string message)
{
using (var packet = new PacketWriter(Operation.AdminAnnounce, CryptFlags.Decrypt))
{
packet.Write(client.GetMuid());
packet.Write(message);
packet.Write(0);
TcpServer.GlobalPacket(packet);
}
}
public override void OnInitialStart()
{
var traits = CurrentStage.GetTraits();
var rand = new Random();
var red = traits.Players.FindAll(c => c.ClientPlayer.PlayerTeam == Team.Red);
var blue = traits.Players.FindAll(c => c.ClientPlayer.PlayerTeam == Team.Blue);
RedVip = red[rand.Next(red.Count)];
BlueVip = blue[rand.Next(blue.Count)];
Battle.AssignVips(traits.Players, RedVip.GetMuid(), BlueVip.GetMuid());
new Thread(ItemThread).Start();
}
public static void AskAgreement(List<Client> clients, Client proposer, int mode, int request)
{
using (var packet = new PacketWriter(Operation.MatchAskAgreement, CryptFlags.Encrypt))
{
packet.Write(proposer.GetMuid());
packet.Write(clients.Count+1, 32);
clients.ForEach(c => packet.Write(c.GetCharacter().Name, 32));
packet.Write(proposer.GetCharacter().Name, 32);
packet.Write(mode);
packet.Write(request);
clients.ForEach(c => c.Send(packet));
}
}
public override void GameInfoCallback(Client client)
{
var traits = CurrentStage.GetTraits();
lock (CurrentStage.ObjectLock)
{
Battle.BattleResponseInfo(client, Scores[0], Scores[1], traits.Players);
}
client.ClientPlayer.PlayerStats.Spawned = true;
client.ClientPlayer.PlayerStats.RequestedInfo = true;
if (client.ClientPlayer.PlayerStats.LateJoined)
{
lock (CurrentStage.ObjectLock)
{
if (traits.DuelQueue.Challenger != null)
{
traits.DuelQueue.AddToQueue(client);
var players = traits.DuelQueue.Clone();
Battle.DuelQueue(client, players, (byte)traits.DuelQueue.WaitQueue.Count,
traits.DuelQueue.Victories, true);
Battle.SetObserver(traits.Players, client.GetMuid());
}
else
{
var players = traits.DuelQueue.Clone();
players.Add(client);
Battle.DuelQueue(client, players, (byte)(traits.DuelQueue.WaitQueue.Count+1), traits.DuelQueue.Victories);
traits.DuelQueue.Challenger = client;
players = traits.DuelQueue.Clone();
Battle.DuelQueue(traits.Players, players, traits.DuelQueue.QueueLength,
traits.DuelQueue.Victories, true);
ThreadPool.QueueUserWorkItem(StartNextRound);
}
}
}
ProcessRoundState();
}
private void ProcessRound(object o)
{
var traits = CurrentStage.GetTraits();
Log.Write("Starting new round.");
lock (CurrentStage.ObjectLock)
{
GameInProgress = true;
if (traits.Time > 0)
{
GameTimer = new Timer();
GameTimer.Interval = TimeSpan.FromMinutes(traits.Time).TotalMilliseconds;
GameTimer.Elapsed += (s, a) => OnRoundEnd();
GameTimer.Enabled = true;
}
traits.Players.ForEach(delegate(Client c)
{
c.ClientPlayer.PlayerStats.Spawned = false;
c.ClientPlayer.PlayerStats.Entered = false;
c.ClientPlayer.PlayerStats.RequestedInfo = false;
});
traits.Round = RoundState.Countdown;
Battle.StageRoundUpdate(traits.Players, traits.StageId, traits.CurrentRound, traits.Round);
Thread.Sleep(TimeSpan.FromSeconds(3));
traits.Round = RoundState.Play;
Battle.StageRoundUpdate(traits.Players, traits.StageId, traits.CurrentRound, traits.Round);
traits.Players.ForEach(delegate(Client c)
{
c.ClientPlayer.PlayerStats.Spawned = true;
c.ClientPlayer.PlayerStats.InGame = true;
});
var rand = new Random();
var red = traits.Players.FindAll(c => c.ClientPlayer.PlayerTeam == Team.Red);
var blue = traits.Players.FindAll(c => c.ClientPlayer.PlayerTeam == Team.Blue);
RedVip = red[rand.Next(red.Count)];
BlueVip = blue[rand.Next(blue.Count)];
Battle.AssignVips(traits.Players, RedVip.GetMuid(), BlueVip.GetMuid());
if (!_killThread)
{
_killThread = true;
while (_killThread)
{
Thread.Sleep(1);
}
}
_killThread = false;
new Thread(ItemThread).Start();
}
}
public static void ResponseLeave(Client client, Muid channel)
{
using (var packet = new PacketWriter(Operation.ChannelLeave, CryptFlags.Encrypt))
{
packet.Write(client.GetMuid());
packet.Write(channel);
client.Send(packet);
}
}
public virtual void GameLoadedCallback(Client client)
{
lock (_stage.ObjectLock)
{
Battle.LoadingComplete(CurrentStage.GetTraits().Players, client.GetMuid());
}
if (_stage.GetTraits().Master != client)
client.ClientPlayer.PlayerState = ObjectStageState.NonReady;
client.ClientPlayer.PlayerStats.InGame = true;
client.ClientPlayer.PlayerStats.Loaded = true;
client.ClientPlayer.PlayerLocation = Place.Battle;
ProcessRoundState();
}
public static void ResponseStageJoin(Client client, Results result)
{
using (var packet = new PacketWriter(Operation.StageJoin, CryptFlags.Encrypt))
{
packet.Write(client.GetMuid());
packet.Write(client.GetStage().GetTraits().StageId);
packet.Write(client.GetStage().GetTraits().StageIndex);
packet.Write(client.GetStage().GetTraits().Name);
client.Send(packet);
}
}
public static void ProcessLoginRequest(Client client, PacketReader packetReader)
{
var user = packetReader.ReadString();
var pass = packetReader.ReadString();
var version = packetReader.ReadInt32();
var checksum = packetReader.ReadInt32();
var totalSize = packetReader.ReadInt32();
var blobSize = packetReader.ReadInt32();
var blobCount = packetReader.ReadInt32();
var md5 = new byte[blobSize*blobCount];
packetReader.Read(md5, 0, blobSize);
if (blobSize > 32)
{
client.Disconnect();
return;
}
if (!Globals.AcceptedString.IsMatch(user) || !Globals.AcceptedString.IsMatch(pass))
{
Match.ResponseLogin(client, Results.LoginAuthenticationFailed, user, UGradeId.Guest, PGradeId.Free, new Muid(0,0));
client.Disconnect();
return;
}
if (Globals.Config.Server.AutoRegistration)
{
if (user.StartsWith("!r"))
{
user = user.Substring(2);
if (!Globals.GunzDatabase.AccountExists(user))
Globals.GunzDatabase.CreateAccount(user, pass, ref client.ClientPlayer.PlayerAccount);
else
{
Match.ResponseNotify(client, "That account is already in use!", 1);
client.Disconnect();
return;
}
}
else
Globals.GunzDatabase.GetAccount(user, pass, ref client.ClientPlayer.PlayerAccount);
}
else
Globals.GunzDatabase.GetAccount(user, pass, ref client.ClientPlayer.PlayerAccount);
if (client.ClientPlayer.PlayerAccount.AccountId == 0)
{
Match.ResponseLogin(client, Results.LoginIncorrectPassword, user, UGradeId.Guest, PGradeId.Free, new Muid(0, 0));
client.Disconnect();
return;
}
if (client.ClientPlayer.PlayerAccount.Access == UGradeId.Banned || client.ClientPlayer.PlayerAccount.Access == UGradeId.Criminal)
{
Match.ResponseLogin(client, Results.LoginBannedId, user, UGradeId.Guest, PGradeId.Free, new Muid(0, 0));
client.Disconnect();
return;
}
if (version != Globals.Config.Client.Version)
{
Match.ResponseLogin(client, Results.LoginInvalidVersion, user, UGradeId.Guest, PGradeId.Free, new Muid(0, 0));
return;
}
if (Globals.Config.Client.UseCrc)
{
if ((checksum^0) != Globals.Config.Client.FileList)
{
Match.ResponseLogin(client, Results.LoginInvalidVersion, user, UGradeId.Guest, PGradeId.Free, new Muid(0, 0));
client.Disconnect();
return;
}
}
var inuse = TcpServer.GetClientFromAid(client.ClientPlayer.PlayerAccount.AccountId);
if (inuse != null && inuse != client)
{
inuse.Disconnect();
}
client.ClientFlags = PacketFlags.Login;
Match.ResponseLogin(client, Results.Accepted, user, client.ClientPlayer.PlayerAccount.Access, PGradeId.Free, client.GetMuid());
}
public void PlayerState(Client client)
{
lock (ObjectLock)
StagePackets.ResponsePlayerState(_traits.Players, client.GetMuid(), _traits.StageId, client.ClientPlayer.PlayerState);
}
public static void ProcessCreateClan(Client client, PacketReader packetReader)
{
var masterId = packetReader.ReadMuid();
var reqeuest = packetReader.ReadInt32();
var clanName = packetReader.ReadString();
var member1 = packetReader.ReadString();
var member2 = packetReader.ReadString();
var member3 = packetReader.ReadString();
var member4 = packetReader.ReadString();
var members = new List<Client>();
members.Add(TcpServer.GetClientFromName(member1));
members.Add(TcpServer.GetClientFromName(member2));
members.Add(TcpServer.GetClientFromName(member3));
members.Add(TcpServer.GetClientFromName(member4));
if (!Globals.AcceptedString.IsMatch(clanName))
{
return;
}
if (Globals.GunzDatabase.ClanExists(clanName))
{
ClanPackets.ResponseCreateClan(client, Results.ClanNameInUse, reqeuest);
return;
}
foreach (var member in members)
{
if (member == null || Globals.GunzDatabase.IsInClan(member))
{
ClanPackets.ResponseCreateClan(client, Results.ClanUserAlreadyInAClan, reqeuest);
return;
}
}
var pendingClan = new PendingClan();
pendingClan.ClanMaster = client;
pendingClan.ClanName = clanName;
pendingClan.RequestId = reqeuest;
pendingClan.Member1 = new Pair<Client, bool>(members[0], false);
pendingClan.Member2 = new Pair<Client, bool>(members[1], false);
pendingClan.Member3 = new Pair<Client, bool>(members[2], false);
pendingClan.Member4 = new Pair<Client, bool>(members[3], false);
lock (Globals.PendingClans)
Globals.PendingClans.Add(pendingClan);
ClanPackets.ResponseCreateClan(client, Results.Accepted, reqeuest);
ClanPackets.AskAgreement(members, reqeuest, clanName, client.GetMuid(), client.GetCharacter().Name);
var responsetimer = new Timer(30000);
responsetimer.Elapsed += (s, o) => CancelRequest(client, pendingClan, responsetimer);
responsetimer.Start();
}
public override void GameLeaveBattle(Client client)
{
lock (CurrentStage.ObjectLock)
{
client.ClientPlayer.PlayerStats = new GameStats();
Battle.LeaveBattle(CurrentStage.GetTraits().Players, client.GetMuid());
if (client == CurrentStage.GetTraits().DuelQueue.Champion || client == CurrentStage.GetTraits().DuelQueue.Challenger)
{
var traits = CurrentStage.GetTraits();
if (traits.DuelQueue.Challenger == client)
{
if (traits.DuelQueue.WaitQueue.Count > 0)
{
traits.DuelQueue.NewChallenger();
}
else
{
traits.DuelQueue.Challenger = null;
}
if (traits.DuelQueue.Victories % 10 == 0 && traits.DuelQueue.Victories > 0)
Battle.UpdateDuelStreak(traits.DuelQueue.Champion.GetCharacter().Name, traits.DuelQueue.Champion.ClientPlayer.PlayerChannel.GetTraits().ChannelName, traits.StageIndex, traits.DuelQueue.Victories);
}
else
{
if (traits.DuelQueue.Victories % 10 == 0 && traits.DuelQueue.Victories > 0)
Battle.EndDuelStreak(traits.DuelQueue.Champion.GetCharacter().Name, traits.DuelQueue.Challenger.GetCharacter().Name, traits.DuelQueue.Victories);
traits.DuelQueue.NewChampion();
}
ThreadPool.QueueUserWorkItem(StartNextRound);
return;
}
CurrentStage.GetTraits().DuelQueue.RemovePlayer(client);
var players = CurrentStage.GetTraits().DuelQueue.Clone();
Battle.DuelQueue(CurrentStage.GetTraits().Players, players, (byte)CurrentStage.GetTraits().DuelQueue.WaitQueue.Count,
CurrentStage.GetTraits().DuelQueue.Victories);
}
base.GameLeaveBattle(client);
}
protected void Spawn(Client client, int sleep = 0)
{
if (sleep > 0)
Thread.Sleep(sleep * 1000);
var map = _stage.GetTraits().CurrentMap;
var r = new Random();
var index = r.Next(1, map.Deathmatch.Count);
var coords = map.Deathmatch[index];
lock (_stage.ObjectLock)
{
Battle.GameSpawn(CurrentStage.GetTraits().Players, client.GetMuid(), coords.First, coords.Second);
}
}
public static void ResponseNotify(Client client, string message, Int32 type = 0)
{
using (var packet = new PacketWriter(Operation.AdminAnnounce, CryptFlags.Encrypt))
{
packet.Write(client.GetMuid());
packet.Write(message);
packet.Write(type);
client.Send(packet);
}
}
public static void ProcessObtainWorldItem(Client client, PacketReader packet)
{
var uidChar = packet.ReadMuid();
var nItem = packet.ReadInt32();
lock (client.GetStage().GetTraits().CurrentMap)
{
var i =
client.GetStage().GetTraits().CurrentMap.DeathMatchItems.Find(
ii => ii.ItemUid == nItem);
if (i != null)
{
i.Taken = true;
i.NextSpawn = DateTime.Now.AddSeconds(i.SpawnTime);
Log.Write("Spawning item: {0}. Next Spawn: {1}", i.ItemId, DateTime.Now.AddSeconds(i.SpawnTime / 1000));
}
else
{
lock (client.GetStage().GetTraits().WorldItems)
{
i = client.GetStage().GetTraits().WorldItems.Find(ii => ii.ItemUid == nItem);
if (i != null)
{
client.GetStage().GetTraits().WorldItems.Remove(i);
}
else
{
return;
}
}
}
lock (client.GetStage().ObjectLock)
Battle.ObtainWorldItem(client.GetStage().GetTraits().Players,
client.GetMuid(), nItem);
}
}
public static void ProcessGameSpawn(Client client, PacketReader packetReader)
{
var uid = packetReader.ReadUInt64();
var xpos = packetReader.ReadSingle();
var ypos = packetReader.ReadSingle();
var zpos = packetReader.ReadSingle();
var xdir = packetReader.ReadSingle();
var ydir = packetReader.ReadSingle();
var zdir = packetReader.ReadSingle();
if (client.GetStage() != null)
{
var traits = client.GetStage().GetTraits();
if (traits.Ruleset.IsDuel())
{
if (traits.DuelQueue.Challenger != client && traits.DuelQueue.Champion != client)
return;
}
if (traits.Ruleset.IsTeam())
return;
var position = new Position();
var direction = new Direction();
position.X = xpos;
position.Y = ypos;
position.Z = zpos;
direction.X = xdir;
direction.Y = ydir;
direction.Z = zdir;
lock (client.GetStage().ObjectLock)
{
Battle.GameSpawn(client.GetStage().GetTraits().Players, client.GetMuid(),
position, direction);
}
}
}
public static void ResponseObjectCacheExclusive(List<Client> clients, ObjectCache cache, Client player)
{
using (var packet = new PacketWriter(Operation.MatchObjectCache, CryptFlags.Encrypt))
{
packet.Write((byte) cache);
packet.Write(1, 176);
packet.Write(0);
packet.Write(player.GetMuid());
packet.Write(player.GetCharacter().Name, 32);
packet.Write(player.GetCharacter().ClanName, 16);
packet.Write((Int32) player.GetCharacter().Level);
packet.Write((Int32) player.ClientPlayer.PlayerAccount.Access);
packet.Write(0);
packet.Write(0);
packet.Write(player.GetCharacter().ClanId);
packet.Write(0);
packet.Write((Int32) player.GetCharacter().Sex);
packet.Write(player.GetCharacter().Hair);
packet.Write(player.GetCharacter().Face);
packet.Write((Int16) 0);
foreach (var item in player.GetCharacter().EquippedItems)
{
packet.Write(item.ItemId);
}
packet.Write(player.GetCharacter().Rank); //rank
packet.Write(player.GetCharacter().Kills); //kill
packet.Write(player.GetCharacter().Deaths); //death
packet.Write(player.GetCharacter().DuelRank); //duel
clients.ForEach(c => c.Send(packet));
}
}
public static void RequestJoin(Client client, Client target, string clanName)
{
using (var packet = new PacketWriter(Operation.MatchClanAskJoinAgreement, CryptFlags.Encrypt))
{
packet.Write(clanName);
packet.Write(client.GetMuid());
packet.Write(client.GetCharacter().Name);
target.Send(packet);
}
}
public void Team(Client client)
{
lock (ObjectLock)
StagePackets.ResponseStageTeam(_traits.Players, client.GetMuid(), _traits.StageId,
client.ClientPlayer.PlayerTeam);
}
public virtual void GameLeaveBattle(Client client)
{
lock (_stage.ObjectLock)
{
Globals.GunzDatabase.UpdateLevel(client.GetCharacter().CharacterId, client.GetCharacter().Xp, client.GetCharacter().Level);
client.ClientPlayer.PlayerStats.Reset();
Battle.LeaveBattle(CurrentStage.GetTraits().Players, client.GetMuid());
var traits = _stage.GetTraits();
if (traits.Players.FindAll(c => !c.GetGameStats().InGame).Count == traits.Players.Count)
{
traits.State = StageState.Standby;
foreach (var c in _stage.GetTraits().Players)
{
c.ClientPlayer.PlayerStats = new GameStats();
if (c != traits.Master)
client.ClientPlayer.PlayerState = ObjectStageState.NonReady;
}
if (_gameType == ObjectStageGameType.DeathMatch && (this as Deathmatch).ItemSpawns != null)
(this as Deathmatch).ItemSpawns.Abort();
else if (_gameType == ObjectStageGameType.Berserker && (this as Berserker).ItemSpawns != null)
(this as Berserker).ItemSpawns.Abort();
else if (_gameType == ObjectStageGameType.TeamDeathMatchExtreme && (this as TeamDeathmatchExtreme).ItemSpawns != null)
(this as TeamDeathmatchExtreme).ItemSpawns.Abort();
_stage.GetTraits().Players.ForEach(c => StagePackets.ResponseSettings(_stage.GetTraits().Players, _stage.GetTraits()));
}
}
}
public static void ProcessStageCreate(Client client, PacketReader packetReader)
{
var uid = packetReader.ReadMuid();
var name = packetReader.ReadString();
var locked = packetReader.ReadBoolean();
var password = packetReader.ReadString();
if (uid != client.GetMuid())
{
client.Disconnect();
return;
}
var traits = new StageTraits();
traits.StageId = Globals.StageCounter.GetNext();
traits.Name = name;
traits.Locked = locked;
traits.Password = password;
traits.Master = client;
client.ClientPlayer.PlayerStage = client.GetChannel().Add(traits);
client.GetStage().Join(client);
}
public void Chat(Client client, string message)
{
lock(ObjectLock)
StagePackets.ResponseStageChat( _traits.Players, client.GetMuid(), _traits.StageId, message);
Settings(client,true);
}
public static void GameEnterBattle(List<Client> clients, Client client)
{
var stage = client.GetStage().GetTraits();
using (var packet = new PacketWriter(Operation.StageEnterBattle, CryptFlags.Encrypt))
{
if (stage.State == StageState.Standby)
packet.Write((byte)0);
else
packet.Write((byte)1);
//really hate constants :(.
packet.Write(1, 394);
packet.Write(client.GetMuid());
if (client.PeerEnd == null)
{
packet.Write(new byte[4], 0, 4);
packet.Write(0);
}
else
{
packet.Write(client.PeerEnd.Address.GetAddressBytes(), 0, 4);
packet.Write(client.PeerEnd.Port);
}
packet.Write(client.GetCharacter().Name, 32);
packet.Write(client.GetCharacter().ClanName, 16);
packet.Write((Int32)client.GetCharacter().ClanGrade);//clan rank
packet.Write(client.GetCharacter().ClanPoint);//clan points
packet.Write((byte)0);//?
packet.Write(client.GetCharacter().Level);
packet.Write(client.GetCharacter().Sex);
packet.Write(client.GetCharacter().Hair);
packet.Write(client.GetCharacter().Face);
packet.Write(client.GetCharacter().Xp);
packet.Write(client.GetCharacter().Bp);
packet.Write(client.GetCharacter().BonusRate);
packet.Write(client.GetCharacter().Prize);
packet.Write(client.GetCharacter().Hp);
packet.Write(client.GetCharacter().Ap);
packet.Write(client.GetCharacter().MaxWeight);
packet.Write(client.GetCharacter().SafeFalls);
packet.Write(client.GetCharacter().Fr);
packet.Write(client.GetCharacter().Cr);
packet.Write(client.GetCharacter().Er);
packet.Write(client.GetCharacter().Wr);
foreach (Item nItem in client.GetCharacter().EquippedItems)
packet.Write(nItem.ItemId);
packet.Write((Int32)client.ClientPlayer.PlayerAccount.Access);
packet.Write(client.GetCharacter().ClanId);
packet.Write(client.GetCharacter().DuelRank); // duel tourney
byte[] obfuscation = new byte[] {
0x00, 0x00, 0x00, 0x00, //head
0x79, 0xF5, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, //chest
0x7B, 0xF5, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, //hands
0x6E, 0xF5, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, //legs
0x6D, 0xF5, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, //feet
0x6C, 0xF5, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, //fingerL
0x49, 0xF5, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, //fingerR
0x48, 0xF5, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, //melee
0x4B, 0xF5, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, //primary
0x72, 0xF5, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, //secondary
0x4C, 0xF5, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, //custom1
0x7F, 0xF5, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, //custom2
0x4A, 0xF5, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, //avatar
0x80, 0xF5, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, //community1
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, //community2
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, //long buff1
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, //long buff2
0x00, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, //head quantity
0x01, 0x00, 0x00, 0x00, //chest quantity
0x01, 0x00, 0x00, 0x00, //hands quantity
0x01, 0x00, 0x00, 0x00, //legs quantity
0x01, 0x00, 0x00, 0x00, //feet quantity
0x01, 0x00, 0x00, 0x00, //fingerL quantity
0x01, 0x00, 0x00, 0x00, //fingerR quantity
0x01, 0x00, 0x00, 0x00, //melee quantity
0x01, 0x00, 0x00, 0x00, //primary quantity
0x01, 0x00, 0x00, 0x00, //secondary quantity
0x4C, 0x00, 0x00, 0x00, //custom1 quantity
0x01, 0x00, 0x00, 0x00, //custom2 quantity
0x01, 0x00, 0x00, 0x00, //vatar quantity
0x00, 0x00, 0x00, 0x00, //community1 quantity
0x00, 0x00, 0x00, 0x00, //community2 quantity
0x00, 0x00, 0x00, 0x00, //longbuff1 quantity
0x00, 0x00, 0x00, 0x00 //longbuff2 quantity
};
packet.Write(obfuscation);
packet.Write((byte)client.ClientPlayer.PlayerTeam);
packet.Write((byte)0);
packet.Write((Int16)0);
clients.ForEach(c => c.Send(packet));
}
}
public void Leave(Client client)
{
lock (ObjectLock)
{
client.ClientPlayer.PlayerLocation = Place.Lobby;
client.ClientFlags = PacketFlags.Character;
client.ClientPlayer.PlayerStage = null;
StagePackets.ResponseStageLeave(_traits.Players, client.GetMuid());
_traits.Players.Remove(client);
if (_traits.Players.Count == 0)
{
if (Globals.NatAgent != null)
{
AgentPackets.ReleaseStageToAgent(Globals.NatAgent, _traits.StageId);
Log.Write("Released stage: {0} from NAT Server", _traits.Name);
}
var channel = ChannelList.Find(this);
if (channel != null)
{
channel.Remove(this);
channel.Refresh();
}
return;
}
if (_traits.Master == client)
_traits.Master = _traits.Players[0];
StagePackets.ResponseObjectCache(_traits.Players, ObjectCache.New, _traits.Players);
StagePackets.ResponseStageMaster(_traits.Players, this);
StagePackets.ResponseSettings(_traits.Players, _traits);
StagePackets.ResponseStageMaster(_traits.Players, this);
Channel.Refresh(client);
}
}
