tiberium/CnC_Remastered_Collection
Archived
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

C&C Remastered Map Editor

Browse source 
Initial commit of C&C Remastered Map Editor code
This commit is contained in:
PG-SteveT 2020-09-10 11:12:58 -07:00
parent 1f6350fe6e
commit e37e174be1
289 changed files with 80922 additions and 7 deletions
Download patch file Download diff file Expand all files Collapse all files

57
CnCTDRAMapEditor/TiberianDawn/ActionTypes.cs Normal file
View file

@ -0,0 +1,57 @@
//
// Copyright 2020 Electronic Arts Inc.
//
// The Command & Conquer Map Editor and corresponding source code is free
// software: you can redistribute it and/or modify it under the terms of
// the GNU General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
// The Command & Conquer Map Editor and corresponding source code is distributed
// in the hope that it will be useful, but with permitted additional restrictions
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
// distributed with this program. You should have received a copy of the
// GNU General Public License along with permitted additional restrictions
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
namespace MobiusEditor.TiberianDawn
{
public static class ActionTypes
{
public const string ACTION_NONE = "None";
public const string ACTION_WIN = "Win";
public const string ACTION_LOSE = "Lose";
public const string ACTION_BEGIN_PRODUCTION = "Production";
public const string ACTION_CREATE_TEAM = "Create Team";
public const string ACTION_DESTROY_TEAM = "Dstry Teams";
public const string ACTION_ALL_HUNT = "All to Hunt";
public const string ACTION_REINFORCEMENTS = "Reinforce.";
public const string ACTION_DZ = "DZ at 'Z'";
public const string ACTION_AIRSTRIKE = "Airstrike";
public const string ACTION_NUKE = "Nuclear Missile";
public const string ACTION_ION = "Ion Cannon";
public const string ACTION_DESTROY_XXXX = "Dstry Trig 'XXXX'";
public const string ACTION_DESTROY_YYYY = "Dstry Trig 'YYYY'";
public const string ACTION_DESTROY_ZZZZ = "Dstry Trig 'ZZZZ'";
public const string ACTION_AUTOCREATE = "Autocreate";
public const string ACTION_WINLOSE = "Cap=Win/Des=Lose";
public const string ACTION_ALLOWWIN = "Allow Win";
private static readonly string[] Types;
static ActionTypes()
{
Types =
(from field in typeof(ActionTypes).GetFields(BindingFlags.Static | BindingFlags.Public)
where field.IsLiteral && !field.IsInitOnly && typeof(string).IsAssignableFrom(field.FieldType)
select field.GetValue(null) as string).ToArray();
}
public static IEnumerable<string> GetTypes()
{
return Types;
}
}
}

25
CnCTDRAMapEditor/TiberianDawn/BasicSection.cs Normal file
View file

@ -0,0 +1,25 @@
//
// Copyright 2020 Electronic Arts Inc.
//
// The Command & Conquer Map Editor and corresponding source code is free
// software: you can redistribute it and/or modify it under the terms of
// the GNU General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
// The Command & Conquer Map Editor and corresponding source code is distributed
// in the hope that it will be useful, but with permitted additional restrictions
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
// distributed with this program. You should have received a copy of the
// GNU General Public License along with permitted additional restrictions
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
using System.ComponentModel;
namespace MobiusEditor.TiberianDawn
{
public class BasicSection : Model.BasicSection
{
private int buildLevel;
[DefaultValue(99)]
public int BuildLevel { get => buildLevel; set => SetField(ref buildLevel, value); }
}
}

101
CnCTDRAMapEditor/TiberianDawn/BuildingTypes.cs Normal file
View file

