1 #include "gameconn.h"

     2 #include "ipcconn.h"

     3 #include "ipcprotocol.h"

     4 #include "../util/logging.h"

     5 #include "../hwconsts.h"

     6 #include <stdbool.h>

     7 #include <stdlib.h>

     8 

     9 typedef enum {

    10 	AWAIT_CONNECTION,

    11 	CONNECTED,

    12 	FINISHED

    13 } gameconn_state;

    14 

    15 struct _flib_gameconn {

    16 	flib_ipcconn connection;

    17 	flib_vector configBuffer;

    18 

    19 	gameconn_state state;

    20 	bool netgame;

    21 

    22 	void (*onConnectCb)(void* context);

    23 	void *onConnectCtx;

    24 

    25 	void (*onDisconnectCb)(void* context, int reason);

    26 	void *onDisconnectCtx;

    27 

    28 	void (*onErrorMessageCb)(void* context, const char *msg);

    29 	void *onErrorMessageCtx;

    30 

    31 	void (*onChatCb)(void* context, const char *msg, bool teamchat);

    32 	void *onChatCtx;

    33 

    34 	void (*onGameRecordedCb)(void *context, const uint8_t *record, int size, bool isSavegame);

    35 	void *onGameRecordedCtx;

    36 

    37 	void (*onNetMessageCb)(void *context, const uint8_t *em, int size);

    38 	void *onNetMessageCtx;

    39 

    40 	bool running;

    41 	bool destroyRequested;

    42 };

    43 

    44 static void defaultCallback_onConnect(void* context) {}

    45 static void defaultCallback_onDisconnect(void* context, int reason) {}

    46 static void defaultCallback_onErrorMessage(void* context, const char *msg) {

    47 	flib_log_w("Error from engine (no callback set): %s", msg);

    48 }

    49 static void defaultCallback_onChat(void* context, const char *msg, bool teamchat) {}

    50 static void defaultCallback_onGameRecorded(void *context, const uint8_t *record, int size, bool isSavegame) {}

    51 static void defaultCallback_onNetMessage(void *context, const uint8_t *em, int size) {}

    52 

    53 static void clearCallbacks(flib_gameconn *conn) {

    54 	conn->onConnectCb = &defaultCallback_onConnect;

    55 	conn->onDisconnectCb = &defaultCallback_onDisconnect;

    56 	conn->onErrorMessageCb = &defaultCallback_onErrorMessage;

    57 	conn->onChatCb = &defaultCallback_onChat;

    58 	conn->onGameRecordedCb = &defaultCallback_onGameRecorded;

    59 	conn->onNetMessageCb = &defaultCallback_onNetMessage;

    60 }

    61 

    62 static bool getGameMod(flib_cfg_meta *meta, flib_cfg *conf, int maskbit) {

    63 	for(int i=0; i<meta->modCount; i++) {

    64 		if(meta->mods[i].bitmaskIndex == maskbit) {

    65 			return conf->mods[i];

    66 		}

    67 	}

    68 	flib_log_e("Unable to find game mod with mask bit %i", maskbit);

    69 	return false;

    70 }

    71 

    72 static int fillConfigBuffer(flib_vector configBuffer, const char *playerName, flib_cfg_meta *metaconf, flib_gamesetup *setup, bool netgame) {

    73 	bool error = false;

    74 	bool perHogAmmo = false;

    75 	bool sharedAmmo = false;

    76 

    77 	error |= flib_ipc_append_message(configBuffer, netgame ? "TN" : "TL");

    78 	error |= flib_ipc_append_seed(configBuffer, setup->seed);

    79 	if(setup->map) {

    80 		error |= flib_ipc_append_mapconf(configBuffer, setup->map, false);

    81 	}

    82 	if(setup->script) {

    83 		error |= flib_ipc_append_message(configBuffer, "escript %s", setup->script);

    84 	}

    85 	if(setup->gamescheme) {

    86 		error |= flib_ipc_append_gamescheme(configBuffer, setup->gamescheme, metaconf);

    87 		perHogAmmo = getGameMod(metaconf, setup->gamescheme, GAMEMOD_PERHOGAMMO_MASKBIT);

    88 		sharedAmmo = getGameMod(metaconf, setup->gamescheme, GAMEMOD_SHAREDAMMO_MASKBIT);

    89 	}

    90 	if(setup->teams) {

    91 		for(int i=0; i<setup->teamcount; i++) {

    92 			error |= flib_ipc_append_addteam(configBuffer, &setup->teams[i], perHogAmmo, sharedAmmo);

    93 		}

    94 	}

    95 	error |= flib_ipc_append_message(configBuffer, "!");

    96 	return error ? -1 : 0;

    97 }

    98 

    99 static flib_gameconn *flib_gameconn_create_partial(bool record, const char *playerName, bool netGame) {

   100 	flib_gameconn *result = NULL;

   101 	flib_gameconn *tempConn = calloc(1, sizeof(flib_gameconn));

   102 	if(tempConn) {

   103 		tempConn->connection = flib_ipcconn_create(record, playerName);

   104 		tempConn->configBuffer = flib_vector_create();

   105 		if(tempConn->connection && tempConn->configBuffer) {

   106 			tempConn->state = AWAIT_CONNECTION;

   107 			tempConn->netgame = netGame;

   108 			clearCallbacks(tempConn);

   109 			result = tempConn;

   110 			tempConn = NULL;

   111 		}

   112 	}

   113 	flib_gameconn_destroy(tempConn);

   114 	return result;

   115 }

   116 

   117 flib_gameconn *flib_gameconn_create(const char *playerName, flib_cfg_meta *metaconf, flib_gamesetup *setup, bool netgame) {

   118 	flib_gameconn *result = NULL;

   119 	flib_gameconn *tempConn = flib_gameconn_create_partial(true, playerName, netgame);

   120 	if(tempConn) {

   121 		if(fillConfigBuffer(tempConn->configBuffer, playerName, metaconf, setup, netgame) == 0) {

   122 			result = tempConn;

   123 			tempConn = NULL;

   124 		}

   125 	}

   126 	flib_gameconn_destroy(tempConn);

   127 	return result;

   128 }

   129 

   130 flib_gameconn *flib_gameconn_create_playdemo(const uint8_t *demo, int size) {

   131 	flib_gameconn *result = NULL;

   132 	flib_gameconn *tempConn = flib_gameconn_create_partial(false, "Player", false);

   133 	if(tempConn) {

   134 		if(flib_vector_append(tempConn->configBuffer, demo, size) == size) {

   135 			result = tempConn;

   136 			tempConn = NULL;

   137 		}

   138 	}

   139 	flib_gameconn_destroy(tempConn);

   140 	return result;

   141 }

   142 

   143 flib_gameconn *flib_gameconn_create_loadgame(const char *playerName, const uint8_t *save, int size) {

   144 	flib_gameconn *result = NULL;

   145 	flib_gameconn *tempConn = flib_gameconn_create_partial(true, playerName, false);

   146 	if(tempConn) {

   147 		if(flib_vector_append(tempConn->configBuffer, save, size) == size) {

   148 			result = tempConn;

   149 			tempConn = NULL;

   150 		}

   151 	}

   152 	flib_gameconn_destroy(tempConn);

   153 	return result;

   154 }

   155 

   156 void flib_gameconn_destroy(flib_gameconn *conn) {

   157 	if(conn) {

   158 		if(conn->running) {

   159 			/*

   160 			 * The function was called from a callback, so the tick function is still running

   161 			 * and we delay the actual destruction. We ensure no further callbacks will be

   162 			 * sent to prevent surprises.

   163 			 */

   164 			clearCallbacks(conn);

   165 			conn->destroyRequested = true;

   166 		} else {

   167 			flib_ipcconn_destroy(&conn->connection);

   168 			flib_vector_destroy(&conn->configBuffer);

   169 			free(conn);

   170 		}

   171 	}

   172 }

   173 

   174 int flib_gameconn_getport(flib_gameconn *conn) {

   175 	if(!conn) {

   176 		flib_log_e("null parameter in flib_gameconn_getport");

   177 		return 0;

   178 	} else {

   179 		return flib_ipcconn_port(conn->connection);

   180 	}

   181 }

   182 

   183 void flib_gameconn_onConnect(flib_gameconn *conn, void (*callback)(void* context), void* context) {

   184 	if(!conn) {

   185 		flib_log_e("null parameter in flib_gameconn_onConnect");

   186 	} else {

   187 		conn->onConnectCb = callback ? callback : &defaultCallback_onConnect;

   188 		conn->onConnectCtx = context;

   189 	}

   190 }

   191 

   192 void flib_gameconn_onDisconnect(flib_gameconn *conn, void (*callback)(void* context, int reason), void* context) {

   193 	if(!conn) {

   194 		flib_log_e("null parameter in flib_gameconn_onDisconnect");

   195 	} else {

   196 		conn->onDisconnectCb = callback ? callback : &defaultCallback_onDisconnect;

   197 		conn->onDisconnectCtx = context;

   198 	}

   199 }

   200 

   201 void flib_gameconn_onErrorMessage(flib_gameconn *conn, void (*callback)(void* context, const char *msg), void* context) {

   202 	if(!conn) {

   203 		flib_log_e("null parameter in flib_gameconn_onErrorMessage");

   204 	} else {

   205 		conn->onErrorMessageCb = callback ? callback : &defaultCallback_onErrorMessage;

   206 		conn->onErrorMessageCtx = context;

   207 	}

   208 }

   209 

   210 void flib_gameconn_onChat(flib_gameconn *conn, void (*callback)(void* context, const char *msg, bool teamchat), void* context) {

   211 	if(!conn) {

   212 		flib_log_e("null parameter in flib_gameconn_onChat");

   213 	} else {

   214 		conn->onChatCb = callback ? callback : &defaultCallback_onChat;

   215 		conn->onChatCtx = context;

   216 	}

   217 }

   218 

   219 void flib_gameconn_onGameRecorded(flib_gameconn *conn, void (*callback)(void *context, const uint8_t *record, int size, bool isSavegame), void* context) {

   220 	if(!conn) {

   221 		flib_log_e("null parameter in flib_gameconn_onGameRecorded");

   222 	} else {

   223 		conn->onGameRecordedCb = callback ? callback : &defaultCallback_onGameRecorded;

   224 		conn->onGameRecordedCtx = context;

   225 	}

   226 }

   227 

   228 void flib_gameconn_onNetMessage(flib_gameconn *conn, void (*callback)(void *context, const uint8_t *em, int size), void* context) {

   229 	if(!conn) {

   230 		flib_log_e("null parameter in flib_gameconn_onNetMessage");

   231 	} else {

   232 		conn->onNetMessageCb = callback ? callback : &defaultCallback_onNetMessage;

   233 		conn->onNetMessageCtx = context;

   234 	}

   235 }

   236 

   237 static void flib_gameconn_wrappedtick(flib_gameconn *conn) {

   238 	if(conn->state == AWAIT_CONNECTION) {

   239 		flib_ipcconn_accept(conn->connection);

   240 		switch(flib_ipcconn_state(conn->connection)) {

   241 		case IPC_CONNECTED:

   242 			{

   243 				flib_constbuffer configBuffer = flib_vector_as_constbuffer(conn->configBuffer);

   244 				if(flib_ipcconn_send_raw(conn->connection, configBuffer.data, configBuffer.size)) {

   245 					conn->state = FINISHED;

   246 					conn->onDisconnectCb(conn->onDisconnectCtx, GAME_END_ERROR);

   247 					return;

   248 				} else {

   249 					conn->state = CONNECTED;

   250 					conn->onConnectCb(conn->onConnectCtx);

   251 					if(conn->destroyRequested) {

   252 						return;

   253 					}

   254 				}

   255 			}

   256 			break;

   257 		case IPC_NOT_CONNECTED:

   258 			conn->state = FINISHED;

   259 			conn->onDisconnectCb(conn->onDisconnectCtx, GAME_END_ERROR);

   260 			return;

   261 		default:

   262 			break;

   263 		}

   264 	}

   265 

   266 	if(conn->state == CONNECTED) {

   267 		uint8_t msgbuffer[257];

   268 		int len;

   269 		while(!conn->destroyRequested && (len = flib_ipcconn_recv_message(conn->connection, msgbuffer))>=0) {

   270 			if(len<2) {

   271 				flib_log_w("Received short message from IPC (<2 bytes)");

   272 				continue;

   273 			}

   274 			switch(msgbuffer[1]) {

   275 			case '?':

   276 				// The pong is already part of the config message

   277 				break;

   278 			case 'C':

   279 				// And we already send the config message on connecting.

   280 				break;

   281 			case 'E':

   282 				if(len>=3) {

   283 					msgbuffer[len-2] = 0;

   284 					conn->onErrorMessageCb(conn->onErrorMessageCtx, (char*)msgbuffer+2);

   285 				}

   286 				break;

   287 			case 'i':

   288 				// TODO stats

   289 				break;

   290 			case 'Q':

   291 			case 'H':

   292 			case 'q':

   293 				{

   294 					int reason = msgbuffer[1]=='Q' ? GAME_END_INTERRUPTED : msgbuffer[1]=='H' ? GAME_END_HALTED : GAME_END_FINISHED;

   295 					bool savegame = (reason != GAME_END_FINISHED) && !conn->netgame;

   296 					flib_constbuffer record = flib_ipcconn_getrecord(conn->connection, savegame);

   297 					if(record.size) {

   298 						conn->onGameRecordedCb(conn->onGameRecordedCtx, record.data, record.size, savegame);

   299 						if(conn->destroyRequested) {

   300 							return;

   301 						}

   302 					}

   303 					conn->state = FINISHED;

   304 					conn->onDisconnectCb(conn->onDisconnectCtx, reason);

   305 					return;

   306 				}

   307 			case 's':

   308 				if(len>=3) {

   309 					msgbuffer[len-2] = 0;

   310 					conn->onChatCb(conn->onChatCtx, (char*)msgbuffer+2, false);

   311 				}

   312 				break;

   313 			case 'b':

   314 				if(len>=3) {

   315 					msgbuffer[len-2] = 0;

   316 					conn->onChatCb(conn->onChatCtx, (char*)msgbuffer+2, true);

   317 				}

   318 				break;

   319 			default:

   320 				conn->onNetMessageCb(conn->onNetMessageCtx, msgbuffer, len);

   321 				break;

   322 			}

   323 		}

   324 	}

   325 

   326 	if(flib_ipcconn_state(conn->connection) == IPC_NOT_CONNECTED) {

   327 		conn->state = FINISHED;

   328 		conn->onDisconnectCb(conn->onDisconnectCtx, GAME_END_ERROR);

   329 	}

   330 }

   331 

   332 void flib_gameconn_tick(flib_gameconn *conn) {

   333 	if(!conn) {

   334 		flib_log_e("null parameter in flib_gameconn_tick");

   335 	} else if(conn->running) {

   336 		flib_log_w("Call to flib_gameconn_tick from a callback");

   337 	} else if(conn->state == FINISHED) {

   338 		flib_log_w("Call to flib_gameconn_tick, but we are already done.");

   339 	} else {

   340 		conn->running = true;

   341 		flib_gameconn_wrappedtick(conn);

   342 		conn->running = false;

   343 

   344 		if(conn->destroyRequested) {

   345 			flib_gameconn_destroy(conn);

   346 		}

   347 	}

   348 }