Exemple #1
0
        public void LoadGame(string path)
        {
            bool flag = false;

            // First we f**k current scene
            ClearAll();


            // Load layers
            if (lt.dtv.Nodes.Count > 0)
            {
                lt.dtv.Nodes[0].Nodes.Clear();
            }

            // Prepare XML serializer
            // Then we load raw data
            Root          root    = new Root();
            XmlSerializer ser     = new XmlSerializer(typeof(Root), Form1.reflectedTypes.ToArray());
            StreamReader  w       = new StreamReader(path);
            Root          rawData = (Root)ser.Deserialize(w);

            // First load back room itself
            Form1.width           = (int)rawData.Room.Size.X;
            Form1.height          = (int)rawData.Room.Size.Y;
            Form1.ActiveForm.Text = "Simplex RPG Engine / " + rawData.Room.Name;

            currentRoom = rawData.Room;

            // if (currentRoom != null)
            // {
            GameRoom gr = (GameRoom)Activator.CreateInstance(currentRoom.GetType());

            selectedLayer = gr.Layers[0];
            int currentDepth = 0;

            foreach (RoomLayer rl in gr.Layers)
            {
                DarkTreeNode dtn = new DarkTreeNode(rl.Name);
                dtn.Tag = dtn;
                dtn.Tag = "";

                if (rl.LayerType == RoomLayer.LayerTypes.typeObject)
                {
                    dtn.Icon = (System.Drawing.Bitmap)Properties.Resources.ResourceManager.GetObject("WorldLocal_16x");
                }
                else if (rl.LayerType == RoomLayer.LayerTypes.typeAsset)
                {
                    dtn.Icon = (System.Drawing.Bitmap)Properties.Resources.ResourceManager.GetObject("Image_16x");
                }
                else
                {
                    dtn.Icon = (System.Drawing.Bitmap)Properties.Resources.ResourceManager.GetObject("MapLineLayer_16x");
                }

                rl.Depth      = currentDepth;
                currentDepth += 100;
                roomLayers.Add(rl);
                lt?.dtv.Nodes[0].Nodes.Add(dtn);
            }

            // we need to initialize layers by type
            foreach (RoomLayer rl in roomLayers)
            {
                if (rl.LayerType == RoomLayer.LayerTypes.typeTile)
                {
                    // Start with empty cell data and load stuff later on
                    ((TileLayer)rl).Data = new int[(int)currentRoom.Size.X / 32, (int)currentRoom.Size.Y / 32];

                    // Now select correct tileset and assign it to this.. well tileset
                    Tileset tl = tilesets.FirstOrDefault(x => x.Name == ((TileLayer)rl).TilelistName);

                    // this can fail so check for that
                    if (tl != null)
                    {
                        // also we need to load textures for the tileset
                        // tl.AutotileLib =

                        // all good
                        ((TileLayer)rl).Tileset = tl;
                    }
                }
            }


            // Time to load babies
            foreach (GameObject g in rawData.Objects)
            {
                Spritesheet s = Sprites.FirstOrDefault(x => x.Name == g.Sprite.TextureSource);

                g.Sprite.Texture            = s.Texture;
                g.Sprite.ImageRectangle     = new Microsoft.Xna.Framework.Rectangle(0, 0, s.CellWidth, s.CellHeight);
                g.Sprite.TextureRows        = s.Rows;
                g.Sprite.TextureCellsPerRow = s.Texture.Width / s.CellWidth;
                g.Sprite.ImageSize          = new Vector2(s.CellWidth, s.CellHeight);
                g.Sprite.FramesCount        = (s.Texture.Width / s.CellWidth) * (s.Texture.Height / s.CellHeight) - 1;
                g.FramesCount  = g.Sprite.FramesCount - 1;
                g.Sprite.cellW = s.CellHeight;
                g.Sprite.cellH = s.CellWidth;

                RoomLayer rt = roomLayers.FirstOrDefault(x => x.Name == g.LayerName);
                g.Layer = (ObjectLayer)rt;

                g.Sprite.UpdateImageRectangle();
                g.UpdateState();
                g.UpdateColliders();

                // Need to give object OriginalType !!!
                g.OriginalType = Type.GetType(g.TypeString);

                g.EvtCreate();
                g.EvtLoad();

                g.Layer.Objects.Add(g);
                sh.RegisterObject(g);
            }

            // Load tiles
            foreach (Tile t in rawData.Tiles)
            {
                RoomLayer correctLayer = roomLayers.FirstOrDefault(x => x.Name == t.TileLayerName);

                if (correctLayer != null)
                {
                    TileLayer crt = (TileLayer)correctLayer;
                    t.TileLayer = crt;
                    crt.Tiles.Add(t);
                }
                else
                {
                    Debug.WriteLine("Tile could not be loaded - TileLayerName is wrong");
                }
            }

            // Now update all tiles
            Texture2D ttt = Editor.Content.Load <Texture2D>(Path.GetFullPath("../../../SimplexRpgEngine3/Content/bin/Windows/Sprites/Tilesets/" + "tileset0"));

            foreach (RoomLayer rl in roomLayers)
            {
                if (rl is TileLayer)
                {
                    TileLayer crt = (TileLayer)rl;

                    foreach (Tile t in crt.Tiles)
                    {
                        t.SourceTexture = ttt;
                        Autotile.UpdateTile(t, crt);
                    }
                }
            }

            w.Close();
        }
