src/hcode/btech/p.btechstats.h File Reference

#include "config.h"

Include dependency graph for p.btechstats.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
char *	silly_get_uptime_to_string (int i)
void	list_charvaluestuff (dbref player, int flag)
int	char_getvaluecode (char *name)
int	char_rollsaving (void)
int	char_rollunskilled (void)
int	char_rollskilled (void)
int	char_rolld6 (int num)
int	char_getvalue (dbref player, char *name)
void	char_setvalue (dbref player, char *name, int value)
int	char_getskilltargetbycode (dbref player, int code, int modifier)
int	char_getskilltarget (dbref player, char *name, int modifier)
int	char_getxpbycode (dbref player, int code)
int	char_gainxpbycode (dbref player, int code, int amount)
int	char_gainxp (dbref player, char *skill, int amount)
int	char_getskillsuccess (dbref player, char *name, int modifier, int loud)
int	char_getskillmargsucc (dbref player, char *name, int modifier)
int	char_getopposedskill (dbref first, char *skill1, dbref second, char *skill2)
int	char_getattrsave (dbref player, char *name)
int	char_getattrsavesucc (dbref player, char *name)
void	zap_unneccessary_stats (void)
void	init_btechstats (void)
void	do_charstatus (dbref player, dbref cause, int key, char *arg1)
void	do_charclear (dbref player, dbref cause, int key, char *arg1)
dbref	char_lookupplayer (dbref player, dbref cause, int key, char *arg1)
void	initialize_pc (dbref player, MECH *mech)
void	fix_pilotdamage (MECH *mech, dbref player)
int	mw_ic_bth (MECH *mech)
int	handlemwconc (MECH *mech, int initial)
void	headhitmwdamage (MECH *mech, MECH *attacker, int dam)
void	mwlethaldam (MECH *mech, MECH *attacker, int dam)
void	lower_xp (dbref player, int promillage)
void	AccumulateTechXP (dbref pilot, MECH *mech, int reason)
void	AccumulateTechWeaponsXP (dbref pilot, MECH *mech, int reason)
void	AccumulateCommXP (dbref pilot, MECH *mech)
void	AccumulatePilXP (dbref pilot, MECH *mech, int reason, int addanyway)
void	AccumulateSpotXP (dbref pilot, MECH *attacker, MECH *wounded)
int	MadePerceptionRoll (MECH *mech, int modifier)
void	AccumulateArtyXP (dbref pilot, MECH *attacker, MECH *wounded)
void	AccumulateComputerXP (dbref pilot, MECH *mech, int reason)
int	HasBoolAdvantage (dbref player, const char *name)
void	AccumulateGunXP (dbref pilot, MECH *attacker, MECH *wounded, int numOccurences, float multiplier, int weapindx, int bth)
void	AccumulateGunXPold (dbref pilot, MECH *attacker, MECH *wounded, int numOccurences, float multiplier, int weapindx, int bth)
void	fun_btgetcharvalue (char *buff, char **bufc, dbref player, dbref cause, char *fargs[], int nfargs, char *cargs[], int ncargs)
void	fun_btsetcharvalue (char *buff, char **bufc, dbref player, dbref cause, char *fargs[], int nfargs, char *cargs[], int ncargs)
void	fun_btcharlist (char *buff, char **bufc, dbref player, dbref cause, char *fargs[], int nfargs, char *cargs[], int ncargs)
void	debug_xptop (dbref player, void *data, char *buffer)
void	debug_setxplevel (dbref player, void *data, char *buffer)
int	btthreshold_func (char *skillname)
chargen_struct *	retrieve_chargen_struct (dbref player)
int	lowest_bit (int num)
int	recursive_add (int lev)
int	can_proceed (dbref player, struct chargen_struct *st)
void	cm_a_add (dbref player, void *data, char *buffer)
void	cm_a_minus (dbref player, void *data, char *buffer)
void	cm_a_toggle (dbref player, void *data, char *buffer)
void	cm_a_set (dbref player, void *data, char *buffer)
void	cm_b_add (dbref player, void *data, char *buffer)
void	cm_b_minus (dbref player, void *data, char *buffer)
void	cm_b_toggle (dbref player, void *data, char *buffer)
void	cm_b_set (dbref player, void *data, char *buffer)
void	cm_c_add (dbref player, void *data, char *buffer)
void	cm_c_minus (dbref player, void *data, char *buffer)
void	cm_c_toggle (dbref player, void *data, char *buffer)
void	cm_c_set (dbref player, void *data, char *buffer)
void	cm_d_add (dbref player, void *data, char *buffer)
void	cm_d_minus (dbref player, void *data, char *buffer)
void	cm_d_toggle (dbref player, void *data, char *buffer)
void	cm_d_set (dbref player, void *data, char *buffer)
void	cm_e_add (dbref player, void *data, char *buffer)
void	cm_e_minus (dbref player, void *data, char *buffer)
void	cm_e_toggle (dbref player, void *data, char *buffer)
void	cm_e_set (dbref player, void *data, char *buffer)
void	cm_f_add (dbref player, void *data, char *buffer)
void	cm_f_minus (dbref player, void *data, char *buffer)
void	cm_f_toggle (dbref player, void *data, char *buffer)
void	cm_f_set (dbref player, void *data, char *buffer)
void	cm_g_add (dbref player, void *data, char *buffer)
void	cm_g_minus (dbref player, void *data, char *buffer)
void	cm_g_toggle (dbref player, void *data, char *buffer)
void	cm_g_set (dbref player, void *data, char *buffer)
void	cm_h_add (dbref player, void *data, char *buffer)
void	cm_h_minus (dbref player, void *data, char *buffer)
void	cm_h_toggle (dbref player, void *data, char *buffer)
void	cm_h_set (dbref player, void *data, char *buffer)
void	cm_i_add (dbref player, void *data, char *buffer)
void	cm_i_minus (dbref player, void *data, char *buffer)
void	cm_i_toggle (dbref player, void *data, char *buffer)
void	cm_i_set (dbref player, void *data, char *buffer)
void	cm_j_add (dbref player, void *data, char *buffer)
void	cm_j_minus (dbref player, void *data, char *buffer)
void	cm_j_toggle (dbref player, void *data, char *buffer)
void	cm_j_set (dbref player, void *data, char *buffer)
void	cm_k_add (dbref player, void *data, char *buffer)
void	cm_k_minus (dbref player, void *data, char *buffer)
void	cm_k_toggle (dbref player, void *data, char *buffer)
void	cm_k_set (dbref player, void *data, char *buffer)
void	cm_l_add (dbref player, void *data, char *buffer)
void	cm_l_minus (dbref player, void *data, char *buffer)
void	cm_l_toggle (dbref player, void *data, char *buffer)
void	cm_l_set (dbref player, void *data, char *buffer)
void	cm_m_add (dbref player, void *data, char *buffer)
void	cm_m_minus (dbref player, void *data, char *buffer)
void	cm_m_toggle (dbref player, void *data, char *buffer)
void	cm_m_set (dbref player, void *data, char *buffer)
void	cm_n_add (dbref player, void *data, char *buffer)
void	cm_n_minus (dbref player, void *data, char *buffer)
void	cm_n_toggle (dbref player, void *data, char *buffer)
void	cm_n_set (dbref player, void *data, char *buffer)
void	cm_o_add (dbref player, void *data, char *buffer)
void	cm_o_minus (dbref player, void *data, char *buffer)
void	cm_o_toggle (dbref player, void *data, char *buffer)
void	cm_o_set (dbref player, void *data, char *buffer)
void	cm_p_add (dbref player, void *data, char *buffer)
void	cm_p_minus (dbref player, void *data, char *buffer)
void	cm_p_toggle (dbref player, void *data, char *buffer)
void	cm_p_set (dbref player, void *data, char *buffer)
void	cm_q_add (dbref player, void *data, char *buffer)
void	cm_q_minus (dbref player, void *data, char *buffer)
void	cm_q_toggle (dbref player, void *data, char *buffer)
void	cm_q_set (dbref player, void *data, char *buffer)
void	cm_r_add (dbref player, void *data, char *buffer)
void	cm_r_minus (dbref player, void *data, char *buffer)
void	cm_r_toggle (dbref player, void *data, char *buffer)
void	cm_r_set (dbref player, void *data, char *buffer)
void	cm_s_add (dbref player, void *data, char *buffer)
void	cm_s_minus (dbref player, void *data, char *buffer)
void	cm_s_toggle (dbref player, void *data, char *buffer)
void	cm_s_set (dbref player, void *data, char *buffer)
void	cm_t_add (dbref player, void *data, char *buffer)
void	cm_t_minus (dbref player, void *data, char *buffer)
void	cm_t_toggle (dbref player, void *data, char *buffer)
void	cm_t_set (dbref player, void *data, char *buffer)
void	cm_u_add (dbref player, void *data, char *buffer)
void	cm_u_minus (dbref player, void *data, char *buffer)
void	cm_u_toggle (dbref player, void *data, char *buffer)
void	cm_u_set (dbref player, void *data, char *buffer)
void	cm_v_add (dbref player, void *data, char *buffer)
void	cm_v_minus (dbref player, void *data, char *buffer)
void	cm_v_toggle (dbref player, void *data, char *buffer)
void	cm_v_set (dbref player, void *data, char *buffer)
void	cm_w_add (dbref player, void *data, char *buffer)
void	cm_w_minus (dbref player, void *data, char *buffer)
void	cm_w_toggle (dbref player, void *data, char *buffer)
void	cm_w_set (dbref player, void *data, char *buffer)
void	cm_x_add (dbref player, void *data, char *buffer)
void	cm_x_minus (dbref player, void *data, char *buffer)
void	cm_x_toggle (dbref player, void *data, char *buffer)
void	cm_x_set (dbref player, void *data, char *buffer)
void	cm_y_add (dbref player, void *data, char *buffer)
void	cm_y_minus (dbref player, void *data, char *buffer)
void	cm_y_toggle (dbref player, void *data, char *buffer)
void	cm_y_set (dbref player, void *data, char *buffer)
void	cm_z_add (dbref player, void *data, char *buffer)
void	cm_z_minus (dbref player, void *data, char *buffer)
void	cm_z_toggle (dbref player, void *data, char *buffer)
void	cm_z_set (dbref player, void *data, char *buffer)
int	can_advance_state (struct chargen_struct *st)
int	can_go_back_state (struct chargen_struct *st)
void	recalculate_skillpoints (struct chargen_struct *st)
void	go_back_state (dbref player, struct chargen_struct *st)
void	chargen_look (dbref player, void *data, char *buffer)
void	chargen_begin (dbref player, void *data, char *buffer)
void	chargen_apply (dbref player, void *data, char *buffer)
void	chargen_done (dbref player, void *data, char *buffer)
void	chargen_next (dbref player, void *data, char *buffer)
void	chargen_prev (dbref player, void *data, char *buffer)
void	chargen_reset (dbref player, void *data, char *buffer)
void	chargen_help (dbref player, void *data, char *buffer)

