@hytopia.com/examples 1.0.3 → 1.0.5

package/frontiers-rpg-game/src/quests/BaseQuest.ts

@@ -0,0 +1,83 @@
+import { SkillId } from '../config';
+import BaseEntity from '../entities/BaseEntity';
+import type { BaseEntityDialogueOption } from '../entities/BaseEntity';
+import type GamePlayer from '../GamePlayer';
+import type GamePlayerEntity from '../GamePlayerEntity';
+import type { ItemClass } from '../items/BaseItem';
+
+export type QuestState = 'active' | 'completed';
+
+export type QuestReward = {
+  items?: { itemClass: ItemClass; quantity: number }[];
+  skillExperience?: { skillId: SkillId; amount: number }[];
+}
+
+export type QuestObjective = {
+  id: string;
+  name: string;
+  description: string;
+  target: number;
+}
+
+export type QuestNpcDialogueInteraction = {
+  npcClass: typeof BaseEntity;
+  dialogueOption: BaseEntityDialogueOption;
+  enabledForInteractor: (interactor: GamePlayerEntity) => boolean;
+}
+
+// Player's progress on a specific quest - simplified to just track progress
+export type PlayerQuestState = {
+  questId: string;
+  state: QuestState;
+  objectiveProgress: { [objectiveId: string]: number };
+  completionCleanup?: () => void;
+}
+
+// Static quest definition class
+export default abstract class BaseQuest {
+  public static readonly id: string;
+  public static readonly name: string;
+  public static readonly description: string;
+  public static readonly objectives: QuestObjective[] = [];
+  public static readonly reward: QuestReward;
+  public static readonly dialogueInteractions: QuestNpcDialogueInteraction[] = [];
+
+  public static availableForPlayer(player: GamePlayer): boolean {
+    return true; // Override in subclasses for requirements
+  }
+
+  public static setupForPlayer(gamePlayer: GamePlayer): () => void {
+    // Override in subclasses to set up event listeners, etc
+    // Returns a cleanup function that will be called when the quest is completed
+    return () => {};
+  }
+
+  public static rewardCompletionForPlayer(gamePlayer: GamePlayer): boolean {
+    if (!gamePlayer.questLog.isQuestActive(this.id)) {
+      return false;
+    }
+
+    if (this.reward.items) {
+      const requiredInventorySlots = this.reward.items.length;
+      const availableSlots = gamePlayer.hotbar.totalEmptySlots + gamePlayer.backpack.totalEmptySlots;
+
+      if (availableSlots < requiredInventorySlots) {
+        gamePlayer.showNotification('Your inventory is too full to accept the quest rewards. Please clear some space and try again.', 'warning');
+        return false;
+      }
+
+      for (const itemReward of this.reward.items) {
+        const item = itemReward.itemClass.create({ quantity: itemReward.quantity });
+        gamePlayer.hotbar.addItem(item) || gamePlayer.backpack.addItem(item);
+      }
+    }
+
+    if (this.reward.skillExperience) {
+      for (const expReward of this.reward.skillExperience) {
+        gamePlayer.adjustSkillExperience(expReward.skillId, expReward.amount);
+      }
+    }
+
+    return true;
+  }
+}

package/frontiers-rpg-game/src/quests/QuestRegistry.ts

