Implement the world wonder.

src/data/buildings.ts

@@ -30,6 +30,7 @@ export default [
         name: 'Town Hall',
         autoBuilt: true,
         maxLevel: 20,
+        requiredTownhallLevel: 0,
         cost: (level: number) => {
             return {
                 wood: getResourceBuildingCost(level, 10),
@@ -56,6 +57,7 @@ export default [
         name: 'Woodcutter',
         autoBuilt: true,
         maxLevel: 20,
+        requiredTownhallLevel: 0,
         cost: (level: number) => {
             return {
                 wood: getResourceBuildingCost(level, 6),
@@ -83,6 +85,7 @@ export default [
         name: 'Mine',
         autoBuilt: true,
         maxLevel: 20,
+        requiredTownhallLevel: 0,
         cost: (level: number) => {
             return {
                 wood: getResourceBuildingCost(level, 10),
@@ -110,6 +113,7 @@ export default [
         name: 'Pit',
         autoBuilt: true,
         maxLevel: 20,
+        requiredTownhallLevel: 0,
         cost: (level: number) => {
             return {
                 wood: getResourceBuildingCost(level, 14),
@@ -137,6 +141,7 @@ export default [
         name: 'Field',
         autoBuilt: true,
         maxLevel: 20,
+        requiredTownhallLevel: 0,
         cost: (level: number) => {
             return {
                 wood: getResourceBuildingCost(level, 14),
@@ -159,6 +164,7 @@ export default [
         type: 'warehouse',
         name: 'Warehouse',
         maxLevel: 20,
+        requiredTownhallLevel: 0,
         cost: (level: number) => {
             return {
                 wood: getStorageBuildingCost(level, 15),
@@ -185,6 +191,7 @@ export default [
         type: 'granary',
         name: 'Granary',
         maxLevel: 20,
+        requiredTownhallLevel: 0,
         cost: (level: number) => {
             return {
                 wood: getStorageBuildingCost(level, 12),
@@ -207,10 +214,65 @@ export default [
             },
         },
     },
+    {
+        type: 'great-warehouse',
+        name: 'Great Warehouse',
+        maxLevel: 20,
+        requiredTownhallLevel: 15,
+        cost: (level: number) => {
+            return {
+                wood: getStorageBuildingCost(level, 150),
+                stone: getStorageBuildingCost(level, 200),
+                iron: getStorageBuildingCost(level, 100),
+                food: getStorageBuildingCost(level, 150),
+            };
+        },
+        timeToBuild: (level: number) => getStandardTimeToBuild(level) * 2,
+        behavior: {
+            storage: (V: VillageState, self: BuildingType) => {
+                const x = self.level;
+                const capacity = ( ( ( x + ( x * x ) ) / 2 ) + 3 ) * 250;
+                return {
+                    'wood': capacity,
+                    'stone': capacity,
+                    'iron': capacity,
+                    'food': 0,
+                };
+            },
+        },
+    },
+    {
+        type: 'great-granary',
+        name: 'Great Granary',
+        maxLevel: 20,
+        requiredTownhallLevel: 15,
+        cost: (level: number) => {
+            return {
+                wood: getStorageBuildingCost(level, 120),
+                stone: getStorageBuildingCost(level, 220),
+                iron: getStorageBuildingCost(level, 100),
+                food:getStorageBuildingCost(level,  60),
+            };
+        },
+        timeToBuild: (level: number) => getStandardTimeToBuild(level) * 2,
+        behavior: {
+            storage: (V: VillageState, self: BuildingType) => {
+                const x = self.level;
+                const capacity = ( ( ( x + ( x * x ) ) / 2 ) + 3 ) * 250;
+                return {
+                    'wood': 0,
+                    'stone': 0,
+                    'iron': 0,
+                    'food': capacity,
+                };
+            },
+        },
+    },
     {
         type: 'university',
         name: 'University',
         maxLevel: 20,
+        requiredTownhallLevel: 5,
         cost: (level: number) => {
             return {
                 wood: getUnitBuildingCost(level, 75),
@@ -237,6 +299,7 @@ export default [
         type: 'barracks',
         name: 'Barracks',
         maxLevel: 20,
+        requiredTownhallLevel: 3,
         cost: (level: number) => {
             return {
                 wood: getUnitBuildingCost(level, 60),
@@ -264,6 +327,7 @@ export default [
         name: 'Palace',
         maxLevel: 20,
         unique: true,
+        requiredTownhallLevel: 10,
         cost: (level: number) => {
             return {
                 wood: getStorageBuildingCost(level, 200),
@@ -289,4 +353,35 @@ export default [
             },
         },
     },
+    {
+        type: 'wonder',
+        name: 'World Wonder',
+        maxLevel: 1,
+        unique: true,
+        requiredTownhallLevel: 20,
+        cost: () => {
+            return {
+                wood: 42000,
+                stone: 42000,
+                iron: 42000,
+                food: 38000,
+            };
+        },
+        timeToBuild: () => 120,
+        behavior: {
+            production: (V: VillageState, self: BuildingType) => {
+                const prod = getEmptyResources();
+                prod.food = self.level * -300;
+                return prod;
+            },
+            triggers: {
+                onLevelUp: (V: VillageState, self: BuildingType) => {
+                    if (self.level === 1) {
+                        // Gain a lot of culture.
+                        V.resources.culture += 18000;
+                    }
+                },
+            },
+        },
+    },
 ];

src/hud/BuildingCreator.svelte

@@ -3,8 +3,8 @@
     import buildings from "../data/buildings";
     import moves from "../moves";
     import showBuildingCreator from "../stores/showBuildingCreator";
-    import { canPayBuildingCost } from "../utils";
-    import village, { type VillageState } from "../village";
+    import { canPayBuildingCost, getTownhall } from "../utils";
+    import village from "../village";
     import Cost from "./Cost.svelte";
 
     function close() {
@@ -25,11 +25,13 @@
     $: constructible = buildings
         .filter(b => !b.autoBuilt)
         .filter(b => !(b.unique && $village.buildings.some(b2 => b2.type === b.type)))
+        .filter(b => !b.requiredTownhallLevel || getTownhall($village).level >= b.requiredTownhallLevel)
         .map(b =>{
             const building = createBuilding(b.type);
             building.level = 0;
             return building;
-        });
+        })
+        .sort((a, b) => a.requiredTownhallLevel - b.requiredTownhallLevel);
 </script>
 
 { #if $showBuildingCreator !== null }

src/quests.ts

@@ -1,31 +0,0 @@
-import type { QuestType, ResourcesType } from "./types";
-import { getEmptyResources, random } from "./utils";
-
-
-let uid = 0;
-
-
-export function createQuest(level: number): QuestType {
-    const reward = getEmptyResources();
-    const adjustedLevel = level * level + 3;
-    const duration = random(adjustedLevel - 2, adjustedLevel + 2);
-    Object.keys(reward).forEach(r => {
-        const resource = r as keyof ResourcesType;
-        reward[resource] = random(
-            Math.round((duration * 5 - level * 10) * (1 + level / 3)),
-            Math.round((duration * 5 + level * 10) * (1 + level / 3)),
-        );
-
-        if (resource === 'culture') {
-            reward[resource] = Math.round(reward[resource] / 20);
-        }
-    });
-
-    return {
-        id: uid++,
-        duration,
-        reward,
-        level,
-        started: false,
-    };
-}

src/types.ts

@@ -26,6 +26,7 @@ export interface BuildingSource {
     autoBuilt?: boolean;
     unique?: boolean;
     maxLevel: number;
+    requiredTownhallLevel: number;
     cost: (level: number) => CostType;
     timeToBuild: (level: number) => number;
     behavior: {

src/update.ts

@@ -1,11 +1,11 @@
 import { produce } from 'immer';
 
 import { CULTURE_TO_WIN } from './constants';
+import { createQuest } from './create';
 import { resolveMission } from './missions';
 import type { ProductionType } from './types';
 import { getProduction, getStorage, shuffle } from './utils';
 import village, { type VillageState } from "./village";
-import { createQuest } from './quests';
 
 
 let lastFrame: number;

src/utils.ts

@@ -161,3 +161,12 @@ export function canPayBuildingCost(V: VillageState, building: BuildingType): boo
         || cost.food > V.resources.food
     );
 }
+
+
+export function getTownhall(V: VillageState): BuildingType {
+    const townhall = V.buildings.find(b => b.type === 'townhall');
+    if (!townhall) {
+        throw new Error("Unable to find the Town hall");
+    }
+    return townhall;
+}

src/village.ts

@@ -112,6 +112,7 @@ function getInitialState() {
 
     // Create the Town hall.
     const townhall = createBuilding('townhall');
+    // townhall.level = 20;
     state.villageTiles[0][0] = townhall.id;
     state.buildings.push(townhall);
 
@@ -134,7 +135,7 @@ function getInitialState() {
             }
             const newBuilding = createBuilding(type);
             newBuilding.tile = new Hex(x, y);
-            newBuilding.level = 20; //newBuilding.type === 'field' ? 1 : 10;
+            newBuilding.level = 1; //20; //newBuilding.type === 'field' ? 1 : 10;
             state.outsideTiles[y][x] = newBuilding.id;
             state.buildings.push(newBuilding);
         });