////////////////////////////////////////////////////////////////////////////////////////////////////////
// Big THANKS to United Noobs (Gil Vargas Aka uo1.who aka ElDiablo) and their 'Vehicle Mod' for CTF //
//I used one of the scripts, modified it, to get the jeeps working in my map for all gametypes(by NDM)//
////////////////////////////////////////////////////////////////////////////////////////////////////////

main() {

thread main_callbacks();

if( getCvarInt("dvar_jeepsEnabled") == 1 ) {
thread jeepy();
}
else {
setCvar("dvar_maxJeeps", "1" );
}

thread jeepy();
}

main_callbacks() {
level.ogDamage = level.callbackPlayerDamage;
level.ogKill = level.callbackPlayerKilled;
level.callbackPlayerDamage = ::Callback_PlayerDamage;
level.callbackPlayerKilled = ::Callback_PlayerKilled;

game["chute_menu"] = "chute";

precacheMenu(game["chute_menu"]);
precacheitem("aa_mp");

level.miscObjectives = [];
for( j = 2; j < 16; j++ )
level.miscObjectives[j] = false;

}

Callback_PlayerDamage(eInflictor, eAttacker, iDamage, iDFlags, sMeansOfDeath, sWeapon, vPoint, vDir, sHitLoc, psOffsetTime) {
if(self.sessionteam == "spectator")
return;

if(!isDefined(vDir))
iDFlags |= level.iDFLAGS_NO_KNOCKBACK;


if( isDefined( eAttacker ) && eAttacker == self || !isDefined( self.vehicle ) || isDefined(self.vehicle) && self.vehicle.vehicleType != "tank" ) {

playFX( level.impact["flesh"], self getOrigin() );
self thread [[level.ogDamage]](eInflictor, eAttacker, iDamage, iDFlags, sMeansOfDeath, sWeapon, vPoint, vDir, sHitLoc, psOffsetTime);
}
}

Callback_PlayerKilled(eInflictor, attacker, iDamage, sMeansOfDeath, sWeapon, vDir, sHitLoc, psOffsetTime, deathAnimDuration) {
self endon("spawned");

if(self.sessionteam == "spectator") {
self.vehicle = undefined;
return;
}

if( isDefined( attacker ) && attacker == self || !isDefined( self.vehicle ) || isDefined(self.vehicle) && self.vehicle.vehicleType != "tank" ) {
self.vehicle = undefined;
self thread [[level.ogKill]](eInflictor, attacker, iDamage, sMeansOfDeath, sWeapon, vDir, sHitLoc, psOffsetTime, deathAnimDuration);
}
}

manualRadiusDamage(attacker,origin,weapon,mdeath, range,damage, maxDamage ,killIfBlocking) {
if( isDefined( mdeath ) )
mDeath = "MOD_EXPLOSIVE";

if( !isDefined( weapon ) )
weapon = "none";

damageMultiplier = range / maxDamage;
players = getentarray("player", "classname");
for( j = 0; J < players.size; j++ ) {
peep = players[j];

if( peep == self )
continue;
pOrigin = peep getOrigin();
dist = distance( origin, pOrigin );
if( dist > range )
continue;

currDamage = int(dist / damageMultiplier);

if( currDamage < damage )
currDamage = damage;

trace = bulletTrace( origin + (0,0,10 ), pOrigin + ( 0 ,0 ,40 ), true, undefined );

ent = trace["entity"];

if( isDefined( ent ) && ent != peep )
if( killIfBlocking != true )
continue;

direction = vectorToAngles( pOrigin - origin );
direction = anglesToForward( direction );

peep thread [[level.callbackPlayerDamage]](self, attacker, currDamage, 1, mdeath, weapon, pOrigin, direction, "none",0);
}
}

monitorExKeys() {
self endon( "intermission" );
self endon("disconnect");

if( isDefined( self.monitorExtraKeys ) )
return;
self.monitorExtraKeys = true;
wait 1;
if( !isDefined( self ) )
return;

self openMenu( game["chute_menu"] );
wait .5;
self closeMenu();

while( isDefined( self ) ) {
self waittill("menuresponse", menu, response);

if( menu == "-1" && isAlive( self ) ) {
self notify( "key_" + response );
}
else {
}
}
}
//*****************************************************
// Util
//*****************************************************
getDiffV2(rollNew, rollOld) {

val1 = positiveMod( rollNew );
val2 = positiveMod( rollOld );

if( val1 > val2 ) {
temp = val1;
val1 = val2;
val2 = temp;
}

if( ( val2 - val1 ) < 180 )
return val2 - val1;
else {
return ( ( 360 - val2) + val1 ) ;
}

}

