volatile sig_atomic_t sig_stop;
#include "gameserver.h"
-#include "highscores.c"
-#include "servermonitor_server.c"
#include "vg/vg_opt.h"
#include "network_common.h"
#include "gameserver_db.h"
alloca( sizeof(netmsg_playeritem) + ADDON_UID_MAX );
item->inetmsg_id = k_inetmsg_playeritem;
+ netmsg_region *region = alloca( sizeof(netmsg_region) + NETWORK_REGION_MAX );
+ region->inetmsg_id = k_inetmsg_region;
+
for( int i=0; i<vg_list_size(gameserver.clients); i++ ){
struct gameserver_client *client = &gameserver.clients[i];
/* items */
for( int j=0; j<k_netmsg_playeritem_max; j++ ){
- chs = vg_strncpy( client->items[j], item->uid, ADDON_UID_MAX,
+ chs = vg_strncpy( client->items[j].uid, item->uid, ADDON_UID_MAX,
k_strncpy_always_add_null );
item->type_index = j;
item->client = i;
gameserver_send_to_client( index, item, size,
k_nSteamNetworkingSend_Reliable );
}
+
+ /* region */
+
+ region->client = i;
+ region->flags = client->region_flags;
+ u32 l = vg_strncpy( client->region, region->loc, NETWORK_REGION_MAX,
+ k_strncpy_always_add_null );
+ size = sizeof(netmsg_region) + l + 1;
+
+ gameserver_send_to_client( index, region, size,
+ k_nSteamNetworkingSend_Reliable );
}
}
k_nSteamNetworkingSend_Reliable );
}
+static void gameserver_update_all_knowledge( int client, int clear );
+
/*
* Deletes client at index and disconnects the connection handle if it was
* set.
NULL, 1 );
}
memset( client, 0, sizeof(struct gameserver_client) );
+ gameserver_update_all_knowledge( index, 1 );
}
/*
db_updateuser( inf->steamid, inf->username, admin );
}
+static int gameserver_item_eq( struct gameserver_item *ia,
+ struct gameserver_item *ib ){
+ if( ia->hash == ib->hash )
+ if( !strcmp(ia->uid,ib->uid) )
+ return 1;
+
+ return 0;
+}
+
+/*
+ * Match addons between two player IDs. if clear is set, then the flags between
+ * those two IDs will all be set to 0.
+ */
+static void gameserver_update_knowledge_table( int client0, int client1,
+ int clear ){
+ u32 idx = network_pair_index( client0, client1 );
+
+ struct gameserver_client *c0 = &gameserver.clients[client0],
+ *c1 = &gameserver.clients[client1];
+
+ u8 flags = 0x00;
+
+ if( !clear ){
+ if( gameserver_item_eq(&c0->items[k_netmsg_playeritem_world0],
+ &c1->items[k_netmsg_playeritem_world0]))
+ flags |= CLIENT_KNOWLEDGE_SAME_WORLD0;
+
+ if( gameserver_item_eq(&c0->items[k_netmsg_playeritem_world1],
+ &c1->items[k_netmsg_playeritem_world1]))
+ flags |= CLIENT_KNOWLEDGE_SAME_WORLD1;
+ }
+
+ gameserver.client_knowledge_mask[idx] = flags;
+}
+
+/*
+ * If a change has been made on this client, then it will adjust the entire
+ * table of other players. if clear is set, all references to client will be set
+ * to 0.
+ */
+static void gameserver_update_all_knowledge( int client, int clear ){
+ for( int i=0; i<NETWORK_MAX_PLAYERS; i ++ ){
+ if( i == client )
+ continue;
+
+ struct gameserver_client *ci = &gameserver.clients[i];
+
+ if( ci->steamid )
+ gameserver_update_knowledge_table( client, i, clear );
+ }
+}
+
+static void gameserver_propogate_player_frame( int client_id,
+ netmsg_playerframe *frame,
+ u32 size ){
+ u32 basic_size = sizeof(netmsg_playerframe) + ((24*3)/8);
+ netmsg_playerframe *full = alloca(size),
+ *basic= alloca(basic_size);
+
+ memcpy( full, frame, size );
+ memcpy( basic, frame, basic_size );
+
+ full->client = client_id;
+ basic->client = client_id;
+ basic->subsystem = 4; /* (.._basic_info: 24f*3 animator ) */
+ basic->sound_effects = 0;
+
+ struct gameserver_client *c0 = &gameserver.clients[client_id];
+ c0->instance = frame->flags & NETMSG_PLAYERFRAME_INSTANCE_ID;
+
+ for( int i=0; i<vg_list_size(gameserver.clients); i++ ){
+ if( i == client_id )
+ continue;
+
+ struct gameserver_client *ci = &gameserver.clients[i];
+
+ int send_full = 0;
+
+ if( c0->instance == ci->instance ){
+ u32 k_index = network_pair_index( client_id, i );
+ u8 k_mask = gameserver.client_knowledge_mask[ k_index ];
+
+ if( (k_mask & (CLIENT_KNOWLEDGE_SAME_WORLD0<<c0->instance)) )
+ send_full = 1;
+ }
+
+ if( send_full ){
+ gameserver_send_to_client( i, full, size,
+ k_nSteamNetworkingSend_Unreliable );
+ }
+ else {
+ gameserver_send_to_client( i, basic, basic_size,
+ k_nSteamNetworkingSend_Unreliable );
+ }
+ }
+}
+
static void gameserver_rx_200_300( SteamNetworkingMessage_t *msg ){
netmsg_blank *tmp = msg->m_pData;
db_send_request( call );
}
else if( tmp->inetmsg_id == k_inetmsg_playerframe ){
- /* propogate */
- netmsg_playerframe *frame = alloca(msg->m_cbSize);
- memcpy( frame, msg->m_pData, msg->m_cbSize );
- frame->client = client_id;
- gameserver_send_to_all( client_id, frame, msg->m_cbSize,
- k_nSteamNetworkingSend_Unreliable );
+ gameserver_propogate_player_frame( client_id,
+ msg->m_pData, msg->m_cbSize );
}
else if( tmp->inetmsg_id == k_inetmsg_playeritem ){
netmsg_playeritem *item = msg->m_pData;
return;
}
- char *dest = client->items[ item->type_index ];
+ char *dest = client->items[ item->type_index ].uid;
network_msgstring( item->uid, msg->m_cbSize, sizeof(netmsg_playeritem),
dest, ADDON_UID_MAX );
[k_netmsg_playeritem_world0]="world0",
[k_netmsg_playeritem_world1]="world1"
}[item->type_index], item->uid );
+
+ gameserver_update_all_knowledge( client_id, 0 );
/* propogate */
netmsg_playeritem *prop = alloca(msg->m_cbSize);
gameserver_send_to_all( client_id, prop, sizeof(netmsg_chat)+l+1,
k_nSteamNetworkingSend_Reliable );
}
+ else if( tmp->inetmsg_id == k_inetmsg_region ){
+ netmsg_region *region = msg->m_pData,
+ *prop = alloca( sizeof(netmsg_region) + NETWORK_REGION_MAX );
+
+ prop->inetmsg_id = k_inetmsg_region;
+ prop->client = client_id;
+ prop->flags = region->flags;
+
+ u32 l = network_msgstring(
+ region->loc, msg->m_cbSize, sizeof(netmsg_region),
+ client->region, NETWORK_REGION_MAX );
+ client->region_flags = region->flags;
+
+ l = vg_strncpy( client->region, prop->loc, NETWORK_REGION_MAX,
+ k_strncpy_always_add_null );
+
+ gameserver_send_to_all( client_id, prop, sizeof(netmsg_region)+l+1,
+ k_nSteamNetworkingSend_Reliable );
+ vg_info( "client %d moved to region: %s\n", client_id, client->region );
+ }
else {
vg_warn( "Unknown inetmsg_id recieved from client. (%u)\n",
tmp->inetmsg_id );
vg_strnull( &q, buf, 512 );
vg_strcat( &q, "SELECT * FROM \"" );
vg_strcat( &q, table_name );
- vg_strcat( &q, "\" ORDER BY time DESC LIMIT 10;" );
+ vg_strcat( &q, "\" ORDER BY time ASC LIMIT 10;" );
if( !vg_strgood(&q) )
return k_request_status_out_of_memory;
vg_msg_init( &data, req->q, msg->m_cbSize - sizeof(netmsg_request) );
/* create response packet */
- netmsg_request *res = alloca( sizeof(netmsg_request) + 512 );
+ netmsg_request *res = alloca( sizeof(netmsg_request) + NETWORK_REQUEST_MAX );
res->inetmsg_id = k_inetmsg_response;
res->id = req->id;
vg_msg body;
- vg_msg_init( &body, res->q, 512 );
+ vg_msg_init( &body, res->q, NETWORK_REQUEST_MAX );
const char *endpoint = vg_msg_getkvstr( &data, "endpoint" );
return s / 0.01;
}
-static void test_runner( db_request *req ){
- vg_warn( "RUNNER\n" );
- char table[DB_TABLE_UID_MAX];
- if( db_get_highscore_table_name( "sr002-local-mp_mtzero",
- "Coastal Run", 0, table ) ){
- if( db_writeusertime( table, 76561198072130043, 232, 1 ) ){
- vg_success( "Written time\n" );
- i32 v = db_readusertime( table, 76561198072130043 );
- vg_success( "Returned time: %u\n", v );
- }
- }
-}
-
int main( int argc, char *argv[] ){
signal( SIGINT, inthandler );
signal( SIGQUIT, inthandler );
while( vg_argp( argc, argv ) ){
if( vg_long_opt( "noauth" ) )
gameserver.auth_mode = eServerModeNoAuthentication;
-
- /* TODO: Options to override, ammend, remove etc */
}
vg_set_mem_quota( 80*1024*1024 );
vg_alloc_quota();
-
db_init();
- db_request *req = db_alloc_request(0);
- if( req ){
- req->handler = test_runner;
- db_send_request(req);
- }
-
- monitor_start_server(); /* UNIX socket monitor */
/* steamworks init
* --------------------------------------------------------------- */
u64 server_ticks = 8000,
last_record_save = 8000,
- last_scoreboard_gen = 0,
- last_monitor_heartbeat = 0;
+ last_scoreboard_gen = 0;
while( !sig_stop ){
- monitor_event_loop();
steamworks_event_loop( hsteampipe );
poll_connections();
usleep(10000);
server_ticks ++;
- if( server_ticks >
- (last_monitor_heartbeat + seconds_to_server_ticks(10.0))){
- last_monitor_heartbeat = server_ticks;
- monitor_heartbeat();
- }
-
if( db_killed() )
break;
}
projects / carveJwlIkooP6JGAAIwe30JlM.git / blobdiff