forrests

ts/generated/tilesets.ts

@@ -351,7 +351,8 @@ export const tilesets = {
         ],
         "variant": 5
       }
-    ]
+    ],
+    "name": "desertRuins"
   },
   "desert": {
     "variants": [
@@ -1034,7 +1035,8 @@ export const tilesets = {
         ],
         "variant": 9
       }
-    ]
+    ],
+    "name": "desert"
   },
   "forrest": {
     "variants": [
@@ -6680,7 +6682,8 @@ export const tilesets = {
         ],
         "variant": 15
       }
-    ]
+    ],
+    "name": "forrest"
   },
   "pond": {
     "variants": [
@@ -11199,7 +11202,8 @@ export const tilesets = {
         ],
         "variant": 27
       }
-    ]
+    ],
+    "name": "pond"
   },
   "fort": {
     "variants": [
@@ -11724,13 +11728,6 @@ export const tilesets = {
               "y": 4
             },
             "id": "wall"
-          },
-          {
-            "position": {
-              "x": 5,
-              "y": 5
-            },
-            "id": "wall"
           }
         ],
         "variant": 2
@@ -13317,6 +13314,7 @@ export const tilesets = {
         ],
         "variant": 9
       }
-    ]
+    ],
+    "name": "fort"
   }
 };

ts/src/game/component/world/waterComponent.ts

