SraUtility.h

Go to the documentation of this file.

#ifndef __SRAUTILITY_H
#define __SRAUTILITY_H

//As of 6/20/2010, this is a legacy file that may need to be re-implemented in UnrealScript as needed

//This file contains a mix of generally useful methods
//These include functions that act on basic types using by the SR library
//Also, this contains all of the magic formulae for character, utilizing SrConstants
//NOTE: All of these functions are inlined for performance

#include <map>
#include <string>
#include <sstream>

#include "CodeGenMacros.h"
#include "SrConstants.h"
#include "SraConstants.h"

namespace SraLogic
{
    //Functions that work on types defined in SraTypes

    INLINE int GetRecoilPenalty(FireMode mode, bool firstShot, bool heavyWeapon)
    {
        int recoil = 0;
        if(firstShot)
        {
            switch(mode)
            {
                case SingleShot: recoil = RECOIL_FIRST_SEMIAUTO; break;
                case SemiAuto: recoil = RECOIL_FIRST_SEMIAUTO; break;
                case BurstFire: recoil = RECOIL_FIRST_BURST; break;
                case LongBurst: recoil = RECOIL_FIRST_LONGBURST; break;
                case FullAuto: recoil = RECOIL_FIRST_LONGBURST; break;
            }
        }
        else
        {
            switch(mode)
            {
                case SemiAuto: recoil = RECOIL_SECOND_SEMIAUTO; break;
                case BurstFire: recoil = RECOIL_SECOND_BURST; break;
                case LongBurst: recoil = RECOIL_SECOND_LONGBURST; break;
                //NOTE: second single-shot and full bursts should NOT happen
            }
        }

        if(heavyWeapon)
            recoil*= RECOIL_HEAVY_MULTIPLIER;

        return recoil;
    }

    INLINE int GetCoverPenalty(Cover cover)
    {
        switch(cover)
        {
            case PartialCover: return RANGED_TARGET_PARTIAL_COVER;
            case GoodCover: return RANGED_TARGET_GOOD_COVER;
            case TotalCover: return RANGED_TARGET_TOTAL_COVER;
            default: return 0;
        }
    }

    INLINE float GetAcceptableLossPercentage(ProfessionalRating professionalRating)
    {
        switch(professionalRating)
        {
            case Untrained: return PROFESSIONALRATING_ACCEPTABLELOSSES_UNTRAINED;
            case SemiTrained: return PROFESSIONALRATING_ACCEPTABLELOSSES_SEMITRAINED;
            case Trained: return PROFESSIONALRATING_ACCEPTABLELOSSES_TRAINED;
            case Elite: return PROFESSIONALRATING_ACCEPTABLELOSSES_ELITE;
        }

        return PROFESSIONALRATING_ACCEPTABLELOSSES_UNTRAINED;
    }

    INLINE bool IsAcceptableLoss(ProfessionalRating professionalRating,
                            int initialBadGuys, int currentBadGuys)
    {
        return ((float)currentBadGuys / (float)initialBadGuys) > 
                    GetAcceptableLossPercentage(professionalRating);
    }

    //Functions that calculate

    INLINE int GetConcealabilityRating(Concealability conc)
    {
        switch(conc)
        {
            case Miniscule: return CONCEALABILITY_MINISCULE;
            case Tiny: return CONCEALABILITY_TINY;
            case Small: return CONCEALABILITY_SMALL;
            case Medium: return CONCEALABILITY_MEDIUM;
            case Big: return CONCEALABILITY_BIG;
            case Large: return CONCEALABILITY_LARGE;
            case Huge: return CONCEALABILITY_HUGE;
        }

        return 0;
    }

    INLINE int GetMinorNpcDamageTrack(int bodyRating, int willRating)
    {
        //take the higher of body or will
        if(willRating > bodyRating)
            bodyRating = willRating;

        return MINORNPC_DMG_BASE + (int)((float)bodyRating*MINORNPC_DMG_MULTIPLIER);
    }

    INLINE int GetPlayerStunDamageTrack(int willRating)
    {
        //pg. 65
        // 8 + (half willpower rounded up)
        int ret = STUN_DMG_BASE + (willRating/ STUN_DMG_DIVISOR);
        if(willRating%STUN_DMG_DIVISOR > 0)
            ret +=1;
        return ret;
    }

