Changeset 10017 for ps

Timestamp:

08/16/11 13:18:32 (13 years ago)

Author:

philip

Message:

Fix -Wconversion warnings in simulation code.
Cast to smaller integer types explicitly.
Generally avoid platform-dependent types (size_t) in simulation code.
Use float versions of math.h functions, not double.

Location:

ps/trunk/source

Files:

• graphics/ShaderProgram.h (modified) (1 diff)
• lib/os_path.h (modified) (1 diff)
• lib/timer.h (modified) (2 diffs)
• maths/Fixed.h (modified) (1 diff)
• ps/Overlay.h (modified) (1 diff)
• ps/utf16string.h (modified) (1 diff)
• simulation2/components/CCmpAIManager.cpp (modified) (5 diffs)
• simulation2/components/CCmpFootprint.cpp (modified) (3 diffs)
• simulation2/components/CCmpMinimap.cpp (modified) (2 diffs)
• simulation2/components/CCmpMotionBall.cpp (modified) (2 diffs)
• simulation2/components/CCmpObstruction.cpp (modified) (9 diffs)
• simulation2/components/CCmpObstructionManager.cpp (modified) (13 diffs)
• simulation2/components/CCmpPathfinder.cpp (modified) (15 diffs)
• simulation2/components/CCmpPathfinder_Common.h (modified) (2 diffs)
• simulation2/components/CCmpPathfinder_Tile.cpp (modified) (4 diffs)
• simulation2/components/CCmpPathfinder_Vertex.cpp (modified) (8 diffs)
• simulation2/components/CCmpPosition.cpp (modified) (1 diff)
• simulation2/components/CCmpProjectileManager.cpp (modified) (3 diffs)
• simulation2/components/CCmpRangeManager.cpp (modified) (12 diffs)
• simulation2/components/CCmpTerrain.cpp (modified) (3 diffs)
• simulation2/components/CCmpTerritoryInfluence.cpp (modified) (2 diffs)
• simulation2/components/CCmpTerritoryManager.cpp (modified) (19 diffs)
• simulation2/components/CCmpUnitMotion.cpp (modified) (1 diff)
• simulation2/components/CCmpVisualActor.cpp (modified) (1 diff)
• simulation2/components/ICmpObstructionManager.h (modified) (10 diffs)
• simulation2/components/ICmpTerrain.h (modified) (2 diffs)
• simulation2/components/ICmpTerritoryInfluence.h (modified) (1 diff)
• simulation2/helpers/Grid.h (modified) (4 diffs)
• simulation2/helpers/Render.cpp (modified) (3 diffs)
• simulation2/helpers/Spatial.h (modified) (5 diffs)
• simulation2/scripting/EngineScriptConversions.cpp (modified) (1 diff)
• simulation2/serialization/DebugSerializer.cpp (modified) (1 diff)
• simulation2/system/ComponentTest.h (modified) (2 diffs)
• sound/SoundGroup.h (modified) (1 diff)

ps/trunk/source/graphics/ShaderProgram.h

@@ -64 +64 @@
         friend class CShaderProgramARB;
     private:
-        Binding(int v, int f) : vertex(v), fragment(f) { }
+        Binding(int v, int f) : vertex((i16)v), fragment((i16)f) { }
         i16 vertex;
         i16 fragment;

ps/trunk/source/lib/os_path.h

@@ -47 +47 @@
     {
         ENSURE(wstring[i] <= UCHAR_MAX);
-        string[i] = wstring[i];
+        string[i] = (char)wstring[i];
     }
     return string;

ps/trunk/source/lib/timer.h

@@ -200 +200 @@
     std::wstring ToString() const
     {
-        ENSURE(m_cycles >= 0.0);
+        ENSURE(m_cycles >= 0);
         return StringForCycles(m_cycles);
     }
@@ -206 +206 @@
     double ToSeconds() const
     {
-        return m_cycles / os_cpu_ClockFrequency();
+        return (double)m_cycles / os_cpu_ClockFrequency();
     }
 

ps/trunk/source/maths/Fixed.h

@@ -149 +149 @@
     static CFixed FromString(const CStrW& s);
 
+    /// Convert to float. May be lossy - float can't represent all values.
     float ToFloat() const
     {
-        return value / (float)fract_pow2;
-    }
-
+        return (float)value / (float)fract_pow2;
+    }
+
+    /// Convert to double. Won't be lossy - double can precisely represent all values.
     double ToDouble() const
     {

ps/trunk/source/ps/Overlay.h

@@ -52 +52 @@
     SColor4ub AsSColor4ub() const
     {
-        return SColor4ub((int)(r*255.0), (int)(g*255.0), (int)(b*255.0), (int)(a*255.0));
+        return SColor4ub((u8)(r*255.0), (u8)(g*255.0), (u8)(b*255.0), (u8)(a*255.0));
     }
 

ps/trunk/source/ps/utf16string.h

@@ -62 +62 @@
         const char_type* end=s;
         while (*end) end++;
-        return end-s;
+        return (size_t)(end-s);
     }
 

ps/trunk/source/simulation2/components/CCmpAIManager.cpp

@@ -142 +142 @@
             u8* img = buf.get() + hdr_size;
             for (size_t i = 0; i < data.size(); ++i)
-                img[i] = (data[i] * 255) / max;
+                img[i] = (u8)((data[i] * 255) / max);
 
             tex_write(&t, filename);
