Subversion Repositories AndroidProjects

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.ComponentModel;

using System.IO;

using System.Windows.Forms;

using System.ComponentModel;

using System.Windows.Forms.Design;

using BurutaruEditor.file.elements;

using BurutaruEditor.file.enemies;

using BurutaruEditor.view;

using BauzoidNET.math;

using BauzoidNET.parser;

using BurutaruEditor.file.conditions;

namespace BurutaruEditor.file

{

    public class Document

    {

        //=================================================================================================================================

        public const float VIRTUAL_WIDTH = 800;

        public const float VIRTUAL_HEIGHT = 480;

        public const float PASTE_OFFSET = 15;

        public static readonly Vector4 TEXT_COLOR = new Vector4(1, 1, 1, 1);

        public const float TEXT_SCALE = 0.8f;

        //=================================================================================================================================

        private MainForm mOwner = null;

        [Browsable(false)]

        public MainForm Owner { get { return mOwner; } }

        [Browsable(false)]

        public DocumentView View { get { return Owner.View; } }

        private bool mIsDirty = false;

        private String mFilename = null;

        private List<CheckPoint> mCheckPoints = new List<CheckPoint>();

        [Browsable(false)]

        public List<CheckPoint> CheckPoints { get { return mCheckPoints; } }

        private List<EnemySpawner> mSpawners = new List<EnemySpawner>();

        [Browsable(false)]

        public List<EnemySpawner> Spawners { get { return mSpawners; } }

        private List<LevelElement> mLevelElements = new List<LevelElement>();

        [Browsable(false)]

        public List<LevelElement> LevelElements { get { return mLevelElements; } }

        private List<BaseCondition> mScripting = new List<BaseCondition>();

        [Browsable(false)]

        public List<BaseCondition> Scripting { get { return mScripting; } }

        [Category("Basic Parameters")]

        public string LevelTitle { get; set; }

        [Category("Basic Parameters")]

        public string StageTitle { get; set; }

        private Vector2 mStartPosition = new Vector2();

        [TypeConverter(typeof(ExpandableObjectConverter))]

        [Category("Basic Parameters")]

        public Vector2 StartPosition { get { return mStartPosition; } }

        [Category("Basic Parameters")]

        public bool WarpIn { get; set; }

        [Category("Basic Parameters")]

        public CheckPoint.StarFieldControlStatus StarFieldStatus { get; set; }

        private string mCopyPasteBuffer = null;

        private float mPasteOffset = PASTE_OFFSET;

        //=================================================================================================================================

        public class SpriteFileNameEditor : FileNameEditor

        {

            protected override void InitializeDialog(OpenFileDialog openFileDialog)

            {

                base.InitializeDialog(openFileDialog);

                String s = Path.Combine(Application.StartupPath, @"..\\..\\..\\..\\..\\BauzoidApps\\BurutaruZ_v2\\burutaru-android\\assets\\data");

                openFileDialog.InitialDirectory = Path.GetFullPath(s) + "\\textures";

                openFileDialog.Filter = "Image files|*.png|All files|*.*";

            }

        }

        public class ShapeFileNameEditor : FileNameEditor

        {

            protected override void InitializeDialog(OpenFileDialog openFileDialog)

            {

                base.InitializeDialog(openFileDialog);

                String s = Path.Combine(Application.StartupPath, @"..\\..\\..\\..\\..\\BauzoidApps\\BurutaruZ_v2\\burutaru-android\\assets\\data");

                openFileDialog.InitialDirectory = Path.GetFullPath(s) + "\\textures";

                openFileDialog.Filter = "Shape files|*.shape|All files|*.*";

            }

        }

        //=================================================================================================================================

        public Document(MainForm owner)

        {

            mOwner = owner;

            ResetDocument();

            StageTitle = "Stage 01";

            WarpIn = false;

            StarFieldStatus = CheckPoint.StarFieldControlStatus.NORMAL;

        }

        public void Init()

        {

            ResetDocument();

        }

        public void Exit()

        {

            ResetDocument();

        }

        public void ResetDocument()

        {

            mFilename = null;

            LevelTitle = "Level Title";

            mIsDirty = false;

            mSpawners.Clear();

            for (int i = 0; i < mLevelElements.Count; i++)

                mLevelElements.ElementAt(i).Exit();

            mLevelElements.Clear();

            mCheckPoints.Clear();

            Owner.CheckPoints.Items.Clear();

            Owner.Spawners.Items.Clear();

            Owner.LevelElements.Items.Clear();

            Owner.Scripting.Items.Clear();

            Owner.Properties.SelectedObject = this;

        }

