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..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 @@ -362,6 +362,28 @@ 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..56d2f2583 --- /dev/null +++ b/src/main/java/com/ghostipedia/cosmiccore/common/machine/multiblock/multi/WirelessComputationTransmitterMachine.java @@ -0,0 +1,203 @@ +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; + +@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()); + + if (!hatchesRegistered) { + addHatchesToWirelessNetwork(); + hatchesRegistered = true; + } + } else { + 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; + + 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); + } + } + + 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() { + WirelessComputationStore.addHatches(getTeamUUID(), computationHatches); + } + + 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..f6fa2d46d --- /dev/null +++ b/src/main/java/com/ghostipedia/cosmiccore/common/machine/multiblock/part/WirelessComputationHatchMachine.java @@ -0,0 +1,213 @@ +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; + +@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)); + } + + 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; + } + + @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); + + 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 (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..32e3252e7 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,6 @@ public abstract class GlobalWirelessVariableStorage { // Global wireless data stick map public static HashMap GlobalWirelessDataSticks = new HashMap<>(20, 0.9f); + + 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..6b030eaf0 --- /dev/null +++ b/src/main/java/com/ghostipedia/cosmiccore/common/wireless/WirelessComputationStore.java @@ -0,0 +1,134 @@ +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; + +public class WirelessComputationStore implements IOpticalComputationProvider { + + private final Set providers = new ObjectOpenHashSet<>(); + + private boolean tickSaturated; + private long timerCWUt = -1; + + 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; + + long currentTime = System.currentTimeMillis() / 50; + if (timerCWUt == currentTime) { + if (tickSaturated) { + return 0; + } + } else { + timerCWUt = currentTime; + tickSaturated = false; + } + + 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) { + if (!provider.canBridge(bridgeSeen)) continue; + maximumCWUt += provider.getMaxCWUt(seen); + } + + return maximumCWUt; + } + + @Override + public boolean canBridge(@NotNull Collection seen) { + seen.add(this); + + for (var provider : providers) { + if (provider.canBridge(seen)) { + return true; + } + } + return false; + } + + 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",