Future/nx1-gsc-dump
1
0
Fork 0
mirror of https://github.com/reaaLx/nx1-gsc-dump.git synced 2025-06-27 23:01:49 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Added more missing files

Browse Source
This commit is contained in:
reaaLx
2024-09-07 15:06:58 +10:00
parent a9da8b788b
commit 7ea506e8ac
470 changed files with 26317 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
maps/mp/gametypes/_gametypes.txt Normal file
View File

@ -0,0 +1,24 @@
dm
dom
sd
sab
war
koth
oneflag
arena
dd
vip
ctf
gtnw
gg
joe
crank
cwtest
mtdm
merc
escortplus
convoy
glad
hvt
gun
oic

532
maps/mp/gametypes/arena.gsc Normal file
View File

@ -0,0 +1,532 @@
#include maps\mp\_utility;
#include maps\mp\gametypes\_hud_util;
/*
Arena
Objective: Eliminate the enemy team
Map ends: When one team eliminates the enemy team, or the flag is reached
Respawning: Beginning of next round
Level requirementss
------------------
Spawnpoints:
classname mp_tdm_spawn
All players spawn from these. The spawnpoint chosen is dependent on the current locations of teammates and enemies
at the time of spawn. Players generally spawn behind their teammates relative to the direction of enemies.
Spectator Spawnpoints:
classname mp_global_intermission
Spectators spawn from these and intermission is viewed from these positions.
Atleast one is required, any more and they are randomly chosen between.
*/
/*QUAKED mp_tdm_spawn (0.0 0.0 1.0) (-16 -16 0) (16 16 72)
Players spawn away from enemies and near their team at one of these positions.*/
/*QUAKED mp_tdm_spawn_axis_start (0.5 0.0 1.0) (-16 -16 0) (16 16 72)
Axis players spawn away from enemies and near their team at one of these positions at the start of a round.*/
/*QUAKED mp_tdm_spawn_allies_start (0.0 0.5 1.0) (-16 -16 0) (16 16 72)
Allied players spawn away from enemies and near their team at one of these positions at the start of a round.*/
main()
{
if(getdvar("mapname") == "mp_background")
return;
maps\mp\gametypes\_globallogic::init();
maps\mp\gametypes\_callbacksetup::SetupCallbacks();
maps\mp\gametypes\_globallogic::SetupCallbacks();
registerRoundSwitchDvar( level._gameType, 0, 0, 9 );
registerTimeLimitDvar( level._gameType, 10, 0, 1440 );
registerScoreLimitDvar( level._gameType, 500, 0, 5000 );
registerRoundLimitDvar( level._gameType, 1, 0, 10 );
registerWinLimitDvar( level._gameType, 1, 0, 10 );
registerRoundSwitchDvar( level._gameType, 3, 0, 30 );
registerNumLivesDvar( level._gameType, 0, 0, 10 );
registerHalfTimeDvar( level._gameType, 0, 0, 1 );
level._teamBased = true;
level._objectiveBased = true;
level._onPrecacheGameType = ::onPrecacheGameType;
level._onStartGameType = ::onStartGameType;
level._getSpawnPoint = ::getSpawnPoint;
level._onSpawnPlayer = ::onSpawnPlayer;
level._onNormalDeath = ::onNormalDeath;
level._onPlayerKilled = ::onPlayerKilled;
level._onDeadEvent = ::onDeadEvent;
game["dialog"]["gametype"] = "arena";
if ( getDvarInt( "g_hardcore" ) )
game["dialog"]["gametype"] = "hc_" + game["dialog"]["gametype"];
else if ( getDvarInt( "camera_thirdPerson" ) )
game["dialog"]["gametype"] = "thirdp_" + game["dialog"]["gametype"];
else if ( getDvarInt( "scr_diehard" ) )
game["dialog"]["gametype"] = "dh_" + game["dialog"]["gametype"];
game["strings"]["overtime_hint"] = &"MP_FIRST_BLOOD";
}
onPrecacheGameType()
{
precacheShader( "compass_waypoint_captureneutral" );
precacheShader( "compass_waypoint_capture" );
precacheShader( "compass_waypoint_defend" );
precacheShader( "waypoint_captureneutral" );
precacheShader( "waypoint_capture" );
precacheShader( "waypoint_defend" );
}
onStartGameType()
{
setClientNameMode("auto_change");
if ( !isdefined( game["switchedsides"] ) )
game["switchedsides"] = false;
if ( game["switchedsides"] )
{
oldAttackers = game["attackers"];
oldDefenders = game["defenders"];
game["attackers"] = oldDefenders;
game["defenders"] = oldAttackers;
}
setObjectiveText( "allies", &"OBJECTIVES_ARENA" );
setObjectiveText( "axis", &"OBJECTIVES_ARENA" );
if ( level._splitscreen )
{
setObjectiveScoreText( "allies", &"OBJECTIVES_ARENA" );
setObjectiveScoreText( "axis", &"OBJECTIVES_ARENA" );
}
else
{
setObjectiveScoreText( "allies", &"OBJECTIVES_ARENA_SCORE" );
setObjectiveScoreText( "axis", &"OBJECTIVES_ARENA_SCORE" );
}
setObjectiveHintText( "allies", &"OBJECTIVES_ARENA_HINT" );
setObjectiveHintText( "axis", &"OBJECTIVES_ARENA_HINT" );
level._spawnMins = ( 0, 0, 0 );
level._spawnMaxs = ( 0, 0, 0 );
maps\mp\gametypes\_spawnlogic::placeSpawnPoints( "mp_tdm_spawn_allies_start" );
maps\mp\gametypes\_spawnlogic::placeSpawnPoints( "mp_tdm_spawn_axis_start" );
maps\mp\gametypes\_spawnlogic::addSpawnPoints( "allies", "mp_tdm_spawn" );
maps\mp\gametypes\_spawnlogic::addSpawnPoints( "axis", "mp_tdm_spawn" );
level._mapCenter = maps\mp\gametypes\_spawnlogic::findBoxCenter( level._spawnMins, level._spawnMaxs );
setMapCenter( level._mapCenter );
allowed[0] = "dom";
allowed[1] = "airdrop_pallet";
allowed[2] = "arena";
maps\mp\gametypes\_rank::registerScoreInfo( "capture", 200 );
maps\mp\gametypes\_gameobjects::main(allowed);
precacheFlag();
thread arenaFlagWaiter();
thread arenaTimeFlagWaiter();
}
precacheFlag()
{
game["flagmodels"] = [];
game["flagmodels"]["neutral"] = "prop_flag_neutral";
game["flagmodels"]["allies"] = maps\mp\gametypes\_teams::getTeamFlagModel( "allies" );
game["flagmodels"]["axis"] = maps\mp\gametypes\_teams::getTeamFlagModel( "axis" );
precacheModel( game["flagmodels"]["neutral"] );
precacheModel( game["flagmodels"]["allies"] );
precacheModel( game["flagmodels"]["axis"] );
precacheString( &"MP_CAPTURING_FLAG" );
precacheString( &"MP_LOSING_FLAG" );
precacheString( &"MP_DOM_YOUR_FLAG_WAS_CAPTURED" );
precacheString( &"MP_DOM_ENEMY_FLAG_CAPTURED" );
precacheString( &"MP_DOM_NEUTRAL_FLAG_CAPTURED" );
precacheString( &"MP_ENEMY_FLAG_CAPTURED_BY" );
precacheString( &"MP_NEUTRAL_FLAG_CAPTURED_BY" );
precacheString( &"MP_FRIENDLY_FLAG_CAPTURED_BY" );
}
arenaTimeFlagWaiter()
{
level endon( "down_to_one" );
level endon( "game_end" );
for( ;; )
{
timeLeft = maps\mp\gametypes\_gamelogic::getTimeRemaining();
if ( timeLeft < 61000 )
break;
wait ( 1 );
}
level notify( "arena_flag_time" );
thread arenaFlag();
}
arenaFlagWaiter()
{
level endon( "game_end" );
level endon( "arena_flag_time" );
for ( ;; )
{
if ( level._inGracePeriod == 0 )
break;
wait ( 0.05 );
}
for ( ;; )
{
if ( getTeamPlayersAlive ( "axis" ) == 1 )
{
thread arenaFlag();
level notify( "down_to_one" );
break;
}
if ( getTeamPlayersAlive ( "allies" ) == 1 )
{
thread arenaFlag();
level notify( "down_to_one" );
break;
}
wait( 1 );
}
}
getSpawnPoint()
{
spawnteam = self.pers["team"];
if ( game["switchedsides"] )
spawnteam = getOtherTeam( spawnteam );
if ( level._inGracePeriod )
{
spawnPoints = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_tdm_spawn_" + spawnteam + "_start" );
spawnPoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_Random( spawnPoints );
}
else
{
spawnPoints = maps\mp\gametypes\_spawnlogic::getTeamSpawnPoints( spawnteam );
spawnPoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_NearTeam( spawnPoints );
}
return spawnPoint;
}
onSpawnPlayer()
{
self.usingObj = undefined;
level notify ( "spawned_player" );
}
onNormalDeath( victim, attacker, lifeId )
{
score = maps\mp\gametypes\_rank::getScoreInfoValue( "kill" );
assert( isDefined( score ) );
attacker maps\mp\gametypes\_gamescore::giveTeamScoreForObjective( attacker.pers["team"], score );
team = victim.team;
if ( game["state"] == "postgame" )
attacker.finalKill = true;
}
onPlayerKilled(eInflictor, attacker, iDamage, sMeansOfDeath, sWeapon, vDir, sHitLoc, psOffsetTime, deathAnimDuration, killId)
{
thread checkAllowSpectating();
}
onTimeLimit()
{
if ( game["status"] == "overtime" )
{
winner = "forfeit";
}
else if ( game["teamScores"]["allies"] == game["teamScores"]["axis"] )
{
winner = "overtime";
}
else if ( game["teamScores"]["axis"] > game["teamScores"]["allies"] )
{
winner = "axis";
}
else
{
winner = "allies";
}
thread maps\mp\gametypes\_gamelogic::endGame( winner, game["strings"]["time_limit_reached"] );
}
checkAllowSpectating()
{
wait ( 0.05 );
update = false;
if ( !level._aliveCount[ game["attackers"] ] )
{
level._spectateOverride[game["attackers"]].allowEnemySpectate = 1;
update = true;
}
if ( !level._aliveCount[ game["defenders"] ] )
{
level._spectateOverride[game["defenders"]].allowEnemySpectate = 1;
update = true;
}
if ( update )
maps\mp\gametypes\_spectating::updateSpectateSettings();
}
arenaFlag()
{
level._lastStatus["allies"] = 0;
level._lastStatus["axis"] = 0;
arenaFlag = getEntArray("flag_arena", "targetname");
primaryFlags = getEntArray( "flag_primary", "targetname" );
secondaryFlags = getEntArray( "flag_secondary", "targetname" );
// check to see if arena flag is present otherwise throw a warning and use the dom Flag.
if ( !isDefined( arenaFlag[0] ) )
{
println("WARNING: no arena flags specified attempting to use Dom flag_b" );
if ( (primaryFlags.size + secondaryFlags.size) < 1 )
{
printLn( "^1Not enough domination flags found in level!" );
maps\mp\gametypes\_callbacksetup::AbortLevel();
return;
}
self setupDomFlag(primaryFlags, secondaryFlags);
}
else
level._arenaFlag = arenaFlag[0];
trigger = level._arenaFlag;
if ( isDefined( trigger.target ) )
{
visuals[0] = getEnt( trigger.target, "targetname" );
}
else
{
visuals[0] = spawn( "script_model", trigger.origin );
visuals[0].angles = trigger.angles;
}
visuals[0] setModel( game["flagmodels"]["neutral"] );
arenaFlag = maps\mp\gametypes\_gameobjects::createUseObject( "neutral", trigger, visuals, (0,0,100) );
arenaFlag maps\mp\gametypes\_gameobjects::allowUse( "enemy" );
arenaFlag maps\mp\gametypes\_gameobjects::setUseTime( 20.0 );
arenaFlag maps\mp\gametypes\_gameobjects::setUseText( &"MP_CAPTURING_FLAG" );
label = arenaFlag maps\mp\gametypes\_gameobjects::getLabel();
arenaFlag.label = label;
arenaFlag maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", "compass_waypoint_defend");
arenaFlag maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", "waypoint_defend");
arenaFlag maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", "compass_waypoint_captureneutral");
arenaFlag maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", "waypoint_captureneutral");
arenaFlag maps\mp\gametypes\_gameobjects::setVisibleTeam( "any" );
arenaFlag.onUse = ::onUse;
arenaFlag.onBeginUse = ::onBeginUse;
arenaFlag.onUseUpdate = ::onUseUpdate;
arenaFlag.onEndUse = ::onEndUse;
arenaFlag.isArena = true;
//play sound to show flag is now available for capture
iPrintLnBold( "Arena flag spawned" );
level._arenaFlag playSound( "flag_spawned" );
traceStart = visuals[0].origin + (0,0,32);
traceEnd = visuals[0].origin + (0,0,-32);
trace = bulletTrace( traceStart, traceEnd, false, undefined );
upangles = vectorToAngles( trace["normal"] );
arenaFlag.baseeffectforward = anglesToForward( upangles );
arenaFlag.baseeffectright = anglesToRight( upangles );
arenaFlag.baseeffectpos = trace["position"];
arenaFlag.levelFlag = level._arenaFlag;
level._arenaFlag = arenaFlag;
}
setupDomFlag( primaryFlags, secondaryFlags )
{
for ( index = 0; index < primaryFlags.size; index++ )
{
label = primaryFlags[index].script_label;
if ( label != "_b" )
{
primaryFlags[index] delete();
}
else
{
level._arenaFlag = primaryFlags[index];
return;
}
}
}
onDeadEvent( team )
{
if ( team == game["attackers"] )
{
level thread arena_endGame( game["defenders"], game["strings"][game["attackers"]+"_eliminated"] );
}
else if ( team == game["defenders"] )
{
level thread arena_endGame( game["attackers"], game["strings"][game["defenders"]+"_eliminated"] );
}
}
arena_endGame( winningTeam, endReasonText )
{
thread maps\mp\gametypes\_gamelogic::endGame( winningTeam, endReasonText );
}
giveFlagCaptureXP( touchList )
{
level endon ( "game_ended" );
wait .05;
WaitTillSlowProcessAllowed();
players = getArrayKeys( touchList );
for ( index = 0; index < players.size; index++ )
{
player = touchList[players[index]].player;
player thread [[level._onXPEvent]]( "capture" );
maps\mp\gametypes\_gamescore::givePlayerScore( "capture", player );
player thread maps\mp\_matchdata::logGameEvent( "capture", player.origin );
}
}
onUse( player )
{
team = player.pers["team"];
oldTeam = self maps\mp\gametypes\_gameobjects::getOwnerTeam();
label = self maps\mp\gametypes\_gameobjects::getLabel();
//player logString( "flag captured: " + self.label );
self.captureTime = getTime();
self maps\mp\gametypes\_gameobjects::setOwnerTeam( team );
self maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", "compass_waypoint_capture" );
self maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", "waypoint_capture" );
self.visuals[0] setModel( game["flagmodels"][team] );
assert( team != "neutral" );
if ( oldTeam == "neutral" )
{
otherTeam = getOtherTeam( team );
thread printAndSoundOnEveryone( team, otherTeam, &"MP_NEUTRAL_FLAG_CAPTURED_BY", &"MP_NEUTRAL_FLAG_CAPTURED_BY", "mp_war_objective_taken", undefined, player );
statusDialog( "captured_a", team );
statusDialog( "enemy_has_a", otherTeam );
}
else
thread printAndSoundOnEveryone( team, oldTeam, &"MP_ENEMY_FLAG_CAPTURED_BY", &"MP_FRIENDLY_FLAG_CAPTURED_BY", "mp_war_objective_taken", "mp_war_objective_lost", player );
thread giveFlagCaptureXP( self.touchList[team] );
player notify( "objective", "captured" );
thread flagCaptured( team, &"MP_DOM_NEUTRAL_FLAG_CAPTURED" );
}
onBeginUse( player )
{
ownerTeam = self maps\mp\gametypes\_gameobjects::getOwnerTeam();
self.didStatusNotify = false;
if ( ownerTeam == "neutral" )
{
otherTeam = getOtherTeam( player.pers["team"] );
statusDialog( "securing", player.pers["team"] );
self.objPoints[player.pers["team"]] thread maps\mp\gametypes\_objpoints::startFlashing();
statusDialog( "enemy_taking", otherTeam );
return;
}
if ( ownerTeam == "allies" )
otherTeam = "axis";
else
otherTeam = "allies";
self.objPoints["allies"] thread maps\mp\gametypes\_objpoints::startFlashing();
self.objPoints["axis"] thread maps\mp\gametypes\_objpoints::startFlashing();
}
onUseUpdate( team, progress, change )
{
if ( progress > 0.05 && change && !self.didStatusNotify )
{
otherTeam = getOtherTeam( team );
statusDialog( "losing_a", otherTeam );
statusDialog( "securing_a", team );
self.didStatusNotify = true;
}
}
onEndUse( team, player, success )
{
self.objPoints["allies"] thread maps\mp\gametypes\_objpoints::stopFlashing();
self.objPoints["axis"] thread maps\mp\gametypes\_objpoints::stopFlashing();
}
statusDialog( dialog, team )
{
time = getTime();
if ( getTime() < level._lastStatus[team] + 6000 )
return;
thread delayedLeaderDialog( dialog, team );
level._lastStatus[team] = getTime();
}
delayedLeaderDialog( sound, team )
{
level endon ( "game_ended" );
wait .1;
WaitTillSlowProcessAllowed();
leaderDialog( sound, team );
}
delayedLeaderDialogBothTeams( sound1, team1, sound2, team2 )
{
level endon ( "game_ended" );
wait .1;
WaitTillSlowProcessAllowed();
leaderDialogBothTeams( sound1, team1, sound2, team2 );
}
flagCaptured( winningTeam, endReasonText )
{
maps\mp\gametypes\_gamelogic::endGame( winningTeam, endReasonText );
}

