Index: binaries/data/mods/mod/gui/gui.rng
===================================================================
--- binaries/data/mods/mod/gui/gui.rng
+++ binaries/data/mods/mod/gui/gui.rng
@@ -572,12 +572,17 @@
   </define>
   <define name="repeat">
     <element name="repeat">
+      <choice>
+        <element name="count">
+          <text/>
+        </element>
+        <attribute name="count">
+          <data type="nonNegativeInteger"/>
+        </attribute>
+      </choice>
       <oneOrMore>
         <ref name="object"/>
       </oneOrMore>
-      <attribute name="count">
-        <data type="nonNegativeInteger"/>
-      </attribute>
       <optional>
         <attribute name="var"/>
       </optional>
Index: binaries/data/mods/public/gui/session/diplomacy/DiplomacyDialog.xml
===================================================================
--- binaries/data/mods/public/gui/session/diplomacy/DiplomacyDialog.xml
+++ binaries/data/mods/public/gui/session/diplomacy/DiplomacyDialog.xml
@@ -41,7 +41,8 @@
 	</object>
 
 	<object size="32 64 100%-32 384">
-		<repeat count="8" var="n">
+		<repeat var="n">
+			<count> Engine.GetNumberOfPlayers() </count>
 			<object name="diplomacyPlayer[n]" size="0 0 100% 20" type="image" hidden="true">
 				<object name="diplomacyPlayerOutcome[n]" size="0 0 25 100%" type="image" tooltip_style="sessionToolTipBold"/>
 				<object name="diplomacyPlayerName[n]" size="25 0 150 100%" type="text" style="DiplomacyText"/>
@@ -56,7 +57,8 @@
 
 				<!-- Tribute -->
 				<object name="diplomacyPlayer[n]_tribute" size="430 0 100%-80 100%">
-					<repeat count="8" var="r">
+					<repeat var="r">
+						<count> Engine.GetNumberOfPlayers() </count>
 						<object name="diplomacyPlayer[n]_tribute[r]" size="0 0 20 100%" type="button" style="iconButton" tooltip_style="sessionToolTipBold" hidden="true">
 							<object name="diplomacyPlayer[n]_tribute[r]_image" type="image" ghost="true"/>
 						</object>
Index: binaries/data/mods/public/gui/session/selection_panels_middle/multiple_details_area.xml
===================================================================
--- binaries/data/mods/public/gui/session/selection_panels_middle/multiple_details_area.xml
+++ binaries/data/mods/public/gui/session/selection_panels_middle/multiple_details_area.xml
@@ -36,7 +36,8 @@
 	<!-- Capture bar -->
 	<object size="15 0 22 100%" type="image" name="captureMultiple" tooltip_style="sessionToolTip">
 		<object type="image" sprite="barBorder" ghost="true" size="-1 -1 100%+1 100%+1"/>
-		<repeat count="9">
+		<repeat>
+			<count> Engine.GetNumberOfPlayers() + 1 </count>
 			<object type="image" sprite="playerColorBackground" ghost="true" name="captureBarMultiple[n]" hidden="true"/>
 		</repeat>
 		<object type="image" sprite="statsBarShaderVertical" ghost="true"/>
Index: binaries/data/mods/public/gui/session/selection_panels_middle/single_details_area.xml
===================================================================
--- binaries/data/mods/public/gui/session/selection_panels_middle/single_details_area.xml
+++ binaries/data/mods/public/gui/session/selection_panels_middle/single_details_area.xml
@@ -34,7 +34,8 @@
 				<object size="0 0 100% 12" name="captureStats" type="text" style="StatsTextRight" ghost="true"/>
 				<object size="1 14 100% 21" name="capture" type="image" tooltip_style="sessionToolTip">
 					<object type="image" sprite="barBorder" ghost="true" size="-1 -1 100%+1 100%+1"/>
-					<repeat count="9">
+					<repeat>
+						<count> Engine.GetNumberOfPlayers() + 1 </count>
 						<object type="image" sprite="playerColorBackground" ghost="true" name="captureBar[n]" hidden="true"/>
 					</repeat>
 					<object type="image" sprite="statsBarShaderHorizontal" ghost="true"/>
Index: binaries/data/mods/public/gui/session/trade/TradePanel.xml
===================================================================
--- binaries/data/mods/public/gui/session/trade/TradePanel.xml
+++ binaries/data/mods/public/gui/session/trade/TradePanel.xml
@@ -15,7 +15,8 @@
 		</object>
 
 		<object name="tradeResources" size="92 0 100% 100%">
-			<repeat count="8">
+			<repeat>
+				<count> Engine.GetNumberOfPlayers() </count>
 				<object name="tradeResource[n]" size="0 0 58 32">
 
 					<object name="tradeResourceButton[n]" type="button" size="4 0 36 100%" style="StoneButton">
