mirrors/thug
1
Fork 0
mirror of https://github.com/thug1src/thug.git synced 2025-01-22 13:53:46 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
d8eb714766
thug/Code/Sk/GameNet/Ngps/p_content.cpp
thug1src d8eb714766 thug1src
2016-02-14 08:39:12 +11:00

1668 lines
56 KiB
C++
Raw Blame History

/*****************************************************************************
** **
** Neversoft Entertainment. **
** **
** Copyright (C) 2000 - All Rights Reserved **
** **
******************************************************************************
** **
** Project: Skate4 **
** **
** Module: GameNet **
** **
** File name: Lobby.cpp **
** **
** Created by: 04/4/02 - spg **
** **
** Description: Gamespy peer lobby implementation **
** **
*****************************************************************************/
/*****************************************************************************
** Includes **
*****************************************************************************/
#include <core/defines.h>
#include <core/thread.h>
#include <core/singleton.h>
#include <gel/mainloop.h>
#include <gel/scripting/script.h>
#include <gel/scripting/utils.h>
#include <sk/gamenet/gamenet.h>
#include <sk/gamenet/ngps/p_content.h>
#include <sk/gamenet/ngps/p_buddy.h>
#include <sk/scripting/cfuncs.h>
#include <sk/scripting/mcfuncs.h>
#include <sk/ParkEditor2/EdMap.h>
// for downloading faces
#include <sk/modules/skate/skate.h>
#include <sk/objects/skaterprofile.h>
#include <gfx/facetexture.h>
#include <gfx/modelappearance.h>
#include <ghttp/ghttp.h>
#include <ghttp/ghttppost.h>
/*****************************************************************************
** DBG Information **
*****************************************************************************/
namespace GameNet
{
/*****************************************************************************
** Externals **
*****************************************************************************/
/*****************************************************************************
** Defines **
*****************************************************************************/
#define vHTTP_COMM_TIMEOUT Tmr::Seconds( 25 )
#define vMAX_FACE_SIZE ( 32 * 1024 )
#define vMAX_FILE_SIZE ( 80 * 1024 )
/*****************************************************************************
** Private Types **
*****************************************************************************/
/*****************************************************************************
** Private Data **
*****************************************************************************/
/*****************************************************************************
** Public Data **
*****************************************************************************/
/*****************************************************************************
** Private Prototypes **
*****************************************************************************/
/*****************************************************************************
** Private Functions **
*****************************************************************************/
/******************************************************************/
/* */
/* */
/******************************************************************/
void ContentMan::s_progress_callback( GHTTPRequest request, // The request.
GHTTPState state, // The current state of the request.
const char* buffer, // The file's bytes so far, NULL if state<GHTTPReceivingFile.
int buffer_len, // The number of bytes in the buffer, 0 if state<GHTTPReceivingFile.
int bytes_received, // The total number of bytes receivied, 0 if state<GHTTPReceivingFile.
int total_size, // The total size of the file, -1 if unknown.
void * param // User-data.
)
{
ContentMan* content_man;
content_man = (ContentMan*) param;
Dbg_Printf( "state: %d buffer len: %d, bytes received %d, total_size %d\n", state, buffer_len, bytes_received, total_size );
if( ( state == GHTTPReceivingFile ) ||
( state == GHTTPPosting ))
{
if( total_size > 0 )
{
content_man->m_percent_complete = (int) (((float) bytes_received / (float) total_size ) * 100.0f );
}
}
content_man->m_last_comm_time = Tmr::GetTime();
}
/******************************************************************/
/* */
/* */
/******************************************************************/
GHTTPBool ContentMan::s_dl_completed_callback( GHTTPRequest request, // The request.
GHTTPResult result, // The result (success or an error).
char* buffer, // The file's bytes (only valid if ghttpGetFile[Ex] was used).
int buffer_len, // The file's length.
void * param // User-data.
)
{
ContentMan* content_man;
content_man = (ContentMan*) param;
Dbg_Printf( "Got result %d\n", result );
content_man->m_percent_complete = 100;
if( result == GHTTPSuccess )
{
uint32 type;
content_man->m_result = vCONTENT_RESULT_SUCCESS;
type = 0;
switch( content_man->m_vault_type )
{
case 0x5be5569f: // parks
type = CRCD(0x3bf882cc,"park");
break;
case 0x7364ea1: // skaters
type = CRCD(0xb010f357,"optionsandpros");
break;
case 0x38dbe1d0: // goals
type = CRCD(0x62896edf,"createdgoals");
break;
case 0x1e26fd3e: // tricks
type = CRCD(0x61a1bc57,"cat");
break;
default:
Dbg_Assert( 0 );
break;
}
CFuncs::SetVaultData((uint8*) buffer, type );
content_man->m_error = 0;
}
else
{
content_man->m_result = vCONTENT_RESULT_FAILURE;
content_man->m_error = result;
}
return GHTTPTrue;
}
/******************************************************************/
/* */
/* */
/******************************************************************/
GHTTPBool ContentMan::s_face_dl_completed_callback( GHTTPRequest request, // The request.
GHTTPResult result, // The result (success or an error).
char* buffer, // The file's bytes (only valid if ghttpGetFile[Ex] was used).
int buffer_len, // The file's length.
void * param // User-data.
)
{
ContentMan* content_man;
content_man = (ContentMan*) param;
Dbg_Printf( "Got result %d\n", result );
content_man->m_percent_complete = 100;
if( result == GHTTPSuccess )
{
content_man->m_result = vCONTENT_RESULT_SUCCESS;
content_man->m_error = 0;
// Copy the downloaded data to the skater profile
Mdl::Skate* skate_mod = Mdl::Skate::Instance();
Obj::CSkaterProfile* pSkaterProfile = skate_mod->GetCurrentProfile();
Dbg_Assert( pSkaterProfile );
Dbg_MsgAssert( !pSkaterProfile->IsPro(), ( "Can only download face onto a custom skater. UI must make the custom skater active before this point" ) );
Gfx::CModelAppearance* pAppearance = pSkaterProfile->GetAppearance();
Dbg_Assert( pAppearance );
Gfx::CFaceTexture* pFaceTexture = pAppearance->GetFaceTexture();
Dbg_MsgAssert( pFaceTexture, ( "Appearance has no face texture" ) );
// GJ: The CFaceTexture is permanently allocated in the
// custom skater, so there should be no need to push
// any heap contexts here... if this assumption changes,
// then we should probably push the skt_info heap
pFaceTexture->ReadTextureDataFromBuffer( (uint8*)buffer, 0 );
pFaceTexture->SetValid( true );
// rebuild the skater to display the new face
Script::RunScript( CRCD(0x808008ea,"refresh_skater_model") );
}
else
{
content_man->m_result = vCONTENT_RESULT_FAILURE;
content_man->m_error = result;
}
return GHTTPTrue;
}
/******************************************************************/
/* */
/* */
/******************************************************************/
GHTTPBool ContentMan::s_ul_completed_callback( GHTTPRequest request, // The request.
GHTTPResult result, // The result (success or an error).
char* buffer, // The file's bytes (only valid if ghttpGetFile[Ex] was used).
int buffer_len, // The file's length.
void * param // User-data.
)
{
ContentMan* content_man;
content_man = (ContentMan*) param;
Dbg_Printf( "Got result %d\n", result );
content_man->m_percent_complete = 100;
if( result == GHTTPSuccess )
{
content_man->m_result = vCONTENT_RESULT_SUCCESS;
}
else
{
content_man->m_result = vCONTENT_RESULT_FAILURE;
}
return GHTTPTrue;
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void ContentMan::s_http_transfer_code( const Tsk::Task< ContentMan > &task )
{
ContentMan& content_man = task.GetData();
if(( Tmr::GetTime() - content_man.m_last_comm_time ) > vHTTP_COMM_TIMEOUT )
{
if( content_man.m_state != vCONTENT_STATE_IDLE )
{
delete [] content_man.m_buffer;
}
Dbg_Printf( "********* TIMING OUT!!!!\n" );
Dbg_Assert( content_man.m_transfer_failed_script );
ghttpCancelRequest( content_man.m_file_request );
Script::RunScript( content_man.m_transfer_failed_script );
content_man.m_state = vCONTENT_STATE_IDLE;
content_man.m_http_transfer_task->Remove();
//ghttpCleanup();
return;
}
Mem::Manager::sHandle().PushContext(Mem::Manager::sHandle().InternetTopDownHeap());
ghttpThink();
Mem::Manager::sHandle().PopContext();
if( content_man.m_percent_complete < 100 )
{
if(( content_man.m_state == vCONTENT_STATE_DOWNLOADING ) ||
( content_man.m_state == vCONTENT_STATE_DOWNLOADING_FACE ))
{
Script::CStruct* p_item_params;
char pct_string[8];
sprintf( pct_string, "%d%%", content_man.m_percent_complete );
p_item_params = new Script::CStruct;
p_item_params->AddComponent( Script::GenerateCRC( "text" ), ESYMBOLTYPE_STRING, pct_string );
Dbg_Assert( content_man.m_update_progress_script );
Script::RunScript( content_man.m_update_progress_script, p_item_params );
delete p_item_params;
}
}
else
{
if( ( content_man.m_state == vCONTENT_STATE_DOWNLOADING ) ||
( content_man.m_state == vCONTENT_STATE_DOWNLOADING_FACE ))
{
delete [] content_man.m_buffer;
}
//WaitSema( content_man.m_thread_semaphore_id );
if(( content_man.m_state == vCONTENT_STATE_DOWNLOADING ) ||
( content_man.m_state == vCONTENT_STATE_DOWNLOADING_FACE ) ||
( content_man.m_state == vCONTENT_STATE_UPLOADING ))
{
int prev_state;
prev_state = content_man.m_state;
content_man.m_http_transfer_task->Remove();
content_man.m_state = vCONTENT_STATE_IDLE;
if( content_man.m_result == vCONTENT_RESULT_SUCCESS )
{
Script::CStruct* params;
params = new Script::CStruct;
params->AddChecksum( "type", content_man.m_vault_type );
if( prev_state == vCONTENT_STATE_UPLOADING )
{
Script::RunScript( "LaunchUploadCompleteDialog", params );
}
else
{
Dbg_Assert( content_man.m_transfer_complete_script );
Script::RunScript( content_man.m_transfer_complete_script, params );
}
delete params;
}
else
{
if( content_man.m_error == GHTTPFileNotFound )
{
Dbg_Assert( content_man.m_file_not_found_script );
Script::RunScript( content_man.m_file_not_found_script );
}
else
{
Dbg_Assert( content_man.m_transfer_failed_script );
Script::RunScript( content_man.m_transfer_failed_script );
}
}
if( ( prev_state == vCONTENT_STATE_DOWNLOADING ) ||
( prev_state == vCONTENT_STATE_DOWNLOADING_FACE ))
{
//delete [] content_man.m_buffer;
}
if( prev_state == vCONTENT_STATE_UPLOADING )
{
delete [] content_man.m_buffer;
}
//content_man.m_state = vCONTENT_STATE_IDLE;
//content_man.m_http_transfer_task->Remove();
//ghttpCleanup();
}
else if( content_man.m_state == vCONTENT_STATE_GETTING_DIR_LIST )
{
if( content_man.m_result == vCONTENT_RESULT_SUCCESS )
{
char* token;
Directory* dir;
Mem::Manager::sHandle().PushContext(Mem::Manager::sHandle().InternetBottomUpHeap());
Dbg_Printf( "**** Parsing directory listing\n" );
token = strtok( content_man.m_buffer, "\r\n" );
if( token )
{
do
{
Dbg_Printf( "**** Got dir %s\n", token );
dir = new Directory;
content_man.m_directories.AddToHead( dir );
strcpy( dir->m_Name, token );
} while(( token = strtok( NULL, "\r\n" )));
content_man.m_cur_dir = content_man.m_next_dir_sh.FirstItem( content_man.m_directories );
if( content_man.m_cur_dir->m_Uploads )
{
content_man.m_cur_dir = content_man.m_next_dir_sh.NextItem();
}
Dbg_Printf( "**** Getting subdir listing for %s\n", content_man.m_cur_dir->m_Name );
content_man.m_state = vCONTENT_STATE_IDLE;
//ghttpCleanup();
delete [] content_man.m_buffer;
//SignalSema( content_man.m_thread_semaphore_id );
content_man.GetSubDirListing( content_man.m_cur_dir );
Mem::Manager::sHandle().PopContext();
return;
}
Mem::Manager::sHandle().PopContext();
}
else
{
content_man.m_state = vCONTENT_STATE_IDLE;
content_man.m_http_transfer_task->Remove();
//ghttpCleanup();
delete [] content_man.m_buffer;
Dbg_Assert( content_man.m_transfer_failed_script );
Script::RunScript( content_man.m_transfer_failed_script );
}
}
else if( content_man.m_state == vCONTENT_STATE_GETTING_SUB_DIR_LIST )
{
Mem::Manager::sHandle().PushContext(Mem::Manager::sHandle().InternetBottomUpHeap());
Dbg_Printf( "Got sub_dir list\n" );
if( content_man.m_result == vCONTENT_RESULT_SUCCESS )
{
Content* content;
char* line, *colon, *token;
char fname[Content::vMAX_FILE_NAME_LEN + 1];
char buff[128];
line = strtok( content_man.m_buffer, "\r\n" );
if( line )
{
do
{
content = new Content;
content_man.m_cur_dir->m_content_list.AddToHead( content );
token = line;
colon = strstr( line, ":" );
Dbg_Assert( colon );
*colon = '\0';
strcpy( fname, token );
sprintf( content->m_Path, "http://www.thugonline.com/%s/%s/%s", content_man.m_vault_root, content_man.m_cur_dir->m_Name, fname );
Dbg_Printf( "Filename: %s\n", fname );
token = colon + 1;
colon = strstr( token, ":" );
Dbg_Assert( colon );
*colon = '\0';
strcpy( content->m_Name, token );
Dbg_Printf( "Display name: %s\n", content->m_Name );
token = colon + 1;
colon = strstr( token, ":" );
Dbg_Assert( colon );
*colon = '\0';
strcpy( content->m_Creator, token );
Dbg_Printf( "Creator: %s\n", content->m_Creator );
// Read the content size, if we're looking at parks
if( content_man.m_vault_type == CRCD(0x5be5569f,"parks") )
{
token = colon + 1;
colon = strstr( token, ":" );
Dbg_Assert( colon );
*colon = '\0';
strcpy( content->m_Size, token );
Dbg_Printf( "Size: %s\n", content->m_Size );
token = colon + 1;
colon = strstr( token, ":" );
Dbg_Assert( colon );
*colon = '\0';
strcpy( buff, token );
content->m_NumPieces = atoi( buff );
Dbg_Printf( "Pieces: %d\n", content->m_NumPieces );
token = colon + 1;
colon = strstr( token, ":" );
Dbg_Assert( colon );
*colon = '\0';
strcpy( buff, token );
content->m_NumGaps = atoi( buff );
Dbg_Printf( "Gaps: %d\n", content->m_NumGaps );
token = colon + 1;
colon = strstr( token, ":" );
Dbg_Assert( colon );
*colon = '\0';
strcpy( buff, token );
content->m_NumGoals = atoi( buff );
Dbg_Printf( "Goals: %d\n", content->m_NumGoals );
token = colon + 1;
colon = strstr( token, ":" );
Dbg_Assert( colon );
*colon = '\0';
strcpy( buff, token );
content->m_Theme = atoi( buff );
Dbg_Printf( "Theme: %d\n", content->m_Theme );
token = colon + 1;
colon = strstr( token, ":" );
Dbg_Assert( colon );
*colon = '\0';
strcpy( buff, token );
content->m_TODScript = atoi( buff );
Dbg_Printf( "Script: 0x%x\n", content->m_TODScript );
}
// Read the content score, if we're looking at tricks
if( content_man.m_vault_type == CRCD(0x1e26fd3e,"tricks") )
{
token = colon + 1;
colon = strstr( token, ":" );
Dbg_Assert( colon );
*colon = '\0';
strcpy( buff, token );
content->m_Score = atoi( buff );
Dbg_Printf( "Score: %d\n", content->m_Score );
}
// Read the content sex, if we're looking at skaters
if( content_man.m_vault_type == CRCD(0x7364ea1,"skaters") )
{
token = colon + 1;
colon = strstr( token, ":" );
Dbg_Assert( colon );
*colon = '\0';
//strcpy( content->m_IsMale, token );
strcpy( buff, token );
content->m_IsMale = atoi( buff );
Dbg_Printf( "IsMale: %d\n", content->m_IsMale );
}
// Read the content sex, if we're looking at skaters
if( content_man.m_vault_type == CRCD(0x38dbe1d0,"goals") )
{
token = colon + 1;
colon = strstr( token, ":" );
Dbg_Assert( colon );
*colon = '\0';
strcpy( buff, token );
content->m_NumGoals = atoi( buff );
Dbg_Printf( "Goals: %d\n", content->m_NumGoals );
}
token = colon + 1;
colon = strstr( token, ":" );
Dbg_Assert( colon );
*colon = '\0';
strcpy( content->m_Checksum, token );
Dbg_Printf( "Checksum: %s\n", content->m_Checksum );
token = colon + 1;
strcpy( content->m_Description, token );
Dbg_Printf( "Desc: %s\n", content->m_Description );
//Dbg_Printf( "////////////////////////\n" );
//Dbg_Printf( "Name: %s\n", content->m_Name );
//Dbg_Printf( "Creator: %s\n", content->m_Creator );
//Dbg_Printf( "Size: %s\n", content->m_Size );
//Dbg_Printf( "Checksum: %s\n", content->m_Checksum );
//Dbg_Printf( "Desc: %s\n", content->m_Description );
} while(( line = strtok( NULL, "\r\n" )));
}
content_man.m_state = vCONTENT_STATE_IDLE;
//ghttpCleanup();
delete [] content_man.m_buffer;
content_man.m_cur_dir = content_man.m_next_dir_sh.NextItem();
if(( content_man.m_cur_dir == NULL ) || ( content_man.m_cur_dir->m_Uploads ))
{
Script::CStruct* pParams;
content_man.m_cur_dir = content_man.m_next_dir_sh.FirstItem( content_man.m_directories );
// We are done. Now display the first category of files
//Dbg_Printf( "**** Done downloading subdirectory listings\n" );
content_man.m_http_transfer_task->Remove();
pParams = new Script::CStruct;
pParams->AddString( "category", content_man.m_cur_dir->m_Name );
pParams->AddChecksum( "type", content_man.m_vault_type );
Script::RunScript( "net_vault_menu_create", pParams );
delete pParams;
}
else
{
content_man.GetSubDirListing( content_man.m_cur_dir );
}
}
else
{
content_man.m_state = vCONTENT_STATE_IDLE;
content_man.m_http_transfer_task->Remove();
//ghttpCleanup();
delete [] content_man.m_buffer;
Dbg_Assert( content_man.m_transfer_failed_script );
Script::RunScript( content_man.m_transfer_failed_script );
}
Mem::Manager::sHandle().PopContext();
}
else if( content_man.m_state == vCONTENT_STATE_GETTING_UPLOADED_LEVELS )
{
char* line, *colon, *token;
Content* content;
Mem::Manager::sHandle().PushContext(Mem::Manager::sHandle().InternetBottomUpHeap());
line = strtok( content_man.m_buffer, "\r\n" );
if( line )
{
do
{
content = new Content;
content_man.m_cur_dir->m_content_list.AddToHead( content );
//Dbg_Printf( "******************************************\n" );
//Dbg_Printf( "Line: %s\n", line );
sprintf( content->m_Path, "http://www.thugonline.com/%s/%s", content_man.m_vault_root, line );
token = line;
colon = strstr( line, ":" );
Dbg_Assert( colon );
*colon = '\0';
strcpy( content->m_Name, token );
token = colon + 1;
colon = strstr( token, ":" );
Dbg_Assert( colon );
*colon = '\0';
strcpy( content->m_Creator, token );
token = colon + 1;
colon = strstr( token, ":" );
Dbg_Assert( colon );
*colon = '\0';
strcpy( content->m_Size, token );
token = colon + 1;
colon = strstr( token, ":" );
Dbg_Assert( colon );
*colon = '\0';
strcpy( content->m_Checksum, token );
token = colon + 1;
strcpy( content->m_Description, token );
/*Dbg_Printf( "////////////////////////\n" );
Dbg_Printf( "Name: %s\n", content->m_Name );
Dbg_Printf( "Creator: %s\n", content->m_Creator );
Dbg_Printf( "Size: %s\n", content->m_Size );
Dbg_Printf( "Checksum: %s\n", content->m_Checksum );
Dbg_Printf( "Desc: %s\n", content->m_Description );
*/
} while(( line = strtok( NULL, "\r\n" )));
}
content_man.m_state = vCONTENT_STATE_IDLE;
content_man.m_http_transfer_task->Remove();
//ghttpCleanup();
delete [] content_man.m_buffer;
content_man.DownloadDirectoryListing();
Mem::Manager::sHandle().PopContext();
}
//SignalSema( content_man.m_thread_semaphore_id );
}
}
/*****************************************************************************
** Public Functions **
*****************************************************************************/
void ContentMan::FreeDirectoryListing( void )
{
Directory* dir, *next;
Lst::Search< Directory > sh;
for( dir = sh.FirstItem( m_directories ); dir; dir = next )
{
next = sh.NextItem();
delete dir;
}
ghttpCleanup();
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void ContentMan::GetDirListing( char* path )
{
GameNet::Manager * gamenet_man = GameNet::Manager::Instance();
Thread::PerThreadStruct net_thread_data;
sprintf( m_download_path, path );
//mlp_man->AddLogicTask( *m_http_transfer_task );
m_percent_complete = 0;
m_last_comm_time = Tmr::GetTime();
m_transfer_complete_script = CRCD(0x89990f,"LaunchDownloadCompleteDialog");
m_transfer_failed_script = CRCD(0x7335ab7f,"LaunchTransferFailedDialog");
m_file_not_found_script = CRCD(0xcf040665,"LaunchGeneralFileNotFoundDialog");
m_update_progress_script = CRCD(0x4b85ee64,"update_transfer_progress");
Dbg_Printf( "**** Downloading path %s\n", m_download_path );
net_thread_data.m_pEntry = s_threaded_download_directory_list;
net_thread_data.m_iInitialPriority = vSOCKET_THREAD_PRIORITY;
net_thread_data.m_pStackBase = gamenet_man->GetNetThreadStack();
net_thread_data.m_iStackSize = vNET_THREAD_STACK_SIZE;
net_thread_data.m_utid = 0x152;
Thread::CreateThread( &net_thread_data );
gamenet_man->SetNetThreadId( net_thread_data.m_osId );
//WaitSema( m_thread_semaphore_id );
StartThread( gamenet_man->GetNetThreadId(), this );
//SignalSema( m_thread_semaphore_id );
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void ContentMan::GetSubDirListing( Directory* dir )
{
char subdir_path[128];
sprintf( subdir_path, "http://www.thugonline.com/%s/%s/dir_list.txt", m_vault_root, dir->m_Name );
m_state = vCONTENT_STATE_GETTING_SUB_DIR_LIST;
m_result = vCONTENT_RESULT_UNDETERMINED;
GetDirListing( subdir_path );
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void ContentMan::FillDirectoryListing( char* dir_text )
{
char* token;
Script::CStruct* p_item_params;
Script::CStruct* p_script_params;
//Dbg_Printf( "printing buffer\n" );
//Dbg_Printf( "Buffer: %s\n", dir_text );
token = strtok( dir_text, "\t" );
if( token )
{
p_item_params = new Script::CStruct;
p_item_params->AddString( "text", token );
token = strtok( NULL, "\r\n" );
Dbg_Assert( token );
p_item_params->AddChecksum( "pad_choose_script", Script::GenerateCRC("download_selected_file"));
// create the parameters that are passed to the choose script
p_script_params= new Script::CStruct;
p_script_params->AddString( "file", token );
p_item_params->AddStructure("pad_choose_params",p_script_params);
Script::RunScript( "make_text_sub_menu_item", p_item_params );
delete p_item_params;
delete p_script_params;
while( token )
{
p_item_params = new Script::CStruct;
token = strtok( NULL, "\t" );
if( token == NULL )
{
break;
}
p_item_params->AddString( "text", token );
p_item_params->AddChecksum( "pad_choose_script", Script::GenerateCRC("download_selected_file"));
token = strtok( NULL, "\r\n" );
Dbg_Assert( token );
// create the parameters that are passed to the choose script
p_script_params= new Script::CStruct;
p_script_params->AddString( "file", token );
p_item_params->AddStructure("pad_choose_params",p_script_params);
Script::RunScript( "make_text_sub_menu_item", p_item_params );
delete p_item_params;
delete p_script_params;
}
}
}
/******************************************************************/
/* */
/* */
/******************************************************************/
ContentMan::ContentMan( void )
{
struct SemaParam params;
m_state = vCONTENT_STATE_IDLE;
m_percent_complete = 0;
m_last_comm_time = 0;
m_http_transfer_task = new Tsk::Task< ContentMan > ( s_http_transfer_code, *this );
params.initCount = 1;
params.maxCount = 10;
m_thread_semaphore_id = CreateSema( &params );
}
/******************************************************************/
/* */
/* */
/******************************************************************/
ContentMan::~ContentMan( void )
{
DeleteSema( m_thread_semaphore_id );
delete m_http_transfer_task;
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void ContentMan::s_threaded_download_directory_list( ContentMan* content_man )
{
WaitSema( content_man->m_thread_semaphore_id );
Mem::Manager::sHandle().PushContext(Mem::Manager::sHandle().InternetBottomUpHeap());
// Register this thread with the sockets API
sockAPIregthr();
content_man->m_buffer = new char[100000];
memset( content_man->m_buffer, 0, 100000 );
content_man->m_file_request = ghttpGetEx( content_man->m_download_path,
NULL,
content_man->m_buffer,
100000,
NULL,
GHTTPFalse,
GHTTPFalse,
s_progress_callback,
s_ul_completed_callback,
content_man );
//delete buffer;
// Deregister this thread with the sockets API
sockAPIderegthr();
//printf( "******** EXITING DOWNLOAD DIRECTORY THREAD\n" );
Mem::Manager::sHandle().PopContext();
SignalSema( content_man->m_thread_semaphore_id );
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void ContentMan::DownloadDirectoryListing( void )
{
char path[128];
Mlp::Manager * mlp_man = Mlp::Manager::Instance();
m_state = vCONTENT_STATE_GETTING_DIR_LIST;
sprintf( path, "http://www.thugonline.com/%s/dir_list.txt", m_vault_root );
GetDirListing( path );
m_result = vCONTENT_RESULT_UNDETERMINED;;
mlp_man->AddLogicTask( *m_http_transfer_task );
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void ContentMan::DownloadFace( char* filename )
{
Mlp::Manager * mlp_man = Mlp::Manager::Instance();
GameNet::Manager * gamenet_man = GameNet::Manager::Instance();
Thread::PerThreadStruct net_thread_data;
char path[256];
Mem::Manager::sHandle().PushContext(Mem::Manager::sHandle().InternetBottomUpHeap());
m_state = vCONTENT_STATE_DOWNLOADING_FACE;
m_result = vCONTENT_RESULT_UNDETERMINED;
mlp_man->AddLogicTask( *m_http_transfer_task );
m_percent_complete = 0;
m_last_comm_time = Tmr::GetTime();
m_transfer_complete_script = CRCD(0x1d53d27f,"LaunchFaceDownloadCompleteDialog");
m_transfer_failed_script = CRCD(0x7335ab7f,"LaunchTransferFailedDialog");
m_file_not_found_script = CRCD(0x609f7535,"LaunchFileNotFoundDialog");
m_update_progress_script = CRCD(0x4b85ee64,"update_transfer_progress");
net_thread_data.m_pEntry = s_threaded_download_face;
net_thread_data.m_iInitialPriority = vSOCKET_THREAD_PRIORITY;
net_thread_data.m_pStackBase = gamenet_man->GetNetThreadStack();
net_thread_data.m_iStackSize = vNET_THREAD_STACK_SIZE;
net_thread_data.m_utid = 0x152;
Thread::CreateThread( &net_thread_data );
gamenet_man->SetNetThreadId( net_thread_data.m_osId );
Dbg_Printf( "In DownloadFace. Path: %s\n", filename );
WaitSema( m_thread_semaphore_id );
sprintf( path, "http://www.thugonline.com/faces/%s", filename );
Dbg_Printf( "Downloading %s\n", path );
StartThread( gamenet_man->GetNetThreadId(), (char*) path );
SignalSema( m_thread_semaphore_id );
Mem::Manager::sHandle().PopContext();
}
/******************************************************************/
/* */
/* */
/******************************************************************/
bool ContentMan::ScriptDownloadFace(Script::CScriptStructure *pParams, Script::CScript *pScript)
{
GameNet::Manager * gamenet_man = GameNet::Manager::Instance();
ContentMan* content_man;
BuddyMan* buddy_man;
char filename[128];
const char* key;
pParams->GetString( "string", &key, Script::ASSERT );
sprintf( filename, "%s.img.ps2", key );
Dbg_Printf( "Downloading %s...\n", filename );
content_man = gamenet_man->mpContentMan;
buddy_man = gamenet_man->mpBuddyMan;
buddy_man->GetProfile();
content_man->DownloadFace( filename );
return true;
}
/******************************************************************/
/* */
/* */
/******************************************************************/
bool ContentMan::ScriptDownloadDirectoryList(Script::CScriptStructure *p_item_params, Script::CScript *pScript)
{
GameNet::Manager * gamenet_man = GameNet::Manager::Instance();
Mlp::Manager * mlp_man = Mlp::Manager::Instance();
ContentMan* content_man;
BuddyMan* buddy_man;
content_man = gamenet_man->mpContentMan;
buddy_man = gamenet_man->mpBuddyMan;
p_item_params->GetChecksum( NONAME, &content_man->m_vault_type , true );
switch( content_man->m_vault_type )
{
case 0x5be5569f: // parks
sprintf( content_man->m_vault_root, "levels" );
break;
case 0x7364ea1: // skaters
sprintf( content_man->m_vault_root, "skaters" );
break;
case 0x38dbe1d0: // goals
sprintf( content_man->m_vault_root, "goals" );
break;
case 0x1e26fd3e: // tricks
sprintf( content_man->m_vault_root, "tricks" );
break;
default:
Dbg_Assert( 0 );
break;
}
if( buddy_man->GetProfile() == 18549782 ) // Gamespy profile of our level-verifying account
{
Directory* dir;
char path[128];
Mem::Manager::sHandle().PushContext(Mem::Manager::sHandle().InternetBottomUpHeap());
dir = new Directory;
dir->m_Uploads = true;
content_man->m_directories.AddToHead( dir );
strcpy( dir->m_Name, "Uploads" );
content_man->m_cur_dir = content_man->m_next_dir_sh.FirstItem( content_man->m_directories );
content_man->m_state = vCONTENT_STATE_GETTING_UPLOADED_LEVELS;
content_man->m_result = vCONTENT_RESULT_UNDETERMINED;
sprintf( path, "http://www.thugonline.com/%s/uploads.txt", content_man->m_vault_root );
content_man->GetDirListing( path );
mlp_man->AddLogicTask( *content_man->m_http_transfer_task );
Mem::Manager::sHandle().PopContext();
}
else
{
content_man->DownloadDirectoryListing();
}
return true;
}
/******************************************************************/
/* */
/* */
/******************************************************************/
bool ContentMan::ScriptFreeDirectoryListing(Script::CScriptStructure *pParams, Script::CScript *pScript)
{
GameNet::Manager * gamenet_man = GameNet::Manager::Instance();
ContentMan* content_man;
content_man = gamenet_man->mpContentMan;
content_man->FreeDirectoryListing();
return true;
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void ContentMan::s_threaded_download_file( const char* path )
{
int max_size;
GameNet::Manager * gamenet_man = GameNet::Manager::Instance();
ContentMan* content_man;
content_man = gamenet_man->mpContentMan;
WaitSema( content_man->m_thread_semaphore_id );
Mem::Manager::sHandle().PushContext(Mem::Manager::sHandle().InternetBottomUpHeap());
max_size = content_man->m_buffer_size;
content_man->m_buffer = new char[max_size];
// Register this thread with the sockets API
sockAPIregthr();
//Dbg_Printf( "downloading %s, size: %d dl complete: %p\n", path, max_size, content_man->m_dl_complete );
gamenet_man->mpContentMan->m_file_request = ghttpGetEx( path,
NULL,
content_man->m_buffer,
max_size,
NULL,
GHTTPFalse,
GHTTPFalse,
s_progress_callback,
content_man->m_dl_complete,
content_man );
// Deregister this thread with the sockets API
sockAPIderegthr();
Mem::Manager::sHandle().PopContext();
SignalSema( gamenet_man->mpContentMan->m_thread_semaphore_id );
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void ContentMan::s_threaded_download_face( const char* path )
{
GameNet::Manager * gamenet_man = GameNet::Manager::Instance();
WaitSema( gamenet_man->mpContentMan->m_thread_semaphore_id );
Mem::Manager::sHandle().PushContext(Mem::Manager::sHandle().InternetBottomUpHeap());
gamenet_man->mpContentMan->m_buffer = new char[vMAX_FACE_SIZE];
// Register this thread with the sockets API
sockAPIregthr();
gamenet_man->mpContentMan->m_file_request = ghttpGetEx( path,
NULL,
gamenet_man->mpContentMan->m_buffer,
vMAX_FACE_SIZE,
NULL,
GHTTPFalse,
GHTTPFalse,
s_progress_callback,
s_face_dl_completed_callback,
gamenet_man->mpContentMan );
// Deregister this thread with the sockets API
sockAPIderegthr();
Mem::Manager::sHandle().PopContext();
SignalSema( gamenet_man->mpContentMan->m_thread_semaphore_id );
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void ContentMan::SetPercentComplete( int percent_complete )
{
m_percent_complete = percent_complete;
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void ContentMan::SetResult( int result )
{
m_result = result;
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void ContentMan::SetError( int error )
{
m_error = error;
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void ContentMan::DownloadFile( DownloadContext* context )
{
Mlp::Manager * mlp_man = Mlp::Manager::Instance();
GameNet::Manager * gamenet_man = GameNet::Manager::Instance();
ContentMan* content_man;
Thread::PerThreadStruct net_thread_data;
Mem::Manager::sHandle().PushContext(Mem::Manager::sHandle().InternetBottomUpHeap());
Dbg_Printf( "Downloading %s\n", context->m_path );
content_man = gamenet_man->mpContentMan;
content_man->m_state = vCONTENT_STATE_DOWNLOADING;
content_man->m_result = vCONTENT_RESULT_UNDETERMINED;
mlp_man->AddLogicTask( *content_man->m_http_transfer_task );
content_man->m_percent_complete = 0;
content_man->m_last_comm_time = Tmr::GetTime();
content_man->m_buffer_size = context->m_max_size;
content_man->m_transfer_failed_script = context->m_transfer_failed_script;
content_man->m_transfer_complete_script = context->m_transfer_complete_script;
content_man->m_update_progress_script = context->m_update_progress_script;
content_man->m_file_not_found_script = context->m_file_not_found_script;
content_man->m_dl_complete = context->m_dl_complete;
net_thread_data.m_pEntry = s_threaded_download_file;
net_thread_data.m_iInitialPriority = vSOCKET_THREAD_PRIORITY;
net_thread_data.m_pStackBase = gamenet_man->GetNetThreadStack();
net_thread_data.m_iStackSize = vNET_THREAD_STACK_SIZE;
net_thread_data.m_utid = 0x152;
Thread::CreateThread( &net_thread_data );
gamenet_man->SetNetThreadId( net_thread_data.m_osId );
WaitSema( content_man->m_thread_semaphore_id );
StartThread( gamenet_man->GetNetThreadId(), context->m_path );
SignalSema( content_man->m_thread_semaphore_id );
Mem::Manager::sHandle().PopContext();
}
/******************************************************************/
/* */
/* */
/******************************************************************/
bool ContentMan::ScriptDownloadFile(Script::CScriptStructure *p_item_params, Script::CScript *pScript)
{
GameNet::Manager * gamenet_man = GameNet::Manager::Instance();
ContentMan* content_man;
const char* path;
DownloadContext context;
p_item_params->GetString( "file", &path );
content_man = gamenet_man->mpContentMan;
context.m_transfer_complete_script = CRCD(0x89990f,"LaunchDownloadCompleteDialog");
context.m_transfer_failed_script = CRCD(0x7335ab7f,"LaunchTransferFailedDialog");
context.m_file_not_found_script = CRCD(0xcf040665,"LaunchGeneralFileNotFoundDialog");
context.m_update_progress_script = CRCD(0x4b85ee64,"update_transfer_progress");
context.m_max_size = vMAX_FILE_SIZE;
sprintf( context.m_path, path );
context.m_dl_complete = s_dl_completed_callback;
content_man->DownloadFile( &context );
return true;
}
/******************************************************************/
/* */
/* */
/******************************************************************
static char* s_fix_name( char* filename )
{
char* ch = filename;
while( *ch )
{
if(( *ch >= '0' ) && ( *ch <= '9' ))
{
ch++;
continue;
}
if(( *ch >= 'A' ) && ( *ch <= 'Z' ))
{
ch++;
continue;
}
if(( *ch >= 'a' ) && ( *ch <= 'z' ))
{
ch++;
continue;
}
if(( *ch == '-' ) || ( *ch =='_' ))
{
ch++;
continue;
}
*ch = '_';
ch++;
}
return filename;
}
/******************************************************************/
/* */
/* */
/******************************************************************/
void ContentMan::s_threaded_upload_file( ContentMan* content_man )
{
GHTTPPost post;
char *file_buffer;
char filename[64], desc[1024], str[64];
GameNet::Manager * gamenet_man = GameNet::Manager::Instance();
Prefs::Preferences* pPreferences;
Script::CStruct* pStructure;
const char* network_id;
int filesize;
uint32 checksum;
pPreferences = gamenet_man->GetNetworkPreferences();
pStructure = pPreferences->GetPreference( Script::GenerateCRC("network_id") );
pStructure->GetText( "ui_string", &network_id, true );
WaitSema( content_man->m_thread_semaphore_id );
sockAPIregthr();
Mem::Manager::sHandle().PushContext(Mem::Manager::sHandle().InternetBottomUpHeap());
post = ghttpNewPost();
switch( content_man->m_vault_type )
{
case 0x5be5569f: // parks
{
filesize = Script::CalculateBufferSize( content_man->m_upload_struct );
file_buffer = new char[filesize];
Script::WriteToBuffer( content_man->m_upload_struct, (uint8*) file_buffer, filesize );
checksum = Crc::GenerateCRC( file_buffer, filesize );
strcpy( filename, content_man->m_upload_filename );
ghttpPostAddString( post, "player", network_id );
sprintf( str, "%d", content_man->m_Width );
ghttpPostAddString( post, "width", str );
sprintf( str, "%d", content_man->m_Height );
ghttpPostAddString( post, "height", str );
sprintf( str, "%d", checksum );
ghttpPostAddString( post, "checksum", str );
sprintf( str, "%d", content_man->m_NumPieces );
ghttpPostAddString( post, "num_pieces", str );
sprintf( str, "%d", content_man->m_NumGaps );
ghttpPostAddString( post, "num_gaps", str );
sprintf( str, "%d", content_man->m_NumGoals );
ghttpPostAddString( post, "num_goals", str );
sprintf( str, "%d", content_man->m_Theme );
ghttpPostAddString( post, "theme", str );
sprintf( str, "0x%x", content_man->m_TODScript );
ghttpPostAddString( post, "tod_script", str );
break;
}
case 0x7364ea1: // skaters
{
ghttpPostAddString( post, "filetype", "cas" );
sprintf( str, "%d", content_man->m_IsMale );
ghttpPostAddString( post, "is_male", str );
filesize = Script::CalculateBufferSize( content_man->m_upload_struct );
file_buffer = new char[filesize];
Script::WriteToBuffer( content_man->m_upload_struct, (uint8*) file_buffer, filesize );
checksum = Crc::GenerateCRC( file_buffer, filesize );
strcpy( filename, content_man->m_upload_filename );
ghttpPostAddString( post, "player", network_id );
sprintf( str, "%d", checksum );
ghttpPostAddString( post, "checksum", str );
Dbg_Printf( "Uploading file: %s\n", filename );
break;
}
case 0x38dbe1d0: // goals
{
ghttpPostAddString( post, "filetype", "cag" );
sprintf( str, "%d", content_man->m_NumGoals );
ghttpPostAddString( post, "num_goals", str );
filesize = Script::CalculateBufferSize( content_man->m_upload_struct );
file_buffer = new char[filesize];
Script::WriteToBuffer( content_man->m_upload_struct, (uint8*) file_buffer, filesize );
checksum = Crc::GenerateCRC( file_buffer, filesize );
strcpy( filename, content_man->m_upload_filename );
ghttpPostAddString( post, "player", network_id );
sprintf( str, "%d", checksum );
ghttpPostAddString( post, "checksum", str );
break;
}
case 0x1e26fd3e: // tricks
{
ghttpPostAddString( post, "filetype", "cat" );
sprintf( str, "%d", content_man->m_Score );
ghttpPostAddString( post, "score", str );
filesize = Script::CalculateBufferSize( content_man->m_upload_struct );
file_buffer = new char[filesize];
Script::WriteToBuffer( content_man->m_upload_struct, (uint8*) file_buffer, filesize );
checksum = Crc::GenerateCRC( file_buffer, filesize );
strcpy( filename, content_man->m_upload_filename );
ghttpPostAddString( post, "player", network_id );
sprintf( str, "%d", checksum );
ghttpPostAddString( post, "checksum", str );
break;
}
default:
file_buffer = NULL;
filesize = 0;
Dbg_Assert( 0 );
break;
}
content_man->m_buffer = file_buffer;
content_man->m_buffer_size = filesize;
ghttpPostAddFileFromMemory( post, "filename", file_buffer, filesize, filename, NULL );
sprintf( desc, "%s", content_man->m_upload_description );
ghttpPostAddString( post, "description", desc );
ghttpPostAddString( post, "uniqueid", GOAGetUniqueID() );
switch( content_man->m_vault_type )
{
case 0x5be5569f: // parks
ghttpPostAddString( post, "filetype", "cap" );
break;
case 0x7364ea1: // skaters
ghttpPostAddString( post, "filetype", "cas" );
break;
case 0x38dbe1d0: // goals
ghttpPostAddString( post, "filetype", "cag" );
break;
case 0x1e26fd3e: // tricks
ghttpPostAddString( post, "filetype", "cat" );
break;
default:
Dbg_Assert( 0 );
break;
}
// debugger log
ghttpPostAddString( post, "dblog", "1" );
content_man->m_file_request = ghttpPostEx( "http://www.thugonline.com/cgi-bin/upload2.pl", NULL, post, GHTTPFalse, GHTTPFalse, s_progress_callback, s_ul_completed_callback, content_man );
// Deregister this thread with the sockets API
sockAPIderegthr();
Mem::Manager::sHandle().PopContext();
SignalSema( content_man->m_thread_semaphore_id );
}
/******************************************************************/
/* */
/* */
/******************************************************************/
bool ContentMan::ScriptUploadFile(Script::CScriptStructure *p_item_params, Script::CScript *pScript)
{
Mlp::Manager * mlp_man = Mlp::Manager::Instance();
ContentMan* content_man;
GameNet::Manager * gamenet_man = GameNet::Manager::Instance();
Thread::PerThreadStruct net_thread_data;
const char* desc, *filename;
content_man = gamenet_man->mpContentMan;
content_man->m_state = vCONTENT_STATE_UPLOADING;
content_man->m_result = vCONTENT_RESULT_UNDETERMINED;
mlp_man->AddLogicTask( *content_man->m_http_transfer_task );
content_man->m_percent_complete = 0;
content_man->m_last_comm_time = Tmr::GetTime();
content_man->m_transfer_failed_script = CRCD(0x7335ab7f,"LaunchTransferFailedDialog");
//Script::PrintContents( p_item_params );
p_item_params->GetChecksum( "type", &content_man->m_vault_type , true );
p_item_params->GetStructure( "data", &content_man->m_upload_struct );
p_item_params->GetString( "description", &desc, Script::ASSERT );
p_item_params->GetString( "filename", &filename, Script::ASSERT );
strcpy( content_man->m_upload_filename, filename );
strcpy( content_man->m_upload_description, desc );
p_item_params->GetInteger( "score", &content_man->m_Score, false );
p_item_params->GetInteger( "width", &content_man->m_Width, false );
p_item_params->GetInteger( "length", &content_man->m_Height, false );
p_item_params->GetInteger( "num_pieces", &content_man->m_NumPieces, false );
p_item_params->GetInteger( "num_gaps", &content_man->m_NumGaps, false );
p_item_params->GetInteger( "num_goals", &content_man->m_NumGoals, false );
p_item_params->GetInteger( "theme", &content_man->m_Theme, false );
p_item_params->GetChecksum( "tod_script", &content_man->m_TODScript, false );
p_item_params->GetInteger( "is_male", &content_man->m_IsMale, false );
net_thread_data.m_pEntry = s_threaded_upload_file;
net_thread_data.m_iInitialPriority = vSOCKET_THREAD_PRIORITY;
net_thread_data.m_pStackBase = gamenet_man->GetNetThreadStack();
net_thread_data.m_iStackSize = vNET_THREAD_STACK_SIZE;
net_thread_data.m_utid = 0x152;
Thread::CreateThread( &net_thread_data );
gamenet_man->SetNetThreadId( net_thread_data.m_osId );
WaitSema( content_man->m_thread_semaphore_id );
StartThread( gamenet_man->GetNetThreadId(), content_man );
SignalSema( content_man->m_thread_semaphore_id );
return true;
}
/******************************************************************/
/* */
/* */
/******************************************************************/
bool ContentMan::ScriptFillVaultMenu(Script::CScriptStructure *pParams, Script::CScript *pScript)
{
ContentMan* content_man;
GameNet::Manager * gamenet_man = GameNet::Manager::Instance();
Lst::Search< Content > sh;
Content* content;
content_man = gamenet_man->mpContentMan;
Mem::Manager::sHandle().PushContext(Mem::Manager::sHandle().InternetTopDownHeap());
for( content = sh.FirstItem( content_man->m_cur_dir->m_content_list ); content; content = sh.NextItem())
{
Script::CStruct* pParams, *pChooseParams;
pParams = new Script::CStruct;
pParams->AddString( "name", content->m_Name );
pParams->AddString( "creator", content->m_Creator );
pParams->AddString( "size", content->m_Size );
pParams->AddInteger( "score", content->m_Score );
pParams->AddInteger( "num_pieces", content->m_NumPieces );
pParams->AddInteger( "num_gaps", content->m_NumGaps );
pParams->AddInteger( "width", content->m_Width );
pParams->AddInteger( "height", content->m_Height );
pParams->AddInteger( "num_goals", content->m_NumGoals );
pParams->AddInteger( "theme", content->m_Theme );
pParams->AddChecksum( "tod_script", content->m_TODScript );
pParams->AddInteger( "is_male", content->m_IsMale );
pParams->AddString( "description", content->m_Description );
pChooseParams = new Script::CStruct;
pChooseParams->AddString( "file", content->m_Path );
pParams->AddStructure( "pad_choose_params", pChooseParams );
switch( content_man->m_vault_type )
{
case 0x5be5569f: // parks
Script::RunScript( "net_vault_menu_add_park", pParams );
break;
case 0x7364ea1: // skaters
Script::RunScript( "net_vault_menu_add_skater", pParams );
break;
case 0x38dbe1d0: // goals
Script::RunScript( "net_vault_menu_add_goal", pParams );
break;
case 0x1e26fd3e: // tricks
Script::RunScript( "net_vault_menu_add_trick", pParams );
break;
default:
Dbg_Assert( 0 );
break;
}
delete pParams;
delete pChooseParams;
}
Mem::Manager::sHandle().PopContext();
return true;
}
/******************************************************************/
/* */
/* */
/******************************************************************/
bool ContentMan::ScriptNextVaultCategory(Script::CScriptStructure *pParams, Script::CScript *pScript)
{
ContentMan* content_man;
GameNet::Manager * gamenet_man = GameNet::Manager::Instance();
Script::CStruct* passback_params;
content_man = gamenet_man->mpContentMan;
content_man->m_cur_dir = content_man->m_next_dir_sh.NextItem();
if( content_man->m_cur_dir == NULL )
{
content_man->m_cur_dir = content_man->m_next_dir_sh.FirstItem( content_man->m_directories );
}
passback_params = pScript->GetParams();
passback_params->AddString( "category", content_man->m_cur_dir->m_Name );
return true;
}
/******************************************************************/
/* */
/* */
/******************************************************************/
bool ContentMan::ScriptPrevVaultCategory(Script::CScriptStructure *pParams, Script::CScript *pScript)
{
ContentMan* content_man;
GameNet::Manager * gamenet_man = GameNet::Manager::Instance();
Script::CStruct* passback_params;
content_man = gamenet_man->mpContentMan;
content_man->m_cur_dir = content_man->m_next_dir_sh.PrevItem();
if( content_man->m_cur_dir == NULL )
{
content_man->m_cur_dir = content_man->m_next_dir_sh.LastItem( content_man->m_directories );
}
passback_params = pScript->GetParams();
passback_params->AddString( "category", content_man->m_cur_dir->m_Name );
return true;
}
/******************************************************************/
/* */
/* */
/******************************************************************/
Directory::Directory( void )
: Lst::Node< Directory > ( this )
{
m_Uploads = false;
}
/******************************************************************/
/* */
/* */
/******************************************************************/
Directory::~Directory( void )
{
Content* content, *next;
Lst::Search< Content > sh;
for( content = sh.FirstItem( m_content_list ); content; content = next )
{
next = sh.NextItem();
delete content;
}
}
/******************************************************************/
/* */
/* */
/******************************************************************/
Content::Content( void )
: Lst::Node< Content > ( this )
{
m_Path[0] = '\0';
m_Name[0] = '\0';
m_Creator[0] = '\0';
m_Size[0] = '\0';
m_Checksum[0] = '\0';
m_Description[0] = '\0';
m_Score = 0;
m_NumPieces = 0;
m_NumGaps = 0;
m_NumGoals = 0;
m_Theme = 0;
m_TODScript = 0;
m_IsMale = 0;
m_Width = 0;
m_Height = 0;
}
/******************************************************************/
/* */
/* */
/******************************************************************/
} // namespace GameNet
Reference in New Issue View Git Blame Copy Permalink