【質問】右クリックで飛ぶ投げ槍の作成

Modding・サーバPlugin制作・ツール制作など、開発関連の質問があればこちらにお願い致します。
フォーラムルール
質問関連フォーラムで質問する時は、必ず次のトピックを一読/厳守お願い致します。
viewtopic.php?f=5&t=999
  • (PostNo.44877)

【質問】右クリックで飛ぶ投げ槍の作成

投稿記事by x裕紀x » 2012年6月25日(月) 20:56

現在投げ槍を作成しているのですが,頑張った結果右クリックで弓のように飛んでいくのですが上手くエフェクトを認識していないようで

槍の後ろの部分だけが見え 自分が動くと常に自分の方向に向いて

やりの横の部分などが全くみえません.

↓このような状態
画像

槍が弓矢のように3Dで見えるようにし,自分の方向を向かないように設定したいのですが誰かお力添えしていただけると助かります.

ソースコードは以下のとおりになっております.

mod_YUKI
コード: 全て選択
package net.minecraft.src; //MCPのパッケージを読み込む
import java.util.Map;


public class mod_YUKI extends BaseMod 
   
   public String getVersion()
   {
      return "1.2.5";
   }

   public static Item LonginusJavelin;
   public static int JavelinID = 201;
   public static int imageJavelinTop;
   
   public mod_YUKI()
   {
      super ();
   }

    public void load()
      {
   
      LonginusJavelin = new ItemLonginusJavelin(JavelinID, EnumToolYuki.LONGINUS).setItemName("LonginusJavelin");
      LonginusJavelin.iconIndex = ModLoader.addOverride("/gui/items.png","/yuki/longinusmove.png");
      ModLoader.addName(LonginusJavelin,"Lance of Longinus");
      ModLoader.registerEntityID(EntityLonginusJavelin.class, "LonginusJavelin", ModLoader.getUniqueEntityId());

     
      ModLoader.addRecipe(new ItemStack(LonginusJavelin,1),
            new Object[]{"#","#","#",
         Character.valueOf('#'),TNTBlock });
    }   
   public void addRenderer(Map map)
   {
      super.addRenderer(map);
      map.put(net.minecraft.src.EntityLonginusJavelin.class, new RenderLonginusJavelin(LonginusJavelin.iconIndex));
   }

}

Item名はLonginusJavelin
IDを201に登録してありTNTBlockで作成します.
テクスチャーは下のようになっています.
画像


RenderLonginusJavelin
コード: 全て選択
package net.minecraft.src;

import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL12;

public class RenderLonginusJavelin extends Render
{
    /**
     * Have the icon index (in items.png) that will be used to render the image. Currently, eggs and snowballs uses this
     * classes.
     */
    private int itemIconIndex;

    public RenderLonginusJavelin(int par1)
    {
        itemIconIndex = par1;
    }

    /**
     * Actually renders the given argument. This is a synthetic bridge method, always casting down its argument and then
     * handing it off to a worker function which does the actual work. In all probabilty, the class Render is generic
     * (Render<T extends Entity) and this method has signature public void doRender(T entity, double d, double d1,
     * double d2, float f, float f1). But JAD is pre 1.5 so doesn't do that.
     */
    public void doRender(Entity par1Entity, double par2, double par4, double par6, float par8, float par9)
    {
        GL11.glPushMatrix();
        GL11.glTranslatef((float)par2, (float)par4, (float)par6);
        GL11.glEnable(GL12.GL_RESCALE_NORMAL);
        GL11.glScalef(0.5F, 0.5F, 0.5F);
        loadTexture("/yuki/longinus.png");
        Tessellator tessellator = Tessellator.instance;

        if (itemIconIndex == 154)
        {
            int i = PotionHelper.func_40358_a(((EntityPotion)par1Entity).getPotionDamage(), false);
            float f = (float)(i >> 16 & 0xff) / 255F;
            float f1 = (float)(i >> 8 & 0xff) / 255F;
            float f2 = (float)(i & 0xff) / 255F;
            GL11.glColor3f(f, f1, f2);
            GL11.glPushMatrix();
            func_40265_a(tessellator, 141);
            GL11.glPopMatrix();
            GL11.glColor3f(1.0F, 1.0F, 1.0F);
        }

        func_40265_a(tessellator, itemIconIndex);
        GL11.glDisable(GL12.GL_RESCALE_NORMAL);
        GL11.glPopMatrix();
    }