Index: binaries/data/mods/public/simulation/helpers/Player.js
===================================================================
--- binaries/data/mods/public/simulation/helpers/Player.js
+++ binaries/data/mods/public/simulation/helpers/Player.js
@@ -1,3 +1,49 @@
+var randColor = [
+	[0, 255, 255],
+	[240, 255, 255],
+	[245, 245, 220],
+	[0, 0, 0],
+	[0, 0, 255],
+	[165, 42, 42],
+	[0, 255, 255],
+	[0, 0, 139],
+	[0, 139, 139],
+	[169, 169, 169],
+	[0, 100, 0],
+	[189, 183, 107],
+	[139, 0, 139],
+	[85, 107, 47],
+	[255, 140, 0],
+	[153, 50, 204],
+	[139, 0, 0],
+	[233, 150, 122],
+	[148, 0, 211],
+	[255, 0, 255],
+	[255, 215, 0],
+	[0, 128, 0],
+	[75, 0, 130],
+	[240, 230, 140],
+	[173, 216, 230],
+	[224, 255, 255],
+	[144, 238, 144],
+	[211, 211, 211],
+	[255, 182, 193],
+	[255, 255, 224],
+	[0, 255, 0],
+	[255, 0, 255],
+	[128, 0, 0],
+	[0, 0, 128],
+	[128, 128, 0],
+	[255, 165, 0],
+	[255, 192, 203],
+	[128, 0, 128],
+	[128, 0, 128],
+	[255, 0, 0],
+	[192, 192, 192],
+	[255, 255, 255],
+	[255, 255, 0]
+];
+
 /**
  * Used to create player entities prior to reading the rest of a map,
  * all other initialization must be done after loading map (terrain/entities).
@@ -34,7 +80,7 @@
 	// Remove existing players or add new ones
 	if (newPlayers)
 	{
-		var settingsNumPlayers = 9; // default 8 players + gaia
+		var settingsNumPlayers = playerData.length;
 
 		if (playerData)
 			settingsNumPlayers = playerData.length; // includes gaia (see above)
@@ -43,6 +89,20 @@
 
 		while (settingsNumPlayers > numPlayers)
 		{
+			// Use data from first player if not defined 
+			if (playerDefaults[numPlayers] === undefined)
+			{				
+				let playerN = Object.assign({}, playerDefaults[1])
+				let color = randColor[numPlayers % randColor.length];
+				playerN.Name = "Player " + playerN
+				playerN.Color = {
+					"r": color[0],
+					"g": color[1],
+					"b": color[2]
+				}
+				playerDefaults[numPlayers] = playerN;
+			}
+			
 			// Add player entity to engine
 			var entID = Engine.AddEntity(GetPlayerTemplateName(getSetting(playerData, playerDefaults, numPlayers, "Civ")));
 			var cmpPlayer = Engine.QueryInterface(entID, IID_Player);
Index: source/graphics/tests/test_LOSTexture.h
===================================================================
--- source/graphics/tests/test_LOSTexture.h
+++ source/graphics/tests/test_LOSTexture.h
@@ -31,22 +31,26 @@
 		CLOSTexture tex(sim);
 
 		const ssize_t size = 8;
-		u32 inputData[size*size] = {
-			2, 2, 2, 0, 0, 0, 0, 0,
-			2, 2, 2, 0, 0, 0, 0, 0,
-			2, 2, 2, 0, 0, 0, 0, 0,
-			0, 0, 0, 0, 0, 0, 0, 0,
-			0, 0, 0, 0, 0, 0, 0, 0,
-			0, 0, 0, 0, 0, 0, 0, 0,
-			0, 0, 0, 0, 0, 0, 0, 0,
-			0, 0, 0, 0, 0, 0, 0, 2
+		PlayersData o(0); o.set(0,0); // zero
+		PlayersData x(0); x.set(0,2); // two
+		
+		PlayersData inputData[size*size] = {
+			x, x, x, o, o, o, o, o,
+			x, x, x, o, o, o, o, o,
+			x, x, x, o, o, o, o, o,
+			o, o, o, o, o, o, o, o,
+			o, o, o, o, o, o, o, o,
+			o, o, o, o, o, o, o, o,
+			o, o, o, o, o, o, o, o,
+			o, o, o, o, o, o, o, x
 		};
-		std::vector<u32> inputDataVec(inputData, inputData+size*size);
+		std::vector<PlayersData> inputDataVec(inputData, inputData+size*size);
 
 		// LOS_MASK should be cmpRanageManager->GetSharedLosMask(1),
 		// but that would mean adding a huge mock component for this and it
 		// should always be LOS_MASK for player 1 (as the other players are bit-shifted).
-		ICmpRangeManager::CLosQuerier los(ICmpRangeManager::LOS_MASK, inputDataVec, size);
+		PlayersData player1(0); player1.set(0, ICmpRangeManager::LOS_MASK);
+		ICmpRangeManager::CLosQuerier los(player1, inputDataVec, size);
 
 		std::vector<u8> losData;
 		size_t pitch;
@@ -66,13 +70,14 @@
 		CLOSTexture tex(sim);
 
 		const ssize_t size = 257;
-		std::vector<u32> inputDataVec;
+		std::vector<PlayersData> inputDataVec;
 		inputDataVec.resize(size*size);
 
 		// LOS_MASK should be cmpRanageManager->GetSharedLosMask(1),
 		// but that would mean adding a huge mock component for this and it
 		// should always be LOS_MASK for player 1 (as the other players are bit-shifted).
-		ICmpRangeManager::CLosQuerier los(ICmpRangeManager::LOS_MASK, inputDataVec, size);
+		PlayersData player1(0); player1.set(0, ICmpRangeManager::LOS_MASK);
+		ICmpRangeManager::CLosQuerier los(player1, inputDataVec, size);
 
 		size_t reps = 128;
 		double t = timer_Time();
Index: source/gui/CGUI.cpp
===================================================================
--- source/gui/CGUI.cpp
+++ source/gui/CGUI.cpp
@@ -852,12 +852,33 @@
 	#define ELMT(x) int elmt_##x = pFile->GetElementID(#x)
 	#define ATTR(x) int attr_##x = pFile->GetAttributeID(#x)
 	ELMT(object);
+	ELMT(count);
 	ATTR(count);
 	ATTR(var);
 
 	XMBAttributeList attributes = Element.GetAttributes();
 
-	int count = CStr(attributes.GetNamedItem(attr_count)).ToInt();
+	int count = 0;
+	
+	if (!attributes.GetNamedItem(attr_count).empty())
+		count = CStr(attributes.GetNamedItem(attr_count)).ToInt();
+	else 
+	{
+		for (XMBElement child : Element.GetChildNodes())
+		{
+			if (child.GetNodeName() != elmt_count)
+				break;
+
+			JSContext* cx = m_ScriptInterface->GetContext();
+			JSAutoRequest rq(cx);
+			JS::RootedValue result(cx);
+			if (m_ScriptInterface->Eval(child.GetText().c_str(), &result))			
+				if (result.isNumber())
+					count = result.toNumber();
+			break;
+		}
+	}
+	
 	CStr var("["+attributes.GetNamedItem(attr_var)+"]");
 	if (var.size() < 3)
 		var = "[n]";
Index: source/ps/GameSetup/GameSetup.cpp
===================================================================
--- source/ps/GameSetup/GameSetup.cpp
+++ source/ps/GameSetup/GameSetup.cpp
@@ -80,6 +80,7 @@
 #include "scriptinterface/ScriptConversions.h"
 #include "scriptinterface/ScriptRuntime.h"
 #include "simulation2/Simulation2.h"
+#include "simulation2/helpers/ArrayData.h"
 #include "lobby/IXmppClient.h"
 #include "soundmanager/scripting/JSInterface_Sound.h"
 #include "soundmanager/ISoundManager.h"
@@ -1318,6 +1319,9 @@
 		}
 
 		// Set up player data
+		Simulation_SetNumberOfPlayersReadOnly(false);
+		Simulation_SetNumberOfPlayers(numPlayers);
+		Simulation_SetNumberOfPlayersReadOnly(true);
 		for (size_t i = 0; i < numPlayers; ++i)
 		{
 			JS::RootedValue player(cx);
Index: source/ps/scripting/JSInterface_Game.h
===================================================================
--- source/ps/scripting/JSInterface_Game.h
+++ source/ps/scripting/JSInterface_Game.h
@@ -37,6 +37,7 @@
 	void RewindTimeWarp(ScriptInterface::CxPrivate* pCxPrivate);
 	void EnableTimeWarpRecording(ScriptInterface::CxPrivate* pCxPrivate, unsigned int numTurns);
 	void DumpTerrainMipmap(ScriptInterface::CxPrivate* pCxPrivate);
+	int GetNumberOfPlayers(ScriptInterface::CxPrivate* pCxPrivate);
 
 	void RegisterScriptFunctions(const ScriptInterface& ScriptInterface);
 }
Index: source/ps/scripting/JSInterface_Game.cpp
===================================================================
--- source/ps/scripting/JSInterface_Game.cpp
+++ source/ps/scripting/JSInterface_Game.cpp
@@ -28,6 +28,7 @@
 #include "ps/World.h"
 #include "scriptinterface/ScriptInterface.h"
 #include "simulation2/system/TurnManager.h"
+#include "simulation2/helpers/ArrayData.h"
 #include "simulation2/Simulation2.h"
 #include "soundmanager/SoundManager.h"
 
@@ -169,6 +170,11 @@
 	LOGMESSAGERENDER("Terrain mipmap written to '%s'", realPath.string8());
 }
 
+int JSI_Game::GetNumberOfPlayers(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
+{
+	return Simulation_GetNumberOfPlayers();
+}
+
 void JSI_Game::RegisterScriptFunctions(const ScriptInterface& scriptInterface)
 {
 	scriptInterface.RegisterFunction<bool, &IsGameStarted>("IsGameStarted");
@@ -186,4 +192,5 @@
 	scriptInterface.RegisterFunction<void, unsigned int, &EnableTimeWarpRecording>("EnableTimeWarpRecording");
 	scriptInterface.RegisterFunction<void, &RewindTimeWarp>("RewindTimeWarp");
 	scriptInterface.RegisterFunction<void, &DumpTerrainMipmap>("DumpTerrainMipmap");
+	scriptInterface.RegisterFunction<int, &GetNumberOfPlayers>("GetNumberOfPlayers");
 }
Index: source/simulation2/components/CCmpRangeManager.cpp
===================================================================
--- source/simulation2/components/CCmpRangeManager.cpp
+++ source/simulation2/components/CCmpRangeManager.cpp
@@ -35,6 +35,7 @@
 #include "simulation2/helpers/MapEdgeTiles.h"
 #include "simulation2/helpers/Render.h"
 #include "simulation2/helpers/Spatial.h"
+#include "simulation2/helpers/ArrayData.h"
 
 #include "graphics/Overlay.h"
 #include "graphics/Terrain.h"
@@ -57,42 +58,32 @@
 	entity_pos_t minRange;
 	entity_pos_t maxRange;
 	entity_pos_t elevationBonus;
-	u32 ownersMask;
+	OwnersData ownersMask;
 	i32 interface;
 	std::vector<entity_id_t> lastMatch;
 	u8 flagsMask;
 };
 
-/**
- * Convert an owner ID (-1 = unowned, 0 = gaia, 1..30 = players)
- * into a 32-bit mask for quick set-membership tests.
- */
-static inline u32 CalcOwnerMask(player_id_t owner)
+
+static inline bool validPlayer(player_id_t player)
 {
-	if (owner >= -1 && owner < 31)
-		return 1 << (1+owner);
-	else
-		return 0; // owner was invalid
+	return player > 0 && player <= Simulation_GetNumberOfPlayers();
 }
 