@@ -360 +360 @@
     void SerializeState(ISerializer& serializer)
     {
-        serializer.NumberU32_Unbounded("num ais", m_Players.size());
+        serializer.NumberU32_Unbounded("num ais", (u32)m_Players.size());
 
         for (size_t i = 0; i < m_Players.size(); ++i)
@@ -368 +368 @@
             serializer.ScriptVal("data", m_Players[i]->m_Obj);
 
-            serializer.NumberU32_Unbounded("num commands", m_Players[i]->m_Commands.size());
+            serializer.NumberU32_Unbounded("num commands", (u32)m_Players[i]->m_Commands.size());
             for (size_t j = 0; j < m_Players[i]->m_Commands.size(); ++j)
             {
@@ -528 +528 @@
             const CMessageProgressiveLoad& msgData = static_cast<const CMessageProgressiveLoad&> (msg);
 
-            *msgData.total += m_TemplateNames.size();
+            *msgData.total += (int)m_TemplateNames.size();
 
             if (*msgData.progressed)
@@ -536 +536 @@
                 *msgData.progressed = true;
 
-            *msgData.progress += m_TemplateLoadedIdx;
+            *msgData.progress += (int)m_TemplateLoadedIdx;
 
             break;

ps/trunk/source/simulation2/components/CCmpFootprint.cpp

@@ -164 +164 @@
 
         // Max spawning distance in tiles
-        const size_t maxSpawningDistance = 4;
+        const i32 maxSpawningDistance = 4;
 
         if (m_Shape == CIRCLE)
         {
             // Expand outwards from foundation
-            for (size_t dist = 0; dist <= maxSpawningDistance; ++dist)
+            for (i32 dist = 0; dist <= maxSpawningDistance; ++dist)
             {
                 // The spawn point should be far enough from this footprint to fit the unit, plus a little gap
-                entity_pos_t clearance = spawnedRadius + entity_pos_t::FromInt(2 + CELL_SIZE*dist);
+                entity_pos_t clearance = spawnedRadius + entity_pos_t::FromInt(2 + (int)CELL_SIZE*dist);
                 entity_pos_t radius = m_Size0 + clearance;
 
                 // Try equally-spaced points around the circle in alternating directions, starting from the front
-                const ssize_t numPoints = 31 + 2*dist;
-                for (ssize_t i = 0; i < (numPoints+1)/2; i = (i > 0 ? -i : 1-i)) // [0, +1, -1, +2, -2, ... (np-1)/2, -(np-1)/2]
+                const i32 numPoints = 31 + 2*dist;
+                for (i32 i = 0; i < (numPoints+1)/2; i = (i > 0 ? -i : 1-i)) // [0, +1, -1, +2, -2, ... (np-1)/2, -(np-1)/2]
                 {
                     entity_angle_t angle = initialAngle + (entity_angle_t::Pi()*2).Multiply(entity_angle_t::FromInt(i)/(int)numPoints);
@@ -198 +198 @@
 
             // Expand outwards from foundation
-            for (size_t dist = 0; dist <= maxSpawningDistance; ++dist)
+            for (i32 dist = 0; dist <= maxSpawningDistance; ++dist)
             {
                 // The spawn point should be far enough from this footprint to fit the unit, plus a little gap
-                entity_pos_t clearance = spawnedRadius + entity_pos_t::FromInt(2 + CELL_SIZE*dist);
-
-                for (size_t edge = 0; edge < 4; ++edge)
+                entity_pos_t clearance = spawnedRadius + entity_pos_t::FromInt(2 + (int)CELL_SIZE*dist);
+
+                for (i32 edge = 0; edge < 4; ++edge)
                 {
                     // Try equally-spaced points along the edge in alternating directions, starting from the middle
-                    const ssize_t numPoints = 9 + 2*dist;
+                    const i32 numPoints = 9 + 2*dist;
 
                     // Compute the direction and length of the current edge
@@ -237 +237 @@
                     dir = dir.Multiply((sx + clearance*2) / (int)(numPoints-1));
 
-                    for (ssize_t i = 0; i < (numPoints+1)/2; i = (i > 0 ? -i : 1-i)) // [0, +1, -1, +2, -2, ... (np-1)/2, -(np-1)/2]
+                    for (i32 i = 0; i < (numPoints+1)/2; i = (i > 0 ? -i : 1-i)) // [0, +1, -1, +2, -2, ... (np-1)/2, -(np-1)/2]
                     {
                         CFixedVector2D pos (center + dir*i);

ps/trunk/source/simulation2/components/CCmpMinimap.cpp

@@ -88 +88 @@
         {
             m_UsePlayerColour = false;
-            m_R = colour.GetChild("@r").ToInt();
-            m_G = colour.GetChild("@g").ToInt();
-            m_B = colour.GetChild("@b").ToInt();
+            m_R = (u8)colour.GetChild("@r").ToInt();
+            m_G = (u8)colour.GetChild("@g").ToInt();
+            m_B = (u8)colour.GetChild("@b").ToInt();
         }
         else
@@ -177 +177 @@
                 break;
             CColor colour = cmpPlayer->GetColour();
-            m_R = (int)(colour.r*255.0);
-            m_G = (int)(colour.g*255.0);
-            m_B = (int)(colour.b*255.0);
+            m_R = (u8)(colour.r*255.0);
+            m_G = (u8)(colour.g*255.0);
+            m_B = (u8)(colour.b*255.0);
+            // TODO: probably should avoid using floating-point here
 
             break;

ps/trunk/source/simulation2/components/CCmpMotionBall.cpp

@@ -95 +95 @@
     float z = pos.Z.ToFloat();
 
-    CVector3D normal;
-    GetSimContext().GetTerrain().CalcNormal(x / CELL_SIZE, z / CELL_SIZE, normal);
+    CVector3D normal = GetSimContext().GetTerrain().CalcExactNormal(x, z);
     // Flatten the vector, to get the downhill force
     float g = 10.f;
@@ -108 +107 @@
     float dt_ = dt.ToFloat();
 
-    m_SpeedX *= pow(drag, dt_);
-    m_SpeedZ *= pow(drag, dt_);
+    m_SpeedX *= powf(drag, dt_);
+    m_SpeedZ *= powf(drag, dt_);
 
     cmpPosition->MoveTo(entity_pos_t::FromFloat(x + m_SpeedX * dt_), entity_pos_t::FromFloat(z + m_SpeedZ * dt_));

ps/trunk/source/simulation2/components/CCmpObstruction.cpp

@@ -41 +41 @@
     DEFAULT_COMPONENT_ALLOCATOR(Obstruction)
 
+    typedef ICmpObstructionManager::tag_t tag_t;
+    typedef ICmpObstructionManager::flags_t flags_t;
+
     // Template state:
 
@@ -49 +52 @@
     entity_pos_t m_Size0; // radius or width
     entity_pos_t m_Size1; // radius or depth
-    u8 m_TemplateFlags;
+    flags_t m_TemplateFlags;
 
     // Dynamic state:
@@ -56 +59 @@
     bool m_Moving;
     entity_id_t m_ControlGroup;
-    ICmpObstructionManager::tag_t m_Tag;
-    u8 m_Flags;
+    tag_t m_Tag;
+    flags_t m_Flags;
 
     static std::string GetSchema()
@@ -128 +131 @@
         m_Flags = m_TemplateFlags;
         if (paramNode.GetChild("DisableBlockMovement").ToBool())
-            m_Flags &= ~ICmpObstructionManager::FLAG_BLOCK_MOVEMENT;
+            m_Flags &= (flags_t)(~ICmpObstructionManager::FLAG_BLOCK_MOVEMENT);
         if (paramNode.GetChild("DisableBlockPathfinding").ToBool())
-            m_Flags &= ~ICmpObstructionManager::FLAG_BLOCK_PATHFINDING;
+            m_Flags &= (flags_t)(~ICmpObstructionManager::FLAG_BLOCK_PATHFINDING);
 
         m_Active = paramNode.GetChild("Active").ToBool();
 
-        m_Tag = ICmpObstructionManager::tag_t();
+        m_Tag = tag_t();
         m_Moving = false;
         m_ControlGroup = GetEntityId();
@@ -195 +198 @@
                 else
                     m_Tag = cmpObstructionManager->AddUnitShape(GetEntityId(),
-                        data.x, data.z, m_Size0, m_Flags | (m_Moving ? ICmpObstructionManager::FLAG_MOVING : 0), m_ControlGroup);
+                        data.x, data.z, m_Size0, (flags_t)(m_Flags | (m_Moving ? ICmpObstructionManager::FLAG_MOVING : 0)), m_ControlGroup);
             }
             else if (!data.inWorld && m_Tag.valid())
             {
                 cmpObstructionManager->RemoveShape(m_Tag);
-                m_Tag = ICmpObstructionManager::tag_t();
+                m_Tag = tag_t();
             }
             break;
@@ -213 +216 @@
 
                 cmpObstructionManager->RemoveShape(m_Tag);
-                m_Tag = ICmpObstructionManager::tag_t();
+                m_Tag = tag_t();
             }
             break;
@@ -245 +248 @@
             else
                 m_Tag = cmpObstructionManager->AddUnitShape(GetEntityId(),
-                    pos.X, pos.Y, m_Size0, m_Flags | (m_Moving ? ICmpObstructionManager::FLAG_MOVING : 0), m_ControlGroup);
+                    pos.X, pos.Y, m_Size0, (flags_t)(m_Flags | (m_Moving ? ICmpObstructionManager::FLAG_MOVING : 0)), m_ControlGroup);
         }
         else if (!active && m_Active)
@@ -260 +263 @@
 
                 cmpObstructionManager->RemoveShape(m_Tag);
-                m_Tag = ICmpObstructionManager::tag_t();
+                m_Tag = tag_t();
             }
         }
@@ -271 +274 @@
         {
             // Remove the blocking flags
-            m_Flags &= ~ICmpObstructionManager::FLAG_BLOCK_MOVEMENT;
-            m_Flags &= ~ICmpObstructionManager::FLAG_BLOCK_PATHFINDING;
+            m_Flags &= (flags_t)(~ICmpObstructionManager::FLAG_BLOCK_MOVEMENT);
+            m_Flags &= (flags_t)(~ICmpObstructionManager::FLAG_BLOCK_PATHFINDING);
         }
         else
         {
             // Add the blocking flags if the template had enabled them
-            m_Flags |= (m_TemplateFlags & ICmpObstructionManager::FLAG_BLOCK_MOVEMENT);
-            m_Flags |= (m_TemplateFlags & ICmpObstructionManager::FLAG_BLOCK_PATHFINDING);
+            m_Flags = (flags_t)(m_Flags | (m_TemplateFlags & ICmpObstructionManager::FLAG_BLOCK_MOVEMENT));
+            m_Flags = (flags_t)(m_Flags | (m_TemplateFlags & ICmpObstructionManager::FLAG_BLOCK_PATHFINDING));
         }
 

ps/trunk/source/simulation2/components/CCmpObstructionManager.cpp

@@ -52 +52 @@
     entity_pos_t x, z;
     entity_pos_t r; // radius of circle, or half width of square
-    u8 flags;
+    ICmpObstructionManager::flags_t flags;
     entity_id_t group; // control group (typically the owner entity, or a formation controller entity) (units ignore collisions with others in the same group)
 };
@@ -65 +65 @@
     CFixedVector2D u, v; // orthogonal unit vectors - axes of local coordinate space
     entity_pos_t hw, hh; // half width/height in local coordinate space
-    u8 flags;
+    ICmpObstructionManager::flags_t flags;
 };
 
@@ -246 +246 @@
     }
 
-    virtual tag_t AddUnitShape(entity_id_t ent, entity_pos_t x, entity_pos_t z, entity_pos_t r, u8 flags, entity_id_t group)
+    virtual tag_t AddUnitShape(entity_id_t ent, entity_pos_t x, entity_pos_t z, entity_pos_t r, flags_t flags, entity_id_t group)
     {
         UnitShape shape = { ent, x, z, r, flags, group };
-        size_t id = m_UnitShapeNext++;
+        u32 id = m_UnitShapeNext++;
         m_UnitShapes[id] = shape;
         MakeDirtyUnit(flags);
@@ -258 +258 @@
     }
 
