1345 lines
42 KiB
Java
1345 lines
42 KiB
Java
package WayofTime.alchemicalWizardry.common.tileEntity;
|
|
|
|
import java.io.BufferedReader;
|
|
import java.io.File;
|
|
import java.io.FileNotFoundException;
|
|
import java.io.FileReader;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.LinkedList;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Map.Entry;
|
|
import java.util.Random;
|
|
|
|
import net.minecraft.block.Block;
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.init.Blocks;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.nbt.NBTTagList;
|
|
import net.minecraft.tileentity.TileEntity;
|
|
import net.minecraftforge.common.util.Constants;
|
|
import net.minecraftforge.common.util.ForgeDirection;
|
|
import WayofTime.alchemicalWizardry.common.Int3;
|
|
import WayofTime.alchemicalWizardry.common.block.BlockTeleposer;
|
|
import WayofTime.alchemicalWizardry.common.demonVillage.BuildingSchematic;
|
|
import WayofTime.alchemicalWizardry.common.demonVillage.DemonBuilding;
|
|
import WayofTime.alchemicalWizardry.common.demonVillage.DemonCrosspath;
|
|
import WayofTime.alchemicalWizardry.common.demonVillage.DemonVillagePath;
|
|
import WayofTime.alchemicalWizardry.common.demonVillage.GridSpace;
|
|
import WayofTime.alchemicalWizardry.common.demonVillage.GridSpaceHolder;
|
|
import WayofTime.alchemicalWizardry.common.spell.complex.effect.SpellHelper;
|
|
|
|
import com.google.gson.Gson;
|
|
import com.google.gson.GsonBuilder;
|
|
|
|
public class TEDemonPortal extends TileEntity
|
|
{
|
|
boolean printDebug = false;
|
|
|
|
public static int buildingGridDelay = 25;
|
|
public static int roadGridDelay = 10;
|
|
|
|
public static int[] tierCostList = new int[]{1000, 50000, 55000};
|
|
|
|
public static List<DemonBuilding> buildingList = new ArrayList();
|
|
public Random rand = new Random();
|
|
private GridSpace[][] area;
|
|
|
|
private int negXRadius; //These variables indicate how much the grid has expanded from the 1x1
|
|
private int posXRadius; //matrix in each direction
|
|
private int negZRadius;
|
|
private int posZRadius;
|
|
|
|
private boolean isInitialized;
|
|
|
|
public int houseCooldown;
|
|
public int roadCooldown;
|
|
public int tier; //Tier of the demon portal - Should select buildings 2 below to this
|
|
public int totalPoints;
|
|
|
|
public String nextDemonPortalName = "";
|
|
public ForgeDirection nextDemonPortalDirection = ForgeDirection.DOWN;
|
|
|
|
public int buildingStage = -1;
|
|
|
|
public TEDemonPortal()
|
|
{
|
|
super();
|
|
|
|
negXRadius = posXRadius = negZRadius = posZRadius = 1;
|
|
|
|
area = new GridSpace[negXRadius + posXRadius + 1][negZRadius + posZRadius + 1];
|
|
for (int xIndex = -negXRadius; xIndex <= posXRadius; xIndex++)
|
|
{
|
|
for (int zIndex = -negZRadius; zIndex <= posZRadius; zIndex++)
|
|
{
|
|
if (Math.abs(xIndex) == 1 || Math.abs(zIndex) == 1)
|
|
{
|
|
this.setGridSpace(xIndex, zIndex, new GridSpace(GridSpace.ROAD, 4));
|
|
} else
|
|
{
|
|
this.setGridSpace(xIndex, zIndex, new GridSpace());
|
|
}
|
|
}
|
|
}
|
|
|
|
isInitialized = false;
|
|
|
|
this.setGridSpace(0, 0, new GridSpace(GridSpace.MAIN_PORTAL, yCoord));
|
|
|
|
this.houseCooldown = 0;
|
|
this.roadCooldown = 0;
|
|
this.tier = 0;
|
|
}
|
|
|
|
public void decreaseRandomCooldown(int amount)
|
|
{
|
|
float totalChance = 0;
|
|
|
|
Map<String, Float> map = new HashMap();
|
|
map.put("roadChance", 0.3f);
|
|
map.put("houseChance", 0.6f);
|
|
|
|
String action = "";
|
|
|
|
for(Entry<String, Float> entry : map.entrySet())
|
|
{
|
|
totalChance += entry.getValue();
|
|
}
|
|
|
|
float pointer = rand.nextFloat() * totalChance;
|
|
|
|
for(Entry<String, Float> entry : map.entrySet())
|
|
{
|
|
float value = entry.getValue();
|
|
if(pointer <= value)
|
|
{
|
|
action = entry.getKey();
|
|
break;
|
|
}else
|
|
{
|
|
pointer -= value;
|
|
}
|
|
}
|
|
|
|
if(action.equals("roadChance"))
|
|
{
|
|
roadCooldown -= amount;
|
|
}else if(action.equals("houseChance"))
|
|
{
|
|
houseCooldown -= amount;
|
|
}
|
|
}
|
|
|
|
public void initialize()
|
|
{
|
|
if (isInitialized)
|
|
{
|
|
return;
|
|
}
|
|
|
|
for (int xIndex = -negXRadius; xIndex <= posXRadius; xIndex++)
|
|
{
|
|
for (int zIndex = -negZRadius; zIndex <= posZRadius; zIndex++)
|
|
{
|
|
if (Math.abs(xIndex) == 1 || Math.abs(zIndex) == 1)
|
|
{
|
|
this.setGridSpace(xIndex, zIndex, new GridSpace(GridSpace.ROAD, yCoord));
|
|
} else if (xIndex == 0 && zIndex == 0)
|
|
{
|
|
this.setGridSpace(0, 0, new GridSpace(GridSpace.MAIN_PORTAL, yCoord));
|
|
} else
|
|
{
|
|
this.setGridSpace(xIndex, zIndex, new GridSpace());
|
|
}
|
|
}
|
|
}
|
|
|
|
this.houseCooldown = TEDemonPortal.buildingGridDelay;
|
|
this.roadCooldown = TEDemonPortal.roadGridDelay;
|
|
|
|
isInitialized = true;
|
|
}
|
|
|
|
@Override
|
|
public void updateEntity()
|
|
{
|
|
if (!isInitialized)
|
|
{
|
|
return;
|
|
}
|
|
|
|
System.out.println("Roads: " + roadCooldown + " Buildings: " + houseCooldown);
|
|
|
|
if(buildingStage >= 0 && buildingStage <=2)
|
|
{
|
|
System.out.println("BuildingStage = " + buildingStage);
|
|
this.createPortalBuilding(buildingStage, nextDemonPortalName, tier);
|
|
buildingStage++;
|
|
return;
|
|
}
|
|
|
|
// if (this.hasLocationChanged)
|
|
// {
|
|
// if (this.changePortalLocation())
|
|
// {
|
|
// if(printDebug)
|
|
// System.out.println("Changed portal location.");
|
|
// return;
|
|
// } else
|
|
// {
|
|
// if(printDebug)
|
|
// System.out.println("Going back to normal, have a nice day!");
|
|
// this.hasLocationChanged = false;
|
|
// }
|
|
// }
|
|
|
|
if (this.roadCooldown <= 0)
|
|
{
|
|
int roadsMade = this.createRandomRoad();
|
|
if (roadsMade > 0)
|
|
{
|
|
this.roadCooldown = TEDemonPortal.roadGridDelay * roadsMade;
|
|
this.totalPoints += this.roadCooldown;
|
|
}
|
|
} else if (this.houseCooldown <= 0)
|
|
{
|
|
int gridsUsed = this.createRandomBuilding(DemonBuilding.BUILDING_HOUSE, tier);
|
|
if (gridsUsed > 0)
|
|
{
|
|
this.houseCooldown = TEDemonPortal.buildingGridDelay * gridsUsed;
|
|
this.totalPoints += this.houseCooldown;
|
|
}
|
|
}
|
|
|
|
if (this.tier < this.tierCostList.length && this.totalPoints > this.tierCostList[this.tier])
|
|
{
|
|
this.tier++;
|
|
|
|
if (this.createRandomBuilding(DemonBuilding.BUILDING_PORTAL, tier) >= 1)
|
|
{
|
|
this.buildingStage = 0;
|
|
}
|
|
}
|
|
|
|
this.houseCooldown = Math.max(0, this.houseCooldown - 1); //Current dummy implementation of the increasing costs
|
|
this.roadCooldown = Math.max(0, this.roadCooldown - 1);
|
|
}
|
|
|
|
@Override
|
|
public void readFromNBT(NBTTagCompound par1NBTTagCompound)
|
|
{
|
|
super.readFromNBT(par1NBTTagCompound);
|
|
this.negXRadius = par1NBTTagCompound.getInteger("negXRadius");
|
|
this.negZRadius = par1NBTTagCompound.getInteger("negZRadius");
|
|
this.posXRadius = par1NBTTagCompound.getInteger("posXRadius");
|
|
this.posZRadius = par1NBTTagCompound.getInteger("posZRadius");
|
|
this.houseCooldown = par1NBTTagCompound.getInteger("houseCooldown");
|
|
this.roadCooldown = par1NBTTagCompound.getInteger("roadCooldown");
|
|
|
|
area = new GridSpace[negXRadius + posXRadius + 1][negZRadius + posZRadius + 1];
|
|
|
|
NBTTagList tagList = par1NBTTagCompound.getTagList("Grid", Constants.NBT.TAG_COMPOUND);
|
|
|
|
for (int i = 0; i < tagList.tagCount(); i++)
|
|
{
|
|
int length = (negZRadius + posZRadius + 1);
|
|
|
|
int x = i / length;
|
|
int z = i % length;
|
|
|
|
NBTTagCompound tag = (NBTTagCompound) tagList.getCompoundTagAt(i);
|
|
GridSpace space = GridSpace.getGridFromTag(tag);
|
|
|
|
area[x][z] = space;
|
|
}
|
|
|
|
this.isInitialized = par1NBTTagCompound.getBoolean("init");
|
|
|
|
this.tier = par1NBTTagCompound.getInteger("tier");
|
|
this.totalPoints = par1NBTTagCompound.getInteger("totalPoints");
|
|
|
|
this.nextDemonPortalName = par1NBTTagCompound.getString("nextDemonPortalName");
|
|
this.buildingStage = par1NBTTagCompound.getInteger("buildingStage");
|
|
this.nextDemonPortalDirection = ForgeDirection.getOrientation(par1NBTTagCompound.getInteger("nextDemonPortalDirection"));
|
|
}
|
|
|
|
@Override
|
|
public void writeToNBT(NBTTagCompound par1NBTTagCompound)
|
|
{
|
|
super.writeToNBT(par1NBTTagCompound);
|
|
par1NBTTagCompound.setInteger("negXRadius", negXRadius);
|
|
par1NBTTagCompound.setInteger("negZRadius", negZRadius);
|
|
par1NBTTagCompound.setInteger("posXRadius", posXRadius);
|
|
par1NBTTagCompound.setInteger("posZRadius", posZRadius);
|
|
par1NBTTagCompound.setInteger("houseCooldown", houseCooldown);
|
|
par1NBTTagCompound.setInteger("roadCooldown", roadCooldown);
|
|
|
|
NBTTagList gridList = new NBTTagList();
|
|
|
|
for (int i = 0; i <= negXRadius + posXRadius; i++)
|
|
{
|
|
for (int j = 0; j <= negZRadius + posZRadius; j++)
|
|
{
|
|
int index = i + (negZRadius + posZRadius + 1) * j;
|
|
|
|
GridSpace space = area[i][j];
|
|
NBTTagCompound nextTag;
|
|
|
|
if (space == null)
|
|
{
|
|
nextTag = new GridSpace().getTag();
|
|
} else
|
|
{
|
|
nextTag = space.getTag();
|
|
}
|
|
|
|
gridList.appendTag(nextTag);
|
|
}
|
|
}
|
|
|
|
par1NBTTagCompound.setTag("Grid", gridList);
|
|
|
|
par1NBTTagCompound.setBoolean("init", this.isInitialized);
|
|
par1NBTTagCompound.setInteger("tier", this.tier);
|
|
par1NBTTagCompound.setInteger("totalPoints", this.totalPoints);
|
|
|
|
par1NBTTagCompound.setString("nextDemonPortalName", nextDemonPortalName);
|
|
par1NBTTagCompound.setInteger("buildingStage", buildingStage);
|
|
|
|
par1NBTTagCompound.setInteger("nextDemonPortalDirection", this.nextDemonPortalDirection.ordinal());
|
|
}
|
|
|
|
public int createRandomRoad() //Return the number of road spaces
|
|
{
|
|
int next = rand.nextInt(4);
|
|
ForgeDirection dir;
|
|
|
|
switch (next)
|
|
{
|
|
case 0:
|
|
dir = ForgeDirection.NORTH;
|
|
break;
|
|
case 1:
|
|
dir = ForgeDirection.SOUTH;
|
|
break;
|
|
case 2:
|
|
dir = ForgeDirection.EAST;
|
|
break;
|
|
case 3:
|
|
dir = ForgeDirection.WEST;
|
|
break;
|
|
default:
|
|
dir = ForgeDirection.NORTH;
|
|
}
|
|
|
|
int length = 5;
|
|
|
|
Int3 road = findRoadSpaceFromDirection(dir, (rand.nextInt(negXRadius + negZRadius + posXRadius + posZRadius)) + 1);
|
|
|
|
int x = road.xCoord;
|
|
int yLevel = road.yCoord;
|
|
int z = road.zCoord;
|
|
|
|
if(printDebug)
|
|
System.out.println("X: " + x + " Z: " + z + " Direction: " + dir.toString());
|
|
|
|
List<ForgeDirection> directions = this.findValidExtentionDirection(x, z);
|
|
|
|
if (directions.size() <= 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int maxDistance = 5;
|
|
|
|
int distance = 0;
|
|
ForgeDirection dominantDirection = null;
|
|
|
|
for (ForgeDirection direction : directions)
|
|
{
|
|
int amt = this.getLength(direction, maxDistance, x, z);
|
|
if (amt > distance)
|
|
{
|
|
distance = amt;
|
|
dominantDirection = direction;
|
|
} else if (amt == distance && rand.nextBoolean())
|
|
{
|
|
dominantDirection = direction;
|
|
}
|
|
}
|
|
|
|
if (dominantDirection == null)
|
|
{
|
|
return 0;
|
|
}
|
|
if(printDebug)
|
|
System.out.println("I got here!");
|
|
if(printDebug)
|
|
System.out.println("Distance: " + distance + " Direction: " + dominantDirection.toString() + " yLevel: " + yLevel);
|
|
|
|
this.createGriddedRoad(x, yLevel, z, dominantDirection, distance + 1, true);
|
|
|
|
return distance;
|
|
}
|
|
|
|
public List<ForgeDirection> findValidExtentionDirection(int x, int z)
|
|
{
|
|
List<ForgeDirection> directions = new LinkedList();
|
|
|
|
if (this.getGridSpace(x, z) == null || !this.getGridSpace(x, z).isRoadSegment())
|
|
{
|
|
return directions;
|
|
}
|
|
|
|
GridSpace nextGrid = this.getGridSpace(x + 1, z);
|
|
if (nextGrid.isEmpty())
|
|
{
|
|
directions.add(ForgeDirection.EAST);
|
|
}
|
|
|
|
nextGrid = this.getGridSpace(x - 1, z);
|
|
if (nextGrid.isEmpty())
|
|
{
|
|
directions.add(ForgeDirection.WEST);
|
|
}
|
|
|
|
nextGrid = this.getGridSpace(x, z + 1);
|
|
if (nextGrid.isEmpty())
|
|
{
|
|
directions.add(ForgeDirection.SOUTH);
|
|
}
|
|
|
|
nextGrid = this.getGridSpace(x, z - 1);
|
|
if (nextGrid.isEmpty())
|
|
{
|
|
directions.add(ForgeDirection.NORTH);
|
|
}
|
|
|
|
return directions;
|
|
}
|
|
|
|
public int getLength(ForgeDirection dir, int maxLength, int x, int z) //Number of spaces forward
|
|
{
|
|
for (int i = 1; i <= maxLength; i++)
|
|
{
|
|
GridSpace space = this.getGridSpace(x + i * dir.offsetX, z + i * dir.offsetZ);
|
|
if (space.isEmpty())
|
|
{
|
|
for (int k = 1; k <= this.getRoadSpacer(); k++)
|
|
{
|
|
GridSpace space1 = this.getGridSpace(x + i * dir.offsetX + dir.offsetZ * k, z + i * dir.offsetZ + dir.offsetX * k);
|
|
GridSpace space2 = this.getGridSpace(x + i * dir.offsetX - dir.offsetZ * k, z + i * dir.offsetZ - dir.offsetX * k);
|
|
|
|
if (space1.isRoadSegment() || space2.isRoadSegment())
|
|
{
|
|
return i - 1;
|
|
}
|
|
}
|
|
|
|
continue;
|
|
}
|
|
if (space.isRoadSegment())
|
|
{
|
|
return i;
|
|
} else
|
|
{
|
|
return i - 1;
|
|
}
|
|
}
|
|
return maxLength;
|
|
}
|
|
|
|
public Int3 findRoadSpaceFromDirection(ForgeDirection dir, int amount)
|
|
{
|
|
int index = 0;
|
|
if (dir == ForgeDirection.NORTH)
|
|
{
|
|
if(printDebug)
|
|
System.out.print("NORTH!");
|
|
for (int i = 0; i <= negZRadius + posZRadius; i++)
|
|
{
|
|
for (int j = 0; j <= negXRadius + posXRadius; j++)
|
|
{
|
|
GridSpace space = area[j][i];
|
|
if (space.isRoadSegment())
|
|
{
|
|
index++;
|
|
if (index >= amount)
|
|
{
|
|
return new Int3(j - negXRadius, space.getYLevel(), i - negZRadius);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if (dir == ForgeDirection.SOUTH)
|
|
{
|
|
for (int i = negZRadius + posZRadius; i >= 0; i--)
|
|
{
|
|
for (int j = 0; j <= negXRadius + posXRadius; j++)
|
|
{
|
|
GridSpace space = area[j][i];
|
|
if (space.isRoadSegment())
|
|
{
|
|
index++;
|
|
if (index >= amount)
|
|
{
|
|
return new Int3(j - negXRadius, space.getYLevel(), i - negZRadius);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if (dir == ForgeDirection.EAST)
|
|
{
|
|
for (int i = negXRadius + posXRadius; i >= 0; i--)
|
|
{
|
|
for (int j = 0; j <= negZRadius + posZRadius; j++)
|
|
{
|
|
GridSpace space = area[i][j];
|
|
if (space.isRoadSegment())
|
|
{
|
|
index++;
|
|
if (index >= amount)
|
|
{
|
|
return new Int3(i - negXRadius, space.getYLevel(), j - negZRadius);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if (dir == ForgeDirection.WEST)
|
|
{
|
|
for (int i = 0; i <= negXRadius + posXRadius; i++)
|
|
{
|
|
for (int j = 0; j <= negZRadius + posZRadius; j++)
|
|
{
|
|
GridSpace space = area[i][j];
|
|
if (space.isRoadSegment())
|
|
{
|
|
index++;
|
|
if (index >= amount)
|
|
{
|
|
return new Int3(i - negXRadius, space.getYLevel(), j - negZRadius);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return new Int3(0, 0, 0);
|
|
}
|
|
|
|
public Int3 findEmptySpaceNearRoad(ForgeDirection dir, int amount, int closeness)
|
|
{
|
|
int index = 0;
|
|
if (dir == ForgeDirection.NORTH)
|
|
{
|
|
if(printDebug)
|
|
System.out.print("NORTH!");
|
|
for (int i = 0; i <= negZRadius + posZRadius; i++)
|
|
{
|
|
for (int j = 0; j <= negXRadius + posXRadius; j++)
|
|
{
|
|
GridSpace space = area[j][i];
|
|
if (space.isEmpty())
|
|
{
|
|
int yLevel = this.findNearestRoadYLevel(j - negXRadius, i - negZRadius, closeness);
|
|
if (yLevel == -1)
|
|
{
|
|
continue;
|
|
}
|
|
index++;
|
|
if (index >= amount)
|
|
{
|
|
return new Int3(j - negXRadius, yLevel, i - negZRadius);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if (dir == ForgeDirection.SOUTH)
|
|
{
|
|
for (int i = negZRadius + posZRadius; i >= 0; i--)
|
|
{
|
|
for (int j = 0; j <= negXRadius + posXRadius; j++)
|
|
{
|
|
GridSpace space = area[j][i];
|
|
int yLevel = this.findNearestRoadYLevel(j - negXRadius, i - negZRadius, closeness);
|
|
if (yLevel == -1)
|
|
{
|
|
continue;
|
|
}
|
|
if (space.isEmpty())
|
|
{
|
|
index++;
|
|
if (index >= amount)
|
|
{
|
|
return new Int3(j - negXRadius, yLevel, i - negZRadius);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if (dir == ForgeDirection.EAST)
|
|
{
|
|
for (int i = negXRadius + posXRadius; i >= 0; i--)
|
|
{
|
|
for (int j = 0; j <= negZRadius + posZRadius; j++)
|
|
{
|
|
GridSpace space = area[i][j];
|
|
int yLevel = this.findNearestRoadYLevel(i - negXRadius, j - negZRadius, closeness);
|
|
if (yLevel == -1)
|
|
{
|
|
continue;
|
|
}
|
|
if (space.isEmpty())
|
|
{
|
|
index++;
|
|
if (index >= amount)
|
|
{
|
|
return new Int3(i - negXRadius, yLevel, j - negZRadius);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if (dir == ForgeDirection.WEST)
|
|
{
|
|
for (int i = 0; i <= negXRadius + posXRadius; i++)
|
|
{
|
|
for (int j = 0; j <= negZRadius + posZRadius; j++)
|
|
{
|
|
GridSpace space = area[i][j];
|
|
int yLevel = this.findNearestRoadYLevel(i - negXRadius, j - negZRadius, closeness);
|
|
if (yLevel == -1)
|
|
{
|
|
continue;
|
|
}
|
|
if (space.isEmpty())
|
|
{
|
|
index++;
|
|
if (index >= amount)
|
|
{
|
|
return new Int3(i - negXRadius, yLevel, j - negZRadius);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return new Int3(0, 0, 0);
|
|
}
|
|
|
|
public Int3 findEmptySpaceFromDirection(ForgeDirection dir, int amount)
|
|
{
|
|
int index = 0;
|
|
if (dir == ForgeDirection.NORTH)
|
|
{
|
|
if(printDebug)
|
|
System.out.print("NORTH!");
|
|
for (int i = 0; i <= negZRadius + posZRadius; i++)
|
|
{
|
|
for (int j = 0; j <= negXRadius + posXRadius; j++)
|
|
{
|
|
GridSpace space = area[j][i];
|
|
if (space.isEmpty())
|
|
{
|
|
index++;
|
|
if (index >= amount)
|
|
{
|
|
return new Int3(j - negXRadius, space.getYLevel(), i - negZRadius);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if (dir == ForgeDirection.SOUTH)
|
|
{
|
|
for (int i = negZRadius + posZRadius; i >= 0; i--)
|
|
{
|
|
for (int j = 0; j <= negXRadius + posXRadius; j++)
|
|
{
|
|
GridSpace space = area[j][i];
|
|
if (space.isEmpty())
|
|
{
|
|
index++;
|
|
if (index >= amount)
|
|
{
|
|
return new Int3(j - negXRadius, space.getYLevel(), i - negZRadius);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if (dir == ForgeDirection.EAST)
|
|
{
|
|
for (int i = negXRadius + posXRadius; i >= 0; i--)
|
|
{
|
|
for (int j = 0; j <= negZRadius + posZRadius; j++)
|
|
{
|
|
GridSpace space = area[i][j];
|
|
if (space.isEmpty())
|
|
{
|
|
index++;
|
|
if (index >= amount)
|
|
{
|
|
return new Int3(i - negXRadius, space.getYLevel(), j - negZRadius);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if (dir == ForgeDirection.WEST)
|
|
{
|
|
for (int i = 0; i <= negXRadius + posXRadius; i++)
|
|
{
|
|
for (int j = 0; j <= negZRadius + posZRadius; j++)
|
|
{
|
|
GridSpace space = area[i][j];
|
|
if (space.isEmpty())
|
|
{
|
|
index++;
|
|
if (index >= amount)
|
|
{
|
|
return new Int3(i - negXRadius, space.getYLevel(), j - negZRadius);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return new Int3(0, 0, 0);
|
|
}
|
|
|
|
public void createGriddedRoad(int gridXi, int yi, int gridZi, ForgeDirection dir, int gridLength, boolean convertStarter) //Total grid length
|
|
{
|
|
if (gridLength == 0 || gridLength == 1)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (convertStarter)
|
|
{
|
|
|
|
}
|
|
|
|
int initGridX = gridXi;
|
|
int initGridZ = gridZi;
|
|
int initY = yi;
|
|
|
|
if (convertStarter)
|
|
{
|
|
this.setGridSpace(initGridX, initGridZ, new GridSpace(GridSpace.CROSSROAD, initY));
|
|
|
|
DemonCrosspath crosspath = new DemonCrosspath(xCoord + initGridX * 5, initY, zCoord + initGridZ * 5);
|
|
crosspath.createCrosspath(worldObj);
|
|
}
|
|
|
|
for (int index = 0; index < gridLength - 1; index++)
|
|
{
|
|
DemonVillagePath path = new DemonVillagePath(xCoord + initGridX * 5, initY, zCoord + initGridZ * 5, dir, 6);
|
|
|
|
Int3 next = path.constructFullPath(worldObj, this.getRoadStepClearance(), this.getRoadBlock(), this.getRoadMeta());
|
|
|
|
if (next != null)
|
|
{
|
|
initY = next.yCoord;
|
|
if(printDebug)
|
|
System.out.println("" + initY);
|
|
}
|
|
|
|
initGridX += dir.offsetX;
|
|
initGridZ += dir.offsetZ;
|
|
|
|
if (!this.getGridSpace(initGridX, initGridZ).isRoadSegment())
|
|
{
|
|
this.setGridSpace(initGridX, initGridZ, new GridSpace(GridSpace.ROAD, initY));
|
|
}
|
|
}
|
|
}
|
|
|
|
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];
|
|
|
|
if(printDebug)
|
|
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 void rightClickBlock(EntityPlayer player, int side)
|
|
{
|
|
if (worldObj.isRemote)
|
|
{
|
|
return;
|
|
}
|
|
|
|
this.initialize();
|
|
|
|
if (ForgeDirection.getOrientation(side) == ForgeDirection.UP)
|
|
{
|
|
this.createRandomBuilding(DemonBuilding.BUILDING_HOUSE, 0);
|
|
} else if (ForgeDirection.getOrientation(side) == ForgeDirection.DOWN)
|
|
{
|
|
this.createRandomBuilding(DemonBuilding.BUILDING_PORTAL, 0);
|
|
} else
|
|
{
|
|
this.createRandomRoad();
|
|
}
|
|
}
|
|
|
|
public int createRandomBuilding(int type, int tier)
|
|
{
|
|
switch (type)
|
|
{
|
|
case DemonBuilding.BUILDING_HOUSE:
|
|
return this.createRandomHouse(tier);
|
|
case DemonBuilding.BUILDING_PORTAL:
|
|
return this.createPortalBuilding(tier);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
public int createPortalBuilding(int buildingTier) //TODO Telepose block next time, then build the new building.
|
|
{
|
|
System.out.println("Hello, I am here!");
|
|
int x = 0;
|
|
int z = 0;
|
|
|
|
GridSpace home = this.getGridSpace(x, z);
|
|
int yLevel = home.getYLevel();
|
|
|
|
GridSpaceHolder grid = this.createGSH();
|
|
|
|
List<ForgeDirection> directions = new ArrayList();
|
|
|
|
for (int i = 2; i < 6; i++)
|
|
{
|
|
ForgeDirection testDir = ForgeDirection.getOrientation(i);
|
|
directions.add(testDir);
|
|
}
|
|
|
|
if (directions.isEmpty())
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
HashMap<ForgeDirection, List<DemonBuilding>> schemMap = new HashMap();
|
|
|
|
for (ForgeDirection nextDir : directions)
|
|
{
|
|
for (DemonBuilding build : TEDemonPortal.buildingList)
|
|
{
|
|
if (build.buildingType != DemonBuilding.BUILDING_PORTAL)
|
|
{
|
|
continue;
|
|
}
|
|
if (schemMap.containsKey(nextDir))
|
|
{
|
|
schemMap.get(nextDir).add(build);
|
|
} else
|
|
{
|
|
schemMap.put(nextDir, new ArrayList());
|
|
schemMap.get(nextDir).add(build);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (schemMap.keySet().isEmpty())
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
ForgeDirection chosenDirection = (ForgeDirection) schemMap.keySet().toArray()[new Random().nextInt(schemMap.keySet().size())];
|
|
DemonBuilding build = schemMap.get(chosenDirection).get(new Random().nextInt(schemMap.get(chosenDirection).size()));
|
|
Int3 portalSpace = build.getDoorSpace(chosenDirection);
|
|
|
|
|
|
this.nextDemonPortalDirection = chosenDirection;
|
|
this.nextDemonPortalName = build.getName();
|
|
|
|
// build.destroyAllInField(worldObj, xCoord + (x) * 5, yLevel, zCoord + (z) * 5, chosenDirection.getOpposite());
|
|
//
|
|
// int yOffset = portalSpace.yCoord;
|
|
// build.buildAll(worldObj, xCoord + (x) * 5, yLevel, zCoord + (z) * 5, chosenDirection.getOpposite());
|
|
// build.setAllGridSpaces(x, z, yLevel, chosenDirection.getOpposite(), GridSpace.MAIN_PORTAL, grid);
|
|
// this.loadGSH(grid);
|
|
|
|
return build.getNumberOfGridSpaces();
|
|
}
|
|
|
|
/**
|
|
* The Stage is at what point the portal is in reacting to the creation of the Demon Portal.
|
|
* Stage == 0 means just the saving
|
|
* Stage == 1 means to telepose the portal
|
|
* Stage == 2 means the teleposition is complete and that the building may be constructed
|
|
*/
|
|
public void createPortalBuilding(int stage, String name, int tier)
|
|
{
|
|
for(DemonBuilding build : TEDemonPortal.buildingList)
|
|
{
|
|
if(build.buildingType != DemonBuilding.BUILDING_PORTAL || build.buildingTier != tier)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if(build.getName().equals(this.nextDemonPortalName))
|
|
{
|
|
int x = 0;
|
|
int z = 0;
|
|
|
|
GridSpace home = this.getGridSpace(x, z);
|
|
int yLevel = home.getYLevel();
|
|
|
|
GridSpaceHolder grid = this.createGSH();
|
|
|
|
ForgeDirection chosenDirection = this.nextDemonPortalDirection;
|
|
Int3 portalSpace = build.getDoorSpace(chosenDirection);
|
|
int yOffset = portalSpace.yCoord;
|
|
|
|
switch(stage)
|
|
{
|
|
case 0:
|
|
|
|
break;
|
|
|
|
case 1:
|
|
int yDestination = yLevel + yOffset;
|
|
if(yCoord != yDestination)
|
|
{
|
|
BlockTeleposer.swapBlocks(worldObj, worldObj, xCoord, yCoord, zCoord, xCoord, yDestination, zCoord);
|
|
}else
|
|
{
|
|
//Nuthin - just as a reminder that we can now increment properly
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
build.destroyAllInField(worldObj, xCoord + (x) * 5, yLevel, zCoord + (z) * 5, chosenDirection.getOpposite());
|
|
|
|
build.buildAll(worldObj, xCoord + (x) * 5, yLevel, zCoord + (z) * 5, chosenDirection.getOpposite());
|
|
build.setAllGridSpaces(x, z, yLevel, chosenDirection.getOpposite(), GridSpace.MAIN_PORTAL, grid);
|
|
this.loadGSH(grid);
|
|
break;
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
public int createRandomHouse(int buildingTier)
|
|
{
|
|
int next = rand.nextInt(4);
|
|
ForgeDirection dir;
|
|
|
|
switch (next)
|
|
{
|
|
case 0:
|
|
dir = ForgeDirection.NORTH;
|
|
break;
|
|
case 1:
|
|
dir = ForgeDirection.SOUTH;
|
|
break;
|
|
case 2:
|
|
dir = ForgeDirection.EAST;
|
|
break;
|
|
case 3:
|
|
dir = ForgeDirection.WEST;
|
|
break;
|
|
default:
|
|
dir = ForgeDirection.NORTH;
|
|
}
|
|
|
|
boolean newProtocol = true;
|
|
|
|
if (newProtocol)
|
|
{
|
|
Int3 space = this.findRoadSpaceFromDirection(dir, 1 * (rand.nextInt(negXRadius + negZRadius + posXRadius + posZRadius)) + 1);
|
|
|
|
int x = space.xCoord;
|
|
int z = space.zCoord;
|
|
int yLevel = space.yCoord;
|
|
|
|
if(printDebug)
|
|
System.out.println("Road space - x: " + x + " z: " + z);
|
|
|
|
GridSpaceHolder grid = this.createGSH();
|
|
|
|
if (!this.getGridSpace(x, z).isRoadSegment())
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
List<ForgeDirection> directions = new ArrayList();
|
|
|
|
for (int i = 2; i < 6; i++)
|
|
{
|
|
ForgeDirection testDir = ForgeDirection.getOrientation(i);
|
|
if (this.getGridSpace(x + testDir.offsetX, z + testDir.offsetZ).isEmpty())
|
|
{
|
|
directions.add(testDir);
|
|
}
|
|
}
|
|
|
|
if (directions.isEmpty())
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
HashMap<ForgeDirection, List<DemonBuilding>> schemMap = new HashMap();
|
|
|
|
for (ForgeDirection nextDir : directions)
|
|
{
|
|
for (DemonBuilding build : TEDemonPortal.buildingList)
|
|
{
|
|
if (build.buildingTier != buildingTier || build.buildingType != DemonBuilding.BUILDING_HOUSE)
|
|
{
|
|
continue;
|
|
}
|
|
Int3 offsetSpace = build.getGridOffsetFromRoad(nextDir, yLevel);
|
|
int xOff = offsetSpace.xCoord;
|
|
int zOff = offsetSpace.zCoord;
|
|
|
|
if (build.isValid(grid, x + xOff, z + zOff, nextDir.getOpposite()))
|
|
{
|
|
if (schemMap.containsKey(nextDir))
|
|
{
|
|
schemMap.get(nextDir).add(build);
|
|
} else
|
|
{
|
|
schemMap.put(nextDir, new ArrayList());
|
|
schemMap.get(nextDir).add(build);
|
|
}
|
|
} else
|
|
{
|
|
System.out.println("This ISN'T valid!");
|
|
}
|
|
}
|
|
}
|
|
|
|
if (schemMap.keySet().isEmpty())
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
ForgeDirection chosenDirection = (ForgeDirection) schemMap.keySet().toArray()[new Random().nextInt(schemMap.keySet().size())];
|
|
DemonBuilding build = schemMap.get(chosenDirection).get(new Random().nextInt(schemMap.get(chosenDirection).size()));
|
|
|
|
Int3 offsetSpace = build.getGridOffsetFromRoad(chosenDirection, yLevel);
|
|
int xOff = offsetSpace.xCoord;
|
|
int zOff = offsetSpace.zCoord;
|
|
|
|
build.destroyAllInField(worldObj, xCoord + (x + xOff) * 5, yLevel, zCoord + (z + zOff) * 5, chosenDirection.getOpposite());
|
|
build.buildAll(worldObj, xCoord + (x + xOff) * 5, yLevel, zCoord + (z + zOff) * 5, chosenDirection.getOpposite());
|
|
build.setAllGridSpaces(x + xOff, z + zOff, yLevel, chosenDirection.getOpposite(), GridSpace.HOUSE, grid);
|
|
this.loadGSH(grid);
|
|
|
|
return build.getNumberOfGridSpaces();
|
|
} else
|
|
{
|
|
Int3 space = findEmptySpaceNearRoad(dir, 3 * (rand.nextInt(negXRadius + negZRadius + posXRadius + posZRadius)) + 1, 2);
|
|
|
|
int x = space.xCoord;
|
|
int z = space.zCoord;
|
|
int yLevel = space.yCoord;
|
|
|
|
GridSpace newSpace = this.getGridSpace(x, z);
|
|
if (!newSpace.isEmpty())
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if (yLevel == -1)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
GridSpaceHolder grid = this.createGSH();
|
|
|
|
ForgeDirection chosenDirection = ForgeDirection.NORTH;
|
|
|
|
HashMap<ForgeDirection, List<DemonBuilding>> bigList = new HashMap();
|
|
|
|
for (DemonBuilding build : TEDemonPortal.buildingList)
|
|
{
|
|
for (int i = 2; i < 6; i++)
|
|
{
|
|
chosenDirection = ForgeDirection.getOrientation(i);
|
|
System.out.println("" + chosenDirection.toString());
|
|
if (build.isValid(grid, x, z, chosenDirection))
|
|
{
|
|
System.out.println("Valid!");
|
|
if (bigList.containsKey(chosenDirection))
|
|
{
|
|
bigList.get(chosenDirection).add(build);
|
|
} else
|
|
{
|
|
bigList.put(chosenDirection, new ArrayList());
|
|
bigList.get(chosenDirection).add(build);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
chosenDirection = ForgeDirection.getOrientation(new Random().nextInt(4) + 2); //Change to favour a direction with a road nearby
|
|
|
|
List<DemonBuilding> buildingList = bigList.get(chosenDirection);
|
|
DemonBuilding build;
|
|
|
|
if (buildingList != null && buildingList.size() > 0)
|
|
{
|
|
build = buildingList.get(new Random().nextInt(buildingList.size()));
|
|
} else
|
|
{
|
|
return 0;
|
|
}
|
|
//TODO: Finish the selection algorythm
|
|
//TODO: Should favour those directions that have a road right next to them.
|
|
|
|
build.buildAll(worldObj, xCoord + x * 5, yLevel, zCoord + z * 5, chosenDirection);
|
|
build.setAllGridSpaces(x, z, yLevel, chosenDirection, GridSpace.HOUSE, grid);
|
|
this.loadGSH(grid);
|
|
|
|
return build.getNumberOfGridSpaces();
|
|
// System.out.println("X: " + x + " Z: " + z + " Direction: " + chosenDirection.toString());
|
|
}
|
|
}
|
|
|
|
public int findNearestRoadYLevel(int xCoord, int zCoord, int maxDistance)
|
|
{
|
|
for (int l = 1; l <= maxDistance; l++)
|
|
{
|
|
for (int i = -l; i <= l; i++)
|
|
{
|
|
for (int j = -l; j <= l; j++)
|
|
{
|
|
if (Math.abs(i) != l && Math.abs(j) != l)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (this.getGridSpace(xCoord + i, zCoord + j).isRoadSegment())
|
|
{
|
|
return this.getGridSpace(xCoord + i, zCoord + j).getYLevel();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
public void createRoad(int xi, int yi, int zi, ForgeDirection dir, int length, boolean doesNotDrop)
|
|
{
|
|
int curX = xi;
|
|
int curY = yi;
|
|
int curZ = zi;
|
|
int roadRadius = this.getRoadRadius();
|
|
|
|
if (dir.offsetY != 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
DemonVillagePath path = new DemonVillagePath(xi, yi, zi, dir, length);
|
|
|
|
path.constructFullPath(worldObj, this.getRoadStepClearance(), this.getRoadBlock(), this.getRoadMeta());
|
|
}
|
|
|
|
public int placeMaterialOnNextAvailable()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
public int getRoadRadius()
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
public Block getRoadBlock()
|
|
{
|
|
return Blocks.nether_brick;
|
|
}
|
|
|
|
public int getRoadMeta()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
public int getRoadStepClearance()
|
|
{
|
|
return 10;
|
|
}
|
|
|
|
public int getRoadSpacer()
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
public GridSpaceHolder createGSH()
|
|
{
|
|
GridSpaceHolder grid = new GridSpaceHolder();
|
|
grid.area = this.area;
|
|
grid.negXRadius = this.negXRadius;
|
|
grid.negZRadius = this.negZRadius;
|
|
grid.posXRadius = this.posXRadius;
|
|
grid.posZRadius = this.posZRadius;
|
|
|
|
return grid;
|
|
}
|
|
|
|
public void loadGSH(GridSpaceHolder grid)
|
|
{
|
|
this.area = grid.area;
|
|
this.negXRadius = grid.negXRadius;
|
|
this.negZRadius = grid.negZRadius;
|
|
this.posXRadius = grid.posXRadius;
|
|
this.posZRadius = grid.posZRadius;
|
|
}
|
|
|
|
public static void loadBuildingList()
|
|
{
|
|
String folder = "config/BloodMagic/schematics";
|
|
Gson gson = new GsonBuilder().setPrettyPrinting().create();
|
|
|
|
File file = new File(folder);
|
|
File[] files = file.listFiles();
|
|
BufferedReader br;
|
|
|
|
try
|
|
{
|
|
for (File f : files)
|
|
{
|
|
br = new BufferedReader(new FileReader(f));
|
|
BuildingSchematic schema = gson.fromJson(br, BuildingSchematic.class);
|
|
TEDemonPortal.buildingList.add(new DemonBuilding(schema));
|
|
}
|
|
} catch (FileNotFoundException e)
|
|
{
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
public int getTotalPoints()
|
|
{
|
|
return this.totalPoints;
|
|
}
|
|
|
|
public void addToPoints(int addition)
|
|
{
|
|
this.totalPoints += addition;
|
|
}
|
|
}
|