Everything is now OpenRA, not OpenRa

OpenRA.Game/GameRules/ActorInfo.cs

@@ -0,0 +1,139 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007,2009,2010 Chris Forbes, Robert Pepperell, Matthew Bowra-Dean, Paul Chote, Alli Witheford.
+ * This file is part of OpenRA.
+ * 
+ *  OpenRA 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.
+ * 
+ *  OpenRA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ * 
+ *  You should have received a copy of the GNU General Public License
+ *  along with OpenRA.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using OpenRA.FileFormats;
+using OpenRA.Traits;
+
+namespace OpenRA.GameRules
+{
+	public class ActorInfo
+	{
+		public readonly string Name;
+		public readonly string Category;
+		public readonly TypeDictionary Traits = new TypeDictionary();
+
+		public ActorInfo( string name, MiniYaml node, Dictionary<string, MiniYaml> allUnits )
+		{
+			var mergedNode = MergeWithParent( node, allUnits ).Nodes;
+
+			Name = name;
+			MiniYaml categoryNode;
+			if( mergedNode.TryGetValue( "Category", out categoryNode ) )
+				Category = categoryNode.Value;
+
+			foreach( var t in mergedNode )
+				if( t.Key != "Inherits" && t.Key != "Category" )
+					Traits.Add( LoadTraitInfo( t.Key, t.Value ) );
+		}
+
+		static MiniYaml GetParent( MiniYaml node, Dictionary<string, MiniYaml> allUnits )
+		{
+			MiniYaml inherits;
+			node.Nodes.TryGetValue( "Inherits", out inherits );
+			if( inherits == null || string.IsNullOrEmpty( inherits.Value ) )
+				return null;
+
+			MiniYaml parent;
+			allUnits.TryGetValue( inherits.Value, out parent );
+			if( parent == null )
+				return null;
+
+			return parent;
+		}
+
+		static MiniYaml MergeWithParent( MiniYaml node, Dictionary<string, MiniYaml> allUnits )
+		{
+			var parent = GetParent( node, allUnits );
+			if( parent != null )
+				return MiniYaml.Merge( node, MergeWithParent( parent, allUnits ) );
+			return node;
+		}
+
+		static Pair<Assembly, string>[] ModAssemblies;
+		public static void LoadModAssemblies(Manifest m)
+		{
+			var asms = new List<Pair<Assembly, string>>();
+
+			// all the core stuff is in this assembly
+			asms.Add(Pair.New(typeof(ITraitInfo).Assembly, typeof(ITraitInfo).Namespace));
+
+			// add the mods
+			foreach (var a in m.Assemblies)
+				asms.Add(Pair.New(Assembly.LoadFile(Path.GetFullPath(a)), Path.GetFileNameWithoutExtension(a)));
+			ModAssemblies = asms.ToArray();
+		}
+
+		static ITraitInfo LoadTraitInfo(string traitName, MiniYaml my)
+		{
+			if (traitName.Contains('@'))
+				traitName = traitName.Substring(0, traitName.IndexOf('@'));
+
+			foreach (var mod in ModAssemblies)
+			{
+				var fullTypeName = mod.Second + "." + traitName + "Info";
+				var info = (ITraitInfo)mod.First.CreateInstance(fullTypeName);
+				if (info == null) continue;
+				FieldLoader.Load(info, my);
+				return info;
+			}
+
+			throw new InvalidOperationException("Cannot locate trait: {0}".F(traitName));
+		}
+
+		public IEnumerable<ITraitInfo> TraitsInConstructOrder()
+		{
+			var ret = new List<ITraitInfo>();
+			var t = Traits.WithInterface<ITraitInfo>().ToList();
+			int index = 0;
+			while( t.Count != 0 )
+			{
+				if( index >= t.Count )
+					throw new InvalidOperationException( "Trait prerequisites not satisfied (or prerequisite loop)" );
+
+				var prereqs = PrerequisitesOf( t[ index ] );
+				if( prereqs.Count == 0 || prereqs.All( n => ret.Any( x => x.GetType().IsSubclassOf( n ) ) ) )
+				{
+					ret.Add( t[ index ] );
+					t.RemoveAt( index );
+					index = 0;
+				}
+				else
+					++index;
+			}
+
+			return ret;
+		}
+
+		static List<Type> PrerequisitesOf( ITraitInfo info )
+		{
+			return info
+				.GetType()
+				.GetInterfaces()
+				.Where( t => t.IsGenericType && t.GetGenericTypeDefinition() == typeof( ITraitPrerequisite<> ) )
+				.Select( t => t.GetGenericArguments()[ 0 ] )
+				.ToList();
+		}
+	}
+}

