public void SaveFileWasLoaded(BuildingsOnMap[] saveFileBuildingsData, RoadsOnMap[] saveFileRoadsData)
{
// Removes existing buildings first
RemoveAllBuildingsFromMap_Quietly();
BaseBuildingsClass savedBuilding = null;
Vector3 savedPosition = Vector3.zero;
for (int i = 0; i < saveFileBuildingsData.Length; ++i)
{
savedPosition.x = saveFileBuildingsData[i].worldPosX;
savedPosition.y = saveFileBuildingsData[i].worldPosY;
savedBuilding = Instantiate(BuildingDataBase.GetInstance().GetBaseBuildingGO(), savedPosition, Quaternion.identity).GetComponent <BaseBuildingsClass>();
savedBuilding.SetNewBuildingType(BuildingDataBase.GetInstance().GetBuildingData((BuildingDataBase.BUILDINGS)saveFileBuildingsData[i].buildingType));
PlaceBuildingToGrid(ref savedBuilding);
}
//do the same for the roads
for (int i = 0; i < saveFileRoadsData.Length; ++i)
{
savedPosition.x = saveFileRoadsData[i].worldPosX;
savedPosition.y = saveFileRoadsData[i].worldPosY;
savedBuilding = Instantiate(BuildingDataBase.GetInstance().GetBaseBuildingGO(), savedPosition, Quaternion.identity).GetComponent <BaseBuildingsClass>();
savedBuilding.SetNewBuildingType(BuildingDataBase.GetInstance().GetBuildingData(BuildingDataBase.BUILDINGS.B_ROAD));
//set to the correct road direction sprite
RoadTypeList roadType = (RoadTypeList)saveFileRoadsData[i].roadType;
savedBuilding.SetSprite(BuildingDataBase.GetInstance().GetRoadSprite(roadType));
StoreLoadedRoads(savedBuilding, roadType);
}
}
public RoadsOnMap[] GetSavedRoads()
{
RoadsOnMap[] saveRoadsData = new RoadsOnMap[m_RoadSpriteRendererMap.Count];
int index = 0;
foreach (KeyValuePair <Vector2Int, BaseBuildingsClass> road in m_RoadSpriteRendererMap)
{
BaseBuildingsClass baseRoad = road.Value;
if (baseRoad == null)
{
continue;
}
saveRoadsData[index] = new RoadsOnMap();
saveRoadsData[index].worldPosX = baseRoad.transform.position.x;
saveRoadsData[index].worldPosY = baseRoad.transform.position.y;
//get and store the type
int indexConverted = Convert2DToIntIndex(road.Key);
if (m_RoadMap.ContainsKey(indexConverted))
{
saveRoadsData[index].roadType = (int)m_RoadMap[indexConverted];
}
++index;
}
return(saveRoadsData);
}
public void PlayerOpenAddEditorMode(BaseBuildingsClass building)
{
//open NPC player editor mode
if (NPCManager.Instance != null)
{
NPCManager.Instance.PlayerEditorModeActive(true);
}
SetBuildModeUI(building);
}
/// <summary>
/// Removes the Building from Grid by setting it's array spots back to untaken, then returns it
/// </summary>
/// <param name="activeBuildingCom"></param>
/// <returns></returns>
GameObject RemoveBuildingFromGrid(BaseBuildingsClass activeBuildingCom)
{
Vector3 buildingBottomLeftWorldPos = activeBuildingCom.GetBottomLeftGridPosition();
Vector2Int buildingSize = activeBuildingCom.GetBuildingSizeOnMap();
// Set all the grids taken by building to false, since no longer there
SetGridTakenArray(buildingBottomLeftWorldPos, buildingSize, false);
RemoveBuildingFromTrackingDictionary(activeBuildingCom);
return(activeBuildingCom.gameObject);
}
public BaseBuildingsClass GetBuildingIfOnMap(BaseBuildingsClass buildingToCheck)
{
foreach (KeyValuePair <Vector2Int, BaseBuildingsClass> entry in m_DictOfBuildingsOnMap)
{
if (entry.Value == buildingToCheck)
{
return(entry.Value);
}
}
return(null);
}
/// <summary>
/// Creates a new Building GO and tries to place it into the Grid.
/// Destroys Building GO if unable to and returns null, returns the newly created GO otherwise
/// </summary>
/// <param name="spawnWorldPos">Where to spawn the Building (Transform's Position)</param>
/// <param name="buildingID">What type of Building</param>
/// <param name="doCheckingGridTaken">Are any of the spots taken by another building already?</param>
/// <returns></returns>
BaseBuildingsClass PlaceBuildingToGrid(Vector2 spawnWorldPos, BuildingDataBase.BUILDINGS buildingID, bool doCheckingGridTaken = false)
{
// Check if we need to create a Custom Building GO
BaseBuildingsClass newBuilding = null;
if (BuildingDataBase.GetInstance().GetBuildingData(buildingID).GetOwnCustomBuildingObject())
{
GameObject customBuilding = BuildingDataBase.GetInstance().GetBuildingData(buildingID).GetOwnCustomBuildingObject();
newBuilding = Instantiate(customBuilding, spawnWorldPos, Quaternion.identity).GetComponent <BaseBuildingsClass>();
}
else
{
newBuilding = Instantiate(BuildingDataBase.GetInstance().GetBaseBuildingGO(), spawnWorldPos, Quaternion.identity).GetComponent <BaseBuildingsClass>();
}
newBuilding.SetNewBuildingType(BuildingDataBase.GetInstance().GetBuildingData(buildingID));
Vector3 buildingBottomLeftWorldPos = newBuilding.GetBottomLeftGridPosition();
Vector2Int buildingSize = newBuilding.GetBuildingSizeOnMap();
// Can we place it there?
if (doCheckingGridTaken)
{
if (!CanPlaceBuildingOnMap(buildingBottomLeftWorldPos, buildingSize))
{
Destroy(newBuilding.gameObject);
return(null);
}
}
// Set all the grids taken by new building to true
SetGridTakenArray(buildingBottomLeftWorldPos, buildingSize, true);
AddBuildingIntoTrackingDictionary(newBuilding); //roads and buildings store accordingly
newBuilding.BuildingPlaced();
// Change Sprite Layer back to default
newBuilding.SetSpriteObjectLayer(0);
newBuilding.gameObject.name = BuildingDataBase.GetInstance().GetBuildingData(buildingID).GetBuildingName();
// Set Sprite's Sorting Order
int newOrder = (int)newBuilding.GetBottomLeftGridPosition().y;
newOrder = -newOrder;
newBuilding.SetSpriteSortingOrder(newOrder);
//set the correct parent
if (newBuilding.GetBuildingType() == BuildingDataBase.BUILDINGS.B_ROAD)
{
newBuilding.gameObject.transform.SetParent(m_RoadParent);
}
else
{
newBuilding.gameObject.transform.SetParent(m_BuildingParent);
}
return(newBuilding);
}
/// <summary>
/// Removes a building from the tracking Dictionary
/// </summary>
/// <param name="activeBuildingCom"></param>
void RemoveBuildingFromTrackingDictionary(BaseBuildingsClass activeBuildingCom)
{
Vector2Int key = (Vector2Int)m_GridGO.WorldToCell(activeBuildingCom.GetBottomLeftGridPosition());
if (m_DictOfBuildingsOnMap.ContainsKey(key)) //if have remove
{
m_DictOfBuildingsOnMap.Remove(key);
return;
}
//check roads instead if its not in building map
m_RoadManager.RemoveRoads(key);
}
//private void Update()
//{
// Vector3Int gridPos = m_currentMap.GetTileMapCom().WorldToCell(Camera.main.ScreenToWorldPoint(Input.mousePosition));
// Debug.Log("GridPOs: " + gridPos + "\n" + m_currentMap.GetTileMapCom().HasTile(gridPos));
// Debug.Log("Tile at : " + gridPos + "\n" + m_currentMap.GetTileMapCom().GetTile(gridPos));
//}
public void SetBuildModeUI(BaseBuildingsClass building)
{
//set UI
if (building != null)
{
SpriteRenderer buildingSprite = building.GetSpriteRenderer();
if (buildingSprite != null)
{
Vector2 uiOffset = new Vector2(0.0f, buildingSprite.bounds.size.y / 2.0f);
IngameUIManager.instance.BuildModeUIOpen(building.GetSpriteGO().transform, uiOffset, building.GetBuildingSizeOnMap(), building.GetBuildingSpriteSize());
}
}
}
public void StoreLoadedInRoads(Vector2Int key, BaseBuildingsClass roadInfo, RoadTypeList roadType)
{
if (CheckMapAvailability(key)) //if key exists, do early return
{
return;
}
m_RoadSpriteRendererMap.Add(key, roadInfo);
int indexConverted = Convert2DToIntIndex(key);
m_RoadMap.Add(indexConverted, roadType);
}
/// <summary>
/// Tries to place a Building into the Grid from it's world Position.
/// Returns null if Unable to, returns the newly created GO otherwise
/// </summary>
/// <param name="activeBuildingCom">The Building GO to place</param>
/// <param name="doCheckingGridTaken">Are any of the spots taken by another building already?</param>
/// <returns></returns>
BaseBuildingsClass PlaceBuildingToGrid(ref BaseBuildingsClass activeBuildingCom, bool doCheckingGridTaken = false)
{
// Check if we need to create a Custom Building GO
if (BuildingDataBase.GetInstance().GetBuildingData(activeBuildingCom.GetBuildingType()).GetOwnCustomBuildingObject())
{
Vector3 buildingPos = activeBuildingCom.transform.position;
BuildingDataBase.BUILDINGS buildingID = activeBuildingCom.GetBuildingType();
Destroy(activeBuildingCom.gameObject);
GameObject customBuilding = BuildingDataBase.GetInstance().GetBuildingData(buildingID).GetOwnCustomBuildingObject();
activeBuildingCom = Instantiate(customBuilding, buildingPos, Quaternion.identity).GetComponent <BaseBuildingsClass>();
activeBuildingCom.SetNewBuildingType(BuildingDataBase.GetInstance().GetBuildingData(buildingID));
}
Vector3 buildingBottomLeftWorldPos = activeBuildingCom.GetBottomLeftGridPosition();
Vector2Int buildingSize = activeBuildingCom.GetBuildingSizeOnMap();
//Debug.Log("GRID POS: " + m_GridGO.WorldToCell(buildingWorldPos));
// Can we place it there?
if (doCheckingGridTaken)
{
if (!CanPlaceBuildingOnMap(buildingBottomLeftWorldPos, buildingSize))
{
return(null);
}
}
// Set all the grids taken by new building to true
SetGridTakenArray(buildingBottomLeftWorldPos, buildingSize, true);
AddBuildingIntoTrackingDictionary(activeBuildingCom); //roads and buildings store accordingly
activeBuildingCom.BuildingPlaced();
// Change Sprite Layer back to building layer
activeBuildingCom.SetSpriteObjectLayer(0);
activeBuildingCom.gameObject.name = BuildingDataBase.GetInstance().GetBuildingData(activeBuildingCom.GetBuildingType()).GetBuildingName();
// Set Sprite's Sorting Order
int newOrder = (int)activeBuildingCom.GetBottomLeftGridPosition().y;
newOrder = -newOrder;
activeBuildingCom.SetSpriteSortingOrder(newOrder);
//set the correct parent
if (activeBuildingCom.GetBuildingType() == BuildingDataBase.BUILDINGS.B_ROAD)
{
activeBuildingCom.gameObject.transform.SetParent(m_RoadParent);
}
else
{
activeBuildingCom.gameObject.transform.SetParent(m_BuildingParent);
}
return(activeBuildingCom);
}
public void SetRoadSprite(Vector2Int key, RoadTypeList type)
{
BaseBuildingsClass road = m_RoadSpriteRendererMap[key];
road.SetSprite(BuildingDataBase.GetInstance().GetRoadSprite(type));
//change and store the road type
int indexConverted = Convert2DToIntIndex(key);
if (m_RoadMap.ContainsKey(indexConverted))
{
m_RoadMap[indexConverted] = type;
}
}
/// <summary>
/// Places the Template Building into the Map
/// </summary>
/// <param name="doChecking">Are any of the spots taken by another building already?</param>
/// <returns></returns>
public BaseBuildingsClass PlaceTemplateBuilding(bool doChecking = false)
{
BaseBuildingsClass PlacedBuilding = PlaceBuildingToGrid(ref m_TemplateBuilding, doChecking);
// Success in placing building, Deduct resources
ResourceManager.GetInstance().DeductResourcesFromBuildingData(m_TemplateBuildingID);
// Success in placing building, Create new building for next placment
BuildingDataBase.BUILDINGS oldID = m_TemplateBuilding.GetBuildingType();
m_TemplateBuilding = Instantiate(BuildingDataBase.GetInstance().GetBaseBuildingGO(), Camera.main.transform.position, Quaternion.identity).GetComponent <BaseBuildingsClass>();
m_TemplateBuilding.SetNewBuildingType(BuildingDataBase.GetInstance().GetBuildingData(oldID));
m_TemplateBuilding.SetSpriteObjectLayer(LayerMask.NameToLayer("BuildingPlaceRef"));
return(PlacedBuilding);
}
/// <summary>
/// Moves m_BuildingToMove from old position in dictionary to it's current position
/// </summary>
public void ConfirmRemovementOfBuilding()
{
if (!m_MovementBrushActive || m_BuildingToMove == null)
{
return;
}
// Place back into Map
PlaceMovedBuildingBackToMap();
// Reset
m_BuildingToMove.transform.GetChild(0).GetComponent <SpriteRenderer>().color = m_BuildingToMove_OldColor;
m_BuildingToMove.BuildingMoved();
m_BuildingToMove = null;
m_BuildingToMove_OldPosition = Vector3.zero;
m_BuildingToMove_OldColor = Color.white;
}
protected virtual void MapWasGenerated()
{
// Spawn buildings to build at spawn
BaseBuildingsClass newBuilding = null;
foreach (MapStartingBuildings building in m_ListOfBuildingsToBuildAtSpawn)
{
foreach (Vector2Int pos in building.spawnGridPositions)
{
newBuilding = MapManager.GetInstance().PlaceNewBuildingIntoMap_WithoutResources(pos, building.buildingID);
newBuilding.SetBuildingPlayerOptions(building.isMovable, building.isRemovable);
}
}
// Allocate resources
foreach (MapStartingResource resource in m_ListOfStartingResources)
{
ResourceManager.GetInstance().SetResource(resource.resourceID, resource.value);
}
}
private void Awake()
{
if (m_Instance != null)
{
Destroy(gameObject);
return;
}
m_Instance = this;
DontDestroyOnLoad(gameObject);
m_GridTakenArray = new List <bool>();
// Placement and Removal
m_TemplateBuilding = Instantiate(BuildingDataBase.GetInstance().GetBaseBuildingGO(), Camera.main.transform.position, Quaternion.identity).GetComponent <BaseBuildingsClass>();
m_TemplateBuilding.SetSpriteObjectLayer(LayerMask.NameToLayer("BuildingPlaceRef"));
m_ListOfBuildingsToRemove = new List <BaseBuildingsClass>();
// Parent the m_GridGO
m_GridGO.transform.parent = transform;
}
//to store the loaded roads from the save file into the roadManager
public void StoreLoadedRoads(BaseBuildingsClass roadBuilding, RoadTypeList roadType)
{
if (m_RoadManager == null)
{
return;
}
Vector3 buildingBottomLeftWorldPos = roadBuilding.GetBottomLeftGridPosition();
Vector2Int buildingSize = roadBuilding.GetBuildingSizeOnMap();
// Set all the grids taken by new building to true
SetGridTakenArray(buildingBottomLeftWorldPos, buildingSize, true);
Vector2Int key = (Vector2Int)m_GridGO.WorldToCell(roadBuilding.GetBottomLeftGridPosition());
roadBuilding.BuildingPlaced();
m_RoadManager.StoreLoadedInRoads(key, roadBuilding, roadType);
}
public void PlaceRoads(Vector2Int key, ref BaseBuildingsClass roadInfo)
{
if (m_RoadSpriteRendererMap.ContainsKey(key))
{
return;
}
//add them in uey
m_RoadSpriteRendererMap.Add(key, roadInfo);
int indexConverted = Convert2DToIntIndex(key);
m_RoadMap.Add(indexConverted, RoadTypeList.NO_CONNECTION);
//change sprites accordingly, do check
CheckAndChangeRoadDirection(key);
//road was added during session
m_RoadAddedInSession = true;
}
/// <summary>
/// Adds a building into the tracking Dictionary
/// </summary>
/// <param name="activeBuildingCom"></param>
void AddBuildingIntoTrackingDictionary(BaseBuildingsClass activeBuildingCom)
{
Vector2Int key = (Vector2Int)m_GridGO.WorldToCell(activeBuildingCom.GetBottomLeftGridPosition());
if (m_DictOfBuildingsOnMap.ContainsKey(key))
{
Debug.LogError("Duplicate Key in MapManager Building Storage!!\n2 Buildings occupying same Position!");
return;
}
//check if its roads or not, store accordingly
if (activeBuildingCom.GetBuildingType() == BuildingDataBase.BUILDINGS.B_ROAD)
{
m_RoadManager.PlaceRoads(key, ref activeBuildingCom);
}
else
{
m_DictOfBuildingsOnMap[key] = activeBuildingCom;
}
}
public void SetNewBuildingToMove(BaseBuildingsClass newBuildingToMove)
{
// Already moving another building
if (m_BuildingToMove != null)
{
return;
}
// Check if building is even on map
m_BuildingToMove = GetBuildingIfOnMap(newBuildingToMove);
if (m_BuildingToMove == null)
{
return;
}
// Remove from grid
RemoveBuildingFromGrid(m_BuildingToMove);
// Store Info
m_BuildingToMove_OldPosition = m_BuildingToMove.transform.position;
m_BuildingToMove_OldColor = m_BuildingToMove.transform.GetChild(0).GetComponent <SpriteRenderer>().color;
//set UI
SetBuildModeUI(m_BuildingToMove);
}
bool CanPlaceBuildingOnMap(BaseBuildingsClass buildingToCheck)
{
return(CanPlaceBuildingOnMap(buildingToCheck.GetBottomLeftGridPosition(), buildingToCheck.GetBuildingSizeOnMap()));
}
/// <summary>
/// Adds a Building to the List to be Removed from Map
/// </summary>
/// <param name="buildingToRemove"></param>
public void AddBuildingToBeRemoved(BaseBuildingsClass buildingToRemove)
{
m_ListOfBuildingsToRemove.Add(buildingToRemove);
}
public void ZeroRoadAround(Vector2Int key)
{
BaseBuildingsClass road = m_RoadSpriteRendererMap[key];
road.SetSprite(BuildingDataBase.GetInstance().GetRoadSprite(RoadTypeList.NO_CONNECTION));
}
void Update()
{
// Slerp Camera towards TargetPos
Camera.main.transform.position = Vector3.Slerp(Camera.main.transform.position, m_TargetCameraPosition, Time.deltaTime * 20.0f);
// Detect Fingers, for mobile input
DetectFingerInput();
#if UNITY_EDITOR || UNITY_STANDALONE
DEBUG_MoveCameraInput();
// Is Placement Brush Active?
if (MapManager.GetInstance().GetPlacementBrushActive())
{
SetTemplateBuildingToGridPosition(); // Move Building with Camera
RenderTemplateBuilding();
}
// Is Removal Brush Active?
else if (MapManager.GetInstance().GetRemovalBrushActive())
{
// THIS ONLY WORKS ON PC
if (Input.GetMouseButtonUp(0))
{
RaycastHit2D hit = Physics2D.Raycast(Camera.main.ScreenToWorldPoint(Input.mousePosition), Vector2.zero, 20.0f, 1 << 0);
if (hit.collider == null)
{
return;
}
// Debug.Log("Raycast2D hit: " + hit.transform.gameObject.name);
// Should put buildings on seperate layer honestly...
BaseBuildingsClass hitBuilding = hit.transform.parent.gameObject.GetComponent <BaseBuildingsClass>();
if (hitBuilding == null)
{
return;
}
// Can building be Removed?
if (!hitBuilding.GetCanBeRemoved())
{
return;
}
hit.transform.gameObject.GetComponent <SpriteRenderer>().color = Color.red;
MapManager.GetInstance().AddBuildingToBeRemoved(hit.transform.parent.gameObject.GetComponent <BaseBuildingsClass>());
}
//else if (Input.GetKeyUp(KeyCode.E))
// MapManager.GetInstance().RemoveBuildingsFromMapUnderList();
}
// Is Movement Brush Active?
else if (MapManager.GetInstance().GetMovementBrushActive())
{
if (MapManager.GetInstance().GetBuildingToMove() == null)
{
// THIS ONLY WORKS ON PC
if (Input.GetMouseButtonUp(0))
{
RaycastHit2D hit = Physics2D.Raycast(Camera.main.ScreenToWorldPoint(Input.mousePosition), Vector2.zero, 20.0f, 1 << 0);
if (hit.collider == null)
{
return;
}
// Debug.Log("Raycast2D hit: " + hit.transform.gameObject.name);
// Should put buildings on seperate layer honestly...
BaseBuildingsClass hitBuilding = hit.transform.parent.gameObject.GetComponent <BaseBuildingsClass>();
if (hitBuilding == null)
{
return;
}
// Can building be Moved?
if (!hitBuilding.GetCanBeMoved())
{
return;
}
// Attach it and calculate offset
MapManager.GetInstance().SetNewBuildingToMove(hitBuilding);
m_MovingPlacedBuildingOffset = hitBuilding.transform.position - Camera.main.transform.position;
}
return;
}
// Make building to move follow camera and grid position
SetMovingBuildingToGridPosition();
// PC INPUTS
// Can place?
if (MapManager.GetInstance().CanPlaceBuildingToMove())
{
MapManager.GetInstance().GetBuildingToMove().transform.GetChild(0).GetComponent <SpriteRenderer>().color = Color.cyan;
//// Confirm
//if (Input.GetKeyUp(KeyCode.O))
//{
// MapManager.GetInstance().ConfirmRemovementOfBuilding();
//}
}
else
{
MapManager.GetInstance().GetBuildingToMove().transform.GetChild(0).GetComponent <SpriteRenderer>().color = Color.gray;
}
// Cancel
if (Input.GetKeyUp(KeyCode.P))
{
MapManager.GetInstance().CancelRemovementOfBuilding();
}
}
// Saving and Loading
//if (Input.GetKeyUp(KeyCode.Z))
// SaveSystem.SaveToFile();
//else if (Input.GetKeyUp(KeyCode.X))
// SaveSystem.LoadFromFile();
#endif
}
