Index: graphics/GameView.cpp
===================================================================
--- graphics/GameView.cpp	(revision 15728)
+++ graphics/GameView.cpp	(working copy)
@@ -481,7 +481,7 @@
 
 	CheckLightEnv();
 
-	m->Game->CachePlayerColours();
+	m->Game->CachePlayerColors();
 }
 
 void CGameView::Render()
Index: graphics/LOSTexture.cpp
===================================================================
--- graphics/LOSTexture.cpp	(revision 15728)
+++ graphics/LOSTexture.cpp	(working copy)
@@ -229,7 +257,7 @@
 
 	glGenTextures(1, &m_Texture);
 
-	// Initialise texture with SoD colour, for the areas we don't
+	// Initialise texture with SoD color, for the areas we don't
 	// overwrite with glTexSubImage2D later
 	u8* texData = new u8[m_TextureSize * m_TextureSize * 4];
 	memset(texData, 0x00, m_TextureSize * m_TextureSize * 4);
Index: graphics/Model.cpp
===================================================================
--- graphics/Model.cpp	(revision 15728)
+++ graphics/Model.cpp	(working copy)
@@ -666,10 +666,10 @@
 		it->m_Model->SetPlayerID(id);
 }
 
-void CModel::SetShadingColor(const CColor& colour)
+void CModel::SetShadingColor(const CColor& color)
 {
-	CModelAbstract::SetShadingColor(colour);
+	CModelAbstract::SetShadingColor(color);
 
 	for (std::vector<Prop>::iterator it = m_Props.begin(); it != m_Props.end(); ++it)
-		it->m_Model->SetShadingColor(colour);
+		it->m_Model->SetShadingColor(color);
 }
Index: graphics/Model.h
===================================================================
--- graphics/Model.h	(revision 15728)
+++ graphics/Model.h	(working copy)
@@ -103,7 +103,7 @@
 	// set the model's player ID, recursively through props
 	void SetPlayerID(player_id_t id);
 	// set the models mod color
-	virtual void SetShadingColor(const CColor& colour);
+	virtual void SetShadingColor(const CColor& color);
 	// get the model's material
 	CMaterial& GetMaterial() { return m_Material; }
 
Index: graphics/ModelAbstract.h
===================================================================
--- graphics/ModelAbstract.h	(revision 15728)
+++ graphics/ModelAbstract.h	(working copy)
@@ -154,7 +154,7 @@
 	// get the model's player ID; initial default is INVALID_PLAYER
 	virtual player_id_t GetPlayerID() const { return m_PlayerID; }
 
-	virtual void SetShadingColor(const CColor& colour) { m_ShadingColor = colour; }
+	virtual void SetShadingColor(const CColor& color) { m_ShadingColor = color; }
 	virtual CColor GetShadingColor() const { return m_ShadingColor; }
 
 protected:
Index: graphics/ObjectEntry.cpp
===================================================================
--- graphics/ObjectEntry.cpp	(revision 15728)
+++ graphics/ObjectEntry.cpp	(working copy)
@@ -73,7 +73,7 @@
 		str << variation.color;
 		int r, g, b;
 		if (! (str >> r >> g >> b)) // Any trailing data is ignored
-			LOGERROR(L"Actor '%ls' has invalid RGB colour '%hs'", m_Base->m_ShortName.c_str(), variation.color.c_str());
+			LOGERROR(L"Actor '%ls' has invalid RGB color '%hs'", m_Base->m_ShortName.c_str(), variation.color.c_str());
 		else
 			m_Color = CColor(r/255.0f, g/255.0f, b/255.0f, 1.0f);
 	}
Index: graphics/ObjectEntry.h
===================================================================
--- graphics/ObjectEntry.h	(revision 15728)
+++ graphics/ObjectEntry.h	(working copy)
@@ -55,10 +55,10 @@
 	std::vector<CObjectBase::Samp> m_Samplers;
 	// model name
 	VfsPath m_ModelName;
-	// colour (used when doing alpha-channel colouring, but not doing player-colour)
+	// color (used when doing alpha-channel coloring, but not doing player-color)
 	CColor m_Color;
-		// (probable TODO: make colour a per-model thing, rather than per-objectEntry,
-		// so we can have lots of colour variations without wasting memory on
+		// (probable TODO: make color a per-model thing, rather than per-objectEntry,
+		// so we can have lots of color variations without wasting memory on
 		// lots of objectEntries)
 
 	std::wstring m_ProjectileModelName;
Index: graphics/ParticleEmitter.cpp
===================================================================
--- graphics/ParticleEmitter.cpp	(revision 15728)
+++ graphics/ParticleEmitter.cpp	(working copy)
@@ -151,7 +151,7 @@
 
 		SColor4ub color = m_Particles[i].color;
 
-		// Special case: If the blending depends on the source colour, not the source alpha,
+		// Special case: If the blending depends on the source color, not the source alpha,
 		// then pre-multiply by the alpha. (This is kind of a hack.)
 		if (m_Type->m_BlendFuncDst == GL_ONE_MINUS_SRC_COLOR)
 		{
Index: graphics/Terrain.cpp
===================================================================
--- graphics/Terrain.cpp	(revision 15728)
+++ graphics/Terrain.cpp	(working copy)
@@ -41,7 +41,7 @@
 // CTerrain constructor
 CTerrain::CTerrain()
 : m_Heightmap(0), m_Patches(0), m_MapSize(0), m_MapSizePatches(0),
-m_BaseColour(255, 255, 255, 255)
+m_BaseColor(255, 255, 255, 255)
 {
 }
 
Index: graphics/Terrain.h
===================================================================
--- graphics/Terrain.h	(revision 15728)
+++ graphics/Terrain.h	(working copy)
@@ -147,11 +147,11 @@
 	 */
 	CBoundingBoxAligned GetVertexesBound(ssize_t i0, ssize_t j0, ssize_t i1, ssize_t j1);
 
-	// get the base colour for the terrain (typically pure white - other colours
+	// get the base color for the terrain (typically pure white - other colors
 	// will interact badly with LOS - but used by the Actor Viewer tool)
-	SColor4ub GetBaseColour() const { return m_BaseColour; }
-	// set the base colour for the terrain
-	void SetBaseColour(SColor4ub colour) { m_BaseColour = colour; }
+	SColor4ub GetBaseColor() const { return m_BaseColor; }
+	// set the base color for the terrain
+	void SetBaseColor(SColor4ub color) { m_BaseColor = color; }
 
 	const CHeightMipmap& GetHeightMipmap() const { return m_HeightMipmap; }
 
@@ -169,8 +169,8 @@
 	CPatch*	m_Patches;
 	// 16-bit heightmap data
 	u16* m_Heightmap;
-	// base colour (usually white)
-	SColor4ub m_BaseColour;
+	// base color (usually white)
+	SColor4ub m_BaseColor;
 	// heightmap mipmap
 	CHeightMipmap m_HeightMipmap;
 };
Index: graphics/TerrainTextureEntry.cpp
===================================================================
--- graphics/TerrainTextureEntry.cpp	(revision 15728)
+++ graphics/TerrainTextureEntry.cpp	(working copy)
@@ -174,7 +174,7 @@
 		(*it)->RemoveTerrain(this);
 }
 
-// BuildBaseColor: calculate the root colour of the texture, used for coloring minimap, and store
+// BuildBaseColor: calculate the root color of the texture, used for coloring minimap, and store
 // in m_BaseColor member
 void CTerrainTextureEntry::BuildBaseColor()
 {
@@ -186,10 +186,10 @@
 		return;
 	}
 
-	// Use the texture colour if available
+	// Use the texture color if available
 	if (GetTexture()->TryLoad())
 	{
-		m_BaseColor = GetTexture()->GetBaseColour();
+		m_BaseColor = GetTexture()->GetBaseColor();
 		m_BaseColorValid = true;
 	}
 }
@@ -362,4 +362,4 @@
 	result.m_hCompositeAlphaMap = hCompositeAlphaMap;
 	
 	m_TerrainAlpha = it;
-}
\ No newline at end of file
+}
Index: graphics/TerritoryTexture.cpp
===================================================================
--- graphics/TerritoryTexture.cpp	(revision 15728)
+++ graphics/TerritoryTexture.cpp	(working copy)
@@ -183,7 +183,7 @@
 		CColor color(1, 0, 1, 1);
 		CmpPtr<ICmpPlayer> cmpPlayer(m_Simulation, cmpPlayerManager->GetPlayerByID(p));
 		if (cmpPlayer)
-			color = cmpPlayer->GetColour();
+			color = cmpPlayer->GetColor();
 		colors.push_back(color);
 	}
 
Index: graphics/TextureConverter.h
===================================================================
--- graphics/TextureConverter.h	(revision 15728)
+++ graphics/TextureConverter.h	(working copy)
@@ -52,7 +52,7 @@
  *
  * 'normal' is 'true' or 'false'.
  *
- * 'alpha' is 'transparency' or 'player' (it determines whether the colour value of
+ * 'alpha' is 'transparency' or 'player' (it determines whether the color value of
  * 0-alpha pixels is significant or not).
  *
  * 'filter' is 'box', 'triangle' or 'kaiser'.
Index: graphics/TextureManager.cpp
===================================================================
--- graphics/TextureManager.cpp	(revision 15728)
+++ graphics/TextureManager.cpp	(working copy)
@@ -189,8 +189,8 @@
 		size_t flags = 0;
 		(void)ogl_tex_get_format(h, &flags, NULL);
 
-		// Initialise base colour from the texture
-		(void)ogl_tex_get_average_colour(h, &texture->m_BaseColour);
+		// Initialise base color from the texture
+		(void)ogl_tex_get_average_color(h, &texture->m_BaseColor);
 
 		// Set GL upload properties
 		(void)ogl_tex_set_wrap(h, texture->m_Properties.m_WrapS, texture->m_Properties.m_WrapT);
@@ -516,7 +516,7 @@
 };
 
 CTexture::CTexture(Handle handle, const CTextureProperties& props, CTextureManagerImpl* textureManager) :
