a spray of missiles firing into random points in the radius around the target

# ----------------------------------------------------------------------------- #
# This is a decompile of the iscript.bin file 'data\scripts\iscript.bin'
# created on: Sun Mar 23 07:14:01 2008
# ----------------------------------------------------------------------------- #

# ----------------------------------------------------------------------------- #
# This header is used by images.dat entries:
# 535 Unknown535 (thingy\elbfireW.grp)
# 534 Unknown534 (thingy\elbfire.grp)
.headerstart
IsId 243
Type 2
Init LasersInit
Death LasersDeath
GndAttkInit LasersGndAttkInit
AirAttkInit [NONE]
.headerend
# ----------------------------------------------------------------------------- #

LasersInit:
tmprmgraphicstart
trgtrangecondjmp 40 LasersLocal00
tmprmgraphicend
LasersLocal00:
playfram 0x00 # frame set 0
playsnd 74 # Bullet\TPhFi100.wav
wait 1
sigorder 1
wait 1
goto LasersGndAttkInit

LasersGndAttkInit:
domissiledmg
wait 2
goto LasersGndAttkInit

LasersDeath:
imgol 447 0 0 # LaserHit (thingy\elbHit.grp)
domissiledmg
wait 1
end

IceCC Command Reference

Format: IceCC opcode name, opcode ID, parameters, opcode description

