runescape

import math
from pychart import *

theme.get_options()

class Graph(object):

    def __init__(self):
        self.data1 = []
        self.data2 = []
        self.data3 = []
        self.data4 = []
        self.xaxis = axis.X(format="/a-60/hL%d", tic_interval = 20, label="Stuff")
        self.yaxis = axis.Y(tic_interval = 20, label="Value")
        self.ar = area.T(x_axis=self.xaxis, y_axis=self.yaxis, y_range=(0,None))
        self.label = ["", "", "", ""]

    def getData1(self):
        return self.data1
    def getData2(self):
        return self.data2
    def getData3(self):
        return self.data3
    def getData4(self):
        return self.data4
    def addData1(self, dataX, dataY):
        self.data1.append((dataX,dataY))
    def addData2(self, dataX, dataY):
        self.data2.append((dataX,dataY))
    def addData3(self, dataX, dataY):
        self.data3.append((dataX,dataY))
    def addData4(self, dataX, dataY):
        self.data4.append((dataX,dataY))
    def setLineLabel(self,label,plotNo):
        if plotNo < 4 and plotNo >= 0:
            self.label[plotNo] = label

    def plotData(self):
        # Filter repeated combat levels
        prevVal=self.data1[0][0] # do for data1
        removedVals = []
        for i in range(0,len(self.data1)):
            if prevVal==self.data1[i][0]:
                removedVals.append(self.data1[i])
            prevVal=self.data1[i][0]
        for i in range(0,len(removedVals)):
            self.data1.remove(removedVals[i])
        prevVal=self.data2[0][0] # do for data2
        removedVals = []
        for i in range(0,len(self.data2)):
            if prevVal==self.data2[i][0]:
                removedVals.append(self.data2[i])
            prevVal=self.data2[i][0]
        for i in range(0,len(removedVals)):
            self.data2.remove(removedVals[i])
        prevVal=self.data3[0][0] # do for data3
        removedVals = []
        for i in range(0,len(self.data3)):
            if prevVal==self.data3[i][0]:
                removedVals.append(self.data3[i])
            prevVal=self.data3[i][0]
        for i in range(0,len(removedVals)):
            self.data3.remove(removedVals[i])
        prevVal=self.data4[0][0] # do for data4
        removedVals = []
        for i in range(0,len(self.data4)):
            if prevVal==self.data4[i][0]:
                removedVals.append(self.data4[i])
            prevVal=self.data4[i][0]
        for i in range(0,len(removedVals)):
            self.data4.remove(removedVals[i])
        # Finally plot the results on the graph
        plot1 = line_plot.T(label=self.label[0], data=self.data1, ycol=1, tick_mark=tick_mark.default)
        plot2 = line_plot.T(label=self.label[1], data=self.data2, ycol=1, tick_mark=tick_mark.default)
        plot3 = line_plot.T(label=self.label[2], data=self.data3, ycol=1, tick_mark=tick_mark.default)
        plot4 = line_plot.T(label=self.label[3], data=self.data4, ycol=1, tick_mark=tick_mark.default)
        self.ar.add_plot(plot1,plot2,plot3)
        self.ar.draw()

