Subversion Repositories AndroidProjects

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;
using System.IO;
using System.Globalization;

using BurutaruEditor.file.elements;
using BurutaruEditor.file.enemies;

using BauzoidNET.parser;
using BauzoidNET.math;

namespace BurutaruEditor.file
{
    public class LevelUtil
    {
        private LevelUtil() { }

        public static bool LoadLevel(String filename, Document doc)
        {
            string text = Preprocessor.stripComments(File.ReadAllText(filename));

            Tokenizer t = new Tokenizer(text);
            t.setStringDelimiter(new char[] { '\'', '"' });

            while (!t.checkNoMoreTokens())
                        {
                parseData(doc, t);
                                /*String identifier = t.readIdentifier();
                               
                                // name
                                if (doc.ReadParameter(t, identifier))
                                {
                                        continue;
                                }
                                // enemy spawnification
                                else if (identifier.Equals("spawn", StringComparison.OrdinalIgnoreCase))
                                {
                                        parseSpawnEnemy(doc, t);
                                }
                                else if (identifier.Equals("CheckPoint", StringComparison.OrdinalIgnoreCase))
                                {
                                        // check checkpoint objects
                                        parsecheckPoint(doc, t);
                                }
                                else
                                {
                                        // check condition objects
                                        /*if (parseConditionObject(levelData, t, identifier))
                                                continue;
                                       
                                        // check command objects
                                        if (parseLevelObject(levelData, t, identifier, BaseCommand.class))
                                                continue;
                    */
                /*

                    if (parseLevelElement(doc, t, identifier))
                        continue;
                                       
                                        //Gdx.app.log(LOG_TAG, identifier + " not found as applicable Level Object!");
                                        t.skipUntilAfterToken("}");
                                }*/
                        }

            return true;
        }

        public static bool parsecheckPoint(Document doc, Tokenizer tokenizer)
        {
            string checkPointName = tokenizer.readString();

            CheckPoint checkPoint = new CheckPoint(doc, checkPointName);

            tokenizer.readToken("{");
            while (!tokenizer.checkToken("}"))
            {
                String nextIdentifier = tokenizer.readIdentifier();
                checkPoint.ReadParameter(tokenizer, nextIdentifier);
            }
            tokenizer.readToken("}");

            doc.AddCheckPoint(checkPoint);

            return false;
        }

        public static void parseSpawnEnemy(Document doc, Tokenizer tokenizer)
            {
            string enemyType = tokenizer.readIdentifier();
            string enemyName = tokenizer.readString();

            // TODO: parse enemy spawn

            EnemySpawner enemy = EnemySpawner.createSpawner(doc, enemyType, enemyName);

            tokenizer.readToken("{");
            while (!tokenizer.checkToken("}"))
            {
                String nextIdentifier = tokenizer.readIdentifier();
                enemy.ReadParameter(tokenizer, nextIdentifier);
            }

            tokenizer.readToken("}");

            doc.AddEnemySpawner(enemy);
        }

        public static bool parseLevelElement(Document doc, Tokenizer t, string identifier)
        {
            if (!t.checkString())
                return false;

            int position = t.getPosition();
            string elementName = t.readString();

            LevelElement e = LevelElement.CreateElement(doc, identifier, elementName);
            if (e == null)
            {
                // not a level element
                t.setPosition(position);
                return false;
            }

            t.readToken("{");
            while (!t.checkToken("}"))
            {
                String nextIdentifier = t.readIdentifier();
                e.ReadParameter(t, nextIdentifier);
            }
            t.readToken("}");

            e.Init();

            doc.AddLevelElement(e);

            return true;
        }

        /*

        private static boolean parseConditionObject(LevelData levelData, Tokenizer tokenizer, String className) throws ScanException
        {
                Class<? extends BaseCondition> conditionClass = null;
               
                try
                {
                        conditionClass = Class.forName(BaseCondition.class.getPackage().getName() + "." + className).asSubclass(BaseCondition.class);
                }
                catch (ClassNotFoundException ex)
                {
                        // not a BaseCondition
                        return false;
                }
               
                String objectName = tokenizer.readString();
                BaseCondition instance = null;
               
                try
                {
                        instance = conditionClass.getDeclaredConstructor(Level.class, String.class).newInstance(levelData.getLevel(), objectName);
                }
                catch (Exception ex)
                {
                        throw new ScanException(Consts.LOG_TAG, ex.getLocalizedMessage() + " while instantiating " + className);
                }
               
                tokenizer.readToken("{");
                while (!tokenizer.checkToken("}"))
                {
                        String nextIdentifier = tokenizer.readIdentifier();
                        instance.readParameter(tokenizer, nextIdentifier);
                }
                tokenizer.readToken("}");
               
                levelData.addCondition(instance);
               
                return true;
        }
       
        */