---

Function Documentation

void AccumulateArtyXP	(	dbref	pilot,
		MECH *	attacker,
		MECH *	wounded
	)

Definition at line 1219 of file btechstats.c.

References char_gainxp(), Destroyed, GunPilot, In_Character, MechTeam, MECH::mynum, Name(), RGotGPilot, SendAttackXP, and tprintf().

Referenced by FireSpot().

{
        int xp = 1;

        /* If not in character ie: like in simulator - no xp */
        if(!In_Character(attacker->mynum))
                return;

        if(!RGotGPilot(attacker))
                return;

        if(GunPilot(attacker) != pilot)
                return;

        /* No xp for shooting yourself */
        if(attacker == wounded)
                return;

        /* No xp for shooting destroyed units */
        if(Destroyed(wounded))
                return;

        /* No xp if both on same team */
        if(MechTeam(wounded) == MechTeam(attacker))
                return;

        /* If target not in character ie: in simulator - no xp */
        if(!In_Character(wounded->mynum))
                return;

        /* Switching to Exile method of tracking xp, where we split
         * Attacking and Piloting xp into two different channels
         */
        if(char_gainxp(pilot, "Gunnery-Artillery", xp))
                SendAttackXP(tprintf("%s gained %d artillery XP", Name(pilot), xp));
}

void AccumulateCommXP	(	dbref	pilot,
		MECH *	mech
	)

Definition at line 1126 of file btechstats.c.

References char_gainxp(), Connected, In_Character, MECH::mynum, Name(), RGotPilot, SendXP, and tprintf().

Referenced by sendchannelstuff().

{
        int xp;

        xp = 1;
        if(!RGotPilot(mech))
                return;
        if(!In_Character(mech->mynum))
                return;
        if(!Connected(pilot))
                return;
        if(char_gainxp(pilot, "Comm-Conventional", xp))
                SendXP(tprintf("%s gained %d %s XP (in #%d)", Name(pilot), xp,
                                           "Comm-Conventional", mech->mynum));
}

void AccumulateComputerXP	(	dbref	pilot,
		MECH *	mech,
		int	reason
	)

Definition at line 1256 of file btechstats.c.

References char_gainxp(), In_Character, isPlayer, MAX, MECH::mynum, Name(), SendXP, and tprintf().

Referenced by HandleOverheat().

{
        int xp;

        if(!mech)
                return;

        if(mech && In_Character(mech->mynum) && isPlayer(pilot))
                if(char_gainxp(pilot, "computer", MAX(1, reason)))
                        SendXP(tprintf
                                   ("%s gained %d computer XP (mech #%d)", Name(pilot),
                                        reason, mech ? mech->mynum : -1));
}

void AccumulateGunXP	(	dbref	pilot,
		MECH *	attacker,
		MECH *	wounded,
		int	numOccurences,
		float	multiplier,
		int	weapindx,
		int	bth
	)

Definition at line 1346 of file btechstats.c.

References AccumulateGunXPold(), confdata::btech_oldxpsystem, confdata::btech_xp_bthmod, confdata::btech_xp_modifier, CLASS_MW, Destroyed, FindGunnerySkillName(), GunPilot, In_Character, MBUF_SIZE, MechTeam, MechType, mudconf, MECH::mynum, NUM_SECTIONS, RGotGPilot, and SectIsDestroyed.

Referenced by DamageMech().

{
        int omul, xp, my_BV, th_BV, my_speed, th_speed;
        float myPilotBVMod = 1.0, theirPilotBVMod = 1.0;
        float weapTypeMod;
        char *skname;
        char buf[MBUF_SIZE];
        int damagemod;
        float vrtmod;
        int i;
        int j = NUM_SECTIONS;

        weapTypeMod = 1;

        if(mudconf.btech_oldxpsystem) {
                AccumulateGunXPold(pilot, attacker, wounded, damage,
                                                   multiplier, weapindx, bth);
                return;
        }

        /* No XP for zero'd mechas */
        for(i = 0; i < NUM_SECTIONS; i++)
                j -= SectIsDestroyed(wounded, i);
        
        if( j < 1)
                return;

        /* Is attacker in character ie: not in simulator */
        if(!In_Character(attacker->mynum))
                return;

        if(!RGotGPilot(attacker))
                return;

        if(GunPilot(attacker) != pilot)
                return;

        /* No xp for shooting yourself */
        if(attacker == wounded)
                return;

        /* No xp for shooting destroyed mechs */
        if(Destroyed(wounded))
                return;

        /* No xp for shooting a teammate */
        if(MechTeam(wounded) == MechTeam(attacker))
                return;

        /* Is the target in character ie: in simulators */
        if(!In_Character(wounded->mynum))
                return;

        /* No skill to match the weapon we're shooting with? */
        if(!(skname = FindGunnerySkillName(attacker, weapindx)))
                return;

        /* No xp for shooting mechwarriors if you not a mechwarrior */
        if(MechType(wounded) == CLASS_MW && MechType(attacker) != CLASS_MW)
                return;

        /* bth to high so no way to hit */
        if(!(bth <= 12))
                return;

        multiplier = multiplier * mudconf.btech_xp_modifier;

        if(mudconf.btech_xp_bthmod) {
                if(!(bth >= 3 && bth <= 12))
                        return;                         /* sure hits aren't interesting */
                multiplier = 2 * multiplier * bth_modifier[bth - 3] / 36;
        }

        omul = multiplier;

        /* Need to do a BV mod between the mechs */
        my_BV = MechBV(attacker);
        th_BV = MechBV(wounded);

        if(mudconf.btech_xp_usePilotBVMod) {
                myPilotBVMod = getPilotBVMod(attacker, weapindx);
                theirPilotBVMod = getPilotBVMod(wounded, weapindx);

                my_BV = my_BV * myPilotBVMod;
                th_BV = th_BV * theirPilotBVMod;

#ifdef XP_DEBUG
                SendDebug(tprintf
                                  ("Using skill modified battle value for mechs %d and %d "
                                   "with skill mods of %2.2f and %2.2f", attacker->mynum,
                                   wounded->mynum, myPilotBVMod, theirPilotBVMod));
#endif
        }

        my_speed = NewMoveValue(attacker) + 1;
        th_speed = NewMoveValue(wounded) + 1;

        if(MechWeapons[weapindx].type == TMISSILE)
                weapTypeMod = mudconf.btech_xp_missilemod;
        else if(MechWeapons[weapindx].type == TAMMO)
                weapTypeMod = mudconf.btech_xp_ammomod;

        if(mudconf.btech_defaultweapdam > 1)
                damagemod = damage;
        else
                damagemod = 1;

        if(mudconf.btech_xp_vrtmod)
                vrtmod = (MechWeapons[weapindx].vrt <
                                  30 ? sqrt((double) MechWeapons[weapindx].vrt / 30.0) : 1);
        else
                vrtmod = 1.0;

        multiplier =
                (vrtmod * weapTypeMod * multiplier * sqrt((double) (th_BV +
                                                                                                                        1) * th_speed *
                                                                                                  mudconf.
                                                                                                  btech_defaultweapbv /
                                                                                                  mudconf.
                                                                                                  btech_defaultweapdam)) /
                (sqrt
                 ((double) (my_BV + 1) * my_speed *
                  MechWeapons[weapindx].battlevalue / damagemod));

        if(mudconf.btech_perunit_xpmod)
                multiplier = multiplier * MechXPMod(attacker); /* Per unit XP Mod. Defaults to 1 anyways */
        
        xp = BOUNDED(1, (int) (multiplier * damage / 100), 10);

        strcpy(buf, Name(wounded->mynum));

        // Emit XP gain over MechAttackXP
        if(char_gainxp(pilot, skname, (int) xp))
                SendAttackXP(tprintf
                                         ("%s gained %d gun XP from feat of %f/100 difficulty "
                                          "(%d damage) against %s", Name(pilot), (int) xp, multiplier,
                                          damage, buf));
}                                                               // end AccumulateGunXP()

