Jump to content
Currently supported: All versions

Awesome_Spider

Forge Modder
 View Profile  See their activity

  • Posts

    892

  • Joined

  • Last visited

  • Days Won

    1

 Content Type 

Posts posted by Awesome_Spider

    [1.11] Block with two properties?

    in Modder Support

    Posted · Edited by Awesome_Spider 

    [09:28:57] [Client thread/ERROR]: Unable to parse metadata from roboticraft:textures/blocks/purifier_front_active.png
java.lang.RuntimeException: invalid frameindex 19
	at net.minecraft.client.renderer.texture.TextureAtlasSprite.loadSpriteFrames(TextureAtlasSprite.java:309) ~[TextureAtlasSprite.class:?]
	at net.minecraft.client.renderer.texture.TextureMap.generateMipmaps(TextureMap.java:247) [TextureMap.class:?]
	at net.minecraft.client.renderer.texture.TextureMap.loadTextureAtlas(TextureMap.java:197) [TextureMap.class:?]
	at net.minecraft.client.renderer.texture.TextureMap.loadSprites(TextureMap.java:94) [TextureMap.class:?]
	at net.minecraftforge.client.model.ModelLoader.setupModelRegistry(ModelLoader.java:155) [ModelLoader.class:?]
	at net.minecraft.client.renderer.block.model.ModelManager.onResourceManagerReload(ModelManager.java:28) [ModelManager.class:?]
	at net.minecraft.client.resources.SimpleReloadableResourceManager.notifyReloadListeners(SimpleReloadableResourceManager.java:132) [SimpleReloadableResourceManager.class:?]
	at net.minecraft.client.resources.SimpleReloadableResourceManager.reloadResources(SimpleReloadableResourceManager.java:113) [SimpleReloadableResourceManager.class:?]
	at net.minecraft.client.Minecraft.refreshResources(Minecraft.java:806) [Minecraft.class:?]
	at net.minecraftforge.fml.client.FMLClientHandler.finishMinecraftLoading(FMLClientHandler.java:347) [FMLClientHandler.class:?]
	at net.minecraft.client.Minecraft.init(Minecraft.java:560) [Minecraft.class:?]
	at net.minecraft.client.Minecraft.run(Minecraft.java:385) [Minecraft.class:?]
	at net.minecraft.client.main.Main.main(Main.java:118) [Main.class:?]
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) ~[?:1.8.0_60]
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) ~[?:1.8.0_60]
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ~[?:1.8.0_60]
	at java.lang.reflect.Method.invoke(Method.java:497) ~[?:1.8.0_60]
	at net.minecraft.launchwrapper.Launch.launch(Launch.java:135) [launchwrapper-1.12.jar:?]
	at net.minecraft.launchwrapper.Launch.main(Launch.java:28) [launchwrapper-1.12.jar:?]
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) ~[?:1.8.0_60]
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) ~[?:1.8.0_60]
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ~[?:1.8.0_60]
	at java.lang.reflect.Method.invoke(Method.java:497) ~[?:1.8.0_60]
	at net.minecraftforge.gradle.GradleStartCommon.launch(GradleStartCommon.java:97) [start/:?]
	at GradleStart.main(GradleStart.java:26) [start/:?]
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) ~[?:1.8.0_60]
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) ~[?:1.8.0_60]
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ~[?:1.8.0_60]
	at java.lang.reflect.Method.invoke(Method.java:497) ~[?:1.8.0_60]
	at com.intellij.rt.execution.application.AppMain.main(AppMain.java:140) [idea_rt.jar:?]

     

    It says frame 19 is invalid, I should have known frame numbers started from 0. That should fix it.

    Blender to minecraft?

    in Modder Support

    Posted

    As far as solving your problem, what Minecraft version are you using? If it's 1.7.10, we don't support that anymore here, if it's 1.8 and up we can help you.

     

    Also, do you want to import a .obj model into Minecraft, or something else?

    [1.11] Block with two properties?

    in Modder Support

    Posted

    It's not working now. The front texture doesn't show. I don't think I changed anything that would make it do that. 

    {
  "forge_marker": 1,
  "defaults": {
    "textures": {
      "front": "#inactive",
      "inactive": "roboticraft:blocks/purifier_front_inactive",
      "active": "roboticraft:blocks/purifier_front_active",
      "top": "roboticraft:blocks/purifier_side",
      "side": "roboticraft:blocks/purifier_side",
      "particle": "roboticraft:blocks/purifier_side"
    }
  },
  "variants": {
    "normal": {
      "model": "orientable"
    },
    "inventory": {
      "model": "orientable"
    },
    "facing": {
      "north": {
        "model": "orientable"
      },
      "south": {
        "model": "orientable",
        "y": 180
      },
      "west": {
        "model": "orientable",
        "y": 270
      },
      "east": {
        "model": "orientable",
        "y": 90
      }
    },
    "active": {
      "true": {
        "textures": {
          "front": "#active"
        }
      },
      "false": {
        "front": "#active"
      }
    }
  }
}

     

    [1.11] Power Capability

    in Modder Support

    Posted

    So I was converting code over, and it's broken. My generator is burning coal but it won't generate energy now that it is converted over to capabilities. Did I do something wrong?

     

    Please excuse any messy code for the moment, I will clean it up later.

    The TileEntity: 

    public class TileEntitySteamEngine extends TileEntity implements ITickable {

    private ItemStackHandler inventory;
    private EnergyStorage energyStorage;
    private FluidStack steamStack;
    private FluidStack waterStack;

    private float steamUsed;

    private String customName;

    private int burnTime;
    private int currentBurnTime;
    private boolean lockBurnTime;

    private int maxEnergy;
    private int energyOutput;

    public TileEntitySteamEngine() {
        inventory = new ItemStackHandler(1);
        energyStorage = new EnergyStorage(100000);

        maxEnergy = 100000;
        energyOutput = 80;

        steamUsed = 200;

        steamStack = new FluidStack(ModFluids.steam, 0);
        waterStack = new FluidStack(FluidRegistry.WATER, 0);
    }

    public IItemHandler getInventory() {
        return inventory;
    }

    public EnergyStorage getEnergyStorage() {
        return energyStorage;
    }

    public int getItemBurnTime(ItemStack stack) {
        int burnTime = 0;
        int registryFuelValue = GameRegistry.getFuelValue(stack);

        if(registryFuelValue > 0) {
            burnTime = registryFuelValue;
        } else {
           burnTime = TileEntityFurnace.getItemBurnTime(stack);
        }

        return burnTime;
    }

    public int getBurnTime() {
        return burnTime;
    }

    public int getCurrentBurnTime() {
        return currentBurnTime;
    }

    public boolean isBurning() {
        return burnTime > 0;
    }

    public boolean canItemBurn(ItemStack stack) {
        return getItemBurnTime(stack) > 0;
    }

    private void setCurrentBurnTime(int itemBurnTime) {
        currentBurnTime = itemBurnTime;
    }

    private void setBurnTime(int burnTime) {
        this.burnTime = burnTime;
    }

    public void attemptAddWater(int amount) {
        int curAmount = waterStack.amount;

        if(curAmount + amount <= 2000) {
            curAmount += amount;

            waterStack.amount = curAmount;

            markDirty();
        } else if(curAmount + amount > 2000) {
            curAmount += amount;

            curAmount -= curAmount - 2000;

            waterStack.amount = curAmount;

            markDirty();
        }
    }

    @Override
    public void update() {
        ItemStack fuelSlot = inventory.getStackInSlot(0);

        boolean dirtyFlag = false;

        if(isBurning() && !lockBurnTime){
            burnTime--;
        }

        if(!world.isRemote) {
            if (!isBurning() && !fuelSlot.isEmpty()) {
                ItemStack stack = fuelSlot;

                currentBurnTime = getItemBurnTime(stack);
                burnTime = currentBurnTime;

                stack.shrink(1);

                inventory.setStackInSlot(0, stack);

                dirtyFlag = true;
            }

            if(isBurning() || !fuelSlot.isEmpty()) {
                if(!isBurning() && canGenerate()) {
                    burnTime = getItemBurnTime(fuelSlot);
                    currentBurnTime = burnTime;

                    if (this.isBurning())
                    {
                        dirtyFlag = true;

                        if (!fuelSlot.isEmpty())
                        {
                            fuelSlot.shrink(1);

                            if (fuelSlot.isEmpty())
                            {
                                inventory.setStackInSlot(0, fuelSlot);
                            }
                        }
                    }
                }

                if (isBurning() && canGenerate())
                {
                    lockBurnTime = false;

                    generate();
                } else if(isBurning() && !canGenerate()) {
                    lockBurnTime = true;
                }
            }
        }

        if(dirtyFlag) {
            markDirty();
        }
    }

    public boolean isSteamFull() {
        return steamStack.amount == 2000;
    }

    public boolean canGenerate() {
        return energyStorage.getEnergyStored() < maxEnergy;//return storedEnergy < maxEnergy;
    }

    private void generate() {
        int steamAmt = steamStack.amount;
        int steamMax = 2000;

        int waterAmt = waterStack.amount;
        int waterMax = 2000;

        if(steamAmt == steamMax) {
            int received = energyStorage.receiveEnergy(energyOutput, true);

            if (received > 0) {
                markDirty();
            }
        }

        //If not full, make steam first
        if(steamAmt + 200 <= steamMax && waterAmt > 0) {
            waterAmt--;

            steamAmt += 200;

            waterStack.amount = waterAmt;
            steamStack.amount = steamAmt;

            markDirty();
        } else if (steamAmt + 200 > steamMax && waterAmt > 0) {
            waterAmt--;

            steamAmt += 200;
            steamAmt -= steamAmt - steamMax;

            waterStack.amount = waterAmt;
            steamStack.amount = steamAmt;

            markDirty();
        }
    }

    public int getField(int id) {
        return id == 0 ? burnTime : id == 1 ? currentBurnTime : id == 2 ? energyStorage.getEnergyStored() : id == 3 ? waterStack.amount : 0;
    }

    public void setField(int id, int value) {
        burnTime = id == 0 ? value : burnTime;
        currentBurnTime = id == 1 ? value : currentBurnTime;
        if(id == 2) {
            energyStorage.extractEnergy(energyStorage.getEnergyStored(), false);
            energyStorage.receiveEnergy(value, false);
        }
        waterStack.amount = id == 3 ? value : waterStack.amount;

        markDirty();
    }

    @Override
    public NBTTagCompound writeToNBT(NBTTagCompound compound) {
        compound.setTag("inventory", inventory.serializeNBT());
        compound.setInteger("storedEnergy", energyStorage.getEnergyStored());
        compound.setInteger("waterAmt", waterStack.amount);
        compound.setInteger("steamAmt", steamStack.amount);
        return super.writeToNBT(compound);
    }

    @Override
    public void readFromNBT(NBTTagCompound compound) {
        inventory.deserializeNBT(compound.getCompoundTag("inventory"));
      
        energyStorage = new EnergyStorage(100000);
        energyStorage.receiveEnergy(compound.getInteger("storedEnergy"), false);

        waterStack = new FluidStack(FluidRegistry.WATER, compound.getInteger("waterAmt"));
        steamStack = new FluidStack(FluidRegistry.getFluid("roboticraft_steam"), compound.getInteger("steamAmt"));
        super.readFromNBT(compound);
    }

    @Override
    public boolean hasCapability(Capability<?> capability, @Nullable EnumFacing facing) {
        return capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY ||
                capability == CapabilityEnergy.ENERGY ||
                        super.hasCapability(capability, facing);
    }

    @Nullable
    @Override
    public <T> T getCapability(Capability<T> capability, @Nullable EnumFacing facing) {
        return capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY ? (T)inventory :
                capability == CapabilityEnergy.ENERGY ? (T)energyStorage :
                        super.getCapability(capability, facing);
    }
}

     

    The Container: 

    public class ContainerTileEntitySteamEngine extends Container {
    private TileEntitySteamEngine te;

    private int burnTime;
    private int currentBurnTime;
    private int storedPower;

    public ContainerTileEntitySteamEngine(IInventory playerInv, TileEntitySteamEngine te) {
        this.te = te;

        // Tile Entity, Slot 1, Slot ID 1
        this.addSlotToContainer(new SlotItemHandler(te.getInventory(), 0, 80, 40));

        // Player Inventory, Slot 9-35, Slot IDs 9-35
        for (int y = 0; y < 3; ++y) {
            for (int x = 0; x < 9; ++x) {
                this.addSlotToContainer(new Slot(playerInv, x + y * 9 + 9, 8 + x * 18, 84 + y * 18));
            }
        }

        // Player Inventory, Slot 0-8, Slot IDs 36-44
        for (int x = 0; x < 9; ++x) {
            this.addSlotToContainer(new Slot(playerInv, x, 8 + x * 18, 142));
        }
    }

    /**
     * Looks for changes made in the container, sends them to every listener.
     */
    public void detectAndSendChanges() {
        super.detectAndSendChanges();

        for(IContainerListener listener : listeners) {
            if (burnTime != te.getField(0)) {
                if (listener instanceof EntityPlayerMP) {
                    ModPacketHandler.INSTANCE.sendTo(new SteamEngineMessage(burnTime, currentBurnTime, storedPower, this.windowId), (EntityPlayerMP) listener);
                }
            }

            if (currentBurnTime != te.getField(1)) {
                if (listener instanceof EntityPlayerMP) {
                    ModPacketHandler.INSTANCE.sendTo(new SteamEngineMessage(burnTime, currentBurnTime, storedPower, this.windowId), (EntityPlayerMP) listener);
                }
            }

            if (storedPower != te.getField(2)) {
                if (listener instanceof EntityPlayerMP) {
                    ModPacketHandler.INSTANCE.sendTo(new SteamEngineMessage(burnTime, currentBurnTime, storedPower, this.windowId), (EntityPlayerMP) listener);
                }
            }
        }

        this.burnTime = this.te.getField(0);
        this.currentBurnTime = this.te.getField(1);
        this.storedPower = this.te.getField(2);
    }

    @SideOnly(Side.CLIENT)
    public void updateProgressBar(int id, int data) {
        if(id == 2) {
            te.getEnergyStorage().extractEnergy(te.getEnergyStorage().getEnergyStored(), true);
            te.getEnergyStorage().receiveEnergy(data, true);
        } else {
            this.te.setField(id, data);
        }
    }

    @Override
    public boolean canInteractWith(EntityPlayer player) {
        return true;
    }
}

     

    The Packet Message: 

    public class SteamEngineMessage implements IMessage {
    // A default constructor is always required
    public SteamEngineMessage() {

    }

    public int burnTime;
    public int currentBurnTime;

    public int storedPower;

    public int id;

    public SteamEngineMessage(int burnTime, int currentBurnTime, int storedPower, int containerID) {
        this.burnTime = burnTime;
        this.currentBurnTime = currentBurnTime;
        this.storedPower = storedPower;
        this.id = containerID;
    }

    @Override
    public void toBytes(ByteBuf buf) {
        // Writes the int into the buf
        buf.writeInt(burnTime);
        buf.writeInt(currentBurnTime);
        buf.writeInt(storedPower);
        buf.writeInt(id);
    }

    @Override
    public void fromBytes(ByteBuf buf) {
        // Reads the int back from the buf. Note that if you have multiple values, you must read in the same order you wrote.
        burnTime = buf.readInt();
        currentBurnTime = buf.readInt();
        storedPower = buf.readInt();
        id = buf.readInt();
    }
}

     

    The packet message handler: 

    public class SteamEngineMessageHandler implements IMessageHandler<SteamEngineMessage, IMessage> {

    @Override
    public IMessage onMessage(SteamEngineMessage message, MessageContext ctx) {
        EntityPlayer player = RobotiCraft.proxy.getPlayerFromContext(ctx);
        Container container = player.openContainer;

        if(container.windowId == message.id) {
            container.updateProgressBar(0, message.burnTime);
            container.updateProgressBar(1, message.currentBurnTime);
            container.updateProgressBar(2, message.storedPower);
        }

        return null;
    }
}

×
×
  • Create New...

Important Information

By using this site, you agree to our Terms of Use.

  I accept