449
maps/mp/gametypes/crank.gsc Normal file
View File

@ -0,0 +1,449 @@
#include maps\mp\_utility;
#include maps\mp\gametypes\_hud_util;
/*
War
Objective: Score points for your team by eliminating players on the opposing team
Map ends: When one team reaches the score limit, or time limit is reached
Respawning: No wait / Near teammates
Level requirementss
------------------
Spawnpoints:
classname mp_tdm_spawn
All players spawn from these. The spawnpoint chosen is dependent on the current locations of teammates and enemies
at the time of spawn. Players generally spawn behind their teammates relative to the direction of enemies.
Spectator Spawnpoints:
classname mp_global_intermission
Spectators spawn from these and intermission is viewed from these positions.
Atleast one is required, any more and they are randomly chosen between.
*/
/*QUAKED mp_tdm_spawn (0.0 0.0 1.0) (-16 -16 0) (16 16 72)
Players spawn away from enemies and near their team at one of these positions.*/
/*QUAKED mp_tdm_spawn_axis_start (0.5 0.0 1.0) (-16 -16 0) (16 16 72)
Axis players spawn away from enemies and near their team at one of these positions at the start of a round.*/
/*QUAKED mp_tdm_spawn_allies_start (0.0 0.5 1.0) (-16 -16 0) (16 16 72)
Allied players spawn away from enemies and near their team at one of these positions at the start of a round.*/
main()
{
if(getdvar("mapname") == "mp_background")
return;
maps\mp\gametypes\_globallogic::init();
maps\mp\gametypes\_callbacksetup::SetupCallbacks();
maps\mp\gametypes\_globallogic::SetupCallbacks();
registerRoundSwitchDvar( level._gameType, 0, 0, 9 );
registerTimeLimitDvar( level._gameType, 10, 0, 1440 );
registerScoreLimitDvar( level._gameType, 500, 0, 5000 );
registerRoundLimitDvar( level._gameType, 1, 0, 10 );
registerWinLimitDvar( level._gameType, 1, 0, 10 );
registerRoundSwitchDvar( level._gameType, 3, 0, 30 );
registerNumLivesDvar( level._gameType, 0, 0, 10 );
registerHalfTimeDvar( level._gameType, 0, 0, 1 );
level._teamBased = true;
level._onStartGameType = ::onStartGameType;
level._getSpawnPoint = ::getSpawnPoint;
level._onNormalDeath = ::onNormalDeath;
level._onSpawnPlayer = ::onSpawnPlayer;
level._onPrecacheGameType = ::onPrecacheGameType;
//level.onTimeLimit = ::onTimeLimit; // overtime not fully supported yet
game["dialog"]["gametype"] = "tm_death";
if ( getDvarInt( "g_hardcore" ) )
game["dialog"]["gametype"] = "hc_" + game["dialog"]["gametype"];
else if ( getDvarInt( "camera_thirdPerson" ) )
game["dialog"]["gametype"] = "thirdp_" + game["dialog"]["gametype"];
else if ( getDvarInt( "scr_diehard" ) )
game["dialog"]["gametype"] = "dh_" + game["dialog"]["gametype"];
else if (getDvarInt( "scr_" + level._gameType + "_promode" ) )
game["dialog"]["gametype"] = game["dialog"]["gametype"] + "_pro";
game["strings"]["overtime_hint"] = &"MP_FIRST_BLOOD";
}
onPrecacheGameType()
{
precacheShader( "waypoint_captureneutral" );
precacheShader( "waypoint_captureneutral_a" );
precacheShader( "waypoint_captureneutral_b" );
precacheShader( "waypoint_captureneutral_c" );
}
onStartGameType()
{
setClientNameMode("auto_change");
if ( !isdefined( game["switchedsides"] ) )
game["switchedsides"] = false;
if ( game["switchedsides"] )
{
oldAttackers = game["attackers"];
oldDefenders = game["defenders"];
game["attackers"] = oldDefenders;
game["defenders"] = oldAttackers;
}
setObjectiveText( "allies", &"OBJECTIVES_WAR" );
setObjectiveText( "axis", &"OBJECTIVES_WAR" );
if ( level._splitscreen )
{
setObjectiveScoreText( "allies", &"OBJECTIVES_WAR" );
setObjectiveScoreText( "axis", &"OBJECTIVES_WAR" );
}
else
{
setObjectiveScoreText( "allies", &"OBJECTIVES_WAR_SCORE" );
setObjectiveScoreText( "axis", &"OBJECTIVES_WAR_SCORE" );
}
setObjectiveHintText( "allies", &"OBJECTIVES_WAR_HINT" );
setObjectiveHintText( "axis", &"OBJECTIVES_WAR_HINT" );
level._spawnMins = ( 0, 0, 0 );
level._spawnMaxs = ( 0, 0, 0 );
maps\mp\gametypes\_spawnlogic::placeSpawnPoints( "mp_tdm_spawn_allies_start" );
maps\mp\gametypes\_spawnlogic::placeSpawnPoints( "mp_tdm_spawn_axis_start" );
maps\mp\gametypes\_spawnlogic::addSpawnPoints( "allies", "mp_tdm_spawn" );
maps\mp\gametypes\_spawnlogic::addSpawnPoints( "axis", "mp_tdm_spawn" );
level._mapCenter = maps\mp\gametypes\_spawnlogic::findBoxCenter( level._spawnMins, level._spawnMaxs );
setMapCenter( level._mapCenter );
allowed[0] = "dom";
allowed[1] = "airdrop_pallet";
maps\mp\gametypes\_gameobjects::main(allowed);
thread campKiller();
thread crankBatteries();
}
crankBatteries()
{
game["flagmodels"] = [];
game["flagmodels"]["neutral"] = "prop_flag_neutral";
game["flagmodels"]["crate"] = "com_plasticcase_friendly";
precacheModel( game["flagmodels"]["neutral"] );
precacheModel( game["flagmodels"]["crate"] );
precacheShader( "waypoint_ammo_friendly" );
precacheShader( "compass_objpoint_ammo_friendly" );
primaryFlags = getEntArray( "flag_primary", "targetname" );
secondaryFlags = getEntArray( "flag_secondary", "targetname" );
if ( (primaryFlags.size + secondaryFlags.size) < 2 )
{
printLn( "^1Not enough domination flags found in level!" );
maps\mp\gametypes\_callbacksetup::AbortLevel();
return;
}
level._flags = [];
for ( index = 0; index < primaryFlags.size; index++ )
level._flags[level._flags.size] = primaryFlags[index];
for ( index = 0; index < secondaryFlags.size; index++ )
level._flags[level._flags.size] = secondaryFlags[index];
level._domFlags = [];
for ( index = 0; index < level._flags.size; index++ )
{
trigger = level._flags[index];
if ( isDefined( trigger.target ) )
{
visuals[0] = getEnt( trigger.target, "targetname" );
}
else
{
visuals[0] = spawn( "script_model", trigger.origin );
visuals[0].angles = trigger.angles;
}
visuals[0] setModel( game["flagmodels"]["crate"] );
domFlag = maps\mp\gametypes\_gameobjects::createUseObject( "neutral", trigger, visuals, (0,0,100) );
domFlag maps\mp\gametypes\_gameobjects::allowUse( "any" );
domFlag maps\mp\gametypes\_gameobjects::setUseTime( 0.5 );
label = domFlag maps\mp\gametypes\_gameobjects::getLabel();
domFlag.label = label;
printLn( "Flag Label: " + label );
domFlag maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", "waypoint_captureneutral" + label );
domFlag maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", "waypoint_captureneutral" + label );
domFlag maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", "waypoint_captureneutral" + label );
domFlag maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", "waypoint_captureneutral" + label );
domFlag maps\mp\gametypes\_gameobjects::setVisibleTeam( "any" );
domFlag.onUse = ::onUseBatt;
domFlag.onBeginUse = ::onBattBeginUse;
domFlag.onUseUpdate = ::onBattUseUpdate;
domFlag.onEndUse = ::onBattEndUse;
traceStart = visuals[0].origin + (0,0,32);
traceEnd = visuals[0].origin + (0,0,-32);
trace = bulletTrace( traceStart, traceEnd, false, undefined );
upangles = vectorToAngles( trace["normal"] );
domFlag.baseeffectforward = anglesToForward( upangles );
domFlag.baseeffectright = anglesToRight( upangles );
domFlag.baseeffectpos = trace["position"];
// legacy spawn code support
level._flags[index].useObj = domFlag;
level._flags[index].adjflags = [];
level._flags[index].nearbyspawns = [];
domFlag.levelFlag = level._flags[index];
level._domFlags[level._domFlags.size] = domFlag;
}
}
onUseBatt( player )
{
if( isDefined( player.canUseBatt ) && player.canUseBatt )
{
player thread maps\mp\_flashgrenades::applyFlash( 1.5, 1 );
player.health = player.maxHealth;
player thread batteryUseCooldown();
}
}
batteryUseCooldown()
{
level endon( "game_ended" );
self endon( "death" );
self endon( "disconnect" );
self.canUseBatt = false;
wait( 10 );
self.canUseBatt = true;
}
onBattBeginUse( player )
{
}
onBattUseUpdate( team, progress, change )
{
}
onBattEndUse( team, player, success )
{
}
onSpawnPlayer()
{
println( "onSpawnPlayer() player = " + self.name );
self thread monitorCrankSprint();
self.canUseBatt = true;
}
monitorCrankSprint()
{
level endon( "game_ended" );
self endon( "death" );
self endon( "disconnect" );
println( "Started monitorCrankSprint() player = " + self.name );
while(1)
{
println( "waiting monitorCrankSprint()" );
self waittill("sprint_begin");
self thread monitorCrankSprintTime();
}
}
monitorCrankSprintTime()
{
println( "monitorCrankSprintTime()" );
level endon( "game_ended" );
self endon( "spawned_player" );
self endon( "death" );
self endon( "disconnect" );
self endon( "sprint_end" );
startTime = getTime();
while(1)
{
// wait one second, then award health
wait( 1 );
// we'll do this until they stop sprinting
self.health += 10;
if( self.health > self.maxHealth )
{
self.health = self.maxHealth;
}
println( "Giving health, health = " + self.health );
}
}
campKiller()
{
println( "Started campKiller()" );
level endon ( "game_ended" );
// var setup
level._minCampDistance = 280;
level._campCounter = 0;
level._numCampSpots = 3;
level._campSpots = [];
if( level._prematchPeriod > 0 )
{
wait( level._prematchPeriod + 3 ); // add in a bit of grace time
}
while ( !level._gameEnded )
{
/*if( isDefined( game["gamestarted"] ) && game["gamestarted"] )
{
wait(1);
continue;
}*/
// first update positions
foreach ( player in level._players )
{
player.campSpots[ level._campCounter % level._numCampSpots ] = player.origin;
}
// now, lets see how far each person has moved
startNum = ( level._campCounter + 1 ) % level._numCampSpots; // since this is a circular buffer, this should be the oldest num we have
endNum = level._campCounter % level._numCampSpots;
foreach ( player in level._players )
{
dist = 0;
prev = 0;
for( index = startNum; true; index = ( index + 1 ) % level._numCampSpots )
{
// skip the first, since we don't have a previous position to compare to
if( index != startNum )
{
if( index < player.campSpots.size ) // make sure we don'
{
if( isDefined( player.campSpots[index] ) && isDefined( player.campSpots[prev] ) )
{
dist += distance( player.campSpots[ prev ], player.campSpots[ index ] );
}
}
}
prev = index;
if( index == endNum )
{
break;
}
}
canTakeDamage = true;
// are they camping?
if( isDefined( player.selectingLocation ) && player.selectingLocation == true )
{
canTakeDamage = false;
}
if( player IsLinked() )
{
canTakeDamage = false;
}
if( canTakeDamage && dist < level._minCampDistance )
{
println( "Player " + player.name + " is camping! dist = " + dist );
//player maps\mp\_radiation::radiationEffect();
//player shellshock( "mp_radiation_low", 0.5);
player.radiationSound = "item_geigercouner_level3";
player stopLoopSound();
player playLoopSound( player.radiationSound );
player ViewKick( 3, player.origin );
player maps\mp\_radiation::doRadiationDamage(15);
}
else
{
player stopLoopSound();
if( !canTakeDamage )
{
println( "Player " + player.name + " ignored, airstriking" );
}
else
{
println( "Player " + player.name + " dist = " + dist );
}
//player notify( "leftTrigger");
}
}
level._campCounter++;
wait ( 1.0 );
}
}
getSpawnPoint()
{
spawnteam = self.pers["team"];
if ( game["switchedsides"] )
spawnteam = getOtherTeam( spawnteam );
if ( level._inGracePeriod )
{
spawnPoints = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_tdm_spawn_" + spawnteam + "_start" );
spawnPoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_Random( spawnPoints );
}
else
{
spawnPoints = maps\mp\gametypes\_spawnlogic::getTeamSpawnPoints( spawnteam );
spawnPoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_NearTeam( spawnPoints );
}
return spawnPoint;
}
onNormalDeath( victim, attacker, lifeId )
{
score = maps\mp\gametypes\_rank::getScoreInfoValue( "kill" );
assert( isDefined( score ) );
attacker maps\mp\gametypes\_gamescore::giveTeamScoreForObjective( attacker.pers["team"], score );
if ( game["state"] == "postgame" && game["teamScores"][attacker.team] > game["teamScores"][level._otherTeam[attacker.team]] )
attacker.finalKill = true;
}
onTimeLimit()
{
if ( game["status"] == "overtime" )
{
winner = "forfeit";
}
else if ( game["teamScores"]["allies"] == game["teamScores"]["axis"] )
{
winner = "overtime";
}
else if ( game["teamScores"]["axis"] > game["teamScores"]["allies"] )
{
winner = "axis";
}
else
{
winner = "allies";
}
thread maps\mp\gametypes\_gamelogic::endGame( winner, game["strings"]["time_limit_reached"] );
}

