Wizz at 10:00, 5 November 2007

2007-11-05T10:00:38Z

New page

#define DROP_DIST '0 0 32768'

void G_Jotun_DropItem( float requestId, entity item, vector targetPos ) {
if ( sys.[[ScriptEvent:isClient|isClient]]() ) {
return;
}

sys.[[ScriptEvent:waitFrame|waitFrame]]();

vector dropOrigin = item.[[ScriptEvent:getWorldOrigin|getWorldOrigin]]();
dropOrigin_x = targetPos_x;
dropOrigin_y = targetPos_y;

entity [[ScriptClass:parachute|parachute]];

vector down = dropOrigin - DROP_DIST;
float frac;
if ( item.vDropItemTrace( dropOrigin, down, item, targetPos ) ) {
if ( !item.vAllowDrop() ) {
if ( requestId != -1 ) {
sys.[[ScriptEvent:clearDeployRequest|clearDeployRequest]]( requestId );
requestId = -1;
}
item.[[ScriptEvent:remove|remove]]();
return;
}
frac = sys.[[ScriptEvent:getTraceFraction|getTraceFraction]]();
} else {
frac = sys.[[ScriptEvent:tracePoint|tracePoint]]( dropOrigin, down, CONTENTS_SOLID | CONTENTS_MOVEABLECLIP, item );
}

if ( frac == 1.f ) {
sys.[[ScriptEvent:warning|warning]]( "G_Jotun_DropItem did not find the ground" );
}

vector finalDestinationII = sys.[[ScriptEvent:getTraceEndPos|getTraceEndPos]]();
item.[[ScriptEvent:setComeToRest|setComeToRest]]( false );
item.[[ScriptEvent:setGroundPosition|setGroundPosition]]( finalDestinationII );
item.[[ScriptEvent:disableKnockback|disableKnockback]]();

entity traceEnt = sys.[[ScriptEvent:getTraceEntity|getTraceEntity]]();
if ( traceEnt != $null_entity && traceEnt != sys.[[ScriptEvent:getEntity|getEntity]]( "worldspawn" ) ) {
item.vBindToEntity( traceEnt );
}

float parachuteDelay = item.[[ScriptEvent:getFloatKeyWithDefault|getFloatKeyWithDefault]]( "parachute_deploy_delay", 3.f );

float parachuteTime = sys.[[ScriptEvent:getTime|getTime]]() + parachuteDelay;
float parachuteZ = finalDestinationII_z + 4196;

while( 1 ) {
sys.[[ScriptEvent:waitFrame|waitFrame]]();

if ( item == $null_entity ) { // Gordon: map restart may have happened, or something else that removes the entity, don't want to spin forever
return;
}

vector origin = item.[[ScriptEvent:getWorldOrigin|getWorldOrigin]]();
vector velocity = item.[[ScriptEvent:getLinearVelocity|getLinearVelocity]]();
vector delta = origin - finalDestinationII;

if ( parachuteTime != -1 && sys.[[ScriptEvent:getTime|getTime]]() > parachuteTime && origin_z < parachuteZ ) {
// spawn a parachute on the dropped vehicle
string paraDef = item.[[ScriptEvent:getKeyWithDefault|getKeyWithDefault]]( "def_parachute", "round_parachute" );

if ( paraDef != "" ) {
[[ScriptClass:parachute|parachute]] = sys.[[ScriptEvent:spawn|spawn]]( paraDef );
if ( [[ScriptClass:parachute|parachute]] != $null_entity ) {
[[ScriptClass:parachute|parachute]].vSetOwner( item );
[[ScriptClass:parachute|parachute]].vForceStayOpen( true );
}
}

parachuteTime = -1;

if ( item.vSkipDeployDrop() ) {
break;
}
}

float count = item.[[ScriptEvent:entitiesInBounds|entitiesInBounds]]( item.[[ScriptEvent:getAbsMins|getAbsMins]](), item.[[ScriptEvent:getAbsMaxs|getAbsMaxs]](), -1, 0 );
float index;
for ( index = 0; index < count; index++ ) {
entity other = item.[[ScriptEvent:getBoundsCacheEntity|getBoundsCacheEntity]]( index );
other.[[ScriptEvent:applyDamage|applyDamage]]( $null_entity, item, down, GetDamage( "damage_magog_npc_collide" ), 1.f, $null_entity ); // FIXME: Get damage decl
}

if ( delta_z <= 1 ) {
break;
}

if ( velocity_z != 0.f ) {
// drift the item towards its destination to account for error in launch origin
float estTimeToHit = sys.[[ScriptEvent:fabs|fabs]]( delta_z / velocity_z );
vector newVelocity = delta * ( velocity_z / delta_z );
newVelocity_z = velocity_z;
item.[[ScriptEvent:setLinearVelocity|setLinearVelocity]]( newVelocity );
}
}

item.[[ScriptEvent:enableKnockback|enableKnockback]]();
if ( [[ScriptClass:parachute|parachute]] != $null_entity ) {
[[ScriptClass:parachute|parachute]].vForceStayOpen( false );
}

if ( requestId != -1 ) {
sys.[[ScriptEvent:clearDeployRequest|clearDeployRequest]]( requestId );
requestId = -1;
}

if ( item != $null_entity ) {
item.vOnDeploy();
item = $null_entity;
}
}