        public bool NewDocument()

        {

            ResetDocument();

            View.ResetView();

            Owner.Text = "Unnamed.level - Burutaru Editor";

            return true;

        }

        public bool LoadDocument(String filename)

        {

            ResetDocument();

            mFilename = filename;

            // fill mLevelElements from file

            if (!LevelUtil.LoadLevel(mFilename, this))

                return false;

            Owner.GlView.Refresh();

            Owner.Text = Path.GetFileName(mFilename) + " - Burutaru Editor";

            return true;

        }

        public bool SaveDocument()

        {

            // save mLevelElements

            if (!LevelUtil.SaveLevel(mFilename, this))

                return false;

            Owner.Text = Path.GetFileName(mFilename) + " - Burutaru Editor";

            SetDirty(false);

            return true;

        }

        public bool SaveDocument(String filename)

        {

            mFilename = filename;

            return SaveDocument();

        }

        public void CreateCheckPoint(float x, float y)

        {

            float tx; float ty;

            Owner.View.TransformToWorldSpace(out tx, out ty, x, y, true);

            CheckPoint cp = new CheckPoint(this, "NewCheckPoint");

            cp.Position.x = tx;

            cp.Position.y = ty;

            AddCheckPoint(cp);

        }

        public void AddCheckPoint(CheckPoint checkPoint)

        {

            mCheckPoints.Add(checkPoint);

            Owner.CheckPoints.Items.Add(checkPoint);

            Owner.CheckPoints.SelectedIndex = Owner.CheckPoints.Items.Count - 1;

        }

        public void CreateEnemySpawner(float x, float y)

        {

            float tx; float ty;

            Owner.View.TransformToWorldSpace(out tx, out ty, x, y);

            string className = Owner.CurrentSpawnerType;

            Type t = Type.GetType("BurutaruEditor.file.enemies." + className + "Spawner");

            Object[] args = { this, "New" + className };

            EnemySpawner sp = (EnemySpawner)Activator.CreateInstance(t, args);

            sp.SpawnTrigger.x = tx - View.CurrentPosition.x;

            sp.SpawnTrigger.y = ty - View.CurrentPosition.y;

            AddEnemySpawner(sp);

            /*Type t = Type.GetType("TestApp.Entry");

            Object[] args = { "emo", false };

            Object o = Activator.CreateInstance(t, args);*/

        }

        public void AddEnemySpawner(EnemySpawner spawner)

        {

            mSpawners.Add(spawner);

            Owner.Spawners.Items.Add(spawner);

            Owner.Spawners.SelectedIndex = Owner.Spawners.Items.Count - 1;

        }

        public void CreateScripting(float x, float y)

        {

            float tx; float ty;

            Owner.View.TransformToWorldSpace(out tx, out ty, x, y);

            string className = Owner.CurrentScriptingType;

            Type t = Type.GetType("BurutaruEditor.file.conditions." + className);

            Object[] args = { this, "New" + className };

            BaseCondition bc = (BaseCondition)Activator.CreateInstance(t, args);

            bc.Position.x = tx - View.CurrentPosition.x;

            bc.Position.y = ty - View.CurrentPosition.y;

            AddScripting(bc);

        }

        public void AddScripting(BaseCondition condition)

        {

            mScripting.Add(condition);

            Owner.Scripting.Items.Add(condition);

            Owner.Scripting.SelectedIndex = Owner.Scripting.Items.Count - 1;

        }

        public void CreateLevelElement(float x, float y, string filename)

        {

            float tx; float ty;

            Owner.View.TransformToWorldSpace(out tx, out ty, x, y);

            string className = Owner.CurrentElementType;

            if (className.Equals("BackgroundElement"))

            {

                BackgroundElement e = new BackgroundElement(this, "NewBackgroundElement");

                e.TextureFile = filename;

                e.Transform.x = tx - View.CurrentPosition.x;

                e.Transform.y = ty - View.CurrentPosition.y;

                e.Transform.w = e.Sprite.getSprite().getTextureWidth();

                e.Transform.h = e.Sprite.getSprite().getTextureHeight();

                e.Transform.centerPivot();

                AddLevelElement(e);

            }

            else if (className.Equals("StaticElement"))

            {

                StaticElement e = new StaticElement(this, "NewStaticElement");

                e.TextureFile = filename;

                e.Transform.x = tx - View.CurrentPosition.x;

                e.Transform.y = ty - View.CurrentPosition.y;

                e.Transform.w = e.Sprite.getSprite().getTextureWidth();

                e.Transform.h = e.Sprite.getSprite().getTextureHeight();

                e.Transform.centerPivot();

                AddLevelElement(e);

            }

            /*Type t = Type.GetType("BurutaruEditor.file.enemies." + className + "Spawner");

            Object[] args = { this, "New" + className };

            EnemySpawner sp = (EnemySpawner)Activator.CreateInstance(t, args);

            sp.SpawnTrigger.x = tx;

            sp.SpawnTrigger.y = ty;

            AddEnemySpawner(sp);*/

        }

