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);
}