//*****************************************************
// Util
//*****************************************************
positiveMod(rollNew) {
if( rollNew < 0 ) {
if( rollNew < -1000 ) {
temp = int( rollNew / -360) - 1;

rollNew -= ( -360 * temp );
}

while( rollNew < -360 )
rollNew += 360;

rollNew = (360 + rollNew ) ;
}
else if( rollNew > 0 ) {
if( rollNew > 1000 ) {
temp = int( rollNew / 360 ) - 1;

rollNew -= ( 360 * temp );
}

while( rollNew > 360 )
rollNew -= 360;
}
return rollNew;
}
//*********************************************
// Util reset angles
//*********************************************
resetAngles( a ) {
a0 = angleMod( a[0] );
a1 = angleMod( a[1] );
a2 = angleMod( a[2] );
if( a0 != a[0] || a1 != a[1] || a2 != a[2] )
return ( a0, a1, a2 );
else
return undefined;
}
//*****************************************
// Util angle mod
//*****************************************
angleMod( pval ) {
if( pval <= -360 ) {
for( j = 0; j <= 100; j++ ) {
if( pval <= -360 )
pval += 360;
else
break;
}
}

if( pval >= 360 ) {
for( j = 0; j <= 100; j++ ) {
if( pval >= 360 )
pval -= 360;
else
break;
}
}
return pval;
}
//*****************************************************
// Util mod
//*****************************************************
miscMod(rollNew) {
if( rollNew < 0 ) {
if( rollNew < -1000 ) {
temp = int( rollNew / -360) - 1;

rollNew -= ( -360 * temp );
}

while( rollNew <= -360 )
rollNew += 360;

}
else if( rollNew > 0 ) {
if( rollNew > 1000 ) {
temp = int( rollNew / 360 ) - 1;

rollNew -= ( 360 * temp );
}

while( rollNew >= 360 )
rollNew -= 360;

}

return rollNew;
}

// Util turn direction
turnDirection( newDirection, oldDirection) {
iResult = 0;
newDirection = miscMod( newDirection );
olddirection = miscMod( oldDirection );

if( newDirection <= 180 ) {
temp = newDirection + 180;

if( oldDirection >= newDirection && oldDirection <= temp )

iResult = 1;
else
iResult = -1;
}
else {
temp = newDirection - 180;
if( oldDirection >= temp && oldDirection <= newDirection )
iResult = -1;
else
iResult = 1;
}

return iResult;

}

// Find a safe place to put the player after unmounting a vehicle.

safeGround(ent,dist,height) {
anglesF = anglesToForward( ent.angles );
anglesR = anglesToRight( ent.angles );
origin = self getOrigin();
direction = (0,0,0);
iPosFound = false;
if( isDefined( ent ) ) {

temp = vector_scale( anglesR, dist );
trace = bulletTrace( origin, origin + temp, false, self );
if( trace["surfacetype"] == "none" || trace["surfacetype"] == "default" ) {
pos = trace["position"];
trace = bulletTrace(pos + (0,0,500), pos - (0,0,200),false, self);

direction = vectorToAngles( origin - pos );

self setOrigin(trace["position"] + (0,0,height));
iPosFound = true;

}

temp = vector_scale( anglesR, dist - ( dist * 2 ));
trace = bulletTrace( origin, origin + temp, false, self );
if( iPosFound == false && trace["surfacetype"] == "none" || trace["surfacetype"] == "default" ) {

pos = trace["position"];
direction = vectorToAngles( origin - pos );

trace = bulletTrace(pos + (0,0,500), pos - (0,0,200),false, self);
self setOrigin(trace["position"] + (0,0,height));

iPosFound = true;
}

temp = vector_scale( anglesF, dist - ( dist * 2 ));
trace = bulletTrace( origin, origin + temp, false, self );
if( iPosFound == false && trace["surfacetype"] == "none" || trace["surfacetype"] == "default" ) {
pos = trace["position"];
direction = vectorToAngles( origin - pos );

trace = bulletTrace(pos + (0,0,500), pos - (0,0,200),false, self);
self setOrigin(trace["position"] + (0,0,height));

iPosFound = true;
}

wait 1;
// Handle players stuck on walls
direction = anglesToForward( direction );
while( isDefined( self ) && isAlive( self ) && self isOnGround() == false ) {
temp = vector_scale( direction, 10 );
self setOrigin( self getOrigin() + temp );
wait .5;
}
}

}

vector_scale(vec, scale) {
vec = (vec[0] * scale, vec[1] * scale, vec[2] * scale);
return vec;
}

jeepy() {

precacheStuff();

//thread jeepgrendamage();
level thread onPlayerConnected();
wait 5;
level.jeeps = [];
level.globalOrg = (-39200, 11083, 350);

ijeeps = getCvarInt("dvar_maxJeeps");
setCvar("dvar_jeeps","1");

for( j = 0; j <= 3190; j+=3190) {
thread spawn_jeep(j);
}
}

onPlayerConnected() {
self endon("intermission");

while(true) {
self waittill("connected", player);
player thread onPlayerDisconnect();
player thread onPlayerSpawn();
}
}

onPlayerSpawn() {
self endon("intermission");
self endon("disconnect");

while(true) {
self waittill("spawned_player");

self thread onPlayerKilled();
self.cancelSprint = undefined;
self.jeep = undefined;

self thread monitorExKeys();
}
}

onPlayerKilled() {
self endon("intermission");
self endon("disconnect");

self waittill("killed_player");
self detachFromJeep();
self detachFromJeep();
}

onPlayerDisconnect() {
self endon("intermission");

self waittill("disconnect");
self detachFromJeep();
}

