Skills with the same choice group at the same level = player picks one. + + +
+
+
π¬ Animation Tester
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+ 
+ 
`;
+ alt="Defense Up" title="Defense +${combatState.defenseBuffPercent}% (${combatState.defenseBuffTurns} turns)">`;
+ }
+
+ // Check for player accuracy buff
+ if (combatState.accuracyBuffTurns > 0) {
+ html += `
`;
+ }
+
+ // Check for player attack buff
+ if (combatState.attackBuffTurns > 0) {
+ html += `
`;
+ }
+
+ // Check for player dodge buff
+ if (combatState.dodgeBuffTurns > 0) {
+ html += `
`;
}
// Check for status effects (poison, etc.)
@@ -16181,6 +17267,8 @@
actualAnimation = monsterType.attackAnimation;
} else if (animationType === 'death' && monsterType.deathAnimation) {
actualAnimation = monsterType.deathAnimation;
+ } else if (animationType === 'miss' && monsterType.missAnimation) {
+ actualAnimation = monsterType.missAnimation;
}
}
@@ -16216,8 +17304,27 @@
}
}
+ // Get player animation for a skill, checking class skill override first
+ function getSkillPlayerAnimation(skillId, rawSkill) {
+ // First check class skill data for animation override
+ if (playerStats && playerStats.class && CLASS_SKILL_DATA[playerStats.class]) {
+ const classSkillData = CLASS_SKILL_DATA[playerStats.class][skillId];
+ if (classSkillData && classSkillData.player_animation) {
+ return classSkillData.player_animation;
+ }
+ }
+
+ // Fall back to skill type-based default
+ if (rawSkill && rawSkill.type) {
+ return rawSkill.type === 'damage' ? 'attack' : 'skill';
+ }
+
+ return 'attack'; // default
+ }
+
// Animate player attack - returns a Promise that resolves when animation completes
- function animatePlayerAttack() {
+ // rawSkill can contain skill data, skillId is used to look up class animation override
+ function animatePlayerAttack(rawSkill = null, skillId = null) {
return new Promise((resolve) => {
const playerEntry = document.querySelector('.player-entry');
if (!playerEntry) {
@@ -16225,17 +17332,78 @@
return;
}
- // Add attacking class to trigger animation
+ const icon = playerEntry.querySelector('.player-entry-icon');
+
+ // Determine which animation to use
+ let animationId = 'attack'; // default
+
+ // Get skill ID from rawSkill if not provided
+ const actualSkillId = skillId || (rawSkill ? rawSkill.id : null);
+
+ if (actualSkillId || rawSkill) {
+ animationId = getSkillPlayerAnimation(actualSkillId, rawSkill);
+ }
+
+ // Add attacking class for border glow effect
playerEntry.classList.add('attacking');
+ // Play the animation on the icon and get duration
+ let duration = 500;
+ if (icon) {
+ duration = playPlayerAnimation(icon, animationId);
+ }
+
// Remove class after animation completes
setTimeout(() => {
playerEntry.classList.remove('attacking');
+ if (icon) {
+ icon.style.animation = '';
+ }
+ resolve();
+ }, duration);
+ });
+ }
+
+ // Animate player miss - plays the miss animation and SFX
+ function animatePlayerMiss() {
+ return new Promise((resolve) => {
+ const playerEntry = document.querySelector('.player-entry');
+ if (!playerEntry) {
+ playSfx('missed');
+ resolve();
+ return;
+ }
+
+ const icon = playerEntry.querySelector('.player-entry-icon');
+
+ // Play miss animation
+ let duration = 2000;
+ if (icon) {
+ duration = playPlayerAnimation(icon, 'miss');
+ }
+
+ // Play miss SFX at the lunge point (20% through - when the miss "lands")
+ setTimeout(() => {
+ playSfx('missed');
+ }, Math.floor(duration * 0.2));
+
+ // Resolve after animation completes
+ setTimeout(() => {
+ if (icon) {
+ icon.style.animation = '';
+ }
resolve();
- }, 500);
+ }, duration);
});
}
+ // Play attack/skill SFX based on skill type
+ function playPlayerAttackSfx(rawSkill) {
+ const skillType = rawSkill ? rawSkill.type : 'damage';
+ const sfxName = (skillType === 'damage') ? 'player_attack' : 'player_skill';
+ playSfx(sfxName);
+ }
+
// Scroll to a monster and animate receiving damage - returns Promise
function scrollToMonsterAndAnimate(monsterIndex, animationType = 'attack') {
return new Promise((resolve) => {
@@ -16258,22 +17426,9 @@
// Highlight the entry being attacked
entry.classList.add('selected');
- // Wait for scroll, then animate
+ // Wait for scroll to complete, then resolve
setTimeout(() => {
- const icon = entry.querySelector('.monster-entry-icon');
- if (icon) {
- // Simple hit reaction animation
- icon.style.animation = 'none';
- icon.offsetHeight; // Force reflow
- icon.style.animation = 'monsterAttack 0.4s ease-out reverse';
-
- setTimeout(() => {
- icon.style.animation = '';
- resolve();
- }, 400);
- } else {
- resolve();
- }
+ resolve();
}, 300);
});
}
@@ -16285,12 +17440,13 @@
const skillTarget = rawSkill ? rawSkill.target : (skill.target || 'enemy');
let rawDamage;
+ const effectiveAtk = getEffectivePlayerAttack();
if (rawSkill && rawSkill.calculate) {
- rawDamage = rawSkill.calculate(combatState.player.atk);
+ rawDamage = rawSkill.calculate(effectiveAtk);
} else if (rawSkill && rawSkill.basePower) {
- rawDamage = Math.floor(combatState.player.atk * (rawSkill.basePower / 100));
+ rawDamage = Math.floor(effectiveAtk * (rawSkill.basePower / 100));
} else {
- rawDamage = combatState.player.atk;
+ rawDamage = effectiveAtk;
}
let grandTotalDamage = 0;
@@ -16310,27 +17466,26 @@
continue;
}
- // Animate player attacking
- await animatePlayerAttack();
-
- // Scroll to and highlight the target
- await scrollToMonsterAndAnimate(targetIndex);
-
- // Calculate hit
+ // Calculate hit FIRST (before any animation)
const hitChance = calculateHitChance(
- combatState.player.accuracy,
+ getEffectivePlayerAccuracy(),
currentTarget.dodge,
skillAccuracy
);
if (!rollHit(hitChance)) {
+ // Miss - play miss animation only
addCombatLog(`β ${displayName} missed ${currentTarget.data.name}! (${hitChance}% chance)`, 'miss');
- playSfx('missed');
- // Brief pause before next attack
- await new Promise(r => setTimeout(r, 300));
+ await animatePlayerMiss();
continue;
}
+ // Hit - play attack animation, then scroll to target
+ await animatePlayerAttack(rawSkill, skillId);
+ await scrollToMonsterAndAnimate(targetIndex);
+
+ // Play hit SFX
+ playPlayerAttackSfx(rawSkill);
monstersHit++;
// Calculate effective defense
@@ -16356,10 +17511,8 @@
// Log the hit
if (hitsOnThisTarget > 1) {
addCombatLog(`β¨ ${displayName} hits ${currentTarget.data.name} ${hitsOnThisTarget} times for ${totalDamage} total damage!`, 'damage');
- playSfx('player_skill');
} else {
addCombatLog(`βοΈ ${displayName} hits ${currentTarget.data.name} for ${totalDamage} damage!`, 'damage');
- playSfx('player_attack');
}
// Check if killed
@@ -16487,6 +17640,70 @@
entry.onclick = () => selectTarget(index);
container.appendChild(entry);
});
+
+ // Update mini enemy roster
+ renderMiniEnemyRoster();
+ }
+
+ // Render mini enemy roster - small icons showing all enemies
+ function renderMiniEnemyRoster() {
+ const container = document.getElementById('miniEnemyRoster');
+ if (!container || !combatState) return;
+
+ container.innerHTML = '';
+
+ combatState.monsters.forEach((monster, index) => {
+ const img = document.createElement('img');
+ img.className = 'mini-enemy-icon';
+ img.src = `/mapgameimgs/monsters/${monster.type}100.png`;
+ img.onerror = () => { img.src = '/mapgameimgs/monsters/default100.png'; };
+ img.title = `${monster.namePrefix || ''}${monster.data.name} Lv.${monster.level}`;
+ img.dataset.index = index;
+
+ // Apply state classes
+ if (index === combatState.selectedTargetIndex) {
+ img.classList.add('selected');
+ }
+ if (monster.hp <= 0) {
+ img.classList.add('dead');
+ }
+ if (combatState.turn === 'monster' && index === combatState.currentMonsterTurn && monster.hp > 0) {
+ img.classList.add('attacking');
+ }
+
+ // Apply animation if one is active on main icon
+ if (monster.hp <= 0) {
+ // Death animation
+ const monsterType = monster.data;
+ const deathAnimId = monsterType?.deathAnimation || 'death';
+ const deathAnim = typeof MONSTER_ANIMATIONS !== 'undefined' ? MONSTER_ANIMATIONS[deathAnimId] : null;
+ if (deathAnim) {
+ const fillStr = deathAnim.fillMode ? ` ${deathAnim.fillMode}` : ' forwards';
+ const easing = deathAnim.easing || 'ease-out';
+ img.style.animation = `monster_${deathAnimId} ${deathAnim.duration}ms ${easing}${fillStr}`;
+ }
+ } else if (monsterActiveAnimations[index]) {
+ // Mirror active animation
+ const activeAnim = monsterActiveAnimations[index];
+ const elapsed = Date.now() - activeAnim.startTime;
+ if (elapsed < activeAnim.duration) {
+ const anim = MONSTER_ANIMATIONS[activeAnim.animId];
+ if (anim) {
+ const easing = anim.easing || 'ease-out';
+ const loopStr = anim.loop ? ' infinite' : '';
+ const fillStr = anim.fillMode ? ` ${anim.fillMode}` : '';
+ // Sync animation timing
+ img.style.animation = `monster_${activeAnim.animId} ${anim.duration}ms ${easing}${loopStr}${fillStr}`;
+ img.style.animationDelay = `-${elapsed}ms`;
+ }
+ }
+ }
+
+ // Click to select target
+ img.onclick = () => selectTarget(index);
+
+ container.appendChild(img);
+ });
}
// Select a monster as target
@@ -16546,18 +17763,20 @@
const displayName = skill.displayName || skill.name;
const targetIndices = combatState.pendingTargets;
const rawSkill = skill.rawSkill;
+ const skillId = skill.skillId;
// Exit targeting mode
combatState.targetingMode = false;
// Calculate base damage
let rawDamage;
+ const effectiveAtk = getEffectivePlayerAttack();
if (rawSkill && rawSkill.calculate) {
- rawDamage = rawSkill.calculate(combatState.player.atk);
+ rawDamage = rawSkill.calculate(effectiveAtk);
} else if (rawSkill && rawSkill.basePower) {
- rawDamage = Math.floor(combatState.player.atk * (rawSkill.basePower / 100));
+ rawDamage = Math.floor(effectiveAtk * (rawSkill.basePower / 100));
} else {
- rawDamage = combatState.player.atk;
+ rawDamage = effectiveAtk;
}
const skillAccuracy = rawSkill ? (rawSkill.accuracy || 95) : 95;
@@ -16576,27 +17795,28 @@
continue;
}
- // Animate player attacking
- await animatePlayerAttack();
-
- // Scroll to and highlight the target monster
- await scrollToMonsterAndAnimate(targetIndex);
-
- // Calculate hit chance
+ // Calculate hit chance FIRST (before any animation)
const hitChance = calculateHitChance(
- combatState.player.accuracy,
+ getEffectivePlayerAccuracy(),
currentTarget.dodge,
skillAccuracy
);
// Roll for hit
if (!rollHit(hitChance)) {
+ // Miss - play miss animation only
addCombatLog(`β Hit ${hitNum + 1}: Missed ${currentTarget.data.name}! (${hitChance}% chance)`, 'miss');
- playSfx('missed');
- await new Promise(r => setTimeout(r, 300));
+ await animatePlayerMiss();
continue;
}
+ // Hit - play attack animation, then scroll to target
+ await animatePlayerAttack(rawSkill, skillId);
+ await scrollToMonsterAndAnimate(targetIndex);
+
+ // Play hit SFX
+ playPlayerAttackSfx(rawSkill);
+
// Calculate effective defense
let effectiveMonsterDef = currentTarget.def;
if (currentTarget.buffs && currentTarget.buffs.defense && currentTarget.buffs.defense.turnsLeft > 0) {
@@ -16612,7 +17832,6 @@
hitsLanded++;
addCombatLog(`βοΈ Hit ${hitNum + 1}: ${damage} damage to ${currentTarget.data.name}!`, 'damage');
- playSfx('player_attack');
// Check if this killed the monster
if (currentTarget.hp <= 0) {
@@ -16782,10 +18001,38 @@
if (combatState.defenseBuffTurns > 0) {
combatState.defenseBuffTurns--;
if (combatState.defenseBuffTurns === 0) {
+ combatState.defenseBuffPercent = 0;
addCombatLog(`π‘οΈ Defense buff expired!`);
}
}
+ // Decrement accuracy buff
+ if (combatState.accuracyBuffTurns > 0) {
+ combatState.accuracyBuffTurns--;
+ if (combatState.accuracyBuffTurns === 0) {
+ combatState.accuracyBuffPercent = 0;
+ addCombatLog(`π― Accuracy buff expired!`);
+ }
+ }
+
+ // Decrement attack buff
+ if (combatState.attackBuffTurns > 0) {
+ combatState.attackBuffTurns--;
+ if (combatState.attackBuffTurns === 0) {
+ combatState.attackBuffPercent = 0;
+ addCombatLog(`βοΈ Attack buff expired!`);
+ }
+ }
+
+ // Decrement dodge buff
+ if (combatState.dodgeBuffTurns > 0) {
+ combatState.dodgeBuffTurns--;
+ if (combatState.dodgeBuffTurns === 0) {
+ combatState.dodgeBuffPercent = 0;
+ addCombatLog(`β‘ Dodge buff expired!`);
+ }
+ }
+
return true;
}
@@ -16835,7 +18082,7 @@
// Enter targeting mode
combatState.targetingMode = true;
- combatState.pendingSkill = { ...skill, displayName, rawSkill: dbSkill || hardcodedSkill };
+ combatState.pendingSkill = { ...skill, skillId, displayName, rawSkill: dbSkill || hardcodedSkill };
combatState.pendingTargets = [];
combatState.totalHitsToSelect = hitCount;
@@ -16861,7 +18108,7 @@
// Execute with random targets
combatState.targetingMode = true;
- combatState.pendingSkill = { ...skill, displayName, rawSkill: dbSkill || hardcodedSkill };
+ combatState.pendingSkill = { ...skill, skillId, displayName, rawSkill: dbSkill || hardcodedSkill };
combatState.pendingTargets = randomTargets;
combatState.totalHitsToSelect = hitCount;
executeMultiHitSkill();
@@ -16900,10 +18147,8 @@
// Determine targets based on skill.target (reuse variables from above)
const targets = skillTarget === 'all_enemies' ? livingMonsters : [target];
- // Animate player attack
- await animatePlayerAttack();
-
// For all_enemies skills with multiple targets, animate each hit sequentially
+ // (executeAnimatedPlayerSkill handles hit checks and animations internally)
if (skillTarget === 'all_enemies' && targets.length > 1) {
const targetIndices = targets.map(t => combatState.monsters.indexOf(t));
await executeAnimatedPlayerSkill(skillId, targetIndices, skill, displayName, dbSkill || hardcodedSkill);
@@ -16918,19 +18163,15 @@
return;
}
- // Scroll to the target monster for single-target attacks
- if (targets.length === 1) {
- await scrollToMonsterAndAnimate(combatState.selectedTargetIndex);
- }
-
// Calculate base damage - support both old calculate() and new basePower
let rawDamage;
+ const effectiveAtk = getEffectivePlayerAttack();
if (hardcodedSkill && hardcodedSkill.calculate) {
- rawDamage = hardcodedSkill.calculate(combatState.player.atk);
+ rawDamage = hardcodedSkill.calculate(effectiveAtk);
} else if (dbSkill) {
- rawDamage = Math.floor(combatState.player.atk * (dbSkill.basePower / 100));
+ rawDamage = Math.floor(effectiveAtk * (dbSkill.basePower / 100));
} else {
- rawDamage = combatState.player.atk;
+ rawDamage = effectiveAtk;
}
const hitCount = skill.hitCount || skill.hits || 1;
@@ -16941,9 +18182,9 @@
// Apply damage to each target
for (const currentTarget of targets) {
- // Calculate hit chance for this target
+ // Calculate hit chance FIRST (before any animation)
const hitChance = calculateHitChance(
- combatState.player.accuracy,
+ getEffectivePlayerAccuracy(),
currentTarget.dodge,
skillAccuracy
);
@@ -16951,12 +18192,21 @@
// Roll for hit
if (!rollHit(hitChance)) {
if (targets.length === 1) {
+ // Miss - play miss animation only
addCombatLog(`β ${displayName} missed ${currentTarget.data.name}! (${hitChance}% chance)`, 'miss');
- playSfx('missed');
+ await animatePlayerMiss();
}
continue; // Miss this target, continue to next
}
+ // Hit - play attack animation and scroll to target
+ await animatePlayerAttack(dbSkill || hardcodedSkill, skillId);
+ if (targets.length === 1) {
+ await scrollToMonsterAndAnimate(combatState.selectedTargetIndex);
+ }
+
+ // Play hit SFX
+ playPlayerAttackSfx(dbSkill || hardcodedSkill);
monstersHit++;
let totalDamage = 0;
@@ -16980,10 +18230,8 @@
if (targets.length === 1) {
if (hitCount > 1) {
addCombatLog(`β¨ ${displayName} hits ${currentTarget.data.name} ${hitCount} times for ${totalDamage} total damage!`, 'damage');
- playSfx('player_skill');
} else {
addCombatLog(`βοΈ ${displayName} hits ${currentTarget.data.name} for ${totalDamage} damage!`, 'damage');
- playSfx('player_attack');
}
}
@@ -17015,10 +18263,9 @@
if (targets.length > 1) {
if (monstersHit === 0) {
addCombatLog(`β ${displayName} missed all enemies!`, 'miss');
- playSfx('missed');
+ await animatePlayerMiss();
} else {
addCombatLog(`π ${displayName} hits ${monstersHit} enemies for ${grandTotalDamage} total damage!`, 'damage');
- playSfx('player_skill');
if (monstersKilled > 0) {
const totalXpGained = combatState.player.xpGained || 0;
addCombatLog(`π ${monstersKilled} enemy${monstersKilled > 1 ? 'ies' : ''} defeated! +${totalXpGained} XP`, 'victory');
@@ -17031,6 +18278,9 @@
autoRetarget();
}
} else if (skill.type === 'heal') {
+ // Animate player using heal skill
+ await animatePlayerAttack(dbSkill || hardcodedSkill, skillId);
+
let healAmount;
if (hardcodedSkill && hardcodedSkill.calculate) {
healAmount = hardcodedSkill.calculate(combatState.player.maxHp);
@@ -17042,11 +18292,39 @@
combatState.player.hp = Math.min(combatState.player.maxHp, combatState.player.hp + healAmount);
addCombatLog(`π ${displayName}! Healed ${healAmount} HP!`, 'heal');
} else if (skill.type === 'buff') {
- // Handle defense buff
- if (dbSkill && dbSkill.statusEffect && dbSkill.statusEffect.type === 'defense_up') {
- combatState.defenseBuffTurns = dbSkill.statusEffect.duration || 2;
- const buffPercent = dbSkill.statusEffect.percent || 50;
- addCombatLog(`π‘οΈ ${displayName}! DEF +${buffPercent}% for ${combatState.defenseBuffTurns} turns!`, 'buff');
+ // Animate player using buff skill
+ await animatePlayerAttack(dbSkill || hardcodedSkill, skillId);
+
+ // Handle buff skills based on effect type
+ if (dbSkill && dbSkill.statusEffect) {
+ const buffType = dbSkill.statusEffect.type;
+ const buffPercent = dbSkill.statusEffect.percent || 20;
+ const buffDuration = dbSkill.statusEffect.duration || 3;
+
+ switch (buffType) {
+ case 'defense_up':
+ combatState.defenseBuffTurns = buffDuration;
+ combatState.defenseBuffPercent = buffPercent;
+ addCombatLog(`π‘οΈ ${displayName}! DEF +${buffPercent}% for ${buffDuration} turns!`, 'buff');
+ break;
+ case 'accuracy_up':
+ combatState.accuracyBuffTurns = buffDuration;
+ combatState.accuracyBuffPercent = buffPercent;
+ addCombatLog(`π― ${displayName}! Accuracy +${buffPercent}% for ${buffDuration} turns!`, 'buff');
+ break;
+ case 'attack_up':
+ combatState.attackBuffTurns = buffDuration;
+ combatState.attackBuffPercent = buffPercent;
+ addCombatLog(`βοΈ ${displayName}! ATK +${buffPercent}% for ${buffDuration} turns!`, 'buff');
+ break;
+ case 'dodge_up':
+ combatState.dodgeBuffTurns = buffDuration;
+ combatState.dodgeBuffPercent = buffPercent;
+ addCombatLog(`β‘ ${displayName}! Dodge +${buffPercent}% for ${buffDuration} turns!`, 'buff');
+ break;
+ default:
+ addCombatLog(`β¨ ${displayName}! Buff activated!`, 'buff');
+ }
} else if (hardcodedSkill && hardcodedSkill.effect === 'dodge') {
// Legacy dodge buff
addCombatLog(`β‘ ${displayName}! Next attack will be dodged!`);
@@ -17161,11 +18439,11 @@
updateCombatUI();
}
- // Calculate hit chance
+ // Calculate hit chance (using player's effective dodge)
const skillAccuracy = selectedSkill.accuracy || 85;
const hitChance = calculateHitChance(
monster.accuracy,
- combatState.player.dodge,
+ getEffectivePlayerDodge(),
skillAccuracy
);
@@ -17183,11 +18461,11 @@
// Scroll to and animate the attacking monster with skill animation
setTimeout(() => animateMonsterAttack(monsterIndex, skillAnimation), 50);
- // Calculate effective defense (with buff if active)
- let effectiveDef = combatState.player.def;
- if (combatState.defenseBuffTurns > 0) {
- effectiveDef = Math.floor(effectiveDef * 1.5);
- }
+ // Get effective defense (using buff helper)
+ const effectiveDef = getEffectivePlayerDefense();
+
+ // Delay damage application to sync with animation "hit" moment (~500ms into animation)
+ const DAMAGE_DELAY = 500;
// Handle different skill types
if (selectedSkill.type === 'buff') {
@@ -17198,84 +18476,100 @@
const duration = selectedSkill.statusEffect.duration || 2;
const percent = selectedSkill.statusEffect.percent || 50;
monster.buffs.defense = { turnsLeft: duration, percent: percent };
- addCombatLog(`π‘οΈ ${monster.namePrefix || ''}${monster.data.name} uses ${selectedSkill.name}! Defense increased by ${percent}%!`, 'buff');
+ setTimeout(() => {
+ addCombatLog(`π‘οΈ ${monster.namePrefix || ''}${monster.data.name} uses ${selectedSkill.name}! Defense increased by ${percent}%!`, 'buff');
+ updateCombatUI();
+ }, DAMAGE_DELAY);
} else {
// Generic buff
monster.buffs.generic = { turnsLeft: 2 };
- addCombatLog(`β¨ ${monster.namePrefix || ''}${monster.data.name} uses ${selectedSkill.name}!`, 'buff');
+ setTimeout(() => {
+ addCombatLog(`β¨ ${monster.namePrefix || ''}${monster.data.name} uses ${selectedSkill.name}!`, 'buff');
+ updateCombatUI();
+ }, DAMAGE_DELAY);
}
} else if (selectedSkill.type === 'heal') {
// Heal skill - monster heals itself
const healAmount = Math.floor(selectedSkill.basePower || 50);
- const oldHp = monster.hp;
- monster.hp = Math.min(monster.maxHp, monster.hp + healAmount);
- const actualHeal = monster.hp - oldHp;
- addCombatLog(`π ${monster.namePrefix || ''}${monster.data.name} uses ${selectedSkill.name}! Restored ${actualHeal} HP!`, 'heal');
+ setTimeout(() => {
+ const oldHp = monster.hp;
+ monster.hp = Math.min(monster.maxHp, monster.hp + healAmount);
+ const actualHeal = monster.hp - oldHp;
+ addCombatLog(`π ${monster.namePrefix || ''}${monster.data.name} uses ${selectedSkill.name}! Restored ${actualHeal} HP!`, 'heal');
+ updateCombatUI();
+ }, DAMAGE_DELAY);
} else if (selectedSkill.type === 'status') {
// Status effect skill (like poison)
const baseDamage = selectedSkill.basePower || 20;
const damage = Math.max(1, Math.floor(monster.atk * (baseDamage / 100)) - effectiveDef);
- combatState.player.hp -= damage;
-
- // Apply status effect
- if (selectedSkill.statusEffect) {
- const effect = selectedSkill.statusEffect;
- // Check if already poisoned
- const existing = combatState.playerStatusEffects.find(e => e.type === effect.type);
- if (!existing) {
- // Scale status effect damage with monster ATK: baseDamage Γ (1 + ATK/20)
- const baseDmg = effect.damage || 5;
- const scaledDamage = Math.ceil(baseDmg * (1 + monster.atk / 20));
- combatState.playerStatusEffects.push({
- type: effect.type,
- damage: scaledDamage,
- turnsLeft: effect.duration || 3
- });
- addCombatLog(`π₯ ${monster.namePrefix || ''}${monster.data.name} uses ${selectedSkill.name}! ${damage} damage + ${effect.type} (${scaledDamage}/turn) applied!`, 'damage');
- setTimeout(() => playSfx('monster_skill'), 650); // Sync with animation
- } else {
- addCombatLog(`π₯ ${monster.namePrefix || ''}${monster.data.name} uses ${selectedSkill.name}! ${damage} damage! (Already ${effect.type}ed)`, 'damage');
- setTimeout(() => playSfx('monster_skill'), 650); // Sync with animation
+
+ setTimeout(() => {
+ combatState.player.hp -= damage;
+
+ // Apply status effect
+ if (selectedSkill.statusEffect) {
+ const effect = selectedSkill.statusEffect;
+ // Check if already poisoned
+ const existing = combatState.playerStatusEffects.find(e => e.type === effect.type);
+ if (!existing) {
+ // Scale status effect damage with monster ATK: baseDamage Γ (1 + ATK/20)
+ const baseDmg = effect.damage || 5;
+ const scaledDamage = Math.ceil(baseDmg * (1 + monster.atk / 20));
+ combatState.playerStatusEffects.push({
+ type: effect.type,
+ damage: scaledDamage,
+ turnsLeft: effect.duration || 3
+ });
+ addCombatLog(`π₯ ${monster.namePrefix || ''}${monster.data.name} uses ${selectedSkill.name}! ${damage} damage + ${effect.type} (${scaledDamage}/turn) applied!`, 'damage');
+ } else {
+ addCombatLog(`π₯ ${monster.namePrefix || ''}${monster.data.name} uses ${selectedSkill.name}! ${damage} damage! (Already ${effect.type}ed)`, 'damage');
+ }
}
- }
+ playSfx('monster_skill');
+ updateCombatUI();
+
+ // Check for defeat
+ if (combatState.player.hp <= 0) {
+ handleCombatDefeat();
+ }
+ }, DAMAGE_DELAY);
} else {
// Regular damage skill or basic attack
const basePower = selectedSkill.basePower || 100;
const rawDamage = Math.floor(monster.atk * (basePower / 100));
const hitCount = selectedSkill.hitCount || 1;
- let totalDamage = 0;
- // Apply monster's defense buff reduction to player's damage? No - this is monster attacking player
- // But we should factor in monster's attack buff if it has one
+ setTimeout(() => {
+ let totalDamage = 0;
- for (let hit = 0; hit < hitCount; hit++) {
- const baseDamage = calculateDamage(rawDamage, effectiveDef);
- const damage = applyDamageVariance(baseDamage);
- totalDamage += damage;
- combatState.player.hp -= damage;
- }
+ for (let hit = 0; hit < hitCount; hit++) {
+ const baseDamage = calculateDamage(rawDamage, effectiveDef);
+ const damage = applyDamageVariance(baseDamage);
+ totalDamage += damage;
+ combatState.player.hp -= damage;
+ }
- // Only show generic "attacks" if it's basic_attack with no custom name
- const isGenericAttack = (selectedSkill.id === 'basic_attack' && selectedSkill.name === 'Attack');
+ // Only show generic "attacks" if it's basic_attack with no custom name
+ const isGenericAttack = (selectedSkill.id === 'basic_attack' && selectedSkill.name === 'Attack');
- if (isGenericAttack) {
- addCombatLog(`βοΈ ${monster.namePrefix || ''}${monster.data.name} attacks! You take ${totalDamage} damage!`, 'damage');
- setTimeout(() => playSfx('monster_attack'), 650); // Sync with animation
- } else if (hitCount > 1) {
- addCombatLog(`π₯ ${monster.namePrefix || ''}${monster.data.name} uses ${selectedSkill.name}! ${hitCount} hits for ${totalDamage} total damage!`, 'damage');
- setTimeout(() => playSfx('monster_skill'), 650); // Sync with animation
- } else {
- addCombatLog(`π₯ ${monster.namePrefix || ''}${monster.data.name} uses ${selectedSkill.name}! You take ${totalDamage} damage!`, 'damage');
- setTimeout(() => playSfx('monster_skill'), 650); // Sync with animation
- }
- }
+ if (isGenericAttack) {
+ addCombatLog(`βοΈ ${monster.namePrefix || ''}${monster.data.name} attacks! You take ${totalDamage} damage!`, 'damage');
+ playSfx('monster_attack');
+ } else if (hitCount > 1) {
+ addCombatLog(`π₯ ${monster.namePrefix || ''}${monster.data.name} uses ${selectedSkill.name}! ${hitCount} hits for ${totalDamage} total damage!`, 'damage');
+ playSfx('monster_skill');
+ } else {
+ addCombatLog(`π₯ ${monster.namePrefix || ''}${monster.data.name} uses ${selectedSkill.name}! You take ${totalDamage} damage!`, 'damage');
+ playSfx('monster_skill');
+ }
- updateCombatUI();
+ updateCombatUI();
- // Check for defeat
- if (combatState.player.hp <= 0) {
- handleCombatDefeat();
- return;
+ // Check for defeat
+ if (combatState.player.hp <= 0) {
+ handleCombatDefeat();
+ }
+ }, DAMAGE_DELAY);
}
// Move to next monster
@@ -17445,6 +18739,16 @@
initMusic();
initSfx();
+ // Initialize admin monster spawn autocomplete
+ setupMonsterSearchAutocomplete();
+
+ // Auto-start GPS tracking on page load
+ setTimeout(() => {
+ if (navigator.geolocation && gpsWatchId === null) {
+ toggleGPS();
+ }
+ }, 1000);
+
// Start appropriate music on first user interaction (required due to autoplay restrictions)
let musicStarted = false;
function startMusicOnInteraction() {
diff --git a/mapgameimgs/monsters/karen_base100.png b/mapgameimgs/monsters/karen_base100.png
new file mode 100755
index 0000000..fec1c42
Binary files /dev/null and b/mapgameimgs/monsters/karen_base100.png differ
diff --git a/mapgameimgs/monsters/karen_base50.png b/mapgameimgs/monsters/karen_base50.png
new file mode 100755
index 0000000..5212ba4
Binary files /dev/null and b/mapgameimgs/monsters/karen_base50.png differ
diff --git a/mapgameimgs/skills/full_restore.png b/mapgameimgs/skills/full_restore.png
index 97fc9c4..8ec280e 100644
Binary files a/mapgameimgs/skills/full_restore.png and b/mapgameimgs/skills/full_restore.png differ
diff --git a/mapgamemusic/homebase.mp3 b/mapgamemusic/homebase.mp3
index 6938070..5c7323e 100755
Binary files a/mapgamemusic/homebase.mp3 and b/mapgamemusic/homebase.mp3 differ
diff --git a/server.js b/server.js
index 1a1d5da..11de35b 100644
--- a/server.js
+++ b/server.js
@@ -853,6 +853,7 @@ app.get('/api/user/rpg-stats', authenticateToken, (req, res) => {
isDead: !!stats.is_dead,
homeBaseIcon: stats.home_base_icon || '00',
revealRadius: stats.reveal_radius || 800,
+ wanderRange: stats.wander_range || 200,
dataVersion: stats.data_version || 1
});
} else {
@@ -1378,6 +1379,7 @@ app.get('/api/monster-types', (req, res) => {
attackAnimation: t.attack_animation || 'attack',
deathAnimation: t.death_animation || 'death',
idleAnimation: t.idle_animation || 'idle',
+ missAnimation: t.miss_animation || 'miss',
// Spawn location restriction
spawnLocation: t.spawn_location || 'anywhere'
}));
@@ -2742,9 +2744,11 @@ wss.on('connection', (ws) => {
} else if (data.type === 'geocacheUpdate') {
// Handle geocache creation/update
if (data.geocache) {
+ console.log(`[GEOCACHE] Received update for cache ${data.geocache.id}, spawnRadius=${data.geocache.spawnRadius}, tags=${JSON.stringify(data.geocache.tags)}`);
const existingIndex = geocaches.findIndex(g => g.id === data.geocache.id);
if (existingIndex >= 0) {
// Update existing geocache
+ console.log(`[GEOCACHE] Updating existing cache at index ${existingIndex}`);
geocaches[existingIndex] = data.geocache;
} else {
// Add new geocache
diff --git a/service-worker.js b/service-worker.js
index a9e2f47..40f55c3 100644
--- a/service-worker.js
+++ b/service-worker.js
@@ -1,6 +1,6 @@
// HikeMap Service Worker
// Increment version to force cache refresh
-const CACHE_NAME = 'hikemap-v1.2.0';
+const CACHE_NAME = 'hikemap-v1.5.0';
const urlsToCache = [
'/',
'/index.html',
@@ -9,9 +9,8 @@ const urlsToCache = [
'/animations.js',
'/icon-192x192.png',
'/icon-512x512.png',
- 'https://unpkg.com/leaflet@1.9.4/dist/leaflet.css',
- 'https://unpkg.com/leaflet@1.9.4/dist/leaflet.js',
- 'https://unpkg.com/leaflet-rotate@0.2.8/dist/leaflet-rotate-src.js',
+ 'https://unpkg.com/maplibre-gl@4.1.0/dist/maplibre-gl.css',
+ 'https://unpkg.com/maplibre-gl@4.1.0/dist/maplibre-gl.js',
'https://cdn.jsdelivr.net/npm/@mdi/font@7.4.47/css/materialdesignicons.min.css'
];