void onUnload()
{
// This handles object carryover
PlacementGrid pgrid = levelGameObject.GetComponent <PlacementGrid>();
foreach (DragAbleObject item in pgrid.heldObjects)
{
loader.ItemCarryOver.Add(item.gameObject);
}
foreach (GameObject item in items)
{
// Only destroy items where neccesary
if (!loader.ItemCarryOver.Contains(item))
{
Destroy(item);
}
else
{
item.transform.parent = null;
}
}
items.Clear();
Destroy(levelGameObject);
levelGameObject = null;
Destroy(decorationContainer);
Destroy(rolloverItemObject);
}
private DemoPresentation myDemo; // FOR PRESENTATION ONLY
private void Start()
{
myDemo = GameObject.FindGameObjectWithTag("Manager").GetComponent <DemoPresentation>(); // FOR PRESENTATION ONLY
cam = GameObject.FindGameObjectWithTag("MainCamera").GetComponent <Camera>();
mySpawnChooser = GameObject.FindGameObjectWithTag("Manager").GetComponent <SpawnChooser>();
highlight = GameObject.FindGameObjectWithTag("Highlight");
grid = gameObject.GetComponent <PlacementGrid>();
}
public void HandleEvent(LevelLoadState state)
{
switch (state)
{
case LevelLoadState.POSTLOAD:
placementGrid = levelMan.Levels[levelMan.currentLevel].levelGameObject.GetComponent <PlacementGrid>();
break;
}
}
private void Awake()
{
foreach (var obj in FindObjectsOfType <GridObject>())
{
if (obj.AutoAddToGrid)
{
_gridObjects.Add(new GridObjectData(obj, PlacementGrid.GetCoordFromCorner(obj.transform.position)));
}
}
}
private void Start()
{
if (!grid)
{
grid = GetComponent <PlacementGrid>();
}
if (isBedroom)
{
GuestManager.instance.rooms.Add(this);
}
}
public void Build(Building building)
{
PlacementGrid script = placementGrid.GetComponent <PlacementGrid>();
if (building.Equals(script.buildingPattern))
{
placementGrid.SetActive(!placementGrid.activeSelf);
}
else
{
placementGrid.SetActive(true);
script.buildingPattern = building;
}
}
public void RenderImageToDesktop(string filename)
{
var height = PlacementGrid.Height;
var width = PlacementGrid.Width;
var bm = new Bitmap(width, height);
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
if (BlockedGrid.IsSet(x, y))
{
bm.SetPixel(x, height - y - 1, Color.Red);
}
else if (Creep.IsSet(x, y))
{
bm.SetPixel(x, height - y - 1, Color.Purple);
}
else if (Explored.IsSet(x, y))
{
if (PlacementGrid.IsSet(x, y))
{
bm.SetPixel(x, height - y - 1, Color.LightBlue);
}
else
{
bm.SetPixel(x, height - y - 1, Color.DarkBlue);
}
}
else if (PlacementGrid.IsSet(x, y))
{
if (NaturalGrid.IsSet(x, y))
{
bm.SetPixel(x, height - y - 1, Color.Pink);
}
else
{
bm.SetPixel(x, height - y - 1, Color.Green);
}
}
else
{
bm.SetPixel(x, height - y - 1, Color.Black);
}
}
}
bm.Save($"{Environment.GetFolderPath(Environment.SpecialFolder.Desktop)}\\{filename}.BMP");
}
/*
* This method returns if the obstacle can be placed at the given cell in the gameworld.
* Params - obstacleGrid: the PlacementGrid of the obstacle you are testing
* cell: the cell to test placement on
*/
bool CanPlaceObject(PlacementGrid obstacleGrid, PGridCell cell) {
// False if grid bounding box goes outside bounds of level
if (obstacleGrid.Height + cell.Row > levelPGrid.Height
|| obstacleGrid.Width + cell.Col > levelPGrid.Width)
return false;
// Go through obstacle's placement grid and make sure that each spot
// it needs is available, starting at cell
for (int r = 0; r < obstacleGrid.Height; r++) {
for (int c = 0; c < obstacleGrid.Width; c++) {
// If a cell is closed on the obstacle then it is occupied
// If a cell is closed on the main grid, it is occpupied or adjacent to an occupied spot
if (obstacleGrid.Closed(r, c)
&& levelPGrid.Closed(cell.Row + r, cell.Col + c)) {
return false;
}
}
}
return true;
}
private bool ValidPlacement(int xPosition, int yPosition, int size, bool requiresCreep = false, bool requiresPower = false, bool avoidCreep = true, bool avoidNatural = false)
{
var mx = xPosition + size;
var my = yPosition + size;
for (int x = xPosition; x < mx; x++)
{
for (int y = yPosition; y < my; y++)
{
if (BlockedGrid.IsSet(x, y))
{
return(false);
}
if (!PlacementGrid.IsSet(x, y))
{
return(false);
}
if (requiresCreep && !Creep.IsSet(x, y))
{
return(false);
}
if (avoidCreep && Creep.IsSet(x, y))
{
return(false);
}
if (requiresPower && !Power.IsSet(x, y))
{
return(false);
}
if (avoidNatural && NaturalGrid.IsSet(x, y))
{
return(false);
}
}
}
return(true);
}
/*
* This method calculates the new spots that are no longer available after object placement
* Params - obstacleGrid: the PlacementGrid for the obstacle just placed
* r, c: the row and column the obstacle was placed
*/
void CalculateAvailableCells(PlacementGrid obstacleGrid, int r, int c) {
// Every cell around a closed cell in obstacleGrid is no longer available
foreach(PGridCell cell in obstacleGrid.Cells()) {
if (cell.Closed) {
// remember that there is actually an obstacle at this cell
occupiedGrid.SetCell (r + cell.Row, c + cell.Col, true);
for (int i = r + cell.Row - 1; i <= r + cell.Row + 1; i++) {
for (int j = c + cell.Col - 1; j <= c + cell.Col + 1; j++) {
if (i >= 0 && i < levelPGrid.Height
&& j >= 0 && j < levelPGrid.Width) {
levelPGrid.SetCell (i, j, true);
//GameManager.objects.Create (ResourcePaths.SpotMarker, new Vector3 (j+.5f, -i-.5f, 0), Quaternion.identity);
}
}
}
}
}
}
/*
* Just testing out using this class before we have level loading implemented
*/
public void CreateSampleLevel() {
// Level parameters, all to be loaded from an xml file
int levelWidth = 9, levelHeight = 5;
int levelPressure = 600;
int levelTemperature = 200;
string levelBorder = ResourcePaths.SampleBorder;
string[] levelObstacles = { ResourcePaths.SampleObstacle, ResourcePaths.SmallSampleObstacle };
int[] levelObstacleAmounts = { 1, 2 };
string[] levelMolecules = { ResourcePaths.OxygenMolecule, ResourcePaths.NitrogenMolecule, ResourcePaths.CarbonMolecule, ResourcePaths.CarbonDioxideMolecule };
int[] levelMoleculeAmounts = { 2, 1, 0, 0 };
string playerMoleculeString = ResourcePaths.CarbonMolecule;
GameManager.worldProperties.SetInitialParams (levelWidth, levelHeight, levelPressure, levelTemperature);
// Create grids for level generator
bool[] gridSpots = new bool[levelWidth * levelHeight];
Array.Clear (gridSpots, 0, gridSpots.Length);
levelPGrid = new PlacementGrid (levelWidth, levelHeight, gridSpots);
occupiedGrid = new PlacementGrid (levelWidth, levelHeight, gridSpots);
// Place level border
var border = GameManager.objects.Create(levelBorder);
PlaceObstacleAtLocation (border, 0, 0);
// Place level obstacles
for (int i = 0; i < levelObstacles.Length; i++) {
for (int o = 0; o < levelObstacleAmounts [i]; o++) {
var obstacle = GameManager.objects.Create (levelObstacles [i]);
if (!PlaceObstacleRandomly (obstacle))
obstacle.SetActive (false);
}
}
// Place level molecules
for (int i = 0; i < levelMolecules.Length; i++) {
for (int m = 0; m < levelMoleculeAmounts [i]; m++) {
var molecule = GameManager.objects.Create (levelMolecules [i]);
if (!PlaceMoleculeRandomly (molecule))
molecule.SetActive (false);
}
}
// Place player
var playerMolecule = GameManager.objects.Create (playerMoleculeString);
var player = GameManager.objects.Create(ResourcePaths.Player);
playerMolecule.transform.SetParent (player.transform);
//Removes the child rigidbody from the player's molecule
Destroy(playerMolecule.GetComponent<Rigidbody2D>());
if (!PlaceMoleculeRandomly (player))
player.SetActive (false);
PlayerManager playerM = player.GetComponent<PlayerManager>();
GameManager.worldProperties.SetPlayer (ref playerM);
}
// Create internal grid if it hasn't been created yet
private void CreateGrid() {
if (grid == null) {
grid = new PlacementGrid (width, height, closedSpots);
}
}
private void Awake()
{
player = GameObject.FindGameObjectWithTag("Player").GetComponent <Player>();
playerCam = player.GetComponentInChildren <Camera>();
placementGrid = gameObject.AddComponent <PlacementGrid>();
}
public void AddToGrid(PlacementGrid grid)
{
currentGrid = GameObject.Find("Placement Grid").GetComponent <PlacementGrid>();
currentGrid.Place(this, gridLayer);
connectedToCells = GetOverlapCells(false);
}
public void RemoveFromGrid()
{
currentGrid.RemoveObject(this);
currentGrid = null;
}