OpenRA.Game/GameRules/Footprint.cs

@@ -0,0 +1,74 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007,2009,2010 Chris Forbes, Robert Pepperell, Matthew Bowra-Dean, Paul Chote, Alli Witheford.
+ * This file is part of OpenRA.
+ * 
+ *  OpenRA 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.
+ * 
+ *  OpenRA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ * 
+ *  You should have received a copy of the GNU General Public License
+ *  along with OpenRA.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using OpenRA.Traits;
+
+namespace OpenRA.GameRules
+{
+	static class Footprint
+	{
+		public static IEnumerable<int2> Tiles( string name, BuildingInfo buildingInfo, int2 topLeft )
+		{
+			var dim = buildingInfo.Dimensions;
+
+			var footprint = buildingInfo.Footprint.Where(x => !char.IsWhiteSpace(x));
+			if (buildingInfo.Bib)
+			{
+				dim.Y += 1;
+				footprint = footprint.Concat(new char[dim.X]);
+			}
+
+			return TilesWhere( name, dim, footprint.ToArray(), a => a != '_' ).Select( t => t + topLeft );
+		}
+
+		public static IEnumerable<int2> Tiles(Actor a, Traits.Building building)
+		{
+			return Tiles( a.Info.Name, a.Info.Traits.Get<BuildingInfo>(), a.Location );
+		}
+
+		public static IEnumerable<int2> UnpathableTiles( string name, BuildingInfo buildingInfo, int2 position )
+		{
+			var footprint = buildingInfo.Footprint.Where( x => !char.IsWhiteSpace( x ) ).ToArray();
+			foreach( var tile in TilesWhere( name, buildingInfo.Dimensions, footprint, a => a == 'x' ) )
+				yield return tile + position;
+		}
+
+		static IEnumerable<int2> TilesWhere( string name, int2 dim, char[] footprint, Func<char, bool> cond )
+		{
+			if( footprint.Length != dim.X * dim.Y )
+				throw new InvalidOperationException( "Invalid footprint for " + name );
+			int index = 0;
+
+			for( int y = 0 ; y < dim.Y ; y++ )
+				for( int x = 0 ; x < dim.X ; x++ )
+					if( cond( footprint[ index++ ] ) )
+						yield return new int2( x, y );
+		}
+
+		public static int2 AdjustForBuildingSize( BuildingInfo buildingInfo )
+		{
+			var dim = buildingInfo.Dimensions;
+			return new int2( dim.X / 2, dim.Y > 1 ? ( dim.Y + 1 ) / 2 : 0 );
+		}
+	}
+}

OpenRA.Game/GameRules/GeneralInfo.cs

