IiPunch - Monk Guide

# -*- coding: utf-8 -*-
"""
Created on Thu Jul  3 23:21:05 2014

@author: toto
"""

"Probabilité de skill chain avec son voisin"

"Simulation d'un round"

from math import *
from random import *


m,M,S,N_ws=0,pow(10,4),0,0

while m<=M :
    da,tp1,tp2,tp_base,acc,rounds=0.25,0.0,0.0,5.0,0.95,0
    time_round,time_ws,T=106/60,2.0,0
    n,N=0,100
    list1,list2=[],[]


    while n<=N :
        while tp1<100 :
            if random()<=da :
                if random()<acc :
                    tp1=tp1+tp_base
                if random()<acc :
                    tp1=tp1+tp_base
            else :
                if random()<acc :
                    tp1=tp1+tp_base
            if random()<=da :
                if random()<acc :
                    tp1=tp1+tp_base
                if random()<acc :
                    tp1=tp1+tp_base
            else :
                if random()<acc :
                    tp1=tp1+tp_base
            T+=time_round
        T,tp1=T+time_ws,2*tp_base
        list1.append(T)
        n+=1
        N_ws+=1
    T,n=0.0,0
    while n<=N :
        while tp2<100 :
            if random()<=da :
                if random()<acc :
                    tp2=tp2+tp_base
                if random()<acc :
                    tp2=tp2+tp_base
            else :
                if random()<acc :
                    tp2=tp2+tp_base
            if random()<=da :
                if random()<acc :
                    tp2=tp2+tp_base
                if random()<acc :
                    tp2=tp2+tp_base
            else :
                if random()<acc :
                    tp2=tp2+tp_base
            T+=time_round
        T,tp2=T+time_ws,2*tp_base
        list2.append(T)
        n+=1
        N_ws+=1
    K=min(len(list1),len(list2))
    
    L=[ abs(list1[j]-list2[j])<6  for j in range(K)]
    S+=sum(L)
    m+=1
print(S/(N_ws/2))

# -*- coding: utf-8 -*-
"""
Created on Fri Jul  4 20:04:12 2014

@author: Pchan™
"""

from math import *
from random import *

time_round,time_ws=106,120-106 #delay between rounds and delay after ws
# the programm automatically adds time_round after a round so I only
# have to add 2 seconds minus time_round (unsure about this)

acc,base_tp=0.95,5 # capped accuracy and tp per fist/kick
ka_rate,da_rate,ta_rate,qa_rate=0.20,0.18,0.02,0.0 #multiattack rates


# this class represents a monk  behaviour and has methods
# to generate a round, add TP, do a ws and give a tp return etc

class MNK(object) :
    def __init__(self, TP=0.0, timeline=0,status='off',wst=-1000,nom='joueur') :
      self._tp=TP #your current tp
      self._tm=timeline #the time (date) at which you have this tp
      self._scstatus=status # unused
      self._lastws=wst # the last time you did a WS
      self._name=nom # cosmetic
    def hit(self,n=1,a=base_tp) : # gives tp for a hit after checking for acc
        for i in range(n) :
            if random()<acc :
                self._tp+=a
    def kick(self) : # tp for kick attacks
        if random()<ka_rate :
            self.hit()
    def multi(self) : # calculates what multi hits you got on this round
    #and gives tp accordingly
        self.hit()
        if random()<qa_rate :
            self.hit(3)
        elif random()<ta_rate :
            self.hit(2)
        elif random()<da_rate :
            self.hit()
    def affiche(self) : # debug
        print(self._name,self._tp,self._tm,self._lastws)
    def genere(self) : #handles the behaviour for a round : tp, delay, date of ws
        self.kick()
        self.multi() # multiple attack on fist 1
        self.multi() # multiple attack on fist 2        
        self._tm+=time_round
        if self._tp >=100 :
            self._lastws=self._tm
#        self.affiche()
    def ws(self) : #handles tp and delay on ws
        self._tp=0
        self.multi() # first hit
        self.multi() # second hit
        self.hit(2,1) #add'l hits on WS
        self._tm+=time_ws
    def scdisable(self) : # resets time of ws to  default value; used after a sc happened
        self._lastws=-1000
#        print("skillchain"+" "+self._name)

        
R1=MNK() #starts MNK 1 behaviour
R1._name='M1'
R1.affiche()
R2=MNK() #starts MNK 2 behaviour
R2._name='M2'
R2.affiche()
N=10**5 #number of ws form mnks 1 or 2 at which the program will end
nb_ws,nb_sc=0,0 # number of skillchains and weapon skills
scstatus='off' #unused

