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);
}
}
// Start is called before the first frame update
void Start()
{
if (m_buildClass)
{
buildingData = BuildingDataBase.GetInstance().GetBuildingData(m_buildClass.GetBuildingType());
}
}
private void Awake()
{
if (m_Instance != null)
{
Destroy(gameObject);
return;
}
m_Instance = this;
DontDestroyOnLoad(gameObject);
// Check for duplicates
int counter;
for (int i = 0; i < (int)BUILDINGS.B_TOTAL; ++i)
{
counter = 0;
foreach (BuildingData baseBuilding in m_ListOfBuildingSO)
{
if (baseBuilding.GetBuildingType() == (BUILDINGS)i)
{
counter++;
}
}
// Check for missing Buildings or duplicated buildingIDs
if (counter != 1)
{
// 2 ScriptableObjects share the same BuildingID
if (counter > 1)
{
Debug.LogError("Duplicate Enum ID in BUILDING Database!! \nDuplicated ID is: " + (BUILDINGS)i);
}
// Missing Building ScriptableObject
else if (counter == 0)
{
Debug.LogError("Missing Building ScriptableObject in BUILDING Database!! \nMissing ID is: " + (BUILDINGS)i);
}
Debug.LogError("DataBase is NOT GENERATED. \nCHECK your BuildingDataBase Again!");
Debug.LogError("FIX THIS NOW!");
return;
}
}
// If no duplicates or missing buildings, convert to Dictionary
foreach (BuildingData baseBuilding in m_ListOfBuildingSO)
{
m_DictOfBuildingSO[baseBuilding.GetBuildingType()] = baseBuilding;
}
//store the road types in a dictionary
foreach (RoadTypeInfo roadInfo in m_RoadSpriteInfo)
{
m_DictRoadTypeSprites.Add(roadInfo.m_RoadType, roadInfo.m_RoadSprite);
}
m_ListOfBuildingSO.Clear();
}
public void IncrementPlacingBuildingID()
{
m_TemplateBuildingID += 1;
if (m_TemplateBuildingID >= BuildingDataBase.BUILDINGS.B_TOTAL)
{
m_TemplateBuildingID = BuildingDataBase.BUILDINGS.B_POND;
}
m_TemplateBuilding.SetNewBuildingType(BuildingDataBase.GetInstance().GetBuildingData(m_TemplateBuildingID));
}
/// <summary>
/// Deducts your current resources against the resourcesNeeded for the buildingType
/// </summary>
/// <param name="buildingID"></param>
public void DeductResourcesFromBuildingData(BuildingDataBase.BUILDINGS buildingID)
{
foreach (ResourcesNeeded resourceNeeded in BuildingDataBase.GetInstance().GetBuildingData(buildingID).GetResourcesNeeded())
{
if (!resourceNeeded.toDeduct)
{
continue;
}
SetResource(resourceNeeded.resourceID, GetResource(resourceNeeded.resourceID) - resourceNeeded.amount);
}
}
/// <summary>
/// Returns if you have enough resources to place the building
/// </summary>
/// <param name="buildingID">What type of building to check against</param>
/// <returns></returns>
public bool EnoughResourcesForBuilding(BuildingDataBase.BUILDINGS buildingID)
{
foreach (ResourcesNeeded resourceNeeded in BuildingDataBase.GetInstance().GetBuildingData(buildingID).GetResourcesNeeded())
{
if (GetResource(resourceNeeded.resourceID) < resourceNeeded.amount)
{
return(false);
}
}
return(true);
}
/// <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>
/// 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);
}
/// <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);
}
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>
/// Enables/Disables Placement Brush to be used for placing down New Buildings in Map.
/// </summary>
/// <param name="newValue">True=Enable, False=Disable</param>
/// <param name="selectedBuildingID">What Building Type to Start with</param>
public void SetPlacementBrush(bool newValue, BuildingDataBase.BUILDINGS selectedBuildingID = BuildingDataBase.BUILDINGS.B_POND)
{
m_PlacmentBrushActive = newValue;
m_TemplateBuildingID = selectedBuildingID;
if (m_PlacmentBrushActive)
{
m_TemplateBuilding.gameObject.SetActive(true);
m_TemplateBuilding.SetNewBuildingType(BuildingDataBase.GetInstance().GetBuildingData(m_TemplateBuildingID));
PlayerOpenAddEditorMode(m_TemplateBuilding);
}
else
{
m_TemplateBuilding.gameObject.SetActive(false);
PlayerCloseAddEditorMode();
}
}
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;
}
/// <summary>
/// Attempts to place a new Building of type buildingID into the map
/// WITHOUT checking and deducting if have resources needed
/// </summary>
/// <param name="spawnWorldPosition">World position of the Building</param>
/// <param name="buildingID">What type of building to place</param>
/// <returns></returns>
public BaseBuildingsClass PlaceNewBuildingIntoMap_WithoutResources(Vector2 spawnWorldPosition, BuildingDataBase.BUILDINGS buildingID)
{
// Convert World to Grid Coordinates
BaseMapClass gridLayout = GetCurrentMap();
Vector3Int gridPos = gridLayout.GetTileMapCom().WorldToCell(spawnWorldPosition);
spawnWorldPosition = gridLayout.GetTileMapCom().CellToWorld(gridPos);
spawnWorldPosition += (Vector2)gridLayout.GetTileMapCom().cellSize * 0.5f;
// Check if we can place building Down
Vector3 buildingBottomLeft = spawnWorldPosition + BuildingDataBase.GetInstance().GetBuildingData(buildingID).GetBottomLeftCorner_PositionOffset();
Vector2Int buildingSize = BuildingDataBase.GetInstance().GetBuildingData(buildingID).GetBuildingSizeOnMap();
if (!CanPlaceBuildingOnMap(buildingBottomLeft, buildingSize))
{
Debug.LogError("Unable to Place Building, Canceling...");
return(null);
}
// Create the Building
return(PlaceBuildingToGrid(spawnWorldPosition, buildingID));
}
// Start is called before the first frame update
public void Init()
{
//get from the building database the different buildings
//make an array of list to store the different categories
List <BuildingData>[] tempBuildingDataStorage = new List <BuildingData> [(int)ShopItemType.TOTAL_TYPE];
for (int i = 0; i < (int)ShopItemType.TOTAL_TYPE; ++i)
{
tempBuildingDataStorage[i] = new List <BuildingData>();
}
//add the buildings to the correct category
for (int i = 0; i < (int)BuildingDataBase.BUILDINGS.B_TOTAL; ++i)
{
BuildingData buildingData = BuildingDataBase.GetInstance().GetBuildingData((BuildingDataBase.BUILDINGS)(i));
if (buildingData == null)
{
return;
}
//item not suppose to be in shop
if (!buildingData.GetIsSoldInShop())
{
continue;
}
//add the building into the correct category
tempBuildingDataStorage[(int)buildingData.GetShopItemType()].Add(buildingData);
}
for (int i = 0; i < (int)ShopItemType.TOTAL_TYPE; ++i)
{
//sort the buildings
SortBuildings sortBuildings = new SortBuildings();
tempBuildingDataStorage[i].Sort(sortBuildings);
//make sure parent exist first
if (i >= m_ShopCategoriesParents.Length)
{
break;
}
//spawn the prefabs and add to the correct parent
foreach (BuildingData buildingData in tempBuildingDataStorage[i])
{
GameObject itemCard = GameObject.Instantiate(m_ItemCardUIPrefab, m_ShopCategoriesParents[i]);
//init the UI with the building info accordingly
ShopItemCardUI shopItemCardUI = itemCard.GetComponent <ShopItemCardUI>();
if (shopItemCardUI == null)
{
continue;
}
shopItemCardUI.Init(buildingData);
}
//clear the list
tempBuildingDataStorage[i].Clear();
}
//set the shop category inactive and active accordingly
InitCategoryShown(m_DefaultShopCategory);
}
public void ZeroRoadAround(Vector2Int key)
{
BaseBuildingsClass road = m_RoadSpriteRendererMap[key];
road.SetSprite(BuildingDataBase.GetInstance().GetRoadSprite(RoadTypeList.NO_CONNECTION));
}