void AccumulateGunXPold	(	dbref	pilot,
		MECH *	attacker,
		MECH *	wounded,
		int	numOccurences,
		float	multiplier,
		int	weapindx,
		int	bth
	)

Definition at line 1486 of file btechstats.c.

References BOUNDED(), confdata::btech_perunit_xpmod, char_gainxp(), CLASS_MW, Destroyed, FindGunnerySkillName(), GunPilot, In_Character, MBUF_SIZE, MechTeam, MechTons, MechType, MechXPMod, MoveValue, mudconf, MECH::mynum, Name(), Number, RGotGPilot, SendAttackXP, SendError, TonValue, and tprintf().

Referenced by AccumulateGunXP().

{
        int omul, xp;
        char *skname;
        char buf[MBUF_SIZE];

        /* Is the attacker in character ie: in simulators */
        if(!In_Character(attacker->mynum))
                return;

        if(!RGotGPilot(attacker))
                return;

        if(GunPilot(attacker) != pilot)
                return;

        /* No xp for shooting yourself */
        if(attacker == wounded)
                return;

        /* No xp for shooting destroyed units */
        if(Destroyed(wounded))
                return;

        /* No xp for shooting teammate */
        if(MechTeam(wounded) == MechTeam(attacker))
                return;

        /* if target is in character ie: in simulators or something */
        if(!In_Character(wounded->mynum))
                return;

        if(!(skname = FindGunnerySkillName(attacker, weapindx)))
                return;

        /* No xp for shooting a mechwarrior unless you a mechwarrior */
        if(MechType(wounded) == CLASS_MW && MechType(attacker) != CLASS_MW)
                return;

        if(!(bth >= 3 && bth <= 12))
                return;                                 /* sure hits aren't interesting */

        omul = multiplier;
        if(MechTons(attacker) > 0)
                multiplier = multiplier * BOUNDED(50,
                                                                                  100 * TonValue(wounded) /
                                                                                  TonValue(attacker), 150);
        else {
                /* Bring this to the attention of the admins */
                SendError(tprintf
                                  ("AccumulateGunXP: Weird tonnage for IC mech #%d (%s): %d",
                                   attacker->mynum, Name(attacker->mynum),
                                   (short) MechTons(attacker)));
                return;
        }

        /* Hmm.. we have to figure the speed differences as well */
        {
                int my_speed = MoveValue(attacker);
                int th_speed = MoveValue(wounded);

                multiplier = multiplier * th_speed * th_speed / my_speed / my_speed;
        }

        multiplier = multiplier * bth_modifier[bth - 3] / 36;
        multiplier = multiplier * 2;    /* For average shot */
        if(mudconf.btech_perunit_xpmod)
                multiplier = multiplier * MechXPMod(attacker); /* Per unit XP Modifier. Defaults to 1 */

        if(Number(1, 50) > (multiplier * numOccurences))
                return;                                 /* Nothing for truly twinky stuff, occasionally */

        xp = BOUNDED(1, (int) (multiplier * numOccurences) / 100, 50);  /*Hardcoded limit */
        strcpy(buf, Name(wounded->mynum));
        /* Switching to Exile method of tracking xp, where we split
         * Attacking and Piloting xp into two different channels
         */
        if(char_gainxp(pilot, skname, (int) xp))
                SendAttackXP(tprintf("%s gained %d gun XP from feat of %f %% "
                                                         "difficulty (%d occurences) against %s",
                                                         Name(pilot), (int) xp, multiplier, numOccurences,
                                                         buf));
}

void AccumulatePilXP	(	dbref	pilot,
		MECH *	mech,
		int	reason,
		int	addanyway
	)

Definition at line 1142 of file btechstats.c.

References char_gainxp(), FindPilotingSkillName(), In_Character, MAX, MechLX, MechLY, MechX, MechY, MECH::mynum, Name(), RGotPilot, SendPilotXP, and tprintf().

Referenced by DamageMech(), MadePilotSkillRoll_Advanced(), mech_ood_event(), and move_mech().

{
        char *skname;
        int xp;

        if(!In_Character(mech->mynum))
                return;

        if(!RGotPilot(mech))
                return;

        if(!(skname = FindPilotingSkillName(mech)))
                return;

        if(!addanyway) {
                if(MechLX(mech) != MechX(mech) || MechLY(mech) != MechY(mech)) {
                        MechLX(mech) = MechX(mech);
                        MechLY(mech) = MechY(mech);
                } else
                        return;
        }
        xp = MAX(1, reason);

        /* Switching to Exile method of tracking xp, where we split
         * Attacking and Piloting xp into two different channels
         */
        if(char_gainxp(pilot, skname, xp))
                SendPilotXP(tprintf("%s gained %d %s XP", Name(pilot), xp, skname));
/*
    if (char_gainxp(pilot, skname, xp))
            SendXP(tprintf("%s gained %d %s XP", Name(pilot), xp, skname));
*/
}

void AccumulateSpotXP	(	dbref	pilot,
		MECH *	attacker,
		MECH *	wounded
	)

Definition at line 1176 of file btechstats.c.

References char_gainxp(), Destroyed, In_Character, MechPilot, MechTeam, MECH::mynum, Name(), RGotPilot, SendXP, and tprintf().

Referenced by FireSpot().

{
        int xp = 1;

        if(!In_Character(attacker->mynum))
                return;
        if(!RGotPilot(attacker))
                return;
        if(MechPilot(attacker) != pilot)
                return;
        if(attacker == wounded)
                return;
        if(Destroyed(wounded))
                return;
        if(MechTeam(wounded) == MechTeam(attacker))
                return;
        if(!In_Character(wounded->mynum))
                return;
        if(char_gainxp(pilot, "Gunnery-Spotting", xp))
                SendXP(tprintf("%s gained spotting XP", Name(pilot)));
}

void AccumulateTechWeaponsXP	(	dbref	pilot,
		MECH *	mech,
		int	reason
	)

Definition at line 1111 of file btechstats.c.

References char_gainxp(), MAX, MECH::mynum, Name(), SendTechXP, and tprintf().

Referenced by tech_weapon_roll().

{
        char *skname;
        int xp;
        static char *techw = "technician-weapons";

        skname = techw;
        xp = MAX(1, reason);

        // We emit all tech xp gains to MechTechXP channel.
        if(char_gainxp(pilot, skname, xp))
                SendTechXP(tprintf("%s gained %d %s XP (changing mech #%d)",
                                                   Name(pilot), xp, skname, mech ? mech->mynum : -1));
}

void AccumulateTechXP	(	dbref	pilot,
		MECH *	mech,
		int	reason
	)

Definition at line 1091 of file btechstats.c.

References char_gainxp(), FindTechSkillName(), MAX, MECH::mynum, Name(), SendTechXP, and tprintf().

Referenced by tech_roll().

{
        char *skname;
        int xp;
        static char *techw = "technician-weapons";

        if(mech) {
                if(!(skname = FindTechSkillName(mech)))
                        return;
        } else
                skname = techw;

        xp = MAX(1, reason);

        // We emit all tech XP gains to the MechTechXP channel.
        if(char_gainxp(pilot, skname, xp))
                SendTechXP(tprintf("%s gained %d %s XP (changing mech #%d)",
                                                   Name(pilot), xp, skname, mech ? mech->mynum : -1));
}

int btthreshold_func

(

char *

skillname

)

Definition at line 1997 of file btechstats.c.

Referenced by fun_btthreshold().

{
        int code;

        if(!skillname || !*skillname)
                return -1;
        code = char_getvaluecode(skillname);
        if(code < 0)
                return -1;
        if(char_values[code].type != CHAR_SKILL)
                return -1;
        return char_values[code].xpthreshold;
}

int can_advance_state

(

struct chargen_struct *

st

)

int can_go_back_state

(

struct chargen_struct *

st

)

int can_proceed	(	dbref	player,
		struct chargen_struct *	st
	)

int char_gainxp	(	dbref	player,
		char *	skill,
		int	amount
	)

Definition at line 403 of file btechstats.c.

References char_gainxpbycode(), and char_getvaluecode().

