Exemplo n.º 1
0
                public void SaveUnitsGroup(LuaParser.Creator LuaFile)
                {
                    LuaFile.OpenTab(LuaParser.Write.PropertieToLua(Name) + LuaParser.Write.SetValue + "GROUP " + LuaParser.Write.OpenBracket);

                    if (!string.IsNullOrEmpty(Prefix))
                    {
                        LuaFile.AddLine(LuaParser.Write.StringToLua(KEY_PREFIX, Prefix));
                    }

                    LuaFile.AddLine(LuaParser.Write.StringToLua(KEY_ORDERS, orders));
                    LuaFile.AddLine(LuaParser.Write.StringToLua(KEY_PLATOON, platoon));


                    LuaFile.OpenTab(KEY_UNITS + LuaParser.Write.OpenBracketValue);
                    foreach (UnitsGroup g in UnitGroups)
                    {
                        g.SaveUnitsGroup(LuaFile);
                    }

                    foreach (Unit u in Units)
                    {
                        Unit.SaveUnit(LuaFile, u.Instance);
                    }


                    LuaFile.CloseTab(LuaParser.Write.EndBracketNext);

                    LuaFile.CloseTab(LuaParser.Write.EndBracketNext);
                }
Exemplo n.º 2
0
                public static void SaveUnit(LuaParser.Creator LuaFile, UnitInstance Instance)
                {
                    LuaFile.OpenTab(LuaParser.Write.PropertieToLua(Instance.gameObject.name) + LuaParser.Write.OpenBracketValue);

                    LuaFile.AddLine(LuaParser.Write.StringToLua(UnitsGroup.KEY_TYPE, Instance.UnitRenderer.BP.CodeName));
                    LuaFile.AddLine(LuaParser.Write.StringToLua(UnitsGroup.KEY_ORDERS, Instance.orders));
                    LuaFile.AddLine(LuaParser.Write.StringToLua(UnitsGroup.KEY_PLATOON, Instance.platoon));
                    LuaFile.AddLine(LuaParser.Write.Vector3ToLua(UnitsGroup.KEY_POSITION, ScmapEditor.WorldPosToScmap(Instance.transform.localPosition)));
                    LuaFile.AddLine(LuaParser.Write.Vector3ToLua(UnitsGroup.KEY_ORIENTATION, Instance.GetScmapRotation()));

                    LuaFile.CloseTab(LuaParser.Write.EndBracketNext);
                }
Exemplo n.º 3
0
            public void SaveArmy(LuaParser.Creator LuaFile, string ArmyName)
            {
                LuaFile.AddSaveComent("");
                LuaFile.AddSaveComent(ArmyName);
                LuaFile.AddSaveComent("");

                LuaFile.AddLine(LuaParser.Write.PropertieToLua(ArmyName) + LuaParser.Write.SetValue);
                LuaFile.OpenTab(LuaParser.Write.OpenBracket);

                LuaFile.AddLine(LuaParser.Write.StringToLua(KEY_PERSONALITY, personality));
                LuaFile.AddLine(LuaParser.Write.StringToLua(KEY_PLANS, plans));
                LuaFile.AddLine(LuaParser.Write.IntToLua(KEY_COLOR, color));
                LuaFile.AddLine(LuaParser.Write.IntToLua(KEY_FACTION, faction));

                // Economy
                LuaFile.OpenTab(KEY_ECONOMY + LuaParser.Write.OpenBracketValue);
                LuaFile.AddLine(LuaParser.Write.FloatToLua(EconomyTab.KEY_MASS, Economy.mass));
                LuaFile.AddLine(LuaParser.Write.FloatToLua(EconomyTab.KEY_ENERGY, Economy.energy));
                LuaFile.CloseTab(LuaParser.Write.EndBracketNext);

                // Aliances
                LuaFile.OpenTab(KEY_ALLIANCES + LuaParser.Write.OpenBracketValue);
                for (int a = 0; a < Alliances.Count; a++)
                {
                    if (Alliances[a].ConnectedArmy == null)
                    {
                        continue;
                    }

                    LuaFile.AddLine(LuaParser.Write.StringToLua(LuaParser.Write.PropertieToLua(Alliances[a].ConnectedArmy.Name), Alliances[a].AllianceType));
                }
                LuaFile.CloseTab(LuaParser.Write.EndBracketNext);

                // Units
                Units.SaveUnitsGroup(LuaFile);

                //Platoon Builders
                LuaFile.OpenTab(KEY_PLATOONBUILDERS + LuaParser.Write.OpenBracketValue);

                LuaFile.AddLine(LuaParser.Write.StringToLua(PlatoonBuilder.KEY_NEXTPLATOONBUILDERID, "1"));

                LuaFile.OpenTab(PlatoonBuilder.KEY_BUILDERS + LuaParser.Write.OpenBracketValue);
                for (int i = 0; i < PlatoonBuilders.Length; i++)
                {
                    PlatoonBuilders[i].SavePlatoonBuilder(LuaFile);
                }
                LuaFile.CloseTab(LuaParser.Write.EndBracketNext);

                LuaFile.CloseTab(LuaParser.Write.EndBracketNext);

                LuaFile.CloseTab(LuaParser.Write.EndBracketNext);
            }