-/**
- * Returns LOS mask for given player.
- */
-static inline u32 CalcPlayerLosMask(player_id_t player)
+static inline bool validOwner(int owner)
 {
-	if (player > 0 && player <= 16)
-		return ICmpRangeManager::LOS_MASK << (2*(player-1));
-	return 0;
+	return owner >= -1 && owner <= Simulation_GetNumberOfPlayers();
 }
 
 /**
  * Returns shared LOS mask for given list of players.
  */
-static u32 CalcSharedLosMask(std::vector<player_id_t> players)
+static PlayersData CalcSharedLosMask(std::vector<player_id_t> players)
 {
-	u32 playerMask = 0;
-	for (size_t i = 0; i < players.size(); i++)
-		playerMask |= CalcPlayerLosMask(players[i]);
+	PlayersData playerMask(0);
+	for (player_id_t id : players)
+		if(validPlayer(id))
+			playerMask.set(id, ICmpRangeManager::LOS_MASK);
 
 	return playerMask;
 }
@@ -101,58 +92,39 @@
  * Add/remove a player to/from mask, which is a 1-bit mask representing a list of players.
  * Returns true if the mask is modified.
  */
-static bool SetPlayerSharedDirtyVisibilityBit(u16& mask, player_id_t player, bool enable)
+static bool SetPlayerSharedDirtyVisibilityBit(PlayersData& mask, player_id_t player, bool enable)
 {
-	if (player <= 0 || player > 16)
+	if (!validPlayer(player))
 		return false;
 
-	u16 oldMask = mask;
+	PlayersData oldMask = mask;
 
-	if (enable)
-		mask |= (0x1 << (player - 1));
-	else
-		mask &= ~(0x1 << (player - 1));
+	mask.set(player, enable ? 0x1 : ~0x1);
 
-	return oldMask != mask;
+	return !oldMask.isEqual(mask);
 }
 
 /**
  * Computes the 2-bit visibility for one player, given the total 32-bit visibilities
  */
-static inline u8 GetPlayerVisibility(u32 visibilities, player_id_t player)
+static inline u8 GetPlayerVisibility(PlayersData visibilities, player_id_t player)
 {
-	if (player > 0 && player <= 16)
-		return (visibilities >> (2 *(player-1))) & 0x3;
+	if (validPlayer(player))
+		return visibilities.get(player) & 0x3;
 	return 0;
 }
 
 /**
  * Test whether the visibility is dirty for a given LoS tile and a given player
  */