    private void func_40265_a(Tessellator par1Tessellator, int par2)
    {
        float f = (float)((par2 % 16) * 16 + 0) / 256F;
        float f1 = (float)((par2 % 16) * 16 + 16) / 256F;
        float f2 = (float)((par2 / 16) * 16 + 0) / 256F;
        float f3 = (float)((par2 / 16) * 16 + 16) / 256F;
        float f4 = 1.0F;
        float f5 = 0.5F;
        float f6 = 0.25F;
        GL11.glRotatef(180F - renderManager.playerViewY, 0.0F, 1.0F, 0.0F);
        GL11.glRotatef(-renderManager.playerViewX, 1.0F, 0.0F, 0.0F);
        par1Tessellator.startDrawingQuads();
        par1Tessellator.setNormal(0.0F, 1.0F, 0.0F);
        par1Tessellator.addVertexWithUV(0.0F - f5, 0.0F - f6, 0.0D, f, f3);
        par1Tessellator.addVertexWithUV(f4 - f5, 0.0F - f6, 0.0D, f1, f3);
        par1Tessellator.addVertexWithUV(f4 - f5, f4 - f6, 0.0D, f1, f2);
        par1Tessellator.addVertexWithUV(0.0F - f5, f4 - f6, 0.0D, f, f2);
        par1Tessellator.draw();
    }
}

詳細は一切わかりませんが,テクスチャーの設定だと思っております.
Renderを継承し,loadTexture("/yuki/longinus.png");でテクスチャーを指定しています.
テクスチャーは下記のようになっています.
画像


EnumToolYuki
コード: 全て選択
package net.minecraft.src;

public enum EnumToolYuki
{
   LONGINUS("LONGINUS",0,20,2000,20F,20);
   
   private EnumToolYuki(String s, int i, int j, int k, float f, int l)
   {
      harvestLevel = j;
      maxUses = k;
      efficiencyOnProperMaterial = f;
      damageVsEntity = l;
   }
   
   public int getMaxUses()
   {
      return maxUses;
   }
   
   public float getEfficiencyOnproperMaterial()
   {
      return efficiencyOnProperMaterial;
   }
   
   public int getDamageVsEntity()
   {
      return damageVsEntity;
   }
   
   public int getHarvestLevel()
   {
      return harvestLevel;
   }
   
   private final int harvestLevel;
   private final int maxUses;
   private final float efficiencyOnProperMaterial;
   private final int damageVsEntity;
   private static final EnumToolYuki field_21209_j[]; /* synthetic field */
   
   static
   {
      field_21209_j = (new EnumToolYuki[]{
         LONGINUS
      });
   }
}

アイテムの強さの設定だと思われます.
テストプレイなので強さがバランス崩壊しております.
ここらへんは特に問題ないと考えております.


ItemLonginusJavelin
コード: 全て選択
package net.minecraft.src;

public class ItemLonginusJavelin extends Item
{
   float f=1.0F;
   
   public ItemLonginusJavelin(int i,EnumToolYuki enumtoolyuki)
   {
      super(i);
      maxStackSize = 1;
      setMaxDamage(enumtoolyuki.getMaxUses());
      weaponDamage = 4 + enumtoolyuki.getDamageVsEntity() * 2;
   }
   
   public float getStrVsBlock(ItemStack itemstack, Block block)
   {
      return block.blockID != Block.web.blockID ? 1.5F : 15F;
   }
   
   public boolean hitEntity(ItemStack itemstack, EntityLiving entityliving, EntityLiving entityliving1)
   {
      itemstack.damageItem(1,entityliving1);
      return true;
   }
   
