public void Start()
{
dataManager = DataManager.instance;
infiniteObjectManager = InfiniteObjectManager.instance;
infiniteObjectManager.Init();
infiniteObjectHistory = InfiniteObjectHistory.instance;
infiniteObjectHistory.Init(infiniteObjectManager.GetTotalObjectCount());
sectionSelection = SectionSelection.instance;
chaseController = ChaseController.instance;
moveDirection = Vector3.forward;
spawnDirection = Vector3.forward;
turnPlatform = new PlatformObject[(int)ObjectLocation.Last];
turnIndex = new int[(int)ObjectLocation.Last];
turnScene = new SceneObject[(int)ObjectLocation.Last];
sceneTurnIndex = new int[(int)ObjectLocation.Last];
infiniteObjectManager.GetObjectSizes(out platformSizes, out sceneSizes, out largestSceneLength);
infiniteObjectManager.GetObjectStartPositions(out platformStartPosition, out sceneStartPosition);
stopObjectSpawns = false;
spawnData = new ObjectSpawnData();
spawnData.largestScene = largestSceneLength;
spawnData.useWidthBuffer = true;
spawnData.section = 0;
spawnData.sectionTransition = false;
noCollidableProbability.Init();
ShowStartupObjects(GameManager.instance.showTutorial);
SpawnObjectRun(true);
GameManager.instance.OnStartGame += StartGame;
}
public void Init(InfiniteObjectHistory objectHistory, ObjectType objectType)
{
targetObjectIndex = -1;
thisObjectType = objectType;
for (int i = 0; i < rules.Count; ++i)
{
rules[i].Init(objectHistory);
}
}
public void OnGUI()
{
GUILayout.Label("Infinite Object Persistence", "BoldLabel");
GUILayout.Label("1. Generate desired tracks using rules and probabilities");
GUILayout.Label("2. Hit play in Unity");
GUILayout.Label("3. Add extra objects (such as tutorial triggers)");
GUILayout.Label("4. Click \"Persist\"");
GUILayout.Space(10);
if (GUILayout.Button("Persist"))
{
saveLocation = EditorUtility.SaveFilePanelInProject("Save Location", "InfiniteObjectPersistence", "prefab", "");
if (saveLocation.Length == 0)
{
return;
}
GameObject infiniteObjectsGroup = GameObject.Find("Infinite Objects");
if (infiniteObjectsGroup != null)
{
GameObject persistGameObject = new GameObject();
InfiniteObjectPersistence persistence = persistGameObject.AddComponent <InfiniteObjectPersistence>() as InfiniteObjectPersistence;
// Persist the Infinite Object History Data
InfiniteObjectHistory infiniteObjectHistory = infiniteObjectsGroup.GetComponent <InfiniteObjectHistory>();
infiniteObjectHistory.SaveInfiniteObjectPersistence(ref persistence);
for (int i = infiniteObjectsGroup.transform.childCount - 1; i >= 0; --i)
{
infiniteObjectsGroup.transform.GetChild(i).parent = persistGameObject.transform;
}
EditorUtility.SetDirty(persistGameObject);
PrefabUtility.CreatePrefab(saveLocation, persistGameObject);
for (int i = persistGameObject.transform.childCount - 1; i >= 0; --i)
{
persistGameObject.transform.GetChild(i).parent = infiniteObjectsGroup.transform;
}
DestroyImmediate(persistGameObject);
Debug.Log("Infinite Object Data Persisted!");
}
else
{
Debug.Log("Error: Unable to find the Infinite Objects Game Object");
}
}
}
public virtual void Init()
{
infiniteObjectHistory = InfiniteObjectHistory.instance;
thisInfiniteObject = GetComponent<InfiniteObject>();
ObjectType objectType = thisInfiniteObject.GetObjectType();
for (int i = 0; i < avoidObjectRuleMaps.Count; ++i) {
avoidObjectRuleMaps[i].Init(infiniteObjectHistory, objectType);
}
for (int i = 0; i < probabilityAdjustmentMaps.Count; ++i) {
probabilityAdjustmentMaps[i].Init(infiniteObjectHistory, objectType);
}
}
// The probability of this object occuring can be based on the previous objects spawned.
public bool ProbabilityAdjustment(InfiniteObjectHistory infiniteObjectHistory, float distance, ref float localDistance, ref float probability)
{
if (targetObjectIndex == -1)
{
Debug.LogError(string.Format("ObjectRuleMap:ProbabilityAdjustment error: target object {0} doesn't exist. Ensure the target object has been added to the Infinite Object Manager.", targetObject));
return(false);
}
for (int i = 0; i < rules.Count; ++i)
{
if ((probability = rules[i].ProbabilityAdjustment(distance, targetObjectIndex, targetObject.GetObjectType())) != -1)
{
localDistance = infiniteObjectHistory.GetTotalDistance(targetObjectIsScene) - infiniteObjectHistory.GetSpawnDistance(targetObjectIndex);
return(true);
}
}
return(false);
}
public virtual void Init()
{
infiniteObjectHistory = InfiniteObjectHistory.instance;
thisInfiniteObject = GetComponent <InfiniteObject>();
ObjectType objectType = thisInfiniteObject.GetObjectType();
for (int i = 0; i < avoidObjectRuleMaps.Count; ++i)
{
avoidObjectRuleMaps[i].Init(infiniteObjectHistory, objectType);
}
for (int i = 0; i < probabilityAdjustmentMaps.Count; ++i)
{
probabilityAdjustmentMaps[i].Init(infiniteObjectHistory, objectType);
}
}
public void Start()
{
infiniteObjectHistory = InfiniteObjectHistory.instance;
// create a new section list for the platforms and scenes since their distances are different
if (sectionSelectionType == SectionSelectionType.Linear)
{
platformSectionList = new DistanceValueList(sectionList.loop, sectionList.loopBackToIndex);
platformSectionList.values = sectionList.values;
platformSectionList.Init();
sceneSectionList = new DistanceValueList(sectionList.loop, sectionList.loopBackToIndex);
sceneSectionList.values = sectionList.values;
sceneSectionList.Init();
}
else
{
sectionList.Init();
}
}
public void Init()
{
infiniteObjectHistory = InfiniteObjectHistory.instance;
objectsPool = new List<List<InfiniteObject>>();
objectPoolIndex = new List<int>();
appearanceRules = new List<AppearanceRules>();
appearanceProbability = new List<AppearanceProbability>();
probabilityCache = new List<float>();
objectCanSpawnCache = new List<bool>();
int totalObjs = platforms.Length + scenes.Length + obstacles.Length + coins.Length + powerUps.Length;
InfiniteObject infiniteObject;
for (int i = 0; i < totalObjs; ++i) {
objectsPool.Add(new List<InfiniteObject>());
objectPoolIndex.Add(0);
probabilityCache.Add(0);
objectCanSpawnCache.Add(false);
infiniteObject = ObjectIndexToObject(i);
infiniteObject.Init();
appearanceRules.Add(infiniteObject.GetComponent<AppearanceRules>());
appearanceRules[i].Init();
appearanceProbability.Add(infiniteObject.GetComponent<AppearanceProbability>());
appearanceProbability[i].Init();
}
// wait until all of the appearance rules have been initialized before the object index is assigned
for (int i = 0; i < totalObjs; ++i) {
infiniteObject = ObjectIndexToObject(i);
for (int j = 0; j < totalObjs; ++j) {
ObjectIndexToObject(j).GetComponent<AppearanceRules>().AssignIndexToObject(infiniteObject, i);
}
}
// cache a fixed amount of each type of object before the game starts
List<InfiniteObject> infiniteObjects = new List<InfiniteObject>();
for (int i = 0; i < prespawnCache; ++i) {
for (int j = 0; j < platforms.Length; ++j) {
infiniteObjects.Add(ObjectFromPool(j, ObjectType.Platform));
}
for (int j = 0; j < scenes.Length; ++j) {
infiniteObjects.Add(ObjectFromPool(j, ObjectType.Scene));
}
}
for (int i = 0; i < infiniteObjects.Count; ++i) {
infiniteObjects[i].Deactivate();
}
}
public void Awake()
{
instance = this;
}
public void Start()
{
dataManager = DataManager.instance;
infiniteObjectManager = InfiniteObjectManager.instance;
infiniteObjectManager.Init();
infiniteObjectHistory = InfiniteObjectHistory.instance;
infiniteObjectHistory.Init(infiniteObjectManager.GetTotalObjectCount());
sectionSelection = SectionSelection.instance;
chaseController = ChaseController.instance;
moveDirection = Vector3.forward;
spawnDirection = Vector3.forward;
turnPlatform = new PlatformObject[(int)ObjectLocation.Last];
turnIndex = new int[(int)ObjectLocation.Last];
turnScene = new SceneObject[(int)ObjectLocation.Last];
sceneTurnIndex = new int[(int)ObjectLocation.Last];
infiniteObjectManager.GetObjectSizes(out platformSizes, out sceneSizes, out largestSceneLength);
infiniteObjectManager.GetObjectStartPositions(out platformStartPosition, out sceneStartPosition);
stopObjectSpawns = false;
spawnData = new ObjectSpawnData();
spawnData.largestScene = largestSceneLength;
spawnData.useWidthBuffer = true;
spawnData.section = 0;
spawnData.sectionTransition = false;
noCollidableProbability.Init();
ShowStartupObjects(GameManager.instance.showTutorial);
SpawnObjectRun(true);
GameManager.instance.OnStartGame += StartGame;
}
public void Init(InfiniteObjectHistory objectHistory)
{
infiniteObjectHistory = objectHistory;
}
public void Start()
{
infiniteObjectHistory = InfiniteObjectHistory.instance;
// create a new section list for the platforms and scenes since their distances are different
if (sectionSelectionType == SectionSelectionType.Linear) {
platformSectionList = new DistanceValueList(sectionList.loop, sectionList.loopBackToIndex);
platformSectionList.values = sectionList.values;
platformSectionList.Init();
sceneSectionList = new DistanceValueList(sectionList.loop, sectionList.loopBackToIndex);
sceneSectionList.values = sectionList.values;
sceneSectionList.Init();
} else {
sectionList.Init();
}
}
// The probability of this object occuring can be based on the previous objects spawned.
public bool ProbabilityAdjustment(InfiniteObjectHistory infiniteObjectHistory, float distance, ref float localDistance, ref float probability)
{
if (targetObjectIndex == -1) {
Debug.LogError(string.Format("ObjectRuleMap:ProbabilityAdjustment error: target object {0} doesn't exist. Ensure the target object has been added to the Infinite Object Manager.", targetObject));
return false;
}
for (int i = 0; i < rules.Count; ++i) {
if ((probability = rules[i].ProbabilityAdjustment(distance, targetObjectIndex, targetObject.GetObjectType())) != -1) {
localDistance = infiniteObjectHistory.GetTotalDistance(targetObjectIsScene) - infiniteObjectHistory.GetSpawnDistance(targetObjectIndex);
return true;
}
}
return false;
}
public void Init(InfiniteObjectHistory objectHistory, ObjectType objectType)
{
targetObjectIndex = -1;
thisObjectType = objectType;
for (int i = 0; i < rules.Count; ++i) {
rules[i].Init(objectHistory);
}
}
public void Awake()
{
instance = this;
}
public void Init()
{
infiniteObjectHistory = InfiniteObjectHistory.instance;
objectsPool = new List <List <InfiniteObject> >();
objectPoolIndex = new List <int>();
appearanceRules = new List <AppearanceRules>();
appearanceProbability = new List <AppearanceProbability>();
probabilityCache = new List <float>();
objectCanSpawnCache = new List <bool>();
int totalObjs = platforms.Length + scenes.Length + obstacles.Length + coins.Length + powerUps.Length;
InfiniteObject infiniteObject;
for (int i = 0; i < totalObjs; ++i)
{
objectsPool.Add(new List <InfiniteObject>());
objectPoolIndex.Add(0);
probabilityCache.Add(0);
objectCanSpawnCache.Add(false);
infiniteObject = ObjectIndexToObject(i);
infiniteObject.Init();
appearanceRules.Add(infiniteObject.GetComponent <AppearanceRules>());
appearanceRules[i].Init();
appearanceProbability.Add(infiniteObject.GetComponent <AppearanceProbability>());
appearanceProbability[i].Init();
}
// wait until all of the appearance rules have been initialized before the object index is assigned
for (int i = 0; i < totalObjs; ++i)
{
infiniteObject = ObjectIndexToObject(i);
for (int j = 0; j < totalObjs; ++j)
{
ObjectIndexToObject(j).GetComponent <AppearanceRules>().AssignIndexToObject(infiniteObject, i);
}
}
// cache a fixed amount of each type of object before the game starts
List <InfiniteObject> infiniteObjects = new List <InfiniteObject>();
for (int i = 0; i < prespawnCache; ++i)
{
for (int j = 0; j < platforms.Length; ++j)
{
infiniteObjects.Add(ObjectFromPool(j, ObjectType.Platform));
}
for (int j = 0; j < scenes.Length; ++j)
{
infiniteObjects.Add(ObjectFromPool(j, ObjectType.Scene));
}
}
for (int i = 0; i < infiniteObjects.Count; ++i)
{
infiniteObjects[i].Deactivate();
}
}
public void Init(InfiniteObjectHistory objectHistory)
{
infiniteObjectHistory = objectHistory;
}
