HUD scale should not affect chat (Thanks bludude4), start work on singleplayer generator.

ClassicalSharp/2D/Screens/ChatScreen.cs

@@ -79,13 +79,13 @@ namespace ClassicalSharp {
 		
 		Font chatFont, chatInputFont, chatUnderlineFont, announcementFont;
 		public override void Init() {
-			int fontSize = (int)(12 * game.GuiScale * game.ChatScale);
+			int fontSize = (int)(12 * game.GuiChatScale);
 			Utils.Clamp( ref fontSize, 8, 60 );		
 			chatFont = new Font( "Arial", fontSize );
 			chatInputFont = new Font( "Arial", fontSize, FontStyle.Bold );
 			chatUnderlineFont = new Font( "Arial", fontSize, FontStyle.Underline );
 			
-			fontSize = (int)(14 * game.GuiScale);
+			fontSize = (int)(14 * game.GuiChatScale);
 			Utils.Clamp( ref fontSize, 8, 60 );
 			announcementFont = new Font( "Arial", fontSize );
 			blockSize = (int)(23 * 2 * game.GuiScale);

ClassicalSharp/ClassicalSharp.csproj

@@ -141,6 +141,8 @@
     <Compile Include="Entities\LocationUpdate.cs" />
     <Compile Include="Entities\NetPlayer.cs" />
     <Compile Include="Game\Game.Properties.cs" />
+    <Compile Include="Generator\Noise.cs" />
+    <Compile Include="Generator\NotchGenerator.cs" />
     <Compile Include="Particles\CollidableParticle.cs" />
     <Compile Include="Particles\Particle.cs" />
     <Compile Include="Particles\ParticleManager.cs" />
@@ -265,6 +267,7 @@
     <Folder Include="2D\Widgets\Menu" />
     <Folder Include="2D\Widgets\Chat" />
     <Folder Include="Blocks" />
+    <Folder Include="Generator" />
     <Folder Include="Particles" />
     <Folder Include="GraphicsAPI" />
     <Folder Include="Entities" />

ClassicalSharp/Game/Game.Properties.cs

@@ -130,6 +130,16 @@ namespace ClassicalSharp {
 			}
 		}
 		
+		/// <summary> Calculates the amount that 2D chat widgets should be scaled by when rendered. </summary>
+		/// <remarks> Affected by both the current resolution of the window, as well as the
+		/// scaling specified by the user (field ChatScale). </remarks>
+		public float GuiChatScale {
+			get {
+				float scaleX = Width / 640f, scaleY = Height / 480f;
+				return Math.Min( scaleX, scaleY ) * ChatScale;
+			}
+		}
+		
 		string defTexturePack = "default.zip";
 		/// <summary> Gets or sets the path of the default texture pack that should be used by the client. </summary>
 		/// <remarks> If the custom default texture pack specified by the user could not be found,

ClassicalSharp/Generator/Noise.cs

@@ -0,0 +1,114 @@
+// Source from http://mrl.nyu.edu/~perlin/noise/
+// Optimised form as we can always treat Z as being = 0.
+// Octave and combined noise based on:
+// https://github.com/UnknownShadow200/ClassicalSharp/wiki/Minecraft-Classic-map-generation-algorithm
+using System;
+
+namespace ClassicalSharp.Generator {
+	
+	// TODO:L calculate based on seed
+	public abstract class Noise {
+		
+		public abstract double Compute( double x, double y );
+	}
+	
+	public sealed class ImprovedNoise : Noise {
+		
+		public override double Compute( double x, double y ) {
+			// Find unit rectangle that contains point
+			int X = (int)Math.Floor( x ) & 255;
+			int Y = (int)Math.Floor( y ) & 255;
+			// Find relative x, y of each point in rectangle.
+			x -= Math.Floor( x );
+			y -= Math.Floor( y );
+			
+			// Compute fade curves for each of x, y.
+			double u = Fade( x ), v = Fade( y );
+			// Hash coordinates of the 4 rectangle corners.
+			int A = p[X] + Y, AA = p[A], AB = p[A + 1],
+			B = p[X + 1] + Y, BA = p[B], BB = p[B + 1];
+
+			// and add blended results from 4 corners of rectangle.
+			return Lerp(
+				v,
+				Lerp( u, Grad( p[AA], x, y, 0 ),
+				     Grad( p[BA], x - 1, y, 0 ) ),
+				Lerp( u, Grad( p[AB], x, y - 1, 0 ),
+				     Grad( p[BB], x - 1, y - 1, 0 ) )
+			);
+		}
+		
+		static double Fade( double t ) {
+			return t * t * t * (t * (t * 6 - 15) + 10);
+		}
+		
+		static double Lerp( double t, double a, double b ) {
+			return a + t * (b - a);
+		}
+		
+		static double Grad( int hash, double x, double y, double z ) {
+			// convert low 4 bits of hash code into 12 gradient directions.
+			int h = hash & 15;
+			double u = h < 8 ? x : y;
+			double v = h < 4 ? y : h == 12 || h == 14 ? x : z;
+			return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
+		}
+		
+		static int[] p = new int[512];
+		static int[] permutation = { 151,160,137,91,90,15,
+			131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,
+			190, 6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,
+			88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,134,139,48,27,166,
+			77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,
+			102,143,54, 65,25,63,161, 1,216,80,73,209,76,132,187,208, 89,18,169,200,196,
+			135,130,116,188,159,86,164,100,109,198,173,186, 3,64,52,217,226,250,124,123,
+			5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,
+			223,183,170,213,119,248,152, 2,44,154,163, 70,221,153,101,155,167, 43,172,9,
+			129,22,39,253, 19,98,108,110,79,113,224,232,178,185, 112,104,218,246,97,228,
+			251,34,242,193,238,210,144,12,191,179,162,241, 81,51,145,235,249,14,239,107,
+			49,192,214, 31,181,199,106,157,184, 84,204,176,115,121,50,45,127, 4,150,254,
+			138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180
+		};
+		
+		static ImprovedNoise() {
+			for( int i = 0; i < 256; i++ )
+				p[256+i] = p[i] = permutation[i];
+		}
+	}
+	
+	
+	public sealed class OctaveNoise : Noise {
+		
+		readonly int octaves;
+		readonly ImprovedNoise baseNoise;
+		public OctaveNoise( int octaves ) {
+			this.octaves = octaves;
+			baseNoise = new ImprovedNoise();
+		}
+		
+		public override double Compute( double x, double y ) {
+			double amplitude = 1, frequency = 1;
+			double sum = 0;
+			for( int i = 0; i < octaves; i++ ) {
+				sum += baseNoise.Compute( x * frequency, y * frequency ) * amplitude;
+				amplitude *= 2;
+				frequency /= 2;
+			}
+			return sum;
+		}
+	}
+	
+	public sealed class CombinedNoise : Noise {
+		
+		readonly Noise noise1, noise2;
+		public CombinedNoise( Noise noise1, Noise noise2 ) {
+			this.noise1 = noise1;
+			this.noise2 = noise2;
+		}
+		
+		public override double Compute( double x, double y ) {
+			double offset = noise2.Compute( x, y );
+			return noise1.Compute( x + offset, y );
+		}
+	}
+}

ClassicalSharp/Generator/NotchGenerator.cs

@@ -0,0 +1,35 @@
+// Based on:
+// https://github.com/UnknownShadow200/ClassicalSharp/wiki/Minecraft-Classic-map-generation-algorithm
+using System;
+using System;
+
+namespace ClassicalSharp.Generator {
+	
+	// TODO: figure out how noise functions differ, probably based on rnd.
+	public class NotchGenerator {
+		
+		int width, height, length;
+		int waterLevel;
+		
+		
+		short[] CreateHeightmap() {
+			Noise n1 = new CombinedNoise(
+				new OctaveNoise( 8 ), new OctaveNoise( 8 ) );
+			Noise n2 = new CombinedNoise(
+				new OctaveNoise( 8 ), new OctaveNoise( 8 ) );
+			Noise n3 = new OctaveNoise( 6 );			
+			int index = 0;
+			short[] map = new short[width * length];
+			
+			for( int z = 0; z < length; z++ ) {
+				for( int x = 0; x < width; x++ ) {
+					float hLow = n1.Compute( x * 1.3f, z * 1.3f ) / 6 - 4;
+					float hHigh = n2.Compute( x * 1.3f, z * 1.3f ) / 5 + 6;
+					
+					float height = n3.Compute( x, z ) > 0 ? hLow : Math.Max( hLow, hHigh );
+					if( height < 0 ) height *= 0.8f;
+					map[index++] = (short)(height + waterLevel);
+				}
+			}
+		}
+	}