class Player(object):

    def __init__(self):
        """
        attack/strength/defence/hp/prayer levels are created for the player
        we also assume a reasonable strength bonus for the stats
        prayer boosts are initialised
        """
        self.attack = 60
        self.strength = 60
        self.defence = 1
        self.hp = 10
        self.prayer = 1
        self.strengthBonus = 86
        self.prayerMultiplier = 1.00

    def getAttack(self):
        return self.attack
    def getStrength(self):
        return self.strength
    def getDefence(self):
        return self.defence
    def getHp(self):
        return self.hp
    def getPrayer(self):
        return self.prayer
    def getCombatLevel(self):
        """
        we calculate the combat level with the given stats assuming the account
        is melee based
        """
        base  = 0.25*(self.defence+self.hp+math.floor(self.prayer/2))
        melee = 0.325*(self.attack+self.strength)
        combat = math.floor(base+melee)
        return combat
    def getPrayerBoost(self):
        """
        find which prayer is the best we can use
        and set our prayer multiplier to that
        to be used in damage calculations
        """
        if self.prayer >= 31:
            self.prayerMultiplier = 1.15
        elif self.prayer >= 13:
            self.prayerMultiplier = 1.10
        elif self.prayer >= 4:
            self.prayerMultiplier = 1.05
        else:
            self.prayerMultiplier = 1.00
    def getMaxHit(self):
        """
        melee max hit is calculated and returned as a floating point (pre eoc damage used cos YOLO)
        """
        effectiveStrenth = self.strength + math.floor(self.strength*0.15) + 5 # Add super strength pot
        self.getPrayerBoost()
        effectiveStrenth = effectiveStrenth * self.prayerMultiplier + 8 + 3 # Add prayer boosts and Aggressive strength bonus
        maxHit = math.floor((5 + effectiveStrenth + ((effectiveStrenth*self.strengthBonus)/64))/1)/10
        return maxHit

    def setAttack(self, attack):
        self.attack = attack
    def setStrength(self, strength):
        self.strength = strength
    def setAutoStrength(self, prayer):
        combatLevel = self.getCombatLevel() # save to be able to keep combat the same
        self.prayer = prayer
        while combatLevel != self.getCombatLevel():
            self.strength -= 1
            self.setAutoHp()
    def setDefence(self, defence):
        self.defence = defence
    def setHp(self, hp):
        self.hp = hp
    def setAutoHp(self):
        """
        sets the minimum amount of hp xp given the combat stats
        (this does not include quest rewards)
        TODO: ADD QUEST REWARD XP TO FIX THIS
        """
        totalCombatXp = self.xpForLevel(self.attack) # add up how much melee xp in total
        totalCombatXp += self.xpForLevel(self.strength)
        totalCombatXp += self.xpForLevel(self.defence)
        totalCombatXp *= 1.33 # hp gets less xp per damage
        totalCombatXp += 1154 # hp starts at 10
        for i in range(1,99):
            if self.xpForLevel(i) > totalCombatXp:
                self.hp = i-1
                break
    def setPrayer(self, prayer):
        self.prayer = prayer
    def setAll(self, attack, strength, defence, prayer):
        """
        faster/cleaner way to set all params
        """
        self.attack = attack
        self.strength = strength
        self.defence = defence
        self.prayer = prayer

    def displayMaxHit(self):
        print "Strength: " + str(self.strength) + " Hp: " + str(self.hp) + " Prayer: " + str(self.prayer)
        print "Combat Level: " + str(self.getCombatLevel())
        print "Max Hit: " + str(self.getMaxHit())
    def plotResults(self):
        if self.prayer == 1:
            graph.addData1(self.getCombatLevel(),self.getMaxHit())
        if self.prayer == 4:
            graph.addData2(self.getCombatLevel(),self.getMaxHit())
        if self.prayer == 13:
            graph.addData3(self.getCombatLevel(),self.getMaxHit())
        if self.prayer == 31:
            graph.addData4(self.getCombatLevel(),self.getMaxHit())
    def xpForLevel(self,level):
        """
        calculate how much xp you need for a given level from 1
        """
        total = 0
        for i in range(1,level):
            total += math.floor(i + 300 * math.pow(2, i / 7.0))
        return math.floor(total/4)
    # def calcCrossoverLevels(self):


graph = Graph()
graph.setLineLabel("1",1)
graph.setLineLabel("4",2)
graph.setLineLabel("13",3)
graph.setLineLabel("31",4)
player = Player() # initialise objects

for i in range(60,100):
    player.setStrength(i)
    player.setPrayer(1)
    player.setAutoHp()
    player.plotResults()
    # player.displayMaxHit()
    for i in [4,13,31]:
        player.setAutoStrength(i)
        player.plotResults()
        # player.displayMaxHit()
graph.plotData()

"""
CALC AT WHICH STRENGTH LEVELS IT IS BEST TO LEVEL UP PRAYER
TO DO THIS I NEED
A WAY TO CALC COMBAT LEVEL  [DONE]
A WAY TO CALC MAX HIT       [DONE]
ITERATE FOR EACH STRENGTH   [DONE]
LEVEL PAST 60 UP TO 99 THE
MAX HITS WITH/WITHOUT PRAYERS
DISPLAY RESULTS NICELY      [DONE] (COULD BE IMPROVED)
CALC CROSSOVER LEVELS       [TODO]
"""