@@ -0,0 +1,118 @@
+import { readdirSync, statSync } from 'fs';
+import { join } from 'path';
+import BaseEntity from '../entities/BaseEntity';
+import BaseQuest from './BaseQuest';
+import type { BaseEntityDialogueOption } from '../entities/BaseEntity';
+import type GamePlayerEntity from '../GamePlayerEntity';
+import type { QuestNpcDialogueInteraction } from './BaseQuest';
+
+type QuestClass = typeof BaseQuest;
+
+export const QUEST_DIALOGUE_OPTION_START_ID = 1000;
+
+export default class QuestRegistry {
+  private static _quests = new Map<string, QuestClass>();
+  private static _dialogueOptionData = new Map<string, { option: BaseEntityDialogueOption; interaction: QuestNpcDialogueInteraction }>();
+  private static _npcRootDialogueOptionIds = new Map<typeof BaseEntity, Set<number>>();
+
+  public static getQuests(): Map<string, QuestClass> {
+    return this._quests;
+  }
+
+  public static getQuestClass(questId: string): QuestClass | undefined {
+    return this._quests.get(questId);
+  }
+
+  public static getQuestRootDialogueOptionsForNPC(npcClass: typeof BaseEntity, interactor: GamePlayerEntity): BaseEntityDialogueOption[] {
+    const rootDialogueOptionIds = this._npcRootDialogueOptionIds.get(npcClass);
+    if (!rootDialogueOptionIds) return [];
+
+    const options: BaseEntityDialogueOption[] = [];
+    for (const optionId of rootDialogueOptionIds) {
+      const data = this._dialogueOptionData.get(`${npcClass.name}-${optionId}`);
+      if (data?.interaction.enabledForInteractor(interactor)) {
+        options.push(data.option);
+      }
+    }
+    return options;
+  }
+
+  public static getValidQuestDialogueOptionForNPC(npcClass: typeof BaseEntity, optionId: number, interactor: GamePlayerEntity): BaseEntityDialogueOption | undefined {
+    const data = this._dialogueOptionData.get(`${npcClass.name}-${optionId}`);
+    return data?.interaction.enabledForInteractor(interactor) ? data.option : undefined;
+  }
+  
+  public static initializeQuests(): void {
+    console.log('Loading quests...');
+    
+    const questFiles = this._findQuestFiles(__dirname);
+    const npcIdCounters = new Map<typeof BaseEntity, number>();
+    let loadedCount = 0;
+    
+    for (const filePath of questFiles) {
+      try {
+        const QuestClass = require(filePath).default;
+        
+        if (QuestClass?.prototype instanceof BaseQuest && QuestClass.id) {
+          this._quests.set(QuestClass.id, QuestClass);
+          
+          for (const interaction of QuestClass.dialogueInteractions) {
+            let currentId = npcIdCounters.get(interaction.npcClass) ?? QUEST_DIALOGUE_OPTION_START_ID;
+            
+            const assignIds = (dialogueOption: BaseEntityDialogueOption, isRoot: boolean = false): void => {
+              const optionId = currentId++;
+              
+              dialogueOption._id = optionId;
+              this._dialogueOptionData.set(`${interaction.npcClass.name}-${optionId}`, { option: dialogueOption, interaction });
+              
+              if (isRoot) {
+                let npcRootOptionIds = this._npcRootDialogueOptionIds.get(interaction.npcClass);
+                if (!npcRootOptionIds) {
+                  npcRootOptionIds = new Set();
+                  this._npcRootDialogueOptionIds.set(interaction.npcClass, npcRootOptionIds);
+                }
+                npcRootOptionIds.add(optionId);
+              }
+
+              if (dialogueOption.nextDialogue?.options) {
+                for (const option of dialogueOption.nextDialogue.options) {
+                  assignIds(option, false);
+                }
+              }
+            };
+            
+            assignIds(interaction.dialogueOption, true);
+            npcIdCounters.set(interaction.npcClass, currentId);
+          }
+          
+          loadedCount++;
+        }
+      } catch (error) {
+        console.warn(`Failed to load quest: ${filePath}`);
+      }
+    }
+
+    console.log(`Loaded ${loadedCount} quests`);
+  }
+  
+  private static _findQuestFiles(dir: string): string[] {
+    const files: string[] = [];
+    
+    try {
+      for (const item of readdirSync(dir)) {
+        const path = join(dir, item);
+        
+        if (statSync(path).isDirectory()) {
+          files.push(...this._findQuestFiles(path));
+        } else if (!item.startsWith('Base') && (item.endsWith('.ts') || item.endsWith('.js'))) {
+          files.push(path);
+        }
+      }
+    } catch (error) {
+      console.warn(`Failed to read directory: ${dir}`);
+    }
+  
+    return files;
+  }
+}
+

package/frontiers-rpg-game/src/quests/main/BlightedHarvestQuest.ts