@@ -12,7 +12,7 @@ export class WaterComponent extends EntityComponent {
         context.drawRectangle({
             x: this.entity.worldPosition.x * 40 + 3,
             y: this.entity.worldPosition.y * 40 + 3,
-            fill: "blue",
+            fill: "#2347cc",
             height: 32,
             width: 32,
         });

ts/src/game/map/biome/common/forts.ts

@@ -19,36 +19,30 @@ import { buildingPrefab } from "../../../prefab/buildingPrefab.js";
 import { farmPrefab } from "../../../prefab/farmPrefab.js";
 import { housePrefab } from "../../../prefab/housePrefab.js";
 import { wellPrefab } from "../../../prefab/wellPrefab.js";
-import { TilesetVariant } from "../../tileset.js";
-import { BiomeEntry } from "../biome.js";
+import { TilesetVariant, getLargestSize } from "../../tileset.js";
+import { placeTileset } from "../../tilesetPlacer.js";
+import { BiomeEntry, BiomeType } from "../biome.js";
 import {
     BiomeMap,
     BiomeMapItem,
     BiomeMapItemEntityFactory,
 } from "../biomeMap.js";
 
 export function generateForts(biomeMap: BiomeMap) {
-    const shouldPlaceForts = Math.random() > 0.6;
+    const shouldPlaceForts = Math.random() > getFortWeight(biomeMap.type);
     if (shouldPlaceForts) {
-        const possibleForPositions = getAllPositionsBoundsFitWithinBounds(
-            { x: 32, y: 32 },
-            { x: 5, y: 5 },
-            (candidate) => biomeMap.isSpotAvailable(candidate),
-        );
-
-        if (possibleForPositions.length > 0) {
-            const oasisPosition = randomEntry(
-                shuffleItems(possibleForPositions),
-            );
+        placeTileset(tilesets.fort, biomeMap, createEntityFactory);
+    }
+}
 
-            const tileset = randomEntry(tilesets.fort.variants);
-            biomeMap.setItem({
-                name: "fort",
-                point: { x: oasisPosition.x1, y: oasisPosition.y1 },
-                size: sizeOfBounds(oasisPosition),
-                factory: createEntityFactory(tileset),
-            });
-        }
+function getFortWeight(type: BiomeType): number {
+    switch (type) {
+        case "forrest":
+        case "snow":
+        case "plains":
+            return 0.1;
+        default:
+            return 0.4;
     }
 }
 

ts/src/game/map/biome/common/vegetation.ts

@@ -1,2 +1,29 @@
-export function generateRandomTrees() {}
+import { generateId } from "../../../../common/idGenerator.js";
+import { Entity } from "../../../entity/entity.js";
+import { treePrefab } from "../../../prefab/treePrefab.js";
+import { placeRandomEntity } from "../../tilesetPlacer.js";
+import {
+    BiomeMap,
+    BiomeMapItem,
+    BiomeMapItemEntityFactory,
+} from "../biomeMap.js";
+
+export function generateRandomTrees(map: BiomeMap) {
+    const randomAmount = 64 + Math.floor(Math.random() * 200);
+    placeRandomEntity(map, "tree", randomAmount, treeFactory);
+}
+
 export function generateRandomBushes() {}
+
+function treeFactory(
+    item: BiomeMapItem,
+    biome: BiomeMap,
+    _allMaps: ReadonlyArray<BiomeMap>,
+    rootEntity: Entity,
+) {
+    const position = biome.worldPosition(item);
+    const variant = Math.floor(Math.random() * 3);
+    const tree = treePrefab(generateId("tree"), variant);
+    tree.worldPosition = position;
+    rootEntity.addChild(tree);
+}

ts/src/game/map/biome/forrest/forrest.ts

@@ -1 +1,54 @@
-export function generateForrest() {}
+import { tilesets } from "../../../../../generated/tilesets.js";
+import { sizeOfBounds } from "../../../../common/bounds.js";
+import { generateId } from "../../../../common/idGenerator.js";
+import { addPoint } from "../../../../common/point.js";
+import { Entity } from "../../../entity/entity.js";
+import { treePrefab } from "../../../prefab/treePrefab.js";
+import { TilesetVariant } from "../../tileset.js";
+import { placeTileset } from "../../tilesetPlacer.js";
+import { BiomeMap, BiomeMapItem } from "../biomeMap.js";
+
+export function generateForrest(map: BiomeMap) {
+    const maxBudget = (32 * 32) / 4;
+    const tileBudget = Math.floor(Math.random() * maxBudget) + maxBudget;
+    let usedBudget = 0;
+    while (usedBudget < tileBudget) {
+        const placedBounds = placeTileset(tilesets.forrest, map, treeFactory);
+        if (placedBounds) {
+            const size = sizeOfBounds(placedBounds);
+            const amount = size.x * size.y;
+            usedBudget += amount;
+        } else {
+            break;
+        }
+    }
+}
+
+function treeFactory(tilesetVariant: TilesetVariant) {
+    return (
+        item: BiomeMapItem,
+        biome: BiomeMap,
+        _allMaps: ReadonlyArray<BiomeMap>,
+        rootEntity: Entity,
+    ) => {
+        for (const entity of tilesetVariant.entities) {
+            switch (entity.id) {
+                case "forrest":
+                    const treeVariant = Math.floor(Math.random() * 3);
+                    const treeEntity = treePrefab(
+                        generateId("tree"),
+                        treeVariant,
+                    );
+
+                    treeEntity.worldPosition = addPoint(
+                        biome.worldPosition(item),
+                        entity.position,
+                    );
+                    rootEntity.addChild(treeEntity);
+                    break;
+                default:
+                    break;
+            }
+        }
+    };
+}

ts/src/game/map/biome/forrest/forrestBiome.ts

@@ -13,13 +13,12 @@ import { generateForrestLake } from "./forrestLake.js";
 
 export function createForrestBiome(biome: BiomeEntry) {
     const biomeMap = new BiomeMap(biome.point, biome.type);
-    generateForrestLake();
+    generateForrestLake(biomeMap);
     generateSmallMountains();
-    generatePonds();
-    generateForrest();
+    generateForrest(biomeMap);
     generateNonPlayerKingdom();
     generateForts(biomeMap);
-    generateRandomTrees();
+    generateRandomTrees(biomeMap);
     generateRandomBuildings();
     generateMines();
     generateConnectionPoints();

ts/src/game/map/biome/forrest/forrestLake.ts

@@ -1 +1,58 @@
-export function generateForrestLake() {}
+import { tilesets } from "../../../../../generated/tilesets.js";
+import { randomEntry, shuffleItems } from "../../../../common/array.js";
+import {
+    getAllPositionsBoundsFitWithinBounds,
+    sizeOfBounds,
+} from "../../../../common/bounds.js";
+import { generateId } from "../../../../common/idGenerator.js";
+import { addPoint } from "../../../../common/point.js";
+import { WaterComponent } from "../../../component/world/waterComponent.js";
+import { Entity } from "../../../entity/entity.js";
+import { Tileset, TilesetVariant, getLargestSize } from "../../tileset.js";
+import { placeTileset } from "../../tilesetPlacer.js";
+import {
+    BiomeMap,
+    BiomeMapItem,
+    BiomeMapItemEntityFactory,
+} from "../biomeMap.js";
+
+export function generateForrestLake(map: BiomeMap) {
+    const maxBudget = (32 * 32) / 10;
+    const tileBudget = Math.floor(Math.random() * maxBudget);
+    let usedBudget = 0;
+    while (usedBudget < tileBudget) {
+        const placedBounds = placeTileset(tilesets.pond, map, lakeFactory);
+        if (placedBounds) {
+            const size = sizeOfBounds(placedBounds);
+            const amount = size.x * size.y;
+            usedBudget += amount;
+        } else {
+            break;
+        }
+    }
+}
+
+function lakeFactory(tilesetVariant: TilesetVariant) {
+    return (
+        item: BiomeMapItem,
+        biome: BiomeMap,
+        _allMaps: ReadonlyArray<BiomeMap>,
+        rootEntity: Entity,
+    ) => {
+        for (const entity of tilesetVariant.entities) {
+            switch (entity.id) {
+                case "water":
+                    const waterEntity = new Entity(generateId("water"));
+                    waterEntity.addComponent(new WaterComponent());
+                    waterEntity.worldPosition = addPoint(
+                        biome.worldPosition(item),
+                        entity.position,
+                    );
+                    rootEntity.addChild(waterEntity);
+                    break;
+                default:
+                    break;
+            }
+        }
+    };
+}

ts/src/game/map/biome/mountains/mountainBiome.ts

@@ -1,3 +1,4 @@
+import { Point } from "../../../../common/point.js";
 import { BiomeEntry } from "../biome.js";
 import { BiomeMap } from "../biomeMap.js";
 import { generateConnectionPoints } from "../common/connectionPoints.js";
@@ -8,18 +9,22 @@ import { generateRandomTrees } from "../common/vegetation.js";
 
 export function createMountainsBiome(biome: BiomeEntry) {
     const biomeMap = new BiomeMap(biome.point, biome.type);
-    fillWithMountainTiles();
-    addCarveouts();
+    const mountainMap: MountainMap = {};
+    fillWithMountainTiles(mountainMap);
+    //addCarveouts(mountainMap);
     generateForts(biomeMap);
-    connectCarveouts();
+    //connectCarveouts(mountainMap, biomeMap);
     blobbifyMountains();
-    generateRandomTrees();
+    generateRandomTrees(biomeMap);
     generateStones();
     generateMines();
     generateConnectionPoints();
     return biomeMap;
 }
-function fillWithMountainTiles() {
+
+type MountainMap = { [id: string]: Point };
+
+function fillWithMountainTiles(_mountainMap: MountainMap) {
     //throw new Error("Function not implemented.");
 }
 

ts/src/game/map/tileset.ts

@@ -8,5 +8,23 @@ export type TilesetVariant = {
 };
 
 export type Tileset = {
+    name: string;
     variants: TilesetVariant[];
 };
+
+export function getLargestSize(tileset: Tileset): Point {
+    return tileset.variants.reduce(
+        (largest, current) => {
+            if (current.width > largest.x) {
+                largest.x = current.width;
+            }
+
+            if (current.height > largest.y) {
+                largest.y = current.height;
+            }
+
+            return largest;
+        },
+        { x: 0, y: 0 },
+    );
+}