public Chunk(Vector3 chunkSize, Vector3 location, Island island)
{
this.mChunkSize = chunkSize;
this.mChunkLocation = location;
this.mVisible = new bool[16, 16, 16, 6];
this.mIsland = island;
}
public override void populate(Island curr, Random random)
{
int x = random.Next(2, (int)curr.getSize().x) * Cst.CHUNK_SIDE;
int z = random.Next(2, (int)curr.getSize().z) * Cst.CHUNK_SIDE;
int y = curr.getSurfaceHeight(x, z);
while (y == -1)
{
x = random.Next(2, (int)curr.getSize().x) * Cst.CHUNK_SIDE;
z = random.Next(2, (int)curr.getSize().z) * Cst.CHUNK_SIDE;
y = curr.getSurfaceHeight(x, z);
}
int size = ((int)(curr.getSize().x + curr.getSize().z) / 2) / 5;
for(int i = 0; i < size * Cst.CHUNK_SIDE; i += 5) {
for (int j = 0, max = random.Next(4, 10); j < max; j++) {
double angle = 2.0 * Math.PI * random.NextDouble();
int treeX = (int)(x + i * Math.Cos(angle)) + (random.Next(-10, 11) / 5);
int treeZ = (int)(y + i * Math.Sin(angle)) + (random.Next(-10, 11) / 5);
int treeY = curr.getSurfaceHeight(treeX, treeZ, "Grass");
if(treeY != -1) { this.createTree(curr, random, treeX, treeY, treeZ); }
}
}
}
public void makeCross(Island current, Vector3 loc)
{
current.setBlockAt((int)loc.x + 1, (int)loc.y, (int)loc.z, "TowerWoodBlock", true);
current.setBlockAt((int)loc.x - 1, (int)loc.y, (int)loc.z, "TowerWoodBlock", true);
current.setBlockAt((int)loc.x, (int)loc.y, (int)loc.z + 1, "TowerWoodBlock", true);
current.setBlockAt((int)loc.x, (int)loc.y, (int)loc.z - 1, "TowerWoodBlock", true);
}
public override void populate(Island curr, Random random)
{
Vector3 p = new Vector3(curr.getSize().x * 8, curr.getSize().y * 16 + 16, curr.getSize().z * 8);
Vector3 center = p + (8) * Vector3.UNIT_X + (8) * Vector3.UNIT_Y + (8) * Vector3.UNIT_Z;
for(float x = p.x; x < p.x + 18; x++) {
for(float y = p.y; y < p.y + 18; y++) {
for(float z = p.z; z < p.z + 16; z++) {
if(isInSphere(x, y, z, center.x, center.y, center.z, 9)) {
curr.setBlockAt((int)x, (int)y, (int)z, 2, true);
}
if(y == center.y) {
curr.setBlockAt((int)x, (int)y, (int)z, "Grass", true);
}
}
}
}
createTree(curr, random, (int)center.x, (int)center.y + 1, (int)center.z);
createTree(curr, random, (int)center.x + 7, (int)center.y + 1, (int)center.z - 3);
createTree(curr, random, (int)center.x, (int)center.y + 1, (int)center.z + 7);
createTree(curr, random, (int)center.x + 2, (int)center.y + 1, (int)center.z + 7);
createTree(curr, random, (int)center.x + 5, (int)center.y + 1, (int)center.z - 7);
createTree(curr, random, (int)center.x + 4, (int)center.y + 1, (int)center.z + 4);
createTree(curr, random, (int)center.x - 2, (int)center.y + 1, (int)center.z + 3);
createTree(curr, random, (int)center.x - 2, (int)center.y + 1, (int)center.z + 4);
createTree(curr, random, (int)center.x - 6, (int)center.y + 1, (int)center.z - 7);
createTree(curr, random, (int)center.x - 5, (int)center.y + 1, (int)center.z - 5);
createTree(curr, random, (int)center.x - 8, (int)center.y + 1, (int)center.z - 3);
}
public void reSpawnCurrentIsland(int verticeCount, float amplitude, float roughness)
{
// (currently not directly in use)
Destroy (currentIsland.getGameObject (), 0f);
currentIsland = spawnIsland (verticeCount, amplitude, roughness);
spawnCamera ();
}
public Zone(int index, int levelIndex, string name, Island island)
{
Index = index;
LevelIndex = levelIndex;
Name = name;
Island = island;
}
public void build(Island current, Random rd, Vector3 loc)
{
int towerHeight = rd.Next(15, 30);
//body
for(int x = 0; x < xMax; x++) {
for(int z = 0; z < zMax; z++) {
for(int y = 0; y <= towerHeight; y++) {
if((x == 0 && z == 0) || (x == 0 && z == zMax - 1) || (x == xMax - 1 && z == 0) || (z == zMax - 1 && x == xMax - 1)) { //corners
current.setBlockAt((int)loc.x + x, (int)loc.y + y, (int)loc.z + z, "TowerWoodBlock", true);
} else if((x == 0 || z == 0 || x == xMax - 1 || z == zMax - 1) && y != towerHeight) { //borders
current.setBlockAt((int)loc.x + x, (int)loc.y + y, (int)loc.z + z, "DarkWood", true);
}
if(y == 0 || y == 1 || y == towerHeight - 1) {
if(x == 0 || z == 0 || x == xMax - 1 || z == zMax - 1) { //borders
current.setBlockAt((int)loc.x + x, (int)loc.y + y, (int)loc.z + z, "TowerWoodBlock", true);
} else {
current.setBlockAt((int)loc.x + x, (int)loc.y + y, (int)loc.z + z, "DarkWood", true);
}
}
}
}
}
new DarkBeard().makeDarkBeard(current, towerHeight, loc, xMax, zMax);
new RoofBuilder().build(current, loc + Vector3.UNIT_Y * towerHeight, new Vector2(xMax, zMax), rd);
new Bridge(this.mSourceBuilding, this.getEntrance(this.mSourceBuilding, 1, loc), new NullTower()).build(current);
}
public List<Node> getAdjacent(Island current, Vector3 destination)
{
Vector3[] adjacent = new Vector3[] {
Vector3.UNIT_X, Vector3.UNIT_Z,
Vector3.NEGATIVE_UNIT_X, Vector3.NEGATIVE_UNIT_Z,
Vector3.UNIT_X + Vector3.UNIT_Z, Vector3.UNIT_X + Vector3.NEGATIVE_UNIT_Z,
Vector3.NEGATIVE_UNIT_X + Vector3.UNIT_Z, Vector3.NEGATIVE_UNIT_X + Vector3.NEGATIVE_UNIT_Z,
};
List<Node> returnList = new List<Node>();
Vector3 adj = Vector3.ZERO;
for(int i = 0; i < adjacent.Length; i++) {
adj = adjacent[i] + this.pos;
if(current.getBlock(adj, false) is Air && !(current.getBlock(adj + Vector3.NEGATIVE_UNIT_Y, false) is Air)) {
returnList.Add(new Node(destination, adj, this));
} else if(current.getBlock(adj + Vector3.UNIT_Y, false) is Air && !(current.getBlock(adj, false) is Air)) {
returnList.Add(new Node(destination, adj + Vector3.UNIT_Y, this));
} else if(current.getBlock(adj - Vector3.UNIT_Y, false) is Air && !(current.getBlock(adj - 2 * Vector3.UNIT_Y, false) is Air)) {
returnList.Add(new Node(destination, adj - Vector3.UNIT_Y, this));
}
}
//}
return returnList;
}
public static void makePortal(int val, Island current, Vector3 position)
{
switch(val) {
case 1:
for(int x = 0; x < 4; x++) {
for(int y = -1; y < 5; y++) {
if(x == 0 || x == 3 || y == -1 || y == 4) { current.setBlockAt((int)position.x + x, (int)position.y + y, (int)position.z, "Crystal", true); }
else { current.setBlockAt((int)position.x + x, (int)position.y + y, (int)position.z, "CrystalGate H", true); }
}
}
break;
case 2:
for(int x = 0; x < 4; x++) {
for(int z = 0; z < 4; z++) {
if(x == 0 || z == 0 || x == 3 || z == 3) { current.setBlockAt((int)position.x + x, (int)position.y, (int)position.z + z, "Crystal", true); }
else {
current.setBlockAt((int)position.x + x, (int)position.y, (int)position.z + z, "CrystalGate H", true);
}
}
}
break;
}
}
public BuildingManager(StateManager stateMgr, Island island, RTSManager RTSMgr)
{
this.mStateMgr = stateMgr;
this.mIsland = island;
this.mRTSManager = RTSMgr;
this.Buildings = new Dictionary<Vector3, Building>();
}
public void Update(Island island, float movementProbability, float eatGrassProbability)
{
age += Time.deltaTime;
Move(island, movementProbability);
if (type == AnimalType.Sheep)
EatGrass(island, eatGrassProbability);
}
public override void populate(Island curr, Random random)
{
{
for (int i = 0; i < (curr.getSize().x + curr.getSize().z) * 4; i++)
{
Vector3 pos = this.findRandomPoint(curr, random, "Grass");
if ((curr.getBlock((int)pos.x, (int)pos.y, (int)pos.z, true) is AirBlock))
{
for (int p = 1; p < 6; p++)
{
int tmp = 0;
for (int y = 6 * p; y < 9 * p; y++)
{
for (int x = 0 + tmp; x < 7 - tmp; x++)
{
for (int z = 0 + tmp; z < 7 - tmp; z++)
{
curr.setBlockAt((int)pos.x + x - 3, (int)pos.y + y, (int)pos.z + z - 3, "Leaves", true);
}
}
tmp++;
}
}
for (int y = 0; y < 30; y++)
{
curr.setBlockAt((int)pos.x, (int)pos.y + y, (int)pos.z, "DarkWood", true);
}
}
}
}
}
public void AddIsland(Island island)
{
if (islands == null) {
islands = new List<Island> ();
}
islands.Add (island);
}
public void GoToLevel(Island island)
{
// Debug.Log(island.LevelName);
// string levelName = island.LevelName;
//Todo goto level with this name
Application.LoadLevel(island.LevelName);
}
public void createTree(Island curr, Random random, int x, int y, int z)
{
for(int i = 0, height = random.Next(6, 12); i < height; i++) {
if(i != height - 1) { curr.setBlockAt(x, y + i, z, "Wood", true); } else { curr.setBlockAt(x, y + i, z, "Leaves", true); }
if(i >= height - 5 && i < height - 3) {
for(int j = -2; j < 3; j++) {
for(int k = -2; k < 3; k++) {
if(j == 0 && k == 0) { continue; }
if((j == -2 && (k == -2 || k == 2)) || (j == 2 && (k == -2 || k == 2))) {
if(random.Next(0, 100) > 15) { curr.setBlockAt(x + j, y + i, z + k, "Leaves", true); }
} else {
curr.setBlockAt(x + j, y + i, z + k, "Leaves", true);
}
}
}
} else if(i >= height - 3) {
for(int j = -1; j < 2; j++) {
for(int k = -1; k < 2; k++) {
if(j == 0 && k == 0) { continue; }
if(i == height - 3 && (j == -1 && (k == -1 || k == 1)) || (j == 1 && (k == -1 || k == 1))) {
if(random.Next(0, 100) > 75) { curr.setBlockAt(x + j, y + i, z + k, "Leaves", true); }
} else {
curr.setBlockAt(x + j, y + i, z + k, "Leaves", true);
}
}
}
}
}
}
public Player(PlayerIndex playerIndex, IShip ship, Island homeIsland, Map map)
{
this.playerIndex = playerIndex;
this.ship = ship;
this.homeIsland = homeIsland;
this.map = map;
}
public Sloop CreateSloop(Color color, Vector2 shipLocation, Island playerIsland, float shipAngle)
{
Sloop ship = new Sloop(base.Game, shipLocation, CannonBallManager, shipAngle);
SloopView shipView = new SloopView(base.Game, color, Color.White, SpriteBatch, ship);
base.Game.Components.Add(ship);
base.Game.Components.Add(shipView);
return ship;
}
public Cutter CreateCutter(Color color, Vector2 shipLocation, Island playerIsland, float shipAngle)
{
Cutter ship = new Cutter(base.Game, shipLocation, CannonBallManager, shipAngle);
CutterView shipView = new CutterView(base.Game, color, Color.White, SpriteBatch, ship);
base.Game.Components.Add(ship);
base.Game.Components.Add(shipView);
return ship;
}
public void display(Island currentIsland, API.Geo.World currentWorld)
{
if (this.faceNumber > 0) {
block.End();
this.node = this.mIsland.Node.CreateChildSceneNode("MultiBlockNode-" + this.mName);
this.node.AttachObject(block);
}
}
public Island CreateIsland(Vector2 position, int goldAmount)
{
Island island = new Island(base.Game, position, goldAmount);
GameObjectView islandView = new GameObjectView(base.Game, Content.Island, Color.White, SpriteBatch, island, ZIndexManager.getZIndex(ZIndexManager.drawnItemOrders.island));
base.Game.Components.Add(island);
base.Game.Components.Add(islandView);
return island;
}
public Island spawnIsland(int verticeCount, float amplitude, float roughness)
{
// Spawn a new island and return a reference
Island theIsland = new Island (GameObject.Find ("Root"), "Island 01");
theIsland.spawnTerrain (10.0f, 4, amplitude, roughness);
theIsland.spawnDelauney (verticeCount, 10f);
return theIsland;
}
public void addNewIsland(int verticeCount, float amplitude, float roughness)
{
// Add a new island to the buffer, switch the view, drop cam
currentIsland.setVisible (false);
currentIsland = spawnIsland (verticeCount, amplitude, roughness);
theIslands.Add (currentIsland);
spawnCamera ();
}
public void InitializeVals(int nVikings, int nSheep, Island source, GameObject island){
numVikings = nVikings;
numSheep = nSheep;
sourceIsland = source.gameObject;
targettedIsland = island;
rotAngle = this.transform.rotation.y;
//this.transform.Rotate(new Vector3(0, 90, 0));
}
/// <summary>
/// An AIController should have access to all information a user of the system has.
/// </summary>
/// <param name="game">The game</param>
/// <param name="controlledShip">The ship that the AI is controlling</param>
/// <param name="homeIsland">The ship's home island</param>
/// <param name="islands">All islands in the game(excluding the ships home island)</param>
public AIController(Game game, IShip controlledShip, Island homeIsland, List<Island> otherIslands, IShip targetShip)
: base(game)
{
this.ControlledShip = controlledShip;
this.HomeIsland = homeIsland;
this.OtherIslands = otherIslands;
this.ProximityRadius = 50.0f;
this.TargetShip = targetShip;
}
public override void populate(Island curr, Random random)
{
Vector3 pos = this.findRandomPoint(curr, random);
int tmp = 0;
string brick = "Sand";
curr.setBlockAt((int)pos.x, (int)pos.y, (int)pos.z, brick, true);
for (int y = 0; y < 18; y++)
{
for (int x = 0 + tmp; x < _width - tmp; x++)
{
for (int z = 0 + tmp; z < _width - tmp; z++) {
if (y == 0 || y == 7)
curr.setBlockAt((int)pos.x + x, (int)pos.y + y - 7, (int)pos.z + z, brick, true);
else if ((x == 0 || z == 0 || x == _width - 1 || z == _width - 1) && y <= 6)
curr.setBlockAt((int)pos.x + x, (int)pos.y + y - 7, (int)pos.z + z, brick, true);
else if (y > 7)
curr.setBlockAt((int)pos.x + x, (int)pos.y + y - 7, (int)pos.z + z, brick, true);
else
curr.setBlockAt((int)pos.x + x, (int)pos.y + y - 7, (int)pos.z + z, "Air", true);
}
}
if (y >= 7)
tmp++;
}
CharacterInfo iaInfo = new CharacterInfo("Robot-" + Guid.NewGuid().ToString(), Faction.Red);
iaInfo.SpawnPoint = new Vector3(pos.x + _width / 2 - 4, (int)pos.y - 5, (int)pos.z + _width / 2) * Cst.CUBE_SIDE;
curr.mWorld.getStateMgr().MainState.CharacMgr.AddCharacter(iaInfo);
iaInfo = new CharacterInfo("Robot-" + Guid.NewGuid().ToString(), Faction.Red);
iaInfo.SpawnPoint = new Vector3(pos.x + _width / 2 + 4, (int)pos.y - 5, (int)pos.z + _width / 2) * Cst.CUBE_SIDE;
curr.mWorld.getStateMgr().MainState.CharacMgr.AddCharacter(iaInfo);
Portals.makePortal(1, curr, new Vector3((int)pos.x + _width / 2 - 2, (int)pos.y - 7, (int)pos.z + _width / 2 - 3));
int tmp2 = 0;
for (int y = 1; y < 6; y++)
{
for (int x = 0; x < 2; x++)
{
for (int z = tmp2; z < tmp2 + 2; z++)
{
curr.setBlockAt((int)pos.x + _width / 2 - 1 + x, (int)pos.y + y - 8, (int)pos.z + _width - 1 + z, brick, true);
curr.setBlockAt((int)pos.x + _width / 2 - 1 + x, (int)pos.y + y - 7, (int)pos.z + _width - 1 + z, "Air", true);
curr.setBlockAt((int)pos.x + _width / 2 - 1 + x, (int)pos.y + y - 5, (int)pos.z + _width - 1 + z, "Air", true);
curr.setBlockAt((int)pos.x + _width / 2 - 1 + x, (int)pos.y + y - 6, (int)pos.z + _width - 1 + z, "Air", true);
}
}
tmp2++;
}
}
public void EatGrass(Island island, float eatGrassProbability)
{
if (island.RandFloat(0f, 1f) < eatGrassProbability) {
foreach (var grass in island.grasses) {
if (grass.row == row && grass.column == column) {
island.grasses.Remove(grass);
break;
}
}
}
}
public MultiBlock(string mat, Island current, World mainWorld, int meshType)
{
this.mMaterial = mat;
this.mName = this.mMaterial + Guid.NewGuid().ToString();
this.mIsland = current;
this.mWorld = mainWorld;
block = new ManualObject("MultiBlock-" + this.mName);
block.Begin(this.mMaterial, RenderOperation.OperationTypes.OT_TRIANGLE_LIST);
this.meshType = meshType;
}
public void build(Island current, Vector3 location, Vector2 size, Random rd)
{
for(int x = 0; x < size.x; x++) {
for(int z = 0; z < size.y; z++) {
if(x == 0 || x == size.x - 1 || z == 0 || z == size.y - 1) {
//build fences
}
if(x == size.x / 2 && z == size.y / 2) { this.buildStructure(current, rd.Next(0, 100) % 3, new Vector3(location.x + x, location.y, location.z + z)); }
}
}
}
public ActionResult Index()
{
var islandTileList = db.IslandTile.ToList();
var playerList = db.Player.ToList();
var islandFactory = new IslandFactory();
Island island = islandFactory.Create(islandTileList);
return(View(island));
}
public override void populate(Island curr, Random random)
{
for(int x = 0; x < curr.getSize().x * Cst.CHUNK_SIDE; x++) {
for(int z = 0; z < curr.getSize().z * Cst.CHUNK_SIDE; z++) {
int y = curr.getSurfaceHeight(x, z);
if(y >= 200) {
curr.setBlockAt(x, y, z, 23, true);
}
}
}
}
public VanillaChunk(Vector3 chunkSize, Vector3 location, Island island)
: base(chunkSize, location, island)
{
this.mBlockList = new Block[16, 16, 16];
for(int x = 0; x < mChunkSize.x; x++) {
for(int y = 0; y < mChunkSize.y; y++) {
for(int z = 0; z < mChunkSize.z; z++) {
this.mBlockList[x, y, z] = staticBlock["Air"];
}
}
}
}
static void Main(string[] args)
{
Console.WriteLine("Enter name of plenet");
string nameOfPlanet = Console.ReadLine();
Planet planet = new Planet(nameOfPlanet);
Console.WriteLine("Enter number of continents");
int numberOfContinents = Convert.ToInt32(Console.ReadLine());
for (int i = 0; i < numberOfContinents; i++)
{
Console.WriteLine("Enter name of continent");
string nameOfContinent = Console.ReadLine();
Console.WriteLine("Enter area of continent");
double areaOfContinent = Convert.ToDouble(Console.ReadLine());
Continent continent = new Continent(nameOfContinent, areaOfContinent);
planet.AddContinent(continent);
}
Console.WriteLine("Enter number of oceans");
int numberOfOceans = Convert.ToInt32(Console.ReadLine());
for (int i = 0; i < numberOfOceans; i++)
{
Console.WriteLine("Enter name of ocean");
string nameOfOcean = Console.ReadLine();
Console.WriteLine("Enter temperature of ocean");
double temperatureOfOcean = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("Enter depth of ocean");
double depthOfOcean = Convert.ToDouble(Console.ReadLine());
Ocean ocean = new Ocean(nameOfOcean, temperatureOfOcean, depthOfOcean);
planet.AddOcean(ocean);
}
Console.WriteLine("Enter number of islands");
int numberOfIslands = Convert.ToInt32(Console.ReadLine());
for (int i = 0; i < numberOfIslands; i++)
{
Console.WriteLine("Enter name of island");
string nameOfIsland = Console.ReadLine();
Console.WriteLine("Enter population of island");
double populationOfIsland = Convert.ToDouble(Console.ReadLine());
Island island = new Island(nameOfIsland, populationOfIsland);
planet.AddIsland(island);
}
Console.WriteLine("Name of planet: " + planet.ReturnName() + "\n");
Console.WriteLine(planet.ReturnInformationOfContinents() + "\n");
Console.WriteLine(planet.ReturnInformationOfOceans() + "\n");
Console.WriteLine(planet.ReturnInformationOfIslands() + "\n");
}
public void Init()
{
island = transform.parent.GetComponent <Island>();
gridSize = GameManager.Instance.GridSize;
gridDivisions = GameManager.Instance.GridDivisions;
GenerateBoard();
transform.localPosition = Vector3.zero;
transform.localRotation = Quaternion.identity;
initReady = true;
}
public char GuessNumber(ref Island orig)
{
Island island = new Island(orig);
char g = makeGuess(ref island);
if (g == ' ')
{
island = new Island(orig);
island.Grow();
return(makeGuess(ref island));
}
return(g);
}
public void AddIsland(Island island)
{
if (_islands.TryGetValue(island, out int refCount))
{
refCount++;
}
else
{
refCount = 1;
}
_islands[island] = refCount;
UpdateScore();
}
void createStartingIsland()
{
Island island = world.createNewIsland(new Coordinate(0, 0, 0));
GameObject startingIsland = Instantiate(islandObject, island.location.vec3 * World.WORLD_NEXUS_LENGTH * World.BLOCK_SIZE, new Quaternion(), transform);
IslandRenderer islandRenderer = startingIsland.GetComponent <IslandRenderer>();
islandRenderer.initialize(island);
playerObject.GetComponent <PlayerController>().currentRenderer = islandRenderer;
Player player1 = world.players[0];
player1.updateLevel(island);
islandRenderer.renderAroundPlayer(player1);
}
public Island getNextIsland(Island currentIsland)
{
int indexOld = route.IndexOf(currentIsland);
if (route.Count < indexOld)
{
return(route[indexOld + 1]);
}
else
{
return(route[0]);
}
}
public override void Paint(Island island)
{
int count = 0;
foreach (var section in m_sections)
{
#if UNITY_EDITOR
UnityEditor.EditorUtility.DisplayProgressBar("Painting Forest", "Painting Sections...", (float)count / (float)m_sections.Length);
#endif
section.Paint();
count++;
}
}
public PathFinder(Vector3 destination, Vector3 start, Island current) // dest in abs value, start rel
{
this.mOpen = new NodeList <Node>();
this.mClosed = new NodeList <Node>();
this.mPossibleNodes = new List <Node>();
this.mSolutionSize = 0;
this.mNbTotIter = 0;
this.mAbsDestination = destination;
this.mRelDestination = MainWorld.getRelativeFromAbsolute(this.mAbsDestination);
this.mCurrent = current;
this.mOpen.Add(new Node(this.mRelDestination, start));
}
public IEnumerator AdjustDockTransform(Island island)
{
CartographicIsland islandStructure = island.CartographicIsland;
var dependencyGraph = islandStructure.Bundle.OSGiProject.DependencyGraph;
GraphVertex vertex = islandStructure.DependencyVertex;
GameObject importDock = island.ImportDock;
GameObject exportDock = island.ExportDock;
yield return(FindSuitablePosition2D(island, importDock, exportDock));
if (vertex == null)
{
yield break;
}
float importSize = 0.04f * 25f; // Don't hardcode.
float exportSize = 0.04f * 25f; // Don't hardcode.
IEnumerable <GraphEdge> outEdges;
dependencyGraph.TryGetOutEdges(vertex, out outEdges);
List <GraphEdge> edgeList = outEdges.ToList();
importDock.transform.localScale = new Vector3(importSize, importSize, importSize);
DependencyDock dockComponent = importDock.GetComponent <DependencyDock>();
dockComponent.setDockType(DockType.Import);
foreach (GraphEdge e in edgeList)
{
GameObject ed = e.Target.Island.IslandGameObject.GetComponent <Island>().ExportDock;
dockComponent.addDockConnection(ed.GetComponent <DependencyDock>(), e.Weight);
}
dependencyGraph.TryGetInEdges(vertex, out outEdges);
edgeList = outEdges.ToList();
float eDockWidth = exportDock.GetComponent <MeshFilter>().sharedMesh.bounds.size.x *exportSize;
float iDockWidth = importDock.GetComponent <MeshFilter>().sharedMesh.bounds.size.x *importSize;
exportDock.transform.localScale = new Vector3(exportSize, exportSize, exportSize);
dockComponent = exportDock.GetComponent <DependencyDock>();
dockComponent.setDockType(DockType.Export);
foreach (GraphEdge e in edgeList)
{
GameObject id = e.Source.Island.IslandGameObject.GetComponent <Island>().ImportDock;
dockComponent.addDockConnection(id.GetComponent <DependencyDock>(), e.Weight);
}
}
public ActionResult ChangeName(int id)
{
Island island = islandRepository.GetIsland(id);
if (island.Property.Player.Id != User.Identity.GetUserId())
{
return(RedirectToAction("Map"));
}
ChangeNameViewModel viewModel = new ChangeNameViewModel {
NameUsed = false, Id = id
};
return(View(viewModel));
}
public VanillaChunk(Vector3 chunkSize, Vector3 location, Island island) : base(chunkSize, location, island)
{
this.mBlockList = new Block[16, 16, 16];
for (int x = 0; x < mChunkSize.x; x++)
{
for (int y = 0; y < mChunkSize.y; y++)
{
for (int z = 0; z < mChunkSize.z; z++)
{
this.mBlockList[x, y, z] = staticBlock["Air"];
}
}
}
}
private void RevealIsland(Island island)
{
currentIsland = island;
// See if new sector needs to be generated
int offSize = size - 1;
Point sectorPoint = new Point(island.point.x % offSize, island.point.y % offSize);
// Negative space offset
int negativeX = 0;
int negativeY = 0;
// Negative sectors
if (sectorPoint.x < 0)
{
sectorPoint.x = offSize + sectorPoint.x;
negativeX -= 1;
}
if (sectorPoint.y < 0)
{
sectorPoint.y = offSize + sectorPoint.y;
negativeY -= 1;
}
int range = 7;
// Horizontal
if (sectorPoint.x <= range)
{
Point sector = new Point(island.point.x / offSize - 1 + negativeX, island.point.y / offSize + negativeY);
GenerateMap(sector);
}
else if (sectorPoint.x >= offSize - range)
{
Point sector = new Point(island.point.x / offSize + 1 + negativeX, island.point.y / offSize + negativeY);
GenerateMap(sector);
}
// Vertical
if (sectorPoint.y <= range)
{
Point sector = new Point(island.point.x / offSize + negativeX, island.point.y / offSize - 1 + negativeY);
GenerateMap(sector);
}
else if (sectorPoint.y >= offSize - range)
{
Point sector = new Point(island.point.x / offSize + negativeX, island.point.y / offSize + 1 + negativeY);
GenerateMap(sector);
}
}
public IActionResult OnGet(int?islandId)
{
this.Climates = htmlHelper.GetEnumSelectList <ClimateType>();
if (islandId.HasValue)
{
Island = islandData.GetById(islandId.Value);
}
else
{
Island = new Island();
}
return(Page());
}
public LookMenu(int width, int height, Island world, string hint = null, Func <Entity, bool> select = null, Action <XYZ> selectAt = null) : base(width, height)
{
UseKeyboard = true;
this.world = world;
this.hint = hint ?? "Select an entity to examine";
this.select = select ?? (e => false);
this.selectAt = selectAt ?? (xyz => { });
cursorVisible = true;
cursorBlink = new Timer(0.4, () => {
cursorVisible = !cursorVisible;
});
UpdateExamine();
}
public void DoTurn(IPirateGame state)
{
// Initing stuff
List <Island> islands = state.NotMyIslands();
List <Pirate> myPirates = state.MyPirates();
List <Pirate> copyPirates = new List <Pirate>(myPirates);
Dictionary <Pirate, Island> pirateToIsland = new Dictionary <Pirate, Island>();
for (int i = 0; i < islands.Count; i++)
{
Pirate closestPirate = GetClosestPirate(state, islands[i], myPirates);
//state.Debug($"closest: {closestPirate.Id.ToString()} to island: {islands[i]}");
if (closestPirate != null)
{
myPirates.Remove(closestPirate);
pirateToIsland.Add(closestPirate, islands[i]);
}
}
copyPirates.ForEach(pirate =>
{
if (pirateToIsland.ContainsKey(pirate) && pirateToIsland[pirate] != null)
{
Island island = pirateToIsland[pirate];
state.Debug($"Pirate {pirate.Id.ToString()} to island {island.Id.ToString()}");
List <Direction> movingDirections = state.GetDirections(pirate, island);
if (movingDirections.Count > 0 && !pirate.IsLost)
{
state.Debug($"Pirate: {pirate.Id.ToString()}");
movingDirections.ForEach(direc =>
{
state.Debug($"{direc}");
});
state.SetSail(pirate, movingDirections[0]);
}
}
else // Bot that has no island
{
state.Debug($"Nothing {pirate.Id.ToString()}");
Island closestIsland = GetClosestIsland(state, pirate, state.NotMyIslands());
if (closestIsland != null)
{
List <Direction> movingDirections = state.GetDirections(pirate, closestIsland);
state.SetSail(pirate, movingDirections[0]);
}
}
});
}
public void Board_cannot_find_land_from_invalid_coordinate()
{
// arrange
var board = new Island();
var posX = _faker.Random.Number(int.MinValue, -1);
var posY = _faker.Random.Number(5, int.MaxValue);
// act
var success = board.TryGetLand(posX, posY, out var land);
// assert
success.Should().BeFalse();
land.Should().BeNull();
}
void SpawnIsland()
{
if (currentIsland != null)
{
Destroy(currentIsland);
}
currentIsland = (GameObject)GameObject.Instantiate(islandPrefab, Vector3.zero, Quaternion.identity);
Island isl = currentIsland.GetComponent <Island>();
isl.islandPosition = new Vector3(Random.Range(0, 10000), Random.Range(0, 10000), Random.Range(0, 10000));
isl.Regenerate(true);
}
public static void Feather(Island island)
{
for (var i = island.Pixels.Count - 1; i >= 0; i--)
{
var pixel = island.Pixels[i];
var x = pixel.X;
var y = pixel.Y;
TryFeather(island, x - 1, y);
TryFeather(island, x + 1, y);
TryFeather(island, x, y - 1);
TryFeather(island, x, y + 1);
}
}
public IEnumerator CanPlaceBlockAtMaximumHeight()
{
Island testCandidate = new Island(64);
Block testBlock = EarthBlock.GetInstance();
BlockPosition blockPosition = new BlockPosition(63, 255, 63);
testCandidate.PlaceBlockAt(testBlock, blockPosition);
Block blockAt = testCandidate.GetBlockAt(blockPosition);
yield return(null);
Assert.That(blockAt, Is.SameAs(testBlock));
}
public Player(Island World, XYZ Position)
{
this.World = World;
this.Position = Position;
this.Velocity = new XYZ(0, 0, 0);
Actions = new HashSet <EntityAction>();
Equipment = new Equipment();
Inventory = new HashSet <IItem>();
Watch = new HashSet <Effect>();
HistoryLog = new List <HistoryEntry>();
HistoryRecent = new List <HistoryEntry>();
health = new Health();
}
public IEnumerator RetrievesPreviouslyPlacedBlock()
{
Island testCandidate = new Island(64);
Block testBlock = GrassyEarthBlock.GetInstance();
BlockPosition blockPosition = new BlockPosition(63, 0, 63);
testCandidate.PlaceBlockAt(testBlock, blockPosition);
Block blockAt = testCandidate.GetBlockAt(blockPosition);
yield return(null);
Assert.That(blockAt, Is.SameAs(testBlock));
}
public IEnumerator BuildIslandHightlight(Island island)
{
GameObject highlight = new GameObject("Island Highlight");
yield return(BuildHighlight(island.gameObject, highlight));
MeshRenderer renderer = highlight.GetComponent <MeshRenderer>();
Interactable interactable = island.GetComponent <Interactable>();
foreach (Region region in island.Regions)
{
yield return(BuildRegionHighlight(region));
}
if (true)
{
interactable.FocusBehaviour = new Action(() => {
if (StateManager.Instance.CurrentState.Name == "main" && interactable.Type == InteractableType.Bundle)
{
UIManager.Instance.SetPanelHeaderTop("Bundle");
UIManager.Instance.SetPanelHeaderBottom(island.name);
UIManager.Instance.Tooltip.Show(island.gameObject);
}
UIManager.Instance.Tooltip.Show(island.gameObject);
interactable.Highlight.gameObject.SetActive(true);
});
interactable.DefocusBehaviour = new Action(() => {
if (StateManager.Instance.CurrentState.Name == "main" && interactable.Type == InteractableType.Bundle)
{
UIManager.Instance.SetPanelHeaderTop("");
UIManager.Instance.SetPanelHeaderBottom("");
}
UIManager.Instance.Tooltip.Hide();
interactable.Highlight.gameObject.SetActive(false);
});
interactable.SelectBehaviour = new Action(() => {
UIManager.Instance.SetPanelHeaderTop("Bundle");
UIManager.Instance.SetPanelHeaderBottom(island.name);
UIManager.Instance.Tooltip.Hide();
});
interactable.DeselectBehaviour = new Action(() => {
UIManager.Instance.Tooltip.Hide();
});
}
}
/// <summary>
/// This method calculates a list of islands from a list of polygons
/// </summary>
/// <param name="polygons">The list of polygons to calculate the islands from</param>
/// <returns>The calculated list of islands</returns>
private static List <Island> calculateIslandFromPolygons(Polygons polygons)
{
List <Island> islandList = new List <Island>();
//We now need to put the polygons through clipper sothat it can detect holes for us
//and then make proper islands with the returned data
PolyTree resultTree = new PolyTree();
Clipper clipper = new Clipper();
clipper.AddPaths(polygons, PolyType.ptClip, true);
clipper.Execute(ClipType.ctUnion, resultTree, PolyFillType.pftEvenOdd, PolyFillType.pftEvenOdd);
List <PolyNode> polyNodeList = moveNodesToSameLevel(resultTree);
foreach (PolyNode polyNode in polyNodeList)
{
if (!polyNode.IsHole)
{
Island temp = new Island();
temp.outlinePolygons.Add(polyNode.Contour);
islandList.Add(temp);
}
else //IsHole
{
bool shouldBreak = false;
foreach (Island island in islandList)
{
if (shouldBreak)
{
break;
}
foreach (Polygon islandPolygon in island.outlinePolygons)
{
if (polyNode.Parent.Contour.Equals(islandPolygon))
{
island.outlinePolygons.Add(polyNode.Contour);
shouldBreak = true;
break;
}
}
}
}
}
//Lastly we return our list of islands
return(islandList);
}
public void TestBridgeConnecting()
{
var level = setupRendering();
var isl = level.CreateNewIsland(new Vector3(5, 3, 5));
cameraIsland = isl;
var isl2 = level.CreateNewIsland(new Vector3(15, 3, 5));
addBridge(isl, Vector3.UnitX, new Vector3(3, 0, 0));
addBridge(isl, Vector3.UnitZ, new Vector3(0, 0, 3));
addBridge(isl2, -Vector3.UnitX, new Vector3(-3, 0, 0));
}
public void Test_Environment()
{
Terrain terrain = Object.FindObjectOfType <Terrain>();
Assert.NotNull(terrain, "Terrain is missing");
AreaDamageOverTime lava = Object.FindObjectOfType <AreaDamageOverTime>();
Assert.NotNull(lava, "Lava is missing");
Island island = Object.FindObjectOfType <Island>();
Assert.NotNull(island, "Island is missing");
}
private string GetDefenderSquadInfo(Island island, int squadCountCount, UnitNames unitNames, int pad)
{
List <long> sc = new List <long>();
StringBuilder sb = new StringBuilder();
// Sort the islands with squads so that they display nicely.
List <long> squadPlans = new List <long>();
for (int c = 0; c < island.SquadPlans.Count; c++)
{
squadPlans.Add(island.SquadPlans[c][0]);
}
squadPlans.Sort();
sb.AppendLine("<pre>");
// Add in all tiles with squads on them
for (int j = 0; j < squadCountCount; j++)
{
sc = island.SquadCounts[j];
int tileNumber = Convert.ToInt32(squadPlans[j]); // Convert.ToInt32(island.SquadPlans[j][0]);
// List blockers & bunkers & features (terrain)
string defenses = island.Defenses;
string features = island.Features;
char defense = defenses[tileNumber];
char feature = features[tileNumber];
string blocker = GetBlockerFromChar(defense);
string bunkers = GetBunkersFromChar(defense);
string terrain = GetTerrainFromChar(feature);
sb.AppendLine(" Squad #" + (j + 1).ToString() + " on tile " + tileNumber.ToString() + " ==> " + terrain + " with " + blocker + " and " + bunkers);
sb.AppendLine(" " + unitNames.Riflemen.PadRight(pad) + " = " + sc[0].ToString().PadLeft(12, ' '));
sb.AppendLine(" " + unitNames.MachineGunners.PadRight(pad) + " = " + sc[1].ToString().PadLeft(12, ' '));
sb.AppendLine(" " + unitNames.Bazookamen.PadRight(pad) + " = " + sc[2].ToString().PadLeft(12, ' '));
sb.AppendLine(" " + unitNames.LightTanks.PadRight(pad) + " = " + sc[3].ToString().PadLeft(12, ' '));
sb.AppendLine(" " + unitNames.MediumTanks.PadRight(pad) + " = " + sc[4].ToString().PadLeft(12, ' '));
sb.AppendLine(" " + unitNames.HeavyTanks.PadRight(pad) + " = " + sc[5].ToString().PadLeft(12, ' '));
sb.AppendLine(" " + unitNames.LightFighters.PadRight(pad) + " = " + sc[6].ToString().PadLeft(12, ' '));
sb.AppendLine(" " + unitNames.MediumFighters.PadRight(pad) + " = " + sc[7].ToString().PadLeft(12, ' '));
sb.AppendLine(" " + unitNames.Bombers.PadRight(pad) + " = " + sc[8].ToString().PadLeft(12, ' '));
}
// Add in all the tiles with no squad on them
sb.AppendLine(GetDefenderNoSquadInfo(island));
sb.AppendLine("</pre>");
return(sb.ToString());
}
/// <summary>
/// Generate columns of blocks at the chunk x, z
/// </summary>
/// <param name="chunk"></param>
static void generateChunkColumn(Chunk chunk)
{
for (int x = 0; x < Chunk.CHUNK_DIAMETER; x++)
{
for (int z = 0; z < Chunk.CHUNK_DIAMETER; z++)
{
int islandX = chunk.location.x * Chunk.CHUNK_DIAMETER + x;
int islandZ = chunk.location.z * Chunk.CHUNK_DIAMETER + z;
generateColumn(chunk, islandX, islandZ);
}
}
Island island = chunk.level as Island;
island.setColumnGenerated(chunk.location);
}
public void Refuse_move_worker_to_invalid_coordinate()
{
// arrange
var board = new Island();
var player = new Player(_faker.Name.FirstName());
var worker = player.Workers.First();
board.TryAddPiece(worker, 0, 0);
// act
var success = worker.TryMoveTo(-1, 5);
// assert
success.Should().BeFalse();
}
public void Worker_cannot_build_at_invalid_coordinate()
{
// arrange
var board = new Island();
var player = new Player(_faker.Name.FirstName());
var worker = player.Workers.First();
board.TryAddPiece(worker, 0, 0);
// act
var success = worker.TryBuildAt(5, -1);
// assert
success.Should().BeFalse();
}