object [[ScriptClass:vehicle_jotun|vehicle_jotun]] {
void preinit();
void init();
void destroy();
void syncFields();

// states
void Deliver();
void Drop();
void Return();

// callbacks
void OnSetDeploymentParms( float deploymentItemIndex, float playerIndex, vector target, float rotation );
void OnKilled( entity inflictor, entity attacker, float damage, vector direction, float location );
void ClearRequest();
void OnItemChanged();
void OnStartTimeChanged();

// utility
void DoSound();
void SetupCommandMap();
boolean PerformDrop();

// virtuals
boolean vIgnoreMagogCollsion();

// threads
void KillAllInBoundingBox();

// deployment stuff
float deployIndex;
float deployPlayerIndex;
float itemIndex;
entity item;
vector targetPos;
float itemRotation;
float startTime;
float dropTime;
float returnTime;
vector gdfCorner;

float deliveryPathLength;
float returnPathLength;

// local data 
float maxHealth;
float damageIndex;

boolean cancelDrop;
boolean dropped;

boolean playedFlyBySound;
boolean playingFlySound;
float flyOverSoundRange;
};

void [[ScriptClass:vehicle_jotun|vehicle_jotun]]::SetupCommandMap() {

}

void [[ScriptClass:vehicle_jotun|vehicle_jotun]]::syncFields() {
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "item" );
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "dropTime" );
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "returnTime" );
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "targetPos" );
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "itemRotation" );
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "gdfCorner" );
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "startTime" );
[[ScriptEvent:syncCallback|syncCallback]]( "item", "OnItemChanged" );
[[ScriptEvent:syncCallback|syncCallback]]( "startTime", "OnStartTimeChanged" );
}

void [[ScriptClass:vehicle_jotun|vehicle_jotun]]::OnItemChanged() {
}

void [[ScriptClass:vehicle_jotun|vehicle_jotun]]::OnStartTimeChanged() {
if ( startTime != -1 ) {
[[ScriptEvent:setState|setState]]( "Deliver" );
}
}

void [[ScriptClass:vehicle_jotun|vehicle_jotun]]::preinit() {
deployPlayerIndex = -1;
startTime = -1;
dropTime = -1;
returnTime = -1;
maxHealth = [[ScriptEvent:getFloatKey|getFloatKey]]( "health" );

SetupCommandMap();

float damageDeclIndex = sys.[[ScriptEvent:getDeclType|getDeclType]]( "damageDef" );
damageIndex = sys.[[ScriptEvent:getDeclIndex|getDeclIndex]]( damageDeclIndex, [[ScriptEvent:getKey|getKey]]( "dmg_drop_damage" ) );

gdfCorner = '0 0 0';

cancelDrop = false;
dropped = false;

playedFlyBySound = false;
playingFlySound = false;

flyOverSoundRange = [[ScriptEvent:getFloatKey|getFloatKey]]( "flyover_sndrange" );
flyOverSoundRange = flyOverSoundRange * flyOverSoundRange;

[[ScriptEvent:setCoverage|setCoverage]]( 0.f );

[[ScriptEvent:disableKnockback|disableKnockback]]();
[[ScriptEvent:hide|hide]]();
}

