• 0

    posted a message on Redstone Game: Spin To Win
    Quote from baeshra

    Not bad, may I ask what the 5 stands for, or is that supposed to be an S? Also, isn't this just a fancy display for a randomizer? It will still be random whether you win or not.

    Yeah It could be called so, and yes it's an S. Guess I should start thinking up an actual 'Game' :smile.gif:
    Posted in: Redstone Discussion and Mechanisms
  • 0

    posted a message on Piston Slot Machine
    This anal rapes my design props to you sir :iapprove:
    Posted in: Redstone Discussion and Mechanisms
  • 0

    posted a message on Redstone Game: Spin To Win
    here's a video for those of you who don't like to read :dry.gif:
    Posted in: Redstone Discussion and Mechanisms
  • 0

    posted a message on Whack a mole mini game finished
    you forgot
    Step 10. ????
    Step 11. Profit
    Posted in: Redstone Discussion and Mechanisms
  • 1

    posted a message on Redstone Game: Spin To Win
    After a couple of late nights it's ALIVE! ha ha couldn't' resist. here's an overview of the machine.

    The randomization is done by a 1 clock torch burnout system. then the torches randomly turn on at different times. Whichever goes on first will be saves into the memory and the state will not be able to change because when one is activated it forces the other two into a permanent on state. It then goes onto the display.
    Win detection
    This works by grouping the top 3 lines into an AND gate which acts as a bi-conditional by "saying" The win will be detected if and only if all three lines are on.
    Display

    Hope you liked it.
    I'll post the world download if ya'll want. :biggrin.gif:
    Any Suggestions/Feedback is greatly appreciated!
    Posted in: Redstone Discussion and Mechanisms
  • 0

    posted a message on Hands turn Black when playing
    Quote from Apocalex

    noskcaJ leahciM

    haha nice reference
    OT: i've had this too. The chests are new so its probably just a lighting bug.
    Posted in: 1.0 Update Discussion
  • 0

    posted a message on Venus Mod [In-Dev]
    Shouldn't be too hard. I'll try to make it as realistic as possible.
    Posted in: Mods Discussion
  • 0

    posted a message on Venus Mod [In-Dev]
    We'll I was thinking Jupiter, but it's all gas. I'll start the basic coding on Tuesday since I don't have anything after school.
    Posted in: Mods Discussion
  • 0

    posted a message on Venus Mod [In-Dev]
    I'm thinking up a mod that will take our beloved Steve and put him on the uninhabitable planet Venus. Special clothing will be needed and an artificial atmosphere will need to be created because oxygen tanks are in short supply.
    Would anyone dl?

    Progress:
    Basic coding [X]
    Posted in: Mods Discussion
  • 0

    posted a message on What is the single most stupid thing someone's said/done in SMP
    "Whats a redstone?"
    Posted in: Discussion
  • 0

    posted a message on Noteblock timing?
    Title^ say at like 128 BPM?
    Posted in: Redstone Discussion and Mechanisms
  • 0

    posted a message on My item is in game but has no properties?
    Anyone? did i miss something?
    Posted in: Mods Discussion
  • 0

    posted a message on My item is in game but has no properties?
    Then why wont it shoot?
    Posted in: Mods Discussion
  • 0

    posted a message on My item is in game but has no properties?
    I made a gun mod (for personal use). I gave the gun a max stack size of one but when I craft it in game i can stack more than one, and it doesn't shoot (yes i crafted the ammo). Here's my code:
    mod_SxL
    package net.minecraft.src;
    
    import java.util.Map;
    
    public class mod_SxL extends BaseMod
    {
         public static final Item M9 = (new Item(300)).setItemName("M9");
         public static final Item SmallRound = (new Item(301)).setItemName("SmallRound");
         	public mod_SxL()
         	{
         		ModLoader.RegisterEntityID(EntitySmallRound.class,"SmallRound",ModLoader.getUniqueEntityId());
         		M9.iconIndex = ModLoader.addOverride("/gui/items.png", "/SxL/M9.png");
         		SmallRound.iconIndex = ModLoader.addOverride("/gui/items.png", "/SxL/SmallRound.png");
         		ModLoader.AddRecipe(new ItemStack(M9, 1), new Object[] {
         			"X", Character.valueOf('X'), Block.dirt
         		});
         		ModLoader.AddRecipe(new ItemStack(SmallRound, 1), new Object[] {
         			"X", Character.valueOf('X'), mod_SxL.M9
         		});
         	}
    
    public void AddRenderer(Map map) 
       { 
    	map.put(EntitySmallRound.class, new RenderSmallRound());
       }
    public String Version()
          {
          return "1.7.3";
          }
    }
    My ItemM9:
    package net.minecraft.src;
    
    import java.util.Random;
    
    public class ItemM9 extends Item
    {
    
        public ItemM9(int i)
        {
            super(i);
            maxStackSize = 1;
        }
    
        public ItemStack onItemRightClick(ItemStack itemstack, World world, EntityPlayer entityplayer)
        {
            if(entityplayer.inventory.consumeInventoryItem(mod_SxL.SmallRound.shiftedIndex))
            {
                world.playSoundAtEntity(entityplayer, "random.bow", 1.0F, 1.0F / (itemRand.nextFloat() * 0.4F + 0.8F));
                if(!world.multiplayerWorld)
                {
                	world.entityJoinedWorld(new EntitySmallRound(world, entityplayer));
                }
            }
            return itemstack;
        }
    }
    RenderSmallRound
    package net.minecraft.src;
    
    import org.lwjgl.opengl.GL11;
    
    public class RenderSmallRound extends Render
    {
    
        public RenderSmallRound()
        {
        }
    
        public void renderArrow(EntitySmallRound entityarrow, double d, double d1, double d2, 
                float f, float f1)
        {
            if(entityarrow.prevRotationYaw == 0.0F && entityarrow.prevRotationPitch == 0.0F)
            {
                return;
            }
            loadTexture("/item/arrows.png");
            GL11.glPushMatrix();
            GL11.glTranslatef((float)d, (float)d1, (float)d2);
            GL11.glRotatef((entityarrow.prevRotationYaw + (entityarrow.rotationYaw - entityarrow.prevRotationYaw) * f1) - 90F, 0.0F, 1.0F, 0.0F);
            GL11.glRotatef(entityarrow.prevRotationPitch + (entityarrow.rotationPitch - entityarrow.prevRotationPitch) * f1, 0.0F, 0.0F, 1.0F);
            Tessellator tessellator = Tessellator.instance;
            int i = 0;
            float f2 = 0.0F;
            float f3 = 0.5F;
            float f4 = (float)(0 + i * 10) / 32F;
            float f5 = (float)(5 + i * 10) / 32F;
            float f6 = 0.0F;
            float f7 = 0.15625F;
            float f8 = (float)(5 + i * 10) / 32F;
            float f9 = (float)(10 + i * 10) / 32F;
            float f10 = 0.05625F;
            GL11.glEnable(32826 /*GL_RESCALE_NORMAL_EXT*/);
            float f11 = (float)entityarrow.arrowShake - f1;
            if(f11 > 0.0F)
            {
                float f12 = -MathHelper.sin(f11 * 3F) * f11;
                GL11.glRotatef(f12, 0.0F, 0.0F, 1.0F);
            }
            GL11.glRotatef(45F, 1.0F, 0.0F, 0.0F);
            GL11.glScalef(f10, f10, f10);
            GL11.glTranslatef(-4F, 0.0F, 0.0F);
            GL11.glNormal3f(f10, 0.0F, 0.0F);
            tessellator.startDrawingQuads();
            tessellator.addVertexWithUV(-7D, -2D, -2D, f6, f8);
            tessellator.addVertexWithUV(-7D, -2D, 2D, f7, f8);
            tessellator.addVertexWithUV(-7D, 2D, 2D, f7, f9);
            tessellator.addVertexWithUV(-7D, 2D, -2D, f6, f9);
            tessellator.draw();
            GL11.glNormal3f(-f10, 0.0F, 0.0F);
            tessellator.startDrawingQuads();
            tessellator.addVertexWithUV(-7D, 2D, -2D, f6, f8);
            tessellator.addVertexWithUV(-7D, 2D, 2D, f7, f8);
            tessellator.addVertexWithUV(-7D, -2D, 2D, f7, f9);
            tessellator.addVertexWithUV(-7D, -2D, -2D, f6, f9);
            tessellator.draw();
            for(int j = 0; j < 4; j++)
            {
                GL11.glRotatef(90F, 1.0F, 0.0F, 0.0F);
                GL11.glNormal3f(0.0F, 0.0F, f10);
                tessellator.startDrawingQuads();
                tessellator.addVertexWithUV(-8D, -2D, 0.0D, f2, f4);
                tessellator.addVertexWithUV(8D, -2D, 0.0D, f3, f4);
                tessellator.addVertexWithUV(8D, 2D, 0.0D, f3, f5);
                tessellator.addVertexWithUV(-8D, 2D, 0.0D, f2, f5);
                tessellator.draw();
            }
    
            GL11.glDisable(32826 /*GL_RESCALE_NORMAL_EXT*/);
            GL11.glPopMatrix();
        }
    
        public void doRender(Entity entity, double d, double d1, double d2, 
                float f, float f1)
        {
            renderArrow((EntitySmallRound)entity, d, d1, d2, f, f1);
        }
    }
    EntitySmallRound
    package net.minecraft.src;
    
    import java.util.List;
    import java.util.Random;
    
    public class EntitySmallRound extends Entity
    {
    
        public EntitySmallRound(World world)
        {
            super(world);
            xTile = -1;
            yTile = -1;
            zTile = -1;
            inTile = 0;
            field_28019_h = 0;
            inGround = false;
            doesArrowBelongToPlayer = false;
            arrowShake = 0;
            ticksInAir = 0;
            setSize(0.5F, 0.5F);
        }
    
        public EntitySmallRound(World world, double d, double d1, double d2)
        {
            super(world);
            xTile = -1;
            yTile = -1;
            zTile = -1;
            inTile = 0;
            field_28019_h = 0;
            inGround = false;
            doesArrowBelongToPlayer = false;
            arrowShake = 0;
            ticksInAir = 0;
            setSize(0.5F, 0.5F);
            setPosition(d, d1, d2);
            yOffset = 0.0F;
        }
    
        public EntitySmallRound(World world, EntityLiving entityliving)
        {
            super(world);
            xTile = -1;
            yTile = -1;
            zTile = -1;
            inTile = 0;
            field_28019_h = 0;
            inGround = false;
            doesArrowBelongToPlayer = false;
            arrowShake = 0;
            ticksInAir = 0;
            owner = entityliving;
            doesArrowBelongToPlayer = entityliving instanceof EntityPlayer;
            setSize(0.5F, 0.5F);
            setLocationAndAngles(entityliving.posX, entityliving.posY + (double)entityliving.getEyeHeight(), entityliving.posZ, entityliving.rotationYaw, entityliving.rotationPitch);
            posX -= MathHelper.cos((rotationYaw / 180F) * 3.141593F) * 0.16F;
            posY -= 0.10000000149011612D;
            posZ -= MathHelper.sin((rotationYaw / 180F) * 3.141593F) * 0.16F;
            setPosition(posX, posY, posZ);
            yOffset = 0.0F;
            motionX = -MathHelper.sin((rotationYaw / 180F) * 3.141593F) * MathHelper.cos((rotationPitch / 180F) * 3.141593F);
            motionZ = MathHelper.cos((rotationYaw / 180F) * 3.141593F) * MathHelper.cos((rotationPitch / 180F) * 3.141593F);
            motionY = -MathHelper.sin((rotationPitch / 180F) * 3.141593F);
            setArrowHeading(motionX, motionY, motionZ, 1.5F, 1.0F);
        }
    
        protected void entityInit()
        {
        }
    
        public void setArrowHeading(double d, double d1, double d2, float f, 
                float f1)
        {
            float f2 = MathHelper.sqrt_double(d * d + d1 * d1 + d2 * d2);
            d /= f2;
            d1 /= f2;
            d2 /= f2;
            d += rand.nextGaussian() * 0.0074999998323619366D * (double)f1;
            d1 += rand.nextGaussian() * 0.0074999998323619366D * (double)f1;
            d2 += rand.nextGaussian() * 0.0074999998323619366D * (double)f1;
            d *= f;
            d1 *= f;
            d2 *= f;
            motionX = d;
            motionY = d1;
            motionZ = d2;
            float f3 = MathHelper.sqrt_double(d * d + d2 * d2);
            prevRotationYaw = rotationYaw = (float)((Math.atan2(d, d2) * 180D) / 3.1415927410125732D);
            prevRotationPitch = rotationPitch = (float)((Math.atan2(d1, f3) * 180D) / 3.1415927410125732D);
            ticksInGround = 0;
        }
    
        public void setVelocity(double d, double d1, double d2)
        {
            motionX = d;
            motionY = d1;
            motionZ = d2;
            if(prevRotationPitch == 0.0F && prevRotationYaw == 0.0F)
            {
                float f = MathHelper.sqrt_double(d * d + d2 * d2);
                prevRotationYaw = rotationYaw = (float)((Math.atan2(d, d2) * 180D) / 3.1415927410125732D);
                prevRotationPitch = rotationPitch = (float)((Math.atan2(d1, f) * 180D) / 3.1415927410125732D);
                prevRotationPitch = rotationPitch;
                prevRotationYaw = rotationYaw;
                setLocationAndAngles(posX, posY, posZ, rotationYaw, rotationPitch);
                ticksInGround = 0;
            }
        }
    
        public void onUpdate()
        {
            super.onUpdate();
            if(prevRotationPitch == 0.0F && prevRotationYaw == 0.0F)
            {
                float f = MathHelper.sqrt_double(motionX * motionX + motionZ * motionZ);
                prevRotationYaw = rotationYaw = (float)((Math.atan2(motionX, motionZ) * 180D) / 3.1415927410125732D);
                prevRotationPitch = rotationPitch = (float)((Math.atan2(motionY, f) * 180D) / 3.1415927410125732D);
            }
            int i = worldObj.getBlockId(xTile, yTile, zTile);
            if(i > 0)
            {
                Block.blocksList[i].setBlockBoundsBasedOnState(worldObj, xTile, yTile, zTile);
                AxisAlignedBB axisalignedbb = Block.blocksList[i].getCollisionBoundingBoxFromPool(worldObj, xTile, yTile, zTile);
                if(axisalignedbb != null && axisalignedbb.isVecInside(Vec3D.createVector(posX, posY, posZ)))
                {
                    inGround = true;
                }
            }
            if(arrowShake > 0)
            {
                arrowShake--;
            }
            if(inGround)
            {
                int j = worldObj.getBlockId(xTile, yTile, zTile);
                int k = worldObj.getBlockMetadata(xTile, yTile, zTile);
                if(j != inTile || k != field_28019_h)
                {
                    inGround = false;
                    motionX *= rand.nextFloat() * 0.2F;
                    motionY *= rand.nextFloat() * 0.2F;
                    motionZ *= rand.nextFloat() * 0.2F;
                    ticksInGround = 0;
                    ticksInAir = 0;
                    return;
                }
                ticksInGround++;
                if(ticksInGround == 1200)
                {
                    setEntityDead();
                }
                return;
            }
            ticksInAir++;
            Vec3D vec3d = Vec3D.createVector(posX, posY, posZ);
            Vec3D vec3d1 = Vec3D.createVector(posX + motionX, posY + motionY, posZ + motionZ);
            MovingObjectPosition movingobjectposition = worldObj.func_28105_a(vec3d, vec3d1, false, true);
            vec3d = Vec3D.createVector(posX, posY, posZ);
            vec3d1 = Vec3D.createVector(posX + motionX, posY + motionY, posZ + motionZ);
            if(movingobjectposition != null)
            {
                vec3d1 = Vec3D.createVector(movingobjectposition.hitVec.xCoord, movingobjectposition.hitVec.yCoord, movingobjectposition.hitVec.zCoord);
            }
            Entity entity = null;
            List list = worldObj.getEntitiesWithinAABBExcludingEntity(this, boundingBox.addCoord(motionX, motionY, motionZ).expand(1.0D, 1.0D, 1.0D));
            double d = 0.0D;
            for(int l = 0; l < list.size(); l++)
            {
                Entity entity1 = (Entity)list.get(l);
                if(!entity1.canBeCollidedWith() || entity1 == owner && ticksInAir < 5)
                {
                    continue;
                }
                float f4 = 0.3F;
                AxisAlignedBB axisalignedbb1 = entity1.boundingBox.expand(f4, f4, f4);
                MovingObjectPosition movingobjectposition1 = axisalignedbb1.func_1169_a(vec3d, vec3d1);
                if(movingobjectposition1 == null)
                {
                    continue;
                }
                double d1 = vec3d.distanceTo(movingobjectposition1.hitVec);
                if(d1 < d || d == 0.0D)
                {
                    entity = entity1;
                    d = d1;
                }
            }
    
            if(entity != null)
            {
                movingobjectposition = new MovingObjectPosition(entity);
            }
            if(movingobjectposition != null)
            {
                if(movingobjectposition.entityHit != null)
                {
                    if(movingobjectposition.entityHit.attackEntityFrom(owner, 4))
                    {
                        worldObj.playSoundAtEntity(this, "random.drr", 1.0F, 1.2F / (rand.nextFloat() * 0.2F + 0.9F));
                        setEntityDead();
                    } else
                    {
                        motionX *= -0.10000000149011612D;
                        motionY *= -0.10000000149011612D;
                        motionZ *= -0.10000000149011612D;
                        rotationYaw += 180F;
                        prevRotationYaw += 180F;
                        ticksInAir = 0;
                    }
                } else
                {
                    xTile = movingobjectposition.blockX;
                    yTile = movingobjectposition.blockY;
                    zTile = movingobjectposition.blockZ;
                    inTile = worldObj.getBlockId(xTile, yTile, zTile);
                    field_28019_h = worldObj.getBlockMetadata(xTile, yTile, zTile);
                    motionX = (float)(movingobjectposition.hitVec.xCoord - posX);
                    motionY = (float)(movingobjectposition.hitVec.yCoord - posY);
                    motionZ = (float)(movingobjectposition.hitVec.zCoord - posZ);
                    float f1 = MathHelper.sqrt_double(motionX * motionX + motionY * motionY + motionZ * motionZ);
                    posX -= (motionX / (double)f1) * 0.05000000074505806D;
                    posY -= (motionY / (double)f1) * 0.05000000074505806D;
                    posZ -= (motionZ / (double)f1) * 0.05000000074505806D;
                    worldObj.playSoundAtEntity(this, "random.drr", 1.0F, 1.2F / (rand.nextFloat() * 0.2F + 0.9F));
                    inGround = true;
                    arrowShake = 7;
                }
            }
            posX += motionX;
            posY += motionY;
            posZ += motionZ;
            float f2 = MathHelper.sqrt_double(motionX * motionX + motionZ * motionZ);
            rotationYaw = (float)((Math.atan2(motionX, motionZ) * 180D) / 3.1415927410125732D);
            for(rotationPitch = (float)((Math.atan2(motionY, f2) * 180D) / 3.1415927410125732D); rotationPitch - prevRotationPitch < -180F; prevRotationPitch -= 360F) { }
            for(; rotationPitch - prevRotationPitch >= 180F; prevRotationPitch += 360F) { }
            for(; rotationYaw - prevRotationYaw < -180F; prevRotationYaw -= 360F) { }
            for(; rotationYaw - prevRotationYaw >= 180F; prevRotationYaw += 360F) { }
            rotationPitch = prevRotationPitch + (rotationPitch - prevRotationPitch) * 0.2F;
            rotationYaw = prevRotationYaw + (rotationYaw - prevRotationYaw) * 0.2F;
            float f3 = 0.99F;
            float f5 = 0.03F;
            if(isInWater())
            {
                for(int i1 = 0; i1 < 4; i1++)
                {
                    float f6 = 0.25F;
                    worldObj.spawnParticle("bubble", posX - motionX * (double)f6, posY - motionY * (double)f6, posZ - motionZ * (double)f6, motionX, motionY, motionZ);
                }
    
                f3 = 0.8F;
            }
            motionX *= f3;
            motionY *= f3;
            motionZ *= f3;
            motionY -= f5;
            setPosition(posX, posY, posZ);
        }
    
        public void writeEntityToNBT(NBTTagCompound nbttagcompound)
        {
            nbttagcompound.setShort("xTile", (short)xTile);
            nbttagcompound.setShort("yTile", (short)yTile);
            nbttagcompound.setShort("zTile", (short)zTile);
            nbttagcompound.setByte("inTile", (byte)inTile);
            nbttagcompound.setByte("inData", (byte)field_28019_h);
            nbttagcompound.setByte("shake", (byte)arrowShake);
            nbttagcompound.setByte("inGround", (byte)(inGround ? 1 : 0));
            nbttagcompound.setBoolean("player", doesArrowBelongToPlayer);
        }
    
        public void readEntityFromNBT(NBTTagCompound nbttagcompound)
        {
            xTile = nbttagcompound.getShort("xTile");
            yTile = nbttagcompound.getShort("yTile");
            zTile = nbttagcompound.getShort("zTile");
            inTile = nbttagcompound.getByte("inTile") & 0xff;
            field_28019_h = nbttagcompound.getByte("inData") & 0xff;
            arrowShake = nbttagcompound.getByte("shake") & 0xff;
            inGround = nbttagcompound.getByte("inGround") == 1;
            doesArrowBelongToPlayer = nbttagcompound.getBoolean("player");
        }
    
        public void onCollideWithPlayer(EntityPlayer entityplayer)
        {
            if(worldObj.multiplayerWorld)
            {
                return;
            }
            
        }
    
        public float getShadowSize()
        {
            return 0.0F;
        }
    
        private int xTile;
        private int yTile;
        private int zTile;
        private int inTile;
        private int field_28019_h;
        private boolean inGround;
        public boolean doesArrowBelongToPlayer;
        public int arrowShake;
        public EntityLiving owner;
        private int ticksInGround;
        private int ticksInAir;
    }
    Can anyone tell me where the error is?
    Posted in: Mods Discussion
  • To post a comment, please .