-    virtual tag_t AddStaticShape(entity_id_t ent, entity_pos_t x, entity_pos_t z, entity_angle_t a, entity_pos_t w, entity_pos_t h, u8 flags)
+    virtual tag_t AddStaticShape(entity_id_t ent, entity_pos_t x, entity_pos_t z, entity_angle_t a, entity_pos_t w, entity_pos_t h, flags_t flags)
     {
         fixed s, c;
@@ -266 +266 @@
 
         StaticShape shape = { ent, x, z, u, v, w/2, h/2, flags };
-        size_t id = m_StaticShapeNext++;
+        u32 id = m_StaticShapeNext++;
         m_StaticShapes[id] = shape;
         MakeDirtyStatic(flags);
@@ -351 +351 @@
                 shape.flags |= FLAG_MOVING;
             else
-                shape.flags &= ~FLAG_MOVING;
+                shape.flags &= (flags_t)~FLAG_MOVING;
 
             MakeDirtyDebug();
@@ -469 +469 @@
      * Call this when a static shape has changed.
      */
-    void MakeDirtyStatic(u8 flags)
+    void MakeDirtyStatic(flags_t flags)
     {
         if (flags & (FLAG_BLOCK_PATHFINDING|FLAG_BLOCK_FOUNDATION))
@@ -481 +481 @@
      * Call this when a unit shape has changed.
      */
-    void MakeDirtyUnit(u8 flags)
+    void MakeDirtyUnit(flags_t flags)
     {
         if (flags & (FLAG_BLOCK_PATHFINDING|FLAG_BLOCK_FOUNDATION))
@@ -691 +691 @@
 static void NearestTile(entity_pos_t x, entity_pos_t z, u16& i, u16& j, u16 w, u16 h)
 {
-    i = clamp((x / (int)CELL_SIZE).ToInt_RoundToZero(), 0, w-1);
-    j = clamp((z / (int)CELL_SIZE).ToInt_RoundToZero(), 0, h-1);
+    i = (u16)clamp((x / (int)CELL_SIZE).ToInt_RoundToZero(), 0, w-1);
+    j = (u16)clamp((z / (int)CELL_SIZE).ToInt_RoundToZero(), 0, h-1);
 }
 
@@ -700 +700 @@
 static void TileCenter(u16 i, u16 j, entity_pos_t& x, entity_pos_t& z)
 {
-    x = entity_pos_t::FromInt(i*(int)CELL_SIZE + CELL_SIZE/2);
-    z = entity_pos_t::FromInt(j*(int)CELL_SIZE + CELL_SIZE/2);
+    x = entity_pos_t::FromInt(i*(int)CELL_SIZE + (int)CELL_SIZE/2);
+    z = entity_pos_t::FromInt(j*(int)CELL_SIZE + (int)CELL_SIZE/2);
 }
 
@@ -811 +811 @@
 
     // WARNING: CCmpRangeManager::LosIsOffWorld needs to be kept in sync with this
-    const ssize_t edgeSize = 3; // number of tiles around the edge that will be off-world
+    const u16 edgeSize = 3; // number of tiles around the edge that will be off-world
 
     u8 edgeFlags = TILE_OBSTRUCTED_PATHFINDING | TILE_OBSTRUCTED_FOUNDATION | TILE_OUTOFBOUNDS;
@@ -845 +845 @@
                 grid.set(i, j, edgeFlags);
         for (u16 j = 0; j < grid.m_H; ++j)
-            for (u16 i = i1-edgeSize+1; i < grid.m_W; ++i)
+            for (u16 i = (u16)(i1-edgeSize+1); i < grid.m_W; ++i)
                 grid.set(i, j, edgeFlags);
         for (u16 j = 0; j < j0+edgeSize; ++j)
-            for (u16 i = i0+edgeSize; i < i1-edgeSize+1; ++i)
+            for (u16 i = (u16)(i0+edgeSize); i < i1-edgeSize+1; ++i)
                 grid.set(i, j, edgeFlags);
-        for (u16 j = j1-edgeSize+1; j < grid.m_H; ++j)
-            for (u16 i = i0+edgeSize; i < i1-edgeSize+1; ++i)
+        for (u16 j = (u16)(j1-edgeSize+1); j < grid.m_H; ++j)
+            for (u16 i = (u16)(i0+edgeSize); i < i1-edgeSize+1; ++i)
                 grid.set(i, j, edgeFlags);
     }
@@ -967 +967 @@
             m_DebugOverlayLines.push_back(SOverlayLine());
             m_DebugOverlayLines.back().m_Color = defaultColour;
-            float a = atan2(it->second.v.X.ToFloat(), it->second.v.Y.ToFloat());
+            float a = atan2f(it->second.v.X.ToFloat(), it->second.v.Y.ToFloat());
             SimRender::ConstructSquareOnGround(GetSimContext(), it->second.x.ToFloat(), it->second.z.ToFloat(), it->second.hw.ToFloat()*2, it->second.hh.ToFloat()*2, a, m_DebugOverlayLines.back(), true);
         }

ps/trunk/source/simulation2/components/CCmpPathfinder.cpp

@@ -32 +32 @@
 #include "simulation2/components/ICmpObstruction.h"
 #include "simulation2/components/ICmpObstructionManager.h"
+#include "simulation2/components/ICmpTerrain.h"
 #include "simulation2/components/ICmpWaterManager.h"
 #include "simulation2/serialization/SerializeTemplates.h"
@@ -78 +79 @@
     // will require some adjustment and rethinking.
     const CParamNode pathingSettings = externalParamNode.GetChild("Pathfinder");
-    m_MaxSameTurnMoves = pathingSettings.GetChild("MaxSameTurnMoves").ToInt();
+    m_MaxSameTurnMoves = (u16)pathingSettings.GetChild("MaxSameTurnMoves").ToInt();
 
 
@@ -306 +307 @@
 void CCmpPathfinder::UpdateGrid()
 {
+    CmpPtr<ICmpTerrain> cmpTerrain(GetSimContext(), SYSTEM_ENTITY);
+    if (cmpTerrain.null())
+        return; // error
+
     // If the terrain was resized then delete the old grid data
-    if (m_Grid && m_MapSize != GetSimContext().GetTerrain().GetTilesPerSide())
+    if (m_Grid && m_MapSize != cmpTerrain->GetTilesPerSide())
     {
         SAFE_DELETE(m_Grid);
@@ -317 +322 @@
     if (!m_Grid)
     {
-        // TOOD: these bits should come from ICmpTerrain
-        ssize_t size = GetSimContext().GetTerrain().GetTilesPerSide();
-
-        ENSURE(size >= 1 && size <= 0xffff); // must fit in 16 bits
-        m_MapSize = size;
+        m_MapSize = cmpTerrain->GetTilesPerSide();
         m_Grid = new Grid<TerrainTile>(m_MapSize, m_MapSize);
         m_ObstructionGrid = new Grid<u8>(m_MapSize, m_MapSize);
@@ -354 +355 @@
                     t |= 1;
                 else
-                    t &= ~1;
+                    t &= (TerrainTile)~1;
 
                 if (obstruct & ICmpObstructionManager::TILE_OBSTRUCTED_FOUNDATION)
                     t |= 2;
                 else
-                    t &= ~2;
+                    t &= (TerrainTile)~2;
             }
         }
@@ -418 +419 @@
 
         // Expand influences on land to find shore distance
-        for (size_t y = 0; y < m_MapSize; ++y)
+        for (u16 y = 0; y < m_MapSize; ++y)
         {
             u16 min = shoreMax;
-            for (size_t x = 0; x < m_MapSize; ++x)
+            for (u16 x = 0; x < m_MapSize; ++x)
             {
                 if (!waterGrid.get(x, y))
@@ -434 +435 @@
                 }
             }
-            for (size_t x = m_MapSize; x > 0; --x)
+            for (u16 x = m_MapSize; x > 0; --x)
             {
                 if (!waterGrid.get(x-1, y))
@@ -448 +449 @@
             }
         }
-        for (size_t x = 0; x < m_MapSize; ++x)
+        for (u16 x = 0; x < m_MapSize; ++x)
         {
             u16 min = shoreMax;
-            for (size_t y = 0; y < m_MapSize; ++y)
+            for (u16 y = 0; y < m_MapSize; ++y)
             {
                 if (!waterGrid.get(x, y))
@@ -464 +465 @@
                 }
             }
-            for (size_t y = m_MapSize; y > 0; --y)
+            for (u16 y = m_MapSize; y > 0; --y)
             {
                 if (!waterGrid.get(x, y-1))
@@ -601 +602 @@
 void CCmpPathfinder::ProcessSameTurnMoves()
 {
-    u32 moveCount;
-
     if (!m_AsyncLongPathRequests.empty())
     {
         // Figure out how many moves we can do this time
-        moveCount = m_MaxSameTurnMoves - m_SameTurnMovesCount;
-    
+        i32 moveCount = m_MaxSameTurnMoves - m_SameTurnMovesCount;
+
         if (moveCount <= 0)
             return;
@@ -613 +612 @@
         // Copy the long request elements we are going to process into a new array
         std::vector<AsyncLongPathRequest> longRequests;
-        if (m_AsyncLongPathRequests.size() <= moveCount)
+        if ((i32)m_AsyncLongPathRequests.size() <= moveCount)
         {
             m_AsyncLongPathRequests.swap(longRequests);
-            moveCount = longRequests.size();
+            moveCount = (i32)longRequests.size();
         }
         else
@@ -627 +626 @@
         ProcessLongRequests(longRequests);
 
-        m_SameTurnMovesCount += moveCount;
+        m_SameTurnMovesCount = (u16)(m_SameTurnMovesCount + moveCount);
     }
     
@@ -633 +632 @@
     {
         // Figure out how many moves we can do now
-        moveCount = m_MaxSameTurnMoves - m_SameTurnMovesCount;
+        i32 moveCount = m_MaxSameTurnMoves - m_SameTurnMovesCount;
 
         if (moveCount <= 0)
@@ -640 +639 @@
         // Copy the short request elements we are going to process into a new array
         std::vector<AsyncShortPathRequest> shortRequests;
-        if (m_AsyncShortPathRequests.size() <= moveCount)
+        if ((i32)m_AsyncShortPathRequests.size() <= moveCount)
         {
             m_AsyncShortPathRequests.swap(shortRequests);
-            moveCount = shortRequests.size();
+            moveCount = (i32)shortRequests.size();
         }
         else
@@ -654 +653 @@
         ProcessShortRequests(shortRequests);
 
-        m_SameTurnMovesCount += moveCount;
+        m_SameTurnMovesCount = (u16)(m_SameTurnMovesCount + moveCount);
     }
 }

ps/trunk/source/simulation2/components/CCmpPathfinder_Common.h

@@ -278 +278 @@
     void NearestTile(entity_pos_t x, entity_pos_t z, u16& i, u16& j)
     {
-        i = clamp((x / (int)CELL_SIZE).ToInt_RoundToZero(), 0, m_MapSize-1);
-        j = clamp((z / (int)CELL_SIZE).ToInt_RoundToZero(), 0, m_MapSize-1);
+        i = (u16)clamp((x / (int)CELL_SIZE).ToInt_RoundToZero(), 0, m_MapSize-1);
+        j = (u16)clamp((z / (int)CELL_SIZE).ToInt_RoundToZero(), 0, m_MapSize-1);
     }
 
@@ -287 +287 @@
     static void TileCenter(u16 i, u16 j, entity_pos_t& x, entity_pos_t& z)
     {
-        x = entity_pos_t::FromInt(i*(int)CELL_SIZE + CELL_SIZE/2);
-        z = entity_pos_t::FromInt(j*(int)CELL_SIZE + CELL_SIZE/2);
+        x = entity_pos_t::FromInt(i*(int)CELL_SIZE + (int)CELL_SIZE/2);
+        z = entity_pos_t::FromInt(j*(int)CELL_SIZE + (int)CELL_SIZE/2);
     }
 

ps/trunk/source/simulation2/components/CCmpPathfinder_Tile.cpp

@@ -61 +61 @@
 
     // Get pi,pj coords of predecessor to this tile on best path, given i,j coords of this tile
-    u16 GetPredI(u16 i) { return i+dpi; }
-    u16 GetPredJ(u16 j) { return j+dpj; }
+    u16 GetPredI(u16 i) { return (u16)(i + dpi); }
+    u16 GetPredJ(u16 j) { return (u16)(j + dpj); }
     // Set the pi,pj coords of predecessor, given i,j coords of this tile
     void SetPred(u16 pi_, u16 pj_, u16 i, u16 j)
     {
-        dpi = pi_-i;
-        dpj = pj_-j;
+        dpi = (i8)((int)pi_ - (int)i);
+        dpj = (i8)((int)pj_ - (int)j);
 #if PATHFIND_DEBUG
         // predecessor must be adjacent
@@ -115 +115 @@
     virtual void ProcessTile(ssize_t i, ssize_t j)
     {
-        if (m_Pathfinder.m_Grid && !IS_PASSABLE(m_Pathfinder.m_Grid->get(i, j), m_Pathfinder.m_DebugPassClass))
+        if (m_Pathfinder.m_Grid && !IS_PASSABLE(m_Pathfinder.m_Grid->get((int)i, (int)j), m_Pathfinder.m_DebugPassClass))
             RenderTile(CColor(1, 0, 0, 0.6f), false);
 
         if (m_Pathfinder.m_DebugGrid)
         {
-            PathfindTile& n = m_Pathfinder.m_DebugGrid->get(i, j);
-
-            float c = clamp(n.GetStep() / (float)m_Pathfinder.m_DebugSteps, 0.f, 1.f);
+            PathfindTile& n = m_Pathfinder.m_DebugGrid->get((int)i, (int)j);
+
+            float c = clamp((float)n.GetStep() / (float)m_Pathfinder.m_DebugSteps, 0.f, 1.f);
 
             if (n.IsOpen())
@@ -388 +388 @@
     // otherwise just aim at the center point. (We'll never try moving outwards to a square shape.)
     if (goal.type == Goal::CIRCLE)
-        state.rGoal = (goal.hw / (int)CELL_SIZE).ToInt_RoundToZero();
+        state.rGoal = (u16)(goal.hw / (int)CELL_SIZE).ToInt_RoundToZero();
     else
         state.rGoal = 0;
@@ -462 +462 @@
         u32 g = state.tiles->get(i, j).cost;
         if (i > 0)
-            ProcessNeighbour(i, j, i-1, j, g, state);
+            ProcessNeighbour(i, j, (u16)(i-1), j, g, state);
         if (i < m_MapSize-1)
-            ProcessNeighbour(i, j, i+1, j, g, state);
+            ProcessNeighbour(i, j, (u16)(i+1), j, g, state);
         if (j > 0)
-            ProcessNeighbour(i, j, i, j-1, g, state);
+            ProcessNeighbour(i, j, i, (u16)(j-1), g, state);
         if (j < m_MapSize-1)
-            ProcessNeighbour(i, j, i, j+1, g, state);
+            ProcessNeighbour(i, j, i, (u16)(j+1), g, state);
     }
 

ps/trunk/source/simulation2/components/CCmpPathfinder_Vertex.cpp

@@ -383 +383 @@
                 if (any)
                 {
-                    CFixedVector2D v0 = CFixedVector2D(fixed::FromInt(i * CELL_SIZE) - r, fixed::FromInt(j * CELL_SIZE) - r);
-                    CFixedVector2D v1 = CFixedVector2D(fixed::FromInt((i+1) * CELL_SIZE) + r, fixed::FromInt((j+1) * CELL_SIZE) + r);
+                    CFixedVector2D v0 = CFixedVector2D(fixed::FromInt(i * (int)CELL_SIZE) - r, fixed::FromInt(j * (int)CELL_SIZE) - r);
+                    CFixedVector2D v1 = CFixedVector2D(fixed::FromInt((i+1) * (int)CELL_SIZE) + r, fixed::FromInt((j+1) * (int)CELL_SIZE) + r);
                     Edge e = { v0, v1 };
                     edgesAA.push_back(e);
@@ -410 +410 @@
         case TileEdge::BOTTOM:
         {
-            v0 = CFixedVector2D(fixed::FromInt(i * CELL_SIZE) - r, fixed::FromInt(j * CELL_SIZE) - r);
-            v1 = CFixedVector2D(fixed::FromInt((i+1) * CELL_SIZE) + r, fixed::FromInt(j * CELL_SIZE) - r);
+            v0 = CFixedVector2D(fixed::FromInt(i * (int)CELL_SIZE) - r, fixed::FromInt(j * (int)CELL_SIZE) - r);
+            v1 = CFixedVector2D(fixed::FromInt((i+1) * (int)CELL_SIZE) + r, fixed::FromInt(j * (int)CELL_SIZE) - r);
             vert.p.X = v0.X - EDGE_EXPAND_DELTA; vert.p.Y = v0.Y - EDGE_EXPAND_DELTA; vert.quadInward = QUADRANT_TR; vertexes.push_back(vert);
             vert.p.X = v1.X + EDGE_EXPAND_DELTA; vert.p.Y = v1.Y - EDGE_EXPAND_DELTA; vert.quadInward = QUADRANT_TL; vertexes.push_back(vert);
@@ -418 +418 @@
         case TileEdge::TOP:
         {
-            v0 = CFixedVector2D(fixed::FromInt((i+1) * CELL_SIZE) + r, fixed::FromInt((j+1) * CELL_SIZE) + r);
-            v1 = CFixedVector2D(fixed::FromInt(i * CELL_SIZE) - r, fixed::FromInt((j+1) * CELL_SIZE) + r);
+            v0 = CFixedVector2D(fixed::FromInt((i+1) * (int)CELL_SIZE) + r, fixed::FromInt((j+1) * (int)CELL_SIZE) + r);
+            v1 = CFixedVector2D(fixed::FromInt(i * (int)CELL_SIZE) - r, fixed::FromInt((j+1) * (int)CELL_SIZE) + r);
             vert.p.X = v0.X + EDGE_EXPAND_DELTA; vert.p.Y = v0.Y + EDGE_EXPAND_DELTA; vert.quadInward = QUADRANT_BL; vertexes.push_back(vert);
             vert.p.X = v1.X - EDGE_EXPAND_DELTA; vert.p.Y = v1.Y + EDGE_EXPAND_DELTA; vert.quadInward = QUADRANT_BR; vertexes.push_back(vert);
@@ -426 +426 @@
         case TileEdge::LEFT:
         {
-            v0 = CFixedVector2D(fixed::FromInt(i * CELL_SIZE) - r, fixed::FromInt((j+1) * CELL_SIZE) + r);
-            v1 = CFixedVector2D(fixed::FromInt(i * CELL_SIZE) - r, fixed::FromInt(j * CELL_SIZE) - r);
+            v0 = CFixedVector2D(fixed::FromInt(i * (int)CELL_SIZE) - r, fixed::FromInt((j+1) * (int)CELL_SIZE) + r);
+            v1 = CFixedVector2D(fixed::FromInt(i * (int)CELL_SIZE) - r, fixed::FromInt(j * (int)CELL_SIZE) - r);
             vert.p.X = v0.X - EDGE_EXPAND_DELTA; vert.p.Y = v0.Y + EDGE_EXPAND_DELTA; vert.quadInward = QUADRANT_BR; vertexes.push_back(vert);
             vert.p.X = v1.X - EDGE_EXPAND_DELTA; vert.p.Y = v1.Y - EDGE_EXPAND_DELTA; vert.quadInward = QUADRANT_TR; vertexes.push_back(vert);
@@ -434 +434 @@
         case TileEdge::RIGHT:
         {
-            v0 = CFixedVector2D(fixed::FromInt((i+1) * CELL_SIZE) + r, fixed::FromInt(j * CELL_SIZE) - r);
-            v1 = CFixedVector2D(fixed::FromInt((i+1) * CELL_SIZE) + r, fixed::FromInt((j+1) * CELL_SIZE) + r);
+            v0 = CFixedVector2D(fixed::FromInt((i+1) * (int)CELL_SIZE) + r, fixed::FromInt(j * (int)CELL_SIZE) - r);
+            v1 = CFixedVector2D(fixed::FromInt((i+1) * (int)CELL_SIZE) + r, fixed::FromInt((j+1) * (int)CELL_SIZE) + r);
             vert.p.X = v0.X + EDGE_EXPAND_DELTA; vert.p.Y = v0.Y - EDGE_EXPAND_DELTA; vert.quadInward = QUADRANT_TL; vertexes.push_back(vert);
             vert.p.X = v1.X + EDGE_EXPAND_DELTA; vert.p.Y = v1.Y + EDGE_EXPAND_DELTA; vert.quadInward = QUADRANT_BL; vertexes.push_back(vert);
@@ -524 +524 @@
         case CCmpPathfinder::Goal::SQUARE:
         {
-            float a = atan2(goal.v.X.ToFloat(), goal.v.Y.ToFloat());
+            float a = atan2f(goal.v.X.ToFloat(), goal.v.Y.ToFloat());
             SimRender::ConstructSquareOnGround(GetSimContext(), goal.x.ToFloat(), goal.z.ToFloat(), goal.hw.ToFloat()*2, goal.hh.ToFloat()*2, a, m_DebugOverlayShortPathLines.back(), true);
             break;
@@ -801 +801 @@
                     // was very near another unit), don't restrict further pathing.
                     if (vertexes[n].quadInward && !(curr.id == START_VERTEX_ID && g < fixed::FromInt(8)))
-                        vertexes[n].quadOutward = ((~vertexes[n].quadInward) & quad);
+                        vertexes[n].quadOutward = ((~vertexes[n].quadInward) & quad) & 0xF;
 
                     if (n == GOAL_VERTEX_ID)
@@ -830 +830 @@
                     // direction (but not go into the inside of the shape).
                     if (vertexes[n].quadInward)
-                        vertexes[n].quadOutward = ((~vertexes[n].quadInward) & quad);
+                        vertexes[n].quadOutward = ((~vertexes[n].quadInward) & quad) & 0xF;
 
                     if (n == GOAL_VERTEX_ID)

ps/trunk/source/simulation2/components/CCmpPosition.cpp

@@ -396 +396 @@
             float delta = rotY - m_InterpolatedRotY;
             // Wrap delta to -M_PI..M_PI
-            delta = fmod(delta + (float)M_PI, 2*(float)M_PI); // range -2PI..2PI
+            delta = fmodf(delta + (float)M_PI, 2*(float)M_PI); // range -2PI..2PI
             if (delta < 0) delta += 2*(float)M_PI; // range 0..2PI
             delta -= (float)M_PI; // range -M_PI..M_PI

ps/trunk/source/simulation2/components/CCmpProjectileManager.cpp

@@ -197 +197 @@
 
     CVector3D offset = projectile.target - projectile.pos;
-    float horizDistance = hypot(offset.X, offset.Z);
+    float horizDistance = hypotf(offset.X, offset.Z);
 
     projectile.speedFactor = 1.f;
@@ -222 +222 @@
         // To prevent arrows going crazily far after missing the target,
         // apply a bit of drag to them
-        projectile.speedFactor *= pow(1.0f - 0.4f*projectile.speedFactor, dt);
+        projectile.speedFactor *= powf(1.0f - 0.4f*projectile.speedFactor, dt);
     }
     else
@@ -283 +283 @@
         axis.Normalize();
 
-    float angle = acos(up.Dot(delta));
+    float angle = acosf(up.Dot(delta));
 
     CMatrix3D transform;

ps/trunk/source/simulation2/components/CCmpRangeManager.cpp

@@ -201 +201 @@
     // 2-bit ELosState per player, starting with player 1 (not 0!) up to player MAX_LOS_PLAYER_ID (inclusive)
     std::vector<u32> m_LosState;
-    static const int MAX_LOS_PLAYER_ID = 16;
+    static const player_id_t MAX_LOS_PLAYER_ID = 16;
 
     // Special static visibility data for the "reveal whole map" mode
@@ -378 +378 @@
             }
 
-            it->second.owner = msgData.to;
+            ENSURE(-128 <= msgData.to && msgData.to <= 127);
+            it->second.owner = (i8)msgData.to;
 
             break;
@@ -422 +423 @@
         m_WorldX1 = x1;
         m_WorldZ1 = z1;
-        m_TerrainVerticesPerSide = vertices;
+        m_TerrainVerticesPerSide = (i32)vertices;
 
         ResetDerivedData(false);
@@ -468 +469 @@
         std::vector<int> owners, int requiredInterface)
     {
-        size_t id = m_QueryNext++;
+        tag_t id = m_QueryNext++;
         m_Queries[id] = ConstructQuery(source, minRange, maxRange, owners, requiredInterface);
 
-        return (tag_t)id;
+        return id;
     }
 
@@ -775 +776 @@
                 m_DebugOverlayLines.push_back(SOverlayLine());
                 m_DebugOverlayLines.back().m_Color = (q.enabled ? enabledRingColour : disabledRingColour);
-                SimRender::ConstructCircleOnGround(GetSimContext(), pos.X.ToFloat(), pos.Y.ToDouble(), q.maxRange.ToFloat(), m_DebugOverlayLines.back(), true);
+                SimRender::ConstructCircleOnGround(GetSimContext(), pos.X.ToFloat(), pos.Y.ToFloat(), q.maxRange.ToFloat(), m_DebugOverlayLines.back(), true);
 
                 // Draw the min range circle
@@ -782 +783 @@
                     m_DebugOverlayLines.push_back(SOverlayLine());
                     m_DebugOverlayLines.back().m_Color = (q.enabled ? enabledRingColour : disabledRingColour);
-                    SimRender::ConstructCircleOnGround(GetSimContext(), pos.X.ToFloat(), pos.Y.ToDouble(), q.minRange.ToFloat(), m_DebugOverlayLines.back(), true);
+                    SimRender::ConstructCircleOnGround(GetSimContext(), pos.X.ToFloat(), pos.Y.ToFloat(), q.minRange.ToFloat(), m_DebugOverlayLines.back(), true);
                 }
 
@@ -912 +913 @@
         // for every vertex around that tile, to mark them as explored
 
-        for (size_t j = 0; j < grid.m_H; ++j)
-        {
-            for (size_t i = 0; i < grid.m_W; ++i)
+        for (u16 j = 0; j < grid.m_H; ++j)
+        {
+            for (u16 i = 0; i < grid.m_W; ++i)
             {
                 u8 p = grid.get(i, j);
@@ -980 +981 @@
             }
 
-            counts[idx] += 1;
+            counts[idx] = (u16)(counts[idx] + 1); // ignore overflow; the player should never have 64K units
         }
     }
@@ -997 +998 @@
         for (i32 idx = idx0; idx <= idx1; ++idx)
         {
-            counts[idx] -= 1;
+            counts[idx] = (u16)(counts[idx] - 1);
 
             // Decreasing from non-zero to zero - move from visible+explored to explored
@@ -1197 +1198 @@
     }
 
-    void LosAdd(i8 owner, entity_pos_t visionRange, CFixedVector2D pos)
+    void LosAdd(player_id_t owner, entity_pos_t visionRange, CFixedVector2D pos)
     {
         if (visionRange.IsZero() || owner <= 0 || owner > MAX_LOS_PLAYER_ID)
             return;
 
-        LosUpdateHelper<true>(owner, visionRange, pos);
-    }
-
-    void LosRemove(i8 owner, entity_pos_t visionRange, CFixedVector2D pos)
+        LosUpdateHelper<true>((u8)owner, visionRange, pos);
+    }
+
+    void LosRemove(player_id_t owner, entity_pos_t visionRange, CFixedVector2D pos)
     {
         if (visionRange.IsZero() || owner <= 0 || owner > MAX_LOS_PLAYER_ID)
             return;
 
-        LosUpdateHelper<false>(owner, visionRange, pos);
-    }
-
-    void LosMove(i8 owner, entity_pos_t visionRange, CFixedVector2D from, CFixedVector2D to)
+        LosUpdateHelper<false>((u8)owner, 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)
@@ -1222 +1223 @@
             // If it's a very large move, then simply remove and add to the new position
 
-            LosUpdateHelper<false>(owner, visionRange, from);
-            LosUpdateHelper<true>(owner, visionRange, to);
+            LosUpdateHelper<false>((u8)owner, visionRange, from);
+            LosUpdateHelper<true>((u8)owner, visionRange, to);
         }
         else
@@ -1229 +1230 @@
             // Otherwise use the version optimised for mostly-overlapping circles
 
-            LosUpdateHelperIncremental(owner, visionRange, from, to);
+            LosUpdateHelperIncremental((u8)owner, visionRange, from, to);
         }
     }

ps/trunk/source/simulation2/components/CCmpTerrain.cpp

@@ -80 +80 @@
     }
 
-    virtual uint32_t GetVerticesPerSide()
+    virtual u16 GetTilesPerSide()
     {
-        return m_Terrain->GetVerticesPerSide();
+        ssize_t tiles = m_Terrain->GetTilesPerSide();
+        ENSURE(1 <= tiles && tiles <= 65535);
+        return (u16)tiles;
+    }
+
+    virtual u16 GetVerticesPerSide()
+    {
+        ssize_t vertices = m_Terrain->GetVerticesPerSide();
+        ENSURE(1 <= vertices && vertices <= 65535);
+        return (u16)vertices;
     }
 
@@ -94 +103 @@
         // TODO: should refactor this code to be nicer
 
+        u16 tiles = GetTilesPerSide();
+        u16 vertices = GetVerticesPerSide();
+
         CmpPtr<ICmpObstructionManager> cmpObstructionManager(GetSimContext(), SYSTEM_ENTITY);
         if (!cmpObstructionManager.null())
         {
             cmpObstructionManager->SetBounds(entity_pos_t::Zero(), entity_pos_t::Zero(),
-                    entity_pos_t::FromInt(m_Terrain->GetTilesPerSide()*CELL_SIZE),
-                    entity_pos_t::FromInt(m_Terrain->GetTilesPerSide()*CELL_SIZE));
+                    entity_pos_t::FromInt(tiles*(int)CELL_SIZE),
+                    entity_pos_t::FromInt(tiles*(int)CELL_SIZE));
         }
 
