Exemplo n.º 1
0
        public override void Update()
        {
            base.Update();
            NoxicoGame.ContextMessage = i18n.GetString("context_interactmode");
            if (this.ParentBoard == null)
            {
                NoxicoGame.Mode = UserMode.Walkabout;
                return;
            }
            //this.ParentBoard.Draw(true);

            if (NoxicoGame.IsKeyDown(KeyBinding.Interact) || NoxicoGame.IsKeyDown(KeyBinding.Back) || Vista.Triggers == XInputButtons.B)
            {
                NoxicoGame.Mode = UserMode.Walkabout;
                NoxicoGame.ClearKeys();
                NoxicoGame.ContextMessage = string.Empty;
                Hide();
                return;
            }

            if (NoxicoGame.IsKeyDown(KeyBinding.TabFocus) || Vista.Triggers == XInputButtons.RightShoulder)
            {
                NoxicoGame.ClearKeys();
                Tabstop++;
                if (Tabstop >= Tabstops.Count)
                {
                    Tabstop = 0;
                }
                XPosition = Tabstops[Tabstop].X;
                YPosition = Tabstops[Tabstop].Y;
                Point();
            }

            if (NoxicoGame.IsKeyDown(KeyBinding.Accept) || Vista.Triggers == XInputButtons.A)
            {
                Subscreens.PreviousScreen.Clear();
                NoxicoGame.ClearKeys();
                var player = NoxicoGame.Me.Player;
#if DEBUG
                if (PointingAt == null)
                {
                    ActionList.Show("Debug?", this.XPosition - NoxicoGame.CameraX, this.YPosition - NoxicoGame.CameraY,
                                    new Dictionary <object, string>()
                    {
                        { "teleport", "Teleport" },
                        { "spawn", "Spawn character" },
                    },
                                    () =>
                    {
                        Hide();
                        if (ActionList.Answer is int && (int)ActionList.Answer == -1)
                        {
                            NoxicoGame.Mode = UserMode.Walkabout;
                            Hide();
                            return;
                        }
                        switch (ActionList.Answer as string)
                        {
                        case "teleport":
                            player.XPosition = this.XPosition;
                            player.YPosition = this.YPosition;
                            ParentBoard.AimCamera();
                            ParentBoard.Redraw();
                            NoxicoGame.Mode = UserMode.Aiming;
                            Point();
                            return;

                        case "spawn":
                            var spawnOptions = new Dictionary <object, string>();
                            foreach (var bp in Character.Bodyplans)
                            {
                                spawnOptions[bp.Text] = bp.Text;
                            }
                            var uniques = Mix.GetTokenTree("uniques.tml", true);
                            foreach (var bp in uniques)
                            {
                                spawnOptions['!' + bp.Text] = bp.Text;
                            }
                            ActionList.Show("Debug?", this.XPosition - NoxicoGame.CameraX, this.YPosition - NoxicoGame.CameraY, spawnOptions,
                                            () =>
                            {
                                if (ActionList.Answer is int && (int)ActionList.Answer == -1)
                                {
                                    NoxicoGame.Mode = UserMode.Aiming;
                                    Point();
                                    return;
                                }
                                Character newChar = null;
                                if (ActionList.Answer is string && ((string)ActionList.Answer).StartsWith('!'))
                                {
                                    newChar = Character.GetUnique(((string)ActionList.Answer).Substring(1));
                                }
                                else
                                {
                                    newChar = Character.Generate((string)ActionList.Answer, Gender.RollDice);
                                }
                                var newBoardChar = new BoardChar(newChar)
                                {
                                    XPosition   = this.XPosition,
                                    YPosition   = this.YPosition,
                                    ParentBoard = this.ParentBoard
                                };
                                newBoardChar.AdjustView();
                                ParentBoard.EntitiesToAdd.Add(newBoardChar);
                                ParentBoard.Redraw();
                                NoxicoGame.Mode = UserMode.Walkabout;
                                Hide();
                                return;
                            }
                                            );
                            break;
                        }
                    }
                                    );
                }
#endif
                if (PointingAt != null)
                {
                    LastTarget = PointingAt;
                    var distance = player.DistanceFrom(PointingAt);
                    var canSee   = player.CanSee(PointingAt);

                    var options     = new Dictionary <object, string>();
                    var description = "something";

                    options["look"] = i18n.GetString("action_lookatit");

                    if (PointingAt is Player)
                    {
                        description     = i18n.Format("action_descyou", player.Character.Name);
                        options["look"] = i18n.GetString("action_lookatyou");
                        if (player.Character.GetStat("excitement") >= 30)
                        {
                            options["f**k"] = i18n.GetString("action_masturbate");
                        }

                        if (player.Character.HasToken("copier") && player.Character.GetToken("copier").Value == 1)
                        {
                            if (player.Character.Path("copier/backup") != null || player.Character.Path("copier/full") == null)
                            {
                                options["revert"] = i18n.GetString("action_revert");
                            }
                        }
                    }
                    else if (PointingAt is DroppedItem)
                    {
                        var drop  = PointingAt as DroppedItem;
                        var item  = drop.Item;
                        var token = drop.Token;
                        description = item.ToString(token);
                        if (distance <= 1)
                        {
                            options["take"] = i18n.GetString("action_pickup");
                        }
                    }
                    else if (PointingAt is Container)
                    {
                        var container = PointingAt as Container;
                        description = container.Name ?? "container";
                    }
                    else if (PointingAt is Clutter)
                    {
                        var clutter = PointingAt as Clutter;
                        description = clutter.Name ?? "something";
                        if (clutter.ID == "craftstation")
                        {
                            options["craft"] = i18n.GetString("action_craft");
                        }
                    }
                    else if (PointingAt is BoardChar)
                    {
                        var boardChar = PointingAt as BoardChar;
                        description     = boardChar.Character.GetKnownName(true);
                        options["look"] = i18n.Format("action_lookathim", boardChar.Character.HimHerIt(true));

                        if (canSee && distance <= 2 && !boardChar.Character.HasToken("beast") && !boardChar.Character.HasToken("sleeping"))
                        {
                            options["talk"] = i18n.Format("action_talktohim", boardChar.Character.HimHerIt(true));
                            if (boardChar.Character.Path("role/vendor") != null && boardChar.Character.Path("role/vendor/class").Text != "carpenter")
                            {
                                options["trade"] = i18n.Format("action_trade", boardChar.Character.HimHerIt(true));
                            }
                        }

                        if (canSee && player.Character.GetStat("excitement") >= 30 && distance <= 1)
                        {
                            var mayFuck  = boardChar.Character.HasToken("willing");
                            var willRape = boardChar.Character.HasToken("helpless");

                            if (!IniFile.GetValue("misc", "allowrape", false) && willRape)
                            {
                                mayFuck = false;
                            }
                            //but DO allow it if they're helpless but willing
                            if (boardChar.Character.HasToken("willing") && willRape)
                            {
                                mayFuck  = true;
                                willRape = false;
                            }
                            if (boardChar.Character.HasToken("beast"))
                            {
                                mayFuck = false;
                            }

                            if (mayFuck)
                            {
                                options["f**k"] = i18n.Format(willRape ? "action_rapehim" : "action_fuckhim", boardChar.Character.HimHerIt(true));
                            }
                        }

                        if (canSee && !boardChar.Character.HasToken("beast") && player.Character.HasToken("copier") && player.Character.Path("copier/timeout") == null)
                        {
                            //if (player.Character.UpdateCopier())
                            if (player.Character.HasToken("fullCopy") || player.Character.HasToken("sexCopy"))
                            {
                                options["copy"] = i18n.Format("action_copyhim", boardChar.Character.HimHerIt(true));
                            }
                        }

                        if (canSee && player.Character.CanShoot() != null && player.ParentBoard.HasToken("combat"))
                        {
                            options["shoot"] = i18n.Format("action_shoothim", boardChar.Character.HimHerIt(true));
                        }
                    }

#if DEBUG
                    if (PointingAt is BoardChar)
                    {
                        options["mutate"] = "(debug) Random mutate";
                    }
                    if (PointingAt is BoardChar)
                    {
                        options["turbomutate"] = "(debug) Apply LOTS of mutations!";
                    }
#endif

                    ActionList.Show(description, PointingAt.XPosition - NoxicoGame.CameraX, PointingAt.YPosition - NoxicoGame.CameraY, options,
                                    () =>
                    {
                        Hide();
                        if (ActionList.Answer is int && (int)ActionList.Answer == -1)
                        {
                            //NoxicoGame.Messages.Add("[Aim message]");
                            NoxicoGame.Mode = UserMode.Aiming;
                            Point();
                            return;
                        }
                        switch (ActionList.Answer as string)
                        {
                        case "look":
                            if (PointingAt is DroppedItem)
                            {
                                var drop  = PointingAt as DroppedItem;
                                var item  = drop.Item;
                                var token = drop.Token;
                                var text  = (item.HasToken("description") && !token.HasToken("unidentified") ? item.GetToken("description").Text : i18n.Format("thisis_x", item.ToString(token))).Trim();
                                MessageBox.Notice(text, true);
                            }
                            else if (PointingAt is Clutter && !((Clutter)PointingAt).Description.IsBlank())
                            {
                                MessageBox.Notice(((Clutter)PointingAt).Description.Trim(), true, ((Clutter)PointingAt).Name ?? "something");
                            }
                            else if (PointingAt is Container)
                            {
                                MessageBox.Notice(((Container)PointingAt).Description.Trim(), true, ((Container)PointingAt).Name ?? "container");
                            }
                            else if (PointingAt is BoardChar)
                            {
                                if (((BoardChar)PointingAt).Character.HasToken("beast"))
                                {
                                    MessageBox.Notice(((BoardChar)PointingAt).Character.LookAt(PointingAt), true, ((BoardChar)PointingAt).Character.GetKnownName(true));
                                }
                                else
                                {
                                    TextScroller.LookAt((BoardChar)PointingAt);
                                }
                            }
                            break;

                        case "talk":
                            if (PointingAt is Player)
                            {
                                //if (Culture.CheckSummoningDay()) return;
                                if (player.Character.Path("mind").Value >= 10)
                                {
                                    MessageBox.Notice(i18n.GetString("talkingotyourself"), true);
                                }
                                else
                                {
                                    MessageBox.Notice(i18n.GetString("talkingtoyourself_nutso"), true);
                                }
                            }
                            else if (PointingAt is BoardChar)
                            {
                                var boardChar = PointingAt as BoardChar;
                                if (boardChar.Character.HasToken("hostile") && !boardChar.Character.HasToken("helpless"))
                                {
                                    MessageBox.Notice(i18n.Format("nothingtosay", boardChar.Character.GetKnownName(false, false, true, true)), true);
                                }
                                else
                                {
                                    SceneSystem.Engage(player.Character, boardChar.Character);
                                }
                            }
                            break;

                        case "trade":
                            ContainerMan.Setup(((BoardChar)PointingAt).Character);
                            break;

                        case "f**k":
                            if (PointingAt is BoardChar)
                            {
                                SexManager.Engage(player.Character, ((BoardChar)PointingAt).Character);
                            }
                            break;

                        case "shoot":
                            player.AimShot(PointingAt);
                            break;

                        case "copy":
                            player.Character.Copy(((BoardChar)PointingAt).Character);
                            player.AdjustView();
                            //NoxicoGame.AddMessage(i18n.Format((player.Character.Path("copier/full") == null) ? "youimitate_x" : "become_x", ((BoardChar)PointingAt).Character.GetKnownName(false, false, true)));
                            NoxicoGame.AddMessage(i18n.Format(player.Character.HasToken("fullCopy") ? "x_becomes_y" : "x_imitates_y").Viewpoint(player.Character, ((BoardChar)PointingAt).Character));
                            player.Energy -= 2000;
                            break;

                        case "revert":
                            player.Character.Copy(null);
                            player.AdjustView();
                            NoxicoGame.AddMessage(i18n.GetString((player.Character.HasToken("fullCopy")) ? "youmelt" : "yourevert"));
                            player.Energy -= 1000;
                            break;

                        case "take":
                            if (PointingAt is DroppedItem)
                            {
                                var drop  = PointingAt as DroppedItem;
                                var item  = drop.Item;
                                var token = drop.Token;
                                drop.Take(player.Character, ParentBoard);
                                player.Energy -= 1000;
                                NoxicoGame.AddMessage(i18n.Format("youpickup_x", item.ToString(token, true)), drop.ForegroundColor);
                                NoxicoGame.Sound.PlaySound("set://GetItem");
                                ParentBoard.Redraw();
                            }
                            break;

                        case "craft":
                            Crafting.Open(player.Character);
                            break;

#if DEBUG
                        case "edit":
                            TokenCarrier tc = null;
                            if (PointingAt is DroppedItem)
                            {
                                tc = ((DroppedItem)PointingAt).Token;
                            }
                            else if (PointingAt is BoardChar)
                            {
                                tc = ((BoardChar)PointingAt).Character;
                            }

                            NoxicoGame.HostForm.Write("TOKEN EDIT ENGAGED. Waiting for editor process to exit.", Color.Black, Color.White, 0, 0);
                            NoxicoGame.HostForm.Draw();
                            ((MainForm)NoxicoGame.HostForm).timer.Enabled = false;
                            var dump = "-- WARNING! Many things may cause strange behavior or crashes. WATCH YOUR F*****G STEP.\r\n" + tc.DumpTokens(tc.Tokens, 0);
                            var temp = Path.Combine(Path.GetTempPath(), DateTime.Now.Ticks.ToString() + ".txt");
                            File.WriteAllText(temp, dump);
                            var process = System.Diagnostics.Process.Start(temp);
                            process.WaitForExit();
                            var newDump = File.ReadAllText(temp);
                            File.Delete(temp);
                            ((MainForm)NoxicoGame.HostForm).timer.Enabled = true;
                            ParentBoard.Redraw();
                            if (newDump == dump)
                            {
                                break;
                            }
                            tc.Tokenize(newDump);
                            ((BoardChar)PointingAt).AdjustView();
                            ((BoardChar)PointingAt).Character.RecalculateStatBonuses();
                            ((BoardChar)PointingAt).Character.CheckHasteSlow();
                            break;

                        case "mutate":
                            var result = ((BoardChar)PointingAt).Character.Mutate(1, 30);
                            NoxicoGame.AddMessage(result);
                            break;

                        case "turbomutate":
                            result = ((BoardChar)PointingAt).Character.Mutate(2500, 30);
                            NoxicoGame.AddMessage(result);
                            break;
#endif

                        default:
                            MessageBox.Notice("Unknown action handler \"" + ActionList.Answer.ToString() + "\".", true);
                            break;
                        }
                    }
                                    );             //	true, true);
                    return;
                }
                else
                {
                    /*
                     * var tSD = this.ParentBoard.GetDescription(YPosition, XPosition);
                     * if (!string.IsNullOrWhiteSpace(tSD))
                     * {
                     *      PointingAt = null;
                     *      MessageBox.ScriptPauseHandler = () =>
                     *      {
                     *              NoxicoGame.Mode = UserMode.Aiming;
                     *              Point();
                     *      };
                     *      MessageBox.Notice(tSD, true);
                     *      return;
                     * }
                     */
                }
            }

#if DEBUG
            if (NoxicoGame.KeyMap[Keys.D])
            {
                NoxicoGame.ClearKeys();
                if (PointingAt != null && PointingAt is BoardChar)
                {
                    ((BoardChar)PointingAt).Character.CreateInfoDump();
                    NoxicoGame.AddMessage("Info for " + ((BoardChar)PointingAt).Character.GetKnownName(true, true, true) + " dumped.", Color.Red);
                }
            }
#endif

            if (NoxicoGame.IsKeyDown(KeyBinding.Left) || Vista.DPad == XInputButtons.Left)
            {
                this.Move(Direction.West);
            }
            else if (NoxicoGame.IsKeyDown(KeyBinding.Right) || Vista.DPad == XInputButtons.Right)
            {
                this.Move(Direction.East);
            }
            else if (NoxicoGame.IsKeyDown(KeyBinding.Up) || Vista.DPad == XInputButtons.Up)
            {
                this.Move(Direction.North);
            }
            else if (NoxicoGame.IsKeyDown(KeyBinding.Down) || Vista.DPad == XInputButtons.Down)
            {
                this.Move(Direction.South);
            }
        }