@@ -0,0 +1,58 @@
+import BaseQuest, { QuestObjective, QuestNpcDialogueInteraction } from '../BaseQuest';
+import { SkillId } from '../../config';
+
+import type GamePlayer from '../../GamePlayer';
+
+import { BaseItemPlayerEvent } from '../../items/BaseItem';
+import type { BaseItemPlayerEventPayloads } from '../../items/BaseItem';
+
+import BlightedRootItem from '../../items/materials/BlightedRootItem';
+
+export default class BlightedHarvestQuest extends BaseQuest {
+  static readonly id = 'blighted-harvest';
+  static readonly name = 'Blighted Harvest';
+  static readonly description = `Scout Morel has discovered corrupted flowers spewing concentrated green vapor deep in the Ratkin Nest. He calls them Blight Blooms. These Blight Blooms are tainting the Ratkin. He needs you to destroy them and take their salvaged remains to Healer Mycelis.`;
+
+  static readonly reward = {
+    skillExperience: [
+      { skillId: SkillId.COMBAT, amount: 300 },
+      { skillId: SkillId.EXPLORATION, amount: 300 },
+    ],
+  }
+
+  static readonly objectives: QuestObjective[] = [
+    {
+      id: 'collect-blighted-roots',
+      name: 'Collect 10 Blighted Roots',
+      description: 'Collect 10 Blighted Roots from Lesser Blight Blooms in the Ratkin Nest.',
+      target: 10,
+    },
+    {
+      id: 'give-blighted-roots',
+      name: 'Give 10 Blighted Roots to Healer Mycelis',
+      description: 'Give 10 Blighted Roots to Healer Mycelis in Stalkhaven.',
+      target: 1,
+    }
+  ];
+
+  static readonly dialogueInteractions: QuestNpcDialogueInteraction[] = [
+    // add convo with healer mycelis
+  ];
+
+  public static setupForPlayer(gamePlayer: GamePlayer): () => void {
+    // Add event listeners
+    const itemPickupListener = (payload: BaseItemPlayerEventPayloads[BaseItemPlayerEvent.PICKED_UP]) => {
+      if (payload.item.id === BlightedRootItem.id) {
+        gamePlayer.questLog.adjustObjectiveProgress(this.id, 'collect-blighted-roots', payload.item.quantity);
+      }
+    };
+
+    gamePlayer.eventRouter.on(BaseItemPlayerEvent.PICKED_UP, itemPickupListener);
+
+    const cleanup = () => {
+      gamePlayer.eventRouter.off(BaseItemPlayerEvent.PICKED_UP, itemPickupListener);
+    };
+
+    return cleanup;
+  }    
+}

package/frontiers-rpg-game/src/quests/main/ClearingCampsQuest.ts