@@ -106 +118 @@
         {
             cmpRangeManager->SetBounds(entity_pos_t::Zero(), entity_pos_t::Zero(),
-                    entity_pos_t::FromInt(m_Terrain->GetTilesPerSide()*CELL_SIZE),
-                    entity_pos_t::FromInt(m_Terrain->GetTilesPerSide()*CELL_SIZE),
-                    m_Terrain->GetVerticesPerSide());
+                    entity_pos_t::FromInt(tiles*(int)CELL_SIZE),
+                    entity_pos_t::FromInt(tiles*(int)CELL_SIZE),
+                    vertices);
         }
 
-        MakeDirty(0, 0, m_Terrain->GetTilesPerSide()+1, m_Terrain->GetTilesPerSide()+1);
+        MakeDirty(0, 0, tiles+1, tiles+1);
     }
 
-    virtual void MakeDirty(ssize_t i0, ssize_t j0, ssize_t i1, ssize_t j1)
+    virtual void MakeDirty(i32 i0, i32 j0, i32 i1, i32 j1)
     {
         CMessageTerrainChanged msg(i0, j0, i1, j1);

ps/trunk/source/simulation2/components/CCmpTerritoryInfluence.cpp

@@ -30 +30 @@
     DEFAULT_COMPONENT_ALLOCATOR(TerritoryInfluence)
 
-    int m_Cost;
+    i32 m_Cost;
     u32 m_Weight;
     u32 m_Radius;
@@ -76 +76 @@
     }
 
