Draft: Adding Sink (Buildings)

parsing/gameData.json

@@ -13,6 +13,7 @@
         "oilrefinery": 30,
         "packager": 10,
         "quantumencoder": 0.1,
+        "resourcesink": 30,
         "smeltermk1": 4
     },
     "items": {

parsing/src/buildings.ts

@@ -39,8 +39,30 @@ function getProducingBuildings(data: any[]): string[] {
     return Array.from(producingBuildingsSet);  // Convert Set to an array
 }
 
-// Function to extract the power consumption for each producing building
-function getPowerConsumptionForBuildings(data: any[], producingBuildings: string[]): { [key: string]: number } {
+// For now this is just the 'Sink', but we may add more in the future
+function getConsumingBuildings(data: any[]): string[] {
+    const consumingBuildingsSet = new Set<string>();
+
+    data
+        .filter((entry: any) => entry.Classes)
+        .flatMap((entry: any) => entry.Classes)
+        .forEach((building: any) => {
+            if (building.ClassName && building.ClassName === "Build_ResourceSink_C") {
+                //This is just to make sure that it still exists, but we may grab more data from it in the future
+
+                // Normalize the building name by removing "_C" and lowercasing it
+                let buildingName: string = building.ClassName.replace(/_C$/, '').toLowerCase();
+                buildingName = buildingName.startsWith('build_') ? buildingName.replace('build_', '') : buildingName;
+
+                consumingBuildingsSet.add(buildingName)
+            }
+        });
+
+    return Array.from(consumingBuildingsSet);  // Convert Set to an array
+}
+
+// Function to extract the power consumption for each building
+function getPowerConsumptionForBuildings(data: any[], buildings: string[]): { [key: string]: number } {
     const buildingsPowerMap: { [key: string]: number } = {};
 
     data
@@ -53,7 +75,7 @@ function getPowerConsumptionForBuildings(data: any[], producingBuildings: string
                 buildingName = buildingName.startsWith('build_') ? buildingName.replace('build_', '') : buildingName;
 
                 // Only include power data if the building is in the producingBuildings list
-                if (producingBuildings.includes(buildingName)) {
+                if (buildings.includes(buildingName)) {
                     buildingsPowerMap[buildingName] = parseFloat(building.mPowerConsumption) || 0;
                 }
             }
@@ -68,4 +90,6 @@ function getPowerConsumptionForBuildings(data: any[], producingBuildings: string
     return sortedMap;
 }
 
-export { getProducingBuildings, getPowerConsumptionForBuildings };
+
+
+export { getProducingBuildings, getConsumingBuildings, getPowerConsumptionForBuildings };

parsing/src/processor.ts

@@ -8,7 +8,7 @@ import {ParserPowerRecipe} from "./interfaces/ParserPowerRecipe";
 import {ParserPart, ParserItemDataInterface} from "./interfaces/ParserPart";
 import {getItems, fixItemNames, fixTurbofuel} from './parts';
 import {getProductionRecipes, getPowerGeneratingRecipes} from './recipes';
-import {getProducingBuildings, getPowerConsumptionForBuildings} from './buildings';
+import {getProducingBuildings, getConsumingBuildings, getPowerConsumptionForBuildings} from './buildings';
 
 // Function to detect if the file is UTF-16
 async function isUtf16(inputFile: string): Promise<boolean> {
@@ -88,8 +88,11 @@ async function processFile(
         // Get an array of all buildings that produce something
         const producingBuildings = getProducingBuildings(data);
 
+        // Get an array of all buildings that consume something
+        const consumingBuildings = getConsumingBuildings(data);
+
         // Get power consumption for the producing buildings
-        const buildings = getPowerConsumptionForBuildings(data, producingBuildings);
+        const buildings = getPowerConsumptionForBuildings(data, [ ...producingBuildings, ...consumingBuildings]);
 
         // Pass the producing buildings with power data to getRecipes to calculate perMin and powerPerProduct
         const recipes = getProductionRecipes(data, buildings);

parsing/tests/parsing.spec.ts

@@ -64,6 +64,14 @@ describe('common', () => {
             expect(results.recipes.length).toBe(291);
         })
 
+        test('buildings test', () => {
+            //arrange
+
+            //act
+
+            //assert
+            expect(Object.keys(results.buildings).length).toBe(13);
+        })
 
         test('buildings should generate correct data', () => {
             expect(Object.keys(results.buildings).length).toBe(14);
@@ -83,6 +91,7 @@ describe('common', () => {
                 packager: 10,
                 quantumencoder: 0.1,  // This has variable power consumption and is calculated in the recipe
                 smeltermk1: 4,
+                resourcesink: 30,
             })
         })
 

web/src/components/planner/Planner.vue

@@ -254,6 +254,7 @@
       ['quantumencoder', 'Quantum Encoder'],
       ['smeltermk1', 'Smelter'],
       ['waterExtractor', 'Water Extractor'],
+      ['resourcesink', 'Resource Sink'],
     ])
 
     return buildingFriendly.get(building) || `UNKNOWN BUILDING: ${building}`

web/src/components/planner/PlannerFactorySatisfaction.vue

@@ -49,7 +49,7 @@
   </div>
 </template>
 
-<script setup lang="ts">
+  <script setup lang="ts">
   import {
     Factory,
   } from '@/interfaces/planner/FactoryInterface'
@@ -76,4 +76,4 @@
   // Reactive factory parts check
   const hasParts = computed(() => Object.keys(props.factory.parts).length > 0)
 
-</script>
+  </script>

web/src/components/planner/PlannerFactorySatisfactionBuildings.vue

@@ -1,10 +1,20 @@
 <template>
   <v-card class="sub-card border-md">
     <v-card-title>
-      <h2 class="text-h6">
+      <h2 class="text-h6 mr-3" style="display: inline">
         <i class="fas fa-building" />
         <span class="ml-3">Power &amp; Buildings</span>
       </h2>
+      <v-btn
+        v-if="!hasSinks"
+        color="orange mr-2"
+        prepend-icon="fas fa-cube"
+        ripple
+        variant="flat"
+        @click="addSinkBuildingRequirement()"
+      >
+        Add Sink
+      </v-btn>
     </v-card-title>
     <v-card-text class="text-body-1 pb-2">
       <v-chip
@@ -53,12 +63,49 @@
   import { formatNumber, formatPower } from '@/utils/numberFormatter'
   import { inject } from 'vue'
   import { Factory } from '@/interfaces/planner/FactoryInterface'
+  import { useGameDataStore } from '@/stores/game-data-store'
+
+  const updateFactory = inject('updateFactory') as (factory: Factory) => void
+
+  const gameDataStore = useGameDataStore()
 
-  defineProps<{
+  const hasSinks = computed(() => props.factory.buildingRequirements && props.factory.buildingRequirements.resourcesink)
+
+  const props = defineProps<{
     factory: Factory;
     helpText: boolean;
   }>()
 
   const getBuildingDisplayName = inject('getBuildingDisplayName') as (part: string) => string
 
+  const addSinkBuildingRequirement = () => {
+    console.log('hasSinks')
+    console.log(hasSinks.value)
+
+    const amount = 1
+    const buildingPower = gameDataStore.getGameData().buildings.resourcesink
+
+    console.log('Found Building')
+    console.log(buildingPower)
+
+    if (!props.factory.buildingRequirements.resourcesink) {
+      console.log('New Sink needed!')
+
+      props.factory.buildingRequirements.resourcesink = {
+        name: 'resourcesink',
+        amount,
+        powerPerBuilding: buildingPower,
+        totalPower: buildingPower * amount,
+      }
+    }
+
+    console.log('Added Building!')
+    console.log(props.factory.buildingRequirements.resourcesink)
+
+    console.log('hasSinks')
+    console.log(hasSinks.value)
+
+    updateFactory(props.factory)
+  }
+
 </script>

web/src/interfaces/DataInterface.ts

@@ -13,7 +13,7 @@ export interface RawResource {
 }
 
 export interface DataInterface {
-  buildings: { [key: string]: string };
+  buildings: { [key: string]: number };
   items: {
     parts: { [key: string]: Part };
     rawResources: { [key: string]: RawResource };

web/src/utils/factory-management/buildings.ts

@@ -53,6 +53,15 @@ export const calculateProductBuildings = (factory: Factory, gameData: DataInterf
   })
 }
 
+export const calculateBuildingsAndPower = (factory: Factory) => {
+  const sinkName = 'resourcesink'
+  const sinkAmount = factory.buildingRequirements[sinkName]?.amount
+  const sinkPower = factory.buildingRequirements[sinkName]?.powerPerBuilding
+
+  factory.totalPower = 0
+  factory.buildingRequirements = {} as {[key: string]: BuildingRequirement }
+}
+
 export const calculatePowerProducerBuildings = (factory: Factory, gameData: DataInterface) => {
   // Loop through each power producer and add up the buildings
   factory.powerProducers.forEach(producer => {
@@ -80,6 +89,18 @@ export const calculatePowerProducerBuildings = (factory: Factory, gameData: Data
     facBuilding.amount = facBuilding.amount + Math.ceil(producer.buildingCount) // Total buildings regardless of clocks
     facBuilding.powerProduced = Number(powerProduced.toFixed(3)) // Fucky wuky floating point numbers
   })
+
+  // Special case for 'Sinks' that aren't used in a recipe/product. They are only added manually by the user
+  if (!sinkAmount || sinkAmount <= 0) return
+  factory.buildingRequirements[sinkName] = {
+    name: sinkName,
+    amount: sinkAmount,
+    powerPerBuilding: sinkPower,
+    totalPower: sinkPower * sinkAmount,
+  }
+
+  // Sum adding the Sink
+  factory.totalPower = factory.totalPower + (sinkPower * sinkAmount)
 }
 
 // Sums up all of the building data to create an aggregate value of power and building requirements