engineON() {
self endon("intermission");
self endon("disconnect");
self endon("jeep_done");

jeep = self;
wait .5;
self thread jeepShocks();
self thread dust();
self thread trackDamage();
jeep thread detectCollition();
jeep thread onJeepCollition();
jeep thread onDestroyedJeep();

imoving = 0;
while( isDefined( jeep )) {

direction = anglesToForward( jeep.angles );

origin = jeep getOrigin();

if( !isDefined( jeep.driver ) ) {
if( jeep.speed <= -2 ) {
jeepAccel();
}
else if( jeep.speed > 2 ) {
jeepDecel();
}
}
else {
if( iMoving == 0 ) {
}
else {
}
}
if( jeep.speed > 2 || jeep.speed < -2 ) {
temp = vector_Scale(direction, jeep.speed );
nextPos = origin + temp;

trace = bulletTrace( nextPos + (0,0,100), (nextPos[0],nextPos[1],origin[2] - 25), false, jeep );

if( !isDefined( trace["entity"] ) )
nextPos = trace["position"];

jeep moveTo( nextPos, 0.1,0,0 );
}
wait .1;
}
}

trackDamage() {
self endon( "intermission" );
self endon( "destroyed_jeep" );

wait(2);

jeep = self;

while( isDefined(jeep) ) {
if(jeep.damage >= jeep.maxDamage ) {

self notify("destroyed_jeep");

self.damage = self.maxDamage;
return;
}

if( self.damage > 1 ) {
origin = self getOrigin();
anglesForward = anglesToForward( self.angles );
anglesUp = anglesToUp( self.angles );

temp = vector_scale( anglesForward, 55 );
temp += origin + vector_scale( anglesUp, 40 );

playFX( level._effect["vehicle_steam"], temp );

wait ( 1.6 / self.damage );
}
else
wait(.5);
}
}

onDestroyedJeep() {
self endon("intermission");

team = self.teamAlt;
self waittill("destroyed_jeep");

peep = self.driver;
peep2 = self.passenger1;

if( isDefined( self.driver ) && self.driver.jeep == self )
self.driver unlink();
if( isDefined( self.passenger1 ) && self.passenger1.jeep == self)
self.passenger1 unlink();

if( isDefined( self.hitBy ) ) {

hitBy = self.hitBy;
hitWeapon = self.hitWeapon;

if( isDefined( peep ) && isAlive( peep ) ) {
peep detachFromJeep();
peep thread [[level.callbackPlayerDamage]](hitBy, hitBy, 1000, 1, "MOD_BULLET", hitWeapon, peep getOrigin(), undefined, "none",0);
}
if( isDefined( peep2 ) && isAlive( peep2 ) ) {
peep2 detachFromJeep();
peep2 thread [[level.callbackPlayerDamage]](hitBy, hitBy, 1000, 1, "MOD_BULLET", hitWeapon, peep2 getOrigin(), undefined, "none",0);
}
}
else {
if( isDefined( peep ) && isAlive( peep ) ) {
peep detachFromJeep();
peep thread [[level.callbackPlayerDamage]](peep, peep, 1000, 1, "MOD_BULLET", "none", peep getOrigin(), undefined, "none",0);
}
if( isDefined( peep2 ) && isAlive( peep2 ) ) {
peep2 detachFromJeep();
peep2 thread [[level.callbackPlayerDamage]](peep2, peep2, 1000, 1, "MOD_BULLET", "none", peep2 getOrigin(), undefined, "none",0);
}
}

origin = self getOrigin();
anglesForward = anglesToForward( self.angles );
anglesUp = anglesToUp( self.angles );

temp = vector_scale( anglesForward, 20 );
temp += origin + vector_scale( anglesUp, 35 );

self playSound("mortar_explosion" + randomIntRange(1,5) );
playFX( level._effect["armoredcar_explosion"], temp );

self notify("jeep_done");

self setModel(game["jeepd"]);
maps\mp\_fx::loopfx("flat_fire",temp + (0,0,15),2,undefined,undefined,undefined,25);
}

dust(){
self endon("intermission");
self endon("destroyed_jeep");

while(true) {
if( self.speed > 2 || self.speed < -2 ) {

anglesForward = anglesToForward( self.angles );
temp = vector_scale(anglesForward, -100 );
playFX(level._effect["libya_dust_kickup"], self getOrigin() + temp );
speed = self.speed;
wtime = .5;
if( speed < 0 ) {
speed = (speed - (speed * 2 ) );
}

wtime = (17/ speed);
if( wtime < .005 )
wtime = .005;
wait( wtime );
}
else
wait .5;
}
}

//***************************************
// Jeep Driver
//***************************************

jeepDriver() {
self endon("intermission");
self endon("killed_player");
self endon("disconnect");
self endon("destroyed_jeep");

jeep = self.jeep;
jeep.angleYaw = jeep.angles[1];

while( isDefined( self.jeep ) && isAlive( self ) && self.jeep == jeep) {
wait .1;

if( !isDefined( jeep.driver ) )
break;
if( jeep.driver != self )
break;

angles = self getPlayerAngles();
jeepAngles = jeep.angles;
origin = jeep getOrigin();

anglesForward = anglesToForward( angles );
jeepAnglesForward = anglesToForward( jeepAngles );

temp = vector_scale( anglesForward, 10000 );
temp += origin;
lookDirection = vectorToAngles( temp - origin );

temp = vector_scale( jeepAnglesForward, - 10000 );
temp += origin;

backDirection = vectorToAngles( temp - origin );

hdirection = turnDirection ( lookDirection[1], backDirection[1] );

hdiff = getDiffV2( lookDirection[1], jeep.angles[1] );

if( hdirection != 0 ) {
tempYaw = hdirection;

iYaw = hdiff;

tempYaw *= ( hdiff * (10/ (20 + iYaw * 1 ) ) );

jeep.angleYaw = jeep.angles[1] + tempYaw;
}
}
}

