Project MCAR: BETA: 2

[PsyWarrior]

Greetings,

Psychic Productions is proud to announce the Public BETA release of Project MCAR!

Project MCAR is an attempt by a group of OFP enthusiasts to overcome one of the boundries of OFP editing: The inability to fire any kind of missile from 'Car' class units. MCAR is essentially a very complicated workaround, which simulates a guided missile launch from a vehicle.

From the perspective of the player, he aims his turret at the enemy unit, presses the trigger and a missile launches. It guides itself to the target (even if the target is in motion), hits it, and obliterates it.

The player has no idea what actually happened: He fired a machine gun bullet, which is 'caught' instantly by the scripting system, and removed. A missile is then created (along with particle effects, sound, etc.), and sent on it's way in the direction of fire. The system then checks to see what the player was aiming at, 'locks' onto it, and activates the guidance code to steer the missile to the target. The system instantaneously detects when the missile has hit it's target, explodes it, and the target is annihilated...

The above is one possible scenario. MCAR also works with AIs, with anti-aircraft missiles, and comes with a selection of guidance codes, including: One based on the 9m32 AA missile, one based on the TOW 2A (self guided) and one based on the TOW 2B. We also have another guidance code: The Realistic TOW 2A, which allows the player/ AI to guide the missile to its target, simply by moving the crosshair. Terrain following missiles are also possible with MCAR.

Also theoretically possible:
-MCAR with boats: Boats cannot fire missiles either, and there is no reason why MCAR should not work with these too. Untested at present.
-Shells: Also possible, but with much less guidance. Better than an explosive MG bullet, at least. Main advantage is a better shell explosion, and the fact that the player can actually see a shell instead of just a tracer.
-Grenade launchers: Same applies as above.
-Direct fire, unguided missiles (like FFARS).

MCAR's limitations:
-Kills are not recorded. This is because the player does not kill the unit - the missile does!
-MP Compatibility: MCAR is completely and utterly untested in MP. It may work, but it will very very likely not. If someone wants to test this, they are welcome to.
-BIS 'Crew' function does not operate with MCAR powered vehicles. We have included our own function to replace it: crew_mcar.

Usage:
[vehicle] call Crew_MCAR
Returns crew of vehicle.

Alright: Now the moment you've all been waiting for: The Files!

www.sunpoint.net/~wrathchalice/HTR_ofp/fls/psy_mcar_Beta2_01-06-04.zip

Okay: Download, play, test and report back what you find. That's the idea. What do you like? What do you dislike? What needs to be improved?

Please note that we are not looking for comments on the textures or modelling of the test platforms.

Have fun...

-Supreme Commander PsyWarrior
-Psychic Producions Command

[TM30]

thx man

you guys helping the ofp community to stay up

[Sa8Gecko]

here is an explanation of the various functions used in this
addon, for the ones interested who already depbo-ed the
files. Take note that this is not a deep explanation, but will
give you an idea of how things are made working, so you
can more easily 'navigate' through the scripts:

What follows is an explanation of the various functions, and of their
usage. I've omitted the PSY_MCAR_ prefix for readability.

*************************************
GENERAL FUNCTIONS
--------------
calcH

this is the very well known function by Vektorboson, returning the
absolute height above sea level of the ground above which the object
passed to the function is located (negative). That is, if you have a flying
plane of which you want to know the ASL, you call this function
this way:
- (plane call calcH)
and then add the value returned by 'getpos plane select 2'.
----------------
getLaunch

usage:
[object (MCAR type)] call getLaunch

returns:
[position of the more distant gamelogic from the vehicle, array containing the
difference between the two gamelogic positions]

This function is used to know which direction is facing the weapon (array) and
the starting location of the missile that will be created subsequently.
-----------------
hShooter

usage:
object call hShooter

returns:
number

returns the height above real ground of the object. It's useful when the object
is placed on top of a building, i.e. a bridge. The value returned by getpos
would be 0, infact. If the height of the object less than zero, zero is returned.
------------------
stayAfloat