763
maps/mp/gametypes/cwtest.gsc Normal file
View File

@ -0,0 +1,763 @@
#include common_scripts\utility;
#include maps\mp\_utility;
#include maps\mp\gametypes\_hud_util;
/*
"Cyber War Test"
// ...etc...
*/
/*QUAKED mp_sab_spawn_axis (0.75 0.0 0.5) (-16 -16 0) (16 16 72)
Axis players spawn away from enemies and near their team at one of these positions.*/
/*QUAKED mp_sab_spawn_axis_planted (0.75 0.0 0.5) (-16 -16 0) (16 16 72)
Axis players spawn away from enemies and near their team at one of these positions.*/
/*QUAKED mp_sab_spawn_allies (0.0 0.75 0.5) (-16 -16 0) (16 16 72)
Allied players spawn away from enemies and near their team at one of these positions.*/
/*QUAKED mp_sab_spawn_allies_planted (0.0 0.75 0.5) (-16 -16 0) (16 16 72)
Allied players spawn away from enemies and near their team at one of these positions.*/
/*QUAKED mp_sab_spawn_axis_start (1.0 0.0 0.5) (-16 -16 0) (16 16 72)
Axis players spawn away from enemies and near their team at one of these positions at the start of a round.*/
/*QUAKED mp_sab_spawn_allies_start (0.0 1.0 0.5) (-16 -16 0) (16 16 72)
Allied players spawn away from enemies and near their team at one of these positions at the start of a round.*/
main()
{
if ( getdvar("mapname") == "mp_background" )
return;
maps\mp\gametypes\_globallogic::init();
maps\mp\gametypes\_callbacksetup::SetupCallbacks();
maps\mp\gametypes\_globallogic::SetupCallbacks();
level._teamBased = true;
registerRoundSwitchDvar( level._gameType, 0, 0, 9 );
registerTimeLimitDvar( level._gameType, 10, 0, 1440 );
registerScoreLimitDvar( level._gameType, 6, 0, 25 );
registerRoundLimitDvar( level._gameType, 1, 0, 10 );
registerWinLimitDvar( level._gameType, 1, 0, 10 );
registerNumLivesDvar( level._gameType, 0, 0, 10 );
registerHalfTimeDvar( level._gameType, 0, 0, 1 );
setOverTimeLimitDvar( 2 );
level._onPrecacheGameType = ::onPrecacheGameType;
level._onStartGameType = ::onStartGameType;
level._getSpawnPoint = ::getSpawnPoint;
level._onSpawnPlayer = ::onSpawnPlayer;
level._onOneLeftEvent = ::onOneLeftEvent;
level._onTimeLimit = ::onTimeLimit;
level._onNormalDeath = ::onNormalDeath;
level._initGametypeAwards = ::initGametypeAwards;
game["dialog"]["gametype"] = "cyberwar";
if ( getDvarInt( "g_hardcore" ) )
game["dialog"]["gametype"] = "hc_" + game["dialog"]["gametype"];
else if ( getDvarInt( "camera_thirdPerson" ) )
game["dialog"]["gametype"] = "thirdp_" + game["dialog"]["gametype"];
else if ( getDvarInt( "scr_diehard" ) )
game["dialog"]["gametype"] = "dh_" + game["dialog"]["gametype"];
else if (getDvarInt( "scr_" + level._gameType + "_promode" ) )
game["dialog"]["gametype"] = game["dialog"]["gametype"] + "_pro";
game["dialog"]["offense_obj"] = "capture_obj";
game["dialog"]["defense_obj"] = "capture_obj";
}
onPrecacheGameType()
{
game["intel_dropped_sound"] = "mp_war_objective_lost";
game["intel_recovered_sound"] = "mp_war_objective_taken";
precacheShader("waypoint_captureneutral");
precacheShader("waypoint_kill");
precacheShader("waypoint_target");
precacheShader("waypoint_escort");
precacheShader("hud_suitcase_bomb");
precacheString(&"MP_EXPLOSIVES_RECOVERED_BY");
precacheString(&"MP_EXPLOSIVES_DROPPED_BY");
precacheString(&"PLATFORM_HOLD_TO_UPLOAD_INTEL");
precacheString(&"MP_UPLOADING_INTEL");
precacheString(&"MP_NO_RESPAWN");
precacheString(&"MP_TIE_BREAKER");
precacheString(&"MP_SUDDEN_DEATH");
}
onStartGameType()
{
if ( !isdefined( game["switchedsides"] ) )
game["switchedsides"] = false;
setClientNameMode("auto_change");
// tagTG<TODO> Need new objective hints and text
setObjectiveText( "allies", &"OBJECTIVES_SAB" );
setObjectiveText( "axis", &"OBJECTIVES_SAB" );
if ( level._splitscreen )
{
setObjectiveScoreText( "allies", &"OBJECTIVES_SAB" );
setObjectiveScoreText( "axis", &"OBJECTIVES_SAB" );
}
else
{
setObjectiveScoreText( "allies", &"OBJECTIVES_SAB_SCORE" );
setObjectiveScoreText( "axis", &"OBJECTIVES_SAB_SCORE" );
}
setObjectiveHintText( "allies", &"OBJECTIVES_SAB_HINT" );
setObjectiveHintText( "axis", &"OBJECTIVES_SAB_HINT" );
level._spawnMins = ( 0, 0, 0 );
level._spawnMaxs = ( 0, 0, 0 );
maps\mp\gametypes\_spawnlogic::placeSpawnPoints( "mp_tdm_spawn_allies_start" );
maps\mp\gametypes\_spawnlogic::placeSpawnPoints( "mp_tdm_spawn_axis_start" );
maps\mp\gametypes\_spawnlogic::addSpawnPoints( "allies", "mp_tdm_spawn" );
maps\mp\gametypes\_spawnlogic::addSpawnPoints( "axis", "mp_tdm_spawn" );
level._mapCenter = maps\mp\gametypes\_spawnlogic::findBoxCenter( level._spawnMins, level._spawnMaxs );
setMapCenter( level._mapCenter );
maps\mp\gametypes\_rank::registerScoreInfo( "plant", 200 );
maps\mp\gametypes\_rank::registerScoreInfo( "destroy", 1000 );
maps\mp\gametypes\_rank::registerScoreInfo( "defuse", 150 );
allowed[0] = "cwtest";
maps\mp\gametypes\_gameobjects::main(allowed);
thread updateGametypeDvars();
thread cyberWarSetup();
}
getSpawnPoint()
{
spawnteam = self.pers["team"];
if ( game["switchedsides"] )
spawnteam = getOtherTeam( spawnteam );
if ( level._inGracePeriod )
{
spawnPoints = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_tdm_spawn_" + spawnteam + "_start" );
spawnPoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_Random( spawnPoints );
}
else
{
spawnPoints = maps\mp\gametypes\_spawnlogic::getTeamSpawnPoints( spawnteam );
spawnPoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_NearTeam( spawnPoints );
}
return spawnPoint;
}
onSpawnPlayer()
{
self.isPlanting = false;
if( ( inOvertime() ) && !isDefined( self.otSpawned ) )
self thread printOTHint();
}
printOTHint()
{
self endon ( "disconnect" );
// give the "Overtime!" message time to show
wait ( 0.25 );
self thread maps\mp\gametypes\_hud_message::SplashNotify( "sudden_death" );
self.otSpawned = true;
}
updateGametypeDvars()
{
level._plantTime = dvarFloatValue( "planttime", 5, 0, 20 );
level._num_active_intel = dvarIntValue( "num_intel", 2, 1, 5 );
level._intel_spawn_delay = dvarFloatValue( "intelspawndelay", 5.0, 0, 20.0 );
level._intel_to_spawn_turret = dvarIntValue( "spawnturretrate", 2, 0, 15 );
}
cyberWarSetup()
{
level._bombExploded = false;
level._effect["bombexplosion"] = loadfx("explosions/tanker_explosion");
triggers = getEntArray( "cwtest_intel_pickup", "targetname" );
if( triggers.size < 1 )
{
error( "No cwtest_intel_pickup triggers found in map." );
return;
}
intel_visuals = getEntArray( "cwtest_intel", "targetname" );
if( intel_visuals.size < 1 )
{
error( "No cwtest_intel script_model found in map." );
return;
}
maperrors = [];
level._cw_intel = [];
for ( i = 0; i < intel_visuals.size; i++ )
{
errored = false;
intel = intel_visuals[i];
intel.trig = undefined;
for ( j = 0; j < triggers.size; j++ )
{
if ( intel istouching( triggers[j] ) )
{
if ( isdefined( intel.trig ) )
{
maperrors[maperrors.size] = "Intel at " + intel.origin + " is touching more than one \"cwtest_intel_pickup\" trigger";
break;
}
intel.trig = triggers[j];
}
}
visuals = [];
visuals[0] = intel;
intel.visuals = visuals;
//intel maps\mp\gametypes\_gameobjects::setModelVisibility( false );
intel.gameObject = maps\mp\gametypes\_gameobjects::createCarryObject( "neutral", intel.trig, intel.visuals, (0,0,32) );
intel.gameObject maps\mp\gametypes\_gameobjects::allowCarry( "none" );
intel.gameObject maps\mp\gametypes\_gameobjects::setVisibleTeam( "none" );
intel.gameObject maps\mp\gametypes\_gameobjects::setModelVisibility( false );
intel.trig.useObj = intel.gameObject;
level._cw_intel[level._cw_intel.size] = intel;
}
if (maperrors.size > 0)
{
println("^1------------ Map Errors ------------");
for(i = 0; i < maperrors.size; i++)
println(maperrors[i]);
println("^1------------------------------------");
error("Map errors. See above");
maps\mp\gametypes\_callbacksetup::AbortLevel();
return;
}
upload_terminals = getEntArray( "terminal_upload", "targetname" );
if( upload_terminals.size < 1 )
{
error("No upload terminals trigger found in map.");
return;
}
level._bombZones["any"] = [];
for ( i = 0; i < upload_terminals.size; i++ )
{
level._bombZones["any"][level._bombZones["any"].size] = createUploadTerminalZone( "any", upload_terminals[i] );
}
level._active_intels = [];
for( i = 0; i < level._num_active_intel; i++ )
{
level._active_intels[i] = undefined;
intel = pickIntelToSpawn();
intel.gameobject makeIntelActive();
}
if ( inOvertime() )
level thread overtimeThread();
}
pickIntelToSpawn()
{
println("pickIntelToSpawn");
validAllies = [];
validAxis = [];
potential_intel = [];
println( "Potential intel size 0" );
for( i = 0; i < level._cw_intel.size; i++ )
{
intel_active = false;
// if( level.cw_intel.size > level.num_active_intel )
// {
// if we have more than the number active needed remove the active intel
for( j = 0; j < level._active_intels.size; j++ )
{
if( isDefined(level._active_intels[j]) && level._active_intels[j] == level._cw_intel[i].gameObject )
{
intel_active = true;
break;
}
}
// }
if( !intel_active )
{
println( "Adding potential intel" );
potential_intel[ potential_intel.size ] = level._cw_intel[i];
}
}
println( "Potential intel size" + potential_intel.size );
foreach ( player in level._players )
{
if ( player.team == "spectator" )
continue;
if ( !isAlive( player ) )
continue;
player.dist = 0;
if ( player.team == "allies" )
validAllies[validAllies.size] = player;
else
validAxis[validAxis.size] = player;
}
if ( !validAllies.size || !validAxis.size )
{
intel = potential_intel[ randomint( potential_intel.size) ];
return intel;
}
for ( i = 0; i < validAllies.size; i++ )
{
for ( j = i + 1; j < validAllies.size; j++ )
{
dist = distanceSquared( validAllies[i].origin, validAllies[j].origin );
validAllies[i].dist += dist;
validAllies[j].dist += dist;
}
}
for ( i = 0; i < validAxis.size; i++ )
{
for ( j = i + 1; j < validAxis.size; j++ )
{
dist = distanceSquared( validAxis[i].origin, validAxis[j].origin );
validAxis[i].dist += dist;
validAxis[j].dist += dist;
}
}
bestPlayer = validAllies[0];
foreach ( player in validAllies )
{
if ( player.dist < bestPlayer.dist )
bestPlayer = player;
}
avgpos["allies"] = bestPlayer.origin;
bestPlayer = validAxis[0];
foreach ( player in validAxis )
{
if ( player.dist < bestPlayer.dist )
bestPlayer = player;
}
avgpos["axis"] = validAxis[0].origin;
bestintel = undefined;
lowestcost = undefined;
for ( i = 0; i < potential_intel.size; i++ )
{
intel = potential_intel[i];
// (purposefully using distance instead of distanceSquared)
cost = abs( distance( intel.origin, avgpos["allies"] ) - distance( intel.origin, avgpos["axis"] ) );
for( j = 0; j < level._active_intels.size; j++ )
{
if( isDefined(level._active_intels[j]) && level._active_intels[j] == intel )
{
cost += 512;
break;
}
}
if ( !isdefined( lowestcost ) || cost < lowestcost )
{
lowestcost = cost;
bestintel = intel;
}
}
assert( isdefined( bestintel ) );
return bestintel;
}
makeIntelActive( use_wait_delay )
{
level endon( "game_ended" );
if( isDefined( use_wait_delay ) && use_wait_delay )
wait level._intel_spawn_delay;
self maps\mp\gametypes\_gameobjects::allowCarry( "any" );
self maps\mp\gametypes\_gameobjects::setVisibleTeam( "any" );
self maps\mp\gametypes\_gameobjects::setModelVisibility( true );
self maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", "waypoint_flag_friendly" );
self maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", "waypoint_flag_friendly" );
self maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", "waypoint_flag_friendly" );
self maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", "waypoint_flag_friendly" );
self maps\mp\gametypes\_gameobjects::setCarryIcon( "hud_suitcase_bomb" );
self.objIDPingEnemy = true;
self.onPickup = ::onPickup;
self.onDrop = ::onDrop;
self.allowWeapons = true;
self.objPoints["allies"].archived = true;
self.objPoints["axis"].archived = true;
self.autoResetTime = 60.0;
found_empty_spot = false;
for( j = 0; j < level._num_active_intel; j++ )
{
// find an empty spot in our array
if( !isDefined( level._active_intels[j] ))
{
found_empty_spot = true;
level._active_intels[j] = self;
break;
}
}
if( !found_empty_spot )
{
error( "Too many active intel( " + level._active_intels.size +" ) ... maybe the current one needs to be disabled first?" );
}
}
makeIntelInactive()
{
self maps\mp\gametypes\_gameobjects::returnHome();
self maps\mp\gametypes\_gameobjects::setModelVisibility( false );
self maps\mp\gametypes\_gameobjects::allowCarry( "none" );
self maps\mp\gametypes\_gameobjects::setVisibleTeam( "none" );
for( j = 0; j < level._num_active_intel; j++ )
{
if( isDefined(level._active_intels[j]) && level._active_intels[j] == self )
{
println( "setting active_intel to undefined index = " + j );
level._active_intels[j] = undefined;
break;
}
}
}
createUploadTerminalZone( team, trigger )
{
visuals = getEntArray( trigger.target, "targetname" );
// tagTG<TODO> figure out why we can't use any as the team here....
terminalZone = maps\mp\gametypes\_gameobjects::createUseObject( "neutral", trigger, visuals, (0,0,64) );
terminalZone resetTermimalSite();
terminalZone.onUse = ::onUse;
terminalZone.onBeginUse = ::onBeginUse;
terminalZone.onEndUse = ::onEndUse;
terminalZone.onCantUse = ::onCantUse;
terminalZone.useWeapon = "briefcase_bomb_mp";
terminalZone.teamUploads["axis"] = 0;
terminalZone.teamUploads["allies"] = 0;
return terminalZone;
}
onBeginUse( player )
{
// uploading intel
player.isPlanting = true;
}
onEndUse( team, player, result )
{
if ( !isAlive( player ) )
return;
player.isPlanting = false;
}
onPickup( player )
{
level notify ( "bomb_picked_up" );
self.autoResetTime = 60.0;
level._useStartSpawns = false;
team = player.pers["team"];
if ( team == "allies" )
otherTeam = "axis";
else
otherTeam = "allies";
player playLocalSound( "mp_suitcase_pickup" );
player leaderDialogOnPlayer( "obj_destroy", "bomb" );
excludeList[0] = player;
leaderDialog( "bomb_taken", team, "bomb", excludeList );
if ( !level._splitscreen )
{
leaderDialog( "bomb_lost", otherTeam, "bomb" );
leaderDialog( "obj_defend", otherTeam, "bomb" );
}
player.isBombCarrier = true;
// recovered the bomb before abandonment timer elapsed
// tagTG<TODO> this is where in sab it would notify people that the bomb is recovered maybe intel recovery needs one too?
// if ( team == self maps\mp\gametypes\_gameobjects::getOwnerTeam() )
// {
// //printOnTeamArg( &"MP_EXPLOSIVES_RECOVERED_BY", team, player );
// playSoundOnPlayers( game["bomb_recovered_sound"], team );
// }
// else
// {
// //printOnTeamArg( &"MP_EXPLOSIVES_RECOVERED_BY", team, player );
// playSoundOnPlayers( game["bomb_recovered_sound"] );
// }
self maps\mp\gametypes\_gameobjects::setOwnerTeam( team );
self maps\mp\gametypes\_gameobjects::setVisibleTeam( "any" );
self maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", "waypoint_kill" );
self maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", "waypoint_kill" );
self maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", "waypoint_escort" );
self maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", "waypoint_escort" );
player incPlayerStat( "bombscarried", 1 );
player thread maps\mp\_matchdata::logGameEvent( "pickup", player.origin );
}
onDrop( player )
{
println( "onDrop" );
if ( isDefined( player ) )
{
// tagTG<TODO> Notify the team that we have dropped intel... we need a new string here
printOnTeamArg( &"MP_EXPLOSIVES_DROPPED_BY", self maps\mp\gametypes\_gameobjects::getOwnerTeam(), player );
if( player.isPlanting )
{
intel = pickIntelToSpawn();
// old intel needs to be deactivated prior to new activation
self makeIntelInactive();
intel.gameobject thread makeIntelActive( true );
}
else
{
playSoundOnPlayers( game["intel_dropped_sound"], self maps\mp\gametypes\_gameobjects::getOwnerTeam() );
thread abandonmentThink( 0.0 );
}
}
else
{
playSoundOnPlayers( game["intel_dropped_sound"], self maps\mp\gametypes\_gameobjects::getOwnerTeam() );
thread abandonmentThink( 0.0 );
}
}
abandonmentThink( delay )
{
level endon ( "bomb_picked_up" );
wait ( delay );
if ( isDefined( self.carrier ) )
return;
if ( self maps\mp\gametypes\_gameobjects::getOwnerTeam() == "allies" )
otherTeam = "axis";
else
otherTeam = "allies";
playSoundOnPlayers( game["intel_dropped_sound"], otherTeam );
self maps\mp\gametypes\_gameobjects::setOwnerTeam( "neutral" );
self maps\mp\gametypes\_gameobjects::setVisibleTeam( "any" );
self maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", "waypoint_flag_friendly" );
self maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", "waypoint_flag_friendly" );
self maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", "waypoint_flag_friendly" );
self maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", "waypoint_flag_friendly" );
}
onUse( player )
{
println( "onUse" );
team = player.pers["team"];
otherTeam = level._otherTeam[team];
// uploaded the intel...
player notify ( "bomb_planted" );
player playSound( "mp_bomb_plant" );
//Add player callout card here if neccesary
player thread maps\mp\gametypes\_hud_message::SplashNotify( "upload", maps\mp\gametypes\_rank::getScoreInfoValue( "plant" ) );
player thread maps\mp\gametypes\_rank::giveRankXP( "plant" );
maps\mp\gametypes\_gamescore::givePlayerScore( "plant", player );
player incPlayerStat( "bombsplanted", 1 );
player thread maps\mp\_matchdata::logGameEvent( "plant", player.origin );
intel_object = player.carryObject;
team = player.pers["team"];
//if ( !inOvertime() )
maps\mp\gametypes\_gamescore::giveTeamScoreForObjective( team, 1 );
self.teamUploads[team] = self.teamUploads[team] + 1;
if( self.teamUploads[team] >= level._intel_to_spawn_turret )
{
self.teamUploads[player.pers["team"]] = 0;
println( "Turret info" );
println( self.curOrigin );
terminalTurret = spawnTurret( "misc_turret", self.curOrigin, level._sentrySettings[ "sentry_minigun" ].weaponInfo );
terminalTurret.angles = self.visuals[0].baseAngles; // tagTG<TODO> find a better place to get angles from
if( isDefined( terminalTurret ) )
{
println( "turret is defined" );
terminalTurret maps\mp\killstreaks\_autosentry::sentry_initSentry( "sentry_minigun", player );
//terminalTurret maps\mp\killstreaks\_autosentry::sentry_setPlaced();
terminalTurret setModel( level._sentrySettings[ "sentry_minigun" ].modelBase );
terminalTurret maps\mp\killstreaks\_autosentry::sentry_makeSolid();
terminalTurret maps\mp\killstreaks\_autosentry::sentry_setActive();
terminalTurret MakeUnusable();
}
else
{
println( "turret is NOT defined" );
}
}
intel = pickIntelToSpawn();
// old intel needs to be deactivated prior to new activation
intel_object makeIntelInactive();
intel.gameobject thread makeIntelActive( true );
}
onCantUse( player )
{
player iPrintLnBold( &"MP_CANT_UPLOAD_WITHOUT_INTEL" );
}
giveLastOnTeamWarning()
{
self endon("death");
self endon("disconnect");
level endon( "game_ended" );
self waitTillRecoveredHealth( 3 );
otherTeam = getOtherTeam( self.pers["team"] );
level thread teamPlayerCardSplash( "callout_lastteammemberalive", self, self.pers["team"] );
level thread teamPlayerCardSplash( "callout_lastenemyalive", self, otherTeam );
level notify ( "last_alive", self );
//self maps\mp\gametypes\_missions::lastManSD();
}
onTimeLimit()
{
if( game["teamScores"]["axis"] > game["teamScores"]["allies"] )
{
thread maps\mp\gametypes\_gamelogic::endGame( "axis", game["strings"]["time_limit_reached"] );
}
else if( game["teamScores"]["axis"] < game["teamScores"]["allies"] )
{
thread maps\mp\gametypes\_gamelogic::endGame( "allies", game["strings"]["time_limit_reached"] );
}
else if( game["teamScores"]["axis"] == game["teamScores"]["allies"] )
{
if ( inOvertime() )
thread maps\mp\gametypes\_gamelogic::endGame( "tie", game["strings"]["time_limit_reached"] );
else
thread maps\mp\gametypes\_gamelogic::endGame( "overtime", game["strings"]["time_limit_reached"] );
}
}
overtimeThread( time )
{
level endon( "game_ended" );
level._inOvertime = true;
wait ( 5.0 );
level._disableSpawning = true;
}
resetTermimalSite()
{
self maps\mp\gametypes\_gameobjects::allowUse( "any" );
self maps\mp\gametypes\_gameobjects::setUseTime( level._plantTime );
self maps\mp\gametypes\_gameobjects::setUseText( &"MP_UPLOADING_INTEL" );
self maps\mp\gametypes\_gameobjects::setUseHintText( &"PLATFORM_HOLD_TO_UPLOAD_INTEL" );
for( i = 0; i < level._cw_intel.size; i++ )
{
self maps\mp\gametypes\_gameobjects::addKeyObject( level._cw_intel[i].gameobject );
}
self maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", "waypoint_targetneutral" );
self maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", "waypoint_targetneutral" );
self maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", "waypoint_targetneutral" );
self maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", "waypoint_targetneutral" );
self maps\mp\gametypes\_gameobjects::setVisibleTeam( "any" );
self.useWeapon = "briefcase_bomb_mp";
}
onOneLeftEvent( team )
{
lastPlayer = getLastLivingPlayer( team );
lastPlayer thread giveLastOnTeamWarning();
}
onNormalDeath( victim, attacker, lifeId, lifeId )
{
if ( victim.isPlanting )
{
thread maps\mp\_matchdata::logKillEvent( lifeId, "planting" );
}
}
initGametypeAwards()
{
maps\mp\_awards::initStatAward( "targetsdestroyed", 0, maps\mp\_awards::highestWins );
maps\mp\_awards::initStatAward( "bombsplanted", 0, maps\mp\_awards::highestWins );
maps\mp\_awards::initStatAward( "bombcarrierkills", 0, maps\mp\_awards::highestWins );
maps\mp\_awards::initStatAward( "bombscarried", 0, maps\mp\_awards::highestWins );
maps\mp\_awards::initStatAward( "killsasbombcarrier", 0, maps\mp\_awards::highestWins );
}

