Last-Stand-MainServer/ServerPacketHandler.h at main · Back2Play-LastStand/Last-Stand-MainServer · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
#pragma once
#include "Protocol.pb.h"

using PacketHandlerFunc = function<bool(Session*, BYTE*, int)>;
extern PacketHandlerFunc GPacketHandler[UINT16_MAX];

enum : unsigned short
{
	PKT_REQ_ENTER = 1000,
	PKT_RES_ENTER = 1001,
	PKT_REQ_ENTER_GAMEROOM = 1002,
	PKT_RES_ENTER_GAMEROOM = 1003,
	PKT_RES_ENTER_GAMEROOM_ALL = 1004,
	PKT_REQ_LEAVE_GAMEROOM = 1005,
	PKT_RES_LEAVE_GAMEROOM = 1006,
	PKT_REQ_ENTER_ROOM = 1007,
	PKT_RES_ENTER_ROOM = 1008,
	PKT_REQ_LEAVE = 1009,
	PKT_RES_LEAVE = 1010,
	PKT_REQ_RESPAWN = 1011,
	PKT_RES_SPAWN = 1012,
	PKT_RES_SPAWN_ALL = 1013,
	PKT_RES_DESPAWN = 1014,
	PKT_RES_CHANGE_HP = 1015,
	PKT_RES_DIE = 1016,
	PKT_REQ_MOVE = 1017,
	PKT_RES_MOVE = 1018,
	PKT_RES_SPAWN_MONSTER = 1019,
	PKT_RES_MOVE_MONSTER = 1020,
	PKT_REQ_ATTACK_OBJECT = 1021,
	PKT_RES_ATTACK_OBJECT = 1022,
};

bool Handle_INVALID(Session* session, BYTE* buffer, int len);
bool Handle_REQ_ENTER(Session* session, Protocol::REQ_ENTER& pkt);
bool Handle_REQ_ENTER_GAMEROOM(Session* session, Protocol::REQ_ENTER_GAMEROOM& pkt);
bool Handle_REQ_LEAVE_GAMEROOM(Session* session, Protocol::REQ_LEAVE_GAMEROOM& pkt);
bool Handle_REQ_ENTER_ROOM(Session* session, Protocol::REQ_ENTER_ROOM& pkt);
bool Handle_REQ_LEAVE(Session* session, Protocol::REQ_LEAVE& pkt);
bool Handle_REQ_RESPAWN(Session* session, Protocol::REQ_RESPAWN& pkt);
bool Handle_REQ_MOVE(Session* session, Protocol::REQ_MOVE& pkt);
bool Handle_REQ_ATTACK_OBJECT(Session* session, Protocol::REQ_ATTACK_OBJECT& pkt);

