public static ViewLevelOrder ToViewModel(LevelOrder model)
{
if (model == null)
{
return(null);
}
ViewLevelOrder item = new ViewLevelOrder();
item.ID = model.ID;
item.LevelOrderID = model.LevelOrderID;
item.UID = model.UID;
item.Name = model.Name;
item.OrderType = model.OrderType;
item.OrderState = model.OrderState;
item.OrderScore = model.OrderScore;
item.OrderDel = model.OrderDel;
item.OriginalLevel = model.OriginalLevel;
item.TargetLevel = model.TargetLevel;
item.ManageID = model.ManageID;
item.CreateTime = model.CreateTime;
item.UpdateTime = model.UpdateTime;
item.Reason = model.Reason;
item.Remark1 = model.Remark1;
item.Remark2 = model.Remark2;
return(item);
}
public void SetChapter(string chapter)
{
if (!LevelOrder.Contains(chapter))
{
return;
}
chapterInt = LevelOrder.ToList().IndexOf(chapter);
}
/// <summary>
/// Implements a simple user interaction to ask for a directory to traverse
/// and compute statistics for.
/// </summary>
public static void DemoDirectoryTreeTraversal()
{
Console.WriteLine();
Console.WriteLine();
Console.WriteLine();
Console.WriteLine("This demo visits (traverses) all sub-directories of a");
Console.WriteLine("given directory and outputs the size of all files in the end.");
Console.WriteLine();
Console.WriteLine("Please input a path e.g. 'C:' (without quotes) or just press enter if you");
Console.WriteLine("do not want to see this demo right now.");
string path = Console.ReadLine();
if (string.IsNullOrEmpty(path) == true)
{
return;
}
if (path.Length == 2) // Change 'C:' into 'C:\' to make sure its a valid path
{
if (path[1] == ':')
{
path += '\\';
}
}
var res = new DirSizeResult(); // Initialize result object
// You can use LevelOrder<T>, PostOrder<T>, and PreOrder<T> here
var Order = new LevelOrder <DirSizeResult, DirectoryInfo>();
res = Order.Traverse(new DirectoryInfo(path)
, i => i.GetDirectories()
, res
, ComputeDirSize
, i => Console.Write(".") // print a simple progress indicator
, (i, exc, j) => // print a simple child exception indicator
{ Console.Write("D"); return(i); }
);
double kBSize = res.Size / 1024;
double mBSize = res.Size / 1024 / 1024;
double gBSize = res.Size / 1024 / 1024 / 1024;
Console.WriteLine();
Console.WriteLine();
Console.WriteLine(" Folders found: {0}", res.Folders);
Console.WriteLine(" Files found: {0}", res.Files);
Console.WriteLine("Directory Size is: {0} Kb, {1} Mb, {2} Gb", kBSize, mBSize, gBSize);
Console.WriteLine();
Console.WriteLine();
Console.WriteLine();
}
public static void SerializeToJson()
{
string[] aCurLevelOrder = AssetDatabase.FindAssets("LevelOrder", new[] { "Assets/ScriptableObjects/Level Data" });
if (aCurLevelOrder.Length <= 0)
{
EditorUtility.DisplayDialog("No Data", "Please Create Levels and Scriptable Objects Before Saving", "Okay");
return;
}
LevelOrder aLevelOrderObject = AssetDatabase.LoadAssetAtPath <LevelOrder>(AssetDatabase.GUIDToAssetPath(aCurLevelOrder[0]));
SaveLevelOrderJSON(aLevelOrderObject);
}
public override void Execute()
{
string nextSceneName = LevelOrder.levelIndex(index);
if (nextSceneName != "")
{
if (setNextLevel)
{
LevelOrder.SetNextLevel();
}
SceneManager.LoadScene(nextSceneName);
}
}
public override void Execute()
{
// Load next scene
string nextSceneName = LevelOrder.NextLevel;
Debug.Log("next scene: " + nextSceneName);
if (nextSceneName != "")
{
LevelOrder.SetNextLevel();
SceneManager.LoadScene(nextSceneName);
}
}
private void ExecuteOrder(LevelOrder order)
{
if (m_DialogueManager == null)
{
m_DialogueManager = GameObject.Find("DialogueManager").GetComponent <DialogManager> ();
}
switch (order.orderType)
{
case (LevelOrderType.SPAWN):
SpawnLevelOrder spawnOrder = (SpawnLevelOrder)order;
for (int i = 0; i < spawnOrder.entities.Count; i++)
{
for (int k = 0; k < spawnOrder.entitiesQuantity [i]; k++)
{
SpawnObject(spawnOrder.entities [i]);
}
}
break;
case (LevelOrderType.MUSIC):
MusicLevelOrder musicLevelOrder = (MusicLevelOrder)order;
SoundManager.instance.PlayMusicFromName(musicLevelOrder.name);
break;
case (LevelOrderType.TALK):
TalkLevelOrder talkLevelOrder = (TalkLevelOrder)order;
m_DialogueManager.TriggerDialogue(talkLevelOrder.tag);
m_DialogueManager.CloseDialogueGuiAfterSeconds(2);
break;
case (LevelOrderType.END_LEVEL):
EventManager.TriggerEvent("EndLevel", new CommandModifier(1, 1, 1));
break;
case (LevelOrderType.WAIT_TRIGGER):
IncreaseWaitingCounter();
break;
case (LevelOrderType.WAIT_DIALOGUE):
IncreaseWaitingCounter();
EventManager.TriggerEvent("WaitDialogue", new CommandModifier(1, 1, 1));
WaitDialogueLevelOrder waitDialogueLevelOrder = (WaitDialogueLevelOrder)order;
m_DialogueManager.TriggerDialogue(waitDialogueLevelOrder.tag);
break;
}
}
void Update()
{
if (isWaiting)
{
return;
}
m_currentTime += Time.deltaTime;
while (m_sequenceId < m_orderSequences.Count)
{
LevelSequence currentSequence = m_orderSequences [m_sequenceId];
if (!started)
{
if (currentSequence.start == LevelSequence.LevelSequenceStart.WHEN_DONE)
{
if (!done)
{
return;
}
m_currentTime = Time.deltaTime;
}
else
{
//m_currentTime -= latestTime;
latestTime = 0;
}
started = true;
}
while (m_orderId < currentSequence.orders.Count)
{
LevelOrder currentOrder = currentSequence.orders [m_orderId];
print(currentOrder.when + " " + m_currentTime);
if (currentOrder.when > m_currentTime)
{
return;
}
latestTime = currentOrder.when;
ExecuteOrder(currentOrder);
m_orderId++;
}
started = false;
m_sequenceId++;
}
}
public static void ParseFile(this LevelGenerator levelGenerator, string file)
{
string[] lines = File.ReadAllLines(file);
List <LevelSequence> sequences = levelGenerator.m_OrderSequences = new List <LevelSequence> ();
LevelSequence currentSequence = new LevelSequence();
foreach (string line in lines)
{
try
{
string[] words = line.Split(' ');
if (words.Length == 0)
{
continue;
}
LevelSequence.ELevelSequenceStart type = LevelSequence.Parse(words[0]);
//New sequence
if (type != LevelSequence.ELevelSequenceStart.ERROR)
{
if (currentSequence.m_Orders.Count > 0 && currentSequence.m_Start != LevelSequence.ELevelSequenceStart.ERROR)
{
sequences.Add(currentSequence);
}
currentSequence = new LevelSequence(type);
continue;
}
//New order
LevelOrder order = MakeLevelOrder(words);
currentSequence.m_Orders.Add(order);
}
catch (Exception e)
{
Debug.LogWarning("Couldn't read line \"" + line + "\" of file \"" + file + "\"");
Debug.LogWarning(e.Message);
}
}
if (currentSequence.m_Orders.Count > 0 && currentSequence.m_Start != LevelSequence.ELevelSequenceStart.ERROR)
{
sequences.Add(currentSequence);
}
}
public void Test1()
{
var problem = new LevelOrder();
var input = new TreeNode(1)
{
left = new TreeNode(2),
right = new TreeNode(3)
{
left = new TreeNode(4)
{
right = new TreeNode(5)
}
}
};
var expectedOutput = new List <List <int> > {
new List <int>()
{
1,
},
new List <int>()
{
2, 3
},
new List <int>()
{
4
},
new List <int>()
{
5
}
};
var output = problem.Solve(input);
for (var i = 0; i < output.Count; i++)
{
CollectionAssert.AreEqual(expectedOutput[i], output[i]);
}
}
void Update()
{
m_CurrentTime += Time.deltaTime;
if (m_SequenceId >= m_OrderSequences.Count)
{
return;
}
LevelSequence currentSequence = m_OrderSequences[m_SequenceId];
float latestTime;
while (m_OrderId < currentSequence.m_Orders.Count)
{
LevelOrder currentOrder = currentSequence.m_Orders[m_OrderId];
if (currentOrder.GetTime() > m_CurrentTime)
{
break;
}
latestTime = currentOrder.GetTime();
currentOrder.ExecuteOrder();
m_OrderId++;
}
}
void CreateReorderableList()
{
if (mAllLevels == null)
{
string[] aCurLevelOrder = AssetDatabase.FindAssets("LevelOrder", new[] { "Assets/ScriptableObjects/Level Data" });
if (aCurLevelOrder.Length >= 1)
{
for (int aI = 1; aI < aCurLevelOrder.Length; aI++)
{
AssetDatabase.DeleteAsset(AssetDatabase.GUIDToAssetPath(aCurLevelOrder[aI]));
}
mAllLevels = AssetDatabase.LoadAssetAtPath <LevelOrder>(AssetDatabase.GUIDToAssetPath(aCurLevelOrder[0]));
}
if (mAllLevels == null)
{
mAllLevels = ScriptableObject.CreateInstance <LevelOrder>();
mAllLevels.Init();
AssetDatabase.CreateAsset(mAllLevels, "Assets/ScriptableObjects/Level Data/LevelOrder.asset");
}
mLevelList = new ReorderableList(mAllLevels.mAllLevels, typeof(Level));
mLevelList.drawHeaderCallback = (Rect aRect) => {
EditorGUI.LabelField(aRect, "Current Levels In Order");
};
mLevelList.drawElementCallback = UpdateLevelList;
mLevelList.onAddCallback = AddNewLevel;
mLevelList.onRemoveCallback = (ReorderableList pList) =>
{
if (EditorUtility.DisplayDialog("Warning!",
"Are you sure you want to delete the level?", "Yes", "No"))
{
AssetDatabase.DeleteAsset(AssetDatabase.GetAssetPath(mActiveLevel));
ReorderableList.defaultBehaviours.DoRemoveButton(pList);
}
};
mLevelList.onSelectCallback = SelectLevel;
}
mEditorMain.Q <IMGUIContainer>("level_list").onGUIHandler = LevelListOnGUI;
}
static void SaveLevelOrderJSON(LevelOrder pOrder)
{
CreateLevelFolder();
CreateResourcesFolder();
SetAssetData();
if (mCurrentAssets[AssetMetaData.AssetType.PrefabAsset].Count <= 0)
{
EditorUtility.DisplayDialog("No Data", "Please Create Levels and Scriptable Objects Before Saving", "Okay");
return;
}
AssetMetaData aCurrentPlayer = null;
foreach (AssetMetaData aPrefab in mCurrentAssets[AssetMetaData.AssetType.PrefabAsset])
{
string aPath = AssetDatabase.GUIDToAssetPath(aPrefab.mGUID);
if (AssetDatabase.GetMainAssetTypeAtPath(aPath) == typeof(Player))
{
aCurrentPlayer = aPrefab;
break;
}
}
if (aCurrentPlayer == null)
{
EditorUtility.DisplayDialog("No Data", "Please Create Levels and Scriptable Objects Before Saving", "Okay");
return;
}
StringBuilder aLevelOrderJSON = new StringBuilder("{\n\"Levels\" : {\n");
int aI = 0;
foreach (Level aLevel in pOrder.mAllLevels)
{
if (aLevel.mStartPosition.mWorldPosition.x < 0 && aLevel.mStartPosition.mWorldPosition.y < 0)
{
continue;
}
if (aLevel.mEndPosition.mWorldPosition.x < 0 && aLevel.mEndPosition.mWorldPosition.y < 0)
{
continue;
}
StringBuilder aResourcesArray = new StringBuilder("\"resources\": [");
StringBuilder aLevelJSON = new StringBuilder("{\"GameObjects\": [");
aLevelJSON.Append(GetStartPositionJson(aLevel.mStartPosition, ref aResourcesArray, aCurrentPlayer));
aLevelJSON.Append(",");
aLevelJSON.Append(GetEndPositionJson(aLevel.mEndPosition, ref aResourcesArray));
aLevelJSON.Append(",");
for (int aJ = 0; aJ < aLevel.mLevelData.Count; aJ++)
{
foreach (GameScriptable aScriptable in aLevel.mLevelData[aJ].mScriptables)
{
aLevelJSON.Append(GetGameScriptableJson(aLevel.mLevelData[aJ].mPosition, aScriptable, ref aResourcesArray));
aLevelJSON.Append(",");
}
}
aLevelJSON.Remove(aLevelJSON.Length - 1, 1);
aLevelJSON.Append("]");
aResourcesArray.Remove(aResourcesArray.Length - 1, 1);
aResourcesArray.Append("]");
aLevelJSON.Append("," + aResourcesArray.ToString());
aLevelJSON.Append("," + "\"Timer\" : " + aLevel.mTime);
aLevelJSON.Append("}");
SaveToFile(aLevelJSON.ToString(), Application.dataPath + "/Assets/Level Data/" + aLevel.mName + ".json");
aLevelOrderJSON.Append("\"" + aI + "\" : \"../Assets/Level Data/" + aLevel.mName + ".json\",");
aI++;
}
aLevelOrderJSON.Remove(aLevelOrderJSON.Length - 1, 1);
aLevelOrderJSON.Append("\n}\n");
string[] aItems = SaveItemPrefabs();
aLevelOrderJSON.Append("," + aItems[0] + "\n");
aLevelOrderJSON.Append("," + aItems[1]);
aLevelOrderJSON.Append("\n}");
SaveToFile(aLevelOrderJSON.ToString(), Application.dataPath + "/Assets/GauntletGame.json");
AssetDatabase.Refresh();
}
public override void Execute()
{
LevelOrder.SetCurrentLevel(index);
}
public override void Execute()
{
LevelOrder.PlayerDeathBackLevel();
}
public ViewLevelOrder GetUid(int UID)
{
LevelOrder lo = _repository.GetUid(UID);
return(ViewLevelOrder.ToViewModel(lo));
}
public ViewLevelOrder GetById(int id)
{
LevelOrder lo = _repository.Get(id);
return(ViewLevelOrder.ToViewModel(lo));
}