Exemplo n.º 4
0
                public void SavePlatoonBuilder(LuaParser.Creator LuaFile)
                {
                    LuaFile.OpenTab(LuaParser.Write.PropertieToLua(Name) + LuaParser.Write.OpenBracketValue);

                    LuaFile.AddLine(LuaParser.Write.StringToLua(KEY_PLATOONTEMPLATE, PlatoonTemplate));
                    LuaFile.AddLine(LuaParser.Write.IntToLua(KEY_PLATOONTEMPLATE, Priority));
                    LuaFile.AddLine(LuaParser.Write.IntToLua(KEY_PLATOONTEMPLATE, InstanceCount));
                    LuaFile.AddLine(LuaParser.Write.StringToLua(KEY_PLATOONTEMPLATE, LocationType));
                    LuaFile.AddLine(LuaParser.Write.IntToLua(KEY_PLATOONTEMPLATE, BuildTimeOut));
                    LuaFile.AddLine(LuaParser.Write.StringToLua(KEY_PLATOONTEMPLATE, PlatoonType));
                    LuaFile.AddLine(LuaParser.Write.BoolToLua(KEY_PLATOONTEMPLATE, RequiresConstruction));

                    //TODO
                    LuaFile.CloseTab(LuaParser.Write.EndBracketNext);
                }
Exemplo n.º 5
0
        public void SaveArmys(LuaParser.Creator LuaFile)
        {
            for (int c = 0; c < Data.Configurations.Length; c++)
            {
                for (int t = 0; t < Data.Configurations[c].Teams.Length; t++)
                {
                    for (int a = 0; a < Data.Configurations[c].Teams[t].Armys.Count; a++)
                    {
                        if (Data.Configurations[c].Teams[t].Armys[a] != null)
                        {
                            Data.Configurations[c].Teams[t].Armys[a].Data.SaveArmy(LuaFile, Data.Configurations[c].Teams[t].Armys[a].Name);
                        }
                    }
                }

                for (int a = 0; a < Data.Configurations[c].ExtraArmys.Count; a++)
                {
                    if (Data.Configurations[c].ExtraArmys[a].Data != null)
                    {
                        Data.Configurations[c].ExtraArmys[a].Data.SaveArmy(LuaFile, Data.Configurations[c].ExtraArmys[a].Name);
                    }
                }
            }

            /*for(int a = 0; a < Data.Armies.Length; a++)
             * {
             *      LuaFile.AddSaveComent("");
             *      LuaFile.AddSaveComent("Army");
             *      LuaFile.AddSaveComent("");
             *
             *      LuaFile.AddLine(LuaParser.Write.PropertiveToLua(Data.Armies[a].Name) + LuaParser.Write.SetValue);
             *      LuaFile.OpenTab(LuaParser.Write.OpenBracket);
             *      {
             *              Data.Armies[a].SaveArmy(LuaFile);
             *
             *      }
             *      LuaFile.CloseTab(LuaParser.Write.EndBracketNext);
             * }*/
        }