usage:
object call stayAfloat

returns:
nothing

It's used to keep the AT missile from contacting ground during the initial search
routine.
------------------
trail

usage:
object call trail

returns:
nothing

generates AT missile smoke trail
-----------------
trail2

usage:
object call trail

returns:
nothing

generates AA missile smoke trail
-----------------
vNorm

usage:
array call vNorm

returns:
array (3 numbers)

array must have three numbers. It returns the normalized array of the one passed.
It's used mostly to know the direction the weapon is facing, as the array returned
contains the director cosines of the array passed to the function. It's vital for
targeting and guidance code. Normally the 2nd array returned by getLaunch is
passed to this function to be normalized.

********************************************
VEHICLE SPECIFIC FUNCTIONS
------------------
delta

usage:
[missile, target] call delta

returns:
number

Used to know if the missile is approaching the target, or it is leaving it behind,
as when the missile overshoot the target. The value returned is confronted with
the actual distance to the target, and if found greater, it means that the missile
has leaved the target behind. It's used in the proximity fuse code, to know when
to detonate the missile
------------------
detonate

usage:
missile call detonate

returns:
object used to detonate the missile, in this case 'RKT_detonator', that is
similar to RAD_chaff.

It's used to detonate the missile, simulating a proximity fuse. Can do without
this function, writing the code directly in the proximity fuse routine.
------------------
angle

usage:
[missile,target,Time of the previous call to this same function,turning rate (deg/sec)] call angle

returns:
[angle,time]
array containing the angle to be used in the successive setVelocity routine and the time
this function has been executed, to be passed again the next time the function will be called.

This function returns the angle of rotation the missile must assume to intercept the
target. If this angle is greater than the admitted turning rate in degrees/sec, this
is automatically adjusted to the max value. Time is used to calculate max angle, so
this function returns it, because next time the function is called it will need to know
the time it was called before, to determine the max rotation the missile can assume.
For example, if the function was called at time 10.880 and then again at time 10.920,
the time difference would be 0.04 secs, and assuming a max turning rate of 60 deg/sec,
in that time the missile could have rotated by .04*60 = 2.4 degrees.
Note that this is the heart of the lead collision guidance code. It operates in 2D only.
------------------
createProxyAA

usage:
vehicle(sa-9 gaskin) call createProxyAA

returns:
nothing

this function is vehicle specific, and it's tailored on the gaskin. It 'populates'
the gaskin with the gamelogics needed for weapon direction
------------------
dz

usage:
[missile,target, additional altitude] call dz

returns:
number

it returns the difference between missile and target ASL heights, adding the 'additional
altitude' value. The additional altitude value is used to make the missile fly a little
higher than the target.
------------------
initSearchAA

usage:
[shooting vehicle, direction of shooting (3d array)] call initSearchAA

returns:
a target, if found, or a proxy target ('Emptydetector'), just to have
something to aim the missile at

It's used in the initial target search of the gaskin. It searches along the
direction of firing for 3000 meters looking for a suitable target, that is
a plane or a chopper (it ignores parachutes). That's why a so high bullet
initspeed (10000) is used: to limitate AI deflection. Infact, if you add
for example a 2 degrees deflection to a target 3000 meters distant,
initSearchAA will not find it, because this target would be 100 meters off
the position searched with nearestObject.
-------------------
noCrewIn

same as getLaunch, is used instead of this when the vehicle cannot move, and
so OFP engine makes everyone aboard (gamelogics included) to disembark.
It's used in the case the human player would board such a damaged vehicle
and would open fire.
--------------------
searchAA

usage:
[shooter,missile,direction (3d array), step] call searchAA

returns:
[target (if found, or else a dummy one), next step]

this function is used in the case initSearchAA has found nothing. It is executed
in various steps to reduce lag. It searches in four additional direction 6 degrees
up,down, left and right from the current one, to try to eliminate deflection errors.
First target found is returned. missile is no longer used, but it is required.
It will be eliminated in a future version. The direction passed must be normalized
before, using vNorm. step is the distance at which to start again the seach, since
as explained before, the search is executed on a lenght of 700 meters a time.
--------------------
smokerAA