//**********************************************
// Util pitch
//**********************************************

jeepShocks() {
self endon("intermission");
self endon("destroyed_jeep");

jeep = self;

while(true) {
if( jeep.speed < -5 || jeep.speed > 5 ) {
o = jeep getOrigin();
angles = vectorToAngles(self getOrigin() - o);

a = anglesToForward( jeep.angles );
temp = vector_scale( a, 1000 );
o2 = temp + self getOrigin();
angles = vectorToAngles(o2 - o);

startPos = jeep.frontLeftTire getOrigin() + (0,0,200 );
endPos = jeep.frontLeftTire getOrigin() - (0,0,20 );
trace = bulletTrace( startPos, endPos, true, jeep );
fltire = trace["position"];

startPos = jeep.frontRightTire getOrigin() + (0,0,200 );
endPos = jeep.frontRightTire getOrigin() - (0,0,20 );
trace = bulletTrace( startPos, endPos, true, jeep );
frtire = trace["position"];

startPos = jeep.backLeftTire getOrigin() + (0,0,200 );
endPos = jeep.backLeftTire getOrigin() - (0,0,15 );
trace = bulletTrace( startPos, endPos, true, jeep );
bltire = trace["position"];

startPos = jeep.backRightTire getOrigin() + (0,0,200 );
endPos = jeep.backRightTire getOrigin() - (0,0,15 );
trace = bulletTrace( startPos, endPos, true, jeep );
brtire = trace["position"];

bl = vectorToAngles( frtire - bltire );
br = vectorToAngles( fltire - brtire );

bl2 = vectorToAngles( frtire - fltire );
br2 = vectorToAngles( brtire - bltire );

x = bl[0];
if( bl[0] < br[0] )
x = br[0];

z = bl2[0];
if( bl2[0] < br2[0] )
z = br2[0];

jeep rotateTo( (x ,self.angleYaw, z), .2, 0, 0);
}
wait .2;
}
}

//***************************************
// Gas
//***************************************

jeepGas() {
self endon("intermission");
self endon("disconnect");
self endon("killed_player");
self endon("destroyed_jeep");
self thread jeepDriver();

jeep = self.jeep;
iState = 3;
iOldState = 0;
stateC = jeep.maxSpeed / 13;
while( isDefined( self.jeep ) && isDefined( self.jeep.driver ) && self == self.jeep.driver ) {

if( self meleeButtonPressed() == true && self attackButtonPressed() == true ) {
if( jeep.speed > 2 ) {
jeep jeepDecel();
jeep jeepDecel();
}
jeep jeepDecel();
iState = 2;
}
else if( self meleeButtonPressed() == true ) {
if( jeep.speed < -2 ) {
jeep jeepAccel();
jeep jeepAccel();
}
jeep jeepAccel();
iState = 2;
}
else {
if( jeep.speed > 2 ) {
jeep jeepDecel();
}
else if( jeep.speed < -2 ) {
jeep jeepAccel();
}
if( jeep.speed < 20 && jeep.speed > -15 )
iState = 1;
}
if( iState != iOldState )
jeep jeepPlaySound( iState );

iOldState = iState;
wait .1;
}
}

//***************************************
// Decel and Accel functions
//***************************************

jeepDecel() {

if( self.speed > self.minSpeed )
self.speed -= 1;

if( self.speed < self.minSpeed )
self.speed = self.minSpeed;
}

jeepAccel() {
iAccel = 1;
if( isDefined(self.passenger1) )
iAccel = .8;

if( self.speed < self.maxSpeed )
self.speed += iAccel;

if( !isDefined( self.passenger1 ) ) {
if( self.speed > (self.maxSpeed + 3) )
self.speed = (self.maxSpeed + 3) ;
}
else {
if( self.speed > self.maxSpeed )
self.speed = self.maxSpeed;
}
}

//*******************************************
// Detach player from jeep
//*******************************************

detachFromJeep() {
self notify("detached_player");

if( !isDefined( self.jeep ) ) {
self.jeep = undefined;
return;
}
jeep = self.jeep;

self.vehicle = undefined;

self.jeep = undefined;
if( isDefined( jeep.driver ) && jeep.driver == self ) {
jeep jeepStopSound();
self unlink();
self.jeep = undefined;
jeep.driver = undefined;
//releaseMiscObjective( jeep.objective );

d = anglesToRight( jeep.angles );

temp = vector_scale(d, -90 );
temp += jeep getOrigin();

self safeGround(jeep,120,50);
self enableWeapon();
self.cancelSprint = undefined;
}
else if( isDefined( jeep.passenger1 ) && jeep.passenger1 == self ) {
self unlink();
self.jeep = undefined;
jeep.passenger1 = undefined;

d = anglesToRight( jeep.angles );

temp = vector_scale(d, 80 );
temp += jeep getOrigin();

self safeGround(jeep,120,50);

self enableWeapon();
self.cancelSprint = undefined;
}
else if( isDefined( jeep.passenger2 ) && jeep.passenger2 == self ) {
self unlink();
self.jeep = undefined;
jeep.passenger2 = undefined;

d = anglesToForward( jeep.angles );

temp = vector_scale(d, -120 );
temp += jeep getOrigin();

trace = bulletTrace( temp + (0,0,100 ), temp + (0,0,-100), false, self );

self setOrigin( trace["position"] );
self enableWeapon();
self.cancelSprint = undefined;
}
}