void [[ScriptClass:vehicle_jotun|vehicle_jotun]]::init() {
thread KillAllInBoundingBox();
}

void [[ScriptClass:vehicle_jotun|vehicle_jotun]]::ClearRequest() {
if ( sys.[[ScriptEvent:isClient|isClient]]() ) {
return;
}

if ( deployPlayerIndex != -1 ) {
sys.[[ScriptEvent:clearDeployRequest|clearDeployRequest]]( deployPlayerIndex );
deployPlayerIndex = -1;
}
}

void [[ScriptClass:vehicle_jotun|vehicle_jotun]]::destroy() {
sys.[[ScriptEvent:killThread|killThread]]( "KillAllInBoundingBox_" + [[ScriptEvent:getName|getName]]() );

ClearRequest();
}

#define JOTUN_FLY_HEIGHT 4096

void [[ScriptClass:vehicle_jotun|vehicle_jotun]]::Deliver() {
[[ScriptEvent:show|show]]();

if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
startTime = sys.[[ScriptEvent:getTime|getTime]]();
gdfCorner = objManager.GetGDFBasePosition();
}

float pathSpeed = [[ScriptEvent:getFloatKeyWithDefault|getFloatKeyWithDefault]]( "path_speed", 1024 );
string pathType = [[ScriptEvent:getKey|getKey]]( "path_type" );

// find the delivery path & level it out
[[ScriptEvent:pathFind|pathFind]]( pathType, targetPos, startTime, 1.0f, gdfCorner_x, gdfCorner_y, 256.0f, false );
[[ScriptEvent:pathLevel|pathLevel]]( 13, -1, -1 );
float numPoints = [[ScriptEvent:pathGetNumPoints|pathGetNumPoints]]();
if ( numPoints < 2 ) {
return;
}

deliveryPathLength = [[ScriptEvent:pathGetLength|pathGetLength]]();

// get the return path & level that out
[[ScriptEvent:pathFind|pathFind]]( pathType, targetPos, startTime + deliveryPathLength / pathSpeed, -1.0f, gdfCorner_x, gdfCorner_y, 1024.0f, true );
float newNumPoints = [[ScriptEvent:pathGetNumPoints|pathGetNumPoints]]();
[[ScriptEvent:pathLevel|pathLevel]]( 13, numPoints - 1, newNumPoints - 1 );

returnPathLength = [[ScriptEvent:pathGetLength|pathGetLength]]() - deliveryPathLength;

float pathLength = deliveryPathLength;
float leadTime = 2.0f;

vector flyOffset = '0 0 0';
flyOffset_z = JOTUN_FLY_HEIGHT;

// setup the start
vector startPoint = [[ScriptEvent:pathGetPoint|pathGetPoint]]( 0 ) + flyOffset;
vector endPoint = [[ScriptEvent:pathGetPoint|pathGetPoint]]( numPoints - 1 ) + flyOffset;
vector startDir = sys.[[ScriptEvent:vecNormalize|vecNormalize]]( endPoint - startPoint );
vector startAngles = sys.[[ScriptEvent:vecToAngles|vecToAngles]]( startDir );

[[ScriptEvent:setWorldOrigin|setWorldOrigin]]( startPoint );
[[ScriptEvent:setAngles|setAngles]]( startAngles );

[[ScriptEvent:startJotunDelivery|startJotunDelivery]]( startTime, pathSpeed, leadTime );

float minDistance = 9999999999.0f;
float coverage = 0.f;
while ( true ) {
float time = sys.[[ScriptEvent:getTime|getTime]]() - startTime;
float frameTime = sys.[[ScriptEvent:getFrameTime|getFrameTime]]();

[[ScriptEvent:setCoverage|setCoverage]]( coverage );
coverage = coverage + frameTime;

//sys.debugCircle( '1 0 0', startPoint, '0 0 1', 256.0f, 16, 0 );
//sys.debugCircle( '1 0 0', endPoint, '0 0 1', 128.0f, 16, 0 );

float aheadPosition = ( time + leadTime )* pathSpeed;

DoSound();

if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
vector origin = [[ScriptEvent:getWorldOrigin|getWorldOrigin]]();
vector delta = origin - endPoint;
delta_z = 0.0f;
float distance = sys.[[ScriptEvent:vecLength|vecLength]]( delta );

if ( distance < minDistance ) {
minDistance = distance;
} else if ( aheadPosition > pathLength ) {
Drop();
}
} else if ( returnTime != -1 ) {
[[ScriptEvent:setState|setState]]( "Return" );
}

