class Example extends Phaser.Scene { constructor() { super(); this.chestPosition = null; // Initialize chest position this.isZooming = false; // Add flag to track zoom state this.currentPhase = 'player'; // Initialize phase this.turnCount = 1; // Initialize turn count this.showPartyList = false; // Define map types and their properties first this.mapTypes = { desert: { baseColor: 0xF4A460, name: 'Desert', movementCost: 2, description: 'A vast desert with challenging terrain.' }, plains: { baseColor: 0x90EE90, name: 'Plains', movementCost: 1, description: 'Open grasslands with good visibility.' }, city: { baseColor: 0x808080, name: 'City', movementCost: 1, description: 'Urban environment with buildings and streets.' }, forest: { baseColor: 0x228B22, name: 'Forest', movementCost: 2, description: 'Dense woodland with limited visibility.' }, swamp: { baseColor: 0x2F4F4F, name: 'Swamp', movementCost: 3, description: 'Marshy terrain with difficult movement.' }, mountain: { baseColor: 0x8B4513, name: 'Mountain', movementCost: 4, description: 'High altitude rocky terrain.' }, ocean: { baseColor: 0x000080, name: 'Ocean', movementCost: 5, description: 'Deep waters with scattered islands.' }, cave: { baseColor: 0x363636, name: 'Cave', movementCost: 2, description: 'Dark underground caverns.' }, castle: { baseColor: 0x708090, name: 'Castle', movementCost: 1, description: 'Ancient fortress with stone walls.' }, ice: { baseColor: 0xB0E0E6, name: 'Ice Field', movementCost: 3, description: 'Frozen wasteland with slippery terrain.' }, ruins: { baseColor: 0xDAA520, name: 'Desert Ruins', movementCost: 2, description: 'Ancient ruins buried in sand.' } }; // Get available maps and select a random one const availableMaps = Object.keys(this.mapTypes); // Keep selecting a new map until it's different from the current one let newMap; do { newMap = Phaser.Utils.Array.GetRandom(availableMaps); } while (newMap === this.currentMap && availableMaps.length > 1); this.currentMap = newMap; this.personalities = [{ name: 'Brave', hpMod: 2, atkMod: 3, defMod: 0, description: 'Fearless in battle', growthRates: { hp: 45, attack: 60, defense: 40 } }, { name: 'Cautious', hpMod: 3, atkMod: 0, defMod: 3, description: 'Always careful', growthRates: { hp: 55, attack: 40, defense: 55 } }, { name: 'Aggressive', hpMod: 0, atkMod: 4, defMod: 0, description: 'Seeks combat', growthRates: { hp: 40, attack: 65, defense: 35 } }, { name: 'Protective', hpMod: 2, atkMod: 0, defMod: 4, description: 'Guards allies', growthRates: { hp: 50, attack: 35, defense: 60 } }, { name: 'Balanced', hpMod: 2, atkMod: 2, defMod: 2, description: 'Well-rounded', growthRates: { hp: 50, attack: 50, defense: 50 } }, { name: 'Reckless', hpMod: -1, atkMod: 5, defMod: 0, description: 'Acts without thinking', growthRates: { hp: 35, attack: 70, defense: 30 } }, { name: 'Stoic', hpMod: 4, atkMod: 1, defMod: 1, description: 'Endures hardship', growthRates: { hp: 65, attack: 40, defense: 45 } }, { name: 'Cunning', hpMod: 0, atkMod: 3, defMod: 2, description: 'Clever tactician', growthRates: { hp: 45, attack: 55, defense: 50 } }, { name: 'Determined', hpMod: 3, atkMod: 2, defMod: 1, description: 'Never gives up', growthRates: { hp: 55, attack: 50, defense: 45 } }, { name: 'Disciplined', hpMod: 1, atkMod: 2, defMod: 3, description: 'Strictly trained', growthRates: { hp: 50, attack: 45, defense: 55 } }]; // Initialize or maintain static chapter counter // Remove chapter tracking this.currentChapter = 1; this.selectedMember = null; this.rangeGraphics = null; // Realistic skin tone palette (hex colors) this.skinTones = [ 0xffe0bd, 0xffcd94, 0xeac086, 0xffad60, 0xffe39f, 0xdeb887, 0xcd9045, 0x8b4513, 0xd7916b, 0xa0522d ]; this.names = ['Khalil', 'Sonya', 'Sunny', 'Daja', 'Verania', 'Brenden', 'Mohammed', 'Cristian', 'Mallory', 'Valentin', 'Leonard', 'Dontae', 'Devan', 'Landen', 'Immanuel', 'Ester', 'Giovanny', 'Jonah', 'Waylon', 'Lawson', 'Trevon', 'Mikaela', 'Rochelle', 'Daveon', 'Ezekiel', 'Donnie', 'Ashly', 'Willis', 'Gabriel', 'Raekwon', 'Benny', 'Madelyn', 'Jacquez', 'Allysa', 'Melissa', 'Kiara', 'Trayvon', 'Shlomo', 'Makiya', 'Ginger', 'Elexis', 'Xavier', 'Joshua', 'Enoch', 'Alia', 'Lidia', 'Hayden', 'Markel', 'Luca', 'Leonardo', 'Kameryn', 'Lacey', 'Raheem', 'Dallas', 'Yousef', 'Camryn', 'Madeleine', 'Kayleigh', 'Seamus', 'Blaise', 'Tyrese', 'Daron', 'Russell', 'Sommer', 'Francisco', 'Jarrod', 'Amirah', 'Dwayne', 'Kassidy', 'Juana', 'Dakoda', 'Eli', 'Martin', 'Ryann', 'Adriel', 'Kobi', 'Braiden', 'Tyler', 'Erika', 'Luc', 'Kayden', 'Isabelle', 'Joana', 'Averie', 'Baylee', 'Carolyn', 'Raphael', 'Lisbeth', 'Reilly', 'Darwin', 'Robin', 'Jennie', 'Makayla', 'Elaina', 'Casey', 'Miah', 'Kellie', 'Starr', 'Yamile', 'Isis', 'Stevie', 'Kaden', 'Daphne', 'Eugene', 'Marlee', 'Jaden', 'Arleth', 'Mathew', 'Zechariah', 'Darcy', 'Anai', 'Ivan', 'Calvin', 'Shannon', 'Jacoby', 'Terrance', 'Maverick', 'Jacquelyn', 'Esther', 'Jordan', 'Jarett', 'Celeste', 'Milena', 'Lilian', 'Simon', 'Beatriz', 'Linnea', 'Kamren', 'Elyssa', 'Janay', 'Gavyn', 'Citlali', 'Nayely', 'Marissa', 'Noah', 'Ellis', 'Karah', 'Sonny', 'Varun', 'Elias', 'Daija', 'Augustine', 'Frank', 'Julian', 'Bethanie', 'Kacie', 'Sarah', 'Erik', 'Jamila', 'Ryan', 'Eve', 'Breann', 'Kaci', 'Kegan', 'Jake', 'Victoria', 'Kenny', 'Darrian', 'Malachi', 'Kaley', 'Nyla', 'Tanya', 'Elian', 'Lorraine', 'Ciera', 'Jade', 'Cullen', 'Danica', 'Carter', 'Emani', 'Dominique', 'Samantha', 'Damian', 'Kavon', 'Bo', 'Tyanna', 'Klarissa', 'Lindsay', 'Tatianna', 'Alessandra', 'Alexis', 'Bethany', 'Arturo', 'Serina', 'Shania', 'Terry', 'Laisha', 'Braedon', 'Alivia', 'Brandt', 'Frances', 'Shawna', 'Zakary', 'Christopher', 'Esmeralda', 'Jose', 'Kristy', 'Anabel', 'Tamara', 'Marlon', 'Lucero', 'Carina', 'Sydney', 'Jairo', 'Devin', 'Josue', 'Jajuan', 'Winston', 'Sophia', 'Vincenzo', 'Kaleigh', 'Amaya', 'Quinton', 'Mikel', 'Carolina', 'Jasmyne', 'Finn', 'Jayson', 'Kourtney', 'Emely', 'Guadalupe', 'Sabina', 'Rhett', 'Denver', 'Nikita', 'Makenzi', 'Ashlyn', 'Jamarcus', 'Jacques', 'Cameron', 'Felicity', 'Dorien', 'Parker', 'Charisma', 'Codey', 'Brittney', 'Melinda', 'Eleazar', 'Zane', 'Whitney', 'Carlos', 'Ricky', 'Kaiden', 'Lila', 'Titus', 'Katy', 'Janeth', 'Ronaldo', 'Jean', 'Miracle', 'Annette', 'Leon', 'Nigel', 'Alisa', 'Elsie', 'Ladarius', 'Kristyn', 'Johnnie', 'Devante', 'Brayden', 'Miles', 'Clara', 'Dakota', 'Chiara', 'Kristopher', 'Flor', 'Stacy', 'Carleigh', 'Keegan', 'Zoie', 'Lena', 'Alysia', 'Baby', 'Darrien', 'Sylvia', 'Pearl', 'Jaliyah', 'Bernardo', 'Dion', 'Isela', 'Travis', 'Tatum', 'Federico', 'Kaylie', 'Deisy', 'Jaiden', 'Jarvis', 'Kari', 'Yamileth', 'Randolph', 'Dixie', 'Ruby', 'Joanna', 'Felix', 'Adia', 'Albert', 'Jazlyn', 'Blake', 'Nathanael', 'Dana', 'Daren', 'Valentina', 'Konner', 'Michelle', 'Kristal', 'Kortney', 'Harvey', 'Mekhi', 'Emalee', 'Konnor', 'Quincy', 'Dawson', 'Tyson', 'Austyn', 'Carlee', 'Jenna', 'Leif', 'Wade', 'Margarita', 'Zoey', 'Jackson', 'Heidi', 'Kenton', 'Mauro', 'Libby', 'Yesica', 'Pilar', 'Dangelo', 'Renee', 'Austen', 'Kelsy', 'Corrina', 'Edgardo', 'Bruce', 'Loren', 'Clifton', 'Kale', 'Joelle', 'Thomas', 'Tamera', 'Giovanna', 'Jeremiah', 'Jailene', 'Maryam', 'Rasheed', 'Everett', 'Serenity', 'Chaim', 'Nathaniel', 'Deion', 'Carlton', 'Leland', 'Amiah', 'Yvette', 'Brian', 'Maximus', 'Aubree', 'German', 'Kaliyah', 'Keyana', 'Elvin', 'Dayna', 'Mercedes', 'Tori', 'Luiz', 'Guillermo', 'Juan', 'Kendal', 'Tomas', 'Tyreek', 'Lainey', 'Katheryn', 'Sammy', 'Kristofer', 'Alexia', 'Chaz', 'Nicolle', 'Alesha', 'Antwan', 'Jamir', 'Devyn', 'Pranav', 'Morris', 'Candy', 'Estrella', 'Macy', 'Brennon', 'Johan', 'Destiney', 'Peyton', 'London', 'Harry', 'Briana', 'Markell', 'Kalynn', 'Kaylan', 'Bronson', 'Braulio', 'Cassandra', 'Natasha', 'Eunice', 'Tommy', 'Grayson', 'Kayleen', 'Naya', 'Nathan', 'Estefany', 'Keyon', 'Brenton', 'Kim', 'Madisyn', 'Hassan', 'Marisol', 'Jaycie', 'Veronica', 'Nash', 'Callie', 'Vicky', 'Myah', 'Randi', 'Angel', 'Nathalia', 'Aniya', 'Allison', 'Keelan', 'Brett', 'Emerald', 'Breonna', 'Mari', 'Jeanette', 'Clarence', 'Virginia', 'Kathryn', 'Jevon', 'Irving', 'Aliah', 'Latrell', 'Hasan', 'Jalin', 'Deanna', 'Deven', 'Karina', 'Noelia', 'Chelsea', 'Tyreese', 'Brisa', 'Alessandro', 'Monica', 'Penelope', 'Zara', 'Brannon', 'Sabastian', 'Chad', 'Natalya', 'Camilla', 'Katlynn', 'Kerrigan', 'Ireland', 'Ari', 'Cesar', 'Vivian', 'Siena', 'Avery', 'Sierra', 'Javonte', 'Jasper', 'Mckinley', 'Donna', 'Vincent', 'Christie', 'Blair', 'China', 'Kaleb', 'Tye', 'Jarrett', 'Keira', 'Raymundo', 'Deontae', 'Jayden', 'Madelyne', 'Dyllan', 'Katie', 'Neal', 'Kalia', 'Karli', 'Janice', 'Kerry', 'Aditya', 'Gemma', 'Annelise', 'Desmond', 'Scarlett', 'Donavan', 'Jonathon', 'Kaycee', 'Lauryn', 'Gregorio', 'Kaiya', 'Paxton', 'Jaquelyn']; // Define unified character classes with their promotion paths this.characterClasses = [ // Base Classes { tier: 1, name: 'Warrior', hpMod: 8, atkMod: 2, defMod: 2, growthRates: { hp: 15, attack: 20, defense: 10 } }, { tier: 1, name: 'Cut-Throat', hpMod: 4, atkMod: 3, defMod: 1, growthRates: { hp: 10, attack: 25, defense: 5 } }, { tier: 1, name: 'Guardian', hpMod: 6, atkMod: 1, defMod: 3, growthRates: { hp: 20, attack: 5, defense: 25 } }, { tier: 1, name: 'Fighter', hpMod: 5, atkMod: 3, defMod: 0, growthRates: { hp: 15, attack: 25, defense: 0 } }, { tier: 1, name: 'Cavalier', hpMod: 7, atkMod: 1, defMod: 4, growthRates: { hp: 20, attack: 10, defense: 20 } }, { tier: 1, name: 'Archer', hpMod: 4, atkMod: 4, defMod: 0, growthRates: { hp: 10, attack: 25, defense: 5 } }, { tier: 1, name: 'Cleric', hpMod: 6, atkMod: 1, defMod: 2, growthRates: { hp: 15, attack: 5, defense: 15 } }, { tier: 1, name: 'Brute', hpMod: 6, atkMod: 3, defMod: 1, growthRates: { hp: 20, attack: 20, defense: 5 } }, { tier: 1, name: 'Sentinel', hpMod: 4, atkMod: 1, defMod: 3, growthRates: { hp: 15, attack: 5, defense: 25 } }, { tier: 1, name: 'Striker', hpMod: 2, atkMod: 3, defMod: 0, growthRates: { hp: 5, attack: 30, defense: 5 } }, { tier: 1, name: 'Thief', hpMod: 3, atkMod: 4, defMod: 0, growthRates: { hp: 10, attack: 30, defense: 0 } }, { tier: 1, name: 'Commander', hpMod: 7, atkMod: 2, defMod: 2, growthRates: { hp: 20, attack: 15, defense: 15 } }, { tier: 1, name: 'Cultist', hpMod: 4, atkMod: 3, defMod: 1, growthRates: { hp: 10, attack: 25, defense: 5 } }, { tier: 1, name: 'Mercenary', hpMod: 2, atkMod: 2, defMod: 1, growthRates: { hp: 5, attack: 15, defense: 0 } }, { tier: 1, name: 'Fencer', hpMod: 5, atkMod: 4, defMod: 0, growthRates: { hp: 15, attack: 15, defense: 10 } } // Advanced Classes (Level 10 Promotions) , { name: 'Knight', tier: 2, baseName: 'Warrior', hpMod: 10, atkMod: 3, defMod: 3, growthRates: { hp: 20, attack: 25, defense: 15 } }, { name: 'Assassin', tier: 2, baseName: 'Cut-Throat', hpMod: 6, atkMod: 5, defMod: 1, growthRates: { hp: 15, attack: 30, defense: 10 } }, { name: 'Paladin', tier: 2, baseName: 'Guardian', hpMod: 8, atkMod: 2, defMod: 4, growthRates: { hp: 25, attack: 10, defense: 30 } }, { name: 'Berserker', tier: 2, baseName: 'Fighter', hpMod: 9, atkMod: 6, defMod: -1, growthRates: { hp: 20, attack: 35, defense: 5 } }, { name: 'Great Knight', tier: 2, baseName: 'Cavalier', hpMod: 10, atkMod: 2, defMod: 5, growthRates: { hp: 25, attack: 15, defense: 25 } }, { name: 'Sniper', tier: 2, baseName: 'Archer', hpMod: 6, atkMod: 6, defMod: 0, growthRates: { hp: 15, attack: 35, defense: 10 } }, { name: 'Bishop', tier: 2, baseName: 'Cleric', hpMod: 8, atkMod: 2, defMod: 3, growthRates: { hp: 20, attack: 15, defense: 20 } }, { name: 'Gladiator', tier: 2, baseName: 'Brute', hpMod: 8, atkMod: 5, defMod: 2, growthRates: { hp: 25, attack: 30, defense: 10 } }, { name: 'Fortress Knight', tier: 2, baseName: 'Sentinel', hpMod: 7, atkMod: 2, defMod: 5, growthRates: { hp: 20, attack: 10, defense: 35 } },{ name: 'Dark Knight', tier: 2, baseName: 'Cultist', hpMod: 7, atkMod: 4, defMod: 2, growthRates: { hp: 20, attack: 30, defense: 15 } }, { name: 'Duelist', tier: 2, baseName: 'Fencer', hpMod: 6, atkMod: 5, defMod: 1, growthRates: { hp: 15, attack: 35, defense: 10 } }, { name: 'Royal Guard', tier: 2, baseName: 'Commander', hpMod: 9, atkMod: 3, defMod: 3, growthRates: { hp: 25, attack: 20, defense: 20 } }, { name: 'Raider', tier: 2, baseName: 'Thief', hpMod: 5, atkMod: 6, defMod: 1, growthRates: { hp: 15, attack: 35, defense: 10 } }, { name: 'Blade Master', tier: 2, baseName: 'Striker', hpMod: 4, atkMod: 7, defMod: 1, growthRates: { hp: 10, attack: 40, defense: 10 } }, { name: 'Warlord', tier: 2, baseName: 'Mercenary', hpMod: 8, atkMod: 4, defMod: 2, growthRates: { hp: 20, attack: 25, defense: 15 } }, // Master Classes (Level 30 Promotions) { name: 'Grand Knight', tier: 3, baseName: 'Knight', hpMod: 12, atkMod: 4, defMod: 4, growthRates: { hp: 25, attack: 30, defense: 20 } }, { name: 'Shadow Master', tier: 3, baseName: 'Assassin', hpMod: 8, atkMod: 7, defMod: 2, growthRates: { hp: 20, attack: 35, defense: 15 } }, { name: 'Holy Knight', tier: 3, baseName: 'Paladin', hpMod: 10, atkMod: 3, defMod: 6, growthRates: { hp: 30, attack: 15, defense: 35 } }, { name: 'War Master', tier: 3, baseName: 'Berserker', hpMod: 12, atkMod: 8, defMod: 0, growthRates: { hp: 25, attack: 40, defense: 10 } }, { name: 'Divine Guard', tier: 3, baseName: 'Great Knight', hpMod: 14, atkMod: 3, defMod: 7, growthRates: { hp: 30, attack: 20, defense: 30 } }, { name: 'Bow Master', tier: 3, baseName: 'Sniper', hpMod: 8, atkMod: 9, defMod: 1, growthRates: { hp: 20, attack: 45, defense: 15 } }, { name: 'Sage', tier: 3, baseName: 'Bishop', hpMod: 10, atkMod: 4, defMod: 4, growthRates: { hp: 25, attack: 25, defense: 25 } }, { name: 'Champion', tier: 3, baseName: 'Gladiator', hpMod: 11, atkMod: 7, defMod: 3, growthRates: { hp: 30, attack: 35, defense: 15 } }, { name: 'Guardian Lord', tier: 3, baseName: 'Fortress Knight', hpMod: 10, atkMod: 3, defMod: 8, growthRates: { hp: 25, attack: 15, defense: 40 } }, { name: 'Death Knight', tier: 3, baseName: 'Dark Knight', hpMod: 10, atkMod: 6, defMod: 4, growthRates: { hp: 25, attack: 35, defense: 20 } }, { name: 'Blade Saint', tier: 3, baseName: 'Duelist', hpMod: 8, atkMod: 8, defMod: 2, growthRates: { hp: 20, attack: 40, defense: 15 } }, { name: 'King\'s Shield', tier: 3, baseName: 'Royal Guard', hpMod: 12, atkMod: 4, defMod: 5, growthRates: { hp: 30, attack: 25, defense: 25 } }, { name: 'Shadow Lord', tier: 3, baseName: 'Raider', hpMod: 7, atkMod: 9, defMod: 2, growthRates: { hp: 20, attack: 40, defense: 15 } }, { name: 'Sword Saint', tier: 3, baseName: 'Blade Master', hpMod: 6, atkMod: 10, defMod: 2, growthRates: { hp: 15, attack: 45, defense: 15 } }, { name: 'Supreme Commander', tier: 3, baseName: 'Warlord', hpMod: 11, atkMod: 6, defMod: 4, growthRates: { hp: 25, attack: 30, defense: 20 } }]; // Initialize empty party member data this.persistentPartyData = []; // If this is a new game (no saved data), initialize with random party size if (this.persistentPartyData.length === 0) { this.partySize = Phaser.Math.Between(3, 5); } this.moveableTiles = []; // Initialize moveableTiles array // Create party members array with random unique names this.partyMembers = []; this.partyPositions = []; // Store positions of party members this.enemies = []; // Store enemy data this.enemyPositions = []; // Store positions of enemies const usedIndexes = new Set(); // Generate persistent party member data for (let i = 0; i < this.partySize; i++) { let randomIndex; do { randomIndex = Phaser.Math.Between(0, this.names.length - 1); } while (usedIndexes.has(randomIndex)); usedIndexes.add(randomIndex); // Assign random class const tierOneClasses = this.characterClasses.filter(c => c.tier === 1); const characterClass = Phaser.Utils.Array.GetRandom(tierOneClasses); // Calculate stats with class modifiers (ensuring they don't exceed limits) const baseHp = 20; const baseAtk = 5; const baseDef = 3; // Create persistent member data // Randomly assign a personality const personality = Phaser.Utils.Array.GetRandom(this.personalities); // Calculate stats with class and personality modifiers (without limits) const totalHp = baseHp + characterClass.hpMod + personality.hpMod; const totalAtk = baseAtk + characterClass.atkMod + personality.atkMod; const totalDef = baseDef + characterClass.defMod + personality.defMod; this.persistentPartyData.push({ name: this.names[randomIndex], class: characterClass.name, personality: personality, maxHp: totalHp, currentHp: totalHp, baseAttack: totalAtk, attack: totalAtk, defense: totalDef, level: 1, enemiesKilled: 0, equippedWeapon: null, // Combine personality and class growth rates growthRates: { hp: personality.growthRates.hp + characterClass.growthRates.hp, attack: personality.growthRates.attack + characterClass.growthRates.attack, defense: personality.growthRates.defense + characterClass.growthRates.defense }, colors: { skinColor: Phaser.Utils.Array.GetRandom(this.skinTones), armorColor: Phaser.Math.RND.integerInRange(0x000000, 0xFFFFFF), accentColor: Phaser.Math.RND.integerInRange(0x000000, 0xFFFFFF), hairColor: Phaser.Math.RND.integerInRange(0x000000, 0xFFFFFF) } }); } } drawMoveRange(row, col) { // Clear existing range graphics if any if (this.rangeGraphics) { this.rangeGraphics.clear(); this.rangeGraphics.destroy(); } const tileSize = Math.min(this.cameras.main.width / 25, this.cameras.main.height / 25); const offsetX = (this.cameras.main.width - (tileSize * 25)) / 2; const offsetY = (this.cameras.main.height - (tileSize * 25)) / 2; // Create new graphics object for range this.rangeGraphics = this.add.graphics(); this.moveableTiles = []; // Store valid movement positions // Set the fill style for range tiles (semi-transparent blue) this.rangeGraphics.fillStyle(0x0088ff, 0.3); // Calculate and draw diamond pattern for (let r = -4; r <= 4; r++) { for (let c = -4; c <= 4; c++) { // Manhattan distance for diamond shape if (Math.abs(r) + Math.abs(c) <= 4) { const targetRow = row + r; const targetCol = col + c; // Check if the position is within grid bounds and not occupied if (targetRow >= 0 && targetRow < 25 && targetCol >= 0 && targetCol < 25) { // Check if position is not occupied by any character const isOccupied = [...this.partyPositions, ...this.enemyPositions].some(pos => pos.row === targetRow && pos.col === targetCol ); if (!isOccupied) { // Draw the range tile this.rangeGraphics.fillRect( offsetX + (targetCol * tileSize), offsetY + (targetRow * tileSize), tileSize, tileSize ); // Store valid movement position this.moveableTiles.push({ row: targetRow, col: targetCol }); } } } } } } create() { // Randomize the map type, ensuring it's different from the previous one const availableMaps = Object.keys(this.mapTypes); let newMap; do { newMap = Phaser.Utils.Array.GetRandom(availableMaps); } while (newMap === this.currentMap && availableMaps.length > 1); this.currentMap = newMap; // Set the background color to black this.cameras.main.setBackgroundColor('#000000'); const gameWidth = this.cameras.main.width; const gameHeight = this.cameras.main.height; const tileSize = Math.min(gameWidth / 25, gameHeight / 25); const graphics = this.add.graphics(); // Initialize grid to track occupied positions const occupiedPositions = Array(25).fill(null).map(() => Array(25).fill(false)); // Calculate offset to center the grid const offsetX = (gameWidth - (tileSize * 25)) / 2; const offsetY = (gameHeight - (tileSize * 25)) / 2; // Draw filled tiles // Create graphics objects const baseGraphics = this.add.graphics(); // for green tiles const blueGraphics = this.add.graphics(); // for blue tiles const gridLinesGraphics = this.add.graphics(); // for grid lines // Create and add new character const createNewCharacter = () => { // Get random name from names array const randomNameIndex = Phaser.Math.Between(0, this.names.length - 1); const characterName = this.names[randomNameIndex]; // Assign random class and personality const tierOneClasses = this.characterClasses.filter(c => c.tier === 1); const characterClass = Phaser.Utils.Array.GetRandom(tierOneClasses); const personality = Phaser.Utils.Array.GetRandom(this.personalities); // Calculate base stats const baseHp = 20; const baseAtk = 5; const baseDef = 3; // Calculate total stats with modifiers const totalHp = baseHp + characterClass.hpMod + personality.hpMod; const totalAtk = baseAtk + characterClass.atkMod + personality.atkMod; const totalDef = baseDef + characterClass.defMod + personality.defMod; // Create character data return { name: characterName, class: characterClass.name, personality: personality, maxHp: totalHp, currentHp: totalHp, attack: totalAtk, defense: totalDef, level: 1, enemiesKilled: 0, growthRates: { hp: personality.growthRates.hp + characterClass.growthRates.hp, attack: personality.growthRates.attack + characterClass.growthRates.attack, defense: personality.growthRates.defense + characterClass.growthRates.defense }, colors: { skinColor: Phaser.Utils.Array.GetRandom(this.skinTones), armorColor: Phaser.Math.RND.integerInRange(0x000000, 0xFFFFFF), accentColor: Phaser.Math.RND.integerInRange(0x000000, 0xFFFFFF), hairColor: Phaser.Math.RND.integerInRange(0x000000, 0xFFFFFF) } }; }; // Create new character // Determine number of recruits (0 to 3) const numRecruits = Phaser.Math.Between(0, 2); // Initialize recruits array this.newRecruit = null; this.additionalRecruits = []; // Create and position recruits for (let i = 0; i < numRecruits; i++) { const recruit = createNewCharacter(); let recruitPosition; do { recruitPosition = { row: Phaser.Math.Between(0, 24), col: Phaser.Math.Between(0, 24) }; } while (occupiedPositions[recruitPosition.row][recruitPosition.col]); // Mark position as occupied occupiedPositions[recruitPosition.row][recruitPosition.col] = true; // Store recruit data // Generate unique colors for each recruit const recruitColors = { skinColor: Phaser.Utils.Array.GetRandom(this.skinTones), armorColor: Phaser.Math.RND.integerInRange(0x000000, 0xFFFFFF), accentColor: Phaser.Math.RND.integerInRange(0x000000, 0xFFFFFF), hairColor: Phaser.Math.RND.integerInRange(0x000000, 0xFFFFFF) }; const recruitData = { member: recruit, row: recruitPosition.row, col: recruitPosition.col, colors: recruitColors // Use the newly generated colors }; // Assign first recruit to this.newRecruit for compatibility if (i === 0) { this.newRecruit = recruitData; } else { this.additionalRecruits.push(recruitData); } } // Draw green background tiles // Get current map properties const currentMapType = this.mapTypes[this.currentMap]; baseGraphics.fillStyle(currentMapType.baseColor); // Draw base tiles according to map type for (let row = 0; row < 25; row++) { for (let col = 0; col < 25; col++) { const x = offsetX + (col * tileSize); const y = offsetY + (row * tileSize); baseGraphics.fillRect(x, y, tileSize, tileSize); // Add map-specific details switch (this.currentMap) { case 'desert': baseGraphics.fillStyle(currentMapType.baseColor); baseGraphics.fillRect(x, y, tileSize, tileSize); if (Math.random() < 0.3) { baseGraphics.fillStyle(0xE6C388); baseGraphics.fillRect(x, y, tileSize, tileSize); baseGraphics.fillStyle(0xF4D03F); baseGraphics.fillRect(x, y, tileSize, tileSize / 4); } break; case 'forest': baseGraphics.fillStyle(currentMapType.baseColor); baseGraphics.fillRect(x, y, tileSize, tileSize); if (Math.random() < 0.6) { baseGraphics.fillStyle(0x006400); // Draw tree-like shapes baseGraphics.fillTriangle( x + tileSize/2, y + tileSize/6, x + tileSize/4, y + tileSize*2/3, x + tileSize*3/4, y + tileSize*2/3 ); baseGraphics.fillStyle(0x8B4513); baseGraphics.fillRect(x + tileSize*2/5, y + tileSize*2/3, tileSize/5, tileSize/4); } break; case 'swamp': baseGraphics.fillStyle(currentMapType.baseColor); baseGraphics.fillRect(x, y, tileSize, tileSize); if (Math.random() < 0.4) { baseGraphics.fillStyle(0x3D5A5A); baseGraphics.fillCircle(x + tileSize/2, y + tileSize/2, tileSize/3); baseGraphics.fillStyle(0x2F4F4F); baseGraphics.fillCircle(x + tileSize/2, y + tileSize/2, tileSize/4); } break; case 'mountain': baseGraphics.fillStyle(currentMapType.baseColor); baseGraphics.fillRect(x, y, tileSize, tileSize); if (Math.random() < 0.5) { baseGraphics.fillStyle(0x6B4423); baseGraphics.fillTriangle( x + tileSize/2, y + tileSize/6, x + tileSize/6, y + tileSize*5/6, x + tileSize*5/6, y + tileSize*5/6 ); baseGraphics.fillStyle(0xFFFFFF); baseGraphics.fillTriangle( x + tileSize/2, y + tileSize/6, x + tileSize/3, y + tileSize/3, x + tileSize*2/3, y + tileSize/3 ); } break; case 'ocean': baseGraphics.fillStyle(currentMapType.baseColor); baseGraphics.fillRect(x, y, tileSize, tileSize); if (Math.random() < 0.7) { baseGraphics.fillStyle(0x0000A0); baseGraphics.fillRect(x, y + Math.sin(x/30 + this.time.now/1000) * tileSize/6 + tileSize/2, tileSize, tileSize/4); } break; case 'cave': baseGraphics.fillStyle(currentMapType.baseColor); baseGraphics.fillRect(x, y, tileSize, tileSize); if (Math.random() < 0.3) { baseGraphics.fillStyle(0x1A1A1A); baseGraphics.fillCircle(x + tileSize/2, y + tileSize/2, tileSize/3); baseGraphics.fillStyle(0x000000); baseGraphics.fillCircle(x + tileSize/2, y + tileSize/2, tileSize/5); } break; case 'castle': baseGraphics.fillStyle(currentMapType.baseColor); baseGraphics.fillRect(x, y, tileSize, tileSize); if (Math.random() < 0.4) { baseGraphics.fillStyle(0x4A4A4A); baseGraphics.fillRect(x + tileSize/6, y + tileSize/6, tileSize*2/3, tileSize*2/3); baseGraphics.fillStyle(0x2A2A2A); baseGraphics.fillRect(x + tileSize/3, y + tileSize/3, tileSize/3, tileSize/3); } break; case 'ice': baseGraphics.fillStyle(currentMapType.baseColor); baseGraphics.fillRect(x, y, tileSize, tileSize); if (Math.random() < 0.5) { baseGraphics.fillStyle(0xFFFFFF); baseGraphics.fillRect(x + tileSize/4, y + tileSize/4, tileSize/2, tileSize/2); baseGraphics.fillStyle(0xE0FFFF); baseGraphics.fillRect(x + tileSize/3, y + tileSize/3, tileSize/3, tileSize/3); } break; case 'ruins': baseGraphics.fillStyle(currentMapType.baseColor); baseGraphics.fillRect(x, y, tileSize, tileSize); if (Math.random() < 0.4) { baseGraphics.fillStyle(0x8B7355); // Draw broken pillar shapes baseGraphics.fillRect(x + tileSize/4, y + tileSize/3, tileSize/2, tileSize*2/3); baseGraphics.fillStyle(0x6B5335); baseGraphics.fillRect(x + tileSize/3, y + tileSize/4, tileSize/3, tileSize/8); } break; case 'plains': // Create full grass tile with texture baseGraphics.fillStyle(currentMapType.baseColor); baseGraphics.fillRect(x, y, tileSize, tileSize); if (Math.random() < 0.4) { // Add grass texture baseGraphics.fillStyle(0x228B22); // Draw multiple small grass patches for (let i = 0; i < 3; i++) { baseGraphics.fillRect( x + Math.random() * tileSize, y + Math.random() * tileSize, tileSize/6, tileSize/6 ); } } break; case 'city': // Create full city tile with building pattern baseGraphics.fillStyle(0x808080); // Base concrete color baseGraphics.fillRect(x, y, tileSize, tileSize); if (Math.random() < 0.015) { // Add building structure baseGraphics.fillStyle(0x505050); baseGraphics.fillRect( x + tileSize/8, y + tileSize/8, tileSize*3/4, tileSize*3/4 ); // Add windows baseGraphics.fillStyle(0x404040); for (let i = 0; i < 2; i++) { for (let j = 0; j < 2; j++) { baseGraphics.fillRect( x + tileSize/4 + (i * tileSize/3), y + tileSize/4 + (j * tileSize/3), tileSize/6, tileSize/6 ); } } } break; case 'city': // Add building-like structures if (Math.random() < 0.15) { baseGraphics.fillStyle(0x696969); baseGraphics.fillRect( x + tileSize/6, y + tileSize/6, tileSize*2/3, tileSize*2/3 ); baseGraphics.fillStyle(currentMapType.baseColor); } break; } } } // Add modular characters for party members in random adjacent formation // Function to draw a modular character const drawModularCharacter = (graphics, x, y, tileSize, colors = null) => { // Use provided colors or generate random ones const characterColors = colors || { skinColor: Phaser.Utils.Array.GetRandom(this.skinTones), armorColor: Phaser.Math.RND.integerInRange(0x000000, 0xFFFFFF), accentColor: Phaser.Math.RND.integerInRange(0x000000, 0xFFFFFF), hairColor: Phaser.Math.RND.integerInRange(0x000000, 0xFFFFFF) }; const padding = tileSize * 0.1; const charWidth = tileSize - (padding * 2); const charHeight = tileSize - (padding * 2); // Draw body (armor) graphics.fillStyle(characterColors.armorColor); const bodyWidth = charWidth * 0.6; // Make body narrower const bodyX = x + (tileSize - bodyWidth) / 2; // Center the body graphics.fillRect(bodyX, y + padding + (charHeight * 0.3), bodyWidth, charHeight * 0.7); // Draw accent details graphics.fillStyle(characterColors.accentColor); graphics.fillRect(bodyX, y + padding + (charHeight * 0.5), bodyWidth, charHeight * 0.1); // Draw head (skin color) as square graphics.fillStyle(characterColors.skinColor); const headSize = charWidth * 0.4; const headX = x + (tileSize - headSize) / 2; const headY = y + padding + (charHeight * 0.1); graphics.fillRect(headX, headY, headSize, headSize); // Draw hair as square graphics.fillStyle(characterColors.hairColor); const hairHeight = headSize * 0.4; graphics.fillRect(headX, headY, headSize, hairHeight); }; // Update occupied positions for next cycle this.occupiedPositions = occupiedPositions; // Choose random starting position const startCol = Phaser.Math.Between(0, 24); const startRow = Phaser.Math.Between(0, 24); let currentCol = startCol; let currentRow = startRow; // Place tiles // Reset partyMembers array with persistent data // Use the persistentPartyData directly to set partyMembers this.partyMembers = []; // Filter out any null, undefined, or defeated members from persistentPartyData this.persistentPartyData = this.persistentPartyData.filter(member => member != null && member.currentHp > 0 ); // Ensure all persistent party members (including recruits) are added this.persistentPartyData.forEach(member => { // Create a deep copy of the member data const copiedMember = { ...member, currentHp: member.maxHp, // Restore HP between chapters colors: { ...member.colors }, growthRates: { ...member.growthRates }, personality: { ...member.personality } }; this.partyMembers.push(copiedMember); }); for (let i = 0; i < this.partyMembers.length; i++) { // Place current tile const x = offsetX + (currentCol * tileSize); const y = offsetY + (currentRow * tileSize); const colors = this.partyMembers[i].colors; drawModularCharacter(blueGraphics, x, y, tileSize, colors); occupiedPositions[currentRow][currentCol] = true; this.partyPositions.push({ member: this.partyMembers[i], row: currentRow, col: currentCol, colors: colors }); // If not the last tile, find next position if (i < this.partyMembers.length - 1) { // Get possible adjacent positions const possibleMoves = [{ row: currentRow - 1, col: currentCol }, // up { row: currentRow + 1, col: currentCol }, // down { row: currentRow, col: currentCol - 1 }, // left { row: currentRow, col: currentCol + 1 } // right ].filter(pos => pos.row >= 0 && pos.row < 25 && pos.col >= 0 && pos.col < 25 && !occupiedPositions[pos.row][pos.col] ); // If no valid moves, find nearest valid position if (possibleMoves.length === 0) { for (let row = 0; row < 25; row++) { for (let col = 0; col < 25; col++) { if (!occupiedPositions[row][col] && ((Math.abs(row - currentRow) === 1 && col === currentCol) || (Math.abs(col - currentCol) === 1 && row === currentRow))) { possibleMoves.push({ row, col }); } } } } // Select random move from possible moves const nextMove = Phaser.Math.RND.pick(possibleMoves); currentRow = nextMove.row; currentCol = nextMove.col; } } // Create and place enemies const createEnemy = () => { // Determine enemy level based on current chapter const enemyLevel = this.currentChapter; // Filter classes based on level requirements let availableClasses; if (enemyLevel >= 30) { // Use tier 3 classes for level 30+ availableClasses = this.characterClasses.filter(c => c.tier === 3); } else if (enemyLevel >= 10) { // Use tier 2 classes for level 10-29 availableClasses = this.characterClasses.filter(c => c.tier === 2); } else { // Use tier 1 classes for levels 1-9 availableClasses = this.characterClasses.filter(c => c.tier === 1); } // Select random class from available classes const enemyClass = Phaser.Utils.Array.GetRandom(availableClasses); // Calculate stat bonuses - add 3 to stats every 5 chapters const chapterMilestone = Math.floor((this.currentChapter - 1) / 5); const statBonus = chapterMilestone * 2; const baseHp = 20 + statBonus; const baseAtk = 5 + statBonus; const baseDef = 3 + statBonus; // Remove stat caps for higher chapters const maxHp = baseHp + enemyClass.hpMod; return { name: 'CD Grunt', class: enemyClass.name, maxHp: maxHp, currentHp: maxHp, attack: baseAtk + enemyClass.atkMod, defense: baseDef + enemyClass.defMod, // Enemy growth rates based on class only growthRates: { hp: enemyClass.growthRates.hp + 40, attack: enemyClass.growthRates.attack + 40, defense: enemyClass.growthRates.defense + 40 } }; }; // Function to draw chest const drawChest = (graphics, x, y, tileSize) => { // Draw chest base graphics.fillStyle(0x8B4513); graphics.fillRect( x + (tileSize * 0.1), y + (tileSize * 0.3), tileSize * 0.8, tileSize * 0.6 ); // Draw chest lid graphics.fillStyle(0xA0522D); graphics.fillRect( x + (tileSize * 0.1), y + (tileSize * 0.1), tileSize * 0.8, tileSize * 0.3 ); // Draw lock graphics.fillStyle(0xFFD700); graphics.fillRect( x + (tileSize * 0.45), y + (tileSize * 0.3), tileSize * 0.1, tileSize * 0.15 ); }; // Function to get random unoccupied position away from party members const getRandomUnoccupiedPosition = () => { let row, col; let isValidPosition = false; do { row = Phaser.Math.Between(0, 24); col = Phaser.Math.Between(0, 24); // Check if position is unoccupied if (occupiedPositions[row][col]) continue; // Check distance from all party members isValidPosition = this.partyPositions.every(partyMember => { const distance = Math.sqrt( Math.pow(row - partyMember.row, 2) + Math.pow(col - partyMember.col, 2) ); return distance >= 5; }); } while (!isValidPosition); return { row, col }; }; // Spawn 2 enemies // Calculate base number of enemies let enemyCount = 2 + (this.currentChapter - 1); // Add additional enemies for every multiple of 5 const additionalEnemies = Math.floor(this.currentChapter / 5) * 2; enemyCount += additionalEnemies; for (let i = 0; i < enemyCount; i++) { let enemy = createEnemy(); // Set enemy level to current chapter enemy.level = this.currentChapter; // Auto-level the enemy if chapter is greater than 1 for (let lvl = 1; lvl < this.currentChapter; lvl++) { // Roll for stat increases based on growth rates if (Phaser.Math.Between(1, 100) <= enemy.growthRates.hp) { enemy.maxHp++; enemy.currentHp++; } if (Phaser.Math.Between(1, 100) <= enemy.growthRates.attack) { enemy.attack++; } if (Phaser.Math.Between(1, 100) <= enemy.growthRates.defense) { enemy.defense++; } } const position = getRandomUnoccupiedPosition(); const x = offsetX + (position.col * tileSize); const y = offsetY + (position.row * tileSize); // Define specific red shades for enemy armors const enemyArmorColors = [ 0xFF0000, // Pure red 0xCC0000, // Dark red 0x990000, // Darker red 0xAA0000 // Medium dark red ]; const colors = { skinColor: Phaser.Utils.Array.GetRandom(this.skinTones), armorColor: Phaser.Utils.Array.GetRandom(enemyArmorColors), accentColor: 0x000000, // Black accent hairColor: 0x000000 // Black hair }; // Draw enemy character drawModularCharacter(blueGraphics, x, y, tileSize, colors); // Mark position as occupied occupiedPositions[position.row][position.col] = true; // Draw all recruits if they exist const drawRecruit = (recruit) => { if (recruit) { const recruitX = offsetX + (recruit.col * tileSize); const recruitY = offsetY + (recruit.row * tileSize); drawModularCharacter(blueGraphics, recruitX, recruitY, tileSize, recruit.colors); // Add green outline for potential recruit blueGraphics.lineStyle(3, 0x00FF00, 0.8); blueGraphics.strokeRect( recruitX + 1, recruitY + 1, tileSize - 2, tileSize - 2 ); } }; // Draw main recruit and additional recruits drawRecruit(this.newRecruit); if (this.additionalRecruits) { this.additionalRecruits.forEach(recruit => drawRecruit(recruit)); } // Store enemy position and data this.enemyPositions.push({ member: enemy, row: position.row, col: position.col, colors: colors }); } // Spawn 1-3 chests in each chapter const numChests = Phaser.Math.Between(1, 3); this.chestPositions = []; for (let i = 0; i < numChests; i++) { const chestPosition = getRandomUnoccupiedPosition(); const chestX = offsetX + (chestPosition.col * tileSize); const chestY = offsetY + (chestPosition.row * tileSize); drawChest(blueGraphics, chestX, chestY, tileSize); occupiedPositions[chestPosition.row][chestPosition.col] = true; // Store chest positions in game state this.chestPositions.push({ row: chestPosition.row, col: chestPosition.col, collected: false }); } // Draw grid lines on top gridLinesGraphics.lineStyle(2, 0x000000, 0.5); // Thicker black lines with 0.5 opacity // Draw vertical lines for (let col = 0; col <= 25; col++) { const x = offsetX + (col * tileSize); gridLinesGraphics.beginPath(); gridLinesGraphics.moveTo(x, offsetY); gridLinesGraphics.lineTo(x, offsetY + (tileSize * 25)); gridLinesGraphics.strokePath(); } // Draw horizontal lines for (let row = 0; row <= 25; row++) { const y = offsetY + (row * tileSize); gridLinesGraphics.beginPath(); gridLinesGraphics.moveTo(offsetX, y); gridLinesGraphics.lineTo(offsetX + (tileSize * 25), y); gridLinesGraphics.strokePath(); // Create question mark button at top left const padding = 20; const questionButton = this.add.text(padding, padding, '?', { fontSize: '32px', color: '#ffffff', backgroundColor: '#444444', padding: { x: 15, y: 10 }, fontStyle: 'bold' }).setOrigin(0, 0) .setInteractive({ useHandCursor: true }) .setDepth(1000); // Add hover effects questionButton.on('pointerover', () => { questionButton.setStyle({ color: '#ffff00' }); }); questionButton.on('pointerout', () => { questionButton.setStyle({ color: '#ffffff' }); }); questionButton.on('pointerdown', () => { const tutorialPages = [ { title: 'Basic Controls', content: '• Click once on a character to show movement range\n' + '• Click valid tile to move character\n' + '• Characters can only move once per turn\n' + '• Black outline shows moved characters' }, { title: 'Combat', content: '• Double click character to attack adjacent enemy\n' + '• Combat is automatic when moving next to an enemy\n' + '• Damage is based on Attack minus Defense\n' + '• Defeating enemies can lead to level ups' }, { title: 'Items & Recruitment', content: '• Move next to chests to collect weapons\n' + '• Weapons provide Attack bonuses\n' + '• Move next to green-outlined characters to recruit them\n' + '• New recruits join at the current chapter\'s level' }, { title: 'Victory Conditions', content: '• Defeat all enemies to win the battle\n' + '• Keep your characters alive\n' + '• Strategic positioning is key\n' + '• Use terrain and numbers to your advantage' } ]; let currentPage = 0; // Create help overlay const helpOverlay = this.add.graphics(); helpOverlay.fillStyle(0x000000, 0.9); helpOverlay.fillRect(0, 0, this.cameras.main.width, this.cameras.main.height); helpOverlay.setDepth(1001); // Create close button const closeButton = this.add.text(this.cameras.main.width - 40, 20, 'X', { fontSize: '24px', color: '#ffffff', backgroundColor: '#ff4444', padding: { x: 10, y: 5 } }).setOrigin(0.5).setDepth(1002).setInteractive({ useHandCursor: true }); // Create title text const titleText = this.add.text( this.cameras.main.width / 2, 100, tutorialPages[currentPage].title, { fontSize: '32px', color: '#ffffff', fontStyle: 'bold' } ).setOrigin(0.5).setDepth(1002); // Create help text const helpText = this.add.text( this.cameras.main.width / 2, this.cameras.main.height / 2, tutorialPages[currentPage].content, { fontSize: '24px', color: '#ffffff', align: 'center', lineSpacing: 20 } ).setOrigin(0.5).setDepth(1002); // Create navigation buttons const prevButton = this.add.text( this.cameras.main.width / 4, this.cameras.main.height - 100, '< Previous', { fontSize: '24px', color: '#ffffff', backgroundColor: '#444444', padding: { x: 15, y: 10 } } ).setOrigin(0.5).setDepth(1002).setInteractive({ useHandCursor: true }); const nextButton = this.add.text( (this.cameras.main.width / 4) * 3, this.cameras.main.height - 100, 'Next >', { fontSize: '24px', color: '#ffffff', backgroundColor: '#444444', padding: { x: 15, y: 10 } } ).setOrigin(0.5).setDepth(1002).setInteractive({ useHandCursor: true }); const pageIndicator = this.add.text( this.cameras.main.width / 2, this.cameras.main.height - 100, `${currentPage + 1}/${tutorialPages.length}`, { fontSize: '24px', color: '#ffffff' } ).setOrigin(0.5).setDepth(1002); // Add hover effects to all buttons [closeButton, prevButton, nextButton].forEach(button => { button.on('pointerover', () => button.setTint(0xffff00)); button.on('pointerout', () => button.clearTint()); }); // Navigation handlers prevButton.on('pointerdown', () => { if (currentPage > 0) { currentPage--; titleText.setText(tutorialPages[currentPage].title); helpText.setText(tutorialPages[currentPage].content); pageIndicator.setText(`${currentPage + 1}/${tutorialPages.length}`); } }); nextButton.on('pointerdown', () => { if (currentPage < tutorialPages.length - 1) { currentPage++; titleText.setText(tutorialPages[currentPage].title); helpText.setText(tutorialPages[currentPage].content); pageIndicator.setText(`${currentPage + 1}/${tutorialPages.length}`); } }); // Close handler closeButton.on('pointerdown', () => { helpOverlay.destroy(); closeButton.destroy(); titleText.destroy(); helpText.destroy(); prevButton.destroy(); nextButton.destroy(); pageIndicator.destroy(); }); }); // Store UI elements in a container for easy visibility toggling this.partyListContainer = this.add.container(0, 0); } // Create party member list container const padding = 10; const startX = gameWidth - 200; const startY = padding; // Add semi-transparent black background for party list const partyBg = this.add.graphics(); partyBg.fillStyle(0x000000, 0.7); partyBg.fillRect(startX - padding, startY - padding, 190, this.partyMembers.length * 100 + padding * 2); this.partyListContainer.add(partyBg); // Create party member displays this.partyMembers.forEach((member, index) => { // Member name and level const nameText = this.add.text(startX, startY + (index * 100), `${member.name} (Level ${member.level})`, { fontSize: '18px', color: '#ffffff', fontFamily: 'Arial' }); // Class text const classText = this.add.text(startX, startY + 20 + (index * 100), `${member.class}`, { fontSize: '14px', color: '#88ff88', fontFamily: 'Arial', fontStyle: 'italic' }); // HP text with growth rate const hpText = this.add.text(startX, startY + 40 + (index * 100), `HP: ${member.currentHp}/${member.maxHp} (${member.growthRates.hp}% ↑)`, { fontSize: '14px', color: '#ff8080', fontFamily: 'Arial' }); // Attack text with growth rate const attackText = this.add.text(startX, startY + 60 + (index * 100), `ATK: ${member.attack} (${member.growthRates.attack}% ↑)`, { fontSize: '14px', color: '#ffff80', fontFamily: 'Arial' }); // Defense text with growth rate const defenseText = this.add.text(startX, startY + 80 + (index * 100), `DEF: ${member.defense} (${member.growthRates.defense}% ↑)`, { fontSize: '14px', color: '#80ff80', fontFamily: 'Arial' }); this.partyListContainer.add(nameText); this.partyListContainer.add(classText); this.partyListContainer.add(hpText); this.partyListContainer.add(attackText); this.partyListContainer.add(defenseText); }); // Initially hide the party list this.partyListContainer.setVisible(false); // Create cursor border graphics (on top of everything) this.cursorBorder = this.add.graphics(); this.cursorBorder.lineStyle(3, 0xFFFFFF, 0.8); // Thicker line (3px) with slight transparency // Add pointer move listener for cursor border // Add pointer move listener for cursor border // Add click handler for party member selection this.input.on('pointerdown', (pointer) => { const gridX = Math.floor((pointer.x - offsetX) / tileSize); const gridY = Math.floor((pointer.y - offsetY) / tileSize); // Handle double click on party members if (pointer.clicks === 2) { const clickedPartyMember = this.partyPositions.find(pos => pos.row === gridY && pos.col === gridX && !pos.hasMoved ); if (clickedPartyMember && this.currentPhase === 'player') { // Mark the party member as moved immediately clickedPartyMember.hasMoved = true; // Clear any existing selection and range graphics if (this.selectedMember === clickedPartyMember) { this.selectedMember = null; if (this.rangeGraphics) { this.rangeGraphics.clear(); this.rangeGraphics.destroy(); this.rangeGraphics = null; } } // Redraw characters to show the black outline for the moved character blueGraphics.clear(); this.partyPositions.forEach(member => { const x = offsetX + (member.col * tileSize); const y = offsetY + (member.row * tileSize); drawModularCharacter(blueGraphics, x, y, tileSize, member.colors); if (member.hasMoved) { blueGraphics.lineStyle(3, 0x000000, 1); blueGraphics.strokeRect( x + 1, y + 1, tileSize - 2, tileSize - 2 ); } }); // Find adjacent enemy const adjacentEnemy = this.enemyPositions.find(enemy => Math.abs(enemy.row - clickedPartyMember.row) + Math.abs(enemy.col - clickedPartyMember.col) === 1 ); if (adjacentEnemy) { // Perform attack // Calculate attack and defense values const attackValue = clickedPartyMember.member.attack; const defenseValue = adjacentEnemy.member.defense; // Calculate damage with all rules let damage; if (defenseValue >= attackValue + 4) { // No damage if defense is at least 4 points higher than attack damage = 0; } else if (defenseValue >= attackValue) { // Guarantee 1 damage if defense is equal to or up to 3 points higher than attack damage = 1; } else { // Normal damage calculation for when attack is higher than defense damage = attackValue - defenseValue; } adjacentEnemy.member.currentHp = Math.max(0, adjacentEnemy.member.currentHp - damage); // Display damage number const damageX = offsetX + (adjacentEnemy.col * tileSize) + tileSize / 2; const damageY = offsetY + (adjacentEnemy.row * tileSize); const damageText = this.add.text(damageX, damageY, `-${damage}`, { fontSize: '20px', color: '#ff0000', fontStyle: 'bold' }).setOrigin(0.5, 0.5); // Check if enemy is defeated if (adjacentEnemy.member.currentHp <= 0) { // Find and remove the enemy from enemyPositions array const enemyIndex = this.enemyPositions.findIndex(e => e.col === adjacentEnemy.col && e.row === adjacentEnemy.row ); if (enemyIndex > -1) { this.enemyPositions.splice(enemyIndex, 1); // Increment enemies killed counter and check for level up clickedPartyMember.member.enemiesKilled++; // Check if all enemies are defeated if (this.enemyPositions.length === 0) { const victoryText = this.add.text( this.cameras.main.width / 2, this.cameras.main.height / 2, 'Victory!', { fontSize: '48px', color: '#ffffff', fontFamily: 'Arial', fontStyle: 'bold', stroke: '#000000', strokeThickness: 6 } ).setOrigin(0.5).setDepth(1001); // Fade out victory text this.tweens.add({ targets: victoryText, alpha: 0, duration: 2000, onComplete: () => { victoryText.destroy(); } }); } // Calculate required kills for next level const requiredKills = 1 + Math.floor(clickedPartyMember.member.level / 5); if (clickedPartyMember.member.enemiesKilled >= requiredKills) { // Process level up this.processLevelUp(clickedPartyMember); } // Redraw all characters to remove the defeated enemy blueGraphics.clear(); this.partyPositions.forEach(member => { const x = offsetX + (member.col * tileSize); const y = offsetY + (member.row * tileSize); drawModularCharacter(blueGraphics, x, y, tileSize, member.colors); }); this.enemyPositions.forEach(enemy => { const x = offsetX + (enemy.col * tileSize); const y = offsetY + (enemy.row * tileSize); drawModularCharacter(blueGraphics, x, y, tileSize, enemy.colors); }); } } // Animate damage text this.tweens.add({ targets: damageText, y: damageY - 30, alpha: 0, duration: 800, onComplete: () => { damageText.destroy(); } }).then(() => { // Check if all party members have moved after the attack let allMoved = this.partyPositions.every(member => member.hasMoved); if (allMoved) { this.currentPhase = 'enemy'; if (this.phaseText && this.phaseText.active) { this.phaseText.setText('Enemy Phase'); this.phaseText.setColor('#ff4444'); } // Start enemy phase this.moveEnemiesPhase(async () => { this.currentPhase = 'player'; if (this.phaseText && this.phaseText.active) { this.phaseText.setText('Player Phase'); this.phaseText.setColor('#4444ff'); } this.turnCount++; if (this.turnText && this.turnText.active) { this.turnText.setText(`Turn ${this.turnCount}`); } // Reset party members' move status this.partyPositions.forEach(member => { member.hasMoved = false; }); }); } // Redraw characters with black outline for moved character blueGraphics.clear(); this.partyPositions.forEach(member => { const x = offsetX + (member.col * tileSize); const y = offsetY + (member.row * tileSize); drawModularCharacter(blueGraphics, x, y, tileSize, member.colors); if (member.hasMoved) { blueGraphics.lineStyle(3, 0x000000, 1); blueGraphics.strokeRect( x + 1, y + 1, tileSize - 2, tileSize - 2 ); } }); // Redraw enemies this.enemyPositions.forEach(enemy => { const x = offsetX + (enemy.col * tileSize); const y = offsetY + (enemy.row * tileSize); drawModularCharacter(blueGraphics, x, y, tileSize, enemy.colors); }); // Update allMoved status allMoved = this.partyPositions.every(member => member.hasMoved); if (allMoved) { this.currentPhase = 'enemy'; this.phaseText.setText('Enemy Phase'); this.phaseText.setColor('#ff4444'); // Start enemy phase this.moveEnemiesPhase(async () => { this.currentPhase = 'player'; this.phaseText.setText('Player Phase'); this.phaseText.setColor('#4444ff'); this.turnCount++; this.turnText.setText(`Turn ${this.turnCount}`); // Reset party members' move status this.partyPositions.forEach(member => { member.hasMoved = false; }); }); } }); } } return; } // Check if clicking on a party member const clickedPartyMember = this.partyPositions.find(pos => pos.row === gridY && pos.col === gridX && !pos.hasMoved ); // Only allow selecting party members during player phase if (clickedPartyMember && this.currentPhase === 'player') { // If clicking the same member, deselect if (this.selectedMember === clickedPartyMember) { this.selectedMember = null; if (this.rangeGraphics) { this.rangeGraphics.clear(); this.rangeGraphics.destroy(); this.rangeGraphics = null; } } else { // Select new member and show range this.selectedMember = clickedPartyMember; this.drawMoveRange(gridY, gridX); } } else if (this.selectedMember) { // Check if the clicked position is within moveable tiles const isValidMove = this.moveableTiles.some(tile => tile.row === gridY && tile.col === gridX ); if (isValidMove) { // Helper function to check for and perform attack const performAttack = async (attacker, defenders, isPartyMember) => { // Find adjacent defender const adjacentDefender = defenders.find(defender => Math.abs(defender.row - gridY) + Math.abs(defender.col - gridX) === 1 ); if (adjacentDefender) { // Calculate base damage const attackPower = attacker.member.attack; const defenseValue = adjacentDefender.member.defense; const damage = attackPower - defenseValue; // Apply damage adjacentDefender.member.currentHp = Math.max(0, adjacentDefender.member.currentHp - damage); // Check if defender is defeated if (adjacentDefender.member.currentHp <= 0) { // Remove defender from appropriate array if (isPartyMember) { // If defender is party member, remove from persistentPartyData const persistentIndex = this.persistentPartyData.findIndex( member => member.name === adjacentDefender.member.name ); if (persistentIndex > -1) { this.persistentPartyData.splice(persistentIndex, 1); } // Also remove from partyPositions const positionIndex = this.partyPositions.findIndex( pos => pos.member.name === adjacentDefender.member.name ); if (positionIndex > -1) { this.partyPositions.splice(positionIndex, 1); } } // Remove from defenders array const defenderIndex = defenders.findIndex(d => d.col === adjacentDefender.col && d.row === adjacentDefender.row ); if (defenderIndex > -1) { defenders.splice(defenderIndex, 1); // If it's a party member attacking, handle enemy defeat if (isPartyMember) { attacker.member.enemiesKilled++; const requiredKills = 1 + Math.floor(attacker.member.level / 5); if (attacker.member.enemiesKilled >= requiredKills) { this.processLevelUp(attacker); } } } } // Display damage number const damageX = offsetX + (adjacentDefender.col * tileSize) + tileSize / 2; const damageY = offsetY + (adjacentDefender.row * tileSize); const damageText = this.add.text(damageX, damageY, `-${damage}`, { fontSize: '20px', color: '#ff0000', fontStyle: 'bold' }).setOrigin(0.5, 0.5); // Animate damage text this.tweens.add({ targets: damageText, y: damageY - 30, alpha: 0, duration: 800, onComplete: () => { damageText.destroy(); } }); // Check if enemy is defeated if (adjacentDefender.member.currentHp <= 0) { const enemyIndex = this.enemyPositions.indexOf(adjacentDefender); if (enemyIndex > -1) { // Increment enemies killed counter and check for level up clickedPartyMember.member.enemiesKilled++; // Remove the defeated enemy this.enemyPositions.splice(enemyIndex, 1); // Check if all enemies are defeated if (this.enemyPositions.length === 0) { // Create dark overlay const overlay = this.add.graphics(); overlay.fillStyle(0x000000, 0.8); overlay.fillRect(0, 0, this.cameras.main.width, this.cameras.main.height); overlay.setDepth(1000); // Create victory text const victoryText = this.add.text( this.cameras.main.width / 2, this.cameras.main.height / 3, 'Victory!', { fontSize: '48px', color: '#ffffff', fontFamily: 'Arial', fontStyle: 'bold', stroke: '#000000', strokeThickness: 6 } ).setOrigin(0.5).setDepth(1001); // Create menu buttons const buttonStyle = { fontSize: '24px', color: '#ffffff', fontFamily: 'Arial', backgroundColor: '#444444', padding: { x: 20, y: 10 } }; // Continue button const continueButton = this.add.text( this.cameras.main.width / 2, this.cameras.main.height / 2, 'Continue', buttonStyle ).setOrigin(0.5).setDepth(1001) .setInteractive({ useHandCursor: true }); // Add hover effects [continueButton].forEach(button => { button.on('pointerover', () => { button.setColor('#ffff00'); }); button.on('pointerout', () => { button.setColor('#ffffff'); }); }); // Add click handlers continueButton.on('pointerdown', () => { // Spawn chest with 100% chance if (true) { // Find random unoccupied position let chestX, chestY; do { chestX = Phaser.Math.Between(0, 24); chestY = Phaser.Math.Between(0, 24); } while ([...this.partyPositions, ...this.enemyPositions].some( pos => pos.row === chestY && pos.col === chestX )); // Draw chest using graphics const chest = this.add.graphics(); const tileSize = Math.min(this.cameras.main.width / 25, this.cameras.main.height / 25); const offsetX = (this.cameras.main.width - (tileSize * 25)) / 2; const offsetY = (this.cameras.main.height - (tileSize * 25)) / 2; // Draw chest base chest.fillStyle(0x8B4513); chest.fillRect( offsetX + (chestX * tileSize) + (tileSize * 0.1), offsetY + (chestY * tileSize) + (tileSize * 0.3), tileSize * 0.8, tileSize * 0.6 ); // Draw chest lid chest.fillStyle(0xA0522D); chest.fillRect( offsetX + (chestX * tileSize) + (tileSize * 0.1), offsetY + (chestY * tileSize) + (tileSize * 0.1), tileSize * 0.8, tileSize * 0.3 ); // Draw lock chest.fillStyle(0xFFD700); chest.fillRect( offsetX + (chestX * tileSize) + (tileSize * 0.45), offsetY + (chestY * tileSize) + (tileSize * 0.3), tileSize * 0.1, tileSize * 0.15 ); } // Clean up menu overlay.destroy(); victoryText.destroy(); continueButton.destroy(); this.scene.restart(); }); } // Calculate required kills for next level (increases by 1 every 5 levels) const requiredKills = 1 + Math.floor(clickedPartyMember.member.level / 5); if (clickedPartyMember.member.enemiesKilled >= requiredKills) { // Reset kill counter clickedPartyMember.member.enemiesKilled = 0; // Level up! clickedPartyMember.member.level++; // Check for promotion levels (both level 10 and 30) const isPromotionLevel = clickedPartyMember.member.level === 10 || clickedPartyMember.member.level === 30; // Apply promotion bonuses for both level 10 and 30 if (isPromotionLevel) { const currentTier = clickedPartyMember.member.level === 10 ? 1 : 2; // Tier 1 for level 10, Tier 2 for level 30 const currentClass = this.characterClasses.find(c => c.name === clickedPartyMember.member.class); // Find promotion class const promotionClass = this.characterClasses.find(c => c.tier === currentTier + 1 && c.baseName === currentClass.name); if (promotionClass) { // Store old stats for comparison const oldStats = { hp: clickedPartyMember.member.maxHp, attack: clickedPartyMember.member.attack, defense: clickedPartyMember.member.defense }; // Apply new class modifiers clickedPartyMember.member.class = promotionClass.name; clickedPartyMember.member.maxHp += promotionClass.hpMod; clickedPartyMember.member.currentHp = clickedPartyMember.member.maxHp; clickedPartyMember.member.attack += promotionClass.atkMod; clickedPartyMember.member.defense += promotionClass.defMod; // Update growth rates const personality = clickedPartyMember.member.personality; clickedPartyMember.member.growthRates = { hp: personality.growthRates.hp + promotionClass.growthRates.hp, attack: personality.growthRates.attack + promotionClass.growthRates.attack, defense: personality.growthRates.defense + promotionClass.growthRates.defense }; } // Increase growth rates const growthBonus = promotionBonus * 0.2; // 20% or 40% increase clickedPartyMember.member.growthRates.hp = Math.min(100, Math.floor(clickedPartyMember.member.growthRates.hp * (1 + growthBonus))); clickedPartyMember.member.growthRates.attack = Math.min(100, Math.floor(clickedPartyMember.member.growthRates.attack * (1 + growthBonus))); clickedPartyMember.member.growthRates.defense = Math.min(100, Math.floor(clickedPartyMember.member.growthRates.defense * (1 + growthBonus))); // Display promotion text const promotionText = this.add.text( offsetX + (clickedPartyMember.col * tileSize), offsetY + (clickedPartyMember.row * tileSize) - 60, `Class Change!\n${currentClass.name} → ${promotionClass.name}\nHP +${clickedPartyMember.member.maxHp - oldStats.hp} ATK +${clickedPartyMember.member.attack - oldStats.attack} DEF +${clickedPartyMember.member.defense - oldStats.defense}`, { fontSize: '20px', color: '#00ff00', stroke: '#000000', strokeThickness: 4, align: 'center' } ).setOrigin(0.5); // Animate promotion text this.tweens.add({ targets: promotionText, y: promotionText.y - 50, alpha: 0, duration: 2000, onComplete: () => promotionText.destroy() }); } // Apply regular stat increases based on growth rates const growthRates = clickedPartyMember.member.growthRates; let statGains = { hp: 0, attack: 0, defense: 0 }; // Check each stat for growth if (Phaser.Math.Between(1, 100) <= growthRates.hp) { statGains.hp = 1; clickedPartyMember.member.maxHp++; clickedPartyMember.member.currentHp++; } if (Phaser.Math.Between(1, 100) <= growthRates.attack) { statGains.attack = 1; clickedPartyMember.member.attack++; } if (Phaser.Math.Between(1, 100) <= growthRates.defense) { statGains.defense = 1; clickedPartyMember.member.defense++; } // Display level up message const levelUpText = this.add.text( offsetX + (clickedPartyMember.col * tileSize), offsetY + (clickedPartyMember.row * tileSize) - 30, `Level Up!\nHP +${statGains.hp} ATK +${statGains.attack} DEF +${statGains.defense}`, { fontSize: '16px', color: '#ffff00', stroke: '#000000', strokeThickness: 4, align: 'center' } ).setOrigin(0.5); // Animate level up text this.tweens.add({ targets: levelUpText, y: levelUpText.y - 50, alpha: 0, duration: 2000, onComplete: () => { levelUpText.destroy(); } }); } this.enemyPositions.splice(enemyIndex, 1); // Check if all enemies are defeated if (this.enemyPositions.length === 0) { // Create simple victory text const victoryText = this.add.text( this.cameras.main.width / 2, this.cameras.main.height / 2, 'Victory!', { fontSize: '48px', color: '#ffffff', fontFamily: 'Arial', fontStyle: 'bold', stroke: '#000000', strokeThickness: 6 } ).setOrigin(0.5).setDepth(1001); // Fade out victory text this.tweens.add({ targets: victoryText, alpha: 0, duration: 2000, onComplete: () => { victoryText.destroy(); } }); } } } } }; // Update member position const oldRow = this.selectedMember.row; const oldCol = this.selectedMember.col; // Check if moving to any chest position that hasn't been collected const chestAtPosition = this.chestPositions.find(chest => !chest.collected && gridY === chest.row && gridX === chest.col ); if (chestAtPosition) { // Define weapon types and materials with their attack boosts const weapons = { // Common weapons (50% chance) 'Axe': { attack: 4, rarity: 'Common', weight: 50 }, 'Sword': { attack: 3, rarity: 'Common', weight: 50 }, 'Dagger': { attack: 2, rarity: 'Common', weight: 50 }, 'Club': { attack: 3, rarity: 'Common', weight: 50 }, 'Shortsword': { attack: 3, rarity: 'Common', weight: 50 }, 'Spear': { attack: 4, rarity: 'Common', weight: 50 }, 'Handaxe': { attack: 3, rarity: 'Common', weight: 50 }, 'Hatchet': { attack: 3, rarity: 'Common', weight: 50 }, // Uncommon weapons (25% chance) 'Lance': { attack: 5, rarity: 'Uncommon', weight: 25 }, 'Mace': { attack: 6, rarity: 'Uncommon', weight: 25 }, 'Scimitar': { attack: 5, rarity: 'Uncommon', weight: 25 }, 'Warhammer': { attack: 6, rarity: 'Uncommon', weight: 25 }, 'Guisarme': { attack: 5, rarity: 'Uncommon', weight: 25 }, 'Falchion': { attack: 5, rarity: 'Uncommon', weight: 25 }, 'Rapier': { attack: 4, rarity: 'Uncommon', weight: 25 }, 'Estoc': { attack: 5, rarity: 'Uncommon', weight: 25 }, // Rare weapons (15% chance) 'Claymore': { attack: 7, rarity: 'Rare', weight: 15 }, 'Halberd': { attack: 8, rarity: 'Rare', weight: 15 }, 'Glaive': { attack: 7, rarity: 'Rare', weight: 15 }, 'Khopesh': { attack: 8, rarity: 'Rare', weight: 15 }, 'Greatsword': { attack: 8, rarity: 'Rare', weight: 15 }, 'Pike': { attack: 7, rarity: 'Rare', weight: 15 }, 'Tomahawk': { attack: 7, rarity: 'Rare', weight: 15 }, 'Morningstar': { attack: 8, rarity: 'Rare', weight: 15 }, // Epic weapons (7% chance) 'Flamberge': { attack: 10, rarity: 'Epic', weight: 7 }, 'Zweihander': { attack: 11, rarity: 'Epic', weight: 7 }, 'Executioner’s Blade': { attack: 10, rarity: 'Epic', weight: 7 }, 'Stormbringer': { attack: 11, rarity: 'Epic', weight: 7 }, 'Dragonfang Spear': { attack: 12, rarity: 'Epic', weight: 7 }, 'Bloodletting Scythe': { attack: 12, rarity: 'Epic', weight: 7 }, 'Inferno Blade': { attack: 11, rarity: 'Epic', weight: 7 }, 'Soulreaver': { attack: 12, rarity: 'Epic', weight: 7 }, // Mythical weapons (3% chance) 'Excalibur': { attack: 15, rarity: 'Mythical', weight: 3 }, 'Durandal': { attack: 16, rarity: 'Mythical', weight: 3 }, 'Mjolnir': { attack: 17, rarity: 'Mythical', weight: 3 }, 'Ragnarok': { attack: 18, rarity: 'Mythical', weight: 3 }, 'Aetherblade': { attack: 19, rarity: 'Mythical', weight: 3 }, 'Eclipse Scythe': { attack: 20, rarity: 'Mythical', weight: 3 }, 'Godslayer': { attack: 21, rarity: 'Mythical', weight: 3 }, 'Voidfang': { attack: 22, rarity: 'Mythical', weight: 3 } }; const materials = { // Common materials (50% chance) 'Iron': { attack: 1, rarity: 'Common', weight: 50 }, 'Bronze': { attack: 1, rarity: 'Common', weight: 50 }, 'Copper': { attack: 1, rarity: 'Common', weight: 50 }, 'Tin': { attack: 1, rarity: 'Common', weight: 50 }, 'Lead': { attack: 1, rarity: 'Common', weight: 50 }, 'Nickel': { attack: 1, rarity: 'Common', weight: 50 }, 'Zinc': { attack: 1, rarity: 'Common', weight: 50 }, 'Carbon Steel': { attack: 2, rarity: 'Common', weight: 50 }, // Uncommon materials (25% chance) 'Steel': { attack: 2, rarity: 'Uncommon', weight: 25 }, 'Silver': { attack: 3, rarity: 'Uncommon', weight: 25 }, 'Electrum': { attack: 2, rarity: 'Uncommon', weight: 25 }, 'Cobalt': { attack: 3, rarity: 'Uncommon', weight: 25 }, 'Titanium': { attack: 3, rarity: 'Uncommon', weight: 25 }, 'Duralumin': { attack: 3, rarity: 'Uncommon', weight: 25 }, 'Chromium': { attack: 2, rarity: 'Uncommon', weight: 25 }, 'Platinum': { attack: 3, rarity: 'Uncommon', weight: 25 }, // Rare materials (15% chance) 'Mythril': { attack: 4, rarity: 'Rare', weight: 15 }, 'Orichalcum': { attack: 5, rarity: 'Rare', weight: 15 }, 'Blacksteel': { attack: 4, rarity: 'Rare', weight: 15 }, 'Darkstone': { attack: 5, rarity: 'Rare', weight: 15 }, 'Voidmetal': { attack: 5, rarity: 'Rare', weight: 15 }, 'Phoenix Ash': { attack: 5, rarity: 'Rare', weight: 15 }, 'Demonite': { attack: 4, rarity: 'Rare', weight: 15 }, 'Moonstone': { attack: 5, rarity: 'Rare', weight: 15 }, // Epic materials (7% chance) 'Adamantite': { attack: 6, rarity: 'Epic', weight: 7 }, 'Starmetal': { attack: 7, rarity: 'Epic', weight: 7 }, 'Voidsteel': { attack: 6, rarity: 'Epic', weight: 7 }, 'Bloodcrystal': { attack: 7, rarity: 'Epic', weight: 7 }, 'Sunforged Metal': { attack: 8, rarity: 'Epic', weight: 7 }, 'Hellfire Ore': { attack: 8, rarity: 'Epic', weight: 7 }, 'Nightmare Shard': { attack: 7, rarity: 'Epic', weight: 7 }, 'Eldritch Alloy': { attack: 8, rarity: 'Epic', weight: 7 }, // Mythical materials (3% chance) 'Dragonscale': { attack: 8, rarity: 'Mythical', weight: 3 }, 'Celestial': { attack: 9, rarity: 'Mythical', weight: 3 }, 'Aetherium': { attack: 10, rarity: 'Mythical', weight: 3 }, 'Eldritch Essence': { attack: 11, rarity: 'Mythical', weight: 3 }, 'Divine Ore': { attack: 12, rarity: 'Mythical', weight: 3 }, 'Primordial Matter': { attack: 13, rarity: 'Mythical', weight: 3 }, 'Godstone': { attack: 14, rarity: 'Mythical', weight: 3 }, 'Chaos Core': { attack: 15, rarity: 'Mythical', weight: 3 } }; // Function to select item based on weights const selectWeightedRandom = (items) => { // First, group items by rarity const rarityGroups = { Common: { weight: 50, items: [] }, Uncommon: { weight: 25, items: [] }, Rare: { weight: 15, items: [] }, Epic: { weight: 7, items: [] }, Mythical: { weight: 3, items: [] } }; // Group items by their rarity Object.entries(items).forEach(([name, item]) => { rarityGroups[item.rarity].items.push([name, item]); }); // First, select a rarity based on weights const totalRarityWeight = Object.values(rarityGroups) .reduce((sum, group) => sum + group.weight, 0); let random = Phaser.Math.Between(1, totalRarityWeight); let selectedRarity; for (const [rarity, group] of Object.entries(rarityGroups)) { random -= group.weight; if (random <= 0) { selectedRarity = rarity; break; } } // Then randomly select an item from the chosen rarity group const itemsInRarity = rarityGroups[selectedRarity].items; return itemsInRarity[Phaser.Math.Between(0, itemsInRarity.length - 1)]; }; // Select weapon and material using weighted random const [weaponType, weaponData] = selectWeightedRandom(weapons); const [material, materialData] = selectWeightedRandom(materials); const totalAttackBoost = (weaponData.attack || 0) + (materialData.attack || 0); // Determine text color based on weapon rarity const rarityColors = { 'Common': '#ffffff', 'Uncommon': '#00ff00', 'Rare': '#0088ff', 'Epic': '#8800ff', 'Mythical': '#ffaa00' }; // Get the current attack value without weapon bonus let currentAttack = this.selectedMember.member.attack; // Remove previous weapon's attack bonus if one exists if (this.selectedMember.member.equippedWeapon) { currentAttack -= this.selectedMember.member.equippedWeapon.attack; } // Store and equip the new weapon const newWeapon = { name: `${material} ${weaponType}`, attack: totalAttackBoost, rarity: Math.max(weaponData.rarity, materialData.rarity) }; // Update the equipped weapon this.selectedMember.member.equippedWeapon = newWeapon; // Add the new weapon's attack bonus to the current attack this.selectedMember.member.attack = currentAttack + totalAttackBoost; // Create black background rectangle with white outline const notificationBg = this.add.graphics(); notificationBg.setDepth(1000); // Define background colors for rarities const rarityBackgrounds = { 'Common': 0x333333, 'Uncommon': 0x1B5E20, // Darker green for uncommon 'Rare': 0x0D47A1, // Bright blue for rare 'Epic': 0x4A148C, // Deep purple for epic 'Mythical': 0xFF6F00 // Bright orange for mythical }; // Get the highest rarity between weapon and material const highestRarity = weaponData.rarity === 'Mythical' || materialData.rarity === 'Mythical' ? 'Mythical' : weaponData.rarity === 'Epic' || materialData.rarity === 'Epic' ? 'Epic' : weaponData.rarity === 'Rare' || materialData.rarity === 'Rare' ? 'Rare' : weaponData.rarity === 'Uncommon' || materialData.rarity === 'Uncommon' ? 'Uncommon' : 'Common'; // Draw colored fill based on rarity notificationBg.fillStyle(rarityBackgrounds[highestRarity], 1); notificationBg.fillRect( this.cameras.main.width / 2 - 200, this.cameras.main.height / 2 - 50, 400, 100 ); // Draw white outline notificationBg.lineStyle(2, 0xFFFFFF, 1); notificationBg.strokeRect( this.cameras.main.width / 2 - 200, this.cameras.main.height / 2 - 50, 400, 100 ); // Add text on top of the black background const chestText = this.add.text( this.cameras.main.width / 2, this.cameras.main.height / 2, `${material} ${weaponType}\nAttack +${totalAttackBoost}`, { fontSize: '24px', color: '#ffffff', align: 'center', stroke: '#000000', strokeThickness: 4 } ).setOrigin(0.5).setDepth(1001); // Remove notification after delay without animation this.time.delayedCall(2000, () => { notificationBg.destroy(); chestText.destroy(); }); // Handle chest collection chestAtPosition.collected = true; // Update local party data without saving to storage const memberIndex = this.persistentPartyData.findIndex(member => member.name === this.selectedMember.member.name); if (memberIndex !== -1) { this.persistentPartyData[memberIndex] = { ...this.selectedMember.member }; } } // Check if moving to any recruit's position const recruitAtPosition = [this.newRecruit, ...(this.additionalRecruits || [])].find( recruit => recruit && gridY === recruit.row && gridX === recruit.col ); if (recruitAtPosition) { // Create a deep copy of the recruit's member data const recruitMemberData = { ...recruitAtPosition.member, currentHp: recruitAtPosition.member.maxHp, enemiesKilled: 0, canHeal: recruitAtPosition.member.class === 'Cleric' || recruitAtPosition.member.class === 'Bishop' || recruitAtPosition.member.class === 'Saint', } // Auto-level the recruit based on current chapter for (let lvl = 1; lvl < this.currentChapter; lvl++) { // Roll for stat increases based on growth rates if (Phaser.Math.Between(1, 100) <= recruitMemberData.growthRates.hp) { recruitMemberData.maxHp++; recruitMemberData.currentHp++; } if (Phaser.Math.Between(1, 100) <= recruitMemberData.growthRates.attack) { recruitMemberData.attack++; } if (Phaser.Math.Between(1, 100) <= recruitMemberData.growthRates.defense) { recruitMemberData.defense++; } } // Set level to current chapter recruitMemberData.level = this.currentChapter; // Add new recruit to party positions this.partyPositions.push({ member: recruitMemberData, row: oldRow, col: oldCol, colors: recruitAtPosition.colors, // Use the recruit's specific colors hasMoved: false }); // Add new recruit to partyMembers array this.partyMembers.push(recruitMemberData); // Add to persistent party data if not already present const alreadyInParty = this.persistentPartyData.some( member => member.name === recruitMemberData.name ); if (!alreadyInParty) { this.persistentPartyData.push(recruitMemberData); // Display recruitment message const recruitText = this.add.text( this.cameras.main.width / 2, this.cameras.main.height / 2, `${recruitMemberData.name} has joined your party!`, { fontSize: '24px', color: '#00ff00', stroke: '#000000', strokeThickness: 4 } ).setOrigin(0.5).setDepth(1000); // Fade out recruitment message this.tweens.add({ targets: recruitText, alpha: 0, duration: 2000, onComplete: () => recruitText.destroy() }); } // Remove recruited character from appropriate array if (recruitAtPosition === this.newRecruit) { this.newRecruit = null; } else { this.additionalRecruits = this.additionalRecruits.filter( recruit => recruit !== recruitAtPosition ); } } // Update selected member's position this.selectedMember.row = gridY; this.selectedMember.col = gridX; this.selectedMember.hasMoved = true; // Mark as moved // Check if selected member can heal and there's an adjacent injured party member const canHeal = this.selectedMember.member.canHeal || this.selectedMember.member.class === 'Cleric' || this.selectedMember.member.class === 'Bishop' || this.selectedMember.member.class === 'Saint'; if (canHeal) { // Find adjacent injured party members const adjacentPartyMember = this.partyPositions.find(member => member !== this.selectedMember && // Not self member.member.currentHp < member.member.maxHp && // Injured Math.abs(member.row - this.selectedMember.row) + Math.abs(member.col - this.selectedMember.col) === 1 // Adjacent ); if (adjacentPartyMember) { // Calculate healing amount const healAmount = 5 + Math.floor(this.selectedMember.member.attack / 2); // Apply healing adjacentPartyMember.member.currentHp = Math.min( adjacentPartyMember.member.maxHp, adjacentPartyMember.member.currentHp + healAmount ); // Display healing text const healText = this.add.text( offsetX + (adjacentPartyMember.col * tileSize), offsetY + (adjacentPartyMember.row * tileSize) - 30, `+${healAmount}`, { fontSize: '20px', color: '#00ff00', stroke: '#000000', strokeThickness: 4 } ).setOrigin(0.5); // Animate healing text this.tweens.add({ targets: healText, y: healText.y - 30, alpha: 0, duration: 1000, onComplete: () => healText.destroy() }); } } // Check for and perform attack after movement if not healing if (!canHeal || !this.partyPositions.some(member => member !== this.selectedMember && member.member.currentHp < member.member.maxHp && Math.abs(member.row - this.selectedMember.row) + Math.abs(member.col - this.selectedMember.col) === 1 )) { performAttack(this.selectedMember, this.enemyPositions, true); } // Clear and redraw characters and chest blueGraphics.clear(); // Redraw chest only if it hasn't been collected // Draw all uncollected chests this.chestPositions.forEach(chest => { if (!chest.collected) { drawChest(blueGraphics, offsetX + (chest.col * tileSize), offsetY + (chest.row * tileSize), tileSize); } }); // Then draw characters this.partyPositions.forEach(member => { const x = offsetX + (member.col * tileSize); const y = offsetY + (member.row * tileSize); drawModularCharacter(blueGraphics, x, y, tileSize, member.colors); // Draw black outline for moved characters if (member.hasMoved) { blueGraphics.lineStyle(3, 0x000000, 1); blueGraphics.strokeRect( x + 1, y + 1, tileSize - 2, tileSize - 2 ); } }); // Add performEnemyAttack method this.performEnemyAttack = (enemy, partyMember, callback) => { // Calculate raw attack and defense values const attackValue = enemy.member.attack; const defenseValue = partyMember.member.defense; // Calculate damage with all rules let damage; if (defenseValue >= attackValue + 4) { // No damage if defense is at least 4 points higher than attack damage = 0; } else if (defenseValue >= attackValue) { // Guarantee 1 damage if defense is equal to or up to 3 points higher than attack damage = 1; } else { // Normal damage calculation for when attack is higher than defense damage = attackValue - defenseValue; } partyMember.member.currentHp = Math.max(0, partyMember.member.currentHp - damage); // Display damage number const damageX = offsetX + (partyMember.col * tileSize) + tileSize / 2; const damageY = offsetY + (partyMember.row * tileSize); const damageText = this.add.text(damageX, damageY, `-${damage}`, { fontSize: '20px', color: '#ff0000', fontStyle: 'bold' }).setOrigin(0.5, 0.5); // Animate damage text this.tweens.add({ targets: damageText, y: damageY - 30, alpha: 0, duration: 800, onComplete: () => { damageText.destroy(); // Check if party member is defeated if (partyMember.member.currentHp <= 0) { const memberIndex = this.partyPositions.indexOf(partyMember); if (memberIndex > -1) { this.partyPositions.splice(memberIndex, 1); } const persistentIndex = this.persistentPartyData.findIndex( m => m.name === partyMember.member.name ); if (persistentIndex > -1) { this.persistentPartyData.splice(persistentIndex, 1); } // Update party list UI if (this.partyListContainer && this.partyListContainer.active) { // Clear existing party list container this.partyListContainer.removeAll(true); // Recreate party list background const padding = 10; const startX = this.cameras.main.width - 200; const startY = padding; const partyBg = this.add.graphics(); partyBg.fillStyle(0x000000, 0.7); partyBg.fillRect(startX - padding, startY - padding, 190, this.partyPositions.length * 80 + padding * 2); this.partyListContainer.add(partyBg); // Recreate party member displays this.partyPositions.forEach((member, index) => { if (member && member.member) { // Member name const nameText = this.add.text(startX, startY + (index * 80), member.member.name, { fontSize: '18px', color: '#ffffff', fontFamily: 'Arial' }); // HP text const hpText = this.add.text(startX, startY + 20 + (index * 80), `HP: ${member.member.currentHp}/${member.member.maxHp}`, { fontSize: '14px', color: '#ff8080', fontFamily: 'Arial' }); // Attack text const attackText = this.add.text(startX, startY + 40 + (index * 80), `ATK: ${member.member.attack}`, { fontSize: '14px', color: '#ffff80', fontFamily: 'Arial' }); // Defense text const defenseText = this.add.text(startX, startY + 60 + (index * 80), `DEF: ${member.member.defense}`, { fontSize: '14px', color: '#80ff80', fontFamily: 'Arial' }); // Add all elements to container this.partyListContainer.add(nameText); this.partyListContainer.add(hpText); this.partyListContainer.add(attackText); this.partyListContainer.add(defenseText); } }); } } if (callback) callback(); } }); }; const checkBattleWon = () => { if (this.enemyPositions.length === 0) { // Create victory overlay const overlay = this.add.graphics(); overlay.fillStyle(0x000000, 0.7); overlay.fillRect(0, 0, this.cameras.main.width, this.cameras.main.height); overlay.setDepth(1000); // Create victory text const victoryText = this.add.text( this.cameras.main.width / 2, this.cameras.main.height / 2 - 50, `Chapter ${this.currentChapter} Complete!`, { fontSize: '48px', color: '#ffffff', fontFamily: 'Arial', fontStyle: 'bold', stroke: '#000000', strokeThickness: 6 } ).setOrigin(0.5).setDepth(1001); // Add continue text const continueText = this.add.text( this.cameras.main.width / 2, this.cameras.main.height / 2 + 50, 'Proceeding to next chapter...', { fontSize: '24px', color: '#ffff00', fontFamily: 'Arial', stroke: '#000000', strokeThickness: 4 } ).setOrigin(0.5).setDepth(1001); // Increment chapter number Example.chapterNumber = (Example.chapterNumber || 0) + 1; this.currentChapter = Example.chapterNumber; // Save the current state of persistentPartyData const currentPartyState = JSON.stringify(this.persistentPartyData); localStorage.setItem('persistentPartyData', currentPartyState); // Add fade out effect this.tweens.add({ targets: [victoryText, continueText], alpha: 0, duration: 1000, delay: 2000, onComplete: () => { // Clean up before scene transition if (this.rangeGraphics) this.rangeGraphics.destroy(); if (baseGraphics) baseGraphics.destroy(); if (blueGraphics) blueGraphics.destroy(); if (gridLinesGraphics) gridLinesGraphics.destroy(); if (this.previewContainer) this.previewContainer.destroy(); if (this.partyListContainer) this.partyListContainer.destroy(); // Clear game state this.partyPositions = []; this.enemyPositions = []; this.moveableTiles = []; this.selectedMember = null; // Reset turn count this.turnCount = 1; // Destroy text objects if (this.phaseText) this.phaseText.destroy(); if (this.turnText) this.turnText.destroy(); if (this.chapterText) this.chapterText.destroy(); // Stop all tweens this.tweens.killAll(); // Restart the scene this.scene.restart(); } }); } }; // Redraw enemies and recruit if exists this.enemyPositions.forEach(enemy => { const x = offsetX + (enemy.col * tileSize); const y = offsetY + (enemy.row * tileSize); drawModularCharacter(blueGraphics, x, y, tileSize, enemy.colors); }); // Draw all recruits if they exist and haven't been recruited const drawRecruit = (recruit) => { if (recruit) { const recruitX = offsetX + (recruit.col * tileSize); const recruitY = offsetY + (recruit.row * tileSize); drawModularCharacter(blueGraphics, recruitX, recruitY, tileSize, recruit.colors); // Add green outline for potential recruit blueGraphics.lineStyle(3, 0x00FF00, 0.8); blueGraphics.strokeRect( recruitX + 1, recruitY + 1, tileSize - 2, tileSize - 2 ); } }; // Draw main recruit and additional recruits drawRecruit(this.newRecruit); if (this.additionalRecruits) { this.additionalRecruits.forEach(recruit => drawRecruit(recruit)); } } // Check if all enemies are defeated after player action if (this.enemyPositions.length === 0) { // Create dark overlay const overlay = this.add.graphics(); overlay.fillStyle(0x000000, 0.8); overlay.fillRect(0, 0, this.cameras.main.width, this.cameras.main.height); overlay.setDepth(1000); // Create victory text const victoryText = this.add.text( this.cameras.main.width / 2, this.cameras.main.height / 3, 'Victory!', { fontSize: '48px', color: '#ffffff', fontFamily: 'Arial', fontStyle: 'bold', stroke: '#000000', strokeThickness: 6 } ).setOrigin(0.5).setDepth(1001); // Create menu buttons const buttonStyle = { fontSize: '24px', color: '#ffffff', fontFamily: 'Arial', backgroundColor: '#444444', padding: { x: 20, y: 10 } }; // Continue button const continueButton = this.add.text( this.cameras.main.width / 2, this.cameras.main.height / 2, 'Continue', buttonStyle ).setOrigin(0.5).setDepth(1001) .setInteractive({ useHandCursor: true }); // Add hover effects [continueButton].forEach(button => { button.on('pointerover', () => { button.setColor('#ffff00'); }); button.on('pointerout', () => { button.setColor('#ffffff'); }); }); // Add click handlers continueButton.on('pointerdown', () => { // Spawn chest with 100% chance let chestX, chestY; do { chestX = Phaser.Math.Between(0, 24); chestY = Phaser.Math.Between(0, 24); } while ([...this.partyPositions, ...this.enemyPositions].some( pos => pos.row === chestY && pos.col === chestX )); // Draw chest using graphics const chest = this.add.graphics(); const tileSize = Math.min(this.cameras.main.width / 25, this.cameras.main.height / 25); const offsetX = (this.cameras.main.width - (tileSize * 25)) / 2; const offsetY = (this.cameras.main.height - (tileSize * 25)) / 2; // Draw chest base chest.fillStyle(0x8B4513); chest.fillRect( offsetX + (chestX * tileSize) + (tileSize * 0.1), offsetY + (chestY * tileSize) + (tileSize * 0.3), tileSize * 0.8, tileSize * 0.6 ); // Draw chest lid chest.fillStyle(0xA0522D); chest.fillRect( offsetX + (chestX * tileSize) + (tileSize * 0.1), offsetY + (chestY * tileSize) + (tileSize * 0.1), tileSize * 0.8, tileSize * 0.3 ); // Draw lock chest.fillStyle(0xFFD700); chest.fillRect( offsetX + (chestX * tileSize) + (tileSize * 0.45), offsetY + (chestY * tileSize) + (tileSize * 0.3), tileSize * 0.1, tileSize * 0.15 ); // Clean up game state and graphics if (baseGraphics) baseGraphics.destroy(); if (blueGraphics) blueGraphics.destroy(); if (gridLinesGraphics) gridLinesGraphics.destroy(); if (this.rangeGraphics) this.rangeGraphics.destroy(); if (this.previewContainer) this.previewContainer.destroy(); if (this.partyListContainer) this.partyListContainer.destroy(); if (this.cursorBorder) this.cursorBorder.destroy(); // Clear stored positions and game state this.partyPositions = []; this.enemyPositions = []; this.moveableTiles = []; this.selectedMember = null; // Reset turn and phase this.currentPhase = 'player'; this.turnCount = 1; // Clean up UI elements if (this.phaseText) this.phaseText.destroy(); if (this.turnText) this.turnText.destroy(); if (this.chapterText) this.chapterText.destroy(); // Stop any ongoing tweens this.tweens.killAll(); // Clean up menu elements overlay.destroy(); victoryText.destroy(); continueButton.destroy(); // Save current state to persistent data before incrementing chapter this.persistentPartyData = [...this.partyMembers].map(member => { // Create deep copy of member data const memberCopy = JSON.parse(JSON.stringify(member)); // Process any pending level ups before saving const requiredKills = 1 + Math.floor(memberCopy.level / 5); if (member.enemiesKilled >= requiredKills) { member.level++; member.enemiesKilled = 0; // Apply stat increases based on growth rates if (Phaser.Math.Between(1, 100) <= member.growthRates.hp) { member.maxHp++; member.currentHp++; } if (Phaser.Math.Between(1, 100) <= member.growthRates.attack) { member.attack++; } if (Phaser.Math.Between(1, 100) <= member.growthRates.defense) { member.defense++; } } return { ...member }; }); // Increment chapter and restart scene this.currentChapter++; this.scene.restart(); }); return; // Exit the function after showing victory menu } // Check if all party members have moved const allMoved = this.partyPositions.every(member => member.hasMoved); if (allMoved && this.currentPhase === 'player') { this.currentPhase = 'enemy'; if (this.phaseText && this.phaseText.active) { this.phaseText.setText('Enemy Phase'); this.phaseText.setColor('#ff4444'); } // Reset party members' move status for next turn this.partyPositions.forEach(member => { member.hasMoved = false; }); // Helper function to calculate Manhattan distance between two positions const calculateDistance = (pos1, pos2) => { return Math.abs(pos1.row - pos2.row) + Math.abs(pos1.col - pos2.col); }; // Helper function to find nearest party member to an enemy const findNearestPartyMember = (enemyPos) => { let nearestMember = null; let shortestDistance = Infinity; this.partyPositions.forEach(partyMember => { const distance = calculateDistance(enemyPos, partyMember); if (distance < shortestDistance) { shortestDistance = distance; nearestMember = partyMember; } }); return nearestMember; }; // Helper function to move enemy one step toward target const moveEnemyTowardTarget = (enemyPos, targetPos) => { const rowDiff = targetPos.row - enemyPos.row; const colDiff = targetPos.col - enemyPos.col; // Create array of possible moves const possibleMoves = []; // Prioritize the larger difference (row or column) if (Math.abs(rowDiff) > Math.abs(colDiff)) { // Try vertical movement first if (rowDiff !== 0) { possibleMoves.push({ row: enemyPos.row + Math.sign(rowDiff), col: enemyPos.col }); } // Then try horizontal movement if (colDiff !== 0) { possibleMoves.push({ row: enemyPos.row, col: enemyPos.col + Math.sign(colDiff) }); } } else { // Try horizontal movement first if (colDiff !== 0) { possibleMoves.push({ row: enemyPos.row, col: enemyPos.col + Math.sign(colDiff) }); } // Then try vertical movement if (rowDiff !== 0) { possibleMoves.push({ row: enemyPos.row + Math.sign(rowDiff), col: enemyPos.col }); } } // Check each possible move in order for (const move of possibleMoves) { // Check if position is within grid bounds if (move.row >= 0 && move.row < 25 && move.col >= 0 && move.col < 25) { // Check if position is not occupied const isOccupied = [...this.partyPositions, ...this.enemyPositions].some( pos => pos.row === move.row && pos.col === move.col ); if (!isOccupied) { return move; } } } // If no valid moves found, return current position return { row: enemyPos.row, col: enemyPos.col }; }; // Function to handle enemy movement phase this.moveEnemiesPhase = (callback) => { let enemyIndex = 0; // Reset hasAttacked flag for all enemies at the start of enemy phase this.enemyPositions.forEach(enemy => { enemy.hasAttacked = false; }); const moveNextEnemy = () => { if (enemyIndex >= this.enemyPositions.length) { callback(); return; } const enemy = this.enemyPositions[enemyIndex]; // First check if there's an adjacent party member to attack const adjacentPartyMember = this.partyPositions.find(member => Math.abs(member.row - enemy.row) + Math.abs(member.col - enemy.col) === 1 ); if (adjacentPartyMember) { // Attack immediately if adjacent enemy.hasAttacked = true; this.performEnemyAttack(enemy, adjacentPartyMember, () => { enemyIndex++; moveNextEnemy(); }); return; } // If no adjacent targets, find nearest member to move towards const nearestMember = findNearestPartyMember(enemy); if (nearestMember) { let moveCount = 0; const maxMoves = 5; const moveEnemy = () => { // Process movement immediately const distance = calculateDistance(enemy, nearestMember); // Stop if max moves reached if (moveCount >= maxMoves) { // Only check for attack if enemy hasn't attacked yet if (!enemy.hasAttacked) { const adjacentPartyMember = this.partyPositions.find(member => Math.abs(member.row - enemy.row) + Math.abs(member.col - enemy.col) === 1 ); if (adjacentPartyMember) { enemy.hasAttacked = true; this.performEnemyAttack(enemy, adjacentPartyMember, () => { enemyIndex++; moveNextEnemy(); }); return; } } enemyIndex++; moveNextEnemy(); return; } const newPos = moveEnemyTowardTarget(enemy, nearestMember); // Check if position is occupied const isOccupied = [...this.partyPositions, ...this.enemyPositions].some(pos => pos !== enemy && pos.row === newPos.row && pos.col === newPos.col ); if (!isOccupied) { enemy.row = newPos.row; enemy.col = newPos.col; // Redraw characters and chest after movement blueGraphics.clear(); // Redraw all uncollected chests this.chestPositions.forEach(chest => { if (!chest.collected) { drawChest(blueGraphics, offsetX + (chest.col * tileSize), offsetY + (chest.row * tileSize), tileSize); } }); this.partyPositions.forEach(member => { const x = offsetX + (member.col * tileSize); const y = offsetY + (member.row * tileSize); drawModularCharacter(blueGraphics, x, y, tileSize, member.colors); }); this.enemyPositions.forEach(enemy => { const x = offsetX + (enemy.col * tileSize); const y = offsetY + (enemy.row * tileSize); drawModularCharacter(blueGraphics, x, y, tileSize, enemy.colors); }); } moveCount++; // Only check for attack after movement is complete if (moveCount >= maxMoves && !enemy.hasAttacked) { const adjacentPartyMember = this.partyPositions.find(member => Math.abs(member.row - enemy.row) + Math.abs(member.col - enemy.col) === 1 ); if (adjacentPartyMember) { enemy.hasAttacked = true; this.performEnemyAttack(enemy, adjacentPartyMember, () => { enemyIndex++; moveNextEnemy(); }); return; } } // Continue movement if not attacking this.time.delayedCall(200, moveEnemy); }; moveEnemy(); } else { enemyIndex++; moveNextEnemy(); } }; moveNextEnemy(); }; // Move enemies and then switch back to player phase this.moveEnemiesPhase(() => { this.currentPhase = 'player'; if (this.phaseText && this.phaseText.active) { this.phaseText.setText('Player Phase'); this.phaseText.setColor('#4444ff'); } // Increment turn count at the end of enemy phase this.turnCount++; if (this.turnText && this.turnText.active) { this.turnText.setText(`Turn ${this.turnCount}`); } // Reset hasMoved status for all party members this.partyPositions.forEach(member => { member.hasMoved = false; }); // Clear and redraw everything blueGraphics.clear(); // Redraw all uncollected chests this.chestPositions.forEach(chest => { if (!chest.collected) { drawChest(blueGraphics, offsetX + (chest.col * tileSize), offsetY + (chest.row * tileSize), tileSize); } }); // Then draw characters this.partyPositions.forEach(member => { const x = offsetX + (member.col * tileSize); const y = offsetY + (member.row * tileSize); drawModularCharacter(blueGraphics, x, y, tileSize, member.colors); }); // Redraw enemies and recruit this.enemyPositions.forEach(enemy => { const x = offsetX + (enemy.col * tileSize); const y = offsetY + (enemy.row * tileSize); drawModularCharacter(blueGraphics, x, y, tileSize, enemy.colors); }); // Draw all recruits if they exist const drawRecruit = (recruit) => { if (recruit) { const recruitX = offsetX + (recruit.col * tileSize); const recruitY = offsetY + (recruit.row * tileSize); // Draw with a distinct visual style drawModularCharacter(blueGraphics, recruitX, recruitY, tileSize, recruit.colors); // Add green outline for potential recruit blueGraphics.lineStyle(3, 0x00FF00, 0.8); blueGraphics.strokeRect( recruitX + 1, recruitY + 1, tileSize - 2, tileSize - 2 ); } }; // Draw main recruit and additional recruits drawRecruit(this.newRecruit); if (this.additionalRecruits) { this.additionalRecruits.forEach(recruit => drawRecruit(recruit)); } }); } // Clear selection and range this.selectedMember = null; if (this.rangeGraphics) { this.rangeGraphics.clear(); this.rangeGraphics.destroy(); this.rangeGraphics = null; } } }); this.input.on('pointermove', (pointer) => { // Calculate grid position const gridX = Math.floor((pointer.x - offsetX) / tileSize); const gridY = Math.floor((pointer.y - offsetY) / tileSize); // Check if cursor is over a party member or enemy separately const hoveredPartyMember = this.partyPositions.find(pos => pos.row === gridY && pos.col === gridX ); const hoveredEnemy = this.enemyPositions.find(pos => pos.row === gridY && pos.col === gridX ); const hoveredMember = hoveredPartyMember || hoveredEnemy; if (hoveredMember) { // Clear and redraw the preview background with appropriate color this.previewBg.clear(); // Draw outline based on character type const outlineColor = hoveredPartyMember ? 0x0000FF : 0xFF0000; // Blue for party, Red for enemies this.previewBg.lineStyle(2, outlineColor, 1); this.previewBg.strokeRect(padding - padding, gameHeight - 100 - padding, 190, 90); // Draw background this.previewBg.fillStyle(0x000000, 0.7); this.previewBg.fillRect(padding - padding, gameHeight - 100 - padding, 190, 90); // Clear previous portrait this.previewPortrait.clear(); // Draw character portrait (head and shoulders only) const portraitSize = 60; // Size for the portrait const portraitX = padding + 10; const portraitY = gameHeight - 90; // Draw shoulders (armor) this.previewPortrait.fillStyle(hoveredMember.colors.armorColor); this.previewPortrait.fillRect( portraitX + (portraitSize * 0.2), portraitY + (portraitSize * 0.6), portraitSize * 0.6, portraitSize * 0.3 ); // Draw accent on armor this.previewPortrait.fillStyle(hoveredMember.colors.accentColor); this.previewPortrait.fillRect( portraitX + (portraitSize * 0.2), portraitY + (portraitSize * 0.65), portraitSize * 0.6, portraitSize * 0.1 ); // Draw head this.previewPortrait.fillStyle(hoveredMember.colors.skinColor); this.previewPortrait.fillRect( portraitX + (portraitSize * 0.3), portraitY + (portraitSize * 0.2), portraitSize * 0.4, portraitSize * 0.4 ); // Draw hair this.previewPortrait.fillStyle(hoveredMember.colors.hairColor); this.previewPortrait.fillRect( portraitX + (portraitSize * 0.3), portraitY + (portraitSize * 0.2), portraitSize * 0.4, portraitSize * 0.15 ); // Update preview text if (hoveredMember && hoveredMember.member && this.previewClassText && this.previewNameText && this.previewHpText && this.previewAttackText && this.previewDefenseText) { this.updatePreviewText(hoveredMember); } // Adjust text positions to accommodate portrait this.previewNameText.setPosition(portraitX + portraitSize + 20, gameHeight - 100); this.previewHpText.setPosition(portraitX + portraitSize + 20, gameHeight - 80); this.previewAttackText.setPosition(portraitX + portraitSize + 20, gameHeight - 60); this.previewDefenseText.setPosition(portraitX + portraitSize + 20, gameHeight - 40); // Show preview this.previewContainer.setVisible(true); } else { // Hide preview when not hovering over a party member this.previewContainer.setVisible(false); } // Only show border if within grid bounds if (gridX >= 0 && gridX < 25 && gridY >= 0 && gridY < 25) { this.cursorBorder.clear(); // Draw outer stroke for better visibility this.cursorBorder.lineStyle(5, 0x000000, 1); this.cursorBorder.strokeRect( offsetX + (gridX * tileSize), offsetY + (gridY * tileSize), tileSize, tileSize ); // Draw inner white stroke this.cursorBorder.lineStyle(2, 0xFFFFFF, 1); this.cursorBorder.strokeRect( offsetX + (gridX * tileSize), offsetY + (gridY * tileSize), tileSize, tileSize ); } else { this.cursorBorder.clear(); } }); // Create preview container this.previewContainer = this.add.container(0, 0); // Add semi-transparent black background for preview first // Create background with conditional outline color const previewBg = this.add.graphics(); this.previewBg = previewBg; // Store reference for later use // Draw semi-transparent black background previewBg.fillStyle(0x000000, 0.7); previewBg.fillRect(padding - padding, gameHeight - 100 - padding, 190, 90); this.previewContainer.add(previewBg); // Create separate graphics object for the preview portrait (will be added last) this.previewPortrait = this.add.graphics(); // Create preview text elements // Create class text (new) this.previewClassText = this.add.text(padding, gameHeight - 120, '', { fontSize: '14px', color: '#00ff00', fontFamily: 'Arial', fontStyle: 'italic' }); this.previewNameText = this.add.text(padding, gameHeight - 100, '', { fontSize: '18px', color: '#ffffff', fontFamily: 'Arial' }); this.previewHpText = this.add.text(padding, gameHeight - 80, '', { fontSize: '14px', color: '#ff8080', fontFamily: 'Arial' }); this.previewAttackText = this.add.text(padding, gameHeight - 60, '', { fontSize: '14px', color: '#ffff80', fontFamily: 'Arial' }); this.previewDefenseText = this.add.text(padding + 100, gameHeight - 60, '', { fontSize: '14px', color: '#80ff80', fontFamily: 'Arial' }); // Add all elements to preview container in correct order this.previewContainer.add(this.previewClassText); this.previewContainer.add(this.previewNameText); this.previewContainer.add(this.previewHpText); this.previewContainer.add(this.previewAttackText); this.previewContainer.add(this.previewDefenseText); // Add portrait last so it appears on top this.previewContainer.add(this.previewPortrait); // Initially hide the preview this.previewContainer.setVisible(false); // Create phase text below chapter text this.phaseText = this.add.text(gameWidth - 20, 45, 'Player Phase', { fontSize: '20px', color: '#4444ff', fontFamily: 'Arial', fontStyle: 'bold' }) .setOrigin(1, 0) .setStroke('#000000', 2) .setAlpha(0.8) .setDepth(1000); // Create turn count text below phase text this.turnText = this.add.text(gameWidth - 20, 75, `Turn ${this.turnCount}`, { fontSize: '20px', color: '#ffffff', fontFamily: 'Arial', fontStyle: 'bold' }) .setOrigin(1, 0) .setStroke('#000000', 2) .setAlpha(0.8) .setDepth(1000); // Create chapter text last to ensure it's on top of everything this.chapterText = this.add.text(gameWidth - 20, 15, `Chapter ${this.currentChapter}`, { fontSize: '24px', color: '#ffffffaa', fontFamily: 'Arial', fontStyle: 'bold' }) .setOrigin(1, 0) .setStroke('#000000', 3) .setAlpha(0.8) .setDepth(1000); } init() { // Initialize showGrowths flag this.showGrowths = false; // Add keyboard input for 'G' key this.input.keyboard.on('keydown-G', () => { this.showGrowths = !this.showGrowths; // Update preview if it's visible if (this.previewContainer && this.previewContainer.visible) { this.updatePreviewText(this.lastHoveredMember); } }); } // Remove cleanupGameState method as it's no longer needed updatePreviewText(hoveredMember) { if (hoveredMember && hoveredMember.member) { this.lastHoveredMember = hoveredMember; if (this.showGrowths && hoveredMember.member.growthRates) { // Show growth rates this.previewHpText.setText(`HP: ${hoveredMember.member.currentHp}/${hoveredMember.member.maxHp} (${hoveredMember.member.growthRates.hp}%)`); this.previewAttackText.setText(`ATK: ${hoveredMember.member.attack} (${hoveredMember.member.growthRates.attack}%)`); this.previewDefenseText.setText(`DEF: ${hoveredMember.member.defense} (${hoveredMember.member.growthRates.defense}%)`); } else { // Show normal stats this.previewHpText.setText(`HP: ${hoveredMember.member.currentHp}/${hoveredMember.member.maxHp}`); this.previewAttackText.setText(`ATK: ${hoveredMember.member.attack}`); this.previewDefenseText.setText(`DEF: ${hoveredMember.member.defense}`); } this.previewClassText.setText(`${hoveredMember.member.class} (lvl ${hoveredMember.member.level})`); this.previewNameText.setText(hoveredMember.member.name); } } // Add new method to handle level ups processLevelUp(character) { // Reset kill counter character.member.enemiesKilled = 0; // Level up! character.member.level++; // Check for promotion levels (both level 10 and 30) const isPromotionLevel = character.member.level === 10 || character.member.level === 30; // Apply promotion bonuses for both level 10 and 30 if (isPromotionLevel) { const currentTier = character.member.level === 10 ? 1 : 2; // Tier 1 for level 10, Tier 2 for level 30 const currentClass = this.characterClasses.find(c => c.name === character.member.class); // Find promotion class const promotionClass = this.characterClasses.find(c => c.tier === currentTier + 1 && c.baseName === currentClass.name); if (promotionClass) { // Store old stats for comparison const oldStats = { hp: character.member.maxHp, attack: character.member.attack, defense: character.member.defense }; // Apply new class modifiers character.member.class = promotionClass.name; character.member.maxHp += promotionClass.hpMod; character.member.currentHp = character.member.maxHp; character.member.attack += promotionClass.atkMod; character.member.defense += promotionClass.defMod; // Update growth rates const personality = character.member.personality; character.member.growthRates = { hp: personality.growthRates.hp + promotionClass.growthRates.hp, attack: personality.growthRates.attack + promotionClass.growthRates.attack, defense: personality.growthRates.defense + promotionClass.growthRates.defense }; // Display promotion text const promotionText = this.add.text( this.cameras.main.width / 2, this.cameras.main.height / 2 - 50, `Class Change!\n${currentClass.name} → ${promotionClass.name}\nHP +${character.member.maxHp - oldStats.hp} ATK +${character.member.attack - oldStats.attack} DEF +${character.member.defense - oldStats.defense}`, { fontSize: '24px', color: '#00ff00', stroke: '#000000', strokeThickness: 4, align: 'center' } ).setOrigin(0.5); // Animate promotion text this.tweens.add({ targets: promotionText, y: promotionText.y - 50, alpha: 0, duration: 2000, onComplete: () => promotionText.destroy() }); } } // Calculate stat gains let statGains = { hp: 0, attack: 0, defense: 0 }; // Roll for each stat if (Phaser.Math.Between(1, 100) <= character.member.growthRates.hp) { statGains.hp = 1; character.member.maxHp++; character.member.currentHp++; } if (Phaser.Math.Between(1, 100) <= character.member.growthRates.attack) { statGains.attack = 1; character.member.attack++; } if (Phaser.Math.Between(1, 100) <= character.member.growthRates.defense) { statGains.defense = 1; character.member.defense++; } // Display level up message const levelUpText = this.add.text( this.cameras.main.width / 2, this.cameras.main.height / 2, `${character.member.name} Level Up!\nHP +${statGains.hp} ATK +${statGains.attack} DEF +${statGains.defense}`, { fontSize: '24px', color: '#ffff00', stroke: '#000000', strokeThickness: 4, align: 'center' } ).setOrigin(0.5).setDepth(1000); // Animate level up text this.tweens.add({ targets: levelUpText, y: levelUpText.y - 50, alpha: 0, duration: 2000, onComplete: () => { levelUpText.destroy(); } }); } } const config = { type: Phaser.AUTO, parent: 'renderDiv', scale: { mode: Phaser.Scale.FIT, autoCenter: Phaser.Scale.CENTER_BOTH, }, width: 800, height: 600, scene: [Example], physics: { default: 'arcade', arcade: { gravity: { y: 0 }, debug: false } } }; window.phaserGame = new Phaser.Game(config);