# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
#
#-------------------------------------------------------------------------
#
#  Usage:
#
#   Die  Roller: /dieroller rq
#
#   Skill  Roll: [1d100.skill(50,0,0)]         # ( skill%, modifer, MA% )
#
#   Parry  Roll: [1d100.parry(50,0,0,12)]      # ( skill%, modifer, MA%, Weapon/Shield AP )
#
#   Dodge  Roll: [1d100.parry(50,0,0)]         # ( skill%, modifer, MA% )
#
#   Attack Roll: [1d100.attack(50,0,0,2,9,3,0)]
#       ( skill%, modifer, MA%, min weap dam, max weap dam, dam bonus, truesword )
#
#   Sorcery Roll: [1d100.sorcery(90,   0,   3,   6,   1,   1,    1)]
#                               (sk, mod, pow, cer, int,  acc, mlt)
#
#
#
#   Skill Training Unlimited Roll: [1d100.trainskill(30,75)]       # (starting skill%, desired skill%)
#   Skill Training Cost Limited:   [1d100.trainskillcost(1000, 50) # (payment, starting skill%)
#   Skill Training Time Limited:   [1d100.trainskilltime(150, 50)  # (time, strting skill%)
#
#-------------------------------------------------------------------------
# --
#
# File: rq.py
# Version:
#   $Id: rq.py,v .1 pelwer
#
# Description: Runequest die roller originally based on Heroman's Hero Dieroller
#
#
# v.1 - pelwer - 2/5/2005
#  o Original release
# v.2 - pelwer - 10/30/2006
#  o Ported to openrpg+ by removing dependance on whrandom
#  o Fixed Riposte spelling
#  o Deleted sorcalc - never used
#  o Added Sorcery Fumble table to sorcery spell roller
#

from die import *
from time import time, clock
import random
from math import floor

__version__ = "$Id: runequest.py,v 1.4 2006/11/15 12:11:22 digitalxero Exp $"

# rq stands for "Runequest"

class runequest(std):
    
    def __init__(self,source=[]):
        std.__init__(self,source)

    # these methods return new die objects for specific options

    
    def skill(self,sk,mod,ma):
        return rqskill(self,sk,mod,ma)

    
    def parry(self,sk,mod,ma,AP):
        return rqparry(self,sk,mod,ma,AP)

    
    def dodge(self,sk,mod,ma):
        return rqdodge(self,sk,mod,ma)

    
    def attack(self,sk,mod,ma,mindam,maxdam,bondam,trueswd):
        return rqattack(self,sk,mod,ma,mindam,maxdam,bondam,trueswd)

    
    def sorcery(self,sk,mod,pow,cer,int,acc,mlt):
        return rqsorcery(self,sk,mod,pow,cer,int,acc,mlt)

    
    def trainskill(self,initial,final):
        return rqtrainskill(self,initial,final)

    
    def trainskillcost(self,cost,sk):
        return rqtrainskillcost(self,cost,sk)

    
    def trainskilltime(self,time,sk):
        return rqtrainskilltime(self,time,sk)

#  RQ Skill Training Cost/Time unlimited
#
# [1d100.trainskill(10,20)]
#          initial skill%, final skill%
#
# sk    = skill %
#
#
class rqtrainskill(std):
    
    def __init__(self,source=[],initial=11,final=0):
        std.__init__(self,source)
        self.s = initial
        self.f = final

    
    def __str__(self):
        myStr = "Unrestricted Training"

        if self.s == 0:
            myStr = "Initial training completed for Cost(50) Time(20) Skill(1 + modifier)"
        else:
            cost  = 0
            time  = 0
            myStr = "Training: "

            while self.s < self.f and self.s < 75:
                cost   += self.s * 5
                time   += self.s * 1
                self.s += random.uniform(1,4) + 1

            myStr  = "Training completed:\n"
            myStr += "\tCost(" + str(int(cost)) + ")\n"
            myStr += "\tTime(" + str(int(time)) + ")\n"
            myStr += "\tSkill(" + str(int(self.s)) + ")"

        return myStr


