#include "src/model.c"
#include "src/array_file.c"
+
/*
* Addon metadata utilities
* -------------------------------------------------------------------------- */
.steam_api = 1,
.use_3d = 1,
.custom_game_settings = 0,
- .custom_shaders = 1
+ .custom_shaders = 1,
+ .multiplayer = 1
},
env, &conf, "src/client.c", "skaterift" );
#endif
vg_str sources = {0};
- vg_strcat( &sources, "src/gameserver.c vg/vg_tool.c vg/vg_steam.c \\\n " );
+ vg_strcat( &sources, "src/gameserver.c vg/vg_tool.c vg/vg_steam2.c \\\n " );
#if 0
vg_strcat( &sources, sqlite.path.buffer );
#endif
struct vg_compiler_conf conf = {0};
vg_strcat( &conf.include, "-Isrc -I./dep " );
- vg_strcat( &conf.include, "-I. -I./vg -I./vg/dep -DVG_MULTITHREAD " );
+ vg_strcat( &conf.include, "-I. -I./vg -I./vg/dep -DVG_MULTITHREAD -DVG_SERVER " );
vg_strcat( &conf.library, "-L./vg/dep/steam " );
- vg_strcat( &conf.link, "-ldl -lpthread -lm "
- "-lsdkencryptedappticket -lsteam_api " );
+ vg_strcat( &conf.link, "-ldl -lm "
+ "-lsteam_api -lsdkencryptedappticket -pthread " );
vg_add_blob( proj, "vg/dep/steam/libsteam_api.so", "" );
vg_add_blob( proj, "vg/dep/steam/libsdkencryptedappticket.so", "" );
.log_source_info = 1,
.use_3d = 0,
.custom_game_settings = 0,
- .custom_shaders = 0
+ .custom_shaders = 0,
+ .multiplayer = 0
},
env, &conf, "src/utest.c", "utest" );
+++ /dev/null
-static bool _skaterift_script_valley( ent_script_event *event )
-{
- if( on_nugget_once( event, "ch4s1a_view" ) )
- {
- /* ch4s1: Mike and you are first encountering the valley world */
- static const struct cs_subtitle EN[] =
- {
- { "m1", KCOL_MIKE "It's gotta be some kind of dream right?" },
- { "m2", KCOL_MIKE "I mean... Cambodia?" },
- { "m3", KCOL_MIKE "What are we even doing here?" },
- { NULL, NULL },
- };
- _cutscene_load_and_play( "metascenes/ch4s1a.ms", EN, 1 );
- }
-
- /* main region is completed (this is just the time trial as of 14.05.25, unlock ch4s2 */
- if( on_function_trigger( event, 27 ) )
- {
- if( _skaterift_script_nugget_status( "ch4s2_view" ) == 0 )
- _skaterift_script_nugget_set( "ch4s2_view", 2 );
- }
-
- /* unlock the finale challenge stuff if we've seen ch4s1 (mike bails) */
- u64 status;
- if( on_nugget_changed( event, "ch4s1_view", &status ) )
- {
- _ent_list_set_visible( _ent_list_get_aliased( "finale:locked" ), status != 1 );
- _ent_list_set_visible( _ent_list_get_aliased( "finale:unlocked" ), status == 1 );
- }
-
- /* finale completed, trigger the exit movie */
- if( on_function_trigger( event, 21 ) )
- {
- // TODOX1
- vg_success( "Exit for a movie\n" );
- }
-
- return 1;
-}
-
-static bool _skaterift_script_ch4s2( ent_script_event *event )
-{
- /* ch4s2: Mike and you find the rocket, and talk to the FBI person. */
- u64 status;
- if( on_nugget_changed( event, "ch4s2_view", &status ) )
- {
- _ent_list_set_visible( event->entity_list, status == 2 );
- _ent_list_set_visible( _ent_list_get_aliased( "rocket" ), status >= 1 );
- }
-
- if( on_function_trigger( event, 0 ) )
- {
- if( on_nugget_once( event, "ch4s2_view" ) )
- {
- static const struct cs_subtitle EN[] =
- {
- { "m1", KCOL_MIKE "What the hell is that thing?" },
- { "f1", KCOL_FBI "Look man, all they told is that uhh" },
- { "f2", KCOL_FBI "they're sending you up to one of saturns moons.." },
- { "f3", KCOL_FBI "On that thing." },
- { "f4", KCOL_FBI "To help you on your mission." },
- { "f5", KCOL_FBI "You guys are more important than any person on earth right now" },
- { "f6", KCOL_FBI "According to the president." },
- { "f7", KCOL_FBI "But obviously this is some kind of joke I'm not in on." },
- { "f8", KCOL_FBI "I don't believe a word of it." },
- { NULL, NULL },
- };
- _cutscene_load_and_play( "metascenes/ch4s2.ms", EN, 1 );
- }
- }
-
- return 1;
-}
-
-static bool _skaterift_script_ch4s1( ent_script_event *event )
-{
- /* ch4s1: (Yes, this comes after ch4s2), Mike is leaving, because JC hasn't shown up anywhere. */
- return 1;
-}
-
-static bool _skaterift_script_ch4s3( ent_script_event *event )
-{
- // on venus
- return 1;
-}
#include "addon.h"
#include "addon_types.h"
#include "vg/vg_msg.h"
-#include "steam.h"
+#include "vg/vg_steam2.h"
#include "workshop.h"
#include <string.h>
return;
}
- if( !steam_ready )
+ if( _steam_api.disabled )
return;
- ISteamUGC *hSteamUGC = SteamAPI_SteamUGC();
-
if( !co_task )
{
vg_async_task *task = vg_allocate_async_task( &vg.loader_tasks, sizeof(struct workshop_scan_info), 1 );
struct workshop_scan_info *info = (void *)task->data;
info->state = k_workshop_scan_state_filter_mounted;
- u32 count = SteamAPI_ISteamUGC_GetSubscribedItems( hSteamUGC, info->workshop_ids, ADDON_MOUNTED_MAX );
+ u32 count = SteamAPI_ISteamUGC_GetSubscribedItems( _steam_api.pSteamUGC, info->workshop_ids, ADDON_MOUNTED_MAX, 0 );
vg_info( "Found %u subscribed items\n", count );
u32 send_count = 0;
for( u32 i=0; i<count; i++ )
{
- u32 state = SteamAPI_ISteamUGC_GetItemState( hSteamUGC, info->workshop_ids[i] );
+ u32 state = SteamAPI_ISteamUGC_GetItemState( _steam_api.pSteamUGC, info->workshop_ids[i] );
if( !(state & k_EItemStateInstalled) )
continue;
u64 _size;
u32 _ts;
- if( !SteamAPI_ISteamUGC_GetItemInstallInfo( hSteamUGC, co_info->workshop_ids[i],
+ if( !SteamAPI_ISteamUGC_GetItemInstallInfo( _steam_api.pSteamUGC, co_info->workshop_ids[i],
&_size, path, sizeof(path), &_ts ))
{
vg_error( "GetItemInstallInfo failed for addon %lu\n", co_info->workshop_ids[i] );
addon_reg *reg = addon_details( addon_id );
if( reg->alias.steam_workshop_id )
{
- ISteamUGC *hSteamUGC = SteamAPI_SteamUGC();
u64 _size;
u32 _ts;
- if( !SteamAPI_ISteamUGC_GetItemInstallInfo( hSteamUGC, reg->alias.steam_workshop_id, &_size,
+ if( !SteamAPI_ISteamUGC_GetItemInstallInfo( _steam_api.pSteamUGC, reg->alias.steam_workshop_id, &_size,
folder->buffer, folder->len, &_ts ))
{
vg_error( "GetItemInstallInfo failed for addon %lu\n", reg->alias.steam_workshop_id );
#pragma once
-#include "vg/vg_steam_ugc.h"
+#include "vg/vg_steam2.h"
#include "vg/vg_mem_pool.h"
#include "vg/vg_string.h"
#include "addon_types.h"
struct game_client
{
- bool demo_mode, nosteam;
+ bool demo_mode;
}
extern g_client;
vg_console_reg_cmd( "atom", _ent_atom_ccmd, _ent_atom_ccmd_poll );
}
+void _ent_atom_init(void)
+{
+ THREAD_0;
+
+ if( _steam_api.disabled )
+ return;
+
+ bool set = 0;
+ if( SteamAPI_ISteamUserStats_GetAchievement( _steam_api.pSteamUserStats, "MARC", &set ) )
+ {
+ if( set ) _atom_set( k_atom_list_global, "MARC", 1 );
+ }
+ if( SteamAPI_ISteamUserStats_GetAchievement( _steam_api.pSteamUserStats, "ALBERT", &set ) )
+ {
+ if( set ) _atom_set( k_atom_list_global, "ALBERT", 1 );
+ }
+ if( SteamAPI_ISteamUserStats_GetAchievement( _steam_api.pSteamUserStats, "JANET", &set ) )
+ {
+ if( set ) _atom_set( k_atom_list_global, "JANET", 1 );
+ }
+ if( SteamAPI_ISteamUserStats_GetAchievement( _steam_api.pSteamUserStats, "BERNADETTA", &set ) )
+ {
+ if( set ) _atom_set( k_atom_list_global, "BERNADETTA", 1 );
+ }
+}
entity_event_result _ent_atom_event( ent_event *event );
void _ent_atom_register(void);
+void _ent_atom_init(void);
#include "world_load.h"
#include "entity.h"
#include "audio.h"
-#include "steam.h"
+#include "vg/vg_steam2.h"
#include "ent_region.h"
#include "player.h"
#include "player_skate.h"
if( world_reg->flags & ADDON_REG_MTZERO )
{
if( world_total & k_ent_route_flag_achieve_gold )
- {
- steam_set_achievement( "MTZERO_GOLD" );
- steam_store_achievements();
- }
+ vg_steam_set_achievement( "MTZERO_GOLD", 1 );
if( world_total & k_ent_route_flag_achieve_silver )
- {
- steam_set_achievement( "MTZERO_SILVER" );
- steam_store_achievements();
- }
+ vg_steam_set_achievement( "MTZERO_SILVER", 1 );
}
else if( world_reg->flags & ADDON_REG_CITY )
{
if( world_total & k_ent_route_flag_achieve_silver )
- {
- steam_set_achievement( "CITY_COMPLETE" );
- steam_store_achievements();
- }
+ vg_steam_set_achievement( "CITY_COMPLETE", 1 );
}
}
-#include "vg/vg_steam_ugc.h"
+#include "vg/vg_steam2.h"
#include "vg/vg_msg.h"
#include "vg/vg_tex.h"
#include "vg/vg_image.h"
#include "player.h"
#include "gui.h"
#include "menu.h"
-#include "steam.h"
#include "addon.h"
#include "save.h"
#include "network.h"
#include "world.h"
#include "world_load.h"
#include "player.h"
-#include "vg/vg_steam_remote_storage.h"
+#include "vg/vg_steam2.h"
#include "workshop.h"
#include "addon.h"
*/
#define _DEFAULT_SOURCE
-#define VG_SERVER
#include <signal.h>
#include <unistd.h>
#include <time.h>
static u64 const k_steamid_max = 0xffffffffffffffff;
-ISteamNetworkingSockets *hSteamNetworkingSockets;
-ISteamNetworkingUtils *hSteamNetworkingUtils;
-
static void segvhandler( int signum )
{
fflush(NULL);
- abort();
+ exit(-1);
}
static void inthandler( int signum )
return;
_gameserver.bytes_send += cbData;
- SteamAPI_ISteamNetworkingSockets_SendMessageToConnection( hSteamNetworkingSockets, client->connection,
+ SteamAPI_ISteamNetworkingSockets_SendMessageToConnection( _steam_api.pSteamNetworkingSockets, client->connection,
pData, cbData, nSendFlags, NULL );
}
netmsg_version version;
version.inetmsg_id = k_inetmsg_version;
version.version = NETWORK_SKATERIFT_VERSION;
- SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
- hSteamNetworkingSockets, client->connection,
+ SteamAPI_ISteamNetworkingSockets_SendMessageToConnection( _steam_api.pSteamNetworkingSockets, client->connection,
&version, sizeof(netmsg_version),
k_nSteamNetworkingSend_Reliable, NULL );
}
{
struct gameserver_client *joiner = &_gameserver.clients[index];
- SteamAPI_ISteamNetworkingSockets_ConfigureConnectionLanes( hSteamNetworkingSockets, joiner->connection, 2,
+ SteamAPI_ISteamNetworkingSockets_ConfigureConnectionLanes( _steam_api.pSteamNetworkingSockets, joiner->connection, 2,
(int[]){ 0,0 }, (u16[]){ 10, 1 } );
netmsg_playerjoin join = { .inetmsg_id = k_inetmsg_playerjoin,
struct gameserver_client *client = &_gameserver.clients[index];
if( client->connection )
{
- SteamAPI_ISteamNetworkingSockets_SetConnectionUserData( hSteamNetworkingSockets, client->connection, -1 );
- SteamAPI_ISteamNetworkingSockets_CloseConnection( hSteamNetworkingSockets, client->connection,
+ SteamAPI_ISteamNetworkingSockets_SetConnectionUserData( _steam_api.pSteamNetworkingSockets, client->connection, -1 );
+ SteamAPI_ISteamNetworkingSockets_CloseConnection( _steam_api.pSteamNetworkingSockets, client->connection,
k_ESteamNetConnectionEnd_Misc_InternalError, NULL, 1 );
}
_gs_requests_client_disconnect( index );
*/
static void handle_new_connection( HSteamNetConnection conn )
{
- SteamAPI_ISteamNetworkingSockets_SetConnectionUserData( hSteamNetworkingSockets, conn, -1 );
+ SteamAPI_ISteamNetworkingSockets_SetConnectionUserData( _steam_api.pSteamNetworkingSockets, conn, -1 );
int index = -1;
{
_gs_monitor_journal( 0, "// BAD!! Hit Player limit!\n" );
vg_error( "Server full\n" );
- SteamAPI_ISteamNetworkingSockets_CloseConnection( hSteamNetworkingSockets, conn, 4500, NULL, 1 );
+ SteamAPI_ISteamNetworkingSockets_CloseConnection( _steam_api.pSteamNetworkingSockets, conn, 4500, NULL, 1 );
return;
}
struct gameserver_client *client = &_gameserver.clients[index];
- EResult accept_status = SteamAPI_ISteamNetworkingSockets_AcceptConnection( hSteamNetworkingSockets, conn );
+ EResult accept_status = SteamAPI_ISteamNetworkingSockets_AcceptConnection( _steam_api.pSteamNetworkingSockets, conn );
if( accept_status == k_EResultOK )
{
client->active = 1;
client->connection = conn;
- SteamAPI_ISteamNetworkingSockets_SetConnectionPollGroup( hSteamNetworkingSockets, conn, _gameserver.client_group );
- SteamAPI_ISteamNetworkingSockets_SetConnectionUserData( hSteamNetworkingSockets, conn, index );
+ SteamAPI_ISteamNetworkingSockets_SetConnectionPollGroup( _steam_api.pSteamNetworkingSockets, conn, _gameserver.client_group );
+ SteamAPI_ISteamNetworkingSockets_SetConnectionUserData( _steam_api.pSteamNetworkingSockets, conn, index );
}
else
{
vg_warn( "Error accepting connection (id: %u)\n", conn );
- SteamAPI_ISteamNetworkingSockets_CloseConnection( hSteamNetworkingSockets, conn,
+ SteamAPI_ISteamNetworkingSockets_CloseConnection( _steam_api.pSteamNetworkingSockets, conn,
k_ESteamNetConnectionEnd_Misc_InternalError, NULL, 1 );
}
}
-static void on_auth_status( CallbackMsg_t *msg )
-{
- SteamNetAuthenticationStatus_t *info = (void *)msg->m_pubParam;
- vg_info( " Authentication availibility: %s\n", string_ESteamNetworkingAvailability(info->m_eAvail) );
- vg_info( " %s\n", info->m_debugMsg );
-}
-
/*
* Get client id of connection handle. Will be -1 if unkown to us either because
* the server is full or we already disconnected them
if( hconn == 0 )
return -1;
else
- id = SteamAPI_ISteamNetworkingSockets_GetConnectionUserData( hSteamNetworkingSockets, hconn );
+ id = SteamAPI_ISteamNetworkingSockets_GetConnectionUserData( _steam_api.pSteamNetworkingSockets, hconn );
if( (id < 0) || (id >= NETWORK_MAX_PLAYERS) )
return -1;
/*
* Callback for steam connection state change
*/
-static void on_connect_status( CallbackMsg_t *msg )
+static void cb_connection_changed( SteamNetConnectionStatusChangedCallback_t *info )
{
- SteamNetConnectionStatusChangedCallback_t *info = (void *)msg->m_pubParam;
- vg_info( " Connection status changed for %lu\n", info->m_hConn );
-
- vg_info( " %s -> %s\n",
- string_ESteamNetworkingConnectionState(info->m_eOldState),
- string_ESteamNetworkingConnectionState(info->m_info.m_eState) );
-
- if( info->m_info.m_eState==k_ESteamNetworkingConnectionState_Connecting )
+ if( info->m_info.m_eState == k_ESteamNetworkingConnectionState_Connecting )
{
handle_new_connection( info->m_hConn );
}
(info->m_info.m_eState == k_ESteamNetworkingConnectionState_Dead) ||
(info->m_info.m_eState == k_ESteamNetworkingConnectionState_None) )
{
- vg_info( "End reason: %d\n", info->m_info.m_eEndReason );
-
int client_id = gameserver_conid( info->m_hConn );
if( client_id != -1 )
{
}
else
{
- SteamAPI_ISteamNetworkingSockets_CloseConnection( hSteamNetworkingSockets, info->m_hConn, 0, NULL, 0 );
+ SteamAPI_ISteamNetworkingSockets_CloseConnection( _steam_api.pSteamNetworkingSockets, info->m_hConn, 0, NULL, 0 );
}
}
}
if( client_id == -1 )
{
vg_warn( "Recieved version from unkown connection (%u)\n", msg->m_conn );
- SteamAPI_ISteamNetworkingSockets_CloseConnection( hSteamNetworkingSockets, msg->m_conn,
+ SteamAPI_ISteamNetworkingSockets_CloseConnection( _steam_api.pSteamNetworkingSockets, msg->m_conn,
k_ESteamNetConnectionEnd_Misc_InternalError, NULL, 1 );
return;
}
if( client_id == -1 )
{
vg_warn( "Recieved auth ticket from unkown connection (%u)\n", msg->m_conn );
- SteamAPI_ISteamNetworkingSockets_CloseConnection( hSteamNetworkingSockets, msg->m_conn,
+ SteamAPI_ISteamNetworkingSockets_CloseConnection( _steam_api.pSteamNetworkingSockets, msg->m_conn,
k_ESteamNetConnectionEnd_Misc_InternalError, NULL, 1 );
return;
}
if( SteamEncryptedAppTicket_GetTicketIssueTime( decrypted, ticket_len ))
{
- RTime32 ctime = time(NULL),
- tickettime = SteamEncryptedAppTicket_GetTicketIssueTime( decrypted, ticket_len ),
- expiretime = tickettime + 24*3*60*60;
+ u32 ctime = time(NULL),
+ tickettime = SteamEncryptedAppTicket_GetTicketIssueTime( decrypted, ticket_len ),
+ expiretime = tickettime + 24*3*60*60;
if( ctime > expiretime )
{
while(1)
{
len = SteamAPI_ISteamNetworkingSockets_ReceiveMessagesOnPollGroup(
- hSteamNetworkingSockets,
+ _steam_api.pSteamNetworkingSockets,
_gameserver.client_group, messages, VG_ARRAY_LEN(messages) );
if( len <= 0 )
int main( int argc, const char *argv[] )
{
+ int returncode = 0;
+ /*
+ * Registration
+ * ---------------------------------------------------------------------
+ */
_gameserver.thread = pthread_self();
vg_log_init();
vg_console_init();
signal( SIGQUIT, inthandler );
signal( SIGPIPE, SIG_IGN );
signal( SIGSEGV, segvhandler );
+ signal( SIGILL, segvhandler );
+ signal( SIGBUS, segvhandler );
{
_vg_opt_init( argc, argv );
return 0;
}
- if( !vg_init_async_queue( &_gameserver.tasks ) )
- goto E0;
-
- if( !db_init() )
- goto E0;
-
- _gs_requests_init();
- _gs_replay_init();
-
- /* steamworks init
+ /* Steam
* --------------------------------------------------------------- */
- steamworks_ensure_txt( "2103940" );
- if( _gameserver.auth_mode == eServerModeAuthentication )
- {
- if( !vg_load_steam_symetric_key( "application_key", _gameserver.app_symmetric_key ))
- goto E1;
- }
- else
- vg_warn( "Running without user authentication.\n" );
- if( !SteamGameServer_Init( 0, NETWORK_PORT, NETWORK_PORT+1, _gameserver.auth_mode, "1.0.0.0" ) )
+ _steam_api.cb_connection_changed = cb_connection_changed;
+
+ if( !vg_steam_init( 0, NETWORK_PORT, NETWORK_PORT+1, _gameserver.auth_mode, "1.0.0.0", "2103940" ) )
{
- vg_error( "SteamGameServer_Init failed\n" );
- goto E1;
+ returncode = -1;
+ goto E0;
}
- void *hSteamGameServer = SteamAPI_SteamGameServer();
- SteamAPI_ISteamGameServer_LogOnAnonymous( hSteamGameServer );
-
- SteamAPI_ManualDispatch_Init();
- HSteamPipe hsteampipe = SteamGameServer_GetHSteamPipe();
- hSteamNetworkingSockets = SteamAPI_SteamGameServerNetworkingSockets_SteamAPI();
- hSteamNetworkingUtils = SteamAPI_SteamNetworkingUtils_SteamAPI();
-
- steam_register_callback( k_iSteamNetAuthenticationStatus, on_auth_status );
- steam_register_callback( k_iSteamNetConnectionStatusChangedCallBack, on_connect_status );
-
- vg_success( "Steamworks API running\n" );
- steamworks_event_loop( hsteampipe );
-
- /*
- * Create a listener
- */
HSteamListenSocket listener;
SteamNetworkingIPAddr localAddr;
SteamAPI_SteamNetworkingIPAddr_Clear( &localAddr );
localAddr.m_port = NETWORK_PORT;
- listener = SteamAPI_ISteamNetworkingSockets_CreateListenSocketIP( hSteamNetworkingSockets, &localAddr, 0, NULL );
- _gameserver.client_group = SteamAPI_ISteamNetworkingSockets_CreatePollGroup( hSteamNetworkingSockets );
+ listener = SteamAPI_ISteamNetworkingSockets_CreateListenSocketIP( _steam_api.pSteamNetworkingSockets, &localAddr, 0, NULL );
+ _gameserver.client_group = SteamAPI_ISteamNetworkingSockets_CreatePollGroup( _steam_api.pSteamNetworkingSockets );
+
+ /*
+ * System INIT
+ */
+ if( !vg_init_async_queue( &_gameserver.tasks ) )
+ goto E0;
+
+ if( !db_init() )
+ goto E0;
+
+ _gs_requests_init();
+ _gs_replay_init();
+
_gameserver.ticks = seconds_to_server_ticks( 30.0 * 60.0 );
- _gs_monitor_journal( 0, "// Gameserver Starting\n" );
+ _gs_monitor_journal( 0, "// Gameserver entering main loop\n" );
while(1)
{
- steamworks_event_loop( hsteampipe );
+ vg_steam_frame();
poll_connections();
_gs_replay_server_tick();
_gs_requests_tick();
}
// TODO Measure max time spent on tasks?
-
while( vg_async_has_work( &_gameserver.tasks ) )
{
if( vg_async_process_next_task( &_gameserver.tasks ) == 0 )
}
EE:vg_info( "Server end\n" );
-
_gs_monitor_journal( 0, "// Gameserver Ending\n" );
- SteamAPI_ISteamNetworkingSockets_DestroyPollGroup( hSteamNetworkingSockets, _gameserver.client_group );
- SteamAPI_ISteamNetworkingSockets_CloseListenSocket( hSteamNetworkingSockets, listener );
-
+ SteamAPI_ISteamNetworkingSockets_DestroyPollGroup( _steam_api.pSteamNetworkingSockets, _gameserver.client_group );
+ SteamAPI_ISteamNetworkingSockets_CloseListenSocket( _steam_api.pSteamNetworkingSockets, listener );
SteamGameServer_Shutdown();
-E1:db_free();
+ db_free();
E0:_gs_monitor_cleanup();
- return 0;
+ vg_steam_shutdown();
+ return returncode;
}
#include "gameserver_replay.c"
#pragma once
-#define VG_SERVER
#include "vg/vg_platform.h"
-#include "vg/vg_steam.h"
-#include "vg/vg_steam_networking.h"
-#include "vg/vg_steam_http.h"
-#include "vg/vg_steam_auth_server.h"
+#include "vg/vg_steam2.h"
#include "vg/vg_async2.h"
#include "network_msg.h"
#include "network_common.h"
}
extern _gameserver;
-extern ISteamNetworkingSockets *hSteamNetworkingSockets;
-extern ISteamNetworkingUtils *hSteamNetworkingUtils;
-
u64 seconds_to_server_ticks( f64 s );
u32 gameserver_get_current_week(void);
vg_strcat( &str, " <tr>\n"
" <td>Tick</td>\n"
" <td>" );
- vg_strcatu64( &str, _gameserver.ticks );
+ vg_strcatu64( &str, _gameserver.ticks, 10 );
vg_strcat( &str, "</td>\n"
" </tr>\n" );
vg_strcat( &str, " <tr>\n"
" <td>Global UID</td>\n"
" <td>" );
- vg_strcatu64( &str, _gameserver.global_uid );
+ vg_strcatu64( &str, _gameserver.global_uid, 10 );
vg_strcat( &str, "</td>\n"
" </tr>\n" );
vg_strcat( &str, " <tr>\n"
" <td>Bytes send (channel 0)</td>"
" <td>" );
- vg_strcatu64( &str, _gameserver.bytes_send );
+ vg_strcatu64( &str, _gameserver.bytes_send, 10 );
vg_strcat( &str, "</td>\n"
" </tr>\n" );
vg_strcat( &str, " <tr>\n"
" <td>Bytes send (channel 1)</td>"
" <td>" );
- vg_strcatu64( &str, _gameserver.bytes_send1 );
+ vg_strcatu64( &str, _gameserver.bytes_send1, 10 );
vg_strcat( &str, "</td>\n"
" </tr>\n" );
vg_strcat( &str, " <tr>\n"
" <td>Bytes recv (channel 0)</td>"
" <td>" );
- vg_strcatu64( &str, _gameserver.bytes_recv );
+ vg_strcatu64( &str, _gameserver.bytes_recv, 10 );
vg_strcat( &str, "</td>\n"
" </tr>\n" );
" function rept(){\n"
" const now = new Date().getTime() / 1000;\n"
" var reference = " );
- vg_strcatu64( &str, time(NULL) );
+ vg_strcatu64( &str, time(NULL), 10 );
vg_strcat( &str, ";\n"
" var secs = Math.floor(now - reference);\n"
" document.getElementById('elapsed').textContent = secs.toString() + \" Seconds Ago\";\n"
#include "gameserver.h"
#include "gameserver_replay.h"
+#include "vg/vg_io.h"
struct _gs_replay _gs_replay;
{
THREAD_1;
struct serialized_replay *info = (void *)task->data;
-
vg_make_directory( "replaydata" );
char path[1024];
else if( req->state == k_request_state_server_error )
{
u32 size = sizeof(netmsg_request);
- SteamNetworkingMessage_t *msg = SteamAPI_ISteamNetworkingUtils_AllocateMessage( hSteamNetworkingUtils, size );
+ SteamNetworkingMessage_t *msg = SteamAPI_ISteamNetworkingUtils_AllocateMessage( _steam_api.pSteamNetworkingUtils, size );
msg->m_conn = client->connection;
msg->m_idxLane = 1;
netmsg_request *res = msg->m_pData;
res->inetmsg_id = k_inetmsg_response;
res->id = req->client_request_id;
res->status = req->status;
- SteamAPI_ISteamNetworkingSockets_SendMessages( hSteamNetworkingSockets, 1, &msg, NULL );
+ SteamAPI_ISteamNetworkingSockets_SendMessages( _steam_api.pSteamNetworkingSockets, 1, &msg, NULL );
req->state = k_request_state_finished;
log_request_status( req );
_gameserver.bytes_send1 += size;
else if( req->state == k_request_state_transfer_start )
{
u32 size = sizeof(netmsg_request) + sizeof(struct netmsg_transfer_header);
- SteamNetworkingMessage_t *msg = SteamAPI_ISteamNetworkingUtils_AllocateMessage( hSteamNetworkingUtils, size );
+ SteamNetworkingMessage_t *msg = SteamAPI_ISteamNetworkingUtils_AllocateMessage( _steam_api.pSteamNetworkingUtils, size );
msg->m_conn = client->connection;
msg->m_idxLane = 1;
header->data_size = req->data_buffer_send_size;
header->chunks = (req->data_buffer_send_size+(GS_TRANSFER_BYTES_PER_TICK-1)) / GS_TRANSFER_BYTES_PER_TICK;
- SteamAPI_ISteamNetworkingSockets_SendMessages( hSteamNetworkingSockets, 1, &msg, NULL );
+ SteamAPI_ISteamNetworkingSockets_SendMessages( _steam_api.pSteamNetworkingSockets, 1, &msg, NULL );
req->state = k_request_state_transfer;
log_request_status( req );
_gameserver.bytes_send1 += size;
}
u32 message_size = sizeof(netmsg_request) + size;
- SteamNetworkingMessage_t *msg =
- SteamAPI_ISteamNetworkingUtils_AllocateMessage( hSteamNetworkingUtils, message_size );
+ SteamNetworkingMessage_t *msg = SteamAPI_ISteamNetworkingUtils_AllocateMessage( _steam_api.pSteamNetworkingUtils, message_size );
msg->m_conn = client->connection;
msg->m_idxLane = 1;
res->status = k_request_status_transfer_continue;
memcpy( res->buffer, req->data_buffer + req->send_offset, size );
- SteamAPI_ISteamNetworkingSockets_SendMessages( hSteamNetworkingSockets, 1, &msg, NULL );
+ SteamAPI_ISteamNetworkingSockets_SendMessages( _steam_api.pSteamNetworkingSockets, 1, &msg, NULL );
req->send_offset += size;
_gameserver.bytes_send1 += size;
}
vg_error( "req[%s##error] State: fail, Status: %u\n", client->username, (u32)error_status );
u32 size = sizeof(netmsg_request);
- SteamNetworkingMessage_t *reply_msg = SteamAPI_ISteamNetworkingUtils_AllocateMessage( hSteamNetworkingUtils, size );
+ SteamNetworkingMessage_t *reply_msg = SteamAPI_ISteamNetworkingUtils_AllocateMessage( _steam_api.pSteamNetworkingUtils, size );
reply_msg->m_conn = client->connection;
reply_msg->m_idxLane = 1;
netmsg_request *res = reply_msg->m_pData;
res->inetmsg_id = k_inetmsg_response;
res->id = client_packet->id;
res->status = error_status;
- SteamAPI_ISteamNetworkingSockets_SendMessages( hSteamNetworkingSockets, 1, &reply_msg, NULL );
+ SteamAPI_ISteamNetworkingSockets_SendMessages( _steam_api.pSteamNetworkingSockets, 1, &reply_msg, NULL );
SteamAPI_SteamNetworkingMessage_t_Release( msg );
_gameserver.bytes_send1 += size;
}
i32 R = menu_nav( &menu.web_choice, mh, 2 );
- if( menu_button( ctx, a, R==0, steam_ready, "Steam Overlay" ) )
+ if( menu_button( ctx, a, R==0, !_steam_api.disabled, "Steam Overlay" ) )
{
- ISteamFriends *hSteamFriends = SteamAPI_SteamFriends();
- SteamAPI_ISteamFriends_ActivateGameOverlayToWebPage( hSteamFriends,
- menu.web_link,
- k_EActivateGameOverlayToWebPageMode_Default );
+ SteamAPI_ISteamFriends_ActivateGameOverlayToWebPage( _steam_api.pSteamFriends,menu.web_link,
+ k_EActivateGameOverlayToWebPageMode_Default );
menu.web_link = NULL;
}
ui_rect end = { panel[0], panel[1] + panel[3] - 48, panel[2], 48 }, a,b;
ui_split_ratio( end, k_ui_axis_v, 0.5f, 2, a, b );
- if( menu_button( ctx, a, R == 0, steam_ready, "Store Page" ) )
+ if( menu_button( ctx, a, R == 0, !_steam_api.disabled, "Store Page" ) )
{
SteamAPI_ISteamFriends_ActivateGameOverlayToStore(
- SteamAPI_SteamFriends(), 2103940, k_EOverlayToStoreFlag_None);
+ _steam_api.pSteamFriends, 2103940, k_EOverlayToStoreFlag_None);
}
if( menu_button( ctx, b, R == 1, 1, "Nah" ) || button_down( k_srbind_mback ) )
#include "skaterift.h"
-#include "vg/vg_steam.h"
-#include "vg/vg_steam_networking.h"
-#include "vg/vg_steam_auth.h"
-#include "vg/vg_steam_friends.h"
+#include "vg/vg_steam2.h"
#include "player.h"
#include "network.h"
#include "network_msg.h"
}
}
-static void on_auth_ticket_recieved( void *result, void *context ){
- EncryptedAppTicketResponse_t *response = result;
-
- if( response->m_eResult == k_EResultOK ){
- vg_info( " New app ticket ready\n" );
- }
- else{
- vg_warn( " Could not request new encrypted app ticket (%u)\n",
- response->m_eResult );
- }
-
- if( SteamAPI_ISteamUser_GetEncryptedAppTicket( hSteamUser,
- network_client.app_symmetric_key,
- VG_ARRAY_LEN(network_client.app_symmetric_key),
- &network_client.app_key_length )){
- vg_success( " Loaded app ticket\n" );
- }
- else{
- vg_error( " No ticket availible\n" );
- network_client.app_key_length = 0;
- }
-}
-
-void request_auth_ticket(void)
-{
- /*
- * TODO Check for one thats cached on the disk and load it.
- * This might be OK though because steam seems to cache the result
- */
-
- vg_info( "Requesting new authorization ticket\n" );
-
- vg_steam_async_call *call = vg_alloc_async_steam_api_call();
- call->userdata = NULL;
- call->p_handler = on_auth_ticket_recieved;
- call->id = SteamAPI_ISteamUser_RequestEncryptedAppTicket( hSteamUser, NULL, 0 );
-}
-
static void network_send_username(void){
if( !network_connected() )
return;
update->inetmsg_id = k_inetmsg_playerusername;
update->index = 0xff;
- ISteamFriends *hSteamFriends = SteamAPI_SteamFriends();
- const char *username = SteamAPI_ISteamFriends_GetPersonaName(hSteamFriends);
+ const char *username = SteamAPI_ISteamFriends_GetPersonaName( _steam_api.pSteamFriends );
u32 chs = str_utf8_collapse( username, update->name, NETWORK_USERNAME_MAX );
SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
- hSteamNetworkingSockets, network_client.remote,
+ _steam_api.pSteamNetworkingSockets, network_client.remote,
update, sizeof(netmsg_playerusername)+chs+1,
k_nSteamNetworkingSend_Reliable, NULL );
}
NETWORK_REGION_MAX, k_strncpy_always_add_null );
SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
- hSteamNetworkingSockets, network_client.remote,
+ _steam_api.pSteamNetworkingSockets, network_client.remote,
region, sizeof(netmsg_region)+l+1,
k_nSteamNetworkingSend_Reliable, NULL );
}
vg_info( "send equip: [%u] %s\n", item->type_index, item->uid );
u32 chs = strlen(item->uid);
- SteamAPI_ISteamNetworkingSockets_SendMessageToConnection( hSteamNetworkingSockets, network_client.remote,
+ SteamAPI_ISteamNetworkingSockets_SendMessageToConnection( _steam_api.pSteamNetworkingSockets, network_client.remote,
item, sizeof(netmsg_playeritem)+chs+1,
k_nSteamNetworkingSend_Reliable, NULL );
}
static void network_disconnect(void)
{
- SteamAPI_ISteamNetworkingSockets_CloseConnection( hSteamNetworkingSockets, network_client.remote, 0, NULL, 0 );
+ SteamAPI_ISteamNetworkingSockets_CloseConnection( _steam_api.pSteamNetworkingSockets, network_client.remote, 0, NULL, 0 );
network_client.remote = 0;
network_client.state = k_ESteamNetworkingConnectionState_None;
return;
}
- if( steam_ready )
+ if( !_steam_api.disabled )
{
if( network_client.user_intent == k_server_intent_offline )
{
skaterift.rt_textures[ k_skaterift_rt_server_status ] = g_render.fb_network_status->attachments[0].id;
}
-void on_server_connect_status( CallbackMsg_t *msg )
+void cb_skaterift_connection_changed( SteamNetConnectionStatusChangedCallback_t *info )
{
- SteamNetConnectionStatusChangedCallback_t *info = (void *)msg->m_pubParam;
- vg_info( " Connection status changed for %lu\n", info->m_hConn );
- vg_info( " %s -> %s\n",
- string_ESteamNetworkingConnectionState(info->m_eOldState),
- string_ESteamNetworkingConnectionState(info->m_info.m_eState) );
-
if( info->m_hConn == network_client.remote )
{
network_client.state = info->m_info.m_eState;
version.inetmsg_id = k_inetmsg_version;
version.version = NETWORK_SKATERIFT_VERSION;
SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
- hSteamNetworkingSockets, network_client.remote, &version,
+ _steam_api.pSteamNetworkingSockets, network_client.remote, &version,
sizeof(netmsg_version), k_nSteamNetworkingSend_Reliable, NULL );
/* TODO: We should really wait to see if the server is in auth mode
* first... */
- u32 size = sizeof(netmsg_auth) + network_client.app_key_length;
+ u32 size = sizeof(netmsg_auth) + _steam_api.app_key_length;
netmsg_auth *auth = alloca(size);
auth->inetmsg_id = k_inetmsg_auth;
- auth->ticket_length = network_client.app_key_length;
- for( int i=0; i<network_client.app_key_length; i++ )
- auth->ticket[i] = network_client.app_symmetric_key[i];
+ auth->ticket_length = _steam_api.app_key_length;
+ for( int i=0; i<_steam_api.app_key_length; i++ )
+ auth->ticket[i] = _steam_api.app_symmetric_key[i];
SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
- hSteamNetworkingSockets, network_client.remote, auth, size,
+ _steam_api.pSteamNetworkingSockets, network_client.remote, auth, size,
k_nSteamNetworkingSend_Reliable, NULL );
}
else if( info->m_info.m_eState == k_ESteamNetworkingConnectionState_ClosedByPeer )
render_server_status_gui();
}
-void on_persona_state_change( CallbackMsg_t *msg )
+void cb_skaterift_persona_changed( PersonaStateChange_t *info )
{
if( !network_connected() )
return;
- PersonaStateChange_t *info = (void *)msg->m_pubParam;
- ISteamUser *hSteamUser = SteamAPI_SteamUser();
-
vg_info( "User: " PRINTF_U64 ", change: %u\n", info->m_ulSteamID, info->m_nChangeFlags );
- if( info->m_ulSteamID == SteamAPI_ISteamUser_GetSteamID(hSteamUser) )
+ if( info->m_ulSteamID == SteamAPI_ISteamUser_GetSteamID( _steam_api.pSteamUser ) )
if( info->m_nChangeFlags & k_EPersonaChangeName )
network_send_username();
vg_info( "connecting...\n" );
network_client.remote = SteamAPI_ISteamNetworkingSockets_ConnectByIPAddress(
- hSteamNetworkingSockets, &network_client.ip, 0, NULL );
+ _steam_api.pSteamNetworkingSockets, &network_client.ip, 0, NULL );
}
static void network_sign_on_complete(void)
for( int i=0; i<10; i++ )
{
len = SteamAPI_ISteamNetworkingSockets_ReceiveMessagesOnConnection(
- hSteamNetworkingSockets, network_client.remote,
+ _steam_api.pSteamNetworkingSockets, network_client.remote,
messages, VG_ARRAY_LEN(messages));
if( len <= 0 )
void network_update(void)
{
- if( !steam_ready )
+ if( _steam_api.disabled )
return;
if( g_client.demo_mode )
chat->client = 0;
u32 l = vg_strncpy( message, chat->msg, NETWORK_MAX_CHAT, k_strncpy_always_add_null );
SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
- hSteamNetworkingSockets, network_client.remote,
+ _steam_api.pSteamNetworkingSockets, network_client.remote,
chat, sizeof(netmsg_chat)+l+1,
k_nSteamNetworkingSend_Reliable, NULL );
}
(network_client.state == k_ESteamNetworkingConnectionState_Connecting) )
{
SteamAPI_ISteamNetworkingSockets_CloseConnection(
- hSteamNetworkingSockets, network_client.remote, 0, NULL, 1 );
+ _steam_api.pSteamNetworkingSockets, network_client.remote, 0, NULL, 1 );
}
}
/*
- * Copyright (C) 2021-2024 Mt.ZERO Software, Harry Godden - All Rights Reserved
+ * Copyright (C) 2021-2025 Mt.ZERO Software, Harry Godden - All Rights Reserved
* All trademarks are property of their respective owners
*/
#pragma once
#include "vg/vg_platform.h"
-#include "vg/vg_steam_networking.h"
+#include "vg/vg_steam2.h"
#include "vg/vg_mem_pool.h"
#include "vg/vg_msg.h"
-#include "steam.h"
#include "network_common.h"
#include "network_msg.h"
#include "addon_types.h"
struct network_client
{
- u8 app_symmetric_key[ 1024 ];
- u32 app_key_length;
EServerMode auth_mode;
HSteamNetConnection remote;
if( network_client.remote_version != NETWORK_SKATERIFT_VERSION ) return 0;
return network_client.state == k_ESteamNetworkingConnectionState_Connected;
}
+
+void cb_skaterift_connection_changed( SteamNetConnectionStatusChangedCallback_t *info );
+void cb_skaterift_persona_changed( PersonaStateChange_t *info );
else
packet->id = 0;
- SteamAPI_ISteamNetworkingSockets_SendMessageToConnection( hSteamNetworkingSockets, network_client.remote,
+ SteamAPI_ISteamNetworkingSockets_SendMessageToConnection( _steam_api.pSteamNetworkingSockets, network_client.remote,
packet, sizeof(netmsg_request)+len,
k_nSteamNetworkingSend_Reliable, NULL );
}
{
vg_msg msg;
vg_msg_init( &msg, data, data_size );
- vg_msg_print( &msg, msg.max );
+ //vg_msg_print( &msg, msg.max );
world_routes_recv_scoreboard( &_world.main, &msg, userdata, status );
if( userdata == world_sfd.active_route_board )
u8 current_id = _net_requests.recieving_request_id;
if( current_id != response->id )
{
- net_request *current = vg_pool_item( &_net_requests.request_pool, current_id );
+ if( current_id )
+ {
+ net_request *current = vg_pool_item( &_net_requests.request_pool, current_id );
+ if( current->callback )
+ current->callback( NULL, 0, current->userdata, k_request_status_server_error );
+ current->state = k_request_state_error;
+ log_request_status( current, "Transfer protocol fault" );
+ _delete_request( current );
+ }
+
if( request->callback )
request->callback( NULL, 0, request->userdata, k_request_status_server_error );
- if( current->callback )
- current->callback( NULL, 0, current->userdata, k_request_status_server_error );
- current->state = k_request_state_error;
request->state = k_request_state_error;
- log_request_status( current, "Transfer protocol fault" );
log_request_status( request, "Transfer protocol fault" );
- _delete_request( current );
_delete_request( request );
_transfer_reset();
return;
#include "gui.h"
#include "ent_region.h"
#include "shaders/model_entity.h"
-#include "vg/vg_steam_friends.h"
+#include "vg/vg_steam2.h"
#include "vg/vg_magi.h"
struct global_netplayers netplayers;
void player_remote_update_friendflags( struct network_player *remote )
{
- ISteamFriends *hSteamFriends = SteamAPI_SteamFriends();
- remote->isfriend = SteamAPI_ISteamFriends_HasFriend( hSteamFriends, remote->steamid, k_EFriendFlagImmediate );
- remote->isblocked = SteamAPI_ISteamFriends_HasFriend( hSteamFriends, remote->steamid, k_EFriendFlagBlocked );
+ remote->isfriend = SteamAPI_ISteamFriends_HasFriend( _steam_api.pSteamFriends, remote->steamid, k_EFriendFlagImmediate );
+ remote->isblocked = SteamAPI_ISteamFriends_HasFriend( _steam_api.pSteamFriends, remote->steamid, k_EFriendFlagBlocked );
}
void decode_playerframe( netmsg_playerframe *frame, u32 data_length, struct interp_frame *dest,
u32 wire_size = base_size + ctx.bytes;
netplayers.up_bytes += wire_size;
- SteamAPI_ISteamNetworkingSockets_SendMessageToConnection( hSteamNetworkingSockets, network_client.remote,
+ SteamAPI_ISteamNetworkingSockets_SendMessageToConnection( _steam_api.pSteamNetworkingSockets, network_client.remote,
frame, wire_size, k_nSteamNetworkingSend_Unreliable,
NULL );
}
void remote_players_imgui_lobby( ui_context *ctx )
{
if( network_client.user_intent == k_server_intent_online )
- {
- if( !(steam_ready && (network_client.state == k_ESteamNetworkingConnectionState_Connected)) )
- {
+ if( !(!_steam_api.disabled && (network_client.state == k_ESteamNetworkingConnectionState_Connected)) )
return;
- }
- }
ui_px y = 50, width = 200, height = 42, gap = 2,
x = vg.window_x - width;
ui_rect us = { x, y, width, height };
/* FIXME: your location */
- remote_player_gui_info( ctx, us, steam_username_at_startup, "you", k_remote_player_gui_type_you, 1 );
+ remote_player_gui_info( ctx, us, _steam_api.username_at_startup, "you", k_remote_player_gui_type_you, 1 );
y += height + gap;
for( u32 i=0; i<NETWORK_MAX_PLAYERS; i ++ )
#include "vg/vg_io.h"
#include "skaterift.h"
-#include "steam.h"
#include "render.h"
#include "world.h"
#include "font.h"
co_thread( co, 1, &vg.loader_tasks );
}
- if( co_step( co, 0 ) )
- {
- if( !g_client.nosteam )
- {
- if( steam_init() )
- {
- steam_register_callback( k_iSteamNetConnectionStatusChangedCallBack, on_server_connect_status );
- steam_register_callback( k_iPersonaStateChange, on_persona_state_change );
- request_auth_ticket();
- }
- }
- }
-
if( co_step( co, 1 ) )
{
vg_loader_step( render_init, NULL );
vg_loader_step( remote_players_init, NULL );
- if( !g_client.nosteam )
- vg_loader_step( NULL, steam_end );
-
vg_loader_step( network_init, network_end );
vg_loader_set_user_information( "Initializing subsystems" );
vg_loader_step( menu_init, NULL );
if( co_step( co, 0 ) )
{
_mount_workshop_addons( NULL );
+ _ent_atom_init();
}
/* stalling for workshop to complete */
return;
skaterift_preupdate_inputs();
-
- steam_update();
world_switcher_update();
if( !_vg_tower_clearence( skaterift.full_ready_mask ) )
#include "render.c"
#include "save.c"
#include "scene.c"
-#include "steam.c"
#include "trail.c"
#include "workshop.c"
#include "world_audio.c"
if( vg_long_opt( "demo", "Turn demo mode on" ) )
g_client.demo_mode = 2;
- if( vg_long_opt( "nosteam", "Disable steam integration (offline)" ) )
- g_client.nosteam = 1;
-
if( (arg = vg_long_opt_arg( "world", "Specify path to world to load" )) )
skaterift.override_load_world = arg;
}
_ent_atom_register();
_ent_challenge_register();
+ _steam_api.demo_mode = g_client.demo_mode; // FIXME Fuck you
+ _steam_api.cb_connection_changed = cb_skaterift_connection_changed;
+ _steam_api.cb_persona_changed = cb_skaterift_persona_changed;
+
vg_run();
return 0;
}
+++ /dev/null
-#include "vg/vg_steam.h"
-#include "vg/vg_steam_utils.h"
-#include "vg/vg_steam_networking.h"
-#include "vg/vg_steam_auth.h"
-#include "vg/vg_steam_http.h"
-#include "vg/vg_steam_friends.h"
-#include "vg/vg_steam_user_stats.h"
-#include "submodules/anyascii/impl/c/anyascii.c"
-#include "skaterift.h"
-#include <string.h>
-
-/*
- * We only want to use steamworks if building for the networked version,
- * theres not much point otherwise. We mainly want steamworks for setting
- * achievements etc.. so that includes our own server too.
- *
- * This file also wraps the functions and interfaces that we want to use to
- * make them a bit easier to read, since they are the flat API they have very
- * long names. in non-networked builds they will return default errors or do
- * nothing.
- */
-
-char steam_username_at_startup[128] = "Unassigned";
-
-static void recv_steam_warning( int severity, const char *msg )
-{
- if( severity == 0 )
- vg_low( "%s\n", msg );
- else
- vg_info( "%s\n", msg );
-}
-
-int steam_ready = 0,
- steam_stats_ready = 0;
-
-void *hSteamNetworkingSockets, *hSteamUser, *hSteamUserStats;
-static HSteamPipe hSteamClientPipe;
-
-static const char *steam_achievement_names[] =
-{
- "ALBERT", "MARC", "JANET", "BERNADETTA",
- "ROUTE_MPY", "ROUTE_MPG", "ROUTE_MPB", "ROUTE_MPR",
- "ROUTE_TO", "ROUTE_TC", "CITY_COMPLETE", "MTZERO_SILVER", "MTZERO_GOLD",
- "80FT"
-};
-
-void steam_store_achievements(void)
-{
- if( steam_ready && steam_stats_ready ){
- SteamAPI_ISteamUserStats_StoreStats( hSteamUserStats );
- }
-}
-
-void steam_set_achievement( const char *name )
-{
- if( g_client.demo_mode )
- return;
-
- if( steam_ready && steam_stats_ready )
- {
- if( SteamAPI_ISteamUserStats_SetAchievement( hSteamUserStats, name ) )
- vg_success( "Achievement set! '%s'\n", name );
- else
- vg_warn( "Failed to set achievement: %s\n", name );
- }
- else
- vg_warn( "Failed to set achievement (steam not ready): %s\n", name );
-}
-
-void steam_clear_achievement( const char *name )
-{
- if( steam_ready && steam_stats_ready ){
- if( SteamAPI_ISteamUserStats_ClearAchievement( hSteamUserStats, name ) ){
- vg_info( "Achievement cleared: '%s'\n", name );
- }
- else{
- vg_warn( "Failed to clear achievement: %s\n", name );
- }
- }
- else{
- vg_warn( "Failed to clear achievement (steam not ready): %s\n", name );
- }
-}
-
-
-void steam_print_all_achievements(void)
-{
- vg_info( "Achievements: \n" );
-
- if( steam_ready && steam_stats_ready ){
- for( int i=0; i<VG_ARRAY_LEN(steam_achievement_names); i++ ){
- steamapi_bool set = 0;
- const char *name = steam_achievement_names[i];
-
- if( SteamAPI_ISteamUserStats_GetAchievement(
- hSteamUserStats, name, &set ) )
- {
- vg_info( " %s %s\n", (set? "[YES]": "[ ]"), name );
- }
- else{
- vg_warn( " Error while fetching achievement status '%s'\n", name );
- }
- }
- }
- else{
- vg_warn( " Steam is not initialized, no results\n" );
- }
-}
-
-int steam_achievement_ccmd( int argc, char const *argv[] )
-{
- if( !(steam_ready && steam_stats_ready) )
- return 1;
-
- if( argc == 1 ){
- if( !strcmp( argv[0], "list" ) ){
- steam_print_all_achievements();
- return 0;
- }
- else if( !strcmp( argv[0], "clearall" )){
- for( int i=0; i<VG_ARRAY_LEN(steam_achievement_names); i++ )
- steam_clear_achievement( steam_achievement_names[i] );
-
- steam_store_achievements();
- }
- }
-
- if( argc == 2 ){
- if( !strcmp( argv[0], "set" ) ){
- steam_set_achievement( argv[1] );
- steam_store_achievements();
- return 0;
- }
- else if( strcmp( argv[0], "clear" ) ){
- steam_clear_achievement( argv[1] );
- steam_store_achievements();
- return 0;
- }
- }
-
- return 1;
-}
-
-static void steam_on_recieve_current_stats( CallbackMsg_t *msg )
-{
- UserStatsReceived_t *rec = (UserStatsReceived_t *)msg->m_pubParam;
- if( rec->m_eResult == k_EResultOK )
- {
- vg_info( "Recieved stats for: %lu (user: %lu)\n", rec->m_nGameID, rec->m_steamIDUser );
- steam_stats_ready = 1;
-
- steamapi_bool set = 0;
- if( SteamAPI_ISteamUserStats_GetAchievement( hSteamUserStats, "MARC", &set ) )
- {
- if( set ) _atom_set( k_atom_list_global, "MARC", 1 );
- }
- if( SteamAPI_ISteamUserStats_GetAchievement( hSteamUserStats, "ALBERT", &set ) )
- {
- if( set ) _atom_set( k_atom_list_global, "ALBERT", 1 );
- }
- if( SteamAPI_ISteamUserStats_GetAchievement( hSteamUserStats, "JANET", &set ) )
- {
- if( set ) _atom_set( k_atom_list_global, "JANET", 1 );
- }
- if( SteamAPI_ISteamUserStats_GetAchievement( hSteamUserStats, "BERNADETTA", &set ) )
- {
- if( set ) _atom_set( k_atom_list_global, "BERNADETTA", 1 );
- }
- }
- else
- vg_error( "Error recieveing stats for user (%u)\n", rec->m_eResult );
-}
-
-static u32 utf8_byte0_byte_count( u8 char0 )
-{
- for( u32 k=2; k<4; k++ )
- {
- if( !(char0 & (0x80 >> k)) )
- return k;
- }
-
- return 0;
-}
-
-u32 str_utf8_collapse( const char *str, char *buf, u32 length )
-{
- u8 *ustr = (u8 *)str;
- u32 utf32_code = 0x00000000;
- u32 i=0, j=0, utf32_byte_ct=0;
- for(;j < length-1;)
- {
- if( ustr[i] == 0x00 )
- break;
- if( ustr[i] & 0x80 )
- {
- if( utf32_byte_ct )
- {
- utf32_byte_ct --;
- utf32_code |= (ustr[i] & 0x3F) << (utf32_byte_ct*6);
- if( !utf32_byte_ct )
- {
- const char *match;
- size_t chars = anyascii( utf32_code, &match );
- for( u32 k=0; k<VG_MIN(chars, length-1-j); k++ )
- buf[ j++ ] = (u8)match[k];
- }
- }
- else
- {
- utf32_byte_ct = utf8_byte0_byte_count( ustr[i] )-1;
- utf32_code = ustr[i] & (0x3F >> utf32_byte_ct);
- utf32_code <<= utf32_byte_ct*6;
- }
- }
- else
- {
- utf32_byte_ct = 0x00;
- buf[j ++] = str[i];
- }
- i++;
- }
- buf[j] = 0x00;
- return j;
-}
-
-void steam_register(void)
-{
- vg_console_reg_cmd( "ach", steam_achievement_ccmd, NULL );
-}
-
-bool steam_init(void)
-{
- const char *username = "offline player";
-
- vg_info( "Initializing steamworks\n" );
-
- if( !SteamAPI_Init() )
- {
- printf("\n");
- vg_error( "Steamworks failed to initialize\n" );
- return 0;
- }
-
- steam_ready = 1;
- SteamAPI_ManualDispatch_Init();
-
- /* Connect interfaces */
- hSteamClientPipe = SteamAPI_GetHSteamPipe();
- hSteamNetworkingSockets = SteamAPI_SteamNetworkingSockets_SteamAPI();
- hSteamUser = SteamAPI_SteamUser();
-
- ISteamUtils *utils = SteamAPI_SteamUtils();
- SteamAPI_ISteamUtils_SetWarningMessageHook( utils, recv_steam_warning );
-
- printf("\n");
- vg_success( "\nSteamworks API running\n" );
-
- ISteamFriends *hSteamFriends = SteamAPI_SteamFriends();
- username = SteamAPI_ISteamFriends_GetPersonaName( hSteamFriends );
-
- /*
- * Request stats
- * --------------------------------------------------------
- */
- hSteamUserStats = SteamAPI_SteamUserStats();
- steam_register_callback( k_iUserStatsReceived, steam_on_recieve_current_stats );
-
- if( !SteamAPI_ISteamUserStats_RequestCurrentStats( hSteamUserStats ) )
- vg_warn( "No Steam Logon: Cannot request stats\n" );
-
- /* TODO: On username update callback */
- str_utf8_collapse( username, steam_username_at_startup, VG_ARRAY_LEN(steam_username_at_startup) );
- return 1;
-}
-
-void steam_update(void)
-{
- if( steam_ready )
- steamworks_event_loop( hSteamClientPipe );
-}
-
-void steam_end(void)
-{
- if( steam_ready )
- {
- vg_info( "Shutting down\n..." );
- SteamAPI_Shutdown();
- }
-}
+++ /dev/null
-/*
- * Copyright (C) 2021-2024 Mt.ZERO Software, Harry Godden - All Rights Reserved
- * All trademarks are property of their respective owners
- */
-#pragma once
-
-extern int steam_ready, steam_stats_ready;
-extern void *hSteamNetworkingSockets, *hSteamUser, *hSteamUserStats;
-extern char steam_username_at_startup[128];
-
-void steam_register(void);
-bool steam_init(void);
-void steam_update(void);
-void steam_end(void);
-u32 str_utf8_collapse( const char *str, char *buf, u32 length );
-int steam_achievement_ccmd( int argc, char const *argv[] );
-void steam_print_all_achievements(void);
-void steam_clear_achievement( const char *name );
-void steam_set_achievement( const char *name );
-void steam_store_achievements(void);
vg_msg_wkvnum( &data, "steamid", k_vg_msg_u64, 1, &steamid );
network_send_request( packet, &data, _profile_download_callback, steamid );
- u64 me_id = SteamAPI_ISteamUser_GetSteamID( SteamAPI_SteamUser() );
+ u64 me_id = SteamAPI_ISteamUser_GetSteamID( _steam_api.pSteamUser );
bool isme = 0;
if( (steamid == 0) || (steamid == me_id) )
{
isme = 1;
}
- ISteamFriends *hSteamFriends = SteamAPI_SteamFriends();
- ISteamUtils *hSteamUtils = SteamAPI_SteamUtils();
- if( isme || SteamAPI_ISteamFriends_HasFriend( hSteamFriends, steamid, k_EFriendFlagImmediate ) )
+ if( isme || SteamAPI_ISteamFriends_HasFriend( _steam_api.pSteamFriends, steamid, k_EFriendFlagImmediate ) )
{
- i32 avatar_handle = SteamAPI_ISteamFriends_GetMediumFriendAvatar( hSteamFriends, steamid );
+ i32 avatar_handle = SteamAPI_ISteamFriends_GetMediumFriendAvatar( _steam_api.pSteamFriends, steamid );
if( avatar_handle )
{
u32 w, h;
- if( SteamAPI_ISteamUtils_GetImageSize( hSteamUtils, avatar_handle, &w, &h ) )
+ if( SteamAPI_ISteamUtils_GetImageSize( _steam_api.pSteamUtils, avatar_handle, &w, &h ) )
{
if( w == 64 && h == 64 )
{
u8 *tmp = malloc( w*h*4 );
- if( SteamAPI_ISteamUtils_GetImageRGBA( hSteamUtils, avatar_handle, tmp, w*h*4 ) )
+ if( SteamAPI_ISteamUtils_GetImageRGBA( _steam_api.pSteamUtils, avatar_handle, tmp, w*h*4 ) )
{
glBindTexture( GL_TEXTURE_2D, _user_profile.avatar_tex );
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, 64, 64, 0, GL_RGBA, GL_UNSIGNED_BYTE, tmp );
#include "vg/vg_io.h"
#include "ent_skateshop.h"
-#include "vg/vg_steam_auth.h"
-#include "vg/vg_steam_ugc.h"
-#include "vg/vg_steam_friends.h"
-#include "steam.h"
+#include "vg/vg_steam2.h"
#include "workshop.h"
struct workshop_form workshop_form;
if( workshop_form.ugc_query.result == k_EResultOK ){
workshop_form.ugc_query.result = k_EResultNone;
- ISteamUGC *hSteamUGC = SteamAPI_SteamUGC();
- SteamAPI_ISteamUGC_ReleaseQueryUGCRequest(
- hSteamUGC, workshop_form.ugc_query.handle );
+ SteamAPI_ISteamUGC_ReleaseQueryUGCRequest( _steam_api.pSteamUGC, workshop_form.ugc_query.handle );
}
workshop_form.page = k_workshop_form_hidden;
static void workshop_form_upload_submission( PublishedFileId_t file_id, char *metadata )
{
THREAD_0;
- ISteamUGC *hSteamUGC = SteamAPI_SteamUGC();
- UGCUpdateHandle_t handle = SteamAPI_ISteamUGC_StartItemUpdate( hSteamUGC, SKATERIFT_APPID, file_id );
+ UGCUpdateHandle_t handle = SteamAPI_ISteamUGC_StartItemUpdate( _steam_api.pSteamUGC, SKATERIFT_APPID, file_id );
/* TODO: Handle failure cases for these */
- SteamAPI_ISteamUGC_SetItemMetadata( hSteamUGC, handle, metadata );
+ SteamAPI_ISteamUGC_SetItemMetadata( _steam_api.pSteamUGC, handle, metadata );
if( workshop_form.submission.submit_title )
{
vg_info( "Setting title\n" );
- SteamAPI_ISteamUGC_SetItemTitle( hSteamUGC, handle, workshop_form.submission.title );
+ SteamAPI_ISteamUGC_SetItemTitle( _steam_api.pSteamUGC, handle, workshop_form.submission.title );
}
if( workshop_form.submission.submit_description )
{
vg_info( "Setting description\n" );
- SteamAPI_ISteamUGC_SetItemDescription( hSteamUGC, handle, workshop_form.submission.description);
+ SteamAPI_ISteamUGC_SetItemDescription( _steam_api.pSteamUGC, handle, workshop_form.submission.description);
}
if( workshop_form.submission.submit_file_and_image )
vg_strcat( &folder, workshop_form.addon_folder );
vg_info( "Setting item content\n" );
- SteamAPI_ISteamUGC_SetItemContent( hSteamUGC, handle, folder.buffer );
+ SteamAPI_ISteamUGC_SetItemContent( _steam_api.pSteamUGC, handle, folder.buffer );
vg_str preview = folder;
vg_strcat( &preview, "/preview.jpg" );
vg_info( "Setting preview image\n" );
- SteamAPI_ISteamUGC_SetItemPreview( hSteamUGC, handle, preview.buffer );
+ SteamAPI_ISteamUGC_SetItemPreview( _steam_api.pSteamUGC, handle, preview.buffer );
}
vg_info( "Setting visibility\n" );
- SteamAPI_ISteamUGC_SetItemVisibility( hSteamUGC, handle, workshop_form.submission.visibility );
+ SteamAPI_ISteamUGC_SetItemVisibility( _steam_api.pSteamUGC, handle, workshop_form.submission.visibility );
vg_info( "Submitting updates\n" );
- vg_steam_async_call *call = vg_alloc_async_steam_api_call();
+ vg_steam_api_call *call = vg_alloc_async_steam_api_call();
call->userdata = NULL;
- call->p_handler = on_workshop_update_result;
- call->id = SteamAPI_ISteamUGC_SubmitItemUpdate( hSteamUGC, handle, "" );
+ call->cb = on_workshop_update_result;
+ call->id = SteamAPI_ISteamUGC_SubmitItemUpdate( _steam_api.pSteamUGC, handle, "" );
}
/*
}
else
{
- vg_steam_async_call *call = vg_alloc_async_steam_api_call();
+ vg_steam_api_call *call = vg_alloc_async_steam_api_call();
call->userdata = userdata;
- call->p_handler = on_workshop_createitem;
- ISteamUGC *hSteamUGC = SteamAPI_SteamUGC();
- call->id = SteamAPI_ISteamUGC_CreateItem( hSteamUGC, SKATERIFT_APPID, k_EWorkshopFileTypeCommunity );
+ call->cb = on_workshop_createitem;
+ call->id = SteamAPI_ISteamUGC_CreateItem( _steam_api.pSteamUGC, SKATERIFT_APPID, k_EWorkshopFileTypeCommunity );
}
}
THREAD_0;
workshop_form.op = k_workshop_op_downloading_submission;
- ISteamUGC *hSteamUGC = SteamAPI_SteamUGC();
- ISteamRemoteStorage *hSteamRemoteStorage = SteamAPI_SteamRemoteStorage();
SteamUGCDetails_t details;
- if( SteamAPI_ISteamUGC_GetQueryUGCResult( hSteamUGC, workshop_form.ugc_query.handle, result_index, &details ) )
+ if( SteamAPI_ISteamUGC_GetQueryUGCResult( _steam_api.pSteamUGC, workshop_form.ugc_query.handle, result_index, &details ) )
{
workshop_reset_submission_data();
workshop_form.submission.submit_description = 0;
u8 metadata_buf[512];
char metadata_str[1024+1];
- int have_meta = SteamAPI_ISteamUGC_GetQueryUGCMetadata( hSteamUGC, workshop_form.ugc_query.handle,
+ int have_meta = SteamAPI_ISteamUGC_GetQueryUGCMetadata( _steam_api.pSteamUGC, workshop_form.ugc_query.handle,
result_index, metadata_str,
1024+1 );
workshop_form.view_published_page_id = page;
workshop_form.published_files_list_length = count;
- ISteamUGC *hSteamUGC = SteamAPI_SteamUGC();
for( int i=0; i<count; i ++ )
{
struct published_file *pfile = &workshop_form.published_files_list[i];
SteamUGCDetails_t details;
- if( SteamAPI_ISteamUGC_GetQueryUGCResult( hSteamUGC, workshop_form.ugc_query.handle, start+i, &details ) )
+ if( SteamAPI_ISteamUGC_GetQueryUGCResult( _steam_api.pSteamUGC, workshop_form.ugc_query.handle, start+i, &details ) )
{
if( details.m_eResult != k_EResultOK )
snprintf( pfile->title, 80, "Error (%d)", details.m_eResult );
workshop_form.view_published_page_id = 0;
workshop_form.published_files_list_length = 0;
- ISteamUGC *hSteamUGC = SteamAPI_SteamUGC();
- SteamAPI_ISteamUGC_ReleaseQueryUGCRequest( hSteamUGC, query->m_handle );
+ SteamAPI_ISteamUGC_ReleaseQueryUGCRequest( _steam_api.pSteamUGC, query->m_handle );
}
}
*/
int workshop_submit_command( int argc, const char *argv[] )
{
- if( !steam_ready )
+ if( _steam_api.disabled )
{
ui_start_modal( &vg_ui.ctx, "Steam API is not initialized\n", NULL, UI_MODAL_BAD, NULL );
return 0;
workshop_form.published_files_list_length = 0;
workshop_form.ugc_query.result = k_EResultNone;
- vg_steam_async_call *call = vg_alloc_async_steam_api_call();
+ vg_steam_api_call *call = vg_alloc_async_steam_api_call();
- ISteamUser *hSteamUser = SteamAPI_SteamUser();
CSteamID steamid;
- steamid.m_unAll64Bits = SteamAPI_ISteamUser_GetSteamID( hSteamUser );
+ steamid.m_unAll64Bits = SteamAPI_ISteamUser_GetSteamID( _steam_api.pSteamUser );
- ISteamUGC *hSteamUGC = SteamAPI_SteamUGC();
- call->p_handler = on_workshop_UGCQueryComplete;
+ call->cb = on_workshop_UGCQueryComplete;
call->userdata = NULL;
UGCQueryHandle_t handle = SteamAPI_ISteamUGC_CreateQueryUserUGCRequest
(
- hSteamUGC,
+ _steam_api.pSteamUGC,
steamid.m_comp.m_unAccountID,
k_EUserUGCList_Published,
k_EUGCMatchingUGCType_Items,
k_EUserUGCListSortOrder_CreationOrderDesc,
SKATERIFT_APPID, SKATERIFT_APPID,
1 );
- SteamAPI_ISteamUGC_SetReturnMetadata( hSteamUGC, handle, 1 );
- call->id = SteamAPI_ISteamUGC_SendQueryUGCRequest( hSteamUGC, handle );
+ SteamAPI_ISteamUGC_SetReturnMetadata( _steam_api.pSteamUGC, handle, 1 );
+ call->id = SteamAPI_ISteamUGC_SendQueryUGCRequest( _steam_api.pSteamUGC, handle );
return 0;
}
if( ui_button_text( ctx, btn_right, "\xb2", 2 ) == 1 )
{
- ISteamFriends *hSteamFriends = SteamAPI_SteamFriends();
- SteamAPI_ISteamFriends_ActivateGameOverlayToWebPage( hSteamFriends,
+ SteamAPI_ISteamFriends_ActivateGameOverlayToWebPage( _steam_api.pSteamFriends,
"https://steamcommunity.com/sharedfiles/workshoplegalagreement",
k_EActivateGameOverlayToWebPageMode_Default );
}
workshop_form_gui_sidebar( ctx, sidebar );
}
-
-/*
- * Some async api stuff
- * -----------------------------------------------------------------------------
- */
-
-#if 0
-void async_workshop_get_filepath( void *data, u32 len )
-{
- struct async_workshop_filepath_info *info = data;
-
- u64 _size;
- u32 _ts;
-
- ISteamUGC *hSteamUGC = SteamAPI_SteamUGC();
- if( !SteamAPI_ISteamUGC_GetItemInstallInfo( hSteamUGC, info->id, &_size, info->buf, info->len, &_ts ))
- {
- vg_error( "GetItemInstallInfo failed\n" );
- info->buf[0] = '\0';
- }
-}
-#endif
#pragma once
#include "addon_types.h"
-#include "vg/vg_steam_remote_storage.h"
+#include "vg/vg_steam2.h"
#include "skaterift.h"
-#include "vg/vg_steam_auth.h"
-#include "vg/vg_steam_ugc.h"
-#include "vg/vg_steam_friends.h"
-#include "steam.h"
#include "ent_skateshop.h"
struct async_workshop_filepath_info{
-#include "vg/vg_steam.h"
-#include "vg/vg_steam_user_stats.h"
+#include "vg/vg_steam2.h"
#include "model.h"
#include "entity.h"
#include "world.h"
#include "font.h"
#include "gui.h"
-#include "steam.h"
#include "network_msg.h"
#include "network_common.h"
{
struct track_info *ti = &track_infos[ route->anon.official_track_id ];
if( ti->achievement_id )
- {
- steam_set_achievement( ti->achievement_id );
- steam_store_achievements();
- }
+ vg_steam_set_achievement( ti->achievement_id, 1 );
}
char mod_uid[ ADDON_UID_MAX ];
projects / carveJwlIkooP6JGAAIwe30JlM.git / commitdiff