310 lines
9.3 KiB
TypeScript
310 lines
9.3 KiB
TypeScript
import { M5Item } from "../items/M5Item"
|
|
import { M5Attribute, M5CharacterCalculatedData, M5RollData, M5Skill, M5SkillCalculated, M5SkillLearned } from "../M5Base"
|
|
|
|
export class M5Character extends Actor {
|
|
|
|
// constructor(
|
|
// data: ConstructorParameters<typeof foundry.documents.BaseActor>[0],
|
|
// context?: ConstructorParameters<typeof foundry.documents.BaseActor>[1]
|
|
// ) {
|
|
// super(data, context)
|
|
// this.prepareDerivedData()
|
|
// }
|
|
|
|
static attributeMinMax(attribute: M5Attribute) {
|
|
return Math.min(100, Math.max(0, attribute.value + attribute.bonus))
|
|
}
|
|
|
|
static attributeBonus(attribute: M5Attribute) {
|
|
const value = this.attributeMinMax(attribute)
|
|
if (value > 95)
|
|
return 2
|
|
if (value > 80)
|
|
return 1
|
|
if (value > 20)
|
|
return 0
|
|
if (value > 5)
|
|
return -1
|
|
return -2
|
|
}
|
|
|
|
derivedData(skip: { skills?: boolean, weapons?: boolean, defensiveWeapons?: boolean, armor?: boolean, items?: boolean, spells?: boolean } = {} ): M5CharacterCalculatedData {
|
|
let ret: M5CharacterCalculatedData = {
|
|
level: 0,
|
|
attributes: {
|
|
st: { value: 0, bonus: 0 },
|
|
gs: { value: 0, bonus: 0 },
|
|
gw: { value: 0, bonus: 0 },
|
|
ko: { value: 0, bonus: 0 },
|
|
in: { value: 0, bonus: 0 },
|
|
zt: { value: 0, bonus: 0 },
|
|
au: { value: 0, bonus: 0 },
|
|
pa: { value: 0, bonus: 0 },
|
|
wk: { value: 0, bonus: 0 }
|
|
},
|
|
stats: {
|
|
armor: 0,
|
|
defense: 0,
|
|
damageBonus: 0,
|
|
attackBonus: 0,
|
|
defenseBonus: 0,
|
|
movementBonus: 0,
|
|
resistanceMind: 0,
|
|
resistanceBody: 0,
|
|
spellCasting: 0,
|
|
brawl: 0,
|
|
brawlEw: 0,
|
|
poisonResistance: 0,
|
|
enduranceBonus: 0
|
|
},
|
|
skills: {
|
|
innate: {},
|
|
general: {},
|
|
combat: {},
|
|
language: {},
|
|
custom: {}
|
|
},
|
|
gear: {
|
|
weapons: {},
|
|
defensiveWeapons: {},
|
|
armor: {},
|
|
items: {}
|
|
},
|
|
spells: {}
|
|
} as M5CharacterCalculatedData
|
|
|
|
const context = (this as any).data
|
|
if (!context)
|
|
return null
|
|
|
|
const data = context.data
|
|
if (!data)
|
|
return null
|
|
|
|
ret.level = M5Character.levelFromExp(data.es)
|
|
|
|
ret.attributes.st.value = M5Character.attributeMinMax(data.attributes.st) // TODO item effects
|
|
ret.attributes.gs.value = M5Character.attributeMinMax(data.attributes.gs)
|
|
ret.attributes.gw.value = M5Character.attributeMinMax(data.attributes.gw)
|
|
ret.attributes.ko.value = M5Character.attributeMinMax(data.attributes.ko)
|
|
ret.attributes.in.value = M5Character.attributeMinMax(data.attributes.in)
|
|
ret.attributes.zt.value = M5Character.attributeMinMax(data.attributes.zt)
|
|
ret.attributes.au.value = M5Character.attributeMinMax(data.attributes.au)
|
|
ret.attributes.pa.value = M5Character.attributeMinMax(data.attributes.pa)
|
|
ret.attributes.wk.value = M5Character.attributeMinMax(data.attributes.wk)
|
|
|
|
ret.attributes.st.bonus = M5Character.attributeBonus(data.attributes.st)
|
|
ret.attributes.gs.bonus = M5Character.attributeBonus(data.attributes.gs)
|
|
ret.attributes.gw.bonus = M5Character.attributeBonus(data.attributes.gw)
|
|
ret.attributes.ko.bonus = M5Character.attributeBonus(data.attributes.ko)
|
|
ret.attributes.in.bonus = M5Character.attributeBonus(data.attributes.in)
|
|
ret.attributes.zt.bonus = M5Character.attributeBonus(data.attributes.zt)
|
|
ret.attributes.au.bonus = M5Character.attributeBonus(data.attributes.au)
|
|
ret.attributes.pa.bonus = M5Character.attributeBonus(data.attributes.pa)
|
|
ret.attributes.wk.bonus = M5Character.attributeBonus(data.attributes.wk)
|
|
|
|
ret.stats.armor = 0
|
|
ret.stats.defense = M5Character.defenseFromLevel(ret.level)
|
|
ret.stats.damageBonus = Math.floor(ret.attributes.st.value/20) + Math.floor(ret.attributes.gs.value/30) - 3
|
|
ret.stats.attackBonus = ret.attributes.gs.bonus
|
|
ret.stats.defenseBonus = ret.attributes.gw.bonus
|
|
ret.stats.movementBonus = 0
|
|
ret.stats.resistanceMind = ret.stats.defense
|
|
ret.stats.resistanceBody = ret.stats.defense + 1
|
|
ret.stats.spellCasting = (data.info.magicUsing ? M5Character.spellCastingFromLevel(ret.level) : 3) + ret.attributes.zt.bonus
|
|
ret.stats.brawl = Math.floor((ret.attributes.st.value + ret.attributes.gw.value) / 20)
|
|
ret.stats.brawlEw = ret.stats.brawl + ret.stats.attackBonus
|
|
ret.stats.poisonResistance = 30 + Math.floor(ret.attributes.ko.value / 2)
|
|
ret.stats.enduranceBonus = Math.floor(ret.attributes.ko.value/10) + Math.floor(ret.attributes.st.value/20)
|
|
|
|
if (!skip.items) {
|
|
context.items?.filter(item => item.data.type === "item").forEach(item => {
|
|
item.prepareDerivedData()
|
|
|
|
let label = item.data.name
|
|
if (item.data.data.magic) {
|
|
label += "*"
|
|
}
|
|
|
|
ret.gear.items[item.data._id] = {
|
|
label: label,
|
|
magic: item.data.data.magic,
|
|
calc: item.data.data.calc
|
|
}
|
|
})
|
|
}
|
|
|
|
if (!skip.skills) {
|
|
context.items?.filter(item => item.data.type === "skill").forEach(item => {
|
|
item.prepareDerivedData()
|
|
const skillMap = ret.skills[item.data.data.type]
|
|
skillMap[item.data._id] = {
|
|
label: item.data.name,
|
|
fw: item.data.data.fw,
|
|
attribute: item.data.data.attribute,
|
|
calc: item.data.data.calc
|
|
} as M5SkillCalculated
|
|
})
|
|
}
|
|
|
|
if (!skip.weapons) {
|
|
context.items?.filter(item => item.data.type === "weapon").forEach(item => {
|
|
item.prepareDerivedData()
|
|
|
|
let label = item.data.name
|
|
if (item.data.data.magic) {
|
|
label += "*("
|
|
+ (item.data.data.stats.attackBonus < 0 ? "" : "+")
|
|
+ item.data.data.stats.attackBonus + "/"
|
|
+ (item.data.data.stats.damageBonus < 0 ? "" : "+")
|
|
+ item.data.data.stats.damageBonus + ")"
|
|
}
|
|
|
|
ret.gear.weapons[item.data._id] = {
|
|
label: label,
|
|
skillId: item.data.data.skillId,
|
|
magic: item.data.data.magic,
|
|
calc: item.data.data.calc
|
|
}
|
|
})
|
|
}
|
|
|
|
if (!skip.defensiveWeapons) {
|
|
context.items?.filter(item => item.data.type === "defensiveWeapon").forEach(item => {
|
|
item.prepareDerivedData()
|
|
|
|
let label = item.data.name
|
|
if (item.data.data.magic) {
|
|
label += "*("
|
|
+ (item.data.data.stats.defenseBonus < 0 ? "" : "+")
|
|
+ item.data.data.stats.defenseBonus + ")"
|
|
}
|
|
|
|
ret.gear.defensiveWeapons[item.data._id] = {
|
|
label: label,
|
|
skillId: item.data.data.skillId,
|
|
magic: item.data.data.magic,
|
|
calc: item.data.data.calc
|
|
}
|
|
})
|
|
}
|
|
|
|
if (!skip.armor) {
|
|
context.items?.filter(item => item.data.type === "armor").forEach(item => {
|
|
item.prepareDerivedData()
|
|
|
|
let label = item.data.name
|
|
if (item.data.data.magic) {
|
|
label += "*"
|
|
}
|
|
|
|
ret.gear.armor[item.data._id] = {
|
|
label: label,
|
|
magic: item.data.data.magic,
|
|
calc: item.data.data.calc
|
|
}
|
|
})
|
|
}
|
|
|
|
if (!skip.spells) {
|
|
context.items?.filter(item => item.data.type === "spell").forEach(item => {
|
|
item.prepareDerivedData()
|
|
|
|
ret.spells[item.data._id] = {
|
|
label: item.data.name,
|
|
process: "midgard5.spell-process-" + item.data.data.process,
|
|
calc: item.data.data.calc
|
|
}
|
|
})
|
|
}
|
|
|
|
return ret
|
|
}
|
|
|
|
prepareDerivedData() {
|
|
const context = (this as any).data
|
|
context.data.calc = this.derivedData({})
|
|
}
|
|
|
|
override getRollData(): any {
|
|
return {
|
|
c: (this as any).data.data,
|
|
i: null,
|
|
iType: null,
|
|
rolls: {},
|
|
res: {}
|
|
} as M5RollData
|
|
}
|
|
|
|
static readonly levelThreshold: Array<number> = [0, 100, 250, 500, 750, 1000, 1250, 1500, 1750, 2000, 2500, 3000, 3500, 4000, 4500, 5000, 6000, 7000, 8000, 9000, 10000, 12500, 15000, 17500, 20000, 22500, 25000, 30000, 35000, 40000, 45000, 50000, 55000, 60000, 65000, 70000, 75000, 80000, 85000, 90000, 95000, 100000, 105000, 110000, 115000, 120000, 125000, 130000, 135000, 140000, 145000, 150000, 155000, 160000, 165000, 170000, 175000, 180000, 185000, 190000, 195000, 200000, 205000, 210000, 215000, 220000, 225000, 230000, 235000, 240000, 245000, 250000, 255000, 260000, 265000, 270000, 275000, 280000]
|
|
static levelFromExp(exp: number): number {
|
|
const ret = M5Character.levelThreshold.findIndex(val => val > exp)
|
|
return ret === -1 ? M5Character.levelThreshold.length : ret
|
|
}
|
|
|
|
static readonly defenseThreshold: Array<[number, number]> = [
|
|
[1, 11],
|
|
[2, 12],
|
|
[5, 13],
|
|
[10, 14],
|
|
[15, 15],
|
|
[20, 16],
|
|
[25, 17],
|
|
[30, 18]
|
|
]
|
|
static defenseFromLevel(lvl: number): number {
|
|
const ret = M5Character.defenseThreshold.find(val => val[0] >= lvl)
|
|
return ret ? ret[1] : M5Character.defenseThreshold[M5Character.defenseThreshold.length - 1][1]
|
|
}
|
|
|
|
static readonly spellCastingThreshold: Array<[number, number]> = [
|
|
[1, 11],
|
|
[2, 12],
|
|
[4, 13],
|
|
[6, 14],
|
|
[8, 15],
|
|
[10, 16],
|
|
[15, 17],
|
|
[20, 18]
|
|
]
|
|
static spellCastingFromLevel(lvl: number): number {
|
|
const ret = M5Character.spellCastingThreshold.find(val => val[0] >= lvl)
|
|
return ret ? ret[1] : M5Character.spellCastingThreshold[M5Character.spellCastingThreshold.length - 1][1]
|
|
}
|
|
|
|
skillBonus(skill: M5Skill, skillName?: string) {
|
|
const attribute = this.attribute(skill.attribute)
|
|
let ret = attribute ? M5Character.attributeBonus(attribute) : 0
|
|
return ret
|
|
}
|
|
|
|
skillEw(skill: M5Skill, skillName?: string) {
|
|
const bonus = this.skillBonus(skill, skillName)
|
|
return skill.fw + bonus
|
|
}
|
|
|
|
attribute(name: string): M5Attribute {
|
|
const context = (this as any).data
|
|
return context?.data?.attributes[name]
|
|
}
|
|
|
|
createSkill(skillName: string): Promise<M5Item> {
|
|
const itemData = {
|
|
name: skillName,
|
|
type: "skill"
|
|
};
|
|
|
|
return (this as any).createEmbeddedDocuments("Item", [itemData]).then(docs => {
|
|
const item = docs[0]
|
|
return item
|
|
})
|
|
}
|
|
|
|
getItem(itemId: string): any {
|
|
if (!(this as any).data?.items)
|
|
return null
|
|
return (this as any).getEmbeddedDocument("Item", itemId)
|
|
}
|
|
|
|
}
|