Odd finding about fuses -> Hack request(?) (Edited 1st post)

Rimshot, if I got it right, this will make my ship invincible, but this not needed, the ship has to be destroyed, but destroying ship by impulse spoils all the fuse sequence.

Adding the actual damage to the explosion(found in explosions.ini) will do, but it spoils some other things, so it doesn’t suit me unfortunately, so the only way so far seems to make impulse damage be treated as explosion

---

Tutorial by LordFjord:

---

A few notes ahead:
The original of this tutorial was made roughly a year ago but got lost in the Excelcia/Infinity forums crash with a total dataloss. This Data was recovered from a backup that JetPak made half a year ago.
Now to the tut:

Fuses

What are fuses?
This is the 1st question what people usually ask. This tutorial should give you a detailed description about fuses, how to use them and what you can do with them.
Fuses are assigned to ships and can be activated when the ship’s hitpoints reach a certain value. The fuse sequences contain mostly FX effects, the most common you see in Freelancer are smoking and burning ships, but also the explosions of bigger capships, which can be very impressive when made with some detail.
You can create various timed effects like explosions, flashes, ships breaking apart, and so on. Fuses are also able to create various things like player lootdrops and other nice details that make the game nicer.

What files are fuses in?
Usually in Data\Missions\fuses.ini , but most capships have their own fuse files. Makes technically no difference as long you have the entries right in freelancer.ini
You can use the fuse entries in all archetype files, may it be ships, solars, …

Sections
I will try to make a list of all possible sections that are found in fuse files. Combining these can create very nice additions to the game.

[fuse]
The definition of the fuse. This is referenced in shiparch.ini and solararch.ini. Fuses can be made for both - it works the same way.
All of the following sections in a file are considered as part of a single fuse - until the next [fuse] section starts.
Code:
[Fuse]
name = intermed_damage_smallship01
lifetime = 1
death_fuse = false

name: reference name
lifetime: total length of the fuse in seconds.
death_fuse: (true/false) This specifies if the player will die after the duration of the fuse. Until then he is technically invincible. (true:) No death-message will be displayed in this case. The player can still fly around and shoot during this time.
(false:) The player dies in a “normal” way, deathmessage is displayed.

[start_effect]
Starting an effect/explosion/whatever - this sets up where and when it is and how it looks. You can include several hardpoint lines to multiply the effect and to recreate it on different mounts. This works for the other fuses as well - you can give most of them several hardpoint entries.
Code:
[start_effect]
effect = gf_continuous_fire
hardpoint = HpWeapon03
hardpoint = HpWeapon04
hardpoint = HpWeapon05
hardpoint = HpShield01
hardpoint = HpShield01
hardpoint = HpThruster01
at_t = 0.000000
attached = true

effect: name reference to effects.ini - the “look” of the effect. can be also an explosion effect (that one can be made to inflict damage - multiple volley explosion damage is possible)
hardpoint: list of hardpoints where the effect will be attached. One of the listed ones will be picked by random.
at_t: (at_time) The effect will start with this delay from the time of triggering. Timing can be important. With a well made timing you can make things like an explosion blast that goes through a capship, then parts starts to fall off, flashes, explosions - till the main hull explodes.
attached: (true/false) specifies if the FX is attached to the ship and if it follows its movement or not.

[destroy_hp_attachment]
Destroy attached items on mounts. You can include several hardpoint lines here to strip many mounts off the ship.
Code:
[destroy_hp_attachment]
at_t = 0.000000
hardpoint = HpTurret_u1_03
fate = debris

at_t: at_time, see above
hardpoint: which hardpoint attachment should be destroyed? anything attached to this mount will be destroyed.
fate: what happens to the mounted item? usually debris.

[destroy_group]
Destroy mesh groups (for example: shipparts). Several groups can be detroyed this way at once.
Code:
[destroy_group]
fate = disappear
at_t = 0.250000
group_name = trans_port_eng_lod1

fate: selfexplaining Razz
at_t: timing, see above
group_name: name of the group in the model file (.cmp) that should be destroyed. This is part of the descrtuctible parts concept of FL.

[tumble]
This decribes ship movement after triggering the fuse.
You can let ships fly weird manovers after “death” before they explode.
Code:
[tumble]
at_t = 0.000000
ang_drag_scale = 0.300000
turn_throttle_z = 0.700000, 0.950000
turn_throttle_x = 0.000000, 0.100000
turn_throttle_y = 0.000000, 0.100000
throttle = 1.000000, 1.000000