#  RQ Skill Training Cost Limited
#
# [1d100.trainskillcost(50,0)]
#          cost, skill%
#
# cost  = cash for training
# sk    = skill %
#
#
class rqtrainskillcost(std):
    
    def __init__(self,source=[],cost=11,sk=0):
        std.__init__(self,source)
        self.cost = cost
        self.sk   = sk

    
    def __str__(self):
        myStr = ""

        if self.sk == 0 and self.cost >= 50:
            myStr = "Initial training completed for Cost(50), Time(50), Skill(1 + modifier)"
        else:
            cost  = 0
            time  = 0
            icost = self.sk * 5

            myStr = "Training: "

            while (cost + icost) < self.cost:
                if self.sk >= 75:
                    break

                cost += icost
                time += self.sk * 1
                self.sk += random.uniform(1,4) + 1
                icost = self.sk * 5

            myStr  = "Training completed: "
            myStr += "Cost(" + str(int(cost)) + ") "
            myStr += "Time(" + str(int(time)) + ") "
            myStr += "Skill(" + str(int(self.sk)) + ")"

        return myStr


#  RQ Skill Training Time Limited
#
# [1d100.trainskilltime(50,0)]
#          time, skill%
#
# time  = time for training
# sk    = skill %
#
#
class rqtrainskilltime(std):
    
    def __init__(self,source=[],time=11,sk=0):
        std.__init__(self,source)
        self.time = time
        self.sk   = sk

    
    def __str__(self):
        myStr = ""

        if self.sk == 0 and self.time >= 20:
            myStr = "Initial training completed for Cost(50), Time(50), Skill(1 + modifier)"
        else:
            cost  = 0
            time  = 0
            itime = self.sk * 1

            myStr = "Trainingsss: "

            while (time + itime) < self.time:
                if self.sk >= 75:
                    break

                cost += self.sk * 5
                time += itime
                self.sk += random.uniform(1,4) + 1
                itime = self.sk * 5

            myStr  = "Training completed: "
            myStr += "Cost(" + str(int(cost)) + ") "
            myStr += "Time(" + str(int(time)) + ") "
            myStr += "Skill(" + str(int(self.sk)) + ")"

        return myStr

#  RQ Skill Roll
#
# [1d100.skill(50,0,0)]
#          skill%, modifer, ma%
#
# sk    = skill %
# mod   = modifier %
# ma    = martial arts %
# skill = sk + mod
#
# success   roll <= skill
#
# failure   roll > skill
#
# crit
#     push( @{$::Cre{Weapons}{$weap_cnt}}, POSIX::floor( skill/20 ) );
#
# special
#     push( @{$::Cre{Weapons}{$weap_cnt}}, POSIX::floor( $skill/5 ) );
#
# fumble: if ( $skill > 100 ) { $fum = 0; } else { $fum = 100 - $skill; }
#             $fum = 100 - POSIX::floor( $fum/20 );
#             if ( $fum == 100 ) { $fum = '00'; };
#
class rqskill(std):
    
    def __init__(self,source=[],sk=11,mod=0,ma=0):
        std.__init__(self,source)
        self.sk  = sk
        self.mod = mod
        self.ma  = ma

    
    def is_success(self):
        return (((self.sum() <= (self.sk + self.mod)) or (self.sum() <= 5)) and (self.sum() <= 95))

    
    def is_ma(self):
        return (self.sum() <= self.ma)

    
    def is_special(self):
        return (self.sum() <= int(floor((self.sk + self.mod)/5)))

    
    def is_critical(self):
        return (self.sum() <= int(floor((self.sk + self.mod) / 20)))

    
    def is_fumble(self):
        if ( self.sk >= 100 ):
            fum = 0
        else:
            fum = (100 - self.sk )
        final_fum = ( 100 - int( floor( fum/20  ) ) )
        return (  self.sum() >= final_fum )

    
    def __str__(self):
        strAdd="+"
        swapmod= self.mod
        if self.mod < 0:
            strAdd= "-"
            swapmod= -self.mod
        modSum = self.sum()
        # build output string
        myStr = " (" + str(modSum) + ")"
        myStr += " vs [" + str(self.sk) + strAdd + str(swapmod) + "]"

        if self.is_fumble(): myStr += " <b><font color=red>Fumble!</font></b>"
        elif self.is_critical(): myStr += " <b><font color=green>Critical!</font></b>"
        elif self.is_special(): myStr += " <i><font color=green>Special!</font></i>"
        elif self.is_success() and self.is_ma(): myStr += " <i><font color=green>Special!</font></i>"
        elif self.is_success(): myStr += " <font color=blue>Success!</font>"
        else: myStr += " <font color=red>Failure!</font>"

        Diff = self.sk - modSum
        myStr += " </font>"

        return myStr

