Global Variables and Bitwise Operations

[dude_obj]

One of the most dangerous things a script can do is attempt to make a critter wield a weapon when the critter doesn't have the necessary animation (pistol, rifle, throw, etc). A critter will often either just disappear or the game will crash if this is attempted. Having changed what almost every critter in the game wields, I learned it is very easy to make mistakes with weapons in the hands of characters that can't use them. So I've been pondering how to do two things:

1) A check to see if any given critter can use any weapon
2) A way to randomize what weapons critters use

I already solved the second part, I have 5 new script commands that select random items, some are for random loot, some are for random store inventory, and there already is facility to handle random weapon generation. The first problem is more difficult to solve.

What I've been thinking for a week is this: it only requires one bit of storage to specify if a critter can use any particular weapon or attack. So there is no need to have a gazillion different variables for this. And this is really interesting: did you know that you can store many different values in a SINGLE global variable? Yes, its possible with bitwise operations, and this is why you see the bwand (bitwise and) and bwor (bitwise or) opcodes among the scripting commands. So I figured out a solution for this problem, one global variable for each unique appearance (FRM) stores multiple bits (0 or 1) and each bit represents an attack type. Here's how it's done:

First definition of the bits, if you look in define.h, you'll see that they already defined names for bit_1 through bit_32, example:

#define bit_1 ( 1 )
#define bit_2 ( 2 )
#define bit_3 ( 4 )
#define bit_4 ( 8 )
#define bit_5 ( 16 )
#define bit_6 ( 32 )
#define bit_7 ( 64 )
#define bit_8 ( 128 )
#define bit_9 ( 256 )

These are of course, powers of 2 because we're talking about binary bits.
So what I can do is define bits that represent attacks, like this:

#define ATTACK_PISTOL bit_1
#define ATTACK_RIFLE bit_2
#define ATTACK_BIGGUN bit_3

So how can I make one global variable store ALL of the attacks for a given character? It can be done using bitwise or (bwor) to set a bit and bitwise and (bwand) to check if a bit is set. For example:

set_global_var(GVAR_NAME, GVAR_NAME bwor bit_1)

This will set the first bit in that global variable, and to check if its set:

x = (global_var(GVAR_NAME) bwand bit_1)

If x equals the value of the bit (1,2,4,8,16,32...) in this case 1 ... then the bit is set.

Now, how to avoid a huge chain of if-then-else to check these bits? Well, each FRM has a unique identifier called FID (File ID) and they start at number 16777217, and ascend following the order of frm names in \art\critters.lst. What I need is to make an frm name map to a global variable, then store within the bits of the global which attacks are available. The game already uses global variables up to number 695. So what I figured was this: the first critter will use 701, and they ascend in the global variable index in the same order as they do in critters.lst. This way I can use the art fid number to access the global variable by index. So I define one simple formula:

#define GVAR_ARTFID_INDEX obj_art_fid(self_obj) - 16776516

This gets the art fid number from the system, and converts it into a gvar index number. Take for example the first critter in critters.lst, its art fid number is 16777217. Plugging that into the above formula we get 701, exactly where I want to start having GVARs for attack lookups. So this formula will automatically work for any critter, take the HMWARR character that you start as, his fid number is 16777278, and using the formula this makes him GVAR 762. I'll use HMWARR as an example of how this lookup works.

I define GVARs for all of the critters in \data\vault13.gam:

GVAR_ATTACKS_hapowr :=0; // (701)
GVAR_ATTACKS_harobe :=0; // (702)
GVAR_ATTACKS_hfcmbt :=0; // (703)
GVAR_ATTACKS_hfjmps :=0; // (704)
...
GVAR_ATTACKS_hmwarr :=0; // (762)

Note that these exactly follow the order of critters in critters.lst, because this order is the same order as art fid number returned by the script command obj_art_fid(self_obj) .. and subtracting 16776516 yields the index in the GVAR list. So now I know where to set or get bits, and I don't need to use names, I can use variable numbers, and since art fid (critter art file number) comes from the system, I can make one command work with any critter.

Next I define the bits for all of the attacks:

