[
{
"path": ".github/ISSUE_TEMPLATE/bugs.md",
"content": "---\nname: Bug report\nabout: Something isn't working right\ntitle: '[BUG] '\nlabels: bug\nassignees: ''\n\n---\n\n**Description:**\n- Give a detailed explanation of the issue\n\n**Steps to Reproduce:**\n- Steps to reproduce this behaviour\n\n**Technical Information:**\n - Minecraft: \n - Fabric API: \n - Industrial Revolution: \n - Modpack: \n\n**Logs:**\n- Use a paste service, do not paste the logs directly here.\n\n**Details:**\nExtra information that might be helpful like screenshots or technical information about your computer.\n"
},
{
"path": ".github/ISSUE_TEMPLATE/requests.md",
"content": "---\nname: Request\nabout: I have a really cool idea!\ntitle: '[REQUEST] '\nlabels: enhancement\nassignees: ''\n\n---\n\n**Description:**\n- Describe your suggestion with as many details as possible.\n\n**Reason:**\n- Why do you think your suggestion should be added?\n"
},
{
"path": ".gitignore",
"content": "# gradle\n\n.gradle/\nbuild/\nout/\n\n# idea\n\n.idea/\n*.iml\n*.ipr\n*.iws\n\n# fabric\n\nrun/"
},
{
"path": "LICENSE.txt",
"content": " Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n\n APPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"[]\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\n Copyright [yyyy] [name of copyright owner]\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n"
},
{
"path": "README.md",
"content": "![](\"https://i.imgur.com/1ZwHaAt.png\")
\nIndustrial Revolution
\nAn Industrial mod made for Fabric.
\n\n \n ![](\"https://i.imgur.com/Ol1Tcf8.png\")
\n \n \n ![](\"https://i.imgur.com/c1DH9VL.png\")
\n \n
\n\n ![](\"https://img.shields.io/badge/License-Apache%202.0-brightgreen.svg\")
\n ![](\"http://cf.way2muchnoise.eu/versions/391708_latest.svg\")
\n ![](\"http://cf.way2muchnoise.eu/391708.svg\")
\n
\n\n## Features\nFor a complete list of features please check the mods [official page](https://www.curseforge.com/minecraft/mc-mods/industrial-revolution)\n\n## License\nDistributed under the Apache License, Version 2.0. See `LICENSE` for more information.\n\n## Build\nIf you want to build this yourself, please clone the repository and execute `gradlew build` in the projects folder. \n\nArtifacts will be generated at `/build/libs`\n"
},
{
"path": "build.gradle",
"content": "plugins {\n id \"fabric-loom\"\n id \"maven-publish\"\n id \"org.jetbrains.kotlin.jvm\"\n}\n\nsourceCompatibility = JavaVersion.VERSION_16\ntargetCompatibility = JavaVersion.VERSION_16\n\narchivesBaseName = project.archives_base_name\nversion = project.mod_version\ngroup = project.maven_group\n\nrepositories {\n maven {\n name = \"Modmuss50\"\n url = \"https://maven.modmuss50.me/\"\n content {\n includeGroup \"RebornCore\"\n includeGroup \"TechReborn\"\n includeGroup \"teamreborn\"\n }\n }\n maven {\n url \"https://maven.shedaniel.me/\"\n content {\n includeGroup \"dev.architectury\"\n includeGroup \"me.shedaniel\"\n includeGroup \"me.shedaniel.cloth\"\n includeGroup \"me.shedaniel.cloth.api\"\n }\n }\n maven {\n url = \"https://maven.fabricmc.net/\"\n content {\n includeGroup \"net.fabricmc\"\n }\n }\n maven {\n name = \"BuildCraft\"\n url = \"https://mod-buildcraft.com/maven\"\n content {\n includeGroup \"alexiil.mc.lib\"\n }\n }\n maven {\n name = \"CottonMC\"\n url = \"https://server.bbkr.space/artifactory/libs-release\"\n content {\n includeGroup \"io.github.cottonmc\"\n }\n }\n maven {\n url = \"https://maven.terraformersmc.com/releases/\"\n content {\n includeGroup \"com.terraformersmc\"\n }\n }\n maven {\n name = \"Patchouli\"\n url = \"https://maven.blamejared.com\"\n content {\n includeGroup \"vazkii.patchouli\"\n }\n }\n maven {\n url = \"https://jitpack.io\"\n content {\n includeGroup \"com.github.Technici4n\"\n includeGroup \"com.github.Draylar\"\n includeGroup \"com.github.Draylar.omega-config\"\n includeGroup \"com.github.emilyploszaj\"\n }\n }\n maven {\n url \"https://oskarstrom.net/maven\"\n content {\n includeGroup \"net.oskarstrom\"\n }\n }\n maven {\n name = \"Cafeteria Development\"\n url = 'https://maven.cafeteria.dev'\n content {\n includeGroup 'dev.cafeteria'\n includeGroup 'me.luligabi'\n includeGroup 'net.adriantodt.fabricmc'\n }\n }\n maven {\n name = 'Ladysnake Mods'\n url = 'https://ladysnake.jfrog.io/artifactory/mods'\n content {\n includeGroup 'io.github.ladysnake'\n includeGroupByRegex 'io\\\\.github\\\\.onyxstudios.*'\n }\n }\n}\n\ndependencies {\n\n dependencies.ext.lib = { dep, optional = false ->\n modImplementation(dep) {\n exclude group: \"net.fabricmc.fabric-api\"\n exclude group: \"com.jamieswhiteshirt\"\n exclude group: \"io.github.prospector\"\n }\n if (!optional) {\n include(dep) {\n exclude group: \"net.fabricmc.fabric-api\"\n exclude group: \"com.jamieswhiteshirt\"\n exclude group: \"io.github.prospector\"\n }\n }\n }\n\n minecraft \"com.mojang:minecraft:${project.minecraft_version}\"\n mappings \"net.fabricmc:yarn:${project.yarn_mappings}:v2\"\n modImplementation \"net.fabricmc:fabric-loader:${project.loader_version}\"\n\n modImplementation \"net.fabricmc.fabric-api:fabric-api:${project.fabric_version}\"\n\n modImplementation \"net.fabricmc:fabric-language-kotlin:${project.fabric_kotlin_version}\"\n\n dependencies.ext.lib(\"teamreborn:energy:${project.tr_energy_version}\")\n dependencies.ext.lib(\"io.github.cottonmc:LibGui:${project.libgui_version}\")\n dependencies.ext.lib(\"vazkii.patchouli:Patchouli:${project.patchouli_version}\")\n dependencies.ext.lib(\"alexiil.mc.lib:libblockattributes-core:${project.lba_version}\")\n dependencies.ext.lib(\"alexiil.mc.lib:libblockattributes-fluids:${project.lba_version}\")\n dependencies.ext.lib(\"alexiil.mc.lib:libblockattributes-items:${project.lba_version}\")\n dependencies.ext.lib(\"com.github.Draylar:magna:${project.magna_version}\")\n dependencies.ext.lib(\"com.github.emilyploszaj:step-height-entity-attribute:v1.0.1\")\n dependencies.ext.lib(\"dev.cafeteria:fake-player-api:${project.fakeplayerapi_version}\")\n dependencies.ext.lib(\"me.luligabi:NoIndium:1.0\")\n dependencies.ext.lib(\"me.shedaniel:RoughlyEnoughItems-fabric:${project.rei_version}\", true)\n\n modRuntimeOnly(\"com.terraformersmc:modmenu:${project.modmenu_version}\") {\n exclude group: \"net.fabricmc.fabric-api\", module: \"fabric-api\"\n }\n\n // DashLoader Stuff\n modCompileOnly(\"net.oskarstrom:DashLoader:2.0-dev12\")\n dependencies.ext.lib(\"io.activej:activej-serializer:${project.activej_version}\", true)\n modRuntimeOnly(\"org.yaml:snakeyaml:1.27\")\n}\n\nloom {\n accessWidenerPath = file(\"src/main/resources/indrev.accesswidener\")\n}\n\nprocessResources {\n inputs.property \"version\", project.version\n\n filesMatching(\"fabric.mod.json\") {\n expand \"version\": project.version\n }\n}\n\n// ensure that the encoding is set to UTF-8, no matter what the system default is\n// this fixes some edge cases with special characters not displaying correctly\n// see http://yodaconditions.net/blog/fix-for-java-file-encoding-problems-with-gradle.html\ntasks.withType(JavaCompile) {\n it.options.encoding = \"UTF-8\"\n it.options.release = 16\n}\n\n\njava {\n\t// Loom will automatically attach sourcesJar to a RemapSourcesJar task and to the \"build\" task\n\t// if it is present.\n\t// If you remove this line, sources will not be generated.\n\twithSourcesJar()\n}\n\njar {\n from(\"LICENSE\") {\n\t\trename { \"${it}_${project.archivesBaseName}\"}\n\t}\n\n exclude(\"me/steven/indrev/datagen\")\n}\n\n// configure the maven publication\npublishing {\n publications {\n mavenJava(MavenPublication) {\n // add all the jars that should be included when publishing to maven\n artifact(remapJar) {\n builtBy remapJar\n }\n artifact(sourcesJar) {\n builtBy remapSourcesJar\n }\n }\n }\n\n // select the repositories you want to publish to\n repositories {\n maven {\n url \"https://maven.cafeteria.dev/releases\"\n credentials {\n username = project.property(\"mcdUsername\")\n password = project.property(\"mcdPassword\")\n }\n authentication {\n basic(BasicAuthentication)\n }\n }\n }\n}\n\ncompileKotlin.kotlinOptions.jvmTarget = \"16\"\n"
},
{
"path": "gradle/wrapper/gradle-wrapper.properties",
"content": "distributionBase=GRADLE_USER_HOME\ndistributionPath=wrapper/dists\ndistributionUrl=https\\://services.gradle.org/distributions/gradle-7.3.1-bin.zip\nzipStoreBase=GRADLE_USER_HOME\nzipStorePath=wrapper/dists\n"
},
{
"path": "gradle.properties",
"content": "kotlin.code.style=official\norg.gradle.jvmargs=-Xmx2G\n# Fabric Properties\nminecraft_version=1.18.2\nyarn_mappings=1.18.2+build.3\nloader_version=0.13.3\n#Fabric api\nfabric_version=0.51.1+1.18.2\nloom_version=0.11-SNAPSHOT\n# Mod Properties\nmod_version=1.14.0-BETA\nmaven_group=me.steven\narchives_base_name=indrev\n# Kotlin\nkotlin_version=1.6.20\nfabric_kotlin_version=1.7.2+kotlin.1.6.20\n# LibGui\nlibgui_version=5.3.2+1.18.2\n# Mod Menu\nmodmenu_version=3.1.0\n# Roughly Enough Items\nrei_version=8.0.442\n# Patchouli\npatchouli_version=1.18.2-66-FABRIC\n# LBA\nlba_version=0.10.0\n# Magna\nmagna_version=1.7.0-1.18\n# TR Energy\ntr_energy_version=2.0.0-beta1\n# Fake Player API\nfakeplayerapi_version=0.3.0\n# ActiveJ\nactivej_version=4.3"
},
{
"path": "gradlew",
"content": "#!/usr/bin/env sh\n\n#\n# Copyright 2015 the original author or authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# https://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n\n##############################################################################\n##\n## Gradle start up script for UN*X\n##\n##############################################################################\n\n# Attempt to set APP_HOME\n# Resolve links: $0 may be a link\nPRG=\"$0\"\n# Need this for relative symlinks.\nwhile [ -h \"$PRG\" ] ; do\n ls=`ls -ld \"$PRG\"`\n link=`expr \"$ls\" : '.*-> \\(.*\\)$'`\n if expr \"$link\" : '/.*' > /dev/null; then\n PRG=\"$link\"\n else\n PRG=`dirname \"$PRG\"`\"/$link\"\n fi\ndone\nSAVED=\"`pwd`\"\ncd \"`dirname \\\"$PRG\\\"`/\" >/dev/null\nAPP_HOME=\"`pwd -P`\"\ncd \"$SAVED\" >/dev/null\n\nAPP_NAME=\"Gradle\"\nAPP_BASE_NAME=`basename \"$0\"`\n\n# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.\nDEFAULT_JVM_OPTS='\"-Xmx64m\" \"-Xms64m\"'\n\n# Use the maximum available, or set MAX_FD != -1 to use that value.\nMAX_FD=\"maximum\"\n\nwarn () {\n echo \"$*\"\n}\n\ndie () {\n echo\n echo \"$*\"\n echo\n exit 1\n}\n\n# OS specific support (must be 'true' or 'false').\ncygwin=false\nmsys=false\ndarwin=false\nnonstop=false\ncase \"`uname`\" in\n CYGWIN* )\n cygwin=true\n ;;\n Darwin* )\n darwin=true\n ;;\n MINGW* )\n msys=true\n ;;\n NONSTOP* )\n nonstop=true\n ;;\nesac\n\nCLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar\n\n\n# Determine the Java command to use to start the JVM.\nif [ -n \"$JAVA_HOME\" ] ; then\n if [ -x \"$JAVA_HOME/jre/sh/java\" ] ; then\n # IBM's JDK on AIX uses strange locations for the executables\n JAVACMD=\"$JAVA_HOME/jre/sh/java\"\n else\n JAVACMD=\"$JAVA_HOME/bin/java\"\n fi\n if [ ! -x \"$JAVACMD\" ] ; then\n die \"ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME\n\nPlease set the JAVA_HOME variable in your environment to match the\nlocation of your Java installation.\"\n fi\nelse\n JAVACMD=\"java\"\n which java >/dev/null 2>&1 || die \"ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.\n\nPlease set the JAVA_HOME variable in your environment to match the\nlocation of your Java installation.\"\nfi\n\n# Increase the maximum file descriptors if we can.\nif [ \"$cygwin\" = \"false\" -a \"$darwin\" = \"false\" -a \"$nonstop\" = \"false\" ] ; then\n MAX_FD_LIMIT=`ulimit -H -n`\n if [ $? -eq 0 ] ; then\n if [ \"$MAX_FD\" = \"maximum\" -o \"$MAX_FD\" = \"max\" ] ; then\n MAX_FD=\"$MAX_FD_LIMIT\"\n fi\n ulimit -n $MAX_FD\n if [ $? -ne 0 ] ; then\n warn \"Could not set maximum file descriptor limit: $MAX_FD\"\n fi\n else\n warn \"Could not query maximum file descriptor limit: $MAX_FD_LIMIT\"\n fi\nfi\n\n# For Darwin, add options to specify how the application appears in the dock\nif $darwin; then\n GRADLE_OPTS=\"$GRADLE_OPTS \\\"-Xdock:name=$APP_NAME\\\" \\\"-Xdock:icon=$APP_HOME/media/gradle.icns\\\"\"\nfi\n\n# For Cygwin or MSYS, switch paths to Windows format before running java\nif [ \"$cygwin\" = \"true\" -o \"$msys\" = \"true\" ] ; then\n APP_HOME=`cygpath --path --mixed \"$APP_HOME\"`\n CLASSPATH=`cygpath --path --mixed \"$CLASSPATH\"`\n \n JAVACMD=`cygpath --unix \"$JAVACMD\"`\n\n # We build the pattern for arguments to be converted via cygpath\n ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`\n SEP=\"\"\n for dir in $ROOTDIRSRAW ; do\n ROOTDIRS=\"$ROOTDIRS$SEP$dir\"\n SEP=\"|\"\n done\n OURCYGPATTERN=\"(^($ROOTDIRS))\"\n # Add a user-defined pattern to the cygpath arguments\n if [ \"$GRADLE_CYGPATTERN\" != \"\" ] ; then\n OURCYGPATTERN=\"$OURCYGPATTERN|($GRADLE_CYGPATTERN)\"\n fi\n # Now convert the arguments - kludge to limit ourselves to /bin/sh\n i=0\n for arg in \"$@\" ; do\n CHECK=`echo \"$arg\"|egrep -c \"$OURCYGPATTERN\" -`\n CHECK2=`echo \"$arg\"|egrep -c \"^-\"` ### Determine if an option\n\n if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition\n eval `echo args$i`=`cygpath --path --ignore --mixed \"$arg\"`\n else\n eval `echo args$i`=\"\\\"$arg\\\"\"\n fi\n i=`expr $i + 1`\n done\n case $i in\n 0) set -- ;;\n 1) set -- \"$args0\" ;;\n 2) set -- \"$args0\" \"$args1\" ;;\n 3) set -- \"$args0\" \"$args1\" \"$args2\" ;;\n 4) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" ;;\n 5) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" ;;\n 6) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" \"$args5\" ;;\n 7) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" \"$args5\" \"$args6\" ;;\n 8) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" \"$args5\" \"$args6\" \"$args7\" ;;\n 9) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" \"$args5\" \"$args6\" \"$args7\" \"$args8\" ;;\n esac\nfi\n\n# Escape application args\nsave () {\n for i do printf %s\\\\n \"$i\" | sed \"s/'/'\\\\\\\\''/g;1s/^/'/;\\$s/\\$/' \\\\\\\\/\" ; done\n echo \" \"\n}\nAPP_ARGS=`save \"$@\"`\n\n# Collect all arguments for the java command, following the shell quoting and substitution rules\neval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS \"\\\"-Dorg.gradle.appname=$APP_BASE_NAME\\\"\" -classpath \"\\\"$CLASSPATH\\\"\" org.gradle.wrapper.GradleWrapperMain \"$APP_ARGS\"\n\nexec \"$JAVACMD\" \"$@\"\n"
},
{
"path": "gradlew.bat",
"content": "@rem\n@rem Copyright 2015 the original author or authors.\n@rem\n@rem Licensed under the Apache License, Version 2.0 (the \"License\");\n@rem you may not use this file except in compliance with the License.\n@rem You may obtain a copy of the License at\n@rem\n@rem https://www.apache.org/licenses/LICENSE-2.0\n@rem\n@rem Unless required by applicable law or agreed to in writing, software\n@rem distributed under the License is distributed on an \"AS IS\" BASIS,\n@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n@rem See the License for the specific language governing permissions and\n@rem limitations under the License.\n@rem\n\n@if \"%DEBUG%\" == \"\" @echo off\n@rem ##########################################################################\n@rem\n@rem Gradle startup script for Windows\n@rem\n@rem ##########################################################################\n\n@rem Set local scope for the variables with windows NT shell\nif \"%OS%\"==\"Windows_NT\" setlocal\n\nset DIRNAME=%~dp0\nif \"%DIRNAME%\" == \"\" set DIRNAME=.\nset APP_BASE_NAME=%~n0\nset APP_HOME=%DIRNAME%\n\n@rem Resolve any \".\" and \"..\" in APP_HOME to make it shorter.\nfor %%i in (\"%APP_HOME%\") do set APP_HOME=%%~fi\n\n@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.\nset DEFAULT_JVM_OPTS=\"-Xmx64m\" \"-Xms64m\"\n\n@rem Find java.exe\nif defined JAVA_HOME goto findJavaFromJavaHome\n\nset JAVA_EXE=java.exe\n%JAVA_EXE% -version >NUL 2>&1\nif \"%ERRORLEVEL%\" == \"0\" goto init\n\necho.\necho ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.\necho.\necho Please set the JAVA_HOME variable in your environment to match the\necho location of your Java installation.\n\ngoto fail\n\n:findJavaFromJavaHome\nset JAVA_HOME=%JAVA_HOME:\"=%\nset JAVA_EXE=%JAVA_HOME%/bin/java.exe\n\nif exist \"%JAVA_EXE%\" goto init\n\necho.\necho ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%\necho.\necho Please set the JAVA_HOME variable in your environment to match the\necho location of your Java installation.\n\ngoto fail\n\n:init\n@rem Get command-line arguments, handling Windows variants\n\nif not \"%OS%\" == \"Windows_NT\" goto win9xME_args\n\n:win9xME_args\n@rem Slurp the command line arguments.\nset CMD_LINE_ARGS=\nset _SKIP=2\n\n:win9xME_args_slurp\nif \"x%~1\" == \"x\" goto execute\n\nset CMD_LINE_ARGS=%*\n\n:execute\n@rem Setup the command line\n\nset CLASSPATH=%APP_HOME%\\gradle\\wrapper\\gradle-wrapper.jar\n\n\n@rem Execute Gradle\n\"%JAVA_EXE%\" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% \"-Dorg.gradle.appname=%APP_BASE_NAME%\" -classpath \"%CLASSPATH%\" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%\n\n:end\n@rem End local scope for the variables with windows NT shell\nif \"%ERRORLEVEL%\"==\"0\" goto mainEnd\n\n:fail\nrem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of\nrem the _cmd.exe /c_ return code!\nif not \"\" == \"%GRADLE_EXIT_CONSOLE%\" exit 1\nexit /b 1\n\n:mainEnd\nif \"%OS%\"==\"Windows_NT\" endlocal\n\n:omega\n"
},
{
"path": "settings.gradle",
"content": "pluginManagement {\n repositories {\n jcenter()\n maven {\n name = 'Fabric'\n url = 'https://maven.fabricmc.net/'\n }\n gradlePluginPortal()\n }\n\n plugins {\n id 'fabric-loom' version loom_version\n id \"org.jetbrains.kotlin.jvm\" version kotlin_version\n }\n\n}\n"
},
{
"path": "src/main/java/me/steven/indrev/AprilFools.java",
"content": "package me.steven.indrev;\n\nimport net.fabricmc.api.EnvType;\nimport net.fabricmc.api.Environment;\nimport net.fabricmc.fabric.api.client.item.v1.ItemTooltipCallback;\nimport net.fabricmc.loader.api.FabricLoader;\nimport net.minecraft.text.LiteralText;\nimport net.minecraft.util.Formatting;\nimport net.minecraft.util.registry.Registry;\n\nimport java.io.File;\nimport java.io.IOException;\nimport java.time.LocalDate;\n\n@Environment(EnvType.CLIENT)\npublic final class AprilFools {\n private static final File CHECK =\n new File(FabricLoader.getInstance().getGameDir().toString(), \".indrev_\" + LocalDate.now().getYear());\n\n public static void init() {\n if (isToday()) {\n ItemTooltipCallback.EVENT.register((itemStack, tooltipContext, list) -> {\n String itemNamespace = Registry.ITEM.getId(itemStack.getItem()).getNamespace();\n if (itemNamespace.equals(IndustrialRevolution.MOD_ID) && list.size() > 1) {\n list.add(new LiteralText(\"\")); // break line\n list.add(new LiteralText(\"every good modpack uses forge...\").formatted(Formatting.ITALIC));\n }\n });\n\n try { CHECK.createNewFile(); }\n catch (IOException ex) { ex.printStackTrace(); }\n }\n }\n\n public static boolean isToday() {\n return false;\n /*LocalDate now = LocalDate.now();\n return now.getDayOfMonth() == 1 && now.getMonthValue() == 4 && !CHECK.exists();*/\n }\n}\n"
},
{
"path": "src/main/java/me/steven/indrev/FabricRecipeRemainder.java",
"content": "package me.steven.indrev;\n\nimport net.minecraft.entity.player.PlayerEntity;\nimport net.minecraft.inventory.CraftingInventory;\nimport net.minecraft.item.ItemStack;\n\npublic interface FabricRecipeRemainder {\n ItemStack getRemainder(ItemStack stack, CraftingInventory craftingInventory, PlayerEntity playerEntity);\n}"
},
{
"path": "src/main/java/me/steven/indrev/IREnergyStorage.java",
"content": "package me.steven.indrev;\n\nimport net.fabricmc.fabric.api.transfer.v1.storage.StoragePreconditions;\nimport net.fabricmc.fabric.api.transfer.v1.transaction.TransactionContext;\nimport net.fabricmc.fabric.api.transfer.v1.transaction.base.SnapshotParticipant;\nimport net.minecraft.util.math.Direction;\nimport org.jetbrains.annotations.Nullable;\nimport team.reborn.energy.api.EnergyStorage;\n\n\n/**\n * Copied from SimpleSidedEnergyContainer and modified to fit IR's needs\n */\npublic abstract class IREnergyStorage extends SnapshotParticipant {\n private final SideStorage[] sideStorages = new SideStorage[7];\n\n public IREnergyStorage() {\n for (int i = 0; i < 7; ++i) {\n sideStorages[i] = new SideStorage(i == 6 ? null : Direction.byId(i));\n }\n }\n\n /**\n * @return The current capacity of this storage.\n */\n public abstract long getCapacity();\n\n /**\n * @return The maximum amount of energy that can be inserted in a single operation from the passed side.\n */\n public abstract long getMaxInsert(@Nullable Direction side);\n\n /**\n * @return The maximum amount of energy that can be extracted in a single operation from the passed side.\n */\n public abstract long getMaxExtract(@Nullable Direction side);\n\n /**\n * @return An {@link EnergyStorage} implementation for the passed side.\n */\n public EnergyStorage getSideStorage(@Nullable Direction side) {\n return sideStorages[side == null ? 6 : side.getId()];\n }\n\n public long getAmount() {\n return 0;\n }\n\n public void setAmount(long v) {\n\n }\n\n @Override\n protected Long createSnapshot() {\n return getAmount();\n }\n\n @Override\n protected void readSnapshot(Long snapshot) {\n setAmount(snapshot);\n }\n\n private class SideStorage implements EnergyStorage {\n private final Direction side;\n\n private SideStorage(Direction side) {\n this.side = side;\n }\n\n @Override\n public boolean supportsInsertion() {\n return getMaxInsert(side) > 0;\n }\n\n @Override\n public long insert(long maxAmount, TransactionContext transaction) {\n StoragePreconditions.notNegative(maxAmount);\n\n long inserted = Math.min(getMaxInsert(side), Math.min(maxAmount, getCapacity() - getAmount()));\n\n if (inserted > 0) {\n updateSnapshots(transaction);\n\n setAmount(getAmount() + inserted);\n return inserted;\n }\n\n return 0;\n }\n\n @Override\n public boolean supportsExtraction() {\n return getMaxExtract(side) > 0;\n }\n\n @Override\n public long extract(long maxAmount, TransactionContext transaction) {\n StoragePreconditions.notNegative(maxAmount);\n\n long extracted = Math.min(getMaxExtract(side), Math.min(maxAmount, getAmount()));\n\n if (extracted > 0) {\n updateSnapshots(transaction);\n setAmount(getAmount() - extracted);\n return extracted;\n }\n\n return 0;\n }\n\n @Override\n public long getAmount() {\n return IREnergyStorage.this.getAmount();\n }\n\n @Override\n public long getCapacity() {\n return IREnergyStorage.this.getCapacity();\n }\n }\n}\n\n"
},
{
"path": "src/main/java/me/steven/indrev/WCustomTabPanel.java",
"content": "/*\nOriginal code by Juuxel, part of https://github.com/CottonMC/LibGui\n\nMIT License\n\nCopyright (c) 2018 The Cotton Project\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n*/\n\npackage me.steven.indrev;\n\nimport io.github.cottonmc.cotton.gui.client.BackgroundPainter;\nimport io.github.cottonmc.cotton.gui.client.LibGui;\nimport io.github.cottonmc.cotton.gui.client.ScreenDrawing;\nimport io.github.cottonmc.cotton.gui.widget.*;\nimport io.github.cottonmc.cotton.gui.widget.data.Axis;\nimport io.github.cottonmc.cotton.gui.widget.data.HorizontalAlignment;\nimport io.github.cottonmc.cotton.gui.widget.data.InputResult;\nimport io.github.cottonmc.cotton.gui.widget.icon.Icon;\nimport net.fabricmc.api.EnvType;\nimport net.fabricmc.api.Environment;\nimport net.minecraft.client.MinecraftClient;\nimport net.minecraft.client.font.TextRenderer;\nimport net.minecraft.client.sound.PositionedSoundInstance;\nimport net.minecraft.client.util.math.MatrixStack;\nimport net.minecraft.sound.SoundEvents;\nimport net.minecraft.text.Text;\nimport net.minecraft.util.Identifier;\nimport org.jetbrains.annotations.Nullable;\n\nimport java.util.*;\nimport java.util.function.Consumer;\n\npublic class WCustomTabPanel extends WPanel {\n private static final int TAB_PADDING = 4;\n private static final int TAB_WIDTH = 28;\n private static final int TAB_HEIGHT = 25;\n private static final int PANEL_PADDING = 8; // The padding of BackgroundPainter.VANILLA\n private static final int ICON_SIZE = 16;\n private final WBox tabRibbon = new WBox(Axis.HORIZONTAL).setSpacing(1);\n private final List tabWidgets = new ArrayList<>();\n private final WCardPanel mainPanel = new WCardPanel();\n\n /**\n * Constructs a new tab panel.\n */\n public WCustomTabPanel() {\n add(tabRibbon, 0, 0);\n add(mainPanel, PANEL_PADDING, TAB_HEIGHT + PANEL_PADDING);\n }\n\n public void add(WWidget widget, int x, int y) {\n children.add(widget);\n widget.setParent(this);\n widget.setLocation(x, y);\n expandToFit(widget);\n }\n\n @Override\n public WPanel setBackgroundPainter(BackgroundPainter painter) {\n return super.setBackgroundPainter(\n BackgroundPainter.createLightDarkVariants(\n BackgroundPainter.createNinePatch(new Identifier(\"libgui\", \"textures/widget/panel_light.png\")).setPadding(0).setTopPadding(-25),\n BackgroundPainter.createNinePatch(new Identifier(\"libgui\", \"textures/widget/panel_dark.png\")).setPadding(8).setTopPadding(-25)\n ));\n }\n\n // dont bother it's just bad code ik\n public WPanel setForceBackgroundPainter(BackgroundPainter painter) {\n return super.setBackgroundPainter(painter);\n }\n\n /**\n * Adds a tab to this panel.\n *\n * @param tab the added tab\n */\n public void add(WCustomTabPanel.Tab tab) {\n WTab tabWidget = new WTab(tab);\n\n if (tabWidgets.isEmpty()) {\n tabWidget.selected = true;\n }\n\n tabWidgets.add(tabWidget);\n tabRibbon.add(tabWidget, TAB_WIDTH, TAB_HEIGHT + TAB_PADDING);\n mainPanel.add(tab.getWidget());\n }\n\n /**\n * Configures and adds a tab to this panel.\n *\n * @param widget the contained widget\n * @param configurator the tab configurator\n */\n public void add(WWidget widget, Consumer configurator) {\n WCustomTabPanel.Tab.Builder builder = new WCustomTabPanel.Tab.Builder(widget);\n configurator.accept(builder);\n add(builder.build());\n }\n\n @Override\n public void setSize(int x, int y) {\n super.setSize(x, y);\n tabRibbon.setSize(x, TAB_HEIGHT);\n }\n\n @Environment(EnvType.CLIENT)\n @Override\n public void addPainters() {\n super.addPainters();\n }\n\n /**\n * The data of a tab.\n */\n public static class Tab {\n private final Text title;\n private final Icon icon;\n private final WWidget widget;\n private final Consumer tooltip;\n\n /**\n * Constructs a tab.\n *\n * @param title the tab title\n * @param icon the tab icon\n * @param widget the widget contained in the tab\n * @param tooltip the tab tooltip\n * @throws IllegalArgumentException if both the title and the icon are null\n * @throws NullPointerException if either the widget or the tooltip is null\n */\n public Tab(Text title, Icon icon, WWidget widget, Consumer tooltip) {\n if (title == null && icon == null) {\n throw new IllegalArgumentException(\"A tab must have a title or an icon\");\n }\n\n this.title = title;\n this.icon = icon;\n this.widget = Objects.requireNonNull(widget, \"widget\");\n this.tooltip = tooltip;\n }\n\n /**\n * Gets the title of this tab.\n *\n * @return the title, or null if there's no title\n */\n public Text getTitle() {\n return title;\n }\n\n /**\n * Gets the icon of this tab.\n *\n * @return the icon, or null if there's no title\n */\n public Icon getIcon() {\n return icon;\n }\n\n /**\n * Gets the contained widget of this tab.\n *\n * @return the contained widget\n */\n public WWidget getWidget() {\n return widget;\n }\n\n /**\n * Adds this widget's tooltip to the {@code tooltip} builder.\n *\n * @param tooltip the tooltip builder\n */\n public void addTooltip(TooltipBuilder tooltip) {\n if (this.tooltip != null)\n this.tooltip.accept(tooltip);\n }\n\n /**\n * A builder for tab data.\n */\n public static final class Builder {\n @Nullable\n private Text title;\n @Nullable\n private Icon icon;\n private final WWidget widget;\n private final List tooltip = new ArrayList<>();\n\n /**\n * Constructs a new tab data builder.\n *\n * @param widget the contained widget\n * @throws NullPointerException if the widget is null\n */\n public Builder(WWidget widget) {\n this.widget = Objects.requireNonNull(widget, \"widget\");\n }\n\n /**\n * Sets the tab title.\n *\n * @param title the new title\n * @return this builder\n * @throws NullPointerException if the title is null\n */\n public Builder title(Text title) {\n this.title = Objects.requireNonNull(title, \"title\");\n return this;\n }\n\n /**\n * Sets the tab icon.\n *\n * @param icon the new icon\n * @return this builder\n * @throws NullPointerException if the icon is null\n */\n public Builder icon(Icon icon) {\n this.icon = Objects.requireNonNull(icon, \"icon\");\n return this;\n }\n\n /**\n * Adds lines to the tab's tooltip.\n *\n * @param lines the added lines\n * @return this builder\n * @throws NullPointerException if the line array is null\n */\n public Builder tooltip(Text... lines) {\n Objects.requireNonNull(lines, \"lines\");\n Collections.addAll(tooltip, lines);\n\n return this;\n }\n\n /**\n * Adds lines to the tab's tooltip.\n *\n * @param lines the added lines\n * @return this builder\n * @throws NullPointerException if the line collection is null\n */\n public Builder tooltip(Collection lines) {\n Objects.requireNonNull(lines, \"lines\");\n tooltip.addAll(lines);\n return this;\n }\n\n /**\n * Builds a tab from this builder.\n *\n * @return the built tab\n */\n public Tab build() {\n Consumer tooltip = null;\n\n if (!this.tooltip.isEmpty()) {\n //noinspection Convert2Lambda\n tooltip = new Consumer() {\n @Environment(EnvType.CLIENT)\n @Override\n public void accept(TooltipBuilder builder) {\n builder.add(WCustomTabPanel.Tab.Builder.this.tooltip.toArray(new Text[0]));\n }\n };\n }\n\n return new Tab(title, icon, widget, tooltip);\n }\n }\n }\n\n private final class WTab extends WWidget {\n private final WCustomTabPanel.Tab data;\n boolean selected = false;\n\n WTab(WCustomTabPanel.Tab data) {\n this.data = data;\n }\n\n @Override\n public boolean canFocus() {\n return true;\n }\n\n @Environment(EnvType.CLIENT)\n @Override\n public InputResult onClick(int x, int y, int button) {\n super.onClick(x, y, button);\n\n MinecraftClient.getInstance().getSoundManager().play(PositionedSoundInstance.master(SoundEvents.UI_BUTTON_CLICK, 1.0F));\n\n for (WTab tab : tabWidgets) {\n tab.selected = (tab == this);\n }\n\n mainPanel.setSelectedCard(data.getWidget());\n WCustomTabPanel.this.layout();\n return InputResult.PROCESSED;\n }\n\n @Environment(EnvType.CLIENT)\n @Override\n public void onKeyPressed(int ch, int key, int modifiers) {\n if (isActivationKey(ch)) {\n onClick(0, 0, 0);\n }\n }\n\n @Environment(EnvType.CLIENT)\n @Override\n public void paint(MatrixStack matrices, int x, int y, int mouseX, int mouseY) {\n TextRenderer renderer = MinecraftClient.getInstance().textRenderer;\n Text title = data.getTitle();\n Icon icon = data.getIcon();\n\n if (title != null) {\n int width = TAB_WIDTH + renderer.getWidth(title);\n if (icon == null) width = Math.max(TAB_WIDTH, width - ICON_SIZE);\n\n if (this.width != width) {\n setSize(width, this.height);\n getParent().layout();\n }\n }\n\n (selected ? WCustomTabPanel.Painters.SELECTED_TAB : WCustomTabPanel.Painters.UNSELECTED_TAB).paintBackground(matrices, x, y, this);\n if (isFocused()) {\n (selected ? WCustomTabPanel.Painters.SELECTED_TAB_FOCUS_BORDER : Painters.UNSELECTED_TAB_FOCUS_BORDER).paintBackground(matrices, x, y, this);\n }\n\n int iconX = 6;\n\n if (title != null) {\n int titleX = (icon != null) ? iconX + ICON_SIZE + 1 : 0;\n int titleY = (height - TAB_PADDING - renderer.fontHeight) / 2 + 1;\n int width = (icon != null) ? this.width - iconX - ICON_SIZE : this.width;\n HorizontalAlignment align = (icon != null) ? HorizontalAlignment.LEFT : HorizontalAlignment.CENTER;\n\n int color;\n if (LibGui.isDarkMode()) {\n color = WLabel.DEFAULT_DARKMODE_TEXT_COLOR;\n } else {\n color = selected ? WLabel.DEFAULT_TEXT_COLOR : 0xEEEEEE;\n }\n\n ScreenDrawing.drawString(matrices, title.asOrderedText(), align, x + titleX, y + titleY, width, color);\n }\n\n if (icon != null) {\n icon.paint(matrices, x + iconX, (y + (height - TAB_PADDING - ICON_SIZE) / 2) + 1, ICON_SIZE);\n }\n }\n\n @Override\n public void addTooltip(TooltipBuilder tooltip) {\n data.addTooltip(tooltip);\n }\n }\n\n /**\n * Internal background painter instances for tabs.\n */\n @Environment(EnvType.CLIENT)\n final static class Painters {\n static final BackgroundPainter SELECTED_TAB = BackgroundPainter.createLightDarkVariants(\n BackgroundPainter.createNinePatch(new Identifier(\"indrev\", \"textures/gui/selected_light.png\")).setTopPadding(2),\n BackgroundPainter.createNinePatch(new Identifier(\"libgui\", \"textures/widget/tab/selected_dark.png\")).setTopPadding(2)\n );\n\n static final BackgroundPainter UNSELECTED_TAB = BackgroundPainter.createLightDarkVariants(\n BackgroundPainter.createNinePatch(new Identifier(\"indrev\", \"textures/gui/unselected_light.png\")),\n BackgroundPainter.createNinePatch(new Identifier(\"libgui\", \"textures/widget/tab/unselected_dark.png\"))\n );\n\n static final BackgroundPainter SELECTED_TAB_FOCUS_BORDER = BackgroundPainter.createNinePatch(new Identifier(\"libgui\", \"textures/widget/tab/focus.png\")).setTopPadding(2);\n static final BackgroundPainter UNSELECTED_TAB_FOCUS_BORDER = BackgroundPainter.createNinePatch(new Identifier(\"libgui\", \"textures/widget/tab/focus.png\"));\n }\n}\n\n"
},
{
"path": "src/main/java/me/steven/indrev/mixin/aprilfools/AprilFoolsMixinConfigPlugin.java",
"content": "package me.steven.indrev.mixin.aprilfools;\n\nimport me.steven.indrev.AprilFools;\nimport net.fabricmc.api.EnvType;\nimport net.fabricmc.loader.api.FabricLoader;\nimport org.objectweb.asm.tree.ClassNode;\nimport org.spongepowered.asm.mixin.extensibility.IMixinConfigPlugin;\nimport org.spongepowered.asm.mixin.extensibility.IMixinInfo;\n\nimport java.util.ArrayList;\nimport java.util.List;\nimport java.util.Set;\n\npublic class AprilFoolsMixinConfigPlugin implements IMixinConfigPlugin {\n private static final ArrayList mixins = new ArrayList<>();\n static {\n mixins.add(\"aprilfools.MixinTranslatableText\");\n }\n\n @Override\n public void onLoad(String mixinPackage) { }\n\n @Override\n public String getRefMapperConfig() {\n return null;\n }\n\n @Override\n public boolean shouldApplyMixin(String targetClassName, String mixinClassName) {\n return true;\n }\n\n @Override\n public void acceptTargets(Set myTargets, Set otherTargets) { }\n\n @Override\n public List getMixins() {\n return FabricLoader.getInstance().getEnvironmentType() == EnvType.CLIENT && AprilFools.isToday() ? mixins : null;\n }\n\n @Override\n public void preApply(String targetClassName, ClassNode targetClass, String mixinClassName, IMixinInfo mixinInfo) { }\n\n @Override\n public void postApply(String targetClassName, ClassNode targetClass, String mixinClassName, IMixinInfo mixinInfo) { }\n}\n"
},
{
"path": "src/main/java/me/steven/indrev/mixin/aprilfools/MixinTranslatableText.java",
"content": "package me.steven.indrev.mixin.aprilfools;\n\nimport me.steven.indrev.IndustrialRevolution;\nimport net.minecraft.text.TranslatableText;\nimport org.spongepowered.asm.mixin.Final;\nimport org.spongepowered.asm.mixin.Mixin;\nimport org.spongepowered.asm.mixin.Shadow;\nimport org.spongepowered.asm.mixin.injection.At;\nimport org.spongepowered.asm.mixin.injection.ModifyVariable;\n\n@Mixin(TranslatableText.class)\npublic class MixinTranslatableText {\n @Shadow @Final private String key;\n\n @ModifyVariable(name = \"string\", at = @At(\"STORE\"), method = \"updateTranslations\")\n private String owo(String original) {\n if (this.key.contains(IndustrialRevolution.MOD_ID)) {\n if (!original.contains(\".\")) {\n String[] words = original.split(\" \");\n for (int i = 0; i < words.length; i++) {\n if (words[i].endsWith(\"ger\") || words[i].endsWith(\"der\"))\n words[i] = words[i].substring(0, words[i].length() - 2) + \"ah\";\n else if (words[i].endsWith(\"er\") || words[i].endsWith(\"re\"))\n words[i] = words[i].substring(0, words[i].length() - 2) + 'y';\n else if (words[i].endsWith(\"xe\"))\n words[i] = words[i].substring(0, words[i].length() - 2) + \"xie\";\n else if (words[i].endsWith(\"et\"))\n words[i] = words[i].substring(0, words[i].length() - 2) + \"ie\";\n\n words[i] = words[i].replaceFirst(\"est\", \"ess\"); // Chest -> Chess\n words[i] = words[i].replaceFirst(\"O\", \"Ow\").replaceFirst(\"o\", \"ow\");\n }\n\n return String.join(\" \", words);\n }\n }\n\n return original;\n }\n}\n"
},
{
"path": "src/main/java/me/steven/indrev/mixin/client/MixinBuiltChunk.java",
"content": "package me.steven.indrev.mixin.client;\n\nimport me.steven.indrev.blockentities.GlobalStateController;\nimport net.minecraft.client.MinecraftClient;\nimport net.minecraft.client.render.chunk.ChunkBuilder;\nimport net.minecraft.util.math.BlockPos;\nimport net.minecraft.util.math.ChunkPos;\nimport org.spongepowered.asm.mixin.Mixin;\nimport org.spongepowered.asm.mixin.Shadow;\nimport org.spongepowered.asm.mixin.injection.At;\nimport org.spongepowered.asm.mixin.injection.Inject;\nimport org.spongepowered.asm.mixin.injection.callback.CallbackInfo;\n\n@Mixin(ChunkBuilder.BuiltChunk.class)\npublic abstract class MixinBuiltChunk {\n @Shadow public abstract BlockPos getOrigin();\n\n @Inject(method = \"rebuild\", at = @At(\"INVOKE\"))\n private void indrev_removeBuiltChunk(CallbackInfo ci) {\n long chunkPos = ChunkPos.toLong(getOrigin().getX() >> 4, getOrigin().getZ() >> 4);\n MinecraftClient.getInstance().execute(() -> GlobalStateController.INSTANCE.getChunksToUpdate().remove(chunkPos));\n }\n}\n"
},
{
"path": "src/main/java/me/steven/indrev/mixin/client/MixinClientPlayerInteractionManager.java",
"content": "package me.steven.indrev.mixin.client;\n\nimport me.steven.indrev.registry.IRItemRegistry;\nimport net.minecraft.client.network.ClientPlayerInteractionManager;\nimport net.minecraft.item.ItemStack;\nimport org.spongepowered.asm.mixin.Mixin;\nimport org.spongepowered.asm.mixin.injection.At;\nimport org.spongepowered.asm.mixin.injection.Redirect;\n\n@Mixin(ClientPlayerInteractionManager.class)\npublic class MixinClientPlayerInteractionManager {\n @Redirect(method = \"isCurrentlyBreaking\", at = @At(value = \"INVOKE\", target = \"Lnet/minecraft/item/ItemStack;areNbtEqual(Lnet/minecraft/item/ItemStack;Lnet/minecraft/item/ItemStack;)Z\"))\n private boolean indrev_fixGamerAxe(ItemStack left, ItemStack right) {\n if (left.getItem() == IRItemRegistry.INSTANCE.getGAMER_AXE_ITEM() && left.getItem() == right.getItem())\n return true;\n return ItemStack.areNbtEqual(left, right);\n }\n}\n"
},
{
"path": "src/main/java/me/steven/indrev/mixin/client/MixinGameRenderer.java",
"content": "package me.steven.indrev.mixin.client;\n\nimport me.steven.indrev.api.IRPlayerEntityExtension;\nimport me.steven.indrev.tools.modular.ArmorModule;\nimport net.minecraft.client.render.GameRenderer;\nimport net.minecraft.entity.LivingEntity;\nimport org.spongepowered.asm.mixin.Mixin;\nimport org.spongepowered.asm.mixin.injection.At;\nimport org.spongepowered.asm.mixin.injection.Inject;\nimport org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;\n\n@Mixin(value = GameRenderer.class, priority = 999)\npublic class MixinGameRenderer {\n @Inject(method = \"getNightVisionStrength\", at = @At(\"INVOKE\"), cancellable = true)\n private static void indrev_nightVisionStrength(LivingEntity livingEntity, float f, CallbackInfoReturnable cir) {\n if (livingEntity instanceof IRPlayerEntityExtension && ((IRPlayerEntityExtension) livingEntity).isApplied(ArmorModule.NIGHT_VISION)) {\n cir.setReturnValue(1f);\n }\n }\n}\n"
},
{
"path": "src/main/java/me/steven/indrev/mixin/client/MixinItemRenderer.java",
"content": "package me.steven.indrev.mixin.client;\n\nimport com.mojang.blaze3d.systems.RenderSystem;\nimport me.steven.indrev.items.armor.IRModularArmorItem;\nimport net.minecraft.client.font.TextRenderer;\nimport net.minecraft.client.render.BufferBuilder;\nimport net.minecraft.client.render.Tessellator;\nimport net.minecraft.client.render.item.ItemRenderer;\nimport net.minecraft.item.ItemStack;\nimport org.spongepowered.asm.mixin.Mixin;\nimport org.spongepowered.asm.mixin.Shadow;\nimport org.spongepowered.asm.mixin.injection.At;\nimport org.spongepowered.asm.mixin.injection.Inject;\nimport org.spongepowered.asm.mixin.injection.callback.CallbackInfo;\n\n@Mixin(ItemRenderer.class)\npublic abstract class MixinItemRenderer {\n\n @Shadow protected abstract void renderGuiQuad(BufferBuilder buffer, int x, int y, int width, int height, int red, int green, int blue, int alpha);\n\n @Inject(\n method = \"renderGuiItemOverlay(Lnet/minecraft/client/font/TextRenderer;Lnet/minecraft/item/ItemStack;IILjava/lang/String;)V\",\n at = @At(\n value = \"INVOKE\",\n target = \"Lnet/minecraft/item/ItemStack;isItemBarVisible()Z\",\n shift = At.Shift.BEFORE\n )\n )\n private void indrev_renderModularArmorFluidTank(TextRenderer renderer, ItemStack stack, int x, int y, String countLabel, CallbackInfo ci) {\n if (stack.getItem() instanceof IRModularArmorItem armor && armor.isFluidItemBarVisible(stack)) {\n RenderSystem.disableDepthTest();\n RenderSystem.disableTexture();\n RenderSystem.disableBlend();\n Tessellator tessellator = Tessellator.getInstance();\n BufferBuilder bufferBuilder = tessellator.getBuffer();\n int i = armor.getFluidItemBarStep(stack);\n int j = armor.getFluidItemBarColor(stack);\n this.renderGuiQuad(bufferBuilder, x + 2, y + 11, 13, 2, 0, 0, 0, 255);\n this.renderGuiQuad(bufferBuilder, x + 2, y + 11, i, 1, j >> 16 & 255, j >> 8 & 255, j & 255, 255);\n RenderSystem.enableBlend();\n RenderSystem.enableTexture();\n RenderSystem.enableDepthTest();\n }\n }\n}\n"
},
{
"path": "src/main/java/me/steven/indrev/mixin/client/MixinLivingEntityClient.java",
"content": "package me.steven.indrev.mixin.client;\n\nimport me.steven.indrev.api.IRPlayerEntityExtension;\nimport me.steven.indrev.tools.modular.ArmorModule;\nimport net.minecraft.entity.LivingEntity;\nimport net.minecraft.entity.effect.StatusEffect;\nimport net.minecraft.entity.effect.StatusEffects;\nimport org.spongepowered.asm.mixin.Mixin;\nimport org.spongepowered.asm.mixin.injection.At;\nimport org.spongepowered.asm.mixin.injection.Inject;\nimport org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;\n\n@Mixin(LivingEntity.class)\npublic abstract class MixinLivingEntityClient {\n @Inject(method = \"hasStatusEffect\", at = @At(\"INVOKE\"), cancellable = true)\n private void indrev_nightVision(StatusEffect effect, CallbackInfoReturnable cir) {\n if (\n effect.equals(StatusEffects.NIGHT_VISION)\n && this instanceof IRPlayerEntityExtension\n && ((IRPlayerEntityExtension) this).isApplied(ArmorModule.NIGHT_VISION)\n ) {\n cir.setReturnValue(true);\n }\n }\n}\n"
},
{
"path": "src/main/java/me/steven/indrev/mixin/client/MixinMinecraftClient.java",
"content": "package me.steven.indrev.mixin.client;\n\nimport me.steven.indrev.gui.screenhandlers.IRGuiScreenHandler;\nimport me.steven.indrev.packets.client.GuiPropertySyncPacket;\nimport net.fabricmc.fabric.api.client.networking.v1.ClientPlayNetworking;\nimport net.fabricmc.fabric.api.networking.v1.PacketByteBufs;\nimport net.minecraft.client.MinecraftClient;\nimport net.minecraft.client.gui.screen.Screen;\nimport net.minecraft.client.gui.screen.ingame.ScreenHandlerProvider;\nimport net.minecraft.network.PacketByteBuf;\nimport net.minecraft.screen.ScreenHandler;\nimport org.spongepowered.asm.mixin.Mixin;\nimport org.spongepowered.asm.mixin.injection.At;\nimport org.spongepowered.asm.mixin.injection.Inject;\nimport org.spongepowered.asm.mixin.injection.callback.CallbackInfo;\n\n@Mixin(MinecraftClient.class)\npublic class MixinMinecraftClient {\n @Inject(method = \"setScreen\", at = @At(\"RETURN\"))\n private void indrev_requestProperties(Screen screen, CallbackInfo ci) {\n if (screen instanceof ScreenHandlerProvider provider) {\n ScreenHandler handler = provider.getScreenHandler();\n if (handler instanceof IRGuiScreenHandler) {\n PacketByteBuf buf = PacketByteBufs.create();\n buf.writeInt(handler.syncId);\n ClientPlayNetworking.send(GuiPropertySyncPacket.INSTANCE.getC2S_REQUEST_PROPERTIES(), buf);\n }\n }\n }\n}\n"
},
{
"path": "src/main/java/me/steven/indrev/mixin/client/MixinWItemSlot.java",
"content": "package me.steven.indrev.mixin.client;\n\nimport io.github.cottonmc.cotton.gui.client.BackgroundPainter;\nimport io.github.cottonmc.cotton.gui.widget.WItemSlot;\nimport org.jetbrains.annotations.Nullable;\nimport org.spongepowered.asm.mixin.Mixin;\nimport org.spongepowered.asm.mixin.Shadow;\nimport org.spongepowered.asm.mixin.injection.At;\nimport org.spongepowered.asm.mixin.injection.Inject;\nimport org.spongepowered.asm.mixin.injection.callback.CallbackInfo;\n\n@Mixin(value = WItemSlot.class, remap = false)\npublic class MixinWItemSlot {\n @Shadow @Nullable\n private BackgroundPainter backgroundPainter;\n\n @Inject(method = \"addPainters\", at = @At(\"HEAD\"), cancellable = true, remap = false)\n private void indrev_dontOverridePainters(CallbackInfo ci) {\n if (backgroundPainter != null) ci.cancel();\n }\n}\n"
},
{
"path": "src/main/java/me/steven/indrev/mixin/common/MixinAbstractCookingRecipe.java",
"content": "package me.steven.indrev.mixin.common;\n\nimport alexiil.mc.lib.attributes.fluid.volume.FluidVolume;\nimport me.steven.indrev.components.CraftingComponent;\nimport me.steven.indrev.recipes.machines.IRRecipe;\nimport me.steven.indrev.recipes.machines.entries.InputEntry;\nimport me.steven.indrev.recipes.machines.entries.OutputEntry;\nimport me.steven.indrev.utils.IRFluidTank;\nimport net.minecraft.item.ItemStack;\nimport net.minecraft.recipe.AbstractCookingRecipe;\nimport net.minecraft.recipe.Ingredient;\nimport net.minecraft.recipe.Recipe;\nimport net.minecraft.recipe.RecipeType;\nimport net.minecraft.util.Identifier;\nimport net.minecraft.util.collection.DefaultedList;\nimport org.jetbrains.annotations.NotNull;\nimport org.spongepowered.asm.mixin.Final;\nimport org.spongepowered.asm.mixin.Mixin;\nimport org.spongepowered.asm.mixin.Shadow;\nimport org.spongepowered.asm.mixin.injection.At;\nimport org.spongepowered.asm.mixin.injection.Inject;\nimport org.spongepowered.asm.mixin.injection.callback.CallbackInfo;\n\nimport java.util.Collections;\nimport java.util.List;\nimport java.util.Random;\n\n@Mixin(AbstractCookingRecipe.class)\npublic abstract class MixinAbstractCookingRecipe implements IRRecipe {\n\n @Shadow @Final protected Identifier id;\n\n @Shadow @Final protected int cookTime;\n\n @Shadow @Final protected ItemStack output;\n\n @Shadow @Final protected Ingredient input;\n\n private InputEntry[] indrev_inputEntries;\n\n private OutputEntry[] indrev_outputEntries;\n\n @Inject(method = \"\", at = @At(\"TAIL\"))\n private void a(RecipeType type, Identifier id, String group, Ingredient input, ItemStack output, float experience, int cookTime, CallbackInfo ci) {\n this.indrev_inputEntries = new InputEntry[] { new InputEntry(input, 1) };\n this.indrev_outputEntries = new OutputEntry[] { new OutputEntry(output, 1d) };\n }\n\n @NotNull\n @Override\n public Identifier getIdentifier() {\n return id;\n }\n\n @NotNull\n @Override\n public InputEntry @NotNull [] getInput() {\n return indrev_inputEntries;\n }\n\n @NotNull\n @Override\n public OutputEntry @NotNull [] getOutputs() {\n return indrev_outputEntries;\n }\n\n @Override\n public int getTicks() {\n return cookTime;\n }\n\n @Override\n public boolean matches(@NotNull List inv, @NotNull List fluidVolume) {\n return this.input.test(inv.get(0));\n }\n\n @NotNull\n @Override\n public List craft(Random random) {\n return Collections.singletonList(output.copy());\n }\n\n @NotNull\n @Override\n public Identifier getId() {\n return id;\n }\n\n @Override\n public boolean isIgnoredInRecipeBook() {\n return false;\n }\n\n @NotNull\n @Override\n public DefaultedList getIngredients() {\n DefaultedList defaultedList = DefaultedList.of();\n defaultedList.add(this.input);\n return defaultedList;\n }\n\n @Override\n public boolean isEmpty() {\n DefaultedList defaultedList = this.getIngredients();\n return defaultedList.isEmpty() || defaultedList.stream().anyMatch((ingredient) -> ingredient.getMatchingStacks().length == 0);\n }\n\n @Override\n public boolean canStart(@NotNull CraftingComponent component) {\n return component.fits(output);\n }\n}\n"
},
{
"path": "src/main/java/me/steven/indrev/mixin/common/MixinEnchantmentHelper.java",
"content": "package me.steven.indrev.mixin.common;\n\nimport me.steven.indrev.api.CustomEnchantmentProvider;\nimport me.steven.indrev.api.IRPlayerEntityExtension;\nimport me.steven.indrev.tools.modular.ArmorModule;\nimport net.minecraft.enchantment.Enchantment;\nimport net.minecraft.enchantment.EnchantmentHelper;\nimport net.minecraft.entity.EquipmentSlot;\nimport net.minecraft.entity.LivingEntity;\nimport net.minecraft.entity.player.PlayerEntity;\nimport net.minecraft.item.ItemStack;\nimport org.spongepowered.asm.mixin.Mixin;\nimport org.spongepowered.asm.mixin.injection.At;\nimport org.spongepowered.asm.mixin.injection.Inject;\nimport org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;\n\n@Mixin(EnchantmentHelper.class)\npublic class MixinEnchantmentHelper {\n @Inject(method = \"getLevel\", at = @At(\"HEAD\"), cancellable = true)\n private static void indrev_customEnchantProvider(Enchantment enchantment, ItemStack stack, CallbackInfoReturnable cir) {\n if (stack.getItem() instanceof CustomEnchantmentProvider) {\n int level = ((CustomEnchantmentProvider) stack.getItem()).getLevel(enchantment, stack);\n if (level > -1)\n cir.setReturnValue(level);\n }\n }\n\n @Inject(method = \"hasAquaAffinity\", at = @At(\"HEAD\"), cancellable = true)\n private static void indrev_waterAffinityChest(LivingEntity entity, CallbackInfoReturnable cir) {\n //specifically checks for water affinity on chestplate\n if (entity instanceof PlayerEntity player\n && ArmorModule.WATER_AFFINITY.getLevel(player.getInventory().getArmorStack(EquipmentSlot.CHEST.getEntitySlotId())) > 0\n && entity instanceof IRPlayerEntityExtension ext\n && ext.isApplied(ArmorModule.WATER_AFFINITY)\n )\n cir.setReturnValue(true);\n }\n\n @Inject(method = \"getDepthStrider\", at = @At(\"HEAD\"), cancellable = true)\n private static void indrev_waterAffinityLegs(LivingEntity entity, CallbackInfoReturnable cir) {\n //specifically checks for water affinity on leggings\n if (entity instanceof PlayerEntity player\n && ArmorModule.WATER_AFFINITY.getLevel(player.getInventory().getArmorStack(EquipmentSlot.LEGS.getEntitySlotId())) > 0\n && entity instanceof IRPlayerEntityExtension ext\n && ext.isApplied(ArmorModule.WATER_AFFINITY)\n )\n cir.setReturnValue(3);\n }\n}\n"
},
{
"path": "src/main/java/me/steven/indrev/mixin/common/MixinEntity.java",
"content": "package me.steven.indrev.mixin.common;\n\nimport me.steven.indrev.api.IREntityExtension;\nimport me.steven.indrev.api.IRPlayerEntityExtension;\nimport me.steven.indrev.inventories.IRInventory;\nimport me.steven.indrev.tools.modular.ArmorModule;\nimport net.minecraft.entity.Entity;\nimport net.minecraft.entity.ItemEntity;\nimport net.minecraft.item.ItemStack;\nimport net.minecraft.world.World;\nimport org.jetbrains.annotations.Nullable;\nimport org.spongepowered.asm.mixin.Mixin;\nimport org.spongepowered.asm.mixin.Shadow;\nimport org.spongepowered.asm.mixin.injection.At;\nimport org.spongepowered.asm.mixin.injection.Inject;\nimport org.spongepowered.asm.mixin.injection.callback.CallbackInfo;\nimport org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;\n\n@Mixin(Entity.class)\npublic abstract class MixinEntity implements IREntityExtension {\n @Shadow public World world;\n\n @Shadow public abstract double getX();\n\n @Shadow public abstract double getY();\n\n @Shadow public abstract double getZ();\n\n private IRInventory machineInv = null;\n\n @Inject(method = \"setAir\", at = @At(\"INVOKE\"), cancellable = true)\n private void indrev_breathingModule(CallbackInfo ci) {\n if (this instanceof IRPlayerEntityExtension && ((IRPlayerEntityExtension) this).isApplied(ArmorModule.BREATHING)) {\n ci.cancel();\n }\n }\n\n @Inject(method = \"getJumpVelocityMultiplier\", at = @At(value = \"RETURN\"), cancellable = true)\n private void indrev_jumpBoostModule(CallbackInfoReturnable cir) {\n if (this instanceof IRPlayerEntityExtension && ((IRPlayerEntityExtension) this).isApplied(ArmorModule.JUMP_BOOST)) {\n cir.setReturnValue((float) ((IRPlayerEntityExtension) this).getAppliedLevel(ArmorModule.JUMP_BOOST));\n }\n }\n\n @Inject(method = \"dropStack(Lnet/minecraft/item/ItemStack;F)Lnet/minecraft/entity/ItemEntity;\", at = @At(\"HEAD\"), cancellable = true)\n private void indrev_onDropItem(ItemStack stack, float yOffset, CallbackInfoReturnable cir) {\n if (!world.isClient && machineInv != null) {\n if (!machineInv.output(stack)) {\n ItemEntity itemEntity = new ItemEntity(world, getX(), getY() + yOffset, getZ(), stack);\n itemEntity.setToDefaultPickupDelay();\n this.world.spawnEntity(itemEntity);\n }\n cir.cancel();\n }\n }\n\n @Nullable\n @Override\n public IRInventory getMachineInv() {\n return machineInv;\n }\n\n @Override\n public void setMachineInv(IRInventory machineInv) {\n this.machineInv = machineInv;\n }\n}\n"
},
{
"path": "src/main/java/me/steven/indrev/mixin/common/MixinItemPredicate.java",
"content": "package me.steven.indrev.mixin.common;\n\nimport me.steven.indrev.api.CustomEnchantmentProvider;\nimport net.minecraft.item.ItemStack;\nimport net.minecraft.predicate.item.EnchantmentPredicate;\nimport net.minecraft.predicate.item.ItemPredicate;\nimport org.spongepowered.asm.mixin.Final;\nimport org.spongepowered.asm.mixin.Mixin;\nimport org.spongepowered.asm.mixin.Shadow;\nimport org.spongepowered.asm.mixin.injection.At;\nimport org.spongepowered.asm.mixin.injection.Inject;\nimport org.spongepowered.asm.mixin.injection.Slice;\nimport org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;\n\n@Mixin(ItemPredicate.class)\npublic class MixinItemPredicate {\n @Shadow @Final private EnchantmentPredicate[] enchantments;\n\n @Inject(\n method = \"test\",\n slice = @Slice(\n from = @At(value = \"INVOKE\", target = \"Lnet/minecraft/predicate/item/EnchantmentPredicate;test(Ljava/util/Map;)Z\")\n ),\n at = @At(value = \"RETURN\"),\n cancellable = true)\n private void indrev_customEnchantProvider(ItemStack stack, CallbackInfoReturnable cir) {\n if (stack.getItem() instanceof CustomEnchantmentProvider && enchantments.length > 0) {\n for (EnchantmentPredicate predicate : enchantments) {\n if (predicate.levels != null && predicate.enchantment != null) {\n int level = ((CustomEnchantmentProvider) stack.getItem()).getLevel(predicate.enchantment, stack);\n if (level > -1 && predicate.levels.test(level)) cir.setReturnValue(true);\n }\n }\n }\n }\n}\n"
},
{
"path": "src/main/java/me/steven/indrev/mixin/common/MixinItemStack.java",
"content": "package me.steven.indrev.mixin.common;\n\nimport com.google.common.collect.Multimap;\nimport me.steven.indrev.api.AttributeModifierProvider;\nimport me.steven.indrev.items.energy.IREnergyItem;\nimport net.minecraft.entity.EquipmentSlot;\nimport net.minecraft.entity.attribute.EntityAttribute;\nimport net.minecraft.entity.attribute.EntityAttributeModifier;\nimport net.minecraft.item.Item;\nimport net.minecraft.item.ItemStack;\nimport net.minecraft.server.network.ServerPlayerEntity;\nimport org.spongepowered.asm.mixin.Mixin;\nimport org.spongepowered.asm.mixin.Shadow;\nimport org.spongepowered.asm.mixin.injection.At;\nimport org.spongepowered.asm.mixin.injection.Inject;\nimport org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;\n\nimport java.util.Random;\n\n@Mixin(ItemStack.class)\npublic abstract class MixinItemStack {\n\n @Shadow public abstract Item getItem();\n\n @Inject(method = \"getAttributeModifiers\", at = @At(\"TAIL\"), cancellable = true)\n private void indrev_modifiableAttributeModifiers(EquipmentSlot equipmentSlot, CallbackInfoReturnable> cir) {\n ItemStack stack = (ItemStack) (Object) this;\n if (stack.getItem() instanceof AttributeModifierProvider) {\n cir.setReturnValue(((AttributeModifierProvider) stack.getItem()).getAttributeModifiers(stack, equipmentSlot));\n }\n }\n\n}\n"
},
{
"path": "src/main/java/me/steven/indrev/mixin/common/MixinLivingEntity.java",
"content": "package me.steven.indrev.mixin.common;\n\nimport net.minecraft.entity.Entity;\nimport net.minecraft.entity.EntityType;\nimport net.minecraft.entity.LivingEntity;\nimport net.minecraft.world.World;\nimport org.spongepowered.asm.mixin.Mixin;\nimport org.spongepowered.asm.mixin.injection.At;\nimport org.spongepowered.asm.mixin.injection.Inject;\nimport org.spongepowered.asm.mixin.injection.callback.CallbackInfo;\n\n@Mixin(LivingEntity.class)\npublic abstract class MixinLivingEntity extends Entity {\n\n public MixinLivingEntity(EntityType type, World world) {\n super(type, world);\n }\n\n /*\n @Inject(method = \"knockDownwards\", at = @At(\"HEAD\"), cancellable = true)\n private void indrev_waterAffinityDownwards(CallbackInfo ci) {\n this.setVelocity(this.getVelocity().add(0.0D, -0.03999999910593033D * 2, 0.0D));\n ci.cancel();\n }\n\n @Inject(method = \"swimUpward\", at = @At(\"HEAD\"), cancellable = true)\n private void indrev_waterAffinityUpwards(CallbackInfo ci) {\n this.setVelocity(this.getVelocity().add(0.0D, 0.03999999910593033D * 2, 0.0D));\n ci.cancel();\n }*/\n}\n"
},
{
"path": "src/main/java/me/steven/indrev/mixin/common/MixinPiglinBrain.java",
"content": "package me.steven.indrev.mixin.common;\n\nimport me.steven.indrev.api.IRPlayerEntityExtension;\nimport me.steven.indrev.tools.modular.ArmorModule;\nimport net.minecraft.entity.LivingEntity;\nimport net.minecraft.entity.mob.PiglinBrain;\nimport org.spongepowered.asm.mixin.Mixin;\nimport org.spongepowered.asm.mixin.injection.At;\nimport org.spongepowered.asm.mixin.injection.Inject;\nimport org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;\n\n@Mixin(PiglinBrain.class)\npublic class MixinPiglinBrain {\n @Inject(method = \"wearsGoldArmor\", at = @At(\"RETURN\"), cancellable = true)\n private static void indrev_hasPiglinTrickerModule(LivingEntity entity, CallbackInfoReturnable cir) {\n if (entity instanceof IRPlayerEntityExtension && ((IRPlayerEntityExtension) entity).isApplied(ArmorModule.PIGLIN_TRICKER)) {\n cir.setReturnValue(true);\n }\n }\n}\n"
},
{
"path": "src/main/java/me/steven/indrev/mixin/common/MixinPlayerEntity.java",
"content": "package me.steven.indrev.mixin.common;\n\nimport it.unimi.dsi.fastutil.objects.Object2IntMap;\nimport it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;\nimport me.steven.indrev.api.IRPlayerEntityExtension;\nimport me.steven.indrev.items.energy.IREnergyItem;\nimport me.steven.indrev.items.energy.IRGamerAxeItem;\nimport me.steven.indrev.tools.modular.ArmorModule;\nimport me.steven.indrev.utils.EnergyutilsKt;\nimport net.minecraft.block.BlockState;\nimport net.minecraft.entity.EntityType;\nimport net.minecraft.entity.LivingEntity;\nimport net.minecraft.entity.player.PlayerEntity;\nimport net.minecraft.entity.player.PlayerInventory;\nimport net.minecraft.item.Item;\nimport net.minecraft.item.ItemStack;\nimport net.minecraft.nbt.NbtCompound;\nimport net.minecraft.world.World;\nimport org.jetbrains.annotations.NotNull;\nimport org.spongepowered.asm.mixin.Mixin;\nimport org.spongepowered.asm.mixin.injection.At;\nimport org.spongepowered.asm.mixin.injection.Inject;\nimport org.spongepowered.asm.mixin.injection.callback.CallbackInfo;\nimport org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;\nimport team.reborn.energy.api.EnergyStorage;\n\nimport java.util.Iterator;\nimport java.util.Map;\n\n@Mixin(PlayerEntity.class)\npublic abstract class MixinPlayerEntity extends LivingEntity implements IRPlayerEntityExtension {\n\n private boolean indrev_regenerating = false;\n private double indrev_shield = 0.0;\n private final Object2IntMap appliedEffects = new Object2IntOpenHashMap<>();\n\n protected MixinPlayerEntity(EntityType entityType, World world) {\n super(entityType, world);\n }\n\n @Inject(method = \"getBlockBreakingSpeed\", at = @At(\"HEAD\"), cancellable = true)\n private void indrev_checkEnergyTool(BlockState block, CallbackInfoReturnable cir) {\n PlayerEntity player = (PlayerEntity) (Object) this;\n PlayerInventory inventory = player.getInventory();\n ItemStack itemStack = inventory.main.get(inventory.selectedSlot);\n Item item = itemStack.getItem();\n EnergyStorage itemIo = EnergyutilsKt.energyOf(itemStack);\n if (itemIo != null && item instanceof IREnergyItem) {\n long amount = itemIo.getAmount();\n if (item instanceof IRGamerAxeItem) {\n NbtCompound tag = itemStack.getOrCreateNbt();\n if (tag.contains(\"Active\") && !tag.getBoolean(\"Active\")) {\n cir.setReturnValue(0.2F);\n return;\n }\n }\n if (amount < 1) cir.setReturnValue(0.2F);\n }\n }\n\n @Inject(method = \"writeCustomDataToNbt\", at = @At(\"RETURN\"))\n private void indrev_writeShieldToPlayerTag(NbtCompound tag, CallbackInfo ci) {\n tag.putDouble(\"indrev:shield\", indrev_shield);\n }\n\n @Inject(method = \"readCustomDataFromNbt\", at = @At(\"RETURN\"))\n private void indrev_readShieldToPlayerTag(NbtCompound tag, CallbackInfo ci) {\n indrev_shield = tag.getDouble(\"indrev:shield\");\n }\n\n @Override\n public double getShieldDurability() {\n return indrev_shield;\n }\n\n @Override\n public void setShieldDurability(double shieldDurability) {\n this.indrev_shield = shieldDurability;\n }\n\n @Override\n public double getMaxShieldDurability() {\n Iterator iterator = getArmorItems().iterator();\n double shield = 0.0;\n while (iterator.hasNext()) {\n ItemStack next = iterator.next();\n shield += ArmorModule.PROTECTION.getLevel(next) * 25;\n }\n return shield;\n }\n\n\n @Override\n public @NotNull Map getAppliedModules() {\n return appliedEffects;\n }\n\n @Override\n public boolean isApplied(@NotNull ArmorModule module) {\n return appliedEffects.containsKey(module);\n }\n\n @Override\n public void applyModule(@NotNull ArmorModule module, int level) {\n appliedEffects.put(module, level);\n }\n\n @Override\n public int getAppliedLevel(@NotNull ArmorModule module) {\n return appliedEffects.getOrDefault(module, 0);\n }\n\n @Override\n public void setRegenerating(boolean isRegenerating) {\n this.indrev_regenerating = isRegenerating;\n }\n\n @Override\n public boolean isRegenerating() {\n return indrev_regenerating;\n }\n}\n"
},
{
"path": "src/main/java/me/steven/indrev/mixin/common/MixinPlayerInventory.java",
"content": "package me.steven.indrev.mixin.common;\n\nimport me.steven.indrev.items.armor.JetpackHandler;\nimport net.minecraft.entity.EquipmentSlot;\nimport net.minecraft.entity.player.PlayerEntity;\nimport net.minecraft.entity.player.PlayerInventory;\nimport net.minecraft.item.ItemStack;\nimport org.spongepowered.asm.mixin.Final;\nimport org.spongepowered.asm.mixin.Mixin;\nimport org.spongepowered.asm.mixin.Shadow;\nimport org.spongepowered.asm.mixin.injection.At;\nimport org.spongepowered.asm.mixin.injection.Inject;\nimport org.spongepowered.asm.mixin.injection.callback.CallbackInfo;\n\n@Mixin(PlayerInventory.class)\npublic abstract class MixinPlayerInventory {\n @Shadow public abstract ItemStack getArmorStack(int slot);\n\n @Shadow @Final public PlayerEntity player;\n\n @Inject(method = \"updateItems\", at = @At(\"TAIL\"))\n private void indrev_tickJetpack(CallbackInfo ci) {\n ItemStack armorStack = getArmorStack(EquipmentSlot.CHEST.getEntitySlotId());\n if (armorStack.getItem() instanceof JetpackHandler handler && handler.isUsable(armorStack)) {\n handler.tickJetpack(armorStack, player);\n }\n }\n}\n"
},
{
"path": "src/main/java/me/steven/indrev/mixin/common/MixinServerPlayerEntity.java",
"content": "package me.steven.indrev.mixin.common;\n\nimport com.mojang.authlib.GameProfile;\nimport io.netty.buffer.Unpooled;\nimport it.unimi.dsi.fastutil.objects.Object2IntMap;\nimport it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;\nimport me.steven.indrev.api.IRServerPlayerEntityExtension;\nimport me.steven.indrev.items.armor.IRModularArmorItem;\nimport me.steven.indrev.items.energy.IRPortableChargerItem;\nimport me.steven.indrev.packets.client.SyncAppliedModulesPacket;\nimport me.steven.indrev.tools.modular.ArmorModule;\nimport me.steven.indrev.utils.AccessorextensionsKt;\nimport me.steven.indrev.utils.EnergyutilsKt;\nimport me.steven.indrev.utils.HelperextensionsKt;\nimport net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking;\nimport net.minecraft.entity.ExperienceOrbEntity;\nimport net.minecraft.entity.ItemEntity;\nimport net.minecraft.entity.damage.DamageSource;\nimport net.minecraft.entity.player.HungerManager;\nimport net.minecraft.entity.player.PlayerEntity;\nimport net.minecraft.entity.player.PlayerInventory;\nimport net.minecraft.item.FoodComponent;\nimport net.minecraft.item.ItemStack;\nimport net.minecraft.network.PacketByteBuf;\nimport net.minecraft.server.network.ServerPlayerEntity;\nimport net.minecraft.server.world.ServerWorld;\nimport net.minecraft.sound.SoundCategory;\nimport net.minecraft.sound.SoundEvent;\nimport net.minecraft.sound.SoundEvents;\nimport net.minecraft.util.math.BlockPos;\nimport net.minecraft.util.math.Box;\nimport net.minecraft.util.math.Vec3d;\nimport net.minecraft.util.math.Vec3i;\nimport net.minecraft.world.World;\nimport org.spongepowered.asm.mixin.Mixin;\nimport org.spongepowered.asm.mixin.Shadow;\nimport org.spongepowered.asm.mixin.injection.At;\nimport org.spongepowered.asm.mixin.injection.Inject;\nimport org.spongepowered.asm.mixin.injection.ModifyVariable;\nimport org.spongepowered.asm.mixin.injection.callback.CallbackInfo;\nimport team.reborn.energy.api.EnergyStorage;\n\nimport java.util.List;\nimport java.util.Map;\n\n@Mixin(ServerPlayerEntity.class)\npublic abstract class MixinServerPlayerEntity extends PlayerEntity implements IRServerPlayerEntityExtension {\n\n @Shadow public abstract boolean isInvulnerableTo(DamageSource damageSource);\n\n @Shadow public abstract void playSound(SoundEvent event, SoundCategory category, float volume, float pitch);\n\n private int ticks = 0;\n private int lastDamageTick = 0;\n private float lastDmg = 0f;\n private double lastShield = 0.0;\n private final Object2IntMap oldAppliedModules = new Object2IntOpenHashMap<>();\n\n public MixinServerPlayerEntity(World world, BlockPos pos, float yaw, GameProfile profile) {\n super(world, pos, yaw, profile);\n }\n\n @Inject(method = \"tick\", at = @At(\"TAIL\"))\n private void indrev_applyEffects(CallbackInfo ci) {\n ticks++;\n\n if (ticks % 15 == 0) {\n applyArmorEffects();\n }\n indrev_tickMagnet();\n setShieldDurability(Math.min(getShieldDurability(), getMaxShieldDurability()));\n }\n\n @ModifyVariable(method = \"damage(Lnet/minecraft/entity/damage/DamageSource;F)Z\", at = @At(\"HEAD\"), argsOnly = true)\n private float indrev_absorbDamage(float amount, DamageSource source) {\n final float initial = amount;\n if (isInvulnerableTo(source)) return amount;\n if (lastDamageTick + 10 > ticks) {\n if (amount <= lastDmg)\n return 0f;\n amount = amount - lastDmg;\n }\n lastDamageTick = ticks;\n lastDmg = initial;\n if (shouldApplyToShield(source)) {\n float leftover = (float) applyDamageToShield(amount);\n if (amount > leftover)\n world.playSoundFromEntity(null, this, SoundEvents.BLOCK_CHAIN_BREAK, SoundCategory.PLAYERS, 1f, 0.0001f);\n return leftover;\n } else\n return amount;\n }\n\n @Inject(method = \"worldChanged\", at = @At(\"TAIL\"))\n private void indrev_syncOnDimChange(ServerWorld origin, CallbackInfo ci) {\n sync();\n AccessorextensionsKt.getFluidNetworkState(origin).onDimChange(this);\n AccessorextensionsKt.getItemNetworkState(origin).onDimChange(this);\n }\n\n private boolean shouldApplyToShield(DamageSource source) {\n if (source.equals(DamageSource.FALL)) return isApplied(ArmorModule.FEATHER_FALLING);\n else if (source.isFire()) return isApplied(ArmorModule.FIRE_RESISTANCE);\n else return !source.equals(DamageSource.STARVE) && !source.equals(DamageSource.DROWN);\n }\n\n private void applyArmorEffects() {\n ServerPlayerEntity player = (ServerPlayerEntity) (Object) this;\n PlayerInventory inventory = player.getInventory();\n getAppliedModules().clear();\n\n for (int i = 0; i < inventory.armor.size(); i++) {\n int cSlot = 36+i;\n ItemStack itemStack = inventory.getStack(cSlot);\n if (itemStack.getItem() instanceof IRModularArmorItem) {\n List modules = ((IRModularArmorItem) itemStack.getItem()).getInstalled(itemStack);\n for (ArmorModule module : modules) {\n int level = module.getLevel(itemStack);\n if (level <= 0) continue;\n switch (module) {\n case SPEED:\n case BREATHING:\n case JUMP_BOOST:\n case NIGHT_VISION:\n case FIRE_RESISTANCE:\n case PIGLIN_TRICKER:\n case FEATHER_FALLING:\n case WATER_AFFINITY:\n if (EnergyutilsKt.extract(inventory, cSlot, 20))\n applyModule(module, level);\n break;\n case AUTO_FEEDER:\n HungerManager hunger = player.getHungerManager();\n if (hunger.isNotFull()) {\n for (int slot = 0; slot <= inventory.size(); slot++) {\n ItemStack stack = inventory.getStack(slot);\n FoodComponent food = stack.getItem().getFoodComponent();\n if (food != null && !food.isAlwaysEdible() && !HelperextensionsKt.hasNegativeEffects(food) && food.getHunger() <= 20 - hunger.getFoodLevel() && EnergyutilsKt.extract(inventory, cSlot, 30)) {\n stack.finishUsing(world, player);\n player.eatFood(world, stack);\n }\n if (!hungerManager.isNotFull()) break;\n }\n }\n break;\n case CHARGER:\n IRPortableChargerItem.Companion.chargeItemsInInv(cSlot, player.getInventory());\n break;\n case SOLAR_PANEL:\n if (world.isDay() && world.isSkyVisible(player.getBlockPos().up(2))) {\n for (int x = 0; x < 4; x++) {\n EnergyutilsKt.insert(inventory, cSlot - x, 75L * level);\n }\n }\n break;\n case PROTECTION:\n if (ticks - 120 > lastDamageTick && getShieldDurability() < getMaxShieldDurability() && EnergyutilsKt.extract(inventory, cSlot, 30)) {\n regenerateShield();\n }\n break;\n default:\n break;\n }\n }\n }\n }\n }\n\n private void indrev_tickMagnet() {\n ServerPlayerEntity player = (ServerPlayerEntity) (Object) this;\n PlayerInventory inventory = player.getInventory();\n for (ItemStack itemStack : inventory.armor) {\n if (itemStack.getItem() instanceof IRModularArmorItem) {\n int level = ArmorModule.MAGNET.getLevel(itemStack);\n if (level > 0) {\n Vec3i offset = new Vec3i(8, 8, 8);\n Box area = new Box(getBlockPos().subtract(offset), getBlockPos().add(offset));\n Vec3d blockCenter = HelperextensionsKt.toVec3d(getBlockPos()).add(0.5, 0.5, 0.5);\n world.getOtherEntities(this, area, (entity) -> entity instanceof ItemEntity || entity instanceof ExperienceOrbEntity).forEach(entity -> {\n if ((entity instanceof ItemEntity itemEntity && !itemEntity.cannotPickup())\n || (entity instanceof ExperienceOrbEntity xpEntity && xpEntity.age > 40)) {\n Vec3d v = entity.getPos().relativize(blockCenter).normalize().multiply(0.2);\n entity.addVelocity(v.x, v.y, v.z);\n //applyModule(ArmorModule.MAGNET, 1);\n }\n });\n return;\n }\n }\n }\n //getAppliedModules().remove(ArmorModule.MAGNET);\n }\n\n private void regenerateShield() {\n setShieldDurability(Math.min(getShieldDurability() + 0.5, getMaxShieldDurability()));\n }\n\n private double applyDamageToShield(double damage) {\n double absorbed = Math.min(damage, getShieldDurability());\n setShieldDurability(getShieldDurability() - absorbed);\n return damage - absorbed;\n }\n\n @Override\n public boolean shouldSync() {\n return !oldAppliedModules.equals(getAppliedModules()) || lastShield != getShieldDurability();\n }\n\n @Override\n public void sync() {\n lastShield = getShieldDurability();\n oldAppliedModules.clear();\n oldAppliedModules.putAll(getAppliedModules());\n PacketByteBuf buf = new PacketByteBuf(Unpooled.buffer());\n Map appliedModules = getAppliedModules();\n buf.writeInt(appliedModules.size());\n appliedModules.forEach((module, level) -> {\n buf.writeInt(module.ordinal());\n buf.writeInt(level);\n });\n buf.writeDouble(getShieldDurability());\n buf.writeBoolean(ticks - 120 > lastDamageTick);\n ServerPlayNetworking.send((ServerPlayerEntity) (Object) this, SyncAppliedModulesPacket.INSTANCE.getSYNC_MODULE_PACKET(), buf);\n }\n\n @Override\n public boolean isRegenerating() {\n return ticks - 120 > lastDamageTick;\n }\n}"
},
{
"path": "src/main/java/me/steven/indrev/mixin/common/MixinServerWorld.java",
"content": "package me.steven.indrev.mixin.common;\n\nimport it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;\nimport me.steven.indrev.api.ServerWorldExtension;\nimport me.steven.indrev.networks.Network;\nimport me.steven.indrev.networks.NetworkState;\nimport me.steven.indrev.networks.ServoNetworkState;\nimport me.steven.indrev.networks.energy.EnergyNetwork;\nimport me.steven.indrev.networks.energy.EnergyNetworkState;\nimport me.steven.indrev.networks.fluid.FluidNetworkState;\nimport me.steven.indrev.networks.item.ItemNetworkState;\nimport net.fabricmc.fabric.api.lookup.v1.block.BlockApiCache;\nimport net.minecraft.server.world.ServerWorld;\nimport net.minecraft.util.math.Direction;\nimport net.minecraft.world.PersistentStateManager;\nimport org.jetbrains.annotations.NotNull;\nimport org.spongepowered.asm.mixin.Mixin;\nimport org.spongepowered.asm.mixin.Shadow;\nimport team.reborn.energy.api.EnergyStorage;\n\n@Mixin(ServerWorld.class)\npublic abstract class MixinServerWorld implements ServerWorldExtension {\n\n private final Long2ObjectOpenHashMap> indrev_energyIoCache = new Long2ObjectOpenHashMap<>();\n\n private ItemNetworkState indrev_itemNetworkState = null;\n private FluidNetworkState indrev_fluidNetworkState = null;\n private EnergyNetworkState indrev_energyNetworkState = null;\n\n @Shadow\n public abstract PersistentStateManager getPersistentStateManager();\n\n @NotNull\n @Override\n public Long2ObjectOpenHashMap> indrev_getEnergyCache() {\n return indrev_energyIoCache;\n }\n\n @NotNull\n @Override\n public EnergyNetworkState indrev_getEnergyNetworkState() {\n ServerWorld world = (ServerWorld) (Object) this;\n if (indrev_energyNetworkState == null) {\n indrev_energyNetworkState = getPersistentStateManager()\n .getOrCreate(\n nbt -> EnergyNetworkState.Companion.readNbt(nbt, () -> new EnergyNetworkState(world)),\n () -> new EnergyNetworkState(world),\n Network.Type.Companion.getENERGY().getKey());\n }\n return indrev_energyNetworkState;\n }\n\n @NotNull\n @Override\n public FluidNetworkState indrev_getFluidNetworkState() {\n ServerWorld world = (ServerWorld) (Object) this;\n if (indrev_fluidNetworkState == null) {\n indrev_fluidNetworkState = getPersistentStateManager()\n .getOrCreate(\n nbt -> ServoNetworkState.Companion.readNbt(nbt, () -> new FluidNetworkState(world)),\n () -> new FluidNetworkState(world),\n Network.Type.Companion.getFLUID().getKey());\n }\n return indrev_fluidNetworkState;\n }\n\n @NotNull\n @Override\n public ItemNetworkState indrev_getItemNetworkState() {\n ServerWorld world = (ServerWorld) (Object) this;\n if (indrev_itemNetworkState == null) {\n indrev_itemNetworkState = getPersistentStateManager()\n .getOrCreate(\n nbt -> ItemNetworkState.Companion.readNbt(nbt, () -> new ItemNetworkState(world)),\n () -> new ItemNetworkState(world),\n Network.Type.Companion.getITEM().getKey());\n }\n return indrev_itemNetworkState;\n }\n}\n"
},
{
"path": "src/main/kotlin/me/steven/indrev/IndustrialRevolution.kt",
"content": "package me.steven.indrev\n\nimport dev.cafeteria.fakeplayerapi.server.FakePlayerBuilder\nimport dev.cafeteria.fakeplayerapi.server.FakeServerPlayer\nimport me.steven.indrev.api.IRServerPlayerEntityExtension\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.config.IRConfig\nimport me.steven.indrev.datagen.DataGeneratorManager\nimport me.steven.indrev.events.common.IRLootTableCallback\nimport me.steven.indrev.gui.screenhandlers.COAL_GENERATOR_HANDLER\nimport me.steven.indrev.gui.screenhandlers.IRGuiScreenHandler\nimport me.steven.indrev.networks.NetworkEvents\nimport me.steven.indrev.packets.PacketRegistry\nimport me.steven.indrev.packets.client.SyncConfigPacket\nimport me.steven.indrev.recipes.SelfRemainderRecipe\nimport me.steven.indrev.recipes.machines.*\nimport me.steven.indrev.registry.*\nimport me.steven.indrev.utils.identifier\nimport net.fabricmc.api.ModInitializer\nimport net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientLifecycleEvents\nimport net.fabricmc.fabric.api.client.itemgroup.FabricItemGroupBuilder\nimport net.fabricmc.fabric.api.event.lifecycle.v1.ServerBlockEntityEvents\nimport net.fabricmc.fabric.api.event.lifecycle.v1.ServerLifecycleEvents\nimport net.fabricmc.fabric.api.event.lifecycle.v1.ServerTickEvents\nimport net.fabricmc.fabric.api.loot.v1.event.LootTableLoadingCallback\nimport net.fabricmc.fabric.api.networking.v1.ServerPlayConnectionEvents\nimport net.fabricmc.fabric.api.particle.v1.FabricParticleTypes\nimport net.fabricmc.fabric.impl.datagen.FabricDataGenHelper\nimport net.fabricmc.loader.api.FabricLoader\nimport net.minecraft.item.Item\nimport net.minecraft.item.ItemGroup\nimport net.minecraft.item.ItemStack\nimport net.minecraft.sound.SoundCategory\nimport net.minecraft.sound.SoundEvent\nimport net.minecraft.tag.TagKey\nimport net.minecraft.util.Identifier\nimport net.minecraft.util.registry.Registry\nimport org.apache.logging.log4j.LogManager\nimport org.apache.logging.log4j.Logger\n\nobject IndustrialRevolution : ModInitializer {\n override fun onInitialize() {\n\n //load the screenhandlers.kt class\n COAL_GENERATOR_HANDLER\n\n IRConfig\n IRItemRegistry.registerAll()\n IRBlockRegistry.registerAll()\n IRFluidRegistry.registerAll()\n\n Registry.register(Registry.SOUND_EVENT, LASER_SOUND_ID, LASER_SOUND_EVENT)\n Registry.register(Registry.PARTICLE_TYPE, identifier(\"laser_particle\"), LASER_PARTICLE)\n\n WorldGeneration.init()\n WorldGeneration.addFeatures()\n\n LootTableLoadingCallback.EVENT.register(IRLootTableCallback)\n\n MachineRegistry\n\n Registry.register(Registry.RECIPE_SERIALIZER, PulverizerRecipe.IDENTIFIER, PulverizerRecipe.SERIALIZER)\n Registry.register(Registry.RECIPE_TYPE, PulverizerRecipe.IDENTIFIER, PulverizerRecipe.TYPE)\n Registry.register(Registry.RECIPE_SERIALIZER, CompressorRecipe.IDENTIFIER, CompressorRecipe.SERIALIZER)\n Registry.register(Registry.RECIPE_TYPE, CompressorRecipe.IDENTIFIER, CompressorRecipe.TYPE)\n Registry.register(Registry.RECIPE_SERIALIZER, InfuserRecipe.IDENTIFIER, InfuserRecipe.SERIALIZER)\n Registry.register(Registry.RECIPE_TYPE, InfuserRecipe.IDENTIFIER, InfuserRecipe.TYPE)\n Registry.register(Registry.RECIPE_SERIALIZER, FluidInfuserRecipe.IDENTIFIER, FluidInfuserRecipe.SERIALIZER)\n Registry.register(Registry.RECIPE_TYPE, FluidInfuserRecipe.IDENTIFIER, FluidInfuserRecipe.TYPE)\n Registry.register(Registry.RECIPE_SERIALIZER, RecyclerRecipe.IDENTIFIER, RecyclerRecipe.SERIALIZER)\n Registry.register(Registry.RECIPE_TYPE, RecyclerRecipe.IDENTIFIER, RecyclerRecipe.TYPE)\n Registry.register(Registry.RECIPE_SERIALIZER, SmelterRecipe.IDENTIFIER, SmelterRecipe.SERIALIZER)\n Registry.register(Registry.RECIPE_TYPE, SmelterRecipe.IDENTIFIER, SmelterRecipe.TYPE)\n Registry.register(Registry.RECIPE_SERIALIZER, CondenserRecipe.IDENTIFIER, CondenserRecipe.SERIALIZER)\n Registry.register(Registry.RECIPE_TYPE, CondenserRecipe.IDENTIFIER, CondenserRecipe.TYPE)\n Registry.register(Registry.RECIPE_SERIALIZER, DistillerRecipe.IDENTIFIER, DistillerRecipe.SERIALIZER)\n Registry.register(Registry.RECIPE_TYPE, DistillerRecipe.IDENTIFIER, DistillerRecipe.TYPE)\n Registry.register(Registry.RECIPE_SERIALIZER, SawmillRecipe.IDENTIFIER, SawmillRecipe.SERIALIZER)\n Registry.register(Registry.RECIPE_TYPE, SawmillRecipe.IDENTIFIER, SawmillRecipe.TYPE)\n Registry.register(Registry.RECIPE_SERIALIZER, ModuleRecipe.IDENTIFIER, ModuleRecipe.SERIALIZER)\n Registry.register(Registry.RECIPE_TYPE, ModuleRecipe.IDENTIFIER, ModuleRecipe.TYPE)\n Registry.register(Registry.RECIPE_SERIALIZER, LaserRecipe.IDENTIFIER, LaserRecipe.SERIALIZER)\n Registry.register(Registry.RECIPE_TYPE, LaserRecipe.IDENTIFIER, LaserRecipe.TYPE)\n Registry.register(Registry.RECIPE_SERIALIZER, ElectrolysisRecipe.IDENTIFIER, ElectrolysisRecipe.SERIALIZER)\n Registry.register(Registry.RECIPE_TYPE, ElectrolysisRecipe.IDENTIFIER, ElectrolysisRecipe.TYPE)\n\n Registry.register(Registry.RECIPE_SERIALIZER, SelfRemainderRecipe.IDENTIFIER, SelfRemainderRecipe.SERIALIZER)\n\n PacketRegistry.registerServer()\n\n ServerTickEvents.END_WORLD_TICK.register(NetworkEvents)\n ServerBlockEntityEvents.BLOCK_ENTITY_LOAD.register(NetworkEvents)\n ServerLifecycleEvents.SERVER_STOPPING.register(NetworkEvents)\n\n ServerPlayConnectionEvents.JOIN.register { handler, _, _ ->\n val player = handler.player\n SyncConfigPacket.sendConfig(player)\n if (player is IRServerPlayerEntityExtension) {\n (player as IRServerPlayerEntityExtension).sync()\n }\n }\n\n ServerTickEvents.START_SERVER_TICK.register { server ->\n server.playerManager.playerList.forEach { player ->\n if (player is IRServerPlayerEntityExtension && player.shouldSync()) {\n player.sync()\n }\n }\n }\n\n ServerTickEvents.END_SERVER_TICK.register { server ->\n server.playerManager.playerList.forEach { player ->\n val currentScreenHandler = player.currentScreenHandler as? IRGuiScreenHandler ?: return@forEach\n currentScreenHandler.syncProperties()\n }\n }\n\n ServerLifecycleEvents.END_DATA_PACK_RELOAD.register { s, _, _ ->\n s.recipeManager.recipes.keys.filterIsInstance>().forEach { it.clearCache() }\n }\n\n if (FabricLoader.getInstance().getLaunchArguments(true).contains(\"-dataGen\")) {\n FabricDataGenHelper.run()\n ClientLifecycleEvents.CLIENT_STARTED.register(ClientLifecycleEvents.ClientStarted {\n DataGeneratorManager(\"indrev\").generate()\n })\n }\n LOGGER.info(\"Industrial Revolution has initialized.\")\n }\n\n val LOGGER: Logger = LogManager.getLogger(\"Industrial Revolution\")\n\n const val MOD_ID = \"indrev\"\n\n val MOD_GROUP: ItemGroup =\n FabricItemGroupBuilder.build(identifier(\"indrev_group\")) { ItemStack { MachineRegistry.PULVERIZER_REGISTRY.block(Tier.MK4).asItem() } }\n\n val COOLERS_TAG: TagKey- = TagKey.of(Registry.ITEM_KEY, identifier(\"coolers\"))\n val WRENCH_TAG: TagKey
- = TagKey.of(Registry.ITEM_KEY, Identifier(\"c:wrenches\"))\n val SCREWDRIVER_TAG: TagKey
- = TagKey.of(Registry.ITEM_KEY, Identifier(\"c:screwdrivers\"))\n val NIKOLITE_ORES: TagKey
- = TagKey.of(Registry.ITEM_KEY, Identifier(\"c:nikolite_ores\"))\n val TIN_ORES: TagKey
- = TagKey.of(Registry.ITEM_KEY, Identifier(\"c:tin_ores\"))\n val LEAD_ORES: TagKey
- = TagKey.of(Registry.ITEM_KEY, Identifier(\"c:lead_ores\"))\n val SILVER_ORES: TagKey
- = TagKey.of(Registry.ITEM_KEY, Identifier(\"c:silver_ores\"))\n val TUNGSTEN_ORES: TagKey
- = TagKey.of(Registry.ITEM_KEY, Identifier(\"c:tungsten_ores\"))\n val ANCIENT_DEBRIS_ORES: TagKey
- = TagKey.of(Registry.ITEM_KEY, Identifier(\"c:ancient_debris_ores\"))\n\n val LASER_SOUND_ID = identifier(\"laser\")\n val LASER_SOUND_EVENT = SoundEvent(LASER_SOUND_ID)\n val LASER_PARTICLE = FabricParticleTypes.simple()\n\n val FAKE_PLAYER_BUILDER = FakePlayerBuilder(identifier(\"default_fake_player\")) { builder, server, world, profile ->\n object : FakeServerPlayer(builder, server, world, profile) {\n override fun isCreative(): Boolean = false\n override fun isSpectator(): Boolean = false\n override fun playSound(sound: SoundEvent?, volume: Float, pitch: Float) {}\n override fun playSound(event: SoundEvent?, category: SoundCategory?, volume: Float, pitch: Float) {}\n }\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/IndustrialRevolutionClient.kt",
"content": "package me.steven.indrev\n\nimport it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap\nimport me.steven.indrev.api.OreDataCards\nimport me.steven.indrev.blockentities.GlobalStateController\nimport me.steven.indrev.blockentities.crafters.*\nimport me.steven.indrev.blockentities.miningrig.DrillBlockEntityRenderer\nimport me.steven.indrev.blockentities.farms.*\nimport me.steven.indrev.blockentities.generators.HeatGeneratorBlockEntityRenderer\nimport me.steven.indrev.blockentities.generators.SteamTurbineBlockEntity\nimport me.steven.indrev.blockentities.laser.CapsuleBlockEntityRenderer\nimport me.steven.indrev.blockentities.laser.LaserBlockEntityRenderer\nimport me.steven.indrev.blockentities.miningrig.MiningRigBlockEntityRenderer\nimport me.steven.indrev.blockentities.modularworkbench.ModularWorkbenchBlockEntityRenderer\nimport me.steven.indrev.blockentities.solarpowerplant.HeliostatBlockEntityRenderer\nimport me.steven.indrev.blockentities.storage.ChargePadBlockEntityRenderer\nimport me.steven.indrev.blockentities.storage.LazuliFluxContainerBlockEntityRenderer\nimport me.steven.indrev.blockentities.storage.TankBlockEntityRenderer\nimport me.steven.indrev.components.multiblock.MultiblockBlockEntityRenderer\nimport me.steven.indrev.config.IRConfig\nimport me.steven.indrev.events.client.*\nimport me.steven.indrev.fluids.FluidType\nimport me.steven.indrev.gui.IRInventoryScreen\nimport me.steven.indrev.gui.screenhandlers.*\nimport me.steven.indrev.gui.screenhandlers.pipes.PipeFilterScreen\nimport me.steven.indrev.networks.Network\nimport me.steven.indrev.networks.client.ClientNetworkState\nimport me.steven.indrev.packets.PacketRegistry\nimport me.steven.indrev.registry.*\nimport me.steven.indrev.events.client.IRWorldRenderer\nimport me.steven.indrev.utils.identifier\nimport net.fabricmc.api.ClientModInitializer\nimport net.fabricmc.fabric.api.`object`.builder.v1.client.model.FabricModelPredicateProviderRegistry\nimport net.fabricmc.fabric.api.blockrenderlayer.v1.BlockRenderLayerMap\nimport net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents\nimport net.fabricmc.fabric.api.client.item.v1.ItemTooltipCallback\nimport net.fabricmc.fabric.api.client.keybinding.v1.KeyBindingHelper\nimport net.fabricmc.fabric.api.client.model.ModelLoadingRegistry\nimport net.fabricmc.fabric.api.client.networking.v1.ClientPlayConnectionEvents\nimport net.fabricmc.fabric.api.client.particle.v1.ParticleFactoryRegistry\nimport net.fabricmc.fabric.api.client.rendering.v1.BlockEntityRendererRegistry\nimport net.fabricmc.fabric.api.client.rendering.v1.HudRenderCallback\nimport net.fabricmc.fabric.api.client.rendering.v1.LivingEntityFeatureRendererRegistrationCallback\nimport net.fabricmc.fabric.api.client.rendering.v1.TooltipComponentCallback\nimport net.fabricmc.fabric.api.client.rendering.v1.WorldRenderEvents\nimport net.fabricmc.fabric.api.client.screenhandler.v1.ScreenRegistry\nimport net.fabricmc.fabric.api.event.client.ClientSpriteRegistryCallback\nimport net.minecraft.client.option.KeyBinding\nimport net.minecraft.client.particle.FlameParticle\nimport net.minecraft.client.render.RenderLayer\nimport net.minecraft.client.util.InputUtil\nimport net.minecraft.item.ElytraItem\nimport net.minecraft.screen.PlayerScreenHandler\nimport org.lwjgl.glfw.GLFW\n\n@Suppress(\"UNCHECKED_CAST\")\nobject IndustrialRevolutionClient : ClientModInitializer {\n override fun onInitializeClient() {\n FluidType.WATER.registerReloadListener()\n FluidType.LAVA.registerReloadListener()\n FluidType.GAS.registerReloadListener()\n arrayOf(\n IRFluidRegistry.COOLANT_STILL,\n IRFluidRegistry.SULFURIC_ACID_STILL,\n IRFluidRegistry.TOXIC_MUD_STILL,\n IRFluidRegistry.STEAM_STILL\n ).forEach { it.registerRender(FluidType.WATER) }\n arrayOf(\n IRFluidRegistry.MOLTEN_NETHERITE_STILL,\n IRFluidRegistry.MOLTEN_IRON_STILL,\n IRFluidRegistry.MOLTEN_GOLD_STILL,\n IRFluidRegistry.MOLTEN_COPPER_STILL,\n IRFluidRegistry.MOLTEN_TIN_STILL,\n IRFluidRegistry.MOLTEN_LEAD_STILL,\n IRFluidRegistry.MOLTEN_SILVER_STILL\n ).forEach { it.registerRender(FluidType.LAVA) }\n arrayOf(\n IRFluidRegistry.HYDROGEN_STILL,\n IRFluidRegistry.OXYGEN_STILL,\n IRFluidRegistry.METHANE_STILL,\n ).forEach { it.registerRender(FluidType.GAS) }\n arrayOf(\n COAL_GENERATOR_HANDLER,\n SOLAR_GENERATOR_HANDLER,\n BIOMASS_GENERATOR_HANDLER,\n HEAT_GENERATOR_HANDLER,\n GAS_BURNING_GENERATOR_HANDLER,\n BATTERY_HANDLER,\n ELECTRIC_FURNACE_HANDLER,\n PULVERIZER_HANDLER,\n COMPRESSOR_HANDLER,\n SOLID_INFUSER_HANDLER,\n RECYCLER_HANDLER,\n CHOPPER_HANDLER,\n RANCHER_HANDLER,\n MINING_RIG_HANDLER,\n MODULAR_WORKBENCH_HANDLER,\n FISHER_HANDLER,\n SCREWDRIVER_HANDLER,\n SMELTER_HANDLER,\n CONDENSER_HANDLER,\n FLUID_INFUSER_HANDLER,\n FARMER_HANDLER,\n SLAUGHTER_HANDLER,\n SAWMILL_HANDLER,\n ELECTRIC_FURNACE_FACTORY_HANDLER,\n PULVERIZER_FACTORY_HANDLER,\n COMPRESSOR_FACTORY_HANDLER,\n SOLID_INFUSER_FACTORY_HANDLER,\n CABINET_HANDLER,\n DRILL_HANDLER,\n LASER_HANDLER,\n ELECTROLYTIC_SEPARATOR_HANDLER,\n STEAM_TURBINE_HANDLER,\n SOLAR_POWER_PLANT_TOWER_HANDLER,\n DATA_CARD_WRITER_HANDLER,\n PUMP_HANDLER\n ).forEach { handler ->\n ScreenRegistry.register(handler) { controller, inv, _ -> IRInventoryScreen(controller, inv.player) }\n }\n ScreenRegistry.register(PIPE_FILTER_HANDLER) { controller, inv, _ -> PipeFilterScreen(controller, inv.player) }\n\n MachineRegistry.CHOPPER_REGISTRY.registerBlockEntityRenderer(::ChopperBlockEntityRenderer)\n MachineRegistry.RANCHER_REGISTRY.registerBlockEntityRenderer(::AOEMachineBlockEntityRenderer)\n MachineRegistry.FARMER_REGISTRY.registerBlockEntityRenderer(::AOEMachineBlockEntityRenderer)\n MachineRegistry.SLAUGHTER_REGISTRY.registerBlockEntityRenderer(::AOEMachineBlockEntityRenderer)\n MachineRegistry.MODULAR_WORKBENCH_REGISTRY.registerBlockEntityRenderer(::ModularWorkbenchBlockEntityRenderer)\n MachineRegistry.CHARGE_PAD_REGISTRY.registerBlockEntityRenderer(::ChargePadBlockEntityRenderer)\n MachineRegistry.CONDENSER_REGISTRY.registerBlockEntityRenderer(::CondenserBlockEntityRenderer)\n MachineRegistry.FLUID_INFUSER_REGISTRY.registerBlockEntityRenderer(::FluidInfuserBlockEntityRenderer)\n MachineRegistry.SOLID_INFUSER_FACTORY_REGISTRY.registerBlockEntityRenderer { MultiblockBlockEntityRenderer { be -> be.multiblockComponent!! } }\n MachineRegistry.COMPRESSOR_FACTORY_REGISTRY.registerBlockEntityRenderer { MultiblockBlockEntityRenderer { be -> be.multiblockComponent!! } }\n MachineRegistry.PULVERIZER_FACTORY_REGISTRY.registerBlockEntityRenderer { MultiblockBlockEntityRenderer { be -> be.multiblockComponent!! } }\n MachineRegistry.ELECTRIC_FURNACE_FACTORY_REGISTRY.registerBlockEntityRenderer { MultiblockBlockEntityRenderer { be -> be.multiblockComponent!! } }\n MachineRegistry.MINING_RIG_REGISTRY.registerBlockEntityRenderer(::MiningRigBlockEntityRenderer)\n MachineRegistry.PUMP_REGISTRY.registerBlockEntityRenderer(::PumpBlockEntityRenderer)\n MachineRegistry.LAZULI_FLUX_CONTAINER_REGISTRY.registerBlockEntityRenderer(::LazuliFluxContainerBlockEntityRenderer)\n MachineRegistry.HEAT_GENERATOR_REGISTRY.registerBlockEntityRenderer(::HeatGeneratorBlockEntityRenderer)\n MachineRegistry.LASER_EMITTER_REGISTRY.registerBlockEntityRenderer(::LaserBlockEntityRenderer)\n MachineRegistry.STEAM_TURBINE_REGISTRY.registerBlockEntityRenderer { MultiblockBlockEntityRenderer { be -> be.multiblockComponent!! } }\n BlockEntityRendererRegistry.register(IRBlockRegistry.TANK_BLOCK_ENTITY) { TankBlockEntityRenderer() }\n BlockEntityRendererRegistry.register(IRBlockRegistry.DRILL_BLOCK_ENTITY_TYPE) { DrillBlockEntityRenderer() }\n BlockEntityRendererRegistry.register(IRBlockRegistry.CAPSULE_BLOCK_ENTITY) { CapsuleBlockEntityRenderer() }\n BlockEntityRendererRegistry.register(IRBlockRegistry.BIOMASS_COMPOSTER_BLOCK_ENTITY) { BiomassComposterBlockEntityRenderer() }\n BlockEntityRendererRegistry.register(IRBlockRegistry.SOLAR_POWER_PLANT_TOWER_BLOCK_ENTITY) { MultiblockBlockEntityRenderer { be -> be.multiblockComponent } }\n BlockEntityRendererRegistry.register(IRBlockRegistry.HELIOSTAT_BLOCK_ENTITY) { HeliostatBlockEntityRenderer() }\n\n MachineRegistry.MODULAR_WORKBENCH_REGISTRY.setRenderLayer(RenderLayer.getTranslucent())\n MachineRegistry.PUMP_REGISTRY.setRenderLayer(RenderLayer.getTranslucent())\n MachineRegistry.HEAT_GENERATOR_REGISTRY.setRenderLayer(RenderLayer.getCutout())\n BlockRenderLayerMap.INSTANCE.putBlock(IRBlockRegistry.TANK_BLOCK, RenderLayer.getCutout())\n BlockRenderLayerMap.INSTANCE.putBlock(IRBlockRegistry.SULFUR_CRYSTAL_CLUSTER, RenderLayer.getTranslucent())\n BlockRenderLayerMap.INSTANCE.putBlock(IRBlockRegistry.DRILL_TOP, RenderLayer.getCutout())\n BlockRenderLayerMap.INSTANCE.putBlock(IRBlockRegistry.DRILL_MIDDLE, RenderLayer.getCutout())\n BlockRenderLayerMap.INSTANCE.putBlock(IRBlockRegistry.DRILL_BOTTOM, RenderLayer.getCutout())\n BlockRenderLayerMap.INSTANCE.putBlock(IRBlockRegistry.CAPSULE_BLOCK, RenderLayer.getCutout())\n\n BlockRenderLayerMap.INSTANCE.putBlock(IRBlockRegistry.CABLE_MK1, RenderLayer.getCutout())\n BlockRenderLayerMap.INSTANCE.putBlock(IRBlockRegistry.CABLE_MK2, RenderLayer.getCutout())\n BlockRenderLayerMap.INSTANCE.putBlock(IRBlockRegistry.CABLE_MK3, RenderLayer.getCutout())\n BlockRenderLayerMap.INSTANCE.putBlock(IRBlockRegistry.CABLE_MK4, RenderLayer.getCutout())\n\n ModelLoadingRegistry.INSTANCE.registerModelProvider(IRModelManagers)\n ModelLoadingRegistry.INSTANCE.registerVariantProvider { IRModelManagers }\n\n FabricModelPredicateProviderRegistry.register(\n IRItemRegistry.GAMER_AXE_ITEM,\n identifier(\"activate\")\n ) { stack, _, _, _ -> stack?.orCreateNbt?.getFloat(\"Progress\") ?: 0f }\n\n FabricModelPredicateProviderRegistry.register(IRItemRegistry.REINFORCED_ELYTRA, identifier(\"broken\")) { stack, _, _, _ ->\n if (ElytraItem.isUsable(stack)) 0.0f else 1.0f\n }\n\n FabricModelPredicateProviderRegistry.register(IRItemRegistry.ORE_DATA_CARD, identifier(\"empty\")) { stack, _, _, _ ->\n if (OreDataCards.readNbt(stack) == null) 0.0f else 1.0f\n }\n\n PacketRegistry.registerClient()\n\n GlobalStateController.initClient()\n\n\n HudRenderCallback.EVENT.register(IRHudRenderCallback)\n WorldRenderEvents.BEFORE_BLOCK_OUTLINE.register(IRWorldRenderer)\n WorldRenderEvents.BEFORE_ENTITIES.register(MatterProjectorPreviewRenderer)\n\n ClientTickEvents.END_CLIENT_TICK.register(IRClientTickEvents)\n\n ClientSpriteRegistryCallback.event(PlayerScreenHandler.BLOCK_ATLAS_TEXTURE).register(\n ClientSpriteRegistryCallback { _, registry ->\n registry.register(identifier(\"block/lazuli_flux_container_lf_level\"))\n registry.register(identifier(\"gui/hud_damaged\"))\n registry.register(identifier(\"gui/hud_regenerating\"))\n registry.register(identifier(\"gui/hud_warning\"))\n registry.register(identifier(\"gui/hud_default\"))\n registry.register(identifier(\"particle/laser_particle_1\"))\n registry.register(identifier(\"particle/laser_particle_2\"))\n registry.register(identifier(\"particle/laser_particle_3\"))\n })\n\n ParticleFactoryRegistry.getInstance().register(IndustrialRevolution.LASER_PARTICLE) { spriteProvider ->\n FlameParticle.Factory(spriteProvider)\n }\n\n ClientPlayConnectionEvents.DISCONNECT.register { _, _ ->\n IRConfig.readConfigs()\n }\n\n LivingEntityFeatureRendererRegistrationCallback.EVENT.register(IRLivingEntityFeatureRendererCallback)\n TooltipComponentCallback.EVENT.register(IRTooltipComponentsCallback)\n ItemTooltipCallback.EVENT.register(MiningRigInfoTooltipCallback)\n\n AprilFools.init()\n }\n\n val MODULAR_CONTROLLER_KEYBINDING: KeyBinding = KeyBindingHelper.registerKeyBinding(\n KeyBinding(\n \"key.indrev.modular\",\n InputUtil.Type.KEYSYM,\n GLFW.GLFW_KEY_K,\n \"category.indrev\"\n )\n )\n\n val GAMER_AXE_TOGGLE_KEYBINDING: KeyBinding = KeyBindingHelper.registerKeyBinding(\n KeyBinding(\n \"key.indrev.gamer_axe_toggle\",\n InputUtil.Type.KEYSYM,\n GLFW.GLFW_KEY_G,\n \"category.indrev\"\n )\n )\n\n val CLIENT_NETWORK_STATE = Object2ObjectOpenHashMap, ClientNetworkState<*>>()\n}\n"
},
{
"path": "src/main/kotlin/me/steven/indrev/api/AttributeModifierProvider.kt",
"content": "package me.steven.indrev.api\n\nimport com.google.common.collect.Multimap\nimport net.minecraft.entity.EquipmentSlot\nimport net.minecraft.entity.attribute.EntityAttribute\nimport net.minecraft.entity.attribute.EntityAttributeModifier\nimport net.minecraft.item.ItemStack\n\ninterface AttributeModifierProvider {\n fun getAttributeModifiers(itemStack: ItemStack, equipmentSlot: EquipmentSlot): Multimap\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/api/CustomEnchantmentProvider.kt",
"content": "package me.steven.indrev.api\n\nimport net.minecraft.enchantment.Enchantment\nimport net.minecraft.item.ItemStack\n\ninterface CustomEnchantmentProvider {\n fun getLevel(enchantment: Enchantment, itemStack: ItemStack): Int\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/api/IREntityExtension.kt",
"content": "package me.steven.indrev.api\n\nimport me.steven.indrev.inventories.IRInventory\n\ninterface IREntityExtension {\n var machineInv: IRInventory?\n\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/api/IRPlayerEntityExtension.kt",
"content": "package me.steven.indrev.api\n\nimport me.steven.indrev.tools.modular.ArmorModule\n\ninterface IRPlayerEntityExtension {\n\n var shieldDurability: Double\n var isRegenerating: Boolean\n\n fun getMaxShieldDurability(): Double\n\n fun getAppliedModules(): Map\n fun applyModule(module: ArmorModule, level: Int)\n fun isApplied(module: ArmorModule): Boolean\n fun getAppliedLevel(module: ArmorModule): Int\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/api/IRServerPlayerEntityExtension.kt",
"content": "package me.steven.indrev.api\n\ninterface IRServerPlayerEntityExtension : IRPlayerEntityExtension {\n fun shouldSync(): Boolean\n fun sync()\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/api/OreDataCards.kt",
"content": "package me.steven.indrev.api\n\nimport me.steven.indrev.config.IRConfig\nimport me.steven.indrev.registry.IRItemRegistry\nimport net.minecraft.item.Item\nimport net.minecraft.item.ItemStack\nimport net.minecraft.item.Items\nimport net.minecraft.nbt.NbtCompound\nimport net.minecraft.nbt.NbtList\nimport net.minecraft.tag.TagKey\nimport net.minecraft.util.Identifier\nimport net.minecraft.util.registry.Registry\nimport java.util.*\nimport kotlin.math.pow\n\nobject OreDataCards {\n\n const val MAX_SIZE = 2048\n const val MAX_RICNHESS = 1.0\n const val MAX_PER_CYCLE = 8\n\n val INVALID_DATA = Data(emptyList(), mutableMapOf(), -1.0, -1, -1, -1, -1, -1)\n\n fun isAllowed(stack: ItemStack): Boolean {\n return IRConfig.miningRigConfig.allowedTags.any { stack.isIn(TagKey.of(Registry.ITEM_KEY, Identifier(it.key))) }\n }\n\n fun getCost(stack: ItemStack): Int {\n return IRConfig.miningRigConfig.allowedTags.firstNotNullOfOrNull { if (stack.isIn(TagKey.of(Registry.ITEM_KEY, Identifier(it.key)))) it.value else null } ?: 0\n }\n\n fun readNbt(stack: ItemStack): Data? {\n if (!stack.isOf(IRItemRegistry.ORE_DATA_CARD)) return null\n val nbt = stack.getSubNbt(\"CardData\") ?: return null\n\n val entriesNbt = nbt.getList(\"Entries\", 10)\n val entries = mutableListOf()\n entriesNbt.forEach { element ->\n val itemId = (element as NbtCompound).getString(\"ItemId\")\n val optional = Registry.ITEM.getOrEmpty(Identifier(itemId))\n if (!optional.isPresent) {\n return INVALID_DATA\n }\n\n val count = element.getInt(\"Count\")\n entries.add(OreEntry(optional.get(), count))\n }\n\n val modifiersNbt = nbt.getList(\"ModifiersUsed\", 10)\n val modifiers = mutableMapOf()\n modifiersNbt.forEach { element ->\n val modifierId = (element as NbtCompound).getInt(\"Modifier\")\n val level = element.getInt(\"Level\")\n modifiers[Modifier.values()[modifierId]] = level\n }\n\n val richness = nbt.getDouble(\"Richness\")\n val size = nbt.getInt(\"Size\")\n val used = nbt.getInt(\"Used\")\n val speed = nbt.getInt(\"Speed\")\n val rng = nbt.getInt(\"Rng\")\n val energy = nbt.getInt(\"Energy\")\n\n return Data(entries.toList(), modifiers, richness, speed, rng, energy, size, used)\n }\n\n fun writeNbt(stack: ItemStack, data: Data) {\n if (!stack.isOf(IRItemRegistry.ORE_DATA_CARD)) return\n val nbt = stack.getOrCreateSubNbt(\"CardData\")\n\n val entriesNbt = NbtList()\n data.entries.forEach { entry ->\n val entryNbt = NbtCompound()\n entryNbt.putString(\"ItemId\", Registry.ITEM.getId(entry.item).toString())\n entryNbt.putInt(\"Count\", entry.count)\n entriesNbt.add(entryNbt)\n }\n nbt.put(\"Entries\", entriesNbt)\n\n val modifiersNbt = NbtList()\n data.modifiersUsed.forEach { (modifier, level) ->\n val modifierNbt = NbtCompound()\n modifierNbt.putInt(\"Modifier\", modifier.ordinal)\n modifierNbt.putInt(\"Level\", level)\n modifiersNbt.add(modifierNbt)\n }\n nbt.put(\"ModifiersUsed\", modifiersNbt)\n\n nbt.putDouble(\"Richness\", data.richness)\n nbt.putInt(\"Size\", data.maxCycles)\n nbt.putInt(\"Used\", data.used)\n nbt.putInt(\"Speed\", data.speed)\n nbt.putInt(\"Rng\", data.rng)\n nbt.putInt(\"Energy\", data.energyRequired)\n }\n\n data class Data(val entries: List, val modifiersUsed: MutableMap, val richness: Double, val speed: Int, val rng: Int, val energyRequired: Int, val maxCycles: Int, var used: Int) {\n fun isValid(): Boolean {\n return this != INVALID_DATA && entries.isNotEmpty() && richness > 0 && maxCycles > 0 && maxCycles < MAX_SIZE\n }\n\n fun isEmpty(): Boolean {\n return used >= maxCycles\n }\n\n fun pickRandom(random: Random): Item {\n entries.forEach { entry ->\n entry.order = -random.nextFloat().pow(1.0f / entry.count.toFloat())\n }\n return entries.minByOrNull { a -> a.order }!!.item\n }\n }\n\n data class OreEntry(val item: Item, val count: Int, var order: Float = 0.0f)\n\n enum class Modifier(val item: Item) {\n RICHNESS(IRItemRegistry.ENRICHED_NIKOLITE_DUST()),\n SPEED(Items.REDSTONE),\n SIZE(Items.STONE),\n RNG(Items.EMERALD);\n\n val translationKey = \"item.indrev.ore_data_card.modifier.${name.lowercase()}\"\n\n companion object {\n fun isModifierItem(item: Item): Boolean = values().any { it.item == item }\n\n fun byItem(item: Item): Modifier? = values().firstOrNull { it.item == item }\n }\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/api/ServerWorldExtension.kt",
"content": "package me.steven.indrev.api\n\nimport it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap\nimport me.steven.indrev.networks.energy.EnergyNetworkState\nimport me.steven.indrev.networks.fluid.FluidNetworkState\nimport me.steven.indrev.networks.item.ItemNetworkState\nimport net.fabricmc.fabric.api.lookup.v1.block.BlockApiCache\nimport net.minecraft.util.math.Direction\nimport team.reborn.energy.api.EnergyStorage\n\ninterface ServerWorldExtension {\n fun indrev_getEnergyCache(): Long2ObjectOpenHashMap>\n\n fun indrev_getEnergyNetworkState(): EnergyNetworkState\n\n fun indrev_getFluidNetworkState(): FluidNetworkState\n\n fun indrev_getItemNetworkState(): ItemNetworkState\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/api/machines/Tier.kt",
"content": "package me.steven.indrev.api.machines\n\nenum class Tier(val io: Long, val id: String) {\n MK1(64, \"mk1\"),\n MK2(128, \"mk2\"),\n MK3(512, \"mk3\"),\n MK4(4096, \"mk4\"),\n CREATIVE(4096, \"creative\");\n\n fun next(): Tier {\n return when (this) {\n MK1 -> MK2\n MK2 -> MK3\n MK3 -> MK4\n else -> error(\"no tier after $this\")\n }\n }\n\n companion object {\n val VALUES = arrayOf(MK1, MK2, MK3, MK4)\n\n val ALL_VALUES = values()\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/api/machines/TransferMode.kt",
"content": "package me.steven.indrev.api.machines\n\nenum class TransferMode(val rgb: Long, val input: Boolean, val output: Boolean) {\n INPUT(0x997e75ff, true, false),\n INPUT_FIRST(0x9975ff8e, true, false),\n INPUT_SECOND(0x9975ff8e, true, false),\n OUTPUT_FIRST(0x9975ff8e, false, true),\n OUTPUT_SECOND(0x9975ff8e, false, true),\n OUTPUT(0x99ffb175, false, true),\n INPUT_OUTPUT(0x99d875ff, true, true),\n NONE(-1, false, false);\n\n fun next(): TransferMode = when (this) {\n INPUT -> INPUT_FIRST\n INPUT_FIRST -> INPUT_SECOND\n INPUT_SECOND -> OUTPUT_FIRST\n OUTPUT_FIRST -> OUTPUT_SECOND\n OUTPUT_SECOND -> OUTPUT\n OUTPUT -> INPUT_OUTPUT\n INPUT_OUTPUT -> NONE\n NONE -> INPUT\n }\n\n fun next(available: Array): TransferMode {\n var current = this\n for (i in values().indices) {\n val possible = current.next()\n if (available.contains(possible)) {\n return possible\n }\n current = possible\n }\n return this\n }\n\n companion object {\n val DEFAULT = arrayOf(INPUT, OUTPUT, INPUT_OUTPUT, NONE)\n val SOLID_INFUSER = arrayOf(INPUT, OUTPUT, INPUT_OUTPUT, INPUT_FIRST, INPUT_SECOND, NONE)\n val ELECTROLYTIC_SEPARATOR = arrayOf(TransferMode.INPUT, TransferMode.OUTPUT_FIRST, TransferMode.OUTPUT_SECOND, TransferMode.NONE)\n }\n\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/api/sideconfigs/Configurable.kt",
"content": "package me.steven.indrev.api.sideconfigs\n\nimport me.steven.indrev.api.machines.TransferMode\nimport net.minecraft.block.BlockState\nimport net.minecraft.util.math.Direction\n\ninterface Configurable {\n fun isConfigurable(type: ConfigurationType): Boolean\n fun isFixed(type: ConfigurationType): Boolean\n fun getValidConfigurations(type: ConfigurationType): Array\n fun getCurrentConfiguration(type: ConfigurationType): SideConfiguration\n fun applyDefault(state: BlockState, type: ConfigurationType, configuration: MutableMap)\n\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/api/sideconfigs/ConfigurationType.kt",
"content": "package me.steven.indrev.api.sideconfigs\n\nimport me.steven.indrev.api.machines.TransferMode\nimport net.minecraft.text.Text\nimport net.minecraft.text.TranslatableText\n\nenum class ConfigurationType(val title: Text, vararg val validModes: TransferMode) {\n ITEM(TranslatableText(\"item.indrev.wrench.item\"), TransferMode.INPUT, TransferMode.OUTPUT, TransferMode.INPUT_OUTPUT, TransferMode.INPUT_FIRST, TransferMode.INPUT_SECOND, TransferMode.NONE),\n FLUID(TranslatableText(\"item.indrev.wrench.fluid\"), TransferMode.INPUT, TransferMode.OUTPUT, TransferMode.INPUT_OUTPUT, TransferMode.NONE),\n ENERGY(TranslatableText(\"item.indrev.wrench.energy\"), TransferMode.INPUT, TransferMode.OUTPUT, TransferMode.NONE);\n\n fun next(): ConfigurationType {\n return when (this) {\n ITEM -> FLUID\n FLUID -> ENERGY\n ENERGY -> ITEM\n }\n }\n\n fun next(available: Array): ConfigurationType {\n var current = this\n for (i in values().indices) {\n val possible = current.next()\n if (available.contains(possible)) {\n return possible\n }\n current = possible\n }\n return this\n }\n\n companion object {\n fun getTypes(blockEntity: Configurable) = values().filter { type -> blockEntity.isConfigurable(type) && !blockEntity.isFixed(type) }.toTypedArray()\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/api/sideconfigs/SideConfiguration.kt",
"content": "package me.steven.indrev.api.sideconfigs\n\nimport io.github.cottonmc.cotton.gui.widget.WGridPanel\nimport io.github.cottonmc.cotton.gui.widget.WToggleButton\nimport io.github.cottonmc.cotton.gui.widget.WWidget\nimport io.netty.buffer.Unpooled\nimport me.steven.indrev.api.machines.TransferMode\nimport me.steven.indrev.blocks.machine.FacingMachineBlock\nimport me.steven.indrev.blocks.machine.HorizontalFacingMachineBlock\nimport me.steven.indrev.gui.widgets.machines.WMachineSideDisplay\nimport me.steven.indrev.packets.common.ConfigureIOPackets\nimport me.steven.indrev.utils.add\nimport net.fabricmc.fabric.api.client.networking.v1.ClientPlayNetworking\nimport net.minecraft.entity.player.PlayerInventory\nimport net.minecraft.nbt.NbtCompound\nimport net.minecraft.network.PacketByteBuf\nimport net.minecraft.text.TranslatableText\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.math.Direction\nimport net.minecraft.world.World\nimport java.util.*\nimport java.util.function.Consumer\n\ndata class SideConfiguration(val type: ConfigurationType, private val transferConfig: EnumMap = EnumMap(Direction::class.java))\n : MutableMap by transferConfig {\n\n var autoPush = true\n var autoPull = true\n\n init {\n Direction.values().forEach { dir -> this[dir] = TransferMode.NONE }\n }\n\n fun canInput(direction: Direction): Boolean {\n return this[direction]?.input == true\n }\n\n fun canOutput(direction: Direction): Boolean {\n return this[direction]?.output == true\n }\n\n fun writeNbt(tag: NbtCompound?) {\n var transferConfigTag = tag?.getCompound(\"TransferConfig\")\n if (tag?.contains(\"TransferConfig\") == false) {\n transferConfigTag = NbtCompound()\n tag.put(\"TransferConfig\", transferConfigTag)\n }\n val configTag = NbtCompound()\n forEach { (dir, mode) ->\n configTag.putString(dir.toString(), mode.toString())\n }\n transferConfigTag?.put(type.toString().lowercase(Locale.getDefault()), configTag)\n configTag.putBoolean(\"AutoPush\", autoPush)\n configTag.putBoolean(\"AutoPull\", autoPull)\n }\n\n fun readNbt(tag: NbtCompound?) {\n if (tag?.contains(\"TransferConfig\") == true) {\n val transferConfigTag = tag.getCompound(\"TransferConfig\")\n val configTag = transferConfigTag.getCompound(type.toString().lowercase(Locale.getDefault()))\n Direction.values().forEach { dir ->\n val value = configTag.getString(dir.toString()).uppercase(Locale.getDefault())\n if (value.isNotEmpty()) {\n val mode = TransferMode.valueOf(value)\n this[dir] = mode\n }\n }\n if (configTag.contains(\"AutoPush\"))\n autoPush = configTag.getBoolean(\"AutoPush\")\n if (configTag.contains(\"AutoPull\"))\n autoPull = configTag.getBoolean(\"AutoPull\")\n }\n }\n\n fun writeBuf(buf: PacketByteBuf) {\n buf.writeBoolean(autoPush)\n buf.writeBoolean(autoPull)\n forEach { dir, mode ->\n buf.writeByte(dir.ordinal)\n buf.writeByte(mode.ordinal)\n }\n }\n\n fun readBuf(buf: PacketByteBuf) {\n autoPush = buf.readBoolean()\n autoPull = buf.readBoolean()\n repeat(6) {\n val direction = Direction.values()[buf.readByte().toInt()]\n val mode = TransferMode.values()[buf.readByte().toInt()]\n this[direction] = mode\n }\n }\n\n fun getConfigurationPanel(world: World, pos: BlockPos, configurable: Configurable, playerInventory: PlayerInventory, type: ConfigurationType): WWidget {\n val root = WGridPanel()\n root.setSize(100, 128)\n\n val configuration = this\n\n if (configuration.type == ConfigurationType.ITEM) {\n val autoPushBtn = WToggleButton(TranslatableText(\"item.indrev.wrench.autopush\"))\n autoPushBtn.toggle = configuration.autoPush\n autoPushBtn.onToggle = Consumer { v ->\n configuration.autoPush = v\n val buf = PacketByteBuf(Unpooled.buffer())\n buf.writeEnumConstant(type)\n buf.writeByte(0)\n buf.writeBlockPos(pos)\n buf.writeBoolean(v)\n ClientPlayNetworking.send(ConfigureIOPackets.UPDATE_AUTO_OPERATION_PACKET_ID, buf)\n }\n root.add(autoPushBtn, 0, 4)\n val autoPullBtn = WToggleButton(TranslatableText(\"item.indrev.wrench.autopull\"))\n autoPullBtn.toggle = configuration.autoPull\n autoPullBtn.onToggle = Consumer { v ->\n configuration.autoPull = v\n val buf = PacketByteBuf(Unpooled.buffer())\n buf.writeEnumConstant(type)\n buf.writeByte(1)\n buf.writeBlockPos(pos)\n buf.writeBoolean(v)\n ClientPlayNetworking.send(ConfigureIOPackets.UPDATE_AUTO_OPERATION_PACKET_ID, buf)\n }\n root.add(autoPullBtn, 0.0, 4.8)\n }\n\n val blockState = world.getBlockState(pos)\n\n val machineVisualizerPanel = WGridPanel()\n MachineSide.values().forEach { side ->\n var facing =\n when {\n blockState.contains(HorizontalFacingMachineBlock.HORIZONTAL_FACING) ->\n blockState[HorizontalFacingMachineBlock.HORIZONTAL_FACING]\n blockState.contains(FacingMachineBlock.FACING) ->\n blockState[FacingMachineBlock.FACING]\n else ->\n Direction.UP\n }\n if (facing.axis.isVertical) {\n facing = playerInventory.player.horizontalFacing.opposite\n }\n val direction = offset(facing, side.direction)\n val mode = configuration[direction]!!\n val widget = WMachineSideDisplay(side, direction, mode, world, pos)\n widget.setOnClick {\n widget.mode = widget.mode.next(configurable.getValidConfigurations(type))\n configuration[direction] = widget.mode\n val buf = PacketByteBuf(Unpooled.buffer())\n buf.writeEnumConstant(type)\n buf.writeBlockPos(pos)\n buf.writeInt(direction.id)\n buf.writeInt(widget.mode.ordinal)\n ClientPlayNetworking.send(ConfigureIOPackets.UPDATE_MACHINE_SIDE_PACKET_ID, buf)\n }\n machineVisualizerPanel.add(widget, (side.x) * 1.2, (side.y) * 1.2)\n }\n root.add(machineVisualizerPanel, 0.5, 0.0)\n return root\n }\n\n private fun offset(facing: Direction, side: Direction): Direction {\n return if (side.axis.isVertical) side\n else when (facing) {\n Direction.NORTH -> side\n Direction.SOUTH -> side.opposite\n Direction.WEST -> side.rotateYCounterclockwise()\n Direction.EAST -> side.rotateYClockwise()\n else -> side\n }\n }\n\n enum class MachineSide(val x: Int, val y: Int, val direction: Direction, val u1: Float, val v1: Float, val u2: Float, val v2: Float) {\n FRONT(1, 1, Direction.NORTH, 5.333f, 5.333f, 10.666f, 10.666f),\n LEFT(0, 1, Direction.EAST, 0.0f, 5.333f, 5.332f, 10.666f),\n BACK(2, 2, Direction.SOUTH, 10.667f, 10.667f, 16.0f, 16f),\n RIGHT(2, 1, Direction.WEST, 10.667f, 5.333f, 16.0f, 10.665f),\n TOP(1, 0, Direction.UP, 5.333f, 0.0f, 10.666f, 5.333f),\n BOTTOM(1, 2, Direction.DOWN, 5.333f, 10.667f, 10.666f, 15.998f)\n }\n\n companion object {\n val EMPTY_ITEM = SideConfiguration(ConfigurationType.ITEM)\n val EMPTY_FLUID = SideConfiguration(ConfigurationType.FLUID)\n val EMPTY_ENERGY = SideConfiguration(ConfigurationType.ENERGY)\n\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/armor/IRArmorMaterial.kt",
"content": "package me.steven.indrev.armor\n\nimport me.steven.indrev.registry.IRItemRegistry\nimport net.minecraft.entity.EquipmentSlot\nimport net.minecraft.item.ArmorMaterial\nimport net.minecraft.recipe.Ingredient\nimport net.minecraft.sound.SoundEvent\nimport net.minecraft.sound.SoundEvents\n\nenum class IRArmorMaterial(\n private val armorName: String,\n private val durabilityMultiplier: Int,\n private val armorValues: IntArray,\n private val enchantability: Int,\n private val equipSound: SoundEvent,\n private val toughness: Float,\n private val knockbackResistance: Float,\n private val repairIngredient: () -> Ingredient?) : ArmorMaterial {\n\n MODULAR(\n \"modular\", 0, intArrayOf(1, 3, 2, 1), 15,\n SoundEvents.ITEM_ARMOR_EQUIP_IRON, 1.0F, 1.0F, { null }\n ),\n STEEL_ELYTRA(\n \"reinforced_elytra\", 30, intArrayOf(1, 1, 1, 1), 15,\n SoundEvents.ITEM_ARMOR_EQUIP_IRON, 1.0F, 0F, { Ingredient.ofItems(IRItemRegistry.STEEL_PLATE()) }\n ),\n JETPACK(\n \"jetpack\", 30, intArrayOf(1, 1, 1, 1), 15,\n SoundEvents.ITEM_ARMOR_EQUIP_IRON, 1.0F, 0F, { null }\n ),\n STEEL(\n \"steel\", 30, intArrayOf(2, 6, 7, 2), 15,\n SoundEvents.ITEM_ARMOR_EQUIP_IRON, 1.0F, 0F, { Ingredient.ofItems(IRItemRegistry.STEEL_INGOT()) }\n ),\n COPPER(\n \"copper\", 14, intArrayOf(2, 4, 5, 2), 15,\n SoundEvents.ITEM_ARMOR_EQUIP_GENERIC, 0.0F, 0.0F, { Ingredient.ofItems(IRItemRegistry.COPPER_INGOT()) }\n ),\n TIN(\n \"tin\", 10, intArrayOf(1, 4, 5, 2), 15,\n SoundEvents.ITEM_ARMOR_EQUIP_GENERIC, 0.0F, 0.0F, { Ingredient.ofItems(IRItemRegistry.TIN_INGOT()) }\n ),\n BRONZE(\n \"bronze\", 15, intArrayOf(2, 5, 6, 2), 15,\n SoundEvents.ITEM_ARMOR_EQUIP_GENERIC, 0.0F, 0.0F, { Ingredient.ofItems(IRItemRegistry.BRONZE_INGOT()) }\n ),\n LEAD(\n \"lead\", 20, intArrayOf(2, 4, 4, 1), 15,\n SoundEvents.ITEM_ARMOR_EQUIP_GENERIC, 0.0F, 0.0F, { Ingredient.ofItems(IRItemRegistry.LEAD_INGOT()) }\n ),\n SILVER(\n \"silver\", 30, intArrayOf(1, 4, 4, 1), 15,\n SoundEvents.ITEM_ARMOR_EQUIP_GENERIC, 0.0F, 0.0F, { Ingredient.ofItems(IRItemRegistry.SILVER_INGOT()) }\n );\n\n override fun getName(): String = armorName\n override fun getEquipSound(): SoundEvent = equipSound\n override fun getRepairIngredient(): Ingredient? = repairIngredient()\n override fun getEnchantability(): Int = enchantability\n override fun getProtectionAmount(slot: EquipmentSlot): Int = this.armorValues[slot.entitySlotId]\n override fun getDurability(slot: EquipmentSlot): Int = BASE_DURABILITY[slot.entitySlotId] * durabilityMultiplier\n override fun getKnockbackResistance(): Float = knockbackResistance\n override fun getToughness(): Float = toughness\n\n companion object {\n private val BASE_DURABILITY = intArrayOf(13, 15, 16, 11)\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/armor/ModuleFeatureRenderer.kt",
"content": "package me.steven.indrev.armor\n\nimport me.steven.indrev.items.armor.IRModularArmorItem\nimport me.steven.indrev.utils.identifier\nimport net.minecraft.client.render.OverlayTexture\nimport net.minecraft.client.render.RenderLayer\nimport net.minecraft.client.render.VertexConsumerProvider\nimport net.minecraft.client.render.entity.feature.ArmorFeatureRenderer\nimport net.minecraft.client.render.entity.feature.FeatureRendererContext\nimport net.minecraft.client.render.entity.model.BipedEntityModel\nimport net.minecraft.client.render.item.ItemRenderer\nimport net.minecraft.client.util.math.MatrixStack\nimport net.minecraft.entity.EquipmentSlot\nimport net.minecraft.entity.LivingEntity\nimport net.minecraft.item.ArmorItem\nimport net.minecraft.util.Identifier\n\nclass ModuleFeatureRenderer, A : BipedEntityModel>(\n context: FeatureRendererContext,\n private val leggingsModel: A,\n private val bodyModel: A\n) : ArmorFeatureRenderer(context, leggingsModel, bodyModel) {\n\n override fun render(matrixStack: MatrixStack, vertexConsumerProvider: VertexConsumerProvider, i: Int, livingEntity: T, f: Float, g: Float, h: Float, j: Float, k: Float, l: Float) {\n renderArmor(matrixStack, vertexConsumerProvider, livingEntity, EquipmentSlot.CHEST, i, getArmor(EquipmentSlot.CHEST))\n renderArmor(matrixStack, vertexConsumerProvider, livingEntity, EquipmentSlot.LEGS, i, getArmor(EquipmentSlot.LEGS))\n renderArmor(matrixStack, vertexConsumerProvider, livingEntity, EquipmentSlot.FEET, i, getArmor(EquipmentSlot.FEET))\n renderArmor(matrixStack, vertexConsumerProvider, livingEntity, EquipmentSlot.HEAD, i, getArmor(EquipmentSlot.HEAD))\n }\n\n private fun renderArmor(matrices: MatrixStack, vertexConsumers: VertexConsumerProvider, livingEntity: T, equipmentSlot: EquipmentSlot, light: Int, bipedEntityModel: A) {\n val itemStack = livingEntity.getEquippedStack(equipmentSlot)\n val item = itemStack.item as? IRModularArmorItem ?: return\n if (item.slotType == equipmentSlot) {\n (this.contextModel as? BipedEntityModel)?.setAttributes(bipedEntityModel) ?: return\n setVisible(bipedEntityModel, equipmentSlot)\n val rgb = item.getColor(itemStack)\n val r = (rgb and 0xFF0000 shr 16) / 255f\n val g = (rgb and 0xFF00 shr 8) / 255f\n val b = (rgb and 0xFF) / 255f\n item.getInstalled(itemStack).filter { it.slots.contains(equipmentSlot) }.forEach { module ->\n if (module.hasTexture) {\n renderArmorParts(\n matrices, vertexConsumers, light, item, itemStack.hasGlint(), bipedEntityModel, usesSecondLayer(equipmentSlot), r, g, b, module.key\n )\n if (module.hasOverlay) {\n renderArmorParts(\n matrices, vertexConsumers, 15728880, item, itemStack.hasGlint(), bipedEntityModel, usesSecondLayer(equipmentSlot), r, g, b, \"${module.key}_overlay\"\n )\n }\n }\n }\n }\n }\n\n private fun renderArmorParts(\n matrixStack: MatrixStack,\n vertexConsumerProvider: VertexConsumerProvider,\n light: Int,\n armorItem: ArmorItem,\n hasGlint: Boolean,\n bipedEntityModel: A,\n secondLayer: Boolean,\n r: Float, g: Float, b: Float,\n overlay: String?) {\n val vertexConsumer = ItemRenderer.getArmorGlintConsumer(vertexConsumerProvider, RenderLayer.getArmorCutoutNoCull(getArmorTexture(armorItem, secondLayer, overlay)), false, hasGlint)\n bipedEntityModel.render(matrixStack, vertexConsumer, light, OverlayTexture.DEFAULT_UV, r, g, b, 1.0f)\n }\n\n private fun getArmor(slot: EquipmentSlot): A {\n return if (usesSecondLayer(slot)) leggingsModel else bodyModel\n }\n\n private fun usesSecondLayer(slot: EquipmentSlot): Boolean {\n return slot == EquipmentSlot.LEGS\n }\n\n private fun getArmorTexture(armorItem: ArmorItem, secondLayer: Boolean, overlay: String?): Identifier {\n val path = \"textures/models/armor/\" + armorItem.material.name + \"_layer_\" + (if (secondLayer) 2 else 1) + (if (overlay == null) \"\" else \"_$overlay\") + \".png\"\n return MODULAR_ARMOR_TEXTURE_CACHE.computeIfAbsent(path) { id -> identifier(id) }\n }\n\n companion object {\n val MODULAR_ARMOR_TEXTURE_CACHE = mutableMapOf()\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/armor/ReinforcedElytraFeatureRenderer.kt",
"content": "package me.steven.indrev.armor\n\nimport me.steven.indrev.items.armor.ReinforcedElytraItem\nimport me.steven.indrev.utils.identifier\nimport net.fabricmc.api.EnvType\nimport net.fabricmc.api.Environment\nimport net.minecraft.client.network.AbstractClientPlayerEntity\nimport net.minecraft.client.render.OverlayTexture\nimport net.minecraft.client.render.RenderLayer\nimport net.minecraft.client.render.VertexConsumerProvider\nimport net.minecraft.client.render.entity.PlayerModelPart\nimport net.minecraft.client.render.entity.feature.FeatureRenderer\nimport net.minecraft.client.render.entity.feature.FeatureRendererContext\nimport net.minecraft.client.render.entity.model.ElytraEntityModel\nimport net.minecraft.client.render.entity.model.EntityModel\nimport net.minecraft.client.render.entity.model.EntityModelLayers\nimport net.minecraft.client.render.entity.model.EntityModelLoader\nimport net.minecraft.client.render.item.ItemRenderer\nimport net.minecraft.client.util.math.MatrixStack\nimport net.minecraft.entity.EquipmentSlot\nimport net.minecraft.entity.LivingEntity\n\n@Environment(EnvType.CLIENT)\nclass ReinforcedElytraFeatureRenderer>(\n context: FeatureRendererContext,\n loader: EntityModelLoader\n) : FeatureRenderer(context) {\n\n private val elytraModel: ElytraEntityModel = ElytraEntityModel(loader.getModelPart(EntityModelLayers.ELYTRA))\n\n override fun render(\n matrices: MatrixStack,\n vertexConsumers: VertexConsumerProvider,\n light: Int,\n entity: T,\n limbAngle: Float,\n limbDistance: Float,\n tickDelta: Float,\n animationProgress: Float,\n headYaw: Float,\n headPitch: Float\n ) {\n val itemStack = entity.getEquippedStack(EquipmentSlot.CHEST)\n if (ReinforcedElytraItem.hasValidElytra(itemStack)) {\n val textureId = when {\n entity !is AbstractClientPlayerEntity -> REINFORCED_ELYTRA_SKIN\n entity.canRenderElytraTexture() && entity.elytraTexture != null -> entity.elytraTexture!!\n entity.canRenderCapeTexture() && entity.capeTexture != null && entity.isPartVisible(PlayerModelPart.CAPE) -> entity.capeTexture!!\n else -> REINFORCED_ELYTRA_SKIN\n }\n matrices.push()\n matrices.translate(0.0, 0.0, 0.125)\n this.contextModel.copyStateTo(elytraModel)\n elytraModel.setAngles(entity, limbAngle, limbDistance, animationProgress, headYaw, headPitch)\n val vertexConsumer = ItemRenderer.getArmorGlintConsumer(\n vertexConsumers,\n RenderLayer.getArmorCutoutNoCull(textureId),\n false,\n itemStack.hasGlint()\n )\n elytraModel.render(matrices, vertexConsumer, light, OverlayTexture.DEFAULT_UV, 1.0f, 1.0f, 1.0f, 1.0f)\n matrices.pop()\n }\n }\n\n companion object {\n private val REINFORCED_ELYTRA_SKIN = identifier(\"textures/entity/reinforced_elytra.png\")\n }\n}\n"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/BaseBlockEntity.kt",
"content": "package me.steven.indrev.blockentities\n\nimport com.google.common.base.Preconditions\nimport me.steven.indrev.components.GuiSyncableComponent\nimport net.minecraft.block.BlockState\nimport net.minecraft.block.entity.BlockEntity\nimport net.minecraft.block.entity.BlockEntityType\nimport net.minecraft.nbt.NbtCompound\nimport net.minecraft.network.packet.s2c.play.BlockEntityUpdateS2CPacket\nimport net.minecraft.server.world.ServerWorld\nimport net.minecraft.util.math.BlockPos\n\nabstract class BaseBlockEntity(type: BlockEntityType<*>, pos: BlockPos, state: BlockState) : BlockEntity(type, pos, state) {\n\n open val guiSyncableComponent: GuiSyncableComponent? = null\n\n fun sync() {\n Preconditions.checkNotNull(world) // Maintain distinct failure case from below\n check(world is ServerWorld) { \"Cannot call sync() on the logical client! Did you check world.isClient first?\" }\n (world as ServerWorld).chunkManager.markForUpdate(getPos())\n }\n\n abstract fun toTag(tag: NbtCompound)\n\n abstract fun fromTag(tag: NbtCompound)\n\n open fun toClientTag(tag: NbtCompound) {\n toTag(tag)\n }\n\n open fun fromClientTag(tag: NbtCompound) {\n fromTag(tag)\n }\n\n override fun toUpdatePacket(): BlockEntityUpdateS2CPacket {\n return BlockEntityUpdateS2CPacket.create(this)\n }\n\n override fun toInitialChunkDataNbt(): NbtCompound {\n val nbt = super.toInitialChunkDataNbt()\n toClientTag(nbt)\n nbt.putBoolean(\"#c\", true)\n return nbt\n }\n\n override fun writeNbt(nbt: NbtCompound) {\n super.writeNbt(nbt)\n toTag(nbt)\n }\n\n override fun readNbt(nbt: NbtCompound) {\n super.readNbt(nbt)\n if (nbt.contains(\"#c\")) {\n fromClientTag(nbt)\n } else {\n fromTag(nbt)\n }\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/BaseMachineBlockEntity.kt",
"content": "package me.steven.indrev.blockentities\n\nimport me.steven.indrev.api.sideconfigs.Configurable\nimport net.minecraft.block.BlockState\nimport net.minecraft.block.InventoryProvider\nimport net.minecraft.block.entity.BlockEntityType\nimport net.minecraft.util.math.BlockPos\n\nabstract class BaseMachineBlockEntity(type: BlockEntityType<*>, pos: BlockPos, state: BlockState)\n : BaseBlockEntity(type, pos, state), InventoryProvider, Configurable, Syncable {\n /**\n * Whether the machine should call #sync or not\n */\n open val syncToWorld = false\n\n var isMarkedForUpdate: Boolean = true\n\n override fun markForUpdate(condition: () -> Boolean) {\n isMarkedForUpdate = isMarkedForUpdate || condition()\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/GlobalStateController.kt",
"content": "package me.steven.indrev.blockentities\n\nimport it.unimi.dsi.fastutil.longs.Long2BooleanOpenHashMap\nimport it.unimi.dsi.fastutil.longs.Long2ObjectMap\nimport it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap\nimport me.steven.indrev.packets.client.MachineStateUpdatePacket\nimport me.steven.indrev.utils.component1\nimport me.steven.indrev.utils.component2\nimport me.steven.indrev.utils.component3\nimport net.fabricmc.api.EnvType\nimport net.fabricmc.api.Environment\nimport net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents\nimport net.fabricmc.fabric.api.networking.v1.PacketByteBufs\nimport net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking\nimport net.minecraft.client.MinecraftClient\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.math.ChunkPos\nimport net.minecraft.world.World\nimport java.util.function.LongFunction\n\nobject GlobalStateController {\n @Environment(EnvType.CLIENT)\n val chunksToUpdate: Long2ObjectMap> = Long2ObjectOpenHashMap()\n @Environment(EnvType.CLIENT)\n val workingStateTracker = Long2BooleanOpenHashMap()\n\n @Environment(EnvType.CLIENT)\n fun queueUpdate(pos: BlockPos) {\n val chunkPos = ChunkPos.toLong(pos.x shr 4, pos.z shr 4)\n if (MinecraftClient.getInstance().isOnThread)\n chunksToUpdate.computeIfAbsent(chunkPos, LongFunction { hashSetOf() }).add(pos)\n else\n MinecraftClient.getInstance().execute { chunksToUpdate.computeIfAbsent(chunkPos, LongFunction { hashSetOf() }).add(pos) }\n }\n\n fun update(world: World, pos: BlockPos, workingState: Boolean) {\n val (x, y, z) = pos\n val players = world.server!!.playerManager.playerList\n for (i in players.indices) {\n val player = players[i]\n if (player.world.registryKey === world.registryKey) {\n val xOffset = x - player.x\n val yOffset = y - player.y\n val zOffset = z - player.z\n if (xOffset * xOffset + yOffset * yOffset + zOffset * zOffset < 64 * 64) {\n val buf = PacketByteBufs.create()\n buf.writeLong(pos.asLong())\n buf.writeBoolean(workingState)\n ServerPlayNetworking.send(player, MachineStateUpdatePacket.UPDATE_PACKET_ID, buf)\n }\n }\n }\n }\n\n @Environment(EnvType.CLIENT)\n fun initClient() {\n var ticks = 0\n ClientTickEvents.END_CLIENT_TICK.register { client ->\n ticks++\n val world = client.world\n if (world != null && ticks % 15 == 0) {\n chunksToUpdate.values.removeIf { positions ->\n positions.forEach { (x, y, z) ->\n client.worldRenderer.scheduleBlockRenders(x , y, z, x, y,z)\n }\n true\n }\n }\n }\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/MachineBlockEntity.kt",
"content": "package me.steven.indrev.blockentities\n\nimport me.steven.indrev.IREnergyStorage\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.api.machines.TransferMode\nimport me.steven.indrev.api.sideconfigs.ConfigurationType\nimport me.steven.indrev.api.sideconfigs.SideConfiguration\nimport me.steven.indrev.blocks.machine.MachineBlock\nimport me.steven.indrev.components.*\nimport me.steven.indrev.components.multiblock.MultiBlockComponent\nimport me.steven.indrev.config.IConfig\nimport me.steven.indrev.config.IRConfig\nimport me.steven.indrev.items.upgrade.Enhancer\nimport me.steven.indrev.registry.MachineRegistry\nimport me.steven.indrev.utils.bucket\nimport me.steven.indrev.utils.transferEnergy\nimport me.steven.indrev.utils.transferFluids\nimport me.steven.indrev.utils.transferItems\nimport net.fabricmc.api.EnvType\nimport net.fabricmc.api.Environment\nimport net.minecraft.block.BlockState\nimport net.minecraft.client.MinecraftClient\nimport net.minecraft.inventory.SidedInventory\nimport net.minecraft.nbt.NbtCompound\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.math.Direction\nimport net.minecraft.world.WorldAccess\nimport kotlin.collections.set\n\nabstract class MachineBlockEntity(val tier: Tier, val registry: MachineRegistry, pos: BlockPos, state: BlockState)\n : BaseMachineBlockEntity(registry.blockEntityType(tier), pos, state) {\n\n val validConnections = Direction.values().toMutableList()\n\n override var guiSyncableComponent: GuiSyncableComponent? = GuiSyncableComponent()\n\n var energy: Long by autosync(ENERGY_ID, 0L) { value ->\n when (tier) {\n Tier.CREATIVE -> energyCapacity\n else -> value.coerceIn(0, energyCapacity)\n }\n }\n\n var inventoryComponent: InventoryComponent? = null\n var temperatureComponent: TemperatureComponent? = null\n var fluidComponent: FluidComponent? = null\n var multiblockComponent: MultiBlockComponent? = null\n var enhancerComponent: EnhancerComponent? = null\n\n var itemTransferCooldown = 0\n\n var workingState: Boolean = false\n set(value) {\n val update = value != field\n field = value\n if (update && world?.isClient == false)\n GlobalStateController.update(world!!, pos, value)\n }\n get() {\n if (world?.isClient == true && GlobalStateController.workingStateTracker.contains(pos.asLong())) {\n MinecraftClient.getInstance().execute { field = GlobalStateController.workingStateTracker.remove(pos.asLong()) }\n }\n return field\n }\n\n var ticks = 0\n\n @Suppress(\"UNCHECKED_CAST\")\n val config: T by lazy { registry.config(tier) as T }\n\n open val maxInput: Long = tier.io\n open val maxOutput: Long = tier.io\n open val energyCapacity: Long get() = config.maxEnergyStored + (IRConfig.upgrades.bufferUpgradeModifier * (enhancerComponent?.getCount(Enhancer.BUFFER) ?: 0))\n\n init {\n trackLong(MAX_ENERGY_ID) { energyCapacity }\n }\n\n open val storage = MachineEnergyStorage()\n\n protected open fun machineTick() {}\n\n @Environment(EnvType.CLIENT)\n open fun machineClientTick() {}\n\n fun tick() {\n inventoryComponent?.run { enhancerComponent?.updateEnhancers(inventory) }\n ticks++\n multiblockComponent?.tick(world!!, pos, cachedState)\n if (multiblockComponent?.isBuilt(world!!, pos, cachedState) == false) return\n\n transferEnergy()\n transferItems()\n transferFluids()\n\n machineTick()\n if (isMarkedForUpdate) {\n markDirty()\n if (syncToWorld) sync()\n isMarkedForUpdate = false\n }\n }\n\n open fun getProcessingSpeed(): Double {\n return 1.0 + (IRConfig.upgrades.speedUpgradeModifier * (enhancerComponent?.getCount(Enhancer.SPEED) ?: 0))\n }\n\n open fun getEnergyCost(): Long = 0\n\n // internal consumption\n fun use(amount: Long): Boolean {\n val extracted = amount.coerceAtMost(energy)\n if (extracted == amount) {\n this.energy -= extracted\n return true\n }\n return false\n }\n\n fun canUse(amount: Long): Boolean {\n val extracted = amount.coerceAtMost(energy)\n return extracted == amount\n }\n\n override fun getInventory(state: BlockState?, world: WorldAccess?, pos: BlockPos?): SidedInventory? = inventoryComponent?.inventory\n\n override fun isConfigurable(type: ConfigurationType): Boolean {\n return when (type) {\n ConfigurationType.ITEM -> inventoryComponent != null\n && (inventoryComponent?.inventory?.inputSlots?.isNotEmpty() == true\n || inventoryComponent?.inventory?.outputSlots?.isNotEmpty() == true)\n ConfigurationType.FLUID -> fluidComponent != null\n ConfigurationType.ENERGY -> false\n }\n }\n\n override fun applyDefault(state: BlockState, type: ConfigurationType, configuration: MutableMap) {\n val direction = (state.block as MachineBlock).getFacing(state)\n when (type) {\n ConfigurationType.ITEM -> {\n configuration[direction.rotateYClockwise()] = TransferMode.INPUT\n configuration[direction.rotateYCounterclockwise()] = TransferMode.OUTPUT\n }\n ConfigurationType.ENERGY -> throw IllegalArgumentException(\"cannot apply energy configuration to $this\")\n else -> return\n }\n }\n\n override fun getValidConfigurations(type: ConfigurationType): Array {\n return when (type) {\n ConfigurationType.ITEM -> TransferMode.DEFAULT\n ConfigurationType.FLUID, ConfigurationType.ENERGY -> arrayOf(TransferMode.INPUT, TransferMode.OUTPUT, TransferMode.NONE)\n }\n }\n\n override fun getCurrentConfiguration(type: ConfigurationType): SideConfiguration {\n return when (type) {\n ConfigurationType.ITEM -> inventoryComponent!!.itemConfig\n ConfigurationType.FLUID -> fluidComponent!!.transferConfig\n ConfigurationType.ENERGY -> error(\"nope\")\n }\n }\n\n override fun isFixed(type: ConfigurationType): Boolean = false\n\n open fun getFluidTransferRate(): Long = when (tier) {\n Tier.MK1 -> bucket / 3\n Tier.MK2 -> bucket * 2 / 3\n else -> bucket\n }\n\n override fun fromTag(tag: NbtCompound) {\n inventoryComponent?.readNbt(tag)\n inventoryComponent?.run { enhancerComponent?.updateEnhancers(inventory) }\n temperatureComponent?.readNbt(tag)\n fluidComponent?.fromTag(tag)\n multiblockComponent?.readNbt(tag)\n energy = tag.getLong(\"Energy\")\n }\n\n override fun toTag(tag: NbtCompound) {\n tag.putLong(\"Energy\", energy)\n inventoryComponent?.writeNbt(tag)\n temperatureComponent?.writeNbt(tag)\n fluidComponent?.toTag(tag)\n multiblockComponent?.writeNbt(tag)\n }\n\n override fun fromClientTag(tag: NbtCompound) {\n }\n\n override fun toClientTag(tag: NbtCompound) {\n }\n\n open inner class MachineEnergyStorage : IREnergyStorage() {\n\n override fun getAmount(): Long = energy\n\n override fun setAmount(v: Long) {\n energy = v\n }\n\n override fun getCapacity(): Long = energyCapacity\n\n override fun getMaxExtract(side: Direction?): Long = maxOutput\n\n override fun getMaxInsert(side: Direction?): Long = maxInput\n\n override fun onFinalCommit() {\n super.onFinalCommit()\n markForUpdate()\n }\n }\n\n companion object {\n const val ENERGY_ID = 0\n const val MAX_ENERGY_ID = 1\n const val TEMPERATURE_ID = 2\n const val MAX_TEMPERATURE_ID = 3\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/Syncable.kt",
"content": "package me.steven.indrev.blockentities\n\ninterface Syncable {\n fun markForUpdate(condition: () -> Boolean = { true })\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/cables/BasePipeBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.cables\n\nimport com.google.common.base.Preconditions\nimport it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.blocks.machine.pipes.BasePipeBlock\nimport me.steven.indrev.networks.Network\nimport me.steven.indrev.registry.IRBlockRegistry\nimport net.fabricmc.fabric.api.rendering.data.v1.RenderAttachmentBlockEntity\nimport net.minecraft.block.BlockState\nimport net.minecraft.block.entity.BlockEntity\nimport net.minecraft.client.MinecraftClient\nimport net.minecraft.nbt.NbtCompound\nimport net.minecraft.nbt.NbtList\nimport net.minecraft.nbt.NbtOps\nimport net.minecraft.network.packet.s2c.play.BlockEntityUpdateS2CPacket\nimport net.minecraft.server.world.ServerWorld\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.math.Direction\n\nclass BasePipeBlockEntity(val pipeType: Network.Type<*>, tier: Tier, pos: BlockPos, state: BlockState) :\n BlockEntity(when (tier) {\n Tier.MK1 -> IRBlockRegistry.COVERABLE_BLOCK_ENTITY_TYPE_MK1\n Tier.MK2 -> IRBlockRegistry.COVERABLE_BLOCK_ENTITY_TYPE_MK2\n Tier.MK3 -> IRBlockRegistry.COVERABLE_BLOCK_ENTITY_TYPE_MK3\n Tier.MK4 -> IRBlockRegistry.COVERABLE_BLOCK_ENTITY_TYPE_MK4\n Tier.CREATIVE -> error(\"no creative cable\")\n }, pos, state), RenderAttachmentBlockEntity {\n\n val connections = Object2ObjectOpenHashMap()\n\n init {\n connections.defaultReturnValue(BasePipeBlock.ConnectionType.NONE)\n }\n\n var coverState: BlockState? = null\n\n override fun getRenderAttachmentData(): Any {\n return PipeRenderData(\n coverState,\n connections.filterValues { type -> type == BasePipeBlock.ConnectionType.CONNECTED }.keys.toTypedArray()\n )\n }\n\n override fun readNbt(tag: NbtCompound) {\n this.coverState = null\n if (tag.contains(\"coverState\")) {\n BlockState.CODEC.decode(NbtOps.INSTANCE, tag.getCompound(\"coverState\")).result().ifPresent { pair ->\n this.coverState = pair.first\n }\n }\n val list = tag.getList(\"connections\", 10)\n connections.clear()\n list?.forEach { t ->\n t as NbtCompound\n val dir = Direction.byId(t.getByte(\"d\").toInt())\n val type = BasePipeBlock.ConnectionType.byId(t.getByte(\"c\").toInt())\n connections[dir] = type\n }\n super.readNbt(tag)\n\n if (world != null && world!!.isClient) {\n MinecraftClient.getInstance().worldRenderer.updateBlock(world!!, pos, null, null, 0)\n }\n }\n\n override fun writeNbt(tag: NbtCompound) {\n if (this.coverState != null) {\n BlockState.CODEC.encode(this.coverState, NbtOps.INSTANCE, NbtCompound()).result().ifPresent { t ->\n tag.put(\"coverState\", t)\n }\n }\n val list = NbtList()\n connections.forEach { (dir, conn) ->\n if (conn != BasePipeBlock.ConnectionType.NONE) {\n val t = NbtCompound()\n t.putByte(\"d\", dir.id.toByte())\n t.putByte(\"c\", conn.id.toByte())\n list.add(t)\n }\n }\n tag.put(\"connections\", list)\n }\n\n fun sync() {\n Preconditions.checkNotNull(world) // Maintain distinct failure case from below\n check(world is ServerWorld) { \"Cannot call sync() on the logical client! Did you check world.isClient first?\" }\n (world as ServerWorld).chunkManager.markForUpdate(getPos())\n }\n\n override fun toUpdatePacket(): BlockEntityUpdateS2CPacket {\n return BlockEntityUpdateS2CPacket.create(this)\n }\n\n override fun toInitialChunkDataNbt(): NbtCompound {\n val nbt = super.toInitialChunkDataNbt()\n writeNbt(nbt)\n return nbt\n }\n\n data class PipeRenderData(val cover: BlockState?, val connections: Array)\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/crafters/CompressorBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.crafters\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.components.EnhancerComponent\nimport me.steven.indrev.components.TemperatureComponent\nimport me.steven.indrev.components.trackObject\nimport me.steven.indrev.inventories.inventory\nimport me.steven.indrev.items.upgrade.Enhancer\nimport me.steven.indrev.recipes.machines.CompressorRecipe\nimport me.steven.indrev.recipes.machines.IRRecipeType\nimport me.steven.indrev.registry.MachineRegistry\nimport net.minecraft.block.BlockState\nimport net.minecraft.util.math.BlockPos\n\nclass CompressorBlockEntity(tier: Tier, pos: BlockPos, state: BlockState) :\n CraftingMachineBlockEntity(tier, MachineRegistry.COMPRESSOR_REGISTRY, pos, state) {\n\n init {\n this.temperatureComponent = TemperatureComponent(this, 0.06, 700..1100, 1500)\n this.enhancerComponent = EnhancerComponent(intArrayOf(4, 5, 6, 7), Enhancer.DEFAULT, this::getMaxCount)\n this.inventoryComponent = inventory(this) {\n input { slot = 2 }\n output { slot = 3 }\n }\n\n trackObject(CRAFTING_COMPONENT_ID, craftingComponents[0])\n }\n\n override val type: IRRecipeType = CompressorRecipe.TYPE\n\n companion object {\n const val CRAFTING_COMPONENT_ID = 4\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/crafters/CompressorFactoryBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.crafters\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.components.CraftingComponent\nimport me.steven.indrev.components.EnhancerComponent\nimport me.steven.indrev.components.TemperatureComponent\nimport me.steven.indrev.components.multiblock.MultiBlockComponent\nimport me.steven.indrev.components.multiblock.definitions.FactoryStructureDefinition\nimport me.steven.indrev.components.trackObject\nimport me.steven.indrev.inventories.inventory\nimport me.steven.indrev.items.upgrade.Enhancer\nimport me.steven.indrev.recipes.machines.CompressorRecipe\nimport me.steven.indrev.recipes.machines.IRRecipeType\nimport me.steven.indrev.registry.MachineRegistry\nimport net.minecraft.block.BlockState\nimport net.minecraft.nbt.NbtCompound\nimport net.minecraft.util.math.BlockPos\n\nclass CompressorFactoryBlockEntity(tier: Tier, pos: BlockPos, state: BlockState) :\n CraftingMachineBlockEntity(tier, MachineRegistry.COMPRESSOR_FACTORY_REGISTRY, pos, state) {\n\n init {\n this.temperatureComponent = TemperatureComponent(this, 0.06, 700..1100, 1400)\n this.enhancerComponent = EnhancerComponent(intArrayOf(2, 3, 4, 5), Enhancer.DEFAULT, this::getMaxCount)\n this.inventoryComponent = inventory(this) {\n input { slots = intArrayOf(6, 8, 10, 12, 14) }\n output { slots = intArrayOf(7, 9, 11, 13, 15) }\n }\n this.craftingComponents = Array(5) { index ->\n val component = CraftingComponent(index, this).apply {\n inputSlots = intArrayOf(6 + (index * 2))\n outputSlots = intArrayOf(6 + (index * 2) + 1)\n }\n trackObject(CRAFTING_COMPONENT_START_ID + index, component)\n component\n }\n this.multiblockComponent = MultiBlockComponent(FactoryStructureDefinition.SELECTOR)\n }\n\n override val syncToWorld: Boolean = true\n\n override val type: IRRecipeType = CompressorRecipe.TYPE\n\n override fun fromClientTag(tag: NbtCompound) {\n multiblockComponent?.readNbt(tag)\n }\n\n override fun toClientTag(tag: NbtCompound) {\n multiblockComponent?.writeNbt(tag)\n }\n\n companion object {\n const val CRAFTING_COMPONENT_START_ID = 4\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/crafters/CondenserBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.crafters\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.api.machines.TransferMode\nimport me.steven.indrev.api.sideconfigs.ConfigurationType\nimport me.steven.indrev.blocks.machine.MachineBlock\nimport me.steven.indrev.components.EnhancerComponent\nimport me.steven.indrev.components.FluidComponent\nimport me.steven.indrev.components.trackObject\nimport me.steven.indrev.inventories.inventory\nimport me.steven.indrev.items.upgrade.Enhancer\nimport me.steven.indrev.recipes.machines.CondenserRecipe\nimport me.steven.indrev.recipes.machines.IRRecipeType\nimport me.steven.indrev.registry.MachineRegistry\nimport me.steven.indrev.utils.bucket\nimport net.minecraft.block.BlockState\nimport net.minecraft.nbt.NbtCompound\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.math.Direction\n\nclass CondenserBlockEntity(tier: Tier, pos: BlockPos, state: BlockState) :\n CraftingMachineBlockEntity(tier, MachineRegistry.CONDENSER_REGISTRY, pos, state) {\n\n init {\n this.enhancerComponent = EnhancerComponent(intArrayOf(3, 4, 5, 6), Enhancer.DEFAULT, this::getMaxCount)\n this.inventoryComponent = inventory(this) {\n output { slot = 2 }\n coolerSlot = 1\n }\n this.fluidComponent = object : FluidComponent({ this }, bucket * 8) {\n init {\n this.inputTanks = intArrayOf(0)\n }\n }\n\n trackObject(CRAFTING_COMPONENT_ID, craftingComponents[0])\n\n trackObject(INPUT_TANK_ID, fluidComponent!![0])\n }\n\n override val syncToWorld: Boolean = true\n\n override val type: IRRecipeType = CondenserRecipe.TYPE\n\n override fun getMaxCount(enhancer: Enhancer): Int {\n return if (enhancer == Enhancer.SPEED) 4 else super.getMaxCount(enhancer)\n }\n\n override fun applyDefault(\n state: BlockState,\n type: ConfigurationType,\n configuration: MutableMap\n ) {\n val direction = (state.block as MachineBlock).getFacing(state)\n when (type) {\n ConfigurationType.ITEM -> {\n configuration[direction.rotateYCounterclockwise()] = TransferMode.OUTPUT\n }\n else -> super.applyDefault(state, type, configuration)\n }\n }\n\n override fun getValidConfigurations(type: ConfigurationType): Array {\n return when (type) {\n ConfigurationType.ITEM -> arrayOf(TransferMode.OUTPUT, TransferMode.NONE)\n else -> return super.getValidConfigurations(type)\n }\n }\n\n override fun fromClientTag(tag: NbtCompound) {\n fluidComponent!!.fromTag(tag)\n }\n\n override fun toClientTag(tag: NbtCompound) {\n fluidComponent!!.toTag(tag)\n }\n\n\n companion object {\n const val CRAFTING_COMPONENT_ID = 2\n const val INPUT_TANK_ID = 3\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/crafters/CondenserBlockEntityRenderer.kt",
"content": "package me.steven.indrev.blockentities.crafters\n\nimport alexiil.mc.lib.attributes.fluid.render.FluidRenderFace\nimport me.steven.indrev.blocks.machine.HorizontalFacingMachineBlock\nimport net.minecraft.client.render.VertexConsumerProvider\nimport net.minecraft.client.render.block.entity.BlockEntityRenderer\nimport net.minecraft.client.util.math.MatrixStack\nimport net.minecraft.util.math.Direction\n\nclass CondenserBlockEntityRenderer : BlockEntityRenderer {\n\n override fun render(\n entity: CondenserBlockEntity?,\n tickDelta: Float,\n matrices: MatrixStack?,\n vertexConsumers: VertexConsumerProvider?,\n light: Int,\n overlay: Int\n ) {\n val fluidComponent = entity?.fluidComponent ?: return\n val faces = when (entity.cachedState[HorizontalFacingMachineBlock.HORIZONTAL_FACING]) {\n Direction.NORTH -> NORTH_FACE\n Direction.SOUTH -> SOUTH_FACE\n Direction.WEST -> WEST_FACE\n Direction.EAST -> EAST_FACE\n else -> return\n }\n val volume = fluidComponent[0]\n if (!volume.isEmpty) {\n volume.render(faces, vertexConsumers, matrices)\n }\n }\n\n companion object {\n private val NORTH_FACE =\n listOf(FluidRenderFace.createFlatFaceZ(0.815, 0.625, -0.005, 0.19, 0.815, -0.005, 1.0, true, false))\n private val SOUTH_FACE =\n listOf(FluidRenderFace.createFlatFaceZ(0.185, 0.625, 1.005, 0.81, 0.815, 1.005, 1.0, true, false))\n private val WEST_FACE =\n listOf(FluidRenderFace.createFlatFaceX(-0.005, 0.625, 0.185, -0.005, 0.815, 0.81, 1.0, false, false))\n private val EAST_FACE =\n listOf(FluidRenderFace.createFlatFaceX(1.005, 0.625, 0.815, 1.005, 0.815, 0.19, 1.0, false, false))\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/crafters/CraftingMachineBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.crafters\n\nimport it.unimi.dsi.fastutil.objects.Object2IntArrayMap\nimport it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.blockentities.MachineBlockEntity\nimport me.steven.indrev.components.CraftingComponent\nimport me.steven.indrev.config.BasicMachineConfig\nimport me.steven.indrev.config.HeatMachineConfig\nimport me.steven.indrev.config.IRConfig\nimport me.steven.indrev.items.upgrade.Enhancer\nimport me.steven.indrev.recipes.IRecipeGetter\nimport me.steven.indrev.recipes.machines.IRRecipe\nimport me.steven.indrev.registry.MachineRegistry\nimport net.minecraft.block.BlockState\nimport net.minecraft.entity.ExperienceOrbEntity\nimport net.minecraft.entity.player.PlayerEntity\nimport net.minecraft.item.Item\nimport net.minecraft.item.ItemStack\nimport net.minecraft.nbt.NbtCompound\nimport net.minecraft.nbt.NbtList\nimport net.minecraft.recipe.SmeltingRecipe\nimport net.minecraft.server.world.ServerWorld\nimport net.minecraft.util.Identifier\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.math.Vec3d\nimport net.minecraft.world.World\nimport java.util.function.IntBinaryOperator\nimport kotlin.math.floor\n\nabstract class CraftingMachineBlockEntity(tier: Tier, registry: MachineRegistry, pos: BlockPos, state: BlockState) :\n MachineBlockEntity(tier, registry, pos, state) {\n\n override val maxOutput: Long = 0\n\n private var currentRecipe: T? = null\n val usedRecipes = Object2IntOpenHashMap()\n abstract val type: IRecipeGetter\n var craftingComponents = Array(1) { CraftingComponent(0, this) }\n var isSplitOn = false\n\n override fun machineTick() {\n ticks++\n craftingComponents.forEach { it.tick() }\n workingState = craftingComponents.any { it.isCrafting }\n if (ticks % 20 == 0 && isSplitOn) { splitStacks() }\n }\n\n override fun getProcessingSpeed(): Double {\n val isFullEfficiency = temperatureComponent?.isFullEfficiency() == true\n val baseSpeed = if (isFullEfficiency)\n ((config as? HeatMachineConfig)?.processTemperatureBoost ?: 1.0) * config.processSpeed\n else\n config.processSpeed\n return baseSpeed + (IRConfig.upgrades.speedUpgradeModifier * (enhancerComponent?.getCount(Enhancer.SPEED) ?: 0))\n }\n\n override fun getEnergyCost(): Long {\n val speedEnhancers = (enhancerComponent!!.getCount(Enhancer.SPEED) * 2).coerceAtLeast(1)\n return (if (temperatureComponent?.isFullEfficiency() == true) config.energyCost * 1.5\n else config.energyCost).toLong() * speedEnhancers\n }\n\n open fun getMaxCount(enhancer: Enhancer): Int {\n return when (enhancer) {\n Enhancer.SPEED -> return 1\n Enhancer.BUFFER -> 4\n else -> 1\n }\n }\n\n open fun splitStacks() {\n if (craftingComponents.size <= 1) return\n val inventory = inventoryComponent!!.inventory\n splitStacks(inventory.inputSlots)\n }\n\n fun splitStacks(inputSlots: IntArray) {\n if (craftingComponents.size <= 1) return\n val inventory = inventoryComponent!!.inventory\n val (item, sum) = inputSlots.associateStacks { inventory.getStack(it) }.maxByOrNull { it.value } ?: return\n if (sum <= 0) return\n\n val freeSlots = inputSlots.filter { inventory.fits(item, it) }\n var remaining = sum\n val slotsUsed = freeSlots.size.coerceAtMost(sum)\n val rem = sum % slotsUsed\n val isBelowLimit = slotsUsed > freeSlots.size\n val baseAmount = Math.floorDiv(sum, slotsUsed)\n freeSlots.forEachIndexed { index, slot ->\n if (isBelowLimit && index + 1 > slotsUsed) {\n inventory.setStack(slot, ItemStack.EMPTY)\n return@forEachIndexed\n }\n var set = baseAmount\n if (rem != 0 && rem > index && remaining > 0)\n set++\n if (index == slotsUsed - 1)\n set += remaining\n remaining -= set\n if (remaining < 0) set += remaining\n inventory.setStack(slot, ItemStack(item, set))\n }\n }\n\n private inline fun IntArray.associateStacks(transform: (Int) -> ItemStack): Map {\n return associateToStacks(Object2IntArrayMap(5), transform)\n }\n\n private inline fun > IntArray.associateToStacks(destination: M, transform: (Int) -> ItemStack): M {\n for (element in this) {\n val stack = transform(element)\n if (!stack.isEmpty && stack.nbt?.isEmpty != false)\n destination.mergeInt(stack.item, stack.count, IntBinaryOperator { old, new -> old + new })\n }\n return destination\n }\n\n override fun fromTag(tag: NbtCompound) {\n val craftTags = tag.getList(\"craftingComponents\", 10)\n craftTags?.forEach { craftTag ->\n val index = (craftTag as NbtCompound).getInt(\"index\")\n craftingComponents[index].readNbt(craftTag)\n }\n isSplitOn = tag.getBoolean(\"split\")\n super.fromTag(tag)\n }\n\n override fun toTag(tag: NbtCompound) {\n val craftTags = NbtList()\n craftingComponents.forEachIndexed { index, crafting ->\n val craftTag = NbtCompound()\n craftTags.add(crafting.writeNbt(craftTag))\n craftTag.putInt(\"index\", index)\n }\n tag.put(\"craftingComponents\", craftTags)\n tag.putBoolean(\"split\", isSplitOn)\n return super.toTag(tag)\n }\n\n @Suppress(\"UNCHECKED_CAST\")\n fun dropExperience(player: PlayerEntity) {\n val list = mutableListOf()\n\n usedRecipes.forEach { (id, amount) ->\n for (recipes in world!!.recipeManager.recipes.values) {\n val recipe = recipes[id] ?: continue\n list.add(recipe as? T ?: continue)\n if (recipe is SmeltingRecipe)\n spawnOrbs(world!!, player.pos, amount, recipe.experience)\n break\n }\n }\n\n player.unlockRecipes(list.toList())\n usedRecipes.clear()\n }\n\n private fun spawnOrbs(world: World, pos: Vec3d, amount: Int, experience: Float) {\n val xp = amount.toFloat() * experience\n var n = floor(xp).toInt()\n val decimal = xp % 1\n if (decimal != 0.0f && Math.random() < decimal.toDouble()) {\n ++n\n }\n ExperienceOrbEntity.spawn(world as ServerWorld, pos, n)\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/crafters/ElectricFurnaceBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.crafters\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.components.EnhancerComponent\nimport me.steven.indrev.components.TemperatureComponent\nimport me.steven.indrev.components.trackObject\nimport me.steven.indrev.inventories.inventory\nimport me.steven.indrev.items.upgrade.Enhancer\nimport me.steven.indrev.mixin.common.MixinAbstractCookingRecipe\nimport me.steven.indrev.recipes.IRecipeGetter\nimport me.steven.indrev.recipes.machines.VanillaCookingRecipeCachedGetter\nimport me.steven.indrev.registry.MachineRegistry\nimport net.minecraft.block.BlockState\nimport net.minecraft.util.math.BlockPos\n\nclass ElectricFurnaceBlockEntity(tier: Tier, pos: BlockPos, state: BlockState) :\n CraftingMachineBlockEntity(tier, MachineRegistry.ELECTRIC_FURNACE_REGISTRY, pos, state) {\n\n init {\n this.temperatureComponent = TemperatureComponent(this, 0.1, 1300..1700, 2000)\n this.enhancerComponent = EnhancerComponent(intArrayOf(4, 5, 6, 7), Enhancer.FURNACE, this::getMaxCount)\n this.inventoryComponent = inventory(this) {\n input { slot = 2 }\n output { slot = 3 }\n }\n trackObject(CRAFTING_COMPONENT_ID, craftingComponents[0])\n }\n\n @Suppress(\"UNCHECKED_CAST\")\n override val type: IRecipeGetter\n get() {\n val upgrades = enhancerComponent!!.enhancers\n return when (upgrades.keys.firstOrNull { it == Enhancer.BLAST_FURNACE || it == Enhancer.SMOKER }) {\n Enhancer.BLAST_FURNACE -> VanillaCookingRecipeCachedGetter.BLASTING\n Enhancer.SMOKER -> VanillaCookingRecipeCachedGetter.SMOKING\n else -> VanillaCookingRecipeCachedGetter.SMELTING\n } as IRecipeGetter\n }\n\n companion object {\n const val CRAFTING_COMPONENT_ID = 4\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/crafters/ElectricFurnaceFactoryBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.crafters\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.components.CraftingComponent\nimport me.steven.indrev.components.EnhancerComponent\nimport me.steven.indrev.components.TemperatureComponent\nimport me.steven.indrev.components.multiblock.MultiBlockComponent\nimport me.steven.indrev.components.multiblock.definitions.FactoryStructureDefinition\nimport me.steven.indrev.components.trackObject\nimport me.steven.indrev.inventories.inventory\nimport me.steven.indrev.items.upgrade.Enhancer\nimport me.steven.indrev.mixin.common.MixinAbstractCookingRecipe\nimport me.steven.indrev.recipes.IRecipeGetter\nimport me.steven.indrev.recipes.machines.VanillaCookingRecipeCachedGetter\nimport me.steven.indrev.registry.MachineRegistry\nimport net.minecraft.block.BlockState\nimport net.minecraft.nbt.NbtCompound\nimport net.minecraft.util.math.BlockPos\n\nclass ElectricFurnaceFactoryBlockEntity(tier: Tier, pos: BlockPos, state: BlockState) :\n CraftingMachineBlockEntity(tier, MachineRegistry.ELECTRIC_FURNACE_FACTORY_REGISTRY, pos, state) {\n\n init {\n this.temperatureComponent = TemperatureComponent(this, 0.1, 1300..1700, 2000)\n this.enhancerComponent = EnhancerComponent(intArrayOf(2, 3, 4, 5), Enhancer.FURNACE, this::getMaxCount)\n this.inventoryComponent = inventory(this) {\n input { slots = intArrayOf(6, 8, 10, 12, 14) }\n output { slots = intArrayOf(7, 9, 11, 13, 15) }\n }\n this.craftingComponents = Array(5) { index ->\n val component = CraftingComponent(index, this).apply {\n inputSlots = intArrayOf(6 + (index * 2))\n outputSlots = intArrayOf(6 + (index * 2) + 1)\n }\n trackObject(CRAFTING_COMPONENT_START_ID + index, component)\n component\n }\n this.multiblockComponent = MultiBlockComponent(FactoryStructureDefinition.SELECTOR)\n }\n\n override val syncToWorld: Boolean = true\n\n @Suppress(\"UNCHECKED_CAST\")\n override val type: IRecipeGetter\n get() {\n val upgrades = enhancerComponent!!.enhancers\n return when (upgrades.keys.firstOrNull { it == Enhancer.BLAST_FURNACE || it == Enhancer.SMOKER }) {\n Enhancer.BLAST_FURNACE -> VanillaCookingRecipeCachedGetter.BLASTING\n Enhancer.SMOKER -> VanillaCookingRecipeCachedGetter.SMOKING\n else -> VanillaCookingRecipeCachedGetter.SMELTING\n } as IRecipeGetter\n }\n\n override fun fromClientTag(tag: NbtCompound) {\n multiblockComponent?.readNbt(tag)\n }\n\n override fun toClientTag(tag: NbtCompound) {\n multiblockComponent?.writeNbt(tag)\n }\n\n companion object {\n const val CRAFTING_COMPONENT_START_ID = 4\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/crafters/ElectrolyticSeparatorBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.crafters\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.api.machines.TransferMode\nimport me.steven.indrev.api.sideconfigs.ConfigurationType\nimport me.steven.indrev.components.EnhancerComponent\nimport me.steven.indrev.components.FluidComponent\nimport me.steven.indrev.components.TemperatureComponent\nimport me.steven.indrev.components.trackObject\nimport me.steven.indrev.inventories.inventory\nimport me.steven.indrev.items.upgrade.Enhancer\nimport me.steven.indrev.recipes.machines.ElectrolysisRecipe\nimport me.steven.indrev.recipes.machines.IRRecipeType\nimport me.steven.indrev.registry.MachineRegistry\nimport me.steven.indrev.utils.bucket\nimport net.minecraft.block.BlockState\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.math.Direction\n\nclass ElectrolyticSeparatorBlockEntity(tier: Tier, pos: BlockPos, state: BlockState)\n : CraftingMachineBlockEntity(tier, MachineRegistry.ELECTROLYTIC_SEPARATOR_REGISTRY, pos, state) {\n\n init {\n this.temperatureComponent = TemperatureComponent(this, 0.06, 500..700, 900)\n this.enhancerComponent = EnhancerComponent(intArrayOf(1, 2, 3, 4), Enhancer.DEFAULT, this::getMaxCount)\n this.inventoryComponent = inventory(this) {\n coolerSlot = 0\n }\n this.fluidComponent = ElectrolyticSeparatorFluidComponent()\n\n trackObject(CRAFTING_COMPONENT_ID, craftingComponents[0])\n\n trackObject(INPUT_TANK_ID, fluidComponent!![0])\n trackObject(FIRST_OUTPUT_TANK_ID, fluidComponent!![1])\n trackObject(SECOND_OUTPUT_TANK_ID, fluidComponent!![2])\n }\n\n override val type: IRRecipeType = ElectrolysisRecipe.TYPE\n\n override fun applyDefault(\n state: BlockState,\n type: ConfigurationType,\n configuration: MutableMap\n ) {\n if (type != ConfigurationType.ITEM)\n super.applyDefault(state, type, configuration)\n }\n\n override fun getValidConfigurations(type: ConfigurationType): Array {\n return when (type) {\n ConfigurationType.FLUID -> TransferMode.ELECTROLYTIC_SEPARATOR\n else -> return super.getValidConfigurations(type)\n }\n }\n\n inner class ElectrolyticSeparatorFluidComponent : FluidComponent({ this }, bucket * 4, 3) {\n\n init {\n this.inputTanks = intArrayOf(0)\n this.outputTanks = intArrayOf(1, 2)\n }\n\n override fun getValidTanks(dir: Direction): IntArray {\n return when (transferConfig[dir]!!) {\n TransferMode.OUTPUT_FIRST -> intArrayOf(1)\n TransferMode.OUTPUT_SECOND -> intArrayOf(2)\n else -> super.getValidTanks(dir)\n }\n }\n }\n\n companion object {\n const val CRAFTING_COMPONENT_ID = 4\n const val INPUT_TANK_ID = 5\n const val FIRST_OUTPUT_TANK_ID = 6\n const val SECOND_OUTPUT_TANK_ID = 7\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/crafters/FluidInfuserBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.crafters\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.components.EnhancerComponent\nimport me.steven.indrev.components.FluidComponent\nimport me.steven.indrev.components.TemperatureComponent\nimport me.steven.indrev.components.trackObject\nimport me.steven.indrev.inventories.inventory\nimport me.steven.indrev.items.upgrade.Enhancer\nimport me.steven.indrev.recipes.machines.FluidInfuserRecipe\nimport me.steven.indrev.recipes.machines.IRRecipeType\nimport me.steven.indrev.registry.MachineRegistry\nimport me.steven.indrev.utils.bucket\nimport net.minecraft.block.BlockState\nimport net.minecraft.nbt.NbtCompound\nimport net.minecraft.util.math.BlockPos\n\nclass FluidInfuserBlockEntity(tier: Tier, pos: BlockPos, state: BlockState)\n : CraftingMachineBlockEntity(tier, MachineRegistry.FLUID_INFUSER_REGISTRY, pos, state) {\n\n init {\n this.temperatureComponent = TemperatureComponent(this, 0.06, 700..1100, 1400)\n this.enhancerComponent = EnhancerComponent(intArrayOf(4, 5, 6, 7), Enhancer.DEFAULT, this::getMaxCount)\n this.inventoryComponent = inventory(this) {\n input { slot = 2 }\n output { slot = 3 }\n }\n this.fluidComponent = FluidInfuserFluidComponent()\n\n trackObject(CRAFTING_COMPONENT_ID, craftingComponents[0])\n\n trackObject(INPUT_TANK_ID, fluidComponent!![0])\n trackObject(OUTPUT_TANK_ID, fluidComponent!![1])\n }\n\n override val syncToWorld: Boolean = true\n\n override val type: IRRecipeType = FluidInfuserRecipe.TYPE\n\n override fun fromClientTag(tag: NbtCompound) {\n fluidComponent!!.fromTag(tag)\n }\n\n override fun toClientTag(tag: NbtCompound) {\n fluidComponent!!.toTag(tag)\n }\n\n inner class FluidInfuserFluidComponent : FluidComponent({ this }, bucket * 8 , 2) {\n init {\n this.inputTanks = intArrayOf(0)\n this.outputTanks = intArrayOf(1)\n\n }\n }\n\n companion object {\n const val CRAFTING_COMPONENT_ID = 4\n const val INPUT_TANK_ID = 5\n const val OUTPUT_TANK_ID = 6\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/crafters/FluidInfuserBlockEntityRenderer.kt",
"content": "package me.steven.indrev.blockentities.crafters\n\nimport alexiil.mc.lib.attributes.fluid.render.FluidRenderFace\nimport me.steven.indrev.blocks.machine.HorizontalFacingMachineBlock\nimport net.minecraft.client.render.VertexConsumerProvider\nimport net.minecraft.client.render.block.entity.BlockEntityRenderer\nimport net.minecraft.client.util.math.MatrixStack\nimport net.minecraft.util.math.Direction\n\nclass FluidInfuserBlockEntityRenderer : BlockEntityRenderer{\n override fun render(\n entity: FluidInfuserBlockEntity?,\n tickDelta: Float,\n matrices: MatrixStack?,\n vertexConsumers: VertexConsumerProvider?,\n light: Int,\n overlay: Int\n ) {\n val fluidComponent = entity?.fluidComponent ?: return\n val inputFace = when (entity.cachedState[HorizontalFacingMachineBlock.HORIZONTAL_FACING]) {\n Direction.NORTH -> INPUT_NORTH_FACE\n Direction.SOUTH -> INPUT_SOUTH_FACE\n Direction.WEST -> INPUT_WEST_FACE\n Direction.EAST -> INPUT_EAST_FACE\n else -> return\n }\n val inputVolume = fluidComponent[0]\n if (!inputVolume.isEmpty) {\n inputVolume.render(inputFace, vertexConsumers, matrices)\n }\n\n val outputFace = when (entity.cachedState[HorizontalFacingMachineBlock.HORIZONTAL_FACING]) {\n Direction.NORTH -> OUTPUT_NORTH_FACE\n Direction.SOUTH -> OUTPUT_SOUTH_FACE\n Direction.WEST -> OUTPUT_WEST_FACE\n Direction.EAST -> OUTPUT_EAST_FACE\n else -> return\n }\n val outputVolume = fluidComponent[1]\n if (!outputVolume.isEmpty) {\n outputVolume.render(outputFace, vertexConsumers, matrices)\n }\n }\n\n companion object {\n private val INPUT_NORTH_FACE =\n listOf(FluidRenderFace.createFlatFaceZ(0.815, 0.690, -0.005, 0.19, 0.815, -0.005, 1.0, true, false))\n private val INPUT_SOUTH_FACE =\n listOf(FluidRenderFace.createFlatFaceZ(0.185, 0.690, 1.005, 0.81, 0.815, 1.005, 1.0, true, false))\n private val INPUT_WEST_FACE =\n listOf(FluidRenderFace.createFlatFaceX(-0.005, 0.690, 0.185, -0.005, 0.815, 0.81, 1.0, false, false))\n private val INPUT_EAST_FACE =\n listOf(FluidRenderFace.createFlatFaceX(1.005, 0.690, 0.815, 1.005, 0.815, 0.19, 1.0, false, false))\n\n private val OUTPUT_NORTH_FACE =\n listOf(FluidRenderFace.createFlatFaceZ(0.815, 0.190, -0.005, 0.19, 0.32, -0.005, 1.0, true, false))\n private val OUTPUT_SOUTH_FACE =\n listOf(FluidRenderFace.createFlatFaceZ(0.185, 0.190, 1.005, 0.81, 0.32, 1.005, 1.0, true, false))\n private val OUTPUT_WEST_FACE =\n listOf(FluidRenderFace.createFlatFaceX(-0.005, 0.190, 0.185, -0.005, 0.32, 0.81, 1.0, false, false))\n private val OUTPUT_EAST_FACE =\n listOf(FluidRenderFace.createFlatFaceX(1.005, 0.190, 0.815, 1.005, 0.32, 0.19, 1.0, false, false))\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/crafters/PulverizerBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.crafters\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.components.EnhancerComponent\nimport me.steven.indrev.components.TemperatureComponent\nimport me.steven.indrev.components.trackObject\nimport me.steven.indrev.inventories.inventory\nimport me.steven.indrev.items.upgrade.Enhancer\nimport me.steven.indrev.recipes.machines.IRRecipeType\nimport me.steven.indrev.recipes.machines.PulverizerRecipe\nimport me.steven.indrev.registry.MachineRegistry\nimport net.minecraft.block.BlockState\nimport net.minecraft.util.math.BlockPos\n\nclass PulverizerBlockEntity(tier: Tier, pos: BlockPos, state: BlockState) :\n CraftingMachineBlockEntity(tier, MachineRegistry.PULVERIZER_REGISTRY, pos, state) {\n\n init {\n this.temperatureComponent = TemperatureComponent(this, 0.06, 700..1100, 1400)\n this.enhancerComponent = EnhancerComponent(intArrayOf(5, 6, 7, 8), Enhancer.DEFAULT, this::getMaxCount)\n this.inventoryComponent = inventory(this) {\n input { slot = 2 }\n output { slots = intArrayOf(3, 4) }\n }\n\n trackObject(CRAFTING_COMPONENT_ID, craftingComponents[0])\n }\n\n override val type: IRRecipeType = PulverizerRecipe.TYPE\n\n companion object {\n const val CRAFTING_COMPONENT_ID = 4\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/crafters/PulverizerFactoryBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.crafters\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.components.CraftingComponent\nimport me.steven.indrev.components.EnhancerComponent\nimport me.steven.indrev.components.TemperatureComponent\nimport me.steven.indrev.components.multiblock.MultiBlockComponent\nimport me.steven.indrev.components.multiblock.definitions.FactoryStructureDefinition\nimport me.steven.indrev.components.trackObject\nimport me.steven.indrev.inventories.inventory\nimport me.steven.indrev.items.upgrade.Enhancer\nimport me.steven.indrev.recipes.machines.IRRecipeType\nimport me.steven.indrev.recipes.machines.PulverizerRecipe\nimport me.steven.indrev.registry.MachineRegistry\nimport net.minecraft.block.BlockState\nimport net.minecraft.nbt.NbtCompound\nimport net.minecraft.util.math.BlockPos\n\nclass PulverizerFactoryBlockEntity(tier: Tier, pos: BlockPos, state: BlockState) :\n CraftingMachineBlockEntity(tier, MachineRegistry.PULVERIZER_FACTORY_REGISTRY, pos, state) {\n\n init {\n this.temperatureComponent = TemperatureComponent(this, 0.06, 700..1100, 1400)\n this.enhancerComponent = EnhancerComponent(intArrayOf(2, 3, 4, 5), Enhancer.DEFAULT, this::getMaxCount)\n this.inventoryComponent = inventory(this) {\n input { slots = intArrayOf(6, 8, 10, 12, 14) }\n output { slots = intArrayOf(7, 9, 11, 13, 15) }\n }\n this.craftingComponents = Array(5) { index ->\n val component = CraftingComponent(index, this).apply {\n inputSlots = intArrayOf(6 + (index * 2))\n outputSlots = intArrayOf(6 + (index * 2) + 1)\n }\n trackObject(CRAFTING_COMPONENT_START_ID + index, component)\n component\n }\n this.multiblockComponent = MultiBlockComponent(FactoryStructureDefinition.SELECTOR)\n }\n\n override val syncToWorld: Boolean = true\n\n override val type: IRRecipeType = PulverizerRecipe.TYPE\n\n override fun fromClientTag(tag: NbtCompound) {\n multiblockComponent?.readNbt(tag)\n }\n\n override fun toClientTag(tag: NbtCompound) {\n multiblockComponent?.writeNbt(tag)\n }\n\n companion object {\n const val CRAFTING_COMPONENT_START_ID = 4\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/crafters/RecyclerBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.crafters\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.components.EnhancerComponent\nimport me.steven.indrev.components.trackObject\nimport me.steven.indrev.inventories.inventory\nimport me.steven.indrev.items.upgrade.Enhancer\nimport me.steven.indrev.recipes.machines.IRRecipeType\nimport me.steven.indrev.recipes.machines.RecyclerRecipe\nimport me.steven.indrev.registry.MachineRegistry\nimport net.minecraft.block.BlockState\nimport net.minecraft.util.math.BlockPos\n\nclass RecyclerBlockEntity(tier: Tier, pos: BlockPos, state: BlockState)\n : CraftingMachineBlockEntity(tier, MachineRegistry.RECYCLER_REGISTRY, pos, state) {\n\n init {\n this.enhancerComponent = object : EnhancerComponent(intArrayOf(4, 5, 6, 7), Enhancer.DEFAULT, this::getMaxCount) {\n override fun isLocked(slot: Int, tier: Tier): Boolean = false\n }\n\n this.inventoryComponent = inventory(this) {\n input { slot = 2 }\n output { slot = 3 }\n coolerSlot = 1\n }\n\n trackObject(CRAFTING_COMPONENT_ID, craftingComponents[0])\n }\n\n override val type: IRRecipeType = RecyclerRecipe.TYPE\n\n companion object {\n const val CRAFTING_COMPONENT_ID = 4\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/crafters/SawmillBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.crafters\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.components.EnhancerComponent\nimport me.steven.indrev.components.TemperatureComponent\nimport me.steven.indrev.components.trackObject\nimport me.steven.indrev.inventories.inventory\nimport me.steven.indrev.items.upgrade.Enhancer\nimport me.steven.indrev.recipes.machines.IRRecipeType\nimport me.steven.indrev.recipes.machines.SawmillRecipe\nimport me.steven.indrev.registry.MachineRegistry\nimport net.minecraft.block.BlockState\nimport net.minecraft.util.math.BlockPos\n\nclass SawmillBlockEntity(tier: Tier, pos: BlockPos, state: BlockState)\n : CraftingMachineBlockEntity(tier, MachineRegistry.SAWMILL_REGISTRY, pos, state) {\n\n init {\n this.temperatureComponent = TemperatureComponent(this, 0.06, 700..1100, 1400)\n this.enhancerComponent = EnhancerComponent(intArrayOf(7, 8, 9, 10), Enhancer.DEFAULT, this::getMaxCount)\n this.inventoryComponent = inventory(this) {\n input { slot = 2 }\n output { slots = intArrayOf(3, 4, 5, 6) }\n }\n\n trackObject(CRAFTING_COMPONENT_ID, craftingComponents[0])\n }\n\n override val type: IRRecipeType = SawmillRecipe.TYPE\n\n companion object {\n const val CRAFTING_COMPONENT_ID = 4\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/crafters/SmelterBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.crafters\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.api.machines.TransferMode\nimport me.steven.indrev.api.sideconfigs.ConfigurationType\nimport me.steven.indrev.blocks.machine.MachineBlock\nimport me.steven.indrev.components.EnhancerComponent\nimport me.steven.indrev.components.FluidComponent\nimport me.steven.indrev.components.TemperatureComponent\nimport me.steven.indrev.components.trackObject\nimport me.steven.indrev.inventories.inventory\nimport me.steven.indrev.items.upgrade.Enhancer\nimport me.steven.indrev.recipes.machines.IRRecipeType\nimport me.steven.indrev.recipes.machines.SmelterRecipe\nimport me.steven.indrev.registry.MachineRegistry\nimport me.steven.indrev.utils.bucket\nimport net.minecraft.block.BlockState\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.math.Direction\n\nclass SmelterBlockEntity(tier: Tier, pos: BlockPos, state: BlockState) :\n CraftingMachineBlockEntity(tier, MachineRegistry.SMELTER_REGISTRY, pos, state) {\n\n init {\n this.temperatureComponent = TemperatureComponent(this, 0.2, 1700..2500, 2700)\n this.enhancerComponent = EnhancerComponent(intArrayOf(3, 4, 5, 6), Enhancer.DEFAULT, this::getMaxCount)\n this.inventoryComponent = inventory(this) {\n input { slot = 2 }\n }\n this.fluidComponent = object : FluidComponent({ this }, bucket * 8) {\n init {\n this.outputTanks = intArrayOf(0)\n }\n }\n trackObject(CRAFTING_COMPONENT_ID, craftingComponents[0])\n trackObject(TANK_ID, fluidComponent!![0])\n }\n\n override val type: IRRecipeType = SmelterRecipe.TYPE\n\n override fun getMaxCount(enhancer: Enhancer): Int {\n return if (enhancer == Enhancer.SPEED) 4 else super.getMaxCount(enhancer)\n }\n\n override fun applyDefault(\n state: BlockState,\n type: ConfigurationType,\n configuration: MutableMap\n ) {\n val direction = (state.block as MachineBlock).getFacing(state)\n when (type) {\n ConfigurationType.ITEM -> {\n configuration[direction.rotateYClockwise()] = TransferMode.INPUT\n }\n else -> super.applyDefault(state, type, configuration)\n }\n }\n\n override fun getValidConfigurations(type: ConfigurationType): Array {\n return when (type) {\n ConfigurationType.ITEM -> arrayOf(TransferMode.INPUT, TransferMode.NONE)\n else -> return super.getValidConfigurations(type)\n }\n }\n\n companion object {\n const val CRAFTING_COMPONENT_ID = 4\n const val TANK_ID = 5\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/crafters/SolidInfuserBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.crafters\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.api.machines.TransferMode\nimport me.steven.indrev.api.sideconfigs.ConfigurationType\nimport me.steven.indrev.components.EnhancerComponent\nimport me.steven.indrev.components.TemperatureComponent\nimport me.steven.indrev.components.trackObject\nimport me.steven.indrev.inventories.inventory\nimport me.steven.indrev.items.upgrade.Enhancer\nimport me.steven.indrev.recipes.machines.IRRecipeType\nimport me.steven.indrev.recipes.machines.InfuserRecipe\nimport me.steven.indrev.registry.MachineRegistry\nimport net.minecraft.block.BlockState\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.math.Direction\n\nclass SolidInfuserBlockEntity(tier: Tier, pos: BlockPos, state: BlockState) :\n CraftingMachineBlockEntity(tier, MachineRegistry.SOLID_INFUSER_REGISTRY, pos, state) {\n\n init {\n this.temperatureComponent = TemperatureComponent(this, 0.06, 700..1100, 1400)\n this.enhancerComponent = EnhancerComponent(intArrayOf(5, 6, 7, 8), Enhancer.DEFAULT, this::getMaxCount)\n this.inventoryComponent = inventory(this) {\n input {\n slots = intArrayOf(2, 3)\n filter { _, dir, slot -> canInput(dir, slot) }\n }\n output { slot = 4 }\n }\n\n trackObject(CRAFTING_COMPONENT_ID, craftingComponents[0])\n }\n\n private fun canInput(side: Direction?, slot: Int): Boolean {\n if (side == null) return true\n return when (inventoryComponent!!.itemConfig[side]) {\n TransferMode.INPUT_FIRST -> slot == 2\n TransferMode.INPUT_SECOND -> slot == 3\n else -> true\n }\n }\n\n override fun getValidConfigurations(type: ConfigurationType): Array {\n return when (type) {\n ConfigurationType.ITEM -> TransferMode.SOLID_INFUSER\n else -> super.getValidConfigurations(type)\n }\n }\n\n override val type: IRRecipeType = InfuserRecipe.TYPE\n\n companion object {\n const val CRAFTING_COMPONENT_ID = 4\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/crafters/SolidInfuserFactoryBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.crafters\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.api.machines.TransferMode\nimport me.steven.indrev.api.sideconfigs.ConfigurationType\nimport me.steven.indrev.components.CraftingComponent\nimport me.steven.indrev.components.EnhancerComponent\nimport me.steven.indrev.components.TemperatureComponent\nimport me.steven.indrev.components.multiblock.MultiBlockComponent\nimport me.steven.indrev.components.multiblock.definitions.FactoryStructureDefinition\nimport me.steven.indrev.components.trackObject\nimport me.steven.indrev.inventories.inventory\nimport me.steven.indrev.items.upgrade.Enhancer\nimport me.steven.indrev.recipes.machines.IRRecipeType\nimport me.steven.indrev.recipes.machines.InfuserRecipe\nimport me.steven.indrev.registry.MachineRegistry\nimport net.minecraft.block.BlockState\nimport net.minecraft.nbt.NbtCompound\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.math.Direction\n\nclass SolidInfuserFactoryBlockEntity(tier: Tier, pos: BlockPos, state: BlockState) :\n CraftingMachineBlockEntity(tier, MachineRegistry.SOLID_INFUSER_FACTORY_REGISTRY, pos, state) {\n\n init {\n this.temperatureComponent = TemperatureComponent(this, 0.06, 700..1100, 1400)\n this.enhancerComponent = EnhancerComponent(intArrayOf(2, 3, 4, 5), Enhancer.DEFAULT, this::getMaxCount)\n this.inventoryComponent = inventory(this) {\n input {\n slots = intArrayOf(6, 7, 9, 10, 12, 13, 15, 16, 18, 19)\n filter { _, dir, slot -> canInput(dir, slot) }\n }\n output { slots = intArrayOf(8, 11, 14, 17, 20) }\n }\n this.craftingComponents = Array(5) { index ->\n val component = CraftingComponent(index, this).apply {\n inputSlots = intArrayOf(6 + (index * 3), 6 + (index * 3) + 1)\n outputSlots = intArrayOf(6 + (index * 3) + 2)\n }\n trackObject(CRAFTING_COMPONENT_START_ID + index, component)\n component\n }\n this.multiblockComponent = MultiBlockComponent(FactoryStructureDefinition.SELECTOR)\n }\n\n override val syncToWorld: Boolean = true\n\n override fun splitStacks() {\n splitStacks(TOP_SLOTS)\n splitStacks(BOTTOM_SLOTS)\n }\n\n private fun canInput(side: Direction?, slot: Int): Boolean {\n if (side == null) return true\n return when (inventoryComponent!!.itemConfig[side]) {\n TransferMode.INPUT_FIRST -> TOP_SLOTS.contains(slot)\n TransferMode.INPUT_SECOND -> BOTTOM_SLOTS.contains(slot)\n else -> true\n }\n }\n\n override fun getValidConfigurations(type: ConfigurationType): Array {\n return when (type) {\n ConfigurationType.ITEM -> TransferMode.SOLID_INFUSER\n else -> super.getValidConfigurations(type)\n }\n }\n\n override val type: IRRecipeType = InfuserRecipe.TYPE\n\n override fun fromClientTag(tag: NbtCompound) {\n multiblockComponent?.readNbt(tag)\n }\n\n override fun toClientTag(tag: NbtCompound) {\n multiblockComponent?.writeNbt(tag)\n }\n\n companion object {\n val TOP_SLOTS = intArrayOf(6, 9, 12, 15, 18)\n val BOTTOM_SLOTS = intArrayOf(7, 10, 13, 16, 19)\n const val CRAFTING_COMPONENT_START_ID = 4\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/farms/AOEMachineBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.farms\n\nimport io.netty.buffer.Unpooled\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.blockentities.MachineBlockEntity\nimport me.steven.indrev.config.IConfig\nimport me.steven.indrev.packets.common.UpdateAOEMachineRangePacket\nimport me.steven.indrev.registry.MachineRegistry\nimport net.fabricmc.fabric.api.client.networking.v1.ClientPlayNetworking\nimport net.minecraft.block.BlockState\nimport net.minecraft.nbt.NbtCompound\nimport net.minecraft.network.PacketByteBuf\nimport net.minecraft.screen.ScreenHandlerContext\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.math.Box\n\nabstract class AOEMachineBlockEntity(tier: Tier, registry: MachineRegistry, pos: BlockPos, state: BlockState) : MachineBlockEntity(tier, registry, pos, state) {\n override val syncToWorld: Boolean = true\n\n var renderWorkingArea = false\n abstract var range: Int\n open fun getWorkingArea(): Box {\n val box = Box(pos)\n return box.expand(range.toDouble(), 0.0, range.toDouble()).stretch(0.0, range.toDouble() * 2, 0.0)\n }\n\n override fun toTag(tag: NbtCompound) {\n tag.putInt(\"range\", range)\n super.toTag(tag)\n }\n\n override fun toClientTag(tag: NbtCompound) {\n tag.putInt(\"range\", range)\n }\n\n override fun fromTag(tag: NbtCompound) {\n super.fromTag(tag)\n range = tag.getInt(\"range\")\n }\n\n override fun fromClientTag(tag: NbtCompound) {\n range = tag.getInt(\"range\")\n }\n\n companion object {\n fun sendValueUpdatePacket(value: Int, ctx: ScreenHandlerContext) {\n if (value > 0) {\n val packet = PacketByteBuf(Unpooled.buffer())\n packet.writeInt(value)\n ctx.run { _, pos -> packet.writeBlockPos(pos) }\n ClientPlayNetworking.send(UpdateAOEMachineRangePacket.UPDATE_VALUE_PACKET_ID, packet)\n }\n }\n\n\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/farms/AOEMachineBlockEntityRenderer.kt",
"content": "package me.steven.indrev.blockentities.farms\n\nimport net.minecraft.client.render.RenderLayer\nimport net.minecraft.client.render.VertexConsumerProvider\nimport net.minecraft.client.render.WorldRenderer\nimport net.minecraft.client.render.block.entity.BlockEntityRenderer\nimport net.minecraft.client.util.math.MatrixStack\n\nopen class AOEMachineBlockEntityRenderer : BlockEntityRenderer> {\n override fun render(\n blockEntity: AOEMachineBlockEntity<*>,\n tickDelta: Float,\n matrices: MatrixStack?,\n vertexConsumers: VertexConsumerProvider,\n light: Int,\n overlay: Int\n ) {\n if (blockEntity.renderWorkingArea) {\n val pos = blockEntity.pos\n val area = blockEntity.getWorkingArea().offset(-pos.x.toDouble(), -pos.y.toDouble(), -pos.z.toDouble())\n val vc = vertexConsumers.getBuffer(RenderLayer.getLines())\n WorldRenderer.drawBox(matrices, vc, area, 1f, 0f, 1f, 1f)\n }\n }\n\n override fun rendersOutsideBoundingBox(blockEntity: AOEMachineBlockEntity<*>?): Boolean = true\n\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/farms/BiomassComposterBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.farms\n\nimport alexiil.mc.lib.attributes.fluid.amount.FluidAmount\nimport alexiil.mc.lib.attributes.fluid.render.FluidRenderFace\nimport alexiil.mc.lib.attributes.fluid.volume.FluidKeys\nimport me.steven.indrev.blockentities.BaseBlockEntity\nimport me.steven.indrev.blocks.misc.BiomassComposterBlock\nimport me.steven.indrev.registry.IRBlockRegistry\nimport me.steven.indrev.registry.IRFluidRegistry\nimport me.steven.indrev.registry.IRItemRegistry\nimport me.steven.indrev.utils.bucket\nimport net.fabricmc.fabric.api.transfer.v1.fluid.FluidVariant\nimport net.fabricmc.fabric.api.transfer.v1.item.ItemVariant\nimport net.fabricmc.fabric.api.transfer.v1.storage.StoragePreconditions\nimport net.fabricmc.fabric.api.transfer.v1.storage.base.SingleVariantStorage\nimport net.fabricmc.fabric.api.transfer.v1.transaction.TransactionContext\nimport net.minecraft.block.BlockState\nimport net.minecraft.block.ComposterBlock\nimport net.minecraft.client.render.VertexConsumerProvider\nimport net.minecraft.client.util.math.MatrixStack\nimport net.minecraft.fluid.Fluids\nimport net.minecraft.nbt.NbtCompound\nimport net.minecraft.util.math.BlockPos\n\nclass BiomassComposterBlockEntity(pos: BlockPos, state: BlockState) : BaseBlockEntity(IRBlockRegistry.BIOMASS_COMPOSTER_BLOCK_ENTITY, pos, state) {\n\n var ticks = 0\n var level = 0\n val fluidInv = BiomassComposterFluidInv()\n val itemInv = BiomassComposterItemInv()\n\n companion object {\n fun tick(state: BlockState, blockEntity: BiomassComposterBlockEntity) {\n val vol = blockEntity.fluidInv\n if (blockEntity.isInProgress()) {\n blockEntity.ticks++\n }\n if (blockEntity.isReady() && state[BiomassComposterBlock.CLOSED] && vol.amount > 0 && vol.resource.isOf(Fluids.WATER)) {\n blockEntity.fluidInv.variant = FluidVariant.of(IRFluidRegistry.METHANE_STILL)\n blockEntity.reset()\n } else if (blockEntity.isReady() && !blockEntity.hasFluids()) {\n blockEntity.itemInv.amount = 1\n blockEntity.itemInv.variant = ItemVariant.of(IRItemRegistry.BIOMASS)\n blockEntity.reset()\n }\n\n blockEntity.doneInsertionThisTick = false\n }\n }\n\n private var doneInsertionThisTick = false\n\n private fun hasFluids() = !fluidInv.isResourceBlank && fluidInv.amount > 0\n\n fun isReady() = level >= 7 && ticks >= getProgressTime()\n\n fun reset() {\n level = 0\n ticks = 0\n markDirty()\n if (!world!!.isClient)\n sync()\n }\n\n fun isInProgress(): Boolean {\n return when {\n level < 7 -> false\n cachedState[BiomassComposterBlock.CLOSED] -> fluidInv.variant.isOf(Fluids.WATER)\n else -> !hasFluids()\n } && ticks < getProgressTime()\n }\n\n fun getProgressTime() = if (!cachedState[BiomassComposterBlock.CLOSED]) 120 else 440\n\n inner class BiomassComposterFluidInv : SingleVariantStorage() {\n override fun canInsert(variant: FluidVariant): Boolean = variant.isOf(Fluids.WATER)\n\n override fun canExtract(variant: FluidVariant): Boolean = variant.isOf(IRFluidRegistry.METHANE_STILL)\n\n override fun getCapacity(variant: FluidVariant?): Long = bucket\n\n override fun getBlankVariant(): FluidVariant = FluidVariant.blank()\n\n fun render(faces: List?, vcp: VertexConsumerProvider?, matrices: MatrixStack?) {\n if (!variant.isBlank)\n FluidKeys.get(variant.fluid).withAmount(FluidAmount.BUCKET).render(faces, vcp, matrices)\n }\n }\n\n inner class BiomassComposterItemInv : SingleVariantStorage() {\n\n override fun canInsert(variant: ItemVariant): Boolean = ComposterBlock.ITEM_TO_LEVEL_INCREASE_CHANCE.contains(variant.item) && level < 7 && !doneInsertionThisTick\n\n override fun insert(insertedVariant: ItemVariant, maxAmount: Long, transaction: TransactionContext?): Long {\n StoragePreconditions.notBlankNotNegative(insertedVariant, maxAmount)\n\n if ((insertedVariant == variant || variant.isBlank) && canInsert(insertedVariant)) {\n\n val chance = ComposterBlock.ITEM_TO_LEVEL_INCREASE_CHANCE.getValue(variant.item)\n val insertedAmount = maxAmount.coerceAtMost(getCapacity(insertedVariant) - amount)\n var actuallyInserted = 0L\n for (x in 0 until insertedAmount) {\n if (world!!.random.nextDouble() < chance) {\n actuallyInserted++\n }\n }\n if (insertedAmount > 0) {\n updateSnapshots(transaction)\n if (variant.isBlank) {\n variant = insertedVariant\n amount = actuallyInserted\n } else {\n amount += actuallyInserted\n }\n doneInsertionThisTick = true\n }\n return insertedAmount\n }\n\n return 0\n }\n\n override fun getCapacity(variant: ItemVariant): Long = 7 - level.toLong()\n\n override fun canExtract(variant: ItemVariant): Boolean = variant.isOf(IRItemRegistry.BIOMASS)\n\n override fun getBlankVariant(): ItemVariant = ItemVariant.blank()\n }\n\n override fun toTag(tag: NbtCompound) {\n tag.putInt(\"ticks\", ticks)\n tag.putInt(\"level\", level)\n tag.put(\"fluidVariant\", fluidInv.variant.toNbt())\n tag.putLong(\"fluidAmt\", fluidInv.amount)\n tag.put(\"itemVariant\", itemInv.variant.toNbt())\n tag.putLong(\"itemAmt\", itemInv.amount)\n }\n\n override fun fromTag(tag: NbtCompound) {\n ticks = tag.getInt(\"ticks\")\n level = tag.getInt(\"level\")\n fluidInv.variant = FluidVariant.fromNbt(tag.getCompound(\"fluidVariant\"))\n fluidInv.amount = tag.getLong(\"fluidAmt\")\n itemInv.variant = ItemVariant.fromNbt(tag.getCompound(\"itemVariant\"))\n itemInv.amount = tag.getLong(\"itemAmt\")\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/farms/BiomassComposterBlockEntityRenderer.kt",
"content": "package me.steven.indrev.blockentities.farms\n\nimport alexiil.mc.lib.attributes.fluid.render.FluidRenderFace\nimport me.steven.indrev.blocks.misc.BiomassComposterBlock\nimport me.steven.indrev.utils.bucket\nimport me.steven.indrev.utils.identifier\nimport net.minecraft.client.MinecraftClient\nimport net.minecraft.client.render.OverlayTexture\nimport net.minecraft.client.render.RenderLayer\nimport net.minecraft.client.render.VertexConsumerProvider\nimport net.minecraft.client.render.WorldRenderer\nimport net.minecraft.client.render.block.entity.BlockEntityRenderer\nimport net.minecraft.client.util.ModelIdentifier\nimport net.minecraft.client.util.math.MatrixStack\n\nclass BiomassComposterBlockEntityRenderer : BlockEntityRenderer {\n override fun render(\n entity: BiomassComposterBlockEntity,\n tickDelta: Float,\n matrices: MatrixStack,\n vertexConsumers: VertexConsumerProvider,\n light: Int,\n overlay: Int\n ) {\n if (entity.cachedState[BiomassComposterBlock.CLOSED]) return\n matrices.run {\n\n if (entity.level > 0) {\n push()\n translate(0.0, ((((entity.level - 1) * 2)) / 16.0), 0.0)\n\n val model = MinecraftClient.getInstance().bakedModelManager.getModel(ModelIdentifier(identifier(\"composting\"), \"\"))\n MinecraftClient.getInstance().blockRenderManager.modelRenderer.render(\n matrices.peek(),\n vertexConsumers.getBuffer(RenderLayer.getTranslucent()),\n null,\n model,\n -1f,\n -1f,\n -1f,\n WorldRenderer.getLightmapCoordinates(entity.world, entity.pos.up()),\n OverlayTexture.DEFAULT_UV\n )\n pop()\n }\n push()\n val vol = entity.fluidInv.amount / bucket.toDouble()\n translate(0.0, vol, 0.0)\n entity.fluidInv.render(FACE, vertexConsumers, matrices)\n pop()\n }\n }\n\n companion object {\n private val FACE = listOf(FluidRenderFace.createFlatFaceY(0.125, 0.0, 0.125, 0.875, 0.0, 0.875, 1.0, true, false))\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/farms/ChopperBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.farms\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.components.EnhancerComponent\nimport me.steven.indrev.config.BasicMachineConfig\nimport me.steven.indrev.inventories.inventory\nimport me.steven.indrev.items.upgrade.Enhancer\nimport me.steven.indrev.registry.MachineRegistry\nimport me.steven.indrev.utils.*\nimport net.minecraft.block.*\nimport net.minecraft.item.AxeItem\nimport net.minecraft.item.BlockItem\nimport net.minecraft.item.BoneMealItem\nimport net.minecraft.item.ItemStack\nimport net.minecraft.item.SwordItem\nimport net.minecraft.loot.context.LootContext\nimport net.minecraft.loot.context.LootContextParameters\nimport net.minecraft.server.world.ServerWorld\nimport net.minecraft.tag.BlockTags\nimport net.minecraft.tag.ItemTags\nimport net.minecraft.util.ItemScatterer\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.math.Box\nimport net.minecraft.world.chunk.Chunk\n\nclass ChopperBlockEntity(tier: Tier, pos: BlockPos, state: BlockState) : AOEMachineBlockEntity(tier, MachineRegistry.CHOPPER_REGISTRY, pos, state) {\n \n init {\n this.enhancerComponent = EnhancerComponent(intArrayOf(15, 16, 17, 18), Enhancer.DEFAULT, this::getMaxCount)\n this.inventoryComponent = inventory(this) {\n input {\n slots = intArrayOf(2, 3, 4, 5)\n //todo tool tags?\n 2 filter { stack -> stack.item is AxeItem || stack.item is SwordItem }\n 3 filter { (_, item) -> item is BoneMealItem }\n 4..5 filter { (stack, item), _ -> stack.isIn(ItemTags.SAPLINGS)\n || (item is BlockItem && (item.block is MushroomPlantBlock || item.block is BambooBlock)) }\n }\n output { slots = intArrayOf(6, 7, 8, 9, 10, 11, 12, 13, 14) }\n coolerSlot = 1\n }\n }\n\n override val maxInput: Long = config.maxInput\n override val maxOutput: Long = 0\n\n private var scheduledBlocks = mutableListOf().iterator()\n private val scannedBlocks = mutableSetOf()\n override var range = 5\n var cooldown = 0.0\n\n override fun machineTick() {\n if (world?.isClient == true) return\n val inventory = inventoryComponent?.inventory ?: return\n cooldown += getProcessingSpeed()\n if (cooldown < config.processSpeed || ticks % 15 != 0 || !canUse(getEnergyCost()))\n return\n val area = getWorkingArea()\n if (!scheduledBlocks.hasNext()) {\n // includes tree branches that goes outside the actual area\n val fullArea = area.expand(4.0).shrink(0.0, -4.0, 0.0)\n scheduledBlocks = fullArea.map(::BlockPos).iterator()\n scannedBlocks.clear()\n } else {\n var currentChunk: Chunk? = null\n var performedActions = 0\n val axeStack = inventory.getStack(2)\n val brokenBlocks = hashMapOf()\n while (scheduledBlocks.hasNext() && cooldown >= config.processSpeed) {\n val pos = scheduledBlocks.next()\n if (!scannedBlocks.add(pos)) continue\n if (pos.x shr 4 != currentChunk?.pos?.x || pos.z shr 4 != currentChunk.pos.z) {\n currentChunk = world?.getChunk(pos)\n }\n val blockState = currentChunk?.getBlockState(pos) ?: continue\n if (axeStack != null\n && !axeStack.isEmpty\n && tryChop(axeStack, pos, blockState, currentChunk)\n ) {\n cooldown -= config.processSpeed\n if (!use(getEnergyCost())) break\n brokenBlocks[pos] = blockState\n performedActions++\n }\n if (pos.y == this.pos.y && pos in area) {\n for (slot in 3..5) {\n val stack = inventory.getStack(slot)\n if (stack.isEmpty || !tryUse(blockState, stack, pos)) continue\n cooldown -= config.processSpeed\n if (!use(getEnergyCost())) break\n brokenBlocks[pos] = blockState\n performedActions++\n }\n }\n }\n brokenBlocks.forEach { (blockPos, blockState) ->\n val droppedStacks = blockState.getDroppedStacks(\n LootContext.Builder(world as ServerWorld).random(world?.random)\n .parameter(LootContextParameters.ORIGIN, blockPos.toVec3d())\n .parameter(LootContextParameters.TOOL, axeStack)\n )\n droppedStacks.forEach {\n if (!inventory.output(it))\n ItemScatterer.spawn(world, blockPos.x.toDouble(), blockPos.y.toDouble(), blockPos.z.toDouble(), it)\n }\n }\n temperatureComponent?.tick(performedActions > 0)\n workingState = performedActions > 0\n }\n cooldown = 0.0\n }\n\n private fun tryChop(\n toolStack: ItemStack,\n blockPos: BlockPos,\n blockState: BlockState,\n chunk: Chunk\n ): Boolean {\n fun damageTool(amount: Int): Boolean {\n return when {\n energyOf(toolStack) != null -> energyOf(toolStack)!!.use(amount.toLong())\n toolStack.isEmpty -> false\n toolStack.isDamageable -> {\n toolStack.damage(amount, world?.random, null)\n if (toolStack.damage >= toolStack.maxDamage)\n toolStack.decrement(1)\n true\n }\n else -> true\n }\n }\n val block = blockState.block\n when {\n toolStack.item is AxeItem\n && (blockState.isIn(BlockTags.LOGS) || block is MushroomBlock || block == Blocks.MUSHROOM_STEM) -> {\n if (!damageTool(1)) return false\n world?.setBlockState(blockPos, Blocks.AIR.defaultState, 3)\n }\n block is LeavesBlock -> {\n world?.setBlockState(blockPos, Blocks.AIR.defaultState, 3)\n }\n toolStack.item is SwordItem && block is BambooBlock && blockPos.y > pos.y -> {\n val upPos = blockPos.up()\n val up = chunk.getBlockState(upPos)\n scannedBlocks.add(upPos)\n if (up.isOf(block))\n tryChop(toolStack, upPos, blockState, chunk)\n if (!damageTool(2)) return false\n world?.setBlockState(blockPos, Blocks.AIR.defaultState, 3)\n }\n else -> return false\n }\n return true\n }\n\n private fun tryUse(blockState: BlockState, itemStack: ItemStack, pos: BlockPos): Boolean {\n val item = itemStack.item\n val block = blockState.block\n when {\n item is BoneMealItem && itemStack.count > 1\n && (blockState.isIn(BlockTags.SAPLINGS) || block is MushroomPlantBlock || block is BambooBlock || block is BambooSaplingBlock)\n && block is Fertilizable\n && block.isFertilizable(world, pos, blockState, false)\n && block.canGrow(world, world?.random, pos, blockState) -> {\n block.grow(world as ServerWorld, world?.random, pos, blockState)\n world?.syncWorldEvent(2005, pos, 0)\n itemStack.decrement(1)\n }\n block is AirBlock\n && item is BlockItem\n && (itemStack.isIn(ItemTags.SAPLINGS) || item.block is MushroomPlantBlock || item.block is BambooBlock)\n && item.block.defaultState.canPlaceAt(world, pos)\n && itemStack.count > 1 -> {\n if (item.block is BambooBlock)\n world?.setBlockState(pos, Blocks.BAMBOO_SAPLING.defaultState, 3)\n else\n world?.setBlockState(pos, item.block.defaultState, 3)\n itemStack.decrement(1)\n }\n else -> return false\n }\n return true\n }\n\n override fun getEnergyCost(): Long {\n val speedEnhancers = (enhancerComponent!!.getCount(Enhancer.SPEED) * 2).coerceAtLeast(1)\n return config.energyCost * speedEnhancers\n }\n\n override fun getWorkingArea(): Box {\n val box = Box(pos)\n return box.expand(range.toDouble(), 0.0, range.toDouble()).stretch(0.0, 40.0, 0.0)\n }\n \n fun getMaxCount(enhancer: Enhancer): Int {\n return when (enhancer) {\n Enhancer.SPEED -> return 12\n Enhancer.BUFFER -> 4\n else -> 1\n }\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/farms/ChopperBlockEntityRenderer.kt",
"content": "package me.steven.indrev.blockentities.farms\n\nimport net.minecraft.client.render.RenderLayer\nimport net.minecraft.client.render.VertexConsumerProvider\nimport net.minecraft.client.render.WorldRenderer\nimport net.minecraft.client.util.math.MatrixStack\n\nclass ChopperBlockEntityRenderer : AOEMachineBlockEntityRenderer() {\n override fun render(\n blockEntity: AOEMachineBlockEntity<*>,\n tickDelta: Float,\n matrices: MatrixStack?,\n vertexConsumers: VertexConsumerProvider,\n light: Int,\n overlay: Int\n ) {\n super.render(blockEntity, tickDelta, matrices, vertexConsumers, light, overlay)\n if (blockEntity.renderWorkingArea) {\n val pos = blockEntity.pos\n val area = blockEntity.getWorkingArea().offset(-pos.x.toDouble(), -pos.y.toDouble(), -pos.z.toDouble()).expand(4.0, 0.0, 4.0)\n val vc = vertexConsumers.getBuffer(RenderLayer.getLines())\n WorldRenderer.drawBox(matrices, vc, area, 1f, 0.2f, 0.2f, 1f)\n }\n\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/farms/DirtOxygenatorBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.farms\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.blockentities.MachineBlockEntity\nimport me.steven.indrev.blocks.machine.FacingMachineBlock\nimport me.steven.indrev.config.MachineConfig\nimport me.steven.indrev.registry.IRFluidRegistry\nimport me.steven.indrev.registry.MachineRegistry\nimport me.steven.indrev.utils.bucket\nimport net.fabricmc.fabric.api.transfer.v1.fluid.FluidVariant\nimport net.fabricmc.fabric.api.transfer.v1.storage.base.SingleVariantStorage\nimport net.minecraft.block.BlockState\nimport net.minecraft.block.Fertilizable\nimport net.minecraft.server.world.ServerWorld\nimport net.minecraft.util.math.BlockPos\n\nclass DirtOxygenatorBlockEntity(pos: BlockPos, state: BlockState) : MachineBlockEntity(Tier.MK1, MachineRegistry.DIRT_OXYGENATOR_REGISTRY, pos, state) {\n\n private var streak = 0\n private var ticksUntilReset = 40\n val fluidInv = FluidStorage()\n\n\n override fun machineTick() {\n val target = pos.offset(cachedState[FacingMachineBlock.FACING]).up()\n val targetState = world!!.getBlockState(target)\n val block = targetState.block\n if (block !is Fertilizable || !targetState.canPlaceAt(world, target)) return\n if (fluidInv.amount <= 0) {\n ticksUntilReset--\n if (ticksUntilReset <= 0)\n streak = 0\n return\n } else {\n streak++\n ticksUntilReset = 40\n }\n val chance = (streak / 300.0).coerceIn(0.0, 1.0) * 0.6\n if (world!!.random.nextDouble() < chance) {\n if (\n block.isFertilizable(world, pos, targetState, false)\n && block.canGrow(world, world!!.random, target, targetState)\n ) {\n block.grow(world as ServerWorld, world!!.random, target, targetState)\n }\n }\n\n fluidInv.variant = FluidVariant.blank()\n fluidInv.amount = 0\n }\n\n inner class FluidStorage : SingleVariantStorage() {\n\n override fun canExtract(variant: FluidVariant): Boolean = false\n\n override fun canInsert(variant: FluidVariant): Boolean = variant.isOf(IRFluidRegistry.OXYGEN_STILL)\n\n override fun getCapacity(variant: FluidVariant): Long = bucket\n\n override fun getBlankVariant(): FluidVariant = FluidVariant.blank()\n }\n}\n"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/farms/DrainBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.farms\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.api.machines.TransferMode\nimport me.steven.indrev.api.sideconfigs.ConfigurationType\nimport me.steven.indrev.blockentities.MachineBlockEntity\nimport me.steven.indrev.components.FluidComponent\nimport me.steven.indrev.config.BasicMachineConfig\nimport me.steven.indrev.registry.MachineRegistry\nimport me.steven.indrev.utils.bucket\nimport me.steven.indrev.utils.contains\nimport me.steven.indrev.utils.drainFluid\nimport net.fabricmc.fabric.api.transfer.v1.fluid.FluidVariant\nimport net.minecraft.block.BlockState\nimport net.minecraft.block.FluidBlock\nimport net.minecraft.block.FluidDrainable\nimport net.minecraft.fluid.FlowableFluid\nimport net.minecraft.fluid.Fluid\nimport net.minecraft.fluid.Fluids\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.math.Box\nimport net.minecraft.util.math.Direction\n\nclass DrainBlockEntity(tier: Tier, pos: BlockPos, state: BlockState) : MachineBlockEntity(tier, MachineRegistry.DRAIN_REGISTRY, pos, state) {\n\n init {\n this.fluidComponent = object : FluidComponent({ this }, bucket) {\n init {\n this.outputTanks = intArrayOf(0)\n }\n }\n }\n\n override val maxInput: Long = config.maxInput\n\n override fun machineTick() {\n val world = world ?: return\n val fluidComponent = fluidComponent ?: return\n if (ticks % 20 == 0 || !fluidComponent[0].isEmpty) return\n\n val fluidState = world.getFluidState(pos.up())\n if (fluidState?.isEmpty == false) {\n val range = getWorkingArea()\n // DOWN is intentionally excluded\n val directions = arrayOf(Direction.UP, Direction.NORTH, Direction.SOUTH, Direction.WEST, Direction.EAST)\n val mutablePos = pos.mutableCopy()\n val fluid = getStill(fluidState.fluid)\n val bfs = mutableListOf(pos.up())\n var i = 0\n while (i < bfs.size) {\n val current = bfs[i++]\n for (dir in directions) {\n mutablePos.set(current, dir)\n if (mutablePos !in bfs && mutablePos in range && getStill(world.getFluidState(mutablePos).fluid) === fluid) {\n bfs.add(mutablePos.toImmutable())\n }\n }\n }\n bfs.sortByDescending { it.y }\n\n for (pos in bfs) {\n val blockState = world.getBlockState(pos)\n val block = blockState?.block\n if (block is FluidDrainable && block is FluidBlock) {\n val drained = block.drainFluid(world, pos, blockState)\n if (drained != Fluids.EMPTY) {\n fluidComponent[0].insert(FluidVariant.of(drained), bucket, true)\n return\n }\n }\n }\n }\n }\n\n private fun getStill(fluid: Fluid): Fluid = if (fluid is FlowableFluid) fluid.still else fluid\n\n fun getWorkingArea(): Box = Box(pos.up()).expand(8.0, 0.0, 8.0).stretch(0.0, 4.0, 0.0)\n\n override fun applyDefault(\n state: BlockState,\n type: ConfigurationType,\n configuration: MutableMap\n ) {\n Direction.values().forEach { dir -> configuration[dir] = TransferMode.OUTPUT }\n }\n\n override fun isFixed(type: ConfigurationType): Boolean = true\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/farms/FarmerBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.farms\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.components.EnhancerComponent\nimport me.steven.indrev.config.BasicMachineConfig\nimport me.steven.indrev.inventories.inventory\nimport me.steven.indrev.items.upgrade.Enhancer\nimport me.steven.indrev.registry.MachineRegistry\nimport me.steven.indrev.utils.map\nimport me.steven.indrev.utils.toVec3d\nimport net.minecraft.block.*\nimport net.minecraft.item.BlockItem\nimport net.minecraft.item.BoneMealItem\nimport net.minecraft.item.Item\nimport net.minecraft.item.ItemStack\nimport net.minecraft.loot.context.LootContext\nimport net.minecraft.loot.context.LootContextParameters\nimport net.minecraft.server.world.ServerWorld\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.math.Box\nimport net.minecraft.util.math.Direction\n\nclass FarmerBlockEntity(tier: Tier, pos: BlockPos, state: BlockState)\n : AOEMachineBlockEntity(tier, MachineRegistry.FARMER_REGISTRY, pos, state) {\n\n init {\n this.enhancerComponent = EnhancerComponent(intArrayOf(14, 15, 16, 17), Enhancer.DEFAULT, this::getMaxCount)\n this.inventoryComponent = inventory(this) {\n input { slots = intArrayOf(1, 2, 3, 4) }\n output { slots = intArrayOf(5, 6, 7, 8, 9, 10, 11, 12, 13) }\n }\n }\n\n override val maxInput: Long = config.maxInput\n override val maxOutput: Long = 0\n\n override var range: Int = 5\n\n var cooldown = 0.0\n private var nextBlocks = emptyList().iterator()\n\n override fun machineTick() {\n cooldown += getProcessingSpeed()\n if (cooldown < config.processSpeed) return\n val world = world as ServerWorld\n val energyCost = config.energyCost\n if (!canUse(energyCost)) return\n if (nextBlocks.hasNext()) {\n while (nextBlocks.hasNext()) {\n val pos = nextBlocks.next()\n val state = world.getBlockState(pos)\n if (state.block != Blocks.SUGAR_CANE)\n tryHarvest(state, pos, world)\n else {\n for (i in 5 downTo 1) {\n val posToHarvest = pos.up(i)\n val toHarvest = world.getBlockState(posToHarvest)\n if (toHarvest.block == Blocks.SUGAR_CANE) {\n tryHarvest(state, posToHarvest, world)\n }\n }\n }\n }\n } else {\n nextBlocks = getWorkingArea().map(::BlockPos).iterator()\n }\n cooldown = 0.0\n }\n\n private fun tryHarvest(state: BlockState, pos: BlockPos, world: ServerWorld): Boolean {\n val block = state.block\n\n val inventory = inventoryComponent?.inventory\n val performedAction = inventory?.inputSlots?.any { slot ->\n val stack = inventory.getStack(slot)\n val item = stack.item\n val isCropBlock = block is CropBlock || block is StemBlock || block is SweetBerryBushBlock || block is CocoaBlock || block is NetherWartBlock\n when {\n item is BoneMealItem && isCropBlock && (block as? Fertilizable)?.isFertilizable(world, pos, state, false) == true && block.canGrow(world, world.random, pos, state) -> {\n stack.decrement(1)\n block.grow(world, world.random, pos, state)\n world.syncWorldEvent(2005, pos, 0)\n true\n }\n canHarvest(slot, state, block, item) -> {\n if ((block is CropBlock || block is SweetBerryBushBlock) && stack.count > 1) {\n world.setBlockState(pos, block.defaultState)\n stack.decrement(1)\n } else {\n world.setBlockState(pos, Blocks.AIR.defaultState)\n }\n val droppedStacks = state.getDroppedStacks(LootContext.Builder(world)\n .random(world.random)\n .parameter(LootContextParameters.ORIGIN, pos.toVec3d())\n .parameter(LootContextParameters.BLOCK_STATE, state)\n .parameter(LootContextParameters.TOOL, ItemStack.EMPTY))\n droppedStacks.forEach { inventory.output(it) }\n true\n }\n block is AirBlock && canPlant(item) && stack.count > 1 -> {\n var cropState = (item as BlockItem).block.defaultState\n\n if (item.block is CocoaBlock) {\n arrayOf(Direction.NORTH, Direction.EAST, Direction.SOUTH, Direction.WEST).firstOrNull {\n cropState = cropState.with(CocoaBlock.FACING, it)\n cropState.canPlaceAt(world, pos)\n } ?: return@any false\n }\n\n if (cropState.canPlaceAt(world, pos) && world.isAir(pos)) {\n world.setBlockState(pos, cropState)\n stack.count--\n true\n } else false\n }\n else -> false\n }\n } ?: false\n if (performedAction)\n use(getEnergyCost())\n return performedAction\n }\n\n override fun getEnergyCost(): Long {\n val speedEnhancers = (enhancerComponent!!.getCount(Enhancer.SPEED) * 2).coerceAtLeast(1)\n return config.energyCost * speedEnhancers\n }\n\n private fun canPlant(item: Item) =\n item is BlockItem && (\n item.block is CropBlock\n || item.block is StemBlock\n || item.block == Blocks.SUGAR_CANE\n || item.block is SweetBerryBushBlock\n || item.block is CocoaBlock\n || item.block is NetherWartBlock\n )\n\n private fun canHarvest(slot: Int, state: BlockState, block: Block, item: Item): Boolean =\n (((block is CropBlock && block.isMature(state))\n || (block is SweetBerryBushBlock && state[SweetBerryBushBlock.AGE] == 2))\n && (item is BlockItem && item.block == block || slot == 4))\n || block is GourdBlock\n || block == Blocks.SUGAR_CANE\n || (block is CocoaBlock && state[CocoaBlock.AGE] == 2)\n || (block is NetherWartBlock && state[NetherWartBlock.AGE] == 3)\n\n override fun getWorkingArea(): Box = Box(pos).expand(range.toDouble(), 0.0, range.toDouble())\n\n fun getMaxCount(enhancer: Enhancer): Int {\n return when (enhancer) {\n Enhancer.SPEED -> return 1\n Enhancer.BUFFER -> 4\n else -> 1\n }\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/farms/FisherBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.farms\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.blockentities.MachineBlockEntity\nimport me.steven.indrev.components.EnhancerComponent\nimport me.steven.indrev.config.BasicMachineConfig\nimport me.steven.indrev.inventories.inventory\nimport me.steven.indrev.items.upgrade.Enhancer\nimport me.steven.indrev.registry.MachineRegistry\nimport me.steven.indrev.utils.component1\nimport me.steven.indrev.utils.component2\nimport me.steven.indrev.utils.toVec3d\nimport net.minecraft.block.BlockState\nimport net.minecraft.item.FishingRodItem\nimport net.minecraft.loot.context.LootContext\nimport net.minecraft.loot.context.LootContextParameters\nimport net.minecraft.loot.context.LootContextTypes\nimport net.minecraft.server.world.ServerWorld\nimport net.minecraft.util.Identifier\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.math.Direction\n\nclass FisherBlockEntity(tier: Tier, pos: BlockPos, state: BlockState)\n : MachineBlockEntity(tier, MachineRegistry.FISHER_REGISTRY, pos, state) {\n\n init {\n this.enhancerComponent = EnhancerComponent(intArrayOf(6, 7, 8, 9), Enhancer.DEFAULT, this::getMaxCount)\n this.inventoryComponent = inventory(this) {\n input {\n slot = 1\n filter { (_, item), _ -> item is FishingRodItem }\n }\n output { slots = intArrayOf(2, 3, 4, 5) }\n }\n }\n\n private var cooldown = config.processSpeed\n \n override val maxInput: Long = config.maxInput\n override val maxOutput: Long = 0\n\n override fun machineTick() {\n if (!canUse(getEnergyCost())) return\n val rodStack = inventoryComponent!!.inventory.getStack(1)\n if (rodStack.isEmpty || rodStack.item !is FishingRodItem || !use(getEnergyCost())) return\n cooldown += getProcessingSpeed()\n if (cooldown < config.processSpeed) return\n cooldown = 0.0\n Direction.values().forEach { direction ->\n val pos = pos.offset(direction)\n if (world?.isWater(pos) == true) {\n val identifiers = getIdentifiers(tier)\n val id = identifiers[world!!.random!!.nextInt(identifiers.size)]\n val lootTable = (world as ServerWorld).server.lootManager.getTable(id)\n val ctx = LootContext.Builder(world as ServerWorld).random(world!!.random)\n .parameter(LootContextParameters.ORIGIN, pos.toVec3d())\n .parameter(LootContextParameters.TOOL, rodStack)\n .build(LootContextTypes.FISHING)\n val loot = lootTable.generateLoot(ctx)\n loot.forEach { stack -> inventoryComponent?.inventory?.output(stack) }\n rodStack?.apply {\n damage++\n if (damage >= maxDamage) decrement(1)\n }\n }\n }\n }\n\n override fun getEnergyCost(): Long {\n val speedEnhancers = (enhancerComponent!!.getCount(Enhancer.SPEED) * 2).coerceAtLeast(1)\n return config.energyCost * speedEnhancers\n }\n\n private fun getIdentifiers(tier: Tier) = when (tier) {\n Tier.MK2 -> arrayOf(FISH_IDENTIFIER)\n Tier.MK3 -> arrayOf(FISH_IDENTIFIER, FISH_IDENTIFIER, JUNK_IDENTIFIER, JUNK_IDENTIFIER, TREASURE_IDENTIFIER)\n else -> arrayOf(FISH_IDENTIFIER, FISH_IDENTIFIER, FISH_IDENTIFIER, TREASURE_IDENTIFIER)\n }\n\n fun getMaxCount(enhancer: Enhancer): Int {\n return when (enhancer) {\n Enhancer.SPEED, Enhancer.BUFFER -> 4\n else -> 1\n }\n }\n\n companion object {\n private val FISH_IDENTIFIER = Identifier(\"gameplay/fishing/fish\")\n private val JUNK_IDENTIFIER = Identifier(\"gameplay/fishing/junk\")\n private val TREASURE_IDENTIFIER = Identifier(\"gameplay/fishing/treasure\")\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/farms/PumpBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.farms\n\nimport it.unimi.dsi.fastutil.longs.LongArrayFIFOQueue\nimport it.unimi.dsi.fastutil.longs.LongOpenHashSet\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.api.machines.TransferMode\nimport me.steven.indrev.api.sideconfigs.ConfigurationType\nimport me.steven.indrev.blockentities.MachineBlockEntity\nimport me.steven.indrev.blocks.machine.HorizontalFacingMachineBlock\nimport me.steven.indrev.components.*\nimport me.steven.indrev.config.BasicMachineConfig\nimport me.steven.indrev.config.IRConfig\nimport me.steven.indrev.inventories.inventory\nimport me.steven.indrev.items.upgrade.Enhancer\nimport me.steven.indrev.registry.MachineRegistry\nimport me.steven.indrev.utils.bucket\nimport me.steven.indrev.utils.drainFluid\nimport net.fabricmc.fabric.api.transfer.v1.fluid.FluidVariant\nimport net.minecraft.block.BlockState\nimport net.minecraft.block.FluidBlock\nimport net.minecraft.block.FluidDrainable\nimport net.minecraft.fluid.FlowableFluid\nimport net.minecraft.fluid.Fluid\nimport net.minecraft.fluid.FluidState\nimport net.minecraft.fluid.Fluids\nimport net.minecraft.nbt.NbtCompound\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.math.Direction\nimport kotlin.math.floor\nimport kotlin.math.roundToInt\n\nclass PumpBlockEntity(tier: Tier, pos: BlockPos, state: BlockState)\n : MachineBlockEntity(tier, MachineRegistry.PUMP_REGISTRY, pos, state) {\n\n init {\n this.fluidComponent = FluidComponent({ this }, bucket)\n this.enhancerComponent = object : EnhancerComponent(intArrayOf(0, 1, 2, 3), Enhancer.DEFAULT, this::getMaxCount) {\n override fun isLocked(slot: Int, tier: Tier): Boolean = false\n }\n this.inventoryComponent = inventory(this) {\n }\n\n trackObject(TANK_ID, fluidComponent!![0])\n trackDouble(SPEED_ID) { config.processSpeed - enhancerComponent!!.getCount(Enhancer.SPEED) * 10 }\n }\n\n override val syncToWorld: Boolean = true\n\n override val maxInput: Long = config.maxInput\n override val maxOutput: Long = 0\n\n var pipePosition = 0.0\n private var isSearchingDown = false\n\n private var currentTarget: BlockPos = pos\n\n private val scanned = LongOpenHashSet()\n private var queue = LongArrayFIFOQueue()\n private var cooldown = 20.0\n\n override fun machineTick() {\n if (pipePosition == 0.0) {\n isSearchingDown = true\n }\n\n if (!isSearchingDown && currentTarget == pos) {\n searchFluid()\n }\n\n if (queue.isEmpty) {\n isSearchingDown = true\n }\n\n if (currentTarget != pos) {\n cooldown--\n if (cooldown <= 0) {\n drainTargetFluid()\n }\n }\n\n if (isSearchingDown) {\n searchDown()\n }\n }\n\n private fun searchFluid() {\n val currentLevel = floor(pipePosition).toInt()\n val lookLevel = pos.offset(Direction.DOWN, currentLevel)\n val currentFluid = world!!.getFluidState(lookLevel)\n val targetFluid = world!!.getFluidState(currentTarget)\n\n if (currentFluid.isEmpty) {\n isSearchingDown = true\n return\n }\n\n if ((targetFluid.isEmpty || !targetFluid.isStill) && !currentFluid.isEmpty) {\n scanned.clear()\n val searching = BlockPos.Mutable()\n val neighbor = BlockPos.Mutable()\n while (!queue.isEmpty) {\n val packedPos = queue.dequeue()\n searching.set(BlockPos.unpackLongX(packedPos), BlockPos.unpackLongY(packedPos), BlockPos.unpackLongZ(packedPos))\n SEARCH_DIRECTIONS.forEach { dir ->\n neighbor.set(searching.x + dir.offsetX, searching.y + dir.offsetY, searching.z + dir.offsetZ)\n if (neighbor.getSquaredDistance(lookLevel) < IRConfig.machines.pumpMaxRange * IRConfig.machines.pumpMaxRange\n && scanned.add(neighbor.asLong())\n && getStill(world!!.getFluidState(neighbor).fluid) == getStill(currentFluid.fluid)) {\n queue.enqueue(neighbor.asLong())\n }\n }\n val fluidState = world!!.getFluidState(searching)\n if (fluidState.isStill && !fluidState.isEmpty && fluidState.fluid == getStill(currentFluid.fluid)) {\n currentTarget = searching\n break\n }\n }\n }\n }\n\n private fun getFluidTouchingPipe(): FluidState {\n val currentLevel = floor(pipePosition).toInt()\n val lookLevel = pos.offset(Direction.DOWN, currentLevel)\n return world!!.getFluidState(lookLevel)\n }\n\n private fun drainTargetFluid() {\n val fluidToPump = world!!.getFluidState(currentTarget)\n if (!fluidToPump.isEmpty && canUse(config.energyCost) && fluidComponent!![0].isEmpty) {\n val blockState = world!!.getBlockState(currentTarget)\n val block = blockState?.block\n if (block is FluidDrainable && block is FluidBlock) {\n val drained = block.drainFluid(world!!, currentTarget, blockState)\n if (drained != Fluids.EMPTY) {\n fluidComponent!![0].insert(FluidVariant.of(drained), bucket, true)\n use(getEnergyCost())\n cooldown = config.processSpeed - enhancerComponent!!.getCount(Enhancer.SPEED) * 10\n }\n currentTarget = pos\n }\n }\n }\n\n override fun getEnergyCost(): Long {\n return config.energyCost * (enhancerComponent!!.getCount(Enhancer.SPEED) + 1)\n }\n\n private fun searchDown() {\n if (use(2)) {\n pipePosition += 0.01\n sync()\n val fluid = getFluidTouchingPipe()\n if (!fluid.isEmpty) {\n isSearchingDown = false\n pipePosition = pipePosition.roundToInt().toDouble()\n queue = LongArrayFIFOQueue()\n val currentLevel = floor(pipePosition).toInt()\n queue.enqueue(pos.offset(Direction.DOWN, currentLevel).asLong())\n }\n }\n }\n\n private fun getStill(fluid: Fluid): Fluid = if (fluid is FlowableFluid) fluid.still else fluid\n\n override fun applyDefault(\n state: BlockState,\n type: ConfigurationType,\n configuration: MutableMap\n ) {\n assert(type == ConfigurationType.FLUID)\n val facing = state[HorizontalFacingMachineBlock.HORIZONTAL_FACING]\n configuration[facing] = TransferMode.OUTPUT\n }\n\n override fun isFixed(type: ConfigurationType): Boolean = true\n fun getMaxCount(enhancer: Enhancer): Int {\n return when (enhancer) {\n Enhancer.SPEED -> return 1\n Enhancer.BUFFER -> 4\n else -> 1\n }\n }\n\n\n override fun toTag(tag: NbtCompound) {\n tag.putDouble(\"MovingTicks\", pipePosition)\n super.toTag(tag)\n }\n\n override fun fromTag(tag: NbtCompound) {\n pipePosition = tag.getDouble(\"MovingTicks\")\n super.fromTag(tag)\n }\n\n override fun fromClientTag(tag: NbtCompound) {\n pipePosition = tag.getDouble(\"MovingTicks\")\n }\n\n override fun toClientTag(tag: NbtCompound) {\n tag.putDouble(\"MovingTicks\", pipePosition)\n }\n\n companion object {\n const val TANK_ID = 2\n const val SPEED_ID = 3\n val SEARCH_DIRECTIONS = mutableListOf(Direction.NORTH, Direction.SOUTH, Direction.EAST, Direction.WEST)\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/farms/PumpBlockEntityRenderer.kt",
"content": "package me.steven.indrev.blockentities.farms\n\nimport alexiil.mc.lib.attributes.fluid.render.FluidRenderFace\nimport me.steven.indrev.blocks.machine.HorizontalFacingMachineBlock\nimport me.steven.indrev.utils.IRFluidTank\nimport me.steven.indrev.utils.identifier\nimport net.minecraft.client.MinecraftClient\nimport net.minecraft.client.render.OverlayTexture\nimport net.minecraft.client.render.RenderLayer\nimport net.minecraft.client.render.VertexConsumerProvider\nimport net.minecraft.client.render.WorldRenderer\nimport net.minecraft.client.render.block.entity.BlockEntityRenderer\nimport net.minecraft.client.util.ModelIdentifier\nimport net.minecraft.client.util.math.MatrixStack\nimport net.minecraft.util.math.Direction\nimport net.minecraft.util.math.Vec3f\nimport kotlin.math.floor\n\nclass PumpBlockEntityRenderer : BlockEntityRenderer {\n override fun render(\n entity: PumpBlockEntity,\n tickDelta: Float,\n matrices: MatrixStack,\n vertexConsumers: VertexConsumerProvider,\n light: Int,\n overlay: Int\n ) {\n matrices.run {\n\n push()\n val inputVolume = entity.fluidComponent!![0]\n if (!inputVolume.isEmpty) {\n\n translate(0.5, 0.5, 0.5)\n var direction = entity.cachedState[HorizontalFacingMachineBlock.HORIZONTAL_FACING]\n if (direction.axis == Direction.Axis.X) direction = direction.opposite\n multiply(Vec3f.POSITIVE_Y.getDegreesQuaternion(direction.asRotation()))\n translate(-0.5, -0.5, -0.5)\n push()\n multiply(Vec3f.NEGATIVE_X.getDegreesQuaternion(22.5f))\n renderFluid(inputVolume, vertexConsumers)\n pop()\n\n push()\n multiply(Vec3f.NEGATIVE_Z.getDegreesQuaternion(22.5f))\n translate(0.5, 0.5, 0.5)\n multiply(Vec3f.NEGATIVE_Y.getDegreesQuaternion(90f))\n translate(-0.5, -0.5, -0.5)\n matrices.translate(0.0, 0.38, 0.0765)\n renderFluid(inputVolume, vertexConsumers)\n pop()\n\n push()\n multiply(Vec3f.POSITIVE_Z.getDegreesQuaternion(22.5f))\n translate(0.5, 0.5, 0.5)\n multiply(Vec3f.NEGATIVE_Y.getDegreesQuaternion(180f))\n translate(-0.5, -0.5, -0.5)\n matrices.translate(0.1284, 0.0, 0.1285)\n renderFluid(inputVolume, vertexConsumers)\n pop()\n }\n pop()\n val currentY = floor(entity.pipePosition).toInt()\n for (y in 1..currentY) {\n push()\n translate(0.0, -y.toDouble(), 0.0)\n renderModel(vertexConsumers, entity)\n pop()\n }\n if (currentY.toDouble() != entity.pipePosition) {\n push()\n scale(1.01f, 1f, 1.01f)\n translate(-0.005, -entity.pipePosition, -0.005)\n renderModel(vertexConsumers, entity)\n pop()\n }\n }\n }\n\n private fun MatrixStack.renderModel(vertexConsumers: VertexConsumerProvider, entity: PumpBlockEntity) {\n val model = MinecraftClient.getInstance().bakedModelManager.getModel(ModelIdentifier(identifier(\"pump_pipe\"), \"\"))\n val buffer = vertexConsumers.getBuffer(RenderLayer.getSolid())\n val light = WorldRenderer.getLightmapCoordinates(entity.world, entity.pos)\n MinecraftClient.getInstance().blockRenderManager.modelRenderer.render(\n peek(), buffer, null, model, -1f, -1f, -1f, light, OverlayTexture.DEFAULT_UV\n )\n }\n\n private fun MatrixStack.renderFluid(inputVolume: IRFluidTank, vcp: VertexConsumerProvider) {\n\n inputVolume.render(FACES, vcp, this)\n }\n\n override fun rendersOutsideBoundingBox(blockEntity: PumpBlockEntity?): Boolean = true\n\n companion object {\n val FACES = listOf(\n FluidRenderFace.createFlatFaceZ(0.443, 0.15, 0.32, 0.556, 0.31, 0.32, 2.0, false, false),\n FluidRenderFace.createFlatFaceZ(0.443, 0.15, 0.32+ (0.55-0.443), 0.556, 0.31, 0.32+ (0.55-0.443), 2.0, true, false),\n FluidRenderFace.createFlatFaceX(0.443, 0.15, 0.323, 0.443, 0.31, 0.426, 2.0, false, false),\n FluidRenderFace.createFlatFaceX(0.443+ (0.55-0.443), 0.15, 0.323, 0.443+ (0.55-0.443), 0.31, 0.426, 2.0, true, false)\n )\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/farms/RancherBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.farms\n\nimport me.steven.indrev.IndustrialRevolution\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.components.EnhancerComponent\nimport me.steven.indrev.components.autosync\nimport me.steven.indrev.config.BasicMachineConfig\nimport me.steven.indrev.inventories.inventory\nimport me.steven.indrev.items.upgrade.Enhancer\nimport me.steven.indrev.registry.MachineRegistry\nimport me.steven.indrev.utils.redirectDrops\nimport net.minecraft.block.BlockState\nimport net.minecraft.entity.damage.DamageSource\nimport net.minecraft.entity.passive.AnimalEntity\nimport net.minecraft.item.ItemStack\nimport net.minecraft.item.SwordItem\nimport net.minecraft.nbt.NbtCompound\nimport net.minecraft.server.world.ServerWorld\nimport net.minecraft.util.ActionResult\nimport net.minecraft.util.Hand\nimport net.minecraft.util.math.BlockPos\n\nclass RancherBlockEntity(tier: Tier, pos: BlockPos, state: BlockState)\n : AOEMachineBlockEntity(tier, MachineRegistry.RANCHER_REGISTRY, pos, state) {\n\n init {\n this.enhancerComponent = EnhancerComponent(intArrayOf(15, 16, 17, 18), Enhancer.DEFAULT, this::getMaxCount)\n this.inventoryComponent = inventory(this) {\n input { slots = intArrayOf(2, 3, 4, 5) }\n output { slots = intArrayOf(6, 7, 8, 9, 10, 11, 12, 13, 14) }\n coolerSlot = 1\n }\n }\n\n override val maxInput: Long = config.maxInput\n override val maxOutput: Long = 0\n\n var cooldown = 0.0\n override var range = 5\n private val fakePlayer by lazy { IndustrialRevolution.FAKE_PLAYER_BUILDER.create(world!!.server, world as ServerWorld, \"rancher\") }\n var feedBabies: Boolean by autosync(FEED_BABIES_ID, true)\n var mateAdults: Boolean by autosync(MATE_ADULTS, true)\n var matingLimit: Int by autosync(MATING_LIMIT, 16)\n var killAfter: Int by autosync(KILL_AFTER, 8)\n\n override fun machineTick() {\n if (world?.isClient == true) return\n val inventory = inventoryComponent?.inventory ?: return\n cooldown += getProcessingSpeed()\n if (cooldown < config.processSpeed) return\n val animals = world?.getEntitiesByClass(AnimalEntity::class.java, getWorkingArea()) { true } ?: emptyList()\n if (animals.isEmpty() || !canUse(getEnergyCost())) {\n workingState = false\n return\n } else workingState = true\n val swordStack = inventory.inputSlots.map { inventory.getStack(it) }.firstOrNull { it.item is SwordItem }\n fakePlayer.inventory.selectedSlot = 0\n if (swordStack != null && !swordStack.isEmpty && swordStack.damage < swordStack.maxDamage) {\n val swordItem = swordStack.item as SwordItem\n val kill = filterAnimalsToKill(animals)\n if (kill.isNotEmpty()) use(getEnergyCost())\n kill.forEach { animal ->\n animal.redirectDrops(inventory) {\n if (!animal.isAlive || !animal.damage(DamageSource.player(fakePlayer), swordItem.attackDamage)) return@forEach\n swordStack.damage(1, world?.random, null)\n if (swordStack.damage >= swordStack.maxDamage) swordStack.decrement(1)\n }\n }\n }\n for (animal in animals) {\n inventory.inputSlots.forEach { slot ->\n val stack = inventory.getStack(slot).copy()\n animal.redirectDrops(inventory) {\n if (tryFeed(animals.size, animal, inventory.getStack(slot)).isAccepted) return@forEach\n fakePlayer.inventory.selectedSlot = 8\n fakePlayer.setStackInHand(Hand.MAIN_HAND, stack)\n if (animal.interactMob(fakePlayer, Hand.MAIN_HAND).isAccepted)\n use(getEnergyCost())\n val inserted = inventory.output(fakePlayer.inventory.getStack(0))\n val handStack = fakePlayer.getStackInHand(Hand.MAIN_HAND)\n if (!handStack.isEmpty && handStack.item != stack.item) {\n inventory.output(handStack)\n fakePlayer.setStackInHand(Hand.MAIN_HAND, ItemStack.EMPTY)\n }\n if (inserted)\n inventory.setStack(slot, stack)\n fakePlayer.inventory.clear()\n }\n }\n }\n fakePlayer.inventory.clear()\n cooldown = 0.0\n }\n\n private fun tryFeed(size: Int, animalEntity: AnimalEntity, stack: ItemStack): ActionResult {\n if (animalEntity.isBreedingItem(stack)) {\n val breedingAge: Int = animalEntity.breedingAge\n if (!world!!.isClient && breedingAge == 0 && animalEntity.canEat() && size <= matingLimit && mateAdults) {\n animalEntity.eat(fakePlayer, Hand.MAIN_HAND, stack)\n animalEntity.lovePlayer(fakePlayer)\n }\n if (animalEntity.isBaby && feedBabies) {\n animalEntity.eat(fakePlayer, Hand.MAIN_HAND, stack)\n animalEntity.growUp(((-breedingAge / 20f) * 0.1f).toInt(), true)\n }\n return ActionResult.SUCCESS\n }\n return ActionResult.PASS\n }\n\n private fun filterAnimalsToKill(entities: List): List {\n val adults = entities.filter { !it.isBaby }\n val types = adults.map { it.type }.associateWith { mutableListOf() }\n adults.forEach { types[it.type]?.add(it) }\n return types.values.let { values ->\n values.map { animals -> animals.dropLast((animals.size - killAfter).coerceAtLeast(killAfter)) }\n }.flatten()\n }\n\n override fun getEnergyCost(): Long {\n val speedEnhancers = (enhancerComponent!!.getCount(Enhancer.SPEED) * 2).coerceAtLeast(1)\n return config.energyCost * speedEnhancers\n }\n\n fun getMaxCount(enhancer: Enhancer): Int {\n return when (enhancer) {\n Enhancer.SPEED -> return 1 \n Enhancer.BUFFER -> 4\n else -> 1\n }\n }\n\n override fun toTag(tag: NbtCompound) {\n super.toTag(tag)\n tag.putBoolean(\"feedBabies\", feedBabies)\n tag.putBoolean(\"mateAdults\", mateAdults)\n tag.putInt(\"matingLimit\", matingLimit)\n tag.putInt(\"killAfter\", killAfter)\n }\n\n override fun fromTag(tag: NbtCompound) {\n super.fromTag(tag)\n feedBabies = tag.getBoolean(\"feedBabies\")\n mateAdults = tag.getBoolean(\"mateAdults\")\n matingLimit = tag.getInt(\"matingLimit\")\n killAfter = tag.getInt(\"killAfter\")\n }\n\n companion object {\n const val FEED_BABIES_ID = 2\n const val MATE_ADULTS = 3\n const val MATING_LIMIT = 4\n const val KILL_AFTER = 5\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/farms/SlaughterBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.farms\n\nimport me.steven.indrev.IndustrialRevolution\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.components.EnhancerComponent\nimport me.steven.indrev.config.BasicMachineConfig\nimport me.steven.indrev.inventories.inventory\nimport me.steven.indrev.items.upgrade.Enhancer\nimport me.steven.indrev.registry.MachineRegistry\nimport me.steven.indrev.utils.redirectDrops\nimport net.minecraft.block.BlockState\nimport net.minecraft.entity.LivingEntity\nimport net.minecraft.entity.boss.WitherEntity\nimport net.minecraft.entity.damage.DamageSource\nimport net.minecraft.entity.decoration.ArmorStandEntity\nimport net.minecraft.entity.player.PlayerEntity\nimport net.minecraft.item.SwordItem\nimport net.minecraft.server.world.ServerWorld\nimport net.minecraft.util.math.BlockPos\n\nclass SlaughterBlockEntity(tier: Tier, pos: BlockPos, state: BlockState) : AOEMachineBlockEntity(tier, MachineRegistry.SLAUGHTER_REGISTRY, pos, state) {\n\n init {\n this.enhancerComponent = EnhancerComponent(\n intArrayOf(11, 12, 13, 14),\n arrayOf(Enhancer.SPEED, Enhancer.BUFFER, Enhancer.DAMAGE),\n this::getMaxCount\n )\n this.inventoryComponent = inventory(this) {\n input { slot = 1 }\n output { slots = intArrayOf(2, 3, 4, 5, 6, 7, 8, 9, 10) }\n }\n }\n\n override val maxInput: Long = config.maxInput\n override val maxOutput: Long = 0\n\n var cooldown = 0.0\n override var range = 5\n private val fakePlayer by lazy { IndustrialRevolution.FAKE_PLAYER_BUILDER.create(world!!.server, world as ServerWorld, \"slaughter\") }\n\n override fun machineTick() {\n if (world?.isClient == true) return\n val inventory = inventoryComponent?.inventory ?: return\n val enhancers = enhancerComponent!!.enhancers\n cooldown += getProcessingSpeed()\n if (cooldown < config.processSpeed) return\n val source = DamageSource.player(fakePlayer)\n val mobs = world?.getEntitiesByClass(LivingEntity::class.java, getWorkingArea()) { e -> e !is PlayerEntity && e !is ArmorStandEntity && !e.isDead && !e.isInvulnerableTo(source) && (e !is WitherEntity || e.invulnerableTimer <= 0) } ?: emptyList()\n if (mobs.isEmpty() || !canUse(getEnergyCost())) {\n workingState = false\n return\n } else workingState = true\n val swordStack = inventory.inputSlots.map { inventory.getStack(it) }.firstOrNull { it.item is SwordItem }\n fakePlayer.inventory.selectedSlot = 0\n if (swordStack != null && !swordStack.isEmpty && swordStack.damage < swordStack.maxDamage) {\n val swordItem = swordStack.item as SwordItem\n use(getEnergyCost())\n mobs.forEach { mob ->\n swordStack.damage(1, world?.random, null)\n if (swordStack.damage >= swordStack.maxDamage) swordStack.decrement(1)\n\n if (mob.isAlive) {\n mob.redirectDrops(inventory) {\n mob.damage(source, (swordItem.attackDamage * Enhancer.getDamageMultiplier(enhancers)).toFloat())\n }\n }\n }\n }\n fakePlayer.inventory.clear()\n cooldown = 0.0\n }\n\n override fun getEnergyCost(): Long {\n val speedEnhancers = (enhancerComponent!!.getCount(Enhancer.SPEED) * 2).coerceAtLeast(1)\n val dmgEnhancers = (enhancerComponent!!.getCount(Enhancer.DAMAGE) * 8).coerceAtLeast(1)\n return config.energyCost * speedEnhancers * dmgEnhancers\n }\n\n fun getMaxCount(enhancer: Enhancer): Int {\n return when (enhancer) {\n Enhancer.SPEED, Enhancer.DAMAGE -> return 1\n Enhancer.BUFFER -> 4\n else -> 1\n }\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/generators/BiomassGeneratorBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.generators\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.components.TemperatureComponent\nimport me.steven.indrev.inventories.inventory\nimport me.steven.indrev.registry.IRItemRegistry\nimport me.steven.indrev.registry.MachineRegistry\nimport net.minecraft.block.BlockState\nimport net.minecraft.item.Item\nimport net.minecraft.util.math.BlockPos\n\nclass BiomassGeneratorBlockEntity(tier: Tier, pos: BlockPos, state: BlockState)\n : SolidFuelGeneratorBlockEntity(tier, MachineRegistry.BIOMASS_GENERATOR_REGISTRY, pos, state) {\n\n init {\n this.temperatureComponent = TemperatureComponent(this, 0.08, 900..2000, 2500)\n this.inventoryComponent = inventory(this) {\n input { slot = 2 }\n }\n }\n\n override fun getFuelMap(): Map = BURN_TIME_MAP\n\n companion object {\n private val BURN_TIME_MAP = hashMapOf()\n\n init {\n BURN_TIME_MAP[IRItemRegistry.BIOMASS] = 150\n }\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/generators/CoalGeneratorBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.generators\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.components.TemperatureComponent\nimport me.steven.indrev.inventories.inventory\nimport me.steven.indrev.registry.MachineRegistry\nimport net.minecraft.block.BlockState\nimport net.minecraft.block.entity.AbstractFurnaceBlockEntity\nimport net.minecraft.item.Item\nimport net.minecraft.util.math.BlockPos\n\nclass CoalGeneratorBlockEntity(pos: BlockPos, state: BlockState) :\n SolidFuelGeneratorBlockEntity(Tier.MK1, MachineRegistry.COAL_GENERATOR_REGISTRY, pos, state) {\n\n init {\n this.temperatureComponent = TemperatureComponent(this, 0.08, 900..2000, 2500)\n this.inventoryComponent = inventory(this) {\n input {\n slot = 2\n 2 filter { stack -> BURN_TIME_MAP.containsKey(stack.item) }\n }\n }\n }\n\n override fun getFuelMap(): Map = BURN_TIME_MAP\n\n companion object {\n private val BURN_TIME_MAP = AbstractFurnaceBlockEntity.createFuelTimeMap()\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/generators/GasBurningGeneratorBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.generators\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.api.machines.TransferMode\nimport me.steven.indrev.api.sideconfigs.ConfigurationType\nimport me.steven.indrev.components.FluidComponent\nimport me.steven.indrev.components.TemperatureComponent\nimport me.steven.indrev.components.autosync\nimport me.steven.indrev.components.trackObject\nimport me.steven.indrev.inventories.inventory\nimport me.steven.indrev.registry.IRFluidFuelRegistry\nimport me.steven.indrev.registry.IRItemRegistry\nimport me.steven.indrev.registry.MachineRegistry\nimport me.steven.indrev.utils.bucket\nimport net.fabricmc.fabric.api.transfer.v1.fluid.FluidVariant\nimport net.minecraft.block.BlockState\nimport net.minecraft.item.ItemStack\nimport net.minecraft.util.math.BlockPos\n\nclass GasBurningGeneratorBlockEntity(pos: BlockPos, state: BlockState) : GeneratorBlockEntity(Tier.MK4, MachineRegistry.GAS_BURNING_GENERATOR_REGISTRY, pos, state) {\n\n private var burnTime by autosync(BURN_TIME_ID, 0)\n private var maxBurnTime by autosync(TOTAL_BURN_TIME_ID, 0)\n\n init {\n this.temperatureComponent = TemperatureComponent(this, 0.3, 2200..2400, 2500)\n this.inventoryComponent = inventory(this) {\n coolerSlot = 0\n output {\n slot = 1\n }\n }\n this.fluidComponent = GasBurningGeneratorFluidComponent()\n }\n\n var generatingTicks = 0\n\n override fun machineTick() {\n super.machineTick()\n if (workingState) {\n generatingTicks++\n\n if (generatingTicks % 100 == 0 && world!!.random.nextDouble() < 0.6) {\n inventoryComponent!!.inventory.output(ItemStack(IRItemRegistry.SOOT))\n }\n }\n }\n\n override fun shouldGenerate(): Boolean {\n if (burnTime > 0) burnTime--\n else if (energyCapacity > energy) {\n val invFluid = fluidComponent!![0]\n val fluid = invFluid.resource.fluid\n if (invFluid.isEmpty || !IRFluidFuelRegistry.isFuel(fluid)) return false\n val fuel = IRFluidFuelRegistry.get(fluid)!!\n if (fluidComponent!![0].extract(fuel.consumptionRatio) == fuel.consumptionRatio) {\n burnTime = fuel.burnTime\n maxBurnTime = burnTime\n }\n }\n\n return burnTime > 0 && energy < energyCapacity\n }\n\n override fun getGenerationRatio(): Long {\n val invFluid = fluidComponent!![0]\n val fluid = invFluid.resource.fluid\n val modifier = if (temperatureComponent!!.isFullEfficiency()) config.temperatureBoost else 1.0\n return ((IRFluidFuelRegistry.get(fluid)?.generationRatio ?: 0) * modifier).toLong()\n }\n\n override fun getValidConfigurations(type: ConfigurationType): Array {\n return when (type) {\n ConfigurationType.ITEM -> arrayOf(TransferMode.OUTPUT, TransferMode.NONE)\n ConfigurationType.FLUID -> arrayOf(TransferMode.INPUT, TransferMode.NONE)\n else -> super.getValidConfigurations(type)\n }\n }\n\n inner class GasBurningGeneratorFluidComponent : FluidComponent({ this }, bucket * 2, 1) {\n\n init {\n trackObject(TANK_ID, this[0])\n }\n\n override fun isFluidValidForTank(index: Int, variant: FluidVariant): Boolean {\n return IRFluidFuelRegistry.isFuel(variant.fluid)\n }\n }\n\n companion object {\n const val BURN_TIME_ID = 4\n const val TOTAL_BURN_TIME_ID = 5\n const val TANK_ID = 6\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/generators/GeneratorBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.generators\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.blockentities.MachineBlockEntity\nimport me.steven.indrev.config.GeneratorConfig\nimport me.steven.indrev.registry.MachineRegistry\nimport net.minecraft.block.BlockState\nimport net.minecraft.util.math.BlockPos\n\nabstract class GeneratorBlockEntity(tier: Tier, registry: MachineRegistry, pos: BlockPos, state: BlockState) :\n MachineBlockEntity(tier, registry, pos, state) {\n\n override fun machineTick() {\n if (world?.isClient == false) {\n val ratio = getGenerationRatio()\n if (shouldGenerate() && energyCapacity > energy + ratio) {\n this.energy += ratio\n this.temperatureComponent?.tick(true)\n workingState = true\n } else {\n workingState = false\n this.temperatureComponent?.tick(false)\n }\n }\n }\n\n override val maxInput: Long = 0\n override val maxOutput: Long = config.maxOutput\n\n abstract fun shouldGenerate(): Boolean\n\n open fun getGenerationRatio(): Long = (config.ratio * if (this.temperatureComponent?.isFullEfficiency() == true) config.temperatureBoost else 1.0).toLong()\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/generators/HeatGeneratorBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.generators\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.components.*\nimport me.steven.indrev.inventories.inventory\nimport me.steven.indrev.registry.MachineRegistry\nimport me.steven.indrev.utils.bucket\nimport net.minecraft.block.BlockState\nimport net.minecraft.fluid.Fluids\nimport net.minecraft.nbt.NbtCompound\nimport net.minecraft.util.math.BlockPos\n\nclass HeatGeneratorBlockEntity(tier: Tier, pos: BlockPos, state: BlockState)\n : GeneratorBlockEntity(tier, MachineRegistry.HEAT_GENERATOR_REGISTRY, pos, state) {\n\n private var burnTime by autosync(GasBurningGeneratorBlockEntity.BURN_TIME_ID, 0)\n private var maxBurnTime by autosync(GasBurningGeneratorBlockEntity.TOTAL_BURN_TIME_ID, 0)\n\n init {\n this.temperatureComponent = TemperatureComponent(this, 0.8, 7000..9000, 10000)\n this.inventoryComponent = inventory(this) {\n input { slot = 2 }\n }\n this.fluidComponent = FluidComponent({ this }, bucket * 4)\n fluidComponent!!.inputTanks = intArrayOf(0)\n\n trackObject(TANK_ID, fluidComponent!![0])\n\n trackLong(GENERATION_RATIO_ID) { getGenerationRatio() }\n trackLong(CONSUMPTION_RATIO_ID) { getConsumptionRate() }\n }\n\n override val syncToWorld: Boolean = true\n\n override fun shouldGenerate(): Boolean {\n if (burnTime > 0) burnTime--\n else if (energyCapacity > energy) {\n val tank = fluidComponent!![0]\n val consume = getConsumptionRate()\n if (tank.variant.isOf(Fluids.LAVA)\n && tank.tryExtract(consume)) {\n burnTime = 10\n maxBurnTime = burnTime\n tank.extract(consume, true)\n }\n markDirty()\n }\n return burnTime > 0 && energy < energyCapacity\n }\n\n override fun getGenerationRatio(): Long {\n return (config.ratio * (temperatureComponent!!.temperature / temperatureComponent!!.optimalRange.first).coerceAtMost(1.0)).toLong()\n }\n\n fun getConsumptionRate(temperature: Double = temperatureComponent!!.temperature): Long {\n return ((temperature / temperatureComponent!!.optimalRange.first).coerceIn(0.001, 1.0) * 810).toLong()\n }\n\n override fun fromTag(tag: NbtCompound) {\n super.fromTag(tag)\n burnTime = tag.getInt(\"BurnTime\")\n maxBurnTime = tag.getInt(\"MaxBurnTime\")\n }\n\n override fun toTag(tag: NbtCompound) {\n tag.putInt(\"BurnTime\", burnTime)\n tag.putInt(\"MaxBurnTime\", maxBurnTime)\n super.toTag(tag)\n }\n\n override fun toClientTag(tag: NbtCompound) {\n fluidComponent!!.toTag(tag)\n }\n\n override fun fromClientTag(tag: NbtCompound) {\n fluidComponent!!.fromTag(tag)\n }\n\n companion object {\n const val TANK_ID = 4\n const val GENERATION_RATIO_ID = 5\n const val CONSUMPTION_RATIO_ID = 6\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/generators/HeatGeneratorBlockEntityRenderer.kt",
"content": "package me.steven.indrev.blockentities.generators\n\nimport alexiil.mc.lib.attributes.fluid.render.FluidRenderFace\nimport me.steven.indrev.blocks.machine.HorizontalFacingMachineBlock\nimport me.steven.indrev.utils.IRFluidTank\nimport net.minecraft.client.render.VertexConsumerProvider\nimport net.minecraft.client.render.block.entity.BlockEntityRenderer\nimport net.minecraft.client.util.math.MatrixStack\nimport net.minecraft.util.math.Direction\nimport net.minecraft.util.math.Vec3f\n\nclass HeatGeneratorBlockEntityRenderer : BlockEntityRenderer {\n override fun render(\n entity: HeatGeneratorBlockEntity?,\n tickDelta: Float,\n matrices: MatrixStack?,\n vertexConsumers: VertexConsumerProvider,\n light: Int,\n overlay: Int\n ) {\n val volume = entity?.fluidComponent?.get(0) ?: return\n if (!volume.isEmpty) {\n matrices?.run {\n push()\n val direction = entity.cachedState[HorizontalFacingMachineBlock.HORIZONTAL_FACING]\n .let { if (it.axis == Direction.Axis.X) it.opposite else it }\n translate(0.5, 0.5, 0.5)\n multiply(Vec3f.POSITIVE_Y.getDegreesQuaternion(direction.asRotation()))\n translate(-0.5, -0.5, -0.5)\n matrices.renderFluid(volume, vertexConsumers)\n pop()\n }\n }\n }\n\n private fun MatrixStack.renderFluid(inputVolume: IRFluidTank, vcp: VertexConsumerProvider) {\n val yMax = (((inputVolume.amount / (4f*81000)) * 10.0) / 16.0).coerceAtLeast(0.1)\n val face =\n listOf(\n FluidRenderFace.createFlatFaceZ(0.01, 0.1, 0.99, 0.99, yMax, 0.99, 2.0, true, false),\n FluidRenderFace.createFlatFaceY(0.01, yMax, 0.8, 0.99, yMax, 0.99, 2.0, true, false),\n FluidRenderFace.createFlatFaceX(0.01, 0.1, 0.8, 0.01, yMax, 0.99, 2.0, false, false),\n FluidRenderFace.createFlatFaceX(0.99, 0.1, 0.8, 0.99, yMax, 0.99, 2.0, true, false)\n )\n inputVolume.render(face, vcp, this)\n }\n\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/generators/SolarGeneratorBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.generators\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.components.TemperatureComponent\nimport me.steven.indrev.inventories.inventory\nimport me.steven.indrev.registry.MachineRegistry\nimport net.minecraft.block.BlockState\nimport net.minecraft.util.math.BlockPos\n\nclass SolarGeneratorBlockEntity(tier: Tier, pos: BlockPos, state: BlockState) :\n GeneratorBlockEntity(tier, MachineRegistry.SOLAR_GENERATOR_REGISTRY, pos, state) {\n\n init {\n this.temperatureComponent = TemperatureComponent(this, 0.1, 500..700, 1000)\n this.inventoryComponent = inventory(this) {}\n\n }\n\n override fun shouldGenerate(): Boolean = this.world?.isSkyVisible(pos.up()) == true && this.world?.isDay == true && energy < energyCapacity\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/generators/SolidFuelGeneratorBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.generators\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.api.machines.TransferMode\nimport me.steven.indrev.api.sideconfigs.ConfigurationType\nimport me.steven.indrev.blocks.machine.MachineBlock\nimport me.steven.indrev.components.autosync\nimport me.steven.indrev.registry.MachineRegistry\nimport net.minecraft.block.BlockState\nimport net.minecraft.item.Item\nimport net.minecraft.item.ItemStack\nimport net.minecraft.nbt.NbtCompound\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.math.Direction\n\nabstract class SolidFuelGeneratorBlockEntity(tier: Tier, registry: MachineRegistry, pos: BlockPos, state: BlockState)\n : GeneratorBlockEntity(tier, registry, pos, state) {\n\n private var burnTime by autosync(BURN_TIME_ID, 0)\n private var maxBurnTime by autosync(TOTAL_BURN_TIME_ID, 0)\n\n override fun shouldGenerate(): Boolean {\n if (burnTime > 0) burnTime--\n else if (energyCapacity > energy) {\n val inventory = inventoryComponent?.inventory ?: return false\n val invStack = inventory.getStack(2)\n val item = invStack.item\n if (!invStack.isEmpty && getFuelMap().containsKey(invStack.item)) {\n burnTime = getFuelMap()[invStack.item] ?: return false\n maxBurnTime = burnTime\n invStack.decrement(1)\n if (item.hasRecipeRemainder())\n inventory.setStack(2, ItemStack(item.recipeRemainder))\n }\n markDirty()\n }\n return burnTime > 0 && energy < energyCapacity\n }\n\n override fun applyDefault(\n state: BlockState,\n type: ConfigurationType,\n configuration: MutableMap\n ) {\n val direction = (state.block as MachineBlock).getFacing(state)\n when (type) {\n ConfigurationType.ITEM -> {\n configuration[direction.rotateYClockwise()] = TransferMode.INPUT\n }\n else -> super.applyDefault(state, type, configuration)\n }\n }\n\n override fun getValidConfigurations(type: ConfigurationType): Array {\n return when (type) {\n ConfigurationType.ITEM -> arrayOf(TransferMode.INPUT, TransferMode.NONE)\n else -> return super.getValidConfigurations(type)\n }\n }\n\n override fun fromTag(tag: NbtCompound) {\n super.fromTag(tag)\n burnTime = tag?.getInt(\"BurnTime\") ?: 0\n maxBurnTime = tag?.getInt(\"MaxBurnTime\") ?: 0\n }\n\n override fun toTag(tag: NbtCompound) {\n tag?.putInt(\"BurnTime\", burnTime)\n tag?.putInt(\"MaxBurnTime\", maxBurnTime)\n super.toTag(tag)\n }\n\n abstract fun getFuelMap(): Map\n\n companion object {\n const val BURN_TIME_ID = 4\n const val TOTAL_BURN_TIME_ID = 5\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/generators/SteamTurbineBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.generators\n\nimport alexiil.mc.lib.attributes.fluid.amount.FluidAmount\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.components.FluidComponent\nimport me.steven.indrev.components.autosync\nimport me.steven.indrev.components.multiblock.MultiBlockComponent\nimport me.steven.indrev.components.multiblock.definitions.SteamTurbineStructureDefinition\nimport me.steven.indrev.components.trackLong\nimport me.steven.indrev.registry.IRFluidRegistry\nimport me.steven.indrev.registry.MachineRegistry\nimport me.steven.indrev.utils.bucket\nimport net.fabricmc.api.EnvType\nimport net.fabricmc.api.Environment\nimport net.fabricmc.fabric.api.transfer.v1.fluid.FluidVariant\nimport net.minecraft.block.BlockState\nimport net.minecraft.nbt.NbtCompound\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.world.World\n\nclass SteamTurbineBlockEntity(pos: BlockPos, state: BlockState) : GeneratorBlockEntity(Tier.MK4, MachineRegistry.STEAM_TURBINE_REGISTRY, pos, state) {\n\n init {\n this.multiblockComponent = SteamTurbineMultiblockComponent()\n this.fluidComponent = SteamTurbineFluidComponent()\n }\n\n override val maxInput: Long = 0\n\n var efficiency by autosync(EFFICIENCY, 1.0)\n\n var generatingTicks = 0\n var totalInserted: FluidAmount = FluidAmount.ZERO\n\n init {\n trackLong(GENERATING) { getGenerationRatio() * 100 }\n }\n\n\n // used for the screen handler\n @Environment(EnvType.CLIENT)\n var consuming: FluidAmount = FluidAmount.ZERO\n\n override fun getGenerationRatio(): Long {\n val radius = getRadius()\n val eff = totalInserted.div(20).asInexactDouble()\n return (((eff * 2) / (radius.toDouble() / 7)) * 2048).toLong()\n }\n\n override fun shouldGenerate(): Boolean {\n if (generatingTicks <= 0) {\n if (!totalInserted.isZero) {\n generatingTicks = 20\n fluidComponent!![0].extract(Long.MAX_VALUE, true)\n } else\n return false\n }\n generatingTicks--\n if (generatingTicks <= 0) totalInserted = FluidAmount.ZERO\n return true\n }\n\n private fun getConsumptionRatio(): FluidAmount {\n return totalInserted.div(20)\n }\n\n private fun getRadius(): Int {\n //return 7\n val matcher = multiblockComponent!!.getSelectedMatcher(world ?: return 0, pos, cachedState)\n return SteamTurbineStructureDefinition.getRadius(matcher.builtId ?: return 0)\n }\n\n private inner class SteamTurbineFluidComponent : FluidComponent({ this }, bucket, 1) {\n\n override fun getTankCapacity(index: Int): Long {\n return (((getRadius() * getRadius().toLong()) * efficiency) * 81L).toLong()\n }\n\n override fun isFluidValidForTank(index: Int, variant: FluidVariant): Boolean {\n return variant.isOf(IRFluidRegistry.STEAM_STILL)\n }\n }\n\n private inner class SteamTurbineMultiblockComponent : MultiBlockComponent({ _, _, _ -> SteamTurbineStructureDefinition }) {\n override fun tick(world: World, pos: BlockPos, blockState: BlockState) {\n super.tick(world, pos, blockState)\n SteamTurbineStructureDefinition\n .getInputValvePositions(pos, blockState, getSelectedMatcher(world, pos, blockState))\n .forEach { valvePos ->\n val valveBlockEntity = world.getBlockEntity(valvePos)\n if (valveBlockEntity is SteamTurbineSteamInputValveBlockEntity)\n valveBlockEntity.steamTurbinePos = pos\n }\n\n if (!isBuilt(world, pos, blockState)) {\n fluidComponent!![0].amount = 0\n }\n }\n }\n\n override fun toTag(tag: NbtCompound) {\n tag.putDouble(\"Efficiency\", efficiency)\n super.toTag(tag)\n }\n\n override fun fromTag(tag: NbtCompound) {\n efficiency = tag.getDouble(\"Efficiency\")\n super.fromTag(tag)\n }\n\n override fun toClientTag(tag: NbtCompound) {\n tag.put(\"Consuming\", getConsumptionRatio().toNbt())\n multiblockComponent?.writeNbt(tag)\n }\n\n override fun fromClientTag(tag: NbtCompound) {\n consuming = FluidAmount.fromNbt(tag.getCompound(\"Consuming\")) ?: consuming\n multiblockComponent?.readNbt(tag)\n }\n\n companion object {\n const val EFFICIENCY = 2\n const val GENERATING = 3\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/generators/SteamTurbineSteamInputValveBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.generators\n\nimport me.steven.indrev.registry.IRBlockRegistry\nimport net.minecraft.block.BlockState\nimport net.minecraft.block.entity.BlockEntity\nimport net.minecraft.util.math.BlockPos\n\nclass SteamTurbineSteamInputValveBlockEntity(pos: BlockPos, state: BlockState) : BlockEntity(IRBlockRegistry.STEAM_TURBINE_STEAM_INPUT_VALVE_BLOCK_ENTITY, pos, state) {\n\n var steamTurbinePos: BlockPos = BlockPos(-1, -1, -1)\n var inserted = false\n\n fun getSteamTurbine(): SteamTurbineBlockEntity? {\n val blockEntity = world!!.getBlockEntity(steamTurbinePos) as? SteamTurbineBlockEntity ?: return null\n return if (blockEntity.multiblockComponent?.isBuilt(world!!, pos, blockEntity.cachedState) == true)\n blockEntity\n else null\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/laser/CapsuleBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.laser\n\nimport com.google.common.base.Preconditions\nimport me.steven.indrev.blocks.machine.LaserBlock\nimport me.steven.indrev.registry.IRBlockRegistry\nimport net.minecraft.block.BlockState\nimport net.minecraft.block.entity.BlockEntity\nimport net.minecraft.inventory.Inventories\nimport net.minecraft.item.ItemStack\nimport net.minecraft.nbt.NbtCompound\nimport net.minecraft.server.world.ServerWorld\nimport net.minecraft.util.collection.DefaultedList\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.math.Direction\nimport net.minecraft.world.World\n\nclass CapsuleBlockEntity(pos: BlockPos, state: BlockState) : BlockEntity(IRBlockRegistry.CAPSULE_BLOCK_ENTITY, pos, state) {\n\n var inventory: DefaultedList = DefaultedList.ofSize(1, ItemStack.EMPTY)\n\n var lastProgress = 0\n\n fun getActiveLasersCount(): Int {\n return Direction.values().count {\n val laser = world?.getBlockEntity(pos.offset(it, 4)) as? LaserBlockEntity ?: return@count false\n laser.cachedState[LaserBlock.POWERED]\n }\n }\n\n override fun readNbt(tag: NbtCompound?) {\n super.readNbt(tag)\n inventory = DefaultedList.ofSize(1, ItemStack.EMPTY)\n Inventories.readNbt(tag, inventory)\n }\n\n override fun writeNbt(tag: NbtCompound) {\n super.writeNbt(tag)\n Inventories.writeNbt(tag, inventory)\n }\n\n open fun sync() {\n Preconditions.checkNotNull(world) // Maintain distinct failure case from below\n check(world is ServerWorld) { \"Cannot call sync() on the logical client! Did you check world.isClient first?\" }\n (world as ServerWorld).chunkManager.markForUpdate(getPos())\n }\n\n companion object {\n fun tick(world: World, pos: BlockPos, state: BlockState, blockEntity: CapsuleBlockEntity) {\n if (world.isClient) return\n val tag = blockEntity.inventory[0].orCreateNbt\n val progress = tag.getInt(\"Progress\")\n if (tag.contains(\"Progress\") && progress == blockEntity.lastProgress) {\n tag.remove(\"Progress\")\n }\n blockEntity.lastProgress = progress\n }\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/laser/CapsuleBlockEntityRenderer.kt",
"content": "package me.steven.indrev.blockentities.laser\n\nimport net.minecraft.client.MinecraftClient\nimport net.minecraft.client.render.VertexConsumerProvider\nimport net.minecraft.client.render.WorldRenderer\nimport net.minecraft.client.render.block.entity.BlockEntityRenderer\nimport net.minecraft.client.render.model.json.ModelTransformation\nimport net.minecraft.client.util.math.MatrixStack\nimport net.minecraft.util.math.Vec3f\n\nclass CapsuleBlockEntityRenderer : BlockEntityRenderer {\n\n override fun render(\n entity: CapsuleBlockEntity?,\n tickDelta: Float,\n matrices: MatrixStack?,\n vertexConsumers: VertexConsumerProvider?,\n light: Int,\n overlay: Int\n ) {\n entity ?: return\n val itemStack = entity.inventory[0]\n if (itemStack.isEmpty) return\n val lightCoord = WorldRenderer.getLightmapCoordinates(entity.world, entity.pos)\n matrices?.run {\n push()\n val time = entity.world?.time ?: 1\n translate(0.5, 0.35, 0.5)\n scale(1.2f, 1.2f, 1.2f)\n multiply(Vec3f.POSITIVE_Y.getDegreesQuaternion((time + tickDelta) * 16 * entity.getActiveLasersCount()))\n MinecraftClient.getInstance().itemRenderer.renderItem(itemStack, ModelTransformation.Mode.GROUND, lightCoord, overlay, matrices, vertexConsumers, 0)\n pop()\n }\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/laser/LaserBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.laser\n\nimport me.steven.indrev.IndustrialRevolution\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.blockentities.MachineBlockEntity\nimport me.steven.indrev.blocks.machine.FacingMachineBlock\nimport me.steven.indrev.blocks.machine.LaserBlock\nimport me.steven.indrev.config.MachineConfig\nimport me.steven.indrev.recipes.machines.LaserRecipe\nimport me.steven.indrev.registry.MachineRegistry\nimport me.steven.indrev.utils.component1\nimport me.steven.indrev.utils.component2\nimport me.steven.indrev.utils.component3\nimport me.steven.indrev.utils.toVec3d\nimport net.fabricmc.api.EnvType\nimport net.fabricmc.api.Environment\nimport net.minecraft.block.BlockState\nimport net.minecraft.entity.Entity\nimport net.minecraft.item.ItemStack\nimport net.minecraft.particle.ParticleTypes\nimport net.minecraft.server.world.ServerWorld\nimport net.minecraft.sound.SoundCategory\nimport net.minecraft.sound.SoundEvents\nimport net.minecraft.util.math.*\nimport net.minecraft.world.World\nimport net.minecraft.world.explosion.Explosion\nimport java.util.*\n\nclass LaserBlockEntity(pos: BlockPos, state: BlockState) : MachineBlockEntity(Tier.MK4, MachineRegistry.LASER_EMITTER_REGISTRY, pos, state) {\n\n override val maxInput: Long = config.maxInput\n override val maxOutput: Long = 0\n\n private var ticksUntilExplode = 100\n\n private var recipe: LaserRecipe? = null\n\n override fun machineTick() {\n if (!cachedState[LaserBlock.POWERED]) {\n ticksUntilExplode = 100\n return\n }\n val facing = cachedState[FacingMachineBlock.FACING]\n val containerPos = pos.offset(facing, 4)\n\n val container = world?.getBlockEntity(containerPos) as? CapsuleBlockEntity\n\n if (container == null) {\n ticksUntilExplode--\n if (ticksUntilExplode < 0) explode()\n return\n } else {\n ticksUntilExplode = 100\n BlockPos.iterate(pos.offset(facing), pos.offset(facing, 3)).forEach {\n world?.breakBlock(it, true)\n }\n }\n\n val stack = container.inventory[0]\n if (recipe == null) {\n recipe = LaserRecipe.TYPE.getMatchingRecipe(world as ServerWorld, stack)\n .firstOrNull { it.matches(stack, emptyList()) }\n } else if (ItemStack.areItemsEqual(recipe!!.outputs.first().stack, stack)) {\n return\n }\n\n if (recipe?.matches(stack, emptyList()) != true) {\n world?.breakBlock(containerPos, false)\n recipe = null\n return\n }\n\n if (!use(config.energyCost)) {\n world?.setBlockState(pos, cachedState.with(LaserBlock.POWERED, false))\n return\n }\n\n val (x, y, z) = scale(facing.vec3f(), 3.0f)\n val damageArea = Box(pos).stretch(x.toDouble(), y.toDouble(), z.toDouble()).let {\n when {\n facing.axis.isVertical ->\n it.shrink(0.3, 0.0, 0.3)\n facing.axis == Direction.Axis.X ->\n it.shrink(0.0, 0.3, 0.3)\n else ->\n it.shrink(0.3, 0.3, 0.0)\n }\n }\n world?.getEntitiesByClass(Entity::class.java, damageArea) { true }?.forEach {\n it.setOnFireFor(1000)\n it.damage(LaserBlock.LASER_DAMAGE_SOURCE, 2f)\n }\n\n val tag = stack.orCreateNbt\n val progress = tag.getDouble(\"Progress\")\n if (progress >= recipe!!.ticks) {\n container.inventory[0] = recipe!!.craft(null as Random?).first()\n container.markDirty()\n container.sync()\n world?.updateNeighbors(containerPos, container.cachedState.block)\n } else\n tag.putDouble(\"Progress\", progress + config.energyCost)\n }\n\n @Environment(EnvType.CLIENT)\n override fun machineClientTick() {\n if (cachedState[LaserBlock.POWERED]) {\n if (!isEmittingLaser()) {\n if (world!!.random.nextDouble() > 0.7) {\n spawnParticles(world!!, pos, isFire = true)\n world!!.playSound(\n pos.x.toDouble() + 0.5,\n pos.y.toDouble() + 0.5,\n pos.z.toDouble() + 0.5,\n SoundEvents.BLOCK_FIRE_EXTINGUISH,\n SoundCategory.BLOCKS,\n 0.6f,\n 0.8f,\n false\n )\n }\n return\n }\n spawnParticles(world!!, pos, 0.4)\n }\n }\n\n private fun spawnParticles(world: World, pos: BlockPos, width: Double = 0.5625, isFire: Boolean = false) {\n val random = world.random\n val facing = cachedState[FacingMachineBlock.FACING]\n repeat(6) {\n val axis = facing.axis\n val x = if (axis != Direction.Axis.X) 0.7 - random.nextDouble() * width else 0.0\n val y = if (axis != Direction.Axis.Y) 0.7 - random.nextDouble() * width else 0.0\n val z = if (axis != Direction.Axis.Z) 0.7 - random.nextDouble() * width else 0.0\n val source = Vec3d(pos.x + x, pos.y + y, pos.z + z).let {\n val (x, y, z) = facing.unitVector\n if (x > 0 || y > 0 || z > 0)\n it.add(Vec3d(facing.unitVector))\n else it\n }\n val velocity = pos.offset(facing, 4).toVec3d().add(x, y, z).subtract(source).normalize().multiply(0.18)\n world.addParticle(\n if (isFire) ParticleTypes.SMOKE else IndustrialRevolution.LASER_PARTICLE,\n true,\n source.x,\n source.y,\n source.z,\n if (isFire) 0.0 else velocity.x,\n if (isFire) 0.05 else velocity.y,\n if (isFire) 0.0 else velocity.z\n )\n }\n }\n\n fun isEmittingLaser(): Boolean {\n val facing = cachedState[FacingMachineBlock.FACING]\n val containerPos = pos.offset(facing, 4)\n return cachedState[LaserBlock.POWERED] && world?.getBlockEntity(containerPos) as? CapsuleBlockEntity != null\n }\n\n private fun explode() {\n world?.createExplosion(\n null,\n pos.x.toDouble(), pos.y.toDouble(), pos.z.toDouble(),\n 3f,\n true,\n Explosion.DestructionType.DESTROY\n )\n }\n\n companion object {\n private fun Direction.vec3f() = Vec3f(offsetX.toFloat(), offsetY.toFloat(), offsetZ.toFloat())\n\n private fun scale(v: Vec3f, scale: Float): Vec3f {\n return Vec3f(v.x * scale, v.y * scale, v.z * scale)\n }\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/laser/LaserBlockEntityRenderer.kt",
"content": "package me.steven.indrev.blockentities.laser\n\nimport me.steven.indrev.blocks.machine.FacingMachineBlock\nimport me.steven.indrev.utils.identifier\nimport net.minecraft.client.render.VertexConsumerProvider\nimport net.minecraft.client.render.block.entity.BeaconBlockEntityRenderer\nimport net.minecraft.client.render.block.entity.BlockEntityRenderer\nimport net.minecraft.client.util.math.MatrixStack\nimport net.minecraft.util.Identifier\nimport net.minecraft.util.math.Direction\n\nclass LaserBlockEntityRenderer : BlockEntityRenderer {\n\n override fun render(\n entity: LaserBlockEntity?,\n tickDelta: Float,\n matrices: MatrixStack?,\n vertexConsumers: VertexConsumerProvider?,\n light: Int,\n overlay: Int\n ) {\n entity ?: return\n if (!entity.isEmittingLaser()) return\n val direction = entity.cachedState[FacingMachineBlock.FACING]\n matrices?.run {\n push()\n translate(direction.unitVector.x.toDouble(), direction.unitVector.y.toDouble(), direction.unitVector.z.toDouble())\n translate(0.5, 0.5, 0.5)\n val rotation = direction.let {\n when {\n it.axis.isHorizontal -> it.rotateYCounterclockwise().unitVector.getDegreesQuaternion(90f)\n it == Direction.DOWN -> Direction.EAST.unitVector.getDegreesQuaternion(180f)\n else -> it.unitVector.getDegreesQuaternion(90f)\n }\n }\n multiply(rotation)\n translate(-0.5, -0.5, -0.5)\n BeaconBlockEntityRenderer.renderBeam(\n matrices,\n vertexConsumers,\n TEXTURE,\n tickDelta,\n 1.0f,\n entity.world!!.time,\n 0,\n 3,\n floatArrayOf(1f, 1f, 1f),\n 0.085f,\n 0.1f\n )\n pop()\n }\n\n }\n\n override fun rendersOutsideBoundingBox(blockEntity: LaserBlockEntity?): Boolean = true\n\n companion object {\n val TEXTURE: Identifier = identifier(\"textures/entity/laser.png\")\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/miningrig/DataCardWriterBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.miningrig\n\nimport me.steven.indrev.api.OreDataCards\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.blockentities.MachineBlockEntity\nimport me.steven.indrev.components.autosync\nimport me.steven.indrev.config.BasicMachineConfig\nimport me.steven.indrev.config.IRConfig\nimport me.steven.indrev.inventories.inventory\nimport me.steven.indrev.registry.IRItemRegistry\nimport me.steven.indrev.registry.MachineRegistry\nimport net.minecraft.block.BlockState\nimport net.minecraft.item.Item\nimport net.minecraft.item.ItemStack\nimport net.minecraft.util.math.BlockPos\n\nclass DataCardWriterBlockEntity (tier: Tier, pos: BlockPos, state: BlockState)\n : MachineBlockEntity(tier, MachineRegistry.DATA_CARD_WRITER_REGISTRY, pos, state) {\n init {\n this.inventoryComponent = inventory(this) {\n input {\n 0 filter { itemStack, _ -> itemStack.item == IRItemRegistry.ORE_DATA_CARD }\n 1 until 13 filter { stack, _ -> OreDataCards.isAllowed(stack) }\n 13 until 16 filter { stack, _ -> OreDataCards.Modifier.isModifierItem(stack.item) }\n }\n }\n }\n\n var processTime by autosync(PROCESS_ID, 0)\n var totalProcessTime by autosync(TOTAL_PROCESS_ID, 0)\n\n private val modifiersToAdd = mutableMapOf()\n private val toWrite = mutableListOf()\n\n override fun machineTick() {\n if (totalProcessTime > 0 && use(getEnergyCost())) {\n if (processTime >= totalProcessTime)\n finish()\n else {\n processTime++\n workingState = true\n }\n } else {\n workingState = false\n }\n }\n\n fun start() {\n val inventory = inventoryComponent!!.inventory\n val cardStack = inventory.getStack(0)\n val oldData = OreDataCards.readNbt(cardStack)\n\n ORES_SLOTS.forEach { slot ->\n val stack = inventory.getStack(slot)\n if (!stack.isEmpty && stack.count == 64) {\n toWrite.add(stack)\n inventory.setStack(slot, ItemStack.EMPTY)\n }\n }\n\n if (toWrite.isEmpty() && oldData == null) {\n return\n }\n\n MODIFIERS_SLOTS.forEach { slot ->\n val stack = inventory.getStack(slot)\n val modifier = OreDataCards.Modifier.byItem(stack.item)\n var level = (modifiersToAdd[modifier] ?: 0) + (oldData?.modifiersUsed?.get(modifier) ?: 0)\n when (modifier) {\n OreDataCards.Modifier.RICHNESS -> {\n while (stack.count >= 16 && level < 40) {\n stack.decrement(16)\n level++\n }\n }\n OreDataCards.Modifier.SPEED, OreDataCards.Modifier.SIZE -> {\n while (stack.count >= 64) {\n stack.decrement(64)\n level++\n }\n }\n OreDataCards.Modifier.RNG -> {\n if (level == 0) {\n stack.decrement(1)\n val r = world!!.random.nextDouble()\n if (r > 0.95 && r <= 0.98) {\n level = -1\n } else if (r > 0.98) {\n level = 1\n }\n }\n }\n else -> return@forEach\n }\n modifiersToAdd[modifier] = level - (oldData?.modifiersUsed?.get(modifier) ?: 0)\n }\n\n processTime = 0\n totalProcessTime = 20*10 + (toWrite.size * (5*modifiersToAdd.map { it.value }.sum()))\n }\n\n private fun finish() {\n val inventory = inventoryComponent!!.inventory\n val cardStack = inventory.getStack(0)\n val oldData = OreDataCards.readNbt(cardStack)\n\n val oreTypes = toWrite.map { it.item }.distinct().count()\n val richnessDecrease = if (oreTypes == 1) 0.02 else 0.04\n val richnessModifier = ((modifiersToAdd[OreDataCards.Modifier.RICHNESS] ?: 0) * 0.01).coerceAtMost(0.2)\n val richness = ((oldData?.richness ?: 1.0) - (richnessDecrease * toWrite.size) + richnessModifier).coerceIn(richnessDecrease, 1.0)\n\n val speedModifier = ((oldData?.modifiersUsed?.get(OreDataCards.Modifier.SPEED) ?: 0) + (modifiersToAdd[OreDataCards.Modifier.SPEED] ?: 0)) * 20\n val speed = 100 + (richness * 1100) - speedModifier + (modifiersToAdd[OreDataCards.Modifier.SIZE] ?: 0) * 2\n\n val rng = oldData?.rng ?: modifiersToAdd[OreDataCards.Modifier.RNG] ?: 0\n\n val oreEnergyRequired = toWrite.sumOf { OreDataCards.getCost(it) * 16 }\n val energyRequired = (oldData?.energyRequired ?: 32) + 8 * (modifiersToAdd[OreDataCards.Modifier.SPEED] ?: 0) + oreEnergyRequired\n\n val cyclesModifiers = (modifiersToAdd[OreDataCards.Modifier.SIZE] ?: 0) * 128\n val maxCycles = (oldData?.maxCycles ?: 0) + (toWrite.size * 64) + cyclesModifiers\n\n val items = mutableMapOf()\n oldData?.entries?.forEach { entry ->\n items[entry.item] = entry.count\n }\n toWrite.forEach { stack ->\n items[stack.item] = items.getOrDefault(stack.item, 0) + stack.count\n }\n val entries = items.keys.map { OreDataCards.OreEntry(it, items[it]!!) }\n\n val modifiersMap = mutableMapOf()\n modifiersToAdd.forEach { (modifier, level) ->\n modifiersMap[modifier] = (oldData?.modifiersUsed?.get(modifier)?: 0) + level\n }\n val data = OreDataCards.Data(entries, modifiersMap, richness, speed.toInt(), rng, energyRequired, maxCycles, oldData?.used ?: 0)\n\n OreDataCards.writeNbt(cardStack, data)\n\n modifiersToAdd.clear()\n toWrite.clear()\n processTime = 0\n totalProcessTime = 0\n }\n\n override fun getEnergyCost(): Long {\n return IRConfig.machines.dataCardWriter.energyCost\n }\n\n companion object {\n const val PROCESS_ID = 2\n const val TOTAL_PROCESS_ID = 3\n\n val MODIFIERS_SLOTS = 13 until 16\n val ORES_SLOTS = 1 until 13\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/miningrig/DrillBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.miningrig\n\nimport com.google.common.base.Preconditions\nimport io.netty.buffer.Unpooled\nimport me.steven.indrev.api.OreDataCards\nimport me.steven.indrev.blocks.machine.DrillBlock\nimport me.steven.indrev.gui.screenhandlers.machines.MiningRigDrillScreenHandler\nimport me.steven.indrev.packets.client.MiningRigSpawnBlockParticlesPacket\nimport me.steven.indrev.registry.IRBlockRegistry\nimport me.steven.indrev.registry.IRItemRegistry\nimport me.steven.indrev.utils.component1\nimport me.steven.indrev.utils.component2\nimport me.steven.indrev.utils.component3\nimport net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking\nimport net.fabricmc.fabric.api.screenhandler.v1.ExtendedScreenHandlerFactory\nimport net.minecraft.block.Block\nimport net.minecraft.block.BlockState\nimport net.minecraft.block.entity.LootableContainerBlockEntity\nimport net.minecraft.entity.player.PlayerInventory\nimport net.minecraft.inventory.Inventories\nimport net.minecraft.item.BlockItem\nimport net.minecraft.item.Item\nimport net.minecraft.item.ItemStack\nimport net.minecraft.nbt.NbtCompound\nimport net.minecraft.network.PacketByteBuf\nimport net.minecraft.network.packet.s2c.play.BlockEntityUpdateS2CPacket\nimport net.minecraft.screen.ScreenHandler\nimport net.minecraft.screen.ScreenHandlerContext\nimport net.minecraft.server.network.ServerPlayerEntity\nimport net.minecraft.server.world.ServerWorld\nimport net.minecraft.text.Text\nimport net.minecraft.text.TranslatableText\nimport net.minecraft.util.collection.DefaultedList\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.registry.Registry\nimport net.minecraft.world.World\n\nclass DrillBlockEntity(pos: BlockPos, state: BlockState) : LootableContainerBlockEntity(IRBlockRegistry.DRILL_BLOCK_ENTITY_TYPE, pos, state), ExtendedScreenHandlerFactory {\n var inventory: DefaultedList = DefaultedList.ofSize(1, ItemStack.EMPTY)\n\n var position: Double = 1.0\n\n var miningProgress: Double = 0.0\n\n fun setWorkingState(working: Boolean) {\n if (cachedState[DrillBlock.WORKING] != working)\n world?.setBlockState(pos, cachedState.with(DrillBlock.WORKING, working))\n }\n\n fun tickMining(miningRig: MiningRigBlockEntity, data: OreDataCards.Data) {\n setWorkingState(true)\n miningProgress += getSpeedMultiplier()\n\n if (miningProgress >= data.speed) {\n miningProgress = 0.0\n val item = data.pickRandom(world!!.random)\n val rng = if (data.rng == 1 && world!!.random.nextDouble() < 0.1) 2 else 1\n val count = ((5 * data.richness) + world!!.random.nextInt((OreDataCards.MAX_PER_CYCLE * data.richness).toInt().coerceAtLeast(1))).toInt() * rng\n var stack = ItemStack(item, count)\n\n if (data.rng == 1 && world!!.random.nextDouble() > 0.9) {\n stack.count *= 2\n } else if (data.rng == -1 && world!!.random.nextDouble() > 0.9) {\n stack = ItemStack.EMPTY\n }\n\n miningRig.output(stack)\n\n data.used++\n miningRig.lastMinedItem = ItemStack(item)\n miningRig.sync()\n\n val drillStack = inventory[0]\n drillStack.damage(1, world!!.random, null)\n if (drillStack.damage >= drillStack.maxDamage) {\n inventory[0] = ItemStack.EMPTY\n }\n\n if (item is BlockItem)\n sendBlockBreakPacket(item.block)\n }\n }\n\n private fun sendBlockBreakPacket(block: Block) {\n val (x, y, z) = pos\n val players = (world as ServerWorld).server.playerManager.playerList\n for (i in players.indices) {\n val serverPlayerEntity = players[i]\n if (serverPlayerEntity.world.registryKey === world!!.registryKey) {\n val xOffset = x - serverPlayerEntity.x\n val yOffset = y - serverPlayerEntity.y\n val zOffset = z - serverPlayerEntity.z\n if (xOffset * xOffset + yOffset * yOffset + zOffset * zOffset < 64 * 64) {\n val buf = PacketByteBuf(Unpooled.buffer())\n buf.writeBlockPos(pos)\n buf.writeInt(Registry.BLOCK.getRawId(block))\n ServerPlayNetworking.send(serverPlayerEntity, MiningRigSpawnBlockParticlesPacket.BLOCK_BREAK_PACKET, buf)\n }\n }\n }\n }\n\n override fun size(): Int = 1\n\n override fun getContainerName(): Text = TranslatableText(\"block.indrev.drill\")\n\n override fun createScreenHandler(syncId: Int, playerInventory: PlayerInventory): ScreenHandler {\n return MiningRigDrillScreenHandler(syncId, playerInventory, ScreenHandlerContext.create(world, pos))\n }\n\n override fun getInvStackList(): DefaultedList = inventory\n\n override fun setInvStackList(list: DefaultedList) {\n inventory = list\n }\n\n override fun readNbt(tag: NbtCompound) {\n super.readNbt(tag)\n inventory = DefaultedList.ofSize(size(), ItemStack.EMPTY)\n if (!deserializeLootTable(tag)) {\n Inventories.readNbt(tag, inventory)\n }\n position = tag.getDouble(\"Position\")\n miningProgress = tag.getDouble(\"Mining\")\n }\n\n override fun writeNbt(tag: NbtCompound) {\n super.writeNbt(tag)\n if (!serializeLootTable(tag)) {\n Inventories.writeNbt(tag, inventory)\n }\n tag.putDouble(\"Position\", position)\n tag.putDouble(\"Mining\", miningProgress)\n }\n\n override fun toUpdatePacket(): BlockEntityUpdateS2CPacket {\n return BlockEntityUpdateS2CPacket.create(this)\n }\n\n override fun toInitialChunkDataNbt(): NbtCompound {\n val nbt = super.toInitialChunkDataNbt()\n writeNbt(nbt)\n return nbt\n }\n\n\n fun sync() {\n Preconditions.checkNotNull(world) // Maintain distinct failure case from below\n check(world is ServerWorld) { \"Cannot call sync() on the logical client! Did you check world.isClient first?\" }\n (world as ServerWorld).chunkManager.markForUpdate(getPos())\n }\n\n override fun writeScreenOpeningData(player: ServerPlayerEntity, buf: PacketByteBuf) {\n buf.writeBlockPos(pos)\n }\n\n fun getSpeedMultiplier(): Double {\n val item = inventory[0].item\n return if (position > 0) 0.0 else when (item) {\n IRItemRegistry.STONE_DRILL_HEAD -> 1.0\n IRItemRegistry.IRON_DRILL_HEAD -> 2.0\n IRItemRegistry.DIAMOND_DRILL_HEAD -> 4.0\n IRItemRegistry.NETHERITE_DRILL_HEAD -> 8.0\n else -> 0.0\n }\n }\n\n companion object {\n\n fun isValidDrill(item: Item) =\n item == IRItemRegistry.STONE_DRILL_HEAD\n || item == IRItemRegistry.IRON_DRILL_HEAD\n || item == IRItemRegistry.DIAMOND_DRILL_HEAD\n || item == IRItemRegistry.NETHERITE_DRILL_HEAD\n\n fun tick(world: World, pos: BlockPos, state: BlockState, blockEntity: DrillBlockEntity) {\n\n if (blockEntity.inventory[0].isEmpty) {\n blockEntity.position = 1.0\n blockEntity.markDirty()\n blockEntity.sync()\n } else if (state[DrillBlock.WORKING]) {\n if (blockEntity.position > 0) blockEntity.position -= 0.01\n\n else return\n blockEntity.markDirty()\n blockEntity.sync()\n }\n }\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/miningrig/DrillBlockEntityRenderer.kt",
"content": "package me.steven.indrev.blockentities.miningrig\n\nimport me.steven.indrev.blocks.machine.DrillBlock\nimport me.steven.indrev.registry.IRItemRegistry\nimport me.steven.indrev.utils.identifier\nimport net.minecraft.client.MinecraftClient\nimport net.minecraft.client.render.OverlayTexture\nimport net.minecraft.client.render.RenderLayers\nimport net.minecraft.client.render.VertexConsumerProvider\nimport net.minecraft.client.render.WorldRenderer\nimport net.minecraft.client.render.block.entity.BlockEntityRenderer\nimport net.minecraft.client.util.ModelIdentifier\nimport net.minecraft.client.util.math.MatrixStack\nimport net.minecraft.util.math.Vec3f\n\nclass DrillBlockEntityRenderer : BlockEntityRenderer {\n override fun render(\n entity: DrillBlockEntity,\n tickDelta: Float,\n matrices: MatrixStack?,\n vertexConsumers: VertexConsumerProvider,\n light: Int,\n overlay: Int\n ) {\n val variant = when (entity.inventory[0].item) {\n IRItemRegistry.STONE_DRILL_HEAD -> \"stone\"\n IRItemRegistry.IRON_DRILL_HEAD -> \"iron\"\n IRItemRegistry.DIAMOND_DRILL_HEAD -> \"diamond\"\n IRItemRegistry.NETHERITE_DRILL_HEAD -> \"netherite\"\n else -> return\n }\n val model =\n MinecraftClient.getInstance().bakedModelManager.getModel(ModelIdentifier(identifier(\"drill_head\"), variant))\n matrices?.run {\n push()\n val entry = peek()\n translate(0.5, 0.0, 0.5)\n if (entity.position <= 0.0 && entity.cachedState[DrillBlock.WORKING]) {\n multiply(Vec3f.POSITIVE_Y.getDegreesQuaternion( (entity.world!!.time + tickDelta) * 12))\n }\n translate(-0.5, entity.position, -0.5)\n MinecraftClient.getInstance().blockRenderManager.modelRenderer.render(\n entry,\n vertexConsumers.getBuffer(RenderLayers.getBlockLayer(entity.cachedState)),\n null,\n model,\n -1f,\n -1f,\n -1f,\n WorldRenderer.getLightmapCoordinates(entity.world, entity.pos),\n OverlayTexture.DEFAULT_UV\n )\n pop()\n }\n }\n\n override fun rendersOutsideBoundingBox(blockEntity: DrillBlockEntity?): Boolean = true\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/miningrig/MiningRigBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.miningrig\n\nimport me.steven.indrev.api.OreDataCards\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.api.machines.TransferMode\nimport me.steven.indrev.api.sideconfigs.ConfigurationType\nimport me.steven.indrev.blockentities.MachineBlockEntity\nimport me.steven.indrev.blocks.machine.DrillBlock\nimport me.steven.indrev.blocks.machine.MachineBlock\nimport me.steven.indrev.components.*\nimport me.steven.indrev.config.BasicMachineConfig\nimport me.steven.indrev.config.IRConfig\nimport me.steven.indrev.inventories.inventory\nimport me.steven.indrev.items.misc.OreDataCardItem\nimport me.steven.indrev.registry.MachineRegistry\nimport me.steven.indrev.utils.*\nimport net.fabricmc.fabric.api.transfer.v1.item.ItemVariant\nimport net.fabricmc.fabric.api.transfer.v1.transaction.Transaction\nimport net.minecraft.block.BlockState\nimport net.minecraft.item.ItemStack\nimport net.minecraft.nbt.NbtCompound\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.math.Direction\nimport java.util.EnumSet\n\nclass MiningRigBlockEntity(tier: Tier, pos: BlockPos, state: BlockState)\n : MachineBlockEntity(tier, MachineRegistry.MINING_RIG_REGISTRY, pos, state) {\n\n init {\n this.inventoryComponent = inventory(this) {\n input {\n 0 filter { itemStack, _ -> itemStack.item is OreDataCardItem }\n }\n }\n trackLong(ENERGY_REQUIRED_ID) { getEnergyCost() }\n trackInt(MAX_SPEED_ID) {\n OreDataCards.readNbt(inventoryComponent!!.inventory.getStack(0))?.speed ?: 0\n }\n VALID_DRILL_POSITIONS.forEachIndexed { index, offset ->\n val id = START_DRILL_ID + index\n val drillPos = pos.add(offset)\n trackDouble(id) {\n val block = world?.getBlockState(drillPos)?.block as? DrillBlock ?: return@trackDouble 0.0\n val drillBlockEntity = world?.getBlockEntity(block.part.getBlockEntityPos(drillPos)) as? DrillBlockEntity ?: return@trackDouble 0.0\n drillBlockEntity.miningProgress\n }\n }\n }\n\n override val syncToWorld: Boolean = true\n\n override val maxInput: Long = config.maxInput\n override val maxOutput: Long = 0\n\n var lastMinedItem: ItemStack = ItemStack.EMPTY\n\n val storageDirections = Direction.values().toMutableList()\n private val remainingStacks = mutableListOf()\n\n override fun machineTick() {\n val inventory = inventoryComponent?.inventory ?: return\n\n if (remainingStacks.isNotEmpty()) {\n val copy = ArrayList(remainingStacks)\n remainingStacks.clear()\n copy.forEach { output(it) }\n\n getActiveDrills().forEach { drill -> drill.setWorkingState(false) }\n workingState = false\n return\n }\n\n val cardStack = inventory.getStack(0)\n val data = OreDataCards.readNbt(cardStack)\n\n if (data != null && data.isValid() && !data.isEmpty() && use(getEnergyCost())) {\n workingState = true\n val before = data.used\n getActiveDrills().forEach { drill -> drill.tickMining(this, data) }\n if (before != data.used)\n OreDataCards.writeNbt(cardStack, data)\n } else {\n workingState = false\n getActiveDrills().forEach { drill ->\n drill.setWorkingState(false)\n drill.miningProgress = 0.0\n }\n }\n }\n\n fun output(stack: ItemStack) {\n val variant = ItemVariant.of(stack)\n var count = stack.count.toLong()\n storageDirections.removeIf { dir ->\n val itemStorage = itemStorageOf(world!!, pos.offset(dir), dir.opposite) ?: return@removeIf true\n if (count > 0) {\n transaction { tx ->\n val inserted = itemStorage.insert(variant, count, tx)\n tx.commit()\n count -= inserted\n }\n }\n\n false\n }\n\n if (count > 0) {\n stack.count = count.toInt()\n remainingStacks.add(stack)\n }\n }\n\n fun getActiveDrills(): List {\n return VALID_DRILL_POSITIONS.map { pos.add(it) }.mapNotNull { pos ->\n val blockState = world?.getBlockState(pos)\n val block = blockState?.block\n if (block is DrillBlock) {\n val blockEntity = world?.getBlockEntity(block.part.getBlockEntityPos(pos)) as? DrillBlockEntity ?: return@mapNotNull null\n val itemStack = blockEntity.inventory[0]\n if (!itemStack.isEmpty && DrillBlockEntity.isValidDrill(itemStack.item)) {\n blockEntity\n } else {\n blockEntity.setWorkingState(false)\n null\n }\n } else null\n }\n }\n\n override fun getEnergyCost(): Long {\n return config.energyCost + (IRConfig.machines.drill * getActiveDrills().size) + (OreDataCards.readNbt(inventoryComponent!!.inventory.getStack(0))?.energyRequired ?: 0)\n }\n\n override fun applyDefault(\n state: BlockState,\n type: ConfigurationType,\n configuration: MutableMap\n ) {\n val direction = (state.block as MachineBlock).getFacing(state)\n when (type) {\n ConfigurationType.ITEM -> {\n configuration[direction.rotateYCounterclockwise()] = TransferMode.OUTPUT\n }\n else -> super.applyDefault(state, type, configuration)\n }\n }\n\n override fun getValidConfigurations(type: ConfigurationType): Array {\n return when (type) {\n ConfigurationType.ITEM -> arrayOf(TransferMode.OUTPUT, TransferMode.NONE)\n else -> return super.getValidConfigurations(type)\n }\n }\n\n override fun toClientTag(tag: NbtCompound) {\n tag.put(\"LastMinedBlock\", lastMinedItem.writeNbt(NbtCompound()))\n }\n\n override fun fromClientTag(tag: NbtCompound) {\n lastMinedItem = ItemStack.fromNbt(tag.getCompound(\"LastMinedBlock\"))\n }\n\n companion object {\n val VALID_DRILL_POSITIONS = arrayOf(\n BlockPos(-1, 0, 0),\n BlockPos(1, 0, 0),\n BlockPos(0, 0, -1),\n BlockPos(0, 0, 1),\n BlockPos(-1, 0, -1),\n BlockPos(-1, 0, 1),\n BlockPos(1, 0, 1),\n BlockPos(1, 0, -1)\n )\n\n const val ENERGY_REQUIRED_ID = 2\n const val MAX_SPEED_ID = 3\n const val START_DRILL_ID = 4\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/miningrig/MiningRigBlockEntityRenderer.kt",
"content": "package me.steven.indrev.blockentities.miningrig\n\nimport me.steven.indrev.blocks.machine.HorizontalFacingMachineBlock\nimport net.minecraft.client.MinecraftClient\nimport net.minecraft.client.render.VertexConsumerProvider\nimport net.minecraft.client.render.block.entity.BlockEntityRenderer\nimport net.minecraft.client.render.model.json.ModelTransformation\nimport net.minecraft.client.util.math.MatrixStack\nimport net.minecraft.util.math.Direction\nimport net.minecraft.util.math.Vec3f\n\nclass MiningRigBlockEntityRenderer : BlockEntityRenderer {\n override fun render(\n entity: MiningRigBlockEntity?,\n tickDelta: Float,\n matrices: MatrixStack?,\n vertexConsumers: VertexConsumerProvider?,\n light: Int,\n overlay: Int\n ) {\n if (entity == null || !entity.workingState) return\n matrices?.run {\n push()\n val direction = entity.cachedState[HorizontalFacingMachineBlock.HORIZONTAL_FACING]\n when (direction) {\n Direction.NORTH -> translate(0.34, 0.6, -0.01)\n Direction.SOUTH -> translate(0.66, 0.6, 1.01)\n Direction.WEST -> translate(-0.01, 0.6, 0.66)\n Direction.EAST -> translate(1.01, 0.6, 0.34)\n else -> {\n pop()\n return\n }\n }\n multiply(Vec3f.NEGATIVE_Y.getDegreesQuaternion(direction.asRotation()))\n scale(0.3f, 0.3f, 0.01f)\n MinecraftClient.getInstance().itemRenderer.renderItem(entity.lastMinedItem, ModelTransformation.Mode.GUI, 15728880, overlay, this, vertexConsumers, 0)\n pop()\n }\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/modularworkbench/ModularWorkbenchBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.modularworkbench\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.blockentities.MachineBlockEntity\nimport me.steven.indrev.components.autosync\nimport me.steven.indrev.config.BasicMachineConfig\nimport me.steven.indrev.inventories.inventory\nimport me.steven.indrev.items.armor.IRColorModuleItem\nimport me.steven.indrev.items.armor.IRModularArmorItem\nimport me.steven.indrev.items.armor.IRModuleItem\nimport me.steven.indrev.recipes.machines.ModuleRecipe\nimport me.steven.indrev.registry.MachineRegistry\nimport me.steven.indrev.tools.modular.ArmorModule\nimport me.steven.indrev.tools.modular.IRModularItem\nimport me.steven.indrev.utils.component1\nimport me.steven.indrev.utils.component2\nimport me.steven.indrev.utils.getRecipes\nimport net.minecraft.block.BlockState\nimport net.minecraft.item.ItemStack\nimport net.minecraft.nbt.NbtCompound\nimport net.minecraft.util.Identifier\nimport net.minecraft.util.math.BlockPos\n\nclass ModularWorkbenchBlockEntity(tier: Tier, pos: BlockPos, state: BlockState)\n : MachineBlockEntity(tier, MachineRegistry.MODULAR_WORKBENCH_REGISTRY, pos, state) {\n\n init {\n this.inventoryComponent = inventory(this) {\n\n maxStackCount = 1\n\n 0 filter { (_, item) -> item !is IRModularItem<*> }\n 1 filter { stack -> stack.item is IRModuleItem }\n 2 filter { stack -> stack.item is IRModularItem<*> }\n 3 until 15 filter { stack, index -> recipe != null && recipe!!.input.size > index - 3 && recipe!!.input[index - 3].ingredient.test(stack) }\n input {\n slots = (1 until 15).map { it }.toIntArray()\n }\n output { slot = 15 }\n }\n }\n\n override val syncToWorld: Boolean = true\n\n override val maxOutput: Long = 0\n\n var moduleProcessTime by autosync(PROCESS_TIME_ID, 0)\n var moduleMaxProcessTime by autosync(MAX_PROCESS_TIME_ID, 0)\n\n private var processTime by autosync(INSTALL_TIME_ID, 0)\n private var maxProcessTime by autosync(MAX_INSTALL_TIME_ID, 0)\n\n private var state: State by autosync(STATE_ID, State.IDLE, State.values())\n\n var selectedRecipe: Identifier? = null\n var recipe: ModuleRecipe? = null\n get() {\n if (selectedRecipe != null)\n field = world!!.recipeManager.getRecipes(ModuleRecipe.TYPE)[selectedRecipe]!!\n return field\n }\n\n override fun machineTick() {\n tickModuleInstall()\n tickModuleCraft()\n }\n\n private fun tickModuleCraft() {\n val inventory = inventoryComponent?.inventory ?: return\n if (!inventory.getStack(15).isEmpty) return\n val inputStacks = inventory.inputSlots.map { inventory.getStack(it) }\n when {\n recipe?.matches(inputStacks, emptyList()) != true -> {\n moduleMaxProcessTime = 0\n moduleProcessTime = 0\n }\n moduleMaxProcessTime in 1..moduleProcessTime -> {\n (3 until 15).forEach { slot -> inventory.setStack(slot, ItemStack.EMPTY) }\n inventory.setStack(15, recipe!!.outputs[0].stack.copy())\n\n moduleMaxProcessTime = 0\n moduleProcessTime = 0\n }\n else -> {\n moduleMaxProcessTime = recipe!!.ticks\n moduleProcessTime++\n }\n }\n }\n\n private fun tickModuleInstall() {\n val inventory = inventoryComponent?.inventory ?: return\n val targetStack = inventory.getStack(2)\n val moduleStack = inventory.getStack(1)\n if (moduleStack.item !is IRModuleItem || targetStack.item !is IRModularItem<*>) {\n processTime = 0\n state = State.IDLE\n return\n }\n val targetItem = targetStack.item as IRModularItem<*>\n val moduleItem = moduleStack.item as IRModuleItem\n val module = moduleItem.module\n val compatible = targetItem.getCompatibleModules(targetStack)\n if (inventory.isEmpty) {\n processTime = 0\n workingState = false\n state = State.IDLE\n } else {\n if (isProcessing()\n && compatible.contains(module)\n && use(config.energyCost)) {\n workingState = true\n processTime += config.processSpeed.toInt()\n if (processTime >= maxProcessTime) {\n inventory.setStack(1, ItemStack.EMPTY)\n val tag = targetStack.orCreateNbt\n when {\n module == ArmorModule.COLOR -> {\n if (targetItem !is IRModularArmorItem) return\n val colorModuleItem = moduleItem as IRColorModuleItem\n targetItem.setColor(targetStack, colorModuleItem.color)\n }\n tag.contains(module.key) -> {\n val level = tag.getInt(module.key) + 1\n tag.putInt(module.key, level.coerceAtMost(module.maxLevel))\n }\n else -> tag.putInt(module.key, 1)\n }\n processTime = 0\n state = State.IDLE\n }\n } else if (energy > 0 && !targetStack.isEmpty && !moduleStack.isEmpty && compatible.contains(module)) {\n val tag = targetStack.orCreateNbt\n if (tag.contains(module.key)) {\n val level = module.getMaxInstalledLevel(targetStack)\n if (module != ArmorModule.COLOR && level >= module.maxLevel) {\n state = State.MAX_LEVEL\n return\n }\n }\n processTime = 1\n maxProcessTime = 1200\n workingState = true\n state = State.INSTALLING\n } else {\n state = State.INCOMPATIBLE\n }\n }\n }\n\n private fun isProcessing(): Boolean = processTime > 0 && energy > 0\n\n override fun fromTag(tag: NbtCompound) {\n processTime = tag.getInt(\"ProcessTime\")\n if (tag.contains(\"SelectedRecipe\"))\n selectedRecipe = Identifier(tag.getString(\"SelectedRecipe\"))\n super.fromTag(tag)\n }\n\n override fun toTag(tag: NbtCompound) {\n tag.putInt(\"ProcessTime\", processTime)\n if (selectedRecipe != null)\n tag.putString(\"SelectedRecipe\", selectedRecipe!!.toString())\n super.toTag(tag)\n }\n\n override fun fromClientTag(tag: NbtCompound) {\n if (tag.contains(\"SelectedRecipe\"))\n selectedRecipe = Identifier(tag.getString(\"SelectedRecipe\"))\n inventoryComponent!!.readNbt(tag)\n }\n\n override fun toClientTag(tag: NbtCompound) {\n if (selectedRecipe != null)\n tag.putString(\"SelectedRecipe\", selectedRecipe!!.toString())\n inventoryComponent!!.writeNbt(tag)\n }\n\n enum class State {\n IDLE,\n INSTALLING,\n INCOMPATIBLE,\n MAX_LEVEL;\n }\n\n companion object {\n const val PROCESS_TIME_ID = 2\n const val MAX_PROCESS_TIME_ID = 3\n const val INSTALL_TIME_ID = 4\n const val MAX_INSTALL_TIME_ID = 5\n const val STATE_ID = 6\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/modularworkbench/ModularWorkbenchBlockEntityRenderer.kt",
"content": "package me.steven.indrev.blockentities.modularworkbench\n\nimport me.steven.indrev.armor.ModuleFeatureRenderer\nimport me.steven.indrev.components.multiblock.MultiblockBlockEntityRenderer\nimport me.steven.indrev.items.armor.IRModularArmorItem\nimport me.steven.indrev.tools.modular.IRModularItem\nimport me.steven.indrev.utils.identifier\nimport net.minecraft.client.MinecraftClient\nimport net.minecraft.client.model.Dilation\nimport net.minecraft.client.model.TexturedModelData\nimport net.minecraft.client.network.AbstractClientPlayerEntity\nimport net.minecraft.client.render.OverlayTexture\nimport net.minecraft.client.render.RenderLayer\nimport net.minecraft.client.render.VertexConsumerProvider\nimport net.minecraft.client.render.WorldRenderer\nimport net.minecraft.client.render.block.entity.BlockEntityRenderer\nimport net.minecraft.client.render.entity.model.BipedEntityModel\nimport net.minecraft.client.render.entity.model.ElytraEntityModel\nimport net.minecraft.client.render.entity.model.PlayerEntityModel\nimport net.minecraft.client.render.item.ItemRenderer\nimport net.minecraft.client.render.model.json.ModelTransformation\nimport net.minecraft.client.util.math.MatrixStack\nimport net.minecraft.entity.EquipmentSlot\nimport net.minecraft.item.ArmorItem\nimport net.minecraft.item.ItemStack\nimport net.minecraft.util.Identifier\nimport net.minecraft.util.math.Vec3f\n\nclass ModularWorkbenchBlockEntityRenderer : BlockEntityRenderer {\n\n private val bodyModel = BipedEntityModel(TexturedModelData.of(PlayerEntityModel.getTexturedModelData(Dilation.NONE, false), 64, 64).createModel())\n private val leggingsModel = BipedEntityModel(TexturedModelData.of(PlayerEntityModel.getTexturedModelData(Dilation.NONE, false), 64, 64).createModel())\n\n init {\n bodyModel.setVisible(false)\n leggingsModel.setVisible(false)\n }\n\n override fun render(\n entity: ModularWorkbenchBlockEntity,\n tickDelta: Float,\n matrices: MatrixStack,\n vertexConsumers: VertexConsumerProvider,\n light: Int,\n overlay: Int\n ) {\n ElytraEntityModel.getTexturedModelData().createModel()\n val itemStack = entity.inventoryComponent?.inventory?.getStack(2)\n if (itemStack?.item is IRModularArmorItem) {\n matrices.run {\n push()\n val yOffset = if (itemStack.item is IRModularArmorItem) {\n when ((itemStack.item as IRModularArmorItem).slotType) {\n EquipmentSlot.HEAD -> 1.0\n EquipmentSlot.CHEST -> 1.5\n EquipmentSlot.LEGS -> 1.7\n EquipmentSlot.FEET -> 2.0\n else -> -1.0\n }\n } else 0.0\n val time = entity.world?.time ?: 1\n translate(0.5, yOffset, 0.5)\n multiply(Vec3f.POSITIVE_Y.getDegreesQuaternion((time + tickDelta) * 4))\n multiply(Vec3f.POSITIVE_Z.getDegreesQuaternion(180f))\n val lightMapCoords = WorldRenderer.getLightmapCoordinates(entity.world, entity.pos)\n renderArmor(this, vertexConsumers, itemStack, lightMapCoords)\n pop()\n }\n } else if (itemStack?.item is IRModularItem<*>) {\n val lightCoord = WorldRenderer.getLightmapCoordinates(entity.world, entity.pos)\n matrices.run {\n push()\n val time = entity.world?.time ?: 1\n translate(0.5, 0.35, 0.5)\n multiply(Vec3f.POSITIVE_Y.getDegreesQuaternion((time + tickDelta) * 4))\n MinecraftClient.getInstance().itemRenderer.renderItem(itemStack, ModelTransformation.Mode.GROUND, lightCoord, overlay, matrices, vertexConsumers, 0)\n pop()\n }\n }\n }\n\n private fun renderArmor(\n matrices: MatrixStack,\n vertexConsumers: VertexConsumerProvider,\n itemStack: ItemStack,\n light: Int\n ) {\n val item = itemStack.item as? IRModularArmorItem ?: return\n val slotType = item.slotType\n val bipedEntityModel = getArmor(slotType)\n setVisible(slotType)\n val rgb = item.getColor(itemStack)\n val r = (rgb and 0xFF0000 shr 16) / 255f\n val g = (rgb and 0xFF00 shr 8) / 255f\n val b = (rgb and 0xFF) / 255f\n renderArmorParts(\n matrices, vertexConsumers, light, item, itemStack.hasGlint(), bipedEntityModel, usesSecondLayer(slotType), r, g, b, null\n )\n item.getInstalled(itemStack).filter { it.slots.contains(slotType) }.forEach { module ->\n if (module.hasTexture) {\n renderArmorParts(\n matrices, vertexConsumers, light, item, itemStack.hasGlint(), bipedEntityModel, usesSecondLayer(slotType), r, g, b, module.key\n )\n if (module.hasOverlay) {\n renderArmorParts(\n matrices, vertexConsumers, 15728880, item, itemStack.hasGlint(), bipedEntityModel, usesSecondLayer(slotType), r, g, b, \"${module.key}_overlay\"\n )\n }\n }\n }\n }\n\n private fun renderArmorParts(\n matrixStack: MatrixStack,\n vertexConsumerProvider: VertexConsumerProvider,\n light: Int,\n armorItem: ArmorItem,\n hasGlint: Boolean,\n bipedEntityModel: BipedEntityModel,\n secondLayer: Boolean,\n r: Float, g: Float, b: Float,\n overlay: String?\n ) {\n val vertexConsumer = ItemRenderer.getArmorGlintConsumer(\n vertexConsumerProvider,\n RenderLayer.getArmorCutoutNoCull(getArmorTexture(armorItem, secondLayer, overlay)),\n false,\n hasGlint\n )\n bipedEntityModel.render(matrixStack, vertexConsumer, light, OverlayTexture.DEFAULT_UV, r, g, b, 1.0f)\n }\n\n private fun getArmor(slot: EquipmentSlot): BipedEntityModel {\n return if (usesSecondLayer(slot)) leggingsModel else bodyModel\n }\n\n private fun usesSecondLayer(slot: EquipmentSlot): Boolean {\n return slot == EquipmentSlot.LEGS\n }\n\n private fun setVisible(slot: EquipmentSlot) {\n bodyModel.head.visible = slot == EquipmentSlot.HEAD\n bodyModel.hat.visible = slot == EquipmentSlot.HEAD\n\n bodyModel.body.visible = slot == EquipmentSlot.CHEST\n bodyModel.rightArm.visible = slot == EquipmentSlot.CHEST\n bodyModel.leftArm.visible = slot == EquipmentSlot.CHEST\n\n leggingsModel.body.visible = slot == EquipmentSlot.LEGS\n leggingsModel.rightLeg.visible = slot == EquipmentSlot.LEGS\n leggingsModel.leftLeg.visible = slot == EquipmentSlot.LEGS\n\n bodyModel.rightLeg.visible = slot == EquipmentSlot.FEET\n bodyModel.leftLeg.visible = slot == EquipmentSlot.FEET\n }\n\n private fun getArmorTexture(armorItem: ArmorItem, bl: Boolean, string: String?): Identifier {\n val path = \"textures/models/armor/\" + armorItem.material.name + \"_layer_\" + (if (bl) 2 else 1) + (if (string == null) \"\" else \"_$string\") + \".png\"\n return ModuleFeatureRenderer.MODULAR_ARMOR_TEXTURE_CACHE.computeIfAbsent(path) { id ->\n if (string == null) Identifier(id) else identifier(id)\n }\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/solarpowerplant/HeliostatBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.solarpowerplant\n\nimport me.steven.indrev.blockentities.BaseBlockEntity\nimport me.steven.indrev.blocks.HeliostatBlock\nimport me.steven.indrev.registry.IRBlockRegistry\nimport net.minecraft.block.BlockState\nimport net.minecraft.nbt.NbtCompound\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.world.World\n\nclass HeliostatBlockEntity(pos: BlockPos, state: BlockState) : BaseBlockEntity(IRBlockRegistry.HELIOSTAT_BLOCK_ENTITY, pos, state) {\n\n var targetBlock: BlockPos = BlockPos.ORIGIN\n\n var pitch: Float = 0.0f\n var yaw: Float = 0.0f\n\n companion object {\n fun tick(world: World, pos: BlockPos, state: BlockState, blockEntity: HeliostatBlockEntity) {\n //this doesn't work, i need another way to check if there's no obstruction\n //val hit = world!!.raycastBlock(pos.toVec3d().add(0.5, 1.5, 0.5), targetBlock.toVec3d().add(0.5, 0.5, 0.5), pos, cachedState.getOutlineShape(world, pos), cachedState)\n //if (hit !is BlockHitResult || hit.blockPos != targetBlock) return\n if (!world.isSkyVisible(pos.up())) return\n val receiver = world.getBlockEntity(blockEntity.targetBlock) as? SolarReceiverBlockEntity ?: return\n val controller =\n world.getBlockEntity(receiver.controllerPos) as? SolarPowerPlantTowerBlockEntity ?: return\n controller.heliostats++\n }\n }\n\n override fun toTag(tag: NbtCompound) {\n tag.putLong(\"target\", targetBlock.asLong())\n }\n \n override fun fromTag(tag: NbtCompound) {\n targetBlock = BlockPos.fromLong(tag.getLong(\"target\"))\n yaw = HeliostatBlock.getYaw(pos, targetBlock)\n pitch = HeliostatBlock.getPitch(pos, targetBlock)\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/solarpowerplant/HeliostatBlockEntityRenderer.kt",
"content": "package me.steven.indrev.blockentities.solarpowerplant\n\nimport net.minecraft.block.Blocks\nimport net.minecraft.block.HorizontalConnectingBlock\nimport net.minecraft.client.MinecraftClient\nimport net.minecraft.client.render.RenderLayers\nimport net.minecraft.client.render.VertexConsumerProvider\nimport net.minecraft.client.render.block.entity.BlockEntityRenderer\nimport net.minecraft.client.util.math.MatrixStack\nimport net.minecraft.util.math.Vec3f\n\nclass HeliostatBlockEntityRenderer : BlockEntityRenderer {\n override fun render(\n entity: HeliostatBlockEntity?,\n tickDelta: Float,\n matrices: MatrixStack?,\n vertexConsumers: VertexConsumerProvider?,\n light: Int,\n overlay: Int\n ) {\n if (entity == null) return\n\n matrices?.run {\n push()\n val state = Blocks.GLASS_PANE.defaultState.with(HorizontalConnectingBlock.WEST, true).with(HorizontalConnectingBlock.EAST, true)\n matrices.translate(0.5, 0.5, 0.5)\n matrices.multiply(Vec3f.NEGATIVE_Y.getDegreesQuaternion(entity.yaw))\n matrices.multiply(Vec3f.POSITIVE_X.getDegreesQuaternion(entity.pitch))\n matrices.translate(-0.5, -0.5, -0.5)\n val buffer = vertexConsumers?.getBuffer(RenderLayers.getBlockLayer(state))\n MinecraftClient.getInstance().blockRenderManager.renderBlock(state, entity.pos, entity.world, this, buffer, false, entity.world!!.random)\n pop()\n }\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/solarpowerplant/SolarPowerPlantTowerBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.solarpowerplant\n\nimport me.steven.indrev.blockentities.BaseBlockEntity\nimport me.steven.indrev.blockentities.Syncable\nimport me.steven.indrev.components.*\nimport me.steven.indrev.components.multiblock.MultiBlockComponent\nimport me.steven.indrev.components.multiblock.definitions.SolarPowerPlantTowerStructureDefinition\nimport me.steven.indrev.registry.IRBlockRegistry\nimport me.steven.indrev.utils.bucket\nimport net.minecraft.block.BlockState\nimport net.minecraft.nbt.NbtCompound\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.world.World\n\nclass SolarPowerPlantTowerBlockEntity(pos: BlockPos, state: BlockState)\n : BaseBlockEntity(IRBlockRegistry.SOLAR_POWER_PLANT_TOWER_BLOCK_ENTITY, pos, state), Syncable {\n\n override val guiSyncableComponent = GuiSyncableComponent()\n\n val temperatureComponent = TemperatureComponent(this, 0.09, 1100..1300, 1500)\n val multiblockComponent = SolarPowerPlantMultiblockComponent()\n val fluidComponent = object : FluidComponent({ this }, bucket * 16, 2) {\n init {\n this.inputTanks = intArrayOf(0)\n this.outputTanks = intArrayOf(1)\n this.unsided = true\n }\n }\n\n var isMarkedForUpdate = false\n\n init {\n trackObject(INPUT_TANK_ID, fluidComponent[0])\n trackObject(OUTPUT_TANK_ID, fluidComponent[1])\n }\n\n var heliostats = 0\n\n companion object {\n const val INPUT_TANK_ID = 4\n const val OUTPUT_TANK_ID = 5\n\n fun tick(world: World, pos: BlockPos, state: BlockState, blockEntity: SolarPowerPlantTowerBlockEntity) {\n blockEntity.multiblockComponent.tick(world, pos, state)\n if (blockEntity.multiblockComponent.isBuilt(world, pos, state)) {\n val limit = blockEntity.heliostats * 6\n blockEntity.temperatureComponent.tick(blockEntity.temperatureComponent.temperature < limit + (world.random.nextFloat() * 2 - 1) * 10)\n blockEntity.markForUpdate()\n blockEntity.heliostats = 0\n }\n }\n }\n\n override fun fromTag(tag: NbtCompound) {\n temperatureComponent.readNbt(tag)\n fluidComponent.fromTag(tag)\n multiblockComponent.readNbt(tag)\n }\n\n override fun toTag(tag: NbtCompound) {\n temperatureComponent.writeNbt(tag)\n fluidComponent.toTag(tag)\n multiblockComponent.writeNbt(tag)\n }\n\n override fun fromClientTag(tag: NbtCompound) {\n multiblockComponent.readNbt(tag)\n }\n\n override fun toClientTag(tag: NbtCompound) {\n multiblockComponent.writeNbt(tag)\n }\n\n override fun markForUpdate(condition: () -> Boolean) {\n isMarkedForUpdate = isMarkedForUpdate || condition()\n }\n\n inner class SolarPowerPlantMultiblockComponent : MultiBlockComponent({ _, _, _ -> SolarPowerPlantTowerStructureDefinition }) {\n override fun tick(world: World, pos: BlockPos, blockState: BlockState) {\n super.tick(world, pos, blockState)\n SolarPowerPlantTowerStructureDefinition.getSolarReceiverPositions(pos, blockState).forEach { receiverPos ->\n val blockEntity = world.getBlockEntity(receiverPos) as? SolarReceiverBlockEntity ?: return@forEach\n blockEntity.controllerPos = pos\n }\n\n SolarPowerPlantTowerStructureDefinition.getFluidInputPositions(pos, blockState).forEach { inputPos ->\n\n }\n }\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/solarpowerplant/SolarReceiverBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.solarpowerplant\n\nimport me.steven.indrev.registry.IRBlockRegistry\nimport net.minecraft.block.BlockState\nimport net.minecraft.block.entity.BlockEntity\nimport net.minecraft.nbt.NbtCompound\nimport net.minecraft.util.math.BlockPos\n\nclass SolarReceiverBlockEntity(pos: BlockPos, state: BlockState) : BlockEntity(IRBlockRegistry.SOLAR_RECEIVER_BLOCK_ENTITY, pos, state) {\n var controllerPos: BlockPos = BlockPos.ORIGIN\n\n override fun writeNbt(tag: NbtCompound?) {\n tag?.putLong(\"controller\", controllerPos.asLong())\n return super.writeNbt(tag)\n }\n\n override fun readNbt(tag: NbtCompound) {\n super.readNbt(tag)\n controllerPos = BlockPos.fromLong(tag.getLong(\"controller\"))\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/storage/CabinetBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.storage\n\nimport me.steven.indrev.gui.screenhandlers.storage.CabinetScreenHandler\nimport me.steven.indrev.registry.IRBlockRegistry\nimport net.fabricmc.fabric.api.screenhandler.v1.ExtendedScreenHandlerFactory\nimport net.minecraft.block.BlockState\nimport net.minecraft.block.entity.LootableContainerBlockEntity\nimport net.minecraft.entity.player.PlayerInventory\nimport net.minecraft.inventory.Inventories\nimport net.minecraft.item.ItemStack\nimport net.minecraft.nbt.NbtCompound\nimport net.minecraft.network.PacketByteBuf\nimport net.minecraft.screen.ScreenHandler\nimport net.minecraft.screen.ScreenHandlerContext\nimport net.minecraft.server.network.ServerPlayerEntity\nimport net.minecraft.text.Text\nimport net.minecraft.text.TranslatableText\nimport net.minecraft.util.collection.DefaultedList\nimport net.minecraft.util.math.BlockPos\n\nclass CabinetBlockEntity(pos: BlockPos, state: BlockState) : LootableContainerBlockEntity(IRBlockRegistry.CABINET_BLOCK_ENTITY_TYPE, pos, state), ExtendedScreenHandlerFactory {\n\n private var inventory: DefaultedList = DefaultedList.ofSize(27, ItemStack.EMPTY)\n\n override fun size(): Int = 27\n\n override fun getContainerName(): Text = TranslatableText(\"block.indrev.cabinet\")\n\n override fun createScreenHandler(syncId: Int, playerInventory: PlayerInventory): ScreenHandler {\n return CabinetScreenHandler(syncId, playerInventory, ScreenHandlerContext.create(world, pos))\n }\n\n override fun getInvStackList(): DefaultedList = inventory\n\n override fun setInvStackList(list: DefaultedList) {\n inventory = list\n }\n\n override fun writeScreenOpeningData(player: ServerPlayerEntity?, buf: PacketByteBuf) {\n buf.writeBlockPos(pos)\n }\n\n override fun readNbt(tag: NbtCompound?) {\n super.readNbt(tag)\n inventory = DefaultedList.ofSize(size(), ItemStack.EMPTY)\n if (!deserializeLootTable(tag)) {\n Inventories.readNbt(tag, inventory)\n }\n }\n\n override fun writeNbt(tag: NbtCompound) {\n super.writeNbt(tag)\n if (!serializeLootTable(tag)) {\n Inventories.writeNbt(tag, inventory)\n }\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/storage/ChargePadBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.storage\n\nimport com.google.common.collect.Iterables\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.blockentities.MachineBlockEntity\nimport me.steven.indrev.config.BasicMachineConfig\nimport me.steven.indrev.inventories.inventory\nimport me.steven.indrev.registry.MachineRegistry\nimport me.steven.indrev.utils.asMutableList\nimport me.steven.indrev.utils.energyOf\nimport net.fabricmc.fabric.api.transfer.v1.transaction.TransactionContext\nimport net.minecraft.block.BlockState\nimport net.minecraft.entity.LivingEntity\nimport net.minecraft.entity.player.PlayerEntity\nimport net.minecraft.nbt.NbtCompound\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.math.Box\nimport team.reborn.energy.api.EnergyStorage\n\nclass ChargePadBlockEntity(tier: Tier, pos: BlockPos, state: BlockState) : MachineBlockEntity(tier, MachineRegistry.CHARGE_PAD_REGISTRY, pos, state) {\n\n init {\n this.inventoryComponent = inventory(this) {\n input { slot = 0 }\n output { slot = 0 }\n }\n }\n\n override val syncToWorld: Boolean = true\n\n override val maxOutput: Long = 16384\n override val maxInput: Long = 16384\n override val energyCapacity: Long = 0L\n\n val energyIo = ChargePadEnergyStorage()\n\n var hasCollided = false\n\n private fun getItemEnergyIo() = energyOf(inventoryComponent!!.inventory, 0)\n\n override fun fromClientTag(tag: NbtCompound) {\n inventoryComponent!!.readNbt(tag)\n }\n\n override fun toClientTag(tag: NbtCompound) {\n inventoryComponent!!.writeNbt(tag)\n }\n\n inner class ChargePadEnergyStorage : EnergyStorage {\n override fun getAmount(): Long = getItemEnergyIo()?.amount ?: 0\n\n override fun getCapacity(): Long = getItemEnergyIo()?.capacity ?: 0\n\n override fun insert(amount: Long, transaction: TransactionContext?): Long {\n val handlers = if (hasCollided) {\n val collidedEntityItems = collectItemIos()\n if (collidedEntityItems.isEmpty()) hasCollided = false\n getItemEnergyIo()?.also { collidedEntityItems.add(it) }\n collidedEntityItems\n } else\n getItemEnergyIo().let { if (it == null) emptyList() else listOf(it) }\n\n if (handlers.isEmpty()) return 0\n\n val max = amount.coerceAtMost(maxOutput)\n var remainder = max\n handlers.forEach { handler ->\n if (remainder > 0)\n remainder -= handler.insert(remainder, transaction)\n else return 0\n }\n return max - remainder\n }\n\n override fun extract(maxAmount: Long, transaction: TransactionContext?): Long = 0\n\n override fun supportsExtraction(): Boolean = false\n\n override fun supportsInsertion(): Boolean = true\n\n private fun collectItemIos(): MutableList {\n return world!!.getEntitiesByClass(LivingEntity::class.java, Box(pos)) { true }.flatMap { entity ->\n when (entity) {\n is PlayerEntity -> Iterables.concat(entity.inventory.armor.mapIndexed { index, _ -> energyOf(entity.inventory, 36 + index) },\n listOf(energyOf(entity.inventory, entity.inventory.selectedSlot), energyOf(entity.inventory, 40)))\n else -> emptyList()\n }\n }.filterNotNull().asMutableList()\n }\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/storage/ChargePadBlockEntityRenderer.kt",
"content": "package me.steven.indrev.blockentities.storage\n\nimport me.steven.indrev.blocks.machine.HorizontalFacingMachineBlock\nimport net.minecraft.client.MinecraftClient\nimport net.minecraft.client.render.VertexConsumerProvider\nimport net.minecraft.client.render.WorldRenderer\nimport net.minecraft.client.render.block.entity.BlockEntityRenderer\nimport net.minecraft.client.render.model.json.ModelTransformation\nimport net.minecraft.client.util.math.MatrixStack\nimport net.minecraft.util.math.Direction\nimport net.minecraft.util.math.Vec3f\nimport kotlin.math.abs\nimport kotlin.math.sin\n\nclass ChargePadBlockEntityRenderer : BlockEntityRenderer {\n override fun render(\n entity: ChargePadBlockEntity?,\n tickDelta: Float,\n matrices: MatrixStack?,\n vertexConsumers: VertexConsumerProvider?,\n light: Int,\n overlay: Int\n ) {\n val inventory = entity?.inventoryComponent?.inventory\n val stack = inventory?.getStack(0)\n if (stack?.isEmpty == false) {\n val facing = entity.cachedState[HorizontalFacingMachineBlock.HORIZONTAL_FACING].rotateYClockwise()\n var x = abs(facing.offsetX.toFloat()) * 0.5\n var z = abs(facing.offsetZ.toFloat()) * 0.5\n if (facing.offsetX == -1)\n z = x\n else if (facing.offsetZ == 1) x = z\n when (facing.axis) {\n Direction.Axis.X -> z += 0.2\n Direction.Axis.Z -> x += 0.2\n else -> return\n }\n matrices?.run {\n push()\n val time = entity.world?.time ?: 1\n val offset = sin((time + tickDelta) / 16.0) / 32.0\n translate(x, 1.1 + offset, z)\n multiply(Vec3f.POSITIVE_Y.getDegreesQuaternion((time + tickDelta) * 4))\n scale(0.5f, 0.5f, 0.5f)\n val lightAbove = WorldRenderer.getLightmapCoordinates(entity.world, entity.pos.up())\n MinecraftClient.getInstance().itemRenderer.renderItem(stack, ModelTransformation.Mode.GROUND, lightAbove, overlay, this, vertexConsumers, 0)\n pop()\n }\n }\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/storage/LazuliFluxContainerBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.storage\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.api.machines.TransferMode\nimport me.steven.indrev.api.sideconfigs.ConfigurationType\nimport me.steven.indrev.api.sideconfigs.SideConfiguration\nimport me.steven.indrev.blockentities.MachineBlockEntity\nimport me.steven.indrev.blocks.machine.FacingMachineBlock\nimport me.steven.indrev.config.LFCConfig\nimport me.steven.indrev.inventories.inventory\nimport me.steven.indrev.registry.MachineRegistry\nimport me.steven.indrev.utils.energyOf\nimport net.minecraft.block.BlockState\nimport net.minecraft.nbt.NbtCompound\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.math.Direction\nimport team.reborn.energy.api.EnergyStorageUtil\nimport kotlin.math.floor\n\nclass LazuliFluxContainerBlockEntity(tier: Tier, pos: BlockPos, state: BlockState) :\n MachineBlockEntity(tier, MachineRegistry.LAZULI_FLUX_CONTAINER_REGISTRY, pos, state) {\n\n init {\n this.inventoryComponent = inventory(this) {\n input { 0 filter { stack -> energyOf(stack) != null } }\n }\n }\n\n override val syncToWorld: Boolean = true\n\n override val maxInput: Long = config.maxInput\n override val maxOutput: Long = config.maxOutput\n\n val transferConfig: SideConfiguration = SideConfiguration(ConfigurationType.ENERGY)\n\n override val storage = LazuliFluxContainerEnergyStorage()\n\n private var clientLastRenderWidth = 0f\n\n override fun machineTick() {\n if (world?.isClient == true) return\n val inventory = inventoryComponent?.inventory ?: return\n val itemIo = energyOf(inventory, 0)\n if (itemIo != null)\n EnergyStorageUtil.move(storage.getSideStorage(null), itemIo, maxOutput, null)\n }\n\n private fun update() {\n val width = floor((((energy.toFloat() / energyCapacity.toFloat()) * 0.5f) + 0.25f) * 16)\n if (width != clientLastRenderWidth) {\n sync()\n clientLastRenderWidth = width\n }\n }\n\n override fun isConfigurable(type: ConfigurationType): Boolean {\n return type == ConfigurationType.ENERGY\n }\n\n override fun getCurrentConfiguration(type: ConfigurationType): SideConfiguration {\n return transferConfig\n }\n\n override fun applyDefault(state: BlockState, type: ConfigurationType, configuration: MutableMap) {\n val facing = state[FacingMachineBlock.FACING]\n Direction.values().forEach { dir ->\n if (dir == facing && tier != Tier.CREATIVE) configuration[dir] = TransferMode.INPUT\n else configuration[dir] = TransferMode.OUTPUT\n }\n }\n\n override fun toTag(tag: NbtCompound) {\n transferConfig.writeNbt(tag)\n super.toTag(tag)\n }\n\n override fun fromTag(tag: NbtCompound) {\n super.fromTag(tag)\n transferConfig.readNbt(tag)\n }\n\n override fun toClientTag(tag: NbtCompound) {\n tag.putLong(\"energy\", energy)\n transferConfig.writeNbt(tag)\n }\n\n override fun fromClientTag(tag: NbtCompound) {\n transferConfig.readNbt(tag)\n energy = tag.getLong(\"energy\")\n }\n\n inner class LazuliFluxContainerEnergyStorage : MachineEnergyStorage() {\n override fun getMaxInsert(side: Direction?): Long {\n return if (side == null || transferConfig.canInput(side)) maxInput\n else 0\n }\n\n override fun getMaxExtract(side: Direction?): Long {\n return if (side == null || transferConfig.canOutput(side)) maxOutput\n else 0\n }\n\n override fun onFinalCommit() {\n super.onFinalCommit()\n update()\n }\n }\n}\n"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/storage/LazuliFluxContainerBlockEntityRenderer.kt",
"content": "package me.steven.indrev.blockentities.storage\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.utils.identifier\nimport net.minecraft.client.MinecraftClient\nimport net.minecraft.client.render.OverlayTexture\nimport net.minecraft.client.render.RenderLayer\nimport net.minecraft.client.render.VertexConsumerProvider\nimport net.minecraft.client.render.block.entity.BlockEntityRenderer\nimport net.minecraft.client.texture.Sprite\nimport net.minecraft.client.util.math.MatrixStack\nimport net.minecraft.screen.PlayerScreenHandler\nimport net.minecraft.util.math.Direction\nimport net.minecraft.util.math.Vec3f\nimport kotlin.math.absoluteValue\nimport kotlin.math.floor\nimport kotlin.math.sin\n\nclass LazuliFluxContainerBlockEntityRenderer : BlockEntityRenderer {\n override fun render(\n entity: LazuliFluxContainerBlockEntity?,\n tickDelta: Float,\n matrices: MatrixStack?,\n vertexConsumers: VertexConsumerProvider?,\n light: Int,\n overlay: Int\n ) {\n entity ?: return\n val width = ((entity.energy.toFloat() / entity.energyCapacity.toFloat()) * 0.5f) + 0.25f\n val sprite = MinecraftClient.getInstance().getSpriteAtlas(PlayerScreenHandler.BLOCK_ATLAS_TEXTURE).apply(identifier(\"block/lazuli_flux_container_lf_level\"))\n val color: Long = (255 shl 24 or when (entity.tier) {\n Tier.MK1 -> 0xffbb19\n Tier.MK2 -> 0x5d3dff\n Tier.MK3 -> 0xfd47ff\n else -> 0xff4070\n }).toLong()\n val maxX = floor((width * 16)) / 16f\n val time = entity.world!!.time\n matrices?.run {\n val offset = 0.001\n push()\n translate(-0.0, 0.0, -offset)\n drawOverlay(this, 0.25f, 0f, maxX, 1f, color, sprite, vertexConsumers, Direction.NORTH, width, tickDelta, time)\n translate(0.0, 0.0, offset)\n\n translate(0.5, 0.5, 0.5)\n multiply(Vec3f.POSITIVE_Y.getDegreesQuaternion(90f))\n translate(-0.5, -0.5, -0.5)\n translate(0.0, 0.0, -offset)\n drawOverlay(this, 0.25f, 0f, maxX, 1f, color, sprite, vertexConsumers, Direction.EAST, width, tickDelta, time)\n translate(0.0, 0.0, offset)\n\n translate(0.5, 0.5, 0.5)\n multiply(Vec3f.POSITIVE_Y.getDegreesQuaternion(90f))\n translate(-0.5, -0.5, -0.5)\n translate(-0.0, 0.0, -offset)\n drawOverlay(this, 0.25f, 0f, maxX, 1f, color, sprite, vertexConsumers, Direction.SOUTH, width, tickDelta, time)\n translate(0.0, 0.0, offset)\n\n translate(0.5, 0.5, 0.5)\n multiply(Vec3f.POSITIVE_Y.getDegreesQuaternion(90f))\n translate(-0.5, -0.5, -0.5)\n translate(0.0, 0.0, -offset)\n drawOverlay(this, 0.25f, 0f, maxX, 1f, color, sprite, vertexConsumers, Direction.WEST, width, tickDelta, time)\n translate(0.0, 0.0, offset)\n pop()\n }\n }\n\n private fun drawOverlay(matrices: MatrixStack, x1: Float, y1: Float, x2: Float, y2: Float, color: Long, sprite: Sprite, vertexConsumers: VertexConsumerProvider?, direction: Direction, width: Float, tickDelta: Float, time: Long) {\n val matrix = matrices.peek().positionMatrix\n \n var xx1 = x1\n var xx2 = x2\n var yy1 = x1\n var yy2 = x2\n\n if (x1 < x2) {\n xx1 = x2\n xx2 = x1\n }\n\n if (y1 < y2) {\n yy1 = y2\n yy2 = y1\n }\n\n val a = (color shr 24 and 255) / 255.0f\n val r = (color shr 16 and 255) / 255.0f\n val g = (color shr 8 and 255) / 255.0f\n val b = (color and 255) / 255.0f\n\n val vec = direction.unitVector\n var maxU = sprite.getFrameU(4.0)\n var minU = sprite.getFrameU(floor(width.toDouble() * 16))\n\n val normal = matrices.peek().normalMatrix\n vertexConsumers?.getBuffer(RenderLayer.getEntityTranslucent(PlayerScreenHandler.BLOCK_ATLAS_TEXTURE))?.run {\n\n fun vertex(x: Float, y: Float, u: Float, v: Float, alpha: Float = a) {\n this@run.vertex(matrix, x, y, 0.0f).color(r, g, b, alpha).texture(u, v).overlay(OverlayTexture.DEFAULT_UV).light(EMISSIVE_LIGHT).normal(normal, vec.x, vec.y, vec.z).next()\n }\n\n vertex(xx1, yy1, minU, sprite.minV)\n vertex(xx1, yy2, minU, sprite.maxV)\n vertex(xx2, yy2, maxU, sprite.maxV)\n vertex(xx1, yy1, minU, sprite.minV)\n vertex(xx1, yy1, minU, sprite.minV)\n vertex(xx2, yy2, maxU, sprite.maxV)\n vertex(xx2, yy1, maxU, sprite.minV)\n vertex(xx1, yy1, minU, sprite.minV)\n\n if (width < 0.75 && width > 0.25) {\n xx2 = xx1\n xx1 = (floor(width * 16) + 1) / 16f\n val opacity = sin((time + tickDelta) / 8).absoluteValue\n maxU = minU\n minU = sprite.getFrameU(floor(width.toDouble() * 16) + 1)\n vertex(xx1, yy1, minU, sprite.minV, opacity)\n vertex(xx1, yy2, minU, sprite.maxV, opacity)\n vertex(xx2, yy2, maxU, sprite.maxV, opacity)\n vertex(xx1, yy1, minU, sprite.minV, opacity)\n vertex(xx1, yy1, minU, sprite.minV, opacity)\n vertex(xx2, yy2, maxU, sprite.maxV, opacity)\n vertex(xx2, yy1, maxU, sprite.minV, opacity)\n vertex(xx1, yy1, minU, sprite.minV, opacity)\n }\n }\n }\n\n companion object {\n private const val EMISSIVE_LIGHT = 15728880\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/storage/TankBlockEntity.kt",
"content": "package me.steven.indrev.blockentities.storage\n\nimport me.steven.indrev.IndustrialRevolution\nimport me.steven.indrev.blockentities.BaseBlockEntity\nimport me.steven.indrev.blockentities.Syncable\nimport me.steven.indrev.blocks.misc.TankBlock\nimport me.steven.indrev.components.FluidComponent\nimport me.steven.indrev.registry.IRBlockRegistry\nimport me.steven.indrev.utils.bucket\nimport net.fabricmc.fabric.api.transfer.v1.fluid.FluidVariant\nimport net.fabricmc.fabric.api.transfer.v1.storage.StorageUtil\nimport net.fabricmc.fabric.api.transfer.v1.storage.base.CombinedStorage\nimport net.fabricmc.fabric.api.transfer.v1.transaction.TransactionContext\nimport net.minecraft.block.BlockState\nimport net.minecraft.nbt.NbtCompound\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.world.World\n\nclass TankBlockEntity(pos: BlockPos, state: BlockState) : BaseBlockEntity(IRBlockRegistry.TANK_BLOCK_ENTITY, pos, state), Syncable {\n val fluidComponent = object : FluidComponent({ this }, bucket * 8) {\n init {\n this.unsided = true\n }\n }\n\n var isMarkedForUpdate: Boolean = true\n\n companion object {\n fun tick(world: World, pos: BlockPos, state: BlockState, blockEntity: TankBlockEntity) {\n if (world.isClient) return\n if (blockEntity.isMarkedForUpdate) {\n blockEntity.markDirty()\n blockEntity.sync()\n blockEntity.isMarkedForUpdate = false\n }\n if (!state[TankBlock.DOWN]) return\n val down = world.getBlockEntity(pos.down()) as? TankBlockEntity ?: return\n val volume = StorageUtil.move(blockEntity.fluidComponent, down.fluidComponent, { true }, Long.MAX_VALUE, null)\n if (volume > 0) {\n down.isMarkedForUpdate = true\n blockEntity.isMarkedForUpdate = true\n }\n }\n }\n\n override fun toTag(tag: NbtCompound) {\n fluidComponent.toTag(tag)\n }\n\n override fun fromTag(tag: NbtCompound) {\n fluidComponent.fromTag(tag)\n }\n\n override fun toClientTag(tag: NbtCompound) {\n fluidComponent.toTag(tag)\n }\n\n override fun fromClientTag(tag: NbtCompound) {\n fluidComponent.fromTag(tag)\n }\n\n override fun markDirty() {\n if (world != null) {\n world!!.markDirty(pos)\n }\n }\n\n override fun markForUpdate(condition: () -> Boolean) {\n isMarkedForUpdate = isMarkedForUpdate || condition()\n }\n\n class CombinedTankStorage : CombinedStorage(mutableListOf()) {\n\n var initialFluid = FluidVariant.blank()\n\n fun add(tank: TankBlockEntity): Boolean {\n val invFluid = tank.fluidComponent[0]\n if (initialFluid.isBlank && !invFluid.isEmpty) {\n initialFluid = invFluid.variant\n } else if (!invFluid.isEmpty && initialFluid != invFluid.variant) {\n IndustrialRevolution.LOGGER.debug(\"Found connected tanks with mismatching fluids @ ${tank.pos}\")\n return false\n }\n parts.add(tank.fluidComponent)\n return true\n }\n\n override fun insert(resource: FluidVariant?, maxAmount: Long, transaction: TransactionContext?): Long {\n if (!initialFluid.isBlank && resource != initialFluid) return 0\n return super.insert(resource, maxAmount, transaction)\n }\n\n override fun extract(resource: FluidVariant?, maxAmount: Long, transaction: TransactionContext?): Long {\n if (!initialFluid.isBlank && resource != initialFluid) return 0\n return super.extract(resource, maxAmount, transaction)\n }\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blockentities/storage/TankBlockEntityRenderer.kt",
"content": "package me.steven.indrev.blockentities.storage\n\nimport alexiil.mc.lib.attributes.fluid.render.FluidRenderFace\nimport me.steven.indrev.blocks.misc.TankBlock\nimport net.minecraft.client.render.VertexConsumerProvider\nimport net.minecraft.client.render.block.entity.BlockEntityRenderer\nimport net.minecraft.client.util.math.MatrixStack\n\nclass TankBlockEntityRenderer : BlockEntityRenderer {\n override fun render(\n entity: TankBlockEntity,\n tickDelta: Float,\n matrices: MatrixStack?,\n vertexConsumers: VertexConsumerProvider?,\n light: Int,\n overlay: Int\n ) {\n val fluidComponent = entity.fluidComponent\n val volume = fluidComponent[0]\n if (volume.isEmpty) return\n val fluid = volume.amount\n val maxFluid = fluidComponent.limit\n var percent = fluid.toFloat() / maxFluid.toFloat()\n val maxHeight = if (entity.cachedState[TankBlock.UP]) 16 else 14\n percent = (percent * maxHeight).toInt() / 16f\n val yHeight = percent.toDouble().coerceAtLeast(0.1)\n val faces = mutableListOf(\n FluidRenderFace.createFlatFaceZ(0.9, 0.0, 0.1, 0.1, yHeight, 0.1, 1.0, true, false),\n FluidRenderFace.createFlatFaceZ(0.1, 0.0, 0.9, 0.9, yHeight, 0.9, 1.0, true, false),\n FluidRenderFace.createFlatFaceX(0.1, 0.0, 0.1, 0.1, yHeight, 0.9, 1.0, false, false),\n FluidRenderFace.createFlatFaceX(0.9, 0.0, 0.9, 0.9, yHeight, 0.1, 1.0, false, false),\n )\n\n var renderFluidTop = true\n if (entity.cachedState[TankBlock.UP]) {\n val aboveTank = entity.world!!.getBlockEntity(entity.pos.up()) as? TankBlockEntity\n renderFluidTop = aboveTank?.fluidComponent?.get(0)?.variant != volume.variant\n }\n if (renderFluidTop) {\n faces.add(FluidRenderFace.createFlatFaceY(0.1, yHeight, 0.1, 0.9, yHeight, 0.9, 1.0, true, false))\n }\n\n for (face in faces) {\n face.light = light;\n }\n\n volume.render(faces, vertexConsumers, matrices);\n }\n}\n"
},
{
"path": "src/main/kotlin/me/steven/indrev/blocks/HeliostatBlock.kt",
"content": "package me.steven.indrev.blocks\n\nimport me.steven.indrev.blockentities.solarpowerplant.HeliostatBlockEntity\nimport net.minecraft.block.Block\nimport net.minecraft.block.BlockEntityProvider\nimport net.minecraft.block.BlockRenderType\nimport net.minecraft.block.BlockState\nimport net.minecraft.block.entity.BlockEntity\nimport net.minecraft.block.entity.BlockEntityTicker\nimport net.minecraft.block.entity.BlockEntityType\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.math.Direction\nimport net.minecraft.util.math.MathHelper\nimport net.minecraft.world.World\n\nclass HeliostatBlock(settings: Settings) : Block(settings), BlockEntityProvider {\n\n override fun getRenderType(state: BlockState?): BlockRenderType = BlockRenderType.ENTITYBLOCK_ANIMATED\n\n override fun createBlockEntity(pos: BlockPos, state: BlockState): BlockEntity = HeliostatBlockEntity(pos, state)\n\n override fun getTicker(\n world: World,\n state: BlockState?,\n type: BlockEntityType?\n ): BlockEntityTicker? {\n return if (world.isClient) null\n else return BlockEntityTicker { world, pos, state, blockEntity ->\n HeliostatBlockEntity.tick(world, pos, state, blockEntity as? HeliostatBlockEntity ?: return@BlockEntityTicker)\n }\n }\n\n companion object {\n private const val RAD2DEG = 57.2957763671875\n\n fun getYaw(origin: BlockPos, target: BlockPos): Float {\n val xOffset = target.x + 0.0 - origin.x.toDouble() + 0.0\n val zOffset = target.z + 0.0 - origin.z.toDouble() + 0.0\n return MathHelper.wrapDegrees((MathHelper.atan2(zOffset, xOffset) * RAD2DEG).toFloat() - 90.0f)\n }\n\n fun getPitch(origin: BlockPos, target: BlockPos): Float {\n val xOffset = target.x + 0.0f - origin.x.toFloat() + 0.0f\n val yOffset = target.y + 0.0f - origin.y.toFloat() + 0.0f\n val zOffset = target.z + 0.0f - origin.z.toFloat() + 0.0f\n val g = MathHelper.sqrt(xOffset * xOffset + zOffset * zOffset).toDouble()\n return MathHelper.wrapDegrees((-(MathHelper.atan2(yOffset.toDouble(), g) * RAD2DEG)).toFloat())\n }\n\n\n fun findConnectingHeliostats(origin: BlockPos, world: World, scanned: MutableSet, positions: MutableSet) {\n Direction.values().forEach { dir ->\n val off = origin.offset(dir)\n if (scanned.add(off.asLong()) && world.testBlockState(off) { state -> state.block is HeliostatBlock }) {\n positions.add(off.asLong())\n findConnectingHeliostats(off, world, scanned, positions)\n }\n }\n }\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blocks/machine/CapsuleBlock.kt",
"content": "package me.steven.indrev.blocks.machine\n\nimport me.steven.indrev.blockentities.laser.CapsuleBlockEntity\nimport me.steven.indrev.recipes.machines.LaserRecipe\nimport net.fabricmc.fabric.api.`object`.builder.v1.block.FabricBlockSettings\nimport net.minecraft.block.Block\nimport net.minecraft.block.BlockEntityProvider\nimport net.minecraft.block.BlockState\nimport net.minecraft.block.Material\nimport net.minecraft.block.entity.BlockEntity\nimport net.minecraft.block.entity.BlockEntityTicker\nimport net.minecraft.block.entity.BlockEntityType\nimport net.minecraft.entity.player.PlayerEntity\nimport net.minecraft.item.ItemStack\nimport net.minecraft.server.world.ServerWorld\nimport net.minecraft.util.ActionResult\nimport net.minecraft.util.Hand\nimport net.minecraft.util.ItemScatterer\nimport net.minecraft.util.hit.BlockHitResult\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.math.Direction\nimport net.minecraft.world.BlockView\nimport net.minecraft.world.World\n\nclass CapsuleBlock : Block(FabricBlockSettings.of(Material.GLASS).requiresTool().nonOpaque().strength(1f, 1f)), BlockEntityProvider {\n override fun onUse(\n state: BlockState?,\n world: World,\n pos: BlockPos?,\n player: PlayerEntity,\n hand: Hand?,\n hit: BlockHitResult?\n ): ActionResult {\n if (!world.isClient && hand == Hand.MAIN_HAND) {\n val stack = player.getStackInHand(hand)\n val recipe = LaserRecipe.TYPE.getMatchingRecipe(world as ServerWorld, stack)\n .firstOrNull { it.matches(stack, emptyList()) }\n val blockEntity = world.getBlockEntity(pos) as? CapsuleBlockEntity ?: return ActionResult.PASS\n if (recipe != null && blockEntity.inventory[0].isEmpty) {\n player.setStackInHand(hand, ItemStack.EMPTY)\n blockEntity.inventory[0] = stack\n } else if (!blockEntity.inventory[0].isEmpty) {\n val itemStack = blockEntity.inventory[0]\n itemStack.nbt = null\n player.inventory?.insertStack(itemStack)\n blockEntity.inventory[0] = ItemStack.EMPTY\n } else\n return ActionResult.PASS\n world.updateNeighbors(pos, this)\n blockEntity.markDirty()\n blockEntity.sync()\n return ActionResult.SUCCESS\n }\n return ActionResult.PASS\n }\n\n override fun onStateReplaced(\n state: BlockState?,\n world: World,\n pos: BlockPos,\n newState: BlockState?,\n moved: Boolean\n ) {\n val blockEntity = world.getBlockEntity(pos) as? CapsuleBlockEntity\n if (blockEntity != null)\n ItemScatterer.spawn(world, pos, blockEntity.inventory)\n super.onStateReplaced(state, world, pos, newState, moved)\n }\n\n override fun emitsRedstonePower(state: BlockState?): Boolean = true\n\n override fun getWeakRedstonePower(\n state: BlockState?,\n world: BlockView,\n pos: BlockPos,\n direction: Direction?\n ): Int {\n val blockEntity = world.getBlockEntity(pos) as? CapsuleBlockEntity ?: return 0\n if (blockEntity.world!!.isClient) return 0\n val stack = blockEntity.inventory[0]\n val recipe = LaserRecipe.TYPE.getMatchingRecipe(world as ServerWorld, stack)\n .firstOrNull { it.matches(stack, emptyList()) }\n return if (recipe == null) 15\n else 0\n }\n\n override fun createBlockEntity(pos: BlockPos, state: BlockState): BlockEntity = CapsuleBlockEntity(pos, state)\n\n override fun getTicker(\n world: World,\n state: BlockState?,\n type: BlockEntityType?\n ): BlockEntityTicker? {\n return if (world.isClient) null\n else BlockEntityTicker { world, pos, state, blockEntity ->\n CapsuleBlockEntity.tick(world, pos, state, blockEntity as CapsuleBlockEntity)\n }\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blocks/machine/ChargePadBlock.kt",
"content": "package me.steven.indrev.blocks.machine\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.blockentities.storage.ChargePadBlockEntity\nimport me.steven.indrev.registry.MachineRegistry\nimport me.steven.indrev.utils.energyOf\nimport net.fabricmc.api.EnvType\nimport net.fabricmc.api.Environment\nimport net.minecraft.block.BlockState\nimport net.minecraft.block.ShapeContext\nimport net.minecraft.client.item.TooltipContext\nimport net.minecraft.entity.Entity\nimport net.minecraft.entity.decoration.ArmorStandEntity\nimport net.minecraft.entity.player.PlayerEntity\nimport net.minecraft.item.ItemPlacementContext\nimport net.minecraft.item.ItemStack\nimport net.minecraft.text.Text\nimport net.minecraft.text.TranslatableText\nimport net.minecraft.util.ActionResult\nimport net.minecraft.util.Formatting\nimport net.minecraft.util.Hand\nimport net.minecraft.util.function.BooleanBiFunction\nimport net.minecraft.util.hit.BlockHitResult\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.math.Direction\nimport net.minecraft.util.shape.VoxelShape\nimport net.minecraft.util.shape.VoxelShapes\nimport net.minecraft.world.BlockView\nimport net.minecraft.world.World\nimport java.util.*\nimport java.util.stream.Stream\n\nclass ChargePadBlock(registry: MachineRegistry, settings: Settings, tier: Tier) :\n HorizontalFacingMachineBlock(registry, settings, tier, null, null) {\n\n override fun getOutlineShape(\n state: BlockState,\n world: BlockView?,\n pos: BlockPos?,\n context: ShapeContext?\n ): VoxelShape =\n when (state[HORIZONTAL_FACING]) {\n Direction.NORTH -> FACING_NORTH\n Direction.SOUTH -> FACING_SOUTH\n Direction.EAST -> FACING_EAST\n Direction.WEST -> FACING_WEST\n else -> FACING_NORTH\n }\n\n override fun onUse(state: BlockState?, world: World, pos: BlockPos?, player: PlayerEntity?, hand: Hand?, hit: BlockHitResult?): ActionResult {\n val blockEntity = world.getBlockEntity(pos) as? ChargePadBlockEntity ?: return ActionResult.PASS\n val inventory = blockEntity.inventoryComponent?.inventory ?: return ActionResult.PASS\n val machineStack = inventory.getStack(0)\n if (!machineStack.isEmpty) {\n player?.inventory?.insertStack(machineStack)\n return ActionResult.SUCCESS\n }\n val handStack = player?.mainHandStack\n if (energyOf(player?.inventory, player?.inventory?.selectedSlot?: return ActionResult.PASS) != null) {\n inventory.setStack(0, handStack)\n player.setStackInHand(Hand.MAIN_HAND, ItemStack.EMPTY)\n return ActionResult.SUCCESS\n }\n return ActionResult.PASS\n }\n\n override fun getPlacementState(ctx: ItemPlacementContext?): BlockState? {\n super.getPlacementState(ctx)\n return this.defaultState.with(HORIZONTAL_FACING, ctx?.playerFacing)\n }\n\n override fun onEntityCollision(state: BlockState?, world: World?, pos: BlockPos?, entity: Entity?) {\n if (entity is PlayerEntity || entity is ArmorStandEntity) {\n val blockEntity = world?.getBlockEntity(pos) as? ChargePadBlockEntity ?: return\n blockEntity.hasCollided = true\n }\n }\n\n override fun appendTooltip(stack: ItemStack?, view: BlockView?, tooltip: MutableList?, options: TooltipContext?) {\n super.appendTooltip(stack, view, tooltip, options)\n tooltip?.add(TranslatableText(\"block.indrev.charge_pad_mk4.tooltip\").formatted(Formatting.BLUE, Formatting.ITALIC))\n }\n\n @Environment(EnvType.CLIENT)\n override fun randomDisplayTick(state: BlockState?, world: World, pos: BlockPos, random: Random?) {\n }\n\n companion object {\n private val FACING_NORTH = Stream.of(\n createCuboidShape(1.0, 0.0, 1.0, 15.0, 0.1, 15.0),\n createCuboidShape(1.25, 0.0, 1.25, 14.75, 0.3, 14.75),\n createCuboidShape(7.0, 0.0, 2.0, 9.0, 15.0, 4.0),\n createCuboidShape(8.0, 15.0, 2.0, 9.0, 15.5, 3.0),\n createCuboidShape(7.0, 15.0, 2.0, 8.0, 15.5, 3.0),\n createCuboidShape(7.0, 15.0, 3.0, 8.0, 15.2, 4.0),\n createCuboidShape(8.0, 15.0, 3.0, 9.0, 15.2, 4.0)\n ).reduce { v1: VoxelShape?, v2: VoxelShape? -> VoxelShapes.combineAndSimplify(v1, v2, BooleanBiFunction.OR) }.orElse(null)\n private val FACING_SOUTH: VoxelShape = Stream.of(\n createCuboidShape(1.0, 0.0, 1.0, 15.0, 0.1, 15.0),\n createCuboidShape(1.25, 0.0, 1.25, 14.75, 0.3, 14.75),\n createCuboidShape(7.0, 0.0, 12.0, 9.0, 15.0, 14.0),\n createCuboidShape(7.0, 15.0, 13.0, 8.0, 15.5, 14.0),\n createCuboidShape(8.0, 15.0, 13.0, 9.0, 15.5, 14.0),\n createCuboidShape(8.0, 15.0, 12.0, 9.0, 15.2, 13.0),\n createCuboidShape(7.0, 15.0, 12.0, 8.0, 15.2, 13.0)\n ).reduce { v1: VoxelShape?, v2: VoxelShape? -> VoxelShapes.combineAndSimplify(v1, v2, BooleanBiFunction.OR) }.orElse(null)\n private val FACING_WEST = Stream.of(\n createCuboidShape(1.0, 0.0, 1.0, 15.0, 0.1, 15.0),\n createCuboidShape(1.25, 0.0, 1.25, 14.75, 0.3, 14.75),\n createCuboidShape(2.0, 0.0, 7.0, 4.0, 15.0, 9.0),\n createCuboidShape(2.0, 15.0, 7.0, 3.0, 15.5, 8.0),\n createCuboidShape(2.0, 15.0, 8.0, 3.0, 15.5, 9.0),\n createCuboidShape(3.0, 15.0, 8.0, 4.0, 15.2, 9.0),\n createCuboidShape(3.0, 15.0, 7.0, 4.0, 15.2, 8.0)\n ).reduce { v1: VoxelShape?, v2: VoxelShape? -> VoxelShapes.combineAndSimplify(v1, v2, BooleanBiFunction.OR) }.orElse(null)\n private val FACING_EAST = Stream.of(\n createCuboidShape(1.0, 0.0, 1.0, 15.0, 0.1, 15.0),\n createCuboidShape(1.25, 0.0, 1.25, 14.75, 0.3, 14.75),\n createCuboidShape(12.0, 0.0, 7.0, 14.0, 15.0, 9.0),\n createCuboidShape(13.0, 15.0, 8.0, 14.0, 15.5, 9.0),\n createCuboidShape(13.0, 15.0, 7.0, 14.0, 15.5, 8.0),\n createCuboidShape(12.0, 15.0, 7.0, 13.0, 15.2, 8.0),\n createCuboidShape(12.0, 15.0, 8.0, 13.0, 15.2, 9.0)\n ).reduce { v1: VoxelShape?, v2: VoxelShape? -> VoxelShapes.combineAndSimplify(v1, v2, BooleanBiFunction.OR) }.orElse(null)\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blocks/machine/DirtOxygenatorBlock.kt",
"content": "package me.steven.indrev.blocks.machine\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.config.IRConfig\nimport me.steven.indrev.registry.MachineRegistry\nimport net.fabricmc.fabric.api.`object`.builder.v1.block.FabricBlockSettings\nimport net.minecraft.block.BlockState\nimport net.minecraft.item.ItemPlacementContext\n\nclass DirtOxygenatorBlock(registry: MachineRegistry, settings: FabricBlockSettings)\n : FacingMachineBlock(registry, settings, Tier.MK1, IRConfig.machines.dirtOxygenator, null) {\n\n override fun getPlacementState(ctx: ItemPlacementContext?): BlockState? {\n return this.defaultState.with(FACING, ctx?.playerLookDirection)\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blocks/machine/DrillBlock.kt",
"content": "package me.steven.indrev.blocks.machine\n\nimport me.steven.indrev.blockentities.miningrig.DrillBlockEntity\nimport me.steven.indrev.registry.IRBlockRegistry\nimport net.minecraft.block.Block\nimport net.minecraft.block.BlockEntityProvider\nimport net.minecraft.block.BlockState\nimport net.minecraft.block.Blocks\nimport net.minecraft.block.entity.BlockEntity\nimport net.minecraft.block.entity.BlockEntityTicker\nimport net.minecraft.block.entity.BlockEntityType\nimport net.minecraft.entity.LivingEntity\nimport net.minecraft.entity.player.PlayerEntity\nimport net.minecraft.item.ItemPlacementContext\nimport net.minecraft.item.ItemStack\nimport net.minecraft.state.StateManager\nimport net.minecraft.state.property.BooleanProperty\nimport net.minecraft.util.ActionResult\nimport net.minecraft.util.Hand\nimport net.minecraft.util.ItemScatterer\nimport net.minecraft.util.StringIdentifiable\nimport net.minecraft.util.hit.BlockHitResult\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.math.Direction\nimport net.minecraft.world.BlockView\nimport net.minecraft.world.World\nimport net.minecraft.world.WorldAccess\nimport net.minecraft.world.WorldView\n\nopen class DrillBlock private constructor(settings: Settings, val part: DrillPart) : Block(settings) {\n\n init {\n this.defaultState = stateManager.defaultState.with(WORKING, false)\n }\n\n override fun getPlacementState(ctx: ItemPlacementContext): BlockState? {\n val middle = ctx.world.getBlockState(ctx.blockPos.up())\n val top = ctx.world.getBlockState(ctx.blockPos.up(2))\n return if (middle.canReplace(ctx) && top.canReplace(ctx)) defaultState else null\n }\n\n override fun onPlaced(\n world: World,\n pos: BlockPos,\n state: BlockState,\n placer: LivingEntity?,\n itemStack: ItemStack?\n ) {\n world.setBlockState(pos.up(2), DRILL_TOP.defaultState)\n world.setBlockState(pos.up(), DRILL_MIDDLE.defaultState)\n }\n\n override fun onUse(\n state: BlockState,\n world: World,\n pos: BlockPos,\n player: PlayerEntity?,\n hand: Hand?,\n hit: BlockHitResult?\n ): ActionResult {\n if (!world.isClient) {\n val blockEntity = world.getBlockEntity(part.getBlockEntityPos(pos)) as? DrillBlockEntity ?: return ActionResult.PASS\n player?.openHandledScreen(blockEntity)\n }\n return ActionResult.CONSUME\n }\n\n override fun getStateForNeighborUpdate(\n state: BlockState,\n direction: Direction?,\n newState: BlockState,\n world: WorldAccess,\n pos: BlockPos,\n posFrom: BlockPos?\n ): BlockState {\n return if (newState.block is DrillBlock) state.with(WORKING, newState[WORKING])\n else if (!part.test(world, pos)) Blocks.AIR.defaultState\n else state\n }\n\n override fun onBreak(world: World, pos: BlockPos, state: BlockState, player: PlayerEntity) {\n if (!world.isClient && player.isCreative && part != DrillPart.BOTTOM) {\n val bottom = part.getBlockEntityPos(pos)\n world.setBlockState(bottom, Blocks.AIR.defaultState)\n }\n super.onBreak(world, pos, state, player)\n }\n\n override fun getPickStack(world: BlockView, pos: BlockPos, state: BlockState): ItemStack = ItemStack(DRILL_BOTTOM)\n\n override fun appendProperties(builder: StateManager.Builder?) {\n builder?.add(WORKING)\n }\n\n enum class DrillPart(val str: String) : StringIdentifiable {\n TOP(\"top\") {\n override fun test(world: WorldView, pos: BlockPos): Boolean {\n return world.getBlockState(pos.down()).isOf(DRILL_MIDDLE)\n && world.getBlockState(pos.down(2)).isOf(DRILL_BOTTOM)\n }\n\n override fun getBlockEntityPos(pos: BlockPos): BlockPos = pos.down(2)\n },\n MIDDLE(\"middle\") {\n override fun test(world: WorldView, pos: BlockPos): Boolean {\n return world.getBlockState(pos.up()).isOf(DRILL_TOP)\n && world.getBlockState(pos.down()).isOf(DRILL_BOTTOM)\n }\n override fun getBlockEntityPos(pos: BlockPos): BlockPos = pos.down()\n },\n BOTTOM(\"bottom\") {\n override fun test(world: WorldView, pos: BlockPos): Boolean {\n return world.getBlockState(pos.up()).isOf(DRILL_MIDDLE)\n && world.getBlockState(pos.up(2)).isOf(DRILL_TOP)\n }\n\n override fun getBlockEntityPos(pos: BlockPos): BlockPos = pos\n };\n\n abstract fun test(world: WorldView, pos: BlockPos): Boolean\n\n abstract fun getBlockEntityPos(pos: BlockPos): BlockPos\n\n override fun asString(): String = str\n }\n\n class TopDrillBlock(settings: Settings) : DrillBlock(settings, DrillPart.TOP)\n\n class MiddleDrillBlock(settings: Settings) : DrillBlock(settings, DrillPart.MIDDLE)\n\n class BottomDrillBlock(settings: Settings) : DrillBlock(settings, DrillPart.BOTTOM), BlockEntityProvider {\n\n override fun createBlockEntity(pos: BlockPos, state: BlockState): BlockEntity = DrillBlockEntity(pos, state)\n\n override fun getTicker(\n world: World,\n state: BlockState?,\n type: BlockEntityType?\n ): BlockEntityTicker? {\n return if (world.isClient) null\n else BlockEntityTicker { world, pos, state, blockEntity -> DrillBlockEntity.tick(world, pos, state, blockEntity as DrillBlockEntity) }\n }\n\n override fun onStateReplaced(\n state: BlockState,\n world: World?,\n pos: BlockPos?,\n newState: BlockState,\n moved: Boolean\n ) {\n\n if (!newState.isOf(this)) {\n (world?.getBlockEntity(pos) as? DrillBlockEntity)?.let {\n ItemScatterer.spawn(world, pos, it)\n }\n }\n super.onStateReplaced(state, world, pos, newState, moved)\n }\n }\n\n companion object {\n private val DRILL_TOP by lazy { IRBlockRegistry.DRILL_TOP }\n private val DRILL_MIDDLE by lazy { IRBlockRegistry.DRILL_MIDDLE }\n private val DRILL_BOTTOM by lazy { IRBlockRegistry.DRILL_BOTTOM }\n val WORKING: BooleanProperty = BooleanProperty.of(\"working\")\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blocks/machine/DrillHeadModel.kt",
"content": "package me.steven.indrev.blocks.machine\n\nimport com.mojang.datafixers.util.Pair\nimport me.steven.indrev.utils.identifier\nimport net.minecraft.client.render.model.BakedModel\nimport net.minecraft.client.render.model.ModelBakeSettings\nimport net.minecraft.client.render.model.ModelLoader\nimport net.minecraft.client.render.model.UnbakedModel\nimport net.minecraft.client.texture.Sprite\nimport net.minecraft.client.util.SpriteIdentifier\nimport net.minecraft.screen.PlayerScreenHandler\nimport net.minecraft.util.Identifier\nimport java.util.function.Function\n\nclass DrillHeadModel(val variant: String) : UnbakedModel {\n\n private val spriteIdCollection = mutableListOf(\n SpriteIdentifier(PlayerScreenHandler.BLOCK_ATLAS_TEXTURE, identifier(\"item/${variant}_drill_head\"))\n )\n\n private val modelIdentifier = identifier(\"block/${variant}_drill_head\")\n private var bakedModel: BakedModel? = null\n\n override fun bake(\n loader: ModelLoader,\n textureGetter: Function,\n rotationContainer: ModelBakeSettings?,\n modelId: Identifier?\n ): BakedModel? {\n bakedModel = loader.getOrLoadModel(modelIdentifier).bake(loader, textureGetter, rotationContainer, modelId)\n return bakedModel\n }\n\n override fun getModelDependencies(): MutableCollection = mutableListOf()\n\n override fun getTextureDependencies(\n unbakedModelGetter: Function?,\n unresolvedTextureReferences: MutableSet>?\n ): MutableCollection {\n return spriteIdCollection\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blocks/machine/ElectrolyticSeparatorBlock.kt",
"content": "package me.steven.indrev.blocks.machine\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.config.IRConfig\nimport me.steven.indrev.gui.screenhandlers.machines.ElectrolyticSeparatorScreenHandler\nimport me.steven.indrev.registry.MachineRegistry\nimport net.fabricmc.fabric.api.`object`.builder.v1.block.FabricBlockSettings\n\nclass ElectrolyticSeparatorBlock(registry: MachineRegistry, settings: FabricBlockSettings, tier: Tier)\n : HorizontalFacingMachineBlock(registry, settings, tier,\n when (tier) {\n Tier.MK1 -> IRConfig.machines.electrolyticSeparatorMk1\n Tier.MK2 -> IRConfig.machines.electrolyticSeparatorMk2\n Tier.MK3 -> IRConfig.machines.electrolyticSeparatorMk3\n else -> IRConfig.machines.electrolyticSeparatorMk4\n },\n ::ElectrolyticSeparatorScreenHandler\n) {\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blocks/machine/FacingMachineBlock.kt",
"content": "package me.steven.indrev.blocks.machine\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.config.IConfig\nimport me.steven.indrev.registry.MachineRegistry\nimport net.minecraft.block.Block\nimport net.minecraft.block.BlockState\nimport net.minecraft.entity.player.PlayerInventory\nimport net.minecraft.item.ItemPlacementContext\nimport net.minecraft.screen.ScreenHandler\nimport net.minecraft.screen.ScreenHandlerContext\nimport net.minecraft.state.StateManager\nimport net.minecraft.state.property.DirectionProperty\nimport net.minecraft.state.property.Properties\nimport net.minecraft.util.BlockRotation\nimport net.minecraft.util.math.Direction\n\nopen class FacingMachineBlock(\n registry: MachineRegistry,\n settings: Settings,\n tier: Tier,\n config: IConfig?,\n screenHandler: ((Int, PlayerInventory, ScreenHandlerContext) -> ScreenHandler)?,\n) : MachineBlock(registry, settings, tier, config, screenHandler) {\n\n override fun getPlacementState(ctx: ItemPlacementContext?): BlockState? {\n super.getPlacementState(ctx)\n return this.defaultState.with(FACING, ctx?.playerLookDirection?.opposite)\n }\n\n override fun appendProperties(builder: StateManager.Builder?) {\n super.appendProperties(builder)\n builder?.add(FACING)\n }\n\n override fun rotate(state: BlockState, rotation: BlockRotation): BlockState {\n return state.with(FACING, HorizontalFacingMachineBlock.getRotated(state[FACING], rotation))\n }\n\n override fun getFacing(state: BlockState): Direction = state[FACING]\n\n companion object {\n val FACING: DirectionProperty = Properties.FACING\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blocks/machine/HorizontalFacingMachineBlock.kt",
"content": "package me.steven.indrev.blocks.machine\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.config.IConfig\nimport me.steven.indrev.registry.MachineRegistry\nimport net.minecraft.block.Block\nimport net.minecraft.block.BlockState\nimport net.minecraft.entity.player.PlayerInventory\nimport net.minecraft.item.ItemPlacementContext\nimport net.minecraft.screen.ScreenHandler\nimport net.minecraft.screen.ScreenHandlerContext\nimport net.minecraft.state.StateManager\nimport net.minecraft.state.property.DirectionProperty\nimport net.minecraft.state.property.Properties\nimport net.minecraft.util.BlockRotation\nimport net.minecraft.util.math.Direction\n\nopen class HorizontalFacingMachineBlock(\n registry: MachineRegistry,\n settings: Settings,\n tier: Tier,\n config: IConfig?,\n screenHandler: ((Int, PlayerInventory, ScreenHandlerContext) -> ScreenHandler)?\n) : MachineBlock(registry, settings, tier, config, screenHandler) {\n\n override fun getPlacementState(ctx: ItemPlacementContext?): BlockState? {\n super.getPlacementState(ctx)\n return this.defaultState.with(HORIZONTAL_FACING, ctx?.playerFacing?.opposite)\n }\n\n override fun appendProperties(builder: StateManager.Builder?) {\n super.appendProperties(builder)\n builder?.add(HORIZONTAL_FACING)\n }\n\n override fun rotate(state: BlockState, rotation: BlockRotation): BlockState {\n return state.with(HORIZONTAL_FACING, getRotated(state[HORIZONTAL_FACING], rotation))\n }\n\n override fun getFacing(state: BlockState): Direction = state[HORIZONTAL_FACING]\n\n companion object {\n val HORIZONTAL_FACING: DirectionProperty = Properties.HORIZONTAL_FACING\n\n fun getRotated(direction: Direction, rotation: BlockRotation): Direction =\n if (direction.axis.isVertical) direction else when (rotation) {\n BlockRotation.NONE -> direction\n BlockRotation.CLOCKWISE_90 -> direction.rotateYClockwise()\n BlockRotation.CLOCKWISE_180 -> direction.opposite\n BlockRotation.COUNTERCLOCKWISE_90 -> direction.rotateYCounterclockwise()\n }\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blocks/machine/LaserBlock.kt",
"content": "package me.steven.indrev.blocks.machine\n\nimport me.steven.indrev.IndustrialRevolution\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.config.IRConfig\nimport me.steven.indrev.gui.screenhandlers.machines.LaserEmitterScreenHandler\nimport me.steven.indrev.registry.MachineRegistry\nimport me.steven.indrev.utils.component1\nimport me.steven.indrev.utils.component2\nimport me.steven.indrev.utils.component3\nimport net.minecraft.block.Block\nimport net.minecraft.block.BlockState\nimport net.minecraft.entity.damage.DamageSource\nimport net.minecraft.item.ItemPlacementContext\nimport net.minecraft.sound.SoundCategory\nimport net.minecraft.state.StateManager\nimport net.minecraft.state.property.BooleanProperty\nimport net.minecraft.state.property.Properties\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.world.World\nimport java.util.*\n\nclass LaserBlock(registry: MachineRegistry, settings: Settings) : FacingMachineBlock(\n registry, settings, Tier.MK4, IRConfig.machines.laser, ::LaserEmitterScreenHandler\n) {\n\n override fun getPlacementState(ctx: ItemPlacementContext?): BlockState? {\n return super.getPlacementState(ctx)?.with(POWERED, false)\n }\n\n override fun appendProperties(builder: StateManager.Builder?) {\n super.appendProperties(builder)\n builder?.add(POWERED)\n }\n\n @Suppress(\"DEPRECATION\")\n override fun neighborUpdate(\n state: BlockState?,\n world: World?,\n pos: BlockPos?,\n block: Block?,\n fromPos: BlockPos?,\n notify: Boolean\n ) {\n super.neighborUpdate(state, world, pos, block, fromPos, notify)\n\n world?.setBlockState(pos, state?.with(POWERED, world.isReceivingRedstonePower(pos)))\n }\n\n override fun randomDisplayTick(state: BlockState?, world: World, pos: BlockPos, random: Random?) {\n if (state!![POWERED] && random!!.nextDouble() > 0.9) {\n val (x, y, z) = pos\n world.playSound(x.toDouble() + 0.5, y.toDouble(), z.toDouble() + 0.5,\n IndustrialRevolution.LASER_SOUND_EVENT, SoundCategory.BLOCKS, 0.4f, 1f, false\n )\n }\n }\n\n\n companion object {\n val POWERED: BooleanProperty = Properties.POWERED\n val LASER_DAMAGE_SOURCE = object : DamageSource(\"laser\") {\n init {\n setFire()\n setBypassesArmor()\n }\n }\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blocks/machine/LazuliFluxContainerBlock.kt",
"content": "package me.steven.indrev.blocks.machine\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.api.sideconfigs.ConfigurationType\nimport me.steven.indrev.blockentities.storage.LazuliFluxContainerBlockEntity\nimport me.steven.indrev.config.IRConfig\nimport me.steven.indrev.gui.screenhandlers.machines.LazuliFluxContainerScreenHandler\nimport me.steven.indrev.registry.MachineRegistry\nimport net.minecraft.block.BlockState\nimport net.minecraft.entity.LivingEntity\nimport net.minecraft.item.ItemStack\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.world.World\n\nclass LazuliFluxContainerBlock(registry: MachineRegistry, settings: Settings, tier: Tier) : FacingMachineBlock(\n registry, settings, tier, when (tier) {\n Tier.MK1 -> IRConfig.machines.lazuliFluxContainerMk1\n Tier.MK2 -> IRConfig.machines.lazuliFluxContainerMk2\n Tier.MK3 -> IRConfig.machines.lazuliFluxContainerMk3\n else -> IRConfig.machines.lazuliFluxContainerMk4\n }, ::LazuliFluxContainerScreenHandler\n) {\n\n override fun onPlaced(\n world: World?,\n pos: BlockPos,\n state: BlockState,\n placer: LivingEntity?,\n itemStack: ItemStack?\n ) {\n super.onPlaced(world, pos, state, placer, itemStack)\n if (world?.isClient == true) {\n val blockEntity = world.getBlockEntity(pos) as? LazuliFluxContainerBlockEntity ?: return\n ConfigurationType.values().forEach { type ->\n if (blockEntity.isConfigurable(type))\n blockEntity.applyDefault(state, type, blockEntity.getCurrentConfiguration(type))\n }\n }\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blocks/machine/MachineBlock.kt",
"content": "package me.steven.indrev.blocks.machine\n\nimport me.steven.indrev.IndustrialRevolution\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.api.machines.TransferMode\nimport me.steven.indrev.api.sideconfigs.ConfigurationType\nimport me.steven.indrev.api.sideconfigs.SideConfiguration\nimport me.steven.indrev.blockentities.MachineBlockEntity\nimport me.steven.indrev.blockentities.storage.LazuliFluxContainerBlockEntity\nimport me.steven.indrev.config.IConfig\nimport me.steven.indrev.gui.IRScreenHandlerFactory\nimport me.steven.indrev.items.misc.IRMachineUpgradeItem\nimport me.steven.indrev.registry.MachineRegistry\nimport me.steven.indrev.utils.energyOf\nimport me.steven.indrev.utils.screwdriver\nimport me.steven.indrev.utils.wrench\nimport net.fabricmc.api.EnvType\nimport net.fabricmc.api.Environment\nimport net.fabricmc.fabric.api.transfer.v1.context.ContainerItemContext\nimport net.fabricmc.fabric.api.transfer.v1.fluid.FluidStorage\nimport net.fabricmc.fabric.api.transfer.v1.storage.StorageUtil\nimport net.minecraft.block.Block\nimport net.minecraft.block.BlockEntityProvider\nimport net.minecraft.block.BlockState\nimport net.minecraft.block.InventoryProvider\nimport net.minecraft.block.entity.BlockEntity\nimport net.minecraft.block.entity.BlockEntityTicker\nimport net.minecraft.block.entity.BlockEntityType\nimport net.minecraft.entity.LivingEntity\nimport net.minecraft.entity.player.PlayerEntity\nimport net.minecraft.entity.player.PlayerInventory\nimport net.minecraft.inventory.SidedInventory\nimport net.minecraft.item.BlockItem\nimport net.minecraft.item.ItemStack\nimport net.minecraft.particle.ParticleTypes\nimport net.minecraft.screen.ScreenHandler\nimport net.minecraft.screen.ScreenHandlerContext\nimport net.minecraft.server.world.ServerWorld\nimport net.minecraft.stat.Stats\nimport net.minecraft.text.TranslatableText\nimport net.minecraft.util.ActionResult\nimport net.minecraft.util.BlockRotation\nimport net.minecraft.util.Hand\nimport net.minecraft.util.ItemScatterer\nimport net.minecraft.util.hit.BlockHitResult\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.math.Direction\nimport net.minecraft.world.World\nimport net.minecraft.world.WorldAccess\nimport java.util.*\n\nopen class MachineBlock(\n val registry: MachineRegistry,\n settings: Settings,\n val tier: Tier,\n val config: IConfig?,\n private val screenHandler: ((Int, PlayerInventory, ScreenHandlerContext) -> ScreenHandler)?,\n) : Block(settings), BlockEntityProvider, InventoryProvider{\n\n override fun createBlockEntity(pos: BlockPos, state: BlockState): BlockEntity? = registry.blockEntityType(tier).instantiate(pos, state)\n\n override fun getTicker(\n world: World,\n state: BlockState?,\n type: BlockEntityType?\n ): BlockEntityTicker? {\n return if (world.isClient)\n BlockEntityTicker { _, _, _, blockEntity -> (blockEntity as? MachineBlockEntity<*>)?.machineClientTick() }\n else\n BlockEntityTicker { _, _, _, blockEntity -> (blockEntity as? MachineBlockEntity<*>)?.tick() }\n }\n\n override fun onUse(\n state: BlockState?,\n world: World,\n pos: BlockPos?,\n player: PlayerEntity?,\n hand: Hand?,\n hit: BlockHitResult?\n ): ActionResult? {\n if (world.isClient) return ActionResult.CONSUME\n val blockEntity = world.getBlockEntity(pos) as? MachineBlockEntity<*> ?: return ActionResult.FAIL\n if (blockEntity.fluidComponent != null) {\n val result = StorageUtil.move(ContainerItemContext.ofPlayerHand(player, hand).find(FluidStorage.ITEM), blockEntity.fluidComponent, { true }, Long.MAX_VALUE, null)\n if (result > 0) return ActionResult.SUCCESS\n }\n val stack = player?.mainHandStack!!\n val item = stack.item\n if (item is IRMachineUpgradeItem) {\n return ActionResult.PASS\n } else if (stack.isIn(IndustrialRevolution.WRENCH_TAG)) {\n return wrench(world, pos!!, state!!, blockEntity, player, stack)\n } else if (stack.isIn(IndustrialRevolution.SCREWDRIVER_TAG)) {\n return screwdriver(world, pos!!, state!!, blockEntity, player, stack)\n } else if (blockEntity.multiblockComponent != null\n && !blockEntity.multiblockComponent!!.isBuilt(world, pos!!, blockEntity.cachedState, true)) {\n player.sendMessage(TranslatableText(\"text.multiblock.not_built\"), true)\n blockEntity.multiblockComponent?.toggleRender(player.isSneaking)\n blockEntity.markDirty()\n blockEntity.sync()\n } else if (screenHandler != null) {\n player.openHandledScreen(IRScreenHandlerFactory(screenHandler, pos!!))\n } else return ActionResult.PASS\n return ActionResult.SUCCESS\n }\n\n @Suppress(\"DEPRECATION\")\n override fun onStateReplaced(state: BlockState, world: World, pos: BlockPos, newState: BlockState, moved: Boolean) {\n val oldBlockEntity = world.getBlockEntity(pos) as? MachineBlockEntity<*>\n super.onStateReplaced(state, world, pos, newState, moved)\n if (world.isClient) return\n\n if (newState.isOf(this)) {\n val oldFacing = getFacing(state)\n val newFacing = getFacing(newState)\n if (oldFacing == newFacing) return\n\n val blockEntity = world.getBlockEntity(pos) as? MachineBlockEntity<*> ?: return\n val rotation = offset(oldFacing, newFacing)\n blockEntity.inventoryComponent?.run {\n update(EnumMap(itemConfig).clone(), itemConfig, rotation)\n }\n blockEntity.fluidComponent?.run {\n update(EnumMap(transferConfig).clone(), transferConfig, rotation)\n }\n if (blockEntity is LazuliFluxContainerBlockEntity) {\n update(EnumMap(blockEntity.transferConfig).clone(), blockEntity.transferConfig, rotation)\n }\n blockEntity.markDirty()\n } else if (oldBlockEntity?.inventoryComponent != null) {\n ItemScatterer.spawn(world, pos, oldBlockEntity.inventoryComponent!!.inventory)\n world.updateComparators(pos, this)\n }\n }\n\n private fun update(original: EnumMap, config: SideConfiguration, rotation: BlockRotation) {\n Direction.values().forEach { side ->\n config[side] = original[rotation.rotate(side)]!!\n }\n }\n\n private fun offset(old: Direction, new: Direction): BlockRotation {\n return when (old) {\n new.rotateYClockwise() -> BlockRotation.CLOCKWISE_90\n new.rotateYCounterclockwise() -> BlockRotation.COUNTERCLOCKWISE_90\n new.opposite -> BlockRotation.CLOCKWISE_180\n else -> BlockRotation.NONE\n }\n }\n\n override fun afterBreak(world: World?, player: PlayerEntity?, pos: BlockPos?, state: BlockState?, blockEntity: BlockEntity?, toolStack: ItemStack?) {\n player?.incrementStat(Stats.MINED.getOrCreateStat(this))\n player?.addExhaustion(0.005f)\n writeNbtComponents(world, player, pos, state, blockEntity, toolStack)\n }\n\n fun writeNbtComponents(world: World?, player: PlayerEntity?, pos: BlockPos?, state: BlockState?, blockEntity: BlockEntity?, toolStack: ItemStack?) {\n if (world is ServerWorld) {\n getDroppedStacks(state, world, pos, blockEntity, player, toolStack).forEach { stack ->\n val item = stack.item\n if (blockEntity is MachineBlockEntity<*> && item is BlockItem && item.block is MachineBlock) {\n val itemIo = energyOf(stack)\n if (itemIo != null) {\n stack.orCreateNbt.putLong(\"energy\", blockEntity.energy)\n }\n val tag = stack.getOrCreateSubNbt(\"MachineInfo\")\n val temperatureController = blockEntity.temperatureComponent\n if (temperatureController != null)\n tag.putDouble(\"Temperature\", temperatureController.temperature)\n }\n dropStack(world, pos, stack)\n }\n state!!.onStacksDropped(world, pos, toolStack)\n }\n }\n\n override fun onPlaced(world: World?, pos: BlockPos, state: BlockState, placer: LivingEntity?, itemStack: ItemStack?) {\n super.onPlaced(world, pos, state, placer, itemStack)\n if (world?.isClient == true) return\n val blockEntity = world?.getBlockEntity(pos)\n if (blockEntity is MachineBlockEntity<*>) {\n val tag = itemStack?.getSubNbt(\"MachineInfo\")\n val temperatureController = blockEntity.temperatureComponent\n val itemIo = energyOf(itemStack)\n if (itemIo != null) {\n blockEntity.energy = itemIo.amount\n }\n if (temperatureController != null) {\n val temperature = tag?.getDouble(\"Temperature\")\n if (temperature != null) temperatureController.temperature = temperature\n }\n ConfigurationType.values().forEach { type ->\n if (blockEntity.isConfigurable(type))\n blockEntity.applyDefault(state, type, blockEntity.getCurrentConfiguration(type))\n }\n world.updateNeighbors(pos, this)\n blockEntity.markDirty()\n }\n }\n\n override fun neighborUpdate(\n state: BlockState?,\n world: World?,\n pos: BlockPos?,\n block: Block?,\n fromPos: BlockPos?,\n notify: Boolean\n ) {\n val blockEntity = world?.getBlockEntity(pos) as? MachineBlockEntity<*> ?: return\n\n blockEntity.validConnections.clear()\n blockEntity.validConnections.addAll(Direction.values())\n }\n\n open fun getFacing(state: BlockState): Direction = Direction.UP\n\n override fun getInventory(state: BlockState?, world: WorldAccess?, pos: BlockPos?): SidedInventory? {\n val blockEntity = world?.getBlockEntity(pos) as? InventoryProvider ?: return null\n return blockEntity.getInventory(state, world, pos)\n }\n\n @Environment(EnvType.CLIENT)\n override fun randomDisplayTick(state: BlockState?, world: World, pos: BlockPos, random: Random?) {\n val blockEntity = world.getBlockEntity(pos) as? MachineBlockEntity<*> ?: return\n if (blockEntity.workingState) {\n val d = pos.x.toDouble() + 0.5\n val e = pos.y.toDouble() + 1.0\n val f = pos.z.toDouble() + 0.5\n world.addParticle(ParticleTypes.SMOKE, d, e, f, 0.0, 0.0, 0.0)\n }\n }\n}\n"
},
{
"path": "src/main/kotlin/me/steven/indrev/blocks/machine/MiningRigBlock.kt",
"content": "package me.steven.indrev.blocks.machine\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.blockentities.miningrig.MiningRigBlockEntity\nimport me.steven.indrev.config.IRConfig\nimport me.steven.indrev.gui.screenhandlers.machines.MiningRigComputerScreenHandler\nimport me.steven.indrev.registry.MachineRegistry\nimport me.steven.indrev.utils.itemStorageOf\nimport net.minecraft.block.Block\nimport net.minecraft.block.BlockState\nimport net.minecraft.client.item.TooltipContext\nimport net.minecraft.entity.LivingEntity\nimport net.minecraft.item.ItemStack\nimport net.minecraft.server.world.ServerWorld\nimport net.minecraft.text.Text\nimport net.minecraft.text.TranslatableText\nimport net.minecraft.util.Formatting\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.math.Direction\nimport net.minecraft.world.BlockView\nimport net.minecraft.world.World\n\nclass MiningRigBlock(registry: MachineRegistry, settings: Settings, tier: Tier) : HorizontalFacingMachineBlock(\n registry,\n settings,\n tier,\n IRConfig.machines.miner,\n ::MiningRigComputerScreenHandler,\n) {\n override fun appendTooltip(\n stack: ItemStack?,\n view: BlockView?,\n tooltip: MutableList?,\n options: TooltipContext?\n ) {\n super.appendTooltip(stack, view, tooltip, options)\n tooltip?.add(\n TranslatableText(\"block.indrev.mining_rig.tooltip\").formatted(Formatting.BLUE, Formatting.ITALIC)\n )\n }\n\n override fun neighborUpdate(\n state: BlockState?,\n world: World?,\n pos: BlockPos?,\n block: Block?,\n fromPos: BlockPos?,\n notify: Boolean\n ) {\n super.neighborUpdate(state, world, pos, block, fromPos, notify)\n\n if (world is ServerWorld) {\n val dir = Direction.fromVector(fromPos!!.subtract(pos)) ?: return\n if (itemStorageOf(world, fromPos, dir) != null) {\n val blockEntity = world.getBlockEntity(pos) as? MiningRigBlockEntity ?: return\n blockEntity.storageDirections.addAll(Direction.values())\n }\n }\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blocks/machine/PumpBlock.kt",
"content": "package me.steven.indrev.blocks.machine\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.config.IRConfig\nimport me.steven.indrev.gui.screenhandlers.machines.PumpScreenHandler\nimport me.steven.indrev.registry.MachineRegistry\nimport net.minecraft.block.BlockState\nimport net.minecraft.block.ShapeContext\nimport net.minecraft.item.ItemPlacementContext\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.math.Direction\nimport net.minecraft.util.shape.VoxelShape\nimport net.minecraft.util.shape.VoxelShapes\nimport net.minecraft.world.BlockView\n\nclass PumpBlock(registry: MachineRegistry, settings: Settings) : HorizontalFacingMachineBlock(\n registry,\n settings,\n Tier.MK1,\n IRConfig.machines.pump,\n ::PumpScreenHandler) {\n\n override fun getOutlineShape(\n state: BlockState?,\n world: BlockView?,\n pos: BlockPos?,\n context: ShapeContext?\n ): VoxelShape = when (state?.get(HORIZONTAL_FACING)) {\n Direction.NORTH -> SHAPE_NORTH\n Direction.SOUTH -> SHAPE_SOUTH\n Direction.WEST -> SHAPE_WEST\n Direction.EAST -> SHAPE_EAST\n else -> VoxelShapes.fullCube()\n }\n\n override fun getPlacementState(ctx: ItemPlacementContext?): BlockState? {\n return this.defaultState.with(HORIZONTAL_FACING, ctx?.playerFacing)\n }\n\n companion object {\n private val SHAPE_NORTH = createCuboidShape(2.5, 0.0, 0.0, 14.5, 16.0, 14.5)\n private val SHAPE_SOUTH = createCuboidShape(2.5, 0.0, 2.5, 14.5, 16.0, 16.0)\n private val SHAPE_WEST = createCuboidShape(0.0, 0.0, 2.5, 14.5, 16.0, 14.5)\n private val SHAPE_EAST = createCuboidShape(2.5, 0.0, 2.5, 16.0, 16.0, 14.5)\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blocks/machine/pipes/BasePipeBlock.kt",
"content": "package me.steven.indrev.blocks.machine.pipes\n\nimport me.steven.indrev.IndustrialRevolution\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.blockentities.cables.BasePipeBlockEntity\nimport me.steven.indrev.items.misc.IRServoItem\nimport me.steven.indrev.networks.EndpointData\nimport me.steven.indrev.networks.Network\nimport me.steven.indrev.networks.ServoNetworkState\nimport me.steven.indrev.registry.IRItemRegistry\nimport me.steven.indrev.utils.component1\nimport me.steven.indrev.utils.component2\nimport me.steven.indrev.utils.component3\nimport me.steven.indrev.utils.toVec3d\nimport net.minecraft.block.Block\nimport net.minecraft.block.BlockEntityProvider\nimport net.minecraft.block.BlockState\nimport net.minecraft.block.ShapeContext\nimport net.minecraft.block.entity.BlockEntity\nimport net.minecraft.entity.LivingEntity\nimport net.minecraft.entity.player.PlayerEntity\nimport net.minecraft.item.BlockItem\nimport net.minecraft.item.ItemPlacementContext\nimport net.minecraft.item.ItemStack\nimport net.minecraft.server.world.ServerWorld\nimport net.minecraft.util.ActionResult\nimport net.minecraft.util.Hand\nimport net.minecraft.util.ItemScatterer\nimport net.minecraft.util.collection.DefaultedList\nimport net.minecraft.util.hit.BlockHitResult\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.math.Direction\nimport net.minecraft.util.math.Vec3d\nimport net.minecraft.util.shape.VoxelShape\nimport net.minecraft.util.shape.VoxelShapes\nimport net.minecraft.world.BlockView\nimport net.minecraft.world.World\n\nabstract class BasePipeBlock(settings: Settings, val tier: Tier, val type: Network.Type<*>) : Block(settings), BlockEntityProvider {\n\n init {\n this.defaultState = stateManager.defaultState\n }\n\n abstract fun getShape(blockEntity: BasePipeBlockEntity): VoxelShape\n\n override fun createBlockEntity(pos: BlockPos, state: BlockState): BlockEntity? = BasePipeBlockEntity(type, tier, pos, state)\n\n override fun getOutlineShape(\n state: BlockState,\n view: BlockView,\n pos: BlockPos?,\n context: ShapeContext?\n ): VoxelShape {\n val blockEntity = view.getBlockEntity(pos) as? BasePipeBlockEntity ?: return VoxelShapes.empty()\n return if (blockEntity.coverState != null) VoxelShapes.fullCube()\n else getShape(blockEntity)\n }\n\n override fun hasDynamicBounds(): Boolean = true\n\n override fun onBlockBreakStart(state: BlockState, world: World, pos: BlockPos, player: PlayerEntity) {\n if (!world.isClient) {\n val blockEntity = world.getBlockEntity(pos) as? BasePipeBlockEntity ?: return\n if (blockEntity.coverState != null && player.mainHandStack.isOf(IRItemRegistry.WRENCH)) {\n val cover = blockEntity.coverState ?: return\n ItemScatterer.spawn(world, pos, DefaultedList.ofSize(1, ItemStack(cover.block)))\n blockEntity.coverState = null\n blockEntity.markDirty()\n blockEntity.sync()\n }\n }\n }\n\n override fun onUse(state: BlockState, world: World, pos: BlockPos, player: PlayerEntity, hand: Hand, hit: BlockHitResult): ActionResult {\n val handStack = player.getStackInHand(hand) ?: return ActionResult.FAIL\n val blockEntity = world.getBlockEntity(pos) as? BasePipeBlockEntity ?: return ActionResult.FAIL\n\n val tryWrench = onWrench(state, world, pos, player, hand, hit)\n if (tryWrench.isAccepted) return tryWrench\n else if (handStack.item is IRServoItem) return ActionResult.PASS\n val item = handStack.item\n if (\n blockEntity.coverState == null\n && !player.isSneaking\n && isValidCover(handStack, world, pos)\n ) {\n val result = (item as BlockItem).block.getPlacementState(ItemPlacementContext(player, hand, handStack, hit))\n blockEntity.coverState = result\n if (!world.isClient) {\n blockEntity.markDirty()\n blockEntity.sync()\n }\n if (!player.abilities.creativeMode)\n handStack.decrement(1)\n return ActionResult.success(world.isClient)\n }\n return ActionResult.PASS\n }\n\n private fun isValidCover(stack: ItemStack, world: World, pos: BlockPos): Boolean {\n val item = stack.item\n return !stack.isEmpty\n && item is BlockItem\n && item.block !is BlockEntityProvider\n && item.block.defaultState.isFullCube(world, pos)\n }\n\n private fun onWrench(state: BlockState,world: World, pos: BlockPos,player: PlayerEntity, hand: Hand, hit: BlockHitResult): ActionResult {\n val handStack = player.getStackInHand(hand) ?: return ActionResult.FAIL\n val blockEntity = world.getBlockEntity(pos) as? BasePipeBlockEntity ?: return ActionResult.FAIL\n if (handStack.isIn(IndustrialRevolution.WRENCH_TAG) && world is ServerWorld) {\n val dir = getSideFromHit(hit.pos, pos)\n val (x, y, z) = hit.pos\n val networkState = type.getNetworkState(world)\n if (networkState is ServoNetworkState<*>) {\n if (dir != null) {\n val data = networkState.removeEndpointData(pos, dir)\n when (data?.type) {\n EndpointData.Type.OUTPUT -> {\n ItemScatterer.spawn(world, x, y, z, ItemStack(IRItemRegistry.SERVO_OUTPUT))\n return ActionResult.SUCCESS\n }\n EndpointData.Type.RETRIEVER -> {\n ItemScatterer.spawn(world, x, y, z, ItemStack(IRItemRegistry.SERVO_RETRIEVER))\n return ActionResult.SUCCESS\n }\n else -> { }\n }\n }\n }\n\n if (blockEntity.connections[dir]!!.isConnected())\n blockEntity.connections[dir] = ConnectionType.WRENCHED\n else\n blockEntity.connections[hit.side] =\n if (isConnectable(world, pos, hit.side)) ConnectionType.CONNECTED else ConnectionType.NONE\n blockEntity.markDirty()\n blockEntity.sync()\n world.updateNeighbors(pos, state.block)\n Network.handleUpdate(networkState, pos)\n return ActionResult.success(world.isClient)\n }\n return ActionResult.PASS\n }\n\n @Suppress(\"DEPRECATION\")\n override fun onStateReplaced(\n blockState: BlockState,\n world: World,\n pos: BlockPos,\n newState: BlockState,\n moved: Boolean\n ) {\n super.onStateReplaced(blockState, world, pos, newState, moved)\n if (!world.isClient) {\n val networkState = type.getNetworkState(world as ServerWorld)\n if (networkState is ServoNetworkState<*>) {\n if (blockState.isOf(newState.block)) {\n Network.handleUpdate(networkState, pos)\n } else {\n Direction.values().forEach { dir ->\n val data = networkState.removeEndpointData(pos, dir)\n val (x, y, z) = pos.toVec3d()\n when (data?.type) {\n EndpointData.Type.OUTPUT ->\n ItemScatterer.spawn(world, x, y, z, ItemStack(IRItemRegistry.SERVO_OUTPUT))\n EndpointData.Type.RETRIEVER ->\n ItemScatterer.spawn(world, x, y, z, ItemStack(IRItemRegistry.SERVO_RETRIEVER))\n else -> {\n }\n }\n }\n }\n }\n Network.handleBreak(networkState, pos)\n }\n }\n\n abstract fun isConnectable(world: ServerWorld, pos: BlockPos, dir: Direction): Boolean\n\n override fun onPlaced(\n world: World,\n pos: BlockPos,\n state: BlockState,\n placer: LivingEntity?,\n itemStack: ItemStack?\n ) {\n super.onPlaced(world, pos, state, placer, itemStack)\n if (!world.isClient) {\n DIRECTIONS.forEach { facing ->\n updateConnection(world as ServerWorld, pos, pos.offset(facing), facing)\n }\n val networkState = type.getNetworkState(world as ServerWorld)\n Network.handleUpdate(networkState, pos)\n }\n }\n\n override fun neighborUpdate(\n state: BlockState,\n world: World?,\n pos: BlockPos,\n block: Block?,\n fromPos: BlockPos,\n notify: Boolean\n ) {\n val (x, y, z) = pos.subtract(fromPos)\n val facing = Direction.fromVector(x, y, z)?.opposite ?: return\n if (world is ServerWorld) {\n updateConnection(world, pos, fromPos, facing)\n }\n }\n\n private fun updateConnection(world: ServerWorld, pos: BlockPos, neighborPos: BlockPos, facing: Direction) {\n val networkState = type.getNetworkState(world)\n val blockEntity = world.getBlockEntity(pos) as? BasePipeBlockEntity ?: return\n val before = blockEntity.connections[facing]\n val new = ConnectionType.getType(isConnectable(world, neighborPos, facing))\n val neighborBlockEntity = world.getBlockEntity(neighborPos) as? BasePipeBlockEntity\n if (before != new && before?.isConnectable() != false && new.isConnectable()) {\n neighborBlockEntity?.connections?.put(facing.opposite, new)\n neighborBlockEntity?.markDirty()\n neighborBlockEntity?.sync()\n blockEntity.connections[facing] = new\n blockEntity.markDirty()\n blockEntity.sync()\n Network.handleUpdate(networkState, pos)\n }\n }\n\n enum class ConnectionType(val id: Int) {\n NONE(-1), CONNECTED(0), WRENCHED(1);\n\n fun isConnected() = this == CONNECTED\n\n fun isConnectable() = this != WRENCHED\n\n companion object {\n fun getType(connects: Boolean) = if (connects) CONNECTED else NONE\n\n fun byId(id: Int): ConnectionType {\n return when (id) {\n 0 -> CONNECTED\n 1 -> WRENCHED\n else -> NONE\n }\n }\n }\n }\n\n companion object {\n\n fun getSideFromHit(hit: Vec3d, pos: BlockPos): Direction? {\n val x = hit.x - pos.x\n val y = hit.y - pos.y\n val z = hit.z - pos.z\n return when {\n y > 0.6625 -> Direction.UP\n y < 0.3375 -> Direction.DOWN\n x > 0.6793 -> Direction.EAST\n x < 0.3169 -> Direction.WEST\n z < 0.3169 -> Direction.NORTH\n z > 0.6625 -> Direction.SOUTH\n else -> null\n }\n }\n\n val DIRECTIONS = Direction.values()\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blocks/machine/pipes/CableBlock.kt",
"content": "package me.steven.indrev.blocks.machine.pipes\n\nimport it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.blockentities.cables.BasePipeBlockEntity\nimport me.steven.indrev.config.IRConfig\nimport me.steven.indrev.networks.Network\nimport me.steven.indrev.networks.energy.CableEnergyIo\nimport me.steven.indrev.utils.energyOf\nimport me.steven.indrev.utils.pack\nimport net.minecraft.client.item.TooltipContext\nimport net.minecraft.item.ItemStack\nimport net.minecraft.server.world.ServerWorld\nimport net.minecraft.text.Text\nimport net.minecraft.text.TranslatableText\nimport net.minecraft.util.Formatting\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.math.Direction\nimport net.minecraft.util.shape.VoxelShape\nimport net.minecraft.util.shape.VoxelShapes\nimport net.minecraft.world.BlockView\nimport java.util.function.IntFunction\n\nclass CableBlock(settings: Settings, tier: Tier) : BasePipeBlock(settings, tier, Network.Type.ENERGY) {\n override fun appendTooltip(\n stack: ItemStack?,\n world: BlockView?,\n tooltip: MutableList?,\n options: TooltipContext?\n ) {\n tooltip?.add(\n TranslatableText(\"gui.indrev.tooltip.maxTransferRate\").formatted(Formatting.AQUA)\n .append(TranslatableText(\"gui.indrev.tooltip.lftick\", getMaxTransferRate()).formatted(Formatting.GRAY))\n )\n }\n\n override fun isConnectable(world: ServerWorld, pos: BlockPos, dir: Direction): Boolean {\n val handler = energyOf(world, pos, dir.opposite)\n if (handler != null && handler !is CableEnergyIo) return true\n val blockEntity = world.getBlockEntity(pos) as? BasePipeBlockEntity ?: return false\n if (!blockEntity.cachedState.isOf(this)) return false\n return blockEntity.connections[dir.opposite]!!.isConnectable()\n }\n\n private fun getMaxTransferRate() = when(tier) {\n Tier.MK1 -> IRConfig.cables.cableMk1\n Tier.MK2 -> IRConfig.cables.cableMk2\n Tier.MK3 -> IRConfig.cables.cableMk3\n else -> IRConfig.cables.cableMk4\n }\n\n override fun getShape(blockEntity: BasePipeBlockEntity): VoxelShape {\n val directions = DIRECTIONS.filter { dir -> blockEntity.connections[dir] == ConnectionType.CONNECTED }\n return SHAPE_CACHE.get().computeIfAbsent(pack(directions).toInt(), IntFunction {\n var shape = CENTER_SHAPE\n directions.forEach { direction ->\n shape = VoxelShapes.union(shape, getShape(direction))\n }\n shape\n })\n }\n\n companion object {\n\n val SHAPE_CACHE: ThreadLocal> = ThreadLocal.withInitial {\n object : Int2ObjectOpenHashMap(64, 0.25f) {\n override fun rehash(newN: Int) {\n }\n }\n }\n\n val DOWN_SHAPE: VoxelShape = createCuboidShape(6.0, 0.0, 6.0, 10.0, 6.0, 10.0)\n val UP_SHAPE: VoxelShape = createCuboidShape(6.0, 10.5, 6.0, 10.0, 16.0, 10.0)\n val SOUTH_SHAPE: VoxelShape = createCuboidShape(6.0, 6.0, 10.5, 10.0, 10.0, 16.0)\n val NORTH_SHAPE: VoxelShape = createCuboidShape(6.0, 6.0, 0.0, 10.0, 10.0, 5.5)\n val EAST_SHAPE: VoxelShape = createCuboidShape(10.5, 6.0, 6.0, 16.0, 10.0, 10.0)\n val WEST_SHAPE: VoxelShape = createCuboidShape(0.0, 6.0, 6.0, 5.5, 10.0, 10.0)\n\n val CENTER_SHAPE: VoxelShape = createCuboidShape(5.5, 5.5, 5.5, 10.5, 10.5, 10.5)\n\n private fun getShape(direction: Direction): VoxelShape {\n var shape = VoxelShapes.empty()\n if (direction == Direction.NORTH) shape = NORTH_SHAPE\n if (direction == Direction.SOUTH) shape = SOUTH_SHAPE\n if (direction == Direction.EAST) shape = EAST_SHAPE\n if (direction == Direction.WEST) shape = WEST_SHAPE\n if (direction == Direction.UP) shape = UP_SHAPE\n if (direction == Direction.DOWN) shape = DOWN_SHAPE\n return shape\n }\n\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blocks/machine/pipes/FluidPipeBlock.kt",
"content": "package me.steven.indrev.blocks.machine.pipes\n\nimport it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.blockentities.cables.BasePipeBlockEntity\nimport me.steven.indrev.config.IRConfig\nimport me.steven.indrev.networks.Network\nimport me.steven.indrev.networks.ServoNetworkState\nimport me.steven.indrev.utils.fluidStorageOf\nimport me.steven.indrev.utils.pack\nimport net.minecraft.client.item.TooltipContext\nimport net.minecraft.item.ItemStack\nimport net.minecraft.server.world.ServerWorld\nimport net.minecraft.text.Text\nimport net.minecraft.text.TranslatableText\nimport net.minecraft.util.Formatting\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.math.Direction\nimport net.minecraft.util.shape.VoxelShape\nimport net.minecraft.util.shape.VoxelShapes\nimport net.minecraft.world.BlockView\nimport java.util.function.IntFunction\n\nclass FluidPipeBlock(settings: Settings, tier: Tier) : BasePipeBlock(settings, tier, Network.Type.FLUID) {\n override fun appendTooltip(\n stack: ItemStack?,\n world: BlockView?,\n tooltip: MutableList?,\n options: TooltipContext?\n ) {\n tooltip?.add(\n TranslatableText(\"gui.indrev.tooltip.maxTransferRate\").formatted(Formatting.AQUA)\n .append(TranslatableText(\"gui.indrev.tooltip.fluidsec\", getMaxTransferRate()).formatted(Formatting.GRAY))\n )\n }\n\n override fun isConnectable(world: ServerWorld, pos: BlockPos, dir: Direction): Boolean {\n if (fluidStorageOf(world, pos, dir.opposite) != null) return true\n if ((type.getNetworkState(world) as ServoNetworkState<*>).hasServo(pos.offset(dir.opposite), dir))\n return true\n val blockEntity = world.getBlockEntity(pos) as? BasePipeBlockEntity ?: return false\n if (!blockEntity.cachedState.isOf(this)) return false\n return blockEntity.connections[dir.opposite]!!.isConnectable()\n }\n\n private fun getMaxTransferRate() = when(tier) {\n Tier.MK1 -> IRConfig.cables.fluidPipeMk1\n Tier.MK2 -> IRConfig.cables.fluidPipeMk2\n Tier.MK3 -> IRConfig.cables.fluidPipeMk3\n else -> IRConfig.cables.fluidPipeMk4\n }\n\n override fun getShape(blockEntity: BasePipeBlockEntity): VoxelShape {\n val directions = DIRECTIONS.filter { dir -> blockEntity.connections[dir] == ConnectionType.CONNECTED }\n return SHAPE_CACHE.get().computeIfAbsent(pack(directions).toInt(), IntFunction {\n var shape = CENTER_SHAPE\n directions.forEach { direction ->\n shape = VoxelShapes.union(shape, getShape(direction))\n }\n shape\n })\n }\n\n companion object {\n\n val SHAPE_CACHE: ThreadLocal> = ThreadLocal.withInitial {\n object : Int2ObjectOpenHashMap(64, 0.25f) {\n override fun rehash(newN: Int) {\n }\n }\n }\n\n val DOWN_SHAPE: VoxelShape = createCuboidShape(6.0, 0.0, 6.0, 10.0, 6.0, 10.0)\n val UP_SHAPE: VoxelShape = createCuboidShape(6.0, 10.0, 6.0, 10.0, 16.0, 10.0)\n val SOUTH_SHAPE: VoxelShape = createCuboidShape(6.0, 6.0, 10.5, 10.0, 10.0, 16.0)\n val NORTH_SHAPE: VoxelShape = createCuboidShape(6.0, 6.0, 0.0, 10.0, 10.0, 6.0)\n val EAST_SHAPE: VoxelShape = createCuboidShape(10.0, 6.0, 6.0, 16.0, 10.0, 10.0)\n val WEST_SHAPE: VoxelShape = createCuboidShape(0.0, 6.0, 6.0, 6.0, 10.0, 10.0)\n\n val CENTER_SHAPE: VoxelShape = createCuboidShape(6.0, 6.0, 6.0, 10.0, 10.0, 10.0)\n\n private fun getShape(direction: Direction): VoxelShape {\n var shape = VoxelShapes.empty()\n if (direction == Direction.NORTH) shape = NORTH_SHAPE\n if (direction == Direction.SOUTH) shape = SOUTH_SHAPE\n if (direction == Direction.EAST) shape = EAST_SHAPE\n if (direction == Direction.WEST) shape = WEST_SHAPE\n if (direction == Direction.UP) shape = UP_SHAPE\n if (direction == Direction.DOWN) shape = DOWN_SHAPE\n return shape\n }\n\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blocks/machine/pipes/ItemPipeBlock.kt",
"content": "package me.steven.indrev.blocks.machine.pipes\n\nimport it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.blockentities.cables.BasePipeBlockEntity\nimport me.steven.indrev.config.IRConfig\nimport me.steven.indrev.gui.screenhandlers.pipes.PipeFilterScreenFactory\nimport me.steven.indrev.gui.screenhandlers.pipes.PipeFilterScreenHandler\nimport me.steven.indrev.networks.Network\nimport me.steven.indrev.networks.ServoNetworkState\nimport me.steven.indrev.utils.itemStorageOf\nimport me.steven.indrev.utils.pack\nimport net.minecraft.block.BlockState\nimport net.minecraft.client.item.TooltipContext\nimport net.minecraft.entity.player.PlayerEntity\nimport net.minecraft.item.ItemStack\nimport net.minecraft.server.world.ServerWorld\nimport net.minecraft.text.Text\nimport net.minecraft.text.TranslatableText\nimport net.minecraft.util.ActionResult\nimport net.minecraft.util.Formatting\nimport net.minecraft.util.Hand\nimport net.minecraft.util.hit.BlockHitResult\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.math.Direction\nimport net.minecraft.util.shape.VoxelShape\nimport net.minecraft.util.shape.VoxelShapes\nimport net.minecraft.world.BlockView\nimport net.minecraft.world.World\nimport java.util.function.IntFunction\n\nclass ItemPipeBlock(settings: Settings, tier: Tier) : BasePipeBlock(settings, tier, Network.Type.ITEM) {\n override fun appendTooltip(\n stack: ItemStack?,\n world: BlockView?,\n tooltip: MutableList?,\n options: TooltipContext?\n ) {\n tooltip?.add(\n TranslatableText(\"gui.indrev.tooltip.maxTransferRate\").formatted(Formatting.AQUA)\n .append(TranslatableText(\"gui.indrev.tooltip.itemsec\", getMaxTransferRate()).formatted(Formatting.GRAY))\n )\n }\n\n override fun onUse(\n state: BlockState,\n world: World,\n pos: BlockPos,\n player: PlayerEntity,\n hand: Hand,\n hit: BlockHitResult\n ): ActionResult {\n val dir = getSideFromHit(hit.pos, pos)\n val blockEntity = world.getBlockEntity(pos) as? BasePipeBlockEntity ?: return ActionResult.PASS\n if (hand == Hand.MAIN_HAND && !world.isClient && player.getStackInHand(hand).isEmpty && dir != null && blockEntity.connections[dir]!!.isConnected()) {\n val type = Network.Type.ITEM\n val networkState = type.getNetworkState(world as ServerWorld)\n if (networkState.networksByPos.get(pos.asLong())?.containers?.containsKey(pos.offset(dir)) == true) {\n player.openHandledScreen(PipeFilterScreenFactory(::PipeFilterScreenHandler, pos, dir))\n return ActionResult.SUCCESS\n }\n }\n return super.onUse(state, world, pos, player, hand, hit)\n }\n\n override fun isConnectable(world: ServerWorld, pos: BlockPos, dir: Direction): Boolean {\n if (itemStorageOf(world, pos, dir.opposite) != null) return true\n if ((type.getNetworkState(world) as ServoNetworkState<*>).hasServo(pos.offset(dir.opposite), dir))\n return true\n val blockEntity = world.getBlockEntity(pos) as? BasePipeBlockEntity ?: return false\n if (!blockEntity.cachedState.isOf(this)) return false\n return blockEntity.connections[dir.opposite]!!.isConnectable()\n }\n\n\n private fun getMaxTransferRate() = when(tier) {\n Tier.MK1 -> IRConfig.cables.itemPipeMk1\n Tier.MK2 -> IRConfig.cables.itemPipeMk2\n Tier.MK3 -> IRConfig.cables.itemPipeMk3\n else -> IRConfig.cables.itemPipeMk4\n }\n\n override fun getShape(blockEntity: BasePipeBlockEntity): VoxelShape {\n val directions = DIRECTIONS.filter { dir -> blockEntity.connections[dir] == ConnectionType.CONNECTED }\n return SHAPE_CACHE.get().computeIfAbsent(pack(directions).toInt(), IntFunction {\n var shape = CENTER_SHAPE\n directions.forEach { direction ->\n shape = VoxelShapes.union(shape, getShape(direction))\n }\n shape\n })\n }\n\n companion object {\n\n val SHAPE_CACHE: ThreadLocal> = ThreadLocal.withInitial {\n object : Int2ObjectOpenHashMap(64, 0.25f) {\n override fun rehash(newN: Int) {\n }\n }\n }\n\n val DOWN_SHAPE: VoxelShape = createCuboidShape(6.5, 0.0, 6.5, 9.5, 6.5, 9.5)\n val UP_SHAPE: VoxelShape = createCuboidShape(6.5, 9.5, 6.5, 9.5, 16.0, 9.5)\n val SOUTH_SHAPE: VoxelShape = createCuboidShape(6.5, 6.5, 9.5, 9.5, 9.5, 16.0)\n val NORTH_SHAPE: VoxelShape = createCuboidShape(6.5, 6.5, 0.0, 9.5, 9.5, 6.5)\n val EAST_SHAPE: VoxelShape = createCuboidShape(9.5, 6.5, 6.5, 16.0, 9.5, 9.5)\n val WEST_SHAPE: VoxelShape = createCuboidShape(0.0, 6.5, 6.5, 6.5, 9.5, 9.5)\n\n val CENTER_SHAPE: VoxelShape = createCuboidShape(6.5, 6.5, 6.5, 9.5, 9.5, 9.5)\n\n private fun getShape(direction: Direction): VoxelShape {\n var shape = VoxelShapes.empty()\n if (direction == Direction.NORTH) shape = NORTH_SHAPE\n if (direction == Direction.SOUTH) shape = SOUTH_SHAPE\n if (direction == Direction.EAST) shape = EAST_SHAPE\n if (direction == Direction.WEST) shape = WEST_SHAPE\n if (direction == Direction.UP) shape = UP_SHAPE\n if (direction == Direction.DOWN) shape = DOWN_SHAPE\n return shape\n }\n\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blocks/machine/solarpowerplant/FluidValveBlock.kt",
"content": "package me.steven.indrev.blocks.machine.solarpowerplant\n\nimport net.minecraft.block.Block\nimport net.minecraft.block.BlockState\nimport net.minecraft.block.FacingBlock\nimport net.minecraft.item.ItemPlacementContext\nimport net.minecraft.state.StateManager\nimport net.minecraft.util.BlockMirror\nimport net.minecraft.util.BlockRotation\nimport net.minecraft.util.math.Direction\n\nopen class FluidValveBlock(settings: Settings) : FacingBlock(settings) {\n\n init {\n this.defaultState = stateManager.defaultState.with(FACING, Direction.NORTH)\n }\n\n override fun appendProperties(builder: StateManager.Builder?) {\n builder?.add(FACING)\n }\n\n override fun rotate(state: BlockState, rotation: BlockRotation): BlockState? {\n return state.with(FACING, rotation.rotate(state[FACING]))\n }\n\n override fun mirror(state: BlockState, mirror: BlockMirror): BlockState? {\n return state.rotate(mirror.getRotation(state[FACING]))\n }\n\n override fun getPlacementState(ctx: ItemPlacementContext): BlockState? {\n return defaultState.with(FACING, ctx.playerLookDirection.opposite)\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blocks/machine/solarpowerplant/SolarPowerPlantFluidOutputBlock.kt",
"content": "package me.steven.indrev.blocks.machine.solarpowerplant\n\nimport me.steven.indrev.blocks.misc.HorizontalFacingBlock\n\nclass SolarPowerPlantFluidOutputBlock(settings: Settings) : HorizontalFacingBlock(settings)"
},
{
"path": "src/main/kotlin/me/steven/indrev/blocks/machine/solarpowerplant/SolarPowerPlantTowerBlock.kt",
"content": "package me.steven.indrev.blocks.machine.solarpowerplant\n\nimport me.steven.indrev.IndustrialRevolution\nimport me.steven.indrev.blockentities.solarpowerplant.HeliostatBlockEntity\nimport me.steven.indrev.blockentities.solarpowerplant.SolarPowerPlantTowerBlockEntity\nimport me.steven.indrev.blocks.misc.HorizontalFacingBlock\nimport me.steven.indrev.components.multiblock.definitions.SolarPowerPlantTowerStructureDefinition\nimport me.steven.indrev.gui.IRScreenHandlerFactory\nimport me.steven.indrev.gui.screenhandlers.machines.SolarPowerPlantTowerScreenHandler\nimport net.minecraft.block.BlockEntityProvider\nimport net.minecraft.block.BlockState\nimport net.minecraft.block.entity.BlockEntity\nimport net.minecraft.block.entity.BlockEntityTicker\nimport net.minecraft.block.entity.BlockEntityType\nimport net.minecraft.entity.player.PlayerEntity\nimport net.minecraft.nbt.NbtLong\nimport net.minecraft.text.LiteralText\nimport net.minecraft.text.TranslatableText\nimport net.minecraft.util.ActionResult\nimport net.minecraft.util.Hand\nimport net.minecraft.util.hit.BlockHitResult\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.world.World\n\nclass SolarPowerPlantTowerBlock(settings: Settings) : HorizontalFacingBlock(settings), BlockEntityProvider {\n\n override fun createBlockEntity(pos: BlockPos, state: BlockState): BlockEntity = SolarPowerPlantTowerBlockEntity(pos, state)\n\n override fun getTicker(\n world: World,\n state: BlockState?,\n type: BlockEntityType?\n ): BlockEntityTicker? {\n return if (world.isClient) null\n else return BlockEntityTicker { world, pos, state, blockEntity -> SolarPowerPlantTowerBlockEntity.tick(world, pos, state, blockEntity as? SolarPowerPlantTowerBlockEntity ?: return@BlockEntityTicker) }\n }\n\n override fun onUse(\n state: BlockState,\n world: World,\n pos: BlockPos,\n player: PlayerEntity,\n hand: Hand,\n hit: BlockHitResult?\n ): ActionResult {\n if (!world.isClient) {\n val stack = player.getStackInHand(hand)\n if (stack.isIn(IndustrialRevolution.SCREWDRIVER_TAG) && stack.orCreateNbt.contains(\"SelectedHeliostats\")) {\n val positions = stack.nbt!!.getList(\"SelectedHeliostats\", 4)?.map { BlockPos.fromLong((it as NbtLong).longValue()) }\n val receivers = SolarPowerPlantTowerStructureDefinition.getSolarReceiverPositions(pos, state)\n\n positions?.forEach { p ->\n val heliostat = world.getBlockEntity(p) as HeliostatBlockEntity\n val target = receivers.minByOrNull { it.getManhattanDistance(p) } ?: return@forEach\n heliostat.targetBlock = target\n heliostat.markDirty()\n heliostat.sync()\n }\n player.sendMessage(LiteralText(\"Linked Heliostats!\"), true)\n } else {\n val blockEntity = world.getBlockEntity(pos) as? SolarPowerPlantTowerBlockEntity ?: return ActionResult.PASS\n if (!blockEntity.multiblockComponent.isBuilt(world, pos, state)) {\n player.sendMessage(TranslatableText(\"text.multiblock.not_built\"), true)\n blockEntity.multiblockComponent.toggleRender(player.isSneaking)\n blockEntity.markDirty()\n blockEntity.sync()\n } else\n player.openHandledScreen(IRScreenHandlerFactory(::SolarPowerPlantTowerScreenHandler, pos))\n }\n }\n return ActionResult.success(world.isClient)\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blocks/machine/solarpowerplant/SolarReceiverBlock.kt",
"content": "package me.steven.indrev.blocks.machine.solarpowerplant\n\nimport me.steven.indrev.blockentities.solarpowerplant.SolarReceiverBlockEntity\nimport net.minecraft.block.Block\nimport net.minecraft.block.BlockEntityProvider\nimport net.minecraft.block.BlockState\nimport net.minecraft.block.entity.BlockEntity\nimport net.minecraft.util.math.BlockPos\n\nclass SolarReceiverBlock(settings: Settings) : Block(settings), BlockEntityProvider {\n override fun createBlockEntity(pos: BlockPos, state: BlockState): BlockEntity = SolarReceiverBlockEntity(pos, state)\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blocks/machine/solarpowerplant/SteamTurbineBlock.kt",
"content": "package me.steven.indrev.blocks.machine.solarpowerplant\n\nimport me.steven.indrev.api.machines.Tier\nimport me.steven.indrev.blocks.machine.HorizontalFacingMachineBlock\nimport me.steven.indrev.config.IRConfig\nimport me.steven.indrev.gui.screenhandlers.machines.SteamTurbineScreenHandler\nimport me.steven.indrev.registry.MachineRegistry\n\nclass SteamTurbineBlock(registry: MachineRegistry, settings: Settings)\n : HorizontalFacingMachineBlock(registry, settings, Tier.MK4, IRConfig.generators.steamTurbine, ::SteamTurbineScreenHandler)"
},
{
"path": "src/main/kotlin/me/steven/indrev/blocks/machine/solarpowerplant/SteamTurbineSteamInputValveBlock.kt",
"content": "package me.steven.indrev.blocks.machine.solarpowerplant\n\nimport me.steven.indrev.blockentities.generators.SteamTurbineSteamInputValveBlockEntity\nimport net.minecraft.block.BlockEntityProvider\nimport net.minecraft.block.BlockState\nimport net.minecraft.block.entity.BlockEntity\nimport net.minecraft.block.entity.BlockEntityTicker\nimport net.minecraft.block.entity.BlockEntityType\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.world.World\n\nclass SteamTurbineSteamInputValveBlock(settings: Settings) : FluidValveBlock(settings), BlockEntityProvider {\n override fun createBlockEntity(pos: BlockPos, state: BlockState): BlockEntity = SteamTurbineSteamInputValveBlockEntity(pos, state)\n\n override fun getTicker(\n world: World,\n state: BlockState?,\n type: BlockEntityType?\n ): BlockEntityTicker? {\n return if (world.isClient) null\n else BlockEntityTicker { _, _, _, blockEntity ->\n (blockEntity as? SteamTurbineSteamInputValveBlockEntity)?.inserted = false\n }\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blocks/misc/AcidFluidBlock.kt",
"content": "package me.steven.indrev.blocks.misc\n\nimport net.minecraft.block.BlockState\nimport net.minecraft.block.Blocks\nimport net.minecraft.block.FluidBlock\nimport net.minecraft.entity.Entity\nimport net.minecraft.entity.damage.DamageSource\nimport net.minecraft.fluid.FlowableFluid\nimport net.minecraft.particle.ParticleTypes\nimport net.minecraft.server.world.ServerWorld\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.math.Direction\nimport net.minecraft.world.World\nimport java.util.*\n\nclass AcidFluidBlock(fluid: FlowableFluid, settings: Settings) : FluidBlock(fluid, settings) {\n override fun randomTick(state: BlockState?, world: ServerWorld?, pos: BlockPos?, random: Random?) {\n Direction.values().forEach { dir ->\n val neighbor = pos?.offset(dir)\n val blockState = world?.getBlockState(neighbor)\n val block = blockState?.block\n if (block == Blocks.DIRT || block == Blocks.GRASS_BLOCK || block == Blocks.FARMLAND || block == Blocks.DIRT_PATH)\n world?.setBlockState(pos, Blocks.COARSE_DIRT.defaultState)\n }\n }\n\n override fun randomDisplayTick(state: BlockState?, world: World, pos: BlockPos, random: Random) {\n if (!world.isAir(pos.up()) || random.nextInt(10) < 5) return\n (0..1).forEach { a ->\n (0..1).forEach { b ->\n world.addParticle(\n ParticleTypes.SNEEZE, pos.x + a / 2.0 + (random.nextFloat() / 5), pos.y + 1.0, pos.z + b / 2.0 + (random.nextFloat() / 5), 0.0, 0.005, 0.0)\n }\n }\n }\n\n override fun onEntityCollision(state: BlockState?, world: World, pos: BlockPos?, entity: Entity?) {\n if (world.time % 15 == 0L)\n entity?.damage(ACID_DAMAGE_SOURCE, 4f)\n }\n\n companion object {\n val ACID_DAMAGE_SOURCE = object : DamageSource(\"acid\") {\n init {\n setBypassesArmor()\n setUnblockable()\n }\n }\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blocks/misc/BiomassComposterBlock.kt",
"content": "package me.steven.indrev.blocks.misc\n\nimport me.steven.indrev.blockentities.farms.BiomassComposterBlockEntity\nimport me.steven.indrev.registry.IRBlockRegistry\nimport me.steven.indrev.registry.IRItemRegistry\nimport me.steven.indrev.utils.bucket\nimport net.fabricmc.fabric.api.`object`.builder.v1.block.FabricBlockSettings\nimport net.fabricmc.fabric.api.transfer.v1.context.ContainerItemContext\nimport net.fabricmc.fabric.api.transfer.v1.fluid.FluidStorage\nimport net.fabricmc.fabric.api.transfer.v1.item.ItemVariant\nimport net.fabricmc.fabric.api.transfer.v1.storage.StorageUtil\nimport net.minecraft.block.*\nimport net.minecraft.block.entity.BlockEntity\nimport net.minecraft.block.entity.BlockEntityTicker\nimport net.minecraft.block.entity.BlockEntityType\nimport net.minecraft.entity.player.PlayerEntity\nimport net.minecraft.item.ItemStack\nimport net.minecraft.state.StateManager\nimport net.minecraft.state.property.BooleanProperty\nimport net.minecraft.util.ActionResult\nimport net.minecraft.util.Hand\nimport net.minecraft.util.hit.BlockHitResult\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.world.World\n\nclass BiomassComposterBlock : Block(FabricBlockSettings.copyOf(Blocks.COMPOSTER)), BlockEntityProvider {\n\n init {\n this.defaultState = stateManager.defaultState.with(CLOSED, false)\n }\n\n override fun createBlockEntity(pos: BlockPos, state: BlockState): BlockEntity = BiomassComposterBlockEntity(pos, state)\n\n override fun getTicker(\n world: World,\n state: BlockState,\n type: BlockEntityType\n ): BlockEntityTicker? {\n return if (world.isClient) null\n else BlockEntityTicker { _, _, state, blockEntity ->\n BiomassComposterBlockEntity.tick(\n state, blockEntity as? BiomassComposterBlockEntity ?: return@BlockEntityTicker\n )\n }\n }\n\n override fun appendProperties(builder: StateManager.Builder?) {\n builder?.add(CLOSED)\n }\n\n override fun onUse(\n state: BlockState,\n world: World,\n pos: BlockPos,\n player: PlayerEntity,\n hand: Hand,\n hit: BlockHitResult?\n ): ActionResult {\n val stack = player.getStackInHand(hand)\n val blockEntity = world.getBlockEntity(pos) as? BiomassComposterBlockEntity ?: return ActionResult.PASS\n val inHand = ContainerItemContext.ofPlayerHand(player, hand).find(FluidStorage.ITEM)\n val result = StorageUtil.move(inHand, blockEntity.fluidInv, { true }, bucket, null)\n if (result > 0) {\n blockEntity.markDirty()\n if (!world.isClient)\n blockEntity.sync()\n return ActionResult.success(world.isClient)\n } else if (ComposterBlock.ITEM_TO_LEVEL_INCREASE_CHANCE.contains(stack.item) || stack.isEmpty) {\n compost(stack, player, blockEntity, world)\n } else if (state[CLOSED]) {\n world.setBlockState(pos, state.with(CLOSED, false))\n if (!player.isCreative)\n player.inventory.offerOrDrop(ItemStack(IRBlockRegistry.PLANKS))\n } else if (stack.isOf(IRBlockRegistry.PLANKS.asItem())) {\n world.setBlockState(pos, state.with(CLOSED, true))\n if (!player.isCreative)\n stack.decrement(1)\n } else return ActionResult.FAIL\n\n return ActionResult.success(world.isClient)\n }\n\n private fun compost(stack: ItemStack, player: PlayerEntity, blockEntity: BiomassComposterBlockEntity, world: World) {\n if (world.isClient) return\n if (blockEntity.itemInv.variant.isOf(IRItemRegistry.BIOMASS)) {\n player.inventory.offerOrDrop(ItemStack(IRItemRegistry.BIOMASS))\n blockEntity.itemInv.variant = ItemVariant.blank()\n blockEntity.itemInv.amount = 0\n\n blockEntity.markDirty()\n blockEntity.sync()\n } else if (blockEntity.level < 7 && !stack.isEmpty) {\n val chance = ComposterBlock.ITEM_TO_LEVEL_INCREASE_CHANCE.getValue(stack.item)\n if (!player.isCreative)\n stack.decrement(1)\n var leveledUp = false\n if (world.random.nextInt() < chance) {\n blockEntity.level++\n blockEntity.markDirty()\n blockEntity.sync()\n leveledUp = true\n }\n world.syncWorldEvent(1500, blockEntity.pos, if (leveledUp) 1 else 0)\n }\n }\n\n companion object {\n val CLOSED: BooleanProperty = BooleanProperty.of(\"closed\")\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blocks/misc/CabinetBlock.kt",
"content": "package me.steven.indrev.blocks.misc\n\nimport me.steven.indrev.blockentities.storage.CabinetBlockEntity\nimport net.minecraft.block.BlockEntityProvider\nimport net.minecraft.block.BlockState\nimport net.minecraft.block.entity.BlockEntity\nimport net.minecraft.entity.player.PlayerEntity\nimport net.minecraft.util.ActionResult\nimport net.minecraft.util.Hand\nimport net.minecraft.util.hit.BlockHitResult\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.world.World\n\nclass CabinetBlock(settings: Settings) : HorizontalFacingBlock(settings), BlockEntityProvider {\n override fun createBlockEntity(pos: BlockPos, state: BlockState): BlockEntity = CabinetBlockEntity(pos, state)\n override fun onUse(\n state: BlockState?,\n world: World,\n pos: BlockPos?,\n player: PlayerEntity,\n hand: Hand?,\n hit: BlockHitResult?\n ): ActionResult {\n if (!world.isClient) {\n val blockEntity = world.getBlockEntity(pos) as? CabinetBlockEntity ?: return ActionResult.PASS\n player.openHandledScreen(blockEntity)\n }\n return ActionResult.success(world.isClient)\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blocks/misc/DuctBlock.kt",
"content": "package me.steven.indrev.blocks.misc\n\nimport net.minecraft.block.BlockState\nimport net.minecraft.block.ShapeContext\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.math.Direction\nimport net.minecraft.util.shape.VoxelShape\nimport net.minecraft.world.BlockView\n\nclass DuctBlock(settings: Settings) : HorizontalFacingBlock(settings) {\n override fun getOutlineShape(\n state: BlockState,\n world: BlockView?,\n pos: BlockPos?,\n context: ShapeContext?\n ): VoxelShape = when (state[FACING]) {\n Direction.NORTH -> FACING_NORTH\n Direction.SOUTH -> FACING_SOUTH\n Direction.WEST -> FACING_WEST\n Direction.EAST -> FACING_EAST\n else -> FACING_NORTH\n }\n companion object {\n private val FACING_SOUTH: VoxelShape = createCuboidShape(2.0, 0.0, 0.0, 14.0, 14.0, 14.0)\n private val FACING_NORTH: VoxelShape = createCuboidShape(2.0, 0.0, 2.0, 14.0, 14.0, 16.0)\n private val FACING_EAST: VoxelShape = createCuboidShape(0.0, 0.0, 2.0, 14.0, 14.0, 14.0)\n private val FACING_WEST: VoxelShape = createCuboidShape(2.0, 0.0, 2.0, 16.0, 14.0, 14.0)\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blocks/misc/HorizontalFacingBlock.kt",
"content": "package me.steven.indrev.blocks.misc\n\nimport net.minecraft.block.Block\nimport net.minecraft.block.BlockState\nimport net.minecraft.block.HorizontalFacingBlock\nimport net.minecraft.item.ItemPlacementContext\nimport net.minecraft.state.StateManager\nimport net.minecraft.util.math.Direction\n\nopen class HorizontalFacingBlock(settings: Settings) : HorizontalFacingBlock(settings) {\n init {\n this.defaultState = stateManager.defaultState.with(FACING, Direction.NORTH)\n }\n\n override fun getPlacementState(ctx: ItemPlacementContext?): BlockState? {\n return defaultState.with(FACING, ctx?.playerFacing?.opposite)\n }\n\n override fun appendProperties(builder: StateManager.Builder?) {\n builder?.add(FACING)\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blocks/misc/NikoliteOreBlock.kt",
"content": "package me.steven.indrev.blocks.misc\n\nimport net.minecraft.block.OreBlock\nimport net.minecraft.util.math.intprovider.UniformIntProvider\n\nclass NikoliteOreBlock(settings: Settings) : OreBlock(settings, UniformIntProvider.create(1, 6))"
},
{
"path": "src/main/kotlin/me/steven/indrev/blocks/misc/PlankBlock.kt",
"content": "package me.steven.indrev.blocks.misc\n\nimport net.minecraft.block.BlockState\nimport net.minecraft.block.ShapeContext\nimport net.minecraft.block.SnowBlock\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.shape.VoxelShape\nimport net.minecraft.world.BlockView\nimport net.minecraft.world.WorldView\n\nclass PlankBlock(settings: Settings) : SnowBlock(settings) {\n override fun canPlaceAt(state: BlockState, world: WorldView?, pos: BlockPos): Boolean = true\n\n override fun getCollisionShape(\n state: BlockState,\n world: BlockView?,\n pos: BlockPos?,\n context: ShapeContext?\n ): VoxelShape = LAYERS_TO_SHAPE[state.get(LAYERS)]\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blocks/misc/SulfurCrystalBlock.kt",
"content": "package me.steven.indrev.blocks.misc\n\nimport me.steven.indrev.registry.IRItemRegistry\nimport net.minecraft.block.Block\nimport net.minecraft.block.BlockState\nimport net.minecraft.block.ShapeContext\nimport net.minecraft.item.Item\nimport net.minecraft.item.ItemPlacementContext\nimport net.minecraft.state.StateManager\nimport net.minecraft.state.property.DirectionProperty\nimport net.minecraft.state.property.Properties\nimport net.minecraft.util.function.BooleanBiFunction\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.math.Direction\nimport net.minecraft.util.shape.VoxelShape\nimport net.minecraft.util.shape.VoxelShapes\nimport net.minecraft.world.BlockView\nimport net.minecraft.world.World\nimport net.minecraft.world.WorldView\nimport java.util.stream.Stream\n\nclass SulfurCrystalBlock(settings: Settings) : Block(settings) {\n\n init {\n defaultState = stateManager.defaultState.with(FACING, Direction.UP)\n }\n\n override fun getOutlineShape(\n state: BlockState,\n world: BlockView?,\n pos: BlockPos?,\n context: ShapeContext?\n ): VoxelShape = when (state[FACING]) {\n Direction.DOWN -> DOWN_SHAPE\n Direction.NORTH -> NORTH_SHAPE\n Direction.SOUTH -> SOUTH_SHAPE\n Direction.WEST -> WEST_SHAPE\n Direction.EAST -> EAST_SHAPE\n else -> UP_SHAPE\n }\n\n override fun neighborUpdate(\n state: BlockState,\n world: World?,\n pos: BlockPos,\n block: Block?,\n fromPos: BlockPos,\n notify: Boolean\n ) {\n val vec = pos.subtract(fromPos)\n val dir = Direction.fromVector(vec.x, vec.y, vec.z)\n if (state[FACING] == dir) {\n world?.breakBlock(pos, true)\n }\n }\n\n override fun canPlaceAt(state: BlockState, world: WorldView, pos: BlockPos): Boolean {\n val direction = state.get(FACING)\n val blockPos = pos.offset(direction.opposite)\n val blockState = world.getBlockState(blockPos)\n return blockState.isSideSolidFullSquare(world, blockPos, direction)\n }\n\n override fun appendProperties(builder: StateManager.Builder?) {\n builder?.add(FACING)\n }\n\n override fun getPlacementState(ctx: ItemPlacementContext?): BlockState? {\n return defaultState.with(FACING, ctx?.playerLookDirection?.opposite)\n }\n\n override fun asItem(): Item {\n return IRItemRegistry.SULFUR_CRYSTAL_ITEM\n }\n\n companion object {\n val FACING: DirectionProperty = Properties.FACING\n private val UP_SHAPE = Stream.of(\n createCuboidShape(2.0, 5.0, 4.0, 3.0, 6.0, 5.0),\n createCuboidShape(2.0, 4.0, 4.0, 4.0, 5.0, 6.0),\n createCuboidShape(1.0, 0.0, 3.0, 4.0, 4.0, 6.0),\n createCuboidShape(3.0, 0.0, 2.0, 5.0, 1.0, 4.0),\n createCuboidShape(0.0, 0.0, 5.0, 2.0, 2.0, 7.0),\n createCuboidShape(10.0, 0.0, 1.0, 12.0, 1.0, 3.0),\n createCuboidShape(11.0, 0.0, 2.0, 14.0, 4.0, 5.0),\n createCuboidShape(11.0, 4.0, 2.0, 13.0, 5.0, 4.0),\n createCuboidShape(12.0, 5.0, 3.0, 13.0, 6.0, 4.0),\n createCuboidShape(13.0, 0.0, 4.0, 15.0, 2.0, 6.0),\n createCuboidShape(6.0, 0.0, 7.0, 8.0, 2.0, 10.0),\n createCuboidShape(7.0, 0.0, 8.0, 12.0, 5.0, 13.0),\n createCuboidShape(8.0, 5.0, 9.0, 11.0, 8.0, 12.0),\n createCuboidShape(9.0, 8.0, 10.0, 10.0, 10.0, 11.0),\n createCuboidShape(11.0, 0.0, 12.0, 14.0, 3.0, 15.0)\n ).reduce { v1, v2 -> VoxelShapes.combineAndSimplify(v1, v2, BooleanBiFunction.OR) }.orElse(null)\n\n private val DOWN_SHAPE = Stream.of(\n createCuboidShape(13.0, 11.0, 4.0, 14.0, 12.0, 5.0),\n createCuboidShape(12.0, 12.0, 4.0, 14.0, 13.0, 6.0),\n createCuboidShape(12.0, 13.0, 3.0, 15.0, 17.0, 6.0),\n createCuboidShape(11.0, 16.0, 2.0, 13.0, 17.0, 4.0),\n createCuboidShape(14.0, 15.0, 5.0, 16.0, 17.0, 7.0),\n createCuboidShape(4.0, 16.0, 1.0, 6.0, 17.0, 3.0),\n createCuboidShape(2.0, 13.0, 2.0, 5.0, 17.0, 5.0),\n createCuboidShape(3.0, 12.0, 2.0, 5.0, 13.0, 4.0),\n createCuboidShape(3.0, 11.0, 3.0, 4.0, 12.0, 4.0),\n createCuboidShape(1.0, 15.0, 4.0, 3.0, 17.0, 6.0),\n createCuboidShape(8.0, 15.0, 7.0, 10.0, 17.0, 10.0),\n createCuboidShape(4.0, 12.0, 8.0, 9.0, 17.0, 13.0),\n createCuboidShape(5.0, 9.0, 9.0, 8.0, 12.0, 12.0),\n createCuboidShape(6.0, 7.0, 10.0, 7.0, 9.0, 11.0),\n createCuboidShape(2.0, 14.0, 12.0, 5.0, 17.0, 15.0)\n ).reduce { v1, v2 -> VoxelShapes.combineAndSimplify(v1, v2, BooleanBiFunction.OR) }.orElse(null)\n\n private val EAST_SHAPE = Stream.of(\n createCuboidShape(5.0, 11.0, 13.0, 6.0, 12.0, 14.0),\n createCuboidShape(4.0, 10.0, 12.0, 5.0, 12.0, 14.0),\n createCuboidShape(0.0, 10.0, 12.0, 4.0, 13.0, 15.0),\n createCuboidShape(0.0, 12.0, 11.0, 1.0, 14.0, 13.0),\n createCuboidShape(0.0, 9.0, 14.0, 2.0, 11.0, 16.0),\n createCuboidShape(0.0, 13.0, 4.0, 1.0, 15.0, 6.0),\n createCuboidShape(0.0, 11.0, 2.0, 4.0, 14.0, 5.0),\n createCuboidShape(4.0, 12.0, 3.0, 5.0, 14.0, 5.0),\n createCuboidShape(5.0, 12.0, 3.0, 6.0, 13.0, 4.0),\n createCuboidShape(0.0, 10.0, 1.0, 2.0, 12.0, 3.0),\n createCuboidShape(0.0, 6.0, 8.0, 2.0, 9.0, 10.0),\n createCuboidShape(0.0, 3.0, 4.0, 5.0, 8.0, 9.0),\n createCuboidShape(5.0, 4.0, 5.0, 8.0, 7.0, 8.0),\n createCuboidShape(8.0, 5.0, 6.0, 10.0, 6.0, 7.0),\n createCuboidShape(0.0, 1.0, 2.0, 3.0, 4.0, 5.0)\n ).reduce { v1, v2 -> VoxelShapes.combineAndSimplify(v1, v2, BooleanBiFunction.OR) }.orElse(null)\n\n private val SOUTH_SHAPE = Stream.of(\n createCuboidShape(1.0, 4.0, 0.0, 3.0, 6.0, 2.0),\n createCuboidShape(3.0, 3.0, 5.0, 4.0, 4.0, 6.0),\n createCuboidShape(3.0, 2.0, 4.0, 5.0, 4.0, 5.0),\n createCuboidShape(2.0, 2.0, 0.0, 5.0, 5.0, 4.0),\n createCuboidShape(4.0, 1.0, 0.0, 6.0, 3.0, 1.0),\n createCuboidShape(11.0, 2.0, 0.0, 13.0, 4.0, 1.0),\n createCuboidShape(12.0, 3.0, 0.0, 15.0, 6.0, 4.0),\n createCuboidShape(12.0, 4.0, 4.0, 14.0, 6.0, 5.0),\n createCuboidShape(13.0, 4.0, 5.0, 14.0, 5.0, 6.0),\n createCuboidShape(14.0, 5.0, 0.0, 16.0, 7.0, 2.0),\n createCuboidShape(8.0, 7.0, 0.0, 10.0, 10.0, 2.0),\n createCuboidShape(4.0, 8.0, 0.0, 9.0, 13.0, 5.0),\n createCuboidShape(5.0, 9.0, 5.0, 8.0, 12.0, 8.0),\n createCuboidShape(6.0, 10.0, 8.0, 7.0, 11.0, 10.0),\n createCuboidShape(2.0, 12.0, 0.0, 5.0, 15.0, 3.0)\n ).reduce { v1, v2 -> VoxelShapes.combineAndSimplify(v1, v2, BooleanBiFunction.OR) }.orElse(null)\n\n private val NORTH_SHAPE = Stream.of(\n createCuboidShape(13.0, 4.0, 14.0, 15.0, 6.0, 16.0),\n createCuboidShape(12.0, 3.0, 10.0, 13.0, 4.0, 11.0),\n createCuboidShape(11.0, 2.0, 11.0, 13.0, 4.0, 12.0),\n createCuboidShape(11.0, 2.0, 12.0, 14.0, 5.0, 16.0),\n createCuboidShape(10.0, 1.0, 15.0, 12.0, 3.0, 16.0),\n createCuboidShape(3.0, 2.0, 15.0, 5.0, 4.0, 16.0),\n createCuboidShape(1.0, 3.0, 12.0, 4.0, 6.0, 16.0),\n createCuboidShape(2.0, 4.0, 11.0, 4.0, 6.0, 12.0),\n createCuboidShape(2.0, 4.0, 10.0, 3.0, 5.0, 11.0),\n createCuboidShape(0.0, 5.0, 14.0, 2.0, 7.0, 16.0),\n createCuboidShape(6.0, 7.0, 14.0, 8.0, 10.0, 16.0),\n createCuboidShape(7.0, 8.0, 11.0, 12.0, 13.0, 16.0),\n createCuboidShape(8.0, 9.0, 8.0, 11.0, 12.0, 11.0),\n createCuboidShape(9.0, 10.0, 6.0, 10.0, 11.0, 8.0),\n createCuboidShape(11.0, 12.0, 13.0, 14.0, 15.0, 16.0)\n ).reduce { v1: VoxelShape?, v2: VoxelShape? -> VoxelShapes.combineAndSimplify(v1, v2, BooleanBiFunction.OR) }.orElse(null)\n\n private val WEST_SHAPE = Stream.of(\n createCuboidShape(10.0, 11.0, 2.0, 11.0, 12.0, 3.0),\n createCuboidShape(11.0, 10.0, 2.0, 12.0, 12.0, 4.0),\n createCuboidShape(12.0, 10.0, 1.0, 16.0, 13.0, 4.0),\n createCuboidShape(15.0, 12.0, 3.0, 16.0, 14.0, 5.0),\n createCuboidShape(14.0, 9.0, 0.0, 16.0, 11.0, 2.0),\n createCuboidShape(15.0, 13.0, 10.0, 16.0, 15.0, 12.0),\n createCuboidShape(12.0, 11.0, 11.0, 16.0, 14.0, 14.0),\n createCuboidShape(11.0, 12.0, 11.0, 12.0, 14.0, 13.0),\n createCuboidShape(10.0, 12.0, 12.0, 11.0, 13.0, 13.0),\n createCuboidShape(14.0, 10.0, 13.0, 16.0, 12.0, 15.0),\n createCuboidShape(14.0, 6.0, 6.0, 16.0, 9.0, 8.0),\n createCuboidShape(11.0, 3.0, 7.0, 16.0, 8.0, 12.0),\n createCuboidShape(8.0, 4.0, 8.0, 11.0, 7.0, 11.0),\n createCuboidShape(6.0, 5.0, 9.0, 8.0, 6.0, 10.0),\n createCuboidShape(13.0, 1.0, 11.0, 16.0, 4.0, 14.0)\n ).reduce { v1, v2 -> VoxelShapes.combineAndSimplify(v1, v2, BooleanBiFunction.OR) }.orElse(null)\n }\n}"
},
{
"path": "src/main/kotlin/me/steven/indrev/blocks/misc/TankBlock.kt",
"content": "package me.steven.indrev.blocks.misc\n\nimport alexiil.mc.lib.attributes.fluid.volume.FluidVolume\nimport me.steven.indrev.blockentities.Syncable\nimport me.steven.indrev.blockentities.storage.TankBlockEntity\nimport me.steven.indrev.components.FluidComponent\nimport me.steven.indrev.registry.IRBlockRegistry\nimport me.steven.indrev.utils.bucket\nimport me.steven.indrev.utils.fluidStorageOf\nimport net.fabricmc.fabric.api.transfer.v1.context.ContainerItemContext\nimport net.fabricmc.fabric.api.transfer.v1.fluid.FluidStorage\nimport net.fabricmc.fabric.api.transfer.v1.storage.StorageUtil\nimport net.minecraft.block.Block\nimport net.minecraft.block.BlockEntityProvider\nimport net.minecraft.block.BlockState\nimport net.minecraft.block.ShapeContext\nimport net.minecraft.block.entity.BlockEntity\nimport net.minecraft.block.entity.BlockEntityTicker\nimport net.minecraft.block.entity.BlockEntityType\nimport net.minecraft.client.item.TooltipContext\nimport net.minecraft.entity.LivingEntity\nimport net.minecraft.entity.player.PlayerEntity\nimport net.minecraft.item.ItemPlacementContext\nimport net.minecraft.item.ItemStack\nimport net.minecraft.server.world.ServerWorld\nimport net.minecraft.stat.Stats\nimport net.minecraft.state.StateManager\nimport net.minecraft.state.property.BooleanProperty\nimport net.minecraft.text.LiteralText\nimport net.minecraft.text.Text\nimport net.minecraft.util.ActionResult\nimport net.minecraft.util.Hand\nimport net.minecraft.util.function.BooleanBiFunction\nimport net.minecraft.util.hit.BlockHitResult\nimport net.minecraft.util.math.BlockPos\nimport net.minecraft.util.math.Direction\nimport net.minecraft.util.shape.VoxelShape\nimport net.minecraft.util.shape.VoxelShapes\nimport net.minecraft.world.BlockView\nimport net.minecraft.world.World\nimport net.minecraft.world.WorldAccess\nimport net.minecraft.world.chunk.Chunk\nimport java.util.stream.Stream\n\nclass TankBlock(settings: Settings) : Block(settings), BlockEntityProvider {\n\n init {\n this.defaultState = stateManager.defaultState.with(UP, false).with(DOWN, false)\n }\n\n override fun appendProperties(builder: StateManager.Builder?) {\n builder?.add(UP, DOWN)\n }\n\n override fun createBlockEntity(pos: BlockPos, state: BlockState): BlockEntity = TankBlockEntity(pos, state)\n\n override fun