Exemplo n.º 6
0
        public void Save(string Path)
        {
            LuaParser.Creator LuaFile = new LuaParser.Creator();

            LuaFile.AddSaveComent("");
            LuaFile.AddSaveComent("Generated by FAF Map Editor");
            LuaFile.AddSaveComent("");

            LuaFile.AddSaveComent("");
            LuaFile.AddSaveComent("Scenario");
            LuaFile.AddSaveComent("");

            LuaFile.AddLine(KEY_Scenario + LuaParser.Write.OpenBracketValue);
            {
                LuaFile.OpenTab();
                LuaFile.AddLine(LuaParser.Write.StringToLua(Scenario.KEY_NEXTAREAID, Data.next_area_id.ToString()));

                // Props
                LuaFile.AddSaveComent("");
                LuaFile.AddSaveComent("Props");
                LuaFile.AddSaveComent("");
                LuaFile.AddLine(Scenario.KEY_PROPS + LuaParser.Write.OpenBracketValue);
                LuaFile.AddLine(LuaParser.Write.EndBracketNext);

                // Areas
                LuaFile.AddSaveComent("");
                LuaFile.AddSaveComent("Areas");
                LuaFile.AddSaveComent("");
                LuaFile.OpenTab(Scenario.KEY_AREAS + LuaParser.Write.OpenBracketValue);
                {
                    for (int a = 0; a < Data.areas.Length; a++)
                    {
                        LuaFile.OpenTab(LuaParser.Write.PropertieToLua(Data.areas[a].Name) + LuaParser.Write.OpenBracketValue);
                        LuaFile.AddLine(LuaParser.Write.RectangleToLua(LuaParser.Write.PropertieToLua(Areas.KEY_RECTANGLE), Data.areas[a].rectangle));
                        LuaFile.CloseTab(LuaParser.Write.EndBracketNext);
                    }
                }
                LuaFile.CloseTab(LuaParser.Write.EndBracketNext);


                //Markers
                GenerateAutoMarkers();

                LuaFile.AddSaveComent("");
                LuaFile.AddSaveComent("Markers");
                LuaFile.AddSaveComent("");
                LuaFile.OpenTab(Scenario.KEY_MASTERCHAIN + LuaParser.Write.OpenBracketValue);
                {
                    for (int mc = 0; mc < Data.MasterChains.Length; mc++)
                    {
                        LuaFile.OpenTab(LuaParser.Write.PropertieToLua(Data.MasterChains[mc].Name) + LuaParser.Write.OpenBracketValue);
                        {
                            LuaFile.OpenTab(MasterChain.KEY_MARKERS + LuaParser.Write.OpenBracketValue);
                            {
                                if (Data.MasterChains[mc].Markers == null)
                                {
                                    Data.MasterChains[mc].Markers = new List <Marker>();
                                }

                                int Mcount = Data.MasterChains[mc].Markers.Count;
                                for (int m = 0; m < Mcount; m++)
                                {
                                    //LuaFile.OpenTab(LuaParser.Write.PropertiveToLua(Data.MasterChains[mc].Markers[m].Name) + LuaParser.Write.OpenBracketValue);
                                    Data.MasterChains[mc].Markers[m].SaveMarkerValues(LuaFile);
                                    //LuaFile.CloseTab(LuaParser.Write.EndBracketNext);
                                }
                            }
                            LuaFile.CloseTab(LuaParser.Write.EndBracketNext);
                        }
                        LuaFile.CloseTab(LuaParser.Write.EndBracketNext);
                    }
                }
                LuaFile.CloseTab(LuaParser.Write.EndBracketNext);

                //Chains
                LuaFile.OpenTab(Scenario.KEY_CHAINS + LuaParser.Write.OpenBracketValue);
                {
                    for (int c = 0; c < Data.Chains.Length; c++)
                    {
                        Data.Chains[c].BakeMarkers();

                        LuaFile.OpenTab(LuaParser.Write.PropertieToLua(Data.Chains[c].Name) + LuaParser.Write.OpenBracketValue);
                        LuaFile.OpenTab(Chain.KEY_MARKERS + LuaParser.Write.OpenBracketValue);

                        for (int i = 0; i < Data.Chains[c].Markers.Length; i++)
                        {
                            LuaFile.AddLine("\"" + Data.Chains[c].Markers[i] + "\",");
                        }

                        LuaFile.CloseTab(LuaParser.Write.EndBracketNext);
                        LuaFile.CloseTab(LuaParser.Write.EndBracketNext);
                    }
                }
                LuaFile.CloseTab(LuaParser.Write.EndBracketNext);

                LuaFile.AddLine(LuaParser.Write.StringToLua(Scenario.KEY_NEXTQUEUEID, Data.next_queue_id.ToString()));

                //Orders
                LuaFile.AddSaveComent("");
                LuaFile.AddSaveComent("Orders");
                LuaFile.AddSaveComent("");
                LuaFile.OpenTab(Scenario.KEY_ORDERS + LuaParser.Write.OpenBracketValue);
                {
                    //Leave empty
                }
                LuaFile.CloseTab(LuaParser.Write.EndBracketNext);

                LuaFile.AddLine(LuaParser.Write.StringToLua(Scenario.KEY_NEXTPLATOONID, Data.next_platoon_id.ToString()));

                Debug.Log(Data.MasterChains[0].Markers.Count);

                //Platoons
                LuaFile.AddSaveComent("");
                LuaFile.AddSaveComent("Platoons");
                LuaFile.AddSaveComent("");
                LuaFile.OpenTab(Scenario.KEY_PLATOONS + LuaParser.Write.OpenBracketValue);
                {
                    for (int p = 0; p < Data.Platoons.Length; p++)
                    {
                        LuaFile.OpenTab(LuaParser.Write.PropertieToLua(Data.Platoons[p].Name) + LuaParser.Write.OpenBracketValue);
                        LuaFile.AddLine(LuaParser.Write.Coma + Data.Platoons[p].PlatoonName + LuaParser.Write.Coma + LuaParser.Write.NextValue);
                        LuaFile.AddLine(LuaParser.Write.Coma + Data.Platoons[p].PlatoonFunction + LuaParser.Write.Coma + LuaParser.Write.NextValue);

                        if (Data.Platoons[p].Action.Loaded)
                        {
                            string Action = LuaParser.Write.OpenBracket;
                            Action += LuaParser.Write.Coma + Data.Platoons[p].Action.Unit + LuaParser.Write.Coma + LuaParser.Write.NextValue + " ";
                            Action += Data.Platoons[p].Action.Unit.ToString() + LuaParser.Write.NextValue + " ";
                            Action += Data.Platoons[p].Action.count.ToString() + LuaParser.Write.NextValue + " ";
                            Action += LuaParser.Write.Coma + Data.Platoons[p].Action.Action + LuaParser.Write.Coma + LuaParser.Write.NextValue + " ";
                            Action += LuaParser.Write.Coma + Data.Platoons[p].Action.Formation + LuaParser.Write.Coma + LuaParser.Write.EndBracketNext + " ";
                            LuaFile.AddLine(Action);
                        }



                        LuaFile.CloseTab(LuaParser.Write.EndBracketNext);
                    }
                }
                LuaFile.CloseTab(LuaParser.Write.EndBracketNext);


                LuaFile.AddLine(LuaParser.Write.StringToLua(Scenario.KEY_NEXTARMYID, Data.next_army_id.ToString()));
                LuaFile.AddLine(LuaParser.Write.StringToLua(Scenario.KEY_NEXTGROUPID, Data.next_group_id.ToString()));
                LuaFile.AddLine(LuaParser.Write.StringToLua(Scenario.KEY_NEXTUNITID, Data.next_unit_id.ToString()));

                //Armies
                LuaFile.AddSaveComent("");
                LuaFile.AddSaveComent("Armies");
                LuaFile.AddSaveComent("");
                LuaFile.OpenTab(Scenario.KEY_ARMIES + LuaParser.Write.OpenBracketValue);
                {
                    //for(int c = 0; c < MapLuaParser.Current.)
                    MapLuaParser.Current.ScenarioLuaFile.SaveArmys(LuaFile);

                    /*for(int a = 0; a < Data.Armies.Length; a++)
                     * {
                     *      LuaFile.AddSaveComent("");
                     *      LuaFile.AddSaveComent("Army");
                     *      LuaFile.AddSaveComent("");
                     *
                     *      LuaFile.AddLine(LuaParser.Write.PropertiveToLua(Data.Armies[a].Name) + LuaParser.Write.SetValue);
                     *      LuaFile.OpenTab(LuaParser.Write.OpenBracket);
                     *      {
                     *              Data.Armies[a].SaveArmy(LuaFile);
                     *
                     *      }
                     *      LuaFile.CloseTab(LuaParser.Write.EndBracketNext);
                     * }*/
                }
                LuaFile.CloseTab(LuaParser.Write.EndBracketNext);
            }
            LuaFile.CloseTab(LuaParser.Write.EndBracket);



            System.IO.File.WriteAllText(Path, LuaFile.GetFileString());
        }