#define ATTACK_PISTOL bit_1
#define ATTACK_SMG bit_2
#define ATTACK_RIFLE bit_3
#define ATTACK_BIGGUN bit_4
#define ATTACK_FLAMER bit_5
#define ATTACK_MINIGUN bit_6
#define ATTACK_ROCKET bit_7
#define ATTACK_KNIFE bit_8
#define ATTACK_CLUB bit_9
#define ATTACK_SLEDGE bit_10
#define ATTACK_SPEAR bit_11
#define ATTACK_PUNCH bit_12
#define ATTACK_KICK bit_13
#define ATTACK_THROW bit_14

Those are all of the attacks, so 14 bits are needed for each critter to store their available attack. This means: if a bit is set they can use that type of weapon or attack.

I already have a spreadsheet that lists all of the attacks for each critter, this is a bit of work, but I can set the bits for critters at the beginning of the game, for example in the artemple map script, the first script to run. All attacks get loaded into GVARs and are therefore available to be checked by any script, anywhere in the game. Here's an example of setting the attacks for the primitive warrior (HMWARR) that the player starts as:

I need a mapping of FRM name to GVAR index for convenience:

#define GVAR_ARTFID_HMWARR (762)

And I define two macros, one for setting bits, and one for getting bits:

#define SET_ATTACK(frm,type) set_global_var(frm, global_var(frm) bwor type)
#define GET_ATTACK(frm,type) (global_var(frm) bwand type)

Then I proceed to set the attack bits for HMWARR character:

SET_ATTACK(GVAR_ARTFID_HMWARR, ATTACK_SPEAR);
SET_ATTACK(GVAR_ARTFID_HMWARR, ATTACK_PUNCH);
SET_ATTACK(GVAR_ARTFID_HMWARR, ATTACK_KICK);
SET_ATTACK(GVAR_ARTFID_HMWARR, ATTACK_THROW);

Now I can check if ANY character can use ANY WEAPON like this:

if ((GET_ATTACK(GVAR_ARTFID_INDEX, ATTACK_SPEAR)) == ATTACK_SPEAR) then display_msg("Spear");

Note how it automatically gets the artfid from a macro that finds the right location of the global variable. The GET_ATTACK command will return the same bit value for spear (bit_11 which is 1024 or 2 ^ 10 within a 32-bit address) IF that bit is set, otherwise zero. I had to check to make sure we can address up to 32-bits for GVARs and yes it works. This means that every GVAR can store 32 on/off states. And if you think about permutations/combinations of those states, a single GVAR can represent a very large number of unique events or states. If you can project where I'm going with this, all I need is a lookup of the bit number by item PID for weapons, and I can distill it down to one simple command:

if (weapon_check(PID_WEAPON))

and I can combine that with my selectRandomWeapon command:

while not (weapon_check(PID_WEAPON)) do begin
weapon := selectRandomWeapon();
end

I have different variants of the selectRandomWeapon command, it can be totally random (any weapon type) or it can be randomized within a type (energy rifles, miniguns, thrown weapons etc). The above command will keep picking weapons until it finds one that the critter has an attack animation for. Now we have random loot, random store inventories, and random weapons on critters.

Putting together the peices in a small example (2 weapon types and one critter):

#define ATTACK_PISTOL bit_1
#define ATTACK_SMG bit_2

#define GVAR_ARTFID_INDEX obj_art_fid(self_obj) - 16776516
#define GVAR_ARTFID_HAPOWR (701)

#define SET_ATTACK(frm,type) set_global_var(frm, global_var(frm) bwor type)
#define GET_ATTACK(frm,type) (global_var(frm) bwand type)

procedure start;
procedure talk_p_proc;

procedure start begin
SET_ATTACK(GVAR_ARTFID_HAPOWR, ATTACK_PISTOL);
SET_ATTACK(GVAR_ARTFID_HAPOWR, ATTACK_SMG);
end

procedure talk_p_proc begin
if ((GET_ATTACK(GVAR_ARTFID_INDEX, ATTACK_PISTOL)) == ATTACK_PISTOL) then display_msg("PISTOL");
if ((GET_ATTACK(GVAR_ARTFID_INDEX, ATTACK_SMG)) == ATTACK_SMG) then display_msg("SMG");
end

