PSI question

[Notorious Fish]

I have never really thought about it but does it go like this

PPU= 1

PPW= .5

So in retrospect 2 PPW points is equivalant to 1 PPU point?

[Tostino]

Passive PSI Damage:
Skill Factors involved: 0.65(65%) PPU + 0.35(35%) PPW

Passive PSI Range:
Skill Factors involved: 0.4(40%) PPU + 0.4(40%) PSU

Passive PSI Frequency:
Skill Factors involved: 0.4(40%) PPU + 0.4(40%)PSU

So 2 points in PPW is better then one point in PPU for damage (up to a point that is).

[Notorious Fish]

Passive PSI Damage:
Skill Factors involved: 0.65(65%) PPU + 0.35(35%) PPW

Passive PSI Range:
Skill Factors involved: 0.4(40%) PPU + 0.4(40%) PSU

Passive PSI Frequency:
Skill Factors involved: 0.4(40%) PPU + 0.4(40%)PSU

The last dont equal 100% 0_o

[Tostino]

They dont need to. The skills are worked out wierd but oh well.

[Notorious Fish]

They dont need to. The skills are worked out wierd but oh well.

Ok smarty panties

heh
How many points for capped PE psi if you dont spend any of them? 150?

[Mighty Max]

Huggs tells me 172

[Notorious Fish]

Thanks that sounds just about right

[Mighty Max]

Hmm if you got Hugs or Haskell you might look up the damage percentages yourself. I gonna add the .hs at the end.

It yet isnt finished and was prelimitary made for me to lern the haskell syntax.

Anyways it is quiet usefull to analyse such data.

Examples how to use it (has to be loaded into haskell (http://www.haskell.org/hugs)):

"psi_sp (psi_cappsi 35 psi_pebase)"
returns 172 as it shows the psi SkillPoints as you cap psi_pebase to lvl 35

"psi_sp ( psi_setmst (psi_cappsi 35 psi_pebase) 87)"
would return the left points after mst reached 87.

"psi_apudmgmod ( psi_setapu( psi_setmst (psi_cappsi 100 psi_monkbase) 87) 120)"
Shows the damage modifier for apu spells with 100apu, 87mst at psilevel 100 [in x/10000]

"psi_mintoreach 138 1 2 87 psi_monkbase"
would return the minimum psilevel you need to get apu to 138, ppu to 1 ppw to 2 and mst to 87

See the other functions for more informations you might calc out.




-- PSI: apu,ppu,ppw,left skillpoints and level
type Psiskills = (Int,Int,Int,Int,Int,Int)
-- INT: hck,res,cst,wpw,psu,skillpoints and level
type Intskills = (Int,Int,Int,Int,Int,Int,Int)
-- STR: mc,hc, ... ,skillpoints and level
type Strskills = (Int,Int,Int,Int)
-- DEX: ... , skillpoints and level
type Dexskills = (Int,Int)
-- CON: ... , skillpoints and level
type Conskills = (Int,Int)

-- complete skillset
type Skillset = (Intskills,Strskills,Conskills,Dexskills,Psiskills)

psiskill :: Skillset -> Psiskills
psiskill (i,s,c,d,p) = p

strskill :: Skillset -> Strskills
strskill (i,s,c,d,p) = s

conskill :: Skillset -> Conskills
conskill (i,s,c,d,p) = c

dexskill :: Skillset -> Dexskills
dexskill (i,s,c,d,p) = d

intskill :: Skillset -> Intskills
intskill (i,s,c,d,p) = i




psi_apu :: Psiskills -> Int
psi_apu (x,_,_,_,_,_) = x

psi_ppu :: Psiskills -> Int
psi_ppu (_,x,_,_,_,_) = x

psi_ppw :: Psiskills -> Int
psi_ppw (_,_,x,_,_,_) = x

psi_mst :: Psiskills -> Int
psi_mst (_,_,_,x,_,_) = x

psi_sp :: Psiskills -> Int
psi_sp (_,_,_,_,x,_) = x

psi_psilevel :: Psiskills -> Int
psi_psilevel (_,_,_,_,_,x) = x

psi_monkbase :: Psiskills
psi_monkbase = (0,0,0,0,78,5)

psi_tankbase :: Psiskills
psi_tankbase = (0,0,0,0,2,1)

psi_pebase :: Psiskills
psi_pebase = psi_tankbase

psi_spybase :: Psiskills
psi_spybase = psi_tankbase

-- monk caps
psi_monkcap = 100
con_monkcap = 45
dex_monkcap = 35
str_monkcap = 20
int_monkcap = 100
-- pe caps
psi_pecap = 35
-- spy caps
psi_spycap = 20
-- tankcaps
psi_tankcap = 10

psi_cappsi :: Int->Psiskills -> Psiskills
psi_cappsi cp (a,b,c,d,s,lvl) | lvl < cp = psi_cappsi cp (a,b,c,d,s+5,lvl+1)
| otherwise = (a,b,c,d,s,lvl)

psi_reducepsi :: Psiskills -> Psiskills
psi_reducepsi (a,b,c,m,s,lvl) | s > 4 = (a,b,c,m,s-5,lvl-1)
| otherwise = (a,b,c,m,s,lvl)

pointstoraise :: Int -> Int
pointstoraise x | x<50 = 1
| x<75 = 2
| x<100 = 3
| otherwise = 5

-- raising / setting mst


psi_raisemst :: Psiskills -> Psiskills
psi_raisemst (a,b,c,m,s,lvl) | (s < (pointstoraise m)) = (a,b,c,m,s,lvl)
| otherwise = (a,b,c,m+1,s-(pointstoraise m),lvl)

psi_setmst :: Psiskills -> Int -> Psiskills
psi_setmst x target | (pointstoraise (psi_mst x)) > (psi_sp x) = x
| (psi_mst x) < target = psi_setmst (psi_raisemst x) target
| otherwise = x


-- raising / setting ppw

psi_raiseppw :: Psiskills -> Psiskills
psi_raiseppw (a,b,c,m,s,lvl) | (s < (pointstoraise c)) = (a,b,c,m,s,lvl)
| otherwise = (a,b,c+1,m,s-(pointstoraise c),lvl)

psi_setppw :: Psiskills -> Int -> Psiskills
psi_setppw x target | (pointstoraise (psi_ppw x)) > (psi_sp x) = x
| (psi_ppw x) < target = psi_setppw (psi_raiseppw x) target
| otherwise = x

-- raising / setting ppu

psi_raiseppu :: Psiskills -> Psiskills
psi_raiseppu (a,b,c,m,s,lvl) | (s < (pointstoraise b)) = (a,b,c,m,s,lvl)
| otherwise = (a,b+1,c,m,s-(pointstoraise b),lvl)

psi_setppu :: Psiskills -> Int -> Psiskills
psi_setppu x target | (pointstoraise (psi_ppu x)) > (psi_sp x) = x
| (psi_ppu x) < target = psi_setppu (psi_raiseppu x) target
| otherwise = x

-- raising / setting apu

psi_raiseapu :: Psiskills -> Psiskills
psi_raiseapu (a,b,c,m,s,lvl) | (s < (pointstoraise a)) = (a,b,c,m,s,lvl)
| otherwise = (a+1,b,c,m,s-(pointstoraise a),lvl)

psi_setapu :: Psiskills -> Int -> Psiskills
psi_setapu x target | (pointstoraise (psi_apu x)) > (psi_sp x) = x
| (psi_apu x) < target = psi_setapu (psi_raiseapu x) target
| otherwise = x

-- trimm level to current spent points
psi_trimmpsi :: Psiskills -> Psiskills
psi_trimmpsi x | psi_sp x > 4 = psi_trimmpsi (psi_reducepsi x)
| otherwise = x

-- minimum lvl to reach the skill tripplet
psi_mintoreach :: Int -> Int -> Int-> Int -> Psiskills -> Int
psi_mintoreach a p w m base = psi_psilevel (psi_trimmpsi ( psi_setapu( psi_setppu( psi_setppw( psi_setmst(psi_cappsi 100 base) m) w) p) a) )

-- damage modifier for apu in /10000
psi_apudmgmod :: Psiskills -> Int
psi_apudmgmod x = ((psi_apu x) * 65) + ((psi_ppw x) * 35)

-- damage modifier for apu in /10000
psi_ppudmgmod :: Psiskills -> Int
psi_ppudmgmod x = ((psi_ppu x) * 65) + ((psi_ppw x) * 35)



-- global get skills
apu :: Skillset -> Int
apu x = psi_apu (psiskill x)

ppu :: Skillset -> Int
ppu x = psi_ppu (psiskill x)

ppw :: Skillset -> Int
ppw x = psi_ppw (psiskill x)

mst :: Skillset -> Int
mst x = psi_mst (psiskill x)

[Dribble Joy]

The last dont equal 100% 0_o
They aren't really percentages. They are ratios.