#
# RQ Parry Roll
#
# same as skill but with fumble dice and armor points
#
# [1d100.parry(50,0,0,12)]
#             skill%, modifer, ma%, Weapon AP
#

class rqparry(std):
    
    def __init__(self,source=[],sk=11,mod=0,ma=0,AP=0):
        std.__init__(self,source)
        self.sk = sk
        self.mod = mod
        self.ma  = ma
        self.AP = AP

    
    def is_success(self):
        return (((self.sum() <= (self.sk + self.mod)) or (self.sum() <= 5)) and (self.sum() <= 95))

    
    def is_special(self):
        return (self.sum() <= int(floor((self.sk + self.mod) / 5)))

    
    def is_ma(self):
        return (self.sum() <= self.ma)

    
    def is_riposte(self):
        return (self.sum() <= (self.ma / 5))

    
    def is_critical(self):
        return ( (  self.sum() <= int( floor( ( self.sk + self.mod  )/20 ) ) ) )

    
    def is_fumble(self):
        if ( self.sk >= 100 ):
            fum = 0
        else:
            fum = (100 - self.sk )
        final_fum = ( 100 - int( floor( fum/20  ) ) )
        return (  self.sum() >= final_fum )

    
    def __str__(self):

        # get fumble roll result in case needed
        fum_roll = random.randint(1,100)

        # get special AP
        spec_AP = int( floor ( self.AP * 1.5 ) )

        # figure out +/- for modifer
        strAdd="+"
        swapmod= self.mod
        if self.mod < 0:
            strAdd= "-"
            swapmod= -self.mod
        modSum = self.sum()

        # build output string
        myStr = " (" + str(modSum) + ")"
        myStr += " vs [" + str(self.sk) + strAdd + str(swapmod) + "]"

        if self.is_fumble():
            myStr += " <b><font color=red>Fumble!</font>  See Fumble Chart [" + str(fum_roll) + "]</b>"
        elif self.is_critical() and self.is_riposte():
            myStr += " <b><font color=green>Critical!</font> All damage blocked!</b>"
            myStr += " Riposte next SR"
        elif self.is_critical():
         myStr += " <b><font color=green>Critical!</font> All damage blocked!</b>"
        elif self.is_special and self.is_riposte():
            myStr += " <i><font color=green>Special!</font> Weapon/Shield AP [" + str(spec_AP) + "]</i>"
            myStr += " Riposte next SR"
        elif self.is_special():
            myStr += " <i><font color=green>Special!</font> Weapon/Shield AP [" + str(spec_AP) + "]</i>"
        elif self.is_success() and self.is_ma():
            myStr += " <i><font color=green>Special!</font> Weapon/Shield AP [" + str(spec_AP) + "]</i>"
        elif self.is_success():
            myStr += " <font color=blue>Success!</font> Weapon/Shield AP [" + str(self.AP) + "]"
        else:
            myStr += " <font color=red>Failure!</font>"

        Diff = self.sk - modSum
        myStr += " </font>"

        return myStr

# RQ Dodge Roll
#
# same as skill but with fumble dice and armor points
#
# [1d100.parry(50,0,0)]
#             skill%, modifer, ma%
#

