Support #1970

Beyond _48_ weapons, help is needed. (NOT 24 mario) (48, yes that limit has been reached)

Added by CeT 3 months ago. Updated 3 months ago.

Status:RejectedStart date:05/18/2014
Priority:NormalDue date:
Assignee:divVerent% Done:

0%

Category:Game Logic
Target version:-

Description

The current code allows up to 48 weapons. With the addition of the morgenstern 48 weapons have been reached (no, weapons will not be removed to make way for others).

Divverent, of Xonotic, Nexuiz, and Darkplaces fame, created the macro code to support 48 weapons. This was an extension of the previous 24 weapon code. When I last talked to him he said that a further extension was trivial, simply follow the pattern of the existing macro code and extend it.

The problem comes from a simple fact that I, and perhaps others, have come to realize is unbreachable: I, your host, am simply not very smart. There are many things I cannot fathom. I get by by sticking to one thing and hammering away at it untill I understand it enough. It took me four years to learn quake C sufficiently to effortlessly move around the code without frustration. Four years.

That is a long time for learning a programming language.

The code that needs to be extended resides in the common directory of the quake C source, specifically the items header file:
qcsrc/common/items.qh

(accessable by web git if you wish here: http://chaosesqueanthology.git.sourceforge.net/git/gitweb.cgi?p=chaosesqueanthology/xonotic-data.pk3dir;a=blob_plain;f=qcsrc/common/items.qh;hb=HEAD )

The code block in question starts at line 93, but note, the code that the anthology uses starts at line 127, note the maxcount 48 (we are using two weapon sets here, we need to extend it to three to add more weapons):
```
[code]
#define WEP_FIRST 1
float WEP_COUNT;
float WEP_LAST;

#if 0
  1. define WEP_MAXCOUNT 24
    // default storage
    .float _WS_weapons;
  2. define WEPSET_BIT(a) power2of((a) - WEP_FIRST)
  3. define WEPSET_DECLARE_A(a) float WS##a
  4. define WEPSET_CLEAR_E(e) ((e)._WS_weapons = 0)
  5. define WEPSET_CLEAR_A(a) (WS##a = 0)
  6. define WEPSET_EMPTY_E(e) ((e)._WS_weapons 0)
  7. define WEPSET_EMPTY_A(a) (WS##a 0)
  8. define WEPSET_COPY_AS(a) (WS##a = getstati(STAT_WEAPONS))
  9. define WEPSET_ADDSTAT() addstat(STAT_WEAPONS, AS_INT, _WS_weapons)
  10. define WEPSET_WRITE_E(dest,a) WriteInt24_t(dest, (a)._WS_weapons)
  11. define WEPSET_WRITE_A(dest,a) WriteInt24_t(dest, WS##a)
  12. define WEPSET_WRITE_W(dest,a) WriteInt24_t(dest, WEPSET_BIT(a))
  13. define WEPSET_READ_E(a) (a)._WS_weapons = ReadInt24_t()
  14. define WEPSET_READ_A(a) (WS##a) = ReadInt24_t()
  15. define WEPSET_OP1_EE(a,b,mergeop,x) ((a)._WS_weapons x (b)._WS_weapons)
  16. define WEPSET_OP2_EE(a,b,mergeop,x,y) ((a)._WS_weapons x (b)._WS_weapons y (a)._WS_weapons)
  17. define WEPSET_OP1_EA(a,b,mergeop,x) ((a)._WS_weapons x WS##b)
  18. define WEPSET_OP2_EA(a,b,mergeop,x,y) ((a)._WS_weapons x WS##b y (a)._WS_weapons)
  19. define WEPSET_OP1_EW(a,b,mergeop,x) ((a)._WS_weapons x WEPSET_BIT(b))
  20. define WEPSET_OP2_EW(a,b,mergeop,x,y) ((a)._WS_weapons x WEPSET_BIT(b) y (a)._WS_weapons)
  21. define WEPSET_OP1_AE(a,b,mergeop,x) (WS##a x (b)._WS_weapons)
  22. define WEPSET_OP2_AE(a,b,mergeop,x,y) (WS##a x (b)._WS_weapons y WS##a)
  23. define WEPSET_OP1_AA(a,b,mergeop,x) (WS##a x WS##b)
  24. define WEPSET_OP2_AA(a,b,mergeop,x,y) (WS##a x WS##b y WS##a)
  25. define WEPSET_OP1_AW(a,b,mergeop,x) (WS##a x WEPSET_BIT(b))
  26. define WEPSET_OP2_AW(a,b,mergeop,x,y) (WS##a x WEPSET_BIT(b) y WS##a)
    #else
  27. define WEP_MAXCOUNT 48
  28. define WEP_FIRST2 25
    .float _WS1_weapons;
    .float _WS2_weapons;
  29. define WEPSET_BIT1(a) (((a) < WEP_FIRST2) ? power2of((a) - WEP_FIRST) : 0)
  30. define WEPSET_BIT2(a) (((a) >= WEP_FIRST2) ? power2of((a) - WEP_FIRST2) : 0)
  31. define WEPSET_DECLARE_A(a) float WS1##a, WS2##a
  32. define WEPSET_CLEAR_E(e) ((e)._WS1_weapons = (e)._WS2_weapons = 0)
  33. define WEPSET_CLEAR_A(a) ((WS1##a) = (WS2##a) = 0)
  34. define WEPSET_EMPTY_E(e) ((e)._WS1_weapons 0 && (e)._WS2_weapons 0)
  35. define WEPSET_EMPTY_A(a) ((WS1##a) 0 && (WS2##a) 0)
  36. define WEPSET_COPY_AS(a) ((WS1##a) = getstati(STAT_WEAPONS), (WS2##a) = getstati(STAT_WEAPONS2))
  37. define WEPSET_ADDSTAT() addstat(STAT_WEAPONS, AS_INT, _WS1_weapons); addstat(STAT_WEAPONS2, AS_INT, _WS2_weapons)
  38. define WEPSET_WRITE_E(dest,a) WriteInt24_t(dest, (a)._WS1_weapons); WriteInt24_t(dest, (a)._WS2_weapons)
  39. define WEPSET_WRITE_A(dest,a) WriteInt24_t(dest, WS1##a); WriteInt24_t(dest, WS2##a)
  40. define WEPSET_WRITE_W(dest,a) WriteInt24_t(dest, WEPSET_BIT1(a)); WriteInt24_t(dest, WEPSET_BIT2(a))
  41. define WEPSET_READ_E(a) (a)._WS1_weapons = ReadInt24_t(); (a)._WS2_weapons = ReadInt24_t()
  42. define WEPSET_READ_A(a) (WS1##a) = ReadInt24_t(); (WS2##a) = ReadInt24_t()
  43. define WEPSET_OP1_EE(a,b,mergeop,x) (((a)._WS1_weapons x (b)._WS1_weapons) mergeop ((a)._WS2_weapons x (b)._WS2_weapons))
  44. define WEPSET_OP2_EE(a,b,mergeop,x,y) (((a)._WS1_weapons x (b)._WS1_weapons y (a)._WS1_weapons) mergeop ((a)._WS2_weapons x (b)._WS2_weapons y (a)._WS2_weapons))
  45. define WEPSET_OP1_EA(a,b,mergeop,x) (((a)._WS1_weapons x WS1##b) mergeop ((a)._WS2_weapons x WS2##b))
  46. define WEPSET_OP2_EA(a,b,mergeop,x,y) (((a)._WS1_weapons x WS1##b y (a)._WS1_weapons) mergeop ((a)._WS2_weapons x WS2##b y (a)._WS2_weapons))
  47. define WEPSET_OP1_EW(a,b,mergeop,x) (((a)._WS1_weapons x WEPSET_BIT1(b)) mergeop ((a)._WS2_weapons x WEPSET_BIT2(b)))
  48. define WEPSET_OP2_EW(a,b,mergeop,x,y) (((a)._WS1_weapons x WEPSET_BIT1(b) y (a)._WS1_weapons) mergeop ((a)._WS2_weapons x WEPSET_BIT2(b) y (a)._WS2_weapons))
  49. define WEPSET_OP1_AE(a,b,mergeop,x) ((WS1##a x (b)._WS1_weapons) mergeop (WS2##a x (b)._WS2_weapons))
  50. define WEPSET_OP2_AE(a,b,mergeop,x,y) ((WS1##a x (b)._WS1_weapons y WS1##a) mergeop (WS2##a x (b)._WS2_weapons y WS2##a))
  51. define WEPSET_OP1_AA(a,b,mergeop,x) ((WS1##a x WS1##b) mergeop (WS2##a x WS2##b))
  52. define WEPSET_OP2_AA(a,b,mergeop,x,y) ((WS1##a x WS1##b y WS1##a) mergeop (WS2##a x WS2##b y WS2##a))
  53. define WEPSET_OP1_AW(a,b,mergeop,x) ((WS1##a x WEPSET_BIT1(b)) mergeop (WS2##a x WEPSET_BIT2(b)))
  54. define WEPSET_OP2_AW(a,b,mergeop,x,y) ((WS1##a x WEPSET_BIT1(b) y WS1##a) mergeop (WS2##a x WEPSET_BIT2(b) y WS2##a))
    #endif

#define XX ,

#define WEPSET_COPY_EE(a,b) WEPSET_OP1_EE(a,b,XX,=)
#define WEPSET_EQ_EE(a,b) WEPSET_OP1_EE(a,b,&&,==)
#define WEPSET_OR_EE(a,b) WEPSET_OP1_EE(a,b,XX,|=)
#define WEPSET_AND_EE(a,b) WEPSET_OP2_EE(a,b,XX,=,&)
#define WEPSET_ANDNOT_EE(a,b) WEPSET_OP1_EE(a,b,XX,&~=)
#define WEPSET_CONTAINS_ANY_EE(a,b) !!(WEPSET_OP1_EE(a,b,||,&))
#define WEPSET_CONTAINS_ALL_EE(a,b) WEPSET_OP2_EE(b,a,&&,==,&)

#define WEPSET_COPY_EA(a,b) WEPSET_OP1_EA(a,b,XX,=)
#define WEPSET_EQ_EA(a,b) WEPSET_OP1_EA(a,b,&&,==)
#define WEPSET_OR_EA(a,b) WEPSET_OP1_EA(a,b,XX,|=)
#define WEPSET_AND_EA(a,b) WEPSET_OP2_EA(a,b,XX,=,&)
#define WEPSET_ANDNOT_EA(a,b) WEPSET_OP1_EA(a,b,XX,&~=)
#define WEPSET_CONTAINS_ANY_EA(a,b) !!(WEPSET_OP1_EA(a,b,||,&))
#define WEPSET_CONTAINS_ALL_EA(a,b) WEPSET_OP2_EA(b,a,&&,==,&)

#define WEPSET_COPY_EW(a,b) WEPSET_OP1_EW(a,b,XX,=)
#define WEPSET_EQ_EW(a,b) WEPSET_OP1_EW(a,b,&&,==)
#define WEPSET_OR_EW(a,b) WEPSET_OP1_EW(a,b,XX,|=)
#define WEPSET_AND_EW(a,b) WEPSET_OP2_EW(a,b,XX,=,&)
#define WEPSET_ANDNOT_EW(a,b) WEPSET_OP1_EW(a,b,XX,&~=)
#define WEPSET_CONTAINS_EW(a,b) !!(WEPSET_OP1_EW(a,b,||,&))

#define WEPSET_COPY_AE(a,b) WEPSET_OP1_AE(a,b,XX,=)
#define WEPSET_EQ_AE(a,b) WEPSET_OP1_AE(a,b,&&,==)
#define WEPSET_OR_AE(a,b) WEPSET_OP1_AE(a,b,XX,|=)
#define WEPSET_AND_AE(a,b) WEPSET_OP2_AE(a,b,XX,=,&)
#define WEPSET_ANDNOT_AE(a,b) WEPSET_OP1_AE(a,b,XX,&~=)
#define WEPSET_CONTAINS_ANY_AE(a,b) !!(WEPSET_OP1_AE(a,b,||,&))
#define WEPSET_CONTAINS_ALL_AE(a,b) WEPSET_OP2_AE(b,a,&&,==,&)

#define WEPSET_COPY_AA(a,b) WEPSET_OP1_AA(a,b,XX,=)
#define WEPSET_EQ_AA(a,b) WEPSET_OP1_AA(a,b,&&,==)
#define WEPSET_OR_AA(a,b) WEPSET_OP1_AA(a,b,XX,|=)
#define WEPSET_AND_AA(a,b) WEPSET_OP2_AA(a,b,XX,=,&)
#define WEPSET_ANDNOT_AA(a,b) WEPSET_OP1_AA(a,b,XX,&~=)
#define WEPSET_CONTAINS_ANY_AA(a,b) !!(WEPSET_OP1_AA(a,b,||,&))
#define WEPSET_CONTAINS_ALL_AA(a,b) WEPSET_OP2_AA(b,a,&&,==,&)

#define WEPSET_COPY_AW(a,b) WEPSET_OP1_AW(a,b,XX,=)
#define WEPSET_EQ_AW(a,b) WEPSET_OP1_AW(a,b,&&,==)
#define WEPSET_OR_AW(a,b) WEPSET_OP1_AW(a,b,XX,|=)
#define WEPSET_AND_AW(a,b) WEPSET_OP2_AW(a,b,XX,=,&)
#define WEPSET_ANDNOT_AW(a,b) WEPSET_OP1_AW(a,b,XX,&~=)
#define WEPSET_CONTAINS_AW(a,b) !!(WEPSET_OP1_AW(a,b,||,&))

WEPSET_DECLARE_A(WEPBIT_ALL);
WEPSET_DECLARE_A(WEPBIT_SUPERWEAPONS);
// note: the fabs call is just there to hide "if result is constant" warning
#define REGISTER_WEAPON_2(id,func,ammotype,i,weapontype,pickupbasevalue,modelname,shortname,wname) \
float id; \
float func(float); \
void RegisterWeapons_##id() \ { \
WEP_LAST = (id = WEP_FIRST + WEP_COUNT); \
WEPSET_OR_AW(WEPBIT_ALL, id); \
if(fabs(weapontype & WEP_FLAG_SUPERWEAPON)) \
WEPSET_OR_AW(WEPBIT_SUPERWEAPONS, id); \
++WEP_COUNT; \
register_weapon(id,func,ammotype,i,weapontype,pickupbasevalue,modelname,shortname,wname); \
} \
ACCUMULATE_FUNCTION(RegisterWeapons, RegisterWeapons_##id)
#ifdef MENUQC
#define REGISTER_WEAPON(id,func,ammotype,i,weapontype,pickupbasevalue,modelname,shortname,wname) \
REGISTER_WEAPON_2(WEP_##id,w_null,ammotype,i,weapontype,pickupbasevalue,modelname,shortname,wname)
#else
#define REGISTER_WEAPON(id,func,ammotype,i,weapontype,pickupbasevalue,modelname,shortname,wname) \
REGISTER_WEAPON_2(WEP_##id,func,ammotype,i,weapontype,pickupbasevalue,modelname,shortname,wname)
#endif

#include "../server/w_all.qc"

#undef REGISTER_WEAPON
ACCUMULATE_FUNCTION(RegisterWeapons, register_weapons_done)

string W_FixWeaponOrder(string order, float complete);
string W_NumberWeaponOrder(string order);
string W_NameWeaponOrder(string order);
string W_FixWeaponOrder_BuildImpulseList(string o);
string W_FixWeaponOrder_AllowIncomplete(string order);
string W_FixWeaponOrder_ForceComplete(string order);

void W_RandomWeapons(entity e, float n);
[/code]
```

How? I don't know, but if you do, please tell!

//-----------------------------------------------------------------------------------//

(So I don't forget)
Note to self: Another file that will need to be edited is the file with the weapon reload code it seems:
near the end of string W_ThrowNewWeapon( in
(line 278 on)
qcsrc/server/cl_weapons.qc
[code]
else if(doreduce) {
for(i = 0, j = 1; i < 24; ++i, j *= 2) {
if(wa & j) {
ammofield = Item_CounterField(j);

// if our weapon is loaded, give its load back to the player
if(self.(weapon_load[self.weapon]) > 0) {
own.ammofield += self.(weapon_load[self.weapon]);
self.(weapon_load[self.weapon]) = -1; // schedule the weapon for reloading
}
thisammo = min(own.ammofield, wep.ammofield);
wep.ammofield = thisammo;
own.ammofield -= thisammo;
s = strcat(s, " and ", ftos(thisammo), " ", Item_CounterFieldName(j));
}
}
s = substring(s, 5, -1);
}
[/code]

the i < 24 stuff, will probably need an aditionally i < 48 if that's possile in qc for loops

items.qh (12.5 KB) CeT, 05/18/2014 05:07 pm

cl_weapons.qc (14.2 KB) CeT, 05/18/2014 05:07 pm


Related issues

Copied from Support #1968: Beyond 48 weapons, help is needed. Closed 05/18/2014

History

#1 Updated by Samual 3 months ago

  • Status changed from New to Rejected

Figure it out yourself you stupid twat.

Also available in: Atom PDF