public ChunkTable(GameSave gameSave, Tuple<int, int, Chunk>[] chunks) : this(gameSave, chunks.Select(x => x.Item1).ToArray(), chunks.Select(x => x.Item2).ToArray(), chunks.Select(x => x.Item3).ToArray()) { }
public static void TestAddChunkToUnloadedChunks(GameSave gameSave, Header header) { ChunkTable oldChunkTable = header.SaveIndex.ChunkTable; var octree = new Octree(gameSave, new BitArray(new[] { false, false }), new byte[] { 1 }); var blockTypeTable = new BlockTypeTable(gameSave, new[] { new StringBlock(gameSave, "Block 0"), new StringBlock(gameSave, "Block 1"), new StringBlock(gameSave, "Block 2"), new StringBlock(gameSave, "Block 2") }, new[] { 0, 0, 0, 1 }); var chunk = new Chunk(gameSave, blockTypeTable, new[] { octree }); var r = new Random(); int x = r.Next(); int z = r.Next(); List<Tuple<int, int, Chunk>> chunks = oldChunkTable.GetChunks().Where(c => c.Item1 != x || c.Item2 != z).ToList(); chunks.Add(new Tuple<int, int, Chunk>(x, z, chunk)); var chunkTable = new ChunkTable(gameSave, chunks.ToArray()); var mainIndex = new SavedStateIndex(gameSave, DateTime.UtcNow.Ticks, new StringBlock(gameSave, "ChunkTable Length: " + chunkTable.Length), chunkTable); var newHeader = new Header(gameSave, mainIndex); newHeader.Write(true); }
public Header(GameSave gameSave, SavedStateIndex saveIndex) : base(gameSave) { Address = new Tuple<int, uint>(0, 0); SaveIndex = saveIndex; UpdateLength(); }
public GameSettings() { _gameMode = GameMode.Adventure; _numberOfPlayers = NumberOfPlayersSelected.OnePlayer; _levelSelected = LevelSelection.Tropical; _adventureMode = AdventureMode.Continue; _gameSave = GameSave.SaveFile1; }
public static void DeleteSaves() { if (File.Exists(Application.persistentDataPath + "/savedGame.Tendresse")) { File.Delete(Application.persistentDataPath + "/savedGame.Tendresse"); } savedGame = new GameSave(); GameSave.current = savedGame; }
public Chunk(GameSave gameSave, BlockTypeTable blockTypeTable, Octree[] octrees) : base(gameSave) { _blockTypeTable = blockTypeTable; _octrees = octrees; UpdateLength(); }
public Octree(GameSave gameSave, BitArray octreeFlags, byte[] octreeValues) : base(gameSave) { _octreeFlags = octreeFlags; _octreeValues = octreeValues; UpdateLength(); }
public SavedStateIndex(GameSave gameSave, long timestamp, StringBlock saveName, ChunkTable chunkTable) : base(gameSave) { _timestamp = timestamp; _saveName = saveName; _chunkTable = chunkTable; UpdateLength(); }
internal static ByteArray FromSave(GameSave gameSave, Tuple<int, uint> address) { ByteArray byteArray; if (!gameSave.TryGetFromBlockStructureCache(address, out byteArray)) { byteArray = new ByteArray(gameSave, address); gameSave.AddToBlockStructureCache(address, byteArray); } return byteArray; }
// Use this for initialization void Awake () { if(control == null) { DontDestroyOnLoad (gameObject); control = this; } else if (control != this) { Destroy(gameObject); } Load (); }
public ChunkTable(GameSave gameSave, int[] xLocations, int[] zLocations, Chunk[] chunks) : base(gameSave) { if (xLocations.Length != zLocations.Length || zLocations.Length != chunks.Length) { throw new ArgumentException("Argument arrays must have the same length!"); } _xLocations = xLocations; _zLocations = zLocations; _chunks = chunks; UpdateLength(); }
void Awake() { control = this; created = PlayerPrefs.GetInt("GameCreated"); if (created !=1) { StatCreation(); } LoadStats(); InGameStats(); }
public static void TestMarkModify(GameSave gameSave, Header header) { var newChunkTable = new ChunkTable(gameSave, header.SaveIndex.ChunkTable.GetChunks().Concat( header.SaveIndex.ChunkTable.GetChunks().Take(1).Select( x => new Tuple<int, int, Chunk>(x.Item1 + 1, x.Item2 - 1, x.Item3))).ToArray()); var newHeader = new Header(gameSave, new SavedStateIndex(gameSave, DateTime.UtcNow.Ticks, new StringBlock(gameSave, "Modified Save"), newChunkTable)); newHeader.Write(true); }
public static void Load() { //Debug.Log("Loading at Destination : " + Application.persistentDataPath); //Debug Save Path if (File.Exists(Application.persistentDataPath + "/savedGame.Tendresse")) { Debug.Log("File exists!"); BinaryFormatter bf = new BinaryFormatter(); FileStream file = File.Open(Application.persistentDataPath + "/savedGame.Tendresse", FileMode.Open); SaveAndLoad.savedGame = (GameSave)bf.Deserialize(file); GameSave.current = SaveAndLoad.savedGame; file.Close(); } else { Debug.Log("File does not exists!"); savedGame = new GameSave(); GameSave.current = savedGame; } }
private Chunk(GameSave gameSave, Tuple<int, uint> address) : base(gameSave, address) { }
public void UpdatePersistentData(GameSave newSave) { levelsData = newSave.levels; statsData = newSave.stats; }
private void InputManager_Update(On.InputManager.orig_Update orig, InputManager self) { // Do the recording, pausing, resetting, and playing here. // Updates the state UpdateState(); // Performs an action depending on the state if (SingletonManager.Get <Dungeon>(false) == null) { // We don't have a Dungeon to work with yet! // This should be removed soon and instead of having levels, have time stamps or something else. // That would allow for TAS in menus (without a Dungeon) orig(self); return; } int level = SingletonManager.Get <Dungeon>(false).Level; if (HasFlag(State.Pausing)) { // Need to find some way of doing standard processing except for actually updating the game } if (HasFlag(State.Playing) && !HasFlag(State.Pausing)) { // Read Inputs from file/RAM and perform them if (TASInput.HasNext(level)) { TASInputPlayer.Update(TASInput.GetNext(level)); mod.Log("Playing input: " + TASInputPlayer.Current); } else { mod.Log("Completed input playback!"); ToggleState(State.Playing); } } if (HasFlag(State.Recording)) { // Read Inputs from real action into file/RAM // Assumes the current level exists. TASInput.CreateAndAdd(level); // Also make sure that the seed is correctly set mod.Log("Recording input: " + TASInput.inputs[level][TASInput.inputs[level].Count - 1].ToString()); // TODO: REMOVE LINE BELOW ToggleState(State.Recording); } if (HasFlag(State.Saving)) { // Save the current floor as a start point (somehow) // Probably just save the SeedData and do a "generateForLevel" or something SaveKey = GameSave.GenerateSaveKey(); SingletonManager.Get <Dungeon>(false).SaveGameData(SaveKey); mod.Log("Saved Key: " + SaveKey + " saved successfully!"); ToggleState(State.Saving); } if (HasFlag(State.SavingToFile)) { // Assume the Dungeon exists, use it to determine the level to write the TAS for. mod.Log("Writing files with *" + tasFileExtensionWrapper.Value); TASIO.WriteTAS(TASInput.inputs, tasFileExtensionWrapper.Value); ToggleState(State.SavingToFile); } if (HasFlag(State.ReadingFromFiles)) { // Don't assume that the Dungeon exists, but read the many information things from the TAS file. // The trick with this is that the seed also needs to be read. TASInput.Clear(); mod.Log("Reading from *" + tasFileExtensionWrapper.Value + " files..."); foreach (string file in System.IO.Directory.GetFiles(".", "*" + tasFileExtensionWrapper.Value)) { // Let's just load all of the info into the TASInput RAM mod.Log("Reading file: " + file); TASIO.ReadTAS(file); } ToggleState(State.ReadingFromFiles); } if (HasFlag(State.Resetting)) { // Reset to the current save point (whatever floor it is) // Probably just do a "generateForLevel" or something (make the game think the data was saved in a certain way) mod.Log("Attempting to load SaveKey: " + SaveKey); if (SaveKey.Length > 0) { // Only now can we load valid data. mod.Log("Preparing Dungeon for SaveKey!"); Dungeon.PrepareForSavedGame(SaveKey, false); } ToggleState(State.Resetting); } if (HasFlag(State.Clearing)) { // Clear the data for this level TASInput.ClearForLevel(level); mod.Log("Cleared all TAS data for level: " + level); ToggleState(State.Clearing); } orig(self); }
public LocalGameSave(GameSave gameSave, string filePath) { GameSave = gameSave; LocalFilePath = filePath; }
public bool IsOtherHasBetterProgress(GameSave other) { return(completedQuests.Count < other.completedQuests.Count); }
private void Save(IAsyncResult result) { _storageDevice = StorageDevice.EndShowSelector(result); if (_storageDevice != null && _storageDevice.IsConnected) { var filename = String.Format("save{0:00}.dat", _slot); var player = PlayerManager.Instance; GameSave save = new GameSave() { Ammo = player.Ammo, Lives = player.Lives, Hearts = player.Hearts, Coins = player.Coins, StagesCompleted = player.StagesCompleted }; IAsyncResult r = _storageDevice.BeginOpenContainer(_storageContainerName, null, null); result.AsyncWaitHandle.WaitOne(); Thread.Sleep(1500); StorageContainer container = _storageDevice.EndOpenContainer(r); if (container.FileExists(filename)) container.DeleteFile(filename); Stream stream = container.CreateFile(filename); IFormatter formatter = new BinaryFormatter(); formatter.Serialize(stream, save); stream.Close(); container.Dispose(); result.AsyncWaitHandle.Close(); if (_saveCallback != null) _saveCallback(); } }
/// <summary> /// <para>Initializes a new UniqueBlockStructure instance.</para> /// <para>This constructor is for blocks that are newly created.</para> /// </summary> /// <param name="gameSave">The GameSave instance this block is attached to.</param> protected UniqueBlockStructure(GameSave gameSave) : base(gameSave) { }
public void CmdLoadBackup() { GameSave.LoadBackup(); }
public void CmdResetConnections() { GameSave.ResetConnections(); RpcResetConnections(); Debug.Log("All connections reset."); }
public void RpcResetConnections() { //TODO: Does this help? GameSave.ResetConnections(); }
public QuestItem(GameSave gameSave, QuestItemDefinition definition, int offset) => (_gameSave, _definition, Offset) = (gameSave, definition, offset);
void InterpretServerOrder(Connection conn, Order o) { // Only accept handshake responses from unvalidated clients // Anything else may be an attempt to exploit the server if (!conn.Validated) { if (o.OrderString == "HandshakeResponse") { ValidateClient(conn, o.TargetString); } else { Log.Write("server", "Rejected connection from {0}; Order `{1}` is not a `HandshakeResponse`.", conn.Socket.RemoteEndPoint, o.OrderString); DropClient(conn); } return; } switch (o.OrderString) { case "Command": { var handledBy = serverTraits.WithInterface <IInterpretCommand>() .FirstOrDefault(t => t.InterpretCommand(this, conn, GetClient(conn), o.TargetString)); if (handledBy == null) { Log.Write("server", "Unknown server command: {0}", o.TargetString); SendOrderTo(conn, "Message", "Unknown server command: {0}".F(o.TargetString)); } break; } case "Chat": DispatchOrdersToClients(conn, 0, o.Serialize()); break; case "Pong": { long pingSent; if (!OpenRA.Exts.TryParseInt64Invariant(o.TargetString, out pingSent)) { Log.Write("server", "Invalid order pong payload: {0}", o.TargetString); break; } var client = GetClient(conn); if (client == null) { return; } var pingFromClient = LobbyInfo.PingFromClient(client); if (pingFromClient == null) { return; } var history = pingFromClient.LatencyHistory.ToList(); history.Add(Game.RunTime - pingSent); // Cap ping history at 5 values (25 seconds) if (history.Count > 5) { history.RemoveRange(0, history.Count - 5); } pingFromClient.Latency = history.Sum() / history.Count; pingFromClient.LatencyJitter = (history.Max() - history.Min()) / 2; pingFromClient.LatencyHistory = history.ToArray(); SyncClientPing(); break; } case "GameSaveTraitData": { if (GameSave != null) { var data = MiniYaml.FromString(o.TargetString)[0]; GameSave.AddTraitData(int.Parse(data.Key), data.Value); } break; } case "CreateGameSave": { if (GameSave != null) { // Sanitize potentially malicious input var filename = o.TargetString; var invalidIndex = -1; var invalidChars = Path.GetInvalidFileNameChars(); while ((invalidIndex = filename.IndexOfAny(invalidChars)) != -1) { filename = filename.Remove(invalidIndex, 1); } var baseSavePath = Platform.ResolvePath( Platform.SupportDirPrefix, "Saves", ModData.Manifest.Id, ModData.Manifest.Metadata.Version); if (!Directory.Exists(baseSavePath)) { Directory.CreateDirectory(baseSavePath); } GameSave.Save(Path.Combine(baseSavePath, filename)); DispatchOrdersToClients(null, 0, Order.FromTargetString("GameSaved", filename, true).Serialize()); } break; } case "LoadGameSave": { if (Type == ServerType.Dedicated || State >= ServerState.GameStarted) { break; } // Sanitize potentially malicious input var filename = o.TargetString; var invalidIndex = -1; var invalidChars = Path.GetInvalidFileNameChars(); while ((invalidIndex = filename.IndexOfAny(invalidChars)) != -1) { filename = filename.Remove(invalidIndex, 1); } var savePath = Platform.ResolvePath( Platform.SupportDirPrefix, "Saves", ModData.Manifest.Id, ModData.Manifest.Metadata.Version, filename); GameSave = new GameSave(savePath); LobbyInfo.GlobalSettings = GameSave.GlobalSettings; LobbyInfo.Slots = GameSave.Slots; // Reassign clients to slots // - Bot ordering is preserved // - Humans are assigned on a first-come-first-serve basis // - Leftover humans become spectators // Start by removing all bots and assigning all players as spectators foreach (var c in LobbyInfo.Clients) { if (c.Bot != null) { LobbyInfo.Clients.Remove(c); var ping = LobbyInfo.PingFromClient(c); if (ping != null) { LobbyInfo.ClientPings.Remove(ping); } } else { c.Slot = null; } } // Rebuild/remap the saved client state // TODO: Multiplayer saves should leave all humans as spectators so they can manually pick slots var adminClientIndex = LobbyInfo.Clients.First(c => c.IsAdmin).Index; foreach (var kv in GameSave.SlotClients) { if (kv.Value.Bot != null) { var bot = new Session.Client() { Index = ChooseFreePlayerIndex(), State = Session.ClientState.NotReady, BotControllerClientIndex = adminClientIndex }; kv.Value.ApplyTo(bot); LobbyInfo.Clients.Add(bot); } else { // This will throw if the server doesn't have enough human clients to fill all player slots // See TODO above - this isn't a problem in practice because MP saves won't use this var client = LobbyInfo.Clients.First(c => c.Slot == null); kv.Value.ApplyTo(client); } } SyncLobbyInfo(); SyncLobbyClients(); SyncClientPing(); break; } } }
public void StartGame() { listener.Stop(); Console.WriteLine("[{0}] Game started", DateTime.Now.ToString(Settings.TimestampFormat)); // Drop any unvalidated clients foreach (var c in PreConns.ToArray()) { DropClient(c); } // Drop any players who are not ready foreach (var c in Conns.Where(c => GetClient(c).IsInvalid).ToArray()) { SendOrderTo(c, "ServerError", "You have been kicked from the server!"); DropClient(c); } // HACK: Turn down the latency if there is only one real player if (LobbyInfo.NonBotClients.Count() == 1) { LobbyInfo.GlobalSettings.OrderLatency = 1; } // Enable game saves for singleplayer missions only // TODO: Enable for multiplayer (non-dedicated servers only) once the lobby UI has been created LobbyInfo.GlobalSettings.GameSavesEnabled = Type != ServerType.Dedicated && LobbyInfo.NonBotClients.Count() == 1; SyncLobbyInfo(); State = ServerState.GameStarted; foreach (var c in Conns) { foreach (var d in Conns) { DispatchOrdersToClient(c, d.PlayerIndex, 0x7FFFFFFF, new[] { (byte)OrderType.Disconnect }); } } if (GameSave == null && LobbyInfo.GlobalSettings.GameSavesEnabled) { GameSave = new GameSave(); } var startGameData = ""; if (GameSave != null) { GameSave.StartGame(LobbyInfo, Map); if (GameSave.LastOrdersFrame >= 0) { startGameData = new List <MiniYamlNode>() { new MiniYamlNode("SaveLastOrdersFrame", GameSave.LastOrdersFrame.ToString()), new MiniYamlNode("SaveSyncFrame", GameSave.LastSyncFrame.ToString()) }.WriteToString(); } } DispatchOrders(null, 0, Order.FromTargetString("StartGame", startGameData, true).Serialize()); foreach (var t in serverTraits.WithInterface <IStartGame>()) { t.GameStarted(this); } if (GameSave != null && GameSave.LastOrdersFrame >= 0) { GameSave.ParseOrders(LobbyInfo, (frame, client, data) => { foreach (var c in Conns) { DispatchOrdersToClient(c, client, frame, data); } }); } }
public void CmdAdjustGameSave(GameObject con, float thresh, float recovery, float absolute, float relative) { GameSave.NeuronParametersChanged(con.GetComponent <Controller>(), thresh, recovery, absolute, relative); }
/// <summary> /// <para>Initializes a new UniqueBlockStructure instance.</para> /// <para>This constructor is for blocks that are read from disk.</para> /// </summary> /// <param name="gameSave">The GameSave instance this block is attached to.</param> /// <param name="address">This block's address.</param> protected UniqueBlockStructure(GameSave gameSave, Tuple<int, uint> address) : base(gameSave, address) { }
void Start() { GS = GameManager.gm.GetComponent<GameSave>(); Gold.text = GS._gold.currentValue.ToString(); }
private void Load(IAsyncResult result) { _storageDevice = StorageDevice.EndShowSelector(result); if (_storageDevice != null && _storageDevice.IsConnected) { GameSave saveData = new GameSave(); var filename = String.Format("save{0:00}.dat", _slot); IAsyncResult r = _storageDevice.BeginOpenContainer(_storageContainerName, null, null); result.AsyncWaitHandle.WaitOne(); StorageContainer container = _storageDevice.EndOpenContainer(r); if (container.FileExists(filename)) { Stream stream = container.OpenFile(filename, FileMode.Open); try { IFormatter formatter = new BinaryFormatter(); saveData = (GameSave)formatter.Deserialize(stream); stream.Close(); container.Dispose(); } catch (Exception ex) { Debug.WriteLine(ex.ToString()); stream.Close(); container.Dispose(); container.DeleteFile(filename); } } result.AsyncWaitHandle.Close(); if (_loadCallback != null) _loadCallback(_slot, saveData); } }
/** * LoadFromDisk() * --> loads a GameSave from the Hard Disk if stand alone, from the playerPrefs if in WebPlayer * */ public static void LoadFromDisk() { if(Application.isWebPlayer) { var serializer = new XmlSerializer(typeof(GameSave)); if(!PlayerPrefs.HasKey("save")) return; TextReader textReader = new StringReader(PlayerPrefs.GetString("save")); GameSave gamesave; gamesave = (GameSave)serializer.Deserialize(textReader); if(gamesave == null) { Debug.Log ("Warning : deserialization fail"); return; } last_save = gamesave; } else { GameSave gamesave = null; try { Stream s = System.IO.File.Open(m_FilePath,System.IO.FileMode.Open); if(s == null) return; BinaryFormatter f = new BinaryFormatter(); f.Binder = new VersionDeserializationBinder(); gamesave = (GameSave)f.Deserialize(s); s.Close(); } catch (IOException e) { } if (gamesave == null) { Debug.Log("Warning : deserialization fail"); return; } last_save = gamesave; } }
internal static SavedStateIndex FromSave(GameSave gameSave, Tuple<int, uint> address) { SavedStateIndex savedStateIndex; if (!gameSave.TryGetFromBlockStructureCache(address, out savedStateIndex)) { savedStateIndex = new SavedStateIndex(gameSave, address); gameSave.AddToBlockStructureCache(address, savedStateIndex); } return savedStateIndex; }
private void LoadSave(GameSave save) { }
private SavedStateIndex(GameSave gameSave, Tuple<int, uint> address) : base(gameSave, address) { }
private ByteArray(GameSave gameSave, Tuple<int, uint> address) : base(gameSave, address) { }
public bool IsSimilarForCloudSaving(GameSave other) { return(completedQuests.Count == other.completedQuests.Count && starCount == other.starCount && ticketsCount == other.ticketsCount); }
public void CmdLoadGame() { GameSave.LoadGame(); }
internal static ChunkTable FromSave(GameSave gameSave, Tuple<int, uint> address) { ChunkTable chunkTable; if (!gameSave.TryGetFromBlockStructureCache(address, out chunkTable)) { chunkTable = new ChunkTable(gameSave, address); gameSave.AddToBlockStructureCache(address, chunkTable); } return chunkTable; }
public void CmdSaveGame(bool backup) { GameSave.SaveGame(backup); }
public override void Paint(Level level) { if (LevelSave.BiomeGenerated is IceBiome) { var clip = Painter.Clip; Painter.Clip = null; Painter.Rect(level, this, 0, Tile.WallB); Painter.Clip = clip; } var scourged = Rnd.Chance(Run.Scourge + 1); if (Rnd.Chance(30)) { var t = Tiles.Pick(Tile.FloorC, Tile.FloorD); if (Rnd.Chance()) { Painter.FillEllipse(level, this, 3, t); } else { Painter.Fill(level, this, 3, t); } if (Rnd.Chance()) { t = Tiles.Pick(Tile.FloorC, Tile.FloorD); if (Rnd.Chance()) { Painter.FillEllipse(level, this, 4, t); } else { Painter.Fill(level, this, 4, t); } } } if (Rnd.Chance()) { if (Rnd.Chance()) { PaintTunnel(level, Tiles.RandomFloor(), GetCenterRect(), true); PaintTunnel(level, Tiles.RandomNewFloor(), GetCenterRect()); } else { PaintTunnel(level, Tiles.RandomNewFloor(), GetCenterRect(), Rnd.Chance()); } } if (GameSave.IsTrue("sk_enraged")) { var rp = GetCenter(); var rsk = new ShopKeeper(); level.Area.Add(rsk); rsk.Center = new Vector2(rp.X * 16 + 8, rp.Y * 16 + 16); return; } var stands = ValidateStands(level, GenerateStands()); if (stands.Count < 4) { Painter.Fill(level, this, 1, Tile.FloorD); Paint(level); return; } if (scourged) { var f = Tiles.RandomFloor(); for (var m = Left + 1; m <= Right - 1; m++) { for (var j = Top + 1; j <= Bottom - 1; j++) { var t = level.Get(m, j); if (t.IsPassable() && t != f) { level.Set(m, j, Tile.EvilFloor); } } } } var pool = Items.GeneratePool(Items.GetPool(Run.Type == RunType.BossRush ? ItemPool.BossRush : ItemPool.Shop)); var consumablePool = Items.GeneratePool(Items.GetPool(ItemPool.ShopConsumable)); var con = Math.Max(1, Math.Ceiling(stands.Count / 4f)); var i = 0; var g = (Run.Depth == 5 && Run.Loop == 0 && LevelSave.GenerateMarket) ? Rnd.Int(stands.Count) : -1; foreach (var s in stands) { var stand = new ShopStand(); level.Area.Add(stand); stand.Center = new Vector2(s.X * 16 + 8, s.Y * 16 + 8); var id = g == i ? "bk:bucket" : Items.GenerateAndRemove(i < con && consumablePool.Count > 0 ? consumablePool : pool, null, true); var item = Items.CreateAndAdd(id, level.Area, false); if (scourged) { item.Scourged = true; } stand.SetItem(item, null); if (pool.Count == 0) { break; } i++; } var p = stands[Rnd.Int(stands.Count)]; var sk = new ShopKeeper(); level.Area.Add(sk); sk.Center = new Vector2(p.X * 16 + 8, p.Y * 16 + 16); // Painter.DrawLine(level, new Dot(Left + 1, Top + 1), new Dot(Right - 1, Top + 1), Tiles.RandomFloor()); var points = new List <Point>(); for (var x = Left + 2; x < Right - 1; x++) { var found = false; foreach (var c in Connected.Values) { if (c.X == x && c.Y == Top) { found = true; break; } } if (!found) { points.Add(new Point(x, Top + 2)); } } var props = new List <Entity> { new Gramophone() }; if (Rnd.Chance(40 + Run.Luck * 7)) { props.Add(new RerollMachine()); } if (Rnd.Chance(40 + Run.Luck * 7)) { props.Add(new VendingMachine()); } foreach (var prop in props) { var pl = points[Rnd.Int(points.Count)]; points.Remove(pl); level.Area.Add(prop); prop.CenterX = pl.X * 16 + 8 + Rnd.Int(-4, 4); prop.Bottom = pl.Y * 16; if (points.Count == 0) { break; } } var tt = Tiles.RandomFloor(); Painter.Call(level, this, 1, (x, y) => { if (level.Get(x, y).Matches(Tile.SpikeOffTmp, Tile.SensingSpikeTmp, Tile.Chasm, Tile.Lava)) { level.Set(x, y, tt); } }); var letters = new[] { 'a', 'b', 'c' }; var spr = $"mat_{letters[Rnd.Int(letters.Length)]}"; foreach (var pair in Connected) { if (pair.Key is SubShopRoom) { continue; } var door = pair.Value; var mat = new SlicedProp(spr, Layers.Entrance); level.Area.Add(mat); if (door.X == Left) { PlaceSign(level, new Vector2(door.X * 16 - 8, door.Y * 16 - 5)); mat.Center = new Vector2(door.X * 16 - 8, door.Y * 16 + 8); } else if (door.X == Right) { PlaceSign(level, new Vector2(door.X * 16 + 24, door.Y * 16 - 5)); mat.Center = new Vector2(door.X * 16 + 24, door.Y * 16 + 8); } else if (door.Y == Top) { mat.Center = new Vector2(door.X * 16 + 8, door.Y * 16 - 8); } else { mat.Center = new Vector2(door.X * 16 + 8, door.Y * 16 + 24); } } }
void CmdPlayerEntered(GameObject obj, int table, int seat) { GameSave.PlayerEntered(obj, table, seat, false); }
internal static Chunk FromSave(GameSave gameSave, Tuple<int, uint> address) { Chunk chunk; if (!gameSave.TryGetFromBlockStructureCache(address, out chunk)) { chunk = new Chunk(gameSave, address); gameSave.AddToBlockStructureCache(address, chunk); } return chunk; }
public void CmdSpawnAllNeurons(GameObject swapper) { GameSave.SpawnAllInstructorNeurons(swapper.GetComponent <SphereSwapper>()); }
/** * SaveLastSave() * --> overwrite the last GameSave allocated * */ public static void SaveLastSave() { if(m_MustLoad) return; Debug.Log("SAVE"); GameSave gamesave = new GameSave(); WorldControllerScript worldController = null; GameObject worldControllerGo = GameObject.Find("GameWorld"); if(worldControllerGo != null) { if((worldController = worldControllerGo.GetComponent<WorldControllerScript>()) != null) gamesave.world = worldController.GetCurrentWorldNumber(); } GameObject[] gameObject = (GameObject[])GameObject.FindObjectsOfType(typeof(GameObject)); int id = 1; foreach(GameObject go in gameObject) { Saveable savecomponent = null; if((savecomponent = go.GetComponent<Saveable>()) != null) { Save save = savecomponent.SaveTo(); save.m_Id = id; gamesave.AddSave(save); id++; } } gamesave.level = Application.loadedLevel; if(last_save != null) { gamesave.time = last_save.time; gamesave.deathCount = last_save.deathCount; gamesave.score = last_save.score; } if(gamesave == null) { Debug.Log ("Warning : save fail"); return; } last_save = gamesave; }
public ByteArray(GameSave gameSave, byte[] data) : base(gameSave) { _data = new byte[data.Length]; data.CopyTo(_data, 0); }