public void RemoveHull(TileOWW tile)
{
tile.SetTileType("Empty");
emptyHullTiles.Remove(tile);
allHullTiles.Add(tile);
ObjectiveController.Instance.CheckObjectives();
}
private void UpdateOxygenSprite(TileOWW tileOWW, float oxygenLevel)
{
Tile t;
if (tileOWW.oxygenLevel > 0)
{
// Create room graphics
t = Resources.Load <Tile>("TileSets/Rooms/Oxygen");
if (tileOWW.GetTileType() == "Hull")
{
t.color = new Color(0.227451f, 0.7294118f, 0.9960784f, tileOWW.oxygenLevel / 50);
}
else
{
t.color = new Color(0.9215686f, 0.5764706f, 0.1176471f);
// TODO: Notification
}
tilemap.SetTile(new Vector3Int(tileOWW.GetX(), tileOWW.GetY(), 0), t);
tilemap.RefreshTile(new Vector3Int(tileOWW.GetX(), tileOWW.GetY(), 0));
}
else
{
// Remove tile graphics
t = null;
tilemap.SetTile(new Vector3Int(tileOWW.GetX(), tileOWW.GetY(), 0), t);
tilemap.RefreshTile(new Vector3Int(tileOWW.GetX(), tileOWW.GetY(), 0));
}
}
public List <TileOWW> PreviewRemoveHull(int start_x, int end_x, int start_y, int end_y)
{
List <TileOWW> hull_tiles = new List <TileOWW>();
ClearPreviews();
// Loop through all the tiles
for (int x = start_x; x <= end_x; x++)
{
for (int y = start_y; y <= end_y; y++)
{
TileOWW tileOWW = WorldController.Instance.GetWorld().GetTileAt(x, y);
// Check valid - remove installed hull OR job
if (tileOWW != null)
{
if (tileOWW.GetTileType() == "Hull")
{
hull_tiles.Add(tileOWW);
CreatePreview(removePreviewPrefab, "Hull", x, y);
}
// Can remove any build job
else if (tileOWW.currentJobType != null)
{
if (tileOWW.currentJobType.Contains("Build"))
{
hull_tiles.Add(tileOWW);
CreatePreview(removePreviewPrefab, "Hull", x, y);
}
}
}
}
}
return(hull_tiles);
}
public Job(Action action, TileOWW tileOWW, float jobTime, string jobType, JobPriority jobPriority, Job prerequisiteJob = null, bool tileExcludeOtherJobs = true)
{
this.action = action;
this.tileOWW = tileOWW;
this.jobTime = jobTime;
this.jobType = jobType;
this.prerequisiteJob = prerequisiteJob;
this.tileExcludeOtherJobs = tileExcludeOtherJobs;
this.jobPriority = jobPriority;
// The tile won't hold a reference to this job. Likely because a character is wandering.
if (tileExcludeOtherJobs == true)
{
tileOWW.currentJobType = jobType;
}
// Set default job pos
jobPosX = tileOWW.GetX();
jobPosY = tileOWW.GetY();
if (jobTime < 0.1f)
{
Debug.LogWarning("Job time is too short! Prerequisites may be skipped");
}
}
public List <TileOWW> PreviewRoom(string roomType, int start_x, int end_x, int start_y, int end_y)
{
List <TileOWW> room_tiles = new List <TileOWW>();
ClearPreviews();
for (int x = start_x; x <= end_x; x++)
{
for (int y = start_y; y <= end_y; y++)
{
TileOWW t = WorldController.Instance.GetWorld().GetTileAt(x, y);
if (t != null)
{
// Check valid
if (t.GetInstalledFurniture()?.GetFurnitureType() != "Wall" && t.GetTileType() == "Hull")
{
room_tiles.Add(t);
CreatePreview(validPreviewPrefab, "Hull", x, y); // TODO: Different looks per room?
}
else
{
CreatePreview(invalidPreviewPrefab, "Hull", x, y); // TODO: Different looks per room?
}
}
}
}
return(room_tiles);
}
public TileOWW PreviewFurniture(FurnitureType furnitureType, int posX, int posY)
{
ClearPreviews();
TileOWW furnitureTile = WorldController.Instance.GetWorld().GetTileAt(posX, posY);
TileOWW furnitureTileReturn = null;
if (furnitureTile != null)
{
// Check valid
if (CheckFurniturePreviewValid(furnitureTile, furnitureType))
{
CreatePreview(validPreviewPrefab, furnitureType.title, posX, posY);
furnitureTileReturn = furnitureTile;
}
else
{
CreatePreview(invalidPreviewPrefab, furnitureType.title, posX, posY);
}
}
// Display price UI
InputController.Instance.currentBuildPrice = furnitureType.cost;
return(furnitureTileReturn);
}
public void UpdateJob(TileOWW tileOWW)
{
if (tileOWW == null)
{
return;
}
RuleTile t;
if (tileOWW.currentJobType != null && // Has a job
((tileOWW.installedFurnitureAltX == null && tileOWW.installedFurnitureAltY == null) || // Is the origin tile of job
(tileOWW.installedFurnitureAltX == tileOWW.GetX() && tileOWW.installedFurnitureAltY == tileOWW.GetY()))) // Is the origin tile of job
{
// Create job graphics
t = Resources.Load <RuleTile>("TileSets/Furniture/" + JobQueueController.Instance.ConvertJobTypeToFurnitureType(tileOWW.currentJobType));
tilemap.SetTile(new Vector3Int(tileOWW.GetX(), tileOWW.GetY(), 0), t);
tilemap.RefreshTile(new Vector3Int(tileOWW.GetX(), tileOWW.GetY(), 0));
}
else
{
// Remove tile graphics
t = null;
tilemap.SetTile(new Vector3Int(tileOWW.GetX(), tileOWW.GetY(), 0), t);
tilemap.RefreshTile(new Vector3Int(tileOWW.GetX(), tileOWW.GetY(), 0));
}
}
protected override void Refresh()
{
// Call from superclass
base.Refresh();
// Program from here onwards
if (targetJob == null || targetJob?.GetJobType() == "Wander")
{
// Not required to use global job queue yet
// targetJob = jobQueue.GetNextJob(new Vector2(currentX, currentY), failedJobs);
DoJobAtVisibleCharacter("Enemy");
if (targetJob == null)
{
// We are idle, wander the ship
TileOWW randomTile = WorldController.Instance.GetWorld().GetRandomHullTile();
if (randomTile != null)
{
targetJob = new Job(delegate() { }, randomTile, 1f, "Wander", JobPriority.Medium, tileExcludeOtherJobs: false);
}
}
}
}
protected void DoJobAtFurnitureTile(string furnitureType, string jobType, Action action, float jobTime)
{
// Does the furnitureType exist in the world?
if (BuildModeController.Instance.furnitureTileOWWMap.ContainsKey(furnitureType))
{
// Loop through all chargers
for (int i = 0; i < BuildModeController.Instance.furnitureTileOWWMap[furnitureType].Count; i++)
{
TileOWW tileOWW = BuildModeController.Instance.furnitureTileOWWMap[furnitureType][i];
if (tileOWW.currentJobType == null)
{
if (targetJob != null)
{
if (targetJob.GetJobType() != jobType)
{
jobQueue.AddJob(targetJob);
targetJob = currentJob = null;
}
}
targetJob = new Job(action, tileOWW, 5, jobType, JobPriority.Medium);
return;
}
}
}
}
protected override void Refresh()
{
// Call from superclass
base.Refresh();
// Program from here onwards
// Find and set a target/current jobs
if (targetJob == null || targetJob?.GetJobType() == "Wander")
{
targetJob = jobQueue.GetNextJob(new Vector2(currentX, currentY), failedJobs);
if (targetJob == null)
{
// We are idle
// TODO: Go to storage and enter low power mode
// Get random hull tile
TileOWW randomHullTile = WorldController.Instance.GetWorld().GetRandomHullTile();
if (randomHullTile != null)
{
targetJob = new Job(delegate() { }, randomHullTile, 1, "Wander", JobPriority.Low, tileExcludeOtherJobs: false);
}
}
}
}
public void UpdateFurniture(TileOWW tileOWW)
{
RuleTile t;
if (tileOWW.GetInstalledFurniture() != null)
{
// Create tile graphics
t = Resources.Load <RuleTile>("TileSets/Furniture/" + tileOWW.GetInstalledFurniture().GetFurnitureType());
tilemap.SetTile(new Vector3Int(tileOWW.GetX(), tileOWW.GetY(), 0), t);
tilemap.RefreshTile(new Vector3Int(tileOWW.GetX(), tileOWW.GetY(), 0));
// Pathfinding
if (!tileOWW.GetIsWalkable())
{
// Create NavMeshObstacle GameObject
GameObject go = new GameObject();
go.name = "NavMeshBlocking: (" + tileOWW.GetX() + " ," + tileOWW.GetY() + ")";
go.transform.parent = Instance.transform;
go.transform.position = new Vector3(tileOWW.GetX(), tileOWW.GetY(), 0);
NavMeshObstacle nma = go.AddComponent <NavMeshObstacle>();
nma.center = new Vector3(0.5f, 0.5f);
// Set parameters depending on the furniture type
if (tileOWW.GetInstalledFurniture().GetFurnitureType() == "Wall")
{
nma.carving = true;
nma.size = new Vector3(0.7f, 0.7f, 1f);
}
else if (tileOWW.GetInstalledFurniture().GetFurnitureType() == "Airlock")
{
nma.size = new Vector3(1f, 1f, 1f);
go.AddComponent <AirlockDoor>();
BoxCollider2D boxCollider = go.AddComponent <BoxCollider2D>();
boxCollider.isTrigger = true;
boxCollider.offset = new Vector2(0.5f, 0.5f);
Rigidbody2D rigidbody = go.AddComponent <Rigidbody2D>();
rigidbody.constraints = RigidbodyConstraints2D.FreezeAll;
}
tileNavBlockMap.Add(tileOWW, go);
}
}
else
{
// Remove tile graphics
t = null;
tilemap.SetTile(new Vector3Int(tileOWW.GetX(), tileOWW.GetY(), 0), t);
tilemap.RefreshTile(new Vector3Int(tileOWW.GetX(), tileOWW.GetY(), 0));
if (tileNavBlockMap.ContainsKey(tileOWW))
{
if (tileNavBlockMap[tileOWW] != null)
{
// Remove NavMeshObstacle GameObject
GameObject go = tileNavBlockMap[tileOWW];
tileNavBlockMap.Remove(tileOWW);
Destroy(go);
}
}
}
}
private void TileOxygen(TileOWW originTile, TileOWW nextTile)
{
// Base case #1
if (nextTile.GetInstalledFurniture()?.GetFurnitureType() == "Wall" || nextTile.GetInstalledFurniture()?.GetFurnitureType() == "Airlock")
{
return;
}
// Base case #2
if (!uncheckedTiles.Contains(nextTile))
{
return;
}
// Main
oxygenTileGroups[originTile].Add(nextTile);
if (uncheckedTiles.Contains(nextTile))
{
uncheckedTiles.Remove(nextTile);
}
// Base case #3
// Note we still add this tile to the group without spreading to other tiles
if (nextTile.GetTileType() == "Empty")
{
return;
}
// Spread to next tiles
TileOWW tileNorth = WorldController.Instance.GetWorld().GetTileAt(nextTile.GetX(), nextTile.GetY() + 1);
TileOWW tileEast = WorldController.Instance.GetWorld().GetTileAt(nextTile.GetX() + 1, nextTile.GetY());
TileOWW tileSouth = WorldController.Instance.GetWorld().GetTileAt(nextTile.GetX(), nextTile.GetY() - 1);
TileOWW tileWest = WorldController.Instance.GetWorld().GetTileAt(nextTile.GetX() - 1, nextTile.GetY());
if (tileNorth != null)
{
{
TileOxygen(originTile, tileNorth);
}
}
if (tileEast != null)
{
{
TileOxygen(originTile, tileEast);
}
}
if (tileSouth != null)
{
{
TileOxygen(originTile, tileSouth);
}
}
if (tileWest != null)
{
{
TileOxygen(originTile, tileWest);
}
}
}
public bool TryDestroyJob(TileOWW tileOWW, JobPriority jobPriority)
{
List <Job> jobList = new List <Job>();
if (jobPriority == JobPriority.User)
{
jobList = jobs_user;
}
else if (jobPriority == JobPriority.High)
{
jobList = jobs_high;
}
else if (jobPriority == JobPriority.Medium)
{
jobList = jobs_med;
}
else if (jobPriority == JobPriority.Low)
{
jobList = jobs_low;
}
// Check the jobList first
foreach (Job job in jobList)
{
if (job.GetTileOWW() == tileOWW)
{
jobList.Remove(job);
tileOWW.currentJobType = null;
JobSpriteController.Instance.UpdateJob(tileOWW);
return(true);
}
}
// Now check all staff
foreach (GameObject staffGO in WorldController.Instance.staff)
{
if (staffGO.GetComponent <Staff>().currentJob != null)
{
if (staffGO.GetComponent <Staff>().currentJob.GetTileOWW() == tileOWW)
{
staffGO.GetComponent <Staff>().currentJob = staffGO.GetComponent <Staff>().targetJob = null;
tileOWW.currentJobType = null;
JobSpriteController.Instance.UpdateJob(tileOWW);
return(true);
}
}
if (staffGO.GetComponent <Staff>().targetJob != null)
{
if (staffGO.GetComponent <Staff>().targetJob.GetTileOWW() == tileOWW)
{
staffGO.GetComponent <Staff>().currentJob = staffGO.GetComponent <Staff>().targetJob = null;
tileOWW.currentJobType = null;
JobSpriteController.Instance.UpdateJob(tileOWW);
return(true);
}
}
}
return(false);
}
private void CreateRemoveFurnitureAction(TileOWW tile, int offsetX = 0, int offsetY = 0)
{
Action removeFurnitureAction = delegate() { RemoveFurniture(tile); };
Job j = new Job(removeFurnitureAction, tile, 2, "Remove " + tile.GetInstalledFurniture().GetFurnitureType(), JobPriority.Medium);
j.SetAltPosition(tile.GetX() + offsetX, tile.GetY() + offsetY);
tile.currentJobType = j.GetJobType();
JobQueueController.BuildersJobQueue.AddJob(j);
}
public void PlaceHull(TileOWW tile)
{
tile.SetTileType("Hull");
emptyHullTiles.Add(tile);
allHullTiles.Add(tile);
// Event checks
ObjectiveController.Instance.CheckObjectives();
}
public List <TileOWW> PreviewFurniture(FurnitureType furnitureType, int start_x, int end_x, int start_y, int end_y)
{
List <TileOWW> furniture_tiles = new List <TileOWW>();
ClearPreviews();
int estimatedCost = 0;
for (int x = start_x; x <= end_x; x++)
{
for (int y = start_y; y <= end_y; y++)
{
TileOWW t = WorldController.Instance.GetWorld().GetTileAt(x, y);
if (t != null)
{
// Check valid
if (CheckFurniturePreviewValid(t, furnitureType))
{
furniture_tiles.Add(t);
CreatePreview(validPreviewPrefab, furnitureType.title, x, y);
estimatedCost += furnitureType.cost;
}
else
{
CreatePreview(invalidPreviewPrefab, furnitureType.title, x, y);
}
}
}
}
// Display price UI
InputController.Instance.currentBuildPrice = estimatedCost;
if (estimatedCost > CurrencyController.Instance.GetBankBalance())
{
ClearPreviews();
for (int x = start_x; x <= end_x; x++)
{
for (int y = start_y; y <= end_y; y++)
{
TileOWW t = WorldController.Instance.GetWorld().GetTileAt(x, y);
if (t != null)
{
CreatePreview(invalidPreviewPrefab, furnitureType.title, x, y);
}
}
}
return(null);
}
else
{
return(furniture_tiles);
}
}
public World(int width, int height)
{
// Tile array
tiles = new TileOWW[width, height];
for (int i = 0; i < width; i++)
{
for (int j = 0; j < height; j++)
{
tiles[i, j] = new TileOWW(i, j, "Empty");
}
}
}
// Overloaded method for planing single furniture jobs at once
public void PlanFurniture(TileOWW furnitureTile, FurnitureType furnitureType)
{
if (furnitureTile != null)
{
// Check validity for multi-tile
for (int i = 0; i < furnitureType.sizeX; i++)
{
for (int j = 0; j < furnitureType.sizeY; j++)
{
TileOWW temp = WorldController.Instance.GetWorld().GetTileAt(furnitureTile.GetX() + i, furnitureTile.GetY() + j);
if (temp.currentJobType != null)
{
Debug.Log("Unable to place job baceause tile already had an existing job: " + temp.currentJobType);
return; // Failed to place
}
}
}
Action placeFurnitureAction = delegate() { PlaceFurniture(furnitureTile, furnitureType.title); };
Job job;
// Allow certain furniture to overwrite others by creating a prerequisite removal job
if (furnitureTile.GetInstalledFurniture()?.GetFurnitureType() == "Wall" && furnitureType.title == "Airlock")
{
Action removeExistingFurnitureAction = delegate() { RemoveFurniture(furnitureTile); };
Job prerequisiteJob = new Job(removeExistingFurnitureAction, furnitureTile, 2, "Remove Wall", JobPriority.Medium);
job = new Job(placeFurnitureAction, furnitureTile, furnitureType.installTime, "Build " + furnitureType.title, JobPriority.Medium, prerequisiteJob);
}
else
{
job = new Job(placeFurnitureAction, furnitureTile, furnitureType.installTime, "Build " + furnitureType.title, JobPriority.Medium);
}
furnitureTile.currentJobType = job.GetJobType();
JobQueueController.BuildersJobQueue.AddJob(job);
// Invoice
CurrencyController.Instance.DeductBankBalance(furnitureType.cost);
// Multi-tile furniture items
for (int i = 0; i < furnitureType.sizeX; i++)
{
for (int j = 0; j < furnitureType.sizeY; j++)
{
TileOWW temp = WorldController.Instance.GetWorld().GetTileAt(furnitureTile.GetX() + i, furnitureTile.GetY() + j);
temp.currentJobType = furnitureTile.currentJobType;
temp.installedFurnitureAltX = furnitureTile.GetX();
temp.installedFurnitureAltY = furnitureTile.GetY();
}
}
}
}
public TileOWW PreviewRemoveFurniture(int posX, int posY)
{
ClearPreviews();
TileOWW tileOWW = WorldController.Instance.GetWorld().GetTileAt(posX, posY);
// Check valid
if (tileOWW?.GetInstalledFurniture()?.GetFurnitureType() == "Wall" || tileOWW?.currentJobType == "Build Wall")
{
CreatePreview(removePreviewPrefab, "Wall", posX, posY);
return(tileOWW);
}
return(null);
}
public bool CheckFurniturePreviewValid(TileOWW tile, FurnitureType furnitureType)
{
if (furnitureType.cost > CurrencyController.Instance.GetBankBalance())
{
// Debug.Log("Couldn't affoard.");
return(false);
}
// Check all tiles of multi-tile furniture
for (int i = 0; i < furnitureType.sizeX; i++)
{
for (int j = 0; j < furnitureType.sizeY; j++)
{
TileOWW t = WorldController.Instance.GetWorld().GetTileAt(tile.GetX() + i, tile.GetY() + j);
if ((t.GetTileType() == "Hull" && furnitureType.exteriorOnly) || (t.GetTileType() == "Empty" && !furnitureType.exteriorOnly))
{
// Debug.Log("Interior / exterior check failed.");
return(false);
}
if (t.installedFurnitureAltX != null || t.installedFurnitureAltY != null)
{
//Allow certain furniture to overwrite others
if (t.GetInstalledFurniture()?.GetFurnitureType() == "Wall" && furnitureType.title == "Airlock")
{
return(true);
}
// Debug.Log("Multi-tile furniture check failed.");
return(false);
}
if (t.GetInstalledFurniture() != null)
{
//Allow certain furniture to overwrite others
if (t.GetInstalledFurniture().GetFurnitureType() == "Wall" && furnitureType.title == "Airlock")
{
return(true);
}
// Debug.Log("Installed furniture check failed");
return(false);
}
if (t.currentJobType != null)
{
// Debug.Log("Existing job check failed.");
return(false);
}
}
}
// All checks passed, furniture is valid.
return(true);
}
public void PreviewStaff(string staffType, int posX, int posY)
{
ClearPreviews();
TileOWW staffTile = WorldController.Instance.GetWorld().GetTileAt(posX, posY);
if (CurrencyController.Instance.GetBankBalance() >= 500)
{
CreatePreview(validPreviewPrefab, staffType, posX, posY);
}
else
{
CreatePreview(invalidPreviewPrefab, staffType, posX, posY);
}
// Display price UI
InputController.Instance.currentBuildPrice = 1000;
}
public void UpdateRoom(TileOWW tileOWW)
{
RuleTile t;
if (tileOWW.GetRoomType() != null)
{
// Create room graphics
t = Resources.Load <RuleTile>("TileSets/Rooms/" + tileOWW.GetRoomType());
tilemap.SetTile(new Vector3Int(tileOWW.GetX(), tileOWW.GetY(), 0), t);
tilemap.RefreshTile(new Vector3Int(tileOWW.GetX(), tileOWW.GetY(), 0));
}
else
{
// Remove tile graphics
t = null;
tilemap.SetTile(new Vector3Int(tileOWW.GetX(), tileOWW.GetY(), 0), t);
tilemap.RefreshTile(new Vector3Int(tileOWW.GetX(), tileOWW.GetY(), 0));
}
}
public void RemoveFurniture(TileOWW tile)
{
string furnitureType = tile.GetInstalledFurniture()?.GetFurnitureType();
// 'Airlock' may be in 'Airlock Open' state
if (furnitureType == "Airlock Open")
{
furnitureType = "Airlock";
}
// Update pathfinding
if (furnitureType == "Wall")
{
// TODO: reset all failed jobs
}
tile.RemoveInstalledFurniture();
// Multi-tile references
for (int i = 0; i < furnitureTypes[furnitureType].sizeX; i++)
{
for (int j = 0; j < furnitureTypes[furnitureType].sizeY; j++)
{
TileOWW temp = WorldController.Instance.GetWorld().GetTileAt(tile.GetX() + i, tile.GetY() + j);
temp.installedFurnitureAltX = null;
temp.installedFurnitureAltY = null;
if (tile.GetTileType() == "Hull")
{
emptyHullTiles.Add(tile);
}
}
}
// Remove from map of furnitureType TileOWW
while (furnitureTileOWWMap[furnitureType].Contains(tile))
{
furnitureTileOWWMap[furnitureType].Remove(tile);
}
ObjectiveController.Instance.CheckObjectives();
}
// TODO: Return true before marking off the other tiles as checked!!
private bool CheckTile(TileOWW tile, List <TileOWW> tilesToCheck)
{
if (tilesToCheck.Contains(tile))
{
tilesToCheck.Remove(tile);
bool isSuccessful = false;
if (CheckTile(WorldController.Instance.GetWorld().GetTileAt(tile.GetX(), tile.GetY() + 1), tilesToCheck))
{
isSuccessful = true;
}
if (CheckTile(WorldController.Instance.GetWorld().GetTileAt(tile.GetX(), tile.GetY() - 1), tilesToCheck))
{
isSuccessful = true;
}
if (CheckTile(WorldController.Instance.GetWorld().GetTileAt(tile.GetX() + 1, tile.GetY()), tilesToCheck))
{
isSuccessful = true;
}
if (CheckTile(WorldController.Instance.GetWorld().GetTileAt(tile.GetX() - 1, tile.GetY()), tilesToCheck))
{
isSuccessful = true;
}
if (isSuccessful)
{
return(true);
}
if (tile.GetInstalledFurniture()?.GetFurnitureType() == "Charging Pad") // TODO: The validity will be horrible
{
return(true);
}
return(false);
}
else
{
return(false);
}
}
public void UpdateTile(TileOWW tile)
{
Tile t;
if (!tileObjectMap.ContainsKey(tile))
{
// The tile might not exist when loading a game from file
t = ScriptableObject.CreateInstance <Tile>();
t.name = tile.GetX() + "_" + tile.GetY();
t.sprite = Resources.Load <Sprite>("Images/Tiles/" + tile.GetTileType());
tilemap.SetTile(new Vector3Int(tile.GetX(), tile.GetY(), 0), t);
tileObjectMap.Add(tile, t);
}
else
{
t = tileObjectMap[tile];
t.sprite = Resources.Load <Sprite>("Images/Tiles/" + tile.GetTileType());
tilemap.RefreshTile(new Vector3Int(tile.GetX(), tile.GetY(), 0));
}
}
void UpdateTileInterface()
{
// Abort if in any building mode
if (isMode_Plopable || isMode_Dragable)
{
return;
}
if (Input.GetMouseButtonUp(0)) // LMB
{
// Check if player clicked on something other than a tile
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
if (Physics.Raycast(ray, out RaycastHit hit))
{
if (hit.collider.tag != "NavigationPlane")
{
return;
}
}
// Get tile clicked on
Vector3 mousePos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
TileOWW tileOWW = WorldController.Instance.GetWorld().GetTileAt((int)mousePos.x, (int)mousePos.y);
// Null checks
if (tileOWW == null)
{
return;
}
if (tileOWW.GetTileType() == "Empty" && tileOWW.currentJobType == null)
{
return;
}
// Create interface
tileInterfaceGO = Instantiate(tileInterfacePrefab);
tileInterfaceGO.GetComponent <TileInterface>().tile = tileOWW;
tileInterfaceGO.GetComponent <TileInterface>().tileType.text = tileOWW.GetTileType();
}
}
public void PlaceFurniture(TileOWW tile, string furnitureType)
{
tile.SetInstalledFurniture(new InstalledFurniture(furnitureType));
// Add to map of furnitureType TileOWW
if (!furnitureTileOWWMap.ContainsKey(furnitureType))
{
furnitureTileOWWMap.Add(furnitureType, new List <TileOWW>());
}
furnitureTileOWWMap[furnitureType].Add(tile);
// If engines built, update ship speed
// TODO: Different types of engines
if (furnitureType == "Engine")
{
// TODO: Different speeds per engine
JourneyController.Instance.shipSpeedMax = furnitureTileOWWMap[furnitureType].Count * 5;
}
// Multi-tile references
if (!furnitureTypes.ContainsKey(furnitureType))
{
Debug.LogError("This key wasnt found: " + furnitureType);
}
for (int i = 0; i < furnitureTypes[furnitureType].sizeX; i++)
{
for (int j = 0; j < furnitureTypes[furnitureType].sizeY; j++)
{
TileOWW temp = WorldController.Instance.GetWorld().GetTileAt(tile.GetX() + i, tile.GetY() + j);
temp.currentJobType = null;
temp.installedFurnitureAltX = tile.GetX();
temp.installedFurnitureAltY = tile.GetY();
emptyHullTiles.Remove(tile);
}
}
ObjectiveController.Instance.CheckObjectives();
}
public Job ToJob()
{
Job p = null;
if (prerequisiteJob != null)
{
p = prerequisiteJob.ToJob();
}
TileOWW tile = WorldController.Instance.GetWorld().GetTileAt(tilePosX, tilePosY);
if (tile == null)
{
Debug.LogWarning("Just made a job with no tile");
}
Job job = new Job(tile, jobTime, jobType, tileExcludeOtherJobs, jobPriority, p);
job.SetAltPosition(jobPosX, jobPosY);
return(job);
}
public List <TileOWW> PreviewRemoveFurniture(int start_x, int end_x, int start_y, int end_y)
{
List <TileOWW> furniture_tiles = new List <TileOWW>();
ClearPreviews();
// Loop through all the tiles
for (int x = start_x; x <= end_x; x++)
{
for (int y = start_y; y <= end_y; y++)
{
TileOWW tileOWW = WorldController.Instance.GetWorld().GetTileAt(x, y);
// Check valid
if (tileOWW != null)
{
if (tileOWW.GetInstalledFurniture() != null)
{
if (tileOWW.GetInstalledFurniture().GetFurnitureType() != "Wall") // Do NOT remove wall furniture items!
{
furniture_tiles.Add(tileOWW);
CreatePreview(removePreviewPrefab, "Hull", x, y);
}
}
// Allow removal of build jobs that are not walls
else if (tileOWW.currentJobType != null)
{
if (tileOWW.currentJobType.Contains("Build") && !tileOWW.currentJobType.Contains("Wall") && !tileOWW.currentJobType.Contains("Hull"))
{
furniture_tiles.Add(tileOWW);
CreatePreview(removePreviewPrefab, "Hull", x, y);
}
}
}
}
}
return(furniture_tiles);
}
public List <TileOWW> PreviewRemoveWall(int start_x, int end_x, int start_y, int end_y)
{
List <TileOWW> wall_tiles = new List <TileOWW>();
ClearPreviews();
// Loop through all the tiles
for (int x = start_x; x <= end_x; x++)
{
for (int y = start_y; y <= end_y; y++)
{
TileOWW tileOWW = WorldController.Instance.GetWorld().GetTileAt(x, y);
// Check valid
if (tileOWW?.GetInstalledFurniture()?.GetFurnitureType() == "Wall" || tileOWW?.currentJobType == "Build Wall") // Only remove wall furniture items!
{
wall_tiles.Add(tileOWW);
CreatePreview(removePreviewPrefab, "Wall", x, y);
}
}
}
return(wall_tiles);
}