   public boolean onBlockDestroyed(ItemStack itemstack, int i, int j, int k, int l, EntityLiving entityliving)
   {
      itemstack.damageItem(2,entityliving);。
      return true;
   }
   
   public int getDamageVsEntity(Entity entity)
   {
      return weaponDamage;
   }
   
   public boolean isFull3D()
   {
      return true;
   }
   
   public EnumAction func_35412_b(ItemStack itemstack)
   {
      return EnumAction.block;
   }
   
   public int func_35411_c(ItemStack itemstack)
   {
      return 0x11940;
   }
   public void onPlayerStoppedUsing(ItemStack itemstack, World world, EntityPlayer entityplayer, int par4)//ここから
    {
        boolean flag = entityplayer.capabilities.isCreativeMode || EnchantmentHelper.getEnchantmentLevel(Enchantment.infinity.effectId, itemstack) > 0;

        if (flag || entityplayer.inventory.hasItem(Item.arrow.shiftedIndex))
        {
            int i = getMaxItemUseDuration(itemstack) - par4;
            float f = (float)i / 20F;
            f = (f * f + f * 2.0F) / 3F;

            if ((double)f < 0.10000000000000001D)
            {
                return;
            }

            if (f > 1.0F)
            {
                f = 1.0F;
            }

            EntityLonginusJavelin entitylonginusjavelin = new EntityLonginusJavelin(world, entityplayer, f * 2.0F);

            if (f == 1.0F)
            {
                entitylonginusjavelin.arrowCritical = true;
            }

            int j = EnchantmentHelper.getEnchantmentLevel(Enchantment.power.effectId, itemstack);

            if (j > 0)
            {
                entitylonginusjavelin.setDamage(entitylonginusjavelin.getDamage() + (double)j * 0.5D + 0.5D);
            }

            int k = EnchantmentHelper.getEnchantmentLevel(Enchantment.punch.effectId, itemstack);

            if (k > 0)
            {
                entitylonginusjavelin.func_46023_b(k);
            }

            if (EnchantmentHelper.getEnchantmentLevel(Enchantment.flame.effectId, itemstack) > 0)
            {
                entitylonginusjavelin.setFire(1000);
            }

            itemstack.damageItem(1, entityplayer);
            world.playSoundAtEntity(entityplayer, "random.bow", 1.0F, 1.0F / (itemRand.nextFloat() * 0.4F + 1.2F) + f * 0.5F);

            if (!flag)
            {
                entityplayer.inventory.consumeInventoryItem(Item.arrow.shiftedIndex);
            }
            else
            {
                entitylonginusjavelin.doesArrowBelongToPlayer = false;
            }

            if (!world.isRemote)
            {
                world.spawnEntityInWorld(entitylonginusjavelin);
            }
        }
    }

    public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
    {
       EntityLonginusJavelin entitylonginusjavelin = new EntityLonginusJavelin(par2World,  par3EntityPlayer, f * 2.0F);
       onPlayerStoppedUsing(par1ItemStack,par2World, par3EntityPlayer,100);
       entitylonginusjavelin.onUpdate();
        return par1ItemStack;
    }//ここまで
   
   public boolean canHarvestBlock(Block block)
   {
      return block.blockID == Block.web.blockID;
   }

   private int weaponDamage;
}

コメントで"ここから""ここまで"と書いてある部分が恐らく問題の部分となっております.
floatなどがどこから使われているのかわからず適当に数値をいれています.
onPlayerStoppedUsing(ItemStack itemstack, World world, EntityPlayer entityplayer, int par4)はItemBowから取ってきたソースをちょっとだけ改変したソースとなっております.
onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)はEntityLonginusの中のデータを引っ張ってくれば動いてくれるのではないかと思って色々引っ張ってます.


EntityLonginusJavelin
コード: 全て選択
package net.minecraft.src;

import java.util.List;
import java.util.Random;

public class EntityLonginusJavelin extends Entity
{
    private int xTile;
    private int yTile;
    private int zTile;
    private int inTile;
    private int inData;
    private boolean inGround;
    public boolean doesArrowBelongToPlayer;