245
maps/mp/gametypes/gg.gsc Normal file
View File

@ -0,0 +1,245 @@
#include maps\mp\_utility;
#include maps\mp\gametypes\_hud_util;
#include common_scripts\utility;
/*
Gun Game
Objective: Score points for your team by eliminating players on the opposing team
Map ends: When one player reaches the max level gun, or time limit is reached
Respawning: No wait / Near teammates
Level requirementss
------------------
Spawnpoints:
classname mp_tdm_spawn
All players spawn from these. The spawnpoint chosen is dependent on the current locations of teammates and enemies
at the time of spawn. Players generally spawn behind their teammates relative to the direction of enemies.
Spectator Spawnpoints:
classname mp_global_intermission
Spectators spawn from these and intermission is viewed from these positions.
Atleast one is required, any more and they are randomly chosen between.
*/
/*QUAKED mp_tdm_spawn (0.0 0.0 1.0) (-16 -16 0) (16 16 72)
Players spawn away from enemies and near their team at one of these positions.*/
/*QUAKED mp_tdm_spawn_axis_start (0.5 0.0 1.0) (-16 -16 0) (16 16 72)
Axis players spawn away from enemies and near their team at one of these positions at the start of a round.*/
/*QUAKED mp_tdm_spawn_allies_start (0.0 0.5 1.0) (-16 -16 0) (16 16 72)
Allied players spawn away from enemies and near their team at one of these positions at the start of a round.*/
main()
{
if(getdvar("mapname") == "mp_background")
return;
maps\mp\gametypes\_globallogic::init();
maps\mp\gametypes\_callbacksetup::SetupCallbacks();
maps\mp\gametypes\_globallogic::SetupCallbacks();
registerRoundSwitchDvar( level._gameType, 0, 0, 9 );
registerTimeLimitDvar( level._gameType, 10, 0, 1440 );
registerScoreLimitDvar( level._gameType, 400 , 400, 400 );
registerRoundLimitDvar( level._gameType, 1, 0, 10 );
registerWinLimitDvar( level._gameType, 1, 0, 10 );
registerRoundSwitchDvar( level._gameType, 3, 0, 30 );
registerNumLivesDvar( level._gameType, 0, 0, 10 );
registerHalfTimeDvar( level._gameType, 0, 0, 1 );
level._teamBased = true;
level._onStartGameType = ::onStartGameType;
level._getSpawnPoint = ::getSpawnPoint;
level._onNormalDeath = ::onNormalDeath;
level._onSpawnPlayer = ::onSpawnPlayer;
//level.onTimeLimit = ::onTimeLimit; // overtime not fully supported yet
game["dialog"]["gametype"] = "gg";
game["strings"]["overtime_hint"] = &"MP_FIRST_BLOOD";
}
onStartGameType()
{
setClientNameMode("auto_change");
if ( !isdefined( game["switchedsides"] ) )
game["switchedsides"] = false;
if ( game["switchedsides"] )
{
oldAttackers = game["attackers"];
oldDefenders = game["defenders"];
game["attackers"] = oldDefenders;
game["defenders"] = oldAttackers;
}
setObjectiveText( "allies", &"OBJECTIVES_WAR" );
setObjectiveText( "axis", &"OBJECTIVES_WAR" );
if ( level._splitscreen )
{
setObjectiveScoreText( "allies", &"OBJECTIVES_WAR" );
setObjectiveScoreText( "axis", &"OBJECTIVES_WAR" );
}
else
{
setObjectiveScoreText( "allies", &"OBJECTIVES_WAR_SCORE" );
setObjectiveScoreText( "axis", &"OBJECTIVES_WAR_SCORE" );
}
setObjectiveHintText( "allies", &"OBJECTIVES_WAR_HINT" );
setObjectiveHintText( "axis", &"OBJECTIVES_WAR_HINT" );
level._spawnMins = ( 0, 0, 0 );
level._spawnMaxs = ( 0, 0, 0 );
maps\mp\gametypes\_spawnlogic::placeSpawnPoints( "mp_tdm_spawn_allies_start" );
maps\mp\gametypes\_spawnlogic::placeSpawnPoints( "mp_tdm_spawn_axis_start" );
maps\mp\gametypes\_spawnlogic::addSpawnPoints( "allies", "mp_tdm_spawn" );
maps\mp\gametypes\_spawnlogic::addSpawnPoints( "axis", "mp_tdm_spawn" );
level._mapCenter = maps\mp\gametypes\_spawnlogic::findBoxCenter( level._spawnMins, level._spawnMaxs );
setMapCenter( level._mapCenter );
level._killstreakRewards = false;
allowed[0] = level._gameType;
allowed[1] = "airdrop_pallet";
maps\mp\gametypes\_gameobjects::main(allowed);
}
getSpawnPoint()
{
spawnteam = self.pers["team"];
if ( game["switchedsides"] )
spawnteam = getOtherTeam( spawnteam );
if ( level._inGracePeriod )
{
spawnPoints = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_tdm_spawn_" + spawnteam + "_start" );
spawnPoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_Random( spawnPoints );
}
else
{
spawnPoints = maps\mp\gametypes\_spawnlogic::getTeamSpawnPoints( spawnteam );
spawnPoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_NearTeam( spawnPoints );
}
return spawnPoint;
}
onSpawnPlayer()
{
self thread onPlayerSpawned();
}
onPlayerSpawned()
{
self waittill( "spawned_player" );
giveGunGameWeapon( self, self.score );
}
onNormalDeath( victim, attacker, lifeId )
{
score = maps\mp\gametypes\_rank::getScoreInfoValue( "kill" );
assert( isDefined( score ) );
update_team_score( attacker, victim );
if ( game["state"] == "postgame" && game["teamScores"][attacker.team] > game["teamScores"][level._otherTeam[attacker.team]] )
attacker.finalKill = true;
}
update_team_score( player, victim )
{
if ( isDefined( level._nukeIncoming ) )
return;
score = player.pers["score"];
player.score = player.pers["score"];
if( player.score % 500 == 0 )
giveGunGameWeapon( player, player.score );
team = player.pers["team"];
team_score = game["teamScores"][team];
if( player.score > team_score )
{
player maps\mp\gametypes\_gamescore::giveTeamScoreForObjective( team, ( player.score - team_score ));
}
}
giveGunGameWeapon( player, score )
{
score_value = maps\mp\gametypes\_rank::getScoreInfoValue( "kill" );
assert( isDefined( score_value ) );
num_kills = ( score / score_value );
score_limit_kills = ( getScoreLimit() / score_value );
kills_per_level = ( score_limit_kills / 5 );
weapon = player getCurrentWeapon();
off_hand = player getCurrentOffhand();
while( player IsMeleeing() )
wait( 0.01 );
while( player IsThrowingGrenade() )
wait( 0.01 );
if( num_kills <= 0 )
{
player maps\mp\gametypes\_class::giveLoadout( player.pers["team"], "class0" );
player _clearPerks();
}
else if( num_kills <= ( 1 * kills_per_level ))
{
player maps\mp\gametypes\_class::giveLoadout( player.pers["team"], "class1" );
player _clearPerks();
}
else if( num_kills <= ( 2 * kills_per_level ))
{
player maps\mp\gametypes\_class::giveLoadout( player.pers["team"], "class2" );
player _clearPerks();
}
else if( num_kills <= ( 3 * kills_per_level ))
{
player maps\mp\gametypes\_class::giveLoadout( player.pers["team"], "class3" );
player _clearPerks();
}
else
{
player maps\mp\gametypes\_class::giveLoadout( player.pers["team"], "class4" );
player _clearPerks();
}
}
onTimeLimit()
{
if ( game["status"] == "overtime" )
{
winner = "forfeit";
}
else if ( game["teamScores"]["allies"] == game["teamScores"]["axis"] )
{
winner = "overtime";
}
else if ( game["teamScores"]["axis"] > game["teamScores"]["allies"] )
{
winner = "axis";
}
else
{
winner = "allies";
}
thread maps\mp\gametypes\_gamelogic::endGame( winner, game["strings"]["time_limit_reached"] );
}