detectCollition() {
self endon("intermission");
self endon("jeep_done");
self endon("destroyed_jeep");

while(true) {
origin = self getOrigin();
anglesF = anglesToForward( self.angles );
anglesR = anglesToRight( self.angles );

// Scan the FRONT and BACK first from left to right, bottom fender and upper

for( j = -40; j <= 40; j += 8 ) {
temp = vector_scale( anglesR, j );
temp += origin;
startPos = temp + vector_scale( anglesF, 25 );
endPos = temp + vector_scale( anglesF, 90 );

trace = bulletTrace( startPos + (0,0,45), endPos + (0,0,45), true, self );

ent = trace["entity"];
if( isDefined(ent) ||
(trace["surfacetype"] != "none" && trace["surfacetype"] != "default") ) {
self notify("trigger_col", ent, 1 );
self.colPos = trace["position"];
self.colSurf = trace["surfacetype"];
}

startPos = temp + vector_scale( anglesF, -65 );
endPos = temp + vector_scale( anglesF, -90 );

trace = bulletTrace( startPos + (0,0,45), endPos + (0,0,45), true, self );

ent = trace["entity"];
if( isDefined(ent) ||
(trace["surfacetype"] != "none" && trace["surfacetype"] != "default") ) {
self notify("trigger_col", ent, 2 );
self.colPos = trace["position"];
self.colSurf = trace["surfacetype"];
}
}

origin = self getOrigin();
anglesF = anglesToForward( self.angles );
anglesR = anglesToRight( self.angles );

// Scan sides, left first
for( j = -80; j <= 80; j += 8 ) {
temp = vector_scale( anglesF, j );
temp += origin;
startPos = temp + vector_scale( anglesR, -34 );
endPos = temp + vector_scale( anglesR, -45 );

trace = bulletTrace( startPos + (0,0,45), endPos + (0,0,45), true, self );

ent = trace["entity"];
if( isDefined(ent) ||
(trace["surfacetype"] != "none" && trace["surfacetype"] != "default") ) {
self notify("trigger_col", ent,3 );
self.colPos = trace["position"];
self.colSurf = trace["surfacetype"];
}

// right side
startPos = temp + vector_scale( anglesR, 34 );
endPos = temp + vector_scale( anglesR, 45 );

trace = bulletTrace( startPos + (0,0,45), endPos + (0,0,45), true, self );
ent = trace["entity"];
if( isDefined(ent) ||
(trace["surfacetype"] != "none" && trace["surfacetype"] != "default") ) {
self notify("trigger_col", ent,4 );
self.colPos = trace["position"];
self.colSurf = trace["surfacetype"];
}
}
wait .1;
}
}

//*********************************************
// Jeep Collition
//*********************************************

onJeepCollition() {
self endon("intermission");
self endon("jeep_done");
self endon("destroyed_jeep");

while(true) {
self waittill("trigger_col", ent,side );

if( isPlayer( ent ) ) {
self movePlayerBack( ent, side );
self attachPlayer( ent );
}
else {

self.damage += 1;

if( isDefined( self.collition ) )
return;

pos = self.colPos;
surf = self.colSurf;

if( self.speed < -2 || self.speed > 2 )
self.frontLeftTire playSound( "bullet_ap_" + surf, pos );

spd = self.speed;

if( spd < 0 && spd > 0 ) {
spd = spd - ( spd * 3 );
}

spd += 1;
if( isDefined( ent ) ) {
ent.colPos = pos;

ent notify("trigger_col", self, 1);
}

if( !isDefined(self.driver) )
spd += 150;
angles = vectorToAngles( self getOrigin() - pos );

anglesForward = anglesToForward( angles );
temp = vector_scale( anglesForward, spd * 3);

if( !isDefined(self.driver) ) {
trace = bulletTrace(self getOrigin() + (0,0,10) , (temp + self getOrigin()) - (0,0,100), false, self );
self moveTo( trace["position"] , .1,0,0.05);
}
else {
trace = bulletTrace(self getOrigin() + (0,0,50) , temp + self getOrigin(), false, self );
self moveTo( trace["position"] , .05,0,0);
}
self.speed = (self.speed - ( self.speed * 1.5 ) );
wait .3;
self.collition = undefined;
}
}
}

//***************************************
// move player back
//***************************************

