project_files/frontlib/ipc/gameconn.c
changeset 7275 15f722e0b96f
parent 7271 5608ac657362
child 7314 6171f0bad318
equal deleted inserted replaced
7273:8eed495fd8da 7275:15f722e0b96f
    36 	void *onChatCtx;
    36 	void *onChatCtx;
    37 
    37 
    38 	void (*onGameRecordedCb)(void *context, const uint8_t *record, int size, bool isSavegame);
    38 	void (*onGameRecordedCb)(void *context, const uint8_t *record, int size, bool isSavegame);
    39 	void *onGameRecordedCtx;
    39 	void *onGameRecordedCtx;
    40 
    40 
    41 	void (*onEngineMessageCb)(void *context, const uint8_t *em, int size);
    41 	void (*onEngineMessageCb)(void *context, const uint8_t *em, size_t size);
    42 	void *onEngineMessageCtx;
    42 	void *onEngineMessageCtx;
    43 
    43 
    44 	bool running;
    44 	bool running;
    45 	bool destroyRequested;
    45 	bool destroyRequested;
    46 };
    46 };
    50 static void defaultCallback_onErrorMessage(void* context, const char *msg) {
    50 static void defaultCallback_onErrorMessage(void* context, const char *msg) {
    51 	flib_log_w("Error from engine (no callback set): %s", msg);
    51 	flib_log_w("Error from engine (no callback set): %s", msg);
    52 }
    52 }
    53 static void defaultCallback_onChat(void* context, const char *msg, bool teamchat) {}
    53 static void defaultCallback_onChat(void* context, const char *msg, bool teamchat) {}
    54 static void defaultCallback_onGameRecorded(void *context, const uint8_t *record, int size, bool isSavegame) {}
    54 static void defaultCallback_onGameRecorded(void *context, const uint8_t *record, int size, bool isSavegame) {}
    55 static void defaultCallback_onEngineMessage(void *context, const uint8_t *em, int size) {}
    55 static void defaultCallback_onEngineMessage(void *context, const uint8_t *em, size_t size) {}
    56 
    56 
    57 static void clearCallbacks(flib_gameconn *conn) {
    57 static void clearCallbacks(flib_gameconn *conn) {
    58 	conn->onConnectCb = &defaultCallback_onConnect;
    58 	conn->onConnectCb = &defaultCallback_onConnect;
    59 	conn->onDisconnectCb = &defaultCallback_onDisconnect;
    59 	conn->onDisconnectCb = &defaultCallback_onDisconnect;
    60 	conn->onErrorMessageCb = &defaultCallback_onErrorMessage;
    60 	conn->onErrorMessageCb = &defaultCallback_onErrorMessage;
    63 	conn->onEngineMessageCb = &defaultCallback_onEngineMessage;
    63 	conn->onEngineMessageCb = &defaultCallback_onEngineMessage;
    64 }
    64 }
    65 
    65 
    66 static flib_gameconn *flib_gameconn_create_partial(bool record, const char *playerName, bool netGame) {
    66 static flib_gameconn *flib_gameconn_create_partial(bool record, const char *playerName, bool netGame) {
    67 	flib_gameconn *result = NULL;
    67 	flib_gameconn *result = NULL;
    68 	flib_gameconn *tempConn = flib_calloc(1, sizeof(flib_gameconn));
    68 	if(!log_badparams_if(!playerName)) {
    69 	if(tempConn) {
    69 		flib_gameconn *tempConn = flib_calloc(1, sizeof(flib_gameconn));
    70 		tempConn->ipcBase = flib_ipcbase_create();
    70 		if(tempConn) {
    71 		tempConn->configBuffer = flib_vector_create();
    71 			tempConn->ipcBase = flib_ipcbase_create();
    72 		tempConn->playerName = flib_strdupnull(playerName);
    72 			tempConn->configBuffer = flib_vector_create();
    73 		if(tempConn->ipcBase && tempConn->configBuffer && tempConn->playerName) {
    73 			tempConn->playerName = flib_strdupnull(playerName);
    74 			if(record) {
    74 			if(tempConn->ipcBase && tempConn->configBuffer && tempConn->playerName) {
    75 				tempConn->demoBuffer = flib_vector_create();
    75 				if(record) {
       
    76 					tempConn->demoBuffer = flib_vector_create();
       
    77 				}
       
    78 				tempConn->state = AWAIT_CONNECTION;
       
    79 				tempConn->netgame = netGame;
       
    80 				clearCallbacks(tempConn);
       
    81 				result = tempConn;
       
    82 				tempConn = NULL;
    76 			}
    83 			}
    77 			tempConn->state = AWAIT_CONNECTION;
    84 		}
    78 			tempConn->netgame = netGame;
    85 		flib_gameconn_destroy(tempConn);
    79 			clearCallbacks(tempConn);
    86 	}
    80 			result = tempConn;
       
    81 			tempConn = NULL;
       
    82 		}
       
    83 	}
       
    84 	flib_gameconn_destroy(tempConn);
       
    85 	return result;
    87 	return result;
    86 }
    88 }
    87 
    89 
    88 flib_gameconn *flib_gameconn_create(const char *playerName, const flib_gamesetup *setup, bool netgame) {
    90 flib_gameconn *flib_gameconn_create(const char *playerName, const flib_gamesetup *setup, bool netgame) {
    89 	flib_gameconn *result = NULL;
    91 	flib_gameconn *result = NULL;
    90 	flib_gameconn *tempConn = flib_gameconn_create_partial(true, playerName, netgame);
    92 	flib_gameconn *tempConn = flib_gameconn_create_partial(true, playerName, netgame);
    91 	if(tempConn) {
    93 	if(tempConn) {
    92 		if(!flib_ipc_append_fullconfig(tempConn->configBuffer, setup, netgame)) {
    94 		if(flib_ipc_append_fullconfig(tempConn->configBuffer, setup, netgame)) {
       
    95 			flib_log_e("Error generating full game configuration for the engine.");
       
    96 		} else {
    93 			result = tempConn;
    97 			result = tempConn;
    94 			tempConn = NULL;
    98 			tempConn = NULL;
    95 		}
    99 		}
    96 	}
   100 	}
    97 	flib_gameconn_destroy(tempConn);
   101 	flib_gameconn_destroy(tempConn);
   100 
   104 
   101 flib_gameconn *flib_gameconn_create_playdemo(const uint8_t *demo, int size) {
   105 flib_gameconn *flib_gameconn_create_playdemo(const uint8_t *demo, int size) {
   102 	flib_gameconn *result = NULL;
   106 	flib_gameconn *result = NULL;
   103 	flib_gameconn *tempConn = flib_gameconn_create_partial(false, "Player", false);
   107 	flib_gameconn *tempConn = flib_gameconn_create_partial(false, "Player", false);
   104 	if(tempConn) {
   108 	if(tempConn) {
   105 		if(flib_vector_append(tempConn->configBuffer, demo, size) == size) {
   109 		if(!flib_vector_append(tempConn->configBuffer, demo, size)) {
   106 			result = tempConn;
   110 			result = tempConn;
   107 			tempConn = NULL;
   111 			tempConn = NULL;
   108 		}
   112 		}
   109 	}
   113 	}
   110 	flib_gameconn_destroy(tempConn);
   114 	flib_gameconn_destroy(tempConn);
   113 
   117 
   114 flib_gameconn *flib_gameconn_create_loadgame(const char *playerName, const uint8_t *save, int size) {
   118 flib_gameconn *flib_gameconn_create_loadgame(const char *playerName, const uint8_t *save, int size) {
   115 	flib_gameconn *result = NULL;
   119 	flib_gameconn *result = NULL;
   116 	flib_gameconn *tempConn = flib_gameconn_create_partial(true, playerName, false);
   120 	flib_gameconn *tempConn = flib_gameconn_create_partial(true, playerName, false);
   117 	if(tempConn) {
   121 	if(tempConn) {
   118 		if(flib_vector_append(tempConn->configBuffer, save, size) == size) {
   122 		if(!flib_vector_append(tempConn->configBuffer, save, size)) {
   119 			result = tempConn;
   123 			result = tempConn;
   120 			tempConn = NULL;
   124 			tempConn = NULL;
   121 		}
   125 		}
   122 	}
   126 	}
   123 	flib_gameconn_destroy(tempConn);
   127 	flib_gameconn_destroy(tempConn);
   159 		}
   163 		}
   160 	}
   164 	}
   161 }
   165 }
   162 
   166 
   163 int flib_gameconn_getport(flib_gameconn *conn) {
   167 int flib_gameconn_getport(flib_gameconn *conn) {
   164 	if(!conn) {
   168 	if(!log_badparams_if(!conn)) {
   165 		flib_log_e("null parameter in flib_gameconn_getport");
       
   166 		return 0;
       
   167 	} else {
       
   168 		return flib_ipcbase_port(conn->ipcBase);
   169 		return flib_ipcbase_port(conn->ipcBase);
   169 	}
   170 	}
       
   171 	return 0;
   170 }
   172 }
   171 
   173 
   172 static void demo_append(flib_gameconn *conn, const void *data, size_t len) {
   174 static void demo_append(flib_gameconn *conn, const void *data, size_t len) {
   173 	if(conn->demoBuffer) {
   175 	if(conn->demoBuffer) {
   174 		if(flib_vector_append(conn->demoBuffer, data, len) < len) {
   176 		if(flib_vector_append(conn->demoBuffer, data, len)) {
   175 			flib_log_e("Error recording demo: Out of memory.");
   177 			flib_log_e("Error recording demo: Out of memory.");
   176 			flib_vector_destroy(conn->demoBuffer);
   178 			flib_vector_destroy(conn->demoBuffer);
   177 			conn->demoBuffer = NULL;
   179 			conn->demoBuffer = NULL;
   178 		}
   180 		}
   179 	}
   181 	}
   211 		}
   213 		}
   212 		msgStart += (uint8_t)data[msgStart]+1;
   214 		msgStart += (uint8_t)data[msgStart]+1;
   213 	}
   215 	}
   214 }
   216 }
   215 
   217 
   216 int flib_gameconn_send_enginemsg(flib_gameconn *conn, uint8_t *data, int len) {
   218 int flib_gameconn_send_enginemsg(flib_gameconn *conn, const uint8_t *data, size_t len) {
   217 	int result = -1;
   219 	int result = -1;
   218 	if(!conn || (!data && len>0)) {
   220 	if(!log_badparams_if(!conn || (!data && len>0))
   219 		flib_log_e("null parameter in flib_gameconn_send_enginemsg");
   221 			&& !flib_ipcbase_send_raw(conn->ipcBase, data, len)) {
   220 	} else if(!flib_ipcbase_send_raw(conn->ipcBase, data, len)) {
       
   221 		demo_append(conn, data, len);
   222 		demo_append(conn, data, len);
   222 		result = 0;
   223 		result = 0;
   223 	}
   224 	}
   224 	return result;
   225 	return result;
   225 }
   226 }
   299 		conn->onGameRecordedCb = callback ? callback : &defaultCallback_onGameRecorded;
   300 		conn->onGameRecordedCb = callback ? callback : &defaultCallback_onGameRecorded;
   300 		conn->onGameRecordedCtx = context;
   301 		conn->onGameRecordedCtx = context;
   301 	}
   302 	}
   302 }
   303 }
   303 
   304 
   304 void flib_gameconn_onEngineMessage(flib_gameconn *conn, void (*callback)(void *context, const uint8_t *em, int size), void* context) {
   305 void flib_gameconn_onEngineMessage(flib_gameconn *conn, void (*callback)(void *context, const uint8_t *em, size_t size), void* context) {
   305 	if(!conn) {
   306 	if(!conn) {
   306 		flib_log_e("null parameter in flib_gameconn_onEngineMessage");
   307 		flib_log_e("null parameter in flib_gameconn_onEngineMessage");
   307 	} else {
   308 	} else {
   308 		conn->onEngineMessageCb = callback ? callback : &defaultCallback_onEngineMessage;
   309 		conn->onEngineMessageCb = callback ? callback : &defaultCallback_onEngineMessage;
   309 		conn->onEngineMessageCtx = context;
   310 		conn->onEngineMessageCtx = context;