public void WelcomeHandler(WelcomePacket wp, NetPeer peer)
{
if (wp != null)
{
Console.WriteLine($"We got: {wp.PlayerId+1} from {peer.EndPoint.ToString()}");
_loggingFunc?.Invoke(wp.PlayerId + 1);
selfId = wp.PlayerId;
//get player handle
var player = _playerHandler?.Invoke();
player.PlayerId = wp.PlayerNumber;
player.Location = new Point(wp.XStart, wp.YStart);
Console.WriteLine($"Player moved to new start location:{wp.XStart},{wp.YStart}");
}
else
{
Console.WriteLine("Packet was malformed!");
}
}
public Client(TcpClient socket)
{
this.socket = socket;
stream = socket.GetStream();
serializer = new BinaryFormatter();
serializer.Binder = new CustomBinder();
threadIn = new Thread(new ThreadStart(listen));
threadOut = new Thread(new ThreadStart(send));
_packetsToSend = new BlockingConcurrentQueue <Packet>();
listening = true;
threadIn.Start();
threadOut.Start();
WelcomePacket packet = new WelcomePacket();
packet.clientConnected = true;
this.SendPacket(packet);
}
private void handleWelcoming(WelcomePacket welcome)
{
String token = Client.Instance.readClientSave();
Console.WriteLine("token : " + token);
if (token.Equals("no token") || token.Equals("error"))
{
UIManager.Instance.RunOnUIThread(() =>
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new LoginForm());
});
}
else
{
LoginTokenPacket p = new LoginTokenPacket();
p.token = token;
Client.Instance.SendPacket(p);
}
}
private Task HandleConnectionAsync(TcpClient tcpClient)
{
WelcomePacket packet = new WelcomePacket();
Send(tcpClient, packet.CreatePacket());
NewsTitlePacket packet2 = new NewsTitlePacket();
Send(tcpClient, packet2.CreatePacket());
NewsContentPacket packet3 = new NewsContentPacket();
Send(tcpClient, packet3.CreatePacket());
return(Task.Run(async() =>
{
using (var networkStream = tcpClient.GetStream())
{
while (true)
{
var buffer = new byte[4096];
Console.WriteLine("[Server] Reading from client");
var byteCount = await networkStream.ReadAsync(buffer, 0, buffer.Length);
int?size = null;
HeadCodeSc?headcode = null;
byte type = buffer[0];
if (type == 0xC1 || type == 0xC3)
{
size = buffer[1];
headcode = (HeadCodeSc)buffer[2];
Console.WriteLine("C1/C3 packet type");
}
else if (type == 0xC2 || type == 0xC4)
{
size = buffer[1] * 256;
size |= buffer[2];
headcode = (HeadCodeSc)buffer[3];
Console.WriteLine("C2/C4 packet type");
}
else
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Unknow packet type 0x{0:X}", type);
Console.ResetColor();
continue;
}
Console.WriteLine("Read {0} bytes from socket.",
byteCount);
Console.WriteLine("Packet type: 0x{0:X} headcode: 0x{1:X} size: 0x{2:X}", type, headcode, size);
Console.WriteLine(BitConverter.ToString(buffer, 0, (int)size));
try
{
if (headcode == HeadCodeSc.ConnectServerData)
{
if ((HeadCodeCs)buffer[3] == HeadCodeCs.ClientConnect)
{
ServerListPacket packetData = new ServerListPacket(udpServer);
Send(tcpClient, packetData.CreatePacket());
}
else if ((HeadCodeCs)buffer[3] == HeadCodeCs.ServerSelect)
{
ServerDataPacket packetData = new ServerDataPacket(udpServer, buffer);
Send(tcpClient, packetData.CreatePacket());
}
}
} catch (Exception)
{
}
}
//await HandleConnectionAsync(tcpClient);
}
}));
}
private void packetManager_PacketReceived(object sender, PacketEventArgs e)
{
switch (e.Packet.PacketType)
{
case PacketType.Welcome:
WelcomePacket welcome = e.Packet as WelcomePacket;
LoginPacket packet = new LoginPacket(this.number, this.password, welcome.Seed,
this.loginStatus, this.channels);
this.packetManager.AddPacket(packet);
break;
// case PacketType.Login80_OK:
// this.State = State.Connected;
// this.timerPing.Start();
// if (this.Connected != null)
// {
// this.Connected(this, EventArgs.Empty);
// }
// break;
case PacketType.Login80_Fail:
if (this.LoggedFail != null)
{
this.LoggedFail(this, EventArgs.Empty);
}
break;
case PacketType.Disconnect:
this.State = State.Disconnected;
this.timerPing.Stop();
if (this.Disconnected != null)
{
this.Disconnected(this, EventArgs.Empty);
}
break;
case PacketType.Login80_OK:
this.State = State.Connected;
this.SendContactList();
this.timerPing.Start();
if (this.Connected != null)
{
this.Connected(this, EventArgs.Empty);
}
break;
case PacketType.UserData:
UserDataPacket userData = e.Packet as UserDataPacket;
foreach (UserData data in userData.Attributes)
{
if (this.contacts.ContainsKey(data.Number))
{
this.contacts[data.Number].ExtendedInfo = data.Attributes;
if (this.ContactInfoReceived != null)
{
this.ContactInfoReceived(this, new ContactEventArgs(this.contacts[data.Number]));
}
}
}
break;
case PacketType.NotifyReply80:
case PacketType.Status:
NotifyReplyPacket notify = e.Packet as NotifyReplyPacket;
foreach (ClientState state in notify.ClientStates)
{
this.contacts[state.Number].State = state;
if (this.ContactStateChanged != null)
{
this.ContactStateChanged(this, new ContactEventArgs(this.contacts[state.Number]));
}
}
break;
case PacketType.TypingNotify:
TypingNotifyPacket typing = e.Packet as TypingNotifyPacket;
if (this.ContactTyping != null)
{
if (this.contacts.ContainsKey(typing.Number))
{
GGContact contact = this.contacts[typing.Number];
this.ContactTyping(this, new TypingEventArgs(typing.Value, contact));
}
}
break;
case PacketType.SendMessageAck:
SendMessageAckPacket ack = e.Packet as SendMessageAckPacket;
if (this.messages.ContainsKey(ack.Sequence))
{
GGMessage message = this.messages[ack.Sequence];
lock (this.messages)
{
this.messages.Remove(ack.Sequence);
}
if (this.MessageStateChanged != null)
{
this.MessageStateChanged(this, new MessageEventArgs(ack.Status, message));
}
}
break;
case PacketType.RecvMessage:
ReceiveMessagePacket receive = e.Packet as ReceiveMessagePacket;
GGMessage msg = new GGMessage(receive.Recipients);
msg.Sender = receive.Sender;
msg.HtmlMessage = receive.HtmlMessage;
msg.PlainMessage = receive.PlainMessage;
msg.Time = receive.Time;
msg.Sequence = receive.Sequence;
ReceiveMessageAckPacket confirm = new ReceiveMessageAckPacket(receive.Sequence);
this.packetManager.AddPacket(confirm);
if (this.MessageReceived != null)
{
MessageEventArgs args = new MessageEventArgs(MessageStatus.Delivered, msg);
this.MessageReceived(this, args);
}
break;
}
}
public void Start()
{
Console.WriteLine("GAME SERVER STARTED");
EventBasedNetListener listener = new EventBasedNetListener();
NetManager server = new NetManager(listener);
server.Start(9050 /* port */);
_netSerializer.Register <WelcomePacket>();
_netSerializer.Register <UpdatePacket>();
_netSerializer.Register <ServerSnapshotPacket>();
_netSerializer.Register <EchoPacket>();
_packetProcessor.SubscribeReusable <UpdatePacket, NetPeer>(HandleClientUpdate);
listener.ConnectionRequestEvent += request =>
{
//we will change this when we create 'game sessions' for now we only support the 4 players.
if (server.PeersCount < 4 /* max connections */)
{
request.AcceptIfKey("SomeConnectionKey");
}
else
{
request.Reject();
}
};
listener.PeerConnectedEvent += peer =>
{
//server stores by ipaddress+port
string key = peer.EndPoint.ToString();
if (!_knownPlayers.ContainsKey(key))
{
// new unknown player connected, let's start tracking them
ServerPlayerData pd = new ServerPlayerData
{
//generate a unique ID for the peer connecting which will be referenced in the future (by other peers as an intermediary (vs telling peers specifically who they're connected to IP/POrt or whatever)
// let's condense this down by 1/3 or so.. (also we know the final characters are ==
ClientID = Convert.ToBase64String(Guid.NewGuid().ToByteArray()).Replace("=", ""),
GameSessionId = string.Empty,
IPAddress = peer.EndPoint.Address,
Port = peer.EndPoint.Port,
MillisecondsSinceLastHeard = 0,
PlayerNumber = GetNextPlayerId() + 1,
PlayerLocation = new Loc {
X = 0, Y = 0
},
_clientRef = peer
};
bool success = _knownPlayers.TryAdd(key, pd);
pd.PlayerLocation.X = pd.PlayerNumber * 15;
pd.PlayerLocation.Y = pd.PlayerNumber * 15;
}
else
{
//player must have disconnected during a game, let's try to reconnect to their game if it's still playing
//TODO: look up the GameSessionID, then start sending this player's packets to all players in the session
}
var pdat = _knownPlayers[key];
Console.WriteLine("PLAYER JOINED: {0} as PLAYER {1} with ID {2}", peer.EndPoint, pdat.PlayerNumber, pdat.ClientID);
//send our info in a welcome packet
WelcomePacket wp = new WelcomePacket
{
PlayerId = pdat.ClientID,
PlayerNumber = pdat.PlayerNumber,
XStart = pdat.PlayerLocation.X,
YStart = pdat.PlayerLocation.Y
};
_packetProcessor.Send <WelcomePacket>(peer, wp, DeliveryMethod.ReliableOrdered);
Console.WriteLine("Packet Processor Sent Packet!");
//peer.Send(_netSerializer.Serialize<WelcomePacket>(wp), DeliveryMethod.ReliableOrdered);
};
listener.NetworkReceiveEvent += Listener_NetworkReceiveEvent;
while (!Console.KeyAvailable)
{
server.PollEvents();
UpdateAllClients(); //sends a snapshot of all client locations every 15ms
Thread.Sleep(15);
}
server.Stop();
}