class rqdodge(std):
    
    def __init__(self,source=[],sk=11,mod=0,ma=0,AP=0):
        std.__init__(self,source)
        self.sk = sk
        self.mod = mod
        self.ma  = ma
        self.AP = AP

    
    def is_success(self):
        return (((self.sum() <= (self.sk + self.mod)) or (self.sum() <= 5)) and (self.sum() <= 95))

    
    def is_special(self):
        return (self.sum() <= int(floor((self.sk + self.mod) / 5)))

    
    def is_ma(self):
        return (self.sum() <= self.ma)

    
    def is_riposte(self):
        return (self.sum() <= (self.ma / 5))

    
    def is_critical(self):
        return ( (  self.sum() <= int( floor( ( self.sk + self.mod  )/20 ) ) ) )

    
    def is_fumble(self):
        if ( self.sk >= 100 ):
            fum = 0
        else:
            fum = (100 - self.sk )
        final_fum = ( 100 - int( floor( fum/20  ) ) )
        return (  self.sum() >= final_fum )

    
    def __str__(self):

        # get fumble roll result in case needed
        fum_roll = random.randint(1,100)

        # get special AP
        spec_AP = int( floor ( self.AP * 1.5 ) )

        # figure out +/- for modifer
        strAdd="+"
        swapmod= self.mod
        if self.mod < 0:
            strAdd= "-"
            swapmod= -self.mod
        modSum = self.sum()

        # build output string
        myStr = " (" + str(modSum) + ")"
        myStr += " vs [" + str(self.sk) + strAdd + str(swapmod) + "]"

        if self.is_fumble():
            myStr += " <b><font color=red>Fumble!</font>  See Fumble Chart [" + str(fum_roll) + "]</b>"
        elif self.is_critical() and self.is_riposte():
            myStr += " <b><font color=green>Critical!</font> All damage dodged!</b>"
            myStr += " Riposte on next SR"
        elif self.is_critical():
            myStr += " <b><font color=green>Critical!</font> All damage dodged!</b>"
        elif self.is_special and self.is_riposte():
            myStr += " <i><font color=green>Special!</font> Damage dodged</b>"
            myStr += " Riposte on next SR"
        elif self.is_special():
            myStr += " <i><font color=green>Special!</font> Damage dodged</b>"
        elif self.is_success() and self.is_ma():
            myStr += " <i><font color=green>Special!</font> Damage dodged</b>"
        elif self.is_success():
            myStr += " <font color=blue>Success!</font> Damage dodged</b>"
        else:
            myStr += " <font color=red>Failure!</font>"

        Diff = self.sk - modSum
        myStr += " </font>"

        return myStr



