internal static void HandleCreateCharacterData(DataBuffer buffer)
{
// get amount of classes.
var classes = buffer.ReadInt32();
for (var i = 1; i < classes + 1; i++) {
var c = new Class();
c.Name = buffer.ReadString();
c.MaleSprite = buffer.ReadInt32();
c.FemaleSprite = buffer.ReadInt32();
Data.Classes.Add(i, c);
}
Interface.ChangeUI(Interface.Windows.CharacterCreate);
}
internal static void HandleLoadMap(DataBuffer buffer)
{
var mapnum = buffer.ReadInt32();
var revision = buffer.ReadInt32();
// Load our map.
Data.LoadMap(mapnum);
// Compare revisions
if (Data.Map.Revision == revision) {
Send.MapOK();
} else {
Send.RequestMap();
}
}
internal static void HandleMapList(DataBuffer buffer)
{
var max = buffer.ReadInt32();
Program.FrmEditor.BeginInvoke((Action)(() => {
Program.FrmEditor.ClearMaps();
}));
for (var i = 1; i <= max; i++) {
Program.FrmEditor.BeginInvoke((Action<Int32, String>)((num, name) => {
Program.FrmEditor.AddMap(String.Format("{0}: {1}", num, name));
}), i, buffer.ReadString());
}
}
internal static void HandlePlayerId(DataBuffer buffer)
{
Data.MyId = buffer.ReadInt32();
}
public static void HandleUseCharacter(Int32 id, DataBuffer buffer)
{
// Make sure the user exists.
if (!Data.Players.ContainsKey(id)) return;
var slot = buffer.ReadInt32();
HandleData.HandleUseCharacter(id, slot);
}
public static void HandleAddCharacter(Int32 id, DataBuffer buffer)
{
var legal = new Regex("^[a-zA-Z0-9]*$");
var name = buffer.ReadString().Trim();
var classn = buffer.ReadInt32();
var gender = buffer.ReadByte();
// Make sure this player exists.
if (!Data.Players.ContainsKey(id)) return;
// Make sure the name is at least X characters long.
if (name.Length < Data.Settings.MinUsernameChar) {
Send.AlertMessage(id, String.Format("Character name must be at least {0} characters in length.", Data.Settings.MinUsernameChar));
return;
}
// Make sure they only entered regular characters.
if (!legal.IsMatch(name)) {
Send.AlertMessage(id, "Invalid name, only letters and numbers are allowed in names.");
return;
}
// Check if the name is already in use or not.
if (Data.Characters.Contains(name)) {
Send.AlertMessage(id, "A character with this name already exists!");
return;
}
// Check if there's a slot left to use!
var slot = -1;
for (var i = 0; slot < Data.Players[id].Characters.Length; i++) {
if (Data.Players[id].Characters[i].Name.Length < 1) {
slot = i;
break;
}
}
if (slot < 0) {
Send.AlertMessage(id, "Unable to create character.");
return;
}
// We've come this far, we can add this character!
Data.Characters.Add(name);
Data.Players[id].Characters[slot].Name = name;
Data.Players[id].Characters[slot].Gender = (Byte)gender;
Data.Players[id].Characters[slot].Class = classn;
Data.Players[id].Characters[slot].Sprite = gender == (Int32)Enumerations.Gender.Male ? Data.Classes[classn].MaleSprite : Data.Classes[classn].FemaleSprite;
Data.Players[id].Characters[slot].Level = 1;
Data.Players[id].Characters[slot].Map = Data.Settings.StartMap;
Data.Players[id].Characters[slot].X = Data.Settings.StartX;
Data.Players[id].Characters[slot].Y = Data.Settings.StartY;
Data.Players[id].Characters[slot].Direction = (Int32)Enumerations.Direction.Down;
for (var i = 0; i < (Int32)Enumerations.Stats.Stat_Count; i++) {
Data.Players[id].Characters[slot].Statistic[i] = Data.Classes[classn].Statistic[i];
}
// Save our data!
Data.SaveCharacterList();
Data.SavePlayer(id);
// Notify our user!
Logger.Write(String.Format("ID: {0} has created a character named '{1}'.", id, name));
HandleData.HandleUseCharacter(id, slot);
}
private void ReceiveData(IAsyncResult ar)
{
var state = (StateObject)ar.AsyncState;
var receive = 0;
this.LastData = DateTime.UtcNow;
try {
receive = this.MainSocket.EndReceive(ar);
} catch { }
if (receive > 0) {
state.Data.Append(state.Buffer);
state.Received += receive;
var temp = new DataBuffer();
temp.FromArray(state.Data.ToArray());
var alength = temp.ReadInt32();
if ((state.Received - 4) >= alength) {
var work = true;
while (work) {
var calc = new DataBuffer();
calc.FromArray(state.Data.ToArray());
var length = calc.ReadInt32();
if (state.Data.Length() - 4 >= length) {
var buffer = new DataBuffer();
buffer.FromArray(state.Data.ToArray().Skip(4).Take(length).ToArray());
var data = state.Data.ToArray().Skip(4 + length).Take(state.Received - (4 + length)).ToArray();
state.Data.FromArray(data);
state.Buffer = data;
this.PacketHandler(buffer);
} else {
var newstate = new StateObject();
this.MainSocket.BeginReceive(newstate.Buffer, 0, StateObject.BufferSize, SocketFlags.None, new AsyncCallback(ReceiveData), newstate);
work = false;
}
}
} else {
this.MainSocket.BeginReceive(state.Buffer, 0, StateObject.BufferSize, SocketFlags.None, new AsyncCallback(ReceiveData), state);
}
}
}
public static void Handle(Int32 id, DataBuffer buffer)
{
var packet = (Packets.Client)buffer.ReadInt32();
Handlers.TryGet(packet, (i, b) => { /* Do Nothing */ })(id, buffer);
}
internal static void HandlePacket(DataBuffer buffer)
{
var packet = (Packets.Server)buffer.ReadInt32();
Handlers.TryGet(packet, (b) => { /* Do Nothing */ })(buffer);
}
internal static void HandleRemovePlayer(DataBuffer buffer)
{
var id = buffer.ReadInt32();
if (!Data.Players.ContainsKey(id)) return;
Data.Players.Remove(id);
}
internal static void HandleSelectCharacterData(DataBuffer buffer)
{
// Retrieve our data.
for (var i = 0; i < Data.CharSelect.Length; i++) {
Data.CharSelect[i] = new Character();
Data.CharSelect[i].Name = buffer.ReadString();
Data.CharSelect[i].Level = buffer.ReadInt32();
}
// Move to the select screen.
Interface.ChangeUI(Interface.Windows.CharacterSelect);
}
internal static void HandlePlayerMoving(DataBuffer buffer)
{
var id = buffer.ReadInt32();
if (!Data.TempPlayers.ContainsKey(id)) return;
for (var i = 0; i < (Int32)Enumerations.Direction.Direction_Count; i++) {
Data.TempPlayers[id].IsMoving[i] = buffer.ReadBoolean();
}
}
internal static void HandlePlayerLocation(DataBuffer buffer)
{
var id = buffer.ReadInt32();
if (!Data.Players.ContainsKey(id)) return;
Data.Players[id].Map = buffer.ReadInt32();
Data.Players[id].X = buffer.ReadInt32();
Data.Players[id].Y = buffer.ReadInt32();
Data.Players[id].Direction = buffer.ReadByte();
}
internal static void HandlePlayerId(DataBuffer buffer)
{
Data.MyId = buffer.ReadInt32();
Data.Players.Add(Data.MyId, new Character());
Data.TempPlayers.Add(Data.MyId, new TempPlayer());
}
internal static void HandlePlayerData(DataBuffer buffer)
{
var id = buffer.ReadInt32();
if (!Data.Players.ContainsKey(id)) {
Data.Players.Add(id, new Character());
Data.TempPlayers.Add(id, new TempPlayer());
}
Data.Players[id].Name = buffer.ReadString();
Data.Players[id].Gender = buffer.ReadByte();
Data.Players[id].Class = buffer.ReadInt32();
Data.Players[id].Level = buffer.ReadInt32();
Data.Players[id].Experience = buffer.ReadInt32();
Data.Players[id].Sprite = buffer.ReadInt32();
Data.Players[id].Map = buffer.ReadInt32();
Data.Players[id].X = buffer.ReadInt32();
Data.Players[id].Y = buffer.ReadInt32();
Data.Players[id].Direction = buffer.ReadByte();
for (var i = 0; i < (Int32)Enumerations.Stats.Stat_Count - 1; i++) {
Data.Players[id].Statistic[i] = buffer.ReadInt32();
}
}
internal static void HandleMapData(DataBuffer buffer)
{
var id = buffer.ReadInt32();
var temp = buffer.ReadBytes();
using (var fs = new MemoryStream()) {
fs.Write(temp, 0, temp.Length);
fs.Position = 0;
using (var re = new BinaryReader(fs)) {
Data.Map.Name = re.ReadString();
Data.Map.Music = re.ReadString();
Data.Map.Revision = re.ReadInt32();
Data.Map.SizeX = re.ReadInt32();
Data.Map.SizeY = re.ReadInt32();
var layers = re.ReadInt32();
Data.Map.Layers.Clear();
for (var l = 0; l < layers; l++) {
Data.Map.Layers.Add(new LayerData(Data.Map.SizeX, Data.Map.SizeY));
Data.Map.Layers[l].Name = re.ReadString();
Data.Map.Layers[l].BelowPlayer = re.ReadBoolean();
for (var x = 0; x < Data.Map.SizeX; x++) {
for (var y = 0; y < Data.Map.SizeY; y++) {
Data.Map.Layers[l].Tiles[x, y].Tileset = re.ReadInt32();
Data.Map.Layers[l].Tiles[x, y].TileX = re.ReadInt32();
Data.Map.Layers[l].Tiles[x, y].TileY = re.ReadInt32();
}
}
}
}
}
Data.SaveMap(id);
Send.MapOK();
}
