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(); } } }