Merge pull request #3551 from pchote/changelog

Update changelog for new playtest.

.editorconfig

@@ -0,0 +1,16 @@
+; Top-most http://editorconfig.org/ file
+root = true
+
+; Unix-style newlines
+[*]
+end_of_line = LF
+
+; 4-column tab indentation
+[*.cs]
+indent_style = tab
+indent_size = 4
+
+; 4-column tab indentation
+[*.yaml]
+indent_style = tab
+indent_size = 4

.gitattributes

@@ -0,0 +1,10 @@
+# Enforce LF normalization on Windows
+* text=lf
+
+# Custom for Visual Studio
+*.cs     diff=csharp
+*.sln    merge=union
+*.csproj merge=union
+*.vbproj merge=union
+*.fsproj merge=union
+*.dbproj merge=union

.gitignore

@@ -10,11 +10,12 @@ obj
 *.manifest
 mods/*/*.dll
 
-# Red Alert binary files
-mods/*/packages/*.[mM][iI][xX]
+# ReSharper crap
+_ReSharper.*/
 
 #binary stuff
 /*.dll
+/*.dll.config
 *.pdb
 *.mdb
 *.exe
@@ -22,9 +23,15 @@ mods/*/packages/*.[mM][iI][xX]
 # backup files by various editors
 *~
 *.orig
+\#*
+.*.sw?
+
 # dependency DLLs (different for every platform!)
 cg.dll
 cgGL.dll
+freetype6.dll
+zlib1.dll
+SDL.dll
 
 /OpenRa.Gl.dll
 
@@ -32,8 +39,6 @@ cgGL.dll
 *.pidb
 *.userprefs
 
-packaging/windows/*.exe
-
 # osx crap
 .DS_Store
 
@@ -49,12 +54,15 @@ OpenRA.Launcher.Mac/build/
 OpenRA.Launcher.Mac/OpenRA.xcodeproj/*.pbxuser
 OpenRA.Launcher.Mac/OpenRA.xcodeproj/*.perspectivev3
 OpenRA.Launcher.Mac/OpenRA.xcodeproj/*.mode1v3
-*.config
 *.resources
 
-# other crap
-Logs/
-Replays/
-settings.yaml
-\#*
-.*.sw?
+# KDE crap
+*.kate-swp
+*.directory
+
+# auto-generated documentation
+DOCUMENTATION.md
+*.html
+
+# StyleCop
+*.Cache

.travis.yml

@@ -0,0 +1,23 @@
+# Travis-CI Build for OpenRA
+# see travis-ci.org for details
+
+# Mono/.NET are not officially supported. The following is a workaround.
+language: c
+
+# Make sure build dependencies are installed.
+install:
+ - sudo apt-get update && sudo apt-get install mono-gmcs cli-common-dev libgl1-mesa-dev libsdl1.2-dev libopenal-dev
+
+# Run the build script which will automatically call RALint and ensure that the IDE project files are still valid.
+script:
+ - make all
+ - xbuild
+
+# Only watch the development branch.
+branches:
+ only:
+   - bleed
+
+# Notify developers when build passed/failed.
+notifications:
+  irc: "irc.freenode.net#openra"

AUTHORS

@@ -1,34 +1,74 @@
-AUTHORS
+OpenRA wouldn't be where it is today without the
+hard work of many contributors.
 
 The OpenRA developers are:
-	* Alli Witheford	(alzeih)
-	* Caleb Anderson	(RobotCaleb)
-	* Chris Forbes		(chrisf)
-	* Curtis Shmyr		(hamb)
-	* Daniel Hernandez	(Mancano)
-	* Matthew Bowra-Dean	(beedee)
-	* Mike Bundy		(kehaar)
+    * Chris Forbes (chrisf)
+    * Curtis Shmyr (hamb)
+    * Paul Chote (pchote)
+    * Matthias Mailänder (Mailaender)
+    * ScottNZ
+
+Previous developers included:
+    * Alli Witheford (alzeih)
+    * Caleb Anderson (RobotCaleb)
+    * Daniel Hernandez (Mancano)
+    * Megan Bowra-Dean (beedee)
+    * Mike Bundy (kehaar)
+    * Robert Pepperell (ytinasni)
 
 Also thanks to:
-	* Andrew Riedi
-	* Bellator
-	* Christer Ulfsparre	(Holloweye)
-	* Erasmus Schroder	(rasco)
-	* Igor Popov		(ihptru)
-	* Jeff Harris		(jeff_1amstudios)
-	* Joakim Lindberg	(booom3)
-	* Max Ugrumov		(katzsmile)
-	* Lawrence Wang
-	* Matthew Gatland	(mgatland)
-	* Max621
-	* Nukem
-	* Paolo Chiodi		(paolochiodi)
-	* Paul Dovydaitis	(pdovy)
-	* Ragequit
-	* Tim Mylemans		(gecko)
-	* Riderr3
-	* Raymond Martineau
+    * Akseli Virtanen (RAGEQUIT)
+    * Andrew Perkins
+    * Andrew Riedi
+    * Andrew Aldridge (i80and)
+    * Andreas Beck (baxtor)
+    * Barnaby Smith (mvi)
+    * Bellator
+    * Bugra Cuhadaroglu (BugraC)
+    * Christer Ulfsparre (Holloweye)
+    * Cody Brittain (Generalcamo)
+    * D2k Sardaukar
+    * Daniel Derejvanik (Harisson)
+    * Danny (Dan9550)
+    * Erasmus Schroder (rasco)
+    * Frank Razenberg (zzattack)
+    * Igor Popov (ihptru)
+    * Iran
+    * James Dunne (jsd)
+    * Jeff Harris (jeff_1amstudios)
+    * Jes
+    * Joakim Lindberg (booom3)
+    * JOo
+    * Kenny Hoxworth (hoxworth)
+    * Krishnakanth Mallik
+    * Kyrre Soerensen (zypres)
+    * Lawrence Wang
+    * Lesueur Benjamin (Valkirie)
+    * Mark Olson (markolson)
+    * Matthew Gatland (mgatland)
+    * Maarten Meuris (Nyerguds)
+    * Max Ugrumov (katzsmile)
+    * Max621
+    * Nukem
+    * Olaf van der Spek
+    * Paolo Chiodi (paolochiodi)
+    * Paul Dovydaitis (pdovy)
+    * Psydev
+    * Raymond Martineau (mart0258)
+    * Reaperrr
+    * Riderr3
+    * Sascha Biedermann (bidifx)
+    * Tim Mylemans (gecko)
+    * Tirili
+    * Tristan Keating (Kilkakon)
+    * Vladimir Komarov (VrKomarov)
+    * Wuschel
+
+Finally, special thanks goes to the original teams
+at Westwood Studios and EA for creating the classic
+games that inspired the creation of OpenRA.
+
+Red Alert, Command and Conquer, and related
+trademarks belong to Electronic Arts Inc. and are
+used without permission.
 
-Past developers included:
-	* Paul Chote		(pchote)
-	* Robert Pepperell	(ytinasni)

CONTRIBUTING.md

@@ -0,0 +1,19 @@
+# OpenRA Contributing Guidelines
+
+## Bug reports
+
+* Have you read the [FAQ](https://github.com/OpenRA/OpenRA/wiki/FAQ)?
+* Add the appropriate log files on crashes.
+* Please be specific on how to reproduce the problem.
+
+## Patches
+
+* [Coding standard](https://github.com/OpenRA/OpenRA/wiki/Coding-Standard)
+* [Branches and Releases](https://github.com/OpenRA/OpenRA/wiki/Branches-and-Releases)
+* [Licensing](http://www.gnu.org/licenses/quick-guide-gplv3.html)
+
+Please `git rebase` to the latest revision of the bleed branch.
+
+Don't forget to add youself to [AUTHORS](https://github.com/OpenRA/OpenRA/blob/bleed/AUTHORS).
+
+While your pull-request is in review it will be helpful if you join [IRC](irc://chat.freenode.net/openra) to discuss the changes.

INSTALL

@@ -41,23 +41,19 @@ UBUNTU (substitute comparable packages for other linux distros):
 
 OpenRA does not work with some older versions of Compiz. On affected systems, disable desktop effects before playing. This is fixed in Ubuntu Natty and later.
 
-You will additionally need to copy the third party dependencies (.dll and .config) from the
-thirdparty and thirdparty/Tao directories into the game root:
-
-	cp -v thirdparty/*.dll thirdparty/Tao/* .
-
-Alternatively, the dlls can be installed into your system GAC. This is not
+The following dlls can also be installed into your system GAC. This is not
 recommended because we ship a custom Tao.FreeType that can conflict with
 other applications that use Tao:
 
-	gacutil -i thirdparty/Tao/Tao.Cg.dll
-	gacutil -i thirdparty/Tao/Tao.OpenGl.dll
-	gacutil -i thirdparty/Tao/Tao.OpenAl.dll
-	gacutil -i thirdparty/Tao/Tao.Sdl.dll
-	gacutil -i thirdparty/Tao/Tao.FreeType.dll
-	gacutil -i thirdparty/ICSharpCode.SharpZipLib.dll
+	gacutil -i Tao.Cg.dll
+	gacutil -i Tao.OpenGl.dll
+	gacutil -i Tao.OpenAl.dll
+	gacutil -i Tao.Sdl.dll
+	gacutil -i Tao.FreeType.dll
+	gacutil -i ICSharpCode.SharpZipLib.dll
 
 To compile OpenRA, run `make' from the command line.
+To install run 'make install'.
 Run the game with `mono OpenRA.Game.exe Game.Mods=ra` for Red Alert
 or `mono OpenRA.Game.exe Game.Mods=cnc` for Command & Conquer
 

Makefile

@@ -1,22 +1,69 @@
+############################# INSTRUCTIONS #############################
+#
+# to compile, run:
+#   make
+#
+# to compile with development tools, run:
+#   make all
+#
+# to install, run:
+#   make [prefix=/foo] [bindir=/bar/bin] install
+#
+# to install with development tools, run:
+#   make [prefix=/foo] [bindir=/bar/bin] install-all
+#
+# to uninstall, run:
+#   make uninstall
+#
+# for help, run:
+#   make help
+#
+# to start the game, run:
+#   openra
+
+
+
+############################## TOOLCHAIN ###############################
+#
 CSC         = gmcs
-CSFLAGS     = -nologo -warn:4 -debug:+ -debug:full -optimize- -codepage:utf8 -unsafe
+CSFLAGS     = -nologo -warn:4 -debug:full -optimize- -codepage:utf8 -unsafe -warnaserror
 DEFINE      = DEBUG;TRACE
-COMMON_LIBS	= System.dll System.Core.dll System.Drawing.dll System.Xml.dll thirdparty/ICSharpCode.SharpZipLib.dll
-PHONY		= core tools package all mods clean distclean
+COMMON_LIBS = System.dll System.Core.dll System.Drawing.dll System.Xml.dll thirdparty/ICSharpCode.SharpZipLib.dll thirdparty/FuzzyLogicLibrary.dll thirdparty/Mono.Nat.dll
 
-.SUFFIXES:
-core: game renderers mod_ra mod_cnc utility
-tools: editor ralint tsbuild
-package: core editor
-mods: mod_ra mod_cnc
-all: core tools
-clean: 
-	@-rm -f *.exe *.dll *.mdb mods/**/*.dll mods/**/*.mdb *.resources
-distclean: clean
 
+
+######################### UTILITIES/SETTINGS ###########################
+#
+# install locations
+prefix ?= /usr/local
+datarootdir ?= $(prefix)/share
+datadir ?= $(datarootdir)
+bindir ?= $(prefix)/bin
+BIN_INSTALL_DIR = $(DESTDIR)$(bindir)
+DATA_INSTALL_DIR = $(DESTDIR)$(datadir)/openra
+
+# install tools
+RM = rm
+RM_R = $(RM) -r
+RM_F = $(RM) -f
+CP = cp
+CP_R = $(CP) -r
+INSTALL = install
+INSTALL_DIR = $(INSTALL) -d
+INSTALL_PROGRAM = $(INSTALL) -m755
+INSTALL_DATA = $(INSTALL) -m644
+
+# program targets
+CORE = fileformats rcg rgl rsdl rnull game utility
+TOOLS = editor tsbuild ralint
+
+VERSION     = $(shell git name-rev --name-only --tags --no-undefined HEAD 2>/dev/null || echo git-`git rev-parse --short HEAD`)
+
+
+
+######################## PROGRAM TARGET RULES ##########################
 #
 # Core binaries
-#
 fileformats_SRCS	:= $(shell find OpenRA.FileFormats/ -iname '*.cs')
 fileformats_TARGET	= OpenRA.FileFormats.dll
 fileformats_KIND	= library
@@ -27,16 +74,14 @@ fileformats: $(fileformats_TARGET)
 game_SRCS			:= $(shell find OpenRA.Game/ -iname '*.cs')
 game_TARGET			= OpenRA.Game.exe
 game_KIND			= winexe
-game_DEPS			= $(fileformats_TARGET) 
+game_DEPS			= $(fileformats_TARGET)
 game_LIBS			= $(COMMON_LIBS) System.Windows.Forms.dll $(game_DEPS) \
-						thirdparty/Tao/Tao.OpenAl.dll thirdparty/Tao/Tao.FreeType.dll
+					thirdparty/Tao/Tao.OpenAl.dll thirdparty/SharpFont.dll
 game_FLAGS			= -win32icon:OpenRA.Game/OpenRA.ico
 PROGRAMS 			+= game
 game: $(game_TARGET)
 
-#
 # Renderer dlls
-#
 rsdl_SRCS			:= $(shell find OpenRA.Renderer.SdlCommon/ -iname '*.cs')
 rsdl_TARGET			= OpenRA.Renderer.SdlCommon.dll
 rsdl_KIND			= library
@@ -70,19 +115,18 @@ rnull_LIBS			= $(COMMON_LIBS) System.Windows.Forms.dll \
 PROGRAMS 			+= rcg rgl rnull rsdl
 renderers: $(rcg_TARGET) $(rgl_TARGET) $(rnull_TARGET) $(rsdl_TARGET)
 
-#
-# Official Mods
-#
-# Red Alert
+
+##### Official Mods #####
 
 STD_MOD_LIBS	= $(fileformats_TARGET) $(game_TARGET)
 STD_MOD_DEPS	= $(STD_MOD_LIBS) $(ralint_TARGET)
 
+# Red Alert
 mod_ra_SRCS			:= $(shell find OpenRA.Mods.RA/ -iname '*.cs')
 mod_ra_TARGET			= mods/ra/OpenRA.Mods.RA.dll
 mod_ra_KIND			= library
-mod_ra_DEPS			= $(STD_MOD_DEPS)
-mod_ra_LIBS			= $(COMMON_LIBS) $(STD_MOD_LIBS)
+mod_ra_DEPS			= $(STD_MOD_DEPS) $(utility_TARGET)
+mod_ra_LIBS			= $(COMMON_LIBS) $(STD_MOD_LIBS) $(utility_TARGET)
 mod_ra_EXTRA_CMDS		= mono --debug RALint.exe ra
 PROGRAMS 			+= mod_ra
 mod_ra: $(mod_ra_TARGET)
@@ -97,9 +141,19 @@ mod_cnc_EXTRA_CMDS	= mono --debug RALint.exe cnc
 PROGRAMS 		+= mod_cnc
 mod_cnc: $(mod_cnc_TARGET)
 
-#
-# Tools
-#
+# Dune 2000
+mod_d2k_SRCS		:= $(shell find OpenRA.Mods.D2k/ -iname '*.cs')
+mod_d2k_TARGET		= mods/d2k/OpenRA.Mods.D2k.dll
+mod_d2k_KIND		= library
+mod_d2k_DEPS		= $(STD_MOD_DEPS) $(mod_ra_TARGET) $(mod_cnc_TARGET) $(utility_TARGET)
+mod_d2k_LIBS		= $(COMMON_LIBS) $(STD_MOD_LIBS) $(mod_ra_TARGET) $(utility_TARGET)
+mod_d2k_EXTRA_CMDS	= mono --debug RALint.exe d2k
+PROGRAMS 		+= mod_d2k
+mod_d2k: $(mod_d2k_TARGET)
+
+
+##### Tools #####
+
 # Map Editor
 editor_SRCS			:= $(shell find OpenRA.Editor/ -iname '*.cs')
 editor_TARGET			= OpenRA.Editor.exe
@@ -127,23 +181,22 @@ ralint: $(ralint_TARGET)
 
 # Builds and exports tilesets from a bitmap
 tsbuild_SRCS		:= $(shell find OpenRA.TilesetBuilder/ -iname '*.cs')
-tsbuild_TARGET		= TilesetBuilder.exe
+tsbuild_TARGET		= OpenRA.TilesetBuilder.exe
 tsbuild_KIND		= winexe
 tsbuild_DEPS		= $(fileformats_TARGET) $(game_TARGET)
 tsbuild_LIBS		= $(COMMON_LIBS) $(tsbuild_DEPS) System.Windows.Forms.dll
-tsbuild_EXTRA		= -resource:OpenRA.TilesetBuilder.Form1.resources
+tsbuild_EXTRA		= -resource:OpenRA.TilesetBuilder.frmBuilder.resources -resource:OpenRA.TilesetBuilder.frmNew.resources -resource:OpenRA.TilesetBuilder.Surface.resources
 PROGRAMS 			+= tsbuild
-OpenRA.TilesetBuilder.Form1.resources:
-	resgen2 OpenRA.TilesetBuilder/Form1.resx OpenRA.TilesetBuilder.Form1.resources 1> /dev/null
-tsbuild: OpenRA.TilesetBuilder.Form1.resources $(tsbuild_TARGET)
+OpenRA.TilesetBuilder.frmBuilder.resources:
+	resgen2 OpenRA.TilesetBuilder/frmBuilder.resx OpenRA.TilesetBuilder.frmBuilder.resources 1> /dev/null
+OpenRA.TilesetBuilder.frmNew.resources:
+	resgen2 OpenRA.TilesetBuilder/frmNew.resx OpenRA.TilesetBuilder.frmNew.resources 1> /dev/null
+OpenRA.TilesetBuilder.Surface.resources:
+	resgen2 OpenRA.TilesetBuilder/Surface.resx OpenRA.TilesetBuilder.Surface.resources 1> /dev/null
+tsbuild: OpenRA.TilesetBuilder.frmBuilder.resources OpenRA.TilesetBuilder.frmNew.resources OpenRA.TilesetBuilder.Surface.resources $(tsbuild_TARGET)
 
-#
-# Launchers / Utilities
-#
-# Patches binary headers to work around a mono bug
-fixheader.exe: packaging/fixheader.cs
-	@echo CSC fixheader.exe
-	@$(CSC) packaging/fixheader.cs $(CSFLAGS) -out:fixheader.exe -t:exe $(COMMON_LIBS:%=-r:%)
+
+##### Launchers / Utilities #####
 
 # Backend for the launcher apps - queries game/mod info and applies actions to an install
 utility_SRCS		:= $(shell find OpenRA.Utility/ -iname '*.cs')
@@ -154,11 +207,13 @@ utility_LIBS        = $(COMMON_LIBS) $(utility_DEPS) thirdparty/ICSharpCode.Shar
 PROGRAMS 			+= utility
 utility: $(utility_TARGET)
 
-.PHONY: $(PHONY) $(PROGRAMS)
 
-#
+# Patches binary headers to work around a mono bug
+fixheader.exe: packaging/fixheader.cs
+	@echo CSC fixheader.exe
+	@$(CSC) packaging/fixheader.cs $(CSFLAGS) -out:fixheader.exe -t:exe $(COMMON_LIBS:%=-r:%)
+
 # Generate build rules for each target defined above in PROGRAMS
-#
 define BUILD_ASSEMBLY
 
 $$($(1)_TARGET): $$($(1)_SRCS) Makefile $$($(1)_DEPS) fixheader.exe
@@ -177,58 +232,129 @@ endef
 $(foreach prog,$(PROGRAMS),$(eval $(call BUILD_ASSEMBLY,$(prog))))
 
 
+
+########################## MAKE/INSTALL RULES ##########################
 #
-# Install / Uninstall for *nix
-#
-prefix = /usr/local
-datarootdir = $(prefix)/share
-datadir = $(datarootdir)
-bindir = $(prefix)/bin
-BIN_INSTALL_DIR = $(DESTDIR)$(bindir)
-INSTALL_DIR = $(DESTDIR)$(datadir)/openra
-INSTALL = install
-INSTALL_PROGRAM = $(INSTALL)
-CORE = fileformats rcg rgl rsdl rnull game editor utility
+default: dependencies core
 
-install: all
-	@-echo "Installing OpenRA to $(INSTALL_DIR)"
-	@$(INSTALL_PROGRAM) -d $(INSTALL_DIR)
-	@$(INSTALL_PROGRAM) $(foreach prog,$(CORE),$($(prog)_TARGET)) $(INSTALL_DIR)
-	@$(INSTALL_PROGRAM) -d $(INSTALL_DIR)/mods/cnc
-	@$(INSTALL_PROGRAM) $(mod_cnc_TARGET) $(INSTALL_DIR)/mods/cnc
+core: game renderers mods utility tsbuild
 
-	@-cp $(foreach f,$(shell ls mods/cnc --hide=*.dll),mods/cnc/$(f)) $(INSTALL_DIR)/mods/cnc
-	@cp -r mods/cnc/maps $(INSTALL_DIR)/mods/cnc
-	@cp -r mods/cnc/chrome $(INSTALL_DIR)/mods/cnc
-	@cp -r mods/cnc/bits $(INSTALL_DIR)/mods/cnc
-	@cp -r mods/cnc/rules $(INSTALL_DIR)/mods/cnc
-	@cp -r mods/cnc/sequences $(INSTALL_DIR)/mods/cnc
-	@cp -r mods/cnc/tilesets $(INSTALL_DIR)/mods/cnc
-	@cp -r mods/cnc/uibits $(INSTALL_DIR)/mods/cnc
-	@$(INSTALL_PROGRAM) -d $(INSTALL_DIR)/mods/ra
-	@$(INSTALL_PROGRAM) $(mod_ra_TARGET) $(INSTALL_DIR)/mods/ra
+tools: editor tsbuild ralint
 
-	@-cp $(foreach f,$(shell ls mods/ra --hide=*.dll),mods/ra/$(f)) $(INSTALL_DIR)/mods/ra
-	@cp -r mods/ra/maps $(INSTALL_DIR)/mods/ra
-	@cp -r mods/ra/bits $(INSTALL_DIR)/mods/ra
-	@cp -r mods/ra/chrome $(INSTALL_DIR)/mods/ra
-	@cp -r mods/ra/rules $(INSTALL_DIR)/mods/ra
-	@cp -r mods/ra/tilesets $(INSTALL_DIR)/mods/ra
-	@cp -r mods/ra/uibits $(INSTALL_DIR)/mods/ra
+package: dependencies core editor docs version
 
-	@cp -r glsl $(INSTALL_DIR)
-	@cp -r cg $(INSTALL_DIR)
-	@cp *.ttf $(INSTALL_DIR)
-	@cp --parents -r thirdparty/Tao $(INSTALL_DIR)
-	@$(INSTALL_PROGRAM) thirdparty/ICSharpCode.SharpZipLib.dll $(INSTALL_DIR)
+mods: mod_ra mod_cnc mod_d2k
 
-	@echo "#!/bin/sh" > openra
-	@echo "cd "$(datadir)"/openra" >> openra
-	@echo "mono "$(datadir)"/openra/OpenRA.Game.exe \"$$""@\"" >> openra
+all: dependencies core tools
 
-	@$(INSTALL_PROGRAM) -d $(BIN_INSTALL_DIR)
-	@$(INSTALL_PROGRAM) -m +rx openra $(BIN_INSTALL_DIR)
+clean:
+	@-$(RM_F) *.exe *.dll *.mdb mods/**/*.dll mods/**/*.mdb *.resources
+
+distclean: clean
+
+dependencies:
+	@ $(CP_R) thirdparty/*.dl* .
+	@ $(CP_R) thirdparty/Tao/* .
+
+version: mods/ra/mod.yaml mods/cnc/mod.yaml mods/d2k/mod.yaml
+	@for i in $? ; do \
+		awk '{sub("Version:.*$$","Version: $(VERSION)"); print $0}' $${i} > $${i}.tmp && \
+		mv -f $${i}.tmp $${i} ; \
+	done
+
+# Documentation (d2k depends on all mod libraries)
+docs: utility
+	@mono --debug OpenRA.Utility.exe --docs d2k > DOCUMENTATION.md
+
+install: install-core
+
+install-all: install-core install-tools
+
+install-core: default
+	@-echo "Installing OpenRA to $(DATA_INSTALL_DIR)"
+	@$(INSTALL_DIR) "$(DATA_INSTALL_DIR)"
+	@$(INSTALL_PROGRAM) $(foreach prog,$(CORE),$($(prog)_TARGET)) "$(DATA_INSTALL_DIR)"
+	@$(INSTALL_DIR) "$(DATA_INSTALL_DIR)/mods"
+	@$(CP_R) mods/cnc "$(DATA_INSTALL_DIR)/mods/"
+	@$(INSTALL_PROGRAM) $(mod_cnc_TARGET) "$(DATA_INSTALL_DIR)/mods/cnc"
+	@$(CP_R) mods/ra "$(DATA_INSTALL_DIR)/mods/"
+	@$(INSTALL_PROGRAM) $(mod_ra_TARGET) "$(DATA_INSTALL_DIR)/mods/ra"
+	@$(CP_R) mods/d2k "$(DATA_INSTALL_DIR)/mods/"
+	@$(INSTALL_PROGRAM) $(mod_d2k_TARGET) "$(DATA_INSTALL_DIR)/mods/d2k"
+
+	@$(INSTALL_DATA) "global mix database.dat" "$(DATA_INSTALL_DIR)/global mix database.dat"
+	@$(INSTALL_DATA) AUTHORS "$(DATA_INSTALL_DIR)/AUTHORS"
+
+	@$(CP_R) glsl "$(DATA_INSTALL_DIR)"
+	@$(CP_R) cg "$(DATA_INSTALL_DIR)"
+	@$(CP) *.ttf "$(DATA_INSTALL_DIR)"
+	@$(CP) thirdparty/Tao/* "$(DATA_INSTALL_DIR)"
+	@$(INSTALL_PROGRAM) thirdparty/ICSharpCode.SharpZipLib.dll "$(DATA_INSTALL_DIR)"
+	@$(INSTALL_PROGRAM) thirdparty/FuzzyLogicLibrary.dll "$(DATA_INSTALL_DIR)"
+	@$(INSTALL_PROGRAM) thirdparty/SharpFont.dll "$(DATA_INSTALL_DIR)"
+	@$(CP) thirdparty/SharpFont.dll.config "$(DATA_INSTALL_DIR)"
+	@$(INSTALL_PROGRAM) thirdparty/Mono.Nat.dll "$(DATA_INSTALL_DIR)"
+
+	@echo "#!/bin/sh" 				>  openra
+	@echo 'BINDIR=$$(dirname $$(readlink -f $$0))'	>> openra
+	@echo 'ROOTDIR="$${BINDIR%'"$(bindir)"'}"' 	>> openra
+	@echo 'DATADIR="$${ROOTDIR}/'"$(datadir)"'"'	>> openra
+	@echo 'cd "$${DATADIR}/openra"' 		>> openra
+	@echo 'exec mono OpenRA.Game.exe "$$@"' 	>> openra
+
+	@$(INSTALL_DIR) "$(BIN_INSTALL_DIR)"
+	@$(INSTALL_PROGRAM) -m +rx openra "$(BIN_INSTALL_DIR)"
+
+	@-$(RM) openra
+
+install-tools: tools
+	@-echo "Installing OpenRA tools to $(DATA_INSTALL_DIR)"
+	@$(INSTALL_DIR) "$(DATA_INSTALL_DIR)"
+	@$(INSTALL_PROGRAM) $(foreach prog,$(TOOLS),$($(prog)_TARGET)) "$(DATA_INSTALL_DIR)"
+
+	@echo "#!/bin/sh" 				>  openra-editor
+	@echo 'BINDIR=$$(dirname $$(readlink -f $$0))'	>> openra-editor
+	@echo 'ROOTDIR="$${BINDIR%'"$(bindir)"'}"' 	>> openra-editor
+	@echo 'DATADIR="$${ROOTDIR}/'"$(datadir)"'"'	>> openra-editor
+	@echo 'cd "$${DATADIR}/openra"'			>> openra-editor
+	@echo 'exec mono OpenRA.Editor.exe "$$@"'	>> openra-editor
+
+	@$(INSTALL_DIR) "$(BIN_INSTALL_DIR)"
+	@$(INSTALL_PROGRAM) -m +rx openra-editor "$(BIN_INSTALL_DIR)"
+
+	@-$(RM) openra-editor
 
 uninstall:
-	@-rm -r $(INSTALL_DIR)
-	@-rm $(DESTDIR)$(bindir)/openra
+	@-$(RM_R) "$(DATA_INSTALL_DIR)"
+	@-$(RM_F) "$(BIN_INSTALL_DIR)/openra"
+	@-$(RM_F) "$(BIN_INSTALL_DIR)/openra-editor"
+
+help:
+	@echo to compile, run:
+	@echo \ \ make
+	@echo
+	@echo to compile with development tools, run:
+	@echo \ \ make all
+	@echo
+	@echo to install, run:
+	@echo \ \ make \[prefix=/foo\] \[bindir=/bar/bin\] install
+	@echo
+	@echo to install with development tools, run:
+	@echo \ \ make \[prefix=/foo\] \[bindir=/bar/bin\] install-all
+	@echo
+	@echo to uninstall, run:
+	@echo \ \ make uninstall
+	@echo
+	@echo to start the game, run:
+	@echo \ \ openra
+
+
+
+
+########################### MAKEFILE SETTINGS ##########################
+#
+.DEFAULT_GOAL := default
+
+.SUFFIXES:
+
+.PHONY: core tools package all mods clean distclean dependencies version $(PROGRAMS)

OpenRA.Editor/BrushTool.cs

@@ -39,7 +39,7 @@ namespace OpenRA.Editor
 			for (var u = 0; u < template.Size.X; u++)
 				for (var v = 0; v < template.Size.Y; v++)
 				{
-					if (surface.Map.IsInMap(new int2(u, v) + pos))
+					if (surface.Map.IsInMap(new CVec(u, v) + pos))
 					{
 						var z = u + v * template.Size.X;
 						if (tile.TileBitmapBytes[z] != null)
@@ -69,17 +69,17 @@ namespace OpenRA.Editor
 					Brush.Bitmap.Height * surface.Zoom);
 		}
 
-		void FloodFillWithBrush(Surface s, int2 pos)
+		void FloodFillWithBrush(Surface s, CPos pos)
 		{
-			var queue = new Queue<int2>();
+			var queue = new Queue<CPos>();
 			var replace = s.Map.MapTiles.Value[pos.X, pos.Y];
 			var touched = new bool[s.Map.MapSize.X, s.Map.MapSize.Y];
 
-			Action<int, int> MaybeEnqueue = (x, y) =>
+			Action<int, int> maybeEnqueue = (x, y) =>
 			{
 				if (s.Map.IsInMap(x, y) && !touched[x, y])
 				{
-					queue.Enqueue(new int2(x, y));
+					queue.Enqueue(new CPos(x, y));
 					touched[x, y] = true;
 				}
 			};
@@ -91,25 +91,25 @@ namespace OpenRA.Editor
 				if (!s.Map.MapTiles.Value[p.X, p.Y].Equals(replace))
 					continue;
 
-				var a = FindEdge(s, p, new int2(-1, 0), replace);
-				var b = FindEdge(s, p, new int2(1, 0), replace);
+				var a = FindEdge(s, p, new CVec(-1, 0), replace);
+				var b = FindEdge(s, p, new CVec(1, 0), replace);
 
 				for (var x = a.X; x <= b.X; x++)
 				{
 					s.Map.MapTiles.Value[x, p.Y] = new TileReference<ushort, byte> { type = Brush.N, index = (byte)0 };
 					if (s.Map.MapTiles.Value[x, p.Y - 1].Equals(replace))
-						MaybeEnqueue(x, p.Y - 1);
+						maybeEnqueue(x, p.Y - 1);
 					if (s.Map.MapTiles.Value[x, p.Y + 1].Equals(replace))
-						MaybeEnqueue(x, p.Y + 1);
+						maybeEnqueue(x, p.Y + 1);
 				}
 			}
 
-			/* todo: optimize */
+			/* TODO: optimize */
 			foreach (var ch in s.Chunks.Values) ch.Dispose();
 			s.Chunks.Clear();
 		}
 
-		int2 FindEdge(Surface s, int2 p, int2 d, TileReference<ushort, byte> replace)
+		CPos FindEdge(Surface s, CPos p, CVec d, TileReference<ushort, byte> replace)
 		{
 			for (; ; )
 			{

OpenRA.Editor/Form1.cs

@@ -1,6 +1,6 @@
-#region Copyright & License Information
+#region Copyright & License Information
 /*
- * Copyright 2007-2011 The OpenRA Developers (see AUTHORS)
+ * Copyright 2007-2013 The OpenRA Developers (see AUTHORS)
  * This file is part of OpenRA, which is free software. It is made
  * available to you under the terms of the GNU General Public License
  * as published by the Free Software Foundation. For more information,
@@ -42,14 +42,17 @@ namespace OpenRA.Editor
 				tilePalette.ResumeLayout();
 				actorPalette.ResumeLayout();
 				resourcePalette.ResumeLayout();
-				surface1.Bind(null, null, null);
+				surface1.Bind(null, null, null, null);
 				pmMiniMap.Image = null;
 				currentMod = toolStripComboBox1.SelectedItem as string;
 
-				Text = "OpenRA Editor (mod:{0})".F(currentMod);
 				Game.modData = new ModData(currentMod);
 				FileSystem.LoadFromManifest(Game.modData.Manifest);
 				Rules.LoadRules(Game.modData.Manifest, new Map());
+
+				var mod = Game.modData.Manifest.Mods[0];
+				Text = "{0} Mod Version: {1} - OpenRA Editor".F(Mod.AllMods[mod].Title, Mod.AllMods[mod].Version);			
+
 				loadedMapName = null;
 			};
 
@@ -67,6 +70,7 @@ namespace OpenRA.Editor
 		{
 			MakeDirty();
 			pmMiniMap.Image = Minimap.AddStaticResources(surface1.Map, Minimap.TerrainBitmap(surface1.Map, true));
+			cashToolStripStatusLabel.Text = CalculateTotalResource().ToString();
 		}
 
 		void ActorDoubleClicked(KeyValuePair<string,ActorReference> kv)
@@ -116,6 +120,8 @@ namespace OpenRA.Editor
 				map.MakeDefaultPlayers();
 
 			PrepareMapResources(Game.modData.Manifest, map);
+			//Calculate total net worth of resources in cash
+			cashToolStripStatusLabel.Text = CalculateTotalResource().ToString();
 
 			dirty = false;
 		}
@@ -138,38 +144,67 @@ namespace OpenRA.Editor
 			Rules.LoadRules(manifest, map);
 			tileset = Rules.TileSets[map.Tileset];
 			tileset.LoadTiles();
-			var palette = new Palette(FileSystem.Open(tileset.Palette), true);
+			int[] ShadowIndex = { 3, 4 };
+			var palette = new Palette(FileSystem.Open(tileset.Palette), ShadowIndex);
 
-			surface1.Bind(map, tileset, palette);
+			// required for desert terrain in RA
+			var playerPalette = tileset.PlayerPalette ?? tileset.Palette;
+			var PlayerPalette = new Palette(FileSystem.Open(playerPalette), ShadowIndex);
+
+			surface1.Bind(map, tileset, palette, PlayerPalette);
 			// construct the palette of tiles
 			var palettes = new[] { tilePalette, actorPalette, resourcePalette };
 			foreach (var p in palettes) { p.Visible = false; p.SuspendLayout(); }
-			foreach (var t in tileset.Templates)
+
+			string[] templateOrder = tileset.EditorTemplateOrder ?? new string[]{};
+			foreach (var tc in tileset.Templates.GroupBy(t => t.Value.Category).OrderBy(t => templateOrder.ToList().IndexOf(t.Key)))
 			{
-				try
+				var category = tc.Key ?? "(Uncategorized)";
+				var categoryHeader = new Label
 				{
-					var bitmap = tileset.RenderTemplate((ushort)t.Key, palette);
-					var ibox = new PictureBox
+					BackColor = SystemColors.Highlight,
+					ForeColor = SystemColors.HighlightText,
+					Text = category,
+					AutoSize = false,
+					Height = 24,
+					TextAlign = ContentAlignment.MiddleLeft,
+					Width = tilePalette.ClientSize.Width,
+				};
+				// hook this manually, anchoring inside FlowLayoutPanel is flaky.
+				tilePalette.Resize += (_,e) => categoryHeader.Width = tilePalette.ClientSize.Width;
+
+				if (tilePalette.Controls.Count > 0)
+					tilePalette.SetFlowBreak(
+						tilePalette.Controls[tilePalette.Controls.Count - 1], true);
+				tilePalette.Controls.Add(categoryHeader);
+
+				foreach( var t in tc )
+				{
+					try
 					{
-						Image = bitmap,
-						Width = bitmap.Width / 2,
-						Height = bitmap.Height / 2,
-						SizeMode = PictureBoxSizeMode.StretchImage
-					};
-
-					var brushTemplate = new BrushTemplate { Bitmap = bitmap, N = t.Key };
-					ibox.Click += (_, e) => surface1.SetTool(new BrushTool(brushTemplate));
-
-					var template = t.Value;
-					tilePalette.Controls.Add(ibox);
-					tt.SetToolTip(ibox,
-						"{1}:{0} ({2}x{3})".F(
-						template.Image,
-						template.Id,
-						template.Size.X,
-						template.Size.Y));
+						var bitmap = tileset.RenderTemplate((ushort)t.Key, palette);
+						var ibox = new PictureBox
+						{
+							Image = bitmap,
+							Width = bitmap.Width / 2,
+							Height = bitmap.Height / 2,
+							SizeMode = PictureBoxSizeMode.StretchImage
+						};
+	
+						var brushTemplate = new BrushTemplate { Bitmap = bitmap, N = t.Key };
+						ibox.Click += (_, e) => surface1.SetTool(new BrushTool(brushTemplate));
+	
+						var template = t.Value;
+						tilePalette.Controls.Add(ibox);
+						tt.SetToolTip(ibox,
+							"{1}:{0} ({2}x{3})".F(
+							template.Image,
+							template.Id,
+							template.Size.X,
+							template.Size.Y));
+					}
+					catch { }
 				}
-				catch { }
 			}
 
 			var actorTemplates = new List<ActorTemplate>();
@@ -187,7 +222,13 @@ namespace OpenRA.Editor
 					if (etf != null && etf.RequireTilesets != null
 						&& !etf.RequireTilesets.Contains(tileset.Id)) continue;
 
-					var template = RenderUtils.RenderActor(info, tileset, palette);
+					var TemplatePalette = PlayerPalette;
+					var rsi = info.Traits.GetOrDefault<RenderSimpleInfo>();
+					// exception for desert buildings
+					if (rsi != null && rsi.Palette != null && rsi.Palette.Contains("terrain"))
+						TemplatePalette = palette;
+
+					var template = RenderUtils.RenderActor(info, tileset, TemplatePalette);
 					var ibox = new PictureBox
 					{
 						Image = template.Bitmap,
@@ -218,7 +259,7 @@ namespace OpenRA.Editor
 			{
 				try
 				{
-					var template = RenderUtils.RenderResourceType(a, tileset.Extensions, palette);
+					var template = RenderUtils.RenderResourceType(a, tileset.Extensions, PlayerPalette);
 					var ibox = new PictureBox
 					{
 						Image = template.Bitmap,
@@ -255,10 +296,13 @@ namespace OpenRA.Editor
 			pmMiniMap.Image = Minimap.AddStaticResources(surface1.Map, Minimap.TerrainBitmap(surface1.Map, true));
 
 			propertiesToolStripMenuItem.Enabled = true;
+			toolStripMenuItemProperties.Enabled = true;
 			resizeToolStripMenuItem.Enabled = true;
+			toolStripMenuItemResize.Enabled = true;
 			saveToolStripMenuItem.Enabled = true;
+			toolStripMenuItemSave.Enabled = true;
 			saveAsToolStripMenuItem.Enabled = true;
-			mnuMinimapToPNG.Enabled = true;	// todo: what is this VB naming bullshit doing here?
+			mnuMinimapToPNG.Enabled = true;	// TODO: what is this VB naming bullshit doing here?
 
 			PopulateActorOwnerChooser();
 		}
@@ -286,14 +330,14 @@ namespace OpenRA.Editor
 					return;
 
 				surface1.Map.ResizeCordon((int)rd.cordonLeft.Value,
-									   (int)rd.cordonTop.Value,
-									   (int)rd.cordonRight.Value,
-									   (int)rd.cordonBottom.Value);
+					(int)rd.cordonTop.Value,
+					(int)rd.cordonRight.Value,
+					(int)rd.cordonBottom.Value);
 
 				if ((int)rd.width.Value != surface1.Map.MapSize.X || (int)rd.height.Value != surface1.Map.MapSize.Y)
 				{
 					surface1.Map.Resize((int)rd.width.Value, (int)rd.height.Value);
-					surface1.Bind(surface1.Map, surface1.TileSet, surface1.Palette);	// rebind it to invalidate all caches
+					surface1.Bind(surface1.Map, surface1.TileSet, surface1.Palette, surface1.PlayerPalette);	// rebind it to invalidate all caches
 				}
 
 				surface1.Invalidate();
@@ -362,6 +406,7 @@ namespace OpenRA.Editor
 					map.ResizeCordon((int)nmd.cordonLeft.Value, (int)nmd.cordonTop.Value,
 						(int)nmd.cordonRight.Value, (int)nmd.cordonBottom.Value);
 
+					map.Players.Clear();
 					map.MakeDefaultPlayers();
 
 					NewMap(map);
@@ -458,12 +503,14 @@ namespace OpenRA.Editor
 		void ShowActorNamesClicked(object sender, EventArgs e)
 		{
 			showActorNamesToolStripMenuItem.Checked ^= true;
+			toolStripMenuItemShowActorNames.Checked ^= true;
 			surface1.ShowActorNames = showActorNamesToolStripMenuItem.Checked;
 		}
 
 		void ShowGridClicked(object sender, EventArgs e)
 		{
 			showGridToolStripMenuItem.Checked ^= true;
+			toolStripMenuItemShowGrid.Checked ^= true;
 			surface1.ShowGrid = showGridToolStripMenuItem.Checked;
 			surface1.Chunks.Clear();
 		}
@@ -491,6 +538,7 @@ namespace OpenRA.Editor
 		void SetupDefaultPlayers(object sender, EventArgs e)
 		{
 			dirty = true;
+			surface1.Map.Players.Clear();
 			surface1.Map.MakeDefaultPlayers();
 
 			surface1.Chunks.Clear();
@@ -499,7 +547,7 @@ namespace OpenRA.Editor
 			PopulateActorOwnerChooser();
 		}
 
-		void onDrawPlayerItem(object sender, DrawItemEventArgs e)
+		void DrawPlayerListItem(object sender, DrawItemEventArgs e)
 		{
 			// color block
 			var player = e.Index >= 0 ? (PlayerReference)(sender as ComboBox).Items[e.Index] : null;
@@ -510,17 +558,203 @@ namespace OpenRA.Editor
 			if (player == null)
 				return;
 
-			var color = player.ColorRamp.GetColor(0);
+			var color = player.Color.RGB;
 			using( var brush = new SolidBrush(color) )
 				e.Graphics.FillRectangle( brush, e.Bounds.Left + 2, e.Bounds.Top + 2, e.Bounds.Height + 6, e.Bounds.Height - 4 );
 			using( var foreBrush = new SolidBrush(e.ForeColor) )
 				e.Graphics.DrawString( player.Name, e.Font, foreBrush, e.Bounds.Left + e.Bounds.Height + 12, e.Bounds.Top );
 		}
 
-		void onSelectOwner(object sender, EventArgs e)
+		void OnSelectedPlayerChanged(object sender, EventArgs e)
 		{
 			var player = actorOwnerChooser.SelectedItem as PlayerReference;
 			surface1.NewActorOwner = player.Name;
 		}
+
+		private void copySelectionToolStripMenuItemClick(object sender, EventArgs e)
+		{
+			surface1.CopySelection();
+		}
+
+		private void openRAWebsiteToolStripMenuItemClick(object sender, EventArgs e)
+		{
+			System.Diagnostics.Process.Start("http://www.open-ra.org");
+		}
+
+		private void openRAResourcesToolStripMenuItemClick(object sender, EventArgs e)
+		{
+			System.Diagnostics.Process.Start("http://content.open-ra.org");
+		}
+
+		private void wikiDocumentationToolStripMenuItemClick(object sender, EventArgs e)
+		{
+			System.Diagnostics.Process.Start("http://github.com/OpenRA/OpenRA/wiki");
+		}
+
+		private void discussionForumsToolStripMenuItemClick(object sender, EventArgs e)
+		{
+			System.Diagnostics.Process.Start("http://www.sleipnirstuff.com/forum/viewforum.php?f=80");
+		}
+
+		private void issueTrackerToolStripMenuItemClick(object sender, EventArgs e)
+		{
+			System.Diagnostics.Process.Start("http://github.com/OpenRA/OpenRA/issues");
+		}
+
+		private void developerBountiesToolStripMenuItemClick(object sender, EventArgs e)
+		{
+			System.Diagnostics.Process.Start("https://www.bountysource.com/#repos/OpenRA/OpenRA");
+		}
+
+		private void sourceCodeToolStripMenuItemClick(object sender, EventArgs e)
+		{
+			System.Diagnostics.Process.Start("http://github.com/OpenRA/OpenRA");
+		}
+
+		private void aboutToolStripMenuItemClick(object sender, EventArgs e)
+		{
+			MessageBox.Show("OpenRA and OpenRA Editor are Free/Libre Open Source Software released under the GNU General Public License version 3. See AUTHORS and COPYING for details.",
+							"About",
+							MessageBoxButtons.OK,
+							MessageBoxIcon.Asterisk);
+		}
+
+		private void helpToolStripButton_Click(object sender, EventArgs e)
+		{
+			System.Diagnostics.Process.Start("http://github.com/OpenRA/OpenRA/wiki/Mapping");
+		}
+
+		private void toolStripMenuItemNewClick(object sender, EventArgs e)
+		{
+			NewClicked(sender, e);
+		}
+
+		private void toolStripMenuItemOpenClick(object sender, EventArgs e)
+		{
+			OpenClicked(sender, e);
+		}
+
+		private void toolStripMenuItemSaveClick(object sender, EventArgs e)
+		{
+			SaveClicked(sender, e);
+		}
+
+		private void toolStripMenuItemPropertiesClick(object sender, EventArgs e)
+		{
+			PropertiesClicked(sender, e);
+		}
+
+		private void toolStripMenuItemResizeClick(object sender, EventArgs e)
+		{
+			ResizeClicked(sender, e);
+		}
+
+		private void toolStripMenuItemShowActorNamesClick(object sender, EventArgs e)
+		{
+			ShowActorNamesClicked(sender, e);
+		}
+
+		private void toolStripMenuItemFixOpenAreasClick(object sender, EventArgs e)
+		{
+			FixOpenAreas(sender, e);
+		}
+
+		private void toolStripMenuItemSetupDefaultPlayersClick(object sender, EventArgs e)
+		{
+			SetupDefaultPlayers(sender, e);
+		}
+
+		private void toolStripMenuItemCopySelectionClick(object sender, EventArgs e)
+		{
+			copySelectionToolStripMenuItemClick(sender, e);
+		}
+
+		private void toolStripMenuItemShowGridClick(object sender, EventArgs e)
+		{
+			ShowGridClicked(sender, e);
+		}
+		
+		public int CalculateTotalResource()
+		{
+			int TotalResource = 0;
+			for(int i = 0; i < surface1.Map.MapSize.X; i++)
+				for (int j = 0; j < surface1.Map.MapSize.Y; j++)
+				{
+					if (surface1.Map.MapResources.Value[i, j].type != 0)
+						TotalResource += GetResourceValue(i, j);
+				}
+			return TotalResource;
+		}
+		
+		int GetAdjecentCellsWith(int ResourceType, int x, int y)
+		{
+			int sum = 0;
+			for (var u = -1; u < 2; u++)
+				for (var v = -1; v < 2; v++)
+				{
+					if (!surface1.Map.IsInMap(new CPos(x + u, y + v)))
+						continue;
+					if (surface1.Map.MapResources.Value[x + u, y + v].type == ResourceType)
+						++sum;
+				}
+			return sum;
+		}
+
+		int GetResourceValue(int x, int y)
+		{
+			int ImageLength = 0;
+			int type = surface1.Map.MapResources.Value[x, y].type;
+			var template = surface1.ResourceTemplates.Where(a => a.Value.Info.ResourceType == type).FirstOrDefault().Value;
+			if (type == 1)
+				ImageLength = 12;
+			else if (type == 2)
+				ImageLength = 3;
+			int density = (GetAdjecentCellsWith(type ,x , y) * ImageLength - 1) / 9;
+			int value = template.Info.ValuePerUnit;
+			return (density) * value;
+		}
+
+		void zoomInToolStripButtonClick(object sender, System.EventArgs e)
+		{
+			if (surface1.Map == null) return;
+
+			surface1.Zoom /= .75f;
+
+			surface1.Invalidate();
+		}
+
+		void zoomOutToolStripButtonClick(object sender, System.EventArgs e)
+		{
+			if (surface1.Map == null) return;
+
+			surface1.Zoom *= .75f;
+
+			surface1.Invalidate();
+		}
+
+		void panToolStripButtonClick(object sender, System.EventArgs e)
+		{
+			panToolStripButton.Checked ^= true;
+			surface1.IsPanning = panToolStripButton.Checked;
+		}
+
+		void showRulerToolStripMenuItemClick(object sender, EventArgs e)
+		{
+			showRulerToolStripMenuItem.Checked ^= true;
+			showRulerToolStripItem.Checked ^= true;
+			surface1.ShowRuler = showRulerToolStripMenuItem.Checked;
+			surface1.Chunks.Clear();
+		}
+
+		void showRulerToolStripItemClick(object sender, System.EventArgs e)
+		{
+			showRulerToolStripMenuItemClick(sender, e);
+		}
+
+		void EraserToolStripButtonClick(object sender, System.EventArgs e)
+		{
+			eraserToolStripButton.Checked ^= true;
+			surface1.IsErasing = eraserToolStripButton.Checked;
+		}
 	}
 }

OpenRA.Editor/Form1.resx

@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <root>
   <!-- 
     Microsoft ResX Schema 
@@ -120,58 +120,292 @@
   <metadata name="tt.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
     <value>17, 17</value>
   </metadata>
-  <metadata name="saveFileDialog.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
-    <value>76, 17</value>
+  <metadata name="toolStrip1.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
+    <value>429, 17</value>
   </metadata>
+  <assembly alias="System.Drawing" name="System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
+  <data name="toolStripMenuItemNew.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
+        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAHPSURBVDhPpZFNTxNRFIb7W1y4NZpI4k/QrRs3rjSu/QMk
+        NjHGYCFgYYIWsaJidAKoUWqEgFiwGjE2ERREKEOZZtpa23H6OWX6OHN7CQaxNfFNTm5Oct7nnvten6fN
+        6AV+rPixM/2sTRzGNgKYGz0kF/2IgXayNIXNF8fADJB8fcY9e0lMHqGw3v1vAO9mLAXqMSx9zD2jot/6
+        cg3l3qSogbvPWViMHwxcVQ+hzZ6maEzgUKCcfSZ6faqDXV0PP6Xj1PmDIWIDMwjVWQHxNhF94ba0Q8/Q
+        OC8XlgRk/v0+iLU1SCJyFCfdSerNWdcYFBnUjLC0Q9fgQ2HeLWltSotdbP5C6gr6zAkSKzcoa32k435p
+        B6fR4NbYPENq9E/A7+odfiwte3K9VGp1cmaZ8VerHD957u+AwE1V2vZUtXfIWxW2Mz9Rp5dbA64OPJC2
+        puz6DmaxRuq7xddkjtHIx9aAy30j0up+huNglWoYuSLftvPE19LcefK2NeBS97AwO06DUsUmky+RSBX4
+        tJ4ltqQTejTXGtDZFXJDa1CpNkPTDJPPG1neLevMfNBQ7k+3B3iheWl7gXlvDrtrh9Q5lNEpgiOR9k/w
+        BtqVHP9f+Xy/AI/l932QyhfPAAAAAElFTkSuQmCC
+</value>
+  </data>
+  <data name="toolStripMenuItemOpen.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGOfPtRkwAAACBjSFJNAAB6
+        JQAAgIMAAPn/AACA6QAAdTAAAOpgAAA6mAAAF2+SX8VGAAAACXBIWXMAAAsMAAALDAE/QCLIAAACeUlE
+        QVQ4T6WSWUiUURiG/4suurJIjUIwskQsEAMjqosQpUVNKbdCSRPKrQVDMddmXEedGdcpFXNGnUYdrSzF
+        sEIoFInQcqHE1CwoKsXUUMnt6XfEye0munjgnO+c9+HjO0cA/osNi2tJLdA6SXN13MwoI12lJ06uiV8+
+        W3d5IwIjVXiGKvwX11djSs2TRFlUito7ILIAoVab7SvCWhqrZYq1omXC4gpPe4Ur8AjNMQjo69IwPVZj
+        4PeojtlhNfoyBXXalKSNBJ5hSjxCcnELzkeoKVcyNVq5Kjz/rZDZnggqSzOoKEpDXZBEcU4id+Sx5Mui
+        RcdfmVClyWLqh8YYXhDD9MVCT/CGrBPcK5Hx62uxMdxUm2XgiT6Tep2MhxVp6NXJ6IqllKlucTc3niJl
+        LKqsGINMqChOY+JTnqHtwRYJdZVK5gelMJSymo9ibSAOeiPhXTid1T5cD3IvF9SqZMb7M+CznEdVCtqe
+        ypcurWz9bQC0ezHX6sr0M0c+lNtx5cKJcVGwXyjJlfDzvZSh1gTqdHIWBiTQHbIU7AwSg+eYa3Nnuvk4
+        E41HGak9gDTUmvPOZjmGGRQqExjpiuG+NouOl2InvRGi4BJ0+LPw6gwzL04x2XSM0ToHvlfZ0p66FT9X
+        KxxsTGwMAlVmLN3NiTzQZkJ/IrwR233tzUyLG5PPHRmrP8Sw3o4vmr30yE2RBO/Bfp9Fg/EV8tKjqSnL
+        oOdxGO3ZgpE2+SaaZZtpSNpCdbw56mgLbt/YhZ/L7oVD9pYuRkF2ShTZksukxwQSd813cbJc9HHm7MnD
+        OB2x46CdNbZWFljuNGP7NhN2mJqIuRX/YOXm30H4A70P0TsBWkcYAAAAAElFTkSuQmCC
+</value>
+  </data>
+  <data name="toolStripMenuItemSave.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGOfPtRkwAAACBjSFJNAAB6
+        JQAAgIMAAPn/AACA6QAAdTAAAOpgAAA6mAAAF2+SX8VGAAAACXBIWXMAAAsMAAALDAE/QCLIAAACPklE
+        QVQ4T6WS70uTURTH9y/03jdBL3prU2O4FqvBU66hLB2GFtKvJ9Isfy3TJEXLVHT5A7QVLp20Wk3CiUb+
+        AH8gJmIsJSs1l7TEoabYRDD4ds99dI9Le1MHzvPi3OfzufeeexQA/iv5p7MjAEp32xpaXat45lhGc5Mf
+        j6zzqKv9BkuVF/dLZ1BU+Bn5eR+Qkz2OG9c9DN0SENjbA9TWbFDxr7G+sQl9Yi/OJL7iyUISuF6ucEF5
+        2Q8q7hkE+5fXcdT4GkqlCFOCk8qSwPF0iQuKCr9TcVdsw198K4gwuJF3axanjS20JAlsjQtccNM8TcWQ
+        2Am/n/LjoOBCZsYk4mJttCwJGup9XJB+bZyKwfgTHvL4EKZ1QBRHYTBY6RdJUFM9xwXi5VEq8tgL7hn5
+        in3RTUg+24+YmDr6TRJUlM+iuwvsKYGUC29hOjfIu00NozvTsWlnCe5DvOkNBMEiC0qKp9DuBpsBoMX+
+        i737T5TeW+RNpYbRndNSPUH4VFwbdLoyWXA7fxLO58AT2yYbnAD0SRkhaTxvRtLVAgmOZfBJJ7TaYllg
+        zplgMFD9IMB3JkjBliLUAsY+LWBiZhFi9l0c17dyWH3MDo2mQBbQWFofInhsEhB8JbcSH71L8M6vIuuO
+        BZFaO4ObEXnkMdTRubIgLfUdu/cahw/onNh/SMCL9gG4u4bQ3TeCweExnDCYoNQ0IorB4aoGqFSZIYL4
+        SxcH+HjShNGQ0DvTU1G3qWF0Z9qVkuDDUemy4N8Tit/kKu4LI/ykxwAAAABJRU5ErkJggg==
+</value>
+  </data>
+  <data name="toolStripMenuItemProperties.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGOfPtRkwAAACBjSFJNAAB6
+        JQAAgIMAAPn/AACA6QAAdTAAAOpgAAA6mAAAF2+SX8VGAAAACXBIWXMAAAsMAAALDAE/QCLIAAAB/klE
+        QVQ4T6WQ30tTUQDHz39QD0UQRlAPIkgPxh6yhCRCykGBL0WZjOytLKdl7KGHJmFYtAjH7uUWy3XvMswf
+        d3Ou8MdWils1ggZCRQ43lbbAwYpB4vbtnDMzrrsMw4cvB87h8/l+OQTAlqJ7ydL/7MEhGvQ9vQdZ6oLT
+        boVouwV7t4XFIvkFKMGB0nB23rqeX187kPl0CR/VJi5hsBh9VBo2nzuqgdPh0/gxeRhJXwWs8g3cDDSC
+        uH0fwKKMvIMyNI6/8DVTPT/bzh7RwAtqOWZdZWjpacZlbwOIMvIe+XweqdSCBo5HLLhqMnK4tfE4YmoV
+        QsIeeLp240rDXpzpPIXmfiOI7AlzAYMXo3c4PO4fpOdJzAVNXMImHyzfierK7TBU7ELlvh0Pj7XXwOSu
+        B+kdnsFqLo9kMo7O6xeQSMSQpZ8RDr3hktm+A6gz7IfgGoThxEX6UvgrKjAbb9eCOIemObAx6ZUcpqeC
+        MJ+vRWQug0B0WSNgoZJt5MnA22L4dw6LmRV8/p6l8E8Oq6FUkYCFSC8CHJKUUThcPg7bJA/uCyq6HcPr
+        kSeW9AXC84l/zXQ2a/7CmwuzWbNCYdGb0Bc4lLHCAtkPR6+Pw7bHdIGoXWB7GdMX2OXXtHkVS6w5WWie
+        XGtms0VvnMN33d/0BT2uV/xhsykSbLz4v4D8ATko6xzt+1ySAAAAAElFTkSuQmCC
+</value>
+  </data>
+  <data name="toolStripMenuItemResize.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
+        YQUAAAH3SURBVDhPrZJfSFNxFMf3rBk+iIH2oOCTIAlZSGCQPqgIqQ/5tHQpPiikBpIpCnuxYkWCokQg
+        qDcoNYZETZAhbII0dh92DdPNvJuj4f7epWa2vOvrzg/u8uqQkA4cztPn8/uee4/mv5RxgQfN2Xkbm9zc
+        EpujUyY2+w0TbJ5ZBL/9sAyCx2cWMcqZYHj5Dv3PJsF/FjE8aUZrH4eWXg7Njzjoeqb+ShU4/iee7MO4
+        jIB0gPsDI9B2PIYkScmORCK4Vt2iTkUvH4djhzI2fbsJeBC88EUl8Hg8aoESW1bg3zKiP2JY2/qO27pe
+        VGu7k3A4HIbL5TqdYIybZ/DPXzLCuwcQt/exIkZR0dAF3rHKYhMcDAbhcDjUAoKfvzJC2ovhayL2+tYO
+        hM0o+PUIbta349adDgYGAgH4/X7Y7fbTCfQvOHTqx9DY9QS19/oSL3eirK4NlwrKMD1nZqDX62UpLBaL
+        WqAfeo3VjW9oevAUn/gV1Nx9iGW7wCQEp2cXsSmKIhOkTNBjMLI9lV1DoVAysvG9GWlZheCmPyIzrzy1
+        gI6EvrIiIQHt7fP54Ha78WbWhAvZV5CRW5paQBd2/Fed7Mz8CmTkXMfFyzdSC+g86WU6EqfTCUEQYLPZ
+        YLVaGXCyr1bq1AK6bbL+SxeXa1FS1awWnK80miNVQhp+0k4xYAAAAABJRU5ErkJggg==
+</value>
+  </data>
+  <data name="toolStripMenuItemShowActorNames.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
+        YQUAAAGOSURBVDhPY/j//z9FGKsgKRirIAiHFm92CyjctB+bHDLGKgjCGa37/gcWbvzftvBaCDZ5GMYq
+        6Je/XtQ3d81/35x1/23j5r7FpgaGsQq6Zaya7Zi8fLZFzML/xgH9QNznj00dCGMVdExa9sUqdqGoWdi0
+        00b+ff8N/LpvYFMHwhgCrmlLE+1iF54AsU3DZ7mZhE79r+fT+U/Pp8MFXS0IYwg4Ji68ahk1WwvGNw6d
+        /ApowH9dz9ZdyOpgGIXjEDdX2Sp61n/DgP4Let7tVw38+67q+fV+0fFs/a9knfNX0SpLBVk9CKNwbGNm
+        bwT6e5+6fZGJik2ulaZThZWmW6OWpmvDfxWbApAhG5HVgzCcYRczg9s4ZNoXTecKUWQFIKzuWDEFaPt/
+        BYsMjCgFExbh06SMgiZt13St+eoQUvoSWYGyXUmEvFnSf2WgC1RsC/4rWqR/UDBL44bJgwl9v25RoGYt
+        JatMLXmTBHgAgrCSTYGoLFBMUjtQS1zTV0tSJ0hL1jgB1QBKMFZB4vF/BgBJP5kepjxMJgAAAABJRU5E
+        rkJggg==
+</value>
+  </data>
+  <data name="toolStripMenuItemShowGrid.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
+        YQUAAAFYSURBVDhPY6AqyJt9/z+UyZA1/TacHd93Cc4OaTwJZ2MAZAPSJt+Es2M6z8PZAbVHMQ0AaQTh
+        7Bn3/mcAbU6fcuN/ysSr/xOBNsd2nfsf0Xr6P8hmkGafyoP/PUr3/ncp3I5pUNZUhLNBmqFMhpDm43C2
+        R+luTI0wALIZykRxdmDtETjbpXAnpgEgZ2cgORukOaId5OzjQGcfBjvbDeTsgu3/7XK3/rfJ3PjfMm0d
+        pkEozgZqhjJRnA3SDGViAlCAQZnA0D4MZzshOdsifS2mAfE9VyDOBoc2wtkgm0F+dsje+t86c9N/89R1
+        /02TVv03jF/x3yB6KaZByKEN8jOUieJskGYoExMEITkbObSRA0wvBpvNcGfvBycSkJ8doKFtDtRskrQa
+        7Gy96GX/daIW/9eKWAjGUO0IgBLa2QhnG8Uvh7OxaoQBZGdbpCJCG9nZeA0gHTAwAACOffGU2o3WzAAA
+        AABJRU5ErkJggg==
+</value>
+  </data>
+  <data name="zoomIntoolStripButton.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
+        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAIiSURBVDhPpY/ta5JRGIct+hP61Oe+RR+KWBBB4cAg02ea
+        ewmKIEzWinIu2yDqUamslrS114qZ01m0Wol7oWXlxFVrmq5yzUk5lmyG6Zz6qKiLXz5qH3KjUbvgPodz
+        c37XOTeDhiTNG6a/+NhDI7Y77boB69X23mnxpc65843aVxqDi5u79DeGLU5Zm8Yw8fTZWNJk+wyTy4tO
+        oxXnmvTgC8lg+Snl4cLV5VSdvLapSW1499Ji/xmgEphPpOCNJuAIUDC65iBTD4JVUZ9mCWo3FyJ/YrI6
+        1PcMwzHfj0VQ6QwiqQyybUyF4jDPRNBjm0f1ZTV2888o8okiWjXGyaFRJwLxFGLpJVCZpZzAE0rA4l3E
+        Q2cQF7Qj2MkTh/OJImrlHRj1+OCNJHPB4tKP+6G4b8cegYQ+L0d2s/trz4v3sH+nMLWQgCecF73+FkX/
+        ZBBdVh8krYMoYdc48okiSJVO29Dcl3w+E4VlNpataE5gdIegs/mh7PuEyrpb4B0VUflEESLy9kaeUBFp
+        fGRB74cgnnxcwIPs3Oq3flw3unFM3g1mhQT6FuHKI9AcPHGFxTkijx+Xd+Gi1px9dQJ1bQM4JG3BXsFp
+        NMsIhN3KVSTVym0Nqsd3meXSsRK2OFZaVY/Kmhuz+w/skzJ3bMWbji2rS1ZgHb1wyjh8oozz35Ica5KQ
+        JGM9vf+W9Ku246yo9N9/QUMQxC6C4IxzuWxeobUWGIxfeWNbk9TvsLwAAAAASUVORK5CYII=
+</value>
+  </data>
+  <data name="zoomOutToolStripButton.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
+        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAIpSURBVDhPpY/da5JhGMYt+hM66riz6KCIBREUDgwyfedy
+        H0ERhMlaUc5lG0S9KpXVkrb2WTFzOotWK3EftKycuGpN07Vcc1KOJZthfsyvV9TF1et4OxBHo/aD+3m4
+        H+7reu6LlYckLZtmv/q5w6P2ex36Qdv1jr5ZyZWuhYtNujdao5u/MvQ3RqwuebvWOPn8xXjabP8Cs9uH
+        LpMNF5oNKBeRoYozqqPMaDHVp29sadYYP7y2On4FkxQWqQx8cQrOYBIm9wLkmiFwKhuyHGHdVkZSiNnm
+        1DwwjiT8P5eQzOYQy+QQTGUxE07BMhdDr30RNVc12Ft+TslICmnTmqaHx1y0KINEdhnJ3DIiVA7eMAWr
+        bwmPXSFc0o1it0ASZSSF1Ck6Meb1wxdLg26LyjARgPKhA/uE0nxfjPx2z7feVx/h+JHETISCN5rGFJ3/
+        7fc4BqZD6Lb5IW0bQgm31slICiHVel1jS3/65Vwc1vkEXXGY6dVNnjD09gBU/Z9RVX8HguPiJCMpREze
+        3SwQKWNNT6zo+xTCs6kIHtG5Ne8DuGny4ISiB+xKKQytotUj5Dl86hqHd0yROqnoxmWdhf51EvXtgzgi
+        a8V+4Vm0yAlEPao1TGpUOxrVT++zK2TjJVxJorS6AVW1t+YPHjogY+/ajned29Y2WYUN+YNXxisnynj/
+        bbLCukxIkrUxf/8xGVDvxHlx6b9vkYcgiD0EwZvg87kC5mk9sFi/AU2lZoSWJFHPAAAAAElFTkSuQmCC
+</value>
+  </data>
+  <data name="panToolStripButton.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
+        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAEQSURBVDhPpZE/DoJgDMWBydHR0SMY7sARSBg5AiO34Agc
+        g4mZkZGRxYQ4KCRGiSz1tRTiHxSMv6Sh9Ot7XynGF1amadZ4XhBrqcxhWdZeRSxukiShPM8JeYwaIT6b
+        sbBtWyqKgmB0QIkGhlzNziJ4BQenKIqITfDaIUTEvOY8meu6nLuIkRWiq6qK2Ai5St4NHMcRk6lpKAiC
+        cQrVPOWDuCxLqbPoadvIG+2dhA2YOI55goa/fdy2mkjDHL7vS8jy6rqWopqM435DL9sanudRmqZaXgb/
+        aohviB7btmmYYglhGEqoXNj8YoJ+3v5WlA/slphkWcYG117yzqwJln5EX9i3TyMmn8A5376Rzv8xjDs1
+        5wrrvlLxhgAAAABJRU5ErkJggg==
+</value>
+  </data>
+  <data name="showRulerToolStripItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
+        YQUAAAEiSURBVDhPvVO7TgJBFN2fovAHNDb+gLGywsbCxoTOxF/wgaLGRPGJNUEeglBaaKExWhF8E1kh
+        Cwsyxzl3d83Gip3Ck5zMvTtzz97cOWPtnFVBbmcusXVaEaZOytg8vsDGUUmYPCxi/aCAtXReuLp/jpW9
+        HCyCxWHML6X8yEP/G2i7wEcHqH8C96/AdQOITc56AvxzAMdxMD696GfAYAgeQlMXN1rAw5uX5+9CAmyZ
+        YDE5NhWXnAffW11Zb1+GstYeve/ZvwILy7uYmEno4jnZGJUiwIGF8bsxKjjtADqNLsBrCmDbjrmADs06
+        oEmUUuj19T033egCdJg7UPjqGc6A1gycdvOkzAToNB2adcCH8WwDV3WI0yIL8FWxKEx/6z9gWT/PHGlW
+        lc2EywAAAABJRU5ErkJggg==
+</value>
+  </data>
+  <data name="toolStripMenuItemFixOpenAreas.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
+        YQUAAAE/SURBVDhPY0ACokCsBaVhAJsYVsBvbGzsD6T/Q2l+HGI4gTwQ/wcBEA3lYxMDGQKjUQAxLpDH
+        ogYFIJsOY8MwjI/uIjAABRBMEQjg8jt2cSAnC00Qp01AAJOHGQoG6IpxugCIMTRjcwEIoCvGZSgYoIcB
+        NiBv6q79v3Rmwv+0Pv//EU32Xzwr9GqgcnCAbisIgMViGzz6G1cn/t9yZer/C892/e/fnfU/vF/3v3m2
+        ZA9EGVAhFifCxWLanH9uvDzh/8Zrk8Dh1bMn9X//nnSQAd+B8mAAshksCaKhfLiYT7Xh/21X5oDZMLDp
+        0lSQASC1YIDXBRbZ0j+7dyX9b9+VANbcvjMB7AKzLIkfQHk4wBkGJqni3cE9Gv97d6WAbQbRIL5xivhU
+        iDIiANC5HUD8CeRsoM1fjJPFJzEwMDAAAD8wxIeEhxEyAAAAAElFTkSuQmCC
+</value>
+  </data>
+  <data name="toolStripMenuItemSetupDefaultPlayers.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
+        YQUAAAD0SURBVDhPY0AD/9FoogEuDaQZdCzROe5YsvOJwwnODw7EO1S7KomLQaXwArAtIM33WrNef1ra
+        /f9NT/7/U/H2X9f6mXeCVRDjEpDNIM0/N876/3FS8f9byTb/Fzhp34ZK4wVg00HOBtkM0vyiKvT/1WDN
+        /z3G8q/AKohxAcjPIGeDbAZpXmch9mteYfb/Gct2EhWQ/0EBBvIzyNkgm8t8A/9X10/6DwLEGoICXCKK
+        /vfP2fr/2p1nJBkCUwSmHUMLwIZcv/ucJENQAMyQG3coMMQprBBsyO17T8k3xNgj+b9rZBF1DAFhqBDp
+        AGQIlEkNwMAAAP7JtzLCVbRNAAAAAElFTkSuQmCC
+</value>
+  </data>
+  <data name="eraserToolStripButton.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
+        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAD2SURBVDhPY6ApmLlqNz+Irmqd/H/aqpP/S3s2/W+etuM/
+        SKy8YxVYDidA1gwDv37/+X/i4sP/xR1rwYbgBNg0//z15/+9px/+3370HmxI7cQN2A3Bpfn1+29wA0Ag
+        o2YmpgHEam6buvm/V1wVqgGkaMYwgCLNMECqZpe0crClYACKYxggWTMIzFx7+v/zN1/+P3z+8f+7j99J
+        0wwCzTN2/992+Ob/tXuv/j9w5j5Q8zu45saJy/FrhoGs+nn/SzsW/58FdM3s9Wf+L9l8/P+MZTuxBxg6
+        SCufCTc5Jq/tf0r5hP9xhZ0gjcRgBAhN68DtRNoABgYAAoqNFseCkuMAAAAASUVORK5CYII=
+</value>
+  </data>
+  <data name="toolStripMenuItemCopySelection.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
+        YQUAAAJVSURBVDhPpZPdS5NhGMZ3LKJ/gzsrHg3sIFsm5A46cC3ImmnWOy0/lrMtpdbct5tbH5Op6eZH
+        6lrvtOYqTTdxrUyCTgoKlSwiAjHICAOro7VdPe+7aRSyhC64eeDhvn73/b4Xj+BvRcc8WRPDphKnUYG2
+        iwxam07AY6sqsTVXZKVa0itypyeHQrD63LhZ1MxVTqolvSZZF5ke7dwKQFIt6RUYvJLD9tm3AmxvA2rO
+        uO+1iv0ey6a52yIX0zMj1fJvsb02srEFB7Coy7a3/obYXjsPSLzVQlt3GNp6aXrAk4nBzEf3+oWRQA8J
+        +ztIcOiq1N/rQGKpCecZMTrN9VK2x0R8XQbi7dAJh10tmSmrQPD4bl/2s7CXmR0fBI0Q4ZEOTPraMe67
+        huCAA4EbbRj1tIJ1m0EBoADc6tIzbrs6CaFTc7ncvy3PAGtzfCW+zCL+OYqfn2YQ+xhCfDWyeb8yH8B1
+        ayOc+hohD5hiXYVc7rx5qRnxhUboa/OhO50HrXwnWqoJjA17EV9UIfayHu8eHIW+4QgMytLkfxkbsBfe
+        9lgRW5nC+sMSrE0dwPe5UhgUeyhoN3RnduHHUxnWoxJ8DRXjVX8+lBVFUJ0sTgL8bksul/nyCx/mhwqw
+        eHM/PkSq8H66EsrjO/AmKMHrETEWvCLeHGrLg0ImwtmyfclP8HWbsv1uU3W7vg4ODcOXjT4gmj2/qqb2
+        EJrkB3GuspifzJnV5QWM4pjodxKdZmWmU1cjvHypitgvnCIUQMwqGaEAoqmREAogFEAayosIN/kP8/9J
+        IPgFAlSB3U6URz4AAAAASUVORK5CYII=
+</value>
+  </data>
+  <data name="QuickhelpToolStripButton.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
+        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAIVSURBVDhPtVJNaxNRFM1PyE+Yn1AUXLjK0uWgDWQZwUUX
+        KsGFBEEcCkIwqBEpGiydsSo2kupsasdo7Yi2toh0sFZjG5JpiZo20/TpVOmH5njvm8BYahEXHji8+968
+        c+55l4n8F0zM+rhVWkHmdg29A/PoK1Yw8uIjOp/3xpvqBgrjLeilZbjNLXxZ34bwt6jexMVCGRndQenl
+        0p+NWHzPXoP3rQ3bAbQhQM0E5Np2BKprbZzrm8TIs8puE+68+r0NwwZiacCwALEBCVcAqet8JlAjk1PZ
+        JzsNJt6u4+FMS3ZmMV9mmFNAMhesbBZLC6oFdOsd8oVXocmdx018Ej9k1FgqiJ0zgS6qlR6BVI4iEFRN
+        IJlxMF/1cfTMcGiQvbskB6ZqgairJ6BCTJKYu9tlAUW1oSRsNDwfB+JXQ4PzN6s07W0ZPxDS5aSgJEFn
+        06Y9CaOqSauJRvMr9qmXQ4P8/RoWvU16eyBUEq5kbigwiKoOMTBQ0zbKlTq6TxihwejkZ1iOJwfEwmiC
+        BQ49yaW50J7Fh0xJw3IxbM3hwo2x0ICRHZzFgveTunYERK5lgo5YMxx8WPFw5Li+U8wYm66jNz+Naov+
+        Beqiao58N5NrPluoryJO0QeKU7sNGKPPazh9aRzGo/eYmVvEMk270fTlmzl2N3XW9xL/jv7iaxw7+wAH
+        E9ew//AVxE8OItv/9O/Cf0ck8gud2vKswuxNZgAAAABJRU5ErkJggg==
+</value>
+  </data>
   <metadata name="menuStrip1.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
     <value>198, 17</value>
   </metadata>
-  <assembly alias="System.Drawing" name="System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
   <data name="newToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
     <value>
         iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAHNSURBVDhPjZNdTxNREIb5LV54azSRxJ8gt95445XGa/8A
-        CU0MMVgIWNmgRSioGN0AapQaISAWrEaITQTkQyhL2WbbWtt1+7ll+7h7SDdBocskk3Mm58xzZt7JaWmx
-        bTdyk9/rPsz0fbYmz2JqfvSdHhJLPpxzTzMUid13F0D3k/h41V57iU+dI7/dfTqA8zKGBLUohjpurxER
-        7/24i/RkSnj/47csLsWOB27IZ1DmrlDQJrHIU8q8EbE63UrD7oVe09p243iIqEAPQGVOQJxKRJwfdgE9
-        gxO8X1wRkIWv/1Ri7A0QD5/HSrWT/HTNTgwIDapayAV0DTwXyQ0/IqwSvXU4hWQn6uwl4usPKCl9pGI+
-        F2DV6zwaX2BQjgjIiZPpHXrpJjU2di7lao2sXmLiwwYXL18/GeB/KP8HqJgH5Iwy++k/yDOrzQF3+p8d
-        AZi1A/RCleQvg81ElrHwt+aA232jLqBmWRjFKlq2wM/9HLGtFCOvPjcHdHQPCYBl1SmWTdK5IvFknu/b
-        GaIrKsEX880B7V1B6rZq5cqhaIqms7aT4cuqyuyygvR0xhvgiOao7Qjm9Byyyw7K80hj0wRGw94tOGPy
-        cs8fetoLfwGP5fd9L1vD4gAAAABJRU5ErkJggg==
+        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAHPSURBVDhPpZFNTxNRFIb7W1y4NZpI4k/QrRs3rjSu/QMk
+        NjHGYCFgYYIWsaJidAKoUWqEgFiwGjE2ERREKEOZZtpa23H6OWX6OHN7CQaxNfFNTm5Oct7nnvten6fN
+        6AV+rPixM/2sTRzGNgKYGz0kF/2IgXayNIXNF8fADJB8fcY9e0lMHqGw3v1vAO9mLAXqMSx9zD2jot/6
+        cg3l3qSogbvPWViMHwxcVQ+hzZ6maEzgUKCcfSZ6faqDXV0PP6Xj1PmDIWIDMwjVWQHxNhF94ba0Q8/Q
+        OC8XlgRk/v0+iLU1SCJyFCfdSerNWdcYFBnUjLC0Q9fgQ2HeLWltSotdbP5C6gr6zAkSKzcoa32k435p
+        B6fR4NbYPENq9E/A7+odfiwte3K9VGp1cmaZ8VerHD957u+AwE1V2vZUtXfIWxW2Mz9Rp5dbA64OPJC2
+        puz6DmaxRuq7xddkjtHIx9aAy30j0up+huNglWoYuSLftvPE19LcefK2NeBS97AwO06DUsUmky+RSBX4
+        tJ4ltqQTejTXGtDZFXJDa1CpNkPTDJPPG1neLevMfNBQ7k+3B3iheWl7gXlvDrtrh9Q5lNEpgiOR9k/w
+        BtqVHP9f+Xy/AI/l932QyhfPAAAAAElFTkSuQmCC
 </value>
   </data>
   <data name="openToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
     <value>
         iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGOfPtRkwAAACBjSFJNAAB6
-        JQAAgIMAAPn/AACA6QAAdTAAAOpgAAA6mAAAF2+SX8VGAAAACXBIWXMAAAsMAAALDAE/QCLIAAACeklE
-        QVQ4T6WTWUiUURiG/4suurJIjUIwskQsEANDqosQpUVNKbdCSRPKrQVDMddmXEedGdcpFXNGnUYdrSzF
-        sEIoFInQcqHE1CwoKsXUUMnt6Z+RLMtA8OK5OZz3Oe/5OEcAhPWwpnBaodZZmqfjWmY5GSo98XJNwq9D
-        1yQIilLhFaYIMIQuxZaZJ4uy6FS1T2BUIUKdNsdPhL9pqpEp/ne18PiiE94RCjzDco0C+rs1zIzXGvkx
-        pmNuRI2+XEG9NjV5NYlXuBLP0DzcQwoQaiuUTI9VrQgvfC5irjeSqrJMKovTURcmU5KbxE15HAWyGNH5
-        e/BCtSab6a+a5ZMXxTD9cdAbsir/CG6Xyvj+qcRY2xBurss28lCfRYNOxr3KdPTqFHQlUspV17mVl0Cx
-        Mg5VdqyxjVBZks7k+3wMtYdaJdRXKVkYksJw6kreiWuD8dAXBa8j6Krx5UqwR4WgVqUwMZAJH+Tcr1bQ
-        /ki+tOnPK7wKhA5v5tvcmHnsxNsKOy6ePTohCvYKpXkSvr2RMtyWSL1OzuKgBHpClwRdwWLwNPPtHsy0
-        HGGy6RCjdfuQhllzxsUs1zBMoUiZyGh3LHe02XQ+E5v0RYqC89AZwOLzk8w+Pc5U82HG6h34Um1LR9pm
-        /N2scLAxsTEKVFlx9LQkcVebBQNJ8FKs+8KH2VZ3pp44Md7gyIjejo+a3fTKTZGE7MJ+j0Xj8lPOz4ih
-        tjyT3gfhdOQIy7TLN9Ai20hj8iZqEsxRx1hw4+oO/F13LjraW7ouC3JSo8mRXCAjNoj4y36GyXLO14VT
-        xw7gfNCO/XbW2FpZYLndjK1bTNhmarLyIa3nKxuyPwG9D9E7Fbto+QAAAABJRU5ErkJggg==
+        JQAAgIMAAPn/AACA6QAAdTAAAOpgAAA6mAAAF2+SX8VGAAAACXBIWXMAAAsMAAALDAE/QCLIAAACeUlE
+        QVQ4T6WSWUiUURiG/4suurJIjUIwskQsEAMjqosQpUVNKbdCSRPKrQVDMddmXEedGdcpFXNGnUYdrSzF
+        sEIoFInQcqHE1CwoKsXUUMnt6XfEye0munjgnO+c9+HjO0cA/osNi2tJLdA6SXN13MwoI12lJ06uiV8+
+        W3d5IwIjVXiGKvwX11djSs2TRFlUito7ILIAoVab7SvCWhqrZYq1omXC4gpPe4Ur8AjNMQjo69IwPVZj
+        4PeojtlhNfoyBXXalKSNBJ5hSjxCcnELzkeoKVcyNVq5Kjz/rZDZnggqSzOoKEpDXZBEcU4id+Sx5Mui
+        RcdfmVClyWLqh8YYXhDD9MVCT/CGrBPcK5Hx62uxMdxUm2XgiT6Tep2MhxVp6NXJ6IqllKlucTc3niJl
+        LKqsGINMqChOY+JTnqHtwRYJdZVK5gelMJSymo9ibSAOeiPhXTid1T5cD3IvF9SqZMb7M+CznEdVCtqe
+        ypcurWz9bQC0ezHX6sr0M0c+lNtx5cKJcVGwXyjJlfDzvZSh1gTqdHIWBiTQHbIU7AwSg+eYa3Nnuvk4
+        E41HGak9gDTUmvPOZjmGGRQqExjpiuG+NouOl2InvRGi4BJ0+LPw6gwzL04x2XSM0ToHvlfZ0p66FT9X
+        KxxsTGwMAlVmLN3NiTzQZkJ/IrwR233tzUyLG5PPHRmrP8Sw3o4vmr30yE2RBO/Bfp9Fg/EV8tKjqSnL
+        oOdxGO3ZgpE2+SaaZZtpSNpCdbw56mgLbt/YhZ/L7oVD9pYuRkF2ShTZksukxwQSd813cbJc9HHm7MnD
+        OB2x46CdNbZWFljuNGP7NhN2mJqIuRX/YOXm30H4A70P0TsBWkcYAAAAAElFTkSuQmCC
 </value>
   </data>
   <data name="saveToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
     <value>
         iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGOfPtRkwAAACBjSFJNAAB6
-        JQAAgIMAAPn/AACA6QAAdTAAAOpgAAA6mAAAF2+SX8VGAAAACXBIWXMAAAsMAAALDAE/QCLIAAACMklE
-        QVQ4T6WT3UuTcRTH9y90303QRbc1NYZrMRs86hzKsmFoIb09kqZpunxJUqxMxZYvkK1w6sTlahJOKvIF
-        TJEUMZaSlZkrWuJQU3QiGHz7nZ+wn0vrQh84Nw98Puc553wfBQDFXorDL18EQOXuXEGHaxlPHItoafbj
-        kXUW9XU/YLnnxd3yaZSWfEZR4Qfk5Y7japaHoVBwAYF9vUBd7Tq9/Oeztr4BfVIfTic95xUUuJ4tcUFl
-        xa//wv7FNRw3voJSKcN0yikEjrYFLigt+bmjgDoT/NW3hDCDG4UFMzhpbBUCW+McF1w3f9km2Aq/n/Lj
-        kORCTvYkEuJtQtDwwMcFmVfGQwR/w0MeH/ZrHZDlURgMViGorfnOBfKl0aBgJ7h35Bv2RTYj5cwbxMbW
-        C0FV5Qx6usFOCaSeH4bp7CDfNi2MZqbPps6bcD8STa8hSRYhuFU2hS43WAaAVvtvdvdVlN+Z50ulhdHM
-        GemeIByX0AmdrkIIbhRNwtkONNk2WHAC0Cdnh5TxnBnJl4t557h4Bsc4odWWCYE5b4LBQM39AO9MAgXL
-        WJhawtinOUxMz0POvY0T+g4Oq6Ps0GiKhYBiaX2I4GeTgOC0/Gp89C7AO7uMazctCNfaGdyC8GOPoY7M
-        F4KM9Hds7hU+80GdEweOSHjaNQB39xB6+kcw+HYM0QYTlJpGRDD4sKoBKlVOiCDx4oUBHk9KGIWE7kyn
-        om3Twmhm6kpF8NGITCGgn2K39QfkKu4LIHJHnwAAAABJRU5ErkJggg==
+        JQAAgIMAAPn/AACA6QAAdTAAAOpgAAA6mAAAF2+SX8VGAAAACXBIWXMAAAsMAAALDAE/QCLIAAACPklE
+        QVQ4T6WS70uTURTH9y/03jdBL3prU2O4FqvBU66hLB2GFtKvJ9Isfy3TJEXLVHT5A7QVLp20Wk3CiUb+
+        AH8gJmIsJSs1l7TEoabYRDD4ds99dI9Le1MHzvPi3OfzufeeexQA/iv5p7MjAEp32xpaXat45lhGc5Mf
+        j6zzqKv9BkuVF/dLZ1BU+Bn5eR+Qkz2OG9c9DN0SENjbA9TWbFDxr7G+sQl9Yi/OJL7iyUISuF6ucEF5
+        2Q8q7hkE+5fXcdT4GkqlCFOCk8qSwPF0iQuKCr9TcVdsw198K4gwuJF3axanjS20JAlsjQtccNM8TcWQ
+        2Am/n/LjoOBCZsYk4mJttCwJGup9XJB+bZyKwfgTHvL4EKZ1QBRHYTBY6RdJUFM9xwXi5VEq8tgL7hn5
+        in3RTUg+24+YmDr6TRJUlM+iuwvsKYGUC29hOjfIu00NozvTsWlnCe5DvOkNBMEiC0qKp9DuBpsBoMX+
+        i737T5TeW+RNpYbRndNSPUH4VFwbdLoyWXA7fxLO58AT2yYbnAD0SRkhaTxvRtLVAgmOZfBJJ7TaYllg
+        zplgMFD9IMB3JkjBliLUAsY+LWBiZhFi9l0c17dyWH3MDo2mQBbQWFofInhsEhB8JbcSH71L8M6vIuuO
+        BZFaO4ObEXnkMdTRubIgLfUdu/cahw/onNh/SMCL9gG4u4bQ3TeCweExnDCYoNQ0IorB4aoGqFSZIYL4
+        SxcH+HjShNGQ0DvTU1G3qWF0Z9qVkuDDUemy4N8Tit/kKu4LI/ykxwAAAABJRU5ErkJggg==
+</value>
+  </data>
+  <data name="saveAsToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGPC/xhBQAAABh0RVh0U29m
+        dHdhcmUAUGFpbnQuTkVUIHYyLjY0giIQKQAAAuxJREFUOE+Vk2lIlFEUho/1x6XUSiVBgqQQosgy0VRy
+        NxlcskSlQsUkcpd0bFxScy3Lbai0UMfGHJdRc5/QwEpaQFBrSEz9kUtqbqWmlYRv1+v8KPpTLxw4fPc+
+        z+Xcy0f/Eze3gwQMkDgxjRCfAAQFqVb+Id7exrS6GkNpWQepIE/447m4EIiKmueLivYVamtdpZbmZWpv
+        X6SmxgWqrZmlCuk0lZVOUGGBkmSyDjIzUyOFwguACPniTFSlpmdxmBXaWlfQ+GgJDQ2fUV01h3LJNIqL
+        PuK2eAw5Nz4gJaUBnZ0uDE5AT48fdHS3iIFmYqd+3TgZDfXreNK5xjb8ndHxl+jqcmedCP39PjAy0ryq
+        VIaSQGBPVF+3yOoL6uRraG5a2iR+y8zsLORyU9aJWIXA0NAEG2Nra2/j45OscoEqH86jtuY7ams/cWgj
+        6+vsvge7mXgDToTyjSf0d+/DWb82LtDS0uc8ScpmqLRkms29Aql0bJNm6VM+Q+NNC9YJ0dvrAQdXZ9id
+        6oafr1wlMOA83SuepKK7E6h4sASJZGiTZsnOy0L1FRNMFVnhpLMZEot6YOr6GGe8pH8KxIUTlHtrFK9f
+        AXn5U7C0a4O5Yyf09sexjYasDLD1qAR7beUICngBgeAeF2hqqkZgT0SZGSNQtIO9BFBasob83EVkZ01D
+        KBxGdNQAoiP6cP7cU7ifVsDFRawS6HGerqWOUFLiILtE4H4xEBxRjsO2DjB39kRIQjYikzPhcyENbh4d
+        cBLUw94+hws0NHZxnuJF70kY+w6SMiA35xvCYuqxfaceDhxzwPJPYHxuBb7B12FlL4e1oww2JzJUgp2c
+        p5jLAxQV+ZafHh47hkOOIoSLklBS04Lh0UkMjgzB0T0MR6xlMLORwtIqmQvU1XdwniLC+ig8tN85IqwH
+        3j6NsHMpREBgBS5eqkRgYAn8/e/A2iYOVjbpOM5gS4sYlUCX86Srs4f9ovzbP8fY2InU1LawjugX1Iz1
+        h1pVBKcAAAAASUVORK5CYII=
 </value>
   </data>
   <data name="cCRedAlertMapToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
@@ -221,85 +455,382 @@
         XTesb3QPLh88M+QwdP6m681Lt7xuXbu94vbgcOjwnZHokdE77DtTd1PuvriXeW/h/sYH6AdFD6UeVjxS
         fNTws+7PbaOWo6fHXMf6Hwc/vj/OGn/2S8Yv7ycKnpCfVEyqTDZPmU2dmnafvvF05dOJZ+nPFmYKf5X+
         tfa5zvMffnP8rX82YnbiBf/Fp99LXsq/PPRq2aueuYC5R69TXy/MF72Rf3P4LeNt37vwd5MLWe+x7ys/
-        6H7o/ujz8cGn1E+f/gUDmPP8usTo0wAAAAlwSFlzAAALDAAACwwBP0AiyAAAAN5JREFUOE+FUwEOAyEI
-        8+k+7X7GoFBWmZdtISYgtS3csrXsFtvzf2Mv8/8d4Hkec2SLM+IHzJsjdwVAcxQrtl8OsDgBxPMGgKJG
-        SQkwMlI2zSCS+cuL0YCceHEDAcBbM6gTQOhDDpnBxHqVOsmgdYvmfCxk7q+JpDZN4yQOJhOAOtmslGna
-        MYE3AN2HeBEmyvhYZ44mL5rRXkijgoAZAA3nCVBzbzM5vuE8x8xmbGIzqE1LkNwHOO2RZmZOjQYTjoWF
-        g/YYr+qn2QBQSl2ofL8oC6Wb2hIOM8WD+bXOex/mMAFDkP1eQgAAAABJRU5ErkJggg==
+        6H7o/ujz8cGn1E+f/gUDmPP8usTo0wAAAAlwSFlzAAALDAAACwwBP0AiyAAAANZJREFUOE+NUAkOwyAM
+        4+k8rT9jthMHyqJpSG4gPkgZa4zVYf6DCXtnJp7nWdioEp2ZtQ2QGXUkKEajTFXJ22SIPMEewCCG3NNU
+        AA+xQqibD05inq8QBUio9TZzggrwNOxBoz2gABtFpMC3yWhzIvpzB1jMqtszRI+ZIdS1AWpwkyhhE/Iz
+        4ATF5ySewBx74gEFVAiIL1Hud3+pvgPQKGGKbTAfHNc27wCAxC3UfwLxDtGj2ZMR8QYHYTKCNmywFp89
+        gUyJIi6YP0OkKyIBpiDx3UvEeawP5jABQ7IsMkAAAAAASUVORK5CYII=
 </value>
   </data>
-  <data name="bitmapToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+  <data name="toolStripMenuItem1.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
     <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGOfPtRkwAAACBjSFJNAAB6
-        JQAAgIMAAPn/AACA6QAAdTAAAOpgAAA6mAAAF2+SX8VGAAAACXBIWXMAAAsMAAALDAE/QCLIAAACR0lE
-        QVQ4T6WTXUiTARSGdxkRRBdB0IUREV1EKRFEYYuQAklL8sKQfphUoJSUWJbLxAVZWqyBio5WajorM1PL
-        xExUlLQfbU5n0lygRerMP/qxOZ92vpjfCKLAi3P5Puc957xHA2gWUoo49147gWUqbSPrdjOXChrQm56S
-        lFVFvKEcXaqV2OQiohMt7Esw+6Ro5gGeWfhbff0BY9NzDI3N0f/JS6fLy7rd6f8HcNsdOI6EYD8cjK3V
-        roiLawdYu+vivwHSWcQM1THz/DQv96+ixeHlVvU71oQFAGTmP+37bdsPBf8WZ4fRFhVEXdcsBQ9srN6Z
-        pjqQhQUCAmcW29JZxA8fvaWyY5YcawdBOy6oANm2H9A3MMypDLNS7b1flJnFtnQWcVmrB2NhMytD9SpA
-        TiUA5+CYInQOjWPrH2V7RBzmijdo9x5VKr+yj6ImD9nmelZsS1UBcme/+OPIJIOfv/Gi201ZXQ/hMfFU
-        Peuktqnbd3QN+U/cXM6tYfmW8ypAQiKdh91TTE7PYHNOYKl6z916F3m+eSNjT1B4vxHjzWoFYrhRwbLN
-        51SAJOynx8vo5Ay9rimKHzu5XtJDpuU1WZY2Eg1WgrXRJOpNxKdcUyBLN6WoAInnyPh3XvW6KW/4MC9O
-        z2ki+Wo1CWklROkMCiT8wEm0kXEsCTmrAiTbDtcEpTVdZOS1oDfWk5xZ6RPeQZeUR8zxK0Qe1BO65xjr
-        t0YotXhjAEAeQ7It8ZSESUjkznIq2bYsTGYW29JZxIs2nFEdLOSdfwFwpvLxRKIY2AAAAABJRU5ErkJg
-        gg==
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
+        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAALOSURBVDhPfZPdS1NhHMdPWKREEhWE3fRXFBHUXS9ahnZV
+        kV2UvVx5UUQXZmnLJc5ZvmRN2YVhdBGsFxqjFU4jaIavIxWNHXWbb2c7U7c8m+n2yfO00hX0gS8858fv
+        931+z3N+j7SeJEn6An00f2nG2mul4kMF123XufbiGk0dTYwHx4n/iJNKT2dqYYr6z/W0DbahLCusJFaE
+        dHTj7oluDG8MmB1mIlok3USJKhhdRnzffaLgf7i+umh0NKZ3Yuo0IUfkVMoa7XI7tiFb6mu1k2SSxI8E
+        9q63XHpySXQojcyO0NxjSaWsoWoqe2r3kFGWgf2bPRWFaDSKFtE4Yz6NZ8KDZHbVIMf/3V3nmecZUqnE
+        1sqtdIx3iFgsFmNOncM94CavMhdJv+XfJJIJtBWN+HJcSL+8hq4GNpVuIseU88ckqATxjfs4db8QqaCu
+        QAR1+qf72f9oP3ste4X2WfZxoOUA2cZs0cmWu1twjDpYnF8kPBOm5EkJ0nFTHrGlmDBwB9zsMu5ie/V2
+        dlTvYGf1TnbX7CazMhPptsSGWxuwdFmIhqOEJlVKHq8anDIX0jncKQxiyzFGw6N4w16hycgkLT0tZN3J
+        YnP5Zp4OPIVlCAQC9Hr6KKotQjLY7nKj7YYw+Bun18m2e9vYWLaR1v5WEdPPPzE2wav2l+Qb85G8s14O
+        lR3Er/pJJBJCOtPRabIrV89+U8LabdXHkVAohCzL+L1+Lj64gOlV9a9humK5TJWtSvyihYUFtEWNpfgS
+        5e3l1H6qhfjqzsEg8pjM2Lcxnjuec7Ti8NpIq1GVs3VnqH9TjzavMReaIxwMoyoqISVEwB8Qbfu8Pl67
+        XnOk4ggfhzrT38Ps/CznG89T3FCM0/2OweFBpv0zKH5FrJ2fnJRaS8k1HMPe8za9eD3vPe+52nyVogfn
+        yDecIK88l5P38iluKqbO/pBgJLiuWJJ+AqhM3amQCvIQAAAAAElFTkSuQmCC
 </value>
   </data>
   <data name="mnuMinimapToPNG.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
     <value>
         iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGOfPtRkwAAACBjSFJNAAB6
-        JQAAgIMAAPn/AACA6QAAdTAAAOpgAAA6mAAAF2+SX8VGAAAACXBIWXMAAAsMAAALDAE/QCLIAAACR0lE
-        QVQ4T6WTXUiTARSGdxkRRBdB0IUREV1EKRFEYYuQAklL8sKQfphUoJSUWJbLxAVZWqyBio5WajorM1PL
-        xExUlLQfbU5n0lygRerMP/qxOZ92vpjfCKLAi3P5Puc957xHA2gWUoo49147gWUqbSPrdjOXChrQm56S
-        lFVFvKEcXaqV2OQiohMt7Esw+6Ro5gGeWfhbff0BY9NzDI3N0f/JS6fLy7rd6f8HcNsdOI6EYD8cjK3V
-        roiLawdYu+vivwHSWcQM1THz/DQv96+ixeHlVvU71oQFAGTmP+37bdsPBf8WZ4fRFhVEXdcsBQ9srN6Z
-        pjqQhQUCAmcW29JZxA8fvaWyY5YcawdBOy6oANm2H9A3MMypDLNS7b1flJnFtnQWcVmrB2NhMytD9SpA
-        TiUA5+CYInQOjWPrH2V7RBzmijdo9x5VKr+yj6ImD9nmelZsS1UBcme/+OPIJIOfv/Gi201ZXQ/hMfFU
-        Peuktqnbd3QN+U/cXM6tYfmW8ypAQiKdh91TTE7PYHNOYKl6z916F3m+eSNjT1B4vxHjzWoFYrhRwbLN
-        51SAJOynx8vo5Ay9rimKHzu5XtJDpuU1WZY2Eg1WgrXRJOpNxKdcUyBLN6WoAInnyPh3XvW6KW/4MC9O
-        z2ki+Wo1CWklROkMCiT8wEm0kXEsCTmrAiTbDtcEpTVdZOS1oDfWk5xZ6RPeQZeUR8zxK0Qe1BO65xjr
-        t0YotXhjAEAeQ7It8ZSESUjkznIq2bYsTGYW29JZxIs2nFEdLOSdfwFwpvLxRKIY2AAAAABJRU5ErkJg
-        gg==
+        JQAAgIMAAPn/AACA6QAAdTAAAOpgAAA6mAAAF2+SX8VGAAAACXBIWXMAAAsNAAALDQHtB8AsAAAB+UlE
+        QVQ4T6WRX0hTYRjGve0iiAq6CovsphHWRaXrogshbEIgiEzbjFLQq266WZG76I8kRIRtIZJhW2NOq5Ga
+        uTkbrmZzf2gyTY8ipIwlYkJIIZP563xHZhtbF9YDz3l53vO9v/N93ykA/svKo883w5vRaZzeKV6NxOh1
+        R+keimB7G8TaF6DL6afzpY+OHi/tdg9PbG5M1iF5NAOwU53WNIiyBRBfFvpmbGJeX0bk3FFsxQdgc/OP
+        ZYnya30Dly+aDegdnhCBGV0ZX8+r8JwppPXIbqWXqeRGisTKmnwEVzbAPhgWgeGSw4yWHsJyfD/Gwl1K
+        b3ZZwuxro8nRwE2rAU90TDl/FkBclNBT1T7aj+1VhtOA+wN36ZFsNIcMXLbrqL1VqwBOXagXr7cAz15/
+        ECGvah5Wc3u8GV3/JSpM5aj1pbmADsd7EfKq7o6Oxu56Kswa1DfOojVocwHiv6aVkq/aE17F5Iyznkzx
+        6YufymsXOVFVTPX1KryxAOYXrmzAY8s7EbaHVXUhtMYwLc8l1n4mFS8u/WBqfoXI9FLuDtIAMVxUE+SR
+        I4W6McRJ/QAtXRJzi6vMLnwnKi3z8XMcsT4vYI/Gz9V7KXkHkxRVDnKw3ELJlX7cgThjEwnGYwlGggt/
+        B4ia6TbZDzqze2nnAERjp94G/Lsp+A2CB/zdurHUfAAAAABJRU5ErkJggg==
+</value>
+  </data>
+  <data name="fullMapRenderToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGOfPtRkwAAACBjSFJNAAB6
+        JQAAgIMAAPn/AACA6QAAdTAAAOpgAAA6mAAAF2+SX8VGAAAACXBIWXMAAAsNAAALDQHtB8AsAAACRElE
+        QVQ4T6WTXUiTcRSHdxkRRBdB0IUREV1ETSKIwoyQAsmV5IUhfaBUoJSUWJbLxAVZWixBRUcrNT8qM1PL
+        hpmoKGkf2pzOpLlAi9QtndKHzfm084a9uzCKujjv1Z7n/M85v2mA/yrlk3eng8DKKWsn62YLFwob0ec8
+        JimrhnhDJbGp5cQkFxOVaGZPgsmPBgi8M/y2Pn8D99Qsw+5ZBj746HL6WLMz/e8ELpsd+6FgbAe1WNts
+        ClxSP8jqHef/LJDOAjNsYfrpSZ7vXUGr3ceN2jesCgsQyMzzwfJs2wHtTzg7jPbIICzdMxTes7Jye5oq
+        kIXNB8vM8mzpLPD9B6+p7pwht7yToG3nVIFsew7uHxzhRIZJqY6+T8rM8mzpLHBFmxdjUQvLQ/SqQE4l
+        sGPIrYCO4XGsA2NsjYjDVPWK0N2HlSqo7qe42Uu2qYFlW1JVgdx5Dn4/6mHo4xee9biosPQSHh1PzZMu
+        6pt7/L/WUPDIxcW8OpZuOqsKJCQCj7gm8UxNY3VMYK55y+0GJ/n+eXUxxyi624Txeq0iMVyrYsnGM6pA
+        Evbd62PMM02fc5KShw6ulvaSaX5JlrmdREM52tAoEvU5xKdcUSSLN6SoAonn6PhXXvS5qGx89wtOz20m
+        +XItCWmlRMYaFEn4vuOE6uJYFHxaFUi27c4Jyuq6ychvRW9sIDmz2g/eIjYpn+ijl9Dt1xOy6whrN0co
+        tXB9gED+GJJtiackTEIid5ZTybZlYTKzPFs6C7xg3SlV8O+F5gdwpvLxKZ4mxAAAAABJRU5ErkJggg==
+</value>
+  </data>
+  <data name="mnuExport.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
+        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAALTSURBVDhPdZJbbIthGMd77caFuHDhRkhwIdwhEXHIIhO2
+        kDiFTIYEsYkhs5DIxIYYY6fuvAljmaHWnbANOxjbugN2ajtVrbZbv21fuyrr168/XzunCv+b932f5/n9
+        87zP+6r+VoPOQa7WiLraQnaVjUtlQ1wr66auVc+Pkv+r+ImZu60Oeq3fGP8iMenxM+72obeI3Kl9S0p+
+        4/9NMqpM9FvdSHKAQIAwBY+SX8bqEDmSXE7pw9fhRvm1Jro+uRUwnBz4IPDR5gqLu1wiW4/k8PzN8G+T
+        vJqBsCJZ2XcP2Vm5t5K1sQ8x212huCTJ+Ka99PYb2LD/xoxBTmUPRqsYKggq6NNncBAVX8fSqCou5HUy
+        6f76IwuiKPJlSiAhtZzM289RXSx4gV+WQ8lgF4MmgV2J9SyMvE/SzTY+j7kYm/Rid3qwCx48nikE5ygF
+        5Q0cPHcb1anrT3+1b7RMEJ1QxfIdWjYfq2dHopbdSbVsP11NZJyGTUcrlUEKiBNjNDV3setEIar4K3VM
+        +/whg1dvrSzeXsqKnRo2x9Wy5kAFS5Tzoqhi5kXkM2ddBgazA9eEg5dtOrbF5aGKPn6L98qdgwoa1bQZ
+        WLbzFnPXqzmT9RLdoJ22PiuNHWaausyMCU5sVjP3NE3sSShClaxupPhRR8jgp6pb9MyPVLMgIpsiTS8+
+        n0xAmZPk+4btswWbxcTJlDJS8+pnXuJYigZxyhuC/X4ptGpbDMxelcas1WkMm0bxelwKbGVwSE9TSwdb
+        lL8QgoPKvNNMcnYNsiwhTc9MmoCfksc9ZJW34xQE7ApsNI7wolXH7uNqKup04b8xPqWCc9cf4By18dUz
+        zpQo4HWP454YxWFT2lbu/a5/gENnC7la9Cwc/qnD5++xISady7laml91MzJiRD+sp72zl/TCx2zcn861
+        koZ/w38qvbSRfadLWK+YRcTeJCaplMS0R/8AVarvzz+nF884LWEAAAAASUVORK5CYII=
+</value>
+  </data>
+  <data name="exitToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
+        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAMVSURBVDhPZZOLT9N3FMX7vy1ZhiKttEh5zrpWJjgjsFF0
+        bGN0gmFzD7PF6AAlbDHLQghzBYuOltLW0lJmqVBaZ1sBBcOjtOIqfX12W0ic4SS//B753XPPufd8Ff9H
+        bm+Pbf88kf5BQj29BL+6jP9iJ/PfXGXN8YBcOs3Br4eRz+V4Zh4n9vUV4kODJAZvEv/uB5bbO/DpGrDV
+        6gkP3SafzR4mKXSOXO9jo+9n8gszsOgF8yiZH6+xefELYudaWdCfwX6iDs9nJtIvd98mWRkeYetmPzwP
+        8jrg4NXwbdLyvmPqZrXVyOIHHzJTUY2v/hQ2dRWezm7I5/dJ4otLRLp7IOrnpdeGX57npChmNLL6sZFA
+        7UlcJw087P0eh+40zspaLMc0REfu7BOEbgywLR1zITfRaz+xEQiSiMbwftSC44iKaW09a1MOCgjd+oUp
+        VQW2ci2T+sZ9KzMt7aT++B0mRkj2XyflEf8iL/n4H9xtn7JudxaLE745/I3ncGq0RRt3VdriZhTuhrNk
+        xW9u4AZxUxdPm1tZHx4lK4PNZ3PkpXjDZufvej0z0t0lFooE5VVECjZc7zeQ6Opmp8vE6idGHqqrcdXo
+        2AmHi52zmQy+C59je6cEz4kanHJNHhA8kUYK55nzPG5qZqWljUDdKZzVOqKSh4z4Sy4Eye7KPbbMbEcn
+        thKZiaaK+zKDcWUlkVEziqWBIZFVz5Khkfnzbaw9kBwINu5PMler48m3V8m92iW1HSfcd0sGWImlTMNd
+        TQ1bjxZR/Lv+AmudAY+QhEw9ZBIJNq1TzMr63EdVuI8oCX55Sb7v8MLh5J5SzZ/vleHpMJHbO4j2iuUv
+        JkrL8er0BCS6XgmOU1mBW1uHS63FXqZmVjLhPN3EWOlxxtU1bM7536Qxm0oR/vU3xkqUTMrPdimarqzG
+        XlHFlKzNqhbZosZcUsadUjXLYxOHz0SB5JnVjs1wViSqJG3lTIgKixCajx5n9N1jWA1NPLdNk5PNHJS9
+        jUKA0skkq/es+C5fYbq5HUfLBWYv9fLUbOH15tabM1CEQvEf0mmgVGzBvO0AAAAASUVORK5CYII=
 </value>
   </data>
   <data name="propertiesToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
     <value>
         iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGOfPtRkwAAACBjSFJNAAB6
-        JQAAgIMAAPn/AACA6QAAdTAAAOpgAAA6mAAAF2+SX8VGAAAACXBIWXMAAAsMAAALDAE/QCLIAAACCklE
-        QVQ4T6WT30tTUQDHz39QD0UQSpAPIkgPyR60AiUiyoGBL4qZjOyt0tZP9tBDk1AsXIhj93ILdd27DPPH
-        3VwrUrdK2ioJHAgVOdoPaQsarBg43L6ec+akuRsEPnw5D4fP5/vlXg4BQHaSf8LjjwdqaTA2cg+y1Ith
-        qxmi5Tas/SYWk+QRoPgmtNsLcPq7GYX8+XoTqaUL+KR2cAmDxeBgqeBv2NhWzwUFOBk4g5/zRxB3V8Es
-        38AtbzuIw/0RLMrMeyhTs2CzGdRtaOTn1dajvLkAR9VKLNvLcHmoExddzSDKzAfkcjkkEtEiOLxoQpdB
-        z+Er7ScQUg/DL5TD2bsfl5oPoKWnCZ3jehDZGeAC1hwL3uXNs55Jep7Gis/AJWxyTeVe1FXvhq5qH6oP
-        7nlw/NoxGByNIKPT77CezSEeD6Pn+jlEIiGk6X8N+F9zyfLYIZzUVUCwT0J36jy9yX83KjDq7zSADE8t
-        cGB7kpksFt76YDzbgMWVFLzBX0WCTcku8mjiTSm8lkUslcHnH2kK/+aw6k+UCJiESE+9XCApz2Gzu5Gk
-        sEVy4r6got82vRV5blVbIDyZ21rAZrPmL7w5P5s1KxQWXRFtgU15lV8ge2AbdXPY8pAuEIsXWJ6FtAVW
-        +SWSmXWssuZ4vnl+s5nNFl1hMLjP8U1bMGR/wS/+N9tf7o6eMpNtADko6xybtEXLAAAAAElFTkSuQmCC
+        JQAAgIMAAPn/AACA6QAAdTAAAOpgAAA6mAAAF2+SX8VGAAAACXBIWXMAAAsMAAALDAE/QCLIAAAB/klE
+        QVQ4T6WQ30tTUQDHz39QD0UQRlAPIkgPxh6yhCRCykGBL0WZjOytLKdl7KGHJmFYtAjH7uUWy3XvMswf
+        d3Ou8MdWils1ggZCRQ43lbbAwYpB4vbtnDMzrrsMw4cvB87h8/l+OQTAlqJ7ydL/7MEhGvQ9vQdZ6oLT
+        boVouwV7t4XFIvkFKMGB0nB23rqeX187kPl0CR/VJi5hsBh9VBo2nzuqgdPh0/gxeRhJXwWs8g3cDDSC
+        uH0fwKKMvIMyNI6/8DVTPT/bzh7RwAtqOWZdZWjpacZlbwOIMvIe+XweqdSCBo5HLLhqMnK4tfE4YmoV
+        QsIeeLp240rDXpzpPIXmfiOI7AlzAYMXo3c4PO4fpOdJzAVNXMImHyzfierK7TBU7ELlvh0Pj7XXwOSu
+        B+kdnsFqLo9kMo7O6xeQSMSQpZ8RDr3hktm+A6gz7IfgGoThxEX6UvgrKjAbb9eCOIemObAx6ZUcpqeC
+        MJ+vRWQug0B0WSNgoZJt5MnA22L4dw6LmRV8/p6l8E8Oq6FUkYCFSC8CHJKUUThcPg7bJA/uCyq6HcPr
+        kSeW9AXC84l/zXQ2a/7CmwuzWbNCYdGb0Bc4lLHCAtkPR6+Pw7bHdIGoXWB7GdMX2OXXtHkVS6w5WWie
+        XGtms0VvnMN33d/0BT2uV/xhsykSbLz4v4D8ATko6xzt+1ySAAAAAElFTkSuQmCC
 </value>
   </data>
   <data name="resizeToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
     <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGOfPtRkwAAACBjSFJNAAB6
-        JQAAgIMAAPn/AACA6QAAdTAAAOpgAAA6mAAAF2+SX8VGAAAACXBIWXMAAAsMAAALDAE/QCLIAAADLklE
-        QVQ4T3WS60/ScRjFf39CL3rR1ovurduWbbU2t7ZqdlkXt7Lrym6O1VoXcdYqQ54wKlGxABE1CzWF0nIm
-        lZcoTbyUNJFIzDJSJK+E0qy8wInvz+i2erazfd+cz3m+zw4nTS+FLOeZNim3Vp6UU5sqvf5MSZqnyjhV
-        pfKUvEx54kqp8rCkWHVQVKSJPHtbs+tUgSYiOicVAMfEqfR1dVFCGSqrX94cHQeN/aXhbyD3Zz91uf3U
-        9tFHTQ4fzVtH9BOQVdKcW2F6/eKkWA1zcxu6vUAQMmCzk/3AErLtDyFrrY035z16T3PXin8B5LfqZE6P
-        HyZzKw5FX+Yh4XtjwZKZGV3lNPIkhhojplON3Uc3S9/Q7LDfADKtKYklMsgTkwV7joixKHQr2Nq2fSET
-        5uQwqtsyjcot45R510ozV8f/2iAhsyolCNh9WIyFoRGYHbIGfYN+SVd7Nznzk8ll0FLzKxdZO3xkaOjG
-        GYUxcIIfRxSlPU4N/rn1fS8JJVlU1WCT3npggVLfAIWuHjJtNRIyjIhTPEKM7D6OSop4RcXpwZ2Wl11l
-        gHanmze/c36ioc8jyRlFjSzljxl2daI9Pwuv1Cnw9PRjZeQ1cCcSS68Fza6+IXL2fCG7w0ssmc3o2IR8
-        gbc1PQU9NUp48sNRcUyAkPBL4AIlUbLk3gEvS6YXrW6p0dx9UZ5n4gHjzBmYAAPPYwRwazeiMXYWqjcs
-        wLSVInAHRYWq0TEf9Q+NUEsg+fr9t2nF1U71leyqn+u3vPuIl2298HZ2wnxkO5q2LYOtxoKpK86D23tW
-        r+7zfCVzywAVGT/QVV2LvNDo0Eo0j3mAtbUTiRnFOJ94Axp9LfIKK5Ctq0RDmw9TQuPAsW7bHYNUYLCQ
-        JL2GRAqjtMDYwV+8wzUAWeY9eIfHYW0fxNodxyGWZeOSPBvzl27C5OXnwG0T5irmr79wgdWTNYyVJFL8
-        kAeo8wyBA/rx2jGErBIH0nXPsWmPEHcM9YgURGPS0jMTZfiXGKDfM4Y0fVOgA/UgRQWECTpExaqxUyDF
-        wuUbJjb4H0AQfxtrDqiweLMUc8LEmLEqnv9zUMzM9B1/cM83lepxTAAAAABJRU5ErkJggg==
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
+        YQUAAAH3SURBVDhPrZJfSFNxFMf3rBk+iIH2oOCTIAlZSGCQPqgIqQ/5tHQpPiikBpIpCnuxYkWCokQg
+        qDcoNYZETZAhbII0dh92DdPNvJuj4f7epWa2vOvrzg/u8uqQkA4cztPn8/uee4/mv5RxgQfN2Xkbm9zc
+        EpujUyY2+w0TbJ5ZBL/9sAyCx2cWMcqZYHj5Dv3PJsF/FjE8aUZrH4eWXg7Njzjoeqb+ShU4/iee7MO4
+        jIB0gPsDI9B2PIYkScmORCK4Vt2iTkUvH4djhzI2fbsJeBC88EUl8Hg8aoESW1bg3zKiP2JY2/qO27pe
+        VGu7k3A4HIbL5TqdYIybZ/DPXzLCuwcQt/exIkZR0dAF3rHKYhMcDAbhcDjUAoKfvzJC2ovhayL2+tYO
+        hM0o+PUIbta349adDgYGAgH4/X7Y7fbTCfQvOHTqx9DY9QS19/oSL3eirK4NlwrKMD1nZqDX62UpLBaL
+        WqAfeo3VjW9oevAUn/gV1Nx9iGW7wCQEp2cXsSmKIhOkTNBjMLI9lV1DoVAysvG9GWlZheCmPyIzrzy1
+        gI6EvrIiIQHt7fP54Ha78WbWhAvZV5CRW5paQBd2/Fed7Mz8CmTkXMfFyzdSC+g86WU6EqfTCUEQYLPZ
+        YLVaGXCyr1bq1AK6bbL+SxeXa1FS1awWnK80miNVQhp+0k4xYAAAAABJRU5ErkJggg==
+</value>
+  </data>
+  <data name="showActorNamesToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
+        YQUAAAGOSURBVDhPY/j//z9FGKsgKRirIAiHFm92CyjctB+bHDLGKgjCGa37/gcWbvzftvBaCDZ5GMYq
+        6Je/XtQ3d81/35x1/23j5r7FpgaGsQq6Zaya7Zi8fLZFzML/xgH9QNznj00dCGMVdExa9sUqdqGoWdi0
+        00b+ff8N/LpvYFMHwhgCrmlLE+1iF54AsU3DZ7mZhE79r+fT+U/Pp8MFXS0IYwg4Ji68ahk1WwvGNw6d
+        /ApowH9dz9ZdyOpgGIXjEDdX2Sp61n/DgP4Let7tVw38+67q+fV+0fFs/a9knfNX0SpLBVk9CKNwbGNm
+        bwT6e5+6fZGJik2ulaZThZWmW6OWpmvDfxWbApAhG5HVgzCcYRczg9s4ZNoXTecKUWQFIKzuWDEFaPt/
+        BYsMjCgFExbh06SMgiZt13St+eoQUvoSWYGyXUmEvFnSf2WgC1RsC/4rWqR/UDBL44bJgwl9v25RoGYt
+        JatMLXmTBHgAgrCSTYGoLFBMUjtQS1zTV0tSJ0hL1jgB1QBKMFZB4vF/BgBJP5kepjxMJgAAAABJRU5E
+        rkJggg==
+</value>
+  </data>
+  <data name="showGridToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
+        YQUAAAFYSURBVDhPY6AqyJt9/z+UyZA1/TacHd93Cc4OaTwJZ2MAZAPSJt+Es2M6z8PZAbVHMQ0AaQTh
+        7Bn3/mcAbU6fcuN/ysSr/xOBNsd2nfsf0Xr6P8hmkGafyoP/PUr3/ncp3I5pUNZUhLNBmqFMhpDm43C2
+        R+luTI0wALIZykRxdmDtETjbpXAnpgEgZ2cgORukOaId5OzjQGcfBjvbDeTsgu3/7XK3/rfJ3PjfMm0d
+        pkEozgZqhjJRnA3SDGViAlCAQZnA0D4MZzshOdsifS2mAfE9VyDOBoc2wtkgm0F+dsje+t86c9N/89R1
+        /02TVv03jF/x3yB6KaZByKEN8jOUieJskGYoExMEITkbObSRA0wvBpvNcGfvBycSkJ8doKFtDtRskrQa
+        7Gy96GX/daIW/9eKWAjGUO0IgBLa2QhnG8Uvh7OxaoQBZGdbpCJCG9nZeA0gHTAwAACOffGU2o3WzAAA
+        AABJRU5ErkJggg==
+</value>
+  </data>
+  <data name="showRulerToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
+        YQUAAAEiSURBVDhPvVO7TgJBFN2fovAHNDb+gLGywsbCxoTOxF/wgaLGRPGJNUEeglBaaKExWhF8E1kh
+        Cwsyxzl3d83Gip3Ck5zMvTtzz97cOWPtnFVBbmcusXVaEaZOytg8vsDGUUmYPCxi/aCAtXReuLp/jpW9
+        HCyCxWHML6X8yEP/G2i7wEcHqH8C96/AdQOITc56AvxzAMdxMD696GfAYAgeQlMXN1rAw5uX5+9CAmyZ
+        YDE5NhWXnAffW11Zb1+GstYeve/ZvwILy7uYmEno4jnZGJUiwIGF8bsxKjjtADqNLsBrCmDbjrmADs06
+        oEmUUuj19T033egCdJg7UPjqGc6A1gycdvOkzAToNB2adcCH8WwDV3WI0yIL8FWxKEx/6z9gWT/PHGlW
+        lc2EywAAAABJRU5ErkJggg==
+</value>
+  </data>
+  <data name="fixOpenAreasToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
+        YQUAAAE/SURBVDhPY0ACokCsBaVhAJsYVsBvbGzsD6T/Q2l+HGI4gTwQ/wcBEA3lYxMDGQKjUQAxLpDH
+        ogYFIJsOY8MwjI/uIjAABRBMEQjg8jt2cSAnC00Qp01AAJOHGQoG6IpxugCIMTRjcwEIoCvGZSgYoIcB
+        NiBv6q79v3Rmwv+0Pv//EU32Xzwr9GqgcnCAbisIgMViGzz6G1cn/t9yZer/C892/e/fnfU/vF/3v3m2
+        ZA9EGVAhFifCxWLanH9uvDzh/8Zrk8Dh1bMn9X//nnSQAd+B8mAAshksCaKhfLiYT7Xh/21X5oDZMLDp
+        0lSQASC1YIDXBRbZ0j+7dyX9b9+VANbcvjMB7AKzLIkfQHk4wBkGJqni3cE9Gv97d6WAbQbRIL5xivhU
+        iDIiANC5HUD8CeRsoM1fjJPFJzEwMDAAAD8wxIeEhxEyAAAAAElFTkSuQmCC
+</value>
+  </data>
+  <data name="setupDefaultPlayersMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
+        YQUAAAD0SURBVDhPY0AD/9FoogEuDaQZdCzROe5YsvOJwwnODw7EO1S7KomLQaXwArAtIM33WrNef1ra
+        /f9NT/7/U/H2X9f6mXeCVRDjEpDNIM0/N876/3FS8f9byTb/Fzhp34ZK4wVg00HOBtkM0vyiKvT/1WDN
+        /z3G8q/AKohxAcjPIGeDbAZpXmch9mteYfb/Gct2EhWQ/0EBBvIzyNkgm8t8A/9X10/6DwLEGoICXCKK
+        /vfP2fr/2p1nJBkCUwSmHUMLwIZcv/ucJENQAMyQG3coMMQprBBsyO17T8k3xNgj+b9rZBF1DAFhqBDp
+        AGQIlEkNwMAAAP7JtzLCVbRNAAAAAElFTkSuQmCC
+</value>
+  </data>
+  <data name="copySelectionToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
+        YQUAAAJVSURBVDhPpZPdS5NhGMZ3LKJ/gzsrHg3sIFsm5A46cC3ImmnWOy0/lrMtpdbct5tbH5Op6eZH
+        6lrvtOYqTTdxrUyCTgoKlSwiAjHICAOro7VdPe+7aRSyhC64eeDhvn73/b4Xj+BvRcc8WRPDphKnUYG2
+        iwxam07AY6sqsTVXZKVa0itypyeHQrD63LhZ1MxVTqolvSZZF5ke7dwKQFIt6RUYvJLD9tm3AmxvA2rO
+        uO+1iv0ey6a52yIX0zMj1fJvsb02srEFB7Coy7a3/obYXjsPSLzVQlt3GNp6aXrAk4nBzEf3+oWRQA8J
+        +ztIcOiq1N/rQGKpCecZMTrN9VK2x0R8XQbi7dAJh10tmSmrQPD4bl/2s7CXmR0fBI0Q4ZEOTPraMe67
+        huCAA4EbbRj1tIJ1m0EBoADc6tIzbrs6CaFTc7ncvy3PAGtzfCW+zCL+OYqfn2YQ+xhCfDWyeb8yH8B1
+        ayOc+hohD5hiXYVc7rx5qRnxhUboa/OhO50HrXwnWqoJjA17EV9UIfayHu8eHIW+4QgMytLkfxkbsBfe
+        9lgRW5nC+sMSrE0dwPe5UhgUeyhoN3RnduHHUxnWoxJ8DRXjVX8+lBVFUJ0sTgL8bksul/nyCx/mhwqw
+        eHM/PkSq8H66EsrjO/AmKMHrETEWvCLeHGrLg0ImwtmyfclP8HWbsv1uU3W7vg4ODcOXjT4gmj2/qqb2
+        EJrkB3GuspifzJnV5QWM4pjodxKdZmWmU1cjvHypitgvnCIUQMwqGaEAoqmREAogFEAayosIN/kP8/9J
+        IPgFAlSB3U6URz4AAAAASUVORK5CYII=
+</value>
+  </data>
+  <data name="toolStripLabel1.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29m
+        dHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAI3SURBVDhPpVBtT1JxHPUz9GHatDSlWfbIxEkCAQJe
+        DJUIKEBEx4OkIiiKPC10QS7XyrU2KRFQUKcBEup06hfoVc1euLVe6OnvbVdN75vWi/O7+5+dh91TBuC/
+        wEraS6Yta/EZuvP6I/Pqkxk2DYMLhL1kvGQvmjC1F0FsNwTDsvrbec1ZsJKWnO4gthtEcNMDXUY1z6Zh
+        QB/HeidsXwzoKTxFV04L04rmKLoTxPi2D49T1I+2Wfn31rh0X/FBtM8aYCXm13svMLkbRmwnhOhOABPb
+        fkS2fAhtDMO/7sZYyQXJ9AMiZwnoLujxipiPW/sKnTAuqaBfpKDNtpBvK7QZJQkYhPBNA5GzBJClYVxW
+        w5mz0K26LAVNRo6OeSlUaTGUSSG8pX6o40rwondxf7wOt8O1xHpuRE1aifCmF+qFZrSlJXiUEqElKYBs
+        jg/NAoXBNQcG8nb05624Eai5GNCeUCCw4YEq9adVMdeE5kQjxJ94aE/LidEG5+ce9BJwRqtOA8jSIEvD
+        nNHBR/61JdlEt0pnGyD6WA9BnIs+0ip/9xC1Y9W/OCOVuDZUcRpwbPYT4yhZWpdVYaj4HO61XrgKDrpV
+        mRTTrcRMm86CPtSMBCNkJFmCD0/RiY44RY/FnbgFxbQYjlULbCtdqPFeJXKWANl74UnrQN5BmxnBzQCH
+        mM2wLBlQ6Sk/4RnQR/yWD8EUD42TXNS/vIN7kbqfjOD6aNVh9fCVw0p3+UGF6/JXhmfw1+PfgbLfYY/G
+        d6iLJ+UAAAAASUVORK5CYII=
+</value>
+  </data>
+  <data name="openRAWebsiteToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29m
+        dHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAANqSURBVDhPXZJvTNR1AIdv03KuXL2pteV8QbnVVmuU
+        xESolRtJG5GxZJIgaN75h0MZZOMMwoOSIPRohAiecnceIGjHcdyheHfA8efAu+Pu4OD412FIBhThKMxJ
+        29PvWJr24nn3fZ7fvt/fRwQ8QnpXapRAvcCkwJ8CdwVmBZqktpRt/z//sLha4EJQuPaTFudcK9Yb3TSP
+        ddPot3DJX8MBa9KyuDXRtMeU8OQjAUF6TKBLPfItM0suxuZ9DM73o5t0YwwMo/b5UHn6qfd0Udp3giRd
+        vHdnfdxTDwe01f4TBBbbGV60M7QwhHvWQ834EA2BCRSucYp7/Zzs6EM3ZKHULiNe875pJSDIkQL3pv5o
+        p3nByKXbRlrmO2i56ePsyCjfD44hNbqQGuwUOIxUTpbh+kVHbFX03zHl78YFA5eNgQqcvxqpXdBz8fc+
+        +ua8lLiHKHaMIm52ITGbyRiuJDMgJ2NChsZTyoXeQraeiroaDEwN/GZAPVVFyZxS+LoP+5yH9KtuxHon
+        n/U5kIwfJXZUTKx/H0mDaeRey8Q2ruWtws23goGlidtW8keOIx3/nMqf26iddJJUd500i43isSukjNSw
+        vzaSfedD+dC8k7SGvfRPN7FZHnZHJO1MufPjgpUcbyZpXgXnbphJrrWT3DhI/Jke0s09yLw6PlVv4bgh
+        kYSKl5BoEum/qScsN/Qv0cG25Gn3bCMKXz5FE23IHZ3sUDs5rI1CqolAogojVRnKF7qPqXeUktUQR/Sp
+        5zCPqHhd9tqMSBhGk87/Hc2Bao70FJDnqWOXtptDmnAa+8u57CpbEescChTmLFT2IvZrowkvXBsMtIlS
+        m3dEC8NYHpwzkmU+QIYlHanJyl7hvkH5ZOthvrlyiK9MYvIMqciNEips+eyqjmTjl6LllSEl1H2gL2k/
+        isF/hrz2bHJtZj6pepmL1xVoe0tQ9RRxrrtQiBzktE2OWLuNF3IeX3o+W7R2JfCRKmadMAzv1y1HsM/8
+        QPVAO9tPhxBTul7418+ypfhpks9HUN6Rxx5NNCE5a+6+Intxw4MpB3mv7J11wjBMbxdFLCu7q1DaDJzt
+        sKDstKIfaGRT4RPsVm0l5NiaxVdlG9ff9x4E7hNR8Ob28Lw3WjblhE4Lj7T0L7dCclbd23BsFc9ki1b/
+        dx7RPxe0rmcJTZoRAAAAAElFTkSuQmCC
+</value>
+  </data>
+  <data name="openRAResourcesToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
+        YQUAAAI6SURBVDhPfZFtSFNRHMb3TQj61pe+VIJ9mPMGldcGyYJe1I2I1qbN6HVL2EJrKGzRmsWkJGaQ
+        RK8Mnc7MuVywNNmLLpNi0YtIm4X2NspkaC5LW7q1p3svbEzv1R88PJzDOT/+nMNzPX2PpXH2B2F3D6Ht
+        0Qs6ZgC85cIIlsPieIICyckVJbyH/hDV3Nxoc8PzLJiSNFBbbIHDO0w1MPYlguevx+DyDTFrmuutvczl
+        VCjYgvuPX1HNTTzxj5GkRBRsgc0VoHrxBNauQVxr7sVcbAGRH3OMgBSr6GNsQZNzkGo28wsJTM/EEJ6Y
+        WVlw195PNfcE3ydnMRqexm1/Nyq8Rsg7L0Fm8kFZ2wJhuXE1I7h5z8MIMon9jWMy+gefx39Ca7PBMHoG
+        jmgHYslZnHhzHLvMduQp6lu2yg1ZPHo8Gq4JrN4RlPaUw/DtGNp/taLntx+HOz9hj3UE2ZYK5FRpC9MC
+        mmQymX64D1+jUF4NQHReglJPMdRhGY4+CGJn4wQEPj3WuqRYp1N3LxJkPlzo4xTISg/233kHUa0U+wIl
+        KGp+i8LL48htUmNNxwFsqNEk0gK6l6ZY78aO+jh2N4RQ5CyBsF2DbYYIyHM+5JiV2Hha42cE9BdxJV9u
+        BFk9DGHdFLbbykCa9NhSHQShHIBAZQJxqErE+tfMCBRX1m8+cutlvnYApO4UCnRdIFRe8BUW8MW6s4RE
+        u4rzYmZyZXXZRNnFxk0HLwTzpMZ5/l5dn0BSIyXElVkAeP8B187ybforr3QAAAAASUVORK5CYII=
+</value>
+  </data>
+  <data name="wikiDocumentationToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29m
+        dHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAJ4SURBVDhPpZN9SFNRGMZvBAVFUUFCQlEUUZBCnQoF
+        +6CMUiwNhUap2ebEr8BKlJKZqGEl1tRELaggNrGJZraKLaOv3TWnEU3ZAnOI5JhzG24T3Bg83XPiDqIJ
+        QX889+Oc9/2d533vezkA/yV2yX9gIqKkHTw53/aRZLe8I2JQxo0BklbTS45XdZMjFU/IgbKHJKGkg+2L
+        yajttaCm5ysU3V9QpTaj/DGPzFuv4tLrn8cVt+lRfO81CpQvIG3sQ26DBnvyW5BY2kk4WScP2f3PCIVC
+        ES0sLKCf/45Tdf3TqdU9032frAgGg39oV04jEorawQB57QaWODIygqGhIfA8D5/Ph2+2H7D/dCEcDmN4
+        eBgmkwmDg4MMsP1MPYis+Tcgu/U9A9Akr9eLmZkZjI2NQavVwm63Y35+HnNzc5idncXExAQDbM5QIC73
+        NjihaZDcecMA9BTqwGAwYHR0FF1dXbDZbAxgNpthNBqh1+tZibGpldghqQeX1/aBNosB6ClutxtOp5MB
+        1Gp1BECduVwujI+PM8D65EvYmnkdXHbzW9osZkuskzqwWCwRQCAQiPRGp9MxwJqDJdh08ho4SZMOKQoN
+        A4gOHA4HA6hUKlitVgbweDysN6KDlYkFiD1RDi7r5kscrVQxgCgaQGFTU1Pw+/3sXVyn5dH78n1SxCSX
+        gUuvewZhsiBMFoi8FfF5Tdh5tgHbsmpRrtTgyt2niDl2GWsPX8SqpCKsSJBj2d4LWLo7F+sOlYJLrdYg
+        p3EgqracVmBj2tWoe1SrkwrBCbO9qIPEwlbslysXdbAk/tzff5coAfBoQ0rFpPC5JoVnXbQYqqiL/y5w
+        vwBd8t4lLDBzngAAAABJRU5ErkJggg==
+</value>
+  </data>
+  <data name="discussionForumsToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29m
+        dHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAHISURBVDhPjZCxT1NRFMa7kpA4sRkSBxIGF535N0hY
+        hEH+Ao27LDDQkHTWRZk0QCIMIuYShjIZSghLIUVMrS3tq21fW1773rMef+e2j4TyGhx+ee+ee77v3PMl
+        5lZ2p2ENPo3gAzyHSRFJDKMGqf2Tgml6gXEjrvs0oNzwzGY6Z+h7PcpgW8V1mmvtwPxuBcZp+cZp+qbs
+        dm09X2mpwfuRBjpVxZWB6KrRNcV6xxRqHXu+z2Cn2QlMlcnaXEJ8cFr89vJNujaf/BougH7p86E+oADL
+        MK0GG1WEftizYp386u1hg1yE1YTX9bnuQy5CLkIugnZTDRaTGxmTyVVM8Kdneba6F6qY/YXVhFyEXIRc
+        hFfaOmupwbndg58Z+KiJfznK676hTlUxuVgRuQivE3Kx51sGA5N3exkr3oUWuQi52GZWuxHnq56U+P9V
+        bavBZSQegx34DFNwRS7SDXu3xPqKCnXykh/lphpkI4MJWIJHg/PK2taxnHx3hEwsavbTactFyZX1/ayK
+        PXhxs8IwXM6C63q+kIsK/kIOTiEFD7QvVhxB0xm5qLgLT+J67hQiEIyDCx14GtejxBYVRA9hCx7H3UfE
+        Fv8fSfwDwZ8JlGSjAbkAAAAASUVORK5CYII=
+</value>
+  </data>
+  <data name="sourceCodeToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
+        YQUAAAAJcEhZcwAADrwAAA68AZW8ckkAAAF+SURBVDhPrZDLSkJRGIWPiagPVO9QbxE1aWqjgkZNwmpQ
+        3lIkSI0wzcCo0MiiC6RdLFSQog5aKOaFtMQ0deX+PaJZBx204OfsffZaH2tv7t/kPonir3H5wrB7grDt
+        +NnMC/bfYuZuyVfk4NM8rc2OYwyNjItDto8iZGRSGpXgMzw4LUdrJp3NA+95uAVZEGJtOQ7uyBjPxSHR
+        SiAzyMAZOfifAvRfY9mncGuEWFsbe1dkVBgVkOqleC2kCcTWTF/VGkFaICHWltV9QcZaHRQa0A0QoFPF
+        UoUAg8Nj4gDWQKKTwHntIghTvV6ncCpbFAesuk7JzMTufxO7FXZAuVJFLl9CLJkXB5jsPsH+U9XGnQrF
+        MhLpD9zHcuIA/bqXAuZNHzRru5gzODGzaIFq1oSJ6SWMTqoRekiLA9hBt9jLv71/4jlVQJTP4jKS7A1g
+        DZapwVajgbXZYKrRQKXGWfClvwbs0TofLvKYgT+UwGEg1hvAvr1GFMAO+p1miuO+Ab7ZFVkV6pPjAAAA
+        AElFTkSuQmCC
+</value>
+  </data>
+  <data name="issueTrackerToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29m
+        dHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAALnSURBVDhPdZDrL1txGMf3D+z13oqOUavSlp621Gq2
+        F7NiLhuZ2yRkExLDlNnMvSN0iE3EMKZza11Kx2hdasssWUhGsmwum5Bt6jI2jiLx3TlEU5u9+Jzf8+T3
+        +36f831OAPgvHj1CeHQLJHTt3sb3d1O5bv395kgj6RcxLHuxhoB7O18Tq/CxFjW7RAtf8H5Z3tMcac7R
+        E7WC5MPeTc03iVpcV2IeXFT65Qu3hNXcveDbogJLjbmgEXcRa+6dhImu3VXEurDJBQIlD4I6HjIMiTDM
+        tyO1KALSaM6dQ80RAyqnxK3VFeJmYs1bdQHqyRr0fmyAYiQPrEd2iOjxRctoBZyLz8KpwAGOeUxqaiex
+        TuU0Z6dy7nkoBWgaK0Huqyika4KRoomEuIIAq8AeUQ3X4OVnO3X4ns65Q+WEsNGlXqwkjFfVflC+L0am
+        NhxJal+EPfdEfmcQJoZuoWqwEI459hCF2LSbDeiPoIH3lqjjgqjhQjVejozuUCSqfBBWJ0F4oy8+9Edi
+        ZaoV+r44sDKYYKbZbtin2MSbDWiIp1xTSLM/inTxSGiRIrTWE4H1l9HbH48lag+7G9OY6AiCTzYbdkmn
+        984kMGAbZ30gpuE/5mzeVEehdECGsGdeCKj1RmV3IsbbrsC01A3TNwVWZ7SofSKGNNXhFK1hxFjdMxsI
+        y1zknCIWsrUyBNZIUdyVhrZGKZY/qWCaz4bhIRc7KyqM15zfG6uSBBzqzAY0XDl7mJFsheqhclSqovBF
+        n45tYz3I6RswyJ2xNSfD2uxL6EqIxXelxMl/DGgc05nDnLsO0NVewk9qcVtfk7H5OfiAqTAqSgnmhsvQ
+        kcsuOdaAJkvOHZ0zKLD9o2J/+ubUdSoCZ/8kZ2NBfu+EIYe1OJzlwDzWgPq9BXJ5BturepiM1A6MrRao
+        sft7EgujDRhIt2091uBNIWf5tdyJHMljk9Qksj+Tib4MewzetyMpEalPsyH1MgapS7Ee+QMga508U1fU
+        1wAAAABJRU5ErkJggg==
+</value>
+  </data>
+  <data name="developerBountiesToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29m
+        dHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAJ8SURBVDhPhZLLT1NBGMW70K2JS7cmxrjU+A9oIGIg
+        FGhEUYkYRYIYaiyCUPqgD2p42hb6BkqLoKUWegt9UKm0JQrSGjdaQErRmLhzY4pE0OPcIRBKfSzO5M7M
+        /Z3vzDfDAfBftUdb06oZ2aE/7WUt7FdbRJE2x3VQhqQQBxqzTDIm+/UwLE+b4j3wffLAsKBFs68Bdczd
+        DJMMYK9I5LQxxsIMHCt2eNfGoXnZAYG7FjWjt3ZNskBWrS9a0oaYFr6Pbjz9YIdt0YyGCQEmUmPoiKpQ
+        7ajE9aFyapIFK0OStH5BAy+B26JKKMNSWBNGDCQMeLw0ACblREtQhKvWS+tZBvJp8brutZrEdSP5bQkb
+        W98x8nYIihnxNrzqhDQoxOWB0s0dhg7a+a5jsueiH73zj+hZ2yJKCusjvUh9TUIVkcG9OgrJlJCtjPLB
+        Mly08A5QA+18p0hGIvXMdVP4ybKNxJbQyiws90u34UATWxlzX2bR7H+AEmOhghqwkbRzXZgkDRpZHqRn
+        7X+vh5zEVoVlGE+OQhRoRJXrBoVnP4cRWguAZ+LivCb3MEcxLbESwfJGD0/qGeo8fPS908G+2EdgB61W
+        P3WPwFFMLjOo9VdvlPWXIk+dK8jpPnOKowhJjrAp2EeiX1DTuLaEZRsma5XOCjCLLqhn21GkLwgU9OSp
+        89Q5RzOa2OS9b7bGLRAwfGhedWJsxQGhtx4XzMUQEhOeqSjJ1eWfzdeeO7EDZhjUMfzjLcHmreCqD3ec
+        VSCGKDYU/iKd9vOM3Kb90F7RodZ1+yB5XWOVwxU/+a4aNupmqaXkNOn0btS/affj5nDFyWu2KzFyVfl7
+        f/i3wPkNOLzMGxqYvkUAAAAASUVORK5CYII=
+</value>
+  </data>
+  <data name="aboutToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAAA8AAAAPCAYAAAA71pVKAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
+        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAJnSURBVDhPbZLtS1NxFMfvf9F/EARBEEFEQdCrXgRGvTMM
+        ClN8URBYkaDUC31RCCZFkj3YnGhmpuh0s+FS51Nr6iLnfMB0W27uSe/udrfr7vp0vdtQs8+Ly+X7Pef8
+        Ducc4V98YYXhHyJ9DoneaYnu8Qg2Z4DNaIJ8yGH+AGNuEeNoBPuKzFJAYS2kshqQ+er0Yuibo2NgFjm9
+        c7BIVss0O2N0TkZQtSIFtpMqW8mM/i8m0rQPOKlu7EeUUnsFHIvbNPZ59aACgajMmduTnCr7Qjgm5VV4
+        0zVGbZOZ1G4HybTKq/4Vrb2tvJ1jJ5Ol1jBPbYuLtJJ7PUeasmoDo45lhG/uEPWt3/PGHhshmbnlMP5w
+        PK9oBRVF+6aw2Bzce9qN0GNb4vkHR87dx+eRX5wosVBUadUmnWtbzaioaQmPe5HSqvcIQ1PrvPw4o5v7
+        cXiCnC4e5fzNQXzhmK5lsyqppIh/bZXymlYEu2uDeqNDM3aXtcfcSohz16xcLDcR3BJ1LaOqSGIEj2eB
+        Gw9bEJa9UeqaR/QB7ce9HuXsFQuXSk1IiqxrcUlCjm9ittq5VW1E2E1q6pzCYl/UAwpM/Axx5GQnRy+0
+        4YvmhhYNbyKLfipq3vG6azy36xXt9UcvLIjJlB60S9ugh2NFbRy/bOCTdUGbltZ6Kkh79xDXH7QQ207u
+        HcqUa50nzWb8waCWukNWkUgoMRKJCFI0iBL302sa5uqdJmbmvYfvfNbto6qhh5qGLqadLlLSb7Yja9hG
+        J7hfZ+RuXScz7v8kFghpO+0wOah43E5x5VtKtBarn/UyPOU5eNOCIPwFCBKiGq2sGKsAAAAASUVORK5C
+        YII=
 </value>
   </data>
   <metadata name="statusStrip1.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
     <value>313, 17</value>
   </metadata>
+  <data name="cashToolStripStatusLabel.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29m
+        dHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAALSSURBVDhPjVLbS5NxGN4/sLm5ZeqWJdlNJ7oIoQPR
+        hWBEIF4VGYUUUSBk0kUidCdTA0UMdBKGkugssxKdeMDcbHn43FjzgGtuNs+HuX07fPu+be7pLdnF1Isu
+        Hvi9vO/ved73fV4RgAMQLMezeHPGcsiUEeUYFYITKj4wpjQFjMq8/bUJQRwhc4Y/stYCcFYg8ANgBxDZ
+        aIHPkG7fX5sQxPFXFaFZwDMIbH0AVhux626DdziV0om1CUEcgXEVdr39iG12IEbKkYVSRJxlcA8cpXRi
+        bUIQh9+oRNilRnDyOvyjF8H2nwI3dQ9buv8kYA1piJJyeP4phJ/5CI1fQ5C5i/XuI5ROrBXxpgxJiDm2
+        zE0oo8ExJQLf03mfPh28vZT2dxX+4Qvw9pyEMFeElS7FQQJuUlUR/l0L8E5a3BxtnUF4Qwuv/jSE2Ufg
+        zbfAGa/Q+wlcHYcQkL+IhWz00UJ2GYAdHWK+4X/z+kcvwzdwDp7PJ6ibfDhbkw8SsKNEEDQj5jUg5hlC
+        lPyPrmuwRvMK1vvgmRsI6rPBWwthbz6EwPMtDRGyi7e9BDddiOBUDvhfj7HcqYBvJBus7gx8X9IR0CnB
+        divg7ZLD/VHOb7bLTOutsjzR9kAqoqQcWdIg7KyEMP+CyB5isV1ODhSQAzlge1LoLvQ0polgpE77wC1W
+        wtUktYs2dJRkhxGij5ylgLzPQXS1GvaWZJo7F2zveeyQ6t5lDu1d5to7GvkT7A1JEK1+TdEGFqrpUxPC
+        jnKEF8rgsxbBqc0CaymE4CjBdu9ZBG2vENvpQWyrjbqtAWu+g9laiVbk6lQUuycfUEtVEJYqELA9w+pI
+        LmY00sHpeiljrUsS5jVS17bhJpGUIOR4Dr/1Nlb6LsFSJS4WOdrlmfb3crWtWcbMNcmEmUYZY62Xqi1v
+        pJnxTTveSjNtDUnquToJM10jESyvxYypUqxmysWZfwCSxP6Dn1PvvAAAAABJRU5ErkJggg==
+</value>
+  </data>
+  <data name="toolStripStatusLabelMousePosition.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
+        YQUAAAFNSURBVDhPxZDNSgJhGIW9hSCCbqRFl2B0CUKLoJWLQFoGCUKbVkURFlTQj9li6MckE81FgUqk
+        iUhWlP0Yk43ZjOOYzpzGz28ammwUNz1wePngPec7vBYDoLNr/iegYdLUwPheaTN/oJm6hgTsRjK4eeS+
+        lc0VkLx6xszyHjdin3T19vX3kO0WkAAmnIYRoSxhcTOAcedCyTE1N022/8IbSFCbDl+uwOFawoB1lIiu
+        /oIcZuMgRm06igLcPrBwe4IYsk2Y32qVOaU2nVpNBleqwB9JwmoSQBq4vWFqayKr3/NiFU8sj/3QhWkA
+        YX79iFqbSNU62KKI61wRzPF5+waza4fUCtRlGe+8hPt8CZfZV+z44+0baAGKWl2UPvFSEJC5e0M0lceW
+        euCOGnwIIiLRNIJnKfhOEqS6xxeDezvUWQOb3UkWW2lweIwGWCxff/dVb00F4NUAAAAASUVORK5CYII=
+</value>
+  </data>
   <metadata name="$this.TrayHeight" type="System.Int32, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
     <value>45</value>
   </metadata>

OpenRA.Editor/LegacyMapImporter.cs

@@ -82,19 +82,19 @@ namespace OpenRA.Editor
 //			{"scrate","crate"},
 		};
 
-		// todo: fix this -- will have bitrotted pretty badly.
-		static Dictionary<string,Pair<Color,Color>> namedColorMapping = new Dictionary<string, Pair<Color, Color>>()
+		// TODO: fix this -- will have bitrotted pretty badly.
+		static Dictionary<string, HSLColor> namedColorMapping = new Dictionary<string, HSLColor>()
 		{
-			{"gold",Pair.New(Color.FromArgb(246,214,121),Color.FromArgb(40,32,8))},
-			{"blue",Pair.New(Color.FromArgb(226,230,246),Color.FromArgb(8,20,52))},
-			{"red",Pair.New(Color.FromArgb(255,20,0),Color.FromArgb(56,0,0))},
-			{"neutral",Pair.New(Color.FromArgb(238,238,238),Color.FromArgb(44,28,24))},
-			{"orange",Pair.New(Color.FromArgb(255,230,149),Color.FromArgb(56,0,0))},
-			{"teal",Pair.New(Color.FromArgb(93,194,165),Color.FromArgb(0,32,32))},
-			{"salmon",Pair.New(Color.FromArgb(210,153,125),Color.FromArgb(56,0,0))},
-			{"green",Pair.New(Color.FromArgb(160,240,140),Color.FromArgb(20,20,20))},
-			{"white",Pair.New(Color.FromArgb(255,255,255),Color.FromArgb(75,75,75))},
-			{"black",Pair.New(Color.FromArgb(80,80,80),Color.FromArgb(5,5,5))},
+			{ "gold", HSLColor.FromRGB(246,214,121) },
+			{ "blue", HSLColor.FromRGB(226,230,246) },
+			{ "red", HSLColor.FromRGB(255,20,0) },
+			{ "neutral", HSLColor.FromRGB(238,238,238) },
+			{ "orange", HSLColor.FromRGB(255,230,149) },
+			{ "teal", HSLColor.FromRGB(93,194,165) },
+			{ "salmon", HSLColor.FromRGB(210,153,125) },
+			{ "green", HSLColor.FromRGB(160,240,140) },
+			{ "white", HSLColor.FromRGB(255,255,255) },
+			{ "black", HSLColor.FromRGB(80,80,80) },
 		};
 
 		int MapSize;
@@ -174,10 +174,10 @@ namespace OpenRA.Editor
 			// Add waypoint actors
 			foreach( var kv in wps )
 			{
-				var a = new ActorReference("mpspawn");
-				a.Add(new LocationInit(kv.Second));
+				var a = new ActorReference("waypoint");
+				a.Add(new LocationInit((CPos)kv.Second));
 				a.Add(new OwnerInit("Neutral"));
-				Map.Actors.Value.Add("spawn" + kv.First, a);
+				Map.Actors.Value.Add("waypoint" + kv.First, a);
 			}
 
 		}
@@ -189,27 +189,27 @@ namespace OpenRA.Editor
 
 		static MemoryStream ReadPackedSection(IniSection mapPackSection)
 		{
-			StringBuilder sb = new StringBuilder();
+			var sb = new StringBuilder();
 			for (int i = 1; ; i++)
 			{
-				string line = mapPackSection.GetValue(i.ToString(), null);
+				var line = mapPackSection.GetValue(i.ToString(), null);
 				if (line == null)
 					break;
 
 				sb.Append(line.Trim());
 			}
 
-			byte[] data = Convert.FromBase64String(sb.ToString());
-			List<byte[]> chunks = new List<byte[]>();
-			BinaryReader reader = new BinaryReader(new MemoryStream(data));
+			var data = Convert.FromBase64String(sb.ToString());
+			var chunks = new List<byte[]>();
+			var reader = new BinaryReader(new MemoryStream(data));
 
 			try
 			{
 				while (true)
 				{
-					uint length = reader.ReadUInt32() & 0xdfffffff;
-					byte[] dest = new byte[8192];
-					byte[] src = reader.ReadBytes((int)length);
+					var length = reader.ReadUInt32() & 0xdfffffff;
+					var dest = new byte[8192];
+					var src = reader.ReadBytes((int)length);
 
 					/*int actualLength =*/
 					Format80.DecodeInto(src, dest);
@@ -219,8 +219,8 @@ namespace OpenRA.Editor
 			}
 			catch (EndOfStreamException) { }
 
-			MemoryStream ms = new MemoryStream();
-			foreach (byte[] chunk in chunks)
+			var ms = new MemoryStream();
+			foreach (var chunk in chunks)
 				ms.Write(chunk, 0, chunk.Length);
 
 			ms.Position = 0;
@@ -276,7 +276,7 @@ namespace OpenRA.Editor
 						Map.Actors.Value.Add("Actor" + ActorCount++,
 							new ActorReference(overlayActorMapping[raOverlayNames[o]])
 							{
-								new LocationInit( new int2(i, j) ),
+								new LocationInit( new CPos(i, j) ),
 								new OwnerInit( "Neutral" )
 							});
 				}
@@ -284,7 +284,7 @@ namespace OpenRA.Editor
 
 		void ReadRATrees(IniFile file)
 		{
-			IniSection terrain = file.GetSection("TERRAIN", true);
+			var terrain = file.GetSection("TERRAIN", true);
 			if (terrain == null)
 				return;
 
@@ -294,7 +294,7 @@ namespace OpenRA.Editor
 				Map.Actors.Value.Add("Actor" + ActorCount++,
 					new ActorReference(kv.Value.ToLowerInvariant())
 					{
-						new LocationInit(new int2(loc % MapSize, loc / MapSize)),
+						new LocationInit(new CPos(loc % MapSize, loc / MapSize)),
 						new OwnerInit("Neutral")
 					});
 			}
@@ -316,14 +316,14 @@ namespace OpenRA.Editor
 
 		void ReadCncOverlay(IniFile file)
 		{
-			IniSection overlay = file.GetSection("OVERLAY", true);
+			var overlay = file.GetSection("OVERLAY", true);
 			if (overlay == null)
 				return;
 
 			foreach (KeyValuePair<string, string> kv in overlay)
 			{
 				var loc = int.Parse(kv.Key);
-				int2 cell = new int2(loc % MapSize, loc / MapSize);
+				var cell = new CPos(loc % MapSize, loc / MapSize);
 
 				var res = Pair.New((byte)0, (byte)0);
 				if (overlayResourceMapping.ContainsKey(kv.Value.ToLower()))
@@ -343,7 +343,7 @@ namespace OpenRA.Editor
 
 		void ReadCncTrees(IniFile file)
 		{
-			IniSection terrain = file.GetSection("TERRAIN", true);
+			var terrain = file.GetSection("TERRAIN", true);
 			if (terrain == null)
 				return;
 
@@ -353,7 +353,7 @@ namespace OpenRA.Editor
 				Map.Actors.Value.Add("Actor" + ActorCount++,
 					new ActorReference(kv.Value.Split(',')[0].ToLowerInvariant())
 					{
-						new LocationInit(new int2(loc % MapSize, loc / MapSize)),
+						new LocationInit(new CPos(loc % MapSize, loc / MapSize)),
 						new OwnerInit("Neutral")
 					});
 			}
@@ -375,13 +375,12 @@ namespace OpenRA.Editor
 					if (parts[0] == "")
 						parts[0] = "Neutral";
 
-
 					if (!Players.Contains(parts[0]))
 						Players.Add(parts[0]);
 
 					var actor = new ActorReference(parts[1].ToLowerInvariant())
 					{
-						new LocationInit(new int2(loc % MapSize, loc / MapSize)),
+						new LocationInit(new CPos(loc % MapSize, loc / MapSize)),
 						new OwnerInit(parts[0]),
 						new HealthInit(float.Parse(parts[2], NumberFormatInfo.InvariantInfo)/256),
 						new FacingInit((section == "INFANTRY") ? int.Parse(parts[6]) : int.Parse(parts[4])),
@@ -415,25 +414,62 @@ namespace OpenRA.Editor
 
 		void LoadPlayer(IniFile file, string section, bool isRA)
 		{
-			var c = section == "BadGuy" ? "red" :
-						isRA ? "blue" : "gold";
-
-			var color = namedColorMapping[c];
+			string c;
+			string race;
+			switch (section)
+			{
+				case "Spain":
+					c = "gold";
+					race = "allies";
+					break;
+				case "England":
+					c = "green";
+					race = "allies";
+					break;
+				case "Ukraine":
+					c = "orange";
+					race = "soviet";
+					break;
+				case "Germany":
+					c = "black";
+					race = "allies";
+					break;
+				case "France":
+					c = "teal";
+					race = "allies";
+					break;
+				case "Turkey":
+					c = "salmon";
+					race = "allies";
+					break;
+				case "Greece":
+				case "GoodGuy":
+					c = isRA? "blue" : "gold";
+					race = isRA ? "allies" : "gdi";
+					break;
+				case "USSR":
+				case "BadGuy":
+					c = "red";
+					race = isRA ? "soviet" : "nod";
+					break;
+				case "Special":
+				case "Neutral":
+				default:
+					c = "neutral";
+					race = isRA ? "allies" : "gdi";
+					break;
+			}
 
 			var pr = new PlayerReference
 			{
 				Name = section,
 				OwnsWorld = section == "Neutral",
 				NonCombatant = section == "Neutral",
-				Race = isRA ? (section == "BadGuy" ? "soviet" : "allies") : (section == "BadGuy" ? "nod" : "gdi"),
-				ColorRamp = new ColorRamp(
-						(byte)((color.First.GetHue() / 360.0f) * 255),
-						(byte)(color.First.GetSaturation() * 255),
-						(byte)(color.First.GetBrightness() * 255),
-						(byte)(color.Second.GetBrightness() * 255))
+				Race = race,
+				Color = namedColorMapping[c]
 			};
 
-			var Neutral = new [] {"Neutral"};
+			var neutral = new [] {"Neutral"};
 			foreach (var s in file.GetSection(section, true))
 			{
 				Console.WriteLine(s.Key);
@@ -443,8 +479,8 @@ namespace OpenRA.Editor
 						pr.InitialCash = int.Parse(s.Value);
 					break;
 					case "Allies":
-						pr.Allies = s.Value.Split(',').Intersect(Players).Except(Neutral).ToArray();
-						pr.Enemies = s.Value.Split(',').SymmetricDifference(Players).Except(Neutral).ToArray();
+						pr.Allies = s.Value.Split(',').Intersect(Players).Except(neutral).ToArray();
+						pr.Enemies = s.Value.Split(',').SymmetricDifference(Players).Except(neutral).ToArray();
 					break;
 				}
 			}

OpenRA.Editor/MapSelect.Designer.cs

@@ -12,15 +12,10 @@ namespace OpenRA.Editor
 {
 	partial class MapSelect
 	{
-		/// <summary>
-		/// TODO
-		/// </summary>
+		// TODO:
 		private System.ComponentModel.IContainer components = null;
 
-		/// <summary>
-		/// TODO
-		/// </summary>
-		/// <param name="disposing">TODO</param>
+		// TODO:
 		protected override void Dispose(bool disposing)
 		{
 			if (disposing && (components != null))
@@ -32,9 +27,7 @@ namespace OpenRA.Editor
 
 		#region Код, автоматически созданный конструктором форм Windows
 
-		/// <summary>
-		/// TODO
-		/// </summary>
+		// TODO:
 		private void InitializeComponent()
 		{
 			this.components = new System.ComponentModel.Container();

OpenRA.Editor/MapSelect.cs

@@ -20,11 +20,19 @@ namespace OpenRA.Editor
 	{
 		public string MapFolderPath;
 
+		public bool DirectoryIsEmpty(string path)
+		{
+			return !Directory.GetFileSystemEntries(path).Any();
+		}
+
 		public MapSelect(string currentMod)
 		{
-			MapFolderPath = new string[] { Environment.CurrentDirectory, "mods", currentMod, "maps" }
+			MapFolderPath = new string[] { Platform.SupportDir, "maps", currentMod }
 				.Aggregate(Path.Combine);
 
+			if (!Directory.Exists(MapFolderPath))
+				Directory.CreateDirectory(MapFolderPath);
+
 			InitializeComponent();
 			MapIconsList.Images.Add(pictureBox1.Image);
 		}
@@ -34,6 +42,9 @@ namespace OpenRA.Editor
 			MapList.Items.Clear();
 			txtPathOut.Text = MapFolderPath;
 
+			if (DirectoryIsEmpty(MapFolderPath))
+				return;
+
 			foreach (var map in ModData.FindMapsIn(MapFolderPath))
 			{
 				ListViewItem map1 = new ListViewItem();

OpenRA.Editor/OpenRA.Editor.csproj

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
@@ -13,6 +13,25 @@
     <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
     <ApplicationIcon>OpenRA.Editor.Icon.ico</ApplicationIcon>
+    <FileUpgradeFlags>
+    </FileUpgradeFlags>
+    <OldToolsVersion>3.5</OldToolsVersion>
+    <UpgradeBackupLocation />
+    <PublishUrl>publish\</PublishUrl>
+    <Install>true</Install>
+    <InstallFrom>Disk</InstallFrom>
+    <UpdateEnabled>false</UpdateEnabled>
+    <UpdateMode>Foreground</UpdateMode>
+    <UpdateInterval>7</UpdateInterval>
+    <UpdateIntervalUnits>Days</UpdateIntervalUnits>
+    <UpdatePeriodically>false</UpdatePeriodically>
+    <UpdateRequired>false</UpdateRequired>
+    <MapFileExtensions>true</MapFileExtensions>
+    <ApplicationRevision>0</ApplicationRevision>
+    <ApplicationVersion>1.0.0.%2a</ApplicationVersion>
+    <IsWebBootstrapper>false</IsWebBootstrapper>
+    <UseApplicationTrust>false</UseApplicationTrust>
+    <BootstrapperEnabled>true</BootstrapperEnabled>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -25,6 +44,7 @@
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <PlatformTarget>x86</PlatformTarget>
     <UseVSHostingProcess>false</UseVSHostingProcess>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
@@ -35,6 +55,7 @@
     <WarningLevel>4</WarningLevel>
     <UseVSHostingProcess>false</UseVSHostingProcess>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="System" />
@@ -98,6 +119,7 @@
     <Compile Include="Properties\AssemblyInfo.cs" />
     <EmbeddedResource Include="ActorPropertiesDialog.resx">
       <DependentUpon>ActorPropertiesDialog.cs</DependentUpon>
+      <SubType>Designer</SubType>
     </EmbeddedResource>
     <EmbeddedResource Include="Form1.resx">
       <DependentUpon>Form1.cs</DependentUpon>
@@ -122,6 +144,7 @@
     <Compile Include="Properties\Resources.Designer.cs">
       <AutoGen>True</AutoGen>
       <DependentUpon>Resources.resx</DependentUpon>
+      <DesignTime>True</DesignTime>
     </Compile>
     <None Include="Properties\Settings.settings">
       <Generator>SettingsSingleFileGenerator</Generator>
@@ -157,6 +180,23 @@
   <ItemGroup>
     <Content Include="OpenRA.Editor.Icon.ico" />
   </ItemGroup>
+  <ItemGroup>
+    <BootstrapperPackage Include="Microsoft.Net.Client.3.5">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1 Client Profile</ProductName>
+      <Install>false</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1</ProductName>
+      <Install>true</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Windows.Installer.3.1">
+      <Visible>False</Visible>
+      <ProductName>Windows Installer 3.1</ProductName>
+      <Install>true</Install>
+    </BootstrapperPackage>
+  </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.

OpenRA.Editor/Properties/Resources.Designer.cs

@@ -1,71 +1,63 @@
 //------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by a tool.
-//     Runtime Version:2.0.50727.4927
+//     Runtime Version:4.0.30319.269
 //
 //     Changes to this file may cause incorrect behavior and will be lost if
 //     the code is regenerated.
 // </auto-generated>
 //------------------------------------------------------------------------------
 
-namespace OpenRA.Editor.Properties
-{
-
-
-	/// <summary>
-	///   A strongly-typed resource class, for looking up localized strings, etc.
-	/// </summary>
-	// This class was auto-generated by the StronglyTypedResourceBuilder
-	// class via a tool like ResGen or Visual Studio.
-	// To add or remove a member, edit your .ResX file then rerun ResGen
-	// with the /str option, or rebuild your VS project.
-	[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "2.0.0.0")]
-	[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
-	[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
-	internal class Resources
-	{
-
-		private static global::System.Resources.ResourceManager resourceMan;
-
-		private static global::System.Globalization.CultureInfo resourceCulture;
-
-		[global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
-		internal Resources()
-		{
-		}
-
-		/// <summary>
-		///   Returns the cached ResourceManager instance used by this class.
-		/// </summary>
-		[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
-		internal static global::System.Resources.ResourceManager ResourceManager
-		{
-			get
-			{
-				if ((resourceMan == null))
-				{
-					global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("OpenRA.Editor.Properties.Resources", typeof(Resources).Assembly);
-					resourceMan = temp;
-				}
-				return resourceMan;
-			}
-		}
-
-		/// <summary>
-		///   Overrides the current thread's CurrentUICulture property for all
-		///   resource lookups using this strongly typed resource class.
-		/// </summary>
-		[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
-		internal static global::System.Globalization.CultureInfo Culture
-		{
-			get
-			{
-				return resourceCulture;
-			}
-			set
-			{
-				resourceCulture = value;
-			}
-		}
-	}
+namespace OpenRA.Editor.Properties {
+    using System;
+    
+    
+    /// <summary>
+    ///   A strongly-typed resource class, for looking up localized strings, etc.
+    /// </summary>
+    // This class was auto-generated by the StronglyTypedResourceBuilder
+    // class via a tool like ResGen or Visual Studio.
+    // To add or remove a member, edit your .ResX file then rerun ResGen
+    // with the /str option, or rebuild your VS project.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    internal class Resources {
+        
+        private static global::System.Resources.ResourceManager resourceMan;
+        
+        private static global::System.Globalization.CultureInfo resourceCulture;
+        
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal Resources() {
+        }
+        
+        /// <summary>
+        ///   Returns the cached ResourceManager instance used by this class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Resources.ResourceManager ResourceManager {
+            get {
+                if (object.ReferenceEquals(resourceMan, null)) {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("OpenRA.Editor.Properties.Resources", typeof(Resources).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+        
+        /// <summary>
+        ///   Overrides the current thread's CurrentUICulture property for all
+        ///   resource lookups using this strongly typed resource class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Globalization.CultureInfo Culture {
+            get {
+                return resourceCulture;
+            }
+            set {
+                resourceCulture = value;
+            }
+        }
+    }
 }

OpenRA.Editor/Properties/Settings.Designer.cs

@@ -1,30 +1,26 @@
 //------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by a tool.
-//     Runtime Version:2.0.50727.4927
+//     Runtime Version:4.0.30319.269
 //
 //     Changes to this file may cause incorrect behavior and will be lost if
 //     the code is regenerated.
 // </auto-generated>
 //------------------------------------------------------------------------------
 
-namespace OpenRA.Editor.Properties
-{
-
-
-	[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
-	[global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "9.0.0.0")]
-	internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase
-	{
-
-		private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
-
-		public static Settings Default
-		{
-			get
-			{
-				return defaultInstance;
-			}
-		}
-	}
+namespace OpenRA.Editor.Properties {
+    
+    
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "10.0.0.0")]
+    internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase {
+        
+        private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
+        
+        public static Settings Default {
+            get {
+                return defaultInstance;
+            }
+        }
+    }
 }

OpenRA.Editor/RenderUtils.cs

@@ -26,7 +26,7 @@ namespace OpenRA.Editor
 
 			bitmap.Palette = p.AsSystemPalette();
 
-			var data = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height),
+			var data = bitmap.LockBits(bitmap.Bounds(),
 				ImageLockMode.WriteOnly, PixelFormat.Format8bppIndexed);
 
 			unsafe
@@ -45,7 +45,7 @@ namespace OpenRA.Editor
 
 		public static ActorTemplate RenderActor(ActorInfo info, TileSet tileset, Palette p)
 		{
-			var image = RenderSimple.GetImage(info);
+			var image = RenderSprites.GetImage(info);
 
 			using (var s = FileSystem.OpenWithExts(image, tileset.Extensions))
 			{
@@ -84,7 +84,7 @@ namespace OpenRA.Editor
 
 				var bitmap = new Bitmap(shp.Width, shp.Height, PixelFormat.Format8bppIndexed);
 				bitmap.Palette = p.AsSystemPalette();
-				var data = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height),
+				var data = bitmap.LockBits(bitmap.Bounds(),
 					ImageLockMode.WriteOnly, PixelFormat.Format8bppIndexed);
 
 				unsafe

OpenRA.Editor/Settings.StyleCop

@@ -0,0 +1,334 @@
+<StyleCopSettings Version="105">
+  <Analyzers>
+    <Analyzer AnalyzerId="StyleCop.CSharp.DocumentationRules">
+      <Rules>
+        <Rule Name="ElementsMustBeDocumented">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="PartialElementsMustBeDocumented">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="EnumerationItemsMustBeDocumented">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="DocumentationMustContainValidXml">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementDocumentationMustHaveSummary">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="PartialElementDocumentationMustHaveSummary">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementDocumentationMustHaveSummaryText">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="PartialElementDocumentationMustHaveSummaryText">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementDocumentationMustNotHaveDefaultSummary">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementParametersMustBeDocumented">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementParameterDocumentationMustMatchElementParameters">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementParameterDocumentationMustDeclareParameterName">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementParameterDocumentationMustHaveText">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementReturnValueMustBeDocumented">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementReturnValueDocumentationMustHaveText">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="VoidReturnValueMustNotBeDocumented">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="GenericTypeParametersMustBeDocumented">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="GenericTypeParametersMustBeDocumentedPartialClass">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="GenericTypeParameterDocumentationMustMatchTypeParameters">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="GenericTypeParameterDocumentationMustDeclareParameterName">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="GenericTypeParameterDocumentationMustHaveText">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="PropertySummaryDocumentationMustMatchAccessors">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="PropertySummaryDocumentationMustOmitSetAccessorWithRestrictedAccess">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementDocumentationMustNotBeCopiedAndPasted">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="SingleLineCommentsMustNotUseDocumentationStyleSlashes">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="DocumentationTextMustNotBeEmpty">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="DocumentationTextMustContainWhitespace">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="DocumentationMustMeetCharacterPercentage">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ConstructorSummaryDocumentationMustBeginWithStandardText">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="DestructorSummaryDocumentationMustBeginWithStandardText">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="DocumentationHeadersMustNotContainBlankLines">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="IncludedDocumentationXPathDoesNotExist">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="IncludeNodeDoesNotContainValidFileAndPath">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="InheritDocMustBeUsedWithInheritingClass">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementDocumentationMustBeSpelledCorrectly">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="FileMustHaveHeader">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="FileHeaderMustShowCopyright">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="FileHeaderMustHaveCopyrightText">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="FileHeaderMustContainFileName">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="FileHeaderFileNameDocumentationMustMatchFileName">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="FileHeaderMustHaveValidCompanyText">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="FileHeaderFileNameDocumentationMustMatchTypeName">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+      </Rules>
+      <AnalyzerSettings />
+    </Analyzer>
+    <Analyzer AnalyzerId="StyleCop.CSharp.SpacingRules">
+      <Rules>
+        <Rule Name="TabsMustNotBeUsed">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+      </Rules>
+      <AnalyzerSettings />
+    </Analyzer>
+    <Analyzer AnalyzerId="StyleCop.CSharp.LayoutRules">
+      <Rules>
+        <Rule Name="CurlyBracketsForMultiLineStatementsMustNotShareLine">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="StatementMustNotBeOnSingleLine">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementMustNotBeOnSingleLine">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="CurlyBracketsMustNotBeOmitted">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementsMustBeSeparatedByBlankLine">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+      </Rules>
+      <AnalyzerSettings />
+    </Analyzer>
+    <Analyzer AnalyzerId="StyleCop.CSharp.OrderingRules">
+      <Rules>
+        <Rule Name="UsingDirectivesMustBePlacedWithinNamespace">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementsMustAppearInTheCorrectOrder">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementsMustBeOrderedByAccess">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+      </Rules>
+      <AnalyzerSettings />
+    </Analyzer>
+    <Analyzer AnalyzerId="StyleCop.CSharp.ReadabilityRules">
+      <Rules>
+        <Rule Name="CodeMustNotContainMultipleStatementsOnOneLine">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="UseStringEmptyForEmptyStrings">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="PrefixLocalCallsWithThis">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="PrefixCallsCorrectly">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ParametersMustBeOnSameLineOrSeparateLines">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+      </Rules>
+      <AnalyzerSettings />
+    </Analyzer>
+    <Analyzer AnalyzerId="StyleCop.CSharp.MaintainabilityRules">
+      <Rules>
+        <Rule Name="AccessModifierMustBeDeclared">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="FieldsMustBePrivate">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="FileMayOnlyContainASingleClass">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ArithmeticExpressionsMustDeclarePrecedence">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+      </Rules>
+      <AnalyzerSettings />
+    </Analyzer>
+  </Analyzers>
+</StyleCopSettings>

OpenRA.Editor/Surface.cs

@@ -26,6 +26,7 @@ namespace OpenRA.Editor
 		public Map Map { get; private set; }
 		public TileSet TileSet { get; private set; }
 		public Palette Palette { get; private set; }
+		public Palette PlayerPalette { get; private set; }
 		public int2 Offset;
 
 		public int2 GetOffset() { return Offset; }
@@ -35,8 +36,16 @@ namespace OpenRA.Editor
 		ITool Tool;
 
 		public bool IsPanning;
+		public bool IsErasing;
 		public bool ShowActorNames;
 		public bool ShowGrid;
+		public bool ShowRuler;
+
+		public bool IsPaste { get { return TileSelection != null && ResourceSelection != null; } }
+		public TileReference<ushort, byte>[,] TileSelection;
+		public TileReference<byte, byte>[,] ResourceSelection;
+		public CPos SelectionStart;
+		public CPos SelectionEnd;
 
 		public string NewActorOwner;
 
@@ -45,21 +54,25 @@ namespace OpenRA.Editor
 		public event Action<KeyValuePair<string, ActorReference>> ActorDoubleClicked = _ => { };
 
 		Dictionary<string, ActorTemplate> ActorTemplates = new Dictionary<string, ActorTemplate>();
-		Dictionary<int, ResourceTemplate> ResourceTemplates = new Dictionary<int, ResourceTemplate>();
+		public Dictionary<int, ResourceTemplate> ResourceTemplates = new Dictionary<int, ResourceTemplate>();
+
+		static readonly Font MarkerFont = new Font(FontFamily.GenericSansSerif, 12.0f, FontStyle.Regular);
+		static readonly SolidBrush TextBrush = new SolidBrush(Color.Red);
 
 		public Keys GetModifiers() { return ModifierKeys; }
 
-		public void Bind(Map m, TileSet ts, Palette p)
+		public void Bind(Map m, TileSet ts, Palette p, Palette pp)
 		{
 			Map = m;
 			TileSet = ts;
 			Palette = p;
+			PlayerPalette = pp;
 			PlayerPalettes = null;
 			Chunks.Clear();
 			Tool = null;
 		}
 
-		public void SetTool(ITool tool) { Tool = tool; }
+		public void SetTool(ITool tool) { Tool = tool; ClearSelection(); }
 
 		public void BindActorTemplates(IEnumerable<ActorTemplate> templates)
 		{
@@ -83,6 +96,8 @@ namespace OpenRA.Editor
 			UpdateStyles();
 		}
 
+		static readonly Pen SelectionPen = new Pen(Color.Blue);
+		static readonly Pen PastePen = new Pen(Color.Green);
 		static readonly Pen CordonPen = new Pen(Color.Red);
 		int2 MousePos;
 
@@ -144,10 +159,10 @@ namespace OpenRA.Editor
 				Scroll(oldMousePos - MousePos);
 			else
 			{
-				if (e.Button == MouseButtons.Right)
+				if (e.Button == MouseButtons.Right || (IsErasing && e.Button == MouseButtons.Left))
 					Erase();
 
-				if (e.Button == MouseButtons.Left)
+				if (e.Button == MouseButtons.Left && !IsErasing)
 					Draw();
 
 				Invalidate();
@@ -157,23 +172,23 @@ namespace OpenRA.Editor
 		void Erase()
 		{
 			// Crash preventing
-			var BrushLocation = GetBrushLocation();
+			var brushLocation = GetBrushLocation();
 
-			if (Map == null || BrushLocation.X >= Map.MapSize.X ||
-				BrushLocation.Y >= Map.MapSize.Y ||
-				BrushLocation.X < 0 ||
-				BrushLocation.Y < 0)
+			if (Map == null || brushLocation.X >= Map.MapSize.X ||
+				brushLocation.Y >= Map.MapSize.Y ||
+				brushLocation.X < 0 ||
+				brushLocation.Y < 0)
 				return;
 
 			Tool = null;
 
-			var key = Map.Actors.Value.FirstOrDefault(a => a.Value.Location() == BrushLocation);
+			var key = Map.Actors.Value.FirstOrDefault(a => a.Value.Location() == brushLocation);
 			if (key.Key != null) Map.Actors.Value.Remove(key.Key);
 
-			if (Map.MapResources.Value[BrushLocation.X, BrushLocation.Y].type != 0)
+			if (Map.MapResources.Value[brushLocation.X, brushLocation.Y].type != 0)
 			{
-				Map.MapResources.Value[BrushLocation.X, BrushLocation.Y] = new TileReference<byte, byte>();
-				var ch = new int2((BrushLocation.X) / ChunkSize, (BrushLocation.Y) / ChunkSize);
+				Map.MapResources.Value[brushLocation.X, brushLocation.Y] = new TileReference<byte, byte>();
+				var ch = new int2((brushLocation.X) / ChunkSize, (brushLocation.Y) / ChunkSize);
 				if (Chunks.ContainsKey(ch))
 				{
 					Chunks[ch].Dispose();
@@ -182,12 +197,20 @@ namespace OpenRA.Editor
 			}
 
 			AfterChange();
+			ClearSelection();
 		}
 
 		void Draw()
 		{
-			if (Tool != null) Tool.Apply(this);
-			AfterChange();
+			if (Tool != null)
+			{
+				Tool.Apply(this);
+				AfterChange();
+			}
+			else if (IsPaste)
+				PasteSelection();
+			else
+				SelectionEnd = GetBrushLocationBR();
 		}
 
 		protected override void OnMouseDown(MouseEventArgs e)
@@ -199,7 +222,12 @@ namespace OpenRA.Editor
 			if (!IsPanning)
 			{
 				if (e.Button == MouseButtons.Right) Erase();
-				if (e.Button == MouseButtons.Left) Draw();
+				if (e.Button == MouseButtons.Left && !IsErasing)
+				{
+					Draw();
+					if (!IsPaste)
+						SelectionStart = SelectionEnd = GetBrushLocation();
+				}
 			}
 
 			Invalidate();
@@ -212,7 +240,7 @@ namespace OpenRA.Editor
 
 			var bitmap = new Bitmap(ChunkSize * TileSet.TileSize, ChunkSize * TileSet.TileSize);
 
-			var data = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height),
+			var data = bitmap.LockBits(bitmap.Bounds(),
 				ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);
 
 			unsafe
@@ -234,7 +262,7 @@ namespace OpenRA.Editor
 						if (Map.MapResources.Value[u * ChunkSize + i, v * ChunkSize + j].type != 0)
 						{
 							var resourceImage = ResourceTemplates[Map.MapResources.Value[u * ChunkSize + i, v * ChunkSize + j].type].Bitmap;
-							var srcdata = resourceImage.LockBits(new Rectangle(0, 0, resourceImage.Width, resourceImage.Height),
+							var srcdata = resourceImage.LockBits(resourceImage.Bounds(),
 								ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
 
 							int* q = (int*)srcdata.Scan0.ToPointer();
@@ -267,31 +295,42 @@ namespace OpenRA.Editor
 			return bitmap;
 		}
 
-		public int2 GetBrushLocation()
+		public CPos GetBrushLocation()
 		{
 			var vX = (int)Math.Floor((MousePos.X - Offset.X) / Zoom);
 			var vY = (int)Math.Floor((MousePos.Y - Offset.Y) / Zoom);
-			return new int2(vX / TileSet.TileSize, vY / TileSet.TileSize);
+			return new CPos(vX / TileSet.TileSize, vY / TileSet.TileSize);
 		}
 
-		public void DrawActor(SGraphics g, int2 p, ActorTemplate t, ColorPalette cp)
+		public CPos GetBrushLocationBR()
+		{
+			var vX = (int)Math.Floor((MousePos.X - Offset.X) / Zoom);
+			var vY = (int)Math.Floor((MousePos.Y - Offset.Y) / Zoom);
+			return new CPos((vX + TileSet.TileSize - 1) / TileSet.TileSize,
+			                (vY + TileSet.TileSize - 1) / TileSet.TileSize);
+		}
+
+		public void DrawActor(SGraphics g, CPos p, ActorTemplate t, ColorPalette cp)
 		{
 			var centered = t.Appearance == null || !t.Appearance.RelativeToTopLeft;
-			DrawImage(g, t.Bitmap, p, centered, cp);
+			var actorPalette = cp;
+			if (t.Appearance != null && t.Appearance.UseTerrainPalette)
+				actorPalette = Palette.AsSystemPalette();
+			DrawImage(g, t.Bitmap, p, centered, actorPalette);
 		}
 
-		float2 GetDrawPosition(int2 location, Bitmap bmp, bool centered)
+		float2 GetDrawPosition(CPos location, Bitmap bmp, bool centered)
 		{
-			float OffsetX = centered ? bmp.Width / 2 - TileSet.TileSize / 2 : 0;
-			float DrawX = TileSet.TileSize * location.X * Zoom + Offset.X - OffsetX;
+			float offsetX = centered ? bmp.Width / 2 - TileSet.TileSize / 2 : 0;
+			float drawX = TileSet.TileSize * location.X * Zoom + Offset.X - offsetX;
 
-			float OffsetY = centered ? bmp.Height / 2 - TileSet.TileSize / 2 : 0;
-			float DrawY = TileSet.TileSize * location.Y * Zoom + Offset.Y - OffsetY;
+			float offsetY = centered ? bmp.Height / 2 - TileSet.TileSize / 2 : 0;
+			float drawY = TileSet.TileSize * location.Y * Zoom + Offset.Y - offsetY;
 
-			return new float2(DrawX, DrawY);
+			return new float2(drawX, drawY);
 		}
 
-		public void DrawImage(SGraphics g, Bitmap bmp, int2 location, bool centered, ColorPalette cp)
+		public void DrawImage(SGraphics g, Bitmap bmp, CPos location, bool centered, ColorPalette cp)
 		{
 			var drawPos = GetDrawPosition(location, bmp, centered);
 
@@ -304,7 +343,7 @@ namespace OpenRA.Editor
 			if (cp != null) bmp.Palette = restorePalette;
 		}
 
-		void DrawActorBorder(SGraphics g, int2 p, ActorTemplate t)
+		void DrawActorBorder(SGraphics g, CPos p, ActorTemplate t)
 		{
 			var centered = t.Appearance == null || !t.Appearance.RelativeToTopLeft;
 			var drawPos = GetDrawPosition(p, t.Bitmap, centered);
@@ -318,8 +357,8 @@ namespace OpenRA.Editor
 		{
 			var pr = Map.Players[name];
 			var pcpi = Rules.Info["player"].Traits.Get<PlayerColorPaletteInfo>();
-			var remap = new PlayerColorRemap(pcpi.PaletteFormat, pr.ColorRamp);
-			return new Palette(Palette, remap).AsSystemPalette();
+			var remap = new PlayerColorRemap(pcpi.RemapIndex, pr.Color, pcpi.Ramp);
+			return new Palette(PlayerPalette, remap).AsSystemPalette();
 		}
 
 		Cache<string, ColorPalette> PlayerPalettes;
@@ -352,7 +391,7 @@ namespace OpenRA.Editor
 					var x = new int2(u / ChunkSize, v / ChunkSize);
 					if (!Chunks.ContainsKey(x)) Chunks[x] = RenderChunk(u / ChunkSize, v / ChunkSize);
 
-					Bitmap bmp = Chunks[x];
+					var bmp = Chunks[x];
 
 					float DrawX = TileSet.TileSize * (float)ChunkSize * (float)x.X * Zoom + Offset.X;
 					float DrawY = TileSet.TileSize * (float)ChunkSize * (float)x.Y * Zoom + Offset.Y;
@@ -367,6 +406,25 @@ namespace OpenRA.Editor
 				Map.Bounds.Width * TileSet.TileSize * Zoom,
 				Map.Bounds.Height * TileSet.TileSize * Zoom);
 
+			e.Graphics.DrawRectangle(SelectionPen,
+				(SelectionStart.X * TileSet.TileSize * Zoom) + Offset.X,
+				(SelectionStart.Y * TileSet.TileSize * Zoom) + Offset.Y,
+				(SelectionEnd - SelectionStart).X * TileSet.TileSize * Zoom,
+				(SelectionEnd - SelectionStart).Y * TileSet.TileSize * Zoom);
+
+			if (IsPaste)
+			{
+				var loc = GetBrushLocation();
+				var width = Math.Abs((SelectionStart - SelectionEnd).X);
+				var height = Math.Abs((SelectionStart - SelectionEnd).Y);
+
+				e.Graphics.DrawRectangle(PastePen,
+					(loc.X * TileSet.TileSize * Zoom) + Offset.X,
+					(loc.Y * TileSet.TileSize * Zoom) + Offset.Y,
+					width * (TileSet.TileSize * Zoom),
+					height * (TileSet.TileSize * Zoom));
+			}
+
 			foreach (var ar in Map.Actors.Value)
 			{
 				if (ActorTemplates.ContainsKey(ar.Value.Type))
@@ -385,6 +443,27 @@ namespace OpenRA.Editor
 							Brushes.White,
 							Brushes.Black);
 
+			if (ShowRuler && Zoom > 0.2)
+			{
+				for (int i = Map.Bounds.Left; i <= Map.Bounds.Right; i+=8)
+				{
+					if( i % 8 == 0)
+					{
+						PointF point = new PointF(i * TileSet.TileSize * Zoom + Offset.X, (Map.Bounds.Top - 8) * TileSet.TileSize * Zoom + Offset.Y);
+						e.Graphics.DrawString((i - Map.Bounds.Left).ToString(), MarkerFont, TextBrush, point);
+					}
+				}
+
+				for (int i = Map.Bounds.Top; i <= Map.Bounds.Bottom; i+=8)
+				{
+					if (i % 8 == 0)
+					{
+						PointF point = new PointF((Map.Bounds.Left - 8) * TileSet.TileSize * Zoom + Offset.X, i * TileSet.TileSize * Zoom + Offset.Y);
+						e.Graphics.DrawString((i - Map.Bounds.Left).ToString(), MarkerFont, TextBrush, point);
+					}
+				}
+			}
+
 			if (Tool != null)
 				Tool.Preview(this, e.Graphics);
 
@@ -395,13 +474,74 @@ namespace OpenRA.Editor
 					DrawActorBorder(e.Graphics, x.Value.Location(), ActorTemplates[x.Value.Type]);
 			}
 		}
+
+		public void CopySelection()
+		{
+			// Grab tiles and resources within selection (doesn't do actors)
+			var start = SelectionStart;
+			var end = SelectionEnd;
+
+			if (start == end) return;
+
+			int width = Math.Abs((start - end).X);
+			int height = Math.Abs((start - end).Y);
+
+			TileSelection = new TileReference<ushort, byte>[width, height];
+			ResourceSelection = new TileReference<byte, byte>[width, height];
+
+			for (int x = 0; x < width; x++)
+			{
+				for (int y = 0; y < height; y++)
+				{
+					//TODO: crash prevention
+					TileSelection[x, y] = Map.MapTiles.Value[start.X + x, start.Y + y];
+					ResourceSelection[x, y] = Map.MapResources.Value[start.X + x, start.Y + y];
+				}
+			}
+		}
+
+		void PasteSelection()
+		{
+			var loc = GetBrushLocation();
+			var width = Math.Abs((SelectionStart - SelectionEnd).X);
+			var height = Math.Abs((SelectionStart - SelectionEnd).Y);
+
+			for (int x = 0; x < width; x++)
+			{
+				for (int y = 0; y < height; y++)
+				{
+					var mapX = loc.X + x;
+					var mapY = loc.Y + y;
+
+					//TODO: crash prevention for outside of bounds
+					Map.MapTiles.Value[mapX, mapY] = TileSelection[x, y];
+					Map.MapResources.Value[mapX, mapY] = ResourceSelection[x, y];
+
+					var ch = new int2(mapX / ChunkSize, mapY / ChunkSize);
+					if (Chunks.ContainsKey(ch))
+					{
+						Chunks[ch].Dispose();
+						Chunks.Remove(ch);
+					}
+				}
+			}
+			AfterChange();
+		}
+
+		void ClearSelection()
+		{
+			SelectionStart = CPos.Zero;
+			SelectionEnd = CPos.Zero;
+			TileSelection = null;
+			ResourceSelection = null;
+		}
 	}
 
 	static class ActorReferenceExts
 	{
-		public static int2 Location(this ActorReference ar)
+		public static CPos Location(this ActorReference ar)
 		{
-			return ar.InitDict.Get<LocationInit>().value;
+			return (CPos)ar.InitDict.Get<LocationInit>().value;
 		}
 
 		public static void DrawStringContrast(this SGraphics g, Font f, string s, int x, int y, Brush fg, Brush bg)

OpenRA.FileFormats/Exts.cs

@@ -41,41 +41,6 @@ namespace OpenRA
 			return a.GetTypes().Select(t => t.Namespace).Distinct().Where(n => n != null);
 		}
 
-		public static string ReadAllText(this Stream s)
-		{
-			using (s)
-			using (var sr = new StreamReader(s))
-				return sr.ReadToEnd();
-		}
-
-		public static byte[] ReadAllBytes(this Stream s)
-		{
-			using (s)
-			{
-				var data = new byte[s.Length - s.Position];
-				s.Read(data, 0, data.Length);
-				return data;
-			}
-		}
-
-		public static void Write(this Stream s, byte[] data)
-		{
-			s.Write(data, 0, data.Length);
-		}
-
-		public static IEnumerable<string> ReadAllLines(this Stream s)
-		{
-			using (var sr = new StreamReader(s))
-				for (; ; )
-				{
-					var line = sr.ReadLine();
-					if (line == null)
-						yield break;
-					else
-						yield return line;
-				}
-		}
-
 		public static bool HasAttribute<T>(this MemberInfo mi)
 		{
 			return mi.GetCustomAttributes(typeof(T), true).Length != 0;
@@ -145,6 +110,14 @@ namespace OpenRA
 			return xs[r.Next(xs.Length)];
 		}
 
+		public static T RandomOrDefault<T>(this IEnumerable<T> ts, Thirdparty.Random r)
+		{
+			if (!ts.Any())
+				return default(T);
+
+			return ts.Random(r);
+		}
+
 		public static float Product(this IEnumerable<float> xs)
 		{
 			return xs.Aggregate(1f, (a, x) => a * x);
@@ -172,9 +145,113 @@ namespace OpenRA
 			return v;
 		}
 
+		public static bool IsPowerOf2(int v)
+		{
+			return (v & (v - 1)) == 0;
+		}
+
+		public static Size NextPowerOf2(this Size s) { return new Size(NextPowerOf2(s.Width), NextPowerOf2(s.Height)); }
+
 		public static string JoinWith<T>(this IEnumerable<T> ts, string j)
 		{
 			return string.Join(j, ts.Select(t => t.ToString()).ToArray());
 		}
+
+		public static IEnumerable<T> Append<T>( this IEnumerable<T> ts, params T[] moreTs)
+		{
+			return ts.Concat(moreTs);
+		}
+
+		public static Dictionary<TKey, TSource> ToDictionaryWithConflictLog<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, string debugName, Func<TKey, string> logKey, Func<TSource, string> logValue)
+		{
+			return ToDictionaryWithConflictLog(source, keySelector, x => x, debugName, logKey, logValue);
+		}
+
+		public static Dictionary<TKey, TElement> ToDictionaryWithConflictLog<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, string debugName, Func<TKey, string> logKey, Func<TElement, string> logValue)
+		{
+			// Fall back on ToString() if null functions are provided:
+			logKey = logKey ?? (s => s.ToString());
+			logValue = logValue ?? (s => s.ToString());
+
+			// Try to build a dictionary and log all duplicates found (if any):
+			var dupKeys = new Dictionary<TKey, List<string>>();
+			var d = new Dictionary<TKey, TElement>();
+			foreach (var item in source)
+			{
+				TKey key = keySelector(item);
+				TElement element = elementSelector(item);
+
+				// Check for a key conflict:
+				if (d.ContainsKey(key))
+				{
+					List<string> dupKeyMessages;
+					if (!dupKeys.TryGetValue(key, out dupKeyMessages))
+					{
+						// Log the initial conflicting value already inserted:
+						dupKeyMessages = new List<string>();
+						dupKeyMessages.Add(logValue(d[key]));
+						dupKeys.Add(key, dupKeyMessages);
+					}
+
+					// Log this conflicting value:
+					dupKeyMessages.Add(logValue(element));
+					continue;
+				}
+
+				d.Add(key, element);
+			}
+
+			// If any duplicates were found, log it and throw a descriptive error
+			if (dupKeys.Count > 0)
+			{
+				string badKeysFormatted = String.Join(", ", dupKeys.Select(p => "{0}: [{1}]".F(logKey(p.Key), String.Join(",", p.Value.ToArray()))).ToArray());
+				string msg = "{0}, duplicate values found for the following keys: {1}".F(debugName, badKeysFormatted);
+				Log.Write("debug", msg);
+				throw new ArgumentException(msg);
+			}
+
+			// Return the dictionary we built:
+			return d;
+		}
+
+		public static Color ColorLerp(float t, Color c1, Color c2)
+		{
+			return Color.FromArgb(
+				(int)(t * c2.A + (1 - t) * c1.A),
+				(int)(t * c2.R + (1 - t) * c1.R),
+				(int)(t * c2.G + (1 - t) * c1.G),
+				(int)(t * c2.B + (1 - t) * c1.B));
+		}
+
+		public static T[] MakeArray<T>(int count, Func<int, T> f)
+		{
+			T[] result = new T[count];
+			for (int i = 0; i < count; i++)
+				result[i] = f(i);
+
+			return result;
+		}
+
+		public static Rectangle Bounds(this Bitmap b) { return new Rectangle(0, 0, b.Width, b.Height); }
+
+		public static int ToBits(this IEnumerable<bool> bits)
+		{
+			var i = 0;
+			var result = 0;
+			foreach (var b in bits)
+				if (b)
+					result |= (1 << i++);
+				else
+					i++;
+			if (i > 33)
+				throw new InvalidOperationException("ToBits only accepts up to 32 values.");
+			return result;
+		}
+	}
+
+	public static class Enum<T>
+	{
+		public static T Parse(string s) { return (T)Enum.Parse(typeof(T), s); }
+		public static T[] GetValues() { return (T[])Enum.GetValues(typeof(T)); }
 	}
 }

OpenRA.FileFormats/FieldLoader.cs

@@ -56,6 +56,11 @@ namespace OpenRA.FileFormats
 				ret = GetValue( fieldName, fieldType, n[ 0 ].Value.Value );
 				return true;
 			}
+			else if ( n.Count > 1 )
+			{
+				throw new InvalidOperationException("The field {0} has multiple definitions:\n{1}"
+					.F(fieldName, n.Select(m => "\t- " + m.Location).JoinWith("\n")));
+			}
 			throw new InvalidOperationException( "TryGetValueFromYaml: unable to load field {0} (of type {1})".F( fieldName, fieldType ) );
 		}
 
@@ -143,19 +148,74 @@ namespace OpenRA.FileFormats
 				return InvalidValueAction(x,fieldType, field);
 			}
 
-			else if (fieldType == typeof(ColorRamp))
+			else if (fieldType == typeof(HSLColor))
 			{
 				var parts = x.Split(',');
-				if (parts.Length == 4)
-					return new ColorRamp(
+				// Allow old ColorRamp format to be parsed as HSLColor
+				if (parts.Length == 3 || parts.Length == 4)
+					return new HSLColor(
 						(byte)int.Parse(parts[0]).Clamp(0, 255),
 						(byte)int.Parse(parts[1]).Clamp(0, 255),
-						(byte)int.Parse(parts[2]).Clamp(0, 255),
-						(byte)int.Parse(parts[3]).Clamp(0, 255));
+						(byte)int.Parse(parts[2]).Clamp(0, 255));
 
 				return InvalidValueAction(x, fieldType, field);
 			}
 
+			else if (fieldType == typeof(WRange))
+			{
+				WRange res;
+				if (WRange.TryParse(x, out res))
+					return res;
+
+				return InvalidValueAction(x, fieldType, field);
+			}
+
+			else if (fieldType == typeof(WVec))
+			{
+				var parts = x.Split(',');
+				if (parts.Length == 3)
+				{
+					WRange rx, ry, rz;
+					if (WRange.TryParse(parts[0], out rx) && WRange.TryParse(parts[1], out ry) && WRange.TryParse(parts[2], out rz))
+						return new WVec(rx, ry, rz);
+				}
+
+				return InvalidValueAction(x, fieldType, field);
+			}
+
+			else if (fieldType == typeof(WPos))
+			{
+				var parts = x.Split(',');
+				if (parts.Length == 3)
+				{
+					WRange rx, ry, rz;
+					if (WRange.TryParse(parts[0], out rx) && WRange.TryParse(parts[1], out ry) && WRange.TryParse(parts[2], out rz))
+						return new WPos(rx, ry, rz);
+				}
+
+				return InvalidValueAction(x, fieldType, field);
+			}
+
+			else if (fieldType == typeof(WAngle))
+			{
+				int res;
+				if (int.TryParse(x, out res))
+					return new WAngle(res);
+				return InvalidValueAction(x, fieldType, field);
+			}
+
+			else if (fieldType == typeof(WRot))
+			{
+				var parts = x.Split(',');
+				if (parts.Length == 3)
+				{
+					int rr, rp, ry;
+					if (int.TryParse(x, out rr) && int.TryParse(x, out rp) && int.TryParse(x, out ry))
+						return new WRot(new WAngle(rr), new WAngle(rp), new WAngle(ry));
+				}
+				return InvalidValueAction(x, fieldType, field);
+			}
+
 			else if (fieldType.IsEnum)
 			{
 				if (!Enum.GetNames(fieldType).Select(a => a.ToLower()).Contains(x.ToLower()))
@@ -320,6 +380,10 @@ namespace OpenRA.FileFormats
 					((int)c.B).Clamp(0, 255));
 			}
 
+			// Don't save floats in settings.yaml using country-specific decimal separators which can be misunderstood as group seperators.
+			if (t == typeof(float))
+				return ((float)v).ToString(CultureInfo.InvariantCulture);
+
 			if (t == typeof(Rectangle))
 			{
 				var r = (Rectangle)v;
@@ -342,4 +406,11 @@ namespace OpenRA.FileFormats
 	}
 
 	public class FieldFromYamlKeyAttribute : Attribute { }
+
+	// mirrors DescriptionAttribute from System.ComponentModel but we dont want to have to use that everywhere.
+	public class DescAttribute : Attribute
+	{
+		public readonly string[] Lines;
+		public DescAttribute(params string[] lines) { Lines = lines; }
+	}
 }

OpenRA.FileFormats/FileFormats/BlowfishKeyProvider.cs

@@ -19,24 +19,6 @@ namespace OpenRA.FileFormats
 	{
 		const string pubkeyStr = "AihRvNoIbTn85FZRYNZRcT+i6KpU+maCsEqr3Q5q+LDB5tH7Tz2qQ38V";
 
-		static sbyte[] char2num = {
-	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
-	52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1,
-	-1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
-	15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
-	-1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
-	41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
-	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
-
 		class PublicKey
 		{
 			public uint[] key1 = new uint[64];
@@ -128,25 +110,9 @@ namespace OpenRA.FileFormats
 
 		void init_pubkey()
 		{
-			int i = 0;
-			uint i2, tmp;
-			byte[] keytmp = new byte[256];
-
 			init_bignum(pubkey.key2, 0x10001, 64);
 
-			i2 = 0;
-			while (i < pubkeyStr.Length)
-			{
-				tmp = (uint)char2num[pubkeyStr[i++]];
-				tmp <<= 6; tmp |= (uint)(byte)char2num[pubkeyStr[i++]];
-				tmp <<= 6; tmp |= (uint)(byte)char2num[pubkeyStr[i++]];
-				tmp <<= 6; tmp |= (uint)(byte)char2num[pubkeyStr[i++]];
-				keytmp[i2++] = (byte)((tmp >> 16) & 0xff);
-				keytmp[i2++] = (byte)((tmp >> 8) & 0xff);
-				keytmp[i2++] = (byte)(tmp & 0xff);
-			}
-
-			key_to_bignum(pubkey.key1, keytmp, 64);
+			key_to_bignum(pubkey.key1, Convert.FromBase64String(pubkeyStr), 64);
 			pubkey.len = bitlen_bignum(pubkey.key1, 64) - 1;
 		}
 

OpenRA.FileFormats/FileFormats/CRC32.cs

@@ -0,0 +1,125 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2013 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation. For more information,
+ * see COPYING.
+ */
+#endregion
+
+namespace OpenRA.FileFormats
+{
+
+	/// <summary>
+	/// Static class that uses a lookup table to calculates CRC32
+	/// checksums of input strings.
+	/// </summary>
+	public static class CRC32
+	{
+		/// <summary>
+		/// The CRC32 lookup table
+		/// </summary>
+		static uint[] lookUp = new uint[256]
+		{
+			0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA,
+			0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
+			0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
+			0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
+			0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE,
+			0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
+			0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC,
+			0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
+			0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,
+			0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
+			0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940,
+			0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
+			0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116,
+			0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
+			0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
+			0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
+			0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A,
+			0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
+			0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818,
+			0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
+			0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
+			0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
+			0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C,
+			0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
+			0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2,
+			0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
+			0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,
+			0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
+			0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086,
+			0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
+			0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4,
+			0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
+			0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,
+			0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
+			0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
+			0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
+			0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE,
+			0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
+			0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,
+			0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
+			0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252,
+			0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
+			0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60,
+			0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
+			0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
+			0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
+			0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04,
+			0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
+			0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A,
+			0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
+			0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,
+			0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
+			0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E,
+			0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
+			0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C,
+			0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
+			0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,
+			0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
+			0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0,
+			0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
+			0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6,
+			0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
+			0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
+			0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
+		};
+
+		/// <summary>
+		/// A fast (native) CRC32 implementation that can be used on a regular byte arrays.
+		/// </summary>
+		/// <param name="data">The data from which to calculate the checksum.</param>
+		/// <param name="polynomal">The polynomal.</param>
+		/// <returns>
+		/// The calculated checksum.
+		/// </returns>
+		public static uint Calculate(byte[] data, uint polynomal = 0xFFFFFFFF)
+		{
+			uint crc = polynomal;
+			for (int i = 0; i < data.Length; i++)
+				crc = (crc >> 8) ^ lookUp[(crc & 0xFF) ^ data[i]];
+			crc ^= polynomal;
+			return crc;
+		}
+
+		/// <summary>
+		/// A fast (native) CRC32 implementation that can be used on a pinned byte array using
+		/// default polynomal.
+		/// </summary>
+		/// <param name="data">		[in,out] If non-null, the.</param>
+		/// <param name="len">		The length of the data data.</param>
+		/// <param name="polynomal">The polynomal to xor with.</param>
+		/// <returns>The calculated checksum.</returns>
+		public static unsafe uint Calculate(byte* data, uint len, uint polynomal = 0xFFFFFFFF)
+		{
+			uint crc = polynomal;
+			for (int i = 0; i < len; i++)
+				crc = (crc >> 8) ^ lookUp[(crc & 0xFF) ^ *data++];
+			crc ^= polynomal;
+			return crc;
+		}
+	}
+}

OpenRA.FileFormats/FileFormats/Format80.cs

@@ -45,7 +45,7 @@ namespace OpenRA.FileFormats
 		static void ReplicatePrevious( byte[] dest, int destIndex, int srcIndex, int count )
 		{
 			if( srcIndex > destIndex )
-				throw new NotImplementedException( string.Format( "srcIndex > destIndex  {0}  {1}", srcIndex, destIndex ) );
+				throw new NotImplementedException("srcIndex > destIndex {0} {1}".F(srcIndex, destIndex));
 
 			if( destIndex - srcIndex == 1 )
 			{
@@ -105,7 +105,7 @@ namespace OpenRA.FileFormats
 						int count = ctx.ReadWord();
 						int srcIndex = ctx.ReadWord();
 						if( srcIndex >= destIndex )
-							throw new NotImplementedException( string.Format( "srcIndex >= destIndex  {0}  {1}", srcIndex, destIndex ) );
+							throw new NotImplementedException("srcIndex >= destIndex {0} {1}".F(srcIndex, destIndex));
 
 						for( int end = destIndex + count ; destIndex < end ; destIndex++ )
 							dest[ destIndex ] = dest[ srcIndex++ ];
@@ -116,7 +116,7 @@ namespace OpenRA.FileFormats
 						int count = count3 + 3;
 						int srcIndex = ctx.ReadWord();
 						if( srcIndex >= destIndex )
-							throw new NotImplementedException( string.Format( "srcIndex >= destIndex  {0}  {1}", srcIndex, destIndex ) );
+							throw new NotImplementedException("srcIndex >= destIndex {0} {1}".F(srcIndex, destIndex));
 
 						for( int end = destIndex + count ; destIndex < end ; destIndex++ )
 							dest[ destIndex ] = dest[ srcIndex++ ];

OpenRA.FileFormats/FileFormats/WavLoader.cs

@@ -0,0 +1,75 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2013 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation. For more information,
+ * see COPYING.
+ */
+#endregion
+
+using System;
+using System.IO;
+using System.Text;
+
+namespace OpenRA.FileFormats
+{
+	public class WavLoader
+	{
+		public readonly int FileSize;
+		public readonly string Format;
+
+		public readonly int FmtChunkSize;
+		public readonly int AudioFormat;
+		public readonly int Channels;
+		public readonly int SampleRate;
+		public readonly int ByteRate;
+		public readonly int BlockAlign;
+		public readonly int BitsPerSample;
+
+		public readonly int DataSize;
+		public readonly byte[] RawOutput;
+
+		public WavLoader(Stream s)
+		{
+			while (s.Position < s.Length)
+			{
+				if ((s.Position & 1) == 1)
+					s.ReadByte(); // Alignment
+
+				var type = s.ReadASCII(4);
+				switch (type)
+				{
+					case "RIFF":
+						FileSize = s.ReadInt32();
+						Format = s.ReadASCII(4);
+						if (Format != "WAVE")
+							throw new NotSupportedException("Not a canonical WAVE file.");
+						break;
+					case "fmt ":
+						FmtChunkSize = s.ReadInt32();
+						if (FmtChunkSize != 16)
+							throw new NotSupportedException("{0} fmt chunk size is not a supported encoding scheme.".F(FmtChunkSize));
+						AudioFormat = s.ReadInt16();
+						if (AudioFormat != 1)
+							throw new NotSupportedException("Non-PCM compression is not supported.");
+						Channels = s.ReadInt16();
+						SampleRate = s.ReadInt32();
+						ByteRate = s.ReadInt32();
+						BlockAlign = s.ReadInt16();
+						BitsPerSample = s.ReadInt16();
+						break;
+					case "data":
+						DataSize = s.ReadInt32();
+						RawOutput = s.ReadBytes(DataSize);
+						break;
+					default:
+						// Ignore unknown chunks
+						var chunkSize = s.ReadInt32();
+						s.ReadBytes(chunkSize);
+						break;
+				}
+			}
+		}
+	}
+}

OpenRA.FileFormats/FileFormats/XccGlobalDatabase.cs

@@ -0,0 +1,44 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2013 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation. For more information,
+ * see COPYING.
+ */
+#endregion
+
+using System.Collections.Generic;
+using System.IO;
+
+namespace OpenRA.FileFormats
+{
+	public class XccGlobalDatabase
+	{
+		public readonly string[] Entries;
+		public XccGlobalDatabase(Stream s)
+		{
+			var entries = new List<string>();
+			var reader = new BinaryReader(s);
+			while (reader.PeekChar() > -1)
+			{
+				var count = reader.ReadInt32();
+				for (var i = 0; i < count; i++)
+				{
+					var chars = new List<char>();
+					char c;
+
+					// Read filename
+					while ((c = reader.ReadChar()) != 0)
+						chars.Add(c);
+					entries.Add(new string(chars.ToArray()));
+
+					// Skip comment
+					while ((c = reader.ReadChar()) != 0);
+				}
+			}
+
+			Entries = entries.ToArray();
+		}
+	}
+}

OpenRA.FileFormats/FileFormats/XccLocalDatabase.cs

@@ -0,0 +1,67 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2013 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation. For more information,
+ * see COPYING.
+ */
+#endregion
+
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+
+namespace OpenRA.FileFormats
+{
+	public class XccLocalDatabase
+	{
+		public readonly string[] Entries;
+		public XccLocalDatabase(Stream s)
+		{
+			// Skip unnecessary header data
+			s.Seek(48, SeekOrigin.Begin);
+			var reader = new BinaryReader(s);
+			var count = reader.ReadInt32();
+			Entries = new string[count];
+			for (var i = 0; i < count; i++)
+			{
+				var chars = new List<char>();
+				char c;
+				while ((c = reader.ReadChar()) != 0)
+					chars.Add(c);
+
+				Entries[i] = new string(chars.ToArray());
+			}
+		}
+
+		public XccLocalDatabase(IEnumerable<string> filenames)
+		{
+			Entries = filenames.ToArray();
+		}
+
+		public byte[] Data()
+		{
+			var data = new MemoryStream();
+			using (var writer = new BinaryWriter(data))
+			{
+				writer.Write(Encoding.ASCII.GetBytes("XCC by Olaf van der Spek"));
+				writer.Write(new byte[] {0x1A,0x04,0x17,0x27,0x10,0x19,0x80,0x00});
+
+				writer.Write((int)(Entries.Aggregate(Entries.Length, (a,b) => a + b.Length) + 52)); // Size
+				writer.Write((int)0); // Type
+				writer.Write((int)0); // Version
+				writer.Write((int)0); // Game/Format (0 == TD)
+				writer.Write((int)Entries.Length); // Entries
+				foreach (var e in Entries)
+				{
+					writer.Write(Encoding.ASCII.GetBytes(e));
+					writer.Write((byte)0);
+				}
+			}
+
+			return data.ToArray();
+		}
+	}
+}

OpenRA.FileFormats/Filesystem/D2kSoundResources.cs

@@ -0,0 +1,102 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2013 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation. For more information,
+ * see COPYING.
+ */
+#endregion
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+
+namespace OpenRA.FileFormats
+{
+	public class D2kSoundResources : IFolder
+	{
+		readonly Stream s;
+
+		readonly string filename;
+		readonly List<string> filenames;
+		readonly int priority;
+
+		readonly Dictionary<uint, PackageEntry> index = new Dictionary<uint, PackageEntry>();
+
+		public D2kSoundResources(string filename, int priority)
+		{
+			this.filename = filename;
+			this.priority = priority;
+
+			s = FileSystem.Open(filename);
+			s.Seek(0, SeekOrigin.Begin);
+
+			filenames = new List<string>();
+
+			var headerLength = s.ReadUInt32();
+			while (s.Position < headerLength + 4)
+			{
+				var name = s.ReadASCIIZ();
+				var offset = s.ReadUInt32();
+				var length = s.ReadUInt32();
+
+				var hash = PackageEntry.HashFilename(name, PackageHashType.Classic);
+				if (!index.ContainsKey(hash))
+					index.Add(hash, new PackageEntry(hash, offset, length));
+
+				filenames.Add(name);
+			}
+		}
+
+		public Stream GetContent(uint hash)
+		{
+			PackageEntry e;
+			if (!index.TryGetValue(hash, out e))
+				return null;
+
+			s.Seek(e.Offset, SeekOrigin.Begin);
+			var data = new byte[e.Length];
+			s.Read(data, 0, (int)e.Length);
+
+			return new MemoryStream(data);
+		}
+
+		public Stream GetContent(string filename)
+		{
+			return GetContent(PackageEntry.HashFilename(filename, PackageHashType.Classic));
+		}
+
+		public bool Exists(string filename)
+		{
+			return index.ContainsKey(PackageEntry.HashFilename(filename, PackageHashType.Classic));
+		}
+
+		public IEnumerable<string> AllFileNames()
+		{
+			return filenames;
+		}
+
+		public string Name { get { return filename; } }
+
+		public int Priority { get { return 1000 + priority; }}
+
+		public IEnumerable<uint> ClassicHashes()
+		{
+			return index.Keys;
+		}
+
+		public IEnumerable<uint> CrcHashes()
+		{
+			yield break;
+		}
+
+		public void Write(Dictionary<string, byte[]> contents)
+		{
+			throw new NotImplementedException("Cannot save Dune 2000 Sound Resources.");
+		}
+	}
+}

OpenRA.FileFormats/Filesystem/FileSystem.cs

@@ -18,29 +18,33 @@ namespace OpenRA.FileFormats
 {
 	public static class FileSystem
 	{
-		static List<IFolder> mountedFolders = new List<IFolder>();
+		public static List<IFolder> MountedFolders = new List<IFolder>();
+		static Cache<uint, List<IFolder>> classicHashIndex = new Cache<uint, List<IFolder>>( _ => new List<IFolder>() );
+		static Cache<uint, List<IFolder>> crcHashIndex = new Cache<uint, List<IFolder>>( _ => new List<IFolder>() );
 
-		static Cache<uint, List<IFolder>> allFiles = new Cache<uint, List<IFolder>>( _ => new List<IFolder>() );
+		public static List<string> FolderPaths = new List<string>();
 
 		static void MountInner(IFolder folder)
 		{
-			mountedFolders.Add(folder);
+			MountedFolders.Add(folder);
 
-			foreach( var hash in folder.AllFileHashes() )
+			foreach (var hash in folder.ClassicHashes())
 			{
-				var l = allFiles[hash];
-				if( !l.Contains( folder ) )
-					l.Add( folder );
+				var l = classicHashIndex[hash];
+				if (!l.Contains(folder))
+					l.Add(folder);
+			}
+
+			foreach (var hash in folder.CrcHashes())
+			{
+				var l = crcHashIndex[hash];
+				if (!l.Contains(folder))
+					l.Add(folder);
 			}
 		}
 
 		static int order = 0;
 
-		static IFolder OpenPackage(string filename)
-		{
-			return OpenPackage(filename, order++);
-		}
-
 		public static IFolder CreatePackage(string filename, int order, Dictionary<string, byte[]> content)
 		{
 			if (filename.EndsWith(".mix", StringComparison.InvariantCultureIgnoreCase))
@@ -49,20 +53,28 @@ namespace OpenRA.FileFormats
 				return new ZipFile(filename, order, content);
 			else if (filename.EndsWith(".oramap", StringComparison.InvariantCultureIgnoreCase))
 				return new ZipFile(filename, order, content);
+			else if (filename.EndsWith(".RS", StringComparison.InvariantCultureIgnoreCase))
+				throw new NotImplementedException("Creating .RS archives is unsupported");
 			else if (filename.EndsWith(".Z", StringComparison.InvariantCultureIgnoreCase))
 				throw new NotImplementedException("Creating .Z archives is unsupported");
 			else
 				return new Folder(filename, order, content);
 		}
 
-		public static IFolder OpenPackage(string filename, int order)
+		public static IFolder OpenPackage(string filename, string annotation, int order)
 		{
 			if (filename.EndsWith(".mix", StringComparison.InvariantCultureIgnoreCase))
-				return new MixFile(filename, order);
+			{
+				var type = string.IsNullOrEmpty(annotation) ? PackageHashType.Classic :
+					FieldLoader.GetValue<PackageHashType>("(value)", annotation);
+				return new MixFile(filename, type, order);
+			}
 			else if (filename.EndsWith(".zip", StringComparison.InvariantCultureIgnoreCase))
 				return new ZipFile(filename, order);
 			else if (filename.EndsWith(".oramap", StringComparison.InvariantCultureIgnoreCase))
 				return new ZipFile(filename, order);
+			else if (filename.EndsWith(".RS", StringComparison.InvariantCultureIgnoreCase))
+				return new D2kSoundResources(filename, order);
 			else if (filename.EndsWith(".Z", StringComparison.InvariantCultureIgnoreCase))
 				return new InstallShieldPackage(filename, order);
 			else
@@ -70,6 +82,11 @@ namespace OpenRA.FileFormats
 		}
 
 		public static void Mount(string name)
+		{
+			Mount(name, null);
+		}
+
+		public static void Mount(string name, string annotation)
 		{
 			var optional = name.StartsWith("~");
 			if (optional) name = name.Substring(1);
@@ -78,7 +95,8 @@ namespace OpenRA.FileFormats
 			if (name.StartsWith("^"))
 				name = Platform.SupportDir+name.Substring(1);
 
-			var a = (Action)(() => FileSystem.MountInner(OpenPackage(name)));
+			FolderPaths.Add(name);
+			Action a = () => FileSystem.MountInner(OpenPackage(name, annotation, order++));
 
 			if (optional)
 				try { a(); }
@@ -89,30 +107,36 @@ namespace OpenRA.FileFormats
 
 		public static void UnmountAll()
 		{
-			mountedFolders.Clear();
-			allFiles = new Cache<uint, List<IFolder>>( _ => new List<IFolder>() );
+			MountedFolders.Clear();
+			FolderPaths.Clear();
+			classicHashIndex = new Cache<uint, List<IFolder>>(_ => new List<IFolder>());
+			crcHashIndex = new Cache<uint, List<IFolder>>(_ => new List<IFolder>());
 		}
 
 		public static bool Unmount(IFolder mount)
 		{
-			return (mountedFolders.RemoveAll(f => f == mount) > 0);
+			return (MountedFolders.RemoveAll(f => f == mount) > 0);
 		}
 
 		public static void Mount(IFolder mount)
 		{
-			if (!mountedFolders.Contains(mount)) mountedFolders.Add(mount);
+			if (!MountedFolders.Contains(mount)) MountedFolders.Add(mount);
 		}
 
-		public static void LoadFromManifest( Manifest manifest )
+		public static void LoadFromManifest(Manifest manifest)
 		{
 			UnmountAll();
-			foreach (var dir in manifest.Folders) Mount(dir);
-			foreach (var pkg in manifest.Packages) Mount(pkg);
+			foreach (var dir in manifest.Folders)
+				Mount(dir);
+
+			foreach (var pkg in manifest.Packages)
+				Mount(pkg.Key, pkg.Value);
 		}
 
-		static Stream GetFromCache( Cache<uint, List<IFolder>> index, string filename )
+		static Stream GetFromCache(PackageHashType type, string filename)
 		{
-			var folder = index[PackageEntry.HashFilename(filename)]
+			var index = type == PackageHashType.CRC32 ? crcHashIndex : classicHashIndex;
+			var folder = index[PackageEntry.HashFilename(filename, type)]
 				.Where(x => x.Exists(filename))
 				.OrderBy(x => x.Priority)
 				.FirstOrDefault();
@@ -123,76 +147,59 @@ namespace OpenRA.FileFormats
 			return null;
 		}
 
-		public static Stream Open(string filename)
+		public static Stream Open(string filename) { return OpenWithExts(filename, ""); }
+
+		public static Stream OpenWithExts(string filename, params string[] exts)
 		{
-			if( filename.IndexOfAny( new char[] { '/', '\\' } ) == -1 )
+			if (filename.IndexOfAny(new char[] { '/', '\\' } ) == -1)
 			{
-				var ret = GetFromCache( allFiles, filename );
-				if( ret != null )
-					return ret;
-			}
-
-			var folder = mountedFolders
-				.Where(x => x.Exists(filename))
-				.OrderByDescending(x => x.Priority)
-				.FirstOrDefault();
-
-			if (folder != null)
-				return folder.GetContent(filename);
-
-			throw new FileNotFoundException( string.Format( "File not found: {0}", filename ), filename );
-		}
-
-		public static Stream OpenWithExts( string filename, params string[] exts )
-		{
-			if( filename.IndexOfAny( new char[] { '/', '\\' } ) == -1 )
-			{
-				foreach( var ext in exts )
+				foreach (var ext in exts)
 				{
-					var s = GetFromCache( allFiles, filename + ext );
-					if( s != null )
+					var s = GetFromCache(PackageHashType.Classic, filename + ext);
+					if (s != null)
+						return s;
+
+					s = GetFromCache(PackageHashType.CRC32, filename + ext);
+					if (s != null)
 						return s;
 				}
 			}
 
-			foreach( var ext in exts )
+			foreach (var ext in exts)
 			{
-				foreach( IFolder folder in mountedFolders )
-					if (folder.Exists(filename + ext))
-						return folder.GetContent( filename + ext );
+				var folder = MountedFolders
+					.Where(x => x.Exists(filename + ext))
+					.OrderByDescending(x => x.Priority)
+					.FirstOrDefault();
+
+				if (folder != null)
+					return folder.GetContent(filename + ext);
 			}
 
-			throw new FileNotFoundException( string.Format( "File not found: {0}", filename ), filename );
+			throw new FileNotFoundException("File not found: {0}".F(filename), filename);
 		}
 
-		public static bool Exists(string filename)
-		{
-			foreach (var folder in mountedFolders)
-				if (folder.Exists(filename))
-					return true;
-			return false;
-		}
+		public static bool Exists(string filename) { return MountedFolders.Any(f => f.Exists(filename)); }
 
 		static Dictionary<string, Assembly> assemblyCache = new Dictionary<string, Assembly>();
 
 		public static Assembly ResolveAssembly(object sender, ResolveEventArgs e)
 		{
 			foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
-			{
 				if (assembly.FullName == e.Name)
 					return assembly;
-			}
 
-			string[] frags = e.Name.Split(',');
+			var frags = e.Name.Split(',');
 			var filename = frags[0] + ".dll";
+
 			Assembly a;
 			if (assemblyCache.TryGetValue(filename, out a))
 				return a;
 
 			if (FileSystem.Exists(filename))
-				using (Stream s = FileSystem.Open(filename))
+				using (var s = FileSystem.Open(filename))
 				{
-					byte[] buf = new byte[s.Length];
+					var buf = new byte[s.Length];
 					s.Read(buf, 0, buf.Length);
 					a = Assembly.Load(buf);
 					assemblyCache.Add(filename, a);

OpenRA.FileFormats/Filesystem/Folder.cs

@@ -17,8 +17,7 @@ namespace OpenRA.FileFormats
 	public class Folder : IFolder
 	{
 		readonly string path;
-
-		int priority;
+		readonly int priority;
 
 		// Create a new folder package
 		public Folder(string path, int priority, Dictionary<string, byte[]> contents)
@@ -45,22 +44,30 @@ namespace OpenRA.FileFormats
 			catch { return null; }
 		}
 
-		public IEnumerable<uint> AllFileHashes()
+		public IEnumerable<uint> ClassicHashes()
 		{
-			foreach( var filename in Directory.GetFiles( path, "*", SearchOption.TopDirectoryOnly ) )
-				yield return PackageEntry.HashFilename( Path.GetFileName(filename) );
+			foreach (var filename in Directory.GetFiles(path, "*", SearchOption.TopDirectoryOnly))
+				yield return PackageEntry.HashFilename(Path.GetFileName(filename), PackageHashType.Classic);
+		}
+
+		public IEnumerable<uint> CrcHashes()
+		{
+			yield break;
+		}
+
+		public IEnumerable<string> AllFileNames()
+		{
+			foreach (var filename in Directory.GetFiles(path, "*", SearchOption.TopDirectoryOnly))
+				yield return Path.GetFileName(filename);
 		}
 
 		public bool Exists(string filename)
 		{
-			return File.Exists(Path.Combine(path,filename));
+			return File.Exists(Path.Combine(path, filename));
 		}
 
-
-		public int Priority
-		{
-			get { return priority; }
-		}
+		public int Priority { get { return priority; } }
+		public string Name { get { return path; } }
 
 		public void Write(Dictionary<string, byte[]> contents)
 		{

OpenRA.FileFormats/Filesystem/InstallShieldPackage.cs

@@ -18,13 +18,17 @@ namespace OpenRA.FileFormats
 	public class InstallShieldPackage : IFolder
 	{
 		readonly Dictionary<uint, PackageEntry> index = new Dictionary<uint, PackageEntry>();
+		readonly List<string> filenames;
 		readonly Stream s;
 		readonly long dataStart = 255;
-		int priority;
+		readonly int priority;
+		readonly string filename;
 
 		public InstallShieldPackage(string filename, int priority)
 		{
+			this.filename = filename;
 			this.priority = priority;
+			filenames = new List<string>();
 			s = FileSystem.Open(filename);
 
 			// Parse package header
@@ -45,11 +49,20 @@ namespace OpenRA.FileFormats
 			// Parse the directory list
 			s.Seek(TOCAddress, SeekOrigin.Begin);
 			BinaryReader TOCreader = new BinaryReader(s);
+
+			var fileCountInDirs = new List<uint>();
+			// Parse directories
 			for (var i = 0; i < DirCount; i++)
-				ParseDirectory(TOCreader);
+				fileCountInDirs.Add(ParseDirectory(TOCreader));
+
+			// Parse files
+			foreach (var fileCount in fileCountInDirs)
+				for (var i = 0; i < fileCount; i++)
+					ParseFile(reader);
+
 		}
 
-		void ParseDirectory(BinaryReader reader)
+		uint ParseDirectory(BinaryReader reader)
 		{
 			// Parse directory header
 			var FileCount = reader.ReadUInt16();
@@ -59,10 +72,7 @@ namespace OpenRA.FileFormats
 
 			// Skip to the end of the chunk
 			reader.ReadBytes(ChunkSize - NameLength - 6);
-
-			// Parse files
-			for (var i = 0; i < FileCount; i++)
-				ParseFile(reader);
+			return FileCount;
 		}
 
 		uint AccumulatedData = 0;
@@ -76,8 +86,10 @@ namespace OpenRA.FileFormats
 			var NameLength = reader.ReadByte();
 			var FileName = new String(reader.ReadChars(NameLength));
 
-			var hash = PackageEntry.HashFilename(FileName);
-			index.Add(hash, new PackageEntry(hash,AccumulatedData, CompressedSize));
+			var hash = PackageEntry.HashFilename(FileName, PackageHashType.Classic);
+			if (!index.ContainsKey(hash))
+				index.Add(hash, new PackageEntry(hash,AccumulatedData, CompressedSize));
+			filenames.Add(FileName);
 			AccumulatedData += CompressedSize;
 
 			// Skip to the end of the chunk
@@ -90,33 +102,40 @@ namespace OpenRA.FileFormats
 			if (!index.TryGetValue(hash, out e))
 				return null;
 
-			s.Seek( dataStart + e.Offset, SeekOrigin.Begin );
-			byte[] data = new byte[ e.Length ];
-			s.Read( data, 0, (int)e.Length );
+			s.Seek(dataStart + e.Offset, SeekOrigin.Begin);
+			var data = new byte[e.Length];
+			s.Read(data, 0, (int)e.Length);
 
 			return new MemoryStream(Blast.Decompress(data));
 		}
 
 		public Stream GetContent(string filename)
 		{
-			return GetContent(PackageEntry.HashFilename(filename));
+			return GetContent(PackageEntry.HashFilename(filename, PackageHashType.Classic));
 		}
 
-		public IEnumerable<uint> AllFileHashes()
+		public IEnumerable<uint> ClassicHashes()
 		{
 			return index.Keys;
 		}
 
+		public IEnumerable<uint> CrcHashes()
+		{
+			yield break;
+		}
+
+		public IEnumerable<string> AllFileNames()
+		{
+			return filenames;
+		}
+
 		public bool Exists(string filename)
 		{
-			return index.ContainsKey(PackageEntry.HashFilename(filename));
+			return index.ContainsKey(PackageEntry.HashFilename(filename, PackageHashType.Classic));
 		}
 
-
-		public int Priority
-		{
-			get { return 2000 + priority; }
-		}
+		public int Priority { get { return 2000 + priority; }}
+		public string Name { get { return filename; } }
 
 		public void Write(Dictionary<string, byte[]> contents)
 		{

OpenRA.FileFormats/Filesystem/MixFile.cs

@@ -1,6 +1,6 @@
 #region Copyright & License Information
 /*
- * Copyright 2007-2011 The OpenRA Developers (see AUTHORS)
+ * Copyright 2007-2013 The OpenRA Developers (see AUTHORS)
  * This file is part of OpenRA, which is free software. It is made
  * available to you under the terms of the GNU General Public License
  * as published by the Free Software Foundation. For more information,
@@ -10,6 +10,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.IO;
 using System.Linq;
 
@@ -19,123 +20,145 @@ namespace OpenRA.FileFormats
 	{
 		Stream GetContent(string filename);
 		bool Exists(string filename);
-		IEnumerable<uint> AllFileHashes();
+		IEnumerable<uint> ClassicHashes();
+		IEnumerable<uint> CrcHashes();
+		IEnumerable<string> AllFileNames();
 		void Write(Dictionary<string, byte[]> contents);
 		int Priority { get; }
+		string Name { get; }
 	}
 
 	public class MixFile : IFolder
 	{
 		readonly Dictionary<uint, PackageEntry> index;
-		readonly bool isRmix, isEncrypted;
 		readonly long dataStart;
 		readonly Stream s;
-		int priority;
+		readonly int priority;
+		readonly string filename;
+		readonly PackageHashType type;
 
-		// Create a new MixFile
+		// Save a mix to disk with the given contents
 		public MixFile(string filename, int priority, Dictionary<string, byte[]> contents)
 		{
+			this.filename = filename;
 			this.priority = priority;
+			this.type = PackageHashType.Classic;
+
 			if (File.Exists(filename))
 				File.Delete(filename);
 
 			s = File.Create(filename);
+			index = new Dictionary<uint, PackageEntry>();
+			contents.Add("local mix database.dat", new XccLocalDatabase(contents.Keys.Append("local mix database.dat")).Data());
 			Write(contents);
 		}
 
-		public MixFile(string filename, int priority)
+		public MixFile(string filename, PackageHashType type, int priority)
 		{
+			this.filename = filename;
 			this.priority = priority;
+			this.type = type;
 			s = FileSystem.Open(filename);
 
-			BinaryReader reader = new BinaryReader(s);
-			uint signature = reader.ReadUInt32();
+			// Detect format type
+			s.Seek(0, SeekOrigin.Begin);
+			var isCncMix = s.ReadUInt16() != 0;
 
-			isRmix = 0 == (signature & ~(uint)(MixFileFlags.Checksum | MixFileFlags.Encrypted));
+			// The C&C mix format doesn't contain any flags or encryption
+			var isEncrypted = false;
+			if (!isCncMix)
+				isEncrypted = (s.ReadUInt16() & 0x2) != 0;
 
-			if (isRmix)
+			List<PackageEntry> entries;
+			if (isEncrypted)
 			{
-				isEncrypted = 0 != (signature & (uint)MixFileFlags.Encrypted);
-				if( isEncrypted )
-				{
-					index = ParseRaHeader( s, out dataStart ).ToDictionary(x => x.Hash);
-					return;
-				}
+				long unused;
+				entries = ParseHeader(DecryptHeader(s, 4, out dataStart), 0, out unused);
 			}
 			else
-				s.Seek( 0, SeekOrigin.Begin );
+				entries = ParseHeader(s, isCncMix ? 0 : 4, out dataStart);
 
-			isEncrypted = false;
-			index = ParseTdHeader(s, out dataStart).ToDictionary(x => x.Hash);
+			index = entries.ToDictionaryWithConflictLog(x => x.Hash,
+				"{0} ({1} format, Encrypted: {2}, DataStart: {3})".F(filename, (isCncMix ? "C&C" : "RA/TS/RA2"), isEncrypted, dataStart),
+			    null, x => "(offs={0}, len={1})".F(x.Offset, x.Length)
+			);
 		}
 
-		const long headerStart = 84;
-
-		List<PackageEntry> ParseRaHeader(Stream s, out long dataStart)
+		List<PackageEntry> ParseHeader(Stream s, long offset, out long headerEnd)
 		{
-			BinaryReader reader = new BinaryReader(s);
-			byte[] keyblock = reader.ReadBytes(80);
-			byte[] blowfishKey = new BlowfishKeyProvider().DecryptKey(keyblock);
+			s.Seek(offset, SeekOrigin.Begin);
+			var numFiles = s.ReadUInt16();
+			/*uint dataSize = */s.ReadUInt32();
 
-			uint[] h = ReadUints(reader, 2);
+			var items = new List<PackageEntry>();
+			for (var i = 0; i < numFiles; i++)
+				items.Add(new PackageEntry(s));
 
-			Blowfish fish = new Blowfish(blowfishKey);
-			MemoryStream ms = Decrypt( h, fish );
-			BinaryReader reader2 = new BinaryReader(ms);
-
-			ushort numFiles = reader2.ReadUInt16();
-			reader2.ReadUInt32(); /*datasize*/
-
-			s.Position = headerStart;
-			reader = new BinaryReader(s);
-
-			int byteCount = 6 + numFiles * PackageEntry.Size;
-			h = ReadUints( reader, ( byteCount + 3 ) / 4 );
-
-			ms = Decrypt( h, fish );
-
-			dataStart = headerStart + byteCount + ( ( ~byteCount + 1 ) & 7 );
-
-			long ds;
-			return ParseTdHeader( ms, out ds );
+			headerEnd = offset + 6 + numFiles*PackageEntry.Size;
+			return items;
 		}
 
-		static MemoryStream Decrypt( uint[] h, Blowfish fish )
+		MemoryStream DecryptHeader(Stream s, long offset, out long headerEnd)
 		{
-			uint[] decrypted = fish.Decrypt( h );
+			s.Seek(offset, SeekOrigin.Begin);
 
-			MemoryStream ms = new MemoryStream();
-			BinaryWriter writer = new BinaryWriter( ms );
-			foreach( uint t in decrypted )
-				writer.Write( t );
+			// Decrypt blowfish key
+			var keyblock = s.ReadBytes(80);
+			var blowfishKey = new BlowfishKeyProvider().DecryptKey(keyblock);
+			var fish = new Blowfish(blowfishKey);
+
+			// Decrypt first block to work out the header length
+			var ms = Decrypt(ReadBlocks(s, offset + 80, 1), fish);
+			var numFiles = ms.ReadUInt16();
+
+			// Decrypt the full header - round bytes up to a full block
+			var blockCount = (13 + numFiles*PackageEntry.Size)/8;
+			headerEnd = offset + 80 + blockCount*8;
+
+			return Decrypt(ReadBlocks(s, offset + 80, blockCount), fish);
+		}
+
+		static MemoryStream Decrypt(uint[] h, Blowfish fish)
+		{
+			var decrypted = fish.Decrypt(h);
+
+			var ms = new MemoryStream();
+			var writer = new BinaryWriter(ms);
+			foreach(var t in decrypted)
+				writer.Write(t);
 			writer.Flush();
 
-			ms.Position = 0;
+			ms.Seek(0, SeekOrigin.Begin);
 			return ms;
 		}
 
-		uint[] ReadUints(BinaryReader r, int count)
+		uint[] ReadBlocks(Stream s, long offset, int count)
 		{
-			uint[] ret = new uint[count];
-			for (int i = 0; i < ret.Length; i++)
-				ret[i] = r.ReadUInt32();
+			s.Seek(offset, SeekOrigin.Begin);
+
+			// A block is a single encryption unit (represented as two 32-bit integers)
+			var ret = new uint[2*count];
+			for (var i = 0; i < ret.Length; i++)
+				ret[i] = s.ReadUInt32();
 
 			return ret;
 		}
 
-		List<PackageEntry> ParseTdHeader(Stream s, out long dataStart)
+		uint? FindMatchingHash(string filename)
 		{
-			List<PackageEntry> items = new List<PackageEntry>();
+			var hash = PackageEntry.HashFilename(filename, type);
+			if (index.ContainsKey(hash))
+				return hash;
 
-			BinaryReader reader = new BinaryReader(s);
-			ushort numFiles = reader.ReadUInt16();
-			/*uint dataSize = */reader.ReadUInt32();
+			// Maybe we were given a raw hash?
+			uint raw;
+			if (!uint.TryParse(filename, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out raw))
+			    return null;
 
-			for (int i = 0; i < numFiles; i++)
-				items.Add(new PackageEntry(reader));
+			if ("{0:X}".F(raw) == filename && index.ContainsKey(raw))
+				return raw;
 
-			dataStart = s.Position;
-			return items;
+			return null;
 		}
 
 		public Stream GetContent(uint hash)
@@ -144,33 +167,71 @@ namespace OpenRA.FileFormats
 			if (!index.TryGetValue(hash, out e))
 				return null;
 
-			s.Seek( dataStart + e.Offset, SeekOrigin.Begin );
-			byte[] data = new byte[ e.Length ];
-			s.Read( data, 0, (int)e.Length );
+			s.Seek(dataStart + e.Offset, SeekOrigin.Begin);
+			var data = new byte[e.Length];
+			s.Read(data, 0, (int)e.Length);
 			return new MemoryStream(data);
 		}
 
 		public Stream GetContent(string filename)
 		{
-			return GetContent(PackageEntry.HashFilename(filename));
+			var hash = FindMatchingHash(filename);
+			return hash.HasValue ? GetContent(hash.Value) : null;
 		}
 
-		public IEnumerable<uint> AllFileHashes()
+		static readonly uint[] Nothing = {};
+		public IEnumerable<uint> ClassicHashes()
 		{
-			return index.Keys;
+			if (type == PackageHashType.Classic)
+				return index.Keys;
+
+			return Nothing;
+		}
+
+		public IEnumerable<uint> CrcHashes()
+		{
+			if (type == PackageHashType.CRC32)
+				return index.Keys;
+
+			return Nothing;
+		}
+
+		public IEnumerable<string> AllFileNames()
+		{
+			var lookup = new Dictionary<uint, string>();
+			if (Exists("local mix database.dat"))
+			{
+				var db = new XccLocalDatabase(GetContent("local mix database.dat"));
+				foreach (var e in db.Entries)
+				{
+					var hash = PackageEntry.HashFilename(e, type);
+					if (!lookup.ContainsKey(hash))
+						lookup.Add(hash, e);
+				}
+			}
+
+			if (FileSystem.Exists("global mix database.dat"))
+			{
+				var db = new XccGlobalDatabase(FileSystem.Open("global mix database.dat"));
+				foreach (var e in db.Entries)
+				{
+					var hash = PackageEntry.HashFilename(e, type);
+					if (!lookup.ContainsKey(hash))
+						lookup.Add(hash, e);
+				}
+			}
+
+			return index.Keys.Select(k => lookup.ContainsKey(k) ? lookup[k] : "{0:X}".F(k));
 		}
 
 		public bool Exists(string filename)
 		{
-			return index.ContainsKey(PackageEntry.HashFilename(filename));
-		}
-
-
-		public int Priority
-		{
-			get { return 1000 + priority; }
+			return FindMatchingHash(filename).HasValue;
 		}
 
+		public int Priority { get { return 1000 + priority; } }
+		public string Name { get { return filename; } }
+		
 		public void Write(Dictionary<string, byte[]> contents)
 		{
 			// Cannot modify existing mixfile - rename existing file and
@@ -186,14 +247,14 @@ namespace OpenRA.FileFormats
 			var items = new List<PackageEntry>();
 			foreach (var kv in contents)
 			{
-				uint length = (uint)kv.Value.Length;
-				uint hash = PackageEntry.HashFilename(Path.GetFileName(kv.Key));
+				var length = (uint)kv.Value.Length;
+				var hash = PackageEntry.HashFilename(Path.GetFileName(kv.Key), type);
 				items.Add(new PackageEntry(hash, dataSize, length));
 				dataSize += length;
 			}
 
 			// Write the new file
-			s.Seek(0,SeekOrigin.Begin);
+			s.Seek(0, SeekOrigin.Begin);
 			using (var writer = new BinaryWriter(s))
 			{
 				// Write file header
@@ -210,11 +271,4 @@ namespace OpenRA.FileFormats
 			}
 		}
 	}
-
-	[Flags]
-	enum MixFileFlags : uint
-	{
-		Checksum = 0x10000,
-		Encrypted = 0x20000,
-	}
 }

OpenRA.FileFormats/Filesystem/ZipFile.cs

@@ -51,7 +51,6 @@ namespace OpenRA.FileFormats
 
 		public Stream GetContent(string filename)
 		{
-
 			using (var z = pkg.GetInputStream(pkg.GetEntry(filename)))
 			{
 				var ms = new MemoryStream();
@@ -65,10 +64,21 @@ namespace OpenRA.FileFormats
 			}
 		}
 
-		public IEnumerable<uint> AllFileHashes()
+		public IEnumerable<uint> ClassicHashes()
 		{
 			foreach(ZipEntry entry in pkg)
-				yield return PackageEntry.HashFilename(entry.Name);
+				yield return PackageEntry.HashFilename(entry.Name, PackageHashType.Classic);
+		}
+
+		public IEnumerable<uint> CrcHashes()
+		{
+			yield break;
+		}
+
+		public IEnumerable<string> AllFileNames()
+		{
+			foreach(ZipEntry entry in pkg)
+				yield return entry.Name;
 		}
 
 		public bool Exists(string filename)
@@ -76,10 +86,8 @@ namespace OpenRA.FileFormats
 			return pkg.GetEntry(filename) != null;
 		}
 
-		public int Priority
-		{
-			get { return 500 + priority; }
-		}
+		public int Priority { get { return 500 + priority; } }
+		public string Name { get { return filename; } }
 
 		public void Write(Dictionary<string, byte[]> contents)
 		{

OpenRA.FileFormats/Graphics/Dune2ShpReader.cs

@@ -36,23 +36,23 @@ namespace OpenRA.FileFormats
 		public readonly byte[] LookupTable;
 		public byte[] Image;
 
-		public Dune2ImageHeader(BinaryReader reader)
+		public Dune2ImageHeader(Stream s)
 		{
-			Flags = (Dune2ImageFlags)reader.ReadUInt16();
-			Slices = reader.ReadByte();
-			Width = reader.ReadUInt16();
-			Height = reader.ReadByte();
-			FileSize = reader.ReadUInt16();
-			DataSize = reader.ReadUInt16();
+			Flags = (Dune2ImageFlags)s.ReadUInt16();
+			Slices = s.ReadUInt8();
+			Width = s.ReadUInt16();
+			Height = s.ReadUInt8();
+			FileSize = s.ReadUInt16();
+			DataSize = s.ReadUInt16();
 
 			if (Flags == Dune2ImageFlags.L16_F80_F2_1 ||
 				Flags == Dune2ImageFlags.L16_F80_F2_2 ||
 				Flags == Dune2ImageFlags.Ln_F80_F2)
 			{
-				int n = Flags == Dune2ImageFlags.Ln_F80_F2 ? reader.ReadByte() : (byte)16;
+				int n = Flags == Dune2ImageFlags.Ln_F80_F2 ? s.ReadUInt8() : (byte)16;
 				LookupTable = new byte[n];
 				for (int i = 0; i < n; i++)
-					LookupTable[i] = reader.ReadByte();
+					LookupTable[i] = s.ReadUInt8();
 			}
 			else
 			{
@@ -78,16 +78,14 @@ namespace OpenRA.FileFormats
 
 		List<Dune2ImageHeader> headers = new List<Dune2ImageHeader>();
 
-		public Dune2ShpReader(Stream stream)
+		public Dune2ShpReader(Stream s)
 		{
-			BinaryReader reader = new BinaryReader(stream);
-
-			ImageCount = reader.ReadUInt16();
+			ImageCount = s.ReadUInt16();
 
 			//Last offset is pointer to end of file.
 			uint[] offsets = new uint[ImageCount + 1];
 
-			uint temp = reader.ReadUInt32();
+			uint temp = s.ReadUInt32();
 
 			//If fourth byte in file is non-zero, the offsets are two bytes each.
 			bool twoByteOffsets = (temp & 0xFF0000) > 0;
@@ -100,13 +98,13 @@ namespace OpenRA.FileFormats
 				offsets[0] = temp + 2;
 
 			for (int i = twoByteOffsets ? 2 : 1; i < ImageCount + 1; i++)
-				offsets[i] = (twoByteOffsets ? reader.ReadUInt16() : reader.ReadUInt32()) + 2;
+				offsets[i] = (twoByteOffsets ? s.ReadUInt16() : s.ReadUInt32()) + 2;
 
 			for (int i = 0; i < ImageCount; i++)
 			{
-				reader.BaseStream.Seek(offsets[i], SeekOrigin.Begin);
-				Dune2ImageHeader header = new Dune2ImageHeader(reader);
-				byte[] imgData = reader.ReadBytes(header.FileSize);
+				s.Seek(offsets[i], SeekOrigin.Begin);
+				Dune2ImageHeader header = new Dune2ImageHeader(s);
+				byte[] imgData = s.ReadBytes(header.FileSize);
 				header.Image = new byte[header.Height * header.Width];
 
 				//Decode image data

OpenRA.FileFormats/Graphics/HvaReader.cs

@@ -0,0 +1,57 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2013 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation. For more information,
+ * see COPYING.
+ */
+
+#endregion
+
+using System;
+using System.IO;
+using System.Linq;
+
+namespace OpenRA.FileFormats
+{
+	public class HvaReader
+	{
+		public readonly uint FrameCount;
+		public readonly uint LimbCount;
+		public readonly float[] Transforms;
+
+		public HvaReader(Stream s)
+		{
+			// Index swaps for transposing a matrix
+			var ids = new byte[]{0,4,8,12,1,5,9,13,2,6,10,14};
+
+			s.Seek(16, SeekOrigin.Begin);
+			FrameCount = s.ReadUInt32();
+			LimbCount = s.ReadUInt32();
+
+			// Skip limb names
+			s.Seek(16*LimbCount, SeekOrigin.Current);
+			Transforms = new float[16*FrameCount*LimbCount];
+			for (var j = 0; j < FrameCount; j++)
+				for (var i = 0; i < LimbCount; i++)
+			{
+				// Convert to column-major matrices and add the final matrix row
+				var c = 16*(LimbCount*j + i);
+				Transforms[c + 3] = 0;
+				Transforms[c + 7] = 0;
+				Transforms[c + 11] = 0;
+				Transforms[c + 15] = 1;
+
+				for (var k = 0; k < 12; k++)
+					Transforms[c + ids[k]] = s.ReadFloat();
+			}
+		}
+
+		public static HvaReader Load(string filename)
+		{
+			using (var s = File.OpenRead(filename))
+				return new HvaReader(s);
+		}
+	}
+}

OpenRA.FileFormats/Graphics/IGraphicsDevice.cs

@@ -37,10 +37,10 @@ namespace OpenRA.FileFormats.Graphics
 		IVertexBuffer<Vertex> CreateVertexBuffer( int length );
 		ITexture CreateTexture( Bitmap bitmap );
 		ITexture CreateTexture();
+		IFrameBuffer CreateFrameBuffer(Size s);
 		IShader CreateShader( string name );
 
 		Size WindowSize { get; }
-		int GpuMemoryUsed { get; }
 
 		void Clear();
 		void Present();
@@ -51,6 +51,12 @@ namespace OpenRA.FileFormats.Graphics
 		void SetLineWidth( float width );
 		void EnableScissor( int left, int top, int width, int height );
 		void DisableScissor();
+
+		void EnableDepthBuffer();
+		void DisableDepthBuffer();
+
+		void EnableAlphaBlending();
+		void DisableAlphaBlending();
 	}
 
 	public interface IVertexBuffer<T>
@@ -61,9 +67,12 @@ namespace OpenRA.FileFormats.Graphics
 
 	public interface IShader
 	{
-		void SetValue( string name, float x, float y );
-		void SetValue( string param, ITexture texture );
-		void Render( Action a );
+		void SetVec(string name, float x);
+		void SetVec(string name, float x, float y);
+		void SetVec(string name, float[] vec, int length);
+		void SetTexture(string param, ITexture texture);
+		void SetMatrix(string param, float[] mtx);
+		void Render(Action a);
 	}
 
 	public interface ITexture
@@ -71,6 +80,15 @@ namespace OpenRA.FileFormats.Graphics
 		void SetData(Bitmap bitmap);
 		void SetData(uint[,] colors);
 		void SetData(byte[] colors, int width, int height);
+		byte[] GetData();
+		Size Size { get; }
+	}
+
+	public interface IFrameBuffer
+	{
+		void Bind();
+		void Unbind();
+		ITexture Texture { get; }
 	}
 
 	public enum PrimitiveType

OpenRA.FileFormats/Graphics/PngLoader.cs

@@ -97,7 +97,7 @@ namespace OpenRA.FileFormats.Graphics
 
 							case "IEND":
 								{
-									var bits = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height),
+									var bits = bitmap.LockBits(bitmap.Bounds(),
 										ImageLockMode.WriteOnly, PixelFormat.Format8bppIndexed);
 
 									using (var ns = new MemoryStream(data.ToArray()))

OpenRA.FileFormats/Graphics/ShpReader.cs

@@ -8,10 +8,10 @@
  */
 #endregion
 
-using System.Collections;
 using System.Collections.Generic;
 using System.Drawing;
 using System.IO;
+using System.Linq;
 
 namespace OpenRA.FileFormats
 {
@@ -30,9 +30,9 @@ namespace OpenRA.FileFormats
 
 		public ImageHeader( BinaryReader reader )
 		{
-			Offset = reader.ReadUInt32();
-			Format = (Format)( Offset >> 24 );
-			Offset &= 0xFFFFFF;
+			var data = reader.ReadUInt32();
+			Offset = data & 0xffffff;
+			Format = (Format)(data >> 24);
 
 			RefOffset = reader.ReadUInt16();
 			RefFormat = (Format)reader.ReadUInt16();
@@ -48,14 +48,9 @@ namespace OpenRA.FileFormats
 		}
 	}
 
-	public enum Format
-	{
-		Format20 = 0x20,
-		Format40 = 0x40,
-		Format80 = 0x80,
-	}
+	public enum Format { Format20 = 0x20, Format40 = 0x40, Format80 = 0x80 }
 
-	public class ShpReader : IEnumerable<ImageHeader>
+	public class ShpReader
 	{
 		public readonly int ImageCount;
 		public readonly ushort Width;
@@ -67,74 +62,71 @@ namespace OpenRA.FileFormats
 
 		int recurseDepth = 0;
 
-		public ShpReader( Stream stream )
+		public ShpReader(Stream stream)
 		{
-			BinaryReader reader = new BinaryReader( stream );
-
-			ImageCount = reader.ReadUInt16();
-			reader.ReadUInt16();
-			reader.ReadUInt16();
-			Width = reader.ReadUInt16();
-			Height = reader.ReadUInt16();
-			reader.ReadUInt32();
-
-			for( int i = 0 ; i < ImageCount ; i++ )
-				headers.Add( new ImageHeader( reader ) );
-
-			new ImageHeader( reader ); // end-of-file header
-			new ImageHeader( reader ); // all-zeroes header
-
-			Dictionary<uint, ImageHeader> offsets = new Dictionary<uint, ImageHeader>();
-			foreach( ImageHeader h in headers )
-				offsets.Add( h.Offset, h );
-
-			for( int i = 0 ; i < ImageCount ; i++ )
+			using (var reader = new BinaryReader(stream))
 			{
-				ImageHeader h = headers[ i ];
-				if( h.Format == Format.Format20 )
-					h.RefImage = headers[ i - 1 ];
+				ImageCount = reader.ReadUInt16();
+				reader.ReadUInt16();
+				reader.ReadUInt16();
+				Width = reader.ReadUInt16();
+				Height = reader.ReadUInt16();
+				reader.ReadUInt32();
 
-				else if( h.Format == Format.Format40 )
+				for (int i = 0 ; i < ImageCount ; i++)
+					headers.Add(new ImageHeader(reader));
+
+				new ImageHeader(reader); // end-of-file header
+				new ImageHeader(reader); // all-zeroes header
+
+				var offsets = headers.ToDictionary(h => h.Offset, h =>h);
+
+				for (int i = 0 ; i < ImageCount ; i++)
 				{
-					if( !offsets.TryGetValue( h.RefOffset, out h.RefImage ) )
-						throw new InvalidDataException( string.Format( "Reference doesnt point to image data {0}->{1}", h.Offset, h.RefOffset ) );
+					var h = headers[ i ];
+					if (h.Format == Format.Format20)
+						h.RefImage = headers[i - 1];
+
+					else if (h.Format == Format.Format40)
+						if (!offsets.TryGetValue(h.RefOffset, out h.RefImage))
+							throw new InvalidDataException("Reference doesnt point to image data {0}->{1}".F(h.Offset, h.RefOffset));
 				}
+
+				foreach (ImageHeader h in headers)
+					Decompress(stream, h);
 			}
-
-			foreach( ImageHeader h in headers )
-				Decompress( stream, h );
 		}
 
-		public ImageHeader this[ int index ]
+		public ImageHeader this[int index]
 		{
-			get { return headers[ index ]; }
+			get { return headers[index]; }
 		}
 
-		void Decompress( Stream stream, ImageHeader h )
+		void Decompress(Stream stream, ImageHeader h)
 		{
-			if( recurseDepth > ImageCount )
-				throw new InvalidDataException( "Format20/40 headers contain infinite loop" );
+			if (recurseDepth > ImageCount)
+				throw new InvalidDataException("Format20/40 headers contain infinite loop");
 
-			switch( h.Format )
+			switch(h.Format)
 			{
 				case Format.Format20:
 				case Format.Format40:
 					{
-						if( h.RefImage.Image == null )
+						if (h.RefImage.Image == null)
 						{
 							++recurseDepth;
-							Decompress( stream, h.RefImage );
+							Decompress(stream, h.RefImage);
 							--recurseDepth;
 						}
 
-						h.Image = CopyImageData( h.RefImage.Image );
+						h.Image = CopyImageData(h.RefImage.Image);
 						Format40.DecodeInto(ReadCompressedData(stream, h), h.Image);
 						break;
 					}
 				case Format.Format80:
 					{
-						byte[] imageBytes = new byte[ Width * Height ];
-						Format80.DecodeInto( ReadCompressedData( stream, h ), imageBytes );
+						var imageBytes = new byte[Width * Height];
+						Format80.DecodeInto(ReadCompressedData(stream, h), imageBytes);
 						h.Image = imageBytes;
 						break;
 					}
@@ -143,37 +135,28 @@ namespace OpenRA.FileFormats
 			}
 		}
 
-		static byte[] ReadCompressedData( Stream stream, ImageHeader h )
+		static byte[] ReadCompressedData(Stream stream, ImageHeader h)
 		{
 			stream.Position = h.Offset;
-			// Actually, far too big. There's no length field with the correct length though :(
-			int compressedLength = (int)( stream.Length - stream.Position );
+			// TODO: Actually, far too big. There's no length field with the correct length though :(
+			var compressedLength = (int)(stream.Length - stream.Position);
 
-			byte[] compressedBytes = new byte[ compressedLength ];
+			var compressedBytes = new byte[ compressedLength ];
 			stream.Read( compressedBytes, 0, compressedLength );
 
-			//MemoryStream ms = new MemoryStream( compressedBytes );
 			return compressedBytes;
 		}
 
-		byte[] CopyImageData( byte[] baseImage )
+		byte[] CopyImageData(byte[] baseImage)
 		{
-			byte[] imageData = new byte[ Width * Height ];
-			for( int i = 0 ; i < Width * Height ; i++ )
-				imageData[ i ] = baseImage[ i ];
+			var imageData = new byte[Width * Height];
+			for (int i = 0 ; i < Width * Height ; i++)
+				imageData[i] = baseImage[i];
 
 			return imageData;
 		}
 
-		public IEnumerator<ImageHeader> GetEnumerator()
-		{
-			return headers.GetEnumerator();
-		}
-
-		IEnumerator IEnumerable.GetEnumerator()
-		{
-			return GetEnumerator();
-		}
+		public IEnumerable<ImageHeader> Frames { get { return headers; } }
 
 		public static ShpReader Load(string filename)
 		{

OpenRA.FileFormats/Graphics/ShpTSReader.cs

@@ -0,0 +1,615 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2013 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made 
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation. For more information,
+ * see LICENSE.
+ */
+#endregion
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Drawing;
+using System.IO;
+
+namespace OpenRA.FileFormats
+{
+
+	public struct Header
+	{
+		public ushort A;
+		// Unknown
+		// Width and Height of the images
+		public ushort Width;
+		public ushort Height;
+		public ushort NumImages;
+	}
+
+	public class HeaderImage
+	{
+		public ushort x;
+		public ushort y;
+		public ushort cx;
+		public ushort cy;
+		// cx and cy are width n height of stored image
+		public byte compression;
+		public byte[] align;
+		public byte[] transparent;
+		public int zero;
+		public int offset;
+		public byte[] Image;
+	}
+
+	public struct SHPData
+	{
+		public HeaderImage HeaderImage;
+		public byte[] Databuffer;
+		public byte[] FrameImage;
+	}
+
+	public struct SHP
+	{
+		public Header Header;
+		public SHPData[] Data;
+	}
+
+
+	public class ShpTSReader : IEnumerable<HeaderImage>
+	{
+		public readonly int ImageCount;
+		public readonly ushort Width;
+		public readonly ushort Height;
+		public readonly ushort Width2;
+		public readonly ushort Height2;
+		public int arroff = 0;
+		public int erri = 0;
+		public int errj = 0;
+		public int errk = 0;
+		public int errl = 0;
+
+		public static int FindNextOffsetFrom(SHP SHP, int Init, int Last)
+		{
+			int result;
+			result = 0;
+			Last++;
+			while ((result == 0) && (Init < Last))
+			{
+				result = SHP.Data[Init].HeaderImage.offset;
+				Init++;
+			}
+			return result;
+		}
+
+		private readonly List<HeaderImage> headers = new List<HeaderImage>();
+
+		public ShpTSReader(Stream s)
+		{
+
+			SHP SHP = new SHP();
+				int FileSize;
+				int x;
+				int k = 0;
+				int l = 0;
+
+				int ImageSize;
+				int NextOffset;
+
+				byte[] FData;
+				byte cp;
+				byte[] Databuffer;
+
+				FileSize = (int)s.Length;
+				// Get Header
+				SHP.Header.A = s.ReadUInt16();
+				SHP.Header.Width = s.ReadUInt16();
+				SHP.Header.Height = s.ReadUInt16();
+				SHP.Header.NumImages = s.ReadUInt16();
+
+				SHP.Data = new SHPData[SHP.Header.NumImages + 1];
+
+				ImageCount = SHP.Header.NumImages;
+				
+				for (x = 1; x <= SHP.Header.NumImages; x++)
+				{
+					SHP.Data[x].HeaderImage = new HeaderImage();
+ 
+					SHP.Data[x].HeaderImage.x = s.ReadUInt16();
+					SHP.Data[x].HeaderImage.y = s.ReadUInt16();
+					SHP.Data[x].HeaderImage.cx = s.ReadUInt16();
+					SHP.Data[x].HeaderImage.cy = s.ReadUInt16();
+
+					SHP.Data[x].HeaderImage.compression = s.ReadUInt8();
+					SHP.Data[x].HeaderImage.align = s.ReadBytes(3);
+					s.ReadInt32();
+					SHP.Data[x].HeaderImage.zero = s.ReadUInt8();
+					SHP.Data[x].HeaderImage.transparent = s.ReadBytes(3);
+
+					SHP.Data[x].HeaderImage.offset = s.ReadInt32();
+
+				}
+
+				Width = SHP.Header.Width;
+				Height = SHP.Header.Height;
+
+				for (int i = 0; i < ImageCount; i++)
+				{
+					headers.Add(SHP.Data[i+1].HeaderImage);
+				}
+
+				// Read and decode each image from the file
+				for (x = 1; x <= SHP.Header.NumImages; x++)
+				{
+					headers[x - 1].Image = new byte[(Width * Height)];
+					for (int i = 0; i < headers[x - 1].Image.Length; i++)
+						headers[x - 1].Image[i] = 0;
+
+					FData = new byte[(Width * Height)];
+
+					// Does it really reads the frame?
+					if (SHP.Data[x].HeaderImage.offset != 0)
+					{
+						try
+						{
+						// Now it checks the compression:
+						if ((SHP.Data[x].HeaderImage.compression == 3))
+						{
+							// decode it
+							// Compression 3
+							NextOffset = FindNextOffsetFrom(SHP, x + 1, SHP.Header.NumImages);
+							if (NextOffset != 0)
+							{
+								
+								ImageSize = NextOffset - SHP.Data[x].HeaderImage.offset;
+								Databuffer = new byte[ImageSize];
+								for (int i = 0; i < ImageSize; i++)
+								{
+									s.Seek(SHP.Data[x].HeaderImage.offset + i, SeekOrigin.Begin);
+									Databuffer[i] = s.ReadUInt8();
+								}
+								SHP.Data[x].Databuffer = new byte[(SHP.Data[x].HeaderImage.cx * SHP.Data[x].HeaderImage.cy)];
+								Decode3(Databuffer, ref SHP.Data[x].Databuffer, SHP.Data[x].HeaderImage.cx, SHP.Data[x].HeaderImage.cy, ref FileSize);
+
+								k = 0;
+								l = 0;
+								for (int i = 0; i < Height; i++)
+								{
+									erri = i;
+									for (int j = SHP.Data[x].HeaderImage.x; j < Width; j++)
+									{
+										errj = j;
+										errl = l;
+										errk = k;
+										arroff = i + j + l;
+
+										if (((j + 1) > (SHP.Data[x].HeaderImage.cx + SHP.Data[x].HeaderImage.x)) || ((i + 1) > (SHP.Data[x].HeaderImage.cy)))
+											cp = 0;
+										else
+											cp = SHP.Data[x].Databuffer[i + (j - SHP.Data[x].HeaderImage.x) + l];
+
+										FData[i + j + k] = cp;
+
+										if (j == (SHP.Data[x].HeaderImage.cx + SHP.Data[x].HeaderImage.x - 1))
+											l = l + (SHP.Data[x].HeaderImage.cx - 1);
+
+										if (j == (Width - 1))
+											k = k + (Width - 1);
+									} 
+								}
+								//FData = headers[x - 1].Image;
+								k = 0;
+								for (int i = 0; i < (Height - SHP.Data[x].HeaderImage.y); i++)
+								{
+									for (int j = 0; j < Width; j++)
+									{
+										headers[x - 1].Image[i + j + k + (Width * SHP.Data[x].HeaderImage.y)] = FData[i + j + k];
+										if (j == (Width - 1))
+										{
+											k = k + (Width - 1);
+										}
+									}
+								}
+
+							}
+							else
+							{
+								
+								ImageSize = 0;
+								ImageSize = FileSize - SHP.Data[x].HeaderImage.offset;
+								Databuffer = new byte[ImageSize];
+								for (int i = 0; i < ImageSize; i++)
+								{
+									s.Seek(SHP.Data[x].HeaderImage.offset + i, SeekOrigin.Begin);
+									Databuffer[i] = s.ReadUInt8();
+								}
+								SHP.Data[x].Databuffer = new byte[((SHP.Data[x].HeaderImage.cx * SHP.Data[x].HeaderImage.cy))];
+								
+								Decode3(Databuffer, ref SHP.Data[x].Databuffer, SHP.Data[x].HeaderImage.cx, SHP.Data[x].HeaderImage.cy, ref ImageSize);
+
+								k = 0;
+								l = 0;
+								for (int i = 0; i < Height; i++)
+								{
+									erri = i;
+									for (int j = SHP.Data[x].HeaderImage.x; j < Width; j++)
+									{
+										errj = j;
+										errl = l;
+										errk = k;
+										arroff = i + j + l;
+
+										if (((j + 1) > (SHP.Data[x].HeaderImage.cx + SHP.Data[x].HeaderImage.x)) || ((i + 1) > (SHP.Data[x].HeaderImage.cy)))
+											cp = 0;
+										else
+											cp = SHP.Data[x].Databuffer[i + (j - SHP.Data[x].HeaderImage.x) + l];
+
+										FData[i + j + k] = cp;
+
+										if (j == (SHP.Data[x].HeaderImage.cx + SHP.Data[x].HeaderImage.x - 1))
+											l = l + (SHP.Data[x].HeaderImage.cx - 1);
+
+										if (j == (Width - 1))
+											k = k + (Width - 1);
+									}
+								}
+								//FData = headers[x - 1].Image;
+								k = 0;
+								for (int i = 0; i < (Height - SHP.Data[x].HeaderImage.y); i++)
+								{
+									for (int j = 0; j < Width; j++)
+									{
+										headers[x - 1].Image[i + j + k + (Width * SHP.Data[x].HeaderImage.y)] = FData[i + j + k];
+										if (j == (Width - 1))
+										{
+											k = k + (Width - 1);
+										}
+									}
+								}
+							}
+						}
+						else if ((SHP.Data[x].HeaderImage.compression == 2))
+						{
+							NextOffset = FindNextOffsetFrom(SHP, x + 1, SHP.Header.NumImages);
+							if (NextOffset != 0)
+							{
+								ImageSize = NextOffset - SHP.Data[x].HeaderImage.offset;
+								SHP.Data[x].Databuffer = new byte[(SHP.Data[x].HeaderImage.cx * SHP.Data[x].HeaderImage.cy)];
+								Databuffer = new byte[ImageSize];
+								for (int i = 0; i < ImageSize; i++)
+								{
+									s.Seek(SHP.Data[x].HeaderImage.offset + i, SeekOrigin.Begin);
+									Databuffer[i] = s.ReadUInt8();
+								}
+
+								Decode2(Databuffer, ref SHP.Data[x].Databuffer, SHP.Data[x].HeaderImage.cx, SHP.Data[x].HeaderImage.cy, ref ImageSize);
+
+								k = 0;
+								l = 0;
+								for (int i = 0; i < Height; i++)
+								{
+									erri = i;
+									for (int j = SHP.Data[x].HeaderImage.x; j < Width; j++)
+									{
+										errj = j;
+										errl = l;
+										errk = k;
+										arroff = i + j + l;
+
+										if (((j + 1) > (SHP.Data[x].HeaderImage.cx + SHP.Data[x].HeaderImage.x)) || ((i + 1) > (SHP.Data[x].HeaderImage.cy)))
+											cp = 0;
+										else
+											cp = SHP.Data[x].Databuffer[i + (j - SHP.Data[x].HeaderImage.x) + l];
+
+										FData[i + j + k] = cp;
+
+										if (j == (SHP.Data[x].HeaderImage.cx + SHP.Data[x].HeaderImage.x - 1))
+											l = l + (SHP.Data[x].HeaderImage.cx - 1);
+
+										if (j == (Width - 1))
+											k = k + (Width - 1);
+									}
+								}
+								//FData = headers[x - 1].Image;
+								k = 0;
+								for (int i = 0; i < (Height - SHP.Data[x].HeaderImage.y); i++)
+								{
+									for (int j = 0; j < Width; j++)
+									{
+										headers[x - 1].Image[i + j + k + (Width * SHP.Data[x].HeaderImage.y)] = FData[i + j + k];
+										if (j == (Width - 1))
+										{
+											k = k + (Width - 1);
+										}
+									}
+								}
+
+								// Compression 2
+							}
+							else
+							{
+								ImageSize = 0;
+								ImageSize = FileSize - SHP.Data[x].HeaderImage.offset;
+								Databuffer = new byte[ImageSize];
+								for (int i = 0; i < ImageSize; i++)
+								{
+									s.Seek(SHP.Data[x].HeaderImage.offset + i, SeekOrigin.Begin);
+									Databuffer[i] = s.ReadUInt8();
+								}
+								SHP.Data[x].Databuffer = new byte[((SHP.Data[x].HeaderImage.cx * SHP.Data[x].HeaderImage.cy))];
+								Decode2(Databuffer, ref SHP.Data[x].Databuffer, SHP.Data[x].HeaderImage.cx, SHP.Data[x].HeaderImage.cy, ref ImageSize);
+
+								k = 0;
+								l = 0;
+								for (int i = 0; i < Height; i++)
+								{
+									erri = i;
+									for (int j = SHP.Data[x].HeaderImage.x; j < Width; j++)
+									{
+										errj = j;
+										errl = l;
+										errk = k;
+										arroff = i + j + l;
+
+										if (((j + 1) > (SHP.Data[x].HeaderImage.cx + SHP.Data[x].HeaderImage.x)) || ((i + 1) > (SHP.Data[x].HeaderImage.cy)))
+											cp = 0;
+										else
+											cp = SHP.Data[x].Databuffer[i + (j - SHP.Data[x].HeaderImage.x) + l];
+
+										FData[i + j + k] = cp;
+
+										if (j == (SHP.Data[x].HeaderImage.cx + SHP.Data[x].HeaderImage.x - 1))
+											l = l + (SHP.Data[x].HeaderImage.cx - 1);
+
+										if (j == (Width - 1))
+											k = k + (Width - 1);
+									}
+								}
+								//FData = headers[x - 1].Image;
+								k = 0;
+								for (int i = 0; i < (Height - SHP.Data[x].HeaderImage.y); i++)
+								{
+									for (int j = 0; j < Width; j++)
+									{
+										headers[x - 1].Image[i + j + k + (Width * SHP.Data[x].HeaderImage.y)] = FData[i + j + k];
+										if (j == (Width - 1))
+										{
+											k = k + (Width - 1);
+										}
+									}
+								}
+								// Compression 2
+							}
+						}
+						else
+						{
+							// Compression 1
+							ImageSize = (int)(SHP.Data[x].HeaderImage.cx * SHP.Data[x].HeaderImage.cy);
+							Databuffer = new byte[ImageSize];
+							for (int i = 0; i < ImageSize; i++)
+							{
+								s.Seek(SHP.Data[x].HeaderImage.offset + i, SeekOrigin.Begin);
+								Databuffer[i] = s.ReadUInt8();
+							}
+							SHP.Data[x].Databuffer = new byte[(SHP.Data[x].HeaderImage.cx * SHP.Data[x].HeaderImage.cy)];
+							SHP.Data[x].Databuffer = Databuffer;
+
+							k = 0;
+							l = 0;
+							for (int i = 0; i < Height; i++)
+							{
+								erri = i;
+								for (int j = SHP.Data[x].HeaderImage.x; j < Width; j++)
+								{
+									errj = j;
+									errl = l;
+									errk = k;
+									arroff = i + j + l;
+
+									if (((j + 1) > (SHP.Data[x].HeaderImage.cx + SHP.Data[x].HeaderImage.x)) || ((i + 1) > (SHP.Data[x].HeaderImage.cy)))
+										cp = 0;
+									else
+										cp = SHP.Data[x].Databuffer[i + (j - SHP.Data[x].HeaderImage.x) + l];
+
+									FData[i + j + k] = cp;
+
+									if (j == (SHP.Data[x].HeaderImage.cx + SHP.Data[x].HeaderImage.x - 1))
+										l = l + (SHP.Data[x].HeaderImage.cx - 1);
+
+									if (j == (Width - 1))
+										k = k + (Width - 1);
+								}
+							}
+							//FData = headers[x - 1].Image;
+							k = 0;
+							for (int i = 0; i < (Height - SHP.Data[x].HeaderImage.y); i++)
+							{
+								for (int j = 0; j < Width; j++)
+								{
+									headers[x - 1].Image[i + j + k + (Width * SHP.Data[x].HeaderImage.y)] = FData[i + j + k];
+									if (j == (Width - 1))
+									{
+										k = k + (Width - 1);
+									}
+								}
+							}
+						}
+					}
+					catch (Exception e)
+					{
+						Console.WriteLine(e.Message);
+					}
+				}
+				// Set the shp's databuffer to the result after decompression
+			}
+			//Width = Width2;
+			//Height = Height2;
+		}
+
+		public HeaderImage this[int index]
+		{
+			get { return headers[index]; }
+		}
+		
+		public static void ReInterpretWordFromBytes(byte Byte1, byte Byte2, ref ushort FullValue)
+		{
+			FullValue = (ushort)((Byte2 * 256) + Byte1);
+		}
+
+		public static void ReInterpretWordFromBytes(byte Byte1, byte Byte2, ref uint FullValue)
+		{
+			FullValue = (uint)((Byte2 * 256) + Byte1);
+		}
+
+		// Compression 3:
+		public static void Decode3(byte[] Source, ref byte[] Dest, int cx, int cy, ref int max)
+		{
+			int SP;
+			int DP;
+			int x;
+			int y;
+			int Count;
+			int v;
+			int maxdp;
+			ushort Pos;
+			maxdp = cx * cy;
+			SP = 0;
+			DP = 0;
+			Pos = 0;
+			try
+			{
+				for (y = 1; y <= cy; y++)
+				{
+					ReInterpretWordFromBytes(Source[SP], Source[SP + 1], ref Pos);
+
+					Count = Pos - 2;
+
+					SP = SP + 2;
+
+					x = 0;
+					while (Count > 0)
+					{
+						Count = Count - 1;
+						if ((SP > max) || (DP > maxdp))
+						{
+							break;
+						}
+						else
+						{
+							// SP has reached max value, exit
+							v = Source[SP];
+							SP++;
+							if (v != 0)
+							{
+								if ((SP > max) || (DP > maxdp))
+								{
+									break;
+								}
+								else
+								{
+									x++;
+									Dest[DP] += (byte)v;
+								}
+								DP++;
+							}
+							else
+							{
+								Count -= 1;
+								v = Source[SP];
+
+								SP++;
+								if ((x + v) > cx)
+								{
+									v = cx - x;
+								}
+								x = x + v;
+								while (v > 0)
+								{
+									if ((SP > max) || (DP > maxdp))
+									{
+										break;
+									}
+									else
+									{
+										v -= 1;
+										Dest[DP] = 0;
+
+									}
+									DP++;
+									// SP has reached max value, exit
+								}
+							}
+						}
+					}
+					if ((SP >= max) || (DP >= maxdp))
+					{
+						return;
+					}
+					// SP has reached max value, exit
+				}
+			}
+
+			catch (Exception e)
+			{
+				Console.WriteLine(e.Message);
+			}
+
+		}
+
+		public static void Decode2(byte[] Source, ref byte[] Dest, int cx, int cy, ref int max)
+		{
+			int SP;
+			int DP;
+			int y;
+			int Count;
+			int maxdp;
+			ushort Pos;
+			maxdp = cx * cy;
+			SP = 0;
+			DP = 0;
+			Pos = 0;
+			try
+			{
+				for (y = 1; y <= cy; y++)
+				{
+					ReInterpretWordFromBytes(Source[SP], Source[SP + 1], ref Pos);
+					Count = Pos - 2;
+					SP += 2;
+					while (Count > 0)
+					{
+						Count -= 1;
+						if ((SP > max) || (DP > maxdp))
+						{
+							return;
+						}
+						// SP has reached max value, exit
+						Dest[DP] = Source[SP];
+						SP++;
+						DP++;
+					}
+					if ((SP >= max) || (DP >= maxdp))
+					{
+						return;
+					}
+					// SP has reached max value, exit
+				}
+			}
+			catch (Exception e)
+			{
+				Console.WriteLine(e.Message);
+			}
+		}
+
+		public IEnumerator<HeaderImage> GetEnumerator()
+		{
+			return headers.GetEnumerator();
+		}
+
+		IEnumerator IEnumerable.GetEnumerator()
+		{
+			return GetEnumerator();
+		}
+
+		public Size Size { get { return new Size(Width, Height); } }
+	}
+}

OpenRA.FileFormats/Graphics/Vertex.cs

@@ -24,5 +24,12 @@ namespace OpenRA.FileFormats.Graphics
 			this.u = uv.X; this.v = uv.Y;
 			this.p = pc.X; this.c = pc.Y;
 		}
+
+		public Vertex(float[] xyz, float2 uv, float2 pc)
+		{
+			this.x = xyz[0]; this.y = xyz[1]; this.z = xyz[2];
+			this.u = uv.X; this.v = uv.Y;
+			this.p = pc.X; this.c = pc.Y;
+		}
 	}
 }

OpenRA.FileFormats/Graphics/VqaReader.cs

@@ -46,67 +46,66 @@ namespace OpenRA.FileFormats
 		public byte[] AudioData { get { return audioData; } }
 		public int CurrentFrame { get { return currentFrame; } }
 
-		public VqaReader( Stream stream )
+		public VqaReader(Stream stream)
 		{
 			this.stream = stream;
-			BinaryReader reader = new BinaryReader( stream );
 
 			// Decode FORM chunk
-			if (new String(reader.ReadChars(4)) != "FORM")
+			if (stream.ReadASCII(4) != "FORM")
 				throw new InvalidDataException("Invalid vqa (invalid FORM section)");
-			/*var length = */ reader.ReadUInt32();
+			/*var length = */ stream.ReadUInt32();
 
-			if (new String(reader.ReadChars(8)) != "WVQAVQHD")
+			if (stream.ReadASCII(8) != "WVQAVQHD")
 				throw new InvalidDataException("Invalid vqa (not WVQAVQHD)");
-			/* var length = */reader.ReadUInt32();
+			/* var length = */stream.ReadUInt32();
 
-			/*var version = */reader.ReadUInt16();
-			/*var flags = */reader.ReadUInt16();
-			Frames = reader.ReadUInt16();
-			Width = reader.ReadUInt16();
-			Height = reader.ReadUInt16();
+			/*var version = */stream.ReadUInt16();
+			/*var flags = */stream.ReadUInt16();
+			Frames = stream.ReadUInt16();
+			Width = stream.ReadUInt16();
+			Height = stream.ReadUInt16();
 
-			blockWidth = reader.ReadByte();
-			blockHeight = reader.ReadByte();
-			Framerate = reader.ReadByte();
-			cbParts = reader.ReadByte();
+			blockWidth = stream.ReadUInt8();
+			blockHeight = stream.ReadUInt8();
+			Framerate = stream.ReadUInt8();
+			cbParts = stream.ReadUInt8();
 			blocks = new int2(Width / blockWidth, Height / blockHeight);
 
-			numColors = reader.ReadUInt16();
-			/*var maxBlocks = */reader.ReadUInt16();
-			/*var unknown1 = */reader.ReadUInt16();
-			/*var unknown2 = */reader.ReadUInt32();
+			numColors = stream.ReadUInt16();
+			/*var maxBlocks = */stream.ReadUInt16();
+			/*var unknown1 = */stream.ReadUInt16();
+			/*var unknown2 = */stream.ReadUInt32();
 
 			// Audio
-			/*var freq = */reader.ReadUInt16();
-			/*var channels = */reader.ReadByte();
-			/*var bits = */reader.ReadByte();
-			/*var unknown3 = */reader.ReadChars(14);
+			/*var freq = */stream.ReadUInt16();
+			/*var channels = */stream.ReadByte();
+			/*var bits = */stream.ReadByte();
+			/*var unknown3 = */stream.ReadBytes(14);
 
-
-			var frameSize = Exts.NextPowerOf2(Math.Max(Width,Height));
+			var frameSize = Exts.NextPowerOf2(Math.Max(Width, Height));
 			cbf = new byte[Width*Height];
 			cbp = new byte[Width*Height];
 			palette = new uint[numColors];
 			origData = new byte[2*blocks.X*blocks.Y];
-			frameData = new uint[frameSize,frameSize];
+			frameData = new uint[frameSize, frameSize];
 
-			var type = new String(reader.ReadChars(4));
+			var type = stream.ReadASCII(4);
 			if (type != "FINF")
 			{
-				reader.ReadBytes(27);
-				type = new String(reader.ReadChars(4));
+				stream.Seek(27, SeekOrigin.Current);
+				type = stream.ReadASCII(4);
 			}
 
-			/*var length = */reader.ReadUInt16();
-			/*var unknown4 = */reader.ReadUInt16();
+			/*var length = */stream.ReadUInt16();
+			/*var unknown4 = */stream.ReadUInt16();
 
 			// Frame offsets
 			offsets = new UInt32[Frames];
 			for (int i = 0; i < Frames; i++)
 			{
-				offsets[i] = reader.ReadUInt32();
-				if (offsets[i] > 0x40000000) offsets[i] -= 0x40000000;
+				offsets[i] = stream.ReadUInt32();
+				if (offsets[i] > 0x40000000)
+					offsets[i] -= 0x40000000;
 				offsets[i] <<= 1;
 			}
 
@@ -130,28 +129,28 @@ namespace OpenRA.FileFormats
 			for (var i = 0; i < Frames; i++)
 			{
 				stream.Seek(offsets[i], SeekOrigin.Begin);
-				BinaryReader reader = new BinaryReader(stream);
 				var end = (i < Frames - 1) ? offsets[i + 1] : stream.Length;
 
-				while (reader.BaseStream.Position < end)
+				while (stream.Position < end)
 				{
-					var type = new String(reader.ReadChars(4));
-					var length = int2.Swap(reader.ReadUInt32());
+					var type = stream.ReadASCII(4);
+					var length = int2.Swap(stream.ReadUInt32());
 
 					switch (type)
 					{
 						case "SND0":
 						case "SND2":
-							var rawAudio = reader.ReadBytes((int)length);
+							var rawAudio = stream.ReadBytes((int)length);
 							ms.Write(rawAudio);
 							compressed = (type == "SND2");
 							break;
 						default:
-							reader.ReadBytes((int)length);
+							stream.ReadBytes((int)length);
 							break;
 					}
 
-					if (reader.PeekChar() == 0) reader.ReadByte();
+					// Chunks are aligned on even bytes; advance by a byte if the next one is null
+					if (stream.Peek() == 0) stream.ReadByte();
 				}
 			}
 
@@ -171,48 +170,47 @@ namespace OpenRA.FileFormats
 
 			// Seek to the start of the frame
 			stream.Seek(offsets[currentFrame], SeekOrigin.Begin);
-			BinaryReader reader = new BinaryReader(stream);
 			var end = (currentFrame < Frames - 1) ? offsets[currentFrame+1] : stream.Length;
 
-			while(reader.BaseStream.Position < end)
+			while (stream.Position < end)
 			{
-				var type = new String(reader.ReadChars(4));
-				var length = int2.Swap(reader.ReadUInt32());
+				var type = stream.ReadASCII(4);
+				var length = int2.Swap(stream.ReadUInt32());
 
 				switch(type)
 				{
 					case "VQFR":
-						DecodeVQFR(reader);
+						DecodeVQFR(stream);
 					break;
 					default:
 						// Don't parse sound here.
-						reader.ReadBytes((int)length);
+						stream.ReadBytes((int)length);
 						break;
 				}
 
 				// Chunks are aligned on even bytes; advance by a byte if the next one is null
-				if (reader.PeekChar() == 0) reader.ReadByte();
+				if (stream.Peek() == 0) stream.ReadByte();
 			}
 		}
 
 		// VQA Frame
-		public void DecodeVQFR(BinaryReader reader)
+		public void DecodeVQFR(Stream s)
 		{
-			while(true)
+			while (true)
 			{
 				// Chunks are aligned on even bytes; may be padded with a single null
-				if (reader.PeekChar() == 0) reader.ReadByte();
-				var type = new String(reader.ReadChars(4));
-				int subchunkLength = (int)int2.Swap(reader.ReadUInt32());
+				if (s.Peek() == 0) s.ReadByte();
+				var type = s.ReadASCII(4);
+				int subchunkLength = (int)int2.Swap(s.ReadUInt32());
 
 				switch(type)
 				{
 					// Full frame-modifier
 					case "CBFZ":
-						Format80.DecodeInto( reader.ReadBytes(subchunkLength), cbf );
+						Format80.DecodeInto(s.ReadBytes(subchunkLength), cbf);
 					break;
 					case "CBF0":
-						cbf = reader.ReadBytes(subchunkLength);
+						cbf = s.ReadBytes(subchunkLength);
 					break;
 
 					// frame-modifier chunk
@@ -224,12 +222,12 @@ namespace OpenRA.FileFormats
 							if (type == "CBP0")
 								cbf = (byte[])cbp.Clone();
 							else
-								Format80.DecodeInto( cbp, cbf );
+								Format80.DecodeInto(cbp, cbf);
 
 							cbOffset = cbChunk = 0;
 						}
 
-						var bytes = reader.ReadBytes(subchunkLength);
+						var bytes = s.ReadBytes(subchunkLength);
 						bytes.CopyTo(cbp,cbOffset);
 						cbOffset += subchunkLength;
 						cbChunk++;
@@ -239,16 +237,16 @@ namespace OpenRA.FileFormats
 					case "CPL0":
 						for (int i = 0; i < numColors; i++)
 						{
-							byte r = (byte)(reader.ReadByte() << 2);
-							byte g = (byte)(reader.ReadByte() << 2);
-							byte b = (byte)(reader.ReadByte() << 2);
+							byte r = (byte)(s.ReadUInt8() << 2);
+							byte g = (byte)(s.ReadUInt8() << 2);
+							byte b = (byte)(s.ReadUInt8() << 2);
 							palette[i] = (uint)((255 << 24) | (r << 16) | (g << 8) | b);
 						}
 					break;
 
 					// Frame data
 					case "VPTZ":
-						Format80.DecodeInto( reader.ReadBytes(subchunkLength), origData );
+						Format80.DecodeInto(s.ReadBytes(subchunkLength), origData);
 						// This is the last subchunk
 						return;
 					default:

OpenRA.FileFormats/Graphics/VxlReader.cs

@@ -0,0 +1,158 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2013 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation. For more information,
+ * see COPYING.
+ */
+
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+namespace OpenRA.FileFormats
+{
+	public enum NormalType { TiberianSun = 2, RedAlert2 = 4 }
+	public class VxlElement
+	{
+		public byte Color;
+		public byte Normal;
+	}
+
+	public class VxlLimb
+	{
+		public string Name;
+		public float Scale;
+		public float[] Bounds;
+		public byte[] Size;
+		public NormalType Type;
+
+		public uint VoxelCount;
+		public Dictionary<byte, VxlElement>[,] VoxelMap;
+	}
+
+	public class VxlReader
+	{
+		public readonly uint LimbCount;
+		public VxlLimb[] Limbs;
+
+		uint BodySize;
+
+		void ReadVoxelData(Stream s, VxlLimb l)
+		{
+			var baseSize = l.Size[0]*l.Size[1];
+			var colStart = new int[baseSize];
+			for (var i = 0; i < baseSize; i++)
+				colStart[i] = s.ReadInt32();
+			s.Seek(4*baseSize, SeekOrigin.Current);
+			var dataStart = s.Position;
+
+			// Count the voxels in this limb
+			l.VoxelCount = 0;
+			for (var i = 0; i < baseSize; i++)
+			{
+				// Empty column
+				if (colStart[i] == -1)
+					continue;
+
+				s.Seek(dataStart + colStart[i], SeekOrigin.Begin);
+				var z = 0;
+				do
+				{
+					z += s.ReadUInt8();
+					var count = s.ReadUInt8();
+					z += count;
+					l.VoxelCount += count;
+					s.Seek(2*count + 1, SeekOrigin.Current);
+				} while (z < l.Size[2]);
+			}
+
+			// Read the data
+			l.VoxelMap = new Dictionary<byte, VxlElement>[l.Size[0],l.Size[1]];
+			for (var i = 0; i < baseSize; i++)
+			{
+				// Empty column
+				if (colStart[i] == -1)
+					continue;
+
+				s.Seek(dataStart + colStart[i], SeekOrigin.Begin);
+
+				byte x = (byte)(i % l.Size[0]);
+				byte y = (byte)(i / l.Size[0]);
+				byte z = 0;
+				l.VoxelMap[x,y] = new Dictionary<byte, VxlElement>();
+				do
+				{
+					z += s.ReadUInt8();
+					var count = s.ReadUInt8();
+					for (var j = 0; j < count; j++)
+					{
+						var v = new VxlElement();
+						v.Color = s.ReadUInt8();
+						v.Normal = s.ReadUInt8();
+
+						l.VoxelMap[x,y].Add(z, v);
+						z++;
+					}
+					// Skip duplicate count
+					s.ReadUInt8();
+				} while (z < l.Size[2]);
+			}
+		}
+
+		public VxlReader(Stream s)
+		{
+
+			if (!s.ReadASCII(16).StartsWith("Voxel Animation"))
+				throw new InvalidDataException("Invalid vxl header");
+
+			s.ReadUInt32();
+			LimbCount = s.ReadUInt32();
+			s.ReadUInt32();
+			BodySize = s.ReadUInt32();
+			s.Seek(770, SeekOrigin.Current);
+
+			// Read Limb headers
+			Limbs = new VxlLimb[LimbCount];
+			for (var i = 0; i < LimbCount; i++)
+			{
+				Limbs[i] = new VxlLimb();
+				Limbs[i].Name = s.ReadASCII(16);
+				s.Seek(12, SeekOrigin.Current);
+			}
+
+			// Skip to the Limb footers
+			s.Seek(802 + 28*LimbCount + BodySize, SeekOrigin.Begin);
+
+			var LimbDataOffset = new uint[LimbCount];
+			for (var i = 0; i < LimbCount; i++)
+			{
+				LimbDataOffset[i] = s.ReadUInt32();
+				s.Seek(8, SeekOrigin.Current);
+				Limbs[i].Scale = s.ReadFloat();
+				s.Seek(48, SeekOrigin.Current);
+
+				Limbs[i].Bounds = new float[6];
+				for (var j = 0; j < 6; j++)
+					Limbs[i].Bounds[j] = s.ReadFloat();
+				Limbs[i].Size = s.ReadBytes(3);
+				Limbs[i].Type = (NormalType)s.ReadByte();
+			}
+
+			for (var i = 0; i < LimbCount; i++)
+			{
+				s.Seek(802 + 28*LimbCount + LimbDataOffset[i], SeekOrigin.Begin);
+				ReadVoxelData(s, Limbs[i]);
+			}
+		}
+
+		public static VxlReader Load(string filename)
+		{
+			using (var s = File.OpenRead(filename))
+				return new VxlReader(s);
+		}
+	}
+}

OpenRA.FileFormats/HSLColor.cs

@@ -12,36 +12,54 @@ using System.Drawing;
 
 namespace OpenRA.FileFormats
 {
-	public struct ColorRamp
+	public struct HSLColor
 	{
-		public byte H,S,L,R;
+		public readonly byte H;
+		public readonly byte S;
+		public readonly byte L;
+		public readonly Color RGB;
 
-		public ColorRamp(byte h, byte s, byte l, byte r)
+		public HSLColor(byte h, byte s, byte l)
 		{
-			H = h; S = s; L = l; R = r;
+			H = h;
+			S = s;
+			L = l;
+			RGB = RGBFromHSL(H / 255f, S / 255f, L / 255f);
 		}
 
-		public static readonly ColorRamp Empty = new ColorRamp(0,0,0,0);
-
-		/* returns a color along the Lum ramp */
-		public Color GetColor( float t )
+		public void ToHSV(out float h, out float s, out float v)
 		{
-			return ColorFromHSL( H / 255f, S / 255f, float2.Lerp( L / 255f, L*R / (255f * 255f), t ) );
+			var ll = 2*L / 255f;
+			var ss = S / 255f * ((ll <= 1) ? ll : 2 - ll);
+
+			h = H / 255f;
+			s = (2 * ss) / (ll + ss);
+			v = (ll + ss) / 2;
 		}
 
-		public override string ToString()
+		public static HSLColor FromHSV(float h, float s, float v)
 		{
-			return "{0},{1},{2},{3}".F(H, S, L, R);
+			var ll = 0.5f*(2 - s)*v;
+			var ss = (ll >= 1 || v <= 0) ? 0 : 0.5f*s*v / (ll <= 0.5f ? ll : 1 - ll);
+			return new HSLColor((byte)(255*h), (byte)(255*ss), (byte)(255*ll));
 		}
 
-		// hk is hue in the range [0,1] instead of [0,360]
-		public static Color ColorFromHSL(float hk, float s, float l)
+		public static HSLColor FromRGB(int r, int g, int b)
+		{
+			var c = Color.FromArgb(r, g, b);
+			var h = (byte)((c.GetHue() / 360.0f) * 255);
+			var s = (byte)(c.GetSaturation() * 255);
+			var l = (byte)(c.GetBrightness() * 255);
+			return new HSLColor(h, s, l);
+		}
+
+		public static Color RGBFromHSL(float h, float s, float l)
 		{
 			// Convert from HSL to RGB
 			var q = (l < 0.5f) ? l * (1 + s) : l + s - (l * s);
 			var p = 2 * l - q;
 
-			float[] trgb = { hk + 1 / 3.0f, hk, hk - 1/3.0f };
+			float[] trgb = { h + 1 / 3.0f, h, h - 1/3.0f };
 			float[] rgb = { 0, 0, 0 };
 
 			for (int k = 0; k < 3; k++)
@@ -61,21 +79,26 @@ namespace OpenRA.FileFormats
 			return Color.FromArgb((int)(rgb[0] * 255), (int)(rgb[1] * 255), (int)(rgb[2] * 255));
 		}
 
-		public static bool operator ==(ColorRamp me, ColorRamp other)
+		public override string ToString()
 		{
-			return (me.H == other.H && me.S == other.S && me.L == other.L && me.R == other.R );
+			return "{0},{1},{2}".F(H, S, L);
 		}
 
-		public static bool operator !=(ColorRamp me, ColorRamp other) { return !(me == other); }
+		public static bool operator ==(HSLColor me, HSLColor other)
+		{
+			return (me.H == other.H && me.S == other.S && me.L == other.L);
+		}
 
-		public override int GetHashCode() { return H.GetHashCode() ^ S.GetHashCode() ^ L.GetHashCode() ^ R.GetHashCode(); }
+		public static bool operator !=(HSLColor me, HSLColor other) { return !(me == other); }
+
+		public override int GetHashCode() { return H.GetHashCode() ^ S.GetHashCode() ^ L.GetHashCode(); }
 
 		public override bool Equals(object obj)
 		{
 			if (obj == null)
 				return false;
 
-			ColorRamp o = (ColorRamp)obj;
+			HSLColor o = (HSLColor)obj;
 			return o == this;
 		}
 	}

OpenRA.FileFormats/Manifest.cs

@@ -9,6 +9,7 @@
 #endregion
 
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 
 namespace OpenRA.FileFormats
@@ -18,9 +19,12 @@ namespace OpenRA.FileFormats
 	public class Manifest
 	{
 		public readonly string[]
-			Mods, Folders, Packages, Rules, ServerTraits,
-			Sequences, Cursors, Chrome, Assemblies, ChromeLayout,
-			Weapons, Voices, Music, Movies, TileSets, ChromeMetrics;
+			Mods, Folders, Rules, ServerTraits,
+			Sequences, VoxelSequences, Cursors, Chrome, Assemblies, ChromeLayout,
+			Weapons, Voices, Notifications, Music, Movies, TileSets,
+			ChromeMetrics, PackageContents;
+
+		public readonly Dictionary<string, string> Packages;
 		public readonly MiniYaml LoadScreen;
 		public readonly Dictionary<string, Pair<string,int>> Fonts;
 		public readonly int TileSize = 24;
@@ -29,29 +33,34 @@ namespace OpenRA.FileFormats
 		{
 			Mods = mods;
 			var yaml = new MiniYaml(null, mods
-				.Select(m => MiniYaml.FromFile("mods/" + m + "/mod.yaml"))
+				.Select(m => MiniYaml.FromFile("mods{0}{1}{0}mod.yaml".F(Path.DirectorySeparatorChar, m)))
 				.Aggregate(MiniYaml.MergeLiberal)).NodesDict;
 
-			// Todo: Use fieldloader
+			// TODO: Use fieldloader
 			Folders = YamlList(yaml, "Folders");
-			Packages = YamlList(yaml, "Packages");
+			Packages = yaml["Packages"].NodesDict.ToDictionary(x => x.Key, x => x.Value.Value);
 			Rules = YamlList(yaml, "Rules");
 			ServerTraits = YamlList(yaml, "ServerTraits");
 			Sequences = YamlList(yaml, "Sequences");
+			VoxelSequences = YamlList(yaml, "VoxelSequences");
 			Cursors = YamlList(yaml, "Cursors");
 			Chrome = YamlList(yaml, "Chrome");
 			Assemblies = YamlList(yaml, "Assemblies");
 			ChromeLayout = YamlList(yaml, "ChromeLayout");
 			Weapons = YamlList(yaml, "Weapons");
 			Voices = YamlList(yaml, "Voices");
+			Notifications = YamlList(yaml, "Notifications");
 			Music = YamlList(yaml, "Music");
 			Movies = YamlList(yaml, "Movies");
 			TileSets = YamlList(yaml, "TileSets");
 			ChromeMetrics = YamlList(yaml, "ChromeMetrics");
+			PackageContents = YamlList(yaml, "PackageContents");
 
 			LoadScreen = yaml["LoadScreen"];
-			Fonts = yaml["Fonts"].NodesDict.ToDictionary(x => x.Key, x => Pair.New(x.Value.NodesDict["Font"].Value,
-												                  int.Parse(x.Value.NodesDict["Size"].Value)));
+			Fonts = yaml["Fonts"].NodesDict.ToDictionary(x => x.Key,
+				x => Pair.New(x.Value.NodesDict["Font"].Value,
+					int.Parse(x.Value.NodesDict["Size"].Value)));
+
 			if (yaml.ContainsKey("TileSize"))
 				TileSize = int.Parse(yaml["TileSize"].Value);
 		}
@@ -59,7 +68,7 @@ namespace OpenRA.FileFormats
 		static string[] YamlList(Dictionary<string, MiniYaml> yaml, string key)
 		{
 			if (!yaml.ContainsKey(key))
-				return new string[ 0 ];
+				return new string[] {};
 
 			return yaml[key].NodesDict.Keys.ToArray();
 		}

OpenRA.FileFormats/Map/PlayerReference.cs

@@ -21,14 +21,17 @@ namespace OpenRA.FileFormats
 		public bool NonCombatant = false;
 		public bool Playable = false;
 		public string Bot = null;
-		public bool DefaultStartingUnits = false;
+		public string StartingUnitsClass = null;
 		public bool AllowBots = true;
+		public bool Required = false;
 
 		public bool LockRace = false;
 		public string Race;
 
+		// ColorRamp naming retained for backward compatibility
 		public bool LockColor = false;
-		public ColorRamp ColorRamp = new ColorRamp(0,0,238,34);
+		public HSLColor ColorRamp = new HSLColor(0,0,238);
+		public HSLColor Color { get { return ColorRamp; } set { ColorRamp = value; }}
 
 		public bool LockSpawn = false;
 		public int Spawn = 0;

OpenRA.FileFormats/Map/SmudgeReference.cs

@@ -15,6 +15,7 @@ namespace OpenRA.FileFormats
 		public readonly string Type;
 		public readonly int2 Location;
 		public readonly int Depth;
+
 		public SmudgeReference( string type, int2 location, int depth )
 		{
 			Type = type;
@@ -22,10 +23,9 @@ namespace OpenRA.FileFormats
 			Depth = depth;
 		}
 
-		public override string ToString ()
+		public override string ToString()
 		{
-			return string.Format("{0} {1},{2} {3}", Type, Location.X,Location.Y, Depth);
+			return "{0} {1},{2} {3}".F(Type, Location.X, Location.Y, Depth);
 		}
-
 	}
 }

OpenRA.FileFormats/Map/TileSet.cs

@@ -20,9 +20,10 @@ namespace OpenRA.FileFormats
 	public class TerrainTypeInfo
 	{
 		public string Type;
-		public bool AcceptSmudge = true;
+		public string[] AcceptsSmudgeType = { };
 		public bool IsWater = false;
 		public Color Color;
+		public string CustomCursor;
 
 		public TerrainTypeInfo() {}
 		public TerrainTypeInfo(MiniYaml my) { FieldLoader.Load(this, my); }
@@ -36,18 +37,19 @@ namespace OpenRA.FileFormats
 		public string Image;
 		public int2 Size;
 		public bool PickAny;
+		public string Category;
 
-		[FieldLoader.LoadUsing( "LoadTiles" )]
+		[FieldLoader.LoadUsing("LoadTiles")]
 		public Dictionary<byte, string> Tiles = new Dictionary<byte, string>();
 
 		public TileTemplate() {}
-		public TileTemplate(MiniYaml my) { FieldLoader.Load( this, my ); }
+		public TileTemplate(MiniYaml my) { FieldLoader.Load(this, my); }
 
-		static object LoadTiles( MiniYaml y )
+		static object LoadTiles(MiniYaml y)
 		{
 			return y.NodesDict["Tiles"].NodesDict.ToDictionary(
 				t => byte.Parse(t.Key),
-				t => t.Value.Value );
+				t => t.Value.Value);
 		}
 
 		static readonly string[] Fields = { "Id", "Image", "Size", "PickAny" };
@@ -58,12 +60,14 @@ namespace OpenRA.FileFormats
 			foreach (var field in Fields)
 			{
 				FieldInfo f = this.GetType().GetField(field);
-				if (f.GetValue(this) == null) continue;
-				root.Add( new MiniYamlNode( field, FieldSaver.FormatValue( this, f ) ) );
+				if (f.GetValue(this) == null)
+					continue;
+
+				root.Add(new MiniYamlNode(field, FieldSaver.FormatValue(this, f)));
 			}
 
-			root.Add( new MiniYamlNode( "Tiles", null,
-				Tiles.Select( x => new MiniYamlNode( x.Key.ToString(), x.Value ) ).ToList() ) );
+			root.Add(new MiniYamlNode("Tiles", null,
+				Tiles.Select(x => new MiniYamlNode(x.Key.ToString(), x.Value)).ToList()));
 
 			return new MiniYaml(null, root);
 		}
@@ -76,18 +80,21 @@ namespace OpenRA.FileFormats
 		public string Name;
 		public string Id;
 		public string Palette;
+		public string PlayerPalette;
 		public int TileSize = 24;
 		public string[] Extensions;
+		public int WaterPaletteRotationBase = 0x60; 
 		public Dictionary<string, TerrainTypeInfo> Terrain = new Dictionary<string, TerrainTypeInfo>();
 		public Dictionary<ushort, TileTemplate> Templates = new Dictionary<ushort, TileTemplate>();
+		public string[] EditorTemplateOrder;
 
 		static readonly string[] fields = {"Name", "TileSize", "Id", "Palette", "Extensions"};
 
 		public TileSet() {}
 
-		public TileSet( string filepath )
+		public TileSet(string filepath)
 		{
-			var yaml = MiniYaml.DictFromFile( filepath );
+			var yaml = MiniYaml.DictFromFile(filepath);
 
 			// General info
 			FieldLoader.Load(this, yaml["General"]);
@@ -105,7 +112,7 @@ namespace OpenRA.FileFormats
 		{
 			foreach (var t in Templates)
 				if (t.Value.Data == null)
-					using( var s = FileSystem.OpenWithExts(t.Value.Image, Extensions) )
+					using (var s = FileSystem.OpenWithExts(t.Value.Image, Extensions))
 						t.Value.Data = new Terrain(s, TileSize);
 		}
 
@@ -117,33 +124,39 @@ namespace OpenRA.FileFormats
 			foreach (var field in fields)
 			{
 				FieldInfo f = this.GetType().GetField(field);
-				if (f.GetValue(this) == null) continue;
-				gen.Add( new MiniYamlNode( field, FieldSaver.FormatValue( this, f ) ) );
+				if (f.GetValue(this) == null)
+					continue;
+
+				gen.Add(new MiniYamlNode(field, FieldSaver.FormatValue(this, f)));
 			}
 
-			root.Add( new MiniYamlNode( "General", null, gen ) );
+			root.Add(new MiniYamlNode("General", null, gen));
 
-			root.Add( new MiniYamlNode( "Terrain", null,
-				Terrain.Select( t => new MiniYamlNode(
-					"TerrainType@{0}".F( t.Value.Type ),
-					t.Value.Save() ) ).ToList() ) );
+			root.Add(new MiniYamlNode( "Terrain", null,
+				Terrain.Select(t => new MiniYamlNode(
+					"TerrainType@{0}".F(t.Value.Type),
+					t.Value.Save())).ToList()));
 
-			root.Add( new MiniYamlNode( "Templates", null,
-				Templates.Select( t => new MiniYamlNode(
-					"Template@{0}".F( t.Value.Id ),
-					t.Value.Save() ) ).ToList() ) );
+			root.Add(new MiniYamlNode("Templates", null,
+				Templates.Select(t => new MiniYamlNode(
+					"Template@{0}".F(t.Value.Id),
+					t.Value.Save())).ToList()));
 			root.WriteToFile(filepath);
 		}
 
 		public byte[] GetBytes(TileReference<ushort,byte> r)
 		{
 			TileTemplate tile;
-			if( Templates.TryGetValue( r.type, out tile ) )
-				return tile.Data.TileBitmapBytes[ r.index ];
+			if (Templates.TryGetValue(r.type, out tile))
+			{
+				var data = tile.Data.TileBitmapBytes[r.index];
+				if (data != null)
+					return data;
+			}
 
-			byte[] missingTile = new byte[ TileSize * TileSize ];
-			for( int i = 0 ; i < missingTile.Length ; i++ )
-				missingTile[ i ] = 0x36;
+			byte[] missingTile = new byte[TileSize*TileSize];
+			for (var i = 0; i < missingTile.Length; i++)
+				missingTile[i] = 0x00;
 
 			return missingTile;
 		}
@@ -154,6 +167,7 @@ namespace OpenRA.FileFormats
 			string ret;
 			if (!tt.TryGetValue(r.index, out ret))
 				return "Clear"; // Default walkable
+
 			return ret;
 		}
 
@@ -166,7 +180,7 @@ namespace OpenRA.FileFormats
 
 			bitmap.Palette = p.AsSystemPalette();
 
-			var data = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height),
+			var data = bitmap.LockBits(bitmap.Bounds(),
 				ImageLockMode.WriteOnly, PixelFormat.Format8bppIndexed);
 
 			unsafe

OpenRA.FileFormats/MiniYaml.cs

@@ -105,22 +105,26 @@ namespace OpenRA.FileFormats
 			levels.Add(new List<MiniYamlNode>());
 
 			var lineNo = 0;
-			foreach (var line in lines)
+			foreach (var ll in lines)
 			{
+				var line = ll;
 				++lineNo;
+				if (line.Contains('#'))
+					line = line.Substring(0, line.IndexOf('#')).TrimEnd(' ', '\t');
 				var t = line.TrimStart(' ', '\t');
-				if (t.Length == 0 || t[0] == '#')
+				if (t.Length == 0)
 					continue;
 				var level = line.Length - t.Length;
+				var location = new MiniYamlNode.SourceLocation { Filename = filename, Line = lineNo };
 
 				if (levels.Count <= level)
-					throw new YamlException("Bad indent in miniyaml");
+					throw new YamlException("Bad indent in miniyaml at {0}".F (location));
 				while (levels.Count > level + 1)
 					levels.RemoveAt(levels.Count - 1);
 
 				var d = new List<MiniYamlNode>();
 				var rhs = SplitAtColon( ref t );
-				levels[ level ].Add( new MiniYamlNode( t, rhs, d, new MiniYamlNode.SourceLocation { Filename = filename, Line = lineNo } ) );
+				levels[ level ].Add( new MiniYamlNode( t, rhs, d, location ) );
 
 				levels.Add(d);
 			}
@@ -196,8 +200,8 @@ namespace OpenRA.FileFormats
 
 			var ret = new List<MiniYamlNode>();
 
-			var aDict = a.ToDictionary( x => x.Key );
-			var bDict = b.ToDictionary( x => x.Key );
+			var aDict = a.ToDictionaryWithConflictLog(x => x.Key, "MiniYaml.Merge", null, x => "{0} (at {1})".F(x.Key, x.Location));
+			var bDict = b.ToDictionaryWithConflictLog(x => x.Key, "MiniYaml.Merge", null, x => "{0} (at {1})".F(x.Key, x.Location));
 			var keys = aDict.Keys.Union( bDict.Keys ).ToList();
 
 			var noInherit = keys.Where(x => x.Length > 0 && x[0] == '-')

OpenRA.FileFormats/OpenRA.FileFormats.csproj

@@ -1,5 +1,5 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="3.5">
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
@@ -12,10 +12,25 @@
     <AssemblyName>OpenRA.FileFormats</AssemblyName>
     <FileUpgradeFlags>
     </FileUpgradeFlags>
-    <OldToolsVersion>2.0</OldToolsVersion>
+    <OldToolsVersion>3.5</OldToolsVersion>
     <UpgradeBackupLocation>
     </UpgradeBackupLocation>
     <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+    <PublishUrl>publish\</PublishUrl>
+    <Install>true</Install>
+    <InstallFrom>Disk</InstallFrom>
+    <UpdateEnabled>false</UpdateEnabled>
+    <UpdateMode>Foreground</UpdateMode>
+    <UpdateInterval>7</UpdateInterval>
+    <UpdateIntervalUnits>Days</UpdateIntervalUnits>
+    <UpdatePeriodically>false</UpdatePeriodically>
+    <UpdateRequired>false</UpdateRequired>
+    <MapFileExtensions>true</MapFileExtensions>
+    <ApplicationRevision>0</ApplicationRevision>
+    <ApplicationVersion>1.0.0.%2a</ApplicationVersion>
+    <IsWebBootstrapper>false</IsWebBootstrapper>
+    <UseApplicationTrust>false</UseApplicationTrust>
+    <BootstrapperEnabled>true</BootstrapperEnabled>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -27,6 +42,7 @@
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <Optimize>false</Optimize>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <OutputPath>bin\Release\</OutputPath>
@@ -37,6 +53,7 @@
     <PlatformTarget>AnyCPU</PlatformTarget>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="System" />
@@ -60,7 +77,6 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="ColorRamp.cs" />
     <Compile Include="Evaluator.cs" />
     <Compile Include="Exts.cs" />
     <Compile Include="FieldLoader.cs" />
@@ -68,6 +84,7 @@
     <Compile Include="FileFormats\Blast.cs" />
     <Compile Include="FileFormats\Blowfish.cs" />
     <Compile Include="FileFormats\BlowfishKeyProvider.cs" />
+    <Compile Include="FileFormats\CRC32.cs" />
     <Compile Include="FileFormats\Format2.cs" />
     <Compile Include="FileFormats\Format40.cs" />
     <Compile Include="FileFormats\Format80.cs" />
@@ -115,6 +132,37 @@
     <Compile Include="Support\Timer.cs" />
     <Compile Include="Thirdparty\Random.cs" />
     <Compile Include="TypeDictionary.cs" />
+    <Compile Include="WPos.cs" />
+    <Compile Include="WVec.cs" />
+    <Compile Include="WAngle.cs" />
+    <Compile Include="WRot.cs" />
+    <Compile Include="WRange.cs" />
+    <Compile Include="HSLColor.cs" />
+    <Compile Include="Graphics\ShpTSReader.cs" />
+    <Compile Include="FileFormats\XccLocalDatabase.cs" />
+    <Compile Include="FileFormats\XccGlobalDatabase.cs" />
+    <Compile Include="Graphics\VxlReader.cs" />
+    <Compile Include="Graphics\HvaReader.cs" />
+    <Compile Include="StreamExts.cs" />
+    <Compile Include="FileFormats\WavLoader.cs" />
+    <Compile Include="Filesystem\D2kSoundResources.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <BootstrapperPackage Include="Microsoft.Net.Client.3.5">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1 Client Profile</ProductName>
+      <Install>false</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1</ProductName>
+      <Install>true</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Windows.Installer.3.1">
+      <Visible>False</Visible>
+      <ProductName>Windows Installer 3.1</ProductName>
+      <Install>true</Install>
+    </BootstrapperPackage>
   </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
@@ -124,4 +172,4 @@
   <Target Name="AfterBuild">
   </Target>
   -->
-</Project>
+</Project>

OpenRA.FileFormats/PackageEntry.cs

@@ -1,6 +1,6 @@
 #region Copyright & License Information
 /*
- * Copyright 2007-2011 The OpenRA Developers (see AUTHORS)
+ * Copyright 2007-2013 The OpenRA Developers (see AUTHORS)
  * This file is part of OpenRA, which is free software. It is made
  * available to you under the terms of the GNU General Public License
  * as published by the Free Software Foundation. For more information,
@@ -8,19 +8,21 @@
  */
 #endregion
 
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Text;
 
 namespace OpenRA.FileFormats
 {
+	public enum PackageHashType { Classic, CRC32 }
+
 	public class PackageEntry
 	{
 		public readonly uint Hash;
 		public readonly uint Offset;
 		public readonly uint Length;
 
-
 		public PackageEntry(uint hash, uint offset, uint length)
 		{
 			Hash = hash;
@@ -28,11 +30,11 @@ namespace OpenRA.FileFormats
 			Length = length;
 		}
 
-		public PackageEntry(BinaryReader r)
+		public PackageEntry(Stream s)
 		{
-			Hash = r.ReadUInt32();
-			Offset = r.ReadUInt32();
-			Length = r.ReadUInt32();
+			Hash = s.ReadUInt32();
+			Offset = s.ReadUInt32();
+			Length = s.ReadUInt32();
 		}
 
 		public void Write(BinaryWriter w)
@@ -46,38 +48,60 @@ namespace OpenRA.FileFormats
 		{
 			string filename;
 			if (Names.TryGetValue(Hash, out filename))
-				return string.Format("{0} - offset 0x{1:x8} - length 0x{2:x8}", filename, Offset, Length);
+				return "{0} - offset 0x{1:x8} - length 0x{2:x8}".F(filename, Offset, Length);
 			else
-				return string.Format("0x{0:x8} - offset 0x{1:x8} - length 0x{2:x8}", Hash, Offset, Length);
+				return "0x{0:x8} - offset 0x{1:x8} - length 0x{2:x8}".F(Hash, Offset, Length);
 		}
 
-		public static uint HashFilename(string name)
+		public static uint HashFilename(string name, PackageHashType type)
 		{
-			if (name.Length > 12)
-				name = name.Substring(0, 12);
+			switch(type)
+			{
+			case PackageHashType.Classic:
+				{
+					name = name.ToUpperInvariant();
+					if (name.Length % 4 != 0)
+						name = name.PadRight(name.Length + (4 - name.Length % 4), '\0');
 
-			name = name.ToUpperInvariant();
-			if (name.Length % 4 != 0)
-				name = name.PadRight(name.Length + (4 - name.Length % 4), '\0');
+					MemoryStream ms = new MemoryStream(Encoding.ASCII.GetBytes(name));
+					BinaryReader reader = new BinaryReader(ms);
 
-			MemoryStream ms = new MemoryStream(Encoding.ASCII.GetBytes(name));
-			BinaryReader reader = new BinaryReader(ms);
+					int len = name.Length >> 2;
+					uint result = 0;
 
-			int len = name.Length >> 2;
-			uint result = 0;
+					while (len-- != 0)
+						result = ((result << 1) | (result >> 31)) + reader.ReadUInt32();
 
-			while (len-- != 0)
-				result = ((result << 1) | (result >> 31)) + reader.ReadUInt32();
+					return result;
+				}
 
-			return result;
+			case PackageHashType.CRC32:
+				{
+					name = name.ToUpperInvariant();
+					var l = name.Length;
+					int a = l >> 2;
+					if ((l & 3) != 0)
+					{
+						name += (char)(l - (a << 2));
+						int i = 3 - (l & 3);
+						while (i-- != 0)
+							name += name[a << 2];
+					}
+					return CRC32.Calculate(Encoding.ASCII.GetBytes(name));
+				}
+
+			default: throw new NotImplementedException("Unknown hash type `{0}`".F(type));
+			}
 		}
 
 		static Dictionary<uint, string> Names = new Dictionary<uint,string>();
 
 		public static void AddStandardName(string s)
 		{
-			uint hash = HashFilename(s);
+			uint hash = HashFilename(s, PackageHashType.Classic); // RA1 and TD
 			Names.Add(hash, s);
+			uint crcHash = HashFilename(s, PackageHashType.CRC32); // TS
+			Names.Add(crcHash, s);
 		}
 
 		public const int Size = 12;

OpenRA.FileFormats/Palette.cs

@@ -1,6 +1,6 @@
 #region Copyright & License Information
 /*
- * Copyright 2007-2011 The OpenRA Developers (see AUTHORS)
+ * Copyright 2007-2012 The OpenRA Developers (see AUTHORS)
  * This file is part of OpenRA, which is free software. It is made
  * available to you under the terms of the GNU General Public License
  * as published by the Free Software Foundation. For more information,
@@ -39,7 +39,13 @@ namespace OpenRA.FileFormats
 			get { return colors; }
 		}
 
-		public Palette(Stream s, bool remapTransparent)
+		public void ApplyRemap(IPaletteRemap r)
+		{
+			for(int i = 0; i < 256; i++)
+				colors[i] = (uint)r.GetRemappedColor(Color.FromArgb((int)colors[i]),i).ToArgb();
+		}
+
+		public Palette(Stream s, int[] remapShadow)
 		{
 			colors = new uint[256];
 
@@ -54,20 +60,15 @@ namespace OpenRA.FileFormats
 				}
 			}
 
-			colors[0] = 0;
-			if (remapTransparent)
-			{
-				colors[1] = 178u << 24; // Hack for d2k; may have side effects
-				colors[3] = 178u << 24;
-				colors[4] = 140u << 24;
-			}
+			colors[0] = 0; //convert black background to transparency
+			foreach (int i in remapShadow)
+				colors[i] = 140u << 24;
 		}
 
 		public Palette(Palette p, IPaletteRemap r)
 		{
-			colors = new uint[256];
-			for(int i = 0; i < 256; i++)
-				colors[i] = (uint)r.GetRemappedColor(Color.FromArgb((int)p.colors[i]),i).ToArgb();
+			colors = (uint[])p.colors.Clone();
+			ApplyRemap(r);
 		}
 
 		public Palette(Palette p)
@@ -75,6 +76,13 @@ namespace OpenRA.FileFormats
 			colors = (uint[])p.colors.Clone();
 		}
 
+		public Palette(uint[] data)
+		{
+			if (data.Length != 256)
+				throw new InvalidDataException("Attempting to create palette with incorrect array size");
+			colors = (uint[])data.Clone();
+		}
+
 		public ColorPalette AsSystemPalette()
 		{
 			ColorPalette pal;
@@ -92,12 +100,27 @@ namespace OpenRA.FileFormats
 			return pal;
 		}
 
-		public static Palette Load( string filename, bool remap )
+		public Bitmap AsBitmap()
+        {
+            var b = new Bitmap(256, 1, PixelFormat.Format32bppArgb);
+            var data = b.LockBits(new Rectangle(0, 0, b.Width, b.Height),
+			                      ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);
+            unsafe
+            {
+                uint* c = (uint*)data.Scan0;
+                for (var x = 0; x < 256; x++)
+	                *(c + x) = colors[x];
+            }
+            b.UnlockBits(data);
+			return b;
+        }
+
+		public static Palette Load(string filename, int[] remap)
 		{
 			using(var s = File.OpenRead(filename))
 				return new Palette(s, remap);
 		}
 	}
 
-	public interface IPaletteRemap { Color GetRemappedColor(Color original, int index);	}
+	public interface IPaletteRemap { Color GetRemappedColor(Color original, int index); }
 }

OpenRA.FileFormats/PlayerColorRemap.cs

@@ -8,39 +8,41 @@
  */
 #endregion
 
+using System;
 using System.Collections.Generic;
 using System.Drawing;
 using System.Linq;
 
 namespace OpenRA.FileFormats
 {
-	// TODO: ship this out of here.
-	public enum PaletteFormat { ra, cnc, d2k }
 
 	public class PlayerColorRemap : IPaletteRemap
 	{
 		Dictionary<int, Color> remapColors;
 
-		public PlayerColorRemap(PaletteFormat fmt, ColorRamp c)
+		public static int GetRemapIndex(int[] Ramp, int i)
 		{
-			var c1 = c.GetColor(0);
-			var c2 = c.GetColor(1); /* temptemp: this can be expressed better */
-
-			var baseIndex = (fmt == PaletteFormat.cnc) ? 0xb0 : (fmt == PaletteFormat.d2k) ? 240 : 80;
-			var ramp = (fmt == PaletteFormat.cnc)
-				? new[] { 0, 2, 4, 6, 8, 10, 13, 15, 1, 3, 5, 7, 9, 11, 12, 14 }
-				: new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
-
-			remapColors = ramp.Select((x, i) => Pair.New(baseIndex + i, ColorLerp(x / 16f, c1, c2)))
-				.ToDictionary(u => u.First, u => u.Second);
+			return Ramp[i];
 		}
 
-		public static Color ColorLerp(float t, Color c1, Color c2)
+		public PlayerColorRemap(int[] Ramp, HSLColor c, float rampFraction)
 		{
-			return Color.FromArgb(255,
-				(int)(t * c2.R + (1 - t) * c1.R),
-				(int)(t * c2.G + (1 - t) * c1.G),
-				(int)(t * c2.B + (1 - t) * c1.B));
+			// Increase luminosity if required to represent the full ramp
+			var rampRange = (byte)((1 - rampFraction)*c.L);
+			var c1 = new HSLColor(c.H, c.S, (byte)Math.Max(rampRange, c.L)).RGB;
+			var c2 = new HSLColor(c.H, c.S, (byte)Math.Max(0, c.L - rampRange)).RGB;
+			var baseIndex = Ramp[0];
+			var RemapRamp = Ramp.Select(r => r - Ramp[0]).ToArray();
+
+			if (Ramp[0] > Ramp[15]) // reversed remapping
+            {
+				baseIndex = Ramp[15];
+				for (var i = 15; i > 0; i--)
+					RemapRamp = Ramp.Select(r => r - Ramp[15]).ToArray();
+			}
+			
+			remapColors = RemapRamp.Select((x, i) => Pair.New(baseIndex + i, Exts.ColorLerp(x / 16f, c1, c2)))
+				.ToDictionary(u => u.First, u => u.Second);
 		}
 
 		public Color GetRemappedColor(Color original, int index)

OpenRA.FileFormats/Primitives/ActionQueue.cs

@@ -56,7 +56,7 @@ namespace OpenRA.FileFormats
 
 		public int CompareTo(DelayedAction other)
 		{
-			return Math.Sign(Time - other.Time);
+			return Time.CompareTo(other.Time);
 		}
 	}
 }

OpenRA.FileFormats/Primitives/Set.cs

@@ -12,7 +12,7 @@ using System;
 using System.Collections;
 using System.Collections.Generic;
 
-namespace OpenRA.Collections
+namespace OpenRA.FileFormats
 {
 	public class Set<T> : IEnumerable<T>
 	{
@@ -44,5 +44,13 @@ namespace OpenRA.Collections
 		{
 			return GetEnumerator();
 		}
+
+		public bool Contains( T obj ) { return data.ContainsKey(obj); }
+
+		public Set( params T[] ts )
+		{
+			foreach( var t in ts )
+				Add(t);
+		}
 	}
 }

OpenRA.FileFormats/Primitives/float2.cs

@@ -92,7 +92,7 @@ namespace OpenRA
 		public static float Dot(float2 a, float2 b) { return a.X * b.X + a.Y * b.Y; }
 		public float2 Round() { return new float2((float)Math.Round(X), (float)Math.Round(Y)); }
 
-		public override string ToString() { return string.Format("({0},{1})", X, Y); }
+		public override string ToString() { return "({0},{1})".F(X, Y); }
 		public int2 ToInt2() { return new int2((int)X, (int)Y); }
 
 		public static float2 Max(float2 a, float2 b) { return new float2(Math.Max(a.X, b.X), Math.Max(a.Y, b.Y)); }
@@ -101,4 +101,18 @@ namespace OpenRA
 		public float LengthSquared { get { return X * X + Y * Y; } }
 		public float Length { get { return (float)Math.Sqrt(LengthSquared); } }
 	}
+
+	public class EWMA
+	{
+		readonly float animRate;
+		float? value;
+
+		public EWMA(float animRate) { this.animRate = animRate; }
+
+		public float Update(float newValue)
+		{
+			value = float2.Lerp(value ?? newValue, newValue, animRate);
+			return value.Value;
+		}
+	}
 }

OpenRA.FileFormats/Primitives/int2.cs

@@ -55,7 +55,7 @@ namespace OpenRA
 		public PointF ToPointF() { return new PointF(X, Y); }
 		public float2 ToFloat2() { return new float2(X, Y); }
 
-		public override string ToString() { return string.Format("{0},{1}", X, Y); }
+		public override string ToString() { return "{0},{1}".F(X, Y); }
 
 		// Change endianness of a uint32
 		public static uint Swap(uint orig)

OpenRA.FileFormats/Settings.StyleCop

@@ -0,0 +1,334 @@
+<StyleCopSettings Version="105">
+  <Analyzers>
+    <Analyzer AnalyzerId="StyleCop.CSharp.DocumentationRules">
+      <Rules>
+        <Rule Name="ElementsMustBeDocumented">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="PartialElementsMustBeDocumented">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="EnumerationItemsMustBeDocumented">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="DocumentationMustContainValidXml">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementDocumentationMustHaveSummary">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="PartialElementDocumentationMustHaveSummary">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementDocumentationMustHaveSummaryText">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="PartialElementDocumentationMustHaveSummaryText">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementDocumentationMustNotHaveDefaultSummary">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementParametersMustBeDocumented">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementParameterDocumentationMustMatchElementParameters">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementParameterDocumentationMustDeclareParameterName">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementParameterDocumentationMustHaveText">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementReturnValueMustBeDocumented">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementReturnValueDocumentationMustHaveText">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="VoidReturnValueMustNotBeDocumented">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="GenericTypeParametersMustBeDocumented">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="GenericTypeParametersMustBeDocumentedPartialClass">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="GenericTypeParameterDocumentationMustMatchTypeParameters">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="GenericTypeParameterDocumentationMustDeclareParameterName">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="GenericTypeParameterDocumentationMustHaveText">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="PropertySummaryDocumentationMustMatchAccessors">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="PropertySummaryDocumentationMustOmitSetAccessorWithRestrictedAccess">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementDocumentationMustNotBeCopiedAndPasted">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="SingleLineCommentsMustNotUseDocumentationStyleSlashes">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="DocumentationTextMustNotBeEmpty">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="DocumentationTextMustContainWhitespace">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="DocumentationMustMeetCharacterPercentage">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ConstructorSummaryDocumentationMustBeginWithStandardText">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="DestructorSummaryDocumentationMustBeginWithStandardText">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="DocumentationHeadersMustNotContainBlankLines">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="IncludedDocumentationXPathDoesNotExist">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="IncludeNodeDoesNotContainValidFileAndPath">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="InheritDocMustBeUsedWithInheritingClass">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementDocumentationMustBeSpelledCorrectly">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="FileMustHaveHeader">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="FileHeaderMustShowCopyright">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="FileHeaderMustHaveCopyrightText">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="FileHeaderMustContainFileName">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="FileHeaderFileNameDocumentationMustMatchFileName">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="FileHeaderMustHaveValidCompanyText">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="FileHeaderFileNameDocumentationMustMatchTypeName">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+      </Rules>
+      <AnalyzerSettings />
+    </Analyzer>
+    <Analyzer AnalyzerId="StyleCop.CSharp.SpacingRules">
+      <Rules>
+        <Rule Name="TabsMustNotBeUsed">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+      </Rules>
+      <AnalyzerSettings />
+    </Analyzer>
+    <Analyzer AnalyzerId="StyleCop.CSharp.LayoutRules">
+      <Rules>
+        <Rule Name="CurlyBracketsForMultiLineStatementsMustNotShareLine">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="StatementMustNotBeOnSingleLine">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementMustNotBeOnSingleLine">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="CurlyBracketsMustNotBeOmitted">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementsMustBeSeparatedByBlankLine">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+      </Rules>
+      <AnalyzerSettings />
+    </Analyzer>
+    <Analyzer AnalyzerId="StyleCop.CSharp.OrderingRules">
+      <Rules>
+        <Rule Name="UsingDirectivesMustBePlacedWithinNamespace">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementsMustAppearInTheCorrectOrder">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementsMustBeOrderedByAccess">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+      </Rules>
+      <AnalyzerSettings />
+    </Analyzer>
+    <Analyzer AnalyzerId="StyleCop.CSharp.ReadabilityRules">
+      <Rules>
+        <Rule Name="CodeMustNotContainMultipleStatementsOnOneLine">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="UseStringEmptyForEmptyStrings">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="PrefixLocalCallsWithThis">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="PrefixCallsCorrectly">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ParametersMustBeOnSameLineOrSeparateLines">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+      </Rules>
+      <AnalyzerSettings />
+    </Analyzer>
+    <Analyzer AnalyzerId="StyleCop.CSharp.MaintainabilityRules">
+      <Rules>
+        <Rule Name="AccessModifierMustBeDeclared">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="FieldsMustBePrivate">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="FileMayOnlyContainASingleClass">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ArithmeticExpressionsMustDeclarePrecedence">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+      </Rules>
+      <AnalyzerSettings />
+    </Analyzer>
+  </Analyzers>
+</StyleCopSettings>

OpenRA.FileFormats/StreamExts.cs

@@ -0,0 +1,138 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2013 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation. For more information,
+ * see COPYING.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+
+namespace OpenRA
+{
+	public static class StreamExts
+	{
+		public static byte[] ReadBytes(this Stream s, int count)
+		{
+			if (count < 0)
+				throw new ArgumentOutOfRangeException("count", "Non-negative number required.");
+
+			var buf = new byte[count];
+			if (s.Read(buf, 0, count) < count)
+				throw new EndOfStreamException();
+
+			return buf;
+		}
+
+		public static int Peek(this Stream s)
+		{
+			var buf = new byte[1];
+			if (s.Read(buf, 0, 1) == 0)
+				return -1;
+
+			s.Seek(s.Position - 1, SeekOrigin.Begin);
+			return buf[0];
+		}
+
+		public static byte ReadUInt8(this Stream s)
+		{
+			return s.ReadBytes(1)[0];
+		}
+
+		public static ushort ReadUInt16(this Stream s)
+		{
+			return BitConverter.ToUInt16(s.ReadBytes(2), 0);
+		}
+
+		public static short ReadInt16(this Stream s)
+		{
+			return BitConverter.ToInt16(s.ReadBytes(2), 0);
+		}
+
+		public static uint ReadUInt32(this Stream s)
+		{
+			return BitConverter.ToUInt32(s.ReadBytes(4), 0);
+		}
+
+		public static int ReadInt32(this Stream s)
+		{
+			return BitConverter.ToInt32(s.ReadBytes(4), 0);
+		}
+
+		public static float ReadFloat(this Stream s)
+		{
+			return BitConverter.ToSingle(s.ReadBytes(4), 0);
+		}
+
+		public static double ReadDouble(this Stream s)
+		{
+			return BitConverter.ToDouble(s.ReadBytes(8), 0);
+		}
+
+		public static string ReadASCII(this Stream s, int length)
+		{
+			return new string(Encoding.ASCII.GetChars(s.ReadBytes(length)));
+		}
+
+		public static string ReadASCIIZ(this Stream s)
+		{
+			var bytes = new List<byte>();
+			var buf = new byte[1];
+
+			for (;;)
+			{
+				if (s.Read(buf, 0, 1) < 1)
+					throw new EndOfStreamException();
+
+				if (buf[0] == 0)
+					break;
+
+				bytes.Add(buf[0]);
+			}
+
+			return new string(Encoding.ASCII.GetChars(bytes.ToArray()));
+		}
+
+		public static string ReadAllText(this Stream s)
+		{
+			using (s)
+			using (var sr = new StreamReader(s))
+				return sr.ReadToEnd();
+		}
+
+		public static byte[] ReadAllBytes(this Stream s)
+		{
+			using (s)
+			{
+				var data = new byte[s.Length - s.Position];
+				s.Read(data, 0, data.Length);
+				return data;
+			}
+		}
+
+		public static void Write(this Stream s, byte[] data)
+		{
+			s.Write(data, 0, data.Length);
+		}
+
+		public static IEnumerable<string> ReadAllLines(this Stream s)
+		{
+			using (var sr = new StreamReader(s))
+			{
+				for (;;)
+				{
+					var line = sr.ReadLine();
+					if (line == null)
+						yield break;
+					else
+						yield return line;
+				}
+			}
+		}
+	}
+}

OpenRA.FileFormats/Support/Log.cs

@@ -26,7 +26,7 @@ namespace OpenRA
 	public static class Log
 	{
 		static string LogPathPrefix = Environment.GetFolderPath(Environment.SpecialFolder.Personal) + Path.DirectorySeparatorChar;
-		static Dictionary<string, ChannelInfo> channels = new Dictionary<string,ChannelInfo>();
+		public static readonly Dictionary<string, ChannelInfo> Channels = new Dictionary<string, ChannelInfo>();
 
 		public static string LogPath
 		{
@@ -47,7 +47,7 @@ namespace OpenRA
 
 		public static void AddChannel(string channelName, string baseFilename)
 		{
-			if (channels.ContainsKey(channelName)) return;
+			if (Channels.ContainsKey(channelName)) return;
 
 			foreach (var filename in FilenamesForChannel(channelName, baseFilename))
 				try
@@ -55,7 +55,7 @@ namespace OpenRA
 					var writer = File.CreateText(filename);
 					writer.AutoFlush = true;
 
-					channels.Add(channelName,
+					Channels.Add(channelName,
 						new ChannelInfo()
 						{
 							Filename = filename,
@@ -70,7 +70,7 @@ namespace OpenRA
 		public static void Write(string channel, string format, params object[] args)
 		{
 			ChannelInfo info;
-			if (!channels.TryGetValue(channel, out info))
+			if (!Channels.TryGetValue(channel, out info))
 				throw new Exception("Tried logging to non-existant channel " + channel);
 
 			info.Writer.WriteLine(format, args);

OpenRA.FileFormats/Thirdparty/Random.cs

@@ -20,6 +20,7 @@ namespace OpenRA.Thirdparty
 		int index = 0;
 
 		public int Last;
+		public int TotalCount = 0;
 
 		public Random() : this(Environment.TickCount) { }
 
@@ -41,13 +42,14 @@ namespace OpenRA.Thirdparty
 			y ^= y >> 18;
 
 			index = (index + 1) % 624;
+			TotalCount++;
 			Last = (int)(y % int.MaxValue);
 			return Last;
 		}
 
 		public int Next(int low, int high) { return low + Next() % (high - low); }
 		public int Next(int high) { return Next() % high; }
-		public double NextDouble() { return Math.Abs(Next() / (double)0x7fffffff); }
+		public float NextFloat() { return Math.Abs(Next() / (float)0x7fffffff); }
 
 		void Generate()
 		{

OpenRA.FileFormats/TypeDictionary.cs

@@ -48,17 +48,17 @@ namespace OpenRA.FileFormats
 
 		public bool Contains<T>()
 		{
-			return dataSingular.ContainsKey( typeof( T ) ) || dataMultiple.ContainsKey( typeof( T ) );
+			return dataSingular.ContainsKey(typeof(T)) || dataMultiple.ContainsKey(typeof(T));
 		}
 
 		public T Get<T>()
 		{
-			if( dataMultiple.ContainsKey( typeof( T ) ) )
-				throw new InvalidOperationException( string.Format( "TypeDictionary contains multiple instance of type `{0}`", typeof( T ) ) );
+			if (dataMultiple.ContainsKey(typeof(T)))
+				throw new InvalidOperationException("TypeDictionary contains multiple instance of type `{0}`".F(typeof(T)));
 
 			object ret;
-			if( !dataSingular.TryGetValue( typeof( T ), out ret ) )
-				throw new InvalidOperationException(string.Format("TypeDictionary does not contain instance of type `{0}`", typeof(T)));
+			if (!dataSingular.TryGetValue(typeof(T), out ret))
+				throw new InvalidOperationException("TypeDictionary does not contain instance of type `{0}`".F(typeof(T)));
 			return (T)ret;
 		}
 
@@ -69,11 +69,11 @@ namespace OpenRA.FileFormats
 
 		public object GetOrDefault(Type t)
 		{
-			if( dataMultiple.ContainsKey(t) )
-				throw new InvalidOperationException( string.Format( "TypeDictionary contains multiple instance of type `{0}`", t ) );
+			if (dataMultiple.ContainsKey(t))
+				throw new InvalidOperationException("TypeDictionary contains multiple instances of type `{0}`".F(t));
 
 			object ret;
-			if( !dataSingular.TryGetValue(t, out ret ) )
+			if (!dataSingular.TryGetValue(t, out ret))
 				return null;
 			return ret;
 		}

OpenRA.FileFormats/WAngle.cs

@@ -0,0 +1,123 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2013 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation. For more information,
+ * see COPYING.
+ */
+#endregion
+
+using System;
+using System.Drawing;
+
+namespace OpenRA
+{
+	/// <summary>
+	/// 1D angle - 1024 units = 360 degrees.
+	/// </summary>
+	public struct WAngle
+	{
+		public readonly int Angle;
+
+		public WAngle(int a)
+		{
+			Angle = a % 1024;
+			if (Angle < 0)
+				Angle += 1024;
+		}
+		public static readonly WAngle Zero = new WAngle(0);
+		public static WAngle FromFacing(int facing) { return new WAngle(facing*4); }
+		public static WAngle FromDegrees(int degrees) { return new WAngle(degrees*1024/360); }
+		public static WAngle operator +(WAngle a, WAngle b) { return new WAngle(a.Angle + b.Angle); }
+		public static WAngle operator -(WAngle a, WAngle b) { return new WAngle(a.Angle - b.Angle); }
+		public static WAngle operator -(WAngle a) { return new WAngle(-a.Angle); }
+
+		public static bool operator ==(WAngle me, WAngle other) { return (me.Angle == other.Angle); }
+		public static bool operator !=(WAngle me, WAngle other) { return !(me == other); }
+
+		public override int GetHashCode() { return Angle.GetHashCode(); }
+
+		public override bool Equals(object obj)
+		{
+			if (obj == null)
+				return false;
+
+			WAngle o = (WAngle)obj;
+			return o == this;
+		}
+
+		public int Sin() { return new WAngle(Angle - 256).Cos(); }
+
+		public int Cos()
+		{
+			if (Angle <= 256)
+				return CosineTable[Angle];
+			if (Angle <= 512)
+				return -CosineTable[512 - Angle];
+			return -new WAngle(Angle - 512).Cos();
+		}
+
+		public int Tan()
+		{
+			if (Angle <= 256)
+				return TanTable[Angle];
+			if (Angle <= 512)
+				return -TanTable[512 - Angle];
+			return new WAngle(Angle - 512).Tan();
+		}
+
+		// Must not be used outside rendering code
+		public float RendererRadians() { return (float)(Angle * Math.PI / 512f); }
+		public float RendererDegrees() { return Angle * 0.3515625f; }
+
+		public override string ToString() { return "{0}".F(Angle); }
+
+		static int[] CosineTable =
+		{
+			1024, 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1022, 1022, 1022, 1021,
+			1021, 1020, 1020, 1019, 1019, 1018, 1017, 1017, 1016, 1015, 1014, 1013,
+			1012, 1011, 1010, 1009, 1008, 1007, 1006, 1005, 1004, 1003, 1001, 1000,
+			999, 997, 996, 994, 993, 991, 990, 988, 986, 985, 983, 981, 979, 978,
+			976, 974, 972, 970, 968, 966, 964, 962, 959, 957, 955, 953, 950, 948,
+			946, 943, 941, 938, 936, 933, 930, 928, 925, 922, 920, 917, 914, 911,
+			908, 906, 903, 900, 897, 894, 890, 887, 884, 881, 878, 875, 871, 868,
+			865, 861, 858, 854, 851, 847, 844, 840, 837, 833, 829, 826, 822, 818,
+			814, 811, 807, 803, 799, 795, 791, 787, 783, 779, 775, 771, 767, 762,
+			758, 754, 750, 745, 741, 737, 732, 728, 724, 719, 715, 710, 706, 701,
+			696, 692, 687, 683, 678, 673, 668, 664, 659, 654, 649, 644, 639, 634,
+			629, 625, 620, 615, 609, 604, 599, 594, 589, 584, 579, 574, 568, 563,
+			558, 553, 547, 542, 537, 531, 526, 521, 515, 510, 504, 499, 493, 488,
+			482, 477, 471, 466, 460, 454, 449, 443, 437, 432, 426, 420, 414, 409,
+			403, 397, 391, 386, 380, 374, 368, 362, 356, 350, 344, 339, 333, 327,
+			321, 315, 309, 303, 297, 291, 285, 279, 273, 267, 260, 254, 248, 242,
+			236, 230, 224, 218, 212, 205, 199, 193, 187, 181, 175, 168, 162, 156,
+			150, 144, 137, 131, 125, 119, 112, 106, 100, 94, 87, 81, 75, 69, 62,
+			56, 50, 43, 37, 31, 25, 18, 12, 6, 0
+		};
+
+		static int[] TanTable =
+		{
+			0, 6, 12, 18, 25, 31, 37, 44, 50, 56, 62, 69, 75, 81, 88, 94, 100, 107,
+			113, 119, 126, 132, 139, 145, 151, 158, 164, 171, 177, 184, 190, 197,
+			203, 210, 216, 223, 229, 236, 243, 249, 256, 263, 269, 276, 283, 290,
+			296, 303, 310, 317, 324, 331, 338, 345, 352, 359, 366, 373, 380, 387,
+			395, 402, 409, 416, 424, 431, 438, 446, 453, 461, 469, 476, 484, 492,
+			499, 507, 515, 523, 531, 539, 547, 555, 563, 571, 580, 588, 596, 605,
+			613, 622, 630, 639, 648, 657, 666, 675, 684, 693, 702, 711, 721, 730,
+			740, 749, 759, 769, 779, 789, 799, 809, 819, 829, 840, 850, 861, 872,
+			883, 894, 905, 916, 928, 939, 951, 963, 974, 986, 999, 1011, 1023, 1036,
+			1049, 1062, 1075, 1088, 1102, 1115, 1129, 1143, 1158, 1172, 1187, 1201,
+			1216, 1232, 1247, 1263, 1279, 1295, 1312, 1328, 1345, 1363, 1380, 1398,
+			1416, 1435, 1453, 1473, 1492, 1512, 1532, 1553, 1574, 1595, 1617, 1639,
+			1661, 1684, 1708, 1732, 1756, 1782, 1807, 1833, 1860, 1887, 1915, 1944,
+			1973, 2003, 2034, 2065, 2098, 2131, 2165, 2199, 2235, 2272, 2310, 2348,
+			2388, 2429, 2472, 2515, 2560, 2606, 2654, 2703, 2754, 2807, 2861, 2918,
+			2976, 3036, 3099, 3164, 3232, 3302, 3375, 3451, 3531, 3613, 3700, 3790,
+			3885, 3984, 4088, 4197, 4311, 4432, 4560, 4694, 4836, 4987, 5147, 5318,
+			5499, 5693, 5901, 6124, 6364, 6622, 6903, 7207, 7539, 7902, 8302, 8743,
+			9233, 9781, 10396, 11094, 11891, 12810, 13882, 15148, 16667, 18524, 20843,
+			23826, 27801, 33366, 41713, 55622, 83438, 166883, int.MaxValue
+		};
+	}
+}

OpenRA.FileFormats/WPos.cs

@@ -0,0 +1,88 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2013 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation. For more information,
+ * see COPYING.
+ */
+#endregion
+
+using System;
+using System.Drawing;
+
+namespace OpenRA
+{
+	/// <summary>
+	/// 3d World position - 1024 units = 1 cell.
+	/// </summary>
+	public struct WPos
+	{
+		public readonly int X, Y, Z;
+
+		public WPos(int x, int y, int z) { X = x; Y = y; Z = z; }
+		public WPos(WRange x, WRange y, WRange z) { X = x.Range; Y = y.Range; Z = z.Range; }
+
+		public static readonly WPos Zero = new WPos(0, 0, 0);
+
+		public static explicit operator WVec(WPos a) { return new WVec(a.X, a.Y, a.Z); }
+
+		public static WPos operator +(WPos a, WVec b) { return new WPos(a.X + b.X, a.Y + b.Y, a.Z + b.Z); }
+		public static WPos operator -(WPos a, WVec b) { return new WPos(a.X - b.X, a.Y - b.Y, a.Z - b.Z); }
+		public static WVec operator -(WPos a, WPos b) { return new WVec(a.X - b.X, a.Y - b.Y, a.Z - b.Z); }
+
+		public static bool operator ==(WPos me, WPos other) { return (me.X == other.X && me.Y == other.Y && me.Z == other.Z); }
+		public static bool operator !=(WPos me, WPos other) { return !(me == other); }
+
+		public static WPos Lerp(WPos a, WPos b, int mul, int div) { return a + (b - a) * mul / div; }
+
+		public static WPos LerpQuadratic(WPos a, WPos b, WAngle pitch, int mul, int div)
+		{
+			// Start with a linear lerp between the points
+			var ret = Lerp(a, b, mul, div);
+
+			if (pitch.Angle == 0)
+				return ret;
+
+			// Add an additional quadratic variation to height
+			// Uses fp to avoid integer overflow
+			var offset = (int)((float)((float)(b - a).Length*pitch.Tan()*mul*(div - mul)) / (float)(1024*div*div));
+			return new WPos(ret.X, ret.Y, ret.Z + offset);
+		}
+
+		public static WPos Average(params WPos[] list)
+		{
+			if (list == null || list.Length == 0)
+				return WPos.Zero;
+
+			var x = 0;
+			var y = 0;
+			var z = 0;
+			foreach(var pos in list)
+			{
+				x += pos.X;
+				y += pos.Y;
+				z += pos.Z;
+			}
+
+			x /= list.Length;
+			y /= list.Length;
+			z /= list.Length;
+
+			return new WPos(x,y,z);
+		}
+
+		public override int GetHashCode() { return X.GetHashCode() ^ Y.GetHashCode() ^ Z.GetHashCode(); }
+
+		public override bool Equals(object obj)
+		{
+			if (obj == null)
+				return false;
+
+			WPos o = (WPos)obj;
+			return o == this;
+		}
+
+		public override string ToString() { return "{0},{1},{2}".F(X, Y, Z); }
+	}
+}

OpenRA.FileFormats/WRange.cs

@@ -0,0 +1,73 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2013 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation. For more information,
+ * see COPYING.
+ */
+#endregion
+
+using System;
+using System.Drawing;
+
+namespace OpenRA
+{
+	/// <summary>
+	/// 1d world distance - 1024 units = 1 cell.
+	/// </summary>
+	public struct WRange
+	{
+		public readonly int Range;
+
+		public WRange(int r) { Range = r; }
+		public static readonly WRange Zero = new WRange(0);
+		public static WRange FromCells(int cells) { return new WRange(1024*cells); }
+
+		public static WRange operator +(WRange a, WRange b) { return new WRange(a.Range + b.Range); }
+		public static WRange operator -(WRange a, WRange b) { return new WRange(a.Range - b.Range); }
+		public static WRange operator -(WRange a) { return new WRange(-a.Range); }
+
+		public static bool operator ==(WRange me, WRange other) { return (me.Range == other.Range); }
+		public static bool operator !=(WRange me, WRange other) { return !(me == other); }
+
+		public static bool TryParse(string s, out WRange result)
+		{
+			s = s.ToLowerInvariant();
+			var components = s.Split('c');
+			int cell = 0;
+			int subcell = 0;
+			result = WRange.Zero;
+
+			switch (components.Length)
+			{
+			case 2:
+				if (!int.TryParse(components[0], out cell) ||
+				    !int.TryParse(components[1], out subcell))
+					return false;
+				break;
+			case 1:
+				if (!int.TryParse(components[0], out subcell))
+					return false;
+				break;
+			default: return false;
+			}
+
+			result = new WRange(1024*cell + subcell);
+			return true;
+		}
+
+		public override int GetHashCode() { return Range.GetHashCode(); }
+
+		public override bool Equals(object obj)
+		{
+			if (obj == null)
+				return false;
+
+			WRange o = (WRange)obj;
+			return o == this;
+		}
+
+		public override string ToString() { return "{0}".F(Range); }
+	}
+}

OpenRA.FileFormats/WRot.cs

@@ -0,0 +1,109 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2013 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation. For more information,
+ * see COPYING.
+ */
+#endregion
+
+using System;
+using System.Drawing;
+
+namespace OpenRA
+{
+	/// <summary>
+	/// 3d World rotation.
+	/// </summary>
+	public struct WRot
+	{
+		public readonly WAngle Roll, Pitch, Yaw;
+
+		public WRot(WAngle roll, WAngle pitch, WAngle yaw) { Roll = roll; Pitch = pitch; Yaw = yaw; }
+		public static readonly WRot Zero = new WRot(WAngle.Zero, WAngle.Zero, WAngle.Zero);
+
+		public static WRot FromFacing(int facing) { return new WRot(WAngle.Zero, WAngle.Zero, WAngle.FromFacing(facing)); }
+		public static WRot FromYaw(WAngle yaw) { return new WRot(WAngle.Zero, WAngle.Zero, yaw); }
+		public static WRot operator +(WRot a, WRot b) { return new WRot(a.Roll + b.Roll, a.Pitch + b.Pitch, a.Yaw + b.Yaw); }
+		public static WRot operator -(WRot a, WRot b) { return new WRot(a.Roll - b.Roll, a.Pitch - b.Pitch, a.Yaw - b.Yaw); }
+		public static WRot operator -(WRot a) { return new WRot(-a.Roll, -a.Pitch, -a.Yaw); }
+
+		public static bool operator ==(WRot me, WRot other) { return (me.Roll == other.Roll &&
+			me.Pitch == other.Pitch && me.Yaw == other.Yaw); }
+		public static bool operator !=(WRot me, WRot other) { return !(me == other); }
+
+		public WRot WithYaw(WAngle yaw)
+		{
+			return new WRot(Roll, Pitch, yaw);
+		}
+
+		public int[] AsQuarternion()
+		{
+			// Angles increase clockwise
+			var r = new WAngle(-Roll.Angle / 2);
+			var p = new WAngle(-Pitch.Angle / 2);
+			var y = new WAngle(-Yaw.Angle / 2);
+			var cr = (long)r.Cos();
+			var sr = (long)r.Sin();
+			var cp = (long)p.Cos();
+			var sp = (long)p.Sin();
+			var cy = (long)y.Cos();
+			var sy = (long)y.Sin();
+
+			// Normalized to 1024 == 1.0
+			return new int[4]
+			{
+				(int)((sr*cp*cy - cr*sp*sy) / 1048576), // x
+				(int)((cr*sp*cy + sr*cp*sy) / 1048576), // y
+				(int)((cr*cp*sy - sr*sp*cy) / 1048576), // z
+				(int)((cr*cp*cy + sr*sp*sy) / 1048576)  // w
+			};
+		}
+
+		public int[] AsMatrix()
+		{
+			var q = AsQuarternion();
+
+			// Theoretically 1024**2, but may differ slightly due to rounding
+			var lsq = q[0]*q[0] + q[1]*q[1] + q[2]*q[2] + q[3]*q[3];
+
+			// Quarternion components use 10 bits, so there's no risk of overflow
+			var mtx = new int[16];
+			mtx[0] = lsq - 2*(q[1]*q[1] + q[2]*q[2]);
+			mtx[1] = 2*(q[0]*q[1] + q[2]*q[3]);
+			mtx[2] = 2*(q[0]*q[2] - q[1]*q[3]);
+			mtx[3] = 0;
+
+			mtx[4] = 2*(q[0]*q[1] - q[2]*q[3]);
+			mtx[5] = lsq - 2*(q[0]*q[0] + q[2]*q[2]);
+			mtx[6] = 2*(q[1]*q[2] + q[0]*q[3]);
+			mtx[7] = 0;
+
+			mtx[8] = 2*(q[0]*q[2] + q[1]*q[3]);
+			mtx[9] = 2*(q[1]*q[2] - q[0]*q[3]);
+			mtx[10] = lsq - 2*(q[0]*q[0] + q[1]*q[1]);
+			mtx[11] = 0;
+
+			mtx[12] = 0;
+			mtx[13] = 0;
+			mtx[14] = 0;
+			mtx[15] = lsq;
+
+			return mtx;
+		}
+
+		public override int GetHashCode() { return Roll.GetHashCode() ^ Pitch.GetHashCode() ^ Yaw.GetHashCode(); }
+
+		public override bool Equals(object obj)
+		{
+			if (obj == null)
+				return false;
+
+			WRot o = (WRot)obj;
+			return o == this;
+		}
+
+		public override string ToString() { return "{0},{1},{2}".F(Roll, Pitch, Yaw); }
+	}
+}

OpenRA.FileFormats/WVec.cs

@@ -0,0 +1,83 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2013 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation. For more information,
+ * see COPYING.
+ */
+#endregion
+
+using System;
+using System.Drawing;
+
+namespace OpenRA
+{
+	/// <summary>
+	/// 3d World vector for describing offsets and distances - 1024 units = 1 cell.
+	/// </summary>
+	public struct WVec
+	{
+		public readonly int X, Y, Z;
+
+		public WVec(int x, int y, int z) { X = x; Y = y; Z = z; }
+		public WVec(WRange x, WRange y, WRange z) { X = x.Range; Y = y.Range; Z = z.Range; }
+
+		public static readonly WVec Zero = new WVec(0, 0, 0);
+
+		public static WVec operator +(WVec a, WVec b) { return new WVec(a.X + b.X, a.Y + b.Y, a.Z + b.Z); }
+		public static WVec operator -(WVec a, WVec b) { return new WVec(a.X - b.X, a.Y - b.Y, a.Z - b.Z); }
+		public static WVec operator -(WVec a) { return new WVec(-a.X, -a.Y, -a.Z); }
+		public static WVec operator /(WVec a, int b) { return new WVec(a.X / b, a.Y / b, a.Z / b); }
+		public static WVec operator *(int a, WVec b) { return new WVec(a * b.X, a * b.Y, a * b.Z); }
+		public static WVec operator *(WVec a, int b) { return b*a; }
+
+		public static bool operator ==(WVec me, WVec other) { return (me.X == other.X && me.Y == other.Y && me.Z == other.Z); }
+		public static bool operator !=(WVec me, WVec other) { return !(me == other); }
+
+		public static int Dot(WVec a, WVec b) { return a.X * b.X + a.Y * b.Y + a.Z * b.Z; }
+		public int LengthSquared { get { return X * X + Y * Y + Z * Z; } }
+		public int Length { get { return (int)Math.Sqrt(LengthSquared); } }
+
+		public WVec Rotate(WRot rot)
+		{
+			var mtx = rot.AsMatrix();
+			var lx = (long)X;
+			var ly = (long)Y;
+			var lz = (long)Z;
+			return new WVec(
+				(int)((lx * mtx[0] + ly*mtx[4] + lz*mtx[8]) / mtx[15]),
+				(int)((lx * mtx[1] + ly*mtx[5] + lz*mtx[9]) / mtx[15]),
+				(int)((lx * mtx[2] + ly*mtx[6] + lz*mtx[10]) / mtx[15]));
+		}
+
+		public static WVec Lerp(WVec a, WVec b, int mul, int div) { return a + (b - a) * mul / div; }
+
+		public static WVec LerpQuadratic(WVec a, WVec b, WAngle pitch, int mul, int div)
+		{
+			// Start with a linear lerp between the points
+			var ret = Lerp(a, b, mul, div);
+
+			if (pitch.Angle == 0)
+				return ret;
+
+			// Add an additional quadratic variation to height
+			// Uses fp to avoid integer overflow
+			var offset = (int)((float)((float)(b - a).Length*pitch.Tan()*mul*(div - mul)) / (float)(1024*div*div));
+			return new WVec(ret.X, ret.Y, ret.Z + offset);
+		}
+
+		public override int GetHashCode() { return X.GetHashCode() ^ Y.GetHashCode() ^ Z.GetHashCode(); }
+
+		public override bool Equals(object obj)
+		{
+			if (obj == null)
+				return false;
+
+			WVec o = (WVec)obj;
+			return o == this;
+		}
+
+		public override string ToString() { return "{0},{1},{2}".F(X, Y, Z); }
+	}
+}

OpenRA.Game/Actor.cs

@@ -13,6 +13,7 @@ using System.Collections.Generic;
 using System.Drawing;
 using System.Linq;
 using OpenRA.FileFormats;
+using OpenRA.Graphics;
 using OpenRA.Traits;
 
 namespace OpenRA
@@ -27,14 +28,16 @@ namespace OpenRA
 		Lazy<IOccupySpace> occupySpace;
 		IHasLocation HasLocation;
 		Lazy<IMove> Move;
+		Lazy<IFacing> Facing;
+
 		public Cached<Rectangle> Bounds;
 		public Cached<Rectangle> ExtendedBounds;
 
 		public IOccupySpace OccupiesSpace { get { return occupySpace.Value; } }
 
-		public int2 Location { get { return occupySpace.Value.TopLeft; } }
+		public CPos Location { get { return occupySpace.Value.TopLeft; } }
 
-		public int2 CenterLocation
+		public PPos CenterLocation
 		{
 			get
 			{
@@ -44,11 +47,30 @@ namespace OpenRA
 			}
 		}
 
-		[Sync]
-		public Player Owner;
+		public WPos CenterPosition
+		{
+			get
+			{
+				var altitude = Move.Value != null ? Move.Value.Altitude : 0;
+				return CenterLocation.ToWPos(altitude);
+			}
+		}
+
+		public WRot Orientation
+		{
+			get
+			{
+				// TODO: Support non-zero pitch/roll in IFacing (IOrientation?)
+				var facing = Facing.Value != null ? Facing.Value.Facing : 0;
+				return new WRot(WAngle.Zero, WAngle.Zero, WAngle.FromFacing(facing));
+			}
+		}
+
+		[Sync] public Player Owner;
 
 		Activity currentActivity;
 		public Group Group;
+		public int Generation;
 
 		internal Actor(World world, string name, TypeDictionary initDict )
 		{
@@ -71,7 +93,8 @@ namespace OpenRA
 					AddTrait(trait.Create(init));
 			}
 
-			Move = Lazy.New( () => TraitOrDefault<IMove>() );
+			Move = Lazy.New(() => TraitOrDefault<IMove>());
+			Facing = Lazy.New(() => TraitOrDefault<IFacing>());
 
 			Size = Lazy.New(() =>
 			{
@@ -79,17 +102,14 @@ namespace OpenRA
 				if (si != null && si.Bounds != null)
 					return new int2(si.Bounds[0], si.Bounds[1]);
 
-				// auto size from render
-				var firstSprite = TraitsImplementing<IRender>().SelectMany(ApplyIRender).FirstOrDefault();
-				if (firstSprite.Sprite == null) return int2.Zero;
-				return (firstSprite.Sprite.size * firstSprite.Scale).ToInt2();
+				return TraitsImplementing<IAutoSelectionSize>().Select(x => x.SelectionSize(this)).FirstOrDefault();
 			});
 
-			ApplyIRender = x => x.Render(this);
-			ApplyRenderModifier = (m, p) => p.ModifyRender(this, m);
+			ApplyIRender = (x, wr) => x.Render(this, wr);
+			ApplyRenderModifier = (m, p, wr) => p.ModifyRender(this, wr, m);
 
-			Bounds = Cached.New( () => CalculateBounds(false) );
-			ExtendedBounds = Cached.New( () => CalculateBounds(true) );
+			Bounds = Cached.New(() => CalculateBounds(false));
+			ExtendedBounds = Cached.New(() => CalculateBounds(true));
 		}
 
 		public void Tick()
@@ -97,7 +117,7 @@ namespace OpenRA
 			Bounds.Invalidate();
 			ExtendedBounds.Invalidate();
 
-			currentActivity = Util.RunActivity( this, currentActivity );
+			currentActivity = Traits.Util.RunActivity(this, currentActivity);
 		}
 
 		public bool IsIdle
@@ -108,13 +128,13 @@ namespace OpenRA
 		OpenRA.FileFormats.Lazy<int2> Size;
 
 		// note: these delegates are cached to avoid massive allocation.
-		Func<IRender, IEnumerable<Renderable>> ApplyIRender;
-		Func<IEnumerable<Renderable>, IRenderModifier, IEnumerable<Renderable>> ApplyRenderModifier;
-		public IEnumerable<Renderable> Render()
+		Func<IRender, WorldRenderer, IEnumerable<IRenderable>> ApplyIRender;
+		Func<IEnumerable<IRenderable>, IRenderModifier, WorldRenderer, IEnumerable<IRenderable>> ApplyRenderModifier;
+		public IEnumerable<IRenderable> Render(WorldRenderer wr)
 		{
 			var mods = TraitsImplementing<IRenderModifier>();
-			var sprites = TraitsImplementing<IRender>().SelectMany(ApplyIRender);
-			return mods.Aggregate(sprites, ApplyRenderModifier);
+			var sprites = TraitsImplementing<IRender>().SelectMany(x => ApplyIRender(x, wr));
+			return mods.Aggregate(sprites, (m,p) => ApplyRenderModifier(m,p,wr));
 		}
 
 		// When useAltitude = true, the bounding box is extended
@@ -123,22 +143,22 @@ namespace OpenRA
 		// at its current altitude
 		Rectangle CalculateBounds(bool useAltitude)
 		{
-			var size = Size.Value;
+			var size = (PVecInt)(Size.Value);
 			var loc = CenterLocation - size / 2;
 
 			var si = Info.Traits.GetOrDefault<SelectableInfo>();
 			if (si != null && si.Bounds != null && si.Bounds.Length > 2)
 			{
-				loc.X += si.Bounds[2];
-				loc.Y += si.Bounds[3];
+				loc += new PVecInt(si.Bounds[2], si.Bounds[3]);
 			}
 
 			var move = Move.Value;
 			if (move != null)
 			{
-				loc.Y -= move.Altitude;
+				loc -= new PVecInt(0, move.Altitude);
+
 				if (useAltitude)
-					size = new int2(size.X, size.Y + move.Altitude);
+					size = new PVecInt(size.X, size.Y + move.Altitude);
 			}
 
 			return new Rectangle(loc.X, loc.Y, size.X, size.Y);
@@ -227,15 +247,21 @@ namespace OpenRA
 			} );
 		}
 
-		// todo: move elsewhere.
+		// TODO: move elsewhere.
 		public void ChangeOwner(Player newOwner)
 		{
 			World.AddFrameEndTask(w =>
 			{
+				var oldOwner = Owner;
+
 				// momentarily remove from world so the ownership queries don't get confused
 				w.Remove(this);
 				Owner = newOwner;
+				Generation++;
 				w.Add(this);
+
+				foreach (var t in this.TraitsImplementing<INotifyOwnerChanged>())
+					t.OnOwnerChanged(this, oldOwner, newOwner);
 			});
 		}
 	}

OpenRA.Game/ActorInitializer.cs

@@ -62,20 +62,29 @@ namespace OpenRA
 		public int Value( World world ) { return value; }
 	}
 
-	public class LocationInit : IActorInit<int2>
+	public class LocationInit : IActorInit<CPos>
 	{
 		[FieldFromYamlKey] public readonly int2 value = int2.Zero;
 		public LocationInit() { }
-		public LocationInit( int2 init ) { value = init; }
-		public int2 Value( World world ) { return value; }
+		public LocationInit( CPos init ) { value = init.ToInt2(); }
+		public CPos Value(World world) { return (CPos)value; }
 	}
 
-	public class CenterLocationInit : IActorInit<int2>
+	public class SubCellInit : IActorInit<SubCell>
+	{
+		[FieldFromYamlKey] public readonly int value = 0;
+		public SubCellInit() { }
+		public SubCellInit(int init) { value = init; }
+		public SubCellInit(SubCell init) { value = (int)init; }
+		public SubCell Value(World world) { return (SubCell)value; }
+	}
+
+	public class CenterLocationInit : IActorInit<PPos>
 	{
 		[FieldFromYamlKey] public readonly int2 value = int2.Zero;
 		public CenterLocationInit() { }
-		public CenterLocationInit( int2 init ) { value = init; }
-		public int2 Value( World world ) { return value; }
+		public CenterLocationInit(PPos init) { value = init.ToInt2(); }
+		public PPos Value(World world) { return (PPos)value; }
 	}
 
 	public class OwnerInit : IActorInit<Player>

OpenRA.Game/ActorMap.cs

@@ -37,7 +37,7 @@ namespace OpenRA
 			world.ActorRemoved += a => Remove( a, a.OccupiesSpace );
 		}
 
-		public IEnumerable<Actor> GetUnitsAt( int2 a )
+		public IEnumerable<Actor> GetUnitsAt(CPos a)
 		{
 			if (!map.IsInMap(a)) yield break;
 
@@ -46,7 +46,7 @@ namespace OpenRA
 					yield return i.actor;
 		}
 
-		public IEnumerable<Actor> GetUnitsAt( int2 a, SubCell sub )
+		public IEnumerable<Actor> GetUnitsAt(CPos a, SubCell sub)
 		{
 			if (!map.IsInMap(a)) yield break;
 
@@ -55,7 +55,7 @@ namespace OpenRA
 					yield return i.actor;
 		}
 
-		public bool HasFreeSubCell(int2 a)
+		public bool HasFreeSubCell(CPos a)
 		{
 			if (!AnyUnitsAt(a))
 				return true;
@@ -64,12 +64,22 @@ namespace OpenRA
 				SubCell.BottomLeft, SubCell.BottomRight }.Any(b => !AnyUnitsAt(a,b));
 		}
 
-		public bool AnyUnitsAt(int2 a)
+		public SubCell? FreeSubCell(CPos a)
+		{
+			if (!HasFreeSubCell(a))
+				return null;
+
+			return new[]{ SubCell.TopLeft, SubCell.TopRight, SubCell.Center,
+				SubCell.BottomLeft, SubCell.BottomRight }.First(b => !AnyUnitsAt(a,b));
+		}
+
+
+		public bool AnyUnitsAt(CPos a)
 		{
 			return influence[ a.X, a.Y ] != null;
 		}
 
-		public bool AnyUnitsAt(int2 a, SubCell sub)
+		public bool AnyUnitsAt(CPos a, SubCell sub)
 		{
 			for( var i = influence[ a.X, a.Y ] ; i != null ; i = i.next )
 				if (i.subCell == sub || i.subCell == SubCell.FullCell)

OpenRA.Game/CPos.cs

@@ -0,0 +1,77 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2011 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation. For more information,
+ * see COPYING.
+ */
+#endregion
+
+using System;
+using System.Drawing;
+
+namespace OpenRA
+{
+	/// <summary>
+	/// Cell coordinate position in the world (coarse).
+	/// </summary>
+	public struct CPos
+	{
+		public readonly int X, Y;
+
+		public CPos(int x, int y) { X = x; Y = y; }
+		public static readonly CPos Zero = new CPos(0, 0);
+
+		public static explicit operator CPos(int2 a) { return new CPos(a.X, a.Y); }
+
+		public static CPos operator +(CVec a, CPos b) { return new CPos(a.X + b.X, a.Y + b.Y); }
+		public static CPos operator +(CPos a, CVec b) { return new CPos(a.X + b.X, a.Y + b.Y); }
+		public static CPos operator -(CPos a, CVec b) { return new CPos(a.X - b.X, a.Y - b.Y); }
+
+		public static CVec operator -(CPos a, CPos b) { return new CVec(a.X - b.X, a.Y - b.Y); }
+
+		public static bool operator ==(CPos me, CPos other) { return (me.X == other.X && me.Y == other.Y); }
+		public static bool operator !=(CPos me, CPos other) { return !(me == other); }
+
+		public static CPos Max(CPos a, CPos b) { return new CPos(Math.Max(a.X, b.X), Math.Max(a.Y, b.Y)); }
+		public static CPos Min(CPos a, CPos b) { return new CPos(Math.Min(a.X, b.X), Math.Min(a.Y, b.Y)); }
+
+		public float2 ToFloat2() { return new float2(X, Y); }
+		public int2 ToInt2() { return new int2(X, Y); }
+		public PPos ToPPos() { return new PPos(Game.CellSize * X, Game.CellSize * Y); }
+
+		public WPos CenterPosition { get { return new WPos(1024*X + 512, 1024*Y + 512, 0); } }
+
+		public CPos Clamp(Rectangle r)
+		{
+			return new CPos(Math.Min(r.Right, Math.Max(X, r.Left)),
+							Math.Min(r.Bottom, Math.Max(Y, r.Top)));
+		}
+
+		public override int GetHashCode() { return X.GetHashCode() ^ Y.GetHashCode(); }
+
+		public override bool Equals(object obj)
+		{
+			if (obj == null)
+				return false;
+
+			CPos o = (CPos)obj;
+			return o == this;
+		}
+
+		public override string ToString() { return "{0},{1}".F(X, Y); }
+
+	}
+
+	public static class RectangleExtensions
+	{
+		public static CPos TopLeftAsCPos(this Rectangle r) { return new CPos(r.Left, r.Top); }
+		public static CPos BottomRightAsCPos(this Rectangle r) { return new CPos(r.Right, r.Bottom); }
+	}
+
+	public static class WPosExtensions
+	{
+		public static CPos ToCPos(this WPos a) { return new CPos(a.X / 1024, a.Y / 1024); }
+	}
+}

OpenRA.Game/CVec.cs

@@ -0,0 +1,89 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2011 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation. For more information,
+ * see COPYING.
+ */
+#endregion
+
+using System;
+using System.Drawing;
+
+namespace OpenRA
+{
+	/// <summary>
+	/// Cell coordinate vector (coarse).
+	/// </summary>
+	public struct CVec
+	{
+		public readonly int X, Y;
+
+		public CVec(int x, int y) { X = x; Y = y; }
+		public CVec(Size p) { X = p.Width; Y = p.Height; }
+
+		public static readonly CVec Zero = new CVec(0, 0);
+
+		public static explicit operator CVec(int2 a) { return new CVec(a.X, a.Y); }
+		public static explicit operator CVec(float2 a) { return new CVec((int)a.X, (int)a.Y); }
+
+		public static CVec operator +(CVec a, CVec b) { return new CVec(a.X + b.X, a.Y + b.Y); }
+		public static CVec operator -(CVec a, CVec b) { return new CVec(a.X - b.X, a.Y - b.Y); }
+		public static CVec operator *(int a, CVec b) { return new CVec(a * b.X, a * b.Y); }
+		public static CVec operator *(CVec b, int a) { return new CVec(a * b.X, a * b.Y); }
+		public static CVec operator /(CVec a, int b) { return new CVec(a.X / b, a.Y / b); }
+
+		public static CVec operator -(CVec a) { return new CVec(-a.X, -a.Y); }
+
+		public static bool operator ==(CVec me, CVec other) { return (me.X == other.X && me.Y == other.Y); }
+		public static bool operator !=(CVec me, CVec other) { return !(me == other); }
+
+		public static CVec Max(CVec a, CVec b) { return new CVec(Math.Max(a.X, b.X), Math.Max(a.Y, b.Y)); }
+		public static CVec Min(CVec a, CVec b) { return new CVec(Math.Min(a.X, b.X), Math.Min(a.Y, b.Y)); }
+
+		public static int Dot(CVec a, CVec b) { return a.X * b.X + a.Y * b.Y; }
+
+		public CVec Sign() { return new CVec(Math.Sign(X), Math.Sign(Y)); }
+		public CVec Abs() { return new CVec(Math.Abs(X), Math.Abs(Y)); }
+		public int LengthSquared { get { return X * X + Y * Y; } }
+		public int Length { get { return (int)Math.Sqrt(LengthSquared); } }
+
+		public float2 ToFloat2() { return new float2(X, Y); }
+		public int2 ToInt2() { return new int2(X, Y); }
+		public WVec ToWVec() { return new WVec(X*1024, Y*1024, 0); }
+
+		public CVec Clamp(Rectangle r)
+		{
+			return new CVec(
+				Math.Min(r.Right, Math.Max(X, r.Left)),
+				Math.Min(r.Bottom, Math.Max(Y, r.Top))
+			);
+		}
+
+		public override int GetHashCode() { return X.GetHashCode() ^ Y.GetHashCode(); }
+
+		public override bool Equals(object obj)
+		{
+			if (obj == null)
+				return false;
+
+			CVec o = (CVec)obj;
+			return o == this;
+		}
+
+		public override string ToString() { return "{0},{1}".F(X, Y); }
+
+		public static readonly CVec[] directions =
+		{
+			new CVec(-1, -1),
+			new CVec(-1,  0),
+			new CVec(-1,  1),
+			new CVec(0, -1),
+			new CVec(0,  1),
+			new CVec(1, -1),
+			new CVec(1,  0),
+			new CVec(1,  1),
+		};
+	}
+}

OpenRA.Game/Effects/DelayedAction.cs

@@ -10,6 +10,7 @@
 
 using System;
 using System.Collections.Generic;
+using OpenRA.Graphics;
 using OpenRA.Traits;
 
 namespace OpenRA.Effects
@@ -25,12 +26,12 @@ namespace OpenRA.Effects
 			this.delay = delay;
 		}
 
-		public void Tick( World world )
+		public void Tick(World world)
 		{
 			if (--delay <= 0)
 				world.AddFrameEndTask(w => { w.Remove(this); a(); });
 		}
 
-		public IEnumerable<Renderable> Render() { yield break; }
+		public IEnumerable<IRenderable> Render(WorldRenderer wr) { yield break; }
 	}
 }

OpenRA.Game/Effects/FlashTarget.cs

@@ -10,6 +10,7 @@
 
 using System.Collections.Generic;
 using System.Linq;
+using OpenRA.Graphics;
 using OpenRA.Traits;
 
 namespace OpenRA.Effects
@@ -32,14 +33,14 @@ namespace OpenRA.Effects
 				world.AddFrameEndTask(w => w.Remove(this));
 		}
 
-		public IEnumerable<Renderable> Render()
+		public IEnumerable<IRenderable> Render(WorldRenderer wr)
 		{
 			if (!target.IsInWorld)
 				yield break;
 
 			if (remainingTicks % 2 == 0)
-				foreach (var r in target.Render())
-					yield return r.WithPalette("highlight");
+				foreach (var r in target.Render(wr))
+					yield return r.WithPalette(wr.Palette("highlight"));
 		}
 	}
 }

OpenRA.Game/Effects/IEffect.cs

@@ -9,13 +9,14 @@
 #endregion
 
 using System.Collections.Generic;
+using OpenRA.Graphics;
 using OpenRA.Traits;
 
 namespace OpenRA.Effects
 {
 	public interface IEffect
 	{
-		void Tick( World world );
-		IEnumerable<Renderable> Render();
+		void Tick(World world);
+		IEnumerable<IRenderable> Render(WorldRenderer r);
 	}
 }

OpenRA.Game/Game.cs

@@ -29,6 +29,8 @@ namespace OpenRA
 	{
 		public static int CellSize { get { return modData.Manifest.TileSize; } }
 
+		public static MouseButtonPreference mouseButtonPreference = new MouseButtonPreference();
+
 		public static ModData modData;
 		static WorldRenderer worldRenderer;
 
@@ -50,18 +52,13 @@ namespace OpenRA
 
 		public static void JoinServer(string host, int port)
 		{
-			var replayFilename = ChooseReplayFilename();
-			string path = Path.Combine( Platform.SupportDir, "Replays" );
-			if( !Directory.Exists( path ) ) Directory.CreateDirectory( path );
-			var replayFile = File.Create( Path.Combine( path, replayFilename ) );
-
 			JoinInner(new OrderManager(host, port,
-				new ReplayRecorderConnection(new NetworkConnection(host, port), replayFile)));
+				new ReplayRecorderConnection(new NetworkConnection(host, port), ChooseReplayFilename)));
 		}
 
 		static string ChooseReplayFilename()
 		{
-			return DateTime.UtcNow.ToString("OpenRA-yyyy-MM-ddTHHmmssZ.rep");
+			return DateTime.UtcNow.ToString("OpenRA-yyyy-MM-ddTHHmmssZ");
 		}
 
 		static void JoinInner(OrderManager om)
@@ -95,14 +92,14 @@ namespace OpenRA
 		// Hacky workaround for orderManager visibility
 		public static Widget OpenWindow(World world, string widget)
 		{
-			return Widget.OpenWindow(widget, new WidgetArgs() {{ "world", world }, { "orderManager", orderManager }, { "worldRenderer", worldRenderer }});
+			return Ui.OpenWindow(widget, new WidgetArgs() {{ "world", world }, { "orderManager", orderManager }, { "worldRenderer", worldRenderer }});
 		}
 
 		// Who came up with the great idea of making these things
 		// impossible for the things that want them to access them directly?
 		public static Widget OpenWindow(string widget, WidgetArgs args)
 		{
-			return Widget.OpenWindow(widget, new WidgetArgs(args)
+			return Ui.OpenWindow(widget, new WidgetArgs(args)
 			{
 				{ "world", worldRenderer.world },
 				{ "orderManager", orderManager },
@@ -125,17 +122,17 @@ namespace OpenRA
 		public static void RunAfterTick(Action a) { delayedActions.Add(a); }
 		public static void RunAfterDelay(int delay, Action a) { delayedActions.Add(a, delay); }
 
-		static void Tick( OrderManager orderManager, Viewport viewPort )
+		static void Tick(OrderManager orderManager, Viewport viewPort)
 		{
 			if (orderManager.Connection.ConnectionState != lastConnectionState)
 			{
 				lastConnectionState = orderManager.Connection.ConnectionState;
-				ConnectionStateChanged( orderManager );
+				ConnectionStateChanged(orderManager);
 			}
 
-			Tick( orderManager );
-			if( worldRenderer != null && orderManager.world != worldRenderer.world )
-				Tick( worldRenderer.world.orderManager );
+			Tick(orderManager);
+			if (worldRenderer != null && orderManager.world != worldRenderer.world)
+				Tick(worldRenderer.world.orderManager);
 
 			using (new PerfSample("render"))
 			{
@@ -152,20 +149,20 @@ namespace OpenRA
 			delayedActions.PerformActions();
 		}
 
-		static void Tick( OrderManager orderManager )
+		static void Tick(OrderManager orderManager)
 		{
 			int t = Environment.TickCount;
 			int dt = t - orderManager.LastTickTime;
 			if (dt >= Settings.Game.Timestep)
-				using( new PerfSample( "tick_time" ) )
+				using (new PerfSample("tick_time"))
 				{
 					orderManager.LastTickTime += Settings.Game.Timestep;
-					Widget.DoTick();
+					Ui.Tick();
 					var world = orderManager.world;
 					if (orderManager.GameStarted)
 						++Viewport.TicksSinceLastMove;
 					Sound.Tick();
-					Sync.CheckSyncUnchanged( world, () => { orderManager.TickImmediate(); } );
+					Sync.CheckSyncUnchanged(world, orderManager.TickImmediate);
 
 					if (world != null)
 					{
@@ -177,14 +174,14 @@ namespace OpenRA
 
 							Log.Write("debug", "--Tick: {0} ({1})", LocalTick, isNetTick ? "net" : "local");
 
-							if (isNetTick) orderManager.Tick();
-
+							if (isNetTick)
+								orderManager.Tick();
 
 							Sync.CheckSyncUnchanged(world, () =>
-								{
-									world.OrderGenerator.Tick(world);
-									world.Selection.Tick(world);
-								});
+							{
+								world.OrderGenerator.Tick(world);
+								world.Selection.Tick(world);
+							});
 
 							world.Tick();
 
@@ -193,6 +190,9 @@ namespace OpenRA
 						else
 							if (orderManager.NetFrameNumber == 0)
 								orderManager.LastTickTime = Environment.TickCount;
+
+						world.TickRender(worldRenderer);
+						viewport.Tick();
 					}
 				}
 		}
@@ -211,26 +211,34 @@ namespace OpenRA
 
 			var map = modData.PrepareMap(mapUID);
 			viewport = new Viewport(new int2(Renderer.Resolution), map.Bounds, Renderer);
-			orderManager.world = new World(modData.Manifest, map, orderManager) { IsShellmap = isShellmap };
+			orderManager.world = new World(modData.Manifest, map, orderManager, isShellmap);
 			worldRenderer = new WorldRenderer(orderManager.world);
 
 			if (orderManager.GameStarted) return;
-			Widget.SelectedWidget = null;
+			Ui.SelectedWidget = null;
 
 			orderManager.LocalFrameNumber = 0;
 			orderManager.LastTickTime = Environment.TickCount;
 			orderManager.StartGame();
 			worldRenderer.RefreshPalette();
+
+			if (!isShellmap)
+				Sound.PlayNotification(null, "Speech", "StartGame", null);
 		}
 
 		public static bool IsHost
 		{
-			get { return orderManager.Connection.LocalClientId == 0; }
+			get
+			{
+				var client= orderManager.LobbyInfo.ClientWithIndex(
+					orderManager.Connection.LocalClientId);
+				return ((client!=null) && client.IsAdmin);
+			}
 		}
 
 		public static Dictionary<String, Mod> CurrentMods
 		{
-			get { return Mod.AllMods.Where( k => modData.Manifest.Mods.Contains( k.Key )).ToDictionary( k => k.Key, k => k.Value ); }
+			get { return Mod.AllMods.Where(k => modData.Manifest.Mods.Contains(k.Key)).ToDictionary(k => k.Key, k => k.Value); }
 		}
 
 		static Modifiers modifiers;
@@ -244,12 +252,20 @@ namespace OpenRA
 			AppDomain.CurrentDomain.AssemblyResolve += FileSystem.ResolveAssembly;
 
 			Settings = new Settings(Platform.SupportDir + "settings.yaml", args);
-			Settings.Save();
 
 			Log.LogPath = Platform.SupportDir + "Logs" + Path.DirectorySeparatorChar;
 			Log.AddChannel("perf", "perf.log");
 			Log.AddChannel("debug", "debug.log");
 			Log.AddChannel("sync", "syncreport.log");
+			Log.AddChannel("server", "server.log");
+
+			if (Settings.Server.DiscoverNatDevices)
+				UPnP.TryNatDiscovery();
+			else
+			{
+				Settings.Server.NatDeviceAvailable = false;
+				Settings.Server.AllowPortForward = false;
+			}
 
 			FileSystem.Mount("."); // Needed to access shaders
 			Renderer.Initialize( Game.Settings.Graphics.Mode );
@@ -259,8 +275,15 @@ namespace OpenRA
 			foreach(var mod in Mod.AllMods)
 				Console.WriteLine("\t{0}: {1} ({2})", mod.Key, mod.Value.Title, mod.Value.Version);
 
-			Sound.Create();
+			Sound.Create(Settings.Sound.Engine);
 			InitializeWithMods(Settings.Game.Mods);
+
+			if (Settings.Server.DiscoverNatDevices)
+			{
+				RunAfterDelay(Settings.Server.NatDiscoveryTimeout, () =>
+				              UPnP.TryStoppingNatDiscovery()
+				              );
+			}
 		}
 
 		public static void InitializeWithMods(string[] mods)
@@ -270,7 +293,7 @@ namespace OpenRA
 			AddChatLine = (a,b,c) => {};
 			ConnectionStateChanged = om => {};
 			BeforeGameStart = () => {};
-			Widget.ResetAll();
+			Ui.ResetAll();
 
 			worldRenderer = null;
 			if (server != null)
@@ -278,20 +301,19 @@ namespace OpenRA
 			if (orderManager != null)
 				orderManager.Dispose();
 
-			// Discard any invalid mods
+			// Discard any invalid mods, set RA as default
 			var mm = mods.Where( m => Mod.AllMods.ContainsKey( m ) ).ToArray();
+			if (mm.Length == 0) mm = new[] { "ra" };
 			Console.WriteLine("Loading mods: {0}", mm.JoinWith(","));
 			Settings.Game.Mods = mm;
-			Settings.Save();
 
 			Sound.StopMusic();
 			Sound.StopVideo();
 			Sound.Initialize();
 
-			modData = new ModData( mm );
+			modData = new ModData(mm);
 			Renderer.InitializeFonts(modData.Manifest);
-			modData.LoadInitialAssets();
-
+			modData.InitializeLoaders();
 
 			PerfHistory.items["render"].hasNormalTick = false;
 			PerfHistory.items["batches"].hasNormalTick = false;
@@ -301,7 +323,40 @@ namespace OpenRA
 			JoinLocal();
 			viewport = new Viewport(new int2(Renderer.Resolution), Rectangle.Empty, Renderer);
 
-			modData.LoadScreen.StartGame();
+			if (Game.Settings.Server.Dedicated)
+			{
+				while (true)
+				{
+					Game.Settings.Server.Map = WidgetUtils.ChooseInitialMap(Game.Settings.Server.Map);
+					Game.Settings.Save();
+					Game.CreateServer(new ServerSettings(Game.Settings.Server));
+					while (true)
+					{
+						System.Threading.Thread.Sleep(100);
+
+						if ((server.State == Server.ServerState.GameStarted)
+						    && (server.conns.Count<=1))
+						{
+							Console.WriteLine("No one is playing, shutting down...");
+							server.Shutdown();
+							break;
+						}
+					}
+					if (Game.Settings.Server.DedicatedLoop)
+					{
+						Console.WriteLine("Starting a new server instance...");
+						continue;
+					}
+					else
+						break;
+				}
+				System.Environment.Exit(0);
+			}
+			else
+			{
+				modData.LoadScreen.StartGame();
+				Settings.Save();
+			}
 		}
 
 		public static void LoadShellMap()
@@ -326,8 +381,20 @@ namespace OpenRA
 		internal static void Run()
 		{
 			while (!quit)
+			{
+				var idealFrameTime = 1.0 / Settings.Graphics.MaxFramerate;
+				var sw = new Stopwatch();
+
 				Tick( orderManager, viewport );
 
+				if (Settings.Graphics.CapFramerate)
+				{
+					var waitTime = idealFrameTime - sw.ElapsedTime();
+					if (waitTime > 0)
+						System.Threading.Thread.Sleep( TimeSpan.FromSeconds(waitTime) );
+				}
+			}
+
 			OnQuit();
 		}
 
@@ -358,13 +425,13 @@ namespace OpenRA
 
 		public static T CreateObject<T>( string name )
 		{
-			return modData.ObjectCreator.CreateObject<T>( name );
+			return modData.ObjectCreator.CreateObject<T>(name);
 		}
 
 		public static void CreateServer(ServerSettings settings)
 		{
 			server = new Server.Server(new IPEndPoint(IPAddress.Any, settings.ListenPort),
-				Game.Settings.Game.Mods, settings, modData);
+			                           Game.Settings.Game.Mods, settings, modData);
 		}
 
 		public static int CreateLocalServer(string map)
@@ -378,9 +445,10 @@ namespace OpenRA
 			// Work around a miscompile in mono 2.6.7:
 			// booleans that default to true cannot be set false by an initializer
 			settings.AdvertiseOnline = false;
+			settings.AllowPortForward = false;
 
 			server = new Server.Server(new IPEndPoint(IPAddress.Loopback, 0),
-				Game.Settings.Game.Mods, settings, modData);
+			                           Game.Settings.Game.Mods, settings, modData);
 
 			return server.Port;
 		}
@@ -390,21 +458,28 @@ namespace OpenRA
 			return orderManager != null && orderManager.world == world;
 		}
 
-		public static void JoinExternalGame()
+		public static bool DownloadMap(string mapHash)
 		{
-			var addressParts = Game.Settings.Game.ConnectTo.Split(
-				new [] { ':' }, StringSplitOptions.RemoveEmptyEntries);
-
-			if (addressParts.Length < 1 || addressParts.Length > 2)
-				return;
-
-			var host = addressParts[0];
-			var port = Exts.WithDefault(1234, () => int.Parse(addressParts[1]));
-
-			Game.Settings.Game.ConnectTo = "";
-			Game.Settings.Save();
-
-			Game.JoinServer(host, port);
+			try
+			{
+				var mod = Game.CurrentMods.FirstOrDefault().Value.Id;
+				var dirPath = "{1}maps{0}{2}".F(Path.DirectorySeparatorChar, Platform.SupportDir, mod);
+				if(!Directory.Exists(dirPath))
+					Directory.CreateDirectory(dirPath);
+				var mapPath = "{1}{0}{2}".F(Path.DirectorySeparatorChar, dirPath, mapHash+".oramap");
+				Console.Write("Trying to download map to {0} ... ".F(mapPath));
+				WebClient webClient = new WebClient();
+				webClient.DownloadFile(Game.Settings.Game.MapRepository + mapHash, mapPath);
+				Game.modData.AvailableMaps.Add(mapHash, new Map(mapPath));
+				Console.WriteLine("done");
+				return true;
+			}
+			catch (WebException e)
+			{
+				Log.Write("debug", "Could not download map '{0}'", mapHash);
+				Log.Write("debug", e.ToString());
+				return false;
+			}
 		}
 	}
 }

OpenRA.Game/GameRules/ActorInfo.cs

@@ -16,8 +16,15 @@ using OpenRA.Traits;
 
 namespace OpenRA
 {
+	//TODO: This is not exported into the documentation yet.
+	[Desc("A unit/building inside the game. Every rules starts with one and adds trait to it.",
+		"Special actors like world or player are usually defined in system.yaml and affect everything.")]
 	public class ActorInfo
 	{
+		[Desc("The actor name can be anything, but the sprites used in the Render*: traits default to this one.",
+			"If you add an ^ in front of the name, the engine will recognize this as a collection of traits",
+			"that can be inherited by others (using Inherits:) and not a real unit.",
+			"You can remove inherited traits by adding a - infront of them as in -TraitName: to inherit everything, but this trait.")]
 		public readonly string Name;
 		public readonly TypeDictionary Traits = new TypeDictionary();
 
@@ -70,6 +77,9 @@ namespace OpenRA
 
 		static ITraitInfo LoadTraitInfo(string traitName, MiniYaml my)
 		{
+			if (!string.IsNullOrEmpty(my.Value))
+				throw new YamlException("Junk value `{0}` on trait node {1}"
+				.F(my.Value, traitName));
 			var info = Game.CreateObject<ITraitInfo>(traitName + "Info");
 			FieldLoader.Load(info, my);
 			return info;

OpenRA.Game/GameRules/Rules.cs

@@ -20,7 +20,8 @@ namespace OpenRA
 	{
 		public static Dictionary<string, ActorInfo> Info;
 		public static Dictionary<string, WeaponInfo> Weapons;
-		public static Dictionary<string, VoiceInfo> Voices;
+		public static Dictionary<string, SoundInfo> Voices;
+		public static Dictionary<string, SoundInfo> Notifications;
 		public static Dictionary<string, MusicInfo> Music;
 		public static Dictionary<string, string> Movies;
 		public static Dictionary<string, TileSet> TileSets;
@@ -30,7 +31,8 @@ namespace OpenRA
 			// Added support to extend the list of rules (add it to m.LocalRules)
 			Info = LoadYamlRules(m.Rules, map.Rules, (k, y) => new ActorInfo(k.Key.ToLowerInvariant(), k.Value, y));
 			Weapons = LoadYamlRules(m.Weapons, map.Weapons, (k, _) => new WeaponInfo(k.Key.ToLowerInvariant(), k.Value));
-			Voices = LoadYamlRules(m.Voices, map.Voices, (k, _) => new VoiceInfo(k.Value));
+			Voices = LoadYamlRules(m.Voices, map.Voices, (k, _) => new SoundInfo(k.Value));
+			Notifications = LoadYamlRules(m.Notifications, map.Notifications, (k, _) => new SoundInfo(k.Value));
 			Music = LoadYamlRules(m.Music, new List<MiniYamlNode>(), (k, _) => new MusicInfo(k.Key, k.Value));
 			Movies = LoadYamlRules(m.Movies, new List<MiniYamlNode>(), (k, v) => k.Value.Value);
 
@@ -44,9 +46,9 @@ namespace OpenRA
 
 		static Dictionary<string, T> LoadYamlRules<T>(string[] files, List<MiniYamlNode> dict, Func<MiniYamlNode, Dictionary<string, MiniYaml>, T> f)
 		{
-			var y = files.Select(a => MiniYaml.FromFile(a)).Aggregate(dict,MiniYaml.MergeLiberal);
-			var yy = y.ToDictionary( x => x.Key, x => x.Value );
-			return y.ToDictionary(kv => kv.Key.ToLowerInvariant(), kv => f(kv, yy));
+			var y = files.Select(MiniYaml.FromFile).Aggregate(dict, MiniYaml.MergeLiberal);
+			var yy = y.ToDictionary(x => x.Key, x => x.Value);
+			return y.ToDictionaryWithConflictLog(kv => kv.Key.ToLowerInvariant(), kv => f(kv, yy), "LoadYamlRules", null, null);
 		}
 
 		public static IEnumerable<KeyValuePair<string,MusicInfo>> InstalledMusic { get { return Music.Where( m => m.Value.Exists ); } }

OpenRA.Game/GameRules/Settings.cs

@@ -1,6 +1,6 @@
 #region Copyright & License Information
 /*
- * Copyright 2007-2011 The OpenRA Developers (see AUTHORS)
+ * Copyright 2007-2013 The OpenRA Developers (see AUTHORS)
  * This file is part of OpenRA, which is free software. It is made
  * available to you under the terms of the GNU General Public License
  * as published by the Free Software Foundation. For more information,
@@ -19,6 +19,9 @@ using OpenRA.Server;
 
 namespace OpenRA.GameRules
 {
+	public enum MouseScrollType { Disabled, Standard, Inverted }
+	public enum SoundCashTicks { Disabled, Normal, Extreme }
+
 	public class ServerSettings
 	{
 		public string Name = "OpenRA Game";
@@ -26,8 +29,19 @@ namespace OpenRA.GameRules
 		public int ExternalPort = 1234;
 		public bool AdvertiseOnline = true;
 		public string MasterServer = "http://master.open-ra.org/";
+		public bool DiscoverNatDevices = false; // Allow users to disable NAT discovery if problems occur
+		public bool AllowPortForward = true; // let the user disable it even if compatible devices are found
+		public bool NatDeviceAvailable = false; // internal check if discovery succeeded
+		public int NatDiscoveryTimeout = 1000; // ms to search for UPnP enabled NATs
+		public bool VerboseNatDiscovery = false; // print very detailed logs for debugging
 		public bool AllowCheats = false;
 		public string Map = null;
+		public string[] Ban = { };
+		public int TimeOut = 0;
+		public bool Dedicated = false;
+		public bool DedicatedLoop = true;
+		public bool LockBots = false;
+		public bool AllowVersionMismatch = false;
 
 		public ServerSettings() { }
 
@@ -38,8 +52,19 @@ namespace OpenRA.GameRules
 			ExternalPort = other.ExternalPort;
 			AdvertiseOnline = other.AdvertiseOnline;
 			MasterServer = other.MasterServer;
+			DiscoverNatDevices = other.DiscoverNatDevices;
+			AllowPortForward = other.AllowPortForward;
+			NatDeviceAvailable = other.NatDeviceAvailable;
+			NatDiscoveryTimeout = other.NatDiscoveryTimeout;
+			VerboseNatDiscovery = other.VerboseNatDiscovery;
 			AllowCheats = other.AllowCheats;
 			Map = other.Map;
+			Ban = other.Ban;
+			TimeOut = other.TimeOut;
+			Dedicated = other.Dedicated;
+			DedicatedLoop = other.DedicatedLoop;
+			LockBots = other.LockBots;
+			AllowVersionMismatch = other.AllowVersionMismatch;
 		}
 	}
 
@@ -51,6 +76,8 @@ namespace OpenRA.GameRules
 		public float LongTickThreshold = 0.001f;
 		public bool SanityCheckUnsyncedCode = false;
 		public int Samples = 25;
+		public bool IgnoreVersionMismatch = false;
+		public bool DeveloperMenu = false;
 	}
 
 	public class GraphicSettings
@@ -60,6 +87,8 @@ namespace OpenRA.GameRules
 		public int2 FullscreenSize = new int2(0,0);
 		public int2 WindowedSize = new int2(1024, 768);
 		public bool PixelDouble = false;
+		public bool CapFramerate = false;
+		public int MaxFramerate = 60;
 
 		public int BatchSize = 8192;
 		public int NumTempBuffers = 8;
@@ -73,18 +102,19 @@ namespace OpenRA.GameRules
 		public float VideoVolume = 0.5f;
 		public bool Shuffle = false;
 		public bool Repeat = false;
-		public bool ShellmapMusic = true;
+		public bool MapMusic = true;
+		public string Engine = "AL";
+		
+		public SoundCashTicks SoundCashTickType = SoundCashTicks.Extreme;
 	}
 
 	public class PlayerSettings
 	{
 		public string Name = "Newbie";
-		public ColorRamp ColorRamp = new ColorRamp(75, 255, 180, 25);
+		public HSLColor Color = new HSLColor(75, 255, 180);
 		public string LastServer = "localhost:1234";
 	}
 
-	public enum MouseScrollType { Disabled, Standard, Inverted }
-
 	public class GameSettings
 	{
 		public string[] Mods = { "ra" };
@@ -96,12 +126,37 @@ namespace OpenRA.GameRules
 		public MouseScrollType MouseScroll = MouseScrollType.Standard;
 		public float ViewportEdgeScrollStep = 10f;
 
+		public bool UseClassicMouseStyle = false;
+
 		// Internal game settings
 		public int Timestep = 40;
 
-		public string ConnectTo = "";
+		public bool AllowDownloading = true;
+		public string MapRepository = "http://content.open-ra.org/map/";
 	}
 
+	public class KeySettings
+	{
+		public string CycleBaseKey = "backspace";
+		public string ToLastEventKey = "space";
+		public string ToSelectionKey = "home";
+
+		public string PauseKey = "f9";
+		public string SellKey = "f10";
+		public string PowerDownKey = "f11";
+		public string RepairKey = "f12";
+
+		public string AttackMoveKey = "a";
+		public string StopKey = "s";
+		public string ScatterKey = "x";
+		public string DeployKey = "f";
+		public string StanceCycleKey = "z";
+		public string GuardKey = "d";
+
+		public string CycleTabsKey = "tab";
+	}
+
+
 	public class Settings
 	{
 		string SettingsFile;
@@ -112,6 +167,7 @@ namespace OpenRA.GameRules
 		public GraphicSettings Graphics = new GraphicSettings();
 		public ServerSettings Server = new ServerSettings();
 		public DebugSettings Debug = new DebugSettings();
+		public KeySettings Keys = new KeySettings();
 
 		public Dictionary<string, object> Sections;
 
@@ -126,6 +182,7 @@ namespace OpenRA.GameRules
 				{"Graphics", Graphics},
 				{"Server", Server},
 				{"Debug", Debug},
+				{"Keys", Keys},
 			};
 
 			// Override fieldloader to ignore invalid entries
@@ -139,7 +196,6 @@ namespace OpenRA.GameRules
 
 			if (File.Exists(SettingsFile))
 			{
-				//Console.WriteLine("Loading settings file {0}",SettingsFile);
 				var yaml = MiniYaml.DictFromFile(SettingsFile);
 
 				foreach (var kv in Sections)
@@ -168,11 +224,11 @@ namespace OpenRA.GameRules
 
 		void LoadSectionYaml(MiniYaml yaml, object section)
 		{
-			object defaults = Activator.CreateInstance(section.GetType());
+			var defaults = Activator.CreateInstance(section.GetType());
 			FieldLoader.InvalidValueAction = (s,t,f) =>
 			{
-				object ret = defaults.GetType().GetField(f).GetValue(defaults);
-				System.Console.WriteLine("FieldLoader: Cannot parse `{0}` into `{2}:{1}`; substituting default `{3}`".F(s,t.Name,f,ret) );
+				var ret = defaults.GetType().GetField(f).GetValue(defaults);
+				Console.WriteLine("FieldLoader: Cannot parse `{0}` into `{2}:{1}`; substituting default `{3}`".F(s,t.Name,f,ret) );
 				return ret;
 			};
 

OpenRA.Game/GameRules/SoundInfo.cs

@@ -1,4 +1,4 @@
-#region Copyright & License Information
+#region Copyright & License Information
 /*
  * Copyright 2007-2011 The OpenRA Developers (see AUTHORS)
  * This file is part of OpenRA, which is free software. It is made
@@ -15,12 +15,16 @@ using OpenRA.FileFormats;
 
 namespace OpenRA.GameRules
 {
-	public class VoiceInfo
+	public class SoundInfo
 	{
 		[FieldLoader.Ignore] public readonly Dictionary<string,string[]> Variants;
+		[FieldLoader.Ignore] public readonly Dictionary<string,string[]> Prefixes;
 		[FieldLoader.Ignore] public readonly Dictionary<string,string[]> Voices;
+		[FieldLoader.Ignore] public readonly Dictionary<string,string[]> Notifications;
 		public readonly string DefaultVariant = ".aud" ;
+		public readonly string DefaultPrefix = "" ;
 		public readonly string[] DisableVariants = { };
+		public readonly string[] DisablePrefixes = { };
 
 		static Dictionary<string, string[]> Load( MiniYaml y, string name )
 		{
@@ -31,30 +35,28 @@ namespace OpenRA.GameRules
 				: new Dictionary<string, string[]>();
 		}
 
-		public readonly OpenRA.FileFormats.Lazy<Dictionary<string, VoicePool>> Pools;
+		public readonly OpenRA.FileFormats.Lazy<Dictionary<string, SoundPool>> VoicePools;
+		public readonly OpenRA.FileFormats.Lazy<Dictionary<string, SoundPool>> NotificationsPools;
 
-		public VoiceInfo( MiniYaml y )
+		public SoundInfo( MiniYaml y )
 		{
 			FieldLoader.Load( this, y );
 			Variants = Load(y, "Variants");
+			Prefixes = Load(y, "Prefixes");
 			Voices = Load(y, "Voices");
+			Notifications = Load(y, "Notifications");
 
-			if (!Voices.ContainsKey("Attack"))
-				Voices.Add("Attack", Voices["Move"]);
-
-			if (!Voices.ContainsKey("AttackMove"))
-				Voices.Add("AttackMove", Voices["Move"]);
-
-			Pools = Lazy.New(() => Voices.ToDictionary( a => a.Key, a => new VoicePool(a.Value) ));
+			VoicePools = Lazy.New(() => Voices.ToDictionary( a => a.Key, a => new SoundPool(a.Value) ));
+			NotificationsPools = Lazy.New(() => Notifications.ToDictionary( a => a.Key, a => new SoundPool(a.Value) ));
 		}
 	}
 
-	public class VoicePool
+	public class SoundPool
 	{
 		readonly string[] clips;
 		readonly List<string> liveclips = new List<string>();
 
-		public VoicePool(params string[] clips)
+		public SoundPool(params string[] clips)
 		{
 			this.clips = clips;
 		}

OpenRA.Game/GameRules/WeaponInfo.cs

@@ -18,21 +18,35 @@ namespace OpenRA.GameRules
 {
 	public class WarheadInfo
 	{
-		public readonly int Spread = 1;									// distance (in pixels) from the explosion center at which damage is 1/2.
+		[Desc("Distance (in pixels) from the explosion center at which damage is 1/2.")]
+		public readonly int Spread = 1;
 		[FieldLoader.LoadUsing( "LoadVersus" )]
-		public readonly Dictionary<string, float> Versus; 				// damage vs each armortype
-		public readonly bool Ore = false;								// can this damage ore?
-		public readonly string Explosion = null;						// explosion effect to use
-		public readonly string WaterExplosion = null;					// explosion effect on hitting water (usually a splash)
-		public readonly string SmudgeType = null;						// type of smudge to apply
-		public readonly int[] Size = { 0, 0 };							// size of the explosion. provide 2 values for a ring effect (outer/inner)
-		public readonly int InfDeath = 0;								// infantry death animation to use
-		public readonly string ImpactSound = null;						// sound to play on impact
-		public readonly string WaterImpactSound = null;					// sound to play on impact with water
-		public readonly int Damage = 0;									// how much (raw) damage to deal
-		public readonly int Delay = 0;									// delay in ticks before dealing the damage. 0=instant (old model)
-		public readonly DamageModel DamageModel = DamageModel.Normal;	// which damage model to use
-		public readonly bool PreventProne = false;						// whether we should prevent prone response in infantry.
+		[Desc("Damage vs each armortype. 0% = can't target.")]
+		public readonly Dictionary<string, float> Versus;
+		[Desc("Can this damage ore?")]
+		public readonly bool Ore = false;
+		[Desc("Explosion effect to use.")]
+		public readonly string Explosion = null;
+		[Desc("Explosion effect on hitting water (usually a splash).")]
+		public readonly string WaterExplosion = null;
+		[Desc("Type of smudge to apply to terrain.")]
+		public readonly string[] SmudgeType = { };
+		[Desc("Size of the explosion. provide 2 values for a ring effect (outer/inner).")]
+		public readonly int[] Size = { 0, 0 };
+		[Desc("Infantry death animation to use")]
+		public readonly int InfDeath = 1;
+		[Desc("Sound to play on impact.")]
+		public readonly string ImpactSound = null;
+		[Desc("Sound to play on impact with water")]
+		public readonly string WaterImpactSound = null;
+		[Desc("How much (raw) damage to deal")]
+		public readonly int Damage = 0;
+		[Desc("Delay in ticks before dealing the damage, 0 = instant (old model).")]
+		public readonly int Delay = 0;
+		[Desc("Which damage model to use.")]
+		public readonly DamageModel DamageModel = DamageModel.Normal;
+		[Desc("Whether we should prevent prone response for infantry.")]
+		public readonly bool PreventProne = false;
 
 		public float EffectivenessAgainst(Actor self)
 		{
@@ -72,11 +86,11 @@ namespace OpenRA.GameRules
 	{
 		public WeaponInfo weapon;
 		public Actor firedBy;
-		public int2 src;
+		public PPos src;
 		public int srcAltitude;
 		public int facing;
 		public Target target;
-		public int2 dest;
+		public PPos dest;
 		public int destAltitude;
 		public float firepowerModifier = 1.0f;
 	}
@@ -86,12 +100,13 @@ namespace OpenRA.GameRules
 	public class WeaponInfo
 	{
 		public readonly float Range = 0;
-		public readonly string Report = null;
+		public readonly string[] Report = null;
+		[Desc("Rate of Fire")]
 		public readonly int ROF = 1;
 		public readonly int Burst = 1;
 		public readonly bool Charges = false;
 		public readonly bool Underwater = false;
-		public readonly string[] ValidTargets = { "Ground" };
+		public readonly string[] ValidTargets = { "Ground", "Water" };
 		public readonly int BurstDelay = 5;
 		public readonly float MinRange = 0;
 
@@ -122,5 +137,37 @@ namespace OpenRA.GameRules
 
 			return ret;
 		}
+
+		public bool IsValidAgainst(Actor a)
+		{
+			var targetable = a.TraitOrDefault<ITargetable>();
+			if (targetable == null || !ValidTargets.Intersect(targetable.TargetTypes).Any())
+				return false;
+
+			if (Warheads.All(w => w.EffectivenessAgainst(a) <= 0))
+				return false;
+
+			return true;
+		}
+
+		public bool IsValidAgainst(Target target, World world)
+		{
+			if (!target.IsValid)
+				return false;
+
+			if (target.IsActor)
+				return IsValidAgainst(target.Actor);
+			else
+			{
+				var cell = target.CenterPosition.ToCPos();
+				if (ValidTargets.Contains("Ground") && world.GetTerrainType(cell) != "Water")
+					return true;
+
+				if (ValidTargets.Contains("Water") && world.GetTerrainType(cell) == "Water")
+					return true;
+
+				return false;
+			}
+		}
 	}
 }

OpenRA.Game/Graphics/Animation.cs

@@ -24,15 +24,13 @@ namespace OpenRA.Graphics
 
 		public string Name { get { return name; } }
 
-		public Animation( string name )
-			: this( name, () => 0 )
-		{
-		}
+		public Animation(string name)
+			: this(name, () => 0)	{}
 
-		public Animation( string name, Func<int> facingFunc )
+		public Animation(string name, Func<int> facingFunc)
 		{
 			this.name = name.ToLowerInvariant();
-			this.tickFunc = () => { };
+			this.tickFunc = () => {};
 			this.facingFunc = facingFunc;
 		}
 
@@ -46,12 +44,12 @@ namespace OpenRA.Graphics
 			}
 		}
 
-		public void Play( string sequenceName )
+		public void Play(string sequenceName)
 		{
 			PlayThen(sequenceName, null);
 		}
 
-		public void PlayRepeating( string sequenceName )
+		public void PlayRepeating(string sequenceName)
 		{
 			backwards = false;
 			tickAlways = false;
@@ -75,16 +73,16 @@ namespace OpenRA.Graphics
 			return true;
 		}
 
-		public void PlayThen( string sequenceName, Action after )
+		public void PlayThen(string sequenceName, Action after)
 		{
 			backwards = false;
 			tickAlways = false;
-			CurrentSequence = SequenceProvider.GetSequence( name, sequenceName );
+			CurrentSequence = SequenceProvider.GetSequence(name, sequenceName);
 			frame = 0;
 			tickFunc = () =>
 			{
 				++frame;
-				if( frame >= CurrentSequence.Length )
+				if (frame >= CurrentSequence.Length)
 				{
 					frame = CurrentSequence.Length - 1;
 					tickFunc = () => { };
@@ -99,11 +97,11 @@ namespace OpenRA.Graphics
 			backwards = true;
 		}
 
-		public void PlayFetchIndex( string sequenceName, Func<int> func )
+		public void PlayFetchIndex(string sequenceName, Func<int> func)
 		{
 			backwards = false;
 			tickAlways = true;
-			CurrentSequence = SequenceProvider.GetSequence( name, sequenceName );
+			CurrentSequence = SequenceProvider.GetSequence(name, sequenceName);
 			frame = func();
 			tickFunc = () => frame = func();
 		}
@@ -113,19 +111,19 @@ namespace OpenRA.Graphics
 
 		public void Tick()
 		{
-			Tick( 40 ); // tick one frame
+			Tick(40); // tick one frame
 		}
 
-		public bool HasSequence(string seq) { return SequenceProvider.HasSequence( name, seq ); }
+		public bool HasSequence(string seq) { return SequenceProvider.HasSequence(name, seq); }
 
-		public void Tick( int t )
+		public void Tick(int t)
 		{
-			if( tickAlways )
+			if (tickAlways)
 				tickFunc();
 			else
 			{
 				timeUntilNextFrame -= t;
-				while( timeUntilNextFrame <= 0 )
+				while (timeUntilNextFrame <= 0)
 				{
 					tickFunc();
 					timeUntilNextFrame += CurrentSequence != null ? CurrentSequence.Tick : 40; // 25 fps == 40 ms
@@ -145,9 +143,9 @@ namespace OpenRA.Graphics
 			}
 		}
 
-		public Sequence GetSequence( string sequenceName )
+		public Sequence GetSequence(string sequenceName)
 		{
-			return SequenceProvider.GetSequence( name, sequenceName );
+			return SequenceProvider.GetSequence(name, sequenceName);
 		}
 	}
 }

OpenRA.Game/Graphics/AnimationWithOffset.cs

@@ -15,36 +15,43 @@ namespace OpenRA.Graphics
 {
 	public class AnimationWithOffset
 	{
-		public Animation Animation;
-		public Func<float2> OffsetFunc;
-		public Func<bool> DisableFunc;
-		public int ZOffset;
+		public readonly Animation Animation;
+		public readonly Func<WVec> OffsetFunc;
+		public readonly Func<bool> DisableFunc;
+		public readonly Func<WPos, int> ZOffset;
 
-		public AnimationWithOffset(Animation a)
-			: this(a, null, null)
-		{
-		}
+		public AnimationWithOffset(Animation a, Func<WVec> offset, Func<bool> disable)
+			: this(a, offset, disable, null) { }
 
-		public AnimationWithOffset(Animation a, Func<float2> o, Func<bool> d)
+		public AnimationWithOffset(Animation a, Func<WVec> offset, Func<bool> disable, int zOffset)
+			: this(a, offset, disable, _ => zOffset) { }
+
+		public AnimationWithOffset(Animation a, Func<WVec> offset, Func<bool> disable, Func<WPos, int> zOffset)
 		{
 			this.Animation = a;
-			this.OffsetFunc = o;
-			this.DisableFunc = d;
+			this.OffsetFunc = offset;
+			this.DisableFunc = disable;
+			this.ZOffset = zOffset;
 		}
 
-		public Renderable Image(Actor self, string pal)
+		public IRenderable Image(Actor self, WorldRenderer wr, PaletteReference pal)
 		{
-			var p = self.CenterLocation;
-			var loc = p - 0.5f * Animation.Image.size
-				+ (OffsetFunc != null ? OffsetFunc() : float2.Zero);
-			var r = new Renderable(Animation.Image, loc, pal, p.Y);
+			return Image(self, wr, pal, 1f);
+		}
 
-			return ZOffset != 0 ? r.WithZOffset(ZOffset) : r;
+		public IRenderable Image(Actor self, WorldRenderer wr, PaletteReference pal, float scale)
+		{
+			var p = self.CenterPosition;
+			if (OffsetFunc != null)
+				p += OffsetFunc();
+
+			var z = (ZOffset != null) ? ZOffset(p) : 0;
+			return new SpriteRenderable(Animation.Image, p, z, pal, scale);
 		}
 
 		public static implicit operator AnimationWithOffset(Animation a)
 		{
-			return new AnimationWithOffset(a);
+			return new AnimationWithOffset(a, null, null, null);
 		}
 	}
 }

OpenRA.Game/Graphics/BeamRenderable.cs

@@ -0,0 +1,68 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2013 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation. For more information,
+ * see COPYING.
+ */
+#endregion
+
+using System.Collections.Generic;
+using System.Drawing;
+
+namespace OpenRA.Graphics
+{
+	public struct BeamRenderable : IRenderable
+	{
+		readonly WPos pos;
+		readonly int zOffset;
+		readonly WVec length;
+		readonly Color color;
+		readonly float width;
+
+		public BeamRenderable(WPos pos, int zOffset, WVec length, float width, Color color)
+		{
+			this.pos = pos;
+			this.zOffset = zOffset;
+			this.length = length;
+			this.color = color;
+			this.width = width;
+		}
+
+		public WPos Pos { get { return pos; } }
+		public float Scale { get { return 1f; } }
+		public PaletteReference Palette { get { return null; } }
+		public int ZOffset { get { return zOffset; } }
+
+		public IRenderable WithScale(float newScale) { return new BeamRenderable(pos, zOffset, length, width, color); }
+		public IRenderable WithPalette(PaletteReference newPalette) { return new BeamRenderable(pos, zOffset, length, width, color); }
+		public IRenderable WithZOffset(int newOffset) { return new BeamRenderable(pos, zOffset, length, width, color); }
+		public IRenderable WithPos(WPos pos) { return new BeamRenderable(pos, zOffset, length, width, color); }
+
+		public void BeforeRender(WorldRenderer wr) {}
+		public void Render(WorldRenderer wr)
+		{
+			var wlr = Game.Renderer.WorldLineRenderer;
+			var src = wr.ScreenPosition(pos);
+			var dest = wr.ScreenPosition(pos + length);
+
+			var lineWidth = wlr.LineWidth;
+			if (lineWidth != width)
+			{
+				wlr.Flush();
+				wlr.LineWidth = width;
+			}
+			
+			wlr.DrawLine(src, dest, color, color);
+			
+			if (lineWidth != width)
+			{
+				wlr.Flush();
+				wlr.LineWidth = lineWidth;
+			}
+		}
+
+		public void RenderDebugGeometry(WorldRenderer wr) {}
+	}
+}

OpenRA.Game/Graphics/ContrailRenderable.cs

@@ -0,0 +1,105 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2013 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation. For more information,
+ * see COPYING.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+
+namespace OpenRA.Graphics
+{
+	public struct ContrailRenderable : IRenderable
+	{
+		readonly World world;
+
+		// Store trail positions in a circular buffer
+		readonly WPos[] trail;
+		int next;
+		int length;
+		int skip;
+
+		readonly Color color;
+		readonly int zOffset;
+
+		public ContrailRenderable(World world, Color color, int length, int skip, int zOffset)
+			: this(world, new WPos[length], 0, 0, skip, color, zOffset) {}
+
+		ContrailRenderable(World world, WPos[] trail, int next, int length, int skip, Color color, int zOffset)
+		{
+			this.world = world;
+			this.trail = trail;
+			this.next = next;
+			this.length = length;
+			this.skip = skip;
+			this.color = color;
+			this.zOffset = zOffset;
+		}
+
+		public WPos Pos { get { return trail[idx(next-1)]; } }
+		public float Scale { get { return 1f; } }
+		public PaletteReference Palette { get { return null; } }
+		public int ZOffset { get { return zOffset; } }
+
+		public IRenderable WithScale(float newScale) { return new ContrailRenderable(world, (WPos[])trail.Clone(), next, length, skip, color, zOffset); }
+		public IRenderable WithPalette(PaletteReference newPalette) { return new ContrailRenderable(world, (WPos[])trail.Clone(), next, length, skip, color, zOffset); }
+		public IRenderable WithZOffset(int newOffset) { return new ContrailRenderable(world, (WPos[])trail.Clone(), next, length, skip, color, newOffset); }
+		public IRenderable WithPos(WPos pos) { return new ContrailRenderable(world, (WPos[])trail.Clone(), next, length, skip, color, zOffset); }
+
+		public void BeforeRender(WorldRenderer wr) {}
+		public void Render(WorldRenderer wr)
+		{
+			// Need at least 4 points to smooth the contrail over
+			if (length - skip < 4 )
+				return;
+
+			// Start of the first line segment is the tail of the list - don't smooth it.
+			var curPos = trail[idx(next - skip - 1)];
+			var curCell = curPos.ToCPos();
+			var curColor = color;
+			for (var i = 0; i < length - skip - 4; i++)
+			{
+				var j = next - skip - i - 2;
+				var nextPos = WPos.Average(trail[idx(j)], trail[idx(j-1)], trail[idx(j-2)], trail[idx(j-3)]);
+				var nextCell = nextPos.ToCPos();
+				var nextColor = Exts.ColorLerp(i * 1f / (length - 4), color, Color.Transparent);
+
+				if (!world.FogObscures(curCell) && !world.FogObscures(nextCell))
+					Game.Renderer.WorldLineRenderer.DrawLine(wr.ScreenPosition(curPos), wr.ScreenPosition(nextPos), curColor, nextColor);
+
+				curPos = nextPos;
+				curCell = nextCell;
+				curColor = nextColor;
+			}
+		}
+
+		public void RenderDebugGeometry(WorldRenderer wr) {}
+
+		// Array index modulo length
+		int idx(int i)
+		{
+			var j = i % trail.Length;
+			return j < 0 ? j + trail.Length : j;
+		}
+
+		public void Update(WPos pos)
+		{
+			trail[next] = pos;
+			next = idx(next+1);
+
+			if (length < trail.Length)
+				length++;
+		}
+
+		public static Color ChooseColor(Actor self)
+		{
+			var ownerColor = Color.FromArgb(255, self.Owner.Color.RGB);
+			return Exts.ColorLerp(0.5f, ownerColor, Color.White);
+		}
+	}
+}

OpenRA.Game/Graphics/CursorProvider.cs

@@ -1,6 +1,6 @@
 #region Copyright & License Information
 /*
- * Copyright 2007-2011 The OpenRA Developers (see AUTHORS)
+ * Copyright 2007-2013 The OpenRA Developers (see AUTHORS)
  * This file is part of OpenRA, which is free software. It is made
  * available to you under the terms of the GNU General Public License
  * as published by the Free Software Foundation. For more information,
@@ -14,23 +14,46 @@ using System.IO;
 using System.Linq;
 using System.Xml;
 using OpenRA.FileFormats;
+using OpenRA.Traits;
 
 namespace OpenRA.Graphics
 {
 	public static class CursorProvider
 	{
+		static HardwarePalette palette;
 		static Dictionary<string, CursorSequence> cursors;
+		static Cache<string, PaletteReference> palettes;
+
+		static PaletteReference CreatePaletteReference(string name)
+		{
+			var pal = palette.GetPalette(name);
+			if (pal == null)
+				throw new InvalidOperationException("Palette `{0}` does not exist".F(name));
+
+			return new PaletteReference(name, palette.GetPaletteIndex(name), pal);
+		}
 
 		public static void Initialize(string[] sequenceFiles)
 		{
 			cursors = new Dictionary<string, CursorSequence>();
+			palettes = new Cache<string, PaletteReference>(CreatePaletteReference);
 			var sequences = new MiniYaml(null, sequenceFiles.Select(s => MiniYaml.FromFile(s)).Aggregate(MiniYaml.MergeLiberal));
+			int[] ShadowIndex = { };
 
-			foreach (var s in sequences.NodesDict["Palettes"].Nodes)
-				Game.modData.Palette.AddPalette(s.Key, new Palette(FileSystem.Open(s.Value.Value), false));
+			if (sequences.NodesDict.ContainsKey("ShadowIndex"))
+			{
+				Array.Resize(ref ShadowIndex, ShadowIndex.Length + 1);
+				int.TryParse(sequences.NodesDict["ShadowIndex"].Value, out ShadowIndex[ShadowIndex.Length - 1]);
+			}
+
+			palette = new HardwarePalette();
+			foreach (var p in sequences.NodesDict["Palettes"].Nodes)
+				palette.AddPalette(p.Key, new Palette(FileSystem.Open(p.Value.Value), ShadowIndex), false);
 
 			foreach (var s in sequences.NodesDict["Cursors"].Nodes)
 				LoadSequencesForCursor(s.Key, s.Value);
+
+			palette.Initialize();
 		}
 
 		static void LoadSequencesForCursor(string cursorSrc, MiniYaml cursor)
@@ -46,6 +69,18 @@ namespace OpenRA.Graphics
 			return cursors.ContainsKey(cursor);
 		}
 
+		public static void DrawCursor(Renderer renderer, string cursorName, int2 lastMousePos, int cursorFrame)
+		{
+			var cursorSequence = GetCursorSequence(cursorName);
+			var cursorSprite = cursorSequence.GetSprite(cursorFrame);
+
+			renderer.SetPalette(palette);
+			renderer.SpriteRenderer.DrawSprite(cursorSprite,
+			                                   lastMousePos - cursorSequence.Hotspot,
+			                                   palettes[cursorSequence.Palette],
+			                                   cursorSprite.size);
+		}
+
 		public static CursorSequence GetCursorSequence(string cursor)
 		{
 			try { return cursors[cursor]; }

OpenRA.Game/Graphics/HardwarePalette.cs

@@ -22,15 +22,17 @@ namespace OpenRA.Graphics
 		public const int MaxPalettes = 256;
 		int allocated = 0;
 
-		ITexture texture;
+		public ITexture Texture { get; private set; }
 		Dictionary<string, Palette> palettes;
 		Dictionary<string, int> indices;
+		Dictionary<string, bool> allowsMods;
 
 		public HardwarePalette()
 		{
 			palettes = new Dictionary<string, Palette>();
 			indices = new Dictionary<string, int>();
-			texture = Game.Renderer.Device.CreateTexture();
+			allowsMods = new Dictionary<string, bool>();
+			Texture = Game.Renderer.Device.CreateTexture();
 		}
 
 		public Palette GetPalette(string name)
@@ -49,22 +51,24 @@ namespace OpenRA.Graphics
 			return ret;
 		}
 
-		public void AddPalette(string name, Palette p)
+		public void AddPalette(string name, Palette p, bool allowModifiers)
 		{
 			if (palettes.ContainsKey(name))
 				throw new InvalidOperationException("Palette {0} has already been defined".F(name));
 
 			palettes.Add(name, p);
 			indices.Add(name, allocated++);
+			allowsMods.Add(name, allowModifiers);
 		}
 
 		uint[,] data = new uint[MaxPalettes, 256];
-		public void Update(IEnumerable<IPaletteModifier> paletteMods)
+		public void ApplyModifiers(IEnumerable<IPaletteModifier> paletteMods)
 		{
 			var copy = palettes.ToDictionary(p => p.Key, p => new Palette(p.Value));
+			var modifiable = copy.Where(p => allowsMods[p.Key]).ToDictionary(p => p.Key, p => p.Value);
 
 			foreach (var mod in paletteMods)
-				mod.AdjustPalette(copy);
+				mod.AdjustPalette(modifiable);
 
 			foreach (var pal in copy)
 			{
@@ -74,9 +78,12 @@ namespace OpenRA.Graphics
 					data[j,i] = c[i];
 			}
 
-			// Doesn't work
-			texture.SetData(data);
-			Game.Renderer.PaletteTexture = texture;
+			Texture.SetData(data);
+		}
+
+		public void Initialize()
+		{
+			ApplyModifiers(new IPaletteModifier[] {});
 		}
 	}
 }

OpenRA.Game/Graphics/LineRenderer.cs

@@ -21,10 +21,10 @@ namespace OpenRA.Graphics
 		Renderer renderer;
 		IShader shader;
 
-		Vertex[] vertices = new Vertex[ Renderer.TempBufferSize ];
+		Vertex[] vertices = new Vertex[Renderer.TempBufferSize];
 		int nv = 0;
 
-		public LineRenderer( Renderer renderer, IShader shader )
+		public LineRenderer(Renderer renderer, IShader shader)
 		{
 			this.renderer = renderer;
 			this.shader = shader;
@@ -32,50 +32,58 @@ namespace OpenRA.Graphics
 
 		public void Flush()
 		{
-			if( nv > 0 )
+			if (nv > 0)
 			{
-				shader.Render( () =>
+				renderer.Device.EnableAlphaBlending();
+				shader.Render(() =>
 				{
 					var vb = renderer.GetTempVertexBuffer();
-					vb.SetData( vertices, nv );
-					renderer.SetLineWidth(LineWidth);
-					renderer.DrawBatch( vb,	0, nv, PrimitiveType.LineList );
-				} );
-
+					vb.SetData(vertices, nv);
+					renderer.SetLineWidth(LineWidth * Game.viewport.Zoom);
+					renderer.DrawBatch(vb, 0, nv, PrimitiveType.LineList);
+				});
+				renderer.Device.DisableAlphaBlending();
 				nv = 0;
 			}
 		}
 
-		public void DrawRect( float2 tl, float2 br, Color c )
+		public void DrawRect(float2 tl, float2 br, Color c)
 		{
-			var tr = new float2( br.X, tl.Y );
-			var bl = new float2( tl.X, br.Y );
-			DrawLine( tl, tr, c, c );
-			DrawLine( tl, bl, c, c );
-			DrawLine( tr, br, c, c );
-			DrawLine( bl, br, c, c );
+			var tr = new float2(br.X, tl.Y);
+			var bl = new float2(tl.X, br.Y);
+			DrawLine(tl, tr, c, c);
+			DrawLine(tl, bl, c, c);
+			DrawLine(tr, br, c, c);
+			DrawLine(bl, br, c, c);
 		}
 
-		public void DrawLine( float2 start, float2 end, Color startColor, Color endColor )
+		public void DrawLine(float2 start, float2 end, Color startColor, Color endColor)
 		{
 			Renderer.CurrentBatchRenderer = this;
 
-			if( nv + 2 > Renderer.TempBufferSize )
+			if (nv + 2 > Renderer.TempBufferSize)
 				Flush();
 
-			vertices[ nv++ ] = new Vertex( start + offset,
-				new float2( startColor.R / 255.0f, startColor.G / 255.0f ),
-				new float2( startColor.B / 255.0f, startColor.A / 255.0f ) );
+			vertices[nv++] = new Vertex(start + offset,
+				new float2(startColor.R / 255.0f, startColor.G / 255.0f),
+				new float2(startColor.B / 255.0f, startColor.A / 255.0f));
 
-			vertices[ nv++ ] = new Vertex( end + offset,
-				new float2( endColor.R / 255.0f, endColor.G / 255.0f ),
-				new float2( endColor.B / 255.0f, endColor.A / 255.0f ) );
+			vertices[nv++] = new Vertex(end + offset,
+				new float2(endColor.R / 255.0f, endColor.G / 255.0f),
+				new float2(endColor.B / 255.0f, endColor.A / 255.0f));
 		}
 
-		public void FillRect( RectangleF r, Color color )
+		public void FillRect(RectangleF r, Color color)
 		{
-			for (float y = r.Top; y < r.Bottom; y++)
+			for (var y = r.Top; y < r.Bottom; y++)
 				DrawLine(new float2(r.Left, y), new float2(r.Right, y), color, color);
 		}
+
+		public void SetViewportParams(Size screen, float zoom, float2 scroll)
+		{
+			shader.SetVec("Scroll", (int)scroll.X, (int)scroll.Y);
+			shader.SetVec("r1", zoom*2f/screen.Width, -zoom*2f/screen.Height);
+			shader.SetVec("r2", -1, 1);
+		}
 	}
 }

OpenRA.Game/Graphics/Minimap.cs

@@ -32,13 +32,11 @@ namespace OpenRA.Graphics
 			var height = map.Bounds.Height;
 
 			if (!actualSize)
-			{
 				width = height = Exts.NextPowerOf2(Math.Max(map.Bounds.Width, map.Bounds.Height));
-			}
 
 			var terrain = new Bitmap(width, height);
 
-			var bitmapData = terrain.LockBits(new Rectangle(0, 0, terrain.Width, terrain.Height),
+			var bitmapData = terrain.LockBits(terrain.Bounds(),
 				ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
 
 			unsafe
@@ -69,7 +67,7 @@ namespace OpenRA.Graphics
 			Bitmap terrain = new Bitmap(terrainBitmap);
 			var tileset = Rules.TileSets[map.Tileset];
 
-			var bitmapData = terrain.LockBits(new Rectangle(0, 0, terrain.Width, terrain.Height),
+			var bitmapData = terrain.LockBits(terrain.Bounds(),
 				ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
 
 			unsafe
@@ -104,7 +102,7 @@ namespace OpenRA.Graphics
 			var map = world.Map;
 			var size = Exts.NextPowerOf2(Math.Max(map.Bounds.Width, map.Bounds.Height));
 			var bitmap = new Bitmap(size, size);
-			var bitmapData = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height),
+			var bitmapData = bitmap.LockBits(bitmap.Bounds(),
 				ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
 
 			unsafe
@@ -132,7 +130,7 @@ namespace OpenRA.Graphics
 			var map = world.Map;
 			var size = Exts.NextPowerOf2(Math.Max(map.Bounds.Width, map.Bounds.Height));
 			var bitmap = new Bitmap(size, size);
-			var bitmapData = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height),
+			var bitmapData = bitmap.LockBits(bitmap.Bounds(),
 				ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
 
 			unsafe
@@ -141,7 +139,7 @@ namespace OpenRA.Graphics
 
 				foreach (var t in world.ActorsWithTrait<IRadarSignature>())
 				{
-					if (!world.LocalShroud.IsVisible(t.Actor))
+					if (world.FogObscures(t.Actor))
 						continue;
 
 					var color = t.Trait.RadarSignatureColor(t.Actor);
@@ -160,10 +158,10 @@ namespace OpenRA.Graphics
 			var map = world.Map;
 			var size = Exts.NextPowerOf2(Math.Max(map.Bounds.Width, map.Bounds.Height));
 			var bitmap = new Bitmap(size, size);
-			if (world.LocalShroud.Disabled)
+			if (world.RenderPlayer == null)
 				return bitmap;
 
-			var bitmapData = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height),
+			var bitmapData = bitmap.LockBits(bitmap.Bounds(),
 				ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
 
 			var shroud = Color.Black.ToArgb();
@@ -176,11 +174,10 @@ namespace OpenRA.Graphics
 				for (var x = 0; x < map.Bounds.Width; x++)
 					for (var y = 0; y < map.Bounds.Height; y++)
 					{
-						var mapX = x + map.Bounds.Left;
-						var mapY = y + map.Bounds.Top;
-						if (!world.LocalShroud.IsExplored(mapX, mapY))
+						var p = new CPos(x + map.Bounds.Left, y + map.Bounds.Top);
+						if (world.ShroudObscures(p))
 							*(c + (y * bitmapData.Stride >> 2) + x) = shroud;
-						else if (!world.LocalShroud.IsVisible(mapX,mapY))
+						else if (world.FogObscures(p))
 							*(c + (y * bitmapData.Stride >> 2) + x) = fog;
 					}
 			}

OpenRA.Game/Graphics/QuadRenderer.cs

@@ -0,0 +1,69 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2011 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation. For more information,
+ * see COPYING.
+ */
+#endregion
+
+using System.Drawing;
+using OpenRA.FileFormats.Graphics;
+
+namespace OpenRA.Graphics
+{
+	public class QuadRenderer : Renderer.IBatchRenderer
+	{
+		Renderer renderer;
+		IShader shader;
+
+		Vertex[] vertices = new Vertex[Renderer.TempBufferSize];
+		int nv = 0;
+
+		public QuadRenderer(Renderer renderer, IShader shader)
+		{
+			this.renderer = renderer;
+			this.shader = shader;
+		}
+
+		public void Flush()
+		{
+			if (nv > 0)
+			{
+				renderer.Device.EnableAlphaBlending();
+				shader.Render(() =>
+				{
+					var vb = renderer.GetTempVertexBuffer();
+					vb.SetData(vertices, nv);
+					renderer.DrawBatch(vb, 0, nv, PrimitiveType.QuadList);
+				});
+				renderer.Device.DisableAlphaBlending();
+
+				nv = 0;
+			}
+		}
+
+		public void FillRect(RectangleF r, Color color)
+		{
+			Renderer.CurrentBatchRenderer = this;
+
+			if (nv + 4 > Renderer.TempBufferSize)
+				Flush();
+
+			vertices[nv] = new Vertex(new float2(r.Left, r.Top), new float2(color.R / 255.0f, color.G / 255.0f), new float2(color.B / 255.0f, color.A / 255.0f));
+			vertices[nv + 1] = new Vertex(new float2(r.Right, r.Top), new float2(color.R / 255.0f, color.G / 255.0f), new float2(color.B / 255.0f, color.A / 255.0f));
+			vertices[nv + 2] = new Vertex(new float2(r.Right, r.Bottom), new float2(color.R / 255.0f, color.G / 255.0f), new float2(color.B / 255.0f, color.A / 255.0f));
+			vertices[nv + 3] = new Vertex(new float2(r.Left, r.Bottom), new float2(color.R / 255.0f, color.G / 255.0f), new float2(color.B / 255.0f, color.A / 255.0f));
+
+			nv += 4;
+		}
+
+		public void SetViewportParams(Size screen, float zoom, float2 scroll)
+		{
+			shader.SetVec("Scroll", (int)scroll.X, (int)scroll.Y);
+			shader.SetVec("r1", zoom*2f/screen.Width, -zoom*2f/screen.Height);
+			shader.SetVec("r2", -1, 1);
+		}
+	}
+}

OpenRA.Game/Graphics/Renderable.cs

@@ -0,0 +1,91 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2013 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation. For more information,
+ * see COPYING.
+ */
+#endregion
+
+using System.Collections.Generic;
+using System.Drawing;
+
+namespace OpenRA.Graphics
+{
+	public class RenderableComparer : IComparer<IRenderable>
+	{
+		WorldRenderer wr;
+		public RenderableComparer(WorldRenderer wr)
+		{
+			this.wr = wr;
+		}
+
+		public int Compare(IRenderable x, IRenderable y)
+		{
+			var xOrder = wr.ScreenZPosition(x.Pos, x.ZOffset);
+			var yOrder = wr.ScreenZPosition(y.Pos, y.ZOffset);
+			return xOrder.CompareTo(yOrder);
+		}
+	}
+
+	public interface IRenderable
+	{
+		WPos Pos { get; }
+		float Scale { get; }
+		PaletteReference Palette { get; }
+		int ZOffset { get; }
+
+		IRenderable WithScale(float newScale);
+		IRenderable WithPalette(PaletteReference newPalette);
+		IRenderable WithZOffset(int newOffset);
+		IRenderable WithPos(WPos pos);
+		void BeforeRender(WorldRenderer wr);
+		void Render(WorldRenderer wr);
+		void RenderDebugGeometry(WorldRenderer wr);
+	}
+
+	public struct SpriteRenderable : IRenderable
+	{
+		readonly Sprite sprite;
+		readonly WPos pos;
+		readonly int zOffset;
+		readonly PaletteReference palette;
+		readonly float scale;
+
+		public SpriteRenderable(Sprite sprite, WPos pos, int zOffset, PaletteReference palette, float scale)
+		{
+			this.sprite = sprite;
+			this.pos = pos;
+			this.zOffset = zOffset;
+			this.palette = palette;
+			this.scale = scale;
+		}
+
+		// Provided for legacy support only - Don't use for new things!
+		public SpriteRenderable(Sprite sprite, float2 pos, PaletteReference palette, int z)
+			: this(sprite, new PPos((int)pos.X, (int)pos.Y).ToWPos(0), z, palette, 1f) { }
+
+		public WPos Pos { get { return pos; } }
+		public float Scale { get { return scale; } }
+		public PaletteReference Palette { get { return palette; } }
+		public int ZOffset { get { return zOffset; } }
+
+		public IRenderable WithScale(float newScale) { return new SpriteRenderable(sprite, pos, zOffset, palette, newScale); }
+		public IRenderable WithPalette(PaletteReference newPalette) { return new SpriteRenderable(sprite, pos, zOffset, newPalette, scale); }
+		public IRenderable WithZOffset(int newOffset) { return new SpriteRenderable(sprite, pos, newOffset, palette, scale); }
+		public IRenderable WithPos(WPos pos) { return new SpriteRenderable(sprite, pos, zOffset, palette, scale); }
+
+		public void BeforeRender(WorldRenderer wr) {}
+		public void Render(WorldRenderer wr)
+		{
+			sprite.DrawAt(wr.ScreenPxPosition(pos) - (0.5f*scale*sprite.size).ToInt2(), palette, scale);
+		}
+
+		public void RenderDebugGeometry(WorldRenderer wr)
+		{
+			var offset = wr.ScreenPxPosition(pos) - 0.5f*scale*sprite.size + sprite.offset;
+			Game.Renderer.WorldLineRenderer.DrawRect(offset, offset + sprite.size, Color.Red);
+		}
+	}
+}

OpenRA.Game/Graphics/Renderer.cs

@@ -26,20 +26,16 @@ namespace OpenRA.Graphics
 		internal static int SheetSize;
 		internal static int TempBufferSize;
 		internal static int TempBufferCount;
-		internal IShader WorldSpriteShader { get; private set; }
-		internal IShader WorldLineShader { get; private set; }
-		internal IShader LineShader { get; private set; }
-		internal IShader RgbaSpriteShader { get; private set; }
-		internal IShader SpriteShader { get; private set; }
 
 		public SpriteRenderer WorldSpriteRenderer { get; private set; }
+		public SpriteRenderer WorldRgbaSpriteRenderer { get; private set; }
+		public QuadRenderer WorldQuadRenderer { get; private set; }
 		public LineRenderer WorldLineRenderer { get; private set; }
+		public VoxelRenderer WorldVoxelRenderer { get; private set; }
 		public LineRenderer LineRenderer { get; private set; }
 		public SpriteRenderer RgbaSpriteRenderer { get; private set; }
 		public SpriteRenderer SpriteRenderer { get; private set; }
 
-		public ITexture PaletteTexture;
-
 		Queue<IVertexBuffer<Vertex>> tempBuffers = new Queue<IVertexBuffer<Vertex>>();
 
 		public Dictionary<string, SpriteFont> Fonts;
@@ -50,20 +46,17 @@ namespace OpenRA.Graphics
 			TempBufferCount = Game.Settings.Graphics.NumTempBuffers;
 			SheetSize = Game.Settings.Graphics.SheetSize;
 
-			WorldSpriteShader = device.CreateShader("world-shp");
-			WorldLineShader = device.CreateShader("world-line");
-			LineShader = device.CreateShader("chrome-line");
-			RgbaSpriteShader = device.CreateShader("chrome-rgba");
-			SpriteShader = device.CreateShader("chrome-shp");
+			WorldSpriteRenderer = new SpriteRenderer(this, device.CreateShader("shp"));
+			WorldRgbaSpriteRenderer = new SpriteRenderer(this, device.CreateShader("rgba"));
+			WorldLineRenderer = new LineRenderer(this, device.CreateShader("line"));
+			WorldVoxelRenderer = new VoxelRenderer(this, device.CreateShader("vxl"));
+			LineRenderer = new LineRenderer(this, device.CreateShader("line"));
+			WorldQuadRenderer = new QuadRenderer(this, device.CreateShader("line"));
+			RgbaSpriteRenderer = new SpriteRenderer(this, device.CreateShader("rgba"));
+			SpriteRenderer = new SpriteRenderer(this, device.CreateShader("shp"));
 
-			WorldSpriteRenderer = new SpriteRenderer( this, WorldSpriteShader );
-			WorldLineRenderer = new LineRenderer(this, WorldLineShader);
-			LineRenderer = new LineRenderer(this, LineShader);
-			RgbaSpriteRenderer = new SpriteRenderer( this, RgbaSpriteShader );
-			SpriteRenderer = new SpriteRenderer( this, SpriteShader );
-
-			for( int i = 0 ; i < TempBufferCount ; i++ )
-				tempBuffers.Enqueue( device.CreateVertexBuffer( TempBufferSize ) );
+			for (int i = 0; i < TempBufferCount; i++)
+				tempBuffers.Enqueue(device.CreateVertexBuffer(TempBufferSize));
 		}
 
 		public void InitializeFonts(Manifest m)
@@ -76,28 +69,33 @@ namespace OpenRA.Graphics
 		public void BeginFrame(float2 scroll, float zoom)
 		{
 			device.Clear();
-
-			WorldLineRenderer.LineWidth = zoom;
-			float2 r1 = new float2(2f/Resolution.Width, -2f/Resolution.Height);
-			float2 r2 = new float2(-1, 1);
-			var zr1 = zoom*r1;
-
-			SetShaderParams( WorldSpriteShader, zr1, r2, scroll );
-			SetShaderParams( WorldLineShader, zr1, r2, scroll );
-			SetShaderParams( LineShader, r1, r2, scroll );
-			SetShaderParams( RgbaSpriteShader, r1, r2, scroll );
-			SetShaderParams( SpriteShader, r1, r2, scroll );
+			WorldSpriteRenderer.SetViewportParams(Resolution, zoom, scroll);
+			WorldRgbaSpriteRenderer.SetViewportParams(Resolution, zoom, scroll);
+			SpriteRenderer.SetViewportParams(Resolution, 1f, float2.Zero);
+			RgbaSpriteRenderer.SetViewportParams(Resolution, 1f, float2.Zero);
+			WorldLineRenderer.SetViewportParams(Resolution, zoom, scroll);
+			WorldQuadRenderer.SetViewportParams(Resolution, zoom, scroll);
+			LineRenderer.SetViewportParams(Resolution, 1f, float2.Zero);
+			WorldVoxelRenderer.SetViewportParams(Resolution, zoom, scroll);
 		}
 
-		void SetShaderParams( IShader s, float2 r1, float2 r2, float2 scroll )
+		ITexture currentPaletteTexture;
+		public void SetPalette(HardwarePalette palette)
 		{
-			s.SetValue( "Palette", PaletteTexture );
-			s.SetValue( "Scroll", (int) scroll.X, (int) scroll.Y );
-			s.SetValue( "r1", r1.X, r1.Y );
-			s.SetValue( "r2", r2.X, r2.Y );
+			if (palette.Texture == currentPaletteTexture)
+				return;
+
+			Flush();
+			currentPaletteTexture = palette.Texture;
+
+			RgbaSpriteRenderer.SetPalette(currentPaletteTexture);
+			SpriteRenderer.SetPalette(currentPaletteTexture);
+			WorldSpriteRenderer.SetPalette(currentPaletteTexture);
+			WorldRgbaSpriteRenderer.SetPalette(currentPaletteTexture);
+			WorldVoxelRenderer.SetPalette(currentPaletteTexture);
 		}
 
-		public void EndFrame( IInputHandler inputHandler )
+		public void EndFrame(IInputHandler inputHandler)
 		{
 			Flush();
 			device.PumpInput(inputHandler);
@@ -131,14 +129,17 @@ namespace OpenRA.Graphics
 		// which makes the window non-interactive in Windowed/Pseudofullscreen mode.
 		static Screen FixOSX() { return Screen.PrimaryScreen; }
 
-		internal static void Initialize( WindowMode windowMode )
+		internal static void Initialize(WindowMode windowMode)
 		{
 			if (Platform.CurrentPlatform == PlatformType.OSX)
 				FixOSX();
 
-			var resolution = GetResolution( windowMode );
-			var rendererPath = Path.GetFullPath( "OpenRA.Renderer.{0}.dll".F(Game.Settings.Graphics.Renderer) );
-			device = CreateDevice( Assembly.LoadFile( rendererPath ), resolution.Width, resolution.Height, windowMode );
+			var resolution = GetResolution(windowMode);
+			
+			string renderer = Game.Settings.Server.Dedicated ? "Null" : Game.Settings.Graphics.Renderer;
+			var rendererPath = Path.GetFullPath("OpenRA.Renderer.{0}.dll".F(renderer));
+			
+			device = CreateDevice(Assembly.LoadFile(rendererPath), resolution.Width, resolution.Height, windowMode);
 		}
 
 		static Size GetResolution(WindowMode windowmode)
@@ -149,12 +150,12 @@ namespace OpenRA.Graphics
 			return new Size(size.X, size.Y);
 		}
 
-		static IGraphicsDevice CreateDevice( Assembly rendererDll, int width, int height, WindowMode window )
+		static IGraphicsDevice CreateDevice(Assembly rendererDll, int width, int height, WindowMode window)
 		{
-			foreach( RendererAttribute r in rendererDll.GetCustomAttributes( typeof( RendererAttribute ), false ) )
+			foreach (RendererAttribute r in rendererDll.GetCustomAttributes(typeof(RendererAttribute), false))
 			{
-				var factory = (IDeviceFactory) r.Type.GetConstructor( Type.EmptyTypes ).Invoke( null );
-				return factory.Create( new Size( width, height ), window );
+				var factory = (IDeviceFactory)r.Type.GetConstructor(Type.EmptyTypes).Invoke(null);
+				return factory.Create(new Size(width, height), window);
 			}
 
 			throw new InvalidOperationException("Renderer DLL is missing RendererAttribute to tell us what type to use!");
@@ -163,7 +164,7 @@ namespace OpenRA.Graphics
 		internal IVertexBuffer<Vertex> GetTempVertexBuffer()
 		{
 			var ret = tempBuffers.Dequeue();
-			tempBuffers.Enqueue( ret );
+			tempBuffers.Enqueue(ret);
 			return ret;
 		}
 
@@ -175,8 +176,8 @@ namespace OpenRA.Graphics
 			get { return currentBatchRenderer; }
 			set
 			{
-				if( currentBatchRenderer == value ) return;
-				if( currentBatchRenderer != null )
+				if (currentBatchRenderer == value) return;
+				if (currentBatchRenderer != null)
 					currentBatchRenderer.Flush();
 				currentBatchRenderer = value;
 			}
@@ -185,7 +186,7 @@ namespace OpenRA.Graphics
 		public void EnableScissor(int left, int top, int width, int height)
 		{
 			Flush();
-			Device.EnableScissor( left, top, width, height );
+			Device.EnableScissor(left, top, width, height);
 		}
 
 		public void DisableScissor()
@@ -193,5 +194,17 @@ namespace OpenRA.Graphics
 			Flush();
 			Device.DisableScissor();
 		}
+
+		public void EnableDepthBuffer()
+		{
+			Flush();
+			Device.EnableDepthBuffer();
+		}
+
+		public void DisableDepthBuffer()
+		{
+			Flush();
+			Device.DisableDepthBuffer();
+		}
 	}
 }

OpenRA.Game/Graphics/Sequence.cs

@@ -8,34 +8,45 @@
  */
 #endregion
 
+using System;
 using System.Xml;
-using OpenRA.FileFormats;
 using System.Collections.Generic;
+using System.Linq;
+using OpenRA.FileFormats;
 
 namespace OpenRA.Graphics
 {
 	public class Sequence
 	{
 		readonly Sprite[] sprites;
-		readonly int start, length, facings, tick;
+		readonly int start, length, stride, facings, tick;
+		readonly bool reverseFacings, transpose;
 
 		public readonly string Name;
 		public int Start { get { return start; } }
 		public int End { get { return start + length; } }
 		public int Length { get { return length; } }
+		public int Stride { get { return stride; } }
 		public int Facings { get { return facings; } }
 		public int Tick { get { return tick; } }
 
-		string srcOverride;
 		public Sequence(string unit, string name, MiniYaml info)
 		{
-			srcOverride = info.Value;
+			var srcOverride = info.Value;
 			Name = name;
 			var d = info.NodesDict;
+			var offset = float2.Zero;
 
-			sprites = Game.modData.SpriteLoader.LoadAllSprites(string.IsNullOrEmpty(srcOverride) ? unit : srcOverride );
 			start = int.Parse(d["Start"].Value);
 
+			if (d.ContainsKey("Offset"))
+				offset = FieldLoader.GetValue<float2>("Offset", d["Offset"].Value);
+
+			// Apply offset to each sprite in the sequence
+			// Different sequences may apply different offsets to the same frame
+			sprites = Game.modData.SpriteLoader.LoadAllSprites(srcOverride ?? unit).Select(
+				s => new Sprite(s.sheet, s.bounds, s.offset + offset, s.channel)).ToArray();
+
 			if (!d.ContainsKey("Length"))
 				length = 1;
 			else if (d["Length"].Value == "*")
@@ -43,47 +54,56 @@ namespace OpenRA.Graphics
 			else
 				length = int.Parse(d["Length"].Value);
 
+			if (d.ContainsKey("Stride"))
+				stride = int.Parse(d["Stride"].Value);
+			else
+				stride = length;
 
-			if(d.ContainsKey("Facings"))
-				facings = int.Parse(d["Facings"].Value);
+			if (d.ContainsKey("Facings"))
+			{
+				var f = int.Parse(d["Facings"].Value);
+				facings = Math.Abs(f);
+				reverseFacings = f < 0;
+			}
 			else
 				facings = 1;
 
-			if(d.ContainsKey("Tick"))
+			if (d.ContainsKey("Tick"))
 				tick = int.Parse(d["Tick"].Value);
 			else
 				tick = 40;
+
+			if (d.ContainsKey("Transpose"))
+			    transpose = bool.Parse(d["Transpose"].Value);
+
+			if (length > stride)
+				throw new InvalidOperationException(
+					"{0}: Sequence {1}.{2}: Length must be <= stride"
+						.F(info.Nodes[0].Location, unit, name));
+
+			if (start < 0 || start + facings * stride > sprites.Length)
+				throw new InvalidOperationException(
+					"{6}: Sequence {0}.{1} uses frames [{2}..{3}] of SHP `{4}`, but only 0..{5} actually exist"
+					.F(unit, name, start, start + facings * stride - 1, srcOverride ?? unit, sprites.Length - 1,
+					info.Nodes[0].Location));
 		}
 
-		public MiniYaml Save()
+		public Sprite GetSprite(int frame)
 		{
-			var root = new List<MiniYamlNode>();
-
-			root.Add(new MiniYamlNode("Start", start.ToString()));
-
-			if (length > 1 && (start != 0 || length != sprites.Length - start))
-				root.Add(new MiniYamlNode("Length", length.ToString()));
-			else if (length > 1 && length == sprites.Length - start)
-				root.Add(new MiniYamlNode("Length", "*"));
-
-			if (facings > 1)
-				root.Add(new MiniYamlNode("Facings", facings.ToString()));
-
-			if (tick != 40)
-				root.Add(new MiniYamlNode("Tick", tick.ToString()));
-
-			return new MiniYaml(srcOverride, root);
-		}
-
-		public Sprite GetSprite( int frame )
-		{
-			return GetSprite( frame, 0 );
+			return GetSprite(frame, 0);
 		}
 
 		public Sprite GetSprite(int frame, int facing)
 		{
-			var f = Traits.Util.QuantizeFacing( facing, facings );
-			return sprites[ (f * length) + ( frame % length ) + start ];
+			var f = Traits.Util.QuantizeFacing(facing, facings);
+
+			if (reverseFacings)
+				f = (facings - f) % facings;
+
+			int i = transpose ? (frame % length) * facings + f :
+				(f * stride) + (frame % length);
+
+			return sprites[start + i];
 		}
 	}
 }

OpenRA.Game/Graphics/SequenceProvider.cs

@@ -40,7 +40,10 @@ namespace OpenRA.Graphics
 				var seq = sequences.NodesDict.ToDictionary(x => x.Key, x => new Sequence(unit,x.Key,x.Value));
 				units.Add(unit, seq);
 			}
-			catch (FileNotFoundException) {} // Do nothing; we can crash later if we actually wanted art
+			catch (FileNotFoundException)
+			{
+				// Do nothing; we can crash later if we actually wanted art
+			} 
 		}
 
 		public static Sequence GetSequence(string unitName, string sequenceName)
@@ -53,7 +56,7 @@ namespace OpenRA.Graphics
 						"Unit `{0}` does not have a sequence `{1}`".F(unitName, sequenceName));
 				else
 					throw new InvalidOperationException(
-						"Unit `{0}` does not have any sequences defined.".F(unitName));
+						"Unit `{0}` does not have all sequences defined.".F(unitName));
 			}
 		}
 
@@ -61,7 +64,7 @@ namespace OpenRA.Graphics
 		{
 			if (!units.ContainsKey(unit))
 				throw new InvalidOperationException(
-					"Unit `{0}` does not have any sequences defined.".F(unit));
+					"Unit `{0}` does not have sequence `{1}` defined.".F(unit, seq));
 
 			return units[unit].ContainsKey(seq);
 		}

OpenRA.Game/Graphics/Sheet.cs

@@ -8,7 +8,9 @@
  */
 #endregion
 
+using System;
 using System.Drawing;
+using System.Drawing.Imaging;
 using OpenRA.FileFormats;
 using OpenRA.FileFormats.Graphics;
 
@@ -16,21 +18,52 @@ namespace OpenRA.Graphics
 {
 	public class Sheet
 	{
-		Bitmap bitmap;
 		ITexture texture;
 		bool dirty;
 		byte[] data;
+
 		public readonly Size Size;
+		public byte[] Data { get { return data ?? texture.GetData(); } }
 
 		public Sheet(Size size)
 		{
 			Size = size;
+			data = new byte[4*Size.Width*Size.Height];
+		}
+
+		public Sheet(ITexture texture)
+		{
+			this.texture = texture;
+			Size = texture.Size;
 		}
 
 		public Sheet(string filename)
 		{
-			bitmap = (Bitmap)Image.FromStream(FileSystem.Open(filename));
+			var bitmap = (Bitmap)Image.FromStream(FileSystem.Open(filename));
 			Size = bitmap.Size;
+
+			data = new byte[4*Size.Width*Size.Height];
+			var b = bitmap.LockBits(bitmap.Bounds(),
+				ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
+
+			unsafe
+			{
+				int* c = (int*)b.Scan0;
+
+				for (var x = 0; x < Size.Width; x++)
+					for (var y = 0; y < Size.Height; y++)
+				{
+					var i = 4*Size.Width*y + 4*x;
+
+					// Convert argb to bgra
+					var argb = *(c + (y * b.Stride >> 2) + x);
+					data[i++] = (byte)(argb >> 0);
+					data[i++] = (byte)(argb >> 8);
+					data[i++] = (byte)(argb >> 16);
+					data[i++] = (byte)(argb >> 24);
+				}
+			}
+			bitmap.UnlockBits(b);
 		}
 
 		public ITexture Texture
@@ -45,23 +78,69 @@ namespace OpenRA.Graphics
 
 				if (dirty)
 				{
-					if (data != null)
-					{
-						texture.SetData(data, Size.Width, Size.Height);
-						dirty = false;
-					}
-					else if (bitmap != null)
-					{
-						texture.SetData(bitmap);
-						dirty = false;
-					}
+					texture.SetData(data, Size.Width, Size.Height);
+					dirty = false;
 				}
 
 				return texture;
 			}
 		}
 
-		public byte[] Data { get { if (data == null) data = new byte[4 * Size.Width * Size.Height]; return data; } }
-		public void MakeDirty() { dirty = true; }
+		public Bitmap AsBitmap()
+		{
+			var d = Data;
+			var b = new Bitmap(Size.Width, Size.Height);
+			var output = b.LockBits(new Rectangle(0, 0, Size.Width, Size.Height),
+				ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);
+
+			unsafe
+			{
+				int* c = (int*)output.Scan0;
+
+				for (var x = 0; x < Size.Width; x++)
+					for (var y = 0; y < Size.Height; y++)
+					{
+						var i = 4*Size.Width*y + 4*x;
+
+						// Convert bgra to argb
+						var argb = (d[i+3] << 24) | (d[i+2] << 16) | (d[i+1] << 8) | d[i];
+						*(c + (y * output.Stride >> 2) + x) = argb;
+					}
+			}
+			b.UnlockBits(output);
+
+			return b;
+		}
+
+		public Bitmap AsBitmap(TextureChannel channel, Palette pal)
+		{
+			var d = Data;
+			var b = new Bitmap(Size.Width, Size.Height);
+			var output = b.LockBits(new Rectangle(0, 0, Size.Width, Size.Height),
+				ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);
+
+			unsafe
+			{
+				int* c = (int*)output.Scan0;
+
+				for (var x = 0; x < Size.Width; x++)
+					for (var y = 0; y < Size.Height; y++)
+				{
+					var index = d[4*Size.Width*y + 4*x + (int)channel];
+					*(c + (y * output.Stride >> 2) + x) = pal.GetColor(index).ToArgb();
+				}
+			}
+			b.UnlockBits(output);
+
+			return b;
+		}
+
+		public void CommitData()
+		{
+			if (data == null)
+				throw new InvalidOperationException("Texture-wrappers are read-only");
+
+			dirty = true;
+		}
 	}
 }

OpenRA.Game/Graphics/SheetBuilder.cs

@@ -8,68 +8,78 @@
  */
 #endregion
 
+using System;
 using System.Drawing;
 
 namespace OpenRA.Graphics
 {
+	public class SheetOverflowException : Exception
+	{
+		public SheetOverflowException(string message)
+			: base(message) {}
+	}
+
+	public enum SheetType
+	{
+		Indexed = 1,
+		DualIndexed = 2,
+		BGRA = 4,
+	}
+
 	public class SheetBuilder
 	{
-		internal SheetBuilder(TextureChannel ch)
+		Sheet current;
+		TextureChannel channel;
+		SheetType type;
+		int rowHeight = 0;
+		Point p;
+		Func<Sheet> allocateSheet;
+
+		public static Sheet AllocateSheet()
 		{
-			current = null;
-			rowHeight = 0;
-			channel = null;
-			initialChannel = ch;
+			return new Sheet(new Size(Renderer.SheetSize, Renderer.SheetSize));;
+		}
+
+		internal SheetBuilder(SheetType t)
+			: this(t, AllocateSheet) {}
+
+		internal SheetBuilder(SheetType t, Func<Sheet> allocateSheet)
+		{
+			channel = TextureChannel.Red;
+			type = t;
+			current = allocateSheet();
+			this.allocateSheet = allocateSheet;
 		}
 
 		public Sprite Add(byte[] src, Size size)
 		{
-			Sprite rect = Allocate(size);
+			var rect = Allocate(size);
 			Util.FastCopyIntoChannel(rect, src);
+			current.CommitData();
 			return rect;
 		}
 
 		public Sprite Add(Size size, byte paletteIndex)
 		{
-			byte[] data = new byte[size.Width * size.Height];
-			for (int i = 0; i < data.Length; i++)
+			var data = new byte[size.Width * size.Height];
+			for (var i = 0; i < data.Length; i++)
 				data[i] = paletteIndex;
 
 			return Add(data, size);
 		}
 
-		Sheet NewSheet() { return new Sheet(new Size( Renderer.SheetSize, Renderer.SheetSize ) ); }
-
-		Sheet current = null;
-		int rowHeight = 0;
-		Point p;
-		TextureChannel? channel = null;
-		TextureChannel initialChannel;
-
-		TextureChannel? NextChannel(TextureChannel? t)
+		TextureChannel? NextChannel(TextureChannel t)
 		{
-			if (t == null)
-				return initialChannel;
+			var nextChannel = (int)t + (int)type;
+			if (nextChannel > (int)TextureChannel.Alpha)
+				return null;
 
-			switch (t.Value)
-			{
-				case TextureChannel.Red: return TextureChannel.Green;
-				case TextureChannel.Green: return TextureChannel.Blue;
-				case TextureChannel.Blue: return TextureChannel.Alpha;
-				case TextureChannel.Alpha: return null;
-
-				default: return null;
-			}
+			return (TextureChannel)nextChannel;
 		}
 
-		public Sprite Allocate(Size imageSize)
+		public Sprite Allocate(Size imageSize) { return Allocate(imageSize, float2.Zero); }
+		public Sprite Allocate(Size imageSize, float2 spriteOffset)
 		{
-			if (current == null)
-			{
-				current = NewSheet();
-				channel = NextChannel(null);
-			}
-
 			if (imageSize.Width + p.X > current.Size.Width)
 			{
 				p = new Point(0, p.Y + rowHeight);
@@ -81,22 +91,25 @@ namespace OpenRA.Graphics
 
 			if (p.Y + imageSize.Height > current.Size.Height)
 			{
-
-				if (null == (channel = NextChannel(channel)))
+				var next = NextChannel(channel);
+				if (next == null)
 				{
-					current = NewSheet();
-					channel = NextChannel(channel);
+					current = allocateSheet();
+					channel = TextureChannel.Red;
 				}
+				else
+					channel = next.Value;
 
 				rowHeight = imageSize.Height;
 				p = new Point(0,0);
 			}
 
-			Sprite rect = new Sprite(current, new Rectangle(p, imageSize), channel.Value);
-			current.MakeDirty();
+			var rect = new Sprite(current, new Rectangle(p, imageSize), spriteOffset, channel);
 			p.X += imageSize.Width;
 
 			return rect;
 		}
+
+		public Sheet Current { get { return current; } }
 	}
 }