IsleHorse/HISP
1
0
Fork 0
mirror of https://github.com/islehorse/HISP.git synced 2025-04-06 21:25:42 +12:00
Code Issues Projects Releases Packages Wiki Activity Actions

Add files via upload

Browse source
This commit is contained in:
Bluzume 2020-09-30 18:23:19 +13:00 • committed by GitHub
parent 14ff669234
commit b0652c2c83
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
23 changed files with 2422 additions and 2323 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

178
Horse Isle Server/Horse Isle Server/Authentication.cs
View file

@ -1,89 +1,89 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Security.Cryptography; using System.Security.Cryptography;
using System.Text; using System.Text;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace Horse_Isle_Server namespace Horse_Isle_Server
{ {
class Authentication class Authentication
{ {
public static string DecryptLogin(string encpass) public static string DecryptLogin(string encpass)
{ {
string decrypt = ""; string decrypt = "";
string ROTPOOL = "bl7Jgk61IZdnY mfDN5zjM2XLqTCty4WSEoKR3BFVQsaUhHOAx0rPwp9uc8iGve"; string ROTPOOL = "bl7Jgk61IZdnY mfDN5zjM2XLqTCty4WSEoKR3BFVQsaUhHOAx0rPwp9uc8iGve";
string POSPOOL = "DQc3uxiGsKZatMmOS5qYveN71zoPTk8yU0H2w9VjprBXWn l4FJd6IRbhgACfEL"; string POSPOOL = "DQc3uxiGsKZatMmOS5qYveN71zoPTk8yU0H2w9VjprBXWn l4FJd6IRbhgACfEL";
string ROTPOOL2 = "evGi8cu9pwPr0xAOHhUasQVFB3RKoESW4ytCTqLX2Mjz5NDfm YndZI16kgJ7lb"; string ROTPOOL2 = "evGi8cu9pwPr0xAOHhUasQVFB3RKoESW4ytCTqLX2Mjz5NDfm YndZI16kgJ7lb";
int i = 0; int i = 0;
int ii = 0; int ii = 0;
while (i < encpass.Length) while (i < encpass.Length)
{ {
int ROT = ROTPOOL.IndexOf(encpass[i].ToString()); int ROT = ROTPOOL.IndexOf(encpass[i].ToString());
int POS = POSPOOL.IndexOf(encpass[i + 1].ToString()); int POS = POSPOOL.IndexOf(encpass[i + 1].ToString());
POS -= (ROT + ii); POS -= (ROT + ii);
if (POS < 0) if (POS < 0)
{ {
POS = (POS / -1) - 1; POS = (POS / -1) - 1;
while (POS >= ROTPOOL.Length) while (POS >= ROTPOOL.Length)
{ {
POS -= ROTPOOL.Length; POS -= ROTPOOL.Length;
} }
decrypt += ROTPOOL2[POS]; decrypt += ROTPOOL2[POS];
} }
else else
{ {
while (POS >= ROTPOOL.Length) while (POS >= ROTPOOL.Length)
{ {
POS -= ROTPOOL.Length; POS -= ROTPOOL.Length;
} }
decrypt += ROTPOOL[POS]; decrypt += ROTPOOL[POS];
} }
i += 2; i += 2;
ii += 1; ii += 1;
} }
return decrypt.Replace(" ", ""); return decrypt.Replace(" ", "");
} }
public static byte[] HashAndSalt(string plaintext, byte[] salt) public static byte[] HashAndSalt(string plaintext, byte[] salt)
{ {
byte[] plaintextBytes = Encoding.UTF8.GetBytes(plaintext); byte[] plaintextBytes = Encoding.UTF8.GetBytes(plaintext);
SHA512 sha512 = new SHA512Managed(); SHA512 sha512 = new SHA512Managed();
byte[] hash = sha512.ComputeHash(plaintextBytes); byte[] hash = sha512.ComputeHash(plaintextBytes);
for (int i = 0; i < hash.Length; i++) for (int i = 0; i < hash.Length; i++)
{ {
hash[i] ^= salt[i]; hash[i] ^= salt[i];
} }
byte[] finalHash = sha512.ComputeHash(hash); byte[] finalHash = sha512.ComputeHash(hash);
return finalHash; return finalHash;
} }
public static bool CheckPassword(string username, string password) public static bool CheckPassword(string username, string password)
{ {
if(Database.CheckUserExist(username)) if(Database.CheckUserExist(username))
{ {
byte[] expectedPassword = Database.GetPasswordHash(username); byte[] expectedPassword = Database.GetPasswordHash(username);
byte[] salt = Database.GetPasswordSalt(username); byte[] salt = Database.GetPasswordSalt(username);
byte[] hashedPassword = HashAndSalt(password, salt); byte[] hashedPassword = HashAndSalt(password, salt);
if (Enumerable.SequenceEqual(expectedPassword, hashedPassword)) if (Enumerable.SequenceEqual(expectedPassword, hashedPassword))
return true; return true;
} }
return false; return false;
} }
} }
} }

271
Horse Isle Server/Horse Isle Server/Client.cs
View file

@ -1,134 +1,137 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.IO; using System.IO;
using System.Linq; using System.Linq;
using System.Net; using System.Net;
using System.Net.Sockets; using System.Net.Sockets;
using System.Text; using System.Text;
using System.Threading; using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace Horse_Isle_Server namespace Horse_Isle_Server
{ {
class Client class Client
{ {
public Socket ClientSocket; public Socket ClientSocket;
public string RemoteIp; public string RemoteIp;
public bool LoggedIn = false; public bool LoggedIn = false;
public User LoggedinUser; public User LoggedinUser;
private Thread recvPackets; private Thread recvPackets;
public void Login(int id) public void Login(int id)
{ {
LoggedinUser = new User(id); LoggedinUser = new User(id);
LoggedIn = true; LoggedIn = true;
} }
private void receivePackets() private void receivePackets()
{ {
// HI1 Packets are terminates by 0x00 so we have to read until we receive that terminator // HI1 Packets are terminates by 0x00 so we have to read until we receive that terminator
MemoryStream ms = new MemoryStream(); MemoryStream ms = new MemoryStream();
while(ClientSocket.Connected) while(ClientSocket.Connected)
{ {
try try
{ {
if (ClientSocket.Available >= 1) if (ClientSocket.Available >= 1)
{ {
byte[] buffer = new byte[ClientSocket.Available]; byte[] buffer = new byte[ClientSocket.Available];
ClientSocket.Receive(buffer); ClientSocket.Receive(buffer);
foreach (Byte b in buffer) foreach (Byte b in buffer)
{ {
ms.WriteByte(b); ms.WriteByte(b);
if (b == 0x00) if (b == 0x00)
{ {
ms.Seek(0x00, SeekOrigin.Begin); ms.Seek(0x00, SeekOrigin.Begin);
byte[] fullPacket = ms.ToArray(); byte[] fullPacket = ms.ToArray();
parsePackets(fullPacket); parsePackets(fullPacket);
ms.Close(); ms.Close();
ms = new MemoryStream(); ms = new MemoryStream();
} }
} }
} }
} }
catch(SocketException e) catch(SocketException e)
{ {
Logger.ErrorPrint("Socket exception occured: " + e.Message +" and so it was disconnected."); Logger.ErrorPrint("Socket exception occured: " + e.Message +" and so it was disconnected.");
Disconnect(); Disconnect();
break; break;
} }
} }
} }
private void parsePackets(byte[] Packet) private void parsePackets(byte[] Packet)
{ {
if (Packet.Length < 1) if (Packet.Length < 1)
{ {
Logger.ErrorPrint("Received an invalid packet (size: "+Packet.Length+")"); Logger.ErrorPrint("Received an invalid packet (size: "+Packet.Length+")");
} }
byte identifier = Packet[0]; byte identifier = Packet[0];
if (!LoggedIn) // Must be either login or policy-file-request if (!LoggedIn) // Must be either login or policy-file-request
{ {
if (Encoding.UTF8.GetString(Packet).StartsWith("<policy-file-request/>")) // Policy File Request if (Encoding.UTF8.GetString(Packet).StartsWith("<policy-file-request/>")) // Policy File Request
{ {
Server.OnCrossdomainPolicyRequest(this); Server.OnCrossdomainPolicyRequest(this);
} }
switch (identifier) switch (identifier)
{ {
case PacketBuilder.PACKET_LOGIN: case PacketBuilder.PACKET_LOGIN:
Server.OnLoginRequest(this, Packet); Server.OnLoginRequest(this, Packet);
break; break;
} }
} }
else else
{ {
switch (identifier) switch (identifier)
{ {
case PacketBuilder.PACKET_LOGIN: case PacketBuilder.PACKET_LOGIN:
Server.OnUserInfoRequest(this, Packet); Server.OnUserInfoRequest(this, Packet);
break; break;
case PacketBuilder.PACKET_MOVE: case PacketBuilder.PACKET_MOVE:
Server.OnMovementPacket(this, Packet); Server.OnMovementPacket(this, Packet);
break; break;
default: default:
Logger.ErrorPrint("Unimplemented Packet: " + BitConverter.ToString(Packet).Replace('-', ' ')); Logger.ErrorPrint("Unimplemented Packet: " + BitConverter.ToString(Packet).Replace('-', ' '));
break; break;
} }
} }
} }
public void Disconnect() public void Disconnect()
{ {
Server.ConnectedClients.Remove(this); Logger.DebugPrint(ClientSocket.RemoteEndPoint + " has Disconnected.");
ClientSocket.Dispose(); LoggedIn = false;
} LoggedinUser = null;
Server.ConnectedClients.Remove(this);
public void SendPacket(byte[] PacketData) ClientSocket.Dispose();
{ }
ClientSocket.Send(PacketData);
} public void SendPacket(byte[] PacketData)
{
public Client(Socket clientSocket) ClientSocket.Send(PacketData);
{ }
ClientSocket = clientSocket;
RemoteIp = clientSocket.RemoteEndPoint.ToString(); public Client(Socket clientSocket)
{
Logger.DebugPrint("Client connected @ " + RemoteIp); ClientSocket = clientSocket;
RemoteIp = clientSocket.RemoteEndPoint.ToString();
recvPackets = new Thread(() =>
{ Logger.DebugPrint("Client connected @ " + RemoteIp);
receivePackets();
}); recvPackets = new Thread(() =>
recvPackets.Start(); {
} receivePackets();
} });
} recvPackets.Start();
}
}
}

210
Horse Isle Server/Horse Isle Server/ConfigReader.cs
View file

@ -1,107 +1,103 @@
using Horse_Isle_Server.Properties; using Horse_Isle_Server.Properties;
using System; using System;
using System.IO; using System.IO;
namespace Horse_Isle_Server namespace Horse_Isle_Server
{ {
class ConfigReader class ConfigReader
{ {
public static int Port; public static int Port;
public static string BindIP; public static string BindIP;
public static string DatabaseIP; public static string DatabaseIP;
public static string DatabaseUsername; public static string DatabaseUsername;
public static string DatabaseName; public static string DatabaseName;
public static string DatabasePassword; public static string DatabasePassword;
public static int DatabasePort; public static int DatabasePort;
public static string Motd; public static string Motd;
public static string MapFile; public static string MapFile;
public static string OverlayMapFile; public static string GameDataFile;
public static string GameDataFile; public static string CrossDomainPolicyFile;
public static string CrossDomainPolicyFile; public static bool Debug;
public static bool Debug;
private static string ConfigurationFileName = "server.properties";
private static string ConfigurationFileName = "server.properties"; public static void OpenConfig()
public static void OpenConfig() {
{ if (!File.Exists(ConfigurationFileName))
if (!File.Exists(ConfigurationFileName)) {
{ Logger.ErrorPrint(ConfigurationFileName+" not found! writing default.");
Logger.ErrorPrint(ConfigurationFileName+" not found! writing default."); File.WriteAllText(ConfigurationFileName,Resources.DefaultServerProperties);
File.WriteAllText(ConfigurationFileName,Resources.DefaultServerProperties); }
}
string[] configFile = File.ReadAllLines(ConfigurationFileName);
string[] configFile = File.ReadAllLines(ConfigurationFileName); foreach (string setting in configFile)
foreach (string setting in configFile) {
{ /*
/* * Avoid crashing.
* Avoid crashing. */
*/ if (setting.Length < 1)
if (setting.Length < 1) continue;
continue; if (setting[0] == '#')
if (setting[0] == '#') continue;
continue; if (!setting.Contains("="))
if (!setting.Contains("=")) continue;
continue;
string[] dataPair = setting.Split('=');
string[] dataPair = setting.Split('=');
string key = dataPair[0];
string key = dataPair[0]; string data = dataPair[1];
string data = dataPair[1]; /*
/* * Parse configuration file
* Parse configuration file */
*/
switch (key)
switch (key) {
{ case "port":
case "port": Port = int.Parse(data);
Port = int.Parse(data); break;
break; case "ip":
case "ip": BindIP = data;
BindIP = data; break;
break; case "db_ip":
case "db_ip": DatabaseIP = data;
DatabaseIP = data; break;
break; case "db_username":
case "db_username": DatabaseUsername = data;
DatabaseUsername = data; break;
break; case "db_password":
case "db_password": DatabasePassword = data;
DatabasePassword = data; break;
break; case "db_name":
case "db_name": DatabaseName = data;
DatabaseName = data; break;
break; case "db_port":
case "db_port": DatabasePort = int.Parse(data);
DatabasePort = int.Parse(data); break;
break; case "map":
case "map": MapFile = data;
MapFile = data; break;
break; case "motd":
case "motd": Motd = data;
Motd = data; break;
break; case "gamedata":
case "gamedata": GameDataFile = data;
GameDataFile = data; break;
break; case "crossdomain":
case "overlaymap": CrossDomainPolicyFile = data;
OverlayMapFile = data; break;
break; case "debug":
case "crossdomain": Debug = data == "true";
CrossDomainPolicyFile = data; break;
break; }
case "debug":
Debug = data == "true";
break;
} }
}
}
}
}
}
}
}

76
Horse Isle Server/Horse Isle Server/Converters.cs
View file

@ -1,38 +1,38 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace Horse_Isle_Server namespace Horse_Isle_Server
{ {
class Converters class Converters
{ {
// Thanks Stackoverflow (https://stackoverflow.com/questions/321370/how-can-i-convert-a-hex-string-to-a-byte-array) // Thanks Stackoverflow (https://stackoverflow.com/questions/321370/how-can-i-convert-a-hex-string-to-a-byte-array)
private static int getHexVal(char hex) private static int getHexVal(char hex)
{ {
int val = (int)hex; int val = (int)hex;
//For uppercase A-F letters: //For uppercase A-F letters:
//return val - (val < 58 ? 48 : 55); //return val - (val < 58 ? 48 : 55);
//For lowercase a-f letters: //For lowercase a-f letters:
//return val - (val < 58 ? 48 : 87); //return val - (val < 58 ? 48 : 87);
//Or the two combined, but a bit slower: //Or the two combined, but a bit slower:
return val - (val < 58 ? 48 : (val < 97 ? 55 : 87)); return val - (val < 58 ? 48 : (val < 97 ? 55 : 87));
} }
public static byte[] StringToByteArray(string hex) public static byte[] StringToByteArray(string hex)
{ {
if (hex.Length % 2 == 1) if (hex.Length % 2 == 1)
throw new ArgumentException("The binary key cannot have an odd number of digits"); throw new ArgumentException("The binary key cannot have an odd number of digits");
byte[] arr = new byte[hex.Length >> 1]; byte[] arr = new byte[hex.Length >> 1];
for (int i = 0; i < hex.Length >> 1; ++i) for (int i = 0; i < hex.Length >> 1; ++i)
{ {
arr[i] = (byte)((getHexVal(hex[i << 1]) << 4) + (getHexVal(hex[(i << 1) + 1]))); arr[i] = (byte)((getHexVal(hex[i << 1]) << 4) + (getHexVal(hex[(i << 1) + 1])));
} }
return arr; return arr;
} }
} }
} }

68
Horse Isle Server/Horse Isle Server/CrossDomainPolicy.cs
View file