    /** Seems to be some sort of timer for animating an arrow. */
    public int arrowShake;

    /** The owner of this arrow. */
    public Entity shootingEntity;
    private int ticksInGround;
    private int ticksInAir;
    private double damage;
    private int field_46027_au;

    /** Is this arrow a critical hit? (Controls particles and damage) */
    public boolean arrowCritical;

    public EntityLonginusJavelin(World par1World)
    {
        super(par1World);
        xTile = -1;
        yTile = -1;
        zTile = -1;
        inTile = 0;
        inData = 0;
        inGround = false;
        doesArrowBelongToPlayer = false;
        arrowShake = 0;
        ticksInAir = 0;
        damage = 2D;
        arrowCritical = false;
        setSize(0.5F, 0.5F);
    }

    public EntityLonginusJavelin(World par1World, double par2, double par4, double par6)
    {
        super(par1World);
        xTile = -1;
        yTile = -1;
        zTile = -1;
        inTile = 0;
        inData = 0;
        inGround = false;
        doesArrowBelongToPlayer = false;
        arrowShake = 0;
        ticksInAir = 0;
        damage = 2D;
        arrowCritical = false;
        setSize(0.5F, 0.5F);
        setPosition(par2, par4, par6);
        yOffset = 0.0F;
    }

    public EntityLonginusJavelin(World par1World, EntityLiving par2EntityLiving, EntityLiving par3EntityLiving, float par4, float par5)
    {
        super(par1World);
        xTile = -1;
        yTile = -1;
        zTile = -1;
        inTile = 0;
        inData = 0;
        inGround = false;
        doesArrowBelongToPlayer = false;
        arrowShake = 0;
        ticksInAir = 0;
        damage = 2D;
        arrowCritical = false;
        shootingEntity = par2EntityLiving;
        doesArrowBelongToPlayer = par2EntityLiving instanceof EntityPlayer;
        posY = (par2EntityLiving.posY + (double)par2EntityLiving.getEyeHeight()) - 0.10000000149011612D;
        double d = par3EntityLiving.posX - par2EntityLiving.posX;
        double d1 = (par3EntityLiving.posY + (double)par3EntityLiving.getEyeHeight()) - 0.69999998807907104D - posY;
        double d2 = par3EntityLiving.posZ - par2EntityLiving.posZ;
        double d3 = MathHelper.sqrt_double(d * d + d2 * d2);

        if (d3 < 9.9999999999999995E-008D)
        {
            return;
        }
        else
        {
            float f = (float)((Math.atan2(d2, d) * 180D) / Math.PI) - 90F;
            float f1 = (float)(-((Math.atan2(d1, d3) * 180D) / Math.PI));
            double d4 = d / d3;
            double d5 = d2 / d3;
            setLocationAndAngles(par2EntityLiving.posX + d4, posY, par2EntityLiving.posZ + d5, f, f1);
            yOffset = 0.0F;
            float f2 = (float)d3 * 0.2F;
            setLonginusJavelinHeading(d, d1 + (double)f2, d2, par4, par5);
            return;
        }
    }

    public EntityLonginusJavelin(World par1World, EntityLiving par2EntityLiving, float par3)
    {
        super(par1World);
        xTile = -1;
        yTile = -1;
        zTile = -1;
        inTile = 0;
        inData = 0;
        inGround = false;
        doesArrowBelongToPlayer = false;
        arrowShake = 0;
        ticksInAir = 0;
        damage = 200D;
        arrowCritical = false;
        shootingEntity = par2EntityLiving;
        doesArrowBelongToPlayer = par2EntityLiving instanceof EntityPlayer;
        setSize(0.5F, 0.5F);
        setLocationAndAngles(par2EntityLiving.posX, par2EntityLiving.posY + (double)par2EntityLiving.getEyeHeight(), par2EntityLiving.posZ, par2EntityLiving.rotationYaw, par2EntityLiving.rotationPitch);
        posX -= MathHelper.cos((rotationYaw / 180F) * (float)Math.PI) * 0.16F;
        posY -= 0.10000000149011612D;
        posZ -= MathHelper.sin((rotationYaw / 180F) * (float)Math.PI) * 0.16F;
        setPosition(posX, posY, posZ);
        yOffset = 0.0F;
        motionX = -MathHelper.sin((rotationYaw / 180F) * (float)Math.PI) * MathHelper.cos((rotationPitch / 180F) * (float)Math.PI);
        motionZ = MathHelper.cos((rotationYaw / 180F) * (float)Math.PI) * MathHelper.cos((rotationPitch / 180F) * (float)Math.PI);
        motionY = -MathHelper.sin((rotationPitch / 180F) * (float)Math.PI);
        setLonginusJavelinHeading(motionX, motionY, motionZ, par3 * 100.5F, 1.0F);
    }

