public void Reset(int difficulty) { currentDifficulty = (DifficultyType)difficulty; ResetBoard(currentDifficulty); ResetGameStats(currentDifficulty); gameUI.Init(); }
protected virtual void ChangeCallBack() { GameEntry.Sound.StopSound(s_TopicSoundId); GameEntry.Sound.StopSound(s_PanbaiSoundId); GameEntry.Sound.StopSound(s_PennySaySoundId); GameEntry.Sound.StopSound(TopicTouchBase.s_SoundSerialId); GameEntry.Sound.PlayUISound((int)UISoundId.MagicDis); //GameEntry.Sound.StopAllLoadedSounds(); //GameEntry.Sound.StopAllLoadingSounds(); if (m_DifficultyType == DifficultyType.Easy) { m_DifficultyType = DifficultyType.Trouble; } else if (m_DifficultyType == DifficultyType.Trouble) { m_DifficultyType = DifficultyType.Easy; } ResetData(); m_TopicCale.Small(); InitBackGround(m_DifficultyType); //Enter_BrushTopic(); if (m_Guide != null) { m_Guide.Close(); } }
public bool ComputeStoryArcChance(int weekCount, DifficultyType difficulty = DifficultyType.common) { float difficultyAdjustment = 0; switch (difficulty) { case DifficultyType.troublesome: difficultyAdjustment = currentTroublesomeChance; break; case DifficultyType.threatening: difficultyAdjustment = currentThreateningChance; break; case DifficultyType.common: difficultyAdjustment = 25f; break; } float checkStoryChance = storyChance + (weekCount * storyChance); checkStoryChance += difficultyAdjustment; float rollDice = UnityEngine.Random.Range(0.0f, 100.0f); //Debug.Log("----------|| Dice Roll for Story: " + rollDice + " over 100" + " Chance Rate:" + checkStoryChance); return(rollDice <= checkStoryChance); }
public override void Handle(EzClient client, EzPacket packet) { int songId = client.Room.Info.SelectedSong; DifficultyType difficulty = client.Room.Info.Difficulty; Score myBestScore = Database.SelectBestScore(client.Account.Id, songId, difficulty); List <Score> scores = Database.SelectBestScores(songId, difficulty, 5); scores.Sort((x, y) => y.TotalScore.CompareTo(x.TotalScore)); IBuffer buffer = EzServer.Buffer.Provide(); if (myBestScore != null) { buffer.WriteInt32(myBestScore.TotalScore, Endianness.Big); } else { buffer.WriteInt32(0, Endianness.Big); } buffer.WriteByte(0); foreach (Score score in scores) { buffer.WriteFixedString(score.CharacterName, 17, Utils.KoreanEncoding); buffer.WriteInt32(score.TotalScore, Endianness.Big); buffer.WriteByte(0); } Send(client, 0x27, buffer); }
private static double SpacingWeight(double distance, DifficultyType type) { if (type == DifficultyType.Speed) { { double weight; if (distance > SINGLE_SPACING_TRESHOLD) { weight = 2.5; } else if (distance > STREAM_SPACING_TRESHOLD) { weight = 1.6 + 0.9 * (distance - STREAM_SPACING_TRESHOLD) / (SINGLE_SPACING_TRESHOLD - STREAM_SPACING_TRESHOLD); } else if (distance > ALMOST_DIAMETER) { weight = 1.2 + 0.4 * (distance - ALMOST_DIAMETER) / (STREAM_SPACING_TRESHOLD - ALMOST_DIAMETER); } else if (distance > ALMOST_DIAMETER / 2) { weight = 0.95 + 0.25 * (distance - (ALMOST_DIAMETER / 2)) / (ALMOST_DIAMETER / 2); } else { weight = 0.95; } return(weight); } } return(type == DifficultyType.Aim ? Math.Pow(distance, 0.99) : 0); }
public static void HandleGameStartedEvent(GameType gt, DifficultyType dt) { switch (gt) { case GameType.OnePlayer: gameType = GameType.OnePlayer; break; case GameType.TwoPlayer: gameType = GameType.TwoPlayer; break; } switch (dt) { case DifficultyType.Easy: ballImpulseForce = configurationData.EasyBallImpulseForce; minSpawnDelay = configurationData.EasyMinSpawnDelay; maxSpawnDelay = configurationData.EasyMaxSpawnDelay; break; case DifficultyType.Medium: ballImpulseForce = configurationData.MediumBallImpulseForce; minSpawnDelay = configurationData.MediumMinSpawnDelay; maxSpawnDelay = configurationData.MediumMaxSpawnDelay; break; case DifficultyType.Hard: ballImpulseForce = configurationData.HardBallImpulseForce; minSpawnDelay = configurationData.HardMinSpawnDelay; maxSpawnDelay = configurationData.HardMaxSpawnDelay; break; } }
/// <summary> /// "难度"显示 监听 /// </summary> /// <param name="data"></param> private void DifficultyShowListener(EventData data) { //data.param string DifficultyType diff = (DifficultyType)Enum.Parse(typeof(DifficultyType), data.Param as string); DifficultyShow(diff); }
public string GetBoardJson(DifficultyType difficulty = 0) { string strResult = null; try { string url = APIBaseUrl + "?difficulty=" + DiffToStr(difficulty); WebRequest reqObj = WebRequest.Create(url); reqObj.Method = "GET"; HttpWebResponse resObj = null; resObj = (HttpWebResponse)reqObj.GetResponse(); using (Stream stream = resObj.GetResponseStream()) { StreamReader sr = new StreamReader(stream); strResult = sr.ReadToEnd(); sr.Close(); } } catch { System.Windows.Forms.MessageBox.Show("API calling failed :^("); } return(strResult); }
public string Generate(DifficultyType difficulty) { List <string> strings = new List <string>(); int nextPick; switch (difficulty) { case DifficultyType.EASY: { nextPick = Random.Range(0, Commands.Length); strings.Add(Commands[nextPick]); break; } case DifficultyType.MEDIUM: { nextPick = Random.Range(0, Commands.Length); strings.Add(Commands[nextPick]); nextPick = Random.Range(0, Objects.Length); strings.Add(Objects[nextPick]); break; } case DifficultyType.HARD: nextPick = Random.Range(0, Commands.Length); strings.Add(Commands[nextPick]); nextPick = Random.Range(0, Objects.Length); strings.Add(Objects[nextPick]); nextPick = Random.Range(0, Values.Length); strings.Add(Values[nextPick]); break; } return(string.Join(" ", strings.ToArray())); }
public int[,] GetBoard(DifficultyType difficulty = 0) { int[,] result = new int[9, 9]; string json = GetBoardJson(difficulty); if (json == null) { return(null); } var jsonObj = new JavaScriptSerializer().Deserialize <Dictionary <string, int[][]> >(json); if (jsonObj == null) { return(null); } for (int x = 0; x < 9; x++) { for (int y = 0; y < 9; y++) { result[x, y] = jsonObj["board"][x][y]; } } return(result); }
public void SetScore(int lessonId, DifficultyType difficultyType, int score) { if (m_StudentData != null) { m_CurSubjectScore = m_StudentData.SetScore(lessonId, difficultyType, score); m_TotalScore = m_StudentData.TotalScore(lessonId); } }
public IActionResult Start(DifficultyType gameType) { string fileId = Guid.NewGuid().ToString(); Game game = new Game(fileId); game.Difficulty = gameType; game.CreateApp(); return(Ok(game)); }
public ColorPalette GetDifficultyColor(DifficultyType type) { if (difficultyColors.TryGetValue(type, out ColorPalette value)) { return(value); } Logger.LogWarning($"ColorPreset.GetDifficultyColor - Unknown type: {type}"); return(new ColorPalette(Color.black)); }
public AdventureAction(AdventureType adventureType, DifficultyType difficultyType, int averagePartyLevel) : base(InteractionType.ADVENTURE) { AdventureType = adventureType; ChallengeRating = averagePartyLevel + (int)difficultyType; DifficultyType = difficultyType; AveragePartyLevel = averagePartyLevel; ParamAdd1 = ((int)adventureType * 1000) + ChallengeRating; // not really used, but can be freed later ... ParamAdd2 = ((int)difficultyType * 1000) + averagePartyLevel; }
public void Change(DifficultyType difficulty) { if (difficulty == currDifficulty) { return; } currDifficulty = difficulty; OnDifficultChanged.Invoke(difficulty); }
public static int[,] CreateBoard(DifficultyType difficulty) { BoardData boardData = ConfigManager.Instance.boardConfig.GetBoard(difficulty); int[,] board = InitBoardWithMine( boardData.width, boardData.height, boardData.mine); board = AddClueToBoard(board); return(board); }
private double CalculateDifficulty(DifficultyType Type) { // Find the highest strain value within each strain step List <double> HighestStrains = new List <double>(); double IntervalEndTime = STRAIN_STEP; double MaximumStrain = 0; // We need to keep track of the maximum strain in the current interval tpHitObject PreviousHitObject = null; foreach (tpHitObject hitObject in tpHitObjects) { // While we are beyond the current interval push the currently available maximum to our strain list while (hitObject.BaseHitObject.StartTime > IntervalEndTime) { HighestStrains.Add(MaximumStrain); // The maximum strain of the next interval is not zero by default! We need to take the last hitObject we encountered, take its strain and apply the decay // until the beginning of the next interval. if (PreviousHitObject == null) { MaximumStrain = 0; } else { double Decay = Math.Pow(tpHitObject.DECAY_BASE[(int)Type], (double)(IntervalEndTime - PreviousHitObject.BaseHitObject.StartTime) / 1000); MaximumStrain = PreviousHitObject.Strains[(int)Type] * Decay; } // Go to the next time interval IntervalEndTime += STRAIN_STEP; } // Obtain maximum strain if (hitObject.Strains[(int)Type] > MaximumStrain) { MaximumStrain = hitObject.Strains[(int)Type]; } PreviousHitObject = hitObject; } // Build the weighted sum over the highest strains for each interval double Difficulty = 0; double Weight = 1; HighestStrains.Sort((a, b) => b.CompareTo(a)); // Sort from highest to lowest strain. foreach (double Strain in HighestStrains) { Difficulty += Weight * Strain; Weight *= DECAY_WEIGHT; } return(Difficulty); }
/// <inheritdoc /> public BlockPlayerCreateGameRequestPayload(string gameName, string password, DifficultyType partyDifficulty, bool isBattleModeEnabled, bool isChallengeModeEnabled, EpisodeType partyEpisode, bool isSinglePlayerModeEnabled) { this.unk1 = unk1; GameName = gameName; Password = password; PartyDifficulty = partyDifficulty; this.isBattleModeEnabled = isBattleModeEnabled; this.isChallengeModeEnabled = isChallengeModeEnabled; PartyEpisode = partyEpisode; this.isSinglePlayerModeEnabled = isSinglePlayerModeEnabled; }
public void LoadTxtTest() { DifficultyType type = DifficultyType.Easy; String file = String.Format("{0}{1}/{2}/{3}/{4}.txt", CONTENT_ROOT, Constants.CONTENT_DIRECTORY, Constants.DATA_DIRECTORY, Constants.LEVELS_DIRECTORY, type); var data = FileManager.LoadTxt(file); Console.WriteLine("Number Lines: " + data.Count); }
public void LoadQuestionListTest() { // Arrange. const DifficultyType type = DifficultyType.Easy; // Act. QuestionManager.LoadQuestionList(type); // Assert. Console.WriteLine("Number Questions: " + QuestionManager.QuestionList.Count); }
public ShootingRange(Texture2D texture, Rectangle rectangle, DifficultyType difficulty, Textures textures) : base(texture, rectangle) { this.Score = AccuracyTrainerStateConstants.Score; this.Hits = AccuracyTrainerStateConstants.Hits; this.Stage = AccuracyTrainerStateConstants.Stage; this.stageTimer = AccuracyTrainerStateConstants.Score; this.difficulty = difficulty; this.textures = textures; this.InitializeTargets(); }
protected double CalculateDifficulty(DifficultyType type) { double actualStrainStep = STRAIN_STEP * TimeRate; // Find the highest strain value within each strain step List <double> highestStrains = new List <double>(); double intervalEndTime = actualStrainStep; double maximumStrain = 0; // We need to keep track of the maximum strain in the current interval OsuHitObjectDifficulty previousHitObject = null; foreach (OsuHitObjectDifficulty hitObject in DifficultyHitObjects) { // While we are beyond the current interval push the currently available maximum to our strain list while (hitObject.BaseHitObject.StartTime > intervalEndTime) { highestStrains.Add(maximumStrain); // The maximum strain of the next interval is not zero by default! We need to take the last hitObject we encountered, take its strain and apply the decay // until the beginning of the next interval. if (previousHitObject == null) { maximumStrain = 0; } else { double decay = Math.Pow(OsuHitObjectDifficulty.DECAY_BASE[(int)type], (intervalEndTime - previousHitObject.BaseHitObject.StartTime) / 1000); maximumStrain = previousHitObject.Strains[(int)type] * decay; } // Go to the next time interval intervalEndTime += actualStrainStep; } // Obtain maximum strain maximumStrain = Math.Max(hitObject.Strains[(int)type], maximumStrain); previousHitObject = hitObject; } // Build the weighted sum over the highest strains for each interval double difficulty = 0; double weight = 1; highestStrains.Sort((a, b) => b.CompareTo(a)); // Sort from highest to lowest strain. foreach (double strain in highestStrains) { difficulty += weight * strain; weight *= DECAY_WEIGHT; } return(difficulty); }
public CreateGameOut(string name, string pass, string description, DifficultyType difficulty, ushort gameCounter) { RequestId = (ushort)(gameCounter * 2); Difficulty = (uint)difficulty; Unknown = 0; PlayerDifference = 0xFF; MaximumPlayers = 8; GameName = name; GamePassword = pass; GameDescription = description; }
private void ResetGameStats(DifficultyType difficulty) { BoardData boardData = ConfigManager.Instance.boardConfig.GetBoard(difficulty); timeCount = 0; mineCount = boardData.mine; safeCellCount = boardData.width * boardData.height - boardData.mine; currentState = GameState.Running; UpdateStatsDisplay(); }
public int GetScore(DifficultyType _type) { foreach (Difficulty d in mDifficultyList) { if (d.mDifficulty == _type) { return(d.mHighScore); } } throw new System.ArgumentOutOfRangeException("Invalid Type"); }
public double CalculateDifficulty(DifficultyType Type) { // Find the highest strain value within each strain step List<double> HighestStrains = new List<double>(); double IntervalEndTime = STRAIN_STEP; double MaximumStrain = 0; // We need to keep track of the maximum strain in the current interval tpHitObject PreviousHitObject = null; foreach (tpHitObject hitObject in tpHitObjects) { // While we are beyond the current interval push the currently available maximum to our strain list while(hitObject.BaseHitObject.StartTime > IntervalEndTime) { HighestStrains.Add(MaximumStrain); // The maximum strain of the next interval is not zero by default! We need to take the last hitObject we encountered, take its strain and apply the decay // until the beginning of the next interval. if(PreviousHitObject == null) { MaximumStrain = 0; } else { double Decay = Math.Pow(tpHitObject.DECAY_BASE[(int)Type], (IntervalEndTime - PreviousHitObject.BaseHitObject.StartTime) / 1000); MaximumStrain = PreviousHitObject.Strains[(int)Type] * Decay; } // Go to the next time interval IntervalEndTime += STRAIN_STEP; } // Obtain maximum strain if (hitObject.Strains[(int)Type] > MaximumStrain) { MaximumStrain = hitObject.Strains[(int)Type]; } PreviousHitObject = hitObject; } // Build the weighted sum over the highest strains for each interval double Difficulty = 0; double Weight = 1; HighestStrains.Sort((a,b) => b.CompareTo(a)); // Sort from highest to lowest strain. foreach(double Strain in HighestStrains) { Difficulty += Weight * Strain; Weight *= DECAY_WEIGHT; } return Difficulty; }
private double[] ExamPercentage(DifficultyType type) { switch (type) { case DifficultyType.Kolay: return(new[] { 0.2, 0.3, 0.5 }); case DifficultyType.Orta: return(new[] { 0.2, 0.5, 0.3 }); } return(new[] { 0.5, 0.3, 0.2 }); }
public async Task <Quiz> GetQuizByDifficultyAsync(DifficultyType difficulty) { try { return(await context.Quizzes.FirstOrDefaultAsync(q => q.Difficulty == difficulty)); } catch (Exception ex) { Debug.WriteLine(ex.InnerException.Message); throw null; } }
protected override void OnOpen(object userData) { base.OnOpen(userData); m_DifficultyType = DifficultyType.Easy; m_Controller.SpeekAgainCallBack += SpeekAgainCallBack; m_Controller.ResetCallBack += ResetCallBack; m_Controller.ChangeCallBack += ChangeCallBack; m_Controller.NextCallBack += NextCallBack; GameEntry.Windows.SubscribeUIWallEvent(OnLidarHitEvent); ResetData(); InitBackGround(m_DifficultyType); InitAnswer(); }
public CustomAdventureChoose(MogwaiController mogwaiController, int width, int height) : base("Adventure", "select your adventure", width, height) { _controller = mogwaiController; MogwaiKeys mogwaiKeys = _controller.CurrentMogwaiKeys ?? _controller.TestMogwaiKeys(); _mogwai = mogwaiKeys.Mogwai; _consoleList = new List <MogwaiChooseButton>(); _currentAdventureType = AdventureType.Dungeon; _currentDifficultyType = DifficultyType.Easy; _currentCost = 0; Init(); }
/// <summary> /// 初始化运行时所需的数据 /// </summary> public void InitRuntimeData(bool allInit) { if (allInit) //可选初始化 { //游戏难度初始化 difficulty = DifficultyType.Easy; //玩家人数初始化 playerNumber = 1; } // 玩家id到角色的映射初始化 ResetPlayerIdToCharacterId(playerNumber); //对话计数器初始化 dialogueRank = 0; }
/***********************************************/ public static int GetCurMineNum(DifficultyType diffType) { int mineNum = 0; switch (diffType) { case DifficultyType.Easy: mineNum = ConfigData.MINE_NUM_A; break; case DifficultyType.Normal: mineNum = ConfigData.MINE_NUM_B; break; case DifficultyType.Hard: mineNum = ConfigData.MINE_NUM_C; break; } return mineNum; }
public void RefreshDiff(DifficultyType type) { curDiffType = type; foreach (UI_DifficultyItem item in settingItems) { if(item.diffType == curDiffType) item.Yes(); else item.No(); } int curDiffInt = (int)curDiffType; if (curDiffInt != PersistentData.instance.CurDiff ()) { PersistentData.instance.StoreDiff(curDiffInt); Clock.instance.ClockStop(); Clock.instance.Clear(); UI_DiffAndMineShower.instance.Refresh(); } }
private bool wasContinuePressed; //bools to holds whether continue was pressed #endregion Fields #region Constructors public Gameplay(SpriteFont font, DifficultyType difficultyType, Texture2D[] gameplayTextures, Texture2D[] playerTextures, SoundEffect[] playerSounds, Texture2D[] enemyTextures) { level = new Level(); //initialise level object wins = false; //game not won exit = false; //exit condition not met this.font = font; this.difficultyType = difficultyType; this.gameplayTextures = gameplayTextures; this.playerTextures = playerTextures; this.playerSounds = playerSounds; this.enemyTextures = enemyTextures; }
/// <summary> /// This functions loads the content for the level. /// </summary> /// <param name="fileStream">stream used to load level from text file</param> /// <param name="difficulty">difficulty setting to create level in</param> /// <param name="gameplayTextures">gameplay textures (i.e. background/tiles)</param> /// <param name="playerTextures">player animation textures</param> /// <param name="playerSounds"> player sound effects</param> /// <param name="enemyTextures">enemy animation textures</param> public void LoadContent( Stream fileStream, DifficultyType difficultyType, Texture2D[] gameplayTextures, Texture2D[] playerTextures, SoundEffect[] playerSounds, Texture2D[] enemyTextures) { switch (difficultyType) //difficulty state switch { case DifficultyType.Easy: difficulty = new Easy(); break; case DifficultyType.Medium: difficulty = new Medium(); break; case DifficultyType.Hard: difficulty = new Hard(); break; } this.winScore = difficulty.winScore; this.textureLimit = difficulty.textureLimit; this.difficultyType = difficultyType; timeCount = TimeSpan.FromMinutes(0.0); //set start time of game to zero this.backgroundTexture = gameplayTextures[0]; //load background texture //load the tile textures this.platformTexture = gameplayTextures[1]; this.floorATexture = gameplayTextures[2]; this.floorBTexture = gameplayTextures[3]; this.floorEdgeLTexture = gameplayTextures[4]; this.floorEdgeRTexture = gameplayTextures[5]; LoadTiles(fileStream); //load the tile map player = new Player(playerStart); player.LoadContent(playerTextures, playerSounds); //create new enemy list (i.e. room for multiple enemies) enemies = new List<Enemy>(); enemySpawn = 0; enemyIndex = 0; this.enemyTextures = enemyTextures; walkLeft = false; enemyKilled = playerSounds[2]; LoadEnemy(); //load an initial enemy }
// Caution: The subjective values are strong with this one private static double SpacingWeight(double distance, DifficultyType Type) { switch(Type) { case DifficultyType.Speed: { double Weight; if (distance > SINGLE_SPACING_TRESHOLD) { Weight = 2.5; } else if (distance > STREAM_SPACING_TRESHOLD) { Weight = 1.6 + 0.9 * (distance - STREAM_SPACING_TRESHOLD) / (SINGLE_SPACING_TRESHOLD - STREAM_SPACING_TRESHOLD); } else if (distance > ALMOST_DIAMETER) { Weight = 1.2 + 0.4 * (distance - ALMOST_DIAMETER) / (STREAM_SPACING_TRESHOLD - ALMOST_DIAMETER); } else if (distance > ALMOST_DIAMETER / 2) { Weight = 0.95 + 0.25 * (distance - (ALMOST_DIAMETER / 2)) / (ALMOST_DIAMETER / 2); } else { Weight = 0.95; } return Weight; } case DifficultyType.Aim: return Math.Pow(distance, 0.99); // Should never happen. default: return 0; } }
/// <summary> /// Starts driver /// </summary> /// <param name="game">Game name to join/create</param> /// <param name="pass">Game pass to join/create</param> /// <param name="difficulty">Game difficulty</param> public void Start(string game, string pass, DifficultyType difficulty) { if (!IsInitalized) { throw new Exception("Driver not initalized!"); } // convert game password to Titlecase TextInfo myTI = new CultureInfo("en-US", false).TextInfo; settings.GameName = game; settings.GamePass = myTI.ToTitleCase(pass); settings.GameDifficulty = difficulty; settings.GameDescription = difficulty.ToString(); PushBot(); }
private void CalculateSpecificStrain(tpHitObject PreviousHitObject, DifficultyType Type) { double Addition = 0; double TimeElapsed = BaseHitObject.StartTime - PreviousHitObject.BaseHitObject.StartTime; double Decay = Math.Pow(DECAY_BASE[(int)Type], TimeElapsed / 1000); if (BaseHitObject.GetType() == typeof(SpinnerObject)) { // Do nothing for spinners } else if (BaseHitObject.GetType() == typeof(SliderObject)) { switch(Type) { case DifficultyType.Speed: // For speed strain we treat the whole slider as a single spacing entity, since "Speed" is about how hard it is to click buttons fast. // The spacing weight exists to differentiate between being able to easily alternate or having to single. Addition = SpacingWeight(PreviousHitObject.LazySliderLengthFirst + PreviousHitObject.LazySliderLengthSubsequent * (((SliderObject)BaseHitObject).RepeatCount - 1) + DistanceTo(PreviousHitObject), Type) * SPACING_WEIGHT_SCALING[(int)Type]; break; case DifficultyType.Aim: // For Aim strain we treat each slider segment and the jump after the end of the slider as separate jumps, since movement-wise there is no difference // to multiple jumps. Addition = ( SpacingWeight(PreviousHitObject.LazySliderLengthFirst, Type) + SpacingWeight(PreviousHitObject.LazySliderLengthSubsequent, Type) * (((SliderObject)BaseHitObject).RepeatCount - 1) + SpacingWeight(DistanceTo(PreviousHitObject), Type) ) * SPACING_WEIGHT_SCALING[(int)Type]; break; } } else if (BaseHitObject.GetType() == typeof(CircleObject)) { Addition = SpacingWeight(DistanceTo(PreviousHitObject), Type) * SPACING_WEIGHT_SCALING[(int)Type]; } // Scale addition by the time, that elapsed. Filter out HitObjects that are too close to be played anyway to avoid crazy values by division through close to zero. // You will never find maps that require this amongst ranked maps. Addition /= Math.Max(TimeElapsed, 50); Strains[(int)Type] = PreviousHitObject.Strains[(int)Type] * Decay + Addition; }
public Difficulty(string[] d,DifficultyType p) { descriptions = d; problemType = p.ToString(); }
void Awake() { instance = this; curDiffType = (DifficultyType)(PersistentData.instance.CurDiff()); RefreshDiff (curDiffType); }