Compare commits

...
290 Commits
Author SHA1 Message Date
gorbit99andslprime d73df3aedc Clear bookmark group tooltip when pulling items or changing quantities (#1152)
Co-authored-by: slprime <[email protected]>
2026-11-22 10:11:37 +02:00
slprime f84b24724a Fix autocraft crash when started from the recipe screen (#1108) (#1150) 2026-11-21 19:57:06 +02:00
OrderedSet86 1bb550305c Less hacky light overlay fix for light opacity 0 blocks (#1124) 2026-11-19 16:26:46 +00:00
gorbit99 6649d28708 Change layout recalculation order (#1125) 2026-11-19 14:55:18 +01:00
slprime 6b7e465306 Copy fluid registry name instead of the display item id (#1122) 2026-11-17 21:53:30 +02:00
ab1e8153f5 Add NEI mob spawn overlay variants (#1111)
- Add multiple light level overlay modes (Connected, Square, GTNH Logo, Pufferfish, X)
- Set default F7 overlay to Connected
- Allow changing horizontal and vertical radius of light level overlay (before it was stuck at 16 blocks)
- Set default horizontal radius to 32 blocks
- Optimize performance by 10-30x compared to master
- Works with shaders (tested Complementary Unbound + Euphoria patches)

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: Martin Robertz <[email protected]>
2026-11-16 19:51:42 +02:00
slprime 4257235e6e Don't toggle handler info widget while typing in recipe search (#1121) 2026-11-15 16:20:26 +02:00
slprime 1c33a5b7d6 Add recipe text search with ~ prefix (#1120) 2026-11-15 15:43:35 +02:00
slprime 8e6b31de18 Speed up GUID cache and bookmark recipe lookups (#1119) 2026-11-13 23:25:20 +02:00
DarkShadow44andslprime 1a27b02412 Don't copy stack unless it changed (#1116)
Co-authored-by: slprime <[email protected]>
2026-11-13 01:53:07 +02:00
slprime 0185cd64b1 Optimize GUI overlap scan for item panels (#1118) 2026-11-12 01:35:53 +02:00
slprime fbbeafcd79 Fix WorldClient leak after leaving the world (#1115) 2026-11-10 19:22:17 +02:00
UltraProdigy 9839d1d08f ci: run build and test on release branches 2026-11-09 01:11:38 -05:00
slprime 84d42de15f Make name optional in API.addCollapsibleGroup (#1114) 2026-11-08 18:13:37 +02:00
slprime d04e1c8e83 Add API.addCollapsibleGroup for registering collapsible item groups (#1113) 2026-11-08 17:37:44 +02:00
slprime 514af5669c Rollback fluent setters in PositionedStack added in #1106 (#1110) 2026-11-06 21:26:08 +01:00
slprime 41c2b96c88 Fix NPE in StackInfo.getItemStackWithMinimumDamage for unregistered items (#1109) 2026-11-05 18:19:48 +02:00
slprime 8e1541eab1 Remove creative tab style option for recipe tabs (#1107) 2026-11-04 16:34:56 +02:00
slprime 9411541fd8 Move RecipeTransferRectHandler out of TemplateRecipeHandler and tidy up PositionedStack (#1106) 2026-11-03 20:35:40 +02:00
slprime ae0d6c6108 Add getResultStacks/getAuxiliaryStacks to IRecipeHandler (#1105) 2026-11-03 17:33:07 +02:00
slprime aea4c2866a Stop auto-creating NEI config files, add export buttons instead (#1104) 2026-11-02 22:20:09 +02:00
slprime c1a525594c Fix ConcurrentModificationException when iterating the crafting recipe list (#1103) 2026-11-02 19:38:18 +02:00
slprimeandMartin Robertz afc8a2380b Remove per-world config override (#1094)
Co-authored-by: Martin Robertz <[email protected]>
2026-11-02 18:20:18 +02:00
slprime a0b2430458 Remove hardcoded vanilla block name overrides (#1102) 2026-11-01 21:53:37 +02:00
Armisael5 4dc6be839b Add NEI Recipe Exporting (#1100) 2026-11-01 15:25:25 +02:00
slprime 030795e3c7 Fix NEI plugin loading crash under a SecurityManager (#1099) 2026-10-29 20:59:01 +02:00
slprime 897a22ad17 Run NEI hotkeys before third-party lastKeyTyped handlers (#1097) 2026-10-28 17:37:45 +02:00
5faed21218 Revert missing item count rendering changes from #1044 (#1091)
Co-authored-by: Martin Robertz <[email protected]>
Co-authored-by: slprime <[email protected]>
2026-10-26 00:21:23 +02:00
Worive aa9da2e0a0 Fix NEI initialization aborting while logging plugin errors (#1093) 2026-10-25 17:10:38 +02:00
slprime e9a3a494d5 Add Mouse Binding (#1092) 2026-10-25 02:49:38 +03:00
slprime ebe83f970f Fix group drag between bookmark namespaces (#1090) 2026-10-24 01:09:00 +03:00
slprime ad9beb7f90 Fill crafting grid with one recipe when Ctrl is held (#1089) 2026-10-23 23:44:16 +03:00
slprime 68bdb51c6b Update tree camera and scrollbar dragging every frame (#1087) 2026-10-22 23:58:41 +03:00
slprime e4e1964dec Fix NPE in BookmarksGridSlot when dragging a group across namespaces (#1086) 2026-10-22 16:22:23 +03:00
slprime 560618024f Autocrafting Optimization (#1084) 2026-10-21 01:24:40 +03:00
slprime e2a2d2a9df Batch 9-slice quads in DrawableResource (#1082) 2026-10-19 15:47:52 +03:00
slprime 7163630cb1 Move 9-slice setup into DrawableBuilder (#1081) 2026-10-16 23:18:28 +03:00
RessedandMartin Robertz ab168ad6ba Make StrictIdentifierFilter (<modid:name:meta>) resolve item on first match (#1080)
Co-authored-by: Martin Robertz <[email protected]>
2026-10-16 20:42:59 +03:00
Martin Robertz e13e3483f0 update+deps+bs 2026-10-16 10:20:51 +02:00
slprime de26547b64 Treat item aliases as translation keys (#1079) 2026-10-15 20:19:58 +03:00
slprime c49f8808fd Fix NPE in item panel getMask (#1078) 2026-10-15 18:59:55 +03:00
slprime 1c6cc8b693 Unify hovered recipe lookup into HoveredRecipe (#1076) 2026-10-12 22:03:07 +03:00
slprime 43ae1b613a Add recipe origins to handler debug widget (#1072) 2026-10-12 13:43:22 +03:00
Wilhelm Schuster 402c4325a6 Update java version in GitHub issue template (#1074) 2026-10-11 23:33:54 +02:00
slprime 550e85c456 Fix -@mod and !@mod search syntax in Extended mode (#1071) 2026-10-10 14:58:17 +03:00
slprime 1673079cbb ItemZoom: Add side priority option (#1070) 2026-10-10 14:36:28 +03:00
slprime e6174c446a Add options for vertical line count in chain tooltips (#1068) 2026-10-09 21:14:11 +03:00
slprime 869b4571b0 Add recipe cycle freeze option (#1067) 2026-10-09 19:47:38 +03:00
slprime 35f5400ecb Fix Crafting Tree NPE (#1064) 2026-10-06 19:57:10 +03:00
micvog 1e2801c891 Fix crash when returning to the crafting tree after its bookmark group was removed (#1063) 2026-10-06 19:46:37 +03:00
Ressedandslprime 1b3b495fec Fix crash while dragging bookmark group to another grid (#1062)
Co-authored-by: slprime <[email protected]>
2026-10-05 20:07:52 +03:00
slprime 2844ea35bc Fix Old Handlers Hack (#1061) 2026-10-04 22:07:41 +03:00
slprime c020ecbf1f Add Custom Renderer API for Fluids (#1059) 2026-10-02 01:22:58 +03:00
slprime a105a60a1a Fix Subset Width Calculation (#1058) 2026-10-01 23:16:35 +03:00
slprime 3a4a6734dc Fix NPE on GT fluid display without NBT (#1057) 2026-09-29 22:30:43 +03:00
slprime 11f9194de9 Fix EnderIo Tank (#1056) 2026-09-29 20:00:29 +03:00
slprimeandgithub-actions[bot] a685efb3b7 Recipe Group Optimization (#1054)
Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
2026-09-28 00:19:29 +03:00
danyadevandMartin Robertz 9f3697bb67 fix cycling for fluid permutations (#1048)
Co-authored-by: Martin Robertz <[email protected]>
2026-09-27 18:21:56 +03:00
slprime 18abb880f8 Add widget size to recipe event (#1053) 2026-09-27 14:13:27 +03:00
slprime 5868187410 Save Tree State (#1052) 2026-09-27 11:00:27 +03:00
slprime f84c4ef2bd Rename PositionStack.Fluid to Tank (#1051) 2026-09-27 08:09:52 +03:00
slprime a54c414595 Add Recipe Groups to GuiRecipe (#1049) 2026-09-27 07:39:27 +03:00
slprime 3c472a02cb Add Flowinf Texture to PositionStack (#1047) 2026-09-26 01:06:38 +03:00
slprime 382278bebb Fix Keybinding Category Names (#1046) 2026-09-25 23:36:57 +03:00
slprime 55c9811a2b Fix search autofocus losing the first typed character (#1045) 2026-09-25 22:17:38 +03:00
slprime 0ec87a8b9e Refactoring Chain Tooltip (#1044) 2026-09-25 22:08:15 +03:00
slprime 939845a9ed Add List View to Recipe (#1041) 2026-09-23 00:14:39 +03:00
Martin Robertz c9db437dd1 update+gradle+bs+deps+gitignore
fix curse auto uploader
2026-09-18 00:21:05 +02:00
Jakub b1f20104a6 Publishing (#1039) 2026-09-17 14:09:06 +02:00
AlexandAlex Vermette ab8d5f275f fix(NEIController): Skip MMB on slot click to avoid unecessary conflict with itemstack using it (#1038)
Co-authored-by: Alex Vermette <[email protected]>
2026-09-17 09:16:46 +03:00
slprime 9e87f2b158 Item Craftables Panel Optimization (#1036) 2026-09-14 18:36:58 +03:00
Dream Master ab512d3fd8 update deps 2026-09-14 10:28:02 +02:00
slprime 4a9f17590b Fix Slot Highlighting (#1035) 2026-09-14 08:44:35 +03:00
slprime a845e6c3e5 Registry NEI Fluids in Server (#1033) 2026-09-12 23:41:17 +03:00
Chitak 985 4f3a0826fe ItemFluidDisplay/getSubItems skips the last fluid (#1032) 2026-09-12 22:43:05 +03:00
slprime 6cd7697ca0 Repair Handler Optimization (#1031) 2026-09-12 20:02:52 +03:00
slprime 38dc14eca1 Fix concurrent modification crash in API.hideItem (#1030) 2026-09-11 08:30:49 +03:00
slprime 1fc824410b Change Fluid Amount Limit (#1029) 2026-09-11 08:10:28 +03:00
slprime af6dba1269 Correctly filtering neifluids (#1027) 2026-09-10 22:52:37 +03:00
slprime 2bf5a1cf9f Fix Bookmark Fluid Factor Limit (#1025) 2026-09-09 19:07:19 +03:00
Ranzuandgithub-actions[bot] 2126ec78bc Destroy one pixel and add color localization (#1022)
Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
2026-09-09 13:34:25 +03:00
slprime 5f6209366a Fix Detect Fluid Display (#1021) 2026-09-09 07:06:14 +03:00
JarnexisandMykhailo Balaker f5fc4e704d Add Ukrainian (uk_UA) localization and translate README (#996)
Co-authored-by: Mykhailo Balaker <[email protected]>
2026-09-08 18:52:48 +02:00
slprimeandgithub-actions[bot] 3d6c1c6e19 Implement Bookmark Tree Screen (#1018)
Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
2026-09-08 13:56:58 +03:00
slprime fda7688807 Added fluid support in recipes (#1020) 2026-09-08 13:41:16 +03:00
boubou19andMartin Robertz 3f38e6f39b Various CPU and RAM improvements (#1015)
Co-authored-by: Martin Robertz <[email protected]>
2026-09-03 00:07:25 +03:00
vcwdfca 866b796411 add centerOverlay (#1016) 2026-08-31 19:21:39 +03:00
slprime 7817640d96 Check unknown bookmark group (#1014) 2026-08-26 16:57:07 +03:00
vcwdfcaandslprime bd595f739c Add feature to save history like bookmarks (#1011)
Co-authored-by: slprime <[email protected]>
2026-08-26 13:40:18 +03:00
slprime 4c74a01930 Fix crash when recipe search results change mid-rebuild (#1012) 2026-08-25 09:09:53 +03:00
slprime 6ced1e0604 Fix Fluid Untranslator (#1009) 2026-08-20 22:25:35 +03:00
slprime f8d00a5445 Add Accepts Label (#1007) 2026-08-14 22:41:15 +03:00
Taran Robertsandslprime 75d53b12ca New worlds ignoring global cheatmode (#1003)
Co-authored-by: slprime <[email protected]>
2026-08-14 16:20:31 +03:00
slprime f93d5977ed Fix Autocrafting With GTTools (#1006) 2026-08-14 15:22:35 +03:00
slprimeandgithub-actions[bot] c4f9c54200 Fix Autocrafting Infinity Loop (#1004)
Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
2026-08-14 13:27:42 +03:00
slprime 7d4c8b82ba Add custom render for PositionedStack (#1002) 2026-08-13 21:49:05 +03:00
slprime c6170f9795 Bookmarks: Fix Permutations with different amount (#1000) 2026-08-12 22:45:39 +03:00
Dream Master 5a533c8994 update+gradle+bs+deps 2026-08-11 00:26:14 +07:00
Nikolay S.andslprime d70a47a3a4 Modernize Java code (#997)
Co-authored-by: slprime <[email protected]>
2026-08-10 14:55:40 +03:00
boubou19andgithub-actions[bot] 6c3db443d7 Cache enum .values() (#998)
Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
2026-08-10 07:40:36 +02:00
boubou19 a51836fe9b Optimize updateUnlimitedItems (#995) 2026-08-07 19:05:01 +03:00
slprime 139ca22e51 Fix Untranslator With Broken Item (#993) 2026-08-04 19:43:34 +03:00
slprime 10fc78bdcf Add Recipe Filter syntax tooltip (#992) 2026-08-04 19:18:27 +03:00
slprime 5fb5ab6698 Added Bookmark Chain Visitor (#991) 2026-08-01 20:35:19 +03:00
slprime f47a8766a9 Create EmptyContainer (#990) 2026-08-01 20:19:54 +03:00
slprime 4cc72444d9 Fix Tooltip with Component in first line (#989) 2026-08-01 20:00:17 +03:00
slprime b48956ef94 Bookmarks Chain: fix container item multiplier limit (#988) 2026-07-29 00:57:12 +03:00
Algentandslprime 583d28ed12 Fix GL reset (#984)
Co-authored-by: slprime <[email protected]>
2026-07-26 23:36:37 +03:00
koolkrafter5 384813347c Overlay Button moves one item if the recipe stack is size zero (#985) 2026-07-26 23:28:39 +03:00
slprime 2b28068382 Simplify the keybinding (#982) 2026-07-25 02:14:12 +03:00
slprime 2c204c25aa Rework chat item link to support bookmarking recipes and groups (#971) 2026-07-11 20:38:01 +03:00
Jordan Rey 5e6ff1d63b fix: spawner placement logic (#973) 2026-07-11 20:33:51 +03:00
Algent 53ce50b35a oregenPattern this time for sure (#974) 2026-07-11 19:53:43 +03:00
slprime 835c4f7e01 Fix Dynamic Keybinding (#972) 2026-07-11 14:20:03 +03:00
RecursivePineapple f8c1f39faf Add Cubic Chunks cube overlay & fix chunk grid above y=256, below y=0. (#970) 2026-07-10 11:02:43 +03:00
slprime 4c4716e64f Fix duplicate keybinding handling by patching KeyBinding static handlers (#968) 2026-07-08 09:19:48 +03:00
LunaandMartin Robertz c84ac27a18 Add offset for snow block to mob spawn overlay (#965)
Co-authored-by: Martin Robertz <[email protected]>
2026-07-07 11:44:58 +02:00
mllfjn 47baee272c Remove redundant simplewasher recipe (#967) 2026-07-07 11:08:44 +02:00
Martin Robertz f55dc716e3 update deps 2026-07-04 19:50:07 +02:00
slprimeandMartin Robertz 26beb079f0 [Feature] Keybinding Refactoring (#957)
Co-authored-by: Martin Robertz <[email protected]>
2026-07-04 14:38:02 +03:00
Algent 841b73c6fe Update way of getting oregen pattern for GT overlay (#964) 2026-06-30 18:18:32 +03:00
slprime 0c7eeebb1f Fix Debug Handler (#963) 2026-06-29 20:24:36 +03:00
slprime 65b56735a7 Add item name aliases for search (#961) 2026-06-29 18:08:59 +02:00
slprime ff428bf538 Allow plugins to force fill mode for overlay button (#960) 2026-06-28 13:11:27 -04:00
Martin Robertz a406021f26 deps 2026-06-27 15:15:43 +02:00
slprime 8500ac57eb Persist hidden items by GUID across reloads (#959) 2026-06-27 00:48:39 +03:00
slprime d97123ec13 ItemLoader Refactoring/Optimization (#958) 2026-06-26 21:25:07 +03:00
slprime 434931bfac Fix Loading Items error log (#956) 2026-06-21 00:57:41 +03:00
RanzuandMartin Robertz 860011036b Convert color class (#947)
Co-authored-by: Martin Robertz <[email protected]>
2026-06-16 10:21:20 +02:00
slprime 937c1858a4 Fix Config Option NPE (#951) 2026-06-14 21:14:44 +03:00
slprime 4562ecf087 Fix Broken DisplayName in Untranslator (#949) 2026-06-13 17:46:46 +03:00
slprime d621d5d5bd Fix Autocrefing Permission (#948) 2026-06-13 17:25:07 +03:00
Martin Robertz 3175b316af update+gradle+deps+bs 2026-06-12 23:32:41 +02:00
slprime 61930ac7a8 Add server-controlled autocraft permission (#942) 2026-06-10 18:58:23 +03:00
slprime fcbf1dcade Fix Single Item In Bookmarks With Amount (#941) 2026-06-07 20:22:42 +03:00
slprime 3fa69e826c Guard loadTransferRects against plugin init errors (#939) 2026-05-27 08:26:29 +03:00
31fff21a55 Smart-Fallback & Alchemic Chemistry Set Fix (#935)
Co-authored-by: FFS <FFS@OhFuckOff>
Co-authored-by: slprime <[email protected]>
2026-05-27 02:29:59 +03:00
slprime 2e9ab88692 Fix ItemStack load from NBT with short overflow (#938) 2026-05-27 02:22:47 +03:00
slprime a02d293d44 Fix Recipe Page Area (#932) 2026-05-11 18:47:36 +03:00
sisyphussy 1265113390 Fix mui2 screen capture (#930) 2026-05-07 20:30:52 +03:00
slprime 4ffd614017 GuiRecipe: Add scrollPages Option (#929) 2026-05-07 18:57:15 +03:00
slprime 41554f4c5b Options: fix memory leaks (#928) 2026-05-06 22:36:07 +02:00
slprime 2104184077 GuiInfo: fix memory leaks (#927) 2026-05-06 20:18:35 +02:00
slprime d5f25a4be8 Prevent ConcurrentModificationException while searching for fuels in ItemList (#926) 2026-05-06 19:43:50 +03:00
slprime ccbf94790a Add Horizontal Scroll to Recipe GUI (#924) 2026-05-06 19:31:00 +03:00
slprime 2f4f72a2d6 Fix Filter Loading (#925) 2026-05-06 07:55:49 +03:00
danyadevandslprime f8cec9a78c Much faster recipe dumper (#920)
Co-authored-by: slprime <[email protected]>
2026-04-25 14:58:50 +03:00
Lucaandslprime fb43a662eb Fix StringIndexOutOfBoundsException in FormattedTextField (#922)
Co-authored-by: slprime <[email protected]>
2026-04-25 10:30:32 +00:00
Luca b2e0b8878a Fix bookmark recipe item order being inconsistent (#921) 2026-04-25 13:21:46 +03:00
slprime 374f019103 Fix Autocrafting NPE (#917) 2026-04-14 01:29:26 +03:00
slprime 5dfcff6f30 Rollback PR#913 (#916) 2026-04-13 20:39:15 +03:00
slprime bd17301cb9 Fix Collapsed Recipes in Bookmarks (#915) 2026-04-13 15:41:30 +03:00
lc-1337 96ccd4e109 fix client -> server sync in creative gui (#913) 2026-04-12 14:47:27 +03:00
Kogepan229 b30ca57e68 Don't block slot click if canCheatItem is false (#912) 2026-04-08 18:35:08 +03:00
slprime 8f949bc1d1 Refactor recipe profiler (#911) 2026-04-07 13:10:39 +03:00
slprime d25365942a Fix Repair Handler with broken ItemStack (#910) 2026-04-06 21:35:47 +03:00
slprime eb58e1dabc Improve Recipe Badge (#909) 2026-04-06 20:39:41 +03:00
slprime f4601e7eed Disable badge by default (#907) 2026-04-04 21:12:05 +03:00
slprime ba48806667 Chance tooltip (#906) 2026-04-04 00:03:15 +03:00
Martin Robertz 70c332796a update+deps 2026-04-03 16:34:57 +02:00
slprime bcc25d4369 Fix Collapsed Recipes in Bookmarks (#905) 2026-03-31 20:47:23 +03:00
slprime 10a3109714 Add recipe chance to bookmarks (#903) 2026-03-30 20:36:55 +03:00
koolkrafter5 b60769864f Improve image exporter data dumper (#902) 2026-03-30 08:19:34 +03:00
slprime 6bc899769f Add Reset to Debug Handler (#901) 2026-03-26 22:22:13 +02:00
slprime 0ba14091fb Refactor DebugHandlerWidget (#900) 2026-03-22 14:10:10 +02:00
slprimeandUltraProdigy 6ed0be7961 Add Repair Handler (#899)
Co-authored-by: UltraProdigy <[email protected]>
2026-03-21 15:04:09 +02:00
slprime d40b951cce Fix areStacksSameTypeWithNBT damage check (#896) 2026-03-19 14:43:45 +02:00
slprime ecdf7892ce updateBuildScript (#895) 2026-03-19 09:39:59 +02:00
slprime 1eaaac94bc Fix filtered permutations (#893) 2026-03-18 01:25:27 +02:00
slprime e99167dddb Change calculateBounds (#892) 2026-03-15 22:41:31 +02:00
slprime 34cb0dc43f Set minimum GTNHLib version to 0.9.6 (#891) 2026-03-15 16:07:31 +01:00
slprime acaad4bf91 Fix Favorite Option (#887) 2026-03-09 21:23:22 +02:00
slprime 3de75f4e26 Fix bookmark slot placement logic (#885) 2026-03-08 12:23:18 +02:00
slprime 47497090ea fix glColor4f; disabled generateSingleRecipeFavorites by default (#884) 2026-03-07 16:58:30 +02:00
slprime 8b45a1757f Add Favorite Item Support (#880) 2026-03-07 16:34:41 +02:00
UltraProdigy 2782f8252e Optimize images (#883) 2026-03-07 09:40:11 +01:00
slprime a5538b2566 Always Show Recipe Ingredients Overlay (#878) 2026-03-01 11:38:05 +02:00
slprime a1f324b796 Remove Generated Favorites from Accepts Followings Tooltip (#873) 2026-02-23 09:32:15 +02:00
slprimeandMartin Robertz f3b6be26df Generate Single-Recipe Favorites (#863)
Co-authored-by: Martin Robertz <[email protected]>
2026-02-16 23:14:55 +01:00
slprime 9c764e3682 Restore the 'get infinite items' action (#867) 2026-02-16 18:39:17 +02:00
slprime 08605c3d73 Removed GTNHLib from required dependency (#866) 2026-02-16 04:37:20 -05:00
slprime 9ec1e0f0cd Change Bookmarks Panel Width (#862) 2026-02-10 19:41:28 +02:00
UltraProdigy e61151186c Exclude Duplicates (#860) 2026-02-09 23:05:15 +01:00
Martin Robertz f7787a9a22 update gradle + deps + bs 2026-02-09 22:32:25 +01:00
slprimeandUltraProdigy a91083bb5a Fix Pull Bookmarked Items (#857)
Co-authored-by: UltraProdigy <[email protected]>
2026-02-09 21:29:07 +00:00
slprimeandUltraProdigy 51f830bdf6 Reset item panel page on search result size change (#855)
Co-authored-by: UltraProdigy <[email protected]>
2026-02-09 16:18:22 -05:00
slprime 9326ac48ad Align panels from center to edges (#856) 2026-02-09 21:11:10 +00:00
c125b71ae0 Added checks for abstract classes when retrieving entities (#833)
Co-authored-by: Martin Robertz <[email protected]>
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
2026-02-08 20:49:58 +00:00
Ranzu 805b90d6f8 Add debug text localization and tooltips (#854) 2026-02-03 17:58:20 +02:00
RanzuandMartin Robertz 900b9f90e7 Added show all handlers and recipes function (#852)
Co-authored-by: Martin Robertz <[email protected]>
2026-02-03 15:38:35 +02:00
Ranzuandslprime 06d4a96c3a Add texture for toggled state of magnet button (#849)
Co-authored-by: slprime <[email protected]>
2026-01-26 20:15:10 +02:00
sbwaz 9a5a4a77ef [Extended+] Quote in extended+ depending on "Quote Drop Item Name" NEI option (#848) 2026-01-26 20:08:27 +02:00
Connor-ColensoandConnor Colenso 4d874ec910 Format number centralisation (#846)
Co-authored-by: Connor Colenso <colen@CONNORSPC>
2026-01-23 20:51:38 -05:00
slprime 7f0f2466a5 Fix Information Handler Background Padding (#843) 2026-01-19 13:13:14 +02:00
slprime 83e1966ff2 Fix Recipe Handlers Padding (#842) 2026-01-19 07:47:05 +01:00
slprime 548f754823 Fix Autocrafting for recipe without ingredients in bookmarks (#841) 2026-01-19 07:46:46 +01:00
slprime e036fd14a8 Correctly crop colored text (#839) 2026-01-13 15:16:09 +02:00
slprime 463f4c9b60 Fix transparency border (#838) 2026-01-13 13:06:59 +02:00
Ranzu 5070fde640 Added optional subset label localization (#836) 2026-01-06 03:02:38 +02:00
454b4f7e1d Added Transparency Border to recipe-background and catalyst-tab (#822)
Co-authored-by: Martin Robertz <[email protected]>
Co-authored-by: slprime <[email protected]>
2025-12-28 15:40:21 +01:00
7b83456f01 Add tooltip for "Required Crafts" with shift (#810)
Co-authored-by: Wilhelm Schuster <[email protected]>
Co-authored-by: Martin Robertz <[email protected]>
Co-authored-by: slprime <[email protected]>
2025-12-28 15:36:39 +02:00
PLASMAchicken 4b7b84b031 Restore NEIModContainer public plugins field (#829) 2025-12-26 19:31:41 +01:00
slprime 75309b81ec Hide Untranslator Subset when Untranslator disabled (#827) 2025-12-21 13:26:26 +02:00
slprimeandMartin Robertz 24e46bb43e Add the ability to move bookmark groups between namespaces (#803)
Co-authored-by: Martin Robertz <[email protected]>
2025-12-16 23:39:32 +02:00
Alexdoru 2ba0773401 [Memory-opti:fix leak] Fix WorldServer leak in NEIServerConfig (#815) 2025-12-16 19:44:15 +00:00
PLASMAchicken eac913c80c Remove Obsolete Code from ModContainer (#820) 2025-12-13 12:42:40 +02:00
slprime 126f0ea73c Fix missing favorites and incorrect crafting chains for recipes with identical ingredients (#814) 2025-11-25 07:24:30 +01:00
slprimeandMartin Robertz cd4668ec84 Backup bookmarks.ini if loading failed (#798)
Co-authored-by: Martin Robertz <[email protected]>
2025-11-24 08:52:01 +02:00
slprime 7c247dd0d2 Ignore space hotkeys when typing in search bar (#808) 2025-11-24 00:21:24 +02:00
slprime 87b549fab5 Normalize Fluid Packet (#811) 2025-11-16 14:17:56 +02:00
slprimeandMartin Robertz 8ed1f7a043 Properly clears inventory before filling a recipe (#796)
Co-authored-by: Martin Robertz <[email protected]>
2025-11-13 08:19:55 +02:00
slprime f2efa35654 Extend HandlerInfo.Builder interface (#809) 2025-11-08 23:54:35 +02:00
slprime bcef287e71 Fix Permutations for Information Handler (#804) 2025-11-08 09:32:47 +02:00
slprime 7f555f7a7f Add Tooltip for debug option (#805) 2025-11-08 09:27:21 +02:00
slprime 9fd38da205 Correctly collapse recipe (#807) 2025-11-08 09:18:14 +02:00
slprime 2fa5563408 Optimizing cross-dimension loading (#806) 2025-11-08 09:12:40 +02:00
slprimeandMartin Robertz 541c0e2def Add 'Bookmark recipe with count' Option (#776)
Co-authored-by: Martin Robertz <[email protected]>
2025-11-07 19:54:09 +02:00
Martin Robertz ac868097e7 update 2025-11-07 18:32:09 +01:00
slprimeandMartin Robertz 2f0de0b6a8 Add 'Show only favorites' option to the 'Craftables' panel (#800)
Co-authored-by: Martin Robertz <[email protected]>
2025-11-06 17:37:00 +02:00
sisyphussy 32bc29e654 Remove glBlitFramebuffer (#801) 2025-11-06 14:36:30 +02:00
slprimeandMartin Robertz ef8a7d8bd5 Create normalizeRecipeQueryStack (#772)
Co-authored-by: Martin Robertz <[email protected]>
2025-11-05 23:15:45 +02:00
slprimeandMartin Robertz adc5a5df16 Add GuiOverlapSlots for subpanels (#799)
Co-authored-by: Martin Robertz <[email protected]>
2025-11-05 21:55:33 +02:00
slprime a828ff227a Remove try/catch from static block (#797) 2025-11-05 19:08:55 +01:00
slprime 9b6f98330e Remove Permutations from Output (#777) 2025-11-05 19:14:48 +02:00
slprime 667c8cb5b6 Implement Dynamic Handler Height (#792) 2025-11-05 19:00:09 +02:00
slprimeandMartin Robertz a186f69444 Fix favorite state refresh (#787)
Co-authored-by: Martin Robertz <[email protected]>
2025-11-04 23:11:00 +01:00
slprime 16f4f20239 Fixed small mouse movement while double-clicking causing drop all items (#793) 2025-11-04 23:10:43 +01:00
slprime bac207cacb Change item slot size in GuiRecipe (#789) 2025-11-04 23:10:32 +01:00
slprime 630e856d83 Fix hotkeys when keyBinding disabled (#786) 2025-10-30 10:17:16 +02:00
slprime 42d96aed0c Show 'Delete Item' tooltip in Creative Mode (#785) 2025-10-29 21:47:34 +01:00
slprimeandsisyphussy bd6384bf24 Сalculate the height of the container before scrolling to the recipe (#782)
Co-authored-by: sisyphussy <[email protected]>
2025-10-29 07:52:33 +00:00
slprime af9726d356 Fixed shift+scroll of ingredients in the recipe GUI (#783) 2025-10-29 07:42:18 +00:00
Martin Robertz 1e1d2f1076 update 2025-10-29 07:54:19 +01:00
slprimeandWilhelm Schuster 7cb94fb22a Clear rawText before formatting (#780)
Co-authored-by: Wilhelm Schuster <[email protected]>
2025-10-25 15:20:28 +02:00
Martin Robertz 87aa4f9ed5 update 2025-10-25 14:18:58 +02:00
DarkShadow44andMartin Robertz 9760fd3eaf Fix another race condition, affecting IndustrialGrafter (#779)
Co-authored-by: Martin Robertz <[email protected]>
2025-10-25 14:11:49 +02:00
slprime 1054871982 Add Scroll to Recipe Catalysts (#770) 2025-10-21 12:28:14 +00:00
slprime d90a667f68 Fix Bookmarks Chain Tooltip Height (#773) 2025-10-19 21:33:46 +03:00
slprime 69e6df5848 Fix Button Texture (#771) 2025-10-19 19:56:23 +02:00
slprime 25fa7ce44e Add defaultbookmarkcontainers.cfg (#769) 2025-10-19 16:07:45 +03:00
slprime e3cd7b860d Fix recipe result count (#767) 2025-10-18 11:07:39 +00:00
slprime 2a3aabc073 Add recipe index to recipe handler height (#768) 2025-10-18 13:03:08 +02:00
slprimeandMartin Robertz 76db43c835 Optimize permutations (#761)
Co-authored-by: Martin Robertz <[email protected]>
2025-10-17 22:23:10 +03:00
slprimeandMartin Robertz 40e53eea7a Fixing HUD flickering (#762)
Co-authored-by: Martin Robertz <[email protected]>
2025-10-17 21:36:30 +03:00
Martin Robertz 6c4d16d6b9 update 2025-10-17 12:50:52 +02:00
RealSilverMoon 4a2abe9fd7 Add a function to copy item name and meta (#758) 2025-10-17 10:54:47 +03:00
sisyphussy d47417302e Fix recipe tooltip lighting (#757) 2025-10-14 17:09:02 +03:00
e13401ded8 Optimize Bookmark Chains with Containers (#751)
Co-authored-by: Martin Robertz <[email protected]>
Co-authored-by: sisyphussy <[email protected]>
2025-10-13 11:01:58 +00:00
sisyphussy 7ada842ef3 Fix tooltip item lighting (#755) 2025-10-13 00:29:09 +03:00
slprimeandMartin Robertz fe0c5d4e50 Create Recipe Widget; Recipe GUI: Infinity Scroll; Recipe GUI: Max Height Settings (#701)
Co-authored-by: Martin Robertz <[email protected]>
2025-10-12 18:39:21 +02:00
slprime 2ea9ae1eb9 Show Handler Icon in Bookmarks (#747) 2025-10-09 21:22:37 +02:00
slprime f7f0596fda Show Items Loading Message (#745) 2025-10-08 16:58:23 +02:00
sbwaz d5e919a9cd [Extended+] Fix the prefixed sequence parsing. (#741) 2025-10-04 13:19:00 +02:00
sisyphussyandMartin Robertz a0ed5da699 Speedup rendering (#740)
Co-authored-by: Martin Robertz <[email protected]>
2025-10-02 12:53:18 +02:00
Martin Robertz 99fb5a656e update 2025-10-02 12:13:08 +02:00
DarkShadow44 4b663222b1 Force tag compounds to be initialized so doesn't happen concurrently later (#730) 2025-10-02 07:15:28 +02:00
Martin Robertz 3e5d0088bc update 2025-10-01 17:21:16 +02:00
948be399d2 allow the steam furnace multiblock to show up in NEI under furnaces (#702)
Co-authored-by: Martin Robertz <[email protected]>
Co-authored-by: EnderProyects <[email protected]>
2025-09-28 13:39:45 +02:00
DarkShadow44 5f6091924d Add more logging for fuel crash (#736) 2025-09-28 01:02:47 +03:00
Dredonkey c5bd1f897a Fix pressing '2' when hovering crafting output not putting the crafted item(s) in the hotbar (#733) 2025-09-27 10:17:40 +00:00
Julia 61d4b6ab62 Revert "Replace lambda with method reference" (#735) 2025-09-27 03:09:17 -07:00
Julia 791d05d5f5 Support Inline Comments After # (#734) 2025-09-26 18:11:47 -07:00
Mike_be 66001275c4 Remove UXV and MAX biolab from NEI recipe catalysts (#732) 2025-09-26 21:40:03 +02:00
slprime db6b83c906 Try fix Fuels (#729) 2025-09-24 13:17:34 +02:00
slprime 58ef6c85e0 Fix NBT Copy (#728) 2025-09-22 20:28:05 -07:00
Martin Robertz ab0aeef872 update 2025-09-21 21:38:41 +02:00
slprime 23b7c69e2f Fix None hotkeys for java8 (#726) 2025-09-21 19:44:20 +02:00
slprime bb89384493 Fix Bookmarks Shadow Items (#724) 2025-09-18 19:07:51 +02:00
slprime e96e4dfdde Create Item Untranslator (#719) 2025-09-17 12:42:35 +00:00
slprime 0a6a6771d8 Fixed Favorite Recipes in bookmarks for ingredients (#720) 2025-09-15 19:21:52 +02:00
sbwaz c96199a727 [Extended+] Filter permutations on the left. Fail on recipe expression, when not searching a recipe. (#716) 2025-09-13 11:18:29 +02:00
azod ab4ea2cfa1 feat(moboverlay): add chat message (on/off) (#715) 2025-09-11 03:45:06 -03:00
Mike_be b679883d02 Remove old entries which resulted in ghost catalysts (#714) 2025-09-08 20:11:32 +02:00
Worive 0048ef80d0 Fix(MobSpawnOverlay): avoid IOB from checking light value from block outside of world (#711) 2025-09-07 11:03:21 +00:00
slprime 84576aa7a2 Fix Permutation Filter (#712) 2025-09-06 22:32:14 +02:00
Dream Master c5cd5b9e61 update 2025-09-05 16:08:54 +02:00
slprimeandMartin Robertz b1bedcf403 Recipe search improvement (#706)
Co-authored-by: Martin Robertz <[email protected]>
2025-09-04 15:59:51 +02:00
Matthew Bentham bba0a11466 Add missing lang key for favorite keybind (#709) 2025-09-04 13:20:53 +02:00
slprime b80948f2f2 Fix Subset Name (#705) 2025-08-31 18:34:19 +02:00
slprime 28539bbacc Fix Keyboard IndexOutOfBoundsException (#704) 2025-08-31 18:33:59 +02:00
UltraProdigy ec28bdf116 Make EFR Lingering Potion Recipes Visible in NEI (#703) 2025-08-30 09:10:05 -04:00
sbwaz e5d55a9bd8 Advanced search expressions and improved recipe search in a new pattern mode: extended+ (#692) 2025-08-24 14:35:59 +07:00
slprime c1f7489de1 Presets: Custom Subsets Mode (#671) 2025-08-22 12:22:09 +00:00
slprime fa6fd01a3a Add Option to Disable Hotkeys Tooltip (#680) 2025-08-22 12:15:23 +00:00
slprime 453ba6667f Add Favorite Hotkey (#681) 2025-08-22 19:12:42 +07:00
slprime 4e11a45852 Add the ability to create a chain of items with zero (#682) 2025-08-22 12:06:27 +00:00
slprime 95274339a0 Change panel position algorithm (#683) 2025-08-22 12:03:05 +00:00
slprime 31fcd6af51 Crate Craftables Panel (#696) 2025-08-22 11:58:41 +00:00
koolkrafter5 860bc059ca Allow shift+scrolling other stacks in recipes (#698) 2025-08-18 19:57:08 +07:00
koolkrafter5 2fc2152809 Strict Item Identify Format (#697) 2025-08-16 21:11:27 +07:00
299 changed files with 27792 additions and 7417 deletions

No files matched your search

+2 -4
View File
@@ -33,12 +33,10 @@ body:
description: What Java version are you using? It's worth mentioning that if you play on Java9+ you should try update to latest minor release (e.g. prefer Java 17.0.6 over 17.0.2) of that version. description: What Java version are you using? It's worth mentioning that if you play on Java9+ you should try update to latest minor release (e.g. prefer Java 17.0.6 over 17.0.2) of that version.
options: options:
- Java 8 - Java 8
- Java 9
- Java 11
- Java 17 - Java 17
- Java 19
- Java 20
- Java 21 - Java 21
- java 25
- java 26
- Other (Please Specify) - Other (Please Specify)
validations: validations:
required: true required: true
+2 -2
View File
@@ -3,9 +3,9 @@ name: Build and test
on: on:
pull_request: pull_request:
branches: [ master, main ] branches: [ master, main, release/** ]
push: push:
branches: [ master, main ] branches: [ master, main, release/** ]
jobs: jobs:
build-and-test: build-and-test:
+17
View File
@@ -0,0 +1,17 @@
name: Optimize images
on:
pull_request:
branches: [ master, main, release/** ]
paths:
- "**/*.png"
push:
branches: [ master, main, release/** ]
paths:
- "**/*.png"
jobs:
optimize-images:
uses: GTNewHorizons/GTNH-Actions-Workflows/.github/workflows/optimize-images.yml@master
secrets: inherit
+3 -1
View File
@@ -28,6 +28,7 @@ whitelist.json
*.iws *.iws
src/main/resources/mixins.*([!.]).json src/main/resources/mixins.*([!.]).json
*.bat *.bat
*.sh
*.DS_Store *.DS_Store
!gradlew.bat !gradlew.bat
.factorypath .factorypath
@@ -35,4 +36,5 @@ addon.local.gradle
addon.local.gradle.kts addon.local.gradle.kts
addon.late.local.gradle addon.late.local.gradle
addon.late.local.gradle.kts addon.late.local.gradle.kts
layout.json layout.json
+3 -1
View File
@@ -1,5 +1,7 @@
# NotEnoughItems Unofficial - By the GTNH Team # NotEnoughItems Unofficial - By the GTNH Team
🌐 **Languages:** [English](README.md) | [Українська](README_uk.md)
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 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
We've tested this against all of the mods included in GTNH, as well as a limited set of other mods (like Reika's mods). Every effort has been made to maintain backwards compatibility, however the focus is on the mods contained in the GTNH modpack. We've tested this against all of the mods included in GTNH, as well as a limited set of other mods (like Reika's mods). Every effort has been made to maintain backwards compatibility, however the focus is on the mods contained in the GTNH modpack.
@@ -73,7 +75,7 @@ All items that match `filter` will show your information page. See `config/NEI/c
#### Item Information Config File #### Item Information Config File
If you're a modpack creator and want to make custom item information pages, they can easily be added in `config/NEI/informationpages.cfg`, which has a few more examples. If you're a modpack creator and want to make custom item information pages, they can easily be added in `config/NEI/informationpages.cfg`, which has a few more examples. The file is not created automatically: use the Export button in the NEI options under Tools > Default Config Files to copy the defaults to `config/NEI`.
## Other items of note: ## Other items of note:
+93
View File
@@ -0,0 +1,93 @@
# NotEnoughItems Unofficial — від команди GTNH
🌐 **Мови:** [English](README.md) | [Українська](README_uk.md)
Продовження модифікації NotEnoughItems для 1.7.10 від розробників збірки GregTech: New Horizons із функціями, натхненними та/або бекпортованими з JustEnoughItems.
Ми протестували цю версію з усіма модами, що входять до GTNH, а також із обмеженим набором інших модів (як-от моди від Reika). Було докладено всіх зусиль для збереження зворотної сумісності, однак основну увагу приділено модам зі збірки GTNH.
Якщо у вас виникли проблеми з NEI за межами збірки GTNH, ви можете повідомити про них у [GitHub-репозиторії GTNH NEI](https://github.com/GTNewHorizons/NotEnoughItems).
## Нові можливості:
* Швидкодія
- Використовує паралельний потік для пошуку у списку предметів на кількох ядрах процесора, що в середньому пришвидшує пошук у 2–6 разів.
- Завантажує обробники рецептів паралельно.
* Текстове поле пошуку з більшістю очікуваних функцій — переміщення курсора вперед/назад, виділення тексту тощо.
* Закладки! Перебуваєте у процесі крафту? Додайте потрібний рецепт до закладок за допомогою клавіші «A» або налаштуйте власну клавішу.
* Перемикання видимості панелі закладок. Гаряча клавіша за замовчуванням — `B`. Меню «Підгрупи предметів» доступне лише тоді, коли панель закладок прихована.
* Кнопки утиліт та читів вирівнюються в ряд та переносяться на новий рядок залежно від розміру графічного інтерфейсу.
* Список предметів (`ItemList`) більше не генерується повторно з `ItemRegistry` під час кожного відкриття інвентарю.
* Вкладки у стилі JEI (або творчого режиму) [За бажанням]. Примітка: вимагає явної підтримки для рендерингу `ItemStack`, інакше використовуються перші дві літери назви обробника.
* Вкладки/обробники завантажуються з конфігураційного CSV-файлу в JAR-архіві (або за бажанням з папки `config`). Для авторів модів доступні IMC-повідомлення з NBT-даними `registerHandlerInfo` та `removeHandlerInfo` для додавання інформації про обробники з використанням тих самих полів, що й у CSV-файлі.
* Пошук за допомогою синтаксису `@[Мод]->[предмет]`. Наприклад: `@Mod.gregtech->iron ingot`.
* Перемикання між режимами рецептів, утиліт та читів за допомогою CTRL + ЛКМ по іконці гайкового ключа.
* Інструменти/предмети з GT5u та інструменти з GT6 тепер мають коректно працювати з функцією накладення та перенесення рецепта.
### Обробник інформаційних сторінок
Хочете додати інформацію про блок чи предмет, не створюючи для нього величезну підказку? Ви можете додати інформацію про будь-який блок чи предмет, зареєструвавши його в обробнику інформації.
Інформаційні сторінки відображаються під час пошуку рецептів або способів використання відповідного предмета. Усі відповідні предмети будуть циклічно змінюватися у верхній частині інформаційної сторінки.
Ваш мод може викликати:
```java
FMLInterModComms.sendMessage("NotEnoughItems", "addItemInfo", nbt);
```
Де `nbt` — це `NBTTagCompound`, відформатований, як описано нижче.
| Тег | Тип | Опис |
|------------------|--------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `filter` | `String` | Текстовий фільтр для визначення предметів, для яких має відображатися ця інформаційна сторінка.<br/>Можна використовувати `modname:itemname`, метадані, теги OreDictionary та регулярні вирази. Повний формат можна переглянути у `config/NEI/collapsibleitems.cfg`. |
| `page` / `pages` | `String` / `String NBTTagList` | Безпосередньо текст для відображення. Різницю між одно- та багатосторінковими повідомленнями див. нижче.<br/>Обидва формати підтримують автоматичний переклад наданих рядків. |
#### Односторінковий формат
Використовуйте текстовий тег `"page"`, якщо хочете додати лише одну сторінку інформації:
```java
NBTTagCompound tag = new NBTTagCompound();
tag.setString("filter", "minecraft:log 3");
tag.setString("page", "Exotic wood found in tropical climates.");
FMLInterModComms.sendMessage("NotEnoughItems", "addItemInfo", tag);
```
#### Багатосторінковий формат
Використовуйте тег `"pages"` як `NBTTagList` із рядків, якщо потрібно додати понад одну сторінку:
```java
NBTTagCompound tag = new NBTTagCompound();
tag.setString("filter", "minecraft:diamond_sword");
NBTTagList pages = new NBTTagList();
pages.appendTag(new NBTTagString("A powerful melee weapon."));
pages.appendTag(new NBTTagString("Can be enchanted for extra effects."));
tag.setTag("pages", pages);
FMLInterModComms.sendMessage("NotEnoughItems", "addItemInfo", tag);
```
* Кожен елемент списку — це одна сторінка.
* Сторінки з’являтимуться в NEI з кнопками для їх гортання.
#### Відповідність предметів
Усі предмети, що відповідають фільтру `filter`, відображатимуть вашу інформаційну сторінку. Повний формат фільтра див. у `config/NEI/collapsibleitems.cfg`.
#### Файл конфігурації інформації про предмети
Якщо ви творець збірки модів і хочете створити власні інформаційні сторінки для предметів, їх можна легко додати у файлі `config/NEI/informationpages.cfg`, де також наведено ще кілька прикладів.
## Інші примітки:
* Вилучено стиль TMI
* Вилучено збереження/завантаження стану інвентарю
## Ліцензія
Авторські права на модифікації від команди GTNH (c) 2019-2024 належать mitchej123 та команді GTNH.
Поширюється за ліцензією LGPL-3.0 або новішої версії — використовуйте цей код на власний розсуд, але, будь ласка, діліться з розробниками будь-якими внесеними вами змінами.
Окремі частини коду натхненні, запозичені або бекпортовані з [JEI](https://github.com/mezz/JustEnoughItems/tree/1.12) за ліцензією MIT.
Авторські права на оригінальний код (c) 2014-2015 належать mezz; код поширювався за ліцензією MIT.
+26
View File
@@ -1,3 +1,29 @@
compileJava { compileJava {
options.encoding = "UTF-8" options.encoding = "UTF-8"
} }
generateGrammarSource {
maxHeapSize = "128m"
arguments += ['-package', 'codechicken.nei.search', '-visitor', '-no-listener']
outputDirectory = file("${projectDir}/build/generated/sources/search/antlr/codechicken/nei/search/")
}
compileJava.dependsOn generateGrammarSource
sourcesJar.dependsOn generateGrammarSource
sourcesJar {
duplicatesStrategy = DuplicatesStrategy.EXCLUDE
}
sourceSets {
main {
java.srcDirs += ["build/generated/sources/search/antlr/"]
}
}
test {
useJUnitPlatform()
testLogging {
events "passed", "skipped", "failed"
}
}
+1
View File
@@ -1,5 +1,6 @@
//version: 1707058017 //version: 1707058017
plugins { plugins {
id 'antlr'
id 'com.gtnewhorizons.gtnhconvention' id 'com.gtnewhorizons.gtnhconvention'
} }
+35 -3
View File
@@ -1,10 +1,42 @@
// Add your dependencies here // Add your dependencies here
configurations.create('gtnhlibEmbed') {
canBeConsumed = false
canBeResolved = true
}
dependencies { dependencies {
api('com.github.GTNewHorizons:CodeChickenCore:1.4.7:dev') api('com.github.GTNewHorizons:CodeChickenCore:1.4.22:dev')
implementation('com.github.GTNewHorizons:GTNHLib:0.6.39:dev') devOnlyNonPublishable('com.github.GTNewHorizons:GTNHLib:0.11.54:dev')
shadowImplementation('org.apache.commons:commons-csv:1.10.0') shadowImplementation('org.apache.commons:commons-csv:1.10.0')
compileOnly 'maven.modrinth:forge-essentials:7.5.1' compileOnly('maven.modrinth:forge-essentials:7.5.1')
compileOnly('com.cardinalstar.cubicchunks:CubicChunks1710:v0.1.14-alpha:dev')
antlr('org.antlr:antlr4:4.13.2')
shadowImplementation('org.antlr:antlr4-runtime:4.13.2')
testImplementation(platform('org.junit:junit-bom:5.13.4'))
testImplementation('org.junit.jupiter:junit-jupiter')
testImplementation("org.mockito:mockito-core:5.+")
testRuntimeOnly('org.junit.platform:junit-platform-launcher')
testRuntimeOnly("org.lwjgl.lwjgl:lwjgl:2.9.3");
compileOnly("com.github.GTNewHorizons:GTNHLib:0.11.54") { transitive = false }
gtnhlibEmbed("com.github.GTNewHorizons:GTNHLib:0.11.54") { transitive = false }
}
def embedArchiveOperations = gtnhGradle.archiveOperations
def gtnhlibEmbedContents = configurations.gtnhlibEmbed.elements.map { files ->
files.collect { embedArchiveOperations.zipTree(it.asFile) }
}
[tasks.jar, tasks.shadowJar].each {
it.configure {
from(gtnhlibEmbedContents) {
include 'com/gtnewhorizon/gtnhlib/color/ColorResource.class'
include 'com/gtnewhorizon/gtnhlib/color/ColorResource$*.class'
}
}
} }
+44 -4
View File
@@ -39,9 +39,33 @@ remoteMappings = https\://raw.githubusercontent.com/MinecraftForge/FML/1.7.10/co
# `./gradlew runClient --username=AnotherPlayer`, or configuring this command in your IDE. # `./gradlew runClient --username=AnotherPlayer`, or configuring this command in your IDE.
developmentEnvironmentUserName = Developer developmentEnvironmentUserName = Developer
# Enables using modern Java syntax (up to version 17) via Jabel, while still targeting JVM 8. # Enables modern Java syntax support. Valid values:
# See https://github.com/bsideup/jabel for details on how this works. # - false: No modern syntax, Java 8 only
enableModernJavaSyntax = true # - jabel: Jabel syntax-only support, compiles to J8 bytecode
# - jvmDowngrader: Full modern Java via JVM Downgrader (syntax + stdlib APIs)
# - modern: Native modern Java bytecode, no downgrading
enableModernJavaSyntax = jabel
# If set, ignores the above setting and compiles with the given toolchain. This may cause unexpected issues,
# and should *not* be used in most situations. -1 disables this.
# forceToolchainVersion = -1
# Target JVM version for JVM Downgrader bytecode downgrading.
# Only used when enableModernJavaSyntax = jvmDowngrader
# downgradeTargetVersion = 8
# Comma-separated list of Java versions for multi-release jar support (JVM Downgrader only).
# Classes will be available in META-INF/versions/N/ for each version N in this list.
# Default: "21,25" (J25+ gets native classes, J21-24 gets partial downgrade, J8-20 gets full downgrade).
# jvmDowngraderMultiReleaseVersions = 21,25
# Specifies how JVM Downgrader API stubs are provided. Options:
# - shade: Shade minimized stubs into the jar
# - gtnhlib: GTNHLib provides stubs at runtime (adds version constraint)
# - external: Another dependency provides stubs (no constraint, no warning)
# - (empty): Warning reminding you to configure stubs
# Note: 'shade' option requires you to verify license compliance, see: https://github.com/unimined/JvmDowngrader/blob/main/LICENSE.md
# jvmDowngraderStubsProvider =
# Enables injecting missing generics into the decompiled source code for a better coding experience. # Enables injecting missing generics into the decompiled source code for a better coding experience.
# Turns most publicly visible List, Map, etc. into proper List<E>, Map<K, V> types. # Turns most publicly visible List, Map, etc. into proper List<E>, Map<K, V> types.
@@ -96,7 +120,9 @@ usesMixinDebug = false
# Specify the location of your implementation of IMixinConfigPlugin. Leave it empty otherwise. # Specify the location of your implementation of IMixinConfigPlugin. Leave it empty otherwise.
mixinPlugin = mixinPlugin =
# Specify the package that contains all of your Mixins. You may only place Mixins in this package or the build will fail! # Specify the package that contains all of your Mixins. The package must exist or
# the build will fail. If you have a package property defined in your mixins.<modid>.json,
# it must match with this or the build will fail.
mixinsPackage = mixinsPackage =
# Specify the core mod entry class if you use a core mod. This class must implement IFMLLoadingPlugin! # Specify the core mod entry class if you use a core mod. This class must implement IFMLLoadingPlugin!
@@ -160,6 +186,11 @@ modrinthRelations = required-project\:codechickencore-unofficial
# Leave this empty if you don't want to publish on CurseForge. # Leave this empty if you don't want to publish on CurseForge.
curseForgeProjectId = 358228 curseForgeProjectId = 358228
# Comma-separated supported CurseForge environments: client, server (case-insensitive).
# Use client or server for mods that only support one environment. Defaults to client,server.
# These tags describe where the mod can run, not whether installation is required on both sides.
curseForgeEnvironments = client,server
# The project's relations on CurseForge. You can use this to refer to other projects on CurseForge. # The project's relations on CurseForge. You can use this to refer to other projects on CurseForge.
# Syntax: type1:name1;type2:name2;... # Syntax: type1:name1;type2:name2;...
# Where type can be one of [requiredDependency, embeddedLibrary, optionalDependency, tool, incompatible], # Where type can be one of [requiredDependency, embeddedLibrary, optionalDependency, tool, incompatible],
@@ -172,6 +203,12 @@ curseForgeRelations = requiredDependency\:codechickencore-unofficial
# projects. New projects should not use this parameter. # projects. New projects should not use this parameter.
# customArchiveBaseName = # customArchiveBaseName =
# Optional parameter to customize the default working directory used by the runClient* tasks. Relative to the project directory.
# runClientWorkingDirectory = run/client
# Optional parameter to customize the default working directory used by the runServer* tasks. Relative to the project directory.
# runServerWorkingDirectory = run/server
# Optional parameter to have the build automatically fail if an illegal version is used. # Optional parameter to have the build automatically fail if an illegal version is used.
# This can be useful if you e.g. only want to allow versions in the form of '1.1.xxx'. # This can be useful if you e.g. only want to allow versions in the form of '1.1.xxx'.
# The check is ONLY performed if the version is a git tag. # The check is ONLY performed if the version is a git tag.
@@ -201,3 +238,6 @@ curseForgeRelations = requiredDependency\:codechickencore-unofficial
# This is meant to be set in $HOME/.gradle/gradle.properties. # This is meant to be set in $HOME/.gradle/gradle.properties.
# ideaCheckSpotlessOnBuild = true # ideaCheckSpotlessOnBuild = true
# Non-GTNH properties
org.gradle.configuration-cache = true
org.gradle.parallel = true
+12
View File
@@ -0,0 +1,12 @@
#This file is generated by updateDaemonJvm
toolchainUrl.FREE_BSD.AARCH64=https\://api.foojay.io/disco/v3.0/ids/539ea72837c6244075f8ee037babc29e/redirect
toolchainUrl.FREE_BSD.X86_64=https\://api.foojay.io/disco/v3.0/ids/876dbbf00bf4ef6190f7da074cee903a/redirect
toolchainUrl.LINUX.AARCH64=https\://api.foojay.io/disco/v3.0/ids/539ea72837c6244075f8ee037babc29e/redirect
toolchainUrl.LINUX.X86_64=https\://api.foojay.io/disco/v3.0/ids/876dbbf00bf4ef6190f7da074cee903a/redirect
toolchainUrl.MAC_OS.AARCH64=https\://api.foojay.io/disco/v3.0/ids/9064f22734b42ac03e85df04b632e167/redirect
toolchainUrl.MAC_OS.X86_64=https\://api.foojay.io/disco/v3.0/ids/4d0277c49991306ac78048580fe34bcf/redirect
toolchainUrl.UNIX.AARCH64=https\://api.foojay.io/disco/v3.0/ids/539ea72837c6244075f8ee037babc29e/redirect
toolchainUrl.UNIX.X86_64=https\://api.foojay.io/disco/v3.0/ids/876dbbf00bf4ef6190f7da074cee903a/redirect
toolchainUrl.WINDOWS.AARCH64=https\://api.foojay.io/disco/v3.0/ids/a9fa3b809e484a1e1ac4308a5dda661a/redirect
toolchainUrl.WINDOWS.X86_64=https\://api.foojay.io/disco/v3.0/ids/aa99913fa6d767d899ffc96082da01ca/redirect
toolchainVersion=25
Binary file not shown.
+3 -1
View File
@@ -1,7 +1,9 @@
distributionBase=GRADLE_USER_HOME distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists distributionPath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-8.13-bin.zip distributionUrl=https\://services.gradle.org/distributions/gradle-9.7.1-bin.zip
networkTimeout=10000 networkTimeout=10000
retries=0
retryBackOffMs=500
validateDistributionUrl=true validateDistributionUrl=true
zipStoreBase=GRADLE_USER_HOME zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists zipStorePath=wrapper/dists
Vendored
+5 -8
View File
@@ -1,7 +1,7 @@
#!/bin/sh #!/bin/sh
# #
# Copyright © 2015-2021 the original authors. # Copyright © 2015 the original authors.
# #
# Licensed under the Apache License, Version 2.0 (the "License"); # Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License. # you may not use this file except in compliance with the License.
@@ -20,7 +20,7 @@
############################################################################## ##############################################################################
# #
# Gradle start up script for POSIX generated by Gradle. # gradlew start up script for POSIX generated by Gradle.
# #
# Important for running: # Important for running:
# #
@@ -29,7 +29,7 @@
# bash, then to run this script, type that shell name before the whole # bash, then to run this script, type that shell name before the whole
# command line, like: # command line, like:
# #
# ksh Gradle # ksh gradlew
# #
# Busybox and similar reduced shells will NOT work, because this script # Busybox and similar reduced shells will NOT work, because this script
# requires all of these POSIX shell features: # requires all of these POSIX shell features:
@@ -57,7 +57,7 @@
# Darwin, MinGW, and NonStop. # Darwin, MinGW, and NonStop.
# #
# (3) This script is generated from the Groovy template # (3) This script is generated from the Groovy template
# https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt # https://github.com/gradle/gradle/blob/3d91ce3b8caaf77ad09f381f43615b715b53f72c/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
# within the Gradle project. # within the Gradle project.
# #
# You can find Gradle at https://github.com/gradle/gradle/. # You can find Gradle at https://github.com/gradle/gradle/.
@@ -114,7 +114,6 @@ case "$( uname )" in #(
NONSTOP* ) nonstop=true ;; NONSTOP* ) nonstop=true ;;
esac esac
CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
# Determine the Java command to use to start the JVM. # Determine the Java command to use to start the JVM.
@@ -172,7 +171,6 @@ fi
# For Cygwin or MSYS, switch paths to Windows format before running java # For Cygwin or MSYS, switch paths to Windows format before running java
if "$cygwin" || "$msys" ; then if "$cygwin" || "$msys" ; then
APP_HOME=$( cygpath --path --mixed "$APP_HOME" ) APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
JAVACMD=$( cygpath --unix "$JAVACMD" ) JAVACMD=$( cygpath --unix "$JAVACMD" )
@@ -212,8 +210,7 @@ DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
set -- \ set -- \
"-Dorg.gradle.appname=$APP_BASE_NAME" \ "-Dorg.gradle.appname=$APP_BASE_NAME" \
-classpath "$CLASSPATH" \ -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
org.gradle.wrapper.GradleWrapperMain \
"$@" "$@"
# Stop when "xargs" is not available. # Stop when "xargs" is not available.
Vendored
+12 -24
View File
@@ -19,12 +19,12 @@
@if "%DEBUG%"=="" @echo off @if "%DEBUG%"=="" @echo off
@rem ########################################################################## @rem ##########################################################################
@rem @rem
@rem Gradle startup script for Windows @rem gradlew startup script for Windows
@rem @rem
@rem ########################################################################## @rem ##########################################################################
@rem Set local scope for the variables with windows NT shell @rem Set local scope for the variables, and ensure extensions are enabled
if "%OS%"=="Windows_NT" setlocal setlocal EnableExtensions
set DIRNAME=%~dp0 set DIRNAME=%~dp0
if "%DIRNAME%"=="" set DIRNAME=. if "%DIRNAME%"=="" set DIRNAME=.
@@ -51,7 +51,7 @@ echo. 1>&2
echo Please set the JAVA_HOME variable in your environment to match the 1>&2 echo Please set the JAVA_HOME variable in your environment to match the 1>&2
echo location of your Java installation. 1>&2 echo location of your Java installation. 1>&2
goto fail "%COMSPEC%" /c exit 1
:findJavaFromJavaHome :findJavaFromJavaHome
set JAVA_HOME=%JAVA_HOME:"=% set JAVA_HOME=%JAVA_HOME:"=%
@@ -65,30 +65,18 @@ echo. 1>&2
echo Please set the JAVA_HOME variable in your environment to match the 1>&2 echo Please set the JAVA_HOME variable in your environment to match the 1>&2
echo location of your Java installation. 1>&2 echo location of your Java installation. 1>&2
goto fail "%COMSPEC%" /c exit 1
:execute :execute
@rem Setup the command line @rem Setup the command line
set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
@rem Execute Gradle @rem Execute gradlew
"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %* @rem endlocal doesn't take effect until after the line is parsed and variables are expanded
@rem which allows us to clear the local environment before executing the java command
endlocal & "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %* & call :exitWithErrorLevel
:end :exitWithErrorLevel
@rem End local scope for the variables with windows NT shell @rem Use "%COMSPEC%" /c exit to allow operators to work properly in scripts
if %ERRORLEVEL% equ 0 goto mainEnd "%COMSPEC%" /c exit %ERRORLEVEL%
:fail
rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
rem the _cmd.exe /c_ return code!
set EXIT_CODE=%ERRORLEVEL%
if %EXIT_CODE% equ 0 set EXIT_CODE=1
if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
exit /b %EXIT_CODE%
:mainEnd
if "%OS%"=="Windows_NT" endlocal
:omega
+1 -1
View File
@@ -1,4 +1,4 @@
// Add any additional repositiroes for your dependencies here // Add any additional repositories for your dependencies here
repositories { repositories {
maven { maven {
+1 -1
View File
@@ -17,7 +17,7 @@ pluginManagement {
} }
plugins { plugins {
id 'com.gtnewhorizons.gtnhsettingsconvention' version '1.0.41' id 'com.gtnewhorizons.gtnhsettingsconvention' version '2.0.34'
} }
+48
View File
@@ -0,0 +1,48 @@
lexer grammar SearchExpressionLexer;
// Antlr4 generates imports with .*
@header {
// CHECKSTYLE:OFF
import codechicken.nei.SearchTokenParser;
}
@members {
private SearchTokenParser searchParser;
public SearchExpressionLexer(CharStream input, SearchTokenParser searchParser) {
this(input);
this.searchParser = searchParser;
}
}
// Lexer rules
REGEX_LEFT : 'r'? '/' -> pushMode(REGEX) ;
QUOTE_LEFT : '"' -> pushMode(QUOTED) ;
DASH : '-' ;
RECIPE_INGREDIENTS : '<&' | '<' ;
RECIPE_RESULT : '>&' | '>' ;
RECIPE_OTHERS : '^&' | '^' ;
RECIPE_TEXT : '~' ;
OR : '|' ;
LEFT_BRACKET : '{' ;
RIGHT_BRACKET : '}' ;
NEWLINE_OR_TAB : [\t\r\n] -> skip ;
SPACE : ' ' ;
ESCAPED_SYMBOL : '\\' . ;
PREFIX : CLEAN_SYMBOL {searchParser.hasRedefinedPrefix(getText().charAt(0))}? ;
CLEAN_SYMBOL : ~[-<>^~{}|/\\ "] ;
mode REGEX;
REGEX_CONTENT : (~[/] | '\\/')+ ;
REGEX_RIGHT : '/' -> popMode ;
mode QUOTED;
QUOTED_CONTENT : (~["] | '\\"')+ ;
QUOTE_RIGHT : '"' -> popMode ;
+74
View File
@@ -0,0 +1,74 @@
parser grammar SearchExpressionParser;
// Antlr4 generates imports with .*
@header {
// CHECKSTYLE:OFF
}
options { tokenVocab=SearchExpressionLexer; }
// Parser rules
// Should only be used for recipes. Thanks to antlr inability to properly
// inherit grammars, this is included where it's not supposed to be
recipeSearchExpression
: recipeClauseExpression*
;
recipeClauseExpression
: ingredientsPrefix=RECIPE_INGREDIENTS searchExpression[0, $ingredientsPrefix.getText().length() > 1]
| resultPrefix=RECIPE_RESULT searchExpression[1, $resultPrefix.getText().length() > 1]
| othersPrefix=RECIPE_OTHERS searchExpression[2, $othersPrefix.getText().length() > 1]
| RECIPE_TEXT searchExpression[4, false]
| searchExpression[3, false]
;
// General search expression rules
searchExpression[int type, boolean allRecipe]
: orExpression
;
orExpression
: sequenceExpression (OR sequenceExpression)*
;
sequenceExpression
: (SPACE* unaryExpression SPACE*)+
;
unaryExpression
: LEFT_BRACKET orExpression RIGHT_BRACKET?
| prefixedExpression
| negateExpression
| token['\0']
;
negateExpression
: DASH unaryExpression
;
prefixedExpression
locals [
Character prefix
]
: prefixToken=PREFIX { $prefix = $prefixToken.getText().charAt(0); } token[$prefix]
;
token[Character prefix]
: regex[prefix]
| quoted[prefix]
| plainText
;
regex[Character prefix]
: REGEX_LEFT REGEX_CONTENT REGEX_RIGHT?
;
quoted[Character prefix]
: QUOTE_LEFT QUOTED_CONTENT QUOTE_RIGHT?
;
plainText
: (CLEAN_SYMBOL | ESCAPED_SYMBOL)+
;
@@ -0,0 +1,151 @@
package codechicken.nei;
import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.item.ItemStack;
import org.lwjgl.opengl.GL11;
import codechicken.lib.vec.Rectangle4i;
import codechicken.nei.ItemsGrid.ItemsGridSlot;
import codechicken.nei.api.GuiInfo;
import codechicken.nei.api.INEIGuiHandler;
import codechicken.nei.api.ShortcutInputHandler;
import codechicken.nei.drawable.DrawableBuilder;
import codechicken.nei.drawable.DrawableResource;
import codechicken.nei.guihook.IContainerTooltipHandler;
import codechicken.nei.recipe.GuiRecipe;
public abstract class AbstractSubpanel<T extends ItemsGrid<? extends ItemsGridSlot, ? extends ItemsGrid.MouseContext>>
extends Widget implements IContainerTooltipHandler {
final DrawableResource DASH = new DrawableBuilder("nei:textures/dash.png", 0, 0, 6, 1).setTextureSize(6, 1).build();
protected int mouseDownItemIndex = -1;
protected int splittingLineColor = 0xffffffff;
protected int linePaddingStart = 0;
protected T grid;
public boolean isEmpty() {
return this.grid.isEmpty();
}
public void draw(int mousex, int mousey) {
drawSplittingLine();
this.grid.draw(mousex, mousey);
}
public void update() {
this.grid.update();
}
public abstract int setPanelWidth(int width);
public void resize(GuiContainer gui) {
this.grid.setGridSize(x, y + 4, w, h - 8);
this.grid.refresh(gui);
}
@Override
public ItemStack getStackMouseOver(int mousex, int mousey) {
final ItemsGridSlot slot = getSlotMouseOver(mousex, mousey);
return slot == null ? null : slot.getItemStack();
}
public ItemsGridSlot getSlotMouseOver(int mousex, int mousey) {
return this.grid.getSlotMouseOver(mousex, mousey);
}
protected void updateLinePadding() {
final GuiContainer guiContainer = NEIClientUtils.getGuiContainer();
final INEIGuiHandler[] handlers = GuiInfo.getGuiHandlersSnapshot();
final Rectangle4i rect = new Rectangle4i(this.x, this.y - 1, 10, 2);
this.linePaddingStart = 0;
while (this.linePaddingStart < this.w && GuiInfo.hideItemPanelSlot(guiContainer, rect, handlers)) {
this.linePaddingStart += 10;
rect.x += 10;
}
}
protected void drawSplittingLine() {
float alpha = (this.splittingLineColor >> 24 & 255) / 255.0F;
float red = (this.splittingLineColor >> 16 & 255) / 255.0F;
float green = (this.splittingLineColor >> 8 & 255) / 255.0F;
float blue = (this.splittingLineColor & 255) / 255.0F;
int width = this.grid.columns * ItemsGrid.SLOT_SIZE - this.linePaddingStart;
int repeat = width / 6;
int shiftX = this.x + this.linePaddingStart + (this.w - width) / 2;
GL11.glColor4f(red, green, blue, alpha);
for (int i = 0; i < repeat; i++) {
DASH.draw(shiftX + i * 6, this.y);
}
GL11.glColor4f(1, 1, 1, 1);
}
@Override
public void mouseDragged(int mousex, int mousey, int button, long heldTime) {
if (this.mouseDownItemIndex >= 0 && ItemPanels.itemPanel.draggedStack == null
&& NEIClientUtils.getHeldItem() == null
&& NEIClientConfig.hasSMPCounterPart()) {
final ItemsGridSlot mouseOverSlot = getSlotMouseOver(mousex, mousey);
if (mouseOverSlot == null || mouseOverSlot.itemIndex != this.mouseDownItemIndex || heldTime > 500) {
ItemPanels.itemPanel.draggedStack = getDraggedStackWithQuantity(
this.grid.getItem(this.mouseDownItemIndex));
this.mouseDownItemIndex = -1;
}
}
}
@Override
public boolean handleClick(int mousex, int mousey, int button) {
if (handleClickExt(mousex, mousey, button)) return true;
final ItemsGridSlot hoverSlot = this.grid.getSlotMouseOver(mousex, mousey);
if (hoverSlot != null) {
if (button == 2) {
ItemPanels.itemPanel.draggedStack = getDraggedStackWithQuantity(hoverSlot.getItemStack());
} else {
mouseDownItemIndex = hoverSlot.itemIndex;
}
return true;
}
return false;
}
protected abstract ItemStack getDraggedStackWithQuantity(ItemStack itemStack);
public ItemStack getStackMouseOverWithQuantity(int mousex, int mousey) {
final ItemStack hoverSlot = getStackMouseOver(mousex, mousey);
return hoverSlot != null ? getDraggedStackWithQuantity(hoverSlot) : null;
}
@Override
public void mouseUp(int mousex, int mousey, int button) {
final ItemsGridSlot hoverSlot = getSlotMouseOver(mousex, mousey);
if (hoverSlot != null && hoverSlot.itemIndex == this.mouseDownItemIndex
&& ItemPanels.itemPanel.draggedStack == null) {
if (NEIController.manager.window instanceof GuiRecipe || NEIClientUtils.shiftKey()
|| !NEIClientConfig.canCheatItem(hoverSlot.getItemStack())) {
ShortcutInputHandler.handleMouseClick(hoverSlot.getItemStack().copy());
} else {
NEIClientUtils.cheatItem(getDraggedStackWithQuantity(hoverSlot.getItemStack()), button, -1);
}
}
this.mouseDownItemIndex = -1;
}
}
@@ -7,8 +7,10 @@ import java.util.ArrayList;
import java.util.List; import java.util.List;
import net.minecraft.client.Minecraft; import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.GuiTextField;
import net.minecraft.client.gui.inventory.GuiContainer; import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.client.settings.GameSettings; import net.minecraft.client.settings.GameSettings;
import net.minecraft.util.ChatAllowedCharacters;
import org.lwjgl.input.Keyboard; import org.lwjgl.input.Keyboard;
@@ -30,6 +32,8 @@ public class AutoFocusWidget implements IContainerInputHandler {
protected boolean autofocus = false; protected boolean autofocus = false;
protected Point mouse; protected Point mouse;
protected Point pendingMouse;
protected GuiTextField textInputHolder;
public AutoFocusWidget() { public AutoFocusWidget() {
GuiContainerManager.addInputHandler(this); GuiContainerManager.addInputHandler(this);
@@ -38,32 +42,83 @@ public class AutoFocusWidget implements IContainerInputHandler {
public void load(GuiContainer gui) { public void load(GuiContainer gui) {
this.autofocus = LayoutManager.searchField.isVisible() && NEIClientConfig.searchWidgetAutofocus() != 0 this.autofocus = LayoutManager.searchField.isVisible() && NEIClientConfig.searchWidgetAutofocus() != 0
&& isAllowedGuiAutoSearchFocus(gui); && isAllowedGuiAutoSearchFocus(gui);
this.mouse = getMousePosition(); this.mouse = null;
this.pendingMouse = null;
if (this.autofocus) {
beginTextInput();
}
}
protected void beginTextInput() {
if (this.textInputHolder == null) {
this.textInputHolder = new GuiTextField(Minecraft.getMinecraft().fontRenderer, 0, 0, 0, 0);
}
this.textInputHolder.setFocused(true);
}
protected void endTextInput() {
if (this.textInputHolder != null) {
this.textInputHolder.setFocused(false);
}
}
public void guiTick() {
if (!this.autofocus) {
return;
}
final Point current = getMousePosition();
if (this.mouse == null) {
if (current.equals(this.pendingMouse)) {
this.mouse = current;
}
this.pendingMouse = current;
} else if (!this.mouse.equals(current)) {
cancel();
}
}
protected void cancel() {
if (this.autofocus) {
this.autofocus = false;
endTextInput();
}
} }
@Override @Override
public boolean keyTyped(GuiContainer gui, char keyChar, int keyCode) { public boolean keyTyped(GuiContainer gui, char keyChar, int keyCode) {
if (this.autofocus) { if (this.autofocus) {
this.autofocus = false;
if (!this.mouse.equals(getMousePosition())) {
return false;
}
if (NEIClientConfig.searchWidgetAutofocus() == 2 if (NEIClientConfig.searchWidgetAutofocus() == 2
&& GameSettings.isKeyDown(Minecraft.getMinecraft().gameSettings.keyBindInventory)) { && GameSettings.isKeyDown(Minecraft.getMinecraft().gameSettings.keyBindInventory)) {
cancel();
return false; return false;
} }
if (keyCode == Keyboard.KEY_RETURN || keyCode == Keyboard.KEY_NUMPADENTER if (keyCode == Keyboard.KEY_RETURN || keyCode == Keyboard.KEY_NUMPADENTER
|| keyCode == Keyboard.KEY_ESCAPE) { || keyCode == Keyboard.KEY_ESCAPE) {
cancel();
return false; return false;
} }
if (!ChatAllowedCharacters.isAllowedCharacter(keyChar)) {
return false;
}
this.autofocus = false;
LayoutManager.searchField.setFocus(true); LayoutManager.searchField.setFocus(true);
endTextInput();
final String oldText = LayoutManager.searchField.text();
LayoutManager.searchField.handleKeyPress(keyCode, keyChar); LayoutManager.searchField.handleKeyPress(keyCode, keyChar);
return true;
return !LayoutManager.searchField.text().equals(oldText);
} }
return false; return false;
@@ -76,13 +131,13 @@ public class AutoFocusWidget implements IContainerInputHandler {
@Override @Override
public boolean mouseClicked(GuiContainer gui, int mousex, int mousey, int button) { public boolean mouseClicked(GuiContainer gui, int mousex, int mousey, int button) {
this.autofocus = false; cancel();
return false; return false;
} }
@Override @Override
public boolean mouseScrolled(GuiContainer gui, int mousex, int mousey, int scrolled) { public boolean mouseScrolled(GuiContainer gui, int mousex, int mousey, int scrolled) {
this.autofocus = false; cancel();
return false; return false;
} }
@@ -91,22 +146,22 @@ public class AutoFocusWidget implements IContainerInputHandler {
@Override @Override
public void onMouseClicked(GuiContainer gui, int mousex, int mousey, int button) { public void onMouseClicked(GuiContainer gui, int mousex, int mousey, int button) {
this.autofocus = false; cancel();
} }
@Override @Override
public void onMouseDragged(GuiContainer gui, int mousex, int mousey, int button, long heldTime) { public void onMouseDragged(GuiContainer gui, int mousex, int mousey, int button, long heldTime) {
this.autofocus = false; cancel();
} }
@Override @Override
public void onMouseScrolled(GuiContainer gui, int mousex, int mousey, int scrolled) { public void onMouseScrolled(GuiContainer gui, int mousex, int mousey, int scrolled) {
this.autofocus = false; cancel();
} }
@Override @Override
public void onMouseUp(GuiContainer gui, int mousex, int mousey, int button) { public void onMouseUp(GuiContainer gui, int mousex, int mousey, int button) {
this.autofocus = false; cancel();
} }
protected boolean isAllowedGuiAutoSearchFocus(GuiContainer gui) { protected boolean isAllowedGuiAutoSearchFocus(GuiContainer gui) {
+155 -86
View File
@@ -19,6 +19,7 @@ import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.entity.player.InventoryPlayer; import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.item.ItemStack; import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound; import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.EnumChatFormatting;
import org.apache.commons.io.IOUtils; import org.apache.commons.io.IOUtils;
@@ -29,6 +30,7 @@ import codechicken.nei.api.IBookmarkContainerHandler;
import codechicken.nei.bookmark.BookmarkGrid; import codechicken.nei.bookmark.BookmarkGrid;
import codechicken.nei.bookmark.BookmarkGroup; import codechicken.nei.bookmark.BookmarkGroup;
import codechicken.nei.bookmark.BookmarkItem; import codechicken.nei.bookmark.BookmarkItem;
import codechicken.nei.bookmark.BookmarkItem.BookmarkItemType;
import codechicken.nei.bookmark.BookmarkStorage; import codechicken.nei.bookmark.BookmarkStorage;
import codechicken.nei.bookmark.BookmarksGridSlot; import codechicken.nei.bookmark.BookmarksGridSlot;
import codechicken.nei.bookmark.GroupingItem; import codechicken.nei.bookmark.GroupingItem;
@@ -183,35 +185,46 @@ public class BookmarkPanel extends PanelWidget<BookmarkGrid> {
if (itemStack != null && this.grid.indexOf(groupId, itemStack, recipeId, false) == -1) { if (itemStack != null && this.grid.indexOf(groupId, itemStack, recipeId, false) == -1) {
final boolean existsRecipe = recipeId != null final boolean existsRecipe = recipeId != null
&& this.grid.existsRecipe(recipeId, BookmarkGrid.DEFAULT_GROUP_ID); && this.grid.existsRecipe(recipeId, BookmarkGrid.DEFAULT_GROUP_ID);
final NBTTagCompound nbTag = StackInfo.itemStackToNBT(itemStack); final Recipe recipe = Recipe.of(recipeId);
long factor = nbTag.getInteger("Count"); final BookmarkItem.Builder builder;
if (recipe != null) {
builder = BookmarkItem.builder(groupId, itemStack, recipe, BookmarkItemType.RESULT).multiplier(1);
} else if (recipeId != null) {
builder = BookmarkItem.builder(groupId, itemStack).recipeId(recipeId)
.factor(StackInfo.getAmount(itemStack)).multiplier(1);
} else {
builder = BookmarkItem.builder(groupId, itemStack).factor(1).multiplier(StackInfo.getAmount(itemStack));
}
if (existsRecipe) { if (existsRecipe) {
builder.type(BookmarkItemType.RESULT);
for (int i = 0; i < this.grid.size(); i++) { for (int i = 0; i < this.grid.size(); i++) {
if (this.grid.getBookmarkItem(i).equalsRecipe(recipeId, groupId)) { if (this.grid.getBookmarkItem(i).equalsRecipe(recipeId, groupId)) {
final long multiplier = this.grid.getBookmarkItem(i).getMultiplier(); builder.multiplier(this.grid.getBookmarkItem(i).getMultiplier());
factor *= multiplier;
break; break;
} }
} }
} else { } else {
factor = nbTag.hasKey("gtFluidName") ? Math.min(144, nbTag.getInteger("Count")) : 1; builder.type(BookmarkItemType.ITEM);
} }
this.grid.addItem(BookmarkItem.of(groupId, itemStack, factor, recipeId, false), true); this.grid.addItem(builder.build(), true);
return true; return true;
} }
return false; return false;
} }
public boolean addRecipe(Recipe recipe, int groupId) { public boolean addRecipe(Recipe recipe, int multiplier, int groupId) {
if (recipe == null) return false;
final RecipeId recipeId = recipe.getRecipeId(); final RecipeId recipeId = recipe.getRecipeId();
if (recipe != null && this.grid.getGroup(groupId) != null && !this.grid.existsRecipe(recipeId, groupId)) { if (this.grid.getGroup(groupId) != null && !this.grid.existsRecipe(recipeId, groupId)) {
this.grid.addRecipe(recipe, groupId); this.grid.addRecipe(recipe, multiplier, groupId);
return true; return true;
} }
@@ -234,21 +247,29 @@ public class BookmarkPanel extends PanelWidget<BookmarkGrid> {
if (item instanceof Recipe recipe) { if (item instanceof Recipe recipe) {
if (uniqueRecipe.add(recipe.getRecipeId())) { if (uniqueRecipe.add(recipe.getRecipeId())) {
this.grid.addRecipe(recipe, groupId); this.grid.addRecipe(recipe, 1, groupId);
} }
} else if (item instanceof RecipeId recipeId) { } else if (item instanceof RecipeId recipeId) {
ItemStack stack = recipeId.getResult(); ItemStack stack = recipeId.getResult();
if (stack != null && uniqueRecipe.add(recipeId)) { if (stack != null && uniqueRecipe.add(recipeId)) {
this.grid.addItem( final Recipe recipe = Recipe.of(recipeId);
BookmarkItem.of(groupId, stack, StackInfo.getAmount(stack), recipeId, false), final BookmarkItem.Builder builder;
true);
if (recipe != null) {
builder = BookmarkItem.builder(groupId, stack, recipe, BookmarkItemType.RESULT);
} else {
builder = BookmarkItem.builder(groupId, stack).recipeId(recipeId)
.factor(StackInfo.getAmount(stack));
}
this.grid.addItem(builder.multiplier(1).type(BookmarkItemType.ITEM).build(), true);
uniqueStack.add(stack); uniqueStack.add(stack);
} }
} else { } else {
ItemStack stack = extractItem(item); final ItemStack stack = extractItem(item);
if (stack != null && !uniqueStack.contains(stack)) { if (stack != null && !uniqueStack.contains(stack)) {
this.grid.addItem(BookmarkItem.of(groupId, stack), true); this.grid.addItem(BookmarkItem.of(groupId, stack), true);
@@ -302,21 +323,23 @@ public class BookmarkPanel extends PanelWidget<BookmarkGrid> {
} }
final int groupId = slot.getGroupId(); final int groupId = slot.getGroupId();
final RecipeId recipeId = slot.getRecipeId(); final RecipeId recipeId = slot.getType() == BookmarkItemType.ITEM ? null : slot.getRecipeId();
final BookmarkGroup group = slot.getGroup(); final BookmarkGroup group = slot.getGroup();
if (recipeId == null || !removeFullRecipe) { if (group.crafting != null && group.collapsed) {
this.grid.removeRecipe(slot.itemIndex, removeFullRecipe);
if (!removeFullRecipe) {
return true;
}
this.grid.removeGroup(groupId);
return true; return true;
} }
if (group.crafting != null && group.collapsed && removeFullRecipe) { if (recipeId != null && group.crafting != null) {
this.grid.removeGroup(groupId);
return true;
} else if (group.crafting != null) {
Set<RecipeId> recipes = group.crafting.recipeRelations.getOrDefault(recipeId, Collections.emptySet()); Set<RecipeId> recipes = group.crafting.recipeRelations.getOrDefault(recipeId, Collections.emptySet());
if (removeFullRecipe && recipes.isEmpty()) { if (recipes.isEmpty()) {
for (Map.Entry<RecipeId, Set<RecipeId>> entry : group.crafting.recipeRelations.entrySet()) { for (Map.Entry<RecipeId, Set<RecipeId>> entry : group.crafting.recipeRelations.entrySet()) {
if (entry.getValue().contains(recipeId)) { if (entry.getValue().contains(recipeId)) {
recipes = entry.getValue(); recipes = entry.getValue();
@@ -326,8 +349,12 @@ public class BookmarkPanel extends PanelWidget<BookmarkGrid> {
} }
if (!recipes.isEmpty()) { if (!recipes.isEmpty()) {
boolean removed = false;
if (!removeFullRecipe) {
return true;
}
boolean removed = false;
for (RecipeId relRecipeId : recipes) { for (RecipeId relRecipeId : recipes) {
removed = this.grid.removeRecipe(relRecipeId, groupId) || removed; removed = this.grid.removeRecipe(relRecipeId, groupId) || removed;
} }
@@ -336,6 +363,11 @@ public class BookmarkPanel extends PanelWidget<BookmarkGrid> {
} }
} }
if (recipeId == null || !removeFullRecipe) {
this.grid.removeRecipe(slot.itemIndex, removeFullRecipe);
return true;
}
return this.grid.removeRecipe(recipeId, groupId); return this.grid.removeRecipe(recipeId, groupId);
} }
@@ -355,7 +387,7 @@ public class BookmarkPanel extends PanelWidget<BookmarkGrid> {
public RecipeId getRecipeId(int itemIndex) { public RecipeId getRecipeId(int itemIndex) {
BookmarkItem meta = this.grid.getCalculatedItem(itemIndex); BookmarkItem meta = this.grid.getCalculatedItem(itemIndex);
return meta.isIngredient ? null : meta.recipeId; return meta.type == BookmarkItemType.INGREDIENT ? null : meta.recipeId;
} }
public boolean existsRecipe(RecipeId recipeId, int groupId) { public boolean existsRecipe(RecipeId recipeId, int groupId) {
@@ -435,7 +467,7 @@ public class BookmarkPanel extends PanelWidget<BookmarkGrid> {
protected int resizeHeader(GuiContainer gui) { protected int resizeHeader(GuiContainer gui) {
final LayoutStyleMinecraft layout = (LayoutStyleMinecraft) LayoutManager.getLayoutStyle(); final LayoutStyleMinecraft layout = (LayoutStyleMinecraft) LayoutManager.getLayoutStyle();
final int rows = (int) Math.ceil((double) layout.buttonCount / layout.numButtons); final int rows = (int) Math.ceil((double) layout.buttonCount / layout.numButtons);
final int diff = rows * 19 + getMarginTop(gui) - y; final int diff = rows * 19 + PADDING - y;
if (diff > 0) { if (diff > 0) {
y += diff; y += diff;
@@ -493,24 +525,31 @@ public class BookmarkPanel extends PanelWidget<BookmarkGrid> {
} }
} }
protected String getPositioningSettingName() { @Override
return "world.panels.bookmarks"; public Rectangle4i calculateBounds(GuiContainer gui) {
} final int maxWidth = (gui.width - 176) / 2 - PADDING * 2;
final int maxHeight = gui.height - PADDING * 2;
final int freeSpace = (gui.width - gui.xSize) / 2 - PADDING * 2;
public int getMarginLeft(GuiContainer gui) { final int paddingLeft = (int) Math
return PADDING; .ceil(maxWidth * NEIClientConfig.getSetting("world.panels.bookmarks.left").getIntValue() / 100000.0);
} final int paddingTop = (int) Math
.ceil(maxHeight * NEIClientConfig.getSetting("world.panels.bookmarks.top").getIntValue() / 100000.0);
final int paddingRight = (int) Math
.ceil(maxWidth * NEIClientConfig.getSetting("world.panels.bookmarks.right").getIntValue() / 100000.0);
final int paddingBottom = (int) Math
.ceil(maxHeight * NEIClientConfig.getSetting("world.panels.bookmarks.bottom").getIntValue() / 100000.0);
public int getMarginTop(GuiContainer gui) { final int width = Math.max(
return PADDING; ItemsGrid.SLOT_SIZE,
} snapDownToMultiple(
Math.min(freeSpace - paddingLeft, maxWidth - paddingLeft - paddingRight)
- BookmarkGrid.GROUP_PANEL_WIDTH,
ItemsGrid.SLOT_SIZE))
+ BookmarkGrid.GROUP_PANEL_WIDTH;
final int height = Math.max(ItemsGrid.SLOT_SIZE, maxHeight - paddingTop - paddingBottom);
public int getWidth(GuiContainer gui) { return new Rectangle4i(paddingLeft + PADDING, paddingTop + PADDING, width, height);
return gui.width - (gui.xSize + gui.width) / 2 - PADDING * 2;
}
public int getHeight(GuiContainer gui) {
return gui.height - getMarginTop(gui) - PADDING;
} }
protected ItemStack getDraggedStackWithQuantity(ItemStack itemStack) { protected ItemStack getDraggedStackWithQuantity(ItemStack itemStack) {
@@ -533,9 +572,10 @@ public class BookmarkPanel extends PanelWidget<BookmarkGrid> {
return; return;
} else if (this.sortableGroup != null) { } else if (this.sortableGroup != null) {
final int overRowIndex = grid.getRowIndex(mousey); final int overRowIndex = Math.min(grid.getRowIndex(mousey), grid.getRows() - 1);
if (overRowIndex >= 0 && this.sortableGroup.groupId != this.grid.getRowGroupId(overRowIndex)) { if (overRowIndex >= 0 && !isOverNamespaceControls(mousex, mousey)
&& !this.sortableGroup.matches(this.grid, this.grid.getRowGroupId(overRowIndex))) {
this.grid.moveGroup(this.sortableGroup, overRowIndex); this.grid.moveGroup(this.sortableGroup, overRowIndex);
} }
@@ -677,7 +717,7 @@ public class BookmarkPanel extends PanelWidget<BookmarkGrid> {
} }
@Override @Override
public List<String> handleTooltip(GuiContainer gui, int mousex, int mousey, List<String> currenttip) { public List<String> handleTooltip(int mousex, int mousey, List<String> currenttip) {
if (this.grid.getPerPage() == 0 || this.grid.isEmpty()) { if (this.grid.getPerPage() == 0 || this.grid.isEmpty()) {
return new ArrayList<>(); return new ArrayList<>();
@@ -704,7 +744,7 @@ public class BookmarkPanel extends PanelWidget<BookmarkGrid> {
this.recipeChainTooltipLineHandler = null; this.recipeChainTooltipLineHandler = null;
} }
return super.handleTooltip(gui, mousex, mousey, currenttip); return super.handleTooltip(mousex, mousey, currenttip);
} }
@Override @Override
@@ -730,7 +770,7 @@ public class BookmarkPanel extends PanelWidget<BookmarkGrid> {
} }
@Override @Override
public Map<String, String> handleHotkeys(GuiContainer gui, int mousex, int mousey, Map<String, String> hotkeys) { public Map<String, String> handleHotkeys(int mousex, int mousey, Map<String, String> hotkeys) {
final int overRowIndex = this.grid.getHoveredRowIndex(true); final int overRowIndex = this.grid.getHoveredRowIndex(true);
final BookmarksGridSlot slot = getSlotMouseOver(mousex, mousey); final BookmarksGridSlot slot = getSlotMouseOver(mousex, mousey);
@@ -760,15 +800,15 @@ public class BookmarkPanel extends PanelWidget<BookmarkGrid> {
NEIMouseUtils.getKeyName(NEIMouseUtils.MOUSE_BTN_RMB), NEIMouseUtils.getKeyName(NEIMouseUtils.MOUSE_BTN_RMB),
NEIClientUtils.translate("bookmark.group.toggle_crafting_chain")); NEIClientUtils.translate("bookmark.group.toggle_crafting_chain"));
hotkeys.put( hotkeys.put(
NEIClientConfig.getKeyName("gui.remove_recipe"), KeyManager.getKeyName("bookmark.remove_recipe", NEIClientUtils.SHIFT_HASH),
NEIClientUtils.translate("bookmark.group.remove_recipe")); NEIClientUtils.translate("bookmark.group.remove_recipe"));
if (BookmarkContainerInfo.getBookmarkContainerHandler(gui) != null) { if (BookmarkContainerInfo.getBookmarkContainerHandler(NEIClientUtils.getGuiContainer()) != null) {
hotkeys.put( hotkeys.put(
NEIClientConfig.getKeyName("gui.bookmark_pull_items"), KeyManager.getKeyName("bookmark.pull_items"),
NEIClientUtils.translate("bookmark.group.pull_items")); NEIClientUtils.translate("bookmark.group.pull_items"));
hotkeys.put( hotkeys.put(
NEIClientConfig.getKeyName("gui.bookmark_pull_items", NEIClientUtils.SHIFT_HASH), KeyManager.getKeyName("bookmark.pull_items", NEIClientUtils.SHIFT_HASH),
NEIClientUtils.translate("bookmark.group.pull_items_shift")); NEIClientUtils.translate("bookmark.group.pull_items_shift"));
} }
@@ -860,23 +900,25 @@ public class BookmarkPanel extends PanelWidget<BookmarkGrid> {
} }
} }
return hotkeys; return super.handleHotkeys(mousex, mousey, hotkeys);
} }
private List<String> recipeChainTooltip(int groupId, List<String> currenttip) { private List<String> recipeChainTooltip(int groupId, List<String> currenttip) {
boolean crafting = this.grid.getGroup(groupId).crafting != null; boolean crafting = this.grid.isCraftingMode(groupId);
if (this.recipeChainTooltipLineHandler == null || this.recipeChainTooltipLineHandler.groupId != groupId if (this.recipeChainTooltipLineHandler == null || this.recipeChainTooltipLineHandler.groupId != groupId
|| this.recipeChainTooltipLineHandler.crafting != crafting) { || this.recipeChainTooltipLineHandler.crafting != crafting) {
this.recipeChainTooltipLineHandler = new RecipeChainTooltipLineHandler( final RecipeChainMath recipeChainMath = this.grid.createRecipeChainMath(groupId);
groupId,
crafting, if (recipeChainMath != null) {
this.grid.createRecipeChainMath(groupId)); this.recipeChainTooltipLineHandler = new RecipeChainTooltipLineHandler(
groupId,
crafting,
recipeChainMath);
}
} }
if (this.recipeChainTooltipLineHandler != null) { currenttip.add(GuiDraw.TOOLTIP_HANDLER + GuiDraw.getTipLineId(this.recipeChainTooltipLineHandler));
currenttip.add(GuiDraw.TOOLTIP_HANDLER + GuiDraw.getTipLineId(this.recipeChainTooltipLineHandler));
}
return currenttip; return currenttip;
} }
@@ -897,13 +939,24 @@ public class BookmarkPanel extends PanelWidget<BookmarkGrid> {
} }
@Override @Override
public List<String> handleItemTooltip(GuiContainer gui, ItemStack itemstack, int mousex, int mousey, public List<String> handleItemTooltip(ItemStack itemstack, int mousex, int mousey, List<String> currenttip) {
List<String> currenttip) {
final BookmarksGridSlot slot = this.grid.getSlotMouseOver(mousex, mousey); final BookmarksGridSlot slot = this.grid.getSlotMouseOver(mousex, mousey);
if (slot != null) { if (slot != null) {
if (slot.isIngredient() && slot.getRecipeId() != null && slot.getBookmarkItem().permutations.size() > 1) { if (slot.getBookmarkItem().chance != PositionedStack.CHANCE_FULL) {
final String chanceText = NEIClientUtils
.formatChance(slot.getBookmarkItem().chance / (float) PositionedStack.CHANCE_FULL);
currenttip.add(
1,
EnumChatFormatting.GRAY + NEIClientUtils.translate(
slot.getType() == BookmarkItemType.INGREDIENT ? "recipe.badge.chance.consume"
: "recipe.badge.chance.output",
chanceText));
}
if (slot.getType() == BookmarkItemType.INGREDIENT && slot.getRecipeId() != null
&& slot.getBookmarkItem().permutations.size() > 1) {
RecipeId recipeId = slot.getRecipeId(); RecipeId recipeId = slot.getRecipeId();
if (recipeId == null) { if (recipeId == null) {
@@ -970,14 +1023,18 @@ public class BookmarkPanel extends PanelWidget<BookmarkGrid> {
this.mouseDownSlot = -1; this.mouseDownSlot = -1;
} }
@Override private boolean isOverNamespaceControls(int mousex, int mousey) {
public boolean onMouseWheel(int shift, int mousex, int mousey) { return new Rectangle4i(
if (!inEditingState() && new Rectangle4i(
namespacePrev.x, namespacePrev.x,
namespacePrev.y, namespacePrev.y,
namespaceNext.x + namespaceNext.w - namespacePrev.x, namespaceNext.x + namespaceNext.w - namespacePrev.x,
namespacePrev.h).contains(mousex, mousey)) { namespacePrev.h).contains(mousex, mousey);
}
@Override
public boolean onMouseWheel(int shift, int mousex, int mousey) {
if ((!inEditingState() || this.sortableGroup != null) && isOverNamespaceControls(mousex, mousey)) {
if (shift > 0) { if (shift > 0) {
this.storage.prevNamespace(); this.storage.prevNamespace();
@@ -996,14 +1053,9 @@ public class BookmarkPanel extends PanelWidget<BookmarkGrid> {
final BookmarksGridSlot slot = this.grid.getSlotMouseOver(mousex, mousey); final BookmarksGridSlot slot = this.grid.getSlotMouseOver(mousex, mousey);
if (slot != null) { if (slot != null) {
int multiplier = 1; final long multiplier = NEIClientUtils.altKey()
? NEIClientUtils.getScrollMultiplier(slot.getItemStack())
if (NEIClientUtils.altKey()) { : 1;
multiplier = NEIClientConfig.showItemQuantityWidget() ? NEIClientConfig.getItemQuantity() : 0;
if (multiplier == 0) {
multiplier = slot.getItemStack().getMaxStackSize();
}
}
this.grid.shiftItemAmount(slot.itemIndex, multiplier * shift); this.grid.shiftItemAmount(slot.itemIndex, multiplier * shift);
return true; return true;
@@ -1021,6 +1073,7 @@ public class BookmarkPanel extends PanelWidget<BookmarkGrid> {
} }
this.grid.shiftGroupAmount(groupId, multiplier * shift); this.grid.shiftGroupAmount(groupId, multiplier * shift);
clearTooltips();
return true; return true;
} }
} }
@@ -1045,20 +1098,23 @@ public class BookmarkPanel extends PanelWidget<BookmarkGrid> {
} }
activeStack = items.get((items.size() - shift + stackIndex) % items.size()); activeStack = items.get((items.size() - shift + stackIndex) % items.size());
this.acceptsFollowingTooltipLineHandler.setActiveStack(activeStack); this.acceptsFollowingTooltipLineHandler.setActiveStack(activeStack);
this.grid.getBookmarkItem(Math.abs(itemIndex)).itemStack = activeStack;
this.grid.onItemsChanged(); final int targetItemIndex = Math.abs(itemIndex);
final BookmarkItem oldItem = this.grid.getBookmarkItem(targetItemIndex);
final BookmarkItem newItem = oldItem.copyWithPerm(activeStack);
this.grid.replaceBookmarkItem(targetItemIndex, newItem);
} }
return true; return true;
} }
if (super.onMouseWheel(shift, mousex, mousey)) { if (super.onMouseWheel(shift, mousex, mousey)) {
final int overRowIndex = grid.getRowIndex(mousey); final int overRowIndex = Math.min(grid.getRowIndex(mousey), grid.getRows() - 1);
if (this.sortableGroup != null && overRowIndex >= 0 if (this.sortableGroup != null && overRowIndex >= 0
&& this.sortableGroup.groupId != this.grid.getRowGroupId(overRowIndex)) { && !this.sortableGroup.matches(this.grid, this.grid.getRowGroupId(overRowIndex))) {
this.grid.moveGroup(this.sortableGroup, overRowIndex); this.grid.moveGroup(this.sortableGroup, overRowIndex);
} }
@@ -1095,7 +1151,7 @@ public class BookmarkPanel extends PanelWidget<BookmarkGrid> {
for (BookmarkItem item : math.initialItems) { for (BookmarkItem item : math.initialItems) {
final long invStackSize = inventory.getOrDefault(item.itemStack, 0L); final long invStackSize = inventory.getOrDefault(item.itemStack, 0L);
final long amount = item.amount - invStackSize * item.fluidCellAmount; final long amount = item.getAmount() - invStackSize * item.fluidCellAmount;
if (amount > 0) { if (amount > 0) {
pullItemStacks.add(item.getItemStack(amount)); pullItemStacks.add(item.getItemStack(amount));
} }
@@ -1109,7 +1165,7 @@ public class BookmarkPanel extends PanelWidget<BookmarkGrid> {
for (BookmarkItem item : math.initialItems) { for (BookmarkItem item : math.initialItems) {
final long invStackSize = inventory.getOrDefault(item.itemStack, 0L); final long invStackSize = inventory.getOrDefault(item.itemStack, 0L);
final long strStackSize = containerStorage.getOrDefault(item.itemStack, 0L); final long strStackSize = containerStorage.getOrDefault(item.itemStack, 0L);
final long amount = item.amount - invStackSize * item.fluidCellAmount final long amount = item.getAmount() - invStackSize * item.fluidCellAmount
- strStackSize * item.fluidCellAmount; - strStackSize * item.fluidCellAmount;
if (amount > 0) { if (amount > 0) {
@@ -1163,7 +1219,17 @@ public class BookmarkPanel extends PanelWidget<BookmarkGrid> {
} }
if (!items.isEmpty()) { if (!items.isEmpty()) {
containerHandler.pullBookmarkItemsFromContainer(guiContainer, items); final int helmStackIndex = FastTransferManager.dropHeldItem(guiContainer);
if (guiContainer.mc.thePlayer.inventory.getItemStack() == null) {
containerHandler.pullBookmarkItemsFromContainer(guiContainer, items);
if (helmStackIndex != -1) {
FastTransferManager.clickSlot(guiContainer, helmStackIndex, 0, 0);
}
clearTooltips();
}
} }
return true; return true;
@@ -1195,7 +1261,10 @@ public class BookmarkPanel extends PanelWidget<BookmarkGrid> {
&& !handlerName.isEmpty() && !handlerName.isEmpty()
&& ingredients != null && ingredients != null
&& !ingredients.isEmpty()) { && !ingredients.isEmpty()) {
addRecipe(Recipe.of(Arrays.asList(stack), handlerName, ingredients), BookmarkGrid.DEFAULT_GROUP_ID); addRecipe(
Recipe.of(Arrays.asList(stack), handlerName, ingredients),
saveSize ? 1 : 0,
BookmarkGrid.DEFAULT_GROUP_ID);
} else { } else {
addItem(stack, saveSize); addItem(stack, saveSize);
} }
@@ -1209,7 +1278,7 @@ public class BookmarkPanel extends PanelWidget<BookmarkGrid> {
@Deprecated @Deprecated
public void addRecipe(BookmarkRecipe recipe, boolean saveSize, int groupId) { public void addRecipe(BookmarkRecipe recipe, boolean saveSize, int groupId) {
addRecipe(recipe.getRecipe(), groupId); addRecipe(recipe.getRecipe(), saveSize ? 1 : 0, groupId);
} }
@Deprecated @Deprecated
@@ -1231,8 +1300,8 @@ public class BookmarkPanel extends PanelWidget<BookmarkGrid> {
@Deprecated @Deprecated
public BookmarkRecipeId getBookmarkRecipeId(int itemIndex) { public BookmarkRecipeId getBookmarkRecipeId(int itemIndex) {
BookmarkItem item = this.grid.getCalculatedItem(itemIndex); BookmarkItem item = this.grid.getCalculatedItem(itemIndex);
return item == null || item.isIngredient || item.recipeId == null ? null return item == null || item.type == BookmarkItemType.INGREDIENT || item.recipeId == null ? null
: new BookmarkRecipeId(item.recipeId.getHandleName(), item.recipeId.getIngredients()); : new BookmarkRecipeId(item.recipeId.getHandlerName(), item.recipeId.getIngredients());
} }
@Deprecated @Deprecated
+5 -1
View File
@@ -15,7 +15,7 @@ public abstract class Button extends Widget {
} }
public int contentWidth() { public int contentWidth() {
return getRenderIcon() == null ? getStringWidth(label) : getRenderIcon().width; return getRenderIcon() == null ? getStringWidth(getRenderLabel()) : getRenderIcon().width;
} }
@Override @Override
@@ -57,6 +57,10 @@ public abstract class Button extends Widget {
return label; return label;
} }
public int getRenderLabelColor() {
return 0;
}
public final String label; public final String label;
public Image icon; public Image icon;
+163 -49
View File
@@ -1,15 +1,17 @@
package codechicken.nei; package codechicken.nei;
import java.io.BufferedReader;
import java.io.File; import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException; import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL; import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.HashSet; import java.util.HashSet;
import java.util.Iterator; import java.util.Iterator;
import java.util.List; import java.util.List;
import java.util.function.BiConsumer; import java.util.Map;
import java.util.TreeMap;
import java.util.function.Consumer; import java.util.function.Consumer;
import java.util.regex.Pattern; import java.util.regex.Pattern;
import java.util.stream.Collectors; import java.util.stream.Collectors;
@@ -21,30 +23,41 @@ import net.minecraft.client.gui.FontRenderer;
import net.minecraft.client.gui.GuiErrorScreen; import net.minecraft.client.gui.GuiErrorScreen;
import net.minecraft.client.gui.GuiScreen; import net.minecraft.client.gui.GuiScreen;
import net.minecraft.client.gui.GuiSelectWorld; import net.minecraft.client.gui.GuiSelectWorld;
import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.client.multiplayer.WorldClient; import net.minecraft.client.multiplayer.WorldClient;
import net.minecraft.client.resources.IResource;
import net.minecraft.entity.Entity; import net.minecraft.entity.Entity;
import net.minecraft.entity.item.EntityItem; import net.minecraft.entity.item.EntityItem;
import net.minecraft.launchwrapper.Launch; import net.minecraft.launchwrapper.Launch;
import net.minecraft.util.ResourceLocation;
import net.minecraft.world.World; import net.minecraft.world.World;
import net.minecraftforge.client.event.GuiOpenEvent; import net.minecraftforge.client.event.GuiOpenEvent;
import net.minecraftforge.client.event.RenderWorldLastEvent; import net.minecraftforge.client.event.RenderWorldLastEvent;
import net.minecraftforge.common.MinecraftForge; import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.event.world.WorldEvent; import net.minecraftforge.event.world.WorldEvent;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils; import org.apache.commons.io.IOUtils;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists; import com.google.common.collect.Lists;
import codechicken.core.ClassDiscoverer; import codechicken.core.ClassDiscoverer;
import codechicken.core.ClientUtils; import codechicken.core.ClientUtils;
import codechicken.core.GuiModListScroll;
import codechicken.lib.packet.PacketCustom; import codechicken.lib.packet.PacketCustom;
import codechicken.nei.api.API; import codechicken.nei.api.API;
import codechicken.nei.api.GuiInfo;
import codechicken.nei.api.IConfigureNEI; import codechicken.nei.api.IConfigureNEI;
import codechicken.nei.api.ItemInfo; import codechicken.nei.api.ItemInfo;
import codechicken.nei.bookmark.tree.GuiCraftingTree;
import codechicken.nei.guihook.GuiContainerManager; import codechicken.nei.guihook.GuiContainerManager;
import codechicken.nei.recipe.GuiRecipeTab; import codechicken.nei.recipe.GuiCraftingRecipe;
import codechicken.nei.recipe.GuiUsageRecipe;
import codechicken.nei.recipe.IRecipeHandler;
import codechicken.nei.recipe.RecipeHandlerRef;
import codechicken.nei.recipe.RecipeItemInputHandler;
import codechicken.nei.recipe.StackInfo; import codechicken.nei.recipe.StackInfo;
import codechicken.nei.recipe.debug.DebugHandlerWidget;
import cpw.mods.fml.client.CustomModLoadingErrorDisplayException; import cpw.mods.fml.client.CustomModLoadingErrorDisplayException;
import cpw.mods.fml.common.FMLCommonHandler; import cpw.mods.fml.common.FMLCommonHandler;
import cpw.mods.fml.common.Loader; import cpw.mods.fml.common.Loader;
@@ -60,6 +73,22 @@ public class ClientHandler {
private static ClientHandler instance; private static ClientHandler instance;
private final ArrayList<EntityItem> SMPmagneticItems = new ArrayList<>(); private final ArrayList<EntityItem> SMPmagneticItems = new ArrayList<>();
private static final String HANDLER_ORDERING = "handlerordering.csv";
public static final List<String> DEFAULT_CONFIGS = ImmutableList.of(
"serialhandlers.cfg",
"heighthackhandlers.cfg",
"hiddenhandlers.cfg",
"enableautofocus.cfg",
"guicraftablesblacklist.cfg",
"defaultbookmarkcontainers.cfg",
"hiddenitems.cfg",
"guidfilters.cfg",
"informationpages.cfg",
"collapsibleitems.cfg",
"recipeidblacklist.cfg",
"handlers.csv",
"catalysts.csv",
HANDLER_ORDERING);
private World lastworld; private World lastworld;
public void addSMPMagneticItem(int i, World world) { public void addSMPMagneticItem(int i, World world) {
@@ -147,43 +176,82 @@ public class ClientHandler {
loadHeightHackHandlers(); loadHeightHackHandlers();
loadHiddenHandlers(); loadHiddenHandlers();
loadEnableAutoFocus(); loadEnableAutoFocus();
loadGuiCraftablesBlacklist();
loadDefaultBookmarkContainers();
ItemInfo.preInit(); ItemInfo.preInit();
StackInfo.loadGuidFilters(); StackInfo.loadGuidFilters();
} }
public static void loadSettingsFile(String resource, Consumer<Stream<String>> callback) { private static URL getDefaultResource(String resource) {
loadSettingsFile(resource, (file, writer) -> { final String folder = resource.substring(resource.lastIndexOf(".") + 1);
String folder = resource.substring(resource.lastIndexOf(".") + 1); return ClientHandler.class.getResource("/assets/nei/" + folder + "/" + resource);
URL defaultResource = ClientHandler.class.getResource("/assets/nei/" + folder + "/" + resource);
if (defaultResource != null) {
try {
IOUtils.copy(defaultResource.openStream(), writer);
} catch (IOException e) {}
}
}, callback);
} }
public static void loadSettingsFile(String resource, BiConsumer<File, FileWriter> createDefault, public static boolean exportDefaultConfig(String resource) {
Consumer<Stream<String>> callback) { final File file = new File(NEIClientConfig.configDir, resource);
File file = new File(NEIClientConfig.configDir, resource); if (file.exists() && !NEIClientUtils.backupFile(file)) return false;
if (!file.exists()) { if (HANDLER_ORDERING.equals(resource)) {
try (FileWriter writer = new FileWriter(file)) { return writeDefaultHandlerOrdering();
NEIClientConfig.logger.info("Creating default '{}' {}", resource, file);
createDefault.accept(file, writer);
} catch (IOException e) {
NEIClientConfig.logger.error("Failed to save default '{}' to file {}", resource, file, e);
}
} }
try (FileReader reader = new FileReader(file)) { final URL url = getDefaultResource(resource);
NEIClientConfig.logger.info("Loading '{}' file {}", resource, file); if (url == null) return false;
callback.accept(
IOUtils.readLines(reader).stream().filter(line -> !line.startsWith("#") && !line.trim().isEmpty())); try {
FileUtils.copyURLToFile(url, file);
NEIClientConfig.logger.info("Exported default '{}' to {}", resource, file);
return true;
} catch (IOException e) {
NEIClientConfig.logger.error("Failed to export default '{}' to file {}", resource, file, e);
return false;
}
}
public static boolean loadSettingsResource(String resource, Consumer<Stream<String>> callback) {
final ResourceLocation location = new ResourceLocation("nei", resource);
try {
final IResource res = Minecraft.getMinecraft().getResourceManager().getResource(location);
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(res.getInputStream(), StandardCharsets.UTF_8))) {
NEIClientConfig.logger.info("Loading '{}' from jar {}", resource, location);
callback.accept(
IOUtils.readLines(reader).stream()
.map(line -> line.contains("#") ? line.substring(0, line.indexOf('#')) : line)
.map(String::trim).filter(line -> !line.isEmpty()));
return true;
}
} catch (Exception io) {
NEIClientConfig.logger.error("Failed to load '{}' file {}", resource, location);
}
return false;
}
public static boolean loadSettingsFile(String resource, Consumer<Stream<String>> callback) {
final File file = new File(NEIClientConfig.configDir, resource);
final boolean fromJar = !file.exists();
try {
final URL url = fromJar ? getDefaultResource(resource) : file.toURI().toURL();
if (url == null) return false;
try (InputStreamReader reader = new InputStreamReader(url.openStream(), StandardCharsets.UTF_8)) {
NEIClientConfig.logger.info("Loading '{}' from {}", resource, fromJar ? "JAR" : file);
callback.accept(
IOUtils.readLines(reader).stream()
.map(line -> line.contains("#") ? line.substring(0, line.indexOf('#')) : line)
.map(String::trim).filter(line -> !line.isEmpty()));
return true;
}
} catch (IOException e) { } catch (IOException e) {
NEIClientConfig.logger.error("Failed to load '{}' file {}", resource, file, e); NEIClientConfig.logger.error("Failed to load '{}' file {}", resource, file, e);
} }
return false;
} }
public static void loadSerialHandlers() { public static void loadSerialHandlers() {
@@ -208,8 +276,27 @@ public class ClientHandler {
public static void loadEnableAutoFocus() { public static void loadEnableAutoFocus() {
loadSettingsFile( loadSettingsFile(
"enableautofocus.cfg", "enableautofocus.cfg",
lines -> AutoFocusWidget.enableAutoFocusPrefixes = lines lines -> AutoFocusWidget.enableAutoFocusPrefixes = lines.collect(Collectors.toList()));
.collect(Collectors.toCollection(ArrayList::new))); }
public static void loadGuiCraftablesBlacklist() {
loadSettingsFile(
"guicraftablesblacklist.cfg",
lines -> ItemCraftablesPanel.guiBlacklist = lines.collect(Collectors.toList()));
}
public static void loadDefaultBookmarkContainers() {
loadSettingsFile("defaultbookmarkcontainers.cfg", lines -> {
for (String clazz : lines.collect(Collectors.toList())) {
try {
API.registerBookmarkContainerHandler(
(Class<? extends GuiContainer>) Class.forName(clazz),
new DefaultBookmarkContainerHandler());
} catch (Exception e) {
NEIClientConfig.logger.error("Failed to load class '{}' for defaultbookmarkcontainers.cfg", clazz);
}
}
});
} }
public static void loadHiddenItems() { public static void loadHiddenItems() {
@@ -219,10 +306,10 @@ public class ClientHandler {
public static void load() { public static void load() {
instance = new ClientHandler(); instance = new ClientHandler();
GuiModListScroll.register("NotEnoughItems");
PacketCustom.assignHandler(NEICPH.channel, new NEICPH()); PacketCustom.assignHandler(NEICPH.channel, new NEICPH());
FMLCommonHandler.instance().bus().register(instance); FMLCommonHandler.instance().bus().register(instance);
MinecraftForge.EVENT_BUS.register(instance); MinecraftForge.EVENT_BUS.register(instance);
MinecraftForge.EVENT_BUS.register(new GuiCraftingTree.EventHandler());
API.registerHighlightHandler(new DefaultHighlightHandler(), ItemInfo.Layout.HEADER); API.registerHighlightHandler(new DefaultHighlightHandler(), ItemInfo.Layout.HEADER);
HUDRenderer.load(); HUDRenderer.load();
@@ -234,26 +321,46 @@ public class ClientHandler {
} }
public static void loadHandlerOrdering() { public static void loadHandlerOrdering() {
final String COMMA_DELIMITER = ","; loadSettingsFile(
final String[] defaultHandlerOrdering = { HANDLER_ORDERING,
lines -> lines.map(line -> line.split(",")).filter(parts -> parts.length == 2).forEach(parts -> {
String handlerId = parts[0];
int ordering = Integer.parseInt(parts[1]);
NEIClientConfig.handlerOrdering.put(handlerId, ordering);
}));
}
private static boolean writeDefaultHandlerOrdering() {
final File file = new File(NEIClientConfig.configDir, HANDLER_ORDERING);
final List<String> lines = Lists.newArrayList(
"# Each line in this file should either be a comment (starts with '#') or an ordering.", "# Each line in this file should either be a comment (starts with '#') or an ordering.",
"# Ordering lines are <handler ID>,<ordering number>.", "# Ordering lines are <handler ID>,<ordering number>.",
"# Handlers will be sorted in order of number ascending, so smaller numbers first.", "# 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.", "# Any handlers that are missing from this file keep their own order, 0 for most of them.",
"# If you delete this file, it will be regenerated with all registered handler IDs.", }; "# Negative numbers are fine.");
final Map<String, Integer> orders = new TreeMap<>();
final List<IRecipeHandler> handlers = new ArrayList<>();
handlers.addAll(GuiCraftingRecipe.craftinghandlers);
handlers.addAll(GuiCraftingRecipe.serialCraftingHandlers);
handlers.addAll(GuiUsageRecipe.usagehandlers);
handlers.addAll(GuiUsageRecipe.serialUsageHandlers);
loadSettingsFile("handlerordering.csv", (file, writer) -> { for (IRecipeHandler handler : handlers) {
List<String> toWrite = Lists.newArrayList(defaultHandlerOrdering); orders.putIfAbsent(
GuiRecipeTab.handlerMap.keySet().stream().sorted() NEIClientConfig.HANDLER_ID_FUNCTION.apply(handler),
.forEach(handlerId -> toWrite.add(String.format("%s" + COMMA_DELIMITER + "0", handlerId))); NEIClientConfig.getHandlerOrder(handler));
try { }
IOUtils.writeLines(toWrite, "\n", writer);
} catch (IOException e) {} orders.forEach((handlerId, order) -> lines.add(handlerId + "," + order));
}, lines -> lines.map(line -> line.split(COMMA_DELIMITER)).filter(parts -> parts.length == 2).forEach(parts -> {
String handlerId = parts[0]; try {
int ordering = Integer.parseInt(parts[1]); NEIClientConfig.logger.info("Creating default '{}' {}", HANDLER_ORDERING, file);
NEIClientConfig.handlerOrdering.put(handlerId, ordering); FileUtils.writeLines(file, StandardCharsets.UTF_8.name(), lines, "\n");
})); return true;
} catch (IOException e) {
NEIClientConfig.logger.error("Failed to save default '{}' to file {}", HANDLER_ORDERING, file, e);
return false;
}
} }
public static void loadPluginsList() { public static void loadPluginsList() {
@@ -319,6 +426,7 @@ public class ClientHandler {
} else if (event.gui == null) { } else if (event.gui == null) {
/* prevent WorldClient reference being held in the Gui */ /* prevent WorldClient reference being held in the Gui */
NEIController.manager = null; NEIController.manager = null;
GuiInfo.clearGuiHandlers();
} }
} }
@@ -339,6 +447,12 @@ public class ClientHandler {
if (event.world == mc.theWorld) { if (event.world == mc.theWorld) {
NEIClientConfig.unloadWorld(); NEIClientConfig.unloadWorld();
ItemMobSpawner.clearEntityReferences(); ItemMobSpawner.clearEntityReferences();
WorldOverlayRenderer.onWorldUnload();
RecipeItemInputHandler.instance.clearTooltipCache();
RecipeHandlerRef.clearCache();
ItemPanels.itemPanel.craftablesPanel.clearGuiReferences();
DebugHandlerWidget.instance.clearGuiReferences();
NEIController.manager = null;
} }
} }
@@ -7,9 +7,13 @@ import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.UUID; import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.function.Supplier;
import java.util.stream.Collectors; import java.util.stream.Collectors;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack; import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTBase;
import net.minecraft.nbt.NBTBase.NBTPrimitive; import net.minecraft.nbt.NBTBase.NBTPrimitive;
import net.minecraft.nbt.NBTTagCompound; import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.StatCollector; import net.minecraft.util.StatCollector;
@@ -34,6 +38,7 @@ public class CollapsibleItems {
public ItemFilter filter; public ItemFilter filter;
public boolean expanded = false; public boolean expanded = false;
public String displayName = ""; public String displayName = "";
public String unlocalizedName;
public void setFilter(String filter) { public void setFilter(String filter) {
this.filter = ItemStackFilterParser.parse(filter.trim()); this.filter = ItemStackFilterParser.parse(filter.trim());
@@ -45,15 +50,38 @@ public class CollapsibleItems {
this.guid = guid; this.guid = guid;
} }
public String getDisplayName() {
if (this.unlocalizedName != null && !this.unlocalizedName.isEmpty()) {
final String translated = StatCollector.translateToLocal(this.unlocalizedName);
if (!translated.equals(this.unlocalizedName)) {
return translated;
}
}
return this.displayName;
}
public boolean matches(ItemStack stack) { public boolean matches(ItemStack stack) {
return this.filter.matches(stack); return this.filter.matches(stack);
} }
} }
public static class ApiGroup {
private String unlocalizedName;
public ApiGroup setName(String unlocalizedName) {
this.unlocalizedName = unlocalizedName;
return this;
}
}
private static final String STATE_KEY = "collapsibleitems"; private static final String STATE_KEY = "collapsibleitems";
protected static File statesFile; protected static File statesFile;
protected static final List<GroupItem> groups = new ArrayList<>(); protected static final List<GroupItem> groups = new ArrayList<>();
protected static final List<Supplier<GroupItem>> apiGroups = new CopyOnWriteArrayList<>();
protected static final Map<ItemStack, Integer> cache = new ConcurrentHashMap<>(); protected static final Map<ItemStack, Integer> cache = new ConcurrentHashMap<>();
private CollapsibleItems() {} private CollapsibleItems() {}
@@ -76,11 +104,57 @@ public class CollapsibleItems {
ClientHandler.loadSettingsFile( ClientHandler.loadSettingsFile(
"collapsibleitems.cfg", "collapsibleitems.cfg",
lines -> parseFile(lines.collect(Collectors.toCollection(ArrayList::new)))); lines -> parseFile(lines.collect(Collectors.toCollection(ArrayList::new))));
for (Supplier<GroupItem> apiGroup : CollapsibleItems.apiGroups) {
try {
addGroup(apiGroup.get());
} catch (Exception e) {
NEIClientConfig.logger.error("Failed to add API group", e);
}
}
} }
loadStates(); loadStates();
} }
public static ApiGroup registerGroup(String filter) {
final ApiGroup apiGroup = new ApiGroup();
CollapsibleItems.apiGroups.add(() -> {
GroupItem group = new GroupItem();
group.setFilter(filter);
group.unlocalizedName = apiGroup.unlocalizedName;
return group;
});
return apiGroup;
}
public static ApiGroup registerGroup(Iterable<ItemStack> items) {
final ApiGroup apiGroup = new ApiGroup();
final ItemStackSet filter = new ItemStackSet();
for (ItemStack stack : items) {
if (stack != null) filter.add(stack.copy());
}
if (filter.isEmpty()) return apiGroup;
final String key = filter.keys().stream()
.map(stack -> Item.itemRegistry.getNameForObject(stack.getItem()) + ":" + stack.getItemDamage())
.sorted().collect(Collectors.joining(","));
final String guid = UUID.nameUUIDFromBytes(key.getBytes()).toString();
CollapsibleItems.apiGroups.add(() -> {
GroupItem group = new GroupItem();
group.setFilter(filter, guid);
group.unlocalizedName = apiGroup.unlocalizedName;
return group;
});
return apiGroup;
}
private static void parseFile(List<String> itemStrings) { private static void parseFile(List<String> itemStrings) {
final JsonParser parser = new JsonParser(); final JsonParser parser = new JsonParser();
GroupItem group = new GroupItem(); GroupItem group = new GroupItem();
@@ -91,17 +165,8 @@ public class CollapsibleItems {
if (itemStr.startsWith("; ")) { if (itemStr.startsWith("; ")) {
JsonObject settings = parser.parse(itemStr.substring(2)).getAsJsonObject(); JsonObject settings = parser.parse(itemStr.substring(2)).getAsJsonObject();
if (settings.get("displayName") != null) {
group.displayName = settings.get("displayName").getAsString();
}
if (settings.get("unlocalizedName") != null) { if (settings.get("unlocalizedName") != null) {
String unlocalizedName = settings.get("unlocalizedName").getAsString(); group.unlocalizedName = settings.get("unlocalizedName").getAsString();
String displayName = StatCollector.translateToLocal(unlocalizedName);
if (!displayName.equals(unlocalizedName)) {
group.displayName = displayName;
}
} }
if (settings.get("expanded") != null) { if (settings.get("expanded") != null) {
@@ -112,7 +177,7 @@ public class CollapsibleItems {
group.setFilter(itemStr); group.setFilter(itemStr);
} }
if (group != null && group.filter != null) { if (group.filter != null) {
addGroup(group); addGroup(group);
group = new GroupItem(); group = new GroupItem();
} }
@@ -175,7 +240,7 @@ public class CollapsibleItems {
public static String getDisplayName(int groupIndex) { public static String getDisplayName(int groupIndex) {
if (groupIndex < CollapsibleItems.groups.size()) { if (groupIndex < CollapsibleItems.groups.size()) {
return CollapsibleItems.groups.get(groupIndex).displayName; return CollapsibleItems.groups.get(groupIndex).getDisplayName();
} }
return null; return null;
@@ -227,17 +292,17 @@ public class CollapsibleItems {
if (NEIClientConfig.world.nbt.hasKey(STATE_KEY)) { if (NEIClientConfig.world.nbt.hasKey(STATE_KEY)) {
NBTTagCompound states = NEIClientConfig.world.nbt.getCompoundTag(STATE_KEY); NBTTagCompound states = NEIClientConfig.world.nbt.getCompoundTag(STATE_KEY);
@SuppressWarnings("unchecked") final Map<String, NBTBase> list = states.tagMap;
final Map<String, NBTPrimitive> list = (Map<String, NBTPrimitive>) states.tagMap;
final Map<String, GroupItem> mapping = new HashMap<>(); final Map<String, GroupItem> mapping = new HashMap<>();
for (GroupItem group : CollapsibleItems.groups) { for (GroupItem group : CollapsibleItems.groups) {
mapping.put(group.guid, group); mapping.put(group.guid, group);
} }
for (Map.Entry<String, NBTPrimitive> nbtEntry : list.entrySet()) { for (Map.Entry<String, NBTBase> nbtEntry : list.entrySet()) {
if (mapping.containsKey(nbtEntry.getKey())) { if (mapping.containsKey(nbtEntry.getKey())) {
mapping.get(nbtEntry.getKey()).expanded = nbtEntry.getValue().func_150290_f() == 1; mapping.get(nbtEntry.getKey()).expanded = ((NBTPrimitive) nbtEntry.getValue()).func_150290_f()
== 1;
} }
} }
} }
@@ -0,0 +1,24 @@
package codechicken.nei;
import com.gtnewhorizon.gtnhlib.color.ColorResource;
public class ColorUtils {
private static final ColorResource.Factory color = new ColorResource.Factory("nei");
public static final ColorResource
// spotless:off
textGray = color.rgb("textGray", "0x404040"),
textLightGray = color.rgb("textLightGray", "0x606060"),
recipeTitle = color.rgb("recipeTitle", "0xFFFFFF"),
recipeTitleHover = color.rgb("recipeTitleHover", "0xFFFF55"),
subsetWidget = color.rgb("subsetWidget", "0xAA00AA"),
recipeBadge = color.rgb("recipeBadge", "0xFDD835"),
buttonLabelNormal = color.rgb("buttonLabelNormal", "0xE0E0E0"),
buttonLabelHover = color.rgb("buttonLabelHover", "0xFFFFA0"),
buttonLabelDisabled = color.rgb("buttonLabelDisabled", "0x601010"),
buttonLabelInactive = color.rgb("buttonLabelInactive", "0xA0A0A0"),
craftingTreeLine = color.argb("craftingTreeLine", "0xFF888888");
// spotless:on
}
@@ -0,0 +1,101 @@
package codechicken.nei;
import java.awt.Dimension;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import codechicken.lib.gui.GuiDraw;
import codechicken.lib.gui.GuiDraw.ITooltipLineHandler;
public abstract class CompositeTooltipLineHandler implements ITooltipLineHandler {
protected static final int SCREEN_MARGIN = 8 * 2 + 10;
protected static final int RESERVED_HEIGHT = 40;
protected final List<ItemsTooltipLineHandler> lines = new ArrayList<>();
protected final Dimension size = new Dimension();
protected boolean created = false;
protected int screenHeight = 0;
protected abstract void createLines();
protected boolean needsUpdate() {
return false;
}
@Override
public Dimension getSize() {
ensureCreated();
return this.size;
}
@Override
public void draw(int x, int y) {
if (this.size.height == 0) return;
for (ItemsTooltipLineHandler line : this.lines) {
line.draw(x, y);
y += line.getSize().height;
}
}
protected void ensureCreated() {
boolean update = needsUpdate();
update = this.screenHeight != (this.screenHeight = GuiDraw.displaySize().height) || update;
if (this.created && !update) {
return;
}
this.created = true;
this.lines.clear();
this.size.setSize(0, 0);
createLines();
fitToScreen();
for (ItemsTooltipLineHandler line : this.lines) {
this.size.width = Math.max(this.size.width, line.getSize().width);
this.size.height += line.getSize().height;
}
}
protected void fitToScreen() {
if (this.lines.isEmpty()) {
return;
}
final List<ItemsTooltipLineHandler> ordered = new ArrayList<>(this.lines);
ordered.sort(Comparator.comparingInt(ItemsTooltipLineHandler::getRows));
int budget = availableHeight() / ItemsTooltipLineHandler.SLOT_SIZE;
int rest = ordered.size();
for (ItemsTooltipLineHandler line : ordered) {
final int fair = Math.max(1, budget / rest);
if (line.getRows() > fair) {
line.setMaxRows(fair);
}
budget -= line.getRows();
rest--;
}
}
protected int availableHeight() {
return GuiDraw.displaySize().height - SCREEN_MARGIN
- RESERVED_HEIGHT
- this.lines.size() * ItemsTooltipLineHandler.headerHeight();
}
protected static int maxLineRows() {
final int height = GuiDraw.displaySize().height - SCREEN_MARGIN
- RESERVED_HEIGHT
- ItemsTooltipLineHandler.headerHeight();
return Math.max(1, height / ItemsTooltipLineHandler.SLOT_SIZE);
}
}
@@ -79,14 +79,13 @@ public class ContainerCreativeInv extends Container {
@Override @Override
public ItemStack transferStackInSlot(EntityPlayer par1EntityPlayer, int slotIndex) { public ItemStack transferStackInSlot(EntityPlayer par1EntityPlayer, int slotIndex) {
ItemStack transferredStack = null; ItemStack transferredStack = null;
Slot slot = (Slot) inventorySlots.get(slotIndex); Slot slot = inventorySlots.get(slotIndex);
if (slot != null && slot.getHasStack()) { if (slot != null && slot.getHasStack()) {
ItemStack stack = slot.getStack(); ItemStack stack = slot.getStack();
transferredStack = stack.copy(); transferredStack = stack.copy();
if (stack.getItem() instanceof ItemArmor) { if (stack.getItem() instanceof ItemArmor armor) {
ItemArmor armor = (ItemArmor) stack.getItem();
if (!getSlot(90 + armor.armorType).getHasStack()) { if (!getSlot(90 + armor.armorType).getHasStack()) {
getSlot(90 + armor.armorType).putStack(transferredStack); getSlot(90 + armor.armorType).putStack(transferredStack);
slot.putStack(null); slot.putStack(null);
@@ -8,7 +8,6 @@ import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.InventoryPlayer; import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.ContainerEnchantment; import net.minecraft.inventory.ContainerEnchantment;
import net.minecraft.inventory.IInventory; import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.Slot;
import net.minecraft.item.Item; import net.minecraft.item.Item;
import net.minecraft.item.ItemStack; import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagList; import net.minecraft.nbt.NBTTagList;
@@ -164,14 +163,14 @@ public class ContainerEnchantmentModifier extends ContainerEnchantment {
public boolean addEnchantment(int e, int level) { public boolean addEnchantment(int e, int level) {
if (e < Enchantment.enchantmentsList.length && Enchantment.enchantmentsList[e] != null) { if (e < Enchantment.enchantmentsList.length && Enchantment.enchantmentsList[e] != null) {
((Slot) inventorySlots.get(0)).getStack().addEnchantment(Enchantment.enchantmentsList[e], level); inventorySlots.get(0).getStack().addEnchantment(Enchantment.enchantmentsList[e], level);
return true; return true;
} }
return false; return false;
} }
public void removeEnchantment(int e) { public void removeEnchantment(int e) {
ItemStack stack = ((Slot) inventorySlots.get(0)).getStack(); ItemStack stack = inventorySlots.get(0).getStack();
NBTTagList nbttaglist = stack.getEnchantmentTagList(); NBTTagList nbttaglist = stack.getEnchantmentTagList();
if (nbttaglist != null) { if (nbttaglist != null) {
for (int i = 0; i < nbttaglist.tagCount(); i++) { for (int i = 0; i < nbttaglist.tagCount(); i++) {
@@ -1,9 +1,10 @@
package codechicken.nei; package codechicken.nei;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.LinkedList; import java.util.List;
import net.minecraft.client.gui.inventory.GuiContainer; import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack; import net.minecraft.item.ItemStack;
import codechicken.nei.api.IBookmarkContainerHandler; import codechicken.nei.api.IBookmarkContainerHandler;
@@ -12,36 +13,18 @@ public class DefaultBookmarkContainerHandler implements IBookmarkContainerHandle
@Override @Override
public void pullBookmarkItemsFromContainer(GuiContainer guiContainer, ArrayList<ItemStack> bookmarkItems) { public void pullBookmarkItemsFromContainer(GuiContainer guiContainer, ArrayList<ItemStack> bookmarkItems) {
FastTransferManager manager = new FastTransferManager(); final List<Slot> slots = guiContainer.inventorySlots.inventorySlots;
LinkedList<ItemStack> containerStacks = manager.saveContainer(guiContainer.inventorySlots); final FastTransferManager manager = new FastTransferManager();
for (ItemStack bookmarkItem : bookmarkItems) { for (ItemStack bookmarkItem : bookmarkItems) {
for (int i = 0; i < slots.size() - 4 * 9; i++) {
int bookmarkSizeBackup = bookmarkItem.stackSize; final Slot slot = slots.get(i);
if (slot.getHasStack() && bookmarkItem.isItemEqual(slot.getStack())) {
for (int i = 0; i < containerStacks.size() - 4 * 9; i++) { // Last 36 slots are player inventory final int transferAmount = Math.min(bookmarkItem.stackSize, slot.getStack().stackSize);
ItemStack containerItem = containerStacks.get(i);
if (containerItem == null) {
continue;
}
if (bookmarkItem.isItemEqual(containerItem)) {
if (bookmarkItem.stackSize <= 0) {
break;
}
int transferAmount = Math.min(bookmarkItem.stackSize, containerItem.stackSize);
manager.transferItems(guiContainer, i, transferAmount); manager.transferItems(guiContainer, i, transferAmount);
bookmarkItem.stackSize -= transferAmount; bookmarkItem.stackSize -= transferAmount;
if (bookmarkItem.stackSize == 0) {
break;
}
} }
} }
bookmarkItem.stackSize = bookmarkSizeBackup;
} }
} }
} }
@@ -20,7 +20,7 @@ public class DefaultHighlightHandler implements IHighlightHandler {
String name = null; String name = null;
try { try {
String s = GuiContainerManager.itemDisplayNameShort(stack); String s = GuiContainerManager.itemDisplayNameShort(stack);
if (s != null && !s.endsWith("Unnamed")) name = s; if (!s.endsWith("Unnamed")) name = s;
if (name != null) currenttip.add(name); if (name != null) currenttip.add(name);
} catch (Exception ignored) {} } catch (Exception ignored) {}
@@ -1,24 +0,0 @@
package codechicken.nei;
import net.minecraft.item.ItemStack;
import codechicken.nei.api.ItemFilter;
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;
}
}
@@ -9,7 +9,9 @@ import java.util.HashMap;
import java.util.HashSet; import java.util.HashSet;
import java.util.LinkedList; import java.util.LinkedList;
import net.minecraft.client.entity.EntityPlayerSP;
import net.minecraft.client.gui.inventory.GuiContainer; import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.Container; import net.minecraft.inventory.Container;
import net.minecraft.inventory.Slot; import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack; import net.minecraft.item.ItemStack;
@@ -89,7 +91,7 @@ public class FastTransferManager {
public static void clearSlots(Container container) { public static void clearSlots(Container container) {
for (int slotNo = 0; slotNo < container.inventorySlots.size(); slotNo++) for (int slotNo = 0; slotNo < container.inventorySlots.size(); slotNo++)
((Slot) container.inventorySlots.get(slotNo)).putStack(null); container.inventorySlots.get(slotNo).putStack(null);
} }
public void performMassTransfer(GuiContainer window, int fromSlot, int toSlot, ItemStack heldStack) { public void performMassTransfer(GuiContainer window, int fromSlot, int toSlot, ItemStack heldStack) {
@@ -281,6 +283,27 @@ public class FastTransferManager {
GuiContainerManager.getManager(window).handleSlotClick(slotIndex, button, modifier); GuiContainerManager.getManager(window).handleSlotClick(slotIndex, button, modifier);
} }
public static int dropHeldItem(GuiContainer window) {
final EntityPlayerSP player = window.mc.thePlayer;
final ItemStack held = player.inventory.getItemStack();
if (held == null) return -1;
for (int i = 0; i < window.inventorySlots.inventorySlots.size(); i++) {
final Slot slot = window.inventorySlots.inventorySlots.get(i);
if (slot.inventory instanceof InventoryPlayer && !slot.getHasStack() && slot.isItemValid(held)) {
clickSlot(window, i, 0, 0);
if (player.inventory.getItemStack() == null) {
return i;
}
}
}
return -1;
}
private boolean fillZoneWithHeldItem(GuiContainer window, int zoneIndex) { private boolean fillZoneWithHeldItem(GuiContainer window, int zoneIndex) {
for (int transferTo : slotZones.get(zoneIndex)) { for (int transferTo : slotZones.get(zoneIndex)) {
ItemStack held = NEIClientUtils.getHeldItem(); ItemStack held = NEIClientUtils.getHeldItem();
@@ -8,17 +8,18 @@ import java.io.InputStream;
import java.io.OutputStream; import java.io.OutputStream;
import java.nio.charset.StandardCharsets; import java.nio.charset.StandardCharsets;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap; import java.util.HashMap;
import java.util.HashSet; import java.util.HashSet;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Optional; import java.util.Objects;
import java.util.Set; import java.util.Set;
import net.minecraft.init.Blocks;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack; import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound; import net.minecraft.nbt.NBTTagCompound;
import net.minecraftforge.fluids.FluidRegistry;
import net.minecraftforge.fluids.FluidStack;
import org.apache.commons.io.IOUtils; import org.apache.commons.io.IOUtils;
@@ -28,19 +29,115 @@ import com.google.gson.JsonSyntaxException;
import codechicken.core.CommonUtils; import codechicken.core.CommonUtils;
import codechicken.nei.api.API; import codechicken.nei.api.API;
import codechicken.nei.recipe.GuiCraftingRecipe;
import codechicken.nei.recipe.GuiRecipeTab;
import codechicken.nei.recipe.ICraftingHandler;
import codechicken.nei.recipe.Recipe.RecipeId; import codechicken.nei.recipe.Recipe.RecipeId;
import codechicken.nei.recipe.RecipeHandlerRef;
import codechicken.nei.recipe.StackInfo; import codechicken.nei.recipe.StackInfo;
import codechicken.nei.util.FavoriteStorage;
import codechicken.nei.util.NBTJson; import codechicken.nei.util.NBTJson;
public class FavoriteRecipes { public class FavoriteRecipes {
private static final Set<NBTTagCompound> tools = new HashSet<>(); protected static final class FastKey {
private static final Map<NBTTagCompound, RecipeId> items = new HashMap<>();
private static final Map<String, RecipeId> fluids = new HashMap<>(); public final ItemStack stack;
private int hash;
public FastKey(ItemStack stack) {
this.stack = stack;
this.hash = 31 + Item.getIdFromItem(stack.getItem());
this.hash = 31 * this.hash + stack.getItemDamage();
}
@Override
public int hashCode() {
return this.hash;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o instanceof FastKey k && this.stack.getItem() == k.stack.getItem()
&& this.stack.getItemDamage() == k.stack.getItemDamage()) {
return this.stack == k.stack || Objects.equals(this.stack.stackTagCompound, k.stack.stackTagCompound);
}
return false;
}
}
private static final RestartableTask singleRecipeFavoritesTask = new RestartableTask(
"Generate Single-Recipe Favorites") {
@Override
public void execute() {
final List<ICraftingHandler> handlers = GuiCraftingRecipe.getCraftingHandlers("all");
final Map<FastKey, RecipeHandlerRef> autogeneratedRecipes = new HashMap<>();
final Set<FastKey> whitelistItems = new HashSet<>(ItemList.items.size());
final FavoriteStorage storage = new FavoriteStorage();
for (ItemStack stack : ItemList.items) {
whitelistItems.add(new FastKey(stack));
}
if (interrupted()) return;
for (ICraftingHandler handler : handlers) {
if (!GuiRecipeTab.getHandlerInfo(handler).getShowFavoritesButton()) continue;
for (int i = 0; i < handler.numRecipes(); i++) {
RecipeHandlerRef ref = null;
for (PositionedStack result : handler.getResultStacks(i)) {
ItemStack stack = StackInfo.getItemStackWithMinimumDamage(result.items);
final FastKey key = new FastKey(stack);
if (!whitelistItems.contains(key)) continue;
if (autogeneratedRecipes.get(key) == null) {
if (ref == null) {
ref = RecipeHandlerRef.of(handler, i);
}
autogeneratedRecipes.put(key, ref);
} else {
autogeneratedRecipes.remove(key);
whitelistItems.remove(key);
}
}
}
if (interrupted()) return;
}
final Map<RecipeHandlerRef, RecipeId> recipesCache = new HashMap<>();
for (Map.Entry<FastKey, RecipeHandlerRef> entry : autogeneratedRecipes.entrySet()) {
final RecipeId recipeId = recipesCache
.computeIfAbsent(entry.getValue(), r -> RecipeId.of(r.handler, r.recipeIndex));
storage.add(entry.getKey().stack, recipeId);
}
FavoriteRecipes.autoFavorites = storage;
updateSubsetVisibility();
}
};
public static final String FAVORITE_ITEM = "FavoriteItem";
private static final FavoriteStorage manualFavorites = new FavoriteStorage();
private static FavoriteStorage autoFavorites = new FavoriteStorage();
private static File favoriteFile; private static File favoriteFile;
private static int revision = 0;
static { static {
API.addSubset("Favorites", FavoriteRecipes::contains); API.addSubset("Favorites.Manual", manualFavorites::contains);
API.addSubset("Favorites.Generated", stack -> FavoriteRecipes.autoFavorites.contains(stack));
} }
private FavoriteRecipes() {} private FavoriteRecipes() {}
@@ -66,7 +163,6 @@ public class FavoriteRecipes {
final File defaultFavorites = configFavorites.exists() ? configFavorites : globalFavorites; final File defaultFavorites = configFavorites.exists() ? configFavorites : globalFavorites;
if (defaultFavorites.exists()) { if (defaultFavorites.exists()) {
try { try {
if (favoriteFile.createNewFile()) { if (favoriteFile.createNewFile()) {
InputStream src = new FileInputStream(defaultFavorites); InputStream src = new FileInputStream(defaultFavorites);
@@ -101,7 +197,9 @@ public class FavoriteRecipes {
} }
final JsonParser parser = new JsonParser(); final JsonParser parser = new JsonParser();
items.clear(); boolean hasErrors = false;
manualFavorites.clear();
for (String itemStr : itemStrings) { for (String itemStr : itemStrings) {
@@ -117,105 +215,151 @@ public class FavoriteRecipes {
final RecipeId recipeId = RecipeId.of(jsonObject.getAsJsonObject("recipeId")); final RecipeId recipeId = RecipeId.of(jsonObject.getAsJsonObject("recipeId"));
final ItemStack stack = StackInfo.loadFromNBT(itemStackNBT); final ItemStack stack = StackInfo.loadFromNBT(itemStackNBT);
if (stack != null) { if (recipeId == null || stack == null) {
final String fluidKey = getFluidKey(stack); continue;
if (fluidKey != null) {
fluids.put(fluidKey, recipeId);
}
} }
items.put(itemStackNBT, recipeId); if (FAVORITE_ITEM.equals(recipeId.getHandlerName()) || RecipeHandlerRef.of(recipeId) != null) {
manualFavorites.add(stack, recipeId);
if (NEIServerUtils.isItemTool(stack)) { } else {
tools.add(itemStackNBT); hasErrors = true;
} }
} }
} catch (IllegalArgumentException | JsonSyntaxException | IllegalStateException e) { } catch (Exception e) {
NEIClientConfig.logger.error("Failed to load favorite from json string:\n{}", itemStr); NEIClientConfig.logger.error("Failed to load favorite from json string: {}", itemStr);
hasErrors = true;
} }
} }
SubsetWidget.updateHiddenItems(); if (hasErrors) {
NEIClientUtils.backupFile(favoriteFile);
save();
}
loadAutoGeneratedRecipes();
}
public static RecipeId getGeneratedFavorite(ItemStack stack) {
if (NEIClientConfig.favoritesEnabled() && stack != null) {
return autoFavorites.getRecipeId(stack);
}
return null;
}
public static ItemStack getGeneratedFavorite(RecipeId recipeId) {
if (NEIClientConfig.favoritesEnabled() && recipeId != null) {
return autoFavorites.getItemStack(recipeId);
}
return null;
}
public static RecipeId getManualFavorite(ItemStack stack) {
if (NEIClientConfig.favoritesEnabled() && stack != null) {
return manualFavorites.getRecipeId(stack);
}
return null;
}
public static ItemStack getManualFavorite(RecipeId recipeId) {
if (NEIClientConfig.favoritesEnabled() && recipeId != null) {
return manualFavorites.getItemStack(recipeId);
}
return null;
} }
public static RecipeId getFavorite(ItemStack stack) { public static RecipeId getFavorite(ItemStack stack) {
if (NEIClientConfig.favoritesEnabled() && stack != null) { if (NEIClientConfig.favoritesEnabled() && stack != null) {
RecipeId recipeId = items.get(StackInfo.itemStackToNBT(stack, false)); final RecipeId recipeId = manualFavorites.getRecipeId(stack);
return recipeId != null ? recipeId : autoFavorites.getRecipeId(stack);
if (recipeId == null) {
recipeId = fluids.get(getFluidKey(stack));
}
if (recipeId != null) {
return recipeId;
}
if (NEIServerUtils.isItemTool(stack)
&& (stack.stackTagCompound == null || !stack.stackTagCompound.hasKey("GT.ToolStats"))) {
for (NBTTagCompound nbt : tools) {
if (NEIServerUtils.areStacksSameTypeCraftingWithNBT(stack, StackInfo.loadFromNBT(nbt))) {
return items.get(nbt);
}
}
}
} }
return null; return null;
} }
public static ItemStack getFavorite(RecipeId recipeId) { public static ItemStack getFavorite(RecipeId recipeId) {
if (NEIClientConfig.favoritesEnabled()) {
final Optional<Map.Entry<NBTTagCompound, RecipeId>> result = items.entrySet().stream()
.filter(entry -> entry.getValue().equals(recipeId)).findAny();
if (result.isPresent()) { if (NEIClientConfig.favoritesEnabled() && recipeId != null) {
return StackInfo.loadFromNBT(result.get().getKey()); final ItemStack stack = manualFavorites.getItemStack(recipeId);
} return stack != null ? stack : autoFavorites.getItemStack(recipeId);
} }
return null; return null;
} }
public static int size() {
return manualFavorites.size() + autoFavorites.size();
}
public static void reload() {
save();
load();
}
public static boolean hasManual() {
return manualFavorites.size() > 0;
}
public static boolean containsManual(ItemStack stack) {
return getManualFavorite(stack) != null;
}
public static boolean contains(ItemStack stack) { public static boolean contains(ItemStack stack) {
return getFavorite(stack) != null; return getFavorite(stack) != null;
} }
public static void setFavorite(ItemStack stack, RecipeId recipeId) { public static void toggleFavoriteItem(ItemStack stack) {
final NBTTagCompound itemStackNBT = StackInfo.itemStackToNBT(stack, false); if (stack == null) return;
final String fluidKey = getFluidKey(stack);
items.entrySet().removeIf(entry -> entry.getKey().equals(itemStackNBT) || entry.getValue().equals(recipeId)); if (containsManual(stack)) {
fluids.entrySet().removeIf(entry -> entry.getKey().equals(fluidKey) || entry.getValue().equals(recipeId)); setFavorite(stack, null);
} else {
if (recipeId != null) { setFavorite(
items.put(itemStackNBT, recipeId); stack,
RecipeId.of(
if (NEIServerUtils.isItemTool(stack)) { stack,
tools.add(itemStackNBT); FavoriteRecipes.FAVORITE_ITEM,
} Arrays.asList(new ItemStack(Blocks.fire, 1), stack)));
if (fluidKey != null) {
fluids.put(fluidKey, recipeId);
}
} }
SubsetWidget.updateHiddenItems();
ItemList.updateFilter.restart();
} }
private static String getFluidKey(ItemStack stack) { public static void setFavorite(ItemStack stack, RecipeId recipeId) {
final FluidStack fluid = StackInfo.getFluid(stack); if (stack == null) return;
if (fluid != null) { manualFavorites.removeItemStack(stack);
return FluidRegistry.getFluidName(fluid);
if (recipeId != null) {
manualFavorites.removeRecipeId(recipeId);
manualFavorites.add(stack, recipeId);
} }
return null; updateSubsetVisibility();
}
public static void loadAutoGeneratedRecipes() {
if (ItemList.loadFinished
&& NEIClientConfig.getBooleanSetting("inventory.favorites.generateSingleRecipeFavorites")) {
singleRecipeFavoritesTask.restart();
} else {
singleRecipeFavoritesTask.stop();
autoFavorites.clear();
updateSubsetVisibility();
}
}
protected static void updateSubsetVisibility() {
SubsetWidget.updateHiddenItems();
FavoriteRecipes.revision++;
}
public static int getRevision() {
return revision;
} }
public static void save() { public static void save() {
@@ -226,7 +370,7 @@ public class FavoriteRecipes {
final List<String> strings = new ArrayList<>(); final List<String> strings = new ArrayList<>();
for (Map.Entry<NBTTagCompound, RecipeId> entry : items.entrySet()) { for (Map.Entry<NBTTagCompound, RecipeId> entry : manualFavorites.getAllFavorites()) {
try { try {
final JsonObject line = new JsonObject(); final JsonObject line = new JsonObject();
@@ -38,6 +38,10 @@ public class FormattedTextField extends GuiTextField {
this.formatter = formatter; this.formatter = formatter;
} }
public TextFormatter getFormatter() {
return this.formatter;
}
public void setPlaceholder(String placeholder) { public void setPlaceholder(String placeholder) {
this.placeholder = placeholder; this.placeholder = placeholder;
} }
@@ -57,6 +61,11 @@ public class FormattedTextField extends GuiTextField {
super.setFocused(focus); super.setFocused(focus);
} }
@Override
public void setText(String rawText) {
super.setText(EnumChatFormatting.getTextWithoutFormattingCodes(rawText));
}
@Override @Override
public void setSelectionPos(int p_146199_1_) { public void setSelectionPos(int p_146199_1_) {
String text = this.getText(); String text = this.getText();
@@ -269,7 +278,7 @@ public class FormattedTextField extends GuiTextField {
} }
Tessellator tessellator = Tessellator.instance; Tessellator tessellator = Tessellator.instance;
GL11.glColor4f(0.0F, 0.0F, 255.0F, 255.0F); GL11.glColor4f(0.0F, 0.0F, 1.0F, 1.0F);
GL11.glDisable(GL11.GL_TEXTURE_2D); GL11.glDisable(GL11.GL_TEXTURE_2D);
GL11.glEnable(GL11.GL_COLOR_LOGIC_OP); GL11.glEnable(GL11.GL_COLOR_LOGIC_OP);
GL11.glLogicOp(GL11.GL_OR_REVERSE); GL11.glLogicOp(GL11.GL_OR_REVERSE);
@@ -287,15 +296,26 @@ public class FormattedTextField extends GuiTextField {
int shift = 0; int shift = 0;
for (int i = 0; i < position; i++) { for (int i = 0; i < position; i++) {
while (this.formattedText.length() > i + shift && this.formattedText.charAt(i + shift) == '\u00a7') { while (this.formattedText.length() > i + shift + 1 && this.formattedText.charAt(i + shift) == '\u00a7'
&& isFormattingCode(this.formattedText.charAt(i + shift + 1))) {
shift += 2; shift += 2;
} }
} }
return position + shift; return Math.min(position + shift, this.formattedText.length());
}
private static boolean isFormattingCode(char c) {
return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f')
|| (c >= 'k' && c <= 'o')
|| c == 'r'
|| (c >= 'A' && c <= 'F')
|| (c >= 'K' && c <= 'O')
|| c == 'R';
} }
private String getPreviousColor(int position) { private String getPreviousColor(int position) {
position = Math.min(position, this.formattedText.length() - 1);
while (position >= 0) { while (position >= 0) {
if (this.formattedText.charAt(position) == '\u00a7') { if (this.formattedText.charAt(position) == '\u00a7') {
return this.formattedText.substring(position, position + 2); return this.formattedText.substring(position, position + 2);
@@ -0,0 +1,188 @@
package codechicken.nei;
import java.lang.ref.WeakReference;
import java.util.Arrays;
import java.util.function.Predicate;
import net.minecraft.client.gui.inventory.GuiContainer;
import codechicken.lib.vec.Rectangle4i;
final class GridOverlapScanner {
private static boolean scanRequested = true;
private static boolean scanFrame = true;
private static boolean wasShowTooltip = true;
private static WeakReference<GuiContainer> lastGui = new WeakReference<>(null);
private boolean invalidated = true;
private final Rectangle4i rect = new Rectangle4i();
private boolean[] checked = new boolean[0];
private int[] queue = new int[0];
private int tail;
private Predicate<Rectangle4i> isHidden;
private boolean[] hidden;
private int hiddenCount;
private int left;
private int top;
private int slotSize;
private int columns;
public static void requestScan() {
scanRequested = true;
}
public static void beginFrame(GuiContainer gui, boolean shouldShowTooltip) {
if (wasShowTooltip != shouldShowTooltip) {
scanRequested = true;
}
wasShowTooltip = shouldShowTooltip;
if (lastGui.get() != gui) {
lastGui = new WeakReference<>(gui);
scanRequested = true;
}
scanFrame = scanRequested;
scanRequested = false;
}
public static boolean isScanFrame() {
return scanFrame;
}
public void invalidate() {
this.invalidated = true;
}
public boolean shouldRefresh() {
final boolean refresh = this.invalidated || scanFrame;
this.invalidated = false;
return refresh;
}
public int scan(Predicate<Rectangle4i> isHidden, int left, int top, int slotSize, int rows, int columns,
boolean seedLeft, boolean seedRight, boolean[] hidden) {
final int size = rows * columns;
if (this.checked.length < size) {
this.checked = new boolean[size];
this.queue = new int[size];
} else {
Arrays.fill(this.checked, 0, size, false);
}
this.isHidden = isHidden;
this.hidden = hidden;
this.hiddenCount = 0;
this.tail = 0;
this.left = left;
this.top = top;
this.slotSize = slotSize;
this.columns = columns;
for (int r = 0; r < rows; r++) {
if (seedLeft) {
probe(r, 0);
}
if (seedRight) {
probe(r, columns - 1);
}
}
for (int head = 0; head < this.tail; head++) {
final int row = this.queue[head] / columns;
final int column = this.queue[head] % columns;
for (int r = Math.max(0, row - 1); r <= Math.min(rows - 1, row + 1); r++) {
for (int c = Math.max(0, column - 1); c <= Math.min(columns - 1, column + 1); c++) {
probe(r, c);
}
}
}
for (int r = 0; r < rows; r++) {
for (int c = 0; c < columns; c++) {
if (this.checked[r * columns + c]) {
continue;
}
int c1 = c;
while (c1 + 1 < columns && !this.checked[r * columns + c1 + 1]) {
c1++;
}
int r1 = r;
while (r1 + 1 < rows && isUnchecked(r1 + 1, c, c1)) {
r1++;
}
scanArea(r, r1, c, c1);
c = c1;
}
}
this.isHidden = null;
this.hidden = null;
return this.hiddenCount;
}
private void probe(int row, int column) {
final int idx = row * this.columns + column;
if (!this.checked[idx]) {
this.checked[idx] = true;
if (test(row, row, column, column)) {
this.hidden[idx] = true;
this.queue[this.tail++] = idx;
this.hiddenCount++;
}
}
}
private void scanArea(int r0, int r1, int c0, int c1) {
if (!test(r0, r1, c0, c1)) {
for (int r = r0; r <= r1; r++) {
Arrays.fill(this.checked, r * this.columns + c0, r * this.columns + c1 + 1, true);
}
} else if (r0 == r1 && c0 == c1) {
this.checked[r0 * this.columns + c0] = true;
this.hidden[r0 * this.columns + c0] = true;
this.hiddenCount++;
} else if (r1 - r0 >= c1 - c0) {
final int mid = (r0 + r1) / 2;
scanArea(r0, mid, c0, c1);
scanArea(mid + 1, r1, c0, c1);
} else {
final int mid = (c0 + c1) / 2;
scanArea(r0, r1, c0, mid);
scanArea(r0, r1, mid + 1, c1);
}
}
private boolean isUnchecked(int row, int c0, int c1) {
for (int c = c0; c <= c1; c++) {
if (this.checked[row * this.columns + c]) {
return false;
}
}
return true;
}
private boolean test(int r0, int r1, int c0, int c1) {
this.rect.set(
this.left + c0 * this.slotSize,
this.top + r0 * this.slotSize,
(c1 - c0 + 1) * this.slotSize,
(r1 - r0 + 1) * this.slotSize);
return this.isHidden.test(this.rect);
}
}
@@ -24,8 +24,8 @@ public class GuiEnchantmentModifier extends GuiContainer {
@Override @Override
protected void drawGuiContainerForegroundLayer(int par1, int par2) { protected void drawGuiContainerForegroundLayer(int par1, int par2) {
fontRendererObj.drawString(translate("enchant"), 12, 6, 0x404040); fontRendererObj.drawString(translate("enchant"), 12, 6, ColorUtils.textGray.getColor());
fontRendererObj.drawString(translate("enchant.level"), 19, 20, 0x404040); fontRendererObj.drawString(translate("enchant.level"), 19, 20, ColorUtils.textGray.getColor());
} }
protected void drawGuiContainerBackgroundLayer(float f, int i, int j) { protected void drawGuiContainerBackgroundLayer(float f, int i, int j) {
@@ -39,7 +39,11 @@ public class GuiEnchantmentModifier extends GuiContainer {
container.drawScrollBar(this); container.drawScrollBar(this);
String levelstring = "" + container.level; String levelstring = "" + container.level;
fontRendererObj.drawString(levelstring, 33 - fontRendererObj.getStringWidth(levelstring) / 2, 34, 0xFF606060); fontRendererObj.drawString(
levelstring,
33 - fontRendererObj.getStringWidth(levelstring) / 2,
34,
ColorUtils.textLightGray.getColor());
GL11.glTranslatef(-guiLeft, -guiTop, 0); GL11.glTranslatef(-guiLeft, -guiTop, 0);
} }
@@ -78,8 +82,8 @@ public class GuiEnchantmentModifier extends GuiContainer {
private void changeLevel(int i) { private void changeLevel(int i) {
container.level += i; container.level += i;
((GuiButton) buttonList.get(0)).enabled = container.level != 1; buttonList.get(0).enabled = container.level != 1;
((GuiButton) buttonList.get(1)).enabled = container.level != 10; buttonList.get(1).enabled = container.level != 10;
} }
protected void mouseClicked(int i, int j, int k) { protected void mouseClicked(int i, int j, int k) {
+21 -26
View File
@@ -7,56 +7,51 @@ import net.minecraft.util.ResourceLocation;
import org.lwjgl.opengl.GL11; import org.lwjgl.opengl.GL11;
import codechicken.nei.drawable.DrawableBuilder;
import codechicken.nei.drawable.DrawableResource;
public class GuiNEIButton extends GuiButton { public class GuiNEIButton extends GuiButton {
protected static final ResourceLocation guiTex = new ResourceLocation("textures/gui/widgets.png"); protected static final ResourceLocation guiTex = new ResourceLocation("textures/gui/widgets.png");
private static final DrawableResource[] BACKGROUNDS = new DrawableResource[3];
static {
for (int state = 0; state < BACKGROUNDS.length; state++) {
BACKGROUNDS[state] = new DrawableBuilder(guiTex, 0, 46 + state * 20, 200, 20).setSlices(2, 2, 2, 2).build();
}
}
public GuiNEIButton(int i, int j, int k, int l, int i1, String s) { public GuiNEIButton(int i, int j, int k, int l, int i1, String s) {
super(i, j, k, l, i1, s); super(i, j, k, l, i1, s);
} }
protected DrawableResource getBackground(int mouseX, int mouseY, boolean mouseOver) {
return BACKGROUNDS[getHoverState(mouseOver)];
}
public void drawButton(Minecraft minecraft, int x, int y) { public void drawButton(Minecraft minecraft, int x, int y) {
if (!visible) return; if (!visible) return;
minecraft.renderEngine.bindTexture(guiTex);
GL11.glColor4f(1, 1, 1, 1);
boolean mouseOver = x >= xPosition && y >= yPosition && x < xPosition + width && y < yPosition + height; boolean mouseOver = x >= xPosition && y >= yPosition && x < xPosition + width && y < yPosition + height;
int k = getHoverState(mouseOver);
drawTexturedModalRect(xPosition, yPosition, 0, 46 + k * 20, width / 2, height / 2); // top left
drawTexturedModalRect(xPosition + width / 2, yPosition, 200 - width / 2, 46 + k * 20, width / 2, height / 2); // top
// right
drawTexturedModalRect(
xPosition,
yPosition + height / 2,
0,
46 + k * 20 + 20 - height / 2,
width / 2,
height / 2); // bottom left
drawTexturedModalRect(
xPosition + width / 2,
yPosition + height / 2,
200 - width / 2,
46 + k * 20 + 20 - height / 2,
width / 2,
height / 2); // bottom right
mouseDragged(minecraft, x, y);
GL11.glColor4f(1, 1, 1, 1);
getBackground(x, y, mouseOver).draw(xPosition, yPosition, width, height);
mouseDragged(minecraft, x, y);
drawContent(minecraft, x, y, mouseOver); drawContent(minecraft, x, y, mouseOver);
} }
protected int getTextColour(boolean mouseOver) { protected int getTextColour(boolean mouseOver) {
int color = 0xe0e0e0;
if (!enabled) { if (!enabled) {
color = 0xffa0a0a0; return ColorUtils.buttonLabelInactive.getColor();
} else if (mouseOver) { } else if (mouseOver) {
color = 0xffffa0; return ColorUtils.buttonLabelHover.getColor();
} }
return color; return ColorUtils.buttonLabelNormal.getColor();
} }
protected void drawContent(Minecraft minecraft, int y, int x, boolean mouseOver) { protected void drawContent(Minecraft minecraft, int x, int y, boolean mouseOver) {
FontRenderer fontrenderer = minecraft.fontRenderer; FontRenderer fontrenderer = minecraft.fontRenderer;
int color = getTextColour(mouseOver); int color = getTextColour(mouseOver);
@@ -289,10 +289,10 @@ public class GuiPotionCreator extends GuiContainerWidget {
CCRenderState.changeTexture("nei:textures/gui/potion.png"); CCRenderState.changeTexture("nei:textures/gui/potion.png");
drawTexturedModalRect(0, 0, 0, 0, xSize, ySize); drawTexturedModalRect(0, 0, 0, 0, xSize, ySize);
FontUtils.drawCenteredString(translate("potion.favourite"), xSize / 2, 4, 0x404040); FontUtils.drawCenteredString(translate("potion.favourite"), xSize / 2, 4, ColorUtils.textGray.getColor());
fontRendererObj.drawString(translate("potion.duration"), 12, 40, 0x404040); fontRendererObj.drawString(translate("potion.duration"), 12, 40, ColorUtils.textGray.getColor());
fontRendererObj.drawString(translate("potion.level"), 19, 73, 0x404040); fontRendererObj.drawString(translate("potion.level"), 19, 73, ColorUtils.textGray.getColor());
FontUtils.drawCenteredString(translateAmplifier(amplifier), 33, 86, 0xFF606060); FontUtils.drawCenteredString(translateAmplifier(amplifier), 33, 86, ColorUtils.textGray.getColor());
} }
@Override @Override
@@ -28,7 +28,7 @@ public class HUDRenderer implements IKeyStateTracker {
@Override @Override
public void tickKeyStates() { public void tickKeyStates() {
if (KeyManager.keyStates.get("world.highlight_tips").down) { if (KeyManager.isPressed("world.highlight_tips")) {
ConfigTag tag = NEIClientConfig.getSetting("world.highlight_tips"); ConfigTag tag = NEIClientConfig.getSetting("world.highlight_tips");
tag.setBooleanValue(!tag.getBooleanValue()); tag.setBooleanValue(!tag.getBooleanValue());
} }
@@ -42,13 +42,11 @@ public class HUDRenderer implements IKeyStateTracker {
&& mc.objectMouseOver != null && mc.objectMouseOver != null
&& mc.objectMouseOver.typeOfHit == MovingObjectType.BLOCK) { && mc.objectMouseOver.typeOfHit == MovingObjectType.BLOCK) {
World world = mc.theWorld; World world = mc.theWorld;
ItemStack[] items = ItemInfo.getIdentifierItems(world, mc.thePlayer, mc.objectMouseOver) final List<ItemStack> items = ItemInfo.getIdentifierItems(world, mc.thePlayer, mc.objectMouseOver);
.toArray(new ItemStack[0]);
if (items.length == 0) return; if (items.isEmpty()) return;
ItemStack stack = StackInfo.getItemStackWithMinimumDamage(items);
final ItemStack stack = StackInfo.getItemStackWithMinimumDamage(items.toArray(new ItemStack[0]));
renderOverlay(stack, ItemInfo.getText(stack, world, mc.thePlayer, mc.objectMouseOver), getPositioning()); renderOverlay(stack, ItemInfo.getText(stack, world, mc.thePlayer, mc.objectMouseOver), getPositioning());
} }
} }
@@ -27,8 +27,8 @@ public class HeldItemHandler implements IContainerInputHandler, IContainerToolti
protected boolean contains(int mousex, int mousey) { protected boolean contains(int mousex, int mousey) {
return NEIClientUtils.getHeldItem() != null && !ItemPanels.bookmarkPanel.inEditingState() return NEIClientUtils.getHeldItem() != null && !ItemPanels.bookmarkPanel.inEditingState()
&& !AutoCraftingManager.processing() && !AutoCraftingManager.processing()
&& (ItemPanels.bookmarkPanel.contains(mousex, mousey) || ItemPanels.itemPanel.contains(mousex, mousey) && (ItemPanels.bookmarkPanel.contains(mousex, mousey)
|| ItemPanels.itemPanel.historyPanel.contains(mousex, mousey)); || ItemPanels.itemPanel.containsWithSubpanels(mousex, mousey));
} }
@Override @Override
@@ -36,7 +36,8 @@ public class HeldItemHandler implements IContainerInputHandler, IContainerToolti
if (contains(mousex, mousey)) { if (contains(mousex, mousey)) {
if (NEIClientConfig.canPerformAction("delete") && NEIClientConfig.canPerformAction("item")) { if (NEIClientConfig.canPerformAction("delete") && NEIClientConfig.canPerformAction("item")
|| NEIClientUtils.mc().playerController.isInCreativeMode()) {
if (button == 1) { if (button == 1) {
NEIClientUtils.decreaseSlotStack(-999); NEIClientUtils.decreaseSlotStack(-999);
} else { } else {
@@ -101,7 +102,8 @@ public class HeldItemHandler implements IContainerInputHandler, IContainerToolti
if (contains(mousex, mousey)) { if (contains(mousex, mousey)) {
currenttip.clear(); currenttip.clear();
if (NEIClientConfig.canPerformAction("delete") && NEIClientConfig.canPerformAction("item")) { if (NEIClientConfig.canPerformAction("delete") && NEIClientConfig.canPerformAction("item")
|| NEIClientUtils.mc().playerController.isInCreativeMode()) {
currenttip.add(EnumChatFormatting.RED + translate("itempanel.deleteItem")); currenttip.add(EnumChatFormatting.RED + translate("itempanel.deleteItem"));
} }
} }
@@ -0,0 +1,161 @@
package codechicken.nei;
import net.minecraft.client.gui.GuiRepair;
import net.minecraft.client.gui.inventory.GuiBrewingStand;
import net.minecraft.client.gui.inventory.GuiCrafting;
import net.minecraft.client.gui.inventory.GuiFurnace;
import net.minecraft.client.gui.inventory.GuiInventory;
import net.minecraft.nbt.NBTTagCompound;
import codechicken.nei.api.API;
import codechicken.nei.recipe.BrewingOverlayHandler;
import codechicken.nei.recipe.BrewingRecipeHandler;
import codechicken.nei.recipe.DefaultOverlayHandler;
import codechicken.nei.recipe.FireworkRecipeHandler;
import codechicken.nei.recipe.FuelRecipeHandler;
import codechicken.nei.recipe.FurnaceRecipeHandler;
import codechicken.nei.recipe.InformationHandler;
import codechicken.nei.recipe.ProfilerRecipeHandler;
import codechicken.nei.recipe.RepairOverlayHandler;
import codechicken.nei.recipe.RepairRecipeHandler;
import codechicken.nei.recipe.ShapedRecipeHandler;
import codechicken.nei.recipe.ShapelessRecipeHandler;
import cpw.mods.fml.common.event.FMLInterModComms;
public class IMCForNEI {
public static void IMCSender() {
API.registerRecipeHandler(new ShapedRecipeHandler());
API.registerUsageHandler(new ShapedRecipeHandler());
sendHandler("codechicken.nei.recipe.ShapedRecipeHandler", "minecraft:crafting_table");
API.registerRecipeHandler(new ShapelessRecipeHandler());
API.registerUsageHandler(new ShapelessRecipeHandler());
sendHandler("codechicken.nei.recipe.ShapelessRecipeHandler", "minecraft:crafting_table");
API.registerRecipeHandler(new FireworkRecipeHandler());
API.registerUsageHandler(new FireworkRecipeHandler());
sendHandler("codechicken.nei.recipe.FireworkRecipeHandler", "minecraft:fireworks");
API.registerRecipeHandler(new FurnaceRecipeHandler());
API.registerUsageHandler(new FurnaceRecipeHandler());
sendHandler("codechicken.nei.recipe.FurnaceRecipeHandler", "minecraft:furnace");
API.registerRecipeHandler(new BrewingRecipeHandler());
API.registerUsageHandler(new BrewingRecipeHandler());
sendHandler("codechicken.nei.recipe.BrewingRecipeHandler", "minecraft:brewing_stand");
API.registerRecipeHandler(new FuelRecipeHandler());
API.registerUsageHandler(new FuelRecipeHandler());
sendFuelRecipeHandler();
API.registerRecipeHandler(new InformationHandler());
API.registerUsageHandler(new InformationHandler());
sendInformationHandler();
API.registerRecipeHandler(new RepairRecipeHandler());
API.registerUsageHandler(new RepairRecipeHandler());
sendRepairHandler();
sendCatalyst("repair", "minecraft:anvil");
API.registerGuiOverlay(GuiCrafting.class, "crafting");
API.registerGuiOverlay(GuiInventory.class, "crafting2x2", 63, 20);
API.registerGuiOverlay(GuiFurnace.class, "smelting");
API.registerGuiOverlay(GuiFurnace.class, "fuel");
API.registerGuiOverlay(GuiBrewingStand.class, "brewing");
API.registerGuiOverlay(GuiRepair.class, "repair", 2, 37);
API.registerGuiOverlayHandler(GuiCrafting.class, new DefaultOverlayHandler(), "crafting");
API.registerGuiOverlayHandler(GuiInventory.class, new DefaultOverlayHandler(63, 20), "crafting2x2");
API.registerGuiOverlayHandler(GuiBrewingStand.class, new BrewingOverlayHandler(), "brewing");
API.registerGuiOverlayHandler(GuiRepair.class, new RepairOverlayHandler(), "repair");
API.registerRecipeHandler(new ProfilerRecipeHandler(true));
API.registerUsageHandler(new ProfilerRecipeHandler(false));
sendProfilerRecipeHandler();
}
private static void sendHandler(String aName, String aBlock) {
NBTTagCompound aNBT = new NBTTagCompound();
aNBT.setString("handler", aName);
aNBT.setString("modName", "Minecraft");
aNBT.setString("modId", "minecraft");
aNBT.setString("itemName", aBlock);
aNBT.setInteger("handlerWidth", 166);
aNBT.setInteger("handlerHeight", 65);
aNBT.setBoolean("multipleWidgetsAllowed", true);
aNBT.setInteger("yShift", 0);
FMLInterModComms.sendMessage("NotEnoughItems", "registerHandlerInfo", aNBT);
}
private static void sendRepairHandler() {
NBTTagCompound aNBT = new NBTTagCompound();
aNBT.setString("handler", "codechicken.nei.recipe.RepairRecipeHandler");
aNBT.setString("modName", "Minecraft");
aNBT.setString("modId", "minecraft");
aNBT.setString("itemName", "minecraft:anvil");
aNBT.setInteger("handlerHeight", 39);
aNBT.setInteger("handlerWidth", 166);
aNBT.setBoolean("multipleWidgetsAllowed", true);
aNBT.setBoolean("showFavoritesButton", false);
aNBT.setInteger("yShift", 0);
FMLInterModComms.sendMessage("NotEnoughItems", "registerHandlerInfo", aNBT);
}
private static void sendFuelRecipeHandler() {
NBTTagCompound aNBT = new NBTTagCompound();
aNBT.setString("handler", "codechicken.nei.recipe.FuelRecipeHandler");
aNBT.setString("modName", "Minecraft");
aNBT.setString("modId", "minecraft");
aNBT.setString("imageResource", "nei:textures/nei_tabbed_sprites.png");
aNBT.setInteger("imageX", 80);
aNBT.setInteger("imageY", 0);
aNBT.setInteger("imageWidth", 14);
aNBT.setInteger("imageHeight", 14);
aNBT.setInteger("handlerHeight", 65);
aNBT.setInteger("handlerWidth", 166);
aNBT.setBoolean("multipleWidgetsAllowed", true);
aNBT.setInteger("yShift", 0);
FMLInterModComms.sendMessage("NotEnoughItems", "registerHandlerInfo", aNBT);
}
private static void sendInformationHandler() {
NBTTagCompound aNBT = new NBTTagCompound();
aNBT.setString("handler", "codechicken.nei.recipe.InformationHandler");
aNBT.setString("modName", "Not Enough Items");
aNBT.setString("modId", "nei");
aNBT.setString("imageResource", "nei:textures/nei_tabbed_sprites.png");
aNBT.setInteger("imageX", 96);
aNBT.setInteger("imageY", 0);
aNBT.setInteger("imageWidth", 16);
aNBT.setInteger("imageHeight", 16);
aNBT.setInteger("handlerHeight", 65);
aNBT.setInteger("handlerWidth", 166);
aNBT.setBoolean("multipleWidgetsAllowed", true);
aNBT.setInteger("yShift", 0);
FMLInterModComms.sendMessage("NotEnoughItems", "registerHandlerInfo", aNBT);
}
private static void sendProfilerRecipeHandler() {
NBTTagCompound aNBT = new NBTTagCompound();
aNBT.setString("handler", "codechicken.nei.recipe.ProfilerRecipeHandler");
aNBT.setString("modName", "Not Enough Items");
aNBT.setString("modId", "nei");
aNBT.setString("itemName", "minecraft:clock");
aNBT.setInteger("handlerHeight", 16);
aNBT.setInteger("handlerWidth", 166);
aNBT.setBoolean("multipleWidgetsAllowed", true);
aNBT.setInteger("yShift", 0);
FMLInterModComms.sendMessage("NotEnoughItems", "registerHandlerInfo", aNBT);
}
private static void sendCatalyst(String aName, String aStack) {
NBTTagCompound aNBT = new NBTTagCompound();
aNBT.setString("handlerID", aName);
aNBT.setString("itemName", aStack);
aNBT.setInteger("priority", 0);
FMLInterModComms.sendMessage("NotEnoughItems", "registerCatalystInfo", aNBT);
}
}
@@ -30,14 +30,7 @@ public class InfiniteStackSizeHandler implements IInfiniteItemHandler {
@Override @Override
public void replenishInfiniteStack(InventoryPlayer inv, int slotNo) { public void replenishInfiniteStack(InventoryPlayer inv, int slotNo) {
ItemStack stack = inv.getStackInSlot(slotNo); inv.getStackInSlot(slotNo).stackSize = 111;
stack.stackSize = 111;
for (int i = 0; i < inv.getSizeInventory(); i++) {
if (i == slotNo) continue;
if (NEIServerUtils.areStacksSameType(stack, inv.getStackInSlot(i))) inv.setInventorySlotContents(i, null);
}
} }
@Override @Override
@@ -0,0 +1,483 @@
package codechicken.nei;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import codechicken.lib.vec.Rectangle4i;
import codechicken.nei.ItemsGrid.ItemsGridSlot;
import codechicken.nei.ItemsGrid.MouseContext;
import codechicken.nei.NEIClientUtils.Alignment;
import codechicken.nei.recipe.AutoCraftingManager;
import codechicken.nei.recipe.GuiCraftingRecipe;
import codechicken.nei.recipe.GuiRecipe;
import codechicken.nei.recipe.ICraftingHandler;
import codechicken.nei.recipe.IRecipeHandler;
import codechicken.nei.recipe.Recipe;
import codechicken.nei.recipe.Recipe.RecipeId;
import codechicken.nei.recipe.RecipeInfo;
import codechicken.nei.recipe.StackInfo;
import codechicken.nei.util.ReadableNumberConverter;
public class ItemCraftablesPanel
extends AbstractSubpanel<ItemsGrid<ItemCraftablesPanel.CraftablesGridSlot, MouseContext>> {
public static class CraftablesGridSlot extends ItemsGridSlot {
protected final long realAmount;
protected final boolean isFluidDisplay;
protected final RecipeId recipeId;
public CraftablesGridSlot(int slotIndex, int itemIndex, ItemStack itemStack, RecipeId recipeId) {
super(slotIndex, itemIndex, itemStack);
this.realAmount = StackInfo.getAmount(itemStack);
this.isFluidDisplay = StackInfo.isFluidDisplayItem(itemStack);
this.recipeId = recipeId;
}
@Override
public RecipeId getRecipeId() {
return this.recipeId;
}
@Override
public <M extends MouseContext> void afterDraw(Rectangle4i rect, M mouseContext) {
drawStackSize(rect);
}
protected void drawStackSize(Rectangle4i rect) {
long stackSize = this.realAmount;
if (stackSize > 1) {
final float panelFactor = (rect.w - 2) / (DEFAULT_SLOT_SIZE - 2);
String amountString = "";
if (stackSize < 10_000) {
amountString = String.valueOf(stackSize);
} else {
amountString = ReadableNumberConverter.INSTANCE.toWideReadableForm(stackSize);
}
if (this.isFluidDisplay) {
amountString += "L";
}
NEIClientUtils.drawNEIOverlayText(
amountString,
new Rectangle4i(rect.x + 1, rect.y + 1, rect.w - 2, rect.h - 2),
panelFactor,
0xFFFFFF,
true,
this.isFluidDisplay ? Alignment.BottomLeft : Alignment.BottomRight);
}
}
}
private static class CraftablesSnapshot {
final GuiContainer guiContainer;
final ItemStackAmount inventory;
final boolean showOnlyFavorites;
final int maxCandidates;
CraftablesSnapshot(GuiContainer guiContainer, ItemStackAmount inventory, boolean showOnlyFavorites,
int maxCandidates) {
this.guiContainer = guiContainer;
this.inventory = inventory;
this.showOnlyFavorites = showOnlyFavorites;
this.maxCandidates = maxCandidates;
}
}
private static class RecipeCandidate {
final IRecipeHandler handler;
final int recipeIndex;
final List<PositionedStack> ingredientStacks;
final ItemStack sortKeyItem;
RecipeCandidate(IRecipeHandler handler, int recipeIndex, List<PositionedStack> ingredientStacks,
ItemStack sortKeyItem) {
this.handler = handler;
this.recipeIndex = recipeIndex;
this.ingredientStacks = ingredientStacks;
this.sortKeyItem = sortKeyItem;
}
}
private static final Comparator<ItemStack> ITEM_SORT_COMPARATOR = Comparator
.comparing(FavoriteRecipes::containsManual).thenComparing(FavoriteRecipes::contains).reversed()
.thenComparing(ItemSorter.instance);
public static List<String> guiBlacklist = new ArrayList<>();
private final int MIN_DELAY = 600;
private Map<String, ArrayList<ICraftingHandler>> identHandlers = new HashMap<>();
private Map<ItemStack, RecipeId> availableRecipes = new HashMap<>();
private GuiContainer lastGuiContainer = null;
private ItemStackAmount lastPlayerInventory = null;
private long lastPlayerInventorySync = 0;
private int lastFavoritesCount = 0;
private volatile CraftablesSnapshot pendingSnapshot;
private final AtomicReference<Map<ItemStack, RecipeId>> pendingResult = new AtomicReference<>();
private final RestartableTask task = new RestartableTask("NEI Craftables Panel") {
@Override
public void execute() {
final CraftablesSnapshot snapshot = ItemCraftablesPanel.this.pendingSnapshot;
if (snapshot != null) {
pendingResult.set(generateCraftables(snapshot));
}
}
};
public ItemCraftablesPanel() {
this.grid = new ItemsGrid<>() {
protected List<CraftablesGridSlot> gridMask;
@Override
protected void onGridChanged() {
this.gridMask = null;
super.onGridChanged();
}
@Override
public List<CraftablesGridSlot> getMask() {
if (this.gridMask == null) {
final int maxSlotIndex = this.rows * this.columns;
final List<CraftablesGridSlot> gridMask = new ArrayList<>();
this.realItems.clear();
if (!ItemCraftablesPanel.this.availableRecipes.isEmpty()) {
final List<Map.Entry<ItemStack, RecipeId>> entries = ItemCraftablesPanel.this.availableRecipes
.entrySet().stream().sorted(Map.Entry.comparingByKey(ITEM_SORT_COMPARATOR))
.limit(maxSlotIndex).collect(Collectors.toList());
int slotIndex = 0;
int itemIndex = 0;
for (Map.Entry<ItemStack, RecipeId> entry : entries) {
if (!isInvalidSlot(slotIndex)) {
this.realItems.add(entry.getKey());
gridMask.add(
new CraftablesGridSlot(
slotIndex,
itemIndex++,
entry.getKey(),
entry.getValue()));
}
if (slotIndex++ >= maxSlotIndex) {
break;
}
}
this.gridMask = gridMask;
} else {
this.gridMask = Collections.emptyList();
}
ItemCraftablesPanel.this.updateLinePadding();
}
return this.gridMask;
}
@Override
protected MouseContext getMouseContext(int mousex, int mousey) {
final ItemsGridSlot hovered = getSlotMouseOver(mousex, mousey);
if (hovered != null) {
return new MouseContext(
hovered.slotIndex,
hovered.slotIndex / this.columns,
hovered.slotIndex % this.columns);
}
return null;
}
};
}
@Override
protected ItemStack getDraggedStackWithQuantity(ItemStack itemStack) {
return ItemQuantityField.prepareStackWithQuantity(itemStack, StackInfo.getAmount(itemStack));
}
@Override
public void draw(int mousex, int mousey) {
if (!this.availableRecipes.isEmpty()) {
super.draw(mousex, mousey);
}
}
@Override
public int setPanelWidth(int width) {
if (getGuiContainer() != this.lastGuiContainer) updateCraftables();
final int columns = width / ItemsGrid.SLOT_SIZE;
final int useRows = NEIClientConfig.getIntSetting("inventory.craftables.useRows");
final int rows = (int) Math.min(Math.ceil(this.availableRecipes.size() * 1f / columns), useRows);
this.w = width;
this.h = 8 + ItemsGrid.SLOT_SIZE * Math.max(rows, 1);
return rows;
}
public void update() {
this.splittingLineColor = NEIClientConfig.getSetting("inventory.craftables.color").getHexValue();
applyPendingResult();
updateCraftables();
super.update();
}
private void applyPendingResult() {
final Map<ItemStack, RecipeId> result = this.pendingResult.getAndSet(null);
if (result != null && NEIClientConfig.showCraftablesPanelWidget()) {
this.availableRecipes = result;
this.grid.onGridChanged();
}
}
private void updateCraftables() {
if (!NEIClientConfig.showCraftablesPanelWidget()) {
clearCraftables();
} else if (this.lastPlayerInventory == null
|| Math.abs(System.currentTimeMillis() - this.lastPlayerInventorySync) >= MIN_DELAY) {
final GuiContainer firstGui = getGuiContainer();
this.lastPlayerInventorySync = System.currentTimeMillis();
if (firstGui != null && !ItemCraftablesPanel.guiBlacklist.contains(firstGui.getClass().getName())) {
final boolean showOnlyFavorites = NEIClientConfig
.getBooleanSetting("inventory.craftables.favoritesOnly");
final ItemStackAmount inv = AutoCraftingManager.getInventoryItems(firstGui);
if (this.lastGuiContainer != firstGui
|| showOnlyFavorites && this.lastFavoritesCount != FavoriteRecipes.size()
|| !inv.equals(this.lastPlayerInventory)) {
this.lastPlayerInventory = inv;
this.lastGuiContainer = firstGui;
this.lastFavoritesCount = FavoriteRecipes.size();
final int maxRows = NEIClientConfig.getIntSetting("inventory.craftables.useRows") + 2;
final int maxCandidates = Math.max(this.grid.columns, 1) * maxRows;
this.pendingSnapshot = new CraftablesSnapshot(
firstGui,
inv,
showOnlyFavorites,
maxCandidates);
this.task.restart();
}
} else {
clearCraftables();
}
}
}
private void clearCraftables() {
if (!this.availableRecipes.isEmpty()) {
this.availableRecipes = Collections.emptyMap();
this.lastPlayerInventory = null;
this.grid.onGridChanged();
}
}
public void clearGuiReferences() {
this.lastGuiContainer = null;
this.pendingSnapshot = null;
}
private GuiContainer getGuiContainer() {
final GuiContainer firstGui = NEIClientUtils.getGuiContainer();
return (firstGui instanceof GuiRecipe<?>gui) ? gui.firstGui : firstGui;
}
private Map<ItemStack, RecipeId> generateCraftables(CraftablesSnapshot snapshot) {
final List<IRecipeHandler> availableHandlers = getAvailableHandlers(snapshot.guiContainer);
final Map<ItemStack, RecipeId> availableRecipes = new HashMap<>();
if (!availableHandlers.isEmpty()) {
final Map<Item, List<ItemStack>> invByItem = indexInventoryByItem(snapshot.inventory.values());
if (snapshot.showOnlyFavorites) {
for (IRecipeHandler handler : availableHandlers) {
availableRecipes.putAll(filterHandlerRecipes(handler, invByItem, true));
}
} else {
final List<RecipeCandidate> candidates = Collections.synchronizedList(new ArrayList<>());
for (IRecipeHandler handler : availableHandlers) {
collectHandlerCandidates(handler, invByItem, candidates);
}
candidates.sort(Comparator.comparing(c -> c.sortKeyItem, ITEM_SORT_COMPARATOR));
candidates.subList(0, Math.min(candidates.size(), snapshot.maxCandidates)).parallelStream()
.forEach(candidate -> buildCandidate(candidate, availableRecipes));
}
}
return availableRecipes;
}
private List<IRecipeHandler> getAvailableHandlers(GuiContainer firstGui) {
final List<IRecipeHandler> availableHandlers = new ArrayList<>();
for (String ident : RecipeInfo.getOverlayHandlerIdents(firstGui)) {
availableHandlers.addAll(identHandlers.computeIfAbsent(ident, GuiCraftingRecipe::getCraftingHandlers));
}
return availableHandlers;
}
private static Map<Item, List<ItemStack>> indexInventoryByItem(List<ItemStack> invStacks) {
final Map<Item, List<ItemStack>> index = new HashMap<>();
for (ItemStack stack : invStacks) {
index.computeIfAbsent(stack.getItem(), i -> new ArrayList<>()).add(stack);
}
return index;
}
private void collectHandlerCandidates(IRecipeHandler handler, Map<Item, List<ItemStack>> invByItem,
List<RecipeCandidate> candidates) {
IntStream.range(0, handler.numRecipes()).parallel().forEach(recipeIndex -> {
final List<PositionedStack> ingredientStacks = handler.getIngredientStacks(recipeIndex);
if (existsIngredients(ingredientStacks, invByItem)) {
final ItemStack sortKeyItem = getCheapResultItem(handler, recipeIndex);
if (sortKeyItem != null) {
candidates.add(new RecipeCandidate(handler, recipeIndex, ingredientStacks, sortKeyItem));
}
}
});
}
private void buildCandidate(RecipeCandidate candidate, Map<ItemStack, RecipeId> availableRecipes) {
final ItemStack result = getCheapResult(candidate.handler, candidate.recipeIndex);
if (result != null) {
final RecipeId recipeId = RecipeId.of(candidate.handler, candidate.recipeIndex, candidate.ingredientStacks);
synchronized (availableRecipes) {
availableRecipes.put(result, recipeId);
}
}
}
private static ItemStack getCheapResultItem(IRecipeHandler handler, int recipeIndex) {
final PositionedStack result = Recipe
.getMainResult(handler.getResultStacks(recipeIndex), pStack -> pStack.items[0]);
return result != null ? result.item : null;
}
private static ItemStack getCheapResult(IRecipeHandler handler, int recipeIndex) {
final List<PositionedStack> results = handler.getResultStacks(recipeIndex);
if (results.isEmpty()) {
return null;
}
final ItemStack stack = Recipe.getMainResult(results, pStack -> pStack.items[0]).item;
int stackSize = 0;
for (PositionedStack result : results) {
if (containsSameType(result, stack)) {
stackSize += StackInfo.getAmount(result.item);
}
}
return StackInfo.withAmount(stack, stackSize);
}
private static boolean containsSameType(PositionedStack pStack, ItemStack stack) {
final ItemStack normalized = StackInfo.withAmount(stack, 0);
for (ItemStack permutation : pStack.items) {
if (NEIServerUtils.areStacksSameTypeWithNBT(StackInfo.withAmount(permutation, 0), normalized)) {
return true;
}
}
return false;
}
private Map<ItemStack, RecipeId> filterHandlerRecipes(IRecipeHandler handler, Map<Item, List<ItemStack>> invByItem,
boolean showOnlyFavorites) {
final Map<ItemStack, RecipeId> availableRecipes = new HashMap<>();
IntStream.range(0, handler.numRecipes()).parallel().forEach(recipeIndex -> {
final List<PositionedStack> ingredientStacks = handler.getIngredientStacks(recipeIndex);
if (existsIngredients(ingredientStacks, invByItem)) {
final ItemStack result = getCheapResult(handler, recipeIndex);
if (result != null) {
final RecipeId recipeId = RecipeId.of(handler, recipeIndex, ingredientStacks);
if (!showOnlyFavorites || FavoriteRecipes.getFavorite(recipeId) != null) {
synchronized (availableRecipes) {
availableRecipes.put(result, recipeId);
}
}
}
}
});
return availableRecipes;
}
private boolean existsIngredients(List<PositionedStack> ingredients, Map<Item, List<ItemStack>> invByItem) {
final Map<ItemStack, Integer> usedItems = new HashMap<>();
for (PositionedStack pStack : ingredients) {
ItemStack used = null;
for (ItemStack permutation : pStack.items) {
final List<ItemStack> candidates = invByItem.get(permutation.getItem());
if (candidates == null) continue;
for (ItemStack is : candidates) {
if (usedItems.getOrDefault(is, is.stackSize) >= pStack.item.stackSize
&& NEIServerUtils.areStacksSameTypeCrafting(permutation, is)) {
used = is;
break;
}
}
if (used != null) break;
}
if (used != null) {
usedItems.put(used, usedItems.getOrDefault(used, used.stackSize) - pStack.item.stackSize);
} else {
return false;
}
}
return !usedItems.isEmpty();
}
}
@@ -1,87 +1,125 @@
package codechicken.nei; package codechicken.nei;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collections;
import java.util.List; import java.util.List;
import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.item.ItemStack; import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import org.lwjgl.opengl.GL11; import org.apache.commons.io.IOUtils;
import codechicken.lib.gui.GuiDraw; import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.google.gson.JsonSyntaxException;
import codechicken.core.CommonUtils;
import codechicken.nei.ItemsGrid.ItemsGridSlot; import codechicken.nei.ItemsGrid.ItemsGridSlot;
import codechicken.nei.ItemsGrid.MouseContext; import codechicken.nei.ItemsGrid.MouseContext;
import codechicken.nei.guihook.IContainerTooltipHandler; import codechicken.nei.recipe.Recipe.RecipeId;
import codechicken.nei.recipe.GuiCraftingRecipe;
import codechicken.nei.recipe.GuiRecipe;
import codechicken.nei.recipe.GuiUsageRecipe;
import codechicken.nei.recipe.StackInfo; import codechicken.nei.recipe.StackInfo;
import codechicken.nei.util.NBTJson;
public class ItemHistoryPanel extends Widget implements IContainerTooltipHandler { public class ItemHistoryPanel extends AbstractSubpanel<ItemsGrid<ItemHistoryPanel.HistoryGridSlot, MouseContext>> {
protected int mouseDownItemIndex = -1; protected File historyFile = null;
protected ItemsGrid<ItemsGridSlot, MouseContext> grid = new ItemsGrid<>() { public static class HistoryGridSlot extends ItemsGridSlot {
protected List<ItemsGridSlot> gridMask; public HistoryGridSlot(int slotIndex, int itemIndex, ItemStack item) {
super(slotIndex, itemIndex, item);
@Override
protected void onGridChanged() {
this.gridMask = null;
super.onGridChanged();
} }
@Override @Override
public List<ItemsGridSlot> getMask() { public RecipeId getRecipeId() {
return FavoriteRecipes.getFavorite(this.item);
if (this.gridMask == null) {
this.gridMask = new ArrayList<>();
for (int slotIndex = 0; slotIndex < Math.min(size(), this.rows * this.columns); slotIndex++) {
this.gridMask.add(new ItemsGridSlot(slotIndex, slotIndex, getItem(slotIndex)));
}
}
return this.gridMask;
} }
@Override
protected MouseContext getMouseContext(int mousex, int mousey) {
final ItemsGridSlot hovered = getSlotMouseOver(mousex, mousey);
if (hovered != null) {
return new MouseContext(
hovered.slotIndex,
hovered.slotIndex / this.columns,
hovered.slotIndex % this.columns);
}
return null;
}
};
public boolean isEmpty() {
return grid.isEmpty();
} }
public ItemHistoryPanel() {
this.grid = new ItemsGrid<>() {
protected List<HistoryGridSlot> gridMask;
@Override
protected void onGridChanged() {
this.gridMask = null;
super.onGridChanged();
}
@Override
public List<HistoryGridSlot> getMask() {
if (this.gridMask == null) {
this.gridMask = new ArrayList<>();
int itemIndex = 0;
for (int slotIndex = 0; slotIndex < this.rows * this.columns && itemIndex < size(); slotIndex++) {
if (!isInvalidSlot(slotIndex)) {
this.gridMask.add(new HistoryGridSlot(slotIndex, itemIndex, getItem(itemIndex)));
itemIndex++;
}
}
ItemHistoryPanel.this.updateLinePadding();
}
return this.gridMask;
}
@Override
protected MouseContext getMouseContext(int mousex, int mousey) {
final HistoryGridSlot hovered = getSlotMouseOver(mousex, mousey);
if (hovered != null) {
return new MouseContext(
hovered.slotIndex,
hovered.slotIndex / this.columns,
hovered.slotIndex % this.columns);
}
return null;
}
};
}
@Override
protected ItemStack getDraggedStackWithQuantity(ItemStack itemStack) {
return ItemQuantityField.prepareStackWithQuantity(itemStack, 0);
}
@Override
public void draw(int mousex, int mousey) { public void draw(int mousex, int mousey) {
if (this.grid.size() > 0) {
if (NEIClientConfig.getIntSetting("inventory.history.splittingMode") == 0) { super.draw(mousex, mousey);
GuiDraw.drawRect(x, y, w, h, NEIClientConfig.getSetting("inventory.history.historyColor").getHexValue());
} else {
drawSplittingArea(x, y, w, h, NEIClientConfig.getSetting("inventory.history.historyColor").getHexValue());
} }
}
this.grid.draw(mousex, mousey); @Override
public int setPanelWidth(int width) {
final int columns = width / ItemsGrid.SLOT_SIZE;
final int useRows = NEIClientConfig.getIntSetting("inventory.history.useRows");
final int rows = (int) Math.min(Math.ceil(this.grid.size() * 1f / columns), useRows);
this.w = width;
this.h = 8 + ItemsGrid.SLOT_SIZE * Math.max(rows, 1);
return rows;
} }
public void update() { public void update() {
this.grid.update(); this.splittingLineColor = NEIClientConfig.getSetting("inventory.history.color").getHexValue();
super.update();
} }
public void addItem(ItemStack stack) { public void addItem(ItemStack stack) {
if (stack != null) { if (stack != null) {
ItemStack is = StackInfo.loadFromNBT(StackInfo.itemStackToNBT(stack), 0); ItemStack is = StackInfo.withAmount(stack, 0);
this.grid.realItems.removeIf(historyStack -> StackInfo.equalItemAndNBT(historyStack, stack, true)); this.grid.realItems.removeIf(historyStack -> StackInfo.equalItemAndNBT(historyStack, stack, true));
this.grid.realItems.add(0, is); this.grid.realItems.add(0, is);
@@ -94,124 +132,107 @@ public class ItemHistoryPanel extends Widget implements IContainerTooltipHandler
} }
} }
public void resize(GuiContainer gui) { public void load() {
this.grid.setGridSize(x, y + 4, w, h - 8);
this.grid.refresh(gui);
}
@Override if (!NEIClientConfig.getBooleanSetting("inventory.history.save")) {
public ItemStack getStackMouseOver(int mousex, int mousey) { return;
final ItemsGridSlot slot = getSlotMouseOver(mousex, mousey); }
return slot == null ? null : slot.getItemStack();
}
public ItemsGridSlot getSlotMouseOver(int mousex, int mousey) { String worldPath = "global";
return grid.getSlotMouseOver(mousex, mousey);
}
private void drawSplittingArea(int x, int y, int width, int height, int color) { if (NEIClientConfig.getBooleanSetting("inventory.history.worldSpecific")) {
worldPath = NEIClientConfig.getWorldPath();
}
float alpha = (color >> 24 & 255) / 255.0F; final File dir = new File(CommonUtils.getMinecraftDir(), "saves/NEI/" + worldPath);
float red = (color >> 16 & 255) / 255.0F;
float green = (color >> 8 & 255) / 255.0F;
float blue = (color & 255) / 255.0F;
GL11.glPushMatrix(); if (!dir.exists()) {
dir.mkdirs();
}
GL11.glDisable(GL11.GL_TEXTURE_2D); final File historyFile = new File(dir, "history.ini");
GL11.glEnable(GL11.GL_LINE_STIPPLE);
GL11.glColor4f(red, green, blue, alpha);
GL11.glLineWidth(2F);
GL11.glLineStipple(2, (short) 0x00FF);
GL11.glBegin(GL11.GL_LINE_LOOP); if (historyFile.equals(this.historyFile)) {
return;
}
GL11.glVertex2i(x, y); List<String> itemStrings = Collections.emptyList();
GL11.glVertex2i(x + width, y);
GL11.glVertex2i(x + width, y + height);
GL11.glVertex2i(x, y + height);
GL11.glEnd(); if (historyFile.exists()) {
try (FileInputStream reader = new FileInputStream(historyFile)) {
GL11.glLineStipple(1, (short) 0xFFFF); NEIClientConfig.logger.info("Loading history from file {}", historyFile);
GL11.glLineWidth(1F); itemStrings = IOUtils.readLines(reader, StandardCharsets.UTF_8);
GL11.glDisable(GL11.GL_LINE_STIPPLE); } catch (IOException e) {
GL11.glEnable(GL11.GL_TEXTURE_2D); NEIClientConfig.logger.error("Failed to load history from file {}", historyFile, e);
GL11.glColor4f(1F, 1F, 1F, 1F); return;
GL11.glPopMatrix();
}
@Override
public void mouseDragged(int mousex, int mousey, int button, long heldTime) {
if (this.mouseDownItemIndex >= 0 && ItemPanels.itemPanel.draggedStack == null
&& NEIClientUtils.getHeldItem() == null
&& NEIClientConfig.hasSMPCounterPart()) {
final ItemsGridSlot mouseOverSlot = getSlotMouseOver(mousex, mousey);
if (mouseOverSlot == null || mouseOverSlot.itemIndex != this.mouseDownItemIndex || heldTime > 500) {
ItemPanels.itemPanel.draggedStack = getDraggedStackWithQuantity(
this.grid.getItem(this.mouseDownItemIndex));
this.mouseDownItemIndex = -1;
} }
} }
} final JsonParser parser = new JsonParser();
final int maxSize = Math.max(50, this.grid.rows * this.grid.columns);
@Override this.grid.realItems.clear();
public boolean handleClick(int mousex, int mousey, int button) {
if (handleClickExt(mousex, mousey, button)) return true;
final ItemsGridSlot hoverSlot = this.grid.getSlotMouseOver(mousex, mousey); for (String itemStr : itemStrings) {
if (hoverSlot != null) {
if (button == 2) { if (itemStr.isEmpty()) {
ItemPanels.itemPanel.draggedStack = getDraggedStackWithQuantity(hoverSlot.getItemStack()); continue;
} else {
mouseDownItemIndex = hoverSlot.itemIndex;
} }
return true; if (this.grid.realItems.size() >= maxSize) {
} break;
}
return false; try {
} JsonObject row = parser.parse(itemStr).getAsJsonObject();
NBTTagCompound itemStackNBT = (NBTTagCompound) NBTJson.toNbt(row.get("item"));
ItemStack itemStack = StackInfo.loadFromNBT(itemStackNBT);
protected ItemStack getDraggedStackWithQuantity(ItemStack itemStack) { if (itemStack != null) {
return ItemQuantityField.prepareStackWithQuantity(itemStack, 0); this.grid.realItems.add(itemStack);
} } else {
NEIClientConfig.logger.warn(
public ItemStack getStackMouseOverWithQuantity(int mousex, int mousey) { "Failed to load history ItemStack from json string, the item no longer exists:\n{}",
final ItemStack hoverSlot = getStackMouseOver(mousex, mousey); itemStr);
return hoverSlot != null ? getDraggedStackWithQuantity(hoverSlot) : null;
}
@Override
public void mouseUp(int mousex, int mousey, int button) {
final ItemsGridSlot hoverSlot = getSlotMouseOver(mousex, mousey);
if (hoverSlot != null && hoverSlot.itemIndex == this.mouseDownItemIndex
&& ItemPanels.itemPanel.draggedStack == null) {
if (NEIController.manager.window instanceof GuiRecipe || NEIClientUtils.shiftKey()
|| !NEIClientConfig.canCheatItem(hoverSlot.getItemStack())) {
if (button == 0) {
GuiCraftingRecipe.openRecipeGui("item", hoverSlot.getItemStack().copy());
} else if (button == 1) {
GuiUsageRecipe.openRecipeGui("item", hoverSlot.getItemStack().copy());
} }
} catch (Exception e) {
} else { NEIClientConfig.logger.error("Failed to load history ItemStack from json string:\n{}", itemStr);
NEIClientUtils.cheatItem(getDraggedStackWithQuantity(hoverSlot.getItemStack()), button, -1);
} }
} }
this.mouseDownItemIndex = -1; this.grid.onItemsChanged();
this.historyFile = historyFile;
}
public void save() {
if (!NEIClientConfig.getBooleanSetting("inventory.history.save")) {
return;
}
if (this.historyFile == null) {
return;
}
final List<String> strings = new ArrayList<>();
for (ItemStack stack : this.grid.realItems) {
try {
final JsonObject row = new JsonObject();
row.add("item", NBTJson.toJsonObject(StackInfo.itemStackToNBT(stack)));
strings.add(NBTJson.toJson(row));
} catch (JsonSyntaxException e) {
NEIClientConfig.logger.error("Failed to stringify history ItemStack to json string");
}
}
try (FileOutputStream output = new FileOutputStream(this.historyFile)) {
IOUtils.writeLines(strings, "\n", output, StandardCharsets.UTF_8);
} catch (IOException e) {
NEIClientConfig.logger.error("Failed to save history list to file {}", this.historyFile, e);
}
} }
} }
+41 -198
View File
@@ -2,34 +2,24 @@ package codechicken.nei;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Arrays; import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList; import java.util.LinkedList;
import java.util.List; import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool; import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinWorkerThread; import java.util.concurrent.ForkJoinWorkerThread;
import java.util.regex.Pattern; import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.StreamSupport;
import net.minecraft.client.Minecraft;
import net.minecraft.item.Item; import net.minecraft.item.Item;
import net.minecraft.item.ItemStack; import net.minecraft.item.ItemStack;
import net.minecraft.util.EnumChatFormatting; import net.minecraft.util.EnumChatFormatting;
import net.minecraft.util.IIcon; import net.minecraft.util.StatCollector;
import com.google.common.collect.ArrayListMultimap; import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.ListMultimap; import com.google.common.collect.ListMultimap;
import codechicken.nei.ThreadOperationTimer.TimeoutException;
import codechicken.nei.api.ItemFilter; import codechicken.nei.api.ItemFilter;
import codechicken.nei.api.ItemFilter.ItemFilterProvider; import codechicken.nei.api.ItemFilter.ItemFilterProvider;
import codechicken.nei.api.ItemInfo; import codechicken.nei.api.ItemInfo;
import codechicken.nei.recipe.InformationHandler; import codechicken.nei.util.ItemUntranslator;
import codechicken.nei.search.TooltipFilter;
public class ItemList { public class ItemList {
@@ -47,9 +37,6 @@ public class ItemList {
public static final List<ItemFilterProvider> itemFilterers = new LinkedList<>(); public static final List<ItemFilterProvider> itemFilterers = new LinkedList<>();
public static final List<ItemsLoadedCallback> loadCallbacks = new LinkedList<>(); public static final List<ItemsLoadedCallback> loadCallbacks = new LinkedList<>();
private static final HashSet<Item> erroredItems = new HashSet<>();
private static final HashSet<String> stackTraces = new HashSet<>();
private static Map<ItemStack, Integer> ordering = new HashMap<>();
/** /**
* Unlike {@link LayoutManager#itemsLoaded}, this indicates whether item loading is actually finished or not. * Unlike {@link LayoutManager#itemsLoaded}, this indicates whether item loading is actually finished or not.
*/ */
@@ -97,7 +84,13 @@ public class ItemList {
public boolean matches(ItemStack item) { public boolean matches(ItemStack item) {
String displayName = EnumChatFormatting.getTextWithoutFormattingCodes(item.getDisplayName()); String displayName = EnumChatFormatting.getTextWithoutFormattingCodes(item.getDisplayName());
if (displayName != null && !displayName.isEmpty() && pattern.matcher(displayName).find()) { if (displayName != null && !displayName.isEmpty() && this.pattern.matcher(displayName).find()) {
return true;
}
displayName = ItemUntranslator.getInstance().getItemStackDisplayName(item);
if (!displayName.isEmpty() && this.pattern.matcher(displayName).find()) {
return true; return true;
} }
@@ -105,7 +98,15 @@ public class ItemList {
displayName = EnumChatFormatting displayName = EnumChatFormatting
.getTextWithoutFormattingCodes(item.getItem().getItemStackDisplayName(item)); .getTextWithoutFormattingCodes(item.getItem().getItemStackDisplayName(item));
return displayName != null && !displayName.isEmpty() && pattern.matcher(displayName).find(); if (displayName != null && !displayName.isEmpty() && this.pattern.matcher(displayName).find()) {
return true;
}
}
for (String alias : ItemInfo.getAliases(item)) {
if (this.pattern.matcher(StatCollector.translateToLocal(alias)).find()) {
return true;
}
} }
return false; return false;
@@ -206,167 +207,32 @@ public class ItemList {
return filters; return filters;
} }
public static final RestartableTask loadItems = new RestartableTask("NEI Item Loading") { public static ItemStack[] expandPermutations(ItemStack[] items) {
List<ItemStack> stacks = new ArrayList<>();
private void damageSearch(Item item, List<ItemStack> permutations) { for (ItemStack item : items) {
HashSet<String> damageIconSet = new HashSet<>(); if (item == null || item.getItem() == null) continue;
for (int damage = 0; damage < 16; damage++) try {
ItemStack itemstack = new ItemStack(item, 1, damage);
IIcon icon = item.getIconIndex(itemstack);
String name = getTooltip(itemstack);
String s = name + "@" + (icon == null ? 0 : icon.hashCode());
if (damageIconSet.add(s)) {
permutations.add(itemstack);
}
} catch (TimeoutException t) {
throw t;
} catch (Throwable t) {
NEIServerUtils.logOnce(
t,
stackTraces,
"Ommiting " + item + ":" + damage + " " + item.getClass().getSimpleName(),
item.toString());
}
}
private String getTooltip(ItemStack stack) {
try {
return String.join("\n", stack.getTooltip(Minecraft.getMinecraft().thePlayer, false));
} catch (Throwable ignored) {}
return "";
}
private void updateOrdering(List<ItemStack> items) {
final Map<ItemStack, Integer> newOrdering = new HashMap<>();
ItemSorter.sort(items);
if (!CollapsibleItems.isEmpty()) {
final HashMap<Integer, Integer> groups = new HashMap<>();
int orderIndex = 0;
for (ItemStack stack : items) {
final int groupIndex = CollapsibleItems.getGroupIndex(stack);
if (groupIndex == -1) {
newOrdering.put(stack, orderIndex++);
} else {
if (!groups.containsKey(groupIndex)) {
groups.put(groupIndex, orderIndex++);
}
newOrdering.put(stack, groups.get(groupIndex));
}
}
} else {
int orderIndex = 0;
for (ItemStack stack : items) {
newOrdering.put(stack, orderIndex++);
}
}
ItemList.ordering = newOrdering;
}
private List<ItemStack> getPermutations(Item item) {
final List<ItemStack> permutations = new LinkedList<>(ItemInfo.itemOverrides.get(item));
if (permutations.isEmpty()) {
item.getSubItems(item, null, permutations);
}
if (permutations.isEmpty()) {
damageSearch(item, permutations);
}
permutations.addAll(ItemInfo.itemVariants.get(item));
return permutations.stream()
.filter(
stack -> stack.getItem() != null && stack.getItem().delegate.name() != null
&& !ItemInfo.isHidden(stack))
.collect(Collectors.toList());
}
// Generate itemlist, permutations, orders, collapsibleitems, and informationhandler stacks
@Override
@SuppressWarnings("unchecked")
public void execute() {
if (!NEIClientConfig.isEnabled() || NEIClientUtils.mc().thePlayer == null) return;
ThreadOperationTimer timer = getTimer(NEIClientConfig.getItemLoadingTimeout());
LayoutManager.itemsLoaded = true;
loadFinished = false;
SearchField.searchParser.clearCache();
ItemSorter.instance.ordering.clear();
CollapsibleItems.clearCache();
TooltipFilter.clearCache();
InformationHandler.clearCache();
List<ItemStack> items = new ArrayList<>();
ListMultimap<Item, ItemStack> itemMap = ArrayListMultimap.create();
ItemStackSet unique = new ItemStackSet();
StreamSupport.stream(((Iterable<Item>) Item.itemRegistry).spliterator(), true).forEach(item -> {
if (item == null || item.delegate.name() == null || erroredItems.contains(item)) return;
try {
timer.reset(item);
List<ItemStack> permutations = getPermutations(item);
timer.reset();
if (item.getItemDamage() == Short.MAX_VALUE) {
List<ItemStack> permutations = itemMap.get(item.getItem());
if (!permutations.isEmpty()) {
for (ItemStack stack : permutations) { for (ItemStack stack : permutations) {
if (!unique.contains(stack)) { ItemStack toAdd = stack.copy();
toAdd.stackSize = item.stackSize;
synchronized (unique) { stacks.add(toAdd);
unique.add(stack);
}
synchronized (items) {
items.add(stack);
}
CollapsibleItems.putItem(stack);
TooltipFilter.getSearchTooltip(stack);
InformationHandler.populateStacks(stack);
}
} }
} else {
synchronized (itemMap) { ItemStack base = new ItemStack(item.getItem(), item.stackSize);
itemMap.putAll(item, permutations); base.stackTagCompound = item.stackTagCompound;
} stacks.add(base);
} catch (Throwable t) {
NEIServerConfig.logger.error("Removing item: {} from list.", item, t);
erroredItems.add(item);
}
});
int index = 0;
for (Item item : (Iterable<Item>) Item.itemRegistry) {
for (ItemStack stack : itemMap.get(item)) {
ItemSorter.instance.ordering.put(stack, index++);
} }
continue;
} }
if (interrupted()) return; stacks.add(item.copy());
ItemList.items = items;
ItemList.itemMap = itemMap;
for (ItemsLoadedCallback callback : loadCallbacks) callback.itemsLoaded();
if (interrupted()) return;
updateOrdering(ItemList.items);
loadFinished = true;
SubsetWidget.updateHiddenItems();
ItemPanels.bookmarkPanel.load();
updateFilter.restart();
} }
};
return stacks.toArray(new ItemStack[0]);
}
public static ForkJoinPool forkJoinPool; public static ForkJoinPool forkJoinPool;
@@ -387,35 +253,12 @@ public class ItemList {
forkJoinPool = new ForkJoinPool(poolSize, factory, null, false); forkJoinPool = new ForkJoinPool(poolSize, factory, null, false);
} }
public static final RestartableTask updateFilter = new RestartableTask("NEI Item Filtering") { // The item list pipeline lives in ItemListLoader; these references are kept for backward compatibility.
public static final RestartableTask loadItems = ItemListLoader.loadItems;
@Override public static final RestartableTask refreshItems = ItemListLoader.refreshItems;
public void execute() {
if (!loadFinished) return; public static final RestartableTask updateFilter = ItemListLoader.updateFilter;
ItemFilter filter = getItemListFilter();
ArrayList<ItemStack> filtered;
try {
filtered = ItemList.forkJoinPool.submit(
() -> items.parallelStream().filter(filter::matches)
.collect(Collectors.toCollection(ArrayList::new)))
.get();
} catch (InterruptedException | ExecutionException e) {
filtered = new ArrayList<>();
e.printStackTrace();
stop();
}
if (interrupted()) return;
filtered.sort(Comparator.comparingInt(ItemList.ordering::get));
if (interrupted()) return;
ItemPanel.updateItemList(filtered);
}
};
/** /**
* @deprecated Use updateFilter.restart() * @deprecated Use updateFilter.restart()
@@ -0,0 +1,383 @@
package codechicken.nei;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
import net.minecraft.client.Minecraft;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Blocks;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.IIcon;
import net.minecraftforge.fluids.IFluidContainerItem;
import com.google.common.base.Throwables;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.ListMultimap;
import codechicken.nei.ItemList.ItemsLoadedCallback;
import codechicken.nei.ThreadOperationTimer.TimeoutException;
import codechicken.nei.api.ItemFilter;
import codechicken.nei.api.ItemInfo;
import codechicken.nei.recipe.InformationHandler;
import codechicken.nei.recipe.RecipeHandlerRef;
import codechicken.nei.recipe.RepairRecipeHandler;
import codechicken.nei.search.TooltipFilter;
import cpw.mods.fml.common.FMLLog;
public class ItemListLoader {
private static final HashSet<Item> erroredItems = new HashSet<>();
private static Map<ItemStack, Integer> ordering = new HashMap<>();
private ItemListLoader() {}
private static void damageSearch(Item item, List<ItemStack> permutations) {
final Set<String> damageIconSet = new HashSet<>();
final EntityPlayer player = Minecraft.getMinecraft().thePlayer;
for (int damage = 0; damage < 16; damage++) {
try {
final ItemStack itemstack = new ItemStack(item, 1, damage);
final IIcon icon = item.getIconIndex(itemstack);
final String key = itemstack.getDisplayName() + "@"
+ (icon == null ? 0 : icon.hashCode())
+ "@"
+ getInformation(itemstack, player);
if (damageIconSet.add(key)) {
permutations.add(itemstack);
}
} catch (TimeoutException t) {
throw t;
} catch (Throwable t) {
NEIClientUtils.errorOnce(
"ItemListLoader: " + item.toString(),
"Ommiting " + item + ":" + damage + " " + item.getClass().getSimpleName(),
t);
}
}
}
private static String getInformation(ItemStack stack, EntityPlayer player) {
try {
final List<String> tooltip = new ArrayList<>();
stack.getItem().addInformation(stack, player, tooltip, false);
return String.join("\n", tooltip);
} catch (Throwable ignored) {}
return "";
}
private static void updateOrdering(List<ItemStack> items) {
final Map<ItemStack, Integer> newOrdering = new HashMap<>();
if (!CollapsibleItems.isEmpty()) {
final HashMap<Integer, Integer> groups = new HashMap<>();
int orderIndex = 0;
for (ItemStack stack : items) {
final int groupIndex = CollapsibleItems.getGroupIndex(stack);
if (groupIndex == -1) {
newOrdering.put(stack, orderIndex++);
} else {
if (!groups.containsKey(groupIndex)) {
groups.put(groupIndex, orderIndex++);
}
newOrdering.put(stack, groups.get(groupIndex));
}
}
} else {
int orderIndex = 0;
for (ItemStack stack : items) {
newOrdering.put(stack, orderIndex++);
}
}
ordering = newOrdering;
}
private static List<ItemStack> getPermutations(Item item) {
final List<ItemStack> permutations = new LinkedList<>(ItemInfo.itemOverrides.get(item));
if (permutations.isEmpty()) {
item.getSubItems(item, null, permutations);
}
if (permutations.isEmpty()) {
damageSearch(item, permutations);
}
permutations.addAll(ItemInfo.itemVariants.get(item));
return permutations.stream()
.filter(
stack -> stack.getItem() != null && stack.getItem().delegate.name() != null
&& !ItemInfo.isHidden(stack))
.collect(Collectors.toList());
}
private static void runChecked(ItemStack stack, Runnable action, String reason) {
int hashOld = 0;
if (stack.hasTagCompound()) {
hashOld = stack.stackTagCompound.hashCode();
}
action.run();
if (stack.hasTagCompound() && hashOld != stack.stackTagCompound.hashCode()) {
FMLLog.warning(
"NEI: Forced tag update with reason (" + reason + ") for " + stack + "(" + stack.getItem() + ")");
}
}
private static void forceTagCompoundInitialization(ItemStack stack) {
Item item = stack.getItem();
if (item == null) {
return;
}
if (item instanceof IFluidContainerItem fluidItem) {
runChecked(stack, () -> fluidItem.getFluid(stack), "getFluid");
}
runChecked(stack, () -> item.isDamaged(stack), "isDamaged");
runChecked(stack, () -> item.getDamage(stack), "getDamage");
runChecked(stack, () -> item.showDurabilityBar(stack), "showDurabilityBar");
runChecked(stack, () -> item.getAttributeModifiers(stack), "getAttributeModifiers");
runChecked(stack, () -> item.getDurabilityForDisplay(stack), "getDurabilityForDisplay");
runChecked(stack, () -> item.getItemStackLimit(stack), "getItemStackLimit");
runChecked(stack, () -> item.getToolClasses(stack), "getToolClasses");
runChecked(stack, () -> item.getUnlocalizedNameInefficiently(stack), "getUnlocalizedNameInefficiently");
runChecked(stack, () -> item.hasEffect(stack), "hasEffect");
runChecked(stack, () -> item.getDigSpeed(stack, Blocks.stone, 0), "getDigSpeed");
/*
* unused... for now runChecked(stack, () -> GameRegistry.getFuelValue(stack), "getFuelValue");
* runChecked(stack, () -> item.getUnlocalizedName(stack), "getUnlocalizedName"); runChecked(stack, () ->
* item.doesContainerItemLeaveCraftingGrid(stack), "doesContainerItemLeaveCraftingGrid"); runChecked(stack, ()
* -> item.getItemUseAction(stack), "getItemUseAction"); runChecked(stack, () ->
* item.getMaxItemUseDuration(stack), "getMaxItemUseDuration"); runChecked(stack, () ->
* item.getPotionEffect(stack), "getPotionEffect"); runChecked(stack, () -> item.isPotionIngredient(stack),
* "isPotionIngredient"); runChecked(stack, () -> item.getRarity(stack), "getRarity"); runChecked(stack, () ->
* item.hasCustomEntity(stack), "hasCustomEntity"); runChecked(stack, () -> item.getSmeltingExperience(stack),
* "getSmeltingExperience"); runChecked(stack, () -> item.getMaxDamage(stack), "getMaxDamage");
* runChecked(stack, () -> item.getDamage(stack), "getDamage"); runChecked(stack, stack::isItemDamaged,
* "isItemDamaged"); runChecked(stack, () -> item.hasEffect(stack, 0), "hasEffect"); runChecked(stack, () ->
* item.getItemEnchantability(stack), "getItemEnchantability"); runChecked(stack, () ->
* item.isBeaconPayment(stack), "isBeaconPayment"); runChecked(stack, () -> item.getDamage(stack), "getDamage");
* runChecked(stack, () -> item.getDamage(stack), "getDamage"); runChecked(stack, () -> item.getDamage(stack),
* "getDamage");
*/
}
@SuppressWarnings("unchecked")
private static List<ItemStack> gatherItems(ThreadOperationTimer timer) {
ItemSorter.instance.ordering.clear();
List<ItemStack> items = new ArrayList<>();
ListMultimap<Item, ItemStack> itemMap = ArrayListMultimap.create();
ItemStackSet unique = new ItemStackSet();
final List<Item> registryItems = new ArrayList<>();
for (Item item : (Iterable<Item>) Item.itemRegistry) registryItems.add(item);
registryItems.parallelStream().forEach(item -> {
if (item == null || item.delegate.name() == null || erroredItems.contains(item)) return;
try {
timer.reset(item);
List<ItemStack> permutations = getPermutations(item);
timer.reset();
synchronized (itemMap) {
itemMap.putAll(item, permutations);
}
} catch (Throwable t) {
NEIServerConfig.logger.error(
"Removing item: {} from list.\n{}: {}",
item,
t.getMessage(),
Throwables.getStackTraceAsString(t));
erroredItems.add(item);
}
});
int index = 0;
for (Item item : (Iterable<Item>) Item.itemRegistry) {
for (ItemStack stack : itemMap.get(item)) {
ItemSorter.instance.ordering.put(stack, index++);
if (!unique.contains(stack)) {
unique.add(stack);
items.add(stack);
}
}
}
ItemList.itemMap = itemMap;
return items;
}
private static void buildItemCaches(List<ItemStack> items) {
SearchField.searchParser.clearCache();
TooltipFilter.clearCache();
InformationHandler.clearCache();
items.parallelStream().forEach(stack -> {
try {
forceTagCompoundInitialization(stack);
InformationHandler.populateStacks(stack);
} catch (Throwable t) {
NEIServerConfig.logger.error(
"Failed to build caches for: {}\n{}: {}",
stack,
t.getMessage(),
Throwables.getStackTraceAsString(t));
}
});
}
private static void indexCollapsibleItems(List<ItemStack> items) {
CollapsibleItems.clearCache();
items.parallelStream().forEach(CollapsibleItems::putItem);
}
public static final RestartableTask loadItems = new RestartableTask("NEI Item Loading") {
@Override
public void execute() {
if (!NEIClientConfig.isEnabled() || NEIClientUtils.mc().thePlayer == null) return;
final ThreadOperationTimer timer = getTimer(NEIClientConfig.getItemLoadingTimeout());
LayoutManager.itemsLoaded = true;
ItemList.loadFinished = false;
warmTooltips.stop();
List<ItemStack> items = gatherItems(timer);
if (interrupted()) return;
buildItemCaches(items);
indexCollapsibleItems(items);
if (interrupted()) return;
ItemSorter.sort(items);
if (interrupted()) return;
ItemList.items = items;
for (ItemsLoadedCallback callback : ItemList.loadCallbacks) callback.itemsLoaded();
if (interrupted()) return;
updateOrdering(ItemList.items);
ItemList.loadFinished = true;
RepairRecipeHandler.findRepairRecipesOnceParallel();
RecipeHandlerRef.clearCache();
FavoriteRecipes.reload();
SubsetWidget.updateHiddenItems();
updateFilter.restart();
warmTooltips.restart();
loadBookmarks.restart();
loadHistory.restart();
}
};
public static final RestartableTask warmTooltips = new RestartableTask("NEI Tooltip Caching") {
@Override
public void execute() {
if (!ItemList.loadFinished) return;
// Use the common pool, not ItemList.forkJoinPool, so it does not queue behind updateFilter.
ItemList.items.parallelStream().forEach(stack -> {
if (interrupted()) return;
try {
TooltipFilter.getSearchTooltip(stack);
} catch (Throwable ignored) {}
});
}
};
public static final RestartableTask loadBookmarks = new RestartableTask("NEI Bookmark Loading") {
@Override
public void execute() {
ItemPanels.bookmarkPanel.load();
}
};
public static final RestartableTask loadHistory = new RestartableTask("NEI History Loading") {
@Override
public void execute() {
ItemPanels.itemPanel.historyPanel.load();
}
};
public static final RestartableTask refreshItems = new RestartableTask("NEI Item Reordering") {
@Override
public void execute() {
if (!ItemList.loadFinished) return;
final List<ItemStack> items = new ArrayList<>(ItemList.items);
indexCollapsibleItems(items);
if (interrupted()) return;
ItemSorter.sort(items);
if (interrupted()) return;
ItemList.items = items;
updateOrdering(ItemList.items);
FavoriteRecipes.reload();
SubsetWidget.updateHiddenItems();
updateFilter.restart();
loadBookmarks.restart();
loadHistory.restart();
}
};
public static final RestartableTask updateFilter = new RestartableTask("NEI Item Filtering") {
@Override
public void execute() {
if (!ItemList.loadFinished) return;
ItemFilter filter = ItemList.getItemListFilter();
ArrayList<ItemStack> filtered;
try {
filtered = ItemList.forkJoinPool.submit(
() -> ItemList.items.parallelStream().filter(filter::matches)
.collect(Collectors.toCollection(ArrayList::new)))
.get();
} catch (InterruptedException | ExecutionException e) {
filtered = new ArrayList<>();
e.printStackTrace();
stop();
}
if (interrupted()) return;
filtered.sort(Comparator.comparingInt(ordering::get));
if (interrupted()) return;
ItemPanel.updateItemList(filtered);
}
};
}
+262 -68
View File
@@ -1,8 +1,10 @@
package codechicken.nei; package codechicken.nei;
import java.util.HashMap; import java.lang.reflect.Modifier;
import java.util.Collections;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import net.minecraft.creativetab.CreativeTabs; import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.Entity; import net.minecraft.entity.Entity;
@@ -15,21 +17,40 @@ import net.minecraft.init.Blocks;
import net.minecraft.item.Item; import net.minecraft.item.Item;
import net.minecraft.item.ItemBlock; import net.minecraft.item.ItemBlock;
import net.minecraft.item.ItemStack; import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.tileentity.TileEntityMobSpawner; import net.minecraft.tileentity.TileEntityMobSpawner;
import net.minecraft.util.EnumChatFormatting; import net.minecraft.util.EnumChatFormatting;
import net.minecraft.util.IIcon; import net.minecraft.util.IIcon;
import net.minecraft.world.World; import net.minecraft.world.World;
import net.minecraftforge.client.MinecraftForgeClient; import net.minecraftforge.client.MinecraftForgeClient;
import net.minecraftforge.common.util.ForgeDirection;
import cpw.mods.fml.relauncher.Side; import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly; import cpw.mods.fml.relauncher.SideOnly;
public class ItemMobSpawner extends ItemBlock { public class ItemMobSpawner extends ItemBlock {
private static final Map<Integer, EntityLiving> entityHashMap = new HashMap<>(); private static final Map<Integer, EntityLiving> entityHashMap = new ConcurrentHashMap<>();
private static final Map<Integer, String> IDtoNameMap = new HashMap<>(); private static final Map<Integer, String> IDtoNameMap = new ConcurrentHashMap<>();
public static int idPig; private static final Map<Class<? extends Entity>, String> ENTITY_CLASS_TO_NAME_CACHE = new ConcurrentHashMap<>();
private static boolean loaded;
public static int idPig = 90;
private static volatile boolean loaded = false;
// For asm
public static int placedX;
public static int placedY;
public static int placedZ;
public static void setLastPlacedPosition(int x, int y, int z) {
placedX = x;
placedY = y;
placedZ = z;
}
public static int[] getLastPlacedPosition() {
return new int[] { placedX, placedY, placedZ };
}
public ItemMobSpawner() { public ItemMobSpawner() {
super(Blocks.mob_spawner); super(Blocks.mob_spawner);
@@ -37,99 +58,272 @@ public class ItemMobSpawner extends ItemBlock {
MinecraftForgeClient.registerItemRenderer(this, new SpawnerRenderer()); MinecraftForgeClient.registerItemRenderer(this, new SpawnerRenderer());
} }
/**
* These are ASM translated from BlockMobSpawner
*/
public static int placedX;
public static int placedY;
public static int placedZ;
@Override @Override
public IIcon getIconFromDamage(int par1) { public IIcon getIconFromDamage(int meta) {
return Blocks.mob_spawner.getBlockTextureFromSide(0); return Blocks.mob_spawner.getBlockTextureFromSide(0);
} }
public boolean onItemUse(ItemStack itemstack, EntityPlayer entityplayer, World world, int x, int y, int z, int par7, @Override
float par8, float par9, float par10) { public boolean onItemUse(ItemStack itemstack, EntityPlayer entityplayer, World world, int x, int y, int z, int side,
if (super.onItemUse(itemstack, entityplayer, world, x, y, z, par7, par8, par9, par10) && world.isRemote) { float hitX, float hitY, float hitZ) {
TileEntityMobSpawner tileentitymobspawner = (TileEntityMobSpawner) world int targetX = x;
.getTileEntity(placedX, placedY, placedZ); int targetY = y;
if (tileentitymobspawner != null) { int targetZ = z;
setDefaultTag(itemstack);
String mobtype = IDtoNameMap.get(itemstack.getItemDamage()); if (!world.getBlock(x, y, z).isReplaceable(world, x, y, z)) {
if (mobtype != null) { ForgeDirection direction = ForgeDirection.getOrientation(side);
NEICPH.sendMobSpawnerID(placedX, placedY, placedZ, mobtype); targetX += direction.offsetX;
tileentitymobspawner.func_145881_a().setEntityName(mobtype); targetY += direction.offsetY;
targetZ += direction.offsetZ;
}
placedX = targetX;
placedY = targetY;
placedZ = targetZ;
String mobType = getMobTypeFromItemStack(itemstack);
boolean placed = super.onItemUse(itemstack, entityplayer, world, x, y, z, side, hitX, hitY, hitZ);
if (placed) {
TileEntity tileEntity = world.getTileEntity(targetX, targetY, targetZ);
if (tileEntity instanceof TileEntityMobSpawner spawner && mobType != null) {
spawner.func_145881_a().setEntityName(mobType);
if (!world.isRemote) {
world.markBlockForUpdate(targetX, targetY, targetZ);
NEICPH.sendMobSpawnerID(targetX, targetY, targetZ, mobType);
} }
} }
return true; return true;
} }
return false; return false;
} }
private String getMobTypeFromItemStack(ItemStack stack) {
int meta = getValidMetaData(stack);
return IDtoNameMap.get(meta);
}
private int getValidMetaData(ItemStack stack) {
int meta = stack.getItemDamage();
if (meta == 0 || !IDtoNameMap.containsKey(meta)) {
return idPig;
}
return meta;
}
@SideOnly(Side.CLIENT) @SideOnly(Side.CLIENT)
@Override @Override
public void addInformation(ItemStack itemstack, EntityPlayer par2EntityPlayer, List<String> list, boolean par4) { public void addInformation(ItemStack itemstack, EntityPlayer player, List<String> tooltip, boolean advanced) {
setDefaultTag(itemstack); int meta = getValidMetaData(itemstack);
int meta = itemstack.getItemDamage(); EntityLiving entity = getEntity(meta);
if (meta == 0) { String mobName = IDtoNameMap.get(meta);
meta = idPig;
if (entity != null && mobName != null) {
EnumChatFormatting color = (entity instanceof IMob) ? EnumChatFormatting.DARK_RED
: EnumChatFormatting.DARK_AQUA;
tooltip.add(color + mobName);
} }
Entity e = getEntity(meta);
list.add(
(e instanceof IMob ? EnumChatFormatting.DARK_RED : EnumChatFormatting.DARK_AQUA)
+ IDtoNameMap.get(meta));
} }
public static EntityLiving getEntity(int ID) { public static EntityLiving getEntity(int id) {
EntityLiving e = entityHashMap.get(ID); EntityLiving cached = entityHashMap.get(id);
if (e == null) { if (cached != null) {
loadSpawners(); return cached;
Class<?> clazz = EntityList.IDtoClassMapping.get(ID);
World world = NEIClientUtils.mc().theWorld;
try {
e = (EntityLiving) clazz.getConstructor(new Class[] { World.class }).newInstance(world);
} catch (Throwable t) {
if (clazz == null)
NEIClientConfig.logger.error("Null class for entity (" + ID + ", " + IDtoNameMap.get(ID));
else NEIClientConfig.logger.error("Error creating instance of entity: " + clazz.getName(), t);
e = getEntity(idPig);
}
entityHashMap.put(ID, e);
} }
return e;
loadSpawners();
Class<?> entityClass = EntityList.IDtoClassMapping.get(id);
World world = NEIClientUtils.mc() != null ? NEIClientUtils.mc().theWorld : null;
if (isInvalidEntityClass(entityClass)) {
return cacheFallback(id);
}
EntityLiving entity = createEntityInstance(entityClass, world, id);
if (entity != null) {
entityHashMap.put(id, entity);
}
return entity;
}
private static boolean isInvalidEntityClass(Class<?> entityClass) {
if (entityClass == null) {
return true;
}
int modifiers = entityClass.getModifiers();
if (Modifier.isAbstract(modifiers) || Modifier.isInterface(modifiers)) {
NEIClientConfig.logger.warn("Skipping abstract/interface entity class: {}", entityClass.getName());
return true;
}
if (!EntityLiving.class.isAssignableFrom(entityClass)) {
NEIClientConfig.logger.warn("Skipping non-EntityLiving class: {}", entityClass.getName());
return true;
}
return false;
}
@SuppressWarnings("unchecked")
private static EntityLiving createEntityInstance(Class<?> entityClass, World world, int id) {
if (entityClass == null || world == null) {
NEIClientConfig.logger.debug("World or entity class is null, using fallback for ID: {}", id);
return getFallbackEntity(id);
}
try {
Class<? extends EntityLiving> livingClass = (Class<? extends EntityLiving>) entityClass;
return livingClass.getConstructor(World.class).newInstance(world);
} catch (Throwable t) {
logEntityCreationError(entityClass, id, t);
return getFallbackEntity(id);
}
}
private static void logEntityCreationError(Class<?> entityClass, int id, Throwable t) {
String entityName = IDtoNameMap.getOrDefault(id, "unknown");
if (entityClass == null) {
NEIClientConfig.logger
.error("Failed to create entity instance: Class is null for ID {}, Name {}", id, entityName, t);
} else {
NEIClientConfig.logger.error(
"Failed to create instance of entity: Class {}, ID {}, Name {}",
entityClass.getName(),
id,
entityName,
t);
}
}
private static EntityLiving cacheFallback(int id) {
EntityLiving fallback = getFallbackEntity(id);
if (fallback != null) {
entityHashMap.put(id, fallback);
}
return fallback;
}
private static EntityLiving getFallbackEntity(int originalId) {
EntityLiving pig = entityHashMap.get(idPig);
if (pig == null) {
World world = NEIClientUtils.mc() != null ? NEIClientUtils.mc().theWorld : null;
if (world != null) {
try {
pig = new EntityPig(world);
entityHashMap.put(idPig, pig);
NEIClientConfig.logger.debug("Created fallback pig entity for ID: {}", originalId);
} catch (Exception e) {
NEIClientConfig.logger
.error("Failed to create fallback pig entity for original ID: {}", originalId, e);
}
} else {
NEIClientConfig.logger.warn("World is null, cannot create fallback entity for ID: {}", originalId);
}
}
return pig;
} }
public static void clearEntityReferences() { public static void clearEntityReferences() {
entityHashMap.clear(); entityHashMap.clear();
} NEIClientConfig.logger.debug("Cleared all entity references from cache");
private void setDefaultTag(ItemStack itemstack) {
if (!IDtoNameMap.containsKey(itemstack.getItemDamage())) itemstack.setItemDamage(idPig);
} }
public static void loadSpawners() { public static void loadSpawners() {
if (loaded) return; if (loaded) {
loaded = true; return;
for (Map.Entry<Class<? extends Entity>, String> entry : EntityList.classToStringMapping.entrySet()) { }
final Class<? extends Entity> clazz = entry.getKey();
if (EntityLiving.class.isAssignableFrom(clazz)) { synchronized (ItemMobSpawner.class) {
Integer id = (Integer) EntityList.classToIDMapping.get(clazz); try {
if (id == null) continue; for (Map.Entry<Class<? extends Entity>, String> entry : EntityList.classToStringMapping.entrySet()) {
String name = entry.getValue();
if (name == null) continue; Class<? extends Entity> clazz = entry.getKey();
if (name.equals("EnderDragon")) continue; String name = entry.getValue();
if (name.equals("Pig")) idPig = id;
if (clazz != EntityPig.class || name.equals("Pig")) { if (shouldRegisterEntity(clazz, name)) {
IDtoNameMap.put(id, name); Integer id = (Integer) EntityList.classToIDMapping.get(clazz);
if (id != null) {
IDtoNameMap.put(id, name);
ENTITY_CLASS_TO_NAME_CACHE.put(clazz, name);
if ("Pig".equals(name)) {
idPig = id;
NEIClientConfig.logger.debug("Set pig entity ID to: {}", id);
}
}
}
} }
loaded = true;
NEIClientConfig.logger.info("Loaded {} spawner entity mappings", IDtoNameMap.size());
} catch (Exception e) {
NEIClientConfig.logger.error("Error loading spawners from entity list", e);
} }
} }
} }
private static boolean shouldRegisterEntity(Class<? extends Entity> clazz, String name) {
if (clazz == null || name == null || name.trim().isEmpty()) {
return false;
}
if (!EntityLiving.class.isAssignableFrom(clazz)) {
return false;
}
if ("EnderDragon".equals(name) || "Giant".equals(name)) {
return false;
}
return true;
}
@Override @Override
public void getSubItems(Item item, CreativeTabs tab, List<ItemStack> list) { public void getSubItems(Item item, CreativeTabs tab, List<ItemStack> list) {
if (!NEIClientConfig.hasSMPCounterPart()) list.add(new ItemStack(item)); if (!NEIClientConfig.hasSMPCounterPart()) {
else for (int i : IDtoNameMap.keySet()) list.add(new ItemStack(item, 1, i)); list.add(new ItemStack(item));
} else {
loadSpawners();
for (int id : IDtoNameMap.keySet()) {
ItemStack stack = new ItemStack(item, 1, id);
list.add(stack);
}
}
}
public static String getEntityNameForMeta(int meta) {
loadSpawners();
return IDtoNameMap.getOrDefault(meta, IDtoNameMap.getOrDefault(idPig, "Pig"));
}
public static boolean isValidEntityMeta(int meta) {
loadSpawners();
return IDtoNameMap.containsKey(meta) || meta == 0;
}
public static Map<Integer, String> getRegisteredSpawnerEntities() {
loadSpawners();
return Collections.unmodifiableMap(IDtoNameMap);
}
public static boolean isEntityValidForSpawner(Class<? extends Entity> entityClass) {
if (entityClass == null) return false;
String name = ENTITY_CLASS_TO_NAME_CACHE.get(entityClass);
if (name == null) {
name = EntityList.classToStringMapping.get(entityClass);
}
return name != null && shouldRegisterEntity(entityClass, name);
} }
} }
+69 -34
View File
@@ -8,6 +8,7 @@ import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.item.ItemStack; import net.minecraft.item.ItemStack;
import codechicken.lib.gui.GuiDraw; import codechicken.lib.gui.GuiDraw;
import codechicken.lib.vec.Rectangle4i;
import codechicken.nei.ItemsPanelGrid.ItemsPanelGridSlot; import codechicken.nei.ItemsPanelGrid.ItemsPanelGridSlot;
import codechicken.nei.util.NEIMouseUtils; import codechicken.nei.util.NEIMouseUtils;
@@ -32,7 +33,8 @@ public class ItemPanel extends PanelWidget<ItemsPanelGrid> {
} }
public ItemHistoryPanel historyPanel = new ItemHistoryPanel(); public ItemHistoryPanel historyPanel = new ItemHistoryPanel();
public Button toggleGroups; public ItemCraftablesPanel craftablesPanel = new ItemCraftablesPanel();
protected Button toggleGroups;
@Deprecated @Deprecated
public static class ItemPanelSlot extends ItemsPanelGridSlot { public static class ItemPanelSlot extends ItemsPanelGridSlot {
@@ -83,6 +85,11 @@ public class ItemPanel extends PanelWidget<ItemsPanelGrid> {
toggleGroups = new Button("G") { toggleGroups = new Button("G") {
@Override
public String getRenderLabel() {
return NEIClientUtils.translate("itempanel.collapsed.button");
}
@Override @Override
public String getButtonTip() { public String getButtonTip() {
return NEIClientUtils.translate("itempanel.collapsed.button.tip"); return NEIClientUtils.translate("itempanel.collapsed.button.tip");
@@ -108,24 +115,29 @@ public class ItemPanel extends PanelWidget<ItemsPanelGrid> {
return String.format("%d/%d", getPage(), Math.max(1, getNumPages())); return String.format("%d/%d", getPage(), Math.max(1, getNumPages()));
} }
protected String getPositioningSettingName() { @Override
return "world.panels.items"; public Rectangle4i calculateBounds(GuiContainer gui) {
} final int maxWidth = (gui.width - 176) / 2 - PADDING * 2;
final int maxHeight = gui.height - PADDING * 2;
final int freeSpace = (gui.width - gui.xSize) / 2 - PADDING * 2;
public int getMarginLeft(GuiContainer gui) { final int paddingLeft = (int) Math
return (gui.width + gui.xSize) / 2 + PADDING; .ceil(maxWidth * NEIClientConfig.getSetting("world.panels.items.left").getIntValue() / 100000.0);
} final int paddingTop = (int) Math
.ceil(maxHeight * NEIClientConfig.getSetting("world.panels.items.top").getIntValue() / 100000.0);
final int paddingRight = (int) Math
.ceil(maxWidth * NEIClientConfig.getSetting("world.panels.items.right").getIntValue() / 100000.0);
final int paddingBottom = (int) Math
.ceil(maxHeight * NEIClientConfig.getSetting("world.panels.items.bottom").getIntValue() / 100000.0);
public int getMarginTop(GuiContainer gui) { final int width = Math.max(
return PADDING; ItemsGrid.SLOT_SIZE,
} snapDownToMultiple(
Math.min(freeSpace - paddingRight, maxWidth - paddingLeft - paddingRight),
ItemsGrid.SLOT_SIZE));
final int height = Math.max(ItemsGrid.SLOT_SIZE, maxHeight - paddingTop - paddingBottom);
public int getWidth(GuiContainer gui) { return new Rectangle4i(gui.width - width - PADDING - paddingRight, paddingTop + PADDING, width, height);
return gui.width - (gui.xSize + gui.width) / 2 - PADDING * 2;
}
public int getHeight(GuiContainer gui) {
return gui.height - getMarginTop(gui) - PADDING;
} }
@Override @Override
@@ -141,26 +153,38 @@ public class ItemPanel extends PanelWidget<ItemsPanelGrid> {
} }
protected int resizeFooter(GuiContainer gui) { protected int resizeFooter(GuiContainer gui) {
if (!NEIClientConfig.showItemQuantityWidget() && NEIClientConfig.isSearchWidgetCentered() int footerY = y + h;
&& !NEIClientConfig.showHistoryPanelWidget()) { int footerHeight = 0;
if (grid.getPerPage() == 0) {
return 0; return 0;
} }
if (NEIClientConfig.showItemQuantityWidget() || !NEIClientConfig.isSearchWidgetCentered()) {
footerY = LayoutManager.quantity.y;
footerHeight = LayoutManager.quantity.h + PanelWidget.PADDING;
}
if (NEIClientConfig.showHistoryPanelWidget()) { if (NEIClientConfig.showHistoryPanelWidget()) {
historyPanel.x = x; historyPanel.x = x;
historyPanel.w = w;
historyPanel.h = 8 + ItemsGrid.SLOT_SIZE * NEIClientConfig.getIntSetting("inventory.history.useRows");
if (NEIClientConfig.showItemQuantityWidget() || !NEIClientConfig.isSearchWidgetCentered()) { if (historyPanel.setPanelWidth(w) != 0) {
historyPanel.y = LayoutManager.quantity.y - historyPanel.h - PanelWidget.PADDING; footerY = historyPanel.y = footerY - historyPanel.h;
return LayoutManager.quantity.h + historyPanel.h + PanelWidget.PADDING * 2; footerHeight += historyPanel.h;
} else { }
historyPanel.y = y + h - historyPanel.h;
return historyPanel.h + PanelWidget.PADDING; }
if (NEIClientConfig.showCraftablesPanelWidget()) {
craftablesPanel.x = x;
if (craftablesPanel.setPanelWidth(w) != 0) {
footerY = craftablesPanel.y = footerY - craftablesPanel.h;
footerHeight += craftablesPanel.h;
} }
} }
return LayoutManager.quantity.h + PanelWidget.PADDING; return footerHeight;
} }
@Override @Override
@@ -168,20 +192,27 @@ public class ItemPanel extends PanelWidget<ItemsPanelGrid> {
super.setVisible(); super.setVisible();
if (grid.getPerPage() > 0) { if (grid.getPerPage() > 0) {
if (!CollapsibleItems.isEmpty() && !grid.isEmpty()) { if (!CollapsibleItems.isEmpty() && !grid.isEmpty()) {
LayoutManager.addWidget(toggleGroups); LayoutManager.addWidget(toggleGroups);
} }
if (NEIClientConfig.showHistoryPanelWidget() && (!grid.isEmpty() || !historyPanel.isEmpty())) { if (NEIClientConfig.showCraftablesPanelWidget()) {
LayoutManager.addWidget(craftablesPanel);
}
if (NEIClientConfig.showHistoryPanelWidget()) {
LayoutManager.addWidget(historyPanel); LayoutManager.addWidget(historyPanel);
} }
} }
} }
@Override @Override
public void resize(GuiContainer gui) { public void resize(GuiContainer gui) {
super.resize(gui); super.resize(gui);
historyPanel.resize(gui); this.historyPanel.resize(gui);
this.craftablesPanel.resize(gui);
} }
protected ItemStack getDraggedStackWithQuantity(ItemStack itemStack) { protected ItemStack getDraggedStackWithQuantity(ItemStack itemStack) {
@@ -189,8 +220,7 @@ public class ItemPanel extends PanelWidget<ItemsPanelGrid> {
} }
@Override @Override
public List<String> handleItemTooltip(GuiContainer gui, ItemStack itemstack, int mousex, int mousey, public List<String> handleItemTooltip(ItemStack itemstack, int mousex, int mousey, List<String> currenttip) {
List<String> currenttip) {
if (!this.grid.forceExpand && !currenttip.isEmpty()) { if (!this.grid.forceExpand && !currenttip.isEmpty()) {
final ItemsPanelGridSlot hoverSlot = this.grid.getSlotMouseOver(mousex, mousey); final ItemsPanelGridSlot hoverSlot = this.grid.getSlotMouseOver(mousex, mousey);
@@ -204,7 +234,7 @@ public class ItemPanel extends PanelWidget<ItemsPanelGrid> {
} }
} }
return super.handleItemTooltip(gui, itemstack, mousex, mousey, currenttip); return super.handleItemTooltip(itemstack, mousex, mousey, currenttip);
} }
@Override @Override
@@ -225,7 +255,7 @@ public class ItemPanel extends PanelWidget<ItemsPanelGrid> {
} }
@Override @Override
public Map<String, String> handleHotkeys(GuiContainer gui, int mousex, int mousey, Map<String, String> hotkeys) { public Map<String, String> handleHotkeys(int mousex, int mousey, Map<String, String> hotkeys) {
final ItemsPanelGridSlot hoverSlot = this.grid.getSlotMouseOver(mousex, mousey); final ItemsPanelGridSlot hoverSlot = this.grid.getSlotMouseOver(mousex, mousey);
if (!this.grid.forceExpand && hoverSlot != null && hoverSlot.groupIndex >= 0 && hoverSlot.groupSize > 1) { if (!this.grid.forceExpand && hoverSlot != null && hoverSlot.groupIndex >= 0 && hoverSlot.groupSize > 1) {
@@ -236,7 +266,12 @@ public class ItemPanel extends PanelWidget<ItemsPanelGrid> {
NEIClientUtils.translate(message, hoverSlot.groupSize)); NEIClientUtils.translate(message, hoverSlot.groupSize));
} }
return hotkeys; return super.handleHotkeys(mousex, mousey, hotkeys);
}
public boolean containsWithSubpanels(int px, int py) {
return contains(px, py) || NEIClientConfig.showHistoryPanelWidget() && this.historyPanel.contains(px, py)
|| NEIClientConfig.showCraftablesPanelWidget() && this.craftablesPanel.contains(px, py);
} }
} }
@@ -83,11 +83,7 @@ public class ItemQuantityField extends TextField {
} }
if (amount == 0) { if (amount == 0) {
amount = NEIClientConfig.showItemQuantityWidget() ? NEIClientConfig.getItemQuantity() : 0; amount = NEIClientUtils.getScrollMultiplier(stack);
if (amount == 0) {
amount = StackInfo.itemStackToNBT(stack).hasKey("gtFluidName") ? 144 : stack.getMaxStackSize();
}
} }
return StackInfo.withAmount(stack, amount); return StackInfo.withAmount(stack, amount);
@@ -118,14 +118,7 @@ public class ItemSorter implements Comparator<ItemStack> {
return name1.compareTo(name2); return name1.compareTo(name2);
}); });
tag.getTag("inventory.itemsort").setDefaultValue(getSaveString(list)); tag.getTag("inventory.itemsort").setDefaultValue(getSaveString(list));
API.addOption(new OptionOpenGui("inventory.itemsort", GuiItemSorter.class) { API.addOption(new OptionOpenGui("inventory.itemsort", GuiItemSorter.class));
@Override
public void useGlobals() {
super.useGlobals();
list = fromSaveString(activeTag().getValue());
}
});
} }
public static String getSaveString(List<SortEntry> list) { public static String getSaveString(List<SortEntry> list) {
@@ -104,6 +104,16 @@ public class ItemStackAmount {
return this.itemMap.isEmpty(); return this.itemMap.isEmpty();
} }
@Override
public boolean equals(Object obj) {
if (obj instanceof ItemStackAmount items) {
return this.itemMap.equals(items.itemMap);
}
return false;
}
public static ItemStackAmount of(ItemStackAmount map) { public static ItemStackAmount of(ItemStackAmount map) {
ItemStackAmount result = new ItemStackAmount(); ItemStackAmount result = new ItemStackAmount();
result.itemMap.putAll(map.itemMap); result.itemMap.putAll(map.itemMap);
@@ -46,8 +46,7 @@ public class ItemStackMap<T> {
} }
public boolean equals(Object o) { public boolean equals(Object o) {
if (!(o instanceof StackMetaKey)) return false; if (!(o instanceof StackMetaKey t)) return false;
StackMetaKey t = (StackMetaKey) o;
return damage == t.damage && Objects.equal(tag, t.tag); return damage == t.damage && Objects.equal(tag, t.tag);
} }
} }
@@ -218,8 +217,7 @@ public class ItemStackMap<T> {
public void put(ItemStack key, T value) { public void put(ItemStack key, T value) {
if (key == null || key.getItem() == null) return; if (key == null || key.getItem() == null) return;
DetailMap map = itemMap.get(key.getItem()); DetailMap map = itemMap.computeIfAbsent(key.getItem(), k -> new DetailMap());
if (map == null) itemMap.put(key.getItem(), map = new DetailMap());
map.put(key, value); map.put(key, value);
} }
+42 -10
View File
@@ -42,7 +42,7 @@ public class ItemZoom extends Widget implements IContainerInputHandler {
if (this.stack != null && this.availableAreaWidth >= SLOT_SIZE * 2 if (this.stack != null && this.availableAreaWidth >= SLOT_SIZE * 2
&& (NEIClientConfig.getBooleanSetting("inventory.itemzoom.enabled") && (NEIClientConfig.getBooleanSetting("inventory.itemzoom.enabled")
|| NEIClientConfig.isKeyHashDown("gui.itemzoom_hold")) || KeyManager.isKeyDown("itemzoom.hold"))
&& GuiContainerManager.shouldShowTooltip(NEIClientUtils.getGuiContainer())) { && GuiContainerManager.shouldShowTooltip(NEIClientUtils.getGuiContainer())) {
final float inverseScaleFactor = 1.0f / this.scale; final float inverseScaleFactor = 1.0f / this.scale;
final float screenScale = getScreenScale(); final float screenScale = getScreenScale();
@@ -58,7 +58,7 @@ public class ItemZoom extends Widget implements IContainerInputHandler {
GL11.glPopMatrix(); GL11.glPopMatrix();
GL11.glPushAttrib(GL11.GL_ALL_ATTRIB_BITS); GL11.glPushAttrib(GL11.GL_ENABLE_BIT | GL11.GL_COLOR_BUFFER_BIT | GL11.GL_LIGHTING_BIT);
GuiContainerManager.enable2DRender(); GuiContainerManager.enable2DRender();
if (NEIClientConfig.getBooleanSetting("inventory.itemzoom.showName")) { if (NEIClientConfig.getBooleanSetting("inventory.itemzoom.showName")) {
@@ -74,7 +74,7 @@ public class ItemZoom extends Widget implements IContainerInputHandler {
if (NEIClientConfig.getBooleanSetting("inventory.itemzoom.enabled") if (NEIClientConfig.getBooleanSetting("inventory.itemzoom.enabled")
&& NEIClientConfig.getBooleanSetting("inventory.itemzoom.helpText")) { && NEIClientConfig.getBooleanSetting("inventory.itemzoom.helpText")) {
String keyName = NEIClientConfig.getKeyName("gui.itemzoom_toggle"); String keyName = KeyManager.getKeyName("itemzoom.toggle", NEIClientUtils.SHIFT_HASH);
if (keyName != null) { if (keyName != null) {
String helpText = NEIClientUtils.translate("itemzoom.toggle", keyName); String helpText = NEIClientUtils.translate("itemzoom.toggle", keyName);
@@ -111,8 +111,14 @@ public class ItemZoom extends Widget implements IContainerInputHandler {
this.xPosition = (availableAreaWidth - this.scale * SLOT_SIZE) / 2; this.xPosition = (availableAreaWidth - this.scale * SLOT_SIZE) / 2;
this.availableAreaWidth = (int) (availableAreaWidth / screenScale); this.availableAreaWidth = (int) (availableAreaWidth / screenScale);
if (availableAreaWidth / screenScale >= mouse.x) { final float rightSideShift = gui.width * screenScale - availableAreaWidth;
this.xPosition += gui.width * screenScale - availableAreaWidth; final boolean leftSideFree = availableAreaWidth / screenScale < mouse.x;
final boolean rightSideFree = mouse.x < gui.width - availableAreaWidth / screenScale;
final boolean showOnRight = leftSideFree && rightSideFree ? !preferLeftSide() : !leftSideFree;
if (showOnRight) {
this.xPosition += rightSideShift;
} }
try { try {
@@ -121,13 +127,34 @@ public class ItemZoom extends Widget implements IContainerInputHandler {
this.displayName = "Unnamed"; this.displayName = "Unnamed";
} }
this.stack = StackInfo.loadFromNBT(StackInfo.itemStackToNBT(stack), 0); // Copying the stack copies its whole NBT, so it is only done when the hovered stack changes
final boolean sameStack = this.stack != null && this.stack.isItemEqual(stack)
&& ItemStack.areItemStackTagsEqual(this.stack, stack);
if (!sameStack) {
this.stack = StackInfo.withAmount(stack, 0);
}
} else { } else {
this.stack = null; this.stack = null;
this.displayName = ""; this.displayName = "";
} }
} }
private boolean preferLeftSide() {
switch (NEIClientConfig.getIntSetting("inventory.itemzoom.preferredSide")) {
case 1:
return true;
case 2:
return false;
}
final int leftCount = NEIClientConfig.isBookmarkPanelHidden()
|| ItemPanels.bookmarkPanel.getGrid().getPerPage() == 0 ? 0 : ItemPanels.bookmarkPanel.getGrid().size();
final int rightCount = ItemPanels.itemPanel.getGrid().getPerPage() == 0 ? 0
: ItemPanels.itemPanel.getGrid().size();
return leftCount <= rightCount;
}
private float getPointSize(GuiContainer gui) { private float getPointSize(GuiContainer gui) {
final float screenScale = 1.0f / getScreenScale(); final float screenScale = 1.0f / getScreenScale();
final float availableAreaWidth = (gui.width - (gui.xSize + gui.width) / 2) * screenScale; final float availableAreaWidth = (gui.width - (gui.xSize + gui.width) / 2) * screenScale;
@@ -197,25 +224,30 @@ public class ItemZoom extends Widget implements IContainerInputHandler {
@Override @Override
public boolean lastKeyTyped(GuiContainer gui, char keyChar, int keyID) { public boolean lastKeyTyped(GuiContainer gui, char keyChar, int keyID) {
return false;
}
if (NEIClientConfig.isKeyHashDown("gui.itemzoom_toggle")) { @Override
public boolean onHotkeyPressed(GuiContainer gui) {
if (KeyManager.isHashDown("itemzoom.toggle", NEIClientUtils.SHIFT_HASH)) {
NEIClientConfig.getSetting("inventory.itemzoom.enabled") NEIClientConfig.getSetting("inventory.itemzoom.enabled")
.setBooleanValue(!NEIClientConfig.getBooleanSetting("inventory.itemzoom.enabled")); .setBooleanValue(!NEIClientConfig.getBooleanSetting("inventory.itemzoom.enabled"));
return true; return true;
} }
if (this.stack != null && NEIClientConfig.isKeyHashDown("gui.itemzoom_hold")) { if (this.stack != null && KeyManager.isKeyDown("itemzoom.hold")) {
return true; return true;
} }
if (this.stack != null && NEIClientConfig.isKeyHashDown("gui.itemzoom_zoom_in")) { if (this.stack != null && KeyManager.isKeyDown("itemzoom.zoom_in")) {
increaseZoom(gui); increaseZoom(gui);
previousKeyboardRepeatEnabled = Keyboard.areRepeatEventsEnabled(); previousKeyboardRepeatEnabled = Keyboard.areRepeatEventsEnabled();
Keyboard.enableRepeatEvents(true); Keyboard.enableRepeatEvents(true);
return true; return true;
} }
if (this.stack != null && NEIClientConfig.isKeyHashDown("gui.itemzoom_zoom_out")) { if (this.stack != null && KeyManager.isKeyDown("itemzoom.zoom_out")) {
decreaseZoom(gui); decreaseZoom(gui);
previousKeyboardRepeatEnabled = Keyboard.areRepeatEventsEnabled(); previousKeyboardRepeatEnabled = Keyboard.areRepeatEventsEnabled();
Keyboard.enableRepeatEvents(true); Keyboard.enableRepeatEvents(true);
+46 -52
View File
@@ -19,7 +19,9 @@ import org.lwjgl.opengl.GL30;
import codechicken.lib.vec.Rectangle4i; import codechicken.lib.vec.Rectangle4i;
import codechicken.nei.api.GuiInfo; import codechicken.nei.api.GuiInfo;
import codechicken.nei.api.INEIGuiHandler;
import codechicken.nei.guihook.GuiContainerManager; import codechicken.nei.guihook.GuiContainerManager;
import codechicken.nei.recipe.Recipe.RecipeId;
import codechicken.nei.recipe.StackInfo; import codechicken.nei.recipe.StackInfo;
public abstract class ItemsGrid<T extends ItemsGrid.ItemsGridSlot, M extends ItemsGrid.MouseContext> { public abstract class ItemsGrid<T extends ItemsGrid.ItemsGridSlot, M extends ItemsGrid.MouseContext> {
@@ -27,7 +29,7 @@ public abstract class ItemsGrid<T extends ItemsGrid.ItemsGridSlot, M extends Ite
protected static class ScreenCapture { protected static class ScreenCapture {
private long nextCacheRefresh = 0; private long nextCacheRefresh = 0;
private Framebuffer framebuffer; private final Framebuffer framebuffer;
public ScreenCapture() { public ScreenCapture() {
this.framebuffer = new Framebuffer(1, 1, true); this.framebuffer = new Framebuffer(1, 1, true);
@@ -51,7 +53,7 @@ public abstract class ItemsGrid<T extends ItemsGrid.ItemsGridSlot, M extends Ite
} }
public void captureScreen(Runnable callback, int mode) { public void captureScreen(Runnable callback, int mode) {
GL11.glPushAttrib(GL11.GL_ALL_ATTRIB_BITS); GL11.glPushAttrib(GL11.GL_ENABLE_BIT);
resetFramebuffer(); resetFramebuffer();
this.framebuffer.bindFramebuffer(false); this.framebuffer.bindFramebuffer(false);
@@ -85,7 +87,7 @@ public abstract class ItemsGrid<T extends ItemsGrid.ItemsGridSlot, M extends Ite
this.framebuffer.framebufferClear(); this.framebuffer.framebufferClear();
} }
// copy depth buffer from MC (fix Angelica) // Copy stencil values (required by mui2)
OpenGlHelper.func_153171_g(GL30.GL_READ_FRAMEBUFFER, minecraft.getFramebuffer().framebufferObject); OpenGlHelper.func_153171_g(GL30.GL_READ_FRAMEBUFFER, minecraft.getFramebuffer().framebufferObject);
OpenGlHelper.func_153171_g(GL30.GL_DRAW_FRAMEBUFFER, this.framebuffer.framebufferObject); OpenGlHelper.func_153171_g(GL30.GL_DRAW_FRAMEBUFFER, this.framebuffer.framebufferObject);
GL30.glBlitFramebuffer( GL30.glBlitFramebuffer(
@@ -171,6 +173,10 @@ public abstract class ItemsGrid<T extends ItemsGrid.ItemsGridSlot, M extends Ite
public <M extends MouseContext> void afterDraw(Rectangle4i rect, M mouseContext) {} public <M extends MouseContext> void afterDraw(Rectangle4i rect, M mouseContext) {}
public RecipeId getRecipeId() {
return null;
}
public void drawItem(Rectangle4i rect) { public void drawItem(Rectangle4i rect) {
drawItem(getItemStack(), rect); drawItem(getItemStack(), rect);
} }
@@ -276,7 +282,7 @@ public abstract class ItemsGrid<T extends ItemsGrid.ItemsGridSlot, M extends Ite
protected boolean[] invalidSlotMap; protected boolean[] invalidSlotMap;
protected Label messageLabel = new Label(getMessageOnEmpty(), true); private final GridOverlapScanner overlapScanner = new GridOverlapScanner();
protected ScreenCapture screenCapture = null; protected ScreenCapture screenCapture = null;
@@ -345,19 +351,25 @@ public abstract class ItemsGrid<T extends ItemsGrid.ItemsGridSlot, M extends Ite
} }
public void setGridSize(int mleft, int mtop, int w, int h) { public void setGridSize(int mleft, int mtop, int w, int h) {
final int newWidth = Math.max(0, w);
final int newHeight = Math.max(0, h);
final boolean changed = marginLeft != mleft || marginTop != mtop || width != newWidth || height != newHeight;
marginLeft = mleft; marginLeft = mleft;
marginTop = mtop; marginTop = mtop;
width = Math.max(0, w); width = newWidth;
height = Math.max(0, h); height = newHeight;
columns = width / SLOT_SIZE; this.columns = newWidth / SLOT_SIZE;
rows = height / SLOT_SIZE; this.rows = newHeight / SLOT_SIZE;
paddingLeft = (width % SLOT_SIZE) / 2; paddingLeft = (width % SLOT_SIZE) / 2;
messageLabel.x = marginLeft + width / 2; if (changed) {
messageLabel.y = marginTop + height / 2; this.overlapScanner.invalidate();
onGridChanged();
}
} }
public void shiftPage(int shift) { public void shiftPage(int shift) {
@@ -396,51 +408,42 @@ public abstract class ItemsGrid<T extends ItemsGrid.ItemsGridSlot, M extends Ite
} }
public void refresh(GuiContainer gui) { public void refresh(GuiContainer gui) {
updateGuiOverlapSlots(gui); if (this.overlapScanner.shouldRefresh()) {
updateGuiOverlapSlots(gui);
}
shiftPage(0); shiftPage(0);
} }
protected void updateGuiOverlapSlots(GuiContainer gui) { protected void updateGuiOverlapSlots(GuiContainer gui) {
final boolean[] oldSlotMap = invalidSlotMap; final boolean[] oldSlotMap = this.invalidSlotMap;
final int oldRows = rows; final int size = this.rows * this.columns;
final int oldColumns = columns; final boolean[] slotMap = new boolean[size];
invalidSlotMap = new boolean[rows * columns]; this.perPage = size;
perPage = columns * rows;
if (gui != null) { if (gui != null && size > 0) {
if (NEIClientConfig.optimizeGuiOverlapComputation()) { final INEIGuiHandler[] handlers = GuiInfo.getGuiHandlersSnapshot();
checkGuiOverlap(gui, 0, columns - 2, 1); final Rectangle4i origin = getSlotRect(0, 0);
checkGuiOverlap(gui, columns - 1, 1, -1);
} else { this.perPage -= this.overlapScanner.scan(
checkGuiOverlap(gui, 0, columns, 1); rect -> GuiInfo.hideItemPanelSlot(gui, rect, handlers),
} origin.x,
origin.y,
SLOT_SIZE,
this.rows,
this.columns,
origin.x + this.columns * SLOT_SIZE > gui.guiLeft,
origin.x < gui.guiLeft + gui.xSize,
slotMap);
} }
if (oldRows != rows || oldColumns != columns || !Arrays.equals(oldSlotMap, invalidSlotMap)) { this.invalidSlotMap = slotMap;
if (!Arrays.equals(oldSlotMap, slotMap)) {
onGridChanged(); onGridChanged();
} }
} }
private void checkGuiOverlap(GuiContainer gui, int start, int end, int dir) {
boolean validColumn = false;
for (int c = start; c != end && (!NEIClientConfig.optimizeGuiOverlapComputation() || !validColumn); c += dir) {
validColumn = true;
for (int r = 0; r < rows; r++) {
final int idx = columns * r + c;
if (idx >= 0 && idx < invalidSlotMap.length
&& !invalidSlotMap[idx]
&& GuiInfo.hideItemPanelSlot(gui, getSlotRect(r, c))) {
invalidSlotMap[idx] = true;
validColumn = false;
perPage--;
}
}
}
}
public T getSlotMouseOver(int mousex, int mousey) { public T getSlotMouseOver(int mousex, int mousey) {
if (!contains(mousex, mousey)) { if (!contains(mousex, mousey)) {
return null; return null;
@@ -561,12 +564,6 @@ public abstract class ItemsGrid<T extends ItemsGrid.ItemsGridSlot, M extends Ite
afterDrawItems(mousex, mousey, mouseContext); afterDrawItems(mousex, mousey, mouseContext);
} }
public void setVisible() {
if (getItems().isEmpty() && getMessageOnEmpty() != null) {
LayoutManager.addWidget(messageLabel);
}
}
public boolean contains(int px, int py) { public boolean contains(int px, int py) {
final Rectangle4i rect = new Rectangle4i( final Rectangle4i rect = new Rectangle4i(
marginLeft + paddingLeft, marginLeft + paddingLeft,
@@ -581,7 +578,4 @@ public abstract class ItemsGrid<T extends ItemsGrid.ItemsGridSlot, M extends Ite
return !isInvalidSlot(columns * getRowIndex(py) + getColumnIndex(px)); return !isInvalidSlot(columns * getRowIndex(py) + getColumnIndex(px));
} }
public String getMessageOnEmpty() {
return null;
}
} }
@@ -11,9 +11,11 @@ import java.util.Set;
import net.minecraft.client.gui.inventory.GuiContainer; import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.item.ItemStack; import net.minecraft.item.ItemStack;
import codechicken.lib.gui.GuiDraw;
import codechicken.lib.vec.Rectangle4i; import codechicken.lib.vec.Rectangle4i;
import codechicken.nei.ItemsGrid.ItemsGridSlot; import codechicken.nei.ItemsGrid.ItemsGridSlot;
import codechicken.nei.guihook.GuiContainerManager; import codechicken.nei.guihook.GuiContainerManager;
import codechicken.nei.recipe.Recipe.RecipeId;
public class ItemsPanelGrid extends ItemsGrid<ItemsPanelGrid.ItemsPanelGridSlot, ItemsPanelGrid.MouseContext> { public class ItemsPanelGrid extends ItemsGrid<ItemsPanelGrid.ItemsPanelGridSlot, ItemsPanelGrid.MouseContext> {
@@ -37,6 +39,11 @@ public class ItemsPanelGrid extends ItemsGrid<ItemsPanelGrid.ItemsPanelGridSlot,
return this.bgItemStack; return this.bgItemStack;
} }
@Override
public RecipeId getRecipeId() {
return FavoriteRecipes.getFavorite(this.item);
}
@Override @Override
public void beforeDraw(Rectangle4i rect, MouseContext mouseContext) { public void beforeDraw(Rectangle4i rect, MouseContext mouseContext) {
super.beforeDraw(rect, mouseContext); super.beforeDraw(rect, mouseContext);
@@ -63,7 +70,7 @@ public class ItemsPanelGrid extends ItemsGrid<ItemsPanelGrid.ItemsPanelGridSlot,
} }
public ArrayList<ItemStack> newItems; public ArrayList<ItemStack> newItems;
public ArrayList<ItemStack> rawItems; public ArrayList<ItemStack> rawItems = new ArrayList<>();
protected List<ItemsPanelGridSlot> gridMask; protected List<ItemsPanelGridSlot> gridMask;
protected final Map<Integer, Integer> itemToGroup = new HashMap<>(); protected final Map<Integer, Integer> itemToGroup = new HashMap<>();
@@ -82,6 +89,10 @@ public class ItemsPanelGrid extends ItemsGrid<ItemsPanelGrid.ItemsPanelGridSlot,
public void refresh(GuiContainer gui) { public void refresh(GuiContainer gui) {
if (this.newItems != null) { if (this.newItems != null) {
if (this.rawItems.size() != this.newItems.size()) {
this.page = 0;
}
this.groupItems.clear(); this.groupItems.clear();
this.itemToGroup.clear(); this.itemToGroup.clear();
this.forceExpand = false; this.forceExpand = false;
@@ -231,9 +242,18 @@ public class ItemsPanelGrid extends ItemsGrid<ItemsPanelGrid.ItemsPanelGridSlot,
Math.min((int) (color.getAlpha() + (255f / 5) * 2), 255)); Math.min((int) (color.getAlpha() + (255f / 5) * 2), 255));
} }
@Override public void draw(int mousex, int mousey) {
public String getMessageOnEmpty() { if (ItemList.loadFinished) {
return ItemList.loadFinished ? null : NEIClientUtils.translate("itempanel.loading"); super.draw(mousex, mousey);
} else {
GuiDraw.drawStringC(
NEIClientUtils
.cropText(GuiDraw.fontRenderer, NEIClientUtils.translate("itempanel.loading"), width - 10),
marginLeft + width / 2,
marginTop + height / 2,
0xffffff,
true);
}
} }
} }
@@ -4,6 +4,7 @@ import static codechicken.lib.gui.GuiDraw.fontRenderer;
import java.awt.Dimension; import java.awt.Dimension;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.IdentityHashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
@@ -17,60 +18,269 @@ import org.lwjgl.opengl.GL12;
import codechicken.lib.gui.GuiDraw; import codechicken.lib.gui.GuiDraw;
import codechicken.lib.gui.GuiDraw.ITooltipLineHandler; import codechicken.lib.gui.GuiDraw.ITooltipLineHandler;
import codechicken.lib.vec.Rectangle4i;
import codechicken.nei.NEIClientUtils.Alignment;
import codechicken.nei.guihook.GuiContainerManager; import codechicken.nei.guihook.GuiContainerManager;
import codechicken.nei.recipe.StackInfo; import codechicken.nei.recipe.StackInfo;
import codechicken.nei.util.ReadableNumberConverter; import codechicken.nei.util.ReadableNumberConverter;
public class ItemsTooltipLineHandler implements ITooltipLineHandler { public class ItemsTooltipLineHandler implements ITooltipLineHandler {
protected static final int SLOT_SIZE = 18; @FunctionalInterface
protected static final int MAX_COLUMNS = 11; public interface AmountRenderer {
protected static final int MARGIN_TOP = 2;
protected String label; void draw(int x, int y, ItemStack stack, long amount);
protected EnumChatFormatting labelColor = EnumChatFormatting.GRAY;
protected List<ItemStack> items;
protected int activeStackIndex = -1;
protected Dimension size = new Dimension();
protected boolean saveStackSize = false;
protected int columns = 0;
protected int count = 0;
protected int rows = 0;
protected int length = 0;
public ItemsTooltipLineHandler(String label, List<ItemStack> items) {
this(label, items, true, 5);
} }
public ItemsTooltipLineHandler(String label, List<ItemStack> items, boolean saveStackSize, int maxRows) { public static class NoAmountRenderer implements AmountRenderer {
this.label = label;
this.items = groupingItemStacks(items);
this.saveStackSize = saveStackSize;
this.length = this.items.size();
if (this.length > 0) { @Override
this.columns = Math.min(MAX_COLUMNS, this.length); public void draw(int x, int y, ItemStack stack, long amount) {
this.rows = Math.min(maxRows, (int) Math.ceil((float) this.length / this.columns)); GuiContainerManager.drawItem(x, y, stack, true, "");
}
this.size.width = Math.max(this.columns * SLOT_SIZE, fontRenderer.getStringWidth(this.label) + 15); protected static void drawAmountText(String text, Rectangle4i rect, int color, Alignment alignment) {
this.size.height = this.rows * SLOT_SIZE + fontRenderer.FONT_HEIGHT + 2 + MARGIN_TOP; NEIClientUtils.drawNEIOverlayText(text, rect, 1, color, true, alignment);
}
}
this.count = Math.min( public static class TotalAmountRenderer extends NoAmountRenderer {
this.length,
Math.min(
this.columns * this.rows,
this.length > MAX_COLUMNS * maxRows ? (MAX_COLUMNS * maxRows) : Integer.MAX_VALUE));
if (this.items.size() > this.count) { private static class AmountText {
String text = "+" + (this.items.size() - this.count);
this.count -= (int) Math.ceil((float) (fontRenderer.getStringWidth(text) - 2) / SLOT_SIZE); public final String text;
public final Alignment alignment;
public AmountText(String text, Alignment alignment) {
this.text = text;
this.alignment = alignment;
} }
} }
private final Map<ItemStack, AmountText> cache = new IdentityHashMap<>();
@Override
public void draw(int x, int y, ItemStack stack, long amount) {
super.draw(x, y, stack, amount);
drawAmount(new Rectangle4i(x, y, SLOT_SIZE - 2, SLOT_SIZE - 2), stack, amount);
}
protected void drawAmount(Rectangle4i rect, ItemStack stack, long amount) {
final AmountText amountText = this.cache.computeIfAbsent(stack, key -> {
final boolean isFluidDisplay = StackInfo.isFluidDisplayItem(key);
final String text = formatAmount(key, amount);
return new AmountText(
isFluidDisplay && !text.isEmpty() ? text + "L" : text,
isFluidDisplay ? Alignment.BottomLeft : Alignment.BottomRight);
});
if (!amountText.text.isEmpty()) {
drawAmountText(amountText.text, rect, 0xFFFFFF, amountText.alignment);
}
}
protected String formatAmount(ItemStack stack, long amount) {
return amount == 0 ? "" : ReadableNumberConverter.INSTANCE.toWideReadableForm(amount);
}
}
public static class StacksAmountRenderer extends NoAmountRenderer {
private static class StacksText {
public final String stacks;
public final String remainder;
public final int color;
public StacksText(String stacks, String remainder, int color) {
this.stacks = stacks;
this.remainder = remainder;
this.color = color;
}
}
private final Map<ItemStack, StacksText> cache = new IdentityHashMap<>();
@Override
public void draw(int x, int y, ItemStack stack, long amount) {
super.draw(x, y, stack, amount);
drawAmount(new Rectangle4i(x, y, SLOT_SIZE - 2, SLOT_SIZE - 2), stack, amount);
}
protected void drawAmount(Rectangle4i rect, ItemStack stack, long amount) {
final StacksText stacksText = this.cache.computeIfAbsent(stack, key -> formatAmount(key, amount));
if (!stacksText.stacks.isEmpty()) {
drawAmountText(stacksText.stacks, rect, stacksText.color, Alignment.TopLeft);
}
if (!stacksText.remainder.isEmpty()) {
drawAmountText(stacksText.remainder, rect, stacksText.color, Alignment.BottomRight);
}
}
private StacksText formatAmount(ItemStack stack, long amount) {
final long stackSize = StackInfo.isFluidDisplayItem(stack) ? FLUID_STACK_SIZE
: Math.max(1, stack.getMaxStackSize());
final long stacks = amount / stackSize;
final long remainder = amount % stackSize;
final String prefix = getPrefix(stack);
return new StacksText(
stacks > 0 ? prefix + "x" + ReadableNumberConverter.INSTANCE.toWideReadableForm(stacks) : "",
remainder > 0
? (stacks > 0 ? "+" : prefix)
+ ReadableNumberConverter.INSTANCE.toWideReadableForm(remainder)
: "",
getColor(stack));
}
protected String getPrefix(ItemStack stack) {
return "";
}
protected int getColor(ItemStack stack) {
return 0xFFFFFF;
}
}
protected static final int SLOT_SIZE = 18;
protected static final int ICON_SIZE = 16;
protected static final int ICON_OFFSET = 1;
protected static final int MAX_COLUMNS = 11;
protected static final int MARGIN_TOP = 2;
protected static final int LABEL_MARGIN = 15;
protected static final int NAME_MARGIN = 2;
protected static final int DEFAULT_MAX_ROWS = 5;
protected static final int FLUID_STACK_SIZE = 144;
protected final List<ItemStack> items;
protected final List<Long> amounts = new ArrayList<>();
protected final List<String> names = new ArrayList<>();
protected AmountRenderer amountRenderer;
protected String label;
protected EnumChatFormatting labelColor = EnumChatFormatting.GRAY;
protected int activeStackIndex = -1;
protected Dimension size = new Dimension();
protected int maxNamedRows = Integer.MAX_VALUE;
protected int length = 0;
protected int rows = 0;
protected int nameRows = 0;
protected int gridColumns = 0;
protected int gridCount = 0;
public static ItemsTooltipLineHandler of(String label, List<ItemStack> items, int maxRows, int maxNamedRows) {
return new ItemsTooltipLineHandler(label, items, true, maxRows, maxNamedRows);
}
public ItemsTooltipLineHandler(String label, List<ItemStack> items) {
this(label, items, true, DEFAULT_MAX_ROWS, 0);
}
public ItemsTooltipLineHandler(String label, List<ItemStack> items, boolean saveStackSize, int maxRows) {
this(label, items, saveStackSize, maxRows, 0);
}
protected ItemsTooltipLineHandler(String label, List<ItemStack> items, boolean saveStackSize, int maxRows,
int maxNamedRows) {
this.label = label;
this.items = groupingItemStacks(items);
this.amountRenderer = saveStackSize ? new TotalAmountRenderer() : new NoAmountRenderer();
this.length = this.items.size();
this.maxNamedRows = maxNamedRows;
setMaxRows(maxRows);
}
protected static int headerHeight() {
return fontRenderer.FONT_HEIGHT + 2 + MARGIN_TOP;
}
public ItemsTooltipLineHandler setMaxRows(int maxRows) {
if (this.length == 0) {
return this;
}
this.names.clear();
this.nameRows = 0;
if (!layoutWithNames(maxRows)) {
layoutAsGrid(maxRows);
}
this.size.height = this.rows * SLOT_SIZE + headerHeight();
return this;
}
public int getRows() {
return this.rows;
}
protected boolean layoutWithNames(int maxRows) {
final int maxNames = Math.min(this.maxNamedRows, this.length <= maxRows ? this.length : maxRows - 1);
final int[] lineWidth = new int[maxNames + 1];
lineWidth[0] = labelWidth();
for (int index = 0; index < maxNames; index++) {
final String name = this.items.get(index).getDisplayName();
this.names.add(name);
lineWidth[index + 1] = Math
.max(lineWidth[index], SLOT_SIZE + NAME_MARGIN + fontRenderer.getStringWidth(name));
}
for (int named = maxNames; named >= 0; named--) {
final int rest = this.length - named;
final int width = Math.max(lineWidth[named], Math.min(rest, MAX_COLUMNS) * SLOT_SIZE);
final int columns = Math.max(1, width / SLOT_SIZE);
final int restRows = (int) Math.ceil((float) rest / columns);
if (named + restRows <= maxRows) {
this.nameRows = named;
this.gridColumns = columns;
this.gridCount = rest;
this.rows = named + restRows;
this.size.width = width;
return true;
}
}
this.names.clear();
return false;
}
protected void layoutAsGrid(int maxRows) {
this.gridColumns = Math.min(MAX_COLUMNS, this.length);
this.rows = Math.min(maxRows, (int) Math.ceil((float) this.length / this.gridColumns));
this.gridCount = Math.min(this.length, this.gridColumns * this.rows);
this.size.width = Math.max(this.gridColumns * SLOT_SIZE, labelWidth());
if (this.gridCount < this.length) {
this.gridCount -= reservedColumns(this.length - this.gridCount);
}
}
protected int labelWidth() {
return fontRenderer.getStringWidth(this.label) + LABEL_MARGIN;
}
protected int reservedColumns(int hidden) {
return (int) Math.ceil((float) (fontRenderer.getStringWidth("+" + hidden) - 2) / SLOT_SIZE);
}
public ItemsTooltipLineHandler setAmountRenderer(AmountRenderer amountRenderer) {
this.amountRenderer = amountRenderer;
return this;
} }
public void setActiveStack(ItemStack activeStack) { public void setActiveStack(ItemStack activeStack) {
final ItemStack realStack = items.stream().filter(stack -> StackInfo.equalItemAndNBT(stack, activeStack, true)) final ItemStack realStack = items.stream().filter(stack -> NEIClientUtils.areStacksSameType(stack, activeStack))
.findFirst().orElse(null); .findFirst().orElse(null);
this.activeStackIndex = items.indexOf(realStack); this.activeStackIndex = items.indexOf(realStack);
} }
@@ -79,6 +289,10 @@ public class ItemsTooltipLineHandler implements ITooltipLineHandler {
return this.activeStackIndex == -1 ? null : this.items.get(this.activeStackIndex); return this.activeStackIndex == -1 ? null : this.items.get(this.activeStackIndex);
} }
public List<ItemStack> getItems() {
return this.items;
}
public boolean isEmpty() { public boolean isEmpty() {
return this.items.isEmpty(); return this.items.isEmpty();
} }
@@ -92,6 +306,11 @@ public class ItemsTooltipLineHandler implements ITooltipLineHandler {
this.labelColor = color; this.labelColor = color;
} }
public void setLabel(String label) {
this.label = label;
this.size.width = Math.max(this.size.width, labelWidth());
}
@Override @Override
public void draw(int x, int y) { public void draw(int x, int y) {
if (this.length == 0) return; if (this.length == 0) return;
@@ -100,70 +319,89 @@ public class ItemsTooltipLineHandler implements ITooltipLineHandler {
fontRenderer.drawStringWithShadow(this.labelColor + this.label + ":", x, y, 0); fontRenderer.drawStringWithShadow(this.labelColor + this.label + ":", x, y, 0);
GL11.glPushAttrib(GL11.GL_ALL_ATTRIB_BITS);
GL11.glPushMatrix();
RenderHelper.enableGUIStandardItemLighting();
GL11.glScaled(1, 1, 3);
GL11.glTranslatef(x, y + fontRenderer.FONT_HEIGHT + 2, 0);
GL11.glEnable(GL12.GL_RESCALE_NORMAL); GL11.glEnable(GL12.GL_RESCALE_NORMAL);
int indexShift = 0; GL11.glPushAttrib(GL11.GL_ENABLE_BIT | GL11.GL_COLOR_BUFFER_BIT | GL11.GL_LIGHTING_BIT);
RenderHelper.enableGUIStandardItemLighting();
if (this.activeStackIndex != -1) { final int xTranslation = x;
indexShift = Math.max(0, Math.min(this.items.size() - this.count, this.activeStackIndex - this.count + 2)); final int yTranslation = y + fontRenderer.FONT_HEIGHT + 2;
final int zTranslation = GuiContainerManager.TOOLTIP_Z_OFFSET;
GL11.glTranslatef(xTranslation, yTranslation, zTranslation);
final int gridShift = gridIndexShift();
for (int index = 0; index < this.nameRows; index++) {
drawSlot(0, index * SLOT_SIZE, index);
} }
for (int index = 0; index < this.count && index + indexShift < this.items.size(); index++) { for (int index = 0; index < this.gridCount; index++) {
ItemStack drawStack = this.items.get(index + indexShift); drawSlot(
int col = index % this.columns; (index % this.gridColumns) * SLOT_SIZE,
int row = index / this.columns; (this.nameRows + index / this.gridColumns) * SLOT_SIZE,
this.nameRows + gridShift + index);
}
String stackSize = !this.saveStackSize || drawStack.stackSize == 0 ? "" NEIClientUtils.gl2DRenderContext(() -> {
: ReadableNumberConverter.INSTANCE.toWideReadableForm(drawStack.stackSize); final int textShift = ICON_OFFSET + Math.round((ICON_SIZE - fontRenderer.FONT_HEIGHT) / 2f);
if (this.activeStackIndex == index + indexShift) { for (int index = 0; index < this.nameRows; index++) {
NEIClientUtils.gl2DRenderContext( fontRenderer.drawStringWithShadow(
() -> GuiDraw.drawRect(col * SLOT_SIZE - 1, row * SLOT_SIZE - 1, 18, 18, 0x66555555)); EnumChatFormatting.GRAY + this.names.get(index),
SLOT_SIZE + NAME_MARGIN,
index * SLOT_SIZE + textShift,
0xFFFFFF);
} }
drawItem(col * SLOT_SIZE, row * SLOT_SIZE, drawStack, stackSize); final int hidden = this.length - this.nameRows - this.gridCount;
}
if (this.count < this.items.size()) { if (hidden > 0) {
final String text = "+" + (this.items.size() - this.count); final String text = "+" + hidden;
NEIClientUtils.gl2DRenderContext(() -> {
fontRenderer.drawStringWithShadow( fontRenderer.drawStringWithShadow(
text, EnumChatFormatting.GRAY + text,
MAX_COLUMNS * SLOT_SIZE - fontRenderer.getStringWidth(text) - 2, this.size.width - fontRenderer.getStringWidth(text) - 2,
(this.rows - 1) * SLOT_SIZE + (SLOT_SIZE - fontRenderer.FONT_HEIGHT) / 2, (this.rows - 1) * SLOT_SIZE + textShift,
0xee555555); 0xFFFFFF);
}); }
} });
GL11.glPopMatrix(); GL11.glTranslatef(-xTranslation, -yTranslation, -zTranslation);
GL11.glPopAttrib(); GL11.glPopAttrib();
} }
protected void drawItem(int x, int y, ItemStack drawStack, String stackSize) { protected int gridIndexShift() {
GuiContainerManager.drawItem(x, y, drawStack, true, stackSize); if (this.nameRows > 0 || this.activeStackIndex == -1) {
return 0;
}
return Math.max(0, Math.min(this.length - this.gridCount, this.activeStackIndex - this.gridCount + 2));
}
protected void drawSlot(int x, int y, int index) {
if (this.activeStackIndex == index) {
NEIClientUtils.gl2DRenderContext(() -> GuiDraw.drawRect(x, y, SLOT_SIZE, SLOT_SIZE, 0x66555555));
}
drawStackWithAmount(x, y, index);
}
protected void drawStackWithAmount(int x, int y, int index) {
this.amountRenderer.draw(x + ICON_OFFSET, y + ICON_OFFSET, this.items.get(index), this.amounts.get(index));
} }
private List<ItemStack> groupingItemStacks(List<ItemStack> items) { private List<ItemStack> groupingItemStacks(List<ItemStack> items) {
final List<ItemStack> result = new ArrayList<>(); final List<ItemStack> result = new ArrayList<>();
for (Map.Entry<NBTTagCompound, Long> entry : ItemStackAmount.of(items).entrySet()) { for (Map.Entry<NBTTagCompound, Long> entry : ItemStackAmount.of(items).entrySet()) {
final ItemStack stack = StackInfo.loadFromNBT(entry.getKey(), Math.max(0, entry.getValue())); result.add(StackInfo.loadFromNBT(entry.getKey(), 0));
this.amounts.add(Math.max(0, entry.getValue()));
if (entry.getKey().hasKey("gtFluidName")) {
stack.stackSize = 0;
}
result.add(stack);
} }
if (result.isEmpty()) { if (result.isEmpty()) {
result.addAll(items); for (ItemStack stack : items) {
result.add(stack);
this.amounts.add(0L);
}
} }
return result; return result;
+175 -20
View File
@@ -2,10 +2,22 @@ package codechicken.nei;
import java.util.HashMap; import java.util.HashMap;
import java.util.LinkedList; import java.util.LinkedList;
import java.util.Map.Entry; import java.util.Map;
import java.util.StringJoiner;
import java.util.function.BooleanSupplier;
import net.minecraft.client.Minecraft;
import net.minecraft.client.settings.KeyBinding;
import org.lwjgl.input.Keyboard;
import org.lwjgl.input.Mouse;
import codechicken.nei.util.NEIKeyboardUtils;
import codechicken.nei.util.NEIMouseUtils;
import cpw.mods.fml.client.registry.ClientRegistry;
/** /**
* Good old down/held/up keystate tracker * Registers NEI key bindings as vanilla {@link KeyBinding}s and exposes their state to the rest of NEI.
*/ */
public class KeyManager { public class KeyManager {
@@ -14,30 +26,173 @@ public class KeyManager {
public void tickKeyStates(); public void tickKeyStates();
} }
public static class KeyState { public static LinkedList<IKeyStateTracker> trackers = new LinkedList<>();
private static final Map<String, KeyBinding> keyBindings = new HashMap<>();
private static final Map<String, String> keyAliases = new HashMap<>();
private static volatile boolean pendingOptionsReload = false;
private static int clickedButton = -1;
public boolean down; static {
public boolean held; // Aliases for legacy keybinds
public boolean up; keyAliases.put("gui.recipe", "recipe.recipe");
keyAliases.put("gui.usage", "recipe.usage");
keyAliases.put("gui.hide_bookmarks", "bookmark.hide");
} }
public static HashMap<String, KeyState> keyStates = new HashMap<>(); public static KeyBinding registerKeyBinding(String ident, int defaultKey) {
public static LinkedList<IKeyStateTracker> trackers = new LinkedList<>(); return keyBindings.computeIfAbsent(ident, id -> {
final KeyBinding binding = new KeyBinding(
"nei.options.keys." + id,
NEIKeyboardUtils.unhash(defaultKey),
categoryFor(id));
ClientRegistry.registerKeyBinding(binding);
return binding;
});
}
public static KeyBinding getKeyBinding(String ident) {
return keyBindings.get(keyAliases.getOrDefault(ident, ident));
}
public static boolean isRegistered(String description) {
for (KeyBinding binding : keyBindings.values()) {
if (binding.getKeyDescription().equals(description)) {
return true;
}
}
return false;
}
public static int getKeyCode(String ident) {
final KeyBinding binding = getKeyBinding(ident);
return binding == null ? Keyboard.KEY_NONE : binding.getKeyCode();
}
public static boolean isKeyDown(String ident) {
final KeyBinding binding = getKeyBinding(ident);
if (binding != null) {
final int keyCode = binding.getKeyCode();
if (keyCode < 0) {
final int button = keyCode + 100;
return Mouse.isButtonDown(button) || button == clickedButton;
} else if (keyCode > Keyboard.KEY_NONE && keyCode < Keyboard.KEYBOARD_SIZE) {
return Keyboard.isKeyDown(keyCode);
}
}
return false;
}
/**
* Whether any NEI key binding is assigned to the given mouse button.
*/
public static boolean isMouseBound(int button) {
for (KeyBinding binding : keyBindings.values()) {
if (binding.getKeyCode() == button - 100) {
return true;
}
}
return false;
}
/**
* Runs a hotkey handler for a click of the given mouse button if the button is bound to any NEI key binding. The
* button is reported as down by {@link #isKeyDown} for the duration of the call, because the LWJGL button state can
* already be released when a quick click is processed.
*
* @return true if the click was consumed by the handler
*/
public static boolean handleMouseHotkey(int button, BooleanSupplier handler) {
if (!isMouseBound(button)) {
return false;
}
final int previous = clickedButton;
clickedButton = button;
try {
return handler.getAsBoolean();
} finally {
clickedButton = previous;
}
}
public static boolean isHashDown(String ident) {
return isHashDown(ident, 0);
}
public static boolean isHashDown(String ident, int modifierMask) {
if (!isKeyDown(ident)) {
return false;
}
if (NEIKeyboardUtils.isHashKey(getKeyCode(ident))) {
return true;
}
return ((modifierMask & NEIKeyboardUtils.CTRL_HASH) != 0) == NEIClientUtils.controlKey()
&& ((modifierMask & NEIKeyboardUtils.SHIFT_HASH) != 0) == NEIClientUtils.shiftKey()
&& ((modifierMask & NEIKeyboardUtils.ALT_HASH) != 0) == NEIClientUtils.altKey();
}
public static String getKeyName(String ident) {
return getKeyName(ident, 0);
}
public static String getKeyName(String ident, int meta) {
final int keyCode = getKeyCode(ident);
return keyCode == Keyboard.KEY_NONE ? null : NEIKeyboardUtils.getKeyName(keyCode, meta);
}
public static String getKeyName(String ident, int meta, int mouseBind) {
final int keyCode = getKeyCode(ident);
return keyCode == Keyboard.KEY_NONE && mouseBind == NEIMouseUtils.MOUSE_BTN_NONE ? null
: getKeyName(keyCode, meta, mouseBind);
}
public static String getKeyName(int keyBind, int mouseBind) {
final int keyCode = NEIKeyboardUtils.unhash(keyBind);
return getKeyName(keyCode, keyBind - keyCode, mouseBind);
}
private static String getKeyName(int keyCode, int hash, int mouseBind) {
StringJoiner keyText = new StringJoiner(" + ");
String keyHash = keyCode == Keyboard.KEY_NONE && hash == 0 ? "" : NEIKeyboardUtils.getKeyName(keyCode, hash);
String mouseHash = mouseBind == NEIMouseUtils.MOUSE_BTN_NONE ? "" : NEIMouseUtils.getKeyName(mouseBind);
if (!keyHash.isEmpty()) {
keyText.add(keyHash);
}
if (!mouseHash.isEmpty()) {
keyText.add(mouseHash);
}
return keyText.toString();
}
public static boolean isPressed(String ident) {
final KeyBinding binding = getKeyBinding(ident);
return binding != null && binding.isPressed();
}
private static String categoryFor(String ident) {
final int dot = ident.indexOf('.');
return dot < 0 ? "nei.options.keys" : "nei.options.keys." + ident.substring(0, dot);
}
public static void requestOptionsReload() {
pendingOptionsReload = true;
}
public static void tickKeyStates() { public static void tickKeyStates() {
for (Entry<String, KeyState> entry : keyStates.entrySet()) {
final boolean down = NEIClientConfig.isKeyHashDown(entry.getKey());
final KeyState state = entry.getValue();
if (down) { if (pendingOptionsReload) {
state.down = !state.held; pendingOptionsReload = false;
state.up = false; Minecraft.getMinecraft().gameSettings.loadOptions();
} else {
state.up = state.held;
state.down = false;
}
state.held = down;
} }
for (IKeyStateTracker tracker : trackers) tracker.tickKeyStates(); for (IKeyStateTracker tracker : trackers) tracker.tickKeyStates();
@@ -43,6 +43,7 @@ import net.minecraft.client.gui.GuiButton;
import net.minecraft.client.gui.inventory.GuiContainer; import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.client.gui.inventory.GuiContainerCreative; import net.minecraft.client.gui.inventory.GuiContainerCreative;
import net.minecraft.client.renderer.InventoryEffectRenderer; import net.minecraft.client.renderer.InventoryEffectRenderer;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.inventory.Slot; import net.minecraft.inventory.Slot;
import net.minecraft.item.Item; import net.minecraft.item.Item;
import net.minecraft.item.ItemStack; import net.minecraft.item.ItemStack;
@@ -68,6 +69,7 @@ import codechicken.nei.guihook.IContainerTooltipHandler;
import codechicken.nei.recipe.AutoCraftingManager; import codechicken.nei.recipe.AutoCraftingManager;
import codechicken.nei.recipe.GuiRecipeTab; import codechicken.nei.recipe.GuiRecipeTab;
import codechicken.nei.recipe.RecipeCatalysts; import codechicken.nei.recipe.RecipeCatalysts;
import codechicken.nei.recipe.debug.DebugHandlerWidget;
public class LayoutManager implements IContainerInputHandler, IContainerTooltipHandler, IContainerDrawHandler, public class LayoutManager implements IContainerInputHandler, IContainerTooltipHandler, IContainerDrawHandler,
IContainerObjectHandler, IKeyStateTracker { IContainerObjectHandler, IKeyStateTracker {
@@ -102,7 +104,7 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
public static Button delete; public static Button delete;
public static ButtonCycled gamemode; public static ButtonCycled gamemode;
public static Button rain; public static Button rain;
public static Button magnet; public static ButtonCycled magnet;
public static Button[] timeButtons = new Button[4]; public static Button[] timeButtons = new Button[4];
public static Button heal; public static Button heal;
@@ -117,11 +119,6 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
*/ */
public static boolean itemsLoaded = false; public static boolean itemsLoaded = false;
/**
* Not present, Present
*/
public static Image[] itemPresenceOverlays = new Image[2];
public static void load() { public static void load() {
API.addLayoutStyle(0, new LayoutStyleMinecraft()); API.addLayoutStyle(0, new LayoutStyleMinecraft());
@@ -223,22 +220,40 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
@Override @Override
public boolean lastKeyTyped(GuiContainer gui, char keyChar, int keyID) { public boolean lastKeyTyped(GuiContainer gui, char keyChar, int keyID) {
if (NEIClientConfig.isKeyHashDown("gui.hide")) { if (isEnabled() && !isHidden()) {
for (Widget widget : controlWidgets) {
if (inputFocused == null) {
widget.lastKeyTyped(keyID, keyChar);
}
}
}
return false;
}
@Override
public boolean onHotkeyPressed(GuiContainer gui) {
if (KeyManager.isKeyDown("gui.hide")) {
toggleBooleanSetting("inventory.hidden"); toggleBooleanSetting("inventory.hidden");
return true; return true;
} }
if (NEIClientConfig.isKeyHashDown("gui.hide_bookmarks")) { if (KeyManager.isKeyDown("bookmark.hide")) {
toggleBooleanSetting("inventory.bookmarks.enabled"); toggleBooleanSetting("inventory.bookmarks.enabled");
return true; return true;
} }
if (NEIClientConfig.isKeyHashDown("gui.next_tooltip") && GuiContainerManager.incrementTooltipPage()) { if (KeyManager.isKeyDown("gui.next_tooltip") && GuiContainerManager.incrementTooltipPage()) {
return true; return true;
} }
if (isEnabled() && !isHidden()) { if (isEnabled() && !isHidden() && inputFocused == null) {
for (Widget widget : controlWidgets) if (inputFocused == null) widget.lastKeyTyped(keyID, keyChar); for (Widget widget : controlWidgets) {
if (widget.onHotkeyPressed()) {
return true;
}
}
} }
return false; return false;
@@ -291,19 +306,6 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
} }
} }
@Override
public void postRenderTooltips(GuiContainer gui, int mousex, int mousey, List<String> tooltip) {
if (!isHidden() && isEnabled() && GuiContainerManager.shouldShowTooltip(gui)) {
final Widget focused = getWidgetUnderMouse(mousex, mousey);
if (focused != null) {
focused.postDrawTooltips(mousex, mousey, tooltip);
}
}
}
@Override @Override
public List<String> handleTooltip(GuiContainer gui, int mousex, int mousey, List<String> currenttip) { public List<String> handleTooltip(GuiContainer gui, int mousex, int mousey, List<String> currenttip) {
@@ -354,6 +356,10 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
if (!isHidden() && isEnabled() && GuiContainerManager.shouldShowTooltip(gui)) { if (!isHidden() && isEnabled() && GuiContainerManager.shouldShowTooltip(gui)) {
final Widget focused = getWidgetUnderMouse(mousex, mousey); final Widget focused = getWidgetUnderMouse(mousex, mousey);
if (focused != null) {
currenttip = focused.handleItemTooltip(itemstack, mousex, mousey, currenttip);
}
if (focused instanceof IContainerTooltipHandler tip) { if (focused instanceof IContainerTooltipHandler tip) {
currenttip = tip.handleItemTooltip(gui, itemstack, mousex, mousey, currenttip); currenttip = tip.handleItemTooltip(gui, itemstack, mousex, mousey, currenttip);
} }
@@ -368,15 +374,22 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
if (!isHidden() && isEnabled() && GuiContainerManager.shouldShowTooltip(gui)) { if (!isHidden() && isEnabled() && GuiContainerManager.shouldShowTooltip(gui)) {
final Widget focused = getWidgetUnderMouse(mousex, mousey); final Widget focused = getWidgetUnderMouse(mousex, mousey);
if (focused instanceof IContainerTooltipHandler tip) { if (focused != null) {
hotkeys = tip.handleHotkeys(gui, mousex, mousey, hotkeys); hotkeys = focused.handleHotkeys(mousex, mousey, hotkeys);
if (focused instanceof IContainerTooltipHandler tip) {
hotkeys = tip.handleHotkeys(gui, mousex, mousey, hotkeys);
}
} }
} }
return hotkeys; return hotkeys;
} }
public static void layout(GuiContainer gui) { public static void layout(GuiContainer gui) {
GridOverlapScanner.beginFrame(gui, GuiContainerManager.shouldShowTooltip(gui));
VisiblityData visiblity = new VisiblityData(); VisiblityData visiblity = new VisiblityData();
visiblity.showNEI = !isHidden(); visiblity.showNEI = !isHidden();
visiblity.showBookmarkPanel = !isBookmarkPanelHidden(); visiblity.showBookmarkPanel = !isBookmarkPanelHidden();
@@ -434,14 +447,14 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
if (!rightclick) { if (!rightclick) {
if (Keyboard.getEventKeyState() && getIsAccessibleControlEventKey() if (Keyboard.getEventKeyState() && getIsAccessibleControlEventKey()
&& NEIClientConfig.canChangeCheatMode()) { && NEIClientConfig.canChangeCheatMode()) {
NEIClientConfig.cycleSetting("inventory.cheatmode", 3); NEIClientConfig.setCheatMode((NEIClientConfig.getCheatMode() + 1) % 3);
} else { } else {
if (Keyboard.getEventKeyState() && (Keyboard.getEventKey() == Keyboard.KEY_LSHIFT if (Keyboard.getEventKeyState() && (Keyboard.getEventKey() == Keyboard.KEY_LSHIFT
|| Keyboard.getEventKey() == Keyboard.KEY_RSHIFT)) { || Keyboard.getEventKey() == Keyboard.KEY_RSHIFT)) {
GuiRecipeTab.loadHandlerInfo(); GuiRecipeTab.loadHandlerInfo();
RecipeCatalysts.loadCatalystInfo(); RecipeCatalysts.loadCatalystInfo();
} }
getOptionList().openGui(getGuiContainer(), false); getOptionList().openGui(getGuiContainer());
} }
return true; return true;
} }
@@ -600,7 +613,7 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
return getStateTip("rain", state); return getStateTip("rain", state);
} }
}; };
magnet = new Button() { magnet = new ButtonCycled(2) {
@Override @Override
public boolean onButtonPress(boolean rightclick) { public boolean onButtonPress(boolean rightclick) {
@@ -700,6 +713,8 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
@Override @Override
public void load(GuiContainer gui) { public void load(GuiContainer gui) {
NEIController.load(gui);
if (isEnabled()) { if (isEnabled()) {
setInputFocused(null); setInputFocused(null);
@@ -713,8 +728,6 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
AutoFocusWidget.instance.load(gui); AutoFocusWidget.instance.load(gui);
} }
NEIController.load(gui);
if (checkCreativeInv(gui) && gui.mc.currentScreen instanceof GuiContainerCreative) // override creative with if (checkCreativeInv(gui) && gui.mc.currentScreen instanceof GuiContainerCreative) // override creative with
// creative+ // creative+
gui.mc.displayGuiScreen(null); // close the screen and wait for the server to open it for us gui.mc.displayGuiScreen(null); // close the screen and wait for the server to open it for us
@@ -783,9 +796,10 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
addWidget(itemZoom); addWidget(itemZoom);
if (visiblity.showSubsetDropdown) { if (visiblity.showSubsetDropdown) {
// Bookmarks or Subset/dropdown
addWidget(dropDown); addWidget(dropDown);
} }
addWidget(DebugHandlerWidget.instance);
} }
public static LayoutStyle getLayoutStyle(int id) { public static LayoutStyle getLayoutStyle(int id) {
@@ -809,6 +823,9 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
if (!isEnabled()) return; if (!isEnabled()) return;
GridOverlapScanner.requestScan();
AutoFocusWidget.instance.guiTick();
for (Widget widget : drawWidgets) widget.update(); for (Widget widget : drawWidgets) widget.update();
} }
@@ -905,29 +922,39 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
final int ty2 = ty + 20 - h2 - te; final int ty2 = ty + 20 - h2 - te;
final int tx2 = 200 - w2 - te; final int tx2 = 200 - w2 - te;
final boolean is2DTexture = GL11.glGetBoolean(GL11.GL_TEXTURE_2D);
GL11.glEnable(GL11.GL_TEXTURE_2D);
changeTexture("textures/gui/widgets.png"); changeTexture("textures/gui/widgets.png");
drawTexturedModalRect(x, y, tx1, ty1, w1, h1); // top left final Tessellator tessellator = Tessellator.instance;
drawTexturedModalRect(x, y2, tx1, ty2, w1, h2); // bottom left tessellator.startDrawingQuads();
addTexturedModalRect(tessellator, x, y, tx1, ty1, w1, h1); // top left
addTexturedModalRect(tessellator, x, y2, tx1, ty2, w1, h2); // bottom left
for (int tile = 0; tile < wTiles; tile++) { for (int tile = 0; tile < wTiles; tile++) {
final int tileX = x + w1 + 50 * tile; final int tileX = x + w1 + 50 * tile;
drawTexturedModalRect(tileX, y, tx3, ty1, 50, h1); // top addTexturedModalRect(tessellator, tileX, y, tx3, ty1, 50, h1); // top
drawTexturedModalRect(tileX, y2, tx3, ty2, 50, h2); // bottom addTexturedModalRect(tessellator, tileX, y2, tx3, ty2, 50, h2); // bottom
} }
drawTexturedModalRect(x2, y, tx2, ty1, w2, h1); // top right addTexturedModalRect(tessellator, x2, y, tx2, ty1, w2, h1); // top right
drawTexturedModalRect(x2, y2, tx2, ty2, w2, h2); // bottom right addTexturedModalRect(tessellator, x2, y2, tx2, ty2, w2, h2); // bottom right
tessellator.draw();
if (!is2DTexture) GL11.glDisable(GL11.GL_TEXTURE_2D);
} }
public static void drawItemPresenceOverlay(int slotX, int slotY, boolean isPresent, boolean slotHighlight) { private static void addTexturedModalRect(Tessellator tessellator, int x, int y, int textureX, int textureY,
int width, int height) {
if (slotHighlight) { final double z = GuiDraw.gui.getZLevel();
NEIClientUtils.gl2DRenderContext(() -> drawRect(slotX, slotY, 16, 16, isPresent ? 0x8000AA00 : 0x80AA0000)); final double u = textureX / 256D;
} else { final double v = textureY / 256D;
Image icon = itemPresenceOverlays[isPresent ? 1 : 0]; final double maxU = (textureX + width) / 256D;
drawIcon(slotX + 16 - icon.width, slotY + 16 - icon.height, icon); final double maxV = (textureY + height) / 256D;
} tessellator.addVertexWithUV(x, y + height, z, u, maxV);
tessellator.addVertexWithUV(x + width, y + height, z, maxU, maxV);
tessellator.addVertexWithUV(x + width, y, z, maxU, v);
tessellator.addVertexWithUV(x, y, z, u, v);
} }
public static LayoutManager instance() { public static LayoutManager instance() {
@@ -938,12 +965,12 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
public void tickKeyStates() { public void tickKeyStates() {
if (Minecraft.getMinecraft().currentScreen != null) return; if (Minecraft.getMinecraft().currentScreen != null) return;
if (KeyManager.keyStates.get("world.dawn").down) timeButtons[0].onButtonPress(false); if (KeyManager.isPressed("world.dawn")) timeButtons[0].onButtonPress(false);
if (KeyManager.keyStates.get("world.noon").down) timeButtons[1].onButtonPress(false); if (KeyManager.isPressed("world.noon")) timeButtons[1].onButtonPress(false);
if (KeyManager.keyStates.get("world.dusk").down) timeButtons[2].onButtonPress(false); if (KeyManager.isPressed("world.dusk")) timeButtons[2].onButtonPress(false);
if (KeyManager.keyStates.get("world.midnight").down) timeButtons[3].onButtonPress(false); if (KeyManager.isPressed("world.midnight")) timeButtons[3].onButtonPress(false);
if (KeyManager.keyStates.get("world.rain").down) rain.onButtonPress(false); if (KeyManager.isPressed("world.rain")) rain.onButtonPress(false);
if (KeyManager.keyStates.get("world.heal").down) heal.onButtonPress(false); if (KeyManager.isPressed("world.heal")) heal.onButtonPress(false);
if (KeyManager.keyStates.get("world.creative").down) gamemode.onButtonPress(false); if (KeyManager.isPressed("world.creative")) gamemode.onButtonPress(false);
} }
} }
@@ -8,7 +8,6 @@ import org.lwjgl.opengl.GL11;
import codechicken.lib.vec.Rectangle4i; import codechicken.lib.vec.Rectangle4i;
import codechicken.nei.api.LayoutStyle; import codechicken.nei.api.LayoutStyle;
import codechicken.nei.drawable.DrawableBuilder;
public class LayoutStyleMinecraft extends LayoutStyle { public class LayoutStyleMinecraft extends LayoutStyle {
@@ -31,16 +30,13 @@ public class LayoutStyleMinecraft extends LayoutStyle {
LayoutManager.gamemode.icons[0] = new Image(132, 12, 12, 12); LayoutManager.gamemode.icons[0] = new Image(132, 12, 12, 12);
LayoutManager.gamemode.icons[1] = new Image(156, 12, 12, 12); LayoutManager.gamemode.icons[1] = new Image(156, 12, 12, 12);
LayoutManager.gamemode.icons[2] = new Image(168, 12, 12, 12); LayoutManager.gamemode.icons[2] = new Image(168, 12, 12, 12);
LayoutManager.magnet.icon = new Image(180, 24, 12, 12); LayoutManager.magnet.icons[0] = new Image(180, 24, 12, 12);
LayoutManager.magnet.icons[1] = new Image(180, 36, 12, 12);
LayoutManager.timeButtons[0].icon = new Image(132, 24, 12, 12); LayoutManager.timeButtons[0].icon = new Image(132, 24, 12, 12);
LayoutManager.timeButtons[1].icon = new Image(120, 24, 12, 12); LayoutManager.timeButtons[1].icon = new Image(120, 24, 12, 12);
LayoutManager.timeButtons[2].icon = new Image(144, 24, 12, 12); LayoutManager.timeButtons[2].icon = new Image(144, 24, 12, 12);
LayoutManager.timeButtons[3].icon = new Image(156, 24, 12, 12); LayoutManager.timeButtons[3].icon = new Image(156, 24, 12, 12);
LayoutManager.heal.icon = new Image(168, 24, 12, 12); LayoutManager.heal.icon = new Image(168, 24, 12, 12);
LayoutManager.itemPresenceOverlays[0] = new DrawableBuilder("nei:textures/nei_tabbed_sprites.png", 0, 40, 8, 8)
.build();
LayoutManager.itemPresenceOverlays[1] = new DrawableBuilder("nei:textures/nei_tabbed_sprites.png", 8, 40, 8, 8)
.build();
} }
@Override @Override
@@ -52,7 +48,7 @@ public class LayoutStyleMinecraft extends LayoutStyle {
public void layout(GuiContainer gui, VisiblityData visiblity) { public void layout(GuiContainer gui, VisiblityData visiblity) {
reset(); reset();
leftSize = ItemPanels.bookmarkPanel.getWidth(gui); leftSize = (gui.width - gui.xSize) / 2 - 4;
numButtons = Math.max(leftSize / 20, 1); numButtons = Math.max(leftSize / 20, 1);
LayoutManager.delete.state = 0x4; LayoutManager.delete.state = 0x4;
@@ -86,6 +82,7 @@ public class LayoutStyleMinecraft extends LayoutStyle {
LayoutManager.options.index = NEIClientConfig.getCheatMode(); LayoutManager.options.index = NEIClientConfig.getCheatMode();
LayoutManager.magnet.state = 0x4 | (NEIClientConfig.getMagnetMode() ? 1 : 0); LayoutManager.magnet.state = 0x4 | (NEIClientConfig.getMagnetMode() ? 1 : 0);
LayoutManager.magnet.index = (LayoutManager.magnet.state & 0x1) != 0 ? 1 : 0;
if (NEIClientConfig.canPerformAction("delete")) { if (NEIClientConfig.canPerformAction("delete")) {
layoutButton(LayoutManager.delete); layoutButton(LayoutManager.delete);
@@ -242,7 +239,11 @@ public class LayoutStyleMinecraft extends LayoutStyle {
Image icon = b.getRenderIcon(); Image icon = b.getRenderIcon();
if (icon == null) { if (icon == null) {
int colour = tex == 2 ? 0xffffa0 : tex == 0 ? 0x601010 : 0xe0e0e0; int labelColor = b.getRenderLabelColor();
int colour = labelColor != 0 ? labelColor
: tex == 2 ? ColorUtils.buttonLabelHover.getColor()
: tex == 0 ? ColorUtils.buttonLabelDisabled.getColor()
: ColorUtils.buttonLabelNormal.getColor();
drawStringC(b.getRenderLabel(), b.x + b.w / 2, b.y + (b.h - 8) / 2, colour); drawStringC(b.getRenderLabel(), b.x + b.w / 2, b.y + (b.h - 8) / 2, colour);
} else { } else {
@@ -54,6 +54,7 @@ public class NEIActions {
addAction("magnet", true); addAction("magnet", true);
addAction("enchant", true); addAction("enchant", true);
addAction("potion", true); addAction("potion", true);
addAction("autocraft");
canDisable.add("dawn"); canDisable.add("dawn");
canDisable.add("noon"); canDisable.add("noon");
+19 -2
View File
@@ -6,6 +6,7 @@ import static codechicken.nei.PacketIDs.S2C;
import net.minecraft.client.Minecraft; import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.inventory.GuiInventory; import net.minecraft.client.gui.inventory.GuiInventory;
import net.minecraft.item.ItemStack; import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.network.play.INetHandlerPlayClient; import net.minecraft.network.play.INetHandlerPlayClient;
import net.minecraft.util.ChatComponentTranslation; import net.minecraft.util.ChatComponentTranslation;
import net.minecraft.world.World; import net.minecraft.world.World;
@@ -14,6 +15,7 @@ import codechicken.core.ClientUtils;
import codechicken.lib.inventory.InventoryUtils; import codechicken.lib.inventory.InventoryUtils;
import codechicken.lib.packet.PacketCustom; import codechicken.lib.packet.PacketCustom;
import codechicken.lib.packet.PacketCustom.IClientPacketHandler; import codechicken.lib.packet.PacketCustom.IClientPacketHandler;
import codechicken.nei.commands.CommandBookmarkAdd;
import cpw.mods.fml.relauncher.Side; import cpw.mods.fml.relauncher.Side;
public class NEICPH implements IClientPacketHandler { public class NEICPH implements IClientPacketHandler {
@@ -56,6 +58,21 @@ public class NEICPH implements IClientPacketHandler {
case S2C.OPEN_POTION_GUI: case S2C.OPEN_POTION_GUI:
ClientUtils.openSMPGui(packet.readUByte(), new GuiPotionCreator(mc.thePlayer.inventory)); ClientUtils.openSMPGui(packet.readUByte(), new GuiPotionCreator(mc.thePlayer.inventory));
break; break;
case S2C.CACHE_BOOKMARK_DATA:
handleCacheBookmarkData(packet);
break;
case S2C.SYNC:
ServerSync.onReply(packet.readInt());
break;
}
}
private void handleCacheBookmarkData(PacketCustom packet) {
final String payloadId = packet.readString();
final NBTTagCompound payloadTag = packet.readNBTTagCompound();
if (payloadTag != null) {
CommandBookmarkAdd.cachePayload(payloadId, payloadTag);
} }
} }
@@ -186,9 +203,9 @@ public class NEICPH implements IClientPacketHandler {
packet.sendToServer(); packet.sendToServer();
} }
public static void sendChatLink(ItemStack stackover) { public static void sendChatLink(NBTTagCompound payloadTag) {
PacketCustom packet = new PacketCustom(channel, C2S.SEND_CHAT_ITEM_LINK); PacketCustom packet = new PacketCustom(channel, C2S.SEND_CHAT_ITEM_LINK);
packet.writeItemStack(stackover); packet.writeNBTTagCompound(payloadTag);
packet.sendToServer(); packet.sendToServer();
} }
+337 -186
View File
@@ -9,13 +9,13 @@ import java.util.Map;
import java.util.Set; import java.util.Set;
import java.util.function.Function; import java.util.function.Function;
import java.util.regex.Pattern; import java.util.regex.Pattern;
import java.util.stream.Stream;
import net.minecraft.client.Minecraft; import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.GuiScreen; import net.minecraft.client.gui.GuiScreen;
import net.minecraft.client.renderer.OpenGlHelper; import net.minecraft.client.renderer.OpenGlHelper;
import net.minecraft.item.ItemStack; import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound; import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.ChatComponentTranslation;
import net.minecraft.util.EnumChatFormatting; import net.minecraft.util.EnumChatFormatting;
import net.minecraft.world.storage.SaveFormatComparator; import net.minecraft.world.storage.SaveFormatComparator;
import net.minecraftforge.common.MinecraftForge; import net.minecraftforge.common.MinecraftForge;
@@ -37,7 +37,6 @@ import codechicken.lib.config.ConfigTag;
import codechicken.lib.config.ConfigTagParent; import codechicken.lib.config.ConfigTagParent;
import codechicken.nei.api.API; import codechicken.nei.api.API;
import codechicken.nei.api.GuiInfo; import codechicken.nei.api.GuiInfo;
import codechicken.nei.api.IConfigureNEI;
import codechicken.nei.api.ItemInfo; import codechicken.nei.api.ItemInfo;
import codechicken.nei.api.NEIInfo; import codechicken.nei.api.NEIInfo;
import codechicken.nei.config.ConfigSet; import codechicken.nei.config.ConfigSet;
@@ -45,7 +44,9 @@ import codechicken.nei.config.GuiHighlightTips;
import codechicken.nei.config.GuiNEIOptionList; import codechicken.nei.config.GuiNEIOptionList;
import codechicken.nei.config.GuiOptionList; import codechicken.nei.config.GuiOptionList;
import codechicken.nei.config.GuiPanelSettings; import codechicken.nei.config.GuiPanelSettings;
import codechicken.nei.config.OptionButton;
import codechicken.nei.config.OptionCycled; import codechicken.nei.config.OptionCycled;
import codechicken.nei.config.OptionExportConfig;
import codechicken.nei.config.OptionGamemodes; import codechicken.nei.config.OptionGamemodes;
import codechicken.nei.config.OptionIntegerField; import codechicken.nei.config.OptionIntegerField;
import codechicken.nei.config.OptionList; import codechicken.nei.config.OptionList;
@@ -56,12 +57,12 @@ import codechicken.nei.config.OptionToggleButtonBoubs;
import codechicken.nei.config.OptionUtilities; import codechicken.nei.config.OptionUtilities;
import codechicken.nei.config.preset.GuiPresetList; import codechicken.nei.config.preset.GuiPresetList;
import codechicken.nei.event.NEIConfigsLoadedEvent; import codechicken.nei.event.NEIConfigsLoadedEvent;
import codechicken.nei.recipe.GuiRecipeTab; import codechicken.nei.moboverlay.MobOverlayScan;
import codechicken.nei.moboverlay.MobOverlayStyle;
import codechicken.nei.recipe.IRecipeHandler; import codechicken.nei.recipe.IRecipeHandler;
import codechicken.nei.recipe.InformationHandler; import codechicken.nei.recipe.InformationHandler;
import codechicken.nei.recipe.RecipeCatalysts; import codechicken.nei.recipe.RecipeCatalysts;
import codechicken.nei.recipe.RecipeInfo; import codechicken.nei.util.ItemUntranslator;
import codechicken.nei.util.NEIKeyboardUtils;
import codechicken.obfuscator.ObfuscationRun; import codechicken.obfuscator.ObfuscationRun;
public class NEIClientConfig { public class NEIClientConfig {
@@ -70,6 +71,7 @@ public class NEIClientConfig {
private static boolean pluginNEIConfigLoaded; private static boolean pluginNEIConfigLoaded;
private static boolean enabledOverride; private static boolean enabledOverride;
private static String worldPath; private static String worldPath;
private static final String CHEAT_MODE_KEY = "cheatmode";
public static Logger logger = LogManager.getLogger("NotEnoughItems"); public static Logger logger = LogManager.getLogger("NotEnoughItems");
public static File configDir = new File(CommonUtils.getMinecraftDir(), "config/NEI/"); public static File configDir = new File(CommonUtils.getMinecraftDir(), "config/NEI/");
@@ -146,6 +148,9 @@ public class NEIClientConfig {
tag.getTag("inventory.widgetsenabled").getBooleanValue(true); tag.getTag("inventory.widgetsenabled").getBooleanValue(true);
API.addOption(new OptionToggleButton("inventory.widgetsenabled")); API.addOption(new OptionToggleButton("inventory.widgetsenabled"));
tag.getTag("findFuelsParallel").getBooleanValue(true);
tag.getTag("showRepairOnlyForDamageableItems").getBooleanValue(true);
tag.getTag("inventory.autocrafting").getBooleanValue(true); tag.getTag("inventory.autocrafting").getBooleanValue(true);
tag.getTag("inventory.dynamicFontSize").getBooleanValue(true); tag.getTag("inventory.dynamicFontSize").getBooleanValue(true);
tag.getTag("inventory.hidden").getBooleanValue(false); tag.getTag("inventory.hidden").getBooleanValue(false);
@@ -155,6 +160,16 @@ public class NEIClientConfig {
.getIntValue(-1); .getIntValue(-1);
API.addOption(new OptionCycled("inventory.cheatmode", 3) { API.addOption(new OptionCycled("inventory.cheatmode", 3) {
@Override
public int value() {
return getCheatMode();
}
@Override
public void setValue(int value) {
setCheatMode(value);
}
@Override @Override
public boolean optionValid(int index) { public boolean optionValid(int index) {
return getLockedMode() == -1 || getLockedMode() == index && NEIInfo.isValidMode(index); return getLockedMode() == -1 || getLockedMode() == index && NEIInfo.isValidMode(index);
@@ -198,6 +213,11 @@ public class NEIClientConfig {
tag.getTag("inventory.bookmarks.showRecipeMarkerMode").setComment("Show Recipe Marker").getIntValue(0); tag.getTag("inventory.bookmarks.showRecipeMarkerMode").setComment("Show Recipe Marker").getIntValue(0);
API.addOption(new OptionCycled("inventory.bookmarks.showRecipeMarkerMode", 3, true)); API.addOption(new OptionCycled("inventory.bookmarks.showRecipeMarkerMode", 3, true));
tag.getTag("inventory.bookmarks.maxVerticalTooltipRows")
.setComment("Max rows in vertical crafting chain tooltip lists (0 - disable, always use grid)")
.getIntValue(12);
API.addOption(new OptionIntegerField("inventory.bookmarks.maxVerticalTooltipRows", 0, 50));
tag.getTag("inventory.bookmarks.recipeMarkerColor").setComment("Color of the icon marker") tag.getTag("inventory.bookmarks.recipeMarkerColor").setComment("Color of the icon marker")
.getHexValue(0xADADAD); .getHexValue(0xADADAD);
API.addOption( API.addOption(
@@ -206,8 +226,9 @@ public class NEIClientConfig {
0, 0,
OptionIntegerField.UNSIGNED_INT_MAX)); OptionIntegerField.UNSIGNED_INT_MAX));
tag.getTag("inventory.bookmarks.recipeChainDir").getIntValue(1); tag.getTag("inventory.bookmarks.showRecipeHandlerIcon").setComment("Show Recipe Handler Icon")
API.addOption(new OptionCycled("inventory.bookmarks.recipeChainDir", 2, true)); .getBooleanValue(false);
API.addOption(new OptionToggleButton("inventory.bookmarks.showRecipeHandlerIcon", true));
tag.getTag("inventory.bookmarks.ignorePotionOverlap").setComment("Ignore overlap with potion effect HUD") tag.getTag("inventory.bookmarks.ignorePotionOverlap").setComment("Ignore overlap with potion effect HUD")
.getBooleanValue(false); .getBooleanValue(false);
@@ -217,26 +238,26 @@ public class NEIClientConfig {
.getBooleanValue(true); .getBooleanValue(true);
API.addOption(new OptionToggleButton("inventory.bookmarks.bookmarkItemsWithRecipe", true)); API.addOption(new OptionToggleButton("inventory.bookmarks.bookmarkItemsWithRecipe", true));
tag.getTag("inventory.bookmarks.bookmarkRecipeWithCount").setComment("Bookmark recipe with count")
.getBooleanValue(false);
API.addOption(new OptionToggleButton("inventory.bookmarks.bookmarkRecipeWithCount", true));
tag.getTag("inventory.bookmarks.craftingTreeZoomWithoutModifier")
.setComment("Zoom Crafting Tree with mouse wheel without holding Ctrl").getBooleanValue(false);
API.addOption(new OptionToggleButton("inventory.bookmarks.craftingTreeZoomWithoutModifier", true));
tag.getTag("inventory.guirecipe.jeiStyleTabs").setComment("Enable/disable JEI Style Tabs") tag.getTag("inventory.guirecipe.jeiStyleTabs").setComment("Enable/disable JEI Style Tabs")
.getBooleanValue(true); .getBooleanValue(true);
API.addOption(new OptionToggleButtonBoubs("inventory.guirecipe.jeiStyleTabs", true)); API.addOption(new OptionToggleButtonBoubs("inventory.guirecipe.jeiStyleTabs", true));
tag.getTag("inventory.guirecipe.jeiStyleRecipeCatalyst").setComment("Enable/disable JEI Style Recipe Catalysts") tag.getTag("inventory.guirecipe.jeiStyleRecipeCatalyst")
.getBooleanValue(true); .setComment("JEI Style Recipe Catalysts (0 - none, 1 - grid, 2 - scroll)").getIntValue(1);
API.addOption(new OptionToggleButton("inventory.guirecipe.jeiStyleRecipeCatalyst", true)); API.addOption(new OptionCycled("inventory.guirecipe.jeiStyleRecipeCatalyst", 3, true));
tag.getTag("inventory.guirecipe.jeiStyleCycledIngredients").setComment("JEI styled cycled ingredients")
.getBooleanValue(true);
API.addOption(new OptionToggleButton("inventory.guirecipe.jeiStyleCycledIngredients", true));
tag.getTag("inventory.guirecipe.cycledIngredientsTooltip").setComment("Show cycled ingredients tooltip") tag.getTag("inventory.guirecipe.cycledIngredientsTooltip").setComment("Show cycled ingredients tooltip")
.getBooleanValue(true); .getBooleanValue(true);
API.addOption(new OptionToggleButton("inventory.guirecipe.cycledIngredientsTooltip", true)); API.addOption(new OptionToggleButton("inventory.guirecipe.cycledIngredientsTooltip", true));
tag.getTag("inventory.guirecipe.creativeTabStyle").setComment("Creative or JEI style tabs")
.getBooleanValue(false);
API.addOption(new OptionToggleButton("inventory.guirecipe.creativeTabStyle", true));
tag.getTag("inventory.guirecipe.itemPresenceOverlay").setComment("Item presence overlay on ?-hover") tag.getTag("inventory.guirecipe.itemPresenceOverlay").setComment("Item presence overlay on ?-hover")
.getIntValue(1); .getIntValue(1);
API.addOption(new OptionCycled("inventory.guirecipe.itemPresenceOverlay", 3, true)); API.addOption(new OptionCycled("inventory.guirecipe.itemPresenceOverlay", 3, true));
@@ -245,13 +266,33 @@ public class NEIClientConfig {
.getBooleanValue(true); .getBooleanValue(true);
API.addOption(new OptionToggleButton("inventory.guirecipe.slotHighlightPresent", true)); API.addOption(new OptionToggleButton("inventory.guirecipe.slotHighlightPresent", true));
tag.getTag("inventory.guirecipe.infiniteScroll").setComment("Use Infinite Scroll for Handlers")
.getBooleanValue(false);
API.addOption(new OptionToggleButton("inventory.guirecipe.infiniteScroll", true));
tag.getTag("inventory.guirecipe.maxHeight").setComment("Recipe GUI Max Height").getIntValue(370);
API.addOption(new OptionIntegerField("inventory.guirecipe.maxHeight", 166, 4000));
tag.getTag("inventory.guirecipe.shiftOverlayRecipe") tag.getTag("inventory.guirecipe.shiftOverlayRecipe")
.setComment("Require holding shift to move items when overlaying recipe").getBooleanValue(true); .setComment("Require holding shift to move items when overlaying recipe").getBooleanValue(true);
API.addOption(new OptionToggleButton("inventory.guirecipe.shiftOverlayRecipe", true)); API.addOption(new OptionToggleButton("inventory.guirecipe.shiftOverlayRecipe", true));
tag.getTag("inventory.guirecipe.scrollPages").setComment("Disable page scroll when overlaying recipe")
.getBooleanValue(true);
API.addOption(new OptionToggleButton("inventory.guirecipe.scrollPages", true));
tag.getTag("inventory.guirecipe.freezeCycleOnHover")
.setComment("Stop cycling the recipe while hovering over an ingredient or a button")
.getBooleanValue(false);
API.addOption(new OptionToggleButton("inventory.guirecipe.freezeCycleOnHover", true));
tag.getTag("inventory.guirecipe.profile").getBooleanValue(false); tag.getTag("inventory.guirecipe.profile").getBooleanValue(false);
API.addOption(new OptionToggleButton("inventory.guirecipe.profile", true)); API.addOption(new OptionToggleButton("inventory.guirecipe.profile", true));
tag.getTag("inventory.guirecipe.handlerInfo").setComment("ADVANCED: Handler Info Widget")
.getBooleanValue(false);
API.addOption(new OptionToggleButton("inventory.guirecipe.handlerInfo", true));
tag.getTag("inventory.subsets.enabled").setComment("Enable/disable Subsets Dropdown").getBooleanValue(true); tag.getTag("inventory.subsets.enabled").setComment("Enable/disable Subsets Dropdown").getBooleanValue(true);
API.addOption(new OptionToggleButton("inventory.subsets.enabled", true)); API.addOption(new OptionToggleButton("inventory.subsets.enabled", true));
@@ -261,15 +302,51 @@ public class NEIClientConfig {
tag.getTag("inventory.history.enabled").setComment("Enable/disable History Panel").getBooleanValue(true); tag.getTag("inventory.history.enabled").setComment("Enable/disable History Panel").getBooleanValue(true);
API.addOption(new OptionToggleButton("inventory.history.enabled", true)); API.addOption(new OptionToggleButton("inventory.history.enabled", true));
tag.getTag("inventory.history.historyColor").setComment("Color of the history area display") tag.getTag("inventory.history.color").setComment("Color of the history area display").getHexValue(0xee555555);
.getHexValue(0xee555555); API.addOption(new OptionIntegerField("inventory.history.color", 0, OptionIntegerField.UNSIGNED_INT_MAX));
API.addOption(new OptionIntegerField("inventory.history.historyColor", 0, OptionIntegerField.UNSIGNED_INT_MAX));
tag.getTag("inventory.history.useRows").setComment("Rows used in historical areas").getIntValue(2); tag.getTag("inventory.history.useRows").setComment("Rows used in historical areas").getIntValue(2);
API.addOption(new OptionIntegerField("inventory.history.useRows", 1, 5)); API.addOption(new OptionIntegerField("inventory.history.useRows", 1, 5));
tag.getTag("inventory.history.splittingMode").getIntValue(1); tag.getTag("inventory.history.worldSpecific").setComment("Global or world specific history")
API.addOption(new OptionCycled("inventory.history.splittingMode", 2, true)); .getBooleanValue(false);
API.addOption(new OptionToggleButton("inventory.history.worldSpecific", true) {
@Override
public boolean onClick(int button) {
super.onClick(button);
ItemPanels.itemPanel.historyPanel.save();
ItemPanels.itemPanel.historyPanel.load();
return true;
}
});
tag.getTag("inventory.history.save").setComment("Enable/disable History save").getBooleanValue(false);
API.addOption(new OptionToggleButton("inventory.history.save", true) {
@Override
public boolean onClick(int button) {
super.onClick(button);
ItemPanels.itemPanel.historyPanel.save();
ItemPanels.itemPanel.historyPanel.load();
return true;
}
});
tag.getTag("inventory.craftables.enabled").setComment("Enable/disable Craftables Panel").getBooleanValue(false);
API.addOption(new OptionToggleButton("inventory.craftables.enabled", true));
tag.getTag("inventory.craftables.color").setComment("Color of the craftables area display")
.getHexValue(0xee555555);
API.addOption(new OptionIntegerField("inventory.craftables.color", 0, OptionIntegerField.UNSIGNED_INT_MAX));
tag.getTag("inventory.craftables.useRows").setComment("Rows used in craftables areas").getIntValue(2);
API.addOption(new OptionIntegerField("inventory.craftables.useRows", 1, 5));
tag.getTag("inventory.craftables.favoritesOnly").setComment("Show Only Favorites Recipes")
.getBooleanValue(false);
API.addOption(new OptionToggleButton("inventory.craftables.favoritesOnly", true));
tag.getTag("inventory.collapsibleItems.enabled").getBooleanValue(true); tag.getTag("inventory.collapsibleItems.enabled").getBooleanValue(true);
API.addOption(new OptionToggleButton("inventory.collapsibleItems.enabled", true) { API.addOption(new OptionToggleButton("inventory.collapsibleItems.enabled", true) {
@@ -279,7 +356,7 @@ public class NEIClientConfig {
super.onClick(button); super.onClick(button);
CollapsibleItems.saveStates(); CollapsibleItems.saveStates();
CollapsibleItems.load(); CollapsibleItems.load();
LayoutManager.markItemsDirty(); ItemList.refreshItems.restart();
return true; return true;
} }
}); });
@@ -314,6 +391,11 @@ public class NEIClientConfig {
tag.getTag("inventory.itemzoom.onlySolid").getBooleanValue(false); tag.getTag("inventory.itemzoom.onlySolid").getBooleanValue(false);
API.addOption(new OptionToggleButton("inventory.itemzoom.onlySolid", true)); API.addOption(new OptionToggleButton("inventory.itemzoom.onlySolid", true));
tag.getTag("inventory.itemzoom.preferredSide")
.setComment("Which side to prefer showing the zoomed item on, when both sides are free.")
.getIntValue(0);
API.addOption(new OptionCycled("inventory.itemzoom.preferredSide", 3, true));
tag.getTag("inventory.itemzoom.helpText") tag.getTag("inventory.itemzoom.helpText")
.setComment("Display name \"Item Zoom\" and the hotkey to toggle this mod below the zoomed item.") .setComment("Display name \"Item Zoom\" and the hotkey to toggle this mod below the zoomed item.")
.getBooleanValue(true); .getBooleanValue(true);
@@ -330,6 +412,13 @@ public class NEIClientConfig {
setFavoriteDefaults(tag); setFavoriteDefaults(tag);
tag.getTag("inventory.tooltip.showFluidTemperature").setComment("Enabled show Fluid Temperature")
.getBooleanValue(true);
API.addOption(new OptionToggleButton("inventory.tooltip.showFluidTemperature", true));
tag.getTag("inventory.tooltip.showFluidState").setComment("Enabled show Fluid State").getBooleanValue(true);
API.addOption(new OptionToggleButton("inventory.tooltip.showFluidState", true));
tag.getTag("inventory.itemIDs").getIntValue(1); tag.getTag("inventory.itemIDs").getIntValue(1);
API.addOption(new OptionCycled("inventory.itemIDs", 3, true)); API.addOption(new OptionCycled("inventory.itemIDs", 3, true));
@@ -355,6 +444,46 @@ public class NEIClientConfig {
tag.getTag("world.overlays.lock").getBooleanValue(true); tag.getTag("world.overlays.lock").getBooleanValue(true);
API.addOption(new OptionToggleButton("world.overlays.lock", true)); API.addOption(new OptionToggleButton("world.overlays.lock", true));
tag.getTag("world.overlays.mobOverlayStyle")
.setComment("Mark on each block of the mob spawn overlay: " + MobOverlayStyle.formatAllNames())
.getValue(MobOverlayStyle.DEFAULT.formatName());
API.addOption(new OptionCycled("world.overlays.mobOverlayStyle", MobOverlayStyle.values().length, true) {
@Override
public int value() {
return MobOverlayStyle.parseStyle(getTag().getValue()).ordinal();
}
@Override
public void setValue(int value) {
getTag().setValue(MobOverlayStyle.values()[value].formatName());
}
@Override
public String getButtonText() {
return translateN(
"world.overlays.mobOverlayStyle."
+ MobOverlayStyle.parseStyle(getTag().getValue()).formatName());
}
});
tag.getTag("world.overlays.mobOverlayRadius")
.setComment("Blocks scanned on each side of the player by the mob spawn overlay")
.getIntValue(MobOverlayScan.DEFAULT_RADIUS);
API.addOption(
new OptionIntegerField(
"world.overlays.mobOverlayRadius",
MobOverlayScan.MIN_RADIUS,
MobOverlayScan.MAX_RADIUS));
tag.getTag("world.overlays.mobOverlayVerticalRadius")
.setComment("Blocks scanned above and below the player by the mob spawn overlay")
.getIntValue(MobOverlayScan.DEFAULT_VERTICAL_RADIUS);
API.addOption(
new OptionIntegerField(
"world.overlays.mobOverlayVerticalRadius",
MobOverlayScan.MIN_VERTICAL_RADIUS,
MobOverlayScan.MAX_VERTICAL_RADIUS));
tag.getTag("inventory.itempanelScale").getIntValue(100); tag.getTag("inventory.itempanelScale").getIntValue(100);
ItemsPanelGrid.updateScale(); ItemsPanelGrid.updateScale();
API.addOption(new OptionIntegerField("inventory.itempanelScale", 1, 1000) { API.addOption(new OptionIntegerField("inventory.itempanelScale", 1, 1000) {
@@ -391,6 +520,8 @@ public class NEIClientConfig {
}); });
tag.getTag("inventory.hotkeysHelpText").getBooleanValue(true); tag.getTag("inventory.hotkeysHelpText").getBooleanValue(true);
API.addOption(new OptionToggleButton("inventory.hotkeysHelpText", true)); API.addOption(new OptionToggleButton("inventory.hotkeysHelpText", true));
tag.getTag("inventory.showHotkeys").getBooleanValue(true);
API.addOption(new OptionToggleButton("inventory.showHotkeys", true));
tag.getTag("loadPluginsInParallel").getBooleanValue(true); tag.getTag("loadPluginsInParallel").getBooleanValue(true);
tag.getTag("itemLoadingTimeout").getIntValue(500); tag.getTag("itemLoadingTimeout").getIntValue(500);
@@ -409,36 +540,53 @@ public class NEIClientConfig {
tag.getTag("inventory.showItemQuantityWidget").setComment("Show Item Quantity Widget").getBooleanValue(true); tag.getTag("inventory.showItemQuantityWidget").setComment("Show Item Quantity Widget").getBooleanValue(true);
API.addOption(new OptionToggleButton("inventory.showItemQuantityWidget", true)); API.addOption(new OptionToggleButton("inventory.showItemQuantityWidget", true));
tag.getTag("inventory.optimize_gui_overlap_computation").setComment("Optimize computation for GUI overlap")
.getBooleanValue(false);
API.addOption(new OptionToggleButton("inventory.optimize_gui_overlap_computation", true));
tag.getTag("inventory.autocrafting").setComment("Autocrafting").getBooleanValue(true); tag.getTag("inventory.autocrafting").setComment("Autocrafting").getBooleanValue(true);
API.addOption(new OptionToggleButton("inventory.autocrafting", true)); API.addOption(new OptionToggleButton("inventory.autocrafting", true));
tag.getTag("tools.handler_load_from_config").setComment("ADVANCED: Load handlers from config") tag.getTag("inventory.itemUntranslator").setComment("Item Untranslator").getBooleanValue(true);
.getBooleanValue(false); API.addOption(new OptionToggleButton("inventory.itemUntranslator", true) {
API.addOption(new OptionToggleButton("tools.handler_load_from_config", true) {
@Override @Override
public boolean onClick(int button) { public boolean onClick(int button) {
super.onClick(button); super.onClick(button);
GuiRecipeTab.loadHandlerInfo();
if (enableItemUntranslator()) {
ItemUntranslator.getInstance().load();
} else {
ItemUntranslator.getInstance().unload();
}
return true; return true;
} }
}); });
tag.getTag("tools.catalyst_load_from_config").setComment("ADVANCED: Load catalysts from config") API.addOption(
.getBooleanValue(false); new OptionButton(
API.addOption(new OptionToggleButton("tools.catalyst_load_from_config", true) { "tools.export_configs.all",
"tools.export_configs.all",
null,
"tools.export_configs.all.tip") {
@Override @Override
public boolean onClick(int button) { public String getButtonText() {
super.onClick(button); return translateN("tools.export_configs.button");
RecipeCatalysts.loadCatalystInfo(); }
return true;
} @Override
}); public boolean onClick(int button) {
int exported = 0;
for (String resource : ClientHandler.DEFAULT_CONFIGS) {
if (ClientHandler.exportDefaultConfig(resource)) exported++;
}
NEIClientUtils.printChatMessage(
new ChatComponentTranslation("nei.options.tools.export_configs.all.done", exported));
return true;
}
});
ClientHandler.DEFAULT_CONFIGS.forEach(fileName -> API.addOption(new OptionExportConfig(fileName)));
setDefaultKeyBindings(); setDefaultKeyBindings();
} }
@@ -447,23 +595,18 @@ public class NEIClientConfig {
OptionList.setOptionList(new OptionList("nei.options") { OptionList.setOptionList(new OptionList("nei.options") {
@Override @Override
public ConfigSet globalConfigSet() { public ConfigSet configSet() {
return global; return global;
} }
@Override
public ConfigSet worldConfigSet() {
return world;
}
@Override @Override
public OptionList configBase() { public OptionList configBase() {
return this; return this;
} }
@Override @Override
public GuiOptionList getGui(GuiScreen parent, OptionList list, boolean world) { public GuiOptionList getGui(GuiScreen parent, OptionList list) {
return new GuiNEIOptionList(parent, list, world); return new GuiNEIOptionList(parent, list);
} }
}); });
} }
@@ -492,12 +635,15 @@ public class NEIClientConfig {
API.addOption(new OptionCycled("inventory.search.widgetAutofocus", 3, true)); API.addOption(new OptionCycled("inventory.search.widgetAutofocus", 3, true));
tag.getTag("inventory.search.patternMode").setComment("Search Mode").getIntValue(1); tag.getTag("inventory.search.patternMode").setComment("Search Mode").getIntValue(1);
API.addOption(new OptionCycled("inventory.search.patternMode", 3, true) { API.addOption(new OptionCycled("inventory.search.patternMode", 4, true) {
@Override @Override
public boolean onClick(int button) { public boolean onClick(int button) {
if (!super.onClick(button)) {
return false;
}
SearchField.searchParser.clearCache(); SearchField.searchParser.clearCache();
return super.onClick(button); return true;
} }
}); });
@@ -550,7 +696,7 @@ public class NEIClientConfig {
@Override @Override
public boolean onClick(int button) { public boolean onClick(int button) {
// SearchField.searchParser.clearCache(); SearchField.searchParser.clearCache();
return super.onClick(button); return super.onClick(button);
} }
@@ -567,8 +713,11 @@ public class NEIClientConfig {
@Override @Override
public boolean onClick(int button) { public boolean onClick(int button) {
if (!super.onClick(button)) {
return false;
}
SearchField.searchParser.clearCache(); SearchField.searchParser.clearCache();
return super.onClick(button); return true;
} }
@Override @Override
@@ -592,8 +741,11 @@ public class NEIClientConfig {
@Override @Override
public boolean onClick(int button) { public boolean onClick(int button) {
if (!super.onClick(button)) {
return false;
}
SearchField.searchParser.clearCache(); SearchField.searchParser.clearCache();
return super.onClick(button); return true;
} }
@Override @Override
@@ -616,8 +768,11 @@ public class NEIClientConfig {
@Override @Override
public boolean onClick(int button) { public boolean onClick(int button) {
if (!super.onClick(button)) {
return false;
}
SearchField.searchParser.clearCache(); SearchField.searchParser.clearCache();
return super.onClick(button); return true;
} }
@Override @Override
@@ -640,8 +795,11 @@ public class NEIClientConfig {
@Override @Override
public boolean onClick(int button) { public boolean onClick(int button) {
if (!super.onClick(button)) {
return false;
}
SearchField.searchParser.clearCache(); SearchField.searchParser.clearCache();
return super.onClick(button); return true;
} }
@Override @Override
@@ -664,8 +822,11 @@ public class NEIClientConfig {
@Override @Override
public boolean onClick(int button) { public boolean onClick(int button) {
if (!super.onClick(button)) {
return false;
}
SearchField.searchParser.clearCache(); SearchField.searchParser.clearCache();
return super.onClick(button); return true;
} }
@Override @Override
@@ -683,6 +844,9 @@ public class NEIClientConfig {
}); });
tag.getTag("inventory.search.logSearchExceptions").setComment("Search exceptions for extended+")
.getBooleanValue(false);
String prefixRedefinitions = tag.getTag("inventory.search.prefixRedefinitions").setComment( String prefixRedefinitions = tag.getTag("inventory.search.prefixRedefinitions").setComment(
"Redefine search prefixes by providing a char-to-char map (JSON). The keys are the original prefixes, the values the new ones. Example: { \"$\": \"€\", \"#\": \"+\", \"@\": \"°\", \"%\": \"!\" }") "Redefine search prefixes by providing a char-to-char map (JSON). The keys are the original prefixes, the values the new ones. Example: { \"$\": \"€\", \"#\": \"+\", \"@\": \"°\", \"%\": \"!\" }")
.getValue("{}"); .getValue("{}");
@@ -693,6 +857,7 @@ public class NEIClientConfig {
}; };
Map<Character, Character> charMap = new Gson().fromJson(prefixRedefinitions, typeToken.getType()); Map<Character, Character> charMap = new Gson().fromJson(prefixRedefinitions, typeToken.getType());
SearchField.searchParser.prefixRedefinitions.putAll(charMap); SearchField.searchParser.prefixRedefinitions.putAll(charMap);
SearchField.searchParser.clearCache();
} catch (JsonParseException e) { } catch (JsonParseException e) {
logger.warn("Failed to convert prefix redefinitions from JSON to CharToCharMap:", e); logger.warn("Failed to convert prefix redefinitions from JSON to CharToCharMap:", e);
} }
@@ -711,8 +876,7 @@ public class NEIClientConfig {
@Override @Override
public boolean onClick(int button) { public boolean onClick(int button) {
super.onClick(button); super.onClick(button);
FavoriteRecipes.save(); FavoriteRecipes.reload();
FavoriteRecipes.load();
return true; return true;
} }
}); });
@@ -725,38 +889,56 @@ public class NEIClientConfig {
.getBooleanValue(false); .getBooleanValue(false);
API.addOption(new OptionToggleButton("inventory.favorites.showRecipeTooltipInGui", true)); API.addOption(new OptionToggleButton("inventory.favorites.showRecipeTooltipInGui", true));
tag.getTag("inventory.favorites.depth").setComment("Bookmark creation depth").getIntValue(3); tag.getTag("inventory.favorites.generateSingleRecipeFavorites")
.setComment("Automatically generate favorites for items with only one recipe").getBooleanValue(false);
API.addOption(new OptionToggleButton("inventory.favorites.generateSingleRecipeFavorites", true) {
@Override
public boolean onClick(int button) {
super.onClick(button);
FavoriteRecipes.loadAutoGeneratedRecipes();
return true;
}
});
tag.getTag("inventory.favorites.depth").setComment("Bookmark creation depth").getIntValue(9);
API.addOption(new OptionIntegerField("inventory.favorites.depth", 0, 100)); API.addOption(new OptionIntegerField("inventory.favorites.depth", 0, 100));
} }
private static void setDefaultKeyBindings() { private static void setDefaultKeyBindings() {
API.addHashBind("gui.recipe", Keyboard.KEY_R); API.addKeyBind("gui.enchant", Keyboard.KEY_X);
API.addHashBind("gui.usage", Keyboard.KEY_U); API.addKeyBind("gui.potion", Keyboard.KEY_P);
API.addKeyBind("gui.back", Keyboard.KEY_BACK);
API.addHashBind("gui.enchant", Keyboard.KEY_X);
API.addHashBind("gui.potion", Keyboard.KEY_P);
API.addKeyBind("gui.prev", Keyboard.KEY_PRIOR); API.addKeyBind("gui.prev", Keyboard.KEY_PRIOR);
API.addKeyBind("gui.next", Keyboard.KEY_NEXT); API.addKeyBind("gui.next", Keyboard.KEY_NEXT);
API.addKeyBind("gui.prev_machine", Keyboard.KEY_UP); API.addKeyBind("gui.hide", Keyboard.KEY_O);
API.addKeyBind("gui.next_machine", Keyboard.KEY_DOWN); API.addKeyBind("gui.search", Keyboard.KEY_F);
API.addKeyBind("gui.prev_recipe", Keyboard.KEY_LEFT);
API.addKeyBind("gui.next_recipe", Keyboard.KEY_RIGHT);
API.addHashBind("gui.hide", Keyboard.KEY_O);
API.addHashBind("gui.search", Keyboard.KEY_F);
API.addKeyBind("gui.bookmark", Keyboard.KEY_A);
API.addHashBind("gui.remove_recipe", Keyboard.KEY_A + NEIClientUtils.SHIFT_HASH);
API.addKeyBind("gui.bookmark_pull_items", Keyboard.KEY_V);
API.addKeyBind("gui.overlay", Keyboard.KEY_S); API.addKeyBind("gui.overlay", Keyboard.KEY_S);
API.addKeyBind("gui.craft_items", Keyboard.KEY_C); API.addKeyBind("gui.craft_items", Keyboard.KEY_C);
API.addHashBind("gui.hide_bookmarks", Keyboard.KEY_B);
API.addKeyBind("gui.getprevioussearch", Keyboard.KEY_UP); API.addKeyBind("gui.getprevioussearch", Keyboard.KEY_UP);
API.addKeyBind("gui.getnextsearch", Keyboard.KEY_DOWN); API.addKeyBind("gui.getnextsearch", Keyboard.KEY_DOWN);
API.addKeyBind("gui.next_tooltip", Keyboard.KEY_Z); API.addKeyBind("gui.next_tooltip", Keyboard.KEY_Z);
API.addHashBind("gui.itemzoom_toggle", Keyboard.KEY_Z + NEIClientUtils.SHIFT_HASH); API.addKeyBind("recipe.recipe", Keyboard.KEY_R);
API.addHashBind("gui.itemzoom_hold", 0); API.addKeyBind("recipe.usage", Keyboard.KEY_U);
API.addHashBind("gui.itemzoom_zoom_in", 0); API.addKeyBind("recipe.back", Keyboard.KEY_BACK);
API.addHashBind("gui.itemzoom_zoom_out", 0); API.addKeyBind("recipe.prev_machine", Keyboard.KEY_UP);
API.addKeyBind("recipe.next_machine", Keyboard.KEY_DOWN);
API.addKeyBind("recipe.prev_recipe", Keyboard.KEY_LEFT);
API.addKeyBind("recipe.next_recipe", Keyboard.KEY_RIGHT);
API.addKeyBind("bookmark.add", Keyboard.KEY_A);
API.addKeyBind("bookmark.favorite", Keyboard.KEY_F);
API.addKeyBind("bookmark.favorite_item", Keyboard.KEY_F);
API.addKeyBind("bookmark.remove_recipe", Keyboard.KEY_A);
API.addKeyBind("bookmark.pull_items", Keyboard.KEY_V);
API.addKeyBind("bookmark.chat_link", Keyboard.KEY_L);
API.addKeyBind("bookmark.open_crafting_tree", Keyboard.KEY_T);
API.addKeyBind("bookmark.hide", Keyboard.KEY_B);
API.addKeyBind("itemzoom.toggle", Keyboard.KEY_Z);
API.addKeyBind("itemzoom.hold", 0);
API.addKeyBind("itemzoom.zoom_in", 0);
API.addKeyBind("itemzoom.zoom_out", 0);
API.addKeyBind("world.chunkoverlay", Keyboard.KEY_F9); API.addKeyBind("world.chunkoverlay", Keyboard.KEY_F9);
API.addKeyBind("world.moboverlay", Keyboard.KEY_F7); API.addKeyBind("world.moboverlay", Keyboard.KEY_F7);
@@ -768,9 +950,10 @@ public class NEIClientConfig {
API.addKeyBind("world.rain", 0); API.addKeyBind("world.rain", 0);
API.addKeyBind("world.heal", 0); API.addKeyBind("world.heal", 0);
API.addKeyBind("world.creative", 0); API.addKeyBind("world.creative", 0);
API.addHashBind("gui.copy_name", Keyboard.KEY_C + NEIClientUtils.CTRL_HASH);
API.addHashBind("gui.copy_oredict", Keyboard.KEY_D + NEIClientUtils.CTRL_HASH); API.addKeyBind("copy.name", Keyboard.KEY_C);
API.addHashBind("gui.chat_link_item", Keyboard.KEY_L + NEIClientUtils.CTRL_HASH); API.addKeyBind("copy.oredict", Keyboard.KEY_D);
API.addKeyBind("copy.identifier", Keyboard.KEY_X);
} }
public static OptionList getOptionList() { public static OptionList getOptionList() {
@@ -778,24 +961,32 @@ public class NEIClientConfig {
} }
public static void loadWorld(String worldPath) { public static void loadWorld(String worldPath) {
final File specificDir = new File(CommonUtils.getMinecraftDir(), "saves/NEI/" + worldPath);
final boolean newWorld = !specificDir.exists();
unloadWorld(); unloadWorld();
setInternalEnabled(true); setInternalEnabled(true);
if (!worldPath.equals(NEIClientConfig.worldPath)) { if (!worldPath.equals(NEIClientConfig.worldPath) || newWorld) {
NEIClientConfig.worldPath = worldPath; NEIClientConfig.worldPath = worldPath;
logger.debug("Loading " + (Minecraft.getMinecraft().isSingleplayer() ? "Local" : "Remote") + " World");
final File specificDir = new File(CommonUtils.getMinecraftDir(), "saves/NEI/" + worldPath);
final boolean newWorld = !specificDir.exists();
if (newWorld) { if (newWorld) {
specificDir.mkdirs(); specificDir.mkdirs();
} }
world = new ConfigSet(new File(specificDir, "NEI.dat"), new ConfigFile(new File(specificDir, "NEI.cfg"))); world = new ConfigSet(new File(specificDir, "NEI.dat"));
if (newWorld && Minecraft.getMinecraft().isSingleplayer() && getLockedMode() == -1) {
final int globalMode = getCheatMode();
final int worldMode = Math
.min(globalMode, NEIClientUtils.mc().playerController.isInCreativeMode() ? 2 : 0);
if (worldMode != globalMode) {
setCheatMode(worldMode);
}
}
bootNEI(); bootNEI();
onWorldLoad(newWorld); onWorldLoad();
} }
} }
@@ -803,20 +994,11 @@ public class NEIClientConfig {
return NEIClientConfig.worldPath; return NEIClientConfig.worldPath;
} }
private static void onWorldLoad(boolean newWorld) { private static void onWorldLoad() {
world.config.setComment(
"World based configuration of NEI.\nMost of these options can be changed ingame.\nDeleting any element will restore it to it's default value");
setWorldDefaults(); setWorldDefaults();
creativeInv = new ItemStack[54]; creativeInv = new ItemStack[54];
LayoutManager.searchField.setText(getSearchExpression()); LayoutManager.searchField.setText(getSearchExpression());
LayoutManager.quantity.setText(Integer.toString(getItemQuantity())); LayoutManager.quantity.setText(Integer.toString(getItemQuantity()));
if (newWorld && Minecraft.getMinecraft().isSingleplayer()) {
world.config.getTag("inventory.cheatmode")
.setIntValue(NEIClientUtils.mc().playerController.isInCreativeMode() ? 2 : 0);
}
NEIInfo.load(ClientUtils.getWorld()); NEIInfo.load(ClientUtils.getWorld());
} }
@@ -830,63 +1012,41 @@ public class NEIClientConfig {
} }
public static void unloadWorld() { public static void unloadWorld() {
if (ItemPanels.bookmarkPanel != null) { if (world == null) {
ItemPanels.bookmarkPanel.save(); return;
} }
ItemPanels.bookmarkPanel.save();
ItemPanels.itemPanel.historyPanel.save();
SubsetWidget.saveHidden(); SubsetWidget.saveHidden();
FavoriteRecipes.save(); FavoriteRecipes.save();
CollapsibleItems.saveStates(); CollapsibleItems.saveStates();
world.saveNBT();
if (world != null) {
world.saveNBT();
}
} }
private static final Map<String, String> keySettings = new HashMap<>();
public static int getKeyBinding(String string) { public static int getKeyBinding(String string) {
final String key = keySettings.computeIfAbsent(string, s -> "keys." + s); return KeyManager.getKeyCode(string);
return getSetting(key).getIntValue(Keyboard.KEY_NONE);
} }
public static void setDefaultKeyBinding(String string, int key) { public static void setDefaultKeyBinding(String string, int key) {
getSetting("keys." + string).getIntValue(key); KeyManager.registerKeyBinding(string, key);
} }
public static boolean isKeyHashDown(String string) { public static boolean isKeyHashDown(String string) {
final int hash = getKeyBinding(string); return KeyManager.isHashDown(string);
if (hash != Keyboard.CHAR_NONE && Keyboard.getEventKeyState()) {
return KeyManager.keyStates.containsKey(string) ? hash == Keyboard.getEventKey()
: hash == NEIClientUtils.getKeyHash();
}
return false;
} }
public static String getKeyName(String keyBind) { public static String getKeyName(String keyBind) {
return getKeyName(keyBind, 0); return KeyManager.getKeyName(keyBind);
} }
public static String getKeyName(String keyBind, int meta, int mouseBind) { public static String getKeyName(String keyBind, int meta, int mouseBind) {
final int hash = getKeyBinding(keyBind); return KeyManager.getKeyName(keyBind, meta, mouseBind);
if (hash == Keyboard.CHAR_NONE) {
return null;
}
return NEIClientUtils.getKeyName(hash + meta, mouseBind);
} }
public static String getKeyName(String keyBind, int meta) { public static String getKeyName(String keyBind, int meta) {
final int hash = getKeyBinding(keyBind); return KeyManager.getKeyName(keyBind, meta);
if (hash == Keyboard.CHAR_NONE) {
return null;
}
return NEIKeyboardUtils.getKeyName(hash + meta);
} }
public static void bootNEI() { public static void bootNEI() {
@@ -895,7 +1055,6 @@ public class NEIClientConfig {
// main NEI config loading // main NEI config loading
ItemInfo.load(); ItemInfo.load();
GuiInfo.load(); GuiInfo.load();
RecipeInfo.load();
HeldItemHandler.load(); HeldItemHandler.load();
LayoutManager.load(); LayoutManager.load();
NEIController.load(); NEIController.load();
@@ -907,27 +1066,18 @@ public class NEIClientConfig {
@Override @Override
public void run() { public void run() {
final Stream<Class<?>> stream = NEIClientConfig.getBooleanSetting("loadPluginsInParallel") PluginLoader.load(
? NEIClientConfig.pluginsList.parallelStream() NEIClientConfig.pluginsList,
: NEIClientConfig.pluginsList.stream(); NEIClientConfig.getBooleanSetting("loadPluginsInParallel"),
NEIModContainer.plugins,
stream.forEach(clazz -> { logger);
try {
IConfigureNEI config = (IConfigureNEI) clazz.getConstructor().newInstance();
config.loadConfig();
NEIModContainer.plugins.add(config);
logger.debug("Loaded {}", clazz.getName());
} catch (Throwable e) {
logger.error("Failed to Load {}", clazz.getName(), e);
}
});
KeyManager.requestOptionsReload();
RecipeCatalysts.loadCatalystInfo(); RecipeCatalysts.loadCatalystInfo();
SubsetWidget.loadCustomSubsets(); SubsetWidget.loadCustomSubsets();
SubsetWidget.loadHidden(); SubsetWidget.loadHidden();
CollapsibleItems.load(); CollapsibleItems.load();
ItemSorter.loadConfig(); ItemSorter.loadConfig();
FavoriteRecipes.load();
// Set pluginNEIConfigLoaded here before posting the NEIConfigsLoadedEvent. This used to be the // Set pluginNEIConfigLoaded here before posting the NEIConfigsLoadedEvent. This used to be the
// other way around, but apparently if your modpack includes 800 mods the event poster might not // other way around, but apparently if your modpack includes 800 mods the event poster might not
@@ -936,25 +1086,22 @@ public class NEIClientConfig {
// API. I don't expect any handler to do this, but who knows what modders have come up with... // API. I don't expect any handler to do this, but who knows what modders have come up with...
pluginNEIConfigLoaded = true; pluginNEIConfigLoaded = true;
MinecraftForge.EVENT_BUS.post(new NEIConfigsLoadedEvent()); MinecraftForge.EVENT_BUS.post(new NEIConfigsLoadedEvent());
ItemList.loadItems.restart(); ItemList.loadItems.restart();
} }
}.start(); }.start();
} else { } else {
SubsetWidget.loadHidden(); SubsetWidget.loadHidden();
ItemList.loadItems.restart(); if (ItemList.loadFinished) {
ItemList.refreshItems.restart();
} else {
ItemList.loadItems.restart();
}
} }
} }
public static boolean isWorldSpecific(String setting) {
if (world == null) return false;
ConfigTag tag = world.config.getTag(setting, false);
return tag != null && tag.value != null;
}
public static ConfigTag getSetting(String s) { public static ConfigTag getSetting(String s) {
return isWorldSpecific(s) ? world.config.getTag(s) : global.config.getTag(s); return global.config.getTag(s);
} }
public static boolean getBooleanSetting(String s) { public static boolean getBooleanSetting(String s) {
@@ -966,7 +1113,9 @@ public class NEIClientConfig {
} }
public static boolean autocraftingEnabled() { public static boolean autocraftingEnabled() {
return getBooleanSetting("inventory.autocrafting"); if (!getBooleanSetting("inventory.autocrafting")) return false;
if (hasSMPCounterpart) return permissableActions.contains("autocraft");
return true;
} }
public static boolean favoritesEnabled() { public static boolean favoritesEnabled() {
@@ -997,6 +1146,10 @@ public class NEIClientConfig {
return getIntSetting("inventory.bookmarks.showRecipeMarkerMode"); return getIntSetting("inventory.bookmarks.showRecipeMarkerMode");
} }
public static int getMaxVerticalTooltipRows() {
return getIntSetting("inventory.bookmarks.maxVerticalTooltipRows");
}
public static boolean showItemQuantityWidget() { public static boolean showItemQuantityWidget() {
return getBooleanSetting("inventory.showItemQuantityWidget"); return getBooleanSetting("inventory.showItemQuantityWidget");
} }
@@ -1033,34 +1186,26 @@ public class NEIClientConfig {
return getBooleanSetting("inventory.guirecipe.slotHighlightPresent"); return getBooleanSetting("inventory.guirecipe.slotHighlightPresent");
} }
public static boolean areJEIStyleRecipeCatalystsVisible() { public static int getJEIStyleRecipeCatalysts() {
return getBooleanSetting("inventory.guirecipe.jeiStyleRecipeCatalyst"); return getIntSetting("inventory.guirecipe.jeiStyleRecipeCatalyst");
}
public static boolean useCreativeTabStyle() {
return getBooleanSetting("inventory.guirecipe.creativeTabStyle");
} }
public static boolean ignorePotionOverlap() { public static boolean ignorePotionOverlap() {
return getBooleanSetting("inventory.bookmarks.ignorePotionOverlap"); return getBooleanSetting("inventory.bookmarks.ignorePotionOverlap");
} }
public static int recipeChainDir() { public static boolean craftingTreeZoomWithoutModifier() {
return getIntSetting("inventory.bookmarks.recipeChainDir"); return getBooleanSetting("inventory.bookmarks.craftingTreeZoomWithoutModifier");
}
public static boolean optimizeGuiOverlapComputation() {
return getBooleanSetting("inventory.optimize_gui_overlap_computation");
}
public static boolean useJEIStyledCycledIngredients() {
return getBooleanSetting("inventory.guirecipe.jeiStyleCycledIngredients");
} }
public static boolean showCycledIngredientsTooltip() { public static boolean showCycledIngredientsTooltip() {
return getBooleanSetting("inventory.guirecipe.cycledIngredientsTooltip"); return getBooleanSetting("inventory.guirecipe.cycledIngredientsTooltip");
} }
public static boolean freezeCycleOnHover() {
return getBooleanSetting("inventory.guirecipe.freezeCycleOnHover");
}
public static boolean requireShiftForOverlayRecipe() { public static boolean requireShiftForOverlayRecipe() {
return getBooleanSetting("inventory.guirecipe.shiftOverlayRecipe"); return getBooleanSetting("inventory.guirecipe.shiftOverlayRecipe");
} }
@@ -1073,14 +1218,6 @@ public class NEIClientConfig {
return mainNEIConfigLoaded && pluginNEIConfigLoaded; return mainNEIConfigLoaded && pluginNEIConfigLoaded;
} }
public static boolean loadHandlersFromJar() {
return !getBooleanSetting("tools.handler_load_from_config");
}
public static boolean loadCatalystsFromJar() {
return !getBooleanSetting("tools.catalyst_load_from_config");
}
public static boolean isProfileRecipeEnabled() { public static boolean isProfileRecipeEnabled() {
return NEIClientConfig.getBooleanSetting("inventory.guirecipe.profile"); return NEIClientConfig.getBooleanSetting("inventory.guirecipe.profile");
} }
@@ -1094,12 +1231,18 @@ public class NEIClientConfig {
} }
public static int getCheatMode() { public static int getCheatMode() {
if (world != null && world.nbt.hasKey(CHEAT_MODE_KEY)) return world.nbt.getInteger(CHEAT_MODE_KEY);
return getIntSetting("inventory.cheatmode"); return getIntSetting("inventory.cheatmode");
} }
public static void setCheatMode(int mode) {
if (world != null) world.nbt.setInteger(CHEAT_MODE_KEY, mode);
else setIntSetting("inventory.cheatmode", mode);
}
public static boolean canChangeCheatMode() { public static boolean canChangeCheatMode() {
if (getLockedMode() != -1) { if (getLockedMode() != -1) {
setIntSetting("inventory.cheatmode", getLockedMode()); setCheatMode(getLockedMode());
return false; return false;
} }
@@ -1165,6 +1308,10 @@ public class NEIClientConfig {
return getBooleanSetting("inventory.history.enabled"); return getBooleanSetting("inventory.history.enabled");
} }
public static boolean showCraftablesPanelWidget() {
return getBooleanSetting("inventory.craftables.enabled");
}
public static int getGridRenderingCacheMode() { public static int getGridRenderingCacheMode() {
return OpenGlHelper.framebufferSupported ? getIntSetting("inventory.gridRenderingCacheMode") : 0; return OpenGlHelper.framebufferSupported ? getIntSetting("inventory.gridRenderingCacheMode") : 0;
} }
@@ -1173,6 +1320,10 @@ public class NEIClientConfig {
return getBooleanSetting("inventory.collapsibleItems.enabled"); return getBooleanSetting("inventory.collapsibleItems.enabled");
} }
public static boolean enableItemUntranslator() {
return getBooleanSetting("inventory.itemUntranslator");
}
public static boolean getMagnetMode() { public static boolean getMagnetMode() {
return enabledActions.contains("magnet"); return enabledActions.contains("magnet");
} }
+154 -72
View File
@@ -9,10 +9,12 @@ import static codechicken.nei.NEIClientConfig.invCreativeMode;
import static codechicken.nei.NEIClientConfig.world; import static codechicken.nei.NEIClientConfig.world;
import java.awt.Color; import java.awt.Color;
import java.io.File;
import java.io.IOException;
import java.io.PrintWriter; import java.io.PrintWriter;
import java.io.StringWriter; import java.io.StringWriter;
import java.math.BigInteger;
import java.math.RoundingMode; import java.math.RoundingMode;
import java.nio.file.Files;
import java.text.DecimalFormat; import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols; import java.text.DecimalFormatSymbols;
import java.text.MessageFormat; import java.text.MessageFormat;
@@ -21,12 +23,13 @@ import java.util.ArrayList;
import java.util.Arrays; import java.util.Arrays;
import java.util.Collections; import java.util.Collections;
import java.util.HashMap; import java.util.HashMap;
import java.util.IdentityHashMap;
import java.util.LinkedList; import java.util.LinkedList;
import java.util.List; import java.util.List;
import java.util.Locale; import java.util.Locale;
import java.util.Map; import java.util.Map;
import java.util.Set; import java.util.Set;
import java.util.StringJoiner; import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors; import java.util.stream.Collectors;
import net.minecraft.client.Minecraft; import net.minecraft.client.Minecraft;
@@ -40,13 +43,16 @@ import net.minecraft.inventory.Container;
import net.minecraft.inventory.Slot; import net.minecraft.inventory.Slot;
import net.minecraft.item.Item; import net.minecraft.item.Item;
import net.minecraft.item.ItemStack; import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.IChatComponent; import net.minecraft.util.IChatComponent;
import net.minecraft.util.ResourceLocation; import net.minecraft.util.ResourceLocation;
import net.minecraftforge.fluids.FluidStack;
import org.lwjgl.input.Keyboard; import org.lwjgl.input.Keyboard;
import org.lwjgl.opengl.GL11; import org.lwjgl.opengl.GL11;
import com.google.common.collect.Iterables; import com.google.common.collect.Iterables;
import com.gtnewhorizon.gtnhlib.util.numberformatting.NumberFormatUtil;
import codechicken.lib.gui.GuiDraw; import codechicken.lib.gui.GuiDraw;
import codechicken.lib.inventory.InventoryRange; import codechicken.lib.inventory.InventoryRange;
@@ -56,11 +62,14 @@ import codechicken.lib.vec.Rectangle4i;
import codechicken.nei.api.GuiInfo; import codechicken.nei.api.GuiInfo;
import codechicken.nei.api.IInfiniteItemHandler; import codechicken.nei.api.IInfiniteItemHandler;
import codechicken.nei.api.ItemInfo; import codechicken.nei.api.ItemInfo;
import codechicken.nei.recipe.GuiOverlayButton.ItemOverlayState;
import codechicken.nei.recipe.StackInfo;
import codechicken.nei.util.NEIKeyboardUtils; import codechicken.nei.util.NEIKeyboardUtils;
import codechicken.nei.util.NEIMouseUtils;
public class NEIClientUtils extends NEIServerUtils { public class NEIClientUtils extends NEIServerUtils {
private static final Set<String> REPORTED = ConcurrentHashMap.newKeySet();
public static class Alignment { public static class Alignment {
public final int x, y; public final int x, y;
@@ -95,6 +104,7 @@ public class NEIClientUtils extends NEIServerUtils {
/** Formats a number with group separator and at most 2 fraction digits. */ /** Formats a number with group separator and at most 2 fraction digits. */
private static final Map<Locale, DecimalFormat> decimalFormatters = new HashMap<>(); private static final Map<Locale, DecimalFormat> decimalFormatters = new HashMap<>();
private static final DecimalFormat CHANCE_FORMAT = new DecimalFormat("##0.##%");
public static final int ALT_HASH = NEIKeyboardUtils.ALT_HASH; public static final int ALT_HASH = NEIKeyboardUtils.ALT_HASH;
public static final int SHIFT_HASH = NEIKeyboardUtils.SHIFT_HASH; public static final int SHIFT_HASH = NEIKeyboardUtils.SHIFT_HASH;
@@ -126,16 +136,26 @@ public class NEIClientUtils extends NEIServerUtils {
}); });
} }
public static String formatNumbers(BigInteger aNumber) { public static String formatNumber(Number aNumber) {
if (NEIModContainer.isGTNHLibLoaded()) {
return NumberFormatUtil.formatNumber(aNumber);
}
return getDecimalFormat().format(aNumber); return getDecimalFormat().format(aNumber);
} }
public static String formatNumbers(long aNumber) { public static String formatFluid(Number aNumber) {
return getDecimalFormat().format(aNumber);
if (NEIModContainer.isGTNHLibLoaded()) {
return NumberFormatUtil.formatFluid(aNumber);
}
return getDecimalFormat().format(aNumber) + " L";
} }
public static String formatNumbers(double aNumber) { public static String formatChance(float chance) {
return getDecimalFormat().format(aNumber); return CHANCE_FORMAT.format(chance);
} }
public static void deleteHeldItem() { public static void deleteHeldItem() {
@@ -198,7 +218,7 @@ public class NEIClientUtils extends NEIServerUtils {
public static void cheatItem(ItemStack stack, int button, int mode) { public static void cheatItem(ItemStack stack, int button, int mode) {
if (!canCheatItem(stack)) return; if (!canCheatItem(stack)) return;
if (mode == -1 && button == 0 && shiftKey() && NEIClientConfig.hasSMPCounterPart()) { if (mode == -1 && button == 0 && controlKey() && NEIClientConfig.hasSMPCounterPart()) {
for (IInfiniteItemHandler handler : ItemInfo.infiniteHandlers) { for (IInfiniteItemHandler handler : ItemInfo.infiniteHandlers) {
if (!handler.canHandleItem(stack)) continue; if (!handler.canHandleItem(stack)) continue;
@@ -283,6 +303,83 @@ public class NEIClientUtils extends NEIServerUtils {
return InventoryUtils.getInsertibleQuantity(new InventoryRange(player.inventory, 0, 36), itemstack) > 0; return InventoryUtils.getInsertibleQuantity(new InventoryRange(player.inventory, 0, 36), itemstack) > 0;
} }
public static List<ItemOverlayState> presenceOverlay(List<PositionedStack> ingredients, List<ItemStack> invStacks) {
final List<ItemOverlayState> states = new ArrayList<>();
final Map<ItemStack, Long> remainingFluid = new IdentityHashMap<>();
for (PositionedStack stack : ingredients) {
boolean found;
if (StackInfo.isFluidDisplayItem(stack.item)) {
final FluidStack requiredFluid = StackInfo.getFluid(stack.item);
found = requiredFluid != null && consumeFluid(invStacks, remainingFluid, requiredFluid);
} else {
found = false;
for (ItemStack is : invStacks) {
if (is.stackSize > 0 && stack.contains(is)) {
is.stackSize--;
found = true;
break;
}
}
}
states.add(new ItemOverlayState(stack, found));
}
return states;
}
private static boolean consumeFluid(List<ItemStack> invStacks, Map<ItemStack, Long> remainingFluid,
FluidStack requiredFluid) {
long need = requiredFluid.amount;
final List<ItemStack> matched = new ArrayList<>();
for (ItemStack is : invStacks) {
if (need <= 0) {
break;
}
if (is.stackSize <= 0) {
continue;
}
final FluidStack invFluid = StackInfo.getFluid(is);
if (invFluid == null || !invFluid.isFluidEqual(requiredFluid)) {
continue;
}
final long available = remainingFluid.computeIfAbsent(is, k -> (long) invFluid.amount * is.stackSize);
if (available <= 0) {
continue;
}
matched.add(is);
need -= available;
}
if (need > 0) {
return false;
}
long remainingNeed = requiredFluid.amount;
for (ItemStack is : matched) {
final long available = remainingFluid.get(is);
final long consumed = Math.min(available, remainingNeed);
remainingFluid.put(is, available - consumed);
remainingNeed -= consumed;
if (remainingNeed <= 0) {
break;
}
}
return true;
}
public static boolean shiftKey() { public static boolean shiftKey() {
return Keyboard.isKeyDown(Keyboard.KEY_LSHIFT) || Keyboard.isKeyDown(Keyboard.KEY_RSHIFT); return Keyboard.isKeyDown(Keyboard.KEY_LSHIFT) || Keyboard.isKeyDown(Keyboard.KEY_RSHIFT);
} }
@@ -370,8 +467,8 @@ public class NEIClientUtils extends NEIServerUtils {
else sendCommand(getStringSetting("command.heal"), mc().thePlayer.getCommandSenderName()); else sendCommand(getStringSetting("command.heal"), mc().thePlayer.getCommandSenderName());
} }
public static void sendChatItemLink(ItemStack stackover) { public static void sendChatItemLink(NBTTagCompound payload) {
if (hasSMPCounterPart()) NEICPH.sendChatLink(stackover); if (hasSMPCounterPart()) NEICPH.sendChatLink(payload);
} }
public static void toggleMagnetMode() { public static void toggleMagnetMode() {
@@ -413,18 +510,11 @@ public class NEIClientUtils extends NEIServerUtils {
if (textWidth > containerWidth) { if (textWidth > containerWidth) {
int dots = fontRenderer.getStringWidth("..."); int dots = fontRenderer.getStringWidth("...");
if (containerWidth > dots) { if (containerWidth <= dots) {
textWidth += dots; return "...";
while (textWidth > containerWidth) {
textWidth -= fontRenderer.getCharWidth(text.charAt(text.length() - 1));
text = text.substring(0, text.length() - 1);
}
return text + "...";
} }
return "..."; return fontRenderer.trimStringToWidth(text, containerWidth - dots) + "...";
} }
return text; return text;
@@ -452,55 +542,8 @@ public class NEIClientUtils extends NEIServerUtils {
return Keyboard.isKeyDown(Keyboard.KEY_LMENU) || Keyboard.isKeyDown(Keyboard.KEY_RMENU); return Keyboard.isKeyDown(Keyboard.KEY_LMENU) || Keyboard.isKeyDown(Keyboard.KEY_RMENU);
} }
public static int getMetaHash() {
if (Keyboard.getEventKeyState()) {
int hash = 0;
if (altKey()) {
hash = hash | ALT_HASH;
}
if (shiftKey()) {
hash = hash | SHIFT_HASH;
}
if (controlKey()) {
hash = hash | CTRL_HASH;
}
return hash;
}
return 0;
}
public static int getKeyHash() {
if (Keyboard.getEventKeyState()) {
final int keycode = Keyboard.getEventKey();
if (!NEIKeyboardUtils.isHashKey(keycode)) {
return getMetaHash() + keycode;
}
}
return Keyboard.CHAR_NONE;
}
public static String getKeyName(int keyBind, int mouseBind) { public static String getKeyName(int keyBind, int mouseBind) {
StringJoiner keyText = new StringJoiner(" + "); return KeyManager.getKeyName(keyBind, mouseBind);
String keyHash = keyBind == Keyboard.KEY_NONE ? "" : NEIKeyboardUtils.getKeyName(keyBind);
String mouseHash = mouseBind == NEIMouseUtils.MOUSE_BTN_NONE ? "" : NEIMouseUtils.getKeyName(mouseBind);
if (!keyHash.isEmpty()) {
keyText.add(keyHash);
}
if (!mouseHash.isEmpty()) {
keyText.add(mouseHash);
}
return keyText.toString();
} }
public static void playClickSound() { public static void playClickSound() {
@@ -527,8 +570,20 @@ public class NEIClientUtils extends NEIServerUtils {
} }
} }
public static long getScrollMultiplier(ItemStack stack) {
final long multiplier = NEIClientConfig.showItemQuantityWidget() ? NEIClientConfig.getItemQuantity() : 0;
if (multiplier != 0) {
return multiplier;
}
return StackInfo.isFluidDisplayItem(stack) ? 144 : stack.getMaxStackSize();
}
public static void drawRect(double left, double top, double width, double height, Color color) { public static void drawRect(double left, double top, double width, double height, Color color) {
Tessellator tessellator = Tessellator.instance; final boolean is2DTexture = GL11.glGetBoolean(GL11.GL_TEXTURE_2D);
final boolean isBlend = GL11.glGetBoolean(GL11.GL_BLEND);
final Tessellator tessellator = Tessellator.instance;
GL11.glEnable(GL11.GL_BLEND); GL11.glEnable(GL11.GL_BLEND);
GL11.glDisable(GL11.GL_TEXTURE_2D); GL11.glDisable(GL11.GL_TEXTURE_2D);
@@ -540,8 +595,9 @@ public class NEIClientUtils extends NEIServerUtils {
tessellator.addVertex(left + width, top, 0.0D); tessellator.addVertex(left + width, top, 0.0D);
tessellator.addVertex(left, top, 0.0D); tessellator.addVertex(left, top, 0.0D);
tessellator.draw(); tessellator.draw();
GL11.glEnable(GL11.GL_TEXTURE_2D); GL11.glColor4f(1, 1, 1, 1);
GL11.glDisable(GL11.GL_BLEND); if (is2DTexture) GL11.glEnable(GL11.GL_TEXTURE_2D);
if (!isBlend) GL11.glDisable(GL11.GL_BLEND);
} }
public static void drawNEIOverlayText(String text, Rectangle4i rect, float scale, int color, boolean shadow, public static void drawNEIOverlayText(String text, Rectangle4i rect, float scale, int color, boolean shadow,
@@ -566,6 +622,7 @@ public class NEIClientUtils extends NEIServerUtils {
GuiDraw.fontRenderer.drawString(text, 0, 0, color, shadow); GuiDraw.fontRenderer.drawString(text, 0, 0, color, shadow);
GL11.glScaled(1 / smallTextScale, 1 / smallTextScale, 1); GL11.glScaled(1 / smallTextScale, 1 / smallTextScale, 1);
GL11.glTranslated(-1 * offsetX, -1 * offsetY, 0); GL11.glTranslated(-1 * offsetX, -1 * offsetY, 0);
GL11.glColor4f(1, 1, 1, 1);
}); });
} }
@@ -588,4 +645,29 @@ public class NEIClientUtils extends NEIServerUtils {
if (!isAlphaTest) GL11.glDisable(GL11.GL_ALPHA_TEST); if (!isAlphaTest) GL11.glDisable(GL11.GL_ALPHA_TEST);
} }
public static void errorOnce(String key, String message, Throwable error) {
if (REPORTED.add(key)) {
NEIClientConfig.logger.error(message, error);
}
}
public static void warnOnce(String key, String message) {
if (REPORTED.add(key)) {
NEIClientConfig.logger.warn(message);
}
}
public static boolean backupFile(File file) {
final File backup = new File(file.getAbsolutePath() + ".backup-" + System.currentTimeMillis());
try {
Files.copy(file.toPath(), backup.toPath());
NEIClientConfig.logger.info("Backed up file {} to {}", file, backup);
return true;
} catch (IOException e) {
NEIClientConfig.logger.error("Failed to backup file {} to {}", file, backup, e);
return false;
}
}
} }
@@ -1,19 +1,21 @@
package codechicken.nei; package codechicken.nei;
import static codechicken.lib.gui.GuiDraw.getMousePosition; import static codechicken.lib.gui.GuiDraw.getMousePosition;
import static codechicken.nei.NEIClientConfig.canCheatItem;
import java.awt.Point; import java.awt.Point;
import java.util.LinkedList;
import net.minecraft.client.gui.inventory.GuiContainer; import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.client.gui.inventory.GuiContainerCreative; import net.minecraft.client.gui.inventory.GuiContainerCreative;
import net.minecraft.entity.player.InventoryPlayer; import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.Slot; import net.minecraft.inventory.Slot;
import net.minecraft.inventory.SlotCrafting; import net.minecraft.inventory.SlotCrafting;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack; import net.minecraft.item.ItemStack;
import net.minecraftforge.client.ClientCommandHandler; import net.minecraftforge.client.ClientCommandHandler;
import codechicken.core.CommonUtils; import codechicken.core.CommonUtils;
import codechicken.lib.gui.GuiDraw;
import codechicken.nei.api.API; import codechicken.nei.api.API;
import codechicken.nei.api.GuiInfo; import codechicken.nei.api.GuiInfo;
import codechicken.nei.api.IInfiniteItemHandler; import codechicken.nei.api.IInfiniteItemHandler;
@@ -21,10 +23,11 @@ import codechicken.nei.api.INEIGuiHandler;
import codechicken.nei.api.ItemInfo; import codechicken.nei.api.ItemInfo;
import codechicken.nei.commands.CommandBookmarkAdd; import codechicken.nei.commands.CommandBookmarkAdd;
import codechicken.nei.commands.CommandRecipeId; import codechicken.nei.commands.CommandRecipeId;
import codechicken.nei.commands.CommandUntranslator;
import codechicken.nei.guihook.GuiContainerManager; import codechicken.nei.guihook.GuiContainerManager;
import codechicken.nei.guihook.IContainerInputHandler; import codechicken.nei.guihook.IContainerInputHandler;
import codechicken.nei.guihook.IContainerSlotClickHandler; import codechicken.nei.guihook.IContainerSlotClickHandler;
import codechicken.nei.recipe.GuiRecipe; import codechicken.nei.util.EmptyContainer;
import cpw.mods.fml.relauncher.Side; import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly; import cpw.mods.fml.relauncher.SideOnly;
@@ -68,34 +71,44 @@ public class NEIController implements IContainerSlotClickHandler, IContainerInpu
public static void registerClientCommands() { public static void registerClientCommands() {
ClientCommandHandler.instance.registerCommand(new CommandBookmarkAdd()); ClientCommandHandler.instance.registerCommand(new CommandBookmarkAdd());
ClientCommandHandler.instance.registerCommand(new CommandRecipeId()); ClientCommandHandler.instance.registerCommand(new CommandRecipeId());
ClientCommandHandler.instance.registerCommand(new CommandUntranslator());
} }
public static void updateUnlimitedItems(InventoryPlayer inventory) { public static void updateUnlimitedItems(InventoryPlayer inventory) {
if (!NEIClientConfig.canPerformAction("item") || !NEIClientConfig.hasSMPCounterPart()) return; if (!NEIClientConfig.canPerformAction("item") || !NEIClientConfig.hasSMPCounterPart()) return;
LinkedList<ItemStack> beforeStacks = new LinkedList<>(); int size = inventory.getSizeInventory();
for (int i = 0; i < inventory.getSizeInventory(); i++) for (int i = 0; i < size; i++) {
beforeStacks.add(NEIServerUtils.copyStack(inventory.getStackInSlot(i)));
for (int i = 0; i < inventory.getSizeInventory(); i++) {
ItemStack stack = inventory.getStackInSlot(i); ItemStack stack = inventory.getStackInSlot(i);
if (stack == null) continue; if (stack == null) continue;
for (IInfiniteItemHandler handler : ItemInfo.infiniteHandlers) for (IInfiniteItemHandler handler : ItemInfo.infiniteHandlers) {
if (handler.canHandleItem(stack) && handler.isItemInfinite(stack)) if (!handler.canHandleItem(stack) || !handler.isItemInfinite(stack)) continue;
handler.replenishInfiniteStack(inventory, i);
}
for (int i = 0; i < inventory.getSizeInventory(); i++) { long beforeSize = packStackSize(stack.stackSize, stack.getItemDamage());
ItemStack newstack = inventory.getStackInSlot(i); handler.replenishInfiniteStack(inventory, i);
if (!NEIServerUtils.areStacksIdentical(beforeStacks.get(i), newstack)) { ItemStack newstack = inventory.getStackInSlot(i);
inventory.setInventorySlotContents(i, beforeStacks.get(i)); // restore in case of SMP fail if (!sameStack(stack, beforeSize, newstack)) {
NEIClientUtils.setSlotContents(i, newstack, false); // sends via SMP handler ;) NEIClientUtils.setSlotContents(i, newstack, false); // sends via SMP handler ;)
stack.stackSize = (int) (beforeSize >> 32);
stack.setItemDamage((int) beforeSize);
inventory.setInventorySlotContents(i, stack); // restore in case of SMP fail
}
} }
} }
} }
private static long packStackSize(int stackSize, int itemDamage) {
return ((long) stackSize << 32) | (itemDamage & 0xFFFFFFFFL);
}
private static boolean sameStack(ItemStack before, long beforeSize, ItemStack stack) {
if (stack == null) return before == null;
return before != null && Item.getIdFromItem(before.getItem()) == Item.getIdFromItem(stack.getItem())
&& beforeSize == packStackSize(stack.stackSize, stack.getItemDamage());
}
public static void processCreativeCycling(InventoryPlayer inventory) { public static void processCreativeCycling(InventoryPlayer inventory) {
if (NEIClientConfig.invCreativeMode() && NEIClientUtils.controlKey()) { if (NEIClientConfig.invCreativeMode() && NEIClientUtils.controlKey()) {
if (selectedItem != inventory.currentItem) { if (selectedItem != inventory.currentItem) {
@@ -136,7 +149,7 @@ public class NEIController implements IContainerSlotClickHandler, IContainerInpu
return true; return true;
} }
if (button == 1 && slot instanceof SlotCrafting) // right click if (button == 1 && modifier != 2 && slot instanceof SlotCrafting) // right click
{ {
for (int i1 = 0; i1 < 64; i1++) // click this slot 64 times for (int i1 = 0; i1 < 64; i1++) // click this slot 64 times
manager.handleSlotClick(slot.slotNumber, button, 0); manager.handleSlotClick(slot.slotNumber, button, 0);
@@ -148,26 +161,40 @@ public class NEIController implements IContainerSlotClickHandler, IContainerInpu
&& slot != null && slot != null
&& slot.getStack() != null && slot.getStack() != null
&& slot.isItemValid(slot.getStack())) { && slot.isItemValid(slot.getStack())) {
if (!canCheatItem(slot.getStack())) return false;
NEIClientUtils.cheatItem(slot.getStack(), button, 1); NEIClientUtils.cheatItem(slot.getStack(), button, 1);
return true; return true;
} }
if (GuiInfo.hasCustomSlots(gui)) return false; if (GuiInfo.hasCustomSlots(gui)) return false;
if (slotIndex >= 0 && NEIClientUtils.shiftKey() if (NEIClientUtils.shiftKey() && button != 2) { // MMB is used by other mods when an itemstack is picked.
&& NEIClientUtils.getHeldItem() != null // fix small mouse movement while clicking causing slotIndex to be -999
&& !slot.getHasStack()) { if (slotIndex == -999) {
ItemStack held = NEIClientUtils.getHeldItem(); final Point mouse = GuiDraw.getMousePosition();
manager.handleSlotClick(slot.slotNumber, button, 0); slot = gui.getSlotAtPosition(mouse.x, mouse.y);
if (slot.isItemValid(held) && !ItemInfo.fastTransferExemptions.contains(slot.getClass()))
fastTransferManager.performMassTransfer(gui, pickedUpFromSlot, slotIndex, held);
return true; if (slot != null) {
} slotIndex = slot.slotNumber;
}
}
if (slotIndex == -999 && NEIClientUtils.shiftKey() && button == 0) { if (slotIndex >= 0 && NEIClientUtils.getHeldItem() != null && !slot.getHasStack()) {
fastTransferManager.throwAll(gui, pickedUpFromSlot); final ItemStack held = NEIClientUtils.getHeldItem();
return true; manager.handleSlotClick(slot.slotNumber, button, 0);
if (slot.isItemValid(held) && !ItemInfo.fastTransferExemptions.contains(slot.getClass())) {
fastTransferManager.performMassTransfer(gui, pickedUpFromSlot, slotIndex, held);
}
return true;
}
if (slotIndex == -999 && button == 0) {
fastTransferManager.throwAll(gui, pickedUpFromSlot);
return true;
}
} }
return false; return false;
@@ -234,7 +261,7 @@ public class NEIController implements IContainerSlotClickHandler, IContainerInpu
// slot in GuiRecipe does not contain actual stack // slot in GuiRecipe does not contain actual stack
// and scroll should be handled by GuiRecipe, not here // and scroll should be handled by GuiRecipe, not here
if (gui instanceof GuiRecipe) return false; if (gui.inventorySlots instanceof EmptyContainer) return false;
Point mousePos = getMousePosition(); Point mousePos = getMousePosition();
Slot mouseover = manager.window.getSlotAtPosition(mousePos.x, mousePos.y); Slot mouseover = manager.window.getSlotAtPosition(mousePos.x, mousePos.y);
@@ -7,8 +7,7 @@ import java.util.HashSet;
import java.util.LinkedList; import java.util.LinkedList;
import java.util.List; import java.util.List;
import java.util.Set; import java.util.Set;
import java.util.concurrent.CopyOnWriteArrayList;
import net.minecraft.util.EnumChatFormatting;
import com.google.common.eventbus.EventBus; import com.google.common.eventbus.EventBus;
import com.google.common.eventbus.Subscribe; import com.google.common.eventbus.Subscribe;
@@ -18,6 +17,7 @@ import codechicken.core.launch.CodeChickenCorePlugin;
import codechicken.nei.api.IConfigureNEI; import codechicken.nei.api.IConfigureNEI;
import codechicken.nei.asm.NEICorePlugin; import codechicken.nei.asm.NEICorePlugin;
import codechicken.nei.config.IMCHandler; import codechicken.nei.config.IMCHandler;
import codechicken.nei.guihook.HideousLinkedList;
import codechicken.nei.recipe.GuiRecipeTab; import codechicken.nei.recipe.GuiRecipeTab;
import cpw.mods.fml.client.FMLFileResourcePack; import cpw.mods.fml.client.FMLFileResourcePack;
import cpw.mods.fml.client.FMLFolderResourcePack; import cpw.mods.fml.client.FMLFolderResourcePack;
@@ -31,22 +31,24 @@ import cpw.mods.fml.common.event.FMLInterModComms;
import cpw.mods.fml.common.event.FMLLoadCompleteEvent; import cpw.mods.fml.common.event.FMLLoadCompleteEvent;
import cpw.mods.fml.common.event.FMLPostInitializationEvent; import cpw.mods.fml.common.event.FMLPostInitializationEvent;
import cpw.mods.fml.common.event.FMLPreInitializationEvent; import cpw.mods.fml.common.event.FMLPreInitializationEvent;
import cpw.mods.fml.common.event.FMLServerAboutToStartEvent;
import cpw.mods.fml.common.versioning.ArtifactVersion; import cpw.mods.fml.common.versioning.ArtifactVersion;
import cpw.mods.fml.common.versioning.VersionParser; import cpw.mods.fml.common.versioning.VersionParser;
import cpw.mods.fml.common.versioning.VersionRange; import cpw.mods.fml.common.versioning.VersionRange;
@SuppressWarnings("UnstableApiUsage")
public class NEIModContainer extends DummyModContainer { public class NEIModContainer extends DummyModContainer {
public static LinkedList<IConfigureNEI> plugins = new LinkedList<>(); public static final LinkedList<IConfigureNEI> plugins = new HideousLinkedList<>(new CopyOnWriteArrayList<>());
private static boolean gregTech5Loaded; private static boolean gregTech5Loaded;
private static boolean gtnhLibLoaded; private static boolean gtnhLibLoaded;
private static boolean cubicChunksLoaded;
private static ASMDataTable asmDataTable; private static ASMDataTable asmDataTable;
public NEIModContainer() { public NEIModContainer() {
super(getModMetadata()); super(getModMetadata());
loadMetadata();
} }
private static ModMetadata getModMetadata() { private static ModMetadata getModMetadata() {
@@ -54,7 +56,7 @@ public class NEIModContainer extends DummyModContainer {
modMetadata.name = "NotEnoughItems"; modMetadata.name = "NotEnoughItems";
modMetadata.modId = "NotEnoughItems"; modMetadata.modId = "NotEnoughItems";
modMetadata.version = Tags.VERSION; modMetadata.version = Tags.VERSION;
modMetadata.authorList = Arrays.asList("ChickenBones", "mitchej123"); modMetadata.authorList = Arrays.asList("ChickenBones", "mitchej123", "SLPrime");
modMetadata.url = "https://github.com/GTNewHorizons/NotEnoughItems"; modMetadata.url = "https://github.com/GTNewHorizons/NotEnoughItems";
modMetadata.description = "Recipe Viewer, Inventory Manager, Item Spawner, Cheats and more; GTNH Version includes many enhancements."; modMetadata.description = "Recipe Viewer, Inventory Manager, Item Spawner, Cheats and more; GTNH Version includes many enhancements.";
return modMetadata; return modMetadata;
@@ -68,6 +70,10 @@ public class NEIModContainer extends DummyModContainer {
return gtnhLibLoaded; return gtnhLibLoaded;
} }
public static boolean isCCLoaded() {
return cubicChunksLoaded;
}
@Override @Override
public Set<ArtifactVersion> getRequirements() { public Set<ArtifactVersion> getRequirements() {
Set<ArtifactVersion> deps = new HashSet<>(); Set<ArtifactVersion> deps = new HashSet<>();
@@ -79,36 +85,12 @@ public class NEIModContainer extends DummyModContainer {
public List<ArtifactVersion> getDependencies() { public List<ArtifactVersion> getDependencies() {
List<ArtifactVersion> deps = new ArrayList<>(); List<ArtifactVersion> deps = new ArrayList<>();
deps.add(VersionParser.parseVersionReference("CodeChickenCore@[" + codechicken.core.asm.Tags.VERSION + ",)")); deps.add(VersionParser.parseVersionReference("CodeChickenCore@[" + codechicken.core.asm.Tags.VERSION + ",)"));
deps.add(VersionParser.parseVersionReference("gtnhlib@[0.6.0,)")); deps.add(VersionParser.parseVersionReference("gtnhlib@[0.9.6,)"));
return deps; return deps;
} }
private String description; private String description;
private void loadMetadata() {
description = super.getMetadata().description.replace("Supporters:", EnumChatFormatting.AQUA + "Supporters:");
}
@Override
public ModMetadata getMetadata() {
StringBuilder s_plugins = new StringBuilder();
if (plugins.size() == 0) {
s_plugins.append(EnumChatFormatting.RED).append("No installed plugins.");
} else {
s_plugins.append(EnumChatFormatting.GREEN).append("Installed plugins: ");
for (int i = 0; i < plugins.size(); i++) {
if (i > 0) s_plugins.append(", ");
IConfigureNEI plugin = plugins.get(i);
s_plugins.append(plugin.getName()).append(" ").append(plugin.getVersion());
}
s_plugins.append(".");
}
ModMetadata meta = super.getMetadata();
meta.description = description.replace("<plugins>", s_plugins.toString());
return meta;
}
@Override @Override
public boolean registerBus(EventBus bus, LoadController controller) { public boolean registerBus(EventBus bus, LoadController controller) {
bus.register(this); bus.register(this);
@@ -119,14 +101,18 @@ public class NEIModContainer extends DummyModContainer {
public void preInit(FMLPreInitializationEvent event) { public void preInit(FMLPreInitializationEvent event) {
gregTech5Loaded = Loader.isModLoaded("gregtech") && !Loader.isModLoaded("gregapi_post"); gregTech5Loaded = Loader.isModLoaded("gregtech") && !Loader.isModLoaded("gregapi_post");
gtnhLibLoaded = Loader.isModLoaded("gtnhlib"); gtnhLibLoaded = Loader.isModLoaded("gtnhlib");
cubicChunksLoaded = Loader.isModLoaded("cubicchunks");
ServerHandler.preInit();
if (CommonUtils.isClient()) ClientHandler.preInit(); if (CommonUtils.isClient()) ClientHandler.preInit();
asmDataTable = event.getAsmData(); asmDataTable = event.getAsmData();
} }
@Subscribe @Subscribe
public void init(FMLInitializationEvent event) { public void init(FMLInitializationEvent event) {
if (CommonUtils.isClient()) ClientHandler.load(); if (CommonUtils.isClient()) {
ClientHandler.load();
IMCForNEI.IMCSender();
}
ServerHandler.load(); ServerHandler.load();
} }
@@ -147,6 +133,11 @@ public class NEIModContainer extends DummyModContainer {
} }
} }
@Subscribe
public void onServerAboutToStart(FMLServerAboutToStartEvent event) {
NEIServerConfig.resetFirstLoad();
}
@Subscribe @Subscribe
public void handleIMCMessages(FMLInterModComms.IMCEvent event) { public void handleIMCMessages(FMLInterModComms.IMCEvent event) {
IMCHandler.processIMC(event.getMessages()); IMCHandler.processIMC(event.getMessages());
@@ -1,14 +1,10 @@
package codechicken.nei; package codechicken.nei;
import java.util.Collection;
import net.minecraft.client.Minecraft; import net.minecraft.client.Minecraft;
import net.minecraft.client.entity.EntityPlayerSP; import net.minecraft.client.entity.EntityPlayerSP;
import net.minecraft.client.gui.inventory.GuiContainer; import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.client.renderer.InventoryEffectRenderer; import net.minecraft.client.renderer.InventoryEffectRenderer;
import net.minecraft.potion.PotionEffect;
import codechicken.lib.vec.Rectangle4i;
import codechicken.nei.api.INEIGuiAdapter; import codechicken.nei.api.INEIGuiAdapter;
/** /**
@@ -18,35 +14,37 @@ public class NEIPotionGuiHandler extends INEIGuiAdapter {
@Override @Override
public boolean hideItemPanelSlot(GuiContainer guiContainer, int slotX, int slotY, int slotW, int slotH) { public boolean hideItemPanelSlot(GuiContainer guiContainer, int slotX, int slotY, int slotW, int slotH) {
if (NEIClientConfig.ignorePotionOverlap()) { if (!(guiContainer instanceof InventoryEffectRenderer)) {
return false; return false;
} }
if (guiContainer instanceof InventoryEffectRenderer) { int x = guiContainer.guiLeft - 124;
int x = guiContainer.guiLeft - 124; if (slotX + slotW <= x || slotX >= x + 140) {
int y = guiContainer.guiTop; return false;
Minecraft minecraft = guiContainer.mc; }
if (minecraft == null) {
return false; Minecraft minecraft = guiContainer.mc;
} if (minecraft == null) {
EntityPlayerSP player = minecraft.thePlayer; return false;
if (player == null) { }
return false; EntityPlayerSP player = minecraft.thePlayer;
} if (player == null) {
Collection<PotionEffect> activePotionEffects = player.getActivePotionEffects(); return false;
if (activePotionEffects.isEmpty()) { }
return false; int potionCount = player.getActivePotionEffects().size();
} if (potionCount == 0 || NEIClientConfig.ignorePotionOverlap()) {
int height = 33; return false;
if (activePotionEffects.size() > 5) { }
height = 132 / (activePotionEffects.size() - 1); int height = 33;
} if (potionCount > 5) {
Rectangle4i slotRect = new Rectangle4i(slotX, slotY, slotW, slotH); height = 132 / (potionCount - 1);
for (PotionEffect potioneffect : activePotionEffects) { }
Rectangle4i box = new Rectangle4i(x, y, 140, 32); return intersectsPotionEffects(slotY, slotH, guiContainer.guiTop, potionCount, height);
if (box.intersects(slotRect)) return true; }
y += height;
} static boolean intersectsPotionEffects(int slotY, int slotH, int effectY, int potionCount, int height) {
for (int i = 0; i < potionCount; i++, effectY += height) {
if (slotY + slotH > effectY && slotY < effectY + 32) return true;
} }
return false; return false;
} }
+11 -1
View File
@@ -11,6 +11,7 @@ import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.inventory.InventoryBasic; import net.minecraft.inventory.InventoryBasic;
import net.minecraft.inventory.Slot; import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack; import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.network.play.INetHandlerPlayServer; import net.minecraft.network.play.INetHandlerPlayServer;
import net.minecraft.tileentity.TileEntity; import net.minecraft.tileentity.TileEntity;
import net.minecraft.tileentity.TileEntityMobSpawner; import net.minecraft.tileentity.TileEntityMobSpawner;
@@ -91,11 +92,20 @@ public class NEISPH implements IServerPacketHandler {
case C2S.SEND_CHAT_ITEM_LINK: case C2S.SEND_CHAT_ITEM_LINK:
handleSendChatItemLink(sender, packet); handleSendChatItemLink(sender, packet);
break; break;
case C2S.SYNC:
handleSync(sender, packet.readInt());
break;
} }
} }
private void handleSync(EntityPlayerMP sender, int id) {
sender.sendContainerAndContentsToPlayer(sender.openContainer, sender.openContainer.getInventory());
new PacketCustom(channel, S2C.SYNC).writeInt(id).sendToPlayer(sender);
}
private void handleSendChatItemLink(EntityPlayerMP sender, PacketCustom packet) { private void handleSendChatItemLink(EntityPlayerMP sender, PacketCustom packet) {
NEIServerUtils.sendChatItemLink(sender, packet.readItemStack()); final NBTTagCompound payloadTag = packet.readNBTTagCompound();
NEIServerUtils.sendChatItemLink(sender, payloadTag);
} }
private void handleDummySlotSet(EntityPlayerMP sender, PacketCustom packet) { private void handleDummySlotSet(EntityPlayerMP sender, PacketCustom packet) {
@@ -18,7 +18,6 @@ import net.minecraft.init.Blocks;
import net.minecraft.item.ItemStack; import net.minecraft.item.ItemStack;
import net.minecraft.nbt.JsonToNBT; import net.minecraft.nbt.JsonToNBT;
import net.minecraft.nbt.NBTTagCompound; import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.server.MinecraftServer;
import net.minecraft.world.World; import net.minecraft.world.World;
import net.minecraftforge.common.DimensionManager; import net.minecraftforge.common.DimensionManager;
import net.minecraftforge.permission.PermissionLevel; import net.minecraftforge.permission.PermissionLevel;
@@ -37,21 +36,23 @@ import codechicken.lib.packet.PacketCustom;
public class NEIServerConfig { public class NEIServerConfig {
private static MinecraftServer server; private static boolean firstLoad;
public static Logger logger = LogManager.getLogger("NotEnoughItems"); public static Logger logger = LogManager.getLogger("NotEnoughItems");
public static File saveDir; public static File saveDir;
public static ConfigFile serverConfig; public static ConfigFile serverConfig;
public static Map<Integer, NBTTagCompound> dimTags = new HashMap<>(); public static Map<Integer, NBTTagCompound> dimTags = new HashMap<>();
public static HashMap<String, PlayerSave> playerSaves = new HashMap<>(); public static HashMap<String, PlayerSave> playerSaves = new HashMap<>();
public static ItemStackMap<Set<String>> bannedItems = new ItemStackMap<>(); public static ItemStackMap<Set<String>> bannedItems = new ItemStackMap<>();
private static boolean doesPermAPIExist = false; private static boolean doesPermAPIExist = false;
public static void resetFirstLoad() {
firstLoad = true;
}
public static void load(World world) { public static void load(World world) {
if (MinecraftServer.getServer() != server) { if (firstLoad) {
firstLoad = false;
logger.debug("Loading NEI Server"); logger.debug("Loading NEI Server");
server = MinecraftServer.getServer();
saveDir = new File(DimensionManager.getCurrentSaveRootDirectory(), "NEI"); saveDir = new File(DimensionManager.getCurrentSaveRootDirectory(), "NEI");
dimTags.clear(); dimTags.clear();
@@ -107,6 +108,7 @@ public class NEIServerConfig {
setDefaultFeature("save-state"); setDefaultFeature("save-state");
setDefaultFeature("item"); setDefaultFeature("item");
setDefaultFeature("delete"); setDefaultFeature("delete");
setDefaultFeature("autocraft", "ALL");
setDefaultFeature("notify-item", "CONSOLE, OP"); setDefaultFeature("notify-item", "CONSOLE, OP");
} }
+102 -48
View File
@@ -4,12 +4,10 @@ import java.io.File;
import java.io.FileInputStream; import java.io.FileInputStream;
import java.io.FileOutputStream; import java.io.FileOutputStream;
import java.io.IOException; import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.AbstractList; import java.util.AbstractList;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
import java.util.Set; import java.util.UUID;
import java.util.zip.ZipException; import java.util.zip.ZipException;
import net.minecraft.command.ICommandSender; import net.minecraft.command.ICommandSender;
@@ -28,12 +26,13 @@ import net.minecraft.nbt.NBTException;
import net.minecraft.nbt.NBTTagCompound; import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList; import net.minecraft.nbt.NBTTagList;
import net.minecraft.server.MinecraftServer; import net.minecraft.server.MinecraftServer;
import net.minecraft.util.ChatComponentText;
import net.minecraft.util.ChatComponentTranslation; import net.minecraft.util.ChatComponentTranslation;
import net.minecraft.util.EnumChatFormatting; import net.minecraft.util.EnumChatFormatting;
import net.minecraft.util.IChatComponent; import net.minecraft.util.IChatComponent;
import net.minecraft.world.World; import net.minecraft.world.World;
import net.minecraft.world.WorldServer;
import net.minecraft.world.WorldSettings.GameType; import net.minecraft.world.WorldSettings.GameType;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.oredict.OreDictionary; import net.minecraftforge.oredict.OreDictionary;
import org.apache.logging.log4j.Level; import org.apache.logging.log4j.Level;
@@ -44,6 +43,8 @@ import codechicken.lib.inventory.InventoryRange;
import codechicken.lib.inventory.InventoryUtils; import codechicken.lib.inventory.InventoryUtils;
import codechicken.lib.packet.PacketCustom; import codechicken.lib.packet.PacketCustom;
import codechicken.nei.PacketIDs.S2C; import codechicken.nei.PacketIDs.S2C;
import codechicken.nei.item.ItemFluidDisplay;
import codechicken.nei.recipe.StackInfo;
import codechicken.nei.util.NBTHelper; import codechicken.nei.util.NBTHelper;
import cpw.mods.fml.common.FMLLog; import cpw.mods.fml.common.FMLLog;
import cpw.mods.fml.common.registry.GameRegistry; import cpw.mods.fml.common.registry.GameRegistry;
@@ -51,15 +52,18 @@ import cpw.mods.fml.relauncher.ReflectionHelper;
public class NEIServerUtils { public class NEIServerUtils {
private static Class<?> gtMetaBaseItem; private static class GTMetaBaseItemHolder {
static { private static final Class<?> gtMetaBaseItem = loadMetaBaseItem();
try {
final ClassLoader loader = NEIServerUtils.class.getClassLoader(); private static Class<?> loadMetaBaseItem() {
NEIServerUtils.gtMetaBaseItem = ReflectionHelper try {
.getClass(loader, "gregtech.api.items.MetaBaseItem", "gregtech.api.items.GT_MetaBase_Item"); final ClassLoader loader = NEIServerUtils.class.getClassLoader();
} catch (Exception ignored) { return ReflectionHelper
/* Do nothing */ .getClass(loader, "gregtech.api.items.MetaBaseItem", "gregtech.api.items.GT_MetaBase_Item");
} catch (Exception ignored) {
return null;
}
} }
} }
@@ -70,7 +74,7 @@ public class NEIServerUtils {
public static void toggleRaining(World world, boolean notify) { public static void toggleRaining(World world, boolean notify) {
boolean raining = !world.isRaining(); boolean raining = !world.isRaining();
if (!raining) // turn off if (!raining) // turn off
((WorldServer) world).provider.resetRainAndThunder(); world.provider.resetRainAndThunder();
else world.getWorldInfo().setRaining(!isRaining(world)); else world.getWorldInfo().setRaining(!isRaining(world));
if (notify) if (notify)
@@ -83,16 +87,46 @@ public class NEIServerUtils {
player.extinguish(); player.extinguish();
} }
public static void sendChatItemLink(EntityPlayerMP sender, ItemStack stackover) { public static void sendChatItemLink(EntityPlayerMP sender, NBTTagCompound payload) {
ServerUtils.sendChatToAll( if (payload == null) {
new ChatComponentTranslation( sender.addChatMessage(new ChatComponentText("Invalid bookmark payload"));
"nei.chat.item_link.text", return;
sender.getDisplayName(), }
stackover.func_151000_E().setChatStyle(
stackover.func_151000_E().getChatStyle().setChatClickEvent( final String linkType = payload.getString("linkType");
new ClickEvent( final String payloadId = UUID.randomUUID().toString().substring(0, 8);
ClickEvent.Action.RUN_COMMAND, final PacketCustom packet = new PacketCustom(NEISPH.channel, S2C.CACHE_BOOKMARK_DATA).writeString(payloadId)
"/nei_bookmark " + stackover.writeToNBT(new NBTTagCompound())))))); .writeNBTTagCompound((NBTTagCompound) payload.copy());
for (EntityPlayer player : ServerUtils.getPlayers()) {
if (player instanceof EntityPlayerMP playerMP) {
packet.sendToPlayer(playerMP);
}
}
try {
final IChatComponent clickable;
if (payload.hasKey("item")) {
clickable = StackInfo.loadFromNBT(payload.getCompoundTag("item")).func_151000_E();
} else {
clickable = new ChatComponentText("[")
.appendSibling(new ChatComponentTranslation("nei.chat.item_link." + linkType + ".text"))
.appendText("]");
}
if (clickable == null) {
throw new Exception("Invalid ItemStack NBT");
}
clickable.getChatStyle()
.setChatClickEvent(new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/nei_bookmark " + payloadId));
ServerUtils.sendChatToAll(
new ChatComponentTranslation("nei.chat.item_link.text", sender.getDisplayName(), clickable));
} catch (Exception e) {
sender.addChatMessage(new ChatComponentText(e.toString()));
}
} }
public static long getTime(World world) { public static long getTime(World world) {
@@ -180,7 +214,7 @@ public class NEIServerUtils {
public static boolean areStacksSameTypeWithNBT(ItemStack stack1, ItemStack stack2) { public static boolean areStacksSameTypeWithNBT(ItemStack stack1, ItemStack stack2) {
return stack1 != null && stack2 != null return stack1 != null && stack2 != null
&& stack1.getItem() == stack2.getItem() && stack1.getItem() == stack2.getItem()
&& (!stack2.getHasSubtypes() || stack2.getItemDamage() == stack1.getItemDamage()) && (stack2.isItemStackDamageable() || stack2.getItemDamage() == stack1.getItemDamage())
&& NBTHelper.matchTag(stack1.getTagCompound(), stack2.getTagCompound()); && NBTHelper.matchTag(stack1.getTagCompound(), stack2.getTagCompound());
} }
@@ -226,12 +260,10 @@ public class NEIServerUtils {
/** /**
* GT Items don't have any NBT set for the recipe, so if either of the stacks has a NULL nbt, and the other doesn't, * GT Items don't have any NBT set for the recipe, so if either of the stacks has a NULL nbt, and the other doesn't,
* pretend they stack * pretend they stack
*
* @param ItemStack stack
* @return
*/ */
public static boolean isItemTool(ItemStack stack) { public static boolean isItemTool(ItemStack stack) {
return NEIServerUtils.gtMetaBaseItem != null && NEIServerUtils.gtMetaBaseItem.isInstance(stack.getItem()); return GTMetaBaseItemHolder.gtMetaBaseItem != null
&& GTMetaBaseItemHolder.gtMetaBaseItem.isInstance(stack.getItem());
} }
/** /**
@@ -409,17 +441,53 @@ public class NEIServerUtils {
throw new RuntimeException(msg); throw new RuntimeException(msg);
} }
@SuppressWarnings("unchecked")
public static ItemStack[] extractRecipeItems(Object obj) { public static ItemStack[] extractRecipeItems(Object obj) {
if (obj instanceof ItemStack) return new ItemStack[] { (ItemStack) obj };
if (obj instanceof ItemStack[]) return (ItemStack[]) obj;
if (obj instanceof List) return ((List<ItemStack>) obj).toArray(new ItemStack[0]);
throw new ClassCastException(obj + " not an ItemStack, ItemStack[] or List<ItemStack?"); if (obj instanceof ItemStack item) {
return new ItemStack[] { item };
}
if (obj instanceof ItemStack[]arr) {
return arr;
}
if (obj instanceof FluidStack fluid) {
return new ItemStack[] { ItemFluidDisplay.createStack(fluid) };
}
if (obj instanceof FluidStack[]arr) {
final ItemStack[] items = new ItemStack[arr.length];
for (int i = 0; i < items.length; i++) {
items[i] = ItemFluidDisplay.createStack(arr[i]);
}
return items;
}
if (obj instanceof List list) {
final ItemStack[] items = new ItemStack[list.size()];
for (int i = 0; i < items.length; i++) {
items[i] = extractRecipeItem(list.get(i));
}
return items;
}
throw new ClassCastException(
obj + " not an ItemStack, ItemStack[], FluidStack, FluidStack[] or a List of them");
}
private static ItemStack extractRecipeItem(Object obj) {
if (obj == null) return null;
if (obj instanceof ItemStack item) return item;
if (obj instanceof FluidStack fluid) return ItemFluidDisplay.createStack(fluid);
throw new ClassCastException(obj + " not an ItemStack or FluidStack");
} }
public static List<Integer> getRange(final int start, final int end) { public static List<Integer> getRange(final int start, final int end) {
return new AbstractList<Integer>() { return new AbstractList<>() {
@Override @Override
public Integer get(int index) { public Integer get(int index) {
@@ -438,20 +506,6 @@ public class NEIServerUtils {
return sb; return sb;
} }
public static void logOnce(Throwable t, Set<String> stackTraces, String message) {
logOnce(t, stackTraces, message, "");
}
public static void logOnce(Throwable t, Set<String> stackTraces, String message, String identifier) {
StringWriter sw = new StringWriter();
t.printStackTrace(new PrintWriter(sw));
String stackTrace = identifier + sw.toString();
if (!stackTraces.contains(stackTrace)) {
NEIServerConfig.logger.error(message, t);
stackTraces.add(stackTrace);
}
}
public static ItemStack getModdedItem(String itemId, String nbtString) { public static ItemStack getModdedItem(String itemId, String nbtString) {
int meta = -1; int meta = -1;
ItemStack itemStack; ItemStack itemStack;
@@ -24,6 +24,7 @@ public final class PacketIDs {
public static final int REQUEST_POTION_GUI = 24; public static final int REQUEST_POTION_GUI = 24;
public static final int SET_DUMMY_SLOT = 25; public static final int SET_DUMMY_SLOT = 25;
public static final int SEND_CHAT_ITEM_LINK = 26; public static final int SEND_CHAT_ITEM_LINK = 26;
public static final int SYNC = 27;
} }
public static final class S2C { public static final class S2C {
@@ -37,5 +38,7 @@ public final class PacketIDs {
public static final int OPEN_ENCHANTMENT_GUI = 21; public static final int OPEN_ENCHANTMENT_GUI = 21;
public static final int SET_CREATIVE_PLUS_MODE = 23; public static final int SET_CREATIVE_PLUS_MODE = 23;
public static final int OPEN_POTION_GUI = 24; public static final int OPEN_POTION_GUI = 24;
public static final int CACHE_BOOKMARK_DATA = 25;
public static final int SYNC = 26;
} }
} }
+46 -69
View File
@@ -11,14 +11,12 @@ import codechicken.lib.vec.Rectangle4i;
import codechicken.nei.ItemsGrid.ItemsGridSlot; import codechicken.nei.ItemsGrid.ItemsGridSlot;
import codechicken.nei.api.GuiInfo; import codechicken.nei.api.GuiInfo;
import codechicken.nei.api.INEIGuiHandler; import codechicken.nei.api.INEIGuiHandler;
import codechicken.nei.api.ShortcutInputHandler;
import codechicken.nei.guihook.GuiContainerManager; import codechicken.nei.guihook.GuiContainerManager;
import codechicken.nei.guihook.IContainerTooltipHandler;
import codechicken.nei.recipe.GuiCraftingRecipe;
import codechicken.nei.recipe.GuiRecipe; import codechicken.nei.recipe.GuiRecipe;
import codechicken.nei.recipe.GuiUsageRecipe;
public abstract class PanelWidget<T extends ItemsGrid<? extends ItemsGridSlot, ? extends ItemsGrid.MouseContext>> public abstract class PanelWidget<T extends ItemsGrid<? extends ItemsGridSlot, ? extends ItemsGrid.MouseContext>>
extends Widget implements IContainerTooltipHandler { extends Widget {
protected static final int PADDING = 2; protected static final int PADDING = 2;
@@ -31,6 +29,9 @@ public abstract class PanelWidget<T extends ItemsGrid<? extends ItemsGridSlot, ?
protected T grid; protected T grid;
private int headerPaddingLeft;
private int headerPaddingRight;
public ArrayList<ItemStack> getItems() { public ArrayList<ItemStack> getItems() {
return this.grid.getItems(); return this.grid.getItems();
} }
@@ -84,44 +85,19 @@ public abstract class PanelWidget<T extends ItemsGrid<? extends ItemsGridSlot, ?
public abstract String getLabelText(); public abstract String getLabelText();
protected abstract String getPositioningSettingName(); public abstract Rectangle4i calculateBounds(GuiContainer gui);
public abstract int getMarginLeft(GuiContainer gui); protected static int snapDownToMultiple(int value, int multiple) {
return (value / multiple) * multiple;
public abstract int getMarginTop(GuiContainer gui); }
public abstract int getWidth(GuiContainer gui);
public abstract int getHeight(GuiContainer gui);
public void resize(GuiContainer gui) { public void resize(GuiContainer gui) {
final Rectangle4i margin = new Rectangle4i( final Rectangle4i bounds = calculateBounds(gui);
getMarginLeft(gui),
getMarginTop(gui),
getWidth(gui),
getHeight(gui));
final String settingName = getPositioningSettingName(); x = bounds.x;
int paddingLeft = (int) Math y = bounds.y;
.ceil(margin.w * NEIClientConfig.getSetting(settingName + ".left").getIntValue() / 100000.0); w = bounds.w;
int paddingTop = (int) Math h = bounds.h;
.ceil(margin.h * NEIClientConfig.getSetting(settingName + ".top").getIntValue() / 100000.0);
int paddingRight = (int) Math
.ceil(margin.w * NEIClientConfig.getSetting(settingName + ".right").getIntValue() / 100000.0);
int paddingBottom = (int) Math
.ceil(margin.h * NEIClientConfig.getSetting(settingName + ".bottom").getIntValue() / 100000.0);
int deltaHeight = Math.min(0, margin.h - paddingTop - paddingBottom - ItemsGrid.SLOT_SIZE) / 2;
paddingLeft = Math.min(paddingLeft, Math.max(0, margin.w - paddingRight - ItemsGrid.SLOT_SIZE));
paddingRight = Math.min(paddingRight, Math.max(0, margin.w - paddingLeft - ItemsGrid.SLOT_SIZE));
paddingTop = Math.min(margin.h - ItemsGrid.SLOT_SIZE, Math.max(0, paddingTop + deltaHeight));
paddingBottom = Math.min(margin.h - paddingTop - ItemsGrid.SLOT_SIZE, Math.max(0, paddingBottom - deltaHeight));
x = margin.x + paddingLeft;
y = margin.y + paddingTop;
w = margin.w - paddingLeft - paddingRight;
h = margin.h - paddingTop - paddingBottom;
final int header = resizeHeader(gui); final int header = resizeHeader(gui);
final int footer = resizeFooter(gui); final int footer = resizeFooter(gui);
@@ -132,26 +108,15 @@ public abstract class PanelWidget<T extends ItemsGrid<? extends ItemsGridSlot, ?
protected int resizeHeader(GuiContainer gui) { protected int resizeHeader(GuiContainer gui) {
final int BUTTON_SIZE = 16; final int BUTTON_SIZE = 16;
int paddingLeft = 0;
int paddingRight = 0;
while (paddingLeft < w && GuiInfo.hideItemPanelSlot( if (GridOverlapScanner.isScanFrame()) {
gui, updateHeaderPadding(gui);
new Rectangle4i(x + paddingLeft, y, ItemsGrid.SLOT_SIZE, ItemsGrid.SLOT_SIZE))) {
paddingLeft += ItemsGrid.SLOT_SIZE;
} }
while (paddingRight < w && GuiInfo.hideItemPanelSlot( final int paddingLeft = this.headerPaddingLeft;
gui, final int paddingRight = this.headerPaddingRight;
new Rectangle4i(
x + w - paddingRight - ItemsGrid.SLOT_SIZE,
y,
ItemsGrid.SLOT_SIZE,
ItemsGrid.SLOT_SIZE))) {
paddingRight += ItemsGrid.SLOT_SIZE;
}
if (paddingLeft + paddingRight >= w) { if (paddingLeft + paddingRight >= this.w) {
return 0; return 0;
} }
@@ -159,16 +124,35 @@ public abstract class PanelWidget<T extends ItemsGrid<? extends ItemsGridSlot, ?
pagePrev.h = pageNext.h = BUTTON_SIZE; pagePrev.h = pageNext.h = BUTTON_SIZE;
pagePrev.y = pageNext.y = y; pagePrev.y = pageNext.y = y;
pagePrev.x = x + paddingLeft; pagePrev.x = this.x + paddingLeft;
pageNext.x = x + w - pageNext.w - paddingRight; pageNext.x = this.x + this.w - pageNext.w - paddingRight;
pageLabel.x = x + paddingLeft + (w - paddingLeft - paddingRight) / 2; pageLabel.x = this.x + paddingLeft + (this.w - paddingLeft - paddingRight) / 2;
pageLabel.y = y + 5; pageLabel.y = this.y + 5;
pageLabel.text = getLabelText(); pageLabel.text = getLabelText();
return BUTTON_SIZE + 2; return BUTTON_SIZE + 2;
} }
private void updateHeaderPadding(GuiContainer gui) {
final INEIGuiHandler[] handlers = GuiInfo.getGuiHandlersSnapshot();
final Rectangle4i slot = new Rectangle4i(this.x, this.y, ItemsGrid.SLOT_SIZE, ItemsGrid.SLOT_SIZE);
this.headerPaddingLeft = 0;
this.headerPaddingRight = 0;
while (this.headerPaddingLeft < this.w && GuiInfo.hideItemPanelSlot(gui, slot, handlers)) {
this.headerPaddingLeft += ItemsGrid.SLOT_SIZE;
slot.x += ItemsGrid.SLOT_SIZE;
}
slot.x = this.x + this.w - ItemsGrid.SLOT_SIZE;
while (this.headerPaddingRight < this.w && GuiInfo.hideItemPanelSlot(gui, slot, handlers)) {
this.headerPaddingRight += ItemsGrid.SLOT_SIZE;
slot.x -= ItemsGrid.SLOT_SIZE;
}
}
protected abstract int resizeFooter(GuiContainer gui); protected abstract int resizeFooter(GuiContainer gui);
public void setVisible() { public void setVisible() {
@@ -176,7 +160,6 @@ public abstract class PanelWidget<T extends ItemsGrid<? extends ItemsGridSlot, ?
LayoutManager.addWidget(pagePrev); LayoutManager.addWidget(pagePrev);
LayoutManager.addWidget(pageNext); LayoutManager.addWidget(pageNext);
LayoutManager.addWidget(pageLabel); LayoutManager.addWidget(pageLabel);
this.grid.setVisible();
} }
} }
@@ -314,13 +297,7 @@ public abstract class PanelWidget<T extends ItemsGrid<? extends ItemsGridSlot, ?
if (NEIController.manager.window instanceof GuiRecipe || NEIClientUtils.shiftKey() if (NEIController.manager.window instanceof GuiRecipe || NEIClientUtils.shiftKey()
|| !NEIClientConfig.canCheatItem(hoverSlot.getItemStack())) { || !NEIClientConfig.canCheatItem(hoverSlot.getItemStack())) {
ShortcutInputHandler.handleMouseClick(hoverSlot.getItemStack());
if (button == 0) {
GuiCraftingRecipe.openRecipeGui("item", hoverSlot.getItemStack().copy());
} else if (button == 1) {
GuiUsageRecipe.openRecipeGui("item", hoverSlot.getItemStack().copy());
}
} else { } else {
NEIClientUtils.cheatItem(getDraggedStackWithQuantity(hoverSlot.getItemStack()), button, -1); NEIClientUtils.cheatItem(getDraggedStackWithQuantity(hoverSlot.getItemStack()), button, -1);
} }
@@ -339,16 +316,16 @@ public abstract class PanelWidget<T extends ItemsGrid<? extends ItemsGridSlot, ?
} }
@Override @Override
public boolean handleKeyPress(int keyID, char keyChar) { public boolean onHotkeyPressed() {
final Point mouse = GuiDraw.getMousePosition(); final Point mouse = GuiDraw.getMousePosition();
if (!contains(mouse.x, mouse.y)) return false; if (!contains(mouse.x, mouse.y)) return false;
if (NEIClientConfig.isKeyHashDown("gui.next")) { if (KeyManager.isKeyDown("gui.next")) {
this.grid.shiftPage(1); this.grid.shiftPage(1);
return true; return true;
} }
if (NEIClientConfig.isKeyHashDown("gui.prev")) { if (KeyManager.isKeyDown("gui.prev")) {
this.grid.shiftPage(-1); this.grid.shiftPage(-1);
return true; return true;
} }
@@ -0,0 +1,66 @@
package codechicken.nei;
import java.util.Collection;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinWorkerThread;
import org.apache.logging.log4j.Logger;
import codechicken.nei.api.IConfigureNEI;
final class PluginLoader {
private PluginLoader() {}
static void load(Collection<Class<?>> plugins, boolean parallel, Collection<IConfigureNEI> loadedPlugins,
Logger logger) {
if (parallel && canSetContextClassLoader()) {
// Common pool workers use the system loader, which cannot see FML-only classes (old Log4j then throws
// while logging a plugin's stack frames), and under a SecurityManager they forbid changing it.
final ClassLoader classLoader = IConfigureNEI.class.getClassLoader();
final ForkJoinPool pool = new ForkJoinPool(Runtime.getRuntime().availableProcessors(), owner -> {
final ForkJoinWorkerThread worker = ForkJoinPool.defaultForkJoinWorkerThreadFactory.newThread(owner);
worker.setContextClassLoader(classLoader);
return worker;
}, null, false);
try {
pool.submit(() -> plugins.parallelStream().forEach(clazz -> load(clazz, loadedPlugins, logger))).join();
} finally {
pool.shutdown();
}
} else {
if (parallel) {
logger.warn("Context class loader cannot be changed, loading plugins sequentially");
}
plugins.forEach(clazz -> load(clazz, loadedPlugins, logger));
}
}
private static void load(Class<?> clazz, Collection<IConfigureNEI> loadedPlugins, Logger logger) {
try {
IConfigureNEI config = (IConfigureNEI) clazz.getConstructor().newInstance();
config.loadConfig();
loadedPlugins.add(config);
logger.debug("Loaded {}", clazz.getName());
} catch (Throwable e) {
logger.error("Failed to Load {}", clazz.getName(), e);
}
}
private static boolean canSetContextClassLoader() {
final SecurityManager securityManager = System.getSecurityManager();
if (securityManager == null) {
return true;
}
try {
securityManager.checkPermission(new RuntimePermission("setContextClassLoader"));
return true;
} catch (SecurityException e) {
return false;
}
}
}
@@ -23,13 +23,18 @@ public class PopupInputHandler implements IContainerInputHandler {
@Override @Override
public boolean lastKeyTyped(GuiContainer gui, char keyChar, int keyID) { public boolean lastKeyTyped(GuiContainer gui, char keyChar, int keyID) {
return false;
}
if (NEIClientConfig.isKeyHashDown("gui.enchant") && canPerformAction("enchant")) { @Override
public boolean onHotkeyPressed(GuiContainer gui) {
if (KeyManager.isHashDown("gui.enchant") && canPerformAction("enchant")) {
NEICPH.sendOpenEnchantmentWindow(); NEICPH.sendOpenEnchantmentWindow();
return true; return true;
} }
if (NEIClientConfig.isKeyHashDown("gui.potion") && canPerformAction("potion")) { if (KeyManager.isHashDown("gui.potion") && canPerformAction("potion")) {
NEICPH.sendOpenPotionWindow(); NEICPH.sendOpenPotionWindow();
return true; return true;
} }
@@ -4,30 +4,48 @@ import java.util.ArrayList;
import java.util.Arrays; import java.util.Arrays;
import java.util.Comparator; import java.util.Comparator;
import java.util.List; import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors; import java.util.stream.Collectors;
import net.minecraft.init.Blocks; import net.minecraft.init.Blocks;
import net.minecraft.item.Item; import net.minecraft.item.Item;
import net.minecraft.item.ItemStack; import net.minecraft.item.ItemStack;
import net.minecraft.util.EnumChatFormatting;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.oredict.OreDictionary; import net.minecraftforge.oredict.OreDictionary;
import codechicken.nei.api.ItemFilter; import codechicken.nei.api.ItemFilter;
import codechicken.nei.api.ItemInfo; import codechicken.nei.api.ItemInfo;
import codechicken.nei.guihook.GuiContainerManager;
import codechicken.nei.item.FluidDrawer;
import codechicken.nei.item.FluidDrawer.FillDirection;
import codechicken.nei.recipe.Badge;
import codechicken.nei.recipe.GuiRecipe; import codechicken.nei.recipe.GuiRecipe;
import codechicken.nei.recipe.StackInfo; import codechicken.nei.recipe.StackInfo;
/** /**
* Simply an {@link ItemStack} with position. Mainly used in the recipe handlers. * Simply an {@link ItemStack} with position. Mainly used in the recipe handlers.
*/ */
public class PositionedStack { public class PositionedStack implements Cloneable {
/** Maximum chance value representing 100% probability (1 unit = 0.01%). */
public static final int CHANCE_FULL = 10_000;
public int relx; public int relx;
public int rely; public int rely;
public int width = 16;
public int height = 16;
public ItemStack[] items; public ItemStack[] items;
// compatibility dummy // compatibility dummy
public ItemStack item; public ItemStack item;
private boolean permutated = false; protected int chance = CHANCE_FULL;
protected boolean permutated = false;
protected String acceptsLabel;
protected Function<ItemStack, List<String>> tooltip;
protected List<Badge> badges;
public PositionedStack(Object object, int x, int y, boolean genPerms) { public PositionedStack(Object object, int x, int y, boolean genPerms) {
items = NEIServerUtils.extractRecipeItems(object); items = NEIServerUtils.extractRecipeItems(object);
@@ -48,31 +66,11 @@ public class PositionedStack {
public void generatePermutations() { public void generatePermutations() {
if (permutated) return; if (permutated) return;
List<ItemStack> stacks = new ArrayList<>(); items = ItemList.expandPermutations(items);
for (ItemStack item : items) {
if (item == null || item.getItem() == null) continue;
if (item.getItemDamage() == Short.MAX_VALUE) { if (items.length == 0) {
List<ItemStack> permutations = ItemList.itemMap.get(item.getItem()); items = new ItemStack[] { new ItemStack(Blocks.fire) };
if (!permutations.isEmpty()) {
for (ItemStack stack : permutations) {
ItemStack toAdd = stack.copy();
toAdd.stackSize = item.stackSize;
stacks.add(toAdd);
}
} else {
ItemStack base = new ItemStack(item.getItem(), item.stackSize);
base.stackTagCompound = item.stackTagCompound;
stacks.add(base);
}
continue;
}
stacks.add(item.copy());
} }
items = stacks.toArray(new ItemStack[0]);
if (items.length == 0) items = new ItemStack[] { new ItemStack(Blocks.fire) };
permutated = true; permutated = true;
setPermutationToRender(0); setPermutationToRender(0);
@@ -82,14 +80,58 @@ public class PositionedStack {
for (ItemStack item : items) if (item.stackSize > i) item.stackSize = i; for (ItemStack item : items) if (item.stackSize > i) item.stackSize = i;
} }
public void setAcceptsLabel(String acceptsLabel) {
this.acceptsLabel = acceptsLabel;
}
public String getAcceptsLabel() {
return this.acceptsLabel;
}
public void setBadges(List<Badge> badges) {
this.badges = badges;
}
public List<Badge> getBadges() {
return this.badges;
}
public void setTooltip(List<String> tooltip) {
this.tooltip = tooltip == null ? null : item -> tooltip;
}
public void setTooltipProvider(Function<ItemStack, List<String>> provider) {
this.tooltip = provider;
}
public List<String> getTooltip() {
return this.tooltip == null ? null : this.tooltip.apply(this.item);
}
public int getChance() {
return this.chance;
}
public void setChance(int chance) {
this.chance = chance;
}
public PositionedStack copy() { public PositionedStack copy() {
PositionedStack pStack = new PositionedStack( try {
Arrays.stream(this.items).map(ItemStack::copy).toArray(ItemStack[]::new), PositionedStack pStack = (PositionedStack) super.clone();
relx, pStack.items = Arrays.stream(this.items).map(ItemStack::copy).toArray(ItemStack[]::new);
rely, pStack.item = this.item == null ? null : this.item.copy();
false); pStack.badges = this.badges == null ? null : new ArrayList<>(this.badges);
pStack.permutated = this.permutated; return pStack;
return pStack; } catch (CloneNotSupportedException e) {
throw new RuntimeException(e);
}
}
public void draw(int mousex, int mousey) {
final int x = this.relx + (this.width - 16) / 2;
final int y = this.rely + (this.height - 16) / 2;
GuiContainerManager.drawItem(x, y, this.item);
} }
public List<ItemStack> getFilteredPermutations() { public List<ItemStack> getFilteredPermutations() {
@@ -97,14 +139,14 @@ public class PositionedStack {
} }
public List<ItemStack> getFilteredPermutations(ItemFilter additionalFilter) { public List<ItemStack> getFilteredPermutations(ItemFilter additionalFilter) {
List<ItemStack> items = Arrays.asList(this.items); List<ItemStack> items = new ArrayList<>(Arrays.asList(this.items));
items = filteringPermutations(items, item -> !ItemInfo.isHidden(item)); items = filteringPermutations(items, item -> !ItemInfo.isHidden(item));
items = filteringPermutations(items, PresetsList.getItemFilter()); items = filteringPermutations(items, PresetsList.getItemFilter());
items = filteringPermutations(items, GuiRecipe.getSearchItemFilter()); items = filteringPermutations(items, GuiRecipe.getSearchItemFilter());
items = filteringPermutations(items, additionalFilter); items = filteringPermutations(items, additionalFilter);
items.sort(Comparator.comparing(FavoriteRecipes::contains).reversed()); items.sort(Comparator.comparing(FavoriteRecipes::containsManual).reversed());
return items; return items;
} }
@@ -114,16 +156,25 @@ public class PositionedStack {
return filteredItems.isEmpty() ? items : filteredItems; return filteredItems.isEmpty() ? items : filteredItems;
} }
public boolean setPermutationToRender(ItemStack ingredient) { public int getPermutationIndex(ItemStack stack) {
for (int index = 0; index < this.items.length; index++) { for (int index = 0; index < this.items.length; index++) {
if (NEIServerUtils.areStacksSameTypeCraftingWithNBT(this.items[index], ingredient)) { if (NEIServerUtils.areStacksSameType(items[index], stack)) {
setPermutationToRender(index); return index;
return true;
} }
} }
return false; return -1;
}
public boolean setPermutationToRender(ItemStack ingredient) {
final int stackIndex = getPermutationIndex(ingredient);
if (stackIndex >= 0) {
setPermutationToRender(stackIndex);
}
return stackIndex >= 0;
} }
public void setPermutationToRender(int index) { public void setPermutationToRender(int index) {
@@ -136,6 +187,12 @@ public class PositionedStack {
} }
} }
public boolean contains(int mx, int my) {
return mx >= this.relx - 1 && mx < this.relx + this.width + 1
&& my >= this.rely - 1
&& my < this.rely + this.height + 1;
}
public boolean contains(ItemStack ingredient) { public boolean contains(ItemStack ingredient) {
for (ItemStack item : items) if (NEIServerUtils.areStacksSameTypeCrafting(item, ingredient)) return true; for (ItemStack item : items) if (NEIServerUtils.areStacksSameTypeCrafting(item, ingredient)) return true;
@@ -161,4 +218,120 @@ public class PositionedStack {
public String toString() { public String toString() {
return "PositionedStack(output='" + item.toString() + "')"; return "PositionedStack(output='" + item.toString() + "')";
} }
public static class Placeholder extends PositionedStack {
public Placeholder(Object object, int x, int y, boolean genPerms) {
super(object, x, y, genPerms);
}
public Placeholder(Object object, int x, int y) {
this(object, x, y, true);
}
@Override
public void draw(int mousex, int mousey) {}
}
public static class Tank extends PositionedStack {
/** The tank size the fill level is measured against, in mB. 0 means "always render full". */
protected int capacity = 0;
protected boolean flowingTexture = false;
protected FillDirection fillDirection = FillDirection.AUTO;
private ItemStack cachedFluidItem;
private FluidStack cachedFluidStack;
public Tank(Object object, int x, int y, boolean genPerms) {
super(object, x, y, genPerms);
}
public Tank(Object object, int x, int y) {
this(object, x, y, true);
}
public Tank(Object object, int x, int y, int width, int height, int capacity) {
super(object, x, y, false);
this.width = width;
this.height = height;
setCapacity(capacity);
}
public int getCapacity() {
return this.capacity;
}
public Tank setCapacity(int capacity) {
this.capacity = Math.max(capacity, 0);
return this;
}
public boolean hasFlowingTexture() {
return this.flowingTexture;
}
public Tank setFlowingTexture(boolean flowingTexture) {
this.flowingTexture = flowingTexture;
return this;
}
public FillDirection getFillDirection() {
return this.fillDirection;
}
public Tank setFillDirection(FillDirection fillDirection) {
this.fillDirection = fillDirection == null ? FillDirection.AUTO : fillDirection;
return this;
}
protected FluidStack getFluidStack() {
if (this.item != this.cachedFluidItem) {
this.cachedFluidItem = this.item;
this.cachedFluidStack = StackInfo.isFluidDisplayItem(this.item) ? StackInfo.getFluid(this.item) : null;
}
return this.cachedFluidStack;
}
@Override
public List<String> getTooltip() {
final List<String> tooltip = new ArrayList<>();
final List<String> customTooltip = super.getTooltip();
final FluidStack fluidStack = getFluidStack();
if (fluidStack != null && this.capacity > 0) {
tooltip.add(
EnumChatFormatting.GRAY + NEIClientUtils
.translate("recipe.fluid.tank.amount", NEIClientUtils.formatFluid(fluidStack.amount)));
}
if (customTooltip != null) {
tooltip.addAll(customTooltip);
}
return tooltip;
}
@Override
public void draw(int mousex, int mousey) {
final FluidStack fluidStack = getFluidStack();
if (fluidStack == null) {
super.draw(mousex, mousey);
return;
}
FluidDrawer.drawTank(
this.relx,
this.rely,
this.width,
this.height,
this.capacity,
fluidStack,
this.flowingTexture,
this.fillDirection);
}
}
} }
+33 -13
View File
@@ -21,6 +21,7 @@ import com.google.gson.JsonPrimitive;
import com.google.gson.JsonSyntaxException; import com.google.gson.JsonSyntaxException;
import codechicken.core.CommonUtils; import codechicken.core.CommonUtils;
import codechicken.nei.SubsetWidget.SubsetTag;
import codechicken.nei.api.API; import codechicken.nei.api.API;
import codechicken.nei.api.IRecipeFilter; import codechicken.nei.api.IRecipeFilter;
import codechicken.nei.api.IRecipeFilter.IRecipeFilterProvider; import codechicken.nei.api.IRecipeFilter.IRecipeFilterProvider;
@@ -33,6 +34,7 @@ import codechicken.nei.util.NBTJson;
public class PresetsList { public class PresetsList {
public enum PresetMode { public enum PresetMode {
SUBSET,
HIDE, HIDE,
REMOVE, REMOVE,
GROUP; GROUP;
@@ -66,11 +68,11 @@ public class PresetsList {
} }
} }
protected static class RecipesFilter implements IRecipeFilterProvider, IRecipeFilter { protected static class PresetRecipeFilter implements IRecipeFilterProvider, IRecipeFilter {
public Set<String> cache; public Set<String> cache;
public IRecipeFilter getFilter() { public IRecipeFilter getRecipeFilter() {
if (cache == null) { if (cache == null) {
cache = PresetsList.presets.stream().filter(p -> p.enabled && p.mode == PresetMode.REMOVE) cache = PresetsList.presets.stream().filter(p -> p.enabled && p.mode == PresetMode.REMOVE)
@@ -81,22 +83,25 @@ public class PresetsList {
} }
@Override @Override
public boolean matches(IRecipeHandler handler, List<PositionedStack> ingredients, PositionedStack result, public boolean matches(IRecipeHandler handler, int recipeIndex) {
List<PositionedStack> others) {
if (matchPositionedStack(ingredients, false)) { if (matchPositionedStack(handler.getIngredientStacks(recipeIndex), false)) {
return false; return false;
} }
if (result != null && matchPositionedStack(result)) { final List<PositionedStack> outputs = handler.getResultStacks(recipeIndex);
if (matchPositionedStack(outputs, true)) {
return true; return true;
} }
if (!others.isEmpty() && matchPositionedStack(others, true)) { final List<PositionedStack> auxiliaries = handler.getAuxiliaryStacks(recipeIndex);
if (matchPositionedStack(auxiliaries, true)) {
return true; return true;
} }
return result == null && others.isEmpty(); return outputs.isEmpty() && auxiliaries.isEmpty();
} }
private boolean matchPositionedStack(List<PositionedStack> items, boolean dir) { private boolean matchPositionedStack(List<PositionedStack> items, boolean dir) {
@@ -143,7 +148,7 @@ public class PresetsList {
} }
public static final List<Preset> presets = new ArrayList<>(); public static final List<Preset> presets = new ArrayList<>();
protected static RecipesFilter recipeFilter = new RecipesFilter(); protected static PresetRecipeFilter recipeFilter = new PresetRecipeFilter();
protected static ItemPanelFilter itemFilter = new ItemPanelFilter(); protected static ItemPanelFilter itemFilter = new ItemPanelFilter();
static { static {
@@ -158,9 +163,7 @@ public class PresetsList {
public static void load() { public static void load() {
final File presetsFile = new File(CommonUtils.getMinecraftDir(), "saves/NEI/global/presets.ini"); final File presetsFile = new File(CommonUtils.getMinecraftDir(), "saves/NEI/global/presets.ini");
if (presetsFile == null || !presetsFile.exists()) { if (!presetsFile.exists()) return;
return;
}
List<String> itemStrings; List<String> itemStrings;
try (FileInputStream reader = new FileInputStream(presetsFile)) { try (FileInputStream reader = new FileInputStream(presetsFile)) {
@@ -216,6 +219,8 @@ public class PresetsList {
if (!preset.items.isEmpty()) { if (!preset.items.isEmpty()) {
presets.add(preset); presets.add(preset);
} }
updateSubsets();
} }
public static void savePresets() { public static void savePresets() {
@@ -241,9 +246,24 @@ public class PresetsList {
recipeFilter.cache = null; recipeFilter.cache = null;
itemFilter.cache = null; itemFilter.cache = null;
updateSubsets();
CollapsibleItems.saveStates(); CollapsibleItems.saveStates();
CollapsibleItems.load(); CollapsibleItems.load();
LayoutManager.markItemsDirty(); ItemList.refreshItems.restart();
}
private static void updateSubsets() {
SubsetWidget.removeTag("Presets");
for (Preset preset : PresetsList.presets) {
if (preset.enabled && preset.mode == PresetMode.SUBSET) {
SubsetWidget.addTag(
new SubsetTag(
"Presets." + preset.name,
stack -> preset.items.contains(Preset.getIdentifier(stack))));
}
}
} }
} }
@@ -3,10 +3,13 @@ package codechicken.nei;
import net.minecraft.util.EnumChatFormatting; import net.minecraft.util.EnumChatFormatting;
import codechicken.nei.SearchField.GuiSearchField; import codechicken.nei.SearchField.GuiSearchField;
import codechicken.nei.api.IRecipeFilter;
import codechicken.nei.api.IRecipeFilter.IRecipeFilterProvider;
import codechicken.nei.api.ItemFilter; import codechicken.nei.api.ItemFilter;
import codechicken.nei.api.ItemFilter.ItemFilterProvider;
import codechicken.nei.util.TextHistory; import codechicken.nei.util.TextHistory;
public abstract class RecipeSearchField extends TextField { public abstract class RecipeSearchField extends TextField implements ItemFilterProvider, IRecipeFilterProvider {
private static final TextHistory history = new TextHistory(); private static final TextHistory history = new TextHistory();
@@ -17,9 +20,18 @@ public abstract class RecipeSearchField extends TextField {
@Override @Override
protected void initInternalTextField() { protected void initInternalTextField() {
field = new GuiSearchField(); final GuiSearchField field = new GuiSearchField();
field.setMaxStringLength(maxSearchLength); field.setMaxStringLength(maxSearchLength);
field.setCursorPositionZero(); field.setCursorPositionZero();
field.setSkipRecipeTokens(true);
field.setFormatter(new SearchTextFormatter(SearchField.searchParser) {
@Override
protected String getContextToken() {
return this.searchParser.getRecipeContextTokens();
}
});
this.field = field;
} }
public boolean isVisible() { public boolean isVisible() {
@@ -42,15 +54,19 @@ public abstract class RecipeSearchField extends TextField {
} }
@Override @Override
public void lastKeyTyped(int keyID, char keyChar) { public boolean onHotkeyPressed() {
if (focused() && NEIClientConfig.isKeyHashDown("gui.getprevioussearch")) { if (focused() && KeyManager.isKeyDown("gui.getprevioussearch")) {
handleNavigateHistory(TextHistory.Direction.PREVIOUS); handleNavigateHistory(TextHistory.Direction.PREVIOUS);
return true;
} }
if (focused() && NEIClientConfig.isKeyHashDown("gui.getnextsearch")) { if (focused() && KeyManager.isKeyDown("gui.getnextsearch")) {
handleNavigateHistory(TextHistory.Direction.NEXT); handleNavigateHistory(TextHistory.Direction.NEXT);
return true;
} }
return false;
} }
@Override @Override
@@ -58,10 +74,16 @@ public abstract class RecipeSearchField extends TextField {
return EnumChatFormatting.getTextWithoutFormattingCodes(s); return EnumChatFormatting.getTextWithoutFormattingCodes(s);
} }
@Override
public ItemFilter getFilter() { public ItemFilter getFilter() {
return ((GuiSearchField) field).getFilter(); return ((GuiSearchField) field).getFilter();
} }
@Override
public IRecipeFilter getRecipeFilter() {
return ((GuiSearchField) field).getRecipeFilter();
}
@Override @Override
public void setFocus(boolean focus) { public void setFocus(boolean focus) {
final boolean previousFocus = field.isFocused(); final boolean previousFocus = field.isFocused();
+48 -15
View File
@@ -15,7 +15,8 @@ import net.minecraftforge.fluids.FluidStack;
import codechicken.lib.gui.GuiDraw; import codechicken.lib.gui.GuiDraw;
import codechicken.nei.ItemList.NothingItemFilter; import codechicken.nei.ItemList.NothingItemFilter;
import codechicken.nei.SearchTokenParser.ISearchParserProvider; import codechicken.nei.SearchTokenParser.ISearchParserProvider;
import codechicken.nei.SearchTokenParser.SearchMode; import codechicken.nei.api.IRecipeFilter;
import codechicken.nei.api.IRecipeFilter.IRecipeFilterProvider;
import codechicken.nei.api.ItemFilter; import codechicken.nei.api.ItemFilter;
import codechicken.nei.api.ItemFilter.ItemFilterProvider; import codechicken.nei.api.ItemFilter.ItemFilterProvider;
import codechicken.nei.recipe.StackInfo; import codechicken.nei.recipe.StackInfo;
@@ -83,14 +84,15 @@ public class SearchField extends TextField implements ItemFilterProvider {
} }
@Override @Override
public SearchMode getSearchMode() { public String getName() {
return SearchMode.fromInt(NEIClientConfig.getIntSetting("inventory.search." + this.name + "SearchMode")); return this.name;
} }
} }
public static class GuiSearchField extends FormattedTextField { public static class GuiSearchField extends FormattedTextField implements ItemFilterProvider, IRecipeFilterProvider {
protected final SearchTokenParser searchParser; protected final SearchTokenParser searchParser;
protected boolean skipRecipeTokens = false;
public GuiSearchField() { public GuiSearchField() {
this(SearchField.searchParser); this(SearchField.searchParser);
@@ -104,12 +106,26 @@ public class SearchField extends TextField implements ItemFilterProvider {
setPlaceholder(NEIClientUtils.translate("inventory.search.placeholder")); setPlaceholder(NEIClientUtils.translate("inventory.search.placeholder"));
} }
public void setSkipRecipeTokens(boolean skipRecipeTokens) {
this.skipRecipeTokens = skipRecipeTokens;
}
@Override
public ItemFilter getFilter() { public ItemFilter getFilter() {
return getFilter(getText()); return getFilter(getText());
} }
@Override
public IRecipeFilter getRecipeFilter() {
return getRecipeFilter(getText());
}
public ItemFilter getFilter(String filterText) { public ItemFilter getFilter(String filterText) {
return this.searchParser.getFilter(filterText); return this.searchParser.getFilter(filterText, this.skipRecipeTokens);
}
public IRecipeFilter getRecipeFilter(String filterText) {
return this.searchParser.getRecipeFilter(filterText);
} }
} }
@@ -205,25 +221,30 @@ public class SearchField extends TextField implements ItemFilterProvider {
public void onTextChange(String oldText) { public void onTextChange(String oldText) {
final String newText = text(); final String newText = text();
if (!newText.equals(oldText)) { if (!newText.equals(oldText)) {
if (newText.length() > 0) NEIClientConfig.logger.debug("Searching for " + newText);
NEIClientConfig.setSearchExpression(newText); NEIClientConfig.setSearchExpression(newText);
ItemList.updateFilter.restart(); ItemList.updateFilter.restart();
} }
} }
@Override @Override
public void lastKeyTyped(int keyID, char keyChar) { public boolean onHotkeyPressed() {
if (isVisible() && NEIClientConfig.isKeyHashDown("gui.search")) { if (isVisible() && KeyManager.isHashDown("gui.search")) {
setFocus(true); setFocus(true);
} return true;
if (focused() && NEIClientConfig.isKeyHashDown("gui.getprevioussearch")) {
handleNavigateHistory(TextHistory.Direction.PREVIOUS);
} }
if (focused() && NEIClientConfig.isKeyHashDown("gui.getnextsearch")) { if (focused() && KeyManager.isKeyDown("gui.getprevioussearch")) {
handleNavigateHistory(TextHistory.Direction.NEXT); handleNavigateHistory(TextHistory.Direction.PREVIOUS);
return true;
} }
if (focused() && KeyManager.isKeyDown("gui.getnextsearch")) {
handleNavigateHistory(TextHistory.Direction.NEXT);
return true;
}
return false;
} }
@Override @Override
@@ -272,7 +293,7 @@ public class SearchField extends TextField implements ItemFilterProvider {
default: default:
break; break;
} }
// regex and extended+
if (!search.isEmpty()) { if (!search.isEmpty()) {
try { try {
return Pattern.compile(search, Pattern.MULTILINE | Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE); return Pattern.compile(search, Pattern.MULTILINE | Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE);
@@ -298,6 +319,9 @@ public class SearchField extends TextField implements ItemFilterProvider {
public static String getEscapedSearchText(String text) { public static String getEscapedSearchText(String text) {
text = EnumChatFormatting.getTextWithoutFormattingCodes(text); text = EnumChatFormatting.getTextWithoutFormattingCodes(text);
boolean addQuotes = text.contains(" ")
&& NEIClientConfig.getBooleanSetting("inventory.search.quoteDropItemName");
switch (NEIClientConfig.getIntSetting("inventory.search.patternMode")) { switch (NEIClientConfig.getIntSetting("inventory.search.patternMode")) {
case 1: case 1:
text = text.replaceAll("[\\?|\\*]", "\\\\$0"); text = text.replaceAll("[\\?|\\*]", "\\\\$0");
@@ -305,11 +329,20 @@ public class SearchField extends TextField implements ItemFilterProvider {
case 2: case 2:
text = text.replaceAll("[{}()\\[\\].+*?^$\\\\|]", "\\\\$0"); text = text.replaceAll("[{}()\\[\\].+*?^$\\\\|]", "\\\\$0");
break; break;
case 3:
// In extended+ quotes require only quotes to be escaped
if (addQuotes) {
text = text.replaceAll("\"", "\\\\$0");
} else {
String prefixes = searchParser.getPrefixes();
text = text.replaceAll("[-<>^{}|/\\\\\"" + Pattern.quote(prefixes) + "]", "\\\\$0");
}
break;
default: default:
break; break;
} }
if (text.contains(" ") && NEIClientConfig.getBooleanSetting("inventory.search.quoteDropItemName")) { if (addQuotes) {
text = "\"" + text + "\""; text = "\"" + text + "\"";
} }
@@ -1,66 +1,111 @@
package codechicken.nei; package codechicken.nei;
import java.util.List;
import java.util.StringJoiner;
import net.minecraft.util.EnumChatFormatting; import net.minecraft.util.EnumChatFormatting;
import codechicken.nei.FormattedTextField.TextFormatter; import codechicken.nei.FormattedTextField.TextFormatter;
import codechicken.nei.SearchTokenParser.SearchToken; import codechicken.nei.search.SearchExpressionFormatVisitor;
import codechicken.nei.search.SearchExpressionUtils;
import codechicken.nei.search.SearchToken;
public class SearchTextFormatter implements TextFormatter { public class SearchTextFormatter implements TextFormatter {
protected final SearchTokenParser searchParser; protected final SearchTokenParser searchParser;
protected String contextToken = "";
public SearchTextFormatter(SearchTokenParser searchParser) { public SearchTextFormatter(SearchTokenParser searchParser) {
this.searchParser = searchParser; this.searchParser = searchParser;
} }
public void setContextToken(String contextToken) {
this.contextToken = contextToken;
}
protected String getContextToken() {
return this.contextToken;
}
@Override
public String format(String text) { public String format(String text) {
final String[] parts = (text + "| ").split("\\|"); final int patternMode = NEIClientConfig.getIntSetting("inventory.search.patternMode");
StringJoiner formattedText = new StringJoiner(EnumChatFormatting.GRAY + "|"); if (patternMode == 3) {
final int spaceModeEnabled = NEIClientConfig.getIntSetting("inventory.search.spaceMode");
if (spaceModeEnabled == 1) {
text = SearchTokenParser.SPACE_PATTERN.matcher(text).replaceAll("\\\\ ");
}
final SearchExpressionFormatVisitor visitor = new SearchExpressionFormatVisitor(searchParser);
return SearchExpressionUtils.visitRecipeSearchExpression(text, visitor);
} else {
final StringBuilder formattedText = new StringBuilder();
final String contextToken = getContextToken();
for (int i = 0; i < parts.length - 1; i++) { for (String[] orQuery : searchParser.splitByDelimiters(text, "|", false)) {
final String filterText = parts[i]; final String filterText = orQuery[1];
final List<SearchToken> tokens = searchParser.splitSearchText(filterText);
StringBuilder formattedPart = new StringBuilder();
int startIndex = 0;
for (SearchToken token : tokens) { formattedText.append(SearchExpressionUtils.HIGHLIGHTS.OR + orQuery[0]);
formattedPart.append(filterText.substring(startIndex, token.start));
EnumChatFormatting tokenColor = EnumChatFormatting.RESET;
if (token.firstChar != null) { for (String[] contextPart : searchParser.splitByDelimiters(filterText, contextToken, false)) {
tokenColor = searchParser.getProvider(token.firstChar).getHighlightedColor();
if (!contextPart[0].isEmpty()) {
formattedText.append(
SearchExpressionUtils.HIGHLIGHTS.RECIPE + contextPart[0].substring(0, 1)
+ EnumChatFormatting.RESET);
contextPart[1] = contextPart[0].substring(1) + contextPart[1];
}
if (contextPart[1].isEmpty()) {
continue;
}
int startIndex = 0;
final String prefixes = contextPart[0].startsWith("~") ? "" : searchParser.getPrefixes();
for (SearchToken token : searchParser.splitSearchText(contextPart[1], prefixes)) {
formattedText.append(contextPart[1].substring(startIndex, token.start));
EnumChatFormatting tokenColor = EnumChatFormatting.RESET;
if (token.firstChar != null) {
tokenColor = searchParser.getProvider(token.firstChar).getHighlightedColor();
}
if (token.ignore != null) {
formattedText
.append(SearchExpressionUtils.HIGHLIGHTS.NEGATE + String.valueOf(token.ignore));
}
if (token.firstChar != null) {
formattedText.append(tokenColor + String.valueOf(token.firstChar));
}
if (token.quotes) {
formattedText.append(SearchExpressionUtils.HIGHLIGHTS.QUOTED + "\"");
}
if (patternMode == 1 && !token.quotes && isRegexToken(token.rawText)) {
formattedText.append(SearchExpressionUtils.HIGHLIGHTS.REGEX + token.rawText.substring(0, 2))
.append(tokenColor + token.rawText.substring(2, token.rawText.length() - 1))
.append(SearchExpressionUtils.HIGHLIGHTS.REGEX + "/");
} else if (!token.rawText.isEmpty()) {
formattedText.append(tokenColor + token.rawText);
}
if (token.quotes) {
formattedText.append(SearchExpressionUtils.HIGHLIGHTS.QUOTED + "\"");
}
startIndex = token.end;
}
formattedText.append(contextPart[1].substring(startIndex, contextPart[1].length()));
} }
if (token.ignore) {
formattedPart.append(EnumChatFormatting.BLUE + "-");
}
if (token.firstChar != null) {
formattedPart.append(tokenColor + String.valueOf(token.firstChar));
}
if (token.quotes) {
formattedPart.append(EnumChatFormatting.GOLD + "\"");
}
if (!token.rawText.isEmpty()) {
formattedPart.append(tokenColor + token.rawText);
}
if (token.quotes) {
formattedPart.append(EnumChatFormatting.GOLD + "\"");
}
startIndex = token.end;
} }
formattedPart.append(filterText.substring(startIndex, filterText.length())); return formattedText.toString();
formattedText.add(formattedPart);
} }
}
return formattedText.toString(); private static boolean isRegexToken(String search) {
return search.length() >= 3 && search.regionMatches(true, 0, "r/", 0, 2) && search.endsWith("/");
} }
} }
@@ -1,14 +1,12 @@
package codechicken.nei; package codechicken.nei;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections; import java.util.Collections;
import java.util.HashMap; import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.regex.Matcher; import java.util.function.Predicate;
import java.util.regex.Pattern; import java.util.regex.Pattern;
import java.util.stream.Collectors;
import net.minecraft.client.Minecraft; import net.minecraft.client.Minecraft;
import net.minecraft.client.resources.Language; import net.minecraft.client.resources.Language;
@@ -18,9 +16,17 @@ import net.minecraft.util.EnumChatFormatting;
import codechicken.nei.ItemList.AllMultiItemFilter; import codechicken.nei.ItemList.AllMultiItemFilter;
import codechicken.nei.ItemList.AnyMultiItemFilter; import codechicken.nei.ItemList.AnyMultiItemFilter;
import codechicken.nei.ItemList.EverythingItemFilter; import codechicken.nei.ItemList.EverythingItemFilter;
import codechicken.nei.ItemList.NegatedItemFilter; import codechicken.nei.api.IRecipeFilter;
import codechicken.nei.ItemList.NothingItemFilter;
import codechicken.nei.api.ItemFilter; import codechicken.nei.api.ItemFilter;
import codechicken.nei.filter.AllMultiRecipeFilter;
import codechicken.nei.filter.AnyMultiRecipeFilter;
import codechicken.nei.filter.RecipeFilter;
import codechicken.nei.filter.RecipeFilter.FilterContext;
import codechicken.nei.filter.RecipeTextFilter;
import codechicken.nei.search.ItemFilterVisitor;
import codechicken.nei.search.RecipeFilterVisitor;
import codechicken.nei.search.SearchExpressionUtils;
import codechicken.nei.search.SearchToken;
public class SearchTokenParser { public class SearchTokenParser {
@@ -39,20 +45,6 @@ public class SearchTokenParser {
} }
} }
public static class SearchToken {
public boolean ignore = false;
public boolean quotes = false;
public Character firstChar = null;
public String[] words;
public String rawText = "";
public int start = 0;
public int end = 0;
}
public static interface ISearchParserProvider { public static interface ISearchParserProvider {
public ItemFilter getFilter(String searchText); public ItemFilter getFilter(String searchText);
@@ -69,7 +61,13 @@ public class SearchTokenParser {
public EnumChatFormatting getHighlightedColor(); public EnumChatFormatting getHighlightedColor();
public SearchMode getSearchMode(); default SearchMode getSearchMode() {
return SearchMode.fromInt(NEIClientConfig.getIntSetting("inventory.search." + getName() + "SearchMode"));
}
default String getName() {
return String.valueOf(getPrefix());
}
} }
private static class ProvidersCache { private static class ProvidersCache {
@@ -83,7 +81,7 @@ public class SearchTokenParser {
} }
} }
private static class IsRegisteredItemFilter implements ItemFilter { public static class IsRegisteredItemFilter implements ItemFilter {
public ItemFilter filter; public ItemFilter filter;
@@ -99,10 +97,14 @@ public class SearchTokenParser {
} }
} }
public static final Pattern SPACE_PATTERN = Pattern.compile(" ");
protected final LRUCache<String, ItemFilter> filtersCache = new LRUCache<>(20); protected final LRUCache<String, ItemFilter> filtersCache = new LRUCache<>(20);
protected final LRUCache<String, IRecipeFilter> recipesCache = new LRUCache<>(20);
protected final List<ISearchParserProvider> searchProviders; protected final List<ISearchParserProvider> searchProviders;
protected final ProvidersCache providersCache = new ProvidersCache(); protected final ProvidersCache providersCache = new ProvidersCache();
protected final Map<Character, Character> prefixRedefinitions = new HashMap<>(); protected final Map<Character, Character> prefixRedefinitions = new HashMap<>();
protected String prefixes = null;
public SearchTokenParser(List<ISearchParserProvider> searchProviders) { public SearchTokenParser(List<ISearchParserProvider> searchProviders) {
this.searchProviders = searchProviders; this.searchProviders = searchProviders;
@@ -114,22 +116,22 @@ public class SearchTokenParser {
public void addProvider(ISearchParserProvider provider) { public void addProvider(ISearchParserProvider provider) {
this.searchProviders.add(provider); this.searchProviders.add(provider);
clearCache();
}
public synchronized void clearCache() {
this.providersCache.clear(); this.providersCache.clear();
this.filtersCache.clear(); this.filtersCache.clear();
this.recipesCache.clear();
this.prefixes = null;
} }
public void clearCache() { public List<ISearchParserProvider> getProviders() {
this.filtersCache.clear();
}
protected List<ISearchParserProvider> getProviders() {
Language currentLanguage = Minecraft.getMinecraft().getLanguageManager().getCurrentLanguage(); Language currentLanguage = Minecraft.getMinecraft().getLanguageManager().getCurrentLanguage();
if (!currentLanguage.getLanguageCode().equals(providersCache.languageCode)) { if (!currentLanguage.getLanguageCode().equals(providersCache.languageCode)) {
providersCache.providers = new ArrayList<>(); final List<ISearchParserProvider> providersList = new ArrayList<>();
providersCache.languageCode = currentLanguage.getLanguageCode(); final Map<Character, ISearchParserProvider> providers = new HashMap<>();
Map<Character, ISearchParserProvider> providers = new HashMap<>();
for (int index = this.searchProviders.size() - 1; index >= 0; index--) { for (int index = this.searchProviders.size() - 1; index >= 0; index--) {
ISearchParserProvider provider = this.searchProviders.get(index); ISearchParserProvider provider = this.searchProviders.get(index);
@@ -138,177 +140,420 @@ public class SearchTokenParser {
if (provider.getSearchMode() == SearchMode.PREFIX && !providers.containsKey(provider.getPrefix())) { if (provider.getSearchMode() == SearchMode.PREFIX && !providers.containsKey(provider.getPrefix())) {
providers.put(provider.getPrefix(), provider); providers.put(provider.getPrefix(), provider);
} else if (provider.getSearchMode() == SearchMode.ALWAYS) { } else if (provider.getSearchMode() == SearchMode.ALWAYS) {
providersCache.providers.add(provider); providersList.add(provider);
} }
} }
} }
providersCache.providers.addAll(providers.values()); providersList.addAll(providers.values());
providersCache.languageCode = currentLanguage.getLanguageCode();
providersCache.providers = providersList;
} }
return providersCache.providers; return providersCache.providers;
} }
public boolean hasRedefinedPrefix(char ch) {
return getPrefixes().indexOf(ch) >= 0;
}
public ISearchParserProvider getProvider(char ch) { public ISearchParserProvider getProvider(char ch) {
return getProviders().stream() if (!hasRedefinedPrefix(ch)) {
.filter( return null;
provider -> provider.getSearchMode() == SearchMode.PREFIX }
&& getRedefinedPrefix(provider.getPrefix()) == ch) for (ISearchParserProvider provider : getProviders()) {
.findFirst().orElse(null); if (provider.getSearchMode() == SearchMode.PREFIX && getRedefinedPrefix(provider.getPrefix()) == ch) {
return provider;
}
}
return null;
}
public List<ItemFilter> getAlwaysProvidersFilters(String searchText) {
final List<ItemFilter> filters = new ArrayList<>();
for (ISearchParserProvider provider : getProviders()) {
if (provider.getSearchMode() == SearchMode.ALWAYS) {
filters.add(provider.getFilter(searchText));
}
}
return filters;
} }
public synchronized ItemFilter getFilter(String filterText) { public synchronized ItemFilter getFilter(String filterText) {
filterText = EnumChatFormatting.getTextWithoutFormattingCodes(filterText).toLowerCase(); return getFilter(filterText, false);
}
return this.filtersCache.computeIfAbsent(filterText, text -> { public synchronized ItemFilter getFilter(String rawText, boolean skipRecipeTokens) {
final String[] parts = text.split("\\|"); final String filterText = EnumChatFormatting.getTextWithoutFormattingCodes(rawText).toLowerCase();
final List<ItemFilter> searchTokens = Arrays.stream(parts).map(this::parseSearchText).filter(s -> s != null)
.collect(Collectors.toList());
if (searchTokens.isEmpty()) { if (filterText.isEmpty()) {
return new EverythingItemFilter(); return new EverythingItemFilter();
} else if (searchTokens.size() == 1) { }
return new IsRegisteredItemFilter(searchTokens.get(0));
} else {
return new IsRegisteredItemFilter(new AnyMultiItemFilter(searchTokens));
}
}); final int patternMode = NEIClientConfig.getIntSetting("inventory.search.patternMode");
if (patternMode != 3) {
return this.filtersCache.computeIfAbsent(skipRecipeTokens + ":" + filterText, _t -> {
final List<ItemFilter> searchTokens = new ArrayList<>();
final String contextTokens = skipRecipeTokens ? getRecipeContextTokens() : "";
for (String[] subQuery : splitByDelimiters(filterText, "|", false)) {
if (subQuery[1].isEmpty()) {
continue;
}
final List<ItemFilter> tokens = new ArrayList<>();
for (String[] contextQuery : splitByDelimiters(subQuery[1], contextTokens, false)) {
if (contextQuery[1].isEmpty() || contextQuery[0].startsWith(">")
|| contextQuery[0].startsWith("^")
|| contextQuery[0].startsWith("~")) {
continue;
}
if (!contextQuery[0].isEmpty()) {
contextQuery[0] = contextQuery[0].substring(1);
}
for (SearchToken token : splitSearchText(contextQuery[0] + contextQuery[1])) {
final ItemFilter result = token.getFilter(this);
if (result != null) {
tokens.add(result);
}
}
}
if (tokens.size() == 1) {
searchTokens.add(tokens.get(0));
} else if (!tokens.isEmpty()) {
searchTokens.add(new AllMultiItemFilter(tokens));
}
}
if (searchTokens.isEmpty()) {
return new EverythingItemFilter();
} else if (searchTokens.size() == 1) {
return new IsRegisteredItemFilter(searchTokens.get(0));
} else {
return new IsRegisteredItemFilter(new AnyMultiItemFilter(searchTokens));
}
});
} else {
return this.filtersCache.computeIfAbsent(filterText, text -> {
final int spaceMode = NEIClientConfig.getIntSetting("inventory.search.spaceMode");
if (spaceMode == 1) {
text = SearchTokenParser.SPACE_PATTERN.matcher(text).replaceAll("\\\\ ");
}
if (skipRecipeTokens) {
return new IsRegisteredItemFilter(
SearchExpressionUtils.visitRecipeSearchExpression(text, new ItemFilterVisitor(this)));
} else {
return new IsRegisteredItemFilter(
SearchExpressionUtils.visitSearchExpression(text, new ItemFilterVisitor(this)));
}
});
}
} }
public List<SearchToken> splitSearchText(String filterText) { public synchronized IRecipeFilter getRecipeFilter(String filterText) {
filterText = EnumChatFormatting.getTextWithoutFormattingCodes(filterText).toLowerCase();
if (filterText.isEmpty()) {
return new RecipeFilter(FilterContext.ANY, true, new EverythingItemFilter());
}
final int patternMode = NEIClientConfig.getIntSetting("inventory.search.patternMode");
if (patternMode != 3) {
return this.recipesCache.computeIfAbsent(filterText, input -> {
final List<IRecipeFilter> searchTokens = new ArrayList<>();
for (String[] orQueryPart : splitByDelimiters(input, "|", false)) {
if (orQueryPart[1].isEmpty()) {
continue;
}
final List<IRecipeFilter> contextList = new ArrayList<>();
for (String[] contextQuery : splitByDelimiters(orQueryPart[1], getRecipeContextTokens(), false)) {
if (contextQuery[1].isEmpty()) {
continue;
}
final List<IRecipeFilter> tokens = new ArrayList<>();
final boolean recipeText = contextQuery[0].startsWith("~");
FilterContext context = FilterContext.ANY;
if (!contextQuery[0].isEmpty()) {
context = FilterContext.fromChar(contextQuery[0].charAt(0));
contextQuery[0] = contextQuery[0].substring(1);
}
for (SearchToken token : splitSearchText(
contextQuery[0] + contextQuery[1],
recipeText ? "" : getPrefixes())) {
if (recipeText) {
final IRecipeFilter text = recipeTextFilter(token);
if (text != null) {
tokens.add(text);
}
} else {
final ItemFilter result = token.getFilter(this);
if (result != null) {
tokens.add(
new RecipeFilter(
context,
token.ignore == null || token.ignore != '!',
result));
}
}
}
if (tokens.size() == 1) {
contextList.add(tokens.get(0));
} else if (!tokens.isEmpty()) {
contextList.add(new AllMultiRecipeFilter(tokens));
}
}
if (contextList.size() == 1) {
searchTokens.add(contextList.get(0));
} else if (!contextList.isEmpty()) {
searchTokens.add(new AllMultiRecipeFilter(contextList));
}
}
if (searchTokens.isEmpty()) {
return new RecipeFilter(FilterContext.ANY, true, new EverythingItemFilter());
} else if (searchTokens.size() == 1) {
return searchTokens.get(0);
} else {
return new AnyMultiRecipeFilter(searchTokens);
}
});
} else {
return this.recipesCache.computeIfAbsent(filterText, text -> {
final int spaceMode = NEIClientConfig.getIntSetting("inventory.search.spaceMode");
if (spaceMode == 1) {
text = SearchTokenParser.SPACE_PATTERN.matcher(text).replaceAll("\\\\ ");
}
return SearchExpressionUtils.visitRecipeSearchExpression(text, new RecipeFilterVisitor(this));
});
}
}
private static IRecipeFilter recipeTextFilter(SearchToken token) {
if (token.rawText.isEmpty()) return null;
final List<Predicate<List<String>>> words = new ArrayList<>();
for (String word : token.words) {
final Pattern pattern = SearchField.getPattern(word);
if (pattern != null) words.add(RecipeTextFilter.matching(pattern));
}
if (words.isEmpty()) return null;
final Predicate<List<String>> text = lines -> words.stream().allMatch(word -> word.test(lines));
return new RecipeTextFilter(token.ignore == null ? text : text.negate());
}
public List<SearchToken> splitSearchText(String filterText) {
return splitSearchText(filterText, getPrefixes());
}
public List<SearchToken> splitSearchText(String filterText, String prefixes) {
if (filterText.isEmpty()) { if (filterText.isEmpty()) {
return Collections.emptyList(); return Collections.emptyList();
} }
final List<SearchToken> tokens = new ArrayList<>(); final List<SearchToken> tokens = new ArrayList<>();
final String prefixes = getPrefixes();
final int spaceMode = NEIClientConfig.getIntSetting("inventory.search.spaceMode"); final int spaceMode = NEIClientConfig.getIntSetting("inventory.search.spaceMode");
// The regular expression first tries to match a string that starts with a space or the beginning of the string, SearchToken lastToken = null;
// followed by a sequence of characters that do not contain special characters -"@#$%&, and ends with a space int lastEnd = 0;
// and the characters -"@#$%& or the end of the string.
final String patternPart1 = "(?<tokenA>(^|\\s+)(?:[^" + Pattern.quote(" -\"" + prefixes)
+ "]).+?(?=\\s+["
+ Pattern.quote("-\"" + prefixes)
+ "]|$))";
// If the first condition is not met, it tries to match a sequence of - characters, followed by @#$%&
// characters, then either a quoted string or non-space characters.
final String patternPart2 = "((?<ignore>-*)(?<firstChar>[" + Pattern.quote(prefixes)
+ "]*)(?<tokenB>\\\".*?(?:\\\"|$)|\\S+\\s*))";
final Pattern pattern = Pattern.compile(spaceMode == 0 ? patternPart2 : (patternPart1 + "|" + patternPart2));
final Matcher filterMatcher = pattern.matcher(filterText);
while (filterMatcher.find()) { for (String[] part : splitByDelimiters(filterText, "-!" + prefixes, true)) {
String firstChar = filterMatcher.group("firstChar"); final SearchToken token = createToken(lastEnd, part, prefixes);
SearchToken token = new SearchToken(); final int length = part[0].length() + part[1].length();
token.start = filterMatcher.start();
token.end = filterMatcher.end();
token.ignore = "-".equals(filterMatcher.group("ignore"));
token.rawText = spaceMode == 0 ? null : filterMatcher.group("tokenA");
if (firstChar != null && !firstChar.isEmpty()) { if (token.isSimpleFilter() && token.rawText.isEmpty()) {
token.firstChar = firstChar.charAt(0); lastEnd += length;
continue;
} }
if (token.rawText == null) { // spaceMode == 0 if (spaceMode == 0) { // and
token.rawText = filterMatcher.group("tokenB"); tokens.add(lastToken = token);
token.quotes = token.rawText.length() > 1 && token.rawText.startsWith("\"") } else if (spaceMode == 1) { // space
&& token.rawText.endsWith("\"");
if (token.quotes) { if (lastToken != null && lastToken.isSimpleFilter() && token.isSimpleFilter()) {
token.rawText = token.rawText.substring(1, token.rawText.length() - 1); lastToken.rawText = filterText.substring(lastToken.start, token.end).trim();
lastToken.words[0] = lastToken.rawText;
lastToken.end = token.end;
} else {
tokens.add(lastToken = token);
}
} else if (spaceMode == 2) { // and-x
if (lastToken != null && lastToken.isSimpleFilter() && token.isSimpleFilter()) {
final String[] newWords = new String[lastToken.words.length + token.words.length];
System.arraycopy(lastToken.words, 0, newWords, 0, lastToken.words.length);
System.arraycopy(token.words, 0, newWords, lastToken.words.length, token.words.length);
lastToken.words = newWords;
lastToken.rawText = filterText.substring(lastToken.start, token.end).trim();
lastToken.end = token.end;
} else {
tokens.add(lastToken = token);
} }
token.words = new String[] { token.rawText.trim() };
} else if (spaceMode == 2) {
token.words = token.rawText.trim().split("\\s+");
} else {
token.words = new String[] { token.rawText.trim() };
} }
tokens.add(token); lastEnd += length;
} }
return tokens; return tokens;
} }
private String getPrefixes() { private SearchToken createToken(int lastEnd, String[] part, String prefixes) {
StringBuilder prefixes = new StringBuilder().append('\0'); final SearchToken token = new SearchToken();
String pref = part[0];
String query = part[1].trim();
for (ISearchParserProvider provider : getProviders()) { token.start = lastEnd;
if (provider.getSearchMode() == SearchMode.PREFIX) { token.end = lastEnd + pref.length() + query.length();
prefixes.append(getRedefinedPrefix(provider.getPrefix()));
if (pref.startsWith("-")) {
token.ignore = '-';
pref = pref.substring(1);
} else if (pref.startsWith("!")) {
token.ignore = '!';
pref = pref.substring(1);
}
if (!pref.isEmpty()) {
char firstChar = pref.charAt(0);
if (prefixes.indexOf(firstChar) >= 0) {
token.firstChar = firstChar;
pref = pref.substring(1);
} }
} }
return prefixes.toString(); String text = pref + query;
token.quotes = text.length() > 1 && text.startsWith("\"") && text.endsWith("\"");
if (token.quotes) {
text = text.substring(1, text.length() - 1);
}
token.rawText = text;
token.words = new String[] { token.quotes ? text.replaceAll("\\\\\"", "\"") : text };
return token;
}
public List<String[]> splitByDelimiters(String input, String delimiters, boolean space) {
if (delimiters == null || delimiters.isEmpty()) {
return Collections.singletonList(new String[] { "", input });
}
final List<String[]> tokens = new ArrayList<>();
final int length = input.length();
final boolean regexTokens = NEIClientConfig.getIntSetting("inventory.search.patternMode") == 1;
boolean insideQuotes = false;
boolean insideRegex = false;
String token = "";
int lastEnd = 0;
int index = 0;
while (index < length) {
final char ch = input.charAt(index);
if (insideRegex) {
if (ch == '/' && input.charAt(index - 1) != '\\') {
insideRegex = false;
}
index++;
continue;
}
if (!insideQuotes && delimiters.indexOf(ch) >= 0
&& (!space || index == 0 || input.charAt(index - 1) == ' ' || lastEnd == index)) {
if (lastEnd == index) {
token += String.valueOf(ch);
} else {
tokens.add(new String[] { token, input.substring(lastEnd, index) });
token = String.valueOf(ch);
}
lastEnd = index + 1;
} else if (!insideQuotes && space && ch != ' ' && (index > 0 && input.charAt(index - 1) == ' ')) {
tokens.add(new String[] { token, input.substring(lastEnd, index) });
token = "";
lastEnd = index;
}
if (ch == '"' && (index == 0 || input.charAt(index - 1) != '\\')) {
insideQuotes = !insideQuotes;
} else if (regexTokens && !insideQuotes && isRegexStart(input, index)) {
insideRegex = true;
index++;
}
index++;
}
tokens.add(new String[] { token, input.substring(lastEnd) });
return tokens;
}
private static boolean isRegexStart(String input, int index) {
return Character.toLowerCase(input.charAt(index)) == 'r' && index + 1 < input.length()
&& input.charAt(index + 1) == '/'
&& (index == 0 || !Character.isLetterOrDigit(input.charAt(index - 1)));
}
public String getPrefixes() {
if (this.prefixes == null) {
final StringBuilder builder = new StringBuilder();
for (ISearchParserProvider provider : getProviders()) {
if (provider.getSearchMode() == SearchTokenParser.SearchMode.PREFIX) {
builder.append(getRedefinedPrefix(provider.getPrefix()));
}
}
this.prefixes = builder.toString();
}
return this.prefixes;
}
public String getRecipeContextTokens() {
// '^' is the start anchor and the negated class in regex mode
return NEIClientConfig.getIntSetting("inventory.search.patternMode") == 2 ? "<>~" : "<>~^";
} }
public char getRedefinedPrefix(char prefix) { public char getRedefinedPrefix(char prefix) {
return this.prefixRedefinitions.getOrDefault(prefix, prefix); return this.prefixRedefinitions.getOrDefault(prefix, prefix);
} }
private ItemFilter parseSearchText(String filterText) {
if (filterText.isEmpty()) {
return null;
}
final AllMultiItemFilter searchTokens = new AllMultiItemFilter();
final List<SearchToken> tokens = splitSearchText(filterText);
for (SearchToken token : tokens) {
if (!token.rawText.isEmpty()) {
ItemFilter result = parseToken(token);
if (token.ignore) {
searchTokens.filters.add(new NegatedItemFilter(result));
} else {
searchTokens.filters.add(result);
}
} else if (!token.ignore) {
searchTokens.filters.add(new NothingItemFilter());
}
}
return searchTokens;
}
private ItemFilter parseToken(SearchToken token) {
final ISearchParserProvider provider = token.firstChar == null ? null : this.getProvider(token.firstChar);
if (provider == null || provider.getSearchMode() == SearchMode.NEVER) {
final List<ItemFilter> filters = new ArrayList<>();
for (ISearchParserProvider _provider : getProviders()) {
if (_provider.getSearchMode() == SearchMode.ALWAYS) {
AllMultiItemFilter filter = generateFilters(_provider, token.words);
if (!filter.filters.isEmpty()) {
filters.add(filter);
}
}
}
return filters.isEmpty() ? new NothingItemFilter() : new AnyMultiItemFilter(filters);
} else {
return generateFilters(provider, token.words);
}
}
private AllMultiItemFilter generateFilters(ISearchParserProvider provider, String[] words) {
final AllMultiItemFilter filters = new AllMultiItemFilter();
for (String work : words) {
final ItemFilter filter = provider.getFilter(work);
if (filter != null) {
filters.filters.add(filter);
}
}
return filters;
}
} }
@@ -10,6 +10,7 @@ import net.minecraftforge.event.world.WorldEvent;
import codechicken.core.CommonUtils; import codechicken.core.CommonUtils;
import codechicken.lib.packet.PacketCustom; import codechicken.lib.packet.PacketCustom;
import codechicken.nei.item.ItemFluidDisplay;
import cpw.mods.fml.common.FMLCommonHandler; import cpw.mods.fml.common.FMLCommonHandler;
import cpw.mods.fml.common.eventhandler.SubscribeEvent; import cpw.mods.fml.common.eventhandler.SubscribeEvent;
import cpw.mods.fml.common.gameevent.PlayerEvent.PlayerChangedDimensionEvent; import cpw.mods.fml.common.gameevent.PlayerEvent.PlayerChangedDimensionEvent;
@@ -18,13 +19,12 @@ import cpw.mods.fml.common.gameevent.PlayerEvent.PlayerLoggedOutEvent;
import cpw.mods.fml.common.gameevent.PlayerEvent.PlayerRespawnEvent; import cpw.mods.fml.common.gameevent.PlayerEvent.PlayerRespawnEvent;
import cpw.mods.fml.common.gameevent.TickEvent; import cpw.mods.fml.common.gameevent.TickEvent;
import cpw.mods.fml.common.gameevent.TickEvent.Phase; import cpw.mods.fml.common.gameevent.TickEvent.Phase;
import cpw.mods.fml.common.registry.GameRegistry;
public class ServerHandler { public class ServerHandler {
private static ServerHandler instance;
public static void load() { public static void load() {
instance = new ServerHandler(); ServerHandler instance = new ServerHandler();
PacketCustom.assignHandler(NEICPH.channel, new NEISPH()); PacketCustom.assignHandler(NEICPH.channel, new NEISPH());
FMLCommonHandler.instance().bus().register(instance); FMLCommonHandler.instance().bus().register(instance);
@@ -33,6 +33,14 @@ public class ServerHandler {
NEIActions.init(); NEIActions.init();
} }
public static void preInit() {
registerFluidDisplayItem();
}
private static void registerFluidDisplayItem() {
GameRegistry.registerItem(new ItemFluidDisplay(), "neiFluidDisplay");
}
@SubscribeEvent @SubscribeEvent
public void tickEvent(TickEvent.WorldTickEvent event) { public void tickEvent(TickEvent.WorldTickEvent event) {
if (event.phase == Phase.START && !event.world.isRemote if (event.phase == Phase.START && !event.world.isRemote
@@ -48,8 +56,7 @@ public class ServerHandler {
@SubscribeEvent @SubscribeEvent
public void tickEvent(TickEvent.PlayerTickEvent event) { public void tickEvent(TickEvent.PlayerTickEvent event) {
if (event.phase == Phase.START && event.player instanceof EntityPlayerMP) { if (event.phase == Phase.START && event.player instanceof EntityPlayerMP player) {
EntityPlayerMP player = (EntityPlayerMP) event.player;
PlayerSave save = NEIServerConfig.forPlayer(player.getCommandSenderName()); PlayerSave save = NEIServerConfig.forPlayer(player.getCommandSenderName());
if (save == null) return; if (save == null) return;
updateMagneticPlayer(player, save); updateMagneticPlayer(player, save);
@@ -0,0 +1,36 @@
package codechicken.nei;
import codechicken.lib.packet.PacketCustom;
import codechicken.nei.PacketIDs.C2S;
/**
* Waits until the server has processed everything the client sent before. The server handles slot clicks and NEI
* packets in the order they came and answers after it has sent the slot updates, so once the answer is here the client
* container holds what the server computed.
*/
public final class ServerSync {
private static int lastId;
private static volatile int awaiting;
private ServerSync() {}
public static void request() {
if (!NEIClientConfig.hasSMPCounterPart()) {
awaiting = 0;
return;
}
awaiting = ++lastId;
new PacketCustom(NEICPH.channel, C2S.SYNC).writeInt(awaiting).sendToServer();
}
public static boolean pending() {
return awaiting != 0;
}
static void onReply(int id) {
if (id == awaiting) awaiting = 0;
}
}
+128 -128
View File
@@ -6,22 +6,19 @@ import java.util.ArrayList;
import java.util.Comparator; import java.util.Comparator;
import java.util.HashMap; import java.util.HashMap;
import java.util.HashSet; import java.util.HashSet;
import java.util.LinkedList;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Set; import java.util.Set;
import java.util.concurrent.TimeUnit; import java.util.regex.Pattern;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.stream.Collectors; import java.util.stream.Collectors;
import java.util.stream.Stream; import java.util.stream.Stream;
import net.minecraft.client.Minecraft; import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.item.ItemStack; import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTBase; import net.minecraft.nbt.NBTBase;
import net.minecraft.nbt.NBTTagCompound; import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList; import net.minecraft.nbt.NBTTagList;
import net.minecraft.nbt.NBTTagString;
import net.minecraft.util.EnumChatFormatting; import net.minecraft.util.EnumChatFormatting;
import org.lwjgl.opengl.GL11; import org.lwjgl.opengl.GL11;
@@ -39,7 +36,6 @@ import codechicken.nei.api.API;
import codechicken.nei.api.ItemFilter; import codechicken.nei.api.ItemFilter;
import codechicken.nei.api.ItemFilter.ItemFilterProvider; import codechicken.nei.api.ItemFilter.ItemFilterProvider;
import codechicken.nei.guihook.GuiContainerManager; import codechicken.nei.guihook.GuiContainerManager;
import codechicken.nei.guihook.IContainerTooltipHandler;
import codechicken.nei.recipe.GuiCraftingRecipe; import codechicken.nei.recipe.GuiCraftingRecipe;
import codechicken.nei.recipe.GuiRecipeTab; import codechicken.nei.recipe.GuiRecipeTab;
import codechicken.nei.recipe.ICraftingHandler; import codechicken.nei.recipe.ICraftingHandler;
@@ -48,15 +44,13 @@ import codechicken.nei.recipe.StackInfo;
import codechicken.nei.util.NBTJson; import codechicken.nei.util.NBTJson;
import codechicken.nei.util.NEIMouseUtils; import codechicken.nei.util.NEIMouseUtils;
public class SubsetWidget extends Button implements ItemFilterProvider, IContainerTooltipHandler { public class SubsetWidget extends Button implements ItemFilterProvider {
protected static final int SLOT_HEIGHT = 18; protected static final int SLOT_HEIGHT = 18;
protected static final int MARGIN = 2; protected static final int MARGIN = 2;
protected static final char PREFIX = '%'; protected static final char PREFIX = '%';
protected static ReentrantReadWriteLock hiddenItemLock = new ReentrantReadWriteLock(); private static final Object hiddenLock = new Object();
protected static Lock hiddenWriteLock = hiddenItemLock.writeLock();
protected static Lock hiddenReadLock = hiddenItemLock.readLock();
public static class SubsetTag { public static class SubsetTag {
@@ -166,7 +160,7 @@ public class SubsetWidget extends Button implements ItemFilterProvider, IContain
// 1 - partitial hidden // 1 - partitial hidden
// 2 - enabled // 2 - enabled
public int state = 2; public int state = 2;
public int calculatedWidth; public volatile int calculatedWidth = -1;
public final List<ItemStack> items; public final List<ItemStack> items;
public final List<SubsetTag> children = new ArrayList<>(); public final List<SubsetTag> children = new ArrayList<>();
protected final SubsetSlot slot = new SubsetSlot(); protected final SubsetSlot slot = new SubsetSlot();
@@ -199,7 +193,7 @@ public class SubsetWidget extends Button implements ItemFilterProvider, IContain
} }
public String name() { public String name() {
int idx = this.fullname.indexOf('.'); int idx = this.fullname.lastIndexOf('.');
return idx < 0 ? this.fullname : this.fullname.substring(idx + 1); return idx < 0 ? this.fullname : this.fullname.substring(idx + 1);
} }
@@ -212,7 +206,7 @@ public class SubsetWidget extends Button implements ItemFilterProvider, IContain
this.state = 2; this.state = 2;
this.items.clear(); this.items.clear();
this.children.clear(); this.children.clear();
this.calculatedWidth = 0; this.calculatedWidth = -1;
} }
public void updateVisiblity(int mx, int my) { public void updateVisiblity(int mx, int my) {
@@ -267,6 +261,10 @@ public class SubsetWidget extends Button implements ItemFilterProvider, IContain
} }
public void resize(Rectangle4i screen, Rectangle4i parent, boolean dropRight) { public void resize(Rectangle4i screen, Rectangle4i parent, boolean dropRight) {
if (calculatedWidth < 0) {
calculatedWidth = this.children.stream().mapToInt(SubsetTag::nameWidth).max().orElse(0);
}
int height = Math.min(slot.contentHeight(), screen.h); int height = Math.min(slot.contentHeight(), screen.h);
int width = Math.max(calculatedWidth + 2, this.items.isEmpty() ? 0 : 16 + MARGIN * 2); int width = Math.max(calculatedWidth + 2, this.items.isEmpty() ? 0 : 16 + MARGIN * 2);
int scrollbarWidth = slot.scrollbarDim().width; int scrollbarWidth = slot.scrollbarDim().width;
@@ -369,14 +367,27 @@ public class SubsetWidget extends Button implements ItemFilterProvider, IContain
private static class DefaultParserProvider implements ISearchParserProvider { private static class DefaultParserProvider implements ISearchParserProvider {
public ItemFilter getFilter(String searchText) { public ItemFilter getFilter(String searchText) {
final String pathPart = searchText.replaceAll("\\s+", "").toLowerCase(); final int patternMode = NEIClientConfig.getIntSetting("inventory.search.patternMode");
Pattern pattern = null;
if (patternMode != 3) {
searchText = searchText.replaceAll("\\s+", "").toLowerCase();
} else {
pattern = SearchField.getPattern(searchText, patternMode);
}
final AnyMultiItemFilter filter = new AnyMultiItemFilter(); final AnyMultiItemFilter filter = new AnyMultiItemFilter();
final Set<ItemStack> filteredItems = new HashSet<>(); final Set<ItemStack> filteredItems = new HashSet<>();
final List<SubsetTag> snapshot;
for (SubsetTag tag : tags.values()) { synchronized (tags) {
if (tag.filter != null && tag.path.contains(pathPart)) { snapshot = new ArrayList<>(tags.values());
filteredItems.addAll(tag.items); }
filter.filters.add(tag.filter);
for (SubsetTag tag : snapshot) {
if (tag.filter != null && matches(tag.path, searchText, pattern)) {
synchronized (tag.items) {
filteredItems.addAll(tag.items);
filter.filters.add(tag.filter);
}
} }
} }
@@ -392,15 +403,25 @@ public class SubsetWidget extends Button implements ItemFilterProvider, IContain
} }
@Override @Override
public SearchMode getSearchMode() { public String getName() {
return SearchMode.fromInt(NEIClientConfig.getIntSetting("inventory.search.subsetsSearchMode")); return "subsets";
}
private boolean matches(String name, String searchText, Pattern pattern) {
if (pattern != null) {
return pattern.matcher(name).find();
} else {
return name.contains(searchText);
}
} }
} }
/** /**
* All operations on this variable should be synchronised. * Canonical {@link StackInfo#getItemStackGUID(ItemStack)} of every hidden item, stored by GUID so the state
* survives world reloads. All operations should be synchronised.
*/ */
private static final ItemStackSet hiddenItems = new ItemStackSet(); private static final Set<String> hiddenItems = new HashSet<>();
private static final Map<String, SubsetTag> tags = new HashMap<>(); private static final Map<String, SubsetTag> tags = new HashMap<>();
private static final SubsetTag root = new SubsetTag(""); private static final SubsetTag root = new SubsetTag("");
protected static boolean enableSearchBySubsets = false; protected static boolean enableSearchBySubsets = false;
@@ -423,24 +444,31 @@ public class SubsetWidget extends Button implements ItemFilterProvider, IContain
} }
updateHiddenItems(); updateHiddenItems();
SearchField.searchParser.clearCache();
}
}
public static void removeTag(String path) {
updateState.stop();
synchronized (tags) {
tags.keySet().removeIf(
parentpath -> parentpath.equals(path.toLowerCase())
|| parentpath.startsWith(path.toLowerCase() + "."));
updateHiddenItems();
SearchField.searchParser.clearCache();
} }
} }
public static boolean isHidden(ItemStack item) { public static boolean isHidden(ItemStack item) {
try { final String guid = StackInfo.getItemStackGUID(item);
if (hiddenReadLock.tryLock(5, TimeUnit.SECONDS)) { synchronized (hiddenLock) {
try { return hiddenItems.contains(guid);
return hiddenItems.contains(item);
} finally {
hiddenReadLock.unlock();
}
} else {
NEIClientConfig.logger.error("Unable to obtain read lock in 'isHidden'");
}
} catch (InterruptedException e) {
e.printStackTrace();
} }
return false; }
private static List<String> toGUIDs(List<ItemStack> items) {
return items.stream().map(StackInfo::getItemStackGUID).collect(Collectors.toList());
} }
private static List<ItemStack> getItems(SubsetTag tag, List<ItemStack> items) { private static List<ItemStack> getItems(SubsetTag tag, List<ItemStack> items) {
@@ -454,90 +482,50 @@ public class SubsetWidget extends Button implements ItemFilterProvider, IContain
} }
public static void showOnly(SubsetTag tag) { public static void showOnly(SubsetTag tag) {
try { final List<String> allItems = toGUIDs(getItems(root, new ArrayList<>()));
if (hiddenWriteLock.tryLock(5, TimeUnit.SECONDS)) { final List<String> tagItems = toGUIDs(getItems(tag, new ArrayList<>()));
try {
hiddenItems.clear();
hiddenItems.addAll(getItems(root, new ArrayList<>()));
hiddenItems.removeAll(getItems(tag, new ArrayList<>()));
} finally {
hiddenWriteLock.unlock();
}
} else {
NEIClientConfig.logger.error("Unable to obtain write lock in 'showOnly'");
}
calculateVisibility(); synchronized (hiddenLock) {
} catch (InterruptedException e) { hiddenItems.clear();
e.printStackTrace(); hiddenItems.addAll(allItems);
hiddenItems.removeAll(tagItems);
} }
calculateVisibility();
} }
public static void setHidden(SubsetTag tag, boolean hidden) { public static void setHidden(SubsetTag tag, boolean hidden) {
try { final List<String> tagItems = toGUIDs(getItems(tag, new ArrayList<>()));
if (hiddenWriteLock.tryLock(5, TimeUnit.SECONDS)) {
try {
List<ItemStack> tagItems = getItems(tag, new ArrayList<>());
if (hidden) { synchronized (hiddenLock) {
hiddenItems.addAll(tagItems); if (hidden) {
} else { hiddenItems.addAll(tagItems);
hiddenItems.removeAll(tagItems);
}
} finally {
hiddenWriteLock.unlock();
}
} else { } else {
NEIClientConfig.logger.error("Unable to obtain write lock in 'setHidden'"); hiddenItems.removeAll(tagItems);
} }
calculateVisibility();
} catch (InterruptedException e) {
e.printStackTrace();
} }
calculateVisibility();
} }
public static void setHidden(ItemStack item, boolean hidden) { public static void setHidden(ItemStack item, boolean hidden) {
try { final String guid = StackInfo.getItemStackGUID(item);
if (hiddenWriteLock.tryLock(5, TimeUnit.SECONDS)) {
try {
if (hidden) { synchronized (hiddenLock) {
hiddenItems.add(item); if (hidden) {
} else { hiddenItems.add(guid);
hiddenItems.remove(item);
}
} finally {
hiddenWriteLock.unlock();
}
} else { } else {
NEIClientConfig.logger.error("Unable to obtain write lock in 'setHidden'"); hiddenItems.remove(guid);
} }
calculateVisibility();
} catch (InterruptedException e) {
e.printStackTrace();
} }
calculateVisibility();
} }
public static void unhideAll() { public static void unhideAll() {
try { synchronized (hiddenLock) {
if (hiddenWriteLock.tryLock(5, TimeUnit.SECONDS)) { hiddenItems.clear();
try {
hiddenItems.clear();
} finally {
hiddenWriteLock.unlock();
}
} else {
NEIClientConfig.logger.error("Unable to obtain write lock in 'unhideAll'");
}
calculateVisibility();
} catch (InterruptedException e) {
e.printStackTrace();
} }
calculateVisibility();
} }
public static void updateHiddenItems() { public static void updateHiddenItems() {
@@ -609,42 +597,43 @@ public class SubsetWidget extends Button implements ItemFilterProvider, IContain
} }
public static void loadHidden() { public static void loadHidden() {
final List<ItemStack> itemList = new LinkedList<>(); final Set<String> guids = new HashSet<>();
try { try {
final NBTTagList guidList = NEIClientConfig.world.nbt.getTagList("hiddenItems", 8);
for (int i = 0; i < guidList.tagCount(); i++) {
guids.add(guidList.getStringTagAt(i));
}
final NBTTagList list = NEIClientConfig.world.nbt.getTagList("hiddenItems", 10); final NBTTagList list = NEIClientConfig.world.nbt.getTagList("hiddenItems", 10);
for (int i = 0; i < list.tagCount(); i++) { for (int i = 0; i < list.tagCount(); i++) {
itemList.add(ItemStack.loadItemStackFromNBT(list.getCompoundTagAt(i))); final ItemStack stack = ItemStack.loadItemStackFromNBT(list.getCompoundTagAt(i));
if (stack != null) {
guids.add(StackInfo.getItemStackGUID(stack));
}
} }
} catch (Exception e) { } catch (Exception e) {
NEIClientConfig.logger.error("Error loading hiddenItems", e); NEIClientConfig.logger.error("Error loading hiddenItems", e);
return; return;
} }
try { synchronized (hiddenLock) {
if (hiddenWriteLock.tryLock(5, TimeUnit.SECONDS)) { hiddenItems.clear();
try { hiddenItems.addAll(guids);
hiddenItems.clear();
hiddenItems.addAll(itemList);
} finally {
hiddenWriteLock.unlock();
}
} else {
NEIClientConfig.logger.error("Unable to obtain second write lock in 'loadHidden'");
}
} catch (InterruptedException e) {
e.printStackTrace();
} }
} }
public static void saveHidden() { public static void saveHidden() {
if (NEIClientConfig.world == null) return; if (NEIClientConfig.world == null) return;
final NBTTagList list = new NBTTagList(); final NBTTagList list = new NBTTagList();
for (ItemStack stack : hiddenItems.values()) { synchronized (hiddenLock) {
list.appendTag(stack.writeToNBT(new NBTTagCompound())); for (String guid : hiddenItems) {
list.appendTag(new NBTTagString(guid));
}
} }
NEIClientConfig.world.nbt.setTag("hiddenItems", list); NEIClientConfig.world.nbt.setTag("hiddenItems", list);
@@ -662,14 +651,22 @@ public class SubsetWidget extends Button implements ItemFilterProvider, IContain
public void execute() { public void execute() {
try { try {
final List<SubsetTag> list = new ArrayList<>(tags.values()); final List<SubsetTag> list;
synchronized (tags) {
list = new ArrayList<>(tags.values());
}
root.clearCache(); root.clearCache();
list.parallelStream().forEach(tag -> { list.parallelStream().forEach(tag -> {
tag.clearCache(); tag.clearCache();
ItemList.items.stream().filter(tag.filter::matches)
.collect(Collectors.toCollection(() -> tag.items)); if (!(tag.filter instanceof NothingItemFilter)) {
ItemList.items.stream().filter(tag.filter::matches)
.collect(Collectors.toCollection(() -> tag.items));
}
}); });
for (SubsetTag tag : list) { for (SubsetTag tag : list) {
@@ -693,18 +690,19 @@ public class SubsetWidget extends Button implements ItemFilterProvider, IContain
for (SubsetTag tag : list) { for (SubsetTag tag : list) {
tag.children.sort(Comparator.comparing(SubsetTag::displayName)); tag.children.sort(Comparator.comparing(SubsetTag::displayName));
tag.calculatedWidth = tag.children.stream().mapToInt(SubsetTag::nameWidth).max().orElse(0); tag.calculatedWidth = -1;
} }
root.children.removeIf(child -> child.children.isEmpty() && child.items.isEmpty()); root.children.removeIf(child -> child.children.isEmpty() && child.items.isEmpty());
root.children.sort(Comparator.comparing(SubsetTag::displayName)); root.children.sort(Comparator.comparing(SubsetTag::displayName));
root.calculatedWidth = root.children.stream().mapToInt(SubsetTag::nameWidth).max().orElse(0); root.calculatedWidth = -1;
calculateVisibility(root); calculateVisibility(root);
} catch (Throwable e) { } catch (Throwable e) {
e.printStackTrace(); e.printStackTrace();
} }
SearchField.searchParser.clearCache();
} }
} }
@@ -716,15 +714,17 @@ public class SubsetWidget extends Button implements ItemFilterProvider, IContain
} }
@Override @Override
public String getRenderLabel() { public int getRenderLabelColor() {
return NEIClientConfig.subsetWidgetOnTop() ? 0 : ColorUtils.subsetWidget.getColor();
}
@Override
public String getRenderLabel() {
if (NEIClientConfig.subsetWidgetOnTop()) { if (NEIClientConfig.subsetWidgetOnTop()) {
return NEIClientUtils.translate("inventory.item_subsets"); return NEIClientUtils.translate("inventory.item_subsets");
} else { } else {
return EnumChatFormatting.DARK_PURPLE + String.valueOf(SearchField.searchParser.getRedefinedPrefix(PREFIX)) return String.valueOf(SearchField.searchParser.getRedefinedPrefix(PREFIX));
+ EnumChatFormatting.RESET;
} }
} }
@Override @Override
@@ -762,7 +762,7 @@ public class SubsetWidget extends Button implements ItemFilterProvider, IContain
root.resize(screen, parent, dropRight); root.resize(screen, parent, dropRight);
GL11.glPushAttrib(GL11.GL_ALL_ATTRIB_BITS); GL11.glPushAttrib(GL11.GL_ENABLE_BIT | GL11.GL_COLOR_BUFFER_BIT | GL11.GL_LIGHTING_BIT);
GuiContainerManager.enable2DRender(); GuiContainerManager.enable2DRender();
GuiContainerManager.drawItems.zLevel += 100; GuiContainerManager.drawItems.zLevel += 100;
@@ -913,7 +913,7 @@ public class SubsetWidget extends Button implements ItemFilterProvider, IContain
} }
@Override @Override
public Map<String, String> handleHotkeys(GuiContainer gui, int mousex, int mousey, Map<String, String> hotkeys) { public Map<String, String> handleHotkeys(int mousex, int mousey, Map<String, String> hotkeys) {
if (SubsetWidget.hoverStack != null) { if (SubsetWidget.hoverStack != null) {
+1 -1
View File
@@ -89,7 +89,7 @@ public abstract class TextField extends Widget {
onTextChange(oldText); onTextChange(oldText);
} }
return handled; return handled || keyID == Keyboard.KEY_SPACE;
} }
public abstract void onTextChange(String oldText); public abstract void onTextChange(String oldText);
+22 -2
View File
@@ -1,6 +1,7 @@
package codechicken.nei; package codechicken.nei;
import java.util.List; import java.util.List;
import java.util.Map;
import net.minecraft.item.ItemStack; import net.minecraft.item.ItemStack;
@@ -14,8 +15,6 @@ public abstract class Widget {
public void postDraw(int mx, int my) {} public void postDraw(int mx, int my) {}
public void postDrawTooltips(int mx, int my, List<String> tooltip) {}
public boolean handleClick(int mx, int my, int button) { public boolean handleClick(int mx, int my, int button) {
return true; return true;
} }
@@ -30,6 +29,10 @@ public abstract class Widget {
public void lastKeyTyped(int keyID, char keyChar) {} public void lastKeyTyped(int keyID, char keyChar) {}
public boolean onHotkeyPressed() {
return false;
}
public boolean handleClickExt(int mx, int my, int button) { public boolean handleClickExt(int mx, int my, int button) {
return false; return false;
} }
@@ -38,6 +41,10 @@ public abstract class Widget {
return false; return false;
} }
public Map<String, String> handleHotkeys(int mousex, int mousey, Map<String, String> hotkeys) {
return hotkeys;
}
public void update() {} public void update() {}
public Rectangle4i bounds() { public Rectangle4i bounds() {
@@ -48,6 +55,10 @@ public abstract class Widget {
return bounds().contains(px, py); return bounds().contains(px, py);
} }
public boolean isVisible() {
return true;
}
public ItemStack getStackMouseOver(int mx, int my) { public ItemStack getStackMouseOver(int mx, int my) {
return null; return null;
} }
@@ -58,6 +69,14 @@ public abstract class Widget {
return tooltip; return tooltip;
} }
public List<String> handleItemTooltip(ItemStack itemstack, int mousex, int mousey, List<String> tooltip) {
return tooltip;
}
public boolean isFocused() {
return false;
}
public void loseFocus() {} public void loseFocus() {}
public void gainFocus() {} public void gainFocus() {}
@@ -67,4 +86,5 @@ public abstract class Widget {
public int z; public int z;
public int w; public int w;
public int h; public int h;
} }
@@ -0,0 +1,279 @@
package codechicken.nei;
import java.awt.Point;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.function.Predicate;
import net.minecraft.item.ItemStack;
import codechicken.lib.gui.GuiDraw;
import codechicken.lib.vec.Rectangle4i;
public class WidgetContainer extends Widget {
protected final List<Widget> widgets = new ArrayList<>();
protected boolean isFocused = false;
public void addWidget(Widget widget) {
this.widgets.add(widget);
}
public void setWidgets(List<Widget> widgets) {
final boolean isFocused = this.isFocused;
clear();
loseFocus();
for (Widget widget : widgets) {
addWidget(widget);
}
this.isFocused = isFocused;
}
public void clear() {
this.widgets.clear();
this.isFocused = false;
}
public List<Widget> getWidgets() {
return Collections.unmodifiableList(this.widgets);
}
public boolean removeIf(Predicate<Widget> filter) {
return this.widgets.removeIf(filter);
}
@Override
public void draw(int mousex, int mousey) {
drawWidgets(mousex, mousey);
}
protected void drawWidgets(int mousex, int mousey) {
final Rectangle4i bounds = bounds();
for (Widget widget : this.widgets) {
if (widget.isVisible() && widget.bounds().intersects(bounds)) {
widget.draw(mousex, mousey);
}
}
}
@Override
public void update() {
for (Widget widget : this.widgets) {
widget.update();
}
Collections.sort(this.widgets, Comparator.comparingInt((Widget widget) -> widget.z));
}
public Widget getWidgetUnderMouse(int mousex, int mousey) {
if (!bounds().contains(mousex, mousey)) {
return null;
}
for (int index = this.widgets.size() - 1; index >= 0; index--) {
final Widget widget = this.widgets.get(index);
if (widget.isVisible() && widget.contains(mousex, mousey)) {
return widget;
}
}
return null;
}
@Override
public boolean onMouseWheel(int scroll, int mousex, int mousey) {
final Widget widget = getWidgetUnderMouse(mousex, mousey);
return widget != null && widget.onMouseWheel(scroll, mousex, mousey);
}
@Override
public boolean handleClick(int mousex, int mousey, int button) {
if (contains(mousex, mousey)) {
gainFocus();
}
final Widget widget = getWidgetUnderMouse(mousex, mousey);
return widget != null && widget.handleClick(mousex, mousey, button);
}
@Override
public boolean handleClickExt(int mousex, int mousey, int button) {
loseFocus();
for (int index = this.widgets.size() - 1; index >= 0; index--) {
final Widget widget = this.widgets.get(index);
if (widget.isVisible() && !widget.contains(mousex, mousey)
&& widget.handleClickExt(mousex, mousey, button)) {
return true;
}
}
return false;
}
@Override
public void mouseDragged(int mousex, int mousey, int button, long heldTime) {
for (int index = this.widgets.size() - 1; index >= 0; index--) {
final Widget widget = this.widgets.get(index);
if (widget.isVisible()) widget.mouseDragged(mousex, mousey, button, heldTime);
}
}
@Override
public void mouseUp(int mousex, int mousey, int button) {
for (int index = this.widgets.size() - 1; index >= 0; index--) {
final Widget widget = this.widgets.get(index);
if (widget.isVisible()) widget.mouseUp(mousex, mousey, button);
}
}
@Override
public boolean handleKeyPress(int keyCode, char keyChar) {
for (int index = this.widgets.size() - 1; index >= 0; index--) {
final Widget widget = this.widgets.get(index);
if (widget.isVisible() && widget.handleKeyPress(keyCode, keyChar)) {
return true;
}
}
return false;
}
@Override
public void lastKeyTyped(int keyID, char keyChar) {
for (int index = this.widgets.size() - 1; index >= 0; index--) {
final Widget widget = this.widgets.get(index);
if (widget.isVisible()) widget.lastKeyTyped(keyID, keyChar);
}
}
@Override
public boolean onHotkeyPressed() {
for (int index = this.widgets.size() - 1; index >= 0; index--) {
final Widget widget = this.widgets.get(index);
if (widget.onHotkeyPressed()) {
return true;
}
}
return false;
}
@Override
public boolean isFocused() {
return this.isFocused;
}
@Override
public void loseFocus() {
for (int index = this.widgets.size() - 1; index >= 0; index--) {
final Widget widget = this.widgets.get(index);
if (widget.isFocused()) {
widget.loseFocus();
}
}
this.isFocused = false;
}
@Override
public void gainFocus() {
final Point mouse = GuiDraw.getMousePosition();
final Widget widget = getWidgetUnderMouse(mouse.x, mouse.y);
if (widget != null) {
if (!widget.isFocused()) {
loseFocus();
widget.gainFocus();
}
} else {
loseFocus();
}
this.isFocused = true;
}
@Override
public ItemStack getStackMouseOver(int mousex, int mousey) {
final Widget widget = getWidgetUnderMouse(mousex, mousey);
if (widget != null) {
return widget.getStackMouseOver(mousex, mousey);
}
return null;
}
@Override
public void postDraw(int mousex, int mousey) {
for (Widget widget : this.widgets) {
if (widget.isVisible()) widget.postDraw(mousex, mousey);
}
}
@Override
public void onGuiClick(int mousex, int mousey) {
for (int index = this.widgets.size() - 1; index >= 0; index--) {
final Widget widget = this.widgets.get(index);
if (widget.isVisible()) widget.onGuiClick(mousex, mousey);
}
}
@Override
public List<String> handleTooltip(int mousex, int mousey, List<String> tooltip) {
final Widget widget = getWidgetUnderMouse(mousex, mousey);
if (widget != null) {
return widget.handleTooltip(mousex, mousey, tooltip);
}
return tooltip;
}
@Override
public List<String> handleItemTooltip(ItemStack itemstack, int mousex, int mousey, List<String> tooltip) {
final Widget widget = getWidgetUnderMouse(mousex, mousey);
if (widget != null) {
return widget.handleItemTooltip(itemstack, mousex, mousey, tooltip);
}
return tooltip;
}
@Override
public Map<String, String> handleHotkeys(int mousex, int mousey, Map<String, String> hotkeys) {
final Widget widget = getWidgetUnderMouse(mousex, mousey);
if (widget != null) {
return widget.handleHotkeys(mousex, mousey, hotkeys);
}
return hotkeys;
}
}
@@ -1,22 +1,25 @@
package codechicken.nei; package codechicken.nei;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.concurrent.Callable;
import net.minecraft.client.Minecraft; import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.Tessellator; import net.minecraft.client.renderer.Tessellator;
import net.minecraft.entity.Entity; import net.minecraft.entity.Entity;
import net.minecraft.entity.EnumCreatureType;
import net.minecraft.entity.passive.EntityPig;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.util.ChatComponentText; import net.minecraft.util.ChatComponentText;
import net.minecraft.world.EnumSkyBlock; import net.minecraft.util.ResourceLocation;
import net.minecraft.world.SpawnerAnimals;
import net.minecraft.world.World; import net.minecraft.world.World;
import net.minecraft.world.biome.BiomeGenBase;
import net.minecraft.world.chunk.Chunk;
import org.lwjgl.opengl.GL11; import org.lwjgl.opengl.GL11;
import codechicken.lib.math.MathHelper; import com.cardinalstar.cubicchunks.world.api.IMinMaxHeight;
import codechicken.nei.KeyManager.IKeyStateTracker; import codechicken.nei.KeyManager.IKeyStateTracker;
import codechicken.nei.moboverlay.MobOverlayDisplayList;
import codechicken.nei.moboverlay.MobOverlayFace;
import codechicken.nei.moboverlay.MobOverlayScan;
import codechicken.nei.moboverlay.MobOverlayStyle;
import cpw.mods.fml.relauncher.ReflectionHelper; import cpw.mods.fml.relauncher.ReflectionHelper;
public class WorldOverlayRenderer implements IKeyStateTracker { public class WorldOverlayRenderer implements IKeyStateTracker {
@@ -24,22 +27,31 @@ public class WorldOverlayRenderer implements IKeyStateTracker {
public static int chunkOverlay = 0; public static int chunkOverlay = 0;
public static int mobOverlay = 0; public static int mobOverlay = 0;
private static byte[] mobSpawnCache; private static final MobOverlayScan MOB_OVERLAY_SCAN = new MobOverlayScan();
private static long mobOverlayUpdateTime; private static final MobOverlayFace MARKED_FACE = new MobOverlayFace();
private static String oregenPatternName; private static final MobOverlayDisplayList MOB_OVERLAY_LIST = new MobOverlayDisplayList();
public static void reset() { public static void reset() {
mobOverlay = 0; mobOverlay = 0;
chunkOverlay = 0; chunkOverlay = 0;
oregenPatternName = null; }
public static void onWorldUnload() {
MOB_OVERLAY_SCAN.clear();
MOB_OVERLAY_LIST.delete();
} }
@Override @Override
public void tickKeyStates() { public void tickKeyStates() {
if (Minecraft.getMinecraft().currentScreen != null) return; if (Minecraft.getMinecraft().currentScreen != null) return;
if (KeyManager.keyStates.get("world.moboverlay").down) mobOverlay = (mobOverlay + 1) % 2; if (KeyManager.isPressed("world.moboverlay")) {
if (KeyManager.keyStates.get("world.chunkoverlay").down) { mobOverlay = (mobOverlay + 1) % 2;
NEIClientUtils
.printChatMessage(new ChatComponentText(NEIClientUtils.translate("chat.moboverlay." + mobOverlay)));
}
if (KeyManager.isPressed("world.chunkoverlay")) {
chunkOverlay = (chunkOverlay + 1) % (NEIModContainer.isGT5Loaded() ? 4 : 3); chunkOverlay = (chunkOverlay + 1) % (NEIModContainer.isGT5Loaded() ? 4 : 3);
// 0-2 (or 3 with gt) // 0-2 (or 3 with gt)
NEIClientUtils.printChatMessage( NEIClientUtils.printChatMessage(
@@ -49,6 +61,7 @@ public class WorldOverlayRenderer implements IKeyStateTracker {
} }
public static void render(float frame) { public static void render(float frame) {
GL11.glPushAttrib(GL11.GL_ENABLE_BIT | GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT | GL11.GL_LINE_BIT);
GL11.glPushMatrix(); GL11.glPushMatrix();
Entity entity = Minecraft.getMinecraft().renderViewEntity; Entity entity = Minecraft.getMinecraft().renderViewEntity;
@@ -62,143 +75,111 @@ public class WorldOverlayRenderer implements IKeyStateTracker {
GL11.glTranslated(-interpPosX + intOffsetX, -interpPosY + intOffsetY, -interpPosZ + intOffsetZ); GL11.glTranslated(-interpPosX + intOffsetX, -interpPosY + intOffsetY, -interpPosZ + intOffsetZ);
GL11.glEnable(GL11.GL_DEPTH_TEST);
GL11.glDepthFunc(GL11.GL_LEQUAL);
renderChunkBounds(entity, intOffsetX, intOffsetY, intOffsetZ); renderChunkBounds(entity, intOffsetX, intOffsetY, intOffsetZ);
renderMobSpawnOverlay(entity, intOffsetX, intOffsetY, intOffsetZ); renderMobSpawnOverlay(entity, intOffsetX, intOffsetY, intOffsetZ);
GL11.glPopMatrix(); GL11.glPopMatrix();
GL11.glPopAttrib();
} }
private static void buildMobSpawnOverlay(Entity entity) { /**
if (mobSpawnCache == null) { * The model view matrix is relative to ({@code intOffsetX}, {@code intOffsetY}, {@code intOffsetZ}), the camera
mobSpawnCache = new byte[33 * 33 * 33]; // 35kB * position cast to {@code int}.
} */
World world = entity.worldObj;
int x1 = (int) entity.posX;
int z1 = (int) entity.posZ;
int y1 = (int) MathHelper.clip(entity.posY, 16, world.getHeight() - 16);
for (int i = 0; i <= 32; i++) {
int x = x1 - 16 + i;
for (int j = 0; j <= 32; j++) {
int z = z1 - 16 + j;
int bufIndex = (i * 33 + j) * 33;
Chunk chunk = world.getChunkFromBlockCoords(x, z);
BiomeGenBase biome = world.getBiomeGenForCoords(x, z);
if (biome.getSpawnableList(EnumCreatureType.monster).isEmpty() || biome.getSpawningChance() <= 0) {
mobSpawnCache[bufIndex] = -1;
continue;
}
int maxHeight = chunk.worldObj.getHeightValue(x, z);
for (int k = 0; k <= 32; k++) {
int y = y1 - 16 + k;
if (y > maxHeight) {
mobSpawnCache[bufIndex + k] = -1;
break;
}
mobSpawnCache[bufIndex + k] = getSpawnMode(chunk, x, y, z);
}
}
}
}
private static void renderMobSpawnOverlay(Entity entity, int intOffsetX, int intOffsetY, int intOffsetZ) { private static void renderMobSpawnOverlay(Entity entity, int intOffsetX, int intOffsetY, int intOffsetZ) {
if (mobOverlay == 0) { if (mobOverlay == 0) {
if (mobSpawnCache != null) { MOB_OVERLAY_SCAN.clear();
mobSpawnCache = null; MOB_OVERLAY_LIST.delete();
}
return; return;
} }
long worldTime = entity.worldObj.getTotalWorldTime(); MOB_OVERLAY_SCAN.update(
if (mobSpawnCache == null || mobOverlayUpdateTime != worldTime) { entity,
mobOverlayUpdateTime = worldTime; NEIClientConfig.getIntSetting("world.overlays.mobOverlayRadius"),
buildMobSpawnOverlay(entity); NEIClientConfig.getIntSetting("world.overlays.mobOverlayVerticalRadius"));
final MobOverlayStyle style = MobOverlayStyle
.parseStyle(NEIClientConfig.getSetting("world.overlays.mobOverlayStyle").getValue());
final long worldTicks = entity.worldObj.getTotalWorldTime();
if (MOB_OVERLAY_LIST.isCompileDue(MOB_OVERLAY_SCAN.getModesVersion(), style, worldTicks)) {
compileMobOverlayList(style, worldTicks);
} }
GL11.glDisable(GL11.GL_TEXTURE_2D); beginMobOverlayDraw(style);
MOB_OVERLAY_LIST.draw(intOffsetX, intOffsetY, intOffsetZ);
endMobOverlayDraw();
}
/**
* Add a marked face to {@link #MOB_OVERLAY_LIST} for each block of {@link #MOB_OVERLAY_SCAN} where mobs can spawn.
*/
private static void compileMobOverlayList(MobOverlayStyle style, long worldTicks) {
MOB_OVERLAY_LIST.beginCompile(MOB_OVERLAY_SCAN, style, worldTicks);
final float alpha = style.computeAlpha();
final Tessellator tess = Tessellator.instance;
tess.startDrawing(style.glMode);
final int span = MOB_OVERLAY_SCAN.getSpan();
for (int i = 0; i < span; i++) {
for (int j = 0; j < span; j++) {
for (int k = 0; k < MOB_OVERLAY_SCAN.getHeight(); k++) {
if (MOB_OVERLAY_SCAN.readSpawnMode(i, k, j) == 0) continue;
MARKED_FACE.moveTo(i, k + MOB_OVERLAY_SCAN.readOverlayYOffset(i, k, j), j);
loadNeighbourModes(i, k, j);
MARKED_FACE.applyColor(style.colouring, alpha);
style.addVertices(MARKED_FACE);
}
}
}
tess.draw();
MOB_OVERLAY_LIST.endCompile();
}
private static void beginMobOverlayDraw(MobOverlayStyle style) {
final ResourceLocation texture = style.texture;
if (texture == null) {
GL11.glDisable(GL11.GL_TEXTURE_2D);
} else {
GL11.glEnable(GL11.GL_TEXTURE_2D);
Minecraft.getMinecraft().getTextureManager().bindTexture(texture);
}
GL11.glEnable(GL11.GL_BLEND); GL11.glEnable(GL11.GL_BLEND);
GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA); GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
GL11.glDisable(GL11.GL_LIGHTING); GL11.glDisable(GL11.GL_LIGHTING);
GL11.glLineWidth(1.5F); GL11.glLineWidth(1.5F);
// the outline of `MobOverlayStyle.CONNECTED` lies in the plane of the tint. With depth writes on, the depth
// test discards most of the outline
GL11.glDepthMask(false);
}
int curSpawnMode = 2; private static void loadNeighbourModes(int i, int k, int j) {
final int span = MOB_OVERLAY_SCAN.getSpan();
World world = entity.worldObj; for (int offsetX = -1; offsetX <= 1; offsetX++) {
int x1 = (int) entity.posX - intOffsetX; for (int offsetZ = -1; offsetZ <= 1; offsetZ++) {
int z1 = (int) entity.posZ - intOffsetZ; final int neighbourI = i + offsetX;
int y1 = (int) MathHelper.clip(entity.posY, 16, world.getHeight() - 16) - intOffsetY; final int neighbourJ = j + offsetZ;
final boolean isInScan = neighbourI >= 0 && neighbourI < span && neighbourJ >= 0 && neighbourJ < span;
final Tessellator tess = Tessellator.instance; final byte spawnMode = isInScan ? MOB_OVERLAY_SCAN.readSpawnMode(neighbourI, k, neighbourJ)
tess.startDrawing(GL11.GL_LINES); : MobOverlayFace.OUTSIDE_SCAN;
tess.setColorOpaque(255, 0, 0); MARKED_FACE.setNeighbourMode(offsetX, offsetZ, spawnMode);
for (int i = 0; i <= 32; i++) {
int x = x1 - 16 + i;
for (int j = 0; j <= 32; j++) {
int z = z1 - 16 + j;
int cacheIndex = (i * 33 + j) * 33;
for (int k = 0; k <= 32; k++) {
int y = y1 - 16 + k;
int spawnMode = mobSpawnCache[cacheIndex + k];
if (spawnMode == 0) {
continue;
} else if (spawnMode == -1) {
break;
}
if (spawnMode != curSpawnMode) {
if (spawnMode == 1) {
tess.setColorOpaque(255, 255, 0);
} else {
tess.setColorOpaque(255, 0, 0);
}
curSpawnMode = spawnMode;
}
tess.addVertex(x, y + 0.02, z);
tess.addVertex(x + 1, y + 0.02, z + 1);
tess.addVertex(x + 1, y + 0.02, z);
tess.addVertex(x, y + 0.02, z + 1);
}
} }
} }
}
tess.draw(); /** Undo the GL state changes of {@link #beginMobOverlayDraw}, except the texture binding. */
private static void endMobOverlayDraw() {
GL11.glDepthMask(true);
GL11.glEnable(GL11.GL_LIGHTING); GL11.glEnable(GL11.GL_LIGHTING);
GL11.glEnable(GL11.GL_TEXTURE_2D); GL11.glEnable(GL11.GL_TEXTURE_2D);
GL11.glDisable(GL11.GL_BLEND); GL11.glDisable(GL11.GL_BLEND);
} }
private static final Entity dummyEntity = new EntityPig(null);
private static final AxisAlignedBB aabb = AxisAlignedBB.getBoundingBox(0, 0, 0, 0, 0, 0);
private static byte getSpawnMode(Chunk chunk, int x, int y, int z) {
if (chunk.getSavedLightValue(EnumSkyBlock.Block, x & 15, y, z & 15) >= 8
|| !SpawnerAnimals.canCreatureTypeSpawnAtLocation(EnumCreatureType.monster, chunk.worldObj, x, y, z)) {
return 0;
}
aabb.minX = x + 0.2;
aabb.maxX = x + 0.8;
aabb.minY = y + 0.01;
aabb.maxY = y + 1.8;
aabb.minZ = z + 0.2;
aabb.maxZ = z + 0.8;
if (!chunk.worldObj.getCollidingBoundingBoxes(dummyEntity, aabb).isEmpty()
|| chunk.worldObj.isAnyLiquid(aabb)) {
return 0;
}
return (byte) (chunk.getSavedLightValue(EnumSkyBlock.Sky, x & 15, y, z & 15) >= 8 ? 1 : 2);
}
private static void renderChunkBounds(Entity entity, int intOffsetX, int intOffsetY, int intOffsetZ) { private static void renderChunkBounds(Entity entity, int intOffsetX, int intOffsetY, int intOffsetZ) {
if (chunkOverlay == 0) return; if (chunkOverlay == 0) return;
int worldMinY = worldMinHeight(entity.worldObj);
int worldMaxY = worldMaxHeight(entity.worldObj);
GL11.glDisable(GL11.GL_TEXTURE_2D); GL11.glDisable(GL11.GL_TEXTURE_2D);
GL11.glEnable(GL11.GL_BLEND); GL11.glEnable(GL11.GL_BLEND);
GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA); GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
@@ -217,14 +198,13 @@ public class WorldOverlayRenderer implements IKeyStateTracker {
double dy = 128; double dy = 128;
double y1 = Math.floor(entity.posY - dy / 2); double y1 = Math.floor(entity.posY - dy / 2);
double y2 = y1 + dy; double y2 = y1 + dy;
if (y1 < 0) { if (y1 < worldMinY) {
y1 = 0; y1 = worldMinY;
y2 = dy; y2 = worldMinY + dy;
} }
if (y2 > worldMaxY) {
if (y1 > entity.worldObj.getHeight()) { y2 = worldMaxY;
y2 = entity.worldObj.getHeight(); y1 = Math.max(worldMaxY - dy, worldMinY);
y1 = y2 - dy;
} }
y1 -= intOffsetY; y1 -= intOffsetY;
@@ -250,23 +230,44 @@ public class WorldOverlayRenderer implements IKeyStateTracker {
tess.addVertex(x1, y2, z1); tess.addVertex(x1, y2, z1);
} }
if (NEIModContainer.isCCLoaded()) {
tess.setColorRGBA_F(0, 0.5F, 0.9F, (float) dist * 0.5F);
int cubeBase = (int) Math.floor((y1 + intOffsetY) / 16.0) * 16;
for (int cubeY = cubeBase; cubeY <= y2 + intOffsetY; cubeY += 16) {
double ry = cubeY - intOffsetY;
tess.addVertex(x1, ry, z1);
tess.addVertex(x2, ry, z1);
tess.addVertex(x1, ry, z2);
tess.addVertex(x2, ry, z2);
tess.addVertex(x1, ry, z1);
tess.addVertex(x1, ry, z2);
tess.addVertex(x2, ry, z1);
tess.addVertex(x2, ry, z2);
}
}
if (cx == 0 && cz == 0) { if (cx == 0 && cz == 0) {
if (chunkOverlay == 2) { if (chunkOverlay == 2) {
dy = 32; dy = 32;
y1 = Math.floor(entity.posY - dy / 2); y1 = Math.floor(entity.posY - dy / 2);
y2 = y1 + dy; y2 = y1 + dy;
if (y1 < 0) { if (y1 < worldMinY) {
y1 = 0; y1 = worldMinY;
y2 = dy; y2 = worldMinY + dy;
} }
if (y2 > worldMaxY) {
if (y1 > entity.worldObj.getHeight()) { y2 = worldMaxY;
y2 = entity.worldObj.getHeight(); y1 = Math.max(worldMaxY - dy, worldMinY);
y1 = y2 - dy;
} }
y1 -= intOffsetY; y1 -= intOffsetY;
y2 -= intOffsetY; y2 -= intOffsetY;
double centerX = (x1 + x2) / 2;
double centerZ = (z1 + z2) / 2;
tess.setColorRGBA_F(0.9F, 0.9F, 0, (float) dist);
tess.addVertex(centerX, y1, centerZ);
tess.addVertex(centerX, y2, centerZ);
tess.setColorRGBA_F(0, 0.9F, 0, 0.4F); tess.setColorRGBA_F(0, 0.9F, 0, 0.4F);
for (double y = (int) y1; y <= y2; y++) { for (double y = (int) y1; y <= y2; y++) {
@@ -361,20 +362,55 @@ public class WorldOverlayRenderer implements IKeyStateTracker {
GL11.glDisable(GL11.GL_BLEND); GL11.glDisable(GL11.GL_BLEND);
} }
private static String getOregenPatternName() { private static int worldMinHeight(World world) {
if (NEIModContainer.isCCLoaded() && world instanceof IMinMaxHeight worldHeights) {
if (oregenPatternName == null) { return worldHeights.getMinHeight();
try { } else {
final ClassLoader loader = WorldOverlayRenderer.class.getClassLoader(); return 0;
final Class<?> gtWorldGenerator = ReflectionHelper
.getClass(loader, "gregtech.common.GTWorldgenerator", "gregtech.common.GT_Worldgenerator");
oregenPatternName = ((Enum<?>) gtWorldGenerator.getDeclaredField("oregenPattern").get(null)).name();
} catch (Exception ignored) {
oregenPatternName = "AXISSYMMETRICAL";
}
} }
}
return oregenPatternName; private static int worldMaxHeight(World world) {
if (NEIModContainer.isCCLoaded() && world instanceof IMinMaxHeight worldHeights) {
return worldHeights.getMaxHeight();
} else {
return world.getHeight();
}
}
private static Callable<String> oregenPatternReader;
private static String getOregenPatternName() {
if (oregenPatternReader == null) {
oregenPatternReader = resolveOregenPatternReader();
}
try {
return oregenPatternReader.call();
} catch (Exception ignored) {
return "AXISSYMMETRICAL";
}
}
private static Callable<String> resolveOregenPatternReader() {
try {
final Class<?> gtWorldGenerator = ReflectionHelper.getClass(
WorldOverlayRenderer.class.getClassLoader(),
"gregtech.common.GTWorldgenerator",
"gregtech.common.GT_Worldgenerator");
try {
// GT5-Unofficial >= 5.09.54.29 support
final Method accessor = gtWorldGenerator.getMethod("getOregenPattern");
return () -> ((Enum<?>) accessor.invoke(null)).name();
} catch (NoSuchMethodException legacy) {
// Older GT
final Field oregenPattern = gtWorldGenerator.getDeclaredField("oregenPattern");
oregenPattern.setAccessible(true);
return () -> ((Enum<?>) oregenPattern.get(null)).name();
}
} catch (Exception ignored) {
return () -> "AXISSYMMETRICAL";
}
} }
public static void load() { public static void load() {
+61 -15
View File
@@ -1,26 +1,29 @@
package codechicken.nei.api; package codechicken.nei.api;
import java.util.Arrays;
import java.util.Collections; import java.util.Collections;
import java.util.Comparator; import java.util.Comparator;
import java.util.List; import java.util.List;
import java.util.Objects; import java.util.Objects;
import java.util.stream.Collectors;
import net.minecraft.block.Block; import net.minecraft.block.Block;
import net.minecraft.client.gui.inventory.GuiContainer; import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.inventory.Slot; import net.minecraft.inventory.Slot;
import net.minecraft.item.Item; import net.minecraft.item.Item;
import net.minecraft.item.ItemStack; import net.minecraft.item.ItemStack;
import net.minecraftforge.fluids.Fluid;
import org.lwjgl.input.Keyboard; import org.lwjgl.input.Keyboard;
import com.google.common.collect.Sets; import com.google.common.collect.Sets;
import codechicken.nei.BookmarkContainerInfo; import codechicken.nei.BookmarkContainerInfo;
import codechicken.nei.CollapsibleItems;
import codechicken.nei.ItemList; import codechicken.nei.ItemList;
import codechicken.nei.ItemSorter; import codechicken.nei.ItemSorter;
import codechicken.nei.ItemStackSet; import codechicken.nei.ItemStackSet;
import codechicken.nei.KeyManager; import codechicken.nei.KeyManager;
import codechicken.nei.KeyManager.KeyState;
import codechicken.nei.LayoutManager; import codechicken.nei.LayoutManager;
import codechicken.nei.NEIClientConfig; import codechicken.nei.NEIClientConfig;
import codechicken.nei.OffsetPositioner; import codechicken.nei.OffsetPositioner;
@@ -32,7 +35,7 @@ import codechicken.nei.SubsetWidget.SubsetTag;
import codechicken.nei.api.IRecipeFilter.IRecipeFilterProvider; import codechicken.nei.api.IRecipeFilter.IRecipeFilterProvider;
import codechicken.nei.api.ItemFilter.ItemFilterProvider; import codechicken.nei.api.ItemFilter.ItemFilterProvider;
import codechicken.nei.config.Option; import codechicken.nei.config.Option;
import codechicken.nei.config.OptionKeyBind; import codechicken.nei.item.FluidDrawer;
import codechicken.nei.recipe.CatalystInfo; import codechicken.nei.recipe.CatalystInfo;
import codechicken.nei.recipe.GuiCraftingRecipe; import codechicken.nei.recipe.GuiCraftingRecipe;
import codechicken.nei.recipe.GuiRecipe; import codechicken.nei.recipe.GuiRecipe;
@@ -146,14 +149,14 @@ public class API {
* Hide an item from the item panel Damage values of OreDictionary.WILDCARD_VALUE and ItemStackMap.WILDCARD_TAG tags * Hide an item from the item panel Damage values of OreDictionary.WILDCARD_VALUE and ItemStackMap.WILDCARD_TAG tags
* function as wildcards for their respective variables * function as wildcards for their respective variables
*/ */
public static void hideItem(ItemStack item) { public static synchronized void hideItem(ItemStack item) {
if (!ItemInfo.hiddenItems.contains(item)) { if (!ItemInfo.hiddenItems.contains(item)) {
ItemInfo.hiddenItems.add(item); ItemInfo.hiddenItems.add(item);
LayoutManager.markItemsDirty(); LayoutManager.markItemsDirty();
} }
} }
public static void hideItem(String rule) { public static synchronized void hideItem(String rule) {
ItemFilter filter = ItemStackFilterParser.parse(rule); ItemFilter filter = ItemStackFilterParser.parse(rule);
if (filter != null) { if (filter != null) {
ItemInfo.hiddenItemsRules.filters.add(filter); ItemInfo.hiddenItemsRules.filters.add(filter);
@@ -176,6 +179,23 @@ public class API {
} }
} }
/**
* Add an alias name that this item can be found by in the search field, in addition to its display name.
*
* @param aliases translation keys, localized at search time
*/
public static void setAliases(ItemStack item, String... aliases) {
final List<String> list = Arrays.asList(aliases).stream().filter(Objects::nonNull).map(String::trim)
.filter(s -> !s.isEmpty()).collect(Collectors.toList());
if (list.isEmpty()) {
ItemInfo.itemAliases.remove(item);
} else {
ItemInfo.itemAliases.put(item, list);
}
}
/** /**
* Adds an item to the item panel. Any items added using this function will override the default search pattern. * Adds an item to the item panel. Any items added using this function will override the default search pattern.
* *
@@ -206,20 +226,12 @@ public class API {
* @param defaultKey The default value, commonly obtained from {@link Keyboard} * @param defaultKey The default value, commonly obtained from {@link Keyboard}
*/ */
public static void addKeyBind(String ident, int defaultKey) { public static void addKeyBind(String ident, int defaultKey) {
NEIClientConfig.setDefaultKeyBinding(ident, defaultKey); KeyManager.registerKeyBinding(ident, defaultKey);
KeyManager.keyStates.put(ident, new KeyState());
addOption(new OptionKeyBind(ident));
} }
/** @Deprecated
* Add a custom KeyBinding to be configured in the Controls menu.
*
* @param ident An identifier for your key, eg "shoot"
* @param defaultKey The default value, commonly obtained from {@link Keyboard}
*/
public static void addHashBind(String ident, int defaultKey) { public static void addHashBind(String ident, int defaultKey) {
NEIClientConfig.setDefaultKeyBinding(ident, defaultKey); KeyManager.registerKeyBinding(ident, defaultKey);
addOption(new OptionKeyBind(ident, true));
} }
public static void addOption(Option option) { public static void addOption(Option option) {
@@ -330,6 +342,30 @@ public class API {
SubsetWidget.addTag(tag); SubsetWidget.addTag(tag);
} }
/**
* Registers a group of items that is collapsed into a single entry in the item panel. Groups registered here have
* the lowest priority: an item that matches a preset or a collapsibleitems.cfg group stays there. They are active
* only while the Collapsible Items option is enabled. Must be called while plugins are loading.
*
* @param filter A search string for matching items that belong to this group. Also identifies the group when its
* expanded state is saved, so changing it resets the saved state.
* @return A handle to optionally set the name shown for the group
*/
public static CollapsibleItems.ApiGroup addCollapsibleGroup(String filter) {
return CollapsibleItems.registerGroup(filter);
}
/**
* Same as {@link #addCollapsibleGroup(String)}, but the group is given as a list of item stacks. The stacks
* identify the group when its expanded state is saved, so changing them resets the saved state.
*
* @param items Item stacks that belong to this group
* @return A handle to optionally set the name shown for the group
*/
public static CollapsibleItems.ApiGroup addCollapsibleGroup(Iterable<ItemStack> items) {
return CollapsibleItems.registerGroup(items);
}
@Deprecated @Deprecated
public static void addSearchProvider(ISearchProvider provider) {} public static void addSearchProvider(ISearchProvider provider) {}
@@ -368,6 +404,16 @@ public class API {
StackInfo.stackStringifyHandlers.add(handler); StackInfo.stackStringifyHandlers.add(handler);
} }
/**
* Replaces the default rendering of a fluid in NEI fluid display slots and fluid tanks.
*
* @param fluid the fluid to render
* @param renderer the renderer, or null to restore the default rendering
*/
public static void registerFluidRenderer(Fluid fluid, IFluidRenderer renderer) {
FluidDrawer.registerFluidRenderer(fluid, renderer);
}
/** /**
* Adds an association between an ingredient and what it can craft. (i.e. Furnace ItemStack -> Smelting and Fuel * 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 * Recipes) Allows players to see what ingredient they need to craft in order to make recipes from a recipe
@@ -24,7 +24,7 @@ public class DefaultOverlayRenderer implements IRecipeOverlayRenderer {
@Override @Override
public void renderOverlay(GuiContainerManager gui, Slot slot) { public void renderOverlay(GuiContainerManager gui, Slot slot) {
GL11.glPushAttrib(GL11.GL_ALL_ATTRIB_BITS); GL11.glPushAttrib(GL11.GL_ENABLE_BIT | GL11.GL_COLOR_BUFFER_BIT | GL11.GL_LIGHTING_BIT);
GL11.glEnable(GL11.GL_BLEND); GL11.glEnable(GL11.GL_BLEND);
GL11.glBlendFunc(770, 1); GL11.glBlendFunc(770, 1);
+14 -7
View File
@@ -16,7 +16,6 @@ import codechicken.nei.NEIDummySlotHandler;
import codechicken.nei.NEIPotionGuiHandler; import codechicken.nei.NEIPotionGuiHandler;
import codechicken.nei.recipe.CheatItemHandler; import codechicken.nei.recipe.CheatItemHandler;
import codechicken.nei.recipe.FillFluidContainerHandler; import codechicken.nei.recipe.FillFluidContainerHandler;
import codechicken.nei.recipe.GuiRecipeCatalyst;
import codechicken.nei.recipe.SearchInputDropHandler; import codechicken.nei.recipe.SearchInputDropHandler;
public class GuiInfo { public class GuiInfo {
@@ -31,7 +30,6 @@ public class GuiInfo {
API.registerNEIGuiHandler(new NEICreativeGuiHandler()); API.registerNEIGuiHandler(new NEICreativeGuiHandler());
API.registerNEIGuiHandler(new NEIChestGuiHandler()); API.registerNEIGuiHandler(new NEIChestGuiHandler());
API.registerNEIGuiHandler(new NEIDummySlotHandler()); API.registerNEIGuiHandler(new NEIDummySlotHandler());
API.registerNEIGuiHandler(new GuiRecipeCatalyst(null));
API.registerNEIGuiHandler(new SearchInputDropHandler()); API.registerNEIGuiHandler(new SearchInputDropHandler());
API.registerNEIGuiHandler(new FillFluidContainerHandler()); API.registerNEIGuiHandler(new FillFluidContainerHandler());
API.registerNEIGuiHandler(new CheatItemHandler()); API.registerNEIGuiHandler(new CheatItemHandler());
@@ -53,20 +51,29 @@ public class GuiInfo {
} }
public static boolean hideItemPanelSlot(GuiContainer gui, Rectangle4i rect) { public static boolean hideItemPanelSlot(GuiContainer gui, Rectangle4i rect) {
return hideItemPanelSlot(gui, rect, getGuiHandlersSnapshot());
}
public static INEIGuiHandler[] getGuiHandlersSnapshot() {
try { try {
readLock.lock(); readLock.lock();
if (guiHandlers.stream() return guiHandlers.toArray(new INEIGuiHandler[0]);
.anyMatch(handler -> handler.hideItemPanelSlot(gui, rect.x, rect.y, rect.w, rect.h))) {
return true;
}
} finally { } finally {
readLock.unlock(); readLock.unlock();
} }
}
public static boolean hideItemPanelSlot(GuiContainer gui, Rectangle4i rect, INEIGuiHandler[] handlers) {
for (INEIGuiHandler handler : handlers) {
if (handler.hideItemPanelSlot(gui, rect.x, rect.y, rect.w, rect.h)) return true;
}
for (Object item : gui.buttonList) { for (Object item : gui.buttonList) {
GuiButton button = (GuiButton) item; GuiButton button = (GuiButton) item;
if ((new Rectangle4i(button.xPosition, button.yPosition, button.width, button.height)).intersects(rect)) { if (button.xPosition + button.width > rect.x && button.xPosition < rect.x + rect.w
&& button.yPosition + button.height > rect.y
&& button.yPosition < rect.y + rect.h) {
return true; return true;
} }
} }
@@ -15,7 +15,7 @@ public interface IBookmarkContainerHandler {
for (int i = 0; i < slots.size() - 4 * 9; i++) { for (int i = 0; i < slots.size() - 4 * 9; i++) {
if (slots.get(i).getHasStack()) { if (slots.get(i).getHasStack()) {
stacks.add(slots.get(i).getStack()); stacks.add(slots.get(i).getStack().copy());
} }
} }
@@ -0,0 +1,17 @@
package codechicken.nei.api;
import net.minecraftforge.fluids.Fluid;
/**
* Custom renderer for a fluid, used by NEI fluid display slots and fluid tanks in recipes.
* <p>
* Register with {@link API#registerFluidRenderer(Fluid, IFluidRenderer)}.
*/
public interface IFluidRenderer {
/**
* Renders one 16x16 tile of the fluid. Partial tiles of a tank are clipped by NEI. The amount overlay is drawn by
* NEI.
*/
void renderFluid(Fluid fluid, int x, int y);
}
@@ -1,15 +1,9 @@
package codechicken.nei.api; package codechicken.nei.api;
import java.util.Collections;
import java.util.List;
import java.util.regex.Pattern; import java.util.regex.Pattern;
import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.item.ItemStack;
import net.minecraft.util.EnumChatFormatting; import net.minecraft.util.EnumChatFormatting;
import codechicken.nei.VisiblityData;
/** /**
* Lets you just override those things you want to * Lets you just override those things you want to
*/ */
@@ -17,31 +11,6 @@ public class INEIGuiAdapter implements INEIGuiHandler {
static final Pattern SPECIAL_REGEX_CHARS = Pattern.compile("[{}()\\[\\].+*?^$\\\\|]"); static final Pattern SPECIAL_REGEX_CHARS = Pattern.compile("[{}()\\[\\].+*?^$\\\\|]");
@Override
public VisiblityData modifyVisiblity(GuiContainer gui, VisiblityData currentVisibility) {
return currentVisibility;
}
@Override
public Iterable<Integer> getItemSpawnSlots(GuiContainer gui, ItemStack item) {
return Collections.emptyList();
}
@Override
public List<TaggedInventoryArea> getInventoryAreas(GuiContainer gui) {
return null;
}
@Override
public boolean handleDragNDrop(GuiContainer gui, int mousex, int mousey, ItemStack draggedStack, int button) {
return false;
}
@Override
public boolean hideItemPanelSlot(GuiContainer gui, int x, int y, int w, int h) {
return false;
}
protected String formattingText(String displayName) { protected String formattingText(String displayName) {
return SPECIAL_REGEX_CHARS.matcher(EnumChatFormatting.getTextWithoutFormattingCodes(displayName)) return SPECIAL_REGEX_CHARS.matcher(EnumChatFormatting.getTextWithoutFormattingCodes(displayName))
.replaceAll("\\\\$0"); .replaceAll("\\\\$0");
@@ -1,5 +1,6 @@
package codechicken.nei.api; package codechicken.nei.api;
import java.util.Collections;
import java.util.List; import java.util.List;
import net.minecraft.client.gui.inventory.GuiContainer; import net.minecraft.client.gui.inventory.GuiContainer;
@@ -12,23 +13,29 @@ import codechicken.nei.VisiblityData;
*/ */
public interface INEIGuiHandler { public interface INEIGuiHandler {
public VisiblityData modifyVisiblity(GuiContainer gui, VisiblityData currentVisibility); default VisiblityData modifyVisiblity(GuiContainer gui, VisiblityData currentVisibility) {
return currentVisibility;
}
/** /**
* NEI will give the specified item to the InventoryRange returned if the player's inventory is full. Should not * NEI will give the specified item to the InventoryRange returned if the player's inventory is full. Should not
* return null, just an empty list * return null, just an empty list
*/ */
public Iterable<Integer> getItemSpawnSlots(GuiContainer gui, ItemStack item); default Iterable<Integer> getItemSpawnSlots(GuiContainer gui, ItemStack item) {
return Collections.emptyList();
}
/** /**
* @return A list of TaggedInventoryAreas that will be used with the savestates. * @return A list of TaggedInventoryAreas that will be used with the savestates.
*/ */
public List<TaggedInventoryArea> getInventoryAreas(GuiContainer gui); default List<TaggedInventoryArea> getInventoryAreas(GuiContainer gui) {
return null;
}
/** /**
* Handles clicks while an itemstack has been dragged from the item panel. Use this to set configurable slots and * Handles clicks while an itemstack has been dragged from the item panel. Use this to set configurable slots and
* the like. Changes made to the stackSize of the dragged stack will be kept * the like. Changes made to the stackSize of the dragged stack will be kept
* *
* @param gui The current gui instance * @param gui The current gui instance
* @param mousex The x position of the mouse * @param mousex The x position of the mouse
* @param mousey The y position of the mouse * @param mousey The y position of the mouse
@@ -37,18 +44,22 @@ public interface INEIGuiHandler {
* @return True if the drag n drop was handled. False to resume processing through other routes. The held stack will * @return True if the drag n drop was handled. False to resume processing through other routes. The held stack will
* be deleted if draggedStack.stackSize == 0 * be deleted if draggedStack.stackSize == 0
*/ */
public boolean handleDragNDrop(GuiContainer gui, int mousex, int mousey, ItemStack draggedStack, int button); default boolean handleDragNDrop(GuiContainer gui, int mousex, int mousey, ItemStack draggedStack, int button) {
return false;
}
/** /**
* Used to prevent the item panel from drawing on top of other gui elements. This function will also be called with * Used to prevent the item panel from drawing on top of other gui elements. This function will also be called with
* a 1x1 size rectangle on the mouse position for determining if the given coordinate should override item panel * a 1x1 size rectangle on the mouse position for determining if the given coordinate should override item panel
* functions such as scrolling * functions such as scrolling
* *
* @param x The x coordinate of the rectangle bounding the slot * @param x The x coordinate of the rectangle bounding the slot
* @param y The y coordinate of the rectangle bounding the slot * @param y The y coordinate of the rectangle bounding the slot
* @param w The w coordinate of the rectangle bounding the slot * @param w The w coordinate of the rectangle bounding the slot
* @param h The h coordinate of the rectangle bounding the slot * @param h The h coordinate of the rectangle bounding the slot
* @return true if the item panel slot within the specified rectangle should not be rendered. * @return true if the item panel slot within the specified rectangle should not be rendered.
*/ */
public boolean hideItemPanelSlot(GuiContainer gui, int x, int y, int w, int h); default boolean hideItemPanelSlot(GuiContainer gui, int x, int y, int w, int h) {
return false;
}
} }
@@ -1,14 +1,12 @@
package codechicken.nei.api; package codechicken.nei.api;
import java.util.ArrayList;
import java.util.List; import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors; import java.util.stream.Collectors;
import net.minecraft.client.gui.inventory.GuiContainer; import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.item.ItemStack;
import codechicken.nei.PositionedStack; import codechicken.nei.NEIClientConfig;
import codechicken.nei.NEIClientUtils;
import codechicken.nei.recipe.GuiOverlayButton.ItemOverlayState; import codechicken.nei.recipe.GuiOverlayButton.ItemOverlayState;
import codechicken.nei.recipe.IRecipeHandler; import codechicken.nei.recipe.IRecipeHandler;
@@ -32,29 +30,19 @@ public interface IOverlayHandler {
return false; return false;
} }
default boolean requireShiftForOverlayRecipe() {
return NEIClientConfig.requireShiftForOverlayRecipe();
}
default List<ItemOverlayState> presenceOverlay(GuiContainer firstGui, IRecipeHandler recipe, int recipeIndex) { default List<ItemOverlayState> presenceOverlay(GuiContainer firstGui, IRecipeHandler recipe, int recipeIndex) {
final List<ItemOverlayState> itemPresenceSlots = new ArrayList<>(); return NEIClientUtils.presenceOverlay(
final List<PositionedStack> ingredients = recipe.getIngredientStacks(recipeIndex); recipe.getIngredientStacks(recipeIndex),
final List<ItemStack> invStacks = firstGui.inventorySlots.inventorySlots.stream() firstGui.inventorySlots.inventorySlots.stream()
.filter( .filter(
s -> s != null && s.getStack() != null s -> s != null && s.getStack() != null
&& s.getStack().stackSize > 0 && s.getStack().stackSize > 0
&& s.isItemValid(s.getStack()) && s.isItemValid(s.getStack())
&& s.canTakeStack(firstGui.mc.thePlayer)) && s.canTakeStack(firstGui.mc.thePlayer))
.map(s -> s.getStack().copy()).collect(Collectors.toList()); .map(s -> s.getStack().copy()).collect(Collectors.toList()));
for (PositionedStack stack : ingredients) {
Optional<ItemStack> used = invStacks.stream().filter(is -> is.stackSize > 0 && stack.contains(is))
.findAny();
itemPresenceSlots.add(new ItemOverlayState(stack, used.isPresent()));
if (used.isPresent()) {
ItemStack is = used.get();
is.stackSize -= 1;
}
}
return itemPresenceSlots;
} }
} }
@@ -1,18 +1,14 @@
package codechicken.nei.api; package codechicken.nei.api;
import java.util.List;
import codechicken.nei.PositionedStack;
import codechicken.nei.recipe.IRecipeHandler; import codechicken.nei.recipe.IRecipeHandler;
public interface IRecipeFilter { public interface IRecipeFilter {
public static interface IRecipeFilterProvider { public static interface IRecipeFilterProvider {
public IRecipeFilter getFilter(); public IRecipeFilter getRecipeFilter();
} }
public boolean matches(IRecipeHandler handler, List<PositionedStack> ingredients, PositionedStack result, public boolean matches(IRecipeHandler handler, int recipeIndex);
List<PositionedStack> others);
} }
@@ -18,6 +18,14 @@ public interface IStackStringifyHandler {
return null; return null;
} }
default ItemStack normalizeRecipeQueryStack(ItemStack stack) {
return null;
}
default void pauseItemDamageSound(boolean pause) {} default void pauseItemDamageSound(boolean pause) {}
default boolean isFluidDisplayItem(ItemStack stack) {
return false;
}
} }
+49 -20
View File
@@ -1,6 +1,7 @@
package codechicken.nei.api; package codechicken.nei.api;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap; import java.util.HashMap;
import java.util.HashSet; import java.util.HashSet;
import java.util.LinkedList; import java.util.LinkedList;
@@ -35,6 +36,7 @@ import net.minecraft.util.MovingObjectPosition;
import net.minecraft.util.RegistryNamespaced; import net.minecraft.util.RegistryNamespaced;
import net.minecraft.world.World; import net.minecraft.world.World;
import net.minecraft.world.biome.BiomeGenBase; import net.minecraft.world.biome.BiomeGenBase;
import net.minecraftforge.client.MinecraftForgeClient;
import net.minecraftforge.common.BiomeDictionary; import net.minecraftforge.common.BiomeDictionary;
import net.minecraftforge.common.IShearable; import net.minecraftforge.common.IShearable;
import net.minecraftforge.oredict.OreDictionary; import net.minecraftforge.oredict.OreDictionary;
@@ -57,14 +59,18 @@ import codechicken.nei.SearchTokenParser.SearchMode;
import codechicken.nei.config.ArrayDumper; import codechicken.nei.config.ArrayDumper;
import codechicken.nei.config.HandlerDumper; import codechicken.nei.config.HandlerDumper;
import codechicken.nei.config.ItemPanelDumper; import codechicken.nei.config.ItemPanelDumper;
import codechicken.nei.config.RecipeDumper;
import codechicken.nei.config.RegistryDumper; import codechicken.nei.config.RegistryDumper;
import codechicken.nei.guihook.GuiContainerManager; import codechicken.nei.guihook.GuiContainerManager;
import codechicken.nei.item.FluidDisplayRenderer;
import codechicken.nei.item.ItemFluidDisplay;
import codechicken.nei.recipe.BrewingRecipeHandler; import codechicken.nei.recipe.BrewingRecipeHandler;
import codechicken.nei.recipe.RecipeItemInputHandler; import codechicken.nei.recipe.RecipeItemInputHandler;
import codechicken.nei.search.IdentifierFilter; import codechicken.nei.search.IdentifierFilter;
import codechicken.nei.search.ModNameFilter; import codechicken.nei.search.ModNameFilter;
import codechicken.nei.search.OreDictionaryFilter; import codechicken.nei.search.OreDictionaryFilter;
import codechicken.nei.search.TooltipFilter; import codechicken.nei.search.TooltipFilter;
import codechicken.nei.util.ItemUntranslator;
import cpw.mods.fml.common.FMLCommonHandler; import cpw.mods.fml.common.FMLCommonHandler;
import cpw.mods.fml.common.ModContainer; import cpw.mods.fml.common.ModContainer;
import cpw.mods.fml.common.registry.GameRegistry; import cpw.mods.fml.common.registry.GameRegistry;
@@ -75,14 +81,18 @@ import cpw.mods.fml.common.registry.GameRegistry.UniqueIdentifier;
*/ */
public class ItemInfo { public class ItemInfo {
public static enum Layout { public enum Layout {
HEADER, HEADER,
BODY, BODY,
FOOTER FOOTER;
public static final Layout[] VALUES = values();
} }
public static final ArrayListMultimap<Layout, IHighlightHandler> highlightHandlers = ArrayListMultimap.create(); public static final ArrayListMultimap<Layout, IHighlightHandler> highlightHandlers = ArrayListMultimap.create();
public static final ItemStackMap<String> nameOverrides = new ItemStackMap<>(); public static final ItemStackMap<String> nameOverrides = new ItemStackMap<>();
public static final ItemStackMap<List<String>> itemAliases = new ItemStackMap<>();
public static final ItemStackSet hiddenItems = new ItemStackSet(); public static final ItemStackSet hiddenItems = new ItemStackSet();
public static final AnyMultiItemFilter hiddenItemsRules = new AnyMultiItemFilter(); public static final AnyMultiItemFilter hiddenItemsRules = new AnyMultiItemFilter();
public static final ItemStackSet finiteItems = new ItemStackSet(); public static final ItemStackSet finiteItems = new ItemStackSet();
@@ -108,6 +118,11 @@ public class ItemInfo {
return nameOverrides.get(stack); return nameOverrides.get(stack);
} }
public static List<String> getAliases(ItemStack stack) {
final List<String> aliases = itemAliases.get(stack);
return aliases != null ? aliases : Collections.emptyList();
}
public static boolean canBeInfinite(ItemStack stack) { public static boolean canBeInfinite(ItemStack stack) {
return !finiteItems.contains(stack); return !finiteItems.contains(stack);
} }
@@ -122,6 +137,7 @@ public class ItemInfo {
public static void preInit() { public static void preInit() {
addMobSpawnerItem(); addMobSpawnerItem();
setupFluidDisplayItemClient();
} }
public static void load() { public static void load() {
@@ -137,6 +153,10 @@ public class ItemInfo {
addSearchProviders(); addSearchProviders();
RecipeItemInputHandler.load(); RecipeItemInputHandler.load();
PresetsList.load(); PresetsList.load();
if (NEIClientConfig.enableItemUntranslator()) {
ItemUntranslator.getInstance().load();
}
} }
private static void addSearchProviders() { private static void addSearchProviders() {
@@ -265,6 +285,7 @@ public class ItemInfo {
}); });
API.addOption(new ItemPanelDumper("tools.dump.itempanel")); API.addOption(new ItemPanelDumper("tools.dump.itempanel"));
API.addOption(new HandlerDumper("tools.dump.handlers")); API.addOption(new HandlerDumper("tools.dump.handlers"));
API.addOption(new RecipeDumper("tools.dump.recipes"));
} }
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
@@ -303,18 +324,17 @@ public class ItemInfo {
GameDataManipulator.replaceItem(Block.getIdFromBlock(Blocks.mob_spawner), new ItemMobSpawner()); GameDataManipulator.replaceItem(Block.getIdFromBlock(Blocks.mob_spawner), new ItemMobSpawner());
} }
private static void setupFluidDisplayItemClient() {
ItemFluidDisplay.INSTANCE.setCreativeTab(ItemFluidDisplay.tabFluids);
MinecraftForgeClient.registerItemRenderer(ItemFluidDisplay.INSTANCE, new FluidDisplayRenderer());
}
private static void addInfiniteHandlers() { private static void addInfiniteHandlers() {
API.addInfiniteItemHandler(new InfiniteStackSizeHandler()); API.addInfiniteItemHandler(new InfiniteStackSizeHandler());
API.addInfiniteItemHandler(new InfiniteToolHandler()); API.addInfiniteItemHandler(new InfiniteToolHandler());
} }
private static void addVanillaBlockProperties() { private static void addVanillaBlockProperties() {
API.setOverrideName(new ItemStack(Blocks.flowing_water), "Water Source");
API.setOverrideName(new ItemStack(Blocks.water), "Water Still");
API.setOverrideName(new ItemStack(Blocks.flowing_lava), "Lava Source");
API.setOverrideName(new ItemStack(Blocks.lava), "Lava Still");
API.setOverrideName(new ItemStack(Blocks.end_portal), "End Portal");
API.setOverrideName(new ItemStack(Blocks.end_portal_frame), "End Portal Frame");
API.hideItem(new ItemStack(Blocks.double_stone_slab, 1, OreDictionary.WILDCARD_VALUE)); API.hideItem(new ItemStack(Blocks.double_stone_slab, 1, OreDictionary.WILDCARD_VALUE));
API.hideItem(new ItemStack(Blocks.double_wooden_slab, 1, OreDictionary.WILDCARD_VALUE)); API.hideItem(new ItemStack(Blocks.double_wooden_slab, 1, OreDictionary.WILDCARD_VALUE));
API.hideItem(new ItemStack(Blocks.carrots)); API.hideItem(new ItemStack(Blocks.carrots));
@@ -387,6 +407,7 @@ public class ItemInfo {
item -> item.getItem() instanceof ItemArmor armor && armor.armorType == 2); item -> item.getItem() instanceof ItemArmor armor && armor.armorType == 2);
API.addSubset("Items.Armor.Boots", item -> item.getItem() instanceof ItemArmor armor && armor.armorType == 3); API.addSubset("Items.Armor.Boots", item -> item.getItem() instanceof ItemArmor armor && armor.armorType == 3);
API.addSubset("Items.Food", item -> item.getItem() instanceof ItemFood); API.addSubset("Items.Food", item -> item.getItem() instanceof ItemFood);
API.addSubset("Items.Fluids", item -> item.getItem() instanceof ItemFluidDisplay);
API.addSubset("Items.Potions.Ingredients", BrewingRecipeHandler.ingredients); API.addSubset("Items.Potions.Ingredients", BrewingRecipeHandler.ingredients);
for (CreativeTabs tab : CreativeTabs.creativeTabArray) { for (CreativeTabs tab : CreativeTabs.creativeTabArray) {
@@ -416,30 +437,38 @@ public class ItemInfo {
Block mouseoverBlock = world.getBlock(x, y, z); Block mouseoverBlock = world.getBlock(x, y, z);
ArrayList<ItemStack> items = new ArrayList<>(); ArrayList<ItemStack> items = new ArrayList<>();
ArrayList<IHighlightHandler> handlers = new ArrayList<>(); ArrayList<IHighlightHandler> handlers = new ArrayList<>();
if (highlightIdentifiers.containsKey(null)) handlers.addAll(highlightIdentifiers.get(null)); if (highlightIdentifiers.containsKey(null)) handlers.addAll(highlightIdentifiers.get(null));
if (highlightIdentifiers.containsKey(mouseoverBlock)) handlers.addAll(highlightIdentifiers.get(mouseoverBlock)); if (highlightIdentifiers.containsKey(mouseoverBlock)) handlers.addAll(highlightIdentifiers.get(mouseoverBlock));
for (IHighlightHandler ident : handlers) { for (IHighlightHandler ident : handlers) {
ItemStack item = ident.identifyHighlight(world, player, hit); final ItemStack item = ident.identifyHighlight(world, player, hit);
if (item != null) items.add(item); if (item != null) items.add(item);
} }
if (items.size() > 0) return items; if (!items.isEmpty()) return items;
ItemStack pick = mouseoverBlock.getPickBlock(hit, world, x, y, z, player); try {
if (pick != null) items.add(pick); final ItemStack pick = mouseoverBlock.getPickBlock(hit, world, x, y, z, player);
if (pick != null) items.add(pick);
} catch (Exception ignored) {}
if (!items.isEmpty()) return items;
if (mouseoverBlock instanceof IShearable shearable) {
if (shearable.isShearable(new ItemStack(Items.shears), world, x, y, z)) {
items.addAll(shearable.onSheared(new ItemStack(Items.shears), world, x, y, z, 0));
}
}
if (!items.isEmpty()) return items;
try { try {
items.addAll(mouseoverBlock.getDrops(world, x, y, z, world.getBlockMetadata(x, y, z), 0)); items.addAll(mouseoverBlock.getDrops(world, x, y, z, world.getBlockMetadata(x, y, z), 0));
} catch (Exception ignored) {} } catch (Exception ignored) {}
if (mouseoverBlock instanceof IShearable) {
IShearable shearable = (IShearable) mouseoverBlock;
if (shearable.isShearable(new ItemStack(Items.shears), world, x, y, z))
items.addAll(shearable.onSheared(new ItemStack(Items.shears), world, x, y, z, 0));
}
if (items.size() == 0) items.add(0, new ItemStack(mouseoverBlock, 1, world.getBlockMetadata(x, y, z))); if (items.isEmpty()) items.add(new ItemStack(mouseoverBlock, 1, world.getBlockMetadata(x, y, z)));
return items; return items;
} }
@@ -452,7 +481,7 @@ public class ItemInfo {
MovingObjectPosition mop) { MovingObjectPosition mop) {
List<String> retString = new ArrayList<>(); List<String> retString = new ArrayList<>();
for (ItemInfo.Layout layout : ItemInfo.Layout.values()) for (ItemInfo.Layout layout : Layout.VALUES)
for (IHighlightHandler handler : ItemInfo.highlightHandlers.get(layout)) for (IHighlightHandler handler : ItemInfo.highlightHandlers.get(layout))
retString = handler.handleTextData(itemStack, world, player, mop, retString, layout); retString = handler.handleTextData(itemStack, world, player, mop, retString, layout);
@@ -13,9 +13,7 @@ public class NEIInfo {
public static void load(World world) { public static void load(World world) {
OptionCycled modeOption = (OptionCycled) NEIClientConfig.getOptionList().getOption("inventory.cheatmode"); OptionCycled modeOption = (OptionCycled) NEIClientConfig.getOptionList().getOption("inventory.cheatmode");
modeOption.parent.synthesizeEnvironment(false);
if (!modeOption.optionValid(modeOption.value())) { if (!modeOption.optionValid(modeOption.value())) {
modeOption.copyGlobals();
modeOption.cycle(); modeOption.cycle();
} }
} }
@@ -10,6 +10,8 @@ import java.util.Map;
import net.minecraft.client.gui.GuiScreen; import net.minecraft.client.gui.GuiScreen;
import net.minecraft.client.gui.inventory.GuiContainer; import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.item.ItemStack; import net.minecraft.item.ItemStack;
import net.minecraftforge.fluids.FluidRegistry;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.oredict.OreDictionary; import net.minecraftforge.oredict.OreDictionary;
import org.lwjgl.input.Mouse; import org.lwjgl.input.Mouse;
@@ -19,17 +21,25 @@ import codechicken.nei.BookmarkContainerInfo;
import codechicken.nei.FavoriteRecipes; import codechicken.nei.FavoriteRecipes;
import codechicken.nei.ItemPanels; import codechicken.nei.ItemPanels;
import codechicken.nei.ItemQuantityField; import codechicken.nei.ItemQuantityField;
import codechicken.nei.KeyManager;
import codechicken.nei.LayoutManager; import codechicken.nei.LayoutManager;
import codechicken.nei.NEIClientConfig; import codechicken.nei.NEIClientConfig;
import codechicken.nei.NEIClientUtils; import codechicken.nei.NEIClientUtils;
import codechicken.nei.PositionedStack;
import codechicken.nei.SearchField; import codechicken.nei.SearchField;
import codechicken.nei.bookmark.BookmarkGrid; import codechicken.nei.bookmark.BookmarkGrid;
import codechicken.nei.bookmark.BookmarkGroup;
import codechicken.nei.bookmark.BookmarkItem; import codechicken.nei.bookmark.BookmarkItem;
import codechicken.nei.bookmark.BookmarkItem.BookmarkItemType;
import codechicken.nei.bookmark.BookmarkPayload;
import codechicken.nei.bookmark.BookmarksGridSlot; import codechicken.nei.bookmark.BookmarksGridSlot;
import codechicken.nei.bookmark.tree.GuiCraftingTree;
import codechicken.nei.recipe.AutoCraftingManager; import codechicken.nei.recipe.AutoCraftingManager;
import codechicken.nei.recipe.GuiCraftingRecipe; import codechicken.nei.recipe.GuiCraftingRecipe;
import codechicken.nei.recipe.GuiFavoriteButton;
import codechicken.nei.recipe.GuiRecipe; import codechicken.nei.recipe.GuiRecipe;
import codechicken.nei.recipe.GuiUsageRecipe; import codechicken.nei.recipe.GuiUsageRecipe;
import codechicken.nei.recipe.HoveredRecipe;
import codechicken.nei.recipe.Recipe; import codechicken.nei.recipe.Recipe;
import codechicken.nei.recipe.Recipe.RecipeId; import codechicken.nei.recipe.Recipe.RecipeId;
import codechicken.nei.recipe.RecipeHandlerRef; import codechicken.nei.recipe.RecipeHandlerRef;
@@ -39,14 +49,38 @@ import codechicken.nei.util.NEIMouseUtils;
public abstract class ShortcutInputHandler { public abstract class ShortcutInputHandler {
private static class HotkeysCache {
public int mousex;
public int mousey;
public ItemStack stack;
public int groupId;
public Map<String, String> hotkeys = new HashMap<>();
public boolean matches(int mousex, int mousey, ItemStack stack, int groupId) {
return Math.abs(this.mousex - mousex) < 16 && Math.abs(this.mousey - mousey) < 16
&& (this.stack == null ? stack == null && this.groupId == groupId
: stack != null && NEIClientUtils.areStacksSameTypeWithNBT(stack, this.stack));
}
public void update(int mousex, int mousey, ItemStack stack, int groupId, Map<String, String> hotkeys) {
this.mousex = mousex;
this.mousey = mousey;
this.stack = stack != null ? stack.copy() : null;
this.groupId = groupId;
this.hotkeys = hotkeys;
}
}
private static HotkeysCache hotkeysCache = new HotkeysCache();
public static boolean handleKeyEvent(ItemStack stackover) { public static boolean handleKeyEvent(ItemStack stackover) {
if (!NEIClientConfig.isLoaded()) { if (!NEIClientConfig.isLoaded()) {
return false; return false;
} }
if (NEIClientConfig.isKeyHashDown("gui.overlay") && stackover == null if (KeyManager.isKeyDown("gui.overlay") && stackover == null && LayoutManager.overlayRenderer != null) {
&& LayoutManager.overlayRenderer != null) {
LayoutManager.overlayRenderer = null; LayoutManager.overlayRenderer = null;
return true; return true;
} }
@@ -56,16 +90,27 @@ public abstract class ShortcutInputHandler {
if (groupId != -1) { if (groupId != -1) {
if (NEIClientConfig.isKeyHashDown("gui.remove_recipe")) { if (KeyManager.isHashDown("bookmark.remove_recipe", NEIClientUtils.SHIFT_HASH)) {
ItemPanels.bookmarkPanel.removeGroup(groupId); ItemPanels.bookmarkPanel.removeGroup(groupId);
return true; return true;
} }
if (NEIClientConfig.isKeyHashDown("gui.bookmark_pull_items")) { if (KeyManager.isKeyDown("bookmark.pull_items")) {
return ItemPanels.bookmarkPanel.pullBookmarkItems(groupId, NEIClientUtils.shiftKey()); return ItemPanels.bookmarkPanel.pullBookmarkItems(groupId, NEIClientUtils.shiftKey());
} }
if (NEIClientConfig.autocraftingEnabled() && NEIClientConfig.isKeyHashDown("gui.craft_items") if (KeyManager.isKeyDown("bookmark.chat_link") && NEIClientUtils.controlKey()) {
NEIClientUtils.sendChatItemLink(BookmarkPayload.of(groupId).toNBT());
return true;
}
if (ItemPanels.bookmarkPanel.getGrid().isCraftingMode(groupId)
&& KeyManager.isKeyDown("bookmark.open_crafting_tree")) {
GuiCraftingTree.openCraftingTreeGui(ItemPanels.bookmarkPanel.getGrid(), groupId);
return true;
}
if (NEIClientConfig.autocraftingEnabled() && KeyManager.isKeyDown("gui.craft_items")
&& NEIClientUtils.shiftKey() && NEIClientUtils.shiftKey()
&& ItemPanels.bookmarkPanel.getGrid().isCraftingMode(groupId)) { && ItemPanels.bookmarkPanel.getGrid().isCraftingMode(groupId)) {
final RecipeChainMath math = ItemPanels.bookmarkPanel.getGrid().createRecipeChainMath(groupId); final RecipeChainMath math = ItemPanels.bookmarkPanel.getGrid().createRecipeChainMath(groupId);
@@ -88,39 +133,47 @@ public abstract class ShortcutInputHandler {
stackover = stackover.copy(); stackover = stackover.copy();
if (NEIClientConfig.isKeyHashDown("gui.overlay")) { if (KeyManager.isKeyDown("gui.overlay")) {
return openOverlayRecipe(stackover); return openOverlayRecipe(stackover);
} }
if (NEIClientConfig.isKeyHashDown("gui.copy_name")) { if (KeyManager.isHashDown("copy.name", NEIClientUtils.CTRL_HASH)) {
return copyItemStackName(stackover); return copyItemStackName(stackover);
} }
if (NEIClientConfig.isKeyHashDown("gui.copy_oredict")) { if (KeyManager.isHashDown("copy.identifier", NEIClientUtils.CTRL_HASH)) {
return copyItemStackID(stackover);
}
if (KeyManager.isHashDown("copy.oredict", NEIClientUtils.CTRL_HASH)) {
return copyItemStackOreDictionary(stackover); return copyItemStackOreDictionary(stackover);
} }
if (NEIClientConfig.isKeyHashDown("gui.chat_link_item")) { if (KeyManager.isKeyDown("bookmark.chat_link") && NEIClientUtils.controlKey()) {
return sendItemStackChatLink(stackover); return sendRecipeInChatLink(stackover, NEIClientUtils.shiftKey());
} }
if (NEIClientConfig.isKeyHashDown("gui.recipe")) { if (KeyManager.isKeyDown("recipe.recipe")) {
return GuiCraftingRecipe.openRecipeGui("item", stackover); return GuiCraftingRecipe.openRecipeGui("item", stackover);
} }
if (NEIClientConfig.isKeyHashDown("gui.usage")) { if (KeyManager.isKeyDown("recipe.usage")) {
return GuiUsageRecipe.openRecipeGui("item", stackover); return GuiUsageRecipe.openRecipeGui("item", stackover);
} }
if (NEIClientConfig.isKeyHashDown("gui.bookmark")) { if (KeyManager.isHashDown("bookmark.favorite", NEIClientUtils.SHIFT_HASH)) {
return saveFavoriteTree(stackover);
}
if (KeyManager.isKeyDown("bookmark.add")) {
return saveRecipeInBookmark(stackover, NEIClientUtils.shiftKey(), NEIClientUtils.controlKey()); return saveRecipeInBookmark(stackover, NEIClientUtils.shiftKey(), NEIClientUtils.controlKey());
} }
if (NEIClientConfig.isKeyHashDown("gui.bookmark_pull_items")) { if (KeyManager.isKeyDown("bookmark.pull_items")) {
return pullRecipeItems(stackover, NEIClientUtils.shiftKey()); return pullRecipeItems(stackover, NEIClientUtils.shiftKey());
} }
if (NEIClientConfig.autocraftingEnabled() && NEIClientConfig.isKeyHashDown("gui.craft_items") if (NEIClientConfig.autocraftingEnabled() && KeyManager.isKeyDown("gui.craft_items")
&& NEIClientUtils.shiftKey()) { && NEIClientUtils.shiftKey()) {
return runAutoCrafting(stackover, !NEIClientUtils.controlKey()); return runAutoCrafting(stackover, !NEIClientUtils.controlKey());
} }
@@ -138,9 +191,9 @@ public abstract class ShortcutInputHandler {
final int button = Mouse.getEventButton(); final int button = Mouse.getEventButton();
if (button == 0) { if (button == 0) {
return GuiCraftingRecipe.openRecipeGui("item", stackover); return GuiCraftingRecipe.openRecipeGui("item", stackover.copy());
} else if (button == 1) { } else if (button == 1) {
return GuiUsageRecipe.openRecipeGui("item", stackover); return GuiUsageRecipe.openRecipeGui("item", stackover.copy());
} }
} }
@@ -152,10 +205,60 @@ public abstract class ShortcutInputHandler {
return true; return true;
} }
private static boolean sendItemStackChatLink(ItemStack stackover) { private static boolean copyItemStackID(ItemStack stackover) {
if (stackover == null) return false; if (stackover == null || stackover.getItem() == null) return false;
NEIClientUtils.sendChatItemLink(stackover); // I wish clients could just send formatted messages String clipboard;
if (StackInfo.isFluidDisplayItem(stackover)) {
final FluidStack fluid = StackInfo.getFluid(stackover);
if (fluid == null) {
return false;
}
clipboard = FluidRegistry.getDefaultFluidName(fluid.getFluid());
} else {
clipboard = stackover.getItem().delegate.name()
+ (stackover.getItemDamage() != 0 ? "/" + stackover.getItemDamage() : "");
}
GuiScreen.setClipboardString(clipboard);
return true;
}
private static boolean sendRecipeInChatLink(ItemStack stackover, boolean saveIngredients) {
final Point mousePos = GuiDraw.getMousePosition();
final BookmarksGridSlot slot = ItemPanels.bookmarkPanel.getSlotMouseOver(mousePos.x, mousePos.y);
if (slot != null && saveIngredients && slot.getType() == BookmarkItemType.RESULT) {
NEIClientUtils.sendChatItemLink(BookmarkPayload.of(slot.getBookmarkItem()).toNBT());
return true;
}
final Recipe recipe = getFocusedRecipe(stackover, mousePos.x, mousePos.y, saveIngredients);
if (recipe != null && saveIngredients) {
NEIClientUtils.sendChatItemLink(BookmarkPayload.of(recipe).toNBT());
return true;
}
final RecipeId recipeId;
if (slot != null) {
recipeId = slot.getType() == BookmarkItemType.INGREDIENT ? null : slot.getRecipeId();
} else {
recipeId = recipe != null ? recipe.getRecipeId() : null;
}
final boolean existsRecipe = NEIClientConfig.getBooleanSetting("inventory.bookmarks.bookmarkItemsWithRecipe");
if (ItemPanels.itemPanel.containsWithSubpanels(mousePos.x, mousePos.y)) {
stackover = ItemQuantityField.prepareStackWithQuantity(stackover, 0);
}
NEIClientUtils.sendChatItemLink(BookmarkPayload.of(stackover, existsRecipe ? recipeId : null).toNBT());
return true; return true;
} }
@@ -190,12 +293,12 @@ public abstract class ShortcutInputHandler {
if (recipe != null) { if (recipe != null) {
math = RecipeChainMath.of(recipe, 1); math = RecipeChainMath.of(recipe, 1);
} }
} else if (slot.getRecipeId() != null && !slot.isIngredient()) { } else if (slot.getRecipeId() != null && slot.getType() != BookmarkItemType.INGREDIENT) {
if (slot.getGroup().crafting == null) { if (slot.getGroup().crafting == null) {
final Recipe recipe = Recipe.of(slot.getRecipeId()); final Recipe recipe = Recipe.of(slot.getRecipeId());
if (recipe != null) { if (recipe != null) {
math = RecipeChainMath.of(recipe, slot != null ? slot.getMultiplier() : 1); math = RecipeChainMath.of(recipe, Math.max(1, slot.getMultiplier()));
} }
} else { } else {
math = ItemPanels.bookmarkPanel.getGrid() math = ItemPanels.bookmarkPanel.getGrid()
@@ -247,14 +350,35 @@ public abstract class ShortcutInputHandler {
return false; return false;
} }
private static boolean saveFavoriteTree(ItemStack stackover) {
final Point mouse = GuiDraw.getMousePosition();
if (ItemPanels.itemPanel.contains(mouse.x, mouse.y)
|| ItemPanels.itemPanel.historyPanel.contains(mouse.x, mouse.y)) {
final RecipeHandlerRef handlerRef = RecipeHandlerRef.of(FavoriteRecipes.getFavorite(stackover));
if (handlerRef != null) {
final GuiFavoriteButton button = new GuiFavoriteButton(handlerRef, 0, 0);
button.saveRecipeInBookmark();
}
return true;
}
return false;
}
private static boolean saveRecipeInBookmark(ItemStack stackover, boolean saveIngredients, boolean saveStackSize) { private static boolean saveRecipeInBookmark(ItemStack stackover, boolean saveIngredients, boolean saveStackSize) {
final Point mousePos = GuiDraw.getMousePosition(); final Point mousePos = GuiDraw.getMousePosition();
// If no slot was removed from the bookmark panel on click:
if (!ItemPanels.bookmarkPanel.removeSlot(mousePos.x, mousePos.y, saveIngredients)) { if (!ItemPanels.bookmarkPanel.removeSlot(mousePos.x, mousePos.y, saveIngredients)) {
final Recipe recipe = getFocusedRecipe(stackover, mousePos.x, mousePos.y, saveIngredients); final Recipe recipe = getFocusedRecipe(stackover, mousePos.x, mousePos.y, saveIngredients);
// --- Case 1: saving a recipe (with ingredients) ---
if (recipe != null && saveIngredients) { if (recipe != null && saveIngredients) {
// If the recipe is not already bookmarked, add it
if (!ItemPanels.bookmarkPanel.removeRecipe(recipe.getRecipeId(), BookmarkGrid.DEFAULT_GROUP_ID)) { if (!ItemPanels.bookmarkPanel.removeRecipe(recipe.getRecipeId(), BookmarkGrid.DEFAULT_GROUP_ID)) {
final Recipe singleRecipe = Recipe.of( final Recipe singleRecipe = Recipe.of(
Arrays.asList(recipe.getResult(stackover)), Arrays.asList(recipe.getResult(stackover)),
@@ -262,26 +386,38 @@ public abstract class ShortcutInputHandler {
recipe.getIngredients()); recipe.getIngredients());
singleRecipe.setCustomRecipeId(recipe.getRecipeId()); singleRecipe.setCustomRecipeId(recipe.getRecipeId());
ItemPanels.bookmarkPanel.addRecipe(singleRecipe, BookmarkGrid.DEFAULT_GROUP_ID); ItemPanels.bookmarkPanel.addRecipe(
singleRecipe,
// Determine if stack size should be saved
saveStackSize
|| NEIClientConfig.getBooleanSetting("inventory.bookmarks.bookmarkRecipeWithCount")
? 1
: 0,
BookmarkGrid.DEFAULT_GROUP_ID);
} }
// --- Case 2: saving an item only ---
} else { } else {
final RecipeId recipeId = recipe != null ? recipe.getRecipeId() : null; final RecipeId recipeId = recipe != null ? recipe.getRecipeId() : null;
// Determine if the item is associated with a recipe and should be saved with it
final boolean existsRecipe = recipeId != null final boolean existsRecipe = recipeId != null
&& ItemPanels.bookmarkPanel.existsRecipe(recipeId, BookmarkGrid.DEFAULT_GROUP_ID) && ItemPanels.bookmarkPanel.existsRecipe(recipeId, BookmarkGrid.DEFAULT_GROUP_ID)
|| NEIClientConfig.getBooleanSetting("inventory.bookmarks.bookmarkItemsWithRecipe"); || NEIClientConfig.getBooleanSetting("inventory.bookmarks.bookmarkItemsWithRecipe");
// If the item was not removed from the bookmarks, add it
if (!ItemPanels.bookmarkPanel if (!ItemPanels.bookmarkPanel
.removeItem(stackover, existsRecipe ? recipeId : null, BookmarkGrid.DEFAULT_GROUP_ID)) { .removeItem(stackover, existsRecipe ? recipeId : null, BookmarkGrid.DEFAULT_GROUP_ID)) {
// Determine whether to preserve the item count
saveStackSize = saveStackSize || saveIngredients saveStackSize = saveStackSize || saveIngredients
|| ItemPanels.bookmarkPanel.existsRecipe(recipeId, BookmarkGrid.DEFAULT_GROUP_ID); || ItemPanels.bookmarkPanel.existsRecipe(recipeId, BookmarkGrid.DEFAULT_GROUP_ID);
if (!saveStackSize) { if (!saveStackSize) {
stackover = StackInfo.withAmount(stackover, 0); stackover = StackInfo.withAmount(stackover, 0);
} else if (ItemPanels.itemPanel.contains(mousePos.x, mousePos.y) } else if (ItemPanels.itemPanel.containsWithSubpanels(mousePos.x, mousePos.y)) {
|| ItemPanels.itemPanel.historyPanel.contains(mousePos.x, mousePos.y)) { stackover = ItemQuantityField.prepareStackWithQuantity(stackover, 0);
stackover = ItemQuantityField.prepareStackWithQuantity(stackover, 0); }
}
ItemPanels.bookmarkPanel ItemPanels.bookmarkPanel
.addItem(stackover, existsRecipe ? recipeId : null, BookmarkGrid.DEFAULT_GROUP_ID); .addItem(stackover, existsRecipe ? recipeId : null, BookmarkGrid.DEFAULT_GROUP_ID);
@@ -295,28 +431,37 @@ public abstract class ShortcutInputHandler {
private static Recipe getFocusedRecipe(ItemStack stackover, int mousex, int mousey, boolean useFavorites) { private static Recipe getFocusedRecipe(ItemStack stackover, int mousex, int mousey, boolean useFavorites) {
final GuiContainer gui = NEIClientUtils.getGuiContainer(); final GuiContainer gui = NEIClientUtils.getGuiContainer();
Recipe recipe = null;
if (useFavorites && (ItemPanels.itemPanel.contains(mousex, mousey) if (gui instanceof GuiRecipe<?>guiRecipe) {
|| ItemPanels.itemPanel.historyPanel.contains(mousex, mousey))) { final Recipe focusedRecipe = guiRecipe.getFocusedRecipe();
recipe = Recipe.of(FavoriteRecipes.getFavorite(stackover));
if (recipe != null) {
recipe.getIngredients().stream().forEach(ingr -> {
final List<ItemStack> permutations = ingr.getPermutations();
for (int index = 0; index < permutations.size(); index++) {
if (FavoriteRecipes.contains(permutations.get(index))) {
ingr.setActiveIndex(index);
break;
}
}
});
if (focusedRecipe != null) {
return focusedRecipe;
} }
}
} else if (gui instanceof GuiRecipe guiRecipe) { if (!useFavorites) {
recipe = guiRecipe.getFocusedRecipe(); return null;
}
final HoveredRecipe hovered = HoveredRecipe.of(gui, stackover);
if (hovered == null || hovered.source != HoveredRecipe.Source.ITEM_PANEL) {
return null;
}
final Recipe recipe = Recipe.of(hovered.recipeId);
if (recipe != null) {
recipe.getIngredients().stream().forEach(ingr -> {
final List<ItemStack> permutations = ingr.getPermutations();
for (int index = 0; index < permutations.size(); index++) {
if (FavoriteRecipes.contains(permutations.get(index))) {
ingr.setActiveIndex(index);
break;
}
}
});
} }
return recipe; return recipe;
@@ -340,96 +485,180 @@ public abstract class ShortcutInputHandler {
return ItemPanels.bookmarkPanel.pullBookmarkItems(math, shift); return ItemPanels.bookmarkPanel.pullBookmarkItems(math, shift);
} }
public static Map<String, String> handleHotkeys(GuiContainer gui, int mousex, int mousey, ItemStack stack) { public static Map<String, String> handleHotkeys(int mousex, int mousey, ItemStack stack) {
final int groupId = ItemPanels.bookmarkPanel.getHoveredGroupId(true); final int groupId = ItemPanels.bookmarkPanel.getHoveredGroupId(true);
if (hotkeysCache.matches(mousex, mousey, stack, groupId)) {
return hotkeysCache.hotkeys;
}
final GuiContainer gui = NEIClientUtils.getGuiContainer();
final Map<String, String> hotkeys = new HashMap<>(); final Map<String, String> hotkeys = new HashMap<>();
if (groupId != -1) { if (groupId != -1) {
final boolean isCraftingMode = ItemPanels.bookmarkPanel.getGrid().isCraftingMode(groupId);
hotkeys.put( hotkeys.put(
NEIClientConfig.getKeyName("gui.remove_recipe"), KeyManager.getKeyName("bookmark.remove_recipe", NEIClientUtils.SHIFT_HASH),
NEIClientUtils.translate("bookmark.group.remove_recipe")); NEIClientUtils.translate("bookmark.group.remove_recipe"));
hotkeys.put(
KeyManager.getKeyName("bookmark.chat_link", NEIClientUtils.CTRL_HASH),
NEIClientUtils.translate("bookmark.group.chat_link"));
if (isCraftingMode) {
hotkeys.put(
KeyManager.getKeyName("bookmark.open_crafting_tree"),
NEIClientUtils.translate("bookmark.group.open_crafting_tree"));
}
if (BookmarkContainerInfo.getBookmarkContainerHandler(gui) != null) { if (BookmarkContainerInfo.getBookmarkContainerHandler(gui) != null) {
hotkeys.put( hotkeys.put(
NEIClientConfig.getKeyName("gui.bookmark_pull_items"), KeyManager.getKeyName("bookmark.pull_items"),
NEIClientUtils.translate("bookmark.group.pull_items")); NEIClientUtils.translate("bookmark.group.pull_items"));
hotkeys.put( hotkeys.put(
NEIClientConfig.getKeyName("gui.bookmark_pull_items", NEIClientUtils.SHIFT_HASH), KeyManager.getKeyName("bookmark.pull_items", NEIClientUtils.SHIFT_HASH),
NEIClientUtils.translate("bookmark.group.pull_items_shift")); NEIClientUtils.translate("bookmark.group.pull_items_shift"));
} }
if (NEIClientConfig.autocraftingEnabled() && ItemPanels.bookmarkPanel.getGrid().isCraftingMode(groupId)) { if (NEIClientConfig.autocraftingEnabled() && isCraftingMode) {
hotkeys.put( hotkeys.put(
NEIClientConfig NEIClientConfig
.getKeyName("gui.craft_items", NEIClientUtils.SHIFT_HASH + NEIClientUtils.CTRL_HASH), .getKeyName("gui.craft_items", NEIClientUtils.SHIFT_HASH + NEIClientUtils.CTRL_HASH),
NEIClientUtils.translate("bookmark.group.craft_missing")); NEIClientUtils.translate("bookmark.group.craft_missing"));
hotkeys.put( hotkeys.put(
NEIClientConfig.getKeyName("gui.craft_items", NEIClientUtils.SHIFT_HASH), KeyManager.getKeyName("gui.craft_items", NEIClientUtils.SHIFT_HASH),
NEIClientUtils.translate("bookmark.group.craft_all")); NEIClientUtils.translate("bookmark.group.craft_all"));
} }
hotkeysCache.update(mousex, mousey, stack, groupId, hotkeys);
return hotkeys;
} }
if (stack == null) { if (stack == null) {
hotkeysCache.update(mousex, mousey, stack, groupId, hotkeys);
return hotkeys; return hotkeys;
} }
final BookmarksGridSlot slot = ItemPanels.bookmarkPanel.getSlotMouseOver(mousex, mousey); final BookmarksGridSlot slot = ItemPanels.bookmarkPanel.getSlotMouseOver(mousex, mousey);
final RecipeId recipeId = getHotkeyRecipeId(gui, mousex, mousey, stack, slot); final HoveredRecipe hovered = HoveredRecipe.of(gui, stack);
final RecipeId recipeId = hovered == null || hovered.source == HoveredRecipe.Source.OTHER
|| hovered.source == HoveredRecipe.Source.BOOKMARK && hovered.favorite ? null : hovered.recipeId;
if (slot != null) { if (slot != null) {
hotkeys.put( final BookmarkGroup group = slot.getGroup();
NEIClientConfig.getKeyName("gui.bookmark"),
NEIClientUtils.translate(slot.isIngredient() ? "bookmark.remove_item" : "bookmark.remove_recipe"));
if (slot.isIngredient()) { if (group.crafting != null && group.collapsed) {
hotkeys.put( hotkeys.put(
NEIClientConfig.getKeyName("gui.bookmark", NEIClientUtils.SHIFT_HASH), KeyManager.getKeyName("bookmark.add", NEIClientUtils.SHIFT_HASH),
NEIClientUtils.translate("bookmark.remove_recipe")); NEIClientUtils.translate("bookmark.group.remove_recipe"));
} } else if (slot.getRecipeId() == null || slot.getType() == BookmarkItemType.ITEM) {
hotkeys.put(KeyManager.getKeyName("bookmark.add"), NEIClientUtils.translate("bookmark.remove_item"));
} else if (group.crafting != null && group.crafting.recipeRelations.entrySet().stream().anyMatch(
entry -> entry.getKey().equals(slot.getRecipeId())
|| entry.getValue().contains(slot.getRecipeId()))) {
hotkeys.put(
KeyManager.getKeyName("bookmark.add", NEIClientUtils.SHIFT_HASH),
NEIClientUtils.translate("bookmark.remove_recipe"));
} else {
hotkeys.put(
KeyManager.getKeyName("bookmark.add", NEIClientUtils.SHIFT_HASH),
NEIClientUtils.translate("bookmark.remove_recipe"));
if (slot.getType() == BookmarkItemType.INGREDIENT) {
hotkeys.put(
KeyManager.getKeyName("bookmark.add"),
NEIClientUtils.translate("bookmark.remove_item"));
hotkeys.put(
KeyManager.getKeyName("bookmark.add", NEIClientUtils.SHIFT_HASH),
NEIClientUtils.translate("bookmark.remove_recipe"));
} else {
final BookmarkItem item = slot.getBookmarkItem();
if (ItemPanels.bookmarkPanel.getGrid().createChainItems(groupId).values().stream()
.noneMatch(
m -> m.type == BookmarkItemType.RESULT && !m.equals(item)
&& item.equalsRecipe(m))) {
hotkeys.put(
KeyManager.getKeyName("bookmark.add"),
NEIClientUtils.translate("bookmark.remove_recipe"));
} else {
hotkeys.put(
KeyManager.getKeyName("bookmark.add"),
NEIClientUtils.translate("bookmark.remove_item"));
hotkeys.put(
KeyManager.getKeyName("bookmark.add", NEIClientUtils.SHIFT_HASH),
NEIClientUtils.translate("bookmark.remove_recipe"));
}
}
}
if (BookmarkContainerInfo.getBookmarkContainerHandler(gui) != null) { if (BookmarkContainerInfo.getBookmarkContainerHandler(gui) != null) {
hotkeys.put( hotkeys.put(
NEIClientConfig.getKeyName("gui.bookmark_pull_items"), KeyManager.getKeyName("bookmark.pull_items"),
NEIClientUtils.translate("bookmark.group.pull_items")); NEIClientUtils.translate("bookmark.group.pull_items"));
hotkeys.put( hotkeys.put(
NEIClientConfig.getKeyName("gui.bookmark_pull_items", NEIClientUtils.SHIFT_HASH), KeyManager.getKeyName("bookmark.pull_items", NEIClientUtils.SHIFT_HASH),
NEIClientUtils.translate("bookmark.group.pull_items_shift")); NEIClientUtils.translate("bookmark.group.pull_items_shift"));
} }
} else { } else {
hotkeys.put(NEIClientConfig.getKeyName("gui.bookmark"), NEIClientUtils.translate("bookmark.add_item")); hotkeys.put(KeyManager.getKeyName("bookmark.add"), NEIClientUtils.translate("bookmark.add_item"));
if (StackInfo.getAmount(stack) > 0) { if (StackInfo.getAmount(stack) > 0) {
hotkeys.put( hotkeys.put(
NEIClientConfig.getKeyName("gui.bookmark", NEIClientUtils.CTRL_HASH), KeyManager.getKeyName("bookmark.add", NEIClientUtils.CTRL_HASH),
NEIClientUtils.translate("bookmark.add_item_with_count")); NEIClientUtils.translate("bookmark.add_item_with_count"));
} }
if (recipeId != null) { if (recipeId != null) {
hotkeys.put( hotkeys.put(
NEIClientConfig.getKeyName("gui.bookmark", NEIClientUtils.SHIFT_HASH), KeyManager.getKeyName("bookmark.add", NEIClientUtils.SHIFT_HASH + NEIClientUtils.CTRL_HASH),
NEIClientUtils.translate("bookmark.add_item_with_recipe_and_count"));
hotkeys.put(
KeyManager.getKeyName("bookmark.add", NEIClientUtils.SHIFT_HASH),
NEIClientUtils.translate("bookmark.add_item_with_recipe")); NEIClientUtils.translate("bookmark.add_item_with_recipe"));
} }
if ((ItemPanels.itemPanel.contains(mousex, mousey)
|| ItemPanels.itemPanel.historyPanel.contains(mousex, mousey)) && FavoriteRecipes.contains(stack)) {
hotkeys.put(
KeyManager.getKeyName("bookmark.favorite", NEIClientUtils.SHIFT_HASH),
NEIClientUtils.translate("recipe.favorite.bookmark_recipe"));
}
} }
hotkeys.put(NEIClientConfig.getKeyName("gui.recipe"), NEIClientUtils.translate("itempanel.open_crafting")); hotkeys.put(KeyManager.getKeyName("recipe.recipe"), NEIClientUtils.translate("itempanel.open_crafting"));
hotkeys.put(NEIClientConfig.getKeyName("gui.usage"), NEIClientUtils.translate("itempanel.open_usage")); hotkeys.put(KeyManager.getKeyName("recipe.usage"), NEIClientUtils.translate("itempanel.open_usage"));
hotkeys.put(NEIClientConfig.getKeyName("gui.copy_name"), NEIClientUtils.translate("itempanel.copy_name"));
hotkeys.put(NEIClientConfig.getKeyName("gui.copy_oredict"), NEIClientUtils.translate("itempanel.copy_oredict"));
hotkeys.put( hotkeys.put(
NEIClientConfig.getKeyName("gui.chat_link_item"), KeyManager.getKeyName("copy.name", NEIClientUtils.CTRL_HASH),
NEIClientUtils.translate("itempanel.chat_link_item")); NEIClientUtils.translate("itempanel.copy_name"));
hotkeys.put(
KeyManager.getKeyName("copy.oredict", NEIClientUtils.CTRL_HASH),
NEIClientUtils.translate("itempanel.copy_oredict"));
hotkeys.put(
KeyManager.getKeyName("copy.identifier", NEIClientUtils.CTRL_HASH),
NEIClientUtils.translate("itempanel.copy_id"));
hotkeys.put(
KeyManager.getKeyName("bookmark.chat_link", NEIClientUtils.CTRL_HASH),
NEIClientUtils.translate("bookmark.item.chat_link"));
if (!(gui instanceof GuiRecipe) && NEIClientConfig.canCheatItem(stack)) { if (!(gui instanceof GuiRecipe) && NEIClientConfig.canCheatItem(stack)) {
hotkeys.put( hotkeys.put(
NEIClientUtils.getKeyName(NEIClientUtils.SHIFT_HASH, NEIMouseUtils.MOUSE_BTN_LMB), KeyManager.getKeyName(NEIClientUtils.SHIFT_HASH, NEIMouseUtils.MOUSE_BTN_LMB),
NEIClientUtils.translate("itempanel.open_crafting")); NEIClientUtils.translate("itempanel.open_crafting"));
hotkeys.put( hotkeys.put(
NEIClientUtils.getKeyName(NEIClientUtils.SHIFT_HASH, NEIMouseUtils.MOUSE_BTN_RMB), KeyManager.getKeyName(NEIClientUtils.SHIFT_HASH, NEIMouseUtils.MOUSE_BTN_RMB),
NEIClientUtils.translate("itempanel.open_usage")); NEIClientUtils.translate("itempanel.open_usage"));
hotkeys.put(
KeyManager.getKeyName(NEIClientUtils.CTRL_HASH, NEIMouseUtils.MOUSE_BTN_LMB),
NEIClientUtils.translate("itempanel.infinite_item"));
} else { } else {
hotkeys.put( hotkeys.put(
NEIMouseUtils.getKeyName(NEIMouseUtils.MOUSE_BTN_LMB), NEIMouseUtils.getKeyName(NEIMouseUtils.MOUSE_BTN_LMB),
@@ -446,18 +675,18 @@ public abstract class ShortcutInputHandler {
if (handlerRef.canUseOverlayRenderer(gui)) { if (handlerRef.canUseOverlayRenderer(gui)) {
hotkeys.put( hotkeys.put(
NEIClientConfig.getKeyName("gui.overlay"), KeyManager.getKeyName("gui.overlay"),
NEIClientUtils.translate("itempanel.overlay_recipe")); NEIClientUtils.translate("itempanel.overlay_recipe"));
} }
if (handlerRef.canFillCraftingGrid(gui)) { if (handlerRef.canFillCraftingGrid(gui)) {
hotkeys.put( hotkeys.put(
NEIClientConfig.getKeyName("gui.overlay", NEIClientUtils.SHIFT_HASH), KeyManager.getKeyName("gui.overlay", NEIClientUtils.SHIFT_HASH),
NEIClientUtils.translate("itempanel.fill_crafting_grid")); NEIClientUtils.translate("itempanel.fill_crafting_grid"));
if (handlerRef.allowedTransferAlghoritm(gui)) { if (handlerRef.allowedTransferAlghoritm(gui)) {
hotkeys.put( hotkeys.put(
NEIClientConfig.getKeyName( KeyManager.getKeyName(
"gui.overlay", "gui.overlay",
NEIClientUtils.SHIFT_HASH + NEIClientUtils.CTRL_HASH), NEIClientUtils.SHIFT_HASH + NEIClientUtils.CTRL_HASH),
NEIClientUtils.translate("itempanel.fill_crafting_grid_quantity")); NEIClientUtils.translate("itempanel.fill_crafting_grid_quantity"));
@@ -466,18 +695,23 @@ public abstract class ShortcutInputHandler {
if (NEIClientConfig.autocraftingEnabled()) { if (NEIClientConfig.autocraftingEnabled()) {
hotkeys.put( hotkeys.put(
NEIClientConfig.getKeyName( KeyManager.getKeyName(
"gui.craft_items", "gui.craft_items",
NEIClientUtils.SHIFT_HASH + NEIClientUtils.CTRL_HASH), NEIClientUtils.SHIFT_HASH + NEIClientUtils.CTRL_HASH),
NEIClientUtils.translate("itempanel.craft_missing")); NEIClientUtils.translate("itempanel.craft_missing"));
hotkeys.put( hotkeys.put(
NEIClientConfig.getKeyName("gui.craft_items", NEIClientUtils.SHIFT_HASH), KeyManager.getKeyName("gui.craft_items", NEIClientUtils.SHIFT_HASH),
NEIClientUtils.translate("itempanel.craft_all")); NEIClientUtils.translate("itempanel.craft_all"));
} }
} }
hotkeys.put(
KeyManager.getKeyName("bookmark.chat_link", NEIClientUtils.SHIFT_HASH + NEIClientUtils.CTRL_HASH),
NEIClientUtils.translate("bookmark.recipe.chat_link"));
} }
hotkeysCache.update(mousex, mousey, stack, groupId, hotkeys);
return hotkeys; return hotkeys;
} }
@@ -486,8 +720,10 @@ public abstract class ShortcutInputHandler {
final List<ItemStack> playerInventory = AutoCraftingManager.getInventoryItems(guiContainer).values(); final List<ItemStack> playerInventory = AutoCraftingManager.getInventoryItems(guiContainer).values();
final RecipeId rootRecipeId = math.createMasterRoot(); final RecipeId rootRecipeId = math.createMasterRoot();
for (BookmarkItem item : math.recipeIngredients) { for (int i = 0; i < math.recipeIngredients.size(); i++) {
if (item.amount > 0 && rootRecipeId.equals(item.recipeId)) { final BookmarkItem item = math.recipeIngredients.get(i);
if (item.getAmount() > 0 && rootRecipeId.equals(item.recipeId)) {
long amount = 0; long amount = 0;
for (ItemStack stack : playerInventory) { for (ItemStack stack : playerInventory) {
@@ -496,31 +732,15 @@ public abstract class ShortcutInputHandler {
} }
} }
if (amount >= item.amount) { if (amount >= item.getAmount()) {
item.factor = item.amount = amount + item.amount - (amount % item.amount); math.recipeIngredients.set(
i,
BookmarkItem.builder(item).multiplier(1)
.factor(amount + item.getAmount() - (amount % item.getAmount()))
.chance(PositionedStack.CHANCE_FULL).build());
} }
} }
} }
} }
private static RecipeId getHotkeyRecipeId(GuiContainer gui, int mousex, int mousey, ItemStack stack,
BookmarksGridSlot slot) {
if (slot != null) {
return slot.isIngredient() ? null : slot.getRecipeId();
} else if (ItemPanels.itemPanel.contains(mousex, mousey)
|| ItemPanels.itemPanel.historyPanel.contains(mousex, mousey)) {
return FavoriteRecipes.getFavorite(stack);
} else
if (gui instanceof GuiRecipe guiRecipe) {
final Recipe focusedRecipe = guiRecipe.getFocusedRecipe();
if (focusedRecipe != null) {
return focusedRecipe.getRecipeId();
}
}
return null;
}
} }
Loaded 100 of 299 files, more files were not shown because too many files have changed in this diff. Show more