The #define parts will be placed in a header file so any script can include them. The SET_ATTACK commands will be done in the first script that runs (artemple map script) so the attack bits are available to any script in the game.

One of the things that annoys me the most about FO scripting is lack of arrays. It makes it difficult to do lookups or operations on sets. However, the bitwise operations in conjunction with GVARs provides a way to do this very efficiently. As you can see, GVARs are very powerful.

 

[Wild_qwerty]

Wow, That sounds great Dude_Obj!

I think I followed most of that Well I followed the idea of what you mean anyway, even if I dont quite get the code

Makes for a whole lot of replay value without the risk of the game crashing.

Now if only you could generate random maps! Though it would be cool to give each town a slightly random location (it could move up to 2 or 3 squares from its normal FO2 location.

Would it be possible to alter these locations? I know the special encounters are in complete random places, but is it possible to specify that the town appears with a certian area of the map, but not always the exact same postition.

 

[jargo]

Great idea dude, don't forget to post this header file when it is ready.

Would it be possible to alter these locations? I know the special encounters are in complete random places, but is it possible to specify that the town appears with a certian area of the map, but not always the exact same postition.

I think yes, it is possible to do.
We have wm_area_set_pos function that can set position of any city in city.txt to desired coordinates.
I did not test it yet but it was used in DNSLVRUN.ssl script.

wm_area_set_pos(AREA_DEN_SLAVE_RUN, temp_map_loc_x, temp_map_loc_y);

So we can in artemple maps script set new positions of any location.

 

[Raven_2]

to dude_obj

I don`t mean offence, but bitwise r/w is in history

Check this code:

#define var variable

procedure start begin end

procedure atoiar(var ostr,var cell) begin
  var i;var val; var str:=""; var c_cell; var flag;
  while c_cell<=cell do begin
   val:=0; flag:=1;

   while ((ostr!=str) and (flag)) do begin
    while not((ostr>str+i and ostr<str+(i+1)) or ostr==str+i) and i<9 do i+=1;
    if i==9 and ostr>str+":" and ostr<str+";" then begin flag:=0; str+=":"; end
    else begin str+=i; val:=val*10+i; end
    i:=0;
   end
		
   c_cell+=1;
  end
  return val;
end

#define add_el(el)	if val!="" then val+=":"+el; else val+=el

procedure talk_p_proc begin
 var val:=""; var i;
 while i<10 do begin
  add_el(random(1,1000000));
  i+=1;
 end
 i-=1;
 while i!=0 do begin
  display_msg("El #"+i+"="+atoiar(val,i));
  i-=1;
 end
end

It writes 10 random numbers from 1 to 1000000 into *one* string variable, placing ":" beside them ("1:2:3:4", for example). Int and float are 32 bit, but string is unlimited (well, I mean, has no hard limit). atoir procedure convert part of ascii string back to int (for ex. atoir("1:2",1) returns 2. 2 not "2"). Only bad thing - there is no easy way for work with strings, atoir it`s a hack of sort so it work slowly and on not-so-fast machines big arrays may cause slowdowns.

I can describe voodoo magc of atoir, if you want Whole procedure and idea is my babies

[EDIT]

On my Athlon XP 3000 r/w of 50 random varibles from 100 to 999 (string contain 3*50+48=198 symbols) go in 3-4 sec. Well, it`s not to high price for ability to work with arrays, I suppose And, of course, atoiar works only witn numeric values.

It works great for array with 5-10 pointers/tilenums.

 

[dude_obj]

I think I followed most of that Well I followed the idea of what you mean anyway, even if I dont quite get the code

Here's a simpler way of explaining what happens. We have 14 attacks and I'm using one binary bit (1 or 0) within a 32-bit global variable to store the attacks. So a GVAR for HMWARR starts as this (the first 14 bits of the variable):

00000000000000 (ie no attacks)

The HMWARR has the last 4 attacks so we want
00000000001111

A hero model will always be
11111111111111 (all attacks)

And the bwor bitwise command is how you set those bits. Its somwhat confusing because any given bit within the 32-bits is accessed by its binary bit number 1,2,4,8,16,32,64...

And then using bwand I check if a bit is set

The other tricky part was just mapping the FRM art fid number to a position (index number) of the global variable where that character's attack data is stored.

 

[dude_obj]

It writes 10 random numbers from 1 to 1000000 into *one* string variable, placing ":" beside them ("1:2:3:4", for example).

That is very cool but I wouldn't say it makes bitwise history. The BWOR and BWAND are very efficient. I use exactly one bit to store an attack type, and doing the bitwise command to set or get that value takes almost no processing. But I'm impressed, because you found a way to make arrays.

 

[Raven_2]

>>That is very cool but I wouldn't say it makes bitwise history.

I mean "widely known" by "in history". bwor and bwand are widely used in F2 script sources.

BTW, i write a document in russian called FScript-HowTo. There is already six chapters. Six chapter contain info about bitwise i/o. So, jargo, check this if you want

 

[dude_obj]

I know the bitwise commands are widely known, but I've never seen anyone do something like what I am doing with them: a macro that indexes art to gvar, and storing attack info in the gvar.

There are 120 critters in my critters.lst, each of which can have 14 attacks. That's 120*14=1680 conditions! So its a good thing to use a single bit for each of those conditions.

What I'm wondering now is whether I can get the animation code (J-RIFLE, etc) from a script command reading item protos. If I can then I can convert that to the proper bit value and lookup in the GVAR (bwand) to see if a critter can use a weapon.

 

[Raven_2]

>>I know the bitwise commands are widely known, but I've never seen anyone do something like what I am doing with them: a macro that indexes art to gvar, and storing attack info in the gvar.

I use bw i/o in poker game script from NV. It save me > 100 LVAR

 

[dude_obj]

Great idea dude, don't forget to post this header file when it is ready.

Okay, here's my whole set of randomization routines. There are several headers that work together. Note that this is all set up for a bunch of new items and critters, so it would need to be modified to work with stock FO2 or other mods.

NEWITEMS.H - Better PID names for existing items and names for new items.
NEWCRITR.H - New critter PID names.
ANIMTYPE.H - Commands for checking if critters have attack animations
RESTOCK.H - Commands for random item generation and inventory/container stocking, critter outfitting.
DEBUG.H - The new commands write to this debug routine (optionally)



The way this works, the first script in the game artemple.map runs the command to store all critter attack types in GVARs:

procedure start begin
if (is_loading_game == false) then call setCritterWeaponAnimFlags;
end

Then other commands read those bit flags to check if any given critter can use any given weapon. These are the new commands added by the animtype.h and restock.h headers. I will have some better documentation and a new version of the headers in a short while ...

Commands in ANIMTYPE.H

setCritterWeaponAnimFlags
Set weapon animation flags (binary bits) for all critters
This command only needs to be run once at beginning of game (artemple.map script)


setAnimBit(gvarIndex, weaponAnimBit)
Set GVAR weapon animation bit to input animantion type
Use binary bit address to set bits indicating what weapon a critter can use
This is called by setCritterWeaponAnimFlags


checkCritterWeaponAnim(critterPtr, weaponAnimType)
Return true if critter can use weapon type


getWeaponAnimIndex(animType)
Return weapon animation binary bit address (for input weapon type)
Used for lookup in global variable, called by checkCritterWeaponAnim


getWeaponAnimType(weaponPID)
Return weapon type for weapon
Can't seem to read the animation code from proto_data(it_data)!
Therefore need lookup to determine animation for weapon PID


getWeaponAnimName(animType)
Return weapon animation type (name) for input weapon type (number)
Used for building list of weapons types a critter can wield


getWeaponAnimNameList(critterPtr)
Return comma separated list of weapon types a critter can use



Commands in RESTOCK.H

createItem(objectPtr, itemPID, qtyMin, qtyMax, chance)
Add input item pid (number) to inventory of input object (pointer)


createRandomItem(objectPtr, itemSubtype, qtyMin, qtyMax, chance, rollCap)
Add random item to inventory of input object (pointer) of item subtype (number)


pickRandomItem(itemSubtype, rollCap)
Return random item PID number (int) for input item subtype number (int)


pickRandomArmor(armorSubtype, rollCap)
Return random armor item PID number for input armor subtype number (int)


createRandomWeapon(objectPtr, weaponSubtype, qtyMin, qtyMax, chance, rollCap)
Add random weapon to inventory of input object (pointer) of input weapon item subtype number (int)


pickRandomWeapon(weaponSubtype, rollCap)
Return random weapon item PID number (int) for input weapon subtype (int)


createUsableRandomWeapon(critterPtr, weaponSubtype, rollCap)
Add random weapon item to inventory of input critter (pointer) that critter can use (has required animations)


pickUsableRandomWeapon(critterPtr, weaponSubtype, rollCap)
Return random weapon item PID number (int) that input critter (pointer) can use (has required animations)


wieldUsableRandomWeapon(critterPtr, rollCap)
Wield weapon item PID number (int) that matches input critter (pointer) best combat skill
Also create ammo that matches the weapon and add to critter inventory


getWeaponAmmo(weaponPID)
Return default ammo item PID number (int) for input weapon PID number (int)


getBestCombatSkill(critterPtr)
Return highest combat skill type (int) for input critter (pointer)
Used so critter can wield weapon usable in its highest combat skill type


getWeaponSkillGroup(skillNumber)
Return weapon skill group (int) that matches skill number (int)
Used to select random weapons by skill type rather than weapon type


getCombatSkillName(skillNumber)
Return combat skill name (string) for input skill number (int)


clearInvenAll(objectPtr)
Remove all items from inventory and destroy


clearInvenWeapons(objectPtr)
Remove all weapon items from inventory and destroy


clearInvenStore(objectPtr)
Remove all objects from inventory except FO2 quest items


itemPID_is_quest_item(itemPID)
Return true if input item (pid number) is Fallout2 quest item
Used to ensure stores don't delete quest items from inventory

 

[Mangler]

I hate to break it to ya...but the Styer and Ruger are RIFLES.

This mistake was clearly left over from the FO:Tactics items.
Is it too late to change?

Also there was an extra PID_PISTOL_BERETTA in: ANIMTYPE.H

procedure getWeaponAnimType(variable weaponPID) begin
...

Also, GJ Dude_Obj!

 

[dude_obj]

I hate to break it to ya...but the Styer and Ruger are RIFLES. This mistake was clearly left over from the FO:Tactics items.

Corpse already corrected me on steyr, which actually is a rifle anim in the proto now. The Ruger is called Automatic Carbine in the item description, okay its now a rifle too. This is an interesting pic:

http://www.weaponsboard.com/webbbs/nfa.cgi/noframes/read/274

Is it too late to change?

Too late, no, catching this even before beta is pretty good. The protos and headers have been changed.

The Thompson was also wrong, its a rifle anim.

Also there was an extra PID_PISTOL_BERETTA in: ANIMTYPE.H

Was yes, it's gone, thanks.

 

[jargo]

Hey great job Dude, this is a complete system , this headers will come handy in future mods.

 

[Corpse]

I hate to break it to ya...but the Styer and Ruger are RIFLES. This mistake was clearly left over from the FO:Tactics items.

Corpse already corrected me on steyr, which actually is a rifle anim in the proto now. The Ruger is called Automatic Carbine in the item description, okay its now a rifle too. This is an interesting pic:

http://www.weaponsboard.com/webbbs/nfa.cgi/noframes/read/274

Cool, a C-Mag for an AC556 would always come in handy, could script it like we planned to script the drum mag for the AK.

Is it too late to change?

Too late, no, catching this even before beta is pretty good. The protos and headers have been changed.

The Thompson was also wrong, its a rifle anim.

Actually the Thompson is ok to use a rifle anim even though it's a submachine gun; if you change it to use the SMG animation code, the mobsters won't be able to use it.

 

[dude_obj]

Cool, a C-Mag for an AC556 would always come in handy, could script it like we planned to script the drum mag for the AK.

Corpse has some really cool weapon ideas ...

Actually the Thompson is ok to use a rifle anim even though it's a submachine gun; if you change it to use the SMG animation code, the mobsters won't be able to use it.

It has always been a rifle in the proto, but I mistakenly named it as SMG in its PID name, and then wrongly placed it in the anim code lookup table so it would require SMG animation. I'm glad I caught this now because that's the kind of thing that will crash the game.