@ -0,0 +1,101 @@
//
// Copyright 2020 Electronic Arts Inc.
//
// The Command & Conquer Map Editor and corresponding source code is free
// software: you can redistribute it and/or modify it under the terms of
// the GNU General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
// The Command & Conquer Map Editor and corresponding source code is distributed
// in the hope that it will be useful, but with permitted additional restrictions
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
// distributed with this program. You should have received a copy of the
// GNU General Public License along with permitted additional restrictions
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
using MobiusEditor.Model;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Reflection;
namespace MobiusEditor.TiberianDawn
{
public static class BuildingTypes
{
public static readonly BuildingType Weapon = new BuildingType(0, "weap", "TEXT_STRUCTURE_TITLE_GDI_WEAPONS_FACTORY", new bool[3, 3] { { false, false, false }, { true, true, true }, { true, true, true } }, true, "Goodguy", false, false, "weap2");
public static readonly BuildingType GTower = new BuildingType(1, "gtwr", "TEXT_STRUCTURE_TITLE_GDI_GUARD_TOWER", new bool[1, 1] { { true } }, false, "Goodguy");
public static readonly BuildingType ATower = new BuildingType(2, "atwr", "TEXT_STRUCTURE_TITLE_GDI_ADV_GUARD_TOWER", new bool[2, 1] { { false }, { true } }, false, "Goodguy");
public static readonly BuildingType Obelisk = new BuildingType(3, "obli", "TEXT_STRUCTURE_TITLE_NOD_OBELISK", new bool[2, 1] { { false }, { true } }, false, "Badguy");
public static readonly BuildingType Command = new BuildingType(4, "hq", "TEXT_STRUCTURE_TITLE_GDI_COMM_CENTER", new bool[2, 2] { { true, false }, { true, true } }, true, "Goodguy");
public static readonly BuildingType Turret = new BuildingType(5, "gun", "TEXT_STRUCTURE_TITLE_NOD_TURRET", new bool[1, 1] { { true } }, false, "Badguy", false, true);
public static readonly BuildingType Const = new BuildingType(6, "fact", "TEXT_STRUCTURE_RA_FACT", new bool[2, 3] { { true, true, true }, { true, true, true } }, true, "Goodguy");
public static readonly BuildingType Refinery = new BuildingType(7, "proc", "TEXT_STRUCTURE_TITLE_GDI_REFINERY", new bool[3, 3] { { false, true, false }, { true, true, true }, { false, false, false } }, true, "Goodguy");
public static readonly BuildingType Storage = new BuildingType(8, "silo", "TEXT_STRUCTURE_TITLE_GDI_SILO", new bool[1, 2] { { true, true } }, true, "Goodguy");
public static readonly BuildingType Helipad = new BuildingType(9, "hpad", "TEXT_STRUCTURE_TITLE_GDI_HELIPAD", new bool[2, 2] { { true, true }, { true, true } }, true, "Goodguy");
public static readonly BuildingType SAM = new BuildingType(10, "sam", "TEXT_STRUCTURE_TITLE_NOD_SAM_SITE", new bool[1, 2] { { true, true } }, false, "Badguy");
public static readonly BuildingType AirStrip = new BuildingType(11, "afld", "TEXT_STRUCTURE_TITLE_NOD_AIRFIELD", new bool[2, 4] { { true, true, true, true }, { true, true, true, true } }, true, "Badguy");
public static readonly BuildingType Power = new BuildingType(12, "nuke", "TEXT_STRUCTURE_TITLE_GDI_POWER_PLANT", new bool[2, 2] { { true, false }, { true, true } }, true, "Goodguy");
public static readonly BuildingType AdvancedPower = new BuildingType(13, "nuk2", "TEXT_STRUCTURE_TITLE_GDI_ADV_POWER_PLANT", new bool[2, 2] { { true, false }, { true, true } }, true, "Goodguy");
public static readonly BuildingType Hospital = new BuildingType(14, "hosp", "TEXT_UNIT_TITLE_HOSP", new bool[2, 2] { { true, true }, { true, true } }, true, "Goodguy");
public static readonly BuildingType Barracks = new BuildingType(15, "pyle", "TEXT_STRUCTURE_TITLE_GDI_BARRACKS", new bool[2, 2] { { true, true }, { false, false } }, true, "Goodguy");
public static readonly BuildingType Tanker = new BuildingType(16, "arco", "TEXT_UNIT_TITLE_ARCO", new bool[1, 2] { { true, true } }, false, "Goodguy");
public static readonly BuildingType Repair = new BuildingType(17, "fix", "TEXT_STRUCTURE_TITLE_GDI_REPAIR_FACILITY", new bool[3, 3] { { false, true, false }, { true, true, true }, { false, true, false} }, true, "Goodguy");
public static readonly BuildingType BioLab = new BuildingType(18, "bio", "TEXT_UNIT_TITLE_BIO", new bool[2, 2] { { true, true }, { true, true } }, true, "Goodguy");
public static readonly BuildingType Hand = new BuildingType(19, "hand", "TEXT_STRUCTURE_TITLE_NOD_HAND_OF_NOD", new bool[3, 2] { { false, false }, { true, true }, { false, true } }, true, "Badguy");
public static readonly BuildingType Temple = new BuildingType(20, "tmpl", "TEXT_STRUCTURE_TITLE_NOD_TEMPLE_OF_NOD", new bool[3, 3] { { false, false, false }, { true, true, true }, { true, true, true } }, true, "Badguy");
public static readonly BuildingType Eye = new BuildingType(21, "eye", "TEXT_STRUCTURE_TITLE_GDI_ADV_COMM_CENTER", new bool[2, 2] { { true, false }, { true, true } }, true, "Goodguy");
public static readonly BuildingType Mission = new BuildingType(22, "miss", "TEXT_STRUCTURE_TITLE_CIV35", new bool[2, 3] { { true, true, true }, { true, true, true } }, true, "Goodguy");
public static readonly BuildingType V01 = new BuildingType(23, "v01", "TEXT_STRUCTURE_TITLE_CIV1", new bool[2, 2] { { false, false }, { true, true } }, false, "Neutral", new TheaterType[] { TheaterTypes.Temperate, TheaterTypes.Winter });
public static readonly BuildingType V02 = new BuildingType(24, "v02", "TEXT_STRUCTURE_TITLE_CIV2", new bool[2, 2] { { false, false }, { true, true } }, false, "Neutral", new TheaterType[] { TheaterTypes.Temperate, TheaterTypes.Winter });
public static readonly BuildingType V03 = new BuildingType(25, "v03", "TEXT_STRUCTURE_TITLE_CIV3", new bool[2, 2] { { false, true }, { true, true } }, false, "Neutral", new TheaterType[] { TheaterTypes.Temperate, TheaterTypes.Winter });
public static readonly BuildingType V04 = new BuildingType(26, "v04", "TEXT_STRUCTURE_TITLE_CIV4", new bool[2, 2] { { false, false }, { true, true } }, false, "Neutral", new TheaterType[] { TheaterTypes.Temperate, TheaterTypes.Winter });
public static readonly BuildingType V05 = new BuildingType(27, "v05", "TEXT_STRUCTURE_TITLE_CIV5", new bool[1, 2] { { true, true } }, false, "Neutral", new TheaterType[] { TheaterTypes.Temperate, TheaterTypes.Winter });
public static readonly BuildingType V06 = new BuildingType(28, "v06", "TEXT_STRUCTURE_TITLE_CIV6", new bool[1, 2] { { true, true } }, false, "Neutral", new TheaterType[] { TheaterTypes.Temperate, TheaterTypes.Winter });
public static readonly BuildingType V07 = new BuildingType(29, "v07", "TEXT_STRUCTURE_TITLE_CIV7", new bool[1, 2] { { true, true } }, false, "Neutral", new TheaterType[] { TheaterTypes.Temperate, TheaterTypes.Winter });
public static readonly BuildingType V08 = new BuildingType(30, "v08", "TEXT_STRUCTURE_TITLE_CIV8", new bool[1, 1] { { true } }, false, "Neutral", new TheaterType[] { TheaterTypes.Temperate, TheaterTypes.Winter });
public static readonly BuildingType V09 = new BuildingType(31, "v09", "TEXT_STRUCTURE_TITLE_CIV9", new bool[1, 1] { { true } }, false, "Neutral", new TheaterType[] { TheaterTypes.Temperate, TheaterTypes.Winter });
public static readonly BuildingType V10 = new BuildingType(32, "v10", "TEXT_STRUCTURE_TITLE_CIV10", new bool[1, 1] { { true } }, false, "Neutral", new TheaterType[] { TheaterTypes.Temperate, TheaterTypes.Winter });
public static readonly BuildingType V11 = new BuildingType(33, "v11", "TEXT_STRUCTURE_TITLE_CIV11", new bool[1, 1] { { true } }, false, "Neutral", new TheaterType[] { TheaterTypes.Temperate, TheaterTypes.Winter });
public static readonly BuildingType V12 = new BuildingType(34, "v12", "TEXT_STRUCTURE_TITLE_CIV12", new bool[1, 1] { { true } }, false, "Neutral", new TheaterType[] { TheaterTypes.Temperate });
public static readonly BuildingType V13 = new BuildingType(35, "v13", "TEXT_STRUCTURE_TITLE_CIV12", new bool[1, 1] { { true } }, false, "Neutral", new TheaterType[] { TheaterTypes.Temperate });
public static readonly BuildingType V14 = new BuildingType(36, "v14", "TEXT_STRUCTURE_TITLE_CIV13", new bool[1, 1] { { true } }, false, "Neutral", new TheaterType[] { TheaterTypes.Temperate, TheaterTypes.Winter });
public static readonly BuildingType V15 = new BuildingType(37, "v15", "TEXT_STRUCTURE_TITLE_CIV14", new bool[1, 1] { { true } }, false, "Neutral", new TheaterType[] { TheaterTypes.Temperate, TheaterTypes.Winter });
public static readonly BuildingType V16 = new BuildingType(38, "v16", "TEXT_STRUCTURE_TITLE_CIV15", new bool[1, 1] { { true } }, false, "Neutral", new TheaterType[] { TheaterTypes.Temperate, TheaterTypes.Winter });
public static readonly BuildingType V17 = new BuildingType(39, "v17", "TEXT_STRUCTURE_TITLE_CIV16", new bool[1, 1] { { true } }, false, "Neutral", new TheaterType[] { TheaterTypes.Temperate, TheaterTypes.Winter });
public static readonly BuildingType V18 = new BuildingType(40, "v18", "TEXT_STRUCTURE_TITLE_CIV17", new bool[1, 1] { { true } }, false, "Neutral", new TheaterType[] { TheaterTypes.Temperate, TheaterTypes.Winter });
public static readonly BuildingType V19 = new BuildingType(41, "v19", "TEXT_STRUCTURE_CIVILIAN_TITLE", new bool[1, 1] { { true } }, false, "Neutral");
public static readonly BuildingType V20 = new BuildingType(42, "v20", "TEXT_STRUCTURE_TITLE_CIV18", new bool[2, 2] { { false, false }, { true, true } }, false, "Neutral", new TheaterType[] { TheaterTypes.Desert });
public static readonly BuildingType V21 = new BuildingType(43, "v21", "TEXT_STRUCTURE_TITLE_CIV19", new bool[2, 2] { { true, true }, { false, true } }, false, "Neutral", new TheaterType[] { TheaterTypes.Desert });
public static readonly BuildingType V22 = new BuildingType(44, "v22", "TEXT_STRUCTURE_TITLE_CIV20", new bool[1, 2] { { true, true } }, false, "Neutral", new TheaterType[] { TheaterTypes.Desert });
public static readonly BuildingType V23 = new BuildingType(45, "v23", "TEXT_STRUCTURE_TITLE_CIV21", new bool[1, 1] { { true } }, false, "Neutral", new TheaterType[] { TheaterTypes.Desert });
public static readonly BuildingType V24 = new BuildingType(46, "v24", "TEXT_STRUCTURE_TITLE_CIV22", new bool[2, 2] { { false, false }, { true, true } }, false, "Neutral", new TheaterType[] { TheaterTypes.Desert });
public static readonly BuildingType V25 = new BuildingType(47, "v25", "TEXT_STRUCTURE_TITLE_CIV1", new bool[2, 2] { { false, true }, { true, true } }, false, "Neutral", new TheaterType[] { TheaterTypes.Desert });
public static readonly BuildingType V26 = new BuildingType(48, "v26", "TEXT_STRUCTURE_TITLE_CIV23", new bool[1, 2] { { true, true } }, false, "Neutral", new TheaterType[] { TheaterTypes.Desert });
public static readonly BuildingType V27 = new BuildingType(49, "v27", "TEXT_STRUCTURE_TITLE_CIV24", new bool[1, 1] { { true } }, false, "Neutral", new TheaterType[] { TheaterTypes.Desert });
public static readonly BuildingType V28 = new BuildingType(50, "v28", "TEXT_STRUCTURE_TITLE_CIV25", new bool[1, 1] { { true } }, false, "Neutral", new TheaterType[] { TheaterTypes.Desert });
public static readonly BuildingType V29 = new BuildingType(51, "v29", "TEXT_STRUCTURE_TITLE_CIV26", new bool[1, 1] { { true } }, false, "Neutral", new TheaterType[] { TheaterTypes.Desert });
public static readonly BuildingType V30 = new BuildingType(52, "v30", "TEXT_STRUCTURE_TITLE_CIV27", new bool[1, 2] { { true, true } }, false, "Neutral", new TheaterType[] { TheaterTypes.Desert });
public static readonly BuildingType V31 = new BuildingType(53, "v31", "TEXT_STRUCTURE_TITLE_CIV28", new bool[1, 2] { { true, true } }, false, "Neutral", new TheaterType[] { TheaterTypes.Desert });
public static readonly BuildingType V32 = new BuildingType(54, "v32", "TEXT_STRUCTURE_TITLE_CIV29", new bool[1, 2] { { true, true } }, false, "Neutral", new TheaterType[] { TheaterTypes.Desert });
public static readonly BuildingType V33 = new BuildingType(55, "v33", "TEXT_STRUCTURE_TITLE_CIV30", new bool[1, 2] { { true, true } }, false, "Neutral", new TheaterType[] { TheaterTypes.Desert });
public static readonly BuildingType V34 = new BuildingType(56, "v34", "TEXT_STRUCTURE_TITLE_CIV31", new bool[1, 1] { { true } }, false, "Neutral", new TheaterType[] { TheaterTypes.Desert });
public static readonly BuildingType V35 = new BuildingType(57, "v35", "TEXT_STRUCTURE_TITLE_CIV32", new bool[1, 1] { { true } }, false, "Neutral", new TheaterType[] { TheaterTypes.Desert });
public static readonly BuildingType V36 = new BuildingType(58, "v36", "TEXT_STRUCTURE_TITLE_CIV33", new bool[1, 1] { { true } }, false, "Neutral", new TheaterType[] { TheaterTypes.Desert });
public static readonly BuildingType V37 = new BuildingType(59, "v37", "TEXT_STRUCTURE_TITLE_CIV34", new bool[2, 4] { { false, true, true, true }, { false, true, true, true } }, false, "Neutral", new TheaterType[] { TheaterTypes.Desert });
private static readonly BuildingType[] Types;
static BuildingTypes()
{
Types =
(from field in typeof(BuildingTypes).GetFields(BindingFlags.Static | BindingFlags.Public)
where field.IsInitOnly && typeof(BuildingType).IsAssignableFrom(field.FieldType)
select field.GetValue(null) as BuildingType).ToArray();
}
public static IEnumerable<BuildingType> GetTypes()
{
return Types;
}
}
}