@@ -0,0 +1,112 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007,2009,2010 Chris Forbes, Robert Pepperell, Matthew Bowra-Dean, Paul Chote, Alli Witheford.
+ * This file is part of OpenRA.
+ * 
+ *  OpenRA 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.
+ * 
+ *  OpenRA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ * 
+ *  You should have received a copy of the GNU General Public License
+ *  along with OpenRA.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+
+namespace OpenRA.GameRules
+{
+	public class GeneralInfo
+	{
+		/* Special Weapons */
+		public readonly float GapRegenInterval =0;
+		public readonly int BadgerBombCount = 1;
+
+		/* Chrono Side Effects */
+		public readonly float QuakeChance = 0;
+		public readonly float QuakeDamage = 0;		/* percent */
+		public readonly float VortexChance = 0;
+		public readonly int VortexDamage = 0;
+		public readonly int VortexRange = 0;
+		public readonly int VortexSpeed = 0;
+
+		/* Repair & Refit */
+		public readonly float RefundPercent = 0;
+		public readonly float ReloadRate = 0;
+		public readonly float RepairPercent = 0;
+		public readonly float RepairRate = 0;
+		public readonly int RepairStep = 0;
+		public readonly float URepairPercent = 0;
+		public readonly int URepairStep = 0;
+
+		/* Combat & Damage */
+		public readonly float TurboBoost = 1.5f;
+		public readonly float BallisticScatter = 0;
+		public readonly float C4Delay = 0;
+		public readonly float ExpSpread = 0;
+		public readonly int FireSupress = 0;
+		public readonly float HomingScatter = 0;
+		public readonly int MaxDamage = 0;
+		public readonly int MinDamage = 0;
+		public readonly bool OreExplosive = false;
+		public readonly bool PlayerAutoCrush = false;
+		public readonly bool PlayerReturnFire = false;
+		public readonly bool PlayerScatter = false;
+		public readonly bool TreeTargeting = false;
+		public readonly int Incoming = 0;
+
+		/* Income & Production */
+		public readonly float BuildSpeed = 0;
+		public readonly float BuildupTime = 0;
+		public readonly int GemValue = 0;
+		public readonly int GoldValue = 0;
+		public readonly float OreTruckRate = 0;
+		public readonly bool SeparateAircraft = true;
+		public readonly float SurvivorRate = 0;
+
+		/* Audo/Visual Map Controls */
+		public readonly bool AllyReveal = true;
+		public readonly float ConditionRed = 0;
+		public readonly float ConditionYellow = 0;
+		public readonly int DropZoneRadius = 0;
+		public readonly bool EnemyHealth = true;
+		public readonly int Gravity = 0;
+		public readonly float IdleActionFrequency = 0;
+		public readonly float MessageDelay = 0;
+		public readonly float MovieTime = 0;
+		public readonly bool NamedCivilians = false;
+		public readonly float SavourDelay = 0;
+		public readonly int ShroudRate = 0;
+		public readonly int SpeakDelay = 0;
+		public readonly int TimerWarning = 0;
+		public readonly bool FlashLowPower = false;
+
+		/* Computer & Movement Controls */
+		public readonly bool CurleyShuffle = false;
+		public readonly float BaseBias = 0;
+		public readonly float BaseDefenseDelay = 0;
+		public readonly float CloseEnough = 0;
+		public readonly int DamageDelay = 0;
+		public readonly int GameSpeeBias = 0;
+		public readonly int LZScanRadius = 0;
+		public readonly bool MineAware = false;
+		public readonly float Stray = 0;
+		public readonly float SubmergeDelay = 0;
+		public readonly float SuspendDelay = 0;
+		public readonly int SuspendPriority = 0;
+		public readonly float TeamDelay = 0;
+
+		/* Misc */
+		[Obsolete]
+		public readonly bool FineDiffControl = false;
+
+		/* OpenRA-specific */
+		public readonly int LowPowerSlowdown = 3;	/* build time multiplier */
+	}
+}

OpenRA.Game/GameRules/InfoLoader.cs

@@ -0,0 +1,51 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007,2009,2010 Chris Forbes, Robert Pepperell, Matthew Bowra-Dean, Paul Chote, Alli Witheford.
+ * This file is part of OpenRA.
+ * 
+ *  OpenRA 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.
+ * 
+ *  OpenRA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ * 
+ *  You should have received a copy of the GNU General Public License
+ *  along with OpenRA.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using OpenRA.FileFormats;
+
+namespace OpenRA.GameRules
+{
+	public class InfoLoader<T> : IEnumerable<KeyValuePair<string, T>>
+	{
+		readonly Dictionary<string, T> infos = new Dictionary<string, T>();
+
+		public InfoLoader(params Pair<string, Func<string,T>>[] srcs)
+		{
+			foreach (var src in srcs)
+				foreach (var name in Rules.Categories[src.First])
+				{
+					var t = src.Second(name);
+					FieldLoader.Load(t, Rules.AllRules.GetSection(name));
+					infos[name] = t;
+				}
+		}
+
+		public T this[string name]
+		{
+			get { return infos[name.ToLowerInvariant()]; }
+		}
+
+		public IEnumerator<KeyValuePair<string, T>> GetEnumerator() { return infos.GetEnumerator(); }
+		IEnumerator IEnumerable.GetEnumerator() { return infos.GetEnumerator(); }
+	}
+}

OpenRA.Game/GameRules/ProjectileInfo.cs