Exemplo n.º 7
0
        public void Save(string Path)
        {
            LuaParser.Creator LuaFile = new LuaParser.Creator();
            LuaFile.AddLine("version = 3 -- Lua Version. Dont touch this");


            LuaFile.OpenTab(TABLE_SCENARIOINFO + LuaParser.Write.OpenBracketValue);
            {
                LuaFile.AddLine(LuaParser.Write.DescriptionToLua(ScenarioInfo.KEY_NAME, Data.name));
                LuaFile.AddLine(LuaParser.Write.DescriptionToLua(ScenarioInfo.KEY_DESCRIPTION, Data.description.Replace("\n", "\\n")));
                LuaFile.AddLine(LuaParser.Write.StringToLua(ScenarioInfo.KEY_PREVIEW, Data.preview));

                LuaFile.AddLine(LuaParser.Write.FloatToLua(ScenarioInfo.KEY_MAPVERSION, Data.map_version));
                Data.AdaptiveMap = MapLuaParser.Current.TablesLuaFile.IsLoaded;
                if (Data.AdaptiveMap)
                {
                    LuaFile.AddLine(LuaParser.Write.BoolToLua(ScenarioInfo.KEY_ADAPTIVEMAP, Data.AdaptiveMap));
                }
                LuaFile.AddLine(LuaParser.Write.StringToLua(ScenarioInfo.KEY_TYPE, Data.type));
                LuaFile.AddLine(LuaParser.Write.BoolToLua(ScenarioInfo.KEY_STARTS, Data.starts));

                LuaFile.AddLine(LuaParser.Write.IntArrayToLua(ScenarioInfo.KEY_SIZE, Data.Size));

                LuaFile.AddLine(LuaParser.Write.FloatArrayToLua(ScenarioInfo.KEY_RECLAIM, Data.Reclaim));

                LuaFile.AddLine(LuaParser.Write.StringToLua(ScenarioInfo.KEY_MAP, Data.map));
                LuaFile.AddLine(LuaParser.Write.StringToLua(ScenarioInfo.KEY_SAVE, Data.save));
                LuaFile.AddLine(LuaParser.Write.StringToLua(ScenarioInfo.KEY_SCRIPT, Data.script));
                LuaFile.AddLine(LuaParser.Write.FloatToLua(NoRusnOffset.VALUE_RADIUS, Data.norushradius));


                for (int c = 0; c < Data.Configurations.Length; c++)
                {
                    for (int t = 0; t < Data.Configurations[c].Teams.Length; t++)
                    {
                        for (int a = 0; a < Data.Configurations[c].Teams[t].Armys.Count; a++)
                        {
                            if (Data.Configurations[c].Teams[t].Armys[a].NoRush.X > 0)
                            {
                                LuaFile.AddLine(LuaParser.Write.FloatToLua(Data.Configurations[c].Teams[t].Armys[a].NoRush.GetXKey(Data.Configurations[c].Teams[t].Armys[a].Name), Data.Configurations[c].Teams[t].Armys[a].NoRush.X));
                            }
                            if (Data.Configurations[c].Teams[t].Armys[a].NoRush.Y > 0)
                            {
                                LuaFile.AddLine(LuaParser.Write.FloatToLua(Data.Configurations[c].Teams[t].Armys[a].NoRush.GetYKey(Data.Configurations[c].Teams[t].Armys[a].Name), Data.Configurations[c].Teams[t].Armys[a].NoRush.Y));
                            }
                        }
                    }
                }

                /*
                 * for(int i = 0; i < Data.NoRushOffsets.Length; i++)
                 * {
                 *      if(Data.NoRushOffsets[i].X > 0)
                 *              LuaFile.AddLine(LuaParser.Write.FloatToLua(Data.NoRushOffsets[i].GetXKey(), Data.NoRushOffsets[i].X));
                 *      if(Data.NoRushOffsets[i].Y > 0)
                 *              LuaFile.AddLine(LuaParser.Write.FloatToLua(Data.NoRushOffsets[i].GetYKey(), Data.NoRushOffsets[i].Y));
                 * }
                 */

                LuaFile.OpenTab(ScenarioInfo.KEY_CONFIGURATIONS + LuaParser.Write.OpenBracketValue);
                {                // Configurations
                    for (int Cf = 0; Cf < Data.Configurations.Length; Cf++)
                    {
                        LuaFile.OpenTab(LuaParser.Write.PropertieToLua(Data.Configurations[Cf].name) + LuaParser.Write.OpenBracketValue);
                        {                        // Configuration Tab
                            LuaFile.OpenTab(Configuration.KEY_TEAMS + LuaParser.Write.OpenBracketValue);
                            {                    //Teams
                                for (int T = 0; T < Data.Configurations[Cf].Teams.Length; T++)
                                {
                                    LuaFile.OpenTab(LuaParser.Write.OpenBracket);
                                    {                                    // Team Tab
                                        LuaFile.AddLine(LuaParser.Write.StringToLua(Team.KEY_NAME, Data.Configurations[Cf].Teams[T].name));
                                        LuaFile.AddLine(LuaParser.Write.StringArrayToLua(Team.KEY_ARMIES, Data.Configurations[Cf].Teams[T].GetArmys(), false));
                                    }
                                    LuaFile.CloseTab(LuaParser.Write.EndBracketNext);
                                }
                            }
                            LuaFile.CloseTab(LuaParser.Write.EndBracketNext);

                            LuaFile.OpenTab(Configuration.KEY_CUSTOMPROPS + LuaParser.Write.OpenBracketValue);
                            {                             // Custom Props
                                int ExtraCount = Data.Configurations[Cf].ExtraArmys.Count;
                                if (ExtraCount > 0)
                                {
                                    string ExtraArmyString = "";
                                    for (int i = 0; i < ExtraCount; i++)
                                    {
                                        if (i > 0)
                                        {
                                            ExtraArmyString += " ";
                                        }
                                        ExtraArmyString += Data.Configurations[Cf].ExtraArmys[i].Name;
                                    }

                                    LuaFile.AddLine(
                                        LuaParser.Write.ValueToLua(LuaParser.Write.PropertieToLua(ScenarioInfo.KEY_EXTRAARMIES),
                                                                   LuaParser.Write.StringFunction(ExtraArmyString),
                                                                   (Data.Configurations[Cf].customprops.Length > 0)
                                                                   ));
                                }


                                for (int i = 0; i < Data.Configurations[Cf].customprops.Length; i++)
                                {
                                    if (Data.Configurations[Cf].customprops[i].key == ScenarioInfo.KEY_EXTRAARMIES)
                                    {
                                        continue;
                                    }
                                    LuaFile.AddLine(
                                        LuaParser.Write.ValueToLua(LuaParser.Write.PropertieToLua(Data.Configurations[Cf].customprops[i].key),
                                                                   LuaParser.Write.StringFunction(Data.Configurations[Cf].customprops[i].value),
                                                                   (i < Data.Configurations[Cf].customprops.Length - 1)));
                                }
                            }
                            LuaFile.CloseTab(LuaParser.Write.EndBracketNext);


                            if (Data.Configurations[Cf].factions.Length > 0)
                            {
                                LuaFile.OpenTab(Configuration.KEY_FACTIONS + LuaParser.Write.OpenBracketValue);

                                for (int i = 0; i < Data.Configurations[Cf].factions.Length; i++)
                                {
                                    bool NotLast = i + 1 < Data.Configurations[Cf].factions.Length;
                                    LuaFile.AddLine(LuaParser.Write.StringArrayToLua(Data.Configurations[Cf].factions[i].Values, NotLast));
                                }

                                LuaFile.CloseTab(LuaParser.Write.EndBracketNext);
                            }
                        }
                        LuaFile.CloseTab(LuaParser.Write.EndBracketNext);
                    }
                }
                LuaFile.CloseTab(LuaParser.Write.EndBracketNext);
            }
            LuaFile.CloseTab(LuaParser.Write.EndBracket);


            System.IO.File.WriteAllText(Path, LuaFile.GetFileString());
        }
