Target_give in races

Hello,

I just noticed that target_give on my race5 isn't working anymore.

I wanted to try my maps on warsow 0.6, and for this map (jerms_race5) i never get the plasma which is linked to a target_give linked to a trigger_multiple

trigger_multiple ==> target_give ==> plasma gun

I tested it on 0.5 and its the same. Has something changed with target_give since 0.42 ? what do i wrong ?

thanks for your help
Jerm's

make sure you arent running in warmup…

warmup in race ?

i tried. I join, press F4 and start racing, still no weapon. *cry*

Ok if we are more than one on the race and ready up, the "mach" starts and weapon are available. but why not in warmup, and why not when there is only one player ?

but wtf I cant see the target_give entity in Netradiant but it is in the entities.def file, any idea ?

it is the first entity after the following lines that is not displayed in Netradiant. Dunno why
//=============================================================================

TARGET_* ENTITIES

//=============================================================================

patch:
race.as
replace

    case MATCH_STATE_WARMUP:
        map.setUpMatch();
        break;

in the void GT_MatchStateStarted()

with

    case MATCH_STATE_WARMUP:
        match.launchState( MATCH_STATE_PLAYTIME );
        break;

Thx schaaf but with these lines in my GT wsw crashes

paste your race.as and i'll apply it for you

I think you have to disable the match cancel when not enough players. I don't remember if it was a gametype option or how was it done. Maybe a call in thinkRules.

Here is my code. But DrahtMaul help me and recode the target_give entity in AngelScript, si now it is working.
[spoiler]

int numCheckpoints = 0;
bool demoRecording = false;
const int MAX_RECORDS = 3;

uint[] levelRecordSectors;
uint   levelRecordFinishTime;
cString levelRecordPlayerName;

int prcYesIcon;

const int DRACE_ROUNDSTATE_NONE = 0;
const int DRACE_ROUNDSTATE_PREROUND = 1;
const int DRACE_ROUNDSTATE_ROUND = 2;
const int DRACE_ROUNDSTATE_ROUNDFINISHED = 3;
const int DRACE_ROUNDSTATE_POSTROUND = 4;

class cDRACERound
{
    int state;
    int numRounds;
    uint roundStateStartTime;
    uint roundStateEndTime;
    int countDown;
    int[] DRACEChallengersQueue;
    cEntity @alphaSpawn;
    cEntity @betaSpawn;
    cClient @roundWinner;
    cClient @roundChallenger;

    cDRACERound()
    {
        this.state = DRACE_ROUNDSTATE_NONE;
        this.numRounds = 0;
        this.roundStateStartTime = 0;
        this.countDown = 0;
        @this.alphaSpawn = null;
        @this.betaSpawn = null;
        @this.roundWinner = null;
        @this.roundChallenger = null;
    }

    ~cDRACERound() {}

    void init()
    {
        this.clearChallengersQueue();
    }

    void clearChallengersQueue()
    {
        if ( this.DRACEChallengersQueue.length() != uint( maxClients ) )
            this.DRACEChallengersQueue.resize( maxClients );

        for ( int i = 0; i < maxClients; i++ )
            this.DRACEChallengersQueue = -1;
    }

    void challengersQueueAddPlayer( cClient @client )
    {
        if ( @client == null )
            return;

        // check for already added
        for ( int i = 0; i < maxClients; i++ )
        {
            if ( this.DRACEChallengersQueue == client.playerNum() )
                return;
        }

        for ( int i = 0; i < maxClients; i++ )
        {
            if ( this.DRACEChallengersQueue < 0 || this.DRACEChallengersQueue >= maxClients )
            {
                this.DRACEChallengersQueue = client.playerNum();
                break;
            }
        }
    }