-    virtual int GetCost()
+    virtual i32 GetCost()
     {
         return m_Cost;

ps/trunk/source/simulation2/components/CCmpTerritoryManager.cpp

@@ -98 +98 @@
         CParamNode::LoadXML(externalParamNode, L"simulation/data/territorymanager.xml");
 
-        m_ImpassableCost = externalParamNode.GetChild("TerritoryManager").GetChild("ImpassableCost").ToInt();
+        int impassableCost = externalParamNode.GetChild("TerritoryManager").GetChild("ImpassableCost").ToInt();
+        ENSURE(0 <= impassableCost && impassableCost <= 255);
+        m_ImpassableCost = (u8)impassableCost;
         m_BorderThickness = externalParamNode.GetChild("TerritoryManager").GetChild("BorderThickness").ToFixed().ToFloat();
         m_BorderSeparation = externalParamNode.GetChild("TerritoryManager").GetChild("BorderSeparation").ToFixed().ToFloat();
@@ -260 +262 @@
         u16 z = tile.id.second;
         if (x > 0)
-            ProcessNeighbour(falloff, x-1, z, tile.rank, false, grid, openTiles, costGrid);
+            ProcessNeighbour(falloff, (u16)(x-1), z, tile.rank, false, grid, openTiles, costGrid);
         if (x < tilesW-1)
-            ProcessNeighbour(falloff, x+1, z, tile.rank, false, grid, openTiles, costGrid);
+            ProcessNeighbour(falloff, (u16)(x+1), z, tile.rank, false, grid, openTiles, costGrid);
         if (z > 0)
-            ProcessNeighbour(falloff, x, z-1, tile.rank, false, grid, openTiles, costGrid);
+            ProcessNeighbour(falloff, x, (u16)(z-1), tile.rank, false, grid, openTiles, costGrid);
         if (z < tilesH-1)
-            ProcessNeighbour(falloff, x, z+1, tile.rank, false, grid, openTiles, costGrid);
+            ProcessNeighbour(falloff, x, (u16)(z+1), tile.rank, false, grid, openTiles, costGrid);
         if (x > 0 && z > 0)
-            ProcessNeighbour(falloff, x-1, z-1, tile.rank, true, grid, openTiles, costGrid);
+            ProcessNeighbour(falloff, (u16)(x-1), (u16)(z-1), tile.rank, true, grid, openTiles, costGrid);
         if (x > 0 && z < tilesH-1)
-            ProcessNeighbour(falloff, x-1, z+1, tile.rank, true, grid, openTiles, costGrid);
+            ProcessNeighbour(falloff, (u16)(x-1), (u16)(z+1), tile.rank, true, grid, openTiles, costGrid);
         if (x < tilesW-1 && z > 0)
-            ProcessNeighbour(falloff, x+1, z-1, tile.rank, true, grid, openTiles, costGrid);
+            ProcessNeighbour(falloff, (u16)(x+1), (u16)(z-1), tile.rank, true, grid, openTiles, costGrid);
         if (x < tilesW-1 && z < tilesH-1)
-            ProcessNeighbour(falloff, x+1, z+1, tile.rank, true, grid, openTiles, costGrid);
+            ProcessNeighbour(falloff, (u16)(x+1), (u16)(z+1), tile.rank, true, grid, openTiles, costGrid);
     }
 }