940
maps/mp/gametypes/joe.gsc Normal file
View File

@ -0,0 +1,940 @@
#include common_scripts\utility;
#include maps\mp\_utility;
#include maps\mp\gametypes\_hud_util;
/*
Domination
Objective: Capture all the flags by touching them
Map ends: When one team captures all the flags, or time limit is reached
Respawning: No wait / Near teammates
Level requirements
------------------
Spawnpoints:
classname mp_tdm_spawn
All players spawn from these. The spawnpoint chosen is dependent on the current locations of owned flags, teammates and
enemies at the time of spawn. Players generally spawn behind their teammates relative to the direction of enemies.
Optionally, give a spawnpoint a script_linkto to specify which flag it "belongs" to (see Flag Descriptors).
Spectator Spawnpoints:
classname mp_global_intermission
Spectators spawn from these and intermission is viewed from these positions.
Atleast one is required, any more and they are randomly chosen between.
Flags:
classname trigger_radius
targetname flag_primary or flag_secondary
Flags that need to be captured to win. Primary flags take time to capture; secondary flags are instant.
Flag Descriptors:
classname script_origin
targetname flag_descriptor
Place one flag descriptor close to each flag. Use the script_linkname and script_linkto properties to say which flags
it can be considered "adjacent" to in the level. For instance, if players have a primary path from flag1 to flag2, and
from flag2 to flag3, flag2 would have a flag_descriptor with these properties:
script_linkname flag2
script_linkto flag1 flag3
Set scr_domdebug to 1 to see flag connections and what spawnpoints are considered connected to each flag.
*/
/*QUAKED mp_dom_spawn (0.5 0.5 1.0) (-16 -16 0) (16 16 72)
Players spawn near their flags at one of these positions.*/
/*QUAKED mp_dom_spawn_axis_start (1.0 0.0 1.0) (-16 -16 0) (16 16 72)
Axis players spawn away from enemies and near their team at one of these positions at the start of a round.*/
/*QUAKED mp_dom_spawn_allies_start (0.0 1.0 1.0) (-16 -16 0) (16 16 72)
Allied players spawn away from enemies and near their team at one of these positions at the start of a round.*/
main()
{
if(getdvar("mapname") == "mp_background")
return;
maps\mp\gametypes\_globallogic::init();
maps\mp\gametypes\_callbacksetup::SetupCallbacks();
maps\mp\gametypes\_globallogic::SetupCallbacks();
registerTimeLimitDvar( level._gameType, 30, 0, 1440 );
registerScoreLimitDvar( level._gameType, 300, 0, 1000 );
registerRoundLimitDvar( level._gameType, 1, 0, 10 );
registerWinLimitDvar( level._gameType, 1, 0, 10 );
registerNumLivesDvar( level._gameType, 0, 0, 10 );
registerHalfTimeDvar( level._gameType, 0, 0, 1 );
registerNumLivesDvar( level._gameType, 1, 0, 5 );
level._teamBased = true;
level._onStartGameType = ::onStartGameType;
level._getSpawnPoint = ::getSpawnPoint;
level._onPrecacheGameType = ::onPrecacheGameType;
level._onSpawnPlayer = ::onSpawnPlayer;
level._onNormalDeath = ::onNormalDeath;
level._onDeadEvent = ::onDeadEvent;
game["dialog"]["gametype"] = "domination";
if ( getDvarInt( "g_hardcore" ) )
game["dialog"]["gametype"] = "hc_" + game["dialog"]["gametype"];
else if ( getDvarInt( "camera_thirdPerson" ) )
game["dialog"]["gametype"] = "thirdp_" + game["dialog"]["gametype"];
else if ( getDvarInt( "scr_diehard" ) )
game["dialog"]["gametype"] = "dh_" + game["dialog"]["gametype"];
else if (getDvarInt( "scr_" + level._gameType + "_promode" ) )
game["dialog"]["gametype"] = game["dialog"]["gametype"] + "_pro";
game["dialog"]["offense_obj"] = "capture_objs";
game["dialog"]["defense_obj"] = "capture_objs";
}
onPrecacheGameType()
{
precacheShader( "waypoint_captureneutral" );
precacheShader( "waypoint_capture" );
precacheShader( "waypoint_defend" );
precacheShader( "waypoint_captureneutral_a" );
precacheShader( "waypoint_capture_a" );
precacheShader( "waypoint_defend_a" );
precacheShader( "waypoint_captureneutral_b" );
precacheShader( "waypoint_capture_b" );
precacheShader( "waypoint_defend_b" );
precacheShader( "waypoint_captureneutral_c" );
precacheShader( "waypoint_capture_c" );
precacheShader( "waypoint_defend_c" );
precacheShader( "waypoint_captureneutral" );
precacheShader( "waypoint_capture" );
precacheShader( "waypoint_defend" );
precacheShader( "waypoint_captureneutral_a" );
precacheShader( "waypoint_capture_a" );
precacheShader( "waypoint_defend_a" );
precacheShader( "waypoint_captureneutral_b" );
precacheShader( "waypoint_capture_b" );
precacheShader( "waypoint_defend_b" );
precacheShader( "waypoint_captureneutral_c" );
precacheShader( "waypoint_capture_c" );
precacheShader( "waypoint_defend_c" );
}
onStartGameType()
{
setClientNameMode("auto_change");
if ( !isdefined( game["switchedsides"] ) )
game["switchedsides"] = false;
if ( game["switchedsides"] )
{
oldAttackers = game["attackers"];
oldDefenders = game["defenders"];
game["attackers"] = oldDefenders;
game["defenders"] = oldAttackers;
}
setObjectiveText( "allies", &"OBJECTIVES_WAR" );
setObjectiveText( "axis", &"OBJECTIVES_WAR" );
if ( level._splitscreen )
{
setObjectiveScoreText( "allies", &"OBJECTIVES_WAR" );
setObjectiveScoreText( "axis", &"OBJECTIVES_WAR" );
}
else
{
setObjectiveScoreText( "allies", &"OBJECTIVES_WAR_SCORE" );
setObjectiveScoreText( "axis", &"OBJECTIVES_WAR_SCORE" );
}
setObjectiveHintText( "allies", &"OBJECTIVES_WAR_HINT" );
setObjectiveHintText( "axis", &"OBJECTIVES_WAR_HINT" );
level._spawnMins = ( 0, 0, 0 );
level._spawnMaxs = ( 0, 0, 0 );
maps\mp\gametypes\_spawnlogic::placeSpawnPoints( "mp_tdm_spawn_allies_start" );
maps\mp\gametypes\_spawnlogic::placeSpawnPoints( "mp_tdm_spawn_axis_start" );
maps\mp\gametypes\_spawnlogic::addSpawnPoints( "allies", "mp_tdm_spawn" );
maps\mp\gametypes\_spawnlogic::addSpawnPoints( "axis", "mp_tdm_spawn" );
level._mapCenter = maps\mp\gametypes\_spawnlogic::findBoxCenter( level._spawnMins, level._spawnMaxs );
setMapCenter( level._mapCenter );
allowed[0] = "dom"; //level.gameType;
allowed[1] = "airdrop_pallet";
maps\mp\gametypes\_gameobjects::main(allowed);
level._flagBaseFXid[ "allies" ] = loadfx( maps\mp\gametypes\_teams::getTeamFlagFX( "allies" ) );
level._flagBaseFXid[ "axis" ] = loadfx( maps\mp\gametypes\_teams::getTeamFlagFX( "axis" ) );
thread domFlags();
}
getSpawnPoint()
{
spawnteam = self.pers["team"];
if ( game["switchedsides"] )
spawnteam = getOtherTeam( spawnteam );
if ( level._inGracePeriod )
{
spawnPoints = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_tdm_spawn_" + spawnteam + "_start" );
spawnPoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_Random( spawnPoints );
}
else
{
spawnPoints = maps\mp\gametypes\_spawnlogic::getTeamSpawnPoints( spawnteam );
spawnPoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_NearTeam( spawnPoints );
}
return spawnPoint;
}
onNormalDeath( victim, attacker, lifeId )
{
score = maps\mp\gametypes\_rank::getScoreInfoValue( "kill" );
assert( isDefined( score ) );
attacker maps\mp\gametypes\_gamescore::giveTeamScoreForObjective( attacker.pers["team"], score );
if ( game["state"] == "postgame" && game["teamScores"][attacker.team] > game["teamScores"][level._otherTeam[attacker.team]] )
attacker.finalKill = true;
}
onTimeLimit()
{
if ( game["status"] == "overtime" )
{
winner = "forfeit";
}
else if ( game["teamScores"]["allies"] == game["teamScores"]["axis"] )
{
winner = "overtime";
}
else if ( game["teamScores"]["axis"] > game["teamScores"]["allies"] )
{
winner = "axis";
}
else
{
winner = "allies";
}
thread maps\mp\gametypes\_gamelogic::endGame( winner, game["strings"]["time_limit_reached"] );
}
onDeadEvent( team )
{
total_lives = 0;
foreach ( other_player in level._players )
{
if( other_player.pers["team"] == team )
{
total_lives += other_player.pers["lives"];
}
}
if( total_lives <= 0 )
{
if ( team == "allies" )
{
iPrintLn( game["strings"]["allies_eliminated"] );
logString( "team eliminated, win: opfor, allies: " + game["teamScores"]["allies"] + ", opfor: " + game["teamScores"]["axis"] );
thread maps\mp\gametypes\_gamelogic::endGame( "axis", game["strings"]["allies_eliminated"] );
}
else if ( team == "axis" )
{
iPrintLn( game["strings"]["axis_eliminated"] );
logString( "team eliminated, win: allies, allies: " + game["teamScores"]["allies"] + ", opfor: " + game["teamScores"]["axis"] );
thread maps\mp\gametypes\_gamelogic::endGame( "allies", game["strings"]["axis_eliminated"] );
}
else
{
logString( "tie, allies: " + game["teamScores"]["allies"] + ", opfor: " + game["teamScores"]["axis"] );
if ( level._teamBased )
thread maps\mp\gametypes\_gamelogic::endGame( "tie", game["strings"]["tie"] );
else
thread maps\mp\gametypes\_gamelogic::endGame( undefined, game["strings"]["tie"] );
}
}
}
domFlags()
{
level._lastStatus["allies"] = 0;
level._lastStatus["axis"] = 0;
game["flagmodels"] = [];
game["flagmodels"]["neutral"] = "prop_flag_neutral";
game["flagmodels"]["allies"] = maps\mp\gametypes\_teams::getTeamFlagModel( "allies" );
game["flagmodels"]["axis"] = maps\mp\gametypes\_teams::getTeamFlagModel( "axis" );
game["flagmodels"]["crate"] = "com_plasticcase_friendly";
precacheModel( game["flagmodels"]["neutral"] );
precacheModel( game["flagmodels"]["allies"] );
precacheModel( game["flagmodels"]["axis"] );
precacheModel( game["flagmodels"]["crate"] );
precacheShader( "waypoint_ammo_friendly" );
precacheShader( "compass_objpoint_ammo_friendly" );
precacheString( &"MP_SECURING_POSITION" );
primaryFlags = getEntArray( "flag_primary", "targetname" );
secondaryFlags = getEntArray( "flag_secondary", "targetname" );
if ( (primaryFlags.size + secondaryFlags.size) < 2 )
{
printLn( "^1Not enough domination flags found in level!" );
maps\mp\gametypes\_callbacksetup::AbortLevel();
return;
}
level._flags = [];
for ( index = 0; index < primaryFlags.size; index++ )
level._flags[level._flags.size] = primaryFlags[index];
for ( index = 0; index < secondaryFlags.size; index++ )
level._flags[level._flags.size] = secondaryFlags[index];
level._domFlags = [];
for ( index = 0; index < level._flags.size; index++ )
{
trigger = level._flags[index];
if ( isDefined( trigger.target ) )
{
visuals[0] = getEnt( trigger.target, "targetname" );
}
else
{
visuals[0] = spawn( "script_model", trigger.origin );
visuals[0].angles = trigger.angles;
}
visuals[0] setModel( game["flagmodels"]["neutral"] );
if( index == 2 )
{
visuals[0] setModel( game["flagmodels"]["crate"] );
}
domFlag = maps\mp\gametypes\_gameobjects::createUseObject( "neutral", trigger, visuals, (0,0,100) );
domFlag maps\mp\gametypes\_gameobjects::allowUse( "any" );
domFlag maps\mp\gametypes\_gameobjects::setUseTime( 10.0 );
domFlag maps\mp\gametypes\_gameobjects::setUseText( &"MP_SECURING_POSITION" );
label = domFlag maps\mp\gametypes\_gameobjects::getLabel();
domFlag.label = label;
printLn( "Flag Label: " + label );
domFlag maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", "waypoint_defend" + label );
domFlag maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", "waypoint_defend" + label );
domFlag maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", "waypoint_captureneutral" + label );
domFlag maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", "waypoint_captureneutral" + label );
domFlag maps\mp\gametypes\_gameobjects::setVisibleTeam( "any" );
if( index == 2 )
{
domFlag maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", "compass_objpoint_ammo_friendly" );
domFlag maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", "waypoint_ammo_friendly" );
domFlag.onUse = ::onUseMiddle;
domFlag.onBeginUse = ::onBeginUse;
domFlag.onUseUpdate = ::onUseUpdate;
domFlag.onEndUse = ::onEndUse;
}
else
{
domFlag.onUse = ::onUse;
domFlag.onBeginUse = ::onBeginUse;
domFlag.onUseUpdate = ::onUseUpdate;
domFlag.onEndUse = ::onEndUse;
}
traceStart = visuals[0].origin + (0,0,32);
traceEnd = visuals[0].origin + (0,0,-32);
trace = bulletTrace( traceStart, traceEnd, false, undefined );
upangles = vectorToAngles( trace["normal"] );
domFlag.baseeffectforward = anglesToForward( upangles );
domFlag.baseeffectright = anglesToRight( upangles );
domFlag.baseeffectpos = trace["position"];
// legacy spawn code support
level._flags[index].useObj = domFlag;
level._flags[index].adjflags = [];
level._flags[index].nearbyspawns = [];
domFlag.levelFlag = level._flags[index];
level._domFlags[level._domFlags.size] = domFlag;
}
// level.bestSpawnFlag is used as a last resort when the enemy holds all flags.
// level.bestSpawnFlag = [];
// level.bestSpawnFlag[ "allies" ] = getUnownedFlagNearestStart( "allies", undefined );
// level.bestSpawnFlag[ "axis" ] = getUnownedFlagNearestStart( "axis", level.bestSpawnFlag[ "allies" ] );
// flagSetup();
}
getUnownedFlagNearestStart( team, excludeFlag )
{
best = undefined;
bestdistsq = undefined;
for ( i = 0; i < level._flags.size; i++ )
{
flag = level._flags[i];
if ( flag getFlagTeam() != "neutral" )
continue;
distsq = distanceSquared( flag.origin, level._startPos[team] );
if ( (!isDefined( excludeFlag ) || flag != excludeFlag) && (!isdefined( best ) || distsq < bestdistsq) )
{
bestdistsq = distsq;
best = flag;
}
}
return best;
}
onBeginUse( player )
{
ownerTeam = self maps\mp\gametypes\_gameobjects::getOwnerTeam();
self.didStatusNotify = false;
if ( ownerTeam == "neutral" )
{
statusDialog( "securing"+self.label, player.pers["team"] );
self.objPoints[player.pers["team"]] thread maps\mp\gametypes\_objpoints::startFlashing();
return;
}
if ( ownerTeam == "allies" )
otherTeam = "axis";
else
otherTeam = "allies";
self.objPoints["allies"] thread maps\mp\gametypes\_objpoints::startFlashing();
self.objPoints["axis"] thread maps\mp\gametypes\_objpoints::startFlashing();
}
onUseUpdate( team, progress, change )
{
if ( progress > 0.05 && change && !self.didStatusNotify )
{
ownerTeam = self maps\mp\gametypes\_gameobjects::getOwnerTeam();
if ( ownerTeam == "neutral" )
{
statusDialog( "securing"+self.label, team );
}
else
{
statusDialog( "losing"+self.label, ownerTeam );
statusDialog( "securing"+self.label, team );
}
self.didStatusNotify = true;
}
}
statusDialog( dialog, team, forceDialog )
{
time = getTime();
if ( getTime() < level._lastStatus[team] + 5000 && (!isDefined( forceDialog ) || !forceDialog) )
return;
thread delayedLeaderDialog( dialog, team );
level._lastStatus[team] = getTime();
}
onEndUse( team, player, success )
{
self.objPoints["allies"] thread maps\mp\gametypes\_objpoints::stopFlashing();
self.objPoints["axis"] thread maps\mp\gametypes\_objpoints::stopFlashing();
}
resetFlagBaseEffect()
{
if ( isdefined( self.baseeffect ) )
self.baseeffect delete();
team = self maps\mp\gametypes\_gameobjects::getOwnerTeam();
if ( team != "axis" && team != "allies" )
return;
fxid = level._flagBaseFXid[ team ];
self.baseeffect = spawnFx( fxid, self.baseeffectpos, self.baseeffectforward, self.baseeffectright );
triggerFx( self.baseeffect );
}
onUse( player )
{
// return straight away if we are doing this too quickly
// I think this is a side affect of allowing you to capture a flag that is owned by your team already...
if( isDefined( self.captureTime ) && getTime() < self.captureTime + 3000 )
{
return;
}
team = player.pers["team"];
oldTeam = self maps\mp\gametypes\_gameobjects::getOwnerTeam();
label = self maps\mp\gametypes\_gameobjects::getLabel();
player.pers["lives"] = player.pers["lives"] + 1;
printLn( "Player " + player.name + "got another set of lives, teammates get 1 more! lives=" + player.pers["lives"] );
println( "My Team Lives" );
foreach ( other_player in level._players )
{
if( other_player.pers["team"] == player.pers["team"] )
{
println( other_player.name + " has " + other_player.pers["lives"] + " lives" );
other_player.pers["lives"] = other_player.pers["lives"] + 1;
if( !isAlive( other_player ))
{
// if the player went from 0 lives (dead) to 1 life, then we should spawn them a new client
if ( isValidClass( other_player.class ) )
{
println( "Now has " + other_player.pers["lives"] + " lives! Respawning" );
other_player thread maps\mp\gametypes\_playerlogic::spawnClient();
}
}
}
}
//player logString( "flag captured: " + self.label );
self.captureTime = getTime();
self maps\mp\gametypes\_gameobjects::setOwnerTeam( team );
// self maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", "waypoint_capture" + label );
// self maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", "waypoint_capture" + label );
self.visuals[0] setModel( game["flagmodels"][team] );
self resetFlagBaseEffect();
level._useStartSpawns = false;
assert( team != "neutral" );
if ( oldTeam == "neutral" )
{
otherTeam = getOtherTeam( team );
thread printAndSoundOnEveryone( team, otherTeam, undefined, undefined, "mp_war_objective_taken", undefined, player );
statusDialog( "secured"+self.label, team, true );
statusDialog( "enemy_has"+self.label, otherTeam, true );
}
else
{
thread printAndSoundOnEveryone( team, oldTeam, undefined, undefined, "mp_war_objective_taken", "mp_war_objective_lost", player );
// thread delayedLeaderDialogBothTeams( "obj_lost", oldTeam, "obj_taken", team );
if ( getTeamFlagCount( team ) == level._flags.size )
{
statusDialog( "secure_all", team );
statusDialog( "lost_all", oldTeam );
}
else
{
statusDialog( "secured"+self.label, team, true );
statusDialog( "lost"+self.label, oldTeam, true );
}
level._bestSpawnFlag[ oldTeam ] = self.levelFlag;
}
player notify( "objective", "captured" );
self thread giveFlagCaptureXP( self.touchList[team] );
self maps\mp\gametypes\_gameobjects::allowUse( "none" );
wait( 10 );
self maps\mp\gametypes\_gameobjects::setOwnerTeam( "neutral" );
self maps\mp\gametypes\_gameobjects::allowUse( "any" );
self.visuals[0] setModel( game["flagmodels"]["neutral"] );
}
onUseMiddle( player )
{
team = player.pers["team"];
// oldTeam = self maps\mp\gametypes\_gameobjects::getOwnerTeam();
label = self maps\mp\gametypes\_gameobjects::getLabel();
//player logString( "flag captured: " + self.label );
self.captureTime = getTime();
// self maps\mp\gametypes\_gameobjects::setOwnerTeam( team );
// self maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", "waypoint_capture" + label );
// self maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", "waypoint_capture" + label );
// self.visuals[0] setModel( game["flagmodels"][team] );
self resetFlagBaseEffect();
level._useStartSpawns = false;
streakName = "precision_airstrike";
if ( isDefined( level._killstreakFuncs[streakName] ) )
{
player maps\mp\killstreaks\_killstreaks::giveKillstreak( streakName );
}
otherTeam = getOtherTeam( team );
thread printAndSoundOnEveryone( team, otherTeam, undefined, undefined, "mp_war_objective_taken", undefined, player );
statusDialog( "secured"+self.label, team, true );
statusDialog( "enemy_has"+self.label, otherTeam, true );
player notify( "objective", "captured" );
//self thread giveFlagCaptureXP( self.touchList[team] );
self maps\mp\gametypes\_gameobjects::allowUse( "none" );
self maps\mp\gametypes\_gameobjects::disableObject();
self waitTillCanUse( 10 );
}
waitTillCanUse( time )
{
wait( time );
self maps\mp\gametypes\_gameobjects::allowUse( "any" );
self maps\mp\gametypes\_gameobjects::enableObject();
}
giveFlagCaptureXP( touchList )
{
level endon ( "game_ended" );
players = getArrayKeys( touchList );
for ( index = 0; index < players.size; index++ )
{
player = touchList[players[index]].player;
player thread maps\mp\gametypes\_hud_message::SplashNotify( "capture", maps\mp\gametypes\_rank::getScoreInfoValue( "capture" ) );
player thread updateCPM();
player thread maps\mp\gametypes\_rank::giveRankXP( "capture", maps\mp\gametypes\_rank::getScoreInfoValue( "capture" ) * player getCapXPScale() );
printLn( maps\mp\gametypes\_rank::getScoreInfoValue( "capture" ) * player getCapXPScale() );
maps\mp\gametypes\_gamescore::givePlayerScore( "capture", player );
// player incPlayerStat( "pointscaptured", 1 );
}
player = self maps\mp\gametypes\_gameobjects::getEarliestClaimPlayer();
level thread teamPlayerCardSplash( "callout_securedposition" + self.label, player );
player thread maps\mp\_matchdata::logGameEvent( "capture", player.origin );
}
delayedLeaderDialog( sound, team )
{
level endon ( "game_ended" );
wait .1;
WaitTillSlowProcessAllowed();
leaderDialog( sound, team );
}
delayedLeaderDialogBothTeams( sound1, team1, sound2, team2 )
{
level endon ( "game_ended" );
wait .1;
WaitTillSlowProcessAllowed();
leaderDialogBothTeams( sound1, team1, sound2, team2 );
}
getOwnedDomFlags()
{
domFlags = [];
foreach ( domFlag in level._domFlags )
{
if ( domFlag maps\mp\gametypes\_gameobjects::getOwnerTeam() != "neutral" && isDefined( domFlag.captureTime ) )
domFlags[domFlags.size] = domFlag;
}
return domFlags;
}
getTeamFlagCount( team )
{
score = 0;
for (i = 0; i < level._flags.size; i++)
{
if ( level._domFlags[i] maps\mp\gametypes\_gameobjects::getOwnerTeam() == team )
score++;
}
return score;
}
getFlagTeam()
{
return self.useObj maps\mp\gametypes\_gameobjects::getOwnerTeam();
}
getBoundaryFlags()
{
// get all flags which are adjacent to flags that aren't owned by the same team
bflags = [];
for (i = 0; i < level._flags.size; i++)
{
for (j = 0; j < level._flags[i].adjflags.size; j++)
{
if (level._flags[i].useObj maps\mp\gametypes\_gameobjects::getOwnerTeam() != level._flags[i].adjflags[j].useObj maps\mp\gametypes\_gameobjects::getOwnerTeam() )
{
bflags[bflags.size] = level._flags[i];
break;
}
}
}
return bflags;
}
getBoundaryFlagSpawns(team)
{
spawns = [];
bflags = getBoundaryFlags();
for (i = 0; i < bflags.size; i++)
{
if (isdefined(team) && bflags[i] getFlagTeam() != team)
continue;
for (j = 0; j < bflags[i].nearbyspawns.size; j++)
spawns[spawns.size] = bflags[i].nearbyspawns[j];
}
return spawns;
}
getSpawnsBoundingFlag( avoidflag )
{
spawns = [];
for (i = 0; i < level._flags.size; i++)
{
flag = level._flags[i];
if ( flag == avoidflag )
continue;
isbounding = false;
for (j = 0; j < flag.adjflags.size; j++)
{
if ( flag.adjflags[j] == avoidflag )
{
isbounding = true;
break;
}
}
if ( !isbounding )
continue;
for (j = 0; j < flag.nearbyspawns.size; j++)
spawns[spawns.size] = flag.nearbyspawns[j];
}
return spawns;
}
// gets an array of all spawnpoints which are near flags that are
// owned by the given team, or that are adjacent to flags owned by the given team.
getOwnedAndBoundingFlagSpawns(team)
{
spawns = [];
for (i = 0; i < level._flags.size; i++)
{
if ( level._flags[i] getFlagTeam() == team )
{
// add spawns near this flag
for (s = 0; s < level._flags[i].nearbyspawns.size; s++)
spawns[spawns.size] = level._flags[i].nearbyspawns[s];
}
else
{
for (j = 0; j < level._flags[i].adjflags.size; j++)
{
if ( level._flags[i].adjflags[j] getFlagTeam() == team )
{
// add spawns near this flag
for (s = 0; s < level._flags[i].nearbyspawns.size; s++)
spawns[spawns.size] = level._flags[i].nearbyspawns[s];
break;
}
}
}
}
return spawns;
}
// gets an array of all spawnpoints which are near flags that are
// owned by the given team
getOwnedFlagSpawns(team)
{
spawns = [];
for (i = 0; i < level._flags.size; i++)
{
if ( level._flags[i] getFlagTeam() == team )
{
// add spawns near this flag
for (s = 0; s < level._flags[i].nearbyspawns.size; s++)
spawns[spawns.size] = level._flags[i].nearbyspawns[s];
}
}
return spawns;
}
flagSetup()
{
maperrors = [];
descriptorsByLinkname = [];
// (find each flag_descriptor object)
descriptors = getentarray("flag_descriptor", "targetname");
flags = level._flags;
for (i = 0; i < level._domFlags.size; i++)
{
closestdist = undefined;
closestdesc = undefined;
for (j = 0; j < descriptors.size; j++)
{
dist = distance(flags[i].origin, descriptors[j].origin);
if (!isdefined(closestdist) || dist < closestdist) {
closestdist = dist;
closestdesc = descriptors[j];
}
}
if (!isdefined(closestdesc)) {
maperrors[maperrors.size] = "there is no flag_descriptor in the map! see explanation in dom.gsc";
break;
}
if (isdefined(closestdesc.flag)) {
maperrors[maperrors.size] = "flag_descriptor with script_linkname \"" + closestdesc.script_linkname + "\" is nearby more than one flag; is there a unique descriptor near each flag?";
continue;
}
flags[i].descriptor = closestdesc;
closestdesc.flag = flags[i];
descriptorsByLinkname[closestdesc.script_linkname] = closestdesc;
}
if (maperrors.size == 0)
{
// find adjacent flags
for (i = 0; i < flags.size; i++)
{
if (isdefined(flags[i].descriptor.script_linkto))
adjdescs = strtok(flags[i].descriptor.script_linkto, " ");
else
adjdescs = [];
for (j = 0; j < adjdescs.size; j++)
{
otherdesc = descriptorsByLinkname[adjdescs[j]];
if (!isdefined(otherdesc) || otherdesc.targetname != "flag_descriptor") {
maperrors[maperrors.size] = "flag_descriptor with script_linkname \"" + flags[i].descriptor.script_linkname + "\" linked to \"" + adjdescs[j] + "\" which does not exist as a script_linkname of any other entity with a targetname of flag_descriptor (or, if it does, that flag_descriptor has not been assigned to a flag)";
continue;
}
adjflag = otherdesc.flag;
if (adjflag == flags[i]) {
maperrors[maperrors.size] = "flag_descriptor with script_linkname \"" + flags[i].descriptor.script_linkname + "\" linked to itself";
continue;
}
flags[i].adjflags[flags[i].adjflags.size] = adjflag;
}
}
}
// assign each spawnpoint to nearest flag
spawnpoints = maps\mp\gametypes\_spawnlogic::getSpawnpointArray( "mp_dom_spawn" );
for (i = 0; i < spawnpoints.size; i++)
{
if (isdefined(spawnpoints[i].script_linkto)) {
desc = descriptorsByLinkname[spawnpoints[i].script_linkto];
if (!isdefined(desc) || desc.targetname != "flag_descriptor") {
maperrors[maperrors.size] = "Spawnpoint at " + spawnpoints[i].origin + "\" linked to \"" + spawnpoints[i].script_linkto + "\" which does not exist as a script_linkname of any entity with a targetname of flag_descriptor (or, if it does, that flag_descriptor has not been assigned to a flag)";
continue;
}
nearestflag = desc.flag;
}
else {
nearestflag = undefined;
nearestdist = undefined;
for (j = 0; j < flags.size; j++)
{
dist = distancesquared(flags[j].origin, spawnpoints[i].origin);
if (!isdefined(nearestflag) || dist < nearestdist)
{
nearestflag = flags[j];
nearestdist = dist;
}
}
}
nearestflag.nearbyspawns[nearestflag.nearbyspawns.size] = spawnpoints[i];
}
if (maperrors.size > 0)
{
println("^1------------ Map Errors ------------");
for(i = 0; i < maperrors.size; i++)
println(maperrors[i]);
println("^1------------------------------------");
error("Map errors. See above");
maps\mp\gametypes\_callbacksetup::AbortLevel();
return;
}
}
onSpawnPlayer()
{
}
updateCPM()
{
if ( !isDefined( self.CPM ) )
{
self.numCaps = 0;
self.CPM = 0;
}
self.numCaps++;
if ( getMinutesPassed() < 1 )
return;
self.CPM = self.numCaps / getMinutesPassed();
}
getCapXPScale()
{
if ( self.CPM < 4 )
return 1;
else
return 0.25;
}