@@ -0,0 +1,45 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007,2009,2010 Chris Forbes, Robert Pepperell, Matthew Bowra-Dean, Paul Chote, Alli Witheford.
+ * This file is part of OpenRA.
+ * 
+ *  OpenRA 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.
+ * 
+ *  OpenRA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ * 
+ *  You should have received a copy of the GNU General Public License
+ *  along with OpenRA.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+namespace OpenRA.GameRules
+{
+	public class ProjectileInfo
+	{
+		public readonly bool AA = false;
+		public readonly bool AG = true;
+		public readonly bool ASW = false;
+		public readonly bool Arcing = false;
+		public readonly int Arm = 0;
+		public readonly bool Degenerates = false;
+		public readonly bool High = false;
+		public readonly string Image = null;
+		public readonly bool Inaccurate = false;
+		public readonly bool Parachuted = false;
+		public readonly bool Proximity = false;
+		public readonly int ROT = 0;
+		public readonly bool Rotates = false;
+		public readonly bool Shadow = true;
+		public readonly bool UnderWater = false;
+		public readonly int RangeLimit = 0;
+
+		// OpenRA-specific:
+		public readonly string Trail = null;
+	}
+}

OpenRA.Game/GameRules/Rules.cs

@@ -0,0 +1,82 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007,2009,2010 Chris Forbes, Robert Pepperell, Matthew Bowra-Dean, Paul Chote, Alli Witheford.
+ * This file is part of OpenRA.
+ * 
+ *  OpenRA 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.
+ * 
+ *  OpenRA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ * 
+ *  You should have received a copy of the GNU General Public License
+ *  along with OpenRA.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using OpenRA.FileFormats;
+using OpenRA.GameRules;
+
+namespace OpenRA
+{
+	public static class Rules
+	{
+		public static IniFile AllRules;
+		public static Dictionary<string, List<string>> Categories = new Dictionary<string, List<string>>();
+		public static InfoLoader<WeaponInfo> WeaponInfo;
+		public static InfoLoader<WarheadInfo> WarheadInfo;
+		public static InfoLoader<ProjectileInfo> ProjectileInfo;
+		public static InfoLoader<VoiceInfo> VoiceInfo;
+		public static GeneralInfo General;
+		public static TechTree TechTree;
+
+		public static Dictionary<string, ActorInfo> Info;
+
+		public static void LoadRules(string map, Manifest m)
+		{
+			var legacyRules = m.LegacyRules.Reverse().ToList();
+			legacyRules.Insert(0, map);
+			AllRules = new IniFile(legacyRules.Select(a => FileSystem.Open(a)).ToArray());
+
+			General = new GeneralInfo();
+			FieldLoader.Load(General, AllRules.GetSection("General"));
+
+			LoadCategories(
+				"Weapon",
+				"Warhead",
+				"Projectile",
+				"Voice");
+
+			WeaponInfo = new InfoLoader<WeaponInfo>(
+				Pair.New<string, Func<string, WeaponInfo>>("Weapon", _ => new WeaponInfo()));
+			WarheadInfo = new InfoLoader<WarheadInfo>(
+				Pair.New<string, Func<string, WarheadInfo>>("Warhead", _ => new WarheadInfo()));
+			ProjectileInfo = new InfoLoader<ProjectileInfo>(
+				Pair.New<string, Func<string, ProjectileInfo>>("Projectile", _ => new ProjectileInfo()));
+			VoiceInfo = new InfoLoader<VoiceInfo>(
+				Pair.New<string, Func<string, VoiceInfo>>("Voice", _ => new VoiceInfo()));
+	
+			var yamlRules = m.Rules.Reverse().Select(a => MiniYaml.FromFile(a)).Aggregate(MiniYaml.Merge);
+
+			ActorInfo.LoadModAssemblies(m);
+			Info = new Dictionary<string, ActorInfo>();
+			foreach( var kv in yamlRules )
+				Info.Add(kv.Key.ToLowerInvariant(), new ActorInfo(kv.Key.ToLowerInvariant(), kv.Value, yamlRules));
+
+			TechTree = new TechTree();
+		}
+
+		static void LoadCategories(params string[] types)
+		{
+			foreach (var t in types)
+				Categories[t] = AllRules.GetSection(t + "Types").Select(x => x.Key.ToLowerInvariant()).ToList();
+		}
+	}
+}

OpenRA.Game/GameRules/TechTree.cs

