int client_game_init_network( char *opponent_name, int diff )
{
/* create an empty one level levelset. the server will send
* the data into the level everytime we play. */
game_set = levelset_create_empty( 1, "empty", "empty" );
/* create client game context */
game = game_create( GT_NETWORK, diff, 100 );
game_set_current( game );
game_round = 0; /* will be increased by init_next_round() */
game_over = 0;
/* a network game communicates every 25 ms by default */
client_comm_delay = 25;
no_comm_since = 0;
/* initiate players */
players_clear();
player_add( client_name, game->diff->lives, levelset_get_first( game_set ) );
player_add( opponent_name, game->diff->lives, levelset_get_first( game_set ) );
cur_player = players_get_first();
display_text( font, "Receiving level data..." );
set_state( CS_RECV_LEVEL );
return 1;
}
int player_hit(struct player *p, struct game *g) {
if (player_remove(p, g)) {
ERR_TRACE();
return -1;
}
if (!p->lives) {
player_respawn(p);
if (player_add(p, g)) {
ERR_TRACE();
return -1;
}
} else {
if (!--p->lives) {
SDLNet_TCP_Send(p->client->s, "\11", 1);
player_free(p);
} else {
player_respawn(p);
if (player_add(p, g)) {
ERR_TRACE();
return -1;
}
}
}
return 0;
}
bool player_init ()
{
player_list.next = &player_list;
player_list.prev = &player_list;
/* our player */
player_add ();
player_add ();
player_add ();
player_add ();
return true;
}
/* create a one level game context for testing a level */
int client_game_init_testing( Level *level )
{
local_game = game_create( GT_LOCAL, config.diff, 100 );
game_set_current( local_game );
game_set_convex_paddle( config.convex );
game_set_ball_auto_return( !config.return_on_click );
game_set_ball_random_angle( config.random_angle );
game_set_ball_accelerated_speed( config.maxballspeed_float );
local_game->localServerGame = 1;
game = game_create( GT_LOCAL, config.diff, 100 );
game_set_current( game );
players_clear();
player_add( config.player_names[0], game->diff->lives, level );
cur_player = players_get_first();
bkgnd_ids[0] = 0;
init_level( cur_player, PADDLE_BOTTOM );
client_state = CS_NONE;
set_state( CS_PLAY );
return 1;
}
void player_colision()
{
int i;
int point = 0;
for ( i = 0; i < e.count; i++ ) {
if ( pos_test( p.p[0].x, p.p[0].y, e.p[i].x, e.p[i].y ) ) {
p.point += e.p[i].point;
b.point = e.p[i].point;
b.x = e.p[i].x;
b.y = e.p[i].y;
b.active = 1;
b.update = 1;
b.b_count = 5;
eat_set( i, GAME_WIDTH, GAME_HEIGHT );
player_add();
}
}
for ( i = 1; i < p.count; i++ ) {
if ( pos_test( p.p[0].x, p.p[0].y, p.p[i].x, p.p[i].y ) ) {
point = (p.count - i) * EAT_POINT;
printf("cannibalism: adding %d points!\n", point);
p.c = color_set( 0.8f, 0.2f, 0.2f );
p.point += point;
p.count = i-1;
b.point = point;
b.x = p.p[0].x;
b.y = p.p[0].y;
b.active = 1;
b.update = 1;
b.b_count = 5;
}
}
for ( i = 0; i < w.count; i++ ) {
if ( pos_test( p.p[0].x, p.p[0].y, w.p[i].x, w.p[i].y ) ) {
player_set( PLAYER_X, PLAYER_Y );
wall_set( GAME_WIDTH, GAME_HEIGHT );
eat_set( 0, GAME_WIDTH, GAME_HEIGHT );
game_over = 1;
}
}
if ( p.p[0].x >= (float)GAME_WIDTH ) {
p.p[0].x = 0.0f;
}
if ( p.p[0].x < 0.0f ) {
p.p[0].x = (float)GAME_WIDTH;
}
if ( p.p[0].y >= (float)GAME_HEIGHT ) {
p.p[0].y = 0.0f;
}
if ( p.p[0].y < 0.0f ) {
p.p[0].y = (float)GAME_HEIGHT;
}
}
/* create local game context and initiate game state
* as given from slot 'slot_id'. */
int client_game_resume_local( int slot_id )
{
int i;
GameSlot gs;
/* load saved game */
if ( !slot_load( slot_id, &gs ) ) return 0;
/* FIXME: config settings are overwritten for this */
config.diff = gs.diff;
config.player_count = gs.player_count;
for ( i = 0; i < config.player_count; i++ )
strcpy( config.player_names[i], gs.player_names[i] );
gameSeed = gs.gameSeed;
/* create local game where all players have full lives */
if ( !client_game_init_local( gs.setname ) ) return 0;
/* re-initiate players */
players_clear();
for ( i = 0; i < config.player_count; i++ )
{
/* name + lives */
player_add( config.player_names[i],
gs.player_lives[i],
levelset_get_first( game_set ) );
/* level */
player_init_level( &players[i],
game_set->levels[gs.player_cur_level_id[i]],
gs.player_cur_level_id[i] );
/* score */
players[i].stats.total_score = gs.player_scores[i];
}
cur_player = players_set_current( gs.cur_player );
/* init first level */
init_level( cur_player, PADDLE_BOTTOM );
return 1;
}
void RaptorServer::AcceptedClient( ConnectedClient *client )
{
if( ! client )
return;
Player *player = Data.GetPlayer( client->PlayerID );
// Send list of server properties to the new client.
Packet info( Raptor::Packet::INFO );
info.AddUShort( Data.Properties.size() );
for( std::map<std::string,std::string>::iterator property_iter = Data.Properties.begin(); property_iter != Data.Properties.end(); property_iter ++ )
{
info.AddString( property_iter->first.c_str() );
info.AddString( property_iter->second.c_str() );
}
client->Send( &info );
// Send list of all players to the new client.
Packet player_list( Raptor::Packet::PLAYER_LIST );
player_list.AddUShort( Raptor::Server->Data.Players.size() );
for( std::map<uint16_t,Player*>::iterator player_iter = Raptor::Server->Data.Players.begin(); player_iter != Raptor::Server->Data.Players.end(); player_iter ++ )
{
player_list.AddUShort( player_iter->second->ID );
player_list.AddString( player_iter->second->Name );
}
client->Send( &player_list );
// Send all existing players' properties to the new client.
for( std::map<uint16_t,Player*>::iterator player_iter = Raptor::Server->Data.Players.begin(); player_iter != Raptor::Server->Data.Players.end(); player_iter ++ )
{
Packet player_properties( Raptor::Packet::PLAYER_PROPERTIES );
player_properties.AddUShort( player_iter->second->ID );
player_properties.AddUInt( player_iter->second->Properties.size() );
for( std::map<std::string,std::string>::iterator property_iter = player_iter->second->Properties.begin(); property_iter != player_iter->second->Properties.end(); property_iter ++ )
{
player_properties.AddString( property_iter->first.c_str() );
player_properties.AddString( property_iter->second.c_str() );
}
client->Send( &player_properties );
}
// Tell other clients about the new player.
Packet player_add( Raptor::Packet::PLAYER_ADD );
player_add.AddUShort( client->PlayerID );
player_add.AddString( player ? player->Name.c_str() : "" );
Net.SendAllExcept( &player_add, client );
// Tell other clients about the new player's properties.
if( player )
{
Packet player_properties( Raptor::Packet::PLAYER_PROPERTIES );
player_properties.AddUShort( client->PlayerID );
player_properties.AddUInt( player->Properties.size() );
for( std::map<std::string,std::string>::iterator property_iter = player->Properties.begin(); property_iter != player->Properties.end(); property_iter ++ )
{
player_properties.AddString( property_iter->first.c_str() );
player_properties.AddString( property_iter->second.c_str() );
}
Net.SendAllExcept( &player_properties, client );
}
// Send list of existing objects to the new client.
Packet obj_list = Packet( Raptor::Packet::OBJECTS_ADD );
obj_list.AddUInt( Data.GameObjects.size() );
for( std::map<uint32_t,GameObject*>::iterator obj_iter = Data.GameObjects.begin(); obj_iter != Data.GameObjects.end(); obj_iter ++ )
{
obj_list.AddUInt( obj_iter->second->ID );
obj_list.AddUInt( obj_iter->second->Type() );
obj_iter->second->AddToInitPacket( &obj_list );
}
client->Send( &obj_list );
// The client is now synchronized, so it should receive updates.
client->Synchronized = true;
client->NetClock.Reset();
if( player )
{
// Tell other players to display a message about the new player.
Packet message( Raptor::Packet::MESSAGE );
message.AddString( (player->Name + " has joined the game.").c_str() );
Net.SendAllExcept( &message, client );
}
}
/* create network/local game context and initiate game state:
* network needs to receive the level data and a local game
* has to load the next level */
int client_game_init_local( char *setname )
{
Set_Chart *chart;
int i, warp_limit;
warp_limit = config.rel_warp_limit;
allow_disintegrate = 1;
/* the original levelsets do not need these workarounds */
if ( STRCMP( setname, "LBreakout2" ) || STRCMP( setname, "LBreakout1" ) ) {
warp_limit = 100;
allow_disintegrate = 0;
}
/* the approach for a local game is to use the same
* settings as a network game. the receiving of packets
* is simply faked by a local_game context that
* runs the game locally. but to use only one game loop
* we do not use it directly but apply its modificiations
* to game which is visualized */
local_game = game_create( GT_LOCAL, config.diff, warp_limit );
game_set_current( local_game );
game_set_convex_paddle( config.convex );
game_set_ball_auto_return( !config.return_on_click );
game_set_ball_random_angle( config.random_angle );
game_set_ball_accelerated_speed( config.maxballspeed_float );
local_game->localServerGame = 1;
/* load levels:
* only required for local games. in network both players
* just require a single level that can store the incoming
* data that is send by the server via the net.
*/
if ( !strcmp( setname, TOURNAMENT ) )
game_set = levelset_load_all( levelset_names, gameSeed, config.addBonusLevels );
else
game_set = levelset_load( setname, ((config.addBonusLevels)?gameSeed:0) );
if ( game_set == 0 ) return 0;
/* load highest score so far if any */
chart = chart_set_query(setname);
strcpy(best_name,"nobody"); best_score = 0;
if (chart)
{
strcpy(best_name,chart->entries[0].name);
best_score = chart->entries[0].score;
}
/* create client game context */
game = game_create( GT_LOCAL, config.diff, warp_limit );
game_set_current( game );
/* a local game is not limited in its communication */
client_comm_delay = 0;
no_comm_since = 0;
/* prepare warp icon at frame */
warp_blinks = 4; warp_blink = 1;
/* set list of level background ids */
for ( i = 0; i < MAX_LEVELS; i++ )
bkgnd_ids[i] = rand() % bkgnd_count;
/* initiate players */
players_clear();
for ( i = 0; i < config.player_count; i++ )
player_add( config.player_names[i],
game->diff->lives,
levelset_get_first( game_set ) );
cur_player = players_get_first();
/* init first level */
init_level( cur_player, PADDLE_BOTTOM );
/* if only one player don't show score table */
client_state = CS_NONE;
if ( player_count > 1 )
set_state( CS_SCORE_TABLE );
else
set_state( CS_PLAY ); /* one player starts immediately */
return 1;
}
