Compare commits

..
107 Commits
Author SHA1 Message Date
miozune 7834d72ecf RecipeCatalyst Enhancements (#199)
* Fix serial handlers not searching catalysts

* Prevent null stack from being added

* Prevent duplicate stack from being added

* Prevent empty handlerID from being added

* Extract code to get modded items

* Use HANDLER_ID_FUNCTION to determine handler's id
This allows mods that don't implement getOverlayIdentifier to work with

* Implement priority

* Fix typo

* Allow catalysts to be loaded from csv
Add IC2 catalysts

* minor cleanup

* Add Avaritia, BM, Forestry

* Log if TransferRects fail

* Implement removing catalyst

* Add placeholder for version controlling

* Add a BUNCH of catalysts

* Add Schematics

* Add more NASA

* Add way to resolve conflict with handlerID
resolve conflict between IC2 Compressor and Mekanism Osmium Compressor

* Add more catalysts

* Add ALL GT catalysts

* Add more

* temporary "fix" for item rendering
reverts 9bbdd7b174

* enable by default

* forgot this one

* Add ability to skip search for catalysts

* resolve some todos
2022-01-30 17:01:12 +01:00
DrParadox7 3ced04b4d3 Updates Handlers
Adds icons for:
-EtFuturum Requiem
-Modular Powersuits
-Metallurgy 4
-Nuclearcraft

Fixes Nuclearcraft's Workspace recipes not displaying correctly
2022-01-27 08:03:21 -08:00
Jason Mitchell 75c02f0357 Adds a few more methods that weren't implemented and at least one that NEI relied on (addFirst was really the only one I found) 2022-01-26 23:34:29 -08:00
Glease 51ea8bba34 Add final modifiers on those handlers fields
Also added an optional asm transformer to catch potential problems
2022-01-26 20:54:04 -08:00
Glease b0c6f358f7 Use copy on write lists for handler lists 2022-01-26 20:54:04 -08:00
miozune c73edaa72e Use String key for RecipeCatalyst instead of IRecipeHandler.class (#197)
* Use String key for RecipeCatalyst instead of IRecipeHandler.class

* deprecate old methods

* delete commented out code
2022-01-22 23:37:54 +01:00
Jason Mitchell caebccc1fd update buildscript again 2022-01-22 09:45:21 -08:00
Jason Mitchell a0c5ea42b9 update buildscript 2022-01-21 22:49:59 -08:00
Jason Mitchell 23d4be06e8 update buildscript 2022-01-21 21:50:17 -08:00
miozune 1e36822fa4 Add RecipeCatalyst system (#195)
* Add RecipeCatalyst system
2022-01-21 20:16:28 -08:00
Jason Mitchell 3ce702343d update buildscript - publish shaded jars properly 2022-01-17 21:46:41 -08:00
Jason Mitchell a3387f0290 update and pin dependencies 2022-01-17 20:27:25 -08:00
Jason Mitchell 116b96f67b maven publish buildscript update 2022-01-17 20:27:25 -08:00
makamys 60fe49d18c Make item loading timeout configurable 2022-01-17 12:39:11 -08:00
slprimeandSerghei Borovetchi cab0aff563 Мove bookmarks.ini (#194)
* move bookmarks.ini

* add world specific bookmarks option

Co-authored-by: Serghei Borovetchi <[email protected]>
2022-01-09 09:05:30 -08:00
slprimeandSerghei Borovetchi 144a37cebb Fix crash with null fluid stack (#193)
* fix crash with null fluid stack

* change minimum stack size in bookmarks

Co-authored-by: Serghei Borovetchi <[email protected]>
2022-01-07 09:06:05 -08:00
Jason Mitchell 2d18dcf42b Small bug fixes 2022-01-04 21:46:46 -08:00
Serghei Borovetchi 5bbcc570f9 fix save last bookmarks set 2022-01-04 09:20:34 -08:00
Serghei Borovetchi 98c9f03e74 d&d to search input; fix giveStack; change grid size 2022-01-03 09:44:33 -08:00
slprimeandSerghei Borovetchi 5dde7cad8b NEI Bookmarks improvements (#188)
* Add bookmarks sets; save items count in bookmarks; change counts in bookmarks; save ingredients in bookmarks; fill fluidcontainers in bookmarks;
* change fill container controls
* fix fill container
* rollback public variables

Co-authored-by: Serghei Borovetchi <[email protected]>
2022-01-02 13:30:54 -08:00
miozune ce17ec8026 Add harvestcraft Garden handler (#187) 2021-12-31 14:49:15 -08:00
Kiwiand[Kiwi233] 63f49a5e4a Update zh_CN.lang (#186)
* Update zh_CN.lang

* Update zh_CN.lang

Co-authored-by: [Kiwi233] <[[email protected]]>
2021-12-30 14:47:30 +01:00
bombcar e2a9d02c4c fix derpendencies.info (#185) 2021-12-26 09:51:14 -08:00
bombcar 6695185c54 Dependencies (#183)
* upgradebuild script
* allow NEI to load without GTNH
2021-12-21 08:36:49 -08:00
Martin Robertz e5b8a4c9c9 ignore bat files 2021-12-11 20:00:21 +01:00
Johann Bernhardt 60d033e879 Update build script and CI (#178) 2021-11-30 15:51:00 +01:00
Jason Mitchell 0310b4177f * Change default max handlers to page to 1
* Add bigger crafting table Handler Info
2021-11-29 21:33:11 -08:00
D-Cysteine 304cc12750 Add regex support for height hack handlers config (#177)
* Make handler height hack configured via regex
2021-11-28 14:25:48 -08:00
Johann Bernhardt a7ca6c8527 Unified build script (#175)
* Update build script
* Update build script to import fix for shadow in dev and sources artifacts
* Update fixed build script to shadow csv dependency in dev jar as well
* Moved jitpack
* Move new files
2021-11-22 08:56:35 -08:00
Jason Mitchell 43b71b1de6 Update build.properties 2021-11-21 19:31:57 -08:00
slprimeandSerghei Borovetchi b6070dd508 Bookmarks Improvements (#174)
* Add Drag&Drop (sorting items) in bookmarks
* save recipes in bookmarks
* Add possibility to extend bookmarks save/restore functions; in future supports GT++ fluids
* change items sorting algorithm
* add NBT support for different bookmarks
* change saving recipe algorithm
* save correct number type in bookmarks.ini

Co-authored-by: Serghei Borovetchi <[email protected]>
2021-11-21 19:31:02 -08:00
Prometheus0000 492c99b8e3 Fix crash (#166)
* Fix server crash
2021-10-18 19:43:19 -04:00
D-Cysteine 4fc368135d Fix height hack and add ordering config (#165)
* Fix height hack and add ordering config

* Use AutoCloseable for height hack

* Address comments
2021-10-16 19:31:43 +02:00
D-Cysteine 58117fa368 Some changes to NEI that are needed by NEI Custom Diagram (#163)
* Add IRecipeHandler support for handling mouse scrollwheel
* Add accessors for handler and recipe indices
* Make Shift+R not be handled as U
* Clean up redundant code
2021-09-30 21:17:14 -07:00
Prometheus0000 db339e94f4 Add yshifts 2021-09-30 21:14:57 -07:00
Jason Mitchell 7126a6d3b0 Bump mod version 2021-09-24 16:46:02 -07:00
D-Cysteine b00f4d1514 Add back in removed unused public methods, which were actually used by some NEI add-ons (#162)
* Fix compatibility with add-ons by re-adding unused public methods
2021-09-24 06:50:34 -07:00
GlodBlock 5b3a255be9 attampt to fix imc (#161)
* attampt to fix imc
2021-09-22 23:38:53 -07:00
Glease 65710c959a Prevent the load of client only classes on dedicated servers 2021-09-15 21:49:58 -07:00
makamys 95ee685b93 Preserve BossStatus#hasColorModifier when rendering spawners
Fixes wither spawner dimming screen (https://github.com/Chicken-Bones/NotEnoughItems/issues/80)
2021-09-14 12:01:36 -07:00
Glease 888f86f2da Remove IMC hack 2021-08-26 12:21:46 -07:00
D-Cysteine b4780716ec Add support for custom handler IDs (#154)
* Always show quantity text box

* Increment version

* Properly fix quantity text field

* Add support for custom handler names

* Add overloads
2021-08-25 06:14:34 +02:00
Andrey 52fb89daf6 Add builder for use in NEIRegisterHandlerInfosEvent (#153) 2021-08-22 10:16:15 -07:00
D-Cysteine dd18d2b775 Properly fix NEI quantity text field behavior (#152)
* Always show quantity text box
* Increment version
* Properly fix quantity text field
2021-08-22 10:15:23 -07:00
DreamMasterXXL 1cf8f4c1d2 bump version 2021-08-14 21:44:47 +02:00
D-Cysteine a016795056 Always show quantity text box (#150) 2021-08-14 21:42:11 +02:00
Andrey f8d492e5f5 Added couple of useful events (#149)
* Added some useful events
* 2.1.8
2021-08-13 12:49:00 -07:00
TimeConqueror 8b073543b3 Added shaded libs to dev-jar 2021-08-13 12:48:31 -07:00
Jason Mitchell 8ef7978044 Add toString() for PositionedStack 2021-08-08 11:56:59 -07:00
YuRaNnNzZZ afd25919c5 added more handlers (gt4, td covers and NER) (#146) 2021-08-04 18:00:34 +02:00
Kiwiand[Kiwi233] 1bd64bc1b8 Update zh_CN.lang (#145)
Co-authored-by: [Kiwi233] <[[email protected]]>
2021-08-02 15:11:34 +02:00
Martin Robertz 45d0621da4 Merge pull request #144 from D-Cysteine/master
Wrap string with comma in double-quotes
2021-08-01 10:21:51 +02:00
D-Cysteine 4a34aa1796 Wrap string with comma in double-quotes 2021-08-01 00:42:15 -06:00
Jason Mitchell fe7066eeb8 Bmp version 2021-07-07 00:00:31 -07:00
Glease c80ab9d6ab fix tab icon lighting
Signed-off-by: Glease <[email protected]>
2021-07-07 00:00:00 -07:00
Jakub Szewczyk 475fda6ceb Don't take ghost slots into account when looking for present items (#136)
Fixes always-present items in forestry worktables
2021-06-14 17:14:06 -07:00
Jason Mitchell ae2cc2c600 Fix some CMEs that pop up when opening inventory immediately after logging in. (#135) 2021-06-05 19:47:58 +02:00
Jason Mitchell 37a571d878 Version bump 2021-05-23 09:55:18 -07:00
GlodBlock 3c9b801e74 add handle for Naquadah Fuel Refine Factory (#132) 2021-05-22 21:07:38 -07:00
Jakub Szewczyk e123ab2f30 Add JEI-style item presence overlay when hovering over the ? button (#130)
Indicates which items are missing and which ones are present in your inventory with small X/checkmark symbols when you hover over the ? button in a recipe gui.
2021-05-22 10:31:40 -07:00
Jason Mitchell 5fdb5824df Fix crash with TC NEI & other handlers with null or short/empty getRecipeName() 2021-05-16 10:27:37 -07:00
Prometheus0000 344b22a322 Trim whitespaces before and after in handler name 2021-05-15 18:02:01 -04:00
PanSzelescik ae1d0d9bba Add new handlers, and change display names (#113)
* Add some handlers and change mod names
* Fix comments
* Revert AE icons
* Fix Mekanism block in Minechem handler
* Quotes
Co-authored-by: Jason Mitchell <[email protected]>
2021-05-02 13:35:38 -07:00
GlodBlock 079835e5d0 add handler for large naquadah reactor 2021-04-26 19:32:22 -07:00
Jason Mitchell a8919dcd95 Fixes
* Handle NBTByte Arrays
* Update height for OC handlers
2021-04-18 16:06:17 -07:00
Jason Mitchell a88a13e7cf Use a config file instead of a hardcoded list so modpacks can customize it. Defaults to BloodMagic "NEIAlchemyRecipeHandler" for non GTNH usage. 2021-04-13 20:54:11 -07:00
Jason Mitchell 8bdcf65250 Add the ability to force recipe/usage handlers to run in serial. Should fix the BM CME. 2021-04-13 20:54:11 -07:00
Jason Mitchell 2e786d1807 2.1.0-GTNH Release 2021-04-12 20:20:36 -07:00
Jason Mitchell 61d6525756 Extend the xor NBT NULL check for any items with a max stack of 1, which should also catch gt6 tools 2021-04-12 20:20:36 -07:00
Jason Mitchell 8790c7f541 Overlap Adjustment
* (Hopefully) Properly handle ItemPanel overlap with multiple recipes on the page
2021-04-12 20:20:36 -07:00
Jason Mitchell 461ac036df Backport Add ability to disable and invert inventory scroll transfer. https://github.com/TheCBProject/NotEnoughItems/commit/7943831c2a8898fd6805d39fba57397742ba37f9 2021-04-12 20:20:36 -07:00
Jason Mitchell d575de33fe IMCHandler
* Add IMCHandler w/ `registerHandlerInfo` & `removeHandlerInfo` (NBT) message handling
2021-04-12 20:20:36 -07:00
Jason Mitchell c3e35f8643 Make overlay handlers work with GT items 2021-04-12 20:20:36 -07:00
Jason Mitchell f94395f453 New mod support
* Botania * Project E - Thanks to Glowredman
* TFC+ & Immersive Engineering - Thanks to FaceTorched
2021-04-12 20:20:36 -07:00
Jason Mitchell 63d6d20c96 Beta13:
* @Mod->item searching has been added using item subsets, allowing for things like `@Blocks.MobSpawners->zombie`
* DoubleFilteredFilter - Requires both filters to apply (Subset & Pattern)
* Finally updated the README.md
2021-04-12 20:20:36 -07:00
Jason Mitchell 427793b41d Better subset layout fix 2021-04-12 20:20:36 -07:00
Jason Mitchell f6c59d7a18 Fix NPE during data dump 2021-04-12 20:20:36 -07:00
Jason Mitchell 0e3507de0a Hax to fix fluid tooltip rendering for forestry & ticon 2021-04-12 20:20:36 -07:00
Jason Mitchell 5bfbf250cc The subset dropdown now shows only when the bookmarks aren't visible (there isn't enough room for it otherwise). 2021-04-12 20:20:36 -07:00
Jason Mitchell c0be69f85f handler updates 2021-04-12 20:20:36 -07:00
Jason Mitchell 934eb26249 Overlay buttons visible again 2021-04-12 20:20:36 -07:00
Jason Mitchell 69ab51bd22 Hopefully fix backwards compat
* Revert an unnecessary field movement
2021-04-12 20:20:36 -07:00
Jason Mitchell b679b65beb Handler tweaks
* Add GT6 handler info (Thanks @Miradae)
* Move afuels back to FurnaceHandler and statically reference it from TemplateRecipeHandler  **Should** fix #84
2021-04-12 20:20:36 -07:00
Jason Mitchell 9a21acd283 Default HandlerInfo if it can't be found. 2021-04-12 20:20:36 -07:00
Jason Mitchell 429f2f36a9 Introduce HandlerInfo
* Switch handler info loading from code to CSV
 * Add option to load from config or JAR
 * handlers.csv is still a WIP
2021-04-12 20:20:36 -07:00
Jason Mitchell 509078da35 GUI Scaling
* Recipe GUI now scales with window size, and displays more than 2 recipes per page, depending on height.
* Hacks to implement recipes per page, based on some assumptions since the height of the handlers are not exposed and are hardcoded
* _Temporarily_ disabled the overlay buttons; they were hardcoded to expect at most 2, need to make them dynamic and actually work again.
2021-04-12 20:20:36 -07:00
Prometheus0000 a6b306263d Fixes some handler bugs (#73)
* Fixes some handler images
* Fixed some handlers not having the right image or being in the right section

Basically just GT/BW/GT++. I also added some spaces to look nicer, and reorganized the GT/BW/GT++ a little.
2021-04-12 20:20:36 -07:00
Jason Mitchell 2162b43aa7 Reorg & restyle GuiRecipe to look a bit more like JEI
Add gregtech hax to avoid overlapping
2021-04-12 20:20:36 -07:00
Jason Mitchell 7c334d32c2 Shift everything instead of conditionally 2021-04-12 20:20:36 -07:00
Lex 8a8f2fd87a shift of the bookmark border 2021-04-12 20:20:36 -07:00
Jason Mitchell 2ae5607a60 fixes beta3 2021-04-12 20:20:36 -07:00
Jason Mitchell 0f1333b308 Bugfixes 2021-04-12 20:20:36 -07:00
Jason Mitchell d645732eb3 Fix IOOBE. 2021-04-12 20:20:36 -07:00
Jason Mitchell 371337cf77 Angry Boubs 2021-04-12 20:20:36 -07:00
Jason Mitchell 4fb83ddea6 Add option to switch between JEI tab style and Creative tab style 2021-04-12 20:20:36 -07:00
Léa Gris a14d70ee8f impr(tab): user creative inventory tab asset and layout
This allow proprely textured GUI without the need to update a resourcepack.
2021-04-12 20:20:36 -07:00
Jason Mitchell 6279149b21 DrawableResource from JEI. Swap out tab & tab icon drawing. 2021-04-12 20:20:36 -07:00
Léa Gris 2a667e1942 refactor: override draw with correct signature 2021-04-12 20:20:36 -07:00
Jason Mitchell c9bf943fb9 Fix crash on bookmark toggle
Fixes #53
2021-04-12 20:20:36 -07:00
Jason Mitchell 14a2dec34e JEI Style Tabs 2021-04-12 20:20:36 -07:00
Jason Mitchell 368a134f92 Prevent bookmarks from overlapping the armor slots on Creative+ mode 2021-04-12 20:20:36 -07:00
Jason Mitchell 68becd6fd6 Add bookmark toggle button.
Switch config button to JEI style, and add ctrl+click to cycle recipe, utility, and cheat mode.
2021-04-12 20:20:36 -07:00
Jason Mitchell fe83411c57 Enable bookmark panel hiding 2021-04-12 20:20:36 -07:00
Jason Mitchell 40ff91a908 Update build script and gradle 2021-04-12 20:20:36 -07:00
Jason Mitchell ca9c2a4052 Switch hiddenItems from synchronized to using a ReentrantReadWriteLock with a tryLock. 2021-02-20 21:19:18 -08:00
Jason Mitchell 34b9998ba3 Don't crash with divide by zero error 2021-02-14 15:42:22 -08:00
Jason Mitchell ebbfd349f2 Custom NBT <> JSON Encoder - Fix bookmark saving of items that require escaping 2021-02-14 10:10:53 -08:00
213 changed files with 8899 additions and 2247 deletions

No files matched your search

+9
View File
@@ -0,0 +1,9 @@
directory="run/crash-reports"
if [ -d $directory ]; then
echo "Crash reports detected:"
cat $directory/*
exit 1
else
echo "No crash reports detected"
exit 0
fi
+45
View File
@@ -0,0 +1,45 @@
# This workflow will build a Java project with Gradle and cache/restore any dependencies to improve the workflow execution time
# For more information see: https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-gradle
name: Build and test
on:
pull_request:
branches: [ master, main ]
push:
branches: [ master, main ]
jobs:
build-and-test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
with:
fetch-depth: 0
- name: Set up JDK 8
uses: actions/setup-java@v2
with:
java-version: '8'
distribution: 'adopt'
cache: gradle
- name: Grant execute permission for gradlew
run: chmod +x gradlew
- name: Setup the workspace
run: ./gradlew setupCIWorkspace
- name: Build the mod
run: ./gradlew build
- name: Run server for 1 minute
run: |
mkdir run
echo "eula=true" > run/eula.txt
timeout 10 ./gradlew runServer || true
- name: Test no crashes happend
run: |
chmod +x .github/scripts/test-no-crash-reports.sh
.github/scripts/test-no-crash-reports.sh
+51
View File
@@ -0,0 +1,51 @@
# This workflow will build a Java project with Gradle and cache/restore any dependencies to improve the workflow execution time
# For more information see: https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-gradle
name: Release tagged build
on:
push:
tags:
- '*'
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
with:
fetch-depth: 0
- name: Set release version
run: echo "RELEASE_VERSION=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
- name: Set up JDK 8
uses: actions/setup-java@v2
with:
java-version: '8'
distribution: 'adopt'
cache: gradle
- name: Grant execute permission for gradlew
run: chmod +x gradlew
- name: Setup the workspace
run: ./gradlew setupCIWorkspace
- name: Build the mod
run: ./gradlew build
- name: Release under current tag
uses: "marvinpinto/action-automatic-releases@latest"
with:
repo_token: "${{ secrets.GITHUB_TOKEN }}"
automatic_release_tag: "${{ env.RELEASE_VERSION }}"
prerelease: false
title: "${{ env.RELEASE_VERSION }}"
files: build/libs/*.jar
- name: Publish to Maven
run: ./gradlew publish
env:
MAVEN_USER: ${{ secrets.MAVEN_USER }}
MAVEN_PASSWORD: ${{ secrets.MAVEN_PASSWORD }}
+26 -9
View File
@@ -1,12 +1,29 @@
./build/
NotEnoughItems.iml
NotEnoughItems.ipr
NotEnoughItems.iws
*.ipr
.gradle
.settings
/.idea/
/run/
/build/
/eclipse/
.classpath
.project
/bin/
/config/
/crash-reports/
/logs/
options.txt
/saves/
usernamecache.json
banned-ips.json
banned-players.json
eula.txt
ops.json
server.properties
servers.dat
usercache.json
whitelist.json
/out/
*.iml
*.ipr
*.iws
.idea/**
run/*
.gradle/
src/main/resources/mixins.*.json
*.bat
+3
View File
@@ -0,0 +1,3 @@
# Any Github changes require admin approval
/.github/** @GTNewHorizons/admin
+11 -3
View File
@@ -1,4 +1,4 @@
# NotEnoughItems - GTNH
# NotEnoughItems Unofficial - By the GTNH Team
A continuation of NotEnoughItems for 1.7.10 by the developers of Gregtech: New Horizons modpack, with features either inspired and/or backported from JustEnoughItems
@@ -10,12 +10,20 @@ We've tested this against all of the mods included in GTNH, as well as a limited
## New Features:
* Speed - Uses a parallel stream to search the item list over multiple cores, resulting in 2-6x faster searches on average [Feels instantaneous]
* Speed
- Uses a parallel stream to search the item list over multiple cores, resulting in 2-6x faster searches on average
- Loads the recipe handlers in parallel
* A textbox for search with most of the features you'd expect - moving forward, backwards, selection, etc
* Bookmarks! What are you in the process of crafting? Bookmark it using either 'A' or configure your own key.
* Toggle bookmark pane. Default shortcut key `B`. Item Subsets menu is only available if bookmarks are not visible.
* Utility/Cheat buttons line up and wrap based on GUI size
* ItemList is no longer regenerated from the ItemRegistry on every inventory load
* JEI (Or Creative) Style tabs [Optional] Note: Requires explicit support to be added for an ItemStack to render, otherwise falls back to the first two letters of the handler name.
* Tabs/Handlers are loaded from a CSV config in the JAR (or optionally from the config folder). NBT IMCEvents `registerHandlerInfo` and `removeHandlerInfo` are available for mod authors to add handler information, using the same fields as the CSV file
* `@[Mod]->[item]` searching. ex: `@Mod.gregtech->iron ingot`
* Cycle between Recipe, Utility, and Cheat mode by ctrl clicking on the Wrench Icon
* GT5u Tools/Items and GT6 tools should now properly work with the Overlay Recipe Transfer
## Other items of note:
* Licensed under LGPL - Use this however you want, but please give back any modifications
+604 -81
View File
@@ -1,130 +1,653 @@
//version: 1642872913
/*
DO NOT CHANGE THIS FILE!
Also, you may replace this file at any time if there is an update available.
Please check https://github.com/GTNewHorizons/ExampleMod1.7.10/blob/main/build.gradle for updates.
*/
import com.github.jengelman.gradle.plugins.shadow.tasks.ConfigureShadowRelocation
import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
import java.util.concurrent.TimeUnit
buildscript {
repositories {
mavenCentral()
maven {
name = "forge"
url = "http://files.minecraftforge.net/maven"
url = "https://maven.minecraftforge.net"
}
maven {
name = "sonatype"
url = "https://oss.sonatype.org/content/repositories/snapshots/"
}
maven {
name = "Scala CI dependencies"
url = "https://repo1.maven.org/maven2/"
}
maven {
name = "jitpack"
url = "https://jitpack.io"
}
}
dependencies {
classpath 'net.minecraftforge.gradle:ForgeGradle:1.2-SNAPSHOT'
classpath 'com.github.GTNewHorizons:ForgeGradle:1.2.5'
}
}
//add dependency repositories
repositories {
maven {
name = "chickenbones"
url = "http://chickenbones.net/maven"
}
plugins {
id 'idea'
id 'eclipse'
id 'scala'
id("org.ajoberstar.grgit") version("3.1.1")
id("com.github.johnrengelman.shadow") version("4.0.4")
id("com.palantir.git-version") version("0.12.3")
id('de.undercouch.download') version('4.1.2')
id("maven-publish")
}
apply plugin: 'forge'
group = "codechicken" // http://maven.apache.org/guides/mini/guide-naming-conventions.html
archivesBaseName = "NotEnoughItems"
def projectJavaVersion = JavaLanguageVersion.of(8)
// Define properties file
ext.configFile = file "build.properties"
java {
toolchain {
languageVersion.set(projectJavaVersion)
}
}
configFile.withReader {
// Load config. It shall from now be referenced as simply config or project.config
def prop = new Properties()
prop.load(it)
project.ext.config = new ConfigSlurper().parse prop
idea {
module {
inheritOutputDirs = true
downloadJavadoc = true
downloadSources = true
}
}
if(JavaVersion.current() != JavaVersion.VERSION_1_8) {
throw new GradleException("This project requires Java 8, but it's running on " + JavaVersion.current())
}
checkPropertyExists("modName")
checkPropertyExists("modId")
checkPropertyExists("modGroup")
checkPropertyExists("autoUpdateBuildScript")
checkPropertyExists("minecraftVersion")
checkPropertyExists("forgeVersion")
checkPropertyExists("replaceGradleTokenInFile")
checkPropertyExists("gradleTokenModId")
checkPropertyExists("gradleTokenModName")
checkPropertyExists("gradleTokenVersion")
checkPropertyExists("gradleTokenGroupName")
checkPropertyExists("apiPackage")
checkPropertyExists("accessTransformersFile")
checkPropertyExists("usesMixins")
checkPropertyExists("mixinPlugin")
checkPropertyExists("mixinsPackage")
checkPropertyExists("coreModClass")
checkPropertyExists("containsMixinsAndOrCoreModOnly")
checkPropertyExists("usesShadowedDependencies")
checkPropertyExists("developmentEnvironmentUserName")
boolean noPublishedSources = project.findProperty("noPublishedSources") ? project.noPublishedSources.toBoolean() : false
String javaSourceDir = "src/main/java/"
String scalaSourceDir = "src/main/scala/"
String targetPackageJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/")
String targetPackageScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/")
if((getFile(targetPackageJava).exists() || getFile(targetPackageScala).exists()) == false) {
throw new GradleException("Could not resolve \"modGroup\"! Could not find " + targetPackageJava + " or " + targetPackageScala)
}
if(apiPackage) {
targetPackageJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + apiPackage.toString().replaceAll("\\.", "/")
targetPackageScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + apiPackage.toString().replaceAll("\\.", "/")
if((getFile(targetPackageJava).exists() || getFile(targetPackageScala).exists()) == false) {
throw new GradleException("Could not resolve \"apiPackage\"! Could not find " + targetPackageJava + " or " + targetPackageScala)
}
}
if(accessTransformersFile) {
String targetFile = "src/main/resources/META-INF/" + accessTransformersFile
if(getFile(targetFile).exists() == false) {
throw new GradleException("Could not resolve \"accessTransformersFile\"! Could not find " + targetFile)
}
}
if(usesMixins.toBoolean()) {
if(mixinsPackage.isEmpty() || mixinPlugin.isEmpty()) {
throw new GradleException("\"mixinPlugin\" requires \"mixinsPackage\" and \"mixinPlugin\" to be set!")
}
targetPackageJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinsPackage.toString().replaceAll("\\.", "/")
targetPackageScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinsPackage.toString().replaceAll("\\.", "/")
if((getFile(targetPackageJava).exists() || getFile(targetPackageScala).exists()) == false) {
throw new GradleException("Could not resolve \"mixinsPackage\"! Could not find " + targetPackageJava + " or " + targetPackageScala)
}
String targetFileJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinPlugin.toString().replaceAll("\\.", "/") + ".java"
String targetFileScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinPlugin.toString().replaceAll("\\.", "/") + ".scala"
String targetFileScalaJava = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinPlugin.toString().replaceAll("\\.", "/") + ".java"
if((getFile(targetFileJava).exists() || getFile(targetFileScala).exists() || getFile(targetFileScalaJava).exists()) == false) {
throw new GradleException("Could not resolve \"mixinPlugin\"! Could not find " + targetFileJava + " or " + targetFileScala + " or " + targetFileScalaJava)
}
}
if(coreModClass) {
String targetFileJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + coreModClass.toString().replaceAll("\\.", "/") + ".java"
String targetFileScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + coreModClass.toString().replaceAll("\\.", "/") + ".scala"
String targetFileScalaJava = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + coreModClass.toString().replaceAll("\\.", "/") + ".java"
if((getFile(targetFileJava).exists() || getFile(targetFileScala).exists() || getFile(targetFileScalaJava).exists()) == false) {
throw new GradleException("Could not resolve \"coreModClass\"! Could not find " + targetFileJava + " or " + targetFileScala + " or " + targetFileScalaJava)
}
}
configurations.all {
resolutionStrategy.cacheChangingModulesFor(0, TimeUnit.SECONDS)
// Make sure GregTech build won't time out
System.setProperty("org.gradle.internal.http.connectionTimeout", 120000 as String)
System.setProperty("org.gradle.internal.http.socketTimeout", 120000 as String)
}
// Fix Jenkins' Git: chmod a file should not be detected as a change and append a '.dirty' to the version
'git config core.fileMode false'.execute()
// Pulls version first from the VERSION env and then git tag
String identifiedVersion
try {
String versionOverride = System.getenv("VERSION") ?: null
identifiedVersion = versionOverride == null ? gitVersion() : versionOverride
version = minecraftVersion + "-" + identifiedVersion
}
catch (Exception e) {
throw new IllegalStateException("This mod must be version controlled by Git AND the repository must provide at least one tag, or the VERSION override must be set!");
}
group = modGroup
if(project.hasProperty("customArchiveBaseName") && customArchiveBaseName) {
archivesBaseName = customArchiveBaseName
}
else {
archivesBaseName = modId
}
minecraft {
version = minecraftVersion + "-" + forgeVersion + "-" + minecraftVersion
runDir = "run"
if (replaceGradleTokenInFile) {
replaceIn replaceGradleTokenInFile
if(gradleTokenModId) {
replace gradleTokenModId, modId
}
if(gradleTokenModName) {
replace gradleTokenModName, modName
}
if(gradleTokenVersion) {
replace gradleTokenVersion, versionDetails().lastTag
}
if(gradleTokenGroupName) {
replace gradleTokenGroupName, modGroup
}
}
}
if(file("addon.gradle").exists()) {
apply from: "addon.gradle"
}
apply from: 'repositories.gradle'
configurations {
implementation.extendsFrom(shadowImplementation) // TODO: remove after all uses are refactored
implementation.extendsFrom(shadowCompile)
implementation.extendsFrom(shadeCompile)
}
repositories {
maven {
name = "Overmind forge repo mirror"
url = "https://gregtech.overminddl1.com/"
}
if(usesMixins.toBoolean()) {
maven {
name = "sponge"
url = "https://repo.spongepowered.org/repository/maven-public"
}
maven {
url = "https://jitpack.io"
}
}
}
dependencies {
compile "codechicken:CodeChickenLib:${config.mc_version}-${config.ccl_version}:dev"
compile "codechicken:CodeChickenCore:${config.mc_version}-${config.ccc_version}:dev"
}
version = "${project.config.mod_version}"
sourceCompatibility = JavaVersion.VERSION_1_8
targetCompatibility = JavaVersion.VERSION_1_8
sourceCompatibility = 1.8
targetCompatibility = 1.8
println config.mc_version + "-" + config.forge_version
// Setup the forge minecraft plugin data. Specify the preferred forge/minecraft version here
minecraft {
version = config.mc_version + "-" + config.forge_version
}
def root = project.projectDir;
sourceSets {
main {
java {
srcDir new File(root, "src")
}
resources {
srcDir new File(root, "resources")
if(usesMixins.toBoolean()) {
annotationProcessor("org.ow2.asm:asm-debug-all:5.0.3")
annotationProcessor("com.google.guava:guava:24.1.1-jre")
annotationProcessor("com.google.code.gson:gson:2.8.6")
annotationProcessor("org.spongepowered:mixin:0.8-SNAPSHOT")
// using 0.8 to workaround a issue in 0.7 which fails mixin application
compile("com.github.GTNewHorizons:SpongePoweredMixin:0.7.12-GTNH") {
// Mixin includes a lot of dependencies that are too up-to-date
exclude module: "launchwrapper"
exclude module: "guava"
exclude module: "gson"
exclude module: "commons-io"
exclude module: "log4j-core"
}
compile("com.github.GTNewHorizons:SpongeMixins:1.5.0")
}
}
processResources {
//redo task if any of these properties change
inputs.property "version", project.version
inputs.property "mc_version", config.mc_version
apply from: 'dependencies.gradle'
// Replace properties in info files
from(sourceSets.main.resources.srcDirs) {
include '*.info'
expand 'version':project.version,'mc_version':config.mc_version
}
def mixingConfigRefMap = "mixins." + modId + ".refmap.json"
def refMap = "${tasks.compileJava.temporaryDir}" + File.separator + mixingConfigRefMap
def mixinSrg = "${tasks.reobf.temporaryDir}" + File.separator + "mixins.srg"
// Move access transformer to META-INF
rename '(.+_at.cfg)', 'META-INF/$1'
task generateAssets {
if(usesMixins.toBoolean()) {
getFile("/src/main/resources/mixins." + modId + ".json").text = """{
"required": true,
"minVersion": "0.7.11",
"package": "${modGroup}.${mixinsPackage}",
"plugin": "${modGroup}.${mixinPlugin}",
"refmap": "${mixingConfigRefMap}",
"target": "@env(DEFAULT)",
"compatibilityLevel": "JAVA_8"
}
version = "${project.minecraft.version}-${project.version}"
def commonManifest = {
attributes 'FMLCorePlugin': 'codechicken.nei.asm.NEICorePlugin'
attributes 'FMLAT': 'nei_at.cfg'
"""
}
}
task relocateShadowJar(type: ConfigureShadowRelocation) {
target = tasks.shadowJar
prefix = modGroup + ".shadow"
}
shadowJar {
project.configurations.shadeCompile.each { dep ->
from(project.zipTree(dep)) {
exclude 'META-INF', 'META-INF/**'
}
}
manifest {
attributes(getManifestAttributes())
}
minimize() // This will only allow shading for actually used classes
configurations = [project.configurations.shadowImplementation, project.configurations.shadowCompile]
dependsOn(relocateShadowJar)
}
jar {
classifier = 'universal'
manifest commonManifest
project.configurations.shadeCompile.each { dep ->
from(project.zipTree(dep)) {
exclude 'META-INF', 'META-INF/**'
}
}
manifest {
attributes(getManifestAttributes())
}
if(usesShadowedDependencies.toBoolean()) {
dependsOn(shadowJar)
enabled = false
}
}
task sourceJar(type: Jar) {
from sourceSets.main.java
from new File(root, "dev")
classifier = 'src'
reobf {
if(usesMixins.toBoolean()) {
addExtraSrgFile mixinSrg
}
}
afterEvaluate {
if(usesMixins.toBoolean()) {
tasks.compileJava {
options.compilerArgs += [
"-AreobfSrgFile=${tasks.reobf.srg}",
"-AoutSrgFile=${mixinSrg}",
"-AoutRefMapFile=${refMap}",
// Elan: from what I understand they are just some linter configs so you get some warning on how to properly code
"-XDenableSunApiLintControl",
"-XDignore.symbol.file"
]
}
}
}
runClient {
def arguments = []
if(usesMixins.toBoolean()) {
arguments += [
"--mods=../build/libs/$modId-${version}.jar",
"--tweakClass org.spongepowered.asm.launch.MixinTweaker"
]
}
if(developmentEnvironmentUserName) {
arguments += [
"--username",
developmentEnvironmentUserName
]
}
args(arguments)
}
runServer {
def arguments = []
if (usesMixins.toBoolean()) {
arguments += [
"--mods=../build/libs/$modId-${version}.jar",
"--tweakClass org.spongepowered.asm.launch.MixinTweaker"
]
}
args(arguments)
}
tasks.withType(JavaExec).configureEach {
javaLauncher.set(
javaToolchains.launcherFor {
languageVersion = projectJavaVersion
}
)
}
processResources
{
// this will ensure that this task is redone when the versions change.
inputs.property "version", project.version
inputs.property "mcversion", project.minecraft.version
// replace stuff in mcmod.info, nothing else
from(sourceSets.main.resources.srcDirs) {
include 'mcmod.info'
// replace version and mcversion
expand "minecraftVersion": project.minecraft.version,
"modVersion": versionDetails().lastTag,
"modId": modId,
"modName": modName
}
if(usesMixins.toBoolean()) {
from refMap
}
// copy everything else, thats not the mcmod.info
from(sourceSets.main.resources.srcDirs) {
exclude 'mcmod.info'
}
}
def getManifestAttributes() {
def manifestAttributes = [:]
if(containsMixinsAndOrCoreModOnly.toBoolean() == false && (usesMixins.toBoolean() || coreModClass)) {
manifestAttributes += ["FMLCorePluginContainsFMLMod": true]
}
if(accessTransformersFile) {
manifestAttributes += ["FMLAT" : accessTransformersFile.toString()]
}
if(coreModClass) {
manifestAttributes += ["FMLCorePlugin": modGroup + "." + coreModClass]
}
if(usesMixins.toBoolean()) {
manifestAttributes += [
"TweakClass" : "org.spongepowered.asm.launch.MixinTweaker",
"MixinConfigs" : "mixins." + modId + ".json",
"ForceLoadAsMod" : containsMixinsAndOrCoreModOnly.toBoolean() == false
]
}
return manifestAttributes
}
task sourcesJar(type: Jar) {
from (sourceSets.main.allJava)
from (file("$projectDir/LICENSE"))
getArchiveClassifier().set('sources')
}
task shadowDevJar(type: ShadowJar) {
project.configurations.shadeCompile.each { dep ->
from(project.zipTree(dep)) {
exclude 'META-INF', 'META-INF/**'
}
}
from sourceSets.main.output
getArchiveClassifier().set("dev")
manifest {
attributes(getManifestAttributes())
}
minimize() // This will only allow shading for actually used classes
configurations = [project.configurations.shadowImplementation, project.configurations.shadowCompile]
}
task relocateShadowDevJar(type: ConfigureShadowRelocation) {
target = tasks.shadowDevJar
prefix = modGroup + ".shadow"
}
task circularResolverJar(type: Jar) {
dependsOn(relocateShadowDevJar)
dependsOn(shadowDevJar)
enabled = false
}
task devJar(type: Jar) {
project.configurations.shadeCompile.each { dep ->
from(project.zipTree(dep)) {
exclude 'META-INF', 'META-INF/**'
}
}
from sourceSets.main.output
classifier = 'dev'
manifest commonManifest
getArchiveClassifier().set("dev")
manifest {
attributes(getManifestAttributes())
}
if(usesShadowedDependencies.toBoolean()) {
dependsOn(circularResolverJar)
enabled = false
}
}
task apiJar(type: Jar) {
from (sourceSets.main.allJava) {
include modGroup.toString().replaceAll("\\.", "/") + "/" + apiPackage.toString().replaceAll("\\.", "/") + '/**'
}
from (sourceSets.main.output) {
include modGroup.toString().replaceAll("\\.", "/") + "/" + apiPackage.toString().replaceAll("\\.", "/") + '/**'
}
from (sourceSets.main.resources.srcDirs) {
include("LICENSE")
}
getArchiveClassifier().set('api')
}
// Tell the artifact system about our extra jars
artifacts {
archives sourceJar, devJar
if(!noPublishedSources) {
archives sourcesJar
}
archives devJar
if(apiPackage) {
archives apiJar
}
}
sourceSets {
main { output.resourcesDir = output.classesDir }
// The gradle metadata includes all of the additional deps that we disabled from POM generation (including forgeBin with no groupID),
// and isn't strictly needed with the POM so just disable it.
tasks.withType(GenerateModuleMetadata) {
enabled = false
}
// Configure an upload task.
uploadArchives {
dependsOn 'reobf'
if (project.hasProperty("local_maven")) {
repositories {
logger.info('Publishing to local maven repo')
mavenDeployer {
repository(url: "file://${local_maven}")
}
}
}
// publishing
publishing {
publications {
maven(MavenPublication) {
from components.java
if(usesShadowedDependencies.toBoolean()) {
artifact source: shadowJar, classifier: ""
}
if(!noPublishedSources) {
artifact source: sourcesJar, classifier: "src"
}
artifact source: usesShadowedDependencies.toBoolean() ? shadowDevJar : devJar, classifier: "dev"
if (apiPackage) {
artifact source: apiJar, classifier: "api"
}
groupId = System.getenv("ARTIFACT_GROUP_ID") ?: "com.github.GTNewHorizons"
artifactId = System.getenv("ARTIFACT_ID") ?: project.name
// Using the identified version, not project.version as it has the prepended 1.7.10
version = System.getenv("RELEASE_VERSION") ?: identifiedVersion
// Remove all non GTNH deps here.
// Original intention was to remove an invalid forgeBin being generated without a groupId (mandatory), but
// it also removes all of the MC deps
pom.withXml {
Node pomNode = asNode()
pomNode.dependencies.'*'.findAll() {
it.groupId.text() != 'com.github.GTNewHorizons'
}.each() {
it.parent().remove(it)
}
}
}
}
repositories {
maven {
url = "http://jenkins.usrv.eu:8081/nexus/content/repositories/releases"
credentials {
username = System.getenv("MAVEN_USER") ?: "NONE"
password = System.getenv("MAVEN_PASSWORD") ?: "NONE"
}
}
}
}
// Updating
task updateBuildScript {
doLast {
if (performBuildScriptUpdate(projectDir.toString())) return
print("Build script already up-to-date!")
}
}
if (isNewBuildScriptVersionAvailable(projectDir.toString())) {
if (autoUpdateBuildScript.toBoolean()) {
performBuildScriptUpdate(projectDir.toString())
} else {
println("Build script update available! Run 'gradle updateBuildScript'")
}
}
static URL availableBuildScriptUrl() {
new URL("https://raw.githubusercontent.com/GTNewHorizons/ExampleMod1.7.10/main/build.gradle")
}
boolean performBuildScriptUpdate(String projectDir) {
if (isNewBuildScriptVersionAvailable(projectDir)) {
def buildscriptFile = getFile("build.gradle")
availableBuildScriptUrl().withInputStream { i -> buildscriptFile.withOutputStream { it << i } }
print("Build script updated. Please REIMPORT the project or RESTART your IDE!")
return true
}
return false
}
boolean isNewBuildScriptVersionAvailable(String projectDir) {
Map parameters = ["connectTimeout": 2000, "readTimeout": 2000]
String currentBuildScript = getFile("build.gradle").getText()
String currentBuildScriptHash = getVersionHash(currentBuildScript)
String availableBuildScript = availableBuildScriptUrl().newInputStream(parameters).getText()
String availableBuildScriptHash = getVersionHash(availableBuildScript)
boolean isUpToDate = currentBuildScriptHash.empty || availableBuildScriptHash.empty || currentBuildScriptHash == availableBuildScriptHash
return !isUpToDate
}
static String getVersionHash(String buildScriptContent) {
String versionLine = buildScriptContent.find("^//version: [a-z0-9]*")
if(versionLine != null) {
return versionLine.split(": ").last()
}
return ""
}
configure(updateBuildScript) {
group = 'forgegradle'
description = 'Updates the build script to the latest version'
}
// Deobfuscation
def deobf(String sourceURL, String fileName) {
def bon2File = "$projectDir/deobf/BON2-2.5.0.jar"
def cacheFile = "$projectDir/deobf/out/" + fileName + ".jar"
def deobfFile = "$projectDir/deobf/out/" + fileName + "-deobf.jar"
if(file(deobfFile).exists()) {
return files(deobfFile)
}
download {
src 'https://github.com/GTNewHorizons/BON2/releases/download/2.5.0/BON2-2.5.0.CUSTOM-all.jar'
dest bon2File
quiet true
overwrite false
}
download {
src sourceURL
dest cacheFile
quiet true
overwrite false
}
exec {
commandLine 'java', '-jar', bon2File, '--inputJar', cacheFile, '--outputJar', deobfFile, '--mcVer', '1.7.10', '--mappingsVer', 'stable_12', '--notch'
workingDir "$projectDir/deobf"
standardOutput = new ByteArrayOutputStream()
}
delete(cacheFile)
return files(deobfFile)
}
// Helper methods
def checkPropertyExists(String propertyName) {
if (project.hasProperty(propertyName) == false) {
throw new GradleException("This project requires a property \"" + propertyName + "\"! Please add it your \"gradle.properties\". You can find all properties and their description here: https://github.com/GTNewHorizons/ExampleMod1.7.10/blob/main/gradle.properties")
}
}
def getFile(String relativePath) {
return new File(projectDir, relativePath)
}
-5
View File
@@ -1,5 +0,0 @@
mc_version=1.7.10
forge_version=10.13.4.1614-1.7.10
ccl_version=1.1.3.138
ccc_version=1.0.7.+
mod_version=2.0.9-GTNH
+7
View File
@@ -0,0 +1,7 @@
// Add your dependencies here
dependencies {
compile("com.github.GTNewHorizons:CodeChickenLib:1.1.5.1:dev")
compile("com.github.GTNewHorizons:CodeChickenCore:1.1.3:dev")
shadowImplementation("org.apache.commons:commons-csv:1.5")
}
@@ -1,808 +0,0 @@
package net.minecraft.client.gui.inventory;
import codechicken.nei.guihook.GuiContainerManager;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.FontRenderer;
import net.minecraft.client.gui.GuiScreen;
import net.minecraft.client.renderer.OpenGlHelper;
import net.minecraft.client.renderer.RenderHelper;
import net.minecraft.client.renderer.texture.TextureMap;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.Container;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
import net.minecraft.util.EnumChatFormatting;
import net.minecraft.util.IIcon;
import net.minecraft.util.MathHelper;
import net.minecraft.util.ResourceLocation;
import org.lwjgl.input.Keyboard;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL12;
@SideOnly(Side.CLIENT)
public abstract class GuiContainer extends GuiScreen
{
protected static final ResourceLocation field_147001_a = new ResourceLocation("textures/gui/container/inventory.png");
/** The X size of the inventory window in pixels. */
public int xSize = 176;
/** The Y size of the inventory window in pixels. */
public int ySize = 166;
/** A list of the players inventory slots */
public Container inventorySlots;
/**
* Starting X position for the Gui. Inconsistent use for Gui backgrounds.
*/
public int guiLeft;
/**
* Starting Y position for the Gui. Inconsistent use for Gui backgrounds.
*/
public int guiTop;
private Slot theSlot;
/** Used when touchscreen is enabled. */
private Slot clickedSlot;
/** Used when touchscreen is enabled. */
private boolean isRightMouseClick;
/** Used when touchscreen is enabled */
private ItemStack draggedStack;
private int field_147011_y;
private int field_147010_z;
private Slot returningStackDestSlot;
private long returningStackTime;
/** Used when touchscreen is enabled */
private ItemStack returningStack;
private Slot field_146985_D;
private long field_146986_E;
protected final Set field_147008_s = new HashSet();
protected boolean field_147007_t;
private int field_146987_F;
private int field_146988_G;
private boolean field_146995_H;
private int field_146996_I;
private long field_146997_J;
private Slot field_146998_K;
private int field_146992_L;
private boolean field_146993_M;
private ItemStack field_146994_N;
private static final String __OBFID = "CL_00000737";
public GuiContainerManager manager;
public GuiContainer(Container par1Container)
{
this.inventorySlots = par1Container;
this.field_146995_H = true;
}
/**
* Adds the buttons (and other controls) to the screen in question.
*/
public void initGui()
{
super.initGui();
this.mc.thePlayer.openContainer = this.inventorySlots;
this.guiLeft = (this.width - this.xSize) / 2;
this.guiTop = (this.height - this.ySize) / 2;
}
/**
* Draws the screen and all the components in it.
*/
public void drawScreen(int par1, int par2, float par3)
{
manager.preDraw();
this.drawDefaultBackground();
int k = this.guiLeft;
int l = this.guiTop;
this.drawGuiContainerBackgroundLayer(par3, par1, par2);
GL11.glDisable(GL12.GL_RESCALE_NORMAL);
RenderHelper.disableStandardItemLighting();
GL11.glDisable(GL11.GL_LIGHTING);
GL11.glDisable(GL11.GL_DEPTH_TEST);
super.drawScreen(par1, par2, par3);
RenderHelper.enableGUIStandardItemLighting();
GL11.glPushMatrix();
GL11.glTranslatef((float)k, (float)l, 0.0F);
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
GL11.glEnable(GL12.GL_RESCALE_NORMAL);
this.theSlot = null;
short short1 = 240;
short short2 = 240;
OpenGlHelper.setLightmapTextureCoords(OpenGlHelper.lightmapTexUnit, (float)short1 / 1.0F, (float)short2 / 1.0F);
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
int k1;
for (int i1 = 0; i1 < this.inventorySlots.inventorySlots.size(); ++i1)
{
Slot slot = (Slot)this.inventorySlots.inventorySlots.get(i1);
this.func_146977_a(slot);
if (this.isMouseOverSlot(slot, par1, par2) && slot.func_111238_b() && !manager.objectUnderMouse(par1, par2))
{
this.theSlot = slot;
GL11.glDisable(GL11.GL_LIGHTING);
GL11.glDisable(GL11.GL_DEPTH_TEST);
int j1 = slot.xDisplayPosition;
k1 = slot.yDisplayPosition;
GL11.glColorMask(true, true, true, false);
this.drawGradientRect(j1, k1, j1 + 16, k1 + 16, -2130706433, -2130706433);
GL11.glColorMask(true, true, true, true);
GL11.glEnable(GL11.GL_LIGHTING);
GL11.glEnable(GL11.GL_DEPTH_TEST);
}
}
//Forge: Force lighting to be disabled as there are some issue where lighting would
//incorrectly be applied based on items that are in the inventory.
GL11.glDisable(GL11.GL_LIGHTING);
this.drawGuiContainerForegroundLayer(par1, par2);
GL11.glEnable(GL11.GL_LIGHTING);
manager.renderObjects(par1, par2);
InventoryPlayer inventoryplayer = this.mc.thePlayer.inventory;
ItemStack itemstack = this.draggedStack == null ? inventoryplayer.getItemStack() : this.draggedStack;
if (itemstack != null)
{
byte b0 = 8;
k1 = this.draggedStack == null ? 8 : 16;
String s = null;
if (this.draggedStack != null && this.isRightMouseClick)
{
itemstack = itemstack.copy();
itemstack.stackSize = MathHelper.ceiling_float_int((float)itemstack.stackSize / 2.0F);
}
else if (this.field_147007_t && this.field_147008_s.size() > 1)
{
itemstack = itemstack.copy();
itemstack.stackSize = this.field_146996_I;
if (itemstack.stackSize == 0)
{
s = "" + EnumChatFormatting.YELLOW + "0";
}
}
this.drawItemStack(itemstack, par1 - k - b0, par2 - l - k1, s);
}
if (this.returningStack != null)
{
float f1 = (float)(Minecraft.getSystemTime() - this.returningStackTime) / 100.0F;
if (f1 >= 1.0F)
{
f1 = 1.0F;
this.returningStack = null;
}
k1 = this.returningStackDestSlot.xDisplayPosition - this.field_147011_y;
int j2 = this.returningStackDestSlot.yDisplayPosition - this.field_147010_z;
int l1 = this.field_147011_y + (int)((float)k1 * f1);
int i2 = this.field_147010_z + (int)((float)j2 * f1);
this.drawItemStack(this.returningStack, l1, i2, (String)null);
}
GL11.glPopMatrix();
/*
if (inventoryplayer.getItemStack() == null && this.theSlot != null && this.theSlot.getHasStack())
{
ItemStack itemstack1 = this.theSlot.getStack();
this.renderToolTip(itemstack1, par1, par2);
}
*/
manager.renderToolTips(par1, par2);
GL11.glEnable(GL11.GL_LIGHTING);
GL11.glEnable(GL11.GL_DEPTH_TEST);
RenderHelper.enableStandardItemLighting();
}
private void drawItemStack(ItemStack p_146982_1_, int p_146982_2_, int p_146982_3_, String p_146982_4_)
{
GL11.glTranslatef(0.0F, 0.0F, 32.0F);
this.zLevel = 500.0F;
itemRender.zLevel = 500.0F;
FontRenderer font = null;
if (p_146982_1_ != null) font = p_146982_1_.getItem().getFontRenderer(p_146982_1_);
if (font == null) font = fontRendererObj;
itemRender.renderItemAndEffectIntoGUI(font, this.mc.getTextureManager(), p_146982_1_, p_146982_2_, p_146982_3_);
itemRender.renderItemOverlayIntoGUI(font, this.mc.getTextureManager(), p_146982_1_, p_146982_2_, p_146982_3_ - (this.draggedStack == null ? 0 : 8), p_146982_4_);
this.zLevel = 0.0F;
itemRender.zLevel = 0.0F;
}
/**
* Draw the foreground layer for the GuiContainer (everything in front of the items)
*/
protected void drawGuiContainerForegroundLayer(int p_146979_1_, int p_146979_2_) {}
protected abstract void drawGuiContainerBackgroundLayer(float var1, int var2, int var3);
private void func_146977_a(Slot p_146977_1_)
{
int i = p_146977_1_.xDisplayPosition;
int j = p_146977_1_.yDisplayPosition;
ItemStack itemstack = p_146977_1_.getStack();
boolean flag = false;
boolean flag1 = p_146977_1_ == this.clickedSlot && this.draggedStack != null && !this.isRightMouseClick;
ItemStack itemstack1 = this.mc.thePlayer.inventory.getItemStack();
String s = null;
if (p_146977_1_ == this.clickedSlot && this.draggedStack != null && this.isRightMouseClick && itemstack != null)
{
itemstack = itemstack.copy();
itemstack.stackSize /= 2;
}
else if (this.field_147007_t && this.field_147008_s.contains(p_146977_1_) && itemstack1 != null)
{
if (this.field_147008_s.size() == 1)
{
return;
}
if (Container.func_94527_a(p_146977_1_, itemstack1, true) && this.inventorySlots.canDragIntoSlot(p_146977_1_))
{
itemstack = itemstack1.copy();
flag = true;
Container.func_94525_a(this.field_147008_s, this.field_146987_F, itemstack, p_146977_1_.getStack() == null ? 0 : p_146977_1_.getStack().stackSize);
if (itemstack.stackSize > itemstack.getMaxStackSize())
{
s = EnumChatFormatting.YELLOW + "" + itemstack.getMaxStackSize();
itemstack.stackSize = itemstack.getMaxStackSize();
}
if (itemstack.stackSize > p_146977_1_.getSlotStackLimit())
{
s = EnumChatFormatting.YELLOW + "" + p_146977_1_.getSlotStackLimit();
itemstack.stackSize = p_146977_1_.getSlotStackLimit();
}
}
else
{
this.field_147008_s.remove(p_146977_1_);
this.func_146980_g();
}
}
this.zLevel = 100.0F;
itemRender.zLevel = 100.0F;
if (itemstack == null)
{
IIcon iicon = p_146977_1_.getBackgroundIconIndex();
if (iicon != null)
{
GL11.glDisable(GL11.GL_LIGHTING);
this.mc.getTextureManager().bindTexture(TextureMap.locationItemsTexture);
this.drawTexturedModelRectFromIcon(i, j, iicon, 16, 16);
GL11.glEnable(GL11.GL_LIGHTING);
flag1 = true;
}
}
if (!flag1)
{
if (flag)
{
drawRect(i, j, i + 16, j + 16, -2130706433);
}
GL11.glEnable(GL11.GL_DEPTH_TEST);
manager.renderSlotUnderlay(p_146977_1_);
manager.drawSlotItem(p_146977_1_, itemstack, i, j, s);
manager.renderSlotOverlay(p_146977_1_);
}
itemRender.zLevel = 0.0F;
this.zLevel = 0.0F;
}
private void func_146980_g()
{
ItemStack itemstack = this.mc.thePlayer.inventory.getItemStack();
if (itemstack != null && this.field_147007_t)
{
this.field_146996_I = itemstack.stackSize;
ItemStack itemstack1;
int i;
for (Iterator iterator = this.field_147008_s.iterator(); iterator.hasNext(); this.field_146996_I -= itemstack1.stackSize - i)
{
Slot slot = (Slot)iterator.next();
itemstack1 = itemstack.copy();
i = slot.getStack() == null ? 0 : slot.getStack().stackSize;
Container.func_94525_a(this.field_147008_s, this.field_146987_F, itemstack1, i);
if (itemstack1.stackSize > itemstack1.getMaxStackSize())
{
itemstack1.stackSize = itemstack1.getMaxStackSize();
}
if (itemstack1.stackSize > slot.getSlotStackLimit())
{
itemstack1.stackSize = slot.getSlotStackLimit();
}
}
}
}
/**
* Returns the slot at the given coordinates or null if there is none.
*/
public Slot getSlotAtPosition(int p_146975_1_, int p_146975_2_)
{
for (int k = 0; k < this.inventorySlots.inventorySlots.size(); ++k)
{
Slot slot = (Slot)this.inventorySlots.inventorySlots.get(k);
if (this.isMouseOverSlot(slot, p_146975_1_, p_146975_2_))
{
return slot;
}
}
return null;
}
/**
* Called when the mouse is clicked.
*/
protected void mouseClicked(int par1, int par2, int par3)
{
if (manager.mouseClicked(par1, par2, par3))
return;
super.mouseClicked(par1, par2, par3);
boolean flag = par3 == this.mc.gameSettings.keyBindPickBlock.getKeyCode() + 100;
Slot slot = this.getSlotAtPosition(par1, par2);
long l = Minecraft.getSystemTime();
this.field_146993_M = this.field_146998_K == slot && l - this.field_146997_J < 250L && this.field_146992_L == par3;
this.field_146995_H = false;
if (par3 == 0 || par3 == 1 || flag)
{
int i1 = this.guiLeft;
int j1 = this.guiTop;
boolean flag1 = par1 < i1 || par2 < j1 || par1 >= i1 + this.xSize || par2 >= j1 + this.ySize;
int k1 = -1;
if (slot != null)
{
k1 = slot.slotNumber;
}
if (flag1)
{
k1 = -999;
}
if (this.mc.gameSettings.touchscreen && flag1 && this.mc.thePlayer.inventory.getItemStack() == null)
{
this.mc.displayGuiScreen((GuiScreen)null);
return;
}
if (k1 != -1)
{
if (this.mc.gameSettings.touchscreen)
{
if (slot != null && slot.getHasStack())
{
this.clickedSlot = slot;
this.draggedStack = null;
this.isRightMouseClick = par3 == 1;
}
else
{
this.clickedSlot = null;
}
}
else if (!this.field_147007_t)
{
if (this.mc.thePlayer.inventory.getItemStack() == null)
{
if (par3 == this.mc.gameSettings.keyBindPickBlock.getKeyCode() + 100)
{
managerHandleMouseClick(slot, k1, par3, 3);
}
else
{
boolean flag2 = k1 != -999 && (Keyboard.isKeyDown(42) || Keyboard.isKeyDown(54));
byte b0 = 0;
if (flag2)
{
this.field_146994_N = slot != null && slot.getHasStack() ? slot.getStack() : null;
b0 = 1;
}
else if (k1 == -999)
{
b0 = 4;
}
managerHandleMouseClick(slot, k1, par3, b0);
}
this.field_146995_H = true;
}
else
{
this.field_147007_t = true;
this.field_146988_G = par3;
this.field_147008_s.clear();
if (par3 == 0)
{
this.field_146987_F = 0;
}
else if (par3 == 1)
{
this.field_146987_F = 1;
}
}
}
}
}
this.field_146998_K = slot;
this.field_146997_J = l;
this.field_146992_L = par3;
}
/**
* Called when a mouse button is pressed and the mouse is moved around. Parameters are : mouseX, mouseY,
* lastButtonClicked & timeSinceMouseClick.
*/
protected void mouseClickMove(int p_146273_1_, int p_146273_2_, int p_146273_3_, long p_146273_4_)
{
Slot slot = this.getSlotAtPosition(p_146273_1_, p_146273_2_);
ItemStack itemstack = this.mc.thePlayer.inventory.getItemStack();
manager.mouseDragged(p_146273_1_, p_146273_2_, p_146273_3_, p_146273_4_);
if (this.clickedSlot != null && this.mc.gameSettings.touchscreen)
{
if (p_146273_3_ == 0 || p_146273_3_ == 1)
{
if (this.draggedStack == null)
{
if (slot != this.clickedSlot)
{
this.draggedStack = this.clickedSlot.getStack().copy();
}
}
else if (this.draggedStack.stackSize > 1 && slot != null && Container.func_94527_a(slot, this.draggedStack, false))
{
long i1 = Minecraft.getSystemTime();
if (this.field_146985_D == slot)
{
if (i1 - this.field_146986_E > 500L)
{
managerHandleMouseClick(this.clickedSlot, this.clickedSlot.slotNumber, 0, 0);
managerHandleMouseClick(slot, slot.slotNumber, 1, 0);
managerHandleMouseClick(this.clickedSlot, this.clickedSlot.slotNumber, 0, 0);
this.field_146986_E = i1 + 750L;
--this.draggedStack.stackSize;
}
}
else
{
this.field_146985_D = slot;
this.field_146986_E = i1;
}
}
}
}
else if (this.field_147007_t && slot != null && itemstack != null && itemstack.stackSize > this.field_147008_s.size() && Container.func_94527_a(slot, itemstack, true) && slot.isItemValid(itemstack) && this.inventorySlots.canDragIntoSlot(slot))
{
this.field_147008_s.add(slot);
this.func_146980_g();
}
}
/**
* Called when the mouse is moved or a mouse button is released. Signature: (mouseX, mouseY, which) which==-1 is
* mouseMove, which==0 or which==1 is mouseUp
*/
protected void mouseMovedOrUp(int p_146286_1_, int p_146286_2_, int p_146286_3_)
{
if(manager.overrideMouseUp(p_146286_1_, p_146286_2_, p_146286_3_))
return;
Slot slot = this.getSlotAtPosition(p_146286_1_, p_146286_2_);
int l = this.guiLeft;
int i1 = this.guiTop;
boolean flag = p_146286_1_ < l || p_146286_2_ < i1 || p_146286_1_ >= l + this.xSize || p_146286_2_ >= i1 + this.ySize;
int j1 = -1;
if (slot != null)
{
j1 = slot.slotNumber;
}
if (flag)
{
j1 = -999;
}
Slot slot1;
Iterator iterator;
if (this.field_146993_M && slot != null && p_146286_3_ == 0 && this.inventorySlots.func_94530_a((ItemStack)null, slot))
{
if (isShiftKeyDown())
{
if (slot != null && slot.inventory != null && this.field_146994_N != null)
{
iterator = this.inventorySlots.inventorySlots.iterator();
while (iterator.hasNext())
{
slot1 = (Slot)iterator.next();
if (slot1 != null && slot1.canTakeStack(this.mc.thePlayer) && slot1.getHasStack() && slot1.inventory == slot.inventory && Container.func_94527_a(slot1, this.field_146994_N, true))
{
managerHandleMouseClick(slot1, slot1.slotNumber, p_146286_3_, 1);
}
}
}
}
else
{
managerHandleMouseClick(slot, j1, p_146286_3_, 6);
}
this.field_146993_M = false;
this.field_146997_J = 0L;
}
else
{
if (this.field_147007_t && this.field_146988_G != p_146286_3_)
{
this.field_147007_t = false;
this.field_147008_s.clear();
this.field_146995_H = true;
return;
}
if (this.field_146995_H)
{
this.field_146995_H = false;
return;
}
boolean flag1;
if (this.clickedSlot != null && this.mc.gameSettings.touchscreen)
{
if (p_146286_3_ == 0 || p_146286_3_ == 1)
{
if (this.draggedStack == null && slot != this.clickedSlot)
{
this.draggedStack = this.clickedSlot.getStack();
}
flag1 = Container.func_94527_a(slot, this.draggedStack, false);
if (j1 != -1 && this.draggedStack != null && flag1)
{
managerHandleMouseClick(this.clickedSlot, this.clickedSlot.slotNumber, p_146286_3_, 0);
managerHandleMouseClick(slot, j1, 0, 0);
if (this.mc.thePlayer.inventory.getItemStack() != null)
{
managerHandleMouseClick(this.clickedSlot, this.clickedSlot.slotNumber, p_146286_3_, 0);
this.field_147011_y = p_146286_1_ - l;
this.field_147010_z = p_146286_2_ - i1;
this.returningStackDestSlot = this.clickedSlot;
this.returningStack = this.draggedStack;
this.returningStackTime = Minecraft.getSystemTime();
}
else
{
this.returningStack = null;
}
}
else if (this.draggedStack != null)
{
this.field_147011_y = p_146286_1_ - l;
this.field_147010_z = p_146286_2_ - i1;
this.returningStackDestSlot = this.clickedSlot;
this.returningStack = this.draggedStack;
this.returningStackTime = Minecraft.getSystemTime();
}
this.draggedStack = null;
this.clickedSlot = null;
}
}
else if (this.field_147007_t && !this.field_147008_s.isEmpty())
{
managerHandleMouseClick((Slot)null, -999, Container.func_94534_d(0, this.field_146987_F), 5);
iterator = this.field_147008_s.iterator();
while (iterator.hasNext())
{
slot1 = (Slot)iterator.next();
managerHandleMouseClick(slot1, slot1.slotNumber, Container.func_94534_d(1, this.field_146987_F), 5);
}
managerHandleMouseClick((Slot)null, -999, Container.func_94534_d(2, this.field_146987_F), 5);
}
else if (this.mc.thePlayer.inventory.getItemStack() != null)
{
if (p_146286_3_ == this.mc.gameSettings.keyBindPickBlock.getKeyCode() + 100)
{
managerHandleMouseClick(slot, j1, p_146286_3_, 3);
}
else
{
flag1 = j1 != -999 && (Keyboard.isKeyDown(42) || Keyboard.isKeyDown(54));
if (flag1)
{
this.field_146994_N = slot != null && slot.getHasStack() ? slot.getStack() : null;
}
managerHandleMouseClick(slot, j1, p_146286_3_, flag1 ? 1 : 0);
}
}
else if(p_146286_3_ >= 0)
manager.mouseUp(p_146286_1_, p_146286_2_, p_146286_3_);
}
if (this.mc.thePlayer.inventory.getItemStack() == null)
{
this.field_146997_J = 0L;
}
this.field_147007_t = false;
}
/**
* Returns if the passed mouse position is over the specified slot.
*/
private boolean isMouseOverSlot(Slot p_146981_1_, int p_146981_2_, int p_146981_3_)
{
return this.func_146978_c(p_146981_1_.xDisplayPosition, p_146981_1_.yDisplayPosition, 16, 16, p_146981_2_, p_146981_3_);
}
protected boolean func_146978_c(int p_146978_1_, int p_146978_2_, int p_146978_3_, int p_146978_4_, int p_146978_5_, int p_146978_6_)
{
int k1 = this.guiLeft;
int l1 = this.guiTop;
p_146978_5_ -= k1;
p_146978_6_ -= l1;
return p_146978_5_ >= p_146978_1_ - 1 && p_146978_5_ < p_146978_1_ + p_146978_3_ + 1 && p_146978_6_ >= p_146978_2_ - 1 && p_146978_6_ < p_146978_2_ + p_146978_4_ + 1;
}
protected void handleMouseClick(Slot p_146984_1_, int p_146984_2_, int p_146984_3_, int p_146984_4_)
{
if (p_146984_1_ != null)
{
p_146984_2_ = p_146984_1_.slotNumber;
}
manager.handleSlotClick(p_146984_2_, p_146984_3_, p_146984_4_);
}
/**
* Fired when a key is typed. This is the equivalent of KeyListener.keyTyped(KeyEvent e).
*/
protected void keyTyped(char par1, int par2)
{
if(manager.lastKeyTyped(par2, par1))
return;
if (par2 == 1 || par2 == this.mc.gameSettings.keyBindInventory.getKeyCode())
{
this.mc.thePlayer.closeScreen();
}
this.checkHotbarKeys(par2);
if (this.theSlot != null && this.theSlot.getHasStack())
{
if (par2 == this.mc.gameSettings.keyBindPickBlock.getKeyCode())
{
managerHandleMouseClick(this.theSlot, this.theSlot.slotNumber, 0, 3);
}
else if (par2 == this.mc.gameSettings.keyBindDrop.getKeyCode())
{
managerHandleMouseClick(this.theSlot, this.theSlot.slotNumber, isCtrlKeyDown() ? 1 : 0, 4);
}
}
}
/**
* This function is what controls the hotbar shortcut check when you press a number key when hovering a stack.
*/
protected boolean checkHotbarKeys(int p_146983_1_)
{
if (this.mc.thePlayer.inventory.getItemStack() == null && this.theSlot != null)
{
for (int j = 0; j < 9; ++j)
{
if (p_146983_1_ == this.mc.gameSettings.keyBindsHotbar[j].getKeyCode())
{
managerHandleMouseClick(this.theSlot, this.theSlot.slotNumber, j, 2);
return true;
}
}
}
return false;
}
/**
* Called when the screen is unloaded. Used to disable keyboard repeat events
*/
public void onGuiClosed()
{
if (this.mc.thePlayer != null)
{
this.inventorySlots.onContainerClosed(this.mc.thePlayer);
}
}
/**
* Returns true if this GUI should pause the game when it is displayed in single-player
*/
public boolean doesGuiPauseGame()
{
return false;
}
/**
* Called from the main game loop to update the screen.
*/
public void updateScreen()
{
super.updateScreen();
manager.updateScreen();
if (!this.mc.thePlayer.isEntityAlive() || this.mc.thePlayer.isDead)
{
this.mc.thePlayer.closeScreen();
}
}
public void setWorldAndResolution(Minecraft mc, int i, int j)
{
super.setWorldAndResolution(mc, i, j);
if(mc.currentScreen == this)
{
manager = new GuiContainerManager(this);
manager.load();
}
}
public void handleKeyboardInput()
{
manager.handleKeyboardInput();
}
public void handleMouseInput()
{
super.handleMouseInput();
manager.handleMouseWheel();
}
public void managerHandleMouseClick(Slot slot, int slotIndex, int button, int modifiers)
{
manager.handleMouseClick(slot, slotIndex, button, modifiers);
}
}
+60
View File
@@ -0,0 +1,60 @@
modName = NotEnoughItems
# This is a case-sensitive string to identify your mod. Convention is to use lower case.
modId = NotEnoughItems
modGroup = codechicken.nei
# WHY is there no version field?
# The build script relies on git to provide a version via tags. It is super easy and will enable you to always know the
# code base or your binary. Check out this tutorial: https://blog.mattclemente.com/2017/10/13/versioning-with-git-tags/
# Will update your build.gradle automatically whenever an update is available
autoUpdateBuildScript = false
minecraftVersion = 1.7.10
forgeVersion = 10.13.4.1614
# Select a username for testing your mod with breakpoints. You may leave this empty for a random user name each time you
# restart Minecraft in development. Choose this dependent on your mod:
# Do you need consistent player progressing (for example Thaumcraft)? -> Select a name
# Do you need to test how your custom blocks interacts with a player that is not the owner? -> leave name empty
developmentEnvironmentUserName = "Developer"
# Define a source file of your project with:
# public static final String VERSION = "GRADLETOKEN_VERSION";
# The string's content will be replaced with your mods version when compiled. You should use this to specify your mod's
# version in @Mod([...], version = VERSION, [...])
# Leave these properties empty to skip individual token replacements
replaceGradleTokenInFile = NEIModContainer.java
gradleTokenModId = GRADLETOKEN_MODID
gradleTokenModName = GRADLETOKEN_MODNAME
gradleTokenVersion = GRADLETOKEN_VERSION
gradleTokenGroupName =
# In case your mod provides an API for other mods to implement you may declare its package here. Otherwise you can
# leave this property empty.
# Example value: apiPackage = api + modGroup = com.myname.mymodid -> com.myname.mymodid.api
apiPackage =
# Specify the configuration file for Forge's access transformers here. I must be placed into /src/main/resources/META-INF/
# Example value: mymodid_at.cfg
accessTransformersFile = nei_at.cfg
# Provides setup for Mixins if enabled. If you don't know what mixins are: Keep it disabled!
usesMixins = false
# Specify the location of your implementation of IMixinPlugin. Leave it empty otherwise.
mixinPlugin =
# Specify the package that contains all of your Mixins. You may only place Mixins in this package or the build will fail!
mixinsPackage =
# Specify the core mod entry class if you use a core mod. This class must implement IFMLLoadingPlugin!
# This parameter is for legacy compatability only
# Example value: coreModClass = asm.FMLPlugin + modGroup = com.myname.mymodid -> com.myname.mymodid.asm.FMLPlugin
coreModClass = asm.NEICorePlugin
# If your project is only a consolidation of mixins or a core mod and does NOT contain a 'normal' mod ( = some class
# that is annotated with @Mod) you want this to be true. When in doubt: leave it on false!
containsMixinsAndOrCoreModOnly = true
# If enabled, you may use 'shadowImplementation' for dependencies. They will be integrated in your jar. It is your
# responsibility check the licence and request permission for distribution, if required.
usesShadowedDependencies = true
Binary file not shown.
+1 -1
View File
@@ -1,5 +1,5 @@
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-6.9.1-bin.zip
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-4.4.1-bin.zip
Vendored
+19 -3
View File
@@ -1,5 +1,21 @@
#!/usr/bin/env sh
#
# Copyright 2015 the original author or authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
##############################################################################
##
## Gradle start up script for UN*X
@@ -28,7 +44,7 @@ APP_NAME="Gradle"
APP_BASE_NAME=`basename "$0"`
# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
DEFAULT_JVM_OPTS=""
DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
# Use the maximum available, or set MAX_FD != -1 to use that value.
MAX_FD="maximum"
@@ -109,8 +125,8 @@ if $darwin; then
GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
fi
# For Cygwin, switch paths to Windows format before running java
if $cygwin ; then
# For Cygwin or MSYS, switch paths to Windows format before running java
if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
APP_HOME=`cygpath --path --mixed "$APP_HOME"`
CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
JAVACMD=`cygpath --unix "$JAVACMD"`
Vendored
+17 -1
View File
@@ -1,3 +1,19 @@
@rem
@rem Copyright 2015 the original author or authors.
@rem
@rem Licensed under the Apache License, Version 2.0 (the "License");
@rem you may not use this file except in compliance with the License.
@rem You may obtain a copy of the License at
@rem
@rem https://www.apache.org/licenses/LICENSE-2.0
@rem
@rem Unless required by applicable law or agreed to in writing, software
@rem distributed under the License is distributed on an "AS IS" BASIS,
@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@rem See the License for the specific language governing permissions and
@rem limitations under the License.
@rem
@if "%DEBUG%" == "" @echo off
@rem ##########################################################################
@rem
@@ -14,7 +30,7 @@ set APP_BASE_NAME=%~n0
set APP_HOME=%DIRNAME%
@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
set DEFAULT_JVM_OPTS=
set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
@rem Find java.exe
if defined JAVA_HOME goto findJavaFromJavaHome
+2
View File
@@ -0,0 +1,2 @@
before_install:
- ./gradlew setupCIWorkspace
+12
View File
@@ -0,0 +1,12 @@
// Add any additional repositiroes for your dependencies here
repositories {
mavenCentral()
maven {
name = "GTNH Maven"
url = "http://jenkins.usrv.eu:8081/nexus/content/groups/public/"
}
maven {
url = "https://jitpack.io"
}
}
Binary file not shown.

Before

Width:  |  Height:  |  Size: 28 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 25 KiB

-21
View File
@@ -1,21 +0,0 @@
[
{
"modid": "NotEnoughItems",
"name": "Not Enough Items",
"version": "${version}",
"mcversion": "${mc_version}",
"description": "Recipe Viewer, Inventory Manager, Item Spawner, Cheats and more; GTNH Version
<plugins>
Supporters: EmuCraft Team, Victor Zimmer, lexi85, Ace_Trainer_Tullius, Bacon_Donut, Iarinu",
"url": "http://www.minecraftforum.net/topic/909223",
"credits": "Alexandria - original idea",
"license": "LGPL-3.0",
"authorList": [ "ChickenBones", "mitchej123" ],
"dependencies": [
"CodeChickenCore"
]
}
]
-19
View File
@@ -1,19 +0,0 @@
/*
* This settings file was auto generated by the Gradle buildInit task
* by 'sunstrike' at '21/11/13 14:14' with Gradle 1.9
*
* The settings file is used to specify which projects to include in your build.
* In a single project build this file can be empty or even removed.
*
* Detailed information about configuring a multi-project build in Gradle can be found
* in the user guide at http://gradle.org/docs/1.9/userguide/multi_project_builds.html
*/
/*
// To declare projects as part of a multi-project build use the 'include' method
include 'shared'
include 'api'
include 'services:webservice'
*/
rootProject.name = 'NotEnoughItems'
-173
View File
@@ -1,173 +0,0 @@
package codechicken.nei;
import cpw.mods.fml.common.registry.GameData;
import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.JsonToNBT;
import net.minecraft.nbt.NBTException;
import net.minecraft.nbt.NBTTagCompound;
import org.apache.commons.io.IOUtils;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
/*
* TODO:
* 1) Bookmark button to toggle visibility
*/
public class BookmarkPanel extends ItemPanel {
public void init() {
super.init();
}
@Override
protected void setItems() {
realItems = _items;
}
public String getLabelText() {
return super.getLabelText() + " [" + realItems.size() + "]";
}
public void addOrRemoveItem(ItemStack item) {
ItemStack normalized = normalize(item);
if(!remove(normalized)) {
_items.add(normalized);
}
saveBookmarks();
}
public static NBTTagCompound itemStackToNBT(ItemStack stack, NBTTagCompound nbTag)
{
String strId = Item.itemRegistry.getNameForObject(stack.getItem());
nbTag.setString("strId", strId);
nbTag.setByte("Count", (byte)stack.stackSize);
nbTag.setShort("Damage", (short)stack.getItemDamage());
if (stack.stackTagCompound != null)
{
nbTag.setTag("tag", stack.stackTagCompound);
}
return nbTag;
}
public static ItemStack loadFromNBT(NBTTagCompound nbtTag)
{
if (!nbtTag.hasKey("id")) {
final short id = (short)GameData.getItemRegistry().getId(nbtTag.getString("strId"));
nbtTag.setShort("id", id);
}
ItemStack stack = ItemStack.loadItemStackFromNBT(nbtTag);
return stack;
}
public void saveBookmarks() {
List<String> strings = new ArrayList<>();
for (ItemStack item:_items) {
strings.add(itemStackToNBT(item, new NBTTagCompound()).toString());
}
File file = NEIClientConfig.bookmarkFile;
if(file != null) {
try(FileWriter writer = new FileWriter(file)) {
IOUtils.writeLines(strings, "\n", writer);
} catch (IOException e) {
NEIClientConfig.logger.error("Filed to save bookmarks list to file {}", file, e);
}
}
}
public void loadBookmarks() {
File file = NEIClientConfig.bookmarkFile;
if (file == null || !file.exists()) {
return;
}
List<String> itemStrings;
try (FileReader reader = new FileReader(file)) {
NEIClientConfig.logger.info("Loading bookmarks from file {}", file);
itemStrings = IOUtils.readLines(reader);
} catch (IOException e) {
NEIClientConfig.logger.error("Failed to load bookmarks from file {}", file, e);
return;
}
_items.clear();
for (String itemStr: itemStrings) {
try {
NBTTagCompound itemStackNBT = (NBTTagCompound)JsonToNBT.func_150315_a(itemStr);
ItemStack itemStack = loadFromNBT(itemStackNBT);
if (itemStack != null) {
_items.add(itemStack);
} else {
NEIClientConfig.logger.warn("Failed to load bookmarked ItemStack from json string, the item no longer exists:\n{}", itemStr);
}
} catch (NBTException e) {
NEIClientConfig.logger.error("Failed to load bookmarked ItemStack from json string:\n{}", itemStr, e);
}
}
}
protected ItemStack normalize(ItemStack item) {
ItemStack copy = item.copy();
copy.stackSize = 1;
return copy;
}
private boolean remove(ItemStack item) {
int i = 0;
for (ItemStack existing : _items) {
if (existing == item || existing.isItemEqual(item)) {
_items.remove(i);
return true;
}
i++;
}
return false;
}
@Override
public int getX(GuiContainer gui) {
return 5;
}
@Override
public int getMarginLeft() {
return 5;
}
@Override
public int getButtonTop() {
LayoutStyleMinecraft layout = (LayoutStyleMinecraft)LayoutManager.getLayoutStyle();
return 2 + (((int)Math.ceil((double)layout.buttonCount / layout.numButtons)) * 18);
}
@Override
public int getNextX(GuiContainer gui) {
return gui.width - prev.w - 2 - ((gui.xSize + gui.width) /2 + 2);
}
@Override
public int getPrevX(GuiContainer gui) {
return 2;
}
@Override
public int getPageX(GuiContainer gui) {
return gui.guiLeft * 3 / 2 + gui.xSize + 1 - ((gui.xSize + gui.width) /2 + 2);
}
public int getHightAdjustment() {
return 0;
}
public int getWidth(GuiContainer gui) {
return LayoutManager.getLeftSize(gui) - ( (gui.xSize + gui.width) / 2 + 3 );
}
}
-479
View File
@@ -1,479 +0,0 @@
package codechicken.nei;
import codechicken.lib.vec.Rectangle4i;
import codechicken.nei.api.GuiInfo;
import codechicken.nei.api.INEIGuiHandler;
import codechicken.nei.guihook.GuiContainerManager;
import codechicken.nei.recipe.GuiCraftingRecipe;
import codechicken.nei.recipe.GuiRecipe;
import codechicken.nei.recipe.GuiUsageRecipe;
import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
import java.util.ArrayList;
import static codechicken.lib.gui.GuiDraw.drawRect;
import static codechicken.nei.NEIClientConfig.canPerformAction;
public class ItemPanel extends Widget {
/**
* Backwards compat :-/
*/
public static ArrayList<ItemStack> items = new ArrayList<>();
/**
* Should not be externally modified, use updateItemList
*/
public ArrayList<ItemStack> realItems = new ArrayList<>();
/**
* Swapped into visible items on update
*/
protected ArrayList<ItemStack> _items = realItems;
public ArrayList<ItemStack> getItems() {
return realItems;
}
public static void updateItemList(ArrayList<ItemStack> newItems) {
ItemPanels.itemPanel._items = newItems;
}
public class ItemPanelSlot
{
public ItemStack item;
public int slotIndex;
public ItemPanelSlot(int index) {
item = realItems.get(index);
slotIndex = index;
}
}
public ItemStack draggedStack;
public int mouseDownSlot = -1;
public Button prev;
public Button next;
public Label pageLabel;
private int marginLeft;
private int marginTop;
private int rows;
private int columns;
private boolean[] validSlotMap;
private int firstIndex;
private int itemsPerPage;
private int page;
private int numPages;
public void init() {
pageLabel = new Label("(0/0)", true);
prev = new Button("Prev")
{
public boolean onButtonPress(boolean rightclick) {
if (!rightclick) {
scroll(-1);
return true;
}
return false;
}
@Override
public String getRenderLabel() {
return "<";
}
};
next = new Button("Next")
{
public boolean onButtonPress(boolean rightclick) {
if (!rightclick) {
scroll(1);
return true;
}
return false;
}
@Override
public String getRenderLabel() {
return ">";
}
};
}
public int getX(GuiContainer gui) {
return (gui.xSize + gui.width) / 2 + 3;
}
public int getMarginLeft() {
return x + (w % 18) / 2;
}
public int getMarginTop() {
return y + (h % 18) / 2;
}
public int getButtonTop() {
return 2;
}
public int getNextX(GuiContainer gui) {
return gui.width - prev.w - 2;
}
public int getPrevX(GuiContainer gui) {
return (gui.xSize + gui.width) / 2 + 2;
}
public int getPageX(GuiContainer gui) {
return gui.guiLeft * 3 / 2 + gui.xSize + 1;
}
public int getHeight(GuiContainer gui) {
return gui.height - 15 - y + getHightAdjustment();
}
public int getHightAdjustment() {
int hAdj = 0;
if (!canPerformAction("item"))
hAdj += 15;
return hAdj;
}
public int getWidth(GuiContainer gui) {
return LayoutManager.getSideWidth(gui) - x;
}
public String getLabelText() {
return pageLabel.text = "(" + getPage() + "/" + getNumPages() + ")";
}
protected void setItems() {
realItems = _items;
// Backwards compat
ItemPanels.itemPanel._items = _items;
}
public void resize(GuiContainer gui) {
setItems();
final int buttonHeight = 16;
final int buttonWidth = 16;
prev.x = getPrevX(gui);
prev.y = getButtonTop();
prev.h = buttonHeight;
prev.w = buttonWidth;
next.x = getNextX(gui);
next.y = getButtonTop();
next.h = buttonHeight;
next.w = buttonWidth;
pageLabel.x = getPageX(gui);
pageLabel.y = prev.y + 5;
pageLabel.text = getLabelText();
y = prev.h + prev.y;
x = getX(gui);
w = getWidth(gui);
h = getHeight(gui);
marginLeft = getMarginLeft();
marginTop = getMarginTop();
columns = w / 18;
rows = h / 18;
//sometimes width and height can be negative with certain resizing
if(rows < 0) rows = 0;
if(columns < 0) columns = 0;
calculatePage();
updateValidSlots();
}
private void calculatePage() {
if (itemsPerPage == 0)
numPages = 0;
else
numPages = (int) Math.ceil((float) realItems.size() / (float) itemsPerPage);
if (firstIndex >= realItems.size())
firstIndex = 0;
if (numPages == 0)
page = 0;
else
page = firstIndex / itemsPerPage + 1;
}
public void setVisible() {
LayoutManager.addWidget(prev);
LayoutManager.addWidget(next);
LayoutManager.addWidget(pageLabel);
}
private void updateValidSlots() {
GuiContainer gui = NEIClientUtils.getGuiContainer();
validSlotMap = new boolean[rows * columns];
itemsPerPage = 0;
for (int i = 0; i < validSlotMap.length; i++)
if (slotValid(gui, i)) {
validSlotMap[i] = true;
itemsPerPage++;
}
}
private boolean slotValid(GuiContainer gui, int i) {
Rectangle4i rect = getSlotRect(i);
for (INEIGuiHandler handler : GuiInfo.guiHandlers)
if (handler.hideItemPanelSlot(gui, rect.x, rect.y, rect.w, rect.h))
return false;
return true;
}
public Rectangle4i getSlotRect(int i) {
return getSlotRect(i / columns, i % columns);
}
public Rectangle4i getSlotRect(int row, int column) {
return new Rectangle4i(marginLeft + column * 18, marginTop + row * 18, 18, 18);
}
@Override
public void draw(int mousex, int mousey) {
if (itemsPerPage == 0)
return;
GuiContainerManager.enableMatrixStackLogging();
int index = firstIndex;
for (int i = 0; i < rows * columns && index < realItems.size(); i++) {
if (validSlotMap[i]) {
Rectangle4i rect = getSlotRect(i);
if (rect.contains(mousex, mousey))
drawRect(rect.x, rect.y, rect.w, rect.h, 0xee555555);//highlight
GuiContainerManager.drawItem(rect.x + 1, rect.y + 1, realItems.get(index));
index++;
}
}
GuiContainerManager.disableMatrixStackLogging();
}
@Override
public void postDraw(int mousex, int mousey) {
if (draggedStack != null) {
GuiContainerManager.drawItems.zLevel += 100;
GuiContainerManager.drawItem(mousex - 8, mousey - 8, draggedStack);
GuiContainerManager.drawItems.zLevel -= 100;
}
}
@Override
public void mouseDragged(int mousex, int mousey, int button, long heldTime) {
if (mouseDownSlot >= 0 && draggedStack == null && NEIClientUtils.getHeldItem() == null &&
NEIClientConfig.hasSMPCounterPart() && !GuiInfo.hasCustomSlots(NEIClientUtils.getGuiContainer())) {
ItemPanelSlot mouseOverSlot = getSlotMouseOver(mousex, mousey);
ItemStack stack = new ItemPanelSlot(mouseDownSlot).item;
if (stack != null && (mouseOverSlot == null || mouseOverSlot.slotIndex != mouseDownSlot || heldTime > 500)) {
int amount = NEIClientConfig.getItemQuantity();
if (amount == 0)
amount = stack.getMaxStackSize();
draggedStack = NEIServerUtils.copyStack(stack, amount);
}
}
}
@Override
public boolean handleClick(int mousex, int mousey, int button) {
if (handleDraggedClick(mousex, mousey, button))
return true;
if (NEIClientUtils.getHeldItem() != null) {
for (INEIGuiHandler handler : GuiInfo.guiHandlers)
if (handler.hideItemPanelSlot(NEIClientUtils.getGuiContainer(), mousex, mousey, 1, 1))
return false;
if (NEIClientConfig.canPerformAction("delete") && NEIClientConfig.canPerformAction("item"))
if (button == 1)
NEIClientUtils.decreaseSlotStack(-999);
else
NEIClientUtils.deleteHeldItem();
else
NEIClientUtils.dropHeldItem();
return true;
}
ItemPanelSlot hoverSlot = getSlotMouseOver(mousex, mousey);
if (hoverSlot != null) {
if (button == 2) {
ItemStack stack = hoverSlot.item;
if (stack != null) {
int amount = NEIClientConfig.getItemQuantity();
if (amount == 0)
amount = stack.getMaxStackSize();
draggedStack = NEIServerUtils.copyStack(stack, amount);
}
} else {
mouseDownSlot = hoverSlot.slotIndex;
}
return true;
}
return false;
}
private boolean handleDraggedClick(int mousex, int mousey, int button) {
if (draggedStack == null)
return false;
GuiContainer gui = NEIClientUtils.getGuiContainer();
boolean handled = false;
for (INEIGuiHandler handler : GuiInfo.guiHandlers)
if (handler.handleDragNDrop(gui, mousex, mousey, draggedStack, button)) {
handled = true;
if (draggedStack.stackSize == 0) {
draggedStack = null;
return true;
}
}
if (handled)
return true;
Slot overSlot = gui.getSlotAtPosition(mousex, mousey);
if (overSlot != null && overSlot.isItemValid(draggedStack)) {
if (NEIClientConfig.canCheatItem(draggedStack)) {
int contents = overSlot.getHasStack() ? overSlot.getStack().stackSize : 0;
int add = button == 0 ? draggedStack.stackSize : 1;
if (overSlot.getHasStack() && !NEIServerUtils.areStacksSameType(draggedStack, overSlot.getStack()))
contents = 0;
int total = Math.min(contents + add, Math.min(overSlot.getSlotStackLimit(), draggedStack.getMaxStackSize()));
if (total > contents) {
NEIClientUtils.setSlotContents(overSlot.slotNumber, NEIServerUtils.copyStack(draggedStack, total), true);
NEICPH.sendGiveItem(NEIServerUtils.copyStack(draggedStack, total), false, false);
draggedStack.stackSize -= total - contents;
}
if (draggedStack.stackSize == 0)
draggedStack = null;
} else {
draggedStack = null;
}
} else if (mousex < gui.guiLeft || mousey < gui.guiTop || mousex >= gui.guiLeft + gui.xSize || mousey >= gui.guiTop + gui.ySize) {
draggedStack = null;
}
return true;
}
@Override
public boolean handleClickExt(int mousex, int mousey, int button) {
return handleDraggedClick(mousex, mousey, button);
}
@Override
public void mouseUp(int mousex, int mousey, int button) {
ItemPanelSlot hoverSlot = getSlotMouseOver(mousex, mousey);
if (hoverSlot != null && hoverSlot.slotIndex == mouseDownSlot && draggedStack == null) {
ItemStack item = hoverSlot.item;
if (NEIController.manager.window instanceof GuiRecipe || !NEIClientConfig.canCheatItem(item)) {
if (button == 0)
GuiCraftingRecipe.openRecipeGui("item", item);
else if (button == 1)
GuiUsageRecipe.openRecipeGui("item", item);
draggedStack = null;
mouseDownSlot = -1;
return;
}
NEIClientUtils.cheatItem(item, button, -1);
}
mouseDownSlot = -1;
}
@Override
public boolean onMouseWheel(int i, int mousex, int mousey) {
if (!contains(mousex, mousey))
return false;
scroll(-i);
return true;
}
@Override
public boolean handleKeyPress(int keyID, char keyChar) {
if (keyID == NEIClientConfig.getKeyBinding("gui.next")) {
scroll(1);
return true;
}
if (keyID == NEIClientConfig.getKeyBinding("gui.prev")) {
scroll(-1);
return true;
}
return false;
}
@Override
public ItemStack getStackMouseOver(int mousex, int mousey) {
ItemPanelSlot slot = getSlotMouseOver(mousex, mousey);
return slot == null ? null : slot.item;
}
public ItemPanelSlot getSlotMouseOver(int mousex, int mousey) {
int index = firstIndex;
for (int i = 0; i < rows * columns && index < realItems.size(); i++)
if (validSlotMap[i]) {
if (getSlotRect(i).contains(mousex, mousey))
return new ItemPanelSlot(index);
index++;
}
return null;
}
public void scroll(int i) {
if (itemsPerPage != 0) {
int oldIndex = firstIndex;
firstIndex += i * itemsPerPage;
if (firstIndex >= realItems.size())
firstIndex = 0;
if (firstIndex < 0)
if (oldIndex > 0)
firstIndex = 0;
else
firstIndex = (realItems.size() - 1) / itemsPerPage * itemsPerPage;
calculatePage();
}
}
public int getPage() {
return page;
}
public int getNumPages() {
return numPages;
}
@Override
public boolean contains(int px, int py) {
GuiContainer gui = NEIClientUtils.getGuiContainer();
Rectangle4i rect = new Rectangle4i(px, py, 1, 1);
for (INEIGuiHandler handler : GuiInfo.guiHandlers)
if (handler.hideItemPanelSlot(gui, rect.x, rect.y, rect.w, rect.h))
return false;
return super.contains(px, py);
}
}
-319
View File
@@ -1,319 +0,0 @@
package codechicken.nei.recipe;
import codechicken.lib.gui.GuiDraw;
import codechicken.lib.render.CCRenderState;
import codechicken.nei.GuiNEIButton;
import codechicken.nei.LayoutManager;
import codechicken.nei.NEIClientConfig;
import codechicken.nei.NEIClientUtils;
import codechicken.nei.PositionedStack;
import codechicken.nei.api.IGuiContainerOverlay;
import codechicken.nei.api.IOverlayHandler;
import codechicken.nei.api.IRecipeOverlayRenderer;
import codechicken.nei.guihook.GuiContainerManager;
import codechicken.nei.guihook.IContainerTooltipHandler;
import codechicken.nei.guihook.IGuiClientSide;
import codechicken.nei.guihook.IGuiHandleMouseWheel;
import net.minecraft.client.gui.GuiButton;
import net.minecraft.client.gui.GuiScreen;
import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
import org.lwjgl.input.Keyboard;
import org.lwjgl.opengl.GL11;
import java.awt.Point;
import java.awt.Rectangle;
import java.util.ArrayList;
import java.util.List;
public abstract class GuiRecipe extends GuiContainer implements IGuiContainerOverlay, IGuiClientSide, IGuiHandleMouseWheel, IContainerTooltipHandler
{
public ArrayList<? extends IRecipeHandler> currenthandlers = new ArrayList<>();
public int page;
public int recipetype;
public ContainerRecipe slotcontainer;
public GuiContainer firstGui;
public GuiScreen prevGui;
public GuiButton nextpage;
public GuiButton prevpage;
public GuiButton overlay1;
public GuiButton overlay2;
protected GuiRecipe(GuiScreen prevgui) {
super(new ContainerRecipe());
slotcontainer = (ContainerRecipe) inventorySlots;
this.prevGui = prevgui;
if(prevgui instanceof GuiContainer)
this.firstGui = (GuiContainer)prevgui;
if (prevgui instanceof IGuiContainerOverlay)
this.firstGui = ((IGuiContainerOverlay) prevgui).getFirstScreen();
}
@Override
public void initGui() {
super.initGui();
currenthandlers = getCurrentRecipeHandlers();
GuiButton nexttype = new GuiNEIButton(0, width / 2 - 70, (height - ySize) / 2 + 3, 13, 12, "<");
GuiButton prevtype = new GuiNEIButton(1, width / 2 + 57, (height - ySize) / 2 + 3, 13, 12, ">");
nextpage = new GuiNEIButton(2, width / 2 - 70, (height + ySize) / 2 - 18, 13, 12, "<");
prevpage = new GuiNEIButton(3, width / 2 + 57, (height + ySize) / 2 - 18, 13, 12, ">");
overlay1 = new GuiNEIButton(4, width / 2 + 65, (height - ySize) / 2 + 63, 13, 12, "?");
overlay2 = new GuiNEIButton(5, width / 2 + 65, (height - ySize) / 2 + 128, 13, 12, "?");
buttonList.add(nexttype);
buttonList.add(prevtype);
buttonList.add(nextpage);
buttonList.add(prevpage);
buttonList.add(overlay1);
buttonList.add(overlay2);
if (currenthandlers.size() == 1) {
nexttype.visible = false;
prevtype.visible = false;
}
refreshPage();
}
@Override
public void keyTyped(char c, int i) {
if (i == Keyboard.KEY_ESCAPE) //esc
{
mc.displayGuiScreen(firstGui);
return;
}
if (GuiContainerManager.getManager(this).lastKeyTyped(i, c))
return;
IRecipeHandler recipehandler = currenthandlers.get(recipetype);
for (int recipe = page * recipehandler.recipiesPerPage(); recipe < recipehandler.numRecipes() && recipe < (page + 1) * recipehandler.recipiesPerPage(); recipe++)
if (recipehandler.keyTyped(this, c, i, recipe))
return;
if (i == mc.gameSettings.keyBindInventory.getKeyCode())
mc.displayGuiScreen(firstGui);
else if (i == NEIClientConfig.getKeyBinding("gui.back"))
mc.displayGuiScreen(prevGui);
else if (i == NEIClientConfig.getKeyBinding("gui.prev_machine"))
prevType();
else if (i == NEIClientConfig.getKeyBinding("gui.next_machine"))
nextType();
else if (i == NEIClientConfig.getKeyBinding("gui.prev_recipe"))
prevPage();
else if (i == NEIClientConfig.getKeyBinding("gui.next_recipe"))
nextPage();
}
@Override
protected void mouseClicked(int par1, int par2, int par3) {
IRecipeHandler recipehandler = currenthandlers.get(recipetype);
for (int recipe = page * recipehandler.recipiesPerPage(); recipe < recipehandler.numRecipes() && recipe < (page + 1) * recipehandler.recipiesPerPage(); recipe++)
if (recipehandler.mouseClicked(this, par3, recipe))
return;
super.mouseClicked(par1, par2, par3);
}
@Override
protected void actionPerformed(GuiButton guibutton) {
super.actionPerformed(guibutton);
switch (guibutton.id) {
case 0:
prevType();
break;
case 1:
nextType();
break;
case 2:
prevPage();
break;
case 3:
nextPage();
break;
case 4:
overlayRecipe(page * currenthandlers.get(recipetype).recipiesPerPage());
break;
case 5:
overlayRecipe(page * currenthandlers.get(recipetype).recipiesPerPage() + 1);
break;
}
}
@Override
public void updateScreen() {
super.updateScreen();
currenthandlers.get(recipetype).onUpdate();
refreshPage();
}
@Override
public List<String> handleTooltip(GuiContainer gui, int mousex, int mousey, List<String> currenttip) {
IRecipeHandler recipehandler = currenthandlers.get(recipetype);
for (int i = page * recipehandler.recipiesPerPage(); i < recipehandler.numRecipes() && i < (page + 1) * recipehandler.recipiesPerPage(); i++)
currenttip = recipehandler.handleTooltip(this, currenttip, i);
return currenttip;
}
@Override
public List<String> handleItemTooltip(GuiContainer gui, ItemStack stack, int mousex, int mousey, List<String> currenttip) {
IRecipeHandler recipehandler = currenthandlers.get(recipetype);
for (int i = page * recipehandler.recipiesPerPage(); i < recipehandler.numRecipes() && i < (page + 1) * recipehandler.recipiesPerPage(); i++)
currenttip = recipehandler.handleItemTooltip(this, stack, currenttip, i);
return currenttip;
}
@Override
public List<String> handleItemDisplayName(GuiContainer gui, ItemStack itemstack, List<String> currenttip) {
return currenttip;
}
private void nextPage() {
page++;
if (page > (currenthandlers.get(recipetype).numRecipes() - 1) / currenthandlers.get(recipetype).recipiesPerPage())
page = 0;
}
private void prevPage() {
page--;
if (page < 0)
page = (currenthandlers.get(recipetype).numRecipes() - 1) / currenthandlers.get(recipetype).recipiesPerPage();
}
private void nextType() {
recipetype++;
if (recipetype >= currenthandlers.size())
recipetype = 0;
page = 0;
}
private void prevType() {
recipetype--;
if (recipetype < 0)
recipetype = currenthandlers.size() - 1;
page = 0;
}
private void overlayRecipe(int recipe) {
IRecipeOverlayRenderer renderer = currenthandlers.get(recipetype).getOverlayRenderer(firstGui, recipe);
IOverlayHandler handler = currenthandlers.get(recipetype).getOverlayHandler(firstGui, recipe);
boolean shift = NEIClientUtils.shiftKey();
if (handler != null && (renderer == null || shift)) {
mc.displayGuiScreen(firstGui);
handler.overlayRecipe(firstGui, currenthandlers.get(recipetype), recipe, shift);
} else if (renderer != null) {
mc.displayGuiScreen(firstGui);
LayoutManager.overlayRenderer = renderer;
}
}
public void refreshPage() {
refreshSlots();
IRecipeHandler handler = currenthandlers.get(recipetype);
boolean multiplepages = handler.numRecipes() > handler.recipiesPerPage();
nextpage.visible = multiplepages;
prevpage.visible = multiplepages;
if(firstGui != null) {
overlay1.yPosition = (height - ySize) / 2 + (handler.recipiesPerPage() == 2 ? 63 : 128);
overlay1.visible = handler.hasOverlay(firstGui, firstGui.inventorySlots, page * handler.recipiesPerPage());
overlay2.visible = handler.recipiesPerPage() == 2 && page * handler.recipiesPerPage() + 1 < handler.numRecipes() &&
handler.hasOverlay(firstGui, firstGui.inventorySlots, page * handler.recipiesPerPage() + 1);
} else {
overlay1.visible = overlay2.visible = false;
}
}
private void refreshSlots() {
slotcontainer.inventorySlots.clear();
IRecipeHandler recipehandler = currenthandlers.get(recipetype);
for (int i = page * recipehandler.recipiesPerPage(); i < recipehandler.numRecipes() && i < (page + 1) * recipehandler.recipiesPerPage(); i++) {
Point p = getRecipePosition(i);
List<PositionedStack> stacks = recipehandler.getIngredientStacks(i);
for (PositionedStack stack : stacks)
slotcontainer.addSlot(stack, p.x, p.y);
stacks = recipehandler.getOtherStacks(i);
for (PositionedStack stack : stacks)
slotcontainer.addSlot(stack, p.x, p.y);
PositionedStack result = recipehandler.getResultStack(i);
if (result != null)
slotcontainer.addSlot(result, p.x, p.y);
}
}
@Override
protected void drawGuiContainerForegroundLayer(int par1, int par2) {
GuiContainerManager.enable2DRender();
IRecipeHandler recipehandler = currenthandlers.get(recipetype);
String s = recipehandler.getRecipeName();
fontRendererObj.drawString(s, (xSize - fontRendererObj.getStringWidth(s)) / 2, 5, 0x404040);
s = NEIClientUtils.translate("recipe.page", page + 1, (currenthandlers.get(recipetype).numRecipes() - 1) / recipehandler.recipiesPerPage() + 1);
fontRendererObj.drawString(s, (xSize - fontRendererObj.getStringWidth(s)) / 2, ySize - 16, 0x404040);
GL11.glPushMatrix();
GL11.glTranslatef(5, 16, 0);
for (int i = page * recipehandler.recipiesPerPage(); i < recipehandler.numRecipes() && i < (page + 1) * recipehandler.recipiesPerPage(); i++) {
recipehandler.drawForeground(i);
GL11.glTranslatef(0, 65, 0);
}
GL11.glPopMatrix();
}
@Override
protected void drawGuiContainerBackgroundLayer(float f, int mx, int my) {
GL11.glColor4f(1, 1, 1, 1);
CCRenderState.changeTexture("nei:textures/gui/recipebg.png");
int j = (width - xSize) / 2;
int k = (height - ySize) / 2;
drawTexturedModalRect(j, k, 0, 0, xSize, ySize);
GL11.glPushMatrix();
GL11.glTranslatef(j + 5, k + 16, 0);
IRecipeHandler recipehandler = currenthandlers.get(recipetype);
for (int i = page * recipehandler.recipiesPerPage(); i < recipehandler.numRecipes() && i < (page + 1) * recipehandler.recipiesPerPage(); i++) {
recipehandler.drawBackground(i);
GL11.glTranslatef(0, 65, 0);
}
GL11.glPopMatrix();
}
@Override
public GuiContainer getFirstScreen() {
return firstGui;
}
public boolean isMouseOver(PositionedStack stack, int recipe) {
Slot stackSlot = slotcontainer.getSlotWithStack(stack, getRecipePosition(recipe).x, getRecipePosition(recipe).y);
Point mousepos = GuiDraw.getMousePosition();
Slot mouseoverSlot = getSlotAtPosition(mousepos.x, mousepos.y);
return stackSlot == mouseoverSlot;
}
public Point getRecipePosition(int recipe) {
return new Point(5, 16 + (recipe % currenthandlers.get(recipetype).recipiesPerPage()) * 65);
}
@Override
public void mouseScrolled(int i) {
if (new Rectangle(guiLeft, guiTop, xSize, ySize).contains(GuiDraw.getMousePosition())) {
if (i > 0)
prevPage();
else
nextPage();
}
}
public abstract ArrayList<? extends IRecipeHandler> getCurrentRecipeHandlers();
}
@@ -0,0 +1,818 @@
package codechicken.nei;
import codechicken.core.CommonUtils;
import codechicken.lib.vec.Rectangle4i;
import codechicken.nei.util.NBTJson;
import codechicken.nei.recipe.StackInfo;
import codechicken.nei.recipe.BookmarkRecipeId;
import codechicken.nei.guihook.GuiContainerManager;
import com.google.gson.JsonParser;
import com.google.gson.JsonPrimitive;
import com.google.gson.JsonObject;
import com.google.gson.JsonSyntaxException;
import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import org.apache.commons.io.IOUtils;
import static codechicken.lib.gui.GuiDraw.getMousePosition;
import static codechicken.lib.gui.GuiDraw.drawRect;
import java.awt.Point;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.HashMap;
public class BookmarkPanel extends ItemPanel
{
protected File bookmarkFile;
protected boolean bookmarksIsLoaded = false;
public int sortedStackIndex = -1;
public int sortedNamespaceIndex = -1;
public Button namespacePrev;
public Button namespaceNext;
public Label namespaceLabel;
protected ArrayList<BookmarkGrid> namespaces = new ArrayList<>();
public int activeNamespaceIndex = 0;
protected static class BookmarkStackMeta
{
public int factor;
public BookmarkRecipeId recipeId;
public boolean ingredient = false;
public BookmarkStackMeta(BookmarkRecipeId recipeId, int count, boolean ingredient)
{
this.recipeId = recipeId;
this.factor = count;
this.ingredient = ingredient;
}
}
protected static class BookmarkGrid extends ItemsGrid
{
protected List<BookmarkStackMeta> metadata = new ArrayList<>();
public int indexOf(ItemStack stackA, BookmarkRecipeId recipeId)
{
final boolean useNBT = NEIClientConfig.useNBTInBookmarks();
for (int idx = 0; idx < realItems.size(); idx++) {
final BookmarkStackMeta meta = getMetadata(idx);
if ((recipeId == null && meta.recipeId == null || recipeId != null && meta.recipeId != null && recipeId.equals(meta.recipeId)) && StackInfo.equalItemAndNBT(stackA, realItems.get(idx), useNBT)) {
return idx;
}
}
return -1;
}
public BookmarkStackMeta getMetadata(int idx)
{
return metadata.get(idx);
}
public void addItem(ItemStack stackA, BookmarkStackMeta meta)
{
realItems.add(stackA);
metadata.add(meta);
}
public void replaceItem(int idx, ItemStack stack)
{
realItems.set(idx, stack);
}
public void removeRecipe(int idx, boolean removeFullRecipe)
{
final BookmarkStackMeta meta = getMetadata(idx);
if (removeFullRecipe && meta.recipeId != null) {
removeRecipe(meta.recipeId);
} else {
removeItem(idx);
}
}
public void removeRecipe(BookmarkRecipeId recipeIdA)
{
BookmarkRecipeId recipeIdB;
for (int slotIndex = metadata.size() - 1; slotIndex >= 0; slotIndex--) {
recipeIdB = getRecipeId(slotIndex);
if (recipeIdB != null && recipeIdA.equals(recipeIdB)) {
removeItem(slotIndex);
}
}
}
protected boolean removeItem(int idx)
{
realItems.remove(idx);
metadata.remove(idx);
return true;
}
public BookmarkRecipeId getRecipeId(int idx)
{
return getMetadata(idx).recipeId;
}
public BookmarkRecipeId findRecipeId(ItemStack stackA)
{
final boolean useNBT = NEIClientConfig.useNBTInBookmarks();
for (int idx = 0; idx < realItems.size(); idx++) {
if (StackInfo.equalItemAndNBT(stackA, getItem(idx), useNBT)) {
return getRecipeId(idx);
}
}
return null;
}
public void moveItem(int src, int dst)
{
realItems.add(dst, realItems.remove(src));
metadata.add(dst, metadata.remove(src));
}
@Override
protected void drawItem(Rectangle4i rect, int idx, ItemPanelSlot focus)
{
if (LayoutManager.bookmarkPanel.sortedNamespaceIndex == LayoutManager.bookmarkPanel.activeNamespaceIndex && LayoutManager.bookmarkPanel.sortedStackIndex == idx) {
drawRect(rect.x, rect.y, rect.w, rect.h, 0xee555555);//highlight
} else {
if (focus != null) {
if (focus.slotIndex == idx) {
drawRect(rect.x, rect.y, rect.w, rect.h, 0xee555555);//highlight
} else if (
LayoutManager.bookmarkPanel.sortedStackIndex == -1 && //disabled when sorting
NEIClientUtils.shiftKey() && //show only with shift key
getRecipeId(focus.slotIndex) != null && getRecipeId(idx) != null && getRecipeId(focus.slotIndex).equals(getRecipeId(idx))//is some recipeId
) {
drawRect(rect.x, rect.y, rect.w, rect.h, getMetadata(idx).ingredient? 0x88b3b300: 0x88009933);//highlight recipe
}
}
GuiContainerManager.drawItem(rect.x + 1, rect.y + 1, getItem(idx), true);
}
}
}
public BookmarkPanel()
{
grid = new BookmarkGrid();
}
public void init()
{
super.init();
namespaceLabel = new Label("1", true);
namespacePrev = new Button("Prev")
{
public boolean onButtonPress(boolean rightclick)
{
if (rightclick) {
return false;
}
return prevNamespace();
}
@Override
public String getRenderLabel()
{
return "<";
}
};
namespaceNext = new Button("Next")
{
public boolean onButtonPress(boolean rightclick)
{
if (rightclick) {
return false;
}
return nextNamespace();
}
@Override
public String getRenderLabel()
{
return ">";
}
};
namespaces.add(new BookmarkGrid());
grid = namespaces.get(activeNamespaceIndex);
}
@Override
public String getLabelText()
{
return super.getLabelText() + " [" + grid.size() + "]";
}
public void addOrRemoveItem(ItemStack stackA)
{
addOrRemoveItem(stackA, "", null);
}
public void addOrRemoveItem(ItemStack stackover, String handlerName, List<PositionedStack> ingredients)
{
loadBookmarksIfNeeded();
final Point mousePos = getMousePosition();
final ItemPanelSlot slot = getSlotMouseOver(mousePos.x, mousePos.y);
final boolean addFullRecipe = NEIClientUtils.shiftKey();
final BookmarkGrid BGrid = (BookmarkGrid) grid;
if (slot != null && StackInfo.equalItemAndNBT(slot.item, stackover, true)) {
BGrid.removeRecipe(slot.slotIndex, addFullRecipe);
} else {
final boolean saveStackSize = NEIClientUtils.controlKey();
final NBTTagCompound nbTagA = StackInfo.itemStackToNBT(stackover, saveStackSize);
final ItemStack normalizedA = StackInfo.loadFromNBT(nbTagA);
BookmarkRecipeId recipeId = null;
if (NEIClientConfig.saveCurrentRecipeInBookmarksEnabled() && handlerName != "" && ingredients != null && ingredients.size() > 0) {
recipeId = new BookmarkRecipeId(handlerName, ingredients);
}
final int idx = BGrid.indexOf(normalizedA, recipeId);
if (idx != -1) {
BGrid.removeRecipe(idx, addFullRecipe);
} else {
if (addFullRecipe && handlerName != "" && ingredients != null) {
final Map<NBTTagCompound, Integer> unique = new HashMap<>();
final ArrayList<NBTTagCompound> sorted = new ArrayList<>();
BGrid.removeRecipe(recipeId);
for (PositionedStack stack : ingredients) {
final NBTTagCompound nbTag = StackInfo.itemStackToNBT(stack.item, saveStackSize);
if (unique.get(nbTag) == null) {
unique.put(nbTag, 1);
sorted.add(nbTag);
} else if (saveStackSize) {
unique.put(nbTag, unique.get(nbTag) + 1);
}
}
for (NBTTagCompound nbTag : sorted) {
nbTag.setInteger("Count", nbTag.getInteger("Count") * unique.get(nbTag));
BGrid.addItem(StackInfo.loadFromNBT(nbTag), new BookmarkStackMeta(recipeId, nbTag.getInteger("Count"), true));
}
}
BGrid.addItem(normalizedA, new BookmarkStackMeta(recipeId, nbTagA.getInteger("Count"), false));
}
}
fixCountOfNamespaces();
saveBookmarks();
}
public BookmarkRecipeId getBookmarkRecipeId(ItemStack stackA)
{
final Point mousePos = getMousePosition();
final ItemPanelSlot slot = getSlotMouseOver(mousePos.x, mousePos.y);
if (slot != null && StackInfo.equalItemAndNBT(slot.item, stackA, true)) {
return ((BookmarkGrid) grid).getRecipeId(slot.slotIndex);
}
BookmarkRecipeId recipeId = ((BookmarkGrid) grid).findRecipeId(stackA);
if (recipeId == null) {
for (int idx = 0; idx < namespaces.size() && recipeId == null; idx++) {
if (idx == activeNamespaceIndex) continue;
recipeId = namespaces.get(idx).findRecipeId(stackA);
}
}
return recipeId;
}
protected String getNamespaceLabelText(boolean shortFormat)
{
String activePage = String.valueOf(activeNamespaceIndex + 1);
return shortFormat? activePage: (activePage + "/" + fixCountOfNamespaces());
}
protected int fixCountOfNamespaces()
{
if (namespaces.get(namespaces.size() - 1).size() > 0) {
namespaces.add(new BookmarkGrid());
} else if (activeNamespaceIndex == namespaces.size() - 2 && grid.size() == 0) {
namespaces.remove(namespaces.size() - 1);
}
return namespaces.size();
}
protected boolean removeEmptyNamespaces()
{
if (activeNamespaceIndex != namespaces.size() - 1 && grid.size() == 0) {
namespaces.remove(activeNamespaceIndex);
grid = namespaces.get(activeNamespaceIndex);
return true;
}
return false;
}
protected boolean prevNamespace()
{
if (!bookmarksIsLoaded) {
return false;
}
fixCountOfNamespaces();
removeEmptyNamespaces();
if (activeNamespaceIndex == 0) {
activeNamespaceIndex = namespaces.size() - 1;
} else {
activeNamespaceIndex --;
}
grid = namespaces.get(activeNamespaceIndex);
return true;
}
protected boolean nextNamespace()
{
if (!bookmarksIsLoaded) {
return false;
}
if (removeEmptyNamespaces()) {
return true;
}
if (activeNamespaceIndex == fixCountOfNamespaces() - 1) {
activeNamespaceIndex = 0;
} else {
activeNamespaceIndex ++;
}
grid = namespaces.get(activeNamespaceIndex);
return true;
}
public void setBookmarkFile(String worldPath)
{
final File dir = new File(CommonUtils.getMinecraftDir(), "saves/NEI/" + worldPath);
if (!dir.exists()) {
dir.mkdirs();
}
bookmarkFile = new File(dir, "bookmarks.ini");
if (!bookmarkFile.exists()) {
final File globalBookmarks = new File(CommonUtils.getMinecraftDir(), "saves/NEI/global/bookmarks.ini");
final File configBookmarks = new File(NEIClientConfig.configDir, "bookmarks.ini");
final File defaultBookmarks = configBookmarks.exists()? configBookmarks: globalBookmarks;
if (defaultBookmarks.exists()) {
try {
bookmarkFile.createNewFile();
InputStream src = new FileInputStream(defaultBookmarks);
OutputStream dst = new FileOutputStream(bookmarkFile);
IOUtils.copy(src, dst);
src.close();
dst.close();
} catch(IOException e) {}
}
}
bookmarksIsLoaded = false;
}
public void saveBookmarks()
{
ArrayList<String> strings = new ArrayList<>();
for (int grpIdx = 0; grpIdx < namespaces.size() - 1; grpIdx++) {
final BookmarkGrid grid = namespaces.get(grpIdx);
if (grpIdx > 0) {
strings.add("");//namespace separator; ignore first namespace
}
for (int idx = 0; idx < grid.size(); idx++) {
try {
final NBTTagCompound nbTag = StackInfo.itemStackToNBT(grid.getItem(idx));
if (nbTag != null) {
JsonObject row = new JsonObject();
BookmarkStackMeta meta = grid.getMetadata(idx);
row.add("item", NBTJson.toJsonObject(nbTag));
row.add("factor", new JsonPrimitive(meta.factor));
row.add("ingredient", new JsonPrimitive(meta.ingredient));
if (meta.recipeId != null) {
row.add("recipeId", meta.recipeId.toJsonObject());
}
strings.add(NBTJson.toJson(row));
}
} catch (JsonSyntaxException e) {
NEIClientConfig.logger.error("Failed to stringify bookmarked ItemStack to json string");
}
}
}
if (bookmarkFile != null) {
try(FileWriter writer = new FileWriter(bookmarkFile)) {
IOUtils.writeLines(strings, "\n", writer);
} catch (IOException e) {
NEIClientConfig.logger.error("Filed to save bookmarks list to file {}", bookmarkFile, e);
}
}
}
public void loadBookmarksIfNeeded()
{
if (bookmarksIsLoaded) {
return;
}
bookmarksIsLoaded = true;
if (bookmarkFile == null || !bookmarkFile.exists()) {
return;
}
List<String> itemStrings;
try (FileReader reader = new FileReader(bookmarkFile)) {
NEIClientConfig.logger.info("Loading bookmarks from file {}", bookmarkFile);
itemStrings = IOUtils.readLines(reader);
} catch (IOException e) {
NEIClientConfig.logger.error("Failed to load bookmarks from file {}", bookmarkFile, e);
return;
}
namespaces.clear();
namespaces.add(new BookmarkGrid());
activeNamespaceIndex = 0;
final JsonParser parser = new JsonParser();
for (String itemStr: itemStrings) {
try {
if (itemStr.isEmpty()) {
if (namespaces.get(activeNamespaceIndex).size() > 0) {
//do not create empty namespaces
namespaces.add(new BookmarkGrid());
activeNamespaceIndex++;
}
continue;
}
JsonObject jsonObject = parser.parse(itemStr).getAsJsonObject();
BookmarkRecipeId recipeId = null;
NBTTagCompound itemStackNBT;
if (jsonObject.get("item") != null) {
itemStackNBT = (NBTTagCompound) NBTJson.toNbt(jsonObject.get("item"));
} else {// old format
itemStackNBT = (NBTTagCompound) NBTJson.toNbt(jsonObject);
}
if (jsonObject.get("recipeId") != null && jsonObject.get("recipeId") instanceof JsonObject) {
recipeId = new BookmarkRecipeId((JsonObject) jsonObject.get("recipeId"));
}
ItemStack itemStack = StackInfo.loadFromNBT(itemStackNBT);
if (itemStack != null) {
namespaces.get(activeNamespaceIndex).addItem(itemStack, new BookmarkStackMeta(
recipeId,
jsonObject.has("factor")? jsonObject.get("factor").getAsInt(): 1,
jsonObject.has("ingredient")? jsonObject.get("ingredient").getAsBoolean(): false
));
} else {
NEIClientConfig.logger.warn("Failed to load bookmarked ItemStack from json string, the item no longer exists:\n{}", itemStr);
}
} catch (IllegalArgumentException | JsonSyntaxException e) {
NEIClientConfig.logger.error("Failed to load bookmarked ItemStack from json string:\n{}", itemStr);
}
}
if (namespaces.get(activeNamespaceIndex).size() == 0) {
activeNamespaceIndex = Math.max(activeNamespaceIndex - 1, 0);
}
grid = namespaces.get(activeNamespaceIndex);
}
@Override
public void resize(GuiContainer gui)
{
loadBookmarksIfNeeded();
super.resize(gui);
final int buttonHeight = 16;
final int buttonWidth = 16;
final int buttonTop = gui.height - buttonHeight - 2;
final int leftBorder = LayoutManager.bookmarksButton.x + LayoutManager.bookmarksButton.w + 2;
final int rightBorder = x + w;
final int center = leftBorder + (rightBorder - leftBorder) / 2;
int labelWidth = 2;
namespacePrev.h = namespaceNext.h = buttonHeight;
namespacePrev.w = namespaceNext.w = buttonWidth;
namespacePrev.y = namespaceNext.y = buttonTop;
if (rightBorder - leftBorder >= 70) {
labelWidth = 36;
namespaceLabel.text = getNamespaceLabelText(false);
} else {
labelWidth = 18;
namespaceLabel.text = getNamespaceLabelText(true);
}
namespaceLabel.y = buttonTop + 5;
namespaceLabel.x = center;
namespacePrev.x = center - labelWidth / 2 - 2 - namespacePrev.w;
namespaceNext.x = center + labelWidth / 2 + 2;
}
@Override
public void setVisible()
{
super.setVisible();
LayoutManager.addWidget(namespacePrev);
LayoutManager.addWidget(namespaceNext);
LayoutManager.addWidget(namespaceLabel);
}
@Override
public int getMarginLeft(GuiContainer gui)
{
return 5;
}
@Override
public int getMarginTop(GuiContainer gui)
{
LayoutStyleMinecraft layout = (LayoutStyleMinecraft)LayoutManager.getLayoutStyle();
return 2 + (((int)Math.ceil((double)layout.buttonCount / layout.numButtons)) * 18);
}
@Override
public int getWidth(GuiContainer gui)
{
return LayoutManager.getLeftSize(gui) - ((gui.xSize + gui.width) / 2 + 3) - 16;
}
@Override
public int getHeight(GuiContainer gui)
{
// - 19 = 22 + 1 -> input in bottom
return gui.height - getMarginTop(gui) - 23;
}
@Override
public void mouseDragged(int mousex, int mousey, int button, long heldTime)
{
if (button == 0 && NEIClientUtils.shiftKey() && mouseDownSlot >= 0) {
ItemPanelSlot mouseOverSlot = getSlotMouseOver(mousex, mousey);
if (sortedStackIndex == -1) {
final ItemStack stack = grid.getItem(mouseDownSlot);
if (stack != null && (mouseOverSlot == null || mouseOverSlot.slotIndex != mouseDownSlot || heldTime > 250)) {
sortedNamespaceIndex = activeNamespaceIndex;
sortedStackIndex = mouseDownSlot;
}
} else {
if (mouseOverSlot == null && sortedNamespaceIndex != activeNamespaceIndex) {
mouseOverSlot = getNextSlot(mousex, mousey);
}
if (mouseOverSlot != null) {
if (sortedNamespaceIndex != activeNamespaceIndex) {
BookmarkGrid BGrid = namespaces.get(sortedNamespaceIndex);
BookmarkStackMeta meta = BGrid.getMetadata(sortedStackIndex);
ItemStack stack = BGrid.getItem(sortedStackIndex);
BGrid.removeItem(sortedStackIndex);
((BookmarkGrid) grid).addItem(stack, meta);
sortedNamespaceIndex = activeNamespaceIndex;
sortedStackIndex = grid.size() - 1;
}
if (mouseOverSlot.slotIndex != sortedStackIndex) {
((BookmarkGrid) grid).moveItem(sortedStackIndex, mouseOverSlot.slotIndex);
sortedStackIndex = mouseOverSlot.slotIndex;
}
}
}
return;
}
super.mouseDragged(mousex, mousey, button, heldTime);
}
private ItemPanelSlot getNextSlot(int mousex, int mousey)
{
int idx = grid.getPage() * grid.getPerPage() - grid.getPerPage();
int gSize = grid.size();
for (int i = 0; i < grid.getRows() * grid.getColumns() && idx <= gSize; i++) {
if (!grid.isInvalidSlot(i)) {
if (idx == gSize && grid.getSlotRect(i).contains(mousex, mousey)) {
return new ItemPanelSlot(idx, null);
}
idx++;
}
}
return null;
}
@Override
public void postDraw(int mousex, int mousey)
{
if (sortedStackIndex != -1) {
GuiContainerManager.drawItems.zLevel += 100;
GuiContainerManager.drawItem(mousex - 8, mousey - 8, namespaces.get(sortedNamespaceIndex).getItem(sortedStackIndex).copy(), true);
GuiContainerManager.drawItems.zLevel -= 100;
}
super.postDraw(mousex, mousey);
}
@Override
protected ItemStack getDraggedStackWithQuantity(int mouseDownSlot)
{
ItemStack stack = grid.getItem(mouseDownSlot);
return stack != null? stack.copy(): null;
}
@Override
public void mouseUp(int mousex, int mousey, int button)
{
if (sortedStackIndex != -1) {
sortedNamespaceIndex = -1;
sortedStackIndex = -1;
mouseDownSlot = -1;
saveBookmarks();
} else {
super.mouseUp(mousex, mousey, button);
}
}
@Override
public boolean onMouseWheel(int shift, int mousex, int mousey)
{
if (new Rectangle4i(namespacePrev.x, namespacePrev.y, namespaceNext.x + namespaceNext.w - namespacePrev.x, namespacePrev.h).contains(mousex, mousey)) {
if (shift > 0) {
prevNamespace();
} else {
nextNamespace();
}
return true;
}
if (!contains(mousex, mousey)) {
return false;
}
if (NEIClientUtils.controlKey()) {
final ItemPanelSlot slot = getSlotMouseOver(mousex, mousey);
if (slot != null) {
final BookmarkGrid BGrid = (BookmarkGrid)grid;
final BookmarkRecipeId recipeId = BGrid.getRecipeId(slot.slotIndex);
final BookmarkStackMeta meta = BGrid.getMetadata(slot.slotIndex);
final boolean addFullRecipe = NEIClientUtils.shiftKey();
if (addFullRecipe) {
BookmarkStackMeta iMeta;
for (int slotIndex = grid.size() - 1; slotIndex >= 0; slotIndex--) {
iMeta = BGrid.getMetadata(slotIndex);
if (iMeta.recipeId != null && iMeta.recipeId.equals(recipeId)) {
NBTTagCompound nbTag = StackInfo.itemStackToNBT(BGrid.getItem(slotIndex), true);
nbTag.setInteger("Count", Math.max(nbTag.getInteger("Count") + iMeta.factor * shift, iMeta.factor));
BGrid.replaceItem(slotIndex, StackInfo.loadFromNBT(nbTag));
}
}
}
NBTTagCompound nbTag = StackInfo.itemStackToNBT(slot.item, true);
nbTag.setInteger("Count", Math.max(nbTag.getInteger("Count") + meta.factor * shift, meta.factor));
BGrid.replaceItem(slot.slotIndex, StackInfo.loadFromNBT(nbTag));
saveBookmarks();
return true;
}
}
return super.onMouseWheel(shift, mousex, mousey);
}
}
@@ -42,15 +42,20 @@ public abstract class Button extends Widget
if (!contains(mx, my))
return tooltip;
String tip = getButtonTip();
final String tip = getButtonTip();
if (tip != null)
tooltip.add(tip);
addTooltips(tooltip);
return tooltip;
}
public String getButtonTip() {
return null;
}
public void addTooltips(List<String> tooltip) {}
public String getRenderLabel() {
return label;
@@ -2,12 +2,19 @@ package codechicken.nei;
public abstract class ButtonCycled extends Button
{
public ButtonCycled() {}
public ButtonCycled(int num) {
icons = new Image[num];
init();
}
@Override
public Image getRenderIcon()
{
return icons[index];
}
public void init() {}
public int index;
public Image[] icons;
}
@@ -5,8 +5,11 @@ import codechicken.core.GuiModListScroll;
import codechicken.lib.packet.PacketCustom;
import codechicken.nei.api.API;
import codechicken.nei.api.ItemInfo;
import codechicken.nei.recipe.GuiRecipeTab;
import com.google.common.collect.Lists;
import cpw.mods.fml.client.CustomModLoadingErrorDisplayException;
import cpw.mods.fml.common.FMLCommonHandler;
import cpw.mods.fml.common.Loader;
import cpw.mods.fml.common.eventhandler.SubscribeEvent;
import cpw.mods.fml.common.gameevent.TickEvent;
import cpw.mods.fml.common.gameevent.TickEvent.Phase;
@@ -23,13 +26,53 @@ import net.minecraft.entity.item.EntityItem;
import net.minecraft.world.World;
import net.minecraftforge.client.event.RenderWorldLastEvent;
import net.minecraftforge.common.MinecraftForge;
import org.apache.commons.csv.CSVFormat;
import org.apache.commons.csv.CSVParser;
import org.apache.commons.csv.CSVRecord;
import org.apache.commons.io.IOUtils;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
public class ClientHandler
{
private static String[] defaultSerialHandlers = {
"WayofTime.alchemicalWizardry.client.nei.NEIAlchemyRecipeHandler"
};
private static String[] defaultHeightHackHandlerRegex = {
"buildcraft.compat.nei.*",
"cofh.thermalexpansion.plugins.nei.handlers.*",
"crazypants.enderio.nei.*",
"forestry.factory.recipes.nei.*",
"ic2.neiIntegration.core.recipehandler.*",
"mariculture.plugins.nei.*",
"redgear.brewcraft.plugins.nei.*",
"tconstruct.plugins.nei.*",
"WayofTime.alchemicalWizardry.client.nei.*",
};
private static String[] defaultHandlerOrdering = {
"# Each line in this file should either be a comment (starts with '#') or an ordering.",
"# Ordering lines are <handler ID>,<ordering number>.",
"# Handlers will be sorted in order of number ascending, so smaller numbers first.",
"# Any handlers that are missing from this file will be assigned to 0.",
"# Negative numbers are fine.",
"# If you delete this file, it will be regenerated with all registered handler IDs.",
};
private static ClientHandler instance;
private ArrayList<EntityItem> SMPmagneticItems = new ArrayList<>();
@@ -114,8 +157,52 @@ public class ClientHandler
}
public static void preInit() {
loadSerialHandlers();
loadHeightHackHandlers();
ItemInfo.preInit();
}
public static void loadSerialHandlers() {
File file = NEIClientConfig.serialHandlersFile;
if(!file.exists()) {
try(FileWriter writer = new FileWriter(file)) {
NEIClientConfig.logger.info("Creating default serial handlers list {}", file);
Collection<String> toSave = Loader.isModLoaded("dreamcraft") ? Collections.singletonList("") : Arrays.asList(defaultSerialHandlers);
IOUtils.writeLines(toSave, "\n", writer);
} catch (IOException e) {
NEIClientConfig.logger.error("Failed to save default serial handlers list to file {}", file, e);
}
}
try (FileReader reader = new FileReader(file)) {
NEIClientConfig.logger.info("Loading serial handlers from file {}", file);
NEIClientConfig.serialHandlers = new HashSet<>(IOUtils.readLines(reader));
} catch (IOException e) {
NEIClientConfig.logger.error("Failed to load serial handlers from file {}", file, e);
}
}
public static void loadHeightHackHandlers() {
File file = NEIClientConfig.heightHackHandlersFile;
if (!file.exists()) {
try (FileWriter writer = new FileWriter(file)) {
NEIClientConfig.logger.info("Creating default height hack handlers list {}", file);
Collection<String> toSave = Arrays.asList(defaultHeightHackHandlerRegex);
IOUtils.writeLines(toSave, "\n", writer);
} catch (IOException e) {
NEIClientConfig.logger.error("Failed to save default height hack handlers list to file {}", file, e);
}
}
try (FileReader reader = new FileReader(file)) {
NEIClientConfig.logger.info("Loading height hack handlers from file {}", file);
NEIClientConfig.heightHackHandlerRegex =
IOUtils.readLines(reader).stream()
.map(Pattern::compile)
.collect(Collectors.toCollection(HashSet::new));
} catch (IOException e) {
NEIClientConfig.logger.error("Failed to load height hack handlers from file {}", file, e);
}
}
public static void load() {
instance = new ClientHandler();
@@ -130,6 +217,58 @@ public class ClientHandler
WorldOverlayRenderer.load();
}
public static void postInit() {
loadHandlerOrdering();
}
public static void loadHandlerOrdering() {
File file = NEIClientConfig.handlerOrderingFile;
if (!file.exists()) {
try (FileWriter writer = new FileWriter(file)) {
NEIClientConfig.logger.info("Creating default handler ordering CSV {}", file);
List<String> toWrite = Lists.newArrayList(defaultHandlerOrdering);
GuiRecipeTab.handlerMap.keySet().stream()
.sorted()
.forEach(handlerId -> toWrite.add(String.format("%s,0", handlerId)));
IOUtils.writeLines(toWrite, "\n", writer);
} catch (IOException e) {
NEIClientConfig.logger.error("Failed to save default handler ordering to file {}", file, e);
}
}
URL url;
try {
url = file.toURI().toURL();
} catch (MalformedURLException e) {
NEIClientConfig.logger.info("Invalid URL for handler ordering CSV.");
e.printStackTrace();
return;
}
try (BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream()))) {
NEIClientConfig.logger.info("Loading handler ordering from file {}", file);
CSVParser csvParser = CSVFormat.EXCEL.withCommentMarker('#').parse(reader);
for (CSVRecord record : csvParser) {
final String handlerId = record.get(0);
int ordering;
try {
ordering = Integer.parseInt(record.get(1));
} catch (NumberFormatException e) {
NEIClientConfig.logger.error("Error parsing CSV record {}: {}", record, e);
continue;
}
NEIClientConfig.handlerOrdering.put(handlerId, ordering);
}
} catch (Exception e) {
NEIClientConfig.logger.info("Error parsing CSV");
e.printStackTrace();
}
}
@SubscribeEvent
public void tickEvent(TickEvent.ClientTickEvent event) {
if(event.phase == Phase.END)
@@ -0,0 +1,22 @@
package codechicken.nei;
import codechicken.nei.api.ItemFilter;
import net.minecraft.item.ItemStack;
public class DoubleFilteredFilter implements ItemFilter {
private ItemFilter filter;
private ItemList.PatternItemFilter patternFilter;
public DoubleFilteredFilter(ItemFilter filter, String itemFilter) {
this.filter = filter;
this.patternFilter = new ItemList.PatternItemFilter(SearchField.getPattern(itemFilter));
}
@Override
public boolean matches(ItemStack item) {
if(filter.matches(item)) {
return patternFilter.matches(item);
}
return false;
}
}
File renamed without changes.
@@ -182,15 +182,16 @@ public class ItemList
}
@Override
@SuppressWarnings("unchecked")
public void execute() {
// System.out.println("Executing NEI Item Loading");
ThreadOperationTimer timer = getTimer(500);
ThreadOperationTimer timer = getTimer(NEIClientConfig.getItemLoadingTimeout());
LinkedList<ItemStack> items = new LinkedList<>();
LinkedList<ItemStack> permutations = new LinkedList<>();
ListMultimap<Item, ItemStack> itemMap = ArrayListMultimap.create();
timer.setLimit(500);
timer.setLimit(NEIClientConfig.getItemLoadingTimeout());
for (Item item : (Iterable<Item>) Item.itemRegistry) {
if (interrupted()) return;
@@ -0,0 +1,546 @@
package codechicken.nei;
import codechicken.nei.api.GuiInfo;
import codechicken.nei.api.INEIGuiHandler;
import codechicken.nei.guihook.GuiContainerManager;
import codechicken.nei.recipe.GuiCraftingRecipe;
import codechicken.nei.recipe.GuiRecipe;
import codechicken.nei.recipe.GuiUsageRecipe;
import codechicken.nei.recipe.StackInfo;
import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.client.gui.inventory.GuiContainerCreative;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.fluids.IFluidContainerItem;
import static codechicken.nei.LayoutManager.searchField;
import java.util.ArrayList;
import java.util.regex.Pattern;
public class ItemPanel extends Widget
{
public ItemStack draggedStack;
public int mouseDownSlot = -1;
public Button pagePrev;
public Button pageNext;
public Label pageLabel;
/**
* Backwards compat :-/
*/
@Deprecated
private int itemsPerPage = 0;
@Deprecated
public static ArrayList<ItemStack> items = new ArrayList<>();
@Deprecated
public ArrayList<ItemStack> realItems = new ArrayList<>();
protected Pattern SPECIAL_REGEX_CHARS = Pattern.compile("[{}()\\[\\].+*?^$\\\\|]");
public static class ItemPanelSlot
{
public ItemStack item;
public int slotIndex;
public ItemPanelSlot(int idx, ItemStack stack)
{
slotIndex = idx;
item = stack;
}
@Deprecated
public ItemPanelSlot(int idx)
{
this(idx, ItemPanels.itemPanel.getGrid().getItem(idx));
}
}
protected static class ItemPanelGrid extends ItemsGrid
{
public ArrayList<ItemStack> newItems;
public void setItems(ArrayList<ItemStack> items)
{
newItems = items;
}
public void refresh(GuiContainer gui)
{
if (newItems != null) {
realItems = newItems;
newItems = null;
}
super.refresh(gui);
}
}
protected ItemsGrid grid = new ItemPanelGrid();
public ArrayList<ItemStack> getItems()
{
return grid.getItems();
}
public static void updateItemList(ArrayList<ItemStack> newItems)
{
((ItemPanelGrid) ItemPanels.itemPanel.getGrid()).setItems(newItems);
ItemPanels.itemPanel.realItems = newItems;
}
@Deprecated
public void scroll(int i)
{
grid.shiftPage(i);
}
public ItemsGrid getGrid()
{
return grid;
}
public void init() {
pageLabel = new Label("(0/0)", true);
pagePrev = new Button("Prev")
{
public boolean onButtonPress(boolean rightclick) {
if (!rightclick) {
grid.shiftPage(-1);
return true;
}
return false;
}
@Override
public String getRenderLabel() {
return "<";
}
};
pageNext = new Button("Next")
{
public boolean onButtonPress(boolean rightclick) {
if (!rightclick) {
grid.shiftPage(1);
return true;
}
return false;
}
@Override
public String getRenderLabel() {
return ">";
}
};
}
public int getMarginLeft(GuiContainer gui)
{
if (gui instanceof GuiContainerCreative && NEIClientUtils.getGamemode() == 2) {
//then activate creative+ first render creative gui and oly then creative+
return (gui.width + 176) / 2 + 2;
}
return (gui.width + gui.xSize) / 2 + 2;
}
public int getMarginTop(GuiContainer gui)
{
return 2;
}
public int getWidth(GuiContainer gui)
{
return LayoutManager.getSideWidth(gui) - getMarginLeft(gui);
}
public int getHeight(GuiContainer gui)
{
// - 19 = 2 + 16 + 1 -> input in bottom
return gui.height - getMarginTop(gui) - 19;
}
public String getLabelText()
{
return "(" + getPage() + "/" + Math.max(1, getNumPages()) + ")";
}
public void resize(GuiContainer gui)
{
final int marginLeft = getMarginLeft(gui);
final int marginTop = getMarginTop(gui);
final int width = getWidth(gui);
final int height = getHeight(gui);
final int buttonHeight = 16;
final int buttonWidth = 16;
pagePrev.w = pageNext.w = buttonWidth;
pagePrev.h = pageNext.h = buttonHeight;
pagePrev.y = pageNext.y = marginTop;
pagePrev.x = marginLeft;
pageNext.x = marginLeft + width - buttonWidth;
pageLabel.x = marginLeft + width / 2;
pageLabel.y = marginTop + 5;
pageLabel.text = getLabelText();
y = marginTop + buttonHeight + 2;
x = marginLeft;
w = width;
h = height - buttonHeight - 2;
grid.setGridSize(x, y, w, h);
grid.refresh(gui);
}
public void setVisible()
{
LayoutManager.addWidget(pagePrev);
LayoutManager.addWidget(pageNext);
LayoutManager.addWidget(pageLabel);
}
@Override
public void draw(int mousex, int mousey)
{
grid.draw(mousex, mousey);
}
@Override
public void postDraw(int mousex, int mousey) {
if (draggedStack != null) {
GuiContainerManager.drawItems.zLevel += 100;
GuiContainerManager.drawItem(mousex - 8, mousey - 8, draggedStack, true);
GuiContainerManager.drawItems.zLevel -= 100;
}
}
@Override
public void mouseDragged(int mousex, int mousey, int button, long heldTime) {
if (mouseDownSlot >= 0 && draggedStack == null && NEIClientUtils.getHeldItem() == null &&
NEIClientConfig.hasSMPCounterPart() && !GuiInfo.hasCustomSlots(NEIClientUtils.getGuiContainer())) {
ItemPanelSlot mouseOverSlot = getSlotMouseOver(mousex, mousey);
if (mouseOverSlot == null || mouseOverSlot.slotIndex != mouseDownSlot || heldTime > 500) {
draggedStack = getDraggedStackWithQuantity(mouseDownSlot);
}
}
}
protected ItemStack getDraggedStackWithQuantity(int mouseDownSlot)
{
ItemStack stack = grid.getItem(mouseDownSlot);
if (stack != null) {
int amount = NEIClientConfig.getItemQuantity();
if (amount == 0) {
amount = stack.getMaxStackSize();
}
return NEIServerUtils.copyStack(stack, amount);
}
return null;
}
@Override
public boolean handleClick(int mousex, int mousey, int button)
{
if (handleClickExt(mousex, mousey, button))
return true;
if (NEIClientUtils.getHeldItem() != null) {
if (!grid.contains(mousex, mousey)) {
return false;
}
if (NEIClientConfig.canPerformAction("delete") && NEIClientConfig.canPerformAction("item"))
if (button == 1)
NEIClientUtils.decreaseSlotStack(-999);
else
NEIClientUtils.deleteHeldItem();
else
NEIClientUtils.dropHeldItem();
return true;
}
ItemPanelSlot hoverSlot = getSlotMouseOver(mousex, mousey);
if (hoverSlot != null) {
if (button == 2) {
if (hoverSlot.item != null) {
draggedStack = getDraggedStackWithQuantity(hoverSlot.slotIndex);
}
} else {
mouseDownSlot = hoverSlot.slotIndex;
}
return true;
}
return false;
}
@Override
public boolean handleClickExt(int mouseX, int mouseY, int button)
{
if (ItemPanels.itemPanel.draggedStack != null) {
return ItemPanels.itemPanel.handleDraggedClick(mouseX, mouseY, button);
}
if (ItemPanels.bookmarkPanel.draggedStack != null) {
return ItemPanels.bookmarkPanel.handleDraggedClick(mouseX, mouseY, button);
}
return false;
}
protected boolean handleDraggedClick(int mouseX, int mouseY, int button)
{
if (draggedStack == null) {
return false;
}
if (handleFillFluidContainerClick(mouseX, mouseY, button)) {
return true;
}
if (handleSearchInputClick(mouseX, mouseY, button)) {
return true;
}
if (handleGUIContainerClick(mouseX, mouseY, button)) {
return true;
}
if (handleCheatItemClick(mouseX, mouseY, button)) {
return true;
}
final GuiContainer gui = NEIClientUtils.getGuiContainer();
if (mouseX < gui.guiLeft || mouseY < gui.guiTop || mouseX >= gui.guiLeft + gui.xSize || mouseY >= gui.guiTop + gui.ySize) {
draggedStack = null;
}
return true;
}
protected boolean handleFillFluidContainerClick(int mouseX, int mouseY, int button)
{
if (button == 2) {
return false;
}
ItemPanelSlot mouseOverSlot = ItemPanels.itemPanel.getSlotMouseOver(mouseX, mouseY);
if (mouseOverSlot == null) {
mouseOverSlot = ItemPanels.bookmarkPanel.getSlotMouseOver(mouseX, mouseY);
}
if (mouseOverSlot != null && draggedStack.getItem() instanceof IFluidContainerItem) {
FluidStack fluidStack = StackInfo.getFluid(mouseOverSlot.item);
if (fluidStack != null) {
final int stackSize = draggedStack.stackSize;
fluidStack = fluidStack.copy();
if (fluidStack.amount == 0) {
fluidStack.amount = 1000;
}
if (mouseOverSlot.item.stackSize > 1) {
fluidStack.amount *= mouseOverSlot.item.stackSize;
}
draggedStack.stackSize = 1;
((IFluidContainerItem) draggedStack.getItem()).fill(draggedStack, fluidStack, true);
draggedStack.stackSize = stackSize;
if (button == 1 && ((IFluidContainerItem) draggedStack.getItem()).getFluid(draggedStack) != null) {
ItemPanels.bookmarkPanel.addOrRemoveItem(draggedStack.copy());
}
}
return true;
}
return false;
}
protected boolean handleGUIContainerClick(int mouseX, int mouseY, int button)
{
final GuiContainer gui = NEIClientUtils.getGuiContainer();
boolean handled = false;
try {
GuiInfo.readLock.lock();
for (INEIGuiHandler handler : GuiInfo.guiHandlers) {
if (handler.handleDragNDrop(gui, mouseX, mouseY, draggedStack, button)) {
handled = true;
break;
}
}
} finally {
GuiInfo.readLock.unlock();
}
if (draggedStack.stackSize == 0) {
draggedStack = null;
}
return handled;
}
protected boolean handleCheatItemClick(int mouseX, int mouseY, int button)
{
final GuiContainer gui = NEIClientUtils.getGuiContainer();
final Slot overSlot = gui.getSlotAtPosition(mouseX, mouseY);
if (overSlot != null && overSlot.isItemValid(draggedStack)) {
if (NEIClientConfig.canCheatItem(draggedStack)) {
int contents = overSlot.getHasStack() ? overSlot.getStack().stackSize : 0;
final int add = button == 0 ? draggedStack.stackSize : 1;
if (overSlot.getHasStack() && !NEIServerUtils.areStacksSameType(draggedStack, overSlot.getStack())) {
contents = 0;
}
final int total = Math.min(contents + add, Math.min(overSlot.getSlotStackLimit(), draggedStack.getMaxStackSize()));
if (total > contents) {
NEIClientUtils.setSlotContents(overSlot.slotNumber, NEIServerUtils.copyStack(draggedStack, total), true);
NEICPH.sendGiveItem(NEIServerUtils.copyStack(draggedStack, total), false, false);
draggedStack.stackSize -= total - contents;
}
if (draggedStack.stackSize == 0) {
draggedStack = null;
}
} else {
draggedStack = null;
}
return true;
}
return false;
}
protected boolean handleSearchInputClick(int mouseX, int mouseY, int button)
{
if (searchField.contains(mouseX, mouseY)) {
final FluidStack fluidStack = StackInfo.getFluid(draggedStack);
if (fluidStack != null) {
searchField.setText(SPECIAL_REGEX_CHARS.matcher(fluidStack.getLocalizedName()).replaceAll("\\\\$0"));
} else {
searchField.setText(SPECIAL_REGEX_CHARS.matcher(draggedStack.getDisplayName()).replaceAll("\\\\$0"));
}
return true;
}
return false;
}
@Override
public void mouseUp(int mousex, int mousey, int button) {
ItemPanelSlot hoverSlot = getSlotMouseOver(mousex, mousey);
if (hoverSlot != null && hoverSlot.slotIndex == mouseDownSlot && draggedStack == null) {
ItemStack item = hoverSlot.item;
if (NEIController.manager.window instanceof GuiRecipe || !NEIClientConfig.canCheatItem(item)) {
if (button == 0)
GuiCraftingRecipe.openRecipeGui("item", item);
else if (button == 1)
GuiUsageRecipe.openRecipeGui("item", item);
draggedStack = null;
mouseDownSlot = -1;
return;
}
NEIClientUtils.cheatItem(getDraggedStackWithQuantity(hoverSlot.slotIndex), button, -1);
}
mouseDownSlot = -1;
}
@Override
public boolean onMouseWheel(int i, int mousex, int mousey) {
if (!contains(mousex, mousey))
return false;
grid.shiftPage(-i);
return true;
}
@Override
public boolean handleKeyPress(int keyID, char keyChar) {
if (keyID == NEIClientConfig.getKeyBinding("gui.next")) {
grid.shiftPage(1);
return true;
}
if (keyID == NEIClientConfig.getKeyBinding("gui.prev")) {
grid.shiftPage(-1);
return true;
}
return false;
}
@Override
public ItemStack getStackMouseOver(int mousex, int mousey) {
ItemPanelSlot slot = getSlotMouseOver(mousex, mousey);
return slot == null ? null : slot.item;
}
public ItemPanelSlot getSlotMouseOver(int mousex, int mousey)
{
return grid.getSlotMouseOver(mousex, mousey);
}
public int getPage() {
return grid.page + 1;
}
public int getNumPages() {
return grid.numPages;
}
@Override
public boolean contains(int px, int py)
{
return grid.contains(px, py);
}
}
@@ -7,30 +7,25 @@ public class ItemQuantityField extends TextField
centered = true;
}
// Find a way to work this this back in
public boolean isValid(String string) {
if (string.equals(""))
return true;
try {
return Integer.parseInt(string) >= 0;
} catch (NumberFormatException nfe) {
return false;
}
}
public int intValue() {
return intValue(text());
}
public int intValue(String s) {
try {
return Integer.parseInt(s);
return Math.max(0, Integer.parseInt(s));
} catch (NumberFormatException nfe) {
return 0;
}
}
@Override
public void gainFocus() {
if (text().equals("0")) {
setText("");
}
}
@Override
public void loseFocus() {
setText(Integer.toString(NEIClientConfig.getItemQuantity()));
@@ -38,7 +33,6 @@ public class ItemQuantityField extends TextField
@Override
public void onTextChange(String oldText) {
if (intValue(oldText) != intValue())//hacky recursion stopper
NEIClientUtils.setItemQuantity(intValue());
NEIClientUtils.setItemQuantity(intValue());
}
}
@@ -0,0 +1,271 @@
package codechicken.nei;
import codechicken.lib.vec.Rectangle4i;
import codechicken.nei.api.GuiInfo;
import codechicken.nei.guihook.GuiContainerManager;
import codechicken.nei.recipe.StackInfo;
import codechicken.nei.ItemPanel.ItemPanelSlot;
import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.item.ItemStack;
import java.util.ArrayList;
import static codechicken.lib.gui.GuiDraw.drawRect;
public class ItemsGrid
{
protected static final int SLOT_SIZE = 18;
protected int width;
protected int height;
protected int marginLeft;
protected int marginTop;
protected ArrayList<ItemStack> realItems = new ArrayList<>();
protected int page;
protected int perPage;
protected int firstIndex;
protected int numPages;
protected int rows;
protected int columns;
protected boolean[] validSlotMap;
protected boolean[] invalidSlotMap;
public ArrayList<ItemStack> getItems()
{
return realItems;
}
public ItemStack getItem(int idx)
{
return realItems.get(idx);
}
public int size()
{
return realItems.size();
}
public int indexOf(ItemStack stackA, boolean useNBT)
{
for (int idx = 0; idx < realItems.size(); idx++) {
if (StackInfo.equalItemAndNBT(stackA, realItems.get(idx), useNBT)) {
return idx;
}
}
return -1;
}
public int getPage()
{
return page + 1;
}
public int getPerPage()
{
return perPage;
}
public int getNumPages()
{
return numPages;
}
public int getRows()
{
return rows;
}
public int getColumns()
{
return columns;
}
public void setGridSize(int mleft, int mtop, int w, int h)
{
//I don't like this big condition
if (marginLeft != mleft || marginTop != mtop || width != w || height != h) {
marginLeft = mleft;
marginTop = mtop;
width = Math.max(0, w);
height = Math.max(0, h);
columns = width / SLOT_SIZE;
rows = height / SLOT_SIZE;
}
}
public void shiftPage(int shift)
{
if (perPage == 0) {
numPages = 0;
page = 0;
return;
}
numPages = (int) Math.ceil((float) realItems.size() / (float) perPage);
page += shift;
if (page >= numPages) {
page = page - numPages;
}
if (page < 0) {
page = numPages + page;
}
page = Math.max(0, Math.min(page, numPages - 1));
}
public void refresh(GuiContainer gui)
{
updateGuiOverlapSlots(gui);
shiftPage(0);
}
private void updateGuiOverlapSlots(GuiContainer gui)
{
invalidSlotMap = new boolean[rows * columns];
perPage = columns * rows;
checkGuiOverlap(gui, 0, columns - 2, 1);
checkGuiOverlap(gui, columns - 1, 1, -1);
}
private void checkGuiOverlap(GuiContainer gui, int start, int end, int dir)
{
boolean validColumn = false;
for (int c = start; c != end && !validColumn; c += dir) {
validColumn = true;
for (int r = 0; r < rows; r++) {
final int idx = columns * r + c;
if (!slotValid(gui, r, c) && idx >= 0 && idx < invalidSlotMap.length && !invalidSlotMap[idx]) {
invalidSlotMap[idx] = true;
validColumn = false;
perPage--;
}
}
}
}
private boolean slotValid(GuiContainer gui, int row, int column)
{
Rectangle4i rect = getSlotRect(row, column);
try {
GuiInfo.readLock.lock();
if (GuiInfo.guiHandlers.stream().anyMatch(handler -> handler.hideItemPanelSlot(gui, rect.x, rect.y, rect.w, rect.h))) {
return false;
}
} finally {
GuiInfo.readLock.unlock();
}
return true;
}
public Rectangle4i getSlotRect(int i)
{
return getSlotRect(i / columns, i % columns);
}
public Rectangle4i getSlotRect(int row, int column)
{
return new Rectangle4i(marginLeft + (width % SLOT_SIZE) / 2 + column * SLOT_SIZE, marginTop + row * SLOT_SIZE, SLOT_SIZE, SLOT_SIZE);
}
public boolean isInvalidSlot(int idx)
{
return invalidSlotMap[idx];
}
public void draw(int mousex, int mousey)
{
if (getPerPage() == 0) {
return;
}
ItemPanelSlot slot = getSlotMouseOver(mousex, mousey);
GuiContainerManager.enableMatrixStackLogging();
int idx = page * perPage;
for (int i = 0; i < rows * columns && idx < size(); i++) {
if (!invalidSlotMap[i]) {
drawItem(getSlotRect(i), idx, slot);
idx ++;
}
}
GuiContainerManager.disableMatrixStackLogging();
}
protected void drawItem(Rectangle4i rect, int idx, ItemPanelSlot focus)
{
if (focus != null && focus.slotIndex == idx) {
drawRect(rect.x, rect.y, rect.w, rect.h, 0xee555555);//highlight
}
GuiContainerManager.drawItem(rect.x + 1, rect.y + 1, getItem(idx));
}
public ItemPanelSlot getSlotMouseOver(int mousex, int mousey)
{
if (!contains(mousex, mousey)) {
return null;
}
final int overRow = (int) ((mousey - marginTop) / SLOT_SIZE);
final int overColumn = (int) ((mousex - marginLeft - (width % SLOT_SIZE) / 2) / SLOT_SIZE);
final int slt = columns * overRow + overColumn;
int idx = page * perPage + slt;
if (overRow >= rows || overColumn >= columns) {
return null;
}
for (int i = 0; i < slt; i++) {
if (invalidSlotMap[i]) {
idx--;
}
}
return idx < size()? new ItemPanelSlot(idx, realItems.get(idx)): null;
}
public boolean contains(int px, int py)
{
if (!(new Rectangle4i(marginLeft, marginTop, width, height)).contains(px, py)) {
return false;
}
final int r = (int) ((py - marginTop) / SLOT_SIZE);
final int c = (int) ((px - marginLeft - (width % SLOT_SIZE) / 2) / SLOT_SIZE);
final int slt = columns * r + c;
return r >= rows || c >= columns || !invalidSlotMap[slt];
}
}
File renamed without changes.
@@ -4,16 +4,18 @@ import codechicken.lib.gui.GuiDraw;
import codechicken.nei.KeyManager.IKeyStateTracker;
import codechicken.nei.api.API;
import codechicken.nei.api.GuiInfo;
import codechicken.nei.api.INEIGuiHandler;
import codechicken.nei.api.IRecipeOverlayRenderer;
import codechicken.nei.api.ItemInfo;
import codechicken.nei.api.LayoutStyle;
import codechicken.nei.drawable.DrawableBuilder;
import codechicken.nei.drawable.DrawableResource;
import codechicken.nei.guihook.GuiContainerManager;
import codechicken.nei.guihook.IContainerDrawHandler;
import codechicken.nei.guihook.IContainerInputHandler;
import codechicken.nei.guihook.IContainerObjectHandler;
import codechicken.nei.guihook.IContainerTooltipHandler;
import cpw.mods.fml.common.Loader;
import codechicken.nei.recipe.GuiRecipeTab;
import codechicken.nei.recipe.RecipeCatalysts;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.GuiButton;
import net.minecraft.client.gui.inventory.GuiContainer;
@@ -22,6 +24,8 @@ import net.minecraft.client.renderer.InventoryEffectRenderer;
import net.minecraft.inventory.Slot;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.EnumChatFormatting;
import org.lwjgl.input.Keyboard;
import org.lwjgl.opengl.GL11;
import java.util.HashMap;
@@ -39,6 +43,7 @@ import static codechicken.nei.NEIClientConfig.getOptionList;
import static codechicken.nei.NEIClientConfig.getSearchExpression;
import static codechicken.nei.NEIClientConfig.hasSMPCounterPart;
import static codechicken.nei.NEIClientConfig.invCreativeMode;
import static codechicken.nei.NEIClientConfig.isBookmarkPanelHidden;
import static codechicken.nei.NEIClientConfig.isEnabled;
import static codechicken.nei.NEIClientConfig.isHidden;
import static codechicken.nei.NEIClientConfig.showIDs;
@@ -50,13 +55,13 @@ import static codechicken.nei.NEIClientUtils.decreaseSlotStack;
import static codechicken.nei.NEIClientUtils.deleteEverything;
import static codechicken.nei.NEIClientUtils.deleteHeldItem;
import static codechicken.nei.NEIClientUtils.deleteItemsOfType;
import static codechicken.nei.NEIClientUtils.getGamemode;
import static codechicken.nei.NEIClientUtils.getGuiContainer;
import static codechicken.nei.NEIClientUtils.getHeldItem;
import static codechicken.nei.NEIClientUtils.getNextGamemode;
import static codechicken.nei.NEIClientUtils.healPlayer;
import static codechicken.nei.NEIClientUtils.isValidGamemode;
import static codechicken.nei.NEIClientUtils.setHourForward;
import static codechicken.nei.NEIClientUtils.setItemQuantity;
import static codechicken.nei.NEIClientUtils.shiftKey;
import static codechicken.nei.NEIClientUtils.toggleMagnetMode;
import static codechicken.nei.NEIClientUtils.toggleRaining;
@@ -66,7 +71,9 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
{
private static LayoutManager instance;
/** Note: this variable isn't actually used by this mod, but NEI add-ons might need it. */
private static Widget inputFocused;
/**
* Sorted bottom first
*/
@@ -81,8 +88,8 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
public static SubsetWidget dropDown;
public static TextField searchField;
public static Button options;
public static Button bookmarks;
public static ButtonCycled options;
public static ButtonCycled bookmarksButton;
public static Button more;
public static Button less;
@@ -99,12 +106,14 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
public static HashMap<Integer, LayoutStyle> layoutStyles = new HashMap<>();
public static boolean ftbUtilsLoaded = false;
public static boolean itemsLoaded = false;
public static void load() {
ftbUtilsLoaded = Loader.isModLoaded("FTBU");
/**
* Not present, Present
*/
public static Image[] itemPresenceOverlays = new Image[2];
public static void load() {
API.addLayoutStyle(0, new LayoutStyleMinecraft());
instance = new LayoutManager();
@@ -136,7 +145,7 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
return gui.width - 3;
}
public static int getLeftSize(GuiContainer gui) {
return getSideWidth(gui) - (ftbUtilsLoaded ? 18 : 0);
return getSideWidth(gui);
}
@Override
@@ -198,6 +207,11 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
toggleBooleanSetting("inventory.hidden");
return true;
}
if (keyID == getKeyBinding("gui.hide_bookmarks")) {
toggleBooleanSetting("inventory.bookmarksEnabled");
return true;
}
if (isEnabled() && !isHidden()) {
for (Widget widget : controlWidgets)
if (inputFocused == null)
@@ -242,6 +256,7 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
widget.draw(mousex, mousey);
} else {
options.draw(mousex, mousey);
bookmarksButton.draw(mousex, mousey);
}
GL11.glEnable(GL11.GL_LIGHTING);
@@ -293,13 +308,21 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
VisiblityData visiblity = new VisiblityData();
if (isHidden())
visiblity.showNEI = false;
if (isBookmarkPanelHidden())
visiblity.showBookmarkPanel = false;
if (gui.height - gui.ySize <= 40)
visiblity.showSearchSection = false;
if (gui.guiLeft - 4 < 76)
visiblity.showWidgets = false;
for (INEIGuiHandler handler : GuiInfo.guiHandlers)
handler.modifyVisiblity(gui, visiblity);
try {
GuiInfo.readLock.lock();
GuiInfo.guiHandlers.forEach(handler -> handler.modifyVisiblity(gui, visiblity));
} finally {
GuiInfo.readLock.unlock();
}
visiblity.translateDependancies();
@@ -318,28 +341,69 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
dropDown = new SubsetWidget();
searchField = new SearchField("search");
options = new Button("Options")
options = new ButtonCycled(3)
{
@Override
public void init() {
this.icons[0] = new DrawableBuilder("nei:textures/nei_tabbed_sprites.png", 32, 0, 16, 16).build();
this.icons[1] = new DrawableBuilder("nei:textures/nei_tabbed_sprites.png", 48, 0, 16, 16).build();
this.icons[2] = new DrawableBuilder("nei:textures/nei_tabbed_sprites.png", 64, 0, 16, 16).build();
}
@Override
public boolean onButtonPress(boolean rightclick) {
if (!rightclick) {
getOptionList().openGui(getGuiContainer(), false);
if (Keyboard.getEventKeyState() && (Keyboard.getEventKey() == Keyboard.KEY_LCONTROL || Keyboard.getEventKey() == Keyboard.KEY_RCONTROL)) {
NEIClientConfig.cycleSetting("inventory.cheatmode", 3);
} else {
if (Keyboard.getEventKeyState() && (Keyboard.getEventKey() == Keyboard.KEY_LSHIFT || Keyboard.getEventKey() == Keyboard.KEY_RSHIFT)) {
GuiRecipeTab.loadHandlerInfo();
RecipeCatalysts.loadCatalystInfo();
}
getOptionList().openGui(getGuiContainer(), false);
}
return true;
}
return false;
}
@Override
public void addTooltips(List<String> tooltip) {
tooltip.add(translate("inventory.options.tip"));
String modeColor = "";
final int cheatMode = NEIClientConfig.getCheatMode();
if (cheatMode == 1)
modeColor = EnumChatFormatting.GOLD.toString();
else if (cheatMode == 2)
modeColor = EnumChatFormatting.RED.toString();
String controlKeyLocalization = translate(Minecraft.isRunningOnMac ? "key.ctrl.mac" : "key.ctrl");
tooltip.add(modeColor + translate("inventory.options.tip.cheatmode." + cheatMode));
tooltip.add(modeColor + translate("inventory.options.tip.cheatmode.disable", controlKeyLocalization));
}
@Override
public String getRenderLabel() {
return translate("inventory.options");
}
};
bookmarks = new Button("Bookmarks")
bookmarksButton = new ButtonCycled(2)
{
@Override
public void init() {
this.icons[0] = new DrawableBuilder("nei:textures/nei_tabbed_sprites.png", 0, 0, 16, 16).build();
this.icons[1] = new DrawableBuilder("nei:textures/nei_tabbed_sprites.png", 16, 0, 16, 16).build();
}
@Override
public boolean onButtonPress(boolean rightclick) {
return false;
NEIClientConfig.toggleBooleanSetting("inventory.bookmarksEnabled");
return true;
}
public String getButtonTip() {
return translate("bookmark.toggle.tip");
}
@Override
@@ -360,7 +424,7 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
if (quantity < 0)
quantity = 0;
setItemQuantity(quantity);
LayoutManager.quantity.setText(Integer.toString(quantity));
return true;
}
};
@@ -377,7 +441,7 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
if (quantity < 0)
quantity = 0;
setItemQuantity(quantity);
LayoutManager.quantity.setText(Integer.toString(quantity));
return true;
}
};
@@ -424,7 +488,7 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
GuiDraw.drawTip(mousex + 9, mousey, translate("inventory.delete." + (shiftKey() ? "all" : "one"), GuiContainerManager.itemDisplayNameShort(getHeldItem())));
}
};
gamemode = new ButtonCycled()
gamemode = new ButtonCycled(3)
{
@Override
public boolean onButtonPress(boolean rightclick) {
@@ -434,12 +498,12 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
}
return false;
}
public String getButtonTip() {
return translate("inventory.gamemode." + getNextGamemode());
public void addTooltips(List<String> tooltip) {
tooltip.add(translate("inventory.current.gamemode." + getGamemode()));
tooltip.add(EnumChatFormatting.GRAY + translate("inventory.gamemode." + getNextGamemode()));
}
};
gamemode.icons = new Image[3];
rain = new Button()
{
@Override
@@ -554,7 +618,7 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
return true;
}
public static void markItemsDirty() {
// If anything has modified data this depends on, we'll need to reload the item list
itemsLoaded = false;
@@ -605,15 +669,14 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
addWidget(options);
addWidget(bookmarksButton);
if (visiblity.showItemPanel) {
addWidget(itemPanel);
itemPanel.setVisible();
if (canPerformAction("item")) {
addWidget(more);
addWidget(less);
addWidget(quantity);
}
addWidget(more);
addWidget(less);
addWidget(quantity);
}
if (visiblity.showBookmarkPanel) {
@@ -622,7 +685,6 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
}
if (visiblity.showSearchSection) {
addWidget(dropDown);
addWidget(searchField);
}
@@ -644,6 +706,11 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
if (canPerformAction("delete"))
addWidget(delete);
}
if (!visiblity.showBookmarkPanel) {
// Bookmarks or Subset/dropdown
addWidget(dropDown);
}
}
@@ -693,13 +760,15 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
@Override
public boolean shouldShowTooltip(GuiContainer gui) {
return itemPanel.draggedStack == null;
return itemPanel.draggedStack == null && bookmarkPanel.sortedStackIndex == -1;
}
/** Note: this method isn't actually used by this mod, but NEI add-ons might need it. */
public static Widget getInputFocused() {
return inputFocused;
}
/** Note: this method isn't actually used by this mod, but NEI add-ons might need it. */
public static void setInputFocused(Widget widget) {
if (inputFocused != null)
inputFocused.loseFocus();
@@ -728,54 +797,66 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
}
public static void drawIcon(int x, int y, Image image) {
changeTexture("nei:textures/nei_sprites.png");
final boolean isDrawableResource = image instanceof DrawableResource;
if (!isDrawableResource)
changeTexture("nei:textures/nei_sprites.png");
GL11.glColor4f(1, 1, 1, 1);
GL11.glEnable(GL11.GL_BLEND);
GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
drawTexturedModalRect(x, y, image.x, image.y, image.width, image.height);
if(!isDrawableResource)
drawTexturedModalRect(x, y, image.x, image.y, image.width, image.height);
else
((DrawableResource)image).draw(x, y);
GL11.glDisable(GL11.GL_BLEND);
}
public static void drawButtonBackground(int x, int y, int w, int h, boolean edges, int type) {
int wtiles = 0;
int wTiles = 0;
int ew = w;//end width
if (w / 2 > 100) {
wtiles = (w - 200) / 50 + 1;
wTiles = (w - 200) / 50 + 1;
ew = 200;
}
int w1 = ew / 2;
int h1 = h / 2;
int w2 = (ew + 1) / 2;
int h2 = (h + 1) / 2;
final int w1 = ew / 2;
final int h1 = h / 2;
final int w2 = (ew + 1) / 2;
final int h2 = (h + 1) / 2;
int x2 = x + w - w2;
int y2 = y + h - h2;
final int x2 = x + w - w2;
final int y2 = y + h - h2;
int ty = 46 + type * 20;
int te = (edges ? 0 : 1);//tex edges
final int ty = 46 + type * 20;
final int te = (edges ? 0 : 1);//tex edges
int ty1 = ty + te;
int tx1 = te;
int tx3 = 75;
final int ty1 = ty + te;
final int tx1 = te;
final int tx3 = 75;
//halfway the 1 is for odd number adjustment
int ty2 = ty + 20 - h2 - te;
int tx2 = 200 - w2 - te;
final int ty2 = ty + 20 - h2 - te;
final int tx2 = 200 - w2 - te;
changeTexture("textures/gui/widgets.png");
drawTexturedModalRect(x, y, tx1, ty1, w1, h1);//top left
drawTexturedModalRect(x, y2, tx1, ty2, w1, h2);//bottom left
for (int tile = 0; tile < wtiles; tile++) {
int tilex = x + w1 + 50 * tile;
drawTexturedModalRect(tilex, y, tx3, ty1, 50, h1);//top
drawTexturedModalRect(tilex, y2, tx3, ty2, 50, h2);//bottom
for (int tile = 0; tile < wTiles; tile++) {
final int tileX = x + w1 + 50 * tile;
drawTexturedModalRect(tileX, y, tx3, ty1, 50, h1);//top
drawTexturedModalRect(tileX, y2, tx3, ty2, 50, h2);//bottom
}
drawTexturedModalRect(x2, y, tx2, ty1, w2, h1);//top right
drawTexturedModalRect(x2, y2, tx2, ty2, w2, h2);//bottom right
}
public static void drawItemPresenceOverlay(int slotX, int slotY, boolean isPresent) {
Image icon = itemPresenceOverlays[isPresent ? 1 : 0];
drawIcon(slotX + 16 - icon.width, slotY + 16 - icon.height, icon);
}
public static LayoutManager instance() {
return instance;
}
@@ -802,4 +883,3 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
}
}
@@ -1,16 +1,19 @@
package codechicken.nei;
import codechicken.nei.api.LayoutStyle;
import codechicken.nei.drawable.DrawableBuilder;
import net.minecraft.client.gui.inventory.GuiContainer;
import org.lwjgl.opengl.GL11;
import static codechicken.lib.gui.GuiDraw.drawStringC;
import static codechicken.nei.LayoutManager.bookmarkPanel;
import static codechicken.nei.LayoutManager.bookmarksButton;
import static codechicken.nei.LayoutManager.delete;
import static codechicken.nei.LayoutManager.dropDown;
import static codechicken.nei.LayoutManager.gamemode;
import static codechicken.nei.LayoutManager.heal;
import static codechicken.nei.LayoutManager.itemPanel;
import static codechicken.nei.LayoutManager.itemPresenceOverlays;
import static codechicken.nei.LayoutManager.less;
import static codechicken.nei.LayoutManager.magnet;
import static codechicken.nei.LayoutManager.more;
@@ -48,6 +51,8 @@ public class LayoutStyleMinecraft extends LayoutStyle
timeButtons[2].icon = new Image(144, 24, 12, 12);
timeButtons[3].icon = new Image(156, 24, 12, 12);
heal.icon = new Image(168, 24, 12, 12);
itemPresenceOverlays[0] = new DrawableBuilder("nei:textures/nei_tabbed_sprites.png", 0, 40, 8, 8).build();
itemPresenceOverlays[1] = new DrawableBuilder("nei:textures/nei_tabbed_sprites.png", 8, 40, 8, 8).build();
}
@Override
@@ -59,7 +64,6 @@ public class LayoutStyleMinecraft extends LayoutStyle
public void layout(GuiContainer gui, VisiblityData visiblity) {
reset();
//leftSize = ((gui.width - gui.xSize) / 2) - 3;
leftSize = ItemPanels.bookmarkPanel.getWidth(gui);
numButtons = Math.max(leftSize / 18, 1);
@@ -87,6 +91,8 @@ public class LayoutStyleMinecraft extends LayoutStyle
else if (NEIClientUtils.isValidGamemode("adventure"))
gamemode.index = 2;
}
bookmarksButton.index = NEIClientConfig.isBookmarkPanelHidden() ? 0 : 1;
options.index = NEIClientConfig.getCheatMode();
magnet.state = 0x4 | (getMagnetMode() ? 1 : 0);
@@ -113,7 +119,7 @@ public class LayoutStyleMinecraft extends LayoutStyle
bookmarkPanel.resize(gui);
more.w = more.h = less.w = less.h = 16;
less.x = itemPanel.prev.x;
less.x = itemPanel.pagePrev.x;
more.x = gui.width - less.w - 2;
more.y = less.y = gui.height - more.h - 2;
@@ -124,14 +130,20 @@ public class LayoutStyleMinecraft extends LayoutStyle
options.x = isEnabled() ? 0 : 6;
options.y = isEnabled() ? gui.height - 22 : gui.height - 28;
options.w = 80;
options.w = 22;
options.h = 22;
bookmarksButton.x = 24 + (isEnabled() ? 0 : 6);
bookmarksButton.y = isEnabled() ? gui.height - 22 : gui.height - 28;
bookmarksButton.w = 22;
bookmarksButton.h = 22;
searchField.y = gui.height - searchField.h - 2;
dropDown.x = itemPanel.x - 150;
dropDown.x = Math.min(numButtons, buttonCount) * 20 + 3;
dropDown.h = 20;
dropDown.w = Math.min(itemPanel.prev.x - dropDown.x - 3, 100);
dropDown.w = itemPanel.x - dropDown.x - 3;
searchField.h = 20;
searchField.w = 150;
searchField.x = (gui.width - searchField.w) / 2;
@@ -144,7 +156,7 @@ public class LayoutStyleMinecraft extends LayoutStyle
public void layoutButton(Button button) {
button.x = 2 + (buttonCount % numButtons) * 20;
button.y = 3 + (buttonCount / numButtons) * 18;
button.y = (buttonCount / numButtons) * 18;
button.h = 17;
button.w = button.contentWidth() + 6;
@@ -169,16 +181,16 @@ public class LayoutStyleMinecraft extends LayoutStyle
Image icon = b.getRenderIcon();
if (icon == null) {
int colour = tex == 2 ? 0xffffa0 :
tex == 0 ? 0x601010 : 0xe0e0e0;
int colour = tex == 2 ? 0xffffa0 : tex == 0 ? 0x601010 : 0xe0e0e0;
drawStringC(b.getRenderLabel(), b.x + b.w / 2, b.y + (b.h - 8) / 2, colour);
} else {
GL11.glColor4f(1, 1, 1, 1);
int iconx = b.x + (b.w - icon.width) / 2;
int icony = b.y + (b.h - icon.height) / 2;
LayoutManager.drawIcon(iconx, icony, icon);
final int iconX = b.x + (b.w - icon.width) / 2;
final int iconY = b.y + (b.h - icon.height) / 2;
LayoutManager.drawIcon(iconX, iconY, icon);
}
}
File renamed without changes.
@@ -22,27 +22,38 @@ import codechicken.nei.config.OptionList;
import codechicken.nei.config.OptionOpenGui;
import codechicken.nei.config.OptionTextField;
import codechicken.nei.config.OptionToggleButton;
import codechicken.nei.config.OptionToggleButtonBoubs;
import codechicken.nei.config.OptionUtilities;
import codechicken.nei.event.NEIConfigsLoadedEvent;
import codechicken.nei.recipe.GuiRecipeTab;
import codechicken.nei.recipe.IRecipeHandler;
import codechicken.nei.recipe.RecipeCatalysts;
import codechicken.nei.recipe.RecipeInfo;
import codechicken.obfuscator.ObfuscationRun;
import com.google.common.base.Objects;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.GuiScreen;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import net.minecraft.world.storage.SaveFormatComparator;
import net.minecraftforge.common.MinecraftForge;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.lwjgl.input.Keyboard;
import java.io.File;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.function.Function;
import java.util.regex.Pattern;
public class NEIClientConfig
{
public class NEIClientConfig {
private static boolean configLoaded;
private static boolean enabledOverride;
private static String worldPath;
public static Logger logger = LogManager.getLogger("NotEnoughItems");
public static File configDir = new File(CommonUtils.getMinecraftDir(), "config/NEI/");
@@ -50,7 +61,40 @@ public class NEIClientConfig
new File("saves/NEI/client.dat"),
new ConfigFile(new File(configDir, "client.cfg")));
public static ConfigSet world;
public static final File bookmarkFile = new File(configDir, "bookmarks.ini");
public static final File handlerFile = new File(configDir, "handlers.csv");
public static final File catalystFile = new File(configDir, "catalysts.csv");
public static final File serialHandlersFile = new File(configDir, "serialhandlers.cfg");
public static final File heightHackHandlersFile = new File(configDir, "heighthackhandlers.cfg");
public static final File handlerOrderingFile = new File(configDir, "handlerordering.csv");
@Deprecated
public static File bookmarkFile;
// Set of handlers that need to be run in serial
public static HashSet<String> serialHandlers = new HashSet<>();
// Set of regexes matching handler ID of handlers that need the hack in GuiRecipe.startHeightHack().
// We use regex here so that we can apply the height hack to entire mods with one entry.
public static HashSet<Pattern> heightHackHandlerRegex = new HashSet<>();
// Map of handler ID to sort order.
// Handlers will be sorted in ascending order, so smaller numbers show up earlier.
// Any handler not in the map will be assigned to 0, and negative numbers are fine.
public static HashMap<String, Integer> handlerOrdering = new HashMap<>();
// Function that extracts the handler ID from a handler, with special logic for
// TemplateRecipeHandler: prefer using the overlay ID if it exists.
public static final Function<IRecipeHandler, String> HANDLER_ID_FUNCTION =
handler -> Objects.firstNonNull(
handler.getOverlayIdentifier(),
handler.getHandlerId());
// Comparator that compares handlers using the handlerOrdering map.
public static final Comparator<IRecipeHandler> HANDLER_COMPARATOR =
Comparator.comparingInt(
handler -> handlerOrdering.getOrDefault(
HANDLER_ID_FUNCTION.apply(handler), 0));
public static ItemStack[] creativeInv;
@@ -113,6 +157,19 @@ public class NEIClientConfig
tag.getTag("inventory.profileRecipes").getBooleanValue(false);
API.addOption(new OptionToggleButton("inventory.profileRecipes", true));
tag.getTag("inventory.disableMouseScrollTransfer").getBooleanValue(false);
API.addOption(new OptionToggleButton("inventory.disableMouseScrollTransfer", true));
tag.getTag("inventory.invertMouseScrollTransfer").getBooleanValue(false);
API.addOption(new OptionToggleButton("inventory.invertMouseScrollTransfer", true) {
@Override
public boolean isEnabled() {
return isMouseScrollTransferEnabled();
}
});
tag.getTag("itemLoadingTimeout").getIntValue(500);
tag.getTag("command.creative").setDefaultValue("/gamemode {0} {1}");
API.addOption(new OptionTextField("command.creative"));
tag.getTag("command.item").setDefaultValue("/give {0} {1} {2} {3} {4}");
@@ -124,6 +181,53 @@ public class NEIClientConfig
tag.getTag("command.heal").setDefaultValue("");
API.addOption(new OptionTextField("command.heal"));
tag.getTag("inventory.worldSpecificBookmarks").setComment("Global or world specific bookmarks").getBooleanValue(false);
API.addOption(new OptionToggleButton("inventory.worldSpecificBookmarks", true) {
@Override
public boolean onClick(int button) {
super.onClick(button);
initBookmarkFile(worldPath);
return true;
}
});
tag.getTag("inventory.bookmarksEnabled").setComment("Enable/disable bookmarks").getBooleanValue(true);
API.addOption(new OptionToggleButton("inventory.bookmarksEnabled", true));
tag.getTag("inventory.saveCurrentRecipeInBookmarksEnabled").setComment("Save Current Recipe in Bookmarks").getBooleanValue(true);
API.addOption(new OptionToggleButton("inventory.saveCurrentRecipeInBookmarksEnabled", true));
tag.getTag("inventory.useNBTInBookmarks").setComment("Use NBT in Bookmarks").getBooleanValue(true);
API.addOption(new OptionToggleButton("inventory.useNBTInBookmarks", true));
tag.getTag("inventory.jei_style_tabs").setComment("Enable/disable JEI Style Tabs").getBooleanValue(true);
API.addOption(new OptionToggleButtonBoubs("inventory.jei_style_tabs", true));
tag.getTag("inventory.jei_style_item_presence_overlay").setComment("Enable/disable JEI Style item presence overlay on ?-hover").getBooleanValue(true);
API.addOption(new OptionToggleButton("inventory.jei_style_item_presence_overlay", true));
tag.getTag("inventory.jei_style_recipe_catalyst").setComment("Enable/disable JEI Style Recipe Catalysts").getBooleanValue(true);
API.addOption(new OptionToggleButton("inventory.jei_style_recipe_catalyst", true));
tag.getTag("inventory.creative_tab_style").setComment("Creative or JEI style tabs").getBooleanValue(false);
API.addOption(new OptionToggleButton("inventory.creative_tab_style", true));
tag.getTag("tools.handler_load_from_config").setComment("ADVANCED: Load handlers from config").getBooleanValue(false);
API.addOption(new OptionToggleButton("tools.handler_load_from_config", true) {
@Override
public boolean onClick(int button) {
super.onClick(button);
GuiRecipeTab.loadHandlerInfo();
return true;
}
});
tag.getTag("tools.catalyst_load_from_config").setComment("ADVANCED: Load catalysts from config").getBooleanValue(false);
API.addOption(new OptionToggleButton("tools.catalyst_load_from_config", true) {
@Override
public boolean onClick(int button) {
super.onClick(button);
RecipeCatalysts.loadCatalystInfo();
return true;
}
});
setDefaultKeyBindings();
}
@@ -167,6 +271,7 @@ public class NEIClientConfig
API.addKeyBind("gui.hide", Keyboard.KEY_O);
API.addKeyBind("gui.search", Keyboard.KEY_F);
API.addKeyBind("gui.bookmark", Keyboard.KEY_A);
API.addKeyBind("gui.hide_bookmarks", Keyboard.KEY_B);
API.addKeyBind("world.chunkoverlay", Keyboard.KEY_F9);
API.addKeyBind("world.moboverlay", Keyboard.KEY_F7);
API.addKeyBind("world.highlight_tips", Keyboard.KEY_NUMPAD0);
@@ -183,17 +288,22 @@ public class NEIClientConfig
return OptionList.getOptionList("nei.options");
}
public static void loadWorld(String saveName) {
public static void loadWorld(String worldPath) {
NEIClientConfig.worldPath = worldPath;
setInternalEnabled(true);
logger.debug("Loading "+(Minecraft.getMinecraft().isSingleplayer() ? "Local" : "Remote")+" World");
bootNEI(ClientUtils.getWorld());
File saveDir = new File(CommonUtils.getMinecraftDir(), "saves/NEI/" + saveName);
boolean newWorld = !saveDir.exists();
if (newWorld)
saveDir.mkdirs();
final File specificDir = new File(CommonUtils.getMinecraftDir(), "saves/NEI/" + worldPath);
final boolean newWorld = !specificDir.exists();
world = new ConfigSet(new File(saveDir, "NEI.dat"), new ConfigFile(new File(saveDir, "NEI.cfg")));
if (newWorld) {
specificDir.mkdirs();
}
initBookmarkFile(worldPath);
world = new ConfigSet(new File(specificDir, "NEI.dat"), new ConfigFile(new File(specificDir, "NEI.cfg")));
onWorldLoad(newWorld);
}
@@ -237,8 +347,8 @@ public class NEIClientConfig
GuiInfo.load();
RecipeInfo.load();
LayoutManager.load();
ItemPanels.bookmarkPanel.loadBookmarks();
NEIController.load();
RecipeCatalysts.loadCatalystInfo();
configLoaded = true;
@@ -259,11 +369,23 @@ public class NEIClientConfig
logger.error("Failed to Load " + clazz.getName(), e);
}
}
MinecraftForge.EVENT_BUS.post(new NEIConfigsLoadedEvent());
}
}.start();
ItemSorter.loadConfig();
}
private static void initBookmarkFile(String worldPath)
{
if (!global.config.getTag("inventory.worldSpecificBookmarks").getBooleanValue()) {
worldPath = "global";
}
ItemPanels.bookmarkPanel.setBookmarkFile(worldPath);
}
public static boolean isWorldSpecific(String setting) {
if(world == null) return false;
ConfigTag tag = world.config.getTag(setting, false);
@@ -281,10 +403,36 @@ public class NEIClientConfig
public static boolean isHidden() {
return !enabledOverride || getBooleanSetting("inventory.hidden");
}
public static boolean isBookmarkPanelHidden() {
return !getBooleanSetting("inventory.bookmarksEnabled");
}
public static boolean saveCurrentRecipeInBookmarksEnabled() {
return getBooleanSetting("inventory.saveCurrentRecipeInBookmarksEnabled");
}
public static boolean useNBTInBookmarks() {
return getBooleanSetting("inventory.useNBTInBookmarks");
}
public static boolean areJEIStyleTabsVisible() {
return getBooleanSetting("inventory.jei_style_tabs");
}
public static boolean isJEIStyleItemPresenceOverlayVisible() {
return getBooleanSetting("inventory.jei_style_item_presence_overlay");
}
public static boolean areJEIStyleRecipeCatalystsVisible() {
return getBooleanSetting("inventory.jei_style_recipe_catalyst");
}
public static boolean useCreativeTabStyle() {
return getBooleanSetting("inventory.creative_tab_style");
}
public static boolean isEnabled() {
return enabledOverride && getBooleanSetting("inventory.widgetsenabled");
}
public static boolean loadHandlersFromJar() {
return !getBooleanSetting("tools.handler_load_from_config");
}
public static boolean loadCatalystsFromJar() {
return !getBooleanSetting("tools.catalyst_load_from_config");
}
public static void setEnabled(boolean flag) {
getSetting("inventory.widgetsenabled").setBooleanValue(flag);
@@ -319,6 +467,10 @@ public class NEIClientConfig
int i = getIntSetting("inventory.itemIDs");
return i == 2 || (i == 1 && isEnabled() && !isHidden());
}
public static int getItemLoadingTimeout() {
return getIntSetting("itemLoadingTimeout");
}
public static void toggleBooleanSetting(String setting) {
ConfigTag tag = getSetting(setting);
@@ -347,6 +499,14 @@ public class NEIClientConfig
world.saveNBT();
}
public static boolean isMouseScrollTransferEnabled() {
return !getBooleanSetting("inventory.disableMouseScrollTransfer");
}
public static boolean shouldInvertMouseScrollTransfer() {
return !getBooleanSetting("inventory.invertMouseScrollTransfer");
}
public static boolean getMagnetMode() {
return enabledActions.contains("magnet");
}
@@ -433,4 +593,5 @@ public class NEIClientConfig
if (file.isDirectory() && !saveFileNames.contains(file.getName()))
ObfuscationRun.deleteDir(file, true);
}
}
@@ -5,7 +5,6 @@ import codechicken.lib.inventory.InventoryUtils;
import codechicken.lib.util.LangProxy;
import codechicken.nei.api.GuiInfo;
import codechicken.nei.api.IInfiniteItemHandler;
import codechicken.nei.api.INEIGuiHandler;
import codechicken.nei.api.ItemInfo;
import com.google.common.collect.Iterables;
import net.minecraft.client.Minecraft;
@@ -27,6 +26,7 @@ import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.stream.Collectors;
import static codechicken.nei.NEIClientConfig.canCheatItem;
import static codechicken.nei.NEIClientConfig.canPerformAction;
@@ -135,10 +135,7 @@ public class NEIClientUtils extends NEIServerUtils
if (mode == 1 && stack.stackSize < stack.getMaxStackSize()) {
giveStack(stack, stack.getMaxStackSize() - stack.stackSize);
} else {
int amount = getItemQuantity();
if (amount == 0)
amount = stack.getMaxStackSize();
giveStack(stack, amount);
giveStack(stack);
}
}
}
@@ -157,9 +154,16 @@ public class NEIClientUtils extends NEIServerUtils
ItemStack typestack = copyStack(stack, 1);
if (!infinite && !canItemFitInInventory(mc().thePlayer, stack) && (mc().currentScreen instanceof GuiContainer)) {
GuiContainer gui = getGuiContainer();
List<Iterable<Integer>> handlerSlots = new LinkedList<>();
for(INEIGuiHandler handler : GuiInfo.guiHandlers)
handlerSlots.add(handler.getItemSpawnSlots(gui, typestack));
final List<Iterable<Integer>> handlerSlots;
try {
GuiInfo.readLock.lock();
handlerSlots = GuiInfo.guiHandlers.stream()
.map(handler -> handler.getItemSpawnSlots(gui, typestack))
.filter(x -> x != null)
.collect(Collectors.toCollection(LinkedList::new));
} finally {
GuiInfo.readLock.unlock();
}
int increment = typestack.getMaxStackSize();
int given = 0;
@@ -347,7 +351,6 @@ public class NEIClientUtils extends NEIServerUtils
public static void setItemQuantity(int i) {
world.nbt.setInteger("quantity", i);
world.saveNBT();
LayoutManager.quantity.setText(Integer.toString(i));
}
public static GuiContainer getGuiContainer() {
@@ -224,12 +224,15 @@ public class NEIController implements IContainerSlotClickHandler, IContainerInpu
@Override
public boolean mouseScrolled(GuiContainer gui, int mousex, int mousey, int scrolled) {
if (!NEIClientConfig.isEnabled() || GuiInfo.hasCustomSlots(gui))
if (!NEIClientConfig.isEnabled() || GuiInfo.hasCustomSlots(gui) || !NEIClientConfig.isMouseScrollTransferEnabled())
return false;
Point mousePos = getMousePosition();
Slot mouseover = manager.window.getSlotAtPosition(mousePos.x, mousePos.y);
if (mouseover != null && mouseover.getHasStack()) {
if(NEIClientConfig.shouldInvertMouseScrollTransfer()) {
scrolled = -scrolled;
}
if (scrolled > 0)
fastTransferManager.transferItem(manager.window, mouseover.slotNumber);
else
@@ -4,15 +4,19 @@ import codechicken.core.CommonUtils;
import codechicken.core.launch.CodeChickenCorePlugin;
import codechicken.nei.api.IConfigureNEI;
import codechicken.nei.asm.NEICorePlugin;
import codechicken.nei.config.IMCHandler;
import codechicken.nei.recipe.GuiRecipeTab;
import codechicken.nei.recipe.RecipeCatalysts;
import com.google.common.eventbus.EventBus;
import com.google.common.eventbus.Subscribe;
import cpw.mods.fml.client.FMLFileResourcePack;
import cpw.mods.fml.client.FMLFolderResourcePack;
import cpw.mods.fml.common.DummyModContainer;
import cpw.mods.fml.common.LoadController;
import cpw.mods.fml.common.MetadataCollection;
import cpw.mods.fml.common.ModMetadata;
import cpw.mods.fml.common.event.FMLInitializationEvent;
import cpw.mods.fml.common.event.FMLInterModComms;
import cpw.mods.fml.common.event.FMLPostInitializationEvent;
import cpw.mods.fml.common.event.FMLPreInitializationEvent;
import cpw.mods.fml.common.versioning.ArtifactVersion;
import cpw.mods.fml.common.versioning.VersionParser;
@@ -30,10 +34,18 @@ public class NEIModContainer extends DummyModContainer
public static LinkedList<IConfigureNEI> plugins = new LinkedList<>();
public NEIModContainer() {
super(MetadataCollection.from(MetadataCollection.class.getResourceAsStream("/neimod.info"), "NotEnoughItems").getMetadataForId("NotEnoughItems", null));
super(getModMetadata());
loadMetadata();
}
private static ModMetadata getModMetadata() {
final ModMetadata modMetadata = new ModMetadata();
modMetadata.name = "GRADLETOKEN_MODNAME";
modMetadata.modId = "GRADLETOKEN_MODID";
modMetadata.version = "GRADLETOKEN_VERSION";
return modMetadata;
}
@Override
public Set<ArtifactVersion> getRequirements() {
Set<ArtifactVersion> deps = new HashSet<>();
@@ -91,6 +103,19 @@ public class NEIModContainer extends DummyModContainer
ServerHandler.load();
}
@Subscribe
public void postInit(FMLPostInitializationEvent event) {
if (CommonUtils.isClient()) {
GuiRecipeTab.loadHandlerInfo();
RecipeCatalysts.loadCatalystInfo();
ClientHandler.postInit();
}
}
@Subscribe
public void handleIMCMessages(FMLInterModComms.IMCEvent event) {
IMCHandler.processIMC(event.getMessages());
}
@Override
public VersionRange acceptableMinecraftVersionRange() {
File renamed without changes.
@@ -5,6 +5,8 @@ import codechicken.core.ServerUtils;
import codechicken.lib.inventory.InventoryRange;
import codechicken.lib.inventory.InventoryUtils;
import codechicken.lib.packet.PacketCustom;
import cpw.mods.fml.common.FMLLog;
import cpw.mods.fml.common.registry.GameRegistry;
import net.minecraft.command.ICommandSender;
import net.minecraft.enchantment.Enchantment;
import net.minecraft.entity.player.EntityPlayer;
@@ -14,6 +16,9 @@ import net.minecraft.inventory.Slot;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.CompressedStreamTools;
import net.minecraft.nbt.JsonToNBT;
import net.minecraft.nbt.NBTBase;
import net.minecraft.nbt.NBTException;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import net.minecraft.server.MinecraftServer;
@@ -24,6 +29,7 @@ import net.minecraft.world.World;
import net.minecraft.world.WorldServer;
import net.minecraft.world.WorldSettings.GameType;
import net.minecraftforge.oredict.OreDictionary;
import org.apache.logging.log4j.Level;
import java.io.File;
import java.io.FileInputStream;
@@ -387,6 +393,50 @@ public class NEIServerUtils
}
}
public static ItemStack getModdedItem(String itemId, String nbtString) {
int meta = -1;
ItemStack itemStack;
if (!itemId.contains(":")) {
NEIClientConfig.logger.info(String.format("Item ID %s is missing colon", itemId));
return null;
}
final String[] split = itemId.split(":");
// ModID:ItemID
String itemLookupId = split[0] + ":" + split[1];
if (split.length >= 3) {
int mIdx = -1;
if (split[2].matches("\\d+")) {
mIdx = 2;
} else {
itemLookupId += ":" + split[2];
if (split.length >= 4) mIdx = 3;
}
if (mIdx != -1) meta = Integer.parseInt(split[mIdx]);
}
if (meta != -1) {
itemStack = GameRegistry.makeItemStack(itemLookupId, meta, 1, nbtString == null ? "" : nbtString);
} else {
itemStack = GameRegistry.findItemStack(split[0], split[1], 1);
if (nbtString != null && !nbtString.isEmpty()) {
try {
final NBTBase nbttag = JsonToNBT.func_150315_a(nbtString);
if (!(nbttag instanceof NBTTagCompound)) {
NEIClientConfig.logger.info("Unexpected NBT string - multiple values {}", nbtString);
return null;
}
itemStack.setTagCompound((NBTTagCompound) nbttag);
} catch (NBTException e) {
FMLLog.getLogger().log(Level.WARN, "Encountered an exception parsing ItemStack NBT string {}", nbtString, e);
return null;
}
}
}
return itemStack;
}
public static NBTTagCompound readNBT(File file) throws IOException {
if(!file.exists()) return null;
FileInputStream in = new FileInputStream(file);
@@ -408,4 +458,8 @@ public class NEIServerUtils
CompressedStreamTools.writeCompressed(tag, out);
out.close();
}
public static int divideCeil(int numerator, int denominator) {
return (int) Math.ceil((float) numerator / denominator);
}
}
@@ -22,8 +22,7 @@ public class PositionedStack
private boolean permutated = false;
public PositionedStack(Object object, int x, int y, boolean genPerms)
{
public PositionedStack(Object object, int x, int y, boolean genPerms) {
items = NEIServerUtils.extractRecipeItems(object);
relx = x;
rely = y;
@@ -39,27 +38,22 @@ public class PositionedStack
this(object, x, y, true);
}
public void generatePermutations()
{
public void generatePermutations() {
if(permutated)
return;
ArrayList<ItemStack> stacks = new ArrayList<>();
for(ItemStack item : items)
{
for(ItemStack item : items) {
if(item == null || item.getItem() == null)
continue;
if(item.getItemDamage() == Short.MAX_VALUE)
{
if(item.getItemDamage() == Short.MAX_VALUE) {
List<ItemStack> permutations = ItemList.itemMap.get(item.getItem());
if(!permutations.isEmpty())
{
if(!permutations.isEmpty()) {
for(ItemStack stack : permutations)
stacks.add(stack.copy());
}
else
{
else {
ItemStack base = new ItemStack(item.getItem(), item.stackSize);
base.stackTagCompound = item.stackTagCompound;
stacks.add(base);
@@ -78,20 +72,17 @@ public class PositionedStack
setPermutationToRender(0);
}
public void setMaxSize(int i)
{
public void setMaxSize(int i) {
for(ItemStack item : items)
if(item.stackSize > i)
item.stackSize = i;
}
public PositionedStack copy()
{
public PositionedStack copy() {
return new PositionedStack(items, relx, rely);
}
public void setPermutationToRender(int index)
{
public void setPermutationToRender(int index) {
item = items[index].copy();
if(item.getItem() == null)
item = new ItemStack(Blocks.fire);
@@ -99,8 +90,7 @@ public class PositionedStack
item.setItemDamage(0);
}
public boolean contains(ItemStack ingredient)
{
public boolean contains(ItemStack ingredient) {
for(ItemStack item : items)
if(NEIServerUtils.areStacksSameTypeCrafting(item, ingredient))
return true;
@@ -108,12 +98,16 @@ public class PositionedStack
return false;
}
public boolean contains(Item ingred)
{
public boolean contains(Item ingred) {
for(ItemStack item : items)
if(item.getItem() == ingred)
return true;
return false;
}
@Override
public String toString() {
return "PositionedStack(output='" + item.toString() + "')";
}
}
@@ -63,8 +63,9 @@ public class SearchField extends TextField implements ItemFilterProvider
}
@Override
public int getTextColour() {
if(ItemPanels.itemPanel.realItems.size() == 0) {
public int getTextColour()
{
if (ItemPanels.itemPanel.getItems().isEmpty()) {
return focused() ? 0xFFcc3300 : 0xFF993300;
} else {
return focused() ? 0xFFE0E0E0 : 0xFF909090;
File renamed without changes.
@@ -33,6 +33,7 @@ public class SpawnerRenderer implements IItemRenderer
String bossName = BossStatus.bossName;
int bossTimeout = BossStatus.statusBarTime;
boolean bossHasColorModifier = BossStatus.hasColorModifier;
try
{
World world = NEIClientUtils.mc().theWorld;
@@ -66,6 +67,7 @@ public class SpawnerRenderer implements IItemRenderer
}
BossStatus.bossName = bossName;
BossStatus.statusBarTime = bossTimeout;
BossStatus.hasColorModifier = bossHasColorModifier;
}
@SuppressWarnings("incomplete-switch")
@@ -26,13 +26,20 @@ import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.regex.Pattern;
import static codechicken.nei.NEIClientUtils.translate;
public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoadedCallback, ISearchProvider
{
public static ReentrantReadWriteLock hiddenItemLock = new ReentrantReadWriteLock();
public static Lock writeLock = hiddenItemLock.writeLock();
public static Lock readLock = hiddenItemLock.readLock();
public static class SubsetState
{
int state = 2;
@@ -210,7 +217,18 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
for(SubsetTag tag : sorted)
tag.cacheState();
}
public void addFiltersWithItem(List<ItemFilter> filters, String itemSearch) {
if(itemSearch == null) {
addFilters(filters);
} else {
if(filter != null)
filters.add(new DoubleFilteredFilter(filter, itemSearch));
for(SubsetTag child : sorted)
child.addFiltersWithItem(filters, itemSearch);
}
}
public void addFilters(List<ItemFilter> filters) {
if(filter != null)
filters.add(filter);
@@ -397,9 +415,20 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
}
public static boolean isHidden(ItemStack item) {
synchronized (hiddenItems) {
return hiddenItems.contains(item);
try {
if(readLock.tryLock(5, TimeUnit.SECONDS)) {
try {
return hiddenItems.contains(item);
} finally {
readLock.unlock();
}
} else {
NEIClientConfig.logger.error("Unable to obtain read lock in 'isHidden'");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
return false;
}
private static void _setHidden(SubsetTag tag, boolean hidden) {
@@ -410,38 +439,80 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
}
private static void _setHidden(ItemStack item, boolean hidden) {
if(hidden)
hiddenItems.add(item);
else
hiddenItems.remove(item);
if (hiddenItemLock.isWriteLockedByCurrentThread()) {
if (hidden)
hiddenItems.add(item);
else
hiddenItems.remove(item);
}
}
public static void showOnly(SubsetTag tag) {
synchronized (hiddenItems) {
for(ItemStack item : ItemList.items)
_setHidden(item, true);
setHidden(tag, false);
try {
if(writeLock.tryLock(5, TimeUnit.SECONDS)) {
try {
for (ItemStack item : ItemList.items)
_setHidden(item, true);
setHidden(tag, false);
} finally {
writeLock.unlock();
}
} else {
NEIClientConfig.logger.error("Unable to obtain write lock in 'showOnly'");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void setHidden(SubsetTag tag, boolean hidden) {
synchronized (hiddenItems) {
_setHidden(tag, hidden);
updateHiddenItems();
try {
if(writeLock.tryLock(5, TimeUnit.SECONDS)) {
try {
_setHidden(tag, hidden);
updateHiddenItems();
} finally {
writeLock.unlock();
}
} else {
NEIClientConfig.logger.error("Unable to obtain write lock in 'setHidden'");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void setHidden(ItemStack item, boolean hidden) {
synchronized (hiddenItems) {
_setHidden(item, hidden);
updateHiddenItems();
try {
if(writeLock.tryLock(5, TimeUnit.SECONDS)) {
try {
_setHidden(item, hidden);
updateHiddenItems();
} finally {
writeLock.unlock();
}
} else {
NEIClientConfig.logger.error("Unable to obtain write lock in 'setHidden'");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void unhideAll() {
synchronized (hiddenItems) {
hiddenItems.clear();
updateHiddenItems();
try {
if(writeLock.tryLock(5, TimeUnit.SECONDS)) {
try {
hiddenItems.clear();
updateHiddenItems();
} finally {
writeLock.unlock();
}
} else {
NEIClientConfig.logger.error("Unable to obtain write lock in 'unhideAll'");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
@@ -451,8 +522,19 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
}
public static void loadHidden() {
synchronized (hiddenItems) {
hiddenItems.clear();
try {
if(writeLock.tryLock(5, TimeUnit.SECONDS)) {
try {
hiddenItems.clear();
} finally {
writeLock.unlock();
}
} else {
NEIClientConfig.logger.error("Unable to obtain write lock in 'loadHidden'");
}
} catch (InterruptedException e) {
e.printStackTrace();
return;
}
List<ItemStack> itemList = new LinkedList<>();
@@ -466,9 +548,19 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
return;
}
synchronized (hiddenItems) {
for(ItemStack item : itemList)
hiddenItems.add(item);
try {
if(writeLock.tryLock(5, TimeUnit.SECONDS)) {
try {
for (ItemStack item : itemList)
hiddenItems.add(item);
} finally {
writeLock.unlock();
}
} else {
NEIClientConfig.logger.error("Unable to obtain second write lock in 'loadHidden'");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
updateState.restart();
}
@@ -484,9 +576,20 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
private static final RestartableTask prepareDirtyHiddenItems = new RestartableTask("NEI Subset Save Thread")
{
private List<ItemStack> getList() {
synchronized (hiddenItems) {
return hiddenItems.values();
try {
if(readLock.tryLock(5, TimeUnit.SECONDS)) {
try {
return hiddenItems.values();
} finally {
readLock.unlock();
}
} else {
NEIClientConfig.logger.error("Unable to obtain read lock in 'NEI Subset Save Thread'");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
return new ArrayList<>();
}
@Override
@@ -706,9 +809,20 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
public ItemFilter getFilter() {
//synchronise access on hiddenItems
return item -> {
synchronized (hiddenItems) {
return !hiddenItems.matches(item);
try {
if(readLock.tryLock(5, TimeUnit.SECONDS)) {
try {
return !hiddenItems.matches(item);
} finally {
readLock.unlock();
}
} else {
NEIClientConfig.logger.error("Unable to obtain read lock in 'getFilter'");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
return false;
};
}
@@ -723,20 +837,32 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
return null;
searchText = searchText.substring(1);
String itemSearch = null;
if(searchText.contains("->")) {
String[] split = searchText.split("->");
searchText = split[0];
if(split.length > 1) itemSearch = split[1];
}
AnyMultiItemFilter filter = new AnyMultiItemFilter();
SubsetTag tag = getTag(searchText);
if(tag != null)
tag.addFilters(filter.filters);
if(tag != null) {
// We've got an exact match
tag.addFiltersWithItem(filter.filters, itemSearch);
}
else {
// Try searching for a substring
Pattern p = SearchField.getPattern(searchText);
if(p == null) return null;
List<SubsetTag> matching = new LinkedList<>();
root.search(matching, p);
if(matching.isEmpty()) return null;
for(SubsetTag tag2 : matching)
tag2.addFilters(filter.filters);
for(SubsetTag tag2 : matching) {
tag2.addFiltersWithItem(filter.filters, itemSearch);
}
}
return filter;
}
@@ -79,6 +79,7 @@ public abstract class TextField extends Widget
if (!focused())
return false;
String oldText = text();
boolean handled = field.textboxKeyTyped(keyChar, keyID);
if(!handled) {
if (keyID == Keyboard.KEY_RETURN || keyID == Keyboard.KEY_NUMPADENTER || keyID == Keyboard.KEY_ESCAPE) {
@@ -88,7 +89,7 @@ public abstract class TextField extends Widget
}
if(handled) {
onTextChange(text());
onTextChange(oldText);
}
return handled;
@@ -120,8 +121,10 @@ public abstract class TextField extends Widget
if (focus) {
previousKeyboardRepeatEnabled = Keyboard.areRepeatEventsEnabled();
Keyboard.enableRepeatEvents(true);
gainFocus();
} else {
Keyboard.enableRepeatEvents(previousKeyboardRepeatEnabled);
loseFocus();
}
}
@@ -55,8 +55,11 @@ public class ThreadOperationTimer extends Thread
while (thread.isAlive()) {
synchronized (this) {
if (operation != null && System.currentTimeMillis() - opTime > limit)
thread.stop(new TimeoutException("Operation took too long", operation));
if (operation != null && System.currentTimeMillis() - opTime > limit) {
// Thread.stop(Throwable) is hard-deprecated and IntelliJ complains about it.
//thread.stop(new TimeoutException("Operation took too long", operation));
thread.stop();
}
}
try {
Thread.sleep(50);
File renamed without changes.
@@ -15,11 +15,15 @@ import codechicken.nei.SubsetWidget.SubsetTag;
import codechicken.nei.api.ItemFilter.ItemFilterProvider;
import codechicken.nei.config.Option;
import codechicken.nei.config.OptionKeyBind;
import codechicken.nei.recipe.CatalystInfo;
import codechicken.nei.recipe.GuiCraftingRecipe;
import codechicken.nei.recipe.GuiUsageRecipe;
import codechicken.nei.recipe.ICraftingHandler;
import codechicken.nei.recipe.IRecipeHandler;
import codechicken.nei.recipe.IUsageHandler;
import codechicken.nei.recipe.RecipeCatalysts;
import codechicken.nei.recipe.RecipeInfo;
import codechicken.nei.recipe.StackInfo;
import net.minecraft.block.Block;
import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.inventory.Slot;
@@ -29,6 +33,7 @@ import org.lwjgl.input.Keyboard;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
/**
* This is the main class that handles item property configuration.
@@ -112,7 +117,12 @@ public class API
}
public static void registerNEIGuiHandler(INEIGuiHandler handler) {
GuiInfo.guiHandlers.add(handler);
try {
GuiInfo.writeLock.lock();
GuiInfo.guiHandlers.add(handler);
} finally {
GuiInfo.writeLock.unlock();
}
}
/**
@@ -279,4 +289,78 @@ public class API
ItemInfo.itemVariants.put(item, variant);
LayoutManager.markItemsDirty();
}
public static void registerStackStringifyHandler(IStackStringifyHandler handler)
{
StackInfo.stackStringifyHandlers.add(handler);
}
/**
* Adds an association between an ingredient and what it can craft. (i.e. Furnace ItemStack -> Smelting and Fuel Recipes)
* Allows players to see what ingredient they need to craft in order to make recipes from a recipe category.
* @param stack the ingredient that can craft recipes (like a furnace or crafting table)
* @param handler the recipe category handled by the ingredient
* @param priority higher priority comes first, default to 0
*/
public static void addRecipeCatalyst(ItemStack stack, IRecipeHandler handler, int priority) {
String handlerID = RecipeCatalysts.getRecipeID(handler);
addRecipeCatalyst(stack, handlerID, priority);
}
/**
* See {@link API#addRecipeCatalyst(ItemStack, IRecipeHandler, int)}
*/
public static void addRecipeCatalyst(ItemStack stack, IRecipeHandler handler) {
addRecipeCatalyst(stack, handler, 0);
}
/**
* Adds an association between an ingredient and what it can craft. (i.e. Furnace ItemStack -> Smelting and Fuel Recipes)
* Allows players to see what ingredient they need to craft in order to make recipes from a recipe category.
* @param stack the ingredient that can craft recipes (like a furnace or crafting table)
* @param handlerID recipe category identifier (see also {@link RecipeCatalysts#getRecipeID(IRecipeHandler)})
* @param priority higher priority comes first, default to 0
*/
public static void addRecipeCatalyst(ItemStack stack, String handlerID, int priority) {
RecipeCatalysts.addRecipeCatalyst(handlerID, new CatalystInfo(stack, priority));
}
/**
* See {@link API#addRecipeCatalyst(ItemStack, String, int)}
*/
public static void addRecipeCatalyst(ItemStack stack, String handlerID) {
addRecipeCatalyst(stack, handlerID, 0);
}
public static void removeRecipeCatalyst(ItemStack stack, IRecipeHandler handler) {
String handlerID = RecipeCatalysts.getRecipeID(handler);
removeRecipeCatalyst(stack, handlerID);
}
public static void removeRecipeCatalyst(ItemStack stack, String handlerID) {
RecipeCatalysts.removeRecipeCatalyst(handlerID, stack);
}
@Deprecated
public static void addRecipeCatalyst(List<ItemStack> stacks, IRecipeHandler handler) {
for (ItemStack stack : stacks) {
addRecipeCatalyst(stack, handler);
}
}
@Deprecated
public static void addRecipeCatalyst(List<ItemStack> stacks, String handlerID) {
for (ItemStack stack : stacks) {
addRecipeCatalyst(stack, handlerID);
}
}
@Deprecated
public static void addRecipeCatalyst(ItemStack stack, Class<? extends IRecipeHandler> handler) {
}
@Deprecated
public static void addRecipeCatalyst(List<ItemStack> stacks, Class<? extends IRecipeHandler> handler) {
}
}
@@ -3,29 +3,38 @@ package codechicken.nei.api;
import codechicken.nei.NEIChestGuiHandler;
import codechicken.nei.NEICreativeGuiHandler;
import codechicken.nei.NEIDummySlotHandler;
import codechicken.nei.recipe.GuiRecipeCatalyst;
import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.client.gui.inventory.GuiContainerCreative;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class GuiInfo
{
public class GuiInfo {
public static final LinkedList<INEIGuiHandler> guiHandlers = new LinkedList<>();
public static final HashSet<Class<? extends GuiContainer>> customSlotGuis = new HashSet<>();
public static ReentrantReadWriteLock guiHandlersLock = new ReentrantReadWriteLock();
public static Lock writeLock = guiHandlersLock.writeLock();
public static Lock readLock = guiHandlersLock.readLock();
public static void load() {
API.registerNEIGuiHandler(new NEICreativeGuiHandler());
API.registerNEIGuiHandler(new NEIChestGuiHandler());
API.registerNEIGuiHandler(new NEIDummySlotHandler());
API.registerNEIGuiHandler(new GuiRecipeCatalyst(null));
customSlotGuis.add(GuiContainerCreative.class);
}
public static void clearGuiHandlers() {
for (Iterator<INEIGuiHandler> iterator = guiHandlers.iterator(); iterator.hasNext(); )
if (iterator.next() instanceof GuiContainer)
iterator.remove();
try {
GuiInfo.writeLock.lock();
guiHandlers.removeIf(ineiGuiHandler -> ineiGuiHandler instanceof GuiContainer);
} finally {
GuiInfo.writeLock.unlock();
}
}
public static boolean hasCustomSlots(GuiContainer gui) {
@@ -0,0 +1,16 @@
package codechicken.nei.api;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraftforge.fluids.FluidStack;
import net.minecraft.item.ItemStack;
public interface IStackStringifyHandler
{
public NBTTagCompound convertItemStackToNBT(ItemStack stack, boolean saveStackSize);
public ItemStack convertNBTToItemStack(NBTTagCompound nbtTag);
public FluidStack getFluid(ItemStack stack);
}
Loaded 100 of 213 files, more files were not shown because too many files have changed in this diff. Show more