    protected void entityInit()
    {
    }

    /**
     * Uses the provided coordinates as a heading and determines the velocity from it with the set force and random
     * variance. Args: x, y, z, force, forceVariation
     */
    public void setLonginusJavelinHeading(double par1, double par3, double par5, float par7, float par8)
    {
        float f = MathHelper.sqrt_double(par1 * par1 + par3 * par3 + par5 * par5);
        par1 /= f;
        par3 /= f;
        par5 /= f;
        par1 += rand.nextGaussian() * 0.0074999998323619366D * (double)par8;
        par3 += rand.nextGaussian() * 0.0074999998323619366D * (double)par8;
        par5 += rand.nextGaussian() * 0.0074999998323619366D * (double)par8;
        par1 *= par7;
        par3 *= par7;
        par5 *= par7;
        motionX = par1;
        motionY = par3;
        motionZ = par5;
        float f1 = MathHelper.sqrt_double(par1 * par1 + par5 * par5);
        prevRotationYaw = rotationYaw = (float)((Math.atan2(par1, par5) * 180D) / Math.PI);
        prevRotationPitch = rotationPitch = (float)((Math.atan2(par3, f1) * 180D) / Math.PI);
        ticksInGround = 0;
    }

    /**
     * Sets the velocity to the args. Args: x, y, z
     */
    public void setVelocity(double par1, double par3, double par5)
    {
        motionX = par1;
        motionY = par3;
        motionZ = par5;

        if (prevRotationPitch == 0.0F && prevRotationYaw == 0.0F)
        {
            float f = MathHelper.sqrt_double(par1 * par1 + par5 * par5);
            prevRotationYaw = rotationYaw = (float)((Math.atan2(par1, par5) * 180D) / Math.PI);
            prevRotationPitch = rotationPitch = (float)((Math.atan2(par3, f) * 180D) / Math.PI);
            prevRotationPitch = rotationPitch;
            prevRotationYaw = rotationYaw;
            setLocationAndAngles(posX, posY, posZ, rotationYaw, rotationPitch);
            ticksInGround = 0;
        }
    }