movePlayerBack( ent , side) {
iRiding = 0;

ent.mback = true;

if( isPlayer(ent) && isDefined( ent.jeep ) && ent.jeep == self ) {
iRiging = 1;
return;
}

if( isPlayer(ent) && iRiding == 0 ) {
iMoving = 0;

a = vectorToAngles( ent getOrigin() - self getOrigin() );
a= anglesToForward( a );
if( side < 3 ) {
if( self.speed >= -5 && self.speed <= 5 )
temp = vector_scale(a,20);
else {
iMoving = 1;
temp = vector_scale(a,150);
}
}
else {
if( self.speed >= -5 && self.speed <= 5 )
temp = vector_scale(a, 22);
else {
iMoving = 1;
temp = vector_scale(a, 150);
}
}

if( !isDefined( ent.jeep ) || isDefined( ent.jeep ) && ent.jeep != self ) {
newPos = temp + ent getOrigin();

trace = bulletTrace(newPos + (0,0,100), newPos - (0,0,100), false, self);

if( self.speed >= -5 && self.speed <= 5 )
ent setOrigin( trace["position"] + ( 0, 0, 00 ) );
else {

eAttacker = self;
if( isDefined( self.driver ) && isPlayer( self.driver ) ) {
eAttacker = self.driver;
}
iDamage = self.speed;
if( iDamage < 0 )
iDamage -= iDamage ;
iDamage *= 3;

angles = vectorToAngles( ent getOrigin() - self getOrigin() );
vDir = anglesToForward( angles );
ent thread [[level.callbackPlayerDamage]](self, eAttacker, int(iDamage), 1, "MOD_EXPLOSIVE", "jeep_mp", ent getOrigin(), vDir, "none",0);

ent setOrigin( trace["position"] + ( 0, 0, 20 ) );
}
}
}
ent.mback = undefined;
}

//***************************************
// Attach Player
//***************************************

attachPlayer( ent ) {
jeep = self;

if( isPlayer( ent ) && isAlive( ent ) && isDefined( ent.pers ) ) {

if( isDefined( ent.vehicle ) )
return;

if( ent useButtonPressed() == true && !isDefined( ent.jeep ) ) {

while( ent useButtonPressed() == true ) {
if( isDefined( self.driver ) ) {
if( isDefined( self.driver.pers ) &&
self.driver.pers["team"] != ent.pers["team"] )
return;
}
if( isDefined( self.passenger1 ) ) {
if( isDefined( self.passenger1.pers ) &&
self.passenger1.pers["team"] != ent.pers["team"] )
return;
}
wait .1;
}

if( isDefined( self.driver ) ) {
if( isDefined( self.driver.pers ) &&
self.driver.pers["team"] != ent.pers["team"] )
return;
}
if( isDefined( self.passenger1 ) ) {
if( isDefined( self.passenger1.pers ) &&
self.passenger1.pers["team"] != ent.pers["team"] )
return;
}

if( !isDefined( jeep.driver ) ) {
jeep.driver = ent;
ent.jeep = jeep;

ent setOrigin(jeep.driverTag getOrigin() );
ent linkTo( jeep.driverTag );
ent thread detachPlayer();
ent disableWeapon();

ent.vehicle = jeep;
//getMiscObjective( jeep ,game["objjeep"],ent );
jeep jeepPlaySound(0);

wait 1;
jeep jeepPlaySound(1);

if( isDefined(jeep.driver ) )
jeep.driver thread jeepGas();

ent.cancelSprint = true;

return 1;
}
else if( !isDefined( jeep.passenger1 ) ) {

jeep.passenger1 = ent;
ent.jeep = jeep;
ent.vehicle = jeep;

ent setOrigin( jeep.passenger1Tag getOrigin() );

ent linkTo( jeep.passenger1Tag );

ent thread detachPlayer();
ent.cancelSprint = true;

return 1;
}
else
return 2;
}
else
return 0;
}
else
return 0;
}

switchPlaces() {
self endon("intermission" );
self endon("disconnect");
self endon("killed_player" );
self endon("detached_player");

jeep = self.jeep;
self iprintlnBold( "Press ^2H ^7to switch places!" );
wait 2;
self iprintlnBold(" \n \n \n \n \n \n ");
if( !isDefined( self ) )
return;

while( isDefined( self ) && isAlive( self ) && isDefined( jeep )) {
self waittill("key_h");

driver = jeep.driver;
passenger = jeep.passenger1;

if( isDefined( driver ) && !isDefined(passenger) || isDefined(passenger) && !isDefined(driver) ) {
if( isDefined( driver ) && self == driver ) {
jeep.driver = undefined;
jeep.passenger1 = self;

self setOrigin( jeep.passenger1Tag getOrigin() );
self linkto( jeep.passenger1Tag );

//releaseMiscObjective( jeep.objective );

self enableWeapon();
jeep jeepStopSound();
}
else if( isDefined(passenger) && self == passenger ) {
jeep.passenger1 = undefined;
jeep.driver = self;

self setOrigin( jeep.driverTag getOrigin() );
self linkto( jeep.driverTag );
//getMiscObjective( jeep ,game["objjeep"], self );
self disableWeapon();
jeep jeepPlaySound(1);
self thread jeepGas();
}
wait .5;
}
}
}