35
CnCTDRAMapEditor/TiberianDawn/Constants.cs Normal file
View file

@ -0,0 +1,35 @@
//
// Copyright 2020 Electronic Arts Inc.
//
// The Command & Conquer Map Editor and corresponding source code is free
// software: you can redistribute it and/or modify it under the terms of
// the GNU General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
// The Command & Conquer Map Editor and corresponding source code is distributed
// in the hope that it will be useful, but with permitted additional restrictions
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
// distributed with this program. You should have received a copy of the
// GNU General Public License along with permitted additional restrictions
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
using System;
using System.Drawing;
using System.IO;
namespace MobiusEditor.TiberianDawn
{
public static class Constants
{
public static readonly string SaveDirectory = Path.Combine(Globals.RootSaveDirectory, "Tiberian_Dawn");
public static readonly Size MaxSize = new Size(64, 64);
public const int MaxAircraft = 100;
public const int MaxBuildings = 500;
public const int MaxInfantry = 500;
public const int MaxTerrain = 500;
public const int MaxUnits = 500;
public const int MaxTeams = 60;
public const int MaxTriggers = 80;
}
}

56
CnCTDRAMapEditor/TiberianDawn/DirectionTypes.cs Normal file
View file

@ -0,0 +1,56 @@
//
// Copyright 2020 Electronic Arts Inc.
//
// The Command & Conquer Map Editor and corresponding source code is free
// software: you can redistribute it and/or modify it under the terms of
// the GNU General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
// The Command & Conquer Map Editor and corresponding source code is distributed
// in the hope that it will be useful, but with permitted additional restrictions
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
// distributed with this program. You should have received a copy of the
// GNU General Public License along with permitted additional restrictions
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
using MobiusEditor.Model;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
namespace MobiusEditor.TiberianDawn
{
public static class DirectionTypes
{
public static readonly DirectionType North = new DirectionType(0, "North", FacingType.North);
public static readonly DirectionType NorthNorthEast = new DirectionType(16, "North-NorthEast");
public static readonly DirectionType NorthEast = new DirectionType(32, "NorthEast", FacingType.NorthEast);
public static readonly DirectionType EastNorthEast = new DirectionType(48, "East-NorthEast");
public static readonly DirectionType East = new DirectionType(64, "East", FacingType.East);
public static readonly DirectionType EastSouthEast = new DirectionType(80, "East-SouthEast");
public static readonly DirectionType SouthEast = new DirectionType(96, "SouthEast", FacingType.SouthEast);
public static readonly DirectionType SouthSouthEast = new DirectionType(112, "South-SouthEast");
public static readonly DirectionType South = new DirectionType(128, "South", FacingType.South);
public static readonly DirectionType SouthSouthWest = new DirectionType(144, "South-SouthWest");
public static readonly DirectionType SouthWest = new DirectionType(160, "SouthWest", FacingType.SouthWest);
public static readonly DirectionType WestSouthWest = new DirectionType(176, "West-SouthWest");
public static readonly DirectionType West = new DirectionType(192, "West", FacingType.West);
public static readonly DirectionType WestNorthWest = new DirectionType(208, "West-NorthWest");
public static readonly DirectionType NorthWest = new DirectionType(224, "NorthWest", FacingType.NorthWest);
public static readonly DirectionType NorthNorthWest = new DirectionType(240, "North-NorthWest");
private static DirectionType[] Types;
static DirectionTypes()
{
Types =
(from field in typeof(DirectionTypes).GetFields(BindingFlags.Static | BindingFlags.Public)
where field.IsInitOnly && typeof(DirectionType).IsAssignableFrom(field.FieldType)
select field.GetValue(null) as DirectionType).ToArray();
}
public static IEnumerable<DirectionType> GetTypes()
{
return Types;
}
}
}

56
CnCTDRAMapEditor/TiberianDawn/EventTypes.cs Normal file
View file

@ -0,0 +1,56 @@
//
// Copyright 2020 Electronic Arts Inc.
//
// The Command & Conquer Map Editor and corresponding source code is free
// software: you can redistribute it and/or modify it under the terms of
// the GNU General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
// The Command & Conquer Map Editor and corresponding source code is distributed
// in the hope that it will be useful, but with permitted additional restrictions
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
// distributed with this program. You should have received a copy of the
// GNU General Public License along with permitted additional restrictions
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
namespace MobiusEditor.TiberianDawn
{
public static class EventTypes
{
public const string EVENT_NONE = "None";
public const string EVENT_PLAYER_ENTERED = "Player Enters";
public const string EVENT_DISCOVERED = "Discovered";
public const string EVENT_ATTACKED = "Attacked";
public const string EVENT_DESTROYED = "Destroyed";
public const string EVENT_ANY = "Any";
public const string EVENT_HOUSE_DISCOVERED = "House Discov.";
public const string EVENT_UNITS_DESTROYED = "Units Destr.";
public const string EVENT_BUILDINGS_DESTROYED = "Bldgs Destr.";
public const string EVENT_ALL_DESTROYED = "All Destr.";
public const string EVENT_CREDITS = "Credits";
public const string EVENT_TIME = "Time";
public const string EVENT_NBUILDINGS_DESTROYED = "# Bldgs Dstr.";
public const string EVENT_NUNITS_DESTROYED = "# Units Dstr.";
public const string EVENT_NOFACTORIES = "No Factories";
public const string EVENT_EVAC_CIVILIAN = "Civ. Evac.";
public const string EVENT_BUILD = "Built It";
private static readonly string[] Types;
static EventTypes()
{
Types =
(from field in typeof(EventTypes).GetFields(BindingFlags.Static | BindingFlags.Public)
where field.IsLiteral && !field.IsInitOnly && typeof(string).IsAssignableFrom(field.FieldType)
select field.GetValue(null) as string).ToArray();
}
public static IEnumerable<string> GetTypes()
{
return Types;
}
}
}

1344
CnCTDRAMapEditor/TiberianDawn/GamePlugin.cs Normal file
View file

File diff suppressed because it is too large Load diff

24
CnCTDRAMapEditor/TiberianDawn/House.cs Normal file
View file

@ -0,0 +1,24 @@
//
// Copyright 2020 Electronic Arts Inc.
//
// The Command & Conquer Map Editor and corresponding source code is free
// software: you can redistribute it and/or modify it under the terms of
// the GNU General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
// The Command & Conquer Map Editor and corresponding source code is distributed
// in the hope that it will be useful, but with permitted additional restrictions
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
// distributed with this program. You should have received a copy of the
// GNU General Public License along with permitted additional restrictions
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
namespace MobiusEditor.TiberianDawn
{
public class House : Model.House
{
public House(Model.HouseType type)
: base(type)
{
}
}
}

55
CnCTDRAMapEditor/TiberianDawn/HouseTypes.cs Normal file
View file