* playfram 0x00 - <frame#> - displays a particular frame, adjusted for direction.
* playframtile 0x01 - <frame#> - displays a particular frame dependent on tileset.
* sethorpos 0x02 - <x> - sets the current horizontal offset of the current image overlay.
* setvertpos 0x03 - <y> - sets the vertical position of an image overlay.
* setpos 0x04 - <x> <y> - sets the current horizontal and vertical position of the current image overlay.
* wait 0x05 - <#ticks> - pauses script execution for a specific number of ticks.
* waitrand 0x06 - <#ticks1> <#ticks2> - pauses script execution for a random number of ticks given two possible wait times.
* goto 0x07 - <labelname> - unconditionally jumps to a specific code block.
* imgol 0x08 - <image#> <x> <y> - displays an active image overlay at an animation level higher than the current image overlay at a specified offset position.
* imgul 0x09 - <image#> <x> <y> - displays an active image overlay at an animation level lower than the current image overlay at a specified offset position.
* imgolorig 0x0a - <image#> - displays an active image overlay at an animation level higher than the current image overlay at the relative origin offset position.
* switchul 0x0b - <image#> - only for powerups. Hypothesised to replace the image overlay that was first created by the current image overlay.
* __0c 0x0c - no parameters - unknown.
* imgoluselo 0x0d - <image#> <x> <y> - displays an active image overlay at an animation level higher than the current image overlay, using a LO* file to determine the offset position.
* imguluselo 0x0e - <image#> <x> <y> - displays an active image overlay at an animation level lower than the current image overlay, using a LO* file to determine the offset position.
* sprol 0x0f - <sprite#> <x> <y> - spawns a sprite one animation level above the current image overlay at a specific offset position.
* highsprol 0x10 - <sprite#> <x> <y> - spawns a sprite at the highest animation level at a specific offset position.
* lowsprul 0x11 - <sprite#> <x> <y> - spawns a sprite at the lowest animation level at a specific offset position.
* uflunstable 0x12 - <flingy# - creates an flingy with restrictions; supposedly crashes in most cases.
* spruluselo 0x13 - <sprite#> <x> <y> - spawns a sprite one animation level below the current image overlay at a specific offset position. The new sprite inherits the direction of the current sprite. Requires LO* file for unknown reason.
* sprul 0x14 - <sprite#> <x> <y> - spawns a sprite one animation level below the current image overlay at a specific offset position. The new sprite inherits the direction of the current sprite.
* sproluselo 0x15 - <sprite#> <overlay#> - spawns a sprite one animation level above the current image overlay, using a specified LO* file for the offset position information. The new sprite inherits the direction of the current sprite.
* end 0x16 - no parameters - destroys the current active image overlay, also removing the current sprite if the image overlay is the last in one in the current sprite.
* setflipstate 0x17 - <flipstate> - sets flip state of the current image overlay.
* playsnd 0x18 - <sound#> - plays a sound.
* playsndrand 0x19 - <#sounds> <sound#> <...> - plays a random sound from a list.
* playsndbtwn 0x1a - <firstsound#> <lastsound#> - plays a random sound between two inclusive sfxdata.dat entry IDs.
* domissiledmg 0x1b - no parameters - causes the damage of a weapon flingy to be applied according to its weapons.dat entry.
* attackmelee 0x1c - <#sounds> <sound#> <...> - applies damage to target without creating a flingy and plays a sound.
* followmaingraphic 0x1d - no parameters - causes the current image overlay to display the same frame as the parent image overlay.
* randcondjmp 0x1e - <randchance#> <labelname> - random jump, chance of performing jump depends on the parameter.
* turnccwise 0x1f - <turnamount> - turns the flingy counterclockwise by a particular amount.
* turncwise 0x20 - <turnamount> - turns the flingy clockwise by a particular amount.
* turn1cwise 0x21 - no parameters - turns the flingy clockwise by one direction unit.
* turnrand 0x22 - <turnamount> - turns the flingy a specified amount in a random direction, with a heavy bias towards turning clockwise.
* setspawnframe 0x23 - <direction> - in specific situations, performs a natural rotation to the given direction.
* sigorder 0x24 - <signal#> - allows the current unit's order to proceed if it has paused for an animation to be completed.
* attackwith 0x25 - <ground = 1, air = 2> - attack with either the ground or air weapon depending on a parameter.
* attack 0x26 - no parameters - attack with either the ground or air weapon depending on target.
* castspell 0x27 - no parameters - identifies when a spell should be cast in a spellcasting animation. The spell is determined by the unit's current order.
* useweapon 0x28 - <weapon#> - makes the unit use a specific weapons.dat ID on its target.
* move 0x29 - <movedistance> - sets the unit to move forward a certain number of pixels at the end of the current tick.
* gotorepeatattk 0x2a - no parameters - signals to StarCraft that after this point, when the unit's cooldown time is over, the repeat attack animation can be called.
* engframe 0x2b - <unknown> - plays a particular frame from a frameset.
* engset 0x2c - <unknown> - causes the current image overlay to display the same frame as the parent image overlay. Appears to have the same function as followmaingraphic
* __2d 0x2d - no parameters - hypothesised to hide the current image overlay until the next animation.
* nobrkcodestart 0x2e - no parameters - holds the processing of player orders until a nobrkcodeend is encountered.
* nobrkcodeend 0x2f - no parameters - allows the processing of player orders after a nobrkcodestart instruction.
* ignorerest 0x30 - no parameters - conceptually, this causes the script to stop until the next animation is called.
* attkshiftproj 0x31 - <distance> - creates the weapon flingy at a particular distance in front of the unit.
* tmprmgraphicstart 0x32 - no parameters - sets the current image overlay state to hidden.
* tmprmgraphicend 0x33 - no parameters - sets the current image overlay state to visible.
* setfldirect 0x34 - <direction> - sets the current direction of the flingy.
* call 0x35 - <labelname> - calls a code block.
* return 0x36 - no parameters - returns from call.
* setflspeed 0x37 - <speed> - sets the flingy.dat speed of the current flingy.
* creategasoverlays 0x38 - <gasoverlay#> - creates gas image overlays at offsets specified by LO* files.
* pwrupcondjmp 0x39 - <labelname> - jumps to a code block if the current unit is a powerup and it is currently picked up.
* trgtrangecondjmp 0x3a - <distance> <labelname> - jumps to a block depending on the distance to the target.
* trgtarccondjmp 0x3b - <angle1> <angle2> <labelname> - jumps to a block depending on the current angle of the target.
* curdirectcondjmp 0x3c - <unknown> <unknown> <labelname> - only for units. Jump to a code block if the current sprite is facing a particular direction.
* imgulnextid 0x3d - <x> <y> - displays an active image overlay at the shadow animation level at a specified offset position. The image overlay that will be displayed is the one that is after the current image overlay in images.dat.
* __3e 0x3e - no parameters - unknown.
* liftoffcondjmp 0x3f - <labelname> - jumps to a code block when the current unit that is a building that is lifted off.
* warpoverlay 0x40 - <frame#> - hypothesised to display the current image overlay's frame clipped to the outline of the parent image overlay.
* orderdone 0x41 - <unknown> - makes a unit repeat an order in a special way.
* grdsprol 0x42 - <sprite#> <x> <y> - spawns a sprite one animation level above the current image overlay at a specific offset position, but only if the current sprite is over ground-passable terrain.
* __43 0x43 - no parameters - unknown.
* dogrddamage 0x44 - no parameters - applies damage like domissiledmg when on ground-unit-passable terrain.

Using turnrand is a ridiculous way -- mainly because its annoying having the unit turn back to its original position. And don't you dare say, "Who cares?" because that's the worst thing to think.

Just use a list of random jumps and have each on turn and turn back a certain amount.

Now, if you are going to use turnrand, you need a list of curdirectcondjmp's to make it face the proper way after the attack.

Random Attack Sequences:

In order to have a unit use random attacks, we need to use the "randcondjmp" opcode in the attack sequence. The probibility in this opcode is based off of 255.

x /100 = % / 255

255 * x / 100 = %

I know that in the end we will have 20 different attack sequences, plus one critical hit sequence. I know I want the critical hit to happen less than the regular sequence, but will naturally happen because of the nature of SC code.

54 = %

So, we will have:

randcondjmp 54 AttackStyle0
randcondjmp 54 AttackStyle1
randcondjmp 54 AttackStyle2
randcondjmp 54 AttackStyle3
randcondjmp 54 AttackStyle4
randcondjmp 54 AttackStyle5
randcondjmp 54 AttackStyle6
randcondjmp 54 AttackStyle7
randcondjmp 54 AttackStyle8
randcondjmp 54 AttackStyle9
randcondjmp 54 AttackStyle10
randcondjmp 54 AttackStyle11
randcondjmp 54 AttackStyle12
randcondjmp 54 AttackStyle13
randcondjmp 54 AttackStyle14
randcondjmp 54 AttackStyle15
randcondjmp 54 AttackStyle16
randcondjmp 54 AttackStyle17
randcondjmp 54 AttackStyle18
randcondjmp 54 AttackStyle19
randcondjmp 54 AttackStyle20
randcondjmp 54 AttackStyle21


(Entry point to produce that was:

for(var BLARG = 0; BLARG < 22; BLARG ++) {
outputStream.WriteLine("randcondjmp 54 AttackStyle" + BLARG);
})

Now, our weapons will need to be modified for this version of random weaponry to work:

Go to datedit and go to a unit that you would like to change.

Make its ground weapon use any weapon that uses Gemini Missile graphics and goes to Max Range. Add some splash damage and make its Max Range about 8.

Do the same to the Air weapon, except make its Max Range about 2-4.

Now make Weapon 123 any weapon that will use an explosion when it hits its target.

Now, we create the code for the random weapons:


Code
var fso = new ActiveXObject("Scripting.FileSystemObject");
var outputFileName = fso.GetParentFolderName(WScript.ScriptFullName) + "\\" + fso.GetBaseName(WScript.ScriptFullName) + ".txt";
var outputStream = fso.CreateTextFile(outputFileName, true);

var number = 0
for(var attackNum = 1; attackNum < 3; attackNum ++) {
for(var turn = 0; turn < 5; turn ++) {
outputStream.WriteLine("AttackStyle" + number++ + ":");
outputStream.WriteLine(" turncwise " + turn);
outputStream.WriteLine(" attackwith " + attackNum);
outputStream.WriteLine(" turnccwise " + turn);
outputStream.WriteLine(" goto EndofAttackSequence");
outputStream.WriteLine("");

outputStream.WriteLine("AttackStyle" + number++ + ":");
outputStream.WriteLine(" turnccwise " + turn);
outputStream.WriteLine(" attackwith " + attackNum);
outputStream.WriteLine(" turncwise " + turn);
outputStream.WriteLine(" goto EndofAttackSequence");
outputStream.WriteLine("");
}
}

outputStream.Close();


We initiate a variable (attackNum) that will change which weapon we use (ground or air). We then initiate a variable that will output what degree our unit will attack.

While messing with the randcondjmp, I realized that my method isn't very random... It favors the first random jump. I tried this:


Code
var fso = new ActiveXObject("Scripting.FileSystemObject");
var outputFileName = fso.GetParentFolderName(WScript.ScriptFullName) + "\\" + fso.GetBaseName(WScript.ScriptFullName) + ".txt";
var outputStream = fso.CreateTextFile(outputFileName, true);

//Functions
function func1(n) {
i = Math.round(51 + 3.8 * n * 256 / 100);
return i
}

//i = original [51] + (4/total) * BLARG * 256 / 100


//Program Entry Point
for(var BLARG = 0; BLARG < 22; BLARG ++) {
outputStream.WriteLine("randcondjmp " + func1(BLARG) + " AttackStyle" + BLARG);
}
outputStream.Close();


Which outputs this:
randcondjmp 51 AttackStyle0
randcondjmp 61 AttackStyle1
randcondjmp 70 AttackStyle2
randcondjmp 80 AttackStyle3
randcondjmp 90 AttackStyle4
randcondjmp 100 AttackStyle5
randcondjmp 109 AttackStyle6
randcondjmp 119 AttackStyle7
randcondjmp 129 AttackStyle8
randcondjmp 139 AttackStyle9
randcondjmp 148 AttackStyle10
randcondjmp 158 AttackStyle11
randcondjmp 168 AttackStyle12
randcondjmp 177 AttackStyle13
randcondjmp 187 AttackStyle14
randcondjmp 197 AttackStyle15
randcondjmp 207 AttackStyle16
randcondjmp 216 AttackStyle17
randcondjmp 226 AttackStyle18
randcondjmp 236 AttackStyle19
randcondjmp 246 AttackStyle20
randcondjmp 255 AttackStyle21

And it works fairly better, but it now favors the random jumps at the end. I'm messing around with the random condition jumps so that every single randcondjmp has the same percentage of firing.

Here's why the first idea I had was wrong:

The first one has a 54/254 chance of firing. The second one has a 54/255 chance of firing IF the first one doesnt fire (201/256). So, the next one needs to have a HIGHER chance of firing so that it is still the same percentage as the first one.

math.round(256/(totalNumberOfPaths - n)

Is that really necessary? I just did an unconditional jump for the last one.

EndofAttackSquence:
wait 1
nobrkcodeend
ignorerest
playfram 0x11
wait 1
gotorepeatattk

EndofAttackSquence:
wait 1
nobrkcodeend

EndofAttackSquence:

Squence

You keep forgetting that you need: