Transaction

jrun
cryptofightsMy¢{"in":0,"ref":["3f41b320ac0e3fc2930585ba768436c89f1f2d42896be9824c982793d482df77_o1","5334f688050535806987424ec00ba75b74a2087c8c3945765dd9107ac81af1a7_o1","9f0e192f744258c3484a1c19fa88ef68e46ee6cf75acc78cfe2ad5a0d2340d0e_o1","5dc606e8c78f47a10ecb5f8645f2dbe09a3b3a2da87e7e614dcc150203adba1a_o1","870c20f2e1b5f421a3083f749776c059e5bf227d6b2d555f11ffda2306389c56_o1","f97d4ac2a3d6f5ed09fad4a4f341619dc5a3773d9844ff95c99c5d4f8388de2f_o1"],"out":["811d6f426defe1b58a1dce1baf213e70d93885bed79d513fba2f5ac89763653d"],"del":[],"cre":["n2Bd4cWhEQK1aVjb1R7EBGV9mrw3etvSdC"],"exec":[{"op":"DEPLOY","data":["class BattleUtils extends FyxClass {\n static isUnderStatusEffect(fighterState, statusEffect, round) {\n return fighterState.statusEffectsRound[statusEffect] > round;\n }\n\n static activeCooldownList(fighterState, round) {\n return fighterState.actionCooldownsRound.map( i=> i > round);\n }\n\n static validateRandom(random, prevRandom) {\n let hashBytes = new Uint8Array(32);\n for (let i = 0; i < 64; i += 2) {\n hashBytes[i / 2] = parseInt(random.slice(i, i + 2), 16);\n }\n return Sha256.hashToHex(hashBytes) === prevRandom;\n }\n\n static rollDmgDice(ability, diceCount, diceFaces, dice, rolls, type) {\n let damage = 0;\n for (var i = 0; i < diceCount; ++i) {\n let toDamageNativeRoll = diceFaces === 0 ? 0 : dice.roll(1, diceFaces);\n rolls.push({\n type: type,\n ability: ability,\n size: diceFaces,\n value: toDamageNativeRoll\n });\n damage += toDamageNativeRoll;\n }\n return damage;\n }\n\n static applySkillCooldown(battle, state, skillType, increment = 0)\n {\n let skillIndex = battle.battlePlayers[state.playerToAct].skills.findIndex( x=> x.skillType == skillType);\n state.fighterStates[state.playerToAct].actionCooldownsRound[skillIndex] = state.fighterStates[state.playerToAct].turnCounter + increment + 1;\n }\n\n static applyStatusEffect(actionLog, battle, state, statusEffect, increment, applyToAttacker = true) {\n const statusEffectMap = Object.keys(Constants.StatusEffect).map(() => 0);\n if (applyToAttacker) {\n state.fighterStates[state.playerToAct].statusEffectsRound[statusEffect] = state.fighterStates[state.playerToAct].turnCounter + increment + 1;\n const lastResult = actionLog.results.slice(-1).pop();\n if(!lastResult) {\n console.error('BattleUtils.applyStatusEffect call with no results:', JSON.stringify(actionLog));\n return;\n }\n if (!lastResult.attackerStatusEffectsIncrement) {\n lastResult.attackerStatusEffectsIncrement = statusEffectMap;\n }\n lastResult.attackerStatusEffectsIncrement[statusEffect] = increment;\n actionLog.actionLogMessage += BattleUtils.getPrettifiedPlayerName(battle, state, !applyToAttacker);\n } else {\n let turnCount = statusEffect == Constants.StatusEffect.Stunned ? battle.turnCount : state.fighterStates[state.playerToAct ? 0 : 1].turnCounter;\n state.fighterStates[state.playerToAct ? 0 : 1].statusEffectsRound[statusEffect] = turnCount + increment;\n if (!actionLog.results.slice(-1).pop().defenderStatusEffectsIncrement) {\n actionLog.results.slice(-1).pop().defenderStatusEffectsIncrement = statusEffectMap;\n }\n actionLog.results.slice(-1).pop().defenderStatusEffectsIncrement[statusEffect] = increment;\n actionLog.actionLogMessage += BattleUtils.getOpponentName(battle, state, applyToAttacker);\n }\n\n if(increment > 90){\n actionLog.actionLogMessage += `<gradient=!status-effect><i> is ${BattleUtils.parseStatusEffect(statusEffect)}\\n`;\n }else{\n actionLog.actionLogMessage += `<gradient=!status-effect><i> is ${BattleUtils.parseStatusEffect(statusEffect)} for ${increment <= 0 ? 1 : increment} turns</i>\\n`;\n }\n }\n\n static makeStatusEffectActionLog(battle, state, skill, statusEffect, increment, log, applyToAttacker = true) {\n let attackerState = state.fighterStates[state.playerToAct];\n let defenderState = state.fighterStates[state.playerToAct ? 0 : 1];\n let damageMap = Object.keys(Constants.DamageType).map(() => 0);\n\n let actionLog = {\n playerIndex: state.playerToAct,\n skillType: skill,\n results: [{\n rolls: [],\n outcome: Constants.Outcome.Success,\n damageOutput: [{\n damage: damageMap,\n defenderHp: defenderState.hp,\n defenderReduction: damageMap,\n }],\n hpIncrement: 0,\n attackerHp: attackerState.hp\n }],\n actionLogMessage: log\n };\n\n this.applyStatusEffect(actionLog, battle, state, statusEffect, increment, applyToAttacker);\n\n return actionLog;\n }\n\n static abilityCheckAndApplyStatusEffect(battle, state, dice, skill, attackerAbility, defenderAbility, statusEffect, duration, applyToAttacker, log) {\n const attackPlayer = battle.battlePlayers[state.playerToAct];\n const attackerState = state.fighterStates[state.playerToAct];\n const defenderState = state.fighterStates[state.playerToAct ? 0 : 1];\n var playerName = BattleUtils.getPrettifiedPlayerName(battle, state);\n\n // Rolls\n let nativeRoll = dice.roll(1, 20);\n let rolls = [];\n rolls.push({\n type: defenderAbility,\n ability: attackerAbility,\n size: 20,\n value: nativeRoll\n });\n\n // Check\n const defenderDC = 10 + defenderState.modifiers[defenderAbility];\n let attackerMod = attackerState.modifiers[attackerAbility];\n if(skill == Constants.SkillType.Hide)\n {\n let mainHand = false;\n if (attackPlayer.mainhand && attackPlayer.mainhand !== null) {\n if (attackPlayer.mainhand.properties && attackPlayer.mainhand.properties !== null) {\n mainHand = true;\n }\n }\n let offHand = false;\n if (attackPlayer.offhand && attackPlayer.offhand !== null) {\n if (attackPlayer.offhand.properties && attackPlayer.offhand.properties !== null) {\n offHand = true;\n }\n }\n \n if ((!mainHand && !offHand) || \n (mainHand && attackPlayer.mainhand.properties[Constants.ItemProperty.Light] && offHand && attackPlayer.offhand.properties[Constants.ItemProperty.Light]))\n {\n attackerMod += 2;\n }\n }\n const outcome = nativeRoll + attackerMod >= defenderDC ?\n Constants.Outcome.Success : \n Constants.Outcome.Fail;\n\n log += `${playerName} <gradient=!log-color>attempts to ${BattleUtils.parseSkillName(skill)} : *${BattleUtils.parseSkillOutcome(outcome)}* : (${nativeRoll} + ${attackerMod} vs ${defenderDC} DC)\\n`;\n\n // Success\n if (outcome === Constants.Outcome.Success) {\n var al = BattleUtils.makeStatusEffectActionLog(battle, state, skill, statusEffect, duration, log, applyToAttacker);\n al.results[0].rolls = rolls;\n al.results[0].outcome = outcome;\n return al;\n }\n\n const damageMap = Object.keys(Constants.DamageType).map(() => 0);\n // Failure\n return {\n playerIndex: state.playerToAct,\n skillType: skill,\n results: [{\n rolls: rolls,\n outcome: outcome,\n damageOutput: [{\n damage: damageMap,\n defenderHp: defenderState.hp,\n defenderReduction: damageMap,\n }],\n attackerStatusEffectsIncrement: Object.keys(Constants.StatusEffect).map(() => 0),\n hpIncrement: 0,\n attackerHp: attackerState.hp\n }],\n actionLogMessage: log\n };\n }\n\n static parseAbility(ability) {\n return ability === 0 ? 'Strength' : (ability === 1 ? 'Dexterity' : 'Intelligence');\n }\n\n static parseAttackOutcome(outcome) {\n return outcome === 0 ? 'Miss' : (outcome === 1 ? 'Hit' : 'Critical');\n }\n\n static parseSkillOutcome(outcome) {\n return outcome === 0 ? 'Fail' : (outcome === 1 ? 'Success' : 'Critical');\n }\n\n static getPrettifiedName(battle, playerIndex) {\n return `<gradient=!player${playerIndex}-color><b>${battle.battlePlayers[playerIndex].fighter.metadata.name.toUpperCase()}</b><gradient=!log-color>`;\n }\n\n static getPrettifiedPlayerName(battle, state, switchAttacker = false) {\n let attackerIndex = switchAttacker ? (state.playerToAct ? 0 : 1) : state.playerToAct;\n return this.getPrettifiedName(battle, attackerIndex);\n }\n\n static getOpponentName(battle, state, switchAttacker = false) {\n let attackerIndex = switchAttacker ? state.playerToAct : (!state.playerToAct ? 1 : 0);\n return this.getPrettifiedName(battle, attackerIndex);\n }\n\n static parseSkillName(skill) {\n switch (skill) {\n case Constants.SkillType.Attack:\n return 'Attack';\n case Constants.SkillType.BattleCry:\n return 'Battle Cry';\n case Constants.SkillType.Burn:\n return 'Burn';\n case Constants.SkillType.Chill:\n return 'Chill';\n case Constants.SkillType.Cleanse:\n return 'Cleanse';\n case Constants.SkillType.CoatWeapon:\n return 'Coat Weapon';\n case Constants.SkillType.Curse:\n return 'Curse';\n case Constants.SkillType.DirtyFighting:\n return 'Dirty Fighting';\n case Constants.SkillType.Fireball:\n return 'Fireball';\n case Constants.SkillType.Focus:\n return 'Focus';\n case Constants.SkillType.Freeze:\n return 'Freeze';\n case Constants.SkillType.Gore:\n return 'Gore';\n case Constants.SkillType.Heal:\n return 'Heal';\n case Constants.SkillType.Hex:\n return 'Hex';\n case Constants.SkillType.Hide:\n return 'Hide';\n case Constants.SkillType.LightningBolt:\n return 'Lightning Bolt';\n case Constants.SkillType.LockAndLoad:\n return 'Lock And Load';\n case Constants.SkillType.Mark:\n return 'Mark';\n case Constants.SkillType.Meditate:\n return 'Meditate';\n case Constants.SkillType.PhaseShift:\n return 'Phase Shift';\n case Constants.SkillType.PinningStrike:\n return 'Pinning Strike';\n case Constants.SkillType.PowerAttack:\n return 'Power Attack';\n case Constants.SkillType.SecondWind:\n return 'Second Wind';\n case Constants.SkillType.Shock:\n return 'Shock';\n case Constants.SkillType.Smite:\n return 'Smite';\n case Constants.SkillType.SneakAttack:\n return 'Sneak Attack';\n case Constants.SkillType.Stun:\n return 'Stun';\n case Constants.SkillType.Taunt:\n return 'Taunt';\n case Constants.SkillType.Stab:\n return 'Stab';\n case Constants.SkillType.Strike:\n return 'Strike';\n case Constants.SkillType.Multiattack:\n return 'Multiattack'; \n }\n }\n\n static parseStatusEffect(statusEffect) {\n switch (statusEffect) {\n case Constants.StatusEffect.Cursed:\n return 'cursed';\n case Constants.StatusEffect.Ethereal:\n return 'ethereal';\n case Constants.StatusEffect.Focused:\n return 'focused';\n case Constants.StatusEffect.Hexed:\n return 'hexed';\n case Constants.StatusEffect.Hidden:\n return 'hidden';\n case Constants.StatusEffect.Inspired:\n return 'inspired';\n case Constants.StatusEffect.Marked:\n return 'marked';\n case Constants.StatusEffect.Meditative:\n return 'meditative';\n case Constants.StatusEffect.Poisoned:\n return 'poisoned';\n case Constants.StatusEffect.Stunned:\n return 'stunned';\n case Constants.StatusEffect.Taunted:\n return 'taunted';\n case Constants.StatusEffect.Poisonous:\n return 'poisonous';\n case Constants.StatusEffect.Demoralized:\n return 'demoralized';\n }\n }\n\n static getItemResistance(item, defenderResistance) {\n if (item) {\n for (var j = 0; j < 10; j++) {\n if (item.damageReduction[j]) {\n defenderResistance[j] += item.damageReduction[j];\n }\n }\n }\n }\n\n // Compute resistance according to items\n static getDefenderResistance(player) {\n var defenderResistance = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0];\n\n this.getItemResistance(player.mainhand, defenderResistance);\n this.getItemResistance(player.offhand, defenderResistance);\n this.getItemResistance(player.armor, defenderResistance);\n this.getItemResistance(player.hat, defenderResistance);\n\n if (player.fighter.skills.includes(Constants.SkillType.Armored)) {\n if (player.fighter.skills.includes(Constants.SkillType.ImprovedArmored)) {\n for (var i = 0; i < 10; i++) {\n defenderResistance[i] += 1;\n }\n }else{\n defenderResistance[Constants.DamageType.Slashing] += 1;\n defenderResistance[Constants.DamageType.Piercing] += 1;\n defenderResistance[Constants.DamageType.Bludgeoning] += 1;\n }\n }\n\n if (player.fighter.skills.includes(Constants.SkillType.Dwarven)) {\n defenderResistance[Constants.DamageType.Slashing] += 1;\n defenderResistance[Constants.DamageType.Piercing] += 1;\n defenderResistance[Constants.DamageType.Bludgeoning] += 1;\n }\n\n return defenderResistance;\n }\n \n static getItemBonus(item, defenderBonus) {\n if (item) {\n for (var j = 0; j < 18; j++) {\n if (item.bonuses[j]) {\n defenderBonus[j] += item.bonuses[j];\n }\n }\n }\n }\n\n // Compute bonuses according to items\n static getItemBonuses(player) {\n var defenderBonus = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];\n\n this.getItemBonus(player.mainhand, defenderBonus);\n this.getItemBonus(player.offhand, defenderBonus);\n this.getItemBonus(player.armor, defenderBonus);\n this.getItemBonus(player.hat, defenderBonus);\n\n return defenderBonus;\n }\n\n static buildBattleState(players, dice) {\n const diceRolls = players.map(() => dice.roll(1, 20));\n const fighterStates = players.map((player, i) => {\n const fighterState = this.buildFighterState(player);\n fighterState.initiative += fighterState.modifiers[Constants.Ability.Dexterity] + diceRolls[i];\n fighterState.turnCounter = 0;\n return fighterState;\n });\n\n let logMessage = '';\n let playerToAct;\n if (fighterStates[0].initiative === fighterStates[1].initiative) {\n if (fighterStates[0].modifiers[Constants.Ability.Dexterity] === fighterStates[1].modifiers[Constants.Ability.Dexterity]) {\n logMessage += '\\n<gradient=!log-color>It\\'s a tie, tossing a coin';\n playerToAct = dice.roll(1, 2) - 1;\n } else {\n playerToAct = fighterStates[0].modifiers[Constants.Ability.Dexterity] > fighterStates[1].modifiers[Constants.Ability.Dexterity] ? 0 : 1;\n logMessage += `\\n<gradient=!player${playerToAct}-color><b>${players[playerToAct].fighter.metadata.name.toUpperCase()}</b> <gradient=!log-color>has higher dexterity`;\n }\n } else {\n playerToAct = fighterStates[0].initiative > fighterStates[1].initiative ? 0 : 1;\n }\n\n const damageMap = Object.keys(Constants.DamageType).map(() => 0);\n const statusEffectMap = Object.keys(Constants.StatusEffect).map(() => 0);\n const actionLogs = fighterStates.map((fighterState, i) => {\n return {\n playerIndex: i,\n skillType: Constants.SkillType.Focus,\n results: [{\n rolls: [{\n type: Constants.RollType.Initiative,\n ability: Constants.Ability.Dexterity,\n size: 20,\n value: diceRolls[i],\n discarded: false,\n bonusFromAbility: fighterState.modifiers[Constants.Ability.Dexterity],\n bonusFromSkill: 0,\n totalBonus: fighterState.modifiers[Constants.Ability.Dexterity]\n }],\n outcome: playerToAct === i ?\n Constants.Outcome.Success :\n Constants.Outcome.Fail,\n damageOutput: [{\n damage: damageMap,\n defenderHp: fighterStates[i ? 0 : 1].maxHP,\n defenderReduction: damageMap\n }],\n attackerStatusEffectsIncrement: statusEffectMap,\n defenderStatusEffectsIncrement: statusEffectMap,\n hpIncrement: 0,\n attackerHp: fighterState.maxHP\n }],\n actionLogMessage: `<gradient=!player${i}-color><b>${players[i].fighter.metadata.name.toUpperCase()}</b> <gradient=!log-color>attempts Initiative: ${diceRolls[i] + fighterState.modifiers[Constants.Ability.Dexterity]}` + (players[i].fighter.skills.includes(Constants.SkillType.Elven) ? ' + 10' : '')\n };\n });\n logMessage += `\\n<gradient=!player${playerToAct}-color><b>${players[playerToAct].fighter.metadata.name.toUpperCase()}</b> <gradient=!log-color>won Initiative`;\n\n actionLogs[playerToAct ? 0 : 1].actionLogMessage += logMessage;\n return {\n status: Constants.Status.Open,\n fighterStates,\n playerToAct,\n actionLogs\n };\n }\n\n static simulateFighterState(battlePlayer) {\n const fighter = battlePlayer.fighter;\n\n // Construct fighter states\n const items = [battlePlayer.mainhand, battlePlayer.offhand, battlePlayer.armor, battlePlayer.hat];\n const derivedStats = BattleUtils.getDerivedStats(fighter,items);\n const fighterModifiers = derivedStats.modifiers;\n\n const hpIncrement = derivedStats.hpIncrement + fighter.hpBonus;\n\n // Create fighter state\n const fighterState = {\n abilityScoreBonuses: derivedStats.abilityScoreBonuses,\n abilityScores: derivedStats.abilityScores,\n modifiers: fighterModifiers,\n evasion: derivedStats.evasion,\n hp: fighterModifiers[Constants.Ability.Strength] + 10 + hpIncrement,\n maxHP: fighterModifiers[Constants.Ability.Strength] + 10 + hpIncrement,\n critChance: derivedStats.critChance,\n statusEffectsRound: Object.keys(Constants.StatusEffect).map(() => 0),\n areLoaded: [false, false],\n actionCooldownsRound: [0, 0, 0, 0],\n validActions: BattleUtils.getValidActions(battlePlayer.skills, battlePlayer.fighter.skills, [false,false,false,false], false,\n true, true, true, battlePlayer.mainhand, battlePlayer.offhand),\n resistances: BattleUtils.getDefenderResistance(battlePlayer),\n initiative: derivedStats.initiative\n };\n return fighterState;\n }\n\n static buildFighterState(battlePlayer) {\n const fighter = battlePlayer.fighter;\n\n // Construct fighter states\n const items = [battlePlayer.mainhand, battlePlayer.offhand, battlePlayer.armor, battlePlayer.hat];\n const derivedStats = BattleUtils.getDerivedStats(fighter,items);\n const fighterModifiers = derivedStats.modifiers;\n\n const hpIncrement = derivedStats.hpIncrement + fighter.hpBonus;\n\n // Create fighter state\n const fighterState = {\n abilityScoreBonuses: derivedStats.abilityScoreBonuses,\n abilityScores: derivedStats.abilityScores,\n modifiers: fighterModifiers,\n evasion: derivedStats.evasion,\n hp: fighterModifiers[Constants.Ability.Strength] + 10 + hpIncrement,\n maxHP: fighterModifiers[Constants.Ability.Strength] + 10 + hpIncrement,\n critChance: derivedStats.critChance,\n statusEffectsRound: Object.keys(Constants.StatusEffect).map(() => 0),\n areLoaded: [false, false],\n actionCooldownsRound: [0, 0, 0, 0],\n validActions: BattleUtils.getValidActions(battlePlayer.skills, fighter.skills, [false,false,false,false], false,\n false, false, false, battlePlayer.mainhand, battlePlayer.offhand),\n resistances: BattleUtils.getDefenderResistance(battlePlayer),\n initiative: derivedStats.initiative\n };\n return fighterState;\n }\n\n // Derived unmutable stats (HP and MaxHP are mutable)\n static getDerivedStats(fighter, items) {\n let abilityScores = FyxClass.deepClone(fighter.abilityScores);\n let abilityScoreBonuses = [0, 0, 0];\n let evasion = 0;\n let critChance = 1;\n let hpIncrement = fighter.skills.includes(Constants.SkillType.Durable) ? (fighter.level * 2) : 0;\n let initiative = 0;\n\n for( const item of items || []) {\n if(item){\n abilityScores[Constants.Ability.Strength] += item.bonuses[Constants.Bonus.Strength];\n abilityScoreBonuses[Constants.Ability.Strength] += item.bonuses[Constants.Bonus.Strength];\n abilityScores[Constants.Ability.Dexterity] += item.bonuses[Constants.Bonus.Dexterity];\n abilityScoreBonuses[Constants.Ability.Dexterity] += item.bonuses[Constants.Bonus.Dexterity];\n abilityScores[Constants.Ability.Intelligence] += item.bonuses[Constants.Bonus.Intelligence];\n abilityScoreBonuses[Constants.Ability.Intelligence] += item.bonuses[Constants.Bonus.Intelligence];\n evasion += item.bonuses[Constants.Bonus.Evasion];\n critChance += item.bonuses[Constants.Bonus.CritChance];\n initiative += item.bonuses[Constants.Bonus.Initiative];\n }\n }\n\n let modifiers = BattleUtils.getModifiers(abilityScores);\n evasion = modifiers[Constants.Ability.Dexterity] + 10;\n\n if (fighter.skills.includes(Constants.SkillType.Elven)) {\n initiative += 10;\n evasion += 2;\n }\n\n if (fighter.skills.includes(Constants.SkillType.Slippery)) {\n evasion += 2;\n }\n\n if (fighter.skills.includes(Constants.SkillType.Cirurgical)) {\n critChance += 1;\n }\n\n if (fighter.skills.includes(Constants.SkillType.Strong)){\n modifiers[Constants.Ability.Strength] += 1;\n }\n\n return {\n abilityScoreBonuses: abilityScoreBonuses,\n abilityScores: abilityScores,\n modifiers: modifiers,\n evasion: evasion,\n critChance: critChance,\n initiative: initiative,\n hpIncrement: hpIncrement\n };\n }\n\n static getModifiers(abilityScores) {\n return [\n parseInt(this.floor((abilityScores[Constants.Ability.Strength] - 10) / 2)),\n parseInt(this.floor((abilityScores[Constants.Ability.Dexterity] - 10) / 2)),\n parseInt(this.floor((abilityScores[Constants.Ability.Intelligence] - 10) / 2))\n ];\n }\n\n static floor(value)\n {\n return value>0 ? value >> 0 : (value -.5) >> 0;\n }\n\n static getValidActions(skills = [], skillTypes = [], skillsCooldown = [], isTaunted, isHiden, isInspired, enemyIsMarked, mainhand, offhand) {\n const {SkillType, ItemProperty, DamageType} = Constants;\n let mainHand = false;\n if (mainhand && mainhand !== null) {\n if (mainhand.properties && mainhand.properties !== null) {\n mainHand = true;\n }\n }\n \n let offHand = false;\n if (offhand && offhand !== null) {\n if (offhand.properties && offhand.properties !== null) {\n offHand = true;\n }\n }\n\n let skillIndex = -1;\n return skills.map(skill => {\n let validSkill = false;\n skillIndex++;\n if (skill) {\n if((mainHand && mainhand.properties[ItemProperty.Innocuous]) \n || (offHand && offhand.properties[ItemProperty.Innocuous]))\n {\n validSkill = !skill.isAttackAction;\n }\n else if(skill.isAttackAction)\n {\n if(isTaunted)\n {\n validSkill = false;\n }\n else if (skill.skillType === SkillType.Multiattack)\n {\n validSkill = mainHand && mainhand.properties[ItemProperty.Brutal] && mainhand.properties[ItemProperty.Heavy];\n } \n else if (skill.skillType === SkillType.Stab)\n {\n validSkill = !skillTypes.includes(SkillType.Warmongering) && \n ((mainHand && mainhand.damageOutputs && mainhand.damageOutputs !== null \n && mainhand.damageOutputs.length > 0 && mainhand.damageOutputs[0].type == DamageType.Slashing)\n || (offHand && offhand.damageOutputs && offhand.damageOutputs !== null \n && offhand.damageOutputs.length > 0 && offhand.damageOutputs[0].type == DamageType.Slashing));\n }\n else if(skill.skillType === SkillType.SneakAttack)\n {\n validSkill = (isHiden && (skillTypes.includes(SkillType.Hide) || skillTypes.includes(SkillType.Shadowy)))\n || (skillTypes.includes(SkillType.ImprovedSneakAttack) && (isInspired || enemyIsMarked));\n }\n else if(skill.skillType === SkillType.LockAndLoad)\n {\n validSkill = (mainHand && mainhand.properties[ItemProperty.Loading]) \n || (offHand && offhand.properties[ItemProperty.Loading]);\n }\n else if(skill.skillType === SkillType.Stun)\n {\n validSkill = mainHand && mainhand.properties[ItemProperty.Brutal] && mainhand.properties[ItemProperty.Heavy];\n }\n else\n {\n validSkill = true;\n }\n }\n else\n {\n validSkill = true;\n }\n }\n return validSkill == true && skillsCooldown[skillIndex] == false;\n });\n }\n\n static computeFighterStates(battle, state) {\n var fighterStates = state.fighterStates;\n\n for (var i = 0; i < 2; i++) {\n // initialize mutable derived stats\n const items = [battle.battlePlayers[i].mainhand, battle.battlePlayers[i].offhand, battle.battlePlayers[i].armor, battle.battlePlayers[i].hat];\n var derivedStats = BattleUtils.getDerivedStats(battle.battlePlayers[i].fighter, items);\n fighterStates[i].abilityScoreBonuses = derivedStats.abilityScoreBonuses;\n fighterStates[i].abilityScores = derivedStats.abilityScores;\n fighterStates[i].modifiers = derivedStats.modifiers;\n fighterStates[i].evasion = derivedStats.evasion;\n fighterStates[i].initiative = derivedStats.initiative;\n fighterStates[i].critChance = derivedStats.critChance;\n\n // offset modifiers and derived stats according to status effects\n if (BattleUtils.isUnderStatusEffect(fighterStates[i], Constants.StatusEffect.Hexed, fighterStates[i].turnCounter)) {\n fighterStates[i].modifiers[Constants.Ability.Dexterity] -= fighterStates[i].modifiers[Constants.Ability.Intelligence];\n }\n\n if (BattleUtils.isUnderStatusEffect(fighterStates[i], Constants.StatusEffect.Focused, fighterStates[i].turnCounter)) {\n fighterStates[i].modifiers[Constants.Ability.Intelligence] += fighterStates[i].modifiers[Constants.Ability.Intelligence];\n }\n\n let enemyIndex = i ? 0 : 1;\n fighterStates[i].validActions = BattleUtils.getValidActions(\n battle.battlePlayers[i].skills, \n battle.battlePlayers[i].fighter.skills, \n BattleUtils.activeCooldownList(fighterStates[i], fighterStates[i].turnCounter), \n BattleUtils.isUnderStatusEffect(fighterStates[i], Constants.StatusEffect.Taunted, fighterStates[i].turnCounter), \n BattleUtils.isUnderStatusEffect(fighterStates[i], Constants.StatusEffect.Hidden, fighterStates[i].turnCounter), \n BattleUtils.isUnderStatusEffect(fighterStates[i], Constants.StatusEffect.isInspired, fighterStates[i].turnCounter),\n BattleUtils.isUnderStatusEffect(fighterStates[enemyIndex], Constants.StatusEffect.Marked, fighterStates[enemyIndex].turnCounter),\n battle.battlePlayers[i].mainhand, \n battle.battlePlayers[i].offhand\n );\n fighterStates[i].evasion = BattleUtils.isUnderStatusEffect(fighterStates[i], Constants.StatusEffect.Ethereal, fighterStates[i].turnCounter) ? \n fighterStates[i].evasion + fighterStates[i].modifiers[Constants.Ability.Intelligence] : \n fighterStates[i].evasion;\n }\n\n return fighterStates;\n }\n\n static skipTurn(battle, state, dice) {\n const defenderState = state.fighterStates[state.playerToAct ? 0 : 1];\n const attackerState = state.fighterStates[state.playerToAct];\n const damageMap = Object.keys(Constants.DamageType).map(() => 0);\n const statusEffectMap = Object.keys(Constants.StatusEffect).map(() => 0);\n var actionLog = {\n playerIndex: state.playerToAct,\n actionLogMessage: `${this.getPrettifiedPlayerName(battle, state, false)} skipped turn`,\n results: [{\n rolls: [],\n outcome: Constants.Outcome.Success,\n damageOutput: [\n {\n damage: damageMap,\n defenderHp: defenderState.hp,\n defenderReduction: damageMap\n }\n ],\n attackerStatusEffectsIncrement: statusEffectMap,\n hpIncrement: 0,\n attackerHp: attackerState.hp\n }]\n };\n state.actionLogs.push(actionLog);\n\n return this.endTurn(battle, state, dice);\n }\n\n static endTurn(battle, state, dice) {\n var attackerIndex = state.playerToAct;\n var defenderIndex = state.playerToAct ? 0 : 1;\n\n if (state.fighterStates[0].hp > 0 && state.fighterStates[1].hp > 0) {\n if ( BattleUtils.isUnderStatusEffect(state.fighterStates[attackerIndex], Constants.StatusEffect.Cursed, state.fighterStates[attackerIndex].turnCounter)) {\n if (state.actionLogs && state.actionLogs.slice(-1).pop().skillType === Constants.SkillType.Vengeful) {\n let vengefulLog = `${this.getPrettifiedPlayerName(battle, state, true)} is vengeful\\n`;\n let damageMap = Object.keys(Constants.DamageType).map(() => 0);\n damageMap[Constants.DamageType.Necrotic] = 1;\n state.actionLogs.push(this.makeDamageActionLog(\n battle, \n state, \n state.fighterStates[attackerIndex], \n battle.battlePlayers[attackerIndex], \n damageMap, \n [], \n Constants.Outcome.Success, \n Constants.SkillType.Vengeful, \n vengefulLog, \n '', \n true\n ));\n } else {\n let damageMap = Object.keys(Constants.DamageType).map(() => 0);\n damageMap[Constants.DamageType.Necrotic] = 1;\n state.actionLogs.push(this.makeDamageActionLog(\n battle, \n state, \n state.fighterStates[attackerIndex], \n battle.battlePlayers[attackerIndex], \n damageMap, \n [], \n Constants.Outcome.Success, \n Constants.SkillType.Curse, \n '', \n '', \n true\n ));\n }\n }\n if ( BattleUtils.isUnderStatusEffect(\n state.fighterStates[attackerIndex], \n Constants.StatusEffect.Poisoned, \n state.fighterStates[attackerIndex].turnCounter)\n ) {\n var damage = dice.roll(1, 4);\n var roll = [{\n type: Constants.RollType.ToDamage,\n ability: Constants.Ability.Dexterity,\n size: 4,\n value: damage\n }];\n let damageMap = Object.keys(Constants.DamageType).map(() => 0);\n damageMap[Constants.DamageType.Poison] = damage;\n state.actionLogs.push(this.makeDamageActionLog(battle, state, state.fighterStates[attackerIndex], battle.battlePlayers[attackerIndex], damageMap, roll, Constants.Outcome.Success, Constants.SkillType.CoatWeapon, '', '', true));\n }\n\n let fatigueThreshold = 7; // TODO: I'd like this to be a global const, but not quite sure how to do that right now\n if (state.fighterStates[attackerIndex].turnCounter > fatigueThreshold) {\n let fatigueLog = `${this.getPrettifiedPlayerName(battle, state)} is fatigued\\n`;\n let damageMap = Object.keys(Constants.DamageType).map(() => 0);\n damageMap[Constants.DamageType.Necrotic] = state.fighterStates[attackerIndex].turnCounter - fatigueThreshold;\n state.actionLogs.push(this.makeDamageActionLog(\n battle, \n state, \n state.fighterStates[attackerIndex], \n battle.battlePlayers[attackerIndex], \n damageMap,\n [], \n Constants.Outcome.Success, \n Constants.SkillType.Curse, \n fatigueLog, \n '', \n true\n ));\n }\n\n if (BattleUtils.isUnderStatusEffect(state.fighterStates[defenderIndex], Constants.StatusEffect.Stunned, battle.turnCount)) {\n state.fighterStates[defenderIndex].turnCounter++;\n }else{\n state.playerToAct = (state.playerToAct + 1) % 2;\n }\n }\n \n if (state.fighterStates[0].hp <= 0 || state.fighterStates[1].hp <= 0) {\n const victorIndex = state.fighterStates[attackerIndex].hp > state.fighterStates[defenderIndex].hp ? attackerIndex : defenderIndex;\n\n if(victorIndex !== -1) {\n var results = state.actionLogs.slice(-1).pop().results;\n results.slice(-1).pop().resultMessage += `${this.getPrettifiedName(battle, victorIndex)} won`;\n state.playerToAct = victorIndex;\n state.victor = {\n pubkey: battle.battlePlayers[victorIndex].pubkey,\n userId: battle.battlePlayers[victorIndex].userId,\n owner: battle.battlePlayers[victorIndex].owner,\n fighter: battle.battlePlayers[victorIndex].fighter,\n };\n }\n\n state.status = Constants.Status.Complete;\n }\n\n state.fighterStates = BattleUtils.computeFighterStates(battle, state);\n state.fighterStates[attackerIndex].turnCounter++;\n\n return state;\n }\n\n static makeDamageActionLog(battle, state, defenderState, defenderPlayer, damageMap, rolls, outcome, skillType, log, preResultDescription, damageSelf = false) {\n return {\n playerIndex: state.playerToAct,\n skillType: skillType,\n results: [this.makeDamageResult(battle, state, defenderState, defenderPlayer, damageMap, rolls, outcome, preResultDescription, damageSelf)],\n actionLogMessage: log\n };\n }\n\n static makeDamageResult(battle, state, damageState, damagePlayer, damageMap, rolls, outcome, preResultDescription, damageSelf = false) {\n var playerName = BattleUtils.getPrettifiedPlayerName(battle, state);\n var opponentName = BattleUtils.getOpponentName(battle, state);\n\n console.log(`--------------------------------------------------------`);\n\n let resistances = this.getDefenderResistance(damagePlayer);\n let defenderReduction = Object.keys(Constants.DamageType).map(() => 0);\n let resultMessage = '';\n for (let i = 0; i < (damageMap || []).length; i++) {\n let resistance = resistances[i];\n expect(resistance).toBeInteger(`${playerName} unknown resistance ${i}`);\n expect(damageMap[i]).toBeInteger(`${playerName} unknown damageMap ${i}`);\n let inflictedDamage = damageMap[i] - resistance;\n inflictedDamage = (inflictedDamage < 0) ? 0 : inflictedDamage;\n defenderReduction[i] = damageMap[i] - inflictedDamage;\n damageState.hp -= inflictedDamage;\n expect(inflictedDamage).toBeInteger(`${playerName} inflicted unknown damage ${inflictedDamage}`);\n\n if (damageMap[i] > 0) {\n resultMessage += damageSelf ? `${playerName} takes damage : ` : `${playerName} damages ${opponentName} : `;\n resultMessage += `${inflictedDamage} (${damageMap[i]} ${Constants.DamageTypeNames[i]}${resistance > 0 ? ` - ${resistance} Resist` : ''})\\n`;\n }\n }\n\n return {\n rolls: rolls,\n outcome: outcome,\n damageOutput: [{\n damage: damageMap,\n defenderHp: damageSelf ? state.fighterStates[state.playerToAct ? 0 : 1].hp : Math.max(damageState.hp, 0),\n defenderReduction: defenderReduction\n }],\n attackerStatusEffectsIncrement: Object.keys(Constants.StatusEffect).map(() => 0),\n hpIncrement: 0,\n attackerHp: damageSelf ? damageState.hp : state.fighterStates[state.playerToAct].hp,\n preResultDescription: preResultDescription,\n resultMessage: resultMessage\n };\n }\n\n\n static directDamage(battle, state, dice, diceCount, diceFaces, defenderState, defenderPlayer, damageType, skill, log) {\n\n let rolls = [];\n let nativeRoll = diceFaces > 0 ? dice.roll(diceCount, diceFaces) : 0;\n rolls.push({\n type: 5,\n ability: Constants.Ability.Strength,\n size: diceFaces,\n value: nativeRoll\n });\n\n const damageMap = Object.keys(Constants.DamageType).map(() => 0);\n damageMap[damageType] = nativeRoll;\n return this.makeDamageActionLog(battle, state, defenderState, defenderPlayer, damageMap, rolls, Constants.Outcome.Success, skill, log);\n }\n\n static getDefenderMaxAbility(battle, state) {\n var abilities = battle.battlePlayers[state.playerToAct ? 0 : 1].fighter.abilityScores;\n var max = Math.max(...abilities);\n for (let i = 0; i < 3; ++i) {\n if (abilities[i] === max) {\n return i;\n }\n }\n return 2;\n }\n}",{"deps":{"Constants":{"$jig":0},"Dice":{"$jig":1},"FyxClass":{"$jig":2},"Math":{"$jig":3},"Sha256":{"$jig":4},"expect":{"$jig":5}},"hash":"9d29fd39187884d2a74e72be730d6af58626ec27bebddfe1858774894804d856"}]}]}