WepSet _WepSet_FromWeapon(int a)
{
a -= WEP_FIRST;
- if (Weapons_MAX > 24)
+ if (REGISTRY_MAX(Weapons) > 24)
if (a >= 24)
{
a -= 24;
- if (Weapons_MAX > 48)
+ if (REGISTRY_MAX(Weapons) > 48)
if (a >= 24)
{
a -= 24;
#ifdef SVQC
void WriteWepSet(float dst, WepSet w)
{
- if (Weapons_MAX > 48) WriteInt72_t(dst, w);
- else if (Weapons_MAX > 24) WriteInt48_t(dst, w);
+ if (REGISTRY_MAX(Weapons) > 48) WriteInt72_t(dst, w);
+ else if (REGISTRY_MAX(Weapons) > 24) WriteInt48_t(dst, w);
else WriteInt24_t(dst, w.x);
}
#endif
}
WepSet ReadWepSet()
{
- if (Weapons_MAX > 48) return ReadInt72_t();
- if (Weapons_MAX > 24) return ReadInt48_t();
+ if (REGISTRY_MAX(Weapons) > 48) return ReadInt72_t();
+ if (REGISTRY_MAX(Weapons) > 24) return ReadInt48_t();
return ReadInt24_t() * '1 0 0';
}
#endif
int i = stof(s);
if (s == "0" || i)
{
- entity wi = Weapons_from(i);
+ entity wi = REGISTRY_GET(Weapons, i);
if (wi != WEP_Null) return wi.netname;
}
return s;
case "minstanex": return "vaporizer";
case "grenadelauncher": return "mortar";
case "uzi": return "machinegun";
+ case "hmg": return "okhmg";
+ case "rpc": return "okrpc";
default: return s;
}
}
return mapPriorityList(order, W_NumberWeaponOrder_MapFunc);
}
-float W_FixWeaponOrder_BuildImpulseList_buf[Weapons_MAX];
+float W_FixWeaponOrder_BuildImpulseList_buf[REGISTRY_MAX(Weapons)];
string W_FixWeaponOrder_BuildImpulseList_order;
void W_FixWeaponOrder_BuildImpulseList_swap(int i, int j, entity pass)
{
float W_FixWeaponOrder_BuildImpulseList_cmp(int i, int j, entity pass)
{
int si = W_FixWeaponOrder_BuildImpulseList_buf[i];
- Weapon e1 = Weapons_from(si);
+ Weapon e1 = REGISTRY_GET(Weapons, si);
int sj = W_FixWeaponOrder_BuildImpulseList_buf[j];
- Weapon e2 = Weapons_from(sj);
+ Weapon e2 = REGISTRY_GET(Weapons, sj);
int d = (e1.impulse + 9) % 10 - (e2.impulse + 9) % 10;
if (d != 0) return -d; // high impulse first!
return strstrofs(strcat(" ", W_FixWeaponOrder_BuildImpulseList_order, " "),
return W_FixWeaponOrder(order, 1);
}
-void W_RandomWeapons(entity e, int n)
+WepSet W_RandomWeapons(entity e, WepSet remaining, int n)
{
- WepSet remaining = e.weapons;
WepSet result = '0 0 0';
for (int j = 0; j < n; ++j)
{
result |= WepSet_FromWeapon(w);
remaining &= ~WepSet_FromWeapon(w);
}
- e.weapons = result;
+ return result;
}
string GetAmmoPicture(int ammotype)
{
switch (ammotype)
{
- case RESOURCE_SHELLS: return ITEM_Shells.m_icon;
- case RESOURCE_BULLETS: return ITEM_Bullets.m_icon;
- case RESOURCE_ROCKETS: return ITEM_Rockets.m_icon;
- case RESOURCE_CELLS: return ITEM_Cells.m_icon;
- case RESOURCE_PLASMA: return ITEM_Plasma.m_icon;
- case RESOURCE_FUEL: return ITEM_JetpackFuel.m_icon;
+ case RES_SHELLS: return ITEM_Shells.m_icon;
+ case RES_BULLETS: return ITEM_Bullets.m_icon;
+ case RES_ROCKETS: return ITEM_Rockets.m_icon;
+ case RES_CELLS: return ITEM_Cells.m_icon;
+ case RES_PLASMA: return ITEM_Plasma.m_icon;
+ case RES_FUEL: return ITEM_JetpackFuel.m_icon;
default: return ""; // wtf, no ammo type?
}
}
+string GetAmmoName(int ammotype)
+{
+ switch (ammotype)
+ {
+ case RES_SHELLS: return ITEM_Shells.m_name;
+ case RES_BULLETS: return ITEM_Bullets.m_name;
+ case RES_ROCKETS: return ITEM_Rockets.m_name;
+ case RES_CELLS: return ITEM_Cells.m_name;
+ case RES_PLASMA: return ITEM_Plasma.m_name;
+ case RES_FUEL: return ITEM_JetpackFuel.m_name;
+ default: return "batteries";
+ }
+}
+
#ifdef CSQC
int GetAmmoTypeFromNum(int i)
{
switch (i)
{
- case 0: return RESOURCE_SHELLS;
- case 1: return RESOURCE_BULLETS;
- case 2: return RESOURCE_ROCKETS;
- case 3: return RESOURCE_CELLS;
- case 4: return RESOURCE_PLASMA;
- case 5: return RESOURCE_FUEL;
- default: return RESOURCE_NONE;
+ case 0: return RES_SHELLS;
+ case 1: return RES_BULLETS;
+ case 2: return RES_ROCKETS;
+ case 3: return RES_CELLS;
+ case 4: return RES_PLASMA;
+ case 5: return RES_FUEL;
+ default: return RES_NONE;
}
}
{
switch (ammotype)
{
- case RESOURCE_SHELLS: return STAT_SHELLS;
- case RESOURCE_BULLETS: return STAT_NAILS;
- case RESOURCE_ROCKETS: return STAT_ROCKETS;
- case RESOURCE_CELLS: return STAT_CELLS;
- case RESOURCE_PLASMA: return STAT_PLASMA.m_id;
- case RESOURCE_FUEL: return STAT_FUEL.m_id;
+ case RES_SHELLS: return STAT_SHELLS;
+ case RES_BULLETS: return STAT_NAILS;
+ case RES_ROCKETS: return STAT_ROCKETS;
+ case RES_CELLS: return STAT_CELLS;
+ case RES_PLASMA: return STAT_PLASMA.m_id;
+ case RES_FUEL: return STAT_FUEL.m_id;
default: return -1;
}
}
* writes:
* this.origin, this.angles
* this.weaponchild
- * this.movedir, this.view_ofs
+ * this.movedir, this.view_ofs, this.movedir_aligned
* attachment stuff
* anim stuff
* to free:
}
this.view_ofs = '0 0 0';
+ this.movedir_aligned = this.movedir;
if (this.movedir.x >= 0)
{
#endif
vector v = this.movedir;
this.movedir = shotorg_adjust(v, false, false, algn);
+ this.movedir_aligned = shotorg_adjust(v, false, true, algn);
this.view_ofs = shotorg_adjust(v, false, true, algn) - v;
}
int compressed_shotorg = compressShotOrigin(this.movedir);
#ifdef CSQC
NET_HANDLE(wframe, bool isNew)
{
- vector a = ReadVector();
+ int fr = ReadByte();
+ float t = ReadFloat();
int slot = ReadByte();
bool restartanim = ReadByte();
entity wepent = viewmodels[slot];
- if(a.x == wepent.anim_idle_x) // we don't need to enforce idle animation
- wepent.animstate_looping = false;
+ if(fr == WFRAME_IDLE)
+ wepent.animstate_looping = false; // we don't need to enforce idle animation
else
+ {
+ vector a = '0 0 0';
+ switch(fr)
+ {
+ default:
+ case WFRAME_IDLE: a = wepent.anim_idle; break;
+ case WFRAME_FIRE1: a = wepent.anim_fire1; break;
+ case WFRAME_FIRE2: a = wepent.anim_fire2; break;
+ case WFRAME_RELOAD: a = wepent.anim_reload; break;
+ }
+ a.z *= t;
anim_set(wepent, a, !restartanim, restartanim, restartanim);
+ }
wepent.state = ReadByte();
wepent.weapon_nextthink = ReadFloat();
switch (wepent.state)
#endif
#ifdef SVQC
-void wframe_send(entity actor, entity weaponentity, vector a, bool restartanim)
+void wframe_send(entity actor, entity weaponentity, int wepframe, float attackrate, bool restartanim)
{
if (!IS_REAL_CLIENT(actor)) return;
int channel = MSG_ONE;
msg_entity = actor;
WriteHeader(channel, wframe);
- WriteVector(channel, a);
+ WriteByte(channel, wepframe);
+ WriteFloat(channel, attackrate);
WriteByte(channel, weaponslot(weaponentity.weaponentity_fld));
WriteByte(channel, restartanim);
WriteByte(channel, weaponentity.state);
});
}
default:
- {
- LOG_INFOF("Incorrect parameters for ^2%s^7", "weapon_find");
- }
+ LOG_INFOF("Incorrect parameters for ^2%s^7", argv(0));
case CMD_REQUEST_USAGE:
{
- LOG_INFO("Usage:^3 cl_cmd weapon_find weapon");
- LOG_INFO(" Where 'weapon' is the lowercase weapon name, 'all' or 'unowned'.");
+ LOG_HELP("Usage:^3 cl_cmd weapon_find weapon");
+ LOG_HELP(" Where 'weapon' is the lowercase weapon name, 'all' or 'unowned'.");
return;
}
}
}
#endif
+#ifdef SVQC
+void W_MuzzleFlash_Model_AttachToShotorg(entity actor, .entity weaponentity, entity flash, vector offset)
+{
+ flash.owner = actor;
+ flash.angles_z = random() * 360;
+
+ entity view = actor.(weaponentity);
+ entity exterior = actor.exteriorweaponentity;
+
+ if (view.oldorigin.x > 0)
+ {
+ setattachment(flash, exterior, "");
+ setorigin(flash, view.oldorigin + offset);
+ }
+ else
+ {
+ if (gettagindex(exterior, "shot")) setattachment(flash, exterior, "shot");
+ else setattachment(flash, exterior, "tag_shot");
+ setorigin(flash, offset);
+ }
+}
+#elif defined(CSQC)
+void W_MuzzleFlash_Model_AttachToShotorg(entity wepent, entity flash, vector offset)
+{
+ flash.owner = wepent;
+ flash.angles_z = random() * 360;
+
+ if (gettagindex(wepent, "shot")) setattachment(flash, wepent, "shot");
+ else setattachment(flash, wepent, "tag_shot");
+ setorigin(flash, offset);
+}
+#endif
+
+void W_MuzzleFlash_Model_Think(entity this)
+{
+ this.frame += 2;
+ this.scale *= 0.5;
+ this.alpha -= 0.25;
+ this.nextthink = time + 0.05;
+
+ if(this.alpha <= 0)
+ {
+ setthink(this, SUB_Remove);
+ this.nextthink = time;
+ this.realowner.muzzle_flash = NULL;
+ return;
+ }
+}
+
+void W_MuzzleFlash_Model(entity wepent, entity muzzlemodel)
+{
+ if(wepent.muzzle_flash == NULL)
+ wepent.muzzle_flash = spawn();
+
+ entity flash = wepent.muzzle_flash;
+ setmodel(flash, muzzlemodel); // precision set below
+
+ flash.scale = 0.75;
+ setthink(flash, W_MuzzleFlash_Model_Think);
+ flash.nextthink = time + 0.02;
+ flash.frame = 2;
+ flash.alpha = 0.75;
+ flash.angles_z = random() * 180;
+ flash.effects = EF_ADDITIVE | EF_FULLBRIGHT;
+ flash.owner = flash.realowner = wepent;
+
+#ifdef CSQC
+ flash.drawmask = MASK_NORMAL;
+#endif
+}
+
+REGISTER_NET_TEMP(w_muzzleflash)
+
+#ifdef SVQC
+void W_MuzzleFlash(Weapon thiswep, entity actor, .entity weaponentity, vector shotorg, vector shotdir)
+{
+ // don't show an exterior muzzle effect for the off-hand
+ if(weaponslot(weaponentity) == 0)
+ {
+ Send_Effect_Except(thiswep.m_muzzleeffect, shotorg, shotdir * 1000, 1, actor);
+
+ if(thiswep.m_muzzlemodel != MDL_Null)
+ {
+ W_MuzzleFlash_Model(actor.exteriorweaponentity, thiswep.m_muzzlemodel);
+ W_MuzzleFlash_Model_AttachToShotorg(actor, weaponentity, actor.exteriorweaponentity.muzzle_flash, '5 0 0');
+ }
+ }
+
+ FOREACH_CLIENT(it == actor || (IS_SPEC(it) && it.enemy == actor),
+ {
+ if(!IS_REAL_CLIENT(it))
+ continue;
+ int channel = MSG_ONE;
+ msg_entity = it;
+ WriteHeader(channel, w_muzzleflash);
+ WriteByte(channel, thiswep.m_id);
+ WriteByte(channel, weaponslot(weaponentity));
+ WriteVector(channel, shotorg);
+ });
+}
+#elif defined(CSQC)
+NET_HANDLE(w_muzzleflash, bool isNew)
+{
+ return = true;
+ int weapon_id = ReadByte();
+ int slot = ReadByte();
+ vector sv_shotorg = ReadVector();
+
+ Weapon thiswep = REGISTRY_GET(Weapons, weapon_id);
+ vector viewangles = getpropertyvec(VF_CL_VIEWANGLES);
+ vector forward, right, up;
+ MAKE_VECTORS(viewangles, forward, right, up);
+
+ if(autocvar_chase_active)
+ {
+ // in third person mode, show the muzzle flash from the server side weapon position
+ // we don't have a view model to reference in this case
+ pointparticles(thiswep.m_muzzleeffect, sv_shotorg, forward * 1000, 1);
+ return;
+ }
+ if(!autocvar_r_drawviewmodel) return;
+
+ entity wepent = viewmodels[slot];
+ // get the local player entity to calculate shot origin
+ entity rlplayer = CSQCModel_server2csqc(player_localentnum - 1);
+ if(!rlplayer)
+ rlplayer = csqcplayer; // fall back to the global
+
+ vector md = wepent.movedir_aligned;
+ vector vecs = ((md.x > 0) ? md : '0 0 0');
+ vector dv = forward * vecs.x + right * -vecs.y + up * vecs.z;
+ vector org = rlplayer.origin + rlplayer.view_ofs + dv;
+
+ pointparticles(thiswep.m_muzzleeffect, org, forward * 1000, 1);
+
+ if(thiswep.m_muzzlemodel != MDL_Null)
+ {
+ W_MuzzleFlash_Model(wepent, thiswep.m_muzzlemodel);
+ W_MuzzleFlash_Model_AttachToShotorg(wepent, wepent.muzzle_flash, '5 0 0');
+ }
+}
+#endif
+
#endif
projects / xonotic / xonotic-data.pk3dir.git / blobdiff