mirror of
https://github.com/reaaLx/nx1-gsc-dump.git
synced 2025-04-22 17:15:48 +00:00
792 lines
22 KiB
Plaintext
792 lines
22 KiB
Plaintext
#include maps\mp\_utility;
|
|
#include maps\mp\gametypes\_hud_util;
|
|
#include common_scripts\utility;
|
|
|
|
INTEL_OFFSET = (0, 0, 24);
|
|
INTEL_OFFSET_TOP = (0, 0, 36);
|
|
INTEL_ICON_PULSE_SCALE = 1.2;
|
|
INTEL_ICON_PULSE_WAIT_SEC = 5;
|
|
INTEL_ICON_COLOR = (1,1,1);
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
init()
|
|
{
|
|
if( getDvarInt( "prototype_intel_enabled" ) == 1 )
|
|
{
|
|
println( "Intel enabled" );
|
|
|
|
intelGamePercentage = getDvarInt( "prototype_intel_percentage" );
|
|
|
|
if( intelGamePercentage >= randomInt( 100 ))
|
|
{
|
|
println( "Intel: This will be an intel game" );
|
|
initIntel();
|
|
level thread onPlayerConnect();
|
|
|
|
level thread addIntelToGame();
|
|
|
|
//tempGetStarted();
|
|
}
|
|
else
|
|
{
|
|
println( "Intel: This is not going to be an intel game" );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
println( "Intel not inited ", getDvarInt( "prototype_intel_enabled" ));
|
|
}
|
|
}
|
|
|
|
tempGetStarted()
|
|
{
|
|
level waittill("connected", player);
|
|
|
|
player thread tempGetStartedSpawned();
|
|
}
|
|
|
|
tempGetStartedSpawned()
|
|
{
|
|
wait 3;
|
|
// setup the team, close the menu, then set our class and wait for our player to spawn
|
|
self [[level._onTeamSelection]]( "allies" );
|
|
self closepopupMenu();
|
|
self closeInGameMenu();
|
|
self.selectedClass = true;
|
|
self [[level._class]]("class0");
|
|
players = getentarray("player", "classname");
|
|
while( players.size == 0 )
|
|
{
|
|
wait 1;
|
|
players = getentarray("player", "classname");
|
|
}
|
|
}
|
|
|
|
intelDebugging()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
initIntel()
|
|
{
|
|
// setup the models and stuff we need for intel
|
|
//precacheShader("waypoint_bomb");
|
|
precacheModel( "prop_suitcase_intel" );
|
|
precacheString(&"MP_AQUIRING_INTEL");
|
|
precacheString(&"MP_INTEL_HEADER");
|
|
|
|
level._intelHUDIcon = "hud_suitcase_bomb";
|
|
precacheShader( level._intelHUDIcon );
|
|
|
|
level._intel = undefined;
|
|
// we need to setup our array of intel types
|
|
intelInitData = [];
|
|
intelInitData["replenish"] = "ammo_primary";
|
|
intelKillsEvalData = [];
|
|
intelKillsEvalData["kills"]["count"] = 3;
|
|
intelKillsEvalData["kills"]["string"] = &"MP_INTEL_KILLS_DESC";
|
|
intelKillsAwardData = [];
|
|
intelKillsAwardData["experience"] = 1000;
|
|
addIntelType( "intel_kills", 0, 15, ::initLifeStats, intelInitData, ::evalLifeStats, intelKillsEvalData, ::intelAward, intelKillsAwardData );
|
|
|
|
intelInitData = [];
|
|
intelInitData["replenish"] = "ammo_primary";
|
|
intelKillsEvalData = [];
|
|
intelKillsEvalData["headshots"]["count"] = 1;
|
|
intelKillsEvalData["headshots"]["string"] = &"MP_INTEL_HEADSHOT_DESC";
|
|
intelKillsAwardData = [];
|
|
intelKillsAwardData["experience"] = 1000;
|
|
addIntelType( "intel_headshot", 0, 15, ::initLifeStats, intelInitData, ::evalLifeStats, intelKillsEvalData, ::intelAward, intelKillsAwardData );
|
|
|
|
intelInitData = [];
|
|
intelInitData["replenish"] = "ammo_primary";
|
|
intelKillsEvalData = [];
|
|
intelKillsEvalData["mostmultikills"]["count"] = 1;
|
|
intelKillsEvalData["mostmultikills"]["string"] = &"MP_INTEL_MULTIKILL_DESC";
|
|
intelKillsAwardData = [];
|
|
intelKillsAwardData["experience"] = 1000;
|
|
addIntelType( "intel_multikills", 0, 15, ::initLifeStats, intelInitData, ::evalLifeStats, intelKillsEvalData, ::intelAward, intelKillsAwardData );
|
|
|
|
intelInitData = [];
|
|
intelInitData["replenish"] = "equipment";
|
|
intelKillsEvalData = [];
|
|
intelKillsEvalData["equipmentkills"]["count"] = 1;
|
|
intelKillsEvalData["equipmentkills"]["string"] = &"MP_INTEL_EQUIPMENT_DESC";
|
|
intelKillsAwardData = [];
|
|
intelKillsAwardData["experience"] = 1000;
|
|
addIntelType( "intel_equipmentkills", 0, 15, ::initLifeStats, intelInitData, ::evalLifeStats, intelKillsEvalData, ::intelAward, intelKillsAwardData );
|
|
|
|
// generate the max weighted value
|
|
level._intelMaxWeight = 0;
|
|
foreach ( intelName, intelDef in level._intelDefs )
|
|
{
|
|
if ( intelDef["weight"] > 0 )
|
|
{
|
|
level._intelMaxWeight += intelDef["weight"];
|
|
level._intelDefs[intelName]["weight"] = level._intelMaxWeight;
|
|
// println( "Adding intel " + intelName + " with weight value " + intelDef["weight"] + " max weight is " + level._intelMaxWeight );
|
|
}
|
|
else
|
|
{
|
|
println( "Warning: Intel def with 0 weight! name = ", intelName );
|
|
}
|
|
}
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
addIntelType( name, intelLevel, weight, initFunc, initData, evalFunc, evalData, awardFunc, awardData )
|
|
{
|
|
evalData["name"] = name;
|
|
awardData["name"] = name;
|
|
level._intelDefs[name]["weight"] = weight;
|
|
level._intelDefs[name]["intelLevel"] = intelLevel;
|
|
level._intelDefs[name]["initFunc"] = initFunc;
|
|
level._intelDefs[name]["initData"] = initData;
|
|
level._intelDefs[name]["evalFunc"] = evalFunc;
|
|
level._intelDefs[name]["evalData"] = evalData;
|
|
level._intelDefs[name]["awardFunc"] = awardFunc;
|
|
level._intelDefs[name]["awardData"] = awardData;
|
|
|
|
foreach( evalPiece, evalDataList in evalData )
|
|
{
|
|
println( evalPiece );
|
|
if( evalPiece != "name" && isDefined( evalDataList["string"] ))
|
|
{
|
|
PreCacheString( evalDataList["string"] );
|
|
}
|
|
}
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
getRandomIntel()
|
|
{
|
|
value = randomInt( level._intelMaxWeight );
|
|
|
|
selectedIntelName = undefined;
|
|
foreach ( intelName, intelDef in level._intelDefs )
|
|
{
|
|
if( intelDef["weight"] > 0 )
|
|
{
|
|
selectedIntelName = intelName;
|
|
|
|
if ( intelDef["weight"] > value )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return( selectedIntelName );
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
initIntelOnPlayer( player )
|
|
{
|
|
process = level._intelDefs[ level._intel ][ "initFunc" ];
|
|
processInitData = level._intelDefs[ level._intel ][ "initData" ];
|
|
processEvalData = level._intelDefs[ level._intel ][ "evalData" ];
|
|
|
|
return [[ process ]]( player, processInitData, processEvalData );
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
evalIntelOnPlayer( player )
|
|
{
|
|
process = level._intelDefs[ level._intel ][ "evalFunc" ];
|
|
processData = level._intelDefs[ level._intel ][ "evalData" ];
|
|
|
|
return [[ process ]]( player, processData );
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
awardIntelOnPlayer( player )
|
|
{
|
|
process = level._intelDefs[ level._intel ][ "awardFunc" ];
|
|
processData = level._intelDefs[ level._intel ][ "awardData" ];
|
|
|
|
[[ process ]]( player, processData );
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
addIntelToGame()
|
|
{
|
|
level._intel = getRandomIntel();
|
|
|
|
println( "Intel added to the game ", level._intel );
|
|
|
|
// wait till we have some player connected
|
|
level waittill( "connected", player );
|
|
|
|
while( level._players.size == 0 )
|
|
{
|
|
wait 0.05;
|
|
}
|
|
|
|
// find a intel spawn location
|
|
spawnPoint = findIntelSpawnLocation();
|
|
|
|
assert( isDefined( spawnPoint ));
|
|
|
|
// create the use objects
|
|
level._intelEnt = createIntelBreifcase( spawnPoint );
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
findIntelSpawnLocation()
|
|
{
|
|
// for now, just grab a random dom point
|
|
// randomPlayer = level._players[ randomInt( level._players.size ) ];
|
|
|
|
// randomPlayer waittill( "spawned_player" );
|
|
|
|
// return randomPlayer [[ level._getSpawnPoint ]]();
|
|
|
|
while( 1 )
|
|
{
|
|
wait 0.5;
|
|
if( isDefined( level._spawnpoints ))
|
|
{
|
|
if( level._spawnpoints.size > 0 )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return level._spawnpoints[ randomInt( level._spawnpoints.size ) ];
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
createIntelBreifcase( entity )
|
|
{
|
|
visuals[0] = spawn( "script_model", entity.origin );
|
|
visuals[0].angles = entity.angles;
|
|
visuals[0] setModel( "prop_suitcase_intel" );
|
|
|
|
cloneTrigger = spawn( "trigger_radius", entity.origin, 0, 96, 60 );
|
|
intelEnt = cloneTrigger;
|
|
|
|
intelZone = maps\mp\gametypes\_gameobjects::createCarryObject( "friendly", intelEnt, visuals, INTEL_OFFSET );
|
|
intelZone maps\mp\gametypes\_gameobjects::setUseTime( 0.5 );
|
|
intelZone maps\mp\gametypes\_gameobjects::setUseText( &"MP_AQUIRING_INTEL" );
|
|
intelZone maps\mp\gametypes\_gameobjects::setVisibleTeam( "any" );
|
|
// intelZone maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", "waypoint_bomb" );
|
|
// intelZone maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", "waypoint_bomb" );
|
|
// intelZone maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", "waypoint_bomb" );
|
|
// intelZone maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", "waypoint_bomb" );
|
|
intelZone maps\mp\gametypes\_gameobjects::allowCarry( "any" );
|
|
intelZone maps\mp\gametypes\_gameobjects::setCarrierVisible( false );
|
|
|
|
intelZone thread intelSpinAnimate();
|
|
|
|
intelZone.onPickup = ::onPickupIntel;
|
|
intelZone.onDrop = ::onDropIntel;
|
|
intelZone.allowWeapons = true;
|
|
intelZone.oldRadius = intelEnt.radius;
|
|
|
|
return intelZone;
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
intelSpinAnimate()
|
|
{
|
|
level endon( "game_ended" );
|
|
self endon( "reset" );
|
|
self endon( "pickup_object" );
|
|
|
|
bottomPos = self.curOrigin + INTEL_OFFSET;
|
|
topPos = self.curOrigin + INTEL_OFFSET_TOP;
|
|
|
|
while( true )
|
|
{
|
|
self.visuals[0] moveTo( topPos, 0.5, 0.15, 0.15 );
|
|
self.visuals[0] rotateYaw( 180, 0.5 );
|
|
|
|
wait( 0.5 );
|
|
|
|
self.visuals[0] moveTo( bottomPos, 0.5, 0.15, 0.15 );
|
|
self.visuals[0] rotateYaw( 180, 0.5 );
|
|
|
|
wait( 0.5 );
|
|
}
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
onPickupIntel( player )
|
|
{
|
|
// level._intelEnt maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", undefined );
|
|
// level._intelEnt maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", undefined );
|
|
// level._intelEnt maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", undefined );
|
|
// level._intelEnt maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", undefined );
|
|
|
|
player thread onIntelAquired();
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
onDropIntel( player )
|
|
{
|
|
// level._intelEnt maps\mp\gametypes\_gameobjects::set2DIcon( "friendly", "waypoint_bomb" );
|
|
// level._intelEnt maps\mp\gametypes\_gameobjects::set3DIcon( "friendly", "waypoint_bomb" );
|
|
// level._intelEnt maps\mp\gametypes\_gameobjects::set2DIcon( "enemy", "waypoint_bomb" );
|
|
// level._intelEnt maps\mp\gametypes\_gameobjects::set3DIcon( "enemy", "waypoint_bomb" );
|
|
|
|
level._intelEnt thread intelSpinAnimate();
|
|
intelCardSplashEveryone( "intel_dropped_callout", player );
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
onPlayerConnect()
|
|
{
|
|
for(;;)
|
|
{
|
|
level waittill( "connected", player );
|
|
|
|
player thread notifyIntelGame();
|
|
player thread onPlayerSpawned();
|
|
}
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
onPlayerSpawned()
|
|
{
|
|
self endon( "disconnect" );
|
|
|
|
if( intelDebugging())
|
|
println( "Intel: onPlayerSpawned" );
|
|
|
|
for(;;)
|
|
{
|
|
self waittill( "spawned_player" );
|
|
if( intelDebugging())
|
|
println( "Intel: Player spawned" );
|
|
self._intelHasIntel = 0;
|
|
// self thread intelWaitDeath();
|
|
}
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
intelWaitDeath()
|
|
{
|
|
self endon( "intel_cleanup" );
|
|
self waittill( "death" );
|
|
self notify( "intel_cleanup" );
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
intelWaitCleanup()
|
|
{
|
|
self waittill( "intel_cleanup" );
|
|
wait 1;
|
|
self destroyIntelHud();
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
onIntelAquired()
|
|
{
|
|
self endon( "disconnect" );
|
|
self endon( "death" );
|
|
|
|
//intelCardSplashEveryone( "intel_pickup_callout", self );
|
|
|
|
self._intelHasIntel = 1;
|
|
self createIntelHud();
|
|
self thread intelWaitDeath();
|
|
self thread intelWaitCleanup();
|
|
|
|
println( "Intel: intel aquired by ", self.name );
|
|
|
|
initIntelOnPlayer( self );
|
|
|
|
while( 1 )
|
|
{
|
|
if( evalIntelOnPlayer( self ) == 1 )
|
|
{
|
|
println( "Intel: Awarding intel to player" );
|
|
|
|
intelCardSplashEveryone( "intel_completed_callout", self );
|
|
|
|
self incPlayerStat( "intelCompleted", 1 );
|
|
|
|
awardIntelOnPlayer( self );
|
|
// get rid of the intel, it's served it's purpose
|
|
//level._intelEnt thread maps\mp\gametypes\_gameobjects::deleteUseObject();
|
|
level._intelEnt maps\mp\gametypes\_gameobjects::disableObject();
|
|
|
|
break;
|
|
}
|
|
wait 0.05;
|
|
}
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
// Evaluation and Award funcs
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
initLifeStats( player, initData, evalData )
|
|
{
|
|
if( intelDebugging())
|
|
println( "Initing Intel on ", player.name );
|
|
i = 0;
|
|
foreach( intelStat, intelStatValue in evalData )
|
|
{
|
|
if( intelStat != "name" )
|
|
{
|
|
player._intelInitValues[intelStat] = getPlayerStat( intelStat );
|
|
player._intelHud["lines"][i]["item"] SetText( intelStatValue["string"] );
|
|
i += 1;
|
|
}
|
|
}
|
|
if( isDefined( initData["replenish"] ))
|
|
{
|
|
weaponList = player GetWeaponsListAll();
|
|
switch( initData["replenish"] )
|
|
{
|
|
case "ammo_primary":
|
|
foreach ( weaponName in weaponList )
|
|
{
|
|
if ( maps\mp\gametypes\_weapons::isPrimaryWeapon( weaponName ) )
|
|
{
|
|
player giveMaxAmmo( weaponName );
|
|
}
|
|
}
|
|
break;
|
|
|
|
case "equipment":
|
|
foreach ( weaponName in weaponList )
|
|
{
|
|
if ( maps\mp\gametypes\_weapons::isEquipment( weaponName ) )
|
|
{
|
|
player giveMaxAmmo( weaponName );
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
evalLifeStats( player, evalData )
|
|
{
|
|
ret = 0;
|
|
allStatsSatisfied = 1;
|
|
if( intelDebugging())
|
|
println( "Evaluating Intel on ", player.name );
|
|
if( isDefined( evalData ))
|
|
{
|
|
i = 0;
|
|
foreach( intelStat, intelDef in evalData )
|
|
{
|
|
if( intelStat != "name" )
|
|
{
|
|
intelStatValue = intelDef["count"];
|
|
currStatValue = ( getPlayerStat( intelStat ) - player._intelInitValues[intelStat] );
|
|
|
|
if( intelDebugging())
|
|
println( "Checking ", intelStat, " value ", intelStatValue );
|
|
if( currStatValue < intelStatValue )
|
|
{
|
|
allStatsSatisfied = 0;
|
|
}
|
|
else
|
|
{
|
|
currStatValue = intelStatValue;
|
|
}
|
|
|
|
// hud text
|
|
hudText = currStatValue + "/" + intelStatValue;
|
|
if( player._intelHud["lines"][i]["text"] != hudText )
|
|
{
|
|
player._intelHud["lines"][i]["text"] = hudText;
|
|
player._intelHud["lines"][i]["status"] SetText( hudText );
|
|
}
|
|
|
|
i = i + 1;
|
|
}
|
|
}
|
|
if( allStatsSatisfied == 1 )
|
|
{
|
|
ret = 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
println( "Could not find evaluation data!\n" );
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
intelAward( player, awardData )
|
|
{
|
|
println( "Giving Intel Award to ", player.name );
|
|
if( isDefined( awardData ))
|
|
{
|
|
player thread maps\mp\gametypes\_hud_message::SplashNotify( "intel_completed", awardData["experience"] );
|
|
|
|
foreach( award, value in awardData )
|
|
{
|
|
if( award != "name" )
|
|
{
|
|
println( award, " ", value );
|
|
switch( award )
|
|
{
|
|
case "experience":
|
|
self thread awardIntelXp( value, awardData );
|
|
break;
|
|
|
|
default:
|
|
println( "Didn't understand how to deal with award type ", award );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
println( "No awards found!" );
|
|
}
|
|
|
|
player notify( "intel_cleanup" );
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
// Hud Notificaiton Scripts
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
awardIntelXp( value, awardData )
|
|
{
|
|
self endon ( "disconnect" );
|
|
|
|
wait( 0.25 );
|
|
self maps\mp\gametypes\_rank::giveRankXP( "challenge", value );
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
notifyIntelGame()
|
|
{
|
|
self waittill( "spawned_player" );
|
|
if( intelDebugging())
|
|
println( "We are playing a game with Intel!" );
|
|
|
|
self thread maps\mp\gametypes\_hud_message::SplashNotify( "intel_ingame", 0 );
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
intelCardSplashEveryone( splash, owner )
|
|
{
|
|
if ( level._hardCoreMode )
|
|
return;
|
|
|
|
foreach ( player in level._players )
|
|
{
|
|
player thread maps\mp\gametypes\_hud_message::playerCardSplashNotify( splash, owner );
|
|
}
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
hudIconPulse()
|
|
{
|
|
self endon( "intel_cleanup" );
|
|
origWidth = self._intelHud["icon"].width;
|
|
origHeight = self._intelHud["icon"].height;
|
|
for(;;)
|
|
{
|
|
self._intelHud["icon"] scaleOverTime( 0.05, int( origWidth * INTEL_ICON_PULSE_SCALE ), int( origHeight * INTEL_ICON_PULSE_SCALE ) );
|
|
wait 0.05;
|
|
self._intelHud["icon"] scaleOverTime( 0.3, origWidth, origHeight );
|
|
wait 0.3;
|
|
wait INTEL_ICON_PULSE_WAIT_SEC;
|
|
}
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
createIntelHud()
|
|
{
|
|
self._intelHud["icon"] = createIcon( level._intelHUDIcon, 40, 40 );
|
|
self._intelHud["icon"].horzAlign = "left";
|
|
self._intelHud["icon"].alignX = "left";
|
|
self._intelHud["icon"].y = 110;
|
|
self._intelHud["icon"].sort = -10;
|
|
self._intelHud["icon"].color = INTEL_ICON_COLOR;
|
|
self thread hudIconPulse();
|
|
|
|
currY = 130;
|
|
self._intelHud["header"] = CreateFontString( "objective", 1.3 );
|
|
self._intelHud["header"].horzAlign = "left";
|
|
self._intelHud["header"].alignX = "left";
|
|
self._intelHud["header"] SetText( &"MP_INTEL_HEADER" );
|
|
self._intelHud["header"].y = currY;
|
|
self._intelHud["header"].x = 42;
|
|
currY += 20;
|
|
|
|
xIndent = 20;
|
|
xOffset = 40;
|
|
|
|
self._intelHud["lines"][0]["item"] = CreateFontString( "objective", 1.25 );
|
|
self._intelHud["lines"][0]["item"].horizAlign = "left";
|
|
self._intelHud["lines"][0]["item"].alignX = "left";
|
|
self._intelHud["lines"][0]["item"].y = currY;
|
|
self._intelHud["lines"][0]["item"].x = xIndent + xOffset;
|
|
self._intelHud["lines"][0]["status"] = CreateFontString( "objective", 1.25 );
|
|
self._intelHud["lines"][0]["status"].horizAlign = "left";
|
|
self._intelHud["lines"][0]["status"].alignX = "left";
|
|
self._intelHud["lines"][0]["status"].y = currY;
|
|
self._intelHud["lines"][0]["status"].x = xIndent;
|
|
self._intelHud["lines"][0]["text"] = "";
|
|
currY += 20;
|
|
|
|
self._intelHud["lines"][1]["item"] = CreateFontString( "objective", 1.25 );
|
|
self._intelHud["lines"][1]["item"].horizAlign = "left";
|
|
self._intelHud["lines"][1]["item"].alignX = "left";
|
|
self._intelHud["lines"][1]["item"].y = currY;
|
|
self._intelHud["lines"][1]["item"].x = xIndent + xOffset;
|
|
self._intelHud["lines"][1]["status"] = CreateFontString( "objective", 1.25 );
|
|
self._intelHud["lines"][1]["status"].horizAlign = "left";
|
|
self._intelHud["lines"][1]["status"].alignX = "left";
|
|
self._intelHud["lines"][1]["status"].y = currY;
|
|
self._intelHud["lines"][1]["status"].x = xIndent;
|
|
self._intelHud["lines"][1]["text"] = "";
|
|
currY += 20;
|
|
|
|
self._intelHud["lines"][2]["item"] = CreateFontString( "objective", 1.25 );
|
|
self._intelHud["lines"][2]["item"].horizAlign = "left";
|
|
self._intelHud["lines"][2]["item"].alignX = "left";
|
|
self._intelHud["lines"][2]["item"].y = currY;
|
|
self._intelHud["lines"][2]["item"].x = xIndent + xOffset;
|
|
self._intelHud["lines"][2]["status"] = CreateFontString( "objective", 1.25 );
|
|
self._intelHud["lines"][2]["status"].horizAlign = "left";
|
|
self._intelHud["lines"][2]["status"].alignX = "left";
|
|
self._intelHud["lines"][2]["status"].y = currY;
|
|
self._intelHud["lines"][2]["status"].x = xIndent;
|
|
self._intelHud["lines"][2]["text"] = "";
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
destroyIntelHud()
|
|
{
|
|
self._intelHud["icon"] destroy();
|
|
self._intelHud["header"] destroy();
|
|
self._intelHud["lines"][0]["item"] destroy();
|
|
self._intelHud["lines"][0]["status"] destroy();
|
|
self._intelHud["lines"][1]["item"] destroy();
|
|
self._intelHud["lines"][1]["status"] destroy();
|
|
self._intelHud["lines"][2]["item"] destroy();
|
|
self._intelHud["lines"][2]["status"] destroy();
|
|
}
|