@@ -0,0 +1,152 @@
+import BaseQuest, { QuestObjective, QuestNpcDialogueInteraction } from '../BaseQuest';
+import { SkillId } from '../../config';
+import type GamePlayer from '../../GamePlayer';
+import type GamePlayerEntity from '../../GamePlayerEntity';
+
+import { BaseEntityPlayerEvent } from '../../entities/BaseEntity';
+import type { BaseEntityPlayerEventPayloads } from '../../entities/BaseEntity';
+
+import CaptainChanterelionEntity from '../../regions/chitter-forest/npcs/CaptainChanterelionEntity';
+import IntoTheNestQuest from './IntoTheNestQuest';
+
+import GoldItem from '../../items/general/GoldItem';
+
+// Bounding boxes we check when a kill happens to determine if it was in an objective area.
+const CAMP_KILL_BOUNDING_BOXES = [
+  { // Main camp
+    objectiveId: 'kill-main-camp',
+    min: { x: -31, y: 1, z: -21 },
+    max: { x: 1, y: 6, z: 16 },
+  },
+  { // Secondary camp
+    objectiveId: 'kill-secondary-camp',
+    min: { x: -20, y: 1, z: -60 },
+    max: { x: 24, y: 6, z: -29 },
+  },
+  { // Lake camp
+    objectiveId: 'kill-lake-camp',
+    min: { x: -115, y: 1, z: 13},
+    max: { x: -65, y: 6, z: 70 },
+  },
+  { // Corridor camp
+    objectiveId: 'kill-corridor-camp',
+    min: { x: 38, y: 1, z: 13 },
+    max: { x: 97, y: 6, z: 55 },
+  },
+];
+
+export default class ClearingCampsQuest extends BaseQuest {
+  static readonly id = 'clearing-camps';
+  static readonly name = `Clearing Camps`;
+  static readonly description = 'The Ratkin have established four major encampments that threaten Stalkhaven. We need to thin out these camps before they can launch a full on assault on Stalkhaven.';
+
+  static readonly reward = {
+    items: [
+      { itemClass: GoldItem, quantity: 100 },
+    ],
+    skillExperience: [
+      { skillId: SkillId.AGILITY, amount: 50 },
+      { skillId: SkillId.COMBAT, amount: 200 },
+      { skillId: SkillId.EXPLORATION, amount: 175 },
+    ],
+  }
+
+  static readonly objectives: QuestObjective[] = [
+    {
+      id: 'kill-main-camp',
+      name: 'Kill 3 Main camp Ratkin',
+      description: 'Kill 3 Ratkin at their main camp in Chitter Forest',
+      target: 3,
+    },
+    {
+      id: 'kill-secondary-camp',
+      name: 'Kill 3 Secondary camp Ratkin',
+      description: 'Kill 3 Ratkin at their secondary camp in Chitter Forest',
+      target: 3,
+    },
+    {
+      id: 'kill-lake-camp',
+      name: 'Kill 3 Lake camp Ratkin',
+      description: 'Kill 3 Ratkin at their lake camp in Chitter Forest',
+      target: 3,
+    },
+    {
+      id: 'kill-corridor-camp',
+      name: 'Kill 3 Corridor camp Ratkin',
+      description: 'Kill 3 Ratkin at their corridor camp in Chitter Forest',
+      target: 3,
+    },
+    {
+      id: 'talk-to-chanterelion',
+      name: 'Talk to Captain Chanterelion',
+      description: 'Talk to Captain Chanterelion at his outpost in Chitter Forest after completing all other objectives.',
+      target: 1,
+    }
+  ];
+
+  static readonly dialogueInteractions: QuestNpcDialogueInteraction[] = [
+    // Quest Complete 
+    {
+      npcClass: CaptainChanterelionEntity,
+      dialogueOption: {
+        text: `I've cleared out the Ratkin camps. What's the situation now?`,
+        nextDialogue: {
+          text: `Great work. You've bought us precious time. My scouts report the surviving Ratkin are retreating toward the lake cave. That cave was once a peaceful Ratkin nest before the fog corrupted them. If there's a source to their madness in that cave, we might have a chance to end this threat at its root.`,
+          options: [
+            {
+              text: `Sounds like that's where we'll need to strike next.`,
+              nextDialogue: {
+                text: `I agree, we're already ahead of you - I've sent one of our scouts to the entrance of the cave to get more intel. Head to the cave and meet with him, we'll need a brave warrior like you to get to the bottom of this.`,
+                options: [
+                  {
+                    text: `I'll head there immediately.`,
+                    dismiss: true,
+                    pureExit: true,
+                  }
+                ]
+              },
+              onSelect: (interactor: GamePlayerEntity) => {
+                interactor.gamePlayer.questLog.adjustObjectiveProgress(this.id, 'talk-to-chanterelion', 1);
+                interactor.gamePlayer.questLog.completeQuest(this.id);
+                interactor.gamePlayer.questLog.startQuest(IntoTheNestQuest);
+              }
+            }
+          ]
+        }
+      },
+      enabledForInteractor: (interactor: GamePlayerEntity) => {
+        return interactor.gamePlayer.questLog.isQuestActive(this.id) &&
+               interactor.gamePlayer.questLog.isQuestObjectiveCompleted(this.id, 'kill-main-camp') &&
+               interactor.gamePlayer.questLog.isQuestObjectiveCompleted(this.id, 'kill-secondary-camp') &&
+               interactor.gamePlayer.questLog.isQuestObjectiveCompleted(this.id, 'kill-lake-camp') &&
+               interactor.gamePlayer.questLog.isQuestObjectiveCompleted(this.id, 'kill-corridor-camp');
+      }
+    }
+  ];
+
+  public static setupForPlayer(gamePlayer: GamePlayer): () => void {
+    // Add event listeners
+    const killListener = (payload: BaseEntityPlayerEventPayloads[BaseEntityPlayerEvent.KILLED]) => {
+      const entity = payload.entity;
+
+      if (entity.name.includes('Ratkin')) {
+        const killedInObjectiveBoundingBox = CAMP_KILL_BOUNDING_BOXES.find(boundingBox => {
+          return entity.position.x >= boundingBox.min.x && entity.position.z >= boundingBox.min.z &&
+                 entity.position.x <= boundingBox.max.x && entity.position.z <= boundingBox.max.z;
+        });
+
+        if (killedInObjectiveBoundingBox) {
+          gamePlayer.questLog.adjustObjectiveProgress(this.id, killedInObjectiveBoundingBox.objectiveId, 1);
+        }
+      }
+    }
+
+    gamePlayer.eventRouter.on(BaseEntityPlayerEvent.KILLED, killListener);
+
+    const cleanup = () => {
+      gamePlayer.eventRouter.off(BaseEntityPlayerEvent.KILLED, killListener);
+    };
+
+    return cleanup;
+  } 
+}

