From ee7107296932894c6062541a519af4bba0b3aaeb Mon Sep 17 00:00:00 2001 From: WayofTime Date: Wed, 13 Jul 2016 17:19:02 -0400 Subject: [PATCH] Remembered after the fact to add the new stuff too. --- .../render/entity/MeteorRenderFactory.java | 15 ++ .../render/entity/RenderEntityMeteor.java | 56 +++++++ .../client/render/model/ModelMeteor.java | 95 ++++++++++++ .../entity/projectile/EntityMeteor.java | 138 ++++++++++++++++++ .../bloodmagic/meteor/MeteorComponent.java | 41 ++++++ .../bloodmagic/meteor/MeteorHolder.java | 74 ++++++++++ .../bloodmagic/meteor/MeteorRegistry.java | 53 +++++++ .../bloodmagic/ritual/RitualMeteor.java | 108 ++++++++++++++ 8 files changed, 580 insertions(+) create mode 100644 src/main/java/WayofTime/bloodmagic/client/render/entity/MeteorRenderFactory.java create mode 100644 src/main/java/WayofTime/bloodmagic/client/render/entity/RenderEntityMeteor.java create mode 100644 src/main/java/WayofTime/bloodmagic/client/render/model/ModelMeteor.java create mode 100644 src/main/java/WayofTime/bloodmagic/entity/projectile/EntityMeteor.java create mode 100644 src/main/java/WayofTime/bloodmagic/meteor/MeteorComponent.java create mode 100644 src/main/java/WayofTime/bloodmagic/meteor/MeteorHolder.java create mode 100644 src/main/java/WayofTime/bloodmagic/meteor/MeteorRegistry.java create mode 100644 src/main/java/WayofTime/bloodmagic/ritual/RitualMeteor.java diff --git a/src/main/java/WayofTime/bloodmagic/client/render/entity/MeteorRenderFactory.java b/src/main/java/WayofTime/bloodmagic/client/render/entity/MeteorRenderFactory.java new file mode 100644 index 00000000..a55f4559 --- /dev/null +++ b/src/main/java/WayofTime/bloodmagic/client/render/entity/MeteorRenderFactory.java @@ -0,0 +1,15 @@ +package WayofTime.bloodmagic.client.render.entity; + +import net.minecraft.client.renderer.entity.Render; +import net.minecraft.client.renderer.entity.RenderManager; +import net.minecraftforge.fml.client.registry.IRenderFactory; +import WayofTime.bloodmagic.entity.projectile.EntityMeteor; + +public class MeteorRenderFactory implements IRenderFactory +{ + @Override + public Render createRenderFor(RenderManager manager) + { + return new RenderEntityMeteor(manager); + } +} diff --git a/src/main/java/WayofTime/bloodmagic/client/render/entity/RenderEntityMeteor.java b/src/main/java/WayofTime/bloodmagic/client/render/entity/RenderEntityMeteor.java new file mode 100644 index 00000000..f1425847 --- /dev/null +++ b/src/main/java/WayofTime/bloodmagic/client/render/entity/RenderEntityMeteor.java @@ -0,0 +1,56 @@ +package WayofTime.bloodmagic.client.render.entity; + +import net.minecraft.client.model.ModelBase; +import net.minecraft.client.renderer.GlStateManager; +import net.minecraft.client.renderer.entity.Render; +import net.minecraft.client.renderer.entity.RenderManager; +import net.minecraft.util.ResourceLocation; +import WayofTime.bloodmagic.api.Constants; +import WayofTime.bloodmagic.client.render.model.ModelMeteor; +import WayofTime.bloodmagic.entity.projectile.EntityMeteor; + +public class RenderEntityMeteor extends Render +{ + public ModelBase model = new ModelMeteor(); + private float scale = 1; + private static final ResourceLocation resource = new ResourceLocation(Constants.Mod.MODID, "textures/models/Meteor.png"); + + public RenderEntityMeteor(RenderManager renderManagerIn) + { + super(renderManagerIn); + } + + @Override + public void doRender(EntityMeteor entity, double x, double y, double z, float entityYaw, float partialTicks) + { +// GlStateManager.pushMatrix(); +// GlStateManager.translate((float) x, (float) y, (float) z); +// GlStateManager.enableRescaleNormal(); +// GlStateManager.scale(0.5F, 0.5F, 0.5F); +// GlStateManager.rotate(-this.renderManager.playerViewY, 0.0F, 1.0F, 0.0F); +// GlStateManager.rotate(this.renderManager.playerViewX, 1.0F, 0.0F, 0.0F); +// this.bindTexture(TextureMap.LOCATION_BLOCKS_TEXTURE); +// this.renderItem.renderItem(ItemComponent.getStack(ItemComponent.REAGENT_BLOODLIGHT), ItemCameraTransforms.TransformType.GROUND); +// GlStateManager.disableRescaleNormal(); +// GlStateManager.popMatrix(); + + GlStateManager.pushMatrix(); + GlStateManager.translate((float) x, (float) y, (float) z); + GlStateManager.enableRescaleNormal(); + GlStateManager.scale(scale, scale, scale); + this.bindTexture(this.getEntityTexture(entity)); +// GL11.glRotatef(entity.prevRotationYaw + (entity.rotationYaw - entity.prevRotationYaw) * f1, 0.0F, 1.0F, 0.0F); +// GL11.glRotatef(180.0f - entity.prevRotationPitch + (entity.rotationPitch - entity.prevRotationPitch) * f1, 1.0F, 0.0F, 0.0f); + model.render(entity, 0, (float) x, (float) y, (float) z, entityYaw, partialTicks); + GlStateManager.disableRescaleNormal(); + GlStateManager.popMatrix(); + + super.doRender(entity, x, y, z, entityYaw, partialTicks); + } + + @Override + protected ResourceLocation getEntityTexture(EntityMeteor entity) + { + return resource; + } +} diff --git a/src/main/java/WayofTime/bloodmagic/client/render/model/ModelMeteor.java b/src/main/java/WayofTime/bloodmagic/client/render/model/ModelMeteor.java new file mode 100644 index 00000000..3e62353c --- /dev/null +++ b/src/main/java/WayofTime/bloodmagic/client/render/model/ModelMeteor.java @@ -0,0 +1,95 @@ +package WayofTime.bloodmagic.client.render.model; + +import net.minecraft.client.model.ModelBase; +import net.minecraft.client.model.ModelRenderer; +import net.minecraft.entity.Entity; + +/** + * This is a direct copy of the meteor model from 1.7.10. As such it probably + * needs to be... better. + * + */ +public class ModelMeteor extends ModelBase +{ + //fields + ModelRenderer Shape1; + ModelRenderer Shape2; + ModelRenderer Shape3; + ModelRenderer Shape4; + ModelRenderer Shape5; + ModelRenderer Shape6; + ModelRenderer Shape7; + + public ModelMeteor() + { + textureWidth = 64; + textureHeight = 64; + Shape1 = new ModelRenderer(this, 0, 0); + Shape1.addBox(-8F, -8F, -8F, 16, 16, 16); + Shape1.setRotationPoint(0F, 0F, 0F); + Shape1.setTextureSize(64, 64); + Shape1.mirror = true; + setRotation(Shape1, 0F, 0F, 0F); + Shape2 = new ModelRenderer(this, 0, 32); + Shape2.addBox(3F, -10F, -1F, 12, 12, 12); + Shape2.setRotationPoint(0F, 0F, 0F); + Shape2.setTextureSize(64, 64); + Shape2.mirror = true; + setRotation(Shape2, 0F, 0F, 0F); + Shape3 = new ModelRenderer(this, 0, 32); + Shape3.addBox(0F, 0F, -10F, 12, 12, 12); + Shape3.setRotationPoint(0F, 0F, 0F); + Shape3.setTextureSize(64, 64); + Shape3.mirror = true; + setRotation(Shape3, 0F, 0F, 0F); + Shape4 = new ModelRenderer(this, 0, 32); + Shape4.addBox(1F, 2F, 2F, 12, 12, 12); + Shape4.setRotationPoint(0F, 0F, 0F); + Shape4.setTextureSize(64, 64); + Shape4.mirror = true; + setRotation(Shape4, 0F, 0F, 0F); + Shape5 = new ModelRenderer(this, 0, 32); + Shape5.addBox(-12F, -5F, 0F, 12, 12, 12); + Shape5.setRotationPoint(0F, 0F, 0F); + Shape5.setTextureSize(64, 64); + Shape5.mirror = true; + setRotation(Shape5, 0F, 0F, 0F); + Shape6 = new ModelRenderer(this, 0, 32); + Shape6.addBox(-13F, -2F, -11F, 12, 12, 12); + Shape6.setRotationPoint(0F, 0F, 0F); + Shape6.setTextureSize(64, 64); + Shape6.mirror = true; + setRotation(Shape6, 0F, 0F, 0F); + Shape7 = new ModelRenderer(this, 0, 32); + Shape7.addBox(-6F, -14F, -9F, 12, 12, 12); + Shape7.setRotationPoint(0F, 0F, 0F); + Shape7.setTextureSize(64, 64); + Shape7.mirror = true; + setRotation(Shape7, 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, entity); + Shape1.render(f5); + Shape2.render(f5); + Shape3.render(f5); + Shape4.render(f5); + Shape5.render(f5); + Shape6.render(f5); + Shape7.render(f5); + } + + 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, Entity entity) + { + super.setRotationAngles(f, f1, f2, f3, f4, f5, entity); + } +} \ No newline at end of file diff --git a/src/main/java/WayofTime/bloodmagic/entity/projectile/EntityMeteor.java b/src/main/java/WayofTime/bloodmagic/entity/projectile/EntityMeteor.java new file mode 100644 index 00000000..8e80527b --- /dev/null +++ b/src/main/java/WayofTime/bloodmagic/entity/projectile/EntityMeteor.java @@ -0,0 +1,138 @@ +package WayofTime.bloodmagic.entity.projectile; + +import lombok.Setter; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.projectile.EntityThrowable; +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.DamageSource; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.RayTraceResult; +import net.minecraft.world.World; +import net.minecraftforge.fml.common.registry.IThrowableEntity; +import WayofTime.bloodmagic.api.Constants; +import WayofTime.bloodmagic.meteor.MeteorRegistry; + +public class EntityMeteor extends EntityThrowable implements IThrowableEntity +{ + protected int ticksInAir = 0; + protected int maxTicksInAir = 600; + + @Setter + public ItemStack meteorStack; + + public EntityMeteor(World world) + { + super(world); + } + + public EntityMeteor(World world, double x, double y, double z, double velX, double velY, double velZ) + { + super(world); + this.setSize(1F, 1F); + this.setPosition(x, y, z); + motionX = velX; + motionY = velY; + motionZ = velZ; + } + + @Override + protected float getGravityVelocity() + { + return 0.03F; + } + + @Override + public void onUpdate() + { + super.onUpdate(); + if (this.ticksExisted > this.maxTicksInAir) + { + setDead(); + } + } + + @Override + protected void onImpact(RayTraceResult mop) + { + if (mop.typeOfHit == RayTraceResult.Type.ENTITY && mop.entityHit != null) + { + this.onImpact(mop.entityHit); + } else if (mop.typeOfHit == RayTraceResult.Type.BLOCK) + { + generateMeteor(mop.getBlockPos()); + } + + this.setDead(); + } + + protected void onImpact(Entity mop) + { + if (mop instanceof EntityLivingBase) + { + doDamage(100, mop); + } + + generateMeteor(mop.getPosition()); + + // spawnHitParticles("magicCrit", 8); + this.setDead(); + } + + protected void doDamage(int i, Entity mop) + { + mop.attackEntityFrom(this.getDamageSource(), i); + } + + public void generateMeteor(BlockPos pos) + { + MeteorRegistry.generateMeteorForItem(meteorStack, worldObj, pos, Blocks.STONE.getDefaultState()); + } + + public DamageSource getDamageSource() + { + return DamageSource.anvil; + } + + @Override + public void writeEntityToNBT(NBTTagCompound nbt) + { + super.writeEntityToNBT(nbt); + nbt.setInteger(Constants.NBT.PROJECTILE_TICKS_IN_AIR, ticksInAir); + nbt.setInteger(Constants.NBT.PROJECTILE_MAX_TICKS_IN_AIR, maxTicksInAir); + + if (meteorStack != null) + { + meteorStack.writeToNBT(nbt); + } + } + + @Override + public void readEntityFromNBT(NBTTagCompound nbt) + { + super.readEntityFromNBT(nbt); + ticksInAir = nbt.getInteger(Constants.NBT.PROJECTILE_TICKS_IN_AIR); + maxTicksInAir = nbt.getInteger(Constants.NBT.PROJECTILE_MAX_TICKS_IN_AIR); + meteorStack = ItemStack.loadItemStackFromNBT(nbt); + } + + @Override + protected boolean canTriggerWalking() + { + return false; + } + + @Override + public boolean canBeCollidedWith() + { + return false; + } + + @Override + public void setThrower(Entity entity) + { + + } +} \ No newline at end of file diff --git a/src/main/java/WayofTime/bloodmagic/meteor/MeteorComponent.java b/src/main/java/WayofTime/bloodmagic/meteor/MeteorComponent.java new file mode 100644 index 00000000..9426a11e --- /dev/null +++ b/src/main/java/WayofTime/bloodmagic/meteor/MeteorComponent.java @@ -0,0 +1,41 @@ +package WayofTime.bloodmagic.meteor; + +import java.util.List; + +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.Setter; +import net.minecraft.block.Block; +import net.minecraft.block.state.IBlockState; +import net.minecraft.item.ItemBlock; +import net.minecraft.item.ItemStack; +import net.minecraftforge.oredict.OreDictionary; + +@Getter +@Setter +@AllArgsConstructor +public class MeteorComponent +{ + public int weight; + public String oreName; + + public IBlockState getStateFromOre() + { + List list = OreDictionary.getOres(oreName); + if (list != null && !list.isEmpty()) + { + for (ItemStack stack : list) + { + if (stack != null && stack.getItem() instanceof ItemBlock) + { + Block block = ((ItemBlock) stack.getItem()).getBlock(); + IBlockState state = block.getStateFromMeta(stack.getItemDamage()); + + return state; + } + } + } + + return null; + } +} diff --git a/src/main/java/WayofTime/bloodmagic/meteor/MeteorHolder.java b/src/main/java/WayofTime/bloodmagic/meteor/MeteorHolder.java new file mode 100644 index 00000000..14e294de --- /dev/null +++ b/src/main/java/WayofTime/bloodmagic/meteor/MeteorHolder.java @@ -0,0 +1,74 @@ +package WayofTime.bloodmagic.meteor; + +import java.util.ArrayList; +import java.util.List; +import java.util.Random; + +import lombok.AllArgsConstructor; +import net.minecraft.block.state.IBlockState; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.World; +import WayofTime.bloodmagic.util.Utils; + +@AllArgsConstructor +public class MeteorHolder +{ + public static Random rand = new Random(); + public List components = new ArrayList(); + + public float explosionStrength; + public int radius; + + public int maxWeight = 1000; + + public void generateMeteor(World world, BlockPos pos, IBlockState fillerBlock) + { + world.newExplosion(null, pos.getX(), pos.getY(), pos.getZ(), explosionStrength, true, true); + + for (int i = -radius; i <= radius; i++) + { + for (int j = -radius; j <= radius; j++) + { + for (int k = -radius; k <= radius; k++) + { + if (i * i + j * j + k * k > (radius + 0.5) * (radius + 0.5)) + { + continue; + } + + BlockPos newPos = pos.add(i, j, k); + IBlockState state = world.getBlockState(newPos); + + if (world.isAirBlock(newPos) || Utils.isBlockLiquid(state)) + { + IBlockState placedState = getRandomOreFromComponents(fillerBlock); + world.setBlockState(newPos, placedState); + } + } + } + } + } + + public IBlockState getRandomOreFromComponents(IBlockState fillerBlock) + { + int goal = rand.nextInt(maxWeight); + + for (MeteorComponent component : components) + { + goal -= component.getWeight(); + if (goal < 0) + { + IBlockState state = component.getStateFromOre(); + if (state != null) + { + return state; + } else + { + return fillerBlock; + } + } + } + + return fillerBlock; + } +} \ No newline at end of file diff --git a/src/main/java/WayofTime/bloodmagic/meteor/MeteorRegistry.java b/src/main/java/WayofTime/bloodmagic/meteor/MeteorRegistry.java new file mode 100644 index 00000000..67d53b61 --- /dev/null +++ b/src/main/java/WayofTime/bloodmagic/meteor/MeteorRegistry.java @@ -0,0 +1,53 @@ +package WayofTime.bloodmagic.meteor; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import net.minecraft.block.state.IBlockState; +import net.minecraft.item.ItemStack; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.World; +import WayofTime.bloodmagic.api.ItemStackWrapper; + +public class MeteorRegistry +{ + public static Map meteorMap = new HashMap(); + + public static void registerMeteor(ItemStack stack, MeteorHolder holder) + { + ItemStackWrapper wrapper = ItemStackWrapper.getHolder(stack); + if (wrapper != null) + { + meteorMap.put(wrapper, holder); + } + } + + public static void registerMeteor(ItemStack stack, List componentList, float explosionStrength, int radius, int maxWeight) + { + MeteorHolder holder = new MeteorHolder(componentList, explosionStrength, radius, maxWeight); + + registerMeteor(stack, holder); + } + + public static boolean hasMeteorForItem(ItemStack stack) + { + ItemStackWrapper wrapper = ItemStackWrapper.getHolder(stack); + return wrapper != null && meteorMap.containsKey(wrapper); + } + + public static MeteorHolder getMeteorForItem(ItemStack stack) + { + ItemStackWrapper wrapper = ItemStackWrapper.getHolder(stack); + return wrapper != null ? meteorMap.get(wrapper) : null; + } + + public static void generateMeteorForItem(ItemStack stack, World world, BlockPos pos, IBlockState fillerBlock) + { + MeteorHolder holder = getMeteorForItem(stack); + if (holder != null) + { + holder.generateMeteor(world, pos, fillerBlock); + } + } +} diff --git a/src/main/java/WayofTime/bloodmagic/ritual/RitualMeteor.java b/src/main/java/WayofTime/bloodmagic/ritual/RitualMeteor.java new file mode 100644 index 00000000..ba36402b --- /dev/null +++ b/src/main/java/WayofTime/bloodmagic/ritual/RitualMeteor.java @@ -0,0 +1,108 @@ +package WayofTime.bloodmagic.ritual; + +import java.util.ArrayList; +import java.util.List; + +import net.minecraft.entity.item.EntityItem; +import net.minecraft.item.ItemStack; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.World; +import WayofTime.bloodmagic.api.Constants; +import WayofTime.bloodmagic.api.ritual.AreaDescriptor; +import WayofTime.bloodmagic.api.ritual.EnumRuneType; +import WayofTime.bloodmagic.api.ritual.IMasterRitualStone; +import WayofTime.bloodmagic.api.ritual.Ritual; +import WayofTime.bloodmagic.api.ritual.RitualComponent; +import WayofTime.bloodmagic.entity.projectile.EntityMeteor; +import WayofTime.bloodmagic.meteor.MeteorRegistry; + +public class RitualMeteor extends Ritual +{ + public static final String ITEM_RANGE = "itemRange"; + + public RitualMeteor() + { + super("ritualMeteor", 0, 1000000, "ritual." + Constants.Mod.MODID + ".meteorRitual"); + addBlockRange(ITEM_RANGE, new AreaDescriptor.Rectangle(new BlockPos(0, 1, 0), 1)); + setMaximumVolumeAndDistanceOfRange(ITEM_RANGE, 0, 10, 10); + } + + @Override + public void performRitual(IMasterRitualStone masterRitualStone) + { + World world = masterRitualStone.getWorldObj(); + + BlockPos pos = masterRitualStone.getBlockPos(); + + AreaDescriptor itemDetectionRange = getBlockRange(ITEM_RANGE); + List itemList = world.getEntitiesWithinAABB(EntityItem.class, itemDetectionRange.getAABB(pos)); + + for (EntityItem entityItem : itemList) + { + ItemStack stack = entityItem.getEntityItem(); + if (MeteorRegistry.hasMeteorForItem(stack)) + { + EntityMeteor meteor = new EntityMeteor(world, pos.getX(), 260, pos.getZ(), 0, -0.1, 0); + meteor.setMeteorStack(stack.copy()); + world.spawnEntityInWorld(meteor); + + entityItem.setDead(); + + masterRitualStone.setActive(false); + } + } + } + + @Override + public int getRefreshTime() + { + return 1; + } + + @Override + public int getRefreshCost() + { + return 0; + } + + @Override + public ArrayList getComponents() + { + ArrayList components = new ArrayList(); + + this.addParallelRunes(components, 2, 0, EnumRuneType.FIRE); + this.addOffsetRunes(components, 3, 1, 0, EnumRuneType.AIR); + this.addOffsetRunes(components, 4, 2, 0, EnumRuneType.AIR); + this.addOffsetRunes(components, 5, 3, 0, EnumRuneType.DUSK); + this.addCornerRunes(components, 4, 0, EnumRuneType.DUSK); + + for (int i = 4; i <= 6; i++) + { + this.addParallelRunes(components, 4, 0, EnumRuneType.EARTH); + } + + this.addParallelRunes(components, 8, 0, EnumRuneType.EARTH); + this.addParallelRunes(components, 8, 1, EnumRuneType.EARTH); + this.addParallelRunes(components, 7, 1, EnumRuneType.EARTH); + this.addParallelRunes(components, 7, 2, EnumRuneType.EARTH); + this.addParallelRunes(components, 6, 2, EnumRuneType.FIRE); + this.addParallelRunes(components, 6, 3, EnumRuneType.WATER); + this.addParallelRunes(components, 5, 3, EnumRuneType.WATER); + this.addParallelRunes(components, 5, 4, EnumRuneType.AIR); + + this.addOffsetRunes(components, 1, 4, 4, EnumRuneType.AIR); + this.addParallelRunes(components, 4, 4, EnumRuneType.AIR); + + this.addOffsetRunes(components, 2, 4, 4, EnumRuneType.WATER); + this.addOffsetRunes(components, 2, 3, 4, EnumRuneType.FIRE); + this.addCornerRunes(components, 3, 4, EnumRuneType.FIRE); + + return components; + } + + @Override + public Ritual getNewCopy() + { + return new RitualMeteor(); + } +}