Durak-plusplus/NetworkHandler.cpp at master · Seeloewen/Durak-plusplus · 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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
#include "NetworkHandler.h"
#include <string>
#include <vector>
#include <sstream>
#include <iostream>
#include <Game.h>
#include "LogUtil.h"
#include "Widgets.h"

Packet::Packet(PacketType type, std::vector<std::string> args)
{
	this->type = type;
	this->args = args;
}

Packet* getPacket(std::string message)
{
	std::cout << message << std::endl;
	std::vector<std::string> args;
	PacketType type = INIT;

	//Convert strings into arguments
	std::stringstream ss(message);
	std::string item;

	int i = 0;
	while (std::getline(ss, item, ';'))
	{
		if (i == 0)
		{
			//Get type from arguments
			type = static_cast<PacketType>(atoi(item.c_str()));
		}
		else
		{
			//Put the remaining arguments
			args.push_back(item);
		}

		i++;
	}


	return new Packet(type, args);
}

bool isServer()
{
	return server != nullptr;
}

bool isClient()
{
	return client != nullptr;
}

Client* getClient(int id)
{
	for (Client* client : server->clients)
	{
		if (client->id == id) return client;
	}
}

void startServer(unsigned int port)
{
	if (client == nullptr && server == nullptr)
	{
		game = new Game();
		server = new Server();

		std::thread serverThread([=]() {
			server->start(port);
			});
		serverThread.detach();
	}
}

void connectAsClient(std::string ip, unsigned int port)
{
	if (client == nullptr && server == nullptr)
	{
		game = new Game();
		client = new Client(0);
		std::thread clientThread([=]() {
			client->connect(ip, port);
			});
		clientThread.detach();
	}
}


void sendPacketOnly(int id, PacketType type, std::string message)
{
	//Assumes this is server
	int t = type;
	server->sendOnly(std::to_string(t) + ";" + message, getClient(id)->clientSocket);
}

void sendPacket(PacketType type)
{
	//Send packet without msg
	sendPacket(type, "");
}

void sendPacket(PacketType type, std::string message)
{
	int t = type;

	//Send packet depending on if it's server or client
	if (isServer())
	{
		int t = type;
		server->send(std::to_string(t) + ";" + message);
	}
	else if (isClient())
	{
		int t = type;
		client->send(std::to_string(t) + ";" + message);
	}
}

void handlePacket(Packet* packet)
{
	switch (packet->type)
	{
	case INIT:
		handleInit(packet->args);
		break;
	case INIT_RESPONSE:
		handleInitResponse(packet->args);
		break;
	case ADDCARD:
		handleAddCard(packet->args);
		break;
	case REMOVECARD:
		handleRemoveCard(packet->args);
		break;
	case ADDTOSTACK:
		handleAddToStack(packet->args);
		break;
	case START:
		handleStart(packet->args);
		break;
	case STARTATTACK:
		handleStartAttack(packet->args);
		break;
	case ADDTOATTACK:
		handleAddToAttack(packet->args);
		break;
	case DEFEND:
		handleDefend(packet->args);
		break;
	case LEAVEATTACK:
		handleLeaveAttack(packet->args);
		break;
	case ENDGAME:
		handleEndGame(packet->args);
		break;
	case RESET:
		handleReset(packet->args);
		break;
	default:
		return;
	}
}