//***************************************
// Detach Player
//***************************************
detachPlayer() {
self endon("intermission" );
wait 1;
self.jeep.driverTag stopLoopSound( self.jeep.sounds[3] );

iHorn = 0;
jeep = self.jeep;
soundTag = jeep.driverTag;
soundFile = jeep.sounds[3];

self thread switchPlaces();
while(isDefined( self.jeep ) && isAlive( self )) {
iBeep = 0;
if( self attackButtonPressed() == true && self meleeButtonPressed() == false ) {
while( self attackButtonPressed() == true )
wait .1;

if( !isDefined( self ) )
break;
if( !isDefined( self.jeep ) )
break;

if( self meleeButtonPressed() == false && isDefined( jeep.driver ) && jeep.driver == self ) {
if( !isDefined( jeep.passenger1 ) ) {
jeep.driver = undefined;
jeep.passenger1 = self;

//releaseMiscObjective( jeep.objective );

self setOrigin( jeep.passenger1Tag getOrigin() );
self linkto( jeep.passenger1Tag );
self enableWeapon();
jeep jeepStopSound();
}
}
}
else if( self meleeButtonPressed() == true && self useButtonPressed() == true ) {
while( self useButtonPressed() == true) {
if( iBeep == 0 && isDefined( self.jeep ) && isDefined( self.jeep.driver) && self.jeep.driver == self) {
iBeep =1;
self.jeep.driverTag playLoopSound( self.jeep.sounds[3] );
}
iHorn += 2;
if( iHorn > 80 ) {
break;
}
wait .1;
}

if( isDefined( soundTag ) && isDefined( soundFile ) ) {
soundTag stopLoopSound( soundFile );
}
}
else if( self useButtonPressed() == true) {
while( self useButtonPressed() == true)
wait .1;

//self loadModel(self.pers["savedmodel"]);
self detachFromJeep();
break;
}
iHorn -= 1;
wait .1;
}

if( isDefined( soundTag ) && isDefined( soundFile ) ) {
soundTag stopLoopSound( soundFile );
}
}

spawn_jeep(j) {

origin = (-3350,-1705,-29) + (j*1.0934,j*(-0.312),j*0.01223);

jeep = spawn("script_model", origin );
jeep setModel( game["jeep"] );
jeep show();

anglesF = anglesToForward( jeep.angles );
anglesR = anglesToRight( jeep.angles );

temp = vector_scale( anglesR, -18);
temp += vector_scale( anglesF, -14);
jeep.driverTag = spawn("script_origin", jeep getOrigin() + (0,0,10 ));
jeep.driverTag linkTo(jeep);

//***********************************
// passenger location
//***********************************

temp = vector_scale( anglesF, -45);

jeep.passenger1Tag = spawn("script_origin", jeep getOrigin() + temp + (0,0,15 ));
jeep.passenger1Tag linkTo(jeep);

//***********************************
// turret Back passenger location
//***********************************

temp = vector_scale( anglesF, -50);

turrets = getentarray ("misc_turret","classname");

if(isDefined(turrets) && turrets.size > 0 ) {
}

//***********************************
// Front Left Tire
//***********************************

temp = vector_scale( anglesF, 50 );
tireOrigin = origin + temp;

temp = vector_scale( anglesR, -25 );
tireOrigin += temp;

jeep.frontLeftTire = spawn("script_origin", tireOrigin + (0,0,1) );
jeep.frontLeftTire linkTo( jeep );

//***********************************
// Front Right Tire
//***********************************

temp = vector_scale( anglesF, 50 );
tireOrigin = origin + temp;

temp = vector_scale( anglesR, 25 );
tireOrigin += temp;

jeep.frontRightTire = spawn("script_origin", tireOrigin + (0,0,1) );
jeep.frontRightTire linkTo( jeep );

//***********************************
// Back Left Tire
//***********************************

temp = vector_scale( anglesF, -40 );
tireOrigin = origin + temp;

temp = vector_scale( anglesR, -25 );
tireOrigin += temp;

jeep.backLeftTire = spawn("script_origin", tireOrigin + (0,0,1) );
jeep.backLeftTire linkTo( jeep );

//***********************************
// Back Right Tire
//***********************************

temp = vector_scale( anglesF, -40 );
tireOrigin = origin + temp;

temp = vector_scale( anglesR, 25 );
tireOrigin += temp;

jeep.backRightTire = spawn("script_origin", tireOrigin + (0,0,1) );
jeep.backRightTire linkTo( jeep );

maxspeed = getCvarInt("dvar_jeepMaxSpeed");
minspeed = getCvarInt("dvar_jeepMinSpeed");
if( maxspeed == 0 )
maxspeed = 36;
if( minspeed == 0 )
minspeed = -27;

jeep.sounds = [];
jeep.sounds[0] = "jeep_start";
jeep.sounds[1] = "jeep_idle";
jeep.sounds[2] = "jeep_move";
jeep.sounds[3] = "jeep_horn";
jeep.sounds[4] = "jeep_crash";

jeep.speed = 0;
jeep.maxSpeed = maxspeed;
jeep.minSpeed = minspeed;
jeep.jeepAngle = 0;
jeep.colPos = (0,0,0);
jeep.colSurf = "";
jeep.maxDamage = 10;
jeep.damage = 0;
jeep.vehicleType = "jeep";

level.jeeps[ level.jeeps.size ] = jeep;
jeep thread engineON();
return jeep;
}