Exemple #2
0
        public void GameClicked(MouseEventArgs e, MouseButtons mb)
        {
            KeyboardState ks = Keyboard.GetState();

            if ((mb & MouseButtons.Left) != 0)
            {
                Input.PressedButtonsOnce[0] = 1; Sgml.LastButton = Sgml.MouseButtons.Left;
            }
            if ((mb & MouseButtons.Right) != 0)
            {
                Input.PressedButtonsOnce[1] = 1; Sgml.LastButton = Sgml.MouseButtons.mb_right;
            }
            if ((mb & MouseButtons.Middle) != 0)
            {
                Input.PressedButtonsOnce[2] = 1; Sgml.LastButton = Sgml.MouseButtons.Middle;
            }
            if ((mb & MouseButtons.None) != 0)
            {
                Input.PressedButtonsOnce[3] = 1;
            }
            if ((mb & MouseButtons.XButton1) != 0)
            {
                Input.PressedButtonsOnce[5] = 1; Sgml.LastButton = Sgml.MouseButtons.mb_x1;
            }
            if ((mb & MouseButtons.XButton2) != 0)
            {
                Input.PressedButtonsOnce[6] = 1; Sgml.LastButton = Sgml.MouseButtons.mb_x2;
            }


            Input.CheckAnyPressed();

            MousePositionTranslated = cam.Camera.ScreenToWorld(MousePosition);

            if (mb == MouseButtons.Left)
            {
                goodBoy = true;
                Vector2 vec = MousePositionTranslated;


                if (DrawGrid)
                {
                    vec = new Vector2((int)vec.X / 32 * 32, (int)vec.Y / 32 * 32);
                }

                if (ks.IsKeyDown(Keys.LeftControl))
                {
                    selectionRectangle.Width  = -selectionRectangle.X + vec.X;
                    selectionRectangle.Height = -selectionRectangle.Y + vec.Y;
                }
                else if (clickedObject == null)
                {
                    if (currentAutotile == null)
                    {
                        if (selectedRectangleObjects.Count > 0)
                        {
                            bool flag = true;

                            if (flag)
                            {
                                if (selectedRectangleObjects.Count > 0)
                                {
                                    foreach (GameObject o in selectedRectangleObjects)
                                    {
                                        o.Position += new Vector2(vec.X - MousePrevious.X, vec.Y - MousePrevious.Y);
                                    }
                                }
                            }
                            else
                            {
                                selectedRectangleObjects.Clear();
                            }
                        }
                        else
                        {
                            if (!ks.IsKeyDown(Keys.LeftShift) || Sgml.PlaceEmpty(vec))
                            {
                                if (Sgml.PlaceEmpty(vec))
                                {
                                    if (SelectedObject != null && selectedLayer.GetType() == typeof(ObjectLayer))
                                    {
                                        GameObject o = (GameObject)Activator.CreateInstance(SelectedObject);

                                        Spritesheet s = new Spritesheet();
                                        if (o.Sprite != null)
                                        {
                                            s = Sprites.FirstOrDefault(x => x.Name == o.Sprite.TextureSource);
                                        }

                                        if (!cmsOpen && SelectedObject != null)
                                        {
                                            if (stackedSteps.Count > 31)
                                            {
                                                stackedSteps.Pop();
                                            }

                                            stackedSteps.Push(SceneObjects.ToList());
                                            editorForm.updateStack(stackedSteps.Count);

                                            o.OriginalType = SelectedObject;
                                            o.TypeString   = SelectedObject.ToString();

                                            if (s == null)
                                            {
                                                Texture2D tx = ConvertToTexture(Properties.Resources.Question_16x,
                                                                                GraphicsDevice);


                                                o.Sprite                = new Sprite();
                                                o.Sprite.Texture        = tx;
                                                o.Sprite.ImageRectangle = new Microsoft.Xna.Framework.Rectangle(0, 0, 16, 16);
                                            }
                                            else
                                            {
                                                o.Sprite.Texture        = s.Texture;
                                                o.Sprite.ImageRectangle = new Microsoft.Xna.Framework.Rectangle(0, 0, s.CellWidth, s.CellHeight);
                                            }

                                            o.Sprite.TextureRows        = s.Rows;
                                            o.Sprite.TextureCellsPerRow = s.Texture.Width / s.CellWidth;
                                            o.Sprite.ImageSize          = new Vector2(s.CellWidth, s.CellHeight);
                                            o.Sprite.FramesCount        = Math.Max((s.Texture.Width / s.CellWidth) * (s.Texture.Height / s.CellHeight) - 1, 1);
                                            o.FramesCount  = Math.Max(o.Sprite.FramesCount - 1, 1);
                                            o.Sprite.cellW = s.CellHeight;
                                            o.Sprite.cellH = s.CellWidth;

                                            o.Position = new Vector2(vec.X - s.CellWidth / 2f, vec.Y - s.CellHeight / 2f);
                                            o.Sprite.ImageRectangle = new Microsoft.Xna.Framework.Rectangle(0, 0, s.CellWidth, s.CellHeight);
                                            o.LayerName             = selectedLayer.Name;
                                            o.Layer = (ObjectLayer)selectedLayer;

                                            Sgml.currentObject = o;
                                            o.EvtCreate();

                                            o.Layer.Objects.Add(o);
                                            SceneObjects.Add(o);
                                            sh.RegisterObject(o);
                                        }

                                        if (!ks.IsKeyDown(Keys.LeftShift))
                                        {
                                            clickedObject = o;
                                        }
                                    }
                                }
                            }

                            if (!Sgml.PlaceEmpty(vec) && !ks.IsKeyDown(Keys.LeftShift))
                            {
                                // there's something cool at the position already, time to grab it
                                GameObject collidingObject = Sgml.instance_place(vec);

                                if (collidingObject != null)
                                {
                                    clickedObject = collidingObject;
                                    helpVec       = new Vector2(-MousePositionTranslated.X + collidingObject.Position.X, -MousePositionTranslated.Y + collidingObject.Position.Y);
                                    clickedVec    = MousePositionTranslated;
                                }
                            }
                        }
                    }
                    else
                    {
                        Vector2 m = MousePositionTranslated;

                        Tile alreadyT = currentTileLayer.Tiles.FirstOrDefault(x => x.PosX == (int)m.X / 32 && x.PosY == (int)m.Y / 32);

                        if (alreadyT == null)
                        {
                            Tile t = new Tile();
                            t.Bits          = 16;
                            t.DrawRectangle = new Microsoft.Xna.Framework.Rectangle(0, 0, 32, 32);
                            t.SourceTexture = currentAutotile.Texture;
                            t.PosX          = (int)m.X / 32;
                            t.PosY          = (int)m.Y / 32;
                            t.TileLayer     = currentTileLayer;
                            t.TileLayerName = t.TileLayer.Name;

                            currentTileLayer.Tiles.Add(t);

                            t = Autotile.UpdateTile(t, currentTileLayer);

                            // basic 4
                            Tile t1 = currentTileLayer.Tiles.FirstOrDefault(x => x.PosX == t.PosX && x.PosY == t.PosY - 1); // N // 2
                            Tile t2 = currentTileLayer.Tiles.FirstOrDefault(x => x.PosX == t.PosX && x.PosY == t.PosY + 1); // S // 64
                            Tile t3 = currentTileLayer.Tiles.FirstOrDefault(x => x.PosX == t.PosX + 1 && x.PosY == t.PosY); // W // 16
                            Tile t4 = currentTileLayer.Tiles.FirstOrDefault(x => x.PosX == t.PosX - 1 && x.PosY == t.PosY); // S // 8

                            // extended 4
                            Tile t5 = currentTileLayer.Tiles.FirstOrDefault(x => x.PosX == t.PosX - 1 && x.PosY == t.PosY - 1); // EN // 1
                            Tile t6 = currentTileLayer.Tiles.FirstOrDefault(x => x.PosX == t.PosX + 1 && x.PosY == t.PosY - 1); // WN // 4
                            Tile t7 = currentTileLayer.Tiles.FirstOrDefault(x => x.PosX == t.PosX - 1 && x.PosY == t.PosY + 1); // ES // 32
                            Tile t8 = currentTileLayer.Tiles.FirstOrDefault(x => x.PosX == t.PosX + 1 && x.PosY == t.PosY + 1); // WS // 128

                            if (t1 != null)
                            {
                                Autotile.UpdateTile(t1, currentTileLayer);
                            }
                            if (t2 != null)
                            {
                                Autotile.UpdateTile(t2, currentTileLayer);
                            }
                            if (t3 != null)
                            {
                                Autotile.UpdateTile(t3, currentTileLayer);
                            }
                            if (t4 != null)
                            {
                                Autotile.UpdateTile(t4, currentTileLayer);
                            }

                            if (t5 != null)
                            {
                                Autotile.UpdateTile(t5, currentTileLayer);
                            }
                            if (t6 != null)
                            {
                                Autotile.UpdateTile(t6, currentTileLayer);
                            }
                            if (t7 != null)
                            {
                                Autotile.UpdateTile(t7, currentTileLayer);
                            }
                            if (t8 != null)
                            {
                                Autotile.UpdateTile(t8, currentTileLayer);
                            }
                        }
                    }
                }
                else
                {
                    vec = MousePositionTranslated;
                    vec = new Vector2(vec.X + helpVec.X, vec.Y + helpVec.Y);

                    if (DrawGrid)
                    {
                        vec    = MousePositionTranslated;
                        vec.X -= (int)(clickedObject.Sprite.ImageRectangle.Width - 32) / 2;//16;
                        vec.Y -= (int)(clickedObject.Sprite.ImageRectangle.Height - 32) / 2;

                        vec = new Vector2((int)vec.X / 32 * 32, (int)vec.Y / 32 * 32);
                    }

                    if (!cmsOpen)
                    {
                        clickedObject.Position = vec;
                    }
                }
            }
            else if (mb == MouseButtons.Right)
            {
                //  Debug.WriteLine("----");
                Vector2 vec = MousePositionTranslated;
                if (DrawGrid)
                {
                    vec = new Vector2((int)vec.X / 32 * 32, (int)vec.Y / 32 * 32);
                }

                foreach (RoomLayer rl in roomLayers)
                {
                    if (rl.Visible)
                    {
                        if (rl is ObjectLayer)
                        {
                            ObjectLayer ol = (ObjectLayer)rl;
                            for (var i = ol.Objects.Count - 1; i >= 0; i--)
                            {
                                Microsoft.Xna.Framework.Rectangle r = new Microsoft.Xna.Framework.Rectangle((int)ol.Objects[i].Position.X, (int)ol.Objects[i].Position.Y, ol.Objects[i].Sprite.ImageRectangle.Width, ol.Objects[i].Sprite.ImageRectangle.Height);

                                if (ks.IsKeyDown(Keys.LeftShift) && r.Contains(vec))
                                {
                                    SceneObjects.Remove(ol.Objects[i]);
                                    ol.Objects[i].EvtDelete();
                                    ol.Objects.Remove(ol.Objects[i]);
                                }
                            }
                        }
                    }
                }
            }

            MousePrevious = MousePositionTranslated;
        }