at_t: timing, see above
ang_drag_scale: multiplier to the angular_drag value of the ship.
turn_throttle_<z|x|y>: not 100% sure but i think its min, max values of turning.
throttle: again, min, max values of ship speed.

[destroy_root]
The time of death. Connected closely to death_fuse = true.
This is what kills the player -> no death message.
Code:
[destroy_root]
at_t = 1.000000

at_t: timing, see above

[damage_root]
Not sure on this as i didnt had time to fully test it, but my guess is that its one sort of selfdamaging . I need to test a few things here. One thing could be possible: you damage a ship to a certain level, then it starts smoking, breaking apart, damaging itself to trigger the next fuse till it is shaken by a shockwave and blows in a spectacular explosion.
Update with the reposting of the tut: this indeed did damage the ship.
Code:
[damage_root]
at_t = 0.100000
damage_type = absolute
hitpoints = 125000

at_t: timing, see above
damage_type: needs a few tests, donno yet
hitpoints: needs testing, my guess is that its the remaining hitpoints - setting this to a fuse triggering level can have interesting cascading effects & trigger another fuse with a fuse.
damage_type: just guessing, maybe relative and absolute - needs testing

[impulse]
You can make physical “blasts” with this that affect ship movement.
Code:
[impulse]
at_t = 1.000000
hardpoint = HpMount
pos_offset = 23, 13, 65
radius = 150
force = 28000000
damage = 0

at_t: timing, see above
hardpoint: origin of physical impulse
pos_offset: additional offset (x, z, y) to the hardpoint’s position
radius: selfexplaining - all objects insisde this wil be affected
force: impulse - how strong is it?
damage: well, blasts can hurt, too

[start_cam_particles]
havent experimented with this one - it’s used in SP missions. “Could” be for ingame cutscenes, but im not sure.
Code:
[start_cam_particles]
effect = gf_whiteflash
at_t = 0.990000
pos_offset = 0, 0, -20
ori_offset = 0, 0, 0

[ignite_fuse]
This makes it possible to trigger several other fuses from one fuse sequence. Typically, it is used for capsihp parts that have their own destruction sequences - when the main section of the ship is “killed” then it triggers the remaining shipparts to completely destroy the ship, running through all fuse sequences and creating usually nice FX.
Code:
[ignite_fuse]
at_t = 0.200000
fuse = b_battleship_head_fuse
fuse_t = 0.000000

selfexplaining.

[make_invincible]
selfexplaining Razz - elegant way to create an “admin” ship.
Code:
[make_invincible]
turn_on = true

[dump_cargo]
This is the magic behind the player lootdrops. It will dump all unmounted equipment a ship carries, including nanos/batts, ammo, commodities, whatever that is not “mounted”.
Code:
[dump_cargo]
at_t = 0.000000
origin_hardpoint = HpMount

entries are selfexplaining. works very good within “death_fuse=true” fuses.

Triggering fuses
All in shiparch.ini and solararch.ini.

Here’s a typical fuse entry of a ship:
Code:
fuse = intermed_damage_smallship01, 0.000000, 8060
fuse = intermed_damage_smallship02, 0.000000, 4567
fuse = intermed_damage_smallship03, 0.000000, 2467

The format is
fuse = < fuse name>, < unknown >, < hitpoints for triggering >

the “unknown” “could” be a minimum triggering level, the last entry being th maximum - this needs verifying.
It is easy to see that the fuses are triggered with degrading hitpoints of a ship. First it smokes, then it catches fire and then burns.

Summary
With a bit love to detail and some work you can create veryvery impressive smoke/fire/explosion sequences involving ship tumbling, shockwaves, explosions (that deal damage), parts breaking off the ship and so on. Lotsa possibilities here that add a lot of detail to the game.
Its maybe best to take a look at some more complicated fuses (capships). Try to figure out how they work, how they are timed and set up.
Its sometimes amazing what small details are worked out for those - you never really notice those in space.

I hope this tutorial was understandable and explained the “magic of fuses” very well Smile
Fjord

P.S.: I will post examples in answers when i find some time.
Feel free to let me know any mistakes/typos, …

---

---

Tutorial by Dev

---