#
# RQ Attack Roll
#
# same as skill but with fumble dice and armor points
#
# [1d100.attack(50,0,0,2,9,3,1)]
#             skill%, modifer, ma%, min weap dam, max weap dam, dam bonus, truesword_enabled
#
class rqattack(std):
    
    def __init__(self,source=[],sk=11,mod=0,ma=0,mindam=0,maxdam=0,bondam=0,trueswd=0):
        std.__init__(self,source)
        self.sk = sk
        self.mod = mod
        self.ma  = ma
        self.mindam = mindam
        self.maxdam = maxdam
        self.bondam = bondam
        self.trueswd = trueswd

    
    def is_success(self):
        return (((self.sum() <= (self.sk + self.mod)) or (self.sum() <= 5)) and (self.sum() <= 95))

    
    def is_ma(self):
        return (self.sum() <= self.ma)

    
    def is_special(self):
        return (self.sum() <= int(floor((self.sk + self.mod) / 5)))

    
    def is_critical(self):
        return ((self.sum() <= int(floor((self.sk + self.mod) / 20))))

    
    def is_supercritical(self):
        return (self.sum() == 1)

    
    def is_fumble(self):
        if ( self.sk >= 100 ):
            fum = 0
        else:
            fum = (100 - self.sk )
        final_fum = ( 100 - int( floor( fum/20  ) ) )
        return (  self.sum() >= final_fum )

    
    def __str__(self):

        # get fumble roll result in case needed
        fum_roll = random.randint(1,100)

        # get hit location roll result in case needed
        location = random.randint(1,20)
        myStr = " to the ["+ str(location) + "] "
        if location < 5:
            myStr += "<B>Right Leg</B>"
        elif location < 9:
            myStr += "<B>Left Leg</B>"
        elif location < 12:
            myStr += "<B>Abdomen</B>"
        elif location < 13:
            myStr += "<B>Chest</B>"
        elif location < 16:
            myStr += "<B>Right Arm</B>"
        elif location < 19:
            myStr += "<B>Left Arm</B>"
        else:
            myStr += "<B>Head</B>"
        hit_loc = myStr


        # get normal damage in case needed
        norm_damage = random.randint(self.mindam*(self.trueswd+1),self.maxdam*(self.trueswd+1)) + self.bondam
        norm_damage_string  = "{" + str( self.mindam*(self.trueswd+1) ) + "-"
        norm_damage_string += str(self.maxdam*(self.trueswd+1)) + "+" + str(self.bondam)
        norm_damage_string += "}[" + str(norm_damage) + "] "

        # get special/critical damage in case needed
        crit_damage = random.randint( self.mindam*(self.trueswd+2), self.maxdam*(self.trueswd+2) ) + self.bondam
        crit_damage_string = "{" + str( self.mindam*(self.trueswd+2) ) + "-" + str(self.maxdam*(self.trueswd+2)) + "+" + str(self.bondam) + "}[" + str(crit_damage) + "] "

        # get supercritical damage in case needed
        super_damage = norm_damage + self.maxdam
        super_damage_string  = "{" + str( self.mindam*(self.trueswd+1) ) + "-"
        super_damage_string += str(self.maxdam*(self.trueswd+1)) + "+" + str(self.maxdam)
        super_damage_string += "+" + str(self.bondam) + "}[" + str(super_damage) + "] "

        # figure out +/- for modifer
        strAdd="+"
        swapmod= self.mod
        if self.mod < 0:
            strAdd= "-"
            swapmod= -self.mod
        modSum = self.sum()

        # build output string
        myStr = " (" + str(modSum) + ")"
        myStr += " vs [" + str(self.sk) + strAdd + str(swapmod) + "]"

        if self.is_fumble():
            myStr += " <b><font color=red>Fumble!</font>  See Fumble Chart [" + str(fum_roll) + "]</b>"
        elif (self.is_supercritical() and self.is_success()):
            myStr += " <b><font color=green>Super Critical!</font></b> Damage: " + str(super_damage_string) + "<u>No Armor Stops</u>" + str(hit_loc)
        elif (self.is_critical() and self.is_success()):
            myStr += " <b><font color=green>Critical!</font></b> Damage: " + str(crit_damage_string) + "<u>No Armor Stops</u>" + str(hit_loc)
        elif ( self.is_special() and self.is_success() ):
            myStr += " <i><font color=green>Special!</font></i> Damage: " + str(crit_damage_string) + str(hit_loc)
        elif (self.is_success() and self.is_ma()):
            myStr += " <i><font color=green>Special!</font></i> Damage: " + str(crit_damage_string) + str(hit_loc)
        elif self.is_success():
            myStr += " <font color=blue>Success!</font> Damage: " + str(norm_damage_string) + str(hit_loc)
        else:
            myStr += " <font color=red>Failure!</font>"

        return myStr