Exemplo n.º 2
0
        public virtual void ToTilemap(ref Tile[,] map)
        {
            var woodFloor = Color.FromArgb(86, 63, 44);
            var caveFloor = Color.FromArgb(65, 66, 87);
            var wall      = Color.FromArgb(20, 15, 12);
            var water     = BiomeData.Biomes[BiomeData.ByName(biome.Realm == Realms.Nox ? "Water" : "KoolAid")];

            allowCaveFloor = false;

            Clutter.ParentBoardHack = Board;

            var doorCount = 0;

            var safeZones = new List <Rectangle>();

            for (var row = 0; row < plotRows; row++)
            {
                for (var col = 0; col < plotCols; col++)
                {
                    if (plots[col, row].BaseID == null)
                    {
                        //Can clutter this up!
                        if (includeClutter && Random.Flip())
                        {
                            Board.AddClutter(col * plotWidth, row * plotHeight, (col * plotWidth) + plotWidth, (row * plotHeight) + plotHeight + row);
                        }
                        else
                        {
                            safeZones.Add(new Rectangle()
                            {
                                Left = col * plotWidth, Top = row * plotHeight, Right = (col * plotWidth) + plotWidth, Bottom = (row * plotHeight) + plotHeight + row
                            });
                        }
                        continue;
                    }

                    if (plots[col, row].BaseID == "<spillover>")
                    {
                        continue;
                    }
                    var building = plots[col, row];
                    var template = building.Template;
                    var sX       = (col * plotWidth) + building.XShift;
                    var sY       = (row * plotHeight) + building.YShift;
                    for (var y = 0; y < template.Height; y++)
                    {
                        for (var x = 0; x < template.Width; x++)
                        {
                            var tc    = template.MapScans[y][x];
                            var def   = string.Empty;
                            var fluid = Fluids.Dry;

                            var addDoor = true;
                            if (tc == '/')
                            {
                                addDoor = false;
                                tc      = '\\';
                            }
                            switch (tc)
                            {
                            case '\'':
                                continue;

                            case ',':
                                def = "pathWay";                                         // FIXME: kind of ugly but does the job
                                break;

                            case '.':
                                def = "woodFloor";
                                break;

                            case '+':                                     //Exit -- can't be seen, coaxes walls into shape.
                                def = "doorwayClosed";

                                if (addDoor)
                                {
                                    doorCount++;
                                    var door = new Door()
                                    {
                                        XPosition       = sX + x,
                                        YPosition       = sY + y,
                                        ForegroundColor = woodFloor,
                                        BackgroundColor = woodFloor.Darken(),
                                        ID          = building.BaseID + "_Door" + doorCount,
                                        ParentBoard = Board,
                                        Closed      = true,
                                        Glyph       = '+'
                                    };
                                    Board.Entities.Add(door);
                                }
                                break;

                            case '=':
                                def = "outerWoodWall";
                                break;

                            case '-':
                                def = "innerWoodWall";
                                break;

                            case '#':
                                def = allowCaveFloor ? "stoneFloor" : "woodFloor";
                                break;

                            default:
                                if (template.Markings.ContainsKey(tc))
                                {
                                    #region Custom markings
                                    var m = template.Markings[tc];
                                    if (m.Text == "block")
                                    {
                                        throw new Exception("Got a BLOCK-type marking in a building template.");
                                    }

                                    if (m.Text != "tile" && m.Text != "floor" && m.Text != "water")
                                    {
                                        //Keep a floor here. The entity fills in the blank.
                                        def = "woodFloor";
                                        var tileDef = TileDefinition.Find(def, false);
                                        map[sX + x, sY + y].Index = tileDef.Index;
                                        //var owner = m.Owner == 0 ? null : building.Inhabitants[m.Owner - 1];
                                        var owner = (Character)null;
                                        if (m.HasToken("owner"))
                                        {
                                            owner = building.Inhabitants[(int)m.GetToken("owner").Value - 1];
                                        }
                                        if (m.Text == "bed")
                                        {
                                            var newBed = new Clutter()
                                            {
                                                XPosition   = sX + x,
                                                YPosition   = sY + y,
                                                Name        = "Bed",
                                                ID          = "Bed_" + (owner == null ? Board.Entities.Count.ToString() : owner.Name.ToID()),
                                                Description = owner == null?i18n.GetString("freebed") : i18n.Format("someonesbed", owner.Name.ToString(true)),
                                                                  ParentBoard = Board,
                                            };
                                            Clutter.ResetToKnown(newBed);
                                            Board.Entities.Add(newBed);
                                        }
                                        if (m.Text == "container")
                                        {
                                            //var type = c == '\x14B' ? "cabinet" : c == '\x14A' ? "chest" : "container";
                                            var type = "chest";
                                            if (m.HasToken("wardrobe"))
                                            {
                                                type = "wardrobe";
                                            }
                                            var contents = DungeonGenerator.GetRandomLoot("container", type, new Dictionary <string, string>()
                                            {
                                                { "gender", owner.PreferredGender.ToString().ToLowerInvariant() },
                                                { "biome", BiomeData.Biomes[DungeonGenerator.DungeonGeneratorBiome].Name.ToLowerInvariant() },
                                            });
                                            if (owner != null)
                                            {
                                                foreach (var content in contents)
                                                {
                                                    content.AddToken("owner", 0, owner.ID);
                                                }
                                            }
                                            var newContainer = new Container(type, contents)                                                     //owner == null ? type.Titlecase() : owner.Name.ToString(true) + "'s " + type, contents)
                                            {
                                                XPosition   = sX + x,
                                                YPosition   = sY + y,
                                                ID          = "Container_" + type + "_" + (owner == null ? Board.Entities.Count.ToString() : owner.Name.ToID()),
                                                ParentBoard = Board,
                                            };
                                            Clutter.ResetToKnown(newContainer);
                                            Board.Entities.Add(newContainer);
                                        }
                                        else if (m.Text == "clutter")
                                        {
                                            if (m.HasToken("id"))
                                            {
                                                var newClutter = new Clutter()
                                                {
                                                    XPosition   = sX + x,
                                                    YPosition   = sY + y,
                                                    ParentBoard = Board,
                                                    ID          = m.GetToken("id").Text,
                                                    Name        = string.Empty,
                                                };
                                                Clutter.ResetToKnown(newClutter);
                                                Board.Entities.Add(newClutter);
                                            }
                                            else
                                            {
                                                var newClutter = new Clutter()
                                                {
                                                    Glyph           = (char)m.GetToken("char").Value,                                                   //m.Params.Last()[0],
                                                    XPosition       = sX + x,
                                                    YPosition       = sY + y,
                                                    ForegroundColor = Color.Black,
                                                    BackgroundColor = tileDef.Background,
                                                    ParentBoard     = Board,
                                                    Name            = m.GetToken("name").Text,                                                  //Name,
                                                    Description     = m.HasToken("description") ? m.GetToken("description").Text : string.Empty,
                                                    Blocking        = m.HasToken("blocking"),
                                                };
                                                Board.Entities.Add(newClutter);
                                            }
                                        }
                                    }
                                    else if (m.Text == "water")
                                    {
                                        fluid = Fluids.Water;
                                    }
                                    else
                                    {
                                        def = TileDefinition.Find((int)m.GetToken("index").Value).Name;
                                    }
                                    #endregion
                                }
                                break;
                            }
                            map[sX + x, sY + y].Index = TileDefinition.Find(def).Index;
                            map[sX + x, sY + y].Fluid = fluid;
                        }
                    }

                    for (var i = 0; i < building.Inhabitants.Count; i++)
                    {
                        var inhabitant = building.Inhabitants[i];
                        //Find each inhabitant's bed so we can give them a starting place.
                        //Alternatively, place them anywhere there's a ' ' within their sector.
                        var bc = new BoardChar(inhabitant);
                        //var bedID = building.BaseID + "_Bed_" + inhabitant.Name.FirstName;
                        //var bed = Board.Entities.OfType<Clutter>().FirstOrDefault(b => b.ID == bedID);
                        //if (bed != null)
                        //{
                        //	bc.XPosition = bed.XPosition;
                        //	bc.YPosition = bed.YPosition;
                        //}
                        //else
                        {
                            //var okay = false;
                            var x     = 0;
                            var y     = 0;
                            var lives = 100;
                            while (lives > 0)
                            {
                                lives--;
                                x = (col * plotWidth) + Random.Next(plotWidth);
                                y = (row * plotHeight) + Random.Next(plotHeight);
                                if (!map[x, y].Definition.Wall &&
                                    (!template.AllowOutside && map[x, y].Definition.Ceiling) &&
                                    Board.Entities.FirstOrDefault(e => e.XPosition == x && e.YPosition == y) == null)
                                {
                                    break;
                                }
                            }
                            bc.XPosition = x;
                            bc.YPosition = y;
                        }
                        bc.Character.AddToken("sectorlock");
                        bc.ParentBoard = Board;
                        bc.AdjustView();
                        bc.Sector = string.Format("s{0}x{1}", row, col);
                        Board.Entities.Add(bc);
                    }
                }
            }

            Board.ResolveVariableWalls();

            if (safeZones.Count > 0 && includeWater)
            {
                Board.AddWater(safeZones);
            }
        }