-static inline bool IsVisibilityDirty(u16 dirty, player_id_t player)
+static inline bool IsVisibilityDirty(const PlayersData & dirty, player_id_t player)
 {
-	if (player > 0 && player <= 16)
-		return (dirty >> (player - 1)) & 0x1;
+	if (validPlayer(player))
+		return dirty.get(player) & 0x1;
 	return false;
 }
 
 /**
- * Test whether a player share this vision
- */
-static inline bool HasVisionSharing(u16 visionSharing, player_id_t player)
-{
-	return visionSharing & 1 << (player-1);
-}
-
-/**
- * Computes the shared vision mask for the player
- */
-static inline u16 CalcVisionSharingMask(player_id_t player)
-{
-	return 1 << (player-1);
-}
-
-/**
  * Checks whether v is in a parabolic range of (0,0,0)
  * The highest point of the paraboloid is (0,range/2,0)
  * and the circle of distance 'range' around (0,0,0) on height y=0 is part of the paraboloid
@@ -216,9 +188,9 @@
 		{ }
 	entity_pos_t x, z;
 	entity_pos_t visionRange;
-	u32 visibilities; // 2-bit visibility, per player
+	PlayersData visibilities; // 2-bit visibility, per player
 	u32 size;
-	u16 visionSharing; // 1-bit per player
+	PlayersData visionSharing; // 1-bit per player
 	i8 owner;
 	u8 flags; // See the FlagMasks enum
 
@@ -231,7 +203,7 @@
 	inline void SetFlag(u8 mask, bool val) { flags = val ? (flags | mask) : (flags & ~mask); }
 };
 
-cassert(sizeof(EntityData) == 24);
+//cassert(sizeof(EntityData) == 24);
 
 /**
  * Serialization helper template for Query
@@ -246,7 +218,7 @@
 		serialize.NumberFixed_Unbounded("min range", value.minRange);
 		serialize.NumberFixed_Unbounded("max range", value.maxRange);
 		serialize.NumberFixed_Unbounded("elevation bonus", value.elevationBonus);
-		serialize.NumberU32_Unbounded("owners mask", value.ownersMask);
+		SerializeOwnersData()(serialize,"owners mask", value.ownersMask);
 		serialize.NumberI32_Unbounded("interface", value.interface);
 		SerializeVector<SerializeU32_Unbounded>()(serialize, "last match", value.lastMatch);
 		serialize.NumberU8_Unbounded("flagsMask", value.flagsMask);
@@ -283,9 +255,9 @@
 		serialize.NumberFixed_Unbounded("x", value.x);
 		serialize.NumberFixed_Unbounded("z", value.z);
 		serialize.NumberFixed_Unbounded("vision", value.visionRange);
-		serialize.NumberU32_Unbounded("visibilities", value.visibilities);
+		SerializePlayersData()(serialize, "visibilities", value.visibilities);
 		serialize.NumberU32_Unbounded("size", value.size);
-		serialize.NumberU16_Unbounded("vision sharing", value.visionSharing);
+		SerializePlayersData()(serialize, "vision sharing", value.visionSharing);
 		serialize.NumberI8_Unbounded("owner", value.owner);
 		serialize.NumberU8_Unbounded("flags", value.flags);
 	}
@@ -370,8 +342,6 @@
 	std::vector<entity_id_t> m_SubdivisionResults;
 
 	// LOS state:
-	static const player_id_t MAX_LOS_PLAYER_ID = 16;
-
 	std::vector<bool> m_LosRevealAll;
 	bool m_LosCircular;
 	i32 m_TerrainVerticesPerSide;
@@ -380,7 +350,7 @@
 	i32 m_LosTilesPerSide;
 	bool m_GlobalVisibilityUpdate;
 	std::vector<u8> m_GlobalPlayerVisibilityUpdate;
-	std::vector<u16> m_DirtyVisibility;
+	std::vector<PlayersData> m_DirtyVisibility;
 	std::vector<std::set<entity_id_t> > m_LosTiles;
 	// List of entities that must be updated, regardless of the status of their tile
 	std::vector<entity_id_t> m_ModifiedEntities;
@@ -392,17 +362,17 @@
 	// Lazily constructed when it's needed, to save memory in smaller games.
 	std::vector<std::vector<u16> > m_LosPlayerCounts;
 
-	// 2-bit ELosState per player, starting with player 1 (not 0!) up to player MAX_LOS_PLAYER_ID (inclusive)
-	std::vector<u32> m_LosState;
+	// 2-bit ELosState per player, starting with player 1 (not 0!) up to player PlayersData::Size() (inclusive)
+	std::vector<PlayersData> m_LosState;
 
 	// Special static visibility data for the "reveal whole map" mode
 	// (TODO: this is usually a waste of memory)
-	std::vector<u32> m_LosStateRevealed;
+	std::vector<PlayersData> m_LosStateRevealed;
 
 	// Shared LOS masks, one per player.
-	std::vector<u32> m_SharedLosMasks;
+	std::vector<PlayersData> m_SharedLosMasks;
 	// Shared dirty visibility masks, one per player.
-	std::vector<u16> m_SharedDirtyVisibilityMasks;
+	std::vector<PlayersData> m_SharedDirtyVisibilityMasks;
 
 	// Cache explored vertices per player (not serialized)
 	u32 m_TotalInworldVertices;
@@ -431,13 +401,13 @@
 
 		// The whole map should be visible to Gaia by default, else e.g. animals
 		// will get confused when trying to run from enemies
-		m_LosRevealAll.resize(MAX_LOS_PLAYER_ID+2,false);
+		m_LosRevealAll.resize(OwnersData::size(),false);
 		m_LosRevealAll[0] = true;
-		m_SharedLosMasks.resize(MAX_LOS_PLAYER_ID+2,0);
-		m_SharedDirtyVisibilityMasks.resize(MAX_LOS_PLAYER_ID + 2, 0);
+		m_SharedLosMasks.resize(OwnersData::size(),PlayersData(0));
+		m_SharedDirtyVisibilityMasks.resize(OwnersData::size(), PlayersData(0));
 
 		m_GlobalVisibilityUpdate = true;
-		m_GlobalPlayerVisibilityUpdate.resize(MAX_LOS_PLAYER_ID);
+		m_GlobalPlayerVisibilityUpdate.resize(PlayersData::size());
 
 		m_LosCircular = false;
 		m_TerrainVerticesPerSide = 0;
@@ -465,16 +435,16 @@
 
 		serialize.Bool("global visibility update", m_GlobalVisibilityUpdate);
 		SerializeVector<SerializeU8_Unbounded>()(serialize, "global player visibility update", m_GlobalPlayerVisibilityUpdate);
-		SerializeRepetitiveVector<SerializeU16_Unbounded>()(serialize, "dirty visibility", m_DirtyVisibility);
+		SerializeRepetitiveVector<SerializePlayersData>()(serialize, "dirty visibility", m_DirtyVisibility);
 		SerializeVector<SerializeU32_Unbounded>()(serialize, "modified entities", m_ModifiedEntities);
 
 		// We don't serialize m_Subdivision, m_LosPlayerCounts or m_LosTiles
 		// since they can be recomputed from the entity data when deserializing;
 		// m_LosState must be serialized since it depends on the history of exploration
-
-		SerializeRepetitiveVector<SerializeU32_Unbounded>()(serialize, "los state", m_LosState);
-		SerializeVector<SerializeU32_Unbounded>()(serialize, "shared los masks", m_SharedLosMasks);
-		SerializeVector<SerializeU16_Unbounded>()(serialize, "shared dirty visibility masks", m_SharedDirtyVisibilityMasks);
+		
+		SerializeRepetitiveVector<SerializePlayersData>()(serialize, "los state", m_LosState);
+		SerializeVector<SerializePlayersData>()(serialize, "shared los masks", m_SharedLosMasks);
+		SerializeVector<SerializePlayersData>()(serialize, "shared dirty visibility masks", m_SharedDirtyVisibilityMasks);
 	}
 
 	virtual void Serialize(ISerializer& serialize)
@@ -718,14 +688,13 @@
 			if (it == m_EntityData.end())
 				break;
 
-			ENSURE(msgData.player > 0 && msgData.player < MAX_LOS_PLAYER_ID+1);
-			u16 visionChanged = CalcVisionSharingMask(msgData.player);
+			ENSURE(validPlayer(msgData.player));
 
 			if (!it->second.HasFlag<FlagMasks::SharedVision>())
 			{
 				// Activation of the Vision Sharing
 				ENSURE(it->second.owner == (i8)msgData.player);
-				it->second.visionSharing = visionChanged;
+				it->second.visionSharing.set(msgData.player,1);
 				it->second.SetFlag<FlagMasks::SharedVision>(true);
 				break;
 			}
@@ -741,9 +710,9 @@
 			}
 
 			if (msgData.add)
-				it->second.visionSharing |= visionChanged;
+				it->second.visionSharing.set(msgData.player,1);
 			else
-				it->second.visionSharing &= ~visionChanged;
+				it->second.visionSharing.set(msgData.player,0);
 			break;
 		}
 		case MT_Update:
@@ -783,7 +752,7 @@
 		// does not affect the incrementally-computed state
 
 		std::vector<std::vector<u16> > oldPlayerCounts = m_LosPlayerCounts;
-		std::vector<u32> oldStateRevealed = m_LosStateRevealed;
+		std::vector<PlayersData> oldStateRevealed = m_LosStateRevealed;
 		FastSpatialSubdivision oldSubdivision = m_Subdivision;
 		std::vector<std::set<entity_id_t> > oldLosTiles = m_LosTiles;
 
@@ -809,12 +778,12 @@
 			}
 			debug_warn(L"inconsistent player counts");
 		}
-		if (oldStateRevealed != m_LosStateRevealed)
-			debug_warn(L"inconsistent revealed");
-		if (oldSubdivision != m_Subdivision)
-			debug_warn(L"inconsistent subdivs");
-		if (oldLosTiles != m_LosTiles)
-			debug_warn(L"inconsistent los tiles");
+		//if (oldStateRevealed != m_LosStateRevealed)
+			//debug_warn(L"inconsistent revealed");
+		//if (oldSubdivision != m_Subdivision)
+			//debug_warn(L"inconsistent subdivs");
+		//if (oldLosTiles != m_LosTiles)
+			//debug_warn(L"inconsistent los tiles");
 	}
 
 	FastSpatialSubdivision* GetSubdivision()
@@ -831,17 +800,17 @@
 		m_LosTilesPerSide = (m_TerrainVerticesPerSide - 1)/LOS_TILES_RATIO;
 
 		m_LosPlayerCounts.clear();
-		m_LosPlayerCounts.resize(MAX_LOS_PLAYER_ID+1);
+		m_LosPlayerCounts.resize(PlayersData::size()+1);
 		m_ExploredVertices.clear();
-		m_ExploredVertices.resize(MAX_LOS_PLAYER_ID+1, 0);
+		m_ExploredVertices.resize(PlayersData::size()+1, 0);
 		if (m_Deserializing)
 		{
 			// recalc current exploration stats.
 			for (i32 j = 0; j < m_TerrainVerticesPerSide; j++)
 				for (i32 i = 0; i < m_TerrainVerticesPerSide; i++)
 					if (!LosIsOffWorld(i, j))
-						for (u8 k = 1; k < MAX_LOS_PLAYER_ID+1; ++k)
-							m_ExploredVertices.at(k) += ((m_LosState[j*m_TerrainVerticesPerSide + i] & (LOS_EXPLORED << (2*(k-1)))) > 0);
+						for (player_id_t k = 1; k <= PlayersData::size(); ++k)
+							m_ExploredVertices.at(k) += ((m_LosState[j*m_TerrainVerticesPerSide + i].get(k) & LOS_EXPLORED ) > 0);
 		}
 		else
 		{
@@ -854,7 +823,7 @@
 		if (!m_Deserializing)
 		{
 			m_DirtyVisibility.clear();
-			m_DirtyVisibility.resize(m_LosTilesPerSide*m_LosTilesPerSide);
+			m_DirtyVisibility.resize(m_LosTilesPerSide*m_LosTilesPerSide,PlayersData(0));
 		}
 		ENSURE(m_DirtyVisibility.size() == (size_t)(m_LosTilesPerSide*m_LosTilesPerSide));
 
@@ -879,10 +848,10 @@
 			for (ssize_t i = 0; i < m_TerrainVerticesPerSide; ++i)
 			{
 				if (LosIsOffWorld(i,j))
-					m_LosStateRevealed[i + j*m_TerrainVerticesPerSide] = 0;
+					m_LosStateRevealed[i + j*m_TerrainVerticesPerSide].fillZeros();
 				else
 				{
-					m_LosStateRevealed[i + j*m_TerrainVerticesPerSide] = 0xFFFFFFFFu;
+					m_LosStateRevealed[i + j*m_TerrainVerticesPerSide].fillOnes();
 					m_TotalInworldVertices++;
 				}
 			}
@@ -1044,33 +1013,42 @@
 
 	virtual std::vector<entity_id_t> GetEntitiesByPlayer(player_id_t player) const
 	{
-		return GetEntitiesByMask(CalcOwnerMask(player));
-	}
+		std::vector<entity_id_t> entities;
 
-	virtual std::vector<entity_id_t> GetNonGaiaEntities() const
-	{
-		return GetEntitiesByMask(~3); // bit 0 for owner=-1 and bit 1 for gaia
-	}
+		for (auto & entityMap : m_EntityData)
+		{
+			// Check owner and add to list if it matches
+			if (validPlayer(entityMap.second.owner) && entityMap.second.owner == player)
+				entities.push_back(entityMap.first);
+		}
 
-	virtual std::vector<entity_id_t> GetGaiaAndNonGaiaEntities() const
-	{
-		return GetEntitiesByMask(~1); // bit 0 for owner=-1
+		return entities;
 	}
 
-	std::vector<entity_id_t> GetEntitiesByMask(u32 ownerMask) const
+	virtual std::vector<entity_id_t> GetNonGaiaEntities() const
 	{
 		std::vector<entity_id_t> entities;
 
-		for (EntityMap<EntityData>::const_iterator it = m_EntityData.begin(); it != m_EntityData.end(); ++it)
+		for (auto & entityMap : m_EntityData)
 		{
+			u8 owner = entityMap.second.owner;
 			// Check owner and add to list if it matches
-			if (CalcOwnerMask(it->second.owner) & ownerMask)
-				entities.push_back(it->first);
+			if (validPlayer(owner))
+				entities.push_back(entityMap.first);
 		}
 
 		return entities;
 	}
 
+	virtual std::vector<entity_id_t> GetGaiaAndNonGaiaEntities() const
+	{
+		std::vector<entity_id_t> entities;
+		for (auto & entityMap : m_EntityData)
+			entities.push_back(entityMap.first);
+
+		return entities;
+	}
+
 	virtual void SetDebugOverlay(bool enabled)
 	{
 		m_DebugOverlayEnabled = enabled;
@@ -1143,7 +1121,10 @@
 	bool TestEntityQuery(const Query& q, entity_id_t id, const EntityData& entity) const
 	{
 		// Quick filter to ignore entities with the wrong owner
-		if (!(CalcOwnerMask(entity.owner) & q.ownersMask))
+		if (!validOwner(entity.owner))
+			return false;
+
+		if (!q.ownersMask.get(entity.owner))
 			return false;
 
 		// Ignore entities not present in the world
@@ -1377,11 +1358,12 @@
 		q.maxRange = maxRange;
 		q.elevationBonus = entity_pos_t::Zero();
 
-		q.ownersMask = 0;
-		for (size_t i = 0; i < owners.size(); ++i)
-			q.ownersMask |= CalcOwnerMask(owners[i]);
+		q.ownersMask.fillZeros();
+		for (const int & owner : owners)
+			if(validOwner(owner))
+				q.ownersMask.set(owner,1);
 
-		if (q.ownersMask == 0)
+		if (q.ownersMask.isZero())
 			LOGWARNING("CCmpRangeManager: No owners in query for entity %u", source);
 
 		q.interface = requiredInterface;
@@ -1570,9 +1552,9 @@
 	virtual CLosQuerier GetLosQuerier(player_id_t player) const
 	{
 		if (GetLosRevealAll(player))
-			return CLosQuerier(0xFFFFFFFFu, m_LosStateRevealed, m_TerrainVerticesPerSide);
+			return CLosQuerier(PlayersData(PlayersData::maxValue()), m_LosStateRevealed, m_TerrainVerticesPerSide);
 		else
-			return CLosQuerier(GetSharedLosMask(player), m_LosState, m_TerrainVerticesPerSide);
+			return CLosQuerier(m_SharedLosMasks[player], m_LosState, m_TerrainVerticesPerSide);
 	}
 
 	virtual void ActivateScriptedVisibility(entity_id_t ent, bool status)
@@ -1610,7 +1592,7 @@
 		}
 
 		// Get visible regions
-		CLosQuerier los(GetSharedLosMask(player), m_LosState, m_TerrainVerticesPerSide);
+		CLosQuerier los(m_SharedLosMasks[player], m_LosState, m_TerrainVerticesPerSide);
 
 		CmpPtr<ICmpVisibility> cmpVisibility(ent);
 
@@ -1739,7 +1721,7 @@
 		}
 
 		// Get visible regions
-		CLosQuerier los(GetSharedLosMask(player), m_LosState, m_TerrainVerticesPerSide);
+		CLosQuerier los(m_SharedLosMasks[player], m_LosState, m_TerrainVerticesPerSide);
 
 		if (los.IsVisible(i,j))
 			return VIS_VISIBLE;
@@ -1779,12 +1761,12 @@
 
 		for (i32 n = 0; n < m_LosTilesPerSide * m_LosTilesPerSide; ++n)
 		{
-			for (player_id_t player = 1; player < MAX_LOS_PLAYER_ID + 1; ++player)
+			for (player_id_t player = 1; player <= PlayersData::size(); ++player)
 				if (IsVisibilityDirty(m_DirtyVisibility[n], player) || m_GlobalPlayerVisibilityUpdate[player-1] == 1 || m_GlobalVisibilityUpdate)
 					for (const entity_id_t& ent : m_LosTiles[n])
 						UpdateVisibility(ent, player);
 
-			m_DirtyVisibility[n] = 0;
+			m_DirtyVisibility[n].fillZeros();
 		}
 
 		std::fill(m_GlobalPlayerVisibilityUpdate.begin(), m_GlobalPlayerVisibilityUpdate.end(), 0);
@@ -1823,7 +1805,7 @@
 		if (oldVis == newVis)
 			return;
 
-		itEnts->second.visibilities = (itEnts->second.visibilities & ~(0x3 << 2 * (player - 1))) | (newVis << 2 * (player - 1));
+		itEnts->second.visibilities.set(player,newVis);
 
 		CMessageVisibilityChanged msg(player, ent, oldVis, newVis);
 		GetSimContext().GetComponentManager().PostMessage(ent, msg);
@@ -1831,17 +1813,17 @@
 
 	void UpdateVisibility(entity_id_t ent)
 	{
-		for (player_id_t player = 1; player < MAX_LOS_PLAYER_ID + 1; ++player)
+		for (player_id_t player = 1; player <= PlayersData::size(); ++player)
 			UpdateVisibility(ent, player);
 	}
 
 	virtual void SetLosRevealAll(player_id_t player, bool enabled)
 	{
 		if (player == -1)
-			m_LosRevealAll[MAX_LOS_PLAYER_ID+1] = enabled;
+			m_LosRevealAll[PlayersData::size()] = enabled;
 		else
 		{
-			ENSURE(player >= 0 && player <= MAX_LOS_PLAYER_ID);
+			ENSURE(player >= 0 && player <= PlayersData::size());
 			m_LosRevealAll[player] = enabled;
 		}
 
@@ -1852,9 +1834,9 @@
 	virtual bool GetLosRevealAll(player_id_t player) const
 	{
 		// Special player value can force reveal-all for every player
-		if (m_LosRevealAll[MAX_LOS_PLAYER_ID+1] || player == -1)
+		if (m_LosRevealAll[PlayersData::size()] || player == -1)
 			return true;
-		ENSURE(player >= 0 && player <= MAX_LOS_PLAYER_ID+1);
+		ENSURE(player >= 0 && player <= PlayersData::size());
 		// Otherwise check the player-specific flag
 		if (m_LosRevealAll[player])
 			return true;
@@ -1884,7 +1866,7 @@
 		// 'player' needs a global visibility update for this turn.
 		bool modified = false;
 
-		for (player_id_t p = 1; p < MAX_LOS_PLAYER_ID+1; ++p)
+		for (player_id_t p = 1; p <= PlayersData::size() ; ++p)
 		{
 			bool inList = std::find(players.begin(), players.end(), p) != players.end();
 
@@ -1896,11 +1878,6 @@
 			m_GlobalPlayerVisibilityUpdate[player-1] = 1;
 	}
 
-	virtual u32 GetSharedLosMask(player_id_t player) const
-	{
-		return m_SharedLosMasks[player];
-	}
-
 	void ExploreAllTiles(player_id_t p)
 	{
 		for (u16 j = 0; j < m_TerrainVerticesPerSide; ++j)
@@ -1909,8 +1886,8 @@
 				if (LosIsOffWorld(i,j))
 					continue;
 				u32 &explored = m_ExploredVertices.at(p);
-				explored += !(m_LosState[i + j*m_TerrainVerticesPerSide] & (LOS_EXPLORED << (2*(p-1))));
-				m_LosState[i + j*m_TerrainVerticesPerSide] |= (LOS_EXPLORED << (2*(p-1)));
+				explored += !(m_LosState[i + j*m_TerrainVerticesPerSide].get(p) & LOS_EXPLORED);
+				m_LosState[i + j*m_TerrainVerticesPerSide].set(p,LOS_EXPLORED);
 			}
 
 		SeeExploredEntities(p);
@@ -1942,7 +1919,7 @@
 			for (u16 i = 0; i < grid.m_W; ++i)
 			{
 				u8 p = grid.get(i, j) & ICmpTerritoryManager::TERRITORY_PLAYER_MASK;
-				if (p > 0 && p <= MAX_LOS_PLAYER_ID)
+				if (p > 0 && p <= PlayersData::size())
 				{
 					u32& explored = m_ExploredVertices.at(p);
 					for (int tj = j * scale; tj <= (j+1) * scale; ++tj)
@@ -1951,17 +1928,17 @@
 							if (LosIsOffWorld(ti, tj))
 								continue;
 
-							u32& losState = m_LosState[ti + tj * m_TerrainVerticesPerSide];
-							if (!(losState & (LOS_EXPLORED << (2*(p-1)))))
+							size_t d = ti + tj * m_TerrainVerticesPerSide;
+							if (!(m_LosState[d].get(p) & LOS_EXPLORED))
 							{
 								++explored;
-								losState |= (LOS_EXPLORED << (2*(p-1)));
+								m_LosState[d].set(p,LOS_EXPLORED);
 							}
 						}
 				}
 			}
 
-		for (player_id_t p = 1; p < MAX_LOS_PLAYER_ID+1; ++p)
+		for (player_id_t p = 1; p <= PlayersData::size(); ++p)
 			SeeExploredEntities(p);
 	}
 
@@ -1989,7 +1966,7 @@
 			int i = (pos.X / (int)TERRAIN_TILE_SIZE).ToInt_RoundToNearest();
 			int j = (pos.Y / (int)TERRAIN_TILE_SIZE).ToInt_RoundToNearest();
 
-			CLosQuerier los(GetSharedLosMask(p), m_LosState, m_TerrainVerticesPerSide);
+			CLosQuerier los(m_SharedLosMasks[p], m_LosState, m_TerrainVerticesPerSide);
 			if (!los.IsExplored(i,j) || los.IsVisible(i,j))
 				continue;
 
@@ -2008,7 +1985,7 @@
 
 	virtual void RevealShore(player_id_t p, bool enable)
 	{
-		if (p <= 0 || p > MAX_LOS_PLAYER_ID)
+		if (!validPlayer(p))
 			return;
 
 		// Maximum distance to the shore
@@ -2085,8 +2062,8 @@
 				i32 i = i0 + idx - idx0;
 				if (!LosIsOffWorld(i, j))
 				{
-					explored += !(m_LosState[idx] & (LOS_EXPLORED << (2*(owner-1))));
-					m_LosState[idx] |= ((LOS_VISIBLE | LOS_EXPLORED) << (2*(owner-1)));
+					explored += !(m_LosState[idx].get(owner) & LOS_EXPLORED);
+					m_LosState[idx].set(owner,LOS_VISIBLE | LOS_EXPLORED);
 				}
 
 				MarkVisibilityDirtyAroundTile(owner, i, j);
@@ -2116,7 +2093,7 @@
 			if (counts[idx] == 0)
 			{
 				// (If LosIsOffWorld then this is a no-op, so don't bother doing the check)
-				m_LosState[idx] &= ~(LOS_VISIBLE << (2*(owner-1)));
+				m_LosState[idx].set(owner, m_LosState[idx].get(owner) & (~LOS_VISIBLE));
 
 				i32 i = i0 + idx - idx0;
 				MarkVisibilityDirtyAroundTile(owner, i, j);
@@ -2137,16 +2114,16 @@
 		int n3 = (j/LOS_TILES_RATIO)*m_LosTilesPerSide + (i-1)/LOS_TILES_RATIO;
 		int n4 = (j/LOS_TILES_RATIO)*m_LosTilesPerSide + i/LOS_TILES_RATIO;
 
-		u16 sharedDirtyVisibilityMask = m_SharedDirtyVisibilityMasks[owner];
+		PlayersData sharedDirtyVisibilityMask = m_SharedDirtyVisibilityMasks[owner];
 
 		if (j > 0 && i > 0)
-			m_DirtyVisibility[n1] |= sharedDirtyVisibilityMask;
+			m_DirtyVisibility[n1].setBitwiseOr(sharedDirtyVisibilityMask);
 		if (n2 != n1 && j > 0 && i < m_TerrainVerticesPerSide)
-			m_DirtyVisibility[n2] |= sharedDirtyVisibilityMask;
+			m_DirtyVisibility[n2].setBitwiseOr(sharedDirtyVisibilityMask);
 		if (n3 != n1 && j < m_TerrainVerticesPerSide && i > 0)
-			m_DirtyVisibility[n3] |= sharedDirtyVisibilityMask;
+			m_DirtyVisibility[n3].setBitwiseOr(sharedDirtyVisibilityMask);
 		if (n4 != n1 && j < m_TerrainVerticesPerSide && i < m_TerrainVerticesPerSide)
-			m_DirtyVisibility[n4] |= sharedDirtyVisibilityMask;
+			m_DirtyVisibility[n4].setBitwiseOr(sharedDirtyVisibilityMask);
 	}
 
 	/**
@@ -2371,43 +2348,43 @@
 
 	void LosAdd(player_id_t owner, entity_pos_t visionRange, CFixedVector2D pos)
 	{
-		if (visionRange.IsZero() || owner <= 0 || owner > MAX_LOS_PLAYER_ID)
+		if (visionRange.IsZero() || !validPlayer(owner))
 			return;
 
 		LosUpdateHelper<true>((u8)owner, visionRange, pos);
 	}
 
-	void SharingLosAdd(u16 visionSharing, entity_pos_t visionRange, CFixedVector2D pos)
+	void SharingLosAdd(PlayersData visionSharing, entity_pos_t visionRange, CFixedVector2D pos)
 	{
 		if (visionRange.IsZero())
 			return;
 
-		for (player_id_t i = 1; i < MAX_LOS_PLAYER_ID+1; ++i)
-			if (HasVisionSharing(visionSharing, i))
+		for (player_id_t i = 1; i <= PlayersData::size(); ++i)
+			if (visionSharing.get(i))
 				LosAdd(i, visionRange, pos);
 	}
 
 	void LosRemove(player_id_t owner, entity_pos_t visionRange, CFixedVector2D pos)
 	{
-		if (visionRange.IsZero() || owner <= 0 || owner > MAX_LOS_PLAYER_ID)
+		if (visionRange.IsZero() || !validPlayer(owner))
 			return;
 
 		LosUpdateHelper<false>((u8)owner, visionRange, pos);
 	}
 
-	void SharingLosRemove(u16 visionSharing, entity_pos_t visionRange, CFixedVector2D pos)
+	void SharingLosRemove(PlayersData visionSharing, entity_pos_t visionRange, CFixedVector2D pos)
 	{
 		if (visionRange.IsZero())
 			return;
 
-		for (player_id_t i = 1; i < MAX_LOS_PLAYER_ID+1; ++i)
-			if (HasVisionSharing(visionSharing, i))
+		for (player_id_t i = 1; i <= PlayersData::size(); ++i)
+			if (visionSharing.get(i))
 				LosRemove(i, visionRange, pos);
 	}
 
 	void LosMove(player_id_t owner, entity_pos_t visionRange, CFixedVector2D from, CFixedVector2D to)
 	{
-		if (visionRange.IsZero() || owner <= 0 || owner > MAX_LOS_PLAYER_ID)
+		if (visionRange.IsZero() || !validPlayer(owner))
 			return;
 
 		if ((from - to).CompareLength(visionRange) > 0)
@@ -2421,13 +2398,13 @@
 			LosUpdateHelperIncremental((u8)owner, visionRange, from, to);
 	}
 
-	void SharingLosMove(u16 visionSharing, entity_pos_t visionRange, CFixedVector2D from, CFixedVector2D to)
+	void SharingLosMove(PlayersData visionSharing, entity_pos_t visionRange, CFixedVector2D from, CFixedVector2D to)
 	{
 		if (visionRange.IsZero())
 			return;
 
-		for (player_id_t i = 1; i < MAX_LOS_PLAYER_ID+1; ++i)
-			if (HasVisionSharing(visionSharing, i))
+		for (player_id_t i = 1; i <= PlayersData::size(); ++i)
+			if (visionSharing.get(i))
 				LosMove(i, visionRange, from, to);
 	}
 
@@ -2447,8 +2424,8 @@
 				if (LosIsOffWorld(i, j))
 					continue;
 
-				for (playerIt = players.begin(); playerIt != players.end(); ++playerIt)
-					if (m_LosState[j*m_TerrainVerticesPerSide + i] & (LOS_EXPLORED << (2*((*playerIt)-1))))
+				for (auto & player: players)
+					if (m_LosState[j*m_TerrainVerticesPerSide + i].get(player) & LOS_EXPLORED)
 					{
 						exploredVertices += 1;
 						break;
Index: source/simulation2/components/ICmpRangeManager.h
===================================================================
--- source/simulation2/components/ICmpRangeManager.h
+++ source/simulation2/components/ICmpRangeManager.h
@@ -24,6 +24,7 @@
 #include "simulation2/system/Interface.h"
 #include "simulation2/helpers/Position.h"
 #include "simulation2/helpers/Player.h"
+#include "simulation2/helpers/ArrayData.h"
 
 #include "graphics/Terrain.h" // for TERRAIN_TILE_SIZE
 
@@ -250,8 +251,8 @@
 		friend class CCmpRangeManager;
 		friend class TestLOSTexture;
 
-		CLosQuerier(u32 playerMask, const std::vector<u32>& data, ssize_t verticesPerSide) :
-			m_Data(&data[0]), m_PlayerMask(playerMask), m_VerticesPerSide(verticesPerSide)
+		CLosQuerier(PlayersData playerMask, const std::vector<PlayersData>& data, ssize_t verticesPerSide) :
+			m_Data(data), m_PlayerMask(playerMask), m_VerticesPerSide(verticesPerSide)
 		{
 		}
 
@@ -266,11 +267,8 @@
 			if (!(i >= 0 && j >= 0 && i < m_VerticesPerSide && j < m_VerticesPerSide))
 				return false;
 
-			// Check high bit of each bit-pair
-			if ((m_Data[j*m_VerticesPerSide + i] & m_PlayerMask) & 0xAAAAAAAAu)
-				return true;
-			else
-				return false;
+			// 2 bit mask VIS_VISIBLE left shift repeated 32 times
+			return m_Data[j*m_VerticesPerSide + i].andExpandedMask(m_PlayerMask, 0xAAAAAAAAAAAAAAAAu);
 		}
 
 		/**
@@ -281,11 +279,8 @@
 			if (!(i >= 0 && j >= 0 && i < m_VerticesPerSide && j < m_VerticesPerSide))
 				return false;
 
-			// Check low bit of each bit-pair
-			if ((m_Data[j*m_VerticesPerSide + i] & m_PlayerMask) & 0x55555555u)
-				return true;
-			else
-				return false;
+			// 2 bit mask VIS_FOGGED left shift repeated 32 times
+			return m_Data[j*m_VerticesPerSide + i].andExpandedMask(m_PlayerMask, 0x5555555555555555u);
 		}
 
 		/**
@@ -297,11 +292,8 @@
 #ifndef NDEBUG
 			ENSURE(i >= 0 && j >= 0 && i < m_VerticesPerSide && j < m_VerticesPerSide);
 #endif
-			// Check high bit of each bit-pair
-			if ((m_Data[j*m_VerticesPerSide + i] & m_PlayerMask) & 0xAAAAAAAAu)
-				return true;
-			else
-				return false;
+			// 2 bit mask VIS_VISIBLE left shift repeated 32 times
+			return m_Data[j*m_VerticesPerSide + i].andExpandedMask(m_PlayerMask, 0xAAAAAAAAAAAAAAAAu);
 		}
 
 		/**
@@ -313,16 +305,13 @@
 #ifndef NDEBUG
 			ENSURE(i >= 0 && j >= 0 && i < m_VerticesPerSide && j < m_VerticesPerSide);
 #endif
-			// Check low bit of each bit-pair
-			if ((m_Data[j*m_VerticesPerSide + i] & m_PlayerMask) & 0x55555555u)
-				return true;
-			else
-				return false;
+			// 2 bit mask VIS_FOGGED left shift repeated 32 times
+			return m_Data[j*m_VerticesPerSide + i].andExpandedMask(m_PlayerMask, 0x5555555555555555u);
 		}
 
 	private:
-		u32 m_PlayerMask;
-		const u32* m_Data;
+		PlayersData m_PlayerMask;
+		const std::vector<PlayersData>& m_Data;
 		ssize_t m_VerticesPerSide;
 	};
 
@@ -416,11 +405,6 @@
 	virtual void SetSharedLos(player_id_t player, const std::vector<player_id_t>& players) = 0;
 
 	/**
-	 * Returns shared LOS mask for player.
-	 */
-	virtual u32 GetSharedLosMask(player_id_t player) const = 0;
-
-	/**
 	 * Get percent map explored statistics for specified player.
 	 */
 	virtual u8 GetPercentMapExplored(player_id_t player) const = 0;