#
#
#   Sorcery Roll: [1d100.sorcery(90,   10,  5,   4,   3,   2,    1)]
#                               (sk, mod, pow, cer, int,  acc, mlt)
#
# Ceremony: (+1d6% per strike rank spent on ceremony)
# Intensity: (-3% per point of Intensity)
# Duration: (-4% per point of Duration)
# Range: (-5% per point of Range)
# Multispell: (-10% per each spell over 1)
# Acceleration: (-5% per point of Acceleration)
# Hold: (-2% per point in spell Held)
#
class rqsorcery(std):
    
    def __init__(self,source=[],sk=11,mod=0,pow=0,cer=0,int=0,acc=0,mlt=0):
        std.__init__(self,source)
        self.sk  = sk   # sorcery skill
        self.mod = mod  # additional modifier ( from duration, range, etc )
        self.pow = pow  # boost pow and additional pow ( from duration, range, etc )
        self.cer = cer  # ceremony d6
        self.int = int  # intensity ( -3% )
        self.acc = acc  # accelerate ( -5% )
        self.mlt = mlt  # multispell ( -10% )

    
    def is_success(self):
        return (((self.sum() <= (self.sk + self.mod)) or (self.sum() <= 5)) and (self.sum() <= 95))

    
    def is_special(self):
        return ( (  self.sum() <= int( floor( ( self.sk + self.mod  )/5  ) ) ) )

    
    def is_critical(self):
        return ( (  self.sum() <= int( floor( ( self.sk + self.mod  )/20 ) ) ) )

    
    def is_fumble(self):
        if ( self.sk >= 100 ):
            fum = 0
        else:
            fum = (100 - self.sk )
        final_fum = ( 100 - int( floor( fum/20  ) ) )
        return (  self.sum() >= final_fum )

    
    def __str__(self):

        # get fumble roll result in case needed
        fum_roll = random.randint(2,12)
        if fum_roll == 12 :
            fum_string = "<br /><font color=purple>Caster temporarily forgets spell. Make an INTx5 roll each day to remember.</font>"
        if fum_roll == 11 :
            fum_string = "<br /><font color=purple>Caster temporarily forgets spell. Make an INTx5 roll each hour to remember.  </font>"
        if fum_roll == 10 :
            fum_string = "<br /><font color=purple>Spell produces reverse of the intended effect.  </font>"
        if fum_roll == 9 :
            fum_string = "<br /><font color=purple>Caster is Stunned. Roll INTx3 to recover at SR 10 each round.  </font>"
        if fum_roll == 8 :
            fum_string = "<br /><font color=purple>Caster takes 2D6 Damage to THP  </font>"
        if fum_roll == 7 :
            fum_string = "<br /><font color=purple>Spell produces reverse of the intended effect at 2x Intensity.  </font>"
        if fum_roll == 6 :
            fum_string = "<br /><font color=purple>Spell is cast on companions (if harmful) or on random nearby foes (if beneficial)  </font>"
        if fum_roll == 5 :
            fum_string = "<br /><font color=purple>Caster takes 1d6 Damage to Head  </font>"
        if fum_roll == 4 :
            fum_string = "<br /><font color=purple>Spell is cast on caster (if harmful) or on random nearby foe (if beneficial)  </font>"
        if fum_roll == 3 :
            fum_string = "<br /><font color=purple>Caster takes 1d6 Damage to THP  </font>"
        if fum_roll == 2 :
            fum_string = "<br /><font color=purple>Caster takes 1 point of Damage to Head  </font>"

        # roll ceremony
        ceremony_roll = random.randint( self.cer, (self.cer*6) )

        # subtract manipulations
        extra_mod = self.mod
        self.mod += ceremony_roll - self.int*3 - self.acc*5 - self.mlt*10

        # add up power cost
        extra_pow = self.pow
        self.pow += self.int + self.mlt + self.acc
        special_pow = int( floor( ( self.pow )/2  ) )

        # figure out +/- for modifer
        strAdd="+"
        swapmod= self.mod
        if self.mod < 0:
            strAdd= "-"
            swapmod= -self.mod
        modSum = self.sum()

        # build output string
        myStr = " (" + str(modSum) + ")"
        myStr += " vs [" + str(self.sk) + strAdd + str(swapmod) + "]"

        if self.is_fumble():
            myStr += " <b><font color=red>Fumble!</font>  POW Cost: [" + str(self.pow) + "],</b> " + fum_string
        elif self.is_critical():
            myStr += " <b><font color=green>Critical!</font></b> POW Cost: [1] "
        elif self.is_special():
            myStr += " <i><font color=green>Special!</font></i> POW Cost: [" + str(special_pow) + "] "
        elif self.is_success():
            myStr += " <font color=blue>Success!</font> POW Cost: [" + str(self.pow) + "] "
        else:
            myStr += " <font color=red>Failure!</font> POW Cost: [1]"

        # print spell details
        myStr += "<br /> --- Other Modifiers:["    + str( extra_mod     ) + "], "
        myStr += "Extra POW:[" + str( extra_pow     ) + "], "
        myStr += "Ceremony:[+"          + str( ceremony_roll ) + "%], "
        myStr += "Intensity(-3):["      + str( self.int      ) + "], "
        myStr += "Accelerate(-5):["     + str( self.acc      ) + "], "
        myStr += "Multispell(-10):["    + str( self.mlt      ) + "] ---"

        return myStr