usage:
[3d array,3d array] call smokerAA

returns:
nothing

generates the smoke at missile launch. The first array contain a position, the
second one a direction. In the scripts these value are exactly the ones returned
by getLaunch.sqf, so the whole call it's simplified this way:
ammo = shooter call getLaunch
ammo call smokerAA
-------------------
tiltmissileAA

usage:
[missile, number] call tiltmissileAA

returns:
missile

It 'simulates' the tilting of the missile. Since as now there's not a function that
set missile pitch, we simulated this by building 13 missiles, each tilted 15 degrees
less or more than the previous one. Examinating the normalized velocity vector,
we can guess exactly how many degrees should the missile be tilted (that is, we
know the direction as regard to the zenith or nadir points). So, if the current missile
is not the one tilted the right way, it is substituted with a proper tilted one.
number, if equal to 1, triggers the substitution notwithstanding: it's used to
substitute the missile if this one is approaching is end life, since BIS missiles
have a max endurance of 10 seconds, while our 9M31 lives for 15 seconds.
-------------------
vz

usage:
[missile, target,additional altitude,missile speed,time,old vz] call vz

returns:
[vertical velocity, time]

missile, target and additional altitude as explained for dz. The other parameters
are needed to calculate the vertical velocity. This function adds the 3D parameter
to the lead collision guidance code (and prevents the missile from leading the
target in a step dive, so that the missile cannot be fouled pointing to the ground
and then pulling up at the latest moment). missile speed is total missile speed,
since vz (vertical velocity) can't exceed max speed. time is used as in angle.sqf,
but now it's the max velocity change rate in meters/sec. In our gaskin
it's limited to 90 m/s . old vz stands for old vertical velocity, and it's passed
to the function to calculate max value of the actual vertical velocity. It's also
used to evitate the missile to lead the target in a step dive, as explained before.
time, as in angle.sqf, must be sent back to the function when it is called again.

An explanation of the scripts will follow. More info upon
request. Feel free to message me for a deeper explanation.

[Sa8Gecko]

this is the second part of the above document, as
it was too great for a single post:

-------------------
launchMissile

usage:
[shooter, starting position (3d array), direction (3d array), missile type (string)] call launchMissile

returns:
missile (the missile being fired)

this function is used to launch the AT missile. Since a similar script could be interrupted
by OFP engine during its execution, and this could be real bad, we made it a function.
starting position is the missile creation position, as returned by getLaunch.sqf.
This position could be moved a little off this point if the vehicle is moving, to reduce
collision probability. missile type is the missile you want this function to fire.
direction, as usual, is the second array returned by getlaunch.sqf, normalized.
-------------------
createProxyAT

same as createProxyAA, only for the humvee
-------------------
dir

usage:
[missile, target] call dir

returns:
[angle, number]

this function returns the angle the missile must rotate to follow the target.
flag is used to know if missile should be considered to have lost lock on target,
in this case if its direction relative to target is more than 45 degrees.
--------------------
meters

usage:
[array (2d), missile] call meters

returns:
[number, missile position (3d array)]

Function used to calculate actual meters traveled by the tow missile, so that
after 3600 meters we can simulate a 'out of wire' condition.
The first array passed to the function is structured like the returned one,
that is it contains the meters travelled so far and the current missile position
on which to calculate the next distance traveled.
--------------------
noCrewInHumvee

like noCrewIn, only for the humvee
--------------------
search

usage:
[x component of the direction vector, y component of the direction vector,missile position] call search

returns:
target, if found, or else a dummy one

it is used to search for a target in case the first targeting routine has found nothing.
It returns the first target found. It searches for 300 meters on four directions spaced
each other 6 degrees, every 15 meters, for a suitable target. Only searches for targets
sitted on ground, no flying ones.
---------------------
search2