while nb_ws<=N :
    if R1._tp>=100 : # if mnk1 has TP...
        R1.ws()
        # next conditions checks wether both mnks are in range time wise for a ws to proc
        if R1._lastws>=R2._lastws and R1._lastws<=R2._lastws+360 and R1._lastws>=0 :
            #R1 closing SC with R2
            R1.scdisable() #resets tps
            R2.scdisable()
            nb_sc+=1 #one more skillchain
        nb_ws+=1#one more weapon skill
    if R2._tp>=100 : #same
        R2.ws()
        if R2._lastws>=R1._lastws and R2._lastws<=R1._lastws+360 and R2._lastws>=0 :
            #R2 closing SC with R1
            R2.scdisable()
            R1.scdisable()
            nb_sc+=1
        nb_ws+=1
        
# the important part : we need to make sure that both mnks behaviours evolve together
# if MNK1's state (date) is happening a few seconds prior to mnk2 then one should allows mnk1
# to do more rounds (should be only 1 or 2 usually) to mathc more or less mnk2's time, and conversely
        
    if R1._tm<=R2._tm : # align MNK1 on MNK2, this means that mnk2's timer is a bit after mnk1
        R1.genere() 
    if R2._tm<=R1._tm :#same
        R2.genere()
    
    
print(nb_sc/nb_ws) #this is the number of skillchains performed by the two mnks - one sc should be counted only once
# nb_ws is the total number of ws performed by bith mnks. This fraction will represent
# the portion of skillchains amongs all ws. mnk1 and mnk2 should close half of the sc each. 

open System

// test parameters
let max_delay = 1000000

let time_gap = 0 // how long a mnk will delay weaponskilling in order to complete a skillchain
let mutable tp_gap = 0
let skillchainMobFactor = 1.30 // individual mob family multiplier
let haste = 40


// fixed values
let rnd = System.Random()
let minSkillchainDelay = 60*1 // skillchain is possible after 1 second after the previous weaponskill
let maxSkillchainDelay = 60*6 // skillchain is possible within 6 seconds of previous weaponskill
let skillchainBonus = 1.12 // job trait
let minWeaponskillTP = 1000

// utility
let tp_by_delay(delay:int) =
    if delay < 76 then
        17 + delay * 489/2000
    else
        32 + (delay - 12) * 11/64


let get_hits_per_hand(qaRate, taRate, daRate) =
    if rnd.Next(100) < qaRate then 4
    elif rnd.Next(100) < taRate then 3
    elif rnd.Next(100) < daRate then 2
    else 1

let get_hits(qaRate, taRate, daRate) =
    get_hits_per_hand(qaRate, taRate, daRate) + get_hits_per_hand(qaRate, taRate, daRate)

let get_kicks(kaRate) =
    if rnd.Next(100) < kaRate then 1
    else 0

// per-hit damage functions
let get_ratio_dmg(baseD:int, ratio:float) =
    (int ((float baseD) * ratio))


let get_dmg(baseD:int, ratio:float, critrate:int) =
    let cRatio =
        if rnd.Next(100) < critrate then
            Math.Min(ratio + 1.0, 3.0)
        else
            ratio

    get_ratio_dmg(baseD, cRatio)


// victory smite crit bonus
let ws_crit_bonus(tp) =
    if tp > 2000 then
        25 + 20 * (tp - 2000) / 1000
    else
        10 + 15 * (tp - 1000) / 1000


let mutable skillchainPending = false
let mutable skillchainInitiation = 0