    bool challengersQueueRemovePlayer( cClient @client )
    {
        if ( @client == null )
            return false;

        for ( int i = 0; i < maxClients; i++ )
        {
            if ( this.DRACEChallengersQueue == client.playerNum() )
            {
                int j;
                for ( j = i + 1; j < maxClients; j++ )
                {
                    this.DRACEChallengersQueue[j - 1] = this.DRACEChallengersQueue[j];
                    if ( DRACEChallengersQueue[j] == -1 )
                        break;
                }

                this.DRACEChallengersQueue[j] = -1;
                return true;
            }
        }

        return false;
    }

    cClient @challengersQueueGetNextPlayer()
    {
        cClient @client = @G_GetClient( this.DRACEChallengersQueue[0] );

        if ( @client != null )
        {
            this.challengersQueueRemovePlayer( client );
        }

        return client;
    }

    void playerTeamChanged( cClient @client, int new_team )
    {
        if ( new_team != TEAM_PLAYERS )
        {
            this.challengersQueueRemovePlayer( client );

            if ( this.state != DRACE_ROUNDSTATE_NONE )
            {
                if ( @client == @this.roundWinner )
                {
                    @this.roundWinner = null;
                    this.newRoundState( DRACE_ROUNDSTATE_ROUNDFINISHED );
                }

                if ( @client == @this.roundChallenger )
                {
                    @this.roundChallenger = null;
                    this.newRoundState( DRACE_ROUNDSTATE_ROUNDFINISHED );
                }
            }
        }
        else if ( new_team == TEAM_PLAYERS )
        {
            this.challengersQueueAddPlayer( client );
        }
    }