@ -1,34 +1,34 @@
using Horse_Isle_Server.Properties; using Horse_Isle_Server.Properties;
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.IO; using System.IO;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace Horse_Isle_Server namespace Horse_Isle_Server
{ {
class CrossDomainPolicy class CrossDomainPolicy
{ {
public static byte[] GetPolicy() public static byte[] GetPolicy()
{ {
if (!File.Exists(ConfigReader.CrossDomainPolicyFile)) { if (!File.Exists(ConfigReader.CrossDomainPolicyFile)) {
if (ConfigReader.Debug) if (ConfigReader.Debug)
Console.WriteLine("[DEBUG] Cross-Domain-Policy file not found, using default"); Console.WriteLine("[DEBUG] Cross-Domain-Policy file not found, using default");
File.WriteAllText(ConfigReader.CrossDomainPolicyFile, Resources.DefaultCrossDomain); File.WriteAllText(ConfigReader.CrossDomainPolicyFile, Resources.DefaultCrossDomain);
} }
MemoryStream ms = new MemoryStream(); MemoryStream ms = new MemoryStream();
byte[] policyFileBytes = File.ReadAllBytes(ConfigReader.CrossDomainPolicyFile); byte[] policyFileBytes = File.ReadAllBytes(ConfigReader.CrossDomainPolicyFile);
ms.Write(policyFileBytes, 0x00, policyFileBytes.Length); ms.Write(policyFileBytes, 0x00, policyFileBytes.Length);
ms.WriteByte(0x00); ms.WriteByte(0x00);
ms.Seek(0x00, SeekOrigin.Begin); ms.Seek(0x00, SeekOrigin.Begin);
byte[] policyFileData = ms.ToArray(); byte[] policyFileData = ms.ToArray();
ms.Close(); ms.Close();
return policyFileData; return policyFileData;
} }
} }
} }

994
Horse Isle Server/Horse Isle Server/Database.cs
View file