@ -0,0 +1,55 @@
//
// Copyright 2020 Electronic Arts Inc.
//
// The Command & Conquer Map Editor and corresponding source code is free
// software: you can redistribute it and/or modify it under the terms of
// the GNU General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
// The Command & Conquer Map Editor and corresponding source code is distributed
// in the hope that it will be useful, but with permitted additional restrictions
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
// distributed with this program. You should have received a copy of the
// GNU General Public License along with permitted additional restrictions
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
using MobiusEditor.Model;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
namespace MobiusEditor.TiberianDawn
{
public static class HouseTypes
{
public static readonly HouseType Good = new HouseType(0, "GoodGuy", "GOOD");
public static readonly HouseType Bad = new HouseType(1, "BadGuy", "BAD_UNIT", "BAD_STRUCTURE", ("harv", "BAD_STRUCTURE"), ("mcv", "BAD_STRUCTURE"));
public static readonly HouseType Neutral = new HouseType(2, "Neutral");
public static readonly HouseType Special = new HouseType(3, "Special");
public static readonly HouseType Multi1 = new HouseType(4, "Multi1", "MULTI1");
public static readonly HouseType Multi2 = new HouseType(5, "Multi2", "MULTI2");
public static readonly HouseType Multi3 = new HouseType(6, "Multi3", "MULTI3");
public static readonly HouseType Multi4 = new HouseType(7, "Multi4", "MULTI4");
public static readonly HouseType Multi5 = new HouseType(8, "Multi5", "MULTI5");
public static readonly HouseType Multi6 = new HouseType(9, "Multi6", "MULTI6");
private static readonly HouseType[] Types;
static HouseTypes()
{
Types =
(from field in typeof(HouseTypes).GetFields(BindingFlags.Static | BindingFlags.Public)
where field.IsInitOnly && typeof(HouseType).IsAssignableFrom(field.FieldType)
select field.GetValue(null) as HouseType).ToArray();
}
public static IEnumerable<HouseType> GetTypes()
{
return Types;
}
public static string GetBasePlayer(string player)
{
return Bad.Equals(player) ? Good.Name : Bad.Name;
}
}
}

60
CnCTDRAMapEditor/TiberianDawn/InfantryTypes.cs Normal file
View file

@ -0,0 +1,60 @@
//
// Copyright 2020 Electronic Arts Inc.
//
// The Command & Conquer Map Editor and corresponding source code is free
// software: you can redistribute it and/or modify it under the terms of
// the GNU General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
// The Command & Conquer Map Editor and corresponding source code is distributed
// in the hope that it will be useful, but with permitted additional restrictions
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
// distributed with this program. You should have received a copy of the
// GNU General Public License along with permitted additional restrictions
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
using MobiusEditor.Model;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
namespace MobiusEditor.TiberianDawn
{
public static class InfantryTypes
{
public static readonly InfantryType E1 = new InfantryType(0, "e1", "TEXT_UNIT_TITLE_GDI_MINIGUNNER", "Goodguy");
public static readonly InfantryType E2 = new InfantryType(1, "e2", "TEXT_UNIT_TITLE_GDI_GRENADIER", "Goodguy");
public static readonly InfantryType E3 = new InfantryType(2, "e3", "TEXT_UNIT_TITLE_GDI_ROCKET_SOLDIER", "Badguy");
public static readonly InfantryType E4 = new InfantryType(3, "e4", "TEXT_UNIT_TITLE_NOD_FLAMETHROWER", "Badguy");
public static readonly InfantryType E5 = new InfantryType(4, "e5", "TEXT_UNIT_TITLE_NOD_CHEM_WARRIOR", "Badguy");
public static readonly InfantryType E7 = new InfantryType(5, "e6", "TEXT_UNIT_TITLE_GDI_ENGINEER", "Goodguy");
public static readonly InfantryType Commando = new InfantryType(6, "rmbo", "TEXT_UNIT_TITLE_GDI_COMMANDO", "Goodguy");
public static readonly InfantryType C1 = new InfantryType(7, "c1", "TEXT_UNIT_TITLE_CIV1", "Neutral");
public static readonly InfantryType C2 = new InfantryType(8, "c2", "TEXT_UNIT_TITLE_CIV2", "Neutral");
public static readonly InfantryType C3 = new InfantryType(9, "c3", "TEXT_UNIT_TITLE_CIV3", "Neutral");
public static readonly InfantryType C4 = new InfantryType(10, "c4", "TEXT_UNIT_TITLE_CIV4", "Neutral");
public static readonly InfantryType C5 = new InfantryType(11, "c5", "TEXT_UNIT_TITLE_CIV5", "Neutral");
public static readonly InfantryType C6 = new InfantryType(12, "c6", "TEXT_UNIT_TITLE_CIV6", "Neutral");
public static readonly InfantryType C7 = new InfantryType(13, "c7", "TEXT_UNIT_TITLE_CIV7", "Neutral");
public static readonly InfantryType C8 = new InfantryType(14, "c8", "TEXT_UNIT_TITLE_CIV8", "Neutral");
public static readonly InfantryType C9 = new InfantryType(15, "c9", "TEXT_UNIT_TITLE_CIV9", "Neutral");
public static readonly InfantryType C10 = new InfantryType(16, "c10", "TEXT_UNIT_TITLE_C10", "Neutral");
public static readonly InfantryType Moebius = new InfantryType(17, "moebius", "TEXT_UNIT_TITLE_MOEBIUS", "Neutral");
public static readonly InfantryType Delphi = new InfantryType(18, "delphi", "TEXT_UNIT_TITLE_DELPHI", "Neutral");
public static readonly InfantryType DrChan = new InfantryType(19, "chan", "TEXT_UNIT_TITLE_CHAN", "Neutral");
private static readonly InfantryType[] Types;
static InfantryTypes()
{
Types =
(from field in typeof(InfantryTypes).GetFields(BindingFlags.Static | BindingFlags.Public)
where field.IsInitOnly && typeof(InfantryType).IsAssignableFrom(field.FieldType)
select field.GetValue(null) as InfantryType).ToArray();
}
public static IEnumerable<InfantryType> GetTypes()
{
return Types;
}
}
}

52
CnCTDRAMapEditor/TiberianDawn/MissionTypes.cs Normal file
View file

@ -0,0 +1,52 @@
//
// Copyright 2020 Electronic Arts Inc.
//
// The Command & Conquer Map Editor and corresponding source code is free
// software: you can redistribute it and/or modify it under the terms of
// the GNU General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
// The Command & Conquer Map Editor and corresponding source code is distributed
// in the hope that it will be useful, but with permitted additional restrictions
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
// distributed with this program. You should have received a copy of the
// GNU General Public License along with permitted additional restrictions
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
using System.Collections.Generic;
namespace MobiusEditor.TiberianDawn
{
public static class MissionTypes
{
private static readonly string[] Types = new string[]
{
"Sleep",
"Attack",
"Move",
"Retreat",
"Guard",
"Sticky",
"Enter",
"Capture",
"Harvest",
"Area Guard",
"Return",
"Stop",
"Ambush",
"Hunt",
"Timed Hunt",
"Unload",
"Sabotage",
"Construction",
"Selling",
"Repair",
"Rescue",
"Missile"
};
public static IEnumerable<string> GetTypes()
{
return Types;
}
}
}

67
CnCTDRAMapEditor/TiberianDawn/OverlayTypes.cs Normal file
View file