Exemplo n.º 8
0
            public void SaveMarkerValues(LuaParser.Creator LuaFile)
            {
                if (MarkerType == MarkerTypes.AutoPathNode)
                {
                    // Convert to Land/Amphibious/Naval markers

                    if (IsOnWater())
                    {                     // Water
                        for (int i = 0; i < AutoMarker_Water.AdjacentToMarker.Count; i++)
                        {
                            if (AutoMarker_Water.AdjacentToMarker[i].MarkerType == MarkerTypes.AutoPathNode)
                            {
                                if (AutoMarker_Water.AdjacentToMarker[i].AutoMarker_Water != null)
                                {
                                    AutoMarker_Water.AdjacentToMarker[i] = AutoMarker_Water.AdjacentToMarker[i].AutoMarker_Water;
                                }
                                else
                                {
                                    AutoMarker_Water.AdjacentToMarker.RemoveAt(i);
                                    i--;
                                }
                            }
                        }

                        AutoMarker_Water.SaveMarkerValues(LuaFile);
                    }
                    else
                    {                     // Land
                        for (int i = 0; i < AutoMarker_Land.AdjacentToMarker.Count; i++)
                        {
                            if (AutoMarker_Land.AdjacentToMarker[i].MarkerType == MarkerTypes.AutoPathNode)
                            {
                                if (AutoMarker_Land.AdjacentToMarker[i].AutoMarker_Land != null)
                                {
                                    AutoMarker_Land.AdjacentToMarker[i] = AutoMarker_Land.AdjacentToMarker[i].AutoMarker_Land;
                                }
                                else
                                {
                                    AutoMarker_Land.AdjacentToMarker.RemoveAt(i);
                                    i--;
                                }
                            }
                        }

                        AutoMarker_Land.SaveMarkerValues(LuaFile);
                    }

                    // Amphibious
                    for (int i = 0; i < AutoMarker_Amphibious.AdjacentToMarker.Count; i++)
                    {
                        if (AutoMarker_Amphibious.AdjacentToMarker[i].MarkerType == MarkerTypes.AutoPathNode)
                        {
                            if (AutoMarker_Amphibious.AdjacentToMarker[i].AutoMarker_Amphibious != null)
                            {
                                AutoMarker_Amphibious.AdjacentToMarker[i] = AutoMarker_Amphibious.AdjacentToMarker[i].AutoMarker_Amphibious;
                            }
                            else
                            {
                                AutoMarker_Amphibious.AdjacentToMarker.RemoveAt(i);
                                i--;
                            }
                        }
                    }

                    AutoMarker_Amphibious.SaveMarkerValues(LuaFile);
                }
                else
                {
                    if (MarkerObj != null)
                    {
                        position = ScmapEditor.WorldPosToScmap(MarkerObj.transform.position);
                        if (MarkerType != MarkerTypes.CameraInfo)
                        {
                            MarkerObj.transform.localRotation = Quaternion.identity;
                        }
                        orientation = Markers.MarkerObject.MarkerRotToScmapRot(MarkerObj.transform.localRotation, MarkerObj.Owner.MarkerType);
                    }

                    ForceDefaultValues();

                    LuaFile.OpenTab(LuaParser.Write.PropertieToLua(Name) + LuaParser.Write.OpenBracketValue);


                    if (AllowByType(KEY_SIZE))
                    {
                        LuaFile.AddLine(LuaParser.Write.FloatToLuaFunction(LuaParser.Write.PropertieToLua(KEY_SIZE), size));
                    }
                    if (AllowByType(KEY_RESOURCE))
                    {
                        LuaFile.AddLine(LuaParser.Write.BoolToLuaFunction(LuaParser.Write.PropertieToLua(KEY_RESOURCE), resource));
                    }
                    if (AllowByType(KEY_AMOUNT))
                    {
                        LuaFile.AddLine(LuaParser.Write.FloatToLuaFunction(LuaParser.Write.PropertieToLua(KEY_AMOUNT), amount));
                    }

                    LuaFile.AddLine(LuaParser.Write.StringToLuaFunction(LuaParser.Write.PropertieToLua(KEY_COLOR), color));

                    if (AllowByType(KEY_EDITORICON))
                    {
                        LuaFile.AddLine(LuaParser.Write.StringToLuaFunction(LuaParser.Write.PropertieToLua(KEY_EDITORICON), editorIcon));
                    }
                    if (AllowByType(KEY_HINT))
                    {
                        LuaFile.AddLine(LuaParser.Write.BoolToLuaFunction(LuaParser.Write.PropertieToLua(KEY_HINT), hint));
                    }

                    if (AllowByType(KEY_ADJACENTTO))
                    {
                        if (string.IsNullOrEmpty(graph))
                        {
                            switch (MarkerType)
                            {
                            case MarkerTypes.LandPathNode:
                                graph = "DefaultLand";
                                break;

                            case MarkerTypes.AmphibiousPathNode:
                                graph = "DefaultAmphibious";
                                break;

                            case MarkerTypes.WaterPathNode:
                                graph = "DefaultWater";
                                break;

                            case MarkerTypes.AirPathNode:
                                graph = "DefaultAir";
                                break;
                            }
                        }

                        LuaFile.AddLine(LuaParser.Write.StringToLuaFunction(LuaParser.Write.PropertieToLua(KEY_GRAPH), graph));


                        adjacentTo = "";
                        for (int i = 0; i < AdjacentToMarker.Count; i++)
                        {
                            if (i > 0)
                            {
                                adjacentTo += " ";
                            }

                            adjacentTo += AdjacentToMarker[i].Name;
                        }

                        LuaFile.AddLine(LuaParser.Write.StringToLuaFunction(LuaParser.Write.PropertieToLua(KEY_ADJACENTTO), adjacentTo));
                    }

                    //Type
                    LuaFile.AddLine(LuaParser.Write.StringToLuaFunction(LuaParser.Write.PropertieToLua(KEY_TYPE), MarkerTypeToString(MarkerType)));
                    LuaFile.AddLine(LuaParser.Write.StringToLuaFunction(LuaParser.Write.PropertieToLua(KEY_PROP), prop));

                    if (AllowByType(KEY_ZOOM))
                    {
                        LuaFile.AddLine(LuaParser.Write.FloatToLuaFunction(LuaParser.Write.PropertieToLua(KEY_ZOOM), zoom));
                    }
                    if (AllowByType(KEY_CANSETCAMERA))
                    {
                        LuaFile.AddLine(LuaParser.Write.BoolToLuaFunction(LuaParser.Write.PropertieToLua(KEY_CANSETCAMERA), canSetCamera));
                    }
                    if (AllowByType(KEY_CANSYNCCAMERA))
                    {
                        LuaFile.AddLine(LuaParser.Write.BoolToLuaFunction(LuaParser.Write.PropertieToLua(KEY_CANSYNCCAMERA), canSyncCamera));
                    }


                    if (AllowByType(KEY_OFFSET))
                    {
                        LuaFile.AddLine(LuaParser.Write.Vector3ToLuaFunction(LuaParser.Write.PropertieToLua(KEY_OFFSET), offset));
                    }
                    if (AllowByType(KEY_EFFECTTEMPLATE))
                    {
                        LuaFile.AddLine(LuaParser.Write.StringToLuaFunction(LuaParser.Write.PropertieToLua(KEY_EFFECTTEMPLATE), EffectTemplate));
                    }
                    if (AllowByType(KEY_SCALE))
                    {
                        LuaFile.AddLine(LuaParser.Write.FloatToLuaFunction(LuaParser.Write.PropertieToLua(KEY_SCALE), scale));
                    }

                    if (MarkerType == MarkerTypes.WeatherGenerator)
                    {
                        LuaFile.AddLine(LuaParser.Write.FloatToLuaFunction(LuaParser.Write.PropertieToLua(KEY_CLOUDCOUNT), cloudCount));
                        LuaFile.AddLine(LuaParser.Write.FloatToLuaFunction(LuaParser.Write.PropertieToLua(KEY_CLOUDCOUNTRANGE), cloudCountRange));

                        LuaFile.AddLine(LuaParser.Write.FloatToLuaFunction(LuaParser.Write.PropertieToLua(KEY_CLOUDEMITTERSCALE), cloudEmitterScale));
                        LuaFile.AddLine(LuaParser.Write.FloatToLuaFunction(LuaParser.Write.PropertieToLua(KEY_CLOUDEMITTERSCALERANGE), cloudEmitterScaleRange));

                        LuaFile.AddLine(LuaParser.Write.FloatToLuaFunction(LuaParser.Write.PropertieToLua(KEY_CLOUDHEIGHT), cloudHeight));
                        LuaFile.AddLine(LuaParser.Write.FloatToLuaFunction(LuaParser.Write.PropertieToLua(KEY_CLOUDHEIGHTRANGE), cloudHeightRange));

                        LuaFile.AddLine(LuaParser.Write.FloatToLuaFunction(LuaParser.Write.PropertieToLua(KEY_CLOUDSPREAD), cloudSpread));
                        LuaFile.AddLine(LuaParser.Write.FloatToLuaFunction(LuaParser.Write.PropertieToLua(KEY_SPAWNCHANCE), spawnChance));
                        LuaFile.AddLine(LuaParser.Write.StringToLuaFunction(LuaParser.Write.PropertieToLua(KEY_FORCETYPE), ForceType));
                    }
                    else if (MarkerType == MarkerTypes.WeatherDefinition)
                    {
                        LuaFile.AddLine(LuaParser.Write.Vector3ToLuaFunction(LuaParser.Write.PropertieToLua(KEY_WEATHERDRIFTDIRECTION), WeatherDriftDirection));
                        LuaFile.AddLine(LuaParser.Write.StringToLuaFunction(LuaParser.Write.PropertieToLua(KEY_MAPSTYLE), MapStyle));

                        LuaFile.AddLine(LuaParser.Write.StringToLuaFunction(LuaParser.Write.PropertieToLua(KEY_WEATHERTYPE01), WeatherType01));
                        LuaFile.AddLine(LuaParser.Write.StringToLuaFunction(LuaParser.Write.PropertieToLua(KEY_WEATHERTYPE02), WeatherType02));
                        LuaFile.AddLine(LuaParser.Write.StringToLuaFunction(LuaParser.Write.PropertieToLua(KEY_WEATHERTYPE03), WeatherType03));
                        LuaFile.AddLine(LuaParser.Write.StringToLuaFunction(LuaParser.Write.PropertieToLua(KEY_WEATHERTYPE04), WeatherType04));

                        LuaFile.AddLine(LuaParser.Write.FloatToLuaFunction(LuaParser.Write.PropertieToLua(KEY_WEATHERTYPE01CHANCE), WeatherType01Chance));
                        LuaFile.AddLine(LuaParser.Write.FloatToLuaFunction(LuaParser.Write.PropertieToLua(KEY_WEATHERTYPE02CHANCE), WeatherType02Chance));
                        LuaFile.AddLine(LuaParser.Write.FloatToLuaFunction(LuaParser.Write.PropertieToLua(KEY_WEATHERTYPE03CHANCE), WeatherType03Chance));
                        LuaFile.AddLine(LuaParser.Write.FloatToLuaFunction(LuaParser.Write.PropertieToLua(KEY_WEATHERTYPE04CHANCE), WeatherType04Chance));
                    }

                    //Transform
                    if (MarkerType == MarkerTypes.CameraInfo)
                    {
                        LuaFile.AddLine(LuaParser.Write.Vector3ToLuaFunctionPrecision(LuaParser.Write.PropertieToLua(KEY_ORIENTATION), orientation, true, 6));
                    }
                    else
                    {
                        LuaFile.AddLine(LuaParser.Write.Vector3ToLuaFunction(LuaParser.Write.PropertieToLua(KEY_ORIENTATION), orientation));
                    }

                    LuaFile.AddLine(LuaParser.Write.Vector3ToLuaFunction(LuaParser.Write.PropertieToLua(KEY_POSITION), position));

                    LuaFile.CloseTab(LuaParser.Write.EndBracketNext);
                }
            }