if ( cancelDrop ) {
ClearRequest();
[[ScriptEvent:setState|setState]]( "Return" );
}

sys.[[ScriptEvent:waitFrame|waitFrame]]();
}
}

void [[ScriptClass:vehicle_jotun|vehicle_jotun]]::Drop() {

[[ScriptClass:player|player]] p = sys.[[ScriptEvent:getClient|getClient]]( deployPlayerIndex );
item = sys.[[ScriptEvent:spawnType|spawnType]]( itemIndex );
item.vSetDeployableOwner( p );

[[ScriptClass:deployable_base|deployable_base]] deployable = item;
if ( deployable != $null_entity ) {
p.SetTargetingItem( item );
}

string statName = item.[[ScriptEvent:getKey|getKey]]( "stat_name" );
if ( statName != "" ) {
sys.[[ScriptEvent:increaseStatInt|increaseStatInt]]( sys.[[ScriptEvent:allocStatInt|allocStatInt]]( statName + "_deployed" ), deployPlayerIndex, 1 );
}

if( PerformDrop() ) {
vector temp = [[ScriptEvent:getWorldOrigin|getWorldOrigin]]();

vector angles;
angles_y = itemRotation;

item.[[ScriptEvent:setOrigin|setOrigin]]( temp - ( g_vectorDown * 256 ) );
item.[[ScriptEvent:setAngles|setAngles]]( angles );
item.[[ScriptEvent:setGameTeam|setGameTeam]]( [[ScriptEvent:getGameTeam|getGameTeam]]() );
item.vSetManualDeploy();
thread G_Jotun_DropItem( deployPlayerIndex, item, targetPos );
} else {
item.[[ScriptEvent:remove|remove]]();
ClearRequest();
}

deployPlayerIndex = -1;
dropped = true;

[[ScriptEvent:setState|setState]]( "Return" );
}

void [[ScriptClass:vehicle_jotun|vehicle_jotun]]::Return() {
if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
returnTime = sys.[[ScriptEvent:getTime|getTime]]();
} else {
while ( returnTime == -1 ) {
sys.[[ScriptEvent:waitFrame|waitFrame]]();
}
}

float numPoints = [[ScriptEvent:pathGetNumPoints|pathGetNumPoints]]();
if ( numPoints < 2 ) {
return;
}

float pathSpeed = [[ScriptEvent:getFloatKeyWithDefault|getFloatKeyWithDefault]]( "path_speed", 1024 );
float pathLength = returnPathLength;
float leadTime = 2.0f;

vector flyOffset = '0 0 0';
flyOffset_z = JOTUN_FLY_HEIGHT;

vector endPoint = [[ScriptEvent:pathGetPoint|pathGetPoint]]( numPoints - 1 ) + flyOffset;
[[ScriptEvent:startJotunReturn|startJotunReturn]]( returnTime, pathSpeed, leadTime );

while ( true ) {
DoSound();

float time = sys.[[ScriptEvent:getTime|getTime]]() - returnTime;
float position = time * pathSpeed;
[[ScriptEvent:setCoverage|setCoverage]]( ( pathLength - 1 - position ) / pathSpeed );

if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
if ( position > pathLength ) {
[[ScriptEvent:remove|remove]]();
}
}

sys.[[ScriptEvent:waitFrame|waitFrame]]();
}
}