Referenced by AccumulateArtyXP(), AccumulateCommXP(), AccumulateComputerXP(), AccumulateGunXPold(), AccumulatePilXP(), AccumulateSpotXP(), AccumulateTechWeaponsXP(), AccumulateTechXP(), and MadePerceptionRoll().

{
        return char_gainxpbycode(player, char_getvaluecode(skill), amount);
}

int char_gainxpbycode	(	dbref	player,
		int	code,
		int	amount
	)

Definition at line 385 of file btechstats.c.

References figure_xp_bonus(), mudstate, statedata::now, retrieve_stats(), SK_XP, store_stats(), VALUES_ATTRS, VALUES_SKILLS, and XP_MAX.

Referenced by char_gainxp(), and fun_btsetcharvalue().

{
        PSTATS *s;

        if(code < 0)
                return 0;
        s = retrieve_stats(player, VALUES_SKILLS | VALUES_ATTRS);
        if(!((mudstate.now > (s->last_use[code] + 30)) ||
                 (char_values[code].flag & SK_XP)))
                return 0;
        s->last_use[code] = mudstate.now;
        s->xp[code] += amount;
        s->xp[code] =
                s->xp[code] % XP_MAX + XP_MAX * figure_xp_bonus(player, s, code);
        store_stats(player, s, VALUES_SKILLS);
        return 1;
}

int char_getattrsave	(	dbref	player,
		char *	name
	)

Definition at line 465 of file btechstats.c.

References char_getvalue().

Referenced by char_getattrsavesucc().

{
        int val = char_getvalue(player, name);

        if(val == -1)
                return (-1);
        else if(val > 9)
                return 0;
        else
                return (18 - 2 * val);
}

int char_getattrsavesucc	(	dbref	player,
		char *	name
	)

Definition at line 477 of file btechstats.c.

References char_getattrsave(), and char_rollskilled().

{
        int roll, val = char_getattrsave(player, name);

        if(val == -1)
                return (-1);

        roll = char_rollskilled();

        if(roll >= val)
                return (1);
        else
                return (0);
}

int char_getopposedskill	(	dbref	first,
		char *	skill1,
		dbref	second,
		char *	skill2
	)

Definition at line 449 of file btechstats.c.

References char_getskillmargsucc().

{
        int per1, per2;

        per1 = char_getskillmargsucc(first, skill1, 0);
        per2 = char_getskillmargsucc(second, skill2, 0);

        if(per1 > per2)
                return (first);
        else if(per2 == per1)
                return (0);
        else
                return (second);
}

int char_getskillmargsucc	(	dbref	player,
		char *	name,
		int	modifier
	)

Definition at line 432 of file btechstats.c.

References char_getskilltargetbycode(), char_getvaluebycode, char_getvaluecode(), char_rollskilled(), and char_rollunskilled().

Referenced by char_getopposedskill().

{
        int roll, val;
        int code;

        code = char_getvaluecode(name);

        val = char_getskilltargetbycode(player, code, modifier);

        if(char_getvaluebycode(player, code) == 0)
                roll = char_rollunskilled();
        else
                roll = char_rollskilled();

        return (roll - val);
}

int char_getskillsuccess	(	dbref	player,
		char *	name,
		int	modifier,
		int	loud
	)

Definition at line 408 of file btechstats.c.

References char_getskilltargetbycode(), char_getvaluebycode, char_getvaluecode(), char_rollskilled(), char_rollunskilled(), and notify_printf().

Referenced by HandleOverheat().

{
        int roll, val;
        int code;

        code = char_getvaluecode(name);

        val = char_getskilltargetbycode(player, code, modifier);

        if(char_getvaluebycode(player, code) == 0)
                roll = char_rollunskilled();
        else
                roll = char_rollskilled();
        if(loud) {
                notify_printf(player, "You make a %s skill roll!", name);
                notify_printf(player, "Modified skill BTH : %d Roll : %d", val, roll);
        }

        if(roll >= val)
                return (1);                             /* Success! */
        else
                return (0);                             /* Failure */
}

int char_getskilltarget	(	dbref	player,
		char *	name,
		int	modifier
	)

Definition at line 369 of file btechstats.c.

References char_getskilltargetbycode(), and char_getvaluecode().

Referenced by FindPilotArtyGun(), FindPilotGunnery(), FindPilotPiloting(), FindPilotSpotting(), FindTechSkill(), FindTechSkillName(), MadePerceptionRoll(), mech_startup_event(), mech_udisembark(), and tech_weapon_roll().

{
        return char_getskilltargetbycode(player, char_getvaluecode(name),
                                                                         modifier);
}

int char_getskilltargetbycode	(	dbref	player,
		int	code,
		int	modifier
	)

Definition at line 352 of file btechstats.c.

References char_getskilltargetbycode_base(), retrieve_stats(), and VALUES_CO.

Referenced by char_getskillmargsucc(), char_getskillsuccess(), char_getskilltarget(), figure_xp_to_next_level(), fun_btgetcharvalue(), fun_btsetcharvalue(), and show_charstatus().

{
        PSTATS *s;

        s = retrieve_stats(player, VALUES_CO);
        return char_getskilltargetbycode_base(player, s, code, modifier, 1);
}

int char_getvalue	(	dbref	player,
		char *	name
	)

Definition at line 297 of file btechstats.c.

References char_getvaluebycode, and char_getvaluecode().

Referenced by char_getattrsave(), mech_startup_event(), and mech_udisembark().

{
        return char_getvaluebycode(player, char_getvaluecode(name));
}

int char_getvaluecode

(

char *

name

)

Definition at line 198 of file btechstats.c.

References alloc_sbuf, free_sbuf, hashfind(), playervaluehash, playervaluehash2, SBUF_SIZE, and ToLower.

Referenced by char_gainxp(), char_getskillmargsucc(), char_getskillsuccess(), char_getskilltarget(), char_getstatvalue(), char_getvalue(), char_setstatvalue(), char_setvalue(), debug_xptop(), fun_btcharlist(), fun_btgetcharvalue(), fun_btsetcharvalue(), and generic_retrieve_stuff().

{
        int *ip;
        char *tmpbuf, *tmpc1, *tmpc2;

        tmpbuf = alloc_sbuf("getvaluecodefind");
        for(tmpc1 = name, tmpc2 = tmpbuf; *tmpc1 &&
                ((tmpbuf - tmpc2) < (SBUF_SIZE - 1)); tmpc1++, tmpc2++)
                *tmpc2 = ToLower(*tmpc1);
        *tmpc2 = 0;
        if((ip = hashfind(tmpbuf, &playervaluehash)) == NULL)
                ip = hashfind(tmpbuf, &playervaluehash2);
        free_sbuf(tmpbuf);
        return ((int) ip) - 1;
}

int char_getxpbycode	(	dbref	player,
		int	code
	)

Definition at line 375 of file btechstats.c.

References retrieve_stats(), VALUES_SKILLS, and XP_MAX.

Referenced by fun_btgetcharvalue(), and fun_btsetcharvalue().

{
        PSTATS *s;

        if(code < 0)
                return 0;
        s = retrieve_stats(player, VALUES_SKILLS);
        return s->xp[code] % XP_MAX;
}

dbref char_lookupplayer	(	dbref	player,
		dbref	cause,
		int	key,
		char *	arg1
	)

Definition at line 748 of file btechstats.c.

References lookup_player().

Referenced by do_charclear(), do_charstatus(), fun_btcharlist(), fun_btgetcharvalue(), fun_btsetcharvalue(), mech_eject(), mech_startup(), and mech_udisembark().

{
        return lookup_player(player, arg1, 0);
}

int char_rolld6

(

int

num

)

Definition at line 277 of file btechstats.c.

References random, and total.

Referenced by char_rollsaving(), char_rollskilled(), and char_rollunskilled().

{
        int i, total = 0;

        for(i = 0; i < num; i++)
                total = total + (random() % 6) + 1;
        return (total);
}

int char_rollsaving

(

void

)

Definition at line 220 of file btechstats.c.

References char_rolld6().

Referenced by handlemwconc(), tech_roll(), and tech_weapon_roll().

{
        int r1, r2, r3;
        int r12, r13, r23;

        r1 = char_rolld6(1);
        r2 = char_rolld6(1);
        r3 = char_rolld6(1);

        r12 = r1 + r2;
        r13 = r1 + r3;
        r23 = r2 + r3;

        if(r12 > r13) {
                if(r12 > r23)
                        return r12;
                else
                        return r23;
        } else {
                if(r13 > r23)
                        return r13;
                else
                        return r23;
        }
}

int char_rollskilled

(

void

)

Definition at line 272 of file btechstats.c.

References char_rolld6().

Referenced by char_getattrsavesucc(), char_getskillmargsucc(), char_getskillsuccess(), and handlemwconc().

{
        return char_rolld6(2);
}

int char_rollunskilled

(

void

)

Definition at line 246 of file btechstats.c.

References char_rolld6().

Referenced by char_getskillmargsucc(), and char_getskillsuccess().

