break;
case 3: // weapon name
- drawstring(weapon_pos, strtolower(self.message), label_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
+ drawstring(weapon_pos, strtolower(self.m_name), label_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
break;
default: // nothing
#define EFFECT(istrail, name, realname) \
REGISTER(RegisterEffects, EFFECT, Effects, name, m_id, Create_Effect_Entity(realname, istrail));
-void RegisterEffects_First()
-{
- #ifdef SVQC
- #define dedi (server_is_dedicated ? "a dedicated " : "")
- #else
- #define dedi ""
- #endif
-
- LOG_TRACEF("Beginning effect initialization on %s%s program...\n", dedi, PROGNAME);
- #undef dedi
-}
-
-void RegisterEffects_Done()
-{
- LOG_TRACE("Effects initialization successful!\n");
-}
-
-// NOW we actually activate the declarations
-ACCUMULATE_FUNCTION(RegisterEffects, RegisterEffects_First)
EFFECT(0, Null, string_null)
#include "all.inc"
-ACCUMULATE_FUNCTION(RegisterEffects, RegisterEffects_Done)
#endif
/* flags */ ATTRIB(BallStealer, spawnflags, int, WEP_TYPE_OTHER | WEP_FLAG_HIDDEN | WEP_FLAG_MUTATORBLOCKED);
/* impulse */ ATTRIB(BallStealer, impulse, int, 0);
/* refname */ ATTRIB(BallStealer, netname, string, "ballstealer");
-/* wepname */ ATTRIB(BallStealer, message, string, _("Ball Stealer"));
+/* wepname */ ATTRIB(BallStealer, m_name, string, _("Ball Stealer"));
ENDCLASS(BallStealer)
REGISTER_WEAPON(NEXBALL, NEW(BallStealer));
#endif
#endif
-
-#include "inventory.qh"
{
WriteByte(MSG_ENTITY, ENT_CLIENT_INVENTORY);
entity e = self.owner;
- if (IS_SPEC(e)) e = e.enemy;
+ if (/*IS_SPEC(e)*/ (e.classname == "spectator")) e = e.enemy;
Inventory data = e.inventory;
Inventory_Write(data);
return true;
void Inventory_new(entity e)
{
Inventory inv = new(Inventory), bak = new(Inventory);
- inv.classname = "inventory", bak.classname = "inventory";
+ inv.classname = bak.classname = "inventory";
inv.inventory = bak;
inv.drawonlytoclient = e;
Net_LinkEntity((inv.owner = e).inventory = inv, false, 0, Inventory_Send);
#ifndef MENUQC
MODEL(ArmorSmall_ITEM, Item_Model("item_armor_small.md3"));
+SOUND(ArmorSmall, "misc/armor1.wav");
#endif
REGISTER_ITEM(ArmorSmall, Armor) {
#ifndef MENUQC
this.m_model = MDL_ArmorSmall_ITEM;
+ this.m_sound = SND_ArmorSmall;
#endif
- this.m_sound = "misc/armor1.wav";
this.m_name = "5 Armor";
this.m_icon = "armor";
#ifdef SVQC
#ifndef MENUQC
MODEL(ArmorMedium_ITEM, Item_Model("item_armor_medium.md3"));
+SOUND(ArmorMedium, "misc/armor10.wav");
#endif
REGISTER_ITEM(ArmorMedium, Armor) {
#ifndef MENUQC
this.m_model = MDL_ArmorMedium_ITEM;
+ this.m_sound = SND_ArmorMedium;
#endif
- this.m_sound = "misc/armor10.wav";
this.m_name = "25 Armor";
this.m_icon = "armor";
#ifdef SVQC
#ifndef MENUQC
MODEL(ArmorLarge_ITEM, Item_Model("item_armor_big.md3"));
+SOUND(ArmorLarge, "misc/armor17_5.wav");
#endif
REGISTER_ITEM(ArmorLarge, Armor) {
#ifndef MENUQC
this.m_model = MDL_ArmorLarge_ITEM;
+ this.m_sound = SND_ArmorLarge;
#endif
- this.m_sound = "misc/armor17_5.wav";
this.m_name = "50 Armor";
this.m_icon = "armor";
this.m_color = '0 1 0';
#ifndef MENUQC
MODEL(ArmorMega_ITEM, Item_Model("item_armor_large.md3"));
+SOUND(ArmorMega, "misc/armor25.wav");
#endif
REGISTER_ITEM(ArmorMega, Armor) {
#ifndef MENUQC
this.m_model = MDL_ArmorMega_ITEM;
+ this.m_sound = SND_ArmorMega;
#endif
- this.m_sound = "misc/armor25.wav";
this.m_name = "100 Armor";
this.m_icon = "item_large_armor";
this.m_color = '0 1 0';
#include "pickup.qh"
CLASS(Armor, Pickup)
#ifdef SVQC
+ ATTRIB(Armor, m_mins, vector, '-16 -16 0')
+ ATTRIB(Armor, m_maxs, vector, '16 16 48')
ATTRIB(Armor, m_pickupevalfunc, float(entity player, entity item), commodity_pickupevalfunc)
#endif
ENDCLASS(Armor)
#ifndef MENUQC
MODEL(HealthSmall_ITEM, Item_Model("g_h1.md3"));
+SOUND(HealthSmall, "misc/minihealth.ogg");
#endif
REGISTER_ITEM(HealthSmall, Health) {
#ifndef MENUQC
this.m_model = MDL_HealthSmall_ITEM;
+ this.m_sound = SND_HealthSmall;
#endif
- this.m_sound = "misc/minihealth.wav";
this.m_name = "5 Health";
this.m_icon = "health";
#ifdef SVQC
#ifndef MENUQC
MODEL(HealthMedium_ITEM, Item_Model("g_h25.md3"));
+SOUND(HealthMedium, "misc/mediumhealth.ogg");
#endif
REGISTER_ITEM(HealthMedium, Health) {
#ifndef MENUQC
this.m_model = MDL_HealthMedium_ITEM;
+ this.m_sound = SND_HealthMedium;
#endif
- this.m_sound = "misc/mediumhealth.wav";
this.m_name = "25 Health";
this.m_icon = "health";
#ifdef SVQC
#ifndef MENUQC
MODEL(HealthLarge_ITEM, Item_Model("g_h50.md3"));
+SOUND(HealthLarge, "misc/mediumhealth.ogg");
#endif
REGISTER_ITEM(HealthLarge, Health) {
#ifndef MENUQC
this.m_model = MDL_HealthLarge_ITEM;
+ this.m_sound = SND_HealthLarge;
#endif
- this.m_sound = "misc/mediumhealth.wav";
this.m_name = "50 Health";
this.m_icon = "health";
this.m_color = '1 0 0';
#ifndef MENUQC
MODEL(HealthMega_ITEM, Item_Model("g_h100.md3"));
+SOUND(HealthMega, "misc/megahealth.ogg");
#endif
REGISTER_ITEM(HealthMega, Health) {
#ifndef MENUQC
this.m_model = MDL_HealthMega_ITEM;
+ this.m_sound = SND_HealthMega;
#endif
- this.m_sound = "misc/megahealth.wav";
this.m_name = "100 Health";
this.m_icon = "item_mega_health";
this.m_color = '1 0 0';
#include "pickup.qh"
CLASS(Health, Pickup)
#ifdef SVQC
+ ATTRIB(Health, m_mins, vector, '-16 -16 0')
+ ATTRIB(Health, m_maxs, vector, '16 16 48')
ATTRIB(Health, m_pickupevalfunc, float(entity player, entity item), commodity_pickupevalfunc)
#endif
ENDCLASS(Health)
#ifdef SVQC
bool ITEM_HANDLE(Pickup, entity this, entity item, entity player) {
- bool b = this.giveTo(this, item, player);
- if (b) {
- LOG_TRACEF("entity %i picked up %s\n", player, this.m_name);
- player.inventory.inv_items[this.m_id]++;
- Inventory_update(player);
- }
- return b;
+ return this.giveTo(this, item, player);
}
#endif
#ifndef PICKUP_H
#define PICKUP_H
+#include "../inventory.qh"
#include "../item.qh"
CLASS(Pickup, GameItem)
#ifndef MENUQC
ATTRIB(Pickup, m_model, Model, NULL)
+ ATTRIB(Pickup, m_sound, Sound, SND_ITEMPICKUP)
#endif
- ATTRIB(Pickup, m_sound, string, "misc/itempickup.wav")
ATTRIB(Pickup, m_name, string, string_null)
METHOD(Pickup, show, void(entity this));
void Pickup_show(entity this) { LOG_INFOF("%s: %s\n", etos(this), this.m_name); }
#ifdef SVQC
+ ATTRIB(Pickup, m_mins, vector, '-16 -16 0')
+ ATTRIB(Pickup, m_maxs, vector, '16 16 32')
ATTRIB(Pickup, m_botvalue, int, 0)
ATTRIB(Pickup, m_itemflags, int, 0)
ATTRIB(Pickup, m_itemid, int, 0)
+ float generic_pickupevalfunc(entity player, entity item);
ATTRIB(Pickup, m_pickupevalfunc, float(entity player, entity item), generic_pickupevalfunc)
ATTRIB(Pickup, m_respawntime, float(), func_null)
ATTRIB(Pickup, m_respawntimejitter, float(), func_null)
- METHOD(Pickup, giveTo, bool(entity this, entity item, entity player));
- bool Pickup_giveTo(entity this, entity item, entity player) { return Item_GiveTo(item, player); }
+ float Item_GiveTo(entity item, entity player);
+ METHOD(Pickup, giveTo, bool(entity this, entity item, entity player))
+ {
+ bool b = Item_GiveTo(item, player);
+ if (b) {
+ LOG_TRACEF("entity %i picked up %s\n", player, this.m_name);
+ player.inventory.inv_items[this.m_id]++;
+ Inventory_update(player);
+ }
+ return b;
+ }
bool ITEM_HANDLE(Pickup, entity this, entity item, entity player);
#endif
ENDCLASS(Pickup)
-#ifdef SVQC
-// For g_pickup_respawntime
-#include "../../../server/defs.qh"
-// Getters to dynamically retrieve the values of g_pickup_respawntime*
-GETTER(float, g_pickup_respawntime_weapon)
-GETTER(float, g_pickup_respawntime_superweapon)
-GETTER(float, g_pickup_respawntime_ammo)
-GETTER(float, g_pickup_respawntime_short)
-GETTER(float, g_pickup_respawntime_medium)
-GETTER(float, g_pickup_respawntime_long)
-GETTER(float, g_pickup_respawntime_powerup)
-GETTER(float, g_pickup_respawntimejitter_weapon)
-GETTER(float, g_pickup_respawntimejitter_superweapon)
-GETTER(float, g_pickup_respawntimejitter_ammo)
-GETTER(float, g_pickup_respawntimejitter_short)
-GETTER(float, g_pickup_respawntimejitter_medium)
-GETTER(float, g_pickup_respawntimejitter_long)
-GETTER(float, g_pickup_respawntimejitter_powerup)
-
-#endif
-
#endif
#ifndef MENUQC
MODEL(Strength_ITEM, Item_Model("g_strength.md3"));
+SOUND(Strength, "misc/powerup.ogg");
#endif
REGISTER_ITEM(Strength, Powerup) {
#ifndef MENUQC
this.m_model = MDL_Strength_ITEM;
+ this.m_sound = SND_Strength;
#endif
- this.m_sound = "misc/powerup.wav";
this.m_name = "Strength Powerup";
this.m_icon = "strength";
this.m_color = '0 0 1';
#ifndef MENUQC
MODEL(Shield_ITEM, Item_Model("g_invincible.md3"));
+SOUND(Shield, "misc/powerup_shield.ogg");
#endif
REGISTER_ITEM(Shield, Powerup) {
#ifndef MENUQC
this.m_model = MDL_Shield_ITEM;
+ this.m_sound = SND_Shield;
#endif
- this.m_sound = "misc/powerup_shield.wav";
this.m_name = "Shield";
this.m_icon = "shield";
this.m_color = '1 0 1';
#include "pickup.qh"
CLASS(Powerup, Pickup)
#ifdef SVQC
+ ATTRIB(Powerup, m_mins, vector, '-16 -16 0')
+ ATTRIB(Powerup, m_maxs, vector, '16 16 48')
ATTRIB(Powerup, m_botvalue, int, 100000)
ATTRIB(Powerup, m_itemflags, int, FL_POWERUP)
ATTRIB(Powerup, m_respawntime, float(), GET(g_pickup_respawntime_powerup))
/* flags */ ATTRIB(MageSpike, spawnflags, int, WEP_TYPE_OTHER | WEP_FLAG_HIDDEN | WEP_FLAG_MUTATORBLOCKED);
/* impulse */ ATTRIB(MageSpike, impulse, int, 9);
/* refname */ ATTRIB(MageSpike, netname, string, "magespike");
-/* wepname */ ATTRIB(MageSpike, message, string, _("Mage spike"));
+/* wepname */ ATTRIB(MageSpike, m_name, string, _("Mage spike"));
ENDCLASS(MageSpike)
REGISTER_WEAPON(MAGE_SPIKE, NEW(MageSpike));
/* flags */ ATTRIB(SpiderAttack, spawnflags, int, WEP_TYPE_OTHER | WEP_FLAG_HIDDEN | WEP_FLAG_MUTATORBLOCKED);
/* impulse */ ATTRIB(SpiderAttack, impulse, int, 9);
/* refname */ ATTRIB(SpiderAttack, netname, string, "spider");
-/* wepname */ ATTRIB(SpiderAttack, message, string, _("Spider attack"));
+/* wepname */ ATTRIB(SpiderAttack, m_name, string, _("Spider attack"));
ENDCLASS(SpiderAttack)
REGISTER_WEAPON(SPIDER_ATTACK, NEW(SpiderAttack));
/* flags */ ATTRIB(WyvernAttack, spawnflags, int, WEP_TYPE_OTHER | WEP_FLAG_HIDDEN | WEP_FLAG_MUTATORBLOCKED);
/* impulse */ ATTRIB(WyvernAttack, impulse, int, 9);
/* refname */ ATTRIB(WyvernAttack, netname, string, "wyvern");
-/* wepname */ ATTRIB(WyvernAttack, message, string, _("Wyvern attack"));
+/* wepname */ ATTRIB(WyvernAttack, m_name, string, _("Wyvern attack"));
ENDCLASS(WyvernAttack)
REGISTER_WEAPON(WYVERN_ATTACK, NEW(WyvernAttack));
{
if (!g_instagib) { remove(self); return; }
if (!self.ammo_cells) self.ammo_cells = autocvar_g_instagib_ammo_drop;
- StartItemA(ITEM_VaporizerCells);
+ StartItem(this, ITEM_VaporizerCells);
}
void instagib_invisibility()
{SELFPARAM();
self.strength_finished = autocvar_g_balance_powerup_strength_time;
- StartItemA(ITEM_Invisibility);
+ StartItem(this, ITEM_Invisibility);
}
void instagib_extralife()
{SELFPARAM();
self.max_health = 1;
- StartItemA(ITEM_ExtraLife);
+ StartItem(this, ITEM_ExtraLife);
}
void instagib_speed()
{SELFPARAM();
self.invincible_finished = autocvar_g_balance_powerup_invincible_time;
- StartItemA(ITEM_Speed);
+ StartItem(this, ITEM_Speed);
}
.float instagib_nextthink;
#ifndef MENUQC
MODEL(VaporizerCells_ITEM, Item_Model("a_cells.md3"));
+SOUND(VaporizerCells, "misc/itempickup.ogg");
#endif
REGISTER_ITEM(VaporizerCells, Ammo) {
#ifndef MENUQC
this.m_model = MDL_VaporizerCells_ITEM;
+ this.m_sound = SND_VaporizerCells;
#endif
- this.m_sound = "misc/itempickup.wav";
this.m_name = "Vaporizer Ammo";
this.m_icon = "ammo_supercells";
#ifdef SVQC
#ifndef MENUQC
MODEL(ExtraLife_ITEM, Item_Model("g_h100.md3"));
+SOUND(ExtraLife, "misc/megahealth.ogg");
#endif
REGISTER_ITEM(ExtraLife, Powerup) {
#ifndef MENUQC
this.m_model = MDL_ExtraLife_ITEM;
+ this.m_sound = SND_ExtraLife;
#endif
- this.m_sound = "misc/megahealth.wav";
this.m_name = "Extra life";
this.m_icon = "item_mega_health";
this.m_color = '1 0 0';
#ifndef MENUQC
MODEL(Invisibility_ITEM, Item_Model("g_strength.md3"));
+SOUND(Invisibility, "misc/powerup.ogg");
#endif
REGISTER_ITEM(Invisibility, Powerup) {
#ifndef MENUQC
this.m_model = MDL_Invisibility_ITEM;
+ this.m_sound = SND_Invisibility;
#endif
- this.m_sound = "misc/powerup.wav";
this.m_name = "Invisibility";
this.m_icon = "strength";
this.m_color = '0 0 1';
#ifndef MENUQC
MODEL(Speed_ITEM, Item_Model("g_invincible.md3"));
+SOUND(Speed, "misc/powerup_shield.ogg");
#endif
REGISTER_ITEM(Speed, Powerup) {
#ifndef MENUQC
this.m_model = MDL_Speed_ITEM;
+ this.m_sound = SND_Speed;
#endif
- this.m_sound = "misc/powerup_shield.wav";
this.m_name = "Speed";
this.m_icon = "shield";
this.m_color = '1 0 1';
string spritelookuptext(string s)
{SELFPARAM();
if (s == WP_RaceStartFinish.netname) return (race_checkpointtime || race_mycheckpointtime) ? _("Finish") : _("Start");
- if (s == WP_Weapon.netname) return get_weaponinfo(self.wp_extra).message;
+ if (s == WP_Weapon.netname) return get_weaponinfo(self.wp_extra).m_name;
if (s == WP_Item.netname) return Items[self.wp_extra].m_waypoint;
if (s == WP_Buff.netname) return Buffs[self.wp_extra].m_prettyName;
if (s == WP_Monster.netname) return get_monsterinfo(self.wp_extra).monster_name;
/* flags */ ATTRIB(EWheelAttack, spawnflags, int, WEP_TYPE_OTHER | WEP_FLAG_HIDDEN | WEP_FLAG_MUTATORBLOCKED);
/* impulse */ ATTRIB(EWheelAttack, impulse, int, 5);
/* refname */ ATTRIB(EWheelAttack, netname, string, "turret_ewheel");
-/* wepname */ ATTRIB(EWheelAttack, message, string, _("eWheel"));
+/* wepname */ ATTRIB(EWheelAttack, m_name, string, _("eWheel"));
ENDCLASS(EWheelAttack)
REGISTER_WEAPON(EWHEEL, NEW(EWheelAttack));
/* flags */ ATTRIB(FlacAttack, spawnflags, int, WEP_TYPE_OTHER | WEP_FLAG_HIDDEN | WEP_FLAG_MUTATORBLOCKED);
/* impulse */ ATTRIB(FlacAttack, impulse, int, 5);
/* refname */ ATTRIB(FlacAttack, netname, string, "turret_flac");
-/* wepname */ ATTRIB(FlacAttack, message, string, _("FLAC"));
+/* wepname */ ATTRIB(FlacAttack, m_name, string, _("FLAC"));
ENDCLASS(FlacAttack)
REGISTER_WEAPON(FLAC, NEW(FlacAttack));
/* flags */ ATTRIB(HellionAttack, spawnflags, int, WEP_TYPE_OTHER | WEP_FLAG_HIDDEN | WEP_FLAG_MUTATORBLOCKED);
/* impulse */ ATTRIB(HellionAttack, impulse, int, 9);
/* refname */ ATTRIB(HellionAttack, netname, string, "turret_hellion");
-/* wepname */ ATTRIB(HellionAttack, message, string, _("Hellion"));
+/* wepname */ ATTRIB(HellionAttack, m_name, string, _("Hellion"));
ENDCLASS(HellionAttack)
REGISTER_WEAPON(HELLION, NEW(HellionAttack));
/* flags */ ATTRIB(HunterKillerAttack, spawnflags, int, WEP_TYPE_OTHER | WEP_FLAG_HIDDEN | WEP_FLAG_MUTATORBLOCKED);
/* impulse */ ATTRIB(HunterKillerAttack, impulse, int, 9);
/* refname */ ATTRIB(HunterKillerAttack, netname, string, "turret_hk");
-/* wepname */ ATTRIB(HunterKillerAttack, message, string, _("Hunter-Killer"));
+/* wepname */ ATTRIB(HunterKillerAttack, m_name, string, _("Hunter-Killer"));
ENDCLASS(HunterKillerAttack)
REGISTER_WEAPON(HK, NEW(HunterKillerAttack));
/* flags */ ATTRIB(MachineGunTurretAttack, spawnflags, int, WEP_TYPE_OTHER | WEP_FLAG_HIDDEN | WEP_FLAG_MUTATORBLOCKED);
/* impulse */ ATTRIB(MachineGunTurretAttack, impulse, int, 9);
/* refname */ ATTRIB(MachineGunTurretAttack, netname, string, "turret_machinegun");
-/* wepname */ ATTRIB(MachineGunTurretAttack, message, string, _("Machinegun"));
+/* wepname */ ATTRIB(MachineGunTurretAttack, m_name, string, _("Machinegun"));
ENDCLASS(MachineGunTurretAttack)
REGISTER_WEAPON(TUR_MACHINEGUN, NEW(MachineGunTurretAttack));
/* flags */ ATTRIB(MLRSTurretAttack, spawnflags, int, WEP_TYPE_OTHER | WEP_FLAG_HIDDEN | WEP_FLAG_MUTATORBLOCKED);
/* impulse */ ATTRIB(MLRSTurretAttack, impulse, int, 9);
/* refname */ ATTRIB(MLRSTurretAttack, netname, string, "turret_mlrs");
-/* wepname */ ATTRIB(MLRSTurretAttack, message, string, _("MLRS"));
+/* wepname */ ATTRIB(MLRSTurretAttack, m_name, string, _("MLRS"));
ENDCLASS(MLRSTurretAttack)
REGISTER_WEAPON(TUR_MLRS, NEW(MLRSTurretAttack));
/* flags */ ATTRIB(PhaserTurretAttack, spawnflags, int, WEP_TYPE_OTHER | WEP_FLAG_HIDDEN | WEP_FLAG_MUTATORBLOCKED);
/* impulse */ ATTRIB(PhaserTurretAttack, impulse, int, 9);
/* refname */ ATTRIB(PhaserTurretAttack, netname, string, "turret_phaser");
-/* wepname */ ATTRIB(PhaserTurretAttack, message, string, _("Phaser"));
+/* wepname */ ATTRIB(PhaserTurretAttack, m_name, string, _("Phaser"));
ENDCLASS(PhaserTurretAttack)
REGISTER_WEAPON(PHASER, NEW(PhaserTurretAttack));
CLASS(PlasmaDualAttack, PlasmaAttack)
/* refname */ ATTRIB(PlasmaDualAttack, netname, string, "turret_plasma_dual");
-/* wepname */ ATTRIB(PlasmaDualAttack, message, string, _("Dual plasma"));
+/* wepname */ ATTRIB(PlasmaDualAttack, m_name, string, _("Dual plasma"));
ENDCLASS(PlasmaDualAttack)
REGISTER_WEAPON(PLASMA_DUAL, NEW(PlasmaDualAttack));
/* flags */ ATTRIB(PlasmaAttack, spawnflags, int, WEP_TYPE_OTHER | WEP_FLAG_HIDDEN | WEP_FLAG_MUTATORBLOCKED);
/* impulse */ ATTRIB(PlasmaAttack, impulse, int, 5);
/* refname */ ATTRIB(PlasmaAttack, netname, string, "turret_plasma");
-/* wepname */ ATTRIB(PlasmaAttack, message, string, _("Plasma"));
+/* wepname */ ATTRIB(PlasmaAttack, m_name, string, _("Plasma"));
ENDCLASS(PlasmaAttack)
REGISTER_WEAPON(PLASMA, NEW(PlasmaAttack));
/* flags */ ATTRIB(TeslaCoilTurretAttack, spawnflags, int, WEP_TYPE_OTHER | WEP_FLAG_HIDDEN | WEP_FLAG_MUTATORBLOCKED);
/* impulse */ ATTRIB(TeslaCoilTurretAttack, impulse, int, 9);
/* refname */ ATTRIB(TeslaCoilTurretAttack, netname, string, "turret_tesla");
-/* wepname */ ATTRIB(TeslaCoilTurretAttack, message, string, _("Tesla Coil"));
+/* wepname */ ATTRIB(TeslaCoilTurretAttack, m_name, string, _("Tesla Coil"));
ENDCLASS(TeslaCoilTurretAttack)
REGISTER_WEAPON(TESLA, NEW(TeslaCoilTurretAttack));
/* flags */ ATTRIB(WalkerTurretAttack, spawnflags, int, WEP_TYPE_OTHER | WEP_FLAG_HIDDEN | WEP_FLAG_MUTATORBLOCKED);
/* impulse */ ATTRIB(WalkerTurretAttack, impulse, int, 5);
/* refname */ ATTRIB(WalkerTurretAttack, netname, string, "turret_walker");
-/* wepname */ ATTRIB(WalkerTurretAttack, message, string, _("Walker"));
+/* wepname */ ATTRIB(WalkerTurretAttack, m_name, string, _("Walker"));
ENDCLASS(WalkerTurretAttack)
REGISTER_WEAPON(WALKER, NEW(WalkerTurretAttack));
/* flags */ ATTRIB(RacerAttack, spawnflags, int, WEP_TYPE_OTHER | WEP_FLAG_HIDDEN | WEP_FLAG_MUTATORBLOCKED);
/* impulse */ ATTRIB(RacerAttack, impulse, int, 3);
/* refname */ ATTRIB(RacerAttack, netname, string, "racercannon");
-/* wepname */ ATTRIB(RacerAttack, message, string, _("Racer cannon"));
+/* wepname */ ATTRIB(RacerAttack, m_name, string, _("Racer cannon"));
ENDCLASS(RacerAttack)
REGISTER_WEAPON(RACER, NEW(RacerAttack));
/* flags */ ATTRIB(RaptorCannon, spawnflags, int, WEP_TYPE_OTHER | WEP_FLAG_HIDDEN | WEP_FLAG_MUTATORBLOCKED);
/* impulse */ ATTRIB(RaptorCannon, impulse, int, 3);
/* refname */ ATTRIB(RaptorCannon, netname, string, "raptorcannon");
-/* wepname */ ATTRIB(RaptorCannon, message, string, _("Raptor cannon"));
+/* wepname */ ATTRIB(RaptorCannon, m_name, string, _("Raptor cannon"));
ENDCLASS(RaptorCannon)
REGISTER_WEAPON(RAPTOR, NEW(RaptorCannon));
/* flags */ ATTRIB(RaptorBomb, spawnflags, int, WEP_TYPE_OTHER | WEP_FLAG_HIDDEN | WEP_FLAG_MUTATORBLOCKED);
/* impulse */ ATTRIB(RaptorBomb, impulse, int, 3);
/* refname */ ATTRIB(RaptorBomb, netname, string, "raptorbomb");
-/* wepname */ ATTRIB(RaptorBomb, message, string, _("Raptor bomb"));
+/* wepname */ ATTRIB(RaptorBomb, m_name, string, _("Raptor bomb"));
ENDCLASS(RaptorBomb)
REGISTER_WEAPON(RAPTOR_BOMB, NEW(RaptorBomb));
/* flags */ ATTRIB(RaptorFlare, spawnflags, int, WEP_TYPE_OTHER | WEP_FLAG_HIDDEN | WEP_FLAG_MUTATORBLOCKED);
/* impulse */ ATTRIB(RaptorFlare, impulse, int, 3);
/* refname */ ATTRIB(RaptorFlare, netname, string, "raptorflare");
-/* wepname */ ATTRIB(RaptorFlare, message, string, _("Raptor flare"));
+/* wepname */ ATTRIB(RaptorFlare, m_name, string, _("Raptor flare"));
ENDCLASS(RaptorFlare)
REGISTER_WEAPON(RAPTOR_FLARE, NEW(RaptorFlare));
REGISTRY(Weapons, 72) // Increase as needed. Can be up to 72.
REGISTER_REGISTRY(RegisterWeapons)
+STATIC_INIT(WeaponPickup) { FOREACH(Weapons, true, LAMBDA(it.m_pickup = NEW(WeaponPickup, it))); }
entity get_weaponinfo(int id);
#ifndef WEAPON_H
#define WEAPON_H
+#include "../items/item/pickup.qh"
const int MAX_WEAPONSLOTS = 2;
/** M: refname : reference name name */
ATTRIB(Weapon, netname, string, "");
/** M: wepname : human readable name */
- ATTRIB(Weapon, message, string, "AOL CD Thrower");
+ ATTRIB(Weapon, m_name, string, "AOL CD Thrower");
+
+ ATTRIB(Weapon, m_pickup, entity, NULL);
/** (SERVER) setup weapon data */
METHOD(Weapon, wr_setup, void(Weapon this)) {}
METHOD(Weapon, wr_pickup, void(Weapon this)) {}
METHOD(Weapon, display, void(entity this, void(string name, string icon) returns)) {
- returns(this.message, this.model2 ? sprintf("/gfx/hud/%s/%s", cvar_string("menu_skin"), this.model2) : string_null);
+ returns(this.m_name, this.model2 ? sprintf("/gfx/hud/%s/%s", cvar_string("menu_skin"), this.model2) : string_null);
}
ENDCLASS(Weapon)
+#include "../items/all.qh"
+CLASS(WeaponPickup, Pickup)
+ ATTRIB(WeaponPickup, m_weapon, Weapon, NULL)
+ ATTRIB(WeaponPickup, m_name, string, string_null)
+#ifndef MENUQC
+ ATTRIB(WeaponPickup, m_sound, Sound, SND_WEAPONPICKUP)
+#endif
+#ifdef SVQC
+ ATTRIB(WeaponPickup, m_itemflags, int, FL_WEAPON)
+ float weapon_pickupevalfunc(entity player, entity item);
+ ATTRIB(WeaponPickup, m_pickupevalfunc, float(entity player, entity item), weapon_pickupevalfunc)
+#endif
+ CONSTRUCTOR(WeaponPickup, Weapon w) {
+ CONSTRUCT(WeaponPickup);
+ this.m_weapon = w;
+ this.m_name = w.m_name;
+#ifndef MENUQC
+ this.m_model = w.m_model;
+#endif
+#ifdef SVQC
+ this.m_botvalue = w.bot_pickupbasevalue;
+#endif
+ }
+#ifdef SVQC
+ METHOD(WeaponPickup, giveTo, bool(entity this, entity item, entity player))
+ {
+ bool b = Item_GiveTo(item, player);
+ if (b) {
+ LOG_TRACEF("entity %i picked up %s\n", player, this.m_name);
+ }
+ return b;
+ }
+#endif
+ENDCLASS(WeaponPickup)
+
CLASS(OffhandWeapon, Object)
METHOD(OffhandWeapon, offhand_think, void(OffhandWeapon this, entity player, bool key_pressed)) {}
ENDCLASS(OffhandWeapon)
// other useful macros
#define WEP_AMMO(wpn) (WEP_##wpn.ammo_field) // only used inside weapon files/with direct name, don't duplicate prefix
-#define WEP_NAME(wpn) ((get_weaponinfo(wpn)).message)
+#define WEP_NAME(wpn) ((get_weaponinfo(wpn)).m_name)
#endif
/* crosshair */ ATTRIB(Arc, w_crosshair_size, float, 0.7);
/* wepimg */ ATTRIB(Arc, model2, string, "weaponarc");
/* refname */ ATTRIB(Arc, netname, string, "arc");
-/* wepname */ ATTRIB(Arc, message, string, _("Arc"));
+/* wepname */ ATTRIB(Arc, m_name, string, _("Arc"));
ENDCLASS(Arc)
REGISTER_WEAPON(ARC, NEW(Arc));
#endif
#ifdef IMPLEMENTATION
#ifdef SVQC
-spawnfunc(weapon_arc) { weapon_defaultspawnfunc(WEP_ARC.m_id); }
+spawnfunc(weapon_arc) { weapon_defaultspawnfunc(this, WEP_ARC); }
bool W_Arc_Beam_Send(entity this, entity to, int sf)
{
/* crosshair */ ATTRIB(Blaster, w_crosshair_size, float, 0.5);
/* wepimg */ ATTRIB(Blaster, model2, string, "weaponlaser");
/* refname */ ATTRIB(Blaster, netname, string, "blaster");
-/* wepname */ ATTRIB(Blaster, message, string, _("Blaster"));
+/* wepname */ ATTRIB(Blaster, m_name, string, _("Blaster"));
ENDCLASS(Blaster)
REGISTER_WEAPON(BLASTER, NEW(Blaster));
#endif
#ifdef IMPLEMENTATION
#ifdef SVQC
-spawnfunc(weapon_blaster) { weapon_defaultspawnfunc(WEP_BLASTER.m_id); }
+spawnfunc(weapon_blaster) { weapon_defaultspawnfunc(this, WEP_BLASTER); }
spawnfunc(weapon_laser) { spawnfunc_weapon_blaster(this); }
void W_Blaster_Touch(void)
/* crosshair */ ATTRIB(Crylink, w_crosshair_size, float, 0.5);
/* wepimg */ ATTRIB(Crylink, model2, string, "weaponcrylink");
/* refname */ ATTRIB(Crylink, netname, string, "crylink");
-/* wepname */ ATTRIB(Crylink, message, string, _("Crylink"));
+/* wepname */ ATTRIB(Crylink, m_name, string, _("Crylink"));
ENDCLASS(Crylink)
REGISTER_WEAPON(CRYLINK, NEW(Crylink));
#endif
#ifdef IMPLEMENTATION
#ifdef SVQC
-spawnfunc(weapon_crylink) { weapon_defaultspawnfunc(WEP_CRYLINK.m_id); }
+spawnfunc(weapon_crylink) { weapon_defaultspawnfunc(this, WEP_CRYLINK); }
void W_Crylink_CheckLinks(entity e)
{
/* crosshair */ ATTRIB(Devastator, w_crosshair_size, float, 0.7);
/* wepimg */ ATTRIB(Devastator, model2, string, "weaponrocketlauncher");
/* refname */ ATTRIB(Devastator, netname, string, "devastator");
-/* wepname */ ATTRIB(Devastator, message, string, _("Devastator"));
+/* wepname */ ATTRIB(Devastator, m_name, string, _("Devastator"));
ENDCLASS(Devastator)
REGISTER_WEAPON(DEVASTATOR, NEW(Devastator));
#endif
#ifdef IMPLEMENTATION
#ifdef SVQC
-spawnfunc(weapon_devastator) { weapon_defaultspawnfunc(WEP_DEVASTATOR.m_id); }
+spawnfunc(weapon_devastator) { weapon_defaultspawnfunc(this, WEP_DEVASTATOR); }
spawnfunc(weapon_rocketlauncher) { spawnfunc_weapon_devastator(this); }
.entity lastrocket;
/* crosshair */ ATTRIB(Electro, w_crosshair_size, float, 0.6);
/* wepimg */ ATTRIB(Electro, model2, string, "weaponelectro");
/* refname */ ATTRIB(Electro, netname, string, "electro");
-/* wepname */ ATTRIB(Electro, message, string, _("Electro"));
+/* wepname */ ATTRIB(Electro, m_name, string, _("Electro"));
ENDCLASS(Electro)
REGISTER_WEAPON(ELECTRO, NEW(Electro));
#endif
#ifdef IMPLEMENTATION
#ifdef SVQC
-spawnfunc(weapon_electro) { weapon_defaultspawnfunc(WEP_ELECTRO.m_id); }
+spawnfunc(weapon_electro) { weapon_defaultspawnfunc(this, WEP_ELECTRO); }
void W_Electro_TriggerCombo(vector org, float rad, entity own)
{
/* crosshair */ //ATTRIB(Fireball, w_crosshair_size, float, 0.65);
/* wepimg */ ATTRIB(Fireball, model2, string, "weaponfireball");
/* refname */ ATTRIB(Fireball, netname, string, "fireball");
-/* wepname */ ATTRIB(Fireball, message, string, _("Fireball"));
+/* wepname */ ATTRIB(Fireball, m_name, string, _("Fireball"));
ENDCLASS(Fireball)
REGISTER_WEAPON(FIREBALL, NEW(Fireball));
#endif
#ifdef IMPLEMENTATION
#ifdef SVQC
-spawnfunc(weapon_fireball) { weapon_defaultspawnfunc(WEP_FIREBALL.m_id); }
+spawnfunc(weapon_fireball) { weapon_defaultspawnfunc(this, WEP_FIREBALL); }
void W_Fireball_Explode(void)
{SELFPARAM();
/* crosshair */ ATTRIB(Hagar, w_crosshair_size, float, 0.8);
/* wepimg */ ATTRIB(Hagar, model2, string, "weaponhagar");
/* refname */ ATTRIB(Hagar, netname, string, "hagar");
-/* wepname */ ATTRIB(Hagar, message, string, _("Hagar"));
+/* wepname */ ATTRIB(Hagar, m_name, string, _("Hagar"));
ENDCLASS(Hagar)
REGISTER_WEAPON(HAGAR, NEW(Hagar));
#endif
#ifdef IMPLEMENTATION
#ifdef SVQC
-spawnfunc(weapon_hagar) { weapon_defaultspawnfunc(WEP_HAGAR.m_id); }
+spawnfunc(weapon_hagar) { weapon_defaultspawnfunc(this, WEP_HAGAR); }
// NO bounce protection, as bounces are limited!
/* crosshair */ ATTRIB(HLAC, w_crosshair_size, float, 0.6);
/* wepimg */ ATTRIB(HLAC, model2, string, "weaponhlac");
/* refname */ ATTRIB(HLAC, netname, string, "hlac");
-/* wepname */ ATTRIB(HLAC, message, string, _("Heavy Laser Assault Cannon"));
+/* wepname */ ATTRIB(HLAC, m_name, string, _("Heavy Laser Assault Cannon"));
ENDCLASS(HLAC)
REGISTER_WEAPON(HLAC, NEW(HLAC));
#endif
#ifdef IMPLEMENTATION
#ifdef SVQC
-spawnfunc(weapon_hlac) { weapon_defaultspawnfunc(WEP_HLAC.m_id); }
+spawnfunc(weapon_hlac) { weapon_defaultspawnfunc(this, WEP_HLAC); }
void W_HLAC_Touch(void)
{SELFPARAM();
/* crosshair */ ATTRIB(HeavyMachineGun, w_crosshair_size, float, 0.6);
/* wepimg */ ATTRIB(HeavyMachineGun, model2, string, "weaponhmg");
/* refname */ ATTRIB(HeavyMachineGun, netname, string, "hmg");
-/* wepname */ ATTRIB(HeavyMachineGun, message, string, _("Heavy Machine Gun"));
+/* wepname */ ATTRIB(HeavyMachineGun, m_name, string, _("Heavy Machine Gun"));
ENDCLASS(HeavyMachineGun)
REGISTER_WEAPON(HMG, NEW(HeavyMachineGun));
#ifdef IMPLEMENTATION
#ifdef SVQC
-spawnfunc(weapon_hmg) { weapon_defaultspawnfunc(WEP_HMG.m_id); }
+spawnfunc(weapon_hmg) { weapon_defaultspawnfunc(this, WEP_HMG); }
void W_HeavyMachineGun_Attack_Auto(Weapon thiswep, entity actor, int slot, int fire)
{
/* crosshair */ ATTRIB(Hook, w_crosshair_size, float, 0.5);
/* wepimg */ ATTRIB(Hook, model2, string, "weaponhook");
/* refname */ ATTRIB(Hook, netname, string, "hook");
-/* wepname */ ATTRIB(Hook, message, string, _("Grappling Hook"));
+/* wepname */ ATTRIB(Hook, m_name, string, _("Grappling Hook"));
ATTRIB(Hook, ammo_factor, float, 1)
ENDCLASS(Hook)
REGISTER_WEAPON(HOOK, NEW(Hook));
#ifdef IMPLEMENTATION
#ifdef SVQC
-spawnfunc(weapon_hook) { weapon_defaultspawnfunc(WEP_HOOK.m_id); }
+spawnfunc(weapon_hook) { weapon_defaultspawnfunc(this, WEP_HOOK); }
void W_Hook_ExplodeThink(void)
{SELFPARAM();
/* crosshair */ ATTRIB(MachineGun, w_crosshair_size, float, 0.6);
/* wepimg */ ATTRIB(MachineGun, model2, string, "weaponuzi");
/* refname */ ATTRIB(MachineGun, netname, string, "machinegun");
-/* wepname */ ATTRIB(MachineGun, message, string, _("MachineGun"));
+/* wepname */ ATTRIB(MachineGun, m_name, string, _("MachineGun"));
ENDCLASS(MachineGun)
REGISTER_WEAPON(MACHINEGUN, NEW(MachineGun));
if(autocvar_sv_q3acompat_machineshotgunswap)
if(self.classname != "droppedweapon")
{
- weapon_defaultspawnfunc(WEP_SHOCKWAVE.m_id);
+ weapon_defaultspawnfunc(this, WEP_SHOCKWAVE);
return;
}
- weapon_defaultspawnfunc(WEP_MACHINEGUN.m_id);
+ weapon_defaultspawnfunc(this, WEP_MACHINEGUN);
}
spawnfunc(weapon_uzi) { spawnfunc_weapon_machinegun(this); }
/* crosshair */ ATTRIB(MineLayer, w_crosshair_size, float, 0.9);
/* wepimg */ ATTRIB(MineLayer, model2, string, "weaponminelayer");
/* refname */ ATTRIB(MineLayer, netname, string, "minelayer");
-/* wepname */ ATTRIB(MineLayer, message, string, _("Mine Layer"));
+/* wepname */ ATTRIB(MineLayer, m_name, string, _("Mine Layer"));
ENDCLASS(MineLayer)
REGISTER_WEAPON(MINE_LAYER, NEW(MineLayer));
#endif
#ifdef IMPLEMENTATION
#ifdef SVQC
-spawnfunc(weapon_minelayer) { weapon_defaultspawnfunc(WEP_MINE_LAYER.m_id); }
+spawnfunc(weapon_minelayer) { weapon_defaultspawnfunc(this, WEP_MINE_LAYER); }
void W_MineLayer_Stick(entity to)
{SELFPARAM();
/* crosshair */ ATTRIB(Mortar, w_crosshair_size, float, 0.7);
/* wepimg */ ATTRIB(Mortar, model2, string, "weapongrenadelauncher");
/* refname */ ATTRIB(Mortar, netname, string, "mortar");
-/* wepname */ ATTRIB(Mortar, message, string, _("Mortar"));
+/* wepname */ ATTRIB(Mortar, m_name, string, _("Mortar"));
ENDCLASS(Mortar)
REGISTER_WEAPON(MORTAR, NEW(Mortar));
#ifdef IMPLEMENTATION
#ifdef SVQC
-spawnfunc(weapon_mortar) { weapon_defaultspawnfunc(WEP_MORTAR.m_id); }
+spawnfunc(weapon_mortar) { weapon_defaultspawnfunc(this, WEP_MORTAR); }
spawnfunc(weapon_grenadelauncher) { spawnfunc_weapon_mortar(this); }
void W_Mortar_Grenade_Explode(void)
/* crosshair */ ATTRIB(PortoLaunch, w_crosshair_size, float, 0.6);
/* wepimg */ ATTRIB(PortoLaunch, model2, string, "weaponporto");
/* refname */ ATTRIB(PortoLaunch, netname, string, "porto");
-/* wepname */ ATTRIB(PortoLaunch, message, string, _("Port-O-Launch"));
+/* wepname */ ATTRIB(PortoLaunch, m_name, string, _("Port-O-Launch"));
ENDCLASS(PortoLaunch)
REGISTER_WEAPON(PORTO, NEW(PortoLaunch));
#ifdef SVQC
#include "../../triggers/trigger/jumppads.qh"
-spawnfunc(weapon_porto) { weapon_defaultspawnfunc(WEP_PORTO.m_id); }
+spawnfunc(weapon_porto) { weapon_defaultspawnfunc(this, WEP_PORTO); }
REGISTER_MUTATOR(porto_ticker, true);
MUTATOR_HOOKFUNCTION(porto_ticker, SV_StartFrame) {
/* crosshair */ ATTRIB(Rifle, w_crosshair_size, float, 0.6);
/* wepimg */ ATTRIB(Rifle, model2, string, "weaponrifle");
/* refname */ ATTRIB(Rifle, netname, string, "rifle");
-/* wepname */ ATTRIB(Rifle, message, string, _("Rifle"));
+/* wepname */ ATTRIB(Rifle, m_name, string, _("Rifle"));
ENDCLASS(Rifle)
REGISTER_WEAPON(RIFLE, NEW(Rifle));
#endif
#ifdef IMPLEMENTATION
#ifdef SVQC
-spawnfunc(weapon_rifle) { weapon_defaultspawnfunc(WEP_RIFLE.m_id); }
+spawnfunc(weapon_rifle) { weapon_defaultspawnfunc(this, WEP_RIFLE); }
spawnfunc(weapon_campingrifle) { spawnfunc_weapon_rifle(this); }
spawnfunc(weapon_sniperrifle) { spawnfunc_weapon_rifle(this); }
/* crosshair */ ATTRIB(RocketPropelledChainsaw, w_crosshair_size, float, 0.6);
/* wepimg */ ATTRIB(RocketPropelledChainsaw, model2, string, "weaponrpc");
/* refname */ ATTRIB(RocketPropelledChainsaw, netname, string, "rpc");
-/* wepname */ ATTRIB(RocketPropelledChainsaw, message, string, _("Rocket Propelled Chainsaw"));
+/* wepname */ ATTRIB(RocketPropelledChainsaw, m_name, string, _("Rocket Propelled Chainsaw"));
ENDCLASS(RocketPropelledChainsaw)
REGISTER_WEAPON(RPC, NEW(RocketPropelledChainsaw));
#endif
#ifdef IMPLEMENTATION
#ifdef SVQC
-spawnfunc(weapon_rpc) { weapon_defaultspawnfunc(WEP_RPC.m_id); }
+spawnfunc(weapon_rpc) { weapon_defaultspawnfunc(this, WEP_RPC); }
void W_RocketPropelledChainsaw_Explode()
{SELFPARAM();
/* crosshair */ ATTRIB(Seeker, w_crosshair_size, float, 0.8);
/* wepimg */ ATTRIB(Seeker, model2, string, "weaponseeker");
/* refname */ ATTRIB(Seeker, netname, string, "seeker");
-/* wepname */ ATTRIB(Seeker, message, string, _("T.A.G. Seeker"));
+/* wepname */ ATTRIB(Seeker, m_name, string, _("T.A.G. Seeker"));
ENDCLASS(Seeker)
REGISTER_WEAPON(SEEKER, NEW(Seeker));
#endif
#ifdef IMPLEMENTATION
#ifdef SVQC
-spawnfunc(weapon_seeker) { weapon_defaultspawnfunc(WEP_SEEKER.m_id); }
+spawnfunc(weapon_seeker) { weapon_defaultspawnfunc(this, WEP_SEEKER); }
// ============================
// Begin: Missile functions, these are general functions to be manipulated by other code
/* crosshair */ ATTRIB(Shockwave, w_crosshair_size, float, 0.7);
/* wepimg */ ATTRIB(Shockwave, model2, string, "weaponshotgun");
/* refname */ ATTRIB(Shockwave, netname, string, "shockwave");
-/* wepname */ ATTRIB(Shockwave, message, string, _("Shockwave"));
+/* wepname */ ATTRIB(Shockwave, m_name, string, _("Shockwave"));
ENDCLASS(Shockwave)
REGISTER_WEAPON(SHOCKWAVE, NEW(Shockwave));
if(autocvar_sv_q3acompat_machineshotgunswap)
if(self.classname != "droppedweapon")
{
- weapon_defaultspawnfunc(WEP_MACHINEGUN.m_id);
+ weapon_defaultspawnfunc(this, WEP_MACHINEGUN);
return;
}
- weapon_defaultspawnfunc(WEP_SHOCKWAVE.m_id);
+ weapon_defaultspawnfunc(this, WEP_SHOCKWAVE);
}
const float MAX_SHOCKWAVE_HITS = 10;
/* crosshair */ ATTRIB(Shotgun, w_crosshair_size, float, 0.65);
/* wepimg */ ATTRIB(Shotgun, model2, string, "weaponshotgun");
/* refname */ ATTRIB(Shotgun, netname, string, "shotgun");
-/* wepname */ ATTRIB(Shotgun, message, string, _("Shotgun"));
+/* wepname */ ATTRIB(Shotgun, m_name, string, _("Shotgun"));
ENDCLASS(Shotgun)
REGISTER_WEAPON(SHOTGUN, NEW(Shotgun));
#endif
#ifdef IMPLEMENTATION
#ifdef SVQC
-spawnfunc(weapon_shotgun) { weapon_defaultspawnfunc(WEP_SHOTGUN.m_id); }
+spawnfunc(weapon_shotgun) { weapon_defaultspawnfunc(this, WEP_SHOTGUN); }
void W_Shotgun_Attack(Weapon thiswep, float isprimary)
{SELFPARAM();
/* wepimg */ ATTRIB(Tuba, model2, string, "weapontuba");
/* refname */ ATTRIB(Tuba, netname, string, "tuba");
/* xgettext:no-c-format */
-/* wepname */ ATTRIB(Tuba, message, string, _("@!#%'n Tuba"));
+/* wepname */ ATTRIB(Tuba, m_name, string, _("@!#%'n Tuba"));
ENDCLASS(Tuba)
REGISTER_WEAPON(TUBA, NEW(Tuba));
#endif
#ifdef IMPLEMENTATION
#ifdef SVQC
-spawnfunc(weapon_tuba) { weapon_defaultspawnfunc(WEP_TUBA.m_id); }
+spawnfunc(weapon_tuba) { weapon_defaultspawnfunc(this, WEP_TUBA); }
bool W_Tuba_HasPlayed(entity pl, string melody, int instrument, bool ignorepitch, float mintempo, float maxtempo)
{
/* crosshair */ ATTRIB(Vaporizer, w_crosshair_size, float, 0.6);
/* wepimg */ ATTRIB(Vaporizer, model2, string, "weaponminstanex");
/* refname */ ATTRIB(Vaporizer, netname, string, "vaporizer");
-/* wepname */ ATTRIB(Vaporizer, message, string, _("Vaporizer"));
+/* wepname */ ATTRIB(Vaporizer, m_name, string, _("Vaporizer"));
ENDCLASS(Vaporizer)
REGISTER_WEAPON(VAPORIZER, NEW(Vaporizer));
#endif
#ifdef IMPLEMENTATION
#ifdef SVQC
-spawnfunc(weapon_vaporizer) { weapon_defaultspawnfunc(WEP_VAPORIZER.m_id); }
+spawnfunc(weapon_vaporizer) { weapon_defaultspawnfunc(this, WEP_VAPORIZER); }
spawnfunc(weapon_minstanex) { spawnfunc_weapon_vaporizer(this); }
void W_RocketMinsta_Explosion(vector loc)
/* crosshair */ ATTRIB(Vortex, w_crosshair_size, float, 0.65);
/* wepimg */ ATTRIB(Vortex, model2, string, "weaponnex");
/* refname */ ATTRIB(Vortex, netname, string, "vortex");
-/* wepname */ ATTRIB(Vortex, message, string, _("Vortex"));
+/* wepname */ ATTRIB(Vortex, m_name, string, _("Vortex"));
ENDCLASS(Vortex)
REGISTER_WEAPON(VORTEX, NEW(Vortex));
#endif
#ifdef IMPLEMENTATION
#ifdef SVQC
-spawnfunc(weapon_vortex) { weapon_defaultspawnfunc(WEP_VORTEX.m_id); }
+spawnfunc(weapon_vortex) { weapon_defaultspawnfunc(this, WEP_VORTEX); }
spawnfunc(weapon_nex) { spawnfunc_weapon_vortex(this); }
void SendCSQCVortexBeamParticle(float charge) {
#define GET(name) name##get
#define GETTER(type, name) type GET(name)() { return name; }
-
+#define PROPERTY(type, name) type name; GETTER(type, name)
#define LAMBDA(...) { __VA_ARGS__; }
// With block may not contain continue or break
class(cname).type name[cnt];
#define ENDCLASS(cname) \
- [[last]] INIT(cname) \
+ INIT(cname) \
{ \
return this; \
}
#ifndef SERVER_ALL_H
#define SERVER_ALL_H
+#include "../common/effects/all.qh"
+#include "../common/models/all.qh"
+#include "../common/sounds/all.qh"
+
#include "autocvars.qh"
#include "constants.qh"
#include "defs.qh"
#include "miscfunctions.qh"
-
-#include "../common/effects/all.qh"
-#include "../common/models/all.qh"
-#include "../common/sounds/all.qh"
-
#endif
float g_warmup_allguns;
float g_warmup_allow_timeout;
float warmup_stage;
-float g_pickup_respawntime_weapon;
-float g_pickup_respawntime_superweapon;
-float g_pickup_respawntime_ammo;
-float g_pickup_respawntime_short;
-float g_pickup_respawntime_medium;
-float g_pickup_respawntime_long;
-float g_pickup_respawntime_powerup;
-float g_pickup_respawntimejitter_weapon;
-float g_pickup_respawntimejitter_superweapon;
-float g_pickup_respawntimejitter_ammo;
-float g_pickup_respawntimejitter_short;
-float g_pickup_respawntimejitter_medium;
-float g_pickup_respawntimejitter_long;
-float g_pickup_respawntimejitter_powerup;
+PROPERTY(float, g_pickup_respawntime_weapon)
+PROPERTY(float, g_pickup_respawntime_superweapon)
+PROPERTY(float, g_pickup_respawntime_ammo)
+PROPERTY(float, g_pickup_respawntime_short)
+PROPERTY(float, g_pickup_respawntime_medium)
+PROPERTY(float, g_pickup_respawntime_long)
+PROPERTY(float, g_pickup_respawntime_powerup)
+PROPERTY(float, g_pickup_respawntimejitter_weapon)
+PROPERTY(float, g_pickup_respawntimejitter_superweapon)
+PROPERTY(float, g_pickup_respawntimejitter_ammo)
+PROPERTY(float, g_pickup_respawntimejitter_short)
+PROPERTY(float, g_pickup_respawntimejitter_medium)
+PROPERTY(float, g_pickup_respawntimejitter_long)
+PROPERTY(float, g_pickup_respawntimejitter_powerup)
float g_jetpack;
float sv_clones;
// string overrides entity
.string item_pickupsound;
.entity item_pickupsound_ent;
+.entity item_model_ent;
// definitions for weaponsystem
// more WEAPONTODO: move these to their proper files
// there is 2 weapon tics that can run in one server frame
const int W_TICSPERFRAME = 2;
-void weapon_defaultspawnfunc(float wpn);
+void weapon_defaultspawnfunc(entity this, Weapon e);
float gameover;
float intermission_running;
if (e.netname == s)
{
g_weaponarena_weapons |= WepSet_FromWeapon(j);
- g_weaponarena_list = strcat(g_weaponarena_list, e.message, " & ");
+ g_weaponarena_list = strcat(g_weaponarena_list, e.m_name, " & ");
break;
}
}
* checks if the current item may be spawned (self.items and self.weapons may be read and written to, as well as the ammo_ fields)
* return error to request removal
*/
-MUTATOR_HOOKABLE(FilterItem, EV_NO_ARGS);
+#define EV_FilterItem(i, o) \
+ /** the current item */ i(entity, __self) \
+ /**/
+MUTATOR_HOOKABLE(FilterItem, EV_FilterItem);
/** return error to request removal */
#define EV_TurretSpawn(i, o) \
const int SP_CTF_FCKILLS = 8;
const int SP_CTF_RETURNS = 9;
+CLASS(Flag, Pickup)
+ ATTRIB(Flag, m_mins, vector, PL_MIN_CONST + '0 0 -13')
+ ATTRIB(Flag, m_maxs, vector, PL_MAX_CONST + '0 0 -13')
+ENDCLASS(Flag)
+Flag CTF_FLAG; STATIC_INIT(Flag) { CTF_FLAG = NEW(Flag); }
+void ctf_FlagTouch() { SELFPARAM(); ITEM_HANDLE(Pickup, CTF_FLAG, this, other); }
+
// flag constants // for most of these, there is just one question to be asked: WHYYYYY?
-#define FLAG_MIN (PL_MIN_CONST + '0 0 -13')
-#define FLAG_MAX (PL_MAX_CONST + '0 0 -13')
const float FLAG_SCALE = 0.6;
const int RETURN_SPEEDRUN = 4;
const int RETURN_NEEDKILL = 5;
+void ctf_Handle_Throw(entity player, entity receiver, float droptype);
+
// flag properties
#define ctf_spawnorigin dropped_origin
bool ctf_stalemate; // indicates that a stalemate is active
ctf_CaptureShield_Update(tmp_entity, 1); // release shield only
// sanity checks
- if(self.mins != FLAG_MIN || self.maxs != FLAG_MAX) { // reset the flag boundaries in case it got squished
+ if(self.mins != CTF_FLAG.m_mins || self.maxs != CTF_FLAG.m_maxs) { // reset the flag boundaries in case it got squished
LOG_TRACE("wtf the flag got squashed?\n");
- tracebox(self.origin, FLAG_MIN, FLAG_MAX, self.origin, MOVE_NOMONSTERS, self);
+ tracebox(self.origin, CTF_FLAG.m_mins, CTF_FLAG.m_maxs, self.origin, MOVE_NOMONSTERS, self);
if(!trace_startsolid || self.noalign) // can we resize it without getting stuck?
- setsize(self, FLAG_MIN, FLAG_MAX); }
+ setsize(self, CTF_FLAG.m_mins, CTF_FLAG.m_maxs); }
switch(self.ctf_status) // reset flag angles in case warpzones adjust it
{
}
}
-void ctf_FlagTouch()
-{SELFPARAM();
+METHOD(Flag, giveTo, bool(Flag this, entity flag, entity toucher))
+{
+ return = false;
if(gameover) { return; }
if(trace_dphitcontents & (DPCONTENTS_PLAYERCLIP | DPCONTENTS_MONSTERCLIP)) { return; }
- entity toucher = other, tmp_entity;
- bool is_not_monster = (!IS_MONSTER(toucher)), num_perteam = 0;
+ bool is_not_monster = (!IS_MONSTER(toucher));
// automatically kill the flag and return it if it touched lava/slime/nodrop surfaces
if(ITEM_TOUCH_NEEDKILL())
{
if(!autocvar_g_ctf_flag_return_damage_delay)
{
- self.health = 0;
- ctf_CheckFlagReturn(self, RETURN_NEEDKILL);
+ flag.health = 0;
+ ctf_CheckFlagReturn(flag, RETURN_NEEDKILL);
}
- if(!self.ctf_flagdamaged) { return; }
+ if(!flag.ctf_flagdamaged) { return; }
}
- FOR_EACH_PLAYER(tmp_entity) if(SAME_TEAM(toucher, tmp_entity)) { ++num_perteam; }
+ int num_perteam = 0;
+ entity tmp_entity; FOR_EACH_PLAYER(tmp_entity) if(SAME_TEAM(toucher, tmp_entity)) { ++num_perteam; }
// special touch behaviors
if(toucher.frozen) { return; }
}
else if (!IS_PLAYER(toucher)) // The flag just touched an object, most likely the world
{
- if(time > self.wait) // if we haven't in a while, play a sound/effect
+ if(time > flag.wait) // if we haven't in a while, play a sound/effect
{
- Send_Effect_(self.toucheffect, self.origin, '0 0 0', 1);
- _sound(self, CH_TRIGGER, self.snd_flag_touch, VOL_BASE, ATTEN_NORM);
- self.wait = time + FLAG_TOUCHRATE;
+ Send_Effect_(flag.toucheffect, flag.origin, '0 0 0', 1);
+ _sound(flag, CH_TRIGGER, flag.snd_flag_touch, VOL_BASE, ATTEN_NORM);
+ flag.wait = time + FLAG_TOUCHRATE;
}
return;
}
else if(toucher.deadflag != DEAD_NO) { return; }
- switch(self.ctf_status)
+ switch(flag.ctf_status)
{
case FLAG_BASE:
{
if(ctf_oneflag)
{
- if(CTF_SAMETEAM(toucher, self) && (toucher.flagcarried) && !toucher.flagcarried.team && is_not_monster)
- ctf_Handle_Capture(self, toucher, CAPTURE_NORMAL); // toucher just captured the neutral flag to enemy base
- else if(!self.team && (!toucher.flagcarried) && (!toucher.ctf_captureshielded) && (time > toucher.next_take_time) && is_not_monster)
- ctf_Handle_Pickup(self, toucher, PICKUP_BASE); // toucher just stole the neutral flag
+ if(CTF_SAMETEAM(toucher, flag) && (toucher.flagcarried) && !toucher.flagcarried.team && is_not_monster)
+ ctf_Handle_Capture(flag, toucher, CAPTURE_NORMAL); // toucher just captured the neutral flag to enemy base
+ else if(!flag.team && (!toucher.flagcarried) && (!toucher.ctf_captureshielded) && (time > toucher.next_take_time) && is_not_monster)
+ ctf_Handle_Pickup(flag, toucher, PICKUP_BASE); // toucher just stole the neutral flag
}
- else if(CTF_SAMETEAM(toucher, self) && (toucher.flagcarried) && DIFF_TEAM(toucher.flagcarried, self) && is_not_monster)
- ctf_Handle_Capture(self, toucher, CAPTURE_NORMAL); // toucher just captured the enemies flag to his base
- else if(CTF_DIFFTEAM(toucher, self) && (!toucher.flagcarried) && (!toucher.ctf_captureshielded) && (time > toucher.next_take_time) && is_not_monster)
- ctf_Handle_Pickup(self, toucher, PICKUP_BASE); // toucher just stole the enemies flag
+ else if(CTF_SAMETEAM(toucher, flag) && (toucher.flagcarried) && DIFF_TEAM(toucher.flagcarried, flag) && is_not_monster)
+ ctf_Handle_Capture(flag, toucher, CAPTURE_NORMAL); // toucher just captured the enemies flag to his base
+ else if(CTF_DIFFTEAM(toucher, flag) && (!toucher.flagcarried) && (!toucher.ctf_captureshielded) && (time > toucher.next_take_time) && is_not_monster)
+ ctf_Handle_Pickup(flag, toucher, PICKUP_BASE); // toucher just stole the enemies flag
break;
}
case FLAG_DROPPED:
{
- if(CTF_SAMETEAM(toucher, self) && (autocvar_g_ctf_flag_return || num_perteam <= 1) && self.team) // automatically return if there's only 1 player on the team
- ctf_Handle_Return(self, toucher); // toucher just returned his own flag
- else if(is_not_monster && (!toucher.flagcarried) && ((toucher != self.ctf_dropper) || (time > self.ctf_droptime + autocvar_g_ctf_flag_collect_delay)))
- ctf_Handle_Pickup(self, toucher, PICKUP_DROPPED); // toucher just picked up a dropped enemy flag
+ if(CTF_SAMETEAM(toucher, flag) && (autocvar_g_ctf_flag_return || num_perteam <= 1) && flag.team) // automatically return if there's only 1 player on the team
+ ctf_Handle_Return(flag, toucher); // toucher just returned his own flag
+ else if(is_not_monster && (!toucher.flagcarried) && ((toucher != flag.ctf_dropper) || (time > flag.ctf_droptime + autocvar_g_ctf_flag_collect_delay)))
+ ctf_Handle_Pickup(flag, toucher, PICKUP_DROPPED); // toucher just picked up a dropped enemy flag
break;
}
case FLAG_PASSING:
{
- if((IS_PLAYER(toucher)) && (toucher.deadflag == DEAD_NO) && (toucher != self.pass_sender))
+ if((IS_PLAYER(toucher)) && (toucher.deadflag == DEAD_NO) && (toucher != flag.pass_sender))
{
- if(DIFF_TEAM(toucher, self.pass_sender))
- ctf_Handle_Return(self, toucher);
+ if(DIFF_TEAM(toucher, flag.pass_sender))
+ ctf_Handle_Return(flag, toucher);
else
- ctf_Handle_Retrieve(self, toucher);
+ ctf_Handle_Retrieve(flag, toucher);
}
break;
}
// appearence
_setmodel(flag, flag.model); // precision set below
- setsize(flag, FLAG_MIN, FLAG_MAX);
+ setsize(flag, CTF_FLAG.m_mins, CTF_FLAG.m_maxs);
setorigin(flag, (flag.origin + FLAG_SPAWN_OFFSET));
if(autocvar_g_ctf_flag_glowtrails)
if(sf & ISF_SIZE)
{
- WriteByte(MSG_ENTITY, ((self.flags & FL_POWERUP) || self.health || self.armorvalue));
+ Pickup p = this.itemdef;
+ WriteByte(MSG_ENTITY, p.instanceOfPowerup || p.instanceOfHealth || p.instanceOfArmor);
}
if(sf & ISF_STATUS)
item.SendFlags |= ISF_LOCATION;
}
-float have_pickup_item(void)
-{SELFPARAM();
- if(self.flags & FL_POWERUP)
+bool have_pickup_item(entity this)
+{
+ if(this.itemdef.instanceOfPowerup)
{
if(autocvar_g_powerups > 0)
return true;
if(autocvar_g_pickup_items == 0)
return false;
if(g_weaponarena)
- if(self.weapons || (self.items & IT_AMMO)) // no item or ammo pickups in weaponarena
+ if(this.weapons || (this.items & IT_AMMO)) // no item or ammo pickups in weaponarena
return false;
}
return true;
e.spawnshieldtime = 1;
e.ItemStatus &= ~ITS_AVAILABLE;
}
- else if((e.flags & FL_WEAPON) && !(e.flags & FL_NO_WEAPON_STAY) && g_weapon_stay)
+ else {
+ entity def = e.itemdef;
+ bool nostay = def.instanceOfWeaponPickup ? !!(def.m_weapon.weapons & WEPSET_SUPERWEAPONS) : false // no weapon-stay on superweapons
+ || e.team // weapon stay isn't supported for teamed weapons
+ ;
+ if(def.instanceOfWeaponPickup && !nostay && g_weapon_stay)
{
// make the item translucent and not touchable
e.model = e.mdl;
e.glowmod = e.colormod;
e.spawnshieldtime = 1;
e.ItemStatus &= ~ITS_AVAILABLE;
- }
+ }}
if (e.items & ITEM_Strength.m_itemid || e.items & ITEM_Shield.m_itemid)
e.ItemStatus |= ITS_POWERUP;
pickedup |= Item_GiveAmmoTo(item, player, health, item.max_health, ITEM_MODE_HEALTH);
pickedup |= Item_GiveAmmoTo(item, player, armorvalue, item.max_armorvalue, ITEM_MODE_ARMOR);
- if (item.flags & FL_WEAPON)
+ if (item.itemdef.instanceOfWeaponPickup)
{
WepSet it;
it = item.weapons;
return 0;
// crude hack to enforce switching weapons
- if(g_cts && (item.flags & FL_WEAPON))
+ if(g_cts && item.itemdef.instanceOfWeaponPickup)
{
W_SwitchWeapon_Force(player, item.weapon);
return 1;
return 1;
}
-void Item_Touch (void)
-{SELFPARAM();
- entity e, head;
+void Item_Touch()
+{
+ SELFPARAM();
// remove the item if it's currnetly in a NODROP brush or hits a NOIMPACT surface (such as sky)
- if(self.classname == "droppedweapon")
+ if (this.classname == "droppedweapon")
{
if (ITEM_TOUCH_NEEDKILL())
{
- remove(self);
+ remove(this);
return;
}
}
if(!(other.flags & FL_PICKUPITEMS)
|| other.frozen
|| other.deadflag
- || (self.solid != SOLID_TRIGGER)
- || (self.owner == other)
- || (time < self.item_spawnshieldtime)
- ) { return;}
+ || (this.solid != SOLID_TRIGGER)
+ || (this.owner == other)
+ || (time < this.item_spawnshieldtime)
+ ) { return; }
- switch(MUTATOR_CALLHOOK(ItemTouch, self, other))
+ switch (MUTATOR_CALLHOOK(ItemTouch, this, other))
{
case MUT_ITEMTOUCH_RETURN: { return; }
case MUT_ITEMTOUCH_PICKUP: { goto pickup; }
}
- if (self.classname == "droppedweapon")
+ if (this.classname == "droppedweapon")
{
- self.strength_finished = max(0, self.strength_finished - time);
- self.invincible_finished = max(0, self.invincible_finished - time);
- self.superweapons_finished = max(0, self.superweapons_finished - time);
+ this.strength_finished = max(0, this.strength_finished - time);
+ this.invincible_finished = max(0, this.invincible_finished - time);
+ this.superweapons_finished = max(0, this.superweapons_finished - time);
}
- entity it = self.itemdef;
- bool gave = (it && it.instanceOfPickup) ? ITEM_HANDLE(Pickup, it, self, other) : Item_GiveTo(self, other);
+ entity it = this.itemdef;
+ bool gave = ITEM_HANDLE(Pickup, it, this, other);
if (!gave)
{
- if (self.classname == "droppedweapon")
+ if (this.classname == "droppedweapon")
{
// undo what we did above
- self.strength_finished += time;
- self.invincible_finished += time;
- self.superweapons_finished += time;
+ this.strength_finished += time;
+ this.invincible_finished += time;
+ this.superweapons_finished += time;
}
return;
}
other.last_pickup = time;
- Send_Effect(EFFECT_ITEM_PICKUP, CENTER_OR_VIEWOFS(self), '0 0 0', 1);
- _sound (other, CH_TRIGGER, (self.item_pickupsound ? self.item_pickupsound : self.item_pickupsound_ent.sound_str()), VOL_BASE, ATTEN_NORM);
+ Send_Effect(EFFECT_ITEM_PICKUP, CENTER_OR_VIEWOFS(this), '0 0 0', 1);
+ _sound (other, CH_TRIGGER, (this.item_pickupsound ? this.item_pickupsound : this.item_pickupsound_ent.sound_str()), VOL_BASE, ATTEN_NORM);
- if (self.classname == "droppedweapon")
- remove (self);
- else if (self.spawnshieldtime)
+ if (this.classname == "droppedweapon")
+ remove (this);
+ else if (this.spawnshieldtime)
{
- if(self.team)
+ entity e;
+ if(this.team)
{
RandomSelection_Init();
- for(head = world; (head = findfloat(head, team, self.team)); )
+ for(entity head = world; (head = findfloat(head, team, this.team)); )
{
if(head.flags & FL_ITEM)
if(head.classname != "item_flag_team" && head.classname != "item_key_team")
}
else
- e = self;
+ e = this;
Item_ScheduleRespawn(e);
}
}
-void Item_Reset()
-{SELFPARAM();
- Item_Show(self, !self.state);
- setorigin (self, self.origin);
+void Item_Reset(entity this)
+{
+ Item_Show(this, !this.state);
+ setorigin(this, this.origin);
- if(self.classname != "droppedweapon")
+ if (this.classname != "droppedweapon")
{
- self.think = Item_Think;
- self.nextthink = time;
+ this.think = Item_Think;
+ this.nextthink = time;
- if(self.waypointsprite_attached)
- WaypointSprite_Kill(self.waypointsprite_attached);
+ if (this.waypointsprite_attached)
+ WaypointSprite_Kill(this.waypointsprite_attached);
- if((self.flags & FL_POWERUP) || (self.weapons & WEPSET_SUPERWEAPONS)) // do not spawn powerups initially!
- Item_ScheduleInitialRespawn(self);
+ if (this.itemdef.instanceOfPowerup || (this.weapons & WEPSET_SUPERWEAPONS)) // do not spawn powerups initially!
+ Item_ScheduleInitialRespawn(this);
}
}
+void Item_Reset_self() { SELFPARAM(); Item_Reset(this); }
void Item_FindTeam()
{SELFPARAM();
head.effects &= ~EF_NODRAW;
}
- Item_Reset();
+ Item_Reset(self);
}
}
RemoveItem();
}
-void StartItem (string itemmodel, string pickupsound, float defaultrespawntime, float defaultrespawntimejitter, string itemname, float itemid, float weaponid, float itemflags, float(entity player, entity item) pickupevalfunc, float pickupbasevalue)
-{SELFPARAM();
- startitem_failed = false;
-
- if(self.model == "")
- self.model = itemmodel;
+void _StartItem(entity this, entity def, float defaultrespawntime, float defaultrespawntimejitter)
+{
+ string itemname = def.m_name;
+ Model itemmodel = def.m_model;
+ Sound pickupsound = def.m_sound;
+ float(entity player, entity item) pickupevalfunc = def.m_pickupevalfunc;
+ float pickupbasevalue = def.m_botvalue;
+ int itemflags = def.m_itemflags;
- if(self.model == "")
- {
- error(strcat("^1Tried to spawn ", itemname, " with no model!\n"));
- return;
- }
+ startitem_failed = false;
- if(self.item_pickupsound == "")
- self.item_pickupsound = pickupsound;
+ this.item_model_ent = itemmodel;
+ this.item_pickupsound_ent = pickupsound;
- if(!self.respawntime) // both need to be set
+ if(!this.respawntime) // both need to be set
{
- self.respawntime = defaultrespawntime;
- self.respawntimejitter = defaultrespawntimejitter;
+ this.respawntime = defaultrespawntime;
+ this.respawntimejitter = defaultrespawntimejitter;
}
- self.items = itemid;
- self.weapon = weaponid;
+ int itemid = def.m_itemid;
+ this.items = itemid;
+ int weaponid = def.instanceOfWeaponPickup ? def.m_weapon.m_id : 0;
+ this.weapon = weaponid;
- if(!self.fade_end)
+ if(!this.fade_end)
{
- self.fade_start = autocvar_g_items_mindist;
- self.fade_end = autocvar_g_items_maxdist;
+ this.fade_start = autocvar_g_items_mindist;
+ this.fade_end = autocvar_g_items_maxdist;
}
if(weaponid)
- self.weapons = WepSet_FromWeapon(weaponid);
+ this.weapons = WepSet_FromWeapon(weaponid);
- self.flags = FL_ITEM | itemflags;
+ this.flags = FL_ITEM | itemflags;
- if(MUTATOR_CALLHOOK(FilterItem)) // error means we do not want the item
+ if(MUTATOR_CALLHOOK(FilterItem, this)) // error means we do not want the item
{
startitem_failed = true;
- remove(self);
+ remove(this);
return;
}
// is it a dropped weapon?
- if (self.classname == "droppedweapon")
+ if (this.classname == "droppedweapon")
{
- self.reset = SUB_Remove;
+ this.reset = SUB_Remove;
// it's a dropped weapon
- self.movetype = MOVETYPE_TOSS;
+ this.movetype = MOVETYPE_TOSS;
// Savage: remove thrown items after a certain period of time ("garbage collection")
- self.think = RemoveItem;
- self.nextthink = time + 20;
+ this.think = RemoveItem;
+ this.nextthink = time + 20;
- self.takedamage = DAMAGE_YES;
- self.event_damage = Item_Damage;
+ this.takedamage = DAMAGE_YES;
+ this.event_damage = Item_Damage;
- if(self.strength_finished || self.invincible_finished || self.superweapons_finished)
- /*
- if(self.items == 0)
- if(!(self.weapons & ~WEPSET_SUPERWEAPONS)) // only superweapons
- if(self.ammo_nails == 0)
- if(self.ammo_cells == 0)
- if(self.ammo_rockets == 0)
- if(self.ammo_shells == 0)
- if(self.ammo_fuel == 0)
- if(self.health == 0)
- if(self.armorvalue == 0)
- */
+ if(this.strength_finished || this.invincible_finished || this.superweapons_finished)
{
// if item is worthless after a timer, have it expire then
- self.nextthink = max(self.strength_finished, self.invincible_finished, self.superweapons_finished);
+ this.nextthink = max(this.strength_finished, this.invincible_finished, this.superweapons_finished);
}
// don't drop if in a NODROP zone (such as lava)
- traceline(self.origin, self.origin, MOVE_NORMAL, self);
+ traceline(this.origin, this.origin, MOVE_NORMAL, this);
if (trace_dpstartcontents & DPCONTENTS_NODROP)
{
startitem_failed = true;
- remove(self);
+ remove(this);
return;
}
}
else
{
- if(!have_pickup_item())
+ if(!have_pickup_item(this))
{
startitem_failed = true;
- remove (self);
+ remove (this);
return;
}
- if(self.angles != '0 0 0')
- self.SendFlags |= ISF_ANGLES;
+ if(this.angles != '0 0 0')
+ this.SendFlags |= ISF_ANGLES;
- self.reset = Item_Reset;
+ this.reset = Item_Reset_self;
// it's a level item
- if(self.spawnflags & 1)
- self.noalign = 1;
- if (self.noalign > 0)
- self.movetype = MOVETYPE_NONE;
+ if(this.spawnflags & 1)
+ this.noalign = 1;
+ if (this.noalign > 0)
+ this.movetype = MOVETYPE_NONE;
else
- self.movetype = MOVETYPE_TOSS;
+ this.movetype = MOVETYPE_TOSS;
// do item filtering according to game mode and other things
- if (self.noalign <= 0)
+ if (this.noalign <= 0)
{
// first nudge it off the floor a little bit to avoid math errors
- setorigin(self, self.origin + '0 0 1');
+ setorigin(this, this.origin + '0 0 1');
// set item size before we spawn a spawnfunc_waypoint
- if((itemflags & FL_POWERUP) || self.health || self.armorvalue)
- setsize (self, '-16 -16 0', '16 16 48');
- else
- setsize (self, '-16 -16 0', '16 16 32');
- self.SendFlags |= ISF_SIZE;
+ setsize(this, def.m_mins, def.m_maxs);
+ this.SendFlags |= ISF_SIZE;
// note droptofloor returns false if stuck/or would fall too far
- if(!self.noalign)
- droptofloor();
- waypoint_spawnforitem(self);
+ if (!this.noalign)
+ WITH(entity, self, this, droptofloor());
+ waypoint_spawnforitem(this);
}
/*
* can't do it that way, as it would break maps
* TODO make a target_give like entity another way, that perhaps has
* the weapon name in a key
- if(self.targetname)
+ if(this.targetname)
{
// target_give not yet supported; maybe later
- print("removed targeted ", self.classname, "\n");
+ print("removed targeted ", this.classname, "\n");
startitem_failed = true;
- remove (self);
+ remove (this);
return;
}
*/
if(autocvar_spawn_debug >= 2)
{
- entity otheritem;
- for(otheritem = findradius(self.origin, 3); otheritem; otheritem = otheritem.chain)
+ for(entity otheritem = findradius(this.origin, 3); otheritem; otheritem = otheritem.chain)
{
// why not flags & fl_item?
if(otheritem.is_item)
{
- LOG_TRACE("XXX Found duplicated item: ", itemname, vtos(self.origin));
+ LOG_TRACE("XXX Found duplicated item: ", itemname, vtos(this.origin));
LOG_TRACE(" vs ", otheritem.netname, vtos(otheritem.origin), "\n");
error("Mapper sucks.");
}
}
- self.is_item = true;
+ this.is_item = true;
}
weaponsInMap |= WepSet_FromWeapon(weaponid);
- precache_model (self.model);
- precache_sound (self.item_pickupsound);
+ precache_model(this.model);
+ precache_sound(this.item_pickupsound);
- if((itemflags & (FL_POWERUP | FL_WEAPON)) || (itemid & (IT_HEALTH | IT_ARMOR | IT_KEY1 | IT_KEY2)))
- self.target = "###item###"; // for finding the nearest item using find()
+ if ( def.instanceOfPowerup
+ || def.instanceOfWeaponPickup
+ || (def.instanceOfHealth && def != ITEM_HealthSmall)
+ || (def.instanceOfArmor && def != ITEM_ArmorSmall)
+ || (itemid & (IT_KEY1 | IT_KEY2))
+ ) this.target = "###item###"; // for finding the nearest item using find()
- Item_ItemsTime_SetTime(self, 0);
+ Item_ItemsTime_SetTime(this, 0);
}
- self.bot_pickup = true;
- self.bot_pickupevalfunc = pickupevalfunc;
- self.bot_pickupbasevalue = pickupbasevalue;
- self.mdl = self.model;
- self.netname = itemname;
- self.touch = Item_Touch;
- setmodel(self, MDL_Null); // precision set below
- //self.effects |= EF_LOWPRECISION;
-
- if((itemflags & FL_POWERUP) || self.health || self.armorvalue)
- {
- self.pos1 = '-16 -16 0';
- self.pos2 = '16 16 48';
- }
- else
- {
- self.pos1 = '-16 -16 0';
- self.pos2 = '16 16 32';
- }
- setsize (self, self.pos1, self.pos2);
+ this.bot_pickup = true;
+ this.bot_pickupevalfunc = pickupevalfunc;
+ this.bot_pickupbasevalue = pickupbasevalue;
+ this.mdl = this.model ? this.model : strzone(this.item_model_ent.model_str());
+ this.netname = itemname;
+ this.touch = Item_Touch;
+ setmodel(this, MDL_Null); // precision set below
+ //this.effects |= EF_LOWPRECISION;
- self.SendFlags |= ISF_SIZE;
+ setsize (this, this.pos1 = def.m_mins, this.pos2 = def.m_maxs);
- if(!(self.spawnflags & 1024))
- {
- if(itemflags & FL_POWERUP)
- self.ItemStatus |= ITS_ANIMATE1;
+ this.SendFlags |= ISF_SIZE;
- if(self.armorvalue || self.health)
- self.ItemStatus |= ITS_ANIMATE2;
+ if (!(this.spawnflags & 1024)) {
+ if(def.instanceOfPowerup)
+ this.ItemStatus |= ITS_ANIMATE1;
+
+ if(this.armorvalue || this.health)
+ this.ItemStatus |= ITS_ANIMATE2;
}
- if(itemflags & FL_WEAPON)
+ if(def.instanceOfWeaponPickup)
{
- if (self.classname != "droppedweapon") // if dropped, colormap is already set up nicely
- self.colormap = 1024; // color shirt=0 pants=0 grey
+ if (this.classname != "droppedweapon") // if dropped, colormap is already set up nicely
+ this.colormap = 1024; // color shirt=0 pants=0 grey
else
- self.gravity = 1;
-
- if(!(self.spawnflags & 1024))
- self.ItemStatus |= ITS_ANIMATE1;
- self.ItemStatus |= ISF_COLORMAP;
+ this.gravity = 1;
+ if (!(this.spawnflags & 1024))
+ this.ItemStatus |= ITS_ANIMATE1;
+ this.ItemStatus |= ISF_COLORMAP;
}
- self.state = 0;
- if(self.team) // broken, no idea why.
+ this.state = 0;
+ if(this.team) // broken, no idea why.
{
- if(!self.cnt)
- self.cnt = 1; // item probability weight
+ if(!this.cnt)
+ this.cnt = 1; // item probability weight
- self.effects |= EF_NODRAW; // marker for item team search
- InitializeEntity(self, Item_FindTeam, INITPRIO_FINDTARGET);
+ this.effects |= EF_NODRAW; // marker for item team search
+ InitializeEntity(this, Item_FindTeam, INITPRIO_FINDTARGET);
}
else
- Item_Reset();
+ Item_Reset(this);
- Net_LinkEntity(self, !((itemflags & FL_POWERUP) || self.health || self.armorvalue), 0, ItemSend);
+ Net_LinkEntity(this, !(def.instanceOfPowerup || def.instanceOfHealth || def.instanceOfArmor), 0, ItemSend);
// call this hook after everything else has been done
- if(MUTATOR_CALLHOOK(Item_Spawn, self))
+ if (MUTATOR_CALLHOOK(Item_Spawn, this))
{
startitem_failed = true;
- remove(self);
+ remove(this);
return;
}
}
-void StartItemA (entity a)
-{SELFPARAM();
- self.itemdef = a;
- StartItem(strzone(a.m_model.model_str()), a.m_sound, a.m_respawntime(), a.m_respawntimejitter(), a.m_name, a.m_itemid, 0, a.m_itemflags, a.m_pickupevalfunc, a.m_botvalue);
+void StartItem(entity this, GameItem def)
+{
+ _StartItem(
+ this,
+ this.itemdef = def,
+ def.m_respawntime(), // defaultrespawntime
+ def.m_respawntimejitter() // defaultrespawntimejitter
+ );
}
spawnfunc(item_rockets)
self.ammo_rockets = g_pickup_rockets;
if(!self.pickup_anyway)
self.pickup_anyway = g_pickup_ammo_anyway;
- StartItemA (ITEM_Rockets);
+ StartItem(this, ITEM_Rockets);
}
spawnfunc(item_bullets)
self.ammo_nails = g_pickup_nails;
if(!self.pickup_anyway)
self.pickup_anyway = g_pickup_ammo_anyway;
- StartItemA (ITEM_Bullets);
+ StartItem(this, ITEM_Bullets);
}
spawnfunc(item_cells)
self.ammo_cells = g_pickup_cells;
if(!self.pickup_anyway)
self.pickup_anyway = g_pickup_ammo_anyway;
- StartItemA (ITEM_Cells);
+ StartItem(this, ITEM_Cells);
}
spawnfunc(item_plasma)
self.ammo_plasma = g_pickup_plasma;
if(!self.pickup_anyway)
self.pickup_anyway = g_pickup_ammo_anyway;
- StartItemA (ITEM_Plasma);
+ StartItem(this, ITEM_Plasma);
}
spawnfunc(item_shells)
self.ammo_shells = g_pickup_shells;
if(!self.pickup_anyway)
self.pickup_anyway = g_pickup_ammo_anyway;
- StartItemA (ITEM_Shells);
+ StartItem(this, ITEM_Shells);
}
spawnfunc(item_armor_small)
self.max_armorvalue = g_pickup_armorsmall_max;
if(!self.pickup_anyway)
self.pickup_anyway = g_pickup_armorsmall_anyway;
- StartItemA (ITEM_ArmorSmall);
+ StartItem(this, ITEM_ArmorSmall);
}
spawnfunc(item_armor_medium)
self.max_armorvalue = g_pickup_armormedium_max;
if(!self.pickup_anyway)
self.pickup_anyway = g_pickup_armormedium_anyway;
- StartItemA (ITEM_ArmorMedium);
+ StartItem(this, ITEM_ArmorMedium);
}
spawnfunc(item_armor_big)
self.max_armorvalue = g_pickup_armorbig_max;
if(!self.pickup_anyway)
self.pickup_anyway = g_pickup_armorbig_anyway;
- StartItemA (ITEM_ArmorLarge);
+ StartItem(this, ITEM_ArmorLarge);
}
spawnfunc(item_armor_large)
self.max_armorvalue = g_pickup_armorlarge_max;
if(!self.pickup_anyway)
self.pickup_anyway = g_pickup_armorlarge_anyway;
- StartItemA (ITEM_ArmorMega);
+ StartItem(this, ITEM_ArmorMega);
}
spawnfunc(item_health_small)
self.health = g_pickup_healthsmall;
if(!self.pickup_anyway)
self.pickup_anyway = g_pickup_healthsmall_anyway;
- StartItemA (ITEM_HealthSmall);
+ StartItem(this, ITEM_HealthSmall);
}
spawnfunc(item_health_medium)
self.health = g_pickup_healthmedium;
if(!self.pickup_anyway)
self.pickup_anyway = g_pickup_healthmedium_anyway;
- StartItemA (ITEM_HealthMedium);
+ StartItem(this, ITEM_HealthMedium);
}
spawnfunc(item_health_large)
self.health = g_pickup_healthlarge;
if(!self.pickup_anyway)
self.pickup_anyway = g_pickup_healthlarge_anyway;
- StartItemA (ITEM_HealthLarge);
+ StartItem(this, ITEM_HealthLarge);
}
spawnfunc(item_health_mega)
self.health = g_pickup_healthmega;
if(!self.pickup_anyway)
self.pickup_anyway = g_pickup_healthmega_anyway;
- StartItemA (ITEM_HealthMega);
+ StartItem(this, ITEM_HealthMega);
}
// support old misnamed entities
{
if(!self.strength_finished)
self.strength_finished = autocvar_g_balance_powerup_strength_time;
- StartItemA (ITEM_Strength);
+ StartItem(this, ITEM_Strength);
}
spawnfunc(item_invincible)
{
if(!self.invincible_finished)
self.invincible_finished = autocvar_g_balance_powerup_invincible_time;
- StartItemA (ITEM_Shield);
+ StartItem(this, ITEM_Shield);
}
// compatibility:
self.ammo_fuel = g_pickup_fuel;
if(!self.pickup_anyway)
self.pickup_anyway = g_pickup_ammo_anyway;
- StartItemA (ITEM_JetpackFuel);
+ StartItem(this, ITEM_JetpackFuel);
}
spawnfunc(item_fuel_regen)
spawnfunc_item_fuel(this);
return;
}
- StartItemA (ITEM_JetpackRegen);
+ StartItem(this, ITEM_JetpackRegen);
}
spawnfunc(item_jetpack)
spawnfunc_item_fuel(this);
return;
}
- StartItemA (ITEM_Jetpack);
+ StartItem(this, ITEM_Jetpack);
}
float GiveWeapon(entity e, float wpn, float op, float val)
.float fade_end;
#ifdef SVQC
-void StartItemA (entity a);
+void StartItem(entity this, entity a);
#endif
#ifdef CSQC
bool ItemSend(entity this, entity to, int sf);
-float have_pickup_item(void);
+bool have_pickup_item(entity this);
const float ITEM_RESPAWN_TICKS = 10;
float Item_GiveTo(entity item, entity player);
-void Item_Touch (void);
+void Item_Touch();
-void Item_Reset();
+void Item_Reset(entity this);
void Item_FindTeam();
// Savage: used for item garbage-collection
.float is_item;
.entity itemdef;
-void StartItem (string itemmodel, string pickupsound, float defaultrespawntime, float defaultrespawntimejitter, string itemname, float itemid, float weaponid, float itemflags, float(entity player, entity item) pickupevalfunc, float pickupbasevalue);
+void _StartItem(entity this, entity def, float defaultrespawntime, float defaultrespawntimejitter);
void target_items_use (void);
return substring(out, 1, -1);
}
-void weapon_defaultspawnfunc(float wpn)
-{SELFPARAM();
- entity e;
- float t;
- string s;
- float i, j;
- int f;
-
- if(self.classname != "droppedweapon" && self.classname != "replacedweapon")
+void weapon_defaultspawnfunc(entity this, Weapon e)
+{
+ int wpn = e.m_id;
+ if (this.classname != "droppedweapon" && this.classname != "replacedweapon")
{
- e = get_weaponinfo(wpn);
-
- if(e.spawnflags & WEP_FLAG_MUTATORBLOCKED)
+ if (e.spawnflags & WEP_FLAG_MUTATORBLOCKED)
{
objerror("Attempted to spawn a mutator-blocked weapon rejected");
startitem_failed = true;
return;
}
- s = W_Apply_Weaponreplace(e.netname);
- MUTATOR_CALLHOOK(SetWeaponreplace, self, e, s);
+ string s = W_Apply_Weaponreplace(e.netname);
+ MUTATOR_CALLHOOK(SetWeaponreplace, this, e, s);
s = ret_string;
- if(s == "")
+ if (s == "")
{
- remove(self);
+ remove(this);
startitem_failed = true;
return;
}
- t = tokenize_console(s);
- if(t >= 2)
+ int t = tokenize_console(s);
+ if (t >= 2)
{
- self.team = --internalteam;
- for(i = 1; i < t; ++i)
+ this.team = --internalteam;
+ for (int i = 1; i < t; ++i)
{
s = argv(i);
- for(j = WEP_FIRST; j <= WEP_LAST; ++j)
+ int j;
+ for (j = WEP_FIRST; j <= WEP_LAST; ++j)
{
e = get_weaponinfo(j);
- if(e.netname == s)
+ if (e.netname == s)
{
- setself(spawn());
- copyentity(this, self);
- self.classname = "replacedweapon";
- weapon_defaultspawnfunc(j);
+ entity replacement = spawn();
+ copyentity(this, replacement);
+ replacement.classname = "replacedweapon";
+ weapon_defaultspawnfunc(replacement, e);
break;
}
}
- if(j > WEP_LAST)
+ if (j > WEP_LAST)
{
LOG_INFO("The weapon replace list for ", this.classname, " contains an unknown weapon ", s, ". Skipped.\n");
}
}
- setself(this);
}
- if(t >= 1) // always the case!
+ if (t >= 1) // always the case!
{
s = argv(0);
wpn = 0;
- for(j = WEP_FIRST; j <= WEP_LAST; ++j)
+ int j;
+ for (j = WEP_FIRST; j <= WEP_LAST; ++j)
{
e = get_weaponinfo(j);
- if(e.netname == s)
+ if (e.netname == s)
{
wpn = j;
break;
}
}
- if(j > WEP_LAST)
+ if (j > WEP_LAST)
{
- LOG_INFO("The weapon replace list for ", self.classname, " contains an unknown weapon ", s, ". Skipped.\n");
+ LOG_INFO("The weapon replace list for ", this.classname, " contains an unknown weapon ", s, ". Skipped.\n");
}
}
- if(wpn == 0)
+ if (wpn == 0)
{
- remove(self);
+ remove(this);
startitem_failed = true;
return;
}
e = get_weaponinfo(wpn);
- if(!self.respawntime)
+ if (!this.respawntime)
{
- if(e.weapons & WEPSET_SUPERWEAPONS)
+ if (e.weapons & WEPSET_SUPERWEAPONS)
{
- self.respawntime = g_pickup_respawntime_superweapon;
- self.respawntimejitter = g_pickup_respawntimejitter_superweapon;
+ this.respawntime = g_pickup_respawntime_superweapon;
+ this.respawntimejitter = g_pickup_respawntimejitter_superweapon;
}
else
{
- self.respawntime = g_pickup_respawntime_weapon;
- self.respawntimejitter = g_pickup_respawntimejitter_weapon;
+ this.respawntime = g_pickup_respawntime_weapon;
+ this.respawntimejitter = g_pickup_respawntimejitter_weapon;
}
}
- if(e.weapons & WEPSET_SUPERWEAPONS)
- if(!self.superweapons_finished)
- self.superweapons_finished = autocvar_g_balance_superweapons_time;
+ if (e.weapons & WEPSET_SUPERWEAPONS)
+ if (!this.superweapons_finished)
+ this.superweapons_finished = autocvar_g_balance_superweapons_time;
// if we don't already have ammo, give us some ammo
- if(!self.(e.ammo_field))
+ if (!this.(e.ammo_field))
{
- switch(e.ammo_field)
+ switch (e.ammo_field)
{
- case ammo_shells: self.ammo_shells = cvar("g_pickup_shells_weapon"); break;
- case ammo_nails: self.ammo_nails = cvar("g_pickup_nails_weapon"); break;
- case ammo_rockets: self.ammo_rockets = cvar("g_pickup_rockets_weapon"); break;
- case ammo_cells: self.ammo_cells = cvar("g_pickup_cells_weapon"); break;
- case ammo_plasma: self.ammo_plasma = cvar("g_pickup_plasma_weapon"); break;
- case ammo_fuel: self.ammo_fuel = cvar("g_pickup_fuel_weapon"); break;
+ case ammo_shells: this.ammo_shells = cvar("g_pickup_shells_weapon"); break;
+ case ammo_nails: this.ammo_nails = cvar("g_pickup_nails_weapon"); break;
+ case ammo_rockets: this.ammo_rockets = cvar("g_pickup_rockets_weapon"); break;
+ case ammo_cells: this.ammo_cells = cvar("g_pickup_cells_weapon"); break;
+ case ammo_plasma: this.ammo_plasma = cvar("g_pickup_plasma_weapon"); break;
+ case ammo_fuel: this.ammo_fuel = cvar("g_pickup_fuel_weapon"); break;
}
}
#if 0 // WEAPONTODO
- if(e.items)
+ if (e.items)
{
- for(i = 0, j = 1; i < 24; ++i, j *= 2)
+ for (int i = 0, j = 1; i < 24; ++i, j <<= 1)
{
- if(e.items & j)
+ if (e.items & j)
{
ammotype = Item_CounterField(j);
- if(!self.ammotype)
- self.ammotype = cvar(strcat("g_pickup_", Item_CounterFieldName(j), "_weapon"));
+ if (!this.ammotype)
+ this.ammotype = cvar(strcat("g_pickup_", Item_CounterFieldName(j), "_weapon"));
}
}
}
#endif
// pickup anyway
- if(g_pickup_weapons_anyway)
- self.pickup_anyway = true;
-
- f = FL_WEAPON;
-
- // no weapon-stay on superweapons
- if(e.weapons & WEPSET_SUPERWEAPONS)
- f |= FL_NO_WEAPON_STAY;
-
- // weapon stay isn't supported for teamed weapons
- if(self.team)
- f |= FL_NO_WEAPON_STAY;
-
- StartItem(strzone(e.m_model.model_str()), string_null, self.respawntime, self.respawntimejitter, e.message, 0, e.weapon, f, weapon_pickupevalfunc, e.bot_pickupbasevalue);
- self.item_pickupsound_ent = SND_WEAPONPICKUP;
+ if (g_pickup_weapons_anyway)
+ this.pickup_anyway = true;
+
+ GameItem def = e.m_pickup;
+ _StartItem(
+ this,
+ this.itemdef = def,
+ this.respawntime, // defaultrespawntime
+ this.respawntimejitter // defaultrespawntimejitter
+ );
#if 0 // WEAPONTODO
- if (self.modelindex) { // don't precache if self was removed
- Weapon w = get_weaponinfo(e.weapon);
- w.wr_init(w);
+ if (this.modelindex) { // don't precache if this was removed
+ e.wr_init(e);
}
#endif
}
string W_Apply_Weaponreplace(string in);
-void weapon_defaultspawnfunc(float wpn);
+void weapon_defaultspawnfunc(entity this, Weapon e);
#endif
{SELFPARAM();
float thisammo, i;
string s;
- var .int ammotype = (get_weaponinfo(wpn)).ammo_field;
+ Weapon info = get_weaponinfo(wpn);
+ var .int ammotype = info.ammo_field;
entity wep = spawn();
}
}
- WITH(entity, self, wep, weapon_defaultspawnfunc(wpn));
+ weapon_defaultspawnfunc(wep, info);
if(startitem_failed)
return string_null;
wep.glowmod = own.weaponentity_glowmod;