Zomg, another tutorial from me. Fuses are actually very interesting things, so hopefully this tutorial will shed some light on the strange things you can do with them.

Fuses are defined in fuse.ini or one of the related fuse files, and start with a [Fuse tag. Everything from there to the next [Fuse tag belongs to that fuse. The subject of this tutorial will be a TIE fighter I put together. Its wings are destructible, and when the ship is destroyed the wings will thrown off at random while the ship itself spins. Furthermore, how long it takes the ship to die varies. Also, if you kill the TIE fighter by shooting off a wing, that wing will always break off. Lastly, as the fighter takes damage there is a random chance that weapons or even the engines of the ship will be destroyed.

Here is the shiparch entry for the ship, for later reference:

[Ship
…
nickname = tie_fighter
…
hit_pts = 1000
fuse = tie_fighter_break_internals1, 0, 650
fuse = tie_fighter_break_internals2, 0, 400
fuse = tie_fighter_death_spin, 0, 1
…

[CollisionGroup
obj = zomgbayz1
separable = true
debris_type = debris_vanish
separation_explosion = explosion_small_ship_breakoff
hit_pts = 10000
root_health_proxy = true

[CollisionGroup
obj = port_wing
separable = true
parent_impulse = 250.000000
child_impulse = 250.000000
mass = 30.000000
debris_type = debris_fighter_piece
type = Port_Wing
hit_pts = 1000
fuse = tie_fighter_port_wing_break, 0, 1
root_health_proxy = true

[CollisionGroup
obj = starboard_wing
separable = true
parent_impulse = 250.000000
child_impulse = 250.000000
mass = 30.000000
debris_type = debris_fighter_piece
type = Starboard_Wing
hit_pts = 1000
fuse = tie_fighter_starboard_wing_break, 0, 1
root_health_proxy = true

The engine hardpoint is attached to the zomgbayz1 group; this will come into play later (the zomgbayz1 group is also linked to the ball part of the .sur file, with Root being the crossbar piece; the wings are themselves). Note that all groups will transfer damage to the root object (root_health_proxy = true); the fuse is set up with this in mind.

===================
On to the mighty fuse definition, which is actually quite a few fuses that work together. First off, the internal damage fuses:

[fuse
name = tie_fighter_break_internals1
lifetime = 0
death_fuse = false

[destroy_hp_attachment
at_t = 0, 3
hardpoint = HpWeapon01
hardpoint = HpWeapon02
hardpoint = HpCM01
fate = disappear

First off, some explanation of what the parameters mean.

-name = <name>This is referenced in shiparch; for example, if you look in the shiparch definition above, tie_fighter_break_internals1 will run when the root object reaches between 0 and 650 health.

• lifetime = <time>The lifetime of the fuse is measured in seconds; a lifetime of 0 means that all things in the fuse happen at the same time. You may be able to provide a range for lifetime (lifetime = <time1>, <time2>such as with debris, but it is not necessary.

• death_fuse = <true, false=“”>If true, the fuse will continue to run even if the ship is technically killed. If false, the fuse will terminate when the ship is destroyed.

• [destroy_hp_attachment
  This event will destroy an attached piece of equipment at the hardpoint specified.

• at_t = <time>OR <time>, <time>The event will occur at the given time (or within the given range of times). The time here always runs from 0 to 1, with 0 being the start of the fuse and 1 being the end. However, you can set the time to be greater than 1 if you want; nothing set to run at a time greater than 1 will actually run, though. What am I doing here, then? There is an even chance of the event running between times 0 and 3, but the event will only execute between times 0 and 1. In other words, there is a 2/3 chance that the event will not run at all. In other words, the fuse has random behavior, which is exactly what I want in this case.

• hardpoint = <hardpoint_name>The hardpoint name refers to an actual hardpoint in the ship’‘s .cmp file. The piece of equipment mounted on this hardpoint will be destroyed, if there is one (if not, nothing happens). You can set multiple hardpoints, in which case the game will randomly pick one of them to destroy. You may also say hardpoint = random, in which case the game will pick one of any of the ship’'s hardpoints.

• fate = <type>The two fate types are “disappear” and “debris”; if it disappears, it just sort of vanishes. If it debris, it will break off the ship. You set the debris type of the equipment or ship part with debris_type = in the appropriate.ini file (for example, a weapon’'s debris type would be set in its definition in weapon_equip.ini). Debris type refers to a [Debris definition (usually in explosions.ini). See my tutorial on advanced explosions for more info on that.

---

[fuse
name = tie_fighter_break_internals2
lifetime = 0
death_fuse = false

[destroy_hp_attachment
at_t = 0, 3
hardpoint = HpWeapon01
hardpoint = HpWeapon02
hardpoint = HpCM01
fate = disappear

[destroy_group
at_t = 0, 5
group_name = zomgbayz1
fate = debris

The next fuse, which runs when the fighter gets more damaged. In addition to randomly breaking off a piece of equipment, there is a 1/5 chance that the group zomgbayz1 will be destroyed. As I mentioned before, the HpEngine01 hardpoint of the TIE fighter is attached to zomgbayz1; if zomgbayz1 is destroyed, the fighter will lose its only engine hardpoint and become immobilized.

The game will likely let you provide multiple group names, in which case it would randomly choose from among them when deciding what to destroy; however, I have not had a reason to try this.

---

[fuse
name = tie_fighter_death_spin
lifetime = 2
death_fuse = true

[destroy_group
at_t = 1
group_name = zomgbayz1
fate = disappear

[destroy_hp_attachment
at_t = 0
hardpoint = HpWeapon01
fate = disappear

[destroy_hp_attachment
at_t = 0
hardpoint = HpWeapon02
fate = disappear

[destroy_hp_attachment
at_t = 0
hardpoint = HpCM01
fate = disappear

[ignite_fuse
at_t = 0
fuse = tie_fighter_port_wing_fuse
fuse_t = 0

[ignite_fuse
at_t = 0
fuse = tie_fighter_starboard_wing_fuse
fuse_t = 0

[tumble
at_t = 0
ang_drag_scale = 0.300000
turn_throttle_z = 0.700000, 0.950000
turn_throttle_x = 0.000000, 0.100000
turn_throttle_y = 0.000000, 0.100000
throttle = 1.000000, 1.000000

[destroy_root
at_t = 0.1, 1

Edit: oh noez, the post length zomgbayz got me. The rest is in the first reply to the thread.

Edited by - Dev on 8/31/2006 10:09:03 PM
Back to top
View user’s profile Send private message Send e-mail

Dev
Old TLR user

Joined: 12 Sep 2004
Posts: 160

PostPosted: Thu Aug 31, 2006 9:08 pm Post subject: Reply with quote
The death fuse is considerably beefier than the damage fuses, and runs when the ship is between 0 and 1 hit points (dead, essentially). Note that death_fuse is set to true; in other words, this fuse will run even when the ship is technically killed.

First off, you can see that all the weapons are destroyed at the start of the fuse to simulate all the weapon systems going offline as the ship breaks up; the engines are not destroyed until the end, which is necessary for the tumble to actually do anything.

The [ignite_fuse is new. This allows you to run any other fuse you want; however, don’'t try running more than one instance of the same fuse simultaneously, as the game will hate on you. As with any fuse, a fuse called this way is run as though it was attached to the root part of the ship.

• fuse = <fuse name=“”>The name of the fuse you want to run.

• fuse_t = <value>I honestly have no idea what this does, nor have I observed much difference by altering it. It may do something, but I haven’'t had any problems leaving it at 0.

We will get to the wing fuses shortly.

The [tumble block is also new.

• ang_drag_scale = <value>I don’'t really know what this does, either. death_comm, which also features a tumble, uses 0.3, and it seems to work. Offhand I would guess it does exactly what it says, scaling the angular drag of the ship by this much; if so, 0.3 would in theory allow the tumbling ship to turn over three times faster, though the game may handle tumbling in such a way that this makes sense.

• turn_throttle_x, y and z = <min>, <max>min and max are on a scale of 0 to 1; these are how hard the ship turns around the given axes (in this case, it’‘s mostly roll). I don’'t know how the game decides what direction the ship will roll. It could be that the range is actually from -1 to 1, but that is total conjecture.

• throttle = <min>, <max>This is the throttle of the main engine, meaning it determines how fast the ship moves forward while tumbling.

Lastly, the all-important [destroy_root. When this event happens, the ship is destroyed; its death explosion happens and it is no more (though I should note that NPCs may randomly run death_comm at this point). In this case I have it happen between times 0.1 and 1; given that the lifetime of the fuse is 2 seconds, this means the ship is actually destroyed between 0.2 and 2 seconds.

---

Now for a look at one of the wing fuses, which gets called at the start of the death spin fuse (the starboard wing fuses is exactly the same in structure). This is actually two fuses, with the first calling the second.

[fuse
name = tie_fighter_port_wing_fuse
lifetime = 0

[ignite_fuse
at_t = 0, 3
fuse = tie_fighter_port_wing_death
fuse_t = 0

As you can see, there is a 1/3 chance that tie_fighter_port_wing_death will run. As a side note, if you don’'t specify death_fuse, it will default to false.

[fuse
name = tie_fighter_port_wing_death
lifetime = 0

[start_effect
at_t = 1
effect = gf_continuous_sparks
hardpoint = DpPort_wing
ori_offset = 0, 90, 0
pos_offset = 0, 0, 0
attached = true

[destroy_group
at_t = 1
group_name = port_wing
fate = debris

If that 1/3 chance happens, the wing is destroyed and a spark effect is placed at the hardpoint DpPort_wing; this hardpoint is placed right at the joint where the wing attaches.

[start_effect has the following parameters:

• effect = <effect_name>The name is a reference to an [Effect, defined in effects.ini or a related effect file.

• hardpoint = <hardpoint_name>Like before, the hardpoint refers to a hardpoint on the ship; you can specify multiple hardpoints to let the game randomly choose, or you can say hardpoint = random to randomly choose between all hardpoints.

• ori_offset = <x_angle>, <y_angle>, <z_angle>How the effect is rotated relative to the hardpoint. The angles are in degrees, and by default they are all 0.

• pos_offset = <x_offset>, <y_offset>, <z_offset>How the effect is positioned relative to the hardpoint. By default all offsets are 0.

• attached = <true, false=“”>If true, the effect will stay connected to the hardpoint until the effect ends or the ship dies. If false, the effect will not be attached to the hardpoint (I believe it continues along the same path it was traveling when it was created).

---

But what about the fuses that were connected to the wings in shiparch.ini? The exist to ensure that when the wings break off, a spark effect will be generated. However, there is some subtlety going on. First off, because damage to a wing will also damage the root ship, and since the wing and root have the same amount of health, killing a wing will also kill the ship. So, the death fuse of the ship will run automatically. Also, when a piece is destroyed it will break off on its own, so the fuse does not need to take care of that.

[fuse
name = tie_fighter_port_wing_break
lifetime = 0

[start_effect
effect = gf_continuous_sparks
hardpoint = DpPort_wing
at_t = 1
ori_offset = 0, 90, 0
attached = true

The effect is the same as the one in the tie_fighter_port_wing_death fuse. The starboard wing has a similar fuse that is structurally the same.

=======================

There are some other fuse events that can prove useful. For example, this is a nifty one:

[damage_root
at_t = 0
damage_type = absolute
hitpoints = 2400

• damage_type = <type>I have only seen absolute; I’'m not sure if there are other types or what they might do.

• hitpoints = <amount>How many hit points the root ship loses.

You could make destructible parts not transfer damage to the root object and instead give them fuses that call damage_root; it may be useful in certain cirumstances. Or you could randomly have a fuse give a ship extra damage.

Another similar one is [damage_group:

[damage_group
group_name = Li_star_wing_lod1
at_t = 0.100000
damage_type = absolute
hitpoints = 50

It works like damage_root except that you can specify the group you want to damage. I think there may be one that lets you damage attachments; just guessing, it would likely be [damage_hp_attachment, and you would specify the hardpoint by one or more hardpoint = <hardpoint_name>lines.

Anyway, that’‘s it for this tutorial. Hopefully you learned something you didn’'t know before.

---

Note: there is also fate = loot</hardpoint_name></amount></type></true,></z_offset></y_offset></x_offset></z_angle></y_angle></x_angle></hardpoint_name></effect_name></max></min></max></min></value></value></fuse></type></hardpoint_name></time></time></time></true,></time2></time1></time></name></z|x|y>

Just noticed: I didn’t manage to explain everything in my first post, will edit a bit now, will make a notice.

[make_invincible]
turn_on = true

put the above into my ship fuse - no effect

I remember Fox posting somewhere that sometimes ships tend to use death_comm fuse instead of those that are declared in shiparch, maybe that’s the case??