Mando Missile doesnt require any extra addon to work, but you may use missile objects (or vehicles/planes/choppers) present in any existing addons as missile bodies for Mando Missiles (Missile object class name) as well as missile launchers.
Mando Missiles comes also as addon, in case you dont want to use the script suite (mando_missiles folder) in your mission. Placing Mando Missile ArmA gamelogic in your mission ensures addon dependency, the gamelogic also executes mando_missileinit.sqf automatically. If you want to use the addon, but not the gamelogic, then you'll need to execute mando_missileinit.sqf from your mission init.sqf script.
General speaking, to fire a missile requires only to execute a single
script, setting up an AI launcher for a particular vehicle requires also
the execution of a single script, enabling a type of launchers for players
for a particular vehicle type or list of types requires also the execution
of a single script, providing chaff/flares protection for an AI unit requires
the execution of a single script too. The complexity is not in the number
of scripts you need to execute, but in the correct parametrization of the
arguments required by these scripts to achieve the desired result.
Back to index
| What is? | Description |
| A mando missile | It is an moveable object, usually an existing ammo or vehicle (ArmA
Ammo classes and ArmA
Vehicle classes), which is accelerated and guided till reaching a target.
Once the target is reached, a custom detonation script is executed which
might include special FX as well as a real explosion. These missiles might
detonate based on proximity or collision. If you set them to explode upon
collision (proximity range set to 0), and the body of the missile is an
explosive existing ammo type, the target will receive the normal damage
caused by an standard shot of that ammo against the target. If you added
a real explosion effect to the detonation script, the target will receive
the damage of the ammo hit plus the damage caused by your custom explosion.
If the missile detonation is configured by proximity, the target will receive
the damage only from the custom explosion. Note that the detonation script
might spawn a second missile, for example to simulate the launch of an
ASROC rocket, where the detonation of the first "missile" (the rocket)
would spawn a torpedo which is the missile that will hit the target.
Mando missiles have two primary guidance modes: inertial and active. In inertial mode the missile will fly towards a calculated position where it should switch to active mode with good chances of "seeing" the target there. While in inertial mode, you may also configure periodical target position updates, so the missile will keep applying trajectory corrections every indicated number of seconds. While in inertial mode, the missile will try to keep the indicated cruise altitude above initial target's altitude (which gives it a limited terrain avoidance capability). Once the missile switches to active mode, and if the target is inside its cone of view, the missile will guide towards the target with constant updates. While flying in inertial mode, the missile cannot be affected by chaff/flares, countermeasures are only effective against missiles flying in active mode.
Another important characteristic of the missiles is that they might be (or not) detectable by radar. Missiles marked as detectable might be tracked and intercepted by missile launchers with anti-missile capability. Mando Missiles might be configured also for terrain avoidance. If the missile is terrain avoiding capable, it will keep tracking the terrain in front of it and will try to keep avoiding terrain elevation while keeping as close as possible to the indicated cruise altitude above target's atitude. Missiles flying in active mode will not try to avoid the terrain at all. |
| AI launcher | It might be a vehicle, building, soldier or even gamelogic which will
work as automatic missile launcher. Enemy sides, antimissile capability,
detection ranges, rate of fire, missile parameters, etc are provided to
configure the launcher. The launcher might be initially active or not,
there is a script to activate or deactivate it at will (if the AI launcher
has an AI unit assigned: driver, commander or gunner, and this unit is
combat mode GREEN or BLUE, the system will remain unactivated). When active,
the launcher will engange targets by its own. If close enough to a missile
provider, it will also reload missiles automatically when needed. Many
launchers may be present for the same vehicle, for example a big battleship
with a SAM launcher, SSM launcher and ASW launcher. Note that vehicles
with automatic launchers might have also visual and/or MCC systems for
players. Using the previous example, the battle ship might have an automatic
SAM and the SSM and ASW systems available for players too.
AI
missile launcher working with AI Mando Guns in YouTube
|
| Visual launcher (visual lock) | A vehicle that will be used by players to have a visual locking-on/firing
system. These systems might include one or more of the following: HUD to
track locked-on targets and to lock on targets, show number of AG and AA
missiles left as well as countermeasures and upper/right RWR showing incomming
missile bearings and position and bearing of the launcher over the map.
It is possible also to configure the Visual launcher without hud and without
RWR display. The visual launcher might have (or not) missiles and /or counter
measures. Keyboard is used for locking on targets, firing missiles and
launching countermeasures (the keys are configurable). Menu actions are
used to select the target type, for example AA mode or AG mode,etc.
Missile loadout of a visual launcher might be configured to have AG weapons and/or AA weapons. For example, 4 AA missiles and 2 AG missiles (which might be also guided bombs). The purpose of the AA missiles is clear, enganging aerial targets. But for the AG weapons you indicate which kind to targeting is available for the launcher: anti-radar (SEAD), AG with boresight locking, structures (buildings) with boresight locking, remote targeting to be able to lock on remotedly locked-on targets (for example, laser designator manned by another unit, or preconfigured targets for the mission). A vehicle, for each position (driver, gunner or commander), should have a maximum of a single visual system attached. For example, a "enhanced" Cobra with a visual system for the pilot with 2 Sidewinders, flares and RWR, and another system for the gunner with four manually guided TOW missiles, but without control over flares and no RWR.
SEAD
visual launcher in YouTube
|
| MCC launcher (radar lock) | Missile Control Center is a dialog based system to track down targets
and fire missiles. You may attach several MCC systems to any position in
the launcher vehicle (driver, gunner or commander). MCC system should not
share the same position (driver, gunner or commander) of a existing visual
launcher system because graphically both systems will interfere with each
other. But, for a single vehicle you may combine MCC with visual launchers
as long as they dont share the same position (driver, gunner, commander).
For example, a Su34 with a visual launcher system for the pilot including
HUD, RWR, 2 short range AA missiles and countermeasures, and then two MCC
systems for the gunner, one for long range interception with 4 missiles
and another to engange AG targets with 4 missiles. In this example, while
the pilot try to avoid incomming enemy missiles controlling the countermeasures,
the gunner may use its long range interception console to track down and
intercept the incomming bandints (similar mechanism than that used by a
F14 Tomcat).
As for the visual launcher, for MCC you also configure the type of targets that might be detected and tracked down by each MCC systems: air units, missiles, radars (AI launchers or other MCC launchers turned on), remote targets, ground and sea targets or even structures (buildings).
|
| Missile replacement | Several ArmA units already use missiles (Su34, AV8B, Strella, Stinger,
Javelins, TOWs, Hellfires). Using a script provided in this suite you may
configure a unit to have any ArmA "stock" missile fired against it, replaced
automatically by a mando missile one. You may modify at will the mando
missile parameters of the missile which will replace the ArmA stock one.
For example, the replacement missile of the Stinger might be slower and
with a much limited seeker detection arcs, to reduce a lot the lethality
of that missile type fired against choppers. Any ArmA stock missile replaced
by a mando one will also be affected by countermeasures.
Rememner that the missile replacement is configured for the potential targets, not for the missile launchers. |
| Counter measures | Chaff or flares dropped by players or automatically by AI units able to avoid incomming missiles working in active mode. |
| Remote target | A target locked on by a unit different than the launcher. For example a laser designator target or targets provided by a script (You may use a provided script to add targets to the remote target array of the desired side (west, east, ...). These targets are immediately available to remote targeting capable launchers depending on the side. So, west remote targets are not "available" for east remote targeting units and so on. Remote targets can be enganged by visual launchers, MCC launchers and AI launchers. |
| Radar target | When an AI launcher switches ON, or when a MCC system is activated, the corresponding vehicle becomes a radar target. Anti-radar capable units are able to lock on any active radar target in the map while the radar of the target is turned on. Radar targets are not sided for the anti-radar units, so you may also lock on friendy active missile launchers. |
| Missile/countermeasures loading unit | Any vehicle type, or object type might be configured as missile/countermeasures provider. If you are close enough to one of them, you will have an action menu to reload missiles, chaff or flares. AI launchers which move or which are close to these providers, will reload missiles automatically. You set up the initial quantity of resources of these loading units, this quantity is reduced proportionally when a launcher reloads its missiles or countermeasures. |
| Custom warhead | A custom script that will be executed when the missile detonates. A
missile detonates when it gets damaged, when it is closer to the target
than the detonation range or when the missile distance to the target, being
closer than 50m, increases (the missile has been outmaneouvered by the
target). The custom warhead will generate any special smoke effects needed
for the explosion, will create a real detonation using existing ammos and
will apply the corresponding increase or decrease in score to the crew
members of the launcher. Most ArmA ammo types have a short life period,
once elapsed ArmA will delete the object automatically. If this happens
before the missile has reached the target, the custom warhead script will
be executed onsidering the last known position of the missile object before
its deletion (list
of ArmA ammo life times).
If you want your missile to cause damage by direct impact (setting its detonation range to 0), then you will not want to add more damage in the custom warhead script. In this case the custom warhead script should not spawn ammo to cause a second explosion. |
| Custom exhaust smoke | A custom script that will be executed as soon as the missile turns its engine on. This script might generate the missile engine smoke trail as well as water or dust effects when the missile flies low over terrain or water. |
| Custom launch effects | A custom script that will be executed as soon as the missile is launched (note that the missile might be dropped with its engine off too). This script might generate any special visual or sound effects related to the launch of the missile. |
| Missile ranges | General speaking, a missile in flight has four main phases:
- Acceleration. - Max speed, while still thrusted (engine on). - Engine off (no more fuel) and decceleration. The missile is still under control and guidance is effective. - Stall. Speed is not enough to keep any practical target tracking. The maximum effectivity of a missile against maneouvering targets is attained while it is inside the Max speed thrusted flight range.
Thrusted range:
Max thrusted range = 1/2*(MS^2)/AC + IS*MS/AC + MS*(ET-MS/AC) For example, for a missile with 6 secs endurace, top speed of 800 m/s
and an acceleration of 180m/s^2:
Thrustless range:
Once the speed of the missile goes below its stall speed, the missile will fall to the ground like a rock, and while it might recover some speed while falling to the ground, it cannot be considered effective at all to pursue a moving target. So, unless the target is a bit below and quite close to the missile once it stalls, the chances to score a hit would be minimal or null. |
| Missile index | Missile index numbers are assigned to each missile type present in a launcher for players (visual, MCC or a mix of both). When you add an MCC to a vehice, you need to indicate the missile index number for the missiles that this particular MCC console will use, so, when you fire a missile using this console, the quantity of missiles of this particular missile index is adjusted substracting one. Visual launchers always use two indexes, the index base is for AA missiles and the index base + 1 for AG missiles (even if the unit has no AA and/or AG missiles). For example, a Su34 with a visual launcher for the pilot with missile index = 0 (2 AA missiles for index 0 and 0 AG missiles for index 0+1), then a MCC console for the gunner with 6 AA missiles using missile index 2 and a second MCC console with 4 AG missiles with missile index 3. Make sure different missile systems present in the same vehicle do not share missile indexes, else the count of missiles left for each system might get messed up with the count of missiles left of a different system. |
| MCC Mark | MCCs have always a maker which might be used for navigation or, in some cases, for targeting. When you click over the left bottom map of a MCC, you change the position of that mark. |
| Line Of Sight (LOS) | All Mando Missile ArmA launchers (AI or manned) do LOS checks before
enganging a target or before allowing you to lock on a target, with the
following exceptions:
- Radar targets: radar emitters considered as targets by SEAD units. - Remote targets: These are locked on by others units (which do LOS checks) and remote targeting capable units will be able to engange them without LOS checking. - Underwater targets or underwater launchers. If the launcher is underwater or the target is underwater, no LOS check is performed. - MCC Mark.  |
If you want to use the script suite version:
1 - Copy "mando_missiles" folder into your mission folder.
2 - Open your description.ext file (or create a new one if you are
not using one already) and make the following changes:
// description.ext
// Needed for Mando Missile ArmA
#include "mando_missiles\mando_missile.h"
// Add here your dialogs, resource types, etc.
class RscTitles
{
// Needed for Mando Missile ArmA
#include "mando_missiles\mando_missiletitles.h"
// Add here anyother title resource you need
};
class CfgSounds
{
sounds[] = {};
// Needed for Mando Missile ArmA
#include "mando_missiles\mando_sounds.h"
// Add here anyother sound you need
};
// End of description.ext file
3 - If you dont have one already, create the file init.sqf or init.sqs
and before anyother MMA script execution add:
// Mando Missile ArmA initialization for init.sqf
[]execVM"mando_missiles\mando_missileinit.sqf";
Sleep 2;
If you want to use the addon version:
Make sure mando_missiles.pbo is in your addons folder.
Then you can:
- Place a Mando Missile ArmA gamelogic in your mission map.
or
- Execute mando_missileinit.sqf script from your
mission's init.sqf script.
// Mando Missile ArmA initialization for init.sqf
[]execVM"mando_missiles\mando_missileinit.sqf";
Sleep 2;
| Parameter | Meaning |
| Launcher | Vehicle, unit, object or gamelogic that will launch the missile. This parameter might be also objNull, in this case the firing coordinates will be absolute ones and not relative to the launcher. |
| Missile object class name | The class of the missile body object. Usually an existing ammo class
name or vehicle class name. For a list of existing ammo and vehicle classes
check ArmA
Ammo classes and ArmA
Vehicle classes. For example, "M_Stinger_AA". If you use an ammo class
name, consider that all of them have a pre-configured life-time (list
of ArmA ammo life times), once that time elapses, ArmA will remove
the object automatically. If this happens, the missile script will trigger
the warhead detonation at the last known position of the missile object
before its automatic deletion.
You may also use any existing vehicle or ammo class name present in any third party addon. |
| Initial firing position | If launcher is not objNull, coordinates relative to the launcher (model coordinates), else, absolute map position. This position is where the missile will be created at launch time, make sure the position doesnt collide with the launcher unit or with the terrain. |
| Initial horizontal direction | Initial horizontal heading of the missile in degrees at launch time. |
| Initial vertical angle | Initial vertical angle, or elevation of the missile at launch time. If the launcher is a vehicle, this angle is added to the current inclination of the launcher. The resulting angle will be rounded to never exceed -89 or 89 degrees. Relative launcher coordinates are in the format [left-right, backward-forward, below-above], for example [-5, 10, 2] means 5m to the left, 10m in front and 2m above the center of the launcher. |
| Initial speed | Speed at launch time in m/s, this speed is added to the speed of the launcher. |
| Maximum speed | Maximum speed of the missile in m/s. The missile will accelerate until this speed is reached. |
| Acceleration factor | This determines the acceleration of the missile once its engine is turned on and while its engine keeps on. m/s gained every second in v2.3 (factor between 1 and 15 for v2.2 and older versions). |
| Target | Vehicle, object or gamelogic targeted by the missile. |
| Detonation range | If missile is closer than this to the target, the missile will detonate its warhead. 0 means direct impact. |
| Missile inboard seeker range | When the missile flies in mode 2 (active seeker), this is the detection range. If the target is not within this range when the missile switches to active mode, the missile will go without guidance. |
| Initial operation mode | 0: Inertial, the missile climbs or dives until cruise altitude + target's
altitude is reached, then it switches to mode 1.
1: Inertial, trying to keep the indicated cruise altitude + target's altitude, the missile flies towards a pre-calculated point where it will switch to mode 2. This precalculated interception point is updated at launch time and, if so indicated, every '#' seconds. This way the missile will fly in inertial mode with periodic target position updates. 2: Active mode: If the target is within seeker scanning arcs and inside active seeker range, the missile will guide directly to the target following an interception or direct collision course (see below). |
| Average cruise altitude | Altitude to keep while flying in modes 0 and 1. This is altitude over target's altitude. |
| Warhead script | A custom script that will be executed when the missile detonates. |
| Smoke trail script | A custom script that is executed when the missile turns is engine on. This script might generate all the smoke special FX needed for that particular missile. If you are using a missile object which generates its own smoke, you might set this to "" so no custom smoke will be added to the missile. |
| Missile engine sound | The name of an existing sound present in description.ext, "" if none. This sound will be generated when the engine is turned on and every indicated number of seconds (see below). |
| Missile sound duration | Missile sound file duration in seconds, the missile will repeat that sound once the duration is elapsed and only if the missile engine is still on. |
| Endurance | Once the missile engine is turned on, it will keep tuned on this quantity of seconds. Once the endurance time is elapsed, the missile will fly thrustless. |
| Terrain avoidance? | If set to true, the missile will keep scanning the terrain elevations in front of it while flying in inertial mode 1. The missile will take evasive maneouvers to try to avoid the terrain elevations while trying to keep the indicated cruise altitude. |
| Frequency of mid-course corrections | While flying in inertial mode 1, this quantity of seconds determines the frequency of mid-course target position updates. If you set here a number of seconds greater than missile engine endurance time, the missile will fly in inertial mode without any target update (except the very first one at launch time). No corrections means that the missile flying in inertial mode might see "nothing" once it reaches the activation point (when it switches to mode 2) because the target has changed its direction while the missile was still flying in mode 1 (see picture above). |
| Time to switch missile engine on | In seconds, the time between missile creation and engine activation.
Use this to create the effect of a missile being dropped from a plane and
turning its engine on 1 or 2 seconds later. The missile will be guided
and accelerated by the script once its engine is on. Note that some existing
ammo classes have built-in engines (most existing ArmA missiles and rockets),
so once these objects are created they will start flying "guideless" immediately.
For these types of objects use a 0 for this parameter to make sure mando_missile
script takes control over them immediately.
Use values greater than 0 only if the missile has "space" to fall down, else it will collide with ground, sea or the launcher as soon as the missile object is created. |
| Guidance delay | In seconds. This is the time the missile waits after being fired and before using any guidance (inertial or active). For example, you might want to fire a missile with a particular orientation and elevation, and have the missile following that orientation and elevation few seconds before turning on its own guidance (inertial or active). A typical case of vertically launched ICBMs. |
| Detectable? | If set to true, anti-missile capable launchers will be able to detect this missile and fire against it. |
| Debug? | If set to true, telemetry missile info will be stored in some global
variables:
mando_missile: the missile object itself. mando_missile_follow: Missile tracking target or not. mando_missile_mode: Current flying mode (0, 1 or 2) mando_missile_emergency: Emergency climb or not (only if missile terrain avoidance is set to true) mando_missile_distance: Distance to destination (target in active mode or space activation position in inertial modes) mando_missile_endurance: Engine endurance left in secods. This information is used, for example, by lower-right info panel of the MCC dialog. So, all MCC units fire the missiles with debug info set to true. |
| Launch FX script | A custom script that will be executed at launch time to create any special smoke, dust, etc FX for the missile lauch. "" if none. |
| Horizontal agility level | Max turn rate in degrees per second in 2.3 (agility factor between 1 and 15 for v2.2 and older versions) |
| Vertical agility level | Max turn rate in degrees per second in 2.3 (agility factor between 1 and 15 for v2.2 and older versions) |
| Accuracy | 0.001 min to 1 max. This determines how easy might be for the missile to "know" where the target is while flying in active mode 2. Low accuracy missiles might have many tracking interruptions so the missiles might have an erratic target tracking which might end in a total tracking lost. |
| Interception mode? | true or false while flying in active mode 2. true = interception course,
false = collision course.
If interception mode is set to true, the missile will not aim directly to the target, but at an interception position calculated based on target heading and speed and missile position and speed at every time. |
| Horizontal scan arc / 2 | Left-Right arc from the missile's nose for active mode target scanning in degrees divided by 2. |
| Vertical scan arc / 2 | Up-Down arc from the missile's nose for active mode target scanning in degrees divided by 2. |
| Z-offset | Offset in meters above or below (negative value) target's vertical center where the missile will aim. For example, a torpedo might need to use a negative Z offset to make sure it will aim at a point below target (ship) flotation level. |
| Minimum countermeasures extent | If this parameter is not provided, the value passed to mando_missiles\mando_missileinit.sqf
will be used, if no value was passed to mando_missileinit.sqf, the default
value of 25 will be used.
If distance between missile and target is smaller than distance between missile and countermeasure + this value, the missile will follow the countermeasures. |
When you fire a missile using Mando Missile Lab, the bottom edit box
is updated with the firing parameters array, this array is directly usable
by mando_missiles\mando_missile.sqf script in your missions (remember
to execute mando_missiles\mando_missileinit.sqf first).The only
variables to be set are _launcher and _debug, set _launcher to the name
of the launcher unit you want to use, and _debug to false or true in case
you want to have telemetry data. For example:
_launcher = mytank1;
_debug = false;
[here goes the content of the resulting bottom
line]execVM"mando_missiles\mando_missile.sqf";
You may use mando_missile_test.Sara demo mission to test parameters configured with mando missile lab.
To understand better how to get the desired flight profile, lets start
step by step with the different phases of a missile launch:
1 - The missile object is created with an intial indicated orientation
(heading and elevation) relative to the launcher. The missile gets the
speed of the launcher.
2 - If so indicated, the missile waits to turn on its own engine. If
the missile was created in the air, the missile will fall down while advancing
a bit based on speed of the launcher unit at launch time.
3 - The missile turns on its own engine.
4 - If so indicated, the missile keeps current course as many seconds
as indicated in "Guidance delay".
5 - The missile activates its guidance. If initial guidance is mode
0, the missile will climb/dive until reaching cruise altitude while keeping
its current heading, once the altitude is reached, the missile switches
to mode 1, if guidance is mode 1, the missile will try to match its altitude
with cruise one, while heading towards a calculated mode 2 activation point.
While the missile is in flying in mode 1, it might get periodic updates
of target position, so new mode 2 activation points are calculated the
the missile will keel correcting its trajectory, once the mode 2 activation
point is reached, the missile switches to mode 2 (active). In mode 2 the
missile will check whether the target is inside its cone of view, and if
the target is visible by the missile, the missile will pursue it in active
mode, with constant target postion, heading and speed updates.
6 - Final guidance, mode 2. If the target is inside missile's cone
of view (determined by horizontal and vertical scan arcs), then if the
missile was fired in intercept mode, the missile will track the traget
following a lead pursuit path, if will follow an continuously calculated
interception position based on heading and speed of the target. If the
missile was fired in not-interception mode, then the missile will track
the target following a pure pursuit trajectory, aiming directly to the
target.
The following figure shows some basic profiles for a ground or sea launched missile:
Profile A:
The missile is fired in initial mode 0 and already pointing up (initial
vertical angle of 75 degrees). The missile will climb and "cross" the barrier
of the specified cruise altuitude, then it will switch to mode 1. In mode
1 the missile will try to dive to match the indicated cruise altitude and
then will try to keep it until the target is withing missile active seeker
range. Then the missile switches to mode 2 for the final aproach.
Profile B:
Quite similar to profile A, but this time the initial vertical angle
is set to "auto" (this is achieved setting it to 90 degrees). So the missile
is launched pointing at the position in space already at cruise altitude
where it will switch to mode 1. In Profile A the missile was fired almost
vertically, so the missile was "forced" to turn vertically to match the
cruise altitude. In this second example, the missile is already oriented
so the missile will reach mode 1 altivation point with little corrections
or none. Once in mode 1 it will keep moving towards the mode 2 activation
point while keeping the indicated cruise altitude.
Profile C:
The missile is fired already in mode 2 (active mode), but with an initial
slight elevation of 35 degrees. The missile, flying in mode 2, will correct
its inclination to aim to the target, and the curve will be determined
by the missile's vertical agility turn rate in degrees per second. If the
agility is too high, as soon as the missile is fired pointing up 35 degrees,
the missile will correct this deviation and the resulting trajectory will
be much flatter. If the vertical agility is low, the missile will take
more time to change from the initial 35 degrees pointing up to the correct
inclination going down to "track" the target. In this case the trajectory
would be more elliptical.
Profile D:
Similar to A and B, but this time the missile is fired with a quite
low vertical inclination, for example, 2 degrees.
Profile E:
Similar to C, but the guidance delay is set to 0.5 or even 1 second.
The missile is fired with an inclination, and the missile will keep the
original inclination and bearing for the indicated "guidance delay" period.
So, the missile will keep going up (guideless) and then guidance is switched
on (in this example, using mode 2 as initial firing mode, but you may use
also mode 1 or mode 0). You may always play with vertical maximum turn
rate to adjust the initial flight profile until the missile really starts
to pursue the target. For example, you fire a missile almost vertically
against a target 10Km away flying at 1000m. The vertical turn rate is,
for example, 25 degrees per second. So the missile, while going up will
start turning in the vertical plane (trying to level the nose), and the
missile's nose will point in the general direction of the target after
about 3.5 seconds. During this period, the missile has been, basically,
going up all the time with its original inclination moving from 85 degrees
to near 0 degrees as, in the process, the missile has climbed close to
1000m, so now the missile is almost at the same level of the target and
heading towards it.
Back to index
| Folder | Content description |
| mando_missiles | main folder, everything related to MMA is inside it as well as the main script mando_missile.sqf. |
| mando_missiles\command | MMA Command related scripts (currently in beta stage). |
| mando_missiles\exhausts | scripts for missiles exhaust smoke effects, you may use the existing ones as templates for your own ones. |
| mando_missiles\launch | scripts for missile launch effects, you may use the existing ones as templates for your own ones. |
| mando_missiles\mcc | Mando Missile Control Center related scripts (MCC vehicles for players). |
| mando_missiles\mcc\mcc_types | Several types of already customized MCCs, you may use the existing ones as templates for your own ones. |
| mando_missiles\Sounds | MMA default sounds. |
| mando_missiles\units | AI armed missile vehicles scripts as well as non MCC missile armed vehicles por players |
| mando_missiles\units\attackers | AI armed missile already customized units, add there your own ones. All the scripts present here are customized ways to execute mando_missileattacker.sqf |
| mando_missiles\units\keysets | Player armed missile (non MCC) customized launchers (visual launchers) |
| mando_missiles\warheads | missile detonation scripts (scripted warheads) |
| Folder and script | Purpose |
| mando_missiles\mando_missileinit.sqf
(Main mando missile initialization script) |
Initialize MMA, execute it before anyother MMA script in every client and server computer. |
| mando_missiles\mando_missile.sqf
(Main missile script) |
Fires a individual missile from launcher or position to target. You may execute this script individually to fire a single missile from a unit or object against another one (to fire a missile, execute this script in a single client or the server, else you might fire many copies of the same missile at the same time). This script is executed automatically by all the scripts supporting AI launchers or player manned launchers (visual or MCC). |
| mando_missiles\mando_replacemissile.sqf | Do not execute it, as the system does it automatically, but modify it at will to customize any ArmA missile you want to be replaced automatically by a MMA one. |
| mando_missiles\createDialogMissileTrack.sqs | Creates an small dialog to track info of in-flight missile launched in debug mode, similar to the in-flight info shown in the MCC console (lower-right MCC panel). |
| mando_missiles\command\mando_comallow_by_name.sqf | Waits until a player is inside a vehicle which name is in the provided array and adds the menu action to activate the Missile Command. (BETA) |
| mando_missiles\command\mando_comallow_by_type.sqf | Waits until a player is inside a vehicle which type/class is in the provided array and adds the menu action to activate the Missile Command (BETA) |
| mando_missiles\mcc\mando_mccallow_by_name.sqf
(MCC missile launcher for players) |
Waits until a player is inside a vehicle which name is in the provided array and adds the menu action to activate the Missile Control Center (MCC) |
| mando_missiles\mcc\mando_mccallow_by_type.sqf
(MCC missile launcher for players) |
Waits until a player is inside a vehicle which type/class is in the provided array and adds the menu action to activate the Missile Control Center (MCC) |
| mando_missiles\units\mando_addremotetarget.sqf | Use when needed to add a remote target to the list of remote targets available for a particular side. Execute it only from a single client or the server each time. The new target will be available for every unit capable of remote targeting for specified side until the target is destroyed or deleted. |
| mando_missiles\units\mando_assignvehicle_by_name.sqf
(Visual missile, chaff, flares launcher for players) |
Waits until a player is inside a vehicle which name is in the provided array and activates the indicated non MCC missile system (visual aiming). |
| mando_missiles\units\mando_assignvehicle_by_type.sqf
(Visual missile, chaff, flares launcher for players) |
Waits until a player is inside a vehicle which type/class is in the provided array and activates the indicated non MCC missile system (visual aiming). |
| mando_missiles\units\mando_attackeronoff.sqf | Execute it when you need to activate or deactivate one or several AI missile attacking systems. Deactivated system will not engange enemies by their own, deactivated systems will not be considered as potential targets by anti-radar systems. |
| mando_missiles\units\mando_flaresreloadallow.sqs | Indicates which object/vehicle types will be valid to reload flares/chaff. Execute this in every machine with a player if you want him to be able to reload flares/chaff. Note that AI launchers are also able to reload flares/chaff if they are close to one of these units. |
| mando_missiles\units\mando_haveialaser.sqf | Checks if the player has an ArmA laser designator to provide him actions to transmit laser target as remote target to other missile armed units of the same side remote targetting capable. Execute this in every machine with a player if you want him to be able to transmit his laser targets to be targetted by other missile armed units able to lock on remote targets. |
| mando_missiles\units\mando_missileattacker.sqf
(AI missile launcher) |
Makes an AI unit able to lock on enemy units, radars, remote targets or even incoming missiles and fire missiles by its own. If you dont want to mess with all the parameters needed by this script, you may use any of the preconfigured missile attackers using the scripts present in mando_missiles\units\attackers folder (or create your own customized AI missile launchers based on the scripts present there). Execute this script on the server. |
| mando_missiles\units\mando_missileecm.sqf
(AI chaff/flares launcher) |
Gives an AI unit chaff/flares to defend itself against incoming mando missiles automatically. Execute it only in the server (or there where the unit is local). |
| mando_missiles\units\mando_missilereloadallow.sqf | Indicates which object/vehicle types will be valid to reload missiles. Execute this in every machine with a player if you want him to be able to reload missiles. Note that AI launchers are also able to reload missiles if they are close to one of these units. |
| mando_missiles\units\mando_onlymandoones.sqf | Execute this in the init field of a unit when you want any missile fired against it to be replaced by the corresponding mando one. If the unit is created (or respawned) within a script, _createdunit SetVehicleInit "res = [This] execVM ""mando_missiles\units\mando_onlymandoones.sqf""";processInitCommands; |
| mando_missiles\units\mando_assignlaser_by_type.sqf | Waits until a player is in a vehicle which type is in the provided array, and then gives that vehicle a scripted laser designator. This script must be executed in every machine where there is a player. |
| mando_missiles\units\mando_assignlaser_by_name.sqf | Waits until a player is in a vehicle which name is in the provided array, and then gives that vehicle a scripted laser designator. This script must be executed in every machine where there is a player. |
| mando_missiles\units\mando_sonobuoy.sqf | Drops a sonobuoy which will provide remote surface and underwater targets. |
| If I want | then I should |
| to know how a particular script works and to learn more about the required script parameters | open the corresponding sqf or sqs file and check its header, most of
the scripts have an extense description inside. Check also the demo missions
to see how and where the scripts are executed (in most cases, from init.sqf
or spawning vehicle scripts).
If you are totally lost about scripting and scripting commands you might check OFPEC Command reference as well as a basic SQF scripting tutorial . |
| to ask some questions | ask them in the Mando Missile ArmA forum thread at OFPEC. |
| to fire a missile | Just execute mando_missile.sqf. Execute it once, if the game is MP, then make sure to fire a single missile the script is not executed in every connected machine, but a single one. |
| to provide MCC capability to some units types | Execute mando_missiles\mcc\mando_mccallow_by_type.sqf in every machine where a player might use any unit of the provided classes as MCC launcher. The most common place would be init.sqf. |
| to provide MCC capability to some specific units with some particular names | Execute mando_missiles\mcc\mando_mccallow_by_name.sqf in every
machine where a player might use any of the provided unit as MCC launcher.
The most common place would be init.sqf.
If you respawn the units after destruction, make sure to use setVehicleVarName command to set again the initial name for these units. |
| to transform some unit types into visual missile or/and chaff/flare launchers for players | Execute mando_missiles\units\mando_assignvehicle_by_type.sqf in every machine where a player might use any unit of the provided classes as visual missile/chaff/flare launcher. The most common place would be init.sqf. |
| to transform some units with particular names into visual missile or/and chaff/flare launchers for players | Execute mando_missiles\units\mando_assignvehicle_by_name.sqf
in every machine where a player might use any unit of the provided ones
as visual missile/chaff/flare launcher. The most common place would be
init.sqf.
If you respawn the units after destruction, make sure to use setVehicleVarName command to set again the initial name for these units. |
| to convert an AI vehicle into an automatic missile launcher | Execute mando_missiles\units\mando_missileattacker.sqf for this
particular vehicle. Execute it server side.
There are many already configured AI missile launchers types which are all the scripts present into mando_missiles\units\attackers folder. These scripts execute mando_missiles\units\mando_missileattacker.sqf with a set of preconfigured parameters to customize types of missile launchers, so you may use these instead of mando_missiles\units\mando_missileattacker.sqf. |
| to provide AI planes or choppers with automatic chaff/flares missile protection | Excute mando_missiles\units\mando_missileecm.sqf for each vehicle you want to have chaff/flares. Execute this script server side. Note that this will provide automatic protection as long as the vehicle is AI driven. |
| to replace any ArmA missile fired against a particular unit by a Mando Missile one | Execute mando_missiles\units\mando_onlymandoones.sqf in the init field of the desired unit. If you create this unit via script, use createdunit SetVehicleInit "res = [This] execVM ""mando_missiles\units\mando_onlymandoones.sqf""";processInitCommands; to make sure the script is executed in every client and the server. |
| to be able to provide laser targets to missile launchers | Execute mando_missiles\units\mando_haveialaser.sqf in init.sqf, this will check whether the player has a laser designator or not, and if he does, some menu actions will be available to transmit a laser target. Note that only missile launchers REMOTE targets capable will be able to engange laser targets transmitted by laser designator units. |
| to make some vehicle or object types able to provide missiles for launchers | Execute mando_missiles\units\mando_missilereloadallow.sqf in init.sqf providing the list of vehicle or object classes that will act as missile loaders. Make sure the script is executed for any client and server. |
| to make some vehicle or object types able to provide chaff/flares for visual launchers | Execute mando_missiles\units\mando_flaresreloadallow.sqs in init.sqf providing the list of vehicle or object classes that will act as missile loaders. Make sure the script is executed for any client and server. |
| to create my own AI launcher | Check the existing ones inside mando_missiles\units\attackers folder, modify any of them and rename it for your particular AI missile launcher and then execute your script from init.sqf server side (inside if (isServer) then { } block. You may also execute mando_missiles\units\mando_missileattacker.sqf directly, providing all the required script parameters. |
| to create my own MCC launcher for players | Check the existing ones inside mando_missiles\mcc\mcc_types folder, modify any of them and rename it for your particular MCC missile launcher and then provide the modified script (its name) as parameter for mando_missiles\mcc\mando_mccallow_by_type.sqf or mando_missiles\mcc\mando_mccallow_by_name.sqf executed from init.sqf for any connected player and the server (if player is not present, you dont need to execute it server side). |
| to create my own visual missile/chaff/flares launcher for players | Check the existing ones inside mando_missiles\units\keysets folder, modify any of them and rename it for your particular visual missile launcher and then provide the modified script (its name) as parameter for mando_missiles\units\mando_assignvehicle_by_type.sqf or mando_missiles\units\mando_assignvehicle_by_name.sqf executed from init.sqf for any connected player and the server (if player is not present, you dont need to execute it server side). |
| to create my own missile warheads | Check already made warheads present in mando_missiles\warheads, you may use any of these as the base to create your onw one and then use the new warhead script as Warhead parameter for your missiles. In your warhead script you shoud modify only the code related to special effects (particles) and detonation (spawn of explosive ammo). Note that the detonation is usually achieved creating an ammo that collides with a small object. |
| to create my own missile engine smoke trails | Check already made smoke trails present in mando_missiles\exhausts,
you may use any of these as the base to create your onw one and then use
the new smoke trail script as smoke parameter for your missiles. A missile
damage above or equal to 0.05 is used to indicate the missile engine is
turned OFF (end of engine endurance time).
These scripts are automatically executed once the missile engine is turned ON. |
| to create my own missile launch effects | Same method as for warheads or smoke trails, the pre-done launch scripts are into mando_missiles\launch folder. |
| to add a new remote target for a side, so all the remote targetting capable units of that side will be able to engange it | execute mando_missiles\units\mando_addremotetarget.sqf indicating target and side. Make sure this script is executed only from a single client or the server. The new target will be available for all the launchers (AI, visual or MCC) which are capable to lock on remote targets until the target is destroyed, deleted or removed from the corresponding remote target array. |
| to change the default keys used by manned visual launchers | All visual launchers have an a menu action to reconfigure the keys
Mando Missile will use to fire missiles, lock on targets and drop countermeasures,
so each player may configure the keys at will:
 |
| to change the visual effects of dropped chaff or flares | Modify the particle effects in mando_chaffflaredraw.sqf and mando_flaremove.sqs |
| to be able to intercept incoming missiles with guns simulating a CIWS system. | Use Mando Gun. The guns will be able to engange and shoot down detectable
missiles. Mando gun units will be detected by SEAD units as potential radar
targets too.
Mando Missile Lab mission includes a Mando Gun. To check missile interception select "sea launcher" "against sea target", Max speed 400 m/s, Seeker range: 1000m, Initial mode:0 Cruise alt: 300m, Detectable:Yes and fire a missile. |
| to see MMA in action | Check Mando Missile videos in YouTube. |
Visual launcher's HUDs are projected over default view for the assigned
position (driver, gunner or commander). If this default view has optics
with a level of zoom in, the HUD needs to adjust the projection placement
of the target mark. There are two ways to indicate this situation to visual
launcher scripts, first is by an optional parameter for these scripts,
and second is by including the corresponding vehicle class inside mando_optics
array modifying mando_missileinit.sqf.
| Script parameter | Description |
| Script suite or addon to use | script suite = false, addon = true, if no provided addon will be used if present. |
| Minimum altitude of air targets | Minimum altitude over ground level to consider a potential target as air target, default value is 10. So, a SAM will not be able to lock on planes or choppers flying lower than this altitude. And a missile launcher able to engange ships or/and vehicles will not attack anything higher than 10m over ground level. |
| Minimum countermeasures extent | Minimum extra distance between missile and countermeasure and missile and target to ensure the missile will be affected by the countermeasure. For example, if this parameter is set to 20 and distance between target and missile is 1000 and distance between missile and countermeasures is 1021, the missile will keep tracking the target ingoring the countermeasures. Default value is 25. |
| Maximum LOS check range | Line Of Sight check will be done against potential targets up to the minimum between this value and the distance between target and launcher. Default value is 3000. |
Example:
[false, 5, 30, 2500]execVM"mando_missiles\mando_missileinit.sqf";
| Script parameter | Description |
| Array of vehicle types
or Array of vehicle names |
An array containing vehicle classes that will have this MCC available
for players.
or An array containing vehicle names that will have this MCC available for players. |
| Maximum number of missiles | A number indicating maximum number of missiles of the indicated index that this MCC allows to load. |
| Current number of missiles left | Current number of loaded missiles of the indicated index. |
| Target types array | Valid values inside that array are "RADAR", "REMOTE", "Air", "Ships" and "Vehicles". [] for none. If "Air" is not the only target type present or if the array is empty, the MCC will be able to use the MCC mark for targeting. |
| Action text | Text of the action menu to activate this MCC. |
| MCC script to be executed upon activation | Some of these are already present in mando_missiles\mcc\mcc_types folder. This script personalizes many parameters of the MCC and the missiles this MCC will be able to fire. You might create your own mcc types based on current ones. |
| Missile launch position relative to the vehicle | [left - right, backward-ahead, below-above]. For example, [3, 0, -2]
for a plane will spawn missiles 3m to the right and 2m below the plane's
center (right wing pilon?).
or [left - right, backward-ahead, below-above, radious], This might be used for launchers without fixed launch direction, in this case, the first three elements define the launch center, and the radious and firing direction determines the final missile spawn position. |
| MCC camera position relative to the vehicle | [left - right, backward-ahead, below-above]. Every MCC has a camera which aims at selected targets, this position determines the placement of the camera relative to launcher's center. |
| Position of the player to activate this mcc | 0 -> driver, 1 -> gunner, 2 -> commander. When the player is in the inicated position, an action menu will be added to activate the MCC console. |
| Fixed firing direction? | If >= 0, horizontal firing heading in degrees releative to launcher's heading. If < 0, the missile is fired aiming already towards the target. For example, 90 would mean the vehicle fires the missiles heading to its right at launch time. |
| Missile index number for the vehicle | Number missile index used by this MCC. |
| Background color | [R,G,B,A], determines the background color of the MCC console. You might have several MCC types available for the same vehicle or vehicle type, and using different colors helps to know which once has the player active. |
| Number of scans to get ready | Number of scans to get ready to fire again after a shot. The frequency of target scanning is configured inside the selected mcc activation script (MCC script to be executed upon activation). |
| Vertical launch angle | Fixed vertical launch angle if between -89 and 89, else the vertical firing angle is automatically set to aim towards the target's position. If the value is different than -100, the value present here will used for the fired missiles, else, the angle used will be that present inside the indicated MCC script to be executed upon activation. |
Example:
// Stryker_TOW type units will be Patriots for
players as gunners
_mcctypeaascript = "mando_missiles\mcc\mcc_types\mando_missilecontrolon_patriot.sqs";
[["Stryker_TOW"], 8, 8, ["Air"], "Patriot Console",
_mcctypeaascript, [0,0,0,2], [0,1,0.25], 1, -1, 0, [0,1,0,0.5], 3, 45]execVM"mando_missiles\mcc\mando_mccallow_by_type.sqf";
| Script parameter | Description |
| Array of vehicle types
or Array of vehicle names |
An array containing vehicle classes that will have this system available
for players.
or An array containing vehicle names that will have this system available for players. |
| Position of the player to activate the system | 0 -> driver, 1 -> gunner. When the player is in the inicated position the system will be activated automatically. |
| Vehicle's weapon class used to aim | Name of the vehicle's weapon used to fire and aim the missiles, "" if none (aiming with the vehicle's nose = fixed direction). List of ArmA weapon names. |
| Maximum number of missiles | Array [AA missiles, AG missiles] Note that AA missiles will use provided missile index number for this vehicle, AG missiles will use provide missile index number + 1. |
| Current number of missiles | Array [AA missiles, AG missiles] |
| Maximum number of countermeasures (flares/chaff). | When you reload countermeasures for this vehicle, this is the maximum you will reach. |
| Current number of countermeasures | Equal or below the maximum number. |
| Control script name | This script is the heart of the visual launcher, while you might create your own ones there are two already done: mando_missilevehicle.sqf (to keep compatibility with older versions) and the newer mando_missilevehicle2.sqf. |
| Can you target ground/sea vehicles using this system? | true/false. |
| Can you target air units using this system? | true/false. |
| Can you target buildings and structures using this system? | true/false. |
| Can you target REMOTE targets using this system? | true/false. |
| Firing position | [left - right, backward-ahead, below-above]. For example, [3, 0, -2]
for a plane will spawn missiles 3m to the right and 2m below the plane's
center (right wing pilon?).
or [left - right, backward-ahead, below-above, radious], This might be used for launchers without fixed launch direction, in this case, the first three elements define the launch center, and the radious and firing direction determines the final missile spawn position. |
| Keyboard control script | this script determines what happens when the player hits lock-on, fire or countermeasures keys. There are many already customized scripts into mando_missiles\units\keysets folder. Missile firing parameters for AA and/or AG missiles for the visual missile launcher are configured there. |
| HUD horizontal arc in degrees | used only if you use mando_missilevehicle.sqf as control script (obsolete). |
| HUD vertical arc in degrees | used only if you use mando_missilevehicle.sqf as control script (obsolete). |
| Weapon sight vertical delta | aproximate height of the sight of the selected weapon, vertical distance over the center of the unit (obsolete). |
| Missile index number for AA missiles | index number + 1 will be automatically asigned to AG missiles |
| Can you lock on active RADAR emitters using this system? | true/false |
| HUD type | 0 -> complete, 1 -> RWR map only, 2 -> targeting HUD only, 3 -> missile/countermeasures quantities only |
| Zoom | (0 or 1). If the units for the indicated position (driver, gunner or commander) have initially zoomed in optics set this to 1. This parameter is optional, if not provided the zoom will be calculated based on unit types (the list of unit types to check is inside mando_missileinit.sqf). |
Example:
// All AV8B2 will have 10 flares, 4 AA missiles
and 2 HARM missiles for the pilot (missile idx 0 and 1)
[["AV8B2"], 0, "", [4,2], [4,2], 10, 10, "mando_missiles\units\mando_missilevehicle2.sqf",
false, true, false, false, [3,-2,-2.5], "mando_missiles\units\keysets\mando_av8harm_keys2.sqf",
5, 10, 2, 0, true, 0] execVm"mando_missiles\units\mando_assignvehicle_by_type.sqf";
| Script parameter | Description |
| Firing unit | Missile armed vehicle, it may be also an object or even a game logic |
| Unit position | AI unit position inside the vehicle to be able to activate this system:
0 driver, 1 gunner, 2 commander, anyother value = no unit (no AI soldier
is needed for the launcher, for example, if the launcher is a building,
of if you simply dont need/want to have an AI soldier responsible of the
system).
Note that for values 0,1 and 2, the soldier in the corresponding position inside the vehicle should be alive and in a combat mode different of GREEN and BLUE, else the system will remain deactivated until destroyed or another AI soldier matching the conditions occupies the indicated position. Players are not valid units for this unit position, only AI soldiers. If you want to have an automatic missile launcher in a vehicle which will be used by players (and you dont want to setup any manned system), then just set this unit position to any value different than 0, 1 and 2. |
| Target types array | ["Air"] or ["LandVehicle"] or ["Air", "LandVehicle", "Ship"] or any combination of these. "REMOTE" target type may be used to indicate this unit may target targets locked by other units. For example ["Ship", "REMOTE"] for an AI launcher able to engange remote targets and ships. |
| Quantity | Number of missiles initially loaded into this unit. |
| Min range | Closer than that, the system will not attack units. This is spatial range, so if the unit has a range of 2Km and the target is near the vertical of the launcher, but 2100m higher, the launcher will not attack. |
| Max range | Farther than that, the system will not attack units. |
| Rate of fire | Maximum number of missiles fired per minute. |
| Firing position | [left - right, backward-ahead, below-above]. For example, [3, 0, -2]
for a plane will spawn missiles 3m to the right and 2m below the plane's
center (right wing pilon?).
or [left - right, backward-ahead, below-above, radious], This might be used for launchers without fixed launch direction, in this case, the first three elements define the launch center, and the radious and firing direction determines the final missile spawn position. |
| Scan arc | Arc in front of the firing unit where targets may be locked, 90 means
from -45 degrees to the left to +45 degrees to the right, 360 will lock
on any target in range, 180 will lock on any target in front of the firing
unit (from -90 to the left to +90 to the right). Or array with arc and
delta [arc, delta], both in degrees. Delta is an angle to add to the direction
of the firing unit. For example, a launcher able to engange targets to
the left of the firing unit in an arc of 90 degrees [90,270].
|
| Minimum knowledge | Minimum knowledge of the target to attack it from 0 (nothing, STANDOFF attacks) to 4 (everything). |
| Enemy sides | Array with sides considered enemy (west, east, resistance, sideLogic, sideEnemy and/or civilian). Note that empty vehicles are considered civilian. |
| Antimissile? | Able to track and fire against incomming detectable missiles? (true/false) |
| Fixed direction? | Its "launcher" is fixed to the direction of the vehicle? true/false. If false, the missile will be fired already oriented towards the target, else using the launcher's direction. |
| Initially active? | true/false. If false, you will need to activate the unit later using mando_missiles\units\mando_attackeronoff.sqf. If true, the unit will start looking for targets as soon as mando_missileattacker.sqf is executed. |
| Radio initially active? | true/false. If false, it may be turned on when needed writing a true into its "mando_missileattacker_radio" variable. |
| Missile parameters array | Same array as the one used by mando_missile.sqf, the list of parameters is described here . |
| Radar activation sound | String for a sound resource defined in description.ext, or "" for none. Mando Missile already incorporates "mando_radaron", you may add your onw ones. |
| Radar deactivation sound | String for a sound resource defined in description.ext, or "" for none. Mando Missile already incorporates "mando_radaroff", you may add your onw ones. |
All the scripts present into mando_missiles\units\attackers folder
are preconfigured ways to execute mando_missiles\units\mando_missileattacker.sqf.
Back to index
| Script parameter | Description |
| unit | Vehicle that has the CHAFF or FLARES packs |
| Maximum range | Maximum distance beetween incomming missile and the unit to drop flares or chaff |
| Countermeasures type | Determines which kind of visual "effect" will be drawn: 0 -> Chaff, 1 -> Flares. |
| Quantity | Initial quantity of countermeasures packets |
| radio | true/false. If true, the unit will send radio messages about incoming missiles and countermeasures deployed. |
| reactiontime (optional) | The unit will wait a random number of seconds between 0 and this value before dropping countermeasures. This parameter is optional, if not provided the reaction delay time will be 0 seconds |
Example:
// bomber1 will drop flares as soon as a missile
is closer than 300m, the plane has a single flares pack.
if (isServer) then
{
[bomber1, 300,
1, 1, false, 1]execVM"mando_missiles\units\mando_missileecm.sqf";
};
This, applied to Mando Missile, might be splitted in three phases:
mando_asroc.sqs is used instead to executing
mando_missileattacker.sqf directly to save us the work of having to enter
many, many parameters. Most of the parameters required by mando_missileattacker.sqf
are set inside mando_asroc.sqs, but some others are passed as parameters
for mando_asroc.sqs too:
So, at the end, mando_asroc.sqs is just
an "easy" way to execute mando_missileattacker.sqf with most needed
missile parameters already preconfigured.
The parameters mean the following:
Mando Missile ASROC in YouTube
mando_missiles\units\keysets\mando_guided_tow.sqf is a good manual guidance example.This script might be used as key handler by visual launchers activated by mando_missiles\units\mando_assignvehicle_by_type.sqf or mando_missiles\units\mando_assignvehicle_by_name.sqf.
Mando Missile TOW manual guidance in YouTube
To fire a missile, first select a contact clicking on it and then click "Target Selected Contact" button. The right panel will show updated information about the target. When TTI (time to impact) is smaller than missile's endurance, you may fire a missile. After firing a missile, the system will take few seconds before allowing to fre a new one (you will see the fire missile button grayed meanwhile).
A missile fired against a target beyond its seeker range will fly in inertial modes 0 and 1 until it reaches the pre-caculated seeker activation point (the altitude above sea level of that point may be entered manually), then the missile will switch on its own seeker to pursue the target. If the target changed its course drastically while the missile was flying in inertial mode, probably the missile will see "nothing" when it activates its onboard seeker (unless the missile has mid-course target position corrections).
The small map to the left has two purposes: track indicated object (contact, target or MCC vehicle) and change the position of the map mark (yellow mark). To change the position of the map mark just right click over the desired position of the map. Make sure the map is "free" so you can zoom/pan it. If the NAV/MARK button is indicating NAV and your vehicle has a driver, it will be commanded to move to the new placement of the map mark (using this mark you may effectively control the driver of the MCC vehicle). It that button is indicating MARK, when right-clicking over the map you will change the position of the mark but the driver will not receive any command. Depending on the type of targets for the MCC, that map mark may be listed in the list of targets, so you may select it and fire against it. This way you may zoom over map structures, place the mark over them and attack them (note that the mark will be shown in your contact list only if it is in-range).
The dark green firing solution circle in the center will turn bright green when the target is inside the missile's seeker horizontal scan arc. "IN RANGE" message will be shown inside that circle when the calculated Time To Impact (TTI in the right console) is smaller than the endurace of the type of missile used. If the target is moving fast towards the MCC launcher, it may be safe even to fire a missile without "IN RANGE" message displayed.
| Control | Description |
| Contact list | Shows the current list of contacts available to be selected as targets (which depends on the available target types for the MCC). Contacts detected by MCC radar are listed as "Contact#", remote contacts transmitted by other friendly units are listed as "Remote target", active surface radar emitters are listed as "Active surface Radar", interceptable missiles are listed as "Missile" and the map mark is listed as "Contact# (MAP MARK)". |
| Target Selected Contact button | Marks as target the last selected contact from the contact list. The MCC will start tracking that contact and will show target data in the right console. For vehicles, planes and ships, LOS check will be performed, if the selected target doesnt pass the LOS check, it will be removed from the contact list. |
| Left console map and map buttons | The map may work in several modes: tracking current contact, tracking current target, tracking the MCC vehicle or free so the player may zoom/pan at will. When tracking a contact, the contact will be displayed as an small green square. When tracking a target, the target will be displayed as a green arrow and a small green dot will mark the pre-calculated point of impact if a missile is fired against the target. When tracking the MCC, the MCC will be displayed with four green small arrows pointing to the MCC position. In free mode the player may zoom and pan the map at will and may also rightclick to change the placement of the "map mark". In NAV mode, re-positioning the "map mark" will also command the MCC vehicle driver to move there. Depending on the available target types of the MCC, the "map mark" itself may be marked as target, so you may place the mark over any ground structure and fire against it. |
| Alt ASL modes 0/1 | Entry here the altitude above sea level that should be kept by the missile when flying in inertial mode. Lower altitudes makes the missile hard to see by the enemy, but the probabilities of impact against ground obstacles will be high. For "safe" shots against aerial targets, check the target's ASL altitude and enter a similar number or higher (if there are any high ground elevations between the MCC and the target). This value doesnt apply if the target is already inside active seeker range of the missiles. |
| Missile Camera button | This button allows you to switch on/off the missile camera. If switched on, the camera will follow the last fired missile in-flight. If you click the button while the camera is following a missile, you will return to normal MCC view. Low FPS may occur if the camera overflies complex and not pre-cached terrain while following the missile in-flight. |
| Fire Missile button | Fires a missile. This button will be grayed after firing a missile as many seconds as indicated by the configured ratio of fire of each MCC unit (scans to load). |
The HUD is used to track locked on targets, show target info (type, range and altitude), number of AA missiles left, number of AG missiles left, operational mode and number of countermeasures left. If maximum number of countermeasures is set to 0, the control showing the count will be hidden, same for missiles.
The RWR shows incoming missiles as red thin vectors (only missiles aproaching the vehicle are shown) and a white vector indicating the relative course of the current target (if any). The RWR also shows our vehicle and direction (green circle with inscribed arrow) and the surrounding terrain, so it also gives the player limited navigation capability.
The menu actions are used to switch to the desired system operational mode, for example, AA to engange aerial targets, AG to engange ground vehicles or ships, anti-radar to be able to lock on radar emitters, structures to be able to lock on ground sctructures like buildings or REMOTE to be able to lock on targets locked on by different units.
Aside of these actions, the player will have also one to reconfigure the keys used to fire missiles, drop countermeasures and lock on targets: Mando Missile Keys, and another action to show ordenance left.
All these actions might work also with other ones comming from scripts like mando_assignlaser_by_type.sqf, mando_assignlaser_by_name.sqf or mando_haveialaser.sqf. For example, a system with a scripted laser turns it on, validates its own laser and then selects REMOTE targets mode to lock on its own validated laser target.
In most cases, the operation of the system is quite simple:
When you click the lock on key, two new values will be displayed in the HUD: AR and TR which are missile active range and missile thrusted range respectively.
As said before, you might also enable RWR for visual launchers. The RWR will be displayed as a small map in the upper right corner of the screen. If there is a locked on target, its vector will be displayed as a white line between your position and the target. Incoming missiles are represented as red lines.
SEAD
visual launcher in YouTube
Visual
SAM in YouTube
Guided
TOW in YouTube
Hellfire
(LOBL) launcher in YouTube
Airborne
MU90 torpedo launcher in YouTube
Airborne
torpedo again in YouTube
If your unit or vehicle has an ArmA LD (dont forget to execute mando_missiles\units\mando_haveialaser.sqf), you will have a new menu action available: Transmit laser target. If you have the LD activated, using that action will make your laser target available for any unit of your side able to lock on remote targets, and your laser target will be available for them as long as you keep your laser ON. If you switch off your laser designator, you will need to re-transmit the laser target once you turn it on again.
For example, for a countermeasures extent of 0, the missile will follow the closer one (target or countermeasures), so, to deviate a frontal shot, the target will need to break left, right, up or down trying to leave the countermeasures between the target and the missile.
Another example with an extent of 100m and a frontal shot. The missile is 1000m ahead of the target and aproaching head-on, the target drops countermeasures and keeps flying towards the missile. At this point the distance between target and missile is 900m and the distance between missile and countermeasures is 950m. Having an extent of 100m, the missile in this situation will follow the countermeasures even having the target 50m closer.
If you want missiles immune to countermeasures, use large negative countermeasures extents, for example, -1000.
The default countermeasure extent value for any missile is set in mando_missiles\mando_missileinit.sqf , but you can set individual values for each individual missile fired, check mando missile countermeasures extent parameter (mando_missile.sqf parameter number 32 starting from 0).
Check Mando Missile flares avoidance in YouTube and some more.
The rating added or substracted (if target was friendly) is equal to
100 + destroyed target cost / 1000.
The cost of the target is read from the config. If no cost parameter
is found, the rating value is set to 100.
For rating and scoring, only the target of the fired missile is considered. Collateral damage to nearby vehicles different than the target does not count.
For MP scoring the criteria is the following:
| Type of target destroyed | MP Score (negative if target was friendly) |
| Air | 5 + number of crew members inside |
| Car/Truck | 2 + number of crew members inside |
| Tank/APC | 3 + number of crew members inside |
| Boat | 3 + number of crew members inside |
| BigShip | 25 + number of crew members inside |
| SmallShip | 15 + number of crew members inside |
| Ship | 10 + number of crew members inside |
| Static | 3 + number of crew members inside |
| Anything else | 1 + number of crew members inside |
If you need to chage the current criteria, modify mando_missiles\mando_score.sqf function.
All warhead scripts have the following generic structure:
// mando missile warhead template
// mando_missilehead_template.sqf
// Jan 2007 Mandoble
//
// This script may be used as explosion script
argument for mando_missile.sqf
//
private ["_pos", "_target", "_targets", "_classtarget", "_rating", "_crewt", "_launcher", "_side", "_unit", "_crew", "_cost", "_dmgtarget", "_score"];
_pos = _this select 0;
_target = _this select 1;
_side = _this select 2;
_launcher = _this select 3;
if ((isNull _target) || ((typeOf _target) in ["LaserTargetW",
"LaserTargetE", "LaserTargetC", "Logic"])) then
{
_targets = nearestObjects [_pos,
["LandVehicle","Air", "Ship"], 10];
if (count _targets > 0) then
{
_target = _targets
select 0;
};
};
_dmgtarget = damage _target;
_classtarget = typeOf _target;
_crewt = count crew _target;
_cost = getNumber (configFile >> "CfgVehicles"
>> _classtarget >> "cost");
// Add here any code related to special visual
and sound effects
// the position of the explosion (last missile
position) is stored into _pos, _target stores the target and _launcher
stores the unit that fired the missile.
// The following block creates a real explosion
making an ammo collide with another ammo or an object
// If this missiles doesnt require any extra
explosion (it works by direct hit), remove the following if block of code.
if (local _target) then
{
_b2 = "Bomb" createVehicle _pos;
_b2 setPos _pos;
_b1 = "M_Ch29_AT" createVehicle
_pos;
sleep 0.5;
deleteVehicle _b2;
};
// Score calculation
Sleep 1;
call mando_scorefunc;
// End of warhead script
You may test easily any warhead script you do from Mando Missile Lab.
All smoke trail scripts have the following generic structure:
// mando missile smoke trail template
// mando_missile_template.sqf v1.0
// Jan 2007 Mandoble
//
// This script may be used as smoke trail argument
for mando_missile.sqf
//
private ["_mis"];
_mis = _this select 0;
while {(!isNull _mis)&&(damage _mis <
0.05)} do
{
// Keep the desired visual particle
and light effects while the condition of this while is met.
// _mis is the missile object
};
// End of smoke trail script
You may test easily any smoke trail script you do from Mando Missile Lab.
All launch scripts have the following generic structure:
// mando missile launch FX template
// mando_launch_template.sqf
// March 2007 Mandoble
//
private ["_mis"];
_mis = _this select 0;
// Add here any particle, light or/and sound effects
you want for launch time.
// Usually you will want to keep the effects
alive only for a short period of time and if !isNull _mis
// End of launch script
You may test easily any launch script you do from Mando Missile Lab.
All AI launchers scripts have the following generic structure:
;mando Basic AI SAM unit
;mando_basicsamunit.sqs
;March 2007 mandoble
;
_disp
= _this select 0
_posunit = _this select
1
_ttype =
_this select 2
_quantity = _this select 3
_minrange = _this select 4
_maxrange = _this select 5
_rof
= _this select 6
_firingpos = _this select 7
_arc
= _this select 8
_minknow = _this select
9
_enemysides = _this select 10
_antimissile = _this select 11
_fixeddir = _this select 12
_active = _this
select 13
_radio =
_this select 14
;Missile parameters
_launcher
= _disp
_missilebody =
"M_Sidewinder_AA"
_vangle
= 45.0
? count _this > 15: _vangle
= _this select 15
_speedini
= 10
_speedmax
= 700
_acceleration = 180
_boomrange
= 20
_activerange =
8000
_modeinit
= 0
_cruisealt
= 500
_boomscript
= "mando_missiles\warheads\mando_missilehead1a.sqf"
_smokescript =
"mando_missiles\exhausts\mando_missilesmoke1a.sqf"
_soundrsc
= "mando_missile1"
_sounddur
= 29
_endurance
= 15
_terrainavoidance = false
_updatefreq
= 1
_delayinit
= 0
_controltime =
0
_detectable
= false
_debug
= false
_launchscript = ""
_hagility
= 75
_vagility
= 35
_accuracy
= 1
_intercept
= true
_scanarch
= 120
_scanarcv
= 90
_offsety
= 1
_flaresextent = 25
; Missile params array that will be passed to
mando_missileattacker.sqf
_missileparams = [_launcher, _missilebody, [0,0,0],
0, _vangle, _speedini, _speedmax, _acceleration, objNull, _boomrange, _activerange,
_modeinit, _cruisealt, _boomscript, _smokescript, _soundrsc, _sounddur,
_endurance, _terrainavoidance, _updatefreq, _delayinit, _controltime, _detectable,
_debug, _launchscript, _hagility, _vagility, _accuracy, _intercept, _scanarch,
_scanarcv, _offsety, _flaresextent]
;MCC Sounds
;Sound for MCC activation
_radaronsound = "mando_radaron"
;Sound for MCC deactivation
_radaroffsound = "mando_radaroff"
[_disp, _posunit, _ttype, _quantity, _minrange, _maxrange, _rof, _firingpos, _arc, _minknow, _enemysides, _antimissile, _fixeddir, _active, _radio, _missileparams, _radaronsound, _radaroffsound] execVM "mando_missiles\units\mando_missileattacker.sqf"
exit
The first 15 parameters are provided when executing the helper script, the meanings are exactly the same as the equivalent of mando_missileattacker.sqf, within the helper script you set all the missile parameters as well as the custom sounds for launcher activation/deactivation. Of course you can decrease the number of required parameters for each template adding more fixed values inside the script, or make fixed values variable adding more parameters at will.
_offsety and _flaresextent are optional. If you dont provide _offsety, the default value will be 1, if you dont provide _flaresextent the default value will come from mando_missileinit.sqf. Note that if you want to provide _flaresextent you need to provide _offsety too, else the array parameters order would be wrong.