// user values
type Mnk(name:string, delay:int) = 
    let name = name
    let hitRate = 95
    let critRate = 25
    let attackRatio = 2.0
    let baseD = 210

    let daRate = 27 // war sub, asperity, blade/steel, qaaxo body, epona, atheling
    let taRate = 7 // qaaxo body, epona, windbuffet
    let qaRate = 1 // windbuffet
    let kaRate = 33 // base, merits, hesy+1 legs

    let store_tp = 10
    let ws_store_tp = 7

    let mutable tp = 0
    let mutable next_round = 0
    
    let mutable melee_hits = 0
    let mutable melee_dmg = 0
    let mutable ws_hits = 0
    let mutable ws_dmg = 0
    let mutable sc_hits = 0
    let mutable sc_dmg = 0

    let delay_limit = ((delay - 280) + 480) * 20 / 100
    let round_delay = Math.Max(delay * (100 - haste) / 100, delay_limit)

    let tpPerHit = tp_by_delay(delay/2) * (100 + store_tp) / 100
    let ws_tpPerHit = tp_by_delay(delay/2) * (100 + ws_store_tp) / 100

    let delay = delay

    member this.TP
        with get() = tp

    member this.Punch(atDelay:int) =
        if next_round = atDelay then
            let all_hits = get_hits(qaRate, taRate, daRate)
            let kicks = get_kicks(kaRate)
            for hit in [ 1 .. all_hits ] do
                if rnd.Next(100) < hitRate then
                    melee_dmg <- melee_dmg + get_dmg(baseD, attackRatio, critRate)
                    tp <- tp + tpPerHit
                    melee_hits <- melee_hits + 1
            for hit in [ 1 .. kicks ] do
                if rnd.Next(100) < hitRate then
                    melee_dmg <- melee_dmg + get_dmg(baseD, attackRatio, critRate)
                    tp <- tp + tpPerHit
                    melee_hits <- melee_hits + 1
            next_round <- next_round + round_delay
        if tp > 3000 then
            tp <- 3000
        ()

    member this.ReadyToWeaponskill(atDelay:int, other_mnk:Mnk) =
        if tp >= minWeaponskillTP then
            if skillchainPending then
                if (atDelay - skillchainInitiation) < minSkillchainDelay then
                    false
                else
                    true
            elif other_mnk.TP < minWeaponskillTP && other_mnk.TP > (minWeaponskillTP - tp_gap) then
                false
            else
                true
        else
            false

    member this.Weaponskill(atDelay:int) =
        let extra_hits = get_hits(qaRate, taRate, daRate) - 2
        let more_hits = 2
        let ws_baseD = baseD + 200
        let ws_critrate = critRate + ws_crit_bonus(tp)
        tp <- 0

        let mutable this_ws_dmg = 0

        // main hit (with fTP)
        if rnd.Next(100) < hitRate then
            this_ws_dmg <- this_ws_dmg + get_dmg((int ((float ws_baseD) * 2.25)), attackRatio, critRate)
            tp <- tp + ws_tpPerHit
        // offhand
        if rnd.Next(100) < hitRate then
            this_ws_dmg <- this_ws_dmg + get_dmg(ws_baseD, attackRatio, critRate)
            tp <- tp + ws_tpPerHit
        // additional hits
        for hit in [ 1 .. (extra_hits + more_hits) ] do
            this_ws_dmg <- this_ws_dmg + get_dmg(ws_baseD, attackRatio, critRate)
            tp <- tp + 10

        ws_dmg <- ws_dmg + this_ws_dmg
        ws_hits <- ws_hits + 1

        if skillchainPending && (atDelay - skillchainInitiation) >= minSkillchainDelay && (atDelay - skillchainInitiation) <= maxSkillchainDelay then
            sc_dmg <- sc_dmg + (int ((float this_ws_dmg) * skillchainBonus * skillchainMobFactor))
            sc_hits <- sc_hits + 1
            skillchainPending <- false
        else
            skillchainInitiation <- atDelay
            skillchainPending <- true

        next_round <- next_round + 120

    member this.Status() =
        printfn "%s" name
        printfn "Melee: %d (%d * %d)" melee_dmg melee_hits (melee_dmg / melee_hits)
        printfn "WSkill: %d (%d * %d)" ws_dmg ws_hits (ws_dmg / ws_hits)
        printfn "SChain: %d (%d * %d)" sc_dmg sc_hits (sc_dmg / sc_hits)
        printfn "SChain frequency: %d%%" (sc_hits * 100 / ws_hits)
        printfn ""
        (melee_dmg + ws_dmg + sc_dmg)




//Console.Read() |> ignore

[<EntryPoint>]
let main(args) =
    if args.Length > 0 then
        tp_gap <- Int32.Parse(args.[0])

    let mnk1 = Mnk("M1", 376)
    let mnk2 = Mnk("M2", 376)

    for delay in [ 0 .. max_delay ] do
        if mnk1.ReadyToWeaponskill(delay, mnk2) then
            mnk1.Weaponskill(delay)
        else
            mnk1.Punch(delay)

        if mnk2.ReadyToWeaponskill(delay, mnk1) then
            mnk2.Weaponskill(delay)
        else
            mnk2.Punch(delay)

    let total_dmg = mnk1.Status() + mnk2.Status()

    printfn "Total damage = %d" total_dmg

    0