@@ -286 +288 @@
 
     CmpPtr<ICmpTerrain> cmpTerrain(GetSimContext(), SYSTEM_ENTITY);
-    uint32_t tilesW = cmpTerrain->GetVerticesPerSide() - 1;
-    uint32_t tilesH = cmpTerrain->GetVerticesPerSide() - 1;
+    u16 tilesW = cmpTerrain->GetTilesPerSide();
+    u16 tilesH = cmpTerrain->GetTilesPerSide();
 
     SAFE_DELETE(m_Territories);
@@ -299 +301 @@
     ICmpPathfinder::pass_class_t passClassDefault = cmpPathfinder->GetPassabilityClass("default");
     const Grid<u16>& passGrid = cmpPathfinder->GetPassabilityGrid();
-    for (u32 j = 0; j < tilesH; ++j)
-    {
-        for (u32 i = 0; i < tilesW; ++i)
+    for (u16 j = 0; j < tilesH; ++j)
+    {
+        for (u16 i = 0; i < tilesW; ++i)
         {
             u16 g = passGrid.get(i, j);
@@ -365 +367 @@
             CmpPtr<ICmpPosition> cmpPosition(GetSimContext(), *eit);
             CFixedVector2D pos = cmpPosition->GetPosition2D();
-            int i = clamp((pos.X / (int)CELL_SIZE).ToInt_RoundToNegInfinity(), 0, (int)tilesW-1);
-            int j = clamp((pos.Y / (int)CELL_SIZE).ToInt_RoundToNegInfinity(), 0, (int)tilesH-1);
+            u16 i = (u16)clamp((pos.X / (int)CELL_SIZE).ToInt_RoundToNegInfinity(), 0, tilesW-1);
+            u16 j = (u16)clamp((pos.Y / (int)CELL_SIZE).ToInt_RoundToNegInfinity(), 0, tilesH-1);
 
             CmpPtr<ICmpTerritoryInfluence> cmpTerritoryInfluence(GetSimContext(), *eit);
@@ -419 +421 @@
 static void NearestTile(entity_pos_t x, entity_pos_t z, u16& i, u16& j, u16 w, u16 h)
 {
-    i = clamp((x / (int)CELL_SIZE).ToInt_RoundToZero(), 0, w-1);
-    j = clamp((z / (int)CELL_SIZE).ToInt_RoundToZero(), 0, h-1);
+    i = (u16)clamp((x / (int)CELL_SIZE).ToInt_RoundToZero(), 0, w-1);
+    j = (u16)clamp((z / (int)CELL_SIZE).ToInt_RoundToZero(), 0, h-1);
 }
 
@@ -428 +430 @@
 static void TileCenter(u16 i, u16 j, entity_pos_t& x, entity_pos_t& z)
 {
-    x = entity_pos_t::FromInt(i*(int)CELL_SIZE + CELL_SIZE/2);
-    z = entity_pos_t::FromInt(j*(int)CELL_SIZE + CELL_SIZE/2);
+    x = entity_pos_t::FromInt(i*(int)CELL_SIZE + (int)CELL_SIZE/2);
+    z = entity_pos_t::FromInt(j*(int)CELL_SIZE + (int)CELL_SIZE/2);
 }
 
@@ -441 +443 @@
         ICmpTerritoryInfluence* cmpTerritoryInfluence = static_cast<ICmpTerritoryInfluence*>(it->second);
 
-        int cost = cmpTerritoryInfluence->GetCost();
+        i32 cost = cmpTerritoryInfluence->GetCost();
         if (cost == -1)
             continue;
@@ -466 +468 @@
                 TileCenter(i, j, x, z);
                 if (Geometry::PointIsInSquare(CFixedVector2D(x - square.x, z - square.z), square.u, square.v, halfSize))
-                    grid.set(i, j, cost);
+                    grid.set(i, j, (u8)cost);
             }
         }
@@ -493 +495 @@
 
     // Try to find an assigned tile
-    for (int j = 0; j < grid.m_H; ++j)
-    {
-        for (int i = 0; i < grid.m_W; ++i)
+    for (u16 j = 0; j < grid.m_H; ++j)
+    {
+        for (u16 i = 0; i < grid.m_W; ++i)
         {
             u8 owner = grid.get(i, j);
@@ -508 +510 @@
                 std::vector<CVector2D>& points = boundaries.back().points;
 
-                int dir = 0; // 0 == bottom edge of tile, 1 == right, 2 == top, 3 == left
-
-                int cdir = dir;
-                int ci = i, cj = j;
+                u8 dir = 0; // 0 == bottom edge of tile, 1 == right, 2 == top, 3 == left
+
+                u8 cdir = dir;
+                u16 ci = i, cj = j;
+
+                u16 maxi = (u16)(grid.m_W-1);
+                u16 maxj = (u16)(grid.m_H-1);
 
                 while (true)
@@ -523 +528 @@
                     {
                     case 0:
-                        if (ci < grid.m_W-1 && cj > 0 && grid.get(ci+1, cj-1) == owner)
+                        if (ci < maxi && cj > 0 && grid.get(ci+1, cj-1) == owner)
                         {
                             ++ci;
@@ -529 +534 @@
                             cdir = 3;
                         }
-                        else if (ci < grid.m_W-1 && grid.get(ci+1, cj) == owner)
+                        else if (ci < maxi && grid.get(ci+1, cj) == owner)
                             ++ci;
                         else
@@ -535 +540 @@
                         break;
                     case 1:
-                        if (ci < grid.m_W-1 && cj < grid.m_H-1 && grid.get(ci+1, cj+1) == owner)
+                        if (ci < maxi && cj < maxj && grid.get(ci+1, cj+1) == owner)
                         {
                             ++ci;
@@ -541 +546 @@
                             cdir = 0;
                         }
-                        else if (cj < grid.m_H-1 && grid.get(ci, cj+1) == owner)
+                        else if (cj < maxj && grid.get(ci, cj+1) == owner)
                             ++cj;
                         else
@@ -547 +552 @@
                         break;
                     case 2:
-                        if (ci > 0 && cj < grid.m_H-1 && grid.get(ci-1, cj+1) == owner)
+                        if (ci > 0 && cj < maxj && grid.get(ci-1, cj+1) == owner)
                         {
                             --ci;
@@ -579 +584 @@
                 // Zero out this whole territory with a simple flood fill, so we don't
                 // process it a second time
-                std::vector<std::pair<int, int> > tileStack;
+                std::vector<std::pair<u16, u16> > tileStack;
 
 #define ZERO_AND_PUSH(i, j) STMT(grid.set(i, j, 0); tileStack.push_back(std::make_pair(i, j)); )
@@ -592 +597 @@
                     if (ti > 0 && grid.get(ti-1, tj) == owner)
                         ZERO_AND_PUSH(ti-1, tj);
-                    if (ti < grid.m_W-1 && grid.get(ti+1, tj) == owner)
+                    if (ti < maxi && grid.get(ti+1, tj) == owner)
                         ZERO_AND_PUSH(ti+1, tj);
                     if (tj > 0 && grid.get(ti, tj-1) == owner)
                         ZERO_AND_PUSH(ti, tj-1);
-                    if (tj < grid.m_H-1 && grid.get(ti, tj+1) == owner)
+                    if (tj < maxj && grid.get(ti, tj+1) == owner)
                         ZERO_AND_PUSH(ti, tj+1);
 
                     if (ti > 0 && tj > 0 && grid.get(ti-1, tj-1) == owner)
                         ZERO_AND_PUSH(ti-1, tj-1);
-                    if (ti > 0 && tj < grid.m_H-1 && grid.get(ti-1, tj+1) == owner)
+                    if (ti > 0 && tj < maxj && grid.get(ti-1, tj+1) == owner)
                         ZERO_AND_PUSH(ti-1, tj+1);
-                    if (ti < grid.m_W-1 && tj > 0 && grid.get(ti+1, tj-1) == owner)
+                    if (ti < maxi && tj > 0 && grid.get(ti+1, tj-1) == owner)
                         ZERO_AND_PUSH(ti+1, tj-1);
-                    if (ti < grid.m_W-1 && tj < grid.m_H-1 && grid.get(ti+1, tj+1) == owner)
+                    if (ti < maxi && tj < maxj && grid.get(ti+1, tj+1) == owner)
                         ZERO_AND_PUSH(ti+1, tj+1);
                 }
@@ -704 +709 @@
         return;
 
-    u8 id = m_TerritoryManager.m_Territories->get(i, j);
+    u8 id = m_TerritoryManager.m_Territories->get((int)i, (int)j);
 
     float a = 0.2f;

ps/trunk/source/simulation2/components/CCmpUnitMotion.cpp

@@ -1043 +1043 @@
     entity_pos_t distLeft = minDistance;
 
-    for (ssize_t i = path.m_Waypoints.size()-1; i >= 0; --i)
+    for (ssize_t i = (ssize_t)path.m_Waypoints.size()-1; i >= 0; --i)
     {
         // Check if the next path segment is longer than the requested minimum

ps/trunk/source/simulation2/components/CCmpVisualActor.cpp

@@ -352 +352 @@
         // Save some data from the old unit
         CColor shading = m_Unit->GetModel().GetShadingColor();
-        size_t playerID = m_Unit->GetModel().GetPlayerID();
+        player_id_t playerID = m_Unit->GetModel().GetPlayerID();
 
         // Replace with the new unit

ps/trunk/source/simulation2/components/ICmpObstructionManager.h

@@ -79 +79 @@
         FLAG_MOVING             = (1 << 4)  // indicates this unit is currently moving
     };
+
+    /**
+     * Bitmask of EFlag values.
+     */
+    typedef u8 flags_t;
 
     /**
@@ -98 +103 @@
      * @return a valid tag for manipulating the shape
      */
-    virtual tag_t AddStaticShape(entity_id_t ent, entity_pos_t x, entity_pos_t z, entity_angle_t a, entity_pos_t w, entity_pos_t h, u8 flags) = 0;
+    virtual tag_t AddStaticShape(entity_id_t ent, entity_pos_t x, entity_pos_t z, entity_angle_t a, entity_pos_t w, entity_pos_t h, flags_t flags) = 0;
 
     /**
@@ -110 +115 @@
      * @return a valid tag for manipulating the shape
      */
-    virtual tag_t AddUnitShape(entity_id_t ent, entity_pos_t x, entity_pos_t z, entity_angle_t r, u8 flags, entity_id_t group) = 0;
+    virtual tag_t AddUnitShape(entity_id_t ent, entity_pos_t x, entity_pos_t z, entity_angle_t r, flags_t flags, entity_id_t group) = 0;
 
     /**
@@ -263 +268 @@
 {
 public:
+    typedef ICmpObstructionManager::tag_t tag_t;
+    typedef ICmpObstructionManager::flags_t flags_t;
+
     virtual ~IObstructionTestFilter() {}
 
@@ -272 +280 @@
      * @param group the control group (typically the shape's unit, or the unit's formation controller, or 0)
      */
-    virtual bool Allowed(ICmpObstructionManager::tag_t tag, u8 flags, entity_id_t group) const = 0;
+    virtual bool Allowed(tag_t tag, flags_t flags, entity_id_t group) const = 0;
 };
 
@@ -281 +289 @@
 {
 public:
-    virtual bool Allowed(ICmpObstructionManager::tag_t UNUSED(tag), u8 UNUSED(flags), entity_id_t UNUSED(group)) const
+    virtual bool Allowed(tag_t UNUSED(tag), flags_t UNUSED(flags), entity_id_t UNUSED(group)) const
     {
         return true;
@@ -293 +301 @@
 {
 public:
-    virtual bool Allowed(ICmpObstructionManager::tag_t UNUSED(tag), u8 flags, entity_id_t UNUSED(group)) const
+    virtual bool Allowed(tag_t UNUSED(tag), flags_t flags, entity_id_t UNUSED(group)) const
     {
         return !(flags & ICmpObstructionManager::FLAG_MOVING);
@@ -314 +322 @@
     }
 
-    virtual bool Allowed(ICmpObstructionManager::tag_t UNUSED(tag), u8 flags, entity_id_t group) const
+    virtual bool Allowed(tag_t UNUSED(tag), flags_t flags, entity_id_t group) const
     {
         if (group == m_Group)
@@ -331 +339 @@
 class SkipTagObstructionFilter : public IObstructionTestFilter
 {
-    ICmpObstructionManager::tag_t m_Tag;
-public:
-    SkipTagObstructionFilter(ICmpObstructionManager::tag_t tag) : m_Tag(tag)
-    {
-    }
-
-    virtual bool Allowed(ICmpObstructionManager::tag_t tag, u8 UNUSED(flags), entity_id_t UNUSED(group)) const
+    tag_t m_Tag;
+public:
+    SkipTagObstructionFilter(tag_t tag) : m_Tag(tag)
+    {
+    }
+
+    virtual bool Allowed(tag_t tag, flags_t UNUSED(flags), entity_id_t UNUSED(group)) const
     {
         return tag.n != m_Tag.n;
@@ -348 +356 @@
 class SkipTagFlagsObstructionFilter : public IObstructionTestFilter
 {
-    ICmpObstructionManager::tag_t m_Tag;
-    u8 m_Mask;
-public:
-    SkipTagFlagsObstructionFilter(ICmpObstructionManager::tag_t tag, u8 mask) : m_Tag(tag), m_Mask(mask)
-    {
-    }
-
-    virtual bool Allowed(ICmpObstructionManager::tag_t tag, u8 flags, entity_id_t UNUSED(group)) const
+    tag_t m_Tag;
+    flags_t m_Mask;
+public:
+    SkipTagFlagsObstructionFilter(tag_t tag, flags_t mask) : m_Tag(tag), m_Mask(mask)
+    {
+    }
+
+    virtual bool Allowed(tag_t tag, flags_t flags, entity_id_t UNUSED(group)) const
     {
         return (tag.n != m_Tag.n && (flags & m_Mask) != 0);

ps/trunk/source/simulation2/components/ICmpTerrain.h

@@ -36 +36 @@
     virtual float GetExactGroundLevel(float x, float z) = 0;
 
-    virtual uint32_t GetVerticesPerSide() = 0;
+    /**
+     * Returns number of tiles per side on the terrain.
+     * Return value is always non-zero.
+     */
+    virtual u16 GetTilesPerSide() = 0;
+
+    /**
+     * Returns number of vertices per side on the terrain.
+     * Return value is always non-zero.
+     */
+    virtual u16 GetVerticesPerSide() = 0;
 
     virtual CTerrain* GetCTerrain() = 0;
@@ -52 +62 @@
      * sent to any components that care about terrain changes.
      */
-    virtual void MakeDirty(ssize_t i0, ssize_t j0, ssize_t i1, ssize_t j1) = 0;
+    virtual void MakeDirty(i32 i0, i32 j0, i32 i1, i32 j1) = 0;
 
     DECLARE_INTERFACE_TYPE(Terrain)

ps/trunk/source/simulation2/components/ICmpTerritoryInfluence.h

@@ -29 +29 @@
      * under the entity's obstruction.
      */
-    virtual int GetCost() = 0;
+    virtual i32 GetCost() = 0;
 
     virtual u32 GetWeight() = 0;

ps/trunk/source/simulation2/helpers/Grid.h

@@ -81 +81 @@
     }
 
-    void set(size_t i, size_t j, const T& value)
+    void set(int i, int j, const T& value)
     {
 #if GRID_BOUNDS_DEBUG
-        ENSURE(i < m_W && j < m_H);
+        ENSURE(0 <= i && i < m_W && 0 <= j && j < m_H);
 #endif
         m_Data[j*m_W + i] = value;
     }
 
-    T& get(size_t i, size_t j) const
+    T& get(int i, int j) const
     {
 #if GRID_BOUNDS_DEBUG
-        ENSURE(i < m_W && j < m_H);
+        ENSURE(0 <= i && i < m_W && 0 <= j && j < m_H);
 #endif
         return m_Data[j*m_W + i];
@@ -114 +114 @@
     enum { BucketBits = 4, BucketSize = 1 << BucketBits };
 
-    T* GetBucket(size_t i, size_t j)
+    T* GetBucket(int i, int j)
     {
         size_t b = (j >> BucketBits) * m_BW + (i >> BucketBits);
@@ -130 +130 @@
         ENSURE(m_W && m_H);
 
-        m_BW = (m_W + BucketSize-1) >> BucketBits;
-        m_BH = (m_H + BucketSize-1) >> BucketBits;
+        m_BW = (u16)((m_W + BucketSize-1) >> BucketBits);
+        m_BH = (u16)((m_H + BucketSize-1) >> BucketBits);
 
         m_Data = new T*[m_BW*m_BH];
@@ -151 +151 @@
     }
 
-    void set(size_t i, size_t j, const T& value)
+    void set(int i, int j, const T& value)
     {
 #if GRID_BOUNDS_DEBUG
-        ENSURE(i < m_W && j < m_H);
+        ENSURE(0 <= i && i < m_W && 0 <= j && j < m_H);
 #endif
         GetBucket(i, j)[(j % BucketSize)*BucketSize + (i % BucketSize)] = value;
     }
 
-    T& get(size_t i, size_t j)
+    T& get(int i, int j)
     {
 #if GRID_BOUNDS_DEBUG
-        ENSURE(i < m_W && j < m_H);
+        ENSURE(0 <= i && i < m_W && 0 <= j && j < m_H);
 #endif
         return GetBucket(i, j)[(j % BucketSize)*BucketSize + (i % BucketSize)];

ps/trunk/source/simulation2/helpers/Render.cpp

@@ -88 +88 @@
     for (size_t i = 0; i <= numPoints; ++i) // use '<=' so it's a closed loop
     {
-        float a = i * 2 * (float)M_PI / numPoints;
-        float px = x + radius * sin(a);
-        float pz = z + radius * cos(a);
+        float a = (float)i * 2 * (float)M_PI / (float)numPoints;
+        float px = x + radius * sinf(a);
+        float pz = z + radius * cosf(a);
         float py = std::max(water, cmpTerrain->GetExactGroundLevel(px, pz)) + heightOffset;
         overlay.m_Coords.push_back(px);
@@ -101 +101 @@
 static void SplitLine(std::vector<std::pair<float, float> >& coords, float x1, float y1, float x2, float y2)
 {
-    float length = sqrt(SQR(x1 - x2) + SQR(y1 - y2));
+    float length = sqrtf(SQR(x1 - x2) + SQR(y1 - y2));
     size_t pieces = ((int)length) / CELL_SIZE;
     if (pieces > 0)
     {
-        float xPieceLength = (x1 - x2) / pieces;
-        float yPieceLength = (y1 - y2) / pieces;
+        float xPieceLength = (x1 - x2) / (float)pieces;
+        float yPieceLength = (y1 - y2) / (float)pieces;
         for (size_t i = 1; i <= (pieces - 1); ++i)
         {
-            coords.push_back(std::make_pair(x1 - (xPieceLength * i), y1 - (yPieceLength * i)));
+            coords.push_back(std::make_pair(x1 - (xPieceLength * (float)i), y1 - (yPieceLength * (float)i)));
         }
     }
@@ -132 +132 @@
     }
 
-    float c = cos(a);
-    float s = sin(a);
+    float c = cosf(a);
+    float s = sinf(a);
 
     std::vector<std::pair<float, float> > coords;

ps/trunk/source/simulation2/helpers/Spatial.h

@@ -61 +61 @@
         ENSURE(toMin.X <= toMax.X && toMin.Y <= toMax.Y);
 
-        size_t i0 = GetI0(toMin.X);
-        size_t j0 = GetJ0(toMin.Y);
-        size_t i1 = GetI1(toMax.X);
-        size_t j1 = GetJ1(toMax.Y);
-        for (size_t j = j0; j <= j1; ++j)
+        u32 i0 = GetI0(toMin.X);
+        u32 j0 = GetJ0(toMin.Y);
+        u32 i1 = GetI1(toMax.X);
+        u32 j1 = GetJ1(toMax.Y);
+        for (u32 j = j0; j <= j1; ++j)
         {
-            for (size_t i = i0; i <= i1; ++i)
+            for (u32 i = i0; i <= i1; ++i)
             {
                 std::vector<T>& div = m_Divisions.at(i + j*m_DivisionsW);
@@ -84 +84 @@
         ENSURE(fromMin.X <= fromMax.X && fromMin.Y <= fromMax.Y);
 
-        size_t i0 = GetI0(fromMin.X);
-        size_t j0 = GetJ0(fromMin.Y);
-        size_t i1 = GetI1(fromMax.X);
-        size_t j1 = GetJ1(fromMax.Y);
-        for (size_t j = j0; j <= j1; ++j)
+        u32 i0 = GetI0(fromMin.X);
+        u32 j0 = GetJ0(fromMin.Y);
+        u32 i1 = GetI1(fromMax.X);
+        u32 j1 = GetJ1(fromMax.Y);
+        for (u32 j = j0; j <= j1; ++j)
         {
-            for (size_t i = i0; i <= i1; ++i)
+            for (u32 i = i0; i <= i1; ++i)
             {
                 std::vector<T>& div = m_Divisions.at(i + j*m_DivisionsW);
 
-                for (size_t n = 0; n < div.size(); ++n)
+                for (u32 n = 0; n < div.size(); ++n)
                 {
                     if (div[n] == item)
@@ -156 +156 @@
         ENSURE(posMin.X <= posMax.X && posMin.Y <= posMax.Y);
 
-        size_t i0 = GetI0(posMin.X);
-        size_t j0 = GetJ0(posMin.Y);
-        size_t i1 = GetI1(posMax.X);
-        size_t j1 = GetJ1(posMax.Y);
-        for (size_t j = j0; j <= j1; ++j)
+        u32 i0 = GetI0(posMin.X);
+        u32 j0 = GetJ0(posMin.Y);
+        u32 i1 = GetI1(posMax.X);
+        u32 j1 = GetJ1(posMax.Y);
+        for (u32 j = j0; j <= j1; ++j)
         {
-            for (size_t i = i0; i <= i1; ++i)
+            for (u32 i = i0; i <= i1; ++i)
             {
                 std::vector<T>& div = m_Divisions.at(i + j*m_DivisionsW);
@@ -193 +193 @@
     // points precisely between divisions are counted in both):
 
-    size_t GetI0(entity_pos_t x)
+    u32 GetI0(entity_pos_t x)
     {
         return Clamp((x / m_DivisionSize).ToInt_RoundToInfinity()-1, 0, (int)m_DivisionsW-1);
     }
 
-    size_t GetJ0(entity_pos_t z)
+    u32 GetJ0(entity_pos_t z)
     {
         return Clamp((z / m_DivisionSize).ToInt_RoundToInfinity()-1, 0, (int)m_DivisionsH-1);
     }
 
-    size_t GetI1(entity_pos_t x)
+    u32 GetI1(entity_pos_t x)
     {
         return Clamp((x / m_DivisionSize).ToInt_RoundToNegInfinity(), 0, (int)m_DivisionsW-1);
     }
 
-    size_t GetJ1(entity_pos_t z)
+    u32 GetJ1(entity_pos_t z)
     {
         return Clamp((z / m_DivisionSize).ToInt_RoundToNegInfinity(), 0, (int)m_DivisionsH-1);
     }
 
-    size_t GetIndex0(CFixedVector2D pos)
+    u32 GetIndex0(CFixedVector2D pos)
     {
         return GetI0(pos.X) + GetJ0(pos.Y)*m_DivisionsW;
     }
 
-    size_t GetIndex1(CFixedVector2D pos)
+    u32 GetIndex1(CFixedVector2D pos)
     {
         return GetI1(pos.X) + GetJ1(pos.Y)*m_DivisionsW;
@@ -225 +225 @@
     entity_pos_t m_DivisionSize;
     std::vector<std::vector<T> > m_Divisions;
-    size_t m_DivisionsW;
-    size_t m_DivisionsH;
+    u32 m_DivisionsW;
+    u32 m_DivisionsH;
 
     template<typename ELEM> friend struct SerializeSpatialSubdivision;

ps/trunk/source/simulation2/scripting/EngineScriptConversions.cpp

@@ -217 +217 @@
         return JSVAL_VOID;
 
-    size_t len = val.m_W * val.m_H;
+    jsuint len = val.m_W * val.m_H;
     JSObject *darray = js_CreateTypedArray(cx, js::TypedArray::TYPE_UINT16, len);
     if (!darray)

ps/trunk/source/simulation2/serialization/DebugSerializer.cpp

@@ -40 +40 @@
 // TODO: we just do e+0xx now; ought to handle varying precisions and inf and nan etc too
 template<typename T>
-std::string canonfloat(T value, size_t prec)
+std::string canonfloat(T value, int prec)
 {
     std::stringstream str;

ps/trunk/source/simulation2/system/ComponentTest.h

@@ -178 +178 @@
     }
 
-    virtual uint32_t GetVerticesPerSide()
+    virtual u16 GetTilesPerSide()
+    {
+        return 16;
+    }
+
+    virtual u16 GetVerticesPerSide()
     {
         return 17;
@@ -188 +193 @@
     }
 
-    virtual void MakeDirty(ssize_t UNUSED(i0), ssize_t UNUSED(j0), ssize_t UNUSED(i1), ssize_t UNUSED(j1))
+    virtual void MakeDirty(i32 UNUSED(i0), i32 UNUSED(j0), i32 UNUSED(i1), i32 UNUSED(j1))
     {
     }

ps/trunk/source/sound/SoundGroup.h

@@ -96 +96 @@
 
     // Set a flag using a value from eSndGrpFlags
-    inline void SetFlag(int flag) { m_Flags |= flag; }
+    inline void SetFlag(int flag) { m_Flags = (unsigned char)(m_Flags | flag); }
 
     // Test flag, returns true if flag is set.