void [[ScriptClass:vehicle_jotun|vehicle_jotun]]::DoSound() {
if( !playingFlySound ) {
playingFlySound = true;
[[ScriptEvent:fadeSound|fadeSound]]( SND_VEHICLE_IDLE, -60.f, 0.f );
[[ScriptEvent:startSound|startSound]]( "snd_flyby_far", SND_VEHICLE_IDLE );
[[ScriptEvent:fadeSound|fadeSound]]( SND_VEHICLE_IDLE, 0.f, 2.f );
}

// check distance to local player
if( !playedFlyBySound ) {
entity p = sys.[[ScriptEvent:getLocalPlayer|getLocalPlayer]]();
if( p != $null_entity ) {
vector playerOrigin = p.[[ScriptEvent:getWorldOrigin|getWorldOrigin]]();
playerOrigin -= [[ScriptEvent:getWorldOrigin|getWorldOrigin]]();
playerOrigin_z = 0.f;

if( sys.[[ScriptEvent:vecLengthSquared|vecLengthSquared]]( playerOrigin ) < flyOverSoundRange ) {
sys.[[ScriptEvent:startSoundDirect|startSoundDirect]]( [[ScriptEvent:getKey|getKey]]( "snd_flyby" ), SND_VEHICLE_IDLE );
playedFlyBySound = true;
}
}
}
}

void [[ScriptClass:vehicle_jotun|vehicle_jotun]]::OnSetDeploymentParms( float deploymentItemIndex, float playerIndex, vector target, float rotation ) {

deployPlayerIndex = playerIndex;
targetPos = target;
itemRotation = sys.[[ScriptEvent:angleNormalize180|angleNormalize180]]( rotation );
itemIndex = deploymentItemIndex;

if( !PerformDrop() ) {
// player has switched sides since calling in the deployable
ClearRequest();
[[ScriptEvent:remove|remove]]();
return;
}

[[ScriptClass:player|player]] p = sys.[[ScriptEvent:getClient|getClient]]( playerIndex );

[[ScriptEvent:setState|setState]]( "Deliver" );
}

void [[ScriptClass:vehicle_jotun|vehicle_jotun]]::OnKilled( entity inflictor, entity attacker, float damage, vector direction, float location ) {
}

void [[ScriptClass:vehicle_jotun|vehicle_jotun]]::KillAllInBoundingBox() {
sys.[[ScriptEvent:threadName|threadName]]( "KillAllInBoundingBox_" + [[ScriptEvent:getName|getName]]() );

sys.[[ScriptEvent:wait|wait]]( 3 );

eachFrame {

vector mins = [[ScriptEvent:getAbsMins|getAbsMins]]();
vector maxs = [[ScriptEvent:getAbsMaxs|getAbsMaxs]]();

// sys.debugBounds( '1 1 1', mins, maxs, 0.f );

float count = [[ScriptEvent:entitiesInBounds|entitiesInBounds]]( mins, maxs, MASK_ALL, 1 );
count = [[ScriptEvent:filterEntitiesByClass|filterEntitiesByClass]]( "sdTransport", 1 );

float i;
for( i = 0; i < count; i++ ) {
entity ent = [[ScriptEvent:getBoundsCacheEntity|getBoundsCacheEntity]]( i );
if( ent == self || ent == item || ent == $null_entity ) {
continue;
}

if( !ent.vIgnoreMagogCollsion() ) {
ent.[[ScriptEvent:applyDamage|applyDamage]]( $null_entity, self, '0 1 0', GetDamage( "damage_magog_npc_collide" ), 60000.f, $null_entity );
}
}
}
}

boolean [[ScriptClass:vehicle_jotun|vehicle_jotun]]::vIgnoreMagogCollsion() {
return true;
}

boolean [[ScriptClass:vehicle_jotun|vehicle_jotun]]::PerformDrop() {
return true;
}

void [[ScriptClass:vehicle_jotun|vehicle_jotun]]::vCancelDeployForPlayer( float playerIndex ) {
if ( playerIndex != deployPlayerIndex ) {
return;
}

// deployables already gone
if ( dropped ) {
return;
}

[[ScriptClass:player|player]] p = sys.[[ScriptEvent:getClient|getClient]]( deployPlayerIndex );
objManager.PlaySoundForPlayer( [[ScriptEvent:getKey|getKey]]( "snd_cancel_deploy" ), p );

ClearRequest();
[[ScriptEvent:setState|setState]]( "Return" );
}

Script:Files:script/vehicles/jotun.script - Revision history

Wizz at 10:00, 5 November 2007