Index: source/simulation2/helpers/ArrayData.h
===================================================================
--- /dev/null
+++ source/simulation2/helpers/ArrayData.h
@@ -0,0 +1,63 @@
+#ifndef ARRAYDATA
+#define ARRAYDATA
+
+#include "simulation2/serialization/SerializeTemplates.h"
+
+#include <boost/unordered_map.hpp>
+
+#include <vector>
+#include <limits>
+
+void Simulation_SetNumberOfPlayersReadOnly(bool readOnly);
+size_t Simulation_GetNumberOfPlayers();
+void Simulation_SetNumberOfPlayers(size_t number);
+
+template <size_t extra>
+class ArrayData
+{
+public:
+	ArrayData();
+	ArrayData(u64 value);
+	ArrayData(std::vector<u8> vector);
+
+	static size_t size();
+	constexpr static u64 maxValue(){ return std::numeric_limits<u64>::max(); }
+	
+	u8 get(size_t i) const;
+	void set(size_t i, u8 v);
+	void fill(u64 value);
+	void fillZeros();
+	void fillOnes();
+	bool isZero() const;
+	bool andExpandedMask(const ArrayData<extra>& second, u64 expandedMask) const;
+	void setBitwiseOr(const ArrayData<extra> & second);
+	const bool isEqual(const ArrayData<extra> & second) const;
+
+	bool operator==(const ArrayData<extra> & second) const;
+
+	template <size_t extra>
+	friend struct SerializeArrayData;
+
+private:
+	size_t sizeInternal() const;
+	u8 getInternal(size_t i) const;
+	void setInternal(size_t i, u16 v);
+	int index(int i) const;
+
+	u64 m_data;
+};
+
+template <size_t extra>
+struct SerializeArrayData
+{
+	void operator()(ISerializer& serialize, const char* name, ArrayData<extra>& value);
+	void operator()(IDeserializer& deserialize, const char* name, ArrayData<extra>& value);
+};
+
+using PlayersData = ArrayData<0>;
+using OwnersData = ArrayData<2>;
+
+using SerializePlayersData = SerializeArrayData<0>;
+using SerializeOwnersData = SerializeArrayData<2>;
+
+#endif // ARRAYDATA
Index: source/simulation2/helpers/ArrayData.cpp
===================================================================
--- /dev/null
+++ source/simulation2/helpers/ArrayData.cpp
@@ -0,0 +1,136 @@
+#include "precompiled.h"
+
+#include "ArrayData.h"
+
+static size_t count = 8;
+static bool countIsReadOnly = true;
+
+void Simulation_SetNumberOfPlayersReadOnly(bool readOnly){ countIsReadOnly  = readOnly; }
+size_t Simulation_GetNumberOfPlayers(){ return count; }
+void Simulation_SetNumberOfPlayers(size_t number)
+{
+	WARN_IF_FALSE(number <= 30);
+
+	if(!countIsReadOnly)
+		count = number;
+}
+
+template <size_t extra>
+ArrayData<extra>::ArrayData()
+{	
+	fillZeros();
+}
+
+template <size_t extra>
+ArrayData<extra>::ArrayData(u64 value)
+{
+	m_data = value;
+}
+
+template <size_t extra>
+ArrayData<extra>::ArrayData(std::vector<u8> vector)
+{
+	m_data = 0;
+	for(size_t i = 0; i < vector.size() && i < size(); i++)
+		setInternal(i,vector[i]);
+}
+
+template <size_t extra>
+size_t ArrayData<extra>::size(){	return count + extra;}
+
+template <size_t extra>
+u8 ArrayData<extra>::get(size_t i) const{	return getInternal(index(i));}
+
+template <size_t extra>
+void ArrayData<extra>::set(size_t i, u8 v){	setInternal(index(i),v);}
+
+template <size_t extra>
+void ArrayData<extra>::fill(u64 value)
+{	
+	m_data = 0;
+	for(size_t i = 0 ; i < 64; i+=2)
+		m_data |= (value & 0x3) << i;
+}
+
+template <size_t extra>
+void ArrayData<extra>::fillZeros()
+{	
+	m_data = 0;
+}
+
+template <size_t extra>
+void ArrayData<extra>::fillOnes()
+{	
+	m_data = std::numeric_limits<u64>::max();
+}
+
+template <size_t extra>
+bool ArrayData<extra>::isZero() const
+{
+	return m_data == 0;
+}
+
+template <size_t extra>
+bool ArrayData<extra>::andExpandedMask(const ArrayData<extra> & second, u64 expandedMask) const
+{
+	return m_data & second.m_data & expandedMask;
+}
+
+template <size_t extra>
+void ArrayData<extra>::setBitwiseOr(const ArrayData<extra> & second)
+{	
+	m_data |= second.m_data;
+}
+
+template <size_t extra>
+const bool ArrayData<extra>::isEqual(const ArrayData<extra> & second) const
+{
+	return m_data == second.m_data;
+}
+
+template <size_t extra>
+bool ArrayData<extra>::operator==(const ArrayData<extra> & second) const
+{
+	return m_data == second.m_data;
+}
+
+template <size_t extra>
+size_t ArrayData<extra>::sizeInternal() const
+{
+	return 64;
+}
+
+template <size_t extra>
+u8 ArrayData<extra>::getInternal(size_t i) const 
+{ 
+	return (m_data >> (2*i)) & 0x3;
+}
+
+template <size_t extra>
+void ArrayData<extra>::setInternal(size_t i, u16 v) 
+{ 
+	m_data = (m_data & ~(0x3 << 2*i)) | (u64(v & 0x3) << 2*i);
+}
+
+template <>
+int ArrayData<0>::index(int i) const { return i - 1; }
+
+template <>
+int ArrayData<2>::index(int i) const { return i + 1; }
+
+template <size_t extra>
+void SerializeArrayData<extra>::operator()(ISerializer& serialize, const char* name, ArrayData<extra>& value)
+{
+	SerializeU64_Unbounded()(serialize, name, value.m_data);
+}
+
+template <size_t extra>
+void SerializeArrayData<extra>::operator()(IDeserializer& deserialize, const char* name, ArrayData<extra>& value)
+{
+	SerializeU64_Unbounded()(deserialize, name, value.m_data);
+}
+
+template class ArrayData<0>;
+template class ArrayData<2>;
+template struct SerializeArrayData<0>;
+template struct SerializeArrayData<2>;
Index: source/simulation2/serialization/BinarySerializer.h
===================================================================
--- source/simulation2/serialization/BinarySerializer.h
+++ source/simulation2/serialization/BinarySerializer.h
@@ -178,6 +178,12 @@
 		m_Impl.Put(name, (const u8*)&v, sizeof(int32_t));
 	}
 