685
maps/mp/gametypes/merc.gsc Normal file
View File

@ -0,0 +1,685 @@
#include maps\mp\_utility;
#include maps\mp\gametypes\_hud_util;
#include common_scripts\utility;
/*
Mercenary Timetrial
Objective: Hit as many of the enemy targets as possible while avoiding civilian targets.
Map ends: When the time limit is reached or all the targets are hit.
Respawning: No wait / Near teammates
Level requirementss
------------------
Spawnpoints:
classname mp_dm_spawn
All players spawn from these. The spawnpoint chosen is dependent on the current locations of teammates and enemies
at the time of spawn. Players generally spawn behind their teammates relative to the direction of enemies.
Spectator Spawnpoints:
classname mp_global_intermission
Spectators spawn from these and intermission is viewed from these positions.
Atleast one is required, any more and they are randomly chosen between.
*/
/*QUAKED mp_dm_spawn (1.0 0.5 0.0) (-16 -16 0) (16 16 72)
Players spawn away from enemies at one of these positions.*/
main()
{
if(getdvar("mapname") == "mp_background")
return;
maps\mp\gametypes\_globallogic::init();
maps\mp\gametypes\_callbacksetup::SetupCallbacks();
maps\mp\gametypes\_globallogic::SetupCallbacks();
registerRoundSwitchDvar( level._gameType, 0, 0, 9 );
registerTimeLimitDvar( level._gameType, 2, 0, 2 );
registerScoreLimitDvar( level._gameType, 500, 0, 5000 );
registerRoundLimitDvar( level._gameType, 1, 0, 10 );
registerWinLimitDvar( level._gameType, 1, 0, 10 );
registerRoundSwitchDvar( level._gameType, 3, 0, 30 );
registerNumLivesDvar( level._gameType, 0, 0, 10 );
registerHalfTimeDvar( level._gameType, 0, 0, 1 );
level._teamBased = false;
level._onStartGameType = ::onStartGameType;
level._getSpawnPoint = ::getSpawnPoint;
level._onSpawnPlayer = ::onSpawnPlayer;
level._onPlayerKilled = ::onPlayerKilled;
level._onNormalDeath = ::onNormalDeath;
// Turn off killstreaks
setDvar( "scr_game_hardpoints", "0" );
game["dialog"]["gametype"] = "freeforall";
if ( getDvarInt( "g_hardcore" ) )
game["dialog"]["gametype"] = "hc_" + game["dialog"]["gametype"];
else if ( getDvarInt( "camera_thirdPerson" ) )
game["dialog"]["gametype"] = "thirdp_" + game["dialog"]["gametype"];
else if ( getDvarInt( "scr_diehard" ) )
game["dialog"]["gametype"] = "dh_" + game["dialog"]["gametype"];
else if (getDvarInt( "scr_" + level._gameType + "_promode" ) )
game["dialog"]["gametype"] = game["dialog"]["gametype"] + "_pro";
game["strings"]["overtime_hint"] = &"MP_FIRST_BLOOD";
precacheshader( "nx_hud_merc_frame" );
}
onStartGameType()
{
setClientNameMode("auto_change");
setObjectiveText( "allies", &"OBJECTIVES_WAR" );
setObjectiveText( "axis", &"OBJECTIVES_WAR" );
if ( !isdefined( game["switchedsides"] ) )
game["switchedsides"] = false;
if ( game["switchedsides"] )
{
oldAttackers = game["attackers"];
oldDefenders = game["defenders"];
game["attackers"] = oldDefenders;
game["defenders"] = oldAttackers;
}
if ( level._splitscreen )
{
setObjectiveScoreText( "allies", &"OBJECTIVES_WAR" );
setObjectiveScoreText( "axis", &"OBJECTIVES_WAR" );
}
else
{
setObjectiveScoreText( "allies", &"OBJECTIVES_WAR_SCORE" );
setObjectiveScoreText( "axis", &"OBJECTIVES_WAR_SCORE" );
}
setObjectiveHintText( "allies", &"OBJECTIVES_WAR_HINT" );
setObjectiveHintText( "axis", &"OBJECTIVES_WAR_HINT" );
level._spawnMins = ( 0, 0, 0 );
level._spawnMaxs = ( 0, 0, 0 );
maps\mp\gametypes\_spawnlogic::addSpawnPoints( "allies", "mp_dm_spawn" );
maps\mp\gametypes\_spawnlogic::addSpawnPoints( "axis", "mp_dm_spawn" );
level._mapCenter = maps\mp\gametypes\_spawnlogic::findBoxCenter( level._spawnMins, level._spawnMaxs );
setMapCenter( level._mapCenter );
allowed[0] = level._gameType;
allowed[1] = "airdrop_pallet";
maps\mp\gametypes\_gameobjects::main(allowed);
maps\mp\gametypes\_rank::registerScoreInfo( "kill", 0 );
//maps\mp\gametypes\_rank::registerScoreInfo( "headshot", 0 );
//maps\mp\gametypes\_rank::registerScoreInfo( "assist", 0 );
//maps\mp\gametypes\_rank::registerScoreInfo( "suicide", 0 );
//maps\mp\gametypes\_rank::registerScoreInfo( "teamkill", 0 );
level._QuickMessageToAll = true;
// Merc mode object and rules setup
thread merc_mode_init();
}
getSpawnPoint()
{
spawnPoints = maps\mp\gametypes\_spawnlogic::getTeamSpawnPoints( self.pers["team"] );
spawnPoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_DM( spawnPoints );
return spawnPoint;
}
onNormalDeath( victim, attacker, lifeId )
{
// Register a score event
score = maps\mp\gametypes\_rank::getScoreInfoValue( "kill" );
assert( isDefined( score ) );
attacker maps\mp\gametypes\_gamescore::giveTeamScoreForObjective( attacker.pers["team"], score );
if ( game["state"] == "postgame" && game["teamScores"][attacker.team] > game["teamScores"][level._otherTeam[attacker.team]] )
attacker.finalKill = true;
}
onSpawnPlayer()
{
println( "onSpawnPlayer() player = " + self.name );
self merc_player_init();
self thread merc_create_HUD();
}
// A player has died
onPlayerKilled(eInflictor, attacker, iDamage, sMeansOfDeath, sWeapon, vDir, sHitLoc, psOffsetTime, deathAnimDuration, killId)
{
self thread merc_destroy_HUD();
// Clear attackers multiplier
if( attacker != self )
{
// Multiplier drops by 1 when you kill a player
if( attacker.mult > 1 )
{
attacker.mult -= 1;
}
attacker thread merc_update_HUD();
}
}
//=================================================================================================
//=================================================================================================
// Does general initialization and setup
merc_mode_init()
{
// Make sure targets exist in the map
if ( !isDefined( getentarray( "target_enemy", "targetname" ) ) )
{
iprintlnbold( "No Merc Mode targets were found in the map" );
}
level.targets_total = 0;
level.targets_remaining = 0;
level.mult_curve = [ 1.0, 1.0, 2.0, 2.8, 3.4, 3.9, 4.2, 4.4, 4.6, 4.8, 5.0 ];
// Target values
//level.target_normal.value = 100;
// Merc mode target and scoring logic
thread merc_mode_logic();
}
// Sets up data for each player in the game
merc_player_init()
{
// If this is the first time the script is run,
// initialize targets_hit
if( !isDefined( self.targets_hit ))
{
self.targets_hit = 0;
}
// If this is the first time the script is run,
// initialize targets_hit
if( !isDefined( self.score ))
{
self.score = 0;
//maps\mp\gametypes\_gamescore::_setPlayerScore( self, 0 );
}
// Reset multiplier to 1
self.mult = 1;
}
//=================================================================================================
//=================================================================================================
merc_mode_logic()
{
// Get a list of all the moving target start points
//level.target_rail_start_points = getentarray( "target_rail_start_point", "targetname" );
// Run the target think script on all the enemy targets
targets = getentarray( "target_enemy", "targetname" );
foreach( target in targets )
{
target thread target_think( "enemy" );
level.targets_total++;
level.targets_remaining++;
}
// Run the target think script on all the small round targets
targets = getentarray( "target_enemy_small", "targetname" );
foreach( target in targets )
{
target thread target_think( "enemy_small" );
level.targets_total++;
level.targets_remaining++;
}
// Run the target think script on all the friendly targets
targets = getentarray( "target_friendly", "targetname" );
foreach( target in targets )
{
target thread target_think( "friendly" );
// Civilians dont count towards the total
//level.targets_total++;
}
}
// Spawned on all the targets at map init
// Each popup target is made of multiple brushes and each brush targets the origin node
target_think( targetType )
{
while( true )
{
// Get this entity origin. Self must have a target key, and the target must have a targetName
self.orgEnt = getEnt( self.target, "targetname" );
// Assert if no origin node found
//assert( isdefined( self.orgEnt ) );
// Attach the geo to this origin node
self linkto ( self.orgEnt );
// No shadows
//self DontCastShadows();
// Hide the aim assist squares
aim_assist_target = getEnt( self.orgEnt.target, "targetname" );
aim_assist_target hide();
aim_assist_target notsolid();
// No collision on dead target
self solid();
// Make this target shootable
self setCanDamage( true );
/*------------------------------
SETUP LATERALLY MOVING TARGETS
--------------------------------*/
/*
// Only do this logic if object has script_parameters, and it is set to use_rail
if ( ( isdefined( self.script_parameters ) ) && ( self.script_parameters == "use_rail" ) )
{
// Links the aim assist block to the target, so they move together
//aim_assist_target linkTo( self );
// Grab closest rail start to this target
self.lateralStartPosition = getclosest( self.orgEnt.origin, level.target_rail_start_points, 10 );
assert( isdefined( self.lateralStartPosition ) );
assert( isdefined( self.lateralStartPosition.target ) );
// Set an end pos. The rail should have an end linked to its start
self.lateralEndPosition = getent( self.lateralStartPosition.target, "targetname" );
assert( isdefined( self.lateralEndPosition ) );
// Setup an array of movement positions
self.lateralMovementOrgs = [];
self.lateralMovementOrgs[ 0 ] = self.lateralStartPosition;
self.lateralMovementOrgs[ 1 ] = self.lateralEndPosition;
dist = distance( self.lateralMovementOrgs[ 0 ].origin, self.lateralMovementOrgs[ 1 ].origin );
self.lateralMoveTime = ( dist / 22 );
// Safety check the movement points
foreach( org in self.lateralMovementOrgs )
{
assertex( org.code_classname == "script_origin", "Pop up targets that move laterally need to be targeting 2 script_origins" );
}
// Randomize the target position
self target_lateral_reset_random();
}
// Movers start moving
if ( isdefined( self.lateralStartPosition ) )
{
self thread target_lateral_movement();
}
*/
/*-----------------------
WAIT FOR TARGET DAMAGE
-------------------------*/
while ( true )
{
// Waits for damage
self waittill ( "damage", amount, attacker, direction_vec, point, type );
// Play some sound
//self playSound( "nx_target_metal_hit" );
if( isDefined( attacker ))
{
// Show hit marker
if( isAlive( attacker ))
{
level._func[ "damagefeedback" ] = maps\mp\gametypes\_damagefeedback::updateDamageFeedback;
attacker maps\mp\gametypes\_damagefeedback::updateDamageFeedback( "" );
}
println( "attacker = " + attacker.name );
// Increase number of targets hit
if ( targetType == "friendly" )
{
//iprintlnbold( "YOU SHOT A CIVILIAN" );
attacker.score += int( -300.0 * merc_get_multiplier( attacker ));
//score = maps\mp\gametypes\_gamescore::_getPlayerScore( attacker );
//maps\mp\gametypes\_gamescore::_setPlayerScore( attacker, score + ( -100 * attacker.mult ));
attacker.mult = 1;
attacker thread merc_update_HUD();
//thread maps\mp\gametypes\_gamescore::sendUpdatedDMScores();
self playSound( "nx_target_mistake_buzzer" );
}
else if( targetType == "enemy_small" )
{
attacker.targets_hit++;
level.targets_remaining--;
attacker.score += int( 100.0 * merc_get_multiplier( attacker ) );
//score = maps\mp\gametypes\_gamescore::_getPlayerScore( attacker );
//maps\mp\gametypes\_gamescore::_setPlayerScore( attacker, score + ( 100 * attacker.mult ));
attacker thread merc_increase_multiplier();
attacker thread merc_update_HUD();
//thread maps\mp\gametypes\_gamescore::sendUpdatedDMScores();
self playSound( "nx_target_enemy_hit" );
}
else
{
attacker.targets_hit++;
level.targets_remaining--;
attacker.score += int( 300.0 * merc_get_multiplier( attacker ) );
//score = maps\mp\gametypes\_gamescore::_getPlayerScore( attacker );
//maps\mp\gametypes\_gamescore::_setPlayerScore( attacker, score + ( 300 * attacker.mult ));
attacker merc_increase_multiplier();
attacker thread merc_update_HUD();
//thread maps\mp\gametypes\_gamescore::sendUpdatedDMScores();
self playSound( "nx_target_enemy_hit" );
}
// Check for last target
if( level.targets_remaining <= 0 )
{
thread maps\mp\gametypes\_gamelogic::endGame( attacker, "All Targets Eliminated" );
}
break;
}
}
// No collision on dead target
self notsolid();
// Lay the target down again. Facedown targets drop facedown, contrary to physics.
if ( isdefined( self.orgEnt.script_noteworthy ) && self.orgEnt.script_noteworthy == "reverse" )
{
self.orgEnt rotatePitch( 90, 0.25 );
}
else if( isdefined( self.orgEnt.script_noteworthy ) && self.orgEnt.script_noteworthy == "sideways" )
{
self.orgEnt rotateYaw( -180, 0.5 );
}
else
{
self.orgEnt rotatePitch( -90, 0.25 );
}
self setCanDamage( false );
break;
}
}
// Increases the players multiplier up to a max of 10
merc_increase_multiplier()
{
if( self.mult < 10 )
{
self.mult += 1;
}
}
// Fetches the player's current multiplier
merc_get_multiplier( player )
{
return ( level.mult_curve[ player.mult ] );
}
//=================================================================================================
// HUD Scripts
//=================================================================================================
// Creates our proto HUD
// self = player
merc_create_HUD()
{
// Horrible hacked HUD
self.barOne = merc_hacky_hud_create_bar( -32, 108 );
self.barTwo = merc_hacky_hud_create_bar( -32, 126 );
self.barThree = merc_hacky_hud_create_bar( -32, 144 );
self.barFour = merc_hacky_hud_create_bar( -32, 162 );
//=============================================================
// Targets Hit Counter
self.counterElem = merc_hacky_hud_create_text( 12, 118, "TARGETS HIT" );
self.counter_valueElem = merc_hacky_hud_create_value( 127, 118 );
// Targets remaining counter
self.remainingElem = merc_hacky_hud_create_text( 12, 136, "REMAINING" );
self.remaining_valueElem= merc_hacky_hud_create_value( 127, 136 );
// Combo counter
self.multElem = merc_hacky_hud_create_text( 12, 154, "COMBO" );
self.mult_valueElem = merc_hacky_hud_create_value( 127, 154 );
// Score counter
self.scoreElem = merc_hacky_hud_create_text( 12, 172, "SCORE" );
self.score_valueElem = merc_hacky_hud_create_value( 127, 172 );
// Force an update now
self thread merc_update_HUD();
}
// This creates a HUD bar background for the text.
// There must be a better way to do this.
merc_hacky_hud_create_bar( xpos, ypos )
{
hudBar = createFontString( "fwmed", 1.0 );
hudBar setPoint( "TOPLEFT", undefined, xpos, ypos );
hudBar setText( "blank" );
hudBar.layer = "visor";
hudBar.shader = "nx_hud_merc_frame";
hudBar setShader( hudBar.shader, 200, 30 );
return hudBar;
}
merc_hacky_hud_create_text( xpos, ypos, text )
{
hudText = createFontString( "fwmed", 1.0 );
hudText setPoint( "TOPLEFT", undefined, xpos, ypos );
hudText setText( text );
hudText.layer = "visor";
return hudText;
}
merc_hacky_hud_create_value( xpos, ypos )
{
hudValue = createFontString( "fwmed", 1.0 );
hudValue setPoint( "TOPLEFT", undefined, xpos, ypos );
hudValue.alignX = "right";
hudValue.layer = "visor";
return hudValue;
}
// Updates the proto HUD
// self = player
merc_update_HUD()
{
if ( isDefined( self.counter_valueElem ) )
{
self.counter_valueElem setText( "" + self.targets_hit );
}
// Update the remaining targets on everyones HUD
foreach( player in level._players )
{
if ( isDefined( player.remaining_valueElem ) )
{
player.remaining_valueElem setText( "" + level.targets_remaining );
}
}
if ( isDefined( self.mult_valueElem ) )
{
multiplier = merc_get_multiplier( self );
self.mult_valueElem setText( "" + multiplier );
}
if ( isDefined( self.score_valueElem ) )
{
self.score_valueElem setText( "" + self.score );
}
}
// Cleans up our proto HUD
// self = player
merc_destroy_HUD()
{
self.barOne destroyElem();
self.barTwo destroyElem();
self.barThree destroyElem();
self.barFour destroyElem();
self.counterElem destroyElem();
self.counter_valueElem destroyElem();
self.remainingElem destroyElem();
self.remaining_valueElem destroyElem();
self.multElem destroyElem();
self.mult_valueElem destroyElem();
self.scoreElem destroyElem();
self.score_valueElem destroyElem();
}
//=================================================================================================
// Moving target scripts
//=================================================================================================
// This randomizes the mover direction
target_lateral_reset_random()
{
if ( cointoss() ) // 50/50 random func
{
self.lateralStartPosition = self.lateralMovementOrgs[ 0 ];
self.lateralEndPosition = self.lateralMovementOrgs[ 1 ];
}
else
{
self.lateralStartPosition = self.lateralMovementOrgs[ 1 ];
self.lateralEndPosition = self.lateralMovementOrgs[ 0 ];
}
// Move to the designated spot
self.orgEnt moveTo( self.lateralStartPosition.origin, .1 );
}
// This moves the mover targets back and forth
target_lateral_movement()
{
// Make a brand new script origin object
dummy = spawn( "script_origin", ( 0, 0, 0 ) );
dummy.angles = self.orgEnt.angles;
dummy.origin = self.orgEnt.origin;
self.orgEnt thread lateral_dummy_move( dummy );
// Kill dummy when player gets too close - Prevents player getting stuck in target
dummy endon( "deleted_because_player_was_too_close" );
dummy endon( "death" );
// Run the get too close thread
foreach( player in level._players )
{
dummy thread delete_when_player_too_close( player );
}
self thread dummy_delete_when_target_goes_back_down( dummy );
while ( true )
{
// Move back and forth
dummy moveTo( self.lateralEndPosition.origin, self.lateralMoveTime );
wait( self.lateralMoveTime );
dummy moveTo( self.lateralStartPosition.origin, self.lateralMoveTime );
wait( self.lateralMoveTime );
}
}
lateral_dummy_move( dummy )
{
dummy endon( "death" );
while( true )
{
wait( 0.05 );
self.origin = dummy.origin;
}
}
// A dummy object helps the target move
// Destroy it when the target is shot down
dummy_delete_when_target_goes_back_down( dummy )
{
dummy endon( "death" );
//self --> the target
self waittill( "target_going_back_down" );
dummy delete();
}
// Stop the mover when player is too close
// This is run on the lateral mover script
delete_when_player_too_close( player )
{
self endon( "death" );
dist = 128;
distSquared = dist * dist;
// Loop untill player is too close
while( true )
{
wait( .05 );
if ( distancesquared( player.origin, self.origin ) < distSquared )
break;
}
self notify( "deleted_because_player_was_too_close" );
self delete();
}
// Copied from single player _utility.gsc
getClosest( org, array, maxdist )
{
if ( !IsDefined( maxdist ) )
maxdist = 500000; // twice the size of the grid
ent = undefined;
foreach ( item in array )
{
newdist = Distance( item.origin, org );
if ( newdist >= maxdist )
continue;
maxdist = newdist;
ent = item;
}
return ent;
}

