// Define standardized enums for work states const WorkStates = { IDLE: 'IDLE', WORKING: 'WORKING', COMPLETED: 'COMPLETED' }; const InteractionStates = { NONE: 'none', DRAGGING: 'dragging' }; // Define enums for task zone types const TaskZoneTypes = { ASSEMBLY: 'ASSEMBLY', QUALITY_CHECK: 'QUALITY_CHECK', GIFT_WRAPPING: 'GIFT_WRAPPING' }; const TaskZoneNames = { [TaskZoneTypes.ASSEMBLY]: 'Assembly Area', [TaskZoneTypes.QUALITY_CHECK]: 'Quality Check Area', [TaskZoneTypes.GIFT_WRAPPING]: 'Gift Wrapping Area' }; const TaskZoneActions = { [TaskZoneTypes.ASSEMBLY]: 'assemble toy', [TaskZoneTypes.QUALITY_CHECK]: 'check toy', [TaskZoneTypes.GIFT_WRAPPING]: 'wrap toy' }; const RestZoneName = 'Rest Area'; const RestZoneAction = 'rest'; class ExtendedSprite extends Phaser.GameObjects.Sprite { constructor(scene, x, y, texture) { super(scene, x, y, texture); this.associatedObjects = []; // Listen for the destroy event this.on('destroy', this.destroyAssociatedObjects, this); scene.add.existing(this); } registerAssociatedObject(obj) { this.associatedObjects.push(obj); } destroyAssociatedObjects() { this.associatedObjects.forEach(obj => obj.destroy()); this.associatedObjects = []; } } class TaskZone extends ExtendedSprite { constructor(scene, type = TaskZoneTypes.ASSEMBLY) { const screenWidth = scene.scale.width; const totalTaskZoneWidth = screenWidth * 0.8; const taskZoneWidth = totalTaskZoneWidth / 3; const x = screenWidth * 0.1 + taskZoneWidth / 2 + taskZoneWidth * (type === TaskZoneTypes.ASSEMBLY ? 0 : type === TaskZoneTypes.QUALITY_CHECK ? 1 : 2); const y = scene.scale.height / 2.1; super(scene, x, y, 'taskZone'); this.scene = scene; this.setOrigin(0.5, 0.5); this.determineDimensions(); this.setDisplaySize(this.width, this.height); this.setDepth(1); this.setAlpha(0); // 30% transparency this.type = type; this.elves = []; this.toys = []; this.workAssignments = {}; // Mapping of elves to toys this.createTextLabels(); this.createBench(); scene.add.existing(this); } determineDimensions() { const screenWidth = this.scene.scale.width; const screenHeight = this.scene.scale.height; this.width = (screenWidth * 0.8) / 3; // 80% of screen width divided by 3 this.height = screenHeight / 2; } determineBenchPosition() { const benchWidth = this.width; const benchHeight = this.height / 3; const benchY = this.y + this.height / 2.5; return { benchWidth, benchHeight, benchY }; } createBench() { const { benchWidth, benchHeight, benchY } = this.determineBenchPosition(); const bench = this.scene.add.sprite(this.x, benchY, 'bench'); bench.setDisplaySize(benchWidth, benchHeight); bench.setOrigin(0.5, 0.5); this.scene.add.existing(bench); } createTextLabels() { const action = TaskZoneActions[this.type]; // Create text with background this.actionText = new TextWithBackground(this.scene, this.x, this.y + this.height / 2 - 20, `Drag n Drop Elf\nto ${action}`, { fontSize: '16px', fontFamily: 'Arial', color: '#ffffff' }); this.registerAssociatedObject(this.actionText); } destroyTextLabels() { if (this.nameText) this.nameText.destroy(); if (this.actionText) this.actionText.destroy(); } positionToys() { const toyWidth = this.toys[0]?.displayWidth || 64; const toyHeight = this.toys[0]?.displayHeight || 64; const maxToysPerRow = Math.floor(this.width / toyWidth); const padding = 10; const totalRows = Math.ceil(this.toys.length / maxToysPerRow); const totalHeight = totalRows * (toyHeight + padding); const startY = this.y - totalHeight / 2; this.toys.forEach((toy, index) => { const row = Math.floor(index / maxToysPerRow); const col = index % maxToysPerRow; const totalRowWidth = Math.min(maxToysPerRow, this.toys.length - row * maxToysPerRow) * (toyWidth + padding); const startX = this.x - totalRowWidth / 2; const x = startX + col * (toyWidth + padding) + toyWidth / 2; const y = startY + row * (toyHeight + padding) + toyHeight / .75; toy.setPosition(x, y); }); } addToy(toy) { if (!this.toys.includes(toy)) { this.toys.push(toy); this.positionToys(); // Update positions of all toys } } removeToy(toy) { if (this.toys.includes(toy)) { this.toys = this.toys.filter(t => t !== toy); this.positionToys(); // Update positions of remaining toys } } addElf(elf) { if (!this.elves.includes(elf)) { this.elves.push(elf); // this.scene.currentLog.addEntry(elf.id, `Entered the ${TaskZoneNames[this.type]}`); } } removeElf(elf) { if (this.elves.includes(elf)) { this.elves = this.elves.filter(e => e !== elf); // this.scene.currentLog.addEntry(elf.id, `Exited the ${TaskZoneNames[this.type]}`); } } isElfInZone(elf) { return Phaser.Geom.Intersects.RectangleToRectangle(this.getBounds(), elf.getBounds()); } updateElfList(elf) { if (this.isElfInZone(elf)) { this.addElf(elf); } else { this.removeElf(elf); } } getNearestToy(elf) { let nearestToy = null; let minDistance = Infinity; this.toys.forEach(toy => { if ((toy.state === WorkStates.IDLE || toy.isPaused()) && toy.state !== WorkStates.COMPLETED) { const distance = Phaser.Math.Distance.Between(elf.x, elf.y, toy.x, toy.y); if (distance < minDistance) { minDistance = distance; nearestToy = toy; } } }); return nearestToy; } update() { // Check each toy in the task zone every frame this.toys.forEach(toy => { if (toy.state === WorkStates.COMPLETED) { const elf = this.elves.find(e => e.workState === WorkStates.WORKING); if (elf) { this.completeWork(elf, toy); } } }); // Check if elves in the zone are idle and assign them to work on the nearest toy this.elves.forEach(elf => elf.lookForWork()); } startWork(elf, toy) { if (elf.workState === WorkStates.IDLE && (toy.state === WorkStates.IDLE || toy.isPaused())) { const elfId = elf.id; const toyId = toy.id; const previousElfState = elf.workState; const previousToyState = toy.state; elf.setWorkState(WorkStates.WORKING); toy.setState(WorkStates.WORKING); toy.setSpeedMultiplier(elf.getSpeedMultiplier()); // Pass elf's speed multiplier to toy this.workAssignments[elfId] = toy; // Map elf to toy } } completeWork(elf, toy) { const workType = this.type === TaskZoneTypes.ASSEMBLY ? 'Assembled' : this.type === TaskZoneTypes.QUALITY_CHECK ? 'Checked' : 'Wrapped'; this.scene.currentLog.addEntry(elf.id, `${workType} toy ${toy.id}`); elf.setWorkState(WorkStates.IDLE); toy.setState(WorkStates.COMPLETED); delete this.workAssignments[elf.id]; // Remove mapping // Notify ToyManager before transitioning the state this.scene.toyManager.handleToyCompletion(toy, this.type); if (this.type === TaskZoneTypes.ASSEMBLY) { toy.transitionState(this, this.scene.qualityCheckZone); } else if (this.type === TaskZoneTypes.QUALITY_CHECK) { toy.transitionState(this, this.scene.giftWrappingZone); } } cancelWork(elf) { const toy = this.workAssignments[elf.id]; if (toy) { const elfId = elf.id; const toyId = toy.id; const previousElfState = elf.workState; const previousToyState = toy.state; elf.setWorkState(WorkStates.IDLE); toy.cancelWork(); delete this.workAssignments[elfId]; // Remove mapping } } } class ToyManager { constructor(scene, startCount, maxCount, taskZones) { this.scene = scene; this.startCount = startCount; this.maxCount = maxCount; this.taskZones = {}; this.toyCounter = 0; this.toys = []; taskZones.forEach(zone => { this.taskZones[zone.type] = zone; }); this.spawnInitialToys(); } spawnInitialToys() { for (let i = 0; i < this.startCount; i++) { this.spawnNewToy(); } } spawnNewToy() { if (this.toys.length < this.maxCount) { const toy = new Toy(this.scene, 300, 100, `${this.toyCounter++}`); this.toys.push(toy); this.taskZones[TaskZoneTypes.ASSEMBLY].addToy(toy); } } handleToyCompletion(toy, taskType) { this.spawnNewToy(); if (taskType === TaskZoneTypes.ASSEMBLY) { } else if (taskType === TaskZoneTypes.GIFT_WRAPPING) { this.archiveToy(toy); // Increment total toys wrappedF this.scene.totalToysWrapped++; this.scene.updateHUD(); this.scene.giftManager.createGift(toy.id); // Remove the toy from the task zone and toy manager const taskZone = this.taskZones[taskType]; taskZone.removeToy(toy); this.toys = this.toys.filter(t => t.id !== toy.id); // Destroy the toy sprite toy.destroy(); } } archiveToy(toy) { // For now, just archive the toy ID. This could be expanded in the future. this.archivedToys = this.archivedToys || []; this.archivedToys.push({ id: toy.id }); } update() { this.toys.forEach(toy => toy.update()); } } class Gift extends Phaser.GameObjects.Sprite { constructor(scene, x, y, toyId, countId) { super(scene, x, y, 'gift'); this.scene = scene; this.toyId = toyId; this.countId = countId; this.setOrigin(0.5, 0.5); this.setDisplaySize(48, 48); // Assuming a standard size for gifts this.setAlpha(0.5); scene.add.existing(this); } // Method to update appearance when the gift is created from a toy makeRealGift() { this.setAlpha(1); // Set to full opacity } } class GiftManager { constructor(scene) { this.scene = scene; this.gifts = []; this.giftCounter = 0; this.initializePlaceholders(this.scene.toysWrappedGoal); } // Initialize placeholder gifts at the start of the game initializePlaceholders(toyWrappedGoal) { for (let i = 0; i < toyWrappedGoal; i++) { this.createPlaceholderGift(i); } this.positionGifts(); } createPlaceholderGift(countId) { const x = this.calculateGiftXPosition(); // We will define this method to always return the left or right column X position const y = this.scene.scale.height - 100; // Position gifts 100px from the bottom of the screen const gift = new Gift(this.scene, x, y, null, countId); // Placeholder gifts don't have toyId initially this.gifts.push(gift); } createGift(toyId) { // Find the next placeholder gift and convert it to a real gift const gift = this.gifts.find(g => g.toyId === null); if (gift) { gift.toyId = toyId; gift.makeRealGift(); } this.positionGifts(); } calculateGiftXPosition() { const padding = 10; const giftWidth = 48; // Position gifts in the left column (change to right if needed) return padding + giftWidth / 2; } positionGifts() { const padding = 10; const giftWidth = 48; const giftHeight = 48; const screenHeight = this.scene.scale.height; let currentY = screenHeight - (giftHeight / 2) - padding; this.gifts.forEach((gift, index) => { const column = Math.floor(index / 10); const row = index % 10; const x = (column === 0) ? this.calculateGiftXPosition() : this.scene.scale.width - padding - giftWidth / 2; const y = screenHeight - padding - (row + 0.5) * (giftHeight + padding); gift.setPosition(x, y); }); } } class Clock { constructor(scene, maxTime) { this.scene = scene; this.maxTime = maxTime; // e.g., 30 seconds this.currentTime = maxTime; this.timeUp = false; } updateTime(delta) { if (this.timeUp) return; this.currentTime -= delta / 1000; // Convert delta to seconds if (this.currentTime <= 0) { this.currentTime = 0; this.timeUp = true; } } isTimeUp() { return this.timeUp; } getTimeLeft() { return Math.ceil(this.currentTime); // Round up to the nearest whole number } } class ProductivityLog { constructor(scene) { this.scene = scene; this.entries = {}; // Object to store log entries for each elf } addEntry(elfId, action) { const currentTime = this.scene.clock.currentTime; const elapsedTime = Math.floor(this.scene.maxTime - currentTime); // Calculate elapsed time and round to integer if (!this.entries[elfId]) { this.entries[elfId] = []; } const entry = `(${elapsedTime}s) - Elf ${elfId} ${action}`; this.entries[elfId].push(entry); this.printEntry(entry); } printEntry(entry) { console.log(entry); } printLog() { let log = "Productivity Log.\n\n"; log += `Session Duration: ${this.scene.clock.currentTime}s\n\n`; for (const [elfId, entries] of Object.entries(this.entries)) { log += `Elf ${elfId}:\n`; entries.forEach(entry => log += `${entry}\n`); log += "\n"; } log += "End Productivity Log.\n"; console.log(log); } } class TextWithBackground extends Phaser.GameObjects.Container { constructor(scene, x, y, text, style, padding = 10, align = 'center') { super(scene, x, y); this.scene = scene; this.padding = padding; this.text = this.scene.add.text(0, 0, text, style) .setOrigin(align === 'center' ? 0.5 : 0, 0.5) .setAlign(align); const bgWidth = this.text.width + 2 * this.padding; const bgHeight = this.text.height + 2 * this.padding; this.background = this.scene.add.sprite(0, 0, 'blackBg') .setDisplaySize(bgWidth, bgHeight) .setAlpha(0.75) .setOrigin(align === 'center' ? 0.5 : 0, 0.5); this.setDepth(1000); // High depth for visibility this.add(this.background); this.add(this.text); this.scene.add.existing(this); } setText(newText) { this.text.setText(newText); const bgWidth = this.text.width + 2 * this.padding; const bgHeight = this.text.height + 2 * this.padding; this.background.setDisplaySize(bgWidth, bgHeight); } } class Main extends Phaser.Scene { constructor() { super(); this.totalToysWrapped = 0; this.toysWrappedGoal = 20; // Goal for wrapped toys to trigger game over this.playState = 'playing'; // Enum-like state management this.maxTime = 120; // 30 seconds max time this.elfCount = 3; // Number of elves to initialize this.logs = []; this.hudTextWithBg = null; this.queueRestart = false; console.log('Main scene initialized'); } preload() { // Load images for elves, toys, task zones, and gifts this.load.image('elf', 'https://play.rosebud.ai/assets/elf.png?TvoI'); this.load.image('toy_dino', 'https://play.rosebud.ai/assets/toy_dino.png?QNfE'); this.load.image('toy_bot', 'https://play.rosebud.ai/assets/toy_bot.webp?MiBw'); this.load.image('toy_rosie', 'https://play.rosebud.ai/assets/toy_rosie.png?EMBz'); this.load.image('toy_bear', 'https://play.rosebud.ai/assets/toy_bear.png?YsKP'); this.load.image('taskZone', 'https://play.rosebud.ai/assets/taskZone.png?udwL'); this.load.image('gift', 'https://play.rosebud.ai/assets/gift.png?BjZa'); // Add correct path to gift sprite this.load.image('restZone', 'https://play.rosebud.ai/assets/taskZone.png?udwL'); // Add correct path to rest zone sprite this.load.image('background', 'https://play.rosebud.ai/assets/DALL·E 2024-07-27 15.11.51 - A highly detailed and realistic Christmas-decorated wooden cabin. The room has wooden walls and a high, pitched ceiling with exposed beams. There is a.webp?RILg'); this.load.image('bench', 'https://play.rosebud.ai/assets/table_PNG7002.png?9340'); this.load.image('blackBg', 'https://play.rosebud.ai/assets/Black.png?bWZ9'); // Load audio this.load.audio('carolOfTheBells', 'https://play.rosebud.ai/assets/carolOfTheBells.mp3?czkg'); } create() { const { width, height } = this.sys.game.config; const background = this.add.image(0, 0, 'background') .setOrigin(0.15, 0.3) .setDisplaySize(width * 1.5, height * 1.5); this.createGameElements(); // Play audio const music = this.sound.add('carolOfTheBells', { volume: 0.5, loop: true }); music.play(); } initializeClock() { this.clock = new Clock(this, this.maxTime); } createHUD() { const textStyle = { fontSize: '24px', fontFamily: 'Arial', color: '#ffffff' }; const hudContent = `Gifts Made: ${this.totalToysWrapped}\n\nGift Goal: ${this.toysWrappedGoal}\n\nTime Left: ${Math.round(this.maxTime)}`; // Create multi-line text with background for HUD this.hudTextWithBg = new TextWithBackground(this, 10, 80, hudContent, textStyle, 10, 'left'); } updateHUD() { const hudContent = `Gifts Made: ${this.totalToysWrapped}\n\nGift Goal: ${this.toysWrappedGoal}\n\nTime Left: ${Math.round(this.clock.currentTime)}`; this.hudTextWithBg.setText(hudContent); } initializeTaskZones() { this.taskZones = []; this.assemblyZone = new TaskZone(this, TaskZoneTypes.ASSEMBLY); this.qualityCheckZone = new TaskZone(this, TaskZoneTypes.QUALITY_CHECK); this.giftWrappingZone = new TaskZone(this, TaskZoneTypes.GIFT_WRAPPING); this.taskZones.push(this.assemblyZone, this.qualityCheckZone, this.giftWrappingZone); } initializeRestZone() { this.restZone = new RestZone(this); } initializeManagers() { this.toyManager = new ToyManager(this, 3, 6, this.taskZones); this.taskZones.forEach(zone => { zone.toyManager = this.toyManager; }); this.giftManager = new GiftManager(this); this.inputManager = new InputManager(this); } createGameElements() { this.createHUD(); this.initializeTaskZones(); this.initializeRestZone(); this.initializeManagers(); this.initializeElves(this.elfCount); this.initializeClock(); this.currentLog = new ProductivityLog(this); // Initialize productivity log } initializeElves(count) { this.elves = []; const elfSpacing = 100; for (let i = 0; i < count; i++) { const x = (i + 1) * elfSpacing; const y = this.scale.height - 100; const id = `${i + 1}`; const elf = new Elf(this, x, y, id); this.elves.push(elf); this.inputManager.addDragEvents(elf); } } clearHUD() { if (this.giftsMadeText) { this.giftsMadeText.destroy(); this.giftsMadeText = null; } if (this.giftsGoalText) { this.giftsGoalText.destroy(); this.giftsGoalText = null; } if (this.timeText) { this.timeText.destroy(); this.timeText = null; } } clearGameElements() { // Clear elves this.elves.forEach(elf => elf.destroy()); this.elves = []; // Clear toys this.toyManager.toys.forEach(toy => toy.destroy()); this.toyManager.toys = []; // Clear gifts this.giftManager.gifts.forEach(gift => gift.destroy()); this.giftManager.gifts = []; // Clear task zones this.taskZones.forEach(zone => zone.destroy()); this.taskZones = []; // Clear rest zone if (this.restZone) { this.restZone.destroy(); this.restZone = null; } // Clear HUD elements this.clearHUD(); } checkGameOver() { if (this.totalToysWrapped >= this.toysWrappedGoal || this.clock.isTimeUp()) { this.playState = 'finished'; console.log('Game Over! All toys are wrapped or time is up.'); // Queue game over handling to the next frame this.time.delayedCall(0, this.handleGameOver, [], this); } } createGameOverElements() { console.log('Creating game over elements...'); const success = this.totalToysWrapped >= this.toysWrappedGoal; const message = success ? "Christmas is saved!" : "Christmas is ruined!"; const giftsMadeText = `You made ${this.totalToysWrapped} out of ${this.toysWrappedGoal} gifts`; const { width, height } = this.sys.game.config; const centerX = width / 2; // Display message this.gameOverMessage = this.add.text(centerX, 50, message, { fontSize: '32px', fontFamily: 'Arial', color: '#ffffff' }).setOrigin(0.5, 0); // Display gifts made out of goal this.giftsMadeOutOfGoalText = this.add.text(centerX, 100, giftsMadeText, { fontSize: '24px', fontFamily: 'Arial', color: '#ffffff' }).setOrigin(0.5, 0); // Retry button this.retryButton = this.add.text(centerX, 200, 'Retry', { fontSize: '24px', fontFamily: 'Arial', color: '#000000', backgroundColor: '#808080', padding: { x: 10, y: 5 } }) .setOrigin(0.5, 0) .setInteractive() .on('pointerover', () => this.retryButton.setStyle({ fill: '#ffffff' })) .on('pointerout', () => this.retryButton.setStyle({ fill: '#000000' })) .on('pointerdown', () => { this.queueRestart = true; console.log('Retry button clicked, queueRestart set to true'); }); // Comment out productivity log code // this.productivityLogTitle = this.add.text(400, 50, "Santa's Productivity List", { fontSize: '32px', fontFamily: 'Arial', color: '#ffffff' }); // this.productivityLogEntries = []; // let yOffset = 100; // for (const [elfId, entries] of Object.entries(this.currentLog.entries)) { // // Display elf name // this.productivityLogEntries.push(this.add.text(400, yOffset, `Elf ${elfId}`, { fontSize: '18px', fontFamily: 'Arial', color: '#ffffff' })); // yOffset += 30; // // Display entries for this elf // entries.forEach((entry, index) => { // this.productivityLogEntries.push(this.add.text(400, yOffset, entry, { fontSize: '16px', fontFamily: 'Arial', color: '#ffffff' })); // yOffset += 20; // }); // yOffset += 10; // Add some space between different elves // } } clearGameOverElements() { console.log('Clearing game over elements...'); if (this.gameOverMessage) this.gameOverMessage.destroy(); if (this.giftsMadeOutOfGoalText) this.giftsMadeOutOfGoalText.destroy(); if (this.retryButton) this.retryButton.destroy(); if (this.productivityLogTitle) this.productivityLogTitle.destroy(); if (this.productivityLogEntries) this.productivityLogEntries.forEach(entry => entry.destroy()); } handleGameOver() { console.log('Handling game over...'); this.clearGameElements(); this.currentLog.printLog(); // Print the productivity log at the end of the game this.logs.push(this.currentLog); // Store the current log in the list of logs this.createGameOverElements(); } restart() { console.log('Restarting game...'); // Reset variables this.totalToysWrapped = 0; this.playState = 'playing'; this.queueRestart = false; // Clear game over elements this.clearGameOverElements(); console.log('Game over elements cleared'); // Recreate game elements this.createGameElements(); console.log('Game elements recreated'); } update(time, delta) { if (this.queueRestart) { console.log('Queue restart is true, restarting game...'); this.restart(); } if (this.playState === 'playing') { // Update each task zone every frame this.taskZones.forEach(zone => zone.update()); // Update the rest zone every frame this.restZone.update(); // Update elves each frame this.elves.forEach(elf => elf.update()); // Update toys each frame this.toyManager.update(); // Update the clock this.clock.updateTime(delta); this.updateHUD(); // Check for game over conditions this.checkGameOver(); } } } class RestZone extends ExtendedSprite { constructor(scene) { super(scene, 0, 0, 'restZone'); this.scene = scene; this.setAlpha(0); this.setOrigin(0.5, 0.5); this.setDepth(-1); this.determineDimensions(); this.setPosition(this.scene.scale.width / 2, this.scene.scale.height); this.setDisplaySize(this.width, this.height); this.createTextLabels(); scene.add.existing(this); } determineDimensions() { this.width = this.scene.scale.width; this.height = this.scene.scale.height / 3; } createTextLabels() { const textContent = `${RestZoneName}\nDrag n Drop Elf to ${RestZoneAction}`; // Create multi-line text with background this.textWithBg = new TextWithBackground(this.scene, this.x, this.y - this.height / 2 + 40, textContent, { fontSize: '24px', fontFamily: 'Arial', color: '#ffffff' }, 10, 'center'); this.registerAssociatedObject(this.textWithBg); } destroyTextLabels() { if (this.textWithBg) this.textWithBg.destroy(); } detectElfInZone(elf) { return Phaser.Geom.Intersects.RectangleToRectangle(this.getBounds(), elf.getBounds()); } handleElfEntry(elf) { elf.restState = 'RESTING'; elf.lastEnergyUpdateTime = this.scene.time.now; } handleElfExit(elf) { elf.restState = 'NOT_RESTING'; } update() { this.scene.elves.forEach(elf => { if (this.detectElfInZone(elf)) { if (elf.restState !== 'RESTING') { this.handleElfEntry(elf); } } else { if (elf.restState === 'RESTING') { this.handleElfExit(elf); } } }); } } class InputManager { constructor(scene) { this.scene = scene; this.currentTarget = null; // Variable to track the current drag target this.setupEvents(); } setupEvents() { this.scene.input.on('pointerdown', this.onPointerDown, this); this.scene.input.on('pointermove', this.onPointerMove, this); this.scene.input.on('pointerup', this.onPointerUp, this); } addDragEvents(target) { target.setInteractive(); // Ensure the target is interactive this.scene.input.setDraggable(target); } onPointerDown(pointer) { const allSprites = this.scene.children.getAll(); for (let sprite of allSprites) { if (sprite instanceof Elf && sprite.isPointerWithin(pointer)) { this.currentTarget = sprite; this.currentTarget.startDrag(); break; } } } onPointerMove(pointer) { if (this.currentTarget && pointer.isDown) { this.currentTarget.drag(pointer); } } onPointerUp(pointer) { if (this.currentTarget) { this.currentTarget.endDrag(); // Check all task zones for the current elf's position const taskZones = this.scene.children.getAll().filter(obj => obj instanceof TaskZone); for (let zone of taskZones) { zone.updateElfList(this.currentTarget); } this.currentTarget = null; // Clear the current target } } } class Elf extends ExtendedSprite { constructor(scene, x, y, id) { super(scene, x, y, 'elf'); this.scene = scene; this.id = id; // Unique ID for the elf instance this.setOrigin(0.5, 0.5); this.setDisplaySize(96, 96); this.setDepth(1001); this.setWorkState(WorkStates.IDLE); this.setInteractionState(InteractionStates.NONE); this.energyLevel = 100; // Start with full energy this.speedMultiplier = 1.0; // Default speed multiplier this.energyDepletionRate = 20; // Energy depletes over 10 seconds this.energyReplenishRate = 5; // Energy replenishes over 10 seconds this.lastEnergyUpdateTime = 0; // Time tracker for energy depletion and replenishment this.restState = 'NOT_RESTING'; // Initial rest state // Create and register progress bar for energy level this.progressBarOffsetX = 0; this.progressBarOffsetY = 36; // Position below the elf this.progressBar = new ProgressBar(scene, x, y + this.progressBarOffsetY, 60, 10, this.progressBarOffsetX, this.progressBarOffsetY); // Create and register energy text for energy level this.energyTextOffsetY = 56; // Position above the progress bar this.createEnergyText(scene); scene.add.existing(this); this.setInteractive(); } createEnergyText(scene) { this.energyText = new TextWithBackground(scene, this.x, this.y + this.energyTextOffsetY, this.getEnergyLevelText(), { fontSize: '16px', fontFamily: 'Arial', color: '#ffffff' }, 5); this.registerAssociatedObject(this.energyText); } updateEnergyText() { this.energyText.setText(this.getEnergyLevelText()); this.energyText.setPosition(this.x, this.y + this.energyTextOffsetY); } destroyEnergyText() { this.energyText.destroy(); } setWorkState(state) { this.workState = state; if (state === WorkStates.WORKING) { this.lastEnergyUpdateTime = this.scene.time.now; // Initialize energy depletion time } } setInteractionState(state) { this.interactionState = state; } startDrag() { this.setInteractionState(InteractionStates.DRAGGING); this.scene.taskZones.forEach(zone => zone.cancelWork(this)); } drag(pointer) { this.setPosition(pointer.x, pointer.y); } endDrag() { this.setInteractionState(InteractionStates.NONE); this.lookForWork(); } isPointerWithin(pointer) { return this.getBounds().contains(pointer.x, pointer.y); } cancelWork() { if (this.workState === WorkStates.WORKING) { this.setWorkState(WorkStates.IDLE); } } lookForWork() { const currentZone = this.scene.taskZones.find(zone => zone.isElfInZone(this)); if (currentZone && this.workState === WorkStates.IDLE && this.interactionState === InteractionStates.NONE) { const nearestToy = currentZone.getNearestToy(this); if (nearestToy) { currentZone.startWork(this, nearestToy); } } } getSpeedMultiplier() { if (this.energyLevel >= 0 && this.energyLevel <= 20) return 5.0; if (this.energyLevel > 20 && this.energyLevel <= 40) return 3.0; if (this.energyLevel > 40 && this.energyLevel <= 60) return 2.0; if (this.energyLevel > 60 && this.energyLevel <= 80) return 1.5; return 1.0; // Very Energized (80-100) } getEnergyLevelText() { if (this.energyLevel >= 0 && this.energyLevel <= 20) return 'Sleepy'; if (this.energyLevel > 20 && this.energyLevel <= 40) return 'Sleepy'; if (this.energyLevel > 40 && this.energyLevel <= 60) return 'Content'; if (this.energyLevel > 60 && this.energyLevel <= 80) return 'Excited'; return 'Excited'; // Very Energized (80-100) } depleteEnergy() { const currentTime = this.scene.time.now; const elapsedTime = (currentTime - this.lastEnergyUpdateTime) / 1000; // Convert to seconds const energyLost = elapsedTime * (100 / this.energyDepletionRate); this.energyLevel = Phaser.Math.Clamp(this.energyLevel - energyLost, 0, 100); this.lastEnergyUpdateTime = currentTime; } replenishEnergy() { const currentTime = this.scene.time.now; const elapsedTime = (currentTime - this.lastEnergyUpdateTime) / 1000; // Convert to seconds const energyGained = elapsedTime * (100 / this.energyReplenishRate); this.energyLevel = Phaser.Math.Clamp(this.energyLevel + energyGained, 0, 100); this.lastEnergyUpdateTime = currentTime; } update() { if (this.workState === WorkStates.WORKING) { this.depleteEnergy(); } else if (this.restState === 'RESTING') { this.replenishEnergy(); } this.updateProgressBar(); this.updateEnergyText(); } updateProgressBar() { this.progressBar.setPosition(this.x, this.y + this.progressBarOffsetY); this.progressBar.updateProgress(this.energyLevel); } destroy() { this.progressBar.destroy(); this.destroyEnergyText(); super.destroy(); } } class Toy extends ExtendedSprite { constructor(scene, x, y, id) { // List of available toy sprites const toySprites = ['toy_dino', 'toy_bot', 'toy_rosie', 'toy_bear']; // Select a random toy sprite const randomSprite = Phaser.Utils.Array.GetRandom(toySprites); super(scene, x, y, randomSprite); this.scene = scene; this.id = id; this.setOrigin(0.5, 0.5); this.setDisplaySize(64, 64); this.setDepth(10); this.state = WorkStates.IDLE; // Initialize state this.progress = 0; this.workDuration = 1500; // Adjusted for testing this.workStartTime = 0; this.speedMultiplier = 1.0; // Default speed multiplier // Offset for the progress bar relative to the toy this.progressBarOffsetX = 0; this.progressBarOffsetY = -20; // Default offset this.progressBar = new ProgressBar(scene, x, y, 60, 10, this.progressBarOffsetX, this.progressBarOffsetY); // Register the progress bar to be destroyed with the toy this.registerAssociatedObject(this.progressBar); scene.add.existing(this); } setState(state) { if (state === WorkStates.WORKING && this.isPaused()) { // Resume work from the current progress this.workStartTime = this.scene.time.now - (this.progress / 100) * (this.workDuration * this.speedMultiplier); } else if (state === WorkStates.WORKING) { this.workStartTime = this.scene.time.now; this.progress = 0; } else if (state === WorkStates.COMPLETED) { this.workStartTime = this.scene.time.now; this.progress = 0; } this.state = state; if (state === WorkStates.WORKING) { this.progressBar.setVisible(true); // Show progress bar when working } else if (state === WorkStates.COMPLETED) { this.progressBar.setVisible(false); // Hide progress bar when completed } } setSpeedMultiplier(multiplier) { this.speedMultiplier = multiplier; } cancelWork() { if (this.state === WorkStates.WORKING) { this.setState(WorkStates.IDLE); } } updateWork() { if (this.state === WorkStates.WORKING) { const elapsedTime = this.scene.time.now - this.workStartTime; const progressIncrease = (elapsedTime / (this.workDuration * this.speedMultiplier)) * 100; this.progress = Phaser.Math.Clamp(progressIncrease, 0, 100); if (this.progress >= 100) { this.setState(WorkStates.COMPLETED); } } } updateProgressBar() { // Update progress bar position based on toy position this.progressBar.setPosition(this.x + this.progressBarOffsetX, this.y + this.progressBarOffsetY); this.progressBar.updateProgress(this.progress); } update() { if (this.state === WorkStates.WORKING) { this.updateWork(); this.updateProgressBar(); } } transitionState(currentZone, nextZone) { switch (currentZone.type) { case TaskZoneTypes.ASSEMBLY: if (this.state === WorkStates.COMPLETED) { currentZone.removeToy(this); nextZone.addToy(this); this.setState(WorkStates.IDLE); } break; case TaskZoneTypes.QUALITY_CHECK: if (this.state === WorkStates.COMPLETED) { currentZone.removeToy(this); nextZone.addToy(this); this.setState(WorkStates.IDLE); } break; default: break; } } isPaused() { return this.progress > 0 && this.state === WorkStates.IDLE; } } class ProgressBarContainer extends Phaser.GameObjects.Container { constructor(scene, x, y, width, height, offsetX = 0, offsetY = 0) { super(scene, x + offsetX, y + offsetY); this.scene = scene; this.width = width; this.height = height; this.offsetX = offsetX; this.offsetY = offsetY; // Create the progress bar this.progressBar = new ProgressBar(scene, 0, 0, width, height); this.add(this.progressBar); // Create the text element this.text = this.scene.add.text(0, height / 2 + 10, '', { fontSize: '16px', fontFamily: 'Arial', color: '#ffffff' }).setOrigin(0.5, 0); this.add(this.text); scene.add.existing(this); } setPosition(x, y) { super.setPosition(x + this.offsetX, y + this.offsetY); this.progressBar.setPosition(this.x, this.y); this.text.setPosition(this.x, this.y + this.height / 2 + 10); } updateProgress(progress) { this.progressBar.updateProgress(progress); } updateText(text) { this.text.setText(text); } destroy() { this.progressBar.destroy(); this.text.destroy(); super.destroy(); } } // Define a reusable ProgressBar class class ProgressBar extends Phaser.GameObjects.Graphics { constructor(scene, x, y, width, height, offsetX = 0, offsetY = 0) { super(scene, { x: x + offsetX, y: y + offsetY }); this.scene = scene; this.width = width; this.height = height; this.offsetX = offsetX; this.offsetY = offsetY; this.setDepth(1000) // Add the progress bar to the scene scene.add.existing(this); this.updateProgress(0); // Initialize with 0 progress } // Set the position of the progress bar with respect to the sprite setPosition(x, y) { this.x = x + this.offsetX; this.y = y + this.offsetY; } // Update the progress bar display updateProgress(progress) { this.clear(); this.fillStyle(0x000000, 1); // Background color this.fillRect(-this.width / 2, -this.height / 2, this.width, this.height); this.fillStyle(0x00ff00, 1); // Progress color this.fillRect(-this.width / 2, -this.height / 2, (this.width * progress) / 100, this.height); } } // Game configuration const container = document.getElementById('renderDiv'); const config = { type: Phaser.AUTO, parent: 'renderDiv', scale: { mode: Phaser.Scale.FIT, autoCenter: Phaser.Scale.CENTER_BOTH, }, width: 800, height: 600, physics: { default: 'arcade', arcade: { gravity: { y: 0 } } }, scene: Main }; window.phaserGame = new Phaser.Game(config);