    void roundAnnouncementPrint( cString &string )
    {
        if ( string.len()  DRACE_ROUNDSTATE_POSTROUND )
        {
            this.newRound();
            return;
        }

        this.state = newState;
        this.roundStateStartTime = levelTime;

        switch ( this.state )
        {
        case DRACE_ROUNDSTATE_NONE:

            this.roundStateEndTime = 0;
            this.countDown = 0;
            break;

        case DRACE_ROUNDSTATE_PREROUND:
        {
            this.roundStateEndTime = levelTime + 3000;
            this.countDown = 3;

            // respawn everyone and disable shooting
            gametype.shootingDisabled = true;

            // pick the last round winner and the first in queue,
            // or, if no round winner, the 2 first in queue
            if ( @this.roundWinner == null )
            {
                @this.roundWinner = @this.challengersQueueGetNextPlayer();
                @this.roundChallenger = @this.challengersQueueGetNextPlayer();
            }
            else
            {
                @this.roundChallenger = @this.challengersQueueGetNextPlayer();
            }

            cEntity @ent;
            cTeam @team;

            @team = @G_GetTeam( TEAM_PLAYERS );

            // respawn all clients inside the playing teams
            for ( int j = 0; @team.ent( j ) != null; j++ )
            {
                @ent = @team.ent( j );

                if ( @ent.client == @this.roundWinner || @ent.client == @this.roundChallenger )
                {
                    ent.client.respawn( false );
                }
                else
                {
                    ent.client.respawn( true );
                    ent.client.chaseCam( null, true );
                }
                
                //we immobilize the players
                ent.client.setPMoveMaxSpeed( 0 );
                ent.client.setPMoveDashSpeed( 0 );
            }

            this.roundAnnouncementPrint( S_COLOR_GREEN + "New Round:" );
            this.roundAnnouncementPrint( S_COLOR_WHITE + this.roundWinner.getName()
                                         + S_COLOR_GREEN + " vs. "
                                         + S_COLOR_WHITE + this.roundChallenger.getName() );
        }
        break;

        case DRACE_ROUNDSTATE_ROUND:
        {
            gametype.shootingDisabled = false;
            this.countDown = 0;
            this.roundStateEndTime = 0;
            
            cEntity @ent;
            cTeam @team;

            @team = @G_GetTeam( TEAM_PLAYERS );

            // allows all players to move again
            for ( int j = 0; @team.ent( j ) != null; j++ )
            {
                @ent = @team.ent( j );
                ent.client.setPMoveMaxSpeed( -1 );
                ent.client.setPMoveDashSpeed( -1 );
            }
            
            int soundIndex = G_SoundIndex( "sounds/announcer/countdown/fight0" + int( brandom( 1, 2 ) ) );
            G_AnnouncerSound( null, soundIndex, GS_MAX_TEAMS, false, null );
        }
        break;

        case DRACE_ROUNDSTATE_ROUNDFINISHED:

            gametype.shootingDisabled = true;
            this.roundStateEndTime = levelTime + 1500;
            this.countDown = 0;
            break;

        case DRACE_ROUNDSTATE_POSTROUND:
        {
            this.roundStateEndTime = levelTime + 3000;

            // add score to round-winning player
            cClient @winner = null;
            cClient @loser = null;

            // watch for one of the players removing from the game
            if ( @this.roundWinner == null || @this.roundChallenger == null )
            {
                if ( @this.roundWinner != null )
                    @winner = @this.roundWinner;
                else if ( @this.roundChallenger != null )
                    @winner = @this.roundChallenger;
            }
            else if ( !this.roundWinner.getEnt().isGhosting() && this.roundChallenger.getEnt().isGhosting() )
            {
                @winner = @this.roundWinner;
                @loser = @this.roundChallenger;
            }
            else if ( this.roundWinner.getEnt().isGhosting() && !this.roundChallenger.getEnt().isGhosting() )
            {
                @winner = @this.roundChallenger;
                @loser = @this.roundWinner;
            }

            // if we didn't find a winner, it was a draw round
            if ( @winner == null )
            {
                this.roundAnnouncementPrint( S_COLOR_ORANGE + "Draw Round!" );
                                        this.challengersQueueAddPlayer( this.roundWinner );
                                        this.challengersQueueAddPlayer( this.roundChallenger );
            }
            else
            {
                int soundIndex;

                soundIndex = G_SoundIndex( "sounds/announcer/ctf/score0" + int( brandom( 1, 2 ) ) );
                G_AnnouncerSound( winner, soundIndex, GS_MAX_TEAMS, false, null );

                if ( @loser != null )
                {
                    winner.stats.addScore( 1 );

                    soundIndex = G_SoundIndex( "sounds/announcer/ctf/score_enemy0" + int( brandom( 1, 2 ) ) );
                    G_AnnouncerSound( loser, soundIndex, GS_MAX_TEAMS, false, null );
                    this.challengersQueueAddPlayer( loser );
                }

                this.roundAnnouncementPrint( S_COLOR_WHITE + winner.getName() + S_COLOR_GREEN + " wins the round!" );
            }

            @this.roundWinner = @winner;
            @this.roundChallenger = null;                       
        }
        break;

        default:
            break;
        }
    }

