public static void Save(string save_name)
{
if (SaveGame.m_State != SaveGame.State.None)
{
Debug.LogWarning("Can't save, state = " + SaveGame.m_State.ToString());
return;
}
if (GreenHellGame.Instance.IsGamescom())
{
return;
}
if (!ReplTools.IsPlayingAlone() && !ReplTools.AmIMaster())
{
SaveGame.SaveCoop();
return;
}
Debug.Log("SAVE - " + save_name);
SaveGame.m_State = SaveGame.State.Save;
HUDSaving.Get().Activate();
SaveGame.SetupObjects();
SaveGame.m_IVals.Clear();
SaveGame.m_SVals.Clear();
SaveGame.m_FVals.Clear();
SaveGame.m_BVals.Clear();
foreach (ISaveLoad saveLoad in SaveGame.m_Objects)
{
saveLoad.Save();
}
BinaryFormatter binaryFormatter = new BinaryFormatter();
MemoryStream memoryStream = new MemoryStream();
binaryFormatter.Serialize(memoryStream, GreenHellGame.s_GameVersion);
binaryFormatter.Serialize(memoryStream, GreenHellGame.Instance.m_GameMode);
long num = DateTime.Now.ToBinary();
binaryFormatter.Serialize(memoryStream, num);
int ivalue = StatsManager.Get().GetStatistic(Enums.Event.DaysSurvived).IValue;
binaryFormatter.Serialize(memoryStream, ivalue);
int activePresetType = (int)DifficultySettings.GetActivePresetType();
binaryFormatter.Serialize(memoryStream, activePresetType);
binaryFormatter.Serialize(memoryStream, MainLevel.Instance.m_Tutorial);
bool flag = Player.Get().IsDead();
binaryFormatter.Serialize(memoryStream, flag);
binaryFormatter.Serialize(memoryStream, ReplicatedSessionState.Get() != null && ReplicatedSessionState.Get().m_PlayedCoop);
Stream serializationStream = memoryStream;
P2PSession instance = P2PSession.Instance;
binaryFormatter.Serialize(serializationStream, ((instance != null) ? instance.GetSessionId() : null) ?? "");
binaryFormatter.Serialize(memoryStream, SaveGame.m_IVals);
binaryFormatter.Serialize(memoryStream, SaveGame.m_SVals);
binaryFormatter.Serialize(memoryStream, SaveGame.m_FVals);
binaryFormatter.Serialize(memoryStream, SaveGame.m_BVals);
DebugUtils.Assert(GreenHellGame.Instance.m_RemoteStorage.FileWrite(save_name, memoryStream.GetBuffer()), "SaveGame - remote storage write failed", true, DebugUtils.AssertType.Info);
memoryStream.Close();
SaveGame.SaveScreenshot(save_name);
SaveGame.m_State = SaveGame.State.None;
}
public int numberOfCars = 0; // How many cars can spawn at once
// Use this for initialization
// ------------------------------------------------------------------------------------------------------ //
// --------------------------------- S T A R T & U P D A T E ------------------------------------------ //
// ------------------------------------------------------------------------------------------------------ //
void Start()
{
carbehaviour = GameObject.FindGameObjectWithTag("Player").GetComponent <CarBehaviour>();
fileManagement = GameObject.FindGameObjectWithTag("fileManager").GetComponent <FileManagement>();
difficultySettings = GameObject.FindGameObjectWithTag("Difficulty").GetComponent <DifficultySettings>();
block = GameObject.FindGameObjectWithTag("block").GetComponent <BlockManager>();
// Start spawning further down so we get an edge at the bottom on start
planeEdgeZ = -1000f; SpawnNewPlane(0);
difficultyLvl = 0;
counter = 1; seconds = 0;
startTimer = false; timer = -3f;
first = true; times = 0;
previousLanes = 0;
// Data File created
fileManagement.createDataFile();
filePath = fileManagement.getFilePath();
spawnCarX = 0; spawnCarY = 0; spawnCarZ = 0;
//PlayerPrefs.DeleteAll();
PlayerPrefs.SetInt("startingNewBlock", 0);
PlayerPrefs.SetInt("numberOfBlocks", PlayerPrefs.GetInt("numberOfBlocks") + 1);
}
private static bool TryTriggerLocalReset()
{
if (!SceneIntermediary.IsFirstScene)
{
return(false);
}
if (Input.GetKeyDown(KeyCode.R))
{
}
else if (Input.GetKeyDown(KeyCode.T))
{
defaultDifficulty = new DifficultySettings(FixedDifficulty.Easy);
}
else if (Input.GetKeyDown(KeyCode.Y))
{
defaultDifficulty = new DifficultySettings(FixedDifficulty.Normal);
}
else if (Input.GetKeyDown(KeyCode.U))
{
defaultDifficulty = new DifficultySettings(FixedDifficulty.Hard);
}
else if (Input.GetKeyDown(KeyCode.I))
{
defaultDifficulty = new DifficultySettings(FixedDifficulty.Lunatic);
}
else
{
return(false);
}
LocalReset();
return(true);
}
public Game(DifficultySettings diffSettings)
{
CMan = new CharacterManager();
this.Difficulty = diffSettings;
this.startTime = DateTime.Now;
this.RespawnSpeed = diffSettings.initRespawnTime;
}
private void Awake()
{
if (instance != null)
{
Destroy(gameObject);
return;
}
instance = this;
int difficultyLevel = DIFFICULTY_LEVEL_NORMAL;
switch (difficultyLevel)
{
case DIFFICULTY_LEVEL_EASY:
speedupTimer = 30.0f;
break;
case DIFFICULTY_LEVEL_NORMAL:
speedupTimer = 15.0f;
break;
case DIFFICULTY_LEVEL_HARD:
speedupTimer = 5.0f;
break;
default:
Debug.LogError("Invalid difficulty level: " + difficultyLevel);
break;
}
tile = tilePrefabs[difficultyLevel];
}
public PlayingGameState()
{
DifficultySettings.SetDifficulty(DifficultyEnum.Easy);
_crosshair = new Crosshair();
_background = new Background();
_fps = new FontRender("fps counter");
_fps.LoadContent("default");
_fps.Location = new Vector2(40, Engine.ScaledViewPort.Y - 50);
_score = new ScoreBoard("score board");
_hud = new Hud("Hud");
_levelController = new LevelController(new LevelBuilder().Levels);
NextLevel();
_scene.AddSpriteToLayer(RenderLayerEnum.LAYER4, _hud);
_scene.AddSpriteToLayer(RenderLayerEnum.LAYER1, _background);
_scene.AddSpriteToLayer(RenderLayerEnum.LAYER4, _fps);
_scene.AddSpriteToLayer(RenderLayerEnum.LAYER4, _score);
_scene.AddSpriteToLayer(RenderLayerEnum.LAYER4, _billboard);
_scene.AddSpriteToLayer(RenderLayerEnum.LAYER5, _crosshair);
Channels.AddNewChannel("score");
Channels.AddNewChannel("duckhit");
Channels.AddNewChannel("gunfired");
_billboard.StartBillBoard("Level " + _levelController.LevelNumber);
}
public static void SetupObjects()
{
SaveGame.m_Objects.Clear();
SaveGame.m_Objects.Add(DifficultySettings.Get());
SaveGame.m_Objects.Add(DialogsManager.Get());
SaveGame.m_Objects.Add(AIManager.Get());
SaveGame.m_Objects.Add(EnemyAISpawnManager.Get());
SaveGame.m_Objects.Add(TriggersManager.Get());
SaveGame.m_Objects.Add(ItemsManager.Get());
SaveGame.m_Objects.Add(SensorManager.Get());
SaveGame.m_Objects.Add(ConstructionGhostManager.Get());
SaveGame.m_Objects.Add(StaticObjectsManager.Get());
SaveGame.m_Objects.Add(Player.Get());
SaveGame.m_Objects.Add(PlayerConditionModule.Get());
SaveGame.m_Objects.Add(PlayerInjuryModule.Get());
SaveGame.m_Objects.Add(PlayerDiseasesModule.Get());
SaveGame.m_Objects.Add(StatsManager.Get());
SaveGame.m_Objects.Add(HintsManager.Get());
SaveGame.m_Objects.Add(ObjectivesManager.Get());
SaveGame.m_Objects.Add(StoryObjectivesManager.Get());
SaveGame.m_Objects.Add(HUDObjectives.Get());
SaveGame.m_Objects.Add(MenuNotepad.Get());
SaveGame.m_Objects.Add(MapTab.Get());
SaveGame.m_Objects.Add(Music.Get());
SaveGame.m_Objects.Add(RainManager.Get());
SaveGame.m_Objects.Add(SleepController.Get());
SaveGame.m_Objects.Add(MainLevel.Instance);
SaveGame.m_Objects.Add(ScenarioManager.Get());
SaveGame.m_Objects.Add(InventoryBackpack.Get());
SaveGame.m_Objects.Add(ReplicatedSessionState.Get());
}
public void CreateEggLayingEvent(Side side, bool initial = false)
{
if (EggLayingEventExists(side))
{
// event exists - abort!
return;
}
DifficultySettings difficulty = Managers.SettingsManager.GetCurrentSettings();
EventIdentifier id = (side == Side.Player) ? EventIdentifier.PlayerEggLaying : EventIdentifier.EnemyEggLaying;
if (side == Side.Player)
{
float delay;
if (initial)
{
delay = difficulty.PlayerInitialEggLayingDelay;
}
else
{
delay = difficulty.PlayerEggLayingDelay;
}
Managers.GameClock.RegisterEvent(delay, CheckIfPlayerEggLayingPossible, id);
}
else
{
float delay = difficulty.EnemyEggLayingDelay;
Managers.GameClock.RegisterEvent(delay, CheckIfEnemyEggLayingPossible, id);
}
}
private void CreateFrogCreationEvent()
{
DifficultySettings difficulty = Managers.SettingsManager.GetCurrentSettings();
float delay = difficulty.FrogRespawnDelay;
Managers.GameClock.RegisterEvent(delay, CreateFrog, EventIdentifier.CreateFrog);
}
// ------------------------------------------------------------------------------------------------------ //
// --------------------------------- S T A R T & U P D A T E ------------------------------------------ //
// ------------------------------------------------------------------------------------------------------ //
void Start()
{
carbehaviour = GameObject.FindGameObjectWithTag("Player").GetComponent <CarBehaviour>();
baseline = GameObject.FindGameObjectWithTag("baseline").GetComponent <Baseline>();
fileManagement = GameObject.FindGameObjectWithTag("fileManager").GetComponent <FileManagement>();
difficultySettings = GameObject.FindGameObjectWithTag("Difficulty").GetComponent <DifficultySettings>();
block = GameObject.FindGameObjectWithTag("block").GetComponent <BlockManager>();
// Start spawning further down so we get an edge at the bottom on start
planeEdgeZ = -1000f; times = 0; previousLanes = 0;
SpawnNewPlane(0);
seconds = 0; timer = -3f;
startTimer = false; first = true; createBaselineNow = true;
spawnCarX = 0; spawnCarY = 0; spawnCarZ = 0;
// When the start the game, the game is easier spawing less cars with longer distances between them
startDistance = 500; numberOfCars = 1; distance = 300; difficultyLvl = 1;
fileManagement.createDataFile();
filePath = fileManagement.getFilePath();
PlayerPrefs.SetInt("startingNewBlock", 0);
PlayerPrefs.SetInt("numberOfBlocks", PlayerPrefs.GetInt("numberOfBlocks") + 1);
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
if (e.Parameter != null)
{
CurrentGame = new BallCatcher(DifficultySettings.createByDifficulty((DifficultySettings.DIFFICULTY)e.Parameter));
}
else
{
CurrentGame = new BallCatcher(DifficultySettings.createByDifficulty(DifficultySettings.DIFFICULTY.EASY));
}
CurrentGame.GameEvent += CurrentGame_GameEvent;
worker.DoWork += Worker_DoWork;
worker.RunWorkerAsync();
timer.Start();
if (ApplicationData.Current.LocalSettings.Values["username"] != null)
{
CurrentGame.CMan.CurrentCharacter.Name = (string)ApplicationData.Current.LocalSettings.Values["username"];
}
initWorker();
base.OnNavigatedTo(e);
}
public static void LoadCoop(string save_name)
{
if (SaveGame.m_State != SaveGame.State.None)
{
Debug.LogWarning("Can't load, state = " + SaveGame.m_State.ToString());
return;
}
if (!GreenHellGame.Instance.FileExistsInRemoteStorage(save_name))
{
return;
}
Debug.Log("FULL_LOAD - " + save_name);
MainLevel.Instance.ResetGameBeforeLoad();
SaveGame.m_State = SaveGame.State.LoadCoop;
SaveGame.SetupObjectsCoop();
SaveGame.m_IVals.Clear();
SaveGame.m_SVals.Clear();
SaveGame.m_FVals.Clear();
SaveGame.m_BVals.Clear();
BinaryFormatter binaryFormatter = new BinaryFormatter();
int fileSize = GreenHellGame.Instance.m_RemoteStorage.GetFileSize(save_name);
byte[] array = new byte[fileSize];
GreenHellGame.Instance.m_RemoteStorage.FileRead(save_name, array, fileSize);
MemoryStream memoryStream = new MemoryStream(array);
GameVersion gameVersion = new GameVersion((GameVersion)binaryFormatter.Deserialize(memoryStream));
SaveGame.m_SaveGameVersion = gameVersion;
GameMode gameMode = (GameMode)binaryFormatter.Deserialize(memoryStream);
long num = (long)binaryFormatter.Deserialize(memoryStream);
int num2 = (int)binaryFormatter.Deserialize(memoryStream);
int num3 = (int)binaryFormatter.Deserialize(memoryStream);
if (gameVersion < GreenHellGame.s_GameVersionEarlyAccessUpdate13 && num3 >= 0 && num3 < 6)
{
DifficultySettings.SetActivePresetType((DifficultySettings.PresetType)num3);
}
if (gameVersion >= GreenHellGame.s_GameVersionEarlyAccessUpdate8)
{
bool flag = (bool)binaryFormatter.Deserialize(memoryStream);
}
if (gameVersion >= GreenHellGame.s_GameVersionEarlyAccessUpdate12 && gameVersion < GreenHellGame.s_GameVersionEarlyAccessUpdate13 && (bool)binaryFormatter.Deserialize(memoryStream))
{
DifficultySettings.SetActivePresetType(DifficultySettings.PresetType.PermaDeath);
}
if (gameVersion >= GreenHellGame.s_GameVersionEarlyAccessUpdate13)
{
bool flag2 = (bool)binaryFormatter.Deserialize(memoryStream);
}
SaveGame.m_IVals = (Dictionary <string, int>)binaryFormatter.Deserialize(memoryStream);
SaveGame.m_SVals = (Dictionary <string, string>)binaryFormatter.Deserialize(memoryStream);
SaveGame.m_FVals = (Dictionary <string, float>)binaryFormatter.Deserialize(memoryStream);
SaveGame.m_BVals = (Dictionary <string, bool>)binaryFormatter.Deserialize(memoryStream);
memoryStream.Close();
foreach (ISaveLoad saveLoad in SaveGame.m_Objects)
{
saveLoad.Load();
}
SaveGame.m_State = SaveGame.State.None;
}
public static void LoadPlayer(string save_name)
{
if (SaveGame.m_State != SaveGame.State.None)
{
Debug.LogWarning("Can't load player, state = " + SaveGame.m_State.ToString());
return;
}
if (!File.Exists(Application.persistentDataPath + "/" + save_name))
{
return;
}
Debug.Log("LOAD_PLAYER - " + save_name);
SaveGame.m_State = SaveGame.State.Load;
SaveGame.SetupObjects();
SaveGame.m_IVals.Clear();
SaveGame.m_SVals.Clear();
SaveGame.m_FVals.Clear();
SaveGame.m_BVals.Clear();
BinaryFormatter binaryFormatter = new BinaryFormatter();
FileStream fileStream = File.Open(Application.persistentDataPath + "/" + save_name, FileMode.Open);
GameVersion lhs = new GameVersion((GameVersion)binaryFormatter.Deserialize(fileStream));
GameMode gameMode = (GameMode)binaryFormatter.Deserialize(fileStream);
long num = (long)binaryFormatter.Deserialize(fileStream);
int num2 = (int)binaryFormatter.Deserialize(fileStream);
int num3 = (int)binaryFormatter.Deserialize(fileStream);
if (lhs >= GreenHellGame.s_GameVersionEarlyAccessUpdate8)
{
bool flag = (bool)binaryFormatter.Deserialize(fileStream);
}
if (lhs >= GreenHellGame.s_GameVersionEarlyAccessUpdate12 && lhs < GreenHellGame.s_GameVersionEarlyAccessUpdate13 && (bool)binaryFormatter.Deserialize(fileStream))
{
DifficultySettings.SetActivePresetType(DifficultySettings.PresetType.PermaDeath);
}
if (lhs >= GreenHellGame.s_GameVersionEarlyAccessUpdate13)
{
bool flag2 = (bool)binaryFormatter.Deserialize(fileStream);
}
if (GreenHellGame.s_GameVersion >= GreenHellGame.s_GameVersionMasterShelters1_3)
{
BinaryFormatter binaryFormatter2 = binaryFormatter;
Stream serializationStream = fileStream;
P2PSession instance = P2PSession.Instance;
binaryFormatter2.Serialize(serializationStream, ((instance != null) ? instance.GetSessionId() : null) ?? "");
}
SaveGame.m_IVals = (Dictionary <string, int>)binaryFormatter.Deserialize(fileStream);
SaveGame.m_SVals = (Dictionary <string, string>)binaryFormatter.Deserialize(fileStream);
SaveGame.m_FVals = (Dictionary <string, float>)binaryFormatter.Deserialize(fileStream);
SaveGame.m_BVals = (Dictionary <string, bool>)binaryFormatter.Deserialize(fileStream);
fileStream.Close();
Player.Get().Load();
PlayerInjuryModule.Get().Load();
PlayerConditionModule.Get().Load();
PlayerDiseasesModule.Get().Load();
ItemsManager.Get().Load();
MainLevel.Instance.Load();
GreenHellGame.Instance.m_LoadGameState = LoadGameState.FullLoadCompleted;
SaveGame.m_State = SaveGame.State.None;
}
public void Start()
{
DifficultySettings difficulty = Managers.SettingsManager.GetCurrentSettings();
this.Speed = difficulty.FrogJumpingSpeed;
this.jumpingDelay = difficulty.FrogJumpingDelay;
CreateFutureJumpEvent();
}
private void SaveDifficulty(DifficultySettings difficulty)
{
BinaryFormatter bf = new BinaryFormatter();
FileStream file = File.Create(Application.persistentDataPath + "/difficulty.txt");
bf.Serialize(file, difficulty);
file.Close();
}
void MineLogic(DifficultySettings d)
{
List <int> numbers;
for (int i = 0; i < d.GetMineCount(); i++)
{
}
}
private void Start()
{
pausePanel.SetActive(false);
difficulty = difficulties[Data.difficulty - 1];
StartGame();
}
// Start is called before the first frame update
void Awake()
{
if (!gameStart)
{
difficultySettings = this;
gameStart = true;
}
}
private void OnStartGame()
{
DifficultySettings.SetActivePresetType(DifficultySettings.PresetType.Hard);
LoadingScreen.Get().Show(LoadingScreenState.StartGame);
GreenHellGame.Instance.m_FromSave = false;
Music.Get().Stop(1f, 0);
GreenHellGame.GetFadeSystem().FadeIn(FadeType.All, null, 2f);
base.Invoke("OnStartGameDelayed", 1f);
MainMenuManager.Get().HideAllScreens();
}
public void OnTutorial()
{
if (!this.m_ButtonsActive)
{
return;
}
GreenHellGame.Instance.m_GameMode = GameMode.Story;
DifficultySettings.SetActivePresetType(DifficultySettings.PresetType.Normal);
MainMenuManager.Get().CallStartGameFadeSequence();
}
public bool TrySetPresetIfValid(DifficultySettings.PresetType preset)
{
if (preset == DifficultySettings.PresetType.Custom || preset == DifficultySettings.PresetType._Count)
{
return(false);
}
if (DifficultySettings.CustomPreset.Equals(DifficultySettings.GetPreset(preset)))
{
DifficultySettings.SetActivePresetType(preset);
return(true);
}
return(false);
}
public Beatmap(string aCode, float?aStarRating = null, string aSongPath = null, string aMapPath = null)
{
code = aCode;
songPath = aSongPath;
mapPath = aMapPath;
string[] lines = aCode.Split(new string[] { "\n" }, StringSplitOptions.None);
generalSettings = ParserStatic.GetSettings(lines, "General", aSectionLines => new GeneralSettings(aSectionLines));
metadataSettings = ParserStatic.GetSettings(lines, "Metadata", aSectionLines => new MetadataSettings(aSectionLines));
difficultySettings = ParserStatic.GetSettings(lines, "Difficulty", aSectionLines => new DifficultySettings(aSectionLines));
colourSettings = ParserStatic.GetSettings(lines, "Colours", aSectionLines => new ColourSettings(aSectionLines));
// event type 3 seems to be "background colour transformation" https://i.imgur.com/Tqlz3s5.png
backgrounds = GetEvents(lines, new List <string>()
{
"Background", "0"
}, anArgs => new Background(anArgs));
videos = GetEvents(lines, new List <string>()
{
"Video", "1"
}, anArgs => new Video(anArgs));
breaks = GetEvents(lines, new List <string>()
{
"Break", "2"
}, anArgs => new Break(anArgs));
sprites = GetEvents(lines, new List <string>()
{
"Sprite", "4"
}, anArgs => new Sprite(anArgs));
storyHitSounds = GetEvents(lines, new List <string>()
{
"Sample", "5"
}, anArgs => new StoryHitSound(anArgs));
animations = GetEvents(lines, new List <string>()
{
"Animation", "6"
}, anArgs => new Animation(anArgs));
timingLines = GetTimingLines(lines);
hitObjects = GetHitobjects(lines);
if (generalSettings.mode == Mode.Standard)
{
// Stacking is standard-only.
ApplyStacking();
starRating = aStarRating ?? (float)StandardDifficultyCalculator.Calculate(this).Item3;
}
}
private void StartGameButton_Click(object sender, RoutedEventArgs e)
{
ListBoxItem selectedItem = (ListBoxItem)diffSelection.SelectedItem;
if (selectedItem == null)
{
nQueue.Enqueue(new Note("Set difficulty", "No difficulty set, please select one"));
}
else
{
string content = (string)selectedItem.Content;
this.Frame.Navigate(typeof(GameView), DifficultySettings.stringToDiff(content));
}
}
private void UseHaltonSequenceMethod(
GameObject player,
MinimapCamera mmCamera,
DifficultySettings ds,
bool isTutorialLevel)
{
Debug.Log($"numast:{ds.numAsteroids}..numGt:{ds.numGasTanks}..numOt:{ds.numOxyTanks}");
// always put a fuel tank at 0,-1
var fuelGO = Instantiate(firstFuelPrefab, new Vector3(-1, 0, 1f), Quaternion.identity);
//fuelGO.GetComponent<Fuel>
curGameObjects.Add(fuelGO);
// and start player at...some sorta start point ... -20? (10 seconds.. at 2 units/second)
if (isTutorialLevel)
{
player.transform.position = new Vector3(ds.playerStartPointX, 0f, 0f);
playerOxygen.Value = ds.initialOxygen;
playerFuel.Value = ds.initialFuel;
//player.transform.position = new Vector3(ds.playerStartPointX - 20f, 0f, 0f);
//playerOxygen.Value = ds.initialOxygen + 15f;
//playerFuel.Value = ds.initialFuel;
}
else
{
player.transform.position = new Vector3(ds.playerStartPointX, 0f, 0f);
playerOxygen.Value = ds.initialOxygen;
playerFuel.Value = ds.initialFuel;
}
// place the planet somewhere just outside
var planetLocation = new Vector3(
ds.asteroidFieldSize + 20f,
Random.Range(ds.asteroidFieldSize * -0.45f, ds.asteroidFieldSize * 0.45f),
1);
var planetGO = Instantiate(planetPrefab, planetLocation, Quaternion.identity);
curGameObjects.Add(planetGO);
//minimap camera
mmCamera.SetupMinimapSizing(ds.asteroidFieldSize);
// then do the halton sequence stuff
GenerateObjectsByHaltonSequence(ds.numAsteroids, ds.numGasTanks, ds.numOxyTanks, ds.asteroidFieldSize);
//then fill in other portions randomly? ehh f**k it
}
public override void restartGame(RestartMessage restartMessage)
{
StopAllCoroutines();
foreach (uint id in spawnedEnemies.Keys)
{
try { Destroy(spawnedEnemies[id].gameObject); }
catch { }
}
spawnedEnemies.Clear();
idCounter = 0;
difficultySettings = GetComponent <DifficultySettings>();
StartCoroutine(SpawnEnemyRoutine());
StartCoroutine(SpawnEnemyGroupRoutine());
}
public static void SetupObjectsCoop()
{
SaveGame.m_Objects.Clear();
SaveGame.m_Objects.Add(ItemsManager.Get());
SaveGame.m_Objects.Add(Player.Get());
SaveGame.m_Objects.Add(PlayerConditionModule.Get());
SaveGame.m_Objects.Add(PlayerInjuryModule.Get());
SaveGame.m_Objects.Add(PlayerDiseasesModule.Get());
SaveGame.m_Objects.Add(StatsManager.Get());
SaveGame.m_Objects.Add(HintsManager.Get());
SaveGame.m_Objects.Add(MenuNotepad.Get());
SaveGame.m_Objects.Add(MapTab.Get());
SaveGame.m_Objects.Add(SleepController.Get());
SaveGame.m_Objects.Add(DifficultySettings.Get());
SaveGame.m_Objects.Add(InventoryBackpack.Get());
}
private void SetUsingPreset(DifficultySettings.PresetType preset_type)
{
DifficultySettingsPreset preset = DifficultySettings.GetPreset(preset_type);
this.GetSelectButton("BaseDifficulty").SetSelectedOptionEnumValue <GameDifficulty>(preset.m_BaseDifficulty);
this.GetSelectButton("NutrientsDepletion").SetSelectedOptionEnumValue <NutrientsDepletion>(preset.m_NutrientsDepletion);
this.GetSelectButton("Insects").SetSelectedOptionBoolValue(preset.m_Insects);
this.GetSelectButton("Leeches").SetSelectedOptionBoolValue(preset.m_Leeches);
this.GetSelectButton("Aquatic").SetSelectedOptionBoolValue(preset.m_Aquatic);
this.GetSelectButton("PermaDeath").SetSelectedOptionBoolValue(preset.m_PermaDeath);
this.GetSelectButton("Predators").SetSelectedOptionBoolValue(preset.m_Predators);
this.GetSelectButton("Sanity").SetSelectedOptionBoolValue(preset.m_Sanity);
this.GetSelectButton("Snakes").SetSelectedOptionBoolValue(preset.m_Snakes);
this.GetSelectButton("Tribes").SetSelectedOptionBoolValue(preset.m_Tribes);
this.GetSelectButton("Energy").SetSelectedOptionBoolValue(preset.m_Energy);
this.GetSelectButton("HPLoss").SetSelectedOptionBoolValue(preset.m_HPLoss);
}
public void Setup()
{
DifficultySettings difficulty = Managers.SettingsManager.GetCurrentSettings();
if (this.Side == Side.Player)
{
this.growingDuration = difficulty.PlayerEggCreationTime;
this.hatchingDuration = 0.0f; // hatches at end of level
StartGrowing();
}
else
{
this.growingDuration = difficulty.EnemyEggCreationTime;
this.hatchingDuration = difficulty.EnemyEggHatchingTime;
StartGrowing();
SetHatchingTime();
}
}
private void LoadDifficulty()
{
try
{
BinaryFormatter bf = new BinaryFormatter();
FileStream file = File.Open(Application.persistentDataPath + "/difficulty.txt", FileMode.Open);
DifficultySettings newDifficulty = (DifficultySettings)bf.Deserialize(file);
file.Close();
diffSet.isEasy = newDifficulty.isEasy;
diffSet.isNormal = newDifficulty.isNormal;
diffSet.isHard = newDifficulty.isHard;
}
catch (System.Exception e)
{
Debug.LogError("Failed To Load Selected Difficulty Setting" + e.Message);
diffSet.isNormal = true;
}
}
private void OnValidate()
{
//Validate animator
if (!m_animator)
{
m_animator = GetComponent <Animator>();
}
//Validate animator parameters
if (!m_animator.parameters.Any(parameter => parameter.name.Equals(m_stateTransitionParameter)))
{
m_stateTransitionParameter = null;
}
if (m_difficultySettings == null)
{
m_difficultySettings = DifficultySettings.Load();
}
}
