public static void LoadLevel(LevelType levelType)
{
AsyncOperation asyncOperation = null;
switch (levelType)
{
case LevelType.MainMenu:
asyncOperation = SceneManager.LoadSceneAsync("MainMenu", LoadSceneMode.Single);
break;
case LevelType.Game:
asyncOperation = SceneManager.LoadSceneAsync("Game", LoadSceneMode.Single);
break;
case LevelType.GameOver:
asyncOperation = SceneManager.LoadSceneAsync("GameOver", LoadSceneMode.Single);
break;
case LevelType.Options:
asyncOperation = SceneManager.LoadSceneAsync("Options", LoadSceneMode.Single);
break;
case LevelType.Leaderboard:
asyncOperation = SceneManager.LoadSceneAsync("Leaderboard", LoadSceneMode.Single);
break;
}
if (asyncOperation != null)
{
GameController.AddAction(new LoadLevelEvent(asyncOperation));
}
else
{
Debug.LogError("Scene of type " + levelType + " missed!");
}
}
public Info(string nameinter, int scoreinter, LevelType level, string dateinter)
{
Name = nameinter;
Score = scoreinter;
Level = level;
Date = dateinter;
}
public Map(int sizeX, int sizeY, int sizeZ, LevelType lvlType, int seed, float heightoffset)
{
_voxels = new byte[sizeX*sizeY*sizeZ];
_numVoxelsOfType = new int[TypeInformation.GetNumTypes()];
_numVoxelsOfType[0] = sizeX * sizeY * sizeZ;
_sizeX = sizeX;
_sizeY = sizeY;
_sizeZ = sizeZ;
// Create the ground
Random rand = new Random(seed);
switch (lvlType)
{
case LevelType.PLAIN:
GeneratePlainLevel(ref rand, heightoffset);
break;
case LevelType.BUBBLE:
GenerateBubbleLevel(ref rand, heightoffset);
break;
case LevelType.MOUNTAINS:
GenerateMountainsLevel(ref rand, heightoffset);
break;
case LevelType.CANYON:
GenerateCanoynsLevel(ref rand, heightoffset);
break;
}
}
/// <summary>
/// To create a new module
/// </summary>
/// <param name="student"></param>
/// <param name="level"></param>
/// <param name="mainform"></param>
public ModuleForm(Student student, LevelType level, MainForm mainform)
{
InitializeComponent();
this.student = student;
this.level = level;
this.mainform = mainform;
}
public void SetLevelType(LevelType type)
{
if(_currentLevelType != type)
{
_currentLevelType = type;
Sounds.PlayLevelBackground(type);
}
}
public Crew(CrewBackground background, CrewPreference preference, CrewSkill skills, TierType tier, LevelType level)
: base (ItemType.Crew, tier, level)
{
if (background == CrewBackground.Undefined) throw new ArgumentException("The crew background is undefined.", nameof(background));
if (preference == CrewPreference.Undefined) throw new ArgumentException("The crew preference is undefined.", nameof(preference));
Background = background;
Preference = preference;
Skills = skills;
}
public int subLevel = 0; //there are 11 sublevels, they represent the progress through game, only modified after video clips end
public void MarkAsComplete(LevelType level) {
print ("mark as complete");
switch (level) {
case LevelType.AutoSymbolism : isAutoSymbolismComplete = true; break;
case LevelType.Chat : isChatComplete = true; break;
case LevelType.Maze : isMazeComplete = true; break;
case LevelType.Flashback : isFlashbackComplete = true; break;
}
}
public Automaton(int sizeX, int sizeY, int sizeZ, LevelType lvlType, int seed, float heightoffset)
{
_map = new Map(sizeX, sizeY, sizeZ, lvlType, seed, heightoffset);
_livingVoxels = new Dictionary<Int32,LivingVoxel>();
_simTask = null;
_deleteList = new List<Voxel>();
_insertionList = new List<Voxel>();
}
public DungeonTreasureChest( LevelType level )
: base(CalculateType( level ))
{
Movable = false;
Locked = true;
Level = level;
}
protected Lesson(int id, string title, string soundPath, string hint, LevelType typeOfLevel, List<Iteration> iterations)
{
this.Id = id;
this.Title = title;
this.SoundPath = soundPath;
this.Hint = hint;
this.TypeOfLevel = typeOfLevel;
this.Iterations = iterations;
}
public LoadScreen(LevelType levelType, PlayerSetup[] playerTypes)
: base("LoadScreen")
{
backgroundThread = new Thread(BackgroundWorkerThread);
backgroundThreadExit = new ManualResetEvent(false);
graphicsDevice = ScreenManager.Game.GraphicsDevice;
this.playerTypes = playerTypes;
this.levelType = levelType;
}
public Gear(GearType gearType, JobType job, GearState state, GearElementary elementary, TierType tier, LevelType level)
: base (ItemType.Gear, tier, level)
{
if (gearType == GearType.Undefined) throw new ArgumentException("The gear type is undefined.", nameof(gearType));
if (job == JobType.Undefined) throw new ArgumentException("The job is undefined.", nameof(job));
if (state == GearState.Undefined) throw new ArgumentException("The gear state is undefined.", nameof(state));
Elementary = elementary;
State = state;
GearType = gearType;
Job = job;
}
//----------------------------------------------------------------------
//
//----------------------------------------------------------------------
public static double CalculateLevelForMobile( Mobile m, LevelType levelType )
{
double stats = (m.Str + m.Dex + m.Int) / 3;
double skills = CalculateWeightedSkillsForClass( m, levelType );
double ratio = (stats + skills) / 245.0;
double normal = ratio - 1 < 0.1 ? 0.1 : ratio - 1;
double calcLevel = normal * 4.0;
return calcLevel;
}
/// <summary>
/// Populate <see cref="HierarchyType"/> from <paramref name="buildFrom"/>.
/// </summary>
/// <param name="hierarchyType">
/// The hierarchy type.
/// </param>
/// <param name="buildFrom">
/// The build from.
/// </param>
public void BuildList(HierarchyType hierarchyType, ILevelObject buildFrom)
{
int order = 1;
do
{
var builtObj = new LevelType();
hierarchyType.Level.Add(builtObj);
string value = buildFrom.Id;
if (!string.IsNullOrWhiteSpace(value))
{
builtObj.id = buildFrom.Id;
}
if (ObjectUtil.ValidString(buildFrom.Urn))
{
builtObj.urn = buildFrom.Urn;
}
IList<ITextTypeWrapper> names = buildFrom.Names;
if (ObjectUtil.ValidCollection(names))
{
builtObj.Name = this.GetTextType(names);
}
IList<ITextTypeWrapper> descriptions = buildFrom.Descriptions;
if (ObjectUtil.ValidCollection(descriptions))
{
builtObj.Description = this.GetTextType(descriptions);
}
if (this.HasAnnotations(buildFrom))
{
builtObj.Annotations = this.GetAnnotationsType(buildFrom);
}
builtObj.Order = order;
if (buildFrom.CodingFormat != null)
{
var textFormatType = new TextFormatType();
this.PopulateTextFormatType(textFormatType, buildFrom.CodingFormat);
builtObj.CodingType = textFormatType;
}
buildFrom = buildFrom.ChildLevel;
order++;
}
while (buildFrom != null);
}
public static List<Stage> GetStages(LevelType level)
{
switch (level)
{
case LevelType.Tutorial:
//Tutorial
return GetTutorialStages();
case LevelType.Level1:
//Level One
return GetLevelOneStages();
case LevelType.Level2:
//Level One
return GetLevelTwoStages();
default:
return null;
}
}
void Awake()
{
SetTerrainData();
if (GetComponent<SpriteRenderer>().color == new Color(125 / 255.0F, 252 / 255.0F, 0 / 255.0F))
{
type = LevelType.grass;
}
else if (GetComponent<SpriteRenderer>().sprite == LoadResources.blue)
{
type = LevelType.water;
}
else// if (GetComponent<SpriteRenderer>().sprite == LoadResources.road)
{
type = LevelType.road;
}
//LoadResource();
}
public static List<string> GenerateLevel(int width, int height, LevelType type) {
Width = width;
Height = height;
Type = type;
_perlinArray = new double[Height, Width];
_intPerlinArray = new int[Height, Width];
// Calculate min and max noise
var noise = new PerlinNoise2D();
for (var i = 0; i < Height; i++) {
for (var j = 0; j < Width; j++) {
_perlinArray[i, j] = noise.PerlinNoise(i, j);
if (_perlinArray[i, j] > _maxNoise)
_maxNoise = _perlinArray[i, j];
else if (_perlinArray[i, j] < _minNoise)
_minNoise = _perlinArray[i, j];
}
}
// Generate perlin Noise
var maxToMin = _maxNoise/_minNoise;
for (var i = 0; i < Height; i++) {
for (var j = 0; j < Width; j++) {
_intPerlinArray[i, j] = (int) ((_perlinArray[i, j] - _minNoise)*maxToMin);
}
}
_level = NoiseToLevel();
#if DEBUG
// Print integer Perlin array and level for debugging
Console.WriteLine();
for (var i = 0; i < Height; i++) {
for (var j = 0; j < Width; j++) {
Console.Write(_intPerlinArray[i, j].ToString());
}
Console.WriteLine();
}
Console.WriteLine();
Output();
#endif
return _level;
}
public static string GetParTimes(string text, LevelType levelType)
{
string pattern = "{0}(?:.|\\s)+?par\\s*=\\s*(.+);";
string levelTypeName;
switch (levelType)
{
default:
case LevelType.Light:
levelTypeName = "normlevel";
break;
case LevelType.Dark:
levelTypeName = "altlevel";
break;
}
string[] result = Regex.Matches(text, string.Format(pattern, levelTypeName)).OfType<Match>().
Where(x => x.Success).Select(x => x.Groups[1].Value).Select(x => float.Parse(x).ToString("0.00") + "f").ToArray();
return string.Join(", ", result);
}
/// <summary>
/// Load modules
/// </summary>
/// <param name="level"></param>
public void LoadModules(LevelType level)
{
if (level == LevelType.Level4)
{
AddToDataGrid(dataGridView1, student.Levels[0].Modules);
double avg = calculateAvg(0);
label2.Text = "Average: " + avg;
}
else if (level == LevelType.Level5)
{
AddToDataGrid(dataGridView2, student.Levels[1].Modules);
double avg = calculateAvg(1);
label3.Text = "Average: " + avg;
}
else if (level == LevelType.Level6)
{
AddToDataGrid(dataGridView3, student.Levels[2].Modules);
double avg = calculateAvg(2);
label4.Text = "Average: " + avg;
}
}
public static string GetLevelNames(string text, LevelType levelType)
{
string pattern = "{0}(?:.|\\s)+?name\\s*=\\s*\"(.+)\";";
string levelTypeName;
switch (levelType)
{
default:
case LevelType.Light:
levelTypeName = "normlevel";
break;
case LevelType.Dark:
levelTypeName = "altlevel";
break;
}
string[] result = Regex.Matches(text, string.Format(pattern, levelTypeName)).OfType<Match>().
Where(x => x.Success).Select(x => '"' + x.Groups[1].Value + '"').ToArray();
return string.Join(", ", result);
}
public void LoadLevelFromFile(string filePath, LevelType levelType)
{
if (this.listLevelIndex != null)
{
listLevelIndex.Clear();
}
TextAsset textAsset = Resources.Load<TextAsset>(filePath);
if(textAsset != null)
{
string[] temp = textAsset.text.Split(new char[] { '\n' }, System.StringSplitOptions.RemoveEmptyEntries);
for(int i = 1; i < temp.Length; i++)//bo dong dau tien
{
string[] context = temp[i].Split(new char[] { ';' }, System.StringSplitOptions.RemoveEmptyEntries);
LevelIndex levelIndex = new LevelIndex(context, levelType);
listLevelIndex.Add(levelIndex);
switch(levelType)
{
case LevelType.NONE:
break;
case LevelType.PLAYER:
listPlayer.Add(levelIndex);
break;
case LevelType.ENEMY:
listEnemy.Add(levelIndex);
break;
case LevelType.GUN:
listGun.Add(levelIndex);
break;
}
}
}
else
{
Debug.Log("chua load dc file");
}
}
/// <summary>
/// Edit existing details of a module
/// </summary>
/// <param name="module"></param>
/// <param name="level"></param>
/// <param name="mainform"></param>
public ModuleForm(Module module, LevelType level, MainForm mainform)
{
InitializeComponent();
this.module = module;
this.level = level;
this.mainform = mainform;
//Set the values of the existing module
textBoxMCode.Text = module.Code;
textBoxMName.Text = module.Name;
comboBoxCredit.SelectedValue = module.Credits;
//Add assessment details
foreach (Assessment asm in module.Assessments)
{
int index = dataGridView1.Rows.Add(1);
dataGridView1.Rows[index].Cells[0].Value = asm.Type;
dataGridView1.Rows[index].Cells[1].Value = asm.Weight;
}
//Flag variable to update or add a new module
updateModule = true;
}
private string GetLeaderboardName(SMBChapter chapter, int level, LevelType type)
{
int id = 100 + ((chapter.Number - 1) * 50) + (level - 1);
if (type == LevelType.Dark) id += chapter.MaxLevelCount;
return "SMB_LEADERBOARD_" + id;
}
/// <summary>
/// Checks equality for level with additional checking of finalization as RightOperandEmpty in levels chain.
/// </summary>
/// <param name="level">Selected level.</param>
/// <param name="type">Level should be with type.</param>
/// <param name="data">Level should be with data.</param>
/// <returns>true value if selected level is equal to selected type and data, otherwise false.</returns>
/// <exception cref="NotSupportedOperationException">If found level is equal to selected type and data but is not latest or is not RightOperandEmpty in levels chain.</exception>
public bool FinalEmptyIs(int level, LevelType type, string data = null)
{
bool ret = Is(level, type, data);
if(!ret) {
return false;
}
if(Levels[level].Type == LevelType.RightOperandEmpty) {
return true; // if current is also the last
}
// check next level
if(Levels[level + 1].Type == LevelType.RightOperandEmpty) {
return true; // 'as is' if next level is final and is RightOperandEmpty.
}
// the next level is not latest or RightOperandEmpty
throw new NotSupportedOperationException("PM - FinalEmptyIs: the level '{0}'({1}) is not final.", Levels[level].Data, Levels[level].Type);
}
/// <summary>
/// Checks equality for level.
/// </summary>
/// <param name="level">Selected level.</param>
/// <param name="type">Level should be with type.</param>
/// <param name="data">Level should be with data.</param>
/// <returns>true value if selected level is equal to selected type and data, otherwise false.</returns>
public bool Is(int level, LevelType type, string data = null)
{
if(level < 0 || level >= Levels.Count) {
return false;
}
ILevel lvl = Levels[level];
return (lvl.Type == type && lvl.Data == data);
}
static PolicyLevel GetLevel( LevelType type )
{
m_danglingLevelIndicator = null;
if (m_levelType == LevelType.None)
{
if (type == LevelType.None)
{
m_levelAssemblyList = m_userAssemblies;
return GetLevel( "User" );
}
else if (type == LevelType.All)
{
return null;
}
else
{
Error( null, "Unknown level type", -1 );
/* not reached */
return null;
}
}
else if (m_levelType == LevelType.Machine)
{
m_levelAssemblyList = m_machineAssemblies;
return GetLevel( "Machine" );
}
else if (m_levelType == LevelType.UserDefault)
{
m_levelAssemblyList = m_userAssemblies;
return GetLevel( "User" );
}
else if (m_levelType == LevelType.UserCustom)
{
if (m_currentCustomLevel == null)
{
m_levelAssemblyList = m_customUserAssemblies;
try
{
m_currentCustomLevel = SecurityManager.LoadPolicyLevelFromFile( m_levelPath, PolicyLevelType.User );
}
catch (Exception e)
{
Error( null, e.Message, -1 );
}
}
return m_currentCustomLevel;
}
else if (m_levelType == LevelType.All)
{
return null;
}
else if (m_levelType == LevelType.Enterprise)
{
m_levelAssemblyList = m_enterpriseAssemblies;
return GetLevel( "Enterprise" );
}
else if (m_levelType == LevelType.AllCustom)
{
if (m_currentCustomLevel == null)
{
try
{
m_currentCustomLevel = SecurityManager.LoadPolicyLevelFromFile( m_levelPath, PolicyLevelType.User );
}
catch (Exception e)
{
Error( null, e.Message, -1 );
}
}
return null;
}
else
{
// This should never occur.
Error( null, "Unknown level type", -1 );
/* not reached */
return null;
}
}
static void CustomAllHandler( String[] args, int index, out int numArgsUsed )
{
numArgsUsed = 1;
if (args[index].Equals( "__internal_usage__" ))
{
PauseCapableWriteLine( manager.GetString( "Help_Option_CustomAll" ) );
return;
}
numArgsUsed = 2;
if (args.Length - index < 2)
{
Error( manager.GetString( "OptionTable_CustomAll" ), manager.GetString( "Error_NotEnoughArgs" ), -1 );
}
m_danglingLevelIndicator = manager.GetString( "OptionTable_CustomAll" );
m_levelPath = args[index+1];
m_levelType = LevelType.AllCustom;
m_currentCustomLevel = null;
}
static void AllHandler( String[] args, int index, out int numArgsUsed )
{
numArgsUsed = 1;
if (args[index].Equals( "__internal_usage__" ))
{
PauseCapableWriteLine( manager.GetString( "Help_Option_All" ) );
return;
}
m_danglingLevelIndicator = manager.GetString( "OptionTable_All" );
m_levelPath = null;
m_levelType = LevelType.All;
}
public HearTheLetter(int id, string title, bool isRecurringTask, string soundPath, string hint, LevelType typeOfLevel, List<Iteration> iterations)
: base(id, title, isRecurringTask, soundPath, hint, typeOfLevel, iterations)
{
}
/// <summary>
/// populate stage list with
/// stages based on level
/// </summary>
public static void InitLevelStages(LevelType level)
{
levelType = level;
stageList = StageFactory.GetStages(level);
LevelCompleted = false;
}
