void RelayMovement()
{
PositionPacket posPacket = new PositionPacket(gameObject.transform.position.x, gameObject.transform.position.y, true, Data.CHARACTER_ID);
SubPacket sp = new SubPacket(GamePacketOpCode.PositionPacket, Data.CHARACTER_ID, 0, posPacket.GetBytes(), SubPacketTypes.GamePacket);
connection.Send(BasePacket.CreatePacket(sp, true, false));
}
//split this up into two methods, one for registering and one for logging in
public void SubmitAccount(string findUser, string findPass, MenuLink ml, bool registering)
{
GameObject passwordGameObj = GameObject.Find(findPass);
InputField passwordInput = passwordGameObj.GetComponent <InputField>();
GameObject userGameObj = GameObject.Find(findUser);
InputField usernameInput = userGameObj.GetComponent <InputField>();
string password = passwordInput.text;
string userName = usernameInput.text;
//problem with this line as registering shouldn't go into CharacterMenu
statusBoxHandler.InstantiatePrefab(Menus.CharacterMenu, MenuPrefabs.StatusBox);
try
{
CheckInputs(userName, password);
AccountPacket ap = new AccountPacket();
byte[] data = ap.GetDataBytes(userName, password);
SubPacket subPacket = new SubPacket(registering, (ushort)userName.Length, (ushort)password.Length, 0, 0, data, SubPacketTypes.Account);
BasePacket packetToSend = BasePacket.CreatePacket(subPacket, false, false);
Utils.SetAccountName(userName);
packetProcessor = GameObject.FindGameObjectWithTag("PacketProcessor").GetComponent <PacketProcessor>();
packetProcessor.LoginOrRegister(packetToSend);
}
catch (AccountException e)
{
StatusBoxHandler.statusText = e.Message;
StatusBoxHandler.readyToClose = true;
}
}
private void HandleNearbyActorsQuery(SubPacket subPacket)
{
PositionsInBoundsPacket posInBoundsPacket = new PositionsInBoundsPacket(subPacket.data);
client.Character.SetCharacterCameraBounds(posInBoundsPacket.XMin, posInBoundsPacket.XMax, posInBoundsPacket.YMin, posInBoundsPacket.YMax);
bool foundNearby = false;
List <SubPacket> nearbyCharacters = new List <SubPacket>();
var connectedPlayers = WorldServer.mConnectedPlayerList.Values.ToList();
foreach (var connectedPlayer in connectedPlayers)
{
if ((connectedPlayer.CharacterId != client.Character.CharacterId) && connectedPlayer.XPos > client.Character.BoundsXMin &&
connectedPlayer.XPos < client.Character.BoundsXMax && connectedPlayer.YPos > client.Character.BoundsYMin &&
connectedPlayer.YPos < client.Character.BoundsYMax)
{
foundNearby = true;
PositionPacket packet = new PositionPacket(connectedPlayer.XPos, connectedPlayer.YPos, true, connectedPlayer.CharacterId);
SubPacket sp = new SubPacket(GamePacketOpCode.NearbyActorsQuery, 0, connectedPlayer.CharacterId, packet.GetBytes(), SubPacketTypes.GamePacket);
nearbyCharacters.Add(sp);
}
}
if (foundNearby)
{
client.QueuePacket(BasePacket.CreatePacket(nearbyCharacters, true, false));
client.FlushQueuedSendPackets();
}
}
private void ProcessSelectCharacter(ClientConnection client, SubPacket packet)
{
SelectCharacterPacket selectCharRequest = new SelectCharacterPacket(packet.data);
Program.Log.Info("{0} => Select character id {1}", client.currentUserId == 0 ? client.GetAddress() : "User " + client.currentUserId, selectCharRequest.characterId);
Character chara = Database.GetCharacter(client.currentUserId, selectCharRequest.characterId);
World world = null;
if (chara != null)
{
world = Database.GetServer(chara.serverId);
}
if (world == null)
{
ErrorPacket errorPacket = new ErrorPacket(selectCharRequest.sequence, 0, 0, 13001, "World Does not exist or is inactive.");
SubPacket subpacket = errorPacket.BuildPacket();
BasePacket basePacket = BasePacket.CreatePacket(subpacket, true, false);
BasePacket.EncryptPacket(client.blowfish, basePacket);
client.QueuePacket(basePacket);
return;
}
SelectCharacterConfirmPacket connectCharacter = new SelectCharacterConfirmPacket(selectCharRequest.sequence, selectCharRequest.characterId, client.currentSessionToken, world.address, world.port, selectCharRequest.ticket);
BasePacket outgoingPacket = BasePacket.CreatePacket(connectCharacter.BuildPackets(), true, false);
BasePacket.EncryptPacket(client.blowfish, outgoingPacket);
client.QueuePacket(outgoingPacket);
}
private void QueryForNearybyActors()
{
PositionsInBoundsPacket packet = new PositionsInBoundsPacket(cameraBounds.min.x, cameraBounds.max.x, cameraBounds.min.y, cameraBounds.max.y);
//Debug.Log(cameraBounds.min.x + "," + cameraBounds.min.y + "," + cameraBounds.max.x + "," + cameraBounds.max.y);
SubPacket sp = new SubPacket(GamePacketOpCode.NearbyActorsQuery, Data.CHARACTER_ID, 0, packet.GetBytes(), SubPacketTypes.GamePacket);
connection.Send(BasePacket.CreatePacket(sp, PacketProcessor.isAuthenticated, false));
}
public void QueuePacket(SubPacket subpacket)
{
bool isAuthed = true;
bool isEncrypted = false;
subpacket.SetTargetId(owner.sessionId);
SendPacketQueue.Add(BasePacket.CreatePacket(subpacket, isAuthed, isEncrypted));
}
private void SendWorldList(ClientConnection client, SubPacket packet)
{
List <World> serverList = Database.GetServers();
WorldListPacket worldlistPacket = new WorldListPacket(0, serverList);
List <SubPacket> subPackets = worldlistPacket.BuildPackets();
BasePacket basePacket = BasePacket.CreatePacket(subPackets, true, false);
BasePacket.EncryptPacket(client.blowfish, basePacket);
client.QueuePacket(basePacket);
}
private void SendImportList(ClientConnection client, SubPacket packet)
{
List <String> names = Database.GetReservedNames(client.currentUserId);
ImportListPacket importListPacket = new ImportListPacket(0, names);
List <SubPacket> subPackets = importListPacket.BuildPackets();
BasePacket basePacket = BasePacket.CreatePacket(subPackets, true, false);
BasePacket.EncryptPacket(client.blowfish, basePacket);
client.QueuePacket(basePacket);
}
private void SendRetainerList(ClientConnection client, SubPacket packet)
{
List <Retainer> retainers = Database.GetRetainers(client.currentUserId);
RetainerListPacket retainerListPacket = new RetainerListPacket(0, retainers);
List <SubPacket> subPackets = retainerListPacket.BuildPackets();
BasePacket basePacket = BasePacket.CreatePacket(subPackets, true, false);
BasePacket.EncryptPacket(client.blowfish, basePacket);
client.QueuePacket(basePacket);
}
public void SendDisconnectPacket()
{
if (Data.CHARACTER_ID != 0)
{
DisconnectPacket dcPacket = new DisconnectPacket(Data.CHARACTER_ID);
SubPacket packet = new SubPacket(GamePacketOpCode.Disconnect, Data.CHARACTER_ID, 0, dcPacket.GetBytes(), SubPacketTypes.GamePacket);
var packetToSend = BasePacket.CreatePacket(packet, PacketProcessor.isAuthenticated, false);
packetToSend.header.connectionType = (ushort)BasePacketConnectionTypes.Connect;
socket.Send(packetToSend.GetPacketBytes());
}
}
private void SendDeleteCharacterRequest()
{
CharacterDeletePacket cd = new CharacterDeletePacket(characterID);
SubPacket sp = cd.GetQueryPacket();
BasePacket packetToSend = BasePacket.CreatePacket(sp, PacketProcessor.isAuthenticated, false);
var box = gameObject.GetComponent <StatusBoxHandler>();
box.InstantiateStatusBoxPrefabWithNoMenuLink(MenuPrefabs.StatusBox);
StatusBoxHandler.statusText = "Waiting for response from server..";
PacketProcessor packetProcessor = GameObject.FindGameObjectWithTag("PacketProcessor").GetComponent <PacketProcessor>();
packetProcessor.SendPacket(packetToSend);
StartCoroutine(WaitForServerResponse(box));
}
// Use this for initialization
void OnEnable()
{
serverResponseFinished = false;
characterServerResponse = new List <SubPacket>();
CharacterQueryPacket cq = new CharacterQueryPacket(Utils.GetAccountName());
SubPacket sp = cq.BuildQueryPacket();
BasePacket packetToSend = BasePacket.CreatePacket(sp, PacketProcessor.isAuthenticated, false);
packetProcessor = GameObject.FindGameObjectWithTag("PacketProcessor").GetComponent <PacketProcessor>();
statusBoxHandler.InstantiateStatusBoxPrefabWithNoMenuLink(MenuPrefabs.StatusBox);
StatusBoxHandler.statusText = "Status: Retrieving character list from server";
packetProcessor.SendPacket(packetToSend);
StartCoroutine(WaitForServerResponseThenDisplayCharacters());
}
private void SendCharacterList(ClientConnection client, SubPacket packet)
{
List <Character> characterList = Database.GetCharacters(client.currentUserId);
if (characterList.Count > 8)
{
Program.Log.Error("Warning, got more than 8 characters. List truncated, check DB for issues.");
}
CharacterListPacket characterlistPacket = new CharacterListPacket(0, characterList);
List <SubPacket> subPackets = characterlistPacket.BuildPackets();
BasePacket basePacket = BasePacket.CreatePacket(subPackets, true, false);
BasePacket.EncryptPacket(client.blowfish, basePacket);
client.QueuePacket(basePacket);
}
// Use this for initialization
void OnEnable()
{
serverResponseFinished = false;
characterServerResponse = new List <SubPacket>();
Debug.Log(Utils.GetAccountName());
CharacterQueryPacket cq = new CharacterQueryPacket(Utils.GetAccountName());
SubPacket sp = cq.BuildQueryPacket();
BasePacket packetToSend = BasePacket.CreatePacket(sp, PacketProcessor.isAuthenticated, false);
packetProcessor = GameObject.FindGameObjectWithTag("PacketProcessor").GetComponent <PacketProcessor>();
statusBoxHandler.InstantiateStatusBoxPrefabWithNoMenuLink(MenuPrefabs.StatusBox);
StatusBoxHandler.statusText = "Status: Retrieving character list from server";
packetProcessor.SendPacket(packetToSend);
StartCoroutine(WaitForServerResponseThenDisplayCharacters());
//send character query packet to server
//open status box you cant close until received response from server
//receive what characters are avaiable for this account if any
//draw them on character select boxes
}
private void ProcessSessionAcknowledgement(ClientConnection client, SubPacket packet)
{
packet.DebugPrintSubPacket();
SessionPacket sessionPacket = new SessionPacket(packet.data);
String clientVersion = sessionPacket.version;
Program.Log.Info("Got acknowledgment for secure session.");
Program.Log.Info("CLIENT VERSION: {0}", clientVersion);
uint userId = Database.GetUserIdFromSession(sessionPacket.session);
client.currentUserId = userId;
client.currentSessionToken = sessionPacket.session;;
if (userId == 0)
{
ErrorPacket errorPacket = new ErrorPacket(sessionPacket.sequence, 0, 0, 13001, "Your session has expired, please login again.");
SubPacket subpacket = errorPacket.BuildPacket();
subpacket.SetTargetId(0xe0006868);
BasePacket errorBasePacket = BasePacket.CreatePacket(subpacket, true, false);
BasePacket.EncryptPacket(client.blowfish, errorBasePacket);
client.QueuePacket(errorBasePacket);
Program.Log.Info("Invalid session, kicking...");
return;
}
Program.Log.Info("USER ID: {0}", userId);
List <Account> accountList = new List <Account>();
Account defaultAccount = new Account();
defaultAccount.id = 1;
defaultAccount.name = "FINAL FANTASY XIV";
accountList.Add(defaultAccount);
AccountListPacket listPacket = new AccountListPacket(1, accountList);
BasePacket basePacket = BasePacket.CreatePacket(listPacket.BuildPackets(), true, false);
BasePacket.EncryptPacket(client.blowfish, basePacket);
client.QueuePacket(basePacket);
}
/// <summary>
/// contact login server and ensure that the ipaddress of player is currently connected to it
/// </summary>
/// <param name="socket"></param>
/// <param name="subPacket"></param>
private void ConfirmClientConnectionWithLoginServer(Socket socket, SubPacket subPacket)
{
Console.WriteLine("Confirming client connection with login server");
IPAddress[] ip = Dns.GetHostAddresses(LOGIN_SERVER_IP);
Character character = new Character(BitConverter.ToUInt32(subPacket.data, 0));
client.HasHandshakedWorldServerToClient = true;
character.WorldClientConnection = client;
if (!WorldServer.mConnectedPlayerList.ContainsKey(character.CharacterId))
{
Console.WriteLine("Inserting character into dictionary: " + character.CharacterId);
WorldServer.mConnectedPlayerList.TryAdd(character.CharacterId, character);
}
else
{
Console.WriteLine("WARNING! : Connected player already exists and trying to add them into list");
}
IPEndPoint remoteEP = new IPEndPoint(ip[0], LOGIN_SERVER_PORT);
socket.Connect(remoteEP);
HandshakePacket packet = new HandshakePacket(client.GetIp(), client.GetPort(), character.CharacterId);
Console.WriteLine("PORT FROM CLIENT:" + client.GetPort());
Console.WriteLine("IP FROM CLIENT:" + client.GetIp());
Console.WriteLine("CHARACTER ID FROM CLIENT: " + character.CharacterId);
SubPacket sp = new SubPacket(GamePacketOpCode.Handshake, 0, 0, packet.GetBytes(), SubPacketTypes.GamePacket);
BasePacket packetToSend = BasePacket.CreatePacket(sp, true, false);
//send packet to login server for confirmation
WorldClientConnection connectionToLoginServer = new WorldClientConnection();
connectionToLoginServer.socket = socket;
connectionToLoginServer.QueuePacket(packetToSend);
connectionToLoginServer.FlushQueuedSendPackets();
connectionToLoginServer.Disconnect();
}
public void FlushQueuedSendPackets(BasePacketConnectionTypes header = BasePacketConnectionTypes.Zone)
{
if (!socket.Connected)
{
return;
}
while (sendPacketQueue.Count > 0)
{
BasePacket packet = BasePacket.CreatePacket(sendPacketQueue, PacketProcessor.isAuthenticated, false);
packet.header.connectionType = (ushort)header;
try
{
socket.Send(packet.GetPacketBytes());
sendPacketQueue.Clear();
}
catch (Exception e)
{
Console.WriteLine("Weird case, socket was d/ced: {0}", e);
}
}
}
// Update is called once per frame
void Update()
{
if (clientActivatedEnterWorld) //if is entering
{
worldServerConnection.EstablishConnection("127.0.0.1", 3435);
// EnterWorldPacket packet = new EnterWorldPacket()
int characterId = Utils.GetCharacter(CharacterSelect.selectedSlot).CharId;
var characterIdBytes = BitConverter.GetBytes(characterId);
if (!BitConverter.IsLittleEndian)
{
Array.Reverse(characterIdBytes);
}
SubPacket packetToSend = new SubPacket(GamePacketOpCode.Handshake, 0, 0, characterIdBytes, SubPacketTypes.GamePacket);
BasePacket test = BasePacket.CreatePacket(packetToSend, PacketProcessor.isAuthenticated, false);
test.header.connectionType = (ushort)BasePacketConnectionTypes.Generic;
worldServerConnection.Send(test);
genericBoxHandler.InstantiateMessageOnlyStatusBox();
var boxText = genericBoxHandler.GetPrefab().GetComponentInChildren <Text>();
boxText.text = "Handshaking with server..";
StartCoroutine(WaitForServerResponse());
clientActivatedEnterWorld = false;
}
}
private void SendCharacterCreateInfo(GameObject[] statNumbers, GameObject nameField, ushort statsAllowed)
{
ushort[] stats = new ushort[statNumbers.Length];
for (int i = 0; i < statNumbers.Length; i++)
{
ushort stat = ushort.Parse(statNumbers[i].GetComponent <Text>().text);
stats[i] = stat;
}
// bytesToSend = o920i
CharacterCreatePacket cp = new CharacterCreatePacket(nameField.GetComponent <InputField>().text, stats, statsAllowed, CharacterSelect.selectedSlot);
var bytesToSend = cp.GetData();
SubPacket sp = new SubPacket(GamePacketOpCode.CreateCharacter, 0, 0, bytesToSend, SubPacketTypes.GamePacket);
BasePacket characterCreationPacket = BasePacket.CreatePacket(sp, PacketProcessor.isAuthenticated, false);
var box = gameObject.GetComponent <StatusBoxHandler>();
// StatusBoxHandler.readyToClose = false;
//modal status box is prefab
box.InstantiateStatusBoxPrefabWithNoMenuLink(MenuPrefabs.StatusBox);
StatusBoxHandler.statusText = "Waiting for response from server..";
packetProcessor = GameObject.FindGameObjectWithTag("PacketProcessor").GetComponent <PacketProcessor>();
packetProcessor.SendPacket(characterCreationPacket);
StartCoroutine(WaitForServerResponse(box));
}
private void ProcessConnectPackets(List <SubPacket> subPackets)
{
foreach (SubPacket subPacket in subPackets)
{
subPacket.debugPrintSubPacket();
switch (subPacket.gameMessage.opcode)
{
case ((ushort)GamePacketOpCode.Handshake):
try
{
Console.WriteLine("100% CORRECT CLIENT CONNECTION: " + client.GetFullAddress());
ConfirmClientConnectionWithLoginServer(new Socket(AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp), subPacket);
}
catch (Exception e)
{
Console.WriteLine(e);
}
break;
case (((ushort)GamePacketOpCode.Acknowledgement)):
AcknowledgePacket ack = new AcknowledgePacket(subPacket.data);
if (ack.AckSuccessful)
{
if (WorldServer.mConnectedPlayerList.TryGetValue(ack.CharacterId, out Character character))
{
client.Disconnect(); //this is 100% login server connection, don't doubt this
client = character.WorldClientConnection;
client.Character = character;
CharacterPositionsWrapper posDbWrapper = WorldDatabase.GetCharacterPosition(client.Character.CharacterId);
client.Character.XPos = posDbWrapper.XPos;
client.Character.YPos = posDbWrapper.YPos;
client.Character.Zone = posDbWrapper.Zone;
Console.WriteLine("Client looks legit: " + (ack.ClientAddress == client.GetIp()));
WorldDatabase.AddToOnlinePlayerList(character.CharacterId, ack.ClientAddress);
client.SessionId = WorldDatabase.GetSessionId(character.CharacterId);
Console.WriteLine("Sending ack received from login server back to: " + client.GetFullAddress());
AcknowledgePacket responseAck = new AcknowledgePacket(ack.AckSuccessful, client.SessionId);
SubPacket sp = new SubPacket(GamePacketOpCode.Acknowledgement, 0, 0, responseAck.GetResponseFromWorldServerBytes(), SubPacketTypes.GamePacket);
client.QueuePacket(BasePacket.CreatePacket(sp, true, false));
client.FlushQueuedSendPackets();
break;
}
else
{
Console.WriteLine("Client has connected but is not in Connected Player List.. Not sure what to do here");
}
}
else
{
Console.WriteLine("Ack not successful, removing from connected player list");
WorldServer.mConnectedPlayerList.TryRemove(ack.CharacterId, out Character unsuccessfulAckCharacter);
client.Disconnect();
}
break;
case (((ushort)GamePacketOpCode.Disconnect)):
DisconnectPacket dc = new DisconnectPacket(subPacket.data);
Console.WriteLine("Got DC packet");
WorldDatabase.RemoveFromOnlinePlayerList(dc.CharacterId);
WorldServer.mConnectedPlayerList.TryRemove(dc.CharacterId, out Character characterToDc);
client.Disconnect();
break;
//if everything okay
default:
break;
}
}
}
public void QueuePacket(SubPacket subpacket, bool isAuthed, bool isEncrypted)
{
SendPacketQueue.Add(BasePacket.CreatePacket(subpacket, isAuthed, isEncrypted));
}
/// <summary>
/// Receive Callback. Reads in incoming data, converting them to base packets. Base packets are sent to be parsed. If not enough data at the end to build a basepacket, move to the beginning and prepend.
/// </summary>
/// <param name="result"></param>
private void ReceiveCallback(IAsyncResult result)
{
ClientConnection conn = (ClientConnection)result.AsyncState;
//Check if disconnected
if ((conn.socket.Poll(1, SelectMode.SelectRead) && conn.socket.Available == 0))
{
lock (mConnectionList)
{
mConnectionList.Remove(conn);
}
return;
}
try
{
int bytesRead = conn.socket.EndReceive(result);
bytesRead += conn.lastPartialSize;
if (bytesRead >= 0)
{
int offset = 0;
//Build packets until can no longer or out of data
while (true)
{
BasePacket basePacket = BasePacket.CreatePacket(ref offset, conn.buffer, bytesRead);
//If can't build packet, break, else process another
if (basePacket == null)
{
break;
}
else
{
mPacketProcessor.ProcessPacket(conn, basePacket);
}
}
//Not all bytes consumed, transfer leftover to beginning
if (offset < bytesRead)
{
Array.Copy(conn.buffer, offset, conn.buffer, 0, bytesRead - offset);
}
conn.lastPartialSize = bytesRead - offset;
//Build any queued subpackets into basepackets and send
conn.FlushQueuedSendPackets();
if (offset < bytesRead)
{
//Need offset since not all bytes consumed
conn.socket.BeginReceive(conn.buffer, bytesRead - offset, conn.buffer.Length - (bytesRead - offset), SocketFlags.None, new AsyncCallback(ReceiveCallback), conn);
}
else
{
//All bytes consumed, full buffer available
conn.socket.BeginReceive(conn.buffer, 0, conn.buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallback), conn);
}
}
else
{
lock (mConnectionList)
{
mConnectionList.Remove(conn);
}
}
}
catch (SocketException)
{
if (conn.socket != null)
{
lock (mConnectionList)
{
mConnectionList.Remove(conn);
}
}
}
}
public static void ThrowDebugErrorToServer(Connection connection)
{
SubPacket sp = new SubPacket(GamePacketOpCode.DebugThrow, 0, 0, new byte[0], SubPacketTypes.ErrorPacket);
connection.Send(BasePacket.CreatePacket(sp, true, false));
}
void UpdateActorPosition()
{
SubPacket sp = new SubPacket(GamePacketOpCode.PositionQuery, Data.CHARACTER_ID, character.Id, new byte[0], SubPacketTypes.GamePacket);
connection.Send(BasePacket.CreatePacket(sp, PacketProcessor.isAuthenticated, false));
}
private void ProcessGenericPackets(List <SubPacket> subPackets)
{
foreach (SubPacket subPacket in subPackets)
{
subPacket.debugPrintSubPacket();
Console.WriteLine(subPacket.gameMessage.opcode);
switch (subPacket.gameMessage.opcode)
{
//contact login server and ensure that ipaddress of player is currently connected to
case ((ushort)GamePacketOpCode.Handshake):
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
try
{
IPAddress[] ip = Dns.GetHostAddresses(LOGIN_SERVER_IP);
int characterId = BitConverter.ToInt32(subPacket.data, 0);
client.CharacterId = characterId;
client.WorldServerToClient = true;
IPEndPoint remoteEP = new IPEndPoint(ip[0], LOGIN_SERVER_PORT);
socket.Connect(remoteEP);
HandshakePacket packet = new HandshakePacket(client.GetIp(), client.GetPort(), characterId);
//Console.WriteLine("PORT FROM CLIENT:" + client.GetPort());
//Console.WriteLine("IP FROM CLIENT:" + client.GetIp());
//Console.WriteLine("CHARACTER ID FROM CLIENT: " + client.CharacterId);
SubPacket sp = new SubPacket(GamePacketOpCode.Handshake, 0, 0, packet.GetBytes(), SubPacketTypes.GamePacket);
BasePacket packetToSend = BasePacket.CreatePacket(sp, true, false);
WorldClientConnection loginServer = new WorldClientConnection();
loginServer.socket = socket;
loginServer.QueuePacket(packetToSend);
loginServer.FlushQueuedSendPackets();
}
catch (Exception e)
{
Console.WriteLine(e);
}
break;
case (((ushort)GamePacketOpCode.Acknowledgement)):
AcknowledgePacket ack = new AcknowledgePacket(subPacket.data);
if (ack.AckSuccessful)
{
foreach (var mClient in WorldServer.GetClientConnections()) //check this if any performance issues
{
Console.WriteLine(ack.CharacterId);
if (mClient.CharacterId == ack.CharacterId && mClient.WorldServerToClient) //this is getting the wrong client
{ //maybe set a boolean in clientconnection that tells whether or not client is created from a server to server communication
ConnectedPlayer connectedPlayer = new ConnectedPlayer(ack.CharacterId);
connectedPlayer.ClientAddress = ack.ClientAddress;
WorldServer.mConnectedPlayerList.Add(connectedPlayer.actorId, connectedPlayer);
client = mClient;
SubPacket sp = new SubPacket(GamePacketOpCode.Acknowledgement, 0, 0, subPacket.data, SubPacketTypes.GamePacket);
client.QueuePacket(BasePacket.CreatePacket(sp, true, false));
client.FlushQueuedSendPackets();
Console.WriteLine("Sending ack back to: " + client.GetFullAddress());
break;
}
}
}
break;
//if everything okay
default:
break;
}
}
}
private void ProcessModifyCharacter(ClientConnection client, SubPacket packet)
{
CharacterModifyPacket charaReq = new CharacterModifyPacket(packet.data);
var slot = charaReq.slot;
var name = charaReq.characterName;
var worldId = charaReq.worldId;
uint pid = 0, cid = 0;
//Get world from new char instance
if (worldId == 0)
{
worldId = client.newCharaWorldId;
}
//Check if this character exists, Get world from there
if (worldId == 0 && charaReq.characterId != 0)
{
Character chara = Database.GetCharacter(client.currentUserId, charaReq.characterId);
if (chara != null)
{
worldId = chara.serverId;
}
}
string worldName = null;
World world = Database.GetServer(worldId);
if (world != null)
{
worldName = world.name;
}
if (worldName == null)
{
ErrorPacket errorPacket = new ErrorPacket(charaReq.sequence, 0, 0, 13001, "World Does not exist or is inactive.");
SubPacket subpacket = errorPacket.BuildPacket();
BasePacket basePacket = BasePacket.CreatePacket(subpacket, true, false);
BasePacket.EncryptPacket(client.blowfish, basePacket);
client.QueuePacket(basePacket);
Program.Log.Info("User {0} => Error; invalid server id: \"{1}\"", client.currentUserId, worldId);
return;
}
bool alreadyTaken;
switch (charaReq.command)
{
case 0x01: //Reserve
alreadyTaken = Database.ReserveCharacter(client.currentUserId, slot, worldId, name, out pid, out cid);
if (alreadyTaken)
{
ErrorPacket errorPacket = new ErrorPacket(charaReq.sequence, 1003, 0, 13005, ""); //BDB - Chara Name Used, //1003 - Bad Word
SubPacket subpacket = errorPacket.BuildPacket();
BasePacket basePacket = BasePacket.CreatePacket(subpacket, true, false);
BasePacket.EncryptPacket(client.blowfish, basePacket);
client.QueuePacket(basePacket);
Program.Log.Info("User {0} => Error; name taken: \"{1}\"", client.currentUserId, charaReq.characterName);
return;
}
else
{
pid = 0;
client.newCharaCid = cid;
client.newCharaSlot = slot;
client.newCharaWorldId = worldId;
client.newCharaName = name;
}
Program.Log.Info("User {0} => Character reserved \"{1}\"", client.currentUserId, name);
break;
case 0x02: //Make
CharaInfo info = CharaInfo.GetFromNewCharRequest(charaReq.characterInfoEncoded);
//Set Initial Appearance (items will be loaded in by map server)
uint[] classAppearance = CharacterCreatorUtils.GetEquipmentForClass(info.currentClass);
info.weapon1 = classAppearance[0];
info.weapon2 = classAppearance[1];
info.head = classAppearance[7];
if (classAppearance[8] != 0)
{
info.body = classAppearance[8];
}
else
{
info.body = CharacterCreatorUtils.GetUndershirtForTribe(info.tribe);
}
info.legs = classAppearance[9];
info.hands = classAppearance[10];
info.feet = classAppearance[11];
info.belt = classAppearance[12];
//Set Initial Position
switch (info.initialTown)
{
case 1: //ocn0Battle02 (Limsa)
info.zoneId = 193;
info.x = 0.016f;
info.y = 10.35f;
info.z = -36.91f;
info.rot = 0.025f;
break;
case 2: //fst0Battle03 (Gridania)
info.zoneId = 166;
info.x = 369.5434f;
info.y = 4.21f;
info.z = -706.1074f;
info.rot = -1.26721f;
break;
case 3: //wil0Battle01 (Ul'dah)
info.zoneId = 184;
info.x = 5.364327f;
info.y = 196.0f;
info.z = 133.6561f;
info.rot = -2.849384f;
break;
}
Database.MakeCharacter(client.currentUserId, client.newCharaCid, info);
pid = 1;
cid = client.newCharaCid;
name = client.newCharaName;
Program.Log.Info("User {0} => Character Created \"{1}\"", client.currentUserId, name);
break;
case 0x03: //Rename
alreadyTaken = Database.RenameCharacter(client.currentUserId, charaReq.characterId, worldId, charaReq.characterName);
if (alreadyTaken)
{
ErrorPacket errorPacket = new ErrorPacket(charaReq.sequence, 1003, 0, 13005, ""); //BDB - Chara Name Used, //1003 - Bad Word
SubPacket subpacket = errorPacket.BuildPacket();
BasePacket basePacket = BasePacket.CreatePacket(subpacket, true, false);
BasePacket.EncryptPacket(client.blowfish, basePacket);
client.QueuePacket(basePacket);
Program.Log.Info("User {0} => Error; name taken: \"{1}\"", client.currentUserId, charaReq.characterName);
return;
}
Program.Log.Info("User {0} => Character renamed \"{1}\"", client.currentUserId, name);
break;
case 0x04: //Delete
Database.DeleteCharacter(charaReq.characterId, charaReq.characterName);
Program.Log.Info("User {0} => Character deleted \"{1}\"", client.currentUserId, name);
break;
case 0x06: //Rename Retainer
Program.Log.Info("User {0} => Retainer renamed \"{1}\"", client.currentUserId, name);
break;
}
CharaCreatorPacket charaCreator = new CharaCreatorPacket(charaReq.sequence, charaReq.command, pid, cid, 1, name, worldName);
BasePacket charaCreatorPacket = BasePacket.CreatePacket(charaCreator.BuildPacket(), true, false);
BasePacket.EncryptPacket(client.blowfish, charaCreatorPacket);
client.QueuePacket(charaCreatorPacket);
}
public void ProcessPacket(ClientConnection client, BasePacket packet)
{
if (packet.header.isCompressed == 0x01)
{
BasePacket.DecompressPacket(ref packet);
}
List <SubPacket> subPackets = packet.GetSubpackets();
foreach (SubPacket subpacket in subPackets)
{
//Initial Connect Packet, Create session
if (subpacket.header.type == 0x01)
{
HelloPacket hello = new HelloPacket(packet.data);
if (packet.header.connectionType == BasePacket.TYPE_ZONE)
{
mServer.AddSession(client, Session.Channel.ZONE, hello.sessionId);
Session session = mServer.GetSession(hello.sessionId);
session.routing1 = mServer.GetWorldManager().GetZoneServer(session.currentZoneId);
session.routing1.SendSessionStart(session, true);
}
else if (packet.header.connectionType == BasePacket.TYPE_CHAT)
{
mServer.AddSession(client, Session.Channel.CHAT, hello.sessionId);
}
client.QueuePacket(_0x7Packet.BuildPacket(0x0E016EE5));
client.QueuePacket(_0x2Packet.BuildPacket(hello.sessionId));
}
//Ping from World Server
else if (subpacket.header.type == 0x07)
{
SubPacket init = _0x8PingPacket.BuildPacket(client.owner.sessionId);
client.QueuePacket(BasePacket.CreatePacket(init, true, false));
}
//Zoning Related
else if (subpacket.header.type == 0x08)
{
//Response, client's current [actorID][time]
//BasePacket init = Login0x7ResponsePacket.BuildPacket(BitConverter.ToUInt32(packet.data, 0x10), Utils.UnixTimeStampUTC(), 0x07);
//client.QueuePacket(init);
packet.DebugPrintPacket();
}
//Game Message
else if (subpacket.header.type == 0x03)
{
//Send to the correct zone server
uint targetSession = subpacket.header.targetId;
InterceptProcess(mServer.GetSession(targetSession), subpacket);
if (mServer.GetSession(targetSession).routing1 != null)
{
mServer.GetSession(targetSession).routing1.SendPacket(subpacket);
}
if (mServer.GetSession(targetSession).routing2 != null)
{
mServer.GetSession(targetSession).routing2.SendPacket(subpacket);
}
}
//World Server Type
else if (subpacket.header.type >= 0x1000)
{
uint targetSession = subpacket.header.targetId;
Session session = mServer.GetSession(targetSession);
switch (subpacket.header.type)
{
//Session Begin Confirm
case 0x1000:
SessionBeginConfirmPacket beginConfirmPacket = new SessionBeginConfirmPacket(packet.data);
if (beginConfirmPacket.invalidPacket || beginConfirmPacket.errorCode == 0)
{
Program.Log.Error("Session {0} had a error beginning session.", beginConfirmPacket.sessionId);
}
break;
//Session End Confirm
case 0x1001:
SessionEndConfirmPacket endConfirmPacket = new SessionEndConfirmPacket(packet.data);
if (!endConfirmPacket.invalidPacket && endConfirmPacket.errorCode != 0)
{
//Check destination, if != 0, update route and start new session
if (endConfirmPacket.destinationZone != 0)
{
session.currentZoneId = endConfirmPacket.destinationZone;
session.routing1 = Server.GetServer().GetWorldManager().GetZoneServer(endConfirmPacket.destinationZone);
session.routing1.SendSessionStart(session);
}
else
{
mServer.RemoveSession(Session.Channel.ZONE, endConfirmPacket.sessionId);
mServer.RemoveSession(Session.Channel.CHAT, endConfirmPacket.sessionId);
}
}
else
{
Program.Log.Error("Session {0} had an error ending session.", endConfirmPacket.sessionId);
}
break;
//Zone Change Request
case 0x1002:
WorldRequestZoneChangePacket zoneChangePacket = new WorldRequestZoneChangePacket(packet.data);
if (!zoneChangePacket.invalidPacket)
{
mServer.GetWorldManager().DoZoneServerChange(session, zoneChangePacket.destinationZoneId, "", zoneChangePacket.destinationSpawnType, zoneChangePacket.destinationX, zoneChangePacket.destinationY, zoneChangePacket.destinationZ, zoneChangePacket.destinationRot);
}
break;
}
}
else
{
packet.DebugPrintPacket();
}
}
}