package/frontiers-rpg-game/src/quests/main/ExploringStalkhavenQuest.ts

@@ -0,0 +1,161 @@
+import BaseQuest, { QuestObjective, QuestNpcDialogueInteraction } from '../BaseQuest';
+import { SkillId } from '../../config';
+import type GamePlayerEntity from '../../GamePlayerEntity';
+
+import HealerMycelisEntity from '../../regions/stalkhaven/npcs/HealerMycelisEntity';
+import CaptainSpornEntity from '../../regions/stalkhaven/npcs/CaptainSpornEntity';
+import CommanderMarkEntity from '../../regions/stalkhaven/npcs/CommanderMarkEntity';
+import MerchantFinnEntity from '../../regions/stalkhaven/npcs/MerchantFinnEntity';
+import TestedMettleQuest from './TestedMettleQuest';
+
+import DullSwordItem from '../../items/weapons/DullSwordItem';
+import AdventurerTunicItem from '../../items/wearables/AdventurerTunicItem';
+import GoldItem from '../../items/general/GoldItem';
+
+export default class ExploringStalkhavenQuest extends BaseQuest {
+  static readonly id = 'exploring-stalkhaven';
+  static readonly name = 'Exploring Stalkhaven';
+  static readonly description = `Commander Mark advised you to learn from Stalkhaven\'s people before facing The Frontier\'s dangers. Speak with key townspeople - the healer who tends to fog survivors, the merchant who supplies brave souls, and the captain who leads refugees to safety. Their knowledge could mean the difference between life and death in the corrupted lands beyond.`;
+
+  static readonly reward = {
+    items: [
+      { itemClass: AdventurerTunicItem, quantity: 1 },
+      { itemClass: DullSwordItem, quantity: 1 },
+      { itemClass: GoldItem, quantity: 75 },
+    ],
+    skillExperience: [
+      { skillId: SkillId.EXPLORATION, amount: 125 },
+    ],
+  }
+
+  static readonly objectives: QuestObjective[] = [
+    {
+      id: 'talk-to-mycelis',
+      name: 'Talk to Healer Mycelis',
+      description: 'Find Healer Mycelis in Stalkhaven and speak with him.',
+      target: 1,
+    },
+    {
+      id: 'talk-to-finn',
+      name: 'Talk to Merchant Finn',
+      description: 'Find Merchant Finn in Stalkhaven and speak with him.',
+      target: 1,
+    },
+    {
+      id: 'talk-to-sporn',
+      name: 'Talk to Captain Sporn',
+      description: 'Find Captain Sporn in Stalkhaven and speak with him.',
+      target: 1,
+    },
+    {
+      id: 'talk-to-mark',
+      name: 'Return to Commander Mark',
+      description: 'Speak with Commander Mark after speaking with the others.',
+      target: 1,
+    }
+  ];
+
+  static readonly dialogueInteractions: QuestNpcDialogueInteraction[] = [
+    // Healer Mycelis
+    {
+      npcClass: HealerMycelisEntity,
+      dialogueOption: {
+        text: `Commander Mark said I should speak with you before venturing into The Frontier.`,
+        nextDialogue: {
+          text: `Wise counsel from Mark. I am Mycelis, a healer who fled Sporewick when corruption consumed it. My spores can mend wounds and cleanse fog ailments. Return when you need healing, traveler.`,
+          options: [
+            {
+              text: `Thank you, Elder. I'll remember.`,
+              dismiss: true,
+              pureExit: true,
+              
+            }
+          ]
+        },
+        onSelect: (interactor: GamePlayerEntity) => {
+          interactor.gamePlayer.questLog.adjustObjectiveProgress(this.id, 'talk-to-mycelis', 1);
+        }
+      },
+      enabledForInteractor: (interactor: GamePlayerEntity) => {
+        return interactor.gamePlayer.questLog.isQuestActive(this.id) && !interactor.gamePlayer.questLog.isQuestObjectiveCompleted(this.id, 'talk-to-mycelis');
+      }
+    },
+
+    // Merchant Finn
+    {
+      npcClass: MerchantFinnEntity,
+      dialogueOption: {
+        text: `Commander Mark said I should speak with you about equipment for The Frontier.`,
+        nextDialogue: {
+          text: `Smart thinking! I'm Finn, and I've got gear to keep you breathing out there. Quality blades, healing potions, whatever you need. Bring coin or trade goods, I'll keep you equipped.`,
+          options: [
+            {
+              text: `I'll remember that. Thanks, Finn.`,
+              dismiss: true,
+              pureExit: true,
+            }
+          ]
+        },
+        onSelect: (interactor: GamePlayerEntity) => {
+          interactor.gamePlayer.questLog.adjustObjectiveProgress(this.id, 'talk-to-finn', 1);
+        }
+      },
+      enabledForInteractor: (interactor: GamePlayerEntity) => {
+        return interactor.gamePlayer.questLog.isQuestActive(this.id) && !interactor.gamePlayer.questLog.isQuestObjectiveCompleted(this.id, 'talk-to-finn');
+      }
+    },
+
+    // Captain Sporn 
+    {
+      npcClass: CaptainSpornEntity,
+      dialogueOption: {
+        text: `Commander Mark sent me to learn about the threats beyond the gates.`,
+        nextDialogue: {
+          text: `Good preparation. Chitter Forest is overrun with corrupted Ratkin under the "Whisker King." Once peaceful traders, now they attack on sight. Get weapons from Finn before entering that cursed forest.`,
+          options: [
+            {
+              text: `I'll arm myself first. Thanks for the warning.`,
+              dismiss: true,
+              pureExit: true,
+            }
+          ]
+        },
+        onSelect: (interactor: GamePlayerEntity) => {
+          interactor.gamePlayer.questLog.adjustObjectiveProgress(this.id, 'talk-to-sporn', 1);
+        }
+      },
+      enabledForInteractor: (interactor: GamePlayerEntity) => {
+        return interactor.gamePlayer.questLog.isQuestActive(this.id) && !interactor.gamePlayer.questLog.isQuestObjectiveCompleted(this.id, 'talk-to-sporn');
+      }
+    },
+
+    // Return to Commander Mark to complete quest
+    {
+      npcClass: CommanderMarkEntity,
+      dialogueOption: {
+        text: `I've spoken with Healer Mycelis, Merchant Finn, and Captain Sporn as you suggested.`,
+        nextDialogue: {
+          text: `Good work - now you understand what we're facing. The 7th Regiment needs help clearing corrupted Ratkin camps, but first I need to test your abilities. These aren't the peaceful traders we once knew - the fog changed them. Take this blade, tunic and coin.. Head to Chitter Forest, and prove you can handle a few corrupted Ratkin.`,
+          options: [
+            {
+              text: `Understood, Commander. I'll prove myself in Chitter Forest.`,
+              dismiss: true,
+              pureExit: true,
+            }
+          ]
+        },
+        onSelect: (interactor: GamePlayerEntity) => {
+          interactor.gamePlayer.questLog.adjustObjectiveProgress(this.id, 'talk-to-mark', 1);
+          interactor.gamePlayer.questLog.completeQuest(this.id);
+          interactor.gamePlayer.questLog.startQuest(TestedMettleQuest);
+        }
+      },
+      enabledForInteractor: (interactor: GamePlayerEntity) => {
+        return interactor.gamePlayer.questLog.isQuestActive(this.id) && 
+          interactor.gamePlayer.questLog.isQuestObjectiveCompleted(this.id, 'talk-to-mycelis') &&
+          interactor.gamePlayer.questLog.isQuestObjectiveCompleted(this.id, 'talk-to-finn') &&
+          interactor.gamePlayer.questLog.isQuestObjectiveCompleted(this.id, 'talk-to-sporn');
+      }
+    }
+  ];
+}