    /**
     * Called to update the entity's position/logic.
     */
    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) / Math.PI);
            prevRotationPitch = rotationPitch = (float)((Math.atan2(motionY, f) * 180D) / Math.PI);
        }

        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 != inData)
            {
                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)
            {
                setDead();
            }

            return;
        }

        ticksInAir++;
        Vec3D vec3d = Vec3D.createVector(posX, posY, posZ);
        Vec3D vec3d1 = Vec3D.createVector(posX + motionX, posY + motionY, posZ + motionZ);
        MovingObjectPosition movingobjectposition = worldObj.rayTraceBlocks_do_do(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 == shootingEntity && ticksInAir < 5)
            {
                continue;
            }

            float f5 = 0.3F;
            AxisAlignedBB axisalignedbb1 = entity1.boundingBox.expand(f5, f5, f5);
            MovingObjectPosition movingobjectposition1 = axisalignedbb1.calculateIntercept(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)
            {
                float f1 = MathHelper.sqrt_double(motionX * motionX + motionY * motionY + motionZ * motionZ);
                int j1 = (int)Math.ceil((double)f1 * damage);

                if (arrowCritical)
                {
                    j1 += rand.nextInt(j1 / 2 + 2);
                }

                DamageSource damagesource = null;

/*                if (shootingEntity == null)
                {
                   
                    damagesource = DamageSourceYT.causeArrowDamage(this, this);
                }
                else
                {
                    damagesource = DamageSourceYT.causeArrowDamage(this, shootingEntity);
                }

                if (isBurning())
                {
                    movingobjectposition.entityHit.setFire(5);
                }

                if (movingobjectposition.entityHit.attackEntityFrom(damagesource, j1))
                {
                    if (movingobjectposition.entityHit instanceof EntityLiving)
                    {
                        ((EntityLiving)movingobjectposition.entityHit).arrowHitTempCounter++;

                        if (field_46027_au > 0)
                        {
                            float f7 = MathHelper.sqrt_double(motionX * motionX + motionZ * motionZ);

                            if (f7 > 0.0F)
                            {
                                movingobjectposition.entityHit.addVelocity((motionX * (double)field_46027_au * 0.60000002384185791D) / (double)f7, 0.10000000000000001D, (motionZ * (double)field_46027_au * 0.60000002384185791D) / (double)f7);
                            }
                        }
                    }

                    worldObj.playSoundAtEntity(this, "random.bowhit", 1.0F, 1.2F / (rand.nextFloat() * 0.2F + 0.9F));
                    setDead();
                }
                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);
                inData = worldObj.getBlockMetadata(xTile, yTile, zTile);
                motionX = (float)(movingobjectposition.hitVec.xCoord - posX);
                motionY = (float)(movingobjectposition.hitVec.yCoord - posY);
                motionZ = (float)(movingobjectposition.hitVec.zCoord - posZ);
                float f2 = MathHelper.sqrt_double(motionX * motionX + motionY * motionY + motionZ * motionZ);
                posX -= (motionX / (double)f2) * 0.05000000074505806D;
                posY -= (motionY / (double)f2) * 0.05000000074505806D;
                posZ -= (motionZ / (double)f2) * 0.05000000074505806D;
                worldObj.playSoundAtEntity(this, "random.bowhit", 1.0F, 1.2F / (rand.nextFloat() * 0.2F + 0.9F));
                inGround = true;
                arrowShake = 7;
                arrowCritical = false;
            }
        }

        if (arrowCritical)
        {
            for (int i1 = 0; i1 < 4; i1++)
            {
                worldObj.spawnParticle("crit", posX + (motionX * (double)i1) / 4D, posY + (motionY * (double)i1) / 4D, posZ + (motionZ * (double)i1) / 4D, -motionX, -motionY + 0.20000000000000001D, -motionZ);
            }
        }

        posX += motionX;
        posY += motionY;
        posZ += motionZ;
        float f3 = MathHelper.sqrt_double(motionX * motionX + motionZ * motionZ);
        rotationYaw = (float)((Math.atan2(motionX, motionZ) * 180D) / Math.PI);

        for (rotationPitch = (float)((Math.atan2(motionY, f3) * 180D) / Math.PI); 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 f4 = 0.99F;
        float f6 = 0.05F;

        if (isInWater())
        {
            for (int k1 = 0; k1 < 4; k1++)
            {
                float f8 = 0.25F;
                worldObj.spawnParticle("bubble", posX - motionX * (double)f8, posY - motionY * (double)f8, posZ - motionZ * (double)f8, motionX, motionY, motionZ);
            }

            f4 = 0.8F;
        }

        motionX *= f4;
        motionY *= f4;
        motionZ *= f4;
        motionY -= f6;
        setPosition(posX, posY, posZ);
    }
    /**
     * (abstract) Protected helper method to write subclass entity data to NBT.
     */
    public void writeEntityToNBT(NBTTagCompound par1NBTTagCompound)
    {
        par1NBTTagCompound.setShort("xTile", (short)xTile);
        par1NBTTagCompound.setShort("yTile", (short)yTile);
        par1NBTTagCompound.setShort("zTile", (short)zTile);
        par1NBTTagCompound.setByte("inTile", (byte)inTile);
        par1NBTTagCompound.setByte("inData", (byte)inData);
        par1NBTTagCompound.setByte("shake", (byte)arrowShake);
        par1NBTTagCompound.setByte("inGround", (byte)(inGround ? 1 : 0));
        par1NBTTagCompound.setBoolean("player", doesArrowBelongToPlayer);
        par1NBTTagCompound.setDouble("damage", damage);
    }

    /**
     * (abstract) Protected helper method to read subclass entity data from NBT.
     */
    public void readEntityFromNBT(NBTTagCompound par1NBTTagCompound)
    {
        xTile = par1NBTTagCompound.getShort("xTile");
        yTile = par1NBTTagCompound.getShort("yTile");
        zTile = par1NBTTagCompound.getShort("zTile");
        inTile = par1NBTTagCompound.getByte("inTile") & 0xff;
        inData = par1NBTTagCompound.getByte("inData") & 0xff;
        arrowShake = par1NBTTagCompound.getByte("shake") & 0xff;
        inGround = par1NBTTagCompound.getByte("inGround") == 1;
        doesArrowBelongToPlayer = par1NBTTagCompound.getBoolean("player");

        if (par1NBTTagCompound.hasKey("damage"))
        {
            damage = par1NBTTagCompound.getDouble("damage");
        }
    }

    /**
     * Called by a player entity when they collide with an entity
     */
    public void onCollideWithPlayer(EntityPlayer par1EntityPlayer)
    {
        if (worldObj.isRemote)
        {
            return;
        }

        if (inGround && doesArrowBelongToPlayer && arrowShake <= 0 && par1EntityPlayer.inventory.addItemStackToInventory(new ItemStack(Item.arrow, 1)))
        {
            worldObj.playSoundAtEntity(this, "random.pop", 0.2F, ((rand.nextFloat() - rand.nextFloat()) * 0.7F + 1.0F) * 2.0F);
            par1EntityPlayer.onItemPickup(this, 1);
            setDead();
        }
    }

    public float getShadowSize()
    {
        return 0.0F;
    }

    public void setDamage(double par1)
    {
        damage = par1;
    }

    public double getDamage()
    {
        return damage;
    }

    public void func_46023_b(int par1)
    {
        field_46027_au = par1;
    }

    /**
     * If returns false, the item will not inflict any damage against entities.
     */
    public boolean canAttackWithItem()
    {
        return true;
    }
}

