public bool OnCreatingResponse(PacketSession session, Packet requestPacket, Packet responsePacket)
{
var idTypes = session.Server.IdTypes;
if (ValidateRequest(requestPacket))
{
var idType = idTypes.FirstOrDefault(x => x.Code == requestPacket.Words[1]);
var idValue = requestPacket.Words[2];
var banListItem = session.Server.BanList.FirstOrDefault(x => x.IdType.Code == idType.Code && x.IdValue == idValue);
if (banListItem != null)
{
session.Server.BanList.Remove(banListItem);
responsePacket.Words.Add(RConDevServer.Protocol.Dice.Battlefield3.Constants.RESPONSE_SUCCESS);
}
else
{
responsePacket.Words.Add(RConDevServer.Protocol.Dice.Battlefield3.Constants.RESPONSE_NOT_FOUND);
}
}
else
{
responsePacket.Words.Add(RConDevServer.Protocol.Dice.Battlefield3.Constants.RESPONSE_INVALID_ARGUMENTS);
}
return true;
}
public bool OnCreatingResponse(PacketSession session, Packet requestPacket, Packet responsePacket)
{
if (requestPacket.WordCount != 2)
{
responsePacket.Words.Add(Constants.RESPONSE_INVALID_ARGUMENTS);
return true;
}
var playerName = requestPacket.Words[1];
if (playerName.Contains(" "))
{
responsePacket.Words.Add(Constants.RESPONSE_INVALID_NAME);
return true;
}
if (session.Server.ReservedSlots.Any(x => x.PlayerName == playerName))
{
responsePacket.Words.Add(Constants.RESPONSE_PLAYER_ALREADY_IN_LIST);
return true;
}
session.Server.ReservedSlots.Add(playerName);
responsePacket.Words.Add(Constants.RESPONSE_SUCCESS);
return true;
}
public override bool OnCreatingResponse(PacketSession session, Packet requestPacket, Packet responsePacket)
{
if (requestPacket.WordCount == 2)
{
bool enabled = false;
if (bool.TryParse(requestPacket.Words[1], out enabled))
{
session.Server.ReservedSlots.IsAggressiveJoin = enabled;
return this.ResponseSuccess(responsePacket);
}
else
{
return this.ResponseInvalidArguments(requestPacket);
}
}
else if (requestPacket.WordCount == 1)
{
var enabled = session.Server.ReservedSlots.IsAggressiveJoin;
responsePacket.Words.AddRange(new string[] { Constants.RESPONSE_SUCCESS, Convert.ToString(enabled) });
return true;
}
else
{
return this.ResponseInvalidArguments(responsePacket);
}
}
public bool OnCreatingResponse(PacketSession session, Packet requestPacket, Packet responsePacket)
{
if (requestPacket.WordCount == 1)
{
// get the current password
Vars vars = session.Server.Vars;
if (vars.ContainsKey(Command))
{
object value = vars[Command];
responsePacket.Words.Add(RConDevServer.Protocol.Dice.Battlefield3.Constants.RESPONSE_SUCCESS);
responsePacket.Words.Add(Convert.ToString(value));
}
else
{
responsePacket.Words.Add(RConDevServer.Protocol.Dice.Battlefield3.Constants.RESPONSE_UNKNOWN_COMMAND);
}
}
else if (requestPacket.WordCount == 2)
{
// set the password
}
else
{
responsePacket.Words.Add(RConDevServer.Protocol.Dice.Battlefield3.Constants.RESPONSE_INVALID_ARGUMENTS);
}
return true;
}
public bool OnCreatingResponse(PacketSession session, Packet requestPacket, Packet responsePacket)
{
if (string.Equals(requestPacket.Words[0],
RConDevServer.Protocol.Dice.Battlefield3.Constants.COMMAND_LOGIN_PLAIN_TEXT,
StringComparison.InvariantCultureIgnoreCase))
{
if (requestPacket.Words.Count == 2 && requestPacket.Words[1] != string.Empty)
{
responsePacket.Words.Clear();
if (requestPacket.Words[1] != session.Server.Password)
{
responsePacket.Words.Add("InvalidPassword");
}
else
{
responsePacket.Words.Add("OK");
session.IsAuthenticated = true;
}
}
else
{
responsePacket.Words.Add("PasswordNotSet");
}
return true;
}
return false;
}
public bool OnCreatingResponse(PacketSession session, Packet requestPacket, Packet responsePacket)
{
// decide between get or set option
if (requestPacket.Words.Count == 1)
{
// get option
responsePacket.Words.Add(RConDevServer.Protocol.Dice.Battlefield3.Constants.RESPONSE_SUCCESS);
responsePacket.Words.Add(session.IsEventsEnabled.ToString().ToLower());
}
else if (requestPacket.Words.Count == 2)
{
// set option
bool enabled = false;
string enabledValue = requestPacket.Words[1];
if (bool.TryParse(enabledValue, out enabled))
{
session.IsEventsEnabled = enabled;
responsePacket.Words.Add(RConDevServer.Protocol.Dice.Battlefield3.Constants.RESPONSE_SUCCESS);
return true;
}
else
{
responsePacket.Words.Add(RConDevServer.Protocol.Dice.Battlefield3.Constants.RESPONSE_INVALID_ARGUMENTS);
}
}
else
{
responsePacket.Words.Add(RConDevServer.Protocol.Dice.Battlefield3.Constants.RESPONSE_INVALID_ARGUMENTS);
}
return true;
}
protected override bool OnGetValue(PacketSession session, Packet responsePacket)
{
object value = session.Server.Vars[Command];
responsePacket.Words.Add(RConDevServer.Protocol.Dice.Battlefield3.Constants.RESPONSE_SUCCESS);
responsePacket.Words.Add(Convert.ToString(value));
return true;
}
protected override bool OnGetValue(PacketSession session, Packet responsePacket)
{
bool isRanked = session.Server.ServerInfo.IsRanked;
responsePacket.Words.Add(RConDevServer.Protocol.Dice.Battlefield3.Constants.RESPONSE_SUCCESS);
responsePacket.Words.Add(Convert.ToString(isRanked));
return true;
}
public override bool OnCreatingResponse(PacketSession session, Packet requestPacket, Packet responsePacket)
{
if (requestPacket.Words.Count != 5)
{
return this.ResponseInvalidArguments(responsePacket);
}
var playerName = requestPacket.Words[1];
if (session.Server.PlayerList.Players.All(x => x.Name != playerName))
{
return this.ResponseInvalidPlayerName(responsePacket);
}
var player = session.Server.PlayerList.Players.FirstOrDefault(x => x.Name == playerName);
var teamIdString = requestPacket.Words[2];
int teamId;
if (!Int32.TryParse(teamIdString, out teamId))
{
return this.ResponseInvalidTeamId(responsePacket);
}
var squadIdString = requestPacket.Words[3];
int squadId;
if (!Int32.TryParse(squadIdString, out squadId))
{
return this.ResponseInvalidSquadId(responsePacket);
}
player.TeamId = teamId;
player.SquadId = squadId;
return this.ResponseSuccess(responsePacket);
}
protected override bool OnGetValue(PacketSession session, Packet responsePacket)
{
var varValue = session.Server.Vars[Command];
responsePacket.Words.Add(Constants.RESPONSE_SUCCESS);
responsePacket.Words.Add(varValue.ToString());
return true;
}
public bool OnCreatingResponse(PacketSession session, Packet requestPacket, Packet responsePacket)
{
// create a default list not regarding the player subset
foreach (string word in session.Server.PlayerList.ToWords(false))
{
responsePacket.Words.Add(word);
}
return true;
}
public bool OnCreatingResponse(PacketSession session, Packet requestPacket, Packet responsePacket)
{
responsePacket.Words.Add(Constants.RESPONSE_SUCCESS);
foreach (string word in session.Server.PlayerList.ToWords())
{
responsePacket.Words.Add(word);
}
return true;
}
public bool OnCreatingResponse(PacketSession session, Packet requestPacket, Packet responsePacket)
{
responsePacket.Words.Add(RConDevServer.Protocol.Dice.Battlefield3.Constants.RESPONSE_SUCCESS);
foreach (string command in new Commands())
{
responsePacket.Words.Add(command);
}
return true;
}
protected override bool OnGetValue(PacketSession session, Packet responsePacket)
{
var response = new[]
{
RConDevServer.Protocol.Dice.Battlefield3.Constants.RESPONSE_SUCCESS,
Convert.ToString(session.Server.Vars[Command])
};
StringListExtensions.AddRange(responsePacket.Words, response);
return true;
}
public bool OnCreatingResponse(PacketSession session, Packet requestPacket, Packet responsePacket)
{
var message = requestPacket.Words[1];
var duration = (requestPacket.Words.Count > 2) ? Convert.ToInt32(requestPacket.Words[2]) : 10;
var playerSubset = (requestPacket.Words.Count > 3)
? PlayerSubset.FromWords(requestPacket.Words.Skip(3).ToList())
: new PlayerSubset { Type = PlayerSubsetType.All };
if (message.Length >= 256)
{
responsePacket.Words.Add(RConDevServer.Protocol.Dice.Battlefield3.Constants.RESPONSE_TOO_LONG_MESSAGE);
return true;
}
switch (playerSubset.Type)
{
case PlayerSubsetType.None:
responsePacket.Words.Add(RConDevServer.Protocol.Dice.Battlefield3.Constants.RESPONSE_INVALID_ARGUMENTS);
return true;
case PlayerSubsetType.All:
responsePacket.Words.Add(RConDevServer.Protocol.Dice.Battlefield3.Constants.RESPONSE_SUCCESS);
return true;
case PlayerSubsetType.Team:
responsePacket.Words.Add(playerSubset.TeamId <= 16
? RConDevServer.Protocol.Dice.Battlefield3.Constants.RESPONSE_SUCCESS
: RConDevServer.Protocol.Dice.Battlefield3.Constants.RESPONSE_INVALID_TEAM);
return true;
case PlayerSubsetType.Squad:
if (playerSubset.TeamId <= 16)
{
responsePacket.Words.Add(playerSubset.SquadId <= 32
? RConDevServer.Protocol.Dice.Battlefield3.Constants.RESPONSE_SUCCESS
: RConDevServer.Protocol.Dice.Battlefield3.Constants.RESPONSE_INVALID_SQUAD);
}
else
{
responsePacket.Words.Add(RConDevServer.Protocol.Dice.Battlefield3.Constants.RESPONSE_INVALID_TEAM);
}
return true;
case PlayerSubsetType.Player:
responsePacket.Words.Add(
session.Server.PlayerList.Players.Any(x => x.Name == playerSubset.PlayerName)
? RConDevServer.Protocol.Dice.Battlefield3.Constants.RESPONSE_SUCCESS
: RConDevServer.Protocol.Dice.Battlefield3.Constants.RESPONSE_PLAYER_NOT_FOUND);
return true;
}
return false;
}
public bool OnCreatingResponse(PacketSession session, Packet requestPacket, Packet responsePacket)
{
int offset = 0;
if (requestPacket.Words.Count == 2)
{
int.TryParse(requestPacket.Words[1], out offset);
}
responsePacket.Words.Add(Constants.RESPONSE_SUCCESS);
StringListExtensions.AddRange(responsePacket.Words, session.Server.ReservedSlots.ToWords(offset));
return true;
}
public bool OnCreatingResponse(PacketSession session, Packet requestPacket, Packet responsePacket)
{
if (requestPacket.Words.Count != 1)
{
responsePacket.Words.Add(Constants.RESPONSE_INVALID_ARGUMENTS);
return true;
}
responsePacket.Words.Add(Constants.RESPONSE_SUCCESS);
responsePacket.Words.Add(Convert.ToString(session.Server.ServerInfo.MaxPlayerCount));
return true;
}
public bool OnCreatingResponse(PacketSession session, Packet requestPacket, Packet responsePacket)
{
if (requestPacket.Words.Count == 1)
{
session.Server.MapList.NextRound();
responsePacket.Words.Add(Constants.RESPONSE_SUCCESS);
}
else
{
responsePacket.Words.Add(Constants.RESPONSE_INVALID_ARGUMENTS);
}
return true;
}
public virtual bool OnCreatingResponse(PacketSession session, Packet requestPacket, Packet responsePacket)
{
if (requestPacket.Words.Count == 1)
{
return OnGetValue(session, responsePacket);
}
if (requestPacket.WordCount == 2)
{
return OnSetValue(session, requestPacket, responsePacket);
}
responsePacket.Words.Add(RConDevServer.Protocol.Dice.Battlefield3.Constants.RESPONSE_INVALID_ARGUMENTS);
return true;
}
/// <summary>
/// Creates a ViewModel for the <see cref="PacketSession"/>
/// </summary>
/// <param name="session"></param>
/// <param name="invoker"> </param>
public SessionViewModel(PacketSession session, Action<Action> invoker)
: base(invoker)
{
PacketSession = session;
this.Packets = new PacketList();
if (PacketSession != null)
{
PacketSession.PacketReceived += PacketSessionOnPacketReceived;
PacketSession.PacketSent += PacketSessionOnPacketSent;
PacketSession.SessionClosed += PacketSessionOnSessionClosed;
PacketSession.ServerUpdated += PacketSessionOnServerUpdated;
}
}
protected override bool OnSetValue(PacketSession session, Packet requestPacket, Packet responsePacket)
{
string stringValue = requestPacket.Words[2];
bool isRanked = false;
if (bool.TryParse(stringValue, out isRanked))
{
session.Server.ServerInfo.IsRanked = isRanked;
responsePacket.Words.Add(RConDevServer.Protocol.Dice.Battlefield3.Constants.RESPONSE_SUCCESS);
return true;
}
responsePacket.Words.Add(RConDevServer.Protocol.Dice.Battlefield3.Constants.RESPONSE_INVALID_ARGUMENTS);
return true;
}
public bool OnCreatingResponse(PacketSession session, Packet requestPacket, Packet responsePacket)
{
if (requestPacket.Words.Count == 1)
{
responsePacket.Words.Add(Constants.RESPONSE_SUCCESS);
responsePacket.Words.Add(Constants.PROTOCOL_CODE);
responsePacket.Words.Add(Constants.PROTOCOL_BUILD_NUM);
}
else
{
responsePacket.Words.Add(Constants.RESPONSE_INVALID_ARGUMENTS);
}
return true;
}
protected override bool OnSetValue(PacketSession session, Packet requestPacket, Packet responsePacket)
{
string valueString = requestPacket.Words[1];
object value = ConvertToValue(valueString);
if (value != null)
{
session.Server.Vars[Command] = value;
responsePacket.Words.Add(RConDevServer.Protocol.Dice.Battlefield3.Constants.RESPONSE_SUCCESS);
}
else
{
responsePacket.Words.Add(RConDevServer.Protocol.Dice.Battlefield3.Constants.RESPONSE_INVALID_ARGUMENTS);
}
return true;
}
public bool OnCreatingResponse(PacketSession session, Packet requestPacket, Packet responsePacket)
{
if (requestPacket.Words.Count != 1)
{
responsePacket.Words.Add(Constants.RESPONSE_INVALID_ARGUMENTS);
return true;
}
session.Server.ReservedSlotsStore.Clear();
foreach (var reservedSlot in session.Server.ReservedSlots)
{
session.Server.ReservedSlotsStore.Add(reservedSlot);
}
responsePacket.Words.Add(Constants.RESPONSE_SUCCESS);
return true;
}
public bool OnCreatingResponse(PacketSession session, Packet requestPacket, Packet responsePacket)
{
if (requestPacket.Words.Count == 1)
{
var mapList = session.Server.MapList;
responsePacket.Words.Add(Constants.RESPONSE_SUCCESS);
responsePacket.Words.Add(Convert.ToString(mapList.CurrentIndex));
responsePacket.Words.Add(Convert.ToString(mapList.NextIndex));
}
else
{
responsePacket.Words.Add(Constants.RESPONSE_INVALID_ARGUMENTS);
}
return true;
}
public bool OnCreatingResponse(PacketSession session, Packet requestPacket, Packet responsePacket)
{
var index = Convert.ToInt32(requestPacket.Words[1]);
var mapList = session.Server.MapList;
if (index > 0 || index < mapList.Count)
{
mapList.RemoveAt(index);
responsePacket.Words.Add(Constants.RESPONSE_SUCCESS);
}
else
{
responsePacket.Words.Add(Constants.RESPONSE_INVALID_MAP_INDEX);
}
return true;
}
public bool OnCreatingResponse(PacketSession session, Packet requestPacket, Packet responsePacket)
{
var startIndex = 0;
if (requestPacket.Words.Count == 2)
{
if (!int.TryParse(requestPacket.Words[1], out startIndex))
{
responsePacket.Words.Add(Constants.RESPONSE_INVALID_ARGUMENTS);
return true;
}
}
responsePacket.Words.Add(Constants.RESPONSE_SUCCESS);
StringListExtensions.AddRange(responsePacket.Words, session.Server.MapList.ToWords(startIndex));
return true;
}
public bool OnCreatingResponse(PacketSession session, Packet requestPacket, Packet responsePacket)
{
var mapListItemsFromStore = session.Server.MapListStore.GetAll();
foreach (var mapListItem in mapListItemsFromStore)
{
////if (session.Server.ReservedSlots.Any(x => x.PlayerName == reservedSlot.PlayerName))
////{
//// responsePacket.Words.Add(Constants.RESPONSE_PLAYER_ALREADY_IN_LIST);
//// return true;
////}
session.Server.MapList.Add(mapListItem);
}
responsePacket.Words.Add(Constants.RESPONSE_SUCCESS);
return true;
}
public override bool OnCreatingResponse(PacketSession session, Packet requestPacket, Packet responsePacket)
{
if (requestPacket.Words.Count != 2)
{
return this.ResponseInvalidArguments(responsePacket);
}
var winningTeamIdString = requestPacket.Words[1];
int winningTeamId;
if (!int.TryParse(winningTeamIdString, out winningTeamId))
{
return this.ResponseInvalidArguments(responsePacket);
}
return this.ResponseSuccess(responsePacket);
}
public bool OnCreatingResponse(PacketSession session, Packet requestPacket, Packet responsePacket)
{
if (requestPacket.Words.Count == 1)
{
responsePacket.Words.Add(Constants.RESPONSE_SUCCESS);
foreach (string word in session.Server.ServerInfo.ToWords())
{
responsePacket.Words.Add(word);
}
}
else
{
responsePacket.Words.Add("InvalidArguments");
}
return true;
}
public static void C_ScaleHandler(PacketSession session, IMessage packet)
{
C_Scale scalePacket = packet as C_Scale;
ClientSession clientSession = session as ClientSession;
if (clientSession.MyPlayer == null)
{
return;
}
if (clientSession.MyPlayer.Room == null)
{
return;
}
Console.WriteLine($"ScaleSet : {scalePacket.Scale}");
S_Scale resScalePacket = new S_Scale();
resScalePacket.PlayerId = clientSession.MyPlayer.Info.PlayerId;
resScalePacket.Scale = scalePacket.Scale;
clientSession.MyPlayer.Room.Broadcast(resScalePacket);
}
// Step2
// 로그인 통과 + 캐릭터 목록
public static void S_LoginHandler(PacketSession session, IMessage packet)
{
S_Login loginPacket = packet as S_Login;
ServerSession serverSession = (ServerSession)session;
// TODO : 로비 UI에서 케릭터 보여주고, 선택할 수 있도록
if (loginPacket.Players == null || loginPacket.Players.Count == 0)
{
C_CreatePlayer createPacket = new C_CreatePlayer();
createPacket.Name = $"Player_{serverSession.DummyId.ToString("0000")}";
serverSession.Send(createPacket);
}
else
{
// 무조건 첫번째 캐릭터 로그인
LobbyPlayerInfo info = loginPacket.Players[0];
C_EnterGame enterGamePacket = new C_EnterGame();
enterGamePacket.Name = info.Name;
serverSession.Send(enterGamePacket);
}
}
// Step 2
public static void S_LoginHandler(PacketSession session, IMessage packet)// 로그인 + 캐릭터 목록
{
S_Login loginPacket = packet as S_Login;
ServerSession serverSession = session as ServerSession;
if (loginPacket.Players == null || loginPacket.Players.Count == 0)
{
C_CreatePlayer createPacket = new C_CreatePlayer();
createPacket.Name = $"DummyPlayer_{serverSession.DummyID.ToString("0000")}";
serverSession.Send(createPacket);
}
else
{
// 무조건 첫번쨰 캐릭터 로그인
LobbyPlayerInfo info = loginPacket.Players[0];
C_EnterGame enterGamePacket = new C_EnterGame();
enterGamePacket.Name = info.Name;
serverSession.Send(enterGamePacket);
}
}
public static void C_SkillHandler(PacketSession session, IMessage packet)
{
C_Skill skillPacket = packet as C_Skill;
ClientSession clientSession = session as ClientSession;
Player player = clientSession.MyPlayer;
if (player == null)
{
return;
}
GameRoom room = player.Room;
if (room == null)
{
return;
}
room.Push(room.HandleSkill, player, skillPacket);
}
public static void C_EquipItemHandler(PacketSession session, IMessage packet)
{
C_EquipItem equipPacket = packet as C_EquipItem;
ClientSession clientSession = session as ClientSession;
Player player = clientSession.MyPlayer;
if (player == null)
{
return;
}
GameRoom room = player.Room;
if (room == null)
{
return;
}
room.Push(room.HandleEquipItem, player, equipPacket);
}
private async void AcceptSession(long clientId, TcpClient client)
{
Logger.Debug("New client connected #{0} {1}", clientId, client.Client.RemoteEndPoint);
var session = new PacketSession(PacketReceiver);
try
{
SessionMapping.TryAdd(clientId, session);
Logger.Trace("Added object #{0} into SessionMapping", clientId);
await session.Start(clientId, client);
Logger.Debug("Connection with client ${0} is closed", clientId);
}
finally
{
SessionMapping.TryRemove(clientId, out var _);
Logger.Trace("Removed object #{0} from SessionMapping", clientId);
}
}
public static void S_DieHandler(PacketSession session, IMessage packet)
{
S_Die diePacket = packet as S_Die;
GameObject go = Managers.Object.FindById(diePacket.Objectid);
if (go == null)
{
return;
}
CreatureController cc = go.GetComponent <CreatureController>();
if (cc == null)
{
return;
}
cc.Hp = 0;
cc.OnDead();
}
public static void S_ChatHandler(PacketSession packetSession, IPacket packet)
{
S_Chat chatPacket = packet as S_Chat;
ServerSession serverSession = packetSession as ServerSession;
//if(chatPacket.playerId == 1)
{
Debug.Log(chatPacket.chat);
// 유니티 관련 동작은 유니티 메인 스레드에서 실행해야 한다.
// 백그라운드 스레드에서 호출 시 실행되지 않는다.
GameObject go = GameObject.Find("Player");
if (go == null)
{
Debug.Log("Player not found.");
}
else
{
Debug.Log("Player found!");
}
}
}
public static void C_CreateRoomHandler(PacketSession session, IMessage packet)
{
Console.WriteLine("CreateRoom!");
ClientSession clientSession = session as ClientSession;
C_CreateRoom createRoomPacket = packet as C_CreateRoom;
GameRoom room = RoomManager.Instance.Add();
room.RoomName = createRoomPacket.Name;
room.Password = createRoomPacket.Password;
S_RoomCreateSuccess roomSuccessPacket = new S_RoomCreateSuccess();
roomSuccessPacket.Room = new RoomInfo();
roomSuccessPacket.Room.Name = room.RoomName;
roomSuccessPacket.Room.Password = room.Password;
roomSuccessPacket.Room.RoomId = room.RoomId;
roomSuccessPacket.Room.PlayerNumber = 0;
roomSuccessPacket.Player = new PlayerInfo();
clientSession.MyPlayer.Info.ChNum = createRoomPacket.ChNum;
roomSuccessPacket.Player = clientSession.MyPlayer.Info;
clientSession.Send(roomSuccessPacket);
Console.WriteLine("SendRoomCreateSuccess!");
}
// 로그인 OK + 캐릭터 목록
public static void S_LoginHandler(PacketSession session, IMessage packet)
{
S_Login loginPacket = (S_Login)packet;
Debug.Log($"LoginOk({loginPacket.LoginOk})");
// TODO : 로비 UI에서 캐릭터 보여주고, 선택할 수 있도록
if (loginPacket.Players == null || loginPacket.Players.Count == 0)
{
C_CreatePlayer createPacket = new C_CreatePlayer();
createPacket.Name = $"Player_{Random.Range(0, 10000).ToString("0000")}";
Managers.Network.Send(createPacket);
}
else
{
// 무조건 첫번째 로그인
LobbyPlayerInfo info = loginPacket.Players[0];
C_EnterGame enterGamePacket = new C_EnterGame();
enterGamePacket.Name = info.Name;
Managers.Network.Send(enterGamePacket);
}
}
public static void S_AddItemHandler(PacketSession session, IMessage packet)
{
S_AddItem itemList = (S_AddItem)packet;
// 메모리에 아이템 정보 적용
foreach (ItemInfo itemInfo in itemList.Items)
{
Item item = Item.MakeItem(itemInfo);
Managers.Inven.Add(item);
}
Debug.Log("아이템을 획득했습니다.");
UI_GameScene gameSceneUI = Managers.UI.SceneUI as UI_GameScene;
gameSceneUI.InvenUI.RefreshUI();
gameSceneUI.StatUi.RefreshUI();
if (Managers.Obj.MyPlayer != null)
{
Managers.Obj.MyPlayer.RefreshAdditionalStat();
}
}
public static void S_ChangeHpHandler(PacketSession session, IMessage packet)
{
S_ChangeHp changePacket = packet as S_ChangeHp;
// 여기서 찾은 PlayerId가 꼭 나라는 보장은 없다. 스킬은 아무나 쓰니깐
GameObject go = Managers.Object.FindById(changePacket.ObjectId);
if (go == null)
{
return;
}
CreatureController cc = go.GetComponent <CreatureController>();
if (cc != null)
{
// 체력을 깎자
cc.Hp = changePacket.Hp; // ui 갱신도 같이 됨
// UI 갱신
Debug.Log($"ChangeHP : {changePacket.Hp}");
}
}
public static void C_JoinRoomHandler(PacketSession session, IMessage packet)
{
ClientSession clientSession = session as ClientSession;
C_JoinRoom joinPacket = packet as C_JoinRoom;
Console.WriteLine("Joinroom " + joinPacket.RoomId);
GameRoom gameRoom = RoomManager.Instance.Find(joinPacket.RoomId);
if (gameRoom.isCreating || gameRoom.isPlaying)
{
return;
}
//TODO 비밀번호 체크
clientSession.MyPlayer.Info.ChNum = joinPacket.ChNum;
gameRoom.EnterRoom(clientSession.MyPlayer);
S_EnterRoom enterRoomPacket = new S_EnterRoom();
enterRoomPacket.Player = clientSession.MyPlayer.Info;
clientSession.Send(enterRoomPacket);
S_MapSaveDataSend mapSendPacket = new S_MapSaveDataSend();
int index = 0;
foreach (MapSave m in clientSession.MyPlayer.Room.MData.Map)
{
mapSendPacket.Map = m;
mapSendPacket.Index = index;
clientSession.Send(mapSendPacket);
index++;
Console.WriteLine("MapSend : " + m.MapCell.Count);
}
S_MobSpawn mobSpawnPacket = new S_MobSpawn();
foreach (Monster m in clientSession.MyPlayer.Room._Monsters)
{
mobSpawnPacket.Mobs.Add(m.Info);
}
clientSession.Send(mobSpawnPacket);
}
public static void C_MoveHandler(PacketSession session, IMessage packet)
{
C_Move movePacket = packet as C_Move;
ClientSession clientSession = session as ClientSession;
//Console.WriteLine($"C_Move ({movePacket.PosInfo.PosX}, {movePacket.PosInfo.PosY})");
Player player = clientSession.MyPlayer;
if (player == null)
{
return;
}
GameRoom room = player.Room;
if (room == null)
{
return;
}
room.Push(room.HandleMove, player, movePacket);
}
public void OnRecvPacket(PacketSession session, ArraySegment <byte> buffer)
{
ushort count = 0;
ushort size = BitConverter.ToUInt16(buffer.Array, buffer.Offset + count);
count += 2;
if (size != buffer.Count)
{
return;
}
ushort id = BitConverter.ToUInt16(buffer.Array, buffer.Offset + count);
count += 2;
Action <PacketSession, ArraySegment <byte> > action = null;
if (_onRecv.TryGetValue(id, out action))
{
action.Invoke(session, buffer);
}
}
public static void S_AddItemHandler(PacketSession session, IMessage packet)// 인게임중 아이템 획득
{
S_AddItem itemList = packet as S_AddItem;
// 아이템정보 메모리에 들고있기
foreach (ItemInfo itemInfo in itemList.Items)
{
Item item = Item.MakeItem(itemInfo);
Managers.Inven.Add(item);
}
Debug.Log("아이템 획득!");
// 인벤토리 새로고침
UI_GameScene gameSceneUI = Managers.UI.SceneUI as UI_GameScene;
gameSceneUI.InvenUI.RefreshUI();
gameSceneUI.StatUI.RefreshUI();
// 변경스텟 적용
if (Managers.Object.MyPlayer != null)
{
Managers.Object.MyPlayer.RefreshAdditionalStat();
}
}
private async void ProcessSocket(Socket socket)
{
Logger.Write("Connected from: " + socket.RemoteEndPoint);
var session = new PacketSession(socket);
_lock.DoWriteLock(() => _sessions.Add(session));
Dispatch(new ConnectionPacket {
Connected = true
}, session);
try
{
while (true)
{
var packet = await session.Receive();
Dispatch(packet, session);
}
}
catch (Exception e)
{
Logger.Write(e);
}
Dispatch(new ConnectionPacket {
Connected = false
}, session);
_lock.DoWriteLock(() => _sessions.Remove(session));
try
{
socket.Shutdown(SocketShutdown.Both);
}
catch
{
}
}
public static void C_MoveHandler(PacketSession session, IMessage packet)
{
C_Move movePacket = packet as C_Move;
ClientSession clientSession = session as ClientSession;
//Console.WriteLine($"C_Move ({movePacket.PosInfo.PosX}, {movePacket.PosInfo.PosY})");
// lock 처리 안하고 멀티쓰레드 방어
Player player = clientSession.MyPlayer; // 내가 꺼내오는 시점의 플레이어를 따로 변수로 뺌
if (player == null)
{
return;
}
// 아래부터는 MyPlayer가 null 아니라고 확신하고 작성한 코드들이지만
// 멀티쓰레드일때는 보장할수가 없다.
// 그래서 플레이어가 내가 꺼내오는 시점에서 있다면? 따로 변수로 빼놓고 쓰자
// 만약 다른 쓰레드에서 LeaveGame() 해버리면 null이 아니라고 체크하고 들어가도
// 하단에서 터질수가 있음
// 그니깐 플레이어처럼 내가 체크하는 시점에서 따로 빼놓음
GameRoom room = player.Room;
if (room == null)
{
return;
}
// JobQueue 방식을 사용했기 때문에 이동패킷에 대한 응답에 딜레이가 생겼음 (room.HandleMove)
// 그런데 내가 조작하는 플레이어는 이미 이동을 해버렸는데 서버 응답은 즉시가 아님
// 클라이언트의 S_MoveHandler을 보면 서버 응답을 받고 내가 조작하는 플레이어의 상태까지 변경해버리기 때문에
// 위에 응답 딜레이와 합쳐져서 부자연스러운 움직임을 보이게 됨,
// 난 이미 이동했지만 서버는 직전 좌표를 던져줘서 나를 강제로 이동시킬수가 있다.
room.Push(room.HandleMove, player, movePacket); // 이동패킷 처리를 안전하게
}
public static void S_EquipItemHandler(PacketSession session, IMessage packet)// 아이템 장착 / 탈착
{
S_EquipItem equipItemOk = packet as S_EquipItem;
Item item = Managers.Inven.Get(equipItemOk.ItemDbId);
if (item == null)
{
return;
}
item.Equipped = equipItemOk.Equipped;
Debug.Log("아이템 착용 변경");
// 인벤토리 새로고침
UI_GameScene gameSceneUI = Managers.UI.SceneUI as UI_GameScene;
gameSceneUI.InvenUI.RefreshUI();
gameSceneUI.StatUI.RefreshUI();
// 변경스텟 적용
if (Managers.Object.MyPlayer != null)
{
Managers.Object.MyPlayer.RefreshAdditionalStat();
}
}
public static void C_EnterGameHandler(PacketSession session, IMessage packet)
{
C_EnterGame enterGamePacket = (C_EnterGame)packet;
ClientSession clientSession = (ClientSession)session;
}
public static void S_LeaveGameHandler(PacketSession session, IMessage packet)
{
S_LeaveGame leaveGameHandler = packet as S_LeaveGame;
Managers.Object.Clear();
}
public static void S_EnterGameHandler(PacketSession session, IMessage packet)
{
S_EnterGame enterGamePacket = packet as S_EnterGame;
ServerSession serverSession = session as ServerSession;
}
public static void C_CreatePlayerHandler(PacketSession session, IMessage packet)
{
C_CreatePlayer enterGamePacket = (C_CreatePlayer)packet;
ClientSession clientSession = (ClientSession)session;
}
public static void S_BroadcastEnterGameHandler(PacketSession session, IPacket packet)
{
S_BroadcastEnterGame pkt = packet as S_BroadcastEnterGame;
ServerSession serverSession = session as ServerSession;
}
public void BroadcastPacket(IPacket packet, PacketSession exceptSession = null)
{
_listener.BroadcastPacket(packet, exceptSession);
}
public static void S_PlayerListHandler(PacketSession session, IPacket packet)
{
S_PlayerList pkt = packet as S_PlayerList;
ServerSession serverSession = session as ServerSession;
}
public override void receivePacketSession(PacketSession ps)
{
_server.sendPacketToClient(ps, ps.Identifier.Id);
}
public static void S_EnterGameHandler(PacketSession session, IMessage packet)
{
S_EnterGame enterGamePacket = packet as S_EnterGame;
Managers.Object.Add(enterGamePacket.Player, myPlayer: true);
}
public static void S_ChangeStatHandler(PacketSession session, IMessage packet)
{
S_ChangeStat itemList = (S_ChangeStat)packet;
// TODO
}
public static void C_PongHandler(PacketSession session, IMessage packet)
{
ClientSession clientSession = (ClientSession)session;
clientSession.HandlePong();
}