Exemplo n.º 9
0
        public void Save(string Path)
        {
            if (!IsLoaded)
            {
                return;
            }

            ScenarioLua.ScenarioInfo ScenarioData = MapLuaParser.Current.ScenarioLuaFile.Data;

            SaveLua.Marker[] AllMarkers = MarkersControler.GetMarkers();

            LuaParser.Creator LuaFile = new LuaParser.Creator();

            LuaFile.AddSaveComent("Generated by FAF Map Editor");
            LuaFile.AddComent("Table of which resources belong to which player, it is sorted in such a way that the first line");
            LuaFile.AddComent("corresponds to player one, the second to player 2 and so on...");
            LuaFile.NextLine(1);



            int ArmyId = 0;

            // Count armies
            for (int c = 0; c < ScenarioData.Configurations.Length; c++)
            {
                for (int t = 0; t < ScenarioData.Configurations[c].Teams.Length; t++)
                {
                    for (int a = 0; a < ScenarioData.Configurations[c].Teams[t].Armys.Count; a++)
                    {
                        if (ScenarioData.Configurations[c].Teams[t].Armys[a].Data != null)
                        {
                            ArmyId++;
                        }
                    }
                }
            }

            LuaFile.AddLine("maxPlayerOnMap" + LuaParser.Write.SetValue + ArmyId);
            LuaFile.NextLine(4);

            LuaFile.AddComent("Line number is 10 + armynumber for the mexes in the table");
            int ArmyCount = ArmyId;

            Data.spawnMexArmy   = new MexArray[ArmyCount];
            Data.spawnHydroArmy = new MexArray[ArmyCount];

            ArmyId = 0;
            // Create Mass table
            for (int c = 0; c < ScenarioData.Configurations.Length; c++)
            {
                for (int t = 0; t < ScenarioData.Configurations[c].Teams.Length; t++)
                {
                    for (int a = 0; a < ScenarioData.Configurations[c].Teams[t].Armys.Count; a++)
                    {
                        if (ScenarioData.Configurations[c].Teams[t].Armys[a].Data != null)
                        {
                            List <string> MarkerArrays = new List <string>();

                            for (int m = 0; m < AllMarkers.Length; m++)
                            {
                                if (AllMarkers[m].MarkerType == SaveLua.Marker.MarkerTypes.Mass && AllMarkers[m].SpawnWithArmy.Contains(ArmyId))
                                {
                                    MarkerArrays.Add(ConvertToTableName(AllMarkers[m].Name, MexName));
                                }
                            }

                            MarkerArrays.Sort();
                            Data.spawnMexArmy[ArmyId] = new MexArray(MarkerArrays.ToArray());

                            string ValueString = CreateTableValueString(MarkerArrays);

                            if (ArmyCount >= 16 && ArmyId == ArmyCount - 1)
                            {
                                ValueString += LuaParser.Write.EndBracket;
                            }
                            else
                            {
                                ValueString += ",";
                            }

                            if (ArmyId == 0)
                            {
                                LuaFile.OpenTab("spwnMexArmy" + LuaParser.Write.OpenBracketValue + "\t\t" + ValueString, 5);
                            }
                            else
                            {
                                LuaFile.AddLine(ValueString);
                            }
                            ArmyId++;
                        }
                    }
                }
            }
            if (ArmyCount < 16)
            {
                for (int a = ArmyId; a < 16; a++)
                {
                    if (a == 15)
                    {
                        LuaFile.AddLine(LuaParser.Write.OpenBracket + LuaParser.Write.EndBracket + LuaParser.Write.EndBracket);
                    }
                    else
                    {
                        LuaFile.AddLine(LuaParser.Write.OpenBracket + LuaParser.Write.EndBracketNext);
                    }
                }
            }

            LuaFile.CloseTab(5);

            LuaFile.NextLine(3);

            LuaFile.AddComent("Line number is 30 + armynumber for the hydros in the table");


            ArmyId = 0;
            // Create Hydro table
            for (int c = 0; c < ScenarioData.Configurations.Length; c++)
            {
                for (int t = 0; t < ScenarioData.Configurations[c].Teams.Length; t++)
                {
                    for (int a = 0; a < ScenarioData.Configurations[c].Teams[t].Armys.Count; a++)
                    {
                        if (ScenarioData.Configurations[c].Teams[t].Armys[a].Data != null)
                        {
                            List <string> MarkerArrays = new List <string>();

                            for (int m = 0; m < AllMarkers.Length; m++)
                            {
                                if (AllMarkers[m].MarkerType == SaveLua.Marker.MarkerTypes.Hydrocarbon && AllMarkers[m].SpawnWithArmy.Contains(ArmyId))
                                {
                                    MarkerArrays.Add(ConvertToTableName(AllMarkers[m].Name, HydroName));
                                }
                            }
                            MarkerArrays.Sort();
                            Data.spawnHydroArmy[ArmyId] = new MexArray(MarkerArrays.ToArray());

                            string ValueString = CreateTableValueString(MarkerArrays);

                            if (ArmyCount >= 16 && ArmyId == ArmyCount - 1)
                            {
                                ValueString += LuaParser.Write.EndBracket;
                            }
                            else
                            {
                                ValueString += ",";
                            }

                            if (ArmyId == 0)
                            {
                                LuaFile.OpenTab("spwnHydroArmy" + LuaParser.Write.OpenBracketValue + "\t" + ValueString, 5);
                            }
                            else
                            {
                                LuaFile.AddLine(ValueString);
                            }
                            ArmyId++;
                        }
                    }
                }
            }

            if (ArmyCount < 16)
            {
                for (int a = ArmyId; a < 16; a++)
                {
                    if (a == 15)
                    {
                        LuaFile.AddLine(LuaParser.Write.OpenBracket + LuaParser.Write.EndBracket + LuaParser.Write.EndBracket);
                    }
                    else
                    {
                        LuaFile.AddLine(LuaParser.Write.OpenBracket + LuaParser.Write.EndBracketNext);
                    }
                }
            }

            LuaFile.CloseTab(5);

            LuaFile.NextLine(2);

            LuaFile.AddComent("RESOURCE SCALING OPTIONS");
            LuaFile.AddComent("exampleMexes = {{1,2},{3,4},{5,6}},        -- exampleMexes = {{1,2}}");
            LuaFile.AddComent("exampleMexes = {{a},{b},{c}},              -- exampleMexes = {{a}}");
            LuaFile.AddComent("option key=1 : removes a+b+c               -- option key=1 : removes a");
            LuaFile.AddComent("option key=2 : spawn a, removes b+c        -- option key=2 : spawns a");
            LuaFile.AddComent("option key=3 : spawn a+b, removes c");
            LuaFile.AddComent("option key=4 : spawn a+b+c");
            LuaFile.NextLine(1);

            int TablesCount = Data.AllTables.Count;

            for (int t = 0; t < TablesCount; t++)
            {
                string TableString = Data.AllTables[t].Key + LuaParser.Write.SetValue;


                if (!Data.AllTables[t].OneDimension)
                {
                    TableString += LuaParser.Write.OpenBracket;
                }

                for (int v = 0; v < Data.AllTables[t].Values.Length; v++)
                {
                    string TableValueKey = Data.AllTables[t].Key;
                    if (!Data.AllTables[t].OneDimension)
                    {
                        TableValueKey += "#" + (v);
                    }

                    List <string> NewMexes = new List <string>();

                    for (int m = 0; m < AllMarkers.Length; m++)
                    {
                        if (Data.AllTables[t].IsHydro && AllMarkers[m].MarkerType == SaveLua.Marker.MarkerTypes.Hydrocarbon)
                        {                         // Hydro
                            if (AllMarkers[m].AdaptiveKeys.Contains(TableValueKey))
                            {
                                NewMexes.Add(ConvertToTableName(AllMarkers[m].Name, HydroName));
                            }
                        }
                        else
                        {                         // Mass
                            if (AllMarkers[m].AdaptiveKeys.Contains(TableValueKey))
                            {
                                NewMexes.Add(ConvertToTableName(AllMarkers[m].Name, MexName));
                            }
                        }
                    }

                    NewMexes.Sort();

                    Data.AllTables[t].Values[v] = new MexArray(NewMexes.ToArray());
                    if (v > 0)
                    {
                        TableString += LuaParser.Write.NextValue;
                    }

                    TableString += CreateTableValueString(NewMexes);
                }

                if (!Data.AllTables[t].OneDimension)
                {
                    TableString += LuaParser.Write.EndBracket;
                }



                LuaFile.AddLine(TableString);
                LuaFile.NextLine();
            }

            System.IO.File.WriteAllText(Path, LuaFile.GetFileString());
        }