+	virtual void PutNumber(const char* name, uint64_t value)
+	{
+		uint64_t v = to_le64(value);
+		m_Impl.Put(name, (const u8*)&v, sizeof(uint64_t));
+	}
+
 	virtual void PutNumber(const char* name, float value)
 	{
 		m_Impl.Put(name, (const u8*)&value, sizeof(float));
Index: source/simulation2/serialization/IDeserializer.h
===================================================================
--- source/simulation2/serialization/IDeserializer.h
+++ source/simulation2/serialization/IDeserializer.h
@@ -48,6 +48,7 @@
 	virtual void NumberI16_Unbounded(const char* name, int16_t& out);
 	virtual void NumberU32_Unbounded(const char* name, uint32_t& out);
 	virtual void NumberI32_Unbounded(const char* name, int32_t& out);
+	virtual void NumberU64_Unbounded(const char * name, uint64_t & out);
 	virtual void NumberFloat_Unbounded(const char* name, float& out);
 	virtual void NumberDouble_Unbounded(const char* name, double& out);
 	virtual void NumberFixed_Unbounded(const char* name, fixed& out);
Index: source/simulation2/serialization/IDeserializer.cpp
===================================================================
--- source/simulation2/serialization/IDeserializer.cpp
+++ source/simulation2/serialization/IDeserializer.cpp
@@ -135,6 +135,13 @@
 	out = (i32)to_le32((u32)value);
 }
 