EntityArrowの中身をEntityLonginusJavelinに変えたのと,少々ダメージなどの値を動かした程度のソースです.
onUpdateの中のdamagesorceのclassから引っ張ってくる時にEntityArrow型とEntityLonginusJavelin型の変換が出来ず,コメントに変更しております.
x裕紀x
ID:70743d1d
水から上がったとこ
 
記事: 4
登録日時: 2012年6月17日(日) 21:10

  • (PostNo.44908)

Re: 【質問】右クリックで飛ぶ投げ槍の作成

投稿記事by ayashige » 2012年6月25日(月) 23:49

矢のように描画したいのであれば、RenderArrowクラスを参考にしたほうがいいと思われます。
RenderLonginusJavelinだと、普通のアイテムのアイコンを描画すと同じような処理になっています。
(自分から見て1枚絵を表示)

RenderArrowクラスでは本体を十字に交差するテクスチャで描画し、矢羽を描画する処理が入っているのでそちらを参考したらいいと思います。
綾繁那人です、ねこによろしく。
ayashige
ID:35312126
大工さん
 
記事: 47
登録日時: 2012年5月03日(木) 12:52

  • (PostNo.45117)

Re: 【質問】右クリックで飛ぶ投げ槍の作成

投稿記事by x裕紀x » 2012年6月27日(水) 23:46

あ!出来ました!!ありがとうございます;ω;
x裕紀x
ID:70743d1d
水から上がったとこ
 
記事: 4
登録日時: 2012年6月17日(日) 21:10


Return to 質問:開発・制作関連

x