@ -0,0 +1,67 @@
//
// Copyright 2020 Electronic Arts Inc.
//
// The Command & Conquer Map Editor and corresponding source code is free
// software: you can redistribute it and/or modify it under the terms of
// the GNU General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
// The Command & Conquer Map Editor and corresponding source code is distributed
// in the hope that it will be useful, but with permitted additional restrictions
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
// distributed with this program. You should have received a copy of the
// GNU General Public License along with permitted additional restrictions
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
using MobiusEditor.Model;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
namespace MobiusEditor.TiberianDawn
{
public static class OverlayTypes
{
public static readonly OverlayType Sandbag = new OverlayType(1, "sbag", "TEXT_STRUCTURE_TITLE_GDI_SANDBAGS", OverlayTypeFlag.Wall);
public static readonly OverlayType Cyclone = new OverlayType(2, "cycl", "TEXT_STRUCTURE_TITLE_GDI_CHAIN_LINK", OverlayTypeFlag.Wall);
public static readonly OverlayType Brick = new OverlayType(3, "brik", "TEXT_STRUCTURE_TITLE_GDI_CONCRETE", OverlayTypeFlag.Wall);
public static readonly OverlayType Barbwire = new OverlayType(4, "barb", "TEXT_STRUCTURE_RA_BARB", OverlayTypeFlag.Wall);
public static readonly OverlayType Wood = new OverlayType(5, "wood", "TEXT_STRUCTURE_TD_WOOD", OverlayTypeFlag.Wall);
public static readonly OverlayType Tiberium1 = new OverlayType(6, "ti1", OverlayTypeFlag.TiberiumOrGold);
public static readonly OverlayType Tiberium2 = new OverlayType(7, "ti2", OverlayTypeFlag.TiberiumOrGold);
public static readonly OverlayType Tiberium3 = new OverlayType(8, "ti3", OverlayTypeFlag.TiberiumOrGold);
public static readonly OverlayType Tiberium4 = new OverlayType(9, "ti4", OverlayTypeFlag.TiberiumOrGold);
public static readonly OverlayType Tiberium5 = new OverlayType(10, "ti5", OverlayTypeFlag.TiberiumOrGold);
public static readonly OverlayType Tiberium6 = new OverlayType(11, "ti6", OverlayTypeFlag.TiberiumOrGold);
public static readonly OverlayType Tiberium7 = new OverlayType(12, "ti7", OverlayTypeFlag.TiberiumOrGold);
public static readonly OverlayType Tiberium8 = new OverlayType(13, "ti8", OverlayTypeFlag.TiberiumOrGold);
public static readonly OverlayType Tiberium9 = new OverlayType(14, "ti9", OverlayTypeFlag.TiberiumOrGold);
public static readonly OverlayType Tiberium10 = new OverlayType(15, "ti10", OverlayTypeFlag.TiberiumOrGold);
public static readonly OverlayType Tiberium11 = new OverlayType(16, "ti11", OverlayTypeFlag.TiberiumOrGold);
public static readonly OverlayType Tiberium12 = new OverlayType(17, "ti12", OverlayTypeFlag.TiberiumOrGold);
public static readonly OverlayType V12 = new OverlayType(20, "v12", "TEXT_STRUCTURE_TITLE_CIV12", new TheaterType[] { TheaterTypes.Temperate });
public static readonly OverlayType V13 = new OverlayType(21, "v13", "TEXT_STRUCTURE_TITLE_CIV12", new TheaterType[] { TheaterTypes.Temperate });
public static readonly OverlayType V14 = new OverlayType(22, "v14", "TEXT_STRUCTURE_TITLE_CIV13", new TheaterType[] { TheaterTypes.Temperate, TheaterTypes.Winter });
public static readonly OverlayType V15 = new OverlayType(23, "v15", "TEXT_STRUCTURE_TITLE_CIV14", new TheaterType[] { TheaterTypes.Temperate, TheaterTypes.Winter });
public static readonly OverlayType V16 = new OverlayType(24, "v16", "TEXT_STRUCTURE_TITLE_CIV15", new TheaterType[] { TheaterTypes.Temperate, TheaterTypes.Winter });
public static readonly OverlayType V17 = new OverlayType(25, "v17", "TEXT_STRUCTURE_TITLE_CIV16", new TheaterType[] { TheaterTypes.Temperate, TheaterTypes.Winter });
public static readonly OverlayType V18 = new OverlayType(26, "v18", "TEXT_STRUCTURE_TITLE_CIV17", new TheaterType[] { TheaterTypes.Temperate, TheaterTypes.Winter });
public static readonly OverlayType FlagSpot = new OverlayType(27, "fpls", OverlayTypeFlag.Flag);
public static readonly OverlayType WoodCrate = new OverlayType(28, "wcrate", OverlayTypeFlag.Crate);
public static readonly OverlayType SteelCrate = new OverlayType(29, "scrate", OverlayTypeFlag.Crate);
private static OverlayType[] Types;
static OverlayTypes()
{
Types =
(from field in typeof(OverlayTypes).GetFields(BindingFlags.Static | BindingFlags.Public)
where field.IsInitOnly && typeof(OverlayType).IsAssignableFrom(field.FieldType)
select field.GetValue(null) as OverlayType).ToArray();
}
public static IEnumerable<OverlayType> GetTypes()
{
return Types;
}
}
}

56
CnCTDRAMapEditor/TiberianDawn/SmudgeTypes.cs Normal file
View file

@ -0,0 +1,56 @@
//
// Copyright 2020 Electronic Arts Inc.
//
// The Command & Conquer Map Editor and corresponding source code is free
// software: you can redistribute it and/or modify it under the terms of
// the GNU General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
// The Command & Conquer Map Editor and corresponding source code is distributed
// in the hope that it will be useful, but with permitted additional restrictions
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
// distributed with this program. You should have received a copy of the
// GNU General Public License along with permitted additional restrictions
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
using MobiusEditor.Model;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Reflection;
namespace MobiusEditor.TiberianDawn
{
public static class SmudgeTypes
{
public static readonly SmudgeType Crater1 = new SmudgeType(0, "cr1");
public static readonly SmudgeType Crater2 = new SmudgeType(1, "cr2");
public static readonly SmudgeType Crater3 = new SmudgeType(2, "cr3");
public static readonly SmudgeType Crater4 = new SmudgeType(3, "cr4");
public static readonly SmudgeType Crater5 = new SmudgeType(4, "cr5");
public static readonly SmudgeType Crater6 = new SmudgeType(5, "cr6");
public static readonly SmudgeType Scorch1 = new SmudgeType(6, "sc1");
public static readonly SmudgeType Scorch2 = new SmudgeType(7, "sc2");
public static readonly SmudgeType Scorch3 = new SmudgeType(8, "sc3");
public static readonly SmudgeType Scorch4 = new SmudgeType(9, "sc4");
public static readonly SmudgeType Scorch5 = new SmudgeType(10, "sc5");
public static readonly SmudgeType Scorch6 = new SmudgeType(11, "sc6");
public static readonly SmudgeType Bib1 = new SmudgeType(12, "bib1", new Size(4, 2), SmudgeTypeFlag.Bib1);
public static readonly SmudgeType Bib2 = new SmudgeType(13, "bib2", new Size(3, 2), SmudgeTypeFlag.Bib2);
public static readonly SmudgeType Bib3 = new SmudgeType(14, "bib3", new Size(2, 2), SmudgeTypeFlag.Bib3);
private static SmudgeType[] Types;
static SmudgeTypes()
{
Types =
(from field in typeof(SmudgeTypes).GetFields(BindingFlags.Static | BindingFlags.Public)
where field.IsInitOnly && typeof(SmudgeType).IsAssignableFrom(field.FieldType)
select field.GetValue(null) as SmudgeType).ToArray();
}
public static IEnumerable<SmudgeType> GetTypes()
{
return Types;
}
}
}

42
CnCTDRAMapEditor/TiberianDawn/TeamMissionTypes.cs Normal file
View file

@ -0,0 +1,42 @@
//
// Copyright 2020 Electronic Arts Inc.
//
// The Command & Conquer Map Editor and corresponding source code is free
// software: you can redistribute it and/or modify it under the terms of
// the GNU General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
// The Command & Conquer Map Editor and corresponding source code is distributed
// in the hope that it will be useful, but with permitted additional restrictions
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
// distributed with this program. You should have received a copy of the
// GNU General Public License along with permitted additional restrictions
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
using System.Collections.Generic;
namespace MobiusEditor.TiberianDawn
{
public static class TeamMissionTypes
{
private static readonly string[] Types = new string[]
{
"Attack Base",
"Attack Units",
"Attack Civil.",
"Rampage",
"Defend Base",
"Move",
"Move to Cell",
"Retreat",
"Guard",
"Loop",
"Attack Tarcom",
"Unload"
};
public static IEnumerable<string> GetTypes()
{
return Types;
}
}
}

256
CnCTDRAMapEditor/TiberianDawn/TemplateTypes.cs Normal file
View file