class ServerPacketHandler
{
public:
	static void Init()
	{
		for (int i = 0; i < UINT16_MAX; i++)
			GPacketHandler[i] = Handle_INVALID;
		GPacketHandler[PKT_REQ_ENTER] = [](Session* session, BYTE* buffer, int len) {return HandlePacket<Protocol::REQ_ENTER>(Handle_REQ_ENTER, session, buffer, len); };
		GPacketHandler[PKT_REQ_ENTER_GAMEROOM] = [](Session* session, BYTE* buffer, int len) {return HandlePacket<Protocol::REQ_ENTER_GAMEROOM>(Handle_REQ_ENTER_GAMEROOM, session, buffer, len); };
		GPacketHandler[PKT_REQ_LEAVE_GAMEROOM] = [](Session* session, BYTE* buffer, int len) {return HandlePacket<Protocol::REQ_LEAVE_GAMEROOM>(Handle_REQ_LEAVE_GAMEROOM, session, buffer, len); };
		GPacketHandler[PKT_REQ_ENTER_ROOM] = [](Session* session, BYTE* buffer, int len) {return HandlePacket<Protocol::REQ_ENTER_ROOM>(Handle_REQ_ENTER_ROOM, session, buffer, len); };
		GPacketHandler[PKT_REQ_LEAVE] = [](Session* session, BYTE* buffer, int len) {return HandlePacket<Protocol::REQ_LEAVE>(Handle_REQ_LEAVE, session, buffer, len); };
		GPacketHandler[PKT_REQ_RESPAWN] = [](Session* session, BYTE* buffer, int len) {return HandlePacket<Protocol::REQ_RESPAWN>(Handle_REQ_RESPAWN, session, buffer, len); };
		GPacketHandler[PKT_REQ_MOVE] = [](Session* session, BYTE* buffer, int len) {return HandlePacket<Protocol::REQ_MOVE>(Handle_REQ_MOVE, session, buffer, len); };
		GPacketHandler[PKT_REQ_ATTACK_OBJECT] = [](Session* session, BYTE* buffer, int len) {return HandlePacket<Protocol::REQ_ATTACK_OBJECT>(Handle_REQ_ATTACK_OBJECT, session, buffer, len); };
	}
	static shared_ptr<vector<char>> MakeSendBuffer(Protocol::RES_ENTER& pkt) { return MakeSendBuffer(pkt, PKT_RES_ENTER); }
	static shared_ptr<vector<char>> MakeSendBuffer(Protocol::RES_ENTER_GAMEROOM& pkt) { return MakeSendBuffer(pkt, PKT_RES_ENTER_GAMEROOM); }
	static shared_ptr<vector<char>> MakeSendBuffer(Protocol::RES_ENTER_GAMEROOM_ALL& pkt) { return MakeSendBuffer(pkt, PKT_RES_ENTER_GAMEROOM_ALL); }
	static shared_ptr<vector<char>> MakeSendBuffer(Protocol::RES_LEAVE_GAMEROOM& pkt) { return MakeSendBuffer(pkt, PKT_RES_LEAVE_GAMEROOM); }
	static shared_ptr<vector<char>> MakeSendBuffer(Protocol::RES_ENTER_ROOM& pkt) { return MakeSendBuffer(pkt, PKT_RES_ENTER_ROOM); }
	static shared_ptr<vector<char>> MakeSendBuffer(Protocol::RES_LEAVE& pkt) { return MakeSendBuffer(pkt, PKT_RES_LEAVE); }
	static shared_ptr<vector<char>> MakeSendBuffer(Protocol::RES_SPAWN& pkt) { return MakeSendBuffer(pkt, PKT_RES_SPAWN); }
	static shared_ptr<vector<char>> MakeSendBuffer(Protocol::RES_SPAWN_ALL& pkt) { return MakeSendBuffer(pkt, PKT_RES_SPAWN_ALL); }
	static shared_ptr<vector<char>> MakeSendBuffer(Protocol::RES_DESPAWN& pkt) { return MakeSendBuffer(pkt, PKT_RES_DESPAWN); }
	static shared_ptr<vector<char>> MakeSendBuffer(Protocol::RES_CHANGE_HP& pkt) { return MakeSendBuffer(pkt, PKT_RES_CHANGE_HP); }
	static shared_ptr<vector<char>> MakeSendBuffer(Protocol::RES_DIE& pkt) { return MakeSendBuffer(pkt, PKT_RES_DIE); }
	static shared_ptr<vector<char>> MakeSendBuffer(Protocol::RES_MOVE& pkt) { return MakeSendBuffer(pkt, PKT_RES_MOVE); }
	static shared_ptr<vector<char>> MakeSendBuffer(Protocol::RES_SPAWN_MONSTER& pkt) { return MakeSendBuffer(pkt, PKT_RES_SPAWN_MONSTER); }
	static shared_ptr<vector<char>> MakeSendBuffer(Protocol::RES_MOVE_MONSTER& pkt) { return MakeSendBuffer(pkt, PKT_RES_MOVE_MONSTER); }
	static shared_ptr<vector<char>> MakeSendBuffer(Protocol::RES_ATTACK_OBJECT& pkt) { return MakeSendBuffer(pkt, PKT_RES_ATTACK_OBJECT); }

	static bool HandlePacket(Session* session, BYTE* buffer, int len)
	{
		PacketHeader* header = reinterpret_cast<PacketHeader*>(buffer);
		return GPacketHandler[header->id](session, buffer, len);
	}

	template<typename PacketType, typename ProcessFunc>
	static bool HandlePacket(ProcessFunc func, Session* session, BYTE* buffer, int len)
	{
		PacketType pkt;
		if (pkt.ParseFromArray(buffer + sizeof(PacketHeader), len - sizeof(PacketHeader)) == false)
			return false;

		return func(session, pkt);
	}

	template<typename T>
	static shared_ptr<vector<char>> MakeSendBuffer(T& pkt, unsigned short id)
	{
		const unsigned short dataSize = static_cast<unsigned short>(pkt.ByteSizeLong());
		const unsigned short packetSize = dataSize + sizeof(PacketHeader);

		shared_ptr<vector<char>> sendBuffer = MakeShared<vector<char>>(packetSize);
		PacketHeader* header = reinterpret_cast<PacketHeader*>(sendBuffer->data());
		header->size = packetSize;
		header->id = id;
		assert(pkt.SerializeToArray(sendBuffer->data() + 4, dataSize));

		return sendBuffer;
	}
};