Testing the creation of hell
This commit is contained in:
WayofTime
parent
796e75b1f9
commit
a2b006105e
2587 changed files with 0 additions and 129617 deletions
|
|
@ -0,0 +1,195 @@
|
|||
package WayofTime.alchemicalWizardry.common.demonVillage;
|
||||
|
||||
import WayofTime.alchemicalWizardry.common.Int3;
|
||||
import cpw.mods.fml.common.registry.GameRegistry;
|
||||
import cpw.mods.fml.common.registry.GameRegistry.UniqueIdentifier;
|
||||
import net.minecraft.block.Block;
|
||||
import net.minecraft.block.BlockStairs;
|
||||
import net.minecraft.init.Blocks;
|
||||
import net.minecraft.world.World;
|
||||
import net.minecraftforge.common.util.ForgeDirection;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
public class BlockSet
|
||||
{
|
||||
protected String blockid;
|
||||
protected int[] metadata;
|
||||
protected List<Int3> positions;
|
||||
|
||||
public BlockSet()
|
||||
{
|
||||
this(Blocks.stone);
|
||||
}
|
||||
|
||||
public BlockSet(String blockid)
|
||||
{
|
||||
this.blockid = blockid;
|
||||
this.metadata = new int[4];
|
||||
positions = new ArrayList();
|
||||
}
|
||||
|
||||
public BlockSet(Block block)
|
||||
{
|
||||
this(BlockSet.getPairedIdForBlock(block));
|
||||
}
|
||||
|
||||
public BlockSet(Block block, int meta)
|
||||
{
|
||||
this(block);
|
||||
for (int i = 0; i < metadata.length; i++)
|
||||
{
|
||||
metadata[i] = meta;
|
||||
}
|
||||
if (block instanceof BlockStairs)
|
||||
{
|
||||
int[] northSet = new int[]{2, 3, 0, 1};
|
||||
int[] eastSet = new int[]{1, 0, 2, 3};
|
||||
int[] southSet = new int[]{3, 2, 1, 0};
|
||||
int[] westSet = new int[]{0, 1, 3, 2};
|
||||
int[] northUpSet = new int[]{6, 7, 4, 5};
|
||||
int[] eastUpSet = new int[]{5, 4, 6, 7};
|
||||
int[] southUpSet = new int[]{7, 6, 5, 4};
|
||||
int[] westUpSet = new int[]{4, 5, 7, 6};
|
||||
|
||||
switch (meta)
|
||||
{
|
||||
case 0:
|
||||
metadata = westSet;
|
||||
break;
|
||||
case 1:
|
||||
metadata = eastSet;
|
||||
break;
|
||||
case 2:
|
||||
metadata = northSet;
|
||||
break;
|
||||
case 3:
|
||||
metadata = southSet;
|
||||
break;
|
||||
case 4:
|
||||
metadata = westUpSet;
|
||||
break;
|
||||
case 5:
|
||||
metadata = eastUpSet;
|
||||
break;
|
||||
case 6:
|
||||
metadata = northUpSet;
|
||||
break;
|
||||
case 7:
|
||||
metadata = southUpSet;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public List<Int3> getPositions()
|
||||
{
|
||||
return positions;
|
||||
}
|
||||
|
||||
public void addPositionToBlock(int xOffset, int yOffset, int zOffset)
|
||||
{
|
||||
positions.add(new Int3(xOffset, yOffset, zOffset));
|
||||
}
|
||||
|
||||
public Block getBlock()
|
||||
{
|
||||
return this.getBlockForString(blockid);
|
||||
}
|
||||
|
||||
public static String getPairedIdForBlock(Block block)
|
||||
{
|
||||
UniqueIdentifier un = GameRegistry.findUniqueIdentifierFor(block);
|
||||
String name = "";
|
||||
|
||||
if (un != null)
|
||||
{
|
||||
name = un.modId + ":" + un.name;
|
||||
}
|
||||
|
||||
return name;
|
||||
}
|
||||
|
||||
public static Block getBlockForString(String str)
|
||||
{
|
||||
String[] parts = str.split(":");
|
||||
String modId = parts[0];
|
||||
String name = parts[1];
|
||||
return GameRegistry.findBlock(modId, name);
|
||||
}
|
||||
|
||||
public int getMetaForDirection(ForgeDirection dir)
|
||||
{
|
||||
if (metadata.length < 4)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
switch (dir)
|
||||
{
|
||||
case NORTH:
|
||||
return metadata[0];
|
||||
case SOUTH:
|
||||
return metadata[1];
|
||||
case WEST:
|
||||
return metadata[2];
|
||||
case EAST:
|
||||
return metadata[3];
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
public void buildAtIndex(World world, int xCoord, int yCoord, int zCoord, ForgeDirection dir, int index)
|
||||
{
|
||||
Block block = this.getBlock();
|
||||
if (index >= positions.size() || block == null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
Int3 position = positions.get(index);
|
||||
int xOff = position.xCoord;
|
||||
int yOff = position.yCoord;
|
||||
int zOff = position.zCoord;
|
||||
int meta = this.getMetaForDirection(dir);
|
||||
|
||||
switch (dir)
|
||||
{
|
||||
case NORTH:
|
||||
break;
|
||||
case SOUTH:
|
||||
xOff *= -1;
|
||||
zOff *= -1;
|
||||
break;
|
||||
case WEST:
|
||||
int temp = zOff;
|
||||
zOff = xOff * -1;
|
||||
xOff = temp;
|
||||
break;
|
||||
case EAST:
|
||||
int temp2 = zOff * -1;
|
||||
zOff = xOff;
|
||||
xOff = temp2;
|
||||
break;
|
||||
default:
|
||||
}
|
||||
|
||||
world.setBlock(xCoord + xOff, yCoord + yOff, zCoord + zOff, block, meta, 3);
|
||||
}
|
||||
|
||||
public void buildAll(World world, int xCoord, int yCoord, int zCoord, ForgeDirection dir)
|
||||
{
|
||||
for (int i = 0; i < positions.size(); i++)
|
||||
{
|
||||
this.buildAtIndex(world, xCoord, yCoord, zCoord, dir, i);
|
||||
}
|
||||
}
|
||||
|
||||
public boolean isContained(Block block, int defaultMeta)
|
||||
{
|
||||
Block thisBlock = this.getBlock();
|
||||
return thisBlock == null ? false : thisBlock.equals(block) && this.metadata[0] == defaultMeta;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,185 @@
|
|||
package WayofTime.alchemicalWizardry.common.demonVillage;
|
||||
|
||||
import WayofTime.alchemicalWizardry.ModBlocks;
|
||||
import WayofTime.alchemicalWizardry.common.Int3;
|
||||
import net.minecraft.block.Block;
|
||||
import net.minecraft.world.World;
|
||||
import net.minecraftforge.common.util.ForgeDirection;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
public class BuildingSchematic
|
||||
{
|
||||
public String name;
|
||||
public int doorX;
|
||||
public int doorZ;
|
||||
public int doorY;
|
||||
public int buildingTier;
|
||||
public int buildingType;
|
||||
public List<BlockSet> blockList;
|
||||
|
||||
public BuildingSchematic()
|
||||
{
|
||||
this("");
|
||||
}
|
||||
|
||||
public BuildingSchematic(String name)
|
||||
{
|
||||
this.name = name;
|
||||
blockList = new ArrayList();
|
||||
this.doorX = 0;
|
||||
this.doorZ = 0;
|
||||
this.doorY = 0;
|
||||
this.buildingTier = 0;
|
||||
this.buildingType = DemonBuilding.BUILDING_HOUSE;
|
||||
}
|
||||
|
||||
public void addBlockWithMeta(Block block, int meta, int xOffset, int yOffset, int zOffset)
|
||||
{
|
||||
for (BlockSet set : blockList)
|
||||
{
|
||||
if (set.isContained(block, meta))
|
||||
{
|
||||
set.addPositionToBlock(xOffset, yOffset, zOffset);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
BlockSet set = new BlockSet(block, meta);
|
||||
set.addPositionToBlock(xOffset, yOffset, zOffset);
|
||||
blockList.add(set);
|
||||
}
|
||||
|
||||
public void buildAll(World world, int xCoord, int yCoord, int zCoord, ForgeDirection dir)
|
||||
{
|
||||
for (BlockSet set : blockList)
|
||||
{
|
||||
set.buildAll(world, xCoord, yCoord, zCoord, dir);
|
||||
}
|
||||
}
|
||||
|
||||
public GridSpaceHolder createGSH()
|
||||
{
|
||||
GridSpaceHolder holder = new GridSpaceHolder();
|
||||
|
||||
for (BlockSet set : blockList)
|
||||
{
|
||||
for (Int3 coords : set.getPositions())
|
||||
{
|
||||
int gridX = (int) ((coords.xCoord + 2 * Math.signum(coords.xCoord)) / 5);
|
||||
int gridZ = (int) ((coords.zCoord + 2 * Math.signum(coords.zCoord)) / 5);
|
||||
|
||||
holder.setGridSpace(gridX, gridZ, new GridSpace(GridSpace.HOUSE, 0));
|
||||
}
|
||||
}
|
||||
|
||||
return holder;
|
||||
}
|
||||
|
||||
public Int3 getGridSpotOfDoor()
|
||||
{
|
||||
int gridX = (int) ((doorX + 2 * Math.signum(doorX)) / 5);
|
||||
int gridZ = (int) ((doorZ + 2 * Math.signum(doorZ)) / 5);
|
||||
|
||||
return new Int3(gridX, doorY, gridZ);
|
||||
}
|
||||
|
||||
public List<Int3> getGriddedPositions(ForgeDirection dir)
|
||||
{
|
||||
List<Int3> positionList = new ArrayList();
|
||||
|
||||
for (BlockSet blockSet : blockList)
|
||||
{
|
||||
for (Int3 pos : blockSet.getPositions())
|
||||
{
|
||||
int xOff = pos.xCoord;
|
||||
int zOff = pos.zCoord;
|
||||
|
||||
switch (dir)
|
||||
{
|
||||
case SOUTH:
|
||||
xOff *= -1;
|
||||
zOff *= -1;
|
||||
break;
|
||||
case WEST:
|
||||
int temp = zOff;
|
||||
zOff = xOff * -1;
|
||||
xOff = temp;
|
||||
break;
|
||||
case EAST:
|
||||
int temp2 = zOff * -1;
|
||||
zOff = xOff;
|
||||
xOff = temp2;
|
||||
break;
|
||||
default:
|
||||
}
|
||||
|
||||
Int3 nextPos = new Int3(xOff, 0, zOff);
|
||||
if (!positionList.contains(nextPos))
|
||||
{
|
||||
positionList.add(nextPos);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return positionList;
|
||||
}
|
||||
|
||||
public void destroyAllInField(World world, int xCoord, int yCoord, int zCoord, ForgeDirection dir)
|
||||
{
|
||||
GridSpaceHolder grid = this.createGSH(); //GridSpaceHolder is not aware of the buildings - need to use the schematic
|
||||
|
||||
List<Int3> positionList = getGriddedPositions(dir);
|
||||
|
||||
for (int i = this.getMinY(); i <= this.getMaxY(); i++)
|
||||
{
|
||||
for (Int3 pos : positionList)
|
||||
{
|
||||
Block block = world.getBlock(xCoord + pos.xCoord, yCoord + i, zCoord + pos.zCoord);
|
||||
if (block != ModBlocks.blockDemonPortal)
|
||||
{
|
||||
world.setBlockToAir(xCoord + pos.xCoord, yCoord + i, zCoord + pos.zCoord);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public int getMinY()
|
||||
{
|
||||
int min = 0;
|
||||
for (BlockSet set : blockList)
|
||||
{
|
||||
for (Int3 pos : set.getPositions())
|
||||
{
|
||||
if (pos.yCoord < min)
|
||||
{
|
||||
min = pos.yCoord;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return min;
|
||||
}
|
||||
|
||||
public int getMaxY()
|
||||
{
|
||||
int max = 0;
|
||||
for (BlockSet set : blockList)
|
||||
{
|
||||
for (Int3 pos : set.getPositions())
|
||||
{
|
||||
if (pos.yCoord > max)
|
||||
{
|
||||
max = pos.yCoord;
|
||||
}
|
||||
}
|
||||
}
|
||||
return max;
|
||||
}
|
||||
|
||||
public String getName()
|
||||
{
|
||||
return this.name;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,120 @@
|
|||
package WayofTime.alchemicalWizardry.common.demonVillage;
|
||||
|
||||
import WayofTime.alchemicalWizardry.common.Int3;
|
||||
import net.minecraft.world.World;
|
||||
import net.minecraftforge.common.util.ForgeDirection;
|
||||
|
||||
public class DemonBuilding
|
||||
{
|
||||
public static final int BUILDING_HOUSE = 0;
|
||||
public static final int BUILDING_PORTAL = 1;
|
||||
|
||||
public BuildingSchematic schematic;
|
||||
public GridSpaceHolder area;
|
||||
public int buildingTier;
|
||||
public int buildingType;
|
||||
public Int3 doorGridSpace;
|
||||
|
||||
public DemonBuilding(BuildingSchematic schematic)
|
||||
{
|
||||
this.schematic = schematic;
|
||||
this.buildingType = schematic.buildingType;
|
||||
this.buildingTier = schematic.buildingTier;
|
||||
this.area = this.createGSHForSchematic(schematic);
|
||||
this.doorGridSpace = schematic.getGridSpotOfDoor();
|
||||
}
|
||||
|
||||
public String getName()
|
||||
{
|
||||
return schematic.getName();
|
||||
}
|
||||
|
||||
public boolean isValid(GridSpaceHolder master, int gridX, int gridZ, ForgeDirection dir)
|
||||
{
|
||||
return area.doesContainAll(master, gridX, gridZ, dir);
|
||||
}
|
||||
|
||||
public void buildAll(World world, int xCoord, int yCoord, int zCoord, ForgeDirection dir)
|
||||
{
|
||||
schematic.buildAll(world, xCoord, yCoord, zCoord, dir);
|
||||
}
|
||||
|
||||
public void setAllGridSpaces(int xInit, int zInit, int yLevel, ForgeDirection dir, int type, GridSpaceHolder master)
|
||||
{
|
||||
area.setAllGridSpaces(xInit, zInit, yLevel, dir, type, master);
|
||||
}
|
||||
|
||||
public GridSpaceHolder createGSHForSchematic(BuildingSchematic scheme)
|
||||
{
|
||||
switch (this.buildingType)
|
||||
{
|
||||
case DemonBuilding.BUILDING_HOUSE:
|
||||
return scheme.createGSH();
|
||||
case DemonBuilding.BUILDING_PORTAL:
|
||||
|
||||
}
|
||||
return scheme.createGSH();
|
||||
}
|
||||
|
||||
public Int3 getDoorSpace(ForgeDirection dir)
|
||||
{
|
||||
int x = 0;
|
||||
int z = 0;
|
||||
switch (dir)
|
||||
{
|
||||
case SOUTH:
|
||||
x = -doorGridSpace.xCoord;
|
||||
z = -doorGridSpace.zCoord;
|
||||
break;
|
||||
case WEST:
|
||||
x = doorGridSpace.zCoord;
|
||||
z = -doorGridSpace.xCoord;
|
||||
break;
|
||||
case EAST:
|
||||
x = -doorGridSpace.zCoord;
|
||||
z = doorGridSpace.xCoord;
|
||||
break;
|
||||
default:
|
||||
x = doorGridSpace.xCoord;
|
||||
z = doorGridSpace.zCoord;
|
||||
break;
|
||||
}
|
||||
|
||||
return new Int3(x, doorGridSpace.yCoord, z);
|
||||
}
|
||||
|
||||
public Int3 getGridOffsetFromRoad(ForgeDirection sideOfRoad, int yLevel)
|
||||
{
|
||||
Int3 doorSpace = this.getDoorSpace(sideOfRoad);
|
||||
int x = doorSpace.xCoord;
|
||||
int z = doorSpace.zCoord;
|
||||
|
||||
switch (sideOfRoad)
|
||||
{
|
||||
case SOUTH:
|
||||
z++;
|
||||
break;
|
||||
case EAST:
|
||||
x++;
|
||||
break;
|
||||
case WEST:
|
||||
x--;
|
||||
break;
|
||||
default:
|
||||
z--;
|
||||
break;
|
||||
}
|
||||
|
||||
return new Int3(x, yLevel, z);
|
||||
}
|
||||
|
||||
public void destroyAllInField(World world, int xCoord, int yCoord, int zCoord, ForgeDirection dir)
|
||||
{
|
||||
schematic.destroyAllInField(world, xCoord, yCoord, zCoord, dir);
|
||||
}
|
||||
|
||||
public int getNumberOfGridSpaces()
|
||||
{
|
||||
return area.getNumberOfGridSpaces();
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,22 @@
|
|||
package WayofTime.alchemicalWizardry.common.demonVillage;
|
||||
|
||||
import net.minecraft.world.World;
|
||||
|
||||
public class DemonCrosspath
|
||||
{
|
||||
private int xCoord;
|
||||
private int yLevel;
|
||||
private int zCoord;
|
||||
|
||||
public DemonCrosspath(int xCoord, int yLevel, int zCoord)
|
||||
{
|
||||
this.xCoord = xCoord;
|
||||
this.yLevel = yLevel;
|
||||
this.zCoord = zCoord;
|
||||
}
|
||||
|
||||
public void createCrosspath(World world)
|
||||
{
|
||||
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,135 @@
|
|||
package WayofTime.alchemicalWizardry.common.demonVillage;
|
||||
|
||||
import WayofTime.alchemicalWizardry.ModBlocks;
|
||||
import WayofTime.alchemicalWizardry.common.Int3;
|
||||
import net.minecraft.block.Block;
|
||||
import net.minecraft.block.material.Material;
|
||||
import net.minecraft.world.World;
|
||||
import net.minecraftforge.common.util.ForgeDirection;
|
||||
|
||||
public class DemonVillagePath
|
||||
{
|
||||
public int xi;
|
||||
public int yi;
|
||||
public int zi;
|
||||
public ForgeDirection dir;
|
||||
public int length;
|
||||
|
||||
public DemonVillagePath(int xi, int yi, int zi, ForgeDirection dir, int length)
|
||||
{
|
||||
this.xi = xi;
|
||||
this.yi = yi;
|
||||
this.zi = zi;
|
||||
this.dir = dir;
|
||||
this.length = length;
|
||||
}
|
||||
|
||||
public Int3 constructFullPath(World world, int clearance, Block block, int meta)
|
||||
{
|
||||
int xPos = this.xi;
|
||||
int yPos = this.yi;
|
||||
int zPos = this.zi;
|
||||
int rad = this.getRoadRadius();
|
||||
|
||||
for (int i = -rad; i <= rad; i++)
|
||||
{
|
||||
this.constructPartialPath(world, clearance, block, meta, xPos - rad * dir.offsetX + i * dir.offsetZ, yPos, zPos - rad * dir.offsetZ + i * dir.offsetX, dir, length + 2 * rad);
|
||||
}
|
||||
|
||||
return this.getFinalLocation(world, clearance);
|
||||
}
|
||||
|
||||
public void constructPartialPath(World world, int clearance, Block roadBlock, int meta, int xi, int yi, int zi, ForgeDirection dir, int length)
|
||||
{
|
||||
int xPos = xi;
|
||||
int yPos = yi;
|
||||
int zPos = zi;
|
||||
|
||||
for (int i = 0; i < length; i++)
|
||||
{
|
||||
int xOffset = i * dir.offsetX;
|
||||
int zOffset = i * dir.offsetZ;
|
||||
|
||||
for (int yOffset = 0; yOffset <= clearance; yOffset++)
|
||||
{
|
||||
int sign = 1;
|
||||
|
||||
Block block1 = world.getBlock(xPos + xOffset, yPos + sign * yOffset, zPos + zOffset);
|
||||
Block highBlock1 = world.getBlock(xPos + xOffset, yPos + sign * yOffset + 1, zPos + zOffset);
|
||||
|
||||
if (!block1.isReplaceable(world, xPos + xOffset, yPos + sign * yOffset, zPos + zOffset) && this.isBlockReplaceable(block1) && highBlock1.isReplaceable(world, xPos + xOffset, yPos + sign * yOffset + 1, zPos + zOffset))
|
||||
{
|
||||
world.setBlock(xPos + xOffset, yPos + sign * yOffset, zPos + zOffset, roadBlock, meta, 3);
|
||||
yPos += sign * yOffset;
|
||||
break;
|
||||
} else
|
||||
{
|
||||
sign = -1;
|
||||
Block block2 = world.getBlock(xPos + xOffset, yPos + sign * yOffset, zPos + zOffset);
|
||||
Block highBlock2 = world.getBlock(xPos + xOffset, yPos + sign * yOffset + 1, zPos + zOffset);
|
||||
|
||||
if (!block2.isReplaceable(world, xPos + xOffset, yPos + sign * yOffset, zPos + zOffset) && this.isBlockReplaceable(block1) && highBlock2.isReplaceable(world, xPos + xOffset, yPos + sign * yOffset + 1, zPos + zOffset))
|
||||
{
|
||||
world.setBlock(xPos + xOffset, yPos + sign * yOffset, zPos + zOffset, roadBlock, meta, 3);
|
||||
yPos += sign * yOffset;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public Int3 getFinalLocation(World world, int clearance)
|
||||
{
|
||||
int xPos = xi;
|
||||
int yPos = yi;
|
||||
int zPos = zi;
|
||||
|
||||
for (int i = 0; i < length; i++)
|
||||
{
|
||||
int xOffset = i * dir.offsetX;
|
||||
int zOffset = i * dir.offsetZ;
|
||||
|
||||
for (int yOffset = 0; yOffset <= clearance; yOffset++)
|
||||
{
|
||||
int sign = 1;
|
||||
|
||||
Block block1 = world.getBlock(xPos + xOffset, yPos + sign * yOffset, zPos + zOffset);
|
||||
Block highBlock1 = world.getBlock(xPos + xOffset, yPos + sign * yOffset + 1, zPos + zOffset);
|
||||
|
||||
if (!block1.isReplaceable(world, xPos + xOffset, yPos + sign * yOffset, zPos + zOffset) && this.isBlockReplaceable(block1) && highBlock1.isReplaceable(world, xPos + xOffset, yPos + sign * yOffset + 1, zPos + zOffset))
|
||||
{
|
||||
yPos += sign * yOffset;
|
||||
break;
|
||||
} else
|
||||
{
|
||||
sign = -1;
|
||||
Block block2 = world.getBlock(xPos + xOffset, yPos + sign * yOffset, zPos + zOffset);
|
||||
Block highBlock2 = world.getBlock(xPos + xOffset, yPos + sign * yOffset + 1, zPos + zOffset);
|
||||
|
||||
if (!block2.isReplaceable(world, xPos + xOffset, yPos + sign * yOffset, zPos + zOffset) && this.isBlockReplaceable(block1) && highBlock2.isReplaceable(world, xPos + xOffset, yPos + sign * yOffset + 1, zPos + zOffset))
|
||||
{
|
||||
yPos += sign * yOffset;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return new Int3(xPos, yPos, zPos);
|
||||
}
|
||||
|
||||
public int getRoadRadius()
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
public boolean isBlockReplaceable(Block block)
|
||||
{
|
||||
if (block.getMaterial() == Material.leaves || block.getMaterial() == Material.vine)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
return !block.equals(ModBlocks.blockDemonPortal);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,77 @@
|
|||
package WayofTime.alchemicalWizardry.common.demonVillage;
|
||||
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
|
||||
public class GridSpace
|
||||
{
|
||||
public static final int EMPTY = 0;
|
||||
public static final int MAIN_PORTAL = 1;
|
||||
public static final int MINI_PORTAL = 2;
|
||||
public static final int ROAD = 3;
|
||||
public static final int CROSSROAD = 4;
|
||||
public static final int HOUSE = 5;
|
||||
|
||||
private int yLevel;
|
||||
private int type;
|
||||
|
||||
public GridSpace()
|
||||
{
|
||||
this(EMPTY, -1);
|
||||
}
|
||||
|
||||
public GridSpace(int type, int yLevel)
|
||||
{
|
||||
this.type = type;
|
||||
this.yLevel = yLevel;
|
||||
}
|
||||
|
||||
public int getGridType()
|
||||
{
|
||||
return this.type;
|
||||
}
|
||||
|
||||
public void setGridType(int type)
|
||||
{
|
||||
this.type = type;
|
||||
}
|
||||
|
||||
public int getYLevel()
|
||||
{
|
||||
return this.yLevel;
|
||||
}
|
||||
|
||||
public void setYLevel(int yLevel)
|
||||
{
|
||||
this.yLevel = yLevel;
|
||||
}
|
||||
|
||||
public boolean isEmpty()
|
||||
{
|
||||
return type == this.EMPTY;
|
||||
}
|
||||
|
||||
public static GridSpace getGridFromTag(NBTTagCompound tag)
|
||||
{
|
||||
return new GridSpace(tag.getInteger("type"), tag.getInteger("yLevel"));
|
||||
}
|
||||
|
||||
public NBTTagCompound getTag()
|
||||
{
|
||||
NBTTagCompound tag = new NBTTagCompound();
|
||||
|
||||
tag.setInteger("type", type);
|
||||
tag.setInteger("yLevel", yLevel);
|
||||
|
||||
return tag;
|
||||
}
|
||||
|
||||
public boolean isRoadSegment()
|
||||
{
|
||||
return type == this.ROAD || type == this.CROSSROAD;
|
||||
}
|
||||
|
||||
public boolean isBuilding()
|
||||
{
|
||||
return type == this.HOUSE;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,309 @@
|
|||
package WayofTime.alchemicalWizardry.common.demonVillage;
|
||||
|
||||
import WayofTime.alchemicalWizardry.ModBlocks;
|
||||
import net.minecraft.block.Block;
|
||||
import net.minecraft.world.World;
|
||||
import net.minecraftforge.common.util.ForgeDirection;
|
||||
|
||||
public class GridSpaceHolder
|
||||
{
|
||||
public GridSpace[][] area;
|
||||
public int negXRadius; //These variables indicate how much the grid has expanded from the 1x1
|
||||
public int posXRadius; //matrix in each direction
|
||||
public int negZRadius;
|
||||
public int posZRadius;
|
||||
|
||||
public GridSpaceHolder()
|
||||
{
|
||||
area = new GridSpace[1][1];
|
||||
area[0][0] = new GridSpace();
|
||||
}
|
||||
|
||||
public void expandAreaInNegX()
|
||||
{
|
||||
GridSpace[][] newGrid = new GridSpace[negXRadius + posXRadius + 2][negZRadius + posZRadius + 1];
|
||||
for (int i = 0; i <= negZRadius + posZRadius; i++)
|
||||
{
|
||||
newGrid[0][i] = new GridSpace();
|
||||
}
|
||||
|
||||
for (int i = 0; i <= negXRadius + posXRadius; i++)
|
||||
{
|
||||
for (int j = 0; j <= negZRadius + posZRadius; j++)
|
||||
{
|
||||
newGrid[i + 1][j] = area[i][j];
|
||||
}
|
||||
}
|
||||
|
||||
area = newGrid;
|
||||
negXRadius += 1;
|
||||
}
|
||||
|
||||
public void expandAreaInPosX()
|
||||
{
|
||||
GridSpace[][] newGrid = new GridSpace[negXRadius + posXRadius + 2][negZRadius + posZRadius + 1];
|
||||
|
||||
for (int i = 0; i <= negZRadius + posZRadius; i++)
|
||||
{
|
||||
newGrid[negXRadius + posXRadius + 1][i] = new GridSpace();
|
||||
}
|
||||
|
||||
for (int i = 0; i <= negXRadius + posXRadius; i++)
|
||||
{
|
||||
for (int j = 0; j <= negZRadius + posZRadius; j++)
|
||||
{
|
||||
newGrid[i][j] = area[i][j];
|
||||
}
|
||||
}
|
||||
|
||||
area = newGrid;
|
||||
posXRadius += 1;
|
||||
}
|
||||
|
||||
public void expandAreaInNegZ()
|
||||
{
|
||||
GridSpace[][] newGrid = new GridSpace[negXRadius + posXRadius + 1][negZRadius + posZRadius + 2];
|
||||
|
||||
System.out.println("x " + newGrid.length + "z " + newGrid[0].length);
|
||||
|
||||
for (int i = 0; i <= negXRadius + posXRadius; i++)
|
||||
{
|
||||
newGrid[i][0] = new GridSpace();
|
||||
}
|
||||
|
||||
for (int i = 0; i <= negXRadius + posXRadius; i++)
|
||||
{
|
||||
for (int j = 0; j <= negZRadius + posZRadius; j++)
|
||||
{
|
||||
newGrid[i][j + 1] = area[i][j];
|
||||
}
|
||||
}
|
||||
|
||||
area = newGrid;
|
||||
negZRadius += 1;
|
||||
}
|
||||
|
||||
public void expandAreaInPosZ()
|
||||
{
|
||||
GridSpace[][] newGrid = new GridSpace[negXRadius + posXRadius + 1][negZRadius + posZRadius + 2];
|
||||
|
||||
for (int i = 0; i <= negXRadius + posXRadius; i++)
|
||||
{
|
||||
newGrid[i][negZRadius + posZRadius + 1] = new GridSpace();
|
||||
}
|
||||
|
||||
for (int i = 0; i <= negXRadius + posXRadius; i++)
|
||||
{
|
||||
for (int j = 0; j <= negZRadius + posZRadius; j++)
|
||||
{
|
||||
newGrid[i][j] = area[i][j];
|
||||
}
|
||||
}
|
||||
|
||||
area = newGrid;
|
||||
posZRadius += 1;
|
||||
}
|
||||
|
||||
public GridSpace getGridSpace(int x, int z)
|
||||
{
|
||||
if (x > posXRadius || x < -negXRadius || z > posZRadius || z < -negZRadius)
|
||||
{
|
||||
return new GridSpace();
|
||||
} else
|
||||
{
|
||||
return (area[x + negXRadius][z + negZRadius]);
|
||||
}
|
||||
}
|
||||
|
||||
public void setGridSpace(int x, int z, GridSpace space)
|
||||
{
|
||||
if (x > posXRadius)
|
||||
{
|
||||
this.expandAreaInPosX();
|
||||
this.setGridSpace(x, z, space);
|
||||
return;
|
||||
} else if (x < -negXRadius)
|
||||
{
|
||||
this.expandAreaInNegX();
|
||||
this.setGridSpace(x, z, space);
|
||||
return;
|
||||
} else if (z > posZRadius)
|
||||
{
|
||||
this.expandAreaInPosZ();
|
||||
this.setGridSpace(x, z, space);
|
||||
return;
|
||||
} else if (z < -negZRadius)
|
||||
{
|
||||
this.expandAreaInNegZ();
|
||||
this.setGridSpace(x, z, space);
|
||||
return;
|
||||
} else
|
||||
{
|
||||
area[x + negXRadius][z + negZRadius] = space;
|
||||
}
|
||||
}
|
||||
|
||||
public boolean doesContainAll(GridSpaceHolder master, int xInit, int zInit, ForgeDirection dir)
|
||||
{
|
||||
if (master != null)
|
||||
{
|
||||
System.out.println("negXRadius: " + negXRadius + " posXRadius: " + posXRadius + " negZRadius: " + negZRadius + " posZRadius: " + posZRadius);
|
||||
for (int i = -negXRadius; i <= posXRadius; i++)
|
||||
{
|
||||
for (int j = -negZRadius; j <= posZRadius; j++)
|
||||
{
|
||||
GridSpace thisSpace = this.getGridSpace(i, j);
|
||||
if (thisSpace.isEmpty())
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
System.out.println("x: " + i + " z: " + j);
|
||||
|
||||
int xOff = 0;
|
||||
int zOff = 0;
|
||||
|
||||
switch (dir)
|
||||
{
|
||||
case SOUTH:
|
||||
xOff = -i;
|
||||
zOff = -j;
|
||||
break;
|
||||
case WEST:
|
||||
xOff = j;
|
||||
zOff = -i;
|
||||
break;
|
||||
case EAST:
|
||||
xOff = -j;
|
||||
zOff = i;
|
||||
break;
|
||||
default:
|
||||
xOff = i;
|
||||
zOff = j;
|
||||
break;
|
||||
}
|
||||
if (!master.getGridSpace(xInit + xOff, zInit + zOff).isEmpty())
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public void setAllGridSpaces(int xInit, int zInit, int yLevel, ForgeDirection dir, int type, GridSpaceHolder master)
|
||||
{
|
||||
System.out.println("Grid space selected: (" + xInit + "," + zInit + ")");
|
||||
if (master != null)
|
||||
{
|
||||
for (int i = -negXRadius; i <= posXRadius; i++)
|
||||
{
|
||||
for (int j = -negZRadius; j <= posZRadius; j++)
|
||||
{
|
||||
GridSpace thisSpace = this.getGridSpace(i, j);
|
||||
if (thisSpace.isEmpty())
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
int xOff = 0;
|
||||
int zOff = 0;
|
||||
|
||||
switch (dir)
|
||||
{
|
||||
case SOUTH:
|
||||
xOff = -i;
|
||||
zOff = -j;
|
||||
break;
|
||||
case WEST:
|
||||
xOff = j;
|
||||
zOff = -i;
|
||||
break;
|
||||
case EAST:
|
||||
xOff = -j;
|
||||
zOff = i;
|
||||
break;
|
||||
default:
|
||||
xOff = i;
|
||||
zOff = j;
|
||||
break;
|
||||
}
|
||||
|
||||
System.out.println("Grid space (" + (xInit + xOff) + "," + (zInit + zOff) + ")");
|
||||
|
||||
master.setGridSpace(xInit + xOff, zInit + zOff, new GridSpace(type, yLevel));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void destroyAllInGridSpaces(World world, int xCoord, int yCoord, int zCoord, ForgeDirection dir)
|
||||
{
|
||||
for (int i = -negXRadius; i <= posXRadius; i++)
|
||||
{
|
||||
for (int j = -negZRadius; j <= posZRadius; j++)
|
||||
{
|
||||
GridSpace thisSpace = this.getGridSpace(i, j);
|
||||
if (thisSpace.isEmpty())
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
int xOff = 0;
|
||||
int zOff = 0;
|
||||
|
||||
switch (dir)
|
||||
{
|
||||
case SOUTH:
|
||||
xOff = -i;
|
||||
zOff = -j;
|
||||
break;
|
||||
case WEST:
|
||||
xOff = j;
|
||||
zOff = -i;
|
||||
break;
|
||||
case EAST:
|
||||
xOff = -j;
|
||||
zOff = i;
|
||||
break;
|
||||
default:
|
||||
xOff = i;
|
||||
zOff = j;
|
||||
break;
|
||||
}
|
||||
|
||||
for (int l = -2; l <= 2; l++)
|
||||
{
|
||||
for (int m = -2; m <= 2; m++)
|
||||
{
|
||||
Block block = world.getBlock(xCoord + xOff * 5 + l, yCoord, zCoord + zOff * 5 + m);
|
||||
if (block == ModBlocks.blockDemonPortal)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
world.setBlockToAir(xCoord + xOff * 5 + l, yCoord, zCoord + zOff * 5 + m);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public int getNumberOfGridSpaces()
|
||||
{
|
||||
int num = 0;
|
||||
for (int i = -this.negXRadius; i <= this.posXRadius; i++)
|
||||
{
|
||||
for (int j = -this.negZRadius; j <= this.posZRadius; j++)
|
||||
{
|
||||
if (!this.getGridSpace(i, j).isEmpty())
|
||||
{
|
||||
num++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return num;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
package WayofTime.alchemicalWizardry.common.demonVillage;
|
||||
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
|
||||
public class TileBlockSet extends BlockSet
|
||||
{
|
||||
public NBTTagCompound tag;
|
||||
}
|
||||
|
|
@ -0,0 +1,63 @@
|
|||
package WayofTime.alchemicalWizardry.common.demonVillage.ai;
|
||||
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
|
||||
import net.minecraft.entity.EntityCreature;
|
||||
import net.minecraft.entity.ai.EntityAIHurtByTarget;
|
||||
import net.minecraft.tileentity.TileEntity;
|
||||
import net.minecraft.util.AxisAlignedBB;
|
||||
import WayofTime.alchemicalWizardry.common.Int3;
|
||||
import WayofTime.alchemicalWizardry.common.demonVillage.demonHoard.demon.IHoardDemon;
|
||||
import WayofTime.alchemicalWizardry.common.demonVillage.tileEntity.TEDemonPortal;
|
||||
|
||||
public class EntityDemonAIHurtByTarget extends EntityAIHurtByTarget
|
||||
{
|
||||
boolean entityCallsForHelp;
|
||||
private int revengeTimer;
|
||||
|
||||
public EntityDemonAIHurtByTarget(EntityCreature demon, boolean callsForHelp)
|
||||
{
|
||||
super(demon, callsForHelp);
|
||||
this.entityCallsForHelp = callsForHelp;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void startExecuting()
|
||||
{
|
||||
this.taskOwner.setAttackTarget(this.taskOwner.getAITarget());
|
||||
this.revengeTimer = this.taskOwner.func_142015_aE();
|
||||
|
||||
if (this.entityCallsForHelp && this.taskOwner instanceof IHoardDemon)
|
||||
{
|
||||
Int3 portalPosition = ((IHoardDemon)this.taskOwner).getPortalLocation();
|
||||
if(portalPosition == null)
|
||||
{
|
||||
super.startExecuting();
|
||||
return;
|
||||
}
|
||||
|
||||
TileEntity portal = this.taskOwner.worldObj.getTileEntity(portalPosition.xCoord, portalPosition.yCoord, portalPosition.zCoord);
|
||||
if(portal instanceof TEDemonPortal)
|
||||
{
|
||||
((TEDemonPortal) portal).notifyDemons(taskOwner, this.taskOwner.getAITarget());
|
||||
}
|
||||
|
||||
// double d0 = this.getTargetDistance();
|
||||
// List list = this.taskOwner.worldObj.getEntitiesWithinAABB(this.taskOwner.getClass(), AxisAlignedBB.getBoundingBox(this.taskOwner.posX, this.taskOwner.posY, this.taskOwner.posZ, this.taskOwner.posX + 1.0D, this.taskOwner.posY + 1.0D, this.taskOwner.posZ + 1.0D).expand(d0, 10.0D, d0));
|
||||
// Iterator iterator = list.iterator();
|
||||
//
|
||||
// while (iterator.hasNext())
|
||||
// {
|
||||
// EntityCreature entitycreature = (EntityCreature)iterator.next();
|
||||
//
|
||||
// if (this.taskOwner != entitycreature && entitycreature.getAttackTarget() == null && !entitycreature.isOnSameTeam(this.taskOwner.getAITarget()))
|
||||
// {
|
||||
// entitycreature.setAttackTarget(this.taskOwner.getAITarget());
|
||||
// }
|
||||
// }
|
||||
}
|
||||
|
||||
super.startExecuting();
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
package WayofTime.alchemicalWizardry.common.demonVillage.demonHoard;
|
||||
|
||||
import net.minecraft.world.World;
|
||||
|
||||
public abstract class DemonHoardPacket
|
||||
{
|
||||
public DemonHoardPacket()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
public abstract int summonDemons(World world, int x, int y, int z, DemonType type, int tier);
|
||||
|
||||
public abstract boolean canFitType(DemonType type);
|
||||
|
||||
public abstract float getRelativeChance(DemonType type, int tier);
|
||||
}
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
package WayofTime.alchemicalWizardry.common.demonVillage.demonHoard;
|
||||
|
||||
import net.minecraft.entity.Entity;
|
||||
import net.minecraft.world.World;
|
||||
import WayofTime.alchemicalWizardry.common.entity.mob.EntityFallenAngel;
|
||||
|
||||
public class DemonPacketAngel extends DemonHoardPacket
|
||||
{
|
||||
@Override
|
||||
public boolean canFitType(DemonType type)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public float getRelativeChance(DemonType type, int tier)
|
||||
{
|
||||
return 1.0f;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int summonDemons(World world, int x, int y, int z, DemonType type, int tier)
|
||||
{
|
||||
Entity entity = new EntityFallenAngel(world);
|
||||
entity.setPosition(x, y, z);
|
||||
|
||||
world.spawnEntityInWorld(entity);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,80 @@
|
|||
package WayofTime.alchemicalWizardry.common.demonVillage.demonHoard;
|
||||
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
import java.util.Map.Entry;
|
||||
|
||||
import net.minecraft.world.World;
|
||||
|
||||
public class DemonPacketRegistry
|
||||
{
|
||||
public static Map<String, DemonHoardPacket> packetMap = new HashMap();
|
||||
|
||||
public static boolean registerDemonPacket(String string, DemonHoardPacket packet)
|
||||
{
|
||||
if(!packetMap.containsValue(string) && packet != null)
|
||||
{
|
||||
packetMap.put(string, packet);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
public static String getDemonPacketName(DemonType type, int tier)
|
||||
{
|
||||
float totalChance = 0;
|
||||
|
||||
for(Entry<String, DemonHoardPacket> entry : packetMap.entrySet())
|
||||
{
|
||||
DemonHoardPacket packet = entry.getValue();
|
||||
|
||||
if(packet == null)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
totalChance += packet.getRelativeChance(type, tier);
|
||||
}
|
||||
|
||||
for(Entry<String, DemonHoardPacket> entry : packetMap.entrySet())
|
||||
{
|
||||
DemonHoardPacket packet = entry.getValue();
|
||||
|
||||
if(packet == null)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
float relativeChance = packet.getRelativeChance(type, tier);
|
||||
|
||||
if(relativeChance >= totalChance)
|
||||
{
|
||||
return entry.getKey();
|
||||
}else
|
||||
{
|
||||
totalChance -= relativeChance;
|
||||
}
|
||||
}
|
||||
|
||||
return "";
|
||||
}
|
||||
|
||||
public static int spawnDemons(World world, int x, int y, int z, DemonType type, int tier)
|
||||
{
|
||||
return spawnDemons(world, x, y, z, getDemonPacketName(type, tier), type, tier);
|
||||
}
|
||||
|
||||
public static int spawnDemons(World world, int x, int y, int z, String name, DemonType type, int tier)
|
||||
{
|
||||
DemonHoardPacket packet = packetMap.get(name);
|
||||
|
||||
if(packet != null)
|
||||
{
|
||||
return packet.summonDemons(world, x, y, z, type, tier);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
package WayofTime.alchemicalWizardry.common.demonVillage.demonHoard;
|
||||
|
||||
public enum DemonType
|
||||
{
|
||||
FIRE,
|
||||
WATER,
|
||||
ICE,
|
||||
WIND
|
||||
}
|
||||
|
|
@ -0,0 +1,416 @@
|
|||
package WayofTime.alchemicalWizardry.common.demonVillage.demonHoard.demon;
|
||||
|
||||
import net.minecraft.entity.Entity;
|
||||
import net.minecraft.entity.EntityLivingBase;
|
||||
import net.minecraft.entity.IRangedAttackMob;
|
||||
import net.minecraft.entity.SharedMonsterAttributes;
|
||||
import net.minecraft.entity.ai.EntityAIArrowAttack;
|
||||
import net.minecraft.entity.ai.EntityAIAttackOnCollide;
|
||||
import net.minecraft.entity.ai.EntityAIFollowOwner;
|
||||
import net.minecraft.entity.ai.EntityAIHurtByTarget;
|
||||
import net.minecraft.entity.ai.EntityAILookIdle;
|
||||
import net.minecraft.entity.ai.EntityAIOwnerHurtByTarget;
|
||||
import net.minecraft.entity.ai.EntityAIOwnerHurtTarget;
|
||||
import net.minecraft.entity.ai.EntityAISwimming;
|
||||
import net.minecraft.entity.ai.EntityAIWander;
|
||||
import net.minecraft.entity.ai.EntityAIWatchClosest;
|
||||
import net.minecraft.entity.monster.EntityCreeper;
|
||||
import net.minecraft.entity.monster.EntityGhast;
|
||||
import net.minecraft.entity.passive.EntityAnimal;
|
||||
import net.minecraft.entity.passive.EntityHorse;
|
||||
import net.minecraft.entity.player.EntityPlayer;
|
||||
import net.minecraft.item.ItemFood;
|
||||
import net.minecraft.item.ItemStack;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
import net.minecraft.pathfinding.PathEntity;
|
||||
import net.minecraft.world.World;
|
||||
import WayofTime.alchemicalWizardry.ModItems;
|
||||
import WayofTime.alchemicalWizardry.common.EntityAITargetAggro;
|
||||
import WayofTime.alchemicalWizardry.common.Int3;
|
||||
import WayofTime.alchemicalWizardry.common.entity.mob.EntityDemon;
|
||||
import WayofTime.alchemicalWizardry.common.entity.projectile.HolyProjectile;
|
||||
import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
|
||||
|
||||
public class EntityMinorDemonGrunt extends EntityDemon implements IRangedAttackMob, IHoardDemon
|
||||
{
|
||||
private EntityAIArrowAttack aiArrowAttack = new EntityAIArrowAttack(this, 1.0D, 40, 40, 15.0F);
|
||||
private EntityAIAttackOnCollide aiAttackOnCollide = new EntityAIAttackOnCollide(this, EntityPlayer.class, 1.2D, false);
|
||||
|
||||
private boolean isAngry = false;
|
||||
private Int3 demonPortal;
|
||||
|
||||
private static float maxTamedHealth = 50.0F;
|
||||
private static float maxUntamedHealth = 50.0F;
|
||||
|
||||
public EntityMinorDemonGrunt(World par1World)
|
||||
{
|
||||
super(par1World, "GruntString");
|
||||
this.setSize(0.7F, 1.8F);
|
||||
this.getNavigator().setAvoidsWater(true);
|
||||
this.tasks.addTask(1, new EntityAISwimming(this));
|
||||
this.tasks.addTask(2, this.aiSit);
|
||||
this.tasks.addTask(3, new EntityAIFollowOwner(this, 1.0D, 10.0F, 2.0F));
|
||||
this.tasks.addTask(4, new EntityAIWander(this, 1.0D));
|
||||
this.tasks.addTask(5, new EntityAIWatchClosest(this, EntityPlayer.class, 8.0F));
|
||||
this.tasks.addTask(6, new EntityAILookIdle(this));
|
||||
this.targetTasks.addTask(1, new EntityAIOwnerHurtByTarget(this));
|
||||
this.targetTasks.addTask(2, new EntityAIOwnerHurtTarget(this));
|
||||
this.targetTasks.addTask(3, new EntityAIHurtByTarget(this, true));
|
||||
this.targetTasks.addTask(4, new EntityAITargetAggro(this, EntityPlayer.class, 0, false));
|
||||
this.setAggro(false);
|
||||
this.setTamed(false);
|
||||
|
||||
demonPortal = new Int3(0,0,0);
|
||||
|
||||
if (par1World != null && !par1World.isRemote)
|
||||
{
|
||||
this.setCombatTask();
|
||||
}
|
||||
|
||||
//this.isImmuneToFire = true;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void applyEntityAttributes()
|
||||
{
|
||||
super.applyEntityAttributes();
|
||||
//This line affects the speed of the monster
|
||||
this.getEntityAttribute(SharedMonsterAttributes.movementSpeed).setBaseValue(0.30000001192092896D);
|
||||
|
||||
//My guess is that this will alter the max health
|
||||
if (this.isTamed())
|
||||
{
|
||||
this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxTamedHealth);
|
||||
} else
|
||||
{
|
||||
this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxUntamedHealth);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setPortalLocation(Int3 position)
|
||||
{
|
||||
this.demonPortal = position;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Int3 getPortalLocation()
|
||||
{
|
||||
return this.demonPortal;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if the newer Entity AI code should be run
|
||||
*/
|
||||
public boolean isAIEnabled()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the active target the Task system uses for tracking
|
||||
*/
|
||||
public void setAttackTarget(EntityLivingBase par1EntityLivingBase)
|
||||
{
|
||||
super.setAttackTarget(par1EntityLivingBase);
|
||||
|
||||
if (par1EntityLivingBase == null)
|
||||
{
|
||||
this.setAngry(false);
|
||||
} else if (!this.isTamed())
|
||||
{
|
||||
this.setAngry(true);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* main AI tick function, replaces updateEntityActionState
|
||||
*/
|
||||
protected void updateAITick()
|
||||
{
|
||||
this.dataWatcher.updateObject(18, Float.valueOf(this.getHealth()));
|
||||
}
|
||||
|
||||
/**
|
||||
* (abstract) Protected helper method to write subclass entity data to NBT.
|
||||
*/
|
||||
public void writeEntityToNBT(NBTTagCompound par1NBTTagCompound)
|
||||
{
|
||||
super.writeEntityToNBT(par1NBTTagCompound);
|
||||
par1NBTTagCompound.setBoolean("Angry", this.isAngry());
|
||||
|
||||
this.demonPortal.writeToNBT(par1NBTTagCompound);
|
||||
}
|
||||
|
||||
/**
|
||||
* (abstract) Protected helper method to read subclass entity data from NBT.
|
||||
*/
|
||||
public void readEntityFromNBT(NBTTagCompound par1NBTTagCompound)
|
||||
{
|
||||
super.readEntityFromNBT(par1NBTTagCompound);
|
||||
this.setAngry(par1NBTTagCompound.getBoolean("Angry"));
|
||||
this.demonPortal = Int3.readFromNBT(par1NBTTagCompound);
|
||||
|
||||
this.setCombatTask();
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the sound this mob makes while it's alive.
|
||||
*/
|
||||
@Override
|
||||
protected String getLivingSound()
|
||||
{
|
||||
//TODO change sounds
|
||||
return "none";
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the sound this mob makes when it is hurt.
|
||||
*/
|
||||
@Override
|
||||
protected String getHurtSound()
|
||||
{
|
||||
return "none";
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the sound this mob makes on death.
|
||||
*/
|
||||
@Override
|
||||
protected String getDeathSound()
|
||||
{
|
||||
return "mob.wolf.death";
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the volume for the sounds this mob makes.
|
||||
*/
|
||||
@Override
|
||||
protected float getSoundVolume()
|
||||
{
|
||||
return 0.4F;
|
||||
}
|
||||
|
||||
/**
|
||||
* Called frequently so the entity can update its state every tick as required. For example, zombies and skeletons
|
||||
* use this to react to sunlight and start to burn.
|
||||
*/
|
||||
@Override
|
||||
public void onLivingUpdate()
|
||||
{
|
||||
super.onLivingUpdate();
|
||||
}
|
||||
|
||||
/**
|
||||
* Called to update the entity's position/logic.
|
||||
*/
|
||||
@Override
|
||||
public void onUpdate()
|
||||
{
|
||||
super.onUpdate();
|
||||
}
|
||||
|
||||
@Override
|
||||
public float getEyeHeight()
|
||||
{
|
||||
return this.height * 0.8F;
|
||||
}
|
||||
|
||||
/**
|
||||
* The speed it takes to move the entityliving's rotationPitch through the faceEntity method. This is only currently
|
||||
* use in wolves.
|
||||
*/
|
||||
public int getVerticalFaceSpeed()
|
||||
{
|
||||
return this.isSitting() ? 20 : super.getVerticalFaceSpeed();
|
||||
}
|
||||
|
||||
public void setTamed(boolean par1)
|
||||
{
|
||||
super.setTamed(par1);
|
||||
|
||||
if (par1)
|
||||
{
|
||||
this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxTamedHealth);
|
||||
} else
|
||||
{
|
||||
this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(this.maxUntamedHealth);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Called when a player interacts with a mob. e.g. gets milk from a cow, gets into the saddle on a pig.
|
||||
*/
|
||||
@Override
|
||||
public boolean interact(EntityPlayer par1EntityPlayer)
|
||||
{
|
||||
ItemStack itemstack = par1EntityPlayer.inventory.getCurrentItem();
|
||||
|
||||
if (this.isTamed())
|
||||
{
|
||||
if (itemstack != null)
|
||||
{
|
||||
if (itemstack.getItem() instanceof ItemFood)
|
||||
{
|
||||
ItemFood itemfood = (ItemFood) itemstack.getItem();
|
||||
|
||||
if (itemfood.isWolfsFavoriteMeat() && this.dataWatcher.getWatchableObjectFloat(18) < this.maxTamedHealth)
|
||||
{
|
||||
if (!par1EntityPlayer.capabilities.isCreativeMode)
|
||||
{
|
||||
--itemstack.stackSize;
|
||||
}
|
||||
|
||||
this.heal((float) itemfood.func_150905_g(itemstack));
|
||||
|
||||
if (itemstack.stackSize <= 0)
|
||||
{
|
||||
par1EntityPlayer.inventory.setInventorySlotContents(par1EntityPlayer.inventory.currentItem, (ItemStack) null);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (this.getOwner() instanceof EntityPlayer && SpellHelper.getUsername(par1EntityPlayer).equalsIgnoreCase(SpellHelper.getUsername((EntityPlayer) this.getOwner())) && !this.isBreedingItem(itemstack))
|
||||
{
|
||||
if (!this.worldObj.isRemote)
|
||||
{
|
||||
this.aiSit.setSitting(!this.isSitting());
|
||||
this.isJumping = false;
|
||||
this.setPathToEntity((PathEntity) null);
|
||||
this.setTarget((Entity) null);
|
||||
this.setAttackTarget((EntityLivingBase) null);
|
||||
}
|
||||
|
||||
this.sendSittingMessageToPlayer(par1EntityPlayer, !this.isSitting());
|
||||
}
|
||||
} else if (itemstack != null && itemstack.getItem().equals(ModItems.weakBloodOrb) && !this.isAngry())
|
||||
{
|
||||
if (!par1EntityPlayer.capabilities.isCreativeMode)
|
||||
{
|
||||
--itemstack.stackSize;
|
||||
}
|
||||
|
||||
if (itemstack.stackSize <= 0)
|
||||
{
|
||||
par1EntityPlayer.inventory.setInventorySlotContents(par1EntityPlayer.inventory.currentItem, null);
|
||||
}
|
||||
|
||||
if (!this.worldObj.isRemote)
|
||||
{
|
||||
if (this.rand.nextInt(1) == 0)
|
||||
{
|
||||
this.setTamed(true);
|
||||
this.setPathToEntity((PathEntity) null);
|
||||
this.setAttackTarget((EntityLivingBase) null);
|
||||
this.aiSit.setSitting(true);
|
||||
this.setHealth(this.maxTamedHealth);
|
||||
this.func_152115_b(par1EntityPlayer.getUniqueID().toString());
|
||||
this.playTameEffect(true);
|
||||
this.worldObj.setEntityState(this, (byte) 7);
|
||||
} else
|
||||
{
|
||||
this.playTameEffect(false);
|
||||
this.worldObj.setEntityState(this, (byte) 6);
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
return super.interact(par1EntityPlayer);
|
||||
}
|
||||
|
||||
|
||||
public boolean isBreedingItem(ItemStack par1ItemStack)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Determines whether this wolf is angry or not.
|
||||
*/
|
||||
public boolean isAngry()
|
||||
{
|
||||
return this.isAngry;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets whether this wolf is angry or not.
|
||||
*/
|
||||
public void setAngry(boolean angry)
|
||||
{
|
||||
this.isAngry = angry;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns true if the mob is currently able to mate with the specified mob.
|
||||
*/
|
||||
@Override
|
||||
public boolean canMateWith(EntityAnimal par1EntityAnimal)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Determines if an entity can be despawned, used on idle far away entities
|
||||
*/
|
||||
@Override
|
||||
protected boolean canDespawn()
|
||||
{
|
||||
//return !this.isTamed() && this.ticksExisted > 2400;
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* A call to determine if this entity should attack the other entity
|
||||
*/
|
||||
@Override
|
||||
public boolean func_142018_a(EntityLivingBase par1EntityLivingBase, EntityLivingBase par2EntityLivingBase)
|
||||
{
|
||||
if (!(par1EntityLivingBase instanceof EntityCreeper) && !(par1EntityLivingBase instanceof EntityGhast))
|
||||
{
|
||||
if (par1EntityLivingBase instanceof EntityDemon)
|
||||
{
|
||||
EntityDemon entitywolf = (EntityDemon) par1EntityLivingBase;
|
||||
|
||||
if (entitywolf.isTamed() && entitywolf.getOwner() == par2EntityLivingBase)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return par1EntityLivingBase instanceof EntityPlayer && par2EntityLivingBase instanceof EntityPlayer && !((EntityPlayer) par2EntityLivingBase).canAttackPlayer((EntityPlayer) par1EntityLivingBase) ? false : !(par1EntityLivingBase instanceof EntityHorse) || !((EntityHorse) par1EntityLivingBase).isTame();
|
||||
} else
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Attack the specified entity using a ranged attack.
|
||||
*/
|
||||
@Override
|
||||
public void attackEntityWithRangedAttack(EntityLivingBase par1EntityLivingBase, float par2)
|
||||
{
|
||||
double xCoord;
|
||||
double yCoord;
|
||||
double zCoord;
|
||||
HolyProjectile hol = new HolyProjectile(worldObj, this, par1EntityLivingBase, 1.8f, 0f, 5, 600);
|
||||
this.worldObj.spawnEntityInWorld(hol);
|
||||
}
|
||||
|
||||
/**
|
||||
* sets this entity's combat AI.
|
||||
*/
|
||||
public void setCombatTask()
|
||||
{
|
||||
this.tasks.removeTask(this.aiAttackOnCollide);
|
||||
this.tasks.removeTask(this.aiArrowAttack);
|
||||
this.tasks.addTask(4, this.aiArrowAttack);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
package WayofTime.alchemicalWizardry.common.demonVillage.demonHoard.demon;
|
||||
|
||||
import WayofTime.alchemicalWizardry.common.Int3;
|
||||
|
||||
public interface IHoardDemon
|
||||
{
|
||||
public void setPortalLocation(Int3 position);
|
||||
public Int3 getPortalLocation();
|
||||
}
|
||||
File diff suppressed because it is too large
Load diff
Loading…
Add table
Add a link
Reference in a new issue