scoreboard.patch

Index: src/fpsgame/client.cpp
===================================================================
--- src/fpsgame/client.cpp	(revision 6490)
+++ src/fpsgame/client.cpp	(working copy)
@@ -1,4 +1,5 @@
 #include "game.h"
+#include "weaponstats.h"

 namespace game
 {
@@ -1221,6 +1222,7 @@
             if(d==player1) getint(p);
             else d->state = getint(p);
             d->frags = getint(p);
+            if(-(d->frags)>d->suicides) d->suicides = -(d->frags); // best effort suicides initialization when joining a running game
             d->flags = getint(p);
             d->deaths = getint(p);
             if(d==player1) getint(p);
@@ -1499,6 +1501,7 @@
                 s->lastaction = lastmillis;
                 s->lastattackgun = s->gunselect;
                 shoteffects(s->gunselect, from, to, s, false, id, prevaction);
+                recordpotentialdamage(s);
                 break;
             }

Index: src/fpsgame/fps.cpp
===================================================================
--- src/fpsgame/fps.cpp	(revision 6490)
+++ src/fpsgame/fps.cpp	(working copy)
@@ -1,4 +1,5 @@
 #include "game.h"
+#include "weaponstats.h"

 namespace game
 {
@@ -397,6 +398,8 @@
     {
         if((d->state!=CS_ALIVE && d->state != CS_LAGGED && d->state != CS_SPAWNING) || intermission) return;

+        recorddamage(actor, d, damage);
+
         if(local) damage = d->dodamage(damage);
         else if(actor==player1) return;

@@ -483,7 +486,10 @@
         if(actor->type==ENT_AI)
             conoutf(contype, "\f2%s got killed by %s!", dname, aname);
         else if(d==actor || actor->type==ENT_INANIMATE)
+        {
+            d->suicides++;
             conoutf(contype, "\f2%s suicided%s", dname, d==player1 ? "!" : "");
+        }
         else if(isteam(d->team, actor->team))
         {
             contype |= CON_TEAMKILL;
@@ -528,12 +534,11 @@
         }
     }

-    ICOMMAND(getfrags, "", (), intret(player1->frags));
-    ICOMMAND(getflags, "", (), intret(player1->flags));
-    ICOMMAND(getdeaths, "", (), intret(player1->deaths));
-    ICOMMAND(getaccuracy, "", (), intret((player1->totaldamage*100)/max(player1->totalshots, 1)));
-    ICOMMAND(gettotaldamage, "", (), intret(player1->totaldamage));
-    ICOMMAND(gettotalshots, "", (), intret(player1->totalshots));
+    PLAYER_VARGS_ICOMMAND(getfrags, intret(p->frags));
+    PLAYER_VARGS_ICOMMAND(getflags, intret(p->flags));
+    PLAYER_VARGS_ICOMMAND(getdeaths, intret(p->deaths));
+    PLAYER_VARGS_ICOMMAND(gettotaldamage, intret(playerdamage(p, DMG_DEALT)));
+    PLAYER_VARGS_ICOMMAND(gettotalshots, intret(playerdamage(p, DMG_POTENTIAL)));

     vector<fpsent *> clients;

@@ -618,9 +623,11 @@
             d->deaths = 0;
             d->totaldamage = 0;
             d->totalshots = 0;
+            d->suicides = 0;
             d->maxhealth = 100;
             d->lifesequence = -1;
             d->respawned = d->suicided = -2;
+            d->stats.reset();
         }

         setclientmode();
Index: src/fpsgame/game.h
===================================================================
--- src/fpsgame/game.h	(revision 6490)
+++ src/fpsgame/game.h	(working copy)
@@ -535,6 +535,8 @@
     }
 };