jeepPlaySound(nSound ) {

if( isDefined( self.sounds[nSound] ) )
self playLoopSound( self.sounds[ nSound ] );

}

jeepStopSound() {
for(j = 0; j < self.sounds.size; j++ ) {
self stopLoopSound( self.sounds[j] );
}
}

//*********************************************
// *
//*********************************************

getDiff( rollNew, rollOld ) {

diff = 0;
if( rollNew <= -360 ) {
for(j = 0; j < 10; j++) {
if( rollNew <= -360 )
rollNew += 360;
else
break;
}
if( rollNew < -180 ) {
rollNew = 360 - rollNew;
}
else {
rollNew = ( 360 - (360 + rollNew ) );
}
}
else if( rollNew >= 360 ) {

for( j = 0; j < 10; j++ ) {
if( rollNew >= 360 )
rollNew -= 360;
else
break;
}
}

if( rollOld <= -360 ) {
for( j = 0; j < 10; j++ ) {
if( rollOld <= -360 )
rollOld += 360;
else
break;
}

if( rollOld < -180 ) {
rollOld = 360 + rollOld;
}
else {
rollOld = ( 360 - (360 + rollOld) );
}
}
else if( rollOld >= 360 ) {
for( j=0; j < 10; j++ ) {
if( rollOld >= 360 )
rollOld -= 360;
else
break;
}
}

if( rollNew > rollOld )
diff = rollNew - rollOld;
else
diff = rollOld - rollNew;

if( diff > 180 )
diff = 360 - diff;

if( diff < 0 )
diff = diff - ( diff * 2 );
return diff;
}

//*****************************************
// Precache Stuff *
//*****************************************

precacheStuff() {
game["jeep"] = "xmodel/vehicle_german_kubel_nomandy";
game["jeepd"] = "xmodel/vehicle_german_kubel_d";

precachemodel( game["jeep"] );
precachemodel( game["jeepd"] );

level._effect["libya_dust_kickup"] = loadfx ("fx/dust/tread_dust_libya.efx");
level._effect["vehicle_steam"] = loadfx("fx/smoke/vehicle_steam.efx");
level._effect["armoredcar_explosion"] = loadFX("fx/explosions/armoredcar_explosion.efx");
}

spawn_jeep(j)

spawn_jeep(j) {

origin = (-3350,-1705,-29) + (j*1.0934,j*(-0.312),j*0.01223);

jeep = spawn("script_model", origin );
jeep setModel( game["jeep"] );
jeep show();

anglesF = anglesToForward( jeep.angles );
anglesR = anglesToRight( jeep.angles );

temp = vector_scale( anglesR, -18);
temp += vector_scale( anglesF, -14);
jeep.driverTag = spawn("script_origin", jeep getOrigin() + (0,0,10 ));
jeep.driverTag linkTo(jeep);

origin = (-3350,-1705,-29)

origin = (x,y,z)

precacheStuff() {
game["jeep"] = "xmodel/vehicle_german_kubel_nomandy";
game["jeepd"] = "xmodel/vehicle_german_kubel_d";

precachemodel( game["jeep"] );
precachemodel( game["jeepd"] );

level._effect["libya_dust_kickup"] = loadfx ("fx/dust/tread_dust_libya.efx");
level._effect["vehicle_steam"] = loadfx("fx/smoke/vehicle_steam.efx");
level._effect["armoredcar_explosion"] = loadFX("fx/explosions/armoredcar_explosion.efx");

maps\mp\vehicles::main();

main()
{

maps\mp\_load::main();
maps\mp\vehicles::main();

setExpFog(0.0001, 0.55, 0.6, 0.55, 0);
// setCullFog(0, 16500, 0.55, 0.6, 0.55, 0);
ambientPlay("ambient_france");

game["allies"] = "american";
game["axis"] = "german";
game["attackers"] = "allies";
game["defenders"] = "axis";
game["american_soldiertype"] = "normandy";
game["german_soldiertype"] = "normandy";

setCvar("r_glowbloomintensity0", ".25");
setCvar("r_glowbloomintensity1", ".25");
setcvar("r_glowskybleedintensity0",".3");

}

name,sequence,file,vol_min,vol_max,vol_mod,pitch_min,pitch_max,dist_min,dist_max,channel,type,probability,loop,masterslave,loadspec,subtitle,compression,secondaryaliasname,volumefalloffcurve,startdelay,speakermap,reverb,lfe percentage

#Jeep
jeep_start,,vehicles/kubel_start.wav,0.6,0.8,,,,350,4000,auto,streamed,,looping,,jouwmapnaam
jeep_idle,,vehicles/jeep_idle01.wav,0.4,.6,,,,100,500,auto,streamed,,looping,,jouwmapnaam
jeep_horn,,vehicles/jeep_horn_loop.wav,0.9,1,,,,500,4000,auto,streamed,,looping,,jouwmapnaam
jeep_move,,vehicles/jeep_move01.wav,0.6,0.8,,,,500,3000,auto,streamed,,looping,,jouwmapnaam
vehicle_collision2,,vehicles/vehicle_hit_person.wav,0.7,0.9,,,,500,1000,auto,streamed,,looping,,jouwmapnaam