769 lines
17 KiB
Java
769 lines
17 KiB
Java
/*
|
|
* This file is part of Applied Energistics 2.
|
|
* Copyright (c) 2013 - 2015, AlgorithmX2, All rights reserved.
|
|
*
|
|
* Applied Energistics 2 is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* Applied Energistics 2 is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with Applied Energistics 2. If not, see <http://www.gnu.org/licenses/lgpl>.
|
|
*/
|
|
|
|
package appeng.recipes;
|
|
|
|
|
|
import java.io.BufferedReader;
|
|
import java.io.FileNotFoundException;
|
|
import java.io.FileOutputStream;
|
|
import java.io.IOException;
|
|
import java.util.HashMap;
|
|
import java.util.LinkedList;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Map.Entry;
|
|
import java.util.zip.ZipEntry;
|
|
import java.util.zip.ZipOutputStream;
|
|
|
|
import javax.annotation.Nonnull;
|
|
|
|
import net.minecraft.item.Item;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraftforge.fml.common.LoaderState;
|
|
import net.minecraftforge.fml.common.registry.GameRegistry;
|
|
import net.minecraftforge.fml.common.registry.GameRegistry.UniqueIdentifier;
|
|
import appeng.api.AEApi;
|
|
import appeng.api.definitions.IBlocks;
|
|
import appeng.api.definitions.IDefinitions;
|
|
import appeng.api.definitions.IItems;
|
|
import appeng.api.exceptions.MissingIngredientError;
|
|
import appeng.api.exceptions.RecipeError;
|
|
import appeng.api.exceptions.RegistrationError;
|
|
import appeng.api.features.IRecipeHandlerRegistry;
|
|
import appeng.api.recipes.ICraftHandler;
|
|
import appeng.api.recipes.IIngredient;
|
|
import appeng.api.recipes.IRecipeHandler;
|
|
import appeng.api.recipes.IRecipeLoader;
|
|
import appeng.core.AEConfig;
|
|
import appeng.core.AELog;
|
|
import appeng.core.AppEng;
|
|
import appeng.core.features.AEFeature;
|
|
import appeng.items.materials.MultiItem;
|
|
import appeng.items.misc.ItemCrystalSeed;
|
|
import appeng.items.parts.ItemMultiPart;
|
|
import appeng.recipes.handlers.IWebsiteSerializer;
|
|
import appeng.recipes.handlers.OreRegistration;
|
|
|
|
import com.google.common.base.Optional;
|
|
import com.google.common.collect.HashMultimap;
|
|
|
|
|
|
/**
|
|
* @author AlgorithmX2
|
|
* @author thatsIch
|
|
* @version rv2
|
|
* @since rv0
|
|
*/
|
|
public class RecipeHandler implements IRecipeHandler
|
|
{
|
|
|
|
public final List<String> tokens = new LinkedList<String>();
|
|
final RecipeData data;
|
|
|
|
public RecipeHandler()
|
|
{
|
|
this.data = new RecipeData();
|
|
}
|
|
|
|
RecipeHandler( RecipeHandler parent )
|
|
{
|
|
this.data = parent.data;
|
|
}
|
|
|
|
private void addCrafting( ICraftHandler ch )
|
|
{
|
|
this.data.Handlers.add( ch );
|
|
}
|
|
|
|
public String getName( @Nonnull IIngredient i )
|
|
{
|
|
try
|
|
{
|
|
for( ItemStack is : i.getItemStackSet() )
|
|
{
|
|
return this.getName( is );
|
|
}
|
|
}
|
|
catch( RecipeError ignored )
|
|
{
|
|
}
|
|
catch( Throwable t )
|
|
{
|
|
t.printStackTrace();
|
|
// :P
|
|
}
|
|
|
|
return i.getNameSpace() + ':' + i.getItemName();
|
|
}
|
|
|
|
public String getName( ItemStack is ) throws RecipeError
|
|
{
|
|
UniqueIdentifier id = GameRegistry.findUniqueIdentifierFor( is.getItem() );
|
|
String realName = id.modId + ':' + id.name;
|
|
|
|
if( !id.modId.equals( AppEng.MOD_ID ) && !id.modId.equals( "minecraft" ) )
|
|
{
|
|
throw new RecipeError( "Not applicable for website" );
|
|
}
|
|
|
|
final IDefinitions definitions = AEApi.instance().definitions();
|
|
final IItems items = definitions.items();
|
|
final IBlocks blocks = definitions.blocks();
|
|
|
|
final Optional<Item> maybeCrystalSeedItem = items.crystalSeed().maybeItem();
|
|
final Optional<Item> maybeSkyStoneItem = blocks.skyStone().maybeItem();
|
|
final Optional<Item> maybeCStorageItem = blocks.craftingStorage1k().maybeItem();
|
|
final Optional<Item> maybeCUnitItem = blocks.craftingUnit().maybeItem();
|
|
final Optional<Item> maybeSkyChestItem = blocks.skyChest().maybeItem();
|
|
|
|
if( maybeCrystalSeedItem.isPresent() && is.getItem() == maybeCrystalSeedItem.get() )
|
|
{
|
|
int dmg = is.getItemDamage();
|
|
if( dmg < ItemCrystalSeed.NETHER )
|
|
{
|
|
realName += ".Certus";
|
|
}
|
|
else if( dmg < ItemCrystalSeed.FLUIX )
|
|
{
|
|
realName += ".Nether";
|
|
}
|
|
else if( dmg < ItemCrystalSeed.FINAL_STAGE )
|
|
{
|
|
realName += ".Fluix";
|
|
}
|
|
}
|
|
else if( maybeSkyStoneItem.isPresent() && is.getItem() == maybeSkyStoneItem.get() )
|
|
{
|
|
switch( is.getItemDamage() )
|
|
{
|
|
case 1:
|
|
realName += ".Block";
|
|
break;
|
|
case 2:
|
|
realName += ".Brick";
|
|
break;
|
|
case 3:
|
|
realName += ".SmallBrick";
|
|
break;
|
|
default:
|
|
}
|
|
}
|
|
else if( maybeCStorageItem.isPresent() && is.getItem() == maybeCStorageItem.get() )
|
|
{
|
|
switch( is.getItemDamage() )
|
|
{
|
|
case 1:
|
|
realName += "4k";
|
|
break;
|
|
case 2:
|
|
realName += "16k";
|
|
break;
|
|
case 3:
|
|
realName += "64k";
|
|
break;
|
|
default:
|
|
}
|
|
}
|
|
else if( maybeCUnitItem.isPresent() && is.getItem() == maybeCUnitItem.get() )
|
|
{
|
|
switch( is.getItemDamage() )
|
|
{
|
|
case 1:
|
|
realName = realName.replace( "Unit", "Accelerator" );
|
|
break;
|
|
default:
|
|
}
|
|
}
|
|
else if( maybeSkyChestItem.isPresent() && is.getItem() == maybeSkyChestItem.get() )
|
|
{
|
|
switch( is.getItemDamage() )
|
|
{
|
|
case 1:
|
|
realName += ".Block";
|
|
break;
|
|
default:
|
|
}
|
|
}
|
|
else if( is.getItem() instanceof MultiItem )
|
|
{
|
|
realName = realName.replace( "ItemMultiMaterial", "ItemMaterial" );
|
|
realName += '.' + ( (MultiItem) is.getItem() ).getTypeByStack( is ).name();
|
|
}
|
|
else if( is.getItem() instanceof ItemMultiPart )
|
|
{
|
|
realName = realName.replace( "ItemMultiPart", "ItemPart" );
|
|
realName += '.' + ( (ItemMultiPart) is.getItem() ).getTypeByStack( is ).name();
|
|
}
|
|
else if( is.getItemDamage() > 0 )
|
|
{
|
|
realName += "." + is.getItemDamage();
|
|
}
|
|
|
|
return realName;
|
|
}
|
|
|
|
public String alias( String in )
|
|
{
|
|
String out = this.data.aliases.get( in );
|
|
|
|
if( out != null )
|
|
{
|
|
return out;
|
|
}
|
|
|
|
return in;
|
|
}
|
|
|
|
@Override
|
|
public void parseRecipes( IRecipeLoader loader, String path )
|
|
{
|
|
try
|
|
{
|
|
BufferedReader reader = null;
|
|
try
|
|
{
|
|
reader = loader.getFile( path );
|
|
}
|
|
catch( Exception err )
|
|
{
|
|
AELog.warning( "Error Loading Recipe File:" + path );
|
|
if( this.data.exceptions )
|
|
{
|
|
AELog.error( err );
|
|
}
|
|
return;
|
|
}
|
|
|
|
boolean inQuote = false;
|
|
boolean inComment = false;
|
|
|
|
String token = "";
|
|
int line = 0;
|
|
|
|
int val = -1;
|
|
while( ( val = reader.read() ) != -1 )
|
|
{
|
|
char c = (char) val;
|
|
|
|
if( c == '\n' )
|
|
{
|
|
line++;
|
|
}
|
|
|
|
if( inComment )
|
|
{
|
|
if( c == '\n' || c == '\r' )
|
|
{
|
|
inComment = false;
|
|
}
|
|
}
|
|
else if( inQuote )
|
|
{
|
|
switch( c )
|
|
{
|
|
case '"':
|
|
inQuote = !inQuote;
|
|
break;
|
|
default:
|
|
token += c;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch( c )
|
|
{
|
|
case '"':
|
|
inQuote = !inQuote;
|
|
break;
|
|
case ',':
|
|
|
|
if( token.length() > 0 )
|
|
{
|
|
this.tokens.add( token );
|
|
this.tokens.add( "," );
|
|
}
|
|
token = "";
|
|
break;
|
|
|
|
case '=':
|
|
|
|
this.processTokens( loader, path, line );
|
|
|
|
if( token.length() > 0 )
|
|
{
|
|
this.tokens.add( token );
|
|
}
|
|
token = "";
|
|
|
|
break;
|
|
|
|
case '#':
|
|
inComment = true;
|
|
// then add a token if you can...
|
|
|
|
case '\n':
|
|
case '\t':
|
|
case '\r':
|
|
case ' ':
|
|
|
|
if( token.length() > 0 )
|
|
{
|
|
this.tokens.add( token );
|
|
}
|
|
token = "";
|
|
|
|
break;
|
|
default:
|
|
token += c;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( token.length() > 0 )
|
|
{
|
|
this.tokens.add( token );
|
|
}
|
|
|
|
reader.close();
|
|
this.processTokens( loader, path, line );
|
|
}
|
|
catch( Throwable e )
|
|
{
|
|
AELog.error( e );
|
|
if( this.data.crash )
|
|
{
|
|
throw new IllegalStateException( e );
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void injectRecipes()
|
|
{
|
|
if( net.minecraftforge.fml.common.Loader.instance().hasReachedState( LoaderState.POSTINITIALIZATION ) )
|
|
{
|
|
throw new IllegalStateException( "Recipes must now be loaded in Init." );
|
|
}
|
|
|
|
Map<Class, Integer> processed = new HashMap<Class, Integer>();
|
|
try
|
|
{
|
|
for( ICraftHandler ch : this.data.Handlers )
|
|
{
|
|
try
|
|
{
|
|
ch.register();
|
|
|
|
Class clz = ch.getClass();
|
|
Integer i = processed.get( clz );
|
|
if( i == null )
|
|
{
|
|
processed.put( clz, 1 );
|
|
}
|
|
else
|
|
{
|
|
processed.put( clz, i + 1 );
|
|
}
|
|
}
|
|
catch( RegistrationError e )
|
|
{
|
|
AELog.warning( "Unable to register a recipe: " + e.getMessage() );
|
|
if( this.data.exceptions )
|
|
{
|
|
AELog.error( e );
|
|
}
|
|
if( this.data.crash )
|
|
{
|
|
throw e;
|
|
}
|
|
}
|
|
catch( MissingIngredientError e )
|
|
{
|
|
if( this.data.errorOnMissing )
|
|
{
|
|
AELog.warning( "Unable to register a recipe:" + e.getMessage() );
|
|
if( this.data.exceptions )
|
|
{
|
|
AELog.error( e );
|
|
}
|
|
if( this.data.crash )
|
|
{
|
|
throw e;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch( Throwable e )
|
|
{
|
|
if( this.data.exceptions )
|
|
{
|
|
AELog.error( e );
|
|
}
|
|
if( this.data.crash )
|
|
{
|
|
throw new IllegalStateException( e );
|
|
}
|
|
}
|
|
|
|
for( Entry<Class, Integer> e : processed.entrySet() )
|
|
{
|
|
AELog.info( "Recipes Loading: " + e.getKey().getSimpleName() + ": " + e.getValue() + " loaded." );
|
|
}
|
|
|
|
if( AEConfig.instance.isFeatureEnabled( AEFeature.WebsiteRecipes ) )
|
|
{
|
|
try
|
|
{
|
|
ZipOutputStream out = new ZipOutputStream( new FileOutputStream( "recipes.zip" ) );
|
|
|
|
HashMultimap<String, IWebsiteSerializer> combined = HashMultimap.create();
|
|
|
|
for( String s : this.data.knownItem )
|
|
{
|
|
try
|
|
{
|
|
|
|
Ingredient i = new Ingredient( this, s, 1 );
|
|
|
|
for( ItemStack is : i.getItemStackSet() )
|
|
{
|
|
String realName = this.getName( is );
|
|
List<IWebsiteSerializer> recipes = this.findRecipe( is );
|
|
if( !recipes.isEmpty() )
|
|
{
|
|
combined.putAll( realName, recipes );
|
|
}
|
|
}
|
|
}
|
|
catch( RecipeError ignored )
|
|
{
|
|
|
|
}
|
|
catch( MissedIngredientSet ignored )
|
|
{
|
|
|
|
}
|
|
catch( RegistrationError ignored )
|
|
{
|
|
|
|
}
|
|
catch( MissingIngredientError ignored )
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
for( String realName : combined.keySet() )
|
|
{
|
|
int offset = 0;
|
|
|
|
for( IWebsiteSerializer ws : combined.get( realName ) )
|
|
{
|
|
String rew = ws.getPattern( this );
|
|
if( rew != null && rew.length() > 0 )
|
|
{
|
|
out.putNextEntry( new ZipEntry( realName + '_' + offset + ".txt" ) );
|
|
offset++;
|
|
out.write( rew.getBytes() );
|
|
}
|
|
}
|
|
}
|
|
|
|
out.close();
|
|
}
|
|
catch( FileNotFoundException e1 )
|
|
{
|
|
AELog.error( e1 );
|
|
}
|
|
catch( IOException e1 )
|
|
{
|
|
AELog.error( e1 );
|
|
}
|
|
}
|
|
}
|
|
|
|
public List<IWebsiteSerializer> findRecipe( ItemStack output )
|
|
{
|
|
List<IWebsiteSerializer> out = new LinkedList<IWebsiteSerializer>();
|
|
|
|
for( ICraftHandler ch : this.data.Handlers )
|
|
{
|
|
try
|
|
{
|
|
if( ch instanceof IWebsiteSerializer && ( (IWebsiteSerializer) ch ).canCraft( output ) )
|
|
{
|
|
out.add( (IWebsiteSerializer) ch );
|
|
}
|
|
}
|
|
catch( Throwable t )
|
|
{
|
|
AELog.error( t );
|
|
}
|
|
}
|
|
|
|
return out;
|
|
}
|
|
|
|
private void processTokens( IRecipeLoader loader, String file, int line ) throws RecipeError
|
|
{
|
|
try
|
|
{
|
|
IRecipeHandlerRegistry cr = AEApi.instance().registries().recipes();
|
|
|
|
if( this.tokens.isEmpty() )
|
|
{
|
|
return;
|
|
}
|
|
|
|
int split = this.tokens.indexOf( "->" );
|
|
if( split != -1 )
|
|
{
|
|
String operation = this.tokens.remove( 0 ).toLowerCase();
|
|
|
|
if( operation.equals( "alias" ) )
|
|
{
|
|
if( this.tokens.size() == 3 && this.tokens.indexOf( "->" ) == 1 )
|
|
{
|
|
this.data.aliases.put( this.tokens.get( 0 ), this.tokens.get( 2 ) );
|
|
}
|
|
else
|
|
{
|
|
throw new RecipeError( "Alias must have exactly 1 input and 1 output." );
|
|
}
|
|
}
|
|
else if( operation.equals( "group" ) )
|
|
{
|
|
List<String> pre = this.tokens.subList( 0, split - 1 );
|
|
List<String> post = this.tokens.subList( split, this.tokens.size() );
|
|
|
|
List<List<IIngredient>> inputs = this.parseLines( pre );
|
|
|
|
if( inputs.size() == 1 && inputs.get( 0 ).size() > 0 && post.size() == 1 )
|
|
{
|
|
this.data.groups.put( post.get( 0 ), new GroupIngredient( post.get( 0 ), inputs.get( 0 ) ) );
|
|
}
|
|
else
|
|
{
|
|
throw new RecipeError( "Group must have exactly 1 output, and 1 or more inputs." );
|
|
}
|
|
}
|
|
else if( operation.equals( "ore" ) )
|
|
{
|
|
List<String> pre = this.tokens.subList( 0, split - 1 );
|
|
List<String> post = this.tokens.subList( split, this.tokens.size() );
|
|
|
|
List<List<IIngredient>> inputs = this.parseLines( pre );
|
|
|
|
if( inputs.size() == 1 && inputs.get( 0 ).size() > 0 && post.size() == 1 )
|
|
{
|
|
ICraftHandler ch = new OreRegistration( inputs.get( 0 ), post.get( 0 ) );
|
|
this.addCrafting( ch );
|
|
}
|
|
else
|
|
{
|
|
throw new RecipeError( "Group must have exactly 1 output, and 1 or more inputs in a single row." );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
List<String> pre = this.tokens.subList( 0, split - 1 );
|
|
List<String> post = this.tokens.subList( split, this.tokens.size() );
|
|
|
|
List<List<IIngredient>> inputs = this.parseLines( pre );
|
|
List<List<IIngredient>> outputs = this.parseLines( post );
|
|
|
|
ICraftHandler ch = cr.getCraftHandlerFor( operation );
|
|
|
|
if( ch != null )
|
|
{
|
|
ch.setup( inputs, outputs );
|
|
this.addCrafting( ch );
|
|
}
|
|
else
|
|
{
|
|
throw new RecipeError( "Invalid crafting type: " + operation );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
String operation = this.tokens.remove( 0 ).toLowerCase();
|
|
|
|
if( operation.equals( "exceptions" ) && ( this.tokens.get( 0 ).equals( "true" ) || this.tokens.get( 0 ).equals( "false" ) ) )
|
|
{
|
|
if( this.tokens.size() == 1 )
|
|
{
|
|
this.data.exceptions = this.tokens.get( 0 ).equals( "true" );
|
|
}
|
|
else
|
|
{
|
|
throw new RecipeError( "exceptions must be true or false explicitly." );
|
|
}
|
|
}
|
|
else if( operation.equals( "crash" ) && ( this.tokens.get( 0 ).equals( "true" ) || this.tokens.get( 0 ).equals( "false" ) ) )
|
|
{
|
|
if( this.tokens.size() == 1 )
|
|
{
|
|
this.data.crash = this.tokens.get( 0 ).equals( "true" );
|
|
}
|
|
else
|
|
{
|
|
throw new RecipeError( "crash must be true or false explicitly." );
|
|
}
|
|
}
|
|
else if( operation.equals( "erroronmissing" ) )
|
|
{
|
|
if( this.tokens.size() == 1 && ( this.tokens.get( 0 ).equals( "true" ) || this.tokens.get( 0 ).equals( "false" ) ) )
|
|
{
|
|
this.data.errorOnMissing = this.tokens.get( 0 ).equals( "true" );
|
|
}
|
|
else
|
|
{
|
|
throw new RecipeError( "erroronmissing must be true or false explicitly." );
|
|
}
|
|
}
|
|
else if( operation.equals( "import" ) )
|
|
{
|
|
if( this.tokens.size() == 1 )
|
|
{
|
|
( new RecipeHandler( this ) ).parseRecipes( loader, this.tokens.get( 0 ) );
|
|
}
|
|
else
|
|
{
|
|
throw new RecipeError( "Import must have exactly 1 input." );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw new RecipeError( operation + ": " + this.tokens.toString() + "; recipe without an output." );
|
|
}
|
|
}
|
|
}
|
|
catch( RecipeError e )
|
|
{
|
|
AELog.warning( "Recipe Error '" + e.getMessage() + "' near line:" + line + " in " + file + " with: " + this.tokens.toString() );
|
|
if( this.data.exceptions )
|
|
{
|
|
AELog.error( e );
|
|
}
|
|
if( this.data.crash )
|
|
{
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
this.tokens.clear();
|
|
}
|
|
|
|
private List<List<IIngredient>> parseLines( List<String> subList ) throws RecipeError
|
|
{
|
|
List<List<IIngredient>> out = new LinkedList<List<IIngredient>>();
|
|
List<IIngredient> cList = new LinkedList<IIngredient>();
|
|
|
|
boolean hasQty = false;
|
|
int qty = 1;
|
|
|
|
for( String v : subList )
|
|
{
|
|
if( v.equals( "," ) )
|
|
{
|
|
if( hasQty )
|
|
{
|
|
throw new RecipeError( "Qty found with no item." );
|
|
}
|
|
if( !cList.isEmpty() )
|
|
{
|
|
out.add( cList );
|
|
}
|
|
cList = new LinkedList<IIngredient>();
|
|
}
|
|
else
|
|
{
|
|
if( this.isNumber( v ) )
|
|
{
|
|
if( hasQty )
|
|
{
|
|
throw new RecipeError( "Qty found with no item." );
|
|
}
|
|
hasQty = true;
|
|
qty = Integer.parseInt( v );
|
|
}
|
|
else
|
|
{
|
|
if( hasQty )
|
|
{
|
|
cList.add( this.findIngredient( v, qty ) );
|
|
hasQty = false;
|
|
}
|
|
else
|
|
{
|
|
cList.add( this.findIngredient( v, 1 ) );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if( !cList.isEmpty() )
|
|
{
|
|
out.add( cList );
|
|
}
|
|
|
|
return out;
|
|
}
|
|
|
|
private IIngredient findIngredient( String v, int qty ) throws RecipeError
|
|
{
|
|
GroupIngredient gi = this.data.groups.get( v );
|
|
|
|
if( gi != null )
|
|
{
|
|
return gi.copy( qty );
|
|
}
|
|
|
|
try
|
|
{
|
|
return new Ingredient( this, v, qty );
|
|
}
|
|
catch( MissedIngredientSet grp )
|
|
{
|
|
return new IngredientSet( grp.rrs );
|
|
}
|
|
}
|
|
|
|
private boolean isNumber( String v )
|
|
{
|
|
if( v.length() <= 0 )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
int l = v.length();
|
|
for( int x = 0; x < l; x++ )
|
|
{
|
|
if( !Character.isDigit( v.charAt( x ) ) )
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|