@@ -0,0 +1,100 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007,2009,2010 Chris Forbes, Robert Pepperell, Matthew Bowra-Dean, Paul Chote, Alli Witheford.
+ * This file is part of OpenRA.
+ * 
+ *  OpenRA 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.
+ * 
+ *  OpenRA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ * 
+ *  You should have received a copy of the GNU General Public License
+ *  along with OpenRA.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using System.Linq;
+using OpenRA.FileFormats;
+using OpenRA.Traits;
+
+namespace OpenRA.GameRules
+{
+	public class TechTree
+	{
+		readonly Cache<string, List<ActorInfo>> producesIndex = new Cache<string, List<ActorInfo>>(x => new List<ActorInfo>());
+
+		public TechTree()
+		{
+			foreach( var info in Rules.Info.Values )
+			{
+				var pi = info.Traits.GetOrDefault<ProductionInfo>();
+				if (pi != null)
+					foreach( var p in pi.Produces )
+						producesIndex[ p ].Add( info );
+			}
+		}
+
+		public Cache<string, List<Actor>> GatherBuildings( Player player )
+		{
+			var ret = new Cache<string, List<Actor>>( x => new List<Actor>() );
+			foreach( var b in player.World.Queries.OwnedBy[player].Where( x=>x.Info.Traits.Contains<BuildingInfo>() ) )
+			{
+				ret[ b.Info.Name ].Add( b );
+				var buildable = b.Info.Traits.GetOrDefault<BuildableInfo>();
+				if( buildable != null )
+					foreach( var alt in buildable.AlternateName )
+						ret[ alt ].Add( b );
+			}
+			return ret;
+		}
+
+		public bool CanBuild( ActorInfo info, Player player, Cache<string, List<Actor>> playerBuildings )
+		{
+			var bi = info.Traits.GetOrDefault<BuildableInfo>();
+			if( bi == null ) return false;
+
+			if( !bi.Owner.Contains( player.Country.Race ) )
+				return false;
+
+			foreach( var p in bi.Prerequisites )
+				if( playerBuildings[ p ].Count == 0 )
+					return false;
+
+			if( producesIndex[ info.Category ].All( x => playerBuildings[ x.Name ].Count == 0 ) )
+				return false;
+
+			return true;
+		}
+
+		public IEnumerable<string> BuildableItems( Player player, params string[] categories )
+		{
+			var playerBuildings = GatherBuildings( player );
+			foreach( var unit in AllBuildables( player, categories ) )
+				if( CanBuild( unit, player, playerBuildings ) )
+					yield return unit.Name;
+		}
+
+		public IEnumerable<ActorInfo> AllBuildables(Player player, params string[] categories)
+		{
+			return Rules.Info.Values
+				.Where( x => x.Name[ 0 ] != '^' )
+				.Where( x => categories.Contains( x.Category ) )
+				.Where( x => x.Traits.Contains<BuildableInfo>() );
+		}
+
+		public IEnumerable<ActorInfo> UnitBuiltAt( ActorInfo info )
+		{
+			var builtAt = info.Traits.Get<BuildableInfo>().BuiltAt;
+			if( builtAt.Length != 0 )
+				return builtAt.Select( x => Rules.Info[ x.ToLowerInvariant() ] );
+			else
+				return producesIndex[ info.Category ];
+		}
+	}
+}

OpenRA.Game/GameRules/UserSettings.cs

@@ -0,0 +1,53 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007,2009,2010 Chris Forbes, Robert Pepperell, Matthew Bowra-Dean, Paul Chote, Alli Witheford.
+ * This file is part of OpenRA.
+ * 
+ *  OpenRA 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.
+ * 
+ *  OpenRA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ * 
+ *  You should have received a copy of the GNU General Public License
+ *  along with OpenRA.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+namespace OpenRA.GameRules
+{
+	public class UserSettings
+	{
+		// Debug settings
+		public readonly bool UnitDebug = false;
+		public readonly bool PathDebug = false;
+		public readonly bool PerfGraph = true;
+		
+		// Window settings
+		public readonly int Width = 0;
+		public readonly int Height = 0;
+		public readonly bool Fullscreen = false;
+		
+		// Internal game settings
+		public readonly int Timestep = 40;
+		public readonly int SheetSize = 512;
+		
+		// External game settings
+		public readonly string NetworkHost = "";
+		public readonly int NetworkPort = 0;
+		public readonly string Map = "scm12ea.ini";
+		public readonly int Player = 1;
+		public readonly string Replay = "";
+		public readonly string PlayerName = "";
+		public readonly string[] InitialMods = { "ra" };
+		
+		// Gameplay options
+		// TODO: These need to die
+		public readonly bool RepairRequiresConyard = true;
+		public readonly bool PowerDownBuildings = true;
+	}
+}