{
        int r1, r2, r3;
        int r12, r13, r23;

        r1 = char_rolld6(1);
        r2 = char_rolld6(1);
        r3 = char_rolld6(1);

        r12 = r1 + r2;
        r13 = r1 + r3;
        r23 = r2 + r3;

        if(r12 < r13) {
                if(r12 < r23)
                        return r12;
                else
                        return r23;
        } else {
                if(r13 < r23)
                        return r13;
                else
                        return r23;
        }
}

void char_setvalue	(	dbref	player,
		char *	name,
		int	value
	)

Definition at line 307 of file btechstats.c.

References char_getvaluecode(), and char_setvaluebycode.

{
        char_setvaluebycode(player, char_getvaluecode(name), value);
}

void chargen_apply	(	dbref	player,
		void *	data,
		char *	buffer
	)

void chargen_begin	(	dbref	player,
		void *	data,
		char *	buffer
	)

void chargen_done	(	dbref	player,
		void *	data,
		char *	buffer
	)

void chargen_help	(	dbref	player,
		void *	data,
		char *	buffer
	)

void chargen_look	(	dbref	player,
		void *	data,
		char *	buffer
	)

void chargen_next	(	dbref	player,
		void *	data,
		char *	buffer
	)

void chargen_prev	(	dbref	player,
		void *	data,
		char *	buffer
	)

void chargen_reset	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_a_add	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_a_minus	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_a_set	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_a_toggle	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_b_add	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_b_minus	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_b_set	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_b_toggle	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_c_add	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_c_minus	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_c_set	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_c_toggle	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_d_add	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_d_minus	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_d_set	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_d_toggle	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_e_add	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_e_minus	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_e_set	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_e_toggle	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_f_add	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_f_minus	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_f_set	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_f_toggle	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_g_add	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_g_minus	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_g_set	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_g_toggle	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_h_add	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_h_minus	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_h_set	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_h_toggle	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_i_add	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_i_minus	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_i_set	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_i_toggle	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_j_add	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_j_minus	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_j_set	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_j_toggle	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_k_add	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_k_minus	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_k_set	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_k_toggle	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_l_add	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_l_minus	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_l_set	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_l_toggle	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_m_add	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_m_minus	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_m_set	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_m_toggle	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_n_add	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_n_minus	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_n_set	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_n_toggle	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_o_add	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_o_minus	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_o_set	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_o_toggle	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_p_add	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_p_minus	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_p_set	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_p_toggle	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_q_add	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_q_minus	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_q_set	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_q_toggle	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_r_add	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_r_minus	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_r_set	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_r_toggle	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_s_add	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_s_minus	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_s_set	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_s_toggle	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_t_add	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_t_minus	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_t_set	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_t_toggle	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_u_add	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_u_minus	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_u_set	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_u_toggle	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_v_add	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_v_minus	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_v_set	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_v_toggle	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_w_add	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_w_minus	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_w_set	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_w_toggle	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_x_add	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_x_minus	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_x_set	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_x_toggle	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_y_add	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_y_minus	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_y_set	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_y_toggle	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_z_add	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_z_minus	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_z_set	(	dbref	player,
		void *	data,
		char *	buffer
	)

void cm_z_toggle	(	dbref	player,
		void *	data,
		char *	buffer
	)

void debug_setxplevel	(	dbref	player,
		void *	data,
		char *	buffer
	)

Definition at line 1981 of file btechstats.c.

References args, DOCHECK, mech_parseattributes(), and Readnum.

{
        char *args[3];
        int xpt, code;

        DOCHECK(mech_parseattributes(buffer, args, 3) != 2, "Invalid arguments!");
        DOCHECK(Readnum(xpt, args[1]), "Invalid value!");
        DOCHECK(xpt < 0, "Threshold needs to be >=0 (0 = no gains possible)");
        DOCHECK((code =
                         char_getvaluecode(args[0])) < 0, "That isn't any charvalue!");
        DOCHECK(char_values[code].type != CHAR_SKILL, "That isn't any skill!");
        char_values[code].xpthreshold = xpt;
    log_error(LOG_WIZARD, "WIZ", "CHANGE", "Exp threshold for %s changed to %d by #%d", 
                                                 char_values[code].name, xpt, player);
}

void debug_xptop	(	dbref	player,
		void *	data,
		char *	buffer
	)

Definition at line 1751 of file btechstats.c.

References addline, addmenu, c, char_getvaluecode(), CHAR_SKILL, DO_WHOLE_DB, DOCHECK, isPlayer, KillCoolMenu(), MAX_PLAYERS_ON, MIN, Name(), notify, retrieve_stats(), ShowCoolMenu(), skipws, tprintf(), VALUES_SKILLS, Wiz, and XP_MAX.

{
        int hm, i, j;
        dbref top[MAX_PLAYERS_ON];
        int topv[MAX_PLAYERS_ON];
        int count = 0, gt = 0;
        coolmenu *c = NULL;
        PSTATS *s;

#if 0
        notify(player, "Support discontinued. Bother a wiz if this bothers you.");
        return;
#endif

        bzero(top, sizeof(top));
        bzero(topv, sizeof(topv));
        skipws(buffer);
        DOCHECK(!*buffer, "Invalid argument!");
        DOCHECK((hm = char_getvaluecode(buffer)) < 0, "Invalid value name!");
        DOCHECK(char_values[hm].type != CHAR_SKILL,
                        "Only skills have XP (for now at least)");
        DO_WHOLE_DB(i) {
                if(!isPlayer(i))
                        continue;
                if(Wiz(i))
                        continue;
                if(!(s = retrieve_stats(i, VALUES_SKILLS)))
                        continue;
                if(!s->xp[hm])
                        continue;
                top[count] = i;
                topv[count] = (s->xp[hm] % XP_MAX);
                gt += topv[count];
                count++;
        }
        for(i = 0; i < (count - 1); i++)
                for(j = i + 1; j < count; j++) {
                        if(topv[j] > topv[i]) {
                                topv[count] = topv[j];
                                topv[j] = topv[i];
                                topv[i] = topv[count];

                                top[count] = top[j];
                                top[j] = top[i];
                                top[i] = top[count];
                        }
                }
        addline();
        for(i = 0; i < MIN(16, count); i++) {
                addmenu(tprintf("%3d. %s", i + 1, Name(top[i])));
                addmenu(tprintf("%d (%.3f %%)", topv[i], (100.0 * topv[i]) / gt));
        }
        addline();
        if(gt) {
                addmenu(tprintf("Grand total: %d points", gt));
                addline();
        }
        ShowCoolMenu(player, c);
        KillCoolMenu(c);
}

void do_charclear	(	dbref	player,
		dbref	cause,
		int	key,
		char *	arg1
	)

Definition at line 711 of file btechstats.c.

References A_ADVS, A_ATTRS, A_HEALTH, A_SKILLS, char_lookupplayer(), DOCHECK, NOTHING, notify_printf(), silly_atr_set(), and WizR.

{
        dbref thing;

        DOCHECK(!WizR(player),
                        "Sorry, only those with the real power may clear players stats");
        DOCHECK(!arg1 || !*arg1, "Who do you want to clear the stats from?");
        thing = char_lookupplayer(player, player, 0, arg1);
        DOCHECK(thing == NOTHING, "I don't know who that is");
        silly_atr_set(thing, A_ATTRS, "");
        silly_atr_set(thing, A_SKILLS, "");
        silly_atr_set(thing, A_ADVS, "");
        silly_atr_set(thing, A_HEALTH, "");
        notify_printf(player, "Player #%d stats cleared", thing);
}

void do_charstatus	(	dbref	player,
		dbref	cause,
		int	key,
		char *	arg1
	)

Definition at line 684 of file btechstats.c.

References char_lookupplayer(), dir, DOCHECK, NOTHING, notify, retrieve_stats(), show_charstatus(), VALUES_ALL, and WizR.

{
        dbref thing;
        int dir = 0;

        PSTATS *s;

        if(WizR(player))
                dir++;

        if(arg1 && *arg1) {
                thing = char_lookupplayer(player, player, 0, arg1);

                DOCHECK(thing == NOTHING, "I don't know who that is");

                if(thing != player && !(WizR(player))) {
                        notify(player,
                                   "You do not have the authority to check that players stats");
                        return;
                }
        } else
                thing = player;

        s = retrieve_stats(thing, VALUES_ALL);
        show_charstatus(player, s, thing);
}

void fix_pilotdamage	(	MECH *	mech,
		dbref	player
	)

Definition at line 877 of file btechstats.c.

References char_gbruise, char_glethal, char_gvalue, MechPilotStatus, retrieve_stats(), VALUES_ATTRS, and VALUES_HEALTH.

Referenced by mech_startup(), and mech_udisembark().

{
        PSTATS *s;
        int bruise, lethal, playerBLD;

        s = retrieve_stats(player, VALUES_HEALTH | VALUES_ATTRS);
        bruise = char_gbruise(s);
        lethal = char_glethal(s);
        playerBLD = char_gvalue(s, "build") * 2;
        if(playerBLD < 1 || playerBLD > 100)
                playerBLD = 10;

        MechPilotStatus(mech) = (bruise + lethal) / playerBLD;
}