        public static bool SaveLevelBinary(string filename, Document doc)
        {
            BinarySerializer s = new BinarySerializer(filename, Serializer.OpenMode.Write);

            for (int i = 0; i < doc.CheckPoints.Count; i++)
            {
                CheckPoint cp = doc.CheckPoints[i];

                s.Write("CheckPoint");
                s.Write(cp.Name);

                cp.WriteData(s);
            }

            for (int i = 0; i < doc.Spawners.Count; i++)
            {
                EnemySpawner es = doc.Spawners[i];

                s.Write("spawn");
                s.Write(es.GetPropertiesType());
                s.Write(es.Name);

                es.WriteData(s);

                /*tw.WriteLine("spawn " + es.GetPropertiesType() + " \"" + es.Name + "\"");
                tw.WriteLine("{");
                es.WriteData(tw);
                tw.WriteLine("}");
                tw.WriteLine("\r");*/
            }

            for (int i = 0; i < doc.LevelElements.Count; i++)
            {
                LevelElement le = doc.LevelElements[i];

                s.Write(le.GetPropertiesType());
                s.Write(le.Name);

                le.WriteData(s);

                /*tw.WriteLine(le.GetPropertiesType() + " \"" + le.Name + "\"");
                tw.WriteLine("{");
                le.WriteData(tw);
                tw.WriteLine("}");
                tw.WriteLine("\r");*/
            }

            s.Close();
            return true;
        }

        public static bool SaveLevel(String filename, Document doc)
        {
            TextWriter tw = new StreamWriter(filename);
           
            Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;

            doc.WriteData(tw);

            for (int i = 0; i < doc.CheckPoints.Count; i++)
            {
                CheckPoint cp = doc.CheckPoints[i];
               
                tw.WriteLine("CheckPoint \"" + cp.Name + "\"");
                tw.WriteLine("{");
                cp.WriteData(tw);
                tw.WriteLine("}");
                tw.WriteLine("\r");
            }

            for (int i = 0; i < doc.Spawners.Count; i++)
            {
                EnemySpawner es = doc.Spawners[i];
                tw.WriteLine("spawn " + es.GetPropertiesType() + " \"" + es.Name + "\"");
                tw.WriteLine("{");
                es.WriteData(tw);
                tw.WriteLine("}");
                tw.WriteLine("\r");
            }

            for (int i = 0; i < doc.LevelElements.Count; i++)
            {
                LevelElement le = doc.LevelElements[i];
                tw.WriteLine(le.GetPropertiesType() + " \"" + le.Name + "\"");
                tw.WriteLine("{");
                le.WriteData(tw);
                tw.WriteLine("}");
                tw.WriteLine("\r");
            }

            tw.Close();
            return true;
        }

        public static void parseData(Document doc, Tokenizer t)
        {
            String identifier = t.readIdentifier();

            // doc parameters
            if (doc.ReadParameter(t, identifier))
            {
                return;
            }
            // enemy spawnification
            if (identifier.Equals("spawn", StringComparison.OrdinalIgnoreCase))
            {
                parseSpawnEnemy(doc, t);
            }
            else if (identifier.Equals("CheckPoint", StringComparison.OrdinalIgnoreCase))
            {
                // check checkpoint objects
                parsecheckPoint(doc, t);
            }
            else
            {
                // check condition objects
                /*if (parseConditionObject(levelData, t, identifier))
                    return;
                                       
                // check command objects
                if (parseLevelObject(levelData, t, identifier, BaseCommand.class))
                    return;
                */

                if (parseLevelElement(doc, t, identifier))
                    return;

                //Gdx.app.log(LOG_TAG, identifier + " not found as applicable Level Object!");
                t.skipUntilAfterToken("}");
            }
        }


        public static void CreateObjectFromString(Document doc, string data)
        {
            Tokenizer t = new Tokenizer(data);
            parseData(doc, t);
        }


        public static string GetObjectData(LevelObject obj, string nameAttach = "")
        {
            MemoryStream memoryStream = new MemoryStream();
            TextWriter tw = new StreamWriter(memoryStream);

            if (obj is CheckPoint)
            {
                tw.WriteLine("CheckPoint \"" + obj.Name + nameAttach + "\"");
            }
            else if (obj is EnemySpawner)
            {
                tw.WriteLine("spawn " + obj.GetPropertiesType() + " \"" + obj.Name + nameAttach + "\"");
            }
            else if (obj is LevelElement)
            {
                tw.WriteLine(obj.GetPropertiesType() + " \"" + obj.Name + nameAttach + "\"");
            }

            tw.WriteLine("{");
            obj.WriteData(tw);
            tw.WriteLine("}");

            tw.Flush();

            string result = Encoding.ASCII.GetString(memoryStream.ToArray());

            memoryStream.Close();

            return result;
        }


        public static void WriteProperty(TextWriter tw, string id, float value, int numTabs = 0)
        {
            for (int i = 0; i < numTabs; i++)
                tw.Write("\t");

            tw.WriteLine(id + " " + value.ToString("F") + ";");
        }

        public static void WriteProperty(TextWriter tw, string id, int value, int numTabs = 0)
        {
            for (int i = 0; i < numTabs; i++)
                tw.Write("\t");

            tw.WriteLine(id + " " + value + ";");
        }

        public static void WriteProperty(TextWriter tw, string id, string value, int numTabs = 0)
        {
            for (int i = 0; i < numTabs; i++)
                tw.Write("\t");

            tw.WriteLine(id + " \"" + value + "\";");
        }

        public static void WriteProperty(TextWriter tw, string id, bool value, int numTabs = 0)
        {
            for (int i = 0; i < numTabs; i++)
                tw.Write("\t");

            tw.WriteLine(id + " " + (value ? "true" : "false") + ";");
        }

        public static void WriteProperty(TextWriter tw, string id, Vector2 value, int numTabs = 0)
        {
            for (int i = 0; i < numTabs; i++)
                tw.Write("\t");

            tw.WriteLine(id + " " + value.x.ToString("F") + ", " + value.y.ToString("F") + ";");
        }

    }
}