297
maps/mp/gametypes/oic.gsc Normal file
View File

@ -0,0 +1,297 @@
//****************************************************************************
// **
// Confidential - (C) Activision Publishing, Inc. 2010 **
// **
//****************************************************************************
// **
// Module: The One-In-The_Chamber game mode ported from MW3 **
// (1) Players use only one predetermined weapon. **
// (2) No class change is allowed in the game mode. **
// (3) Players have limited ammo to start the game. **
// (4) Obtaining kills will reward players with additional ammo.**
// (5) Match terminates when there is only one player left. **
// **
// **
// Created: August 23rd, 2011 - James Chen **
// **
//***************************************************************************/
#include maps\mp\_utility;
#include maps\mp\gametypes\_hud_util;
#include maps\mp\gametypes\_class;
MATCHRULES_INITIALAMMO = 1;
MATCHRULES_REWARDAMMO = 1;
NUMBER_OF_LIVES = 3;
WARNING_START_WHEN_LIFE_LEFT = 2;
WEAPON_NAME = "coltanaconda_mp";
main()
{
precachestring( &"SPLASHES_SURVIVOR" );
precachestring( &"SPLASHES_OIC_LAST_LIFE" );
precachestring( &"SPLASHES_OIC_LIFE_LEFT" );
maps\mp\gametypes\_globallogic::init();
maps\mp\gametypes\_callbacksetup::SetupCallbacks();
maps\mp\gametypes\_globallogic::SetupCallbacks();
/* if ( isUsingMatchRulesData() )
{
// set common values
setCommonRulesFromMatchRulesData( true );
// set everything else (private match options, default .cfg file values, and what normally is registered in the 'else' below)
level.matchRules_initialAmmo = GetMatchRulesData( "oicData", "initialAmmoCount" );
level.matchRules_rewardAmmo = GetMatchRulesData( "oicData", "killRewardAmmoCount" );
SetDvar( "scr_oic_winlimit", 1 );
registerWinLimitDvar( "oic", 1 );
SetDvar( "scr_oic_roundlimit", 1 );
registerRoundLimitDvar( "oic", 1 );
SetDvar( "scr_oic_halftime", 0 );
registerHalfTimeDvar( "oic", 0 );
SetDvar( "scr_oic_promode", 0 );
}
else
{ */
registerTimeLimitDvar( level._gameType, 10, 0, 1440 );
registerScoreLimitDvar( level._gameType, 0, 0, 1000 );
registerRoundLimitDvar( level._gameType, 1, 0, 10 );
registerWinLimitDvar( level._gameType, 1, 0, 10 );
registerNumLivesDvar( level._gameType, NUMBER_OF_LIVES, 0, 10 );
registerHalfTimeDvar( level._gameType, 0, 0, 1 );
// }
level._teamBased = false;
level._doPrematch = true;
level._killstreakRewards = false;
level._onStartGameType = ::onStartGameType;
level._onSpawnPlayer = ::onSpawnPlayer;
level._getSpawnPoint = ::getSpawnPoint;
level._onPlayerKilled = ::onPlayerKilled;
level._modifyPlayerDamage = ::modifyPlayerDamage;
level._blockWeaponDrops = true;
level._blockRechargeablePerk = true;
level._blockClassChange = true;
level._overridePlayerModel = true;
level._disableWarSuit = true;
setDvar( "scr_game_hardpoints", "0" );
setDvar( "scr_game_perks", "0" );
setDvar( "scr_player_maxhealth", "30" );
game["dialog"]["gametype"] = "oic";
}
onStartGameType()
{
setClientNameMode("auto_change");
setObjectiveText( "allies", &"OBJECTIVES_OIC" );
setObjectiveText( "axis", &"OBJECTIVES_OIC" );
if ( level._splitscreen )
{
setObjectiveScoreText( "allies", &"OBJECTIVES_OIC" );
setObjectiveScoreText( "axis", &"OBJECTIVES_OIC" );
}
else
{
setObjectiveScoreText( "allies", &"OBJECTIVES_OIC_SCORE" );
setObjectiveScoreText( "axis", &"OBJECTIVES_OIC_SCORE" );
}
setObjectiveHintText( "allies", &"OBJECTIVES_OIC_HINT" );
setObjectiveHintText( "axis", &"OBJECTIVES_OIC_HINT" );
level._spawnMins = ( 0, 0, 0 );
level._spawnMaxs = ( 0, 0, 0 );
maps\mp\gametypes\_spawnlogic::addSpawnPoints( "allies", "mp_dm_spawn" );
maps\mp\gametypes\_spawnlogic::addSpawnPoints( "axis", "mp_dm_spawn" );
level._mapCenter = maps\mp\gametypes\_spawnlogic::findBoxCenter( level._spawnMins, level._spawnMaxs );
setMapCenter( level._mapCenter );
allowed[0] = "oic";
maps\mp\gametypes\_gameobjects::main(allowed);
maps\mp\gametypes\_rank::registerScoreInfo( "kill", 100 );
maps\mp\gametypes\_rank::registerScoreInfo( "headshot", 0 );
maps\mp\gametypes\_rank::registerScoreInfo( "assist", 0 );
maps\mp\gametypes\_rank::registerScoreInfo( "suicide", 0 );
maps\mp\gametypes\_rank::registerScoreInfo( "teamkill", 0 );
maps\mp\gametypes\_rank::registerScoreInfo( "survive", 25 );
level._QuickMessageToAll = true;
level._blockWeaponDrops = true;
level thread watchElimination();
}
getSpawnPoint()
{
spawnPoints = maps\mp\gametypes\_spawnlogic::getTeamSpawnPoints( self.pers["team"] );
spawnPoint = maps\mp\gametypes\_spawnlogic::getSpawnpoint_DM( spawnPoints );
return spawnPoint;
}
onSpawnPlayer()
{
// award ammo that the player might have been waiting to receive on death
if ( isDefined( self.oic_rewardAmmo ) && self.oic_rewardAmmo )
self giveAmmo();
else
self.oic_rewardAmmo = 0;
self thread waitLoadoutDone();
level notify ( "spawned_player" );
}
waitLoadoutDone()
{
level endon( "game_ended" );
self endon( "disconnect" );
level waittill( "player_spawned" );
if ( !isDefined( self.oic_life_remaining ))
{
self.oic_life_remaining = NUMBER_OF_LIVES;
}
else
{
self.oic_life_remaining -= 1;
}
if ( self.oic_life_remaining == 1 )
{
self thread maps\mp\gametypes\_rank::xpEventPopup( &"SPLASHES_OIC_LAST_LIFE" );
}
else if ( self.oic_life_remaining <= WARNING_START_WHEN_LIFE_LEFT )
{
self iPrintLnBold ( &"SPLASHES_OIC_LIFE_LEFT", self.oic_life_remaining );
}
// clear temp data
self takeAllWeapons();
// give gun
_giveWeapon( WEAPON_NAME );
self switchToWeapon( WEAPON_NAME );
self setSpawnWeapon( WEAPON_NAME );
primaryTokens = strtok( WEAPON_NAME, "_" );
self.pers["primaryWeapon"] = primaryTokens[0];
self.primaryWeapon = WEAPON_NAME;
// give ammo
clipAmmo = MATCHRULES_INITIALAMMO;
if( isDefined( self.pers["clip_ammo"] ) )
{
clipAmmo = self.pers["clip_ammo"];
self.pers["clip_ammo"] = undefined;
}
self SetWeaponAmmoClip( self.primaryWeapon, clipAmmo );
stockAmmo = 0;
if( isDefined( self.pers["stock_ammo"] ) )
{
stockAmmo = self.pers["stock_ammo"];
self.pers["stock_ammo"] = undefined;
}
self SetWeaponAmmoStock( self.primaryWeapon, stockAmmo );
// give knife
//self SetOffhandPrimaryClass( "throwingknife" );
//_giveWeapon( "throwingknife_mp" );
}
modifyPlayerDamage( victim, eAttacker, iDamage, sMeansOfDeath, sWeapon, vPoint, vDir, sHitLoc )
{
if ( ( sMeansOfDeath == "MOD_PISTOL_BULLET" ) || ( sMeansOfDeath == "MOD_RIFLE_BULLET" ) || ( sMeansOfDeath == "MOD_HEAD_SHOT" ) )
iDamage = 999;
return iDamage;
}
onPlayerKilled( eInflictor, attacker, iDamage, sMeansOfDeath, sWeapon, vDir, sHitLoc, psOffsetTime, deathAnimDuration, lifeId )
{
if ( isDefined( attacker ) && isPlayer( attacker ) && self != attacker )
{
attacker.oic_rewardAmmo += MATCHRULES_REWARDAMMO;
if ( self attackButtonPressed() )
attacker thread waitGiveAmmo();
else
attacker giveAmmo();
}
}
waitGiveAmmo()
{
self endon( "death" );
self endon( "disconnect" );
level endon( "game_ended" );
self notify( "oic_waitGiveAmmo" );
self endon( "oic_waitGiveAmmo" );
while( self attackButtonPressed() )
wait( 0.05 );
giveAmmo();
}
giveAmmo()
{
currentWeapon = self getCurrentWeapon();
clipAmmo = self GetWeaponAmmoClip( currentWeapon );
self SetWeaponAmmoClip( currentWeapon, clipAmmo + self.oic_rewardAmmo );
self playLocalSound( "scavenger_pack_pickup" );
self.oic_rewardAmmo = 0;
}
watchElimination()
{
level endon( "game_ended" );
for ( ;; )
{
level waittill( "player_eliminated", player );
thread teamPlayerCardSplash( "callout_eliminated", player );
remainingPlayers = [];
foreach ( player in level._players )
{
if ( IsDefined( player ) && ( IsAlive( player ) || player.pers["lives"] > 0 ) )
{
remainingPlayers[remainingPlayers.size] = player;
player thread maps\mp\gametypes\_rank::xpEventPopup( &"SPLASHES_SURVIVOR" );
maps\mp\gametypes\_gamescore::givePlayerScore( "survive", player, undefined, true );
}
}
if ( remainingPlayers.size > 2 )
{
playSoundOnPlayers( "mp_enemy_obj_captured" );
}
else if ( remainingPlayers.size == 2 )
{
playSoundOnPlayers( "mp_obj_captured" );
remainingPlayers[0] thread maps\mp\gametypes\_hud_message::playerCardSplashNotify( "callout_lastenemyalive", remainingPlayers[1] );
remainingPlayers[1] thread maps\mp\gametypes\_hud_message::playerCardSplashNotify( "callout_lastenemyalive", remainingPlayers[0] );
}
}
}