void fun_btcharlist	(	char *	buff,
		char **	bufc,
		dbref	player,
		dbref	cause,
		char *	fargs[],
		int	nfargs,
		char *	cargs[],
		int	ncargs
	)

Definition at line 1688 of file btechstats.c.

References CHAR_ADVANTAGE, CHAR_ATTRIBUTE, char_getvaluebycode, char_getvaluecode(), char_lookupplayer(), CHAR_SKILL, fn_range_check(), listmatch(), name, NOTHING, and safe_str.

{
        int i;
        int type = 0;
        int first = 1;
        dbref target = 0;
        enum {
                CHSKI,
                CHADV,
                CHATT,
        };
        static char *cmds[] = {
                "skills",
                "advantages",
                "attributes",
                NULL
        };

        if(!fn_range_check("BTCHARLIST", nfargs, 1, 2, buff, bufc))
                return;

        if(nfargs == 2) {
                target = char_lookupplayer(player, cause, 0, fargs[1]);
                if(target == NOTHING) {
                        safe_str("#-1 FUNCTION (BTCHARLIST) INVALID TARGET", buff, bufc);
                        return;
                }
        }

        switch (listmatch(cmds, fargs[0])) {
        case CHSKI:
                type = CHAR_SKILL;
                break;
        case CHADV:
                type = CHAR_ADVANTAGE;
                break;
        case CHATT:
                type = CHAR_ATTRIBUTE;
                break;
        default:
                safe_str("#-1 FUNCTION (BTCHARLIST) INVALID VALUE", buff, bufc);
                return;
        }

        for(i = 0; i < NUM_CHARVALUES; ++i)
                if(type == char_values[i].type) {
                        if(nfargs == 2 && type != CHAR_ATTRIBUTE) {
                                int targetcode = char_getvaluecode(char_values[i].name);
                                if(char_getvaluebycode(target, targetcode) == 0)
                                        continue;
                        }
                        if(first)
                                first = 0;
                        else
                                safe_str(" ", buff, bufc);
                        safe_str(char_values[i].name, buff, bufc);
                }
        return;
}

void fun_btgetcharvalue	(	char *	buff,
		char **	bufc,
		dbref	player,
		dbref	cause,
		char *	fargs[],
		int	nfargs,
		char *	cargs[],
		int	ncargs
	)

Definition at line 1572 of file btechstats.c.

References char_getskilltargetbycode(), char_getvaluebycode, char_getvaluecode(), char_getxpbycode(), char_lookupplayer(), CHAR_SKILL, figure_xp_to_next_level(), FUNCHECK, NOTHING, Readnum, retrieve_stats(), safe_tprintf_str(), VALUES_SKILLS, and Wiz.

{
        /* fargs[0] = char id (#222)
           fargs[1] = value name / value loc #
           fargs[2] = flaggo (?) */
        dbref target;
        int targetcode, flaggo;

        FUNCHECK((target =
                          char_lookupplayer(player, cause, 0, fargs[0])) == NOTHING,
                         "#-1 INVALID TARGET");
        FUNCHECK(!Wiz(player), "#-1 PERMISSION DENIED!");
        if(Readnum(targetcode, fargs[1]))
                targetcode = char_getvaluecode(fargs[1]);
        FUNCHECK(targetcode < 0 ||
                         targetcode >= NUM_CHARVALUES, "#-1 INVALID VALUE");
        flaggo = atoi(fargs[2]);
        if(char_values[targetcode].type == CHAR_SKILL && flaggo == 4) {
                safe_tprintf_str(buff, bufc, "%d",
                                                 figure_xp_to_next_level(target, targetcode));
                return;
        }
        if(char_values[targetcode].type == CHAR_SKILL && flaggo == 3) {
                safe_tprintf_str(buff, bufc, "%d",
                                                 retrieve_stats(target,
                                                                                VALUES_SKILLS)->values[targetcode]);
                return;
        }
        if(char_values[targetcode].type == CHAR_SKILL && flaggo == 2) {
                safe_tprintf_str(buff, bufc, "%d", char_getxpbycode(target,
                                                                                                                        targetcode));
                return;
        }
        if(char_values[targetcode].type == CHAR_SKILL && flaggo) {
                safe_tprintf_str(buff, bufc, "%d",
                                                 char_getskilltargetbycode(target, targetcode, 0));
                return;
        }
        safe_tprintf_str(buff, bufc, "%d", char_getvaluebycode(target,
                                                                                                                   targetcode));
}

void fun_btsetcharvalue	(	char *	buff,
		char **	bufc,
		dbref	player,
		dbref	cause,
		char *	fargs[],
		int	nfargs,
		char *	cargs[],
		int	ncargs
	)

Definition at line 1615 of file btechstats.c.

References char_gainxpbycode(), char_getskilltargetbycode(), char_getvaluebycode, char_getvaluecode(), char_getxpbycode(), char_lookupplayer(), char_setvaluebycode, CHAR_SKILL, FUNCHECK, Name(), name, NOTHING, Readnum, safe_tprintf_str(), SendXP, tprintf(), and Wiz.

{
        /* fargs[0] = char id (#222)
           fargs[1] = value name / value loc #
           fargs[2] = value to be set
           fargs[3] = flaggo (?)
         */
        dbref target;
        int targetcode, targetvalue, flaggo;

        FUNCHECK((target =
                          char_lookupplayer(player, cause, 0, fargs[0])) == NOTHING,
                         "#-1 INVALID TARGET");
        FUNCHECK(!Wiz(player), "#-1 PERMISSION DENIED!");
        if(Readnum(targetcode, fargs[1]))
                targetcode = char_getvaluecode(fargs[1]);
        FUNCHECK(targetcode < 0 ||
                         targetcode >= NUM_CHARVALUES, "#-1 INVALID VALUE");
        targetvalue = atoi(fargs[2]);
        flaggo = atoi(fargs[3]);

        /* We supposedly have everything at hand.. */
        if(flaggo) {
                FUNCHECK(char_values[targetcode].type != CHAR_SKILL,
                                 "#-1 ONLY SKILLS CAN HAVE FLAG");
                if(flaggo == 1) {
                        /* Need to do some evil frobbage here */
                        char_setvaluebycode(target, targetcode, 0);
                        targetvalue =
                                char_getskilltargetbycode(target, targetcode,
                                                                                  0) - targetvalue;
                } else {
                        if(flaggo != 3) {
                                /* Add exp */
                                char_gainxpbycode(target, targetcode, targetvalue);
                                SendXP(tprintf("#%d added %d more %s XP to #%d", player,
                                                           targetvalue, char_values[targetcode].name,
                                                           target));
                                safe_tprintf_str(buff, bufc, "%s gained %d more %s XP.",
                                                                 Name(target), targetvalue,
                                                                 char_values[targetcode].name);
                        } else {
                                /* Set the xp instead */
                                char_gainxpbycode(target, targetcode,
                                                                  targetvalue - char_getxpbycode(target,
                                                                                                                                 targetcode));
                                SendXP(tprintf
                                           ("#%d set #%d's %s XP to %d", player, target,
                                                char_values[targetcode].name, targetvalue));
                                safe_tprintf_str(buff, bufc, "%s's %s XP set to %d.",
                                                                 Name(target), char_values[targetcode].name,
                                                                 targetvalue);
                        }
                        return;
                }
        }
        char_setvaluebycode(target, targetcode, targetvalue);
        safe_tprintf_str(buff, bufc, "%s's %s set to %d", Name(target),
                                         char_values[targetcode].name, char_getvaluebycode(target,
                                                                                                                                           targetcode));
}

void go_back_state	(	dbref	player,
		struct chargen_struct *	st
	)

int handlemwconc	(	MECH *	mech,
		int	initial
	)

Definition at line 923 of file btechstats.c.

References BOUNDED(), ChannelEmitKill(), char_rollsaving(), char_rollskilled(), Destroy, In_Character, mech_notify(), mech_printf(), MechDesiredSpeed, MECHPILOT, MechPilot, MechPilotStatus, MechSpeed, mw_ic_bth(), MECH::mynum, ProlongUncon(), Uncon, and UNCONSCIOUS_TIME.

Referenced by headhitmwdamage(), mech_recovery_event(), and mwlethaldam().