        public LevelElement FindLevelElement(string name)

        {

            for (int i = 0; i < mLevelElements.Count; i++)

            {

                LevelElement e = mLevelElements.ElementAt(i);

                if (e.Name.Equals(name, StringComparison.OrdinalIgnoreCase))

                    return e;

            }

            return null;

        }

        public void AddLevelElement(LevelElement element)

        {

            mLevelElements.Add(element);

            Owner.LevelElements.Items.Add(element);

            Owner.LevelElements.SelectedIndex = Owner.LevelElements.Items.Count - 1;

        }

        public void DeleteCurrentObject()

        {

            if (Owner.CurrentObjectMode == MainForm.ObjectMode.CHECKPOINTS)

            {

                int i = Owner.CheckPoints.SelectedIndex;

                Owner.CheckPoints.Items.RemoveAt(i);

                mCheckPoints.RemoveAt(i);

                Owner.CheckPoints.SelectedIndex = Math.Min(i-1, Owner.CheckPoints.Items.Count - 1);

            }

            else if (Owner.CurrentObjectMode == MainForm.ObjectMode.SPAWNERS)

            {

                int i = Owner.Spawners.SelectedIndex;

                Owner.Spawners.Items.RemoveAt(i);

                mSpawners.RemoveAt(i);

                Owner.Spawners.SelectedIndex = Math.Min(i-1, Owner.Spawners.Items.Count - 1);

            }

            else if (Owner.CurrentObjectMode == MainForm.ObjectMode.ELEMENTS)

            {

                int i = Owner.LevelElements.SelectedIndex;

                Owner.LevelElements.Items.RemoveAt(i);

                mLevelElements.RemoveAt(i);

                Owner.LevelElements.SelectedIndex = Math.Min(i-1, Owner.LevelElements.Items.Count - 1);

            }

            else if (Owner.CurrentObjectMode == MainForm.ObjectMode.SCRIPTING)

            {

                int i = Owner.Scripting.SelectedIndex;

                Owner.Scripting.Items.RemoveAt(i);

                mScripting.RemoveAt(i);

                Owner.Scripting.SelectedIndex = Math.Min(i - 1, Owner.Scripting.Items.Count - 1);

            }

        }

        public void MoveObjectTo<T>(List<T> objList, System.Windows.Forms.ListBox lb, int fromIndex, int toIndex)

        {

            if ((fromIndex < 0) || (fromIndex >= objList.Count) ||

                (toIndex < 0) || (toIndex >= objList.Count))

                return;

            T cp = objList.ElementAt(fromIndex);

            objList.RemoveAt(fromIndex);

            objList.Insert(toIndex, cp);

            lb.Items.RemoveAt(fromIndex);

            lb.Items.Insert(toIndex, cp);

            lb.SelectedIndex = toIndex;

        }

        public void MoveObjectUp()

        {

            switch (Owner.CurrentObjectMode)

            {

                case MainForm.ObjectMode.CHECKPOINTS:

                    MoveObjectTo(mCheckPoints, Owner.CheckPoints, Owner.CheckPoints.SelectedIndex, Owner.CheckPoints.SelectedIndex - 1);

                    break;

                case MainForm.ObjectMode.SPAWNERS:

                    MoveObjectTo(mSpawners, Owner.Spawners, Owner.Spawners.SelectedIndex, Owner.Spawners.SelectedIndex - 1);

                    break;

                case MainForm.ObjectMode.ELEMENTS:

                    MoveObjectTo(mLevelElements, Owner.LevelElements, Owner.LevelElements.SelectedIndex, Owner.LevelElements.SelectedIndex - 1);

                    break;

                case MainForm.ObjectMode.SCRIPTING:

                    MoveObjectTo(mScripting, Owner.Scripting, Owner.Scripting.SelectedIndex, Owner.Scripting.SelectedIndex - 1);

                    break;

            }

        }