OpenRA.Game/GameRules/VoiceInfo.cs

@@ -0,0 +1,74 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007,2009,2010 Chris Forbes, Robert Pepperell, Matthew Bowra-Dean, Paul Chote, Alli Witheford.
+ * This file is part of OpenRA.
+ * 
+ *  OpenRA 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.
+ * 
+ *  OpenRA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ * 
+ *  You should have received a copy of the GNU General Public License
+ *  along with OpenRA.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using OpenRA.FileFormats;
+
+namespace OpenRA.GameRules
+{
+	public class VoiceInfo
+	{
+		public readonly string[] SovietVariants = { ".aud" };
+		public readonly string[] AlliedVariants = { ".aud" };
+		public readonly string[] Select = { };
+		public readonly string[] Move = { };
+		public readonly string[] Attack = null;
+		public readonly string[] Die = { };
+
+		public readonly Lazy<Dictionary<string, VoicePool>> Pools;
+
+		public VoiceInfo()
+		{
+			Pools = Lazy.New(() =>
+				new Dictionary<string, VoicePool>
+				{
+					{ "Select", new VoicePool(Select) },
+					{ "Move", new VoicePool(Move) },
+					{ "Attack", new VoicePool( Attack ?? Move ) },
+					{ "Die", new VoicePool(Die) },
+				});
+		}
+	}
+
+	public class VoicePool
+	{
+		readonly string[] clips;
+		readonly List<string> liveclips = new List<string>();
+
+		public VoicePool(params string[] clips)
+		{
+			this.clips = clips;
+		}
+
+		public string GetNext()
+		{
+			if (liveclips.Count == 0)
+				liveclips.AddRange(clips);
+
+			if (liveclips.Count == 0)
+				return null;		/* avoid crashing if there's no clips at all */
+
+			var i = Game.world.CosmeticRandom.Next(liveclips.Count);
+			var s = liveclips[i];
+			liveclips.RemoveAt(i);
+			return s;
+		}
+	}
+}

OpenRA.Game/GameRules/WarheadInfo.cs

@@ -0,0 +1,46 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007,2009,2010 Chris Forbes, Robert Pepperell, Matthew Bowra-Dean, Paul Chote, Alli Witheford.
+ * This file is part of OpenRA.
+ * 
+ *  OpenRA 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.
+ * 
+ *  OpenRA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ * 
+ *  You should have received a copy of the GNU General Public License
+ *  along with OpenRA.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+namespace OpenRA.GameRules
+{
+	public class WarheadInfo
+	{
+		public readonly int Spread = 1;
+		public readonly float[] Verses = { 1, 1, 1, 1, 1 };
+		public readonly bool Wall = false;
+		public readonly bool Wood = false;
+		public readonly bool Ore = false;
+		public readonly int Explosion = 0;
+		public readonly int InfDeath = 0;
+		public readonly string ImpactSound = null;
+		public readonly string WaterImpactSound = null;
+
+		public float EffectivenessAgainst(ArmorType at) { return Verses[ (int)at ]; }
+	}
+
+	public enum ArmorType
+	{
+		none = 0,
+		wood = 1,
+		light = 2,
+		heavy = 3,
+		concrete = 4,
+	}
+}

OpenRA.Game/GameRules/WeaponInfo.cs

@@ -0,0 +1,41 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007,2009,2010 Chris Forbes, Robert Pepperell, Matthew Bowra-Dean, Paul Chote, Alli Witheford.
+ * This file is part of OpenRA.
+ * 
+ *  OpenRA 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.
+ * 
+ *  OpenRA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ * 
+ *  You should have received a copy of the GNU General Public License
+ *  along with OpenRA.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+namespace OpenRA.GameRules
+{
+	public class WeaponInfo
+	{
+		public readonly int Burst = 1;
+		public readonly bool Charges = false;
+		public readonly int Damage = 0;
+		public readonly string Projectile = "Invisible";
+		public readonly int ROF = 1; // in 1/15 second units.
+		public readonly float Range = 0;
+		public readonly string Report = null;
+		public readonly int Speed = -1;
+		public readonly bool TurboBoost = false;
+		public readonly string Warhead = null;
+
+		public readonly bool RenderAsTesla = false;
+		public readonly bool RenderAsLaser = false;
+		public readonly bool UsePlayerColor = true;
+		public readonly int BeamRadius = 1;
+	}
+}