9 files changed, 403 insertions, 97 deletions

diff --git a/src/render/Clouds.cpp b/src/render/Clouds.cpp
index 161418b9..b5af6619 100644
--- a/src/render/Clouds.cpp
+++ b/src/render/Clouds.cpp
@@ -133,7 +133,7 @@ CClouds::Render(void)
 	CSprite::InitSpriteBuffer();
 
 	int minute = CClock::GetHours()*60 + CClock::GetMinutes();
-	RwV3d campos = *(RwV3d*)&TheCamera.GetPosition();
+	RwV3d campos = TheCamera.GetPosition();
 
 	// Moon
 	int moonfadeout = Abs(minute - 180);	// fully visible at 3AM
diff --git a/src/render/Coronas.cpp b/src/render/Coronas.cpp
index 33c3f4bf..48f0f6b9 100644
--- a/src/render/Coronas.cpp
+++ b/src/render/Coronas.cpp
@@ -255,7 +255,7 @@ CCoronas::Render(void)
 
 		CVector spriteCoors;
 		float spritew, spriteh;
-		if(!CSprite::CalcScreenCoors(aCoronas[i].coors, spriteCoors, &spritew, &spriteh, true)){
+		if(!CSprite::CalcScreenCoors(aCoronas[i].coors, &spriteCoors, &spritew, &spriteh, true)){
 			aCoronas[i].offScreen = true;
 			aCoronas[i].sightClear = false;
 		}else{
@@ -464,7 +464,7 @@ CCoronas::RenderReflections(void)
 
 				CVector spriteCoors;
 				float spritew, spriteh;
-				if(CSprite::CalcScreenCoors(coors, spriteCoors, &spritew, &spriteh, true)){
+				if(CSprite::CalcScreenCoors(coors, &spriteCoors, &spritew, &spriteh, true)){
 					float drawDist = 0.75f * aCoronas[i].drawDist;
 					drawDist = Min(drawDist, 55.0f);
 					if(spriteCoors.z < drawDist){
@@ -531,7 +531,7 @@ CCoronas::DoSunAndMoon(void)
 
 	CVector spriteCoors;
 	float spritew, spriteh;
-	if(CSprite::CalcScreenCoors(sunCoors, spriteCoors, &spritew, &spriteh, true)){
+	if(CSprite::CalcScreenCoors(sunCoors, &spriteCoors, &spritew, &spriteh, true)){
 		SunScreenX = spriteCoors.x;
 		SunScreenY = spriteCoors.y;
 	}else{
diff --git a/src/render/Fluff.cpp b/src/render/Fluff.cpp
index 690a1d3f..c76d6109 100644
--- a/src/render/Fluff.cpp
+++ b/src/render/Fluff.cpp
@@ -655,7 +655,7 @@ void CScrollBar::Render()
 	RwRenderStateSet(rwRENDERSTATEZTESTENABLE,       (void*)TRUE);
 
 	CVector coronaCoord, screenCoord;
-	float   screenW, screenH;
+	float screenW, screenH;
 	for (int i = 1; i < ARRAY_SIZE(m_MessageBar); ++i)
 	{
 		for (int j = 0; j < 5; ++j)
@@ -667,7 +667,7 @@ void CScrollBar::Render()
 			// Render main coronas
 			if (m_MessageBar[i] & (1 << j))
 			{
-				if (CSprite::CalcScreenCoors(coronaCoord, screenCoord, &screenW, &screenH, true))
+				if (CSprite::CalcScreenCoors(coronaCoord, &screenCoord, &screenW, &screenH, true))
 				{
 					CSprite::RenderBufferedOneXLUSprite(
 						screenCoord.x, screenCoord.y, screenCoord.z,
@@ -679,7 +679,7 @@ void CScrollBar::Render()
 			// Render smaller and faded coronas for a trailing effect
 			else if (m_MessageBar[i - 1] & (1 << j))
 			{
-				if (CSprite::CalcScreenCoors(coronaCoord, screenCoord, &screenW, &screenH, true))
+				if (CSprite::CalcScreenCoors(coronaCoord, &screenCoord, &screenW, &screenH, true))
 				{
 					CSprite::RenderBufferedOneXLUSprite(
 						screenCoord.x, screenCoord.y, screenCoord.z,
@@ -834,7 +834,7 @@ void CDigitalClock::Render()
 		const char* clockMessage = FindDigitalClockMessage();
 
 		CVector coronaCoord, screenCoord;
-		float   screenW, screenH;
+		float screenW, screenH;
 		for (int c = 0; c < 5; ++c) // for each char to be displayed
 		{
 			for (int i = 0; i < 5; ++i) // for each column of coronas
@@ -847,7 +847,7 @@ void CDigitalClock::Render()
 						coronaCoord.y = m_Position.y + (8 * c + i) * m_Size.y * m_fScale / 8.0f;
 						coronaCoord.z = m_Position.z + j * m_fScale / 8.0f;
 
-						if (CSprite::CalcScreenCoors(coronaCoord, screenCoord, &screenW, &screenH, true))
+						if (CSprite::CalcScreenCoors(coronaCoord, &screenCoord, &screenW, &screenH, true))
 						{
 							CSprite::RenderBufferedOneXLUSprite(
 								screenCoord.x, screenCoord.y, screenCoord.z,
diff --git a/src/render/Particle.cpp b/src/render/Particle.cpp
index 2b19486e..f175c264 100644
--- a/src/render/Particle.cpp
+++ b/src/render/Particle.cpp
@@ -1570,7 +1570,7 @@ void CParticle::Render()
 				float w;
 				float h;
 
-				if ( CSprite::CalcScreenCoors(particle->m_vecPosition, coors, &w, &h, true) )
+				if ( CSprite::CalcScreenCoors(particle->m_vecPosition, &coors, &w, &h, true) )
 				{
 #ifdef PC_PARTICLE
 					if ( (!particleBanned || SCREEN_WIDTH * fParticleScaleLimit >= w)
@@ -1650,7 +1650,7 @@ void CParticle::Render()
 							float fRotation;
 							float fTrailLength;
 							
-							if ( CSprite::CalcScreenCoors(vecPrevPos, particle->m_vecScreenPosition, &fTrailLength, &fRotation, true) )
+							if ( CSprite::CalcScreenCoors(vecPrevPos, &particle->m_vecScreenPosition, &fTrailLength, &fRotation, true) )
 							{
 								CVector2D vecDist
 								(
diff --git a/src/render/PointLights.cpp b/src/render/PointLights.cpp
index 0713dc6d..6f0b4d46 100644
--- a/src/render/PointLights.cpp
+++ b/src/render/PointLights.cpp
@@ -218,7 +218,7 @@ CPointLights::RenderFogEffect(void)
 								// more intensity the closer to line
 								intensity *= 1.0f - sq(Sqrt(linedistsq) / FOG_AREA_WIDTH);
 
-								if(CSprite::CalcScreenCoors(fogcoors, spriteCoors, &spritew, &spriteh, true)){
+								if(CSprite::CalcScreenCoors(fogcoors, &spriteCoors, &spritew, &spriteh, true)){
 									float rotation = (CTimer::GetTimeInMilliseconds()&0x1FFF) * 2*3.14f / 0x2000;
 									float size = FogSizes[r>>1];
 									CSprite::RenderOneXLUSprite_Rotate_Aspect(spriteCoors.x, spriteCoors.y, spriteCoors.z,
@@ -267,7 +267,7 @@ CPointLights::RenderFogEffect(void)
 								intensity *= 1.0f - sq(lightdist / FOG_AREA_RADIUS);
 
 								CVector fogcoors(xi, yi, point.point.z + 1.6f);
-								if(CSprite::CalcScreenCoors(fogcoors, spriteCoors, &spritew, &spriteh, true)){
+								if(CSprite::CalcScreenCoors(fogcoors, &spriteCoors, &spritew, &spriteh, true)){
 									float rotation = (CTimer::GetTimeInMilliseconds()&0x3FFF) * 2*3.14f / 0x4000;
 									float size = FogSizes[r>>1];
 									CSprite::RenderOneXLUSprite_Rotate_Aspect(spriteCoors.x, spriteCoors.y, spriteCoors.z,
diff --git a/src/render/Renderer.cpp b/src/render/Renderer.cpp
index a0f66819..d47cac31 100644
--- a/src/render/Renderer.cpp
+++ b/src/render/Renderer.cpp
@@ -741,7 +741,7 @@ CRenderer::ScanWorld(void)
 	vectors[CORNER_PRIO_RIGHT].x = vectors[CORNER_LOD_RIGHT].x * 0.2f;
 	vectors[CORNER_PRIO_RIGHT].y = vectors[CORNER_LOD_RIGHT].y * 0.2f;
 	vectors[CORNER_PRIO_RIGHT].z = vectors[CORNER_LOD_RIGHT].z;
-	RwV3dTransformPoints((RwV3d*)vectors, (RwV3d*)vectors, 9, cammatrix);
+	RwV3dTransformPoints(vectors, vectors, 9, cammatrix);
 
 	m_loadingPriority = false;
 	if(TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOPDOWN ||
@@ -881,7 +881,7 @@ CRenderer::RequestObjectsInFrustum(void)
 	vectors[CORNER_PRIO_RIGHT].x = vectors[CORNER_LOD_RIGHT].x * 0.2f;
 	vectors[CORNER_PRIO_RIGHT].y = vectors[CORNER_LOD_RIGHT].y * 0.2f;
 	vectors[CORNER_PRIO_RIGHT].z = vectors[CORNER_LOD_RIGHT].z;
-	RwV3dTransformPoints((RwV3d*)vectors, (RwV3d*)vectors, 9, cammatrix);
+	RwV3dTransformPoints(vectors, vectors, 9, cammatrix);
 
 	if(TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOPDOWN ||
 #ifdef FIX_BUGS
diff --git a/src/render/WaterLevel.cpp b/src/render/WaterLevel.cpp
index ecfccc90..a0c7ae31 100644
--- a/src/render/WaterLevel.cpp
+++ b/src/render/WaterLevel.cpp
@@ -1,6 +1,7 @@
 #include "common.h"
 #include "main.h"
 #include "FileMgr.h"
+#include "FileLoader.h"
 #include "TxdStore.h"
 #include "Timer.h"
 #include "Weather.h"
@@ -30,8 +31,8 @@ float TEXTURE_ADDV;
 int32 CWaterLevel::ms_nNoOfWaterLevels;
 float CWaterLevel::ms_aWaterZs[48];
 CRect CWaterLevel::ms_aWaterRects[48];
-uint8 CWaterLevel::aWaterBlockList[WATER_BLOCK_SIZE][WATER_BLOCK_SIZE];
-uint8 CWaterLevel::aWaterFineBlockList[WATER_FINEBLOCK_SIZE][WATER_FINEBLOCK_SIZE];
+int8 CWaterLevel::aWaterBlockList[MAX_LARGE_SECTORS][MAX_LARGE_SECTORS];
+int8 CWaterLevel::aWaterFineBlockList[MAX_SMALL_SECTORS][MAX_SMALL_SECTORS];
 bool CWaterLevel::WavesCalculatedThisFrame;
 RpAtomic *CWaterLevel::ms_pWavyAtomic;
 RpGeometry *CWaterLevel::apGeomArray[8];
@@ -53,41 +54,179 @@ const float fGreenMult = 1.0f;
 const float fBlueMult = 1.4f;
 
 
-
 void
 CWaterLevel::Initialise(Const char *pWaterDat)
 {
 	ms_nNoOfWaterLevels = 0;
-	
+
+#ifdef MASTER
 	int32 hFile = -1;
-	
+
 	do
 	{
 		hFile = CFileMgr::OpenFile("DATA\\waterpro.dat", "rb");
 	}
 	while ( hFile < 0 );
-	
-	if ( hFile > 0 )
+#else
+	int32 hFile = CFileMgr::OpenFile("DATA\\waterpro.dat", "rb");
+#endif
+
+	if (hFile > 0)
 	{
-		if ( hFile >= 0 )
+		CFileMgr::Read(hFile, (char *)&ms_nNoOfWaterLevels, sizeof(ms_nNoOfWaterLevels));
+		CFileMgr::Read(hFile, (char *)ms_aWaterZs, sizeof(ms_aWaterZs));
+		CFileMgr::Read(hFile, (char *)ms_aWaterRects, sizeof(ms_aWaterRects));
+		CFileMgr::Read(hFile, (char *)aWaterBlockList, sizeof(aWaterBlockList));
+		CFileMgr::Read(hFile, (char *)aWaterFineBlockList, sizeof(aWaterFineBlockList));
+
+		CFileMgr::CloseFile(hFile);
+	}
+#ifndef MASTER
+	else
+	{
+		printf("Init waterlevels\n");
+
+		CFileMgr::SetDir("");
+		hFile = CFileMgr::OpenFile(pWaterDat, "r");
+
+		char *line;
+
+		while ((line = CFileLoader::LoadLine(hFile)))
 		{
-			CFileMgr::Read(hFile, (char *)&ms_nNoOfWaterLevels, sizeof(ms_nNoOfWaterLevels));
-			CFileMgr::Read(hFile, (char *)ms_aWaterZs,	sizeof(ms_aWaterZs));
-			CFileMgr::Read(hFile, (char *)ms_aWaterRects, sizeof(ms_aWaterRects));
-			CFileMgr::Read(hFile, (char *)aWaterBlockList, sizeof(aWaterBlockList));
-			CFileMgr::Read(hFile, (char *)aWaterFineBlockList, sizeof(aWaterFineBlockList));
+#ifdef FIX_BUGS
+			if (*line && *line != ';' && !strstr(line, "* ;end of file"))
+#else
+			if (*line && *line != ';')
+#endif
+			{
+				float z, l, b, r, t;
+				sscanf(line, "%f %f %f %f %f", &z, &l, &b, &r, &t);
+				AddWaterLevel(l, b, r, t, z);
+			}
 		}
-		
+
 		CFileMgr::CloseFile(hFile);
+
+		for (int32 x = 0; x < MAX_SMALL_SECTORS; x++)
+		{
+			for (int32 y = 0; y < MAX_SMALL_SECTORS; y++)
+			{
+				aWaterFineBlockList[x][y] = NO_WATER;
+			}
+		}
+
+		// rasterize water rects read from file
+		for (int32 i = 0; i < ms_nNoOfWaterLevels; i++)
+		{
+			int32 l = WATER_HUGE_X(ms_aWaterRects[i].left);
+			int32 r = WATER_HUGE_X(ms_aWaterRects[i].right) + 1.0f;
+			int32 t = WATER_HUGE_Y(ms_aWaterRects[i].top);
+			int32 b = WATER_HUGE_Y(ms_aWaterRects[i].bottom) + 1.0f;
+
+#ifdef FIX_BUGS
+			// water.dat has rects that go out of bounds
+			// which causes memory corruption
+			l = clamp(l, 0, MAX_SMALL_SECTORS - 1);
+			r = clamp(r, 0, MAX_SMALL_SECTORS - 1);
+			t = clamp(t, 0, MAX_SMALL_SECTORS - 1);
+			b = clamp(b, 0, MAX_SMALL_SECTORS - 1);
+#endif
+
+			for (int32 x = l; x <= r; x++)
+			{
+				for (int32 y = t; y <= b; y++)
+				{
+					aWaterFineBlockList[x][y] = i;
+				}
+			}
+		}
+
+		// remove tiles that are obscured by land
+		for (int32 x = 0; x < MAX_SMALL_SECTORS; x++)
+		{
+			float worldX = WATER_START_X + x * SMALL_SECTOR_SIZE;
+
+			for (int32 y = 0; y < MAX_SMALL_SECTORS; y++)
+			{
+				if (aWaterFineBlockList[x][y] >= 0)
+				{
+					float worldY = WATER_START_Y + y * SMALL_SECTOR_SIZE;
+
+					int32 i;
+					for (i = 0; i <= 8; i++)
+					{
+						for (int32 j = 0; j <= 8; j++)
+						{
+							CVector worldPos = CVector(worldX + i * (SMALL_SECTOR_SIZE / 8), worldY + j * (SMALL_SECTOR_SIZE / 8), ms_aWaterZs[aWaterFineBlockList[x][y]]);
+
+							if ((worldPos.x > WORLD_MIN_X && worldPos.x < WORLD_MAX_X) && (worldPos.y > WORLD_MIN_Y && worldPos.y < WORLD_MAX_Y) &&
+							    (!WaterLevelAccordingToRectangles(worldPos.x, worldPos.y) || TestVisibilityForFineWaterBlocks(worldPos)))
+								continue;
+
+							// at least one point in the tile wasn't blocked, so don't remove water
+							i = 1000;
+							break;
+						}
+					}
+
+					if (i < 1000)
+						aWaterFineBlockList[x][y] = NO_WATER;
+				}
+			}
+		}
+
+		RemoveIsolatedWater();
+
+		// calculate coarse tiles from fine tiles
+		for (int32 x = 0; x < MAX_LARGE_SECTORS; x++)
+		{
+			for (int32 y = 0; y < MAX_LARGE_SECTORS; y++)
+			{
+				if (aWaterFineBlockList[x * 2][y * 2] >= 0)
+				{
+					aWaterBlockList[x][y] = aWaterFineBlockList[x * 2][y * 2];
+				}
+				else if (aWaterFineBlockList[x * 2 + 1][y * 2] >= 0)
+				{
+					aWaterBlockList[x][y] = aWaterFineBlockList[x * 2 + 1][y * 2];
+				}
+				else if (aWaterFineBlockList[x * 2][y * 2 + 1] >= 0)
+				{
+					aWaterBlockList[x][y] = aWaterFineBlockList[x * 2][y * 2 + 1];
+				}
+				else if (aWaterFineBlockList[x * 2 + 1][y * 2 + 1] >= 0)
+				{
+					aWaterBlockList[x][y] = aWaterFineBlockList[x * 2 + 1][y * 2 + 1];
+				}
+				else
+				{
+					aWaterBlockList[x][y] = NO_WATER;
+				}
+			}
+		}
+
+		hFile = CFileMgr::OpenFileForWriting("data\\waterpro.dat");
+
+		if (hFile > 0)
+		{
+			CFileMgr::Write(hFile, (char *)&ms_nNoOfWaterLevels, sizeof(ms_nNoOfWaterLevels));
+			CFileMgr::Write(hFile, (char *)ms_aWaterZs,	sizeof(ms_aWaterZs));
+			CFileMgr::Write(hFile, (char *)ms_aWaterRects, sizeof(ms_aWaterRects));
+			CFileMgr::Write(hFile, (char *)aWaterBlockList, sizeof(aWaterBlockList));
+			CFileMgr::Write(hFile, (char *)aWaterFineBlockList, sizeof(aWaterFineBlockList));
+
+			CFileMgr::CloseFile(hFile);
+		}
 	}
+#endif
 	
 	CTxdStore::PushCurrentTxd();
 
 	int32 slot = CTxdStore::FindTxdSlot("particle");
 	CTxdStore::SetCurrentTxd(slot);
 	
-	if ( gpWaterTex == NULL )
-		gpWaterTex = RwTextureRead("water_old", NULL);
+	if ( gpWaterTex == nil )
+		gpWaterTex = RwTextureRead("water_old", nil);
 	gpWaterRaster = RwTextureGetRaster(gpWaterTex);
 	
 	CTxdStore::PopCurrentTxd();
@@ -104,10 +243,10 @@ CWaterLevel::Shutdown()
 	FreeBoatWakeArray();
 	DestroyWavyAtomic();
 
-	if ( gpWaterTex != NULL )
+	if ( gpWaterTex != nil )
 	{
 		RwTextureDestroy(gpWaterTex);
-		gpWaterTex = NULL;
+		gpWaterTex = nil;
 	}
 }
 
@@ -129,15 +268,15 @@ CWaterLevel::CreateWavyAtomic()
 													|rpGEOMETRYPRELIT
 													|rpGEOMETRYMODULATEMATERIALCOLOR);
 													
-		ASSERT(wavyGeometry != NULL);
+		ASSERT(wavyGeometry != nil);
 	
 	}
 	
 	{
 		wavyMaterial = RpMaterialCreate();
 		
-		ASSERT(wavyMaterial != NULL);
-		ASSERT(gpWaterTex   != NULL);
+		ASSERT(wavyMaterial != nil);
+		ASSERT(gpWaterTex   != nil);
 		
 		RpMaterialSetTexture(wavyMaterial, gpWaterTex);
 	}
@@ -145,7 +284,7 @@ CWaterLevel::CreateWavyAtomic()
 	{
 		wavyTriangles = RpGeometryGetTriangles(wavyGeometry);
 		
-		ASSERT(wavyTriangles != NULL);
+		ASSERT(wavyTriangles != nil);
 		/*  
 			[B]       [C]
 			 ***********
@@ -176,9 +315,9 @@ CWaterLevel::CreateWavyAtomic()
 
 	{
 		wavyMorphTarget = RpGeometryGetMorphTarget(wavyGeometry, 0);
-		ASSERT(wavyMorphTarget != NULL);
+		ASSERT(wavyMorphTarget != nil);
 		wavyVert = RpMorphTargetGetVertices(wavyMorphTarget);	
-		ASSERT(wavyVert != NULL);
+		ASSERT(wavyVert != nil);
 		
 		for ( int32 i = 0; i < 9; i++ )
 		{
@@ -198,10 +337,10 @@ CWaterLevel::CreateWavyAtomic()
 	
 	{
 		wavyFrame = RwFrameCreate();
-		ASSERT( wavyFrame != NULL );
+		ASSERT( wavyFrame != nil );
 		
 		ms_pWavyAtomic = RpAtomicCreate();		
-		ASSERT( ms_pWavyAtomic != NULL );
+		ASSERT( ms_pWavyAtomic != nil );
 		
 		RpAtomicSetGeometry(ms_pWavyAtomic, wavyGeometry, 0);
 		RpAtomicSetFrame(ms_pWavyAtomic, wavyFrame);
@@ -222,6 +361,170 @@ CWaterLevel::DestroyWavyAtomic()
 	RwFrameDestroy(frame);	
 }
 
+#ifndef MASTER
+void
+CWaterLevel::AddWaterLevel(float fXLeft, float fYBottom, float fXRight, float fYTop, float fLevel)
+{
+	ms_aWaterRects[ms_nNoOfWaterLevels] = CRect(fXLeft, fYBottom, fXRight, fYTop);
+	ms_aWaterZs[ms_nNoOfWaterLevels] = fLevel;
+	ms_nNoOfWaterLevels++;
+}
+
+bool
+CWaterLevel::WaterLevelAccordingToRectangles(float fX, float fY, float *pfOutLevel)
+{
+	if (ms_nNoOfWaterLevels <= 0) return false;
+
+	for (int32 i = 0; i < ms_nNoOfWaterLevels; i++)
+	{
+		if (fX >= ms_aWaterRects[i].left && fX <= ms_aWaterRects[i].right
+			&& fY >= ms_aWaterRects[i].top && fY <= ms_aWaterRects[i].bottom)
+		{
+			if (pfOutLevel) *pfOutLevel = ms_aWaterZs[i];
+
+			return true;
+		}
+	}
+
+	return false;
+}
+
+bool
+CWaterLevel::TestVisibilityForFineWaterBlocks(const CVector &worldPos)
+{
+	static CVector2D tab[] =
+	{
+		{ 50.0f, 50.0f },
+		{ -50.0f, 50.0f },
+		{ -50.0f, -50.0f },
+		{ 50.0f, -50.0f },
+		{ 50.0f, 0.0f },
+		{ -50.0f, 0.0f },
+		{ 0.0f, -50.0f },
+		{ 0.0f, 50.0f },
+	};
+
+	CEntity *entity;
+	CColPoint col;
+	CVector lineStart, lineEnd;
+
+	lineStart = worldPos;
+
+	if (!CWorld::ProcessVerticalLine(lineStart, lineStart.z + 100.0f, col, entity, true, false, false, false, true, false, nil))
+	{
+		lineStart.x += 0.4f;
+		lineStart.y += 0.4f;
+
+		if (!CWorld::ProcessVerticalLine(lineStart, lineStart.z + 100.0f, col, entity, true, false, false, false, true, false, nil))
+		{
+			return false;
+		}
+	}
+
+	for (int32 i = 0; i < ARRAY_SIZE(tab); i++)
+	{
+		lineStart = worldPos;
+		lineEnd = worldPos;
+
+		lineEnd.x += tab[i].x;
+		lineEnd.y += tab[i].y;
+		lineEnd.z += 100.0f;
+
+		if ((lineEnd.x > WORLD_MIN_X && lineEnd.x < WORLD_MAX_X) && (lineEnd.y > WORLD_MIN_Y && lineEnd.y < WORLD_MAX_Y))
+		{
+			if (!CWorld::ProcessLineOfSight(lineStart, lineEnd, col, entity, true, false, false, false, true, false, nil))
+			{
+				lineStart.x += 0.4f;
+				lineStart.y += 0.4f;
+				lineEnd.x += 0.4f;
+				lineEnd.y += 0.4f;
+
+				if (!CWorld::ProcessLineOfSight(lineStart, lineEnd, col, entity, true, false, false, false, true, false, nil))
+				{
+					return false;
+				}
+			}
+		}
+	}
+
+	return true;
+}
+
+void
+CWaterLevel::RemoveIsolatedWater()
+{
+	bool (*isConnected)[MAX_SMALL_SECTORS] = new bool[MAX_SMALL_SECTORS][MAX_SMALL_SECTORS];
+
+	for (int32 x = 0; x < MAX_SMALL_SECTORS; x++)
+	{
+		for (int32 y = 0; y < MAX_SMALL_SECTORS; y++)
+		{
+			isConnected[x][y] = false;
+		}
+	}
+
+	isConnected[0][0] = true;
+	bool keepGoing;
+
+	do
+	{
+		keepGoing = false;
+
+		for (int32 x = 0; x < MAX_SMALL_SECTORS; x++)
+		{
+			for (int32 y = 0; y < MAX_SMALL_SECTORS; y++)
+			{
+				if (aWaterFineBlockList[x][y] < 0 || isConnected[x][y])
+					continue;
+
+				if (x > 0 && isConnected[x - 1][y])
+				{
+					isConnected[x][y] = true;
+					keepGoing = true;
+				}
+
+				if (y > 0 && isConnected[x][y - 1])
+				{
+					isConnected[x][y] = true;
+					keepGoing = true;
+				}
+
+				if (x + 1 < MAX_SMALL_SECTORS && isConnected[x + 1][y])
+				{
+					isConnected[x][y] = true;
+					keepGoing = true;
+				}
+
+				if (y + 1 < MAX_SMALL_SECTORS && isConnected[x][y + 1])
+				{
+					isConnected[x][y] = true;
+					keepGoing = true;
+				}
+			}
+		}
+	}
+	while (keepGoing);
+
+	int32 numRemoved = 0;
+
+	for (int32 x = 0; x < MAX_SMALL_SECTORS; x++)
+	{
+		for (int32 y = 0; y < MAX_SMALL_SECTORS; y++)
+		{
+			if (aWaterFineBlockList[x][y] >= 0 && !isConnected[x][y] && ms_aWaterZs[aWaterFineBlockList[x][y]] == 0.0f)
+			{
+				numRemoved++;
+				aWaterFineBlockList[x][y] = NO_WATER;
+			}
+		}
+	}
+
+	printf("Removed %d isolated patches of water\n", numRemoved);
+
+	delete[] isConnected;
+}
+#endif
+
 bool
 CWaterLevel::GetWaterLevel(float fX, float fY, float fZ, float *pfOutLevel, bool bDontCheckZ)
 {
@@ -231,12 +534,12 @@ CWaterLevel::GetWaterLevel(float fX, float fY, float fZ, float *pfOutLevel, bool
 	ASSERT( x >= 0 && x < HUGE_SECTOR_SIZE );
 	ASSERT( y >= 0 && y < HUGE_SECTOR_SIZE );
 
-	uint8 nBlock = aWaterFineBlockList[x][y];
+	int8 nBlock = aWaterFineBlockList[x][y];
 
-	if ( nBlock == 128 )
+	if ( nBlock == NO_WATER )
 		return false;
 
-	ASSERT( pfOutLevel != NULL );
+	ASSERT( pfOutLevel != nil );
 	*pfOutLevel = ms_aWaterZs[nBlock];
 
 	float fAngle = (CTimer::GetTimeInMilliseconds() & 4095) * (TWOPI / 4096.0f);
@@ -270,12 +573,12 @@ CWaterLevel::GetWaterLevelNoWaves(float fX, float fY, float fZ, float *pfOutLeve
 	ASSERT( x >= 0 && x < HUGE_SECTOR_SIZE );
 	ASSERT( y >= 0 && y < HUGE_SECTOR_SIZE );
 	
-	uint8 nBlock = aWaterFineBlockList[x][y];
+	int8 nBlock = aWaterFineBlockList[x][y];
 		
-	if ( nBlock == 128 )
+	if ( nBlock == NO_WATER )
 		return false;
 	
-	ASSERT( pfOutLevel != NULL );
+	ASSERT( pfOutLevel != nil );
 	*pfOutLevel = ms_aWaterZs[nBlock];
 
 	return true;
@@ -418,10 +721,10 @@ CWaterLevel::RenderWater()
 	{
 		for ( int32 y = nStartY; y <= nEndY; y++ )
 		{
-			if (   !(aWaterBlockList[2*x+0][2*y+0] & 128)
-				|| !(aWaterBlockList[2*x+1][2*y+0] & 128)
-				|| !(aWaterBlockList[2*x+0][2*y+1] & 128)
-				|| !(aWaterBlockList[2*x+1][2*y+1] & 128) )
+			if (   aWaterBlockList[2*x+0][2*y+0] >= 0
+				|| aWaterBlockList[2*x+1][2*y+0] >= 0
+				|| aWaterBlockList[2*x+0][2*y+1] >= 0
+				|| aWaterBlockList[2*x+1][2*y+1] >= 0 )
 			{
 				float fX = WATER_FROM_HUGE_SECTOR_X(x);
 				float fY = WATER_FROM_HUGE_SECTOR_Y(y);
@@ -443,16 +746,16 @@ CWaterLevel::RenderWater()
 						{
 							float fZ;
 	
-							if ( !(aWaterBlockList[2*x+0][2*y+0] & 128) )
+							if ( aWaterBlockList[2*x+0][2*y+0] >= 0 )
 								fZ = ms_aWaterZs[ aWaterBlockList[2*x+0][2*y+0] ];
 	
-							if ( !(aWaterBlockList[2*x+1][2*y+0] & 128) )
+							if ( aWaterBlockList[2*x+1][2*y+0] >= 0 )
 								fZ = ms_aWaterZs[ aWaterBlockList[2*x+1][2*y+0] ];
 	
-							if ( !(aWaterBlockList[2*x+0][2*y+1] & 128) )
+							if ( aWaterBlockList[2*x+0][2*y+1] >= 0 )
 								fZ = ms_aWaterZs[ aWaterBlockList[2*x+0][2*y+1] ];
 	
-							if ( !(aWaterBlockList[2*x+1][2*y+1] & 128) )
+							if ( aWaterBlockList[2*x+1][2*y+1] >= 0 )
 								fZ = ms_aWaterZs[ aWaterBlockList[2*x+1][2*y+1] ];
 							
 							RenderOneFlatHugeWaterPoly(fX, fY, fZ, color);
@@ -463,7 +766,7 @@ CWaterLevel::RenderWater()
 							{
 								for ( int32 y2 = 2*y; y2 <= 2*y+1; y2++ )
 								{
-									if ( !(aWaterBlockList[x2][y2] & 128) )
+									if ( aWaterBlockList[x2][y2] >= 0 )
 									{
 										float fLargeX = WATER_FROM_LARGE_SECTOR_X(x2);
 										float fLargeY = WATER_FROM_LARGE_SECTOR_Y(y2);
@@ -498,7 +801,7 @@ CWaterLevel::RenderWater()
 													float fZ;
 													
 													// WS
-													if ( !(aWaterFineBlockList[2*x2+0][2*y2+0] & 128) )
+													if ( aWaterFineBlockList[2*x2+0][2*y2+0] >= 0 )
 													{
 														float fSmallX = fLargeX;
 														float fSmallY = fLargeY;
@@ -519,7 +822,7 @@ CWaterLevel::RenderWater()
 													}
 													
 													// SE
-													if ( !(aWaterFineBlockList[2*x2+1][2*y2+0] & 128) )
+													if ( aWaterFineBlockList[2*x2+1][2*y2+0] >= 0 )
 													{
 														float fSmallX = fLargeX + (LARGE_SECTOR_SIZE/2);
 														float fSmallY = fLargeY;
@@ -540,7 +843,7 @@ CWaterLevel::RenderWater()
 													}
 													
 													// WN
-													if ( !(aWaterFineBlockList[2*x2+0][2*y2+1] & 128) )
+													if ( aWaterFineBlockList[2*x2+0][2*y2+1] >= 0 )
 													{
 														float fSmallX = fLargeX;
 														float fSmallY = fLargeY + (LARGE_SECTOR_SIZE/2);
@@ -561,7 +864,7 @@ CWaterLevel::RenderWater()
 													}
 													
 													//NE
-													if ( !(aWaterFineBlockList[2*x2+1][2*y2+1] & 128) )
+													if ( aWaterFineBlockList[2*x2+1][2*y2+1] >= 0 )
 													{
 														float fSmallX = fLargeX + (LARGE_SECTOR_SIZE/2);
 														float fSmallY = fLargeY + (LARGE_SECTOR_SIZE/2);
@@ -591,7 +894,7 @@ CWaterLevel::RenderWater()
 												}
 											}	//	if ( TheCamera.IsSphereVisible
 										}	//	if ( fLargeSectorDistToCamSqr < fHugeSectorMaxRenderDistSqr )
-									}	//	if ( !(aWaterBlockList[x2][y2] & 128) )
+									}	//	if ( aWaterBlockList[x2][y2] >= 0 )
 								}	//	for ( int32 y2 = 2*y; y2 <= 2*y+1; y2++ )
 							}	//	for ( int32 x2 = 2*x; x2 <= 2*x+1; x2++ )
 							//
@@ -948,19 +1251,19 @@ CWaterLevel::RenderOneWavySector(float fX, float fY, float fZ, RwRGBA const &col
 		
 		CBoat::FillBoatList();
 		
-		ASSERT( ms_pWavyAtomic != NULL );
+		ASSERT( ms_pWavyAtomic != nil );
 
 		RpGeometry *geometry = RpAtomicGetGeometry(ms_pWavyAtomic);
 		
-		ASSERT( geometry != NULL );
+		ASSERT( geometry != nil );
 
 		RwRGBA      *wavyPreLights = RpGeometryGetPreLightColors(geometry);
 		RwTexCoords *wavyTexCoords = RpGeometryGetVertexTexCoords(geometry, rwTEXTURECOORDINATEINDEX0);
 		RwV3d       *wavyVertices  = RpMorphTargetGetVertices(RpGeometryGetMorphTarget(geometry, 0));
 		
-		ASSERT( wavyPreLights != NULL );
-		ASSERT( wavyTexCoords != NULL );
-		ASSERT( wavyVertices  != NULL );
+		ASSERT( wavyPreLights != nil );
+		ASSERT( wavyTexCoords != nil );
+		ASSERT( wavyVertices  != nil );
 
 		RpGeometryLock(geometry, rpGEOMETRYLOCKVERTICES
 								| rpGEOMETRYLOCKPRELIGHT
@@ -983,7 +1286,7 @@ CWaterLevel::RenderOneWavySector(float fX, float fY, float fZ, RwRGBA const &col
 		RpGeometryUnlock(geometry);
 	}
 	
-	static CBoat *apBoatList[4] = { NULL };
+	static CBoat *apBoatList[4] = { nil };
 	
 	if ( apGeomArray[0]
 		&& nGeomUsed < MAX_BOAT_WAKES
@@ -997,16 +1300,16 @@ CWaterLevel::RenderOneWavySector(float fX, float fY, float fZ, RwRGBA const &col
 		RpGeometry *wavyGeometry = RpAtomicGetGeometry(ms_pWavyAtomic);	
 		RpGeometry *geom  = apGeomArray[nGeomUsed++];
 		
-		ASSERT( wavyGeometry != NULL );
-		ASSERT( geom != NULL );
+		ASSERT( wavyGeometry != nil );
+		ASSERT( geom != nil );
 		
 		RpAtomic *atomic = RpAtomicCreate();
-		ASSERT( atomic != NULL );
+		ASSERT( atomic != nil );
 		
 		RpAtomicSetGeometry(atomic, geom, 0);
 		
 		RwFrame *frame = RwFrameCreate();
-		ASSERT( frame != NULL );
+		ASSERT( frame != nil );
 		
 		RwMatrixCopy(RwFrameGetMatrix(frame), RwFrameGetMatrix(RpAtomicGetFrame(ms_pWavyAtomic)));
 		RpAtomicSetFrame(atomic, frame);
@@ -1017,11 +1320,11 @@ CWaterLevel::RenderOneWavySector(float fX, float fY, float fZ, RwRGBA const &col
 		RwV3d  *geomVertices        = RpMorphTargetGetVertices(RpGeometryGetMorphTarget(geom, 0));
 		RwV3d  *wavyVertices        = RpMorphTargetGetVertices(RpGeometryGetMorphTarget(wavyGeometry, 0));
 		
-		ASSERT( geomTexCoords != NULL );
-		ASSERT( wavyTexCoord  != NULL );
-		ASSERT( geomPreLights != NULL );
-		ASSERT( geomVertices  != NULL );
-		ASSERT( wavyVertices  != NULL );
+		ASSERT( geomTexCoords != nil );
+		ASSERT( wavyTexCoord  != nil );
+		ASSERT( geomPreLights != nil );
+		ASSERT( geomVertices  != nil );
+		ASSERT( wavyVertices  != nil );
 
 		RpGeometryLock(geom, rpGEOMETRYLOCKVERTICES | rpGEOMETRYLOCKPRELIGHT | rpGEOMETRYLOCKTEXCOORDS);
 		
@@ -1038,7 +1341,7 @@ CWaterLevel::RenderOneWavySector(float fX, float fY, float fZ, RwRGBA const &col
 		
 				for ( int32 k = 0; k < 4; k++ )
 				{
-					if ( apBoatList[k] != NULL )
+					if ( apBoatList[k] != nil )
 						fDistMult += CBoat::IsVertexAffectedByWake(CVector(fVertexX, fVertexY, 0.0f), apBoatList[k]);
 				}
 				
@@ -1087,7 +1390,7 @@ CWaterLevel::RenderOneWavySector(float fX, float fY, float fZ, RwRGBA const &col
 		pos.y = fY;
 		pos.z = fZ;
 		
-		ASSERT( ms_pWavyAtomic != NULL );
+		ASSERT( ms_pWavyAtomic != nil );
 		
 		RwFrameTranslate(RpAtomicGetFrame(ms_pWavyAtomic), &pos, rwCOMBINEREPLACE);
 		
@@ -1116,7 +1419,7 @@ CWaterLevel::CalcDistanceToWater(float fX, float fY)
 	{
 		for ( int32 y = nStartY; y <= nEndY; y++ )
 		{
-			if ( !(aWaterFineBlockList[x][y] & 128) )
+			if ( aWaterFineBlockList[x][y] >= 0 )
 			{				
 				float fSectorX = WATER_FROM_SMALL_SECTOR_X(x);
 				float fSectorY = WATER_FROM_SMALL_SECTOR_Y(y);
@@ -1142,7 +1445,7 @@ CWaterLevel::RenderAndEmptyRenderBuffer()
 	{
 		LittleTest();
 
-		if ( RwIm3DTransform(TempBufferRenderVertices, TempBufferVerticesStored, NULL, rwIM3D_VERTEXUV) )
+		if ( RwIm3DTransform(TempBufferRenderVertices, TempBufferVerticesStored, nil, rwIM3D_VERTEXUV) )
 		{
 			RwIm3DRenderIndexedPrimitive(rwPRIMTYPETRILIST, TempBufferRenderIndexList, TempBufferIndicesStored);
 			RwIm3DEnd();
@@ -1160,29 +1463,29 @@ CWaterLevel::AllocateBoatWakeArray()
 
 	PUSH_MEMID(MEMID_STREAM);
 
-	ASSERT(ms_pWavyAtomic != NULL );
+	ASSERT(ms_pWavyAtomic != nil );
 	
 	RpGeometry    *wavyGeometry    = RpAtomicGetGeometry(ms_pWavyAtomic);
-	ASSERT(wavyGeometry    != NULL );
+	ASSERT(wavyGeometry    != nil );
 	RpMorphTarget *wavyMorphTarget = RpGeometryGetMorphTarget(wavyGeometry, 0);
 	RpMaterial    *wavyMaterial    = RpGeometryGetMaterial(wavyGeometry, 0);
 
-	ASSERT(wavyMorphTarget != NULL );
-	ASSERT(wavyMaterial    != NULL );
+	ASSERT(wavyMorphTarget != nil );
+	ASSERT(wavyMaterial    != nil );
 
 	for ( int32 geom = 0; geom < MAX_BOAT_WAKES; geom++ )
 	{
-		if ( apGeomArray[geom] == NULL )
+		if ( apGeomArray[geom] == nil )
 		{
 			apGeomArray[geom] = RpGeometryCreate(9*9, 8*8*2, rpGEOMETRYTRISTRIP
 															| rpGEOMETRYPRELIT
 															| rpGEOMETRYMODULATEMATERIALCOLOR
 															| rpGEOMETRYTEXTURED);
-			ASSERT(apGeomArray[geom] != NULL);
+			ASSERT(apGeomArray[geom] != nil);
 
 			RpTriangle *geomTriangles = RpGeometryGetTriangles(apGeomArray[geom]);
 			
-			ASSERT( geomTriangles != NULL );
+			ASSERT( geomTriangles != nil );
 
 			for ( int32 i = 0; i < 8; i++ )
 			{
@@ -1216,8 +1519,8 @@ CWaterLevel::AllocateBoatWakeArray()
 			RpMorphTarget *geomMorphTarget = RpGeometryGetMorphTarget(apGeomArray[geom], 0);
 			RwV3d         *geomVertices    = RpMorphTargetGetVertices(geomMorphTarget);
 			
-			ASSERT( geomMorphTarget != NULL );
-			ASSERT( geomVertices != NULL );
+			ASSERT( geomMorphTarget != nil );
+			ASSERT( geomVertices != nil );
 
 			for ( int32 i = 0; i < 9; i++ )
 			{
@@ -1242,10 +1545,10 @@ CWaterLevel::FreeBoatWakeArray()
 {
 	for ( int32 i = 0; i < MAX_BOAT_WAKES; i++ )
 	{
-		if ( apGeomArray[i] != NULL )
+		if ( apGeomArray[i] != nil )
 		{
 			RpGeometryDestroy(apGeomArray[i]);
-			apGeomArray[i] = NULL;
+			apGeomArray[i] = nil;
 		}
 	}
 	
diff --git a/src/render/WaterLevel.h b/src/render/WaterLevel.h
index 269d6091..cf3537ae 100644
--- a/src/render/WaterLevel.h
+++ b/src/render/WaterLevel.h
@@ -1,9 +1,9 @@
 #pragma once
 
-#define WATER_BLOCK_SIZE     LARGE_SECTOR_SIZE
-#define WATER_FINEBLOCK_SIZE HUGE_SECTOR_SIZE
 #define WATER_Z_OFFSET (1.5f)
 
+#define NO_WATER -128
+
 #define MAX_SMALL_SECTORS      128
 #define MAX_LARGE_SECTORS      64
 #define MAX_HUGE_SECTORS       32
@@ -23,7 +23,6 @@
 #define WATER_WIDTH		((WATER_END_X - WATER_START_X))
 #define WATER_HEIGHT	((WATER_END_Y - WATER_START_Y))
 
-
 #define WATER_UNSIGN_X(x)                   ( (x) + (WATER_WIDTH /2) )
 #define WATER_UNSIGN_Y(y)                   ( (y) + (WATER_HEIGHT/2) )
 #define WATER_SIGN_X(x)                     ( (x) - (WATER_WIDTH /2) )
@@ -72,8 +71,8 @@ class CWaterLevel
 	static int32       ms_nNoOfWaterLevels;
 	static float       ms_aWaterZs[48];
 	static CRect       ms_aWaterRects[48];
-	static uint8       aWaterBlockList[WATER_BLOCK_SIZE][WATER_BLOCK_SIZE];
-	static uint8       aWaterFineBlockList[WATER_FINEBLOCK_SIZE][WATER_FINEBLOCK_SIZE];
+	static int8        aWaterBlockList[MAX_LARGE_SECTORS][MAX_LARGE_SECTORS];
+	static int8        aWaterFineBlockList[MAX_SMALL_SECTORS][MAX_SMALL_SECTORS];
 	static bool        WavesCalculatedThisFrame;
 	static RpAtomic   *ms_pWavyAtomic;
 	static RpGeometry *apGeomArray[MAX_BOAT_WAKES];
@@ -84,6 +83,10 @@ public:
 	static void    Shutdown();
 	static void    CreateWavyAtomic();
 	static void    DestroyWavyAtomic();
+	static void    AddWaterLevel(float fXLeft, float fYBottom, float fXRight, float fYTop, float fLevel);
+	static bool    WaterLevelAccordingToRectangles(float fX, float fY, float *pfOutLevel = nil);
+	static bool    TestVisibilityForFineWaterBlocks(const CVector &worldPos);
+	static void    RemoveIsolatedWater();
 	static bool    GetWaterLevel(float fX, float fY, float fZ, float *pfOutLevel, bool bDontCheckZ);
 	static bool    GetWaterLevel(CVector coors, float *pfOutLevel, bool bDontCheckZ) { return GetWaterLevel(coors.x, coors.y, coors.z, pfOutLevel, bDontCheckZ); }
 	static bool    GetWaterLevelNoWaves(float fX, float fY, float fZ, float *pfOutLevel);
diff --git a/src/render/Weather.cpp b/src/render/Weather.cpp
index f16467b6..e765f306 100644
--- a/src/render/Weather.cpp
+++ b/src/render/Weather.cpp
@@ -359,7 +359,7 @@ void CWeather::AddRain()
 		RwCameraGetFarClipPlane(TheCamera.m_pRwCamera) / (RwCameraGetFarClipPlane(TheCamera.m_pRwCamera) * *(CVector2D*)RwCameraGetViewWindow(TheCamera.m_pRwCamera)).Magnitude();
 	splash_points[3] = 4.0f * CVector(RwCameraGetViewWindow(TheCamera.m_pRwCamera)->x, RwCameraGetViewWindow(TheCamera.m_pRwCamera)->y, 1.0f) *
 		RwCameraGetFarClipPlane(TheCamera.m_pRwCamera) / (RwCameraGetFarClipPlane(TheCamera.m_pRwCamera) * *(CVector2D*)RwCameraGetViewWindow(TheCamera.m_pRwCamera)).Magnitude();
-	RwV3dTransformPoints((RwV3d*)splash_points, (RwV3d*)splash_points, 4, RwFrameGetMatrix(RwCameraGetFrame(TheCamera.m_pRwCamera)));
+	RwV3dTransformPoints(splash_points, splash_points, 4, RwFrameGetMatrix(RwCameraGetFrame(TheCamera.m_pRwCamera)));
 	CVector fp = (splash_points[0] + splash_points[1] + splash_points[2] + splash_points[3]) / 4;
 	for (int i = 0; i < num_splash_attempts; i++) {
 		CColPoint point;