package/frontiers-rpg-game/src/quests/main/IntoTheNestQuest.ts

@@ -0,0 +1,63 @@
+import BaseQuest, { QuestObjective, QuestNpcDialogueInteraction } from '../BaseQuest';
+import { SkillId } from '../../config';
+import type GamePlayerEntity from '../../GamePlayerEntity';
+
+import ScoutMorelEntity from '../../regions/ratkin-nest/npcs/ScoutMorelEntity';
+import BlightedHarvestQuest from './BlightedHarvestQuest';
+
+export default class IntoTheNestQuest extends BaseQuest {
+  static readonly id = 'into-the-nest';
+  static readonly name = `Into the Nest`;
+  static readonly description = `Captain Chanterelion has sent you to meet his scout in a cave by the nearby lake that's the entrance to a Ratkin Nest.`;
+
+  static readonly reward = {
+    skillExperience: [
+      { skillId: SkillId.EXPLORATION, amount: 75 },
+    ],
+  }
+
+  static readonly objectives: QuestObjective[] = [
+    {
+      id: 'talk-to-scout-morel',
+      name: 'Find and speak with Scout Morel',
+      description: 'Find Scout Morel in the Ratkin nest by the Chitter Forest lake and speak with him.',
+      target: 1,
+    },
+  ];
+
+  static readonly dialogueInteractions: QuestNpcDialogueInteraction[] = [
+    // Quest Complete 
+    {
+      npcClass: ScoutMorelEntity,
+      dialogueOption: {
+        text: `Captain Chanterelion sent me to find you. What's going on here?`,
+        nextDialogue: {
+          text: `Thank the spores you're here! The Captain said he'd send someone. I've been scouting this corrupted nest and found something deeply disturbing - twisted, pulsating growths I've never seen before. They're like corrupted flowers, spewing concentrated sickly green vapor that is similar to the fog. I'm calling them Blight Blooms - they seem to be spreading the corruption that's turning the Ratkin into those aggressive Tainted ones.`,
+          options: [
+            {
+              text: `What do you need me to do?`,
+              nextDialogue: {
+                text: `These Blight Blooms... they're not natural. Us Capfolk have generations of knowledge about fungi and plant corruption - if we can get remains of these things back to Healer Mycelis in Stalkhaven, he might be able to determine where this blight is coming from. I need you to destroy those foul Blight Blooms, collect whatever remains you can salvage, and bring them to Healer Mycelis in Stalkhaven.`,
+                options: [
+                  {
+                    text: `I'll destroy the Blight Blooms and bring the remains to Healer Mycelis.`,
+                    dismiss: true,
+                    pureExit: true,
+                  }
+                ]
+              },
+              onSelect: (interactor: GamePlayerEntity) => {
+                interactor.gamePlayer.questLog.adjustObjectiveProgress(this.id, 'talk-to-scout-morel', 1);
+                interactor.gamePlayer.questLog.completeQuest(this.id);
+                interactor.gamePlayer.questLog.startQuest(BlightedHarvestQuest);
+              }
+            }
+          ]
+        },
+      },
+      enabledForInteractor: (interactor: GamePlayerEntity) => {
+        return interactor.gamePlayer.questLog.isQuestActive(this.id);
+      }
+    }
+  ];
+}