    INLINE int GetPlayerPhysicalDamageTrack(int bodRating)
    {
        //pg. 65
        // 8 + (half bod rounded up)
        int ret = PHYSICAL_DMG_BASE + (bodRating/ PHYSICAL_DMG_DIVISOR);
        if(bodRating%PHYSICAL_DMG_DIVISOR > 0)
            ret +=1;
        return ret;
    }

    INLINE int GetSoundDistancePenalty(float distanceInMeters)
    {
        //At the moment, this is based on rules on pg. 117, but maybe a formula would work better
        if(distanceInMeters <= DISTANCE_FOR_SOUND_NOT_IMMEDIATE_VICINITY)
            return SOUND_IMMEDIATE_VICINITY;
        else if(distanceInMeters > DISTANCE_FOR_SOUND_NOT_IMMEDIATE_VICINITY && distanceInMeters <DISTANCE_FOR_SOUND_FAR_AWAY)
            return SOUND_NOT_IMMEDIATE_VICINITY;
        else
            return SOUND_FAR_AWAY;
    }

    INLINE int GetSightDistancePenalty(float distanceInMeters)
    {
        //At the moment, this is based on rules on pg. 117, but maybe a formula would work better
        if(distanceInMeters <= DISTANCE_FOR_SIGHT_NOT_IMMEDIATE_VICINITY)
            return SIGHT_IMMEDIATE_VICINITY;
        else if(distanceInMeters > DISTANCE_FOR_SIGHT_NOT_IMMEDIATE_VICINITY && distanceInMeters <DISTANCE_FOR_SIGHT_FAR_AWAY)
            return SIGHT_NOT_IMMEDIATE_VICINITY;
        else
            return SIGHT_FAR_AWAY;
    }

    INLINE int GetFallingDamage(float metersFallen)
    {
        if(metersFallen <= 0.0f)
            return 0;
        else if(metersFallen > 0.0f && metersFallen < 3.0f)
            return 2;
        else if(metersFallen >= 3.0f && metersFallen < 6.0f)
            return 4;
        else if(metersFallen >= 6.0f && metersFallen < 8.0f)
            return 6;
        else
        {
            metersFallen -= 8.0f;
            return 6 + (int)(metersFallen/2.0f);
        }
    }

    INLINE int BuyHits(int totalRating)
    {
        //no dice == no hits
        if(totalRating <= 0)
            return 0;

        return totalRating/AUTO_SUCCESS_DIVISOR;
    }

    INLINE int RollHits(int totalRating)
    {
        //no dice == no hits
        if(totalRating <= 0)
            return 0;

        //make one "roll" per rating point
        int numHits = 0;
        int randomNumber;
        for(int i = 0; i < totalRating; ++i)
        {
            //A hit is a 5 or better on a d6, or 1 in 3 chance
            randomNumber = rand()%3;
            if(randomNumber == 2)
                numHits++;
        }

        return numHits;
    }

    INLINE int GetHealingEssencePenalty(int currentEssence)
    {
        return (INITIAL_ESS - currentEssence)/HEALING_ESSENCE_MULTIPLIER;
    }

    INLINE int GetPhysicalHealingPerDay(int bodyRating)
    {
        return (HEALING_PHYSICAL_MULTIPLIER*bodyRating)/HEALING_PHYSICAL_DIVISOR;
    }

    INLINE float GetTimeForOneBoxStunInRealHours(int willRating, int bodyRating)
    {
        int stunBoxesPerGameHour = (willRating + bodyRating)/HEALING_STUN_DIVISOR;
        return REAL_HOURS_PER_GAME_HOUR/(float)stunBoxesPerGameHour;
    }

    INLINE int GetWoundModifier(int numberOfBoxes)
    {
        return numberOfBoxes/WOUNDMODIFIER_DIVISOR;
    }

    INLINE int GetNaturalReachBonus(Race race)
    {
        if(race == Troll)
            return TROLL_REACH_BONUS;

        return 0;
    }
}

#endif