+void IDeserializer::NumberU64_Unbounded(const char* name, uint64_t& out)
+{
+	uint64_t value;
+	Get(name, (u8*)&value, sizeof(uint64_t));
+	out = to_le32(value);
+}
+
 void IDeserializer::NumberFloat_Unbounded(const char* name, float& out)
 {
 	Get(name, (u8*)&out, sizeof(float));
Index: source/simulation2/serialization/ISerializer.h
===================================================================
--- source/simulation2/serialization/ISerializer.h
+++ source/simulation2/serialization/ISerializer.h
@@ -178,6 +178,11 @@
 		PutNumber(name, value);
 	}
 
+	void NumberU64_Unbounded(const char* name, uint32_t value) ///@copydoc NumberU8_Unbounded()
+	{
+		PutNumber(name, value);
+	}
+
 	void NumberFloat_Unbounded(const char* name, float value) ///@copydoc NumberU8_Unbounded()
 	{
 		PutNumber(name, value);
Index: source/simulation2/serialization/SerializeTemplates.h
===================================================================
--- source/simulation2/serialization/SerializeTemplates.h
+++ source/simulation2/serialization/SerializeTemplates.h
@@ -281,6 +281,19 @@
 	}
 };
 
+struct SerializeU64_Unbounded
+{
+	void operator()(ISerializer& serialize, const char* name, u64 value)
+	{
+		serialize.NumberU64_Unbounded(name, value);
+	}
+
+	void operator()(IDeserializer& deserialize, const char* name, u64& value)
+	{
+		deserialize.NumberU64_Unbounded(name, value);
+	}
+};
+
 struct SerializeBool
 {
 	void operator()(ISerializer& serialize, const char* name, bool value)