public void ClearClusterSaveData(RoomClusterData clustData)
{
if (clustData == null)
{
Debug.LogWarning("Can't clear NULL Cluster save data!"); return;
} // Safety check.
foreach (RoomData rd in clustData.rooms)
{
ClearRoomSaveData(rd);
}
Debug.Log("Cleared CLUSTER save data!");
}
// ================================================================
// Doers
// ================================================================
//public void UpdateNumSnacks() {
// // Update by Room.
// NumSnacksTotal = 0;
// NumSnacksCollected = 0;
// foreach (RoomData rd in roomDatas.Values) {
// rd.UpdateNumSnacks();
// NumSnacksTotal += rd.NumSnacksTotal;
// NumSnacksCollected += rd.NumSnacksCollected;
// }
//}
//public void UpdateNumSnacksTotal() {
// NumSnacksTotal = 0;
// foreach (RoomData rd in roomDatas.Values) {
// foreach (PropData pd in rd.allPropDatas) {
// if (pd is SnackData) { NumSnacksTotal++; }
// }
// }
//}
// ================================================================
// Events
// ================================================================
public void OnPlayerEatSnack(Room room)
{
// Update counts!
//room.MyRoomData.RefreshSnackCount();
RoomClusterData clusterData = room.MyClusterData;
if (clusterData != null)
{
clusterData.RefreshSnackCount();
GameManagers.Instance.DataManager.RefreshSnackCountGame();
}
}
static public void OpenGameplayScene(RoomClusterData clust)
{
// Default to the first Room in the cluster.
RoomData room = clust.rooms[0];
// Did we last play this cluster? Start in the last room we were in!
string lastPlayedRoomKey = SaveStorage.GetString(SaveKeys.LastPlayedRoomKey(clust.WorldIndex));
for (int i = 0; i < clust.rooms.Count; i++)
{
if (lastPlayedRoomKey == clust.rooms[i].RoomKey)
{
room = clust.rooms[i];
break;
}
}
OpenGameplayScene(room);
}
private void RecursivelyAddRoomToCluster(RoomData rd, RoomClusterData cluster)
{
if (rd.WasUsedInSearchAlgorithm)
{
return;
} // This RoomData was used? Ignore it.
// Update Room's values, and add to Cluster's list!
rd.SetMyCluster(cluster);
rd.WasUsedInSearchAlgorithm = true;
cluster.rooms.Add(rd);
// Now try for all its neighbors!
for (int i = 0; i < rd.Openings.Count; i++)
{
if (rd.Openings[i].IsRoomTo)
{
RecursivelyAddRoomToCluster(rd.Openings[i].RoomTo, cluster);
}
}
}
// ----------------------------------------------------------------
// Initialize
// ----------------------------------------------------------------
public void Initialize(ClustSelController clustSelController, WorldView myWorldView, RoomClusterData myClustData, Vector2 pos)
{
this.clustSelController = clustSelController;
this.myClustData = myClustData;
worldHue = ((150 + myClustData.WorldIndex * 40) / 360f) % 1;
// Parent jazz!
GameUtils.ParentAndReset(this.gameObject, myWorldView.transform);
//transform.SetAsFirstSibling(); // put behind other stuff.
this.gameObject.name = "ClustTile " + myClustData.ClustIndex;
myRectTransform.anchoredPosition = pos;
t_clustName.text = (myClustData.ClustIndex + 1).ToString();
// Make RoomViews!
AddRoomViews();
// Add i_snacks!
if (myClustData.IsUnlocked)
{
int numEaten = myClustData.SnackCount.Eaten_All;
int numTotal = myClustData.SnackCount.Total_All;
GameObject prefabGO = ResourcesHandler.Instance.ClustSelListClustRowSnack;
float spacingX = 18;
float snackIconsWidth = numTotal * spacingX;
for (int i = 0; i < numTotal; i++)
{
float posX = -2 - snackIconsWidth + (i * spacingX);
Image img = Instantiate(prefabGO).GetComponent <Image>();
img.name = "Snack " + i;
GameUtils.ParentAndReset(img.gameObject, this.transform);
img.rectTransform.anchoredPosition = new Vector2(posX, 0);
// Not eaten? Darker img!
if (i >= numEaten)
{
img.color = new Color(0, 0, 0, 0.8f);
}
}
}
RefreshVisuals();
}
private void MakeClustTiles()
{
WorldData myWorldData = GameManagers.Instance.DataManager.GetWorldData(WorldIndex);
int NumClusts = myWorldData.clusters.Count;
float tempY = 0;
const float gapY = 6;
clustTiles = new ClustTile[NumClusts];
for (int i = 0; i < NumClusts; i++)
{
RoomClusterData clustData = myWorldData.clusters[i];
ClustTile newObj = Instantiate(ResourcesHandler.Instance.ClustSelMapClustTile).GetComponent <ClustTile>();
Vector2 tilePos = new Vector2(0, tempY);
newObj.Initialize(clustSelController, this, clustData, tilePos);
clustTiles[i] = newObj;
tempY -= newObj.Size.y + gapY;
}
// Size meee
myRectTransform.sizeDelta = new Vector2(myRectTransform.rect.size.x, Mathf.Abs(tempY) + 0);
}
// /** Once we know where the center of the playable world is, set the posWorld value for all my rooms! */
// private void SetAllRoomDatasPosWorld () {
// foreach (RoomData rd in roomDatas.Values) {
// rd.SetPosWorld (new Vector2 (rd.posGlobal.x-CenterPos.x, rd.posGlobal.y-CenterPos.y));
// }
// }
private void RecalculateRoomClusters()
{
// Reset Rooms' ClustIndex.
foreach (RoomData rd in roomDatas.Values)
{
rd.SetMyCluster(null);
rd.WasUsedInSearchAlgorithm = false;
}
// Remake Clusters!
clusters = new List <RoomClusterData>();
foreach (RoomData rd in roomDatas.Values)
{
if (rd.WasUsedInSearchAlgorithm)
{
continue;
} // Already used this fella? Skip 'em.
// If this is a ClusterStart room...!
if (rd.isClustStart)
{
// Add a new Cluster, and populate it!
RoomClusterData newClust = new RoomClusterData(worldIndex, rd.RoomKey);
clusters.Add(newClust);
RecursivelyAddRoomToCluster(rd, newClust);
// Update its bounds!
newClust.RefreshBounds();
}
}
// Order Clusters by y-pos!
clusters.Sort((c1, c2) => c1.BoundsGlobal.position.y.CompareTo(c2.BoundsGlobal.position.y));
// NOW set Clusters' ClustIndex!
for (int i = 0; i < clusters.Count; i++)
{
clusters[i].SetClustIndex(i);
clusters[i].RefreshSnackCount();
}
// Reset Rooms' WasUsedInSearchAlgorithm.
ResetRoomsWasUsedInSearch();
}
// ----------------------------------------------------------------
// Initialize
// ----------------------------------------------------------------
public void Initialize(Transform tf_parent, RoomClusterData myClustData, RoomData myRoomData, float scale)
{
this.MyRoomData = myRoomData;
// Parent jazz!
GameUtils.ParentAndReset(this.gameObject, tf_parent);
this.gameObject.name = "RoomView " + myRoomData.RoomKey;
myRectTransform.sizeDelta = myRoomData.Size;// * scale;
Vector2 pos = myRoomData.PosGlobal - myClustData.BoundsGlobal.center;
pos += myRoomData.cameraBoundsData.pos; // hack-y! Just getting to work for now. Works around the rooms' local/global alignment mismatch.
myRectTransform.anchoredPosition = pos; // * scale;
contents.Initialize(this);
// Secret and unvisited? Hide me!
if (myRoomData.IsSecret && !myRoomData.HasPlayerBeenHere)
{
this.gameObject.SetActive(false);
}
}
// Setters
//public void SetClustIndex(int _clustIndex) {
// MyAddress = new RoomAddress(MyAddress.world, _clustIndex, MyAddress.room);
//}
public void SetMyCluster(RoomClusterData cluster)
{
MyCluster = cluster;
}
// ----------------------------------------------------------------
// Doers
// ----------------------------------------------------------------
public void StartGameAtClust(RoomClusterData clust)
{
SceneHelper.OpenGameplayScene(clust);
}