-	m_Handle(handle), m_BaseColour(0), m_State(UNLOADED), m_Properties(props), m_TextureManager(textureManager)
+	m_Handle(handle), m_BaseColor(0), m_State(UNLOADED), m_Properties(props), m_TextureManager(textureManager)
 {
 	// Add a reference to the handle (it might be shared by multiple CTextures
 	// so we can't take ownership of it)
@@ -613,9 +613,9 @@
 	return (flags & TEX_ALPHA) != 0;
 }
 
-u32 CTexture::GetBaseColour() const
+u32 CTexture::GetBaseColor() const
 {
-	return m_BaseColour;
+	return m_BaseColor;
 }
 
 size_t CTexture::GetUploadedSize() const
Index: graphics/TextureManager.h
===================================================================
--- graphics/TextureManager.h	(revision 15728)
+++ graphics/TextureManager.h	(working copy)
@@ -237,7 +237,7 @@
 	 * average of the whole texture).
 	 * Returns 0 if the texture has no mipmaps.
 	 */
-	u32 GetBaseColour() const;
+	u32 GetBaseColor() const;
 
 	/**
 	 * Returns total number of bytes uploaded for this texture.
@@ -287,7 +287,7 @@
 	const CTextureProperties m_Properties;
 
 	Handle m_Handle;
-	u32 m_BaseColour;
+	u32 m_BaseColor;
 
 	enum {
 		UNLOADED, // loading has not started
Index: gui/CGUISprite.h
===================================================================
--- gui/CGUISprite.h	(revision 15728)
+++ gui/CGUISprite.h	(working copy)
@@ -123,7 +123,7 @@
 	 */
 	GLint			m_WrapMode;
 
-	// Visual effects (e.g. colour modulation)
+	// Visual effects (e.g. color modulation)
 	SGUIImageEffects* m_Effects;
 
 	// Color
Index: gui/GUIRenderer.cpp
===================================================================
--- gui/GUIRenderer.cpp	(revision 15728)
+++ gui/GUIRenderer.cpp	(working copy)
@@ -79,7 +79,7 @@
 		//     "stretched:filename.ext" - stretched image
 		//     "stretched:grayscale:filename.ext" - stretched grayscale image
 		//     "cropped:(0.5, 0.25)"    - stretch this ratio (x,y) of the top left of the image
-		//     "colour:r g b a"         - solid colour
+		//     "color:r g b a"          - solid color
 		//
 		// and if so, try to create it as a new sprite.
 		if (SpriteName.substr(0, 10) == "stretched:")
@@ -141,10 +141,10 @@
 			CStrW value = wstring_from_utf8(SpriteName.substr(7));
 			CColor color;
 
-			// Check colour is valid
+			// Check color is valid
 			if (!GUI<CColor>::ParseString(value, color))
 			{
-				LOGERROR(L"GUI: Error parsing sprite 'colour' (\"%ls\")", value.c_str());
+				LOGERROR(L"GUI: Error parsing sprite 'color' (\"%ls\")", value.c_str());
 				return;
 			}
 