        public void MoveObjectDown()

        {

            switch (Owner.CurrentObjectMode)

            {

                case MainForm.ObjectMode.CHECKPOINTS:

                    MoveObjectTo(mCheckPoints, Owner.CheckPoints, Owner.CheckPoints.SelectedIndex, Owner.CheckPoints.SelectedIndex + 1);

                    break;

                case MainForm.ObjectMode.SPAWNERS:

                    MoveObjectTo(mSpawners, Owner.Spawners, Owner.Spawners.SelectedIndex, Owner.Spawners.SelectedIndex + 1);

                    break;

                case MainForm.ObjectMode.ELEMENTS:

                    MoveObjectTo(mLevelElements, Owner.LevelElements, Owner.LevelElements.SelectedIndex, Owner.LevelElements.SelectedIndex + 1);

                    break;

                case MainForm.ObjectMode.SCRIPTING:

                    MoveObjectTo(mScripting, Owner.Scripting, Owner.Scripting.SelectedIndex, Owner.Scripting.SelectedIndex + 1);

                    break;

            }

        }

        public void Cut()

        {

            if (View.SelectedObject != null)

            {

                mCopyPasteBuffer = LevelUtil.GetObjectData(View.SelectedObject, "Copy");

                mPasteOffset = PASTE_OFFSET;

                // TODO: remove selected object

            }

        }

        public void Copy()

        {

            if (View.SelectedObject != null)

            {

                mCopyPasteBuffer = LevelUtil.GetObjectData(View.SelectedObject, "Copy");

                mPasteOffset = PASTE_OFFSET;

            }

        }

        public void Paste()

        {

            if (mCopyPasteBuffer != null)

            {

                System.Console.WriteLine(mCopyPasteBuffer);

                LevelUtil.CreateObjectFromString(this, mCopyPasteBuffer);

                View.SelectedObject.MoveBy(mPasteOffset, mPasteOffset, -1);

                mPasteOffset += PASTE_OFFSET;

            }            

        }

        //=================================================================================================================================

        public string GetPropertiesTitle()

        {

            return "Level Parameters";

        }

        public string GetPropertiesType()

        {

            return "";

        }

        public void SetDirty(bool dirty)

        {

            mIsDirty = dirty;

        }

        public bool IsDirty()

        {

            return mIsDirty;

        }

        public String GetFilename()

        {

            return mFilename;

        }

        public void SetFilename(String filename)

        {

            mFilename = filename;

        }

        public bool IsFilenameSet()

        {

            return (mFilename != null);

        }

        public void WriteData(TextWriter tw)

        {

            LevelUtil.WriteProperty(tw, "name", LevelTitle);

            LevelUtil.WriteProperty(tw, "stage", StageTitle);

            LevelUtil.WriteProperty(tw, "startPosition", mStartPosition);

            LevelUtil.WriteProperty(tw, "warpIn", WarpIn);

            LevelUtil.WriteProperty(tw, "starFieldStatus", (int)StarFieldStatus);

            /*tw.WriteLine("name \"" + LevelTitle + "\";");

            tw.WriteLine("stage \"" + StageTitle + "\";");

            tw.WriteLine("startPosition " + mStartPosition.x + ", " + mStartPosition.y + ";");

            tw.WriteLine("warpIn " + (WarpIn ? "true" : "false") + ";");

            tw.WriteLine("\tstarFieldStatus " + (int)StarFieldStatus + ";");*/

        }        

        public bool ReadParameter(Tokenizer t, string id)

        {

            if (id.Equals("name", StringComparison.OrdinalIgnoreCase))

            {

                LevelTitle = t.readString();

            }

            else if (id.Equals("stage", StringComparison.OrdinalIgnoreCase))

            {

                StageTitle = t.readString();

            }

            else if (id.Equals("startPosition", StringComparison.OrdinalIgnoreCase))

            {

                mStartPosition = ParseUtil.readVector2(t);

            }

            else if (id.Equals("warpIn", StringComparison.OrdinalIgnoreCase))

            {

                WarpIn = t.readIdentifier().Equals("true", StringComparison.OrdinalIgnoreCase);

            }

            else if (id.Equals("starFieldStatus", StringComparison.OrdinalIgnoreCase))

            {

                int status = (int)t.readNumber();

                StarFieldStatus = (CheckPoint.StarFieldControlStatus)status;

            }

            else

            {

                // unsupported id

                return false;

            }

            t.readToken(";");

            return true;

        }

    }

}