{
        int m, roll;

        if(In_Character(mech->mynum) && MechPilot(mech) > 0)
                m = mw_ic_bth(mech);
        else {
                if(initial)
                        if(MechPilotStatus(mech) > 5) {
                                mech_notify(mech, MECHPILOT,
                                                        "You are killed from personal injuries!!");
                                MechPilot(mech) = -1;
                                Destroy(mech);
                                ChannelEmitKill(mech, mech);
                                MechSpeed(mech) = 0.;
                                MechDesiredSpeed(mech) = 0.;
                                return 0;
                        }
                m = PilotStatusRollNeeded[BOUNDED(0, (int) MechPilotStatus(mech), 4)];
        }
        if(initial && Uncon(mech))
                return 0;
        if(m < 0)
                /*  Gets the saving roll for someone with toughness  */
                roll = char_rollsaving();
        else
                roll = char_rollskilled();
        if(MechPilot(mech) >= 0) {
                if(initial) {
                        mech_notify(mech, MECHPILOT,
                                                "You attempt to keep consciousness!");
                        mech_printf(mech, MECHPILOT,
                                                "Retain Conciousness on: %d  \tRoll: %d", abs(m),
                                                roll);
                } else {
                        mech_notify(mech, MECHPILOT,
                                                "You attempt to regain consciousness!");
                        mech_printf(mech, MECHPILOT,
                                                "Regain Consciousness on: %d  \tRoll: %d", abs(m),
                                                roll);
                }
        }
        if(roll < (abs(m))) {
                if(initial)
                        mech_notify(mech, MECHPILOT,
                                                "Consciousness slips away from you as you enter a sea of darkness...");
                ProlongUncon(mech, UNCONSCIOUS_TIME);
                return 0;
        }
        return 1;
}

int HasBoolAdvantage	(	dbref	player,
		const char *	name
	)

Definition at line 1270 of file btechstats.c.

References char_gvalue, retrieve_stats(), SBUF_SIZE, VALUES_ADVS, VALUES_ATTRS, and VALUES_HEALTH.

Referenced by ammo_explosion(), ChargeMech(), DeathFromAbove(), DisplayTarget(), mech_turnmode(), MechCargoMaxSpeed(), PhysicalAttack(), PhysicalDamage(), tech_roll(), tech_weapon_roll(), UpdateHeading(), and UpdateSpeed().

{
        PSTATS *s;
        char buf[SBUF_SIZE];

        strcpy(buf, name);
        s = retrieve_stats(player, VALUES_ATTRS | VALUES_ADVS | VALUES_HEALTH);
        if(char_gvalue(s, buf) == 1)
                return 1;
        else
                return 0;
}

void headhitmwdamage	(	MECH *	mech,
		MECH *	attacker,
		int	dam
	)

Definition at line 975 of file btechstats.c.

References char_gbruise, char_glethal, char_gvalue, char_sbruise, char_slethal, Destroyed, DestroyMech(), GotPilot, handlemwconc(), In_Character, KillMechContentsIfIC(), MechPilot, MechPilotStatus, MECH::mynum, retrieve_stats(), store_stats(), VALUES_ADVS, VALUES_ATTRS, and VALUES_HEALTH.

Referenced by ammo_explosion(), DamageMech(), DeathFromAbove(), HandleFasaVehicleCrit(), HandleVehicleCrit(), mech_explode_event(), MechFalls(), reactor_explosion(), and UpdateHeat().

{
        PSTATS *s;
        dbref player;
        int damage, bruise, lethaldam, playerBLD;

        if(mech->mynum < 0)
                return;
        /* check to see if mech is IC */
        if(!In_Character(mech->mynum) || !GotPilot(mech)) {
                MechPilotStatus(mech) += dam;
                handlemwconc(mech, 1);
                return;
        }
        player = MechPilot(mech);

        s = retrieve_stats(player, VALUES_ATTRS | VALUES_ADVS | VALUES_HEALTH);
        /* get the player_stats structure */

        bruise = char_gbruise(s);
        /* gets the players bruise damage */

        playerBLD = char_gvalue(s, "build");
        /* get the player's BLD value */

        damage = 2 * playerBLD * dam;
        /* the damage we are due */

        bruise += damage;
        /* this part subtracts 10 from players lethal damage */

        if(bruise > playerBLD * 10) {
                lethaldam = char_glethal(s);
                lethaldam += (bruise - playerBLD * 10);
                bruise = playerBLD * 10;

                if(lethaldam >= playerBLD * 10) {
                        lethaldam = playerBLD * 10;
                        char_slethal(s, playerBLD * 10 - 1);
                        char_sbruise(s, playerBLD * 10);
                        store_stats(player, s, VALUES_HEALTH);
                        if(!Destroyed(mech)) {
                                DestroyMech(mech, attacker, 1);
                        }
                        KillMechContentsIfIC(mech->mynum);
                        return;
                }
                char_slethal(s, lethaldam);
        }
        char_sbruise(s, bruise);
        store_stats(player, s, VALUES_HEALTH);
        handlemwconc(mech, 1);
        MechPilotStatus(mech) += dam;
}

void init_btechstats

(

void

)

Definition at line 498 of file btechstats.c.

References alloc_sbuf, free_sbuf, HASH_FACTOR, hashadd(), hashinit(), name, playervaluehash, playervaluehash2, and ToLower.

Referenced by LoadSpecialObjects().

{
        char *tmpbuf, *tmpc1, *tmpc2;
        int i, j;

        hashinit(&playervaluehash, 20 * HASH_FACTOR);
        hashinit(&playervaluehash2, 20 * HASH_FACTOR);
        tmpbuf = alloc_sbuf("getvaluecode");
        for(i = 0; i < NUM_CHARVALUES; i++) {
                for(tmpc1 = char_values[i].name, tmpc2 = tmpbuf; *tmpc1;
                        tmpc1++, tmpc2++)
                        *tmpc2 = ToLower(*tmpc1);
                *tmpc2 = '\0';
                hashadd(tmpbuf, (int *) (i + 1), &playervaluehash);
                tmpbuf[0] = '\0';
                tmpc1 = tmpbuf;
                for(j = 0; char_values[i].name[j]; j++) {
                        if(!isupper(char_values[i].name[j]))
                                continue;
                        strncpy(tmpc1, &char_values[i].name[j], 3);
                        tmpc1 += 3;
                }
                *tmpc1 = '\0';
                if(strlen(tmpbuf) <= 3) {
                        strncpy(tmpbuf, char_values[i].name, 5);
                        tmpbuf[5] = '\0';
                }
                char_values_short[i] = strdup(tmpbuf);
                for(tmpc1 = tmpbuf; *tmpc1; tmpc1++)
                        *tmpc1 = ToLower(*tmpc1);
                hashadd(tmpbuf, (int *) (i + 1), &playervaluehash2);
        }
        free_sbuf(tmpbuf);
}

void initialize_pc	(	dbref	player,
		MECH *	mech
	)

Definition at line 773 of file btechstats.c.

References A_PCEQUIP, c, char_gbruise, char_glethal, char_gvalue, CLASS_MW, CTORSO, find_matching_vlong_part(), HEAD, I2Ammo, IsWeapon, LARM, loc_mod(), MBUF_SIZE, MechCritStatus, MechMaxSpeed, MechType, MechWeapons, MP1, Name(), NUM_SECTIONS, PC_INITIALIZED, PC_LOCS, RARM, retrieve_stats(), RLEG, SendError, SetPartAmmoMode, SetPartData, SetPartFireMode, SetPartType, SetSectArmor, SetSectInt, SetSectOArmor, SetSectOInt, silly_atr_get(), tprintf(), VALUES_ATTRS, VALUES_HEALTH, VALUES_SKILLS, and Weapon2I.

Referenced by autoeject(), char_disembark(), char_eject(), and mech_startup_event().