@ -1,498 +1,498 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using MySqlConnector; using MySqlConnector;
namespace Horse_Isle_Server namespace Horse_Isle_Server
{ {
class Database class Database
{ {
public static MySqlConnection db; public static MySqlConnection db;
public static void OpenDatabase() public static void OpenDatabase()
{ {
db = new MySqlConnection("server=" + ConfigReader.DatabaseIP + ";user=" + ConfigReader.DatabaseUsername + ";password=" + ConfigReader.DatabasePassword+";database="+ConfigReader.DatabaseName); db = new MySqlConnection("server=" + ConfigReader.DatabaseIP + ";user=" + ConfigReader.DatabaseUsername + ";password=" + ConfigReader.DatabasePassword+";database="+ConfigReader.DatabaseName);
db.Open(); db.Open();
string UserTable = "CREATE TABLE Users(Id INT, Username TEXT(16),Email TEXT(128),Country TEXT(128),SecurityQuestion Text(128),SecurityAnswerHash TEXT(128),Age INT,PassHash TEXT(128), Salt TEXT(128),Gender TEXT(16), Admin TEXT(3), Moderator TEXT(3))"; string UserTable = "CREATE TABLE Users(Id INT, Username TEXT(16),Email TEXT(128),Country TEXT(128),SecurityQuestion Text(128),SecurityAnswerHash TEXT(128),Age INT,PassHash TEXT(128), Salt TEXT(128),Gender TEXT(16), Admin TEXT(3), Moderator TEXT(3))";
string ExtTable = "CREATE TABLE UserExt(Id INT, X INT, Y INT, Money INT, BankBalance BIGINT,ProfilePage Text(1028), CharId INT)"; string ExtTable = "CREATE TABLE UserExt(Id INT, X INT, Y INT, Money INT, BankBalance BIGINT,ProfilePage Text(1028), CharId INT)";
string MailTable = "CREATE TABLE Mailbox(IdTo INT, PlayerFrom TEXT(16),Subject TEXT(128), Message Text(1028), TimeSent INT)"; string MailTable = "CREATE TABLE Mailbox(IdTo INT, PlayerFrom TEXT(16),Subject TEXT(128), Message Text(1028), TimeSent INT)";
string WorldTable = "CREATE TABLE World(TimeStarted INT, Weather TEXT(64))"; string WorldTable = "CREATE TABLE World(TimeStarted INT, Weather TEXT(64))";
string DroppedTable = "CREATE TABLE DroppedItems(X INT, Y INT, ItemID INT)"; string DroppedTable = "CREATE TABLE DroppedItems(X INT, Y INT, ItemID INT)";
try try
{ {
MySqlCommand sqlCommand = db.CreateCommand(); MySqlCommand sqlCommand = db.CreateCommand();
sqlCommand.CommandText = UserTable; sqlCommand.CommandText = UserTable;
sqlCommand.ExecuteNonQuery(); sqlCommand.ExecuteNonQuery();
} }
catch (Exception e) { catch (Exception e) {
Logger.WarnPrint(e.Message); Logger.WarnPrint(e.Message);
}; };
try try
{ {
MySqlCommand sqlCommand = db.CreateCommand(); MySqlCommand sqlCommand = db.CreateCommand();
sqlCommand.CommandText = ExtTable; sqlCommand.CommandText = ExtTable;
sqlCommand.ExecuteNonQuery(); sqlCommand.ExecuteNonQuery();
} }
catch (Exception e) catch (Exception e)
{ {
Logger.WarnPrint(e.Message); Logger.WarnPrint(e.Message);
}; };
try try
{ {
MySqlCommand sqlCommand = db.CreateCommand(); MySqlCommand sqlCommand = db.CreateCommand();
sqlCommand.CommandText = MailTable; sqlCommand.CommandText = MailTable;
sqlCommand.ExecuteNonQuery(); sqlCommand.ExecuteNonQuery();
} }
catch (Exception e) catch (Exception e)
{ {
Logger.WarnPrint(e.Message); Logger.WarnPrint(e.Message);
}; };
try try
{ {
MySqlCommand sqlCommand = db.CreateCommand(); MySqlCommand sqlCommand = db.CreateCommand();
sqlCommand.CommandText = DroppedTable; sqlCommand.CommandText = DroppedTable;
sqlCommand.ExecuteNonQuery(); sqlCommand.ExecuteNonQuery();
} }
catch (Exception e) catch (Exception e)
{ {
Logger.WarnPrint(e.Message); Logger.WarnPrint(e.Message);
}; };
try try
{ {
MySqlCommand sqlCommand = db.CreateCommand(); MySqlCommand sqlCommand = db.CreateCommand();
sqlCommand.CommandText = WorldTable; sqlCommand.CommandText = WorldTable;
sqlCommand.ExecuteNonQuery(); sqlCommand.ExecuteNonQuery();
int epoch = (int)(DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds; int epoch = (int)(DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds;
sqlCommand = db.CreateCommand(); sqlCommand = db.CreateCommand();
sqlCommand.CommandText = "INSERT INTO World VALUES(@unix,'SUNNY')"; sqlCommand.CommandText = "INSERT INTO World VALUES(@unix,'SUNNY')";
sqlCommand.Parameters.AddWithValue("@unix", epoch); sqlCommand.Parameters.AddWithValue("@unix", epoch);
sqlCommand.Prepare(); sqlCommand.Prepare();
sqlCommand.ExecuteNonQuery(); sqlCommand.ExecuteNonQuery();
} }
catch (Exception e) catch (Exception e)
{ {
Logger.WarnPrint(e.Message); Logger.WarnPrint(e.Message);
}; };
} }
public static int GetServerCreationTime() public static int GetServerCreationTime()
{ {
MySqlCommand sqlCommand = db.CreateCommand(); MySqlCommand sqlCommand = db.CreateCommand();
sqlCommand.CommandText = "SELECT TimeStarted FROM World"; sqlCommand.CommandText = "SELECT TimeStarted FROM World";
int creationTime = Convert.ToInt32(sqlCommand.ExecuteScalar()); int creationTime = Convert.ToInt32(sqlCommand.ExecuteScalar());
return creationTime; return creationTime;
} }
public static string GetWorldWeather() public static string GetWorldWeather()
{ {
MySqlCommand sqlCommand = db.CreateCommand(); MySqlCommand sqlCommand = db.CreateCommand();
sqlCommand.CommandText = "SELECT Weather FROM World"; sqlCommand.CommandText = "SELECT Weather FROM World";
string Weather = sqlCommand.ExecuteScalar().ToString(); string Weather = sqlCommand.ExecuteScalar().ToString();
return Weather; return Weather;
} }
public static void SetWorldWeather(string Weather) public static void SetWorldWeather(string Weather)
{ {
MySqlCommand sqlCommand = db.CreateCommand(); MySqlCommand sqlCommand = db.CreateCommand();
sqlCommand.CommandText = "UPDATE World SET Weather=@weather"; sqlCommand.CommandText = "UPDATE World SET Weather=@weather";
sqlCommand.Parameters.AddWithValue("@weather", Weather); sqlCommand.Parameters.AddWithValue("@weather", Weather);
sqlCommand.Prepare(); sqlCommand.Prepare();
sqlCommand.ExecuteNonQuery(); sqlCommand.ExecuteNonQuery();
} }
public static byte[] GetPasswordSalt(string username) public static byte[] GetPasswordSalt(string username)
{ {
if (CheckUserExist(username)) if (CheckUserExist(username))
{ {
MySqlCommand sqlCommand = db.CreateCommand(); MySqlCommand sqlCommand = db.CreateCommand();
sqlCommand.CommandText = "SELECT Salt FROM Users WHERE Username=@name"; sqlCommand.CommandText = "SELECT Salt FROM Users WHERE Username=@name";
sqlCommand.Parameters.AddWithValue("@name", username); sqlCommand.Parameters.AddWithValue("@name", username);
sqlCommand.Prepare(); sqlCommand.Prepare();
string expectedHash = sqlCommand.ExecuteScalar().ToString(); string expectedHash = sqlCommand.ExecuteScalar().ToString();
return Converters.StringToByteArray(expectedHash); return Converters.StringToByteArray(expectedHash);
} }
else else
{ {
throw new KeyNotFoundException("Username " + username + " not found in database."); throw new KeyNotFoundException("Username " + username + " not found in database.");
} }
} }
public static int CheckMailcount(int id) public static int CheckMailcount(int id)
{ {
MySqlCommand sqlCommand = db.CreateCommand(); MySqlCommand sqlCommand = db.CreateCommand();
sqlCommand.CommandText = "SELECT COUNT(1) FROM Mailbox WHERE IdTo=@id"; sqlCommand.CommandText = "SELECT COUNT(1) FROM Mailbox WHERE IdTo=@id";
sqlCommand.Parameters.AddWithValue("@id", id); sqlCommand.Parameters.AddWithValue("@id", id);
sqlCommand.Prepare(); sqlCommand.Prepare();
Int32 count = Convert.ToInt32(sqlCommand.ExecuteScalar()); Int32 count = Convert.ToInt32(sqlCommand.ExecuteScalar());
return count; return count;
} }
public static void AddMail(int toId, string fromName, string subject, string message) public static void AddMail(int toId, string fromName, string subject, string message)
{ {
MySqlCommand sqlCommand = db.CreateCommand(); MySqlCommand sqlCommand = db.CreateCommand();
int epoch = (int)(DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds; int epoch = (int)(DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds;
sqlCommand.CommandText = "INSERT INTO Mailbox VALUES(@toId,@from,@subject,@message,@time)"; sqlCommand.CommandText = "INSERT INTO Mailbox VALUES(@toId,@from,@subject,@message,@time)";
sqlCommand.Parameters.AddWithValue("@toId", toId); sqlCommand.Parameters.AddWithValue("@toId", toId);
sqlCommand.Parameters.AddWithValue("@from", fromName); sqlCommand.Parameters.AddWithValue("@from", fromName);
sqlCommand.Parameters.AddWithValue("@subject", subject); sqlCommand.Parameters.AddWithValue("@subject", subject);
sqlCommand.Parameters.AddWithValue("@mesasge", message); sqlCommand.Parameters.AddWithValue("@mesasge", message);
sqlCommand.Parameters.AddWithValue("@time", epoch); sqlCommand.Parameters.AddWithValue("@time", epoch);
sqlCommand.Prepare(); sqlCommand.Prepare();
sqlCommand.ExecuteNonQuery(); sqlCommand.ExecuteNonQuery();
} }
public static bool CheckUserExist(int id) public static bool CheckUserExist(int id)
{ {
MySqlCommand sqlCommand = db.CreateCommand(); MySqlCommand sqlCommand = db.CreateCommand();
sqlCommand.CommandText = "SELECT COUNT(1) FROM Users WHERE Id=@id"; sqlCommand.CommandText = "SELECT COUNT(1) FROM Users WHERE Id=@id";
sqlCommand.Parameters.AddWithValue("@id", id); sqlCommand.Parameters.AddWithValue("@id", id);
sqlCommand.Prepare(); sqlCommand.Prepare();
Int32 count = Convert.ToInt32(sqlCommand.ExecuteScalar()); Int32 count = Convert.ToInt32(sqlCommand.ExecuteScalar());
return count >= 1; return count >= 1;
} }
public static bool CheckUserExist(string username) public static bool CheckUserExist(string username)
{ {
MySqlCommand sqlCommand = db.CreateCommand(); MySqlCommand sqlCommand = db.CreateCommand();
sqlCommand.CommandText = "SELECT COUNT(1) FROM Users WHERE Username=@name"; sqlCommand.CommandText = "SELECT COUNT(1) FROM Users WHERE Username=@name";
sqlCommand.Parameters.AddWithValue("@name", username); sqlCommand.Parameters.AddWithValue("@name", username);
sqlCommand.Prepare(); sqlCommand.Prepare();
Int32 count = Convert.ToInt32(sqlCommand.ExecuteScalar()); Int32 count = Convert.ToInt32(sqlCommand.ExecuteScalar());
return count >= 1; return count >= 1;
} }
public static bool CheckUserExtExists(int id) public static bool CheckUserExtExists(int id)
{ {
MySqlCommand sqlCommand = db.CreateCommand(); MySqlCommand sqlCommand = db.CreateCommand();
sqlCommand.CommandText = "SELECT COUNT(1) FROM UserExt WHERE Id=@id"; sqlCommand.CommandText = "SELECT COUNT(1) FROM UserExt WHERE Id=@id";
sqlCommand.Parameters.AddWithValue("@id", id); sqlCommand.Parameters.AddWithValue("@id", id);
sqlCommand.Prepare(); sqlCommand.Prepare();
Int32 count = Convert.ToInt32(sqlCommand.ExecuteScalar()); Int32 count = Convert.ToInt32(sqlCommand.ExecuteScalar());
return count >= 1; return count >= 1;
} }
public static bool CheckUserIsModerator(string username) public static bool CheckUserIsModerator(string username)
{ {
if (CheckUserExist(username)) if (CheckUserExist(username))
{ {
MySqlCommand sqlCommand = db.CreateCommand(); MySqlCommand sqlCommand = db.CreateCommand();
sqlCommand.CommandText = "SELECT Moderator FROM Users WHERE Username=@name"; sqlCommand.CommandText = "SELECT Moderator FROM Users WHERE Username=@name";
sqlCommand.Parameters.AddWithValue("@name", username); sqlCommand.Parameters.AddWithValue("@name", username);
sqlCommand.Prepare(); sqlCommand.Prepare();
string modStr = sqlCommand.ExecuteScalar().ToString(); string modStr = sqlCommand.ExecuteScalar().ToString();
return modStr == "YES"; return modStr == "YES";
} }
else else
{ {
throw new KeyNotFoundException("Username " + username + " not found in database."); throw new KeyNotFoundException("Username " + username + " not found in database.");
} }
} }
public static bool CheckUserIsAdmin(string username) public static bool CheckUserIsAdmin(string username)
{ {
if (CheckUserExist(username)) if (CheckUserExist(username))
{ {
MySqlCommand sqlCommand = db.CreateCommand(); MySqlCommand sqlCommand = db.CreateCommand();
sqlCommand.CommandText = "SELECT Admin FROM Users WHERE Username=@name"; sqlCommand.CommandText = "SELECT Admin FROM Users WHERE Username=@name";
sqlCommand.Parameters.AddWithValue("@name", username); sqlCommand.Parameters.AddWithValue("@name", username);
sqlCommand.Prepare(); sqlCommand.Prepare();
string adminStr = sqlCommand.ExecuteScalar().ToString(); string adminStr = sqlCommand.ExecuteScalar().ToString();
return adminStr == "YES"; return adminStr == "YES";
} }
else else
{ {
throw new KeyNotFoundException("Username " + username + " not found in database."); throw new KeyNotFoundException("Username " + username + " not found in database.");
} }
} }
public static void CreateUserExt(int id) public static void CreateUserExt(int id)
{ {
if (CheckUserExtExists(id)) // user allready exists! if (CheckUserExtExists(id)) // user allready exists!
throw new Exception("Userid " + id + " Allready in userext."); throw new Exception("Userid " + id + " Allready in userext.");
MySqlCommand sqlCommand = db.CreateCommand(); MySqlCommand sqlCommand = db.CreateCommand();
sqlCommand.CommandText = "INSERT INTO UserExt VALUES(@id,@x,@y,0,0,'',5)"; sqlCommand.CommandText = "INSERT INTO UserExt VALUES(@id,@x,@y,0,0,'',0)";
sqlCommand.Parameters.AddWithValue("@id", id); sqlCommand.Parameters.AddWithValue("@id", id);
sqlCommand.Parameters.AddWithValue("@x", Gamedata.NewUserStartX); sqlCommand.Parameters.AddWithValue("@x", Map.NewUserStartX);
sqlCommand.Parameters.AddWithValue("@y", Gamedata.NewUserStartY); sqlCommand.Parameters.AddWithValue("@y", Map.NewUserStartY);
sqlCommand.Prepare(); sqlCommand.Prepare();
sqlCommand.ExecuteNonQuery(); sqlCommand.ExecuteNonQuery();
} }
public static int GetUserid(string username) public static int GetUserid(string username)
{ {
if (CheckUserExist(username)) if (CheckUserExist(username))
{ {
MySqlCommand sqlCommand = db.CreateCommand(); MySqlCommand sqlCommand = db.CreateCommand();
sqlCommand.CommandText = "SELECT Id FROM Users WHERE Username=@name"; sqlCommand.CommandText = "SELECT Id FROM Users WHERE Username=@name";
sqlCommand.Parameters.AddWithValue("@name", username); sqlCommand.Parameters.AddWithValue("@name", username);
sqlCommand.Prepare(); sqlCommand.Prepare();
int userId = Convert.ToInt32(sqlCommand.ExecuteScalar()); int userId = Convert.ToInt32(sqlCommand.ExecuteScalar());
return userId; return userId;
} }
else else
{ {
throw new KeyNotFoundException("Username " + username + " not found in database."); throw new KeyNotFoundException("Username " + username + " not found in database.");
} }
} }
public static int GetPlayerCharId(int userId) public static int GetPlayerCharId(int userId)
{ {
if (CheckUserExtExists(userId)) if (CheckUserExtExists(userId))
{ {
MySqlCommand sqlCommand = db.CreateCommand(); MySqlCommand sqlCommand = db.CreateCommand();
sqlCommand.CommandText = "SELECT CharId FROM UserExt WHERE Id=@id"; sqlCommand.CommandText = "SELECT CharId FROM UserExt WHERE Id=@id";
sqlCommand.Parameters.AddWithValue("@id", userId); sqlCommand.Parameters.AddWithValue("@id", userId);
sqlCommand.Prepare(); sqlCommand.Prepare();
int CharId = Convert.ToInt32(sqlCommand.ExecuteScalar()); int CharId = Convert.ToInt32(sqlCommand.ExecuteScalar());
return CharId; return CharId;
} }
else else
{ {
throw new KeyNotFoundException("Id " + userId + " not found in database."); throw new KeyNotFoundException("Id " + userId + " not found in database.");
} }
} }
public static void SetPlayerCharId(int charid, int id) public static void SetPlayerCharId(int charid, int id)
{ {
if (CheckUserExist(id)) if (CheckUserExist(id))
{ {
MySqlCommand sqlCommand = db.CreateCommand(); MySqlCommand sqlCommand = db.CreateCommand();
sqlCommand.CommandText = "UPDATE UserExt SET CharId=@charId WHERE Id=@id"; sqlCommand.CommandText = "UPDATE UserExt SET CharId=@charId WHERE Id=@id";
sqlCommand.Parameters.AddWithValue("@charId", charid); sqlCommand.Parameters.AddWithValue("@charId", charid);
sqlCommand.Parameters.AddWithValue("@id", id); sqlCommand.Parameters.AddWithValue("@id", id);
sqlCommand.Prepare(); sqlCommand.Prepare();
sqlCommand.ExecuteNonQuery(); sqlCommand.ExecuteNonQuery();
} }
else else
{ {
throw new KeyNotFoundException("Id " + id + " not found in database."); throw new KeyNotFoundException("Id " + id + " not found in database.");
} }
} }
public static int GetPlayerX(int userId) public static int GetPlayerX(int userId)
{ {
if (CheckUserExtExists(userId)) if (CheckUserExtExists(userId))
{ {
MySqlCommand sqlCommand = db.CreateCommand(); MySqlCommand sqlCommand = db.CreateCommand();
sqlCommand.CommandText = "SELECT X FROM UserExt WHERE Id=@id"; sqlCommand.CommandText = "SELECT X FROM UserExt WHERE Id=@id";
sqlCommand.Parameters.AddWithValue("@id", userId); sqlCommand.Parameters.AddWithValue("@id", userId);
sqlCommand.Prepare(); sqlCommand.Prepare();
int X = Convert.ToInt32(sqlCommand.ExecuteScalar()); int X = Convert.ToInt32(sqlCommand.ExecuteScalar());
return X; return X;
} }
else else
{ {
throw new KeyNotFoundException("Id " + userId + " not found in database."); throw new KeyNotFoundException("Id " + userId + " not found in database.");
} }
} }
public static void SetPlayerX(int x, int id) public static void SetPlayerX(int x, int id)
{ {
if (CheckUserExist(id)) if (CheckUserExist(id))
{ {
MySqlCommand sqlCommand = db.CreateCommand(); MySqlCommand sqlCommand = db.CreateCommand();
sqlCommand.CommandText = "UPDATE UserExt SET X=@x WHERE Id=@id"; sqlCommand.CommandText = "UPDATE UserExt SET X=@x WHERE Id=@id";
sqlCommand.Parameters.AddWithValue("@x", x); sqlCommand.Parameters.AddWithValue("@x", x);
sqlCommand.Parameters.AddWithValue("@id", id); sqlCommand.Parameters.AddWithValue("@id", id);
sqlCommand.Prepare(); sqlCommand.Prepare();
sqlCommand.ExecuteNonQuery(); sqlCommand.ExecuteNonQuery();
} }
else else
{ {
throw new KeyNotFoundException("Id " + id + " not found in database."); throw new KeyNotFoundException("Id " + id + " not found in database.");
} }
} }
public static int GetPlayerY(int userId) public static int GetPlayerY(int userId)
{ {
if (CheckUserExtExists(userId)) if (CheckUserExtExists(userId))
{ {
MySqlCommand sqlCommand = db.CreateCommand(); MySqlCommand sqlCommand = db.CreateCommand();
sqlCommand.CommandText = "SELECT Y FROM UserExt WHERE Id=@id"; sqlCommand.CommandText = "SELECT Y FROM UserExt WHERE Id=@id";
sqlCommand.Parameters.AddWithValue("@id", userId); sqlCommand.Parameters.AddWithValue("@id", userId);
sqlCommand.Prepare(); sqlCommand.Prepare();
int Y = Convert.ToInt32(sqlCommand.ExecuteScalar()); int Y = Convert.ToInt32(sqlCommand.ExecuteScalar());
return Y; return Y;
} }
else else
{ {
throw new KeyNotFoundException("Id " + userId + " not found in database."); throw new KeyNotFoundException("Id " + userId + " not found in database.");
} }
} }
public static void SetPlayerY(int y, int id) public static void SetPlayerY(int y, int id)
{ {
if (CheckUserExist(id)) if (CheckUserExist(id))
{ {
MySqlCommand sqlCommand = db.CreateCommand(); MySqlCommand sqlCommand = db.CreateCommand();
sqlCommand.CommandText = "UPDATE UserExt SET Y=@y WHERE Id=@id"; sqlCommand.CommandText = "UPDATE UserExt SET Y=@y WHERE Id=@id";
sqlCommand.Parameters.AddWithValue("@y", y); sqlCommand.Parameters.AddWithValue("@y", y);
sqlCommand.Parameters.AddWithValue("@id", id); sqlCommand.Parameters.AddWithValue("@id", id);
sqlCommand.Prepare(); sqlCommand.Prepare();
sqlCommand.ExecuteNonQuery(); sqlCommand.ExecuteNonQuery();
} }
else else
{ {
throw new KeyNotFoundException("Id " + id + " not found in database."); throw new KeyNotFoundException("Id " + id + " not found in database.");
} }
} }
public static void SetPlayerMoney(int money, int id) public static void SetPlayerMoney(int money, int id)
{ {
if (CheckUserExist(id)) if (CheckUserExist(id))
{ {
MySqlCommand sqlCommand = db.CreateCommand(); MySqlCommand sqlCommand = db.CreateCommand();
sqlCommand.CommandText = "UPDATE UserExt SET Money=@money WHERE Id=@id"; sqlCommand.CommandText = "UPDATE UserExt SET Money=@money WHERE Id=@id";
sqlCommand.Parameters.AddWithValue("@money", money); sqlCommand.Parameters.AddWithValue("@money", money);
sqlCommand.Parameters.AddWithValue("@id", id); sqlCommand.Parameters.AddWithValue("@id", id);
sqlCommand.Prepare(); sqlCommand.Prepare();
sqlCommand.ExecuteNonQuery(); sqlCommand.ExecuteNonQuery();
} }
else else
{ {
throw new KeyNotFoundException("Id " + id + " not found in database."); throw new KeyNotFoundException("Id " + id + " not found in database.");
} }
} }
public static int GetPlayerMoney(int userId) public static int GetPlayerMoney(int userId)
{ {
if (CheckUserExtExists(userId)) if (CheckUserExtExists(userId))
{ {
MySqlCommand sqlCommand = db.CreateCommand(); MySqlCommand sqlCommand = db.CreateCommand();
sqlCommand.CommandText = "SELECT Money FROM UserExt WHERE Id=@id"; sqlCommand.CommandText = "SELECT Money FROM UserExt WHERE Id=@id";
sqlCommand.Parameters.AddWithValue("@id", userId); sqlCommand.Parameters.AddWithValue("@id", userId);
sqlCommand.Prepare(); sqlCommand.Prepare();
int Money = Convert.ToInt32(sqlCommand.ExecuteScalar()); int Money = Convert.ToInt32(sqlCommand.ExecuteScalar());
return Money; return Money;
} }
else else
{ {
throw new KeyNotFoundException("Id " + userId + " not found in database."); throw new KeyNotFoundException("Id " + userId + " not found in database.");
} }
} }
public static int GetPlayerBankMoney(int userId) public static int GetPlayerBankMoney(int userId)
{ {
if (CheckUserExtExists(userId)) if (CheckUserExtExists(userId))
{ {
MySqlCommand sqlCommand = db.CreateCommand(); MySqlCommand sqlCommand = db.CreateCommand();
sqlCommand.CommandText = "SELECT BankBalance FROM UserExt WHERE Id=@id"; sqlCommand.CommandText = "SELECT BankBalance FROM UserExt WHERE Id=@id";
sqlCommand.Parameters.AddWithValue("@id", userId); sqlCommand.Parameters.AddWithValue("@id", userId);
sqlCommand.Prepare(); sqlCommand.Prepare();
int BankMoney = Convert.ToInt32(sqlCommand.ExecuteScalar()); int BankMoney = Convert.ToInt32(sqlCommand.ExecuteScalar());
return BankMoney; return BankMoney;
} }
else else
{ {
throw new KeyNotFoundException("Id " + userId + " not found in database."); throw new KeyNotFoundException("Id " + userId + " not found in database.");
} }
} }
public static void SetPlayerBankMoney(int bankMoney, int id) public static void SetPlayerBankMoney(int bankMoney, int id)
{ {
if (CheckUserExist(id)) if (CheckUserExist(id))
{ {
MySqlCommand sqlCommand = db.CreateCommand(); MySqlCommand sqlCommand = db.CreateCommand();
sqlCommand.CommandText = "UPDATE UserExt SET BankBalance=@bankMoney WHERE Id=@id"; sqlCommand.CommandText = "UPDATE UserExt SET BankBalance=@bankMoney WHERE Id=@id";
sqlCommand.Parameters.AddWithValue("@bankMoney", bankMoney); sqlCommand.Parameters.AddWithValue("@bankMoney", bankMoney);
sqlCommand.Parameters.AddWithValue("@id", id); sqlCommand.Parameters.AddWithValue("@id", id);
sqlCommand.Prepare(); sqlCommand.Prepare();
sqlCommand.ExecuteNonQuery(); sqlCommand.ExecuteNonQuery();
} }
else else
{ {
throw new KeyNotFoundException("Id " + id + " not found in database."); throw new KeyNotFoundException("Id " + id + " not found in database.");
} }
} }
public static void SetPlayerProfile(string profilePage, int id) public static void SetPlayerProfile(string profilePage, int id)
{ {
if (CheckUserExist(id)) if (CheckUserExist(id))
{ {
MySqlCommand sqlCommand = db.CreateCommand(); MySqlCommand sqlCommand = db.CreateCommand();
sqlCommand.CommandText = "UPDATE UserExt SET ProfilePage=@profilePage WHERE Id=@id"; sqlCommand.CommandText = "UPDATE UserExt SET ProfilePage=@profilePage WHERE Id=@id";
sqlCommand.Parameters.AddWithValue("@profilePage", profilePage); sqlCommand.Parameters.AddWithValue("@profilePage", profilePage);
sqlCommand.Parameters.AddWithValue("@id", id); sqlCommand.Parameters.AddWithValue("@id", id);
sqlCommand.Prepare(); sqlCommand.Prepare();
sqlCommand.ExecuteNonQuery(); sqlCommand.ExecuteNonQuery();
} }
else else
{ {
throw new KeyNotFoundException("Id " + id + " not found in database."); throw new KeyNotFoundException("Id " + id + " not found in database.");
} }
} }
public static string GetPlayerProfile(int id) public static string GetPlayerProfile(int id)
{ {
if (CheckUserExist(id)) if (CheckUserExist(id))
{ {
MySqlCommand sqlCommand = db.CreateCommand(); MySqlCommand sqlCommand = db.CreateCommand();
sqlCommand.CommandText = "SELECT ProfilePage FROM UserExt WHERE Id=@id"; sqlCommand.CommandText = "SELECT ProfilePage FROM UserExt WHERE Id=@id";
sqlCommand.Parameters.AddWithValue("@id", id); sqlCommand.Parameters.AddWithValue("@id", id);
sqlCommand.Prepare(); sqlCommand.Prepare();
string profilePage = sqlCommand.ExecuteScalar().ToString(); string profilePage = sqlCommand.ExecuteScalar().ToString();
return profilePage; return profilePage;
} }
else else
{ {
throw new KeyNotFoundException("Id " + id + " not found in database."); throw new KeyNotFoundException("Id " + id + " not found in database.");
} }
} }
public static string GetUsername(int userId) public static string GetUsername(int userId)
{ {
if(CheckUserExist(userId)) if(CheckUserExist(userId))
{ {
MySqlCommand sqlCommand = db.CreateCommand(); MySqlCommand sqlCommand = db.CreateCommand();
sqlCommand.CommandText = "SELECT Username FROM Users WHERE Id=@id"; sqlCommand.CommandText = "SELECT Username FROM Users WHERE Id=@id";
sqlCommand.Parameters.AddWithValue("@id", userId); sqlCommand.Parameters.AddWithValue("@id", userId);
sqlCommand.Prepare(); sqlCommand.Prepare();
string username = sqlCommand.ExecuteScalar().ToString(); string username = sqlCommand.ExecuteScalar().ToString();
return username; return username;
} }
else else
{ {
throw new KeyNotFoundException("Id " + userId + " not found in database."); throw new KeyNotFoundException("Id " + userId + " not found in database.");
} }
} }
public static byte[] GetPasswordHash(string username) public static byte[] GetPasswordHash(string username)
{ {
if(CheckUserExist(username)) if(CheckUserExist(username))
{ {
MySqlCommand sqlCommand = db.CreateCommand(); MySqlCommand sqlCommand = db.CreateCommand();
sqlCommand.CommandText = "SELECT PassHash FROM Users WHERE Username=@name"; sqlCommand.CommandText = "SELECT PassHash FROM Users WHERE Username=@name";
sqlCommand.Parameters.AddWithValue("@name", username); sqlCommand.Parameters.AddWithValue("@name", username);
sqlCommand.Prepare(); sqlCommand.Prepare();
string expectedHash = sqlCommand.ExecuteScalar().ToString(); string expectedHash = sqlCommand.ExecuteScalar().ToString();
return Converters.StringToByteArray(expectedHash); return Converters.StringToByteArray(expectedHash);
} }
else else
{ {
throw new KeyNotFoundException("Username " + username + " not found in database."); throw new KeyNotFoundException("Username " + username + " not found in database.");
} }
} }
} }
} }

116
Horse Isle Server/Horse Isle Server/Gamedata.cs
View file

@ -1,60 +1,56 @@
using System.Collections.Generic; using System.Collections.Generic;
using System.IO; using System.IO;
using Newtonsoft.Json; using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
namespace Horse_Isle_Server
{ namespace Horse_Isle_Server
{
class Gamedata
{ class Gamedata
public static string TileFlags; {
public static int NewUserStartX; public static void ReadGamedata()
public static int NewUserStartY; {
// Messages if(!File.Exists(ConfigReader.GameDataFile))
public static string NewUserMessage; {
public static string AreaMessage; Logger.ErrorPrint("Game Data JSON File: " + ConfigReader.GameDataFile + " Does not exist!");
public static string NothingMessage; return;
public static string LoginMessage; }
string jsonData = File.ReadAllText(ConfigReader.GameDataFile);
public static void ReadGamedata() dynamic gameData = JsonConvert.DeserializeObject(jsonData);
{
if(!File.Exists(ConfigReader.GameDataFile)) int totalIsles = gameData.isles.Count;
{ for(int i = 0; i < totalIsles; i++)
Logger.ErrorPrint("Game Data JSON File: " + ConfigReader.GameDataFile + " Does not exist!"); {
return;
} World.Isle isle = new World.Isle();
string jsonData = File.ReadAllText(ConfigReader.GameDataFile); isle.StartX = gameData.isles[i].start_x;
dynamic gameData = JsonConvert.DeserializeObject(jsonData); isle.StartY = gameData.isles[i].start_y;
isle.EndX = gameData.isles[i].end_x;
int totalIsles = gameData.isles.Count; isle.EndY = gameData.isles[i].end_y;
for(int i = 0; i < totalIsles; i++) isle.Tileset = gameData.isles[i].tileset;
{ isle.Name = gameData.isles[i].name;
World.Isle isle = new World.Isle(); Logger.DebugPrint("Registered Isle: " + isle.Name + " X " + isle.StartX + "-" + isle.EndX + " Y " + isle.StartY + "-" + isle.EndY + " tileset: " + isle.Tileset);
isle.StartX = gameData.isles[i].start_x; World.Isles.Add(isle);
isle.StartY = gameData.isles[i].start_y; }
isle.EndX = gameData.isles[i].end_x;
isle.EndY = gameData.isles[i].end_y; Messages.NewUserMessage = gameData.new_user.starting_message;
isle.Tileset = gameData.isles[i].tileset; Map.NewUserStartX = gameData.new_user.starting_x;
isle.Name = gameData.isles[i].name; Map.NewUserStartY = gameData.new_user.starting_y;
Logger.DebugPrint("Registered Isle: " + isle.Name + " X " + isle.StartX + "-" + isle.EndX + " Y " + isle.StartY + "-" + isle.EndY + " tileset: " + isle.Tileset); Messages.LoginFormat = gameData.messages.login_format;
World.Isles.Add(isle); Messages.AreaMessage = gameData.messages.area_format;
} Messages.NothingMessage = gameData.messages.nothing_message;
Messages.MotdFormat = gameData.messages.motd_format;
NewUserMessage = gameData.new_user.starting_message;
NewUserStartX = gameData.new_user.starting_x; JArray overlayTileDepth = gameData.tile_paramaters.overlay_tiles.tile_depth;
NewUserStartY = gameData.new_user.starting_y; JArray terrainTilePassibility = gameData.tile_paramaters.terrain_tiles.passibility;
Map.OverlayTileDepth = overlayTileDepth.ToObject<int[]>();
LoginMessage = gameData.messages.login_format; Map.TerrainTilePassibility = terrainTilePassibility.ToObject<bool[]>();
AreaMessage = gameData.messages.area_format; }
NothingMessage = gameData.messages.nothing_message;
}
TileFlags = gameData.map_flags; }
}
}
}

218
Horse Isle Server/Horse Isle Server/Horse Isle Server.csproj
View file

@ -1,110 +1,110 @@
<?xml version="1.0" encoding="utf-8"?> <?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> <Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" /> <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
<PropertyGroup> <PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProjectGuid>{C48CBD82-AB30-494A-8FFA-4DE7069B5827}</ProjectGuid> <ProjectGuid>{C48CBD82-AB30-494A-8FFA-4DE7069B5827}</ProjectGuid>
<OutputType>Exe</OutputType> <OutputType>Exe</OutputType>
<RootNamespace>Horse_Isle_Server</RootNamespace> <RootNamespace>Horse_Isle_Server</RootNamespace>
<AssemblyName>Horse Isle Server</AssemblyName> <AssemblyName>Horse Isle Server</AssemblyName>
<TargetFrameworkVersion>v4.8</TargetFrameworkVersion> <TargetFrameworkVersion>v4.8</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment> <FileAlignment>512</FileAlignment>
<AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects> <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
<Deterministic>true</Deterministic> <Deterministic>true</Deterministic>
<NuGetPackageImportStamp> <NuGetPackageImportStamp>
</NuGetPackageImportStamp> </NuGetPackageImportStamp>
<TargetFrameworkProfile /> <TargetFrameworkProfile />
</PropertyGroup> </PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<PlatformTarget>AnyCPU</PlatformTarget> <PlatformTarget>AnyCPU</PlatformTarget>
<DebugSymbols>true</DebugSymbols> <DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType> <DebugType>full</DebugType>
<Optimize>false</Optimize> <Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath> <OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants> <DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport> <ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel> <WarningLevel>4</WarningLevel>
<Prefer32Bit>false</Prefer32Bit> <Prefer32Bit>false</Prefer32Bit>
</PropertyGroup> </PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<PlatformTarget>AnyCPU</PlatformTarget> <PlatformTarget>AnyCPU</PlatformTarget>
<DebugType>pdbonly</DebugType> <DebugType>pdbonly</DebugType>
<Optimize>true</Optimize> <Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath> <OutputPath>bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants> <DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport> <ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel> <WarningLevel>4</WarningLevel>
<Prefer32Bit>false</Prefer32Bit> <Prefer32Bit>false</Prefer32Bit>
</PropertyGroup> </PropertyGroup>
<ItemGroup> <ItemGroup>
<Reference Include="Microsoft.CSharp" /> <Reference Include="Microsoft.CSharp" />
<Reference Include="MySqlConnector, Version=1.0.0.0, Culture=neutral, PublicKeyToken=d33d3e53aa5f8c92, processorArchitecture=MSIL"> <Reference Include="MySqlConnector, Version=1.0.0.0, Culture=neutral, PublicKeyToken=d33d3e53aa5f8c92, processorArchitecture=MSIL">
<HintPath>..\packages\MySqlConnector.1.0.1\lib\net471\MySqlConnector.dll</HintPath> <HintPath>..\packages\MySqlConnector.1.0.1\lib\net471\MySqlConnector.dll</HintPath>
</Reference> </Reference>
<Reference Include="Newtonsoft.Json, Version=12.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL"> <Reference Include="Newtonsoft.Json, Version=12.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
<HintPath>..\packages\Newtonsoft.Json.12.0.3\lib\net45\Newtonsoft.Json.dll</HintPath> <HintPath>..\packages\Newtonsoft.Json.12.0.3\lib\net45\Newtonsoft.Json.dll</HintPath>
</Reference> </Reference>
<Reference Include="System" /> <Reference Include="System" />
<Reference Include="System.Buffers, Version=4.0.2.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL"> <Reference Include="System.Buffers, Version=4.0.2.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
<HintPath>..\packages\System.Buffers.4.4.0\lib\netstandard2.0\System.Buffers.dll</HintPath> <HintPath>..\packages\System.Buffers.4.4.0\lib\netstandard2.0\System.Buffers.dll</HintPath>
</Reference> </Reference>
<Reference Include="System.Data" /> <Reference Include="System.Data" />
<Reference Include="System.Drawing" /> <Reference Include="System.Drawing" />
<Reference Include="System.Memory, Version=4.0.1.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL"> <Reference Include="System.Memory, Version=4.0.1.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
<HintPath>..\packages\System.Memory.4.5.0\lib\netstandard2.0\System.Memory.dll</HintPath> <HintPath>..\packages\System.Memory.4.5.0\lib\netstandard2.0\System.Memory.dll</HintPath>
</Reference> </Reference>
<Reference Include="System.Net" /> <Reference Include="System.Net" />
<Reference Include="System.Numerics" /> <Reference Include="System.Numerics" />
<Reference Include="System.Numerics.Vectors, Version=4.1.3.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL"> <Reference Include="System.Numerics.Vectors, Version=4.1.3.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
<HintPath>..\packages\System.Numerics.Vectors.4.4.0\lib\net46\System.Numerics.Vectors.dll</HintPath> <HintPath>..\packages\System.Numerics.Vectors.4.4.0\lib\net46\System.Numerics.Vectors.dll</HintPath>
</Reference> </Reference>
<Reference Include="System.Runtime.CompilerServices.Unsafe, Version=4.0.4.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL"> <Reference Include="System.Runtime.CompilerServices.Unsafe, Version=4.0.4.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
<HintPath>..\packages\System.Runtime.CompilerServices.Unsafe.4.5.0\lib\netstandard2.0\System.Runtime.CompilerServices.Unsafe.dll</HintPath> <HintPath>..\packages\System.Runtime.CompilerServices.Unsafe.4.5.0\lib\netstandard2.0\System.Runtime.CompilerServices.Unsafe.dll</HintPath>
</Reference> </Reference>
<Reference Include="System.Threading.Tasks.Extensions, Version=4.1.0.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL"> <Reference Include="System.Threading.Tasks.Extensions, Version=4.1.0.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
<HintPath>..\packages\System.Threading.Tasks.Extensions.4.3.0\lib\portable-net45+win8+wp8+wpa81\System.Threading.Tasks.Extensions.dll</HintPath> <HintPath>..\packages\System.Threading.Tasks.Extensions.4.3.0\lib\portable-net45+win8+wp8+wpa81\System.Threading.Tasks.Extensions.dll</HintPath>
</Reference> </Reference>
<Reference Include="System.Transactions" /> <Reference Include="System.Transactions" />
<Reference Include="System.Xml.Linq" /> <Reference Include="System.Xml.Linq" />
<Reference Include="System.Xml" /> <Reference Include="System.Xml" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<Compile Include="Authentication.cs" /> <Compile Include="Authentication.cs" />
<Compile Include="Client.cs" /> <Compile Include="Client.cs" />
<Compile Include="Converters.cs" /> <Compile Include="Converters.cs" />
<Compile Include="Database.cs" /> <Compile Include="Database.cs" />
<Compile Include="Gamedata.cs" /> <Compile Include="Gamedata.cs" />
<Compile Include="Logger.cs" /> <Compile Include="Logger.cs" />
<Compile Include="ConfigReader.cs" /> <Compile Include="ConfigReader.cs" />
<Compile Include="CrossDomainPolicy.cs" /> <Compile Include="CrossDomainPolicy.cs" />
<Compile Include="Mailbox.cs" /> <Compile Include="Mailbox.cs" />
<Compile Include="Map.cs" /> <Compile Include="Map.cs" />
<Compile Include="Messages.cs" /> <Compile Include="Messages.cs" />
<Compile Include="PacketBuilder.cs" /> <Compile Include="PacketBuilder.cs" />
<Compile Include="Program.cs" /> <Compile Include="Program.cs" />
<Compile Include="Properties\AssemblyInfo.cs" /> <Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="Properties\Resources.Designer.cs"> <Compile Include="Properties\Resources.Designer.cs">
<AutoGen>True</AutoGen> <AutoGen>True</AutoGen>
<DesignTime>True</DesignTime> <DesignTime>True</DesignTime>
<DependentUpon>Resources.resx</DependentUpon> <DependentUpon>Resources.resx</DependentUpon>
</Compile> </Compile>
<Compile Include="Server.cs" /> <Compile Include="Server.cs" />
<Compile Include="User.cs" /> <Compile Include="User.cs" />
<Compile Include="World.cs" /> <Compile Include="World.cs" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<None Include="packages.config" /> <None Include="packages.config" />
<None Include="Resources\server.properties" /> <None Include="Resources\server.properties" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<EmbeddedResource Include="Properties\Resources.resx"> <EmbeddedResource Include="Properties\Resources.resx">
<Generator>ResXFileCodeGenerator</Generator> <Generator>ResXFileCodeGenerator</Generator>
<LastGenOutput>Resources.Designer.cs</LastGenOutput> <LastGenOutput>Resources.Designer.cs</LastGenOutput>
</EmbeddedResource> </EmbeddedResource>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<None Include="Resources\default_cross_domain.xml" /> <None Include="Resources\default_cross_domain.xml" />
</ItemGroup> </ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" /> <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
</Project> </Project>

50
Horse Isle Server/Horse Isle Server/Logger.cs
View file

@ -1,25 +1,25 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace Horse_Isle_Server namespace Horse_Isle_Server
{ {
class Logger class Logger
{ {
public static void DebugPrint(string text) public static void DebugPrint(string text)
{ {
if (ConfigReader.Debug) if (ConfigReader.Debug)
Console.WriteLine("[DEBUG] " + text); Console.WriteLine("[DEBUG] " + text);
} }
public static void WarnPrint(string text) public static void WarnPrint(string text)
{ {
Console.WriteLine("[WARN] " + text); Console.WriteLine("[WARN] " + text);
} }
public static void ErrorPrint(string text) public static void ErrorPrint(string text)
{ {
Console.WriteLine("[ERROR] " + text); Console.WriteLine("[ERROR] " + text);
} }
} }
} }

40
Horse Isle Server/Horse Isle Server/Mailbox.cs
View file

@ -1,20 +1,20 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace Horse_Isle_Server namespace Horse_Isle_Server
{ {
class Mailbox class Mailbox
{ {
private User baseUser; private User baseUser;
public int MailCount; public int MailCount;
public Mailbox(User user) public Mailbox(User user)
{ {
MailCount = Database.CheckMailcount(user.Id); MailCount = Database.CheckMailcount(user.Id);
baseUser = user; baseUser = user;
} }
} }
} }

93
Horse Isle Server/Horse Isle Server/Map.cs
View file

@ -1,42 +1,51 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Drawing; using System.Drawing;
using System.IO; using System.IO;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace Horse_Isle_Server namespace Horse_Isle_Server
{ {
class Map class Map
{ {
public static Bitmap MapData; public static int[] OverlayTileDepth;
public static Bitmap oMapData; public static bool[] TerrainTilePassibility;
public static int GetTileId(int x, int y, bool overlay)
{ public static Bitmap MapData;
if ((x > MapData.Width || x < 0) || (y > MapData.Height || y < 0)) // Outside map?
return 0x01; public static int NewUserStartX;
public static int NewUserStartY;
if (overlay) public static int GetTileId(int x, int y, bool overlay)
return oMapData.GetPixel(x, y).B; {
else if ((x > MapData.Width || x < 0) || (y > MapData.Height || y < 0)) // Outside map?
return MapData.GetPixel(x, y).B; return 0x1;
}
public static bool CheckPassable(int x, int y)
{ if (overlay)
return true; // not implemented yet return MapData.GetPixel(x, y).R;
} else
return MapData.GetPixel(x, y).B;
public static void OpenMap() }
{ public static bool CheckPassable(int x, int y)
if(!File.Exists(ConfigReader.MapFile) || !File.Exists(ConfigReader.OverlayMapFile)) {
{ int tileId = GetTileId(x, y, false);
Logger.ErrorPrint("Map file not found."); bool passable = TerrainTilePassibility[tileId-1];
return; Logger.DebugPrint("Checking tile passibility for tileid: " + tileId + " at " + x + "," + y+" passable: " +passable);
} return passable;
}
MapData = new Bitmap(ConfigReader.MapFile);
oMapData = new Bitmap(ConfigReader.OverlayMapFile); public static void OpenMap()
} {
} if(!File.Exists(ConfigReader.MapFile))
} {
Logger.ErrorPrint("Map file not found.");
return;
}
MapData = new Bitmap(ConfigReader.MapFile);
}
}
}

78
Horse Isle Server/Horse Isle Server/Messages.cs
View file

@ -1,34 +1,44 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace Horse_Isle_Server namespace Horse_Isle_Server
{ {
class Messages class Messages
{ {
public static string NewUserMessage;
public static string LoginMessage(string username) public static string AreaMessage;
{ public static string NothingMessage;
return Gamedata.LoginMessage.Replace("%USERNAME%", username); public static string LoginFormat;
}
public static string MotdFormat;
public static string LocationData(int x, int y)
{ public static string GetMOTD()
string message = ""; {
try return MotdFormat.Replace("%MOTD%", ConfigReader.Motd);
{ }
World.Isle isle = World.GetIsle(x, y); public static string GetLoginMessage(string username)
message = Gamedata.AreaMessage.Replace("%AREA%", isle.Name); {
} return LoginFormat.Replace("%USERNAME%", username);
catch (Exception) { } }
int[] itemIds = World.GetDroppedItems(x, y); public static string LocationData(int x, int y)
if (itemIds.Length == 0) {
message += Gamedata.NothingMessage; string message = "";
try
return message; {
} World.Isle isle = World.GetIsle(x, y);
} message = AreaMessage.Replace("%AREA%", isle.Name);
} }
catch (Exception) { }
int[] itemIds = World.GetDroppedItems(x, y);
if (itemIds.Length == 0)
message += NothingMessage;
return message;
}
}
}

854
Horse Isle Server/Horse Isle Server/PacketBuilder.cs
View file

@ -1,412 +1,442 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.IO; using System.IO;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace Horse_Isle_Server namespace Horse_Isle_Server
{ {
class PacketBuilder class PacketBuilder
{ {
public const byte PACKET_TERMINATOR = 0x00; public const byte PACKET_TERMINATOR = 0x00;
public const byte PACKET_A_TERMINATOR = 0x0A; public const byte PACKET_A_TERMINATOR = 0x0A;
public const byte PACKET_LOGIN = 0x7F; public const byte PACKET_LOGIN = 0x7F;
public const byte PACKET_CHAT = 0x14; public const byte PACKET_CHAT = 0x14;
public const byte PACKET_MOVE = 0x15; public const byte PACKET_MOVE = 0x15;
public const byte PACKET_USERINFO = 0x81; public const byte PACKET_USERINFO = 0x81;
public const byte PACKET_WORLD = 0x7A; public const byte PACKET_WORLD = 0x7A;
public const byte PACKET_BASE_STATS = 0x7B; public const byte PACKET_BASE_STATS = 0x7B;
public const byte PACKET_PLACE_INFO = 0x1E; public const byte PACKET_PLACE_INFO = 0x1E;
public const byte PACKET_AREA_DEFS = 0x79; public const byte PACKET_AREA_DEFS = 0x79;
public const byte PACKET_TILE_FLAGS = 0x75; public const byte PACKET_ANNOUNCEMENT = 0x7E;
public const byte PACKET_TILE_FLAGS = 0x75;
public const byte AREA_SEPERATOR = 0x5E;
public const byte AREA_SEPERATOR = 0x5E;
public const byte MOVE_UP = 0x14;
public const byte MOVE_DOWN = 0x15; public const byte MOVE_UP = 0x14;
public const byte MOVE_RIGHT = 0x16; public const byte MOVE_DOWN = 0x15;
public const byte MOVE_LEFT = 0x17; public const byte MOVE_RIGHT = 0x16;
public const byte MOVE_EXIT = 0x10; public const byte MOVE_LEFT = 0x17;
public const byte MOVE_EXIT = 0x10;
public const byte CHAT_BOTTOM_LEFT = 0x14;
public const byte CHAT_BOTTOM_RIGHT = 0x15; public const byte CHAT_BOTTOM_LEFT = 0x14;
public const byte CHAT_BOTTOM_RIGHT = 0x15;
public const byte LOGIN_INVALID_USER_PASS = 0x15;
public const byte LOGIN_SUCCESS = 0x14; public const byte LOGIN_INVALID_USER_PASS = 0x15;
public const byte LOGIN_SUCCESS = 0x14;
public const byte DIRECTION_UP = 0;
public const byte DIRECTION_RIGHT = 1; public const byte DIRECTION_UP = 0;
public const byte DIRECTION_DOWN = 2; public const byte DIRECTION_RIGHT = 1;
public const byte DIRECTION_LEFT = 3; public const byte DIRECTION_DOWN = 2;
public const byte DIRECTION_LOGIN = 4; public const byte DIRECTION_LEFT = 3;
public const byte DIRECTION_LOGIN = 4;
public const byte DIRECTION_NONE = 10;
public static byte[] CreateLoginPacket(bool Success)
{
MemoryStream ms = new MemoryStream(); public static byte[] CreateLoginPacket(bool Success)
ms.WriteByte(PACKET_LOGIN); {
if (Success) MemoryStream ms = new MemoryStream();
ms.WriteByte(LOGIN_SUCCESS); ms.WriteByte(PACKET_LOGIN);
else if (Success)
ms.WriteByte(LOGIN_INVALID_USER_PASS); ms.WriteByte(LOGIN_SUCCESS);
ms.WriteByte(PACKET_TERMINATOR); else
ms.WriteByte(LOGIN_INVALID_USER_PASS);
ms.Seek(0x00, SeekOrigin.Begin); ms.WriteByte(PACKET_TERMINATOR);
byte[] Packet = ms.ToArray();
ms.Dispose(); ms.Seek(0x00, SeekOrigin.Begin);
byte[] Packet = ms.ToArray();
return Packet; ms.Dispose();
}
return Packet;
public static byte[] CreateMovementPacket(int x, int y,int charId,int facing, int direction, bool walk) }
{
// Header information public static byte[] CreateMovementPacket(int x, int y,int charId,int facing, int direction, bool walk)
MemoryStream ms = new MemoryStream(); {
ms.WriteByte(PACKET_MOVE); // Header information
MemoryStream ms = new MemoryStream();
ms.WriteByte((byte)((x / 64) + 20)); //1 ms.WriteByte(PACKET_MOVE);
ms.WriteByte((byte)((x % 64) + 20)); //2
ms.WriteByte((byte)(((x-4) / 64) + 20)); //1
ms.WriteByte((byte)((y / 64) + 20)); //3 ms.WriteByte((byte)(((x-4) % 64) + 20)); //2
ms.WriteByte((byte)((y % 64) + 20)); //4
ms.WriteByte((byte)(((y-1) / 64) + 20)); //3
ms.WriteByte((byte)(facing + 20)); //5 ms.WriteByte((byte)(((y-1) % 64) + 20)); //4
ms.WriteByte((byte)((charId / 64) + 20)); //6 ms.WriteByte((byte)(facing + 20)); //5
ms.WriteByte((byte)((charId % 64) + 20)); //7
ms.WriteByte((byte)((charId / 64) + 20)); //6
ms.WriteByte((byte)(direction + 20)); //8 ms.WriteByte((byte)((charId % 64) + 20)); //7
ms.WriteByte((byte)(Convert.ToInt32(walk) + 20)); //9 ms.WriteByte((byte)(direction + 20)); //8
// Map Data ms.WriteByte((byte)(Convert.ToInt32(walk) + 20)); //9
if (direction >= 20) // Map Data
{
direction -= 20; if (direction >= 20)
} {
direction -= 20;
int ystart = y - 3; }
int xstart = x - 2;
int ystart = y - 4;
int xstart = x - 6;
if (direction == DIRECTION_UP)
{
for (int relx = 0; relx <= 12; relx++) if (direction == DIRECTION_UP)
{ {
int tileId = Map.GetTileId(xstart + relx, ystart, false); for (int relx = 0; relx <= 12; relx++)
int otileId = Map.GetTileId(xstart + relx, ystart, true); {
int tileId = Map.GetTileId(xstart + relx, ystart, false);
if (tileId == 290) int otileId = Map.GetTileId(xstart + relx, ystart, true);
tileId -= 100;
if (otileId == 290)
otileId -= 100; ms.WriteByte((byte)tileId);
if (tileId == 190)
ms.WriteByte((byte)tileId); ms.WriteByte((byte)0x5B);
ms.WriteByte((byte)otileId); ms.WriteByte((byte)otileId);
} if (otileId == 190)
} ms.WriteByte((byte)0x5A);
}
if (direction == DIRECTION_LEFT) }
{
for (int rely = 0; rely <= 9; rely++) if (direction == DIRECTION_LEFT)
{ {
int tileId = Map.GetTileId(xstart, ystart + rely, false); for (int rely = 0; rely <= 9; rely++)
int otileId = Map.GetTileId(xstart, ystart + rely, true); {
int tileId = Map.GetTileId(xstart, ystart + rely, false);
if (tileId == 290) int otileId = Map.GetTileId(xstart, ystart + rely, true);
tileId -= 100;
if (otileId == 290)
otileId -= 100; ms.WriteByte((byte)tileId);
if (tileId == 190)
ms.WriteByte((byte)tileId); ms.WriteByte((byte)0x5B);
ms.WriteByte((byte)otileId); ms.WriteByte((byte)otileId);
} if (otileId == 190)
} ms.WriteByte((byte)0x5A);
}
}
if (direction == DIRECTION_RIGHT)
{
for (int rely = 0; rely <= 9; rely++) if (direction == DIRECTION_RIGHT)
{ {
int tileId = Map.GetTileId(xstart + 12, ystart + rely, false); for (int rely = 0; rely <= 9; rely++)
int otileId = Map.GetTileId(xstart + 12, ystart + rely, true); {
int tileId = Map.GetTileId(xstart + 12, ystart + rely, false);
if (tileId == 290) int otileId = Map.GetTileId(xstart + 12, ystart + rely, true);
tileId -= 100;
if (otileId == 290)
otileId -= 100; ms.WriteByte((byte)tileId);
if (tileId == 190)
ms.WriteByte((byte)tileId); ms.WriteByte((byte)0x5B);
ms.WriteByte((byte)otileId); ms.WriteByte((byte)otileId);
} if (otileId == 190)
} ms.WriteByte((byte)0x5A);
}
if (direction == DIRECTION_DOWN) }
{
for (int relx = 0; relx <= 12; relx++) if (direction == DIRECTION_DOWN)
{ {
int tileId = Map.GetTileId(xstart + relx, ystart + 9, false); for (int relx = 0; relx <= 12; relx++)
int otileId = Map.GetTileId(xstart + relx, ystart + 9, true); {
int tileId = Map.GetTileId(xstart + relx, ystart + 9, false);
if (tileId == 290) int otileId = Map.GetTileId(xstart + relx, ystart + 9, true);
tileId -= 100;
if (otileId == 290)
otileId -= 100; ms.WriteByte((byte)tileId);
if (tileId == 190)
ms.WriteByte((byte)tileId); ms.WriteByte((byte)0x5B);
ms.WriteByte((byte)otileId); ms.WriteByte((byte)otileId);
} if (otileId == 190)
} ms.WriteByte((byte)0x5A);
if (direction == DIRECTION_LOGIN) }
{ }
for(int rely = 0; rely <= 9; rely++) if (direction == DIRECTION_LOGIN)
{ {
for (int relx = 0; relx <= 12; relx++) for(int rely = 0; rely <= 9; rely++)
{ {
int tileId = Map.GetTileId(xstart + relx, ystart + rely, false); for (int relx = 0; relx <= 12; relx++)
int otileId = Map.GetTileId(xstart + relx, ystart + rely, true); {
int tileId = Map.GetTileId(xstart + relx, ystart + rely, false);
if (tileId == 290) int otileId = Map.GetTileId(xstart + relx, ystart + rely, true);
tileId -= 100;
if(otileId == 290)
otileId -= 100; ms.WriteByte((byte)tileId);
if (tileId == 190)
ms.WriteByte((byte)tileId); ms.WriteByte((byte)0x5B);
ms.WriteByte((byte)otileId);
} ms.WriteByte((byte)otileId);
} if (otileId == 190)
ms.WriteByte((byte)0x5A);
} }
}
ms.WriteByte(PACKET_TERMINATOR); }
ms.Seek(0x00, SeekOrigin.Begin);
byte[] Packet = ms.ToArray();
ms.Dispose(); ms.WriteByte(PACKET_TERMINATOR);
return Packet; ms.Seek(0x00, SeekOrigin.Begin);
} byte[] Packet = ms.ToArray();
ms.Dispose();
public static byte[] CreatePlaceInfo(string formattedText)
{ Logger.DebugPrint(BitConverter.ToString(Packet).Replace('-', ' '));
byte[] strBytes = Encoding.UTF8.GetBytes(formattedText);
return Packet;
MemoryStream ms = new MemoryStream(); }
ms.WriteByte(PACKET_PLACE_INFO); public static byte[] CreatePlaceInfo(string formattedText)
{
ms.Write(strBytes, 0x00, strBytes.Length); byte[] strBytes = Encoding.UTF8.GetBytes(formattedText);
ms.WriteByte(PACKET_TERMINATOR); MemoryStream ms = new MemoryStream();
ms.Seek(0x00, SeekOrigin.Begin); ms.WriteByte(PACKET_PLACE_INFO);
byte[] Packet = ms.ToArray();
ms.Dispose(); ms.Write(strBytes, 0x00, strBytes.Length);
return Packet; ms.WriteByte(PACKET_TERMINATOR);
}
public static byte[] CreateChat(string formattedText, byte chatWindow) ms.Seek(0x00, SeekOrigin.Begin);
{ byte[] Packet = ms.ToArray();
byte[] strBytes = Encoding.UTF8.GetBytes(formattedText); ms.Dispose();
MemoryStream ms = new MemoryStream(); return Packet;
}
ms.WriteByte(PACKET_CHAT); public static byte[] CreateChat(string formattedText, byte chatWindow)
ms.WriteByte(chatWindow); {
byte[] strBytes = Encoding.UTF8.GetBytes(formattedText);
ms.Write(strBytes, 0x00, strBytes.Length);
MemoryStream ms = new MemoryStream();
ms.WriteByte(PACKET_TERMINATOR);
ms.WriteByte(PACKET_CHAT);
ms.Seek(0x00, SeekOrigin.Begin); ms.WriteByte(chatWindow);
byte[] Packet = ms.ToArray();
ms.Dispose(); ms.Write(strBytes, 0x00, strBytes.Length);
return Packet; ms.WriteByte(PACKET_TERMINATOR);
}
ms.Seek(0x00, SeekOrigin.Begin);
public static byte[] CreateAreaMessage(int x, int y) byte[] Packet = ms.ToArray();
{ ms.Dispose();
string locationStr = Messages.LocationData(x, y);
return CreatePlaceInfo(locationStr); return Packet;
} }
public static byte[] CreateLoginMessage(string username)
{ public static byte[] CreateWorldData(int gameTime, int gameDay, int gameYear, string weather)
string formattedStr = Messages.LoginMessage(username); {
return CreateChat(formattedStr,CHAT_BOTTOM_RIGHT); byte[] strBytes = Encoding.UTF8.GetBytes(weather);
}
MemoryStream ms = new MemoryStream();
public static byte[] CreateWorldData(int gameTime, int gameDay, int gameYear, string weather) ms.WriteByte(PACKET_WORLD);
{
byte[] strBytes = Encoding.UTF8.GetBytes(weather); ms.WriteByte((byte)((gameTime / 64) + 20));
ms.WriteByte((byte)((gameTime % 64) + 20));
MemoryStream ms = new MemoryStream();
ms.WriteByte(PACKET_WORLD); ms.WriteByte((byte)((gameDay / 64) + 20));
ms.WriteByte((byte)((gameDay % 64) + 20));
ms.WriteByte((byte)((gameTime / 64) + 20));
ms.WriteByte((byte)((gameTime % 64) + 20)); ms.WriteByte((byte)((gameYear / 64) + 20));
ms.WriteByte((byte)((gameYear % 64) + 20));
ms.WriteByte((byte)((gameDay / 64) + 20));
ms.WriteByte((byte)((gameDay % 64) + 20)); ms.Write(strBytes,0x00, strBytes.Length);
ms.WriteByte(PACKET_TERMINATOR);
ms.WriteByte((byte)((gameYear / 64) + 20));
ms.WriteByte((byte)((gameYear % 64) + 20)); ms.Seek(0x00, SeekOrigin.Begin);
byte[] Packet = ms.ToArray();
ms.Write(strBytes,0x00, strBytes.Length); ms.Dispose();
ms.WriteByte(PACKET_TERMINATOR);
return Packet;
ms.Seek(0x00, SeekOrigin.Begin); }
byte[] Packet = ms.ToArray();
ms.Dispose(); public static byte[] CreateIsleData(World.Isle[] isles)
{
return Packet; MemoryStream ms = new MemoryStream();
} ms.WriteByte(PACKET_AREA_DEFS);
foreach(World.Isle isle in isles)
public static byte[] CreateIsleData(World.Isle[] isles) {
{ byte[] strBytes = Encoding.UTF8.GetBytes(isle.Name);
MemoryStream ms = new MemoryStream();
ms.WriteByte(PACKET_AREA_DEFS); ms.WriteByte(AREA_SEPERATOR);
foreach(World.Isle isle in isles)
{ ms.WriteByte((byte)(((isle.StartX - 4) / 64) + 20));
byte[] strBytes = Encoding.UTF8.GetBytes(isle.Name); ms.WriteByte((byte)(((isle.StartX - 4) % 64) + 20));
ms.WriteByte(AREA_SEPERATOR); ms.WriteByte((byte)(((isle.EndX - 4) / 64) + 20));
ms.WriteByte((byte)(((isle.EndX - 4) % 64) + 20));
ms.WriteByte((byte)((isle.StartX / 64) + 20));
ms.WriteByte((byte)((isle.StartX % 64) + 20)); ms.WriteByte((byte)(((isle.StartY - 1) / 64) + 20));
ms.WriteByte((byte)(((isle.StartY - 1) % 64) + 20));
ms.WriteByte((byte)((isle.EndX / 64) + 20));
ms.WriteByte((byte)((isle.EndX % 64) + 20)); ms.WriteByte((byte)(((isle.EndY - 1) / 64) + 20));
ms.WriteByte((byte)(((isle.EndY - 1) % 64) + 20));
ms.WriteByte((byte)((isle.StartY / 64) + 20));
ms.WriteByte((byte)((isle.StartY % 64) + 20)); ms.WriteByte((byte)isle.Tileset.ToString()[0]);
ms.WriteByte((byte)((isle.EndY / 64) + 20)); ms.Write(strBytes, 0x00, strBytes.Length);
ms.WriteByte((byte)((isle.EndY % 64) + 20)); }
ms.WriteByte(PACKET_TERMINATOR);
ms.WriteByte((byte)isle.Tileset.ToString()[0]);
ms.Seek(0x00, SeekOrigin.Begin);
ms.Write(strBytes, 0x00, strBytes.Length); byte[] Packet = ms.ToArray();
} ms.Dispose();
ms.WriteByte(PACKET_TERMINATOR);
return Packet;
ms.Seek(0x00, SeekOrigin.Begin); }
byte[] Packet = ms.ToArray();
ms.Dispose(); public static byte[] CreateBaseStats(int money, int playerCount, int mail)
{
return Packet; byte[] moneyStrBytes = Encoding.UTF8.GetBytes(money.ToString());
} byte[] playerStrBytes = Encoding.UTF8.GetBytes(playerCount.ToString());
byte[] mailStrBytes = Encoding.UTF8.GetBytes(mail.ToString());
public static byte[] CreateBaseStats(int money, int playerCount, int mail)
{ MemoryStream ms = new MemoryStream();
byte[] moneyStrBytes = Encoding.UTF8.GetBytes(money.ToString()); ms.WriteByte(PACKET_BASE_STATS);
byte[] playerStrBytes = Encoding.UTF8.GetBytes(playerCount.ToString()); ms.Write(moneyStrBytes, 0x00, moneyStrBytes.Length);
byte[] mailStrBytes = Encoding.UTF8.GetBytes(mail.ToString()); ms.WriteByte((byte)'|');
ms.Write(playerStrBytes, 0x00, playerStrBytes.Length);
MemoryStream ms = new MemoryStream(); ms.WriteByte((byte)'|');
ms.WriteByte(PACKET_BASE_STATS); ms.Write(mailStrBytes, 0x00, mailStrBytes.Length);
ms.Write(moneyStrBytes, 0x00, moneyStrBytes.Length); ms.WriteByte((byte)'|');
ms.WriteByte((byte)'|'); ms.WriteByte(PACKET_TERMINATOR);
ms.Write(playerStrBytes, 0x00, playerStrBytes.Length);
ms.WriteByte((byte)'|'); ms.Seek(0x00, SeekOrigin.Begin);
ms.Write(mailStrBytes, 0x00, mailStrBytes.Length); byte[] Packet = ms.ToArray();
ms.WriteByte((byte)'|'); ms.Dispose();
ms.WriteByte(PACKET_TERMINATOR);
return Packet;
ms.Seek(0x00, SeekOrigin.Begin); }
byte[] Packet = ms.ToArray();
ms.Dispose(); public static byte[] CreateTileOverlayFlags(int[] tileDepthFlags)
{
return Packet; MemoryStream ms = new MemoryStream();
} ms.WriteByte(PACKET_TILE_FLAGS);
public static byte[] CreateTileFlags(string tileFlags) foreach(int tileDepthFlag in tileDepthFlags)
{ {
MemoryStream ms = new MemoryStream(); ms.WriteByte((byte)tileDepthFlag.ToString()[0]);
ms.WriteByte(PACKET_TILE_FLAGS); }
byte[] strBytes = Encoding.UTF8.GetBytes(tileFlags); ms.WriteByte(PACKET_TERMINATOR);
ms.Write(strBytes, 0x00, strBytes.Length);
ms.Seek(0x00, SeekOrigin.Begin);
ms.WriteByte(PACKET_TERMINATOR); byte[] Packet = ms.ToArray();
ms.Dispose();
ms.Seek(0x00, SeekOrigin.Begin);
byte[] Packet = ms.ToArray(); return Packet;
ms.Dispose(); }
public static byte[] CreateSecCode(byte[] SecCodeSeed, int SecCodeInc, bool Admin, bool Moderator)
return Packet; {
} MemoryStream ms = new MemoryStream();
public static byte[] CreateSecCode(byte[] SecCodeSeed, int SecCodeInc, bool Admin, bool Moderator) ms.WriteByte(PACKET_USERINFO);
{
MemoryStream ms = new MemoryStream(); ms.WriteByte((byte)(SecCodeSeed[0] + 33));
ms.WriteByte(PACKET_USERINFO); ms.WriteByte((byte)(SecCodeSeed[1] + 33));
ms.WriteByte((byte)(SecCodeSeed[2] + 33));
ms.WriteByte((byte)(SecCodeSeed[0] + 33)); ms.WriteByte((byte)(SecCodeInc + 33));
ms.WriteByte((byte)(SecCodeSeed[1] + 33));
ms.WriteByte((byte)(SecCodeSeed[2] + 33)); char userType = 'N'; // Normal?
ms.WriteByte((byte)(SecCodeInc + 33)); if (Moderator)
userType = 'M';
char userType = 'N'; // Normal? if (Admin)
if (Moderator) userType = 'A';
userType = 'M';
if (Admin) ms.WriteByte((byte)userType);
userType = 'A'; ms.WriteByte(PACKET_TERMINATOR);
ms.WriteByte((byte)userType); ms.Seek(0x00, SeekOrigin.Begin);
ms.WriteByte(PACKET_TERMINATOR); byte[] Packet = ms.ToArray();
ms.Dispose();
ms.Seek(0x00, SeekOrigin.Begin);
byte[] Packet = ms.ToArray(); return Packet;
ms.Dispose(); }
public static byte[] CreateAnnouncement(string announcement)
return Packet; {
} MemoryStream ms = new MemoryStream();
ms.WriteByte(PACKET_ANNOUNCEMENT);
public static byte[] CreateUserInfo(Client client) byte[] strBytes = Encoding.UTF8.GetBytes(announcement);
{ ms.Write(strBytes, 0x00, strBytes.Length);
MemoryStream ms = new MemoryStream(); ms.WriteByte(PACKET_TERMINATOR);
if(!client.LoggedIn)
throw new Exception("Client is not logged in."); ms.Seek(0x00, SeekOrigin.Begin);
User user = client.LoggedinUser; byte[] Packet = ms.ToArray();
ms.Dispose();
byte[] MovementPacket = CreateMovementPacket(user.X, user.Y, user.CharacterId, DIRECTION_DOWN, DIRECTION_LOGIN, false);
ms.Write(MovementPacket, 0x00, MovementPacket.Length); return Packet;
}
byte[] LoginMessage = CreateLoginMessage(user.Username);
ms.Write(LoginMessage, 0x00, LoginMessage.Length); public static byte[] CreateAreaMessage(int x, int y)
{
World.Time time = World.GetGameTime(); string locationStr = Messages.LocationData(x, y);
int timestamp = time.hours * 60; return CreatePlaceInfo(locationStr);
timestamp += time.minutes; }
public static byte[] CreateMotd()
byte[] WorldData = CreateWorldData(timestamp, time.days, time.year, World.GetWeather()); {
ms.Write(WorldData, 0x00, WorldData.Length); string formattedMotd = Messages.GetMOTD();
return CreateAnnouncement(formattedMotd);
byte[] SecCodePacket = CreateSecCode(user.SecCodeSeeds, user.SecCodeInc, user.Administrator, user.Moderator); }
ms.Write(SecCodePacket, 0x00, SecCodePacket.Length); public static byte[] CreateLoginMessage(string username)
{
byte[] BaseStatsPacketData = CreateBaseStats(user.Money, Server.GetNumberOfPlayers(), user.MailBox.MailCount); string formattedStr = Messages.GetLoginMessage(username);
ms.Write(BaseStatsPacketData, 0x00, BaseStatsPacketData.Length); return CreateChat(formattedStr, CHAT_BOTTOM_RIGHT);
}
byte[] AreaMessage = CreateAreaMessage(user.X,user.Y);
ms.Write(AreaMessage, 0x00, AreaMessage.Length); public static byte[] CreateUserInfo(Client client)
{
byte[] IsleData = CreateIsleData(World.Isles.ToArray()); MemoryStream ms = new MemoryStream();
ms.Write(IsleData, 0x00, IsleData.Length); if(!client.LoggedIn)
throw new Exception("Client is not logged in.");
byte[] TileFlags = CreateTileFlags(Gamedata.TileFlags); User user = client.LoggedinUser;
ms.Write(TileFlags, 0x00, TileFlags.Length);
byte[] MovementPacket = CreateMovementPacket(user.X, user.Y, user.CharacterId, DIRECTION_DOWN, DIRECTION_LOGIN, true);
ms.Seek(0x00, SeekOrigin.Begin); ms.Write(MovementPacket, 0x00, MovementPacket.Length);
byte[] Packet = ms.ToArray();
ms.Dispose(); byte[] LoginMessage = CreateLoginMessage(user.Username);
ms.Write(LoginMessage, 0x00, LoginMessage.Length);
return Packet;
} World.Time time = World.GetGameTime();
} int timestamp = time.hours * 60;
} timestamp += time.minutes;
byte[] WorldData = CreateWorldData(timestamp, time.days, time.year, World.GetWeather());
ms.Write(WorldData, 0x00, WorldData.Length);
byte[] SecCodePacket = CreateSecCode(user.SecCodeSeeds, user.SecCodeInc, user.Administrator, user.Moderator);
ms.Write(SecCodePacket, 0x00, SecCodePacket.Length);
byte[] BaseStatsPacketData = CreateBaseStats(user.Money, Server.GetNumberOfPlayers(), user.MailBox.MailCount);
ms.Write(BaseStatsPacketData, 0x00, BaseStatsPacketData.Length);
byte[] AreaMessage = CreateAreaMessage(user.X,user.Y);
ms.Write(AreaMessage, 0x00, AreaMessage.Length);
byte[] IsleData = CreateIsleData(World.Isles.ToArray());
ms.Write(IsleData, 0x00, IsleData.Length);
byte[] TileFlags = CreateTileOverlayFlags(Map.OverlayTileDepth);
ms.Write(TileFlags, 0x00, TileFlags.Length);
byte[] MotdData = CreateMotd();
ms.Write(MotdData, 0x00, MotdData.Length);
ms.Seek(0x00, SeekOrigin.Begin);
byte[] Packet = ms.ToArray();
ms.Dispose();
return Packet;
}
}
}

66
Horse Isle Server/Horse Isle Server/Program.cs
View file

@ -1,21 +1,45 @@
using System; using System;
using System.IO; using System.Drawing;
using System.Reflection; using System.Drawing.Imaging;
using System.IO;
namespace Horse_Isle_Server using System.Reflection;
{
class Program namespace Horse_Isle_Server
{ {
static void Main(string[] args) class Program
{ {
Directory.SetCurrentDirectory(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location)); static void Main(string[] args)
ConfigReader.OpenConfig(); {
CrossDomainPolicy.GetPolicy(); /*
Database.OpenDatabase(); Bitmap mbmp = new Bitmap("MapData.bmp");
Map.OpenMap(); Bitmap bmp = new Bitmap("oMapData.bmp");
Gamedata.ReadGamedata(); Console.WriteLine(bmp.PixelFormat);
Server.StartServer(); Bitmap bbmp = new Bitmap(bmp.Width, bmp.Height, PixelFormat.Format24bppRgb);
for(int x = 0; x < bmp.Width; x++)
} {
} for(int y = 0; y < bmp.Height; y++)
} {
Color col = mbmp.GetPixel(x, y);
Color col2 = bmp.GetPixel(x, y);
bbmp.SetPixel(x,y,Color.FromArgb(col2.B, 0, col.B));
}
}
bbmp.Save("MapData2.bmp", ImageFormat.Bmp);
Console.WriteLine("image checked");
*/
Directory.SetCurrentDirectory(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location));
ConfigReader.OpenConfig();
CrossDomainPolicy.GetPolicy();
Database.OpenDatabase();
Map.OpenMap();
Gamedata.ReadGamedata();
Server.StartServer();
}
}
}

72
Horse Isle Server/Horse Isle Server/Properties/AssemblyInfo.cs
View file

@ -1,36 +1,36 @@
using System.Reflection; using System.Reflection;
using System.Runtime.CompilerServices; using System.Runtime.CompilerServices;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following // General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information // set of attributes. Change these attribute values to modify the information
// associated with an assembly. // associated with an assembly.
[assembly: AssemblyTitle("Horse Isle Server")] [assembly: AssemblyTitle("Horse Isle Server")]
[assembly: AssemblyDescription("")] [assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")] [assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")] [assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Horse Isle Server")] [assembly: AssemblyProduct("Horse Isle Server")]
[assembly: AssemblyCopyright("Copyright © 2020")] [assembly: AssemblyCopyright("Copyright © 2020")]
[assembly: AssemblyTrademark("")] [assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")] [assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible // Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from // to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type. // COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)] [assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM // The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("c48cbd82-ab30-494a-8ffa-4de7069b5827")] [assembly: Guid("c48cbd82-ab30-494a-8ffa-4de7069b5827")]
// Version information for an assembly consists of the following four values: // Version information for an assembly consists of the following four values:
// //
// Major Version // Major Version
// Minor Version // Minor Version
// Build Number // Build Number
// Revision // Revision
// //
// You can specify all the values or you can default the Build and Revision Numbers // You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below: // by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")] // [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")] [assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")] [assembly: AssemblyFileVersion("1.0.0.0")]

208
Horse Isle Server/Horse Isle Server/Properties/Resources.Designer.cs generated
View file

@ -1,104 +1,104 @@
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// <auto-generated> // <auto-generated>
// This code was generated by a tool. // This code was generated by a tool.
// Runtime Version:4.0.30319.42000 // Runtime Version:4.0.30319.42000
// //
// Changes to this file may cause incorrect behavior and will be lost if // Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated. // the code is regenerated.
// </auto-generated> // </auto-generated>
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
namespace Horse_Isle_Server.Properties { namespace Horse_Isle_Server.Properties {
using System; using System;
/// <summary> /// <summary>
/// A strongly-typed resource class, for looking up localized strings, etc. /// A strongly-typed resource class, for looking up localized strings, etc.
/// </summary> /// </summary>
// This class was auto-generated by the StronglyTypedResourceBuilder // This class was auto-generated by the StronglyTypedResourceBuilder
// class via a tool like ResGen or Visual Studio. // class via a tool like ResGen or Visual Studio.
// To add or remove a member, edit your .ResX file then rerun ResGen // To add or remove a member, edit your .ResX file then rerun ResGen
// with the /str option, or rebuild your VS project. // with the /str option, or rebuild your VS project.
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")] [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()] [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
internal class Resources { internal class Resources {
private static global::System.Resources.ResourceManager resourceMan; private static global::System.Resources.ResourceManager resourceMan;
private static global::System.Globalization.CultureInfo resourceCulture; private static global::System.Globalization.CultureInfo resourceCulture;
[global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
internal Resources() { internal Resources() {
} }
/// <summary> /// <summary>
/// Returns the cached ResourceManager instance used by this class. /// Returns the cached ResourceManager instance used by this class.
/// </summary> /// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Resources.ResourceManager ResourceManager { internal static global::System.Resources.ResourceManager ResourceManager {
get { get {
if (object.ReferenceEquals(resourceMan, null)) { if (object.ReferenceEquals(resourceMan, null)) {
global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Horse_Isle_Server.Properties.Resources", typeof(Resources).Assembly); global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Horse_Isle_Server.Properties.Resources", typeof(Resources).Assembly);
resourceMan = temp; resourceMan = temp;
} }
return resourceMan; return resourceMan;
} }
} }
/// <summary> /// <summary>
/// Overrides the current thread's CurrentUICulture property for all /// Overrides the current thread's CurrentUICulture property for all
/// resource lookups using this strongly typed resource class. /// resource lookups using this strongly typed resource class.
/// </summary> /// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Globalization.CultureInfo Culture { internal static global::System.Globalization.CultureInfo Culture {
get { get {
return resourceCulture; return resourceCulture;
} }
set { set {
resourceCulture = value; resourceCulture = value;
} }
} }
/// <summary> /// <summary>
/// Looks up a localized string similar to &lt;cross-domain-policy&gt; /// Looks up a localized string similar to &lt;cross-domain-policy&gt;
/// &lt;allow-access-from domain=&quot;*&quot; to-ports=&quot;1080&quot; secure=&quot;false&quot;/&gt; /// &lt;allow-access-from domain=&quot;*&quot; to-ports=&quot;1080&quot; secure=&quot;false&quot;/&gt;
///&lt;/cross-domain-policy&gt;. ///&lt;/cross-domain-policy&gt;.
/// </summary> /// </summary>
internal static string DefaultCrossDomain { internal static string DefaultCrossDomain {
get { get {
return ResourceManager.GetString("DefaultCrossDomain", resourceCulture); return ResourceManager.GetString("DefaultCrossDomain", resourceCulture);
} }
} }
/// <summary> /// <summary>
/// Looks up a localized string similar to # Horse Isle Server Default Configuration File /// Looks up a localized string similar to # Horse Isle Server Default Configuration File
/// ///
///# Ip address the server will bind to (default: 0.0.0.0 ALL INTERFACES) ///# Ip address the server will bind to (default: 0.0.0.0 ALL INTERFACES)
///ip=0.0.0.0 ///ip=0.0.0.0
///# Port the server will bind to (default: 1080) ///# Port the server will bind to (default: 1080)
///port=1080 ///port=1080
/// ///
///# MariaDB Database ///# MariaDB Database
///db_ip=127.0.0.1 ///db_ip=127.0.0.1
///db_username=root ///db_username=root
///db_password=test123 ///db_password=test123
///db_port=3306 ///db_port=3306
/// ///
///# Map Data ///# Map Data
///map=MapData.bmp ///map=MapData.bmp
///overlaymap=oMapData.bmp ///overlaymap=oMapData.bmp
/// ///
///# Cross-Domain Policy File ///# Cross-Domain Policy File
///crossdomain=&quot;CrossDomainPolicy.xml ///crossdomain=&quot;CrossDomainPolicy.xml
/// ///
///# Should print debug logs ///# Should print debug logs
///debug=false. ///debug=false.
/// </summary> /// </summary>
internal static string DefaultServerProperties { internal static string DefaultServerProperties {
get { get {
return ResourceManager.GetString("DefaultServerProperties", resourceCulture); return ResourceManager.GetString("DefaultServerProperties", resourceCulture);
} }
} }
} }
} }

252
Horse Isle Server/Horse Isle Server/Properties/Resources.resx
View file

@ -1,127 +1,127 @@
<?xml version="1.0" encoding="utf-8"?> <?xml version="1.0" encoding="utf-8"?>
<root> <root>
<!-- <!--
Microsoft ResX Schema Microsoft ResX Schema
Version 2.0 Version 2.0
The primary goals of this format is to allow a simple XML format The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes various data types are done through the TypeConverter classes
associated with the data types. associated with the data types.
Example: Example:
... ado.net/XML headers & schema ... ... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader> <resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader> <resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader> <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader> <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data> <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data> <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64"> <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value> <value>[base64 mime encoded serialized .NET Framework object]</value>
</data> </data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64"> <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value> <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment> <comment>This is a comment</comment>
</data> </data>
There are any number of "resheader" rows that contain simple There are any number of "resheader" rows that contain simple
name/value pairs. name/value pairs.
Each data row contains a name, and value. The row also contains a Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture. text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the Classes that don't support this are serialized and stored with the
mimetype set. mimetype set.
The mimetype is used for serialized objects, and tells the The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly: extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below. read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64 mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding. : and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64 mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding. : and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64 mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter : using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding. : and then encoded with base64 encoding.
--> -->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata"> <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" /> <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true"> <xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType> <xsd:complexType>
<xsd:choice maxOccurs="unbounded"> <xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata"> <xsd:element name="metadata">
<xsd:complexType> <xsd:complexType>
<xsd:sequence> <xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" /> <xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence> </xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" /> <xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" /> <xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" /> <xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" /> <xsd:attribute ref="xml:space" />
</xsd:complexType> </xsd:complexType>
</xsd:element> </xsd:element>
<xsd:element name="assembly"> <xsd:element name="assembly">
<xsd:complexType> <xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" /> <xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" /> <xsd:attribute name="name" type="xsd:string" />
</xsd:complexType> </xsd:complexType>
</xsd:element> </xsd:element>
<xsd:element name="data"> <xsd:element name="data">
<xsd:complexType> <xsd:complexType>
<xsd:sequence> <xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" /> <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" /> <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence> </xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" /> <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" /> <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" /> <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" /> <xsd:attribute ref="xml:space" />
</xsd:complexType> </xsd:complexType>
</xsd:element> </xsd:element>
<xsd:element name="resheader"> <xsd:element name="resheader">
<xsd:complexType> <xsd:complexType>
<xsd:sequence> <xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" /> <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence> </xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" /> <xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType> </xsd:complexType>
</xsd:element> </xsd:element>
</xsd:choice> </xsd:choice>
</xsd:complexType> </xsd:complexType>
</xsd:element> </xsd:element>
</xsd:schema> </xsd:schema>
<resheader name="resmimetype"> <resheader name="resmimetype">
<value>text/microsoft-resx</value> <value>text/microsoft-resx</value>
</resheader> </resheader>
<resheader name="version"> <resheader name="version">
<value>2.0</value> <value>2.0</value>
</resheader> </resheader>
<resheader name="reader"> <resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader> </resheader>
<resheader name="writer"> <resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader> </resheader>
<assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" /> <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
<data name="DefaultCrossDomain" type="System.Resources.ResXFileRef, System.Windows.Forms"> <data name="DefaultCrossDomain" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>..\Resources\default_cross_domain.xml;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252</value> <value>..\Resources\default_cross_domain.xml;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252</value>
</data> </data>
<data name="DefaultServerProperties" type="System.Resources.ResXFileRef, System.Windows.Forms"> <data name="DefaultServerProperties" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>..\Resources\server.properties;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252</value> <value>..\Resources\server.properties;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252</value>
</data> </data>
</root> </root>

4
Horse Isle Server/Horse Isle Server/Resources/default_cross_domain.xml
View file

@ -1,3 +1,3 @@
<cross-domain-policy> <cross-domain-policy>
<allow-access-from domain="*" to-ports="12321" secure="false"/> <allow-access-from domain="*" to-ports="12321" secure="false"/>
</cross-domain-policy> </cross-domain-policy>

55
Horse Isle Server/Horse Isle Server/Resources/server.properties
View file

@ -1,29 +1,28 @@
# Horse Isle Server Default Configuration File # Horse Isle Server Default Configuration File
# Ip address the server will bind to (default: 0.0.0.0 ALL INTERFACES) # Ip address the server will bind to (default: 0.0.0.0 ALL INTERFACES)
ip=0.0.0.0 ip=0.0.0.0
# Port the server will bind to (default: 12321) # Port the server will bind to (default: 12321)
port=12321 port=12321
# MariaDB Database # MariaDB Database
db_ip=127.0.0.1 db_ip=127.0.0.1
db_name=beta db_name=beta
db_username=root db_username=root
db_password=test123 db_password=test123
db_port=3306 db_port=3306
# Map Data # Map Data
map=MapData.bmp map=MapDataCombined.bmp
overlaymap=oMapData.bmp
# Game Data JSON
# Game Data JSON gamedata=gamedata.json
gamedata=gamedata.json
# Cross-Domain Policy File
# Cross-Domain Policy File crossdomain=CrossDomainPolicy.xml
crossdomain=CrossDomainPolicy.xml
# Red Text Stating "Todays Note:"
# Red Text Stating "Todays Note:" motd=April 11, 2020. New breed, Camarillo White Horse. Two new quests.
motd=April 11, 2020. New breed, Camarillo White Horse. Two new quests.
# Should print debug logs
# Should print debug logs
debug=false debug=false

340
Horse Isle Server/Horse Isle Server/Server.cs
View file

@ -1,154 +1,186 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Net; using System.Net;
using System.Net.Sockets; using System.Net.Sockets;
using System.Text; using System.Text;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace Horse_Isle_Server namespace Horse_Isle_Server
{ {
class Server class Server
{ {
public static Socket ServerSocket; public static Socket ServerSocket;
public static List<Client> ConnectedClients = new List<Client>(); public static List<Client> ConnectedClients = new List<Client>();
public static void OnCrossdomainPolicyRequest(Client sender) // When a cross-domain-policy request is received. public static void OnCrossdomainPolicyRequest(Client sender) // When a cross-domain-policy request is received.
{ {
Logger.DebugPrint("Cross-Domain-Policy request received from: " + sender.RemoteIp); Logger.DebugPrint("Cross-Domain-Policy request received from: " + sender.RemoteIp);
byte[] crossDomainPolicyResponse = CrossDomainPolicy.GetPolicy(); // Generate response packet byte[] crossDomainPolicyResponse = CrossDomainPolicy.GetPolicy(); // Generate response packet
sender.SendPacket(crossDomainPolicyResponse); // Send to client. sender.SendPacket(crossDomainPolicyResponse); // Send to client.
} }
public static void OnUserInfoRequest(Client sender, byte[] packet) public static void OnUserInfoRequest(Client sender, byte[] packet)
{ {
if (!sender.LoggedIn) if (!sender.LoggedIn)
{ {
Logger.ErrorPrint(sender.RemoteIp + " Requested user information when not logged in."); Logger.ErrorPrint(sender.RemoteIp + " Requested user information when not logged in.");
return; return;
} }
Logger.DebugPrint(sender.LoggedinUser.Username + " Requesting user information."); Logger.DebugPrint(sender.LoggedinUser.Username + " Requesting user information.");
byte[] userInfoPackets = PacketBuilder.CreateUserInfo(sender); byte[] userInfoPackets = PacketBuilder.CreateUserInfo(sender);
sender.SendPacket(userInfoPackets); sender.SendPacket(userInfoPackets);
} }
public static void OnMovementPacket(Client sender, byte[] packet) public static void OnMovementPacket(Client sender, byte[] packet)
{ {
if (!sender.LoggedIn) if (!sender.LoggedIn)
{ {
Logger.ErrorPrint(sender.RemoteIp + " Sent movement packet when not logged in."); Logger.ErrorPrint(sender.RemoteIp + " Sent movement packet when not logged in.");
return; return;
} }
User loggedInUser = sender.LoggedinUser; User loggedInUser = sender.LoggedinUser;
byte movementDirection = packet[1]; byte movementDirection = packet[1];
switch(movementDirection)
{ if(movementDirection == PacketBuilder.MOVE_UP)
case PacketBuilder.MOVE_UP: {
if(Map.CheckPassable(loggedInUser.X, loggedInUser.Y+1)) if (Map.CheckPassable(loggedInUser.X, loggedInUser.Y - 1))
loggedInUser.Y -= 1; {
byte[] moveUpResponse = PacketBuilder.CreateMovementPacket(loggedInUser.X, loggedInUser.Y, loggedInUser.CharacterId, PacketBuilder.DIRECTION_UP, PacketBuilder.DIRECTION_UP, true); loggedInUser.Y -= 1;
sender.SendPacket(moveUpResponse); byte[] moveUpResponse = PacketBuilder.CreateMovementPacket(loggedInUser.X, loggedInUser.Y, loggedInUser.CharacterId, PacketBuilder.DIRECTION_UP, PacketBuilder.DIRECTION_UP, true);
break; sender.SendPacket(moveUpResponse);
case PacketBuilder.MOVE_LEFT: }
if (Map.CheckPassable(loggedInUser.X - 1, loggedInUser.Y)) else
loggedInUser.X -= 1; {
byte[] moveLeftResponse = PacketBuilder.CreateMovementPacket(loggedInUser.X, loggedInUser.Y, loggedInUser.CharacterId, PacketBuilder.DIRECTION_LEFT, PacketBuilder.DIRECTION_LEFT, true); byte[] moveUpResponse = PacketBuilder.CreateMovementPacket(loggedInUser.X, loggedInUser.Y, loggedInUser.CharacterId, PacketBuilder.DIRECTION_UP, PacketBuilder.DIRECTION_NONE, false);
sender.SendPacket(moveLeftResponse); sender.SendPacket(moveUpResponse);
break; }
case PacketBuilder.MOVE_RIGHT: }
if (Map.CheckPassable(loggedInUser.X +1 , loggedInUser.Y)) else if(movementDirection == PacketBuilder.MOVE_LEFT)
loggedInUser.X += 1; {
byte[] moveRightResponse = PacketBuilder.CreateMovementPacket(loggedInUser.X, loggedInUser.Y, loggedInUser.CharacterId, PacketBuilder.DIRECTION_RIGHT, PacketBuilder.DIRECTION_RIGHT, true); if (Map.CheckPassable(loggedInUser.X - 1, loggedInUser.Y))
sender.SendPacket(moveRightResponse); {
break; loggedInUser.X -= 1;
case PacketBuilder.MOVE_DOWN: byte[] moveLeftResponse = PacketBuilder.CreateMovementPacket(loggedInUser.X, loggedInUser.Y, loggedInUser.CharacterId, PacketBuilder.DIRECTION_LEFT, PacketBuilder.DIRECTION_LEFT, true);
if (Map.CheckPassable(loggedInUser.X, loggedInUser.Y + 1)) sender.SendPacket(moveLeftResponse);
loggedInUser.Y += 1; }
byte[] moveDownResponse = PacketBuilder.CreateMovementPacket(loggedInUser.X, loggedInUser.Y, loggedInUser.CharacterId, PacketBuilder.DIRECTION_DOWN, PacketBuilder.DIRECTION_DOWN, true); else
sender.SendPacket(moveDownResponse); {
break; byte[] moveLeftResponse = PacketBuilder.CreateMovementPacket(loggedInUser.X, loggedInUser.Y, loggedInUser.CharacterId, PacketBuilder.DIRECTION_LEFT, PacketBuilder.DIRECTION_NONE, false);
} sender.SendPacket(moveLeftResponse);
}
byte[] tileData = PacketBuilder.CreateAreaMessage(loggedInUser.X, loggedInUser.Y); }
sender.SendPacket(tileData); else if(movementDirection == PacketBuilder.MOVE_RIGHT)
} {
public static void OnLoginRequest(Client sender, byte[] packet) if (Map.CheckPassable(loggedInUser.X + 1, loggedInUser.Y))
{ {
Logger.DebugPrint("Login request received from: " + sender.RemoteIp); loggedInUser.X += 1;
byte[] moveLeftResponse = PacketBuilder.CreateMovementPacket(loggedInUser.X, loggedInUser.Y, loggedInUser.CharacterId, PacketBuilder.DIRECTION_RIGHT, PacketBuilder.DIRECTION_RIGHT, true);
string loginRequestString = Encoding.UTF8.GetString(packet).Substring(1); sender.SendPacket(moveLeftResponse);
}
if (!loginRequestString.Contains('|') || packet.Length < 3) else
{ {
Logger.ErrorPrint(sender.RemoteIp + " Sent an invalid login request"); byte[] moveLeftResponse = PacketBuilder.CreateMovementPacket(loggedInUser.X, loggedInUser.Y, loggedInUser.CharacterId, PacketBuilder.DIRECTION_RIGHT, PacketBuilder.DIRECTION_NONE, false);
return; sender.SendPacket(moveLeftResponse);
} }
}
if(packet[1] != PacketBuilder.PACKET_A_TERMINATOR) else if(movementDirection == PacketBuilder.MOVE_DOWN)
{ {
string[] loginParts = loginRequestString.Split('|'); if (Map.CheckPassable(loggedInUser.X, loggedInUser.Y + 1))
if (loginParts.Length < 3) {
{ loggedInUser.Y += 1;
Logger.ErrorPrint(sender.RemoteIp + " Sent a login request of invalid length. " + loginRequestString); byte[] moveDownResponse = PacketBuilder.CreateMovementPacket(loggedInUser.X, loggedInUser.Y, loggedInUser.CharacterId, PacketBuilder.DIRECTION_DOWN, PacketBuilder.DIRECTION_DOWN, true);
return; sender.SendPacket(moveDownResponse);
} }
else
int version = int.Parse(loginParts[0]); {
string encryptedUsername = loginParts[1]; byte[] moveDownResponse = PacketBuilder.CreateMovementPacket(loggedInUser.X, loggedInUser.Y, loggedInUser.CharacterId, PacketBuilder.DIRECTION_DOWN, PacketBuilder.DIRECTION_NONE, false);
string encryptedPassword = loginParts[2]; sender.SendPacket(moveDownResponse);
string username = Authentication.DecryptLogin(encryptedUsername); }
string password = Authentication.DecryptLogin(encryptedPassword);
}
if (Authentication.CheckPassword(username, password))
{
// Obtain user information byte[] tileData = PacketBuilder.CreateAreaMessage(loggedInUser.X, loggedInUser.Y);
int userId = Database.GetUserid(username); sender.SendPacket(tileData);
sender.Login(userId); }
public static void OnLoginRequest(Client sender, byte[] packet)
byte[] ResponsePacket = PacketBuilder.CreateLoginPacket(true); {
sender.SendPacket(ResponsePacket); Logger.DebugPrint("Login request received from: " + sender.RemoteIp);
}
else string loginRequestString = Encoding.UTF8.GetString(packet).Substring(1);
{
Logger.WarnPrint(sender.RemoteIp + " Attempted to login to: " + username + " with incorrect password " + password); if (!loginRequestString.Contains('|') || packet.Length < 3)
byte[] ResponsePacket = PacketBuilder.CreateLoginPacket(false); {
sender.SendPacket(ResponsePacket); Logger.ErrorPrint(sender.RemoteIp + " Sent an invalid login request");
} return;
} }
} if(packet[1] != PacketBuilder.PACKET_A_TERMINATOR)
{
public static int GetNumberOfPlayers() string[] loginParts = loginRequestString.Split('|');
{ if (loginParts.Length < 3)
int count = 0; {
foreach(Client client in ConnectedClients) Logger.ErrorPrint(sender.RemoteIp + " Sent a login request of invalid length. " + loginRequestString);
{ return;
if (client.LoggedIn) }
count++;
} int version = int.Parse(loginParts[0]);
return count; string encryptedUsername = loginParts[1];
} string encryptedPassword = loginParts[2];
public static void StartServer() string username = Authentication.DecryptLogin(encryptedUsername);
{ string password = Authentication.DecryptLogin(encryptedPassword);
ServerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPAddress hostIP = IPAddress.Parse(ConfigReader.BindIP); if (Authentication.CheckPassword(username, password))
IPEndPoint ep = new IPEndPoint(hostIP, ConfigReader.Port); {
ServerSocket.Bind(ep); // Obtain user information
Logger.DebugPrint("Binding to ip: " + ConfigReader.BindIP + " On port: " + ConfigReader.Port.ToString()); int userId = Database.GetUserid(username);
ServerSocket.Listen(10000); sender.Login(userId);
while(true) byte[] ResponsePacket = PacketBuilder.CreateLoginPacket(true);
{ sender.SendPacket(ResponsePacket);
Logger.DebugPrint("Waiting for new connections..."); }
else
Socket cientSocket = ServerSocket.Accept(); {
Client client = new Client(cientSocket); Logger.WarnPrint(sender.RemoteIp + " Attempted to login to: " + username + " with incorrect password " + password);
ConnectedClients.Add(client); byte[] ResponsePacket = PacketBuilder.CreateLoginPacket(false);
} sender.SendPacket(ResponsePacket);
} }
} }
}
}
public static int GetNumberOfPlayers()
{
int count = 0;
foreach(Client client in ConnectedClients)
{
if (client.LoggedIn)
count++;
}
return count;
}
public static void StartServer()
{
ServerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPAddress hostIP = IPAddress.Parse(ConfigReader.BindIP);
IPEndPoint ep = new IPEndPoint(hostIP, ConfigReader.Port);
ServerSocket.Bind(ep);
Logger.DebugPrint("Binding to ip: " + ConfigReader.BindIP + " On port: " + ConfigReader.Port.ToString());
ServerSocket.Listen(10000);
while(true)
{
Logger.DebugPrint("Waiting for new connections...");
Socket cientSocket = ServerSocket.Accept();
Client client = new Client(cientSocket);
ConnectedClients.Add(client);
}
}
}
}

326
Horse Isle Server/Horse Isle Server/User.cs
View file

@ -1,163 +1,163 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace Horse_Isle_Server namespace Horse_Isle_Server
{ {
class User class User
{ {
public int Id; public int Id;
public string Username; public string Username;
public bool Administrator; public bool Administrator;
public bool Moderator; public bool Moderator;
public bool NewPlayer = false; public bool NewPlayer = false;
public Mailbox MailBox; public Mailbox MailBox;
public string ProfilePage { public string ProfilePage {
get get
{ {
return profilePage; return profilePage;
} }
set set
{ {
Database.SetPlayerProfile(value, Id); Database.SetPlayerProfile(value, Id);
profilePage = value; profilePage = value;
} }
} }
public int Money public int Money
{ {
get get
{ {
return money; return money;
} }
set set
{ {
Database.SetPlayerBankMoney(value, Id); Database.SetPlayerBankMoney(value, Id);
money = value; money = value;
} }
} }
public int BankMoney public int BankMoney
{ {
get get
{ {
return bankMoney; return bankMoney;
} }
set set
{ {
Database.SetPlayerBankMoney(value, Id); Database.SetPlayerBankMoney(value, Id);
bankMoney = value; bankMoney = value;
} }
} }
public int X public int X
{ {
get get
{ {
return x; return x;
} }
set set
{ {
Database.SetPlayerX(value, Id); Database.SetPlayerX(value, Id);
x = value; x = value;
} }
} }
public int Y public int Y
{ {
get get
{ {
return y; return y;
} }
set set
{ {
Database.SetPlayerY(value, Id); Database.SetPlayerY(value, Id);
y = value; y = value;
} }
} }
public int CharacterId public int CharacterId
{ {
get get
{ {
return charId; return charId;
} }
set set
{ {
Database.SetPlayerCharId(value, Id); Database.SetPlayerCharId(value, Id);
charId = value; charId = value;
} }
} }
private int charId; private int charId;
private string profilePage; private string profilePage;
private int x; private int x;
private int y; private int y;
private int money; private int money;
private int bankMoney; private int bankMoney;
public byte[] SecCodeSeeds = new byte[3]; public byte[] SecCodeSeeds = new byte[3];
public int SecCodeInc = 0; public int SecCodeInc = 0;
public int SecCodeCount = 0; public int SecCodeCount = 0;
public byte[] GenerateSecCode() public byte[] GenerateSecCode()
{ {
var i = 0; var i = 0;
SecCodeCount++; SecCodeCount++;
SecCodeSeeds[SecCodeCount % 3] = (byte)(SecCodeSeeds[SecCodeCount % 3] + SecCodeInc); SecCodeSeeds[SecCodeCount % 3] = (byte)(SecCodeSeeds[SecCodeCount % 3] + SecCodeInc);
SecCodeSeeds[SecCodeCount % 3] = (byte)(SecCodeSeeds[SecCodeCount % 3] % 92); SecCodeSeeds[SecCodeCount % 3] = (byte)(SecCodeSeeds[SecCodeCount % 3] % 92);
i = SecCodeSeeds[0] + SecCodeSeeds[1] * SecCodeSeeds[2] - SecCodeSeeds[1]; i = SecCodeSeeds[0] + SecCodeSeeds[1] * SecCodeSeeds[2] - SecCodeSeeds[1];
i = Math.Abs(i); i = Math.Abs(i);
i = i % 92; i = i % 92;
byte[] SecCode = new byte[4]; byte[] SecCode = new byte[4];
SecCode[0] = (byte)(SecCodeSeeds[0] + 33); SecCode[0] = (byte)(SecCodeSeeds[0] + 33);
SecCode[1] = (byte)(SecCodeSeeds[1] + 33); SecCode[1] = (byte)(SecCodeSeeds[1] + 33);
SecCode[2] = (byte)(SecCodeSeeds[2] + 33); SecCode[2] = (byte)(SecCodeSeeds[2] + 33);
SecCode[3] = (byte)(i + 33); SecCode[3] = (byte)(i + 33);
return SecCode; return SecCode;
} }
public User(int UserId) public User(int UserId)
{ {
if (!Database.CheckUserExist(UserId)) if (!Database.CheckUserExist(UserId))
throw new KeyNotFoundException("User " + UserId + " not found in database!"); throw new KeyNotFoundException("User " + UserId + " not found in database!");
if (!Database.CheckUserExtExists(UserId)) if (!Database.CheckUserExtExists(UserId))
{ {
Database.CreateUserExt(UserId); Database.CreateUserExt(UserId);
NewPlayer = true; NewPlayer = true;
} }
Id = UserId; Id = UserId;
Username = Database.GetUsername(UserId); Username = Database.GetUsername(UserId);
Administrator = Database.CheckUserIsAdmin(Username); Administrator = Database.CheckUserIsAdmin(Username);
Moderator = Database.CheckUserIsModerator(Username); Moderator = Database.CheckUserIsModerator(Username);
x = Database.GetPlayerX(UserId); x = Database.GetPlayerX(UserId);
y = Database.GetPlayerY(UserId); y = Database.GetPlayerY(UserId);
charId = Database.GetPlayerCharId(UserId); charId = Database.GetPlayerCharId(UserId);
money = Database.GetPlayerMoney(UserId); money = Database.GetPlayerMoney(UserId);
bankMoney = Database.GetPlayerBankMoney(UserId); bankMoney = Database.GetPlayerBankMoney(UserId);
profilePage = Database.GetPlayerProfile(UserId); profilePage = Database.GetPlayerProfile(UserId);
MailBox = new Mailbox(this); MailBox = new Mailbox(this);
// Generate SecCodes // Generate SecCodes
Random rng = new Random(); Random rng = new Random();
SecCodeSeeds[0] = (byte)rng.Next(0, 255 - 33); SecCodeSeeds[0] = (byte)rng.Next(0, 255 - 33);
SecCodeSeeds[1] = (byte)rng.Next(0, 255 - 33); SecCodeSeeds[1] = (byte)rng.Next(0, 255 - 33);
SecCodeSeeds[2] = (byte)rng.Next(0, 255 - 33); SecCodeSeeds[2] = (byte)rng.Next(0, 255 - 33);
SecCodeInc = (byte)rng.Next(0, 255 - 33); SecCodeInc = (byte)rng.Next(0, 255 - 33);
} }
} }
} }

158
Horse Isle Server/Horse Isle Server/World.cs
View file

@ -1,79 +1,79 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using System.Threading.Tasks; using System.Threading.Tasks;
namespace Horse_Isle_Server namespace Horse_Isle_Server
{ {
class World class World
{ {
public struct Isle public struct Isle
{ {
public int StartX; public int StartX;
public int EndX; public int EndX;
public int StartY; public int StartY;
public int EndY; public int EndY;
public int Tileset; public int Tileset;
public string Name; public string Name;
} }
public struct Time public struct Time
{ {
public int minutes; public int minutes;
public int hours; public int hours;
public int days; public int days;
public int year; public int year;
} }
public const int MINUTE = 4320; public const int MINUTE = 4320;
public static List<Isle> Isles = new List<Isle>(); public static List<Isle> Isles = new List<Isle>();
public static Time GetGameTime() public static Time GetGameTime()
{ {
int epoch = Database.GetServerCreationTime(); int epoch = Database.GetServerCreationTime();
DateTime serverCreationTime = DateTimeOffset.FromUnixTimeSeconds(epoch).DateTime; DateTime serverCreationTime = DateTimeOffset.FromUnixTimeSeconds(epoch).DateTime;
DateTime currentTime = DateTime.Now; DateTime currentTime = DateTime.Now;
TimeSpan difference = (currentTime.Date - currentTime.Date); TimeSpan difference = (currentTime.Date - currentTime.Date);
int totalMilis = Convert.ToInt32(difference.TotalMilliseconds); int totalMilis = Convert.ToInt32(difference.TotalMilliseconds);
int gameMinutes = totalMilis / MINUTE; int gameMinutes = totalMilis / MINUTE;
int gameHours = (totalMilis / MINUTE * 600); int gameHours = (totalMilis / MINUTE * 600);
int gameDays = (totalMilis / (MINUTE * 60) * 24); int gameDays = (totalMilis / (MINUTE * 60) * 24);
int gameYears = ((totalMilis / (MINUTE * 60) * 24)*365); int gameYears = ((totalMilis / (MINUTE * 60) * 24)*365);
Time time = new Time(); Time time = new Time();
time.days = gameDays; time.days = gameDays;
time.year = gameYears; time.year = gameYears;
time.minutes = gameMinutes; time.minutes = gameMinutes;
time.hours = gameHours; time.hours = gameHours;
return time; return time;
} }
public static Isle GetIsle(int x, int y) public static Isle GetIsle(int x, int y)
{ {
foreach(Isle isle in Isles) foreach(Isle isle in Isles)
{ {
if (isle.StartX <= x && isle.EndX >= x && isle.StartY <= y && isle.EndY >= y) if (isle.StartX <= x && isle.EndX >= x && isle.StartY <= y && isle.EndY >= y)
{ {
return isle; return isle;
} }
} }
throw new KeyNotFoundException("x,y not in an isle!"); throw new KeyNotFoundException("x,y not in an isle!");
} }
public static int[] GetDroppedItems(int x, int y) public static int[] GetDroppedItems(int x, int y)
{ {
return new int[] { }; // Not implemented yet. return new int[] { }; // Not implemented yet.
} }
public static string GetWeather() public static string GetWeather()
{ {
return Database.GetWorldWeather(); return Database.GetWorldWeather();
} }
} }
} }

18
Horse Isle Server/Horse Isle Server/packages.config
View file

@ -1,10 +1,10 @@
<?xml version="1.0" encoding="utf-8"?> <?xml version="1.0" encoding="utf-8"?>
<packages> <packages>
<package id="MySqlConnector" version="1.0.1" targetFramework="net48" /> <package id="MySqlConnector" version="1.0.1" targetFramework="net48" />
<package id="Newtonsoft.Json" version="12.0.3" targetFramework="net48" /> <package id="Newtonsoft.Json" version="12.0.3" targetFramework="net48" />
<package id="System.Buffers" version="4.4.0" targetFramework="net48" /> <package id="System.Buffers" version="4.4.0" targetFramework="net48" />
<package id="System.Memory" version="4.5.0" targetFramework="net48" /> <package id="System.Memory" version="4.5.0" targetFramework="net48" />
<package id="System.Numerics.Vectors" version="4.4.0" targetFramework="net48" /> <package id="System.Numerics.Vectors" version="4.4.0" targetFramework="net48" />
<package id="System.Runtime.CompilerServices.Unsafe" version="4.5.0" targetFramework="net48" /> <package id="System.Runtime.CompilerServices.Unsafe" version="4.5.0" targetFramework="net48" />
<package id="System.Threading.Tasks.Extensions" version="4.3.0" targetFramework="net48" /> <package id="System.Threading.Tasks.Extensions" version="4.3.0" targetFramework="net48" />
</packages> </packages>