Change package name for realsies now :P

This commit is contained in:
Arona Jones committed 2014-12-15 00:11:48 +00:00
1 parent 4d8df815cc
commit dae454dc17
138 files changed
+491 -438

No files matched your search

@@ -0,0 +1,116 @@
package com.cricketcraft.chisel;
import java.util.HashMap;
import com.cricketcraft.chisel.utils.General;
import net.minecraft.block.Block;
import net.minecraft.item.Item;
import cpw.mods.fml.common.FMLLog;
import cpw.mods.fml.common.registry.GameRegistry;
public class BlockNameConversion
{
static final private HashMap<String, String> namingConversion = new HashMap<String, String>();
public static class NameConversions
{
public final static int MAX = 5;
protected static String conversion(String oldname, int step)
{
oldname = General.cleanTags(oldname);
String newname = null;
switch (step) {
case 0: // lookup list
return namingConversion.get(oldname);
case 1: // remove Chisel:
if(oldname.startsWith("Chisel:")){
newname = oldname.replaceAll("(?i)" + "Chisel:", "");
}
return newname;
case 2: // rename "marbleSlab" -> "marble_slab", "redstone" -> "redstone_block"
newname = oldname.replaceAll("([a-z]+)([A-Z])", "$1_$2").toLowerCase();
if (newname.startsWith("block_"))
{
newname = newname.replaceFirst("block_([a-z_]+)", "$1_block");
}
else if (newname.startsWith("snakestone_"))
{
newname = newname.replaceFirst("snakestone_([a-z_]+)", "$1_snakestone");
}
return newname;
case 3: // rename "wood-dark-oak" -> "dark_oak_planks"
newname = oldname.replaceAll("([a-z]+)([A-Z])", "$1_$2").toLowerCase().replace('-', '_');
if (newname.contains("wood_"))
{
newname = newname.replaceFirst("wood_([a-z_]+)", "$1_planks");
}
return newname;
case (MAX - 1): // ALWAYS last: rename "blockYxx" -> "yxx" (e.g. "dirt" -> "dirt").
// This can be dangerous in cases like "carpet" (a block) -> "carpet" (NO block)
return oldname.replaceAll("([a-z]+)([A-Z])", "$1_$2").toLowerCase().replaceFirst("block_", "");
default:
throw new IndexOutOfBoundsException("conversion got invalid parameter step=" + step);
}
}
}
static public void init()
{
namingConversion.put("blockCobble", "cobblestone");
namingConversion.put("iron", "iron_block");
namingConversion.put("gold", "gold_block");
namingConversion.put("diamond", "diamond_block");
namingConversion.put("lightstone", "glowstone");
namingConversion.put("lapis", "lapis_block");
namingConversion.put("emerald", "emerald_block");
namingConversion.put("hellrock", "netherrack");
namingConversion.put("stoneMoss", "mossy_cobblestone");
namingConversion.put("stoneBrick", "stonebrick");
namingConversion.put("fenceIron", "iron_bars");
namingConversion.put("fantasy", "fantasyblock");
namingConversion.put("carpetFloor", "carpet");
namingConversion.put("temple", "templeblock");
namingConversion.put("templeMossy", "mossy_templeblock");
namingConversion.put("factory", "factoryblock");
namingConversion.put("laboratory", "laboratoryblock");
// "LightGray" is unfortunately converted to "light_gray"
namingConversion.put("stainedGlassLightGray", "stained_glass_lightgray");
namingConversion.put("stainedGlassPaneLightGray", "stained_glass_pane_lightgray");
namingConversion.put("blockTemple", "templeblock");
namingConversion.put("stoneBrick", "stonebricksmooth");
namingConversion.put("blockTempleMossy", "mossy_templeblock");
namingConversion.put("blockFactory", "factoryblock");
namingConversion.put("blockFft", "fantasyblock");
namingConversion.put("blockCarpetFloor", "carpet");
namingConversion.put("blockLaboratory", "laboratoryblock");
}
public static Item findItem(String oldname)
{
FMLLog.getLogger().trace("[Chisel 2] findItem() START " + oldname);
Item item = null;
for (int i = 0; i < NameConversions.MAX && item == null; i++)
{
FMLLog.getLogger().trace("[Chisel 2] findItem() Checking for " + NameConversions.conversion(oldname, i));
item = GameRegistry.findItem(Chisel.MOD_ID, NameConversions.conversion(oldname, i));
}
return item;
}
public static Block findBlock(String oldname)
{
FMLLog.getLogger().trace("[Chisel 2] findBlock() START: " + oldname);
Block block = null;
for (int i = 0; i < NameConversions.MAX && block == null; i++)
{
FMLLog.getLogger().trace("[Chisel 2] findBlock() Checking for " + NameConversions.conversion(oldname, i));
block = GameRegistry.findBlock(Chisel.MOD_ID, NameConversions.conversion(oldname, i));
}
return block;
}
}
@@ -0,0 +1,205 @@
package com.cricketcraft.chisel;
import java.io.File;
import com.cricketcraft.chisel.block.BlockCarvable;
import com.cricketcraft.chisel.block.tileentity.TileEntityAutoChisel;
import com.cricketcraft.chisel.block.tileentity.TileEntityPresent;
import com.cricketcraft.chisel.client.gui.GuiAutoChisel;
import com.cricketcraft.chisel.client.gui.GuiChisel;
import com.cricketcraft.chisel.client.gui.GuiPresent;
import com.cricketcraft.chisel.compat.Compatibility;
import com.cricketcraft.chisel.compat.FMPIntegration;
import com.cricketcraft.chisel.compat.ModIntegration;
import com.cricketcraft.chisel.init.ModBlocks;
import com.cricketcraft.chisel.init.ModItems;
import com.cricketcraft.chisel.init.ModTabs;
import com.cricketcraft.chisel.inventory.ContainerAutoChisel;
import com.cricketcraft.chisel.inventory.ContainerChisel;
import com.cricketcraft.chisel.inventory.ContainerPresent;
import com.cricketcraft.chisel.inventory.InventoryChiselSelection;
import com.cricketcraft.chisel.proxy.CommonProxy;
import com.cricketcraft.chisel.utils.General;
import com.cricketcraft.chisel.world.GeneratorLimestone;
import com.cricketcraft.chisel.world.GeneratorMarble;
import net.minecraft.block.Block;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.common.config.Configuration;
import cpw.mods.fml.client.event.ConfigChangedEvent;
import cpw.mods.fml.common.FMLCommonHandler;
import cpw.mods.fml.common.FMLLog;
import cpw.mods.fml.common.Mod;
import cpw.mods.fml.common.Mod.EventHandler;
import cpw.mods.fml.common.Mod.Instance;
import cpw.mods.fml.common.SidedProxy;
import cpw.mods.fml.common.event.FMLInitializationEvent;
import cpw.mods.fml.common.event.FMLInterModComms;
import cpw.mods.fml.common.event.FMLMissingMappingsEvent;
import cpw.mods.fml.common.event.FMLMissingMappingsEvent.MissingMapping;
import cpw.mods.fml.common.event.FMLPostInitializationEvent;
import cpw.mods.fml.common.event.FMLPreInitializationEvent;
import cpw.mods.fml.common.eventhandler.SubscribeEvent;
import cpw.mods.fml.common.network.IGuiHandler;
import cpw.mods.fml.common.network.NetworkRegistry;
import cpw.mods.fml.common.registry.GameRegistry;
import cpw.mods.fml.common.registry.GameRegistry.Type;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
@Mod(modid = Chisel.MOD_ID, name = Chisel.MOD_NAME, version = Chisel.VERSION, guiFactory = "com.cricketcraft.chisel.client.gui.GuiFactory", dependencies = "after:ForgeMultipart;")
public class Chisel
{
public static final String MOD_ID = "chisel";
public static final BlockCarvable.SoundType soundTempleFootstep = new BlockCarvable.SoundType("dig.stone", MOD_ID + ":step.templeblock", 1.0f, 1.0f);
public static final String MOD_NAME = "Chisel 2";
public static final String VERSION = "2.1.3";
public static final BlockCarvable.SoundType soundHolystoneFootstep = new BlockCarvable.SoundType("holystone", 1.0f, 1.0f);
public static final BlockCarvable.SoundType soundMetalFootstep = new BlockCarvable.SoundType("metal", 1.0f, 1.0f);
public static boolean multipartLoaded = false;
public static int RenderEldritchId;
public static int RenderCTMId;
public static int RenderCarpetId;
@Instance(MOD_ID)
public static Chisel instance;
@SidedProxy(clientSide = "com.cricketcraft.chisel.proxy.ClientProxy", serverSide = "com.cricketcraft.chisel.proxy.CommonProxy")
public static CommonProxy proxy;
@SideOnly(Side.CLIENT)
private static void initModIntegration() {
if(Configurations.enableFMP) {
ModIntegration.addMod(FMPIntegration.class);
}
ModIntegration.init();
}
@EventHandler
public void missingMapping(FMLMissingMappingsEvent event) {
BlockNameConversion.init();
for (MissingMapping m : event.get()) {
// This bug was introduced along with Chisel 1.5.2, and was fixed in 1.5.3.
// Ice Stairs were called null.0-7 instead of other names, and Marble/Limestone stairs did not exist.
// This fixes the bug.
if (m.name.startsWith("null.") && m.name.length() == 6 && m.type == Type.BLOCK) {
m.warn();//(Action.WARN);
}
// Fix mapping of snakestoneSand, snakestoneStone, limestoneStairs, marbleStairs when loading an old (1.5.4) save
else if (m.type == Type.BLOCK) {
final Block block = BlockNameConversion.findBlock(m.name);
if (block != null) {
m.remap(block);
FMLLog.getLogger().info("Remapping block " + m.name + " to " + General.getName(block));
} else
FMLLog.getLogger().warn("Block " + m.name + " could not get remapped.");
} else if (m.type == Type.ITEM) {
final Item item = BlockNameConversion.findItem(m.name);
if (item != null) {
m.remap(item);
FMLLog.getLogger().info("Remapping item " + m.name + " to " + General.getName(item));
} else
FMLLog.getLogger().warn("Item " + m.name + " could not get remapped.");
}
}
}
@EventHandler
public void preInit(FMLPreInitializationEvent event) {
File configFile = event.getSuggestedConfigurationFile();
Configurations.configExists = configFile.exists();
Configurations.config = new Configuration(configFile);
Configurations.config.load();
Configurations.refreshConfig();
ModTabs.load();
ModBlocks.load();
ModItems.load();
proxy.preInit();
}
@EventHandler
public void init(FMLInitializationEvent event)
{
Crafting.init();
NetworkRegistry.INSTANCE.registerGuiHandler(this, new IGuiHandler() {
@Override
public Object getServerGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) {
switch (ID) {
case 0:
return new ContainerChisel(player.inventory, new InventoryChiselSelection(null));
case 1:
TileEntity tileentity = world.getTileEntity(x, y, z);
if (tileentity instanceof TileEntityAutoChisel)
return new ContainerAutoChisel(player.inventory, (TileEntityAutoChisel) tileentity);
case 2:
TileEntity tileEntity = world.getTileEntity(x, y, z);
if (tileEntity instanceof TileEntityPresent)
return new ContainerPresent(player.inventory, (TileEntityPresent) tileEntity);
default:
return null;
}
}
@Override
public Object getClientGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) {
switch (ID) {
case 0:
return new GuiChisel(player.inventory, new InventoryChiselSelection(null));
case 1:
TileEntity tileentity = world.getTileEntity(x, y, z);
if (tileentity instanceof TileEntityAutoChisel)
return new GuiAutoChisel(player.inventory, (TileEntityAutoChisel) tileentity);
case 2:
TileEntity tileEntity = world.getTileEntity(x, y, z);
if (tileEntity instanceof TileEntityPresent)
return new GuiPresent(player.inventory, (TileEntityPresent) tileEntity);
default:
return null;
}
}
});
GameRegistry.registerWorldGenerator(new GeneratorMarble(ModBlocks.marble, 32, Configurations.marbleAmount), 1000);
GameRegistry.registerWorldGenerator(new GeneratorLimestone(ModBlocks.limestone, 32, Configurations.limestoneAmount), 1000);
if (event.getSide() == Side.CLIENT) {
initModIntegration();
}
proxy.init();
MinecraftForge.EVENT_BUS.register(this);
MinecraftForge.EVENT_BUS.register(new ChiselLeftClick());
FMLCommonHandler.instance().bus().register(instance);
FMLInterModComms.sendMessage("Waila", "register", "com.cricketcraft.chisel.Waila.register");
}
@EventHandler
public void postInit(FMLPostInitializationEvent event)
{
ModIntegration.postInit();
Compatibility.init(event);
}
@SubscribeEvent
public void onConfigChanged(ConfigChangedEvent.OnConfigChangedEvent event) {
if (event.modID.equals("chisel")) {
Configurations.refreshConfig();
}
}
}
@@ -0,0 +1,190 @@
package com.cricketcraft.chisel;
import java.util.HashMap;
import java.util.Random;
import com.cricketcraft.chisel.api.ChiselMode;
import com.cricketcraft.chisel.carving.CarvingVariation;
import com.cricketcraft.chisel.client.GeneralChiselClient;
import com.cricketcraft.chisel.init.ModBlocks;
import com.cricketcraft.chisel.init.ModItems;
import com.cricketcraft.chisel.item.ItemChisel;
import net.minecraft.block.Block;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Blocks;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.world.World;
import net.minecraftforge.common.util.ForgeDirection;
import net.minecraftforge.event.entity.player.PlayerInteractEvent;
import net.minecraftforge.event.world.BlockEvent;
import cpw.mods.fml.common.FMLCommonHandler;
import cpw.mods.fml.common.eventhandler.SubscribeEvent;
public class ChiselLeftClick
{
HashMap<String, Long> chiselUseTime = new HashMap<String, Long>();
HashMap<String, String> chiselUseLocation = new HashMap<String, String>();
Random random = new Random();
public static void setBlock(World world, int x, int y, int z, ChiselMode chiselMode, Block previousBlock, int previousMetadata, Block newBlock, int newMetadata, ForgeDirection direction) {
if (chiselMode == ChiselMode.SINGLE)
{
world.setBlock(x, y, z, newBlock, newMetadata, 2);
} else if (chiselMode == ChiselMode.CIRCLETHREE)
{
int radius = 1;
for (int i = -radius; i <= radius; i++)
for (int j = -radius; j <= radius; j++)
{
//TODO facing stuff so this can be anywhere
if (world.getBlock(x + i, y, z + j) != null)
{
if (world.getBlock(x + i, y, z + j) == previousBlock && world.getBlockMetadata(x + i, y, z + j) == previousMetadata) {
int shiftedX = x;
int shiftedY = y;
int shiftedZ = z;
world.setBlock(shiftedX, shiftedY, shiftedZ, newBlock, newMetadata, 2);
}
}
}
}
}
@SubscribeEvent
public void onPlayerClick(PlayerInteractEvent event) {
if (event.action != PlayerInteractEvent.Action.LEFT_CLICK_BLOCK) return;
if (!Configurations.enableChiseling) return;
EntityPlayer player = event.entityPlayer;
ItemStack stack = player.getHeldItem();
if (stack == null || stack.getItem() != ModItems.chisel) return;
World world = event.world;
int x = event.x;
int y = event.y;
int z = event.z;
Block block = world.getBlock(x, y, z);
int blockMeta = world.getBlockMetadata(x, y, z);
ItemStack chiselTarget = null;
if (stack.stackTagCompound != null) {
chiselTarget = ItemStack.loadItemStackFromNBT(stack.stackTagCompound.getCompoundTag("chiselTarget"));
}
boolean chiselHasBlockInside = true;
if (chiselTarget == null) {
chiselHasBlockInside = false;
Long useTime = chiselUseTime.get(player.getCommandSenderName());
String loc = chiselUseLocation.get(player.getCommandSenderName());
if (useTime != null && chiselUseLocation != null && loc.equals(x + "|" + y + "|" + z)) {
long cooldown = 20;
long time = world.getWorldInfo().getWorldTotalTime();
if (time > useTime - cooldown && time < useTime + cooldown) return; //noReplace = true;
}
CarvingVariation[] variations = ItemChisel.carving.getVariations(block, blockMeta);
if (variations == null || variations.length < 2) return; //noReplace = true;
else {
int index = -1;
//Find the index of the next block in the variation list
for (int i = 0; i < variations.length; ++i) {
CarvingVariation currVariation = variations[i];
//If the metadata matches, then we are interested in the block AFTER this one
if (currVariation.block.equals(block) && currVariation.meta == blockMeta) {
index = i + 1;
}
}
//If no index was found, something is wrong. Return.
if (index < 0) {
return;
}
//If the the current block is the last in the list, loop back to the first
else if (index >= variations.length) {
index = 0;
}
CarvingVariation var = variations[index];
chiselTarget = new ItemStack(var.block, 1, var.damage);
}
}
Item result = null;
int targetMeta = 0;
Item target = chiselTarget.getItem();
targetMeta = chiselTarget.getItemDamage();
boolean match = ItemChisel.carving.isVariationOfSameClass(Block.getBlockFromItem(target), targetMeta, block, blockMeta);
result = target;
/* special case: stone can be carved to cobble and bricks */
if (Configurations.chiselStoneToCobbleBricks) {
if (!match && block.equals(Blocks.stone) && Block.getBlockFromItem(target).equals(ModBlocks.cobblestone))
match = true;
if (!match && block.equals(Blocks.stone) && Block.getBlockFromItem(target).equals(ModBlocks.stoneBrick))
match = true;
}
if (!match)
return; //noReplace = true;
int updateValue = 1;
if (!world.isRemote || chiselHasBlockInside) {
world.setBlock(x, y, z, Block.getBlockFromItem(result), targetMeta, updateValue);
world.markBlockForUpdate(x, y, z);
}
switch (FMLCommonHandler.instance().getEffectiveSide()) {
case SERVER:
chiselUseTime.put(player.getCommandSenderName(), world.getWorldInfo().getWorldTotalTime());
chiselUseLocation.put(player.getCommandSenderName(), x + "|" + y + "|" + z);
try {
//TODO chisel left click thingy
// Packet packet = Chisel.packet.create(Packets.CHISELED).writeInt(x).writeInt(y).writeInt(z);
// Chisel.packet.sendToAllAround(packet, new TargetPoint(player.dimension, x, y, z, 30.0f));
} catch (Exception e) {
e.printStackTrace();
}
break;
case CLIENT:
if (chiselHasBlockInside) {
String sound = ItemChisel.carving.getVariationSound(result, chiselTarget.getItemDamage());
GeneralChiselClient.spawnChiselEffect(x, y, z, sound);
}
break;
default:
break;
}
stack.damageItem(1, player);
if (stack.stackSize == 0) {
player.inventory.mainInventory[player.inventory.currentItem] = chiselHasBlockInside ? chiselTarget : null;
}
}
@SubscribeEvent
public void onBlockBreak(BlockEvent.BreakEvent event) {
if (!Configurations.enableChiseling) return;
EntityPlayer player = event.getPlayer();
ItemStack stack = player.getHeldItem();
if (stack == null || stack.getItem() != ModItems.chisel) return;
event.setCanceled(true);
}
}
@@ -0,0 +1,61 @@
package com.cricketcraft.chisel;
import net.minecraftforge.common.config.Configuration;
public class Configurations
{
public static Configuration config;
public static boolean configExists;
public static boolean oldPillars;
public static boolean disableCTM;
public static boolean blockDescriptions;
public static boolean ghostCloud;
public static boolean allowMossy;
public static boolean chiselStoneToCobbleBricks;
public static boolean enableChiseling;
public static boolean chiselRecipe;
public static boolean autoChisel;
public static boolean fancy;
public static boolean enableFMP;
public static boolean animatedVoidstone;
public static int factoryBlockAmount;
public static int particlesTickrate;
public static int marbleAmount;
public static int limestoneAmount;
public static double concreteVelocity;
public static boolean refreshConfig()
{
concreteVelocity = config.get("general", "concreteVelocity", 0.45, "Traversing concrete roads, players will acceleration to this velocity. For reference, normal running speed is about 0.28. Set to 0 to disable acceleration.").getDouble(0.45);
particlesTickrate = config.get("client", "particleTickrate", 1, "Particle tick rate. Greater value = less particles.").getInt(1);
oldPillars = config.get("client", "pillarOldGraphics", false, "Use old pillar textures").getBoolean(false);
disableCTM = !config.get("client", "connectedTextures", true, "Enable connected textures").getBoolean(true);
fancy = config.get("client", "fancyLeaves", true, "Enable fancy textures").getBoolean(true);
blockDescriptions = config.get("client", "tooltipsUseBlockDescriptions", true, "Make variations of blocks have the same name, and use the description in tooltip to distinguish them.").getBoolean(true);
chiselStoneToCobbleBricks = config.get("general", "chiselStoneToCobbleBricks", true, "Chisel stone to cobblestone and bricks by left-click.").getBoolean(true);
enableChiseling = config.get("general", "enableChiselingLeftClicking", false, "Change blocks to another block using the Chisel and left-click.").getBoolean(false);
ghostCloud = config.get("general", "doesCloudRenderLikeGhost", true).getBoolean(true);
factoryBlockAmount = config.get("general", "amountYouGetFromFactoryBlockCrafting", 32).getInt(32);
allowMossy = config.get("general", "allowCobbleToMossyInChisel", true).getBoolean(true);
marbleAmount = config.get("worldgen", "marbleAmount", 7, "Amount of marble to generate in the world; use 0 for none").getInt(7);
limestoneAmount = config.get("worldgen", "limestoneAmount", 8, "Amount of limestone to generate in the world; use 0 for none").getInt(8);
chiselRecipe = config.get("general", "chiselAlternateRecipe", false, "Use alternative crafting recipe for the chisel").getBoolean(false);
autoChisel = config.get("general", "autoChisel", true, "Should people be allowed to use the auto chisel").getBoolean(true);
enableFMP = config.get("general", "enableFMP", true, "Do you want to enable FMP").getBoolean(true);
animatedVoidstone = config.get("client", "animatedVoidstone", true, "True, you want animated textures. False, nah i'm good.").getBoolean(true);
if(config.hasChanged())
{
config.save();
}
return true;
}
public static boolean featureEnabled(String feature)
{
return config.get("features", feature, true).getBoolean(true) && refreshConfig();
}
}
@@ -0,0 +1,117 @@
package com.cricketcraft.chisel;
import com.cricketcraft.chisel.init.ModBlocks;
import com.cricketcraft.chisel.init.ModItems;
import net.minecraft.block.Block;
import net.minecraft.init.Blocks;
import net.minecraft.init.Items;
import net.minecraft.item.ItemStack;
import net.minecraft.item.crafting.FurnaceRecipes;
import net.minecraftforge.oredict.OreDictionary;
import net.minecraftforge.oredict.ShapedOreRecipe;
import net.minecraftforge.oredict.ShapelessOreRecipe;
import cpw.mods.fml.common.registry.GameRegistry;
public class Crafting {
public static void init() {
Block concreteRecipeBlock = Block.getBlockFromName(Configurations.config.get("tweaks", "concrete recipe block", "gravel", "Unlocalized name of the block that, when burned, will produce concrete (examples: lightgem, stone)").getString());
if (concreteRecipeBlock == null) concreteRecipeBlock = Blocks.gravel;
if(Configurations.featureEnabled("concrete"))
FurnaceRecipes.smelting().func_151393_a(concreteRecipeBlock, new ItemStack(ModBlocks.concrete), 0.1F);
if(Configurations.featureEnabled("sandstoneScribbles"))
GameRegistry.addRecipe(new ItemStack(ModBlocks.sandstoneScribbles, 1), new Object[]{"X", 'X', new ItemStack(ModBlocks.sandstone, 1, 8),});
for (int meta = 0; meta < 16; meta++) {
if(Configurations.featureEnabled("marble"))
GameRegistry.addRecipe(new ItemStack(ModBlocks.marbleSlab, 6, 0), new Object[]{"***", '*', new ItemStack(ModBlocks.marble, 1, meta)});
if(Configurations.featureEnabled("limestone"))
GameRegistry.addRecipe(new ItemStack(ModBlocks.limestoneSlab, 6, 0), new Object[]{"***", '*', new ItemStack(ModBlocks.limestone, 1, meta)});
if(Configurations.featureEnabled("marblePillar"))
GameRegistry.addRecipe(new ItemStack(ModBlocks.marblePillarSlab, 6, 0), new Object[]{"***", '*', new ItemStack(ModBlocks.marblePillar, 1, meta)});
if(Configurations.featureEnabled("marblePillar"))
GameRegistry.addRecipe(new ItemStack(ModBlocks.marblePillar, 6), new Object[]{"XX", "XX", "XX", 'X', new ItemStack(ModBlocks.marble, 1, meta),});
if(Configurations.featureEnabled("marble"))
GameRegistry.addRecipe(new ItemStack(ModBlocks.marble, 4), new Object[]{"XX", "XX", 'X', new ItemStack(ModBlocks.marblePillar, 1, meta),});
if(Configurations.featureEnabled("icePillar"))
GameRegistry.addRecipe(new ItemStack(ModBlocks.icePillar, 6, 1), new Object[]{"XX", "XX", "XX", 'X', new ItemStack(ModBlocks.ice, 1, meta),});
if(Configurations.featureEnabled("ice"))
GameRegistry.addRecipe(new ItemStack(ModBlocks.ice, 4, 1), new Object[]{"XX", "XX", 'X', new ItemStack(ModBlocks.icePillar, 1, meta),});
if(Configurations.featureEnabled("sandstone"))
GameRegistry.addRecipe(new ItemStack(Blocks.sandstone, 1, 1), new Object[]{"X", 'X', new ItemStack(ModBlocks.sandstoneScribbles, 1, meta),});
if(Configurations.featureEnabled("carpet"))
GameRegistry.addRecipe(new ItemStack(ModBlocks.carpet, 8, meta), new Object[]{"YYY", "YXY", "YYY", 'X', new ItemStack(Items.string, 1), 'Y', new ItemStack(Blocks.wool, 1, meta),});
if(Configurations.featureEnabled("carpetFloor"))
GameRegistry.addRecipe(new ItemStack(ModBlocks.carpetFloor, 3, meta), new Object[]{"XX", 'X', new ItemStack(ModBlocks.carpet, 1, meta),});
}
// The following recipe is due to bugs with Chisel 1.5.1 to 1.5.6a
if(Configurations.featureEnabled("sandstone"))
GameRegistry.addRecipe(new ItemStack(Blocks.sandstone, 1, 0), new Object[]{"X", 'X', new ItemStack(ModBlocks.sandstone, 1, 0),});
// The following recipe is due to bug with Chisel 1.5.6b
if(Configurations.featureEnabled("sandstone"))
GameRegistry.addRecipe(new ItemStack(Blocks.sandstone, 1, 1), new Object[]{"X", 'X', new ItemStack(ModBlocks.sandstone, 1, 1),});
if(Configurations.featureEnabled("holystone"))
GameRegistry.addRecipe(new ItemStack(ModBlocks.holystone, 8, 0), new Object[]{"***", "*X*", "***", '*', new ItemStack(Blocks.stone, 1), 'X', new ItemStack(Items.feather, 1)});
if(Configurations.featureEnabled("lavastone"))
GameRegistry.addRecipe(new ItemStack(ModBlocks.lavastone, 8, 0), new Object[]{"***", "*X*", "***", '*', new ItemStack(Blocks.stone, 1), 'X', new ItemStack(Items.lava_bucket, 1)});
if(Configurations.featureEnabled("waterstone"))
GameRegistry.addRecipe(new ItemStack(ModBlocks.waterstone, 8, 0), new Object[]{"***", "*X*", "***", '*', new ItemStack(Blocks.stone, 1), 'X', new ItemStack(Items.water_bucket, 1)});
if(Configurations.featureEnabled("fantasy"))
GameRegistry.addRecipe(new ItemStack(ModBlocks.fantasy, 8, 0), new Object[]{"***", "*X*", "***", '*', new ItemStack(Blocks.stone, 1), 'X', new ItemStack(Items.gold_nugget, 1)});
if(Configurations.featureEnabled("futuristicArmorPlating"))
GameRegistry.addRecipe(new ItemStack(ModBlocks.tyrian, 8, 0), new Object[]{"***", "*X*", "***", '*', new ItemStack(Blocks.stone, 1), 'X', new ItemStack(Items.iron_ingot, 1)});
if(Configurations.featureEnabled("templeBlock"))
GameRegistry.addRecipe(new ItemStack(ModBlocks.temple, 8, 0), new Object[]{"***", "*X*", "***", '*', new ItemStack(Blocks.stone, 1), 'X', new ItemStack(Items.dye, 1, 4)});
if(Configurations.featureEnabled("factory"))
GameRegistry.addRecipe(new ItemStack(ModBlocks.factory, Configurations.factoryBlockAmount, 0), new Object[]{"*X*", "X X", "*X*", '*', new ItemStack(Blocks.stone, 1), 'X', new ItemStack(Items.iron_ingot, 1)});
if(Configurations.featureEnabled("voidstone"))
GameRegistry.addRecipe(new ItemStack(ModBlocks.voidstone, 8, 1), new Object[]{"oxo", "xyx", "oxo", 'x', new ItemStack(Blocks.stone, 1), 'y', new ItemStack(Items.ender_pearl, 1), 'o', new ItemStack(Blocks.obsidian, 1)});
GameRegistry.addRecipe(new ShapedOreRecipe(new ItemStack(ModBlocks.roadLine, 8, 0), new Object[]{"wrw", "wrw", "wrw", ('w'), "dyeWhite", ('r'), Items.redstone}));
if (Configurations.chiselRecipe) {
GameRegistry.addRecipe(new ShapedOreRecipe(new ItemStack(ModItems.chisel, 1), new Object[]{" YY", " YY", "X ", 'X', Items.stick, 'Y', Items.iron_ingot}));
} else {
GameRegistry.addRecipe(new ShapedOreRecipe(new ItemStack(ModItems.chisel, 1), new Object[]{" Y", "X ", 'X', Items.stick, 'Y', Items.iron_ingot}));
}
if (Configurations.featureEnabled("ballOfMoss"))
GameRegistry.addRecipe(new ItemStack(ModItems.itemBallOMoss, 1), new Object[]{"XYX", "YXY", "XYX", 'X', Blocks.vine, 'Y', Items.stick});
if (Configurations.featureEnabled("cloud"))
GameRegistry.addRecipe(new ItemStack(ModItems.itemCloudInABottle, 1), new Object[]{"X X", "XYX", " X ", 'X', Blocks.glass, 'Y', Items.quartz});
if (Configurations.featureEnabled("smashingrock"))
GameRegistry.addShapelessRecipe(new ItemStack(ModItems.smashingRock, 16), new Object[]{new ItemStack(Items.stone_pickaxe), new ItemStack(Items.glass_bottle, 1), new ItemStack(Items.stone_shovel)});
if(Configurations.featureEnabled("paperWall"))
GameRegistry.addRecipe(new ShapedOreRecipe(new ItemStack(ModBlocks.paperWall, 8), new Object[]{"ppp", "psp", "ppp", ('p'), Items.paper, ('s'), "stickWood"}));
String[] sGNames = new String[]{
"White", "Orange", "Magenta", "Light Blue",
"Yellow", "Lime", "Pink", "Gray",
"Light Gray", "Cyan", "Purple", "Blue",
"Brown", "Green", "Red", "Black"
};
for (int i = 0; i < 16; i++) {
OreDictionary.registerOre("stainedClay" + sGNames[i].replaceAll(" ", ""), new ItemStack(Blocks.stained_hardened_clay, 1, i));
OreDictionary.registerOre("blockWool" + sGNames[i].replaceAll(" ", ""), new ItemStack(Blocks.wool, 1, i));
if(Configurations.featureEnabled("woolenClay"))
GameRegistry.addRecipe(new ShapelessOreRecipe(new ItemStack(ModBlocks.woolenClay, 2, i), new Object[]{"blockWool" + sGNames[i].replaceAll(" ", ""), "stainedClay" + sGNames[i].replaceAll(" ", "")}));
}
if(Configurations.featureEnabled("laboratory"))
GameRegistry.addRecipe(new ItemStack(ModBlocks.laboratory, 8, 0), new Object[]{"***", "*X*", "***", '*', new ItemStack(Blocks.stone, 1), 'X', new ItemStack(Items.quartz, 1)});
if(Configurations.autoChisel)
GameRegistry.addRecipe(new ShapedOreRecipe(new ItemStack(ModBlocks.autoChisel, 1), new Object[]{"XXX", "XYX", "XXX", Character.valueOf('X'), "plankWood", Character.valueOf('Y'), ModItems.chisel}));
if(Configurations.featureEnabled("hexPlating"))
GameRegistry.addRecipe(new ShapedOreRecipe(new ItemStack(ModBlocks.hexPlating, 1), new Object[]{"XXX", "XYX", "XXX", 'X', "stone", 'Y', "blockCoal"}));
}
}
@@ -0,0 +1,47 @@
package com.cricketcraft.chisel;
public class Packets// extends MessageHandlerBase
{
//TODO packet
public static final int CHISELED = 1;
/*
public void onChiseled(Packet stream, EntityPlayer player) throws IOException
{
final int x = stream.readInt();
final int y = stream.readInt();
final int z = stream.readInt();
switch(FMLCommonHandler.instance().getEffectiveSide())
{
case SERVER:
Packet packet = Chisel.packet.create(CHISELED).writeInt(x).writeInt(y).writeInt(z);
Chisel.packet.sendToAllAround(packet, new TargetPoint(player.dimension, x, y, z, 30.0f));
break;
case CLIENT:
Block block = player.worldObj.getBlock(x, y, z);
int blockMeta = player.worldObj.getBlockMetadata(x, y, z);
GeneralChiselClient.spawnChiselEffect(x, y, z, Carving.chisel.getVariationSound(block, blockMeta));
break;
default:
break;
}
}
@Override
public void onMessage(Packet packet, INetHandler handler,
EntityPlayer player, int command) throws IOException
{
switch(command)
{
case CHISELED:
onChiseled(packet, player);
return;
}
}
*/
}
@@ -0,0 +1,50 @@
package com.cricketcraft.chisel;
import java.util.List;
import com.cricketcraft.chisel.block.BlockCarvable;
import mcp.mobius.waila.api.IWailaConfigHandler;
import mcp.mobius.waila.api.IWailaDataAccessor;
import mcp.mobius.waila.api.IWailaDataProvider;
import mcp.mobius.waila.api.IWailaRegistrar;
import net.minecraft.item.ItemStack;
public class Waila implements IWailaDataProvider
{
@Override
public ItemStack getWailaStack(IWailaDataAccessor accessor, IWailaConfigHandler configHandler)
{
return null;
}
@Override
public List<String> getWailaHead(ItemStack stack, List<String> strings, IWailaDataAccessor accessor, IWailaConfigHandler configHandler)
{
return strings;
}
@Override
public List<String> getWailaBody(ItemStack stack, List<String> strings, IWailaDataAccessor accessor, IWailaConfigHandler configHandler)
{
if(accessor.getBlock() instanceof BlockCarvable)
{
BlockCarvable block = (BlockCarvable) accessor.getBlock();
strings.add(block.getVariation(accessor.getMetadata()).description);
}
return strings;
}
@Override
public List<String> getWailaTail(ItemStack stack, List<String> strings, IWailaDataAccessor accessor, IWailaConfigHandler configHandler)
{
return strings;
}
public static void register(IWailaRegistrar registrar)
{
Waila instance = new Waila();
registrar.registerBodyProvider(instance, BlockCarvable.class);
}
}
@@ -0,0 +1,10 @@
package com.cricketcraft.chisel.api;
public enum ChiselMode
{
SINGLE,
CIRCLETHREE,
COLLUM,
SIDEWAYS
}
@@ -0,0 +1,8 @@
package com.cricketcraft.chisel.api;
import com.cricketcraft.chisel.carving.CarvableVariation;
public interface ICarvable
{
public CarvableVariation getVariation(int metadata);
}
@@ -0,0 +1,8 @@
package com.cricketcraft.chisel.api;
import net.minecraft.item.ItemStack;
public interface IChiselMode
{
public ChiselMode getChiselMode(ItemStack itemStack);
}
@@ -0,0 +1,12 @@
package com.cricketcraft.chisel.api;
import net.minecraft.block.Block;
import net.minecraft.world.IBlockAccess;
public interface IFacade {
int getFacadeMetadata(IBlockAccess world, int x, int y, int z, int side);
Block getFacade(IBlockAccess world, int x, int y, int z, int side);
}
@@ -0,0 +1,130 @@
package com.cricketcraft.chisel.block;
import java.util.List;
import java.util.Random;
import com.cricketcraft.chisel.Chisel;
import com.cricketcraft.chisel.block.tileentity.TileEntityAutoChisel;
import com.cricketcraft.chisel.init.ModBlocks;
import com.cricketcraft.chisel.init.ModItems;
import net.minecraft.block.Block;
import net.minecraft.block.BlockContainer;
import net.minecraft.block.material.Material;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.item.EntityItem;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
public class BlockAutoChisel extends BlockContainer{
public BlockAutoChisel() {
super(Material.rock);
setHardness(1F);
}
@Override
public int getRenderType() {
return -1;
}
@Override
public boolean isOpaqueCube() {
return false;
}
@Override
public boolean renderAsNormalBlock() {
return false;
}
@Override
public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int metadata, float x1, float y1, float z1) {
TileEntity tile = world.getTileEntity(x, y, z);
if (world.isRemote)
return true;
if (tile != null && tile instanceof TileEntityAutoChisel && !player.isSneaking()){
player.openGui(Chisel.instance, 1, world, x, y, z);
}
if(player.isSneaking() && tile!= null && tile instanceof TileEntityAutoChisel){
TileEntityAutoChisel autoChisel = (TileEntityAutoChisel) tile;
System.out.println(player.getHeldItem());
if(player.getItemInUse() == new ItemStack(ModItems.upgrade, 1, 0)){
//If they are using the speed upgrade
world.setBlock(x, y, z, ModBlocks.autoChisel, 1, 3);
} else if(player.getItemInUse() == new ItemStack(ModItems.upgrade, 1, 1)){
//If they are using the automation upgrade
world.setBlock(x, y, z, ModBlocks.autoChisel, 2, 3);
} else if(player.getItemInUse() == new ItemStack(ModItems.upgrade, 1, 2)){
//If they are using the stack upgrade
world.setBlock(x, y, z, ModBlocks.autoChisel, 3, 3);
}
}
return true;
}
@Override
public void breakBlock(World world, int x, int y, int z, Block block, int par6) {
dropItems(world, x, y, z);
super.breakBlock(world, x, y, z, block, par6);
}
@Override
public int damageDropped(int metadata){
return metadata;
}
@SideOnly(Side.CLIENT)
@Override
public void getSubBlocks(Item item, CreativeTabs creativeTabs, List subItems){
for(int x = 0; x < 4; x++){
subItems.add(new ItemStack(this, 1, x));
}
}
private void dropItems(World world, int x, int y, int z) {
Random random = new Random();
TileEntity tileEntity = world.getTileEntity(x, y, z);
if (!(tileEntity instanceof TileEntityAutoChisel)) {
return;
}
TileEntityAutoChisel inventory = (TileEntityAutoChisel) world.getTileEntity(x, y, z);
for (int c = 0; c < inventory.getSizeInventory(); c++) {
ItemStack stack = inventory.getStackInSlot(c);
if (stack != null && stack.stackSize > 0) {
float rx = random.nextFloat() * 0.8F + 0.1F;
float ry = random.nextFloat() * 0.8F + 0.1F;
float rz = random.nextFloat() * 0.8F + 0.1F;
EntityItem entityItem = new EntityItem(world, x + rx, y + ry, z + rz, stack);
if (stack.hasTagCompound()) {
entityItem.getEntityItem().setTagCompound((NBTTagCompound) stack.getTagCompound().copy());
}
float factor = 0.05F;
entityItem.motionX = random.nextGaussian() * factor;
entityItem.motionY = random.nextGaussian() * factor + 0.2F;
entityItem.motionZ = random.nextGaussian() * factor;
world.spawnEntityInWorld(entityItem);
stack.stackSize = 0;
}
}
}
@Override
public TileEntity createNewTileEntity(World var1, int var2) {
return new TileEntityAutoChisel();
}
}
@@ -0,0 +1,16 @@
package com.cricketcraft.chisel.block;
import net.minecraft.world.IBlockAccess;
/**
* Created by Pokefenn
*/
public class BlockBeaconBase extends BlockCarvable
{
@Override
public boolean isBeaconBase(IBlockAccess worldObj, int x, int y, int z, int beaconX, int beaconY, int beaconZ)
{
return true;
}
}
@@ -0,0 +1,162 @@
package com.cricketcraft.chisel.block;
import java.util.List;
import com.cricketcraft.chisel.Chisel;
import com.cricketcraft.chisel.api.ICarvable;
import com.cricketcraft.chisel.carving.CarvableHelper;
import com.cricketcraft.chisel.carving.CarvableVariation;
import com.cricketcraft.chisel.init.ModTabs;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.item.Item;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
public class BlockCarvable extends Block implements ICarvable {
public CarvableHelper carverHelper;
private boolean isAlpha;
public BlockCarvable() {
this(Material.rock);
}
public BlockCarvable(Material m) {
super(m);
carverHelper = new CarvableHelper();
setCreativeTab(ModTabs.tabChiselBlocks);
}
public BlockCarvable setStained(boolean a) {
this.isAlpha = a;
return this;
}
@Override
@SideOnly(Side.CLIENT)
public int getRenderBlockPass() {
return isAlpha ? 1 : 0;
}
@Override
public IIcon getIcon(int side, int metadata) {
return carverHelper.getIcon(side, metadata);
}
@Override
public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
return carverHelper.getIcon(world, x, y, z, side);
}
@Override
public int damageDropped(int i) {
return i;
}
@Override
public void registerBlockIcons(IIconRegister register) {
carverHelper.registerBlockIcons("Chisel", this, register);
}
@Override
public void getSubBlocks(Item item, CreativeTabs tabs, List list) {
carverHelper.registerSubBlocks(this, tabs, list);
}
@Override
public int getRenderType() {
return Chisel.RenderCTMId;
}
@Override
public CarvableVariation getVariation(int metadata) {
return carverHelper.getVariation(metadata);
}
public static class SoundType extends Block.SoundType {
public final String soundNameStep;
public final String soundNameBreak;
public final String soundNamePlace;
/**
* Creates a SoundType with automatic names for step and break sounds.
* Sound names dig.soundName and step.soundName must be specified in the
* sounds.json
*
* @param soundName block of the sound. Will automatically be expanded to
* "mod:dig.soundName" and "mod:step.soundName" respectively)
* @param volume default 1.0f
* @param frequency default 1.0f
*/
public SoundType(String soundName, float volume, float frequency) {
super(soundName, volume, frequency);
this.soundNameStep = null;
this.soundNameBreak = null;
this.soundNamePlace = null;
}
/**
* Creates a SoundType with manual names for step and break sounds.
* Sound names must be specified in the sounds.json
*
* @param soundNameBreak block break sound
* @param soundNameStep block step sound
* @param volume default 1.0f
* @param frequency default 1.0f
*/
public SoundType(String soundNameBreak, String soundNameStep, float volume, float frequency) {
super(soundNameStep, volume, frequency);
this.soundNameStep = soundNameStep;
this.soundNameBreak = soundNameBreak;
this.soundNamePlace = null;
}
/**
* Creates a SoundType with manual names for step, break and place
* sounds. Sound names must be specified in the sounds.json
*
* @param soundNameBreak block break sound
* @param soundNameStep block step sound
* @param soundNamePlace block place sound
* @param volume default 1.0f
* @param frequency default 1.0f
*/
public SoundType(String soundNameBreak, String soundNameStep, String soundNamePlace, float volume, float frequency) {
super(soundNameStep, volume, frequency);
this.soundNameStep = soundNameStep;
this.soundNameBreak = soundNameBreak;
this.soundNamePlace = soundNamePlace;
}
@Override
public String getBreakSound() {
if (soundNameBreak == null)
return Chisel.MOD_ID + ":dig." + this.soundName;
else
return this.soundNameBreak;
}
@Override
public String getStepResourcePath() {
if (soundNameStep == null)
return Chisel.MOD_ID + ":step." + this.soundName;
else
return this.soundNameStep;
}
@Override
public String func_150496_b() {
if (soundNamePlace == null)
return getBreakSound();
else
return this.soundNamePlace;
}
}
}
@@ -0,0 +1,87 @@
package com.cricketcraft.chisel.block;
import java.util.List;
import com.cricketcraft.chisel.Chisel;
import com.cricketcraft.chisel.api.ICarvable;
import com.cricketcraft.chisel.carving.CarvableHelper;
import com.cricketcraft.chisel.carving.CarvableVariation;
import com.cricketcraft.chisel.init.ModTabs;
import net.minecraft.block.BlockGlass;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.item.Item;
import net.minecraft.util.IIcon;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
public class BlockCarvableGlass extends BlockGlass implements ICarvable
{
public CarvableHelper carverHelper;
private boolean isAlpha = false;
public BlockCarvableGlass()
{
super(Material.glass, false);
carverHelper = new CarvableHelper();
setCreativeTab(ModTabs.tabChiselBlocks);
}
public BlockCarvableGlass setStained(boolean a)
{
this.isAlpha = a;
return this;
}
@Override
public boolean renderAsNormalBlock()
{
return false;
}
@Override
public int getRenderType()
{
return Chisel.RenderCTMId;
}
@Override
public IIcon getIcon(int side, int metadata)
{
return carverHelper.getIcon(side, metadata);
}
@Override
public int damageDropped(int i)
{
return i;
}
@Override
public void registerBlockIcons(IIconRegister register)
{
carverHelper.registerBlockIcons("Chisel", this, register);
}
@Override
public void getSubBlocks(Item item, CreativeTabs tabs, List list)
{
carverHelper.registerSubBlocks(this, tabs, list);
}
@Override
public CarvableVariation getVariation(int metadata)
{
return carverHelper.getVariation(metadata);
}
@Override
@SideOnly(Side.CLIENT)
public int getRenderBlockPass()
{
return isAlpha ? 1 : 0;
}
}
@@ -0,0 +1,82 @@
package com.cricketcraft.chisel.block;
import java.util.List;
import com.cricketcraft.chisel.api.ICarvable;
import com.cricketcraft.chisel.carving.CarvableHelper;
import com.cricketcraft.chisel.carving.CarvableVariation;
import com.cricketcraft.chisel.client.render.BlockMarblePaneRenderer;
import com.cricketcraft.chisel.init.ModTabs;
import net.minecraft.block.BlockPane;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.item.Item;
import net.minecraft.util.IIcon;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
public class BlockCarvablePane extends BlockPane implements ICarvable
{
public CarvableHelper carverHelper;
public boolean isAlpha;
public BlockCarvablePane(Material material, boolean drops)
{
super("", "", material, drops);
carverHelper = new CarvableHelper();
setCreativeTab(ModTabs.tabChiselBlocks);
}
public BlockCarvablePane setStained(boolean a)
{
this.isAlpha = a;
return this;
}
@Override
@SideOnly(Side.CLIENT)
public int getRenderBlockPass()
{
return isAlpha ? 1 : 0;
}
@Override
public int getRenderType()
{
return BlockMarblePaneRenderer.id;
}
@Override
public IIcon getIcon(int side, int metadata)
{
return carverHelper.getIcon(side, metadata);
}
@Override
public int damageDropped(int i)
{
return i;
}
@Override
public void registerBlockIcons(IIconRegister register)
{
carverHelper.registerBlockIcons("Chisel", this, register);
}
@Override
public void getSubBlocks(Item item, CreativeTabs tabs, List list)
{
carverHelper.registerSubBlocks(this, tabs, list);
}
@Override
public CarvableVariation getVariation(int metadata)
{
return carverHelper.getVariation(metadata);
}
}
@@ -0,0 +1,32 @@
package com.cricketcraft.chisel.block;
import net.minecraft.block.material.Material;
import net.minecraft.world.IBlockAccess;
public class BlockCarvablePowered extends BlockCarvable {
public BlockCarvablePowered(Material m) {
super(m);
}
/**
* Can this block provide power. Only wire currently seems to have this
* change based on its state.
*/
@Override
public boolean canProvidePower() {
return true;
}
/**
* Returns true if the block is emitting indirect/weak redstone power on the
* specified side. If isBlockNormalCube returns true, standard redstone
* propagation rules will apply instead and this will not be called. Args:
* World, X, Y, Z, side. Note that the side is reversed - eg it is 1 (up)
* when checking the bottom of the block.
*/
@Override
public int isProvidingWeakPower(IBlockAccess par1IBlockAccess, int par2, int par3, int par4, int par5) {
return 15;
}
}
@@ -0,0 +1,49 @@
package com.cricketcraft.chisel.block;
import com.cricketcraft.chisel.api.ICarvable;
import com.cricketcraft.chisel.carving.CarvableHelper;
import com.cricketcraft.chisel.carving.CarvableVariation;
import net.minecraft.block.BlockPumpkin;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.util.IIcon;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
public class BlockCarvablePumpkin extends BlockPumpkin implements ICarvable{
public CarvableHelper carverHelper;
@SideOnly(Side.CLIENT)
private IIcon top;
@SideOnly(Side.CLIENT)
private IIcon face;
@SideOnly(Side.CLIENT)
private IIcon side;
private int sideVal, faceVal;
public BlockCarvablePumpkin(boolean isOn, int sideTexture, int faceTexture) {
super(isOn);
sideVal = sideTexture;
faceVal = faceTexture;
}
@Override
public IIcon getIcon(int side, int meta) {
//if(side != 0 || side != 1){
// if(side == ForgeDirection.)
return null;
}
@Override
public void registerBlockIcons(IIconRegister icon){
top = icon.registerIcon(this.getTextureName() + "_top_" + sideVal);
side = icon.registerIcon(this.getTextureName() + "_side_" + sideVal);
face = icon.registerIcon(this.getTextureName() + "_face_" + faceVal);
}
@Override
public CarvableVariation getVariation(int metadata) {
return carverHelper.getVariation(metadata);
}
}
@@ -0,0 +1,69 @@
package com.cricketcraft.chisel.block;
import java.util.Random;
import com.cricketcraft.chisel.Configurations;
import net.minecraft.block.material.Material;
import net.minecraft.entity.Entity;
import net.minecraft.item.Item;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
public class BlockCloud extends BlockCarvable {
public BlockCloud() {
super(Material.ice);
useNeighborBrightness = true;
}
@Override
public void onEntityCollidedWithBlock(World world, int i, int j, int k, Entity entity) {
entity.fallDistance = 0.0F;
if (entity.motionY < 0.0D) {
entity.motionY *= 0.0050000000000000001D;
} else if (entity.motionY > 0) {
entity.motionY += 0.0285;
}
}
@Override
public boolean isOpaqueCube() {
return false;
}
@Override
public int getRenderBlockPass() {
return Configurations.ghostCloud ? 1 : 0;
}
@Override
public boolean shouldSideBeRendered(IBlockAccess iblockaccess, int i, int j, int k, int l) {
return super.shouldSideBeRendered(iblockaccess, i, j, k, 1 - l);
}
@Override
public AxisAlignedBB getCollisionBoundingBoxFromPool(World world, int i, int j, int k) {
return AxisAlignedBB.getBoundingBox(i + 0.2, j, k + 0.2, i + 0.8, j + 0.2, k + 0.8);
}
@Override
public Item getItemDropped(int par1, Random rand, int par3) {
return Item.getItemFromBlock(this);
}
@Override
public int quantityDropped(Random rand) {
return 0;
}
@Override
public int damageDropped(int meta) {
return 0;
}
}
@@ -0,0 +1,38 @@
package com.cricketcraft.chisel.block;
import com.cricketcraft.chisel.Configurations;
import com.cricketcraft.chisel.client.GeneralChiselClient;
import net.minecraft.entity.Entity;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.world.World;
import cpw.mods.fml.common.FMLCommonHandler;
import cpw.mods.fml.relauncher.Side;
public class BlockConcrete extends BlockCarvable
{
public BlockConcrete()
{
super();
}
@Override
public AxisAlignedBB getCollisionBoundingBoxFromPool(World par1World, int par2, int par3, int par4)
{
float f = 0.125F;
return AxisAlignedBB.getBoundingBox(par2, par3, par4, (par2 + 1), ((par3 + 1) - f), (par4 + 1));
}
@Override
public void onEntityCollidedWithBlock(World world, int x, int y, int z, Entity entity)
{
if(FMLCommonHandler.instance().getEffectiveSide() != Side.CLIENT)
return;
if(Configurations.concreteVelocity == 0)
return;
GeneralChiselClient.speedupPlayer(world, entity, Configurations.concreteVelocity);
}
}
@@ -0,0 +1,20 @@
package com.cricketcraft.chisel.block;
import com.cricketcraft.chisel.Chisel;
public class BlockEldritch extends BlockCarvable
{
public BlockEldritch()
{
super();
}
@Override
public int getRenderType()
{
return Chisel.RenderEldritchId;
}
}
@@ -0,0 +1,36 @@
package com.cricketcraft.chisel.block;
import java.util.Random;
import com.cricketcraft.chisel.Chisel;
import com.cricketcraft.chisel.client.GeneralChiselClient;
import com.cricketcraft.chisel.init.ModTabs;
import com.cricketcraft.chisel.utils.General;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.util.IIcon;
import net.minecraft.world.World;
public class BlockGrimstone extends BlockCarvable {
public IIcon iconStar;
public BlockGrimstone(Material m) {
super(m);
this.setCreativeTab(ModTabs.tabChiselBlocks);
}
@Override
public void randomDisplayTick(World world, int x, int y, int z, Random random) {
if (General.rand.nextInt(4) == 0 && world.isRemote)
GeneralChiselClient.spawnGrimstoneFX(world, this, x, y, z);
}
@Override
public void registerBlockIcons(IIconRegister register) {
super.registerBlockIcons(register);
iconStar = register.registerIcon(Chisel.MOD_ID + ":grimstone/particles/star");
}
}
@@ -0,0 +1,35 @@
package com.cricketcraft.chisel.block;
import java.util.Random;
import com.cricketcraft.chisel.client.GeneralChiselClient;
import com.cricketcraft.chisel.utils.General;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.util.IIcon;
import net.minecraft.world.World;
public class BlockHolystone extends BlockCarvable {
public IIcon iconStar;
public BlockHolystone(Material m) {
super(m);
this.setLightLevel(0.25F);
}
@Override
public void randomDisplayTick(World world, int x, int y, int z, Random random) {
if (General.rand.nextInt(4) == 0 && world.isRemote)
GeneralChiselClient.spawnHolystoneFX(world, this, x, y, z);
}
@Override
public void registerBlockIcons(IIconRegister register) {
super.registerBlockIcons(register);
iconStar = register.registerIcon("Chisel:holystone/particles/star");
}
}
@@ -0,0 +1,32 @@
package com.cricketcraft.chisel.block;
import java.util.Random;
import com.cricketcraft.chisel.client.GeneralChiselClient;
import net.minecraft.block.material.Material;
import net.minecraft.world.World;
public class BlockLavastone extends BlockMarbleTexturedOre
{
public BlockLavastone(Material mat, String baseIcon)
{
super(mat, baseIcon);
setLightLevel(1F);
}
@Override
public void randomDisplayTick(World world, int x, int y, int z, Random random)
{
if(random.nextInt(8) == 0 && world.isRemote)
GeneralChiselClient.spawnLavastoneFX(world, this, x, y, z);
}
@Override
public boolean renderAsNormalBlock()
{
return true;
}
}
@@ -0,0 +1,15 @@
package com.cricketcraft.chisel.block;
import net.minecraft.block.material.Material;
public class BlockLeaf extends BlockCarvable {
public BlockLeaf(Material material) {
super(material);
}
@Override
public boolean isOpaqueCube() {
return false;
}
}
@@ -0,0 +1,29 @@
package com.cricketcraft.chisel.block;
import java.util.Random;
import net.minecraft.block.material.Material;
import net.minecraft.init.Blocks;
import net.minecraft.init.Items;
import net.minecraft.item.Item;
public class BlockLightstoneCarvable extends BlockCarvable {
public BlockLightstoneCarvable() {
super(Material.glass);
}
@Override
public int quantityDropped(Random random) {
return Blocks.glowstone.quantityDropped(random);
}
@Override
public Item getItemDropped(int i, Random random, int a) {
return Items.glowstone_dust;
}
@Override
public int damageDropped(int i) {
return 0;
}
}
@@ -0,0 +1,57 @@
package com.cricketcraft.chisel.block;
import java.util.Random;
import net.minecraft.init.Blocks;
import net.minecraft.init.Items;
import net.minecraft.item.Item;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
public class BlockMarbleBookshelf extends BlockCarvable
{
public BlockMarbleBookshelf()
{
super();
}
@Override
@SideOnly(Side.CLIENT)
public IIcon getIcon(int side, int metadata)
{
if(side < 2)
return Blocks.planks.getBlockTextureFromSide(side);
return super.getIcon(side, metadata);
}
@Override
public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side)
{
if(side < 2)
return Blocks.planks.getBlockTextureFromSide(side);
return super.getIcon(world, x, y, z, side);
}
@Override
public int quantityDropped(Random par1Random)
{
return 3;
}
@Override
public Item getItemDropped(int par1, Random par2Random, int par3)
{
return Items.book;
}
@Override
public float getEnchantPowerBonus(World world, int x, int y, int z)
{
return 1;
}
}
@@ -0,0 +1,73 @@
package com.cricketcraft.chisel.block;
import java.util.List;
import com.cricketcraft.chisel.Chisel;
import com.cricketcraft.chisel.api.ICarvable;
import com.cricketcraft.chisel.carving.CarvableHelper;
import com.cricketcraft.chisel.carving.CarvableVariation;
import com.cricketcraft.chisel.init.ModTabs;
import net.minecraft.block.BlockCarpet;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.item.Item;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
public class BlockMarbleCarpet extends BlockCarpet implements ICarvable
{
public CarvableHelper carverHelper;
public BlockMarbleCarpet(Material m)
{
carverHelper = new CarvableHelper();
setCreativeTab(ModTabs.tabChiselBlocks);
}
@Override
public IIcon getIcon(int side, int metadata)
{
return carverHelper.getIcon(side, metadata);
}
@Override
public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side)
{
return carverHelper.getIcon(world, x, y, z, side);
}
@Override
public int damageDropped(int i)
{
return i;
}
@Override
public void registerBlockIcons(IIconRegister register)
{
carverHelper.registerBlockIcons("Chisel", this, register);
}
@Override
public void getSubBlocks(Item item, CreativeTabs tabs, List list)
{
carverHelper.registerSubBlocks(this, tabs, list);
}
@Override
public int getRenderType()
{
return Chisel.RenderCarpetId;
}
@Override
public CarvableVariation getVariation(int metadata)
{
return carverHelper.getVariation(metadata);
}
}
@@ -0,0 +1,82 @@
package com.cricketcraft.chisel.block;
import java.util.List;
import com.cricketcraft.chisel.api.ICarvable;
import com.cricketcraft.chisel.carving.CarvableHelper;
import com.cricketcraft.chisel.carving.CarvableVariation;
import com.cricketcraft.chisel.init.ModTabs;
import net.minecraft.block.Block;
import net.minecraft.block.BlockIce;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.stats.StatList;
import net.minecraft.util.IIcon;
import net.minecraft.world.World;
public class BlockMarbleIce extends BlockIce implements ICarvable
{
public CarvableHelper carverHelper;
public BlockMarbleIce()
{
super();
carverHelper = new CarvableHelper();
setCreativeTab(ModTabs.tabChiselBlocks);
}
@Override
public IIcon getIcon(int side, int metadata)
{
return carverHelper.getIcon(side, metadata);
}
@Override
public int damageDropped(int i)
{
return 0;
}
@Override
public void registerBlockIcons(IIconRegister register)
{
carverHelper.registerBlockIcons("Chisel", this, register);
}
@Override
public void getSubBlocks(Item item, CreativeTabs tabs, List list)
{
carverHelper.registerSubBlocks(this, tabs, list);
}
@Override
public void harvestBlock(World par1World, EntityPlayer par2EntityPlayer, int par3, int par4, int par5, int par6)
{
super.harvestBlock(par1World, par2EntityPlayer, par3, par4, par5, par6);
par2EntityPlayer.addStat(StatList.mineBlockStatArray[Block.getIdFromBlock(this)], 1);
par2EntityPlayer.addExhaustion(0.025F);
/*
if(this.canSilkHarvest(par1World, par2EntityPlayer, par3, par4, par5, par6) && EnchantmentHelper.getSilkTouchModifier(par2EntityPlayer))
{
ItemStack itemstack = this.createStackedBlock(par6);
if(itemstack != null)
{
this.dropBlockAsItem(par1World, par3, par4, par5, itemstack);
}
}
*/
}
@Override
public CarvableVariation getVariation(int metadata)
{
return carverHelper.getVariation(metadata);
}
}
@@ -0,0 +1,51 @@
package com.cricketcraft.chisel.block;
import java.util.Random;
import com.cricketcraft.chisel.carving.CarvableHelper;
import com.cricketcraft.chisel.init.ModBlocks;
import net.minecraft.block.Block;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.world.World;
public class BlockMarbleIceStairs extends BlockMarbleStairs
{
public BlockMarbleIceStairs(Block block, int meta, CarvableHelper helper)
{
super(block, meta, helper);
slipperiness = 0.98F;
setTickRandomly(true);
}
@Override
public void harvestBlock(World par1World, EntityPlayer par2EntityPlayer, int par3, int par4, int par5, int par6)
{
ModBlocks.ice.harvestBlock(par1World, par2EntityPlayer, par3, par4, par5, par6);
}
@Override
public int quantityDropped(Random par1Random)
{
return ModBlocks.ice.quantityDropped(par1Random);
}
@Override
public int damageDropped(int i)
{
return 0;
}
@Override
public void updateTick(World par1World, int par2, int par3, int par4, Random par5Random)
{
ModBlocks.ice.updateTick(par1World, par2, par3, par4, par5Random);
}
@Override
public int getMobilityFlag()
{
return 0;
}
}
@@ -0,0 +1,85 @@
package com.cricketcraft.chisel.block;
import java.util.Random;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.MovingObjectPosition;
import net.minecraft.world.World;
public class BlockMarbleLamp extends BlockCarvable {
BlockMarbleLamp blockUnpowered;
BlockMarbleLamp blockPowered;
boolean powered;
public BlockMarbleLamp() {
super(Material.redstoneLight);
powered = false;
blockUnpowered = this;
blockPowered = new BlockMarbleLamp(this);
setHardness(0.3F);
}
public BlockMarbleLamp(BlockMarbleLamp unpoweredVersion) {
super(Material.redstoneLight);
carverHelper = unpoweredVersion.carverHelper;
powered = true;
blockUnpowered = unpoweredVersion;
blockPowered = this;
setLightLevel(1.0F);
setHardness(0.3F);
}
public void checkPower(World world, int x, int y, int z) {
if (world.isRemote) return;
boolean isGettingPower = world.isBlockIndirectlyGettingPowered(x, y, z);
int meta = world.getBlockMetadata(x, y, z);
if (powered && !isGettingPower) {
world.setBlock(x, y, z, blockUnpowered, meta, 2);
} else if (!powered && isGettingPower) {
world.setBlock(x, y, z, blockPowered, meta, 2);
}
}
@Override
public void onBlockAdded(World world, int x, int y, int z) {
checkPower(world, x, y, z);
}
@Override
public void onNeighborBlockChange(World world, int x, int y, int z, Block block) {
checkPower(world, x, y, z);
}
/*
@Override
public void updateTick(World world, int x, int y, int z, Random rand){
if (world.isRemote) return;
if(powered && !world.isBlockIndirectlyGettingPowered(x, y, z)){
int meta=world.getBlockMetadata(x, y, z);
world.setBlock(x, y, z, Block.redstoneLampIdle.blockID, meta, 2);
}
}*/
@Override
public Item getItemDropped(int par1, Random par2Random, int par3) {
return Item.getItemFromBlock(blockUnpowered);
}
@Override
public ItemStack getPickBlock(MovingObjectPosition target, World world, int x, int y, int z) {
return new ItemStack(blockUnpowered, 1, world.getBlockMetadata(x, y, z));
}
}
@@ -0,0 +1,40 @@
package com.cricketcraft.chisel.block;
import com.cricketcraft.chisel.carving.CarvableVariation;
import com.cricketcraft.chisel.client.render.BlockMarblePillarRenderer;
import net.minecraft.block.material.Material;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
public class BlockMarblePillar extends BlockCarvable {
public IIcon sides[] = new IIcon[6];
public BlockMarblePillar(Material m) {
super(m);
}
@Override
public int getRenderType() {
return BlockMarblePillarRenderer.id;
}
@Override
public IIcon getIcon(int side, int metadata) {
return sides[side];
}
@Override
public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
return sides[side];
}
public IIcon getCtmIcon(int index, int metadata) {
CarvableVariation var = carverHelper.variations.get(metadata);
if (index >= 4) return var.iconTop;
if (var.seamsCtmVert == null) return var.icon;
return var.seamsCtmVert.icons[index];
}
}
@@ -0,0 +1,121 @@
package com.cricketcraft.chisel.block;
import java.util.List;
import java.util.Random;
import net.minecraft.block.Block;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.Entity;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.util.IIcon;
import net.minecraft.util.MovingObjectPosition;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
public class BlockMarbleSlab extends BlockCarvable
{
public Block master;
public BlockMarbleSlab bottom;
public BlockMarbleSlab top;
public boolean isBottom;
public BlockMarbleSlab(BlockCarvable marble)
{
opaque = true;
setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.5F, 1.0F);
master = marble;
bottom = this;
top = new BlockMarbleSlab(this);
isBottom = true;
}
public BlockMarbleSlab(BlockMarbleSlab bottomBlock)
{
super();
setBlockBounds(0.0F, 0.5F, 0.0F, 1.0F, 1.0F, 1.0F);
master = bottomBlock.master;
bottom = bottomBlock;
top = this;
carverHelper = bottomBlock.carverHelper;
isBottom = false;
}
@Override
public void setBlockBoundsBasedOnState(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
{
if(isBottom)
{
setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.5F, 1.0F);
} else
{
setBlockBounds(0.0F, 0.5F, 0.0F, 1.0F, 1.0F, 1.0F);
}
}
@Override
public void setBlockBoundsForItemRender()
{
setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.5F, 1.0F);
}
@Override
public void addCollisionBoxesToList(World par1World, int par2, int par3, int par4, AxisAlignedBB par5AxisAlignedBB, List par6List, Entity par7Entity)
{
setBlockBoundsBasedOnState(par1World, par2, par3, par4);
super.addCollisionBoxesToList(par1World, par2, par3, par4, par5AxisAlignedBB, par6List, par7Entity);
}
@Override
public boolean isOpaqueCube()
{
return false;
}
@Override
public int damageDropped(int meta)
{
return meta;
}
@Override
public Item getItemDropped(int par1, Random par2Random, int par3)
{
return Item.getItemFromBlock(bottom);
}
@Override
public boolean renderAsNormalBlock()
{
return false;
}
@Override
@SideOnly(Side.CLIENT)
public ItemStack getPickBlock(MovingObjectPosition mop, World world, int x, int y, int z)
{
return new ItemStack(bottom, 1, world.getBlockMetadata(x, y, z));
}
@Override
public IIcon getIcon(int side, int metadata)
{
return carverHelper.getIcon(side, metadata);
// return master.getIcon(side, metadata);
}
@Override
public void getSubBlocks(Item block, CreativeTabs tabs, List list)
{
if(isBottom)
super.getSubBlocks(block, tabs, list);
}
}
@@ -0,0 +1,110 @@
package com.cricketcraft.chisel.block;
import java.util.List;
import com.cricketcraft.chisel.api.ICarvable;
import com.cricketcraft.chisel.carving.CarvableHelper;
import com.cricketcraft.chisel.carving.CarvableVariation;
import com.cricketcraft.chisel.client.render.BlockMarbleStairsRenderer;
import com.cricketcraft.chisel.init.ModTabs;
import net.minecraft.block.Block;
import net.minecraft.block.BlockStairs;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.IIcon;
import net.minecraft.util.MathHelper;
import net.minecraft.world.World;
public class BlockMarbleStairs extends BlockStairs implements ICarvable
{
CarvableHelper carverHelper;
int blockMeta;
public BlockMarbleStairs(Block block, int meta, CarvableHelper helper)
{
super(block, meta);
this.useNeighborBrightness = true;
setCreativeTab(ModTabs.tabChiselBlocks);
carverHelper = helper;
blockMeta = meta;
}
@Override
public IIcon getIcon(int side, int metadata)
{
return carverHelper.getIcon(side, blockMeta + metadata / 8);
}
@Override
public int damageDropped(int i)
{
return i & 0x8;
}
@Override
public void registerBlockIcons(IIconRegister register)
{
if(blockMeta == 0)
carverHelper.registerBlockIcons("Chisel", this, register);
}
@Override
public void getSubBlocks(Item block, CreativeTabs tabs, List list)
{
list.add(new ItemStack(block, 1, 0));
list.add(new ItemStack(block, 1, 8));
}
@Override
public int getRenderType()
{
return BlockMarbleStairsRenderer.id;
}
@Override
public void onBlockPlacedBy(World par1World, int par2, int par3, int par4, EntityLivingBase par5EntityLiving, ItemStack par6ItemStack)
{
int l = MathHelper.floor_double((par5EntityLiving.rotationYaw * 4.0F / 360.0F) + 0.5D) & 3;
int i1 = par1World.getBlockMetadata(par2, par3, par4) & 4;
int odd = par6ItemStack.getItemDamage();
if(l == 0)
{
par1World.setBlockMetadataWithNotify(par2, par3, par4, 2 | i1 + odd, 2);
}
if(l == 1)
{
par1World.setBlockMetadataWithNotify(par2, par3, par4, 1 | i1 + odd, 2);
}
if(l == 2)
{
par1World.setBlockMetadataWithNotify(par2, par3, par4, 3 | i1 + odd, 2);
}
if(l == 3)
{
par1World.setBlockMetadataWithNotify(par2, par3, par4, 0 | i1 + odd, 2);
}
}
@Override
public int onBlockPlaced(World world, int x, int y, int z, int side, float hx, float hy, float hz, int damage)
{
// int res=super.onBlockPlaced();
return side != 0 && (side == 1 || hy <= 0.5D) ? damage : damage | 4;
}
@Override
public CarvableVariation getVariation(int metadata)
{
return carverHelper.getVariation(metadata);
}
}
@@ -0,0 +1,60 @@
package com.cricketcraft.chisel.block;
import com.cricketcraft.chisel.carving.CarvableHelper;
import com.cricketcraft.chisel.carving.CarvableVariation;
import com.cricketcraft.chisel.item.ItemCarvable;
import net.minecraft.block.Block;
import net.minecraft.item.ItemStack;
import net.minecraft.item.crafting.CraftingManager;
import cpw.mods.fml.common.registry.GameRegistry;
public class BlockMarbleStairsMaker
{
public CarvableHelper carverHelper;
BlockMarbleStairs blocks[];
//int idStart;
Block blockBase;
String blockName;
public BlockMarbleStairsMaker(Block base)
{
carverHelper = new CarvableHelper();
blockBase = base;
}
public void create(String name)
{
create(null, name);
}
public void create(BlockMarbleStairsMakerCreator creator, String name)
{
blocks = new BlockMarbleStairs[carverHelper.variations.size() / 2];
for(int i = 0; i < blocks.length; i++)
{
String n = name + "." + i;
blocks[i] = creator == null ?
new BlockMarbleStairs(blockBase, i * 2, carverHelper) :
creator.create(blockBase, i * 2, carverHelper);
blocks[i].setBlockName(n);
GameRegistry.registerBlock(blocks[i], ItemCarvable.class, n);
for(int meta = 0; meta < 2 && i * 2 + meta < carverHelper.variations.size(); meta++)
{
CarvableVariation variation = carverHelper.variations.get(i * 2 + meta);
for(int j = 0; j < 8; j++)
carverHelper.registerVariation(name + ".orientation." + j, variation, blocks[i], j + meta * 8);
CraftingManager.getInstance().addRecipe(new ItemStack(blocks[i], 4, meta * 8), new Object[]{"* ", "** ", "***", '*', new ItemStack(blockBase, 1, i * 2 + meta)});
}
CarvableHelper.chiselBlocks.add(blocks[i]);
}
}
}
@@ -0,0 +1,10 @@
package com.cricketcraft.chisel.block;
import com.cricketcraft.chisel.carving.CarvableHelper;
import net.minecraft.block.Block;
public interface BlockMarbleStairsMakerCreator
{
public BlockMarbleStairs create(Block block, int meta, CarvableHelper helper);
}
@@ -0,0 +1,69 @@
package com.cricketcraft.chisel.block;
import java.util.List;
import com.cricketcraft.chisel.api.ICarvable;
import com.cricketcraft.chisel.carving.CarvableHelper;
import com.cricketcraft.chisel.carving.CarvableVariation;
import com.cricketcraft.chisel.init.ModTabs;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.item.Item;
import net.minecraft.util.IIcon;
public class BlockMarbleTexturedOre extends BlockTexturedOre implements ICarvable
{
public CarvableHelper carverHelper;
public BlockMarbleTexturedOre(Material mat, String baseIcon)
{
super(mat, baseIcon);
carverHelper = new CarvableHelper();
setCreativeTab(ModTabs.tabChiselBlocks);
}
public BlockMarbleTexturedOre(Material mat, Block block) {
super(mat, block);
carverHelper = new CarvableHelper();
setCreativeTab(ModTabs.tabChiselBlocks);
}
@Override
public IIcon getIcon(int side, int metadata)
{
return carverHelper.getIcon(side, metadata);
}
@Override
public int damageDropped(int i)
{
return i;
}
@Override
public void registerBlockIcons(IIconRegister register)
{
super.registerBlockIcons(register);
carverHelper.registerBlockIcons("Chisel", this, register);
}
@Override
public void getSubBlocks(Item block, CreativeTabs tabs, List list)
{
carverHelper.registerSubBlocks(this, tabs, list);
}
@Override
public CarvableVariation getVariation(int metadata)
{
return carverHelper.getVariation(metadata);
}
}
@@ -0,0 +1,51 @@
package com.cricketcraft.chisel.block;
import java.util.List;
import com.cricketcraft.chisel.carving.CarvableHelper;
import com.cricketcraft.chisel.init.ModTabs;
import net.minecraft.block.Block;
import net.minecraft.block.BlockWall;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.item.Item;
import net.minecraft.util.IIcon;
public class BlockMarbleWall extends BlockWall
{
CarvableHelper carverHelper;
public BlockMarbleWall(Block block)
{
super(block);
carverHelper = new CarvableHelper();
setCreativeTab(ModTabs.tabChiselBlocks);
}
@Override
public IIcon getIcon(int side, int metadata)
{
return carverHelper.getIcon(side, metadata);
}
@Override
public int damageDropped(int i)
{
return i;
}
@Override
public void registerBlockIcons(IIconRegister register)
{
carverHelper.registerBlockIcons("Chisel", this, register);
}
@Override
public void getSubBlocks(Item block, CreativeTabs tabs, List list)
{
carverHelper.registerSubBlocks(this, tabs, list);
}
}
@@ -0,0 +1,440 @@
package com.cricketcraft.chisel.block;
import java.util.Calendar;
import java.util.Iterator;
import java.util.Random;
import com.cricketcraft.chisel.Chisel;
import com.cricketcraft.chisel.api.ICarvable;
import com.cricketcraft.chisel.block.tileentity.TileEntityPresent;
import com.cricketcraft.chisel.carving.CarvableHelper;
import com.cricketcraft.chisel.carving.CarvableVariation;
import com.cricketcraft.chisel.init.ModTabs;
import com.cricketcraft.chisel.inventory.InventoryLargePresent;
import net.minecraft.block.Block;
import net.minecraft.block.BlockContainer;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.item.EntityItem;
import net.minecraft.entity.passive.EntityOcelot;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.Container;
import net.minecraft.inventory.IInventory;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.util.MathHelper;
import net.minecraft.util.ResourceLocation;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import net.minecraftforge.common.util.ForgeDirection;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
public class BlockPresent extends BlockContainer implements ICarvable {
private final Random random = new Random();
public CarvableHelper carverHelper;
private boolean isChristmas = true;
public BlockPresent() {
super(Material.wood);
carverHelper = new CarvableHelper();
setCreativeTab(ModTabs.tabChiselBlocks);
setBlockBounds(0.0625F, 0.0F, 0.0625F, 0.9375F, 0875F, 0.9365F);
Calendar calendar = Calendar.getInstance();
if (calendar.get(2) + 1 == 12 && calendar.get(5) >= 25 && calendar.get(5) <= 26) {
isChristmas = true;//<--- this would have been false before and it lasts for two days :)
}
}
private static boolean isCatSittingOnMe(World world, int x, int y, int z) {
Iterator iterator = world.getEntitiesWithinAABB(EntityOcelot.class, AxisAlignedBB.getBoundingBox(x, y + 1, z, x + 1, y + 2, z + 1)).iterator();
EntityOcelot ocelot;
do {
if (!iterator.hasNext()) {
return false;
}
Entity entity = (Entity) iterator.next();
ocelot = (EntityOcelot) entity;
} while (!ocelot.isSitting());
return true;
}
public ResourceLocation getResourceSingle(int metadata) {
if (isChristmas) {
switch (metadata) {
case 1:
return new ResourceLocation(Chisel.MOD_ID, "textures/blocks/present/red.png");
default:
return null;
}
} else {
switch (metadata) {
case 1:
return new ResourceLocation(Chisel.MOD_ID, "textures/blocks/present/crate.png");
default:
return null;
}
}
}
public ResourceLocation getResourceDouble(int metadata) {
if (isChristmas) {
switch (metadata) {
case 1:
return new ResourceLocation(Chisel.MOD_ID, "textures/blocks/presentDouble/red.png");
default:
return null;
}
} else {
switch (metadata) {
case 1:
return new ResourceLocation(Chisel.MOD_ID, "textures/blocks/presentDouble/crate.png");
default:
return null;
}
}
}
@Override
public boolean isOpaqueCube() {
return false;
}
@Override
public boolean renderAsNormalBlock() {
return false;
}
@Override
public int getRenderType() {
return -1;
}
@Override
public void onBlockPlacedBy(World world, int x, int y, int z, EntityLivingBase entityLivingBase, ItemStack itemStack) {
Block front = world.getBlock(x, y, z - 1);
Block back = world.getBlock(x, y, z + 1);
Block left = world.getBlock(x - 1, y, z);
Block right = world.getBlock(x + 1, y, z);
byte metadata = 0;
int rot = MathHelper.floor_double((entityLivingBase.rotationYaw * 4.0F / 360.0F) + 0.5D) & 3;
if (rot == 0) {
metadata = 2;
}
if (rot == 1) {
metadata = 5;
}
if (rot == 2) {
metadata = 3;
}
if (rot == 3) {
metadata = 4;
}
if (front != this && back != this && left != this && right != this) {
world.setBlockMetadataWithNotify(x, y, z, metadata, 3);
} else {
if ((front == this || back == this) && (metadata == 4 || metadata == 5)) {
if (front == this) {
world.setBlockMetadataWithNotify(x, y, z - 1, metadata, 3);
} else {
world.setBlockMetadataWithNotify(x, y, z + 1, metadata, 3);
}
world.setBlockMetadataWithNotify(x, y, z, metadata, 3);
}
if ((left == this || right == this) && (metadata == 4 || metadata == 5)) {
if (left == this) {
world.setBlockMetadataWithNotify(x - 1, y, z, metadata, 3);
} else {
world.setBlockMetadataWithNotify(x + 1, y, z, metadata, 3);
}
world.setBlockMetadataWithNotify(x, y, z, metadata, 3);
}
}
}
@Override
public boolean canPlaceBlockAt(World world, int x, int y, int z) {
int l = 0;
if (world.getBlock(x - 1, y, z) == this) {
++l;
}
if (world.getBlock(x + 1, y, z) == this) {
++l;
}
if (world.getBlock(x, y, z - 1) == this) {
++l;
}
if (world.getBlock(x, y, z + 1) == this) {
++l;
}
return l > 1 ? false : (areSurroundingBlocksMe(world, x, y - 1, z) ? false : (areSurroundingBlocksMe(world, x, y + 1, z) ? false : (areSurroundingBlocksMe(world, x, y, z - 1) ? false : !areSurroundingBlocksMe(world, x, y, z + 1))));
}
private boolean areSurroundingBlocksMe(World world, int x, int y, int z) {
return world.getBlock(x, y, z) != this ? false : (world.getBlock(x - 1, y, z) == this ? true : (world.getBlock(x + 1, y, z) == this ? true : (world.getBlock(x, y, z - 1) == this ? true : world.getBlock(x, y, z + 1) == this)));
}
@Override
public void onNeighborBlockChange(World world, int x, int y, int z, Block neighbor) {
super.onNeighborBlockChange(world, x, y, z, neighbor);
TileEntityPresent tileEntityPresent = (TileEntityPresent) world.getTileEntity(x, y, z);
if (tileEntityPresent != null) {
tileEntityPresent.updateContainingBlockInfo();
}
}
@Override
public void breakBlock(World world, int x, int y, int z, Block present, int meta) {
TileEntityPresent tileEntityPresent = (TileEntityPresent) world.getTileEntity(x, y, z);
if (tileEntityPresent != null) {
for (int c = 0; c < tileEntityPresent.getSizeInventory(); c++) {
ItemStack itemStack = tileEntityPresent.getStackInSlot(c);
if (itemStack != null) {
float f = random.nextFloat() * 0.8F + 0.1F;
float f1 = random.nextFloat() * 0.8F + 0.1F;
EntityItem entityItem;
for (float f2 = random.nextFloat() * 0.8F + 0.1F; itemStack.stackSize > 0; world.spawnEntityInWorld(entityItem)) {
int stack = random.nextInt(21) + 10;
if (stack > itemStack.stackSize) {
stack = itemStack.stackSize;
}
itemStack.stackSize -= stack;
entityItem = new EntityItem(world, x + f, y + f1, z + f2, new ItemStack(itemStack.getItem(), stack, itemStack.getItemDamage()));
float motion = 0.05F;
entityItem.motionX = random.nextGaussian() * motion;
entityItem.motionY = random.nextGaussian() * motion + 0.2F;
entityItem.motionZ = random.nextGaussian() * motion;
if (itemStack.hasTagCompound()) {
entityItem.getEntityItem().setTagCompound((NBTTagCompound) itemStack.getTagCompound().copy());
}
}
}
}
world.func_147453_f(x, y, z, this);
}
super.breakBlock(world, x, y, z, this, meta);
}
@Override
public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int meta, float x1, float y1, float z1) {
if (!world.isRemote) {
player.openGui(Chisel.instance, 2, world, x, y, z);
return true;
} else {
return true;
}
}
@Override
public void setBlockBoundsBasedOnState(IBlockAccess world, int x, int y, int z) {
if (world.getBlock(x, y, z - 1) == this) {
this.setBlockBounds(0.0625F, 0.0F, 0.0F, 0.9375F, 0.875F, 0.9375F);
} else if (world.getBlock(x, y, z + 1) == this) {
this.setBlockBounds(0.0625F, 0.0F, 0.0625F, 0.9375F, 0.875F, 0.9375F);
} else if (world.getBlock(x - 1, y, z) == this) {
this.setBlockBounds(0.0F, 0.0F, 0.0625F, 0.9375F, 0.875F, 1.0F);
} else if (world.getBlock(x + 1, y, z) == this) {
this.setBlockBounds(0.0625F, 0.0F, 0.0625F, 1.0F, 0.875F, 0.9375F);
} else {
this.setBlockBounds(0.0625F, 0.0F, 0.0625F, 0.9375F, 0.875F, 0.9375F);
}
}
@Override
public void onBlockAdded(World world, int x, int y, int z) {
super.onBlockAdded(world, x, y, z);
this.changeMetadataBasedOffSpecs(world, x, y, z);
Block back = world.getBlock(x, y, z - 1);
Block front = world.getBlock(x, y, z + 1);
Block left = world.getBlock(x - 1, y, z);
Block right = world.getBlock(x + 1, y, z);
if (back == this) {
this.changeMetadataBasedOffSpecs(world, x, y, z - 1);
}
if (front == this) {
this.changeMetadataBasedOffSpecs(world, x, y, z + 1);
}
if (left == this) {
this.changeMetadataBasedOffSpecs(world, x - 1, y, z);
}
if (right == this) {
this.changeMetadataBasedOffSpecs(world, x + 1, y, z);
}
}
public void changeMetadataBasedOffSpecs(World world, int x, int y, int z) {
if (!world.isRemote) {
Block back = world.getBlock(x, y, z - 1);
Block front = world.getBlock(x, y, z + 1);
Block left = world.getBlock(x - 1, y, z);
Block right = world.getBlock(x + 1, y, z);
boolean flag = true, flag1;
byte metadata;
int x1, blockMeta, z1;
Block backLeft, frontRight;
if (front != this && back != this) {
if (left != this && right != this) {
metadata = 3;
if (front.func_149730_j() && !back.func_149730_j()) {
metadata = 3;
}
if (back.func_149730_j() && !front.func_149730_j()) {
metadata = 2;
}
if (left.func_149730_j() && !right.func_149730_j()) {
metadata = 5;
}
if (right.func_149730_j() && !left.func_149730_j()) {
metadata = 4;
}
} else {
x1 = back == this ? x - 1 : x + 1;
backLeft = world.getBlock(x1, y, z - 1);
z1 = back == this ? z - 1 : z + 1;
frontRight = world.getBlock(x + 1, y, z1);
metadata = 5;
flag1 = true;
if (back == this) {
blockMeta = world.getBlockMetadata(x, y, z - 1);
} else {
blockMeta = world.getBlockMetadata(x, y, z + 1);
}
if (blockMeta == 4) {
metadata = 4;
}
if ((left.func_149730_j() || backLeft.func_149730_j()) && !right.func_149730_j() && !frontRight.func_149730_j()) {
metadata = 5;
}
if ((right.func_149730_j() || frontRight.func_149730_j()) && !left.func_149730_j() && !backLeft.func_149730_j()) {
metadata = 4;
}
}
world.setBlockMetadataWithNotify(x, y, z, metadata, 3);
}
}
}
@Override
public TileEntity createNewTileEntity(World world, int par2) {
return new TileEntityPresent();
}
@Override
public int isProvidingWeakPower(IBlockAccess world, int x, int y, int z, int strength) {
if (!canProvidePower()) {
return 0;
} else {
int players = ((TileEntityPresent) world.getTileEntity(x, y, z)).numPlayersUsing;
return MathHelper.clamp_int(players, 0, 15);
}
}
@Override
public int isProvidingStrongPower(IBlockAccess world, int x, int y, int z, int strength) {
return strength == 1 ? isProvidingWeakPower(world, x, y, z, strength) : 0;
}
@Override
public boolean hasComparatorInputOverride() {
return true;
}
@Override
public int getComparatorInputOverride(World world, int x, int y, int z, int strength) {
return Container.calcRedstoneFromInventory(getInventory(world, x, y, z));
}
@SideOnly(Side.CLIENT)
public void registerBlockIcons(IIconRegister register) {
this.blockIcon = register.registerIcon("planks_oak");
}
public IInventory getInventory(World world, int x, int y, int z) {
Object object = (TileEntityPresent) world.getTileEntity(x, y, z);
if (object == null) {
return null;
} else if (world.isSideSolid(x, y + 1, z, ForgeDirection.DOWN)) {
return null;
} else if (isCatSittingOnMe(world, x, y, z)) {
return null;
} else if (world.getBlock(x - 1, y, z) == this && (world.isSideSolid(x - 1, y + 1, z, ForgeDirection.DOWN) || isCatSittingOnMe(world, x, y - 1, z))) {
return null;
} else if (world.getBlock(x + 1, y, z) == this && (world.isSideSolid(x + 1, y + 1, z, ForgeDirection.DOWN) || isCatSittingOnMe(world, x, y + 1, z))) {
return null;
} else if (world.getBlock(x, y, z - 1) == this && (world.isSideSolid(x, y + 1, z - 1, ForgeDirection.DOWN) || isCatSittingOnMe(world, x, y, z - 1))) {
return null;
} else if (world.getBlock(x, y, z + 1) == this && (world.isSideSolid(x, y + 1, z + 1, ForgeDirection.DOWN) || isCatSittingOnMe(world, x, y, z + 1))) {
return null;
} else {
if (world.getBlock(x - 1, y, z) == this) {
object = new InventoryLargePresent("container.chestDouble", (TileEntityPresent) world.getTileEntity(x - 1, y, z), (IInventory) object);
}
if (world.getBlock(x + 1, y, z) == this) {
object = new InventoryLargePresent("container.chestDouble", (TileEntityPresent) world.getTileEntity(x + 1, y, z), (IInventory) object);
}
if (world.getBlock(x, y, z - 1) == this) {
object = new InventoryLargePresent("container.chestDouble", (TileEntityPresent) world.getTileEntity(x, y, z - 1), (IInventory) object);
}
if (world.getBlock(x, y, z + 1) == this) {
object = new InventoryLargePresent("container.chestDouble", (TileEntityPresent) world.getTileEntity(x, y, z + 1), (IInventory) object);
}
return (IInventory) object;
}
}
@Override
public CarvableVariation getVariation(int metadata) {
return carverHelper.getVariation(metadata);
}
}
@@ -0,0 +1,82 @@
package com.cricketcraft.chisel.block;
import com.cricketcraft.chisel.client.render.BlockRoadLineRenderer;
import com.cricketcraft.chisel.init.ModTabs;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.init.Blocks;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.util.IIcon;
import net.minecraft.world.World;
public class BlockRoadLine extends Block
{
public IIcon aloneIcon;
public IIcon halfLineIcon;
public IIcon fullLineIcon;
public BlockRoadLine()
{
super(Material.circuits);
this.setBlockBounds(0.0f, 0.0f, 0.0f, 1.0f, 0.00390625f, 1.0f);
// this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.0625F, 1.0F);
setCreativeTab(ModTabs.tabChiselBlocks);
}
@Override
public AxisAlignedBB getCollisionBoundingBoxFromPool(World par1World, int par2, int par3, int par4)
{
return null;
}
@Override
public boolean isOpaqueCube()
{
return false;
}
@Override
public boolean renderAsNormalBlock()
{
return false;
}
@Override
public int getRenderType()
{
return BlockRoadLineRenderer.id;
}
@Override
public boolean canPlaceBlockAt(World par1World, int par2, int par3, int par4)
{
return par1World.doesBlockHaveSolidTopSurface(par1World, par2, par3 - 1, par4) || par1World.getBlock(par2, par3 - 1, par4).equals(Blocks.glowstone);
}
@Override
public void onNeighborBlockChange(World par1World, int par2, int par3, int par4, Block block)
{
if(par1World.isRemote) return;
if(!this.canPlaceBlockAt(par1World, par2, par3, par4))
{
this.dropBlockAsItem(par1World, par2, par3, par4, 0, 0);
par1World.setBlockToAir(par2, par3, par4);
}
super.onNeighborBlockChange(par1World, par2, par3, par4, block);
}
@Override
public void registerBlockIcons(IIconRegister reg)
{
blockIcon = aloneIcon = reg.registerIcon("Chisel:line-marking/white-center");
halfLineIcon = reg.registerIcon("Chisel:line-marking/white-side");
fullLineIcon = reg.registerIcon("Chisel:line-marking/white-long");
}
}
@@ -0,0 +1,576 @@
package com.cricketcraft.chisel.block;
import java.util.List;
import com.cricketcraft.chisel.client.render.BlockSnakeStoneRenderer;
import com.cricketcraft.chisel.init.ModTabs;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.IIcon;
import net.minecraft.util.MathHelper;
import net.minecraft.world.World;
public class BlockSnakestone extends Block
{
static final int SEC_HEAD = 0;
static final int SEC_DOWN = 4;
static final int SEC_UP = 8;
static final int SEC_HOR = 12;
static final int SIDE_B = 0;
static final int SIDE_T = 1;
static final int SIDE_N = 2;
static final int SIDE_S = 3;
static final int SIDE_W = 4;
static final int SIDE_E = 5;
String iconPrefix;
IIcon iconFaceLeft;
IIcon iconFaceRight;
IIcon iconCross;
IIcon iconFace;
IIcon iconTopTip;
IIcon iconTopSide;
IIcon iconBottom;
IIcon iconBottomSide;
IIcon iconBottomTip;
IIcon iconLeftDown;
IIcon iconRightDown;
IIcon iconLeftUp;
IIcon iconRightUp;
IIcon iconLeftTip;
IIcon iconSide;
IIcon iconRightTip;
IIcon iconTop;
public boolean flipTopTextures;
public BlockSnakestone(String iconPrefix)
{
super(Material.rock);
setHardness(1.5F);
setResistance(10.0F);
setStepSound(Block.soundTypeStone);
setCreativeTab(ModTabs.tabChiselBlocks);
flipTopTextures = false;
this.iconPrefix = iconPrefix;
}
@Override
public int getRenderType()
{
return BlockSnakeStoneRenderer.id;
}
static final int[] rotRemap = {0, 3, 1, 2};
@Override
public void onBlockPlacedBy(World world, int x, int y, int z, EntityLivingBase entity, ItemStack stack)
{
int meta = world.getBlockMetadata(x, y, z);
if(meta > 3) return;
if(rotateHead(world, x, y, z) != -1)
return;
int rot = rotRemap[(MathHelper.floor_double(entity.rotationYaw * 4.0 / 360.0 + 0.5)) & 3];
world.setBlockMetadataWithNotify(x, y, z, rot, 3);
}
@Override
public int onBlockPlaced(World world, int x, int y, int z, int side, float hx, float hy, float hz, int meta)
{
if(meta <= 3) return meta;
if(rotateBodyPart(world, x, y, z))
{
return world.getBlockMetadata(x, y, z);
}
if(side == 0 || side == 1) meta = 14;
if(side == 2 || side == 3) meta = 13;
if(side == 4 || side == 5) meta = 12;
world.setBlockMetadataWithNotify(x, y, z, meta, 2);
return meta;
}
@Override
public void onNeighborBlockChange(World world, int x, int y, int z, Block block)
{
int kind = world.getBlockMetadata(x, y, z) & 0xC;
if(kind == 0)
{
rotateHead(world, x, y, z);
} else
{
rotateBodyPart(world, x, y, z);
}
}
public int[] getConnections(World world, int ox, int oy, int oz)
{
int index = 0;
int[] res = {-1, -1, -1, -1, -1, -1, -1};
for(int direction = 0; direction < 6; direction++)
{
int x = ox, y = oy, z = oz;
switch(direction)
{
case 0:
z--;
break;
case 1:
z++;
break;
case 2:
x--;
break;
case 3:
x++;
break;
case 4:
y--;
break;
case 5:
y++;
break;
}
if(!world.getBlock(x, y, z).equals(this)) continue;
boolean match = false;
int px1 = x, px2 = x;
int py1 = y, py2 = y;
int pz1 = z, pz2 = z;
int meta = world.getBlockMetadata(x, y, z);
if((meta & 0xc) == 4 || (meta & 0xc) == 8)
{
if((meta & 4) == 4) py1--;
else py1++;
switch(meta & 3)
{
case 0:
pz2--;
break;
case 1:
pz2++;
break;
case 2:
px2--;
break;
case 3:
px2++;
break;
}
} else if(meta == 12)
{
px1--;
px2++;
} else if(meta == 13)
{
pz1--;
pz2++;
} else if(meta == 14)
{
py1--;
py2++;
} else if(meta == 15)
{
match = true;
} else if(meta < 4)
{
match = true;
}
if(!match)
{
Block b1 = world.getBlock(px1, py1, pz1);
Block b2 = world.getBlock(px2, py2, pz2);
if(b1 != this || b2 != this)
match = true;
if(ox == px1 && oy == py1 && oz == pz1)
match = true;
if(ox == px2 && oy == py2 && oz == pz2)
match = true;
}
if(match)
res[index++] = direction;
}
if(index != 5)
res[index] = -1;
return res;
}
public boolean rotateBodyPart(World world, int x, int y, int z)
{
int[] con = getConnections(world, x, y, z);
int blockMeta = world.getBlockMetadata(x, y, z);
int kind = blockMeta & 0xc;
if(con[1] == -1) return false;
if(con[2] != -1) return false;
int meta = 15;
if(con[0] == 2 && con[1] == 3)
{
meta = 12;
} else if(con[0] == 0 && con[1] == 1)
{
meta = 13;
} else if(con[0] == 4 && con[1] == 5)
{
meta = 14;
} else if(con[1] == 4)
{
meta = SEC_DOWN | con[0];
} else if(con[1] == 5)
{
meta = SEC_UP | con[0];
}
if(blockMeta != meta)
world.setBlockMetadataWithNotify(x, y, z, meta, 3);
return true;
}
public int rotateHead(World world, int x, int y, int z)
{
int[] con = getConnections(world, x, y, z);
if(con[1] >= 0 && con[1] < 4) return -1;
int meta = -1;
switch(con[0])
{
case 0:
meta = 1;
break;
case 1:
meta = 0;
break;
case 2:
meta = 3;
break;
case 3:
meta = 2;
break;
}
if(meta == -1) return -1;
world.setBlock(x, y, z, this, meta, 3);
return meta;
}
public boolean connectedTo(World par1World, int x, int y, int z, int direction)
{
switch(direction)
{
case 0:
return par1World.getBlock(x, y, z - 1).equals(this);
case 1:
return par1World.getBlock(x, y, z + 1).equals(this);
case 2:
return par1World.getBlock(x - 1, y, z).equals(this);
case 3:
return par1World.getBlock(x + 1, y, z).equals(this);
case 4:
return par1World.getBlock(x, y - 1, z).equals(this);
case 5:
return par1World.getBlock(x, y + 1, z).equals(this);
}
return false;
}
@Override
public IIcon getIcon(int side, int meta)
{
int type = meta & 0xc;
int orient = meta & 0x3;
switch(meta | (side << 4))
{
case (SEC_HOR | 0 | (SIDE_B << 4)):
return iconBottomTip;
case (SEC_HOR | 0 | (SIDE_T << 4)):
return iconTopSide;
case (SEC_HOR | 0 | (SIDE_N << 4)):
return iconSide;
case (SEC_HOR | 0 | (SIDE_S << 4)):
return iconSide;
case (SEC_HOR | 0 | (SIDE_W << 4)):
return iconCross;
case (SEC_HOR | 0 | (SIDE_E << 4)):
return iconCross;
case (SEC_HOR | 1 | (SIDE_B << 4)):
return iconBottomTip;
case (SEC_HOR | 1 | (SIDE_T << 4)):
return iconTopSide;
case (SEC_HOR | 1 | (SIDE_N << 4)):
return iconCross;
case (SEC_HOR | 1 | (SIDE_S << 4)):
return iconCross;
case (SEC_HOR | 1 | (SIDE_W << 4)):
return iconSide;
case (SEC_HOR | 1 | (SIDE_E << 4)):
return iconSide;
case (SEC_HOR | 2 | (SIDE_B << 4)):
return iconCross;
case (SEC_HOR | 2 | (SIDE_T << 4)):
return iconCross;
case (SEC_HOR | 2 | (SIDE_N << 4)):
return iconSide;
case (SEC_HOR | 2 | (SIDE_S << 4)):
return iconSide;
case (SEC_HOR | 2 | (SIDE_W << 4)):
return iconSide;
case (SEC_HOR | 2 | (SIDE_E << 4)):
return iconSide;
case (SEC_HOR | 3 | (SIDE_B << 4)):
return iconBottom;
case (SEC_HOR | 3 | (SIDE_T << 4)):
return iconTop;
case (SEC_HOR | 3 | (SIDE_N << 4)):
return iconSide;
case (SEC_HOR | 3 | (SIDE_S << 4)):
return iconSide;
case (SEC_HOR | 3 | (SIDE_W << 4)):
return iconSide;
case (SEC_HOR | 3 | (SIDE_E << 4)):
return iconSide;
case (SEC_DOWN | 0 | (SIDE_B << 4)):
return iconCross;
case (SEC_DOWN | 0 | (SIDE_T << 4)):
return iconTopTip;
case (SEC_DOWN | 0 | (SIDE_N << 4)):
return iconCross;
case (SEC_DOWN | 0 | (SIDE_S << 4)):
return iconRightTip;
case (SEC_DOWN | 0 | (SIDE_W << 4)):
return iconLeftDown;
case (SEC_DOWN | 0 | (SIDE_E << 4)):
return iconRightDown;
case (SEC_DOWN | 1 | (SIDE_B << 4)):
return iconCross;
case (SEC_DOWN | 1 | (SIDE_T << 4)):
return iconTopTip;
case (SEC_DOWN | 1 | (SIDE_N << 4)):
return iconLeftTip;
case (SEC_DOWN | 1 | (SIDE_S << 4)):
return iconCross;
case (SEC_DOWN | 1 | (SIDE_W << 4)):
return iconRightDown;
case (SEC_DOWN | 1 | (SIDE_E << 4)):
return iconLeftDown;
case (SEC_DOWN | 2 | (SIDE_B << 4)):
return iconCross;
case (SEC_DOWN | 2 | (SIDE_T << 4)):
return iconTopTip;
case (SEC_DOWN | 2 | (SIDE_N << 4)):
return iconRightDown;
case (SEC_DOWN | 2 | (SIDE_S << 4)):
return iconLeftDown;
case (SEC_DOWN | 2 | (SIDE_W << 4)):
return iconCross;
case (SEC_DOWN | 2 | (SIDE_E << 4)):
return iconLeftTip;
case (SEC_DOWN | 3 | (SIDE_B << 4)):
return iconCross;
case (SEC_DOWN | 3 | (SIDE_T << 4)):
return iconTopTip;
case (SEC_DOWN | 3 | (SIDE_N << 4)):
return iconLeftDown;
case (SEC_DOWN | 3 | (SIDE_S << 4)):
return iconRightDown;
case (SEC_DOWN | 3 | (SIDE_W << 4)):
return iconRightTip;
case (SEC_DOWN | 3 | (SIDE_E << 4)):
return iconCross;
case (SEC_UP | 0 | (SIDE_B << 4)):
return iconBottomSide;
case (SEC_UP | 0 | (SIDE_T << 4)):
return iconCross;
case (SEC_UP | 0 | (SIDE_N << 4)):
return iconCross;
case (SEC_UP | 0 | (SIDE_S << 4)):
return iconLeftTip;
case (SEC_UP | 0 | (SIDE_W << 4)):
return iconLeftUp;
case (SEC_UP | 0 | (SIDE_E << 4)):
return iconRightUp;
case (SEC_UP | 1 | (SIDE_B << 4)):
return iconBottomSide;
case (SEC_UP | 1 | (SIDE_T << 4)):
return iconCross;
case (SEC_UP | 1 | (SIDE_N << 4)):
return iconRightTip;
case (SEC_UP | 1 | (SIDE_S << 4)):
return iconCross;
case (SEC_UP | 1 | (SIDE_W << 4)):
return iconRightUp;
case (SEC_UP | 1 | (SIDE_E << 4)):
return iconLeftUp;
case (SEC_UP | 2 | (SIDE_B << 4)):
return iconBottomSide;
case (SEC_UP | 2 | (SIDE_T << 4)):
return iconCross;
case (SEC_UP | 2 | (SIDE_N << 4)):
return iconRightUp;
case (SEC_UP | 2 | (SIDE_S << 4)):
return iconLeftUp;
case (SEC_UP | 2 | (SIDE_W << 4)):
return iconCross;
case (SEC_UP | 2 | (SIDE_E << 4)):
return iconRightTip;
case (SEC_UP | 3 | (SIDE_B << 4)):
return iconBottomSide;
case (SEC_UP | 3 | (SIDE_T << 4)):
return iconCross;
case (SEC_UP | 3 | (SIDE_N << 4)):
return iconLeftUp;
case (SEC_UP | 3 | (SIDE_S << 4)):
return iconRightUp;
case (SEC_UP | 3 | (SIDE_W << 4)):
return iconLeftTip;
case (SEC_UP | 3 | (SIDE_E << 4)):
return iconCross;
case (SEC_HEAD | 0 | (SIDE_B << 4)):
return iconBottomSide;
case (SEC_HEAD | 0 | (SIDE_T << 4)):
return iconTopTip;
case (SEC_HEAD | 0 | (SIDE_N << 4)):
return iconFace;
case (SEC_HEAD | 0 | (SIDE_S << 4)):
return iconCross;
case (SEC_HEAD | 0 | (SIDE_W << 4)):
return iconFaceLeft;
case (SEC_HEAD | 0 | (SIDE_E << 4)):
return iconFaceRight;
case (SEC_HEAD | 1 | (SIDE_B << 4)):
return iconBottomSide;
case (SEC_HEAD | 1 | (SIDE_T << 4)):
return iconTopTip;
case (SEC_HEAD | 1 | (SIDE_N << 4)):
return iconCross;
case (SEC_HEAD | 1 | (SIDE_S << 4)):
return iconFace;
case (SEC_HEAD | 1 | (SIDE_W << 4)):
return iconFaceRight;
case (SEC_HEAD | 1 | (SIDE_E << 4)):
return iconFaceLeft;
case (SEC_HEAD | 2 | (SIDE_B << 4)):
return iconBottomSide;
case (SEC_HEAD | 2 | (SIDE_T << 4)):
return iconTopTip;
case (SEC_HEAD | 2 | (SIDE_N << 4)):
return iconFaceRight;
case (SEC_HEAD | 2 | (SIDE_S << 4)):
return iconFaceLeft;
case (SEC_HEAD | 2 | (SIDE_W << 4)):
return iconFace;
case (SEC_HEAD | 2 | (SIDE_E << 4)):
return iconCross;
case (SEC_HEAD | 3 | (SIDE_B << 4)):
return iconBottomSide;
case (SEC_HEAD | 3 | (SIDE_T << 4)):
return iconTopTip;
case (SEC_HEAD | 3 | (SIDE_N << 4)):
return iconFaceLeft;
case (SEC_HEAD | 3 | (SIDE_S << 4)):
return iconFaceRight;
case (SEC_HEAD | 3 | (SIDE_W << 4)):
return iconCross;
case (SEC_HEAD | 3 | (SIDE_E << 4)):
return iconFace;
}
return iconCross;
}
@Override
public void getSubBlocks(Item item, CreativeTabs tabs, List list)
{
list.add(new ItemStack(item, 1, 1));
list.add(new ItemStack(item, 1, 13));
}
@Override
public int damageDropped(int meta)
{
if(meta < 4)
{
return 1;
}
return 13;
}
@Override
public void registerBlockIcons(IIconRegister register)
{
iconFaceLeft = register.registerIcon(iconPrefix + "face-left");
iconFaceRight = register.registerIcon(iconPrefix + "face-right");
iconFace = register.registerIcon(iconPrefix + "face");
iconLeftUp = register.registerIcon(iconPrefix + "left-up");
iconLeftDown = register.registerIcon(iconPrefix + "left-down");
iconLeftTip = register.registerIcon(iconPrefix + "left-tip");
iconRightUp = register.registerIcon(iconPrefix + "right-up");
iconRightDown = register.registerIcon(iconPrefix + "right-down");
iconRightTip = register.registerIcon(iconPrefix + "right-tip");
iconTop = register.registerIcon(iconPrefix + "top");
iconTopTip = register.registerIcon(iconPrefix + "top-tip");
iconTopSide = register.registerIcon(iconPrefix + "top-side");
iconBottom = register.registerIcon(iconPrefix + "bot");
iconBottomTip = register.registerIcon(iconPrefix + "bot-tip");
iconBottomSide = register.registerIcon(iconPrefix + "bot-side");
iconCross = register.registerIcon(iconPrefix + "crosssection");
iconSide = register.registerIcon(iconPrefix + "side");
}
}
@@ -0,0 +1,41 @@
package com.cricketcraft.chisel.block;
import java.util.Random;
import com.cricketcraft.chisel.client.GeneralChiselClient;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.util.IIcon;
import net.minecraft.world.World;
public class BlockSnakestoneObsidian extends BlockSnakestone
{
public IIcon[] particles = new IIcon[8];
public BlockSnakestoneObsidian(String iconPrefix)
{
super(iconPrefix);
flipTopTextures = true;
}
@Override
public void randomDisplayTick(World world, int x, int y, int z, Random random)
{
GeneralChiselClient.spawnSnakestoneObsidianFX(world, this, x, y, z);
}
@Override
public void registerBlockIcons(IIconRegister register)
{
super.registerBlockIcons(register);
for(int i = 0; i < particles.length; i++)
{
particles[i] = register.registerIcon(iconPrefix + "particles/" + i);
}
}
}
@@ -0,0 +1,80 @@
package com.cricketcraft.chisel.block;
import com.cricketcraft.chisel.Configurations;
import com.cricketcraft.chisel.client.GeneralChiselClient;
import com.cricketcraft.chisel.client.render.BlockSpikesRenderer;
import com.cricketcraft.chisel.utils.General;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.Entity;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.util.IIcon;
import net.minecraft.world.World;
import cpw.mods.fml.common.FMLCommonHandler;
import cpw.mods.fml.relauncher.Side;
public class BlockSpikes extends Block
{
public IIcon iconBase;
public IIcon iconSpike;
public BlockSpikes(Material mat)
{
super(Material.circuits);
this.setCreativeTab(CreativeTabs.tabDecorations);
this.setBlockBounds(0.0f, 0.0f, 0.0f, 1.0f, 1.0f / 16, 1.0f);
}
@Override
public AxisAlignedBB getCollisionBoundingBoxFromPool(World world, int x, int y, int z)
{
return null;
}
@Override
public void onEntityCollidedWithBlock(World world, int x, int y, int z, Entity entity)
{
if(FMLCommonHandler.instance().getEffectiveSide() == Side.CLIENT)
return;
double dy = entity.posY - entity.prevPosY;
GeneralChiselClient.speedupPlayer(world, entity, Configurations.concreteVelocity);
}
@Override
public boolean isOpaqueCube()
{
return false;
}
@Override
public boolean renderAsNormalBlock()
{
return true;
}
@Override
public int getRenderType()
{
return BlockSpikesRenderer.id;
}
@Override
public int damageDropped(int meta)
{
return 0;
}
@Override
public void registerBlockIcons(IIconRegister register)
{
blockIcon = iconBase = register.registerIcon(General.getName(this) + "base");
iconSpike = register.registerIcon(General.getName(this) + "spike");
}
}
@@ -0,0 +1,64 @@
package com.cricketcraft.chisel.block;
import com.cricketcraft.chisel.client.render.BlockTexturedOreRenderer;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.util.IIcon;
public class BlockTexturedOre extends Block
{
public int currentPass;
public Block base;
public IIcon icon;
String iconFile;
public BlockTexturedOre(Material mat, Block base)
{
super(mat);
this.base = base;
}
public BlockTexturedOre(Material mat, String iconFile)
{
super(mat);
this.iconFile = iconFile;
}
@Override
public boolean renderAsNormalBlock()
{
return false;
}
@Override
public int getRenderType()
{
return BlockTexturedOreRenderer.id;
}
@Override
public int getRenderBlockPass()
{
return 1;
}
@Override
public boolean canRenderInPass(int pass)
{
currentPass = pass;
return pass == 1 || pass == 0;
}
@Override
public void registerBlockIcons(IIconRegister register)
{
if(iconFile != null)
icon = register.registerIcon(iconFile);
}
}
@@ -0,0 +1,12 @@
package com.cricketcraft.chisel.block;
import net.minecraft.block.material.Material;
public class BlockVoidstone extends BlockMarbleTexturedOre {
public BlockVoidstone(String s) {
super(Material.rock, s);
setHardness(5.0F);
setResistance(10.0F);
}
}
@@ -0,0 +1,53 @@
package com.cricketcraft.chisel.block;
import com.cricketcraft.chisel.Chisel;
import com.cricketcraft.chisel.api.ICarvable;
import com.cricketcraft.chisel.carving.CarvableHelper;
import com.cricketcraft.chisel.carving.CarvableVariation;
import com.cricketcraft.chisel.init.ModTabs;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.util.IIcon;
public class BlockVoidstonePillar extends Block implements ICarvable{
public static IIcon topBottom, pillarSide;
public CarvableHelper carvableHelper;
private boolean isAnimated;
public BlockVoidstonePillar(boolean isAnimated) {
super(Material.rock);
carvableHelper = new CarvableHelper();
setHardness(5.0F);
setResistance(10.0F);
setCreativeTab(ModTabs.tabChiselBlocks);
this.isAnimated = isAnimated;
}
@Override
public IIcon getIcon(int side, int meta){
if(side == 0 || side == 1){
return topBottom;
} else {
return pillarSide;
}
}
@Override
public void registerBlockIcons(IIconRegister icon){
if(this.isAnimated)
topBottom = icon.registerIcon(Chisel.MOD_ID + ":voidstone/animated/pillar-top");
else
topBottom = icon.registerIcon(Chisel.MOD_ID + ":voidstone/pillar-top");
pillarSide = icon.registerIcon(Chisel.MOD_ID + ":voidstone/pillar-side");
}
@Override
public CarvableVariation getVariation(int metadata) {
return carvableHelper.getVariation(metadata);
}
}
@@ -0,0 +1,15 @@
package com.cricketcraft.chisel.block;
import net.minecraft.block.material.Material;
public class BlockWaterstone extends BlockMarbleTexturedOre {
public BlockWaterstone(Material mat, String baseIcon) {
super(mat, baseIcon);
}
@Override
public boolean renderAsNormalBlock() {
return true;
}
}
@@ -0,0 +1,35 @@
package com.cricketcraft.chisel.block;
import java.util.List;
import net.minecraft.block.Block;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.ItemBlock;
import net.minecraft.item.ItemStack;
import net.minecraft.util.StatCollector;
public class ItemBlockAutoChisel extends ItemBlock{
private final String[] names = {"base", "speed", "automation", "stack"};
private int metadata;
public ItemBlockAutoChisel(Block block) {
super(block);
setHasSubtypes(true);
}
@Override
public int getMetadata(int meta){
return meta;
}
@Override
public String getUnlocalizedName(ItemStack itemStack){
return getUnlocalizedName() + "." + names[itemStack.getItemDamage()];
}
@Override
public void addInformation(ItemStack itemStack, EntityPlayer player, List list, boolean par4){
list.add(StatCollector.translateToLocal(getUnlocalizedName() + "." + names[itemStack.getItemDamage()] + ".desc"));
}
}
@@ -0,0 +1,236 @@
package com.cricketcraft.chisel.block.tileentity;
import net.minecraft.entity.item.EntityItem;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.ISidedInventory;
import net.minecraft.item.ItemBlock;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import net.minecraft.network.NetworkManager;
import net.minecraft.network.Packet;
import net.minecraft.network.play.server.S35PacketUpdateTileEntity;
import net.minecraft.tileentity.TileEntity;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
public class TileEntityAutoChisel extends TileEntity implements ISidedInventory {
private static EntityItem ghostItem;
boolean equal = false;
private ItemStack[] inventory = new ItemStack[3];
private String name = "autoChisel";
@Override
public boolean canUpdate() {
return true;
}
@Override
public ItemStack decrStackSize(int slot, int size) {
if (inventory[slot] != null) {
ItemStack is;
if (inventory[slot].stackSize <= size) {
is = inventory[slot];
inventory[slot] = null;
return is;
} else {
is = inventory[slot].splitStack(size);
if (inventory[slot].stackSize == 0)
inventory[slot] = null;
return is;
}
} else
return null;
}
@Override
public void readFromNBT(NBTTagCompound nbt) {
super.readFromNBT(nbt);
NBTTagList tags = nbt.getTagList("Items", 10);
inventory = new ItemStack[getSizeInventory()];
for (int i = 0; i < tags.tagCount(); i++) {
NBTTagCompound data = tags.getCompoundTagAt(i);
int j = data.getByte("Slot") & 255;
if (j >= 0 && j < inventory.length) {
inventory[j] = ItemStack.loadItemStackFromNBT(data);
}
}
if (nbt.hasKey("CustomName", 8)) {
this.name = nbt.getString("CustomName");
}
}
@Override
public void updateEntity() {
if (!worldObj.isRemote && worldObj.getWorldTime() % 20 == 0) {
if (inventory[0] != null && inventory[1] != null) {
if (inventory[0].getItem() instanceof ItemBlock && inventory[1].getItem() instanceof ItemBlock) {
if (inventory[0].getItem() == inventory[1].getItem()) {
equal = true;
} else {
equal = false;
}
if (equal) {
if (inventory[0].stackSize < 0) {
inventory[0] = null;
}
if (inventory[1].stackSize < 0) {
inventory[1] = null;
}
if (inventory[1].stackSize < 0) {
inventory[1] = null;
}
if (inventory[2] == null) {
setInventorySlotContents(2, new ItemStack(inventory[1].getItem(), 1, inventory[1].getItemDamage()));
decrStackSize(0, 1);
} else {
if (inventory[0].stackSize != 0 && inventory[2].stackSize <= getInventoryStackLimit()) {
decrStackSize(0, 1);
inventory[2].stackSize++;
} else {
inventory[0] = null;
}
}
}
}
}
}
markDirty();
}
@Override
public void writeToNBT(NBTTagCompound nbt) {
super.writeToNBT(nbt);
NBTTagList tags = new NBTTagList();
for (int i = 0; i < inventory.length; i++) {
if (inventory[i] != null) {
NBTTagCompound data = new NBTTagCompound();
data.setByte("Slot", (byte) i);
inventory[i].writeToNBT(data);
tags.appendTag(data);
}
}
nbt.setTag("Items", tags);
if (this.hasCustomInventoryName()) {
nbt.setString("CustomName", this.name);
}
}
@Override
public int getSizeInventory() {
return inventory.length;
}
@Override
public ItemStack getStackInSlot(int slot) {
return inventory[slot];
}
@Override
public ItemStack getStackInSlotOnClosing(int slot) {
if (inventory[slot] != null) {
ItemStack is = inventory[slot];
inventory[slot] = null;
return is;
} else
return null;
}
@Override
public void setInventorySlotContents(int slot, ItemStack stack) {
inventory[slot] = stack;
if (stack != null && stack.stackSize > getInventoryStackLimit()) {
stack.stackSize = getInventoryStackLimit();
}
markDirty();
}
@Override
public String getInventoryName() {
return name;
}
@Override
public final boolean isUseableByPlayer(EntityPlayer player) {
return true;
}
@Override
public int getInventoryStackLimit() {
return 64;
}
@Override
public boolean hasCustomInventoryName() {
return false;
}
@Override
public int[] getAccessibleSlotsFromSide(int side) {
return new int[3];
}
@Override
public boolean isItemValidForSlot(int slot, ItemStack itemStack) {
return true;
}
@Override
public boolean canInsertItem(int slot, ItemStack itemStack, int side) {
return false;
}
@Override
public boolean canExtractItem(int slot, ItemStack itemStack, int side) {
return true;
}
@Override
public void openInventory() {
}
@Override
public void closeInventory() {
NBTTagList tags = new NBTTagList();
System.out.print(tags);
}
@SideOnly(Side.CLIENT)
public EntityItem getItemForRendering(int slot) {
if (ghostItem == null) {
ghostItem = new EntityItem(worldObj);
ghostItem.hoverStart = 0.0F;
}
if (inventory[slot] == null) {
return null;
} else {
ghostItem.setEntityItemStack(new ItemStack(inventory[slot].getItem(), 1, inventory[slot].getItemDamage()));
return ghostItem;
}
}
@Override
public Packet getDescriptionPacket() {
NBTTagCompound tag = new NBTTagCompound();
writeToNBT(tag);
return new S35PacketUpdateTileEntity(xCoord, yCoord, zCoord, 1, tag);
}
@Override
public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity packet) {
readFromNBT(packet.func_148857_g());
}
}
@@ -0,0 +1,221 @@
package com.cricketcraft.chisel.block.tileentity;
import java.util.Iterator;
import java.util.List;
import com.cricketcraft.chisel.block.BlockPresent;
import com.cricketcraft.chisel.inventory.ContainerPresent;
import com.cricketcraft.chisel.inventory.InventoryLargePresent;
import net.minecraft.block.Block;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.tileentity.TileEntityChest;
import net.minecraft.util.AxisAlignedBB;
public class TileEntityPresent extends TileEntityChest {
public TileEntityPresent() {
}
@Override
public boolean isUseableByPlayer(EntityPlayer player) {
return this.worldObj.getTileEntity(xCoord, yCoord, zCoord) != this ? false : player.getDistanceSq(xCoord + 0.5D, yCoord + 0.5D, zCoord + 0.5D) <= 64.0D;
}
public void checkIfAdjacentBlocksAreMe(TileEntityPresent tile, int meta) {
if (tile.isInvalid()) {
this.adjacentChestChecked = false;
} else if (this.adjacentChestChecked) {
switch (meta) {
case 0:
if (this.adjacentChestZPos != tile) {
this.adjacentChestChecked = false;
}
break;
case 1:
if (this.adjacentChestXNeg != tile) {
this.adjacentChestChecked = false;
}
break;
case 2:
if (this.adjacentChestZNeg != tile) {
this.adjacentChestChecked = false;
}
break;
case 3:
if (this.adjacentChestXPos != tile) {
this.adjacentChestChecked = false;
}
}
}
}
public void checkForAdjacentPresents() {
if (!this.adjacentChestChecked) {
TileEntityPresent zNeg = (TileEntityPresent) this.adjacentChestZNeg;
TileEntityPresent xPos = (TileEntityPresent) this.adjacentChestXPos;
TileEntityPresent xNeg = (TileEntityPresent) this.adjacentChestXNeg;
TileEntityPresent zPos = (TileEntityPresent) this.adjacentChestZPos;
this.adjacentChestChecked = true;
if (this.isBlockPresent(xCoord - 1, yCoord, zCoord)) {
xNeg = (TileEntityPresent) this.worldObj.getTileEntity(xCoord - 1, yCoord, zCoord);
}
if (this.isBlockPresent(xCoord + 1, yCoord, zCoord)) {
xPos = (TileEntityPresent) this.worldObj.getTileEntity(xCoord + 1, yCoord, zCoord);
}
if (this.isBlockPresent(xCoord, yCoord, zCoord - 1)) {
zNeg = (TileEntityPresent) this.worldObj.getTileEntity(xCoord, yCoord, zCoord - 1);
}
if (this.isBlockPresent(xCoord, yCoord, zCoord + 1)) {
zPos = (TileEntityPresent) this.worldObj.getTileEntity(xCoord, yCoord, zCoord + 1);
}
if (this.adjacentChestZNeg != null) {
zNeg.checkIfAdjacentBlocksAreMe(this, 0);
}
if (this.adjacentChestZPos != null) {
zPos.checkIfAdjacentBlocksAreMe(this, 2);
}
if (this.adjacentChestXPos != null) {
xPos.checkIfAdjacentBlocksAreMe(this, 1);
}
if (this.adjacentChestXNeg != null) {
xNeg.checkIfAdjacentBlocksAreMe(this, 3);
}
this.adjacentChestXNeg = xNeg;
this.adjacentChestXPos = xPos;
this.adjacentChestZPos = zPos;
this.adjacentChestZNeg = zNeg;
}
}
private boolean isBlockPresent(int x, int y, int z) {
if (this.worldObj == null) {
return false;
} else {
Block block = this.worldObj.getBlock(x, y, z);
return block instanceof BlockPresent;
}
}
@Override
public void updateEntity() {
super.updateEntity();
checkForAdjacentPresents();
float f;
if (!worldObj.isRemote && numPlayersUsing != 0 && (+xCoord + yCoord + zCoord) % 200 == 0) {
numPlayersUsing = 0;
f = 5.0F;
List<?> list = worldObj.getEntitiesWithinAABB(EntityPlayer.class, AxisAlignedBB.getBoundingBox(xCoord - f, yCoord - f, zCoord - f, (xCoord + 1) + f, (yCoord + 1) + f, (zCoord + 1) + f));
Iterator<?> iterator = list.iterator();
while (iterator.hasNext()) {
EntityPlayer player = (EntityPlayer) iterator.next();
if (player.openContainer instanceof ContainerPresent) {
IInventory inventory = ((ContainerPresent) player.openContainer).getLowerPresentInventory();
if (inventory == this || inventory instanceof InventoryLargePresent && ((InventoryLargePresent) inventory).isPartOfLargePresent(this)) {
++numPlayersUsing;
}
}
}
}
prevLidAngle = lidAngle;
f = 0.1F;
double d2;
if (numPlayersUsing > 0 && lidAngle == 0.0F && adjacentChestZNeg == null && adjacentChestXNeg == null) {
double d1 = xCoord + 0.5D;
d2 = xCoord + 0.5D;
if (adjacentChestZPos != null) {
d2 += 0.5D;
}
if (adjacentChestXPos != null) {
d1 += 0.5D;
}
worldObj.playSoundEffect(d1, yCoord + 0.5D, d2, "random.chestopen", 0.5F, worldObj.rand.nextFloat() * 0.1F + 0.9F);
}
if (numPlayersUsing == 0 && lidAngle > 0.0F || numPlayersUsing > 0 && lidAngle < 1.0F) {
float f1 = lidAngle;
if (numPlayersUsing > 0) {
lidAngle += f;
} else {
lidAngle -= f;
}
if (lidAngle > 1.0F) {
lidAngle = 1.0F;
}
float f2 = 0.5F;
if (lidAngle < f2 && f1 >= f2 && adjacentChestZNeg == null && adjacentChestXNeg == null) {
d2 = xCoord + 0.5D;
double d0 = zCoord + 0.5D;
if (adjacentChestZPos != null) {
d0 += 0.5D;
}
if (adjacentChestXPos != null) {
d2 += 0.5D;
}
worldObj.playSoundEffect(d2, yCoord + 0.5D, d0, "random.chestclosed", 0.5F, worldObj.rand.nextFloat() * 0.1F + 0.9F);
}
if (lidAngle < 0.0F) {
lidAngle = 0.0F;
}
}
}
@Override
public void openInventory() {
if (numPlayersUsing < 0) {
numPlayersUsing = 0;
}
++numPlayersUsing;
worldObj.addBlockEvent(xCoord, yCoord, zCoord, getBlockType(), 1, numPlayersUsing);
worldObj.notifyBlocksOfNeighborChange(xCoord, yCoord, zCoord, getBlockType());
worldObj.notifyBlocksOfNeighborChange(xCoord, yCoord - 1, zCoord, getBlockType());
}
@Override
public void closeInventory() {
if (getBlockType() instanceof BlockPresent) {
--numPlayersUsing;
worldObj.addBlockEvent(xCoord, yCoord, zCoord, getBlockType(), 1, numPlayersUsing);
worldObj.notifyBlocksOfNeighborChange(xCoord, yCoord, zCoord, getBlockType());
worldObj.notifyBlocksOfNeighborChange(xCoord, yCoord - 1, zCoord, getBlockType());
}
}
@Override
public void invalidate() {
super.invalidate();
updateContainingBlockInfo();
checkForAdjacentPresents();
}
}
@@ -0,0 +1,444 @@
package com.cricketcraft.chisel.carving;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import com.cricketcraft.chisel.Chisel;
import com.cricketcraft.chisel.Configurations;
import com.cricketcraft.chisel.block.BlockMarbleSlab;
import com.cricketcraft.chisel.carving.CarvableVariation.CarvableVariationCTM;
import com.cricketcraft.chisel.client.render.CTM;
import com.cricketcraft.chisel.client.render.TextureSubmap;
import com.cricketcraft.chisel.item.ItemCarvable;
import com.cricketcraft.chisel.utils.GeneralClient;
import net.minecraft.block.Block;
import net.minecraft.block.BlockPane;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.item.ItemStack;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import cpw.mods.fml.common.registry.GameRegistry;
public class CarvableHelper
{
public static final ArrayList<Block> chiselBlocks = new ArrayList<Block>();
public static final int NORMAL = 0;
public static final int TOPSIDE = 1;
public static final int TOPBOTSIDE = 2;
public static final int CTM3 = 3;
public static final int CTMV = 4;
public static final int CTMH = 5;
public static final int V9 = 6;
public static final int V4 = 7;
public static final int CTMX = 8;
public CarvableHelper()
{
}
public ArrayList<CarvableVariation> variations = new ArrayList<CarvableVariation>();
CarvableVariation[] map = new CarvableVariation[16];
public boolean forbidChiseling = false;
public String blockName;
public void addVariation(String description, int metadata, Block bb)
{
addVariation(description, metadata, null, bb, 0);
}
public void addVariation(String description, int metadata, Block bb, int blockMeta)
{
addVariation(description, metadata, null, bb, blockMeta);
}
public void addVariation(String description, int metadata, Block bb, int blockMeta, Material material)
{
addVariation(description, metadata, null, bb, blockMeta);
}
public void addVariation(String description, int metadata, String texture)
{
addVariation(description, metadata, texture, null, 0);
}
public void addVariation(String description, int metadata, String texture, Block block, int blockMeta)
{
if(variations.size() >= 16)
return;
if(blockName == null && block != null)
blockName = block.getLocalizedName();
else if(blockName == null && description != null)
blockName = description;
CarvableVariation variation = new CarvableVariation();
variation.description = description;
variation.metadata = metadata;
variation.blockName = blockName;
if(texture != null)
{
variation.texture = texture;
String path = "/assets/" + Chisel.MOD_ID + "/textures/blocks/" + variation.texture;
boolean any = Chisel.class.getResource(path + ".png") != null;
boolean ctm3 = Chisel.class.getResource(path + "-ctm1.png") != null && Chisel.class.getResource(path + "-ctm2.png") != null && Chisel.class.getResource(path + "-ctm3.png") != null;
boolean ctmv = Chisel.class.getResource(path + "-ctmv.png") != null;
boolean ctmh = Chisel.class.getResource(path + "-ctmh.png") != null;
boolean side = Chisel.class.getResource(path + "-side.png") != null;
boolean top = Chisel.class.getResource(path + "-top.png") != null;
boolean bot = Chisel.class.getResource(path + "-bottom.png") != null;
boolean v9 = Chisel.class.getResource(path + "-v9.png") != null;
boolean v4 = Chisel.class.getResource(path + "-v4.png") != null;
boolean ctmx = Chisel.class.getResource(path + "-ctm.png") != null;
if(ctm3)
{
variation.kind = 3;
} else if(ctmh && top)
{
variation.kind = 5;
} else if(ctmv && top)
{
variation.kind = CTMV;
} else if(bot && top && side)
{
variation.kind = 2;
} else if(top && side)
{
variation.kind = 1;
} else if(v9)
{
variation.kind = V9;
} else if(v4)
{
variation.kind = V4;
} else if(any && ctmx && !Configurations.disableCTM)
{
variation.kind = CTMX;
} else if(any)
{
variation.kind = 0;
} else
{
throw new RuntimeException("No valid textures found for chisel block variation '" + description + "' (" + variation.texture + ")");
}
} else
{
variation.block = block;
variation.kind = 2;
variation.blockMeta = blockMeta;
}
variations.add(variation);
map[metadata] = variation;
}
public CarvableVariation getVariation(int metadata)
{
if(metadata < 0 || metadata > 15)
metadata = 0;
CarvableVariation variation = map[metadata];
if(variation == null)
return null;
return variation;
}
public IIcon getIcon(int side, int metadata)
{
if(metadata < 0 || metadata > 15)
metadata = 0;
CarvableVariation variation = map[metadata];
if(variation == null)
return GeneralClient.getMissingIcon();
switch(variation.kind)
{
case 0:
return variation.icon;
case 1:
if(side == 0 || side == 1)
return variation.iconTop;
else
return variation.icon;
case 2:
if(side == 1)
return variation.iconTop;
else if(side == 0)
return variation.iconBot;
else
return variation.icon;
case 3:
return variation.ctm.seams[0].icons[0];
case 4:
if(side < 2)
return variation.iconTop;
else
return variation.seamsCtmVert.icons[0];
case 5:
if(side < 2)
return variation.iconTop;
else
return variation.seamsCtmVert.icons[0];
case V9:
return variation.variations9.icons[4];
case V4:
return variation.variations9.icons[0];
case CTMX:
return variation.icon;
}
return GeneralClient.getMissingIcon();
}
public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side)
{
int metadata = world.getBlockMetadata(x, y, z);
if(metadata < 0 || metadata > 15)
metadata = 0;
CarvableVariation variation = map[metadata];
if(variation == null)
return GeneralClient.getMissingIcon();
switch(variation.kind)
{
case 0:
case 1:
case 2:
return getIcon(side, metadata);
case 3:
int tex = CTM.getTexture(world, x, y, z, side);
int row = tex / 16;
int col = tex % 16;
return variation.ctm.seams[col / 4].icons[col % 4 + row * 4];
case 4:
{
if(side < 2)
return variation.iconTop;
Block block = world.getBlock(x, y, z);
boolean topConnected = block.equals(world.getBlock(x, y + 1, z)) && metadata == world.getBlockMetadata(x, y + 1, z);
boolean botConnected = block.equals(world.getBlock(x, y - 1, z)) && metadata == world.getBlockMetadata(x, y - 1, z);
if(topConnected && botConnected) return variation.seamsCtmVert.icons[2];
if(topConnected && !botConnected) return variation.seamsCtmVert.icons[3];
if(!topConnected && botConnected) return variation.seamsCtmVert.icons[1];
return variation.seamsCtmVert.icons[0];
}
case 5:
if(side < 2)
return variation.iconTop;
Block block = world.getBlock(x, y, z);
boolean p;
boolean n;
boolean reverse = side == 2 || side == 4;
if(side < 4)
{
p = isSame(world, x - 1, y, z, block, metadata);
n = isSame(world, x + 1, y, z, block, metadata);
} else
{
p = isSame(world, x, y, z + 1, block, metadata);
n = isSame(world, x, y, z - 1, block, metadata);
}
if(p && n) return variation.seamsCtmVert.icons[1];
else if(p) return variation.seamsCtmVert.icons[reverse ? 2 : 3];
else if(n) return variation.seamsCtmVert.icons[reverse ? 3 : 2];
return variation.seamsCtmVert.icons[0];
case V9:
case V4:
int index = x + y * 606731 + z * 571163 + side * 555491;
if(index < 0) index = -index;
return variation.variations9.icons[index % ((variation.kind == V9) ? 9 : 4)];
case CTMX:
return variation.icon;
}
return GeneralClient.getMissingIcon();
}
public void register(Block block, String name)
{
register(block, name, ItemCarvable.class);
}
public void registerBlock(Block block, String name)
{
registerBlock(block, name, ItemCarvable.class);
}
void registerBlock(Block block, String name, Class<? extends ItemCarvable> cl)
{
block.setBlockName(name);
GameRegistry.registerBlock(block, cl, name);
chiselBlocks.add(block);
}
public void register(Block block, String name, Class<? extends ItemCarvable> cl)
{
registerBlock(block, name, cl);
if(block instanceof BlockMarbleSlab)
{
BlockMarbleSlab slab = (BlockMarbleSlab) block;
}
for(CarvableVariation variation : variations)
{
registerVariation(name, variation, block, variation.metadata);
if(block instanceof BlockMarbleSlab && ((BlockMarbleSlab) block).isBottom)
{
BlockMarbleSlab slab = (BlockMarbleSlab) block;
slab.top.setHarvestLevel("chisel", 0, variation.metadata);
if(!forbidChiseling)
{
Carving.chisel.addVariation(name + ".top", slab.top, variation.metadata, 0);
Carving.chisel.setGroupClass(name + ".top", name);
}
}
}
}
public void registerVariation(String name, CarvableVariation variation, Block block, int blockMeta)
{
//TODO Multipart registry goes here
if(forbidChiseling)
return;
if(variation.block == null)
{
Carving.chisel.addVariation(name, block, blockMeta, variation.metadata);
block.setHarvestLevel("chisel", 0, blockMeta);
} else
{
Carving.chisel.addVariation(name, variation.block, variation.blockMeta, variation.metadata);
variation.block.setHarvestLevel("chisel", 0, variation.blockMeta);
}
}
public void registerBlockIcons(String modName, Block block, IIconRegister register)
{
for(CarvableVariation variation : variations)
{
if(variation.block != null)
{
variation.block.registerBlockIcons(register);
if(variation.block instanceof BlockPane)
{
variation.icon = variation.block.getBlockTextureFromSide(2);
variation.iconTop = ((BlockPane) variation.block).getBlockTextureFromSide(0);
variation.iconBot = ((BlockPane) variation.block).getBlockTextureFromSide(0);
} else
{
switch(variation.kind)
{
case 0:
variation.icon = variation.block.getIcon(2, variation.blockMeta);
break;
case 1:
variation.icon = variation.block.getIcon(2, variation.blockMeta);
variation.iconTop = variation.block.getIcon(0, variation.blockMeta);
break;
case 2:
variation.icon = variation.block.getIcon(2, variation.blockMeta);
variation.iconTop = variation.block.getIcon(1, variation.blockMeta);
variation.iconBot = variation.block.getIcon(0, variation.blockMeta);
break;
}
}
} else
{
switch(variation.kind)
{
case 0:
variation.icon = register.registerIcon(modName + ":" + variation.texture);
break;
case 1:
variation.icon = register.registerIcon(modName + ":" + variation.texture + "-side");
variation.iconTop = register.registerIcon(modName + ":" + variation.texture + "-top");
break;
case 2:
variation.icon = register.registerIcon(modName + ":" + variation.texture + "-side");
variation.iconTop = register.registerIcon(modName + ":" + variation.texture + "-top");
variation.iconBot = register.registerIcon(modName + ":" + variation.texture + "-bottom");
break;
case 3:
CarvableVariationCTM ctm = new CarvableVariationCTM();
ctm.seams[0] = new TextureSubmap(register.registerIcon(modName + ":" + variation.texture + "-ctm1"), 4, 4);
ctm.seams[1] = new TextureSubmap(register.registerIcon(modName + ":" + variation.texture + "-ctm2"), 4, 4);
ctm.seams[2] = new TextureSubmap(register.registerIcon(modName + ":" + variation.texture + "-ctm3"), 4, 4);
variation.ctm = ctm;
break;
case 4:
variation.seamsCtmVert = new TextureSubmap(register.registerIcon(modName + ":" + variation.texture + "-ctmv"), 2, 2);
variation.iconTop = register.registerIcon(modName + ":" + variation.texture + "-top");
break;
case 5:
variation.seamsCtmVert = new TextureSubmap(register.registerIcon(modName + ":" + variation.texture + "-ctmh"), 2, 2);
variation.iconTop = register.registerIcon(modName + ":" + variation.texture + "-top");
break;
case V9:
variation.variations9 = new TextureSubmap(register.registerIcon(modName + ":" + variation.texture + "-v9"), 3, 3);
break;
case V4:
variation.variations9 = new TextureSubmap(register.registerIcon(modName + ":" + variation.texture + "-v4"), 2, 2);
break;
case CTMX:
variation.icon = register.registerIcon(modName + ":" + variation.texture);
variation.submap = new TextureSubmap(register.registerIcon(modName + ":" + variation.texture + "-ctm"), 4, 4);
variation.submapSmall = new TextureSubmap(variation.icon, 2, 2);
break;
}
}
}
}
public void registerSubBlocks(Block block, CreativeTabs tabs, List<ItemStack> list)
{
for(CarvableVariation variation : variations)
{
list.add(new ItemStack(block, 1, variation.metadata));
}
}
private boolean isSame(IBlockAccess world, int x, int y, int z, Block block, int meta)
{
return world.getBlock(x, y, z).equals(block) && world.getBlockMetadata(x, y, z) == meta;
}
public void setChiselBlockName(String name)
{
blockName = name;
}
public static Set<Block> getChiselBlockSet()
{
HashSet<Block> tools = new HashSet<Block>();
tools.addAll(CarvableHelper.chiselBlocks);
return tools;
}
}
@@ -0,0 +1,35 @@
package com.cricketcraft.chisel.carving;
import com.cricketcraft.chisel.client.render.TextureSubmap;
import net.minecraft.block.Block;
import net.minecraft.util.IIcon;
public class CarvableVariation
{
public String blockName;
public String description;
public int metadata;
public int kind;
public Block block;
public int blockMeta;
public String texture;
public IIcon icon;
public IIcon iconTop;
public IIcon iconBot;
public CarvableVariationCTM ctm;
public TextureSubmap seamsCtmVert;
public TextureSubmap variations9;
public TextureSubmap submap;
public TextureSubmap submapSmall;
static class CarvableVariationCTM
{
TextureSubmap seams[] = new TextureSubmap[3];
}
}
@@ -0,0 +1,192 @@
package com.cricketcraft.chisel.carving;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import com.cricketcraft.chisel.Chisel;
import net.minecraft.block.Block;
import net.minecraft.init.Blocks;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraftforge.oredict.OreDictionary;
public class Carving
{
HashMap<String, CarvingGroup> carvingGroupsByName = new HashMap<String, CarvingGroup>();
HashMap<String, CarvingGroup> carvingGroupsByOre = new HashMap<String, CarvingGroup>();
HashMap<String, CarvingGroup> carvingGroupsByVariation = new HashMap<String, CarvingGroup>();
public static Carving chisel = new Carving();
public static Carving needle = new Carving();
String key(Item item, int metadata)
{
return Item.itemRegistry.getNameForObject(item) + "|" + metadata;
}
String key(Block block, int metadata)
{
return Block.blockRegistry.getNameForObject(block) + "|" + metadata;
}
public boolean isVariationOfSameClass(Block target, int metadata1, Block block2, int metadata2)
{
CarvingGroup group1 = carvingGroupsByVariation.get(key(target, metadata1));
if(group1 == null) return false;
CarvingGroup group2 = carvingGroupsByVariation.get(key(block2, metadata2));
if(group2 == null) return false;
return group1 == group2 || group1.className.equals(group2.className) && !group1.className.isEmpty();
}
public CarvingVariation[] getVariations(Block block, int metadata)
{
CarvingGroup group = getGroup(block, metadata);
if(group == null) return null;
CarvingVariation[] res = group.variations.toArray(new CarvingVariation[group.variations.size()]);
return res;
}
public String getOre(Block block, int metadata)
{
CarvingGroup group = getGroup(block, metadata);
if(group == null)
return null;
return group.oreName;
}
public ArrayList<ItemStack> getItems(ItemStack chiseledItem)
{
ArrayList<ItemStack> items = new ArrayList<ItemStack>();
int damage = chiseledItem.getItemDamage();
CarvingGroup group = getGroup(Block.getBlockFromItem(chiseledItem.getItem()), damage);
if(group == null)
return items;
HashMap<String, Integer> mapping = new HashMap<String, Integer>();
if(group.variations != null)
{
for(CarvingVariation v : group.variations)
{
String key = Block.getIdFromBlock(v.block) + "|" + v.damage;
if(mapping.containsKey(key)) continue;
mapping.put(key, 1);
items.add(new ItemStack(v.block, 1, v.damage));
}
}
ArrayList<ItemStack> ores;
if(group.oreName != null && ((ores = OreDictionary.getOres(group.oreName)) != null))
{
for(ItemStack stack : ores)
{
String key = Item.getIdFromItem(stack.getItem()) + "|" + stack.getItemDamage();
if(mapping.containsKey(key)) continue;
mapping.put(key, 2);
items.add(stack);
}
}
return items;
}
public CarvingGroup getGroup(Block block, int metadata)
{
if(block.equals(Blocks.stone))
block = Blocks.stonebrick;
// Check name first
CarvingGroup res;
int i = OreDictionary.getOreID(block.getUnlocalizedName());
if(i < 1)
return null;
//if((res = carvingGroupsByOre.get(OreDictionary.getOreIDs(new ItemStack(block, 1, metadata)))) != null)
// return res;
if((res = carvingGroupsByVariation.get(key(block, metadata))) != null)
return res;
return null;
}
CarvingGroup getGroup(String name)
{
CarvingGroup group = carvingGroupsByName.get(name);
if(group == null)
{
group = new CarvingGroup(name);
group.className = name;
carvingGroupsByName.put(name, group);
}
return group;
}
public CarvingVariation addVariation(String name, Block block, int metadata, int order)
{
CarvingGroup group = getGroup(name);
CarvingGroup blockGroup = carvingGroupsByVariation.get(key(block, metadata));
if(blockGroup != null || blockGroup == group)
return null;
CarvingVariation variation = new CarvingVariation(block, metadata, order);
group.variations.add(variation);
Collections.sort(group.variations);
carvingGroupsByVariation.put(key(block, metadata), group);
return variation;
}
public void registerOre(String name, String oreName)
{
CarvingGroup group = getGroup(name);
carvingGroupsByOre.put(oreName, group);
group.oreName = oreName;
}
public void setGroupClass(String name, String className)
{
CarvingGroup group = getGroup(name);
group.className = className;
}
public void setVariationSound(String name, String sound)
{
CarvingGroup group = getGroup(name);
group.sound = sound;
}
public String getVariationSound(Block block, int metadata)
{
return getVariationSound(Item.getItemFromBlock(block), metadata);
}
public String getVariationSound(Item item, int metadata)
{
CarvingGroup blockGroup = carvingGroupsByVariation.get(key(item, metadata));
if(blockGroup == null || blockGroup.sound == null)
return Chisel.MOD_ID+":chisel.fallback";
return blockGroup.sound;
}
}
@@ -0,0 +1,18 @@
package com.cricketcraft.chisel.carving;
import java.util.ArrayList;
public class CarvingGroup
{
public CarvingGroup(String n)
{
name = n;
}
String name;
String className;
String sound;
String oreName;
ArrayList<CarvingVariation> variations = new ArrayList<CarvingVariation>();
}
@@ -0,0 +1,25 @@
package com.cricketcraft.chisel.carving;
import net.minecraft.block.Block;
public class CarvingVariation implements Comparable
{
public CarvingVariation(Block block, int metadata, int ord)
{
this.order = ord;
this.block = block;
this.meta = metadata;
this.damage = metadata;
}
@Override
public int compareTo(Object a)
{
return order - ((CarvingVariation) a).order;
}
public int order;
public Block block;
public int meta;
public int damage;
}
@@ -0,0 +1,247 @@
package com.cricketcraft.chisel.client;
import net.minecraft.block.Block;
import net.minecraft.client.Minecraft;
import net.minecraft.client.entity.EntityPlayerSP;
import net.minecraft.client.particle.EffectRenderer;
import net.minecraft.client.particle.EntityDiggingFX;
import net.minecraft.client.particle.EntityLavaFX;
import net.minecraft.entity.Entity;
import net.minecraft.world.World;
import java.util.Random;
import com.cricketcraft.chisel.Configurations;
import com.cricketcraft.chisel.block.BlockGrimstone;
import com.cricketcraft.chisel.block.BlockHolystone;
import com.cricketcraft.chisel.block.BlockLavastone;
import com.cricketcraft.chisel.block.BlockSnakestoneObsidian;
import com.cricketcraft.chisel.entity.fx.EntityBallOMossFX;
import com.cricketcraft.chisel.entity.fx.EntityGrimstoneFX;
import com.cricketcraft.chisel.entity.fx.EntityHolystoneFX;
import com.cricketcraft.chisel.entity.fx.EntitySnakestoneObsidianFX;
import com.cricketcraft.chisel.utils.GeneralClient;
public class GeneralChiselClient {
public static Random rand = new Random();
public static int tick = 0;
public static void spawnLavastoneFX(World world, BlockLavastone block, int x, int y, int z) {
if (Configurations.particlesTickrate != 0 && tick++ % Configurations.particlesTickrate != 0) return;
float f = 0.15F;
double x1 = x + rand.nextDouble() * (block.getBlockBoundsMaxX() - block.getBlockBoundsMinX() - f * 2.0F) + f + block.getBlockBoundsMinX();
double y1 = y + rand.nextDouble() * (block.getBlockBoundsMaxY() - block.getBlockBoundsMinY() - f * 2.0F) + f + block.getBlockBoundsMinY();
double z1 = z + rand.nextDouble() * (block.getBlockBoundsMaxZ() - block.getBlockBoundsMinZ() - f * 2.0F) + f + block.getBlockBoundsMinZ();
switch (rand.nextInt(6)) {
case 0:
y1 = y + block.getBlockBoundsMinY() - f;
y--;
break;
case 1:
y1 = y + block.getBlockBoundsMaxY() + f;
y++;
break;
case 2:
z1 = z + block.getBlockBoundsMinZ() - f;
z--;
break;
case 3:
z1 = z + block.getBlockBoundsMaxZ() + f;
z++;
break;
case 4:
x1 = x + block.getBlockBoundsMinX() - f;
x--;
break;
case 5:
x1 = x + block.getBlockBoundsMaxX() + f;
x++;
break;
}
if (world.getBlock(x, y, z).isOpaqueCube()) return;
EntityLavaFX res = new EntityLavaFX(world, x1, y1, z1);
double multiplier = 0.45;
res.motionX = -multiplier * (x1 - x - 0.5);
res.motionY = multiplier * (y1 - y - 0.5);
res.motionZ = -multiplier * (z1 - z - 0.5);
Minecraft.getMinecraft().effectRenderer.addEffect(res);
}
public static void spawnHolystoneFX(World world, BlockHolystone block, int x, int y, int z) {
if (Configurations.particlesTickrate != 0 && tick++ % Configurations.particlesTickrate != 0) return;
float f = 0.15F;
double x1 = x + rand.nextDouble() * (block.getBlockBoundsMaxX() - block.getBlockBoundsMinX() - f * 2.0F) + f + block.getBlockBoundsMinX();
double y1 = y + rand.nextDouble() * (block.getBlockBoundsMaxY() - block.getBlockBoundsMinY() - f * 2.0F) + f + block.getBlockBoundsMinY();
double z1 = z + rand.nextDouble() * (block.getBlockBoundsMaxZ() - block.getBlockBoundsMinZ() - f * 2.0F) + f + block.getBlockBoundsMinZ();
switch (rand.nextInt(6)) {
case 0:
y1 = y + block.getBlockBoundsMinY() - f;
y--;
break;
case 1:
y1 = y + block.getBlockBoundsMaxY() + f;
y++;
break;
case 2:
z1 = z + block.getBlockBoundsMinZ() - f;
z--;
break;
case 3:
z1 = z + block.getBlockBoundsMaxZ() + f;
z++;
break;
case 4:
x1 = x + block.getBlockBoundsMinX() - f;
x--;
break;
case 5:
x1 = x + block.getBlockBoundsMaxX() + f;
x++;
break;
}
if (world.getBlock(x, y, z).isOpaqueCube()) return;
EntityHolystoneFX res = new EntityHolystoneFX(world, block, x1, y1, z1);
Minecraft.getMinecraft().effectRenderer.addEffect(res);
}
public static void spawnGrimstoneFX(World world, BlockGrimstone block, int x, int y, int z) {
if (Configurations.particlesTickrate != 0 && tick++ % Configurations.particlesTickrate != 0) return;
float f = 0.15F;
double x1 = x + rand.nextDouble() * (block.getBlockBoundsMaxX() - block.getBlockBoundsMinX() - f * 2.0F) + f + block.getBlockBoundsMinX();
double y1 = y + rand.nextDouble() * (block.getBlockBoundsMaxY() - block.getBlockBoundsMinY() - f * 2.0F) + f + block.getBlockBoundsMinY();
double z1 = z + rand.nextDouble() * (block.getBlockBoundsMaxZ() - block.getBlockBoundsMinZ() - f * 2.0F) + f + block.getBlockBoundsMinZ();
switch (rand.nextInt(6)) {
case 0:
y1 = y + block.getBlockBoundsMinY() - f;
y--;
break;
case 1:
y1 = y + block.getBlockBoundsMaxY() + f;
y++;
break;
case 2:
z1 = z + block.getBlockBoundsMinZ() - f;
z--;
break;
case 3:
z1 = z + block.getBlockBoundsMaxZ() + f;
z++;
break;
case 4:
x1 = x + block.getBlockBoundsMinX() - f;
x--;
break;
case 5:
x1 = x + block.getBlockBoundsMaxX() + f;
x++;
break;
}
if (world.getBlock(x, y, z).isOpaqueCube()) return;
EntityGrimstoneFX res = new EntityGrimstoneFX(world, block, x1, y1, z1);
Minecraft.getMinecraft().effectRenderer.addEffect(res);
}
public static void spawnSnakestoneObsidianFX(World world, BlockSnakestoneObsidian block, int x, int y, int z) {
if (Configurations.particlesTickrate == 0 || tick++ % Configurations.particlesTickrate == 0) {
EntitySnakestoneObsidianFX res = new EntitySnakestoneObsidianFX(world, block, x, y, z);
Minecraft.getMinecraft().effectRenderer.addEffect(res);
}
}
public static void spawnBallOMossFX(World world, double x, double y, double z) {
if (Configurations.particlesTickrate == 0 || tick++ % Configurations.particlesTickrate == 0) {
EntityBallOMossFX res = new EntityBallOMossFX(world, x, y, z);
Minecraft.getMinecraft().effectRenderer.addEffect(res);
}
}
public static EntityDiggingFX addBlockHitEffects(World world, int x, int y, int z, int side) {
Block block = world.getBlock(x, y, z);
if (block.isAir(world, x, y, z))
return null;
EffectRenderer renderer = Minecraft.getMinecraft().effectRenderer;
float f = 0.1F;
double d0 = x + rand.nextDouble() * (block.getBlockBoundsMaxX() - block.getBlockBoundsMinX() - f * 2.0F) + f + block.getBlockBoundsMinX();
double d1 = y + rand.nextDouble() * (block.getBlockBoundsMaxY() - block.getBlockBoundsMinY() - f * 2.0F) + f + block.getBlockBoundsMinY();
double d2 = z + rand.nextDouble() * (block.getBlockBoundsMaxZ() - block.getBlockBoundsMinZ() - f * 2.0F) + f + block.getBlockBoundsMinZ();
switch (side) {
case 0:
d1 = y + block.getBlockBoundsMinY() - f;
break;
case 1:
d1 = y + block.getBlockBoundsMaxY() + f;
break;
case 2:
d2 = z + block.getBlockBoundsMinZ() - f;
break;
case 3:
d2 = z + block.getBlockBoundsMaxZ() + f;
break;
case 4:
d0 = x + block.getBlockBoundsMinX() - f;
break;
case 5:
d0 = x + block.getBlockBoundsMaxX() + f;
break;
}
EntityDiggingFX res = new EntityDiggingFX(world, d0, d1, d2, 0.0D, 0.0D, 0.0D, block, world.getBlockMetadata(x, y, z), side);
res.motionX = d0 - (x + 0.5);
res.motionY = d1 - (y + 0.5);
res.motionZ = d2 - (z + 0.5);
renderer.addEffect(res);
return res;
}
public static void spawnChiselEffect(int x, int y, int z, String sound) {
World world = Minecraft.getMinecraft().theWorld;
for (int side = 0; side < 6; side++) {
for (int j = 0; j < 16; j++) {
EntityDiggingFX fx = addBlockHitEffects(Minecraft.getMinecraft().theWorld, x, y, z, side);
if (fx == null) return;
fx.multipleParticleScaleBy(0.25f + 0.5f * rand.nextFloat());
fx.multiplyVelocity(0.3f * rand.nextFloat());
}
}
GeneralClient.playChiselSound(world, x, y, z, sound);
}
public static void speedupPlayer(World world, Entity entity, double concreteVelocity) {
double velocity = Math.sqrt(entity.motionX * entity.motionX + entity.motionZ * entity.motionZ);
if (!(entity instanceof EntityPlayerSP)) return;
if (velocity == 0) return;
if (velocity >= Configurations.concreteVelocity) return;
EntityPlayerSP player = (EntityPlayerSP) entity;
if (Math.abs(player.movementInput.moveForward) < 0.75f && Math.abs(player.movementInput.moveStrafe) < 0.75f)
return;
entity.motionX = Configurations.concreteVelocity * entity.motionX / velocity;
entity.motionZ = Configurations.concreteVelocity * entity.motionZ / velocity;
}
}
@@ -0,0 +1,28 @@
package com.cricketcraft.chisel.client.gui;
import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.util.ResourceLocation;
import org.lwjgl.opengl.GL11;
import com.cricketcraft.chisel.block.tileentity.TileEntityAutoChisel;
import com.cricketcraft.chisel.inventory.ContainerAutoChisel;
public class GuiAutoChisel extends GuiContainer {
private static final ResourceLocation gui = new ResourceLocation("chisel:textures/autochisel-gui.png");
public GuiAutoChisel(InventoryPlayer inventoryPlayer, TileEntityAutoChisel tileEntityAutoChisel){
super(new ContainerAutoChisel(inventoryPlayer, tileEntityAutoChisel));
}
@Override
protected void drawGuiContainerBackgroundLayer(float par1, int par2, int par3){
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
this.mc.renderEngine.bindTexture(gui);
int x = (width - xSize) / 2;
int y = (height - ySize) / 2;
this.drawTexturedModalRect(x ,y, 0, 0, xSize, ySize);
}
}
@@ -0,0 +1,67 @@
package com.cricketcraft.chisel.client.gui;
import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.client.resources.I18n;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.InventoryPlayer;
import org.lwjgl.opengl.GL11;
import com.cricketcraft.chisel.inventory.ContainerChisel;
import com.cricketcraft.chisel.inventory.InventoryChiselSelection;
import com.cricketcraft.chisel.utils.GeneralClient;
public class GuiChisel extends GuiContainer
{
public EntityPlayer player;
public ContainerChisel container;
public GuiChisel(InventoryPlayer iinventory, InventoryChiselSelection menu)
{
super(new ContainerChisel(iinventory, menu));
player = iinventory.player;
height = 177;
container = (ContainerChisel) inventorySlots;
}
@Override
public void onGuiClosed()
{
super.onGuiClosed();
inventorySlots.onContainerClosed(player);
}
boolean isExtended()
{
return container.inventory.activeVariations > 16;
}
@Override
protected void drawGuiContainerForegroundLayer(int j, int i)
{
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
String line = isExtended() ?
I18n.format(this.container.inventory.getInventoryName() + ".titleShort") :
I18n.format(this.container.inventory.getInventoryName() + ".title");
fontRendererObj.drawString(line, 88 - fontRendererObj.getStringWidth(line) / 2, 13, 0x404040);
}
@Override
protected void drawGuiContainerBackgroundLayer(float f, int mx, int my)
{
drawDefaultBackground();
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
int i = width - xSize >> 1;
int j = height - ySize >> 1;
String texture = isExtended() ?
"chisel:textures/chisel-gui-24.png" :
"chisel:textures/chisel-gui.png";
GeneralClient.bind(texture);
drawTexturedModalRect(i, j, 0, 0, xSize, ySize);
}
}
@@ -0,0 +1,18 @@
package com.cricketcraft.chisel.client.gui;
import com.cricketcraft.chisel.Chisel;
import com.cricketcraft.chisel.Configurations;
import net.minecraft.client.gui.GuiScreen;
import net.minecraftforge.common.config.ConfigElement;
import net.minecraftforge.common.config.Configuration;
import cpw.mods.fml.client.config.GuiConfig;
public class GuiChiselConfig extends GuiConfig
{
public GuiChiselConfig(GuiScreen parent)
{
super(parent, new ConfigElement(Configurations.config.getCategory(Configuration.CATEGORY_GENERAL)).getChildElements(), Chisel.MOD_ID, false, false, GuiConfig.getAbridgedConfigPath(Configurations.config.toString()));
}
}
@@ -0,0 +1,71 @@
package com.cricketcraft.chisel.client.gui;
import net.minecraft.client.gui.GuiTextField;
public class GuiEdit extends GuiElement
{
GuiTextField field;
String tempString = "";
public GuiEdit(int x, int y, int w, int h)
{
super(x, y, w, h);
}
@Override
public void onAdded()
{
field = new GuiTextField(gui.fontRendererObj(), x, y, w, h);
setText(tempString);
}
public String getText()
{
if(field == null)
{
return tempString;
} else
{
return field.getText();
}
}
public void setText(String text)
{
if(field == null)
{
tempString = text;
} else
{
field.setText(text);
}
}
@Override
public void render()
{
field.drawTextBox();
}
@Override
public void mouseDown(InputMouseEvent ev)
{
field.mouseClicked(ev.x, ev.y, ev.button);
if(isMouseOver(ev))
{
ev.handled = true;
}
}
@Override
public void keyPressed(InputKeyboardEvent ev)
{
field.textboxKeyTyped(ev.character, ev.key);
if(field.isFocused())
{
ev.handled = true;
}
}
}
@@ -0,0 +1,187 @@
package com.cricketcraft.chisel.client.gui;
import java.util.ArrayList;
import org.lwjgl.opengl.GL11;
public class GuiElement
{
public int x;
public int y;
public int w;
public int h;
public GuiScreenPlus gui;
public GuiElement parent, addedParent;
private ArrayList<GuiElement> children = null;
public GuiElement(int x, int y, int w, int h)
{
this.x = x;
this.y = y;
this.w = w;
this.h = h;
}
public GuiElement addChild(GuiElement e)
{
if(children == null)
{
children = new ArrayList<GuiElement>();
}
if(e.parent != null)
{
e.parent.removeChild(e);
}
children.add(e);
e.x += x;
e.y += y;
e.parent = this;
e.gui = gui;
return e;
}
public GuiElement removeChild(GuiElement e)
{
if(children == null)
{
return e;
}
children.remove(e);
e.x -= x;
e.y -= y;
e.parent = null;
e.gui = null;
return e;
}
public void onAdded()
{
if(children == null)
{
return;
}
for(GuiElement e : children)
{
if(e.parent != e.addedParent)
{
e.onAdded();
}
e.addedParent = e.parent;
}
}
boolean isMouseOver(InputMouseEvent ev)
{
return ev.x >= x && ev.x < x + w && ev.y >= y && ev.y < y + h;
}
public void mouseDown(InputMouseEvent ev)
{
if(children == null)
{
return;
}
for(GuiElement e : children)
{
e.mouseDown(ev);
if(ev.handled)
{
return;
}
}
}
public void mouseUp(InputMouseEvent ev)
{
if(children == null)
{
return;
}
for(GuiElement e : children)
{
e.mouseUp(ev);
if(ev.handled)
{
return;
}
}
}
public void mouseMove(InputMouseEvent ev)
{
if(children == null)
{
return;
}
for(GuiElement e : children)
{
e.mouseMove(ev);
if(ev.handled)
{
return;
}
}
}
public void mouseWheel(InputMouseEvent ev)
{
if(children == null)
{
return;
}
for(GuiElement e : children)
{
e.mouseWheel(ev);
if(ev.handled)
{
return;
}
}
}
public void render()
{
if(children == null)
{
return;
}
for(GuiElement e : children)
{
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
e.render();
}
}
public void keyPressed(InputKeyboardEvent ev)
{
if(children == null)
{
return;
}
for(GuiElement e : children)
{
e.keyPressed(ev);
if(ev.handled)
{
return;
}
}
}
}
@@ -0,0 +1,83 @@
package com.cricketcraft.chisel.client.gui;
public class GuiExButton extends GuiElement
{
protected String caption;
int u, v, texw, texh;
int borderTop, borderRight, borderBottom, borderLeft;
boolean over;
public boolean disabled;
public TexturedBox boxDisabled;
public TexturedBox boxNormal;
public TexturedBox boxOver;
public GuiExButton(int x, int y, int w, int h, String caption)
{
this(x, y, w, h, caption, "textures/gui/widgets.png");
}
public GuiExButton(int x, int y, int w, int h, String caption, String texture)
{
super(x, y, w, h);
this.caption = caption;
disabled = false;
u = 0;
v = 46;
texw = 200;
texh = 20;
borderTop = 2;
borderRight = 2;
borderBottom = 3;
borderLeft = 2;
boxDisabled = new TexturedBox(texture, 0, 46, 200, 20, 2, 2, 3, 2);
boxNormal = new TexturedBox(texture, 0, 66, 200, 20, 2, 2, 3, 2);
boxOver = new TexturedBox(texture, 0, 86, 200, 20, 2, 2, 3, 2);
}
public void onClick()
{
}
@Override
public void render()
{
int color = 0xffe0e0e0;
TexturedBox box = boxDisabled;
if(!disabled && !over)
{
box = boxNormal;
color = 0xffffffff;
} else if(!disabled && over)
{
box = boxOver;
color = 0xffffff70;
}
box.render(gui, x, y, w, h);
gui.drawCenteredStringWithShadow(caption, x + w / 2, y + h / 2, color);
}
@Override
public void mouseMove(InputMouseEvent ev)
{
over = isMouseOver(ev);
}
@Override
public void mouseDown(InputMouseEvent ev)
{
if(!isMouseOver(ev))
{
return;
}
gui.playSound("random.click", 1.0f, 1.0f);
onClick();
}
}
@@ -0,0 +1,34 @@
package com.cricketcraft.chisel.client.gui;
import java.util.Set;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.GuiScreen;
import cpw.mods.fml.client.IModGuiFactory;
public class GuiFactory implements IModGuiFactory
{
@Override
public void initialize(Minecraft minecraftInstance)
{
}
@Override
public Class<? extends GuiScreen> mainConfigGuiClass()
{
return GuiChiselConfig.class;
}
@Override
public Set<RuntimeOptionCategoryElement> runtimeGuiCategories()
{
return null;
}
@Override
public RuntimeOptionGuiHandler getHandlerFor(RuntimeOptionCategoryElement element)
{
return null;
}
}
@@ -0,0 +1,23 @@
package com.cricketcraft.chisel.client.gui;
public class GuiLabel extends GuiElement
{
String caption;
public GuiLabel(int x, int y, int w, int h, String caption)
{
super(x, y, w, h);
this.caption = caption;
}
public GuiLabel(int x, int y, String string)
{
this(x, y, 0, 0, string);
}
@Override
public void render()
{
gui.drawString(caption, x, y, 0x404040);
}
}
@@ -0,0 +1,33 @@
package com.cricketcraft.chisel.client.gui;
import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.util.ResourceLocation;
import org.lwjgl.opengl.GL11;
import com.cricketcraft.chisel.block.tileentity.TileEntityPresent;
import com.cricketcraft.chisel.inventory.ContainerPresent;
public class GuiPresent extends GuiContainer {
private static final ResourceLocation gui = new ResourceLocation("chisel:textures/present-gui.png");
private IInventory upper, lower;
private int rows;
public GuiPresent(InventoryPlayer inventoryPlayer, TileEntityPresent tileEntityPresent) {
super(new ContainerPresent(inventoryPlayer, tileEntityPresent));
rows = tileEntityPresent.getSizeInventory() / 9;
this.ySize = 114 + rows * 18;
}
@Override
protected void drawGuiContainerBackgroundLayer(float p_146976_1_, int p_146976_2_, int p_146976_3_) {
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
this.mc.getTextureManager().bindTexture(gui);
int x = (this.width - this.xSize) / 2;
int y = (this.height - this.ySize) / 2;
this.drawTexturedModalRect(x, y, 0, 0, this.xSize, this.rows * 18 + 17);
this.drawTexturedModalRect(x, y + this.rows * 18 + 17, 0, 126, this.xSize, 96);
}
}
@@ -0,0 +1,274 @@
package com.cricketcraft.chisel.client.gui;
import net.minecraft.client.gui.FontRenderer;
import net.minecraft.client.gui.GuiScreen;
import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.inventory.Container;
import org.lwjgl.input.Keyboard;
import org.lwjgl.input.Mouse;
import org.lwjgl.opengl.GL11;
import com.cricketcraft.chisel.utils.DummyContainer;
import com.cricketcraft.chisel.utils.GeneralClient;
public class GuiScreenPlus extends GuiContainer
{
public int screenW;
public int screenH;
public int screenX;
public int screenY;
public GuiElement root;
String backgroundTexture;
public GuiScreenPlus(Container container, int w, int h, String backgroundTexture)
{
super(container);
root = new GuiElement(0, 0, w, h);
root.gui = this;
this.screenW = w;
this.screenH = h;
this.backgroundTexture = backgroundTexture;
}
public GuiScreenPlus(int w, int h, String backgroundTexture)
{
this(new DummyContainer(), w, h, backgroundTexture);
}
@Override
public void initGui()
{
xSize = screenW;
ySize = screenH;
super.initGui();
screenX = guiLeft;
screenY = guiTop;
root.onAdded();
Keyboard.enableRepeatEvents(true);
}
@Override
public void handleInput()
{
while(Mouse.next())
{
this.handleMouseInput();
}
while(Keyboard.next())
{
this.handleKeyboardInput();
}
}
InputMouseEvent mouseEvent = new InputMouseEvent();
int oldX = -1;
int oldY = -1;
boolean[] downButtons = new boolean[12];
@Override
public void handleMouseInput()
{
mouseEvent.handled = false;
mouseEvent.x = Mouse.getEventX() * width / mc.displayWidth - this.screenX;
mouseEvent.y = height - Mouse.getEventY() * height / mc.displayHeight - 1 - this.screenY;
if(oldX == -1)
{
oldX = mouseEvent.x;
oldY = mouseEvent.y;
}
mouseEvent.dx = mouseEvent.x - oldX;
mouseEvent.dy = mouseEvent.y - oldY;
oldX = mouseEvent.x;
oldY = mouseEvent.y;
mouseEvent.down = Mouse.getEventButtonState();
mouseEvent.button = Mouse.getEventButton();
mouseEvent.wheel = Mouse.getEventDWheel();
if(mouseEvent.wheel != 0)
{
if(mouseEvent.wheel < 0)
{
mouseEvent.wheel = -1;
} else
{
mouseEvent.wheel = 1;
}
root.mouseWheel(mouseEvent);
} else if(mouseEvent.button >= 0 && mouseEvent.button < downButtons.length)
{
if(downButtons[mouseEvent.button] != mouseEvent.down)
{
downButtons[mouseEvent.button] = mouseEvent.down;
if(mouseEvent.down)
{
root.mouseDown(mouseEvent);
} else
{
root.mouseUp(mouseEvent);
}
} else if(mouseEvent.dx != 0 || mouseEvent.dy != 0)
{
root.mouseMove(mouseEvent);
}
} else if(mouseEvent.dx != 0 || mouseEvent.dy != 0)
{
root.mouseMove(mouseEvent);
}
if(!mouseEvent.handled)
{
super.handleMouseInput();
}
}
InputKeyboardEvent keyboardEvent = new InputKeyboardEvent();
@Override
public void handleKeyboardInput()
{
keyboardEvent.handled = false;
if(Keyboard.getEventKeyState())
{
keyboardEvent.key = Keyboard.getEventKey();
keyboardEvent.character = Keyboard.getEventCharacter();
switch(keyboardEvent.key)
{
case 1:
break;
default:
root.keyPressed(keyboardEvent);
}
}
if(!keyboardEvent.handled)
{
super.handleKeyboardInput();
}
}
public void close()
{
mc.displayGuiScreen((GuiScreen) null);
mc.setIngameFocus();
}
protected void addChild(GuiElement e)
{
root.addChild(e);
}
@Override
protected void drawGuiContainerBackgroundLayer(float f, int bx, int by)
{
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
GeneralClient.bind(backgroundTexture);
drawTexturedModalRect(screenX, screenY, 0, 0, screenW, screenH);
}
@Override
protected void drawGuiContainerForegroundLayer(int fx, int fy)
{
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
root.render();
}
public void drawString(String text, int sx, int sy, int color)
{
fontRendererObj.drawString(text, sx, sy, color);
}
public void drawCenteredString(String text, int sx, int sy, int color)
{
fontRendererObj.drawString(text, sx - fontRendererObj.getStringWidth(text) / 2, sy - fontRendererObj.FONT_HEIGHT / 2, color);
}
public void drawStringWithShadow(String text, int sx, int sy, int color)
{
fontRendererObj.drawStringWithShadow(text, sx, sy, color);
}
public void drawCenteredStringWithShadow(String text, int sx, int sy, int color)
{
fontRendererObj.drawStringWithShadow(text, sx - fontRendererObj.getStringWidth(text) / 2, sy - fontRendererObj.FONT_HEIGHT / 2, color);
}
public FontRenderer fontRendererObj()
{
return this.fontRendererObj;
}
protected void drawRect(int gx, int gy, int gw, int gh, int c1, int c2)
{
drawGradientRect(gx, gy, gx + gw, gy + gh, c1, c2);
}
public void drawTiledRect(int rx, int ry, int rw, int rh, int u, int v, int tw, int th)
{
if(rw == 0 || rh == 0 || tw == 0 || th == 0) return;
float pixel = 0.00390625f;
Tessellator tessellator = Tessellator.instance;
tessellator.startDrawingQuads();
for(int y = 0; y < rh; y += th)
{
for(int x = 0; x < rw; x += tw)
{
int qw = tw;
if(x + qw > rw)
{
qw = rw - x;
}
int qh = th;
if(y + qh > rh)
{
qh = rh - y;
}
double x1 = rx + x;
double x2 = rx + x + qw;
double y1 = ry + y;
double y2 = ry + y + qh;
double u1 = pixel * (u);
double u2 = pixel * (u + tw);
double v1 = pixel * (v);
double v2 = pixel * (v + th);
tessellator.addVertexWithUV(x1, y2, this.zLevel, u1, v2);
tessellator.addVertexWithUV(x2, y2, this.zLevel, u2, v2);
tessellator.addVertexWithUV(x2, y1, this.zLevel, u2, v1);
tessellator.addVertexWithUV(x1, y1, this.zLevel, u1, v1);
}
}
tessellator.draw();
}
public void bindTexture(String tex)
{
GeneralClient.bind(tex);
}
public void playSound(String sound, float volume, float pitch)
{
// TODO
//mc.getSoundHandler().playSoundFX(null, 1.0F, 1.0F);
}
}
@@ -0,0 +1,124 @@
package com.cricketcraft.chisel.client.gui;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.Gui;
import net.minecraft.client.renderer.Tessellator;
import org.lwjgl.opengl.GL11;
public class GuilScrolledBox extends GuiElement
{
public int offset = 0;
int contentHeight = 0;
int scrollingStart = -1;
public GuilScrolledBox(int x, int y, int w, int h)
{
super(x, y, w, h);
}
int x0, x1;
protected void overlayBackground(int start, int end, int color, int a1, int a2)
{
Tessellator tessellator = Tessellator.instance;
float f = 32.0F;
tessellator.startDrawingQuads();
tessellator.setColorRGBA_I(color, a2);
tessellator.addVertexWithUV(x0, end, 0.0D, 0.0D, end / f);
tessellator.addVertexWithUV(x1, end, 0.0D, gui.width / f, end / f);
tessellator.setColorRGBA_I(color, a1);
tessellator.addVertexWithUV(x1, start, 0.0D, gui.width / f, start / f);
tessellator.addVertexWithUV(x0, start, 0.0D, 0.0D, start / f);
tessellator.draw();
}
@Override
public GuiElement addChild(GuiElement e)
{
int childBottom = e.y + e.h - 18;
if(childBottom > contentHeight)
contentHeight = childBottom;
return super.addChild(e);
}
@Override
public void render()
{
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
Minecraft.getMinecraft().getTextureManager().bindTexture(Gui.optionsBackground);
x0 = -gui.screenX;
x1 = -gui.screenX + gui.width;
overlayBackground(y, h, 0x202020, 0xff, 0xff);
GL11.glPushMatrix();
GL11.glTranslatef(0.0f, offset, 0.0f);
super.render();
GL11.glPopMatrix();
GL11.glEnable(GL11.GL_BLEND);
GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
GL11.glDisable(GL11.GL_ALPHA_TEST);
GL11.glShadeModel(GL11.GL_SMOOTH);
GL11.glDisable(GL11.GL_TEXTURE_2D);
overlayBackground(y, y + 8, 0x000000, 0xff, 0x00);
overlayBackground(h - 8, h, 0x000000, 0x00, 0xff);
GL11.glEnable(GL11.GL_TEXTURE_2D);
GL11.glShadeModel(GL11.GL_FLAT);
GL11.glEnable(GL11.GL_ALPHA_TEST);
GL11.glDisable(GL11.GL_BLEND);
Minecraft.getMinecraft().getTextureManager().bindTexture(Gui.optionsBackground);
overlayBackground(-gui.screenY, y, 0x404040, 0xff, 0xff);
overlayBackground(h, -gui.screenY + gui.height, 0x404040, 0xff, 0xff);
}
@Override
public void mouseMove(InputMouseEvent ev)
{
if(scrollingStart != -1)
{
offset = ev.y - scrollingStart;
if(offset > contentHeight) offset = contentHeight;
if(offset < -contentHeight) offset = -contentHeight;
}
ev.y -= offset;
super.mouseMove(ev);
ev.y += offset;
}
@Override
public void mouseDown(InputMouseEvent ev)
{
scrollingStart = ev.y - offset;
if(ev.y >= y && ev.y < y + h)
{
ev.y -= offset;
super.mouseDown(ev);
ev.y += offset;
}
}
@Override
public void mouseUp(InputMouseEvent ev)
{
scrollingStart = -1;
if(ev.y >= y && ev.y < y + h)
{
ev.y -= offset;
super.mouseUp(ev);
ev.y += offset;
}
}
}
@@ -0,0 +1,6 @@
package com.cricketcraft.chisel.client.gui;
public class InputEvent
{
public boolean handled;
}
@@ -0,0 +1,7 @@
package com.cricketcraft.chisel.client.gui;
public class InputKeyboardEvent extends InputEvent
{
public int key;
public char character;
}
@@ -0,0 +1,12 @@
package com.cricketcraft.chisel.client.gui;
public class InputMouseEvent extends InputEvent
{
public int x;
public int y;
public int dx;
public int dy;
public int wheel;
public int button;
public boolean down;
}
@@ -0,0 +1,126 @@
package com.cricketcraft.chisel.client.gui;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.GuiButton;
import org.lwjgl.input.Mouse;
import com.cricketcraft.chisel.utils.GeneralClient;
public abstract class Scrollbar extends GuiButton
{
public boolean active;
public float offset;
public float step;
boolean dragged;
int elementHeight = 15;
public Scrollbar(int id, int x, int y, int w, int h, String string)
{
super(id, x, y, w, h, string);
offset = 0;
step = 0.025f;
height = h;
active = true;
dragged = false;
}
/**
* Returns true if the mouse has been pressed on this control. Equivalent of
* MouseListener.mousePressed(MouseEvent e).
*/
@Override
public boolean mousePressed(Minecraft mc, int x, int y)
{
if(x < xPosition || x >= xPosition + width)
{
return false;
}
if(y < yPosition || y >= yPosition + height)
{
return false;
}
if(active)
{
dragged = true;
}
return true;
}
/**
* Draws this button to the screen.
*/
@Override
public void drawButton(Minecraft mc, int x, int y)
{
if(dragged)
{
float initialOffset = offset;
int off = y - yPosition - elementHeight / 2;
offset = 1.0f * off / (height - elementHeight);
if(offset < 0)
{
offset = 0;
}
if(offset > 1)
{
offset = 1;
}
if(initialOffset != offset)
{
onScrolled(offset);
}
}
int bottom = yPosition + height;
GeneralClient.bind("/gui/allitems.png");
drawTexturedModalRect(xPosition, yPosition + (int) ((height - elementHeight) * offset), active ? 232 : 244, 0, 12, elementHeight);
}
public void handleMouseInput()
{
if(Mouse.getEventButton() == 0 && !Mouse.getEventButtonState())
{
dragged = false;
}
if(!active)
{
return;
}
float initialOffset = offset;
int direction = Mouse.getEventDWheel();
if(direction != 0)
{
offset += direction > 0 ? -step : step;
}
if(offset < 0)
{
offset = 0;
}
if(offset > 1)
{
offset = 1;
}
if(initialOffset != offset)
{
onScrolled(offset);
}
}
public abstract void onScrolled(float off);
}
@@ -0,0 +1,73 @@
package com.cricketcraft.chisel.client.gui;
public class TexturedBox
{
String texture;
int u, v, texw, texh;
int borderTop, borderRight, borderBottom, borderLeft;
public TexturedBox(String texture, int u, int v, int texw, int texh, int borderTop, int borderRight, int borderBottom, int borderLeft)
{
this.texture = texture;
this.u = u;
this.v = v;
this.texw = texw;
this.texh = texh;
this.borderTop = borderTop;
this.borderRight = borderRight;
this.borderBottom = borderBottom;
this.borderLeft = borderLeft;
}
public void render(GuiScreenPlus gui, int x, int y, int w, int h)
{
int x1 = x;
int x2 = x + borderLeft;
int x3 = x + w - borderRight;
int y1 = y;
int y2 = y + borderTop;
int y3 = y + h - borderBottom;
int w1 = borderLeft;
int w2 = w - borderLeft - borderRight;
int w3 = borderRight;
int h1 = borderTop;
int h2 = h - borderTop - borderBottom;
int h3 = borderBottom;
int u1 = u;
int v1 = v;
int tw = texw;
if(tw > w)
{
tw = w;
}
int th = texh;
if(th > h)
{
th = h;
}
int u2 = u1 + borderLeft;
int u3 = u1 + texw - borderRight;
int v2 = v1 + borderTop;
int v3 = v1 + texh - borderBottom;
int texw1 = borderLeft;
int texw2 = tw - borderLeft - borderRight;
int texw3 = borderRight;
int texh1 = borderTop;
int texh2 = th - borderTop - borderBottom;
int texh3 = borderBottom;
gui.bindTexture(texture);
gui.drawTexturedModalRect(x1, y1, u1, v1, w1, h1);
gui.drawTiledRect(x2, y1, w2, h1, u2, v1, texw2, texh1);
gui.drawTexturedModalRect(x3, y1, u3, v1, w3, h1);
gui.drawTiledRect(x1, y2, w1, h2, u1, v2, w1, texh2);
gui.drawTiledRect(x2, y2, w2, h2, u2, v2, texw2, texh2);
gui.drawTiledRect(x3, y2, w3, h2, u3, v2, w3, texh2);
gui.drawTexturedModalRect(x1, y3, u1, v3, w1, h3);
gui.drawTiledRect(x2, y3, w2, h3, u2, v3, texw2, texh3);
gui.drawTexturedModalRect(x3, y3, u3, v3, w3, h3);
}
}
@@ -0,0 +1,147 @@
package com.cricketcraft.chisel.client.model;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
import net.minecraft.entity.Entity;
public class ModelAutoChisel extends ModelBase
{
//fields
ModelRenderer Shape1;
ModelRenderer Shape2;
ModelRenderer Shape3;
ModelRenderer Shape4;
ModelRenderer Shape5;
ModelRenderer Shape6;
ModelRenderer Shape7;
ModelRenderer Shape8;
ModelRenderer Shape9;
ModelRenderer Shape10;
ModelRenderer Shape11;
ModelRenderer Shape12;
public ModelAutoChisel()
{
textureWidth = 64;
textureHeight = 32;
Shape1 = new ModelRenderer(this, 0, 0);
Shape1.addBox(0F, 0F, 0F, 16, 1, 1);
Shape1.setRotationPoint(-8F, 23F, -8F);
Shape1.setTextureSize(64, 32);
Shape1.mirror = true;
setRotation(Shape1, 0F, 0F, 0F);
Shape2 = new ModelRenderer(this, 0, 0);
Shape2.addBox(0F, 0F, 0F, 1, 1, 15);
Shape2.setRotationPoint(-8F, 23F, -7F);
Shape2.setTextureSize(64, 32);
Shape2.mirror = true;
setRotation(Shape2, 0F, 0F, 0F);
Shape3 = new ModelRenderer(this, 0, 0);
Shape3.addBox(0F, 0F, 0F, 1, 1, 15);
Shape3.setRotationPoint(7F, 23F, -7F);
Shape3.setTextureSize(64, 32);
Shape3.mirror = true;
setRotation(Shape3, 0F, 0F, 0F);
Shape4 = new ModelRenderer(this, 0, 0);
Shape4.addBox(0F, 0F, 0F, 14, 1, 1);
Shape4.setRotationPoint(-7F, 23F, 7F);
Shape4.setTextureSize(64, 32);
Shape4.mirror = true;
setRotation(Shape4, 0F, 0F, 0F);
Shape5 = new ModelRenderer(this, 0, 0);
Shape5.addBox(0F, 0F, 0F, 1, 15, 1);
Shape5.setRotationPoint(-8F, 8F, -8F);
Shape5.setTextureSize(64, 32);
Shape5.mirror = true;
setRotation(Shape5, 0F, 0F, 0F);
Shape6 = new ModelRenderer(this, 0, 0);
Shape6.addBox(0F, 0F, 0F, 1, 15, 1);
Shape6.setRotationPoint(-8F, 8F, 7F);
Shape6.setTextureSize(64, 32);
Shape6.mirror = true;
setRotation(Shape6, 0F, 0F, 0F);
Shape7 = new ModelRenderer(this, 0, 0);
Shape7.addBox(0F, 0F, 0F, 1, 15, 1);
Shape7.setRotationPoint(7F, 8F, -8F);
Shape7.setTextureSize(64, 32);
Shape7.mirror = true;
setRotation(Shape7, 0F, 0F, 0F);
Shape8 = new ModelRenderer(this, 0, 0);
Shape8.addBox(0F, 0F, 0F, 1, 15, 1);
Shape8.setRotationPoint(7F, 8F, 7F);
Shape8.setTextureSize(64, 32);
Shape8.mirror = true;
setRotation(Shape8, 0F, 0F, 0F);
Shape9 = new ModelRenderer(this, 0, 0);
Shape9.addBox(0F, 0F, 0F, 14, 1, 1);
Shape9.setRotationPoint(-7F, 8F, 7F);
Shape9.setTextureSize(64, 32);
Shape9.mirror = true;
setRotation(Shape9, 0F, 0F, 0F);
Shape10 = new ModelRenderer(this, 0, 0);
Shape10.addBox(0F, 0F, 0F, 14, 1, 1);
Shape10.setRotationPoint(-7F, 8F, -8F);
Shape10.setTextureSize(64, 32);
Shape10.mirror = true;
setRotation(Shape10, 0F, 0F, 0F);
Shape11 = new ModelRenderer(this, 0, 0);
Shape11.addBox(0F, 0F, 0F, 1, 1, 14);
Shape11.setRotationPoint(7F, 8F, -7F);
Shape11.setTextureSize(64, 32);
Shape11.mirror = true;
setRotation(Shape11, 0F, 0F, 0F);
Shape12 = new ModelRenderer(this, 0, 0);
Shape12.addBox(0F, 0F, 0F, 1, 1, 14);
Shape12.setRotationPoint(-8F, 8F, -7F);
Shape12.setTextureSize(64, 32);
Shape12.mirror = true;
setRotation(Shape12, 0F, 0F, 0F);
}
public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5)
{
super.render(entity, f, f1, f2, f3, f4, f5);
setRotationAngles(f, f1, f2, f3, f4, f5);
Shape1.render(f5);
Shape2.render(f5);
Shape3.render(f5);
Shape4.render(f5);
Shape5.render(f5);
Shape6.render(f5);
Shape7.render(f5);
Shape8.render(f5);
Shape9.render(f5);
Shape10.render(f5);
Shape11.render(f5);
Shape12.render(f5);
}
public void renderAll(){
Shape1.render(0.0625F);
Shape2.render(0.0625F);
Shape3.render(0.0625F);
Shape4.render(0.0625F);
Shape5.render(0.0625F);
Shape6.render(0.0625F);
Shape7.render(0.0625F);
Shape8.render(0.0625F);
Shape9.render(0.0625F);
Shape10.render(0.0625F);
Shape11.render(0.0625F);
Shape12.render(0.0625F);
}
private void setRotation(ModelRenderer model, float x, float y, float z)
{
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5)
{
super.setRotationAngles(f, f1, f2, f3, f4, f5, null);
}
}
@@ -0,0 +1,88 @@
package com.cricketcraft.chisel.client.render;
import net.minecraft.block.Block;
import net.minecraft.client.renderer.RenderBlocks;
import net.minecraft.world.IBlockAccess;
import org.lwjgl.opengl.GL11;
import com.cricketcraft.chisel.Chisel;
import com.cricketcraft.chisel.api.ICarvable;
import com.cricketcraft.chisel.carving.CarvableHelper;
import com.cricketcraft.chisel.carving.CarvableVariation;
import com.cricketcraft.chisel.utils.Drawing;
import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
import cpw.mods.fml.client.registry.RenderingRegistry;
public class BlockAdvancedMarbleRenderer implements ISimpleBlockRenderingHandler
{
public RenderBlocksCTM rendererCTM = new RenderBlocksCTM();
RenderBlocksColumn rendererColumn = new RenderBlocksColumn();
public BlockAdvancedMarbleRenderer()
{
if(Chisel.RenderCTMId == 0)
{
Chisel.RenderCTMId = RenderingRegistry.getNextAvailableRenderId();
}
}
@Override
public void renderInventoryBlock(Block block, int metadata, int modelID, RenderBlocks renderer)
{
GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
Drawing.drawBlock(block, metadata, renderer);
GL11.glTranslatef(0.5F, 0.5F, 0.5F);
}
@Override
public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks rendererOld)
{
int meta = world.getBlockMetadata(x, y, z);
CarvableVariation var = ((ICarvable) block).getVariation(meta);
switch(var == null ? 0 : var.kind)
{
case CarvableHelper.CTMX:
rendererCTM.blockAccess = world;
rendererCTM.renderMaxX = 1.0;
rendererCTM.renderMaxY = 1.0;
rendererCTM.renderMaxZ = 1.0;
rendererCTM.submap = var.submap;
rendererCTM.submapSmall = var.submapSmall;
rendererCTM.rendererOld = rendererOld;
return rendererCTM.renderStandardBlock(block, x, y, z);
case CarvableHelper.CTMV:
rendererColumn.blockAccess = world;
rendererColumn.renderMaxX = 1.0;
rendererColumn.renderMaxY = 1.0;
rendererColumn.renderMaxZ = 1.0;
rendererColumn.submap = var.seamsCtmVert;
rendererColumn.iconTop = var.iconTop;
return rendererColumn.renderStandardBlock(block, x, y, z);
default:
return rendererOld.renderStandardBlock(block, x, y, z);
}
}
@Override
public boolean shouldRender3DInInventory(int renderId)
{
return true;
}
@Override
public int getRenderId()
{
return Chisel.RenderCTMId;
}
}
@@ -0,0 +1,25 @@
package com.cricketcraft.chisel.client.render;
import com.cricketcraft.chisel.Chisel;
import cpw.mods.fml.client.registry.RenderingRegistry;
public class BlockCarpetRenderer extends BlockAdvancedMarbleRenderer
{
public BlockCarpetRenderer()
{
super();
Chisel.RenderCarpetId = RenderingRegistry.getNextAvailableRenderId();
rendererCTM = new RenderBlocksCTMCarpet();
}
@Override
public int getRenderId()
{
return Chisel.RenderCarpetId;
}
}
@@ -0,0 +1,116 @@
package com.cricketcraft.chisel.client.render;
import net.minecraft.block.Block;
import net.minecraft.client.renderer.RenderBlocks;
import net.minecraft.world.IBlockAccess;
import org.lwjgl.opengl.GL11;
import com.cricketcraft.chisel.Chisel;
import com.cricketcraft.chisel.utils.Drawing;
import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
import cpw.mods.fml.client.registry.RenderingRegistry;
public class BlockEldritchRenderer implements ISimpleBlockRenderingHandler
{
public BlockEldritchRenderer()
{
Chisel.RenderEldritchId = RenderingRegistry.getNextAvailableRenderId();
}
@Override
public void renderInventoryBlock(Block block, int metadata, int modelID, RenderBlocks renderer)
{
GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
Drawing.drawBlock(block, metadata, renderer);
GL11.glTranslatef(0.5F, 0.5F, 0.5F);
}
RenderBlocksEldritch renderer = new RenderBlocksEldritch();
@Override
public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks rendererOld)
{
int meta = world.getBlockMetadata(x, y, z);
// tessellator.setBrightness(block.getMixedBrightnessForBlock(world, x, y, z));
/*
double d0 = 0.4000000059604645D;
double d1 = 0.5D - d0;
double d2 = 0.20000000298023224D;
*/
// renderer.renderTorchAtAngle(Block.torchWood, x - d1, y + d2, z, -d0, 0.0D, 0);
/*
Icon icon = block.getIcon(2, meta);
double u0 = icon.getMinU();
double v0 = icon.getMaxV();
double u1 = icon.getMaxU();
double v1 = icon.getMinV();
double uu = icon.getInterpolatedU(8.0D);
double vv = icon.getInterpolatedV(8.0D);
int lyp=block.getMixedBrightnessForBlock(world, x, y+1, z);
int lym=block.getMixedBrightnessForBlock(world, x, y-1, z);
int lxp=block.getMixedBrightnessForBlock(world, x+1, y, z);
int lxm=block.getMixedBrightnessForBlock(world, x-1, y, z);
int lzp=block.getMixedBrightnessForBlock(world, x, y, z+1);
int lzm=block.getMixedBrightnessForBlock(world, x, y, z-1);
icon = block.getIcon(0, meta);
u0 = icon.getMinU();
v0 = icon.getMinV();
u1 = icon.getMaxU();
v1 = icon.getMaxV();
vertex(1,u0,v0); vertex(5,u1,v0); vertex(6,u1,v1); vertex(2,u0,v1);
icon = block.getIcon(1, meta);
u0 = icon.getMinU();
v0 = icon.getMinV();
u1 = icon.getMaxU();
v1 = icon.getMaxV();
vertex(0,u0,v0); vertex(3,u0,v1); vertex(7,u1,v1); vertex(4,u1,v0);
*/
renderer.blockAccess = world;
renderer.renderMaxX = 1.0;
renderer.renderMaxY = 1.0;
renderer.renderMaxZ = 1.0;
renderer.renderStandardBlock(block, x, y, z);
return true;
/*
boolean flag = renderer.renderStandardBlock(block, x, y, z);
return flag;*/
}
@Override
public boolean shouldRender3DInInventory(int renderId)
{
return true;
}
@Override
public int getRenderId()
{
return Chisel.RenderEldritchId;
}
}
@@ -0,0 +1,340 @@
package com.cricketcraft.chisel.client.render;
import net.minecraft.block.Block;
import net.minecraft.block.BlockPane;
import net.minecraft.client.renderer.EntityRenderer;
import net.minecraft.client.renderer.RenderBlocks;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import org.lwjgl.opengl.GL11;
import com.cricketcraft.chisel.utils.Drawing;
import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
import cpw.mods.fml.client.registry.RenderingRegistry;
public class BlockMarblePaneRenderer implements ISimpleBlockRenderingHandler
{
public static int id;
public BlockMarblePaneRenderer()
{
id = RenderingRegistry.getNextAvailableRenderId();
}
@Override
public void renderInventoryBlock(Block block, int meta, int modelID, RenderBlocks renderer)
{
GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
GL11.glScalef(1.25f, 1.25f, 1.25f);
renderer.setRenderBounds(0.0f, 0.0f, 0.5f - 0.0625f, 1.0f, 1.0f, 0.5f + 0.0625f);
Drawing.drawBlock(block, meta, renderer);
}
class PaneRenderer
{
Tessellator tessellator;
double i0u0;
double i0uh;
double i0u1;
double i0v0;
double i0v1;
double i1u0;
double i1u1;
double i1v0;
double i1vh;
double i1v1;
double i1v;
double i2u0;
double i2u1;
double i2v0;
double i2v1;
double i2v;
double x0;
double xh;
double x1;
double xp0;
double xp1;
double z0;
double zh;
double z1;
double zp0;
double zp1;
double y0;
double y1;
void set(double x, double y, double z, IIcon icon, IIcon icon1, IIcon icon2)
{
tessellator = Tessellator.instance;
i0u0 = icon.getMinU();
i0uh = icon.getInterpolatedU(8.0D);
i0u1 = icon.getMaxU();
i0v0 = icon.getMinV();
i0v1 = icon.getMaxV();
i1u0 = icon1.getInterpolatedU(7.0D);
i1u1 = icon1.getInterpolatedU(9.0D);
i1v0 = icon1.getMinV();
i1vh = icon1.getInterpolatedV(8.0D);
i1v1 = icon1.getMaxV();
i1v = i1v1 - i1v0;
i2u0 = icon2.getInterpolatedU(7.0D);
i2u1 = icon2.getInterpolatedU(9.0D);
i2v0 = icon2.getMinV();
i2v1 = icon2.getMaxV();
i2v = i2v1 - i2v0;
x0 = x;
xh = x0 + 0.5D;
x1 = x + 1;
xp0 = x0 + 0.5D - 0.0625D;
xp1 = x0 + 0.5D + 0.0625D;
z0 = z;
zh = z0 + 0.5D;
z1 = z + 1;
zp0 = z0 + 0.5D - 0.0625D;
zp1 = z0 + 0.5D + 0.0625D;
y0 = y;
y1 = y + 1;
}
public void renderNorthPane()
{
tessellator.addVertexWithUV(xh, y1, z0, i0uh, i0v0);
tessellator.addVertexWithUV(xh, y0, z0, i0uh, i0v1);
tessellator.addVertexWithUV(xh, y0, zh, i0u0, i0v1);
tessellator.addVertexWithUV(xh, y1, zh, i0u0, i0v0);
tessellator.addVertexWithUV(xh, y1, zh, i0u0, i0v0);
tessellator.addVertexWithUV(xh, y0, zh, i0u0, i0v1);
tessellator.addVertexWithUV(xh, y0, z0, i0uh, i0v1);
tessellator.addVertexWithUV(xh, y1, z0, i0uh, i0v0);
}
public void renderSouthPane()
{
tessellator.addVertexWithUV(xh, y1, zh, i0u1, i0v0);
tessellator.addVertexWithUV(xh, y0, zh, i0u1, i0v1);
tessellator.addVertexWithUV(xh, y0, z1, i0uh, i0v1);
tessellator.addVertexWithUV(xh, y1, z1, i0uh, i0v0);
tessellator.addVertexWithUV(xh, y1, z1, i0uh, i0v0);
tessellator.addVertexWithUV(xh, y0, z1, i0uh, i0v1);
tessellator.addVertexWithUV(xh, y0, zh, i0u1, i0v1);
tessellator.addVertexWithUV(xh, y1, zh, i0u1, i0v0);
}
public void renderWestPane()
{
tessellator.addVertexWithUV(x0, y1, zh, i0uh, i0v0);
tessellator.addVertexWithUV(x0, y0, zh, i0uh, i0v1);
tessellator.addVertexWithUV(xh, y0, zh, i0u0, i0v1);
tessellator.addVertexWithUV(xh, y1, zh, i0u0, i0v0);
tessellator.addVertexWithUV(xh, y1, zh, i0u0, i0v0);
tessellator.addVertexWithUV(xh, y0, zh, i0u0, i0v1);
tessellator.addVertexWithUV(x0, y0, zh, i0uh, i0v1);
tessellator.addVertexWithUV(x0, y1, zh, i0uh, i0v0);
}
public void renderEastPane()
{
tessellator.addVertexWithUV(xh, y1, zh, i0u1, i0v0);
tessellator.addVertexWithUV(xh, y0, zh, i0u1, i0v1);
tessellator.addVertexWithUV(x1, y0, zh, i0uh, i0v1);
tessellator.addVertexWithUV(x1, y1, zh, i0uh, i0v0);
tessellator.addVertexWithUV(x1, y1, zh, i0uh, i0v0);
tessellator.addVertexWithUV(x1, y0, zh, i0uh, i0v1);
tessellator.addVertexWithUV(xh, y0, zh, i0u1, i0v1);
tessellator.addVertexWithUV(xh, y1, zh, i0u1, i0v0);
}
public void renderVerticalNS(double y, double zoff0, double zoff1, double v0, double v1)
{
tessellator.addVertexWithUV(xp0, y0 + y, z0 + zoff0, i1u0, i1v0 + i1v * v0);
tessellator.addVertexWithUV(xp0, y0 + y, z0 + zoff1, i1u0, i1v0 + i1v * v1);
tessellator.addVertexWithUV(xp1, y0 + y, z0 + zoff1, i1u1, i1v0 + i1v * v1);
tessellator.addVertexWithUV(xp1, y0 + y, z0 + zoff0, i1u1, i1v0 + i1v * v0);
tessellator.addVertexWithUV(xp0, y0 + y, z0 + zoff1, i1u0, i1v0 + i1v * v1);
tessellator.addVertexWithUV(xp0, y0 + y, z0 + zoff0, i1u0, i1v0 + i1v * v0);
tessellator.addVertexWithUV(xp1, y0 + y, z0 + zoff0, i1u1, i1v0 + i1v * v0);
tessellator.addVertexWithUV(xp1, y0 + y, z0 + zoff1, i1u1, i1v0 + i1v * v1);
}
public void renderVerticalWE(double y, double xoff0, double xoff1, double v0, double v1)
{
tessellator.addVertexWithUV(x0 + xoff0, y0 + y, zp1, i1u1, i1v0 + i1v * v0);
tessellator.addVertexWithUV(x0 + xoff1, y0 + y, zp1, i1u1, i1v0 + i1v * v1);
tessellator.addVertexWithUV(x0 + xoff1, y0 + y, zp0, i1u0, i1v0 + i1v * v1);
tessellator.addVertexWithUV(x0 + xoff0, y0 + y, zp0, i1u0, i1v0 + i1v * v0);
tessellator.addVertexWithUV(x0 + xoff1, y0 + y, zp1, i1u1, i1v0 + i1v * v1);
tessellator.addVertexWithUV(x0 + xoff0, y0 + y, zp1, i1u1, i1v0 + i1v * v0);
tessellator.addVertexWithUV(x0 + xoff0, y0 + y, zp0, i1u0, i1v0 + i1v * v0);
tessellator.addVertexWithUV(x0 + xoff1, y0 + y, zp0, i1u0, i1v0 + i1v * v1);
}
public void renderHorizontalNS(double zoff, double v0, double v1)
{
tessellator.addVertexWithUV(xp0, y1, z0 + zoff, i2u0, i2v0 + i2v * v1);
tessellator.addVertexWithUV(xp0, y0, z0 + zoff, i2u0, i2v0 + i2v * v0);
tessellator.addVertexWithUV(xp1, y0, z0 + zoff, i2u1, i2v0 + i2v * v0);
tessellator.addVertexWithUV(xp1, y1, z0 + zoff, i2u1, i2v0 + i2v * v1);
tessellator.addVertexWithUV(xp1, y1, z0 + zoff, i2u1, i2v0 + i2v * v1);
tessellator.addVertexWithUV(xp1, y0, z0 + zoff, i2u1, i2v0 + i2v * v0);
tessellator.addVertexWithUV(xp0, y0, z0 + zoff, i2u0, i2v0 + i2v * v0);
tessellator.addVertexWithUV(xp0, y1, z0 + zoff, i2u0, i2v0 + i2v * v1);
}
public void renderHorizontalWE(double xoff, double v0, double v1)
{
tessellator.addVertexWithUV(x0 + xoff, y1, zp0, i2u0, i2v0 + i2v * v1);
tessellator.addVertexWithUV(x0 + xoff, y0, zp0, i2u0, i2v0 + i2v * v0);
tessellator.addVertexWithUV(x0 + xoff, y0, zp1, i2u1, i2v0 + i2v * v0);
tessellator.addVertexWithUV(x0 + xoff, y1, zp1, i2u1, i2v0 + i2v * v1);
tessellator.addVertexWithUV(x0 + xoff, y1, zp1, i2u1, i2v0 + i2v * v1);
tessellator.addVertexWithUV(x0 + xoff, y0, zp1, i2u1, i2v0 + i2v * v0);
tessellator.addVertexWithUV(x0 + xoff, y0, zp0, i2u0, i2v0 + i2v * v0);
tessellator.addVertexWithUV(x0 + xoff, y1, zp0, i2u0, i2v0 + i2v * v1);
}
}
PaneRenderer paneRenderer = new PaneRenderer();
@Override
public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block b, int modelId, RenderBlocks renderer)
{
BlockPane block = (BlockPane) b;
Tessellator tessellator = Tessellator.instance;
int worldHeight = world.getHeight();
tessellator.setBrightness(block.getMixedBrightnessForBlock(world, x, y, z));
float f = 1.0F;
int i1 = block.colorMultiplier(world, x, y, z);
float f1 = (i1 >> 16 & 255) / 255.0F;
float f2 = (i1 >> 8 & 255) / 255.0F;
float f3 = (i1 & 255) / 255.0F;
if(EntityRenderer.anaglyphEnable)
{
float f4 = (f1 * 30.0F + f2 * 59.0F + f3 * 11.0F) / 100.0F;
float f5 = (f1 * 30.0F + f2 * 70.0F) / 100.0F;
float f6 = (f1 * 30.0F + f3 * 70.0F) / 100.0F;
f1 = f4;
f2 = f5;
f3 = f6;
}
tessellator.setColorOpaque_F(f * f1, f * f2, f * f3);
int meta = world.getBlockMetadata(x, y, z);
IIcon iconPane = block.getIcon(2, meta);
IIcon iconTop = block.getIcon(1, meta);
IIcon iconSide = block.getIcon(0, meta);
if(iconPane == null || iconTop == null || iconSide == null) return false;
paneRenderer.set(x, y, z, iconPane, iconTop, iconSide);
boolean connectsNorth = block.canPaneConnectToBlock(world.getBlock(x, y, z - 1));
boolean connectsSouth = block.canPaneConnectToBlock(world.getBlock(x, y, z + 1));
boolean connectsWest = block.canPaneConnectToBlock(world.getBlock(x - 1, y, z));
boolean connectsEast = block.canPaneConnectToBlock(world.getBlock(x + 1, y, z));
boolean connectsTop = block.canPaneConnectToBlock(world.getBlock(x, y + 1, z));
boolean connectsBottom = block.canPaneConnectToBlock(world.getBlock(x, y - 1, z));
boolean connectsTopNorth = block.canPaneConnectToBlock(world.getBlock(x, y + 1, z - 1));
boolean connectsTopSouth = block.canPaneConnectToBlock(world.getBlock(x, y + 1, z + 1));
boolean connectsTopWest = block.canPaneConnectToBlock(world.getBlock(x - 1, y + 1, z));
boolean connectsTopEast = block.canPaneConnectToBlock(world.getBlock(x + 1, y + 1, z));
boolean connectsBottomNorth = block.canPaneConnectToBlock(world.getBlock(x, y - 1, z - 1));
boolean connectsBottomSouth = block.canPaneConnectToBlock(world.getBlock(x, y - 1, z + 1));
boolean connectsBottomWest = block.canPaneConnectToBlock(world.getBlock(x - 1, y - 1, z));
boolean connectsBottomEast = block.canPaneConnectToBlock(world.getBlock(x + 1, y - 1, z));
boolean isolatedTop = !connectsTopNorth && !connectsTopSouth && !connectsTopWest && !connectsTopEast;
boolean isolatedBottom = !connectsBottomNorth && !connectsBottomSouth && !connectsBottomWest && !connectsBottomEast;
if(!connectsNorth && !connectsSouth && !connectsWest && !connectsEast)
{
connectsNorth = connectsSouth = connectsWest = connectsEast = true;
}
int connections = 0;
if(connectsNorth)
{
paneRenderer.renderNorthPane();
if(!connectsBottom || !connectsBottomNorth && !isolatedBottom)
paneRenderer.renderVerticalNS(-0.0003, 0.0, 0.5, 0.5, 0.0);
if(!connectsTop || !connectsTopNorth && !isolatedTop)
paneRenderer.renderVerticalNS(+1.0003, 0.0, 0.5, 0.5, 0.0);
connections++;
}
if(connectsSouth)
{
paneRenderer.renderSouthPane();
if(!connectsBottom || !connectsBottomSouth && !isolatedBottom)
paneRenderer.renderVerticalNS(-0.0004, 0.5, 1.0, 1.0, 0.5);
if(!connectsTop || !connectsTopSouth && !isolatedTop)
paneRenderer.renderVerticalNS(+1.0004, 0.5, 1.0, 1.0, 0.5);
connections++;
}
if(connectsWest)
{
paneRenderer.renderWestPane();
if(!connectsBottom || !connectsBottomWest && !isolatedBottom)
paneRenderer.renderVerticalWE(-0.0001, 0.0, 0.5, 0.5, 0.0);
if(!connectsTop || !connectsTopWest && !isolatedTop)
paneRenderer.renderVerticalWE(+1.0001, 0.0, 0.5, 0.5, 0.0);
connections++;
}
if(connectsEast)
{
paneRenderer.renderEastPane();
if(!connectsBottom || !connectsBottomEast && !isolatedBottom)
paneRenderer.renderVerticalWE(-0.0002, 0.5, 1.0, 1.0, 0.5);
if(!connectsTop || !connectsTopEast && !isolatedTop)
paneRenderer.renderVerticalWE(+1.0002, 0.5, 1.0, 1.0, 0.5);
connections++;
}
if(connections == 1)
{
if(connectsNorth) paneRenderer.renderHorizontalNS(0.5, 1.0, 0.0);
if(connectsSouth) paneRenderer.renderHorizontalNS(0.5, 0.0, 1.0);
if(connectsEast) paneRenderer.renderHorizontalWE(0.5, 0.0, 1.0);
if(connectsWest) paneRenderer.renderHorizontalWE(0.5, 1.0, 0.0);
} else if(connections == 4)
{
paneRenderer.renderHorizontalNS(0.0, 1.0, 0.0);
paneRenderer.renderHorizontalNS(1.0, 0.0, 1.0);
paneRenderer.renderHorizontalWE(0.0, 0.0, 1.0);
paneRenderer.renderHorizontalWE(1.0, 1.0, 0.0);
}
return true;
}
@Override
public boolean shouldRender3DInInventory(int renderId)
{
return false;
}
@Override
public int getRenderId()
{
return id;
}
}
@@ -0,0 +1,175 @@
package com.cricketcraft.chisel.client.render;
import net.minecraft.block.Block;
import net.minecraft.client.renderer.RenderBlocks;
import net.minecraft.world.IBlockAccess;
import org.lwjgl.opengl.GL11;
import com.cricketcraft.chisel.block.BlockMarblePillar;
import com.cricketcraft.chisel.carving.CarvableHelper;
import com.cricketcraft.chisel.utils.Drawing;
import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
import cpw.mods.fml.client.registry.RenderingRegistry;
public class BlockMarblePillarRenderer implements ISimpleBlockRenderingHandler
{
public static int id;
public BlockMarblePillarRenderer()
{
id = RenderingRegistry.getNextAvailableRenderId();
}
@Override
public void renderInventoryBlock(Block blck, int metadata, int modelID, RenderBlocks renderer)
{
if(!(blck instanceof BlockMarblePillar))
return;
BlockMarblePillar block = (BlockMarblePillar) blck;
block.sides[0] = block.sides[1] = block.getCtmIcon(4, metadata);
block.sides[2] = block.sides[3] = block.sides[4] = block.sides[5] = block.getCtmIcon(0, metadata);
GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
Drawing.drawBlock(block, metadata, renderer);
}
boolean connected(IBlockAccess world, int x, int y, int z, Block block, int meta)
{
return world.getBlock(x, y, z).equals(block) && world.getBlockMetadata(x, y, z) == meta;
}
@Override
public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block blck, int modelId, RenderBlocks renderer)
{
if(!(blck instanceof BlockMarblePillar))
return false;
BlockMarblePillar block = (BlockMarblePillar) blck;
int metadata = world.getBlockMetadata(x, y, z);
if(block.carverHelper.variations.get(metadata).kind != CarvableHelper.CTMV)
{
block.sides[0] = block.carverHelper.getIcon(0, metadata);
block.sides[1] = block.carverHelper.getIcon(1, metadata);
block.sides[2] = block.carverHelper.getIcon(2, metadata);
block.sides[3] = block.carverHelper.getIcon(3, metadata);
block.sides[4] = block.carverHelper.getIcon(4, metadata);
block.sides[5] = block.carverHelper.getIcon(5, metadata);
return renderer.renderStandardBlock(block, x, y, z);
}
boolean yp = connected(world, x, y + 1, z, block, metadata);
boolean yn = connected(world, x, y - 1, z, block, metadata);
if(yp || yn)
{
block.sides[0] = block.getCtmIcon(4, metadata);
block.sides[1] = block.getCtmIcon(4, metadata);
if(yp && yn)
block.sides[2] = block.getCtmIcon(2, metadata);
else if(yp)
block.sides[2] = block.getCtmIcon(3, metadata);
else
block.sides[2] = block.getCtmIcon(1, metadata);
block.sides[3] = block.sides[4] = block.sides[5] = block.sides[2];
} else
{
boolean xp = connected(world, x + 1, y, z, block, metadata);
boolean xn = connected(world, x - 1, y, z, block, metadata);
if(xp && (connected(world, x + 1, y + 1, z, block, metadata) || connected(world, x + 1, y - 1, z, block, metadata)))
xp = false;
if(xn && (connected(world, x - 1, y + 1, z, block, metadata) || connected(world, x - 1, y - 1, z, block, metadata)))
xn = false;
if(xp || xn)
{
renderer.uvRotateEast = 2;
renderer.uvRotateWest = 1;
renderer.uvRotateTop = 1;
renderer.uvRotateBottom = 1;
block.sides[4] = block.getCtmIcon(4, metadata);
block.sides[5] = block.getCtmIcon(4, metadata);
if(xp && xn)
block.sides[0] = block.getCtmIcon(2, metadata);
else if(xp)
block.sides[0] = block.getCtmIcon(3, metadata);
else
block.sides[0] = block.getCtmIcon(1, metadata);
block.sides[1] = block.sides[2] = block.sides[3] = block.sides[0];
} else
{
boolean zp = connected(world, x, y, z + 1, block, metadata);
boolean zn = connected(world, x, y, z - 1, block, metadata);
if(zp && (connected(world, x, y + 1, z + 1, block, metadata) || connected(world, x, y - 1, z + 1, block, metadata)))
zp = false;
if(zp && (connected(world, x + 1, y, z + 1, block, metadata) || connected(world, x - 1, y, z + 1, block, metadata)))
zp = false;
if(zn && (connected(world, x, y + 1, z - 1, block, metadata) || connected(world, x, y - 1, z - 1, block, metadata)))
zn = false;
if(zn && (connected(world, x + 1, y, z - 1, block, metadata) || connected(world, x - 1, y, z - 1, block, metadata)))
zn = false;
if(zp || zn)
{
renderer.uvRotateSouth = 1;
renderer.uvRotateNorth = 2;
block.sides[2] = block.getCtmIcon(4, metadata);
block.sides[3] = block.getCtmIcon(4, metadata);
if(zp && zn)
block.sides[0] = block.getCtmIcon(2, metadata);
else if(zp)
block.sides[0] = block.getCtmIcon(1, metadata);
else
block.sides[0] = block.getCtmIcon(3, metadata);
block.sides[1] = block.sides[4] = block.sides[5] = block.sides[0];
} else
{
block.sides[0] = block.sides[1] = block.getCtmIcon(4, metadata);
block.sides[2] = block.sides[3] = block.sides[4] = block.sides[5] = block.getCtmIcon(0, metadata);
}
}
}
boolean flag = renderer.renderStandardBlock(block, x, y, z);
renderer.uvRotateSouth = 0;
renderer.uvRotateEast = 0;
renderer.uvRotateWest = 0;
renderer.uvRotateNorth = 0;
renderer.uvRotateTop = 0;
renderer.uvRotateBottom = 0;
return flag;
}
@Override
public boolean shouldRender3DInInventory(int renderId)
{
return true;
}
@Override
public int getRenderId()
{
return id;
}
}
@@ -0,0 +1,63 @@
package com.cricketcraft.chisel.client.render;
import net.minecraft.block.Block;
import net.minecraft.client.renderer.RenderBlocks;
import net.minecraft.world.IBlockAccess;
import org.lwjgl.opengl.GL11;
import com.cricketcraft.chisel.block.BlockMarbleStairs;
import com.cricketcraft.chisel.utils.Drawing;
import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
import cpw.mods.fml.client.registry.RenderingRegistry;
public class BlockMarbleStairsRenderer implements ISimpleBlockRenderingHandler
{
public static int id;
public BlockMarbleStairsRenderer()
{
id = RenderingRegistry.getNextAvailableRenderId();
}
@Override
public void renderInventoryBlock(Block block, int meta, int modelID, RenderBlocks renderer)
{
GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
renderer.setRenderBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 0.5F);
Drawing.drawBlock(block, meta, renderer);
renderer.setRenderBounds(0.0F, 0.0F, 0.5F, 1.0F, 0.5F, 1.0F);
Drawing.drawBlock(block, meta, renderer);
}
@Override
public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block blck, int modelId, RenderBlocks renderer)
{
if(blck == null || !(blck instanceof BlockMarbleStairs))
return false;
BlockMarbleStairs block = (BlockMarbleStairs) blck;
renderer.renderBlockStairs(block, x, y, z);
return true;
}
@Override
public boolean shouldRender3DInInventory(int renderId)
{
return true;
}
@Override
public int getRenderId()
{
return id;
}
public int getRenderBlockPass()
{
return 1;
}
}
@@ -0,0 +1,55 @@
package com.cricketcraft.chisel.client.render;
import net.minecraft.block.Block;
import net.minecraft.client.renderer.RenderBlocks;
import net.minecraft.world.IBlockAccess;
import org.lwjgl.opengl.GL11;
import com.cricketcraft.chisel.utils.Drawing;
import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
import cpw.mods.fml.client.registry.RenderingRegistry;
public class BlockNoCTMRenderer implements ISimpleBlockRenderingHandler
{
static int id;
public BlockNoCTMRenderer()
{
id = RenderingRegistry.getNextAvailableRenderId();
}
@Override
public void renderInventoryBlock(Block block, int meta, int modelID, RenderBlocks renderer)
{
GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
Drawing.drawBlock(block, meta, renderer);
}
@Override
public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer)
{
int meta = world.getBlockMetadata(x, y, z);
if(meta != 0) renderer.overrideBlockTexture = block.getIcon(0, meta);
renderer.setRenderBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
renderer.renderStandardBlock(block, x, y, z);
renderer.overrideBlockTexture = null;
return false;
}
@Override
public boolean shouldRender3DInInventory(int renderId)
{
return true;
}
@Override
public int getRenderId()
{
return id;
}
}
@@ -0,0 +1,138 @@
package com.cricketcraft.chisel.client.render;
import com.cricketcraft.chisel.block.BlockRoadLine;
import com.cricketcraft.chisel.utils.Drawing;
import net.minecraft.block.Block;
import net.minecraft.client.renderer.EntityRenderer;
import net.minecraft.client.renderer.RenderBlocks;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
import cpw.mods.fml.client.registry.RenderingRegistry;
public class BlockRoadLineRenderer implements ISimpleBlockRenderingHandler
{
public static int id;
public BlockRoadLineRenderer()
{
id = RenderingRegistry.getNextAvailableRenderId();
}
@Override
public void renderInventoryBlock(Block block, int meta, int modelID, RenderBlocks renderer)
{
renderer.setRenderBoundsFromBlock(block);
Drawing.drawBlock(block, meta, renderer);
}
public void renderTopFace(double y, IIcon icon)
{
Tessellator tessellator = Tessellator.instance;
tessellator.addVertexWithUV(1, y, 0, icon.getMaxU(), icon.getMinV());
tessellator.addVertexWithUV(0, y, 0, icon.getMinU(), icon.getMinV());
tessellator.addVertexWithUV(0, y, 1, icon.getMinU(), icon.getMaxV());
tessellator.addVertexWithUV(1, y, 1, icon.getMaxU(), icon.getMaxV());
}
@Override
public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block b, int modelId, RenderBlocks renderer)
{
int meta = world.getBlockMetadata(x, y, z);
BlockRoadLine block = (BlockRoadLine) b;
Tessellator tessellator = Tessellator.instance;
tessellator.setBrightness(block.getMixedBrightnessForBlock(world, x, y, z));
float f = 1.0F;
int i1 = block.colorMultiplier(world, x, y, z);
float f1 = (i1 >> 16 & 255) / 255.0F;
float f2 = (i1 >> 8 & 255) / 255.0F;
float f3 = (i1 & 255) / 255.0F;
if(EntityRenderer.anaglyphEnable)
{
float f4 = (f1 * 30.0F + f2 * 59.0F + f3 * 11.0F) / 100.0F;
float f5 = (f1 * 30.0F + f2 * 70.0F) / 100.0F;
float f6 = (f1 * 30.0F + f3 * 70.0F) / 100.0F;
f1 = f4;
f2 = f5;
f3 = f6;
}
tessellator.setColorOpaque_F(f * f1, f * f2, f * f3);
boolean N = world.getBlock(x, y, z - 1).equals(block);
boolean S = world.getBlock(x, y, z + 1).equals(block);
boolean W = world.getBlock(x - 1, y, z).equals(block);
boolean E = world.getBlock(x + 1, y, z).equals(block);
if(!N && !S && !W && !E)
{
renderer.renderStandardBlock(block, x, y, z);
return true;
}
if(N && S)
{
renderer.uvRotateTop = 0;
renderer.overrideBlockTexture = block.fullLineIcon;
renderer.renderStandardBlock(block, x, y, z);
} else
{
if(N)
{
renderer.uvRotateTop = 0;
renderer.overrideBlockTexture = block.halfLineIcon;
renderer.renderStandardBlock(block, x, y, z);
}
if(S)
{
renderer.uvRotateTop = 3;
renderer.overrideBlockTexture = block.halfLineIcon;
renderer.renderStandardBlock(block, x, y, z);
}
}
if(E && W)
{
renderer.uvRotateTop = 1;
renderer.overrideBlockTexture = block.fullLineIcon;
renderer.renderStandardBlock(block, x, y, z);
} else
{
if(E)
{
renderer.uvRotateTop = 1;
renderer.overrideBlockTexture = block.halfLineIcon;
renderer.renderStandardBlock(block, x, y, z);
}
if(W)
{
renderer.uvRotateTop = 2;
renderer.overrideBlockTexture = block.halfLineIcon;
renderer.renderStandardBlock(block, x, y, z);
}
}
renderer.uvRotateTop = 0;
renderer.overrideBlockTexture = null;
return true;
}
@Override
public boolean shouldRender3DInInventory(int renderId)
{
return false;
}
@Override
public int getRenderId()
{
return id;
}
}
@@ -0,0 +1,140 @@
package com.cricketcraft.chisel.client.render;
import net.minecraft.block.Block;
import net.minecraft.client.renderer.RenderBlocks;
import net.minecraft.world.IBlockAccess;
import org.lwjgl.opengl.GL11;
import com.cricketcraft.chisel.block.BlockSnakestone;
import com.cricketcraft.chisel.utils.Drawing;
import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
import cpw.mods.fml.client.registry.RenderingRegistry;
public class BlockSnakeStoneRenderer implements ISimpleBlockRenderingHandler
{
public static int id;
public BlockSnakeStoneRenderer()
{
id = RenderingRegistry.getNextAvailableRenderId();
}
@Override
public void renderInventoryBlock(Block block, int meta, int modelID, RenderBlocks renderer)
{
setRenderRotate(renderer, (BlockSnakestone) block, meta);
GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
Drawing.drawBlock(block, meta, renderer);
GL11.glTranslatef(0.5F, 0.5F, 0.5F);
restoreRendererRotate(renderer);
}
@Override
public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer)
{
int meta = world.getBlockMetadata(x, y, z);
setRenderRotate(renderer, (BlockSnakestone) block, meta);
boolean didRender = renderer.renderStandardBlock(block, x, y, z);
restoreRendererRotate(renderer);
return didRender;
}
private void restoreRendererRotate(RenderBlocks renderer)
{
renderer.uvRotateSouth = 0;
renderer.uvRotateEast = 0;
renderer.uvRotateWest = 0;
renderer.uvRotateNorth = 0;
renderer.uvRotateTop = 0;
renderer.uvRotateBottom = 0;
}
private void setRenderRotate(RenderBlocks renderer, BlockSnakestone block, int meta)
{
int type = meta & 0xC;
int orient = meta & 0x3;
if(type == 0)
{
switch(orient)
{
case 0:
renderer.uvRotateTop = 1;
renderer.uvRotateBottom = 2;
break;
case 1:
renderer.uvRotateTop = 1;
renderer.uvRotateBottom = 1;
break;
case 2:
renderer.uvRotateTop = 0;
renderer.uvRotateBottom = 3;
break;
case 3:
renderer.uvRotateTop = 0;
renderer.uvRotateBottom = 0;
}
} else if((type == 4) || (type == 8))
{
switch(orient)
{
case 0:
renderer.uvRotateTop = block.flipTopTextures ? 1 : 2;
renderer.uvRotateBottom = 1;
renderer.uvRotateWest = 2;
break;
case 1:
renderer.uvRotateTop = 1;
renderer.uvRotateBottom = 1;
renderer.uvRotateEast = 2;
break;
case 2:
renderer.uvRotateTop = block.flipTopTextures ? 0 : 3;
renderer.uvRotateBottom = 0;
renderer.uvRotateSouth = 2;
break;
case 3:
renderer.uvRotateTop = 0;
renderer.uvRotateBottom = 0;
renderer.uvRotateNorth = 2;
}
} else if(type == 12)
{
switch(orient)
{
case 0:
renderer.uvRotateTop = 0;
renderer.uvRotateBottom = 0;
break;
case 1:
renderer.uvRotateTop = 1;
renderer.uvRotateBottom = 1;
break;
case 2:
renderer.uvRotateNorth = 2;
renderer.uvRotateSouth = 2;
renderer.uvRotateEast = 2;
renderer.uvRotateWest = 2;
}
}
}
@Override
public boolean shouldRender3DInInventory(int renderId)
{
return true;
}
@Override
public int getRenderId()
{
return id;
}
}
@@ -0,0 +1,116 @@
package com.cricketcraft.chisel.client.render;
import java.util.Random;
import com.cricketcraft.chisel.init.ModBlocks;
import com.cricketcraft.chisel.utils.Drawing;
import net.minecraft.block.Block;
import net.minecraft.client.renderer.RenderBlocks;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
import cpw.mods.fml.client.registry.RenderingRegistry;
public class BlockSpikesRenderer implements ISimpleBlockRenderingHandler
{
public static int id;
public BlockSpikesRenderer()
{
id = RenderingRegistry.getNextAvailableRenderId();
}
@Override
public void renderInventoryBlock(Block block, int meta, int modelID, RenderBlocks renderer)
{
Drawing.drawBlock(block, meta, renderer);
}
void drawSpike(IIcon icon, double r, double h, double x, double y, double z, double dx, double dz)
{
Tessellator tessellator = Tessellator.instance;
double u0 = icon.getMinU();
double u1 = icon.getMaxU();
double v0 = icon.getMaxV();
double v1 = icon.getMinV();
double tx = x + dx;
double ty = y + h;
double tz = z + dz;
tessellator.addVertexWithUV(x + r, y + 0, z + r, u0, v0);
tessellator.addVertexWithUV(x + r, y + 0, z - r, u1, v0);
tessellator.addVertexWithUV(tx, ty, tz, u1, v1);
tessellator.addVertexWithUV(tx, ty, tz, u0, v1);
tessellator.addVertexWithUV(x - r, y + 0, z + r, u1, v0);
tessellator.addVertexWithUV(x + r, y + 0, z + r, u0, v0);
tessellator.addVertexWithUV(tx, ty, tz, u1, v1);
tessellator.addVertexWithUV(tx, ty, tz, u0, v1);
tessellator.addVertexWithUV(x + r, y + 0, z - r, u1, v0);
tessellator.addVertexWithUV(x - r, y + 0, z - r, u0, v0);
tessellator.addVertexWithUV(tx, ty, tz, u1, v1);
tessellator.addVertexWithUV(tx, ty, tz, u0, v1);
tessellator.addVertexWithUV(x - r, y + 0, z - r, u1, v0);
tessellator.addVertexWithUV(x - r, y + 0, z + r, u0, v0);
tessellator.addVertexWithUV(tx, ty, tz, u1, v1);
tessellator.addVertexWithUV(tx, ty, tz, u0, v1);
}
@Override
public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer)
{
renderer.renderStandardBlock(block, x, y, z);
Tessellator tessellator = Tessellator.instance;
IIcon icon = ModBlocks.spikeTrap.iconSpike;
double d = 1.5 / 16;
double r = d / 2;
double skew = 0.5;
// tessellator.setBrightness(block.getMixedBrightnessForBlock(world, x, y, z));
tessellator.addTranslation(0, 1.0f / 16, 0);
Random rand = new Random();
for(int xx = 0; xx < 4; xx++)
{
for(int yy = 0; yy < 4; yy++)
{
// float sx=1.0f/16+rand.nextFloat()*13.0f/16;
// float sz=1.0f/16+rand.nextFloat()*13.0f/16;
float sx = (2.0f + (12.0f - (float) d) * xx / 3) / 16;
float sz = (2.0f + (12.0f - (float) d) * yy / 3) / 16;
tessellator.addTranslation(sx, 0, sz);
drawSpike(icon, r, 0.5 + rand.nextDouble() * 0.35, x, y, z, rand.nextDouble() * skew - skew / 2, rand.nextDouble() * skew - skew / 2);
tessellator.addTranslation(-sx, 0, -sz);
}
}
tessellator.addTranslation(0, -1.0f / 16, 0);
return true;
}
@Override
public boolean shouldRender3DInInventory(int renderId)
{
return true;
}
@Override
public int getRenderId()
{
return id;
}
}
@@ -0,0 +1,90 @@
package com.cricketcraft.chisel.client.render;
import net.minecraft.block.Block;
import net.minecraft.client.renderer.RenderBlocks;
import net.minecraft.init.Blocks;
import net.minecraft.world.IBlockAccess;
import org.lwjgl.opengl.GL11;
import com.cricketcraft.chisel.block.BlockTexturedOre;
import com.cricketcraft.chisel.utils.Drawing;
import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
import cpw.mods.fml.client.registry.RenderingRegistry;
public class BlockTexturedOreRenderer implements ISimpleBlockRenderingHandler
{
float bot = -0.001f, top = 1.0f - bot;
public static int id;
public BlockTexturedOreRenderer()
{
id = RenderingRegistry.getNextAvailableRenderId();
}
@Override
public void renderInventoryBlock(Block blck, int meta, int modelID, RenderBlocks renderer)
{
if(blck == null || !(blck instanceof BlockTexturedOre))
return;
BlockTexturedOre block = (BlockTexturedOre) blck;
if(block.icon != null)
{
renderer.overrideBlockTexture = block.icon;
renderer.renderBlockAsItem(Blocks.stone, meta, 1.0f);
renderer.overrideBlockTexture = null;
} else if(block.base != null)
{
renderer.renderBlockAsItem(block.base, meta, 1.0f);
}
GL11.glEnable(3042);
GL11.glBlendFunc(770, 771);
renderer.setRenderBounds(bot, bot, bot, top, top, top);
GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
Drawing.drawBlock(block, meta, renderer);
GL11.glDisable(3042);
}
@Override
public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block blck, int modelId, RenderBlocks renderer)
{
if(blck == null || !(blck instanceof BlockTexturedOre))
return false;
BlockTexturedOre block = (BlockTexturedOre) blck;
if(block.currentPass == 0)
{
if(block.icon != null)
{
renderer.overrideBlockTexture = block.icon;
renderer.renderStandardBlock(block, x, y, z);
renderer.overrideBlockTexture = null;
} else if(block.base != null)
{
renderer.renderBlockByRenderType(block.base, x, y, z);
}
} else
{
renderer.setRenderBounds(bot, bot, bot, top, top, top);
renderer.renderStandardBlock(block, x, y, z);
}
return true;
}
@Override
public boolean shouldRender3DInInventory(int modelId)
{
return true;
}
@Override
public int getRenderId()
{
return id;
}
}
@@ -0,0 +1,310 @@
package com.cricketcraft.chisel.client.render;
import com.cricketcraft.chisel.api.IFacade;
import net.minecraft.block.Block;
import net.minecraft.world.IBlockAccess;
public class CTM
{
static int submaps[][] = {
{16, 17, 18, 19},
{16, 9, 18, 13},
{8, 9, 12, 13},
{8, 17, 12, 19},
{16, 9, 6, 15},
{8, 17, 14, 7},
{2, 11, 6, 15},
{8, 9, 14, 15},
{10, 1, 14, 15},
{10, 11, 14, 5},
{0, 11, 4, 15},
{0, 1, 14, 15},
{},
{},
{},
{},
{16, 17, 6, 7},
{16, 9, 6, 5},
{8, 9, 4, 5},
{8, 17, 4, 7},
{2, 11, 18, 13},
{10, 3, 12, 19},
{10, 11, 12, 13},
{10, 3, 14, 7},
{0, 11, 14, 15},
{10, 11, 4, 15},
{10, 11, 4, 5},
{10, 1, 14, 5},
{},
{},
{},
{},
{2, 3, 6, 7},
{2, 1, 6, 5},
{0, 1, 4, 5},
{0, 3, 4, 7},
{2, 11, 6, 5},
{8, 9, 4, 15},
{2, 1, 6, 15},
{8, 9, 14, 5},
{0, 1, 4, 15},
{0, 1, 14, 5},
{10, 1, 4, 15},
{0, 11, 14, 5},
{},
{},
{},
{},
{2, 3, 18, 19},
{2, 1, 18, 13},
{0, 1, 12, 13},
{0, 3, 12, 19},
{10, 1, 12, 13},
{0, 3, 14, 7},
{0, 11, 12, 13},
{10, 3, 4, 7},
{0, 11, 4, 5},
{10, 1, 4, 5},
{10, 11, 14, 15},
{0, 1, 4, 5},
{},
{},
{},
{},
};
public static int[] getSubmapIndices(IBlockAccess world, int x, int y, int z, int side)
{
int index = getTexture(world, x, y, z, side);
return submaps[index];
}
public static int getTexture(IBlockAccess world, int x, int y, int z, int side)
{
if(world == null)
return 0;
int texture = 0;
Block block = world.getBlock(x, y, z);
int blockMetadata = world.getBlockMetadata(x, y, z);
boolean b[] = new boolean[6];
if(side <= 1)
{
b[0] = isConnected(world, x - 1, y, z, side, block, blockMetadata);
b[1] = isConnected(world, x + 1, y, z, side, block, blockMetadata);
b[2] = isConnected(world, x, y, z + 1, side, block, blockMetadata);
b[3] = isConnected(world, x, y, z - 1, side, block, blockMetadata);
} else if(side == 2)
{
b[0] = isConnected(world, x + 1, y, z, side, block, blockMetadata);
b[1] = isConnected(world, x - 1, y, z, side, block, blockMetadata);
b[2] = isConnected(world, x, y - 1, z, side, block, blockMetadata);
b[3] = isConnected(world, x, y + 1, z, side, block, blockMetadata);
} else if(side == 3)
{
b[0] = isConnected(world, x - 1, y, z, side, block, blockMetadata);
b[1] = isConnected(world, x + 1, y, z, side, block, blockMetadata);
b[2] = isConnected(world, x, y - 1, z, side, block, blockMetadata);
b[3] = isConnected(world, x, y + 1, z, side, block, blockMetadata);
} else if(side == 4)
{
b[0] = isConnected(world, x, y, z - 1, side, block, blockMetadata);
b[1] = isConnected(world, x, y, z + 1, side, block, blockMetadata);
b[2] = isConnected(world, x, y - 1, z, side, block, blockMetadata);
b[3] = isConnected(world, x, y + 1, z, side, block, blockMetadata);
} else if(side == 5)
{
b[0] = isConnected(world, x, y, z + 1, side, block, blockMetadata);
b[1] = isConnected(world, x, y, z - 1, side, block, blockMetadata);
b[2] = isConnected(world, x, y - 1, z, side, block, blockMetadata);
b[3] = isConnected(world, x, y + 1, z, side, block, blockMetadata);
}
if(b[0] & !b[1] & !b[2] & !b[3])
texture = 3;
else if(!b[0] & b[1] & !b[2] & !b[3])
texture = 1;
else if(!b[0] & !b[1] & b[2] & !b[3])
texture = 16;
else if(!b[0] & !b[1] & !b[2] & b[3])
texture = 48;
else if(b[0] & b[1] & !b[2] & !b[3])
texture = 2;
else if(!b[0] & !b[1] & b[2] & b[3])
texture = 32;
else if(b[0] & !b[1] & b[2] & !b[3])
texture = 19;
else if(b[0] & !b[1] & !b[2] & b[3])
texture = 51;
else if(!b[0] & b[1] & b[2] & !b[3])
texture = 17;
else if(!b[0] & b[1] & !b[2] & b[3])
texture = 49;
else if(!b[0] & b[1] & b[2] & b[3])
texture = 33;
else if(b[0] & !b[1] & b[2] & b[3])
texture = 35;
else if(b[0] & b[1] & !b[2] & b[3])
texture = 50;
else if(b[0] & b[1] & b[2] & !b[3])
texture = 18;
else if(b[0] & b[1] & b[2] & b[3])
texture = 34;
boolean b2[] = new boolean[6];
if(side <= 1)
{
b2[0] = !isConnected(world, x + 1, y, z + 1, side, block, blockMetadata);
b2[1] = !isConnected(world, x - 1, y, z + 1, side, block, blockMetadata);
b2[2] = !isConnected(world, x + 1, y, z - 1, side, block, blockMetadata);
b2[3] = !isConnected(world, x - 1, y, z - 1, side, block, blockMetadata);
} else if(side == 2)
{
b2[0] = !isConnected(world, x - 1, y - 1, z, side, block, blockMetadata);
b2[1] = !isConnected(world, x + 1, y - 1, z, side, block, blockMetadata);
b2[2] = !isConnected(world, x - 1, y + 1, z, side, block, blockMetadata);
b2[3] = !isConnected(world, x + 1, y + 1, z, side, block, blockMetadata);
} else if(side == 3)
{
b2[0] = !isConnected(world, x + 1, y - 1, z, side, block, blockMetadata);
b2[1] = !isConnected(world, x - 1, y - 1, z, side, block, blockMetadata);
b2[2] = !isConnected(world, x + 1, y + 1, z, side, block, blockMetadata);
b2[3] = !isConnected(world, x - 1, y + 1, z, side, block, blockMetadata);
} else if(side == 4)
{
b2[0] = !isConnected(world, x, y - 1, z + 1, side, block, blockMetadata);
b2[1] = !isConnected(world, x, y - 1, z - 1, side, block, blockMetadata);
b2[2] = !isConnected(world, x, y + 1, z + 1, side, block, blockMetadata);
b2[3] = !isConnected(world, x, y + 1, z - 1, side, block, blockMetadata);
} else if(side == 5)
{
b2[0] = !isConnected(world, x, y - 1, z - 1, side, block, blockMetadata);
b2[1] = !isConnected(world, x, y - 1, z + 1, side, block, blockMetadata);
b2[2] = !isConnected(world, x, y + 1, z - 1, side, block, blockMetadata);
b2[3] = !isConnected(world, x, y + 1, z + 1, side, block, blockMetadata);
}
if(texture == 17 && b2[0])
texture = 4;
if(texture == 19 && b2[1])
texture = 5;
if(texture == 49 && b2[2])
texture = 20;
if(texture == 51 && b2[3])
texture = 21;
if(texture == 18 && b2[0] && b2[1])
texture = 7;
if(texture == 33 && b2[0] && b2[2])
texture = 6;
if(texture == 35 && b2[3] && b2[1])
texture = 23;
if(texture == 50 && b2[3] && b2[2])
texture = 22;
if(texture == 18 && !b2[0] && b2[1])
texture = 39;
if(texture == 33 && b2[0] && !b2[2])
texture = 38;
if(texture == 35 && !b2[3] && b2[1])
texture = 53;
if(texture == 50 && b2[3] && !b2[2])
texture = 52;
if(texture == 18 && b2[0] && !b2[1])
texture = 37;
if(texture == 33 && !b2[0] && b2[2])
texture = 36;
if(texture == 35 && b2[3] && !b2[1])
texture = 55;
if(texture == 50 && !b2[3] && b2[2])
texture = 54;
if(texture == 34 && b2[0] && b2[1] && b2[2] && b2[3])
texture = 58;
if(texture == 34 && !b2[0] && b2[1] && b2[2] && b2[3])
texture = 9;
if(texture == 34 && b2[0] && !b2[1] && b2[2] && b2[3])
texture = 25;
if(texture == 34 && b2[0] && b2[1] && !b2[2] && b2[3])
texture = 8;
if(texture == 34 && b2[0] && b2[1] && b2[2] && !b2[3])
texture = 24;
if(texture == 34 && b2[0] && b2[1] && !b2[2] && !b2[3])
texture = 11;
if(texture == 34 && !b2[0] && !b2[1] && b2[2] && b2[3])
texture = 26;
if(texture == 34 && !b2[0] && b2[1] && !b2[2] && b2[3])
texture = 27;
if(texture == 34 && b2[0] && !b2[1] && b2[2] && !b2[3])
texture = 10;
if(texture == 34 && b2[0] && !b2[1] && !b2[2] && b2[3])
texture = 42;
if(texture == 34 && !b2[0] && b2[1] && b2[2] && !b2[3])
texture = 43;
if(texture == 34 && b2[0] && !b2[1] && !b2[2] && !b2[3])
texture = 40;
if(texture == 34 && !b2[0] && b2[1] && !b2[2] && !b2[3])
texture = 41;
if(texture == 34 && !b2[0] && !b2[1] && b2[2] && !b2[3])
texture = 56;
if(texture == 34 && !b2[0] && !b2[1] && !b2[2] && b2[3])
texture = 57;
return texture;
}
private static boolean isConnected(IBlockAccess world, int x, int y, int z, int side, Block block, int meta)
{
int x2 = x, y2 = y, z2 = z;
switch(side)
{
case 0:
y2--;
break;
case 1:
y2++;
break;
case 2:
z2--;
break;
case 3:
z2++;
break;
case 4:
x2--;
break;
case 5:
x2++;
break;
}
if (getBlockOrFacade(world, x2, y2, z2, side) == null || getBlockOrFacade(world, x, y, z, side) == null || block == null)
return false;
return getBlockOrFacade(world, x, y, z, side).equals(block) && getBlockOrFacadeMetadata(world, x, y, z, side) == meta && (!getBlockOrFacade(world, x2, y2, z2, side).equals(block) || getBlockOrFacadeMetadata(world, x2, y2, z2, side) != meta);
}
private static int getBlockOrFacadeMetadata(IBlockAccess world, int x, int y, int z, int side) {
Block blk = world.getBlock(x, y, z);
if(blk instanceof IFacade) {
return ((IFacade)blk).getFacadeMetadata(world, x, y, z, side);
}
return world.getBlockMetadata(x, y, z);
}
private static Block getBlockOrFacade(IBlockAccess world, int x, int y, int z, int side) {
Block blk = world.getBlock(x, y, z);
if(blk instanceof IFacade) {
blk = ((IFacade)blk).getFacade(world, x, y, z, side);
}
return blk;
}
}
@@ -0,0 +1,377 @@
package com.cricketcraft.chisel.client.render;
import net.minecraft.block.Block;
import net.minecraft.client.renderer.RenderBlocks;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.util.IIcon;
public class RenderBlocksCTM extends RenderBlocks
{
RenderBlocksCTM()
{
super();
resetVertices();
}
Tessellator tessellator;
double[] X = new double[26];
double[] Y = new double[26];
double[] Z = new double[26];
double[] U = new double[26];
double[] V = new double[26];
int[] L = new int[26];
float[] R = new float[26];
float[] G = new float[26];
float[] B = new float[26];
TextureSubmap submap;
TextureSubmap submapSmall;
RenderBlocks rendererOld;
int bx, by, bz;
@Override
public boolean renderStandardBlock(Block block, int x, int y, int z)
{
bx = x;
by = y;
bz = z;
tessellator = Tessellator.instance;
tessellator.setColorOpaque_F(1.0F, 1.0F, 1.0F);
tessellator.addTranslation(x, y, z);
boolean res = super.renderStandardBlock(block, x, y, z);
tessellator.addTranslation(-x, -y, -z);
return res;
}
void setupSides(int a, int b, int c, int d, int xa, int xb, int xc, int xd, int e)
{
L[a] = brightnessBottomLeft;
L[b] = brightnessBottomRight;
L[c] = brightnessTopRight;
L[d] = brightnessTopLeft;
L[e] = (brightnessBottomLeft + brightnessTopLeft + brightnessTopRight + brightnessBottomRight) / 4;
L[xa] = (L[a] + L[b]) / 2;
L[xb] = (L[b] + L[c]) / 2;
L[xc] = (L[c] + L[d]) / 2;
L[xd] = (L[d] + L[a]) / 2;
R[a] = colorRedBottomLeft;
R[b] = colorRedBottomRight;
R[c] = colorRedTopRight;
R[d] = colorRedTopLeft;
R[e] = (colorRedBottomLeft + colorRedTopLeft + colorRedTopRight + colorRedBottomRight) / 4;
R[xa] = (R[a] + R[b]) / 2;
R[xb] = (R[b] + R[c]) / 2;
R[xc] = (R[c] + R[d]) / 2;
R[xd] = (R[d] + R[a]) / 2;
G[a] = colorGreenBottomLeft;
G[b] = colorGreenBottomRight;
G[c] = colorGreenTopRight;
G[d] = colorGreenTopLeft;
G[e] = (colorGreenBottomLeft + colorGreenTopLeft + colorGreenTopRight + colorGreenBottomRight) / 4;
G[xa] = (G[a] + G[b]) / 2;
G[xb] = (G[b] + G[c]) / 2;
G[xc] = (G[c] + G[d]) / 2;
G[xd] = (G[d] + G[a]) / 2;
B[a] = colorBlueBottomLeft;
B[b] = colorBlueBottomRight;
B[c] = colorBlueTopRight;
B[d] = colorBlueTopLeft;
B[e] = (colorBlueBottomLeft + colorBlueTopLeft + colorBlueTopRight + colorBlueBottomRight) / 4;
B[xa] = (B[a] + B[b]) / 2;
B[xb] = (B[b] + B[c]) / 2;
B[xc] = (B[c] + B[d]) / 2;
B[xd] = (B[d] + B[a]) / 2;
}
void side(int a, int b, int c, int d, int iconIndex, boolean flip)
{
IIcon icon = iconIndex >= 16 ? submapSmall.icons[iconIndex - 16] : submap.icons[iconIndex];
double u0 = icon.getMaxU();
double u1 = icon.getMinU();
double v0 = icon.getMaxV();
double v1 = icon.getMinV();
U[a] = flip ? u1 : u1;
U[b] = flip ? u0 : u1;
U[c] = flip ? u0 : u0;
U[d] = flip ? u1 : u0;
V[a] = flip ? v1 : v1;
V[b] = flip ? v1 : v0;
V[c] = flip ? v0 : v0;
V[d] = flip ? v0 : v1;
vert(a);
vert(b);
vert(c);
vert(d);
}
void vert(int index)
{
if(enableAO)
{
tessellator.setColorOpaque_F(R[index], G[index], B[index]);
tessellator.setBrightness(L[index]);
}
tessellator.addVertexWithUV(X[index], Y[index], Z[index], U[index], V[index]);
}
@Override
public void renderFaceXNeg(Block block, double x, double y, double z, IIcon icon)
{
if(rendererOld != null && rendererOld.hasOverrideBlockTexture())
{
IIcon i = rendererOld.overrideBlockTexture;
tessellator.addVertexWithUV(0.0, 1.0, 0.0, i.getMinU(), i.getMinV());
tessellator.addVertexWithUV(0.0, 0.0, 0.0, i.getMinU(), i.getMaxV());
tessellator.addVertexWithUV(0.0, 0.0, 1.0, i.getMaxU(), i.getMaxV());
tessellator.addVertexWithUV(0.0, 1.0, 1.0, i.getMaxU(), i.getMinV());
} else
{
int tex[] = CTM.getSubmapIndices(blockAccess, bx, by, bz, 4);
setupSides(1, 0, 4, 5, 14, 19, 17, 23, 9);
side(1, 14, 9, 23, tex[0], false);
side(23, 9, 17, 5, tex[1], false);
side(9, 19, 4, 17, tex[3], false);
side(14, 0, 19, 9, tex[2], false);
}
}
@Override
public void renderFaceXPos(Block block, double x, double y, double z, IIcon icon)
{
if(rendererOld != null && rendererOld.hasOverrideBlockTexture())
{
IIcon i = rendererOld.overrideBlockTexture;
tessellator.addVertexWithUV(1.0, 1.0, 1.0, i.getMaxU(), i.getMinV());
tessellator.addVertexWithUV(1.0, 0.0, 1.0, i.getMaxU(), i.getMaxV());
tessellator.addVertexWithUV(1.0, 0.0, 0.0, i.getMinU(), i.getMaxV());
tessellator.addVertexWithUV(1.0, 1.0, 0.0, i.getMinU(), i.getMinV());
} else
{
int tex[] = CTM.getSubmapIndices(blockAccess, bx, by, bz, 5);
setupSides(3, 2, 6, 7, 15, 25, 16, 21, 11);
side(11, 21, 3, 15, tex[3], false);
side(16, 7, 21, 11, tex[2], false);
side(25, 11, 15, 2, tex[1], false);
side(6, 16, 11, 25, tex[0], false);
}
}
@Override
public void renderFaceZNeg(Block block, double x, double y, double z, IIcon icon)
{
if(rendererOld != null && rendererOld.hasOverrideBlockTexture())
{
IIcon i = rendererOld.overrideBlockTexture;
tessellator.addVertexWithUV(1.0, 1.0, 0.0, i.getMaxU(), i.getMinV());
tessellator.addVertexWithUV(1.0, 0.0, 0.0, i.getMaxU(), i.getMaxV());
tessellator.addVertexWithUV(0.0, 0.0, 0.0, i.getMinU(), i.getMaxV());
tessellator.addVertexWithUV(0.0, 1.0, 0.0, i.getMinU(), i.getMinV());
} else
{
int tex[] = CTM.getSubmapIndices(blockAccess, bx, by, bz, 2);
setupSides(2, 3, 0, 1, 15, 18, 14, 22, 8);
side(2, 15, 8, 22, tex[0], false);
side(15, 3, 18, 8, tex[2], false);
side(8, 18, 0, 14, tex[3], false);
side(22, 8, 14, 1, tex[1], false);
}
}
@Override
public void renderFaceZPos(Block block, double x, double y, double z, IIcon icon)
{
if(rendererOld != null && rendererOld.hasOverrideBlockTexture())
{
IIcon i = rendererOld.overrideBlockTexture;
tessellator.addVertexWithUV(0.0, 1.0, 1.0, i.getMinU(), i.getMinV());
tessellator.addVertexWithUV(0.0, 0.0, 1.0, i.getMinU(), i.getMaxV());
tessellator.addVertexWithUV(1.0, 0.0, 1.0, i.getMaxU(), i.getMaxV());
tessellator.addVertexWithUV(1.0, 1.0, 1.0, i.getMaxU(), i.getMinV());
} else
{
int tex[] = CTM.getSubmapIndices(blockAccess, bx, by, bz, 3);
setupSides(4, 7, 6, 5, 20, 16, 24, 17, 10);
side(17, 4, 20, 10, tex[2], false);
side(5, 17, 10, 24, tex[0], false);
side(24, 10, 16, 6, tex[1], false);
side(10, 20, 7, 16, tex[3], false);
}
}
@Override
public void renderFaceYNeg(Block block, double x, double y, double z, IIcon icon)
{
if(rendererOld != null && rendererOld.hasOverrideBlockTexture())
{
IIcon i = rendererOld.overrideBlockTexture;
tessellator.addVertexWithUV(0.0, 0.0, 1.0, i.getMinU(), i.getMaxV());
tessellator.addVertexWithUV(0.0, 0.0, 0.0, i.getMinU(), i.getMinV());
tessellator.addVertexWithUV(1.0, 0.0, 0.0, i.getMaxU(), i.getMinV());
tessellator.addVertexWithUV(1.0, 0.0, 1.0, i.getMaxU(), i.getMaxV());
} else
{
int tex[] = CTM.getSubmapIndices(blockAccess, bx, by, bz, 0);
setupSides(0, 3, 7, 4, 18, 21, 20, 19, 13);
side(13, 21, 7, 20, tex[3], true);
side(19, 13, 20, 4, tex[2], true);
side(0, 18, 13, 19, tex[0], true);
side(18, 3, 21, 13, tex[1], true);
}
}
@Override
public void renderFaceYPos(Block block, double x, double y, double z, IIcon icon)
{
if(rendererOld != null && rendererOld.hasOverrideBlockTexture())
{
IIcon i = rendererOld.overrideBlockTexture;
tessellator.addVertexWithUV(0.0, 1.0, 0.0, i.getMinU(), i.getMinV());
tessellator.addVertexWithUV(0.0, 1.0, 1.0, i.getMinU(), i.getMaxV());
tessellator.addVertexWithUV(1.0, 1.0, 1.0, i.getMaxU(), i.getMaxV());
tessellator.addVertexWithUV(1.0, 1.0, 0.0, i.getMaxU(), i.getMinV());
} else
{
int tex[] = CTM.getSubmapIndices(blockAccess, bx, by, bz, 1);
setupSides(2, 1, 5, 6, 22, 23, 24, 25, 12);
side(12, 24, 6, 25, tex[3], false);
side(22, 12, 25, 2, tex[1], false);
side(1, 23, 12, 22, tex[0], false);
side(23, 5, 24, 12, tex[2], false);
}
}
void resetVertices()
{
X[0] = 0;
Z[0] = 0;
Y[0] = 0;
X[1] = 0;
Z[1] = 0;
Y[1] = 1;
X[2] = 1;
Z[2] = 0;
Y[2] = 1;
X[3] = 1;
Z[3] = 0;
Y[3] = 0;
X[4] = 0;
Z[4] = 1;
Y[4] = 0;
X[5] = 0;
Z[5] = 1;
Y[5] = 1;
X[6] = 1;
Z[6] = 1;
Y[6] = 1;
X[7] = 1;
Z[7] = 1;
Y[7] = 0;
X[8] = 0.5;
Z[8] = 0;
Y[8] = 0.5;
X[9] = 0;
Z[9] = 0.5;
Y[9] = 0.5;
X[10] = 0.5;
Z[10] = 1;
Y[10] = 0.5;
X[11] = 1;
Z[11] = 0.5;
Y[11] = 0.5;
X[12] = 0.5;
Z[12] = 0.5;
Y[12] = 1;
X[13] = 0.5;
Z[13] = 0.5;
Y[13] = 0;
X[14] = 0;
Z[14] = 0;
Y[14] = 0.5;
X[15] = 1;
Z[15] = 0;
Y[15] = 0.5;
X[16] = 1;
Z[16] = 1;
Y[16] = 0.5;
X[17] = 0;
Z[17] = 1;
Y[17] = 0.5;
X[18] = 0.5;
Z[18] = 0;
Y[18] = 0;
X[19] = 0;
Z[19] = 0.5;
Y[19] = 0;
X[20] = 0.5;
Z[20] = 1;
Y[20] = 0;
X[21] = 1;
Z[21] = 0.5;
Y[21] = 0;
X[22] = 0.5;
Z[22] = 0;
Y[22] = 1;
X[23] = 0;
Z[23] = 0.5;
Y[23] = 1;
X[24] = 0.5;
Z[24] = 1;
Y[24] = 1;
X[25] = 1;
Z[25] = 0.5;
Y[25] = 1;
}
}
@@ -0,0 +1,49 @@
package com.cricketcraft.chisel.client.render;
import net.minecraft.block.Block;
import net.minecraft.util.IIcon;
public class RenderBlocksCTMCarpet extends RenderBlocksCTM
{
RenderBlocksCTMCarpet()
{
super();
}
@Override
void resetVertices()
{
super.resetVertices();
for(int i = 0; i < Y.length; i++)
{
Y[i] /= 16;
}
}
@Override
public void renderFaceXNeg(Block block, double x, double y, double z, IIcon icon)
{
rendererOld.renderFaceXNeg(block, 0, 0, 0, submapSmall.icon);
}
@Override
public void renderFaceXPos(Block block, double x, double y, double z, IIcon icon)
{
rendererOld.renderFaceXPos(block, 0, 0, 0, submapSmall.icon);
}
@Override
public void renderFaceZNeg(Block block, double x, double y, double z, IIcon icon)
{
rendererOld.renderFaceZNeg(block, 0, 0, 0, submapSmall.icon);
}
@Override
public void renderFaceZPos(Block block, double x, double y, double z, IIcon icon)
{
rendererOld.renderFaceZPos(block, 0, 0, 0, submapSmall.icon);
}
}
@@ -0,0 +1,163 @@
package com.cricketcraft.chisel.client.render;
import net.minecraft.block.Block;
import net.minecraft.client.renderer.RenderBlocks;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
public class RenderBlocksColumn extends RenderBlocks
{
TextureSubmap submap;
IIcon iconTop;
IIcon sides[] = new IIcon[6];
RenderBlocksColumn()
{
super();
}
boolean connected(IBlockAccess world, int x, int y, int z, Block block, int meta)
{
return world.getBlock(x, y, z).equals(block) && world.getBlockMetadata(x, y, z) == meta;
}
@Override
public boolean renderStandardBlock(Block block, int x, int y, int z)
{
int metadata = blockAccess.getBlockMetadata(x, y, z);
boolean yp = connected(blockAccess, x, y + 1, z, block, metadata);
boolean yn = connected(blockAccess, x, y - 1, z, block, metadata);
if(yp || yn)
{
sides[0] = iconTop;
sides[1] = iconTop;
if(yp && yn)
sides[2] = submap.icons[2];
else if(yp)
sides[2] = submap.icons[3];
else
sides[2] = submap.icons[1];
sides[3] = sides[4] = sides[5] = sides[2];
} else
{
boolean xp = connected(blockAccess, x + 1, y, z, block, metadata);
boolean xn = connected(blockAccess, x - 1, y, z, block, metadata);
if(xp && (connected(blockAccess, x + 1, y + 1, z, block, metadata) || connected(blockAccess, x + 1, y - 1, z, block, metadata)))
xp = false;
if(xn && (connected(blockAccess, x - 1, y + 1, z, block, metadata) || connected(blockAccess, x - 1, y - 1, z, block, metadata)))
xn = false;
if(xp || xn)
{
uvRotateEast = 2;
uvRotateWest = 1;
uvRotateTop = 1;
uvRotateBottom = 1;
sides[4] = iconTop;
sides[5] = iconTop;
if(xp && xn)
sides[0] = submap.icons[2];
else if(xp)
sides[0] = submap.icons[3];
else
sides[0] = submap.icons[1];
sides[1] = sides[2] = sides[3] = sides[0];
} else
{
boolean zp = connected(blockAccess, x, y, z + 1, block, metadata);
boolean zn = connected(blockAccess, x, y, z - 1, block, metadata);
if(zp && (connected(blockAccess, x, y + 1, z + 1, block, metadata) || connected(blockAccess, x, y - 1, z + 1, block, metadata)))
zp = false;
if(zp && (connected(blockAccess, x + 1, y, z + 1, block, metadata) || connected(blockAccess, x - 1, y, z + 1, block, metadata)))
zp = false;
if(zn && (connected(blockAccess, x, y + 1, z - 1, block, metadata) || connected(blockAccess, x, y - 1, z - 1, block, metadata)))
zn = false;
if(zn && (connected(blockAccess, x + 1, y, z - 1, block, metadata) || connected(blockAccess, x - 1, y, z - 1, block, metadata)))
zn = false;
if(zp || zn)
{
uvRotateSouth = 1;
uvRotateNorth = 2;
sides[2] = iconTop;
sides[3] = iconTop;
if(zp && zn)
sides[0] = submap.icons[2];
else if(zp)
sides[0] = submap.icons[1];
else
sides[0] = submap.icons[3];
sides[1] = sides[4] = sides[5] = sides[0];
} else
{
sides[0] = sides[1] = iconTop;
sides[2] = sides[3] = sides[4] = sides[5] = submap.icons[0];
}
}
}
boolean flag = super.renderStandardBlock(block, x, y, z);
uvRotateSouth = 0;
uvRotateEast = 0;
uvRotateWest = 0;
uvRotateNorth = 0;
uvRotateTop = 0;
uvRotateBottom = 0;
return flag;
}
@Override
public void renderFaceXNeg(Block block, double x, double y, double z, IIcon icon)
{
super.renderFaceXNeg(block, x, y, z, sides[4]);
}
@Override
public void renderFaceXPos(Block block, double x, double y, double z, IIcon icon)
{
super.renderFaceXPos(block, x, y, z, sides[5]);
}
@Override
public void renderFaceZNeg(Block block, double x, double y, double z, IIcon icon)
{
super.renderFaceZNeg(block, x, y, z, sides[2]);
}
@Override
public void renderFaceZPos(Block block, double x, double y, double z, IIcon icon)
{
super.renderFaceZPos(block, x, y, z, sides[3]);
}
@Override
public void renderFaceYNeg(Block block, double x, double y, double z, IIcon icon)
{
super.renderFaceYNeg(block, x, y, z, sides[0]);
}
@Override
public void renderFaceYPos(Block block, double x, double y, double z, IIcon icon)
{
super.renderFaceYPos(block, x, y, z, sides[1]);
}
}
@@ -0,0 +1,328 @@
package com.cricketcraft.chisel.client.render;
import net.minecraft.block.Block;
import net.minecraft.client.renderer.RenderBlocks;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.util.IIcon;
public class RenderBlocksEldritch extends RenderBlocks
{
RenderBlocksEldritch()
{
super();
}
static double displacementMap[] = {
+0.1165, -0.0352, -0.1208, +0.0906, -0.0295, +0.0302, -0.0973, +0.0548,
-0.1077, +0.0662, -0.0932, -0.0925, -0.1161, +0.0073, -0.1084, +0.1136,
+0.0307, +0.0316, -0.1066, -0.0237, +0.0614, -0.0864, +0.0837, +0.1218,
+0.0502, -0.0529, -0.0942, +0.1209, -0.0418, +0.1035, +0.0066, -0.0255,
+0.0830, -0.0361, +0.0965, +0.0646, +0.1124, +0.0890, -0.0037, +0.0467,
+0.1025, +0.1161, +0.0014, +0.0365, +0.0755, -0.0025, +0.0739, +0.0656,
+0.0571, -0.0813, -0.0062, -0.0904, -0.0005, +0.0612, -0.0227, +0.0138,
-0.0899, -0.0019, -0.1047, +0.1191, -0.1197, -0.1123, +0.0999, +0.0638,
+0.0865, +0.0029, -0.0084, +0.1132, -0.0433, +0.0115, +0.0850, +0.0439,
+0.0748, +0.0460, -0.0441, +0.0839, +0.0162, -0.0229, +0.0774, -0.0647,
-0.0636, -0.0709, -0.0719, -0.0194, +0.1070, -0.0466, -0.1200, -0.0996,
-0.0298, -0.1035, -0.0006, +0.0530, -0.0939, -0.1210, +0.0176, +0.0924,
+0.0343, -0.0777, +0.1050, -0.0729, -0.0062, -0.1107, -0.0434, -0.0042,
+0.0232, +0.0269, +0.0709, -0.0388, +0.0342, +0.0240, -0.0192, +0.0491,
+0.0017, -0.1240, +0.0687, -0.1160, +0.1123, -0.0332, -0.0260, +0.0476,
-0.0049, -0.0893, -0.0243, -0.0371, -0.0230, +0.0656, +0.1080, +0.0781,
-0.0648, +0.0082, -0.1086, -0.0451, -0.0594, -0.1155, -0.0623, -0.0152,
+0.0131, -0.0754, +0.0607, +0.0876, -0.0657, +0.0366, -0.0981, +0.1164,
-0.0623, +0.0181, -0.0475, +0.0722, -0.0293, +0.0486, -0.0195, +0.1041,
+0.1011, +0.0042, -0.0045, -0.1031, +0.0110, +0.0058, +0.0083, -0.0782,
-0.1003, -0.0082, -0.0304, -0.0971, -0.0097, -0.0208, -0.1059, -0.0239,
-0.0385, +0.0505, +0.0537, -0.1098, -0.0022, -0.0165, -0.0027, -0.0208,
+0.0305, +0.0592, +0.0301, +0.0055, +0.1138, -0.0338, -0.0901, +0.1015,
+0.0061, +0.0861, -0.1057, -0.0889, -0.0972, +0.0783, -0.1052, -0.0932,
-0.1103, +0.0497, +0.1222, -0.0146, +0.0632, -0.0240, -0.0193, +0.0676,
-0.1128, -0.0886, +0.0926, +0.0538, -0.0175, -0.0966, -0.0369, +0.1124,
-0.0820, -0.1013, -0.0836, -0.0981, -0.0502, +0.0573, +0.0616, -0.0458,
+0.0294, +0.0108, -0.0782, +0.0692, +0.0234, -0.0178, -0.0171, -0.0505,
-0.0313, +0.0538, +0.0462, -0.0758, +0.0556, -0.0023, -0.1086, -0.0100,
-0.0897, -0.0409, -0.1161, +0.0212, +0.1229, -0.0945, +0.0341, +0.1238,
+0.0893, -0.1189, -0.1098, -0.0125, +0.1137, -0.0202, +0.0239, -0.0408,
+0.0920, +0.0777, -0.0085, -0.0572, -0.0293, -0.0131, +0.0272, +0.0991,
};
static int dmap1 = displacementMap.length * 1 / 6;
static int dmap2 = displacementMap.length * 2 / 6;
static int dmap3 = displacementMap.length * 3 / 6;
static int dmap4 = displacementMap.length * 4 / 6;
static int dmap5 = displacementMap.length * 5 / 6;
static int dmap = displacementMap.length;
Tessellator tessellator;
double[] X = new double[14];
double[] Y = new double[14];
double[] Z = new double[14];
double[] U = new double[14];
double[] V = new double[14];
int[] L = new int[14];
float[] R = new float[14];
float[] G = new float[14];
float[] B = new float[14];
@Override
public boolean renderStandardBlock(Block block, int x, int y, int z)
{
int index = x + y * 34573 + z * 32465781;
if(index < 0) index = -index;
X[0] = x;
Z[0] = z;
Y[0] = y;
X[1] = x;
Z[1] = z;
Y[1] = y + 1;
X[2] = x + 1;
Z[2] = z;
Y[2] = y + 1;
X[3] = x + 1;
Z[3] = z;
Y[3] = y;
X[4] = x;
Z[4] = z + 1;
Y[4] = y;
X[5] = x;
Z[5] = z + 1;
Y[5] = y + 1;
X[6] = x + 1;
Z[6] = z + 1;
Y[6] = y + 1;
X[7] = x + 1;
Z[7] = z + 1;
Y[7] = y;
X[8] = x + 0.5 + displacementMap[(index + 0) % dmap];
Z[8] = z - displacementMap[(index + 10) % dmap];
Y[8] = y + 0.5 + displacementMap[(index + 20) % dmap];
X[9] = x - displacementMap[(index + 0 + dmap1) % dmap];
Z[9] = z + 0.5 + displacementMap[(index + 10 + dmap1) % dmap];
Y[9] = y + 0.5 + displacementMap[(index + 20 + dmap1) % dmap];
X[10] = x + 0.5 + displacementMap[(index + 0 + dmap2) % dmap];
Z[10] = z + 1 + displacementMap[(index + 10 + dmap2) % dmap];
Y[10] = y + 0.5 + displacementMap[(index + 20 + dmap2) % dmap];
X[11] = x + 1 + displacementMap[(index + 0 + dmap3) % dmap];
Z[11] = z + 0.5 + displacementMap[(index + 10 + dmap3) % dmap];
Y[11] = y + 0.5 + displacementMap[(index + 20 + dmap3) % dmap];
X[12] = x + 0.5 + displacementMap[(index + 0 + dmap4) % dmap];
Z[12] = z + 0.5 + displacementMap[(index + 10 + dmap4) % dmap];
Y[12] = y + 1;//+displacementMap[(index+20+dmap4)%dmap];
X[13] = x + 0.5 + displacementMap[(index + 0 + dmap5) % dmap];
Z[13] = z + 0.5 + displacementMap[(index + 10 + dmap5) % dmap];
Y[13] = y + 0;//+displacementMap[(index+20+dmap5)%dmap];
tessellator = Tessellator.instance;
tessellator.setColorOpaque_F(1.0F, 1.0F, 1.0F);
return super.renderStandardBlock(block, x, y, z);
}
void setupSides(IIcon icon, int a, int b, int c, int d, int e, int ta, int tb, int tc, int td)
{
L[a] = brightnessBottomLeft;
L[b] = brightnessBottomRight;
L[c] = brightnessTopRight;
L[d] = brightnessTopLeft;
L[e] = (brightnessBottomLeft + brightnessTopLeft + brightnessTopRight + brightnessBottomRight) / 4;
R[a] = colorRedBottomLeft;
R[b] = colorRedBottomRight;
R[c] = colorRedTopRight;
R[d] = colorRedTopLeft;
R[e] = (colorRedBottomLeft + colorRedTopLeft + colorRedTopRight + colorRedBottomRight) / 4;
G[a] = colorGreenBottomLeft;
G[b] = colorGreenBottomRight;
G[c] = colorGreenTopRight;
G[d] = colorGreenTopLeft;
G[e] = (colorGreenBottomLeft + colorGreenTopLeft + colorGreenTopRight + colorGreenBottomRight) / 4;
B[a] = colorBlueBottomLeft;
B[b] = colorBlueBottomRight;
B[c] = colorBlueTopRight;
B[d] = colorBlueTopLeft;
B[e] = (colorBlueBottomLeft + colorBlueTopLeft + colorBlueTopRight + colorBlueBottomRight) / 4;
double u0 = icon.getMaxU();
double u1 = icon.getMinU();
double v0 = icon.getMaxV();
double v1 = icon.getMinV();
U[ta] = u0;
U[tb] = u0;
U[tc] = u1;
U[td] = u1;
U[e] = icon.getInterpolatedU(8.0D);
V[ta] = v0;
V[tb] = v1;
V[tc] = v1;
V[td] = v0;
V[e] = icon.getInterpolatedV(8.0D);
}
void vert(int index)
{
if(enableAO)
{
tessellator.setColorOpaque_F(R[index], G[index], B[index]);
tessellator.setBrightness(L[index]);
}
tessellator.addVertexWithUV(X[index], Y[index], Z[index], U[index], V[index]);
}
@Override
public void renderFaceXNeg(Block block, double x, double y, double z, IIcon icon)
{
setupSides(icon, 1, 0, 4, 5, 9, 4, 5, 1, 0);
vert(1);
vert(0);
vert(9);
vert(9);
vert(0);
vert(4);
vert(9);
vert(9);
vert(4);
vert(5);
vert(9);
vert(9);
vert(5);
vert(1);
vert(9);
vert(9);
}
@Override
public void renderFaceXPos(Block block, double x, double y, double z, IIcon icon)
{
setupSides(icon, 3, 2, 6, 7, 11, 3, 2, 6, 7);
vert(6);
vert(7);
vert(11);
vert(11);
vert(7);
vert(3);
vert(11);
vert(11);
vert(3);
vert(2);
vert(11);
vert(11);
vert(2);
vert(6);
vert(11);
vert(11);
}
@Override
public void renderFaceZNeg(Block block, double x, double y, double z, IIcon icon)
{
setupSides(icon, 2, 3, 0, 1, 8, 0, 1, 2, 3);
vert(0);
vert(1);
vert(8);
vert(8);
vert(1);
vert(2);
vert(8);
vert(8);
vert(2);
vert(3);
vert(8);
vert(8);
vert(3);
vert(0);
vert(8);
vert(8);
}
@Override
public void renderFaceZPos(Block block, double x, double y, double z, IIcon icon)
{
setupSides(icon, 4, 7, 6, 5, 10, 7, 6, 5, 4);
vert(5);
vert(4);
vert(10);
vert(10);
vert(6);
vert(5);
vert(10);
vert(10);
vert(7);
vert(6);
vert(10);
vert(10);
vert(4);
vert(7);
vert(10);
vert(10);
}
@Override
public void renderFaceYNeg(Block block, double x, double y, double z, IIcon icon)
{
setupSides(icon, 0, 3, 7, 4, 13, 0, 3, 7, 4);
vert(0);
vert(3);
vert(13);
vert(13);
vert(3);
vert(7);
vert(13);
vert(13);
vert(7);
vert(4);
vert(13);
vert(13);
vert(4);
vert(0);
vert(13);
vert(13);
}
@Override
public void renderFaceYPos(Block block, double x, double y, double z, IIcon icon)
{
setupSides(icon, 2, 1, 5, 6, 12, 2, 1, 5, 6);
vert(2);
vert(1);
vert(12);
vert(12);
vert(1);
vert(5);
vert(12);
vert(12);
vert(5);
vert(6);
vert(12);
vert(12);
vert(6);
vert(2);
vert(12);
vert(12);
}
}
@@ -0,0 +1,37 @@
package com.cricketcraft.chisel.client.render;
import net.minecraft.util.IIcon;
import net.minecraftforge.client.event.TextureStitchEvent;
import net.minecraftforge.common.MinecraftForge;
import cpw.mods.fml.common.eventhandler.SubscribeEvent;
public class TextureSubmap
{
public int width, height;
public IIcon icon;
public IIcon icons[];
public TextureSubmap(IIcon i, int w, int h)
{
icon = i;
width = w;
height = h;
icons = new IIcon[width * height];
MinecraftForge.EVENT_BUS.register(this);
}
@SubscribeEvent
public void TexturesStitched(TextureStitchEvent.Post event)
{
for(int x = 0; x < width; x++)
{
for(int y = 0; y < height; y++)
{
icons[y * width + x] = new TextureVirtual(icon, width, height, x, y);
}
}
}
}
@@ -0,0 +1,92 @@
package com.cricketcraft.chisel.client.render;
import net.minecraft.util.IIcon;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
public class TextureVirtual implements IIcon
{
int ox, oy;
float u0, u1, v0, v1;
String name;
IIcon icon;
TextureVirtual(IIcon parent, int w, int h, int x, int y)
{
icon = parent;
u0 = icon.getInterpolatedU(16.0 * (x) / w);
u1 = icon.getInterpolatedU(16.0 * (x + 1) / w);
v0 = icon.getInterpolatedV(16.0 * (y) / h);
v1 = icon.getInterpolatedV(16.0 * (y + 1) / h);
name = icon.getIconName() + "|" + x + "." + y;
ox = icon.getIconWidth();
oy = icon.getIconHeight();
}
@Override
@SideOnly(Side.CLIENT)
public float getMinU()
{
return u0;
}
@Override
@SideOnly(Side.CLIENT)
public float getMaxU()
{
return u1;
}
@Override
@SideOnly(Side.CLIENT)
public float getInterpolatedU(double d0)
{
return (float) (u0 + (u1 - u0) * d0 / 16.0);
}
@Override
@SideOnly(Side.CLIENT)
public float getMinV()
{
return v0;
}
@Override
@SideOnly(Side.CLIENT)
public float getMaxV()
{
return v1;
}
@Override
@SideOnly(Side.CLIENT)
public float getInterpolatedV(double d0)
{
return (float) (v0 + (v1 - v0) * d0 / 16.0);
}
@Override
@SideOnly(Side.CLIENT)
public String getIconName()
{
return name;
}
@Override
@SideOnly(Side.CLIENT)
public int getIconWidth()
{
return ox;
}
@Override
@SideOnly(Side.CLIENT)
public int getIconHeight()
{
return oy;
}
}
@@ -0,0 +1,83 @@
package com.cricketcraft.chisel.client.render.item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.ResourceLocation;
import net.minecraftforge.client.IItemRenderer;
import org.lwjgl.opengl.GL11;
import com.cricketcraft.chisel.client.model.ModelAutoChisel;
import cpw.mods.fml.client.FMLClientHandler;
public class ItemAutoChiselRenderer implements IItemRenderer{
private final ModelAutoChisel model = new ModelAutoChisel();
private ResourceLocation texture;
@Override
public boolean handleRenderType(ItemStack item, ItemRenderType type) {
return type != ItemRenderType.FIRST_PERSON_MAP;
}
@Override
public boolean shouldUseRenderHelper(ItemRenderType type, ItemStack item, ItemRendererHelper helper) {
return true;
}
@Override
public void renderItem(ItemRenderType type, ItemStack item, Object... data) {
switch (item.getItemDamage()){
case 0:
texture = new ResourceLocation("chisel:textures/blocks/autoChisel/autoChisel.png");
break;
case 1:
texture = new ResourceLocation("chisel:textures/blocks/autoChisel/autoChisel_speed.png");
break;
case 2:
texture = new ResourceLocation("chisel:textures/blocks/autoChisel/autoChisel_automation.png");
break;
case 3:
texture = new ResourceLocation("chisel:textures/blocks/autoChisel/autoChisel_stack.png");
break;
default:
texture = new ResourceLocation("chisel:textures/blocks/autoChisel/autoChisel.png");
break;
}
FMLClientHandler.instance().getClient().renderEngine.bindTexture(texture);
switch (type){
case ENTITY:
renderBlock(0.0F, 1.0F, 0.0F);
break;
case EQUIPPED:
renderBlock(0.5F, 1.5F, 0.5F);
break;
case EQUIPPED_FIRST_PERSON:
renderBlock(0.5F, 1.0F, 0.5F);
break;
case INVENTORY:
renderInventory(0.0F, 0.625F, 0.0F);
break;
default:
break;
}
}
private void renderBlock(float x, float y, float z){
GL11.glPushMatrix();
GL11.glTranslatef(x, y, z);
GL11.glScaled(-1, -1, 1);
model.renderAll();
GL11.glPopMatrix();
}
private void renderInventory(float x, float y, float z){
GL11.glPushMatrix();
GL11.glTranslatef(x, y, z);
GL11.glRotatef(180F, 1F, 0, 0);
GL11.glRotatef(-90F, 0, 1F, 0);
GL11.glScalef(0.8F, 0.8F, 0.8F);
model.renderAll();
GL11.glPopMatrix();
}
}
@@ -0,0 +1,50 @@
package com.cricketcraft.chisel.client.render.item;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.RenderBlocks;
import net.minecraft.client.renderer.RenderHelper;
import net.minecraft.client.renderer.entity.RenderItem;
import net.minecraft.item.ItemStack;
import net.minecraftforge.client.IItemRenderer;
import org.lwjgl.opengl.GL11;
public class ItemChiselRenderer implements IItemRenderer
{
RenderBlocks renderBlock = new RenderBlocks();
RenderItem renderItem = new RenderItem();
@Override
public boolean handleRenderType(ItemStack item, ItemRenderType type)
{
return type == IItemRenderer.ItemRenderType.INVENTORY;
}
@Override
public boolean shouldUseRenderHelper(ItemRenderType type, ItemStack item, ItemRendererHelper helper)
{
return false;
}
@Override
public void renderItem(ItemRenderType type, ItemStack stack, Object... data)
{
RenderHelper.enableGUIStandardItemLighting();
renderItem.renderItemIntoGUI(Minecraft.getMinecraft().fontRenderer, Minecraft.getMinecraft().renderEngine, stack, 0, 0);
if(stack.stackTagCompound == null) return;
ItemStack chiselTarget = ItemStack.loadItemStackFromNBT(stack.stackTagCompound.getCompoundTag("chiselTarget"));
if(chiselTarget == null) return;
GL11.glPushMatrix();
GL11.glScalef(0.65f, 0.65f, 0.65f);
GL11.glTranslatef(-8f, -8f, 0.0f);
renderItem.renderItemIntoGUI(Minecraft.getMinecraft().fontRenderer, Minecraft.getMinecraft().renderEngine, chiselTarget, 8, 8);
GL11.glPopMatrix();
}
}
@@ -0,0 +1,65 @@
package com.cricketcraft.chisel.client.render.item;
import net.minecraft.client.model.ModelChest;
import net.minecraft.item.ItemStack;
import net.minecraft.util.ResourceLocation;
import net.minecraftforge.client.IItemRenderer;
import org.lwjgl.opengl.GL11;
import com.cricketcraft.chisel.Chisel;
import cpw.mods.fml.client.FMLClientHandler;
public class ItemPresentRenderer implements IItemRenderer {
private final ModelChest model = new ModelChest();
@Override
public boolean handleRenderType(ItemStack item, ItemRenderType type) {
return type != ItemRenderType.FIRST_PERSON_MAP;
}
@Override
public boolean shouldUseRenderHelper(ItemRenderType type, ItemStack item, ItemRendererHelper helper) {
return true;
}
@Override
public void renderItem(ItemRenderType type, ItemStack item, Object... data) {
FMLClientHandler.instance().getClient().renderEngine.bindTexture(new ResourceLocation(Chisel.MOD_ID, "textures/blocks/present/red.png"));
switch (type) {
case ENTITY:
renderBlock(0.0F, 0.0F, 0.0F);
break;
case EQUIPPED:
renderBlock(0.0F, 0.0F, 0.0F);
break;
case EQUIPPED_FIRST_PERSON:
renderBlock(0.0F, 0.0F, 0.0F);
break;
case INVENTORY:
renderInventory(1.0F, 1.0F, 1.0F);
break;
default:
break;
}
}
private void renderBlock(float x, float y, float z) {
GL11.glPushMatrix();
GL11.glTranslatef(x, y, z);
GL11.glScaled(-1, -1, 1);
model.renderAll();
GL11.glPopMatrix();
}
private void renderInventory(float x, float y, float z) {
GL11.glPushMatrix();
GL11.glTranslatef(x, y, z);
GL11.glRotatef(180F, 1F, 0, 0);
GL11.glRotatef(-90F, 0, 1F, 0);
GL11.glScalef(1.0F, 1.0F, 1.0F);
model.renderAll();
GL11.glPopMatrix();
}
}
@@ -0,0 +1,129 @@
package com.cricketcraft.chisel.client.render.tile;
import static org.lwjgl.opengl.GL11.glPopMatrix;
import static org.lwjgl.opengl.GL11.glPushMatrix;
import static org.lwjgl.opengl.GL11.glRotatef;
import static org.lwjgl.opengl.GL11.glScalef;
import static org.lwjgl.opengl.GL11.glTranslatef;
import net.minecraft.client.renderer.entity.RenderItem;
import net.minecraft.client.renderer.entity.RenderManager;
import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
import net.minecraft.entity.item.EntityItem;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.ResourceLocation;
import net.minecraft.world.World;
import org.lwjgl.opengl.GL11;
import com.cricketcraft.chisel.block.tileentity.TileEntityAutoChisel;
import com.cricketcraft.chisel.client.model.ModelAutoChisel;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
public class RenderAutoChisel extends TileEntitySpecialRenderer {
private static EntityItem ghostItem;
private static TileEntityAutoChisel autoChisel;
private final ModelAutoChisel model;
private ResourceLocation texture;
private final RenderItem renderTargetAndChisel, renderBase;
public RenderAutoChisel(){
model = new ModelAutoChisel();
renderTargetAndChisel = new RenderItem(){
@Override
public boolean shouldBob(){
return false;
}
};
renderTargetAndChisel.setRenderManager(RenderManager.instance);
renderBase = new RenderItem(){
@Override
public boolean shouldBob(){
return true;
}
};
renderBase.setRenderManager(RenderManager.instance);
}
@Override
public void renderTileEntityAt(TileEntity tile, double x, double y, double z, float scale) {
switch (tile.getBlockMetadata()){
case 0:
texture = new ResourceLocation("chisel:textures/blocks/autoChisel/autoChisel.png");
break;
case 1:
texture = new ResourceLocation("chisel:textures/blocks/autoChisel/autoChisel_speed.png");
break;
case 2:
texture = new ResourceLocation("chisel:textures/blocks/autoChisel/autoChisel_automation.png");
break;
case 3:
texture = new ResourceLocation("chisel:textures/blocks/autoChisel/autoChisel_stack.png");
break;
default:
texture = new ResourceLocation("chisel:textures/blocks/autoChisel/autoChisel.png");
break;
}
bindTexture(texture);
glPushMatrix();
glTranslatef((float) x + 0.5F, (float) y + 1.5F, (float) z + 0.5F);
glRotatef(180F, 0.0F, 0.0F, 1.0F);
glScalef(0.89F, 1.0F, 0.89F);
this.model.renderAll();
glPopMatrix();
//Render Blocks
autoChisel = (TileEntityAutoChisel) tile;
EntityItem item = autoChisel.getItemForRendering(1);
if(item != null){
GL11.glPushMatrix();
GL11.glTranslated(x + 0.5, y + 0.5, z + 0.5);
GL11.glScaled(3, 3, 3);
renderTargetAndChisel.doRender(item, 0, 0, 0, 0, 0);
GL11.glPopMatrix();
}
EntityItem item2 = autoChisel.getItemForRendering(0);
if(item2 != null){
GL11.glPushMatrix();
GL11.glTranslated(x + 0.5, y + 1.5, z + 0.5);
GL11.glScaled(1, 1, 1);
renderBase.doRender(item2, 0, 0, 0, 0, 0);
GL11.glPopMatrix();
}
/*EntityItem chisel = getGhostItem(autoChisel.getWorldObj(), new ItemStack(ModItems.chisel));
if(chisel != null){
GL11.glPushMatrix();
GL11.glTranslated(x + 1.5, y + 1.5, z + 1.5);
GL11.glScaled(1, 1, 1);
renderTargetAndChisel.doRender(chisel, 0, 0, 0, 0, 0);
GL11.glPopMatrix();
}*/
}
@SideOnly(Side.CLIENT)
public EntityItem getGhostItem(World world, ItemStack itemStack){
if(ghostItem == null){
ghostItem = new EntityItem(world);
ghostItem.hoverStart = 0.0F;
}
if(itemStack == null){
return null;
} else {
ghostItem.setEntityItemStack(itemStack);
return ghostItem;
}
}
}
@@ -0,0 +1,129 @@
package com.cricketcraft.chisel.client.render.tile;
import net.minecraft.block.Block;
import net.minecraft.block.BlockChest;
import net.minecraft.client.model.ModelChest;
import net.minecraft.client.model.ModelLargeChest;
import net.minecraft.client.renderer.tileentity.TileEntityChestRenderer;
import net.minecraft.tileentity.TileEntity;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL12;
import com.cricketcraft.chisel.block.BlockPresent;
import com.cricketcraft.chisel.block.tileentity.TileEntityPresent;
import cpw.mods.fml.common.FMLLog;
public class RenderPresent extends TileEntityChestRenderer {
private ModelChest chest = new ModelChest();
private ModelChest doubleChest = new ModelLargeChest();
//TODO: this will be changed so it actually chescks after I have crate textures :)
//private boolean isChristmas = true;
public RenderPresent() {
}
public void renderTileEntityAt(TileEntityPresent present, double x, double y, double z, float partialTicks) {
int i;
if (!present.hasWorldObj()) {
i = 0;
} else {
Block block = present.getBlockType();
i = present.getBlockMetadata();
if (block instanceof BlockChest && i == 0) {
try {
((BlockChest) block).func_149954_e(present.getWorldObj(), present.xCoord, present.yCoord, present.zCoord);
} catch (ClassCastException e) {
FMLLog.severe("[Chisel 2] Attempted to render a present at %d, %d, %d that was not a present", present.xCoord, present.yCoord, present.zCoord);
}
i = present.getBlockMetadata();
}
present.checkForAdjacentPresents();
}
if (present.adjacentChestZNeg == null && present.adjacentChestXNeg == null) {
BlockPresent blockPresent = (BlockPresent) present.getWorldObj().getBlock(present.xCoord, present.yCoord, present.zCoord);
ModelChest modelchest;
if (present.adjacentChestXPos == null && present.adjacentChestZPos == null) {
modelchest = this.chest;
this.bindTexture(blockPresent.getResourceSingle(1));
} else {
modelchest = this.doubleChest;
this.bindTexture(blockPresent.getResourceDouble(1));
}
GL11.glPushMatrix();
GL11.glEnable(GL12.GL_RESCALE_NORMAL);
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
GL11.glTranslatef((float) x, (float) y + 1.0F, (float) z + 1.0F);
GL11.glScalef(1.0F, -1.0F, -1.0F);
GL11.glTranslatef(0.5F, 0.5F, 0.5F);
short short1 = 0;
if (i == 2) {
short1 = 180;
}
if (i == 3) {
short1 = 0;
}
if (i == 4) {
short1 = 90;
}
if (i == 5) {
short1 = -90;
}
if (i == 2 && present.adjacentChestXPos != null) {
GL11.glTranslatef(1.0F, 0.0F, 0.0F);
}
if (i == 5 && present.adjacentChestZPos != null) {
GL11.glTranslatef(0.0F, 0.0F, -1.0F);
}
GL11.glRotatef((float) short1, 0.0F, 1.0F, 0.0F);
GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
float f1 = present.prevLidAngle + (present.lidAngle - present.prevLidAngle) * partialTicks;
float f2;
if (present.adjacentChestZNeg != null) {
f2 = present.adjacentChestZNeg.prevLidAngle + (present.adjacentChestZNeg.lidAngle - present.adjacentChestZNeg.prevLidAngle) * partialTicks;
if (f2 > f1) {
f1 = f2;
}
}
if (present.adjacentChestXNeg != null) {
f2 = present.adjacentChestXNeg.prevLidAngle + (present.adjacentChestXNeg.lidAngle - present.adjacentChestXNeg.prevLidAngle) * partialTicks;
if (f2 > f1) {
f1 = f2;
}
}
f1 = 1.0F - f1;
f1 = 1.0F - f1 * f1 * f1;
modelchest.chestLid.rotateAngleX = -(f1 * (float) Math.PI / 2.0F);
modelchest.renderAll();
GL11.glDisable(GL12.GL_RESCALE_NORMAL);
GL11.glPopMatrix();
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
}
}
@Override
public void renderTileEntityAt(TileEntity tileEntity, double x, double y, double z, float partialTicks) {
this.renderTileEntityAt((TileEntityPresent) tileEntity, x, y, z, partialTicks);
}
}
@@ -0,0 +1,37 @@
package com.cricketcraft.chisel.compat;
import com.cricketcraft.chisel.carving.Carving;
import cpw.mods.fml.common.Loader;
import cpw.mods.fml.common.event.FMLPostInitializationEvent;
import cpw.mods.fml.common.registry.GameRegistry;
public class Compatibility
{
public static void init(FMLPostInitializationEvent event)
{
new MarbleCompatibility().postInit(event);
addSupport("ProjRed|Exploration", "projectred.exploration.stone", "marble", 0, 99);
addSupport("bluepower", "marble", "marble", 0, 99);
addSupport("PFAAGeologica", "strongStone", "marble", 5, 99);
addSupport("PFAAGeologica", "strongStoneSlab", "marbleSlab", 5, 99);
addSupport("PFAAGeologica", "strongStoneBrickStairs.marble", "marbleStairs", 0, 99);
addSupport("PFAAGeologica", "mediumStone", "limestone", 0, 99);
addSupport("PFAAGeologica", "mediumStoneSlab", "limestoneSlab", 0, 99);
addSupport("PFAAGeologica", "mediumStoneBrickStairs.limestone", "limestoneStairs", 0, 99);
addSupport("PFAAGeologica", "strongStoneBrick", "stoneBrick", 3, 99);
addSupport("PFAAGeologica", "strongCobble", "cobblestone", 3, 99);
}
public static void addSupport(String modname, String blockname, String name, int metadata, int order)
{
if(Loader.isModLoaded(modname) && GameRegistry.findBlock(modname, blockname) != null)
{
Carving.chisel.addVariation(name, GameRegistry.findBlock(modname, blockname), metadata, order);
GameRegistry.findBlock(modname, blockname).setHarvestLevel("chisel", 0, 0);
}
}
}
@@ -0,0 +1,103 @@
package com.cricketcraft.chisel.compat;
import com.cricketcraft.chisel.compat.ModIntegration.IModIntegration;
import com.cricketcraft.chisel.init.ModBlocks;
import net.minecraft.block.Block;
import net.minecraft.item.ItemStack;
import cpw.mods.fml.common.event.FMLInterModComms;
public class FMPIntegration implements IModIntegration{
@Override
public String getModId(){
return "ForgeMicroblock";
}
@Override
public void onInit(){
registerMaterial(ModBlocks.marble);
registerMaterial(ModBlocks.limestone);
registerMaterial(ModBlocks.cobblestone, 1, 15);
registerMaterial(ModBlocks.glass, 1, 15);
registerMaterial(ModBlocks.sandstone, 3, 15);
registerMaterial(ModBlocks.sandSnakestone, 1, 1);
registerMaterial(ModBlocks.sandSnakestone, 13, 13);
registerMaterial(ModBlocks.sandstoneScribbles);
registerMaterial(ModBlocks.concrete, 0, 10);
registerMaterial(ModBlocks.iron, 1, 15);
registerMaterial(ModBlocks.gold, 1, 14);
registerMaterial(ModBlocks.diamond, 1, 12);
registerMaterial(ModBlocks.lightstone, 1, 15); //This is glowstone
registerMaterial(ModBlocks.lapis, 1, 8);
registerMaterial(ModBlocks.emerald, 1, 11);
registerMaterial(ModBlocks.netherBrick, 1, 5);
registerMaterial(ModBlocks.netherrack, 1, 14);
registerMaterial(ModBlocks.cobblestoneMossy, 1, 15);
registerMaterial(ModBlocks.stoneBrick, 4, 15);
registerMaterial(ModBlocks.snakestone, 1, 1);
registerMaterial(ModBlocks.snakestone, 13, 13);
registerMaterial(ModBlocks.dirt, 0, 3);
registerMaterial(ModBlocks.dirt, 6, 7);
registerMaterial(ModBlocks.dirt, 11, 11);
registerMaterial(ModBlocks.ice, 1, 15);
registerMaterial(ModBlocks.icePillar);
for(int x = 0; x < 4; x++){
registerMaterial(ModBlocks.planks[x], 1, 15); // Oak, Spruce, Birch and Jungle
}
//Accacia
registerMaterial(ModBlocks.planks[4], 1, 1);
registerMaterial(ModBlocks.planks[4], 2, 2);
registerMaterial(ModBlocks.planks[4], 6, 6);
registerMaterial(ModBlocks.planks[4], 8, 11);
registerMaterial(ModBlocks.planks[4], 13, 13);
//Dark Oak
registerMaterial(ModBlocks.planks[5], 1, 1);
registerMaterial(ModBlocks.planks[5], 2, 2);
registerMaterial(ModBlocks.planks[5], 6, 6);
registerMaterial(ModBlocks.planks[5], 8, 11);
registerMaterial(ModBlocks.planks[5], 13, 13);
registerMaterial(ModBlocks.obsidian, 1, 15);
registerMaterial(ModBlocks.obsidianSnakestone, 1, 1);
registerMaterial(ModBlocks.obsidianSnakestone, 13, 13);
registerMaterial(ModBlocks.redstone, 1, 15);
registerMaterial(ModBlocks.holystone, 0, 13);
registerMaterial(ModBlocks.carpet);
registerMaterial(ModBlocks.lavastone, 0, 6);
registerMaterial(ModBlocks.fantasy, 0, 1);
registerMaterial(ModBlocks.fantasy, 3, 14);
registerMaterial(ModBlocks.tyrian);
registerMaterial(ModBlocks.temple, 1, 2);
registerMaterial(ModBlocks.temple, 4, 15);
registerMaterial(ModBlocks.templeMossy, 1, 2);
registerMaterial(ModBlocks.templeMossy, 4, 15);
registerMaterial(ModBlocks.factory, 0, 12);
registerMaterial(ModBlocks.factory, 14, 14);
registerMaterial(ModBlocks.stainedGlass[0]); //White
registerMaterial(ModBlocks.stainedGlass[4]); //Yellow
registerMaterial(ModBlocks.stainedGlass[8]); //Light Gray
registerMaterial(ModBlocks.stainedGlass[12]); //Brown
registerMaterial(ModBlocks.woolenClay);
registerMaterial(ModBlocks.laboratory, 2, 3);
registerMaterial(ModBlocks.laboratory, 5, 12);
registerMaterial(ModBlocks.voidstone, 0, 3);
registerMaterial(ModBlocks.voidstone, 12, 15);
registerMaterial(ModBlocks.waterstone);
}
@Override
public void onPostInit(){
}
private void registerMaterial(Block block){
registerMaterial(block, 0, 15);
}
private void registerMaterial(Block block, int minMeta, int maxMeta){
for(int c = minMeta; c <= maxMeta; c++){
FMLInterModComms.sendMessage(getModId(), "microMaterial", new ItemStack(block, 1, c));
}
}
}
@@ -0,0 +1,166 @@
package com.cricketcraft.chisel.compat;
import com.cricketcraft.chisel.carving.Carving;
import net.minecraft.block.Block;
import cpw.mods.fml.common.event.FMLPostInitializationEvent;
public class MarbleCompatibility
{
abstract class ClassCompat
{
Class<?> cl;
public ClassCompat(String name)
{
try
{
if((cl = Class.forName(name)) != null)
action();
} catch(ClassNotFoundException e)
{
//e.printStackTrace();
} catch(IllegalArgumentException e)
{
e.printStackTrace();
} catch(IllegalAccessException e)
{
e.printStackTrace();
} catch(NoSuchFieldException e)
{
e.printStackTrace();
} catch(SecurityException e)
{
e.printStackTrace();
} catch(Exception e)
{
e.printStackTrace();
}
}
abstract void action() throws Exception;
abstract class BlockCompat
{
Block block;
public BlockCompat(String variableName) throws Exception
{
block = (Block) ClassCompat.this.cl.getField(variableName).get(null);
if(block != null)
action();
}
abstract void action() throws Exception;
}
;
}
;
abstract class ClassBlockCompat
{
Block block;
ClassBlockCompat(final String className, final String blockName)
{
new ClassCompat(className)
{
@Override
void action() throws Exception
{
new BlockCompat(blockName)
{
@Override
void action() throws Exception
{
ClassBlockCompat.this.doAction(block);
}
};
}
};
}
void doAction(Block b)
{
block = b;
action();
}
abstract void action();
}
public void postInit(FMLPostInitializationEvent event)
{
new ClassBlockCompat("shukaro.artifice.ArtificeBlocks", "marble")
{
@Override
void action()
{
Carving.chisel.addVariation("marble", block, 0, 99);
block.setHarvestLevel("chisel", 0, 0);
}
};
new ClassBlockCompat("com.bluepowermod.init.BPBlocks", "marble")
{
@Override
void action()
{
Carving.chisel.addVariation("marble", block, 0, 99);
block.setHarvestLevel("chisel", 0, 0);
}
};
new ClassBlockCompat("num.numirp.block.ModBlocks", "blockDecor")
{
@Override
void action()
{
Carving.chisel.addVariation("marble", block, 0, 99);
block.setHarvestLevel("chisel", 0, 0);
}
};
new ClassBlockCompat("mariculture.core.Core", "limestone")
{
@Override
void action()
{
Carving.chisel.addVariation("limestone", block, 0, 99);
block.setHarvestLevel("chisel", 0, 0);
}
};
new ClassBlockCompat("emasher.core.EmasherCore", "limestone")
{
@Override
void action()
{
Carving.chisel.addVariation("limestone", block, 0, 99);
block.setHarvestLevel("chisel", 0, 0);
}
};
new ClassCompat("Reika.GeoStrata.GeoStrata")
{
@Override
void action() throws Exception
{
Block[] blocks = (Block[]) cl.getField("blocks").get(null);
Carving.chisel.addVariation("marble", blocks[0], 2, 99);
blocks[0].setHarvestLevel("chisel", 0, 2);
Carving.chisel.addVariation("limestone", blocks[0], 3, 99);
blocks[0].setHarvestLevel("chisel", 0, 3);
}
};
}
}
@@ -0,0 +1,49 @@
package com.cricketcraft.chisel.compat;
import java.util.ArrayList;
import java.util.List;
import cpw.mods.fml.common.Loader;
public class ModIntegration {
private static List<IModIntegration> integratedMods = new ArrayList<IModIntegration>();
public static void addMod(Class<? extends IModIntegration> cls){
try{
IModIntegration obj = cls.newInstance();
if(Loader.isModLoaded(obj.getModId())){
integratedMods.add(obj);
}
} catch(Throwable throwable){
throwable.printStackTrace();
}
}
public static void init(){
try{
for(IModIntegration integration : integratedMods){
integration.onInit();
}
} catch (Throwable throwable){
throwable.printStackTrace();
}
}
public static void postInit(){
try {
for (IModIntegration integration : integratedMods){
integration.onPostInit();
}
} catch (Throwable throwable){
throwable.printStackTrace();
}
}
static interface IModIntegration{
String getModId();
void onInit();
void onPostInit();
}
}
Loaded 100 of 138 files, more files were not shown because too many files have changed in this diff. Show more