public void Start()
{
cameraTransform = Camera.main.transform;
infiniteObjectManager = InfiniteObjectManager.instance;
infiniteObjectManager.init();
infiniteObjectHistory = InfiniteObjectHistory.instance;
infiniteObjectHistory.init(infiniteObjectManager.getTotalObjectCount());
sectionSelection = SectionSelection.instance;
moveDirection = Vector3.forward;
turnOffset = Vector3.zero;
turnPlatform = new PlatformObject[(int)ObjectLocation.Last];
localDistance = new float[(int)ObjectLocation.Last];
localSceneDistance = new float[(int)ObjectLocation.Last];
localPlatformHeight = new float[(int)ObjectLocation.Last];
localSceneHeight = new float[(int)ObjectLocation.Last];
infiniteObjectManager.getObjectSizes(out platformSizes, out sceneSizes, out straightPlatformWidth, out largestSceneLength);
stopObjectSpawns = false;
spawnData = new ObjectSpawnData();
spawnData.largestScene = largestSceneLength;
spawnData.useWidthBuffer = true;
spawnData.section = 0;
spawnData.sectionTransition = false;
noCollidableProbability.init();
showStartupObjects(false);
spawnObjectRun(true);
}
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];
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);
}
public void Init()
{
objectHistory = InfiniteObjectHistory.instance;
objectManager = ObjectManager.instance;
moveDirection = Vector3.up;
slotCount = objectManager.slotCount;
spawnDirection = Vector3.up;
activeSlots = GetStartingSlot();
}
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 Manager Data
InfiniteObjectGenerator infiniteObjectGenerator = infiniteObjectsGroup.GetComponent <InfiniteObjectGenerator>();
infiniteObjectGenerator.saveInfiniteObjectPersistence(ref persistence);
// 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");
}
}
}
// 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)
{
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);
}
// Use this for initialization
void Start()
{
objectHistory = InfiniteObjectHistory.instance;
objectManager = ObjectManager.instance;
objectGenerator = ObjectGenerator.instance;
inputController = InputController.instance;
objectManager.Init();
objectHistory.Init();
objectGenerator.Init();
objectGenerator.StartGame();
inputController.StartGame();
}
public virtual void init()
{
infiniteObjectHistory = InfiniteObjectHistory.instance;
infiniteObject = GetComponent <InfiniteObject>();
ObjectType objectType = infiniteObject.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);
platformSectionList.values = sectionList.values;
platformSectionList.init();
sceneSectionList = new DistanceValueList(sectionList.loop);
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);
}
}
}
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);
}
}
}
public void init(InfiniteObjectHistory objectHistory)
{
infiniteObjectHistory = objectHistory;
}
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("ObjectRuleMap:probabilityAdjustment error: target object doesn't exist. Ensure the target object has been added to the Infinite Object Manager.");
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 init(InfiniteObjectHistory objectHistory)
{
infiniteObjectHistory = objectHistory;
}
void Awake()
{
instance = this;
}
public void Awake()
{
instance = this;
}