+#include "weaponstats_type.h"
+
 struct fpsent : dynent, fpsstate
 {
     int weight;                         // affects the effectiveness of hitpush
@@ -549,6 +551,8 @@
     int lastpickup, lastpickupmillis, lastbase, lastrepammo, flagpickup, tokens;
     vec lastcollect;
     int frags, flags, deaths, totaldamage, totalshots;
+    int suicides;
+    weaponstats stats;
     editinfo *edit;
     float deltayaw, deltapitch, deltaroll, newyaw, newpitch, newroll;
     int smoothmillis;
@@ -560,7 +564,7 @@

     vec muzzle;

-    fpsent() : weight(100), clientnum(-1), privilege(PRIV_NONE), lastupdate(0), plag(0), ping(0), lifesequence(0), respawned(-1), suicided(-1), lastpain(0), attacksound(-1), attackchan(-1), idlesound(-1), idlechan(-1), frags(0), flags(0), deaths(0), totaldamage(0), totalshots(0), edit(NULL), smoothmillis(-1), playermodel(-1), ai(NULL), ownernum(-1), p1xbratenversion(0, 0, 0), muzzle(-1, -1, -1)
+    fpsent() : weight(100), clientnum(-1), privilege(PRIV_NONE), lastupdate(0), plag(0), ping(0), lifesequence(0), respawned(-1), suicided(-1), lastpain(0), attacksound(-1), attackchan(-1), idlesound(-1), idlechan(-1), frags(0), flags(0), deaths(0), totaldamage(0), totalshots(0), suicides(0), edit(NULL), smoothmillis(-1), playermodel(-1), ai(NULL), ownernum(-1), p1xbratenversion(0, 0, 0), muzzle(-1, -1, -1)
     {
         name[0] = team[0] = info[0] = 0;
         respawn();
diff --git src/fpsgame/scoreboard.cpp src/fpsgame/scoreboard.cpp
index 1457f19..0c93387 100644
--- src/fpsgame/scoreboard.cpp
+++ src/fpsgame/scoreboard.cpp
@@ -469,6 +469,9 @@ namespace game
             g.space(.25f);
         }

+    extern int usep1xbratenmenus;
+    namespace mod { extern void renderscoreboard(g3d_gui &g, bool firstpass); }
+
     struct scoreboardgui : g3d_callback
     {
         bool showing;
@@ -490,7 +493,8 @@ namespace game
         void gui(g3d_gui &g, bool firstpass)
         {
             g.start(menustart, 0.03f, NULL, false);
-            renderscoreboard(g, firstpass);
+            if(usep1xbratenmenus) mod::renderscoreboard(g, firstpass);
+            else renderscoreboard(g, firstpass);
             g.end();
         }

Index: src/fpsgame/weapon.cpp
===================================================================
--- src/fpsgame/weapon.cpp	(revision 6490)
+++ src/fpsgame/weapon.cpp	(working copy)
@@ -1,5 +1,6 @@
 // weapon.cpp: all shooting and effects code, projectile management
 #include "game.h"
+#include "weaponstats.h"

 namespace game
 {
@@ -17,7 +18,7 @@
     VARP(maxdebris, 10, 25, 1000);
     VARP(maxbarreldebris, 5, 10, 1000);

-    ICOMMAND(getweapon, "", (), intret(player1->gunselect));
+    PLAYER_VARGS_ICOMMAND(getweapon, intret(p->gunselect));

     void gunselect(int gun, fpsent *d)
     {
@@ -825,6 +826,7 @@
 		d->gunwait = guns[d->gunselect].attackdelay;
 		if(d->gunselect == GUN_PISTOL && d->ai) d->gunwait += int(d->gunwait*(((101-d->skill)+rnd(111-d->skill))/100.f));
         d->totalshots += guns[d->gunselect].damage*(d->quadmillis ? 4 : 1)*guns[d->gunselect].rays;
+        recordpotentialdamage(d);
     }

     void adddynlights()
diff --git src/p1xbraten/scoreboard.cpp src/p1xbraten/scoreboard.cpp
new file mode 100644
index 0000000..8da7701
--- /dev/null
+++ src/p1xbraten/scoreboard.cpp
@@ -0,0 +1,324 @@
+#include "game.h"
+#include "weaponstats.h"
+
+namespace game
+{
+    extern int showservinfo, gamespeed, highlightscore, hidefrags, showdeaths, showping, showpj, showclientnum, showspectators, showspectatorping;
+
+namespace mod
+{
+    MOD(VARP, showsuicides, 0, 0, 1);
+    MOD(VARP, showflags, 0, 0, 1);
+    MOD(VARP, showkpd, 0, 0, 1);
+    MOD(VARP, showaccuracy, 0, 0, 1);
+    MOD(VARP, showdamage, 0, 0, 2);
+    MOD(VARP, showdamagereceived, 0, 0, 1);
+
+    int statuscolor(fpsent *d, int color)
+    {
+        if(d->privilege) color = d->privilege>=PRIV_ADMIN ? COL_ADMIN : (d->privilege>=PRIV_AUTH ? COL_AUTH : COL_MASTER);
+        if(d->state==CS_DEAD) color = (color>>1)&0x7F7F7F;
+        return color;
+    }
+
+    void renderscoreboard(g3d_gui &g, bool firstpass)
+    {
+        g.space(.25f);
+
+        const ENetAddress *address = connectedpeer();
+        if(showservinfo && address)
+        {
+            string hostname;
+            if(enet_address_get_host_ip(address, hostname, sizeof(hostname)) >= 0)
+            {
+                if(servdesc[0]) g.titlef("%.25s", COL_WHITE, NULL, servdesc);
+                else g.titlef("%s:%d", COL_WHITE, NULL, hostname, address->port);
+            }
+        }
+
+        g.pushlist();
+        g.spring();
+        g.text(server::modename(gamemode), COL_WHITE);
+        g.space(3);
+        const char *mname = getclientmap();
+        g.text(mname[0] ? mname : "[new map]", COL_WHITE);
+        if(m_timed && mname[0] && (maplimit >= 0 || intermission))
+        {
+            g.space(3);
+            if(intermission) g.text("intermission", COL_WHITE);
+            else
+            {
+                int secs = max(maplimit-lastmillis+999, 0)/1000, mins = secs/60;
+                secs %= 60;
+                g.pushlist();
+                g.strut(mins >= 10 ? 4.5f : 3.5f);
+                g.textf("%d:%02d", COL_WHITE, NULL, mins, secs);
+                g.poplist();
+            }
+        }
+        if(gamespeed != 100) { g.space(3); g.textf("%d.%02dx", COL_GRAY, NULL, gamespeed/100, gamespeed%100); }
+        if(ispaused()) { g.space(3); g.text("paused", COL_GRAY); }
+        g.spring();
+        g.poplist();
+
+        g.space(.75f);
+
+        int numgroups = groupplayers();
+        loopk(numgroups)
+        {
+            if((k%2)==0) g.pushlist(); // horizontal
+
+            scoregroup &sg = *groups[k];
+            int teamcolor = sg.team && m_teammode ? (isteam(player1->team, sg.team) ? COL_BLUE : COL_RED) : 0;
+
+            g.pushlist(); // vertical
+            g.pushlist(); // horizontal
+
+            #define loopscoregroup(o, b) \
+                loopv(sg.players) \
+                { \
+                    fpsent *o = sg.players[i]; \
+                    b; \
+                }
+
+            #define rightjustified(b) \
+                { \
+                    g.pushlist(); \
+                    g.spring(); \
+                    b; \
+                    g.poplist(); \
+                }
+
+            #define fgcolor (o==hudplayer() && highlightscore && (multiplayer(false) || demoplayback || players.length() > 1) ? COL_YELLOW : COL_WHITE)
+
+            if(sg.team && m_teammode)
+            {
+                g.pushlist(); // vertical
+                if(sg.score>=10000) g.textf("%s: WIN", teamcolor, NULL, sg.team);
+                else g.textf("%s: %d", teamcolor, NULL, sg.team, sg.score);
+                g.pushlist(); // horizontal
+            }
+
+            g.pushlist();
+            g.text("name", COL_GRAY);
+            loopscoregroup(o, g.text(colorname(o), statuscolor(o, fgcolor)););
+            g.poplist();
+
+            if(m_ctf && showflags)
+            {
+                g.space(2);
+                g.pushlist();
+                rightjustified(g.text("flags", COL_GRAY))
+                loopscoregroup(o, rightjustified(g.textf("%d", fgcolor, NULL, o->flags)));
+                g.poplist();
+            }
+
+            if(!cmode || !cmode->hidefrags() || !hidefrags)
+            {
+                g.space(2);
+                g.pushlist();
+                rightjustified(g.text("frags", COL_GRAY))
+                loopscoregroup(o, rightjustified(g.textf("%d", fgcolor, NULL, o->frags)));
+                g.poplist();
+            }
+
+            if(showdeaths)
+            {
+                g.space(2);
+                g.pushlist();
+                rightjustified(g.text("deaths", COL_GRAY))
+                loopscoregroup(o, rightjustified(g.textf("%d", fgcolor, NULL, o->deaths)));
+                g.poplist();
+            }
+
+            if(showsuicides)
+            {
+                g.space(2);
+                g.pushlist();
+                rightjustified(g.text("suis", COL_GRAY))
+                loopscoregroup(o, rightjustified(g.textf("%d", fgcolor, NULL, o->suicides)));
+                g.poplist();
+            }
+
+            if(showkpd)
+            {
+                g.space(2);
+                g.pushlist();
+                g.strut(3);
+                rightjustified(g.text("kpd", COL_GRAY))
+                loopscoregroup(o, rightjustified(g.textf("%.1f", fgcolor, NULL, (float)o->frags/max(1, o->deaths))));
+                g.poplist();
+            }
+
+            if(showaccuracy)
+            {
+                g.space(2);
+                g.pushlist();
+                g.strut(4);
+                rightjustified(g.text("acc", COL_GRAY))
+                loopscoregroup(o, rightjustified(g.textf("%.0f%%", fgcolor, NULL, playeraccuracy(o))));
+                g.poplist();
+            }
+
+            if(!m_insta)
+            {
+                if(showdamage)
+                {
+                    g.space(2);
+                    g.pushlist();
+                    g.strut(4);
+                    rightjustified(g.text("dmg", COL_GRAY))
+                    loopscoregroup(o, {
+                        float dmg = (float) showdamage == 1 ? playerdamage(o, DMG_DEALT) : playernetdamage(o);
+                        const char *fmt = "%.0f";
+                        if(fabs(dmg) > 1000.0f) { fmt = "%.1fk"; dmg = dmg/1000.0f; }
+                        rightjustified(g.textf(fmt, fgcolor, NULL, dmg));
+                    });
+                    g.poplist();
+                }
+
+                if(showdamagereceived)
+                {
+                    g.space(2);
+                    g.pushlist();
+                    g.strut(4);
+                    rightjustified(g.text("dr", COL_GRAY))
+                    loopscoregroup(o, {
+                        float dmg = (float) playerdamage(o, DMG_RECEIVED);
+                        const char *fmt = "%.0f";
+                        if(fabs(dmg) > 1000.0f) { fmt = "%.1fk"; dmg = dmg/1000.0f; }
+                        rightjustified(g.textf(fmt, fgcolor, NULL, dmg));
+                    });
+                    g.poplist();
+                }
+            }
+
+            if(multiplayer(false) || demoplayback)
+            {
+                if(showping)
+                {
+                    g.space(2);
+                    g.pushlist();
+                    rightjustified(g.text("ping", COL_GRAY))
+                    loopscoregroup(o,
+                    {
+                        fpsent *p = o->ownernum >= 0 ? getclient(o->ownernum) : o;
+                        if(!p) p = o;
+                        if(!showpj && p->state==CS_LAGGED) rightjustified(g.text("LAG", fgcolor))
+                        else rightjustified(g.textf("%d", fgcolor, NULL, p->ping))
+                    });
+                    g.poplist();
+                }
+
+                if(showpj)
+                {
+                    g.space(2);
+                    g.pushlist();
+                    g.strut(2);
+                    rightjustified(g.text("pj", COL_GRAY))
+                    loopscoregroup(o,
+                    {
+                        fpsent *p = o->ownernum >= 0 ? getclient(o->ownernum) : o;
+                        if(!p) p = o;
+                        if(p==player1) rightjustified(g.text("0", fgcolor))
+                        else if(p->state==CS_LAGGED) rightjustified(g.text("LAG", fgcolor))
+                        else rightjustified(g.textf("%d", fgcolor, NULL, abs(33-p->plag)))
+                    });
+                    g.poplist();
+                }
+            }
+
+            if(showclientnum || player1->privilege>=PRIV_MASTER)
+            {
+                g.space(2);
+                g.pushlist();
+                rightjustified(g.text("cn", COL_GRAY))
+                loopscoregroup(o, rightjustified(g.textf("%d", fgcolor, NULL, o->clientnum)));
+                g.poplist();
+            }
+
+            if(sg.team && m_teammode)
+            {
+                g.poplist(); // horizontal
+                g.poplist(); // vertical
+            }
+
+            g.poplist(); // horizontal
+            g.poplist(); // vertical
+
+            if(k+1<numgroups && (k+1)%2) g.space(3);
+            else
+            {
+                g.poplist(); // horizontal
+                if(k+1<numgroups) g.space(.75f);
+            }
+        }
+
+        if(showspectators && spectators.length())
+        {
+            #define loopspectators(o, b) \
+                loopv(spectators) \
+                { \
+                    fpsent *o = spectators[i]; \
+                    b; \
+                }
+
+            g.space(.75f);
+
+            if(showclientnum || showspectatorping || player1->privilege>=PRIV_MASTER)
+            {
+                g.pushlist();
+
+                g.pushlist();
+                g.text("spectator", COL_GRAY);
+                loopspectators(o, g.text(colorname(o), statuscolor(o, fgcolor)));
+                g.poplist();
+
+                if((multiplayer(false) || demoplayback) && showspectatorping)
+                {
+                    g.space(2);
+                    g.pushlist();
+                    rightjustified(g.text("ping", COL_GRAY))
+                    loopspectators(o,
+                    {
+                        fpsent *p = o->ownernum >= 0 ? getclient(o->ownernum) : o;
+                        if(!p) p = o;
+                        if(p->state==CS_LAGGED) rightjustified(g.text("LAG", fgcolor))
+                        else rightjustified(g.textf("%d", fgcolor, NULL, p->ping))
+                    });
+                    g.poplist();
+                }
+
+                if(showclientnum || player1->privilege>=PRIV_MASTER)
+                {
+                    g.space(2);
+                    g.pushlist();
+                    rightjustified(g.text("cn", COL_GRAY))
+                    loopspectators(o, rightjustified(g.textf("%d", fgcolor, NULL, o->clientnum)));
+                    g.poplist();
+                }
+
+                g.poplist();
+            }
+            else
+            {
+                g.textf("%d spectator%s", COL_GRAY, NULL, spectators.length(), spectators.length()!=1 ? "s" : "");
+                loopspectators(o,
+                {
+                    if((i%3)==0)
+                    {
+                        g.pushlist();
+                        g.text("", fgcolor, 0);
+                    }
+                    g.text(colorname(o), statuscolor(o, fgcolor));
+                    if(i+1<spectators.length() && (i+1)%3) g.space(1);
+                    else g.poplist();
+                });
+            }
+        }
+
+        g.space(.25f);
+        }
+
+    }
+}
Index: src/p1xbraten/weaponstats.cpp
===================================================================
--- src/p1xbraten/weaponstats.cpp	(nonexistent)
+++ src/p1xbraten/weaponstats.cpp	(working copy)
@@ -0,0 +1,60 @@
+#include "game.h"
+#include "weaponstats.h"
+
+namespace game {
+    void recordpotentialdamage(fpsent *shooter)
+    {
+        if(!shooter) return;
+        int gun = shooter->gunselect;
+        int potentialdamage = guns[gun].damage * (shooter->quadmillis ? 4 : 1 ) * guns[gun].rays;
+        shooter->stats.add(DMG_POTENTIAL, gun, potentialdamage);
+    }
+
+    bool shouldcountdamage(fpsent *attacker, fpsent *target)
+    {
+        return (attacker != target) && !isteam(attacker->team, target->team);
+    }
+
+    void recorddamage(fpsent *attacker, fpsent *target, int damage)
+    {
+        if((attacker == target) || isteam(attacker->team, target->team)) return;
+        int gun = attacker->gunselect;
+        // try to fix gun used to deal the damage
+        if((gun != GUN_SG && damage != guns[gun].damage * (attacker->quadmillis ? 4 : 1)) || (gun == GUN_SG && damage%(attacker->quadmillis ? 40 : 10) != 0))
+        {
+            gun = attacker->stats.lastprojectile;
+        }
+        attacker->stats.add(DMG_DEALT, gun, damage);
+        target->stats.add(DMG_RECEIVED, gun, damage);
+    }
+
+    int playerdamage(fpsent *p, int typ, int gun)
+    {
+        if(!p) p = hudplayer();
+        return p->stats.get(typ, gun);
+    }
+    DAMAGECOMMAND(getdamagepotential, intret(playerdamage(p, DMG_POTENTIAL, gun)))
+    DAMAGECOMMAND(getdamagedealt, intret(playerdamage(p, DMG_DEALT, gun)))
+    DAMAGECOMMAND(getdamagereceived, intret(playerdamage(p, DMG_RECEIVED, gun)))
+
+    int playerdamagewasted(fpsent *p, int gun)
+    {
+        if(!p) p = hudplayer();
+        return p->stats.wasted(gun);
+    }
+    DAMAGECOMMAND(getdamagewasted, intret(playerdamagewasted(p, gun)))
+
+    int playernetdamage(fpsent *p, int gun)
+    {
+        if(!p) p = hudplayer();
+        return p->stats.net(gun);
+    }
+    DAMAGECOMMAND(getnetdamage, intret(playernetdamage(p, gun)))
+
+    float playeraccuracy(fpsent *p, int gun)
+    {
+        if(!p) p = hudplayer();
+        return p->stats.accuracy(gun);
+    }
+    DAMAGECOMMAND(getaccuracy, floatret(playeraccuracy(p, gun)))
+}
Index: src/p1xbraten/weaponstats.h
===================================================================
--- src/p1xbraten/weaponstats.h	(nonexistent)
+++ src/p1xbraten/weaponstats.h	(working copy)
@@ -0,0 +1,27 @@
+#ifndef __WEAPONSTATS_H__
+#define __WEAPONSTATS_H__
+
+#include "game.h"
+
+namespace game {
+    extern void recordpotentialdamage(fpsent *shooter);
+    extern bool shouldcountdamage(fpsent *attacker, fpsent *target);
+    extern void recorddamage(fpsent *attacker, fpsent *target, int damage);
+    extern int playerdamage(fpsent *p, int typ, int gun = -1);
+    extern int playerdamagewasted(fpsent *p, int gun = -1);
+    extern int playernetdamage(fpsent *p, int gun = -1);
+    extern float playeraccuracy(fpsent *p, int gun = -1);
+
+    #define PLAYER_VARGS_ICOMMAND(name,b) ICOMMAND(name, "V", (tagval *args, int numargs), { \
+        fpsent *p = (numargs > 0 && args[0].getint() != -1) ? getclient(args[0].getint()) : hudplayer(); \
+        if(!p) { conoutf("\f6no player with CN %d", args[0].getint()); return; } \
+        b; \
+    })
+
+    #define DAMAGECOMMAND(name,b) PLAYER_VARGS_ICOMMAND(name, { \
+        int gun = numargs > 1 ? args[1].getint() : -1; \
+        b;\
+    })
+}
+
+#endif
Index: src/p1xbraten/weaponstats_type.h
===================================================================
--- src/p1xbraten/weaponstats_type.h	(nonexistent)
+++ src/p1xbraten/weaponstats_type.h	(working copy)
@@ -0,0 +1,59 @@
+#ifndef __WEAPONSTATS_TYPE_H__
+#define __WEAPONSTATS_TYPE_H__
+
+#define NUM_MP_GUNS (GUN_PISTOL+1 - GUN_FIST)
+#define guninrange(i) (i >= 0 && i < NUM_MP_GUNS)
+
+enum { DMG_POTENTIAL = 0, DMG_DEALT, DMG_RECEIVED, NUM_DMG_TYPES };
+#define dmgtypeinrange(i) (i >= 0 && i < NUM_DMG_TYPES)
+
+struct weaponstats {
+    int lastprojectile;
+
+    int damage[NUM_DMG_TYPES][NUM_MP_GUNS];
+
+    weaponstats()
+    {
+        reset();
+    }
+
+    void reset()
+    {
+        lastprojectile = -1;
+        loopi(NUM_DMG_TYPES) loopj(NUM_MP_GUNS) damage[i][j] = 0;
+    }
+
+    void add(int typ, int gun, int dmg)
+    {
+        if(!dmgtypeinrange(typ) || !guninrange(gun)) return;
+        damage[typ][gun] += dmg;
+        if(typ == DMG_POTENTIAL && (gun == GUN_RL || gun == GUN_GL)) lastprojectile = gun;
+    }
+
+    int get(int typ, int gun)
+    {
+        if(!dmgtypeinrange(typ)) return 0;
+        if(guninrange(gun)) return damage[typ][gun];
+        int total = 0;
+        loopi(NUM_MP_GUNS) total += damage[typ][i];
+        return total;
+    }
+
+    int wasted(int gun)
+    {
+        return get(DMG_POTENTIAL, gun) - get(DMG_DEALT, gun);
+    }
+
+    int net(int gun)
+    {
+        return get(DMG_DEALT, gun) - get(DMG_RECEIVED, gun);
+    }
+
+    float accuracy(int gun)
+    {
+        float nonzerototal = max(1.0f, (float)get(DMG_POTENTIAL, gun));
+        return min(100.0f, (float)get(DMG_DEALT, gun) / nonzerototal * 100.0f);
+    }
+};
+
+#endif