{
        PSTATS *s;
        int bruise, lethal, playerBLD;
        int dam, tot;
        char *c;
        int cnt;
        char buf1[MBUF_SIZE];
        char buf2[MBUF_SIZE];
        char buf3[MBUF_SIZE];
        char buf4[2];
        int ammo1;
        int ammo2;
        int i, id, brand;
        int pc_loc_to_mech_loc[] = { HEAD, CTORSO, RARM, RLEG };

        if(!(MechType(mech) == CLASS_MW &&
                 !(MechCritStatus(mech) & PC_INITIALIZED)))
                return;
        buf4[1] = 0;
        s = retrieve_stats(player, VALUES_HEALTH | VALUES_ATTRS | VALUES_SKILLS);
        playerBLD = char_gvalue(s, "build");
        MechCritStatus(mech) |= PC_INITIALIZED;
        bruise = char_gbruise(s);
        lethal = char_glethal(s);
        tot = playerBLD * 20;
        dam = bruise + lethal;
        MechMaxSpeed(mech) =
                (playerBLD + char_gvalue(s, "reflexes") + char_gvalue(s,
                                                                                                                          "running")) *
                MP1 / 9.0;
#define PC_LOCS 4
        for(i = 0; i < NUM_SECTIONS; i++) {
                SetSectArmor(mech, i, 0);
                SetSectOArmor(mech, i, 0);
                SetSectInt(mech, i, (loc_mod(i) * (tot - dam)) / 100 + 1);
                SetSectOInt(mech, i, (loc_mod(i) * (tot - dam)) / 100 + 1);
        }
        c = silly_atr_get(player, A_PCEQUIP);
        cnt = sscanf(c, "%s %s %s %d %d", buf1, buf2, buf3, &ammo1, &ammo2);

        switch (cnt) {
        case 5:
        case 4:
        case 3:
                if(strcmp(buf3, "-")) {
                        if(!find_matching_vlong_part(buf3, NULL, &id, &brand)) {
                                SendError(tprintf("Invalid PC weapon #1 for %s(#%d): %s",
                                                                  Name(player), player, buf3));
                                return;
                        }
                        if(IsWeapon(id)) {
                                SetPartType(mech, LARM, 0, id);
                                SetPartData(mech, LARM, 0, 0);
                                SetPartFireMode(mech, LARM, 0, 0);
                                SetPartAmmoMode(mech, LARM, 0, 0);
                                if((i = MechWeapons[Weapon2I(id)].ammoperton)) {
                                        SetPartType(mech, LARM, 1, I2Ammo(Weapon2I(id)));
                                        SetPartData(mech, LARM, 1, cnt >= 5 ? ammo2 : i);
                                        SetPartFireMode(mech, LARM, 1, 0);
                                        SetPartAmmoMode(mech, LARM, 1, 0);
                                }
                        }
                }
        case 2:
                if(strcmp(buf2, "-")) {
                        if(!find_matching_vlong_part(buf2, NULL, &id, &brand)) {
                                SendError(tprintf("Invalid PC weapon #1 for %s(#%d): %s",
                                                                  Name(player), player, buf2));
                                return;
                        }
                        if(IsWeapon(id)) {
                                SetPartType(mech, RARM, 0, id);
                                SetPartData(mech, RARM, 0, 0);
                                SetPartFireMode(mech, RARM, 0, 0);
                                SetPartAmmoMode(mech, RARM, 0, 0);
                                if((i = MechWeapons[Weapon2I(id)].ammoperton)) {
                                        SetPartType(mech, RARM, 1, I2Ammo(Weapon2I(id)));
                                        SetPartData(mech, RARM, 1, cnt >= 4 ? ammo1 : i);
                                        SetPartFireMode(mech, RARM, 1, 0);
                                        SetPartAmmoMode(mech, RARM, 1, 0);
                                }
                        }
                }
        case 1:
                if(strlen(buf1) != PC_LOCS) {
                        SendError(tprintf("Invalid armor string for %s(#%d): %s",
                                                          Name(player), player, buf1));
                        return;
                }
                for(i = 0; buf1[i]; i++)
                        if(!isdigit(buf1[i])) {
                                SendError(tprintf
                                                  ("Invalid armor char for %s(#%d) in %s (pos %d,%c)",
                                                   Name(player), player, buf1, i + 1, buf1[i]));
                                return;
                        }
                for(i = 0; buf1[i]; i++) {
                        buf4[0] = buf1[i];
                        SetSectArmor(mech, pc_loc_to_mech_loc[i], atoi(buf4));
                }
        }
}

void list_charvaluestuff	(	dbref	player,
		int	flag
	)

Definition at line 155 of file btechstats.c.

References name, notify, and notify_printf().

Referenced by do_show().

{
        int found = 0, ok, type;
        int i;
        char buf[80];

        if(flag == -1)
                notify(player, "List of charvalues available:");
        if(flag >= 0) {
                notify_printf(player, "List of %s available:",
                                          btech_charvaluetype_names[flag]);
        }
        buf[0] = 0;
        for(i = 0; i < NUM_CHARVALUES; i++) {
                ok = 0;
                type = char_values[i].type;
                if(flag < 0)
                        ok = 1;
                else if(type == flag)
                        ok = 1;
                if(ok) {
                        sprintf(buf + strlen(buf), "%-23s ", char_values[i].name);
                        if(!((++found) % 3)) {
                                notify(player, buf);
                                strcpy(buf, " ");
                        }
                }
        }
        if(found % 3) {
                notify(player, buf);
        }
        notify(player, " ");
        notify_printf(player, "Total of %d things found.", found);
}

void lower_xp	(	dbref	player,
		int	promillage
	)

Definition at line 1072 of file btechstats.c.

{
        PSTATS *s;
        int i;

        s = retrieve_stats(player, VALUES_ALL);
        for(i = 0; i < NUM_CHARVALUES; i++) {
                if(!s->xp[i])
                        continue;
                if(s->xp[i] < 0) {
                        s->xp[i] = 0;
                        continue;
                }
                s->xp[i] = (s->xp[i] % XP_MAX) * promillage / 1000;
                s->xp[i] = s->xp[i] % XP_MAX + XP_MAX * figure_xp_bonus(player, s, i);
        }
        store_stats(player, s, VALUES_ALL);
}

int lowest_bit

(

int

num

)

int MadePerceptionRoll	(	MECH *	mech,
		int	modifier
	)

Definition at line 1198 of file btechstats.c.

References char_gainxp(), char_getskilltarget(), In_Character, MechPer, MechPilot, MECH::mynum, Name(), RGotGPilot, Roll(), SendXP, and tprintf().

Referenced by Sensor_Sees(), show_building_in_hex(), show_mines_in_hex(), and steppable_base_check().

{
        int pilot;

        if(!In_Character(mech->mynum))
                return 0;
        if(!RGotGPilot(mech))
                return 0;
        pilot = MechPilot(mech);
        if(pilot <= 0)
                return 0;
        if(!MechPer(mech))
                MechPer(mech) = char_getskilltarget(pilot, "Perception", 2);
        if(Roll() < (MechPer(mech) + modifier))
                return 0;
        char_gainxp(pilot, "Perception", 1);
        if(char_gainxp(pilot, "Perception", 1))
                SendXP(tprintf("%s gained 1 perception XP", Name(pilot)));
        return 1;
}

int mw_ic_bth

(

MECH *

mech

)

Definition at line 896 of file btechstats.c.

References char_gbruise, char_gvalue, MechPilot, retrieve_stats(), VALUES_ADVS, VALUES_ATTRS, and VALUES_HEALTH.

Referenced by handlemwconc().

{
        int playerBLD;
        int bruise, playerhits;
        PSTATS *s;
        int mod = 1;

        s = retrieve_stats(MechPilot(mech),
                                           VALUES_ATTRS | VALUES_ADVS | VALUES_HEALTH);
        playerBLD = char_gvalue(s, "build");
        bruise = char_gbruise(s);
        playerhits = 10 * playerBLD - bruise;
        if(char_gvalue(s, "toughness") == 1)
                mod = -1;
        if(playerhits >= (8 * playerBLD))
                return 3 * mod;
        else if(playerhits >= (6 * playerBLD))
                return 5 * mod;
        else if(playerhits >= (4 * playerBLD))
                return 7 * mod;
        else if(playerhits >= (2 * playerBLD))
                return 9 * mod;
        else if(playerhits >= -1)
                return 11 * mod;
        return 0;
}

void mwlethaldam	(	MECH *	mech,
		MECH *	attacker,
		int	dam
	)

Definition at line 1030 of file btechstats.c.

References BOUNDED(), char_gbruise, char_glethal, char_gvalue, char_sbruise, char_slethal, Destroyed, DestroyMech(), GotPilot, handlemwconc(), In_Character, KillMechContentsIfIC(), MechPilot, MechPilotStatus, MECH::mynum, retrieve_stats(), store_stats(), VALUES_ADVS, VALUES_ATTRS, and VALUES_HEALTH.

{
        PSTATS *s;
        dbref player;
        int bruise, lethaldam, playerBLD;

        if(mech->mynum < 0)
                return;
        /* check to see if mech is IC */
        if(!In_Character(mech->mynum) || !GotPilot(mech)) {
                MechPilotStatus(mech) += dam;
                handlemwconc(mech, 1);
                return;
        }
        player = MechPilot(mech);

        s = retrieve_stats(player, VALUES_ATTRS | VALUES_ADVS | VALUES_HEALTH);
        /* get the player_stats structure */
        bruise = char_gbruise(s);
        playerBLD = char_gvalue(s, "build");
        if(!playerBLD)
                playerBLD++;
        lethaldam = char_glethal(s);
        lethaldam += BOUNDED(10, dam * playerBLD, 40);
        if(lethaldam >= playerBLD * 10) {
                lethaldam = playerBLD * 10;
                char_slethal(s, lethaldam - 1);
                char_sbruise(s, lethaldam);
                store_stats(player, s, VALUES_HEALTH);
                if(!Destroyed(mech)) {
                        DestroyMech(mech, attacker, 1);
                }
                KillMechContentsIfIC(mech->mynum);
                return;
        }
        char_sbruise(s, playerBLD * 10 - 5);
        char_slethal(s, lethaldam);
        store_stats(player, s, VALUES_HEALTH);
        handlemwconc(mech, 1);
        MechPilotStatus(mech) += dam;
}

void recalculate_skillpoints

(

struct chargen_struct *

st

)

int recursive_add

(

int

lev

)

struct chargen_struct* retrieve_chargen_struct

(

dbref

player

)

char* silly_get_uptime_to_string

(

int

i

)

Definition at line 54 of file btechstats.c.

References c, free_sbuf, get_uptime_to_string(), and MBUF_SIZE.

Referenced by tech_checkstatus().

{
        static char buf[MBUF_SIZE];
        char *c;

        c = get_uptime_to_string(i);
        strcpy(buf, c);
        free_sbuf(c);
        return buf;
}

void zap_unneccessary_stats

(

void

)

---