public static World Create(MapData mapData, LevelData newLevel, Game game, Rectangle screenRec) { var tilesetList = new List<Tileset>(); foreach (TilesetData data in mapData.Tilesets) { tilesetList.Add( TilesetFactory.Create(data, game) ); } var mapLayers = mapData.Layers.Select(l => MapLayer.FromMapLayerData(l)).ToList(); // MUSTDO: modify TileMap to be able to accept multiple tile sets var map = new TileMap(tilesetList[0], mapLayers[0]); // SHOULDDO: find out why does map need tilesets to? for (int i = 1; i < tilesetList.Count; i++) map.AddTileset(tilesetList[i]); for (int i = 1; i < mapLayers.Count; i++) map.AddLayer(mapLayers[i]); var level = new Level(map); var world = new World(game, screenRec); world.Levels.Add(level); world.CurrentLevel = 0; return world; }
// Use this for initialization void Start () { _GameManater = this; catapult = new Catapult (); leveldata = new LevelData(); AutoStartTableType (); }
void StageSetup(int _level) { stageHolder = new GameObject("Stage").transform; GameObject floorNode; int lev = _level; // JSONを読み込み、オブジェクトを配置。 stLevelData = jsonFM.search.levelList[lev - 1]; GameManager.instance.leftEnergies = stLevelData.leftEnergy; GameManager.instance.leftTime = stLevelData.limitTime; // y座標を変換させるためのローカル変数。 // ex) 6 by 6の場合、1 -> 6、2 -> 5、...、6 -> 1 int toInverse = stLevelData.column - 1; for (int y = 0; y < stLevelData.column; y++) { for (int x = 0; x < stLevelData.row; x++) { // y座標を反転。 int num = stLevelData.floorData[toInverse - y][x]; floorNode = Instantiate(Floor[num], new Vector3(x * 0.64f + 0.32f, y * 0.64f + 0.32f, 0.0f), Quaternion.identity) as GameObject; //ヒエラルキーが乱れることを防ぐため、オブジェクトの親をセット。 floorNode.transform.SetParent(stageHolder); } } }
public SectionBuilderSelector(ISectionBuilderConfiguration sectionBuilderConfigurator, LevelData levelData) { this.sectionBuilderConfigurator = sectionBuilderConfigurator; this.levelData = levelData; difficultyManager = ServiceLocator.getService<IDifficultyBasedBuilderPicking>(); availableSectionBuilders = new Dictionary<SectionBuilderType, ISectionBuilder>(); }
void Start() { difficultyManager = new DifficultyManager(); new ServiceLocator (); ServiceLocator.addService<IProcessorFSM> (new ProcessorFSM ()); ServiceLocator.addService<IProcessorPatternConfiguration> (new ProcessorPatternConfigurator ()); ServiceLocator.addService<IBladeSectionDifficulty>(difficultyManager); levelData = new LevelData(); poolManager = new GameObjectPoolManager(); testSectionBuilderConfigurator = new SectionBuilderConfigurator(levelData) as ISectionBuilderConfiguration; testSectionBuilderSeclector = new SectionBuilderSelector(testSectionBuilderConfigurator, levelData) as ISectionBuilderSelection; SectionBuilderClear clearBuilder = new SectionBuilderClear(); SectionBuilderBlades bladesBuilder = new SectionBuilderBlades(levelData, poolManager); SectionBuilderProcessors processorsBuilder = new SectionBuilderProcessors (levelData, poolManager); testSectionBuilderSeclector.addSectionBuilder(clearBuilder); testSectionBuilderSeclector.addSectionBuilder(bladesBuilder); testSectionBuilderSeclector.addSectionBuilder(processorsBuilder); levelData.activeSectionBuilder = clearBuilder; testSectionDesigner = new SectionDesigner(testSectionBuilderSeclector, levelData) as ISectionDesigning; rowCleaner = new RowCleaner(poolManager); testLevelHandler = new LevelHandler(levelData, testSectionDesigner, rowCleaner); for (int i = 0; i < 50; ++i) { testLevelHandler.buildNewRow(); } }
public static void LoadLevel(JSONObject levelJSON, int order) { CurrentLevel = new LevelData(); // Load level order, bounces, crystals CurrentLevel.levelOrder = order; CurrentLevel.maxBounce = int.Parse(levelJSON["properties"]["bounce"].str); CurrentLevel.minCrystal = int.Parse(levelJSON["properties"]["crystal"].str); // Load milestones string[] milestones = levelJSON["properties"]["milestone"].str.Split(','); CurrentLevel.milestones = new Vector2(float.Parse(milestones[0]), float.Parse(milestones[1])); // Load layers CurrentLevel.layers = new List<LayerData>(); for (int i = 1; i < levelJSON["layers"].list.Count; i++) { if (levelJSON["layers"][i]["name"].str.ToLower().Equals("ball")) CurrentLevel.ballData = AddObject(levelJSON["layers"][i]["objects"][0]); else if (levelJSON["layers"][i]["name"].str.ToLower().Equals("waypoint")) CurrentLevel.waypoints = AddWaypointLayer(levelJSON["layers"][i]["objects"]); else CurrentLevel.layers.Add(AddLayer(levelJSON["layers"][i])); } // init empty waypoint array if (CurrentLevel.waypoints == null) CurrentLevel.waypoints = new WaypointData[0]; }
public static string Serialize(GameObject rootOfTree) { LevelData ld; ld = new LevelData(); UniqueIdentifier identifier = UniqueIdentifier.identifier; GameObject n = identifier.gameObject; ld.StoredObject = new StoredItem() { Name = identifier.Id, GameObjectName = n.name }; Component[] toBeProcessed = UniqueIdentifier.identifier.gameObject.GetComponents<Component>(); int i = toBeProcessed.Length; ld.StoredItem = new List<StoredData>(); while (i-- > 0) { Component cp = toBeProcessed[i]; #if UNITY_EDITOR if (cp is Transform) continue; #else if (cp is SaveObject || cp is Transform) continue; #endif StoredData sd = new StoredData() { Type = cp.GetType().FullName, Name = UniqueIdentifier.identifier.Id }; if (CustomSerializers.ContainsKey(cp.GetType())) { sd.Data = Encoding.Default.GetString(CustomSerializers[cp.GetType()].Serialize(cp)); } else { sd.Data = UnitySerializer.JSONSerializeForDeserializeInto(cp); } ld.StoredItem.Add(sd); } return UnitySerializer.JSONSerialize(ld); }
void Awake() { // Add Data and Actions. string path = Application.dataPath + "/" + Settings.LevelDataPath; mLevelData = JsonExtend.Load<LevelData>(path); }
public void setLevelData(LevelData levelData, int number) { this.levelNumber = number; this.levelData = levelData; GameManager.setCurrentLevel(this); GameManager.getMainGamera().initalize(levelData.cameraCenter); initBackground(); initForeground(); initRooms(); initLiveObjectsGraph(); initObjects(); initThreats(); availableTermites = levelData.availableTermites; GameManager.getLevelGUI().enableRefreshTimer(); }
public Room(RoomScale scale) { data = LevelData.getLevel (ApplicationData.getLastLevel()); int width = data.getRoomWidth (); int height = data.getRoomHeight (); entities = new RoomEntity[height][]; for (int i=0; i < height; i++) { entities[i] = new RoomEntity[width]; } instance = this; HallBuilder hallBuilder = new HallBuilder (); this.hall = hallBuilder.build (data); this.scale = scale; HallMeshBuilder meshBuilder = new HallMeshBuilder (); meshBuilder.setHall (hall); meshBuilder.setScale (scale); meshBuilder.process (); RoomObjectGenerator generator = new RoomObjectGenerator (data); for (int i=0; i<width; i++) { for (int j=0; j<height; j++) { entities[j][i] = generator.instantiateRoomObject(i, j); } } Game.GetInstance ().player.wait (6); if (ApplicationData.getLastLevel () == 1) { SoundManager.instance.PlaySingle ("introduccion"); } else { SoundManager.instance.PlaySingle ("entrada-laberinto"); } }
public void Add(LevelData data) { if (m_Indexes.Contains(data)) return; m_Indexes.Add(data); m_Indexes.Sort(Comp); }
public SectionBuilderConfigurator(LevelData levelData) { this.levelData = levelData; bladeSectionLenghtManager = ServiceLocator.getService<IBladeSectionDifficulty>(); processorSectionDifficultyManager = ServiceLocator.getService<IProcessorGroupDifficulty>(); heatVentSectionDifficultyManager = ServiceLocator.getService<IHeatVentSectionDifficulty>(); bugsSectionDifficulty = ServiceLocator.getService<IBugsSectionDifficulty>(); }
public static LevelData Load(string filename) { FileStream stream = new FileStream(filename, FileMode.Open); LevelData ld = new LevelData(); ld.FromStream(stream); stream.Close(); return ld; }
void Next() { levelNum++; if (levelNum > TOTALLEVELCOUNT - 1) levelNum = 0; level.text = (levelNum + 1).ToString(); myLevel = xml.GetComponent<XMLScript>().LoadLevel(levelNum); UpdateScores(); }
void Prev() { levelNum--; if (levelNum < 0) levelNum = TOTALLEVELCOUNT - 1; level.text = (levelNum + 1).ToString(); myLevel = xml.GetComponent<XMLScript>().LoadLevel(levelNum); UpdateScores(); }
public static void Save(LevelData data, string fileName) { BinaryFormatter bf = new BinaryFormatter(); FileStream file = File.Create(Application.persistentDataPath + "/" + fileName); bf.Serialize(file, data); file.Close(); }
public void Setup(LevelData i_data, MenuManager i_mainMenuManager) { //Set Data data = i_data; mainMenuManager = i_mainMenuManager; //Apply Data GetComponentInChildren<Text>().text = (data.number + 1).ToString(); }
public SectionBuilderHeatVent(LevelData levelData, GameObjectPoolManager poolManager) { this.levelData = levelData; this.poolManager = poolManager; difficultyManager = ServiceLocator.getService<IHeatVentSectionDifficulty>(); type = SectionBuilderType.heatVent; heatVent = Resources.Load("HeatVent") as GameObject; poolManager.addPool(heatVent, 20); }
public SectionBuilderProcessors(LevelData levelData, GameObjectPoolManager poolManager) { this.levelData = levelData; this.poolManager = poolManager; type = SectionBuilderType.processor; GameObject processor = Resources.Load("Processor") as GameObject; GameObject processorGroup = Resources.Load("ProcessorGroup") as GameObject; poolManager.addPool(processor, 200); poolManager.addPool(processorGroup, 20); }
public void SaveLevel(int zone, int level) { LevelData levelData = new LevelData (); foreach (GameObject gameObject in FindSavableRootGameObjects()) { levelData.items.Add (CreateItemDataFromGameObject (gameObject)); } levelData.SaveToFile (zone, level); }
public LevelLogicData(LevelData levelData) { this.m_LevelData = levelData; /* this.m_BattleArray = new Dictionary<byte, ActorLogicData>(); string actorUIDPrefix = "enemy{0}"; string skillUIDPrefix = "enemyskill{0}"; int actorUIDCounter = 1; int skillUIDCounter = 1; foreach (var item in levelData.BattleArray) { ActorData actorData = ConfigCtrller.Instance.Actor.GetActorDataByID(item.Value); List<SkillLogicDataBase> skillList = new List<SkillLogicDataBase>(); foreach (var acotrSkillID in actorData.Skills) { ActorSkillData actorSkillData = ConfigCtrller.Instance.Skill.GetActorSkillDataByID(acotrSkillID); List<SkillDataBase> skillDataBaseList = new List<SkillDataBase>(); foreach (var skillID in actorSkillData.SkillIDs) { SkillDataBase skillDataBase = ConfigCtrller.Instance.Skill.GetSkillDataBaseByID(skillID); skillDataBaseList.Add(skillDataBase); } SkillLogicDataBase skillLogicData = null; string skillUID = string.Format(skillUIDPrefix, skillUIDCounter); switch (actorSkillData.SkillType) { case SkillType.Normal: break; case SkillType.First: case SkillType.Active: skillLogicData = new ActiveSkillLogicData(skillUID, actorSkillData, skillDataBaseList); break; case SkillType.Passive: skillLogicData = new PassiveSkillLogicData(skillUID, actorSkillData, skillDataBaseList); break; case SkillType.Trigger: skillLogicData = new TriggerSkillLogicData(skillUID, actorSkillData, skillDataBaseList); break; case SkillType.Weather: skillLogicData = new WeatherSkillLogicData(skillUID, actorSkillData, skillDataBaseList); break; default: break; } skillUIDCounter++; if (skillLogicData != null) { skillList.Add(skillLogicData); } } ActorLogicData actorLogicData = new ActorLogicData(string.Format(actorUIDPrefix,actorUIDCounter++),actorData, skillList); this.m_BattleArray.Add(item.Key,actorLogicData); } */ }
public static int AddLevel(LevelData data) { int index = numLevels; if(index > MAX_LEVELS) { return -1; } levels[index] = data; numLevels++; return index; }
//Overwrites data, need to fix public void Save() { BinaryFormatter bFormatter = new BinaryFormatter (); FileStream file = File.Create (Application.persistentDataPath + "/ApplicationInfo" + fileEnding); LevelData dataToSave = new LevelData (); dataToSave.highScore = highScore; bFormatter.Serialize (file, dataToSave); file.Close (); }
public void Load(LevelData data) { for (int i = 0; i < data.tiles.Count; ++i) { GameObject instance = Instantiate(tilePrefab) as GameObject; Tile t = instance.GetComponent<Tile>(); t.transform.SetParent(transform); t.Load(data.tiles[i]); tiles.Add(t.pos, t); } }
public void Setup(LevelData levelData, GameObjectPoolManager poolManager) { tilePosition = Vector3.zero; this.levelData = levelData; this.poolManager = poolManager; poolManager.addPool(sideWallTilePrefab, 100); poolManager.addPool(floorTilePrefab, 300); poolManager.addPool(bladeRowWallLeft, 20); poolManager.addPool(bladeRowWallRight, 20); wallSectionBuilder.poolManager = poolManager; }
public static void SaveLevelData(int lvlId, LevelData data) { FileInfo fInfo = new FileInfo("Levels/Level_" + lvlId.ToString("D2") + ".xml"); if (fInfo.Exists) File.Delete(fInfo.FullName); StreamWriter writer = fInfo.CreateText(); XmlSerializer xmlSerializer = new XmlSerializer(typeof(LevelData)); xmlSerializer.Serialize(writer, data); writer.Close(); }
public LevelHandler(LevelData levelData, ISectionDesigning sectionDesigner, IRowCleanup rowCleaner) { this.sectionDesigner = sectionDesigner; this.rowCleaner = rowCleaner; level = new Queue<List<GameObject>>(); for(int i =0; i< levelData.levelLength; ++i) { level.Enqueue(new List<GameObject>()); } }
public void save() { BinaryFormatter bf = new BinaryFormatter(); FileStream file = File.Create(Application.persistentDataPath + "/levelData.dat"); Debug.Log("Saved level data to: " + Application.persistentDataPath + "/levelData.dat"); LevelData data = new LevelData(); data.completedLevels = this.completedLevels; data.unlockedLevels = this.unlockedLevels; bf.Serialize(file, data); file.Close(); }
public void CreateFirstLevel() { Data.levels = new System.Collections.Generic.List<LevelData>(); LevelData l = new LevelData(); l.levelIndex = 1; l.countOfKeys = 1; l.countOfKeysDuringGame = 1; l.totalTime = 60; l.keyTime = 10; Data.levels.Add(l); Data.SaveLevels(); }
private HallNode generateHallNode(LevelData data, int i, int j) { HallNode node = new HallNode (); if (i - 1 < 0 || (data.wallAt (i - 1, j) && !data.wallAt (i, j))) node.setWall (HallNode.Wall.LEFT); if (i + 1 >= hallWidth || (data.wallAt (i + 1, j) && !data.wallAt (i, j))) node.setWall (HallNode.Wall.RIGHT); if (j - 1 < 0 || (data.wallAt (i, j - 1) && !data.wallAt (i, j))) node.setWall (HallNode.Wall.TOP); if (j + 1 >= hallHeight || (data.wallAt (i, j + 1) && !data.wallAt (i, j))) node.setWall (HallNode.Wall.BOTTOM); return node; }
public static Sprite MapASMDPLCToBmp(byte[] artfile, string mapfileloc, EngineVersion mapversion, string dplcloc, EngineVersion dplcversion, int frame, int startpal, bool priority = false) { if (mapversion == EngineVersion.Invalid) { mapversion = LevelData.Game.MappingsVersion; } if (dplcversion == EngineVersion.Invalid) { dplcversion = LevelData.Game.DPLCVersion; } return(MapDPLCToBmp(artfile, LevelData.ASMToBin(mapfileloc, mapversion), mapversion, LevelData.ASMToBin(dplcloc, dplcversion), dplcversion, frame, startpal, priority)); }
void lastLevelLoad(LevelData level, Sprite sp, System.Action loadMethod) { Image im = LevelBtnPrefab.GetComponent <Image>(); im.sprite = sp; }
private extern IEnumerator orig_TransitionRoutine(LevelData next, Vector2 direction);
public void PlayLevel(int levelId) { LevelData data = LevelDataBase.LoadLevelData(levelId); LoadLevel(levelId, data, false); EnableWinCheck = true; CheckWinGrids = new bool[GridRowCount, GridColCount]; foreach (ElementData eleData in data.LevelEnd) { if (eleData.Catagory == 2) { CheckGreenGrid = new Vector2(eleData.GridX, eleData.GridY); continue; } if (eleData.Catagory == 3) { CheckRedGrid = new Vector2(eleData.GridX, eleData.GridY); continue; } ElementInfo eleInfo = ElementFactory.ElementInfos.First(ei => ei.Catagory == eleData.Catagory && ei.Type == eleData.Type); int eleGridX = eleData.GridX; int eleGridY = eleData.GridY; foreach (Vector2 pos in eleInfo.OccupyGridsL) { int eleSegX = (int)(eleGridX + pos.x); int eleSegY = (int)(eleGridY + pos.y); if (GetGridWorldIndex(eleSegX) == 0) { CheckWinGrids[eleSegY, eleSegX] = true; } } foreach (Vector2 pos in eleInfo.OccupyGridsR) { int eleSegX = (int)(eleGridX + pos.x); int eleSegY = (int)(eleGridY + pos.y); if (GetGridWorldIndex(eleSegX) == 1) { CheckWinGrids[eleSegY, eleSegX] = true; } } } // add guides for (int i = 0; i < GridRowCount; i++) { for (int j = 0; j < GridColCount; j++) { if (CheckWinGrids[i, j]) { GameObject guide = (GameObject)Instantiate(Resources.Load <GameObject>("guideElement")); Guides.Add(guide); guide.transform.position = new Vector3(PosStartX + GridWorldSize * j, PosStartY + GridWorldSize * i, -0.05f); } } } GuideGreen = (GameObject)Instantiate(Resources.Load <GameObject>("guideGreen")); GuideGreen.transform.position = new Vector3(PosStartX + GridWorldSize * (CheckGreenGrid.x + 0.5f), PosStartY + GridWorldSize * (CheckGreenGrid.y - 0.5f), -0.05f); GuideRed = (GameObject)Instantiate(Resources.Load <GameObject>("guideRed")); GuideRed.transform.position = new Vector3(PosStartX + GridWorldSize * (CheckRedGrid.x + 0.5f), PosStartY + GridWorldSize * (CheckRedGrid.y - 0.5f), -0.05f); // show intro Transform introTrans = PanelGame.transform.Find("Intro"); if (introTrans) { Destroy(introTrans.gameObject); } GameObject intro = new GameObject("Intro"); intro.AddComponent <SpriteRenderer>().sprite = Resources.Load <Sprite>("Intros/intro_" + levelId.ToString("D2")); intro.transform.parent = PanelGame.transform; }
private void Awake() { playerData = GameFacade.GetInstance().playerData; levelData = GameFacade.GetInstance().levelData; gameUIController = GameFacade.GetInstance().gameUIController; }
public void LoadLevel(string levelPath, bool playing) { // Load LevelData and initialize the lists levelData = (LevelData)SerializationManager.LoadData(levelPath); TileElement tileModel = Constants.TILE_MODELS[(int)TileElementNames.Ground]; availableVines = levelData.availableVines; // Create the Grounds board = new TileElement[levelData.grounds.GetLength(0), levelData.grounds.GetLength(1), levelData.grounds.GetLength(2)]; for (int x = 0; x < board.GetLength(0); x++) { for (int y = 0; y < board.GetLength(1); y++) { for (int z = 0; z < board.GetLength(2); z++) { if (levelData.grounds[x, y, z] != null) { board[x, y, z] = tileModel.LoadTileElement(new object[] { new Vector3Int(x, y, z), levelData.grounds[x, y, z] }); board[x, y, z].model = Instantiate(Resources.Load("Models/Ground")) as GameObject; board[x, y, z].BindDataToModel(); board[x, y, z].WarpToPos(); ((Ground)board[x, y, z]).ColorFacets(litBases); } } } } // Create Bramble and save his position bramble = (Bramble)Constants.TILE_MODELS[(int)TileElementNames.Bramble].LoadTileElement(new object[] { new Vector3Int(levelData.brambleCoords[0], levelData.brambleCoords[1], levelData.brambleCoords[2]), levelData.brambleDirection }); bramble.model = Instantiate(Resources.Load("Models/Bramble")) as GameObject; bramble.BindDataToModel(); bramble.WarpToPos(); board[bramble.GetPos().x, bramble.GetPos().y, bramble.GetPos().z] = bramble; // Create the Sigil board[levelData.sigilCoords[0], levelData.sigilCoords[1], levelData.sigilCoords[2]] = (Sigil)Constants.TILE_MODELS[(int)TileElementNames.Sigil].LoadTileElement(new object[] { new Vector3Int(levelData.sigilCoords[0], levelData.sigilCoords[1], levelData.sigilCoords[2]), }); board[levelData.sigilCoords[0], levelData.sigilCoords[1], levelData.sigilCoords[2]].model = Instantiate(Resources.Load("Models/Sigil")) as GameObject; board[levelData.sigilCoords[0], levelData.sigilCoords[1], levelData.sigilCoords[2]].BindDataToModel(); board[levelData.sigilCoords[0], levelData.sigilCoords[1], levelData.sigilCoords[2]].WarpToPos(); // Convert the data arrays to Queues Queue <int> intQueue = new Queue <int>(); for (int i = 0; i < levelData.dataInts.Length; i++) { intQueue.Enqueue(levelData.dataInts[i]); } Queue <Shade> shadeQueue = new Queue <Shade>(); for (int i = 0; i < levelData.dataShades.Length; i++) { shadeQueue.Enqueue(levelData.dataShades[i]); } // Decompile all of the non-essential elements for (int i = 0; i < levelData.tileTypes.Length; i++) { TileElement tileBase = Constants.TILE_MODELS[(int)levelData.tileTypes[i]]; TileElement decompiledTile = tileBase.DecompileTileElement(ref intQueue, ref shadeQueue); decompiledTile.model = Instantiate(Resources.Load("Models/" + tileBase.TileName())) as GameObject; decompiledTile.BindDataToModel(); decompiledTile.WarpToPos(); decompiledTile.AdjustRender(); if (tileBase is Monocoord) { Monocoord monoTile = (Monocoord)decompiledTile; board[monoTile.GetPos().x, monoTile.GetPos().y, monoTile.GetPos().z] = decompiledTile; } else { Dicoord diTile = (Dicoord)decompiledTile; for (int x = diTile.GetPos1().x; x <= diTile.GetPos2().x; x++) { for (int y = diTile.GetPos1().y; y <= diTile.GetPos2().y; y++) { for (int z = diTile.GetPos1().z; z <= diTile.GetPos2().z; z++) { board[x, y, z] = decompiledTile; } } } } } CameraManager.current.CalibrateCamera(board); }
private void Start() { levelData = SaveManager.Read("Save.dat"); }
public void GoToGameplay(LevelData level) { SessionManager.Instance.levelData = level; SceneManager.LoadScene(gameplaySceneName); }
private void Construct(LevelData data) { levelData = data; }
private void AddEvents() { leftEventManager = leftSaber?.GetComponent <EventManager>(); if (!leftEventManager) { leftEventManager = leftSaber.AddComponent <EventManager>(); } rightEventManager = rightSaber?.GetComponent <EventManager>(); if (!rightEventManager) { rightEventManager = rightSaber.AddComponent <EventManager>(); } if (leftEventManager?.OnLevelStart == null || rightEventManager?.OnLevelStart == null) { return; } leftEventManager.OnLevelStart.Invoke(); rightEventManager.OnLevelStart.Invoke(); try { scoreController = FindObjectsOfType <ScoreController>().FirstOrDefault(); if (scoreController) { scoreController.multiplierDidChangeEvent += MultiplierCallBack; scoreController.comboDidChangeEvent += ComboChangeEvent; } else { Logger.log.Warn($"Failed to locate a suitable '{nameof(ScoreController)}'."); } beatmapObjectManager = scoreController.GetField <BeatmapObjectManager, ScoreController>("_beatmapObjectManager"); if (beatmapObjectManager != null) { beatmapObjectManager.noteWasCutEvent += SliceCallBack; beatmapObjectManager.noteWasMissedEvent += NoteMissCallBack; } else { Logger.log.Warn($"Failed to locate a suitable '{nameof(BeatmapObjectManager)}'."); } saberCollisionManager = Resources.FindObjectsOfTypeAll <ObstacleSaberSparkleEffectManager>().FirstOrDefault(); if (saberCollisionManager) { saberCollisionManager.sparkleEffectDidStartEvent += SaberStartCollide; saberCollisionManager.sparkleEffectDidEndEvent += SaberEndCollide; } else { Logger.log.Warn($"Failed to locate a suitable '{nameof(ObstacleSaberSparkleEffectManager)}'."); } gameEnergyCounter = Resources.FindObjectsOfTypeAll <GameEnergyCounter>().FirstOrDefault(); if (gameEnergyCounter) { gameEnergyCounter.gameEnergyDidReach0Event += FailLevelCallBack; } else { Logger.log.Warn($"Failed to locate a suitable '{nameof(GameEnergyCounter)}'."); } beatmapCallback = Resources.FindObjectsOfTypeAll <BeatmapObjectCallbackController>().FirstOrDefault(); if (beatmapCallback) { beatmapCallback.beatmapEventDidTriggerEvent += LightEventCallBack; } else { Logger.log.Warn($"Failed to locate a suitable '{nameof(BeatmapObjectCallbackController)}'."); } playerHeadAndObstacleInteraction = scoreController.GetField <PlayerHeadAndObstacleInteraction, ScoreController>("_playerHeadAndObstacleInteraction"); if (playerHeadAndObstacleInteraction == null) { Logger.log.Warn($"Failed to locate a suitable '{nameof(PlayerHeadAndObstacleInteraction)}'."); } } catch (Exception ex) { Logger.log.Error(ex); throw; } try { float LastTime = 0.0f; LevelData levelData = BS_Utils.Plugin.LevelData; BeatmapData beatmapData = levelData.GameplayCoreSceneSetupData.difficultyBeatmap.beatmapData; IReadOnlyList <IReadonlyBeatmapLineData> beatmapLinesData = beatmapData.beatmapLinesData; foreach (BeatmapLineData beatMapLineData in beatmapLinesData) { IReadOnlyList <BeatmapObjectData> beatmapObjectsData = beatMapLineData.beatmapObjectsData; for (int i = beatmapObjectsData.Count - 1; i >= 0; i--) { BeatmapObjectData beatmapObjectData = beatmapObjectsData[i]; if (beatmapObjectData.beatmapObjectType == BeatmapObjectType.Note && ((NoteData)beatmapObjectData).colorType != global::ColorType.None) { if (beatmapObjectData.time > LastTime) { LastTime = beatmapObjectData.time; } } } } lastNoteTime = LastTime; } catch (Exception ex) { Logger.log.Error(ex); throw; } }
public override void InitialiseCell(LevelData levelData) { killCount = levelData.totalKills; }
private void LoadLevel(int level) { _level = _levels.First(l => l.level == level); }
public static byte[] OpenArtFile(string file, CompressionType comp) { return(LevelData.ReadFile(file, comp)); }
public static Entity LoadRight(Level level, LevelData levelData, Vector2 offset, EntityData entityData) => new TriggerSpikesOriginal(entityData, offset, Directions.Right);
public void LoadCurrentLevel() { LevelData data = SaveSystem.loadLevel(); currentLevel = data.level; }
void Awake() { GameObject gameMaster = GameObject.Find("GameMaster"); if (stats == null) { stats = gameMaster.GetComponent <GameStats>(); } if (stats == null) { stats = gameMaster.AddComponent <GameStats>(); } if (level == null) { level = Utility.GetLevelData(); } if (level == null) { Debug.LogError("LevelData is null"); } if (debugger == null) { debugger = gameMaster.GetComponent <Debugger>(); } if (debugger == null) { debugger = gameMaster.AddComponent <Debugger>(); } if (ballCollision == null) { ballCollision = GetComponent <BallCollision>(); } if (ballCollision == null) { Debug.LogError("ballCollision is null"); } if (anchorRb == null) { anchorRb = transform.parent.GetComponent <Rigidbody2D>(); } if (anchorRb == null) { Debug.LogError("anchorRb is null"); } if (selfCollider == null) { selfCollider = GetComponent <CircleCollider2D>(); } if (selfCollider == null) { Debug.LogError("selfCollider is null"); } if (selfRb == null) { selfRb = GetComponent <Rigidbody2D>(); } if (selfRb == null) { Debug.LogError("selfRb is null"); } if (springJoint == null) { springJoint = GetComponent <SpringJoint2D>(); } if (springJoint == null) { Debug.LogError("springJoint is null"); } }
AreaData(LevelData levelData) { m_LevelData = levelData; }
private void loadLevel(LevelData level, LevelButton btn) { Image image = btn.GetComponentInChildren <Image>(); Sprite levelSpr = null; if (image != null) { Texture2D texture = null; if (level is LevelDataLoaded) { texture = GameDataSaver.LoadTexture((level as LevelDataLoaded).TexturePath); } else if (level is LevelDataDefault) { texture = (level as LevelDataDefault).Texture; } if (texture != null) { levelSpr = Sprite.Create(texture, new Rect(0, 0, 512, 512), Vector2.zero, 100); } image.sprite = levelSpr; } btn.onClick.AddListener(() => { if (LevelButton.LastBtnClicked != btn) { LevelButton.LastBtnClicked = btn; LevelButton.ClickCount = 0; } LevelButton.ClickCount++; if (LevelButton.ClickCount == 1) { showStats(level); } else if (LevelButton.ClickCount == 2) { LevelButton.LastBtnClicked = null; LevelButton.ClickCount = 0; FindObjectOfType <GameDataSaver>().LoadLevel(level); } }); if (level is LevelDataLoaded) { btn.onPressing.AddListener(() => { DeletelevelDialogPanel.position = btn.transform.position; DeletelevelDialogPanel.sizeDelta = btn.GetComponent <RectTransform>().sizeDelta; DeletelevelDialogPanel.gameObject.SetActive(true); DeleteBtn.onClick.RemoveAllListeners(); DeleteBtn.onClick.AddListener(() => { FindObjectOfType <GameDataSaver>().DeleteLevel(level); DeletelevelDialogPanel.gameObject.SetActive(false); Destroy(btn.gameObject); loadLevel(GameDataSaver.LastLevel, LastLevelImg); }); }); } }
public GameSettingsManager(LevelData levelData) { this.levelData = levelData; }
public new void TransitionTo(LevelData next, Vector2 direction) { orig_TransitionTo(next, direction); Everest.Events.Level.TransitionTo(this, next, direction); }
public static Entity LoadRight(Level level, LevelData levelData, Vector2 offset, EntityData entityData) { entityData.Values["type"] = entityData.Attr("hotType", "default"); return(new CoreModeSpikes(entityData, offset, Directions.Right)); }
public extern void orig_TransitionTo(LevelData next, Vector2 direction);
private void BuildRiver(int levelDepth, int levelWidth, Vector3 riverOrigin, LevelData levelData) { HashSet <Vector3> visitedCoordinates = new HashSet <Vector3>(); // the first coordinate is the river origin Vector3 currentCoordinate = riverOrigin; bool foundWater = false; while (!foundWater) { // convert from Level Coordinate System to Tile Coordinate System and retrieve the corresponding TileData TileCoordinate tileCoordinate = levelData.ConvertToTileCoordinate((int)currentCoordinate.z, (int)currentCoordinate.x); TileData tileData = levelData.tileData[tileCoordinate.tileZIndex, tileCoordinate.tileXIndex]; // save the current coordinate as visited visitedCoordinates.Add(currentCoordinate); // check if we have found water if (tileData.chosenHeightTerrainTypes[tileCoordinate.coordinateZIndex, tileCoordinate.coordinateXIndex].name == "water") { // if we found water, we stop foundWater = true; } else { // change the texture of the tileData to show a river tileData.texture.SetPixel(tileCoordinate.coordinateXIndex, tileCoordinate.coordinateZIndex, this.riverColor); tileData.texture.Apply(); // pick neighbor coordinates, if they exist List <Vector3> neighbors = new List <Vector3>(); if (currentCoordinate.z > 0) { neighbors.Add(new Vector3(currentCoordinate.x, 0, currentCoordinate.z - 1)); } if (currentCoordinate.z < levelDepth - 1) { neighbors.Add(new Vector3(currentCoordinate.x, 0, currentCoordinate.z + 1)); } if (currentCoordinate.x > 0) { neighbors.Add(new Vector3(currentCoordinate.x - 1, 0, currentCoordinate.z)); } if (currentCoordinate.x < levelWidth - 1) { neighbors.Add(new Vector3(currentCoordinate.x + 1, 0, currentCoordinate.z)); } // find the minimum neighbor that has not been visited yet and flow to it float minHeight = float.MaxValue; Vector3 minNeighbor = new Vector3(0, 0, 0); foreach (Vector3 neighbor in neighbors) { // convert from Level Coordinate System to Tile Coordinate System and retrieve the corresponding TileData TileCoordinate neighborTileCoordinate = levelData.ConvertToTileCoordinate((int)neighbor.z, (int)neighbor.x); TileData neighborTileData = levelData.tileData[neighborTileCoordinate.tileZIndex, neighborTileCoordinate.tileXIndex]; // if the neighbor is the lowest one and has not been visited yet, save it float neighborHeight = tileData.heightMap[neighborTileCoordinate.coordinateZIndex, neighborTileCoordinate.coordinateXIndex]; if (neighborHeight < minHeight && !visitedCoordinates.Contains(neighbor)) { minHeight = neighborHeight; minNeighbor = neighbor; } } // flow to the lowest neighbor currentCoordinate = minNeighbor; } } }
} // Offset: 0x20 public IReadOnlyBinaryDataAccessor GetDataReference() { return(LevelData.GetReadOnlyDataReference(Header.FileDataOffset + FileDataOffset, FileDataLength)); }
public override void OnInspectorGUI() { base.OnInspectorGUI(); LevelData data = (LevelData)target; if (data.Grid != Vector2Int.zero) { EditorGUILayout.Space(); EditorGUI.indentLevel = 0; GUIStyle boardStyle = new GUIStyle("box"); boardStyle.padding = new RectOffset(5, 5, 5, 5); boardStyle.margin.left = 16; GUIStyle headerY = new GUIStyle(); headerY.fixedHeight = 35; GUIStyle colStyle = new GUIStyle(); colStyle.fixedWidth = fixedEnumWidth; GUIStyle rowStyle = new GUIStyle(); rowStyle.fixedHeight = rowHeight; GUIStyle rowHeaderStyle = new GUIStyle(); rowHeaderStyle.fixedWidth = colStyle.fixedWidth - 1; GUIStyle colHeaderStyle = new GUIStyle(); colHeaderStyle.fixedWidth = 32; colHeaderStyle.fixedHeight = rowHeight; GUIStyle colLabelStyle = new GUIStyle(); colLabelStyle.fixedWidth = rowHeaderStyle.fixedWidth - 6; colLabelStyle.alignment = TextAnchor.MiddleCenter; colLabelStyle.fontStyle = FontStyle.Bold; //Define the label of the corner. It will read (Row, Col) GUIStyle cornerLabelStyle = new GUIStyle(); cornerLabelStyle.fixedWidth = 64; cornerLabelStyle.alignment = TextAnchor.UpperLeft; cornerLabelStyle.fontStyle = FontStyle.BoldAndItalic; cornerLabelStyle.fontSize = 12; cornerLabelStyle.padding.top = -5; GUIStyle rowLabelStyle = new GUIStyle(); rowLabelStyle.fixedWidth = 15; rowLabelStyle.alignment = TextAnchor.MiddleLeft; rowLabelStyle.fontStyle = FontStyle.Bold; GUIStyle enumStyle = new GUIStyle("popup"); enumStyle.fixedWidth = fixedEnumWidth; EditorGUILayout.BeginHorizontal(boardStyle); for (int col = -1; col < data.Grid.y; col++) { EditorGUILayout.BeginVertical((col == -1) ? headerY : colStyle); for (int row = -1; row < data.Grid.x; row++) { //First, draw corner with to display row and col if (col == -1 && row == -1) { EditorGUILayout.BeginVertical(rowHeaderStyle); EditorGUILayout.LabelField("Row,Col", cornerLabelStyle); EditorGUILayout.EndHorizontal(); } else if (col == -1) { EditorGUILayout.BeginVertical(colHeaderStyle); EditorGUILayout.LabelField(row.ToString(), rowLabelStyle); EditorGUILayout.EndHorizontal(); } else if (row == -1) { EditorGUILayout.BeginVertical(rowHeaderStyle); EditorGUILayout.LabelField(col.ToString(), colLabelStyle); EditorGUILayout.EndHorizontal(); } if (col >= 0 && row >= 0) { EditorGUILayout.BeginHorizontal(rowStyle); //redo grid if the size changed if (data.Grid.x < row || data.Grid.y < col || data.boardInfo.Length != (data.Grid.x * data.Grid.y)) { data.SetBoard(data.Grid); } int index = data.GetIndex(row, col); data.boardInfo[index] = (GridInfo)EditorGUILayout.EnumPopup(data.boardInfo[index], enumStyle); EditorGUILayout.EndHorizontal(); } } EditorGUILayout.EndVertical(); } EditorGUILayout.EndHorizontal(); } //end if data grid != 0 }
public void Load(RectTransform pagesParent, RectTransform pagePrefab, LevelButton levelBtnPrefab, List <LevelData> levels, LevelData lastlevel, int levelsOnPage) { for (int i = 0; i < levels.Count; i++) { LevelButton btn = Instantiate(levelBtnPrefab); btn.transform.SetParent(LevelsParent); btn.transform.localScale = Vector3.one; int levelNumber = i; loadLevel(levels[levelNumber], btn); } }
public GameStateManager(LevelData levelData) { this.levelData = levelData; }
/// <summary> /// Serializes the level to a byte array, with an optional root item. The root item /// and its children, if specified, will be the only things saved /// </summary> /// <returns> The level data as a byte array </returns> /// <param name='urgent'> Whether to save even if serialization is suspended </param> /// <param name='id'> Identifier (or null) of an object to be the root of the data serialization </param> public static string SerializeLevel(bool urgent, string id) { LevelData ld; using (new Radical.Logging()) { using (new UnitySerializer.ForceJSON()) { //First we need to know the name of the last level loaded using (new UnitySerializer.SerializationScope()) { ld = new LevelData() { //The level to reload Name = Application.loadedLevelName }; //All of the currently active uniquely identified objects ld.StoredObjectNames = UniqueIdentifier .AllIdentifiers .Where(i => string.IsNullOrEmpty(id) || i.Id == id || HasParent(i, id)) .Select(i => i.gameObject) .Where(go => go != null) .Where(go => { var shouldSerialize = go.FindInterface <IControlSerializationEx>(); return(shouldSerialize == null || shouldSerialize.ShouldSaveWholeObject()); }) .Where(go => { if (Store == null) { return(true); } var result = true; Store(go, ref result); return(result); }) .Select(n => { try { var si = new StoredItem() { createEmptyObject = n.GetComponent <EmptyObjectIdentifier>() != null, Active = n.activeSelf, layer = n.layer, tag = n.tag, setExtraData = true, Components = n.GetComponents <Component>().Where(c => c != null).Select( c => c.GetType().FullName).Distinct(). ToDictionary(v => v, v => true), Name = n.GetComponent <UniqueIdentifier>().Id, GameObjectName = n.name, ParentName = (n.transform.parent == null || n.transform.parent.GetComponent <UniqueIdentifier>() == null) ? null : (n.transform.parent.GetComponent <UniqueIdentifier>(). Id), ClassId = n.GetComponent <PrefabIdentifier>() != null ? n.GetComponent <PrefabIdentifier>().ClassId : string.Empty }; if (n.GetComponent <StoreInformation>()) { n.SendMessage("OnSerializing", SendMessageOptions.DontRequireReceiver); } var pf = n.GetComponent <PrefabIdentifier>(); if (pf != null) { var components = GetComponentsInChildrenWithClause(n); si.Children = components.GroupBy(c => c.ClassId).ToDictionary(c => c.Key, c => c.Select( i => i.Id) .ToList()); } return(si); } catch (Exception e) { Debug.LogWarning("Failed to serialize status of " + n.name + " with error " + e.ToString()); return(null); } }) .Where(si => si != null) .ToList(); //All of the data for the items to be stored var toBeProcessed = UniqueIdentifier .AllIdentifiers .Where(o => o.GetComponent <StoreInformation>() != null || o.GetComponent <PrefabIdentifier>() != null) .Where(i => string.IsNullOrEmpty(id) || i.Id == id || HasParent(i, id)) .Where(i => i != null) .Select(i => i.gameObject) .Where(i => i != null) .Where(go => { var shouldSerialize = go.FindInterface <IControlSerializationEx>(); return(shouldSerialize == null || shouldSerialize.ShouldSaveWholeObject()); }) .Distinct() .Where(go => { if (Store == null) { return(true); } var result = true; Store(go, ref result); return(result); }) .SelectMany(o => o.GetComponents <Component>()) .Where(c => { if (c == null) { return(false); } var tp = c.GetType(); var store = true; StoreComponent(c, ref store); return(store && (!(c is IControlSerialization) || (c as IControlSerialization).ShouldSave()) && !tp.IsDefined(typeof(DontStoreAttribute), true) && !IgnoreTypes.Contains(tp.FullName)); }) .Select(c => new { Identifier = (StoreInformation)c.gameObject.GetComponent(typeof(StoreInformation)), Component = c }) .Where(cp => (cp.Identifier.StoreAllComponents || cp.Identifier.Components.Contains(cp.Component.GetType().FullName))) .OrderBy(cp => cp.Identifier.Id) .ThenBy(cp => cp.Component.GetType().FullName).ToList(); var processed = 0; ld.StoredItems = toBeProcessed .Select(cp => { try { if (Radical.IsLogging()) { Radical.Log("<{0} : {1} - {2}>", cp.Component.gameObject.GetFullName(), cp.Component.GetType().Name, cp.Component.GetComponent <UniqueIdentifier>().Id); Radical.IndentLog(); } var sd = new StoredData() { Type = cp.Component.GetType().FullName, ClassId = cp.Identifier.ClassId, Name = cp.Component.GetComponent <UniqueIdentifier>().Id }; if (CustomSerializers.ContainsKey(cp.Component.GetType())) { sd.Data = UnitySerializer.TextEncoding.GetString(CustomSerializers[cp.Component.GetType()].Serialize(cp.Component)); } else { sd.Data = UnitySerializer.JSONSerializeForDeserializeInto(cp.Component); } if (Radical.IsLogging()) { Radical.OutdentLog(); Radical.Log("</{0} : {1}>", cp.Component.gameObject.GetFullName(), cp.Component.GetType().Name); } processed++; Progress("Storing", (float)processed / (float)toBeProcessed.Count); return(sd); } catch (Exception e) { processed++; Debug.LogWarning("Failed to serialize data (" + cp.Component.GetType().AssemblyQualifiedName + ") of " + cp.Component.name + " with error " + e.ToString()); return(null); } }) .Where(s => s != null) .ToList(); } } } var data = UnitySerializer.JSONSerialize(ld); return(data); }
private IEnumerator SpawnWithDelay() { yield return(new WaitForEndOfFrame()); data = LevelsDifficultyContainer.Houses[LevelContainer.CurrentHouseNumber - 1].levelsData[LevelContainer.CurrentLevelIndex]; numberOfNails = LevelContainer.NumberOfNails; int i = 0; while (i < numberOfNails) { yield return(new WaitForEndOfFrame()); int index = Random.Range(1, 7); switch (index) { case 1: if (spawnedDefaultNails < data.numberOfDefaultNails) { Nail defNail = Instantiate(defaultNail, defaultNail.transform.position + new Vector3(Xoffset * i, 0f, 0f), Quaternion.identity) as DefaultNail; defNail.gameObject.transform.SetParent(transform); defNail.Xoffset = Xoffset; spawnedDefaultNails++; i++; } break; case 2: if (spawnedRedNails < data.numberOfRedNails) { Nail rNail = Instantiate(redNail, redNail.transform.position + new Vector3(Xoffset * i, 0f, 0f), Quaternion.identity) as RedNail; rNail.gameObject.transform.SetParent(transform); rNail.Xoffset = Xoffset; spawnedRedNails++; i++; } break; case 3: if (spawnedMediumNails < data.numberOfMediumNails) { Nail mNail = Instantiate(mediumNail, mediumNail.transform.position + new Vector3(Xoffset * i, 0f, 0f), Quaternion.identity) as MediumNail; mNail.gameObject.transform.SetParent(transform); mNail.Xoffset = Xoffset; spawnedMediumNails++; i++; } break; case 4: if (spawnedMovingDefaultNails < data.movingDefaultNails) { Nail defNail = Instantiate(defaultNail, defaultNail.transform.position + new Vector3(Xoffset * i, 0f, 0f), Quaternion.identity) as DefaultNail; defNail.gameObject.transform.SetParent(transform); defNail.Xoffset = Xoffset; defNail.transform.position = defNail.DefaultPosition; defNail.isMoving = true; spawnedMovingDefaultNails++; i++; } break; case 5: if (spawnedMovingRedNails < data.movingRedNails) { Nail rNail = Instantiate(redNail, redNail.transform.position + new Vector3(Xoffset * i, 0f, 0f), Quaternion.identity) as RedNail; rNail.gameObject.transform.SetParent(transform); rNail.Xoffset = Xoffset; rNail.transform.position = rNail.DefaultPosition; rNail.isMoving = true; spawnedMovingRedNails++; i++; } break; case 6: if (spawnedMovingMediumNails < data.movingMediumNails) { Nail mNail = Instantiate(mediumNail, mediumNail.transform.position + new Vector3(Xoffset * i, 0f, 0f), Quaternion.identity) as MediumNail; mNail.gameObject.transform.SetParent(transform); mNail.Xoffset = Xoffset; mNail.transform.position = mNail.DefaultPosition; mNail.isMoving = true; spawnedMovingMediumNails++; i++; } break; } } }
public static bool LoadCustomEntity(EntityData entityData, Level level) { LevelData levelData = level.Session.LevelData; Vector2 offset = new Vector2(levelData.Bounds.Left, levelData.Bounds.Top); if (Everest.Events.Level.LoadEntity(level, levelData, offset, entityData)) { return(true); } if (EntityLoaders.TryGetValue(entityData.Name, out EntityLoader loader)) { Entity loaded = loader(level, levelData, offset, entityData); if (loaded != null) { level.Add(loaded); return(true); } } if (entityData.Name == "everest/spaceController") { level.Add(new SpaceController()); return(true); } // The following entities have hardcoded "attributes." // Everest allows custom maps to set them. if (entityData.Name == "spinner") { if (level.Session.Area.ID == 3 || (level.Session.Area.ID == 7 && level.Session.Level.StartsWith("d-")) || entityData.Bool("dust")) { level.Add(new DustStaticSpinner(entityData, offset)); return(true); } CrystalColor color = CrystalColor.Blue; if (level.Session.Area.ID == 5) { color = CrystalColor.Red; } else if (level.Session.Area.ID == 6) { color = CrystalColor.Purple; } else if (level.Session.Area.ID == 10) { color = CrystalColor.Rainbow; } else if ("core".Equals(entityData.Attr("color"), StringComparison.InvariantCultureIgnoreCase)) { color = (CrystalColor)(-1); } else if (!Enum.TryParse(entityData.Attr("color"), true, out color)) { color = CrystalColor.Blue; } level.Add(new CrystalStaticSpinner(entityData, offset, color)); return(true); } if (entityData.Name == "trackSpinner") { if (level.Session.Area.ID == 10 || entityData.Bool("star")) { level.Add(new StarTrackSpinner(entityData, offset)); return(true); } else if (level.Session.Area.ID == 3 || (level.Session.Area.ID == 7 && level.Session.Level.StartsWith("d-")) || entityData.Bool("dust")) { level.Add(new DustTrackSpinner(entityData, offset)); return(true); } level.Add(new BladeTrackSpinner(entityData, offset)); return(true); } if (entityData.Name == "rotateSpinner") { if (level.Session.Area.ID == 10 || entityData.Bool("star")) { level.Add(new StarRotateSpinner(entityData, offset)); return(true); } else if (level.Session.Area.ID == 3 || (level.Session.Area.ID == 7 && level.Session.Level.StartsWith("d-")) || entityData.Bool("dust")) { level.Add(new DustRotateSpinner(entityData, offset)); return(true); } level.Add(new BladeRotateSpinner(entityData, offset)); return(true); } if (entityData.Name == "checkpoint" && entityData.Position == Vector2.Zero && !entityData.Bool("allowOrigin")) { // Workaround for mod levels with old versions of Ahorn containing a checkpoint at (0, 0): // Create the checkpoint and avoid the start position update in orig_Load. level.Add(new Checkpoint(entityData, offset)); return(true); } if (entityData.Name == "cloud") { patch_Cloud cloud = new Cloud(entityData, offset) as patch_Cloud; if (entityData.Has("small")) { cloud.Small = entityData.Bool("small"); } level.Add(cloud); return(true); } if (entityData.Name == "cobweb") { patch_Cobweb cobweb = new Cobweb(entityData, offset) as patch_Cobweb; if (entityData.Has("color")) { cobweb.OverrideColors = entityData.Attr("color")?.Split(',').Select(s => Calc.HexToColor(s)).ToArray(); } level.Add(cobweb); return(true); } if (entityData.Name == "movingPlatform") { patch_MovingPlatform platform = new MovingPlatform(entityData, offset) as patch_MovingPlatform; if (entityData.Has("texture")) { platform.OverrideTexture = entityData.Attr("texture"); } level.Add(platform); return(true); } if (entityData.Name == "sinkingPlatform") { patch_SinkingPlatform platform = new SinkingPlatform(entityData, offset) as patch_SinkingPlatform; if (entityData.Has("texture")) { platform.OverrideTexture = entityData.Attr("texture"); } level.Add(platform); return(true); } if (entityData.Name == "crumbleBlock") { patch_CrumblePlatform platform = new CrumblePlatform(entityData, offset) as patch_CrumblePlatform; if (entityData.Has("texture")) { platform.OverrideTexture = entityData.Attr("texture"); } level.Add(platform); return(true); } if (entityData.Name == "wire") { Wire wire = new Wire(entityData, offset); if (entityData.Has("color")) { wire.Color = entityData.HexColor("color"); } level.Add(wire); return(true); } return(false); }