Index: gui/scripting/JSInterface_IGUIObject.cpp
===================================================================
--- gui/scripting/JSInterface_IGUIObject.cpp	(revision 15728)
+++ gui/scripting/JSInterface_IGUIObject.cpp	(working copy)
@@ -161,13 +161,13 @@
 
 		case GUIST_CColor:
 			{
-				CColor colour;
-				GUI<CColor>::GetSetting(e, propName, colour);
+				CColor color;
+				GUI<CColor>::GetSetting(e, propName, color);
 				JS::RootedObject obj(cx, pScriptInterface->CreateCustomObject("GUIColor"));
 				vp.setObject(*obj);
 				JS::RootedValue c(cx);
 				// Attempt to minimise ugliness through macrosity
-				#define P(x) c = JS::NumberValue(colour.x); \
+				#define P(x) c = JS::NumberValue(color.x); \
 				if (c.isNull()) \
 					return false; \
 				JS_SetProperty(cx, obj, #x, c.address())
@@ -528,17 +528,17 @@
 			}
 			else if (vp.isObject() && JS_InstanceOf(cx, &vp.toObject(), &JSI_GUIColor::JSI_class, NULL))
 			{
-				CColor colour;
+				CColor color;
 				JS::RootedObject (cx, &vp.toObject());
 				JS::RootedValue t(cx);
 				double s;
 				#define PROP(x) JS_GetProperty(cx, obj, #x, t.address()); \
 								s = t.toDouble(); \
-								colour.x = (float)s
+								color.x = (float)s
 				PROP(r); PROP(g); PROP(b); PROP(a);
 				#undef PROP
 
-				GUI<CColor>::SetSetting(e, propName, colour);
+				GUI<CColor>::SetSetting(e, propName, color);
 			}
 			else
 			{
Index: lib/res/graphics/ogl_tex.cpp
===================================================================
--- lib/res/graphics/ogl_tex.cpp	(revision 15728)
+++ lib/res/graphics/ogl_tex.cpp	(working copy)
@@ -1039,13 +1039,13 @@
 	return INFO::OK;
 }
 
-// retrieve colour of 1x1 mipmap level
-extern Status ogl_tex_get_average_colour(Handle ht, u32* p)
+// retrieve color of 1x1 mipmap level
+extern Status ogl_tex_get_average_color(Handle ht, u32* p)
 {
 	H_DEREF(ht, OglTex, ot);
 	warn_if_uploaded(ht, ot);
 
-	*p = ot->t.get_average_colour();
+	*p = ot->t.get_average_color();
 	return INFO::OK;
 }
 
Index: lib/res/graphics/ogl_tex.h
===================================================================
--- lib/res/graphics/ogl_tex.h	(revision 15728)
+++ lib/res/graphics/ogl_tex.h	(working copy)
@@ -408,7 +408,7 @@
 
 /**
  * Retrieve ARGB value of 1x1 mipmap level of the texture,
- * i.e. the average colour of the whole texture.
+ * i.e. the average color of the whole texture.
  *
  * @param ht Texture handle
  * @param p will be filled with ARGB value (or 0 if texture does not have mipmaps)
@@ -416,7 +416,7 @@
  *
  * Must be called before uploading (raises a warning if called afterwards).
  */
-extern Status ogl_tex_get_average_colour(Handle ht, u32* p);
+extern Status ogl_tex_get_average_color(Handle ht, u32* p);
 
 
 //
Index: lib/sysdep/os/win/wcursor.cpp
===================================================================
--- lib/sysdep/os/win/wcursor.cpp	(revision 15728)
+++ lib/sysdep/os/win/wcursor.cpp	(working copy)
@@ -56,7 +56,7 @@
 	// CreateBitmap; bpp/format must be checked against those of the DC.
 	// this is the simplest way and we don't care about slight performance
 	// differences because this is typically only called once.
-	HBITMAP hbmColour = CreateBitmap(w, h, 1, 32, bgra_img);
+	HBITMAP hbmColor = CreateBitmap(w, h, 1, 32, bgra_img);
 
 	// CreateIconIndirect doesn't access this; we just need to pass
 	// an empty bitmap.
@@ -69,12 +69,12 @@
 	ii.xHotspot = (DWORD)hx;
 	ii.yHotspot = (DWORD)hy;
 	ii.hbmMask  = hbmMask;
-	ii.hbmColor = hbmColour;
+	ii.hbmColor = hbmColor;
 	HICON hIcon = CreateIconIndirect(&ii);
 
 	// CreateIconIndirect makes copies, so we no longer need these.
 	DeleteObject(hbmMask);
-	DeleteObject(hbmColour);
+	DeleteObject(hbmColor);
 
 	if(!wutil_IsValidHandle(hIcon))
 		WARN_RETURN(ERR::FAIL);
Index: lib/sysdep/os/win/wsdl.cpp
===================================================================
--- lib/sysdep/os/win/wsdl.cpp	(revision 15728)
+++ lib/sysdep/os/win/wsdl.cpp	(working copy)
@@ -330,11 +330,11 @@
 static void video_SetPixelFormat(HDC hDC, int bpp)
 {
 	const DWORD dwFlags = PFD_SUPPORT_OPENGL|PFD_DRAW_TO_WINDOW|PFD_DOUBLEBUFFER;
-	BYTE cColourBits = (BYTE)bpp;
+	BYTE cColorBits = (BYTE)bpp;
 	BYTE cAlphaBits = 0;
 	if(bpp == 32)
 	{
-		cColourBits = 24;
+		cColorBits = 24;
 		cAlphaBits = 8;
 	}
 	const BYTE cAccumBits   = 0;
@@ -348,7 +348,7 @@
 		1,								// version
 		dwFlags,
 		PFD_TYPE_RGBA,
-		cColourBits, 0, 0, 0, 0, 0, 0,	// c*Bits, c*Shift are unused
+		cColorBits, 0, 0, 0, 0, 0, 0,	// c*Bits, c*Shift are unused
 		cAlphaBits, 0,					// cAlphaShift is unused
 		cAccumBits,	0, 0, 0, 0,			// cAccum*Bits are unused
 		cDepthBits,
Index: lib/tex/tex.cpp
===================================================================
--- lib/tex/tex.cpp	(revision 15728)
+++ lib/tex/tex.cpp	(working copy)
@@ -637,8 +637,8 @@
 	return p + m_Ofs;
 }
 
-// returns colour of 1x1 mipmap level
-u32 Tex::get_average_colour() const
+// returns color of 1x1 mipmap level
+u32 Tex::get_average_color() const
 {
 	// require mipmaps
 	if(!(m_Flags & TEX_MIPMAPS))
Index: lib/tex/tex.h
===================================================================
--- lib/tex/tex.h	(revision 15728)
+++ lib/tex/tex.h	(working copy)
@@ -337,7 +337,7 @@
 	 *
 	 * @return ARGB value (or 0 if texture does not have mipmaps)
 	 **/
-	u32 get_average_colour() const;
+	u32 get_average_color() const;
 
 	/**
 	 * return total byte size of the image pixels. (including mipmaps!)
Index: lib/tex/tex_bmp.cpp
===================================================================
--- lib/tex/tex_bmp.cpp	(revision 15728)
+++ lib/tex/tex_bmp.cpp	(working copy)
@@ -94,7 +94,7 @@
 }
 
 
-// requirements: uncompressed, direct colour, bottom up
+// requirements: uncompressed, direct color, bottom up
 Status TexCodecBmp::decode(rpU8 data, size_t UNUSED(size), Tex* RESTRICT t) const
 {
 	const BmpHeader* hdr = (const BmpHeader*)data;
Index: lib/tex/tex_png.cpp
===================================================================
--- lib/tex/tex_png.cpp	(revision 15728)
+++ lib/tex/tex_png.cpp	(working copy)
@@ -125,8 +125,8 @@
 	// read header and determine format
 	png_read_info(png_ptr, info_ptr);
 	png_uint_32 w, h;
-	int bit_depth, colour_type;
-	png_get_IHDR(png_ptr, info_ptr, &w, &h, &bit_depth, &colour_type, 0, 0, 0);
+	int bit_depth, color_type;
+	png_get_IHDR(png_ptr, info_ptr, &w, &h, &bit_depth, &color_type, 0, 0, 0);
 	const size_t pitch = png_get_rowbytes(png_ptr, info_ptr);
 	const u32 bpp = (u32)(pitch/w * 8);
 
@@ -133,13 +133,13 @@
 	size_t flags = 0;
 	if(bpp == 32)
 		flags |= TEX_ALPHA;
-	if(colour_type == PNG_COLOR_TYPE_GRAY)
+	if(color_type == PNG_COLOR_TYPE_GRAY)
 		flags |= TEX_GREY;
 
 	// make sure format is acceptable
 	if(bit_depth != 8)
 		WARN_RETURN(ERR::TEX_NOT_8BIT_PRECISION);
-	if(colour_type & PNG_COLOR_MASK_PALETTE)
+	if(color_type & PNG_COLOR_MASK_PALETTE)
 		WARN_RETURN(ERR::TEX_INVALID_COLOR_TYPE);
 
 	const size_t img_size = pitch * h;
@@ -165,25 +165,25 @@
 	const png_uint_32 w = (png_uint_32)t->m_Width, h = (png_uint_32)t->m_Height;
 	const size_t pitch = w * t->m_Bpp / 8;
 
-	int colour_type;
+	int color_type;
 	switch(t->m_Flags & (TEX_GREY|TEX_ALPHA))
 	{
 	case TEX_GREY|TEX_ALPHA:
-		colour_type = PNG_COLOR_TYPE_GRAY_ALPHA;
+		color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
 		break;
 	case TEX_GREY:
-		colour_type = PNG_COLOR_TYPE_GRAY;
+		color_type = PNG_COLOR_TYPE_GRAY;
 		break;
 	case TEX_ALPHA:
-		colour_type = PNG_COLOR_TYPE_RGB_ALPHA;
+		color_type = PNG_COLOR_TYPE_RGB_ALPHA;
 		break;
 	default:
-		colour_type = PNG_COLOR_TYPE_RGB;
+		color_type = PNG_COLOR_TYPE_RGB;
 		break;
 	}
 
 	png_set_write_fn(png_ptr, da, io_write, io_flush);
-	png_set_IHDR(png_ptr, info_ptr, w, h, 8, colour_type,
+	png_set_IHDR(png_ptr, info_ptr, w, h, 8, color_type,
 		PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
 
 	u8* data = t->get_data();
Index: lib/tex/tex_tga.cpp
===================================================================
--- lib/tex/tex_tga.cpp	(revision 15728)
+++ lib/tex/tex_tga.cpp	(working copy)
@@ -34,8 +34,8 @@
 
 enum TgaImgType
 {
-	TGA_TRUE_COLOUR = 2,	// uncompressed 24 or 32 bit direct RGB
-	TGA_GREY        = 3		// uncompressed 8 bit direct greyscale
+	TGA_TRUE_COLOR = 2,	// uncompressed 24 or 32 bit direct RGB
+	TGA_GREY       = 3	// uncompressed 8 bit direct greyscale
 };
 
 enum TgaImgDesc
@@ -47,9 +47,9 @@
 typedef struct
 {
 	u8 img_id_len;			// 0 - no image identifier present
-	u8 colour_map_type;		// 0 - no colour map present
+	u8 color_map_type;		// 0 - no color map present
 	u8 img_type;			// see TgaImgType
-	u8 colour_map[5];		// unused
+	u8 color_map[5];		// unused
 
 	u16 x_origin;			// unused
 	u16 y_origin;			// unused
@@ -62,7 +62,7 @@
 }
 TgaHeader;
 
-// TGA file: header [img id] [colour map] image data
+// TGA file: header [img id] [color map] image data
 
 #pragma pack(pop)
 
@@ -79,14 +79,14 @@
 
 	// the first TGA header doesn't have a magic field;
 	// we can only check if the first 4 bytes are valid
-	// .. not direct colour
-	if(hdr->colour_map_type != 0)
+	// .. not direct color
+	if(hdr->color_map_type != 0)
 		return false;
-	// .. wrong colour type (not uncompressed greyscale or RGB)
-	if(hdr->img_type != TGA_TRUE_COLOUR && hdr->img_type != TGA_GREY)
+	// .. wrong color type (not uncompressed greyscale or RGB)
+	if(hdr->img_type != TGA_TRUE_COLOR && hdr->img_type != TGA_GREY)
 		return false;
 
-	// note: we can't check img_id_len or colour_map[0] - they are
+	// note: we can't check img_id_len or color_map[0] - they are
 	// undefined and may assume any value.
 
 	return true;
@@ -127,7 +127,7 @@
 		flags |= TEX_ALPHA;
 	if(bpp == 8)
 		flags |= TEX_GREY;
-	if(type == TGA_TRUE_COLOUR)
+	if(type == TGA_TRUE_COLOR)
 		flags |= TEX_BGR;
 
 	// sanity checks
@@ -151,7 +151,7 @@
 		img_desc |= TGA_TOP_DOWN;
 	if(t->m_Bpp == 32)
 		img_desc |= 8;	// size of alpha channel
-	TgaImgType img_type = (t->m_Flags & TEX_GREY)? TGA_GREY : TGA_TRUE_COLOUR;
+	TgaImgType img_type = (t->m_Flags & TEX_GREY)? TGA_GREY : TGA_TRUE_COLOR;
 
 	size_t transforms = t->m_Flags;
 	transforms &= ~TEX_ORIENTATION;	// no flip needed - we can set top-down bit.
@@ -160,9 +160,9 @@
 	const TgaHeader hdr =
 	{
 		0,				// no image identifier present
-		0,				// no colour map present
+		0,				// no color map present
 		(u8)img_type,
-		{0,0,0,0,0},	// unused (colour map)
+		{0,0,0,0,0},	// unused (color map)
 		0, 0,			// unused (origin)
 		(u16)t->m_Width,
 		(u16)t->m_Height,
Index: ps/CConsole.cpp
===================================================================
--- ps/CConsole.cpp	(revision 15728)
+++ ps/CConsole.cpp	(working copy)
@@ -340,7 +340,7 @@
 		// Cursor character is chosen to be an underscore
 		textRenderer.Put(0.0f, 0.0f, L"_");
 
-		// Revert to the standard text colour
+		// Revert to the standard text color
 		textRenderer.Color(1.0f, 1.0f, 1.0f);
 	}
 }
Index: ps/Game.cpp
===================================================================
--- ps/Game.cpp	(revision 15728)
+++ ps/Game.cpp	(working copy)
@@ -350,9 +350,9 @@
 
 static CColor BrokenColor(0.3f, 0.3f, 0.3f, 1.0f);
 
-void CGame::CachePlayerColours()
+void CGame::CachePlayerColors()
 {
-	m_PlayerColours.clear();
+	m_PlayerColors.clear();
 
 	CmpPtr<ICmpPlayerManager> cmpPlayerManager(*m_Simulation2, SYSTEM_ENTITY);
 	if (!cmpPlayerManager)
@@ -359,23 +359,23 @@
 		return;
 
 	int numPlayers = cmpPlayerManager->GetNumPlayers();
-	m_PlayerColours.resize(numPlayers);
+	m_PlayerColors.resize(numPlayers);
 
 	for (int i = 0; i < numPlayers; ++i)
 	{
 		CmpPtr<ICmpPlayer> cmpPlayer(*m_Simulation2, cmpPlayerManager->GetPlayerByID(i));
 		if (!cmpPlayer)
-			m_PlayerColours[i] = BrokenColor;
+			m_PlayerColors[i] = BrokenColor;
 		else
-			m_PlayerColours[i] = cmpPlayer->GetColour();
+			m_PlayerColors[i] = cmpPlayer->GetColor();
 	}
 }
 
 
-CColor CGame::GetPlayerColour(int player) const
+CColor CGame::GetPlayerColor(int player) const
 {
-	if (player < 0 || player >= (int)m_PlayerColours.size())
+	if (player < 0 || player >= (int)m_PlayerColors.size())
 		return BrokenColor;
 
-	return m_PlayerColours[player];
+	return m_PlayerColors[player];
 }
Index: ps/Game.h
===================================================================
--- ps/Game.h	(revision 15728)
+++ ps/Game.h	(working copy)
@@ -93,14 +93,14 @@
 	void SetPlayerID(int playerID);
 
 	/**
-	 * Retrieving player colours from scripts is slow, so this updates an
-	 * internal cache of all players' colours.
+	 * Retrieving player colors from scripts is slow, so this updates an
+	 * internal cache of all players' colors.
 	 * Call this just before rendering, so it will always have the latest
-	 * colours.
+	 * colors.
 	 */
-	void CachePlayerColours();
+	void CachePlayerColors();
 
-	CColor GetPlayerColour(int player) const;
+	CColor GetPlayerColor(int player) const;
 
 	/**
 	 * Get m_GameStarted.
@@ -166,7 +166,7 @@
 	void RegisterInit(const JS::HandleValue attribs, const std::string& savedState);
 	IReplayLogger* m_ReplayLogger;
 
-	std::vector<CColor> m_PlayerColours;
+	std::vector<CColor> m_PlayerColors;
 
 	int LoadInitialState();
 	std::string m_InitialSavedState; // valid between RegisterInit and LoadInitialState
Index: renderer/OverlayRenderer.cpp
===================================================================
--- renderer/OverlayRenderer.cpp	(revision 15728)
+++ renderer/OverlayRenderer.cpp	(working copy)
@@ -260,7 +260,7 @@
 	PROFILE3("prepare overlays");
 
 	// This is where we should do something like sort the overlays by
-	// colour/sprite/etc for more efficient rendering
+	// color/sprite/etc for more efficient rendering
 
 	for (size_t i = 0; i < m->texlines.size(); ++i)
 	{
Index: renderer/PostprocManager.cpp
===================================================================
--- renderer/PostprocManager.cpp	(revision 15728)
+++ renderer/PostprocManager.cpp	(working copy)
@@ -37,7 +37,7 @@
 #if !CONFIG2_GLES
 
 CPostprocManager::CPostprocManager()
-	: m_IsInitialised(false), m_PingFbo(0), m_PongFbo(0), m_PostProcEffect(L"default"), m_ColourTex1(0), m_ColourTex2(0), 
+	: m_IsInitialised(false), m_PingFbo(0), m_PongFbo(0), m_PostProcEffect(L"default"), m_ColorTex1(0), m_ColorTex2(0),
 	  m_DepthTex(0), m_BloomFbo(0), m_BlurTex2a(0), m_BlurTex2b(0), m_BlurTex4a(0), m_BlurTex4b(0),
 	  m_BlurTex8a(0), m_BlurTex8b(0), m_WhichBuffer(true)
 {
@@ -65,10 +65,10 @@
 		if (m_BloomFbo) pglDeleteFramebuffersEXT(1, &m_BloomFbo);
 		m_PingFbo = m_PongFbo = m_BloomFbo = 0;
 		
-		if (m_ColourTex1) glDeleteTextures(1, &m_ColourTex1);
-		if (m_ColourTex2) glDeleteTextures(1, &m_ColourTex2);
+		if (m_ColorTex1) glDeleteTextures(1, &m_ColorTex1);
+		if (m_ColorTex2) glDeleteTextures(1, &m_ColorTex2);
 		if (m_DepthTex) glDeleteTextures(1, &m_DepthTex);
-		m_ColourTex1 = m_ColourTex2 = m_DepthTex = 0;
+		m_ColorTex1 = m_ColorTex2 = m_DepthTex = 0;
 		
 		if (m_BlurTex2a) glDeleteTextures(1, &m_BlurTex2a);
 		if (m_BlurTex2b) glDeleteTextures(1, &m_BlurTex2b);
@@ -98,8 +98,8 @@
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 	
 	// Two fullscreen ping-pong textures. 
-	GEN_BUFFER_RGBA(m_ColourTex1, m_Width, m_Height);
-	GEN_BUFFER_RGBA(m_ColourTex2, m_Width, m_Height);
+	GEN_BUFFER_RGBA(m_ColorTex1, m_Width, m_Height);
+	GEN_BUFFER_RGBA(m_ColorTex2, m_Width, m_Height);
 	
 	// Textures for several blur sizes. It would be possible to reuse
 	// m_BlurTex2b, thus avoiding the need for m_BlurTex4b and m_BlurTex8b, though given
@@ -134,7 +134,7 @@
 	
 	pglGenFramebuffersEXT(1, &m_PingFbo);
 	pglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_PingFbo);
-	pglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, m_ColourTex1, 0);
+	pglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, m_ColorTex1, 0);
 	pglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D, m_DepthTex, 0);
 	
 	GLenum status = pglCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
@@ -145,7 +145,7 @@
 	
 	pglGenFramebuffersEXT(1, &m_PongFbo);
 	pglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_PongFbo);
-	pglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, m_ColourTex2, 0);
+	pglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, m_ColorTex2, 0);
 	pglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D, m_DepthTex, 0);
 	
 	status = pglCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
@@ -320,7 +320,7 @@
 		ApplyBlurGauss(tex2, temptex, width, height); 
 	
 	// We do the same thing for each scale, incrementally adding more and more blur.
-	SCALE_AND_BLUR(m_WhichBuffer ? m_ColourTex1 : m_ColourTex2, m_BlurTex2a, m_BlurTex2b);
+	SCALE_AND_BLUR(m_WhichBuffer ? m_ColorTex1 : m_ColorTex2, m_BlurTex2a, m_BlurTex2b);
 	SCALE_AND_BLUR(m_BlurTex2a, m_BlurTex4a, m_BlurTex4b);
 	SCALE_AND_BLUR(m_BlurTex4a, m_BlurTex8a, m_BlurTex8b);
 	
@@ -403,9 +403,9 @@
 	// We also bind a bunch of other textures and parameters, but since
 	// this only happens once per frame the overhead is negligible.
 	if (m_WhichBuffer)
-		shader->BindTexture(str_renderedTex, m_ColourTex1);
+		shader->BindTexture(str_renderedTex, m_ColorTex1);
 	else
-		shader->BindTexture(str_renderedTex, m_ColourTex2);
+		shader->BindTexture(str_renderedTex, m_ColorTex2);
 	
 	shader->BindTexture(str_depthTex, m_DepthTex);
 	
Index: renderer/PostprocManager.h
===================================================================
--- renderer/PostprocManager.h	(revision 15728)
+++ renderer/PostprocManager.h	(working copy)
@@ -28,8 +28,8 @@
 	// Two framebuffers, that we flip between at each shader pass.
 	GLuint m_PingFbo, m_PongFbo;
 	
-	// Unique colour textures for the framebuffers.
-	GLuint m_ColourTex1, m_ColourTex2;
+	// Unique color textures for the framebuffers.
+	GLuint m_ColorTex1, m_ColorTex2;
 	
 	// The framebuffers share a depth/stencil texture.
 	GLuint m_DepthTex;
@@ -98,7 +98,7 @@
 	// Matching setter that calls LoadEffect.
 	void SetPostEffect(CStrW name);
 
-	// Clears the two colour buffers and depth buffer, and redirects all rendering
+	// Clears the two color buffers and depth buffer, and redirects all rendering
 	// to our textures instead of directly to the system framebuffer. 
 	void CaptureRenderOutput();
 	
Index: renderer/RenderModifiers.cpp
===================================================================
--- renderer/RenderModifiers.cpp	(revision 15728)
+++ renderer/RenderModifiers.cpp	(working copy)
@@ -117,5 +117,5 @@
 		shader->Uniform(m_BindingShadingColor, model->GetShadingColor());
 
 	if (m_BindingPlayerColor.Active())
-		shader->Uniform(m_BindingPlayerColor, g_Game->GetPlayerColour(model->GetPlayerID()));
+		shader->Uniform(m_BindingPlayerColor, g_Game->GetPlayerColor(model->GetPlayerID()));
 }
Index: renderer/Renderer.cpp
===================================================================
--- renderer/Renderer.cpp	(revision 15728)
+++ renderer/Renderer.cpp	(working copy)
@@ -1318,7 +1318,7 @@
 	// has to be done in a separate pass.
 	// First we render all occluders into depth, then render all units with
 	// inverted depth test so any behind an occluder will get drawn in a constant
-	// colour.
+	// color.
 
 	float silhouetteAlpha = 0.75f;
 
@@ -1369,7 +1369,7 @@
 	else
 	{
 		// Since we can't sort, we'll use the stencil buffer to ensure we only draw
-		// a pixel once (using the colour of whatever model happens to be drawn first).
+		// a pixel once (using the color of whatever model happens to be drawn first).
 		glEnable(GL_BLEND);
 		glBlendFunc(GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA);
 		pglBlendColorEXT(0, 0, 0, silhouetteAlpha);
Index: renderer/SilhouetteRenderer.cpp
===================================================================
--- renderer/SilhouetteRenderer.cpp	(revision 15728)
+++ renderer/SilhouetteRenderer.cpp	(working copy)
@@ -55,7 +55,7 @@
 }
 
 /*
- * Silhouettes are the solid-coloured versions of units that are rendered when
+ * Silhouettes are the solid-colored versions of units that are rendered when
  * standing behind a building or terrain, so the player won't lose them.
  *
  * The rendering is done in CRenderer::RenderSilhouettes, by rendering the
Index: renderer/TerrainOverlay.cpp
===================================================================
--- renderer/TerrainOverlay.cpp	(revision 15728)
+++ renderer/TerrainOverlay.cpp	(working copy)
@@ -180,12 +180,12 @@
 #endif
 }
 
-void TerrainOverlay::RenderTile(const CColor& colour, bool draw_hidden)
+void TerrainOverlay::RenderTile(const CColor& color, bool draw_hidden)
 {
-	RenderTile(colour, draw_hidden, m_i, m_j);
+	RenderTile(color, draw_hidden, m_i, m_j);
 }
 
-void TerrainOverlay::RenderTile(const CColor& colour, bool draw_hidden, ssize_t i, ssize_t j)
+void TerrainOverlay::RenderTile(const CColor& color, bool draw_hidden, ssize_t i, ssize_t j)
 {
 	// TODO: if this is unpleasantly slow, make it much more efficient
 	// (e.g. buffering data and making a single draw call? or at least
@@ -210,7 +210,7 @@
 
 	CVector3D pos;
 	glBegin(GL_TRIANGLES);
-		glColor4fv(colour.FloatArray());
+		glColor4fv(color.FloatArray());
 		if (m_Terrain->GetTriangulationDir(i, j))
 		{
 			m_Terrain->CalcPosition(i,   j,   pos); glVertex3fv(pos.GetFloatArray());
@@ -236,12 +236,12 @@
 #endif
 }
 
-void TerrainOverlay::RenderTileOutline(const CColor& colour, int line_width, bool draw_hidden)
+void TerrainOverlay::RenderTileOutline(const CColor& color, int line_width, bool draw_hidden)
 {
-	RenderTileOutline(colour, line_width, draw_hidden, m_i, m_j);
+	RenderTileOutline(color, line_width, draw_hidden, m_i, m_j);
 }
 
-void TerrainOverlay::RenderTileOutline(const CColor& colour, int line_width, bool draw_hidden, ssize_t i, ssize_t j)
+void TerrainOverlay::RenderTileOutline(const CColor& color, int line_width, bool draw_hidden, ssize_t i, ssize_t j)
 {
 	if (draw_hidden)
 	{
@@ -265,7 +265,7 @@
 
 	CVector3D pos;
 	glBegin(GL_QUADS);
-		glColor4fv(colour.FloatArray());
+		glColor4fv(color.FloatArray());
 		m_Terrain->CalcPosition(i,   j,   pos); glVertex3fv(pos.GetFloatArray());
 		m_Terrain->CalcPosition(i+1, j,   pos); glVertex3fv(pos.GetFloatArray());
 		m_Terrain->CalcPosition(i+1, j+1, pos); glVertex3fv(pos.GetFloatArray());
Index: renderer/TerrainOverlay.h
===================================================================
--- renderer/TerrainOverlay.h	(revision 15728)
+++ renderer/TerrainOverlay.h	(working copy)
@@ -128,31 +128,31 @@
 	/**
 	 * Draw a filled quad on top of the current tile.
 	 *
-	 * @param colour  colour to draw. May be transparent (alpha &lt; 1)
+	 * @param color  color to draw. May be transparent (alpha &lt; 1)
 	 * @param draw_hidden  true if hidden tiles (i.e. those behind other tiles)
 	 * should be drawn
 	 */
-	void RenderTile(const CColor& colour, bool draw_hidden);
+	void RenderTile(const CColor& color, bool draw_hidden);
 
 	/**
 	 * Draw a filled quad on top of the given tile.
 	 */
-	void RenderTile(const CColor& colour, bool draw_hidden, ssize_t i, ssize_t j);
+	void RenderTile(const CColor& color, bool draw_hidden, ssize_t i, ssize_t j);
 
 	/**
 	 * Draw an outlined quad on top of the current tile.
 	 *
-	 * @param colour  colour to draw. May be transparent (alpha &lt; 1)
+	 * @param color  color to draw. May be transparent (alpha &lt; 1)
 	 * @param line_width  width of lines in pixels. 1 is a sensible value
 	 * @param draw_hidden  true if hidden tiles (i.e. those behind other tiles)
 	 * should be drawn
 	 */
-	void RenderTileOutline(const CColor& colour, int line_width, bool draw_hidden);
+	void RenderTileOutline(const CColor& color, int line_width, bool draw_hidden);
 
 	/**
 	 * Draw an outlined quad on top of the given tile.
 	 */
-	void RenderTileOutline(const CColor& colour, int line_width, bool draw_hidden, ssize_t i, ssize_t j);
+	void RenderTileOutline(const CColor& color, int line_width, bool draw_hidden, ssize_t i, ssize_t j);
 	
 private:
 	// Process all tiles
Index: renderer/TerrainRenderer.cpp
===================================================================
--- renderer/TerrainRenderer.cpp	(revision 15728)
+++ renderer/TerrainRenderer.cpp	(working copy)
@@ -281,7 +281,7 @@
 	const CLightEnv& lightEnv = g_Renderer.GetLightEnv();
 
 	pglClientActiveTextureARB(GL_TEXTURE0);
-	glEnableClientState(GL_COLOR_ARRAY); // diffuse lighting colours
+	glEnableClientState(GL_COLOR_ARRAY); // diffuse lighting colors
 
 	// The vertex color is scaled by 0.5 to permit overbrightness without clamping.
 	// We therefore need to draw clamp((texture*lighting)*2.0), where 'texture'
Index: tools/atlas/AtlasUI/ActorEditor/ActorEditorListCtrl.cpp
===================================================================
--- tools/atlas/AtlasUI/ActorEditor/ActorEditorListCtrl.cpp	(revision 15728)
+++ tools/atlas/AtlasUI/ActorEditor/ActorEditorListCtrl.cpp	(working copy)
@@ -30,21 +30,21 @@
 	: DraggableListCtrl(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize,
 		wxLC_REPORT | wxLC_HRULES | wxLC_VRULES | wxLC_SINGLE_SEL)
 {
-	// Set colours for row backgrounds (which vary depending on what columns
+	// Set colors for row backgrounds (which vary depending on what columns
 	// have some data)
-	#define COLOUR(name, c0, c1) \
-	m_ListItemAttr_##name[0].SetBackgroundColour(wxColour c0); \
-	m_ListItemAttr_##name[1].SetBackgroundColour(wxColour c1)
+	#define COLOR(name, c0, c1) \
+	m_ListItemAttr_##name[0].SetBackgroundColor(wxColor c0); \
+	m_ListItemAttr_##name[1].SetBackgroundColor(wxColor c1)
 	
 	const int f=0xFF, e=0xEE, c=0xCC;
-	COLOUR(Model,   (f,f,e), (f,f,c));
-	COLOUR(Texture, (f,e,e), (f,c,c));
-	COLOUR(Anim,    (e,f,e), (c,f,c));
-	COLOUR(Prop,    (e,e,f), (c,c,f));
-	COLOUR(Colour,  (f,e,f), (f,c,f));
-	COLOUR(None,    (f,f,f), (f,f,f));
+	COLOR(Model,   (f,f,e), (f,f,c));
+	COLOR(Texture, (f,e,e), (f,c,c));
+	COLOR(Anim,    (e,f,e), (c,f,c));
+	COLOR(Prop,    (e,e,f), (c,c,f));
+	COLOR(Colour,  (f,e,f), (f,c,f));
+	COLOR(None,    (f,f,f), (f,f,f));
 
-	#undef COLOUR
+	#undef COLOR
 
 	AddColumnType(_("Variant"),		90,  "@name",		new FieldEditCtrl_Text());
 	AddColumnType(_("Ratio"),		50,  "@frequency",	new FieldEditCtrl_Text());
@@ -52,7 +52,7 @@
 	AddColumnType(_("Textures"),		250, "textures",	new FieldEditCtrl_Dialog(&TexListEditor::Create));
 	AddColumnType(_("Animations"),		250, "animations",	new FieldEditCtrl_Dialog(&AnimListEditor::Create));
 	AddColumnType(_("Props"),		220, "props",		new FieldEditCtrl_Dialog(&PropListEditor::Create));
-	AddColumnType(_("Colour"),		80,  "colour",		new FieldEditCtrl_Colour());
+	AddColumnType(_("Colour"),		80,  "colour",		new FieldEditCtrl_Color());
 }
 
 void ActorEditorListCtrl::DoImport(AtObj& in)
@@ -104,7 +104,7 @@
 	{
 		AtObj row (m_ListData[item]);
 
-		// Colour-code the row, depending on the first non-empty column,
+		// Color-code the row, depending on the first non-empty column,
 		// and also alternate between light/dark.
 
 		if (row["mesh"].hasContent())
@@ -116,7 +116,7 @@
 		else if (row["props"].hasContent())
 			return const_cast<wxListItemAttr*>(&m_ListItemAttr_Prop[item%2]);
 		else if (row["colour"].hasContent())
-			return const_cast<wxListItemAttr*>(&m_ListItemAttr_Colour[item%2]);
+			return const_cast<wxListItemAttr*>(&m_ListItemAttr_Color[item%2]);
 	}
 
 	return const_cast<wxListItemAttr*>(&m_ListItemAttr_None[item%2]);
Index: tools/atlas/AtlasUI/CustomControls/ColorDialog/ColorDialog.cpp
===================================================================
--- tools/atlas/AtlasUI/CustomControls/ColorDialog/ColorDialog.cpp	(revision 15728)
+++ tools/atlas/AtlasUI/CustomControls/ColorDialog/ColorDialog.cpp	(working copy)
@@ -20,14 +20,14 @@
 #include "wx/regex.h"
 #include "wx/config.h"
 
-#include "ColourDialog.h"
+#include "ColorDialog.h"
 
-ColourDialog::ColourDialog(wxWindow* parent, const wxString& customColourConfigPath, const wxColour& defaultColour)
-: wxColourDialog(parent), m_ConfigPath(customColourConfigPath)
+ColorDialog::ColorDialog(wxWindow* parent, const wxString& customColorConfigPath, const wxColour& defaultColor)
+: wxColourDialog(parent), m_ConfigPath(customColorConfigPath)
 {
-	GetColourData().SetColour(defaultColour);
+	GetColourData().SetColour(defaultColor);
 
-	// Load custom colours from the config database
+	// Load custom colors from the config database
 
 	wxRegEx re (_T("([0-9]+) ([0-9]+) ([0-9]+)"), wxRE_EXTENDED);
 
@@ -36,14 +36,14 @@
 	{
 		for (int i = 0; i < 16; ++i)
 		{
-			wxString customColour;
-			if (cfg->Read(wxString::Format(_T("%s%d"), m_ConfigPath.c_str(), i), &customColour)
-				&& re.Matches(customColour))
+			wxString customColor;
+			if (cfg->Read(wxString::Format(_T("%s%d"), m_ConfigPath.c_str(), i), &customColor)
+				&& re.Matches(customColor))
 			{
 				long r, g, b;
-				re.GetMatch(customColour, 1).ToLong(&r);
-				re.GetMatch(customColour, 2).ToLong(&g);
-				re.GetMatch(customColour, 3).ToLong(&b);
+				re.GetMatch(customColor, 1).ToLong(&r);
+				re.GetMatch(customColor, 2).ToLong(&g);
+				re.GetMatch(customColor, 3).ToLong(&b);
 				GetColourData().SetCustomColour(i, wxColour(r, g, b));
 			}
 		}
@@ -50,12 +50,12 @@
 	}
 }
 
-int ColourDialog::ShowModal()
+int ColorDialog::ShowModal()
 {
 	int ret = wxColourDialog::ShowModal();
 	if (ret == wxID_OK)
 	{
-		// Save all the custom colours back into the config database
+		// Save all the custom colors back into the config database
 
 		wxConfigBase* cfg = wxConfigBase::Get(false);
 		if (cfg)
@@ -63,10 +63,10 @@
 			for (int i = 0; i < 16; ++i)
 			{
 				wxString name = wxString::Format(_T("%s%d"), m_ConfigPath.c_str(), i);
-				wxColour colour = GetColourData().GetCustomColour(i);
+				wxColour color = GetColourData().GetCustomColour(i);
 
-				wxString customColour = wxString::Format(_T("%d %d %d"), colour.Red(), colour.Green(), colour.Blue());
-				cfg->Write(name, customColour);
+				wxString customColor = wxString::Format(_T("%d %d %d"), color.Red(), color.Green(), color.Blue());
+				cfg->Write(name, customColor);
 			}
 		}
 	}
Index: tools/atlas/AtlasUI/CustomControls/ColorDialog/ColorDialog.h
===================================================================
--- tools/atlas/AtlasUI/CustomControls/ColorDialog/ColorDialog.h	(revision 15728)
+++ tools/atlas/AtlasUI/CustomControls/ColorDialog/ColorDialog.h	(working copy)
@@ -15,16 +15,16 @@
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef INCLUDED_COLOURDIALOG
-#define INCLUDED_COLOURDIALOG
+#ifndef INCLUDED_COLORDIALOG
+#define INCLUDED_COLORDIALOG
 
 #include <wx/colordlg.h>
 
-class ColourDialog : public wxColourDialog
+class ColorDialog : public wxColourDialog
 {
 public:
-	// Typical customColourConfigPath would be "Scenario Editor/LightingColour"
-	ColourDialog(wxWindow* parent, const wxString& customColourConfigPath, const wxColour& defaultColour);
+	// A typical customColorConfigPath would be "Scenario Editor/LightingColor"
+	ColorDialog(wxWindow* parent, const wxString& customColorConfigPath, const wxColour& defaultColor);
 
 	int ShowModal();
 
@@ -32,4 +32,4 @@
 	wxString m_ConfigPath;
 };
 
-#endif // INCLUDED_COLOURDIALOG
+#endif // INCLUDED_COLORDIALOG
Index: tools/atlas/AtlasUI/CustomControls/ColourDialog/ColourDialog.cpp
===================================================================
--- tools/atlas/AtlasUI/CustomControls/ColourDialog/ColourDialog.cpp	(revision 15728)
+++ tools/atlas/AtlasUI/CustomControls/ColourDialog/ColourDialog.cpp	(working copy)
@@ -1,75 +0,0 @@
-/* Copyright (C) 2009 Wildfire Games.
- * This file is part of 0 A.D.
- *
- * 0 A.D. is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * 0 A.D. is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "precompiled.h"
-
-#include "wx/regex.h"
-#include "wx/config.h"
-
-#include "ColourDialog.h"
-
-ColourDialog::ColourDialog(wxWindow* parent, const wxString& customColourConfigPath, const wxColour& defaultColour)
-: wxColourDialog(parent), m_ConfigPath(customColourConfigPath)
-{
-	GetColourData().SetColour(defaultColour);
-
-	// Load custom colours from the config database
-
-	wxRegEx re (_T("([0-9]+) ([0-9]+) ([0-9]+)"), wxRE_EXTENDED);
-
-	wxConfigBase* cfg = wxConfigBase::Get(false);
-	if (cfg)
-	{
-		for (int i = 0; i < 16; ++i)
-		{
-			wxString customColour;
-			if (cfg->Read(wxString::Format(_T("%s%d"), m_ConfigPath.c_str(), i), &customColour)
-				&& re.Matches(customColour))
-			{
-				long r, g, b;
-				re.GetMatch(customColour, 1).ToLong(&r);
-				re.GetMatch(customColour, 2).ToLong(&g);
-				re.GetMatch(customColour, 3).ToLong(&b);
-				GetColourData().SetCustomColour(i, wxColour(r, g, b));
-			}
-		}
-	}
-}
-
-int ColourDialog::ShowModal()
-{
-	int ret = wxColourDialog::ShowModal();
-	if (ret == wxID_OK)
-	{
-		// Save all the custom colours back into the config database
-
-		wxConfigBase* cfg = wxConfigBase::Get(false);
-		if (cfg)
-		{
-			for (int i = 0; i < 16; ++i)
-			{
-				wxString name = wxString::Format(_T("%s%d"), m_ConfigPath.c_str(), i);
-				wxColour colour = GetColourData().GetCustomColour(i);
-
-				wxString customColour = wxString::Format(_T("%d %d %d"), colour.Red(), colour.Green(), colour.Blue());
-				cfg->Write(name, customColour);
-			}
-		}
-	}
-
-	return ret;
-}
Index: tools/atlas/AtlasUI/CustomControls/ColourDialog/ColourDialog.h
===================================================================
--- tools/atlas/AtlasUI/CustomControls/ColourDialog/ColourDialog.h	(revision 15728)
+++ tools/atlas/AtlasUI/CustomControls/ColourDialog/ColourDialog.h	(working copy)
@@ -1,35 +0,0 @@
-/* Copyright (C) 2009 Wildfire Games.
- * This file is part of 0 A.D.
- *
- * 0 A.D. is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * 0 A.D. is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef INCLUDED_COLOURDIALOG
-#define INCLUDED_COLOURDIALOG
-
-#include <wx/colordlg.h>
-
-class ColourDialog : public wxColourDialog
-{
-public:
-	// Typical customColourConfigPath would be "Scenario Editor/LightingColour"
-	ColourDialog(wxWindow* parent, const wxString& customColourConfigPath, const wxColour& defaultColour);
-
-	int ShowModal();
-
-private:
-	wxString m_ConfigPath;
-};
-
-#endif // INCLUDED_COLOURDIALOG
Index: tools/atlas/AtlasUI/CustomControls/EditableListCtrl/EditableListCtrl.cpp
===================================================================
--- tools/atlas/AtlasUI/CustomControls/EditableListCtrl/EditableListCtrl.cpp	(revision 15728)
+++ tools/atlas/AtlasUI/CustomControls/EditableListCtrl/EditableListCtrl.cpp	(working copy)
@@ -37,8 +37,8 @@
 								   const wxString& name)
 	: wxListCtrl(parent, id, pos, size, style | wxLC_VIRTUAL, validator, name)
 {
-	m_ListItemAttr[0].SetBackgroundColour(wxColour(0xff, 0xff, 0xff));
-	m_ListItemAttr[1].SetBackgroundColour(wxColour(0xee, 0xee, 0xee));
+	m_ListItemAttr[0].SetBackgroundColor(wxColor(0xff, 0xff, 0xff));
+	m_ListItemAttr[1].SetBackgroundColor(wxColor(0xee, 0xee, 0xee));
 
 	wxASSERT_MSG(style & wxLC_REPORT, _T("EditableListCtrl must be LC_REPORT"));
 	UpdateDisplay();
@@ -277,7 +277,7 @@
 	if (item >= (long)m_ListData.size())
 		return const_cast<wxListItemAttr*>(&m_ListItemAttr[0]);
 
-	// Make the background colours of rows alternate
+	// Make the background colors of rows alternate
 	else
 		return const_cast<wxListItemAttr*>(&m_ListItemAttr[item%2]);
 }
Index: tools/atlas/AtlasUI/CustomControls/EditableListCtrl/EditableListCtrl.h
===================================================================
--- tools/atlas/AtlasUI/CustomControls/EditableListCtrl/EditableListCtrl.h	(revision 15728)
+++ tools/atlas/AtlasUI/CustomControls/EditableListCtrl/EditableListCtrl.h	(working copy)
@@ -108,7 +108,7 @@
 
 	bool IsRowBlank(int n);
 
-	wxListItemAttr m_ListItemAttr[2]; // standard+alternate colours
+	wxListItemAttr m_ListItemAttr[2]; // standard+alternate colors
 
 	DECLARE_EVENT_TABLE();
 };
Index: tools/atlas/AtlasUI/ScenarioEditor/Sections/Environment/Environment.cpp
===================================================================
--- tools/atlas/AtlasUI/ScenarioEditor/Sections/Environment/Environment.cpp	(revision 15728)
+++ tools/atlas/AtlasUI/ScenarioEditor/Sections/Environment/Environment.cpp	(working copy)
@@ -157,12 +157,12 @@
 	void OnClick(wxCommandEvent& WXUNUSED(evt))
 	{
 		ColourDialog dlg (this, _T("Scenario Editor/LightingColour"),
-			wxColour(m_Colour->r, m_Colour->g, m_Colour->b));
+			wxColor(m_Color->r, m_Color->g, m_Color->b));
 
 		if (dlg.ShowModal() == wxID_OK)
 		{
-			wxColour& c = dlg.GetColourData().GetColour();
-			m_Colour = AtlasMessage::Colour(c.Red(), c.Green(), c.Blue());
+			wxColor& c = dlg.GetColourData().GetColour();
+			m_Color = AtlasMessage::Color(c.Red(), c.Green(), c.Blue());
 			UpdateButton();
 
 			g_EnvironmentSettings.NotifyObserversExcept(m_Conn);
@@ -171,7 +171,7 @@
 
 	void UpdateButton()
 	{
-		m_Button->SetBackgroundColour(wxColour(m_Colour->r, m_Colour->g, m_Colour->b));
+		m_Button->SetBackgroundColor(wxColor(m_Color->r, m_Color->g, m_Color->b));
 		m_Button->SetLabel(wxString::Format(_T("%02X %02X %02X"), m_Colour->r, m_Colour->g, m_Colour->b));
 
 		int y = 3*m_Colour->r + 6*m_Colour->g + 1*m_Colour->b;
Index: tools/atlas/AtlasUI/ScenarioEditor/Sections/Player/Player.cpp
===================================================================
--- tools/atlas/AtlasUI/ScenarioEditor/Sections/Player/Player.cpp	(revision 15728)
+++ tools/atlas/AtlasUI/ScenarioEditor/Sections/Player/Player.cpp	(working copy)
@@ -33,11 +33,11 @@
 	ID_PlayerMetal,
 	ID_PlayerStone,
 	ID_PlayerPop,
-	ID_PlayerColour,
+	ID_PlayerColor,
 
 	ID_DefaultName,
 	ID_DefaultCiv,
-	ID_DefaultColour,
+	ID_DefaultColor,
 	ID_DefaultAI,
 	ID_DefaultFood,
 	ID_DefaultWood,
@@ -130,12 +130,12 @@
 			gridSizer->Add(civChoice, wxSizerFlags(1).Expand().Align(wxALIGN_RIGHT));
 			m_Controls.civ = civChoice;
 
-			wxButton* colourButton = new wxButton(this, ID_PlayerColour);
-			gridSizer->Add(new DefaultCheckbox(this, ID_DefaultColour, colourButton), wxSizerFlags().Align(wxALIGN_CENTER_VERTICAL));
+			wxButton* colorButton = new wxButton(this, ID_PlayerColor);
+			gridSizer->Add(new DefaultCheckbox(this, ID_DefaultColor, colorButton), wxSizerFlags().Align(wxALIGN_CENTER_VERTICAL));
 			gridSizer->Add(new wxStaticText(this, wxID_ANY, _("Colour")), wxSizerFlags().Align(wxALIGN_CENTER_VERTICAL | wxALIGN_RIGHT));
-			gridSizer->Add(Tooltipped(colourButton,
+			gridSizer->Add(Tooltipped(colorButton,
 				_("Set player colour")), wxSizerFlags(1).Expand().Align(wxALIGN_RIGHT));
-			m_Controls.colour = colourButton;
+			m_Controls.color = colorButton;
 
 			wxChoice* aiChoice = new wxChoice(this, wxID_ANY);
 			gridSizer->Add(new DefaultCheckbox(this, ID_DefaultAI, aiChoice), wxSizerFlags().Align(wxALIGN_CENTER_VERTICAL));
Index: tools/atlas/AtlasUI/ScenarioEditor/Sections/Player/Player.h
===================================================================
--- tools/atlas/AtlasUI/ScenarioEditor/Sections/Player/Player.h	(revision 15728)
+++ tools/atlas/AtlasUI/ScenarioEditor/Sections/Player/Player.h	(working copy)
@@ -54,7 +54,7 @@
 
 	wxTextCtrl* name;
 	wxChoice* civ;
-	wxButton* colour;
+	wxButton* color;
 	wxSpinCtrl* food;
 	wxSpinCtrl* wood;
 	wxSpinCtrl* stone;
Index: tools/atlas/AtlasUI/ScenarioEditor/Sections/Terrain/Terrain.cpp
===================================================================
--- tools/atlas/AtlasUI/ScenarioEditor/Sections/Terrain/Terrain.cpp	(revision 15728)
+++ tools/atlas/AtlasUI/ScenarioEditor/Sections/Terrain/Terrain.cpp	(working copy)
@@ -326,7 +326,7 @@
 	{
 		m_ScrolledPanel = new wxScrolledWindow(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxVSCROLL);
 		m_ScrolledPanel->SetScrollRate(0, 10);
-		m_ScrolledPanel->SetBackgroundColour(wxColour(255, 255, 255));
+		m_ScrolledPanel->SetBackgroundColor(wxColor(255, 255, 255));
 
 		wxSizer* sizer = new wxBoxSizer(wxVERTICAL);
 		sizer->Add(m_ScrolledPanel, wxSizerFlags().Proportion(1).Expand());
@@ -418,9 +418,9 @@
 		g_SelectedTexture.NotifyObservers();
 
 		if (m_LastTerrainSelection)
-			m_LastTerrainSelection->SetBackgroundColour(wxNullColour);
+			m_LastTerrainSelection->SetBackgroundColor(wxNullColor);
 
-		button->SetBackgroundColour(wxColour(255, 255, 0));
+		button->SetBackgroundColor(wxColor(255, 255, 0));
 		m_LastTerrainSelection = button;
 
 		// Slight hack: Default to Paint mode because that's probably what the user wanted
@@ -449,7 +449,7 @@
 	wxString m_Name;
 	wxScrolledWindow* m_ScrolledPanel;
 	wxGridSizer* m_ItemSizer;
-	wxButton* m_LastTerrainSelection; // button that was last selected, so we can undo its colouring
+	wxButton* m_LastTerrainSelection; // button that was last selected, so we can undo its coloring
 
 	DECLARE_EVENT_TABLE();
 };
Index: tools/atlas/GameInterface/ActorViewer.cpp
===================================================================
--- tools/atlas/GameInterface/ActorViewer.cpp	(revision 15728)
+++ tools/atlas/GameInterface/ActorViewer.cpp	(working copy)
@@ -440,10 +440,10 @@
 	m.CurrentUnitAnim = animation;
 }
 
-void ActorViewer::SetBackgroundColour(const SColor4ub& colour)
+void ActorViewer::SetBackgroundColor(const SColor4ub& color)
 {
-	m.Background = colour;
-	m.Terrain.SetBaseColour(colour);
+	m.Background = color;
+	m.Terrain.SetBaseColor(color);
 }
 
 void ActorViewer::SetWalkEnabled(bool enabled)    { m.WalkEnabled = enabled; }
Index: tools/atlas/GameInterface/ActorViewer.h
===================================================================
--- tools/atlas/GameInterface/ActorViewer.h	(revision 15728)
+++ tools/atlas/GameInterface/ActorViewer.h	(working copy)
@@ -37,7 +37,7 @@
 	entity_id_t GetEntity();
 	void SetActor(const CStrW& id, const CStrW& animation, player_id_t playerID);
 	void UnloadObjects();
-	void SetBackgroundColour(const SColor4ub& colour);
+	void SetBackgroundColor(const SColor4ub& color);
 	void SetWalkEnabled(bool enabled);
 	void SetGroundEnabled(bool enabled);
 	void SetWaterEnabled(bool enabled);
Index: tools/atlas/GameInterface/Brushes.cpp
===================================================================
--- tools/atlas/GameInterface/Brushes.cpp	(revision 15728)
+++ tools/atlas/GameInterface/Brushes.cpp	(working copy)
@@ -56,7 +56,7 @@
 	{
 		ssize_t i0, j0;
 		m_Brush->GetBottomLeft(i0, j0);
-		// Colour this tile based on the average of the surrounding vertices
+		// Color this tile based on the average of the surrounding vertices
 		float avg = (
 			m_Brush->Get(i-i0, j-j0)   + m_Brush->Get(i-i0+1, j-j0) +
 			m_Brush->Get(i-i0, j-j0+1) + m_Brush->Get(i-i0+1, j-j0+1)
Index: tools/atlas/GameInterface/Handlers/EnvironmentHandlers.cpp
===================================================================
--- tools/atlas/GameInterface/Handlers/EnvironmentHandlers.cpp	(revision 15728)
+++ tools/atlas/GameInterface/Handlers/EnvironmentHandlers.cpp	(working copy)
@@ -49,11 +49,11 @@
 	s.watermurkiness = wm->m_Murkiness;
 	s.windangle = wm->m_WindAngle;
 
-	// CColor colours
-#define COLOUR(A, B) A = Colour((int)(B.r*255), (int)(B.g*255), (int)(B.b*255))
-	COLOUR(s.watercolour, wm->m_WaterColor);
-	COLOUR(s.watertint, wm->m_WaterTint);
-#undef COLOUR
+	// CColor colors
+#define COLOR(A, B) A = Color((int)(B.r*255), (int)(B.g*255), (int)(B.b*255))
+	COLOR(s.watercolor, wm->m_WaterColor);
+	COLOR(s.watertint, wm->m_WaterTint);
+#undef COLOR
 
 	float sunrotation = g_LightEnv.GetRotation();
 	if (sunrotation > (float)M_PI)
@@ -73,8 +73,8 @@
 	s.saturation = g_LightEnv.m_Saturation;
 	s.bloom = g_LightEnv.m_Bloom;
 
-	// RGBColor (CVector3D) colours
-#define COLOUR(A, B) A = Colour((int)(B.X*255), (int)(B.Y*255), (int)(B.Z*255))
+	// RGBColor (CVector3D) colors
+#define COLOR(A, B) A = Color((int)(B.X*255), (int)(B.Y*255), (int)(B.Z*255))
 	s.sunoverbrightness = MaxComponent(g_LightEnv.m_SunColor);
 	// clamp color to [0..1] before packing into u8 triplet
 	if(s.sunoverbrightness > 1.0f)
@@ -82,11 +82,11 @@
 	// no component was above 1.0, so reset scale factor (don't want to darken)
 	else
 		s.sunoverbrightness = 1.0f;
-	COLOUR(s.suncolour, g_LightEnv.m_SunColor);
-	COLOUR(s.terraincolour, g_LightEnv.m_TerrainAmbientColor);
-	COLOUR(s.unitcolour, g_LightEnv.m_UnitsAmbientColor);
-	COLOUR(s.fogcolour, g_LightEnv.m_FogColor);
-#undef COLOUR
+	COLOR(s.suncolor, g_LightEnv.m_SunColor);
+	COLOR(s.terraincolor, g_LightEnv.m_TerrainAmbientColor);
+	COLOR(s.unitcolor, g_LightEnv.m_UnitsAmbientColor);
+	COLOR(s.fogcolor, g_LightEnv.m_FogColor);
+#undef COLOR
 
 	return s;
 }
@@ -104,10 +104,10 @@
 	wm->m_WindAngle = s.windangle;
 	wm->m_WaterType = s.watertype._Unwrap();
 	
-#define COLOUR(A, B) B = CColor(A->r/255.f, A->g/255.f, A->b/255.f, 1.f)
-	COLOUR(s.watercolour, wm->m_WaterColor);
-	COLOUR(s.watertint, wm->m_WaterTint);
-#undef COLOUR
+#define COLOR(A, B) B = CColor(A->r/255.f, A->g/255.f, A->b/255.f, 1.f)
+	COLOR(s.watercolor, wm->m_WaterColor);
+	COLOR(s.watertint, wm->m_WaterTint);
+#undef COLOR
 
 	g_LightEnv.SetRotation(s.sunrotation);
 	g_LightEnv.SetElevation(s.sunelevation);
@@ -130,13 +130,13 @@
 	g_LightEnv.m_Saturation = s.saturation;
 	g_LightEnv.m_Bloom = s.bloom;
 
-#define COLOUR(A, B) B = RGBColor(A->r/255.f, A->g/255.f, A->b/255.f)
-	COLOUR(s.suncolour, g_LightEnv.m_SunColor);
+#define COLOR(A, B) B = RGBColor(A->r/255.f, A->g/255.f, A->b/255.f)
+	COLOR(s.suncolor, g_LightEnv.m_SunColor);
 	g_LightEnv.m_SunColor *= s.sunoverbrightness;
-	COLOUR(s.terraincolour, g_LightEnv.m_TerrainAmbientColor);
-	COLOUR(s.unitcolour, g_LightEnv.m_UnitsAmbientColor);
-	COLOUR(s.fogcolour, g_LightEnv.m_FogColor);
-#undef COLOUR
+	COLOR(s.terraincolor, g_LightEnv.m_TerrainAmbientColor);
+	COLOR(s.unitcolor, g_LightEnv.m_UnitsAmbientColor);
+	COLOR(s.fogcolor, g_LightEnv.m_FogColor);
+#undef COLOR
 }
 
 BEGIN_COMMAND(SetEnvironmentSettings)
Index: tools/atlas/GameInterface/Handlers/MapHandlers.cpp
===================================================================
--- tools/atlas/GameInterface/Handlers/MapHandlers.cpp	(revision 15728)
+++ tools/atlas/GameInterface/Handlers/MapHandlers.cpp	(working copy)
@@ -231,7 +231,7 @@
 		{
 			int offset = y * mapLineSkip + x * bytesPP;
 			
-			// pick colour channel with highest value
+			// pick color channel with highest value
 			u16 value = std::max(mapdata[offset+bytesPP*2], std::max(mapdata[offset], mapdata[offset+bytesPP]));
 			
 			heightmap[(terrainSize-y-1) * hmSize + x] = clamp(value * 256, 0, 65535);
Index: tools/atlas/GameInterface/Handlers/ObjectHandlers.cpp
===================================================================
--- tools/atlas/GameInterface/Handlers/ObjectHandlers.cpp	(revision 15728)
+++ tools/atlas/GameInterface/Handlers/ObjectHandlers.cpp	(working copy)
@@ -101,7 +101,7 @@
 // Helper function to find color of player owning the given entity,
 //	returns white if entity has no owner. Uses caching to avoid
 //	expensive script calls.
-static CColor GetOwnerPlayerColor(PlayerColorMap& colourMap, entity_id_t id)
+static CColor GetOwnerPlayerColor(PlayerColorMap& colorMap, entity_id_t id)
 {
 	// Default color - white
 	CColor color(1.0f, 1.0f, 1.0f, 1.0f);
@@ -111,8 +111,8 @@
 	if (cmpOwnership)
 	{
 		player_id_t owner = cmpOwnership->GetOwner();
-		if (colourMap.find(owner) != colourMap.end())
-			return colourMap[owner];
+		if (colorMap.find(owner) != colorMap.end())
+			return colorMap[owner];
 		else
 		{
 			CmpPtr<ICmpPlayerManager> cmpPlayerManager(sim, SYSTEM_ENTITY);
@@ -119,7 +119,7 @@
 			entity_id_t playerEnt = cmpPlayerManager->GetPlayerByID(owner);
 			CmpPtr<ICmpPlayer> cmpPlayer(sim, playerEnt);
 			if (cmpPlayer)
-				color = colourMap[owner] = cmpPlayer->GetColour();
+				color = colorMap[owner] = cmpPlayer->GetColor();
 		}
 	}
 	return color;
@@ -129,7 +129,7 @@
 {
 	CSimulation2& sim = *g_Game->GetSimulation2();
 
-	// Cache player colours for performance
+	// Cache player colors for performance
 	PlayerColorMap playerColors;
 
 	// Clear old selection rings
Index: tools/atlas/GameInterface/Messages.h
===================================================================
--- tools/atlas/GameInterface/Messages.h	(revision 15728)
+++ tools/atlas/GameInterface/Messages.h	(working copy)
@@ -60,7 +60,7 @@
 MESSAGE(SetViewParamC,
 		((int, view)) // eRenderView
 		((std::wstring, name))
-		((Colour, value))
+		((Color, value))
 		);
 MESSAGE(SetViewParamS,
 		((int, view)) // eRenderView
@@ -442,15 +442,15 @@
 	Shareable<float> watermurkiness; // range ???
 	Shareable<float> windangle;
 
-	Shareable<Colour> watercolour;
-	Shareable<Colour> watertint;
+	Shareable<Color> watercolor;
+	Shareable<Color> watertint;
 
 	Shareable<float> sunrotation; // range -pi..+pi
 	Shareable<float> sunelevation; // range -pi/2 .. +pi/2
 
-	// emulate 'HDR' by allowing overly bright suncolour. this is
-	// multiplied on to suncolour after converting to float
-	// (struct Colour stores as normal u8, 0..255)
+	// emulate 'HDR' by allowing overly bright suncolor. this is
+	// multiplied on to suncolor after converting to float
+	// (struct Color stores as normal u8, 0..255)
 	Shareable<float> sunoverbrightness; // range 1..3
 
 	// support different lighting models ("old" for the version compatible with old scenarios,
@@ -459,10 +459,10 @@
 
 	Shareable<std::wstring> skyset;
 
-	Shareable<Colour> suncolour;
-	Shareable<Colour> terraincolour;
-	Shareable<Colour> unitcolour;
-	Shareable<Colour> fogcolour;
+	Shareable<Color> suncolor;
+	Shareable<Color> terraincolor;
+	Shareable<Color> unitcolor;
+	Shareable<Color> fogcolor;
 	
 	Shareable<float> fogfactor;
 	Shareable<float> fogmax;
Index: tools/atlas/GameInterface/SharedTypes.h
===================================================================
--- tools/atlas/GameInterface/SharedTypes.h	(revision 15728)
+++ tools/atlas/GameInterface/SharedTypes.h	(working copy)
@@ -66,14 +66,14 @@
 SHAREABLE_STRUCT(Position);
 
 
-struct Colour
+struct Color
 {
-	Colour()
+	Color()
 		: r(255), g(0), b(255)
 	{
 	}
 
-	Colour(unsigned char r, unsigned char g, unsigned char b)
+	Color(unsigned char r, unsigned char g, unsigned char b)
 		: r(r), g(g), b(b)
 	{
 	}
@@ -80,7 +80,7 @@
 
 	unsigned char r, g, b;
 };
-SHAREABLE_STRUCT(Colour);
+SHAREABLE_STRUCT(Color);
 
 
 typedef unsigned int ObjectID;
Index: tools/atlas/GameInterface/View.cpp
===================================================================
--- tools/atlas/GameInterface/View.cpp	(revision 15728)
+++ tools/atlas/GameInterface/View.cpp	(working copy)
@@ -51,7 +51,7 @@
 {
 }
 
-void AtlasView::SetParam(const std::wstring& UNUSED(name), const AtlasMessage::Colour& UNUSED(value))
+void AtlasView::SetParam(const std::wstring& UNUSED(name), const AtlasMessage::Color& UNUSED(value))
 {
 }
 
@@ -151,11 +151,11 @@
 		m_ActorViewer->SetPropPointsMode(value);
 }
 
-void AtlasViewActor::SetParam(const std::wstring& name, const AtlasMessage::Colour& value)
+void AtlasViewActor::SetParam(const std::wstring& name, const AtlasMessage::Color& value)
 {
 	if (name == L"background")
 	{
-		m_ActorViewer->SetBackgroundColour(SColor4ub(value.r, value.g, value.b, 255));
+		m_ActorViewer->SetBackgroundColor(SColor4ub(value.r, value.g, value.b, 255));
 	}
 }
 
Index: tools/atlas/GameInterface/View.h
===================================================================
--- tools/atlas/GameInterface/View.h	(revision 15728)
+++ tools/atlas/GameInterface/View.h	(working copy)
@@ -48,7 +48,7 @@
 
 	virtual void SetParam(const std::wstring& name, bool value);
 	virtual void SetParam(const std::wstring& name, int value);
-	virtual void SetParam(const std::wstring& name, const AtlasMessage::Colour& value);
+	virtual void SetParam(const std::wstring& name, const AtlasMessage::Color& value);
 	virtual void SetParam(const std::wstring& name, const std::wstring& value);
 
 	// These always return a valid (not NULL) object
@@ -139,7 +139,7 @@
 
 	virtual void SetParam(const std::wstring& name, bool value);
 	virtual void SetParam(const std::wstring& name, int value);
-	virtual void SetParam(const std::wstring& name, const AtlasMessage::Colour& value);
+	virtual void SetParam(const std::wstring& name, const AtlasMessage::Color& value);
 
 	void SetSpeedMultiplier(float speedMultiplier);
 	ActorViewer& GetActorViewer();