    void think()
    {
        if ( this.state == DRACE_ROUNDSTATE_NONE )
            return;

        if ( match.getState() != MATCH_STATE_PLAYTIME )
        {
            this.endGame();
            return;
        }

        if ( this.roundStateEndTime != 0 )
        {
            if ( this.roundStateEndTime < levelTime )
            {
                this.newRoundState( this.state + 1 );
                return;
            }

            if ( this.countDown > 0 )
            {
                // we can't use the authomatic countdown announces because their are based on the
                // matchstate timelimit, and prerounds don't use it. So, fire the announces "by hand".
                int remainingSeconds = int( ( this.roundStateEndTime - levelTime ) * 0.001f ) + 1;
                if ( remainingSeconds < 0 )
                    remainingSeconds = 0;

                if ( remainingSeconds < this.countDown )
                {
                    this.countDown = remainingSeconds;

                    if ( this.countDown == 4 )
                    {
                        int soundIndex = G_SoundIndex( "sounds/announcer/countdown/ready0" + int( brandom( 1, 2 ) ) );
                        G_AnnouncerSound( null, soundIndex, GS_MAX_TEAMS, false, null );
                    }
                    else if ( this.countDown  levelTime ) // something is very wrong here
            return;

        client.addAward( S_COLOR_CYAN + "Race Finished!" );

        this.finishTime = levelTime - this.startTime;
        this.inRace = false;

        // print the time differences with the best race of this player
        // green if player's best time at this sector, red if not improving previous best time
        if ( this.bestFinishTime == 0 )
        {
            delta = this.finishTime;
            str = S_COLOR_GREEN + " ";
        }
        else if ( this.finishTime  this.finishTime )
            {
                // move the other records down
                for ( int i = MAX_RECORDS - 1; i > top; i-- )
                    levelRecords.Copy( levelRecords[i - 1] );

                levelRecords[top].Store( client );

                DRACE_WriteTopScores();
                DRACE_UpdateHUDTopScores();
                break;
            }
        }

        // set up for respawning the player with a delay if we are in warmup
        if ( match.getState() == MATCH_STATE_WARMUP )  
        {
          cEntity @respawner = G_SpawnEntity( "race_respawner" );
          respawner.nextThink = levelTime + 5000;
          respawner.count = client.playerNum();
        }

        G_AnnouncerSound( client, G_SoundIndex( "sounds/misc/timer_ploink" ), GS_MAX_TEAMS, false, null );
    }

    void touchCheckPoint( cClient @client, int id )
    {
        uint delta;
        cString str;

        if ( id < 0 || id >= numCheckpoints )
            return;

        if ( !this.inRace )
            return;

        if ( this.sectorTimes[id] != 0 ) // already past this checkPoint
            return;

        if ( this.startTime > levelTime ) // something is very wrong here
            return;

        this.sectorTimes[id] = levelTime - this.startTime;

        // print some output and give awards if earned

        // green if player's best time at this sector, red if not improving previous best time
        if ( this.bestSectorTimes[id] == 0 )
        {
            delta = this.sectorTimes[id];
            str = S_COLOR_GREEN + " ";
        }
        else if ( this.sectorTimes[id] = maxClients )
            break;

        @client = @G_GetClient( DRACERound.DRACEChallengersQueue );
        if ( @client == null )
            break;

        if ( client.isReady() )
            readyIcon = prcYesIcon;
        else
            readyIcon = 0;

        if ( match.getState() != MATCH_STATE_PLAYTIME )
            playerID = client.playerNum();
        else
            playerID = client.getEnt().isGhosting() ? -( client.playerNum() + 1 ) : client.playerNum();
        
        racing = int( DRACE_GetPlayerTimer( client ).inRace ? 1 : 0 );

        entry = "&p " + playerID + " "
                + client.getClanName() + " "
                + client.stats.score + " "
                + DRACE_GetPlayerTimer( client ).bestFinishTime + " "
                + client.ping + " "
                + racing + " "
                + readyIcon + " ";

        if ( scoreboardMessage.len() + entry.len() < maxlen )
            scoreboardMessage += entry;
    }
    
    return scoreboardMessage;
}

// Some game actions trigger score events. These are events not related to killing
// oponents, like capturing a flag
void GT_scoreEvent( cClient @client, cString &score_event, cString &args )
{
    if ( score_event == "dmg" )
    {
    }
    else if ( score_event == "kill" )
    {
        cEntity @attacker = null;

        if ( @client != null )
            @attacker = @client.getEnt();

        int arg1 = args.getToken( 0 ).toInt();
        int arg2 = args.getToken( 1 ).toInt();

        // target, attacker, inflictor
        DRACERound.playerKilled( G_GetEntity( arg1 ), attacker, G_GetEntity( arg2 ) );
    }
    else if ( score_event == "award" )
    {
    }
    else if ( score_event == "enterGame" )
    {
        DRACE_GetPlayerTimer( client ).clear();
    }

}

// a player is being respawned. This can happen from several ways, as dying, changing team,
// being moved to ghost state, be placed in respawn queue, being spawned from spawn queue, etc
void GT_playerRespawn( cEntity @ent, int old_team, int new_team )
{
    DRACE_GetPlayerTimer( ent.client ).cancelRace();

    if ( old_team != new_team )
    {
        DRACERound.playerTeamChanged( ent.client, new_team );
    }
    
    if ( ent.isGhosting() )
        return;
    
    // set player movement to pass through other players
    ent.client.setPMoveFeatures( ent.client.pmoveFeatures | PMFEAT_GHOSTMOVE );
    
    if ( gametype.isInstagib() )
        ent.client.inventoryGiveItem( WEAP_INSTAGUN );
    else
        ent.client.inventorySetCount( WEAP_GUNBLADE, 1 );

    // select rocket launcher if available
    if ( ent.client.canSelectWeapon( WEAP_ROCKETLAUNCHER ) )
        ent.client.selectWeapon( WEAP_ROCKETLAUNCHER );
    else
        ent.client.selectWeapon( -1 ); // auto-select best weapon in the inventory

    // add a teleportation effect
    ent.respawnEffect();

    int soundIndex = G_SoundIndex( "sounds/announcer/countdown/ready0" + int( brandom( 1, 2 ) ) );
    G_AnnouncerSound( ent.client, soundIndex, GS_MAX_TEAMS, false, null );
}

// Thinking function. Called each frame
void GT_ThinkRules()
{
    if ( match.scoreLimitHit() || match.timeLimitHit() || match.suddenDeathFinished() )
        match.launchState( match.getState() + 1 );

    if ( match.getState() >= MATCH_STATE_POSTMATCH )
        return;

    if ( match.getState() == MATCH_STATE_PLAYTIME )
    {
        // if there is no player in TEAM_PLAYERS finish the match and restart
        if ( G_GetTeam( TEAM_PLAYERS ).numPlayers == 0 && demoRecording )
        {
            match.stopAutorecord();
            demoRecording = false;
        }
        else if ( !demoRecording && G_GetTeam( TEAM_PLAYERS ).numPlayers > 0 )
        {
            match.startAutorecord();
            demoRecording = true;
        }
    }

    // set all clients race stats
    cClient @client;

    for ( int i = 0; i < maxClients; i++ )
    {
        @client = @G_GetClient( i );
        if ( client.state() < CS_SPAWNED )
            continue;

        // always clear all before setting
        client.setHUDStat( STAT_PROGRESS_SELF, 0 );
        client.setHUDStat( STAT_PROGRESS_OTHER, 0 );
        client.setHUDStat( STAT_IMAGE_SELF, 0 );
        client.setHUDStat( STAT_IMAGE_OTHER, 0 );
        client.setHUDStat( STAT_PROGRESS_ALPHA, 0 );
        client.setHUDStat( STAT_PROGRESS_BETA, 0 );
        client.setHUDStat( STAT_IMAGE_ALPHA, 0 );
        client.setHUDStat( STAT_IMAGE_BETA, 0 );
        client.setHUDStat( STAT_MESSAGE_SELF, 0 );
        client.setHUDStat( STAT_MESSAGE_OTHER, 0 );
        client.setHUDStat( STAT_MESSAGE_ALPHA, 0 );
        client.setHUDStat( STAT_MESSAGE_BETA, 0 );

        // all stats are set to 0 each frame, so it's only needed to set a stat if it's going to get a value
        if ( DRACE_GetPlayerTimer( client ).inRace )
            client.setHUDStat( STAT_TIME_SELF, (levelTime - DRACE_GetPlayerTimer( client ).startTime) / 100 );

        client.setHUDStat( STAT_TIME_BEST, DRACE_GetPlayerTimer( client ).bestFinishTime / 100 );
        client.setHUDStat( STAT_TIME_RECORD, levelRecords[0].finishTime / 100 );

        client.setHUDStat( STAT_TIME_ALPHA, -9999 );
        client.setHUDStat( STAT_TIME_BETA, -9999 );

        if ( levelRecords[0].playerName.len() > 0 )
            client.setHUDStat( STAT_MESSAGE_OTHER, CS_GENERAL );
        if ( levelRecords[1].playerName.len() > 0 )
            client.setHUDStat( STAT_MESSAGE_ALPHA, CS_GENERAL + 1 );
        if ( levelRecords[2].playerName.len() > 0 )
            client.setHUDStat( STAT_MESSAGE_BETA, CS_GENERAL + 2 );
    }
    
   DRACERound.think();
}

// The game has detected the end of the match state, but it
// doesn't advance it before calling this function.
// This function must give permission to move into the next
// state by returning true.
bool GT_MatchStateFinished( int incomingMatchState )
{
    // ** MISSING EXTEND PLAYTIME CHECK **

    if ( match.getState()  MATCH_STATE_WARMUP
            && incomingMatchState < MATCH_STATE_POSTMATCH ) {
        match.startAutorecord();
        demoRecording = false;
        DRACE_WriteTopScores();
    }

    if ( match.getState() == MATCH_STATE_POSTMATCH ) {
        match.stopAutorecord();
        demoRecording = false;
        DRACE_WriteTopScores();
    }
    
    return true;
}

// the match state has just moved into a new state. Here is the
// place to set up the new state rules
void GT_MatchStateStarted()
{
    switch ( match.getState() )
    {
    case MATCH_STATE_WARMUP:
        DRACE_SetUpWarmup();
        break;

    case MATCH_STATE_COUNTDOWN:
        DRACE_SetUpCountdown();
        break;

    case MATCH_STATE_PLAYTIME:
        DRACERound.newGame();
        break;

    case MATCH_STATE_POSTMATCH:
        gametype.pickableItemsMask = 0;
        gametype.dropableItemsMask = 0;
        DRACERound.endGame();
        break;

    default:
        break;
    }
}

// the gametype is shutting down cause of a match restart or map change
void GT_Shutdown()
{
}

// The map entities have just been spawned. The level is initialized for
// playing, but nothing has yet started.
void GT_SpawnGametype()
{
    //G_Print( "numCheckPoints: " + numCheckpoints + "" );

    // setup the checkpoints arrays sizes adjusted to numCheckPoints
    for ( int i = 0; i < maxClients; i++ )
        cPlayerTimes.setupArrays( numCheckpoints );

    for ( int i = 0; i < MAX_RECORDS; i++ )
        levelRecords.setupArrays( numCheckpoints );

    DRACE_replace_target_give();
    DRACE_LoadTopScores();
}

// Important: This function is called before any entity is spawned, and
// spawning entities from it is forbidden. If you want to make any entity
// spawning at initialization do it in GT_SpawnGametype, which is called
// right after the map entities spawning.

void GT_InitGametype()
{
    gametype.setTitle( "Duel Race" );
    gametype.setVersion( "1.04" );
    gametype.setAuthor( "^5J^7e^5r^7m^5'^7s" );

    DRACERound.init();

    // if the gametype doesn't have a config file, create it
    if ( !G_FileExists( "configs/server/gametypes/" + gametype.getName() + ".cfg" ) )
    {
        cString config;

        // the config file doesn't exist or it's empty, create it
        config = "// '" + gametype.getTitle() + "' gametype configuration file"
                 + "// This config will be executed each time the gametype is started"
                 + "// map rotation"
                 + "set g_maplist \"cwrace2 cwrace3\" // list of maps in automatic rotation"
                 + "set g_maprotation \"0\"   // 0 = same map, 1 = in order, 2 = random"
                 + "// game settings"
                 + "set g_scorelimit \"11\""
                 + "set g_timelimit \"0\""
                 + "set g_warmup_enabled \"0\""
                 + "set g_warmup_timelimit \"5\""
                 + "set g_match_extendedtime \"0\""
                 + "set g_allow_falldamage \"0\""
                 + "set g_allow_selfdamage \"0\""
                 + "set g_allow_teamdamage \"0\""
                 + "set g_allow_stun \"1\""
                 + "set g_teams_maxplayers \"0\""
                 + "set g_teams_allow_uneven \"0\""
                 + "set g_countdown_time \"3\""
                 + "set g_maxtimeouts \"3\" // -1 = unlimited"
                 + "set g_challengers_queue \"0\""

                 + "echo \"" + gametype.getName() + ".cfg executed\"";

        G_WriteFile( "configs/server/gametypes/" + gametype.getName() + ".cfg", config );
        G_Print( "Created default config file for '" + gametype.getName() + "'" );
        G_CmdExecute( "exec configs/server/gametypes/" + gametype.getName() + ".cfg silent" );
    }

    gametype.spawnableItemsMask = ( IT_AMMO | IT_WEAPON | IT_POWERUP );
    if ( gametype.isInstagib() )
        gametype.spawnableItemsMask &= ~uint(G_INSTAGIB_NEGATE_ITEMMASK);

    gametype.respawnableItemsMask = gametype.spawnableItemsMask;
    gametype.dropableItemsMask = gametype.spawnableItemsMask;
    gametype.pickableItemsMask = gametype.spawnableItemsMask;

    //gametype.dropableItemsMask = 0;
    //gametype.pickableItemsMask = ( gametype.spawnableItemsMask | gametype.dropableItemsMask );

    gametype.isTeamBased = false;
    gametype.isRace = true;
    gametype.hasChallengersQueue = true;
    gametype.maxPlayersPerTeam = 0;

    gametype.ammoRespawn = 1;
    gametype.armorRespawn = 1;
    gametype.weaponRespawn = 1;
    gametype.healthRespawn = 1;
    gametype.powerupRespawn = 1;
    gametype.megahealthRespawn = 1;
    gametype.ultrahealthRespawn = 1;

    gametype.readyAnnouncementEnabled = false;
    gametype.scoreAnnouncementEnabled = false;
    gametype.countdownEnabled = false;
    gametype.mathAbortDisabled = false;
    gametype.shootingDisabled = false;
    gametype.infiniteAmmo = true;
    gametype.canForceModels = true;
    gametype.canShowMinimap = false;
    gametype.teamOnlyMinimap = true;

    gametype.spawnpointRadius = 0;

    if ( gametype.isInstagib() )
        gametype.spawnpointRadius *= 2;

    // set spawnsystem type to instant while players join
    for ( int team = TEAM_PLAYERS; team < GS_MAX_TEAMS; team++ )
        gametype.setTeamSpawnsystem( team, SPAWNSYSTEM_INSTANT, 0, 0, false );

    // define the scoreboard layout
    G_ConfigString( CS_SCB_PLAYERTAB_LAYOUT, "%n 112 %s 52 %i 52 %t 96 %l 48 %b 50 %p 18" );
    G_ConfigString( CS_SCB_PLAYERTAB_TITLES, "Name Clan Score Time Ping Racing R" );

    // precache images that can be used by the scoreboard
    prcYesIcon = G_ImageIndex( "gfx/hud/icons/vsay/yes" );

    // add commands
    G_RegisterCommand( "gametype" );
    G_RegisterCommand( "racerestart" );

    demoRecording = false;

    G_Print( "Gametype '" + gametype.getTitle() + "' initialized" );
}

[/spoiler]

gametype.mathAbortDisabled = false;

Match abort resets the match state to warmup if there are less than 2 players. Set it to true in the init function and the problem should be solved.

ok, you were talking about drace…

@Schaaf the problem is the same the moment you are in RACE mode.
@thx Jal, so I can modify it and race alone on my server.

Anyway thx to you both for your help, and Merry Xmas everybody