@ -0,0 +1,256 @@
//
// Copyright 2020 Electronic Arts Inc.
//
// The Command & Conquer Map Editor and corresponding source code is free
// software: you can redistribute it and/or modify it under the terms of
// the GNU General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
// The Command & Conquer Map Editor and corresponding source code is distributed
// in the hope that it will be useful, but with permitted additional restrictions
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
// distributed with this program. You should have received a copy of the
// GNU General Public License along with permitted additional restrictions
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
using MobiusEditor.Model;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
namespace MobiusEditor.TiberianDawn
{
public static class TemplateTypes
{
public static readonly TemplateType Clear = new TemplateType(0, "clear1", 1, 1, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate }, TemplateTypeFlag.Clear);
public static readonly TemplateType Water = new TemplateType(1, "w1", 1, 1, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate, TheaterTypes.Desert });
public static readonly TemplateType Water2 = new TemplateType(2, "w2", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType Shore1 = new TemplateType(3, "sh1", 3, 3, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType Shore2 = new TemplateType(4, "sh2", 3, 3, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType Shore3 = new TemplateType(5, "sh3", 1, 1, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType Shore4 = new TemplateType(6, "sh4", 2, 1, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType Shore5 = new TemplateType(7, "sh5", 3, 3, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType Shore11 = new TemplateType(8, "sh11", 3, 3, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType Shore12 = new TemplateType(9, "sh12", 3, 3, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType Shore13 = new TemplateType(10, "sh13", 3, 3, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType Shore14 = new TemplateType(11, "sh14", 3, 3, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType Shore15 = new TemplateType(12, "sh15", 3, 3, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType Slope1 = new TemplateType(13, "s01", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope2 = new TemplateType(14, "s02", 2, 3, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope3 = new TemplateType(15, "s03", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope4 = new TemplateType(16, "s04", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope5 = new TemplateType(17, "s05", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope6 = new TemplateType(18, "s06", 2, 3, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope7 = new TemplateType(19, "s07", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope8 = new TemplateType(20, "s08", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope9 = new TemplateType(21, "s09", 3, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope10 = new TemplateType(22, "s10", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope11 = new TemplateType(23, "s11", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope12 = new TemplateType(24, "s12", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope13 = new TemplateType(25, "s13", 3, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope14 = new TemplateType(26, "s14", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope15 = new TemplateType(27, "s15", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope16 = new TemplateType(28, "s16", 2, 3, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope17 = new TemplateType(29, "s17", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope18 = new TemplateType(30, "s18", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope19 = new TemplateType(31, "s19", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope20 = new TemplateType(32, "s20", 2, 3, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope21 = new TemplateType(33, "s21", 1, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope22 = new TemplateType(34, "s22", 2, 1, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope23 = new TemplateType(35, "s23", 3, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope24 = new TemplateType(36, "s24", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope25 = new TemplateType(37, "s25", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope26 = new TemplateType(38, "s26", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope27 = new TemplateType(39, "s27", 3, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope28 = new TemplateType(40, "s28", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope29 = new TemplateType(41, "s29", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope30 = new TemplateType(42, "s30", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope31 = new TemplateType(43, "s31", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope32 = new TemplateType(44, "s32", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope33 = new TemplateType(45, "s33", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope34 = new TemplateType(46, "s34", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope35 = new TemplateType(47, "s35", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope36 = new TemplateType(48, "s36", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope37 = new TemplateType(49, "s37", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Slope38 = new TemplateType(50, "s38", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Shore32 = new TemplateType(51, "sh32", 3, 3, new TheaterType[] { TheaterTypes.Temperate, TheaterTypes.Winter });
public static readonly TemplateType Shore33 = new TemplateType(52, "sh33", 3, 3, new TheaterType[] { TheaterTypes.Temperate, TheaterTypes.Winter });
public static readonly TemplateType Shore20 = new TemplateType(53, "sh20", 4, 1, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore21 = new TemplateType(54, "sh21", 3, 1, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore22 = new TemplateType(55, "sh22", 6, 2, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore23 = new TemplateType(56, "sh23", 2, 2, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Brush1 = new TemplateType(57, "br1", 1, 1, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Brush2 = new TemplateType(58, "br2", 1, 1, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Brush3 = new TemplateType(59, "br3", 1, 1, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Brush4 = new TemplateType(60, "br4", 1, 1, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Brush5 = new TemplateType(61, "br5", 1, 1, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Brush6 = new TemplateType(62, "br6", 2, 2, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Brush7 = new TemplateType(63, "br7", 2, 2, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Brush8 = new TemplateType(64, "br8", 3, 2, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Brush9 = new TemplateType(65, "br9", 3, 2, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Brush10 = new TemplateType(66, "br10", 2, 1, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Patch1 = new TemplateType(67, "p01", 1, 1, new TheaterType[] { TheaterTypes.Temperate, TheaterTypes.Desert });
public static readonly TemplateType Patch2 = new TemplateType(68, "p02", 1, 1, new TheaterType[] { TheaterTypes.Temperate, TheaterTypes.Desert });
public static readonly TemplateType Patch3 = new TemplateType(69, "p03", 1, 1, new TheaterType[] { TheaterTypes.Temperate, TheaterTypes.Desert });
public static readonly TemplateType Patch4 = new TemplateType(70, "p04", 1, 1, new TheaterType[] { TheaterTypes.Temperate, TheaterTypes.Desert });
public static readonly TemplateType Patch5 = new TemplateType(71, "p05", 2, 2, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Patch6 = new TemplateType(72, "p06", 6, 4, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Patch7 = new TemplateType(73, "p07", 4, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate, TheaterTypes.Desert });
public static readonly TemplateType Patch8 = new TemplateType(74, "p08", 3, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate, TheaterTypes.Desert });
public static readonly TemplateType Shore16 = new TemplateType(75, "sh16", 3, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType Shore17 = new TemplateType(76, "sh17", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate, TheaterTypes.Desert });
public static readonly TemplateType Shore18 = new TemplateType(77, "sh18", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate, TheaterTypes.Desert });
public static readonly TemplateType Shore19 = new TemplateType(78, "sh19", 3, 2, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Patch13 = new TemplateType(79, "p13", 3, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType Patch14 = new TemplateType(80, "p14", 2, 1, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType Patch15 = new TemplateType(81, "p15", 4, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType Boulder1 = new TemplateType(82, "b1", 1, 1, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate, TheaterTypes.Desert });
public static readonly TemplateType Boulder2 = new TemplateType(83, "b2", 2, 1, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate, TheaterTypes.Desert });
public static readonly TemplateType Boulder3 = new TemplateType(84, "b3", 3, 1, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType Boulder4 = new TemplateType(85, "b4", 1, 1, new TheaterType[] { TheaterTypes.Temperate });
public static readonly TemplateType Boulder5 = new TemplateType(86, "b5", 1, 1, new TheaterType[] { TheaterTypes.Temperate });
public static readonly TemplateType Boulder6 = new TemplateType(87, "b6", 1, 1, new TheaterType[] { TheaterTypes.Temperate });
public static readonly TemplateType Shore6 = new TemplateType(88, "sh6", 3, 3, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType Shore7 = new TemplateType(89, "sh7", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType Shore8 = new TemplateType(90, "sh8", 3, 3, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType Shore9 = new TemplateType(91, "sh9", 3, 3, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType Shore10 = new TemplateType(92, "sh10", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType Road1 = new TemplateType(93, "d01", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road2 = new TemplateType(94, "d02", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road3 = new TemplateType(95, "d03", 1, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road4 = new TemplateType(96, "d04", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road5 = new TemplateType(97, "d05", 3, 4, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road6 = new TemplateType(98, "d06", 2, 3, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road7 = new TemplateType(99, "d07", 3, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road8 = new TemplateType(100, "d08", 3, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road9 = new TemplateType(101, "d09", 4, 3, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road10 = new TemplateType(102, "d10", 4, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road11 = new TemplateType(103, "d11", 2, 3, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road12 = new TemplateType(104, "d12", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road13 = new TemplateType(105, "d13", 4, 3, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road14 = new TemplateType(106, "d14", 3, 3, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road15 = new TemplateType(107, "d15", 3, 3, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road16 = new TemplateType(108, "d16", 3, 3, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road17 = new TemplateType(109, "d17", 3, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road18 = new TemplateType(110, "d18", 3, 3, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road19 = new TemplateType(111, "d19", 3, 3, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road20 = new TemplateType(112, "d20", 3, 3, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road21 = new TemplateType(113, "d21", 3, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road22 = new TemplateType(114, "d22", 3, 3, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road23 = new TemplateType(115, "d23", 3, 3, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road24 = new TemplateType(116, "d24", 3, 3, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road25 = new TemplateType(117, "d25", 3, 3, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road26 = new TemplateType(118, "d26", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road27 = new TemplateType(119, "d27", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road28 = new TemplateType(120, "d28", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road29 = new TemplateType(121, "d29", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road30 = new TemplateType(122, "d30", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road31 = new TemplateType(123, "d31", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road32 = new TemplateType(124, "d32", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road33 = new TemplateType(125, "d33", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road34 = new TemplateType(126, "d34", 3, 3, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road35 = new TemplateType(127, "d35", 3, 3, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road36 = new TemplateType(128, "d36", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road37 = new TemplateType(129, "d37", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road38 = new TemplateType(130, "d38", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road39 = new TemplateType(131, "d39", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road40 = new TemplateType(132, "d40", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road41 = new TemplateType(133, "d41", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road42 = new TemplateType(134, "d42", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Road43 = new TemplateType(135, "d43", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType River1 = new TemplateType(136, "rv01", 5, 4, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType River2 = new TemplateType(137, "rv02", 5, 3, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType River3 = new TemplateType(138, "rv03", 4, 4, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType River4 = new TemplateType(139, "rv04", 4, 4, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType River5 = new TemplateType(140, "rv05", 3, 3, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType River6 = new TemplateType(141, "rv06", 3, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType River7 = new TemplateType(142, "rv07", 3, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType River8 = new TemplateType(143, "rv08", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType River9 = new TemplateType(144, "rv09", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType River10 = new TemplateType(145, "rv10", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType River11 = new TemplateType(146, "rv11", 2, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType River12 = new TemplateType(147, "rv12", 3, 4, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType River13 = new TemplateType(148, "rv13", 4, 4, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType River14 = new TemplateType(149, "rv14", 4, 3, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType River15 = new TemplateType(150, "rv15", 4, 3, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType River16 = new TemplateType(151, "rv16", 6, 4, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType River17 = new TemplateType(152, "rv17", 6, 5, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType River18 = new TemplateType(153, "rv18", 4, 4, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType River19 = new TemplateType(154, "rv19", 4, 4, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType River20 = new TemplateType(155, "rv20", 6, 8, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType River21 = new TemplateType(156, "rv21", 5, 8, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType River22 = new TemplateType(157, "rv22", 3, 3, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType River23 = new TemplateType(158, "rv23", 3, 3, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType River24 = new TemplateType(159, "rv24", 3, 3, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType River25 = new TemplateType(160, "rv25", 3, 3, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Ford1 = new TemplateType(161, "ford1", 3, 3, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Ford2 = new TemplateType(162, "ford2", 3, 3, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Falls1 = new TemplateType(163, "falls1", 3, 3, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Falls2 = new TemplateType(164, "falls2", 3, 2, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Desert, TheaterTypes.Temperate });
public static readonly TemplateType Bridge1 = new TemplateType(165, "bridge1", 4, 4, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType Bridge1d = new TemplateType(166, "bridge1d", 4, 4, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType Bridge2 = new TemplateType(167, "bridge2", 5, 5, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType Bridge2d = new TemplateType(168, "bridge2d", 5, 5, new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate });
public static readonly TemplateType Bridge3 = new TemplateType(169, "bridge3", 6, 5, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Bridge3d = new TemplateType(170, "bridge3d", 6, 5, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Bridge4 = new TemplateType(171, "bridge4", 6, 4, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Bridge4d = new TemplateType(172, "bridge4d", 6, 4, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore24 = new TemplateType(173, "sh24", 3, 3, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore25 = new TemplateType(174, "sh25", 3, 2, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore26 = new TemplateType(175, "sh26", 3, 2, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore27 = new TemplateType(176, "sh27", 4, 1, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore28 = new TemplateType(177, "sh28", 3, 1, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore29 = new TemplateType(178, "sh29", 6, 2, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore30 = new TemplateType(179, "sh30", 2, 2, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore31 = new TemplateType(180, "sh31", 3, 3, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Patch16 = new TemplateType(181, "p16", 2, 2, new TheaterType[] { TheaterTypes.Winter });
public static readonly TemplateType Patch17 = new TemplateType(182, "p17", 4, 2, new TheaterType[] { TheaterTypes.Winter });
public static readonly TemplateType Patch18 = new TemplateType(183, "p18", 4, 3, new TheaterType[] { TheaterTypes.Winter });
public static readonly TemplateType Patch19 = new TemplateType(184, "p19", 4, 3, new TheaterType[] { TheaterTypes.Winter });
public static readonly TemplateType Patch20 = new TemplateType(185, "p20", 4, 3, new TheaterType[] { TheaterTypes.Winter });
public static readonly TemplateType Shore34 = new TemplateType(186, "sh34", 3, 3, new TheaterType[] { TheaterTypes.Temperate, TheaterTypes.Winter });
public static readonly TemplateType Shore35 = new TemplateType(187, "sh35", 3, 3, new TheaterType[] { TheaterTypes.Temperate, TheaterTypes.Winter });
public static readonly TemplateType Shore36 = new TemplateType(188, "sh36", 1, 1, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore37 = new TemplateType(189, "sh37", 1, 1, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore38 = new TemplateType(190, "sh38", 1, 1, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore39 = new TemplateType(191, "sh39", 1, 1, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore40 = new TemplateType(192, "sh40", 3, 3, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore41 = new TemplateType(193, "sh41", 3, 3, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore42 = new TemplateType(194, "sh42", 1, 2, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore43 = new TemplateType(195, "sh43", 1, 3, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore44 = new TemplateType(196, "sh44", 1, 3, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore45 = new TemplateType(197, "sh45", 1, 2, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore46 = new TemplateType(198, "sh46", 3, 3, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore47 = new TemplateType(199, "sh47", 3, 3, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore48 = new TemplateType(200, "sh48", 3, 3, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore49 = new TemplateType(201, "sh49", 3, 3, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore50 = new TemplateType(202, "sh50", 4, 3, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore51 = new TemplateType(203, "sh51", 4, 3, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore52 = new TemplateType(204, "sh52", 4, 3, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore53 = new TemplateType(205, "sh53", 4, 3, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore54 = new TemplateType(206, "sh54", 3, 2, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore55 = new TemplateType(207, "sh55", 3, 2, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore56 = new TemplateType(208, "sh56", 3, 2, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore57 = new TemplateType(209, "sh57", 3, 2, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore58 = new TemplateType(210, "sh58", 2, 3, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore59 = new TemplateType(211, "sh59", 2, 3, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore60 = new TemplateType(212, "sh60", 2, 3, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore61 = new TemplateType(213, "sh61", 2, 3, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore62 = new TemplateType(214, "sh62", 6, 1, new TheaterType[] { TheaterTypes.Desert });
public static readonly TemplateType Shore63 = new TemplateType(215, "sh63", 4, 1, new TheaterType[] { TheaterTypes.Desert });
private static TemplateType[] Types;
static TemplateTypes()
{
Types =
(from field in typeof(TemplateTypes).GetFields(BindingFlags.Static | BindingFlags.Public)
where field.IsInitOnly && typeof(TemplateType).IsAssignableFrom(field.FieldType)
select field.GetValue(null) as TemplateType).ToArray();
}
public static IEnumerable<TemplateType> GetTypes()
{
return Types;
}
}
}

72
CnCTDRAMapEditor/TiberianDawn/TerrainTypes.cs Normal file
View file

@ -0,0 +1,72 @@
//
// Copyright 2020 Electronic Arts Inc.
//
// The Command & Conquer Map Editor and corresponding source code is free
// software: you can redistribute it and/or modify it under the terms of
// the GNU General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
// The Command & Conquer Map Editor and corresponding source code is distributed
// in the hope that it will be useful, but with permitted additional restrictions
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
// distributed with this program. You should have received a copy of the
// GNU General Public License along with permitted additional restrictions
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
using MobiusEditor.Model;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
namespace MobiusEditor.TiberianDawn
{
public static class TerrainTypes
{
public static readonly TerrainType Tree1 = new TerrainType(0, "t01", new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate }, new bool[2, 2] { { false, false }, { true, false } });
public static readonly TerrainType Tree2 = new TerrainType(1, "t02", new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate }, new bool[2, 2] { { false, false }, { true, false } });
public static readonly TerrainType Tree3 = new TerrainType(2, "t03", new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate }, new bool[2, 2] { { false, false }, { true, false } });
public static readonly TerrainType Tree4 = new TerrainType(3, "t04", new TheaterType[] { TheaterTypes.Desert }, new bool[1, 1] { { true } });
public static readonly TerrainType Tree5 = new TerrainType(4, "t05", new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate }, new bool[2, 2] { { false, false }, { true, false } });
public static readonly TerrainType Tree6 = new TerrainType(5, "t06", new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate }, new bool[2, 2] { { false, false }, { true, false } });
public static readonly TerrainType Tree7 = new TerrainType(6, "t07", new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate }, new bool[2, 2] { { false, false }, { true, false } });
public static readonly TerrainType Tree8 = new TerrainType(7, "t08", new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate, TheaterTypes.Desert }, new bool[1, 2] { { true, false } });
public static readonly TerrainType Tree9 = new TerrainType(8, "t09", new TheaterType[] { TheaterTypes.Desert }, new bool[1, 2] { { true, false } });
public static readonly TerrainType Tree10 = new TerrainType(9, "t10", new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate }, new bool[2, 2] { { false, false }, { true, true } });
public static readonly TerrainType Tree11 = new TerrainType(10, "t11", new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate }, new bool[2, 2] { { false, false }, { true, true } });
public static readonly TerrainType Tree12 = new TerrainType(11, "t12", new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate }, new bool[2, 2] { { false, false }, { true, false } });
public static readonly TerrainType Tree13 = new TerrainType(12, "t13", new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate }, new bool[2, 2] { { false, false }, { true, false } });
public static readonly TerrainType Tree14 = new TerrainType(13, "t14", new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate }, new bool[2, 2] { { false, false }, { true, true } });
public static readonly TerrainType Tree15 = new TerrainType(14, "t15", new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate }, new bool[2, 2] { { false, false }, { true, true } });
public static readonly TerrainType Tree16 = new TerrainType(15, "t16", new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate }, new bool[2, 2] { { false, false }, { true, false } });
public static readonly TerrainType Tree17 = new TerrainType(16, "t17", new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate }, new bool[2, 2] { { false, false }, { true, false } });
public static readonly TerrainType Tree18 = new TerrainType(17, "t18", new TheaterType[] { TheaterTypes.Desert }, new bool[2, 3] { { false, false, false }, { false, true, false } });
public static readonly TerrainType Split1 = new TerrainType(18, "split2", new TheaterType[] { TheaterTypes.Temperate, TheaterTypes.Winter }, new bool[2, 2] { { false, false }, { true, false } }, true);
public static readonly TerrainType Split2 = new TerrainType(19, "split3", new TheaterType[] { TheaterTypes.Temperate, TheaterTypes.Winter, TheaterTypes.Desert }, new bool[2, 2] { { false, false }, { true, false } }, true);
public static readonly TerrainType Clump1 = new TerrainType(20, "tc01", new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate }, new bool[2, 3] { { false, false, false }, { true, true, false } });
public static readonly TerrainType Clump2 = new TerrainType(21, "tc02", new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate }, new bool[2, 3] { { false, true, false }, { true, true, false } });
public static readonly TerrainType Clump3 = new TerrainType(22, "tc03", new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate }, new bool[2, 3] { { true, true, false }, { true, true, false } });
public static readonly TerrainType Clump4 = new TerrainType(23, "tc04", new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate }, new bool[3, 4] { { false, false, false, false }, { true, true, true, false }, { true, false, false, false } });
public static readonly TerrainType Clump5 = new TerrainType(24, "tc05", new TheaterType[] { TheaterTypes.Winter, TheaterTypes.Temperate }, new bool[3, 4] { { false, false, true, false }, { true, true, true, false }, { false, true, true, false } });
public static readonly TerrainType Rock1 = new TerrainType(25, "rock1", new TheaterType[] { TheaterTypes.Desert }, new bool[2, 2] { { false, false }, { true, true } });
public static readonly TerrainType Rock2 = new TerrainType(26, "rock2", new TheaterType[] { TheaterTypes.Desert }, new bool[2, 2] { { true, true }, { false, false } });
public static readonly TerrainType Rock3 = new TerrainType(27, "rock3", new TheaterType[] { TheaterTypes.Desert }, new bool[2, 3] { { false, false, false }, { true, true, false } });
public static readonly TerrainType Rock4 = new TerrainType(28, "rock4", new TheaterType[] { TheaterTypes.Desert }, new bool[1, 2] { { true, false } });
public static readonly TerrainType Rock5 = new TerrainType(29, "rock5", new TheaterType[] { TheaterTypes.Desert }, new bool[1, 2] { { true, false } });
public static readonly TerrainType Rock6 = new TerrainType(30, "rock6", new TheaterType[] { TheaterTypes.Desert }, new bool[2, 3] { { false, false, false }, { true, true, true } });
public static readonly TerrainType Rock7 = new TerrainType(31, "rock7", new TheaterType[] { TheaterTypes.Desert }, new bool[1, 5] { { true, true, true, true, false } });
private static TerrainType[] Types;
static TerrainTypes()
{
Types =
(from field in typeof(TerrainTypes).GetFields(BindingFlags.Static | BindingFlags.Public)
where field.IsInitOnly && typeof(TerrainType).IsAssignableFrom(field.FieldType)
select field.GetValue(null) as TerrainType).ToArray();
}
public static IEnumerable<TerrainType> GetTypes()
{
return Types;
}
}
}

46
CnCTDRAMapEditor/TiberianDawn/TheaterTypes.cs Normal file
View file

@ -0,0 +1,46 @@
//
// Copyright 2020 Electronic Arts Inc.
//
// The Command & Conquer Map Editor and corresponding source code is free
// software: you can redistribute it and/or modify it under the terms of
// the GNU General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
// The Command & Conquer Map Editor and corresponding source code is distributed
// in the hope that it will be useful, but with permitted additional restrictions
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
// distributed with this program. You should have received a copy of the
// GNU General Public License along with permitted additional restrictions
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
using MobiusEditor.Model;
using MobiusEditor.Utility;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
namespace MobiusEditor.TiberianDawn
{
public static class TheaterTypes
{
private static readonly IEnumerable<string> commonTilesets = new string[] { "TD_Units", "TD_Structures", "TD_VFX", "Common_VFX" };
public static readonly TheaterType Desert = new TheaterType(0, "desert", "TD_Terrain_Desert".Yield().Concat(commonTilesets));
public static readonly TheaterType Temperate = new TheaterType(2, "temperate", "TD_Terrain_Temperate".Yield().Concat(commonTilesets));
public static readonly TheaterType Winter = new TheaterType(2, "winter", "TD_Terrain_Winter".Yield().Concat(commonTilesets));
private static TheaterType[] Types;
static TheaterTypes()
{
Types =
(from field in typeof(TheaterTypes).GetFields(BindingFlags.Static | BindingFlags.Public)
where field.IsInitOnly && typeof(TheaterType).IsAssignableFrom(field.FieldType)
select field.GetValue(null) as TheaterType).ToArray();
}
public static IEnumerable<TheaterType> GetTypes()
{
return Types;
}
}
}

69
CnCTDRAMapEditor/TiberianDawn/UnitTypes.cs Normal file
View file

@ -0,0 +1,69 @@
//
// Copyright 2020 Electronic Arts Inc.
//
// The Command & Conquer Map Editor and corresponding source code is free
// software: you can redistribute it and/or modify it under the terms of
// the GNU General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
// The Command & Conquer Map Editor and corresponding source code is distributed
// in the hope that it will be useful, but with permitted additional restrictions
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
// distributed with this program. You should have received a copy of the
// GNU General Public License along with permitted additional restrictions
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
using MobiusEditor.Model;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Reflection;
namespace MobiusEditor.TiberianDawn
{
public static class UnitTypes
{
public static readonly UnitType HTank = new UnitType(0, "htnk", "TEXT_UNIT_TITLE_GDI_MAMMOTH_TANK", "Goodguy", true);
public static readonly UnitType MTank = new UnitType(1, "mtnk", "TEXT_UNIT_TITLE_GDI_MED_TANK", "Goodguy", true);
public static readonly UnitType LTank = new UnitType(2, "ltnk", "TEXT_UNIT_TITLE_NOD_LIGHT_TANK", "Badguy", true);
public static readonly UnitType STank = new UnitType(3, "stnk", "TEXT_UNIT_TITLE_NOD_STEALTH_TANK", "Badguy");
public static readonly UnitType FTank = new UnitType(4, "ftnk", "TEXT_UNIT_TITLE_NOD_FLAME_TANK", "Badguy");
public static readonly UnitType Visceroid = new UnitType(5, "vice", "TEXT_UNIT_TITLE_VICE", "Special");
public static readonly UnitType APC = new UnitType(6, "apc", "TEXT_UNIT_TITLE_GDI_APC", "Goodguy");
public static readonly UnitType MLRS = new UnitType(7, "msam", "TEXT_UNIT_TITLE_GDI_MRLS", "Goodguy", true);
public static readonly UnitType Jeep = new UnitType(8, "jeep", "TEXT_UNIT_TITLE_GDI_HUMVEE", "Goodguy", true);
public static readonly UnitType Buggy = new UnitType(9, "bggy", "TEXT_UNIT_TITLE_NOD_NOD_BUGGY", "Badguy", true);
public static readonly UnitType Harvester = new UnitType(10, "harv", "TEXT_UNIT_TITLE_GDI_HARVESTER", "Goodguy");
public static readonly UnitType Arty = new UnitType(11, "arty", "TEXT_UNIT_TITLE_NOD_ARTILLERY", "Badguy");
public static readonly UnitType SAM = new UnitType(12, "mlrs", "TEXT_UNIT_TITLE_GDI_MLRS", "Goodguy", true);
public static readonly UnitType Hover = new UnitType(13, "lst", "TEXT_UNIT_TITLE_LST", "Goodguy");
public static readonly UnitType MHQ = new UnitType(14, "mhq", "TEXT_UNIT_TITLE_MHQ", "Goodguy");
public static readonly UnitType GunBoat = new UnitType(15, "boat", "TEXT_UNIT_TITLE_WAKE", "Goodguy", true);
public static readonly UnitType MCV = new UnitType(16, "mcv", "TEXT_UNIT_TITLE_GDI_MCV", "Goodguy");
public static readonly UnitType Bike = new UnitType(17, "bike", "TEXT_UNIT_TITLE_NOD_RECON_BIKE", "Badguy");
public static readonly UnitType Tric = new UnitType(18, "tric", "TEXT_UNIT_TITLE_TRIC", "Special");
public static readonly UnitType Trex = new UnitType(19, "trex", "TEXT_UNIT_TITLE_TREX", "Special");
public static readonly UnitType Rapt = new UnitType(20, "rapt", "TEXT_UNIT_TITLE_RAPT", "Special");
public static readonly UnitType Steg = new UnitType(21, "steg", "TEXT_UNIT_TITLE_STEG", "Special");
public static readonly UnitType Tran = new UnitType(0 | UnitTypeIDMask.Aircraft, "tran", "TEXT_UNIT_TITLE_GDI_TRANSPORT", "Goodguy");
public static readonly UnitType A10 = new UnitType(1 | UnitTypeIDMask.Aircraft, "a10", "TEXT_UNIT_TITLE_A10", "Goodguy", false, true);
public static readonly UnitType Heli = new UnitType(2 | UnitTypeIDMask.Aircraft, "heli", "TEXT_UNIT_TITLE_NOD_HELICOPTER", "Badguy");
public static readonly UnitType C17 = new UnitType(3 | UnitTypeIDMask.Aircraft, "c17", "TEXT_UNIT_TITLE_C17", "Badguy", false, true);
public static readonly UnitType Orca = new UnitType(4 | UnitTypeIDMask.Aircraft, "orca", "TEXT_UNIT_TITLE_GDI_ORCA", "Goodguy");
private static readonly UnitType[] Types;
static UnitTypes()
{
Types =
(from field in typeof(UnitTypes).GetFields(BindingFlags.Static | BindingFlags.Public)
where field.IsInitOnly && typeof(UnitType).IsAssignableFrom(field.FieldType)
select field.GetValue(null) as UnitType).ToArray();
}
public static IEnumerable<UnitType> GetTypes()
{
return Types;
}
}
}