usage:
[x component of the direction vector, y component of the direction vector, z component
of the direction vector,missile,shooter] call search2

returns:
a target, if found, or else a dummy one.

It's used by the 'tow2a real', mostly to help the AI to hit moving and distant targets.
It can be useful even for human players, too, even if sometimes one would do better
without. This function is called (about) every fourth of a second, and scans a triangular
area in front of the missile, till 100 meters in front of it. A maximum of five targets
are stored in an array, and the one which lies nearer to the missile direction is selected.
Can target flying vehicles too.
---------------------
smokerAT

similar to smokerAA.sqf, but for the humvee
---------------------
subs

usage:
[missile,missile type (string)] call subs

returns:
missile

substitutes the current missile passed with a new one, of type 'missile type'.
missile type can even be not passed to the function: in this case a tow2a
missile is created.
---------------------
targetPos

similar to angle.sqf, but for the humvee. It's used by the 'real humvee' missile
to lead moving targets.
---------------------
towspeed

usage:
time call towspeed

returns:
speed in meter/sec

Used to assign the real humvee missile a realistic speed based on time elapsed
since missile creation. Such time is the value passed to the function.
----------------------
xchange

usage:
[missile,time,condition (number)] call xchange

returns:
[missile, condition]

every six seconds it respawns the missile, so that it can live till at least 20 seconds
(if it doesn't hit something before). condition is used not to make the missile being
substituted again when this function is called again and six seconds aren't elapsed yet:
for example, if the function would be called at times: 5.990 ,6.010, 6.030 etc, at time
6.010 it will substitute the missile, and would do that again at time 6.030 if condition
was not present to stop it. condition can assume value 0 or 1, and needs to be sent back
to the function itself next time this one is called.
***************************************************************************

[Armybikos]

Good job on finally getting TOW's on HMMWV's, and I especially like the TOW 2B option. Just some tips to make it more realistic.

1) Magnification on the TOW system varies depending if you are shooting an M220, and M220 ITAS or from a M2 Bradley but it is designed to engage targets all the way out to 3750 meters, your magnification on the TOW 2B version lower than your 2A (real) version, and the crosshairs a bit thick.The 2A system (real) seems excellent though.

2) When firing a live TOW there is approximately a 1.5 second delay after the trigger is depressed and the TOW launching, this is due to the gyroscope that stabilizes the TOW in flight needs kick in before the launch.

3) The TOW 2B only flies 1.5 meters above the target and does not arc into the air and come onto the target, the MCS just tells the TOW to fly 1.5 meters above where you have the crosshairs and when it magnetically detects the vehicle it fires it's dual tantulum warheads downward.

Over all this addon rocks, finally someone had overcome the no missile on whelled vehicle obstacle, and with a few tweaks this scripting will be a necessity for all further addons.

[h-]

First of all, thnx for the feedback.

Keep it coming

your magnification on the TOW 2B version lower than your 2A (real) version, and the crosshairs a bit thick.The 2A system (real) seems excellent though.

There's actually a bug in the TOW 2A and 2B sights, as they are not zoomed at all...
The difference between the zoom factor on the 'Real' Humwee and the rest was just that, we wanted the real be different from the rest, and the rest more 'BIS like'. (didn't we? ;D )

When firing a live TOW there is approximately a 1.5 second delay after the trigger is depressed and the TOW launching, this is due to the gyroscope that stabilizes the TOW in flight needs kick in before the launch.

Hmmm.. I think we were told the delay was 0.5 seconds...
Well, on low-end system there's definately a delay when firing...
But I think we can add that delay though...

The TOW 2B only flies 1.5 meters above the target and does not arc into the air and come onto the target, the MCS just tells the TOW to fly 1.5 meters above where you have the crosshairs and when it magnetically detects the vehicle it fires it's dual tantulum warheads downward

Yeah, it seems to 'jump' quite high, that TOW of ours...
This is relatively easy to fix, so it will be...

[PsyWarrior]

This topic is locked, due to the release of the BETA: 2.5.

-Psy|W

#Locked.