From b2546817f67806304e4a33b0474657b401dc6229 Mon Sep 17 00:00:00 2001 From: MrQuentinet <32539717+mrquentin@users.noreply.github.com> Date: Fri, 6 Feb 2026 16:20:36 -0500 Subject: [PATCH 1/3] Implement wireless computation --- .../cosmiccore/blockstates/star_ladder.json | 71 +++++- .../wireless_computation_hatch.json | 28 +++ .../wireless_computation_transmitter.json | 76 ++++++ .../assets/cosmiccore/lang/en_ud.json | 14 ++ .../assets/cosmiccore/lang/en_us.json | 14 ++ .../machine/wireless_computation_hatch.json | 32 +++ .../wireless_computation_transmitter.json | 90 +++++++ .../item/wireless_computation_hatch.json | 3 + .../wireless_computation_transmitter.json | 3 + .../common/data/CosmicMachines.java | 39 +++ .../common/data/lang/CosmicLangHandler.java | 20 ++ ...WirelessComputationTransmitterMachine.java | 211 +++++++++++++++++ .../part/WirelessComputationHatchMachine.java | 224 ++++++++++++++++++ .../GlobalWirelessVariableStorage.java | 3 + .../wireless/WirelessComputationStore.java | 149 ++++++++++++ .../mixin/accessor/RecipeLogicAccessor.java | 16 ++ .../part/wireless_computation_hatch.json | 6 + src/main/resources/cosmiccore.mixins.json | 1 + 18 files changed, 999 insertions(+), 1 deletion(-) create mode 100644 src/generated/resources/assets/cosmiccore/blockstates/wireless_computation_hatch.json create mode 100644 src/generated/resources/assets/cosmiccore/blockstates/wireless_computation_transmitter.json create mode 100644 src/generated/resources/assets/cosmiccore/models/block/machine/wireless_computation_hatch.json create mode 100644 src/generated/resources/assets/cosmiccore/models/block/machine/wireless_computation_transmitter.json create mode 100644 src/generated/resources/assets/cosmiccore/models/item/wireless_computation_hatch.json create mode 100644 src/generated/resources/assets/cosmiccore/models/item/wireless_computation_transmitter.json create mode 100644 src/main/java/com/ghostipedia/cosmiccore/common/machine/multiblock/multi/WirelessComputationTransmitterMachine.java create mode 100644 src/main/java/com/ghostipedia/cosmiccore/common/machine/multiblock/part/WirelessComputationHatchMachine.java create mode 100644 src/main/java/com/ghostipedia/cosmiccore/common/wireless/WirelessComputationStore.java create mode 100644 src/main/java/com/ghostipedia/cosmiccore/mixin/accessor/RecipeLogicAccessor.java create mode 100644 src/main/resources/assets/cosmiccore/models/block/machine/part/wireless_computation_hatch.json diff --git a/src/generated/resources/assets/cosmiccore/blockstates/star_ladder.json b/src/generated/resources/assets/cosmiccore/blockstates/star_ladder.json index e1e4793e5..ad9a7da96 100644 --- a/src/generated/resources/assets/cosmiccore/blockstates/star_ladder.json +++ b/src/generated/resources/assets/cosmiccore/blockstates/star_ladder.json @@ -1,7 +1,76 @@ { "variants": { - "": { + "facing=east,upwards_facing=east": { + "gtceu:z": 270, + "model": "cosmiccore:block/machine/star_ladder", + "y": 90 + }, + "facing=east,upwards_facing=north": { + "model": "cosmiccore:block/machine/star_ladder", + "y": 90 + }, + "facing=east,upwards_facing=south": { + "gtceu:z": 180, + "model": "cosmiccore:block/machine/star_ladder", + "y": 90 + }, + "facing=east,upwards_facing=west": { + "gtceu:z": 90, + "model": "cosmiccore:block/machine/star_ladder", + "y": 90 + }, + "facing=north,upwards_facing=east": { + "gtceu:z": 270, "model": "cosmiccore:block/machine/star_ladder" + }, + "facing=north,upwards_facing=north": { + "model": "cosmiccore:block/machine/star_ladder" + }, + "facing=north,upwards_facing=south": { + "gtceu:z": 180, + "model": "cosmiccore:block/machine/star_ladder" + }, + "facing=north,upwards_facing=west": { + "gtceu:z": 90, + "model": "cosmiccore:block/machine/star_ladder" + }, + "facing=south,upwards_facing=east": { + "gtceu:z": 270, + "model": "cosmiccore:block/machine/star_ladder", + "y": 180 + }, + "facing=south,upwards_facing=north": { + "model": "cosmiccore:block/machine/star_ladder", + "y": 180 + }, + "facing=south,upwards_facing=south": { + "gtceu:z": 180, + "model": "cosmiccore:block/machine/star_ladder", + "y": 180 + }, + "facing=south,upwards_facing=west": { + "gtceu:z": 90, + "model": "cosmiccore:block/machine/star_ladder", + "y": 180 + }, + "facing=west,upwards_facing=east": { + "gtceu:z": 270, + "model": "cosmiccore:block/machine/star_ladder", + "y": 270 + }, + "facing=west,upwards_facing=north": { + "model": "cosmiccore:block/machine/star_ladder", + "y": 270 + }, + "facing=west,upwards_facing=south": { + "gtceu:z": 180, + "model": "cosmiccore:block/machine/star_ladder", + "y": 270 + }, + "facing=west,upwards_facing=west": { + "gtceu:z": 90, + "model": "cosmiccore:block/machine/star_ladder", + "y": 270 } } } \ No newline at end of file diff --git a/src/generated/resources/assets/cosmiccore/blockstates/wireless_computation_hatch.json b/src/generated/resources/assets/cosmiccore/blockstates/wireless_computation_hatch.json new file mode 100644 index 000000000..de587c2ed --- /dev/null +++ b/src/generated/resources/assets/cosmiccore/blockstates/wireless_computation_hatch.json @@ -0,0 +1,28 @@ +{ + "variants": { + "facing=down": { + "model": "cosmiccore:block/machine/wireless_computation_hatch", + "x": 90 + }, + "facing=east": { + "model": "cosmiccore:block/machine/wireless_computation_hatch", + "y": 90 + }, + "facing=north": { + "model": "cosmiccore:block/machine/wireless_computation_hatch" + }, + "facing=south": { + "model": "cosmiccore:block/machine/wireless_computation_hatch", + "y": 180 + }, + "facing=up": { + "gtceu:z": 180, + "model": "cosmiccore:block/machine/wireless_computation_hatch", + "x": 270 + }, + "facing=west": { + "model": "cosmiccore:block/machine/wireless_computation_hatch", + "y": 270 + } + } +} \ No newline at end of file diff --git a/src/generated/resources/assets/cosmiccore/blockstates/wireless_computation_transmitter.json b/src/generated/resources/assets/cosmiccore/blockstates/wireless_computation_transmitter.json new file mode 100644 index 000000000..2eb8e7e44 --- /dev/null +++ b/src/generated/resources/assets/cosmiccore/blockstates/wireless_computation_transmitter.json @@ -0,0 +1,76 @@ +{ + "variants": { + "facing=east,upwards_facing=east": { + "gtceu:z": 270, + "model": "cosmiccore:block/machine/wireless_computation_transmitter", + "y": 90 + }, + "facing=east,upwards_facing=north": { + "model": "cosmiccore:block/machine/wireless_computation_transmitter", + "y": 90 + }, + "facing=east,upwards_facing=south": { + "gtceu:z": 180, + "model": "cosmiccore:block/machine/wireless_computation_transmitter", + "y": 90 + }, + "facing=east,upwards_facing=west": { + "gtceu:z": 90, + "model": "cosmiccore:block/machine/wireless_computation_transmitter", + "y": 90 + }, + "facing=north,upwards_facing=east": { + "gtceu:z": 270, + "model": "cosmiccore:block/machine/wireless_computation_transmitter" + }, + "facing=north,upwards_facing=north": { + "model": "cosmiccore:block/machine/wireless_computation_transmitter" + }, + "facing=north,upwards_facing=south": { + "gtceu:z": 180, + "model": "cosmiccore:block/machine/wireless_computation_transmitter" + }, + "facing=north,upwards_facing=west": { + "gtceu:z": 90, + "model": "cosmiccore:block/machine/wireless_computation_transmitter" + }, + "facing=south,upwards_facing=east": { + "gtceu:z": 270, + "model": "cosmiccore:block/machine/wireless_computation_transmitter", + "y": 180 + }, + "facing=south,upwards_facing=north": { + "model": "cosmiccore:block/machine/wireless_computation_transmitter", + "y": 180 + }, + "facing=south,upwards_facing=south": { + "gtceu:z": 180, + "model": "cosmiccore:block/machine/wireless_computation_transmitter", + "y": 180 + }, + "facing=south,upwards_facing=west": { + "gtceu:z": 90, + "model": "cosmiccore:block/machine/wireless_computation_transmitter", + "y": 180 + }, + "facing=west,upwards_facing=east": { + "gtceu:z": 270, + "model": "cosmiccore:block/machine/wireless_computation_transmitter", + "y": 270 + }, + "facing=west,upwards_facing=north": { + "model": "cosmiccore:block/machine/wireless_computation_transmitter", + "y": 270 + }, + "facing=west,upwards_facing=south": { + "gtceu:z": 180, + "model": "cosmiccore:block/machine/wireless_computation_transmitter", + "y": 270 + }, + "facing=west,upwards_facing=west": { + "gtceu:z": 90, + "model": "cosmiccore:block/machine/wireless_computation_transmitter", + "y": 270 + } + } +} \ No newline at end of file diff --git a/src/generated/resources/assets/cosmiccore/lang/en_ud.json b/src/generated/resources/assets/cosmiccore/lang/en_ud.json index 913e3d609..60666bdd7 100644 --- a/src/generated/resources/assets/cosmiccore/lang/en_ud.json +++ b/src/generated/resources/assets/cosmiccore/lang/en_ud.json @@ -449,6 +449,8 @@ "block.cosmiccore.wailing_ichor_casing": "buısɐƆ ɹoɥɔI buıןıɐM", "block.cosmiccore.wasp": "]ԀSⱯM[ ɯɹoɟʇɐןԀ uoıʇɐɹɐdǝS pıoɹǝʇsⱯ ǝpıM", "block.cosmiccore.wear_resistant_ruridit_casing": "buısɐƆ ʇıpıɹnᴚ ʇuɐʇsısǝᴚ ɹɐǝM", + "block.cosmiccore.wireless_computation_hatch": "ɥɔʇɐH uoıʇɐʇndɯoƆ ssǝןǝɹıM", + "block.cosmiccore.wireless_computation_transmitter": "ɹǝʇʇıɯsuɐɹ⟘ uoıʇɐʇndɯoƆ ssǝןǝɹıM", "block.cosmiccore.wireless_data_hatch": "ɥɔʇɐH ɐʇɐᗡ ssǝןǝɹıM", "block.cosmiccore.wireless_data_transmitter": "ɹǝʇʇıɯsuɐɹ⟘ ɐʇɐᗡ ssǝןǝɹıM", "block.cosmiccore.zblan_glass": "ssɐן⅁ uɐןqZ", @@ -662,6 +664,10 @@ "cosmiccore.machine.ore_extraction_drill.tooltip.1": ")uoıʇɔɐɹʇxǝ ɹǝd ǝɹo ǝʇǝןdǝp oʇ ǝɔuɐɥɔ(ɟ§ %sǝ§ :ǝɔuɐɥƆ ןɐʌoɯǝᴚɟ§", "cosmiccore.machine.ore_extraction_drill.tooltip.2": ")ǝɹo ɹǝd suoıʇɔɐɹʇxǝ ǝbɐɹǝʌɐ(ɟ§ x%sɐ§ :pןǝıʎ ǝʌıʇɔǝɟɟƎɟ§", "cosmiccore.machine.ore_extraction_drill.tooltip.3": "ʇuǝsǝɹd sı ǝɹo ou ןıʇun unɹ ןןıʍ 'uoıʇǝןdɯoɔ ɹǝʇɟɐ uɐɔs ʇɹɐʇsǝɹ oʇ ɹǝʌıɹpʍǝɹɔs ǝs∩ㄥ§", + "cosmiccore.machine.wireless_computation_hatch.max_cwu": "%d :ǝןqɐןıɐʌⱯ ʇ/∩MƆ xɐW", + "cosmiccore.machine.wireless_computation_hatch.providers": "%d :sɹǝpıʌoɹԀ ʞɹoʍʇǝN", + "cosmiccore.machine.wireless_computation_hatch.tooltip.0": "ʞɹoʍʇǝu s,ɯɐǝʇ ǝɥʇ ɯoɹɟ uoıʇɐʇndɯoɔ sǝʌıǝɔǝɹ ʎןssǝןǝɹıM", + "cosmiccore.machine.wireless_computation_hatch.tooltip.1": "sǝɥɔʇɐɥ uoıʇɐʇndɯoɔ pǝɹıʍ ɹoɟ ʇuǝɯǝɔɐןdǝɹ uı-doɹᗡ", "cosmiccore.mana_leaching_tub.desc": "0006 ɹǝʞɐoS ɐuɐW", "cosmiccore.multiblock.advanced.star_ladder_tier": "%sq§ :ɟ§sǝןnpoW ɥɔɹɐǝsǝᴚ xɐWɐ§ \n %sq§ :ɟ§ɹǝı⟘ ɹǝɥʇǝ⟘ pןOɹǝppɐꞀɹɐʇS ǝuıɥɐɯoΛɐ§", "cosmiccore.multiblock.booster_used": "%s :ɹǝʇsooᗺ", @@ -731,6 +737,14 @@ "cosmiccore.multiblock.stellar_module.power_failure": "¡ʎbɹǝuƎ ʇuǝıɔıɟɟnsuI - Ǝᴚ∩ꞀIⱯℲ ᴚƎMOԀן§ɔ§", "cosmiccore.multiblock.stellar_module.speed_bonus": "%sɐ§ :snuoᗺ pǝǝdSㄥ§", "cosmiccore.multiblock.stellar_module.stage": "%sǝ§ :ǝbɐʇS sıɹIㄥ§", + "cosmiccore.multiblock.wireless_computation_transmitter.cwu_usage": "ʇ/∩MƆ %d / %d :ǝbɐs∩ ∩MƆ", + "cosmiccore.multiblock.wireless_computation_transmitter.local_hatches": "%d :sǝɥɔʇɐH ɹǝʌıǝɔǝᴚ ןɐɔoꞀ", + "cosmiccore.multiblock.wireless_computation_transmitter.max_cwu": "%d :ʇ/∩MƆ xɐW", + "cosmiccore.multiblock.wireless_computation_transmitter.network_providers": "%d :sɹǝpıʌoɹԀ ʞɹoʍʇǝN", + "cosmiccore.multiblock.wireless_computation_transmitter.tooltip.0": "ʞɹoʍʇǝu s,ɯɐǝʇ ǝɥʇ oʇ ʎןssǝןǝɹıʍ uoıʇɐʇndɯoɔ sʇıɯsuɐɹ⟘", + "cosmiccore.multiblock.wireless_computation_transmitter.tooltip.1": "sǝɥɔʇɐH ɹǝʌıǝɔǝᴚ ɐıʌ sǝɔɹnos uoıʇɐʇndɯoɔ ʇɔǝuuoƆ", + "cosmiccore.multiblock.wireless_computation_transmitter.tooltip.2": "ɥɔʇɐɥ ɹǝʌıǝɔǝɹ ɹǝd ∩Ǝ ɹǝıʇ ΛnꞀ sǝɯnsuoƆ", + "cosmiccore.multiblock.wireless_computation_transmitter.transmitting": "uoıʇɐʇndɯoƆ buıʇʇıɯsuɐɹ⟘", "cosmiccore.omnia_circuit.ev": "˙ʇınɔɹıƆ ΛƎ ʎuɐ sɐ sʞɹoM9§", "cosmiccore.omnia_circuit.hv": "˙ʇınɔɹıƆ ΛH ʎuɐ sɐ sʞɹoM9§", "cosmiccore.omnia_circuit.iv": "˙ʇınɔɹıƆ ΛI ʎuɐ sɐ sʞɹoM9§", diff --git a/src/generated/resources/assets/cosmiccore/lang/en_us.json b/src/generated/resources/assets/cosmiccore/lang/en_us.json index 44f5dc257..be9b3b994 100644 --- a/src/generated/resources/assets/cosmiccore/lang/en_us.json +++ b/src/generated/resources/assets/cosmiccore/lang/en_us.json @@ -449,6 +449,8 @@ "block.cosmiccore.wailing_ichor_casing": "Wailing Ichor Casing", "block.cosmiccore.wasp": "Wide Asteroid Separation Platform [WASP]", "block.cosmiccore.wear_resistant_ruridit_casing": "Wear Resistant Ruridit Casing", + "block.cosmiccore.wireless_computation_hatch": "Wireless Computation Hatch", + "block.cosmiccore.wireless_computation_transmitter": "Wireless Computation Transmitter", "block.cosmiccore.wireless_data_hatch": "Wireless Data Hatch", "block.cosmiccore.wireless_data_transmitter": "Wireless Data Transmitter", "block.cosmiccore.zblan_glass": "Zblan Glass", @@ -662,6 +664,10 @@ "cosmiccore.machine.ore_extraction_drill.tooltip.1": "§fRemoval Chance: §e%s §f(chance to deplete ore per extraction)", "cosmiccore.machine.ore_extraction_drill.tooltip.2": "§fEffective Yield: §a%sx §f(average extractions per ore)", "cosmiccore.machine.ore_extraction_drill.tooltip.3": "§7Use screwdriver to restart scan after completion, will run until no ore is present", + "cosmiccore.machine.wireless_computation_hatch.max_cwu": "Max CWU/t Available: %d", + "cosmiccore.machine.wireless_computation_hatch.providers": "Network Providers: %d", + "cosmiccore.machine.wireless_computation_hatch.tooltip.0": "Wirelessly receives computation from the team's network", + "cosmiccore.machine.wireless_computation_hatch.tooltip.1": "Drop-in replacement for wired computation hatches", "cosmiccore.mana_leaching_tub.desc": "Mana Soaker 9000", "cosmiccore.multiblock.advanced.star_ladder_tier": "§aVomahine StarLadderOld Tether Tier§f: §b%s \n §aMax Research Modules§f: §b%s", "cosmiccore.multiblock.booster_used": "Booster: %s", @@ -731,6 +737,14 @@ "cosmiccore.multiblock.stellar_module.power_failure": "§c§lPOWER FAILURE - Insufficient Energy!", "cosmiccore.multiblock.stellar_module.speed_bonus": "§7Speed Bonus: §a%s", "cosmiccore.multiblock.stellar_module.stage": "§7Iris Stage: §e%s", + "cosmiccore.multiblock.wireless_computation_transmitter.cwu_usage": "CWU Usage: %d / %d CWU/t", + "cosmiccore.multiblock.wireless_computation_transmitter.local_hatches": "Local Receiver Hatches: %d", + "cosmiccore.multiblock.wireless_computation_transmitter.max_cwu": "Max CWU/t: %d", + "cosmiccore.multiblock.wireless_computation_transmitter.network_providers": "Network Providers: %d", + "cosmiccore.multiblock.wireless_computation_transmitter.tooltip.0": "Transmits computation wirelessly to the team's network", + "cosmiccore.multiblock.wireless_computation_transmitter.tooltip.1": "Connect computation sources via Receiver Hatches", + "cosmiccore.multiblock.wireless_computation_transmitter.tooltip.2": "Consumes LuV tier EU per receiver hatch", + "cosmiccore.multiblock.wireless_computation_transmitter.transmitting": "Transmitting Computation", "cosmiccore.omnia_circuit.ev": "§6Works as any EV Circuit.", "cosmiccore.omnia_circuit.hv": "§6Works as any HV Circuit.", "cosmiccore.omnia_circuit.iv": "§6Works as any IV Circuit.", diff --git a/src/generated/resources/assets/cosmiccore/models/block/machine/wireless_computation_hatch.json b/src/generated/resources/assets/cosmiccore/models/block/machine/wireless_computation_hatch.json new file mode 100644 index 000000000..bf55cad9c --- /dev/null +++ b/src/generated/resources/assets/cosmiccore/models/block/machine/wireless_computation_hatch.json @@ -0,0 +1,32 @@ +{ + "parent": "minecraft:block/block", + "loader": "gtceu:machine", + "machine": "cosmiccore:wireless_computation_hatch", + "replaceable_textures": [ + "bottom", + "top", + "side" + ], + "variants": { + "is_formed=false": { + "model": { + "parent": "cosmiccore:block/machine/part/wireless_computation_hatch", + "textures": { + "bottom": "gtceu:block/casings/voltage/uev/bottom", + "side": "gtceu:block/casings/voltage/uev/side", + "top": "gtceu:block/casings/voltage/uev/top" + } + } + }, + "is_formed=true": { + "model": { + "parent": "cosmiccore:block/machine/part/wireless_computation_hatch", + "textures": { + "bottom": "gtceu:block/casings/voltage/uev/bottom", + "side": "gtceu:block/casings/voltage/uev/side", + "top": "gtceu:block/casings/voltage/uev/top" + } + } + } + } +} \ No newline at end of file diff --git a/src/generated/resources/assets/cosmiccore/models/block/machine/wireless_computation_transmitter.json b/src/generated/resources/assets/cosmiccore/models/block/machine/wireless_computation_transmitter.json new file mode 100644 index 000000000..5f54d19ff --- /dev/null +++ b/src/generated/resources/assets/cosmiccore/models/block/machine/wireless_computation_transmitter.json @@ -0,0 +1,90 @@ +{ + "parent": "minecraft:block/block", + "loader": "gtceu:machine", + "machine": "cosmiccore:wireless_computation_transmitter", + "texture_overrides": { + "all": "gtceu:block/casings/hpca/high_power_casing" + }, + "variants": { + "is_formed=false,recipe_logic_status=idle": { + "model": { + "parent": "gtceu:block/machine/template/cube_all/sided", + "textures": { + "all": "gtceu:block/casings/hpca/high_power_casing", + "overlay_front": "gtceu:block/multiblock/data_bank/overlay_front", + "overlay_front_emissive": "gtceu:block/multiblock/data_bank/overlay_front_emissive" + } + } + }, + "is_formed=false,recipe_logic_status=suspend": { + "model": { + "parent": "gtceu:block/machine/template/cube_all/sided", + "textures": { + "all": "gtceu:block/casings/hpca/high_power_casing", + "overlay_front": "gtceu:block/multiblock/data_bank/overlay_front", + "overlay_front_emissive": "gtceu:block/multiblock/data_bank/overlay_front_emissive" + } + } + }, + "is_formed=false,recipe_logic_status=waiting": { + "model": { + "parent": "gtceu:block/machine/template/cube_all/sided", + "textures": { + "all": "gtceu:block/casings/hpca/high_power_casing", + "overlay_front": "gtceu:block/multiblock/data_bank/overlay_front_active", + "overlay_front_emissive": "gtceu:block/multiblock/data_bank/overlay_front_active_emissive" + } + } + }, + "is_formed=false,recipe_logic_status=working": { + "model": { + "parent": "gtceu:block/machine/template/cube_all/sided", + "textures": { + "all": "gtceu:block/casings/hpca/high_power_casing", + "overlay_front": "gtceu:block/multiblock/data_bank/overlay_front_active", + "overlay_front_emissive": "gtceu:block/multiblock/data_bank/overlay_front_active_emissive" + } + } + }, + "is_formed=true,recipe_logic_status=idle": { + "model": { + "parent": "gtceu:block/machine/template/cube_all/sided", + "textures": { + "all": "gtceu:block/casings/hpca/high_power_casing", + "overlay_front": "gtceu:block/multiblock/data_bank/overlay_front", + "overlay_front_emissive": "gtceu:block/multiblock/data_bank/overlay_front_emissive" + } + } + }, + "is_formed=true,recipe_logic_status=suspend": { + "model": { + "parent": "gtceu:block/machine/template/cube_all/sided", + "textures": { + "all": "gtceu:block/casings/hpca/high_power_casing", + "overlay_front": "gtceu:block/multiblock/data_bank/overlay_front", + "overlay_front_emissive": "gtceu:block/multiblock/data_bank/overlay_front_emissive" + } + } + }, + "is_formed=true,recipe_logic_status=waiting": { + "model": { + "parent": "gtceu:block/machine/template/cube_all/sided", + "textures": { + "all": "gtceu:block/casings/hpca/high_power_casing", + "overlay_front": "gtceu:block/multiblock/data_bank/overlay_front_active", + "overlay_front_emissive": "gtceu:block/multiblock/data_bank/overlay_front_active_emissive" + } + } + }, + "is_formed=true,recipe_logic_status=working": { + "model": { + "parent": "gtceu:block/machine/template/cube_all/sided", + "textures": { + "all": "gtceu:block/casings/hpca/high_power_casing", + "overlay_front": "gtceu:block/multiblock/data_bank/overlay_front_active", + "overlay_front_emissive": "gtceu:block/multiblock/data_bank/overlay_front_active_emissive" + } + } + } + } +} \ No newline at end of file diff --git a/src/generated/resources/assets/cosmiccore/models/item/wireless_computation_hatch.json b/src/generated/resources/assets/cosmiccore/models/item/wireless_computation_hatch.json new file mode 100644 index 000000000..f712c4a0c --- /dev/null +++ b/src/generated/resources/assets/cosmiccore/models/item/wireless_computation_hatch.json @@ -0,0 +1,3 @@ +{ + "parent": "cosmiccore:block/machine/wireless_computation_hatch" +} \ No newline at end of file diff --git a/src/generated/resources/assets/cosmiccore/models/item/wireless_computation_transmitter.json b/src/generated/resources/assets/cosmiccore/models/item/wireless_computation_transmitter.json new file mode 100644 index 000000000..14fc8407d --- /dev/null +++ b/src/generated/resources/assets/cosmiccore/models/item/wireless_computation_transmitter.json @@ -0,0 +1,3 @@ +{ + "parent": "cosmiccore:block/machine/wireless_computation_transmitter" +} \ No newline at end of file diff --git a/src/main/java/com/ghostipedia/cosmiccore/common/data/CosmicMachines.java b/src/main/java/com/ghostipedia/cosmiccore/common/data/CosmicMachines.java index 68ac3aef5..11d5d649c 100644 --- a/src/main/java/com/ghostipedia/cosmiccore/common/data/CosmicMachines.java +++ b/src/main/java/com/ghostipedia/cosmiccore/common/data/CosmicMachines.java @@ -16,6 +16,7 @@ import com.ghostipedia.cosmiccore.common.machine.IndustrialApiaryMachine; import com.ghostipedia.cosmiccore.common.machine.WirelessChargerMachine; import com.ghostipedia.cosmiccore.common.machine.multiblock.electric.hpca.HPCAMachine; +import com.ghostipedia.cosmiccore.common.machine.multiblock.multi.WirelessComputationTransmitterMachine; import com.ghostipedia.cosmiccore.common.machine.multiblock.multi.WirelessDataBankMachine; import com.ghostipedia.cosmiccore.common.machine.multiblock.multi.bee.AlvearyModifierType; import com.ghostipedia.cosmiccore.common.machine.multiblock.part.*; @@ -873,6 +874,44 @@ private static MachineDefinition[] registerTieredMachines(String name, .overlayTieredHullModel("wireless_data_hatch") .register(); + public static final MachineDefinition WIRELESS_COMPUTATION_HATCH = REGISTRATE + .machine("wireless_computation_hatch", WirelessComputationHatchMachine::new) + .langValue("Wireless Computation Hatch") + .rotationState(RotationState.ALL) + .abilities(PartAbility.COMPUTATION_DATA_RECEPTION) + .modelProperty(GTMachineModelProperties.IS_FORMED, false) + .tier(UEV) + .overlayTieredHullModel("wireless_computation_hatch") + .tooltips( + Component.translatable("cosmiccore.machine.wireless_computation_hatch.tooltip.0"), + Component.translatable("cosmiccore.machine.wireless_computation_hatch.tooltip.1")) + .register(); + + public static final MultiblockMachineDefinition WIRELESS_COMPUTATION_TRANSMITTER = REGISTRATE + .multiblock("wireless_computation_transmitter", WirelessComputationTransmitterMachine::new) + .langValue("Wireless Computation Transmitter") + .rotationState(RotationState.NON_Y_AXIS) + .appearanceBlock(COMPUTER_CASING) + .recipeType(GTRecipeTypes.DUMMY_RECIPES) + .tooltips( + Component.translatable("cosmiccore.multiblock.wireless_computation_transmitter.tooltip.0"), + Component.translatable("cosmiccore.multiblock.wireless_computation_transmitter.tooltip.1"), + Component.translatable("cosmiccore.multiblock.wireless_computation_transmitter.tooltip.2")) + .pattern(definition -> FactoryBlockPattern.start() + .aisle("CCC", "CCC", "CCC") + .aisle("CCC", "CAC", "CCC") + .aisle("CCC", "CSC", "CCC") + .where('S', controller(blocks(definition.getBlock()))) + .where('A', blocks(ADVANCED_COMPUTER_CASING.get())) + .where('C', blocks(COMPUTER_CASING.get()).setMinGlobalLimited(12) + .or(abilities(PartAbility.INPUT_ENERGY).setMinGlobalLimited(1).setMaxGlobalLimited(2)) + .or(abilities(PartAbility.COMPUTATION_DATA_RECEPTION).setMinGlobalLimited(1)) + .or(abilities(PartAbility.MAINTENANCE).setExactLimit(1))) + .build()) + .workableCasingModel(GTCEu.id("block/casings/hpca/high_power_casing"), + GTCEu.id("block/multiblock/data_bank")) + .register(); + public static final MachineDefinition DRONE_MAINTENANCE_INTERFACE = REGISTRATE .machine("drone_maintenance_interface", (blockEntity) -> new DroneMaintenanceInterfacePartMachine(blockEntity)) diff --git a/src/main/java/com/ghostipedia/cosmiccore/common/data/lang/CosmicLangHandler.java b/src/main/java/com/ghostipedia/cosmiccore/common/data/lang/CosmicLangHandler.java index 9dcc34cc1..ad1dd7579 100644 --- a/src/main/java/com/ghostipedia/cosmiccore/common/data/lang/CosmicLangHandler.java +++ b/src/main/java/com/ghostipedia/cosmiccore/common/data/lang/CosmicLangHandler.java @@ -362,6 +362,26 @@ public static void init(RegistrateLangProvider provider) { provider.add("cosmiccore.wireless_charger.enter_range", "You have entered charging range [Range - %s blocks]"); provider.add("cosmiccore.wireless_charger.left_range", "You have left charging range [Range - %s blocks]"); + + // Wireless Computation + provider.add("cosmiccore.machine.wireless_computation_hatch.tooltip.0", + "Wirelessly receives computation from the team's network"); + provider.add("cosmiccore.machine.wireless_computation_hatch.tooltip.1", + "Drop-in replacement for wired computation hatches"); + provider.add("cosmiccore.machine.wireless_computation_hatch.providers", "Network Providers: %d"); + provider.add("cosmiccore.machine.wireless_computation_hatch.max_cwu", "Max CWU/t Available: %d"); + provider.add("cosmiccore.multiblock.wireless_computation_transmitter.tooltip.0", + "Transmits computation wirelessly to the team's network"); + provider.add("cosmiccore.multiblock.wireless_computation_transmitter.tooltip.1", + "Connect computation sources via Receiver Hatches"); + provider.add("cosmiccore.multiblock.wireless_computation_transmitter.tooltip.2", + "Consumes LuV tier EU per receiver hatch"); + provider.add("cosmiccore.multiblock.wireless_computation_transmitter.transmitting", "Transmitting Computation"); + provider.add("cosmiccore.multiblock.wireless_computation_transmitter.local_hatches", "Local Receiver Hatches: %d"); + provider.add("cosmiccore.multiblock.wireless_computation_transmitter.network_providers", "Network Providers: %d"); + provider.add("cosmiccore.multiblock.wireless_computation_transmitter.max_cwu", "Max CWU/t: %d"); + provider.add("cosmiccore.multiblock.wireless_computation_transmitter.cwu_usage", "CWU Usage: %d / %d CWU/t"); + provider.add("cosmiccore.circuit.lore.tier.max.0", "MAX Tier Circuit"); provider.add("cosmiccore.circuit.lore.tier.max.1", "Not a processor- but an Obituary."); provider.add("cosmiccore.circuit.lore.tier.max.2", "Input: Existence."); diff --git a/src/main/java/com/ghostipedia/cosmiccore/common/machine/multiblock/multi/WirelessComputationTransmitterMachine.java b/src/main/java/com/ghostipedia/cosmiccore/common/machine/multiblock/multi/WirelessComputationTransmitterMachine.java new file mode 100644 index 000000000..5ed0d43a9 --- /dev/null +++ b/src/main/java/com/ghostipedia/cosmiccore/common/machine/multiblock/multi/WirelessComputationTransmitterMachine.java @@ -0,0 +1,211 @@ +package com.ghostipedia.cosmiccore.common.machine.multiblock.multi; + +import com.ghostipedia.cosmiccore.common.wireless.WirelessComputationStore; +import com.ghostipedia.cosmiccore.utils.OwnershipUtils; + +import com.gregtechceu.gtceu.api.GTValues; +import com.gregtechceu.gtceu.api.capability.IControllable; +import com.gregtechceu.gtceu.api.capability.IEnergyContainer; +import com.gregtechceu.gtceu.api.capability.IOpticalComputationHatch; +import com.gregtechceu.gtceu.api.capability.recipe.CWURecipeCapability; +import com.gregtechceu.gtceu.api.capability.recipe.EURecipeCapability; +import com.gregtechceu.gtceu.api.capability.recipe.IO; +import com.gregtechceu.gtceu.api.machine.ConditionalSubscriptionHandler; +import com.gregtechceu.gtceu.api.machine.IMachineBlockEntity; +import com.gregtechceu.gtceu.api.machine.feature.IFancyUIMachine; +import com.gregtechceu.gtceu.api.machine.feature.multiblock.IDisplayUIMachine; +import com.gregtechceu.gtceu.api.machine.feature.multiblock.IMaintenanceMachine; +import com.gregtechceu.gtceu.api.machine.feature.multiblock.IMultiPart; +import com.gregtechceu.gtceu.api.machine.multiblock.MultiblockDisplayText; +import com.gregtechceu.gtceu.api.machine.multiblock.PartAbility; +import com.gregtechceu.gtceu.api.machine.multiblock.WorkableElectricMultiblockMachine; +import com.gregtechceu.gtceu.api.machine.trait.RecipeLogic; +import com.gregtechceu.gtceu.api.misc.EnergyContainerList; +import com.gregtechceu.gtceu.common.machine.owner.FTBOwner; +import com.gregtechceu.gtceu.config.ConfigHolder; + +import com.lowdragmc.lowdraglib.utils.DummyWorld; + +import net.minecraft.MethodsReturnNonnullByDefault; +import net.minecraft.network.chat.Component; +import net.minecraft.world.level.block.Block; + +import it.unimi.dsi.fastutil.longs.Long2ObjectMaps; + +import java.util.*; + +import javax.annotation.ParametersAreNonnullByDefault; + +/** + * Wireless Computation Transmitter multiblock. + * Aggregates computation from receiver hatches and makes it available wirelessly to the team's network. + */ +@MethodsReturnNonnullByDefault +@ParametersAreNonnullByDefault +public class WirelessComputationTransmitterMachine extends WorkableElectricMultiblockMachine + implements IFancyUIMachine, IDisplayUIMachine, IControllable { + + public static final int EUT_PER_HATCH = GTValues.VA[GTValues.LuV]; + + private IMaintenanceMachine maintenance; + private IEnergyContainer energyContainer; + private List computationHatches = new ArrayList<>(); + private boolean hatchesRegistered = false; + + private final ConditionalSubscriptionHandler tickSubscription; + + public WirelessComputationTransmitterMachine(IMachineBlockEntity holder) { + super(holder); + this.energyContainer = new EnergyContainerList(new ArrayList<>()); + this.tickSubscription = new ConditionalSubscriptionHandler(this, this::tick, this::isSubscriptionActive); + } + + protected UUID getTeamUUID() { + var owner = getOwner(); + if (owner == null) { + return getOwnerUUID(); + } + if (owner instanceof FTBOwner ftbOwner) { + var team = ftbOwner.getPlayerTeam(getOwnerUUID()); + return team != null ? team.getTeamId() : getOwnerUUID(); + } + return getOwnerUUID(); + } + + protected boolean isSubscriptionActive() { + return isFormed(); + } + + private void tick() { + if (isWorkingEnabled() && isFormed()) { + getRecipeLogic().setStatus(RecipeLogic.Status.WORKING); + energyContainer.removeEnergy(calculateEnergyUsage()); + + // Only register hatches when state changes to working + if (!hatchesRegistered) { + addHatchesToWirelessNetwork(); + hatchesRegistered = true; + } + } else { + // Only unregister hatches when state changes to not working + if (hatchesRegistered) { + removeHatchesFromWirelessNetwork(); + hatchesRegistered = false; + } + getRecipeLogic().setStatus(RecipeLogic.Status.SUSPEND); + } + } + + @Override + public void onStructureFormed() { + super.onStructureFormed(); + if (getLevel() instanceof DummyWorld) return; + + List energyContainers = new ArrayList<>(); + computationHatches = new ArrayList<>(); + Map ioMap = getMultiblockState().getMatchContext().getOrCreate("ioMap", Long2ObjectMaps::emptyMap); + + for (IMultiPart part : getParts()) { + IO io = ioMap.getOrDefault(part.self().getPos().asLong(), IO.BOTH); + + if (part instanceof IMaintenanceMachine maintenanceMachine) { + this.maintenance = maintenanceMachine; + } + + if (io == IO.NONE || io == IO.OUT) continue; + + // Collect energy containers + for (var handler : part.getRecipeHandlers()) { + var handlerIO = handler.getHandlerIO(); + if (io != IO.BOTH && handlerIO != IO.BOTH && io != handlerIO) continue; + if (handler.hasCapability(EURecipeCapability.CAP) && + handler instanceof IEnergyContainer container) { + energyContainers.add(container); + } + } + + // Collect computation hatches (receivers only) + Block block = part.self().getBlockState().getBlock(); + if (PartAbility.COMPUTATION_DATA_RECEPTION.isApplicable(block)) { + if (part instanceof IOpticalComputationHatch hatch) { + computationHatches.add(hatch); + } else { + var handlerLists = part.getRecipeHandlers(); + for (var handlerList : handlerLists) { + for (var cwu : handlerList.getCapability(CWURecipeCapability.CAP)) { + if (cwu instanceof IOpticalComputationHatch hatch) { + computationHatches.add(hatch); + } + } + } + } + } + } + + if (this.maintenance == null) { + onStructureInvalid(); + return; + } + + this.energyContainer = new EnergyContainerList(new ArrayList<>(energyContainers)); + this.hatchesRegistered = false; + + tickSubscription.updateSubscription(); + } + + @Override + public void onStructureInvalid() { + if (hatchesRegistered) { + removeHatchesFromWirelessNetwork(); + hatchesRegistered = false; + } + + super.onStructureInvalid(); + this.energyContainer = new EnergyContainerList(new ArrayList<>()); + this.computationHatches = new ArrayList<>(); + getRecipeLogic().setStatus(RecipeLogic.Status.SUSPEND); + tickSubscription.unsubscribe(); + } + + private int calculateEnergyUsage() { + int receivers = computationHatches.size(); + boolean hasMaintenance = ConfigHolder.INSTANCE.machines.enableMaintenance && this.maintenance != null; + var maintenanceMultiplier = hasMaintenance ? (1 + ((float) this.maintenance.getNumMaintenanceProblems() / 10)) : 1; + return (int) Math.floor(receivers * maintenanceMultiplier * EUT_PER_HATCH); + } + + private void addHatchesToWirelessNetwork() { + var uuid = getTeamUUID(); + com.ghostipedia.cosmiccore.CosmicCore.LOGGER.info("Adding {} computation hatches to wireless network for team {}", computationHatches.size(), uuid); + WirelessComputationStore.addHatches(uuid, computationHatches); + var store = WirelessComputationStore.getStore(uuid); + com.ghostipedia.cosmiccore.CosmicCore.LOGGER.info("Store now has {} providers, max CWU: {}", store.getProviderCount(), store.getMaxCWUt()); + } + + private void removeHatchesFromWirelessNetwork() { + WirelessComputationStore.removeHatches(getTeamUUID(), computationHatches); + } + + @Override + public void addDisplayText(List textList) { + var store = WirelessComputationStore.getStore(getTeamUUID()); + int allocatedCWU = store.getAllocatedCWUt(); + int maxCWU = store.getMaxCWUt(); + int totalProviders = store.getProviderCount(); + + MultiblockDisplayText.builder(textList, isFormed()) + .setWorkingStatus(true, isActive() && isWorkingEnabled()) + .setWorkingStatusKeys( + "gtceu.multiblock.idling", + "gtceu.multiblock.idling", + "cosmiccore.multiblock.wireless_computation_transmitter.transmitting") + .addEnergyUsageExactLine(calculateEnergyUsage()) + .addCustom(list -> { + list.add(Component.translatable("cosmiccore.multiblock.wireless_computation_transmitter.network_providers", totalProviders)); + list.add(Component.translatable("cosmiccore.multiblock.wireless_computation_transmitter.cwu_usage", allocatedCWU, maxCWU)); + }) + .addWorkingStatusLine() + .addEmptyLine() + .addCustom(list -> OwnershipUtils.addOwnerLine(list, getOwner(), true)); + } +} diff --git a/src/main/java/com/ghostipedia/cosmiccore/common/machine/multiblock/part/WirelessComputationHatchMachine.java b/src/main/java/com/ghostipedia/cosmiccore/common/machine/multiblock/part/WirelessComputationHatchMachine.java new file mode 100644 index 000000000..e1b9adbb5 --- /dev/null +++ b/src/main/java/com/ghostipedia/cosmiccore/common/machine/multiblock/part/WirelessComputationHatchMachine.java @@ -0,0 +1,224 @@ +package com.ghostipedia.cosmiccore.common.machine.multiblock.part; + +import com.ghostipedia.cosmiccore.common.wireless.WirelessComputationStore; +import com.ghostipedia.cosmiccore.mixin.accessor.RecipeLogicAccessor; +import com.ghostipedia.cosmiccore.utils.OwnershipUtils; + +import com.gregtechceu.gtceu.api.capability.IOpticalComputationHatch; +import com.gregtechceu.gtceu.api.capability.IOpticalComputationProvider; +import com.gregtechceu.gtceu.api.capability.IOpticalComputationReceiver; +import com.gregtechceu.gtceu.api.capability.recipe.CWURecipeCapability; +import com.gregtechceu.gtceu.api.capability.recipe.IO; +import com.gregtechceu.gtceu.api.capability.recipe.RecipeCapability; +import com.gregtechceu.gtceu.api.gui.GuiTextures; +import com.gregtechceu.gtceu.api.machine.IMachineBlockEntity; +import com.gregtechceu.gtceu.api.machine.feature.IRecipeLogicMachine; +import com.gregtechceu.gtceu.api.machine.feature.multiblock.IMultiController; +import com.gregtechceu.gtceu.api.machine.feature.multiblock.IMultiPart; +import com.gregtechceu.gtceu.api.machine.multiblock.MultiblockDisplayText; +import com.gregtechceu.gtceu.api.machine.multiblock.part.MultiblockPartMachine; +import com.gregtechceu.gtceu.api.machine.trait.NotifiableRecipeHandlerTrait; +import com.gregtechceu.gtceu.api.machine.trait.RecipeLogic; +import com.gregtechceu.gtceu.api.recipe.GTRecipe; +import com.gregtechceu.gtceu.common.machine.owner.FTBOwner; + +import com.lowdragmc.lowdraglib.gui.widget.*; + +import net.minecraft.MethodsReturnNonnullByDefault; +import net.minecraft.network.chat.Component; +import net.minecraft.world.InteractionHand; +import net.minecraft.world.entity.player.Player; +import net.minecraft.world.phys.BlockHitResult; + +import lombok.Getter; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import java.util.UUID; + +import javax.annotation.ParametersAreNonnullByDefault; + +/** + * Wireless computation hatch that routes computation requests to WirelessComputationStore. + * Acts as a drop-in replacement for wired computation hatches in consumer multiblocks. + */ +@MethodsReturnNonnullByDefault +@ParametersAreNonnullByDefault +public class WirelessComputationHatchMachine extends MultiblockPartMachine { + + protected final WirelessComputationContainer computationContainer; + + public WirelessComputationHatchMachine(IMachineBlockEntity holder) { + super(holder); + this.computationContainer = new WirelessComputationContainer(this); + } + + protected UUID getTeamUUID() { + var owner = getOwner(); + if (owner == null) { + return getOwnerUUID(); + } + if (owner instanceof FTBOwner ftbOwner) { + var team = ftbOwner.getPlayerTeam(getOwnerUUID()); + return team != null ? team.getTeamId() : getOwnerUUID(); + } + return getOwnerUUID(); + } + + @Override + public boolean shouldOpenUI(Player player, InteractionHand hand, BlockHitResult hit) { + return true; + } + + @Override + public boolean canShared() { + return false; + } + + @Override + public Widget createUIWidget() { + var group = new WidgetGroup(0, 0, 182 + 8, 117 + 8); + group.addWidget(new DraggableScrollableWidgetGroup(4, 4, 182, 117).setBackground(GuiTextures.DISPLAY) + .addWidget(new LabelWidget(4, 5, self().getBlockState().getBlock().getDescriptionId())) + .addWidget(new ComponentPanelWidget(4, 17, this::addDisplayText) + .textSupplier(this.getLevel().isClientSide ? null : this::addDisplayText) + .setMaxWidthLimit(200))); + group.setBackground(GuiTextures.BACKGROUND_INVERSE); + return group; + } + + public void addDisplayText(List textList) { + var store = WirelessComputationStore.getStore(getTeamUUID()); + int maxCWU = store.getMaxCWUt(); + int providerCount = store.getProviderCount(); + + MultiblockDisplayText.builder(textList, isFormed()) + .addCustom(list -> { + list.add(Component.translatable("cosmiccore.machine.wireless_computation_hatch.providers", providerCount)); + list.add(Component.translatable("cosmiccore.machine.wireless_computation_hatch.max_cwu", maxCWU)); + }) + .addCustom(list -> OwnershipUtils.addOwnerLine(list, getOwner(), true)); + } + + /** + * Custom computation container that routes requests to WirelessComputationStore. + */ + protected class WirelessComputationContainer extends NotifiableRecipeHandlerTrait + implements IOpticalComputationHatch, IOpticalComputationReceiver { + + @Getter + protected final IO handlerIO = IO.IN; + + protected long lastTimeStamp; + private int currentOutputCwu = 0, lastOutputCwu = 0; + + public WirelessComputationContainer(WirelessComputationHatchMachine machine) { + super(machine); + this.lastTimeStamp = Long.MIN_VALUE; + } + + @Override + public boolean isTransmitter() { + return false; // Acts as receiver - receives computation from wireless network + } + + @Override + public int requestCWUt(int cwut, boolean simulate, @NotNull Collection seen) { + var latestTimeStamp = getMachine().getOffsetTimer(); + if (lastTimeStamp < latestTimeStamp) { + lastOutputCwu = currentOutputCwu; + currentOutputCwu = 0; + lastTimeStamp = latestTimeStamp; + } + + seen.add(this); + + // Route to wireless computation store + var store = WirelessComputationStore.getStore(getTeamUUID()); + return store.requestCWUt(cwut, simulate, seen); + } + + @Override + public int getMaxCWUt(@NotNull Collection seen) { + seen.add(this); + var store = WirelessComputationStore.getStore(getTeamUUID()); + return store.getMaxCWUt(seen); + } + + @Override + public boolean canBridge(@NotNull Collection seen) { + seen.add(this); + var store = WirelessComputationStore.getStore(getTeamUUID()); + return store.canBridge(seen); + } + + @Override + public List handleRecipeInner(IO io, GTRecipe recipe, List left, boolean simulate) { + var teamUUID = getTeamUUID(); + var store = WirelessComputationStore.getStore(teamUUID); + + int sum = left.stream().mapToInt(Integer::intValue).sum(); + if (!simulate) { + com.ghostipedia.cosmiccore.CosmicCore.LOGGER.info("handleRecipeInner: io={}, sum={}, teamUUID={}, providers={}, maxCWU={}", + io, sum, teamUUID, store.getProviderCount(), store.getMaxCWUt()); + } + if (io == IO.IN) { + int availableCWUt = store.requestCWUt(Integer.MAX_VALUE, true); + if (availableCWUt >= sum) { + if (recipe.data.getBoolean("duration_is_total_cwu")) { + int drawn = store.requestCWUt(availableCWUt, simulate); + if (!simulate) { + if (machine instanceof IRecipeLogicMachine rlm) { + RecipeLogic logic = rlm.getRecipeLogic(); + RecipeLogicAccessor accessor = (RecipeLogicAccessor) logic; + accessor.setProgress(accessor.getProgress() - 1 + drawn); + } else if (machine instanceof IMultiPart multiPart) { + for (IMultiController controller : multiPart.getControllers()) { + if (controller instanceof IRecipeLogicMachine rlm) { + RecipeLogic logic = rlm.getRecipeLogic(); + RecipeLogicAccessor accessor = (RecipeLogicAccessor) logic; + accessor.setProgress(accessor.getProgress() - 1 + drawn); + } + } + } + } + sum -= drawn; + } else { + sum -= store.requestCWUt(sum, simulate); + } + } + } else if (io == IO.OUT) { + int canInput = this.getMaxCWUt() - this.lastOutputCwu; + if (!simulate) { + this.currentOutputCwu = Math.min(canInput, sum); + } + sum = sum - canInput; + } + return sum <= 0 ? null : Collections.singletonList(sum); + } + + @Override + public @NotNull List getContents() { + return List.of(lastOutputCwu); + } + + @Override + public double getTotalContentAmount() { + return lastOutputCwu; + } + + @Override + public RecipeCapability getCapability() { + return CWURecipeCapability.CAP; + } + + @Nullable + @Override + public IOpticalComputationProvider getComputationProvider() { + return WirelessComputationStore.getStore(getTeamUUID()); + } + } +} diff --git a/src/main/java/com/ghostipedia/cosmiccore/common/wireless/GlobalWirelessVariableStorage.java b/src/main/java/com/ghostipedia/cosmiccore/common/wireless/GlobalWirelessVariableStorage.java index 8b32b6c0f..375d51745 100644 --- a/src/main/java/com/ghostipedia/cosmiccore/common/wireless/GlobalWirelessVariableStorage.java +++ b/src/main/java/com/ghostipedia/cosmiccore/common/wireless/GlobalWirelessVariableStorage.java @@ -8,4 +8,7 @@ public abstract class GlobalWirelessVariableStorage { // Global wireless data stick map public static HashMap GlobalWirelessDataSticks = new HashMap<>(20, 0.9f); + + // Global wireless computation map + public static HashMap GlobalWirelessComputation = new HashMap<>(20, 0.9f); } diff --git a/src/main/java/com/ghostipedia/cosmiccore/common/wireless/WirelessComputationStore.java b/src/main/java/com/ghostipedia/cosmiccore/common/wireless/WirelessComputationStore.java new file mode 100644 index 000000000..80f7dea64 --- /dev/null +++ b/src/main/java/com/ghostipedia/cosmiccore/common/wireless/WirelessComputationStore.java @@ -0,0 +1,149 @@ +package com.ghostipedia.cosmiccore.common.wireless; + +import com.gregtechceu.gtceu.api.capability.IOpticalComputationHatch; +import com.gregtechceu.gtceu.api.capability.IOpticalComputationProvider; + +import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet; +import org.jetbrains.annotations.NotNull; + +import java.util.*; + +import static com.ghostipedia.cosmiccore.common.wireless.GlobalWirelessVariableStorage.GlobalWirelessComputation; + +/** + * In-memory store for wireless computation providers, keyed by Team UUID. + * Aggregates computation from all registered transmitter multiblocks for a team. + */ +public class WirelessComputationStore implements IOpticalComputationProvider { + + private final Set providers = new ObjectOpenHashSet<>(); + + // Per-tick saturation tracking to avoid redundant computation requests + private boolean tickSaturated; + private long timerCWUt = -1; + + // Track allocated CWU for display purposes + private int lastAllocatedCWUt = 0; + private int currentAllocatedCWUt = 0; + private long allocationTimer = -1; + + public void clearProviders() { + providers.clear(); + } + + public void addProviders(List hatches) { + providers.addAll(hatches); + } + + public void removeProviders(List hatches) { + hatches.forEach(providers::remove); + } + + public Set getProviders() { + return Collections.unmodifiableSet(providers); + } + + public int getProviderCount() { + return providers.size(); + } + + public int getAllocatedCWUt() { + return lastAllocatedCWUt; + } + + @Override + public int requestCWUt(int cwut, boolean simulate, @NotNull Collection seen) { + seen.add(this); + + if (cwut == 0) return 0; + + // Per-tick saturation check using game time + long currentTime = System.currentTimeMillis() / 50; // Approximate tick time + if (timerCWUt == currentTime) { + if (tickSaturated) { + return 0; + } + } else { + timerCWUt = currentTime; + tickSaturated = false; + } + + // Reset allocation tracking each tick + if (allocationTimer != currentTime) { + lastAllocatedCWUt = currentAllocatedCWUt; + currentAllocatedCWUt = 0; + allocationTimer = currentTime; + } + + Collection bridgeSeen = new ArrayList<>(seen); + int allocatedCWUt = 0; + + for (var provider : providers) { + if (!provider.canBridge(bridgeSeen)) continue; + int allocated = provider.requestCWUt(cwut, simulate, seen); + allocatedCWUt += allocated; + cwut -= allocated; + if (cwut == 0) break; + } + + if (!simulate) { + currentAllocatedCWUt += allocatedCWUt; + if (allocatedCWUt == 0) { + tickSaturated = true; + } + } + + return allocatedCWUt; + } + + @Override + public int getMaxCWUt(@NotNull Collection seen) { + seen.add(this); + + Collection bridgeSeen = new ArrayList<>(seen); + int maximumCWUt = 0; + + for (var provider : providers) { + boolean canBridge = provider.canBridge(bridgeSeen); + int providerCWU = canBridge ? provider.getMaxCWUt(seen) : 0; + com.ghostipedia.cosmiccore.CosmicCore.LOGGER.info("Provider {} (class={}) canBridge={} CWU={}", + provider, provider.getClass().getName(), canBridge, providerCWU); + if (!canBridge) continue; + maximumCWUt += providerCWU; + } + + com.ghostipedia.cosmiccore.CosmicCore.LOGGER.info("Total max CWU from {} providers: {}", providers.size(), maximumCWUt); + return maximumCWUt; + } + + @Override + public boolean canBridge(@NotNull Collection seen) { + seen.add(this); + + for (var provider : providers) { + if (provider.canBridge(seen)) { + return true; + } + } + return false; + } + + // Static access methods + + public static WirelessComputationStore getStore(UUID uuid) { + if (GlobalWirelessComputation.get(uuid) == null) { + GlobalWirelessComputation.put(uuid, new WirelessComputationStore()); + } + return GlobalWirelessComputation.get(uuid); + } + + public static void addHatches(UUID uuid, List hatches) { + var store = getStore(uuid); + store.addProviders(hatches); + } + + public static void removeHatches(UUID uuid, List hatches) { + var store = getStore(uuid); + store.removeProviders(hatches); + } +} diff --git a/src/main/java/com/ghostipedia/cosmiccore/mixin/accessor/RecipeLogicAccessor.java b/src/main/java/com/ghostipedia/cosmiccore/mixin/accessor/RecipeLogicAccessor.java new file mode 100644 index 000000000..71aedac88 --- /dev/null +++ b/src/main/java/com/ghostipedia/cosmiccore/mixin/accessor/RecipeLogicAccessor.java @@ -0,0 +1,16 @@ +package com.ghostipedia.cosmiccore.mixin.accessor; + +import com.gregtechceu.gtceu.api.machine.trait.RecipeLogic; + +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.gen.Accessor; + +@Mixin(RecipeLogic.class) +public interface RecipeLogicAccessor { + + @Accessor("progress") + int getProgress(); + + @Accessor("progress") + void setProgress(int progress); +} diff --git a/src/main/resources/assets/cosmiccore/models/block/machine/part/wireless_computation_hatch.json b/src/main/resources/assets/cosmiccore/models/block/machine/part/wireless_computation_hatch.json new file mode 100644 index 000000000..6ac2de691 --- /dev/null +++ b/src/main/resources/assets/cosmiccore/models/block/machine/part/wireless_computation_hatch.json @@ -0,0 +1,6 @@ +{ + "parent": "gtceu:block/overlay/front_emissive", + "textures": { + "overlay_emissive": "cosmiccore:block/overlay/wireless_data_hatch" + } +} diff --git a/src/main/resources/cosmiccore.mixins.json b/src/main/resources/cosmiccore.mixins.json index 0c2c7e7aa..a3b43fa54 100644 --- a/src/main/resources/cosmiccore.mixins.json +++ b/src/main/resources/cosmiccore.mixins.json @@ -44,6 +44,7 @@ "accessor.LivingEntityAccessor", "accessor.CubicSplineMultipointAccessor", "accessor.LootTableAccessor", + "accessor.RecipeLogicAccessor", "ae2.eudisplay.EUAddAppearanceMixin", "ae2.eudisplay.EUAddPowerUnitMixin", "ae2.eudisplay.EUAddSettingMixin", From 10f4e97649ce9795cd13f16d8deb375e69ea4ad3 Mon Sep 17 00:00:00 2001 From: MrQuentinet <32539717+mrquentin@users.noreply.github.com> Date: Fri, 6 Feb 2026 16:31:26 -0500 Subject: [PATCH 2/3] spotless --- .../common/data/lang/CosmicLangHandler.java | 6 ++++-- .../WirelessComputationTransmitterMachine.java | 18 ++++++++++++------ .../part/WirelessComputationHatchMachine.java | 10 ++++++---- .../wireless/WirelessComputationStore.java | 5 +++-- 4 files changed, 25 insertions(+), 14 deletions(-) diff --git a/src/main/java/com/ghostipedia/cosmiccore/common/data/lang/CosmicLangHandler.java b/src/main/java/com/ghostipedia/cosmiccore/common/data/lang/CosmicLangHandler.java index ad1dd7579..d0b1df8aa 100644 --- a/src/main/java/com/ghostipedia/cosmiccore/common/data/lang/CosmicLangHandler.java +++ b/src/main/java/com/ghostipedia/cosmiccore/common/data/lang/CosmicLangHandler.java @@ -377,8 +377,10 @@ public static void init(RegistrateLangProvider provider) { provider.add("cosmiccore.multiblock.wireless_computation_transmitter.tooltip.2", "Consumes LuV tier EU per receiver hatch"); provider.add("cosmiccore.multiblock.wireless_computation_transmitter.transmitting", "Transmitting Computation"); - provider.add("cosmiccore.multiblock.wireless_computation_transmitter.local_hatches", "Local Receiver Hatches: %d"); - provider.add("cosmiccore.multiblock.wireless_computation_transmitter.network_providers", "Network Providers: %d"); + provider.add("cosmiccore.multiblock.wireless_computation_transmitter.local_hatches", + "Local Receiver Hatches: %d"); + provider.add("cosmiccore.multiblock.wireless_computation_transmitter.network_providers", + "Network Providers: %d"); provider.add("cosmiccore.multiblock.wireless_computation_transmitter.max_cwu", "Max CWU/t: %d"); provider.add("cosmiccore.multiblock.wireless_computation_transmitter.cwu_usage", "CWU Usage: %d / %d CWU/t"); diff --git a/src/main/java/com/ghostipedia/cosmiccore/common/machine/multiblock/multi/WirelessComputationTransmitterMachine.java b/src/main/java/com/ghostipedia/cosmiccore/common/machine/multiblock/multi/WirelessComputationTransmitterMachine.java index 5ed0d43a9..067b9e649 100644 --- a/src/main/java/com/ghostipedia/cosmiccore/common/machine/multiblock/multi/WirelessComputationTransmitterMachine.java +++ b/src/main/java/com/ghostipedia/cosmiccore/common/machine/multiblock/multi/WirelessComputationTransmitterMachine.java @@ -43,7 +43,7 @@ @MethodsReturnNonnullByDefault @ParametersAreNonnullByDefault public class WirelessComputationTransmitterMachine extends WorkableElectricMultiblockMachine - implements IFancyUIMachine, IDisplayUIMachine, IControllable { + implements IFancyUIMachine, IDisplayUIMachine, IControllable { public static final int EUT_PER_HATCH = GTValues.VA[GTValues.LuV]; @@ -170,16 +170,19 @@ public void onStructureInvalid() { private int calculateEnergyUsage() { int receivers = computationHatches.size(); boolean hasMaintenance = ConfigHolder.INSTANCE.machines.enableMaintenance && this.maintenance != null; - var maintenanceMultiplier = hasMaintenance ? (1 + ((float) this.maintenance.getNumMaintenanceProblems() / 10)) : 1; + var maintenanceMultiplier = hasMaintenance ? (1 + ((float) this.maintenance.getNumMaintenanceProblems() / 10)) : + 1; return (int) Math.floor(receivers * maintenanceMultiplier * EUT_PER_HATCH); } private void addHatchesToWirelessNetwork() { var uuid = getTeamUUID(); - com.ghostipedia.cosmiccore.CosmicCore.LOGGER.info("Adding {} computation hatches to wireless network for team {}", computationHatches.size(), uuid); + com.ghostipedia.cosmiccore.CosmicCore.LOGGER + .info("Adding {} computation hatches to wireless network for team {}", computationHatches.size(), uuid); WirelessComputationStore.addHatches(uuid, computationHatches); var store = WirelessComputationStore.getStore(uuid); - com.ghostipedia.cosmiccore.CosmicCore.LOGGER.info("Store now has {} providers, max CWU: {}", store.getProviderCount(), store.getMaxCWUt()); + com.ghostipedia.cosmiccore.CosmicCore.LOGGER.info("Store now has {} providers, max CWU: {}", + store.getProviderCount(), store.getMaxCWUt()); } private void removeHatchesFromWirelessNetwork() { @@ -201,8 +204,11 @@ public void addDisplayText(List textList) { "cosmiccore.multiblock.wireless_computation_transmitter.transmitting") .addEnergyUsageExactLine(calculateEnergyUsage()) .addCustom(list -> { - list.add(Component.translatable("cosmiccore.multiblock.wireless_computation_transmitter.network_providers", totalProviders)); - list.add(Component.translatable("cosmiccore.multiblock.wireless_computation_transmitter.cwu_usage", allocatedCWU, maxCWU)); + list.add(Component.translatable( + "cosmiccore.multiblock.wireless_computation_transmitter.network_providers", + totalProviders)); + list.add(Component.translatable("cosmiccore.multiblock.wireless_computation_transmitter.cwu_usage", + allocatedCWU, maxCWU)); }) .addWorkingStatusLine() .addEmptyLine() diff --git a/src/main/java/com/ghostipedia/cosmiccore/common/machine/multiblock/part/WirelessComputationHatchMachine.java b/src/main/java/com/ghostipedia/cosmiccore/common/machine/multiblock/part/WirelessComputationHatchMachine.java index e1b9adbb5..ee9280f6b 100644 --- a/src/main/java/com/ghostipedia/cosmiccore/common/machine/multiblock/part/WirelessComputationHatchMachine.java +++ b/src/main/java/com/ghostipedia/cosmiccore/common/machine/multiblock/part/WirelessComputationHatchMachine.java @@ -97,7 +97,8 @@ public void addDisplayText(List textList) { MultiblockDisplayText.builder(textList, isFormed()) .addCustom(list -> { - list.add(Component.translatable("cosmiccore.machine.wireless_computation_hatch.providers", providerCount)); + list.add(Component.translatable("cosmiccore.machine.wireless_computation_hatch.providers", + providerCount)); list.add(Component.translatable("cosmiccore.machine.wireless_computation_hatch.max_cwu", maxCWU)); }) .addCustom(list -> OwnershipUtils.addOwnerLine(list, getOwner(), true)); @@ -107,7 +108,7 @@ public void addDisplayText(List textList) { * Custom computation container that routes requests to WirelessComputationStore. */ protected class WirelessComputationContainer extends NotifiableRecipeHandlerTrait - implements IOpticalComputationHatch, IOpticalComputationReceiver { + implements IOpticalComputationHatch, IOpticalComputationReceiver { @Getter protected final IO handlerIO = IO.IN; @@ -162,8 +163,9 @@ public List handleRecipeInner(IO io, GTRecipe recipe, List lef int sum = left.stream().mapToInt(Integer::intValue).sum(); if (!simulate) { - com.ghostipedia.cosmiccore.CosmicCore.LOGGER.info("handleRecipeInner: io={}, sum={}, teamUUID={}, providers={}, maxCWU={}", - io, sum, teamUUID, store.getProviderCount(), store.getMaxCWUt()); + com.ghostipedia.cosmiccore.CosmicCore.LOGGER.info( + "handleRecipeInner: io={}, sum={}, teamUUID={}, providers={}, maxCWU={}", + io, sum, teamUUID, store.getProviderCount(), store.getMaxCWUt()); } if (io == IO.IN) { int availableCWUt = store.requestCWUt(Integer.MAX_VALUE, true); diff --git a/src/main/java/com/ghostipedia/cosmiccore/common/wireless/WirelessComputationStore.java b/src/main/java/com/ghostipedia/cosmiccore/common/wireless/WirelessComputationStore.java index 80f7dea64..70878f680 100644 --- a/src/main/java/com/ghostipedia/cosmiccore/common/wireless/WirelessComputationStore.java +++ b/src/main/java/com/ghostipedia/cosmiccore/common/wireless/WirelessComputationStore.java @@ -107,12 +107,13 @@ public int getMaxCWUt(@NotNull Collection seen) { boolean canBridge = provider.canBridge(bridgeSeen); int providerCWU = canBridge ? provider.getMaxCWUt(seen) : 0; com.ghostipedia.cosmiccore.CosmicCore.LOGGER.info("Provider {} (class={}) canBridge={} CWU={}", - provider, provider.getClass().getName(), canBridge, providerCWU); + provider, provider.getClass().getName(), canBridge, providerCWU); if (!canBridge) continue; maximumCWUt += providerCWU; } - com.ghostipedia.cosmiccore.CosmicCore.LOGGER.info("Total max CWU from {} providers: {}", providers.size(), maximumCWUt); + com.ghostipedia.cosmiccore.CosmicCore.LOGGER.info("Total max CWU from {} providers: {}", providers.size(), + maximumCWUt); return maximumCWUt; } From 32d5c37cd4b0feb8df51973fa225a5897b957c38 Mon Sep 17 00:00:00 2001 From: MrQuentinet <32539717+mrquentin@users.noreply.github.com> Date: Sat, 7 Feb 2026 15:38:20 -0500 Subject: [PATCH 3/3] cleanup comments --- ...WirelessComputationTransmitterMachine.java | 16 +------------- .../part/WirelessComputationHatchMachine.java | 15 +------------ .../GlobalWirelessVariableStorage.java | 1 - .../wireless/WirelessComputationStore.java | 22 +++---------------- 4 files changed, 5 insertions(+), 49 deletions(-) diff --git a/src/main/java/com/ghostipedia/cosmiccore/common/machine/multiblock/multi/WirelessComputationTransmitterMachine.java b/src/main/java/com/ghostipedia/cosmiccore/common/machine/multiblock/multi/WirelessComputationTransmitterMachine.java index 067b9e649..56d2f2583 100644 --- a/src/main/java/com/ghostipedia/cosmiccore/common/machine/multiblock/multi/WirelessComputationTransmitterMachine.java +++ b/src/main/java/com/ghostipedia/cosmiccore/common/machine/multiblock/multi/WirelessComputationTransmitterMachine.java @@ -36,10 +36,6 @@ import javax.annotation.ParametersAreNonnullByDefault; -/** - * Wireless Computation Transmitter multiblock. - * Aggregates computation from receiver hatches and makes it available wirelessly to the team's network. - */ @MethodsReturnNonnullByDefault @ParametersAreNonnullByDefault public class WirelessComputationTransmitterMachine extends WorkableElectricMultiblockMachine @@ -81,13 +77,11 @@ private void tick() { getRecipeLogic().setStatus(RecipeLogic.Status.WORKING); energyContainer.removeEnergy(calculateEnergyUsage()); - // Only register hatches when state changes to working if (!hatchesRegistered) { addHatchesToWirelessNetwork(); hatchesRegistered = true; } } else { - // Only unregister hatches when state changes to not working if (hatchesRegistered) { removeHatchesFromWirelessNetwork(); hatchesRegistered = false; @@ -114,7 +108,6 @@ public void onStructureFormed() { if (io == IO.NONE || io == IO.OUT) continue; - // Collect energy containers for (var handler : part.getRecipeHandlers()) { var handlerIO = handler.getHandlerIO(); if (io != IO.BOTH && handlerIO != IO.BOTH && io != handlerIO) continue; @@ -124,7 +117,6 @@ public void onStructureFormed() { } } - // Collect computation hatches (receivers only) Block block = part.self().getBlockState().getBlock(); if (PartAbility.COMPUTATION_DATA_RECEPTION.isApplicable(block)) { if (part instanceof IOpticalComputationHatch hatch) { @@ -176,13 +168,7 @@ private int calculateEnergyUsage() { } private void addHatchesToWirelessNetwork() { - var uuid = getTeamUUID(); - com.ghostipedia.cosmiccore.CosmicCore.LOGGER - .info("Adding {} computation hatches to wireless network for team {}", computationHatches.size(), uuid); - WirelessComputationStore.addHatches(uuid, computationHatches); - var store = WirelessComputationStore.getStore(uuid); - com.ghostipedia.cosmiccore.CosmicCore.LOGGER.info("Store now has {} providers, max CWU: {}", - store.getProviderCount(), store.getMaxCWUt()); + WirelessComputationStore.addHatches(getTeamUUID(), computationHatches); } private void removeHatchesFromWirelessNetwork() { diff --git a/src/main/java/com/ghostipedia/cosmiccore/common/machine/multiblock/part/WirelessComputationHatchMachine.java b/src/main/java/com/ghostipedia/cosmiccore/common/machine/multiblock/part/WirelessComputationHatchMachine.java index ee9280f6b..f6fa2d46d 100644 --- a/src/main/java/com/ghostipedia/cosmiccore/common/machine/multiblock/part/WirelessComputationHatchMachine.java +++ b/src/main/java/com/ghostipedia/cosmiccore/common/machine/multiblock/part/WirelessComputationHatchMachine.java @@ -41,10 +41,6 @@ import javax.annotation.ParametersAreNonnullByDefault; -/** - * Wireless computation hatch that routes computation requests to WirelessComputationStore. - * Acts as a drop-in replacement for wired computation hatches in consumer multiblocks. - */ @MethodsReturnNonnullByDefault @ParametersAreNonnullByDefault public class WirelessComputationHatchMachine extends MultiblockPartMachine { @@ -104,9 +100,6 @@ public void addDisplayText(List textList) { .addCustom(list -> OwnershipUtils.addOwnerLine(list, getOwner(), true)); } - /** - * Custom computation container that routes requests to WirelessComputationStore. - */ protected class WirelessComputationContainer extends NotifiableRecipeHandlerTrait implements IOpticalComputationHatch, IOpticalComputationReceiver { @@ -123,7 +116,7 @@ public WirelessComputationContainer(WirelessComputationHatchMachine machine) { @Override public boolean isTransmitter() { - return false; // Acts as receiver - receives computation from wireless network + return false; } @Override @@ -137,7 +130,6 @@ public int requestCWUt(int cwut, boolean simulate, @NotNull Collection handleRecipeInner(IO io, GTRecipe recipe, List lef var store = WirelessComputationStore.getStore(teamUUID); int sum = left.stream().mapToInt(Integer::intValue).sum(); - if (!simulate) { - com.ghostipedia.cosmiccore.CosmicCore.LOGGER.info( - "handleRecipeInner: io={}, sum={}, teamUUID={}, providers={}, maxCWU={}", - io, sum, teamUUID, store.getProviderCount(), store.getMaxCWUt()); - } if (io == IO.IN) { int availableCWUt = store.requestCWUt(Integer.MAX_VALUE, true); if (availableCWUt >= sum) { diff --git a/src/main/java/com/ghostipedia/cosmiccore/common/wireless/GlobalWirelessVariableStorage.java b/src/main/java/com/ghostipedia/cosmiccore/common/wireless/GlobalWirelessVariableStorage.java index 375d51745..32e3252e7 100644 --- a/src/main/java/com/ghostipedia/cosmiccore/common/wireless/GlobalWirelessVariableStorage.java +++ b/src/main/java/com/ghostipedia/cosmiccore/common/wireless/GlobalWirelessVariableStorage.java @@ -9,6 +9,5 @@ public abstract class GlobalWirelessVariableStorage { // Global wireless data stick map public static HashMap GlobalWirelessDataSticks = new HashMap<>(20, 0.9f); - // Global wireless computation map public static HashMap GlobalWirelessComputation = new HashMap<>(20, 0.9f); } diff --git a/src/main/java/com/ghostipedia/cosmiccore/common/wireless/WirelessComputationStore.java b/src/main/java/com/ghostipedia/cosmiccore/common/wireless/WirelessComputationStore.java index 70878f680..6b030eaf0 100644 --- a/src/main/java/com/ghostipedia/cosmiccore/common/wireless/WirelessComputationStore.java +++ b/src/main/java/com/ghostipedia/cosmiccore/common/wireless/WirelessComputationStore.java @@ -10,19 +10,13 @@ import static com.ghostipedia.cosmiccore.common.wireless.GlobalWirelessVariableStorage.GlobalWirelessComputation; -/** - * In-memory store for wireless computation providers, keyed by Team UUID. - * Aggregates computation from all registered transmitter multiblocks for a team. - */ public class WirelessComputationStore implements IOpticalComputationProvider { private final Set providers = new ObjectOpenHashSet<>(); - // Per-tick saturation tracking to avoid redundant computation requests private boolean tickSaturated; private long timerCWUt = -1; - // Track allocated CWU for display purposes private int lastAllocatedCWUt = 0; private int currentAllocatedCWUt = 0; private long allocationTimer = -1; @@ -57,8 +51,7 @@ public int requestCWUt(int cwut, boolean simulate, @NotNull Collection seen) { int maximumCWUt = 0; for (var provider : providers) { - boolean canBridge = provider.canBridge(bridgeSeen); - int providerCWU = canBridge ? provider.getMaxCWUt(seen) : 0; - com.ghostipedia.cosmiccore.CosmicCore.LOGGER.info("Provider {} (class={}) canBridge={} CWU={}", - provider, provider.getClass().getName(), canBridge, providerCWU); - if (!canBridge) continue; - maximumCWUt += providerCWU; + if (!provider.canBridge(bridgeSeen)) continue; + maximumCWUt += provider.getMaxCWUt(seen); } - com.ghostipedia.cosmiccore.CosmicCore.LOGGER.info("Total max CWU from {} providers: {}", providers.size(), - maximumCWUt); return maximumCWUt; } @@ -129,8 +115,6 @@ public boolean canBridge(@NotNull Collection seen) return false; } - // Static access methods - public static WirelessComputationStore getStore(UUID uuid) { if (GlobalWirelessComputation.get(uuid) == null) { GlobalWirelessComputation.put(uuid, new WirelessComputationStore());