private void OnAnnounceRace(GameServerPacket packet)
{
IList <CardRace> races = new List <CardRace>();
packet.ReadByte(); // player
int count = packet.ReadByte();
int available = packet.ReadInt32();
int filter = 0x1;
for (int i = 0; i < 23; ++i)
{
if ((available & filter) != 0)
{
races.Add((CardRace)filter);
}
filter <<= 1;
}
races = _ai.OnAnnounceRace(count, races);
int reply = 0;
for (int i = 0; i < count; ++i)
{
reply += (int)races[i];
}
Connection.Send(CtosMessage.Response, reply);
}
private void OnSelectYesNo(GameServerPacket packet)
{
packet.ReadByte(); // player
int reply = _ai.OnSelectYesNo(packet.ReadInt32()) ? (1) : (0);
Connection.Send(CtosMessage.Response, reply);
}
public List <string> Say(GameServerPacket msg, string name = null)
{
if (msg == null)
{
return(new List <string>());
}
List <string> names = GameManager.SendMessage(msg, name);
List <GameClient> _clients = new List <GameClient>();
m_mutexClients.WaitOne();
_clients.AddRange(m_clients);
m_mutexClients.ReleaseMutex();
foreach (GameClient client in _clients)
{
if (client != null && client.Player != null)
{
if (!names.Contains(client.Player.Name))
{
if (!string.IsNullOrEmpty(name))
{
if (client.Player.Name != name)
{
continue;
}
}
names.Add(client.Player.Name);
client.Player.Send(msg);
}
}
}
return(names);
}
private void OnJoinGame(GameServerPacket packet)
{
uint banlist = packet.ReadUInt32();
int rule = packet.ReadByte();
int mode = packet.ReadByte();
//TODO tag
_room.IsTag = mode == 2;
Logger.WriteLine("istag = " + _room.IsTag);
GameClientPacket deck = new GameClientPacket(CtosMessage.UpdateDeck);
deck.Write(Deck.Cards.Count + Deck.ExtraCards.Count);
deck.Write(Deck.SideCards.Count);
foreach (Card card in Deck.Cards)
{
deck.Write(card.Id);
}
foreach (Card card in Deck.ExtraCards)
{
deck.Write(card.Id);
}
foreach (Card card in Deck.SideCards)
{
deck.Write(card.Id);
}
Connection.Send(deck);
}
private void OnSelectCounter(GameServerPacket packet)
{
packet.ReadByte(); // player
int type = packet.ReadInt16();
int quantity = packet.ReadByte();
IList <ClientCard> cards = new List <ClientCard>();
IList <int> counters = new List <int>();
int count = packet.ReadByte();
for (int i = 0; i < count; ++i)
{
packet.ReadInt32(); // card id
int player = GetLocalPlayer(packet.ReadByte());
CardLocation loc = (CardLocation)packet.ReadByte();
int seq = packet.ReadByte();
int num = packet.ReadByte();
cards.Add(_duel.GetCard(player, loc, seq));
counters.Add(num);
}
IList <int> used = _ai.OnSelectCounter(type, quantity, cards, counters);
byte[] result = new byte[used.Count];
for (int i = 0; i < quantity; ++i)
{
result[i] = (byte)used[i];
}
GameClientPacket reply = new GameClientPacket(CtosMessage.Response);
reply.Write(result);
Connection.Send(reply);
}
private void OnChat(GameServerPacket packet)
{
packet.ReadInt16(); // player
string msg = packet.ReadUnicode(256); // message
Console.WriteLine("Message:" + msg);
}
private void OnSelectEffectYn(GameServerPacket packet)
{
packet.ReadByte(); // player
int cardId = packet.ReadInt32();
int player = GetLocalPlayer(packet.ReadByte());
CardLocation loc = (CardLocation)packet.ReadByte();
int seq = packet.ReadByte();
packet.ReadByte();
ClientCard card = _duel.GetCard(player, loc, seq);
if (card == null)
{
Connection.Send(CtosMessage.Response, 0);
return;
}
if (card.Id == 0)
{
card.SetId(cardId);
}
int reply = _ai.OnSelectEffectYn(card) ? (1) : (0);
Connection.Send(CtosMessage.Response, reply);
}
private void OnChainSorting(GameServerPacket packet)
{
//Code me paul!!
//This was my best guess after reading the ygopro code
//AutoChain??
Connection.Send(CtosMessage.Response, -1);
}
private void OnStart(GameServerPacket packet)
{
int type = packet.ReadByte();
m_duel.IsFirst = (type & 0xF) == 0;
m_duel.LifePoints[GetLocalPlayer(0)] = packet.ReadInt32();
m_duel.LifePoints[GetLocalPlayer(1)] = packet.ReadInt32();
int deck = packet.ReadInt16();
int extra = packet.ReadInt16();
m_duel.Fields[GetLocalPlayer(0)].Init(deck, extra);
deck = packet.ReadInt16();
extra = packet.ReadInt16();
m_duel.Fields[GetLocalPlayer(1)].Init(deck, extra);
if (!Game.IsCheckmate && m_room.Names[0] != Program.Config.Username && m_room.Names[1] != Program.Config.Username)
{
Connection.Close();
return;
}
Logger.WriteLine("Duel started! " + m_room.Names[0] + " versus " + m_room.Names[1] + ".");
m_ai.OnStart();
if (Game.IsCheckmate)
{
Game.CheckmateClient.OnStart();
}
}
private void OnJoinGame(GameServerPacket packet)
{
GameClientPacket deck = new GameClientPacket(CtosMessage.UpdateDeck);
deck.Write(Deck.Cards.Count + Deck.ExtraCards.Count);
deck.Write(Deck.SideCards.Count);
foreach (CardData card in Deck.Cards)
{
deck.Write(card.Id);
}
foreach (CardData card in Deck.ExtraCards)
{
deck.Write(card.Id);
}
foreach (CardData card in Deck.SideCards)
{
deck.Write(card.Id);
}
if (!Game.IsCheckmate)
{
Connection.Send(deck);
}
else
{
Connection.Send(CtosMessage.HsToDuelist);
Connection.Send(deck);
Connection.Send(CtosMessage.HsReady);
}
}
private void OnAnnounceAttrib(GameServerPacket packet)
{
IList <CardAttribute> attributes = new List <CardAttribute>();
packet.ReadByte(); // player
int count = packet.ReadByte();
int available = packet.ReadInt32();
int filter = 0x1;
for (int i = 0; i < 7; ++i)
{
if ((available & filter) != 0)
{
attributes.Add((CardAttribute)filter);
}
filter <<= 1;
}
attributes = m_ai.OnAnnounceAttrib(count, attributes);
int reply = 0;
for (int i = 0; i < count; ++i)
{
reply += (int)attributes[i];
}
Connection.Send(CtosMessage.Response, reply);
}
private void OnSelectPosition(GameServerPacket packet)
{
packet.ReadByte(); // player
int cardId = packet.ReadInt32();
int pos = packet.ReadByte();
if (pos == 0x1 || pos == 0x2 || pos == 0x4 || pos == 0x8)
{
Connection.Send(CtosMessage.Response, pos);
return;
}
IList <CardPosition> positions = new List <CardPosition>();
if ((pos & (int)CardPosition.FaceUpAttack) != 0)
{
positions.Add(CardPosition.FaceUpAttack);
}
if ((pos & (int)CardPosition.FaceDownAttack) != 0)
{
positions.Add(CardPosition.FaceDownAttack);
}
if ((pos & (int)CardPosition.FaceUpDefence) != 0)
{
positions.Add(CardPosition.FaceUpDefence);
}
if ((pos & (int)CardPosition.FaceDownDefence) != 0)
{
positions.Add(CardPosition.FaceDownDefence);
}
Connection.Send(CtosMessage.Response, (int)_ai.OnSelectPosition(cardId, positions));
}
private void OnReplay(GameServerPacket packet)
{
if (!Program.Replay)
{
return;
}
byte[] replay = packet.ReadToEnd();
const string directory = "replay";
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
string otherName = _room.Names[0] == Game.Username ? _room.Names[1] : _room.Names[0];
string file = "AI_" + DateTime.Now.ToString("yyyy-MM-dd.HH-mm.") + otherName + ".yrp";
string fullname = Path.Combine(directory, file);
if (Regex.IsMatch(file, @"^[\w\-. ]+$"))
{
try{
File.WriteAllBytes(fullname, replay);
}catch (Exception) {
}
}
//Connection.Close();
}
private void Game_PacketLost(GameServerPacket PacketID)
{
if (PacketID == GameServerPacket.GameLogonSuccess)
{
this.Game.WriteToLog("Game Connection TimedOut", Color.Orange);
this.FailToJoinGameEvent?.Invoke();
}
}
private void OnShuffleDeck(GameServerPacket packet)
{
// Looks like this isn't necessary.
//int player = GetLocalPlayer(packet.ReadByte());
//foreach (ClientCard card in m_duel.Fields[player].Deck)
// card.SetId(0);
}
public static GameServerPacket getMessage(string finalmsg, PlayerType type = PlayerType.Yellow)
{
GameServerPacket packet = new GameServerPacket(StocMessage.Chat);
packet.Write((short)type);
packet.WriteUnicode(finalmsg, finalmsg.Length + 1);
return(packet);
}
private void OnWin(GameServerPacket packet)
{
int result = GetLocalPlayer(packet.ReadByte());
string otherName = _room.Names[0] == Game.Username ? _room.Names[1] : _room.Names[0];
string textResult = (result == 2 ? "Draw" : result == 0 ? "Win" : "Lose");
Logger.WriteLine("Duel finished against " + otherName + ", result: " + textResult);
}
private void OnTimeLimit(GameServerPacket packet)
{
int player = GetLocalPlayer(packet.ReadByte());
if (player == 0)
{
Connection.Send(CtosMessage.TimeConfirm);
}
}
private void OnSelectSum(GameServerPacket packet)
{
packet.ReadByte(); // mode
packet.ReadByte(); // player
int sumval = packet.ReadInt32();
int min = packet.ReadByte();
int max = packet.ReadByte();
IList <ClientCard> cards = new List <ClientCard>();
int count = packet.ReadByte();
for (int i = 0; i < count; ++i)
{
int cardId = packet.ReadInt32();
int player = GetLocalPlayer(packet.ReadByte());
CardLocation loc = (CardLocation)packet.ReadByte();
int seq = packet.ReadByte();
ClientCard card = _duel.GetCard(player, loc, seq);
if (card != null)
{
if (cardId != 0 && card.Id != cardId)
{
card.SetId(cardId);
}
cards.Add(card);
}
packet.ReadInt32();
}
IList <ClientCard> selected = _ai.OnSelectSum(cards, sumval, min, max);
byte[] result = new byte[selected.Count + 1];
result[0] = (byte)selected.Count;
for (int i = 0; i < selected.Count; ++i)
{
int id = 0;
for (int j = 0; j < count; ++j)
{
if (cards[j] == null)
{
continue;
}
if (cards[j].Equals(selected[i]))
{
id = j;
break;
}
}
result[i + 1] = (byte)id;
}
GameClientPacket reply = new GameClientPacket(CtosMessage.Response);
reply.Write(result);
Connection.Send(reply);
}
private void OnPlayerEnter(GameServerPacket packet)
{
string name = packet.ReadUnicode(20);
int pos = packet.ReadByte();
if (pos < 8)
{
_room.Names[pos] = name;
}
}
private void OnShuffleHand(GameServerPacket packet)
{
int player = GetLocalPlayer(packet.ReadByte());
packet.ReadByte();
foreach (ClientCard card in _duel.Fields[player].Hand)
{
card.SetId(packet.ReadInt32());
}
}
private void OnUpdateData(GameServerPacket packet)
{
int player = GetLocalPlayer(packet.ReadByte());
CardLocation loc = (CardLocation)packet.ReadByte();
IList <ClientCard> cards = null;
switch (loc)
{
case CardLocation.Hand:
cards = _duel.Fields[player].Hand;
break;
case CardLocation.MonsterZone:
cards = _duel.Fields[player].MonsterZone;
break;
case CardLocation.SpellZone:
cards = _duel.Fields[player].SpellZone;
break;
case CardLocation.Grave:
cards = _duel.Fields[player].Graveyard;
break;
case CardLocation.Removed:
cards = _duel.Fields[player].Banished;
break;
case CardLocation.Deck:
cards = _duel.Fields[player].Deck;
break;
case CardLocation.Extra:
cards = _duel.Fields[player].ExtraDeck;
break;
}
if (cards != null)
{
foreach (ClientCard card in cards)
{
try{
int len = packet.ReadInt32();
if (len < 8)
{
continue;
}
long pos = packet.GetPosition();
card.Update(packet, _duel);
packet.SetPosition(pos + len - 4);
}catch (Exception) {
}
}
}
}
private void OnDraw(GameServerPacket packet)
{
int player = GetLocalPlayer(packet.ReadByte());
int count = packet.ReadByte();
for (int i = 0; i < count; ++i)
{
_duel.Fields[player].Deck.RemoveAt(_duel.Fields[player].Deck.Count - 1);
_duel.Fields[player].Hand.Add(new ClientCard(0, CardLocation.Hand));
}
}
private void OnDamage(GameServerPacket packet)
{
int player = GetLocalPlayer(packet.ReadByte());
int final = _duel.LifePoints[player] - packet.ReadInt32();
if (final < 0)
{
final = 0;
}
_duel.LifePoints[player] = final;
}
public void Tick()
{
if (!Connection.IsConnected)
{
return;
}
while (Connection.HasPacket())
{
GameServerPacket packet = Connection.Receive();
_behavior.OnPacket(packet);
}
}
private void OnMove(GameServerPacket packet)
{
int cardId = packet.ReadInt32();
int pc = GetLocalPlayer(packet.ReadByte());
int pl = packet.ReadByte();
int ps = packet.ReadSByte();
packet.ReadSByte(); // pp
int cc = GetLocalPlayer(packet.ReadByte());
int cl = packet.ReadByte();
int cs = packet.ReadSByte();
int cp = packet.ReadSByte();
packet.ReadInt32(); // reason
ClientCard card = _duel.GetCard(pc, (CardLocation)pl, ps);
if ((pl & (int)CardLocation.Overlay) != 0)
{
pl = pl & 0x7f;
card = _duel.GetCard(pc, (CardLocation)pl, ps);
if (card != null)
{
card.Overlays.Remove(cardId);
}
}
else
{
_duel.RemoveCard((CardLocation)pl, card, pc, ps);
}
if ((cl & (int)CardLocation.Overlay) != 0)
{
cl = cl & 0x7f;
card = _duel.GetCard(cc, (CardLocation)cl, cs);
if (card != null)
{
card.Overlays.Add(cardId);
}
}
else
{
_duel.AddCard((CardLocation)cl, cardId, cc, cs, cp);
if ((pl & (int)CardLocation.Overlay) == 0 && card != null)
{
ClientCard newcard = _duel.GetCard(cc, (CardLocation)cl, cs);
if (newcard != null)
{
newcard.Overlays.AddRange(card.Overlays);
}
}
}
}
private void OnChaining(GameServerPacket packet)
{
packet.ReadInt32(); // card id
int pcc = GetLocalPlayer(packet.ReadByte());
int pcl = packet.ReadByte();
int pcs = packet.ReadSByte();
int subs = packet.ReadSByte();
ClientCard card = _duel.GetCard(pcc, pcl, pcs, subs);
int cc = GetLocalPlayer(packet.ReadByte());
_ai.OnChaining(card, cc);
}
private void OnSelectOption(GameServerPacket packet)
{
IList <int> options = new List <int>();
packet.ReadByte(); // player
int count = packet.ReadByte();
for (int i = 0; i < count; ++i)
{
options.Add(packet.ReadInt32());
}
Connection.Send(CtosMessage.Response, _ai.OnSelectOption(options));
}
private void OnAnnounceNumber(GameServerPacket packet)
{
IList <int> numbers = new List <int>();
packet.ReadByte(); // player
int count = packet.ReadByte();
for (int i = 0; i < count; ++i)
{
numbers.Add(packet.ReadInt32());
}
Connection.Send(CtosMessage.Response, _ai.OnAnnounceNumber(numbers));
}
private void OnChaining(GameServerPacket packet)
{
packet.ReadInt32(); // card id
int pcc = GetLocalPlayer(packet.ReadByte());
int pcl = packet.ReadByte();
int pcs = packet.ReadSByte();
packet.ReadSByte(); // subs
ClientCard card = m_duel.GetCard(pcc, (CardLocation)pcl, pcs);
int cc = GetLocalPlayer(packet.ReadByte());
m_ai.OnChaining(card, cc);
}
public void ServerMessage(string msg, PlayerType color = PlayerType.Yellow, bool isNow = true)
{
string finalmsg = "[Server] " + msg;
using (GameServerPacket packet = new GameServerPacket(StocMessage.Chat))
{
packet.Write((short)color);
packet.WriteUnicode(finalmsg, finalmsg.Length + 1);
SendToAll(packet, isNow);
}
}
private void SendToAll(CoreMessage msg)
{
byte[] buffer = msg.CreateBuffer();
using(GameServerPacket packet = new GameServerPacket(msg.Message)){
packet.Write(buffer);
Game.SendToAll(packet);
}
}
private void OnDraw(CoreMessage msg)
{
using(GameServerPacket packet = new GameServerPacket(msg.Message)){
int player = msg.Reader.ReadByte();
int count = msg.Reader.ReadByte();
packet.Write((byte)player);
packet.Write((byte)count);
for (int i = 0; i < count; i++)
{
uint code = msg.Reader.ReadUInt32();
if ((code & 0x80000000) != 0)
packet.Write(code);
else
packet.Write(0);
}
SendToPlayer(msg, player);
Game.SendToAllBut(packet, player);
}
}
private void OnMove(CoreMessage msg)
{
byte[] raw = msg.Reader.ReadBytes(16);
int pc = raw[4];
int pl = raw[5];
int cc = raw[8];
int cl = raw[9];
int cs = raw[10];
int cp = raw[11];
SendToPlayer(msg, cc);
using(GameServerPacket packet = new GameServerPacket(msg.Message)){
packet.Write(raw);
if (!Convert.ToBoolean((cl & ((int)CardLocation.Grave + (int)CardLocation.Overlay))) && Convert.ToBoolean((cl & ((int)CardLocation.Deck + (int)CardLocation.Hand)))
|| Convert.ToBoolean((cp & (int)CardPosition.FaceDown)))
{
packet.SetPosition(2);
packet.Write((int)0);
}
Game.SendToAllBut(packet, cc);
}
if (cl != 0 && (cl & 0x80) == 0 && (cl != pl || pc != cc))
Game.RefreshSingle(cc, cl, cs);
}
private void OnConfirmCards(CoreMessage msg)
{
int player = msg.Reader.ReadByte();
int count = msg.Reader.ReadByte();
msg.Reader.ReadBytes(count * 7);
byte[] buffer = msg.CreateBuffer();
using(GameServerPacket packet = new GameServerPacket(msg.Message)){
packet.Write(buffer);
if ((CardLocation)buffer[7] == CardLocation.Hand)
Game.SendToAll(packet);
else
Game.CurPlayers[player].Send(packet);
}
}
private void OnHint(CoreMessage msg)
{
int type = msg.Reader.ReadByte();
int player = msg.Reader.ReadByte();
msg.Reader.ReadInt32();
byte[] buffer = msg.CreateBuffer();
using(GameServerPacket packet = new GameServerPacket(msg.Message)){
packet.Write(buffer);
switch (type)
{
case 1:
case 2:
case 3:
case 4:
case 5:
Game.CurPlayers[player].Send(packet);
break;
case 6:
case 7:
case 8:
case 9:
Game.SendToAllBut(packet, player);
break;
case 10:
if (Game.IsTag)
Game.CurPlayers[player].Send(packet);
else
Game.SendToAll(packet);
break;
}
}
}
public static void OnUpdateDeck(GameSession client, GameClientPacket packet){
if (client.Game==null||client.Type == (int)PlayerType.Observer||client.Type == (int)PlayerType.Undefined)
return;
Deck deck = new Deck();
int main = packet.ReadInt32();
int side = packet.ReadInt32();
for (int i = 0; i < main; i++)
deck.AddMain(packet.ReadInt32());
for (int i = 0; i < side; i++)
deck.AddSide(packet.ReadInt32());
if (client.Game.State == GameState.Lobby)
{
client.Deck = deck;
client.Game.IsReady[client.Type] = false;
}
else if (client.Game.State == GameState.Side)
{
if (client.Game.IsReady[client.Type])
return;
if (!client.Deck.Check(deck))
{
using(GameServerPacket error = new GameServerPacket(StocMessage.ErrorMsg)){
error.Write((byte)3);
error.Write(0);
client.Send(error);
}
return;
}
client.Deck = deck;
client.Game.IsReady[client.Type] = true;
client.Game.ServerMessage(string.Format(Messages.MSG_READY, client.Name));
client.Send(GameServerPacket.EmtryMessage(StocMessage.DuelStart));
client.Game.MatchSide();
}
}
private void SendToPlayer(CoreMessage msg, int player)
{
if (player != 0 && player != 1)
return;
byte[] buffer = msg.CreateBuffer();
using(GameServerPacket packet = new GameServerPacket(msg.Message)){
packet.Write(buffer);
Game.CurPlayers[player].Send(packet);
}
}
public void RefreshSingle(int player, int location, int sequence, int flag = 0x781fff)
{
byte[] result = m_duel.QueryCard(player, location, sequence, flag);
if (location == (int)CardLocation.Removed && (result[15] & (int)CardPosition.FaceDown) != 0)
return;
using (GameServerPacket update = new GameServerPacket(GameMessage.UpdateCard))
{
update.Write((byte)player);
update.Write((byte)location);
update.Write((byte)sequence);
update.Write(result);
CurPlayers[player].Send(update);
if (IsTag)
{
if ((location & (int)CardLocation.Onfield) != 0)
{
SendToTeam(update, player);
if ((result[15] & (int)CardPosition.FaceUp) != 0)
SendToTeam(update, 1 - player);
}
else
{
CurPlayers[player].Send(update);
if ((location & 0x90) != 0)
SendToAllBut(update, player);
}
}
else
{
if ((location & 0x90) != 0 || ((location & 0x2c) != 0 && (result[15] & (int)CardPosition.FaceUp) != 0))
SendToAllBut(update, player);
}
}
}
private void SendJoinGame(GameSession player)
{
using (GameServerPacket join = new GameServerPacket(StocMessage.JoinGame))
{
join.Write(Banlist == null ? 0U : Banlist.Hash);
join.Write((byte)Config.Rule);
join.Write((byte)Config.Mode);
join.Write(Config.EnablePriority);
join.Write(Config.NoCheckDeck);
join.Write(Config.NoShuffleDeck);
// C++ padding: 5 bytes + 3 bytes = 8 bytes
for (int i = 0; i < 3; i++)
join.Write((byte)0);
join.Write(Config.StartLp);
join.Write((byte)Config.StartHand);
join.Write((byte)Config.DrawCount);
join.Write((short)Config.GameTimer);
player.Send(join);
}
if (State != GameState.Lobby)
SendDuelingPlayers(player);
}
public void WaitForResponse(int player)
{
m_lastresponse = player;
CurPlayers[player].State = PlayerState.Response;
using (GameServerPacket wait = new GameServerPacket(GameMessage.Waiting))
{
SendToAllBut(wait, player);
}
TimeStart();
using (GameServerPacket packet = new GameServerPacket(StocMessage.TimeLimit))
{
packet.Write((byte)player);
packet.Write((byte)0); // C++ padding
packet.Write((short)m_timelimit[player]);
SendToPlayers(packet);
}
}
public void RefreshSpells(int player, int flag = 0x681fff, bool useCache = true)
{
byte[] result = m_duel.QueryFieldCard(player, CardLocation.SpellZone, flag, useCache);
using (GameServerPacket update = new GameServerPacket(GameMessage.UpdateData))
{
update.Write((byte)player);
update.Write((byte)CardLocation.SpellZone);
update.Write(result);
SendToTeam(update, player);
}
using (GameServerPacket update = new GameServerPacket(GameMessage.UpdateData))
{
update.Write((byte)player);
update.Write((byte)CardLocation.SpellZone);
using (MemoryStream ms = new MemoryStream(result))
{
BinaryReader reader = new BinaryReader(ms);
BinaryWriter writer = new BinaryWriter(ms);
for (int i = 0; i < 8; i++)
{
int len = reader.ReadInt32();
if (len == 4)
{
// update.Write(4);
continue;
}
long pos = ms.Position;
byte[] raw = reader.ReadBytes(len - 4);
if ((raw[11] & (int)CardPosition.FaceDown) != 0)
{
ms.Position = pos;
writer.Write(new byte[len - 4]);
}
}
reader.Close();
writer.Close();
}
update.Write(result);
SendToTeam(update, 1 - player);
SendToObservers(update);
}
}
public void SendToObservers(GameServerPacket packet, bool isNow = true)
{
lock (Observers)
{
foreach (GameSession player in Observers)
{
if (player != null)
{
player.Send(packet, isNow);
}
}
}
}
public static void SendTypeChange(this GameSession client)
{
if(client == null||client.Game==null)return;
using(GameServerPacket packet = new GameServerPacket(StocMessage.TypeChange)){
packet.Write((byte)(client.Type + (client.Equals(client.Game.HostPlayer) ? (int)PlayerType.Host : 0)));
client.Send(packet);
}
}
public static void OnChat(GameSession client, GameClientPacket packet){
if (!client.IsAuthentified){
return;
}
string msg = packet.ReadUnicode(256);
if(client.Game==null){
return;
}
if(!client.OnChatCommand(msg)){
using(GameServerPacket chat = new GameServerPacket(StocMessage.Chat)){
chat.Write((short)client.Type);
chat.WriteUnicode(msg, msg.Length + 1);
client.Game.SendToAllBut(chat, client);
}
}
}
public void RefreshGrave(int player, int flag = 0x81fff, bool useCache = true)
{
byte[] result = m_duel.QueryFieldCard(player, CardLocation.Grave, flag, useCache);
using (GameServerPacket update = new GameServerPacket(GameMessage.UpdateData))
{
update.Write((byte)player);
update.Write((byte)CardLocation.Grave);
update.Write(result);
SendToAll(update);
}
}
public static void LobbyError(this GameSession client, string message,bool isNow=true)
{
using(GameServerPacket join = new GameServerPacket(StocMessage.JoinGame)){
join.Write(0U);
join.Write((byte)0);
join.Write((byte)0);
join.Write(0);
join.Write(0);
join.Write(0);
// C++ padding: 5 bytes + 3 bytes = 8 bytes
for (int i = 0; i < 3; i++)
join.Write((byte)0);
join.Write(0);
join.Write((byte)0);
join.Write((byte)0);
join.Write((short)0);
client.Send(join, false);
}
using(GameServerPacket enter = new GameServerPacket(StocMessage.HsPlayerEnter)){
enter.WriteUnicode("[err]" + message, 20);
enter.Write((byte)0);
client.Send(enter, isNow);
}
}
public void SendToTeam(GameServerPacket packet, int team, bool isNow = true)
{
if (!IsTag)
{
if (Players[team] != null)
Players[team].Send(packet, isNow);
}
else if (team == 0)
{
if (Players[0] != null)
Players[0].Send(packet, isNow);
if (Players[1] != null)
Players[1].Send(packet, isNow);
}
else
{
if (Players[2] != null)
Players[2].Send(packet, isNow);
if (Players[3] != null)
Players[3].Send(packet, isNow);
}
}
private void OnSelectCard(CoreMessage msg)
{
using(GameServerPacket packet = new GameServerPacket(msg.Message)){
int player = msg.Reader.ReadByte();
packet.Write((byte)player);
packet.Write(msg.Reader.ReadBytes(3));
int count = msg.Reader.ReadByte();
packet.Write((byte)count);
for (int i = 0; i < count; i++)
{
int code = msg.Reader.ReadInt32();
int pl = msg.Reader.ReadByte();
int loc = msg.Reader.ReadByte();
int seq = msg.Reader.ReadByte();
int pos = msg.Reader.ReadByte();
packet.Write(pl == player ? code : 0);
packet.Write((byte)pl);
packet.Write((byte)loc);
packet.Write((byte)seq);
packet.Write((byte)pos);
}
Game.WaitForResponse(player);
Game.CurPlayers[player].Send(packet);
}
}
public void RefreshExtra(int player, int flag = 0x81fff, bool useCache = true)
{
byte[] result = m_duel.QueryFieldCard(player, CardLocation.Extra, flag, useCache);
using (GameServerPacket update = new GameServerPacket(GameMessage.UpdateData))
{
update.Write((byte)player);
update.Write((byte)CardLocation.Extra);
update.Write(result);
CurPlayers[player].Send(update);
}
}
private void OnShuffleHand(CoreMessage msg)
{
int player = msg.Reader.ReadByte();
int count = msg.Reader.ReadByte();
using(GameServerPacket packet = new GameServerPacket(msg.Message)){
packet.Write((byte)player);
packet.Write((byte)count);
msg.Reader.ReadBytes(count * 4);
for (int i = 0; i < count; i++)
packet.Write(0);
SendToPlayer(msg, player);
Game.SendToAllBut(packet, player);
}
Game.RefreshHand(player, 0x181fff, false);
}
public void SendToAllBut(GameServerPacket packet, int except, bool isNow = true)
{
if (except < CurPlayers.Length)
SendToAllBut(packet, CurPlayers[except], isNow);
else
SendToAll(packet, isNow);
}
private void OnSet(CoreMessage msg)
{
msg.Reader.ReadBytes(4);
byte[] raw = msg.Reader.ReadBytes(4);
using(GameServerPacket packet = new GameServerPacket(GameMessage.Set)){
packet.Write(0);
packet.Write(raw);
Game.SendToAll(packet);
}
}
public void EndDuel(bool force)
{
if (State == GameState.Duel)
{
if (!Replay.Disabled)
{
Replay.End();
byte[] replayData = Replay.GetFile();
GameServerPacket packet = new GameServerPacket(StocMessage.Replay);
packet.Write(replayData);
SendToPlayers(packet);
//SendToAll(packet);
}
State = GameState.End;
m_duel.End();
DuleTimer.Stop();
}
if (m_swapped)
{
m_swapped = false;
GameSession temp = Players[0];
Players[0] = Players[1];
Players[1] = temp;
Players[0].Type = 0;
Players[1].Type = 1;
}
if (IsMatch && !force && !MatchIsEnd())
{
IsReady[0] = false;
IsReady[1] = false;
ServerMessage(Messages.MSG_SIDE);
State = GameState.Side;
GameTimer.StartSideTimer();
// Server.OnPlayEvent(PlayerStatu.PlayerSide, Players);
using (GameServerPacket p = new GameServerPacket(StocMessage.ChangeSide))
{
SendToPlayers(p);
}
using (GameServerPacket p = new GameServerPacket(StocMessage.WaitingSide))
{
SendToObservers(p);
}
}
else {
if (State == GameState.Side)
{
//Logger.WriteLine("side is lose");
State = GameState.End;
GameSession pl = null;
try
{
if (Players[0] != null)
{
pl = (Players[0].IsConnected) ? Players[1] : Players[0];
}
}
catch { }
if (pl != null)
{
// && pl.Type != (int)PlayerType.Observer
Surrender(pl, 4, true);
}
}
End();
}
}
private void OnTagSwap(CoreMessage msg)
{
int player = msg.Reader.ReadByte();
int mcount = msg.Reader.ReadByte();
int ecount = msg.Reader.ReadByte();
int epcount = msg.Reader.ReadByte();
int hcount = msg.Reader.ReadByte();
using(GameServerPacket packet = new GameServerPacket(GameMessage.TagSwap)){
packet.Write((byte)player);
packet.Write((byte)mcount);
packet.Write((byte)ecount);
packet.Write((byte)epcount);
packet.Write((byte)hcount);
uint id = msg.Reader.ReadUInt32();
packet.Write(id);
for (int i = 0; i < hcount; i++)
{
uint code = msg.Reader.ReadUInt32();
if ((code & 0x80000000) != 0)
packet.Write(code);
else
packet.Write(0);
}
for (int i = 0; i < ecount; i++)
{
uint code = msg.Reader.ReadUInt32();
if ((code & 0x80000000) != 0)
packet.Write(code);
else
packet.Write(0);
}
SendToPlayer(msg, player);
Game.SendToAllBut(packet, player);
}
Game.RefreshExtra(player);
Game.RefreshMonsters(0, 0x81fff, false);
Game.RefreshMonsters(1, 0x81fff, false);
Game.RefreshSpells(0, 0x681fff, false);
Game.RefreshSpells(1, 0x681fff, false);
Game.RefreshHand(0, 0x181fff, false);
Game.RefreshHand(1, 0x181fff, false);
}
public static void ServerMessage(this GameSession client, string msg, PlayerType type=PlayerType.Yellow,bool isNow=true)
{
string finalmsg = "[Server] " + msg;
using(GameServerPacket packet = new GameServerPacket(StocMessage.Chat)){
packet.Write((short)type);
packet.WriteUnicode(finalmsg, finalmsg.Length + 1);
client.Send(packet, isNow);
}
}
private void SendToAll(CoreMessage msg, int length)
{
if (length == 0)
{
using(GameServerPacket p = new GameServerPacket(msg.Message)){
Game.SendToAll(p);
}
return;
}
msg.Reader.ReadBytes(length);
SendToAll(msg);
}
public void End()
{
if (IsEnd)
{
return;
}
IsEnd = true;
using (GameServerPacket p = new GameServerPacket(StocMessage.DuelEnd))
{
SendToAll(p);
}
RoomManager.Remove(this);
}
public void Connect(ServerInfo info, User user){
if(client!=null){
client.Close();
}
client = new AsyncClient();
try{
client.Connect(info.Host, info.Port);
using(GameServerPacket login = new GameServerPacket()){
login.WriteUnicode(user.Name, 20);
login.WriteUnicode(user.Password, 32);
login.Use();
client.BeginSend(login.Content);
}
}catch(Exception){
}
}
public void RefreshHand(int player, int flag = 0x181fff, bool useCache = true)
{
byte[] result = m_duel.QueryFieldCard(player, CardLocation.Hand, flag | 0x100000, useCache);
using (GameServerPacket update = new GameServerPacket(GameMessage.UpdateData))
{
update.Write((byte)player);
update.Write((byte)CardLocation.Hand);
update.Write(result);
CurPlayers[player].Send(update);
}
using (GameServerPacket update = new GameServerPacket(GameMessage.UpdateData))
{
update.Write((byte)player);
update.Write((byte)CardLocation.Hand);
using (MemoryStream ms = new MemoryStream(result))
{
BinaryReader reader = new BinaryReader(ms);
BinaryWriter writer = new BinaryWriter(ms);
while (ms.Position < ms.Length)
{
int len = reader.ReadInt32();
if (len == 4)
{
//update.Write(4);
continue;
}
long pos = ms.Position;
byte[] raw = reader.ReadBytes(len - 4);
if (raw[len - 8] == 0)
{
ms.Position = pos;
writer.Write(new byte[len - 4]);
}
}
writer.Close();
reader.Close();
}
update.Write(result);
SendToAllBut(update, player);
}
}
