186 files changed, 10585 insertions, 4062 deletions

diff --git a/MCServer/Plugins/APIDump/APIDesc.lua b/MCServer/Plugins/APIDump/APIDesc.lua
index 2f791293d..e6ee4ca10 100644
--- a/MCServer/Plugins/APIDump/APIDesc.lua
+++ b/MCServer/Plugins/APIDump/APIDesc.lua
@@ -1634,6 +1634,11 @@ a_Player:OpenWindow(Window);
 			]],
 			Functions =
 			{
+				HasCustomName = { Params = "", Return = "bool", Notes = "Returns true if the monster has a custom name." },
+				GetCustomName = { Params = "", Return = "string", Notes = "Gets the custom name of the monster. If no custom name is set, the function returns an empty string." },
+				SetCustomName = { Params = "string", Return = "", Notes = "Sets the custom name of the monster. You see the name over the monster. If you want to disable the custom name, simply set an empty string." },
+				IsCustomNameAlwaysVisible = { Params = "", Return = "bool", Notes = "Is the custom name of this monster always visible? If not, you only see the name when you sight the mob." },
+				SetCustomNameAlwaysVisible = { Params = "bool", Return = "", Notes = "Sets the custom name visiblity of this monster. If it's false, you only see the name when you sight the mob. If it's true, you always see the custom name." },
 				FamilyFromType = { Params = "{{cMonster#MobType|MobType}}", Return = "{{cMonster#MobFamily|MobFamily}}", Notes = "(STATIC) Returns the mob family ({{cMonster#MobFamily|mfXXX}} constants) based on the mob type ({{cMonster#MobType|mtXXX}} constants)" },
 				GetMobFamily = { Params = "", Return = "{{cMonster#MobFamily|MobFamily}}", Notes = "Returns this mob's family ({{cMonster#MobFamily|mfXXX}} constant)" },
 				GetMobType = { Params = "", Return = "{{cMonster#MobType|MobType}}", Notes = "Returns the type of this mob ({{cMonster#MobType|mtXXX}} constant)" },
@@ -1759,6 +1764,7 @@ a_Player:OpenWindow(Window);
 				ForceSetSpeed = { Params = "{{Vector3d|Direction}}", Notes = "Forces the player to move to the given direction." },
 				GetClientHandle = { Params = "", Return = "{{cClientHandle}}", Notes = "Returns the client handle representing the player's connection. May be nil (AI players)." },
 				GetColor = { Return = "string", Notes = "Returns the full color code to be used for this player's messages (based on their rank). Prefix player messages with this code." },
+				GetPlayerListName = { Return = "string", Notes = "Returns the name that is used in the playerlist." },
 				GetCurrentXp = { Params = "", Return = "number", Notes = "Returns the current amount of XP" },
 				GetEffectiveGameMode = { Params = "", Return = "{{Globals#GameMode|GameMode}}", Notes = "(OBSOLETE) Returns the current resolved game mode of the player. If the player is set to inherit the world's gamemode, returns that instead. See also GetGameMode() and IsGameModeXXX() functions. Note that this function is the same as GetGameMode(), use that function instead." },
 				GetEquippedItem = { Params = "", Return = "{{cItem}}", Notes = "Returns the item that the player is currently holding; empty item if holding nothing." },
@@ -1809,6 +1815,9 @@ a_Player:OpenWindow(Window);
 				SendMessagePrivateMsg = { Params = "Message, SenderName", Return = "", Notes = "Prepends Light Blue [MSG: *SenderName*] / prepends SenderName and colours entire text (depending on ShouldUseChatPrefixes()) and sends message to player. For private messaging." },
 				SendMessageSuccess = { Params = "Message", Return = "", Notes = "Prepends Green [INFO] / colours entire text (depending on ShouldUseChatPrefixes()) and sends message to player. Success notification." },
 				SendMessageWarning = { Params = "Message, Sender", Return = "", Notes = "Prepends Rose [WARN] / colours entire text (depending on ShouldUseChatPrefixes()) and sends message to player. Denotes that something concerning, such as plugin reload, is about to happen." },
+				HasCustomName = { Params = "", Return = "bool", Notes = "Returns true if the player has a custom name." },
+				GetCustomName = { Params = "", Return = "string", Notes = "Returns the custom name of this player. If the player hasn't a custom name, it will return an empty string." },
+				SetCustomName = { Params = "string", Return = "", Notes = "Sets the custom name of this player. If you want to disable the custom name, simply set an empty string. The custom name will be used in the tab-list, in the player nametag and in the tab-completion." },
 				SetCanFly = { Params = "CanFly", Notes = "Sets if the player can fly or not." },
 				SetCrouch = { Params = "IsCrouched", Return = "", Notes = "Sets the crouch state, broadcasts the change to other players." },
 				SetCurrentExperience = { Params = "XPAmount", Return = "", Notes = "Sets the current amount of experience (and indirectly, the XP level)." },
diff --git a/MCServer/Plugins/APIDump/Hooks/OnSpawningEntity.lua b/MCServer/Plugins/APIDump/Hooks/OnSpawningEntity.lua
index c4bff3916..e2bd1c940 100644
--- a/MCServer/Plugins/APIDump/Hooks/OnSpawningEntity.lua
+++ b/MCServer/Plugins/APIDump/Hooks/OnSpawningEntity.lua
@@ -6,8 +6,9 @@ return
 		DefaultFnName = "OnSpawningEntity",  -- also used as pagename
 		Desc = [[
 			This hook is called before the server spawns an {{cEntity|entity}}. The plugin can either modify the
-			entity before it is spawned, or disable the spawning altogether. If the entity spawning is a
-			monster, the {{OnSpawningMonster|HOOK_SPAWNING_MONSTER}} hook is called before this hook.</p>
+			entity before it is spawned, or disable the spawning altogether. You can't disable the spawning if the
+			entity is a player. If the entity spawning is a monster, the {{OnSpawningMonster|HOOK_SPAWNING_MONSTER}}
+			hook is called before this hook.</p>
 			<p>
 			See also the {{OnSpawnedEntity|HOOK_SPAWNED_ENTITY}} hook for a similar hook called after the
 			entity is spawned.
diff --git a/MCServer/Plugins/Debuggers/Debuggers.lua b/MCServer/Plugins/Debuggers/Debuggers.lua
index 66e06cb72..f66ac76a0 100644
--- a/MCServer/Plugins/Debuggers/Debuggers.lua
+++ b/MCServer/Plugins/Debuggers/Debuggers.lua
@@ -38,6 +38,7 @@ function Initialize(Plugin)
 	-- _X: Disabled so that the normal operation doesn't interfere with anything
 	-- PM:AddHook(cPluginManager.HOOK_CHUNK_GENERATED,              OnChunkGenerated);
 
+	PM:BindCommand("/nick",    "debuggers", HandleNickCmd,         "- Gives you a custom name");
 	PM:BindCommand("/le",      "debuggers", HandleListEntitiesCmd, "- Shows a list of all the loaded entities");
 	PM:BindCommand("/ke",      "debuggers", HandleKillEntitiesCmd, "- Kills all the loaded entities");
 	PM:BindCommand("/wool",    "debuggers", HandleWoolCmd,         "- Sets all your armor to blue wool");
@@ -770,6 +771,21 @@ end
 
 
 
+function HandleNickCmd(Split, Player)
+	if (Split[2] == nil) then
+		Player:SendMessage("Usage: /nick [CustomName]");
+		return true;
+	end
+
+	Player:SetCustomName(Split[2]);
+	Player:SendMessageSuccess("Custom name setted to " .. Player:GetCustomName() .. "!")
+	return true
+end
+
+
+
+
+
 function HandleListEntitiesCmd(Split, Player)
 	local NumEntities = 0;
 	
diff --git a/MCServer/crafting.txt b/MCServer/crafting.txt
index 1236ab10e..8e68d5cb5 100644
--- a/MCServer/crafting.txt
+++ b/MCServer/crafting.txt
@@ -348,6 +348,7 @@ Emerald, 9      = EmeraldBlock, *
 RedstoneDust, 9 = RedstoneBlock, *
 Coal, 9         = CoalBlock, *
 Clay, 4         = ClayBlock, *
+SlimeBall, 9    = SlimeBlock, *
 
 Painting            = Stick, 1:1, 1:2, 1:3, 2:1, 2:3, 3:1, 3:2, 3:3   | Wool, 2:2
 ItemFrame           = Stick, 1:1, 1:2, 1:3, 2:1, 2:3, 3:1, 3:2, 3:3   | Leather, 2:2
diff --git a/MCServer/items.ini b/MCServer/items.ini
index 380c13e02..daf366654 100644
--- a/MCServer/items.ini
+++ b/MCServer/items.ini
@@ -1,5 +1,6 @@
 [Items]
 air=0
+stone=1
 rock=1
 granite=1:1
 polishedgranite=1:2
@@ -7,7 +8,6 @@ diorite=1:3
 polisheddiorite=1:4
 andesite=1:5
 polishedandesite=1:6
-stone=1
 grass=2
 dirt=3
 coarseddirt=3:1
@@ -410,7 +410,7 @@ lightgraystainedclay=159:8
 lightgreystainedclay=159:8
 ltgraystainedclay=159:8
 ltgreystainedclay=159:8
-silvertsainedclay=159:8
+silverstainedclay=159:8
 cyanstainedclay=159:9
 purplestainedclay=159:10
 violetstainedclay=159:10
@@ -471,6 +471,7 @@ darkoakwoodstairs=164
 bigoakwoodstiars=164
 roofedoakwoodstairs=164
 slimeblock=165
+barrier=166
 irontrapdoor=167
 prismarine=168
 prismarinebricks=168:1
@@ -525,7 +526,8 @@ redsandstone=179
 chiseledredsandstone=179:1
 smoothredsandstone=179:2
 redsandstonestairs=180
-redsandstoneslab=182
+newstoneslab=182
+redsandstoneslab=182:0
 sprucefencegate=183
 coniferfencegate=183
 pinefencegate=183
@@ -698,7 +700,11 @@ lightdust=348
 glowdust=348
 fish=349
 rawfish=349
+rawsalmon=349:1
+clownfish=349:2
+pufferfish=349:3
 cookedfish=350
+cookedsalmon=350:1
 dye=351
 inksac=351:0
 blackdye=351:0
diff --git a/MCServer/lang/items_de.ini b/MCServer/lang/items_de.ini
new file mode 100644
index 000000000..3c2ab87d1
--- /dev/null
+++ b/MCServer/lang/items_de.ini
@@ -0,0 +1,603 @@
+[Items]
+luft=0
+stein=1
+granit=1:1
+poliertergranit=1:2
+diorit=1:3
+polierterdiorit=1:4
+andesit=1:5
+polierterandesit=1:6
+grasblock=2
+erde=3
+grobeerde=3:1
+podsol=3:2
+bruchstein=4
+holzbretter=5
+eichenholzbretter=5:0
+fichtenholzbretter=5:1
+birkenholzbretter=5:2
+tropenholzbretter=5:3
+akazienholzbretter=5:4
+schwarzeichenholzbretter=5:5
+setzling=6
+eichensetzling=6:0
+fichtensetzling=6:1
+birkensetzling=6:2
+tropensetzling=6:3
+akaziensetzling=6:4
+schwarzeichensetzling=6:5
+grundgestein=7
+wasser=8
+fliessendeswasser=8
+stehendeswasser=9
+stilleswasser=9
+swasser=9
+lava=10
+fliessendelava=10
+stehendelava=11
+stillelava=11
+slava=11
+sand=12
+rotersand=12:1
+kies=13
+golderz=14
+eisenerz=15
+kohleerz=16
+stamm=17
+eichenholz=17:0
+fichtenholz=17:1
+birkenholz=17:2
+tropenholz=17:3
+laub=18
+eichenlaub=18:0
+fichtenlaub=18:1
+birkenlaub=18:2
+tropenlaub=18:3
+schwamm=19
+nasserschwamm=19:1
+glas=20
+lapislazulierz=21
+lapislazuliblock=22
+werfer=23
+sandstein=24
+normalersandstein=24:0
+gemeisseltersandstein=24:1
+glattersandstein=24:2
+notenblock=25
+bettblock=26
+antriebsschiene=27
+sensorschiene=28
+klebrigerkolben=29
+spinnenweben=30
+gras=31
+gras=31:1
+farn=31:2
+toterbusch=32
+kolben=33
+kolbenkopf=34
+wolle=35
+weissewolle=35:0
+orangenewolle=35:1
+magentawolle=35:2
+hellblauewolle=35:3
+gelbewolle=35:4
+hellgruene=35:5
+rosawolle=35:6
+grauwool=35:7
+greywool=35:7
+grauewolle=35:7
+hellgrauewolle=35:8
+tuerkisewolle=35:9
+violettewolle=35:10
+blauewolle=35:11
+braunewolle=35:12
+gruenewolle=35:13
+rotewolle=35:14
+schwarzewolle=35:15
+loewenzahn=37
+blume=38
+mohn=38:0
+blaueorchidee=38:1
+sternlauch=38:2
+porzellansternchen=38:3
+rotetulpe=38:4
+orangenetulpe=38:5
+weissetulpe=38:6
+rosatulpe=38:7
+margerite=38:8
+braunerpilz=39
+roterpilz=40
+goldblock=41
+eisenblock=42
+doppelstufe=43
+doppelsteinstufe=43:0
+doppelsandsteinstufe=43:1
+doppelholzstufe=43:2
+doppelbruchsteinstufe=43:3
+doppelziegelstufe=43:4
+doppelsteinziegelstufe=43:5
+doppelnetherziegelstufe=43:6
+doppelquarzstufe=43:7
+stufe=44
+steinstufe=44:0
+sandsteinstufe=44:1
+holzstufe=44:2
+bruchsteinstufe=44:3
+ziegelstufe=44:4
+steinziegelstufe=44:5
+netherziegelstufe=44:6
+quarzstufe=44:7
+ziegelsteine=45
+tnt=46
+buecherregal=47
+bemoosterbruchstein=48
+obsidian=49
+fackel=50
+feuer=51
+monsterspawner=52
+eichenholztreppe=53
+kiste=54
+rotstonekabel=55
+diamanterz=56
+diamantblock=57
+werkbank=58
+ernte=59
+farmland=60
+ofen=61
+brennenderofen=62
+schildblock=63
+holztuerblock=64
+leiter=65
+schiene=66
+bruchsteintreppe=67
+wandschild=68
+schalter=69
+steindruckplatte=70
+eisentuerblock=71
+holzdruckplatte=72
+rotstoneerz=73
+leuchtendesrotstoneerz=74
+erloschenerotstonefackel=75
+rotstonefackel=76
+setinknopf=77
+schnee=78
+eis=79
+schneeblock=80
+kaktus=81
+ton=82
+zuckerrohrblock=83
+plattenspieler=84
+eichenholzzaun=85
+kuerbis=86
+netherstein=87
+selensand=88
+leuchtstein=89
+portal=90
+kürbislaterne=91
+kuchenlock=92
+weissesglas=95
+orangenesglas=95:1
+magentaglas=95:2
+hellblauesglas=95:3
+gelbesglas=95:4
+hellgruenesglas=95:5
+rosagerfaerbtglas=95:6
+grauesglas=95:7
+hellgrauesglas=95:8
+tuerkisesglas=95:9
+violettesglas=95:10
+blauesglas=95:11
+braunesglas=95:12
+gruenesglas=95:13
+rotesglas=95:14
+schwarzesglas=95:15
+falltuer=96
+silberfischblock=97
+steinziegel=98
+bemoostesteinziegel=98:1
+rissigesteinziegel=98:2
+gemeisseltesteinziegel=98:3
+braunerpilzblock=99
+roterpilzblock=100
+eisengitter=101
+glasscheibe=102
+melone=103
+kuerbispflanze=104
+melonenpflanze=105
+ranken=106
+eichenholzzauntor=107
+ziegeltreppe=108
+steinziegeltreppe=109
+myzel=110
+seerosenblatt=111
+netherziegel=112
+netherziegelzaun=113
+netherziegeltreppe=114
+netherwarzenblock=115
+zaubertisch=116
+braustandblock=117
+kesselblock=118
+endportal=119
+endportalrahmen=120
+endstein=121
+drachenei=122
+redstonelampe=123
+erlosscheneredstonelampe=124
+doppelholzstufe=125
+doppeleichenholzstufe=125:0
+doppelfichtenholzstufe=125:1
+doppelbirkenholzstufe=125:2
+doppeltropenholzstufe=125:3
+doppelakazienholzstufe=125:4
+doppelschwarzeichenstufe=125:5
+holzstufe=126
+eichenholzstufe=126:0
+fichtenholzstufe=126:1
+birkenholzstufe=126:2
+tropenholzstufe=126:3
+akazienholzstufe=126:4
+schwarzeichenholzstufe=126:5
+kakaobohnen=127
+sandsteintreppe=128
+smaragderz=129
+endertruhe=130
+haken=131
+stolperdraht=132
+smaragdblock=133
+fichtenholztreppe=134
+birkenholztreppe=135
+tropenholztreppe=136
+kommandoblock=137
+leuchtfeuer=138
+bruchsteinmauer=139
+bemoostebruchsteinmauer=139:1
+blumentopfblock=140
+karottenpflanze=141
+kartoffelpflanze=142
+knopf=143
+skelettschaedel=144
+witherskelettschaedel=144:1
+zombieschaedel=144:2
+schaedel=144:3
+creeperschaedel=144:4
+amboss=145
+redstonetruhe=146
+waegeplatteniedrigegewichte=147 # WTF, that names are so stupid...
+waegeplattehohegewichte=148
+inaktiverkomparator=149
+aktiverkomparator=150
+tageslichtsensor=151
+redstoneblock=152
+netherquarzerz=153
+trichter=154
+quarzblock=155
+gemeisselterquarzblock=155:1
+quarzsaeule=155:2
+quarztreppe=156
+aktivierungsschiene=157
+spender=158
+weissgerfaerbterton=159
+orangegerfaerbterton=159:1
+magentagerfaerbterton=159:2
+hellblaugerfaerbterton=159:3
+gelbgerfaerbterton=159:4
+hellgruengerfaerbterton=159:5
+rosagerfaerbterton=159:6
+graugerfaerbterton=159:7
+hellgraugefaerbterton=159:8
+tuerkisgerfaerbterton=159:9
+purplegerfaerbterton=159:10
+violettegerfaerbterton=159:10
+blaugerfaerbterton=159:11
+braungerfaerbterton=159:12
+gruengerfaerbterton=159:13
+rotgerfaerbterton=159:14
+schwarzgerfaerbterton=159:15
+weisseglasscheibe=160
+orangeneglasscheibe=160:1
+magentaglasscheibe=160:2
+hellblaueglasscheibe=160:3
+gelbeglasscheibe=160:4
+hellgrueneglasscheibe=160:5
+rosaglasscheibe=160:6
+graueglasscheibe=160:7
+hellgraueglasscheibe=160:8
+tuerkiseglasscheibe=160:9
+violetteglasscheibe=160:10
+blaueglasscheibe=160:11
+brauneglasscheibe=160:12
+grueneglasscheibe=160:13
+roteglasscheibe=160:14
+schwarzeglasscheibe=160:15
+neueslaub=161
+akazienlaub=161:0
+schwarzeichenlaub=161:1
+neuestaemme=162
+akazienholz=162:0
+schwarzeichenholz=162:1
+akazientreppe=163
+schwarzeichentreppe=164
+schleimblock=165
+bartriere=166
+eisenfalltür=167
+prismarin=168
+prismarinziegel=168:1
+dunklerprismarin=168:2
+seelaterne=169
+strohballen=170
+teppich=171
+weisserteppich=171:0
+orangenerteppich=171:1
+magentateppich=171:2
+hellblauerteppich=171:3
+gelberteppich=171:4
+hellgruenerteppich=171:5
+rosateppich=171:6
+grauerteppich=171:7
+hellgrauerteppich=171:8
+tuerkiserteppich=171:9
+violetterteppich=171:10
+blauerteppich=171:11
+braunerteppich=171:12
+gruenerteppich=171:13
+roterteppich=171:14
+schwarzerteppich=171:15
+gebrannterton=172
+kohleblock=173
+packeis=174
+doppelpflanze=175
+sonnenblume=175:0
+Flieder=175:1
+hohesgras=175:2
+grosserfarn=175:3
+rosenstrauch=175:4
+pfingstrose=175:5
+rotersandstein=179
+gemeisselterrotersandstein=179:1
+glatterrotersandstein=179:2
+rotesandsteintreppe=180
+neuesteinstufe=182
+rotesandsteinstufe=182:0
+fichtenzauntor=183
+birkenzauntor=184
+tropenzauntor=185
+schwarzeichenzauntor=186
+akazienzauntor=187
+fichtenzaun=188
+birkenzaun=189
+tropenzaun=190
+schwarzeichenzaun=191
+akazienzaun=192
+eisenschaufel=256
+eisenspitzhacke=257
+eisenaxt=258
+feuerzeug=259
+apfel=260
+bogen=261
+pfeil=262
+kohle=263
+holzkohle=263:1
+diamant=264
+eisenbarren=265
+goldbarren=266
+eisenschwert=267
+holzschwert=268
+holzschaufel=269
+holzspitzhacke=270
+holzaxt=271
+steinschwert=272
+steinschaufel=273
+steinspitzhacke=274
+steinaxt=275
+diamantschwert=276
+diamantschaufel=277
+diamantspitzhacke=278
+diamantaxt=279
+stock=280
+schuessel=281
+pilzsuppe=282
+goldschwert=283
+goldschaufel=284
+goldspitzhacke=285
+goldaxt=286
+faden=287
+feder=288
+schwarzpulver=289
+holzhacke=290
+steinhacke=291
+eisenhacke=292
+diamanthacke=293
+goldhacke=294
+samen=295
+weizen=296
+brot=297
+lederkappe=298
+lederjacke=299
+lederhose=300
+lederstiefel=301
+kettenhaube=302
+kettenhemd=303
+kettenhose=304
+kettenstiefel=305
+eisenhelm=306
+eisenbrustplatte=307
+eisenbeinschutz=308
+eisenstiefel=309
+diamanthelm=310
+diamantbrustplatte=311
+diamantbeinschutz=312
+diamantstiefel=313
+goldhelm=314
+goldharnisch=315
+goldbeinschutz=316
+goldstiefel=317
+goldboots=317
+feuerstein=318
+rohesschweinefleisch=319
+gebratenesschweinefleisch=320
+gemaelde=321
+goldenerapfel=322
+goldenerapfel=322:1
+schild=323
+eichenholztuer=324
+eimer=325
+wassereimer=326
+lavaeimer=327
+lore=328
+sattel=329
+eisentuer=330
+redstone=331
+schneeballl=332
+boot=333
+leder=334
+milcht=335
+ziegel=336
+ton=337
+zuckercane=338
+papier=339
+buch=340
+schleimball=341
+gueterlore=342
+angetriebenelore=343
+ei=344
+kompass=345
+angel=346
+uhr=347
+glowstonestaub=348
+fisch=349
+roherfisch=349
+roherlachs=349:1
+clownfisch=349:2
+kugelfisch=349:3
+gebratenerfisch=350
+gebratenerlachs=350:1
+farbe=351
+tintenbeutel=351:0
+rosenrot=351:1
+kaktusgruen=351:2
+kakaobohnen=351:3
+lapislazuli=351:4
+violetterfarbstoff=351:5
+tuerkiserfarbstoff=351:6
+hellgrauerfarbstoff=351:7
+grauerfarbstoff=351:8
+rosafarbstoff=351:9
+hellgruenerfarbstoff=351:10
+gelberfarbstoff=351:11
+hellblauerfarbstoff=351:12
+magentafarbstoff=351:13
+orangenerfarbstoff=351:14
+knochenmehl=351:15
+knochen=352
+zucker=353
+kuchen=354
+bett=355
+redstoneverstaerker=356
+keks=357
+karte=358
+schere=359
+melone=360
+kürbiskerne=361
+melonenkerne=362
+rohesrindfleisch=363
+steak=364
+roheshühnchen=365
+gebrateneshühnchen=366
+verrottetesfleisch=367
+enderperle=368
+lohenrute=369
+ghasttraene=370
+goldnugget=371
+netherwarze=372
+trank=373
+glasflasche=374
+spinnenauge=375
+fermentiertesspinnenauge=376
+lohenstaub=377
+magmacreme=378
+braustand=379
+kessel=380
+enderauge=381
+glitzerndemelone=382
+spawnei=383
+erfahrungsfläschchen=384
+feuerkugel=385
+buchundfeder=386
+beschriebenesbuch=387
+smaragd=388
+rahmen=389
+blumentopf=390
+karotte=391
+kartoffel=392
+ofenkartoffel=393
+giftigekartoffel=394
+leerekarte=395
+goldenekarotte=396
+skelettschaedel=397
+witherschaedel=397:1
+zombieschaedel=397:2
+kopf=397:3
+creeperschaedel=397:4
+karottenrute=398
+netherstern=399
+kuerbiskuchen=400
+feuerwerksrakete=401
+feuerwerksstern=402
+verzauberungsbuch=403
+redstonekomparator=404
+netherziegelitem=405
+netherquarz=406
+tntlore=407
+trichterlore=408
+prismarinscherbe=409
+prismarinkristalle=410
+roheskaninchen=411
+gebrateneskaninchen=412
+kaninchenragout=413
+hasenpfote=414
+kaninchenfell=415
+ruestungsstaender=416
+eisernepferderuestung=417
+goldenepferderuestung=418
+diamantenepferderuestung=419
+leine=420
+namensschild=421
+kommandoblocklore=422
+roheshammelfleisch=423
+gebrateneshammelfleisch=424
+banner=425
+schwarzesbanner=415:0
+rotesbanner=415:1
+gruenesbanner=415:2
+braunbanner=415:3
+blauesbanner=415:4
+violettesbanner=415:5
+tuerkisesbanner=415:6
+hellgrauesbanner=415:7
+grauesbanner=415:8
+rosabanner=415:9
+hellgruenesbanner=415:10
+gelbesbanner=415:11
+hellblauesbanner=415:12
+magentabanner=415:13
+orangenesbanner=415:14
+weissesbanner=415:15
+fichtenholztuer=427
+birkenholztuer=428
+tropentuer=429
+akazientuer=430
+schwarzeichentuer=431
+goldeneschallplatte=2256
+grueneschallplatte=2257
+blocksschallplatte=2258
+chirpschallplatte=2259
+farschallplatte=2260
+mallschallplatte=2261
+mellohischallplatte=2262
+stalschallplatte=2263
+stradschallplatte=2264
+wardschallplatte=2265
+11schallplatte=2266
+
+
+
diff --git a/README.md b/README.md
index 27166413e..b42467039 100644
--- a/README.md
+++ b/README.md
@@ -5,7 +5,7 @@ MCServer is a Minecraft server that is written in C++ and designed to be efficie
 
 MCServer can run on PCs, Macs, and *nix. This includes android phones and tablets as well as Raspberry Pis. 
 
-We currently support the protocol from Minecraft 1.2 all the way up to Minecraft 1.7.10.
+We currently support the protocol from Minecraft 1.2 all the way up to Minecraft 1.8.
 
 Installation
 ------------
diff --git a/Tools/QtBiomeVisualiser/BiomeView.cpp b/Tools/QtBiomeVisualiser/BiomeView.cpp
index bbaccb369..ce5a870cd 100644
--- a/Tools/QtBiomeVisualiser/BiomeView.cpp
+++ b/Tools/QtBiomeVisualiser/BiomeView.cpp
@@ -1,6 +1,6 @@
 #include "Globals.h"
 #include "BiomeView.h"
-#include "Chunk.h"
+#include "QtChunk.h"
 #include <QPainter>
 #include <QResizeEvent>
 
diff --git a/Tools/QtBiomeVisualiser/ChunkSource.cpp b/Tools/QtBiomeVisualiser/ChunkSource.cpp
index 2235816bc..bebf89a0a 100644
--- a/Tools/QtBiomeVisualiser/ChunkSource.cpp
+++ b/Tools/QtBiomeVisualiser/ChunkSource.cpp
@@ -1,7 +1,9 @@
 #include "Globals.h"
 #include "ChunkSource.h"
 #include <QThread>
-#include "Generating/BioGen.h"
+#include "src/Generating/BioGen.h"
+#include "src/StringCompression.h"
+#include "src/WorldStorage/FastNBT.h"
 #include "inifile/iniFile.h"
 
 
@@ -140,8 +142,8 @@ static void biomesToImage(cChunkDef::BiomeMap & a_Biomes, Chunk::Image & a_Image
 ////////////////////////////////////////////////////////////////////////////////
 // BioGenSource:
 
-BioGenSource::BioGenSource(QString a_WorldIniPath) :
-	m_WorldIniPath(a_WorldIniPath),
+BioGenSource::BioGenSource(cIniFilePtr a_IniFile) :
+	m_IniFile(a_IniFile),
 	m_Mtx(QMutex::Recursive)
 {
 	reload();
@@ -169,16 +171,251 @@ void BioGenSource::getChunkBiomes(int a_ChunkX, int a_ChunkZ, ChunkPtr a_DestChu
 
 void BioGenSource::reload()
 {
-	cIniFile ini;
-	ini.ReadFile(m_WorldIniPath.toStdString());
-	int seed = ini.GetValueSetI("Seed", "Seed", 0);
+	int seed = m_IniFile->GetValueSetI("Generator", "Seed", 0);
 	bool unused = false;
 	QMutexLocker lock(&m_Mtx);
-	m_BiomeGen.reset(cBiomeGen::CreateBiomeGen(ini, seed, unused));
-	lock.unlock();
-	ini.WriteFile(m_WorldIniPath.toStdString());
+	m_BiomeGen.reset(cBiomeGen::CreateBiomeGen(*m_IniFile, seed, unused));
 }
 
 
 
 
+
+////////////////////////////////////////////////////////////////////////////////
+// AnvilSource::AnvilFile
+
+class AnvilSource::AnvilFile
+{
+public:
+	/** Coordinates of the region file. */
+	int m_RegionX, m_RegionZ;
+
+	/** True iff the file contains proper data. */
+	bool m_IsValid;
+
+
+
+	/** Creates a new instance with the specified region coords. Reads the file header. */
+	AnvilFile(int a_RegionX, int a_RegionZ, const AString & a_WorldPath) :
+		m_RegionX(a_RegionX),
+		m_RegionZ(a_RegionZ),
+		m_IsValid(false)
+	{
+		readFile(Printf("%s/r.%d.%d.mca", a_WorldPath.c_str(), a_RegionX, a_RegionZ));
+	}
+
+
+
+	/** Returns the compressed data of the specified chunk.
+	Returns an empty string when chunk not present. */
+	AString getChunkData(int a_ChunkX, int a_ChunkZ)
+	{
+		if (!m_IsValid)
+		{
+			return "";
+		}
+
+		// Translate to local coords:
+		int RelChunkX = a_ChunkX - m_RegionX * 32;
+		int RelChunkZ = a_ChunkZ - m_RegionZ * 32;
+		ASSERT((RelChunkX >= 0) && (RelChunkX < 32));
+		ASSERT((RelChunkZ >= 0) && (RelChunkZ < 32));
+
+		// Get the chunk data location:
+		UInt32 chunkOffset = m_Header[RelChunkX + 32 * RelChunkZ] >> 8;
+		UInt32 numChunkSectors = m_Header[RelChunkX + 32 * RelChunkZ] & 0xff;
+		if ((chunkOffset < 2) || (numChunkSectors == 0))
+		{
+			return "";
+		}
+
+		// Get the real data size:
+		const char * chunkData = m_FileData.data() + chunkOffset * 4096;
+		UInt32 chunkSize = GetBEInt(chunkData);
+		if ((chunkSize < 2) || (chunkSize / 4096 > numChunkSectors))
+		{
+			// Bad data, bail out
+			return "";
+		}
+
+		// Check the compression method:
+		if (chunkData[4] != 2)
+		{
+			// Chunk is in an unknown compression
+			return "";
+		}
+		chunkSize--;
+
+		// Read the chunk data:
+		return m_FileData.substr(chunkOffset * 4096 + 5, chunkSize);
+	}
+
+protected:
+	AString m_FileData;
+	UInt32 m_Header[2048];
+
+
+	/** Reads the whole specified file contents and parses the header. */
+	void readFile(const AString & a_FileName)
+	{
+		// Read the entire file:
+		m_FileData = cFile::ReadWholeFile(a_FileName);
+		if (m_FileData.size() < sizeof(m_Header))
+		{
+			return;
+		}
+
+		// Parse the header - change endianness:
+		const char * hdr = m_FileData.data();
+		for (size_t i = 0; i < ARRAYCOUNT(m_Header); i++)
+		{
+			m_Header[i] = GetBEInt(hdr + 4 * i);
+		}
+		m_IsValid = true;
+	}
+};
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// AnvilSource:
+
+AnvilSource::AnvilSource(QString a_WorldRegionFolder) :
+	m_WorldRegionFolder(a_WorldRegionFolder)
+{
+}
+
+
+
+
+
+void AnvilSource::getChunkBiomes(int a_ChunkX, int a_ChunkZ, ChunkPtr a_DestChunk)
+{
+	// Load the compressed data:
+	AString compressedChunkData = getCompressedChunkData(a_ChunkX, a_ChunkZ);
+	if (compressedChunkData.empty())
+	{
+		return;
+	}
+
+	// Uncompress the chunk data:
+	AString uncompressed;
+	int res = InflateString(compressedChunkData.data(), compressedChunkData.size(), uncompressed);
+	if (res != Z_OK)
+	{
+		return;
+	}
+
+	// Parse the NBT data:
+	cParsedNBT nbt(uncompressed.data(), uncompressed.size());
+	if (!nbt.IsValid())
+	{
+		return;
+	}
+
+	// Get the biomes out of the NBT:
+	int Level = nbt.FindChildByName(0, "Level");
+	if (Level < 0)
+	{
+		return;
+	}
+	cChunkDef::BiomeMap biomeMap;
+	int mcsBiomes = nbt.FindChildByName(Level, "MCSBiomes");
+	if ((mcsBiomes >= 0) && (nbt.GetDataLength(mcsBiomes) == sizeof(biomeMap)))
+	{
+		// Convert the biomes from BigEndian to platform native numbers:
+		const char * beBiomes = nbt.GetData(mcsBiomes);
+		for (size_t i = 0; i < ARRAYCOUNT(biomeMap); i++)
+		{
+			biomeMap[i] = (EMCSBiome)GetBEInt(beBiomes + 4 * i);
+		}
+		// Render the biomes:
+		Chunk::Image img;
+		biomesToImage(biomeMap, img);
+		a_DestChunk->setImage(img);
+		return;
+	}
+
+	// MCS biomes not found, load Vanilla biomes instead:
+	int biomes = nbt.FindChildByName(Level, "Biomes");
+	if ((biomes < 0) || (nbt.GetDataLength(biomes) != ARRAYCOUNT(biomeMap)))
+	{
+		return;
+	}
+	// Convert the biomes from Vanilla to EMCSBiome:
+	const char * vanillaBiomes = nbt.GetData(biomes);
+	for (size_t i = 0; i < ARRAYCOUNT(biomeMap); i++)
+	{
+		biomeMap[i] = EMCSBiome(vanillaBiomes[i]);
+	}
+	// Render the biomes:
+	Chunk::Image img;
+	biomesToImage(biomeMap, img);
+	a_DestChunk->setImage(img);
+}
+
+
+
+
+
+void AnvilSource::reload()
+{
+	// Remove all files from the cache:
+	QMutexLocker lock(&m_Mtx);
+	m_Files.clear();
+}
+
+
+
+
+
+void AnvilSource::chunkToRegion(int a_ChunkX, int a_ChunkZ, int & a_RegionX, int & a_RegionZ)
+{
+	a_RegionX = a_ChunkX >> 5;
+	a_RegionZ = a_ChunkZ >> 5;
+}
+
+
+
+
+
+AString AnvilSource::getCompressedChunkData(int a_ChunkX, int a_ChunkZ)
+{
+	return getAnvilFile(a_ChunkX, a_ChunkZ)->getChunkData(a_ChunkX, a_ChunkZ);
+}
+
+
+
+
+
+AnvilSource::AnvilFilePtr AnvilSource::getAnvilFile(int a_ChunkX, int a_ChunkZ)
+{
+	int RegionX, RegionZ;
+	chunkToRegion(a_ChunkX, a_ChunkZ, RegionX, RegionZ);
+
+	// Search the cache for the file:
+	QMutexLocker lock(&m_Mtx);
+	for (auto itr = m_Files.cbegin(), end = m_Files.cend(); itr != end; ++itr)
+	{
+		if (((*itr)->m_RegionX == RegionX) && ((*itr)->m_RegionZ == RegionZ))
+		{
+			// Found the file in the cache, move it to front and return it:
+			AnvilFilePtr file(*itr);
+			m_Files.erase(itr);
+			m_Files.push_front(file);
+			return file;
+		}
+	}
+
+	// File not in cache, create it:
+	AnvilFilePtr file(new AnvilFile(RegionX, RegionZ, m_WorldRegionFolder.toStdString()));
+	m_Files.push_front(file);
+	return file;
+}
+
+
+
+
+
diff --git a/Tools/QtBiomeVisualiser/ChunkSource.h b/Tools/QtBiomeVisualiser/ChunkSource.h
index 868e4a144..7bd1865ff 100644
--- a/Tools/QtBiomeVisualiser/ChunkSource.h
+++ b/Tools/QtBiomeVisualiser/ChunkSource.h
@@ -1,7 +1,8 @@
 #pragma once
+#include "Globals.h"
 #include <QString>
 #include <QMutex>
-#include "Chunk.h"
+#include "QtChunk.h"
 
 
 
@@ -11,6 +12,7 @@
 class cBiomeGen;
 typedef std::shared_ptr<cBiomeGen> cBiomeGenPtr;
 class cIniFile;
+typedef std::shared_ptr<cIniFile> cIniFilePtr;
 
 
 
@@ -40,15 +42,15 @@ class BioGenSource :
 {
 public:
 	/** Constructs a new BioGenSource based on the biome generator that is defined in the specified world.ini file. */
-	BioGenSource(QString a_WorldIniPath);
+	BioGenSource(cIniFilePtr a_IniFile);
 
 	// ChunkSource overrides:
 	virtual void getChunkBiomes(int a_ChunkX, int a_ChunkZ, ChunkPtr a_DestChunk) override;
 	virtual void reload(void) override;
 
 protected:
-	/** Path to the world.ini file from which the m_WorldIni is regenerated on reload requests. */
-	QString m_WorldIniPath;
+	/** The world.ini contents from which the generator is created and re-created on reload(). */
+	cIniFilePtr m_IniFile;
 
 	/** The generator used for generating biomes. */
 	std::unique_ptr<cBiomeGen> m_BiomeGen;
@@ -64,11 +66,40 @@ class AnvilSource :
 	public ChunkSource
 {
 public:
-	// TODO
+	/** Constructs a new AnvilSource based on the world path. */
+	AnvilSource(QString a_WorldRegionFolder);
 
 	// ChunkSource overrides:
 	virtual void getChunkBiomes(int a_ChunkX, int a_ChunkZ, ChunkPtr a_DestChunk) override;
-	virtual void reload() override {}
+	virtual void reload() override;
+
+protected:
+	class AnvilFile;
+	typedef std::shared_ptr<AnvilFile> AnvilFilePtr;
+
+
+	/** Folder where the individual Anvil Region files are located. */
+	QString m_WorldRegionFolder;
+
+	/** List of currently loaded files. Acts as a cache so that a file is not opened and closed over and over again.
+	Protected against multithreaded access by m_Mtx. */
+	std::list<AnvilFilePtr> m_Files;
+
+	/** Guards m_Files agains multithreaded access. */
+	QMutex m_Mtx;
+
+
+	/** Converts chunk coords to region coords. */
+	void chunkToRegion(int a_ChunkX, int a_ChunkZ, int & a_RegionX, int & a_RegionZ);
+
+	/** Returns the compressed data of the specified chunk.
+	Returns an empty string if the chunk is not available. */
+	AString getCompressedChunkData(int a_ChunkX, int a_ChunkZ);
+
+	/** Returns the file object that contains the specified chunk.
+	The file is taken from the cache if available there, otherwise it is created anew. */
+	AnvilFilePtr getAnvilFile(int a_ChunkX, int a_ChunkZ);
+
 };
 
 
diff --git a/Tools/QtBiomeVisualiser/GeneratorSetup.cpp b/Tools/QtBiomeVisualiser/GeneratorSetup.cpp
new file mode 100644
index 000000000..f5412404c
--- /dev/null
+++ b/Tools/QtBiomeVisualiser/GeneratorSetup.cpp
@@ -0,0 +1,159 @@
+#include "Globals.h"
+#include "GeneratorSetup.h"
+#include <QLabel>
+#include <QLineEdit>
+#include "src/Generating/BioGen.h"
+#include "inifile/iniFile.h"
+
+
+
+
+
+static const QString s_GeneratorNames[] =
+{
+	QString("Checkerboard"),
+	QString("Constant"),
+	QString("DistortedVoronoi"),
+	QString("MultiStepMap"),
+	QString("TwoLevel"),
+	QString("Voronoi"),
+};
+
+
+
+
+
+GeneratorSetup::GeneratorSetup(const AString & a_IniFileName, QWidget * a_Parent) :
+	super(a_Parent),
+	m_IniFile(new cIniFile())
+{
+	// The seed and generator name is in a separate form layout at the top, always present:
+	m_eSeed = new QLineEdit();
+	m_eSeed->setValidator(new QIntValidator());
+	m_eSeed->setText("0");
+	m_eSeed->setProperty("INI.ItemName", QVariant("Seed"));
+	m_cbGenerator = new QComboBox();
+	m_cbGenerator->setMinimumWidth(120);
+	for (size_t i = 0; i < ARRAYCOUNT(s_GeneratorNames); i++)
+	{
+		m_cbGenerator->addItem(s_GeneratorNames[i]);
+	}
+	QFormLayout * baseLayout = new QFormLayout();
+	baseLayout->addRow(new QLabel(tr("Seed")), m_eSeed);
+	baseLayout->addRow(new QLabel(tr("Generator")), m_cbGenerator);
+
+	// The rest of the controls are in a dynamically created form layout:
+	m_FormLayout = new QFormLayout();
+
+	// The main layout joins these two vertically:
+	m_MainLayout = new QVBoxLayout();
+	m_MainLayout->addLayout(baseLayout);
+	m_MainLayout->addLayout(m_FormLayout);
+	m_MainLayout->addStretch();
+	setLayout(m_MainLayout);
+
+	// Load the INI file, if specified, otherwise set defaults:
+	if (!a_IniFileName.empty() && m_IniFile->ReadFile(a_IniFileName))
+	{
+		m_cbGenerator->setCurrentText(QString::fromStdString(m_IniFile->GetValue("Generator", "BiomeGen")));
+		m_eSeed->setText(QString::number(m_IniFile->GetValueI("Generator", "Seed")));
+	}
+	else
+	{
+		m_IniFile->SetValue("Generator", "Generator", "Composable");
+		m_IniFile->SetValue("Generator", "BiomeGen", m_cbGenerator->currentText().toStdString());
+		bool dummy;
+		delete cBiomeGen::CreateBiomeGen(*m_IniFile, 0, dummy);
+	}
+	updateFromIni();
+
+	// Connect the change events only after the data has been loaded:
+	connect(m_cbGenerator, SIGNAL(currentIndexChanged(QString)), this, SLOT(generatorChanged(QString)));
+	connect(m_eSeed,       SIGNAL(textChanged(QString)),         this, SLOT(editChanged(QString)));
+}
+
+
+
+
+
+void GeneratorSetup::generatorChanged(const QString & a_NewName)
+{
+	// Clear the current contents of the form layout by assigning it to a stack temporary:
+	{
+		m_MainLayout->takeAt(1);
+		QWidget().setLayout(m_FormLayout);
+	}
+
+	// Re-create the layout:
+	m_FormLayout = new QFormLayout();
+	m_MainLayout->insertLayout(1, m_FormLayout);
+
+	// Recreate the INI file:
+	m_IniFile->Clear();
+	m_IniFile->SetValue("Generator", "Generator", "Composable");
+	m_IniFile->SetValue("Generator", "BiomeGen", a_NewName.toStdString());
+
+	// Create a dummy biome gen from the INI file, this will create the defaults in the INI file:
+	bool dummy;
+	delete cBiomeGen::CreateBiomeGen(*m_IniFile, m_Seed, dummy);
+
+	// Read all values from the INI file and put them into the form layout:
+	updateFromIni();
+
+	// Notify of the changes:
+	emit generatorUpdated();
+}
+
+
+
+
+
+void GeneratorSetup::editChanged(const QString & a_NewValue)
+{
+	QString itemName = sender()->property("INI.ItemName").toString();
+	m_IniFile->SetValue("Generator", itemName.toStdString(), a_NewValue.toStdString());
+	emit generatorUpdated();
+}
+
+
+
+
+
+void GeneratorSetup::updateFromIni()
+{
+	int keyID = m_IniFile->FindKey("Generator");
+	if (keyID <= -1)
+	{
+		return;
+	}
+	int numItems = m_IniFile->GetNumValues(keyID);
+	AString generatorName = m_IniFile->GetValue("Generator", "BiomeGen");
+	size_t generatorNameLen = generatorName.length();
+	for (int i = 0; i < numItems; i++)
+	{
+		AString itemName  = m_IniFile->GetValueName(keyID, i);
+		if ((itemName == "Generator") || (itemName == "BiomeGen"))
+		{
+			// These special cases are not to be added
+			continue;
+		}
+		AString itemValue = m_IniFile->GetValue(keyID, i);
+
+		QLineEdit * edit = new QLineEdit();
+		edit->setText(QString::fromStdString(itemValue));
+		edit->setProperty("INI.ItemName", QVariant(QString::fromStdString(itemName)));
+
+		// Remove the generator name prefix from the item name, for clarity purposes:
+		if (NoCaseCompare(itemName.substr(0, generatorNameLen), generatorName) == 0)
+		{
+			itemName.erase(0, generatorNameLen);
+		}
+
+		connect(edit, SIGNAL(textChanged(QString)), this, SLOT(editChanged(QString)));
+		m_FormLayout->addRow(new QLabel(QString::fromStdString(itemName)), edit);
+	}  // for i - INI values[]
+}
+
+
+
+
diff --git a/Tools/QtBiomeVisualiser/GeneratorSetup.h b/Tools/QtBiomeVisualiser/GeneratorSetup.h
new file mode 100644
index 000000000..e72d3abbc
--- /dev/null
+++ b/Tools/QtBiomeVisualiser/GeneratorSetup.h
@@ -0,0 +1,64 @@
+#pragma once
+
+#include <memory>
+#include <QDialog>
+#include <QComboBox>
+#include <QVBoxLayout>
+#include <QFormLayout>
+
+
+
+
+
+class cIniFile;
+typedef std::shared_ptr<cIniFile> cIniFilePtr;
+
+
+
+
+
+class GeneratorSetup :
+	public QWidget
+{
+	typedef QWidget super;
+
+	Q_OBJECT
+
+public:
+	/** Creates the widget and loads the contents of the INI file, if not empty. */
+	explicit GeneratorSetup(const std::string & a_IniFileName, QWidget * parent = nullptr);
+
+	/** Returns the cIniFile instance that is being edited by this widget. */
+	cIniFilePtr getIniFile() { return m_IniFile; }
+
+signals:
+	/** Emitted when the generator parameters have changed. */
+	void generatorUpdated();
+
+public slots:
+	/** Called when the user selects a different generator from the top combobox.
+	Re-creates m_IniFile and updates the form layout. */
+	void generatorChanged(const QString & a_NewName);
+
+protected slots:
+	/** Called when any of the edit widgets are changed. */
+	void editChanged(const QString & a_NewValue);
+
+protected:
+	QComboBox * m_cbGenerator;
+	QLineEdit * m_eSeed;
+	QVBoxLayout * m_MainLayout;
+	QFormLayout * m_FormLayout;
+
+	cIniFilePtr m_IniFile;
+
+	int m_Seed;
+
+
+	/** Updates the form layout with the values from m_IniFile. */
+	void updateFromIni();
+};
+
+
+
+
diff --git a/Tools/QtBiomeVisualiser/Globals.h b/Tools/QtBiomeVisualiser/Globals.h
index d3c7f0675..8d2e913b7 100644
--- a/Tools/QtBiomeVisualiser/Globals.h
+++ b/Tools/QtBiomeVisualiser/Globals.h
@@ -238,14 +238,14 @@ template class SizeChecker<UInt16, 2>;
 
 #ifndef TEST_GLOBALS
 	// Common headers (part 1, without macros):
-	#include "StringUtils.h"
-	#include "OSSupport/Sleep.h"
-	#include "OSSupport/CriticalSection.h"
-	#include "OSSupport/Semaphore.h"
-	#include "OSSupport/Event.h"
-	#include "OSSupport/Thread.h"
-	#include "OSSupport/File.h"
-	#include "Logger.h"
+	#include "src/StringUtils.h"
+	#include "src/OSSupport/Sleep.h"
+	#include "src/OSSupport/CriticalSection.h"
+	#include "src/OSSupport/Semaphore.h"
+	#include "src/OSSupport/Event.h"
+	#include "src/OSSupport/Thread.h"
+	#include "src/OSSupport/File.h"
+	#include "src/Logger.h"
 #else
 	// Logging functions
 void inline LOGERROR(const char* a_Format, ...) FORMATSTRING(1, 2);
@@ -375,10 +375,10 @@ T Clamp(T a_Value, T a_Min, T a_Max)
 
 
 // Common headers (part 2, with macros):
-#include "ChunkDef.h"
-#include "BiomeDef.h"
-#include "BlockID.h"
-#include "BlockInfo.h"
+#include "src/ChunkDef.h"
+#include "src/BiomeDef.h"
+#include "src/BlockID.h"
+#include "src/BlockInfo.h"
 
 
 
diff --git a/Tools/QtBiomeVisualiser/MainWindow.cpp b/Tools/QtBiomeVisualiser/MainWindow.cpp
index 65d0ccf5e..eb45690c1 100644
--- a/Tools/QtBiomeVisualiser/MainWindow.cpp
+++ b/Tools/QtBiomeVisualiser/MainWindow.cpp
@@ -5,19 +5,34 @@
 #include <QMenuBar>
 #include <QApplication>
 #include <QFileDialog>
+#include <QSettings>
+#include <QDirIterator>
 #include "inifile/iniFile.h"
 #include "ChunkSource.h"
-#include "Generating/BioGen.h"
+#include "src/Generating/BioGen.h"
+#include "src/StringCompression.h"
+#include "src/WorldStorage/FastNBT.h"
+#include "GeneratorSetup.h"
 
 
 
 
 
 MainWindow::MainWindow(QWidget * parent) :
-	QMainWindow(parent)
+	QMainWindow(parent),
+	m_GeneratorSetup(nullptr),
+	m_LineSeparator(nullptr)
 {
-	m_BiomeView = new BiomeView(this);
-	setCentralWidget(m_BiomeView);
+	initMinecraftPath();
+
+	m_BiomeView = new BiomeView();
+	m_MainLayout = new QHBoxLayout();
+	m_MainLayout->addWidget(m_BiomeView, 1);
+	m_MainLayout->setMenuBar(menuBar());
+	m_MainLayout->setMargin(0);
+	QWidget * central = new QWidget();
+	central->setLayout(m_MainLayout);
+	setCentralWidget(central);
 
 	createActions();
 	createMenus();
@@ -36,10 +51,35 @@ MainWindow::~MainWindow()
 
 
 
-void MainWindow::generate()
+void MainWindow::newGenerator()
 {
+	// (Re-)open the generator setup dialog with empty settings:
+	openGeneratorSetup("");
+
+	// Set the chunk source:
+	cIniFilePtr iniFile = m_GeneratorSetup->getIniFile();
+	m_BiomeView->setChunkSource(std::shared_ptr<BioGenSource>(new BioGenSource(iniFile)));
+	m_BiomeView->redraw();
+}
+
+
+
+
+
+void MainWindow::openGenerator()
+{
+	// Let the user specify the world.ini file:
 	QString worldIni = QFileDialog::getOpenFileName(this, tr("Open world.ini"), QString(), tr("world.ini (world.ini)"));
-	m_BiomeView->setChunkSource(std::shared_ptr<BioGenSource>(new BioGenSource(worldIni)));
+	if (worldIni.isEmpty())
+	{
+		return;
+	}
+
+	// (Re-)open the generator setup dialog:
+	openGeneratorSetup(worldIni.toStdString());
+
+	// Set the chunk source:
+	m_BiomeView->setChunkSource(std::shared_ptr<BioGenSource>(new BioGenSource(m_GeneratorSetup->getIniFile())));
 	m_BiomeView->redraw();
 }
 
@@ -47,9 +87,58 @@ void MainWindow::generate()
 
 
 
-void MainWindow::open()
+void MainWindow::openWorld()
 {
-	// TODO
+	// Let the user specify the world:
+	QString regionFolder = QFileDialog::getExistingDirectory(this, tr("Select the region folder"), QString());
+	if (regionFolder.isEmpty())
+	{
+		return;
+	}
+
+	// Remove the generator setup dialog, if open:
+	closeGeneratorSetup();
+
+	// Set the chunk source:
+	m_BiomeView->setChunkSource(std::shared_ptr<AnvilSource>(new AnvilSource(regionFolder)));
+	m_BiomeView->redraw();
+}
+
+
+
+
+
+void MainWindow::openVanillaWorld()
+{
+	// The world is stored in the sender action's data, retrieve it:
+	QAction * action = qobject_cast<QAction *>(sender());
+	if (action == nullptr)
+	{
+		return;
+	}
+
+	// Remove the generator setup dialog, if open:
+	closeGeneratorSetup();
+
+	// Set the chunk source:
+	m_BiomeView->setChunkSource(std::shared_ptr<AnvilSource>(new AnvilSource(action->data().toString())));
+	m_BiomeView->redraw();
+}
+
+
+
+
+
+void MainWindow::initMinecraftPath()
+{
+	#ifdef Q_OS_MAC
+		m_MinecraftPath = QDir::homePath() + QDir::toNativeSeparators("/Library/Application Support/minecraft");
+	#elif defined Q_OS_WIN32
+		QSettings ini(QSettings::IniFormat, QSettings::UserScope, ".minecraft", "minecraft1");
+		m_MinecraftPath = QFileInfo(ini.fileName()).absolutePath();
+	#else
+		m_MinecraftPath = QDir::homePath() + QDir::toNativeSeparators("/.minecraft");
+	#endif
 }
 
 
@@ -58,19 +147,26 @@ void MainWindow::open()
 
 void MainWindow::createActions()
 {
-	m_actGen = new QAction(tr("&Generate..."), this);
-	m_actGen->setShortcut(tr("Ctrl+N"));
-	m_actGen->setStatusTip(tr("Open a generator INI file and display the generated biomes"));
-	connect(m_actGen, SIGNAL(triggered()), this, SLOT(generate()));
+	createWorldActions();
+
+	m_actNewGen = new QAction(tr("&New generator"), this);
+	m_actNewGen->setShortcut(tr("Ctrl+N"));
+	m_actNewGen->setStatusTip(tr("Open a generator INI file and display the generated biomes"));
+	connect(m_actNewGen, SIGNAL(triggered()), this, SLOT(newGenerator()));
 
-	m_actOpen = new QAction(tr("&Open world..."), this);
-	m_actOpen->setShortcut(tr("Ctrl+O"));
-	m_actOpen->setStatusTip(tr("Open an existing world and display its biomes"));
-	connect(m_actOpen, SIGNAL(triggered()), this, SLOT(open()));
+	m_actOpenGen = new QAction(tr("&Open generator..."), this);
+	m_actOpenGen->setShortcut(tr("Ctrl+G"));
+	m_actOpenGen->setStatusTip(tr("Open a generator INI file and display the generated biomes"));
+	connect(m_actOpenGen, SIGNAL(triggered()), this, SLOT(openGenerator()));
+
+	m_actOpenWorld = new QAction(tr("&Open world..."), this);
+	m_actOpenWorld->setShortcut(tr("Ctrl+O"));
+	m_actOpenWorld->setStatusTip(tr("Open an existing world and display its biomes"));
+	connect(m_actOpenWorld, SIGNAL(triggered()), this, SLOT(openWorld()));
 
 	m_actReload = new QAction(tr("&Reload"), this);
 	m_actReload->setShortcut(tr("F5"));
-	m_actReload->setStatusTip(tr("Open an existing world and display its biomes"));
+	m_actReload->setStatusTip(tr("Clear the view cache and force a reload of all the data"));
 	connect(m_actReload, SIGNAL(triggered()), m_BiomeView, SLOT(reload()));
 
 	m_actExit = new QAction(tr("E&xit"), this);
@@ -83,15 +179,130 @@ void MainWindow::createActions()
 
 
 
+void MainWindow::createWorldActions()
+{
+	QDir mc(m_MinecraftPath);
+	if (!mc.cd("saves"))
+	{
+		return;
+	}
+
+	QDirIterator it(mc);
+	int key = 1;
+	while (it.hasNext())
+	{
+		it.next();
+		if (!it.fileInfo().isDir())
+		{
+			continue;
+		}
+		QString name = getWorldName(it.filePath().toStdString());
+		if (name.isEmpty())
+		{
+			continue;
+		}
+		QAction * w = new QAction(this);
+		w->setText(name);
+		w->setData(it.filePath() + "/region");
+		if (key < 10)
+		{
+			w->setShortcut("Ctrl+" + QString::number(key));
+			key++;
+		}
+		connect(w, SIGNAL(triggered()), this, SLOT(openVanillaWorld()));
+		m_WorldActions.append(w);
+	}
+}
+
+
+
+
+
 void MainWindow::createMenus()
 {
-	QMenu * mFile = menuBar()->addMenu(tr("&World"));
-	mFile->addAction(m_actGen);
-	mFile->addAction(m_actOpen);
-	mFile->addSeparator();
-	mFile->addAction(m_actReload);
-	mFile->addSeparator();
-	mFile->addAction(m_actExit);
+	QMenu * file = menuBar()->addMenu(tr("&Map"));
+	file->addAction(m_actNewGen);
+	file->addAction(m_actOpenGen);
+	file->addSeparator();
+	QMenu * worlds = file->addMenu(tr("Open existing"));
+	worlds->addActions(m_WorldActions);
+	if (m_WorldActions.empty())
+	{
+		worlds->setEnabled(false);
+	}
+	file->addAction(m_actOpenWorld);
+	file->addSeparator();
+	file->addAction(m_actReload);
+	file->addSeparator();
+	file->addAction(m_actExit);
+}
+
+
+
+
+
+QString MainWindow::getWorldName(const AString & a_Path)
+{
+	AString levelData = cFile::ReadWholeFile(a_Path + "/level.dat");
+	if (levelData.empty())
+	{
+		// No such file / no data
+		return QString();
+	}
+
+	AString uncompressed;
+	if (UncompressStringGZIP(levelData.data(), levelData.size(), uncompressed) != Z_OK)
+	{
+		return QString();
+	}
+	cParsedNBT nbt(uncompressed.data(), uncompressed.size());
+	if (!nbt.IsValid())
+	{
+		return QString();
+	}
+	AString name = nbt.GetName(1);
+	int levelNameTag = nbt.FindTagByPath(nbt.GetRoot(), "Data\\LevelName");
+	if ((levelNameTag <= 0) || (nbt.GetType(levelNameTag) != TAG_String))
+	{
+		return QString();
+	}
+	return QString::fromStdString(nbt.GetString(levelNameTag));
+}
+
+
+
+
+
+void MainWindow::openGeneratorSetup(const AString & a_IniFileName)
+{
+	// Close any previous editor:
+	closeGeneratorSetup();
+
+	// Open up a new editor:
+	m_GeneratorSetup = new GeneratorSetup(a_IniFileName);
+	m_LineSeparator = new QWidget();
+	m_LineSeparator->setFixedWidth(2);
+	m_LineSeparator->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Expanding);
+	m_LineSeparator->setStyleSheet(QString("background-color: #c0c0c0;"));
+	m_MainLayout->addWidget(m_LineSeparator);
+	m_MainLayout->addWidget(m_GeneratorSetup);
+
+	// Connect the signals from the setup pane:
+	connect(m_GeneratorSetup, SIGNAL(generatorUpdated()), m_BiomeView, SLOT(reload()));
+}
+
+
+
+
+
+void MainWindow::closeGeneratorSetup()
+{
+	delete m_MainLayout->takeAt(2);
+	delete m_MainLayout->takeAt(1);
+	delete m_GeneratorSetup;
+	delete m_LineSeparator;
+	m_GeneratorSetup = nullptr;
+	m_LineSeparator = nullptr;
 }
 
 
diff --git a/Tools/QtBiomeVisualiser/MainWindow.h b/Tools/QtBiomeVisualiser/MainWindow.h
index b37bf4120..6490a937f 100644
--- a/Tools/QtBiomeVisualiser/MainWindow.h
+++ b/Tools/QtBiomeVisualiser/MainWindow.h
@@ -1,43 +1,92 @@
 #pragma once
 
+#include <memory>
+#include <QList>
 #include <QMainWindow>
+#include <QHBoxLayout>
 #include "BiomeView.h"
 
 
 
 
 
+// fwd:
+class GeneratorSetup;
+
+
+
+
+
 class MainWindow :
 	public QMainWindow
 {
 	Q_OBJECT
 
-	BiomeView * m_BiomeView;
-
 public:
-	MainWindow(QWidget *parent = 0);
+	MainWindow(QWidget * parent = nullptr);
 	~MainWindow();
 
 private slots:
+	/** Creates a generator definition from scratch, lets user modify generator params in realtime. */
+	void newGenerator();
+
 	/** Opens a generator definition and generates the biomes based on that. */
-	void generate();
+	void openGenerator();
 
 	/** Opens an existing world and displays the loaded biomes. */
-	void open();
+	void openWorld();
+
+	/** Opens a vanilla world that is specified by the calling action. */
+	void openVanillaWorld();
 
 protected:
 	// Actions:
-	QAction * m_actGen;
-	QAction * m_actOpen;
+	QAction * m_actNewGen;
+	QAction * m_actOpenGen;
+	QAction * m_actOpenWorld;
 	QAction * m_actReload;
 	QAction * m_actExit;
 
+	/** List of actions that open the specific vanilla world. */
+	QList<QAction *> m_WorldActions;
+
+	/** Path to the vanilla folder. */
+	QString m_MinecraftPath;
+
+	/** The pane for setting up the generator, available when visualising a generator. */
+	GeneratorSetup * m_GeneratorSetup;
+
+	/** The main biome display widget. */
+	BiomeView * m_BiomeView;
+
+	/** The layout for the window. */
+	QHBoxLayout * m_MainLayout;
+
+	/** The separator line between biome view and generator setup. */
+	QWidget * m_LineSeparator;
+
+
+	/** Initializes the m_MinecraftPath based on the proper MC path */
+	void initMinecraftPath();
 
 	/** Creates the actions that the UI supports. */
 	void createActions();
 
+	/** Creates the actions that open a specific vanilla world. Iterates over the minecraft saves folder. */
+	void createWorldActions();
+
 	/** Creates the menu bar and connects its events. */
 	void createMenus();
+
+	/** Returns the name of the vanilla world in the specified path.
+	Reads the level.dat file for the name. Returns an empty string on failure. */
+	QString getWorldName(const AString & a_Path);
+
+	/** Opens the generator setup pane, if not already open, and loads the specified INI file to it. */
+	void openGeneratorSetup(const AString & a_IniFileName);
+
+	/** Closes and destroys the generator setup pane, if there is one. */
+	void closeGeneratorSetup();
 };
 
 
diff --git a/Tools/QtBiomeVisualiser/main.cpp b/Tools/QtBiomeVisualiser/QtBiomeVisualiser.cpp
index f41cdcfb2..f41cdcfb2 100644
--- a/Tools/QtBiomeVisualiser/main.cpp
+++ b/Tools/QtBiomeVisualiser/QtBiomeVisualiser.cpp
diff --git a/Tools/QtBiomeVisualiser/QtBiomeVisualiser.pro b/Tools/QtBiomeVisualiser/QtBiomeVisualiser.pro
index e6b65e628..9e5d1303c 100644
--- a/Tools/QtBiomeVisualiser/QtBiomeVisualiser.pro
+++ b/Tools/QtBiomeVisualiser/QtBiomeVisualiser.pro
@@ -12,7 +12,7 @@ TARGET = QtBiomeVisualiser
 TEMPLATE = app
 
 
-SOURCES += main.cpp\
+SOURCES +=\
 		MainWindow.cpp \
     BiomeView.cpp \
     ../../src/Generating/BioGen.cpp \
@@ -27,9 +27,28 @@ SOURCES += main.cpp\
     ../../src/OSSupport/IsThread.cpp \
     ../../src/BiomeDef.cpp \
     ChunkCache.cpp \
-    Chunk.cpp \
     ChunkSource.cpp \
-    ChunkLoader.cpp
+    ChunkLoader.cpp \
+    ../../src/StringCompression.cpp \
+    ../../src/WorldStorage/FastNBT.cpp \
+    ../../lib/zlib/adler32.c \
+    ../../lib/zlib/compress.c \
+    ../../lib/zlib/crc32.c \
+    ../../lib/zlib/deflate.c \
+    ../../lib/zlib/gzclose.c \
+    ../../lib/zlib/gzlib.c \
+    ../../lib/zlib/gzread.c \
+    ../../lib/zlib/gzwrite.c \
+    ../../lib/zlib/infback.c \
+    ../../lib/zlib/inffast.c \
+    ../../lib/zlib/inflate.c \
+    ../../lib/zlib/inftrees.c \
+    ../../lib/zlib/trees.c \
+    ../../lib/zlib/uncompr.c \
+    ../../lib/zlib/zutil.c \
+    GeneratorSetup.cpp \
+    QtBiomeVisualiser.cpp \
+    QtChunk.cpp
 
 HEADERS  += MainWindow.h \
 		Globals.h \
@@ -46,15 +65,36 @@ HEADERS  += MainWindow.h \
     ../../src/OSSupport/IsThread.h \
     ../../src/BiomeDef.h \
     ChunkCache.h \
-    Chunk.h \
     ChunkSource.h \
-    ChunkLoader.h
+    ChunkLoader.h \
+    ../../src/StringCompression.h \
+    ../../src/WorldStorage/FastNBT.h \
+    ../../lib/zlib/crc32.h \
+    ../../lib/zlib/deflate.h \
+    ../../lib/zlib/gzguts.h \
+    ../../lib/zlib/inffast.h \
+    ../../lib/zlib/inffixed.h \
+    ../../lib/zlib/inflate.h \
+    ../../lib/zlib/inftrees.h \
+    ../../lib/zlib/trees.h \
+    ../../lib/zlib/zconf.h \
+    ../../lib/zlib/zlib.h \
+    ../../lib/zlib/zutil.h \
+    GeneratorSetup.h \
+    QtChunk.h
 
 INCLUDEPATH += $$_PRO_FILE_PWD_ \
-	$$_PRO_FILE_PWD_/../../src \
-	$$_PRO_FILE_PWD_/../../lib
+	$$_PRO_FILE_PWD_/../../lib \
+	$$_PRO_FILE_PWD_/../../lib/jsoncpp/include \
+	$$_PRO_FILE_PWD_/../../lib/polarssl/include \
+	$$_PRO_FILE_PWD_/../../lib/sqlite \
+	$$_PRO_FILE_PWD_/../../lib/SQLiteCpp/include \
+	$$_PRO_FILE_PWD_/../../
+
 
 
 CONFIG += C++11
 
+OTHER_FILES +=
+
 
diff --git a/Tools/QtBiomeVisualiser/Chunk.cpp b/Tools/QtBiomeVisualiser/QtChunk.cpp
index d3419af9c..80109b2f8 100644
--- a/Tools/QtBiomeVisualiser/Chunk.cpp
+++ b/Tools/QtBiomeVisualiser/QtChunk.cpp
@@ -1,6 +1,5 @@
 #include "Globals.h"
-#include "Globals.h"
-#include "Chunk.h"
+#include "QtChunk.h"
 
 
 
diff --git a/Tools/QtBiomeVisualiser/Chunk.h b/Tools/QtBiomeVisualiser/QtChunk.h
index 03e7bd1b3..03e7bd1b3 100644
--- a/Tools/QtBiomeVisualiser/Chunk.h
+++ b/Tools/QtBiomeVisualiser/QtChunk.h
diff --git a/src/Bindings/CMakeLists.txt b/src/Bindings/CMakeLists.txt
index 7a1769e9a..930ee9771 100644
--- a/src/Bindings/CMakeLists.txt
+++ b/src/Bindings/CMakeLists.txt
@@ -129,6 +129,8 @@ set_source_files_properties(${CMAKE_SOURCE_DIR}/src/Bindings/Bindings.cpp PROPER
 set_source_files_properties(${CMAKE_SOURCE_DIR}/src/Bindings/Bindings.h PROPERTIES GENERATED TRUE)
 set_source_files_properties(${CMAKE_SOURCE_DIR}/src/Bindings/LuaState_Call.inc PROPERTIES GENERATED TRUE)
 
+set_source_files_properties(${CMAKE_SOURCE_DIR}/src/Bindings/Bindings.cpp PROPERTIES COMPILE_FLAGS -Wno-error)
+
 if(NOT MSVC)
     add_library(Bindings ${SRCS} ${HDRS})
 
diff --git a/src/Bindings/DeprecatedBindings.cpp b/src/Bindings/DeprecatedBindings.cpp
index 36243bc92..02aa15be4 100644
--- a/src/Bindings/DeprecatedBindings.cpp
+++ b/src/Bindings/DeprecatedBindings.cpp
@@ -5,11 +5,6 @@
 #undef TOLUA_TEMPLATE_BIND
 #include "tolua++/include/tolua++.h"
 
-#include "Plugin.h"
-#include "PluginLua.h"
-#include "PluginManager.h"
-#include "LuaWindow.h"
-#include "LuaChunkStay.h"
 
 #include "../BlockInfo.h"
 
diff --git a/src/Bindings/LuaChunkStay.cpp b/src/Bindings/LuaChunkStay.cpp
index 154bcb200..a3d3a8090 100644
--- a/src/Bindings/LuaChunkStay.cpp
+++ b/src/Bindings/LuaChunkStay.cpp
@@ -6,7 +6,6 @@
 #include "Globals.h"
 #include "LuaChunkStay.h"
 #include "PluginLua.h"
-#include "../World.h"
 
 
 
diff --git a/src/Bindings/LuaChunkStay.h b/src/Bindings/LuaChunkStay.h
index 49ab9a0ad..d76b67de9 100644
--- a/src/Bindings/LuaChunkStay.h
+++ b/src/Bindings/LuaChunkStay.h
@@ -18,6 +18,7 @@
 
 // fwd:
 class cPluginLua;
+class cChunkMap;
 
 
 
diff --git a/src/Bindings/LuaState.h b/src/Bindings/LuaState.h
index 44f187701..094a200e0 100644
--- a/src/Bindings/LuaState.h
+++ b/src/Bindings/LuaState.h
@@ -56,7 +56,6 @@ struct HTTPRequest;
 class cWebAdmin;
 struct HTTPTemplateRequest;
 class cTNTEntity;
-class cCreeper;
 class cHopperEntity;
 class cBlockEntity;
 class cBoundingBox;
diff --git a/src/Bindings/LuaWindow.cpp b/src/Bindings/LuaWindow.cpp
index 1a2582ab0..c4d03b86b 100644
--- a/src/Bindings/LuaWindow.cpp
+++ b/src/Bindings/LuaWindow.cpp
@@ -6,7 +6,6 @@
 #include "LuaWindow.h"
 #include "../UI/SlotArea.h"
 #include "PluginLua.h"
-#include "../Entities/Player.h"
 #include "lua/src/lauxlib.h"  // Needed for LUA_REFNIL
 
 
diff --git a/src/Bindings/ManualBindings.cpp b/src/Bindings/ManualBindings.cpp
index b7ea65759..d8134f159 100644
--- a/src/Bindings/ManualBindings.cpp
+++ b/src/Bindings/ManualBindings.cpp
@@ -5,7 +5,6 @@
 #undef TOLUA_TEMPLATE_BIND
 #include "tolua++/include/tolua++.h"
 #include "polarssl/md5.h"
-#include "Plugin.h"
 #include "PluginLua.h"
 #include "PluginManager.h"
 #include "LuaWindow.h"
@@ -27,7 +26,6 @@
 #include "../BlockEntities/MobHeadEntity.h"
 #include "../BlockEntities/FlowerPotEntity.h"
 #include "../LineBlockTracer.h"
-#include "../Protocol/Authenticator.h"
 #include "../WorldStorage/SchematicFileSerializer.h"
 #include "../CompositeChat.h"
 
diff --git a/src/Bindings/Plugin.h b/src/Bindings/Plugin.h
index c9a53346d..fb22dd33e 100644
--- a/src/Bindings/Plugin.h
+++ b/src/Bindings/Plugin.h
@@ -1,23 +1,25 @@
 
 #pragma once
 
-#include "PluginManager.h"
-
+#include "Defines.h"
 
+class cCommandOutputCallback;
+class cItems;
+class cHopperEntity;
 
 
 
+class cBlockEntityWithItems;
 class cClientHandle;
-class cPlayer;
 class cPickup;
-class cItem;
+class cPlayer;
+class cProjectileEntity;
 class cEntity;
+class cMonster;
 class cWorld;
 class cChunkDesc;
 struct TakeDamageInfo;
 
-// fwd: cPlayer.h
-class cPlayer;
 
 // fwd: CraftingRecipes.h
 class cCraftingGrid;
diff --git a/src/Bindings/PluginLua.cpp b/src/Bindings/PluginLua.cpp
index 2c2d05547..2629eb641 100644
--- a/src/Bindings/PluginLua.cpp
+++ b/src/Bindings/PluginLua.cpp
@@ -12,10 +12,12 @@
 #endif
 #include "PluginLua.h"
 #include "../CommandOutput.h"
+#include "PluginManager.h"
+#include "../Item.h"
 
 extern "C"
 {
-	#include "lua/src/lualib.h"
+	#include "lua/src/lauxlib.h"
 }
 
 #undef TOLUA_TEMPLATE_BIND
diff --git a/src/Bindings/PluginManager.cpp b/src/Bindings/PluginManager.cpp
index f62e6ae02..e0faa838a 100644
--- a/src/Bindings/PluginManager.cpp
+++ b/src/Bindings/PluginManager.cpp
@@ -4,12 +4,10 @@
 #include "PluginManager.h"
 #include "Plugin.h"
 #include "PluginLua.h"
-#include "../WebAdmin.h"
 #include "../Item.h"
 #include "../Root.h"
 #include "../Server.h"
 #include "../CommandOutput.h"
-#include "../ChatColor.h"
 
 #include "inifile/iniFile.h"
 #include "../Entities/Player.h"
diff --git a/src/Bindings/PluginManager.h b/src/Bindings/PluginManager.h
index cef6619d7..fff3bc323 100644
--- a/src/Bindings/PluginManager.h
+++ b/src/Bindings/PluginManager.h
@@ -1,9 +1,8 @@
 
 #pragma once
 
-#include "../Item.h"
-
 
+#include "Defines.h"
 
 
 
@@ -36,7 +35,6 @@ class cPickup;
 
 // fwd: Pawn.h
 struct TakeDamageInfo;
-class cPawn;
 
 // fwd: CommandOutput.h
 class cCommandOutputCallback;
@@ -49,6 +47,8 @@ class cBlockEntityWithItems;
 
 
 
+class cItems;
+
 
 
 // tolua_begin
diff --git a/src/Bindings/WebPlugin.cpp b/src/Bindings/WebPlugin.cpp
index 4fa64d937..eca1c74e6 100644
--- a/src/Bindings/WebPlugin.cpp
+++ b/src/Bindings/WebPlugin.cpp
@@ -3,7 +3,6 @@
 
 #include "WebPlugin.h"
 #include "../WebAdmin.h"
-#include "../Server.h"
 #include "../Root.h"
 
 
diff --git a/src/Bindings/WebPlugin.h b/src/Bindings/WebPlugin.h
index 46bc0cd2d..9b825b918 100644
--- a/src/Bindings/WebPlugin.h
+++ b/src/Bindings/WebPlugin.h
@@ -1,7 +1,6 @@
 
 #pragma once
 
-struct lua_State;
 struct HTTPRequest;
 
 
diff --git a/src/BlockEntities/BlockEntity.h b/src/BlockEntities/BlockEntity.h
index e9d3a00ae..11f185ce6 100644
--- a/src/BlockEntities/BlockEntity.h
+++ b/src/BlockEntities/BlockEntity.h
@@ -1,8 +1,6 @@
 
 #pragma once
 
-#include "../ClientHandle.h"
-#include "../World.h"
 
 
 
@@ -13,8 +11,9 @@ namespace Json
 	class Value;
 };
 
+class cChunk;
 class cPlayer;
-class cPacket;
+class cWorld;
 
 
 
diff --git a/src/BlockEntities/BlockEntityWithItems.h b/src/BlockEntities/BlockEntityWithItems.h
index 5f1639d45..e511ee8cb 100644
--- a/src/BlockEntities/BlockEntityWithItems.h
+++ b/src/BlockEntities/BlockEntityWithItems.h
@@ -12,6 +12,7 @@
 #include "BlockEntity.h"
 #include "../ItemGrid.h"
 #include "../UI/WindowOwner.h"
+#include "World.h"
 
 
 
diff --git a/src/BlockEntities/ChestEntity.cpp b/src/BlockEntities/ChestEntity.cpp
index 21e1f6ba2..5447c7c49 100644
--- a/src/BlockEntities/ChestEntity.cpp
+++ b/src/BlockEntities/ChestEntity.cpp
@@ -5,7 +5,6 @@
 #include "../Item.h"
 #include "../Entities/Player.h"
 #include "../UI/Window.h"
-#include "json/json.h"
 
 
 
diff --git a/src/BlockEntities/ChestEntity.h b/src/BlockEntities/ChestEntity.h
index cd06b3e2c..fa36e08be 100644
--- a/src/BlockEntities/ChestEntity.h
+++ b/src/BlockEntities/ChestEntity.h
@@ -13,8 +13,6 @@ namespace Json
 };
 
 class cClientHandle;
-class cServer;
-class cNBTData;
 
 
 
diff --git a/src/BlockEntities/CommandBlockEntity.cpp b/src/BlockEntities/CommandBlockEntity.cpp
index 20702a9ac..318874a9b 100644
--- a/src/BlockEntities/CommandBlockEntity.cpp
+++ b/src/BlockEntities/CommandBlockEntity.cpp
@@ -4,16 +4,14 @@
 // Implements the cCommandBlockEntity class representing a single command block in the world
 
 #include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
-#include "json/json.h"
 #include "CommandBlockEntity.h"
-#include "../Entities/Player.h"
-#include "../WorldStorage/FastNBT.h"
 
 #include "../CommandOutput.h"
 #include "../Root.h"
 #include "../Server.h"  // ExecuteConsoleCommand()
-#include "../Chunk.h"
 #include "../ChatColor.h"
+#include "../World.h"
+#include "../ClientHandle.h"
 
 
 
diff --git a/src/BlockEntities/CommandBlockEntity.h b/src/BlockEntities/CommandBlockEntity.h
index d02bf7d7b..22cd44322 100644
--- a/src/BlockEntities/CommandBlockEntity.h
+++ b/src/BlockEntities/CommandBlockEntity.h
@@ -10,7 +10,7 @@
 #pragma once
 
 #include "BlockEntity.h"
-
+#include "RedstonePoweredEntity.h"
 
 
 
@@ -27,7 +27,8 @@ namespace Json
 // tolua_begin
 
 class cCommandBlockEntity :
-	public cBlockEntity
+	public cBlockEntity,
+	public cRedstonePoweredEntity
 {
 	typedef cBlockEntity super;
 	
@@ -52,7 +53,7 @@ public:
 	// tolua_begin
 
 	/// Sets the internal redstone power flag to "on" or "off", depending on the parameter. Calls Activate() if appropriate
-	void SetRedstonePower(bool a_IsPowered);
+	virtual void SetRedstonePower(bool a_IsPowered) override;
 
 	/// Sets the command block to execute a command in the next tick
 	void Activate(void);
diff --git a/src/BlockEntities/DispenserEntity.cpp b/src/BlockEntities/DispenserEntity.cpp
index c02c68afa..4794375cf 100644
--- a/src/BlockEntities/DispenserEntity.cpp
+++ b/src/BlockEntities/DispenserEntity.cpp
@@ -2,13 +2,10 @@
 #include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
 
 #include "DispenserEntity.h"
-#include "../Entities/Player.h"
 #include "../Simulator/FluidSimulator.h"
 #include "../Chunk.h"
 
 #include "../World.h"
-#include "../Entities/ArrowEntity.h"
-#include "../Entities/FireChargeEntity.h"
 #include "../Entities/ProjectileEntity.h"
 
 
@@ -109,7 +106,7 @@ void cDispenserEntity::DropSpenseFromSlot(cChunk & a_Chunk, int a_SlotNum)
 		{
 			double MobX = 0.5 + (DispX + DispChunk->GetPosX() * cChunkDef::Width);
 			double MobZ = 0.5 + (DispZ + DispChunk->GetPosZ() * cChunkDef::Width);
-			if (m_World->SpawnMob(MobX, DispY, MobZ, (cMonster::eType)m_Contents.GetSlot(a_SlotNum).m_ItemDamage) >= 0)
+			if (m_World->SpawnMob(MobX, DispY, MobZ, (eMonsterType)m_Contents.GetSlot(a_SlotNum).m_ItemDamage) >= 0)
 			{
 				m_Contents.ChangeSlotCount(a_SlotNum, -1);
 			}
@@ -203,7 +200,7 @@ void cDispenserEntity::SpawnProjectileFromDispenser(int a_BlockX, int a_BlockY,
 
 Vector3d cDispenserEntity::GetShootVector(NIBBLETYPE a_Meta)
 {
-	switch (a_Meta)
+	switch (a_Meta & 0x7)
 	{
 		case E_META_DROPSPENSER_FACING_YP: return Vector3d( 0,  1,  0);
 		case E_META_DROPSPENSER_FACING_YM: return Vector3d( 0, -1,  0);
diff --git a/src/BlockEntities/DropSpenserEntity.cpp b/src/BlockEntities/DropSpenserEntity.cpp
index dc38e3e9b..260c71641 100644
--- a/src/BlockEntities/DropSpenserEntity.cpp
+++ b/src/BlockEntities/DropSpenserEntity.cpp
@@ -8,7 +8,6 @@
 #include "DropSpenserEntity.h"
 #include "../Entities/Player.h"
 #include "../Chunk.h"
-#include "json/json.h"
 
 
 
diff --git a/src/BlockEntities/DropSpenserEntity.h b/src/BlockEntities/DropSpenserEntity.h
index be56447aa..c70cd0531 100644
--- a/src/BlockEntities/DropSpenserEntity.h
+++ b/src/BlockEntities/DropSpenserEntity.h
@@ -22,7 +22,6 @@ namespace Json
 }
 
 class cClientHandle;
-class cServer;
 
 
 
diff --git a/src/BlockEntities/DropperEntity.cpp b/src/BlockEntities/DropperEntity.cpp
index 5d4a8ad97..5cbf6d56e 100644
--- a/src/BlockEntities/DropperEntity.cpp
+++ b/src/BlockEntities/DropperEntity.cpp
@@ -5,8 +5,6 @@
 
 #include "Globals.h"
 #include "DropperEntity.h"
-#include "../Entities/Player.h"
-#include "../Simulator/FluidSimulator.h"
 
 
 
diff --git a/src/BlockEntities/EnderChestEntity.cpp b/src/BlockEntities/EnderChestEntity.cpp
index 17816d63e..b870f9e50 100644
--- a/src/BlockEntities/EnderChestEntity.cpp
+++ b/src/BlockEntities/EnderChestEntity.cpp
@@ -5,7 +5,6 @@
 #include "../Item.h"
 #include "../Entities/Player.h"
 #include "../UI/Window.h"
-#include "json/json.h"
 
 
 
diff --git a/src/BlockEntities/EnderChestEntity.h b/src/BlockEntities/EnderChestEntity.h
index ed178f6fc..311af8d76 100644
--- a/src/BlockEntities/EnderChestEntity.h
+++ b/src/BlockEntities/EnderChestEntity.h
@@ -3,7 +3,6 @@
 
 #include "BlockEntity.h"
 #include "UI/WindowOwner.h"
-#include "json/json.h"
 
 
 
diff --git a/src/BlockEntities/FlowerPotEntity.cpp b/src/BlockEntities/FlowerPotEntity.cpp
index e001634b8..d2bc59d34 100644
--- a/src/BlockEntities/FlowerPotEntity.cpp
+++ b/src/BlockEntities/FlowerPotEntity.cpp
@@ -4,7 +4,6 @@
 // Implements the cFlowerPotEntity class representing a single flower pot in the world
 
 #include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
-#include "json/json.h"
 #include "FlowerPotEntity.h"
 #include "../Entities/Player.h"
 #include "../Item.h"
diff --git a/src/BlockEntities/FlowerPotEntity.h b/src/BlockEntities/FlowerPotEntity.h
index 89901cf2d..b86f9c840 100644
--- a/src/BlockEntities/FlowerPotEntity.h
+++ b/src/BlockEntities/FlowerPotEntity.h
@@ -9,8 +9,8 @@
 #pragma once
 
 #include "BlockEntity.h"
+#include "Item.h"
 
-class cItem;
 
 
 
diff --git a/src/BlockEntities/FurnaceEntity.cpp b/src/BlockEntities/FurnaceEntity.cpp
index 72fd7f2b3..d7b2fd910 100644
--- a/src/BlockEntities/FurnaceEntity.cpp
+++ b/src/BlockEntities/FurnaceEntity.cpp
@@ -5,8 +5,6 @@
 #include "../UI/Window.h"
 #include "../Entities/Player.h"
 #include "../Root.h"
-#include "../Chunk.h"
-#include "json/json.h"
 
 
 
diff --git a/src/BlockEntities/FurnaceEntity.h b/src/BlockEntities/FurnaceEntity.h
index cf1a755e0..7ac25cf52 100644
--- a/src/BlockEntities/FurnaceEntity.h
+++ b/src/BlockEntities/FurnaceEntity.h
@@ -14,7 +14,6 @@ namespace Json
 }
 
 class cClientHandle;
-class cServer;
 
 
 
diff --git a/src/BlockEntities/HopperEntity.cpp b/src/BlockEntities/HopperEntity.cpp
index 88e7b8e1b..444378c92 100644
--- a/src/BlockEntities/HopperEntity.cpp
+++ b/src/BlockEntities/HopperEntity.cpp
@@ -10,10 +10,7 @@
 #include "../Entities/Pickup.h"
 #include "../Bindings/PluginManager.h"
 #include "ChestEntity.h"
-#include "DropSpenserEntity.h"
 #include "FurnaceEntity.h"
-#include "../BoundingBox.h"
-#include "json/json.h"
 
 
 
diff --git a/src/BlockEntities/JukeboxEntity.cpp b/src/BlockEntities/JukeboxEntity.cpp
index c96253b11..1131b99b0 100644
--- a/src/BlockEntities/JukeboxEntity.cpp
+++ b/src/BlockEntities/JukeboxEntity.cpp
@@ -3,8 +3,8 @@
 
 #include "JukeboxEntity.h"
 #include "../World.h"
-#include "json/json.h"
-
+#include "json/value.h"
+#include "Entities/Player.h"
 
 
 
diff --git a/src/BlockEntities/JukeboxEntity.h b/src/BlockEntities/JukeboxEntity.h
index d677d340f..a6fdf3c7e 100644
--- a/src/BlockEntities/JukeboxEntity.h
+++ b/src/BlockEntities/JukeboxEntity.h
@@ -2,7 +2,6 @@
 #pragma once
 
 #include "BlockEntity.h"
-#include "../Entities/Player.h"
 
 
 
diff --git a/src/BlockEntities/MobHeadEntity.cpp b/src/BlockEntities/MobHeadEntity.cpp
index ce895eb6f..9a1a40abe 100644
--- a/src/BlockEntities/MobHeadEntity.cpp
+++ b/src/BlockEntities/MobHeadEntity.cpp
@@ -4,7 +4,6 @@
 // Implements the cMobHeadEntity class representing a single skull/head in the world
 
 #include "Globals.h"
-#include "json/json.h"
 #include "MobHeadEntity.h"
 #include "../Entities/Player.h"
 
diff --git a/src/BlockEntities/MobHeadEntity.h b/src/BlockEntities/MobHeadEntity.h
index f91a3cc9e..45fa0d951 100644
--- a/src/BlockEntities/MobHeadEntity.h
+++ b/src/BlockEntities/MobHeadEntity.h
@@ -9,7 +9,7 @@
 #pragma once
 
 #include "BlockEntity.h"
-
+#include "Defines.h"
 
 
 
diff --git a/src/BlockEntities/NoteEntity.cpp b/src/BlockEntities/NoteEntity.cpp
index 95145c117..ecbedbcb1 100644
--- a/src/BlockEntities/NoteEntity.cpp
+++ b/src/BlockEntities/NoteEntity.cpp
@@ -3,7 +3,7 @@
 
 #include "NoteEntity.h"
 #include "../World.h"
-#include "json/json.h"
+#include "json/value.h"
 
 
 
diff --git a/src/BlockEntities/RedstonePoweredEntity.h b/src/BlockEntities/RedstonePoweredEntity.h
index f11df4fc4..eac4e35d4 100644
--- a/src/BlockEntities/RedstonePoweredEntity.h
+++ b/src/BlockEntities/RedstonePoweredEntity.h
@@ -6,7 +6,7 @@ class cRedstonePoweredEntity
 {
 public:
 
-	virtual ~cRedstonePoweredEntity() {};
+	virtual ~cRedstonePoweredEntity() {}
 
 	/// Sets the internal redstone power flag to "on" or "off", depending on the parameter. Calls Activate() if appropriate
 	virtual void SetRedstonePower(bool a_IsPowered) = 0;
diff --git a/src/BlockEntities/SignEntity.cpp b/src/BlockEntities/SignEntity.cpp
index 23d9ef926..423d254d2 100644
--- a/src/BlockEntities/SignEntity.cpp
+++ b/src/BlockEntities/SignEntity.cpp
@@ -4,9 +4,9 @@
 // Implements the cSignEntity class representing a single sign in the world
 
 #include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
-#include "json/json.h"
+#include "json/value.h"
 #include "SignEntity.h"
-#include "../Entities/Player.h"
+#include "../ClientHandle.h"
 
 
 
diff --git a/src/BlockID.cpp b/src/BlockID.cpp
index 07a1fc9e5..9026d81f2 100644
--- a/src/BlockID.cpp
+++ b/src/BlockID.cpp
@@ -261,34 +261,34 @@ int StringToMobType(const AString & a_MobString)
 		const char * m_String;
 	} MobMap [] =
 	{
-		{cMonster::mtCreeper,      "Creeper"},
-		{cMonster::mtSkeleton,     "Skeleton"},
-		{cMonster::mtSpider,       "Spider"},
-		{cMonster::mtGiant,        "Giant"},
-		{cMonster::mtZombie,       "Zombie"},
-		{cMonster::mtSlime,        "Slime"},
-		{cMonster::mtGhast,        "Ghast"},
-		{cMonster::mtZombiePigman, "ZombiePigman"},
-		{cMonster::mtEnderman,     "Enderman"},
-		{cMonster::mtCaveSpider,   "CaveSpider"},
-		{cMonster::mtSilverfish,   "SilverFish"},
-		{cMonster::mtBlaze,        "Blaze"},
-		{cMonster::mtMagmaCube,    "MagmaCube"},
-		{cMonster::mtEnderDragon,  "EnderDragon"},
-		{cMonster::mtWither,       "Wither"},
-		{cMonster::mtBat,          "Bat"},
-		{cMonster::mtWitch,        "Witch"},
-		{cMonster::mtPig,          "Pig"},
-		{cMonster::mtSheep,        "Sheep"},
-		{cMonster::mtCow,          "Cow"},
-		{cMonster::mtChicken,      "Chicken"},
-		{cMonster::mtSquid,        "Squid"},
-		{cMonster::mtWolf,         "Wolf"},
-		{cMonster::mtMooshroom,    "Mooshroom"},
-		{cMonster::mtSnowGolem,    "SnowGolem"},
-		{cMonster::mtOcelot,       "Ocelot"},
-		{cMonster::mtIronGolem,    "IronGolem"},
-		{cMonster::mtVillager,     "Villager"},
+		{mtCreeper,      "Creeper"},
+		{mtSkeleton,     "Skeleton"},
+		{mtSpider,       "Spider"},
+		{mtGiant,        "Giant"},
+		{mtZombie,       "Zombie"},
+		{mtSlime,        "Slime"},
+		{mtGhast,        "Ghast"},
+		{mtZombiePigman, "ZombiePigman"},
+		{mtEnderman,     "Enderman"},
+		{mtCaveSpider,   "CaveSpider"},
+		{mtSilverfish,   "SilverFish"},
+		{mtBlaze,        "Blaze"},
+		{mtMagmaCube,    "MagmaCube"},
+		{mtEnderDragon,  "EnderDragon"},
+		{mtWither,       "Wither"},
+		{mtBat,          "Bat"},
+		{mtWitch,        "Witch"},
+		{mtPig,          "Pig"},
+		{mtSheep,        "Sheep"},
+		{mtCow,          "Cow"},
+		{mtChicken,      "Chicken"},
+		{mtSquid,        "Squid"},
+		{mtWolf,         "Wolf"},
+		{mtMooshroom,    "Mooshroom"},
+		{mtSnowGolem,    "SnowGolem"},
+		{mtOcelot,       "Ocelot"},
+		{mtIronGolem,    "IronGolem"},
+		{mtVillager,     "Villager"},
 	};
 	for (size_t i = 0; i < ARRAYCOUNT(MobMap); i++)
 	{
diff --git a/src/BlockID.h b/src/BlockID.h
index d835f9518..45e71d85d 100644
--- a/src/BlockID.h
+++ b/src/BlockID.h
@@ -175,12 +175,36 @@ enum ENUM_BLOCK_ID
 	E_BLOCK_NEW_LOG = 162,
 	E_BLOCK_ACACIA_WOOD_STAIRS = 163,
 	E_BLOCK_DARK_OAK_WOOD_STAIRS = 164,
+	E_BLOCK_SLIME_BLOCK = 165,
+	E_BLOCK_BARRIER = 166,
+	E_BLOCK_IRON_TRAPDOOR = 167,
+	E_BLOCK_PRISMARINE_BLOCK = 168,
+	E_BLOCK_SEA_LANTERN = 169,
 	E_BLOCK_HAY_BALE = 170,
 	E_BLOCK_CARPET = 171,
 	E_BLOCK_HARDENED_CLAY = 172,
 	E_BLOCK_BLOCK_OF_COAL = 173,
 	E_BLOCK_PACKED_ICE = 174,
 	E_BLOCK_BIG_FLOWER = 175,
+	E_BLOCK_RED_SANDSTONE = 179,
+	E_BLOCK_RED_SANDSTONE_STAIRS = 180,
+	E_BLOCK_DOUBLE_NEW_STONE_SLAB= 181,
+	E_BLOCK_NEW_STONE_SLAB = 182,
+	E_BLOCK_SPRUCE_FENCE_GATE = 183,
+	E_BLOCK_BIRCH_FENCE_GATE = 184,
+	E_BLOCK_JUNGLE_FENCE_GATE = 185,
+	E_BLOCK_DARK_OAK_FENCE_GATE = 186,
+	E_BLOCK_ACACIA_FENCE_GATE = 187,
+	E_BLOCK_SPRUCE_FENCE = 188,
+	E_BLOCK_BIRCH_FENCE = 189,
+	E_BLOCK_JUNGLE_FENCE = 190,
+	E_BLOCK_DARK_OAK_FENCE = 191,
+	E_BLOCK_ACACIA_FENCE = 192,
+	E_BLOCK_SPRUCE_DOOR = 193,
+	E_BLOCK_BIRCH_DOOR = 194,
+	E_BLOCK_JUNGLE_DOOR = 195,
+	E_BLOCK_ACACIA_DOOR = 196,
+	E_BLOCK_DARK_OAK_DOOR = 197,
 	
 	// Keep these two as the last values, without a number - they will get their correct number assigned automagically by C++
 	// IsValidBlock() depends on this
@@ -356,6 +380,14 @@ enum ENUM_ITEM_ID
 	E_ITEM_NETHER_QUARTZ = 406,
 	E_ITEM_MINECART_WITH_TNT = 407,
 	E_ITEM_MINECART_WITH_HOPPER = 408,
+	E_ITEM_PRISMARINE_SHARD = 409,
+	E_ITEM_PRISMARINE_CRYSTALS = 410,
+	E_ITEM_RAW_RABBIT = 411,
+	E_ITEM_COOKED_RABBIT = 412,
+	E_ITEM_RABBIT_STEW = 413,
+	E_ITEM_RABBITS_FOOT = 414,
+	E_ITEM_RABBIT_HIDE = 415,
+	E_ITEM_ARMOR_STAND = 416,
 	E_ITEM_IRON_HORSE_ARMOR = 417,
 	E_ITEM_GOLD_HORSE_ARMOR = 418,
 	E_ITEM_DIAMOND_HORSE_ARMOR = 419,
@@ -363,7 +395,13 @@ enum ENUM_ITEM_ID
 	E_ITEM_NAME_TAG = 421,
 	E_ITEM_MINECART_WITH_COMMAND_BLOCK = 422,
 	E_ITEM_RAW_MUTTON = 423,
-	E_ITEM_MUTTON = 424,
+	E_ITEM_COOKED_MUTTON = 424,
+	E_ITEM_BANNER = 425,
+	E_ITEM_SPRUCE_DOOR = 427,
+	E_ITEM_BIRCH_DOOR = 428,
+	E_ITEM_JUNGLE_DOOR = 429,
+	E_ITEM_ACACIA_DOOR = 430,
+	E_ITEM_DARK_OAK_DOOR = 431,
 	
 	// Keep these two as the last values of the consecutive list, without a number - they will get their correct number assigned automagically by C++
 	// IsValidItem() depends on this!
diff --git a/src/BlockInfo.cpp b/src/BlockInfo.cpp
index 0324cabf5..fb9b746b3 100644
--- a/src/BlockInfo.cpp
+++ b/src/BlockInfo.cpp
@@ -6,26 +6,6 @@
 
 
 
-
-
-cBlockInfo::cBlockInfo()
-	: m_LightValue(0x00)
-	, m_SpreadLightFalloff(0x0f)
-	, m_Transparent(false)
-	, m_OneHitDig(false)
-	, m_PistonBreakable(false)
-	, m_IsSnowable(false)
-	, m_IsSolid(true)
-	, m_FullyOccupiesVoxel(false)
-	, m_CanBeTerraformed(false)
-	, m_PlaceSound("")
-	, m_Handler(NULL)
-{}
-
-
-
-
-
 cBlockInfo::~cBlockInfo()
 {
 	delete m_Handler;
@@ -33,28 +13,6 @@ cBlockInfo::~cBlockInfo()
 }
 
 
-
-
-
-/** This accessor makes sure that the cBlockInfo structures are properly initialized exactly once.
-It does so by using the C++ singleton approximation - storing the actual singleton as the function's static variable.
-It works only if it is called for the first time before the app spawns other threads. */
-cBlockInfo & cBlockInfo::Get(BLOCKTYPE a_Type)
-{
-	static cBlockInfo ms_Info[256];
-	static bool IsBlockInfoInitialized = false;
-	if (!IsBlockInfoInitialized)
-	{
-		cBlockInfo::Initialize(ms_Info);
-		IsBlockInfoInitialized = true;
-	}
-	return ms_Info[a_Type];
-}
-
-
-
-
-
 void cBlockInfo::Initialize(cBlockInfoArray & a_Info)
 {
 	for (unsigned int i = 0; i < 256; ++i)
@@ -84,18 +42,26 @@ void cBlockInfo::Initialize(cBlockInfoArray & a_Info)
 	a_Info[E_BLOCK_REDSTONE_ORE_GLOWING].m_LightValue = 9;
 	a_Info[E_BLOCK_REDSTONE_REPEATER_ON].m_LightValue = 9;
 	a_Info[E_BLOCK_REDSTONE_TORCH_ON   ].m_LightValue = 7;
+	a_Info[E_BLOCK_SEA_LANTERN         ].m_LightValue = 15;
 	a_Info[E_BLOCK_STATIONARY_LAVA     ].m_LightValue = 15;
 	a_Info[E_BLOCK_TORCH               ].m_LightValue = 14;
 
 
 	// Spread blocks
+	a_Info[E_BLOCK_ACACIA_DOOR         ].m_SpreadLightFalloff = 1;
+	a_Info[E_BLOCK_ACACIA_FENCE        ].m_SpreadLightFalloff = 1;
+	a_Info[E_BLOCK_ACACIA_FENCE_GATE   ].m_SpreadLightFalloff = 1;
 	a_Info[E_BLOCK_ACTIVATOR_RAIL      ].m_SpreadLightFalloff = 1;
 	a_Info[E_BLOCK_ACTIVE_COMPARATOR   ].m_SpreadLightFalloff = 1;
 	a_Info[E_BLOCK_AIR                 ].m_SpreadLightFalloff = 1;
 	a_Info[E_BLOCK_ANVIL               ].m_SpreadLightFalloff = 1;
+	a_Info[E_BLOCK_BARRIER             ].m_SpreadLightFalloff = 1;
 	a_Info[E_BLOCK_BEACON              ].m_SpreadLightFalloff = 1;
 	a_Info[E_BLOCK_BED                 ].m_SpreadLightFalloff = 1;
 	a_Info[E_BLOCK_BIG_FLOWER          ].m_SpreadLightFalloff = 1;
+	a_Info[E_BLOCK_BIRCH_DOOR          ].m_SpreadLightFalloff = 1;
+	a_Info[E_BLOCK_BIRCH_FENCE         ].m_SpreadLightFalloff = 1;
+	a_Info[E_BLOCK_BIRCH_FENCE_GATE    ].m_SpreadLightFalloff = 1;
 	a_Info[E_BLOCK_BROWN_MUSHROOM      ].m_SpreadLightFalloff = 1;
 	a_Info[E_BLOCK_BREWING_STAND       ].m_SpreadLightFalloff = 1;
 	a_Info[E_BLOCK_CACTUS              ].m_SpreadLightFalloff = 1;
@@ -109,6 +75,9 @@ void cBlockInfo::Initialize(cBlockInfoArray & a_Info)
 	a_Info[E_BLOCK_COBWEB              ].m_SpreadLightFalloff = 1;
 	a_Info[E_BLOCK_CROPS               ].m_SpreadLightFalloff = 1;
 	a_Info[E_BLOCK_DANDELION           ].m_SpreadLightFalloff = 1;
+	a_Info[E_BLOCK_DARK_OAK_DOOR       ].m_SpreadLightFalloff = 1;
+	a_Info[E_BLOCK_DARK_OAK_FENCE      ].m_SpreadLightFalloff = 1;
+	a_Info[E_BLOCK_DARK_OAK_FENCE_GATE ].m_SpreadLightFalloff = 1;
 	a_Info[E_BLOCK_DAYLIGHT_SENSOR     ].m_SpreadLightFalloff = 1;
 	a_Info[E_BLOCK_DEAD_BUSH           ].m_SpreadLightFalloff = 1;
 	a_Info[E_BLOCK_DETECTOR_RAIL       ].m_SpreadLightFalloff = 1;
@@ -132,6 +101,10 @@ void cBlockInfo::Initialize(cBlockInfoArray & a_Info)
 	a_Info[E_BLOCK_INACTIVE_COMPARATOR ].m_SpreadLightFalloff = 1;
 	a_Info[E_BLOCK_IRON_BARS           ].m_SpreadLightFalloff = 1;
 	a_Info[E_BLOCK_IRON_DOOR           ].m_SpreadLightFalloff = 1;
+	a_Info[E_BLOCK_IRON_TRAPDOOR       ].m_SpreadLightFalloff = 1;
+	a_Info[E_BLOCK_JUNGLE_DOOR         ].m_SpreadLightFalloff = 1;
+	a_Info[E_BLOCK_JUNGLE_FENCE        ].m_SpreadLightFalloff = 1;
+	a_Info[E_BLOCK_JUNGLE_FENCE_GATE   ].m_SpreadLightFalloff = 1;
 	a_Info[E_BLOCK_LADDER              ].m_SpreadLightFalloff = 1;
 	a_Info[E_BLOCK_LEAVES              ].m_SpreadLightFalloff = 1;
 	a_Info[E_BLOCK_LEVER               ].m_SpreadLightFalloff = 1;
@@ -142,6 +115,7 @@ void cBlockInfo::Initialize(cBlockInfoArray & a_Info)
 	a_Info[E_BLOCK_NETHER_PORTAL       ].m_SpreadLightFalloff = 1;
 	a_Info[E_BLOCK_NETHER_WART         ].m_SpreadLightFalloff = 1;
 	a_Info[E_BLOCK_NEW_LEAVES          ].m_SpreadLightFalloff = 1;
+	a_Info[E_BLOCK_NEW_STONE_SLAB      ].m_SpreadLightFalloff = 1;
 	a_Info[E_BLOCK_PISTON              ].m_SpreadLightFalloff = 1;
 	a_Info[E_BLOCK_PISTON_EXTENSION    ].m_SpreadLightFalloff = 1;
 	a_Info[E_BLOCK_PISTON_MOVED_BLOCK  ].m_SpreadLightFalloff = 1;
@@ -158,6 +132,9 @@ void cBlockInfo::Initialize(cBlockInfoArray & a_Info)
 	a_Info[E_BLOCK_SAPLING             ].m_SpreadLightFalloff = 1;
 	a_Info[E_BLOCK_SIGN_POST           ].m_SpreadLightFalloff = 1;
 	a_Info[E_BLOCK_SNOW                ].m_SpreadLightFalloff = 1;
+	a_Info[E_BLOCK_SPRUCE_DOOR         ].m_SpreadLightFalloff = 1;
+	a_Info[E_BLOCK_SPRUCE_FENCE        ].m_SpreadLightFalloff = 1;
+	a_Info[E_BLOCK_SPRUCE_FENCE_GATE   ].m_SpreadLightFalloff = 1;
 	a_Info[E_BLOCK_STAINED_GLASS       ].m_SpreadLightFalloff = 1;
 	a_Info[E_BLOCK_STAINED_GLASS_PANE  ].m_SpreadLightFalloff = 1;
 	a_Info[E_BLOCK_STICKY_PISTON       ].m_SpreadLightFalloff = 1;
@@ -186,13 +163,20 @@ void cBlockInfo::Initialize(cBlockInfoArray & a_Info)
 
 
 	// Transparent blocks
+	a_Info[E_BLOCK_ACACIA_DOOR         ].m_Transparent = true;
+	a_Info[E_BLOCK_ACACIA_FENCE        ].m_Transparent = true;
+	a_Info[E_BLOCK_ACACIA_FENCE_GATE   ].m_Transparent = true;
 	a_Info[E_BLOCK_ACTIVATOR_RAIL      ].m_Transparent = true;
 	a_Info[E_BLOCK_ACTIVE_COMPARATOR   ].m_Transparent = true;
 	a_Info[E_BLOCK_AIR                 ].m_Transparent = true;
 	a_Info[E_BLOCK_ANVIL               ].m_Transparent = true;
+	a_Info[E_BLOCK_BARRIER             ].m_Transparent = true;
 	a_Info[E_BLOCK_BEACON              ].m_Transparent = true;
 	a_Info[E_BLOCK_BED                 ].m_Transparent = true;
 	a_Info[E_BLOCK_BIG_FLOWER          ].m_Transparent = true;
+	a_Info[E_BLOCK_BIRCH_DOOR          ].m_Transparent = true;
+	a_Info[E_BLOCK_BIRCH_FENCE         ].m_Transparent = true;
+	a_Info[E_BLOCK_BIRCH_FENCE_GATE    ].m_Transparent = true;
 	a_Info[E_BLOCK_BROWN_MUSHROOM      ].m_Transparent = true;
 	a_Info[E_BLOCK_BREWING_STAND       ].m_Transparent = true;
 	a_Info[E_BLOCK_CACTUS              ].m_Transparent = true;
@@ -206,6 +190,9 @@ void cBlockInfo::Initialize(cBlockInfoArray & a_Info)
 	a_Info[E_BLOCK_COBWEB              ].m_Transparent = true;
 	a_Info[E_BLOCK_CROPS               ].m_Transparent = true;
 	a_Info[E_BLOCK_DANDELION           ].m_Transparent = true;
+	a_Info[E_BLOCK_DARK_OAK_DOOR       ].m_Transparent = true;
+	a_Info[E_BLOCK_DARK_OAK_FENCE      ].m_Transparent = true;
+	a_Info[E_BLOCK_DARK_OAK_FENCE_GATE ].m_Transparent = true;
 	a_Info[E_BLOCK_DAYLIGHT_SENSOR     ].m_Transparent = true;
 	a_Info[E_BLOCK_DEAD_BUSH           ].m_Transparent = true;
 	a_Info[E_BLOCK_DETECTOR_RAIL       ].m_Transparent = true;
@@ -229,6 +216,10 @@ void cBlockInfo::Initialize(cBlockInfoArray & a_Info)
 	a_Info[E_BLOCK_INACTIVE_COMPARATOR ].m_Transparent = true;
 	a_Info[E_BLOCK_IRON_BARS           ].m_Transparent = true;
 	a_Info[E_BLOCK_IRON_DOOR           ].m_Transparent = true;
+	a_Info[E_BLOCK_IRON_TRAPDOOR       ].m_Transparent = true;
+	a_Info[E_BLOCK_JUNGLE_DOOR         ].m_Transparent = true;
+	a_Info[E_BLOCK_JUNGLE_FENCE        ].m_Transparent = true;
+	a_Info[E_BLOCK_JUNGLE_FENCE_GATE   ].m_Transparent = true;
 	a_Info[E_BLOCK_LADDER              ].m_Transparent = true;
 	a_Info[E_BLOCK_LAVA                ].m_Transparent = true;
 	a_Info[E_BLOCK_LEAVES              ].m_Transparent = true;
@@ -241,6 +232,7 @@ void cBlockInfo::Initialize(cBlockInfoArray & a_Info)
 	a_Info[E_BLOCK_NETHER_PORTAL       ].m_Transparent = true;
 	a_Info[E_BLOCK_NETHER_WART         ].m_Transparent = true;
 	a_Info[E_BLOCK_NEW_LEAVES          ].m_Transparent = true;
+	a_Info[E_BLOCK_NEW_STONE_SLAB      ].m_Transparent = true;
 	a_Info[E_BLOCK_PISTON              ].m_Transparent = true;
 	a_Info[E_BLOCK_PISTON_EXTENSION    ].m_Transparent = true;
 	a_Info[E_BLOCK_PISTON_MOVED_BLOCK  ].m_Transparent = true;
@@ -257,6 +249,9 @@ void cBlockInfo::Initialize(cBlockInfoArray & a_Info)
 	a_Info[E_BLOCK_SAPLING             ].m_Transparent = true;
 	a_Info[E_BLOCK_SIGN_POST           ].m_Transparent = true;
 	a_Info[E_BLOCK_SNOW                ].m_Transparent = true;
+	a_Info[E_BLOCK_SPRUCE_DOOR         ].m_Transparent = true;
+	a_Info[E_BLOCK_SPRUCE_FENCE        ].m_Transparent = true;
+	a_Info[E_BLOCK_SPRUCE_FENCE_GATE   ].m_Transparent = true;
 	a_Info[E_BLOCK_STAINED_GLASS       ].m_Transparent = true;
 	a_Info[E_BLOCK_STAINED_GLASS_PANE  ].m_Transparent = true;
 	a_Info[E_BLOCK_STATIONARY_LAVA     ].m_Transparent = true;
@@ -388,6 +383,7 @@ void cBlockInfo::Initialize(cBlockInfoArray & a_Info)
 	a_Info[E_BLOCK_DIAMOND_ORE         ].m_IsSnowable = true;
 	a_Info[E_BLOCK_DIRT                ].m_IsSnowable = true;
 	a_Info[E_BLOCK_DISPENSER           ].m_IsSnowable = true;
+	a_Info[E_BLOCK_DOUBLE_NEW_STONE_SLAB].m_IsSnowable = true;
 	a_Info[E_BLOCK_DOUBLE_STONE_SLAB   ].m_IsSnowable = true;
 	a_Info[E_BLOCK_DOUBLE_WOODEN_SLAB  ].m_IsSnowable = true;
 	a_Info[E_BLOCK_DROPPER             ].m_IsSnowable = true;
@@ -424,14 +420,17 @@ void cBlockInfo::Initialize(cBlockInfoArray & a_Info)
 	a_Info[E_BLOCK_NOTE_BLOCK          ].m_IsSnowable = true;
 	a_Info[E_BLOCK_OBSIDIAN            ].m_IsSnowable = true;
 	a_Info[E_BLOCK_PLANKS              ].m_IsSnowable = true;
+	a_Info[E_BLOCK_PRISMARINE_BLOCK    ].m_IsSnowable = true;
 	a_Info[E_BLOCK_PUMPKIN             ].m_IsSnowable = true;
 	a_Info[E_BLOCK_QUARTZ_BLOCK        ].m_IsSnowable = true;
+	a_Info[E_BLOCK_RED_SANDSTONE       ].m_IsSnowable = true;
 	a_Info[E_BLOCK_REDSTONE_LAMP_OFF   ].m_IsSnowable = true;
 	a_Info[E_BLOCK_REDSTONE_LAMP_ON    ].m_IsSnowable = true;
 	a_Info[E_BLOCK_REDSTONE_ORE        ].m_IsSnowable = true;
 	a_Info[E_BLOCK_REDSTONE_ORE_GLOWING].m_IsSnowable = true;
 	a_Info[E_BLOCK_SAND                ].m_IsSnowable = true;
 	a_Info[E_BLOCK_SANDSTONE           ].m_IsSnowable = true;
+	a_Info[E_BLOCK_SEA_LANTERN         ].m_IsSnowable = true;
 	a_Info[E_BLOCK_SILVERFISH_EGG      ].m_IsSnowable = true;
 	a_Info[E_BLOCK_SNOW_BLOCK          ].m_IsSnowable = true;
 	a_Info[E_BLOCK_SOULSAND            ].m_IsSnowable = true;
@@ -488,7 +487,7 @@ void cBlockInfo::Initialize(cBlockInfoArray & a_Info)
 
 
 	// Blocks that fully occupy their voxel - used as a guide for torch placeable blocks, amongst other things:
-	a_Info[E_BLOCK_NEW_LOG             ].m_FullyOccupiesVoxel = true;
+	a_Info[E_BLOCK_BARRIER             ].m_FullyOccupiesVoxel = true;
 	a_Info[E_BLOCK_BEDROCK             ].m_FullyOccupiesVoxel = true;
 	a_Info[E_BLOCK_BLOCK_OF_COAL       ].m_FullyOccupiesVoxel = true;
 	a_Info[E_BLOCK_BLOCK_OF_REDSTONE   ].m_FullyOccupiesVoxel = true;
@@ -533,12 +532,15 @@ void cBlockInfo::Initialize(cBlockInfoArray & a_Info)
 	a_Info[E_BLOCK_NETHERRACK          ].m_FullyOccupiesVoxel = true;
 	a_Info[E_BLOCK_NETHER_BRICK        ].m_FullyOccupiesVoxel = true;
 	a_Info[E_BLOCK_NETHER_QUARTZ_ORE   ].m_FullyOccupiesVoxel = true;
+	a_Info[E_BLOCK_NEW_LOG             ].m_FullyOccupiesVoxel = true;
 	a_Info[E_BLOCK_NOTE_BLOCK          ].m_FullyOccupiesVoxel = true;
 	a_Info[E_BLOCK_OBSIDIAN            ].m_FullyOccupiesVoxel = true;
 	a_Info[E_BLOCK_PACKED_ICE          ].m_FullyOccupiesVoxel = true;
 	a_Info[E_BLOCK_PLANKS              ].m_FullyOccupiesVoxel = true;
+	a_Info[E_BLOCK_PRISMARINE_BLOCK    ].m_FullyOccupiesVoxel = true;
 	a_Info[E_BLOCK_PUMPKIN             ].m_FullyOccupiesVoxel = true;
 	a_Info[E_BLOCK_QUARTZ_BLOCK        ].m_FullyOccupiesVoxel = true;
+	a_Info[E_BLOCK_RED_SANDSTONE       ].m_FullyOccupiesVoxel = true;
 	a_Info[E_BLOCK_REDSTONE_LAMP_OFF   ].m_FullyOccupiesVoxel = true;
 	a_Info[E_BLOCK_REDSTONE_LAMP_ON    ].m_FullyOccupiesVoxel = true;
 	a_Info[E_BLOCK_REDSTONE_ORE        ].m_FullyOccupiesVoxel = true;
@@ -732,12 +734,35 @@ void cBlockInfo::Initialize(cBlockInfoArray & a_Info)
 	a_Info[E_BLOCK_NEW_LOG             ].m_PlaceSound = "dig.wood";
 	a_Info[E_BLOCK_ACACIA_WOOD_STAIRS  ].m_PlaceSound = "dig.wood";
 	a_Info[E_BLOCK_DARK_OAK_WOOD_STAIRS ].m_PlaceSound = "dig.wood";
+	a_Info[E_BLOCK_SLIME_BLOCK         ].m_PlaceSound = "dig.slime"; // I hope it is named slime, it's definetly a new sound type though...
+	a_Info[E_BLOCK_BARRIER             ].m_PlaceSound = "dig.stone";
+	a_Info[E_BLOCK_IRON_TRAPDOOR       ].m_PlaceSound = "dig.metal";
+	a_Info[E_BLOCK_PRISMARINE_BLOCK    ].m_PlaceSound = "dig.stone";
+	a_Info[E_BLOCK_SEA_LANTERN         ].m_PlaceSound = "dig.stone";
 	a_Info[E_BLOCK_HAY_BALE            ].m_PlaceSound = "dig.grass";
 	a_Info[E_BLOCK_CARPET              ].m_PlaceSound = "dig.cloth";
 	a_Info[E_BLOCK_HARDENED_CLAY       ].m_PlaceSound = "dig.stone";
 	a_Info[E_BLOCK_BLOCK_OF_COAL       ].m_PlaceSound = "dig.stone";
 	a_Info[E_BLOCK_PACKED_ICE          ].m_PlaceSound = "dig.stone";
 	a_Info[E_BLOCK_BIG_FLOWER          ].m_PlaceSound = "dig.grass";
+	a_Info[E_BLOCK_RED_SANDSTONE       ].m_PlaceSound = "dig.stone";
+	a_Info[E_BLOCK_RED_SANDSTONE_STAIRS ].m_PlaceSound = "dig.stone";
+	a_Info[E_BLOCK_NEW_STONE_SLAB      ].m_PlaceSound = "dig.stone";
+	a_Info[E_BLOCK_SPRUCE_FENCE_GATE   ].m_PlaceSound = "dig.wood";
+	a_Info[E_BLOCK_BIRCH_FENCE_GATE    ].m_PlaceSound = "dig.wood";
+	a_Info[E_BLOCK_JUNGLE_FENCE_GATE   ].m_PlaceSound = "dig.wood";
+	a_Info[E_BLOCK_DARK_OAK_FENCE_GATE ].m_PlaceSound = "dig.wood";
+	a_Info[E_BLOCK_ACACIA_FENCE_GATE   ].m_PlaceSound = "dig.wood";
+	a_Info[E_BLOCK_SPRUCE_FENCE        ].m_PlaceSound = "dig.wood";
+	a_Info[E_BLOCK_BIRCH_FENCE         ].m_PlaceSound = "dig.wood";
+	a_Info[E_BLOCK_JUNGLE_FENCE        ].m_PlaceSound = "dig.wood";
+	a_Info[E_BLOCK_DARK_OAK_FENCE      ].m_PlaceSound = "dig.wood";
+	a_Info[E_BLOCK_ACACIA_FENCE        ].m_PlaceSound = "dig.wood";
+	a_Info[E_BLOCK_SPRUCE_DOOR         ].m_PlaceSound = "dig.wood";
+	a_Info[E_BLOCK_BIRCH_DOOR          ].m_PlaceSound = "dig.wood";
+	a_Info[E_BLOCK_JUNGLE_DOOR         ].m_PlaceSound = "dig.wood";
+	a_Info[E_BLOCK_ACACIA_DOOR         ].m_PlaceSound = "dig.wood";
+	a_Info[E_BLOCK_DARK_OAK_DOOR       ].m_PlaceSound = "dig.wood";
 }
 
 
diff --git a/src/BlockInfo.h b/src/BlockInfo.h
index 567070a7f..1e4cf2ca0 100644
--- a/src/BlockInfo.h
+++ b/src/BlockInfo.h
@@ -11,14 +11,27 @@ class cBlockHandler;
 
 
 
-
 // tolua_begin
 class cBlockInfo
 {
 public:
 
 	/** Returns the associated BlockInfo structure for the specified block type. */
-	static cBlockInfo & Get(BLOCKTYPE a_Type);
+	
+	/** This accessor makes sure that the cBlockInfo structures are properly initialized exactly once.
+	It does so by using the C++ singleton approximation - storing the actual singleton as the function's static variable.
+	It works only if it is called for the first time before the app spawns other threads. */
+	static cBlockInfo & Get(BLOCKTYPE a_Type)
+	{
+		static cBlockInfo ms_Info[256];
+		static bool IsBlockInfoInitialized = false;
+		if (!IsBlockInfoInitialized)
+		{
+			cBlockInfo::Initialize(ms_Info);
+			IsBlockInfoInitialized = true;
+		}
+		return ms_Info[a_Type];
+	}
 
 
 	/** How much light do the blocks emit on their own? */
@@ -78,7 +91,19 @@ protected:
 	typedef cBlockInfo cBlockInfoArray[256];
 
 	/** Creates a default BlockInfo structure, initializes all values to their defaults */
-	cBlockInfo();
+	cBlockInfo()
+		: m_LightValue(0x00)
+		, m_SpreadLightFalloff(0x0f)
+		, m_Transparent(false)
+		, m_OneHitDig(false)
+		, m_PistonBreakable(false)
+		, m_IsSnowable(false)
+		, m_IsSolid(true)
+		, m_FullyOccupiesVoxel(false)
+		, m_CanBeTerraformed(false)
+		, m_PlaceSound("")
+		, m_Handler(NULL)
+	{}
 
 	/** Cleans up the stored values */
 	~cBlockInfo();
diff --git a/src/Blocks/BlockBed.cpp b/src/Blocks/BlockBed.cpp
index cd1cc2a5f..3b6328b38 100644
--- a/src/Blocks/BlockBed.cpp
+++ b/src/Blocks/BlockBed.cpp
@@ -4,6 +4,15 @@
 
 
 
+#include "BroadcastInterface.h"
+#include "ChunkInterface.h"
+#include "Entities/../World.h"
+#include "Entities/Player.h"
+#include "WorldInterface.h"
+
+
+
+
 
 void cBlockBedHandler::OnPlacedByPlayer(
 	cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player,
diff --git a/src/Blocks/BlockBed.h b/src/Blocks/BlockBed.h
index bf9d9c01d..9fd45644b 100644
--- a/src/Blocks/BlockBed.h
+++ b/src/Blocks/BlockBed.h
@@ -2,12 +2,14 @@
 #pragma once
 
 #include "BlockHandler.h"
-#include "ChunkInterface.h"
-#include "WorldInterface.h"
 #include "MetaRotator.h"
-#include "../Entities/Player.h"
+#include "Item.h"
 
 
+class cChunkInterface;
+class cPlayer;
+class cWorldInterface;
+
 
 
 
diff --git a/src/Blocks/BlockBigFlower.h b/src/Blocks/BlockBigFlower.h
index 89ffc864d..3577bdd40 100644
--- a/src/Blocks/BlockBigFlower.h
+++ b/src/Blocks/BlockBigFlower.h
@@ -2,7 +2,7 @@
 #pragma once
 
 #include "BlockHandler.h"
-
+#include "ChunkInterface.h"
 
 
 
diff --git a/src/Blocks/BlockDirt.h b/src/Blocks/BlockDirt.h
index 23e5a3cde..60d81db72 100644
--- a/src/Blocks/BlockDirt.h
+++ b/src/Blocks/BlockDirt.h
@@ -3,8 +3,8 @@
 
 #include "BlockHandler.h"
 #include "../FastRandom.h"
-
-
+#include "Root.h"
+#include "Bindings/PluginManager.h"
 
 
 
diff --git a/src/Blocks/BlockDoor.cpp b/src/Blocks/BlockDoor.cpp
index 1a277f071..96345a2df 100644
--- a/src/Blocks/BlockDoor.cpp
+++ b/src/Blocks/BlockDoor.cpp
@@ -1,7 +1,6 @@
 
 #include "Globals.h"
 #include "BlockDoor.h"
-#include "../Item.h"
 #include "../Entities/Player.h"
 
 
diff --git a/src/Blocks/BlockDoor.h b/src/Blocks/BlockDoor.h
index 69e30d9c8..b2f9e4dcd 100644
--- a/src/Blocks/BlockDoor.h
+++ b/src/Blocks/BlockDoor.h
@@ -5,6 +5,7 @@
 #include "../Entities/Player.h"
 #include "Chunk.h"
 #include "MetaRotator.h"
+#include "ChunkInterface.h"
 
 
 
diff --git a/src/Blocks/BlockHandler.cpp b/src/Blocks/BlockHandler.cpp
index 30b303cfd..7bfff0545 100644
--- a/src/Blocks/BlockHandler.cpp
+++ b/src/Blocks/BlockHandler.cpp
@@ -3,8 +3,6 @@
 #include "BlockHandler.h"
 #include "../Item.h"
 #include "../World.h"
-#include "../Root.h"
-#include "../Bindings/PluginManager.h"
 #include "../Chunk.h"
 #include "BlockAnvil.h"
 #include "BlockBed.h"
@@ -68,6 +66,7 @@
 #include "BlockTripwireHook.h"
 #include "BlockSand.h"
 #include "BlockSapling.h"
+#include "BlockSeaLantern.h"
 #include "BlockSideways.h"
 #include "BlockSignPost.h"
 #include "BlockSlab.h"
@@ -84,6 +83,8 @@
 #include "BlockWorkbench.h"
 
 
+#include "BlockPluginInterface.h"
+
 
 
 
@@ -177,12 +178,16 @@ cBlockHandler * cBlockHandler::CreateBlockHandler(BLOCKTYPE a_BlockType)
 	switch (a_BlockType)
 	{
 		// Block handlers, alphabetically sorted:
+		case E_BLOCK_ACACIA_DOOR:           return new cBlockDoorHandler            (a_BlockType);
+		case E_BLOCK_ACACIA_FENCE_GATE:     return new cBlockFenceGateHandler       (a_BlockType);
 		case E_BLOCK_ACACIA_WOOD_STAIRS:    return new cBlockStairsHandler          (a_BlockType);
 		case E_BLOCK_ACTIVATOR_RAIL:        return new cBlockRailHandler            (a_BlockType);
 		case E_BLOCK_ANVIL:                 return new cBlockAnvilHandler           (a_BlockType);
 		case E_BLOCK_BEACON:                return new cBlockEntityHandler          (a_BlockType);
 		case E_BLOCK_BED:                   return new cBlockBedHandler             (a_BlockType);
 		case E_BLOCK_BIG_FLOWER:            return new cBlockBigFlowerHandler       (a_BlockType);
+		case E_BLOCK_BIRCH_DOOR:            return new cBlockDoorHandler            (a_BlockType);
+		case E_BLOCK_BIRCH_FENCE_GATE:      return new cBlockFenceGateHandler       (a_BlockType);
 		case E_BLOCK_BIRCH_WOOD_STAIRS:     return new cBlockStairsHandler          (a_BlockType);
 		case E_BLOCK_BREWING_STAND:         return new cBlockBrewingStandHandler    (a_BlockType);
 		case E_BLOCK_BRICK_STAIRS:          return new cBlockStairsHandler          (a_BlockType);
@@ -200,12 +205,15 @@ cBlockHandler * cBlockHandler::CreateBlockHandler(BLOCKTYPE a_BlockType)
 		case E_BLOCK_COBBLESTONE_STAIRS:    return new cBlockStairsHandler          (a_BlockType);
 		case E_BLOCK_COBWEB:                return new cBlockCobWebHandler          (a_BlockType);
 		case E_BLOCK_CROPS:                 return new cBlockCropsHandler           (a_BlockType);
+		case E_BLOCK_DARK_OAK_DOOR:         return new cBlockDoorHandler            (a_BlockType);
+		case E_BLOCK_DARK_OAK_FENCE_GATE:   return new cBlockFenceGateHandler       (a_BlockType);
 		case E_BLOCK_DARK_OAK_WOOD_STAIRS:  return new cBlockStairsHandler          (a_BlockType);
 		case E_BLOCK_DEAD_BUSH:             return new cBlockDeadBushHandler        (a_BlockType);
 		case E_BLOCK_DETECTOR_RAIL:         return new cBlockRailHandler            (a_BlockType);
 		case E_BLOCK_DIAMOND_ORE:           return new cBlockOreHandler             (a_BlockType);
 		case E_BLOCK_DIRT:                  return new cBlockDirtHandler            (a_BlockType);
 		case E_BLOCK_DISPENSER:             return new cBlockDropSpenserHandler     (a_BlockType);
+		case E_BLOCK_DOUBLE_NEW_STONE_SLAB: return new cBlockDoubleSlabHandler      (a_BlockType);
 		case E_BLOCK_DOUBLE_STONE_SLAB:     return new cBlockDoubleSlabHandler      (a_BlockType);
 		case E_BLOCK_DOUBLE_WOODEN_SLAB:    return new cBlockDoubleSlabHandler      (a_BlockType);
 		case E_BLOCK_DROPPER:               return new cBlockDropSpenserHandler     (a_BlockType);
@@ -231,8 +239,11 @@ cBlockHandler * cBlockHandler::CreateBlockHandler(BLOCKTYPE a_BlockType)
 		case E_BLOCK_INACTIVE_COMPARATOR:   return new cBlockComparatorHandler      (a_BlockType);
 		case E_BLOCK_IRON_DOOR:             return new cBlockDoorHandler            (a_BlockType);
 		case E_BLOCK_IRON_ORE:              return new cBlockOreHandler             (a_BlockType);
+		case E_BLOCK_IRON_TRAPDOOR:         return new cBlockTrapdoorHandler        (a_BlockType);
 		case E_BLOCK_JACK_O_LANTERN:        return new cBlockPumpkinHandler         (a_BlockType);
 		case E_BLOCK_JUKEBOX:               return new cBlockEntityHandler          (a_BlockType);
+		case E_BLOCK_JUNGLE_DOOR:           return new cBlockDoorHandler            (a_BlockType);
+		case E_BLOCK_JUNGLE_FENCE_GATE:     return new cBlockFenceGateHandler       (a_BlockType);
 		case E_BLOCK_JUNGLE_WOOD_STAIRS:    return new cBlockStairsHandler          (a_BlockType);
 		case E_BLOCK_LADDER:                return new cBlockLadderHandler          (a_BlockType);
 		case E_BLOCK_LEVER:                 return new cBlockLeverHandler           (a_BlockType);
@@ -253,6 +264,7 @@ cBlockHandler * cBlockHandler::CreateBlockHandler(BLOCKTYPE a_BlockType)
 		case E_BLOCK_NETHER_QUARTZ_ORE:     return new cBlockOreHandler             (a_BlockType);
 		case E_BLOCK_NEW_LEAVES:            return new cBlockLeavesHandler          (a_BlockType);
 		case E_BLOCK_NEW_LOG:               return new cBlockSidewaysHandler        (a_BlockType);
+		case E_BLOCK_NEW_STONE_SLAB:        return new cBlockSlabHandler            (a_BlockType);
 		case E_BLOCK_NOTE_BLOCK:            return new cBlockEntityHandler          (a_BlockType);
 		case E_BLOCK_PISTON:                return new cBlockPistonHandler          (a_BlockType);
 		case E_BLOCK_PISTON_EXTENSION:      return new cBlockPistonHeadHandler;
@@ -264,6 +276,7 @@ cBlockHandler * cBlockHandler::CreateBlockHandler(BLOCKTYPE a_BlockType)
 		case E_BLOCK_QUARTZ_BLOCK:          return new cBlockQuartzHandler          (a_BlockType);
 		case E_BLOCK_QUARTZ_STAIRS:         return new cBlockStairsHandler          (a_BlockType);
 		case E_BLOCK_RAIL:                  return new cBlockRailHandler            (a_BlockType);
+		case E_BLOCK_RED_SANDSTONE_STAIRS:  return new cBlockStairsHandler          (a_BlockType);
 		case E_BLOCK_REDSTONE_LAMP_ON:      return new cBlockRedstoneLampHandler    (a_BlockType);
 		case E_BLOCK_REDSTONE_ORE:          return new cBlockOreHandler             (a_BlockType);
 		case E_BLOCK_REDSTONE_ORE_GLOWING:  return new cBlockOreHandler             (a_BlockType);
@@ -277,8 +290,10 @@ cBlockHandler * cBlockHandler::CreateBlockHandler(BLOCKTYPE a_BlockType)
 		case E_BLOCK_SAND:                  return new cBlockSandHandler            (a_BlockType);
 		case E_BLOCK_SANDSTONE_STAIRS:      return new cBlockStairsHandler          (a_BlockType);
 		case E_BLOCK_SAPLING:               return new cBlockSaplingHandler         (a_BlockType);
+		case E_BLOCK_SEA_LANTERN:           return new cBlockSeaLanternHandler      (a_BlockType);
 		case E_BLOCK_SIGN_POST:             return new cBlockSignPostHandler        (a_BlockType);
 		case E_BLOCK_SNOW:                  return new cBlockSnowHandler            (a_BlockType);
+		case E_BLOCK_SPRUCE_DOOR:           return new cBlockDoorHandler            (a_BlockType);
 		case E_BLOCK_SPRUCE_WOOD_STAIRS:    return new cBlockStairsHandler          (a_BlockType);
 		case E_BLOCK_STAINED_GLASS:         return new cBlockGlassHandler           (a_BlockType);
 		case E_BLOCK_STAINED_GLASS_PANE:    return new cBlockGlassHandler           (a_BlockType);
diff --git a/src/Blocks/BlockHandler.h b/src/Blocks/BlockHandler.h
index 3a8115da0..83de836cb 100644
--- a/src/Blocks/BlockHandler.h
+++ b/src/Blocks/BlockHandler.h
@@ -2,10 +2,6 @@
 #pragma once
 
 #include "../Defines.h"
-#include "../Item.h"
-#include "WorldInterface.h"
-#include "ChunkInterface.h"
-#include "BlockPluginInterface.h"
 
 
 
@@ -14,6 +10,10 @@
 // fwd:
 class cPlayer;
 class cChunk;
+class cBlockPluginInterface;
+class cChunkInterface;
+class cWorldInterface;
+class cItems;
 
 
 
diff --git a/src/Blocks/BlockMobHead.h b/src/Blocks/BlockMobHead.h
index b51155802..e21e42334 100644
--- a/src/Blocks/BlockMobHead.h
+++ b/src/Blocks/BlockMobHead.h
@@ -151,7 +151,7 @@ public:
 			a_ChunkInterface.SetBlock(a_BlockX - 1, a_BlockY, a_BlockZ, E_BLOCK_AIR, 0);
 
 			// Spawn the wither:
-			a_WorldInterface.SpawnMob(a_BlockX + 0.5, a_BlockY - 2, a_BlockZ + 0.5, cMonster::mtWither);
+			a_WorldInterface.SpawnMob(a_BlockX + 0.5, a_BlockY - 2, a_BlockZ + 0.5, mtWither);
 
 			// Award Achievement
 			a_WorldInterface.ForEachPlayer(PlayerCallback);
@@ -181,7 +181,7 @@ public:
 			a_ChunkInterface.SetBlock(a_BlockX, a_BlockY, a_BlockZ - 1, E_BLOCK_AIR, 0);
 
 			// Spawn the wither:
-			a_WorldInterface.SpawnMob(a_BlockX + 0.5, a_BlockY - 2, a_BlockZ + 0.5, cMonster::mtWither);
+			a_WorldInterface.SpawnMob(a_BlockX + 0.5, a_BlockY - 2, a_BlockZ + 0.5, mtWither);
 
 			// Award Achievement
 			a_WorldInterface.ForEachPlayer(PlayerCallback);
diff --git a/src/Blocks/BlockPiston.cpp b/src/Blocks/BlockPiston.cpp
index 0169fb266..34d11f675 100644
--- a/src/Blocks/BlockPiston.cpp
+++ b/src/Blocks/BlockPiston.cpp
@@ -5,6 +5,7 @@
 #include "../World.h"
 #include "../Entities/Player.h"
 #include "BlockInServerPluginInterface.h"
+#include "ChunkInterface.h"
 
 
 
diff --git a/src/Blocks/BlockPiston.h b/src/Blocks/BlockPiston.h
index 0bec603e3..3a3fc7224 100644
--- a/src/Blocks/BlockPiston.h
+++ b/src/Blocks/BlockPiston.h
@@ -4,7 +4,7 @@
 #include "BlockHandler.h"
 
 
-
+class cWorld;
 
 
 class cBlockPistonHandler :
@@ -94,6 +94,7 @@ private:
 		switch (a_BlockType)
 		{
 			case E_BLOCK_ANVIL:
+			case E_BLOCK_BARRIER:
 			case E_BLOCK_BEACON:
 			case E_BLOCK_BEDROCK:
 			case E_BLOCK_BREWING_STAND:
diff --git a/src/Blocks/BlockPortal.h b/src/Blocks/BlockPortal.h
index 8fac2a126..97ba26ee3 100644
--- a/src/Blocks/BlockPortal.h
+++ b/src/Blocks/BlockPortal.h
@@ -50,7 +50,7 @@ public:
 		int PosX = a_Chunk.GetPosX() * cChunkDef::Width + a_RelX;
 		int PosZ = a_Chunk.GetPosZ() * cChunkDef::Width + a_RelZ;
 
-		a_WorldInterface.SpawnMob(PosX, a_RelY, PosZ, cMonster::mtZombiePigman);
+		a_WorldInterface.SpawnMob(PosX, a_RelY, PosZ, mtZombiePigman);
 	}
 
 	virtual bool CanBeAt(cChunkInterface & a_ChunkInterface, int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
diff --git a/src/Blocks/BlockPumpkin.h b/src/Blocks/BlockPumpkin.h
index 15ac80fd7..275d1422a 100644
--- a/src/Blocks/BlockPumpkin.h
+++ b/src/Blocks/BlockPumpkin.h
@@ -36,7 +36,7 @@ public:
 			a_ChunkInterface.FastSetBlock(a_BlockX, a_BlockY,     a_BlockZ, E_BLOCK_AIR, 0);
 			a_ChunkInterface.FastSetBlock(a_BlockX, a_BlockY - 1, a_BlockZ, E_BLOCK_AIR, 0);
 			a_ChunkInterface.FastSetBlock(a_BlockX, a_BlockY - 2, a_BlockZ, E_BLOCK_AIR, 0);
-			a_WorldInterface.SpawnMob(a_BlockX + 0.5, a_BlockY - 2, a_BlockZ + 0.5, cMonster::mtSnowGolem);
+			a_WorldInterface.SpawnMob(a_BlockX + 0.5, a_BlockY - 2, a_BlockZ + 0.5, mtSnowGolem);
 			return;
 		}
 		
@@ -61,7 +61,7 @@ public:
 			a_ChunkInterface.FastSetBlock(a_BlockX,     a_BlockY - 2, a_BlockZ, E_BLOCK_AIR, 0);
 			
 			// Spawn the golem:
-			a_WorldInterface.SpawnMob(a_BlockX + 0.5, a_BlockY - 2, a_BlockZ + 0.5, cMonster::mtIronGolem);
+			a_WorldInterface.SpawnMob(a_BlockX + 0.5, a_BlockY - 2, a_BlockZ + 0.5, mtIronGolem);
 		}
 		else if (
 			(a_ChunkInterface.GetBlock(a_BlockX, a_BlockY - 1, a_BlockZ + 1) == E_BLOCK_IRON_BLOCK) &&
@@ -76,7 +76,7 @@ public:
 			a_ChunkInterface.FastSetBlock(a_BlockX, a_BlockY - 2, a_BlockZ,     E_BLOCK_AIR, 0);
 			
 			// Spawn the golem:
-			a_WorldInterface.SpawnMob(a_BlockX + 0.5, a_BlockY - 2, a_BlockZ + 0.5, cMonster::mtIronGolem);
+			a_WorldInterface.SpawnMob(a_BlockX + 0.5, a_BlockY - 2, a_BlockZ + 0.5, mtIronGolem);
 		}
 	}
 
diff --git a/src/Blocks/BlockRedstoneRepeater.h b/src/Blocks/BlockRedstoneRepeater.h
index 3e5259c56..1eb67f714 100644
--- a/src/Blocks/BlockRedstoneRepeater.h
+++ b/src/Blocks/BlockRedstoneRepeater.h
@@ -4,7 +4,7 @@
 #include "BlockHandler.h"
 #include "Chunk.h"
 #include "MetaRotator.h"
-
+#include "ChunkInterface.h"
 
 
 
diff --git a/src/Blocks/BlockSeaLantern.h b/src/Blocks/BlockSeaLantern.h
new file mode 100644
index 000000000..a9259d1d6
--- /dev/null
+++ b/src/Blocks/BlockSeaLantern.h
@@ -0,0 +1,30 @@
+
+#pragma once
+
+#include "BlockHandler.h"
+
+
+
+
+
+class cBlockSeaLanternHandler :
+	public cBlockHandler
+{
+public:
+	cBlockSeaLanternHandler(BLOCKTYPE a_BlockType)
+		: cBlockHandler(a_BlockType)
+	{
+	}
+
+
+	virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
+	{
+		// Reset meta to 0
+		cFastRandom Random;
+		a_Pickups.push_back(cItem(E_ITEM_PRISMARINE_CRYSTALS, (char)(2 + Random.NextInt(2)), 0));
+	}
+} ;
+
+
+
+
diff --git a/src/Blocks/BlockSlab.h b/src/Blocks/BlockSlab.h
index 0ad30bb2b..ffe2414f7 100644
--- a/src/Blocks/BlockSlab.h
+++ b/src/Blocks/BlockSlab.h
@@ -12,6 +12,7 @@
 #include "BlockHandler.h"
 #include "../Items/ItemHandler.h"
 #include "Root.h"
+#include "ChunkInterface.h"
 
 
 
@@ -96,7 +97,7 @@ public:
 	/// Returns true if the specified blocktype is one of the slabs handled by this handler
 	static bool IsAnySlabType(BLOCKTYPE a_BlockType)
 	{
-		return ((a_BlockType == E_BLOCK_WOODEN_SLAB) || (a_BlockType == E_BLOCK_STONE_SLAB));
+		return ((a_BlockType == E_BLOCK_WOODEN_SLAB) || (a_BlockType == E_BLOCK_STONE_SLAB) || (a_BlockType == E_BLOCK_NEW_STONE_SLAB));
 	}
 
 
@@ -119,6 +120,7 @@ public:
 		{
 			case E_BLOCK_STONE_SLAB:  return E_BLOCK_DOUBLE_STONE_SLAB;
 			case E_BLOCK_WOODEN_SLAB: return E_BLOCK_DOUBLE_WOODEN_SLAB;
+			case E_BLOCK_NEW_STONE_SLAB: return E_BLOCK_DOUBLE_NEW_STONE_SLAB;
 		}
 		ASSERT(!"Unhandled slab type!");
 		return E_BLOCK_AIR;
@@ -158,6 +160,7 @@ public:
 		{
 			case E_BLOCK_DOUBLE_STONE_SLAB:  return E_BLOCK_STONE_SLAB;
 			case E_BLOCK_DOUBLE_WOODEN_SLAB: return E_BLOCK_WOODEN_SLAB;
+			case E_BLOCK_DOUBLE_NEW_STONE_SLAB: return E_BLOCK_NEW_STONE_SLAB;
 		}
 		ASSERT(!"Unhandled double slab type!");
 		return a_BlockType;
diff --git a/src/Blocks/BlockVine.h b/src/Blocks/BlockVine.h
index b61673cc5..06d84f2d4 100644
--- a/src/Blocks/BlockVine.h
+++ b/src/Blocks/BlockVine.h
@@ -2,7 +2,7 @@
 
 #include "BlockHandler.h"
 #include "MetaRotator.h"
-
+#include "Bindings/PluginManager.h"
 
 
 
diff --git a/src/Blocks/ChunkInterface.cpp b/src/Blocks/ChunkInterface.cpp
index 540581ae7..e22a1410e 100644
--- a/src/Blocks/ChunkInterface.cpp
+++ b/src/Blocks/ChunkInterface.cpp
@@ -2,7 +2,139 @@
 #include "Globals.h"
 
 #include "ChunkInterface.h"
+#include "ChunkMap.h"
 #include "BlockHandler.h"
+#include "WorldInterface.h" 
+
+
+
+
+
+
+BLOCKTYPE cChunkInterface::GetBlock(int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	return m_ChunkMap->GetBlock(a_BlockX, a_BlockY, a_BlockZ);
+}
+
+
+
+
+
+BLOCKTYPE cChunkInterface::GetBlock(const Vector3i & a_Pos)
+{
+	return GetBlock(a_Pos.x, a_Pos.y, a_Pos.z);
+}
+
+
+
+
+
+NIBBLETYPE cChunkInterface::GetBlockMeta(int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	return m_ChunkMap->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
+}
+
+
+
+
+
+
+bool cChunkInterface::GetBlockTypeMeta(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta)
+{
+	return m_ChunkMap->GetBlockTypeMeta(a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta);
+}
+
+
+
+
+
+
+/** Sets the block at the specified coords to the specified value.
+Full processing, incl. updating neighbors, is performed.
+*/
+void cChunkInterface::SetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
+{
+	m_ChunkMap->SetBlock(a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta);
+}
+
+
+
+
+
+
+void cChunkInterface::SetBlockMeta(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_MetaData)
+{
+	m_ChunkMap->SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, a_MetaData);
+}
+
+
+
+
+
+
+void cChunkInterface::QueueSetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, int a_TickDelay, BLOCKTYPE a_PreviousBlockType, cWorldInterface &  a_WorldInterface)
+{
+	m_ChunkMap->QueueSetBlock(a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta, a_WorldInterface.GetWorldAge() + a_TickDelay, a_PreviousBlockType);
+}
+
+
+
+
+
+
+/** Sets the block at the specified coords to the specified value.
+The replacement doesn't trigger block updates.
+The replaced blocks aren't checked for block entities (block entity is leaked if it exists at this block)
+*/
+void cChunkInterface::FastSetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
+{
+	m_ChunkMap->FastSetBlock(a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta);
+}
+
+
+
+
+
+
+void cChunkInterface::FastSetBlock(const Vector3i & a_Pos, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
+{
+	FastSetBlock( a_Pos.x, a_Pos.y, a_Pos.z, a_BlockType, a_BlockMeta);
+}
+
+
+
+
+
+
+void cChunkInterface::UseBlockEntity(cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	m_ChunkMap->UseBlockEntity(a_Player, a_BlockX, a_BlockY, a_BlockZ);
+}
+
+
+
+
+
+
+bool cChunkInterface::ForEachChunkInRect(int a_MinChunkX, int a_MaxChunkX, int a_MinChunkZ, int a_MaxChunkZ, cChunkDataCallback & a_Callback)
+{
+	return m_ChunkMap->ForEachChunkInRect(a_MinChunkX, a_MaxChunkX, a_MinChunkZ, a_MaxChunkZ, a_Callback);
+}
+
+
+
+
+
+
+bool cChunkInterface::WriteBlockArea(cBlockArea & a_Area, int a_MinBlockX, int a_MinBlockY, int a_MinBlockZ, int a_DataTypes)
+{
+	return m_ChunkMap->WriteBlockArea(a_Area, a_MinBlockX, a_MinBlockY, a_MinBlockZ, a_DataTypes);
+}
+
+
+
+
+
 
 bool cChunkInterface::DigBlock(cWorldInterface & a_WorldInterface, int a_X, int a_Y, int a_Z)
 {
@@ -10,3 +142,4 @@ bool cChunkInterface::DigBlock(cWorldInterface & a_WorldInterface, int a_X, int
 	Handler->OnDestroyed(*this, a_WorldInterface, a_X, a_Y, a_Z);
 	return m_ChunkMap->DigBlock(a_X, a_Y, a_Z);
 }
+
diff --git a/src/Blocks/ChunkInterface.h b/src/Blocks/ChunkInterface.h
index d5f1f1273..2f0cfea11 100644
--- a/src/Blocks/ChunkInterface.h
+++ b/src/Blocks/ChunkInterface.h
@@ -1,13 +1,13 @@
 
 #pragma once
 
-#include "../ChunkMap.h"
 #include "../ForEachChunkProvider.h"
-#include "WorldInterface.h"
-
 
 
 
+class cChunkMap;
+class cWorldInterface;
+class cPlayer;
 
 class cChunkInterface:
 	public cForEachChunkProvider
@@ -16,70 +16,34 @@ public:
 
 	cChunkInterface(cChunkMap * a_ChunkMap) : m_ChunkMap(a_ChunkMap) {}
 
-	BLOCKTYPE GetBlock(int a_BlockX, int a_BlockY, int a_BlockZ)
-	{
-		return m_ChunkMap->GetBlock(a_BlockX, a_BlockY, a_BlockZ);
-	}
-	BLOCKTYPE GetBlock(const Vector3i & a_Pos)
-	{
-		return GetBlock(a_Pos.x, a_Pos.y, a_Pos.z);
-	}
-	NIBBLETYPE GetBlockMeta(int a_BlockX, int a_BlockY, int a_BlockZ)
-	{
-		return m_ChunkMap->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
-	}
+	BLOCKTYPE GetBlock(int a_BlockX, int a_BlockY, int a_BlockZ);
+	BLOCKTYPE GetBlock(const Vector3i & a_Pos);
+	NIBBLETYPE GetBlockMeta(int a_BlockX, int a_BlockY, int a_BlockZ);
 
-	bool GetBlockTypeMeta(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta)
-	{
-		return m_ChunkMap->GetBlockTypeMeta(a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta);
-	}
+	bool GetBlockTypeMeta(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta);
 	
 	/** Sets the block at the specified coords to the specified value.
 	Full processing, incl. updating neighbors, is performed.
 	*/
-	void SetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
-	{
-		m_ChunkMap->SetBlock(a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta);
-	}
+	void SetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
 	
-	void SetBlockMeta(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_MetaData)
-	{
-		m_ChunkMap->SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, a_MetaData);
-	}
+	void SetBlockMeta(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_MetaData);
 	
-	void QueueSetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, int a_TickDelay, BLOCKTYPE a_PreviousBlockType, cWorldInterface &  a_WorldInterface)
-	{
-		m_ChunkMap->QueueSetBlock(a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta, a_WorldInterface.GetWorldAge() + a_TickDelay, a_PreviousBlockType);
-	}
+	void QueueSetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, int a_TickDelay, BLOCKTYPE a_PreviousBlockType, cWorldInterface &  a_WorldInterface);
 	
 	/** Sets the block at the specified coords to the specified value.
 	The replacement doesn't trigger block updates.
 	The replaced blocks aren't checked for block entities (block entity is leaked if it exists at this block)
 	*/
-	void FastSetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
-	{
-		m_ChunkMap->FastSetBlock(a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta);
-	}
+	void FastSetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
 	
-	void FastSetBlock(const Vector3i & a_Pos, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
-	{
-		FastSetBlock( a_Pos.x, a_Pos.y, a_Pos.z, a_BlockType, a_BlockMeta);
-	}
+	void FastSetBlock(const Vector3i & a_Pos, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
 
-	void UseBlockEntity(cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ)
-	{
-		m_ChunkMap->UseBlockEntity(a_Player, a_BlockX, a_BlockY, a_BlockZ);
-	}
+	void UseBlockEntity(cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ);
 	
-	virtual bool ForEachChunkInRect(int a_MinChunkX, int a_MaxChunkX, int a_MinChunkZ, int a_MaxChunkZ, cChunkDataCallback & a_Callback) override
-	{
-		return m_ChunkMap->ForEachChunkInRect(a_MinChunkX, a_MaxChunkX, a_MinChunkZ, a_MaxChunkZ, a_Callback);
-	}
+	virtual bool ForEachChunkInRect(int a_MinChunkX, int a_MaxChunkX, int a_MinChunkZ, int a_MaxChunkZ, cChunkDataCallback & a_Callback) override;
 	
-	virtual bool WriteBlockArea(cBlockArea & a_Area, int a_MinBlockX, int a_MinBlockY, int a_MinBlockZ, int a_DataTypes) override
-	{
-		return m_ChunkMap->WriteBlockArea(a_Area, a_MinBlockX, a_MinBlockY, a_MinBlockZ, a_DataTypes);
-	}
+	virtual bool WriteBlockArea(cBlockArea & a_Area, int a_MinBlockX, int a_MinBlockY, int a_MinBlockZ, int a_DataTypes) override;
 	
 	bool DigBlock(cWorldInterface & a_WorldInterface, int a_X, int a_Y, int a_Z);
 	
diff --git a/src/Blocks/GetHandlerCompileTimeTemplate.h b/src/Blocks/GetHandlerCompileTimeTemplate.h
new file mode 100644
index 000000000..3466b5426
--- /dev/null
+++ b/src/Blocks/GetHandlerCompileTimeTemplate.h
@@ -0,0 +1,91 @@
+
+#pragma once
+
+class cBlockTorchHandler;
+class cBlockLeverHandler;
+class cBlockButtonHandler;
+class cBlockTripwireHookHandler;
+class cBlockDoorHandler;
+class cBlockPistonHandler;
+
+
+
+
+
+
+template<BLOCKTYPE T>
+class GetHandlerCompileTime;
+
+
+
+
+
+
+
+template<>
+class GetHandlerCompileTime<E_BLOCK_TORCH>
+{
+public:
+	typedef cBlockTorchHandler type;
+};
+
+
+
+
+
+
+template<>
+class GetHandlerCompileTime<E_BLOCK_LEVER>
+{
+public:
+	typedef cBlockLeverHandler type;
+};
+
+
+
+
+
+
+template<>
+class GetHandlerCompileTime<E_BLOCK_STONE_BUTTON>
+{
+public:
+	typedef cBlockButtonHandler type;
+};
+
+
+
+
+
+
+template<>
+class GetHandlerCompileTime<E_BLOCK_TRIPWIRE_HOOK>
+{
+public:
+	typedef cBlockTripwireHookHandler type;
+};
+
+
+
+
+
+
+template<>
+class GetHandlerCompileTime<E_BLOCK_WOODEN_DOOR>
+{
+public:
+	typedef cBlockDoorHandler type;
+};
+
+
+
+
+
+
+template<>
+class GetHandlerCompileTime<E_BLOCK_PISTON>
+{
+public:
+	typedef cBlockPistonHandler type;
+};
+
diff --git a/src/Blocks/WorldInterface.h b/src/Blocks/WorldInterface.h
index 889ef1d87..106c314e7 100644
--- a/src/Blocks/WorldInterface.h
+++ b/src/Blocks/WorldInterface.h
@@ -2,14 +2,15 @@
 #pragma once
 
 #include "BroadcastInterface.h"
-#include "../Mobs/Monster.h"
+#include "../Mobs/MonsterTypes.h"
 
 class cItems;
 
 typedef cItemCallback<cBlockEntity> cBlockEntityCallback;
 
 
-
+class cMonster;
+class cPlayer;
 
 
 class cWorldInterface
@@ -33,7 +34,7 @@ public:
 	virtual void SpawnItemPickups(const cItems & a_Pickups, double a_BlockX, double a_BlockY, double a_BlockZ, double a_SpeedX, double a_SpeedY, double a_SpeedZ, bool IsPlayerCreated = false) = 0;
 	
 	/** Spawns a mob of the specified type. Returns the mob's EntityID if recognized and spawned, <0 otherwise */
-	virtual int SpawnMob(double a_PosX, double a_PosY, double a_PosZ, cMonster::eType a_MonsterType) = 0;
+	virtual int SpawnMob(double a_PosX, double a_PosY, double a_PosZ, eMonsterType a_MonsterType) = 0;
 
 	/** Spawns an experience orb at the given location with the given reward. It returns the UniqueID of the spawned experience orb. */
 	virtual int SpawnExperienceOrb(double a_X, double a_Y, double a_Z, int a_Reward) = 0;
diff --git a/src/ByteBuffer.cpp b/src/ByteBuffer.cpp
index 96556bf61..70fdc008c 100644
--- a/src/ByteBuffer.cpp
+++ b/src/ByteBuffer.cpp
@@ -267,7 +267,7 @@ size_t cByteBuffer::GetReadableSpace(void) const
 	}
 	// Single readable space partition:
 	ASSERT(m_WritePos >= m_ReadPos);
-	return m_WritePos - m_ReadPos ;
+	return m_WritePos - m_ReadPos;
 }
 
 
@@ -489,6 +489,30 @@ bool cByteBuffer::ReadLEInt(int & a_Value)
 
 
 
+bool cByteBuffer::ReadPosition(int & a_BlockX, int & a_BlockY, int & a_BlockZ)
+{
+	Int64 Value;
+	if (!ReadBEInt64(Value))
+	{
+		return false;
+	}
+
+	// Convert the 64 received bits into 3 coords:
+	UInt32 BlockXRaw = (Value >> 38) & 0x03ffffff;  // Top 26 bits
+	UInt32 BlockYRaw = (Value >> 26) & 0x0fff;      // Middle 12 bits
+	UInt32 BlockZRaw = (Value & 0x03ffffff);        // Bottom 26 bits
+	
+	// If the highest bit in the number's range is set, convert the number into negative:
+	a_BlockX = ((BlockXRaw & 0x02000000) == 0) ? BlockXRaw : -(0x04000000 - (int)BlockXRaw);
+	a_BlockY = ((BlockYRaw & 0x0800) == 0)     ? BlockYRaw : -(0x0800     - (int)BlockYRaw);
+	a_BlockZ = ((BlockZRaw & 0x02000000) == 0) ? BlockZRaw : -(0x04000000 - (int)BlockZRaw);
+	return true;
+}
+
+
+
+
+
 bool cByteBuffer::WriteChar(char a_Value)
 {
 	CHECK_THREAD;
@@ -526,6 +550,19 @@ bool cByteBuffer::WriteBEShort(short a_Value)
 
 
 
+bool cByteBuffer::WriteBEUShort(unsigned short a_Value)
+{
+	CHECK_THREAD;
+	CheckValid();
+	PUTBYTES(2);
+	u_short Converted = htons((u_short)a_Value);
+	return WriteBuf(&Converted, 2);
+}
+
+
+
+
+
 bool cByteBuffer::WriteBEInt(int a_Value)
 {
 	CHECK_THREAD;
@@ -661,6 +698,15 @@ bool cByteBuffer::WriteLEInt(int a_Value)
 
 
 
+bool cByteBuffer::WritePosition(int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	return WriteBEInt64(((Int64)a_BlockX & 0x3FFFFFF) << 38 | ((Int64)a_BlockY & 0xFFF) << 26 | ((Int64)a_BlockZ & 0x3FFFFFF));
+}
+
+
+
+
+
 bool cByteBuffer::ReadBuf(void * a_Buffer, size_t a_Count)
 {
 	CHECK_THREAD;
diff --git a/src/ByteBuffer.h b/src/ByteBuffer.h
index adaa00330..74dc378d4 100644
--- a/src/ByteBuffer.h
+++ b/src/ByteBuffer.h
@@ -64,6 +64,7 @@ public:
 	bool ReadVarInt         (UInt32 & a_Value);
 	bool ReadVarUTF8String  (AString & a_Value);  // string length as VarInt, then string as UTF-8
 	bool ReadLEInt          (int & a_Value);
+	bool ReadPosition       (int & a_BlockX, int & a_BlockY, int & a_BlockZ);
 
 	/** Reads VarInt, assigns it to anything that can be assigned from an UInt32 (unsigned short, char, Byte, double, ...) */
 	template <typename T> bool ReadVarInt(T & a_Value)
@@ -81,6 +82,7 @@ public:
 	bool WriteChar           (char a_Value);
 	bool WriteByte           (unsigned char a_Value);
 	bool WriteBEShort        (short  a_Value);
+	bool WriteBEUShort       (unsigned short a_Value);
 	bool WriteBEInt          (int    a_Value);
 	bool WriteBEInt64        (Int64  a_Value);
 	bool WriteBEFloat        (float  a_Value);
@@ -90,6 +92,7 @@ public:
 	bool WriteVarInt         (UInt32 a_Value);
 	bool WriteVarUTF8String  (const AString & a_Value);  // string length as VarInt, then string as UTF-8
 	bool WriteLEInt          (int a_Value);
+	bool WritePosition       (int a_BlockX, int a_BlockY, int a_BlockZ);
 	
 	/** Reads a_Count bytes into a_Buffer; returns true if successful */
 	bool ReadBuf(void * a_Buffer, size_t a_Count);
diff --git a/src/Chunk.cpp b/src/Chunk.cpp
index c799f65fd..ddec950ea 100644
--- a/src/Chunk.cpp
+++ b/src/Chunk.cpp
@@ -39,6 +39,7 @@
 #include "BlockInServerPluginInterface.h"
 #include "SetChunkData.h"
 #include "BoundingBox.h"
+#include "Blocks/ChunkInterface.h"
 
 #include "json/json.h"
 
@@ -92,6 +93,7 @@ cChunk::cChunk(
 	m_NeighborZP(a_NeighborZP),
 	m_WaterSimulatorData(a_World->GetWaterSimulator()->CreateChunkData()),
 	m_LavaSimulatorData (a_World->GetLavaSimulator ()->CreateChunkData()),
+	m_RedstoneSimulatorData(NULL),
 	m_AlwaysTicked(0)
 {
 	if (a_NeighborXM != NULL)
@@ -160,6 +162,8 @@ cChunk::~cChunk()
 	m_WaterSimulatorData = NULL;
 	delete m_LavaSimulatorData;
 	m_LavaSimulatorData = NULL;
+	delete m_RedstoneSimulatorData;
+	m_RedstoneSimulatorData = NULL;
 }
 
 
@@ -1368,9 +1372,9 @@ void cChunk::CreateBlockEntities(void)
 
 void cChunk::WakeUpSimulators(void)
 {
-	cSimulator * WaterSimulator = m_World->GetWaterSimulator();
-	cSimulator * LavaSimulator  = m_World->GetLavaSimulator();
-	cSimulator * RedstoneSimulator = m_World->GetRedstoneSimulator();
+	cSimulator<cChunk, cWorld> * WaterSimulator = m_World->GetWaterSimulator();
+	cSimulator<cChunk, cWorld> * LavaSimulator  = m_World->GetLavaSimulator();
+	cSimulator<cChunk, cWorld> * RedstoneSimulator = m_World->GetRedstoneSimulator();
 	int BaseX = m_PosX * cChunkDef::Width;
 	int BaseZ = m_PosZ * cChunkDef::Width;
 	for (int x = 0; x < Width; x++)
@@ -3046,7 +3050,7 @@ void cChunk::BroadcastEntityAnimation(const cEntity & a_Entity, char a_Animation
 
 
 
-void cChunk::BroadcastParticleEffect(const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmmount, cClientHandle * a_Exclude)
+void cChunk::BroadcastParticleEffect(const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmount, cClientHandle * a_Exclude)
 {
 	for (cClientHandleList::iterator itr = m_LoadedByClient.begin(); itr != m_LoadedByClient.end(); ++itr)
 	{
@@ -3054,7 +3058,7 @@ void cChunk::BroadcastParticleEffect(const AString & a_ParticleName, float a_Src
 		{
 			continue;
 		}
-		(*itr)->SendParticleEffect(a_ParticleName, a_SrcX, a_SrcY, a_SrcZ, a_OffsetX, a_OffsetY, a_OffsetZ, a_ParticleData, a_ParticleAmmount);
+		(*itr)->SendParticleEffect(a_ParticleName, a_SrcX, a_SrcY, a_SrcZ, a_OffsetX, a_OffsetY, a_OffsetZ, a_ParticleData, a_ParticleAmount);
 	}  // for itr - LoadedByClient[]
 }
 
diff --git a/src/Chunk.h b/src/Chunk.h
index f282694c2..b525fbb82 100644
--- a/src/Chunk.h
+++ b/src/Chunk.h
@@ -9,7 +9,9 @@
 #include "Simulator/SandSimulator.h"
 #include "Simulator/IncrementalRedstoneSimulator.h"
 
+#include "Blocks/GetHandlerCompileTimeTemplate.h"
 
+#include "ChunkMap.h"
 
 
 
@@ -29,7 +31,10 @@ class MTRand;
 class cPlayer;
 class cChunkMap;
 class cBeaconEntity;
+class cBoundingBox;
 class cChestEntity;
+class cCHunkDataCallback;
+class cCommandBlockEntity;
 class cDispenserEntity;
 class cFurnaceEntity;
 class cNoteEntity;
@@ -44,6 +49,7 @@ class cFluidSimulatorData;
 class cMobCensus;
 class cMobSpawner;
 class cRedstonePoweredEntity;
+class cSetChunkData;
 
 typedef std::list<cClientHandle *>         cClientHandleList;
 typedef cItemCallback<cEntity>             cEntityCallback;
@@ -326,7 +332,7 @@ public:
 	void BroadcastEntityStatus       (const cEntity & a_Entity, char a_Status, const cClientHandle * a_Exclude = NULL);
 	void BroadcastEntityVelocity     (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
 	void BroadcastEntityAnimation    (const cEntity & a_Entity, char a_Animation, const cClientHandle * a_Exclude = NULL);
-	void BroadcastParticleEffect     (const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmmount, cClientHandle * a_Exclude = NULL);
+	void BroadcastParticleEffect     (const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmount, cClientHandle * a_Exclude = NULL);
 	void BroadcastRemoveEntityEffect (const cEntity & a_Entity, int a_EffectID, const cClientHandle * a_Exclude = NULL);
 	void BroadcastSoundEffect        (const AString & a_SoundName, double a_X, double a_Y, double a_Z, float a_Volume, float a_Pitch, const cClientHandle * a_Exclude = NULL);
 	void BroadcastSoundParticleEffect(int a_EffectID, int a_SrcX, int a_SrcY, int a_SrcZ, int a_Data, const cClientHandle * a_Exclude = NULL);
@@ -414,12 +420,7 @@ public:
 	cFluidSimulatorData *     GetLavaSimulatorData (void) { return m_LavaSimulatorData; }
 	cSandSimulatorChunkData & GetSandSimulatorData (void) { return m_SandSimulatorData; }
 
-	cRedstoneSimulatorChunkData * GetRedstoneSimulatorData(void) { return &m_RedstoneSimulatorData; }
-	cRedstoneSimulatorChunkData * GetRedstoneSimulatorQueuedData(void) { return &m_RedstoneSimulatorQueuedData; }
-	cIncrementalRedstoneSimulator::PoweredBlocksList * GetRedstoneSimulatorPoweredBlocksList(void) { return &m_RedstoneSimulatorPoweredBlocksList; }
-	cIncrementalRedstoneSimulator::LinkedBlocksList * GetRedstoneSimulatorLinkedBlocksList(void) { return &m_RedstoneSimulatorLinkedBlocksList; }
-	cIncrementalRedstoneSimulator::SimulatedPlayerToggleableList * GetRedstoneSimulatorSimulatedPlayerToggleableList(void) { return &m_RedstoneSimulatorSimulatedPlayerToggleableList; }
-	cIncrementalRedstoneSimulator::RepeatersDelayList * GetRedstoneSimulatorRepeatersDelayList(void) { return &m_RedstoneSimulatorRepeatersDelayList; }
+	cRedstoneSimulatorChunkData * GetRedstoneSimulatorData(void) { return m_RedstoneSimulatorData; }
 	bool IsRedstoneDirty(void) const { return m_IsRedstoneDirty; }
 	void SetIsRedstoneDirty(bool a_Flag) { m_IsRedstoneDirty = a_Flag; }
 
@@ -504,12 +505,8 @@ private:
 	cFluidSimulatorData *   m_LavaSimulatorData;
 	cSandSimulatorChunkData m_SandSimulatorData;
 
-	cRedstoneSimulatorChunkData m_RedstoneSimulatorData;
-	cRedstoneSimulatorChunkData m_RedstoneSimulatorQueuedData;
-	cIncrementalRedstoneSimulator::PoweredBlocksList m_RedstoneSimulatorPoweredBlocksList;
-	cIncrementalRedstoneSimulator::LinkedBlocksList m_RedstoneSimulatorLinkedBlocksList;
-	cIncrementalRedstoneSimulator::SimulatedPlayerToggleableList m_RedstoneSimulatorSimulatedPlayerToggleableList;
-	cIncrementalRedstoneSimulator::RepeatersDelayList m_RedstoneSimulatorRepeatersDelayList;
+	cRedstoneSimulatorChunkData * m_RedstoneSimulatorData;
+
 
 	/** Indicates if simulate-once blocks should be updated by the redstone simulator */
 	bool m_IsRedstoneDirty;
diff --git a/src/ChunkMap.cpp b/src/ChunkMap.cpp
index e8728091f..38a7d9bd4 100644
--- a/src/ChunkMap.cpp
+++ b/src/ChunkMap.cpp
@@ -17,7 +17,7 @@
 #include "MobSpawner.h"
 #include "BoundingBox.h"
 #include "SetChunkData.h"
-
+#include "Blocks/ChunkInterface.h"
 #include "Entities/Pickup.h"
 
 #ifndef _WIN32
@@ -617,7 +617,7 @@ void cChunkMap::BroadcastEntityAnimation(const cEntity & a_Entity, char a_Animat
 
 
 
-void cChunkMap::BroadcastParticleEffect(const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmmount, cClientHandle * a_Exclude)
+void cChunkMap::BroadcastParticleEffect(const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmount, cClientHandle * a_Exclude)
 {
 	cCSLock Lock(m_CSLayers);
 	int ChunkX, ChunkZ;
@@ -629,7 +629,7 @@ void cChunkMap::BroadcastParticleEffect(const AString & a_ParticleName, float a_
 		return;
 	}
 	// It's perfectly legal to broadcast packets even to invalid chunks!
-	Chunk->BroadcastParticleEffect(a_ParticleName, a_SrcX, a_SrcY, a_SrcZ, a_OffsetX, a_OffsetY, a_OffsetZ, a_ParticleData, a_ParticleAmmount, a_Exclude);
+	Chunk->BroadcastParticleEffect(a_ParticleName, a_SrcX, a_SrcY, a_SrcZ, a_OffsetX, a_OffsetY, a_OffsetZ, a_ParticleData, a_ParticleAmount, a_Exclude);
 }
 
 
diff --git a/src/ChunkMap.h b/src/ChunkMap.h
index dfa1a57b4..6e92833f1 100644
--- a/src/ChunkMap.h
+++ b/src/ChunkMap.h
@@ -87,7 +87,7 @@ public:
 	void BroadcastEntityStatus(const cEntity & a_Entity, char a_Status, const cClientHandle * a_Exclude = NULL);
 	void BroadcastEntityVelocity(const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
 	void BroadcastEntityAnimation(const cEntity & a_Entity, char a_Animation, const cClientHandle * a_Exclude = NULL);
-	void BroadcastParticleEffect(const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmmount, cClientHandle * a_Exclude = NULL);
+	void BroadcastParticleEffect(const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmount, cClientHandle * a_Exclude = NULL);
 	void BroadcastRemoveEntityEffect (const cEntity & a_Entity, int a_EffectID, const cClientHandle * a_Exclude = NULL);
 	void BroadcastSoundEffect(const AString & a_SoundName, double a_X, double a_Y, double a_Z, float a_Volume, float a_Pitch, const cClientHandle * a_Exclude = NULL);
 	void BroadcastSoundParticleEffect(int a_EffectID, int a_SrcX, int a_SrcY, int a_SrcZ, int a_Data, const cClientHandle * a_Exclude = NULL);
diff --git a/src/ChunkSender.cpp b/src/ChunkSender.cpp
index 95c4d03d2..a3151eb3f 100644
--- a/src/ChunkSender.cpp
+++ b/src/ChunkSender.cpp
@@ -12,6 +12,7 @@
 #include "World.h"
 #include "BlockEntities/BlockEntity.h"
 #include "Protocol/ChunkDataSerializer.h"
+#include "ClientHandle.h"
 
 
 
diff --git a/src/ClientHandle.cpp b/src/ClientHandle.cpp
index 4a3a3c250..878d309c9 100644
--- a/src/ClientHandle.cpp
+++ b/src/ClientHandle.cpp
@@ -124,13 +124,14 @@ cClientHandle::~cClientHandle()
 	if (m_Player != NULL)
 	{
 		cWorld * World = m_Player->GetWorld();
-		if (!m_Username.empty() && (World != NULL))
-		{
-			// Send the Offline PlayerList packet:
-			World->BroadcastPlayerListItem(*m_Player, false, this);
-		}
 		if (World != NULL)
 		{
+			if (!m_Username.empty())
+			{
+				// Send the Offline PlayerList packet:
+				World->BroadcastPlayerListRemovePlayer(*m_Player, this);
+			}
+	
 			World->RemovePlayer(m_Player, true);  // Must be called before cPlayer::Destroy() as otherwise cChunk tries to delete the player, and then we do it again
 			m_Player->Destroy();
 		}
@@ -370,7 +371,12 @@ void cClientHandle::Authenticate(const AString & a_Name, const AString & a_UUID,
 
 	// Send experience
 	m_Player->SendExperience();
-	
+
+	// Send player list items
+	SendPlayerListAddPlayer(*m_Player);
+	World->BroadcastPlayerListAddPlayer(*m_Player);
+	World->SendPlayerList(m_Player);
+
 	m_Player->Initialize(*World);
 	m_State = csAuthenticated;
 
@@ -1206,50 +1212,61 @@ void cClientHandle::FinishDigAnimation()
 
 void cClientHandle::HandleRightClick(int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ, const cItem & a_HeldItem)
 {
+	// TODO: Rewrite this function
+
 	LOGD("HandleRightClick: {%d, %d, %d}, face %d, HeldItem: %s",
 		a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, ItemToFullString(a_HeldItem).c_str()
 	);
 	
 	cWorld * World = m_Player->GetWorld();
+	bool AreRealCoords = (Vector3d(a_BlockX, a_BlockY, a_BlockZ) - m_Player->GetPosition()).Length() <= 5;
 
 	if (
 		(a_BlockFace != BLOCK_FACE_NONE) &&  // The client is interacting with a specific block
-		(
-			(Diff(m_Player->GetPosX(), (double)a_BlockX) > 6) ||  // The block is too far away
-			(Diff(m_Player->GetPosY(), (double)a_BlockY) > 6) ||
-			(Diff(m_Player->GetPosZ(), (double)a_BlockZ) > 6)
-		)
+		IsValidBlock(a_HeldItem.m_ItemType) &&
+		!AreRealCoords
 	)
 	{
 		AddFaceDirection(a_BlockX, a_BlockY, a_BlockZ, a_BlockFace);
-		World->SendBlockTo(a_BlockX, a_BlockY, a_BlockZ, m_Player);
-		if (a_BlockY < cChunkDef::Height - 1)
+		if ((a_BlockX != -1) && (a_BlockY >= 0) && (a_BlockZ != -1))
 		{
-			World->SendBlockTo(a_BlockX, a_BlockY + 1, a_BlockZ, m_Player);  // 2 block high things
-		}
-		if (a_BlockY > 0)
-		{
-			World->SendBlockTo(a_BlockX, a_BlockY - 1, a_BlockZ, m_Player);  // 2 block high things
+			World->SendBlockTo(a_BlockX, a_BlockY, a_BlockZ, m_Player);
+			if (a_BlockY < cChunkDef::Height - 1)
+			{
+				World->SendBlockTo(a_BlockX, a_BlockY + 1, a_BlockZ, m_Player);  // 2 block high things
+			}
+			if (a_BlockY > 0)
+			{
+				World->SendBlockTo(a_BlockX, a_BlockY - 1, a_BlockZ, m_Player);  // 2 block high things
+			}
 		}
 		m_Player->GetInventory().SendEquippedSlot();
 		return;
 	}
 
+	if (!AreRealCoords)
+	{
+		a_BlockFace = BLOCK_FACE_NONE;
+	}
+
 	cPluginManager * PlgMgr = cRoot::Get()->GetPluginManager();
 	if (PlgMgr->CallHookPlayerRightClick(*m_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_CursorX, a_CursorY, a_CursorZ))
 	{
 		// A plugin doesn't agree with the action, replace the block on the client and quit:
-		cChunkInterface ChunkInterface(World->GetChunkMap());
-		BLOCKTYPE BlockType = World->GetBlock(a_BlockX, a_BlockY, a_BlockZ);
-		cBlockHandler * BlockHandler = cBlockInfo::GetHandler(BlockType);
-		BlockHandler->OnCancelRightClick(ChunkInterface, *World, m_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace);
-		
-		if (a_BlockFace != BLOCK_FACE_NONE)
+		if (AreRealCoords)
 		{
-			AddFaceDirection(a_BlockX, a_BlockY, a_BlockZ, a_BlockFace);
-			World->SendBlockTo(a_BlockX, a_BlockY, a_BlockZ, m_Player);
-			World->SendBlockTo(a_BlockX, a_BlockY + 1, a_BlockZ, m_Player);  // 2 block high things
-			m_Player->GetInventory().SendEquippedSlot();
+			cChunkInterface ChunkInterface(World->GetChunkMap());
+			BLOCKTYPE BlockType = World->GetBlock(a_BlockX, a_BlockY, a_BlockZ);
+			cBlockHandler * BlockHandler = cBlockInfo::GetHandler(BlockType);
+			BlockHandler->OnCancelRightClick(ChunkInterface, *World, m_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace);
+
+			if (a_BlockFace != BLOCK_FACE_NONE)
+			{
+				AddFaceDirection(a_BlockX, a_BlockY, a_BlockZ, a_BlockFace);
+				World->SendBlockTo(a_BlockX, a_BlockY, a_BlockZ, m_Player);
+				World->SendBlockTo(a_BlockX, a_BlockY + 1, a_BlockZ, m_Player);  // 2 block high things
+				m_Player->GetInventory().SendEquippedSlot();
+			}
 		}
 		return;
 	}
@@ -1282,22 +1299,25 @@ void cClientHandle::HandleRightClick(int a_BlockX, int a_BlockY, int a_BlockZ, e
 		return;
 	}
 
-	BLOCKTYPE BlockType;
-	NIBBLETYPE BlockMeta;
-	World->GetBlockTypeMeta(a_BlockX, a_BlockY, a_BlockZ, BlockType, BlockMeta);
-	cBlockHandler * BlockHandler = cBlockInfo::GetHandler(BlockType);
-	
-	if (BlockHandler->IsUseable() && !m_Player->IsCrouched())
+	if (AreRealCoords)
 	{
-		if (PlgMgr->CallHookPlayerUsingBlock(*m_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_CursorX, a_CursorY, a_CursorZ, BlockType, BlockMeta))
+		BLOCKTYPE BlockType;
+		NIBBLETYPE BlockMeta;
+		World->GetBlockTypeMeta(a_BlockX, a_BlockY, a_BlockZ, BlockType, BlockMeta);
+		cBlockHandler * BlockHandler = cBlockInfo::GetHandler(BlockType);
+
+		if (BlockHandler->IsUseable() && !m_Player->IsCrouched())
 		{
-			// A plugin doesn't agree with using the block, abort
+			if (PlgMgr->CallHookPlayerUsingBlock(*m_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_CursorX, a_CursorY, a_CursorZ, BlockType, BlockMeta))
+			{
+				// A plugin doesn't agree with using the block, abort
+				return;
+			}
+			cChunkInterface ChunkInterface(World->GetChunkMap());
+			BlockHandler->OnUse(ChunkInterface, *World, m_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_CursorX, a_CursorY, a_CursorZ);
+			PlgMgr->CallHookPlayerUsedBlock(*m_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_CursorX, a_CursorY, a_CursorZ, BlockType, BlockMeta);
 			return;
 		}
-		cChunkInterface ChunkInterface(World->GetChunkMap());
-		BlockHandler->OnUse(ChunkInterface, *World, m_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_CursorX, a_CursorY, a_CursorZ);
-		PlgMgr->CallHookPlayerUsedBlock(*m_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_CursorX, a_CursorY, a_CursorZ, BlockType, BlockMeta);
-		return;
 	}
 	
 	short EquippedDamage = Equipped.m_ItemDamage;
@@ -2326,18 +2346,18 @@ void cClientHandle::SendInventorySlot(char a_WindowID, short a_SlotNum, const cI
 
 
 
-void cClientHandle::SendMapColumn(int a_ID, int a_X, int a_Y, const Byte * a_Colors, unsigned int a_Length)
+void cClientHandle::SendMapColumn(int a_ID, int a_X, int a_Y, const Byte * a_Colors, unsigned int a_Length, unsigned int m_Scale)
 {
-	m_Protocol->SendMapColumn(a_ID, a_X, a_Y, a_Colors, a_Length);
+	m_Protocol->SendMapColumn(a_ID, a_X, a_Y, a_Colors, a_Length, m_Scale);
 }
 
 
 
 
 
-void cClientHandle::SendMapDecorators(int a_ID, const cMapDecoratorList & a_Decorators)
+void cClientHandle::SendMapDecorators(int a_ID, const cMapDecoratorList & a_Decorators, unsigned int m_Scale)
 {
-	m_Protocol->SendMapDecorators(a_ID, a_Decorators);
+	m_Protocol->SendMapDecorators(a_ID, a_Decorators, m_Scale);
 }
 
 
@@ -2353,9 +2373,9 @@ void cClientHandle::SendMapInfo(int a_ID, unsigned int a_Scale)
 
 
 
-void cClientHandle::SendParticleEffect(const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmmount)
+void cClientHandle::SendParticleEffect(const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmount)
 {
-	m_Protocol->SendParticleEffect(a_ParticleName, a_SrcX, a_SrcY, a_SrcZ, a_OffsetX, a_OffsetY, a_OffsetZ, a_ParticleData, a_ParticleAmmount);
+	m_Protocol->SendParticleEffect(a_ParticleName, a_SrcX, a_SrcY, a_SrcZ, a_OffsetX, a_OffsetY, a_OffsetZ, a_ParticleData, a_ParticleAmount);
 }
 
 
@@ -2397,9 +2417,45 @@ void cClientHandle::SendPlayerAbilities()
 
 
 
-void cClientHandle::SendPlayerListItem(const cPlayer & a_Player, bool a_IsOnline)
+void cClientHandle::SendPlayerListAddPlayer(const cPlayer & a_Player)
+{
+	m_Protocol->SendPlayerListAddPlayer(a_Player);
+}
+
+
+
+
+
+void cClientHandle::SendPlayerListRemovePlayer(const cPlayer & a_Player)
+{
+	m_Protocol->SendPlayerListRemovePlayer(a_Player);
+}
+
+
+
+
+
+void cClientHandle::SendPlayerListUpdateGameMode(const cPlayer & a_Player)
+{
+	m_Protocol->SendPlayerListUpdateGameMode(a_Player);
+}
+
+
+
+
+
+void cClientHandle::SendPlayerListUpdatePing(const cPlayer & a_Player)
+{
+	m_Protocol->SendPlayerListUpdatePing(a_Player);
+}
+
+
+
+
+
+void cClientHandle::SendPlayerListUpdateDisplayName(const cPlayer & a_Player, const AString & a_CustomName)
 {
-	m_Protocol->SendPlayerListItem(a_Player, a_IsOnline);
+	m_Protocol->SendPlayerListUpdateDisplayName(a_Player, a_CustomName);
 }
 
 
diff --git a/src/ClientHandle.h b/src/ClientHandle.h
index 3d0995636..0a936a2ca 100644
--- a/src/ClientHandle.h
+++ b/src/ClientHandle.h
@@ -134,73 +134,77 @@ public:
 
 	// The following functions send the various packets:
 	// (Please keep these alpha-sorted)
-	void SendAttachEntity        (const cEntity & a_Entity, const cEntity * a_Vehicle);
-	void SendBlockAction         (int a_BlockX, int a_BlockY, int a_BlockZ, char a_Byte1, char a_Byte2, BLOCKTYPE a_BlockType);
-	void SendBlockBreakAnim      (int a_EntityID, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Stage);
-	void SendBlockChange         (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);  // tolua_export
-	void SendBlockChanges        (int a_ChunkX, int a_ChunkZ, const sSetBlockVector & a_Changes);
-	void SendChat                (const AString & a_Message, eMessageType a_ChatPrefix, const AString & a_AdditionalData = "");
-	void SendChat                (const cCompositeChat & a_Message);
-	void SendChunkData           (int a_ChunkX, int a_ChunkZ, cChunkDataSerializer & a_Serializer);
-	void SendCollectEntity       (const cEntity & a_Entity, const cPlayer & a_Player);
-	void SendDestroyEntity       (const cEntity & a_Entity);
-	void SendDisconnect          (const AString & a_Reason);
-	void SendEditSign            (int a_BlockX, int a_BlockY, int a_BlockZ);
-	void SendEntityEffect        (const cEntity & a_Entity, int a_EffectID, int a_Amplifier, short a_Duration);
-	void SendEntityEquipment     (const cEntity & a_Entity, short a_SlotNum, const cItem & a_Item);
-	void SendEntityHeadLook      (const cEntity & a_Entity);
-	void SendEntityLook          (const cEntity & a_Entity);
-	void SendEntityMetadata      (const cEntity & a_Entity);
-	void SendEntityProperties    (const cEntity & a_Entity);
-	void SendEntityRelMove       (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ);
-	void SendEntityRelMoveLook   (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ);
-	void SendEntityStatus        (const cEntity & a_Entity, char a_Status);
-	void SendEntityVelocity      (const cEntity & a_Entity);
-	void SendExplosion           (double a_BlockX, double a_BlockY, double a_BlockZ, float a_Radius, const cVector3iArray & a_BlocksAffected, const Vector3d & a_PlayerMotion);
-	void SendGameMode            (eGameMode a_GameMode);
-	void SendHealth              (void);
-	void SendInventorySlot       (char a_WindowID, short a_SlotNum, const cItem & a_Item);
-	void SendMapColumn           (int a_ID, int a_X, int a_Y, const Byte * a_Colors, unsigned int a_Length);
-	void SendMapDecorators       (int a_ID, const cMapDecoratorList & a_Decorators);
-	void SendMapInfo             (int a_ID, unsigned int a_Scale);
-	void SendPaintingSpawn       (const cPainting & a_Painting);
-	void SendPickupSpawn         (const cPickup & a_Pickup);
-	void SendEntityAnimation     (const cEntity & a_Entity, char a_Animation);  // tolua_export
-	void SendParticleEffect      (const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmmount);
-	void SendPlayerAbilities     (void);
-	void SendPlayerListItem      (const cPlayer & a_Player, bool a_IsOnline);
-	void SendPlayerMaxSpeed      (void);  ///< Informs the client of the maximum player speed (1.6.1+)
-	void SendPlayerMoveLook      (void);
-	void SendPlayerPosition      (void);
-	void SendPlayerSpawn         (const cPlayer & a_Player);
-	void SendPluginMessage       (const AString & a_Channel, const AString & a_Message);  // Exported in ManualBindings.cpp
-	void SendRemoveEntityEffect  (const cEntity & a_Entity, int a_EffectID);
-	void SendRespawn             (eDimension a_Dimension, bool a_ShouldIgnoreDimensionChecks = false);
-	void SendExperience          (void);
-	void SendExperienceOrb       (const cExpOrb & a_ExpOrb);
-	void SendScoreboardObjective (const AString & a_Name, const AString & a_DisplayName, Byte a_Mode);
-	void SendScoreUpdate         (const AString & a_Objective, const AString & a_Player, cObjective::Score a_Score, Byte a_Mode);
-	void SendDisplayObjective    (const AString & a_Objective, cScoreboard::eDisplaySlot a_Display);
-	void SendSoundEffect         (const AString & a_SoundName, double a_X, double a_Y, double a_Z, float a_Volume, float a_Pitch);  // tolua_export
-	void SendSoundParticleEffect (int a_EffectID, int a_SrcX, int a_SrcY, int a_SrcZ, int a_Data);
-	void SendSpawnFallingBlock   (const cFallingBlock & a_FallingBlock);
-	void SendSpawnMob            (const cMonster & a_Mob);
-	void SendSpawnObject         (const cEntity & a_Entity, char a_ObjectType, int a_ObjectData, Byte a_Yaw, Byte a_Pitch);
-	void SendSpawnVehicle        (const cEntity & a_Vehicle, char a_VehicleType, char a_VehicleSubType = 0);
-	void SendStatistics          (const cStatManager & a_Manager);
-	void SendTabCompletionResults(const AStringVector & a_Results);
-	void SendTeleportEntity      (const cEntity & a_Entity);
-	void SendThunderbolt         (int a_BlockX, int a_BlockY, int a_BlockZ);
-	void SendTimeUpdate          (Int64 a_WorldAge, Int64 a_TimeOfDay, bool a_DoDaylightCycle);  // tolua_export
-	void SendUnloadChunk         (int a_ChunkX, int a_ChunkZ);
-	void SendUpdateBlockEntity   (cBlockEntity & a_BlockEntity);
-	void SendUpdateSign          (int a_BlockX, int a_BlockY, int a_BlockZ, const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4);
-	void SendUseBed              (const cEntity & a_Entity, int a_BlockX, int a_BlockY, int a_BlockZ);
-	void SendWeather             (eWeather a_Weather);
-	void SendWholeInventory      (const cWindow & a_Window);
-	void SendWindowClose         (const cWindow & a_Window);
-	void SendWindowOpen          (const cWindow & a_Window);
-	void SendWindowProperty      (const cWindow & a_Window, int a_Property, int a_Value);
+	void SendAttachEntity               (const cEntity & a_Entity, const cEntity * a_Vehicle);
+	void SendBlockAction                (int a_BlockX, int a_BlockY, int a_BlockZ, char a_Byte1, char a_Byte2, BLOCKTYPE a_BlockType);
+	void SendBlockBreakAnim             (int a_EntityID, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Stage);
+	void SendBlockChange                (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);  // tolua_export
+	void SendBlockChanges               (int a_ChunkX, int a_ChunkZ, const sSetBlockVector & a_Changes);
+	void SendChat                       (const AString & a_Message, eMessageType a_ChatPrefix, const AString & a_AdditionalData = "");
+	void SendChat                       (const cCompositeChat & a_Message);
+	void SendChunkData                  (int a_ChunkX, int a_ChunkZ, cChunkDataSerializer & a_Serializer);
+	void SendCollectEntity              (const cEntity & a_Entity, const cPlayer & a_Player);
+	void SendDestroyEntity              (const cEntity & a_Entity);
+	void SendDisconnect                 (const AString & a_Reason);
+	void SendEditSign                   (int a_BlockX, int a_BlockY, int a_BlockZ);
+	void SendEntityEffect               (const cEntity & a_Entity, int a_EffectID, int a_Amplifier, short a_Duration);
+	void SendEntityEquipment            (const cEntity & a_Entity, short a_SlotNum, const cItem & a_Item);
+	void SendEntityHeadLook             (const cEntity & a_Entity);
+	void SendEntityLook                 (const cEntity & a_Entity);
+	void SendEntityMetadata             (const cEntity & a_Entity);
+	void SendEntityProperties           (const cEntity & a_Entity);
+	void SendEntityRelMove              (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ);
+	void SendEntityRelMoveLook          (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ);
+	void SendEntityStatus               (const cEntity & a_Entity, char a_Status);
+	void SendEntityVelocity             (const cEntity & a_Entity);
+	void SendExplosion                  (double a_BlockX, double a_BlockY, double a_BlockZ, float a_Radius, const cVector3iArray & a_BlocksAffected, const Vector3d & a_PlayerMotion);
+	void SendGameMode                   (eGameMode a_GameMode);
+	void SendHealth                     (void);
+	void SendInventorySlot              (char a_WindowID, short a_SlotNum, const cItem & a_Item);
+	void SendMapColumn                  (int a_ID, int a_X, int a_Y, const Byte * a_Colors, unsigned int a_Length, unsigned int m_Scale);
+	void SendMapDecorators              (int a_ID, const cMapDecoratorList & a_Decorators, unsigned int m_Scale);
+	void SendMapInfo                    (int a_ID, unsigned int a_Scale);
+	void SendPaintingSpawn              (const cPainting & a_Painting);
+	void SendPickupSpawn                (const cPickup & a_Pickup);
+	void SendEntityAnimation            (const cEntity & a_Entity, char a_Animation);  // tolua_export
+	void SendParticleEffect             (const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmount);
+	void SendPlayerAbilities            (void);
+	void SendPlayerListAddPlayer        (const cPlayer & a_Player);
+	void SendPlayerListRemovePlayer     (const cPlayer & a_Player);
+	void SendPlayerListUpdateGameMode   (const cPlayer & a_Player);
+	void SendPlayerListUpdatePing       (const cPlayer & a_Player);
+	void SendPlayerListUpdateDisplayName(const cPlayer & a_Player, const AString & a_CustomName);
+	void SendPlayerMaxSpeed             (void);  ///< Informs the client of the maximum player speed (1.6.1+)
+	void SendPlayerMoveLook             (void);
+	void SendPlayerPosition             (void);
+	void SendPlayerSpawn                (const cPlayer & a_Player);
+	void SendPluginMessage              (const AString & a_Channel, const AString & a_Message);  // Exported in ManualBindings.cpp
+	void SendRemoveEntityEffect         (const cEntity & a_Entity, int a_EffectID);
+	void SendRespawn                    (eDimension a_Dimension, bool a_ShouldIgnoreDimensionChecks = false);
+	void SendExperience                 (void);
+	void SendExperienceOrb              (const cExpOrb & a_ExpOrb);
+	void SendScoreboardObjective        (const AString & a_Name, const AString & a_DisplayName, Byte a_Mode);
+	void SendScoreUpdate                (const AString & a_Objective, const AString & a_Player, cObjective::Score a_Score, Byte a_Mode);
+	void SendDisplayObjective           (const AString & a_Objective, cScoreboard::eDisplaySlot a_Display);
+	void SendSoundEffect                (const AString & a_SoundName, double a_X, double a_Y, double a_Z, float a_Volume, float a_Pitch);  // tolua_export
+	void SendSoundParticleEffect        (int a_EffectID, int a_SrcX, int a_SrcY, int a_SrcZ, int a_Data);
+	void SendSpawnFallingBlock          (const cFallingBlock & a_FallingBlock);
+	void SendSpawnMob                   (const cMonster & a_Mob);
+	void SendSpawnObject                (const cEntity & a_Entity, char a_ObjectType, int a_ObjectData, Byte a_Yaw, Byte a_Pitch);
+	void SendSpawnVehicle               (const cEntity & a_Vehicle, char a_VehicleType, char a_VehicleSubType = 0);
+	void SendStatistics                 (const cStatManager & a_Manager);
+	void SendTabCompletionResults       (const AStringVector & a_Results);
+	void SendTeleportEntity             (const cEntity & a_Entity);
+	void SendThunderbolt                (int a_BlockX, int a_BlockY, int a_BlockZ);
+	void SendTimeUpdate                 (Int64 a_WorldAge, Int64 a_TimeOfDay, bool a_DoDaylightCycle);  // tolua_export
+	void SendUnloadChunk                (int a_ChunkX, int a_ChunkZ);
+	void SendUpdateBlockEntity          (cBlockEntity & a_BlockEntity);
+	void SendUpdateSign                 (int a_BlockX, int a_BlockY, int a_BlockZ, const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4);
+	void SendUseBed                     (const cEntity & a_Entity, int a_BlockX, int a_BlockY, int a_BlockZ);
+	void SendWeather                    (eWeather a_Weather);
+	void SendWholeInventory             (const cWindow & a_Window);
+	void SendWindowClose                (const cWindow & a_Window);
+	void SendWindowOpen                 (const cWindow & a_Window);
+	void SendWindowProperty             (const cWindow & a_Window, int a_Property, int a_Value);
 
 	// tolua_begin
 	const AString & GetUsername(void) const;
diff --git a/src/CompositeChat.cpp b/src/CompositeChat.cpp
index 0d339021e..d1eb0b852 100644
--- a/src/CompositeChat.cpp
+++ b/src/CompositeChat.cpp
@@ -5,6 +5,7 @@
 
 #include "Globals.h"
 #include "CompositeChat.h"
+#include "ClientHandle.h"
 
 
 
@@ -399,6 +400,183 @@ void cCompositeChat::AddStyle(AString & a_Style, const AString & a_AddStyle)
 
 
 
+AString cCompositeChat::CreateJsonString(bool a_ShouldUseChatPrefixes) const
+{
+	Json::Value msg;
+	msg["text"] = cClientHandle::FormatMessageType(a_ShouldUseChatPrefixes, GetMessageType(), GetAdditionalMessageTypeData());  // The client crashes without this field being present
+	const cCompositeChat::cParts & Parts = GetParts();
+	for (cCompositeChat::cParts::const_iterator itr = Parts.begin(), end = Parts.end(); itr != end; ++itr)
+	{
+		Json::Value Part;
+		switch ((*itr)->m_PartType)
+		{
+			case cCompositeChat::ptText:
+			{
+				Part["text"] = (*itr)->m_Text;
+				AddChatPartStyle(Part, (*itr)->m_Style);
+				break;
+			}
+			
+			case cCompositeChat::ptClientTranslated:
+			{
+				const cCompositeChat::cClientTranslatedPart & p = (const cCompositeChat::cClientTranslatedPart &)**itr;
+				Part["translate"] = p.m_Text;
+				Json::Value With;
+				for (AStringVector::const_iterator itrW = p.m_Parameters.begin(), endW = p.m_Parameters.end(); itrW != endW; ++itr)
+				{
+					With.append(*itrW);
+				}
+				if (!p.m_Parameters.empty())
+				{
+					Part["with"] = With;
+				}
+				AddChatPartStyle(Part, p.m_Style);
+				break;
+			}
+			
+			case cCompositeChat::ptUrl:
+			{
+				const cCompositeChat::cUrlPart & p = (const cCompositeChat::cUrlPart &)**itr;
+				Part["text"] = p.m_Text;
+				Json::Value Url;
+				Url["action"] = "open_url";
+				Url["value"] = p.m_Url;
+				Part["clickEvent"] = Url;
+				AddChatPartStyle(Part, p.m_Style);
+				break;
+			}
+			
+			case cCompositeChat::ptSuggestCommand:
+			case cCompositeChat::ptRunCommand:
+			{
+				const cCompositeChat::cCommandPart & p = (const cCompositeChat::cCommandPart &)**itr;
+				Part["text"] = p.m_Text;
+				Json::Value Cmd;
+				Cmd["action"] = (p.m_PartType == cCompositeChat::ptRunCommand) ? "run_command" : "suggest_command";
+				Cmd["value"] = p.m_Command;
+				Part["clickEvent"] = Cmd;
+				AddChatPartStyle(Part, p.m_Style);
+				break;
+			}
+
+			case cCompositeChat::ptShowAchievement:
+			{
+				const cCompositeChat::cShowAchievementPart & p = (const cCompositeChat::cShowAchievementPart &)**itr;
+				Part["translate"] = "chat.type.achievement";
+
+				Json::Value Ach;
+				Ach["action"] = "show_achievement";
+				Ach["value"] = p.m_Text;
+				
+				Json::Value AchColourAndName;
+				AchColourAndName["color"] = "green";
+				AchColourAndName["translate"] = p.m_Text;
+				AchColourAndName["hoverEvent"] = Ach;
+
+				Json::Value Extra;
+				Extra.append(AchColourAndName);
+
+				Json::Value Name;
+				Name["text"] = p.m_PlayerName;
+
+				Json::Value With;
+				With.append(Name);
+				With.append(Extra);
+
+				Part["with"] = With;
+				AddChatPartStyle(Part, p.m_Style);
+				break;
+			}
+		}
+		msg["extra"].append(Part);
+	}  // for itr - Parts[]
+
+	return msg.toStyledString();
+}
+
+
+
+
+
+void cCompositeChat::AddChatPartStyle(Json::Value & a_Value, const AString & a_PartStyle) const
+{
+	size_t len = a_PartStyle.length();
+	for (size_t i = 0; i < len; i++)
+	{
+		switch (a_PartStyle[i])
+		{
+			case 'b':
+			{
+				// bold
+				a_Value["bold"] = Json::Value(true);
+				break;
+			}
+			
+			case 'i':
+			{
+				// italic
+				a_Value["italic"] = Json::Value(true);
+				break;
+			}
+			
+			case 'u':
+			{
+				// Underlined
+				a_Value["underlined"] = Json::Value(true);
+				break;
+			}
+			
+			case 's':
+			{
+				// strikethrough
+				a_Value["strikethrough"] = Json::Value(true);
+				break;
+			}
+			
+			case 'o':
+			{
+				// obfuscated
+				a_Value["obfuscated"] = Json::Value(true);
+				break;
+			}
+			
+			case '@':
+			{
+				// Color, specified by the next char:
+				i++;
+				if (i >= len)
+				{
+					// String too short, didn't contain a color
+					break;
+				}
+				switch (a_PartStyle[i])
+				{
+					case '0': a_Value["color"] = Json::Value("black");        break;
+					case '1': a_Value["color"] = Json::Value("dark_blue");    break;
+					case '2': a_Value["color"] = Json::Value("dark_green");   break;
+					case '3': a_Value["color"] = Json::Value("dark_aqua");    break;
+					case '4': a_Value["color"] = Json::Value("dark_red");     break;
+					case '5': a_Value["color"] = Json::Value("dark_purple");  break;
+					case '6': a_Value["color"] = Json::Value("gold");         break;
+					case '7': a_Value["color"] = Json::Value("gray");         break;
+					case '8': a_Value["color"] = Json::Value("dark_gray");    break;
+					case '9': a_Value["color"] = Json::Value("blue");         break;
+					case 'a': a_Value["color"] = Json::Value("green");        break;
+					case 'b': a_Value["color"] = Json::Value("aqua");         break;
+					case 'c': a_Value["color"] = Json::Value("red");          break;
+					case 'd': a_Value["color"] = Json::Value("light_purple"); break;
+					case 'e': a_Value["color"] = Json::Value("yellow");       break;
+					case 'f': a_Value["color"] = Json::Value("white");        break;
+				}  // switch (color)
+			}  // case '@'
+		}  // switch (Style[i])
+	}  // for i - a_PartStyle[]
+}
+
+
+
+
+
 ////////////////////////////////////////////////////////////////////////////////
 // cCompositeChat::cBasePart:
 
diff --git a/src/CompositeChat.h b/src/CompositeChat.h
index 2dc21b98f..369eed196 100644
--- a/src/CompositeChat.h
+++ b/src/CompositeChat.h
@@ -4,6 +4,7 @@
 // Declares the cCompositeChat class used to wrap a chat message with multiple parts (text, url, cmd)
 
 #include "Defines.h"
+#include "json/json.h"
 
 
 
@@ -189,6 +190,8 @@ public:
 	Used for older protocols that don't support composite chat
 	and for console-logging. */
 	AString ExtractText(void) const;
+
+	AString CreateJsonString(bool a_ShouldUseChatPrefixes = true) const;
 	
 	// tolua_end
 	
@@ -197,6 +200,9 @@ public:
 	/** Converts the MessageType to a LogLevel value.
 	Used by the logging bindings when logging a cCompositeChat object. */
 	static cLogger::eLogLevel MessageTypeToLogLevel(eMessageType a_MessageType);
+
+	/** Adds the chat part's style (represented by the part's stylestring) into the Json object. */
+	void AddChatPartStyle(Json::Value & a_Value, const AString & a_PartStyle) const;
 	
 protected:
 	/** All the parts that */
diff --git a/src/Entities/ArrowEntity.cpp b/src/Entities/ArrowEntity.cpp
index 954e0a267..c265c5043 100644
--- a/src/Entities/ArrowEntity.cpp
+++ b/src/Entities/ArrowEntity.cpp
@@ -3,7 +3,6 @@
 #include "Player.h"
 #include "ArrowEntity.h"
 #include "../Chunk.h"
-#include "FastRandom.h"
 
 
 
diff --git a/src/Entities/Boat.cpp b/src/Entities/Boat.cpp
index 8ff8866a1..328a70846 100644
--- a/src/Entities/Boat.cpp
+++ b/src/Entities/Boat.cpp
@@ -62,6 +62,8 @@ bool cBoat::DoTakeDamage(TakeDamageInfo & TDI)
 
 void cBoat::OnRightClicked(cPlayer & a_Player)
 {
+	super::OnRightClicked(a_Player);
+
 	if (m_Attachee != NULL)
 	{
 		if (m_Attachee->GetUniqueID() == a_Player.GetUniqueID())
diff --git a/src/Entities/EnderCrystal.cpp b/src/Entities/EnderCrystal.cpp
index c17bb608e..30df2c110 100644
--- a/src/Entities/EnderCrystal.cpp
+++ b/src/Entities/EnderCrystal.cpp
@@ -3,8 +3,8 @@
 
 #include "EnderCrystal.h"
 #include "ClientHandle.h"
-#include "Player.h"
 #include "../Chunk.h"
+#include "../World.h"
 
 
 
diff --git a/src/Entities/Entity.cpp b/src/Entities/Entity.cpp
index 42b207c48..da85dec50 100644
--- a/src/Entities/Entity.cpp
+++ b/src/Entities/Entity.cpp
@@ -3,7 +3,6 @@
 
 #include "Entity.h"
 #include "../World.h"
-#include "../Server.h"
 #include "../Root.h"
 #include "../Matrix4.h"
 #include "../ClientHandle.h"
@@ -135,7 +134,7 @@ const char * cEntity::GetParentClass(void) const
 
 bool cEntity::Initialize(cWorld & a_World)
 {
-	if (cPluginManager::Get()->CallHookSpawningEntity(a_World, *this))
+	if (cPluginManager::Get()->CallHookSpawningEntity(a_World, *this) && !IsPlayer())
 	{
 		return false;
 	}
@@ -260,7 +259,7 @@ void cEntity::TakeDamage(eDamageType a_DamageType, cEntity * a_Attacker, int a_R
 void cEntity::SetYawFromSpeed(void)
 {
 	const double EPS = 0.0000001;
-	if ((abs(m_Speed.x) < EPS) && (abs(m_Speed.z) < EPS))
+	if ((std::abs(m_Speed.x) < EPS) && (std::abs(m_Speed.z) < EPS))
 	{
 		// atan2() may overflow or is undefined, pick any number
 		SetYaw(0);
@@ -277,7 +276,7 @@ void cEntity::SetPitchFromSpeed(void)
 {
 	const double EPS = 0.0000001;
 	double xz = sqrt(m_Speed.x * m_Speed.x + m_Speed.z * m_Speed.z);  // Speed XZ-plane component
-	if ((abs(xz) < EPS) && (abs(m_Speed.y) < EPS))
+	if ((std::abs(xz) < EPS) && (std::abs(m_Speed.y) < EPS))
 	{
 		// atan2() may overflow or is undefined, pick any number
 		SetPitch(0);
@@ -334,14 +333,15 @@ bool cEntity::DoTakeDamage(TakeDamageInfo & a_TDI)
 				cMonster * Monster = (cMonster *)this;
 				switch (Monster->GetMobType())
 				{
-					case cMonster::mtSkeleton:
-					case cMonster::mtZombie:
-					case cMonster::mtWither:
-					case cMonster::mtZombiePigman:
+					case mtSkeleton:
+					case mtZombie:
+					case mtWither:
+					case mtZombiePigman:
 					{
 						a_TDI.FinalDamage += (int)ceil(2.5 * SmiteLevel);
 						break;
 					}
+					default: break;
 				}
 			}
 		}
@@ -352,9 +352,9 @@ bool cEntity::DoTakeDamage(TakeDamageInfo & a_TDI)
 				cMonster * Monster = (cMonster *)this;
 				switch (Monster->GetMobType())
 				{
-					case cMonster::mtSpider:
-					case cMonster::mtCaveSpider:
-					case cMonster::mtSilverfish:
+					case mtSpider:
+					case mtCaveSpider:
+					case mtSilverfish:
 					{
 						a_TDI.RawDamage += (int)ceil(2.5 * BaneOfArthropodsLevel);
 						// TODO: Add slowness effect
@@ -384,9 +384,9 @@ bool cEntity::DoTakeDamage(TakeDamageInfo & a_TDI)
 				cMonster * Monster = (cMonster *)this;
 				switch (Monster->GetMobType())
 				{
-					case cMonster::mtGhast:
-					case cMonster::mtZombiePigman:
-					case cMonster::mtMagmaCube:
+					case mtGhast:
+					case mtZombiePigman:
+					case mtMagmaCube:
 					{
 						break;
 					};
@@ -1015,7 +1015,7 @@ void cEntity::HandlePhysics(float a_Dt, cChunk & a_Chunk)
 				if (Tracer.HitNormal.y != 0.f) NextSpeed.y = 0.f;
 				if (Tracer.HitNormal.z != 0.f) NextSpeed.z = 0.f;
 
-				if (Tracer.HitNormal.y == 1)  // Hit BLOCK_FACE_YP, we are on the ground
+				if (Tracer.HitNormal.y == 1.f)  // Hit BLOCK_FACE_YP, we are on the ground
 				{
 					m_bOnGround = true;
 				}
@@ -1960,7 +1960,7 @@ void cEntity::SteerVehicle(float a_Forward, float a_Sideways)
 	{
 		return;
 	}
-	if ((a_Forward != 0) || (a_Sideways != 0))
+	if ((a_Forward != 0.f) || (a_Sideways != 0.f))
 	{
 		m_AttachedTo->HandleSpeedFromAttachee(a_Forward, a_Sideways);
 	}
diff --git a/src/Entities/Entity.h b/src/Entities/Entity.h
index 6bc070dcc..3fa7e80c1 100644
--- a/src/Entities/Entity.h
+++ b/src/Entities/Entity.h
@@ -447,7 +447,7 @@ public:
 	// tolua_end
 	
 	/// Called when the specified player right-clicks this entity
-	virtual void OnRightClicked(cPlayer &) {}
+	virtual void OnRightClicked(cPlayer & a_Player) {}
 
 	/// Returns the list of drops for this pawn when it is killed. May check a_Killer for special handling (sword of looting etc.). Called from KilledBy().
 	virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL)
diff --git a/src/Entities/EntityEffect.cpp b/src/Entities/EntityEffect.cpp
index 1a923930f..b1ddaa30e 100644
--- a/src/Entities/EntityEffect.cpp
+++ b/src/Entities/EntityEffect.cpp
@@ -96,6 +96,7 @@ int cEntityEffect::GetPotionEffectDuration(short a_ItemDamage)
 			base = 1800;
 			break;
 		}
+		default: break;
 	}
 	
 	// If potion is level II, half the duration. If not, stays the same
@@ -435,8 +436,8 @@ void cEntityEffectPoison::OnTick(cPawn & a_Target)
 		// Doesn't effect undead mobs, spiders
 		if (
 			Target.IsUndead() ||
-			(Target.GetMobType() == cMonster::mtSpider) ||
-			(Target.GetMobType() == cMonster::mtCaveSpider)
+			(Target.GetMobType() == mtSpider) ||
+			(Target.GetMobType() == mtCaveSpider)
 		)
 		{
 			return;
diff --git a/src/Entities/ExpBottleEntity.cpp b/src/Entities/ExpBottleEntity.cpp
index 202dde942..ee142a5a2 100644
--- a/src/Entities/ExpBottleEntity.cpp
+++ b/src/Entities/ExpBottleEntity.cpp
@@ -19,9 +19,26 @@ cExpBottleEntity::cExpBottleEntity(cEntity * a_Creator, double a_X, double a_Y,
 
 void cExpBottleEntity::OnHitSolidBlock(const Vector3d & a_HitPos, eBlockFace a_HitFace)
 {
+	Break(a_HitPos);
+}
+
+
+
+
+
+void cExpBottleEntity::OnHitEntity(cEntity & a_EntityHit, const Vector3d & a_HitPos)
+{
+	Break(a_HitPos);
+}
+
+
+
+
+
+void cExpBottleEntity::Break(const Vector3d &a_HitPos)
+{
 	// Spawn an experience orb with a reward between 3 and 11.
 	m_World->BroadcastSoundParticleEffect(2002, POSX_TOINT, POSY_TOINT, POSZ_TOINT, 0);
 	m_World->SpawnExperienceOrb(GetPosX(), GetPosY(), GetPosZ(), 3 + m_World->GetTickRandomNumber(8));
-	
 	Destroy();
 }
diff --git a/src/Entities/ExpBottleEntity.h b/src/Entities/ExpBottleEntity.h
index d62a84469..d36110f97 100644
--- a/src/Entities/ExpBottleEntity.h
+++ b/src/Entities/ExpBottleEntity.h
@@ -29,5 +29,10 @@ protected:
 	
 	// cProjectileEntity overrides:
 	virtual void OnHitSolidBlock(const Vector3d & a_HitPos, eBlockFace a_HitFace) override;
+	virtual void OnHitEntity    (cEntity & a_EntityHit, const Vector3d & a_HitPos) override;
+
+	/** Breaks the bottle, fires its particle effects and sounds
+	@param a_HitPos     The position where the bottle will break */
+	void Break(const Vector3d &a_HitPos);
 	
 };  // tolua_export
diff --git a/src/Entities/HangingEntity.cpp b/src/Entities/HangingEntity.cpp
index 8c70c606e..3276bc4a0 100644
--- a/src/Entities/HangingEntity.cpp
+++ b/src/Entities/HangingEntity.cpp
@@ -21,6 +21,21 @@ cHangingEntity::cHangingEntity(eEntityType a_EntityType, eBlockFace a_BlockFace,
 
 
 
+void cHangingEntity::SetDirection(eBlockFace a_BlockFace)
+{
+	if ((a_BlockFace < 2) || (a_BlockFace > 5))
+	{
+		ASSERT(!"Tried to set a bad direction!");
+		return;
+	}
+
+	m_BlockFace = a_BlockFace;
+}
+
+
+
+
+
 void cHangingEntity::SpawnOn(cClientHandle & a_ClientHandle)
 {
 	int Dir = 0;
@@ -28,11 +43,17 @@ void cHangingEntity::SpawnOn(cClientHandle & a_ClientHandle)
 	// The client uses different values for item frame directions and block faces. Our constants are for the block faces, so we convert them here to item frame faces
 	switch (m_BlockFace)
 	{
-		case BLOCK_FACE_ZP: break;  // Initialised to zero
+		case BLOCK_FACE_ZP: Dir = 0; break;
 		case BLOCK_FACE_ZM: Dir = 2; break;
 		case BLOCK_FACE_XM: Dir = 1; break;
 		case BLOCK_FACE_XP: Dir = 3; break;
-		default: ASSERT(!"Unhandled block face when trying to spawn item frame!"); return;
+		default:
+		{
+			LOGINFO("Invalid face (%d) in a cHangingEntity at {%d, %d, %d}, adjusting to BLOCK_FACE_XP.",
+				m_BlockFace, (int)GetPosX(), (int)GetPosY(), (int)GetPosZ()
+			);
+			Dir = 3;
+		}
 	}
 
 	if ((Dir == 0) || (Dir == 2))  // Probably a client bug, but two directions are flipped and contrary to the norm, so we do -180
diff --git a/src/Entities/HangingEntity.h b/src/Entities/HangingEntity.h
index 3593f9ede..1cc0034e1 100644
--- a/src/Entities/HangingEntity.h
+++ b/src/Entities/HangingEntity.h
@@ -24,7 +24,7 @@ public:
 	eBlockFace GetDirection() const { return m_BlockFace; }  // tolua_export
 	
 	/** Set the orientation from the hanging entity */
-	void SetDirection(eBlockFace a_BlockFace) { m_BlockFace = a_BlockFace; }  // tolua_export
+	void SetDirection(eBlockFace a_BlockFace);  // tolua_export
 	
 	/** Returns the X coord. */
 	int GetTileX() const { return POSX_TOINT; }  // tolua_export
diff --git a/src/Entities/ItemFrame.cpp b/src/Entities/ItemFrame.cpp
index 0bc10ec60..f512324eb 100644
--- a/src/Entities/ItemFrame.cpp
+++ b/src/Entities/ItemFrame.cpp
@@ -22,11 +22,13 @@ cItemFrame::cItemFrame(eBlockFace a_BlockFace, double a_X, double a_Y, double a_
 
 void cItemFrame::OnRightClicked(cPlayer & a_Player)
 {
+	super::OnRightClicked(a_Player);
+
 	if (!m_Item.IsEmpty())
 	{
 		// Item not empty, rotate, clipping values to zero to three inclusive
 		m_Rotation++;
-		if (m_Rotation >= 4)
+		if (m_Rotation >= 8)
 		{
 			m_Rotation = 0;
 		}
diff --git a/src/Entities/Minecart.cpp b/src/Entities/Minecart.cpp
index 1501eea84..2df64d5c1 100644
--- a/src/Entities/Minecart.cpp
+++ b/src/Entities/Minecart.cpp
@@ -13,6 +13,7 @@
 #include "Player.h"
 #include "../BoundingBox.h"
 
+#define NO_SPEED 0.0
 #define MAX_SPEED 8
 #define MAX_SPEED_NEGATIVE -MAX_SPEED
 
@@ -220,7 +221,7 @@ void cMinecart::HandleRailPhysics(NIBBLETYPE a_RailMeta, float a_Dt)
 			bool BlckCol = TestBlockCollision(a_RailMeta), EntCol = TestEntityCollision(a_RailMeta);
 			if (EntCol || BlckCol) return;
 			
-			if (GetSpeedZ() != 0)  // Don't do anything if cart is stationary
+			if (GetSpeedZ() != NO_SPEED)  // Don't do anything if cart is stationary
 			{
 				if (GetSpeedZ() > 0)
 				{
@@ -239,13 +240,13 @@ void cMinecart::HandleRailPhysics(NIBBLETYPE a_RailMeta, float a_Dt)
 		{
 			SetYaw(180);
 			SetPosY(floor(GetPosY()) + 0.55);
-			SetSpeedY(0);
-			SetSpeedZ(0);
+			SetSpeedY(NO_SPEED);
+			SetSpeedZ(NO_SPEED);
 
 			bool BlckCol = TestBlockCollision(a_RailMeta), EntCol = TestEntityCollision(a_RailMeta);
 			if (EntCol || BlckCol) return;
 
-			if (GetSpeedX() != 0)
+			if (GetSpeedX() != NO_SPEED)
 			{
 				if (GetSpeedX() > 0)
 				{
@@ -305,9 +306,9 @@ void cMinecart::HandleRailPhysics(NIBBLETYPE a_RailMeta, float a_Dt)
 		case E_META_RAIL_ASCEND_XM:  // ASCEND EAST
 		{
 			SetYaw(180);
-			SetSpeedZ(0);
+			SetSpeedZ(NO_SPEED);
 
-			if (GetSpeedX() >= 0)
+			if (GetSpeedX() >= NO_SPEED)
 			{
 				if (GetSpeedX() <= MAX_SPEED)
 				{
@@ -424,9 +425,9 @@ void cMinecart::HandlePoweredRailPhysics(NIBBLETYPE a_RailMeta)
 			bool BlckCol = TestBlockCollision(a_RailMeta), EntCol = TestEntityCollision(a_RailMeta);
 			if (EntCol || BlckCol) return;
 			
-			if (GetSpeedZ() != 0)
+			if (GetSpeedZ() != NO_SPEED)
 			{
-				if (GetSpeedZ() > 0)
+				if (GetSpeedZ() > NO_SPEED)
 				{
 					AddSpeedZ(AccelDecelSpeed);
 				}
@@ -441,15 +442,15 @@ void cMinecart::HandlePoweredRailPhysics(NIBBLETYPE a_RailMeta)
 		{
 			SetYaw(180);
 			SetPosY(floor(GetPosY()) + 0.55);
-			SetSpeedY(0);
-			SetSpeedZ(0);
+			SetSpeedY(NO_SPEED);
+			SetSpeedZ(NO_SPEED);
 
 			bool BlckCol = TestBlockCollision(a_RailMeta), EntCol = TestEntityCollision(a_RailMeta);
 			if (EntCol || BlckCol) return;
 
-			if (GetSpeedX() != 0)
+			if (GetSpeedX() != NO_SPEED)
 			{
-				if (GetSpeedX() > 0)
+				if (GetSpeedX() > NO_SPEED)
 				{
 					AddSpeedX(AccelDecelSpeed);
 				}
@@ -463,9 +464,9 @@ void cMinecart::HandlePoweredRailPhysics(NIBBLETYPE a_RailMeta)
 		case E_META_RAIL_ASCEND_XM:  // ASCEND EAST
 		{
 			SetYaw(180);
-			SetSpeedZ(0);
+			SetSpeedZ(NO_SPEED);
 
-			if (GetSpeedX() >= 0)
+			if (GetSpeedX() >= NO_SPEED)
 			{
 				if (GetSpeedX() <= MAX_SPEED)
 				{
@@ -483,9 +484,9 @@ void cMinecart::HandlePoweredRailPhysics(NIBBLETYPE a_RailMeta)
 		case E_META_RAIL_ASCEND_XP:  // ASCEND WEST
 		{
 			SetYaw(180);
-			SetSpeedZ(0);
+			SetSpeedZ(NO_SPEED);
 
-			if (GetSpeedX() > 0)
+			if (GetSpeedX() > NO_SPEED)
 			{
 				AddSpeedX(AccelDecelSpeed);
 				SetSpeedY(GetSpeedX());
@@ -503,9 +504,9 @@ void cMinecart::HandlePoweredRailPhysics(NIBBLETYPE a_RailMeta)
 		case E_META_RAIL_ASCEND_ZM:  // ASCEND NORTH
 		{
 			SetYaw(270);
-			SetSpeedX(0);
+			SetSpeedX(NO_SPEED);
 
-			if (GetSpeedZ() >= 0)
+			if (GetSpeedZ() >= NO_SPEED)
 			{
 				if (GetSpeedZ() <= MAX_SPEED)
 				{
@@ -523,9 +524,9 @@ void cMinecart::HandlePoweredRailPhysics(NIBBLETYPE a_RailMeta)
 		case E_META_RAIL_ASCEND_ZP:  // ASCEND SOUTH
 		{
 			SetYaw(270);
-			SetSpeedX(0);
+			SetSpeedX(NO_SPEED);
 
-			if (GetSpeedZ() > 0)
+			if (GetSpeedZ() > NO_SPEED)
 			{
 				AddSpeedZ(AccelDecelSpeed);
 				SetSpeedY(GetSpeedZ());
@@ -576,7 +577,7 @@ void cMinecart::SnapToRail(NIBBLETYPE a_RailMeta)
 		case E_META_RAIL_ASCEND_XP:
 		case E_META_RAIL_XM_XP:
 		{
-			SetSpeedZ(0);
+			SetSpeedZ(NO_SPEED);
 			SetPosZ(floor(GetPosZ()) + 0.5);
 			break;
 		}
@@ -584,7 +585,7 @@ void cMinecart::SnapToRail(NIBBLETYPE a_RailMeta)
 		case E_META_RAIL_ASCEND_ZP:
 		case E_META_RAIL_ZM_ZP:
 		{
-			SetSpeedX(0);
+			SetSpeedX(NO_SPEED);
 			SetPosX(floor(GetPosX()) + 0.5);
 			break;
 		}
@@ -593,12 +594,12 @@ void cMinecart::SnapToRail(NIBBLETYPE a_RailMeta)
 		{
 			if (GetPosZ() > floor(GetPosZ()) + 0.5)
 			{
-				if (GetSpeedZ() > 0)
+				if (GetSpeedZ() > NO_SPEED)
 				{
 					SetSpeedX(-GetSpeedZ() * 0.7);
 				}
 
-				SetSpeedZ(0);
+				SetSpeedZ(NO_SPEED);
 				SetPosZ(floor(GetPosZ()) + 0.5);
 			}
 			else if (GetPosX() > floor(GetPosX()) + 0.5)
@@ -608,82 +609,82 @@ void cMinecart::SnapToRail(NIBBLETYPE a_RailMeta)
 					SetSpeedZ(-GetSpeedX() * 0.7);
 				}
 
-				SetSpeedX(0);
+				SetSpeedX(NO_SPEED);
 				SetPosX(floor(GetPosX()) + 0.5);
 			}
-			SetSpeedY(0);
+			SetSpeedY(NO_SPEED);
 			break;
 		}
 		case E_META_RAIL_CURVED_ZM_XP:
 		{
 			if (GetPosZ() > floor(GetPosZ()) + 0.5)
 			{
-				if (GetSpeedZ() > 0)
+				if (GetSpeedZ() > NO_SPEED)
 				{
 					SetSpeedX(GetSpeedZ() * 0.7);
 				}
 
-				SetSpeedZ(0);
+				SetSpeedZ(NO_SPEED);
 				SetPosZ(floor(GetPosZ()) + 0.5);
 			}
 			else if (GetPosX() < floor(GetPosX()) + 0.5)
 			{
-				if (GetSpeedX() < 0)
+				if (GetSpeedX() < NO_SPEED)
 				{
 					SetSpeedZ(GetSpeedX() * 0.7);
 				}
 
-				SetSpeedX(0);
+				SetSpeedX(NO_SPEED);
 				SetPosX(floor(GetPosX()) + 0.5);
 			}
-			SetSpeedY(0);
+			SetSpeedY(NO_SPEED);
 			break;
 		}
 		case E_META_RAIL_CURVED_ZP_XM:
 		{
 			if (GetPosZ() < floor(GetPosZ()) + 0.5)
 			{
-				if (GetSpeedZ() < 0)
+				if (GetSpeedZ() < NO_SPEED)
 				{
 					SetSpeedX(GetSpeedZ() * 0.7);
 				}
 
-				SetSpeedZ(0);
+				SetSpeedZ(NO_SPEED);
 				SetPosZ(floor(GetPosZ()) + 0.5);
 			}
 			else if (GetPosX() > floor(GetPosX()) + 0.5)
 			{
-				if (GetSpeedX() > 0)
+				if (GetSpeedX() > NO_SPEED)
 				{
 					SetSpeedZ(GetSpeedX() * 0.7);
 				}
 
-				SetSpeedX(0);
+				SetSpeedX(NO_SPEED);
 				SetPosX(floor(GetPosX()) + 0.5);
 			}
-			SetSpeedY(0);
+			SetSpeedY(NO_SPEED);
 			break;
 		}
 		case E_META_RAIL_CURVED_ZP_XP:
 		{
 			if (GetPosZ() < floor(GetPosZ()) + 0.5)
 			{
-				if (GetSpeedZ() < 0)
+				if (GetSpeedZ() < NO_SPEED)
 				{
 					SetSpeedX(-GetSpeedZ() * 0.7);
 				}
 
-				SetSpeedZ(0);
+				SetSpeedZ(NO_SPEED);
 				SetPosZ(floor(GetPosZ()) + 0.5);
 			}
 			else if (GetPosX() < floor(GetPosX()) + 0.5)
 			{
-				if (GetSpeedX() < 0)
+				if (GetSpeedX() < NO_SPEED)
 				{
 					SetSpeedZ(-GetSpeedX() * 0.7);
 				}
 
-				SetSpeedX(0);
+				SetSpeedX(NO_SPEED);
 				SetPosX(floor(GetPosX()) + 0.5);
 			}
 			SetSpeedY(0);
@@ -876,7 +877,7 @@ bool cMinecart::TestEntityCollision(NIBBLETYPE a_RailMeta)
 			Vector3d Distance = MinecartCollisionCallback.GetCollidedEntityPosition() - Vector3d(GetPosX(), 0, GetPosZ());
 
 			// Prevent division by small numbers
-			if (abs(Distance.z) < 0.001)
+			if (std::abs(Distance.z) < 0.001)
 			{
 				Distance.z = 0.001;
 			}
@@ -925,7 +926,7 @@ bool cMinecart::TestEntityCollision(NIBBLETYPE a_RailMeta)
 			Vector3d Distance = MinecartCollisionCallback.GetCollidedEntityPosition() - Vector3d(GetPosX(), 0, GetPosZ());
 
 			// Prevent division by small numbers
-			if (abs(Distance.z) < 0.001)
+			if (std::abs(Distance.z) < 0.001)
 			{
 				Distance.z = 0.001;
 			}
@@ -1072,6 +1073,8 @@ cRideableMinecart::cRideableMinecart(double a_X, double a_Y, double a_Z, const c
 
 void cRideableMinecart::OnRightClicked(cPlayer & a_Player)
 {
+	super::OnRightClicked(a_Player);
+
 	if (m_Attachee != NULL)
 	{
 		if (m_Attachee->GetUniqueID() == a_Player.GetUniqueID())
@@ -1124,8 +1127,7 @@ void cMinecartWithChest::SetSlot(size_t a_Idx, const cItem & a_Item)
 
 void cMinecartWithChest::OnRightClicked(cPlayer & a_Player)
 {
-	// Show the chest UI window to the player
-	// TODO
+	// TODO: Show the chest UI window to the player
 }
 
 
diff --git a/src/Entities/Pawn.cpp b/src/Entities/Pawn.cpp
index fe6c24a7a..fc8ca3d47 100644
--- a/src/Entities/Pawn.cpp
+++ b/src/Entities/Pawn.cpp
@@ -9,9 +9,9 @@
 
 
 
-cPawn::cPawn(eEntityType a_EntityType, double a_Width, double a_Height):
-	super(a_EntityType, 0, 0, 0, a_Width, a_Height),
-	m_EntityEffects(tEffectMap())
+cPawn::cPawn(eEntityType a_EntityType, double a_Width, double a_Height) :
+	super(a_EntityType, 0, 0, 0, a_Width, a_Height)
+	, m_EntityEffects(tEffectMap())
 {
 }
 
@@ -111,3 +111,6 @@ void cPawn::ClearEntityEffects()
 		RemoveEntityEffect(EffectType);
 	}
 }
+
+
+
diff --git a/src/Entities/Player.cpp b/src/Entities/Player.cpp
index 38d42be14..66da14c0c 100644
--- a/src/Entities/Player.cpp
+++ b/src/Entities/Player.cpp
@@ -81,7 +81,8 @@ cPlayer::cPlayer(cClientHandle* a_Client, const AString & a_PlayerName) :
 	m_Team(NULL),
 	m_TicksUntilNextSave(PLAYER_INVENTORY_SAVE_INTERVAL),
 	m_bIsTeleporting(false),
-	m_UUID((a_Client != NULL) ? a_Client->GetUUID() : "")
+	m_UUID((a_Client != NULL) ? a_Client->GetUUID() : ""),
+	m_CustomName("")
 {
 	m_InventoryWindow = new cInventoryWindow(*this);
 	m_CurrentWindow = m_InventoryWindow;
@@ -266,7 +267,7 @@ void cPlayer::Tick(float a_Dt, cChunk & a_Chunk)
 	cTimer t1;
 	if (m_LastPlayerListTime + PLAYER_LIST_TIME_MS <= t1.GetNowTime())
 	{
-		m_World->SendPlayerList(this);
+		m_World->BroadcastPlayerListUpdatePing(*this);
 		m_LastPlayerListTime = t1.GetNowTime();
 	}
 
@@ -809,6 +810,29 @@ void cPlayer::SetCanFly(bool a_CanFly)
 
 
 
+void cPlayer::SetCustomName(const AString & a_CustomName)
+{
+	if (m_CustomName == a_CustomName)
+	{
+		return;
+	}
+
+	m_World->BroadcastPlayerListRemovePlayer(*this);
+
+	m_CustomName = a_CustomName;
+	if (m_CustomName.length() > 16)
+	{
+		m_CustomName = m_CustomName.substr(0, 16);
+	}
+
+	m_World->BroadcastPlayerListAddPlayer(*this);
+	m_World->BroadcastSpawnEntity(*this, GetClientHandle());
+}
+
+
+
+
+
 void cPlayer::SetFlying(bool a_IsFlying)
 {
 	if (a_IsFlying == m_IsFlying)
@@ -1176,6 +1200,8 @@ void cPlayer::SetGameMode(eGameMode a_GameMode)
 		SetFlying(false);
 		SetCanFly(false);
 	}
+
+	m_World->BroadcastPlayerListUpdateGameMode(*this);
 }
 
 
@@ -1448,6 +1474,28 @@ AString cPlayer::GetColor(void) const
 
 
 
+AString cPlayer::GetPlayerListName(void) const
+{
+	const AString & Color = GetColor();
+
+	if (HasCustomName())
+	{
+		return m_CustomName;
+	}
+	else if ((GetName().length() <= 14) && !Color.empty())
+	{
+		return Printf("%s%s", Color.c_str(), GetName().c_str());
+	}
+	else
+	{
+		return GetName();
+	}
+}
+
+
+
+
+
 void cPlayer::TossEquippedItem(char a_Amount)
 {
 	cItems Drops;
@@ -2013,8 +2061,8 @@ void cPlayer::UpdateMovementStats(const Vector3d & a_DeltaPos)
 				cMonster * Monster = (cMonster *)m_AttachedTo;
 				switch (Monster->GetMobType())
 				{
-					case cMonster::mtPig:   m_Stats.AddValue(statDistPig,   Value); break;
-					case cMonster::mtHorse: m_Stats.AddValue(statDistHorse, Value); break;
+					case mtPig:   m_Stats.AddValue(statDistPig,   Value); break;
+					case mtHorse: m_Stats.AddValue(statDistHorse, Value); break;
 					default: break;
 				}
 				break;
diff --git a/src/Entities/Player.h b/src/Entities/Player.h
index d64dd6b99..ffd0b7e03 100644
--- a/src/Entities/Player.h
+++ b/src/Entities/Player.h
@@ -254,6 +254,9 @@ public:
 	The returned value either is empty, or includes the cChatColor::Delimiter. */
 	AString GetColor(void) const;
 
+	/** Returns the name that is used in the playerlist. */
+	AString GetPlayerListName(void) const;
+
 	/** tosses the item in the selected hotbar slot */
 	void TossEquippedItem(char a_Amount = 1);
 
@@ -401,6 +404,16 @@ public:
 	/** If true the player can fly even when he's not in creative. */
 	void SetCanFly(bool a_CanFly);
 
+	/** Returns true if the player has a custom name. */
+	bool HasCustomName(void) const { return !m_CustomName.empty(); }
+
+	/** Returns the custom name of this player. If the player hasn't a custom name, it will return an empty string. */
+	const AString & GetCustomName(void) const { return m_CustomName; }
+
+	/** Sets the custom name of this player. If you want to disable the custom name, simply set an empty string.
+	The custom name will be used in the tab-list, in the player nametag and in the tab-completion. */
+	void SetCustomName(const AString & a_CustomName);
+
 	/** Gets the last position that the player slept in
 	This is initialised to the world spawn point if the player has not slept in a bed as of yet
 	*/
@@ -565,6 +578,8 @@ protected:
 	If no ClientHandle is given, the UUID is initialized to empty. */
 	AString m_UUID;
 
+	AString m_CustomName;
+
 	/** Sets the speed and sends it to the client, so that they are forced to move so. */
 	virtual void DoSetSpeed(double a_SpeedX, double a_SpeedY, double a_SpeedZ) override;
 
diff --git a/src/Entities/ThrownEggEntity.cpp b/src/Entities/ThrownEggEntity.cpp
index 456083108..5ae85bee8 100644
--- a/src/Entities/ThrownEggEntity.cpp
+++ b/src/Entities/ThrownEggEntity.cpp
@@ -48,13 +48,13 @@ void cThrownEggEntity::TrySpawnChicken(const Vector3d & a_HitPos)
 {
 	if (m_World->GetTickRandomNumber(7) == 1)
 	{
-		m_World->SpawnMob(a_HitPos.x, a_HitPos.y, a_HitPos.z, cMonster::mtChicken);
+		m_World->SpawnMob(a_HitPos.x, a_HitPos.y, a_HitPos.z, mtChicken);
 	}
 	else if (m_World->GetTickRandomNumber(32) == 1)
 	{
-		m_World->SpawnMob(a_HitPos.x, a_HitPos.y, a_HitPos.z, cMonster::mtChicken);
-		m_World->SpawnMob(a_HitPos.x, a_HitPos.y, a_HitPos.z, cMonster::mtChicken);
-		m_World->SpawnMob(a_HitPos.x, a_HitPos.y, a_HitPos.z, cMonster::mtChicken);
-		m_World->SpawnMob(a_HitPos.x, a_HitPos.y, a_HitPos.z, cMonster::mtChicken);
+		m_World->SpawnMob(a_HitPos.x, a_HitPos.y, a_HitPos.z, mtChicken);
+		m_World->SpawnMob(a_HitPos.x, a_HitPos.y, a_HitPos.z, mtChicken);
+		m_World->SpawnMob(a_HitPos.x, a_HitPos.y, a_HitPos.z, mtChicken);
+		m_World->SpawnMob(a_HitPos.x, a_HitPos.y, a_HitPos.z, mtChicken);
 	}
 }
diff --git a/src/Entities/ThrownSnowballEntity.cpp b/src/Entities/ThrownSnowballEntity.cpp
index d94e75898..496397100 100644
--- a/src/Entities/ThrownSnowballEntity.cpp
+++ b/src/Entities/ThrownSnowballEntity.cpp
@@ -32,8 +32,8 @@ void cThrownSnowballEntity::OnHitEntity(cEntity & a_EntityHit, const Vector3d &
 	int TotalDamage = 0;
 	if (a_EntityHit.IsMob())
 	{
-		cMonster::eType MobType = ((cMonster &) a_EntityHit).GetMobType();
-		if (MobType == cMonster::mtBlaze)
+		eMonsterType MobType = ((cMonster &) a_EntityHit).GetMobType();
+		if (MobType == mtBlaze)
 		{
 			TotalDamage = 3;
 		}
diff --git a/src/Generating/BioGen.cpp b/src/Generating/BioGen.cpp
index 217ca8f80..3ee0bd4c5 100644
--- a/src/Generating/BioGen.cpp
+++ b/src/Generating/BioGen.cpp
@@ -913,15 +913,32 @@ EMCSBiome cBioGenTwoLevel::SelectBiome(int a_BiomeGroup, int a_BiomeIdx, int a_D
 
 void cBioGenTwoLevel::InitializeBiomeGen(cIniFile & a_IniFile)
 {
-	// TODO: Read these from a file
-	m_VoronoiLarge.SetCellSize(1024);
-	m_VoronoiSmall.SetCellSize(128);
-	m_DistortX.AddOctave(0.01f,   16);
-	m_DistortX.AddOctave(0.005f,   8);
-	m_DistortX.AddOctave(0.0025f,  4);
-	m_DistortZ.AddOctave(0.01f,   16);
-	m_DistortZ.AddOctave(0.005f,   8);
-	m_DistortZ.AddOctave(0.0025f,  4);
+	m_VoronoiLarge.SetCellSize(a_IniFile.GetValueSetI("Generator", "TwoLevelLargeCellSize", 1024));
+	m_VoronoiSmall.SetCellSize(a_IniFile.GetValueSetI("Generator", "TwoLevelSmallCellSize", 128));
+	m_DistortX.AddOctave(
+		(float)a_IniFile.GetValueSetF("Generator", "TwoLevelDistortXOctave1Freq", 0.01),
+		(float)a_IniFile.GetValueSetF("Generator", "TwoLevelDistortXOctave1Amp",  16)
+	);
+	m_DistortX.AddOctave(
+		(float)a_IniFile.GetValueSetF("Generator", "TwoLevelDistortXOctave2Freq", 0.005),
+		(float)a_IniFile.GetValueSetF("Generator", "TwoLevelDistortXOctave2Amp",  8)
+	);
+	m_DistortX.AddOctave(
+		(float)a_IniFile.GetValueSetF("Generator", "TwoLevelDistortXOctave3Freq", 0.0025),
+		(float)a_IniFile.GetValueSetF("Generator", "TwoLevelDistortXOctave3Amp",  4)
+	);
+	m_DistortZ.AddOctave(
+		(float)a_IniFile.GetValueSetF("Generator", "TwoLevelDistortZOctave1Freq", 0.01),
+		(float)a_IniFile.GetValueSetF("Generator", "TwoLevelDistortZOctave1Amp",  16)
+	);
+	m_DistortZ.AddOctave(
+		(float)a_IniFile.GetValueSetF("Generator", "TwoLevelDistortZOctave2Freq", 0.005),
+		(float)a_IniFile.GetValueSetF("Generator", "TwoLevelDistortZOctave2Amp",  8)
+	);
+	m_DistortZ.AddOctave(
+		(float)a_IniFile.GetValueSetF("Generator", "TwoLevelDistortZOctave3Freq", 0.0025),
+		(float)a_IniFile.GetValueSetF("Generator", "TwoLevelDistortZOctave3Amp",  4)
+	);
 }
 
 
diff --git a/src/Generating/Caves.cpp b/src/Generating/Caves.cpp
index 71154dff9..fc925a150 100644
--- a/src/Generating/Caves.cpp
+++ b/src/Generating/Caves.cpp
@@ -755,7 +755,7 @@ void cStructGenDualRidgeCaves::GenFinish(cChunkDesc & a_ChunkDesc)
 				float n2 = m_Noise2.CubicNoise3D(xx, yy, zz);
 				float n3 = m_Noise1.CubicNoise3D(xx * 4, yy * 4, zz * 4) / 4;
 				float n4 = m_Noise2.CubicNoise3D(xx * 4, yy * 4, zz * 4) / 4;
-				if ((abs(n1 + n3) * abs(n2 + n4)) > m_Threshold)
+				if ((std::abs(n1 + n3) * std::abs(n2 + n4)) > m_Threshold)
 				{
 					a_ChunkDesc.SetBlockType(x, y, z, E_BLOCK_AIR);
 				}
diff --git a/src/Generating/FinishGen.cpp b/src/Generating/FinishGen.cpp
index eb57a5faa..96e3dc26b 100644
--- a/src/Generating/FinishGen.cpp
+++ b/src/Generating/FinishGen.cpp
@@ -15,6 +15,7 @@
 #include "../Simulator/FluidSimulator.h"  // for cFluidSimulator::CanWashAway()
 #include "../Simulator/FireSimulator.h"
 #include "../World.h"
+#include "inifile/iniFile.h"
 
 
 
diff --git a/src/Generating/Noise3DGenerator.cpp b/src/Generating/Noise3DGenerator.cpp
index eb816f564..c3ca30384 100644
--- a/src/Generating/Noise3DGenerator.cpp
+++ b/src/Generating/Noise3DGenerator.cpp
@@ -236,7 +236,7 @@ void cNoise3DGenerator::GenerateNoiseArray(int a_ChunkX, int a_ChunkZ, NOISE_DAT
 	m_Cubic.Generate2D(Height, DIM_X, DIM_Z, StartX / 25, EndX / 25, StartZ / 25, EndZ / 25);
 	for (size_t i = 0; i < ARRAYCOUNT(Height); i++)
 	{
-		Height[i] = abs(Height[i]) * m_HeightAmplification + 1;
+		Height[i] = std::abs(Height[i]) * m_HeightAmplification + 1;
 	}
 
 	// Modify the noise by height data:
@@ -395,7 +395,7 @@ void cNoise3DComposable::GenerateNoiseArrayIfNeeded(int a_ChunkX, int a_ChunkZ)
 		for (int x = 0; x < 17; x += UPSCALE_X)
 		{
 			NOISE_DATATYPE NoiseX = ((NOISE_DATATYPE)(a_ChunkX * cChunkDef::Width + x)) / m_FrequencyX;
-			NOISE_DATATYPE val = abs(m_Noise1.CubicNoise2D(NoiseX / 5, NoiseZ / 5)) * m_HeightAmplification + 1;
+			NOISE_DATATYPE val = std::abs(m_Noise1.CubicNoise2D(NoiseX / 5, NoiseZ / 5)) * m_HeightAmplification + 1;
 			Height[x + 17 * z] = val * val * val;
 		}
 	}
diff --git a/src/Globals.h b/src/Globals.h
index de1024010..0926457da 100644
--- a/src/Globals.h
+++ b/src/Globals.h
@@ -162,8 +162,17 @@ template class SizeChecker<UInt16, 2>;
 	TypeName(const TypeName &); \
 	void operator =(const TypeName &)
 
+// A macro that is used to mark unused local variables, to avoid pedantic warnings in gcc / clang / MSVC
+// Note that in MSVC it requires the full type of X to be known
+#define UNUSED_VAR(X) (void)(X)
+
 // A macro that is used to mark unused function parameters, to avoid pedantic warnings in gcc
-#define UNUSED(X) (void)(X)
+// Written so that the full type of param needn't be known
+#ifdef _MSC_VER
+	#define UNUSED(X)
+#else
+	#define UNUSED UNUSED_VAR
+#endif
 
 
 
@@ -261,6 +270,27 @@ void inline LOGERROR(const char* a_Format, ...)
 	vprintf(a_Format, argList);
 	va_end(argList);
 }
+
+void inline LOGWARNING(const char* a_Format, ...) FORMATSTRING(1, 2);
+
+void inline LOGWARNING(const char* a_Format, ...)
+{
+	va_list argList;
+	va_start(argList, a_Format);
+	vprintf(a_Format, argList);
+	va_end(argList);
+}
+
+void inline LOGD(const char* a_Format, ...) FORMATSTRING(1, 2);
+
+void inline LOGD(const char* a_Format, ...)
+{
+	va_list argList;
+	va_start(argList, a_Format);
+	vprintf(a_Format, argList);
+	va_end(argList);
+}
+
 #endif
 
 
diff --git a/src/Items/ItemBucket.h b/src/Items/ItemBucket.h
index a17c4838b..3a533958f 100644
--- a/src/Items/ItemBucket.h
+++ b/src/Items/ItemBucket.h
@@ -7,6 +7,7 @@
 #include "../Blocks/BlockHandler.h"
 #include "../LineBlockTracer.h"
 #include "../BlockInServerPluginInterface.h"
+#include "../Blocks/ChunkInterface.h"
 
 
 
diff --git a/src/Items/ItemDoor.h b/src/Items/ItemDoor.h
index c1b439024..cd5baf44f 100644
--- a/src/Items/ItemDoor.h
+++ b/src/Items/ItemDoor.h
@@ -30,7 +30,22 @@ public:
 		BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
 	) override
 	{
-		a_BlockType = (m_ItemType == E_ITEM_WOODEN_DOOR) ? E_BLOCK_WOODEN_DOOR : E_BLOCK_IRON_DOOR;
+		switch (m_ItemType)
+		{
+			case E_ITEM_WOODEN_DOOR:   a_BlockType = E_BLOCK_WOODEN_DOOR; break;
+			case E_ITEM_IRON_DOOR:     a_BlockType = E_BLOCK_IRON_DOOR; break;
+			case E_ITEM_SPRUCE_DOOR:   a_BlockType = E_BLOCK_SPRUCE_DOOR; break;
+			case E_ITEM_BIRCH_DOOR:    a_BlockType = E_BLOCK_BIRCH_DOOR; break;
+			case E_ITEM_JUNGLE_DOOR:   a_BlockType = E_BLOCK_JUNGLE_DOOR; break;
+			case E_ITEM_DARK_OAK_DOOR: a_BlockType = E_BLOCK_DARK_OAK_DOOR; break;
+			case E_ITEM_ACACIA_DOOR:   a_BlockType = E_BLOCK_ACACIA_DOOR; break;
+			default:
+			{
+				ASSERT(!"Unhandled door type");
+				return false;
+			}
+		}
+		
 		cChunkInterface ChunkInterface(a_World->GetChunkMap());
 		bool Meta = BlockHandler(a_BlockType)->GetPlacementBlockTypeMeta(
 			ChunkInterface, a_Player,
diff --git a/src/Items/ItemFood.h b/src/Items/ItemFood.h
index 1af6e21e8..e7c718c77 100644
--- a/src/Items/ItemFood.h
+++ b/src/Items/ItemFood.h
@@ -35,7 +35,9 @@ public:
 			// Carrots handled in ItemSeeds
 			case E_ITEM_COOKED_CHICKEN:   return FoodInfo(6, 7.2);
 			case E_ITEM_COOKED_FISH:      return FoodInfo(5, 6);  // TODO: Add other fish types
+			case E_ITEM_COOKED_MUTTON:    return FoodInfo(6, 9.6);
 			case E_ITEM_COOKED_PORKCHOP:  return FoodInfo(8, 12.8);
+			case E_ITEM_COOKED_RABBIT:    return FoodInfo(5, 6);
 			case E_ITEM_COOKIE:           return FoodInfo(2, 0.4);
 			// Golden apple handled in ItemGoldenApple
 			case E_ITEM_GOLDEN_CARROT:    return FoodInfo(6, 14.4);
@@ -43,16 +45,17 @@ public:
 			case E_ITEM_POISONOUS_POTATO: return FoodInfo(2, 1.2);
 			// Potatoes handled in ItemSeeds
 			case E_ITEM_PUMPKIN_PIE:      return FoodInfo(8, 4.8);
+			case E_ITEM_RABBIT_STEW:      return FoodInfo(10, 12);
 			case E_ITEM_RED_APPLE:        return FoodInfo(4, 2.4);
 			case E_ITEM_RAW_BEEF:         return FoodInfo(3, 1.8);
 			case E_ITEM_RAW_CHICKEN:      return FoodInfo(2, 1.2);
 			case E_ITEM_RAW_FISH:         return FoodInfo(2, 1.2);
 			case E_ITEM_RAW_MUTTON:       return FoodInfo(2, 1.2);
 			case E_ITEM_RAW_PORKCHOP:     return FoodInfo(3, 1.8);
+			case E_ITEM_RAW_RABBIT:       return FoodInfo(3, 1.8);
 			case E_ITEM_ROTTEN_FLESH:     return FoodInfo(4, 0.8);
 			case E_ITEM_SPIDER_EYE:       return FoodInfo(2, 3.2);
 			case E_ITEM_STEAK:            return FoodInfo(8, 12.8);
-			case E_ITEM_MUTTON:           return FoodInfo(6, 9.6);
 		}
 		LOGWARNING("%s: Unknown food item (%d), returning zero nutrition", __FUNCTION__, m_ItemType);
 		return FoodInfo(0, 0.f);
diff --git a/src/Items/ItemHandler.cpp b/src/Items/ItemHandler.cpp
index 8c3f28c74..caa623abc 100644
--- a/src/Items/ItemHandler.cpp
+++ b/src/Items/ItemHandler.cpp
@@ -193,6 +193,11 @@ cItemHandler *cItemHandler::CreateItemHandler(int a_ItemType)
 			return new cItemSeedsHandler(a_ItemType);
 		}
 		
+		case E_ITEM_ACACIA_DOOR:
+		case E_ITEM_BIRCH_DOOR:
+		case E_ITEM_DARK_OAK_DOOR:
+		case E_ITEM_JUNGLE_DOOR:
+		case E_ITEM_SPRUCE_DOOR:
 		case E_ITEM_IRON_DOOR:
 		case E_ITEM_WOODEN_DOOR:
 		{
@@ -214,19 +219,22 @@ cItemHandler *cItemHandler::CreateItemHandler(int a_ItemType)
 		case E_ITEM_BREAD:
 		case E_ITEM_COOKED_CHICKEN:
 		case E_ITEM_COOKED_FISH:
+		case E_ITEM_COOKED_MUTTON:
 		case E_ITEM_COOKED_PORKCHOP:
+		case E_ITEM_COOKED_RABBIT:
 		case E_ITEM_COOKIE:
 		case E_ITEM_GOLDEN_CARROT:
 		case E_ITEM_MELON_SLICE:
-		case E_ITEM_MUTTON:
 		case E_ITEM_POISONOUS_POTATO:
 		case E_ITEM_PUMPKIN_PIE:
-		case E_ITEM_RED_APPLE:
+		case E_ITEM_RABBIT_STEW:
 		case E_ITEM_RAW_BEEF:
 		case E_ITEM_RAW_CHICKEN:
 		case E_ITEM_RAW_FISH:
 		case E_ITEM_RAW_MUTTON:
 		case E_ITEM_RAW_PORKCHOP:
+		case E_ITEM_RAW_RABBIT:
+		case E_ITEM_RED_APPLE:
 		case E_ITEM_ROTTEN_FLESH:
 		case E_ITEM_SPIDER_EYE:
 		case E_ITEM_STEAK:
@@ -392,8 +400,12 @@ char cItemHandler::GetMaxStackSize(void)
 	
 	switch (m_ItemType)
 	{
+		case E_ITEM_ACACIA_DOOR:          return 64;
+		case E_ITEM_ARMOR_STAND:          return 16;
 		case E_ITEM_ARROW:                return 64;
 		case E_ITEM_BAKED_POTATO:         return 64;
+		case E_ITEM_BANNER:               return 16;
+		case E_ITEM_BIRCH_DOOR:           return 64;
 		case E_ITEM_BLAZE_POWDER:         return 64;
 		case E_ITEM_BLAZE_ROD:            return 64;
 		case E_ITEM_BONE:                 return 64;
@@ -404,7 +416,6 @@ char cItemHandler::GetMaxStackSize(void)
 		case E_ITEM_BREWING_STAND:        return 64;
 		case E_ITEM_BUCKET:               return 16;
 		case E_ITEM_CARROT:               return 64;
-		case E_ITEM_CAKE:                 return 1;
 		case E_ITEM_CAULDRON:             return 64;
 		case E_ITEM_CLAY:                 return 64;
 		case E_ITEM_CLAY_BRICK:           return 64;
@@ -415,7 +426,9 @@ char cItemHandler::GetMaxStackSize(void)
 		case E_ITEM_COOKED_CHICKEN:       return 64;
 		case E_ITEM_COOKED_FISH:          return 64;
 		case E_ITEM_COOKED_PORKCHOP:      return 64;
+		case E_ITEM_COOKED_MUTTON:        return 64;
 		case E_ITEM_COOKIE:               return 64;
+		case E_ITEM_DARK_OAK_DOOR:        return 64;
 		case E_ITEM_DIAMOND:              return 64;
 		case E_ITEM_DYE:                  return 64;
 		case E_ITEM_EGG:                  return 16;
@@ -439,6 +452,7 @@ char cItemHandler::GetMaxStackSize(void)
 		case E_ITEM_GOLD_NUGGET:          return 64;
 		case E_ITEM_GUNPOWDER:            return 64;
 		case E_ITEM_HEAD:                 return 64;
+		case E_ITEM_JUNGLE_DOOR:          return 64;
 		case E_ITEM_IRON:                 return 64;
 		case E_ITEM_ITEM_FRAME:           return 64;
 		case E_ITEM_LEATHER:              return 64;
@@ -452,11 +466,16 @@ char cItemHandler::GetMaxStackSize(void)
 		case E_ITEM_PAPER:                return 64;
 		case E_ITEM_POISONOUS_POTATO:     return 64;
 		case E_ITEM_POTATO:               return 64;
+		case E_ITEM_PRISMARINE_CRYSTALS:  return 64;
+		case E_ITEM_PRISMARINE_SHARD:     return 64;
 		case E_ITEM_PUMPKIN_PIE:          return 64;
 		case E_ITEM_PUMPKIN_SEEDS:        return 64;
+		case E_ITEM_RABBITS_FOOT:         return 64;
+		case E_ITEM_RABBIT_HIDE:          return 64;
 		case E_ITEM_RAW_BEEF:             return 64;
 		case E_ITEM_RAW_CHICKEN:          return 64;
 		case E_ITEM_RAW_FISH:             return 64;
+		case E_ITEM_RAW_MUTTON:           return 64;
 		case E_ITEM_RAW_PORKCHOP:         return 64;
 		case E_ITEM_RED_APPLE:            return 64;
 		case E_ITEM_REDSTONE_DUST:        return 64;
@@ -468,6 +487,7 @@ char cItemHandler::GetMaxStackSize(void)
 		case E_ITEM_SNOWBALL:             return 16;
 		case E_ITEM_SPAWN_EGG:            return 64;
 		case E_ITEM_SPIDER_EYE:           return 64;
+		case E_ITEM_SPRUCE_DOOR:          return 64;
 		case E_ITEM_STEAK:                return 64;
 		case E_ITEM_STICK:                return 64;
 		case E_ITEM_STRING:               return 64;
@@ -546,41 +566,47 @@ bool cItemHandler::CanHarvestBlock(BLOCKTYPE a_BlockType)
 	switch (a_BlockType)
 	{
 		case E_BLOCK_ANVIL:
-		case E_BLOCK_ENCHANTMENT_TABLE:
-		case E_BLOCK_FURNACE:
-		case E_BLOCK_LIT_FURNACE:
+		case E_BLOCK_BRICK:
+		case E_BLOCK_CAULDRON:
 		case E_BLOCK_COAL_ORE:
-		case E_BLOCK_STONE:
 		case E_BLOCK_COBBLESTONE:
-		case E_BLOCK_END_STONE:
-		case E_BLOCK_MOSSY_COBBLESTONE:
-		case E_BLOCK_SANDSTONE_STAIRS:
-		case E_BLOCK_SANDSTONE:
-		case E_BLOCK_STONE_BRICKS:
-		case E_BLOCK_NETHER_BRICK:
-		case E_BLOCK_NETHERRACK:
-		case E_BLOCK_STONE_SLAB:
-		case E_BLOCK_DOUBLE_STONE_SLAB:
-		case E_BLOCK_STONE_PRESSURE_PLATE:
-		case E_BLOCK_BRICK:
 		case E_BLOCK_COBBLESTONE_STAIRS:
 		case E_BLOCK_COBBLESTONE_WALL:
-		case E_BLOCK_STONE_BRICK_STAIRS:
-		case E_BLOCK_NETHER_BRICK_STAIRS:
-		case E_BLOCK_CAULDRON:
-		case E_BLOCK_OBSIDIAN:
 		case E_BLOCK_DIAMOND_BLOCK:
 		case E_BLOCK_DIAMOND_ORE:
+		case E_BLOCK_DOUBLE_STONE_SLAB:
+		case E_BLOCK_EMERALD_ORE:
+		case E_BLOCK_ENCHANTMENT_TABLE:
+		case E_BLOCK_END_STONE:
+		case E_BLOCK_FURNACE:
 		case E_BLOCK_GOLD_BLOCK:
 		case E_BLOCK_GOLD_ORE:
-		case E_BLOCK_REDSTONE_ORE:
-		case E_BLOCK_REDSTONE_ORE_GLOWING:
-		case E_BLOCK_EMERALD_ORE:
 		case E_BLOCK_IRON_BLOCK:
 		case E_BLOCK_IRON_ORE:
-		case E_BLOCK_LAPIS_ORE:
+		case E_BLOCK_IRON_TRAPDOOR:
 		case E_BLOCK_LAPIS_BLOCK:
+		case E_BLOCK_LAPIS_ORE:
+		case E_BLOCK_LIT_FURNACE:
+		case E_BLOCK_MOSSY_COBBLESTONE:
+		case E_BLOCK_NETHER_BRICK:
+		case E_BLOCK_NETHER_BRICK_STAIRS:
+		case E_BLOCK_NETHER_BRICK_FENCE:
+		case E_BLOCK_NETHERRACK:
+		case E_BLOCK_NEW_STONE_SLAB:
+		case E_BLOCK_OBSIDIAN:
+		case E_BLOCK_PRISMARINE_BLOCK:
+		case E_BLOCK_RED_SANDSTONE:
+		case E_BLOCK_RED_SANDSTONE_STAIRS:
+		case E_BLOCK_REDSTONE_ORE:
+		case E_BLOCK_REDSTONE_ORE_GLOWING:
+		case E_BLOCK_SANDSTONE_STAIRS:
+		case E_BLOCK_SANDSTONE:
 		case E_BLOCK_SNOW:
+		case E_BLOCK_STONE:
+		case E_BLOCK_STONE_BRICKS:
+		case E_BLOCK_STONE_BRICK_STAIRS:
+		case E_BLOCK_STONE_PRESSURE_PLATE:
+		case E_BLOCK_STONE_SLAB:
 		case E_BLOCK_VINES:
 		case E_BLOCK_PACKED_ICE:
 		case E_BLOCK_MOB_SPAWNER:
diff --git a/src/Items/ItemHoe.h b/src/Items/ItemHoe.h
index 8e63536d4..de8b9a061 100644
--- a/src/Items/ItemHoe.h
+++ b/src/Items/ItemHoe.h
@@ -47,4 +47,3 @@ public:
 
 
 
-
diff --git a/src/Items/ItemSpawnEgg.h b/src/Items/ItemSpawnEgg.h
index bba97afa1..617ecd808 100644
--- a/src/Items/ItemSpawnEgg.h
+++ b/src/Items/ItemSpawnEgg.h
@@ -33,9 +33,9 @@ public:
 			a_BlockY--;
 		}
 
-		cMonster::eType MonsterType = ItemDamageToMonsterType(a_Item.m_ItemDamage);
+		eMonsterType MonsterType = ItemDamageToMonsterType(a_Item.m_ItemDamage);
 		if (
-			(MonsterType != cMonster::mtInvalidType) &&  // Valid monster type
+			(MonsterType != mtInvalidType) &&  // Valid monster type
 			(a_World->SpawnMob(a_BlockX + 0.5, a_BlockY, a_BlockZ + 0.5, MonsterType) >= 0))  // Spawning succeeded
 		{
 			if (!a_Player->IsGameModeCreative())
@@ -52,36 +52,36 @@ public:
 	
 	/** Converts the Spawn egg item damage to the monster type to spawn.
 	Returns mtInvalidType for invalid damage values. */
-	static cMonster::eType ItemDamageToMonsterType(short a_ItemDamage)
+	static eMonsterType ItemDamageToMonsterType(short a_ItemDamage)
 	{
 		switch (a_ItemDamage)
 		{
-			case E_META_SPAWN_EGG_BAT:           return cMonster::mtBat;
-			case E_META_SPAWN_EGG_BLAZE:         return cMonster::mtBlaze;
-			case E_META_SPAWN_EGG_CAVE_SPIDER:   return cMonster::mtCaveSpider;
-			case E_META_SPAWN_EGG_CHICKEN:       return cMonster::mtChicken;
-			case E_META_SPAWN_EGG_COW:           return cMonster::mtCow;
-			case E_META_SPAWN_EGG_CREEPER:       return cMonster::mtCreeper;
-			case E_META_SPAWN_EGG_ENDERMAN:      return cMonster::mtEnderman;
-			case E_META_SPAWN_EGG_GHAST:         return cMonster::mtGhast;
-			case E_META_SPAWN_EGG_HORSE:         return cMonster::mtHorse;
-			case E_META_SPAWN_EGG_MAGMA_CUBE:    return cMonster::mtMagmaCube;
-			case E_META_SPAWN_EGG_MOOSHROOM:     return cMonster::mtMooshroom;
-			case E_META_SPAWN_EGG_OCELOT:        return cMonster::mtOcelot;
-			case E_META_SPAWN_EGG_PIG:           return cMonster::mtPig;
-			case E_META_SPAWN_EGG_SHEEP:         return cMonster::mtSheep;
-			case E_META_SPAWN_EGG_SILVERFISH:    return cMonster::mtSilverfish;
-			case E_META_SPAWN_EGG_SKELETON:      return cMonster::mtSkeleton;
-			case E_META_SPAWN_EGG_SLIME:         return cMonster::mtSlime;
-			case E_META_SPAWN_EGG_SPIDER:        return cMonster::mtSpider;
-			case E_META_SPAWN_EGG_SQUID:         return cMonster::mtSquid;
-			case E_META_SPAWN_EGG_VILLAGER:      return cMonster::mtVillager;
-			case E_META_SPAWN_EGG_WITCH:         return cMonster::mtWitch;
-			case E_META_SPAWN_EGG_WOLF:          return cMonster::mtWolf;
-			case E_META_SPAWN_EGG_ZOMBIE:        return cMonster::mtZombie;
-			case E_META_SPAWN_EGG_ZOMBIE_PIGMAN: return cMonster::mtZombiePigman;
+			case E_META_SPAWN_EGG_BAT:           return mtBat;
+			case E_META_SPAWN_EGG_BLAZE:         return mtBlaze;
+			case E_META_SPAWN_EGG_CAVE_SPIDER:   return mtCaveSpider;
+			case E_META_SPAWN_EGG_CHICKEN:       return mtChicken;
+			case E_META_SPAWN_EGG_COW:           return mtCow;
+			case E_META_SPAWN_EGG_CREEPER:       return mtCreeper;
+			case E_META_SPAWN_EGG_ENDERMAN:      return mtEnderman;
+			case E_META_SPAWN_EGG_GHAST:         return mtGhast;
+			case E_META_SPAWN_EGG_HORSE:         return mtHorse;
+			case E_META_SPAWN_EGG_MAGMA_CUBE:    return mtMagmaCube;
+			case E_META_SPAWN_EGG_MOOSHROOM:     return mtMooshroom;
+			case E_META_SPAWN_EGG_OCELOT:        return mtOcelot;
+			case E_META_SPAWN_EGG_PIG:           return mtPig;
+			case E_META_SPAWN_EGG_SHEEP:         return mtSheep;
+			case E_META_SPAWN_EGG_SILVERFISH:    return mtSilverfish;
+			case E_META_SPAWN_EGG_SKELETON:      return mtSkeleton;
+			case E_META_SPAWN_EGG_SLIME:         return mtSlime;
+			case E_META_SPAWN_EGG_SPIDER:        return mtSpider;
+			case E_META_SPAWN_EGG_SQUID:         return mtSquid;
+			case E_META_SPAWN_EGG_VILLAGER:      return mtVillager;
+			case E_META_SPAWN_EGG_WITCH:         return mtWitch;
+			case E_META_SPAWN_EGG_WOLF:          return mtWolf;
+			case E_META_SPAWN_EGG_ZOMBIE:        return mtZombie;
+			case E_META_SPAWN_EGG_ZOMBIE_PIGMAN: return mtZombiePigman;
 		}
-		return cMonster::mtInvalidType;
+		return mtInvalidType;
 	}
 } ;
 
diff --git a/src/LineBlockTracer.cpp b/src/LineBlockTracer.cpp
index f03e796d1..1b42081c2 100644
--- a/src/LineBlockTracer.cpp
+++ b/src/LineBlockTracer.cpp
@@ -146,7 +146,7 @@ bool cLineBlockTracer::MoveToNextBlock(void)
 		dirY,
 		dirZ,
 	} Direction = dirNONE;
-	if (abs(m_DiffX) > EPS)
+	if (std::abs(m_DiffX) > EPS)
 	{
 		double DestX = (m_DirX > 0) ? (m_CurrentX + 1) : m_CurrentX;
 		Coeff = (DestX - m_StartX) / m_DiffX;
@@ -155,7 +155,7 @@ bool cLineBlockTracer::MoveToNextBlock(void)
 			Direction = dirX;
 		}
 	}
-	if (abs(m_DiffY) > EPS)
+	if (std::abs(m_DiffY) > EPS)
 	{
 		double DestY = (m_DirY > 0) ? (m_CurrentY + 1) : m_CurrentY;
 		double CoeffY = (DestY - m_StartY) / m_DiffY;
@@ -165,7 +165,7 @@ bool cLineBlockTracer::MoveToNextBlock(void)
 			Direction = dirY;
 		}
 	}
-	if (abs(m_DiffZ) > EPS)
+	if (std::abs(m_DiffZ) > EPS)
 	{
 		double DestZ = (m_DirZ > 0) ? (m_CurrentZ + 1) : m_CurrentZ;
 		double CoeffZ = (DestZ - m_StartZ) / m_DiffZ;
@@ -227,9 +227,11 @@ bool cLineBlockTracer::Item(cChunk * a_Chunk)
 		}
 
 		// Update the current chunk
-		if (a_Chunk != NULL)
+		a_Chunk = a_Chunk->GetNeighborChunk(m_CurrentX, m_CurrentZ);
+		if (a_Chunk == NULL)
 		{
-			a_Chunk = a_Chunk->GetNeighborChunk(m_CurrentX, m_CurrentZ);
+			m_Callbacks->OnNoChunk();
+			return false;
 		}
 
 		if (a_Chunk->IsValid())
@@ -245,13 +247,10 @@ bool cLineBlockTracer::Item(cChunk * a_Chunk)
 				return false;
 			}
 		}
-		else
+		else if (m_Callbacks->OnNextBlockNoData(m_CurrentX, m_CurrentY, m_CurrentZ, m_CurrentFace))
 		{
-			if (m_Callbacks->OnNextBlockNoData(m_CurrentX, m_CurrentY, m_CurrentZ, m_CurrentFace))
-			{
-				// The callback terminated the trace
-				return false;
-			}
+			// The callback terminated the trace
+			return false;
 		}
 	}
 }
diff --git a/src/Map.cpp b/src/Map.cpp
index 8f205a606..c106ccd83 100644
--- a/src/Map.cpp
+++ b/src/Map.cpp
@@ -432,7 +432,7 @@ void cMap::StreamNext(cMapClient & a_Client)
 		// This is dangerous as the player object may have been destroyed before the decorator is erased from the list
 		UpdateDecorators();
 
-		Handle->SendMapDecorators(m_ID, m_Decorators);
+		Handle->SendMapDecorators(m_ID, m_Decorators, m_Scale);
 
 		a_Client.m_NextDecoratorUpdate = 0;
 	}
@@ -444,7 +444,7 @@ void cMap::StreamNext(cMapClient & a_Client)
 
 		const Byte * Colors = &m_Data[Y * m_Height];
 
-		Handle->SendMapColumn(m_ID, Y, 0, Colors, m_Height);
+		Handle->SendMapColumn(m_ID, Y, 0, Colors, m_Height, m_Scale);
 	}
 }
 
@@ -595,10 +595,10 @@ void cMap::SendTo(cClientHandle & a_Client)
 	{
 		const Byte* Colors = &m_Data[i * m_Height];
 
-		a_Client.SendMapColumn(m_ID, i, 0, Colors, m_Height);
+		a_Client.SendMapColumn(m_ID, i, 0, Colors, m_Height, m_Scale);
 	}
 
-	a_Client.SendMapDecorators(m_ID, m_Decorators);
+	a_Client.SendMapDecorators(m_ID, m_Decorators, m_Scale);
 }
 
 
diff --git a/src/MobSpawner.cpp b/src/MobSpawner.cpp
index 2350ffe85..fb73e0b1b 100644
--- a/src/MobSpawner.cpp
+++ b/src/MobSpawner.cpp
@@ -8,12 +8,12 @@
 
 
 
-cMobSpawner::cMobSpawner(cMonster::eFamily a_MonsterFamily, const std::set<cMonster::eType>& a_AllowedTypes) :
+cMobSpawner::cMobSpawner(cMonster::eFamily a_MonsterFamily, const std::set<eMonsterType>& a_AllowedTypes) :
 	m_MonsterFamily(a_MonsterFamily),
 	m_NewPack(true),
-	m_MobType(cMonster::mtInvalidType)
+	m_MobType(mtInvalidType)
 {
-	for (std::set<cMonster::eType>::const_iterator itr = a_AllowedTypes.begin(); itr != a_AllowedTypes.end(); ++itr)
+	for (std::set<eMonsterType>::const_iterator itr = a_AllowedTypes.begin(); itr != a_AllowedTypes.end(); ++itr)
 	{
 		if (cMonster::FamilyFromType(*itr) == a_MonsterFamily)
 		{
@@ -44,9 +44,9 @@ bool cMobSpawner::CheckPackCenter(BLOCKTYPE a_BlockType)
 
 
 
-void cMobSpawner::addIfAllowed(cMonster::eType toAdd, std::set<cMonster::eType>& toAddIn)
+void cMobSpawner::addIfAllowed(eMonsterType toAdd, std::set<eMonsterType>& toAddIn)
 {
-	std::set<cMonster::eType>::iterator itr = m_AllowedTypes.find(toAdd);
+	std::set<eMonsterType>::iterator itr = m_AllowedTypes.find(toAdd);
 	if (itr != m_AllowedTypes.end())
 	{
 		toAddIn.insert(toAdd);
@@ -57,49 +57,49 @@ void cMobSpawner::addIfAllowed(cMonster::eType toAdd, std::set<cMonster::eType>&
 
 
 
-cMonster::eType cMobSpawner::ChooseMobType(EMCSBiome a_Biome)
+eMonsterType cMobSpawner::ChooseMobType(EMCSBiome a_Biome)
 {
-	std::set<cMonster::eType> allowedMobs;
+	std::set<eMonsterType> allowedMobs;
 
 	if (a_Biome == biMushroomIsland || a_Biome == biMushroomShore)
 	{
-		addIfAllowed(cMonster::mtMooshroom, allowedMobs);
+		addIfAllowed(mtMooshroom, allowedMobs);
 	}
 	else if (a_Biome == biNether)
 	{
-		addIfAllowed(cMonster::mtGhast, allowedMobs);
-		addIfAllowed(cMonster::mtZombiePigman, allowedMobs);
-		addIfAllowed(cMonster::mtMagmaCube, allowedMobs);
+		addIfAllowed(mtGhast, allowedMobs);
+		addIfAllowed(mtZombiePigman, allowedMobs);
+		addIfAllowed(mtMagmaCube, allowedMobs);
 	}
 	else if (a_Biome == biEnd)
 	{
-		addIfAllowed(cMonster::mtEnderman, allowedMobs);
+		addIfAllowed(mtEnderman, allowedMobs);
 	}
 	else
 	{
-		addIfAllowed(cMonster::mtBat, allowedMobs);
-		addIfAllowed(cMonster::mtSpider, allowedMobs);
-		addIfAllowed(cMonster::mtZombie, allowedMobs);
-		addIfAllowed(cMonster::mtSkeleton, allowedMobs);
-		addIfAllowed(cMonster::mtCreeper, allowedMobs);
-		addIfAllowed(cMonster::mtSquid, allowedMobs);
+		addIfAllowed(mtBat, allowedMobs);
+		addIfAllowed(mtSpider, allowedMobs);
+		addIfAllowed(mtZombie, allowedMobs);
+		addIfAllowed(mtSkeleton, allowedMobs);
+		addIfAllowed(mtCreeper, allowedMobs);
+		addIfAllowed(mtSquid, allowedMobs);
 		
 		if (a_Biome != biDesert && a_Biome != biBeach && a_Biome != biOcean)
 		{
-			addIfAllowed(cMonster::mtSheep, allowedMobs);
-			addIfAllowed(cMonster::mtPig, allowedMobs);
-			addIfAllowed(cMonster::mtCow, allowedMobs);
-			addIfAllowed(cMonster::mtChicken, allowedMobs);
-			addIfAllowed(cMonster::mtEnderman, allowedMobs);
-			addIfAllowed(cMonster::mtSlime, allowedMobs);  // MG TODO : much more complicated rule
+			addIfAllowed(mtSheep, allowedMobs);
+			addIfAllowed(mtPig, allowedMobs);
+			addIfAllowed(mtCow, allowedMobs);
+			addIfAllowed(mtChicken, allowedMobs);
+			addIfAllowed(mtEnderman, allowedMobs);
+			addIfAllowed(mtSlime, allowedMobs);  // MG TODO : much more complicated rule
 			
 			if (a_Biome == biForest || a_Biome == biForestHills || a_Biome == biTaiga  || a_Biome == biTaigaHills)
 			{
-				addIfAllowed(cMonster::mtWolf, allowedMobs);
+				addIfAllowed(mtWolf, allowedMobs);
 			}
 			else if (a_Biome == biJungle || a_Biome == biJungleHills)
 			{
-				addIfAllowed(cMonster::mtOcelot, allowedMobs);
+				addIfAllowed(mtOcelot, allowedMobs);
 			}
 		}
 	}
@@ -107,7 +107,7 @@ cMonster::eType cMobSpawner::ChooseMobType(EMCSBiome a_Biome)
 	size_t allowedMobsSize = allowedMobs.size();
 	if (allowedMobsSize > 0)
 	{
-		std::set<cMonster::eType>::iterator itr = allowedMobs.begin();
+		std::set<eMonsterType>::iterator itr = allowedMobs.begin();
 		int iRandom = m_Random.NextInt((int)allowedMobsSize, a_Biome);
 
 		for (int i = 0; i < iRandom; i++)
@@ -117,14 +117,14 @@ cMonster::eType cMobSpawner::ChooseMobType(EMCSBiome a_Biome)
 
 		return *itr;
 	}
-	return cMonster::mtInvalidType;
+	return mtInvalidType;
 }
 
 
 
 
 
-bool cMobSpawner::CanSpawnHere(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_RelZ, cMonster::eType a_MobType, EMCSBiome a_Biome)
+bool cMobSpawner::CanSpawnHere(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_RelZ, eMonsterType a_MobType, EMCSBiome a_Biome)
 {
 	cFastRandom Random;
 	BLOCKTYPE TargetBlock = E_BLOCK_AIR;
@@ -144,21 +144,21 @@ bool cMobSpawner::CanSpawnHere(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_R
 
 		switch (a_MobType)
 		{
-			case cMonster::mtSquid:
+			case mtSquid:
 			{
 				return IsBlockWater(TargetBlock) && (a_RelY >= 45) && (a_RelY <= 62);
 			}
 
-			case cMonster::mtBat:
+			case mtBat:
 			{
 				return (a_RelY <= 63) && (BlockLight <= 4) && (SkyLight <= 4) && (TargetBlock == E_BLOCK_AIR) && !cBlockInfo::IsTransparent(BlockAbove);
 			}
 
-			case cMonster::mtChicken:
-			case cMonster::mtCow:
-			case cMonster::mtPig:
-			case cMonster::mtHorse:
-			case cMonster::mtSheep:
+			case mtChicken:
+			case mtCow:
+			case mtPig:
+			case mtHorse:
+			case mtSheep:
 			{
 				return (
 					(TargetBlock == E_BLOCK_AIR) &&
@@ -169,7 +169,7 @@ bool cMobSpawner::CanSpawnHere(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_R
 				);
 			}
 				
-			case cMonster::mtOcelot:
+			case mtOcelot:
 			{
 				return (
 					(TargetBlock == E_BLOCK_AIR) &&
@@ -182,7 +182,7 @@ bool cMobSpawner::CanSpawnHere(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_R
 				);
 			}
 			
-			case cMonster::mtEnderman:
+			case mtEnderman:
 			{
 				if (a_RelY < 250)
 				{
@@ -203,7 +203,7 @@ bool cMobSpawner::CanSpawnHere(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_R
 				break;
 			}
 			
-			case cMonster::mtSpider:
+			case mtSpider:
 			{
 				bool CanSpawn = true;
 				bool HasFloor = false;
@@ -229,9 +229,9 @@ bool cMobSpawner::CanSpawnHere(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_R
 				return CanSpawn && HasFloor && (SkyLight <= 7) && (BlockLight <= 7);
 			}
 			
-			case cMonster::mtCreeper:
-			case cMonster::mtSkeleton:
-			case cMonster::mtZombie:
+			case mtCreeper:
+			case mtSkeleton:
+			case mtZombie:
 			{
 				return (
 					(TargetBlock == E_BLOCK_AIR) &&
@@ -243,8 +243,8 @@ bool cMobSpawner::CanSpawnHere(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_R
 				);
 			}
 
-			case cMonster::mtMagmaCube:
-			case cMonster::mtSlime:
+			case mtMagmaCube:
+			case mtSlime:
 			{
 				return (
 					(TargetBlock == E_BLOCK_AIR) &&
@@ -256,8 +256,8 @@ bool cMobSpawner::CanSpawnHere(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_R
 				);
 			}
 			
-			case cMonster::mtGhast:
-			case cMonster::mtZombiePigman:
+			case mtGhast:
+			case mtZombiePigman:
 			{
 				return (
 					(TargetBlock == E_BLOCK_AIR) &&
@@ -267,7 +267,7 @@ bool cMobSpawner::CanSpawnHere(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_R
 				);
 			}
 			
-			case cMonster::mtWolf:
+			case mtWolf:
 			{
 				return (
 					(TargetBlock == E_BLOCK_GRASS) &&
@@ -306,15 +306,15 @@ cMonster* cMobSpawner::TryToSpawnHere(cChunk * a_Chunk, int a_RelX, int a_RelY,
 	if (m_NewPack)
 	{
 		m_MobType = ChooseMobType(a_Biome);
-		if (m_MobType == cMonster::mtInvalidType)
+		if (m_MobType == mtInvalidType)
 		{
 			return toReturn;
 		}
-		if (m_MobType == cMonster::mtWolf)
+		if (m_MobType == mtWolf)
 		{
 			a_MaxPackSize = 8;
 		}
-		else if (m_MobType == cMonster::mtGhast)
+		else if (m_MobType == mtGhast)
 		{
 			a_MaxPackSize = 1;
 		}
diff --git a/src/MobSpawner.h b/src/MobSpawner.h
index e139f6923..3d2d4a6ce 100644
--- a/src/MobSpawner.h
+++ b/src/MobSpawner.h
@@ -30,7 +30,7 @@ public :
 	// a_AllowedTypes is the set of types allowed for mobs it will spawn. Empty set
 	// would result in no spawn at all
 	// Allowed mobs thah are not of the right Family will not be include (no warning)
-	cMobSpawner(cMonster::eFamily MobFamily, const std::set<cMonster::eType> & a_AllowedTypes);
+	cMobSpawner(cMonster::eFamily MobFamily, const std::set<eMonsterType> & a_AllowedTypes);
 
 	/// Check if specified block can be a Pack center for this spawner
 	bool CheckPackCenter(BLOCKTYPE a_BlockType);
@@ -55,19 +55,17 @@ public :
 	static bool CanSpawnHere(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_RelZ, cMonster::eType a_MobType, EMCSBiome a_Biome);
 
 protected :
-
 	// return a random type that can spawn on specified biome.
 	// returns E_ENTITY_TYPE_DONOTUSE if none is possible
-	cMonster::eType ChooseMobType(EMCSBiome a_Biome);
+	eMonsterType ChooseMobType(EMCSBiome a_Biome);
 
 	// add toAdd inside toAddIn, if toAdd is in m_AllowedTypes
-	void addIfAllowed(cMonster::eType toAdd, std::set<cMonster::eType> & toAddIn);
+	void addIfAllowed(eMonsterType toAdd, std::set<eMonsterType> & toAddIn);
 
-protected :
 	cMonster::eFamily m_MonsterFamily;
-	std::set<cMonster::eType> m_AllowedTypes;
+	std::set<eMonsterType> m_AllowedTypes;
 	bool m_NewPack;
-	cMonster::eType m_MobType;
+	eMonsterType m_MobType;
 	std::set<cMonster*> m_Spawned;
 	cFastRandom m_Random;
 } ;
diff --git a/src/Mobs/AggressiveMonster.cpp b/src/Mobs/AggressiveMonster.cpp
index 5f5b1853d..be2f71f7a 100644
--- a/src/Mobs/AggressiveMonster.cpp
+++ b/src/Mobs/AggressiveMonster.cpp
@@ -11,7 +11,7 @@
 
 
 
-cAggressiveMonster::cAggressiveMonster(const AString & a_ConfigName, eType a_MobType, const AString & a_SoundHurt, const AString & a_SoundDeath, double a_Width, double a_Height) :
+cAggressiveMonster::cAggressiveMonster(const AString & a_ConfigName, eMonsterType a_MobType, const AString & a_SoundHurt, const AString & a_SoundDeath, double a_Width, double a_Height) :
 	super(a_ConfigName, a_MobType, a_SoundHurt, a_SoundDeath, a_Width, a_Height)
 {
 	m_EMPersonality = AGGRESSIVE;
diff --git a/src/Mobs/AggressiveMonster.h b/src/Mobs/AggressiveMonster.h
index d70ff04a3..2549ba2d3 100644
--- a/src/Mobs/AggressiveMonster.h
+++ b/src/Mobs/AggressiveMonster.h
@@ -14,7 +14,7 @@ class cAggressiveMonster :
 	
 public:
 
-	cAggressiveMonster(const AString & a_ConfigName, eType a_MobType, const AString & a_SoundHurt, const AString & a_SoundDeath, double a_Width, double a_Height);
+	cAggressiveMonster(const AString & a_ConfigName, eMonsterType a_MobType, const AString & a_SoundHurt, const AString & a_SoundDeath, double a_Width, double a_Height);
 
 	virtual void Tick          (float a_Dt, cChunk & a_Chunk) override;
 	virtual void InStateChasing(float a_Dt) override;
diff --git a/src/Mobs/Monster.cpp b/src/Mobs/Monster.cpp
index 81acf1a93..12ca6bbbe 100644
--- a/src/Mobs/Monster.cpp
+++ b/src/Mobs/Monster.cpp
@@ -24,38 +24,38 @@ The strings need to be lowercase (for more efficient comparisons in StringToMobT
 */
 static const struct
 {
-	cMonster::eType m_Type;
+	eMonsterType m_Type;
 	const char * m_lcName;
 } g_MobTypeNames[] =
 {
-	{cMonster::mtBat,          "bat"},
-	{cMonster::mtBlaze,        "blaze"},
-	{cMonster::mtCaveSpider,   "cavespider"},
-	{cMonster::mtChicken,      "chicken"},
-	{cMonster::mtCow,          "cow"},
-	{cMonster::mtCreeper,      "creeper"},
-	{cMonster::mtEnderman,     "enderman"},
-	{cMonster::mtEnderDragon,  "enderdragon"},
-	{cMonster::mtGhast,        "ghast"},
-	{cMonster::mtHorse,        "horse"},
-	{cMonster::mtIronGolem,    "irongolem"},
-	{cMonster::mtMagmaCube,    "magmacube"},
-	{cMonster::mtMooshroom,    "mooshroom"},
-	{cMonster::mtOcelot,       "ocelot"},
-	{cMonster::mtPig,          "pig"},
-	{cMonster::mtSheep,        "sheep"},
-	{cMonster::mtSilverfish,   "silverfish"},
-	{cMonster::mtSkeleton,     "skeleton"},
-	{cMonster::mtSlime,        "slime"},
-	{cMonster::mtSnowGolem,    "snowgolem"},
-	{cMonster::mtSpider,       "spider"},
-	{cMonster::mtSquid,        "squid"},
-	{cMonster::mtVillager,     "villager"},
-	{cMonster::mtWitch,        "witch"},
-	{cMonster::mtWither,       "wither"},
-	{cMonster::mtWolf,         "wolf"},
-	{cMonster::mtZombie,       "zombie"},
-	{cMonster::mtZombiePigman, "zombiepigman"},
+	{mtBat,          "bat"},
+	{mtBlaze,        "blaze"},
+	{mtCaveSpider,   "cavespider"},
+	{mtChicken,      "chicken"},
+	{mtCow,          "cow"},
+	{mtCreeper,      "creeper"},
+	{mtEnderman,     "enderman"},
+	{mtEnderDragon,  "enderdragon"},
+	{mtGhast,        "ghast"},
+	{mtHorse,        "horse"},
+	{mtIronGolem,    "irongolem"},
+	{mtMagmaCube,    "magmacube"},
+	{mtMooshroom,    "mooshroom"},
+	{mtOcelot,       "ocelot"},
+	{mtPig,          "pig"},
+	{mtSheep,        "sheep"},
+	{mtSilverfish,   "silverfish"},
+	{mtSkeleton,     "skeleton"},
+	{mtSlime,        "slime"},
+	{mtSnowGolem,    "snowgolem"},
+	{mtSpider,       "spider"},
+	{mtSquid,        "squid"},
+	{mtVillager,     "villager"},
+	{mtWitch,        "witch"},
+	{mtWither,       "wither"},
+	{mtWolf,         "wolf"},
+	{mtZombie,       "zombie"},
+	{mtZombiePigman, "zombiepigman"},
 } ;
 
 
@@ -65,7 +65,7 @@ static const struct
 ////////////////////////////////////////////////////////////////////////////////
 // cMonster:
 
-cMonster::cMonster(const AString & a_ConfigName, eType a_MobType, const AString & a_SoundHurt, const AString & a_SoundDeath, double a_Width, double a_Height)
+cMonster::cMonster(const AString & a_ConfigName, eMonsterType a_MobType, const AString & a_SoundHurt, const AString & a_SoundDeath, double a_Width, double a_Height)
 	: super(etMonster, a_Width, a_Height)
 	, m_EMState(IDLE)
 	, m_EMPersonality(AGGRESSIVE)
@@ -75,6 +75,8 @@ cMonster::cMonster(const AString & a_ConfigName, eType a_MobType, const AString
 	, m_IdleInterval(0)
 	, m_DestroyTimer(0)
 	, m_MobType(a_MobType)
+	, m_CustomName("")
+	, m_CustomNameAlwaysVisible(false)
 	, m_SoundHurt(a_SoundHurt)
 	, m_SoundDeath(a_SoundDeath)
 	, m_AttackRate(3)
@@ -489,50 +491,50 @@ void cMonster::KilledBy(TakeDamageInfo & a_TDI)
 	switch (m_MobType)
 	{
 		// Animals
-		case cMonster::mtChicken:
-		case cMonster::mtCow:
-		case cMonster::mtHorse:
-		case cMonster::mtPig:
-		case cMonster::mtSheep:
-		case cMonster::mtSquid:
-		case cMonster::mtMooshroom:
-		case cMonster::mtOcelot:
-		case cMonster::mtWolf:
+		case mtChicken:
+		case mtCow:
+		case mtHorse:
+		case mtPig:
+		case mtSheep:
+		case mtSquid:
+		case mtMooshroom:
+		case mtOcelot:
+		case mtWolf:
 		{
 			Reward = m_World->GetTickRandomNumber(2) + 1;
 			break;
 		}
 
 		// Monsters
-		case cMonster::mtCaveSpider:
-		case cMonster::mtCreeper:
-		case cMonster::mtEnderman:
-		case cMonster::mtGhast:
-		case cMonster::mtSilverfish:
-		case cMonster::mtSkeleton:
-		case cMonster::mtSpider:
-		case cMonster::mtWitch:
-		case cMonster::mtZombie:
-		case cMonster::mtZombiePigman:
-		case cMonster::mtSlime:
-		case cMonster::mtMagmaCube:
+		case mtCaveSpider:
+		case mtCreeper:
+		case mtEnderman:
+		case mtGhast:
+		case mtSilverfish:
+		case mtSkeleton:
+		case mtSpider:
+		case mtWitch:
+		case mtZombie:
+		case mtZombiePigman:
+		case mtSlime:
+		case mtMagmaCube:
 		{
 			Reward = 6 + (m_World->GetTickRandomNumber(2));
 			break;
 		}
-		case cMonster::mtBlaze:
+		case mtBlaze:
 		{
 			Reward = 10;
 			break;
 		}
 
 		// Bosses
-		case cMonster::mtEnderDragon:
+		case mtEnderDragon:
 		{
 			Reward = 12000;
 			break;
 		}
-		case cMonster::mtWither:
+		case mtWither:
 		{
 			Reward = 50;
 			break;
@@ -555,6 +557,25 @@ void cMonster::KilledBy(TakeDamageInfo & a_TDI)
 
 
 
+void cMonster::OnRightClicked(cPlayer & a_Player)
+{
+	super::OnRightClicked(a_Player);
+
+	const cItem & EquippedItem = a_Player.GetEquippedItem();
+	if ((EquippedItem.m_ItemType == E_ITEM_NAME_TAG) && !EquippedItem.m_CustomName.empty())
+	{
+		SetCustomName(EquippedItem.m_CustomName);
+		if (!a_Player.IsGameModeCreative())
+		{
+			a_Player.GetInventory().RemoveOneEquippedItem();
+		}
+	}
+}
+
+
+
+
+
 // Checks to see if EventSeePlayer should be fired
 // monster sez: Do I see the player
 void cMonster::CheckEventSeePlayer(void)
@@ -683,6 +704,39 @@ void cMonster::InStateEscaping(float a_Dt)
 
 
 
+void cMonster::SetCustomName(const AString & a_CustomName)
+{
+	m_CustomName = a_CustomName;
+
+	// The maximal length is 64
+	if (a_CustomName.length() > 64)
+	{
+		m_CustomName = a_CustomName.substr(0, 64);
+	}
+
+	if (m_World != NULL)
+	{
+		m_World->BroadcastEntityMetadata(*this);
+	}
+}
+
+
+
+
+
+void cMonster::SetCustomNameAlwaysVisible(bool a_CustomNameAlwaysVisible)
+{
+	m_CustomNameAlwaysVisible = a_CustomNameAlwaysVisible;
+	if (m_World != NULL)
+	{
+		m_World->BroadcastEntityMetadata(*this);
+	}
+}
+
+
+
+
+
 void cMonster::GetMonsterConfig(const AString & a_Name)
 {
 	cRoot::Get()->GetMonsterConfig()->AssignAttributes(this, a_Name);
@@ -701,7 +755,7 @@ bool cMonster::IsUndead(void)
 
 
 
-AString cMonster::MobTypeToString(cMonster::eType a_MobType)
+AString cMonster::MobTypeToString(eMonsterType a_MobType)
 {
 	// Mob types aren't sorted, so we need to search linearly:
 	for (size_t i = 0; i < ARRAYCOUNT(g_MobTypeNames); i++)
@@ -720,7 +774,7 @@ AString cMonster::MobTypeToString(cMonster::eType a_MobType)
 
 
 
-cMonster::eType cMonster::StringToMobType(const AString & a_Name)
+eMonsterType cMonster::StringToMobType(const AString & a_Name)
 {
 	AString lcName = StrToLower(a_Name);
 	
@@ -761,7 +815,7 @@ cMonster::eType cMonster::StringToMobType(const AString & a_Name)
 
 
 
-cMonster::eFamily cMonster::FamilyFromType(eType a_Type)
+cMonster::eFamily cMonster::FamilyFromType(eMonsterType a_Type)
 {
 	// Passive-agressive mobs are counted in mob spawning code as passive
 
@@ -826,7 +880,7 @@ int cMonster::GetSpawnDelay(cMonster::eFamily a_MobFamily)
 
 
 
-cMonster * cMonster::NewMonsterFromType(cMonster::eType a_MobType)
+cMonster * cMonster::NewMonsterFromType(eMonsterType a_MobType)
 {
 	cFastRandom Random;
 	cMonster * toReturn = NULL;
diff --git a/src/Mobs/Monster.h b/src/Mobs/Monster.h
index 86c882d47..0fa620b3a 100644
--- a/src/Mobs/Monster.h
+++ b/src/Mobs/Monster.h
@@ -6,6 +6,7 @@
 #include "../BlockID.h"
 #include "../Item.h"
 #include "../Enchantments.h"
+#include "MonsterTypes.h"
 
 
 
@@ -23,41 +24,9 @@ class cMonster :
 {
 	typedef cPawn super;
 public:
-	/// This identifies individual monster type, as well as their network type-ID
-	enum eType
-	{
-		mtInvalidType = -1,
-		
-		mtBat          = E_META_SPAWN_EGG_BAT,
-		mtBlaze        = E_META_SPAWN_EGG_BLAZE,
-		mtCaveSpider   = E_META_SPAWN_EGG_CAVE_SPIDER,
-		mtChicken      = E_META_SPAWN_EGG_CHICKEN,
-		mtCow          = E_META_SPAWN_EGG_COW,
-		mtCreeper      = E_META_SPAWN_EGG_CREEPER,
-		mtEnderDragon  = E_META_SPAWN_EGG_ENDER_DRAGON,
-		mtEnderman     = E_META_SPAWN_EGG_ENDERMAN,
-		mtGhast        = E_META_SPAWN_EGG_GHAST,
-		mtGiant        = E_META_SPAWN_EGG_GIANT,
-		mtHorse        = E_META_SPAWN_EGG_HORSE,
-		mtIronGolem    = E_META_SPAWN_EGG_IRON_GOLEM,
-		mtMagmaCube    = E_META_SPAWN_EGG_MAGMA_CUBE,
-		mtMooshroom    = E_META_SPAWN_EGG_MOOSHROOM,
-		mtOcelot       = E_META_SPAWN_EGG_OCELOT,
-		mtPig          = E_META_SPAWN_EGG_PIG,
-		mtSheep        = E_META_SPAWN_EGG_SHEEP,
-		mtSilverfish   = E_META_SPAWN_EGG_SILVERFISH,
-		mtSkeleton     = E_META_SPAWN_EGG_SKELETON,
-		mtSlime        = E_META_SPAWN_EGG_SLIME,
-		mtSnowGolem    = E_META_SPAWN_EGG_SNOW_GOLEM,
-		mtSpider       = E_META_SPAWN_EGG_SPIDER,
-		mtSquid        = E_META_SPAWN_EGG_SQUID,
-		mtVillager     = E_META_SPAWN_EGG_VILLAGER,
-		mtWitch        = E_META_SPAWN_EGG_WITCH,
-		mtWither       = E_META_SPAWN_EGG_WITHER,
-		mtWolf         = E_META_SPAWN_EGG_WOLF,
-		mtZombie       = E_META_SPAWN_EGG_ZOMBIE,
-		mtZombiePigman = E_META_SPAWN_EGG_ZOMBIE_PIGMAN,
-	} ;
+
+	//Depreciated
+	typedef eMonsterType eType;
 
 	enum eFamily
 	{
@@ -80,7 +49,7 @@ public:
 	a_MobType is the type of the mob (also used in the protocol ( http://wiki.vg/Entities#Mobs 2012_12_22))
 	a_SoundHurt and a_SoundDeath are assigned into m_SoundHurt and m_SoundDeath, respectively
 	*/
-	cMonster(const AString & a_ConfigName, eType a_MobType, const AString & a_SoundHurt, const AString & a_SoundDeath, double a_Width, double a_Height);
+	cMonster(const AString & a_ConfigName, eMonsterType a_MobType, const AString & a_SoundHurt, const AString & a_SoundDeath, double a_Width, double a_Height);
 
 	CLASS_PROTODEF(cMonster)
 	
@@ -92,11 +61,13 @@ public:
 	
 	virtual void KilledBy(TakeDamageInfo & a_TDI) override;
 
+	virtual void OnRightClicked(cPlayer & a_Player) override;
+
 	virtual void MoveToPosition(const Vector3d & a_Position);  // tolua_export
 	virtual bool ReachedDestination(void);
 	
 	// tolua_begin
-	eType GetMobType(void) const { return m_MobType; }
+	eMonsterType GetMobType(void) const { return m_MobType; }
 	eFamily GetMobFamily(void) const;
 	// tolua_end
 	
@@ -147,15 +118,32 @@ public:
 	virtual bool IsSitting (void) const { return false; }
 	
 	// tolua_begin
-	
+
+	/** Returns true if the monster has a custom name. */
+	bool HasCustomName(void) const { return !m_CustomName.empty(); }
+
+	/** Gets the custom name of the monster. If no custom name is set, the function returns an empty string. */
+	const AString & GetCustomName(void) const { return m_CustomName; }
+
+	/** Sets the custom name of the monster. You see the name over the monster.
+	If you want to disable the custom name, simply set an empty string. */
+	void SetCustomName(const AString & a_CustomName);
+
+	/** Is the custom name of this monster always visible? If not, you only see the name when you sight the mob. */
+	bool IsCustomNameAlwaysVisible(void) const { return m_CustomNameAlwaysVisible; }
+
+	/** Sets the custom name visiblity of this monster.
+	If it's false, you only see the name when you sight the mob. If it's true, you always see the custom name. */
+	void SetCustomNameAlwaysVisible(bool a_CustomNameAlwaysVisible);
+
 	/// Translates MobType enum to a string, empty string if unknown
-	static AString MobTypeToString(eType a_MobType);
+	static AString MobTypeToString(eMonsterType a_MobType);
 	
 	/// Translates MobType string to the enum, mtInvalidType if not recognized
-	static eType StringToMobType(const AString & a_MobTypeName);
+	static eMonsterType StringToMobType(const AString & a_MobTypeName);
 	
 	/// Returns the mob family based on the type
-	static eFamily FamilyFromType(eType a_MobType);
+	static eFamily FamilyFromType(eMonsterType a_MobType);
 
 	/// Returns the spawn delay (number of game ticks between spawn attempts) for the given mob family
 	static int GetSpawnDelay(cMonster::eFamily a_MobFamily);
@@ -166,7 +154,7 @@ public:
 	a_MobType is the type of the mob to be created
 	Asserts and returns null if mob type is not specified
 	*/
-	static cMonster * NewMonsterFromType(eType a_MobType);
+	static cMonster * NewMonsterFromType(eMonsterType a_MobType);
 
 protected:
 	
@@ -230,7 +218,9 @@ protected:
 	float m_IdleInterval;
 	float m_DestroyTimer;
 
-	eType m_MobType;
+	eMonsterType m_MobType;
+	AString m_CustomName;
+	bool m_CustomNameAlwaysVisible;
 
 	AString m_SoundHurt;
 	AString m_SoundDeath;
diff --git a/src/Mobs/MonsterTypes.h b/src/Mobs/MonsterTypes.h
new file mode 100644
index 000000000..7a73e99f4
--- /dev/null
+++ b/src/Mobs/MonsterTypes.h
@@ -0,0 +1,41 @@
+
+#pragma once
+
+/// This identifies individual monster type, as well as their network type-ID
+// tolua_begin
+enum eMonsterType
+{
+	mtInvalidType = -1,
+	
+	mtBat          = E_META_SPAWN_EGG_BAT,
+	mtBlaze        = E_META_SPAWN_EGG_BLAZE,
+	mtCaveSpider   = E_META_SPAWN_EGG_CAVE_SPIDER,
+	mtChicken      = E_META_SPAWN_EGG_CHICKEN,
+	mtCow          = E_META_SPAWN_EGG_COW,
+	mtCreeper      = E_META_SPAWN_EGG_CREEPER,
+	mtEnderDragon  = E_META_SPAWN_EGG_ENDER_DRAGON,
+	mtEnderman     = E_META_SPAWN_EGG_ENDERMAN,
+	mtGhast        = E_META_SPAWN_EGG_GHAST,
+	mtGiant        = E_META_SPAWN_EGG_GIANT,
+	mtHorse        = E_META_SPAWN_EGG_HORSE,
+	mtIronGolem    = E_META_SPAWN_EGG_IRON_GOLEM,
+	mtMagmaCube    = E_META_SPAWN_EGG_MAGMA_CUBE,
+	mtMooshroom    = E_META_SPAWN_EGG_MOOSHROOM,
+	mtOcelot       = E_META_SPAWN_EGG_OCELOT,
+	mtPig          = E_META_SPAWN_EGG_PIG,
+	mtSheep        = E_META_SPAWN_EGG_SHEEP,
+	mtSilverfish   = E_META_SPAWN_EGG_SILVERFISH,
+	mtSkeleton     = E_META_SPAWN_EGG_SKELETON,
+	mtSlime        = E_META_SPAWN_EGG_SLIME,
+	mtSnowGolem    = E_META_SPAWN_EGG_SNOW_GOLEM,
+	mtSpider       = E_META_SPAWN_EGG_SPIDER,
+	mtSquid        = E_META_SPAWN_EGG_SQUID,
+	mtVillager     = E_META_SPAWN_EGG_VILLAGER,
+	mtWitch        = E_META_SPAWN_EGG_WITCH,
+	mtWither       = E_META_SPAWN_EGG_WITHER,
+	mtWolf         = E_META_SPAWN_EGG_WOLF,
+	mtZombie       = E_META_SPAWN_EGG_ZOMBIE,
+	mtZombiePigman = E_META_SPAWN_EGG_ZOMBIE_PIGMAN,
+} ;
+// tolua_end
+
diff --git a/src/Mobs/Mooshroom.cpp b/src/Mobs/Mooshroom.cpp
index 81bd3e3b4..99958720f 100644
--- a/src/Mobs/Mooshroom.cpp
+++ b/src/Mobs/Mooshroom.cpp
@@ -67,7 +67,7 @@ void cMooshroom::OnRightClicked(cPlayer & a_Player)
 			cItems Drops;
 			Drops.push_back(cItem(E_BLOCK_RED_MUSHROOM, 5, 0));
 			m_World->SpawnItemPickups(Drops, GetPosX(), GetPosY(), GetPosZ(), 10);
-			m_World->SpawnMob(GetPosX(), GetPosY(), GetPosZ(), cMonster::mtCow);
+			m_World->SpawnMob(GetPosX(), GetPosY(), GetPosZ(), mtCow);
 			Destroy();
 		} break;
 	}
diff --git a/src/Mobs/PassiveAggressiveMonster.cpp b/src/Mobs/PassiveAggressiveMonster.cpp
index 24501b1ba..e0cc2fd21 100644
--- a/src/Mobs/PassiveAggressiveMonster.cpp
+++ b/src/Mobs/PassiveAggressiveMonster.cpp
@@ -9,7 +9,7 @@
 
 
 
-cPassiveAggressiveMonster::cPassiveAggressiveMonster(const AString & a_ConfigName, eType a_MobType, const AString & a_SoundHurt, const AString & a_SoundDeath, double a_Width, double a_Height) :
+cPassiveAggressiveMonster::cPassiveAggressiveMonster(const AString & a_ConfigName, eMonsterType a_MobType, const AString & a_SoundHurt, const AString & a_SoundDeath, double a_Width, double a_Height) :
 	super(a_ConfigName, a_MobType, a_SoundHurt, a_SoundDeath, a_Width, a_Height)
 {
 	m_EMPersonality = PASSIVE;
diff --git a/src/Mobs/PassiveAggressiveMonster.h b/src/Mobs/PassiveAggressiveMonster.h
index a0da50e8e..72f472281 100644
--- a/src/Mobs/PassiveAggressiveMonster.h
+++ b/src/Mobs/PassiveAggressiveMonster.h
@@ -13,7 +13,7 @@ class cPassiveAggressiveMonster :
 	typedef cAggressiveMonster super;
 	
 public:
-	cPassiveAggressiveMonster(const AString & a_ConfigName, eType a_MobType, const AString & a_SoundHurt, const AString & a_SoundDeath, double a_Width, double a_Height);
+	cPassiveAggressiveMonster(const AString & a_ConfigName, eMonsterType a_MobType, const AString & a_SoundHurt, const AString & a_SoundDeath, double a_Width, double a_Height);
 
 	virtual bool DoTakeDamage(TakeDamageInfo & a_TDI) override;
 } ;
diff --git a/src/Mobs/PassiveMonster.cpp b/src/Mobs/PassiveMonster.cpp
index 2861d7314..be3043e3d 100644
--- a/src/Mobs/PassiveMonster.cpp
+++ b/src/Mobs/PassiveMonster.cpp
@@ -8,7 +8,7 @@
 
 
 
-cPassiveMonster::cPassiveMonster(const AString & a_ConfigName, eType a_MobType, const AString & a_SoundHurt, const AString & a_SoundDeath, double a_Width, double a_Height) :
+cPassiveMonster::cPassiveMonster(const AString & a_ConfigName, eMonsterType a_MobType, const AString & a_SoundHurt, const AString & a_SoundDeath, double a_Width, double a_Height) :
 	super(a_ConfigName, a_MobType, a_SoundHurt, a_SoundDeath, a_Width, a_Height)
 {
 	m_EMPersonality = PASSIVE;
diff --git a/src/Mobs/PassiveMonster.h b/src/Mobs/PassiveMonster.h
index 70574585a..9221d9a6e 100644
--- a/src/Mobs/PassiveMonster.h
+++ b/src/Mobs/PassiveMonster.h
@@ -13,7 +13,7 @@ class cPassiveMonster :
 	typedef cMonster super;
 	
 public:
-	cPassiveMonster(const AString & a_ConfigName, eType a_MobType, const AString & a_SoundHurt, const AString & a_SoundDeath, double a_Width, double a_Height);
+	cPassiveMonster(const AString & a_ConfigName, eMonsterType a_MobType, const AString & a_SoundHurt, const AString & a_SoundDeath, double a_Width, double a_Height);
 
 	virtual void Tick(float a_Dt, cChunk & a_Chunk) override;
 
diff --git a/src/Mobs/Sheep.cpp b/src/Mobs/Sheep.cpp
index 1a82115d2..cbb33cb90 100644
--- a/src/Mobs/Sheep.cpp
+++ b/src/Mobs/Sheep.cpp
@@ -45,7 +45,7 @@ void cSheep::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 	{
 		LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting);
 	}
-	AddRandomDropItem(a_Drops, 1, 3 + LootingLevel, IsOnFire() ? E_ITEM_MUTTON : E_ITEM_RAW_MUTTON);
+	AddRandomDropItem(a_Drops, 1, 3 + LootingLevel, IsOnFire() ? E_ITEM_COOKED_MUTTON : E_ITEM_RAW_MUTTON);
 }
 
 
@@ -54,6 +54,8 @@ void cSheep::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 
 void cSheep::OnRightClicked(cPlayer & a_Player)
 {
+	super::OnRightClicked(a_Player);
+
 	const cItem & EquippedItem = a_Player.GetEquippedItem();
 	if ((EquippedItem.m_ItemType == E_ITEM_SHEARS) && !IsSheared() && !IsBaby())
 	{
diff --git a/src/Mobs/Villager.cpp b/src/Mobs/Villager.cpp
index 1cdac7c74..0efd5501e 100644
--- a/src/Mobs/Villager.cpp
+++ b/src/Mobs/Villager.cpp
@@ -109,11 +109,11 @@ void cVillager::HandleFarmerPrepareFarmCrops()
 	Surrounding.Read(
 		m_World,
 		(int) GetPosX() - 5,
-		(int) GetPosX() + 5,
+		(int) GetPosX() + 6,
 		(int) GetPosY() - 3,
-		(int) GetPosY() + 3,
+		(int) GetPosY() + 4,
 		(int) GetPosZ() - 5,
-		(int) GetPosZ() + 5
+		(int) GetPosZ() + 6
 	);
 
 	for (int I = 0; I < 5; I++)
diff --git a/src/Mobs/Villager.h b/src/Mobs/Villager.h
index aa81f0790..d3a38dbf0 100644
--- a/src/Mobs/Villager.h
+++ b/src/Mobs/Villager.h
@@ -2,7 +2,7 @@
 #pragma once
 
 #include "PassiveMonster.h"
-
+#include "Blocks/ChunkInterface.h"
 
 
 
diff --git a/src/Protocol/CMakeLists.txt b/src/Protocol/CMakeLists.txt
index 1ba66ff1f..5426c58fa 100644
--- a/src/Protocol/CMakeLists.txt
+++ b/src/Protocol/CMakeLists.txt
@@ -14,6 +14,7 @@ SET (SRCS
 	Protocol15x.cpp
 	Protocol16x.cpp
 	Protocol17x.cpp
+	Protocol18x.cpp
 	ProtocolRecognizer.cpp)
 
 SET (HDRS
@@ -27,6 +28,7 @@ SET (HDRS
 	Protocol15x.h
 	Protocol16x.h
 	Protocol17x.h
+	Protocol18x.h
 	ProtocolRecognizer.h)
 
 if(NOT MSVC)
diff --git a/src/Protocol/ChunkDataSerializer.cpp b/src/Protocol/ChunkDataSerializer.cpp
index ebe61631b..5d080656d 100644
--- a/src/Protocol/ChunkDataSerializer.cpp
+++ b/src/Protocol/ChunkDataSerializer.cpp
@@ -8,6 +8,8 @@
 #include "Globals.h"
 #include "ChunkDataSerializer.h"
 #include "zlib/zlib.h"
+#include "ByteBuffer.h"
+#include "Protocol18x.h"
 
 
 
@@ -30,7 +32,7 @@ cChunkDataSerializer::cChunkDataSerializer(
 
 
 
-const AString & cChunkDataSerializer::Serialize(int a_Version)
+const AString & cChunkDataSerializer::Serialize(int a_Version, int a_ChunkX, int a_ChunkZ)
 {
 	Serializations::const_iterator itr = m_Serializations.find(a_Version);
 	if (itr != m_Serializations.end())
@@ -43,6 +45,7 @@ const AString & cChunkDataSerializer::Serialize(int a_Version)
 	{
 		case RELEASE_1_2_5: Serialize29(data); break;
 		case RELEASE_1_3_2: Serialize39(data); break;
+		case RELEASE_1_8_0: Serialize47(data, a_ChunkX, a_ChunkZ); break;
 		// TODO: Other protocol versions may serialize the data differently; implement here
 		
 		default:
@@ -52,7 +55,10 @@ const AString & cChunkDataSerializer::Serialize(int a_Version)
 			break;
 		}
 	}
-	m_Serializations[a_Version] = data;
+	if (!data.empty())
+	{
+		m_Serializations[a_Version] = data;
+	}
 	return m_Serializations[a_Version];
 }
 
@@ -174,3 +180,72 @@ void cChunkDataSerializer::Serialize39(AString & a_Data)
 
 
 
+
+void cChunkDataSerializer::Serialize47(AString & a_Data, int a_ChunkX, int a_ChunkZ)
+{
+	// This function returns the fully compressed packet (including packet size), not the raw packet!
+
+	// Create the packet:
+	cByteBuffer Packet(512 KiB);
+	Packet.WriteVarInt(0x21);  // Packet id (Chunk Data packet)
+	Packet.WriteBEInt(a_ChunkX);
+	Packet.WriteBEInt(a_ChunkZ);
+	Packet.WriteBool(true);  // "Ground-up continuous", or rather, "biome data present" flag
+	Packet.WriteBEUShort(0xffff);  // We're aways sending the full chunk with no additional data, so the bitmap is 0xffff
+
+	// Write the chunk size:
+	const int BiomeDataSize = cChunkDef::Width * cChunkDef::Width;
+	UInt32 ChunkSize = (
+		(cChunkDef::NumBlocks * 2) +  // Block meta + type
+		sizeof(m_BlockLight) +        // Block light
+		sizeof(m_BlockSkyLight) +     // Block sky light
+		BiomeDataSize                 // Biome data
+	);
+	Packet.WriteVarInt(ChunkSize);
+
+	// Write the block types to the packet:
+	for (size_t Index = 0; Index < cChunkDef::NumBlocks; Index++)
+	{
+		BLOCKTYPE BlockType = m_BlockTypes[Index] & 0xFF;
+		NIBBLETYPE BlockMeta = m_BlockMetas[Index / 2] >> ((Index & 1) * 4) & 0x0f;
+		Packet.WriteByte((unsigned char)(BlockType << 4) | BlockMeta);
+		Packet.WriteByte((unsigned char)(BlockType >> 4));
+	}
+
+	// Write the rest:
+	Packet.WriteBuf(m_BlockLight,    sizeof(m_BlockLight));
+	Packet.WriteBuf(m_BlockSkyLight, sizeof(m_BlockSkyLight));
+	Packet.WriteBuf(m_BiomeData,     BiomeDataSize);
+
+	AString PacketData;
+	Packet.ReadAll(PacketData);
+	Packet.CommitRead();
+
+	cByteBuffer Buffer(20);
+	if (PacketData.size() >= 256)
+	{
+		if (!cProtocol180::CompressPacket(PacketData, a_Data))
+		{
+			ASSERT(!"Packet compression failed.");
+			a_Data.clear();
+			return;
+		}
+	}
+	else
+	{
+		AString PostData;
+		Buffer.WriteVarInt((UInt32)Packet.GetUsedSpace() + 1);
+		Buffer.WriteVarInt(0);
+		Buffer.ReadAll(PostData);
+		Buffer.CommitRead();
+
+		a_Data.clear();
+		a_Data.reserve(PostData.size() + PacketData.size());
+		a_Data.append(PostData.data(), PostData.size());
+		a_Data.append(PacketData.data(), PacketData.size());
+	}
+}
+
+
+
+
diff --git a/src/Protocol/ChunkDataSerializer.h b/src/Protocol/ChunkDataSerializer.h
index a42856356..a082ef3d8 100644
--- a/src/Protocol/ChunkDataSerializer.h
+++ b/src/Protocol/ChunkDataSerializer.h
@@ -23,13 +23,15 @@ protected:
 	Serializations m_Serializations;
 	
 	void Serialize29(AString & a_Data);  // Release 1.2.4 and 1.2.5
-	void Serialize39(AString & a_Data);  // Release 1.3.1 and 1.3.2
+	void Serialize39(AString & a_Data);  // Release 1.3.1 to 1.7.10
+	void Serialize47(AString & a_Data, int a_ChunkX, int a_ChunkZ);  // Release 1.8
 	
 public:
 	enum
 	{
 		RELEASE_1_2_5 = 29,
 		RELEASE_1_3_2 = 39,
+		RELEASE_1_8_0 = 47,
 	} ;
 	
 	cChunkDataSerializer(
@@ -40,7 +42,7 @@ public:
 		const unsigned char *           a_BiomeData
 	);
 
-	const AString & Serialize(int a_Version);  // Returns one of the internal m_Serializations[]
+	const AString & Serialize(int a_Version, int a_ChunkX, int a_ChunkZ);  // Returns one of the internal m_Serializations[]
 } ;
 
 
diff --git a/src/Protocol/Protocol.h b/src/Protocol/Protocol.h
index 8e1842ec1..b2ee92918 100644
--- a/src/Protocol/Protocol.h
+++ b/src/Protocol/Protocol.h
@@ -50,82 +50,87 @@ public:
 		m_Client(a_Client)
 	{
 	}
+
 	virtual ~cProtocol() {}
 	
 	/// Called when client sends some data
 	virtual void DataReceived(const char * a_Data, size_t a_Size) = 0;
 	
 	// Sending stuff to clients (alphabetically sorted):
-	virtual void SendAttachEntity        (const cEntity & a_Entity, const cEntity * a_Vehicle) = 0;
-	virtual void SendBlockAction         (int a_BlockX, int a_BlockY, int a_BlockZ, char a_Byte1, char a_Byte2, BLOCKTYPE a_BlockType) = 0;
-	virtual void SendBlockBreakAnim      (int a_EntityID, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Stage) = 0;
-	virtual void SendBlockChange         (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) = 0;
-	virtual void SendBlockChanges        (int a_ChunkX, int a_ChunkZ, const sSetBlockVector & a_Changes) = 0;
-	virtual void SendChat                (const AString & a_Message) = 0;
-	virtual void SendChat                (const cCompositeChat & a_Message) = 0;
-	virtual void SendChunkData           (int a_ChunkX, int a_ChunkZ, cChunkDataSerializer & a_Serializer) = 0;
-	virtual void SendCollectEntity       (const cEntity & a_Entity, const cPlayer & a_Player) = 0;
-	virtual void SendDestroyEntity       (const cEntity & a_Entity) = 0;
-	virtual void SendDisconnect          (const AString & a_Reason) = 0;
-	virtual void SendEditSign            (int a_BlockX, int a_BlockY, int a_BlockZ) = 0;  ///< Request the client to open up the sign editor for the sign (1.6+)
-	virtual void SendEntityEffect        (const cEntity & a_Entity, int a_EffectID, int a_Amplifier, short a_Duration) = 0;
-	virtual void SendEntityEquipment     (const cEntity & a_Entity, short a_SlotNum, const cItem & a_Item) = 0;
-	virtual void SendEntityHeadLook      (const cEntity & a_Entity) = 0;
-	virtual void SendEntityLook          (const cEntity & a_Entity) = 0;
-	virtual void SendEntityMetadata      (const cEntity & a_Entity) = 0;
-	virtual void SendEntityProperties    (const cEntity & a_Entity) = 0;
-	virtual void SendEntityRelMove       (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ) = 0;
-	virtual void SendEntityRelMoveLook   (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ) = 0;
-	virtual void SendEntityStatus        (const cEntity & a_Entity, char a_Status) = 0;
-	virtual void SendEntityVelocity      (const cEntity & a_Entity) = 0;
-	virtual void SendExplosion           (double a_BlockX, double a_BlockY, double a_BlockZ, float a_Radius, const cVector3iArray & a_BlocksAffected, const Vector3d & a_PlayerMotion) = 0;
-	virtual void SendGameMode            (eGameMode a_GameMode) = 0;
-	virtual void SendHealth              (void) = 0;
-	virtual void SendInventorySlot       (char a_WindowID, short a_SlotNum, const cItem & a_Item) = 0;
-	virtual void SendKeepAlive           (int a_PingID) = 0;
-	virtual void SendLogin               (const cPlayer & a_Player, const cWorld & a_World) = 0;
-	virtual void SendLoginSuccess        (void) = 0;
-	virtual void SendMapColumn           (int a_ID, int a_X, int a_Y, const Byte * a_Colors, unsigned int a_Length) = 0;
-	virtual void SendMapDecorators       (int a_ID, const cMapDecoratorList & a_Decorators) = 0;
-	virtual void SendMapInfo             (int a_ID, unsigned int a_Scale) = 0;
-	virtual void SendPaintingSpawn       (const cPainting & a_Painting) = 0;
-	virtual void SendPickupSpawn         (const cPickup & a_Pickup) = 0;
-	virtual void SendPlayerAbilities     (void) = 0;
-	virtual void SendEntityAnimation     (const cEntity & a_Entity, char a_Animation) = 0;
-	virtual void SendParticleEffect      (const AString & a_SoundName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmmount) = 0;
-	virtual void SendPlayerListItem      (const cPlayer & a_Player, bool a_IsOnline) = 0;
-	virtual void SendPlayerMaxSpeed      (void) = 0;  ///< Informs the client of the maximum player speed (1.6.1+)
-	virtual void SendPlayerMoveLook      (void) = 0;
-	virtual void SendPlayerPosition      (void) = 0;
-	virtual void SendPlayerSpawn         (const cPlayer & a_Player) = 0;
-	virtual void SendPluginMessage       (const AString & a_Channel, const AString & a_Message) = 0;
-	virtual void SendRemoveEntityEffect  (const cEntity & a_Entity, int a_EffectID) = 0;
-	virtual void SendRespawn             (eDimension a_Dimension, bool a_ShouldIgnoreDimensionChecks) = 0;
-	virtual void SendExperience          (void) = 0;
-	virtual void SendExperienceOrb       (const cExpOrb & a_ExpOrb) = 0;
-	virtual void SendScoreboardObjective (const AString & a_Name, const AString & a_DisplayName, Byte a_Mode) = 0;
-	virtual void SendScoreUpdate         (const AString & a_Objective, const AString & a_Player, cObjective::Score a_Score, Byte a_Mode) = 0;
-	virtual void SendDisplayObjective    (const AString & a_Objective, cScoreboard::eDisplaySlot a_Display) = 0;
-	virtual void SendSoundEffect         (const AString & a_SoundName, double a_X, double a_Y, double a_Z, float a_Volume, float a_Pitch) = 0;
-	virtual void SendSoundParticleEffect (int a_EffectID, int a_SrcX, int a_SrcY, int a_SrcZ, int a_Data) = 0;
-	virtual void SendSpawnFallingBlock   (const cFallingBlock & a_FallingBlock) = 0;
-	virtual void SendSpawnMob            (const cMonster & a_Mob) = 0;
-	virtual void SendSpawnObject         (const cEntity & a_Entity, char a_ObjectType, int a_ObjectData, Byte a_Yaw, Byte a_Pitch) = 0;
-	virtual void SendSpawnVehicle        (const cEntity & a_Vehicle, char a_VehicleType, char a_VehicleSubType) = 0;
-	virtual void SendStatistics          (const cStatManager & a_Manager) = 0;
-	virtual void SendTabCompletionResults(const AStringVector & a_Results) = 0;
-	virtual void SendTeleportEntity      (const cEntity & a_Entity) = 0;
-	virtual void SendThunderbolt         (int a_BlockX, int a_BlockY, int a_BlockZ) = 0;
-	virtual void SendTimeUpdate          (Int64 a_WorldAge, Int64 a_TimeOfDay, bool a_DoDaylightCycle) = 0;
-	virtual void SendUnloadChunk         (int a_ChunkX, int a_ChunkZ) = 0;
-	virtual void SendUpdateBlockEntity   (cBlockEntity & a_BlockEntity) = 0;
-	virtual void SendUpdateSign          (int a_BlockX, int a_BlockY, int a_BlockZ, const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4) = 0;
-	virtual void SendUseBed              (const cEntity & a_Entity, int a_BlockX, int a_BlockY, int a_BlockZ) = 0;
-	virtual void SendWeather             (eWeather a_Weather) = 0;
-	virtual void SendWholeInventory      (const cWindow    & a_Window) = 0;
-	virtual void SendWindowClose         (const cWindow    & a_Window) = 0;
-	virtual void SendWindowOpen          (const cWindow & a_Window) = 0;
-	virtual void SendWindowProperty      (const cWindow & a_Window, int a_Property, int a_Value) = 0;
+	virtual void SendAttachEntity               (const cEntity & a_Entity, const cEntity * a_Vehicle) = 0;
+	virtual void SendBlockAction                (int a_BlockX, int a_BlockY, int a_BlockZ, char a_Byte1, char a_Byte2, BLOCKTYPE a_BlockType) = 0;
+	virtual void SendBlockBreakAnim             (int a_EntityID, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Stage) = 0;
+	virtual void SendBlockChange                (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) = 0;
+	virtual void SendBlockChanges               (int a_ChunkX, int a_ChunkZ, const sSetBlockVector & a_Changes) = 0;
+	virtual void SendChat                       (const AString & a_Message) = 0;
+	virtual void SendChat                       (const cCompositeChat & a_Message) = 0;
+	virtual void SendChunkData                  (int a_ChunkX, int a_ChunkZ, cChunkDataSerializer & a_Serializer) = 0;
+	virtual void SendCollectEntity              (const cEntity & a_Entity, const cPlayer & a_Player) = 0;
+	virtual void SendDestroyEntity              (const cEntity & a_Entity) = 0;
+	virtual void SendDisconnect                 (const AString & a_Reason) = 0;
+	virtual void SendEditSign                   (int a_BlockX, int a_BlockY, int a_BlockZ) = 0;  ///< Request the client to open up the sign editor for the sign (1.6+)
+	virtual void SendEntityEffect               (const cEntity & a_Entity, int a_EffectID, int a_Amplifier, short a_Duration) = 0;
+	virtual void SendEntityEquipment            (const cEntity & a_Entity, short a_SlotNum, const cItem & a_Item) = 0;
+	virtual void SendEntityHeadLook             (const cEntity & a_Entity) = 0;
+	virtual void SendEntityLook                 (const cEntity & a_Entity) = 0;
+	virtual void SendEntityMetadata             (const cEntity & a_Entity) = 0;
+	virtual void SendEntityProperties           (const cEntity & a_Entity) = 0;
+	virtual void SendEntityRelMove              (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ) = 0;
+	virtual void SendEntityRelMoveLook          (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ) = 0;
+	virtual void SendEntityStatus               (const cEntity & a_Entity, char a_Status) = 0;
+	virtual void SendEntityVelocity             (const cEntity & a_Entity) = 0;
+	virtual void SendExplosion                  (double a_BlockX, double a_BlockY, double a_BlockZ, float a_Radius, const cVector3iArray & a_BlocksAffected, const Vector3d & a_PlayerMotion) = 0;
+	virtual void SendGameMode                   (eGameMode a_GameMode) = 0;
+	virtual void SendHealth                     (void) = 0;
+	virtual void SendInventorySlot              (char a_WindowID, short a_SlotNum, const cItem & a_Item) = 0;
+	virtual void SendKeepAlive                  (int a_PingID) = 0;
+	virtual void SendLogin                      (const cPlayer & a_Player, const cWorld & a_World) = 0;
+	virtual void SendLoginSuccess               (void) = 0;
+	virtual void SendMapColumn                  (int a_ID, int a_X, int a_Y, const Byte * a_Colors, unsigned int a_Length, unsigned int m_Scale) = 0;
+	virtual void SendMapDecorators              (int a_ID, const cMapDecoratorList & a_Decorators, unsigned int m_Scale) = 0;
+	virtual void SendMapInfo                    (int a_ID, unsigned int a_Scale) = 0;
+	virtual void SendPaintingSpawn              (const cPainting & a_Painting) = 0;
+	virtual void SendPickupSpawn                (const cPickup & a_Pickup) = 0;
+	virtual void SendPlayerAbilities            (void) = 0;
+	virtual void SendEntityAnimation            (const cEntity & a_Entity, char a_Animation) = 0;
+	virtual void SendParticleEffect             (const AString & a_SoundName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmount) = 0;
+	virtual void SendPlayerListAddPlayer        (const cPlayer & a_Player) = 0;
+	virtual void SendPlayerListRemovePlayer     (const cPlayer & a_Player) = 0;
+	virtual void SendPlayerListUpdateGameMode   (const cPlayer & a_Player) = 0;
+	virtual void SendPlayerListUpdatePing       (const cPlayer & a_Player) = 0;
+	virtual void SendPlayerListUpdateDisplayName(const cPlayer & a_Player, const AString & a_CustomName) = 0;
+	virtual void SendPlayerMaxSpeed             (void) = 0;  ///< Informs the client of the maximum player speed (1.6.1+)
+	virtual void SendPlayerMoveLook             (void) = 0;
+	virtual void SendPlayerPosition             (void) = 0;
+	virtual void SendPlayerSpawn                (const cPlayer & a_Player) = 0;
+	virtual void SendPluginMessage              (const AString & a_Channel, const AString & a_Message) = 0;
+	virtual void SendRemoveEntityEffect         (const cEntity & a_Entity, int a_EffectID) = 0;
+	virtual void SendRespawn                    (eDimension a_Dimension, bool a_ShouldIgnoreDimensionChecks) = 0;
+	virtual void SendExperience                 (void) = 0;
+	virtual void SendExperienceOrb              (const cExpOrb & a_ExpOrb) = 0;
+	virtual void SendScoreboardObjective        (const AString & a_Name, const AString & a_DisplayName, Byte a_Mode) = 0;
+	virtual void SendScoreUpdate                (const AString & a_Objective, const AString & a_Player, cObjective::Score a_Score, Byte a_Mode) = 0;
+	virtual void SendDisplayObjective           (const AString & a_Objective, cScoreboard::eDisplaySlot a_Display) = 0;
+	virtual void SendSoundEffect                (const AString & a_SoundName, double a_X, double a_Y, double a_Z, float a_Volume, float a_Pitch) = 0;
+	virtual void SendSoundParticleEffect        (int a_EffectID, int a_SrcX, int a_SrcY, int a_SrcZ, int a_Data) = 0;
+	virtual void SendSpawnFallingBlock          (const cFallingBlock & a_FallingBlock) = 0;
+	virtual void SendSpawnMob                   (const cMonster & a_Mob) = 0;
+	virtual void SendSpawnObject                (const cEntity & a_Entity, char a_ObjectType, int a_ObjectData, Byte a_Yaw, Byte a_Pitch) = 0;
+	virtual void SendSpawnVehicle               (const cEntity & a_Vehicle, char a_VehicleType, char a_VehicleSubType) = 0;
+	virtual void SendStatistics                 (const cStatManager & a_Manager) = 0;
+	virtual void SendTabCompletionResults       (const AStringVector & a_Results) = 0;
+	virtual void SendTeleportEntity             (const cEntity & a_Entity) = 0;
+	virtual void SendThunderbolt                (int a_BlockX, int a_BlockY, int a_BlockZ) = 0;
+	virtual void SendTimeUpdate                 (Int64 a_WorldAge, Int64 a_TimeOfDay, bool a_DoDaylightCycle) = 0;
+	virtual void SendUnloadChunk                (int a_ChunkX, int a_ChunkZ) = 0;
+	virtual void SendUpdateBlockEntity          (cBlockEntity & a_BlockEntity) = 0;
+	virtual void SendUpdateSign                 (int a_BlockX, int a_BlockY, int a_BlockZ, const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4) = 0;
+	virtual void SendUseBed                     (const cEntity & a_Entity, int a_BlockX, int a_BlockY, int a_BlockZ) = 0;
+	virtual void SendWeather                    (eWeather a_Weather) = 0;
+	virtual void SendWholeInventory             (const cWindow    & a_Window) = 0;
+	virtual void SendWindowClose                (const cWindow    & a_Window) = 0;
+	virtual void SendWindowOpen                 (const cWindow & a_Window) = 0;
+	virtual void SendWindowProperty             (const cWindow & a_Window, int a_Property, int a_Value) = 0;
 
 	/// Returns the ServerID used for authentication through session.minecraft.net
 	virtual AString GetAuthServerID(void) = 0;
diff --git a/src/Protocol/Protocol125.cpp b/src/Protocol/Protocol125.cpp
index a66c64309..369a35e18 100644
--- a/src/Protocol/Protocol125.cpp
+++ b/src/Protocol/Protocol125.cpp
@@ -262,7 +262,7 @@ void cProtocol125::SendChunkData(int a_ChunkX, int a_ChunkZ, cChunkDataSerialize
 	SendPreChunk(a_ChunkX, a_ChunkZ, true);
 	
 	// Send the chunk data:
-	AString Serialized = a_Serializer.Serialize(cChunkDataSerializer::RELEASE_1_2_5);
+	AString Serialized = a_Serializer.Serialize(cChunkDataSerializer::RELEASE_1_2_5, a_ChunkX, a_ChunkZ);
 	WriteByte(PACKET_MAP_CHUNK);
 	WriteInt (a_ChunkX);
 	WriteInt (a_ChunkZ);
@@ -608,7 +608,7 @@ void cProtocol125::SendLoginSuccess(void)
 
 
 
-void cProtocol125::SendMapColumn(int a_ID, int a_X, int a_Y, const Byte * a_Colors, unsigned int a_Length)
+void cProtocol125::SendMapColumn(int a_ID, int a_X, int a_Y, const Byte * a_Colors, unsigned int a_Length, unsigned int m_Scale)
 {
 	cCSLock Lock(m_CSPacket);
 
@@ -630,7 +630,7 @@ void cProtocol125::SendMapColumn(int a_ID, int a_X, int a_Y, const Byte * a_Colo
 
 
 
-void cProtocol125::SendMapDecorators(int a_ID, const cMapDecoratorList & a_Decorators)
+void cProtocol125::SendMapDecorators(int a_ID, const cMapDecoratorList & a_Decorators, unsigned int m_Scale)
 {
 	cCSLock Lock(m_CSPacket);
 
@@ -700,7 +700,7 @@ void cProtocol125::SendEntityAnimation(const cEntity & a_Entity, char a_Animatio
 
 
 
-void cProtocol125::SendParticleEffect(const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmmount)
+void cProtocol125::SendParticleEffect(const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmount)
 {
 	// Not supported by this protocol version
 }
@@ -719,21 +719,27 @@ void cProtocol125::SendPaintingSpawn(const cPainting & a_Painting)
 
 
 
-void cProtocol125::SendPlayerListItem(const cPlayer & a_Player, bool a_IsOnline)
+void cProtocol125::SendPlayerListAddPlayer(const cPlayer & a_Player)
 {
 	cCSLock Lock(m_CSPacket);
-	AString PlayerName(a_Player.GetColor());
-	PlayerName.append(a_Player.GetName());
-	if (PlayerName.length() > 14)
-	{
-		PlayerName.erase(14);
-	}
-	PlayerName += cChatColor::White;
+	WriteByte  (PACKET_PLAYER_LIST_ITEM);
+	WriteString(a_Player.GetPlayerListName());
+	WriteBool  (true);
+	WriteShort (a_Player.GetClientHandle()->GetPing());
+	Flush();
+}
+
 
-	WriteByte  ((unsigned char)PACKET_PLAYER_LIST_ITEM);
-	WriteString(PlayerName);
-	WriteBool  (a_IsOnline);
-	WriteShort (a_IsOnline ? a_Player.GetClientHandle()->GetPing() : 0);
+
+
+
+void cProtocol125::SendPlayerListRemovePlayer(const cPlayer & a_Player)
+{
+	cCSLock Lock(m_CSPacket);
+	WriteByte  (PACKET_PLAYER_LIST_ITEM);
+	WriteString(a_Player.GetPlayerListName());
+	WriteBool  (false);
+	WriteShort (0);
 	Flush();
 }
 
@@ -741,6 +747,37 @@ void cProtocol125::SendPlayerListItem(const cPlayer & a_Player, bool a_IsOnline)
 
 
 
+void cProtocol125::SendPlayerListUpdateGameMode(const cPlayer & a_Player)
+{
+	// Not implemented in this protocol version
+	UNUSED(a_Player);
+}
+
+
+
+
+
+void cProtocol125::SendPlayerListUpdatePing(const cPlayer & a_Player)
+{
+	// It is a simple add player packet in this protocol.
+	SendPlayerListAddPlayer(a_Player);
+}
+
+
+
+
+
+void cProtocol125::SendPlayerListUpdateDisplayName(const cPlayer & a_Player, const AString & a_CustomName)
+{
+	// Not implemented in this protocol version
+	UNUSED(a_Player);
+	UNUSED(a_CustomName);
+}
+
+
+
+
+
 void cProtocol125::SendPlayerMaxSpeed(void)
 {
 	// Not supported by this protocol version
@@ -792,7 +829,14 @@ void cProtocol125::SendPlayerSpawn(const cPlayer & a_Player)
 	cCSLock Lock(m_CSPacket);
 	WriteByte	 (PACKET_PLAYER_SPAWN);
 	WriteInt   (a_Player.GetUniqueID());
-	WriteString(a_Player.GetName());
+	if (a_Player.HasCustomName())
+	{
+		WriteString(a_Player.GetCustomName());
+	}
+	else
+	{
+		WriteString(a_Player.GetName());
+	}
 	WriteInt   ((int)(a_Player.GetPosX() * 32));
 	WriteInt   ((int)(a_Player.GetPosY() * 32));
 	WriteInt   ((int)(a_Player.GetPosZ() * 32));
@@ -1946,7 +1990,7 @@ void cProtocol125::WriteMobMetadata(const cMonster & a_Mob)
 {
 	switch (a_Mob.GetMobType())
 	{
-		case cMonster::mtCreeper:
+		case mtCreeper:
 		{
 			WriteByte(0x10);
 			WriteChar(((const cCreeper &)a_Mob).IsBlowing() ? 1 : -1);  // Blowing up?
@@ -1954,25 +1998,25 @@ void cProtocol125::WriteMobMetadata(const cMonster & a_Mob)
 			WriteByte(((const cCreeper &)a_Mob).IsCharged() ? 1 : 0);  // Lightning-charged?
 			break;
 		}
-		case cMonster::mtBat:
+		case mtBat:
 		{
 			WriteByte(0x10);
 			WriteByte(((const cBat &)a_Mob).IsHanging() ? 1 : 0);  // Upside down?
 			break;
 		}
-		case cMonster::mtPig:
+		case mtPig:
 		{
 			WriteByte(0x10);
 			WriteByte(((const cPig &)a_Mob).IsSaddled() ? 1 : 0);  // Saddled?
 			break;
 		}
-		case cMonster::mtVillager:
+		case mtVillager:
 		{
 			WriteByte(0x50);
 			WriteInt(((const cVillager &)a_Mob).GetVilType());  // What sort of TESTIFICATE?
 			break;
 		}
-		case cMonster::mtZombie:
+		case mtZombie:
 		{
 			WriteByte(0xC);
 			WriteByte(((const cZombie &)a_Mob).IsBaby() ? 1 : 0);  // Baby zombie?
@@ -1982,13 +2026,13 @@ void cProtocol125::WriteMobMetadata(const cMonster & a_Mob)
 			WriteByte(((const cZombie &)a_Mob).IsConverting() ? 1 : 0);  // Converted-but-converting-back zombllager?
 			break;
 		}
-		case cMonster::mtGhast:
+		case mtGhast:
 		{
 			WriteByte(0x10);
 			WriteByte(((const cGhast &)a_Mob).IsCharging());  // About to spit a flameball?
 			break;
 		}
-		case cMonster::mtWolf:
+		case mtWolf:
 		{
 			Byte WolfStatus = 0;
 			if (((const cWolf &)a_Mob).IsSitting())
@@ -2012,7 +2056,7 @@ void cProtocol125::WriteMobMetadata(const cMonster & a_Mob)
 			WriteByte(((const cWolf &)a_Mob).IsBegging() ? 1 : 0);  // Ultra cute mode?
 			break;
 		}
-		case cMonster::mtSheep:
+		case mtSheep:
 		{
 			// [1](1111)
 			// [] = Is sheared? () = Color, from 0 to 15
@@ -2028,7 +2072,7 @@ void cProtocol125::WriteMobMetadata(const cMonster & a_Mob)
 			WriteByte(SheepMetadata);
 			break;
 		}
-		case cMonster::mtEnderman:
+		case mtEnderman:
 		{
 			WriteByte(0x10);
 			WriteByte((Byte)(((const cEnderman &)a_Mob).GetCarriedBlock()));  // Block that he stole from your house
@@ -2038,19 +2082,19 @@ void cProtocol125::WriteMobMetadata(const cMonster & a_Mob)
 			WriteByte(((const cEnderman &)a_Mob).IsScreaming() ? 1 : 0);  // Screaming at your face?
 			break;
 		}
-		case cMonster::mtSkeleton:
+		case mtSkeleton:
 		{
 			WriteByte(0xD);
 			WriteByte(((const cSkeleton &)a_Mob).IsWither() ? 1 : 0);  // It's a skeleton, but it's not
 			break;
 		}
-		case cMonster::mtWitch:
+		case mtWitch:
 		{
 			WriteByte(0x15);
 			WriteByte(((const cWitch &)a_Mob).IsAngry() ? 1 : 0);  // Aggravated? Doesn't seem to do anything
 			break;
 		}
-		case cMonster::mtWither:
+		case mtWither:
 		{
 			WriteByte(0x54);  // Int at index 20
 			WriteInt((Int32)((const cWither &)a_Mob).GetWitherInvulnerableTicks());
@@ -2058,11 +2102,11 @@ void cProtocol125::WriteMobMetadata(const cMonster & a_Mob)
 			WriteFloat((float)(a_Mob.GetHealth()));
 			break;
 		}
-		case cMonster::mtSlime:
-		case cMonster::mtMagmaCube:
+		case mtSlime:
+		case mtMagmaCube:
 		{
 			WriteByte(0x10);
-			if (a_Mob.GetMobType() == cMonster::mtSlime)
+			if (a_Mob.GetMobType() == mtSlime)
 			{
 				WriteByte((Byte)((const cSlime &)a_Mob).GetSize());  // Size of slime - HEWGE, meh, cute BABBY SLIME
 			}
@@ -2072,7 +2116,7 @@ void cProtocol125::WriteMobMetadata(const cMonster & a_Mob)
 			}
 			break;
 		}
-		case cMonster::mtHorse:
+		case mtHorse:
 		{
 			int Flags = 0;
 			if (((const cHorse &)a_Mob).IsTame())
diff --git a/src/Protocol/Protocol125.h b/src/Protocol/Protocol125.h
index 1063777a2..3ea116c3b 100644
--- a/src/Protocol/Protocol125.h
+++ b/src/Protocol/Protocol125.h
@@ -28,76 +28,80 @@ public:
 	virtual void DataReceived(const char * a_Data, size_t a_Size) override;
 	
 	/// Sending stuff to clients (alphabetically sorted):
-	virtual void SendAttachEntity        (const cEntity & a_Entity, const cEntity * a_Vehicle) override;
-	virtual void SendBlockAction         (int a_BlockX, int a_BlockY, int a_BlockZ, char a_Byte1, char a_Byte2, BLOCKTYPE a_BlockType) override;
-	virtual void SendBlockBreakAnim	     (int a_EntityID, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Stage) override;
-	virtual void SendBlockChange         (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) override;
-	virtual void SendBlockChanges        (int a_ChunkX, int a_ChunkZ, const sSetBlockVector & a_Changes) override;
-	virtual void SendChat                (const AString & a_Message) override;
-	virtual void SendChat                (const cCompositeChat & a_Message) override;
-	virtual void SendChunkData           (int a_ChunkX, int a_ChunkZ, cChunkDataSerializer & a_Serializer) override;
-	virtual void SendCollectEntity       (const cEntity & a_Entity, const cPlayer & a_Player) override;
-	virtual void SendDestroyEntity       (const cEntity & a_Entity) override;
-	virtual void SendDisconnect          (const AString & a_Reason) override;
-	virtual void SendEditSign            (int a_BlockX, int a_BlockY, int a_BlockZ) override;  ///< Request the client to open up the sign editor for the sign (1.6+)
-	virtual void SendEntityEffect        (const cEntity & a_Entity, int a_EffectID, int a_Amplifier, short a_Duration) override;
-	virtual void SendEntityEquipment     (const cEntity & a_Entity, short a_SlotNum, const cItem & a_Item) override;
-	virtual void SendEntityHeadLook      (const cEntity & a_Entity) override;
-	virtual void SendEntityLook          (const cEntity & a_Entity) override;
-	virtual void SendEntityMetadata      (const cEntity & a_Entity) override;
-	virtual void SendEntityProperties    (const cEntity & a_Entity) override;
-	virtual void SendEntityRelMove       (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ) override;
-	virtual void SendEntityRelMoveLook   (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ) override;
-	virtual void SendEntityStatus        (const cEntity & a_Entity, char a_Status) override;
-	virtual void SendEntityVelocity      (const cEntity & a_Entity) override;
-	virtual void SendExplosion           (double a_BlockX, double a_BlockY, double a_BlockZ, float a_Radius, const cVector3iArray & a_BlocksAffected, const Vector3d & a_PlayerMotion) override;
-	virtual void SendGameMode            (eGameMode a_GameMode) override;
-	virtual void SendHealth              (void) override;
-	virtual void SendInventorySlot       (char a_WindowID, short a_SlotNum, const cItem & a_Item) override;
-	virtual void SendKeepAlive           (int a_PingID) override;
-	virtual void SendLogin               (const cPlayer & a_Player, const cWorld & a_World) override;
-	virtual void SendLoginSuccess        (void) override;
-	virtual void SendMapColumn           (int a_ID, int a_X, int a_Y, const Byte * a_Colors, unsigned int a_Length) override;
-	virtual void SendMapDecorators       (int a_ID, const cMapDecoratorList & a_Decorators) override;
-	virtual void SendMapInfo             (int a_ID, unsigned int a_Scale) override;
-	virtual void SendParticleEffect      (const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmmount) override;
-	virtual void SendPaintingSpawn       (const cPainting & a_Painting) override;
-	virtual void SendPickupSpawn         (const cPickup & a_Pickup) override;
-	virtual void SendPlayerAbilities     (void) override {}  // This protocol doesn't support such message
-	virtual void SendEntityAnimation     (const cEntity & a_Entity, char a_Animation) override;
-	virtual void SendPlayerListItem      (const cPlayer & a_Player, bool a_IsOnline) override;
-	virtual void SendPlayerMaxSpeed      (void) override;
-	virtual void SendPlayerMoveLook      (void) override;
-	virtual void SendPlayerPosition      (void) override;
-	virtual void SendPlayerSpawn         (const cPlayer & a_Player) override;
-	virtual void SendPluginMessage       (const AString & a_Channel, const AString & a_Message) override;
-	virtual void SendRemoveEntityEffect  (const cEntity & a_Entity, int a_EffectID) override;
-	virtual void SendRespawn             (eDimension a_Dimension, bool a_ShouldIgnoreDimensionChecks) override;
-	virtual void SendExperience          (void) override;
-	virtual void SendExperienceOrb       (const cExpOrb &  a_ExpOrb) override;
-	virtual void SendScoreboardObjective (const AString & a_Name, const AString & a_DisplayName, Byte a_Mode) override;
-	virtual void SendScoreUpdate         (const AString & a_Objective, const AString & a_Player, cObjective::Score a_Score, Byte a_Mode) override {}  // This protocol doesn't support such message
-	virtual void SendDisplayObjective    (const AString & a_Objective, cScoreboard::eDisplaySlot a_Display)                              override {}  // This protocol doesn't support such message
-	virtual void SendSoundEffect         (const AString & a_SoundName, double a_X, double a_Y, double a_Z, float a_Volume, float a_Pitch) override;
-	virtual void SendSoundParticleEffect (int a_EffectID, int a_SrcX, int a_SrcY, int a_SrcZ, int a_Data) override;
-	virtual void SendSpawnFallingBlock   (const cFallingBlock & a_FallingBlock) override;
-	virtual void SendSpawnMob            (const cMonster & a_Mob) override;
-	virtual void SendSpawnObject         (const cEntity & a_Entity, char a_ObjectType, int a_ObjectData, Byte a_Yaw, Byte a_Pitch) override;
-	virtual void SendSpawnVehicle        (const cEntity & a_Vehicle, char a_VehicleType, char a_VehicleSubType) override;
-	virtual void SendStatistics          (const cStatManager & a_Manager) override;
-	virtual void SendTabCompletionResults(const AStringVector & a_Results) override;
-	virtual void SendTeleportEntity      (const cEntity & a_Entity) override;
-	virtual void SendThunderbolt         (int a_BlockX, int a_BlockY, int a_BlockZ) override;
-	virtual void SendTimeUpdate          (Int64 a_WorldAge, Int64 a_TimeOfDay, bool a_DoDaylightCycle) override;
-	virtual void SendUnloadChunk         (int a_ChunkX, int a_ChunkZ) override;
-	virtual void SendUpdateBlockEntity   (cBlockEntity & a_BlockEntity) override {}
-	virtual void SendUpdateSign          (int a_BlockX, int a_BlockY, int a_BlockZ, const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4) override;
-	virtual void SendUseBed              (const cEntity & a_Entity, int a_BlockX, int a_BlockY, int a_BlockZ) override;
-	virtual void SendWeather             (eWeather a_Weather) override;
-	virtual void SendWholeInventory      (const cWindow & a_Window) override;
-	virtual void SendWindowClose         (const cWindow & a_Window) override;
-	virtual void SendWindowOpen          (const cWindow & a_Window) override;
-	virtual void SendWindowProperty      (const cWindow & a_Window, int a_Property, int a_Value) override;
+	virtual void SendAttachEntity               (const cEntity & a_Entity, const cEntity * a_Vehicle) override;
+	virtual void SendBlockAction                (int a_BlockX, int a_BlockY, int a_BlockZ, char a_Byte1, char a_Byte2, BLOCKTYPE a_BlockType) override;
+	virtual void SendBlockBreakAnim	            (int a_EntityID, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Stage) override;
+	virtual void SendBlockChange                (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) override;
+	virtual void SendBlockChanges               (int a_ChunkX, int a_ChunkZ, const sSetBlockVector & a_Changes) override;
+	virtual void SendChat                       (const AString & a_Message) override;
+	virtual void SendChat                       (const cCompositeChat & a_Message) override;
+	virtual void SendChunkData                  (int a_ChunkX, int a_ChunkZ, cChunkDataSerializer & a_Serializer) override;
+	virtual void SendCollectEntity              (const cEntity & a_Entity, const cPlayer & a_Player) override;
+	virtual void SendDestroyEntity              (const cEntity & a_Entity) override;
+	virtual void SendDisconnect                 (const AString & a_Reason) override;
+	virtual void SendEditSign                   (int a_BlockX, int a_BlockY, int a_BlockZ) override;  ///< Request the client to open up the sign editor for the sign (1.6+)
+	virtual void SendEntityEffect               (const cEntity & a_Entity, int a_EffectID, int a_Amplifier, short a_Duration) override;
+	virtual void SendEntityEquipment            (const cEntity & a_Entity, short a_SlotNum, const cItem & a_Item) override;
+	virtual void SendEntityHeadLook             (const cEntity & a_Entity) override;
+	virtual void SendEntityLook                 (const cEntity & a_Entity) override;
+	virtual void SendEntityMetadata             (const cEntity & a_Entity) override;
+	virtual void SendEntityProperties           (const cEntity & a_Entity) override;
+	virtual void SendEntityRelMove              (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ) override;
+	virtual void SendEntityRelMoveLook          (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ) override;
+	virtual void SendEntityStatus               (const cEntity & a_Entity, char a_Status) override;
+	virtual void SendEntityVelocity             (const cEntity & a_Entity) override;
+	virtual void SendExplosion                  (double a_BlockX, double a_BlockY, double a_BlockZ, float a_Radius, const cVector3iArray & a_BlocksAffected, const Vector3d & a_PlayerMotion) override;
+	virtual void SendGameMode                   (eGameMode a_GameMode) override;
+	virtual void SendHealth                     (void) override;
+	virtual void SendInventorySlot              (char a_WindowID, short a_SlotNum, const cItem & a_Item) override;
+	virtual void SendKeepAlive                  (int a_PingID) override;
+	virtual void SendLogin                      (const cPlayer & a_Player, const cWorld & a_World) override;
+	virtual void SendLoginSuccess               (void) override;
+	virtual void SendMapColumn                  (int a_ID, int a_X, int a_Y, const Byte * a_Colors, unsigned int a_Length, unsigned int m_Scale) override;
+	virtual void SendMapDecorators              (int a_ID, const cMapDecoratorList & a_Decorators, unsigned int m_Scale) override;
+	virtual void SendMapInfo                    (int a_ID, unsigned int a_Scale) override;
+	virtual void SendParticleEffect             (const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmount) override;
+	virtual void SendPaintingSpawn              (const cPainting & a_Painting) override;
+	virtual void SendPickupSpawn                (const cPickup & a_Pickup) override;
+	virtual void SendPlayerAbilities            (void) override {}  // This protocol doesn't support such message
+	virtual void SendEntityAnimation            (const cEntity & a_Entity, char a_Animation) override;
+	virtual void SendPlayerListAddPlayer        (const cPlayer & a_Player) override;
+	virtual void SendPlayerListRemovePlayer     (const cPlayer & a_Player) override;
+	virtual void SendPlayerListUpdateGameMode   (const cPlayer & a_Player) override;
+	virtual void SendPlayerListUpdatePing       (const cPlayer & a_Player) override;
+	virtual void SendPlayerListUpdateDisplayName(const cPlayer & a_Player, const AString & a_CustomName) override;
+	virtual void SendPlayerMaxSpeed             (void) override;
+	virtual void SendPlayerMoveLook             (void) override;
+	virtual void SendPlayerPosition             (void) override;
+	virtual void SendPlayerSpawn                (const cPlayer & a_Player) override;
+	virtual void SendPluginMessage              (const AString & a_Channel, const AString & a_Message) override;
+	virtual void SendRemoveEntityEffect         (const cEntity & a_Entity, int a_EffectID) override;
+	virtual void SendRespawn                    (eDimension a_Dimension, bool a_ShouldIgnoreDimensionChecks) override;
+	virtual void SendExperience                 (void) override;
+	virtual void SendExperienceOrb              (const cExpOrb &  a_ExpOrb) override;
+	virtual void SendScoreboardObjective        (const AString & a_Name, const AString & a_DisplayName, Byte a_Mode) override;
+	virtual void SendScoreUpdate                (const AString & a_Objective, const AString & a_Player, cObjective::Score a_Score, Byte a_Mode) override {}  // This protocol doesn't support such message
+	virtual void SendDisplayObjective           (const AString & a_Objective, cScoreboard::eDisplaySlot a_Display)                              override {}  // This protocol doesn't support such message
+	virtual void SendSoundEffect                (const AString & a_SoundName, double a_X, double a_Y, double a_Z, float a_Volume, float a_Pitch) override;
+	virtual void SendSoundParticleEffect        (int a_EffectID, int a_SrcX, int a_SrcY, int a_SrcZ, int a_Data) override;
+	virtual void SendSpawnFallingBlock          (const cFallingBlock & a_FallingBlock) override;
+	virtual void SendSpawnMob                   (const cMonster & a_Mob) override;
+	virtual void SendSpawnObject                (const cEntity & a_Entity, char a_ObjectType, int a_ObjectData, Byte a_Yaw, Byte a_Pitch) override;
+	virtual void SendSpawnVehicle               (const cEntity & a_Vehicle, char a_VehicleType, char a_VehicleSubType) override;
+	virtual void SendStatistics                 (const cStatManager & a_Manager) override;
+	virtual void SendTabCompletionResults       (const AStringVector & a_Results) override;
+	virtual void SendTeleportEntity             (const cEntity & a_Entity) override;
+	virtual void SendThunderbolt                (int a_BlockX, int a_BlockY, int a_BlockZ) override;
+	virtual void SendTimeUpdate                 (Int64 a_WorldAge, Int64 a_TimeOfDay, bool a_DoDaylightCycle) override;
+	virtual void SendUnloadChunk                (int a_ChunkX, int a_ChunkZ) override;
+	virtual void SendUpdateBlockEntity          (cBlockEntity & a_BlockEntity) override {}
+	virtual void SendUpdateSign                 (int a_BlockX, int a_BlockY, int a_BlockZ, const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4) override;
+	virtual void SendUseBed                     (const cEntity & a_Entity, int a_BlockX, int a_BlockY, int a_BlockZ) override;
+	virtual void SendWeather                    (eWeather a_Weather) override;
+	virtual void SendWholeInventory             (const cWindow & a_Window) override;
+	virtual void SendWindowClose                (const cWindow & a_Window) override;
+	virtual void SendWindowOpen                 (const cWindow & a_Window) override;
+	virtual void SendWindowProperty             (const cWindow & a_Window, int a_Property, int a_Value) override;
 	
 	virtual AString GetAuthServerID(void) override;
 	
diff --git a/src/Protocol/Protocol132.cpp b/src/Protocol/Protocol132.cpp
index 5c58ab0ba..63a15c082 100644
--- a/src/Protocol/Protocol132.cpp
+++ b/src/Protocol/Protocol132.cpp
@@ -176,7 +176,7 @@ void cProtocol132::SendChunkData(int a_ChunkX, int a_ChunkZ, cChunkDataSerialize
 	// Pre-chunk not used in 1.3.2. Finally.
 
 	// Send the chunk data:
-	AString Serialized = a_Serializer.Serialize(cChunkDataSerializer::RELEASE_1_3_2);
+	AString Serialized = a_Serializer.Serialize(cChunkDataSerializer::RELEASE_1_3_2, a_ChunkX, a_ChunkZ);
 	WriteByte(PACKET_CHUNK_DATA);
 	WriteInt (a_ChunkX);
 	WriteInt (a_ChunkZ);
@@ -260,7 +260,14 @@ void cProtocol132::SendPlayerSpawn(const cPlayer & a_Player)
 	cCSLock Lock(m_CSPacket);
 	WriteByte	 (PACKET_PLAYER_SPAWN);
 	WriteInt   (a_Player.GetUniqueID());
-	WriteString(a_Player.GetName());
+	if (a_Player.HasCustomName())
+	{
+		WriteString(a_Player.GetCustomName());
+	}
+	else
+	{
+		WriteString(a_Player.GetName());
+	}
 	WriteInt   ((int)(a_Player.GetPosX() * 32));
 	WriteInt   ((int)(a_Player.GetPosY() * 32));
 	WriteInt   ((int)(a_Player.GetPosZ() * 32));
diff --git a/src/Protocol/Protocol14x.cpp b/src/Protocol/Protocol14x.cpp
index 3b6b6a42a..d33314a2f 100644
--- a/src/Protocol/Protocol14x.cpp
+++ b/src/Protocol/Protocol14x.cpp
@@ -132,12 +132,6 @@ void cProtocol142::SendSoundParticleEffect(int a_EffectID, int a_SrcX, int a_Src
 
 void cProtocol142::SendTimeUpdate(Int64 a_WorldAge, Int64 a_TimeOfDay, bool a_DoDaylightCycle)
 {
-	if (!a_DoDaylightCycle)
-	{
-		// When writing a "-" before the number the client ignores it but it will stop the client-side time expiration.
-		a_TimeOfDay = std::min(-a_TimeOfDay, -1LL);
-	}
-
 	cCSLock Lock(m_CSPacket);
 	WriteByte (PACKET_UPDATE_TIME);
 	WriteInt64(a_WorldAge);
diff --git a/src/Protocol/Protocol15x.cpp b/src/Protocol/Protocol15x.cpp
index 2b1f01b08..089296fdf 100644
--- a/src/Protocol/Protocol15x.cpp
+++ b/src/Protocol/Protocol15x.cpp
@@ -80,7 +80,7 @@ void cProtocol150::SendWindowOpen(const cWindow & a_Window)
 
 
 
-void cProtocol150::SendParticleEffect(const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmmount)
+void cProtocol150::SendParticleEffect(const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmount)
 {
 	cCSLock Lock(m_CSPacket);
 	WriteByte(PACKET_PARTICLE_EFFECT);
@@ -92,7 +92,7 @@ void cProtocol150::SendParticleEffect(const AString & a_ParticleName, float a_Sr
 	WriteFloat(a_OffsetY);
 	WriteFloat(a_OffsetZ);
 	WriteFloat(a_ParticleData);
-	WriteInt(a_ParticleAmmount);
+	WriteInt(a_ParticleAmount);
 	Flush();
 }
 
diff --git a/src/Protocol/Protocol15x.h b/src/Protocol/Protocol15x.h
index 0d171a67c..968d5ebcf 100644
--- a/src/Protocol/Protocol15x.h
+++ b/src/Protocol/Protocol15x.h
@@ -29,7 +29,7 @@ public:
 	cProtocol150(cClientHandle * a_Client);
 	
 	virtual void SendWindowOpen          (const cWindow & a_Window) override;
-	virtual void SendParticleEffect      (const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmmount) override;
+	virtual void SendParticleEffect      (const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmount) override;
 	virtual void SendScoreboardObjective (const AString & a_Name, const AString & a_DisplayName, Byte a_Mode) override;
 	virtual void SendScoreUpdate         (const AString & a_Objective, const AString & a_Player, cObjective::Score a_Score, Byte a_Mode) override;
 	virtual void SendDisplayObjective    (const AString & a_Objective, cScoreboard::eDisplaySlot a_Display) override;
diff --git a/src/Protocol/Protocol17x.cpp b/src/Protocol/Protocol17x.cpp
index 49a62e4f3..95abcd146 100644
--- a/src/Protocol/Protocol17x.cpp
+++ b/src/Protocol/Protocol17x.cpp
@@ -1,10 +1,12 @@
+
 // Protocol17x.cpp
 
 /*
 Implements the 1.7.x protocol classes:
 	- cProtocol172
 		- release 1.7.2 protocol (#4)
-(others may be added later in the future for the 1.7 release series)
+	- cProtocol176
+		- release 1.7.6 protocol (#5)
 */
 
 #include "Globals.h"
@@ -251,101 +253,13 @@ void cProtocol172::SendChat(const AString & a_Message)
 void cProtocol172::SendChat(const cCompositeChat & a_Message)
 {
 	ASSERT(m_State == 3);  // In game mode?
-	
-	// Compose the complete Json string to send:
-	Json::Value msg;
+
 	cWorld * World = m_Client->GetPlayer()->GetWorld();
-	msg["text"] = cClientHandle::FormatMessageType((World == NULL) ? false : World->ShouldUseChatPrefixes(), a_Message.GetMessageType(), a_Message.GetAdditionalMessageTypeData());  // The client crashes without this field being present
-	const cCompositeChat::cParts & Parts = a_Message.GetParts();
-	for (cCompositeChat::cParts::const_iterator itr = Parts.begin(), end = Parts.end(); itr != end; ++itr)
-	{
-		Json::Value Part;
-		switch ((*itr)->m_PartType)
-		{
-			case cCompositeChat::ptText:
-			{
-				Part["text"] = (*itr)->m_Text;
-				AddChatPartStyle(Part, (*itr)->m_Style);
-				break;
-			}
-			
-			case cCompositeChat::ptClientTranslated:
-			{
-				const cCompositeChat::cClientTranslatedPart & p = (const cCompositeChat::cClientTranslatedPart &)**itr;
-				Part["translate"] = p.m_Text;
-				Json::Value With;
-				for (AStringVector::const_iterator itrW = p.m_Parameters.begin(), endW = p.m_Parameters.end(); itrW != endW; ++itr)
-				{
-					With.append(*itrW);
-				}
-				if (!p.m_Parameters.empty())
-				{
-					Part["with"] = With;
-				}
-				AddChatPartStyle(Part, p.m_Style);
-				break;
-			}
-			
-			case cCompositeChat::ptUrl:
-			{
-				const cCompositeChat::cUrlPart & p = (const cCompositeChat::cUrlPart &)**itr;
-				Part["text"] = p.m_Text;
-				Json::Value Url;
-				Url["action"] = "open_url";
-				Url["value"] = p.m_Url;
-				Part["clickEvent"] = Url;
-				AddChatPartStyle(Part, p.m_Style);
-				break;
-			}
-			
-			case cCompositeChat::ptSuggestCommand:
-			case cCompositeChat::ptRunCommand:
-			{
-				const cCompositeChat::cCommandPart & p = (const cCompositeChat::cCommandPart &)**itr;
-				Part["text"] = p.m_Text;
-				Json::Value Cmd;
-				Cmd["action"] = (p.m_PartType == cCompositeChat::ptRunCommand) ? "run_command" : "suggest_command";
-				Cmd["value"] = p.m_Command;
-				Part["clickEvent"] = Cmd;
-				AddChatPartStyle(Part, p.m_Style);
-				break;
-			}
+	bool ShouldUseChatPrefixes = (World == NULL) ? false : World->ShouldUseChatPrefixes();
 
-			case cCompositeChat::ptShowAchievement:
-			{
-				const cCompositeChat::cShowAchievementPart & p = (const cCompositeChat::cShowAchievementPart &)**itr;
-				Part["translate"] = "chat.type.achievement";
-
-				Json::Value Ach;
-				Ach["action"] = "show_achievement";
-				Ach["value"] = p.m_Text;
-				
-				Json::Value AchColourAndName;
-				AchColourAndName["color"] = "green";
-				AchColourAndName["translate"] = p.m_Text;
-				AchColourAndName["hoverEvent"] = Ach;
-
-				Json::Value Extra;
-				Extra.append(AchColourAndName);
-
-				Json::Value Name;
-				Name["text"] = p.m_PlayerName;
-
-				Json::Value With;
-				With.append(Name);
-				With.append(Extra);
-
-				Part["with"] = With;
-				AddChatPartStyle(Part, p.m_Style);
-				break;
-			}
-		}
-		msg["extra"].append(Part);
-	}  // for itr - Parts[]
-	
 	// Send the message to the client:
 	cPacketizer Pkt(*this, 0x02);
-	Pkt.WriteString(msg.toStyledString());
+	Pkt.WriteString(a_Message.CreateJsonString(ShouldUseChatPrefixes));
 }
 
 
@@ -358,7 +272,7 @@ void cProtocol172::SendChunkData(int a_ChunkX, int a_ChunkZ, cChunkDataSerialize
 	
 	// Serialize first, before creating the Packetizer (the packetizer locks a CS)
 	// This contains the flags and bitmasks, too
-	const AString & ChunkData = a_Serializer.Serialize(cChunkDataSerializer::RELEASE_1_3_2);
+	const AString & ChunkData = a_Serializer.Serialize(cChunkDataSerializer::RELEASE_1_3_2, a_ChunkX, a_ChunkZ);
 	
 	cPacketizer Pkt(*this, 0x21);  // Chunk Data packet
 	Pkt.WriteInt(a_ChunkX);
@@ -727,7 +641,7 @@ void cProtocol172::SendPaintingSpawn(const cPainting & a_Painting)
 
 
 
-void cProtocol172::SendMapColumn(int a_ID, int a_X, int a_Y, const Byte * a_Colors, unsigned int a_Length)
+void cProtocol172::SendMapColumn(int a_ID, int a_X, int a_Y, const Byte * a_Colors, unsigned int a_Length, unsigned int m_Scale)
 {
 	ASSERT(m_State == 3);  // In game mode?
 	
@@ -749,7 +663,7 @@ void cProtocol172::SendMapColumn(int a_ID, int a_X, int a_Y, const Byte * a_Colo
 
 
 
-void cProtocol172::SendMapDecorators(int a_ID, const cMapDecoratorList & a_Decorators)
+void cProtocol172::SendMapDecorators(int a_ID, const cMapDecoratorList & a_Decorators, unsigned int m_Scale)
 {
 	ASSERT(m_State == 3);  // In game mode?
 	
@@ -787,7 +701,6 @@ void cProtocol172::SendMapInfo(int a_ID, unsigned int a_Scale)
 
 
 
-
 void cProtocol172::SendPickupSpawn(const cPickup & a_Pickup)
 {
 	ASSERT(m_State == 3);  // In game mode?
@@ -858,7 +771,7 @@ void cProtocol172::SendEntityAnimation(const cEntity & a_Entity, char a_Animatio
 
 
 
-void cProtocol172::SendParticleEffect(const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmmount)
+void cProtocol172::SendParticleEffect(const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmount)
 {
 	ASSERT(m_State == 3);  // In game mode?
 	
@@ -871,21 +784,66 @@ void cProtocol172::SendParticleEffect(const AString & a_ParticleName, float a_Sr
 	Pkt.WriteFloat(a_OffsetY);
 	Pkt.WriteFloat(a_OffsetZ);
 	Pkt.WriteFloat(a_ParticleData);
-	Pkt.WriteInt(a_ParticleAmmount);
+	Pkt.WriteInt(a_ParticleAmount);
 }
 
 
 
 
 
-void cProtocol172::SendPlayerListItem(const cPlayer & a_Player, bool a_IsOnline)
+void cProtocol172::SendPlayerListAddPlayer(const cPlayer & a_Player)
 {
 	ASSERT(m_State == 3);  // In game mode?
-	
+
 	cPacketizer Pkt(*this, 0x38);  // Playerlist Item packet
-	Pkt.WriteString(a_Player.GetName());
-	Pkt.WriteBool(a_IsOnline);
-	Pkt.WriteShort(a_IsOnline ? a_Player.GetClientHandle()->GetPing() : 0);
+	Pkt.WriteString(a_Player.GetPlayerListName());
+	Pkt.WriteBool(true);
+	Pkt.WriteShort(a_Player.GetClientHandle()->GetPing());
+}
+
+
+
+
+
+void cProtocol172::SendPlayerListRemovePlayer(const cPlayer & a_Player)
+{
+	ASSERT(m_State == 3);  // In game mode?
+
+	cPacketizer Pkt(*this, 0x38);
+	Pkt.WriteString(a_Player.GetPlayerListName());
+	Pkt.WriteBool(false);
+	Pkt.WriteShort(0);
+}
+
+
+
+
+
+void cProtocol172::SendPlayerListUpdateGameMode(const cPlayer & a_Player)
+{
+	// Not implemented in this protocol version
+	UNUSED(a_Player);
+}
+
+
+
+
+
+void cProtocol172::SendPlayerListUpdatePing(const cPlayer & a_Player)
+{
+	// It is a simple add player packet in this protocol.
+	SendPlayerListAddPlayer(a_Player);
+}
+
+
+
+
+
+void cProtocol172::SendPlayerListUpdateDisplayName(const cPlayer & a_Player, const AString & a_CustomName)
+{
+	// Not implemented in this protocol version
+	UNUSED(a_Player);
+	UNUSED(a_CustomName);
 }
 
 
@@ -959,9 +917,16 @@ void cProtocol172::SendPlayerSpawn(const cPlayer & a_Player)
 	
 	// Called to spawn another player for the client
 	cPacketizer Pkt(*this, 0x0c);  // Spawn Player packet
-	Pkt.WriteVarInt(a_Player.GetUniqueID());
+	Pkt.WriteVarInt((UInt32) a_Player.GetUniqueID());
 	Pkt.WriteString(cMojangAPI::MakeUUIDDashed(a_Player.GetClientHandle()->GetUUID()));
-	Pkt.WriteString(a_Player.GetName());
+	if (a_Player.HasCustomName())
+	{
+		Pkt.WriteString(a_Player.GetCustomName());
+	}
+	else
+	{
+		Pkt.WriteString(a_Player.GetName());
+	}
 	Pkt.WriteFPInt(a_Player.GetPosX());
 	Pkt.WriteFPInt(a_Player.GetPosY());
 	Pkt.WriteFPInt(a_Player.GetPosZ());
@@ -1515,14 +1480,14 @@ void cProtocol172::AddReceivedData(const char * a_Data, size_t a_Size)
 		);
 		m_CommLogFile.Flush();
 	}
-	
+
 	if (!m_ReceivedData.Write(a_Data, a_Size))
 	{
 		// Too much data in the incoming queue, report to caller:
 		m_Client->PacketBufferFull();
 		return;
 	}
-	
+
 	// Handle all complete packets:
 	for (;;)
 	{
@@ -1542,10 +1507,7 @@ void cProtocol172::AddReceivedData(const char * a_Data, size_t a_Size)
 		cByteBuffer bb(PacketLen + 1);
 		VERIFY(m_ReceivedData.ReadToByteBuffer(bb, (int)PacketLen));
 		m_ReceivedData.CommitRead();
-		
-		// Write one NUL extra, so that we can detect over-reads
-		bb.Write("\0", 1);
-		
+
 		UInt32 PacketType;
 		if (!bb.ReadVarInt(PacketType))
 		{
@@ -1553,6 +1515,9 @@ void cProtocol172::AddReceivedData(const char * a_Data, size_t a_Size)
 			break;
 		}
 
+		// Write one NUL extra, so that we can detect over-reads
+		bb.Write("\0", 1);
+		
 		// Log the packet info into the comm log file:
 		if (g_ShouldLogCommIn)
 		{
@@ -1560,7 +1525,7 @@ void cProtocol172::AddReceivedData(const char * a_Data, size_t a_Size)
 			bb.ReadAll(PacketData);
 			bb.ResetRead();
 			bb.ReadVarInt(PacketType);
-			ASSERT(PacketData.size() > 0);
+			ASSERT(PacketData.size() > 0);  // We have written an extra NUL, so there had to be at least one byte read
 			PacketData.resize(PacketData.size() - 1);
 			AString PacketDataHex;
 			CreateHexDump(PacketDataHex, PacketData.data(), PacketData.size(), 16);
@@ -1568,7 +1533,7 @@ void cProtocol172::AddReceivedData(const char * a_Data, size_t a_Size)
 				PacketType, PacketType, PacketLen, PacketLen, m_State, PacketDataHex.c_str()
 			);
 		}
-		
+
 		if (!HandlePacket(bb, PacketType))
 		{
 			// Unknown packet, already been reported, but without the length. Log the length here:
@@ -1593,7 +1558,7 @@ void cProtocol172::AddReceivedData(const char * a_Data, size_t a_Size)
 			
 			return;
 		}
-		
+
 		if (bb.GetReadableSpace() != 1)
 		{
 			// Read more or less than packet length, report as error
@@ -1614,7 +1579,7 @@ void cProtocol172::AddReceivedData(const char * a_Data, size_t a_Size)
 			m_Client->PacketError(PacketType);
 		}
 	}  // for (ever)
-	
+
 	// Log any leftover bytes into the logfile:
 	if (g_ShouldLogCommIn && (m_ReceivedData.GetReadableSpace() > 0))
 	{
@@ -1725,7 +1690,7 @@ bool cProtocol172::HandlePacket(cByteBuffer & a_ByteBuffer, UInt32 a_PacketType)
 void cProtocol172::HandlePacketStatusPing(cByteBuffer & a_ByteBuffer)
 {
 	HANDLE_READ(a_ByteBuffer, ReadBEInt64, Int64, Timestamp);
-	
+
 	cPacketizer Pkt(*this, 0x01);  // Ping packet
 	Pkt.WriteInt64(Timestamp);
 }
@@ -1937,7 +1902,7 @@ void cProtocol172::HandlePacketClientSettings(cByteBuffer & a_ByteBuffer)
 	HANDLE_READ(a_ByteBuffer, ReadByte,          Byte,    ShowCape);
 	
 	m_Client->SetLocale(Locale);
-	// TODO: handle in m_Client
+	// TODO: Do anything with the other values.
 }
 
 
@@ -2291,7 +2256,6 @@ void cProtocol172::SendData(const char * a_Data, size_t a_Size)
 
 
 
-
 bool cProtocol172::ReadItem(cByteBuffer & a_ByteBuffer, cItem & a_Item)
 {
 	HANDLE_PACKET_READ(a_ByteBuffer, ReadBEShort, short, ItemType);
@@ -2436,85 +2400,6 @@ void cProtocol172::StartEncryption(const Byte * a_Key)
 
 
 
-void cProtocol172::AddChatPartStyle(Json::Value & a_Value, const AString & a_PartStyle)
-{
-	size_t len = a_PartStyle.length();
-	for (size_t i = 0; i < len; i++)
-	{
-		switch (a_PartStyle[i])
-		{
-			case 'b':
-			{
-				// bold
-				a_Value["bold"] = Json::Value(true);
-				break;
-			}
-			
-			case 'i':
-			{
-				// italic
-				a_Value["italic"] = Json::Value(true);
-				break;
-			}
-			
-			case 'u':
-			{
-				// Underlined
-				a_Value["underlined"] = Json::Value(true);
-				break;
-			}
-			
-			case 's':
-			{
-				// strikethrough
-				a_Value["strikethrough"] = Json::Value(true);
-				break;
-			}
-			
-			case 'o':
-			{
-				// obfuscated
-				a_Value["obfuscated"] = Json::Value(true);
-				break;
-			}
-			
-			case '@':
-			{
-				// Color, specified by the next char:
-				i++;
-				if (i >= len)
-				{
-					// String too short, didn't contain a color
-					break;
-				}
-				switch (a_PartStyle[i])
-				{
-					case '0': a_Value["color"] = Json::Value("black");        break;
-					case '1': a_Value["color"] = Json::Value("dark_blue");    break;
-					case '2': a_Value["color"] = Json::Value("dark_green");   break;
-					case '3': a_Value["color"] = Json::Value("dark_aqua");    break;
-					case '4': a_Value["color"] = Json::Value("dark_red");     break;
-					case '5': a_Value["color"] = Json::Value("dark_purple");  break;
-					case '6': a_Value["color"] = Json::Value("gold");         break;
-					case '7': a_Value["color"] = Json::Value("gray");         break;
-					case '8': a_Value["color"] = Json::Value("dark_gray");    break;
-					case '9': a_Value["color"] = Json::Value("blue");         break;
-					case 'a': a_Value["color"] = Json::Value("green");        break;
-					case 'b': a_Value["color"] = Json::Value("aqua");         break;
-					case 'c': a_Value["color"] = Json::Value("red");          break;
-					case 'd': a_Value["color"] = Json::Value("light_purple"); break;
-					case 'e': a_Value["color"] = Json::Value("yellow");       break;
-					case 'f': a_Value["color"] = Json::Value("white");        break;
-				}  // switch (color)
-			}  // case '@'
-		}  // switch (Style[i])
-	}  // for i - a_PartStyle[]
-}
-
-
-
-
-
 ////////////////////////////////////////////////////////////////////////////////
 // cProtocol172::cPacketizer:
 
@@ -2524,6 +2409,7 @@ cProtocol172::cPacketizer::~cPacketizer()
 
 	// Send the packet length
 	UInt32 PacketLen = (UInt32)m_Out.GetUsedSpace();
+
 	m_Protocol.m_OutPacketLenBuffer.WriteVarInt(PacketLen);
 	m_Protocol.m_OutPacketLenBuffer.ReadAll(DataToSend);
 	m_Protocol.SendData(DataToSend.data(), DataToSend.size());
@@ -2618,6 +2504,7 @@ void cProtocol172::cPacketizer::WriteItem(const cItem & a_Item)
 		cFireworkItem::WriteToNBTCompound(a_Item.m_FireworkItem, Writer, (ENUM_ITEM_ID)a_Item.m_ItemType);
 	}
 	Writer.Finish();
+
 	AString Compressed;
 	CompressStringGZIP(Writer.GetResult().data(), Writer.GetResult().size(), Compressed);
 	WriteShort((short)Compressed.size());
@@ -2627,6 +2514,7 @@ void cProtocol172::cPacketizer::WriteItem(const cItem & a_Item)
 
 
 
+
 void cProtocol172::cPacketizer::WriteBlockEntity(const cBlockEntity & a_BlockEntity)
 {
 	cFastNBTWriter Writer;
@@ -2850,7 +2738,7 @@ void cProtocol172::cPacketizer::WriteEntityMetadata(const cEntity & a_Entity)
 			WriteByte(0xA2);
 			WriteItem(Frame.GetItem());
 			WriteByte(0x3);
-			WriteByte(Frame.GetRotation());
+			WriteByte(Frame.GetRotation() / 2);
 			break;
 		}
 		default: break;
@@ -2865,7 +2753,7 @@ void cProtocol172::cPacketizer::WriteMobMetadata(const cMonster & a_Mob)
 {
 	switch (a_Mob.GetMobType())
 	{
-		case cMonster::mtCreeper:
+		case mtCreeper:
 		{
 			WriteByte(0x10);
 			WriteByte(((const cCreeper &)a_Mob).IsBlowing() ? 1 : -1);
@@ -2874,28 +2762,28 @@ void cProtocol172::cPacketizer::WriteMobMetadata(const cMonster & a_Mob)
 			break;
 		}
 		
-		case cMonster::mtBat:
+		case mtBat:
 		{
 			WriteByte(0x10);
 			WriteByte(((const cBat &)a_Mob).IsHanging() ? 1 : 0);
 			break;
 		}
 		
-		case cMonster::mtPig:
+		case mtPig:
 		{
 			WriteByte(0x10);
 			WriteByte(((const cPig &)a_Mob).IsSaddled() ? 1 : 0);
 			break;
 		}
 		
-		case cMonster::mtVillager:
+		case mtVillager:
 		{
 			WriteByte(0x50);
 			WriteInt(((const cVillager &)a_Mob).GetVilType());
 			break;
 		}
 		
-		case cMonster::mtZombie:
+		case mtZombie:
 		{
 			WriteByte(0x0c);
 			WriteByte(((const cZombie &)a_Mob).IsBaby() ? 1 : 0);
@@ -2906,14 +2794,14 @@ void cProtocol172::cPacketizer::WriteMobMetadata(const cMonster & a_Mob)
 			break;
 		}
 		
-		case cMonster::mtGhast:
+		case mtGhast:
 		{
 			WriteByte(0x10);
 			WriteByte(((const cGhast &)a_Mob).IsCharging());
 			break;
 		}
 		
-		case cMonster::mtWolf:
+		case mtWolf:
 		{
 			const cWolf & Wolf = (const cWolf &)a_Mob;
 			Byte WolfStatus = 0;
@@ -2941,7 +2829,7 @@ void cProtocol172::cPacketizer::WriteMobMetadata(const cMonster & a_Mob)
 			break;
 		}
 		
-		case cMonster::mtSheep:
+		case mtSheep:
 		{
 			WriteByte(0x10);
 			Byte SheepMetadata = 0;
@@ -2954,7 +2842,7 @@ void cProtocol172::cPacketizer::WriteMobMetadata(const cMonster & a_Mob)
 			break;
 		}
 		
-		case cMonster::mtEnderman:
+		case mtEnderman:
 		{
 			WriteByte(0x10);
 			WriteByte((Byte)(((const cEnderman &)a_Mob).GetCarriedBlock()));
@@ -2965,21 +2853,21 @@ void cProtocol172::cPacketizer::WriteMobMetadata(const cMonster & a_Mob)
 			break;
 		}
 		
-		case cMonster::mtSkeleton:
+		case mtSkeleton:
 		{
 			WriteByte(0x0d);
 			WriteByte(((const cSkeleton &)a_Mob).IsWither() ? 1 : 0);
 			break;
 		}
 		
-		case cMonster::mtWitch:
+		case mtWitch:
 		{
 			WriteByte(0x15);
 			WriteByte(((const cWitch &)a_Mob).IsAngry() ? 1 : 0);
 			break;
 		}
 
-		case cMonster::mtWither:
+		case mtWither:
 		{
 			WriteByte(0x54);  // Int at index 20
 			WriteInt(((const cWither &)a_Mob).GetWitherInvulnerableTicks());
@@ -2988,21 +2876,21 @@ void cProtocol172::cPacketizer::WriteMobMetadata(const cMonster & a_Mob)
 			break;
 		}
 		
-		case cMonster::mtSlime:
+		case mtSlime:
 		{
 			WriteByte(0x10);
 			WriteByte(((const cSlime &)a_Mob).GetSize());
 			break;
 		}
 		
-		case cMonster::mtMagmaCube:
+		case mtMagmaCube:
 		{
 			WriteByte(0x10);
 			WriteByte(((const cMagmaCube &)a_Mob).GetSize());
 			break;
 		}
 		
-		case cMonster::mtHorse:
+		case mtHorse:
 		{
 			const cHorse & Horse = (const cHorse &)a_Mob;
 			int Flags = 0;
@@ -3048,6 +2936,15 @@ void cProtocol172::cPacketizer::WriteMobMetadata(const cMonster & a_Mob)
 			break;
 		}
 	}  // switch (a_Mob.GetType())
+
+	// Custom name:
+	if (a_Mob.HasCustomName())
+	{
+		WriteByte(0x8a);
+		WriteString(a_Mob.GetCustomName());
+		WriteByte(0x0b);
+		WriteByte(a_Mob.IsCustomNameAlwaysVisible() ? 1 : 0);
+	}
 }
 
 
@@ -3092,7 +2989,14 @@ void cProtocol176::SendPlayerSpawn(const cPlayer & a_Player)
 	cPacketizer Pkt(*this, 0x0c);  // Spawn Player packet
 	Pkt.WriteVarInt(a_Player.GetUniqueID());
 	Pkt.WriteString(cMojangAPI::MakeUUIDDashed(a_Player.GetClientHandle()->GetUUID()));
-	Pkt.WriteString(a_Player.GetName());
+	if (a_Player.HasCustomName())
+	{
+		Pkt.WriteString(a_Player.GetCustomName());
+	}
+	else
+	{
+		Pkt.WriteString(a_Player.GetName());
+	}
 
 	const Json::Value & Properties = a_Player.GetClientHandle()->GetProperties();
 	Pkt.WriteVarInt(Properties.size());
diff --git a/src/Protocol/Protocol17x.h b/src/Protocol/Protocol17x.h
index d3100d0fb..8f537f5d7 100644
--- a/src/Protocol/Protocol17x.h
+++ b/src/Protocol/Protocol17x.h
@@ -5,7 +5,8 @@
 Declares the 1.7.x protocol classes:
 	- cProtocol172
 		- release 1.7.2 protocol (#4)
-(others may be added later in the future for the 1.7 release series)
+	- cProtocol176
+		- release 1.7.6 protocol (#5)
 */
 
 
@@ -60,76 +61,80 @@ public:
 	virtual void DataReceived(const char * a_Data, size_t a_Size) override;
 
 	/** Sending stuff to clients (alphabetically sorted): */
-	virtual void SendAttachEntity        (const cEntity & a_Entity, const cEntity * a_Vehicle) override;
-	virtual void SendBlockAction         (int a_BlockX, int a_BlockY, int a_BlockZ, char a_Byte1, char a_Byte2, BLOCKTYPE a_BlockType) override;
-	virtual void SendBlockBreakAnim	     (int a_EntityID, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Stage) override;
-	virtual void SendBlockChange         (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) override;
-	virtual void SendBlockChanges        (int a_ChunkX, int a_ChunkZ, const sSetBlockVector & a_Changes) override;
-	virtual void SendChat                (const AString & a_Message) override;
-	virtual void SendChat                (const cCompositeChat & a_Message) override;
-	virtual void SendChunkData           (int a_ChunkX, int a_ChunkZ, cChunkDataSerializer & a_Serializer) override;
-	virtual void SendCollectEntity       (const cEntity & a_Entity, const cPlayer & a_Player) override;
-	virtual void SendDestroyEntity       (const cEntity & a_Entity) override;
-	virtual void SendDisconnect          (const AString & a_Reason) override;
-	virtual void SendDisplayObjective    (const AString & a_Objective, cScoreboard::eDisplaySlot a_Display) override;
-	virtual void SendEditSign            (int a_BlockX, int a_BlockY, int a_BlockZ) override;  ///< Request the client to open up the sign editor for the sign (1.6+)
-	virtual void SendEntityAnimation     (const cEntity & a_Entity, char a_Animation) override;
-	virtual void SendEntityEffect        (const cEntity & a_Entity, int a_EffectID, int a_Amplifier, short a_Duration) override;
-	virtual void SendEntityEquipment     (const cEntity & a_Entity, short a_SlotNum, const cItem & a_Item) override;
-	virtual void SendEntityHeadLook      (const cEntity & a_Entity) override;
-	virtual void SendEntityLook          (const cEntity & a_Entity) override;
-	virtual void SendEntityMetadata      (const cEntity & a_Entity) override;
-	virtual void SendEntityProperties    (const cEntity & a_Entity) override;
-	virtual void SendEntityRelMove       (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ) override;
-	virtual void SendEntityRelMoveLook   (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ) override;
-	virtual void SendEntityStatus        (const cEntity & a_Entity, char a_Status) override;
-	virtual void SendEntityVelocity      (const cEntity & a_Entity) override;
-	virtual void SendExperience          (void) override;
-	virtual void SendExperienceOrb       (const cExpOrb & a_ExpOrb) override;
-	virtual void SendExplosion           (double a_BlockX, double a_BlockY, double a_BlockZ, float a_Radius, const cVector3iArray & a_BlocksAffected, const Vector3d & a_PlayerMotion) override;
-	virtual void SendGameMode            (eGameMode a_GameMode) override;
-	virtual void SendHealth              (void) override;
-	virtual void SendInventorySlot       (char a_WindowID, short a_SlotNum, const cItem & a_Item) override;
-	virtual void SendKeepAlive           (int a_PingID) override;
-	virtual void SendLogin               (const cPlayer & a_Player, const cWorld & a_World) override;
-	virtual void SendLoginSuccess        (void) override;
-	virtual void SendMapColumn           (int a_ID, int a_X, int a_Y, const Byte * a_Colors, unsigned int a_Length) override;
-	virtual void SendMapDecorators       (int a_ID, const cMapDecoratorList & a_Decorators) override;
-	virtual void SendMapInfo             (int a_ID, unsigned int a_Scale) override;
-	virtual void SendPaintingSpawn       (const cPainting & a_Painting) override;
-	virtual void SendParticleEffect      (const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmmount) override;
-	virtual void SendPickupSpawn         (const cPickup & a_Pickup) override;
-	virtual void SendPlayerAbilities     (void) override;
-	virtual void SendPlayerListItem      (const cPlayer & a_Player, bool a_IsOnline) override;
-	virtual void SendPlayerMaxSpeed      (void) override;
-	virtual void SendPlayerMoveLook      (void) override;
-	virtual void SendPlayerPosition      (void) override;
-	virtual void SendPlayerSpawn         (const cPlayer & a_Player) override;
-	virtual void SendPluginMessage       (const AString & a_Channel, const AString & a_Message) override;
-	virtual void SendRemoveEntityEffect  (const cEntity & a_Entity, int a_EffectID) override;
-	virtual void SendRespawn             (eDimension a_Dimension, bool a_ShouldIgnoreDimensionChecks) override;
-	virtual void SendScoreUpdate         (const AString & a_Objective, const AString & a_Player, cObjective::Score a_Score, Byte a_Mode) override;
-	virtual void SendScoreboardObjective (const AString & a_Name, const AString & a_DisplayName, Byte a_Mode) override;
-	virtual void SendSoundEffect         (const AString & a_SoundName, double a_X, double a_Y, double a_Z, float a_Volume, float a_Pitch) override;
-	virtual void SendSoundParticleEffect (int a_EffectID, int a_SrcX, int a_SrcY, int a_SrcZ, int a_Data) override;
-	virtual void SendSpawnFallingBlock   (const cFallingBlock & a_FallingBlock) override;
-	virtual void SendSpawnMob            (const cMonster & a_Mob) override;
-	virtual void SendSpawnObject         (const cEntity & a_Entity, char a_ObjectType, int a_ObjectData, Byte a_Yaw, Byte a_Pitch) override;
-	virtual void SendSpawnVehicle        (const cEntity & a_Vehicle, char a_VehicleType, char a_VehicleSubType) override;
-	virtual void SendStatistics          (const cStatManager & a_Manager) override;
-	virtual void SendTabCompletionResults(const AStringVector & a_Results) override;
-	virtual void SendTeleportEntity      (const cEntity & a_Entity) override;
-	virtual void SendThunderbolt         (int a_BlockX, int a_BlockY, int a_BlockZ) override;
-	virtual void SendTimeUpdate          (Int64 a_WorldAge, Int64 a_TimeOfDay, bool a_DoDaylightCycle) override;
-	virtual void SendUnloadChunk         (int a_ChunkX, int a_ChunkZ) override;
-	virtual void SendUpdateBlockEntity   (cBlockEntity & a_BlockEntity) override;
-	virtual void SendUpdateSign          (int a_BlockX, int a_BlockY, int a_BlockZ, const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4) override;
-	virtual void SendUseBed              (const cEntity & a_Entity, int a_BlockX, int a_BlockY, int a_BlockZ) override;
-	virtual void SendWeather             (eWeather a_Weather) override;
-	virtual void SendWholeInventory      (const cWindow & a_Window) override;
-	virtual void SendWindowClose         (const cWindow & a_Window) override;
-	virtual void SendWindowOpen          (const cWindow & a_Window) override;
-	virtual void SendWindowProperty      (const cWindow & a_Window, int a_Property, int a_Value) override;
+	virtual void SendAttachEntity               (const cEntity & a_Entity, const cEntity * a_Vehicle) override;
+	virtual void SendBlockAction                (int a_BlockX, int a_BlockY, int a_BlockZ, char a_Byte1, char a_Byte2, BLOCKTYPE a_BlockType) override;
+	virtual void SendBlockBreakAnim	            (int a_EntityID, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Stage) override;
+	virtual void SendBlockChange                (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) override;
+	virtual void SendBlockChanges               (int a_ChunkX, int a_ChunkZ, const sSetBlockVector & a_Changes) override;
+	virtual void SendChat                       (const AString & a_Message) override;
+	virtual void SendChat                       (const cCompositeChat & a_Message) override;
+	virtual void SendChunkData                  (int a_ChunkX, int a_ChunkZ, cChunkDataSerializer & a_Serializer) override;
+	virtual void SendCollectEntity              (const cEntity & a_Entity, const cPlayer & a_Player) override;
+	virtual void SendDestroyEntity              (const cEntity & a_Entity) override;
+	virtual void SendDisconnect                 (const AString & a_Reason) override;
+	virtual void SendDisplayObjective           (const AString & a_Objective, cScoreboard::eDisplaySlot a_Display) override;
+	virtual void SendEditSign                   (int a_BlockX, int a_BlockY, int a_BlockZ) override;  ///< Request the client to open up the sign editor for the sign (1.6+)
+	virtual void SendEntityAnimation            (const cEntity & a_Entity, char a_Animation) override;
+	virtual void SendEntityEffect               (const cEntity & a_Entity, int a_EffectID, int a_Amplifier, short a_Duration) override;
+	virtual void SendEntityEquipment            (const cEntity & a_Entity, short a_SlotNum, const cItem & a_Item) override;
+	virtual void SendEntityHeadLook             (const cEntity & a_Entity) override;
+	virtual void SendEntityLook                 (const cEntity & a_Entity) override;
+	virtual void SendEntityMetadata             (const cEntity & a_Entity) override;
+	virtual void SendEntityProperties           (const cEntity & a_Entity) override;
+	virtual void SendEntityRelMove              (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ) override;
+	virtual void SendEntityRelMoveLook          (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ) override;
+	virtual void SendEntityStatus               (const cEntity & a_Entity, char a_Status) override;
+	virtual void SendEntityVelocity             (const cEntity & a_Entity) override;
+	virtual void SendExperience                 (void) override;
+	virtual void SendExperienceOrb              (const cExpOrb & a_ExpOrb) override;
+	virtual void SendExplosion                  (double a_BlockX, double a_BlockY, double a_BlockZ, float a_Radius, const cVector3iArray & a_BlocksAffected, const Vector3d & a_PlayerMotion) override;
+	virtual void SendGameMode                   (eGameMode a_GameMode) override;
+	virtual void SendHealth                     (void) override;
+	virtual void SendInventorySlot              (char a_WindowID, short a_SlotNum, const cItem & a_Item) override;
+	virtual void SendKeepAlive                  (int a_PingID) override;
+	virtual void SendLogin                      (const cPlayer & a_Player, const cWorld & a_World) override;
+	virtual void SendLoginSuccess               (void) override;
+	virtual void SendMapColumn                  (int a_ID, int a_X, int a_Y, const Byte * a_Colors, unsigned int a_Length, unsigned int m_Scale) override;
+	virtual void SendMapDecorators              (int a_ID, const cMapDecoratorList & a_Decorators, unsigned int m_Scale) override;
+	virtual void SendMapInfo                    (int a_ID, unsigned int a_Scale) override;
+	virtual void SendPaintingSpawn              (const cPainting & a_Painting) override;
+	virtual void SendParticleEffect             (const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmount) override;
+	virtual void SendPickupSpawn                (const cPickup & a_Pickup) override;
+	virtual void SendPlayerAbilities            (void) override;
+	virtual void SendPlayerListAddPlayer        (const cPlayer & a_Player) override;
+	virtual void SendPlayerListRemovePlayer     (const cPlayer & a_Player) override;
+	virtual void SendPlayerListUpdateGameMode   (const cPlayer & a_Player) override;
+	virtual void SendPlayerListUpdatePing       (const cPlayer & a_Player) override;
+	virtual void SendPlayerListUpdateDisplayName(const cPlayer & a_Player, const AString & a_CustomName) override;
+	virtual void SendPlayerMaxSpeed             (void) override;
+	virtual void SendPlayerMoveLook             (void) override;
+	virtual void SendPlayerPosition             (void) override;
+	virtual void SendPlayerSpawn                (const cPlayer & a_Player) override;
+	virtual void SendPluginMessage              (const AString & a_Channel, const AString & a_Message) override;
+	virtual void SendRemoveEntityEffect         (const cEntity & a_Entity, int a_EffectID) override;
+	virtual void SendRespawn                    (eDimension a_Dimension, bool a_ShouldIgnoreDimensionChecks) override;
+	virtual void SendScoreUpdate                (const AString & a_Objective, const AString & a_Player, cObjective::Score a_Score, Byte a_Mode) override;
+	virtual void SendScoreboardObjective        (const AString & a_Name, const AString & a_DisplayName, Byte a_Mode) override;
+	virtual void SendSoundEffect                (const AString & a_SoundName, double a_X, double a_Y, double a_Z, float a_Volume, float a_Pitch) override;
+	virtual void SendSoundParticleEffect        (int a_EffectID, int a_SrcX, int a_SrcY, int a_SrcZ, int a_Data) override;
+	virtual void SendSpawnFallingBlock          (const cFallingBlock & a_FallingBlock) override;
+	virtual void SendSpawnMob                   (const cMonster & a_Mob) override;
+	virtual void SendSpawnObject                (const cEntity & a_Entity, char a_ObjectType, int a_ObjectData, Byte a_Yaw, Byte a_Pitch) override;
+	virtual void SendSpawnVehicle               (const cEntity & a_Vehicle, char a_VehicleType, char a_VehicleSubType) override;
+	virtual void SendStatistics                 (const cStatManager & a_Manager) override;
+	virtual void SendTabCompletionResults       (const AStringVector & a_Results) override;
+	virtual void SendTeleportEntity             (const cEntity & a_Entity) override;
+	virtual void SendThunderbolt                (int a_BlockX, int a_BlockY, int a_BlockZ) override;
+	virtual void SendTimeUpdate                 (Int64 a_WorldAge, Int64 a_TimeOfDay, bool a_DoDaylightCycle) override;
+	virtual void SendUnloadChunk                (int a_ChunkX, int a_ChunkZ) override;
+	virtual void SendUpdateBlockEntity          (cBlockEntity & a_BlockEntity) override;
+	virtual void SendUpdateSign                 (int a_BlockX, int a_BlockY, int a_BlockZ, const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4) override;
+	virtual void SendUseBed                     (const cEntity & a_Entity, int a_BlockX, int a_BlockY, int a_BlockZ) override;
+	virtual void SendWeather                    (eWeather a_Weather) override;
+	virtual void SendWholeInventory             (const cWindow & a_Window) override;
+	virtual void SendWindowClose                (const cWindow & a_Window) override;
+	virtual void SendWindowOpen                 (const cWindow & a_Window) override;
+	virtual void SendWindowProperty             (const cWindow & a_Window, int a_Property, int a_Value) override;
 
 	virtual AString GetAuthServerID(void) override { return m_AuthServerID; }
 
@@ -251,19 +256,19 @@ protected:
 	
 	/** Adds the received (unencrypted) data to m_ReceivedData, parses complete packets */
 	void AddReceivedData(const char * a_Data, size_t a_Size);
-	
+
 	/** Reads and handles the packet. The packet length and type have already been read.
 	Returns true if the packet was understood, false if it was an unknown packet
 	*/
 	bool HandlePacket(cByteBuffer & a_ByteBuffer, UInt32 a_PacketType);
-	
+
 	// Packet handlers while in the Status state (m_State == 1):
-	void HandlePacketStatusPing   (cByteBuffer & a_ByteBuffer);
+	void HandlePacketStatusPing(cByteBuffer & a_ByteBuffer);
 	virtual void HandlePacketStatusRequest(cByteBuffer & a_ByteBuffer);
-	
+
 	// Packet handlers while in the Login state (m_State == 2):
 	void HandlePacketLoginEncryptionResponse(cByteBuffer & a_ByteBuffer);
-	void HandlePacketLoginStart             (cByteBuffer & a_ByteBuffer);
+	void HandlePacketLoginStart(cByteBuffer & a_ByteBuffer);
 	
 	// Packet handlers while in the Game state (m_State == 3):
 	void HandlePacketAnimation              (cByteBuffer & a_ByteBuffer);
@@ -300,15 +305,13 @@ protected:
 	void SendCompass(const cWorld & a_World);
 	
 	/** Reads an item out of the received data, sets a_Item to the values read. Returns false if not enough received data */
-	bool ReadItem(cByteBuffer & a_ByteBuffer, cItem & a_Item);
+	virtual bool ReadItem(cByteBuffer & a_ByteBuffer, cItem & a_Item);
 	
 	/** Parses item metadata as read by ReadItem(), into the item enchantments. */
 	void ParseItemMetadata(cItem & a_Item, const AString & a_Metadata);
 	
 	void StartEncryption(const Byte * a_Key);
-	
-	/** Adds the chat part's style (represented by the part's stylestring) into the Json object. */
-	void AddChatPartStyle(Json::Value & a_Value, const AString & a_PartStyle);
+
 } ;
 
 
diff --git a/src/Protocol/Protocol18x.cpp b/src/Protocol/Protocol18x.cpp
new file mode 100644
index 000000000..a2dbb7a1f
--- /dev/null
+++ b/src/Protocol/Protocol18x.cpp
@@ -0,0 +1,3270 @@
+
+// Protocol18x.cpp
+
+/*
+Implements the 1.8.x protocol classes:
+	- cProtocol180
+		- release 1.8.0 protocol (#47)
+(others may be added later in the future for the 1.8 release series)
+*/
+
+#include "Globals.h"
+#include "json/json.h"
+#include "Protocol18x.h"
+#include "ChunkDataSerializer.h"
+#include "PolarSSL++/Sha1Checksum.h"
+
+#include "../ClientHandle.h"
+#include "../Root.h"
+#include "../Server.h"
+#include "../World.h"
+#include "../StringCompression.h"
+#include "../CompositeChat.h"
+#include "../Statistics.h"
+
+#include "../WorldStorage/FastNBT.h"
+#include "../WorldStorage/EnchantmentSerializer.h"
+
+#include "../Entities/ExpOrb.h"
+#include "../Entities/Minecart.h"
+#include "../Entities/FallingBlock.h"
+#include "../Entities/Painting.h"
+#include "../Entities/Pickup.h"
+#include "../Entities/Player.h"
+#include "../Entities/ItemFrame.h"
+#include "../Entities/ArrowEntity.h"
+#include "../Entities/FireworkEntity.h"
+
+#include "../Mobs/IncludeAllMonsters.h"
+#include "../UI/Window.h"
+
+#include "../BlockEntities/BeaconEntity.h"
+#include "../BlockEntities/CommandBlockEntity.h"
+#include "../BlockEntities/MobHeadEntity.h"
+#include "../BlockEntities/FlowerPotEntity.h"
+#include "Bindings/PluginManager.h"
+
+
+
+
+
+#define HANDLE_READ(ByteBuf, Proc, Type, Var) \
+	Type Var; \
+	if (!ByteBuf.Proc(Var))\
+	{\
+		return;\
+	}
+
+
+
+
+
+#define HANDLE_PACKET_READ(ByteBuf, Proc, Type, Var) \
+	Type Var; \
+	{ \
+		if (!ByteBuf.Proc(Var)) \
+		{ \
+			ByteBuf.CheckValid(); \
+			return false; \
+		} \
+		ByteBuf.CheckValid(); \
+	}
+
+
+
+
+
+const int MAX_ENC_LEN = 512;  // Maximum size of the encrypted message; should be 128, but who knows...
+const uLongf MAX_COMPRESSED_PACKET_LEN = 200 KiB;  // Maximum size of compressed packets.
+
+
+
+
+
+// fwd: main.cpp:
+extern bool g_ShouldLogCommIn, g_ShouldLogCommOut;
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// cProtocol180:
+
+cProtocol180::cProtocol180(cClientHandle * a_Client, const AString & a_ServerAddress, UInt16 a_ServerPort, UInt32 a_State) :
+	super(a_Client),
+	m_ServerAddress(a_ServerAddress),
+	m_ServerPort(a_ServerPort),
+	m_State(a_State),
+	m_ReceivedData(32 KiB),
+	m_OutPacketBuffer(64 KiB),
+	m_OutPacketLenBuffer(20),  // 20 bytes is more than enough for one VarInt
+	m_IsEncrypted(false),
+	m_LastSentDimension(dimNotSet)
+{
+	// Create the comm log file, if so requested:
+	if (g_ShouldLogCommIn || g_ShouldLogCommOut)
+	{
+		static int sCounter = 0;
+		cFile::CreateFolder("CommLogs");
+		AString FileName = Printf("CommLogs/%x_%d__%s.log", (unsigned)time(NULL), sCounter++, a_Client->GetIPString().c_str());
+		m_CommLogFile.Open(FileName, cFile::fmWrite);
+	}
+}
+
+
+
+
+
+void cProtocol180::DataReceived(const char * a_Data, size_t a_Size)
+{
+	if (m_IsEncrypted)
+	{
+		Byte Decrypted[512];
+		while (a_Size > 0)
+		{
+			size_t NumBytes = (a_Size > sizeof(Decrypted)) ? sizeof(Decrypted) : a_Size;
+			m_Decryptor.ProcessData(Decrypted, (Byte *)a_Data, NumBytes);
+			AddReceivedData((const char *)Decrypted, NumBytes);
+			a_Size -= NumBytes;
+			a_Data += NumBytes;
+		}
+	}
+	else
+	{
+		AddReceivedData(a_Data, a_Size);
+	}
+}
+
+
+
+
+
+void cProtocol180::SendAttachEntity(const cEntity & a_Entity, const cEntity * a_Vehicle)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x1b);  // Attach Entity packet
+	Pkt.WriteInt(a_Entity.GetUniqueID());
+	Pkt.WriteInt((a_Vehicle != NULL) ? a_Vehicle->GetUniqueID() : 0);
+	Pkt.WriteBool(false);
+}
+
+
+
+
+
+void cProtocol180::SendBlockAction(int a_BlockX, int a_BlockY, int a_BlockZ, char a_Byte1, char a_Byte2, BLOCKTYPE a_BlockType)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x24);  // Block Action packet
+	Pkt.WritePosition(a_BlockX, a_BlockY, a_BlockZ);
+	Pkt.WriteByte(a_Byte1);
+	Pkt.WriteByte(a_Byte2);
+	Pkt.WriteVarInt(a_BlockType);
+}
+
+
+
+
+
+void cProtocol180::SendBlockBreakAnim(int a_EntityID, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Stage)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x25);  // Block Break Animation packet
+	Pkt.WriteVarInt(a_EntityID);
+	Pkt.WritePosition(a_BlockX, a_BlockY, a_BlockZ);
+	Pkt.WriteChar(a_Stage);
+}
+
+
+
+
+
+void cProtocol180::SendBlockChange(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
+{
+	ASSERT(m_State == 3);  // In game mode?
+
+	cPacketizer Pkt(*this, 0x23);  // Block Change packet
+	Pkt.WritePosition(a_BlockX, a_BlockY, a_BlockZ);
+	Pkt.WriteVarInt(((UInt32)a_BlockType << 4) | ((UInt32)a_BlockMeta & 15));
+}
+
+
+
+
+
+void cProtocol180::SendBlockChanges(int a_ChunkX, int a_ChunkZ, const sSetBlockVector & a_Changes)
+{
+	ASSERT(m_State == 3);  // In game mode?
+
+	cPacketizer Pkt(*this, 0x22);  // Multi Block Change packet
+	Pkt.WriteInt(a_ChunkX);
+	Pkt.WriteInt(a_ChunkZ);
+	Pkt.WriteVarInt((UInt32)a_Changes.size());
+	for (sSetBlockVector::const_iterator itr = a_Changes.begin(), end = a_Changes.end(); itr != end; ++itr)
+	{
+		short Coords = (short) (itr->y | (itr->z << 8) | (itr->x << 12));
+		Pkt.WriteShort(Coords);
+		Pkt.WriteVarInt((itr->BlockType & 0xFFF) << 4 | (itr->BlockMeta & 0xF));
+	}  // for itr - a_Changes[]
+}
+
+
+
+
+
+void cProtocol180::SendChat(const AString & a_Message)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x02);  // Chat Message packet
+	Pkt.WriteString(Printf("{\"text\":\"%s\"}", EscapeString(a_Message).c_str()));
+	Pkt.WriteChar(0);
+}
+
+
+
+
+
+void cProtocol180::SendChat(const cCompositeChat & a_Message)
+{
+	ASSERT(m_State == 3);  // In game mode?
+
+	cWorld * World = m_Client->GetPlayer()->GetWorld();
+	bool ShouldUseChatPrefixes = (World == NULL) ? false : World->ShouldUseChatPrefixes();
+
+	// Send the message to the client:
+	cPacketizer Pkt(*this, 0x02);
+	Pkt.WriteString(a_Message.CreateJsonString(ShouldUseChatPrefixes));
+	Pkt.WriteChar(0);
+}
+
+
+
+
+
+void cProtocol180::SendChunkData(int a_ChunkX, int a_ChunkZ, cChunkDataSerializer & a_Serializer)
+{
+	ASSERT(m_State == 3);  // In game mode?
+
+	// Serialize first, before creating the Packetizer (the packetizer locks a CS)
+	// This contains the flags and bitmasks, too
+	const AString & ChunkData = a_Serializer.Serialize(cChunkDataSerializer::RELEASE_1_8_0, a_ChunkX, a_ChunkZ);
+
+	cCSLock Lock(m_CSPacket);
+	SendData(ChunkData.data(), ChunkData.size());
+}
+
+
+
+
+
+void cProtocol180::SendCollectEntity(const cEntity & a_Entity, const cPlayer & a_Player)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x0d);  // Collect Item packet
+	Pkt.WriteVarInt(a_Entity.GetUniqueID());
+	Pkt.WriteVarInt(a_Player.GetUniqueID());
+}
+
+
+
+
+
+void cProtocol180::SendDestroyEntity(const cEntity & a_Entity)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x13);  // Destroy Entities packet
+	Pkt.WriteVarInt(1);
+	Pkt.WriteVarInt(a_Entity.GetUniqueID());
+}
+
+
+
+
+
+void cProtocol180::SendDisconnect(const AString & a_Reason)
+{
+	switch (m_State)
+	{
+		case 2:
+		{
+			// During login:
+			cPacketizer Pkt(*this, 0);
+			Pkt.WriteString(Printf("{\"text\":\"%s\"}", EscapeString(a_Reason).c_str()));
+			break;
+		}
+		case 3:
+		{
+			// In-game:
+			cPacketizer Pkt(*this, 0x40);
+			Pkt.WriteString(Printf("{\"text\":\"%s\"}", EscapeString(a_Reason).c_str()));
+			break;
+		}
+	}
+}
+
+
+
+
+
+void cProtocol180::SendEditSign(int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x36);  // Sign Editor Open packet
+	Pkt.WritePosition(a_BlockX, a_BlockY, a_BlockZ);
+}
+
+
+
+
+
+void cProtocol180::SendEntityEffect(const cEntity & a_Entity, int a_EffectID, int a_Amplifier, short a_Duration)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x1D);  // Entity Effect packet
+	Pkt.WriteVarInt(a_Entity.GetUniqueID());
+	Pkt.WriteByte(a_EffectID);
+	Pkt.WriteByte(a_Amplifier);
+	Pkt.WriteVarInt((UInt32)a_Duration);
+	Pkt.WriteBool(false);  // Hide particles
+}
+
+
+
+
+
+void cProtocol180::SendEntityEquipment(const cEntity & a_Entity, short a_SlotNum, const cItem & a_Item)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x04);  // Entity Equipment packet
+	Pkt.WriteVarInt((UInt32)a_Entity.GetUniqueID());
+	Pkt.WriteShort(a_SlotNum);
+	Pkt.WriteItem(a_Item);
+}
+
+
+
+
+
+void cProtocol180::SendEntityHeadLook(const cEntity & a_Entity)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x19);  // Entity Head Look packet
+	Pkt.WriteVarInt((UInt32)a_Entity.GetUniqueID());
+	Pkt.WriteByteAngle(a_Entity.GetHeadYaw());
+}
+
+
+
+
+
+void cProtocol180::SendEntityLook(const cEntity & a_Entity)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x16);  // Entity Look packet
+	Pkt.WriteVarInt(a_Entity.GetUniqueID());
+	Pkt.WriteByteAngle(a_Entity.GetYaw());
+	Pkt.WriteByteAngle(a_Entity.GetPitch());
+	Pkt.WriteBool(true);  // TODO: IsOnGround() on entities
+}
+
+
+
+
+
+void cProtocol180::SendEntityMetadata(const cEntity & a_Entity)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x1c);  // Entity Metadata packet
+	Pkt.WriteVarInt(a_Entity.GetUniqueID());
+	Pkt.WriteEntityMetadata(a_Entity);
+	Pkt.WriteByte(0x7f);  // The termination byte
+}
+
+
+
+
+
+void cProtocol180::SendEntityProperties(const cEntity & a_Entity)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x20);  // Entity Properties packet
+	Pkt.WriteVarInt(a_Entity.GetUniqueID());
+	Pkt.WriteEntityProperties(a_Entity);
+}
+
+
+
+
+
+void cProtocol180::SendEntityRelMove(const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x15);  // Entity Relative Move packet
+	Pkt.WriteVarInt(a_Entity.GetUniqueID());
+	Pkt.WriteByte(a_RelX);
+	Pkt.WriteByte(a_RelY);
+	Pkt.WriteByte(a_RelZ);
+	Pkt.WriteBool(true);  // TODO: IsOnGround() on entities
+}
+
+
+
+
+
+void cProtocol180::SendEntityRelMoveLook(const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x17);  // Entity Look And Relative Move packet
+	Pkt.WriteVarInt(a_Entity.GetUniqueID());
+	Pkt.WriteByte(a_RelX);
+	Pkt.WriteByte(a_RelY);
+	Pkt.WriteByte(a_RelZ);
+	Pkt.WriteByteAngle(a_Entity.GetYaw());
+	Pkt.WriteByteAngle(a_Entity.GetPitch());
+	Pkt.WriteBool(true);  // TODO: IsOnGround() on entities
+}
+
+
+
+
+
+void cProtocol180::SendEntityStatus(const cEntity & a_Entity, char a_Status)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x1a);  // Entity Status packet
+	Pkt.WriteInt(a_Entity.GetUniqueID());
+	Pkt.WriteChar(a_Status);
+}
+
+
+
+
+
+void cProtocol180::SendEntityVelocity(const cEntity & a_Entity)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x12);  // Entity Velocity packet
+	Pkt.WriteVarInt(a_Entity.GetUniqueID());
+	// 400 = 8000 / 20 ... Conversion from our speed in m/s to 8000 m/tick
+	Pkt.WriteShort((short)(a_Entity.GetSpeedX() * 400));
+	Pkt.WriteShort((short)(a_Entity.GetSpeedY() * 400));
+	Pkt.WriteShort((short)(a_Entity.GetSpeedZ() * 400));
+}
+
+
+
+
+
+void cProtocol180::SendExplosion(double a_BlockX, double a_BlockY, double a_BlockZ, float a_Radius, const cVector3iArray & a_BlocksAffected, const Vector3d & a_PlayerMotion)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x27);  // Explosion packet
+	Pkt.WriteFloat((float)a_BlockX);
+	Pkt.WriteFloat((float)a_BlockY);
+	Pkt.WriteFloat((float)a_BlockZ);
+	Pkt.WriteFloat((float)a_Radius);
+	Pkt.WriteInt((int)a_BlocksAffected.size());
+	for (cVector3iArray::const_iterator itr = a_BlocksAffected.begin(), end = a_BlocksAffected.end(); itr != end; ++itr)
+	{
+		Pkt.WriteChar((char)itr->x);
+		Pkt.WriteChar((char)itr->y);
+		Pkt.WriteChar((char)itr->z);
+	}  // for itr - a_BlockAffected[]
+	Pkt.WriteFloat((float)a_PlayerMotion.x);
+	Pkt.WriteFloat((float)a_PlayerMotion.y);
+	Pkt.WriteFloat((float)a_PlayerMotion.z);
+}
+
+
+
+
+
+void cProtocol180::SendGameMode(eGameMode a_GameMode)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x2b);  // Change Game State packet
+	Pkt.WriteByte(3);  // Reason: Change game mode
+	Pkt.WriteFloat((float)a_GameMode);
+}
+
+
+
+
+
+void cProtocol180::SendHealth(void)
+{
+	ASSERT(m_State == 3);  // In game mode?
+
+	cPacketizer Pkt(*this, 0x06);  // Update Health packet
+	cPlayer * Player = m_Client->GetPlayer();
+	Pkt.WriteFloat((float)Player->GetHealth());
+	Pkt.WriteVarInt((UInt32)Player->GetFoodLevel());
+	Pkt.WriteFloat((float)Player->GetFoodSaturationLevel());
+}
+
+
+
+
+
+void cProtocol180::SendInventorySlot(char a_WindowID, short a_SlotNum, const cItem & a_Item)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x2f);  // Set Slot packet
+	Pkt.WriteChar(a_WindowID);
+	Pkt.WriteShort(a_SlotNum);
+	Pkt.WriteItem(a_Item);
+}
+
+
+
+
+
+void cProtocol180::SendKeepAlive(int a_PingID)
+{
+	// Drop the packet if the protocol is not in the Game state yet (caused a client crash):
+	if (m_State != 3)
+	{
+		LOGWARNING("Trying to send a KeepAlive packet to a player who's not yet fully logged in (%d). The protocol class prevented the packet.", m_State);
+		return;
+	}
+	
+	cPacketizer Pkt(*this, 0x00);  // Keep Alive packet
+	Pkt.WriteVarInt(a_PingID);
+}
+
+
+
+
+
+void cProtocol180::SendLogin(const cPlayer & a_Player, const cWorld & a_World)
+{
+	// Send the Join Game packet:
+	{
+		cServer * Server = cRoot::Get()->GetServer();
+		cPacketizer Pkt(*this, 0x01);  // Join Game packet
+		Pkt.WriteInt(a_Player.GetUniqueID());
+		Pkt.WriteByte((Byte)a_Player.GetEffectiveGameMode() | (Server->IsHardcore() ? 0x08 : 0));  // Hardcore flag bit 4
+		Pkt.WriteChar((char)a_World.GetDimension());
+		Pkt.WriteByte(2);  // TODO: Difficulty (set to Normal)
+		Pkt.WriteByte(Server->GetMaxPlayers());
+		Pkt.WriteString("default");  // Level type - wtf?
+		Pkt.WriteBool(false);  // Reduced Debug Info - wtf?
+	}
+	m_LastSentDimension = a_World.GetDimension();
+	
+	// Send the spawn position:
+	{
+		cPacketizer Pkt(*this, 0x05);  // Spawn Position packet
+		Pkt.WritePosition((int)a_World.GetSpawnX(), (int)a_World.GetSpawnY(), (int)a_World.GetSpawnZ());
+	}
+
+	// Send the server difficulty:
+	{
+		cPacketizer Pkt(*this, 0x41);
+		Pkt.WriteChar(1);
+	}
+	
+	// Send player abilities:
+	SendPlayerAbilities();
+}
+
+
+
+
+void cProtocol180::SendLoginSuccess(void)
+{
+	ASSERT(m_State == 2);  // State: login?
+
+	// Enable compression:
+	{
+		cPacketizer Pkt(*this, 0x03);  // Set compression packet
+		Pkt.WriteVarInt(256);
+	}
+
+	m_State = 3;  // State = Game
+
+	{
+		cPacketizer Pkt(*this, 0x02);  // Login success packet
+		Pkt.WriteString(cMojangAPI::MakeUUIDDashed(m_Client->GetUUID()));
+		Pkt.WriteString(m_Client->GetUsername());
+	}
+}
+
+
+
+
+
+void cProtocol180::SendPaintingSpawn(const cPainting & a_Painting)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	double PosX = a_Painting.GetPosX();
+	double PosY = a_Painting.GetPosY();
+	double PosZ = a_Painting.GetPosZ();
+
+	switch (a_Painting.GetDirection())
+	{
+		case 0: PosZ += 1; break;
+		case 1: PosX -= 1; break;
+		case 2: PosZ -= 1; break;
+		case 3: PosX += 1; break;
+	}
+
+	cPacketizer Pkt(*this, 0x10);  // Spawn Painting packet
+	Pkt.WriteVarInt(a_Painting.GetUniqueID());
+	Pkt.WriteString(a_Painting.GetName().c_str());
+	Pkt.WritePosition((int)PosX, (int)PosY, (int)PosZ);
+	Pkt.WriteChar(a_Painting.GetDirection());
+}
+
+
+
+
+
+void cProtocol180::SendMapColumn(int a_ID, int a_X, int a_Y, const Byte * a_Colors, unsigned int a_Length, unsigned int m_Scale)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x34);
+	Pkt.WriteVarInt(a_ID);
+	Pkt.WriteByte(m_Scale);
+
+	Pkt.WriteVarInt(0);
+	Pkt.WriteByte(1);
+	Pkt.WriteByte(a_Length);
+	Pkt.WriteByte(a_X);
+	Pkt.WriteByte(a_Y);
+
+	Pkt.WriteVarInt(a_Length);
+	for (unsigned int i = 0; i < a_Length; ++i)
+	{
+		Pkt.WriteByte(a_Colors[i]);
+	}
+}
+
+
+
+
+
+void cProtocol180::SendMapDecorators(int a_ID, const cMapDecoratorList & a_Decorators, unsigned int m_Scale)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x34);
+	Pkt.WriteVarInt(a_ID);
+	Pkt.WriteByte(m_Scale);
+	Pkt.WriteVarInt(a_Decorators.size());
+
+	for (cMapDecoratorList::const_iterator it = a_Decorators.begin(); it != a_Decorators.end(); ++it)
+	{
+		Pkt.WriteByte((it->GetType() << 4) | (it->GetRot() & 0xf));
+		Pkt.WriteByte(it->GetPixelX());
+		Pkt.WriteByte(it->GetPixelZ());
+	}
+
+	Pkt.WriteByte(0);
+}
+
+
+
+
+
+void cProtocol180::SendMapInfo(int a_ID, unsigned int a_Scale)
+{
+	UNUSED(a_ID);
+	UNUSED(a_Scale);
+
+	// This packet was removed in 1.8
+}
+
+
+
+
+
+void cProtocol180::SendPickupSpawn(const cPickup & a_Pickup)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	{
+		cPacketizer Pkt(*this, 0x0e);  // Spawn Object packet
+		Pkt.WriteVarInt(a_Pickup.GetUniqueID());
+		Pkt.WriteByte(2);  // Type = Pickup
+		Pkt.WriteFPInt(a_Pickup.GetPosX());
+		Pkt.WriteFPInt(a_Pickup.GetPosY());
+		Pkt.WriteFPInt(a_Pickup.GetPosZ());
+		Pkt.WriteByteAngle(a_Pickup.GetYaw());
+		Pkt.WriteByteAngle(a_Pickup.GetPitch());
+		Pkt.WriteInt(0);  // No object data
+	}
+
+	{
+		cPacketizer Pkt(*this, 0x1c);  // Entity Metadata packet
+		Pkt.WriteVarInt(a_Pickup.GetUniqueID());
+		Pkt.WriteByte((0x05 << 5) | 10);  // Slot type + index 10
+		Pkt.WriteItem(a_Pickup.GetItem());
+		Pkt.WriteByte(0x7f);  // End of metadata
+	}
+}
+
+
+
+
+
+void cProtocol180::SendPlayerAbilities(void)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x39);  // Player Abilities packet
+	Byte Flags = 0;
+	cPlayer * Player = m_Client->GetPlayer();
+	if (Player->IsGameModeCreative())
+	{
+		Flags |= 0x01;
+		Flags |= 0x08;  // Godmode, used for creative
+	}
+	if (Player->IsFlying())
+	{
+		Flags |= 0x02;
+	}
+	if (Player->CanFly())
+	{
+		Flags |= 0x04;
+	}
+	Pkt.WriteByte(Flags);
+	Pkt.WriteFloat((float)(0.05 * Player->GetFlyingMaxSpeed()));
+	Pkt.WriteFloat((float)(0.1 * Player->GetNormalMaxSpeed()));
+}
+
+
+
+
+
+void cProtocol180::SendEntityAnimation(const cEntity & a_Entity, char a_Animation)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x0b);  // Animation packet
+	Pkt.WriteVarInt(a_Entity.GetUniqueID());
+	Pkt.WriteChar(a_Animation);
+}
+
+
+
+
+
+void cProtocol180::SendParticleEffect(const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmount)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	int ParticleID = GetParticleID(a_ParticleName);
+
+	cPacketizer Pkt(*this, 0x2A);
+	Pkt.WriteInt(ParticleID);
+	Pkt.WriteBool(false);
+	Pkt.WriteFloat(a_SrcX);
+	Pkt.WriteFloat(a_SrcY);
+	Pkt.WriteFloat(a_SrcZ);
+	Pkt.WriteFloat(a_OffsetX);
+	Pkt.WriteFloat(a_OffsetY);
+	Pkt.WriteFloat(a_OffsetZ);
+	Pkt.WriteFloat(a_ParticleData);
+	Pkt.WriteInt(a_ParticleAmount);
+}
+
+
+
+
+
+void cProtocol180::SendPlayerListAddPlayer(const cPlayer & a_Player)
+{
+	ASSERT(m_State == 3);  // In game mode?
+
+	cPacketizer Pkt(*this, 0x38);  // Playerlist Item packet
+	Pkt.WriteVarInt(0);
+	Pkt.WriteVarInt(1);
+	Pkt.WriteUUID(a_Player.GetUUID());
+	Pkt.WriteString(a_Player.GetPlayerListName());
+
+	const Json::Value & Properties = a_Player.GetClientHandle()->GetProperties();
+	Pkt.WriteVarInt(Properties.size());
+	for (Json::Value::iterator itr = Properties.begin(), end = Properties.end(); itr != end; ++itr)
+	{
+		Pkt.WriteString(((Json::Value)*itr).get("name", "").asString());
+		Pkt.WriteString(((Json::Value)*itr).get("value", "").asString());
+		AString Signature = ((Json::Value)*itr).get("signature", "").asString();
+		if (Signature.empty())
+		{
+			Pkt.WriteBool(false);
+		}
+		else
+		{
+			Pkt.WriteBool(true);
+			Pkt.WriteString(Signature);
+		}
+	}
+
+	Pkt.WriteVarInt((UInt32)a_Player.GetGameMode());
+	Pkt.WriteVarInt((UInt32)a_Player.GetClientHandle()->GetPing());
+	Pkt.WriteBool(false);
+}
+
+
+
+
+
+void cProtocol180::SendPlayerListRemovePlayer(const cPlayer & a_Player)
+{
+	ASSERT(m_State == 3);  // In game mode?
+
+	cPacketizer Pkt(*this, 0x38);  // Playerlist Item packet
+	Pkt.WriteVarInt(4);
+	Pkt.WriteVarInt(1);
+	Pkt.WriteUUID(a_Player.GetUUID());
+}
+
+
+
+
+
+void cProtocol180::SendPlayerListUpdateGameMode(const cPlayer & a_Player)
+{
+	ASSERT(m_State == 3);  // In game mode?
+
+	cPacketizer Pkt(*this, 0x38);  // Playerlist Item packet
+	Pkt.WriteVarInt(1);
+	Pkt.WriteVarInt(1);
+	Pkt.WriteUUID(a_Player.GetUUID());
+	Pkt.WriteVarInt((UInt32)a_Player.GetGameMode());
+}
+
+
+
+
+
+void cProtocol180::SendPlayerListUpdatePing(const cPlayer & a_Player)
+{
+	ASSERT(m_State == 3);  // In game mode?
+
+	cPacketizer Pkt(*this, 0x38);  // Playerlist Item packet
+	Pkt.WriteVarInt(2);
+	Pkt.WriteVarInt(1);
+	Pkt.WriteUUID(a_Player.GetUUID());
+	Pkt.WriteVarInt((UInt32)a_Player.GetClientHandle()->GetPing());
+}
+
+
+
+
+
+void cProtocol180::SendPlayerListUpdateDisplayName(const cPlayer & a_Player, const AString & a_CustomName)
+{
+	ASSERT(m_State == 3);  // In game mode?
+
+	cPacketizer Pkt(*this, 0x38);  // Playerlist Item packet
+	Pkt.WriteVarInt(3);
+	Pkt.WriteVarInt(1);
+	Pkt.WriteUUID(a_Player.GetUUID());
+
+	if (a_CustomName.empty())
+	{
+		Pkt.WriteBool(false);
+	}
+	else
+	{
+		Pkt.WriteBool(true);
+		Pkt.WriteString(Printf("{\"text\":\"%s\"}", a_CustomName.c_str()));
+	}
+}
+
+
+
+
+
+void cProtocol180::SendPlayerMaxSpeed(void)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x20);  // Entity Properties
+	cPlayer * Player = m_Client->GetPlayer();
+	Pkt.WriteVarInt(Player->GetUniqueID());
+	Pkt.WriteInt(1);  // Count
+	Pkt.WriteString("generic.movementSpeed");
+	// The default game speed is 0.1, multiply that value by the relative speed:
+	Pkt.WriteDouble(0.1 * Player->GetNormalMaxSpeed());
+	if (Player->IsSprinting())
+	{
+		Pkt.WriteVarInt(1);  // Modifier count
+		Pkt.WriteInt64(0x662a6b8dda3e4c1c);
+		Pkt.WriteInt64(0x881396ea6097278d);  // UUID of the modifier
+		Pkt.WriteDouble(Player->GetSprintingMaxSpeed() - Player->GetNormalMaxSpeed());
+		Pkt.WriteByte(2);
+	}
+	else
+	{
+		Pkt.WriteVarInt(0);  // Modifier count
+	}
+}
+
+
+
+
+
+void cProtocol180::SendPlayerMoveLook(void)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x08);  // Player Position And Look packet
+	cPlayer * Player = m_Client->GetPlayer();
+	Pkt.WriteDouble(Player->GetPosX());
+	
+	// The "+ 0.001" is there because otherwise the player falls through the block they were standing on.
+	Pkt.WriteDouble(Player->GetStance() + 0.001);
+	
+	Pkt.WriteDouble(Player->GetPosZ());
+	Pkt.WriteFloat((float)Player->GetYaw());
+	Pkt.WriteFloat((float)Player->GetPitch());
+	Pkt.WriteByte(0);
+}
+
+
+
+
+
+void cProtocol180::SendPlayerPosition(void)
+{
+	// There is no dedicated packet for this, send the whole thing:
+	SendPlayerMoveLook();
+}
+
+
+
+
+
+void cProtocol180::SendPlayerSpawn(const cPlayer & a_Player)
+{
+	// Called to spawn another player for the client
+	cPacketizer Pkt(*this, 0x0c);  // Spawn Player packet
+	Pkt.WriteVarInt(a_Player.GetUniqueID());
+	Pkt.WriteUUID(cMojangAPI::MakeUUIDShort(a_Player.GetUUID()));
+	Pkt.WriteFPInt(a_Player.GetPosX());
+	Pkt.WriteFPInt(a_Player.GetPosY());
+	Pkt.WriteFPInt(a_Player.GetPosZ());
+	Pkt.WriteByteAngle(a_Player.GetYaw());
+	Pkt.WriteByteAngle(a_Player.GetPitch());
+	short ItemType = a_Player.GetEquippedItem().IsEmpty() ? 0 : a_Player.GetEquippedItem().m_ItemType;
+	Pkt.WriteShort(ItemType);
+	Pkt.WriteByte((3 << 5) | 6);  // Metadata: float + index 6
+	Pkt.WriteFloat((float)a_Player.GetHealth());
+	Pkt.WriteByte((4 << 5 | (2 & 0x1F)) & 0xFF);
+	Pkt.WriteString(a_Player.GetName());
+	Pkt.WriteByte(0x7f);  // Metadata: end
+}
+
+
+
+
+
+void cProtocol180::SendPluginMessage(const AString & a_Channel, const AString & a_Message)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x3f);
+	Pkt.WriteString(a_Channel);
+	Pkt.WriteVarInt((UInt32)a_Message.size());
+	Pkt.WriteBuf(a_Message.data(), a_Message.size());
+}
+
+
+
+
+
+void cProtocol180::SendRemoveEntityEffect(const cEntity & a_Entity, int a_EffectID)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x1e);
+	Pkt.WriteVarInt(a_Entity.GetUniqueID());
+	Pkt.WriteByte(a_EffectID);
+}
+
+
+
+
+
+void cProtocol180::SendRespawn(eDimension a_Dimension, bool a_ShouldIgnoreDimensionChecks)
+{
+	if ((m_LastSentDimension == a_Dimension) && !a_ShouldIgnoreDimensionChecks)
+	{
+		// Must not send a respawn for the world with the same dimension, the client goes cuckoo if we do (unless we are respawning from death)
+		return;
+	}
+
+	cPacketizer Pkt(*this, 0x07);  // Respawn packet
+	cPlayer * Player = m_Client->GetPlayer();
+	Pkt.WriteInt((int)a_Dimension);
+	Pkt.WriteByte(2);  // TODO: Difficulty (set to Normal)
+	Pkt.WriteByte((Byte)Player->GetEffectiveGameMode());
+	Pkt.WriteString("default");
+	m_LastSentDimension = a_Dimension;
+}
+
+
+
+
+
+void cProtocol180::SendExperience(void)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x1f);  // Experience Packet
+	cPlayer * Player = m_Client->GetPlayer();
+	Pkt.WriteFloat(Player->GetXpPercentage());
+	Pkt.WriteVarInt((UInt32)Player->GetXpLevel());
+	Pkt.WriteVarInt((UInt32)Player->GetCurrentXp());
+}
+
+
+
+
+
+void cProtocol180::SendExperienceOrb(const cExpOrb & a_ExpOrb)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x11);
+	Pkt.WriteVarInt(a_ExpOrb.GetUniqueID());
+	Pkt.WriteFPInt(a_ExpOrb.GetPosX());
+	Pkt.WriteFPInt(a_ExpOrb.GetPosY());
+	Pkt.WriteFPInt(a_ExpOrb.GetPosZ());
+	Pkt.WriteShort(a_ExpOrb.GetReward());
+}
+
+
+
+
+
+void cProtocol180::SendScoreboardObjective(const AString & a_Name, const AString & a_DisplayName, Byte a_Mode)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x3b);
+	Pkt.WriteString(a_Name);
+	Pkt.WriteByte(a_Mode);
+	if ((a_Mode == 0) || (a_Mode == 2))
+	{
+		Pkt.WriteString(a_DisplayName);
+		Pkt.WriteString("integer");
+	}
+}
+
+
+
+
+
+void cProtocol180::SendScoreUpdate(const AString & a_Objective, const AString & a_Player, cObjective::Score a_Score, Byte a_Mode)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x3c);
+	Pkt.WriteString(a_Player);
+	Pkt.WriteByte(a_Mode);
+	Pkt.WriteString(a_Objective);
+
+	if (a_Mode != 1)
+	{
+		Pkt.WriteVarInt((UInt32) a_Score);
+	}
+}
+
+
+
+
+
+void cProtocol180::SendDisplayObjective(const AString & a_Objective, cScoreboard::eDisplaySlot a_Display)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x3d);
+	Pkt.WriteByte((int) a_Display);
+	Pkt.WriteString(a_Objective);
+}
+
+
+
+
+
+void cProtocol180::SendSoundEffect(const AString & a_SoundName, double a_X, double a_Y, double a_Z, float a_Volume, float a_Pitch)
+{
+	ASSERT(m_State == 3);  // In game mode?
+
+	cPacketizer Pkt(*this, 0x29);  // Sound Effect packet
+	Pkt.WriteString(a_SoundName);
+	Pkt.WriteInt((int)(a_X * 8.0));
+	Pkt.WriteInt((int)(a_Y * 8.0));
+	Pkt.WriteInt((int)(a_Z * 8.0));
+	Pkt.WriteFloat(a_Volume);
+	Pkt.WriteByte((Byte)(a_Pitch * 63));
+}
+
+
+
+
+
+void cProtocol180::SendSoundParticleEffect(int a_EffectID, int a_SrcX, int a_SrcY, int a_SrcZ, int a_Data)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x28);  // Effect packet
+	Pkt.WriteInt(a_EffectID);
+	Pkt.WritePosition(a_SrcX, a_SrcY, a_SrcZ);
+	Pkt.WriteInt(a_Data);
+	Pkt.WriteBool(false);
+}
+
+
+
+
+
+void cProtocol180::SendSpawnFallingBlock(const cFallingBlock & a_FallingBlock)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x0e);  // Spawn Object packet
+	Pkt.WriteVarInt(a_FallingBlock.GetUniqueID());
+	Pkt.WriteByte(70);  // Falling block
+	Pkt.WriteFPInt(a_FallingBlock.GetPosX());
+	Pkt.WriteFPInt(a_FallingBlock.GetPosY());
+	Pkt.WriteFPInt(a_FallingBlock.GetPosZ());
+	Pkt.WriteByteAngle(a_FallingBlock.GetYaw());
+	Pkt.WriteByteAngle(a_FallingBlock.GetPitch());
+	Pkt.WriteInt(((int)a_FallingBlock.GetBlockType()) | (((int)a_FallingBlock.GetBlockMeta()) << 12));
+	Pkt.WriteShort((short)(a_FallingBlock.GetSpeedX() * 400));
+	Pkt.WriteShort((short)(a_FallingBlock.GetSpeedY() * 400));
+	Pkt.WriteShort((short)(a_FallingBlock.GetSpeedZ() * 400));
+}
+
+
+
+
+
+void cProtocol180::SendSpawnMob(const cMonster & a_Mob)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x0f);  // Spawn Mob packet
+	Pkt.WriteVarInt(a_Mob.GetUniqueID());
+	Pkt.WriteByte((Byte)a_Mob.GetMobType());
+	Pkt.WriteFPInt(a_Mob.GetPosX());
+	Pkt.WriteFPInt(a_Mob.GetPosY());
+	Pkt.WriteFPInt(a_Mob.GetPosZ());
+	Pkt.WriteByteAngle(a_Mob.GetPitch());
+	Pkt.WriteByteAngle(a_Mob.GetHeadYaw());
+	Pkt.WriteByteAngle(a_Mob.GetYaw());
+	Pkt.WriteShort((short)(a_Mob.GetSpeedX() * 400));
+	Pkt.WriteShort((short)(a_Mob.GetSpeedY() * 400));
+	Pkt.WriteShort((short)(a_Mob.GetSpeedZ() * 400));
+	Pkt.WriteEntityMetadata(a_Mob);
+	Pkt.WriteByte(0x7f);  // Metadata terminator
+}
+
+
+
+
+
+void cProtocol180::SendSpawnObject(const cEntity & a_Entity, char a_ObjectType, int a_ObjectData, Byte a_Yaw, Byte a_Pitch)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	double PosX = a_Entity.GetPosX();
+	double PosZ = a_Entity.GetPosZ();
+	double Yaw = a_Entity.GetYaw();
+	if (a_ObjectType == 71)
+	{
+		FixItemFramePositions(a_ObjectData, PosX, PosZ, Yaw);
+	}
+
+	cPacketizer Pkt(*this, 0xe);  // Spawn Object packet
+	Pkt.WriteVarInt(a_Entity.GetUniqueID());
+	Pkt.WriteByte(a_ObjectType);
+	Pkt.WriteFPInt(PosX);
+	Pkt.WriteFPInt(a_Entity.GetPosY());
+	Pkt.WriteFPInt(PosZ);
+	Pkt.WriteByteAngle(a_Entity.GetPitch());
+	Pkt.WriteByteAngle(Yaw);
+	Pkt.WriteInt(a_ObjectData);
+	if (a_ObjectData != 0)
+	{
+		Pkt.WriteShort((short)(a_Entity.GetSpeedX() * 400));
+		Pkt.WriteShort((short)(a_Entity.GetSpeedY() * 400));
+		Pkt.WriteShort((short)(a_Entity.GetSpeedZ() * 400));
+	}
+}
+
+
+
+
+
+void cProtocol180::SendSpawnVehicle(const cEntity & a_Vehicle, char a_VehicleType, char a_VehicleSubType)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0xe);  // Spawn Object packet
+	Pkt.WriteVarInt(a_Vehicle.GetUniqueID());
+	Pkt.WriteByte(a_VehicleType);
+	Pkt.WriteFPInt(a_Vehicle.GetPosX());
+	Pkt.WriteFPInt(a_Vehicle.GetPosY());
+	Pkt.WriteFPInt(a_Vehicle.GetPosZ());
+	Pkt.WriteByteAngle(a_Vehicle.GetPitch());
+	Pkt.WriteByteAngle(a_Vehicle.GetYaw());
+	Pkt.WriteInt(a_VehicleSubType);
+	if (a_VehicleSubType != 0)
+	{
+		Pkt.WriteShort((short)(a_Vehicle.GetSpeedX() * 400));
+		Pkt.WriteShort((short)(a_Vehicle.GetSpeedY() * 400));
+		Pkt.WriteShort((short)(a_Vehicle.GetSpeedZ() * 400));
+	}
+}
+
+
+
+
+
+void cProtocol180::SendStatistics(const cStatManager & a_Manager)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x37);
+	Pkt.WriteVarInt(statCount);  // TODO 2014-05-11 xdot: Optimization: Send "dirty" statistics only
+
+	for (size_t i = 0; i < (size_t)statCount; ++i)
+	{
+		StatValue Value = a_Manager.GetValue((eStatistic) i);
+		const AString & StatName = cStatInfo::GetName((eStatistic) i);
+
+		Pkt.WriteString(StatName);
+		Pkt.WriteVarInt(Value);
+	}
+}
+
+
+
+
+
+void cProtocol180::SendTabCompletionResults(const AStringVector & a_Results)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x3a);  // Tab-Complete packet
+	Pkt.WriteVarInt((int)a_Results.size());
+
+	for (AStringVector::const_iterator itr = a_Results.begin(), end = a_Results.end(); itr != end; ++itr)
+	{
+		Pkt.WriteString(*itr);
+	}
+}
+
+
+
+
+
+void cProtocol180::SendTeleportEntity(const cEntity & a_Entity)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x18);
+	Pkt.WriteVarInt(a_Entity.GetUniqueID());
+	Pkt.WriteFPInt(a_Entity.GetPosX());
+	Pkt.WriteFPInt(a_Entity.GetPosY());
+	Pkt.WriteFPInt(a_Entity.GetPosZ());
+	Pkt.WriteByteAngle(a_Entity.GetYaw());
+	Pkt.WriteByteAngle(a_Entity.GetPitch());
+	Pkt.WriteBool(true);  // TODO: IsOnGrond() on entities
+}
+
+
+
+
+
+void cProtocol180::SendThunderbolt(int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x2c);  // Spawn Global Entity packet
+	Pkt.WriteVarInt(0);  // EntityID = 0, always
+	Pkt.WriteByte(1);  // Type = Thunderbolt
+	Pkt.WriteFPInt(a_BlockX);
+	Pkt.WriteFPInt(a_BlockY);
+	Pkt.WriteFPInt(a_BlockZ);
+}
+
+
+
+
+
+void cProtocol180::SendTimeUpdate(Int64 a_WorldAge, Int64 a_TimeOfDay, bool a_DoDaylightCycle)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	if (!a_DoDaylightCycle)
+	{
+		// When writing a "-" before the number the client ignores it but it will stop the client-side time expiration.
+		a_TimeOfDay = std::min(-a_TimeOfDay, -1LL);
+	}
+	
+	cPacketizer Pkt(*this, 0x03);
+	Pkt.WriteInt64(a_WorldAge);
+	Pkt.WriteInt64(a_TimeOfDay);
+}
+
+
+
+
+
+void cProtocol180::SendUnloadChunk(int a_ChunkX, int a_ChunkZ)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x21);  // Chunk Data packet
+	Pkt.WriteInt(a_ChunkX);
+	Pkt.WriteInt(a_ChunkZ);
+	Pkt.WriteBool(true);
+	Pkt.WriteShort(0);  // Primary bitmap
+	Pkt.WriteVarInt(0);  // Data size
+}
+
+
+
+
+void cProtocol180::SendUpdateBlockEntity(cBlockEntity & a_BlockEntity)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x35);  // Update tile entity packet
+	Pkt.WritePosition(a_BlockEntity.GetPosX(), a_BlockEntity.GetPosY(), a_BlockEntity.GetPosZ());
+
+	Byte Action = 0;
+	switch (a_BlockEntity.GetBlockType())
+	{
+		case E_BLOCK_MOB_SPAWNER:   Action = 1; break;  // Update mob spawner spinny mob thing
+		case E_BLOCK_COMMAND_BLOCK: Action = 2; break;  // Update command block text
+		case E_BLOCK_BEACON:        Action = 3; break;  // Update beacon entity
+		case E_BLOCK_HEAD:          Action = 4; break;  // Update Mobhead entity
+		case E_BLOCK_FLOWER_POT:    Action = 5; break;  // Update flower pot
+		default: ASSERT(!"Unhandled or unimplemented BlockEntity update request!"); break;
+	}
+	Pkt.WriteByte(Action);
+
+	Pkt.WriteBlockEntity(a_BlockEntity);
+}
+
+
+
+
+
+void cProtocol180::SendUpdateSign(int a_BlockX, int a_BlockY, int a_BlockZ, const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4)
+{
+	ASSERT(m_State == 3);  // In game mode?
+
+	cPacketizer Pkt(*this, 0x33);
+	Pkt.WritePosition(a_BlockX, a_BlockY, a_BlockZ);
+
+	Json::StyledWriter JsonWriter;
+	AString Lines[] = { a_Line1, a_Line2, a_Line3, a_Line4 };
+	for (size_t i = 0; i < ARRAYCOUNT(Lines); i++)
+	{
+		Json::Value RootValue;
+		RootValue["text"] = Lines[i];
+		Pkt.WriteString(JsonWriter.write(RootValue).c_str());
+	}
+}
+
+
+
+
+
+void cProtocol180::SendUseBed(const cEntity & a_Entity, int a_BlockX, int a_BlockY, int a_BlockZ)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x0a);
+	Pkt.WriteVarInt(a_Entity.GetUniqueID());
+	Pkt.WritePosition(a_BlockX, a_BlockY, a_BlockZ);
+}
+
+
+
+
+
+void cProtocol180::SendWeather(eWeather a_Weather)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	{
+		cPacketizer Pkt(*this, 0x2b);  // Change Game State packet
+		Pkt.WriteByte((a_Weather == wSunny) ? 1 : 2);  // End rain / begin rain
+		Pkt.WriteFloat(0);  // Unused for weather
+	}
+
+	// TODO: Fade effect, somehow
+}
+
+
+
+
+
+void cProtocol180::SendWholeInventory(const cWindow & a_Window)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x30);  // Window Items packet
+	Pkt.WriteChar(a_Window.GetWindowID());
+	Pkt.WriteShort(a_Window.GetNumSlots());
+	cItems Slots;
+	a_Window.GetSlots(*(m_Client->GetPlayer()), Slots);
+	for (cItems::const_iterator itr = Slots.begin(), end = Slots.end(); itr != end; ++itr)
+	{
+		Pkt.WriteItem(*itr);
+	}  // for itr - Slots[]
+}
+
+
+
+
+
+void cProtocol180::SendWindowClose(const cWindow & a_Window)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x2e);
+	Pkt.WriteChar(a_Window.GetWindowID());
+}
+
+
+
+
+
+void cProtocol180::SendWindowOpen(const cWindow & a_Window)
+{
+	ASSERT(m_State == 3);  // In game mode?
+
+	if (a_Window.GetWindowType() < 0)
+	{
+		// Do not send this packet for player inventory windows
+		return;
+	}
+
+	cPacketizer Pkt(*this, 0x2d);
+	Pkt.WriteChar(a_Window.GetWindowID());
+	Pkt.WriteString(a_Window.GetWindowTypeName());
+	Pkt.WriteString(Printf("{\"text\":\"%s\"}", a_Window.GetWindowTitle().c_str()));
+
+	switch (a_Window.GetWindowType())
+	{
+		case cWindow::wtWorkbench:
+		case cWindow::wtEnchantment:
+		case cWindow::wtAnvil:
+		{
+			Pkt.WriteChar(0);
+			break;
+		}
+		default:
+		{
+			Pkt.WriteChar(a_Window.GetNumNonInventorySlots());
+			break;
+		}
+	}
+
+	if (a_Window.GetWindowType() == cWindow::wtAnimalChest)
+	{
+		Pkt.WriteInt(0);  // TODO: The animal's EntityID
+	}
+}
+
+
+
+
+
+void cProtocol180::SendWindowProperty(const cWindow & a_Window, int a_Property, int a_Value)
+{
+	ASSERT(m_State == 3);  // In game mode?
+	
+	cPacketizer Pkt(*this, 0x31);  // Window Property packet
+	Pkt.WriteChar(a_Window.GetWindowID());
+	Pkt.WriteShort(a_Property);
+	Pkt.WriteShort(a_Value);
+}
+
+
+
+
+
+bool cProtocol180::CompressPacket(const AString & a_Packet, AString & a_CompressedData)
+{
+	// Compress the data:
+	char CompressedData[MAX_COMPRESSED_PACKET_LEN];
+
+	uLongf CompressedSize = compressBound(a_Packet.size());
+	if (CompressedSize >= MAX_COMPRESSED_PACKET_LEN)
+	{
+		ASSERT(!"Too high packet size.");
+		return false;
+	}
+
+	int Status = compress2((Bytef*)CompressedData, &CompressedSize, (const Bytef*)a_Packet.data(), a_Packet.size(), Z_DEFAULT_COMPRESSION);
+	if (Status != Z_OK)
+	{
+		return false;
+	}
+
+	AString LengthData;
+	cByteBuffer Buffer(20);
+	Buffer.WriteVarInt((UInt32)a_Packet.size());
+	Buffer.ReadAll(LengthData);
+	Buffer.CommitRead();
+
+	Buffer.WriteVarInt(CompressedSize + LengthData.size());
+	Buffer.WriteVarInt(a_Packet.size());
+	Buffer.ReadAll(LengthData);
+	Buffer.CommitRead();
+
+	a_CompressedData.clear();
+	a_CompressedData.reserve(LengthData.size() + CompressedSize);
+	a_CompressedData.append(LengthData.data(), LengthData.size());
+	a_CompressedData.append(CompressedData, CompressedSize);
+	return true;
+}
+
+
+
+
+
+int cProtocol180::GetParticleID(const AString & a_ParticleName)
+{
+	static bool IsInitialized = false;
+	static std::map<AString, int> ParticleMap;
+	if (!IsInitialized)
+	{
+		// Initialize the ParticleMap:
+		ParticleMap["explode"]          = 0;
+		ParticleMap["largeexplode"]     = 1;
+		ParticleMap["hugeexplosion"]    = 2;
+		ParticleMap["fireworksspark"]   = 3;
+		ParticleMap["bubble"]           = 4;
+		ParticleMap["splash"]           = 5;
+		ParticleMap["wake"]             = 6;
+		ParticleMap["suspended"]        = 7;
+		ParticleMap["depthsuspend"]     = 8;
+		ParticleMap["crit"]             = 9;
+		ParticleMap["magiccrit"]        = 10;
+		ParticleMap["smoke"]            = 11;
+		ParticleMap["largesmoke"]       = 12;
+		ParticleMap["spell"]            = 13;
+		ParticleMap["instantspell"]     = 14;
+		ParticleMap["mobspell"]         = 15;
+		ParticleMap["mobspellambient"]  = 16;
+		ParticleMap["witchmagic"]       = 17;
+		ParticleMap["dripwater"]        = 18;
+		ParticleMap["driplava"]         = 19;
+		ParticleMap["angryvillager"]    = 20;
+		ParticleMap["happyVillager"]    = 21;
+		ParticleMap["townaura"]         = 22;
+		ParticleMap["note"]             = 23;
+		ParticleMap["portal"]           = 24;
+		ParticleMap["enchantmenttable"] = 25;
+		ParticleMap["flame"]            = 26;
+		ParticleMap["lava"]             = 27;
+		ParticleMap["footstep"]         = 28;
+		ParticleMap["cloud"]            = 29;
+		ParticleMap["reddust"]          = 30;
+		ParticleMap["snowballpoof"]     = 31;
+		ParticleMap["snowshovel"]       = 32;
+		ParticleMap["slime"]            = 33;
+		ParticleMap["heart"]            = 34;
+		ParticleMap["barrier"]          = 35;
+		ParticleMap["iconcrack"]        = 36;
+		ParticleMap["blockcrack"]       = 37;
+		ParticleMap["blockdust"]        = 38;
+		ParticleMap["droplet"]          = 39;
+		ParticleMap["take"]             = 40;
+		ParticleMap["mobappearance"]    = 41;
+	}
+
+	AString ParticleName = StrToLower(a_ParticleName);
+	if (ParticleMap.find(ParticleName) == ParticleMap.end())
+	{
+		LOGWARNING("Unknown particle: %s", a_ParticleName.c_str());
+		ASSERT(!"Unknown particle");
+		return 0;
+	}
+
+	return ParticleMap[ParticleName];
+}
+
+
+
+
+
+void cProtocol180::FixItemFramePositions(int a_ObjectData, double & a_PosX, double & a_PosZ, double & a_Yaw)
+{
+	switch (a_ObjectData)
+	{
+		case 0:
+		{
+			a_PosZ += 1;
+			a_Yaw = 0;
+			break;
+		}
+		case 1:
+		{
+			a_PosX -= 1;
+			a_Yaw = 90;
+			break;
+		}
+		case 2:
+		{
+			a_PosZ -= 1;
+			a_Yaw = 180;
+			break;
+		}
+		case 3:
+		{
+			a_PosX += 1;
+			a_Yaw = 270;
+			break;
+		}
+	}
+}
+
+
+
+
+
+void cProtocol180::AddReceivedData(const char * a_Data, size_t a_Size)
+{
+	// Write the incoming data into the comm log file:
+	if (g_ShouldLogCommIn)
+	{
+		if (m_ReceivedData.GetReadableSpace() > 0)
+		{
+			AString AllData;
+			size_t OldReadableSpace = m_ReceivedData.GetReadableSpace();
+			m_ReceivedData.ReadAll(AllData);
+			m_ReceivedData.ResetRead();
+			m_ReceivedData.SkipRead(m_ReceivedData.GetReadableSpace() - OldReadableSpace);
+			ASSERT(m_ReceivedData.GetReadableSpace() == OldReadableSpace);
+			AString Hex;
+			CreateHexDump(Hex, AllData.data(), AllData.size(), 16);
+			m_CommLogFile.Printf("Incoming data, " SIZE_T_FMT " (0x" SIZE_T_FMT_HEX ") unparsed bytes already present in buffer:\n%s\n",
+				AllData.size(), AllData.size(), Hex.c_str()
+			);
+		}
+		AString Hex;
+		CreateHexDump(Hex, a_Data, a_Size, 16);
+		m_CommLogFile.Printf("Incoming data: %d (0x%x) bytes: \n%s\n",
+			(unsigned)a_Size, (unsigned)a_Size, Hex.c_str()
+		);
+		m_CommLogFile.Flush();
+	}
+
+	if (!m_ReceivedData.Write(a_Data, a_Size))
+	{
+		// Too much data in the incoming queue, report to caller:
+		m_Client->PacketBufferFull();
+		return;
+	}
+
+	// Handle all complete packets:
+	for (;;)
+	{
+		UInt32 PacketLen;
+		if (!m_ReceivedData.ReadVarInt(PacketLen))
+		{
+			// Not enough data
+			m_ReceivedData.ResetRead();
+			break;
+		}
+		if (!m_ReceivedData.CanReadBytes(PacketLen))
+		{
+			// The full packet hasn't been received yet
+			m_ReceivedData.ResetRead();
+			break;
+		}
+		
+		// Check packet for compression:
+		UInt32 CompressedSize = 0;
+		AString UncompressedData;
+		if (m_State == 3)
+		{
+			UInt32 NumBytesRead = m_ReceivedData.GetReadableSpace();
+			m_ReceivedData.ReadVarInt(CompressedSize);
+			if (CompressedSize > 0)
+			{
+				// Decompress the data:
+				AString CompressedData;
+				m_ReceivedData.ReadString(CompressedData, CompressedSize);
+				InflateString(CompressedData.data(), CompressedSize, UncompressedData);
+				PacketLen = UncompressedData.size();
+			}
+			else
+			{
+				NumBytesRead -= m_ReceivedData.GetReadableSpace();  // How many bytes has the CompressedSize taken up?
+				ASSERT(PacketLen > NumBytesRead);
+				PacketLen -= NumBytesRead;
+			}
+		}
+		
+		// Move the packet payload to a separate cByteBuffer, bb:
+		cByteBuffer bb(PacketLen + 1);
+		if (CompressedSize == 0)
+		{
+			// No compression was used, move directly
+			VERIFY(m_ReceivedData.ReadToByteBuffer(bb, (int)PacketLen));
+		}
+		else
+		{
+			// Compression was used, move the uncompressed data:
+			VERIFY(bb.Write(UncompressedData.data(), UncompressedData.size()));
+		}
+		m_ReceivedData.CommitRead();
+
+		UInt32 PacketType;
+		if (!bb.ReadVarInt(PacketType))
+		{
+			// Not enough data
+			break;
+		}
+
+		// Write one NUL extra, so that we can detect over-reads
+		bb.Write("\0", 1);
+		
+		// Log the packet info into the comm log file:
+		if (g_ShouldLogCommIn)
+		{
+			AString PacketData;
+			bb.ReadAll(PacketData);
+			bb.ResetRead();
+			bb.ReadVarInt(PacketType);
+			ASSERT(PacketData.size() > 0);  // We have written an extra NUL, so there had to be at least one byte read
+			PacketData.resize(PacketData.size() - 1);
+			AString PacketDataHex;
+			CreateHexDump(PacketDataHex, PacketData.data(), PacketData.size(), 16);
+			m_CommLogFile.Printf("Next incoming packet is type %u (0x%x), length %u (0x%x) at state %d. Payload:\n%s\n",
+				PacketType, PacketType, PacketLen, PacketLen, m_State, PacketDataHex.c_str()
+			);
+		}
+
+		if (!HandlePacket(bb, PacketType))
+		{
+			// Unknown packet, already been reported, but without the length. Log the length here:
+			LOGWARNING("Unhandled packet: type 0x%x, state %d, length %u", PacketType, m_State, PacketLen);
+			
+			#ifdef _DEBUG
+				// Dump the packet contents into the log:
+				bb.ResetRead();
+				AString Packet;
+				bb.ReadAll(Packet);
+				Packet.resize(Packet.size() - 1);  // Drop the final NUL pushed there for over-read detection
+				AString Out;
+				CreateHexDump(Out, Packet.data(), (int)Packet.size(), 24);
+				LOGD("Packet contents:\n%s", Out.c_str());
+			#endif  // _DEBUG
+			
+			// Put a message in the comm log:
+			if (g_ShouldLogCommIn)
+			{
+				m_CommLogFile.Printf("^^^^^^ Unhandled packet ^^^^^^\n\n\n");
+			}
+			
+			return;
+		}
+
+		// The packet should have 1 byte left in the buffer - the NUL we had added
+		if (bb.GetReadableSpace() != 1)
+		{
+			// Read more or less than packet length, report as error
+			LOGWARNING("Protocol 1.8: Wrong number of bytes read for packet 0x%x, state %d. Read " SIZE_T_FMT " bytes, packet contained %u bytes",
+				PacketType, m_State, bb.GetUsedSpace() - bb.GetReadableSpace(), PacketLen
+			);
+
+			// Put a message in the comm log:
+			if (g_ShouldLogCommIn)
+			{
+				m_CommLogFile.Printf("^^^^^^ Wrong number of bytes read for this packet (exp %d left, got " SIZE_T_FMT " left) ^^^^^^\n\n\n",
+					1, bb.GetReadableSpace()
+				);
+				m_CommLogFile.Flush();
+			}
+
+			ASSERT(!"Read wrong number of bytes!");
+			m_Client->PacketError(PacketType);
+		}
+	}  // for (ever)
+
+	// Log any leftover bytes into the logfile:
+	if (g_ShouldLogCommIn && (m_ReceivedData.GetReadableSpace() > 0))
+	{
+		AString AllData;
+		size_t OldReadableSpace = m_ReceivedData.GetReadableSpace();
+		m_ReceivedData.ReadAll(AllData);
+		m_ReceivedData.ResetRead();
+		m_ReceivedData.SkipRead(m_ReceivedData.GetReadableSpace() - OldReadableSpace);
+		ASSERT(m_ReceivedData.GetReadableSpace() == OldReadableSpace);
+		AString Hex;
+		CreateHexDump(Hex, AllData.data(), AllData.size(), 16);
+		m_CommLogFile.Printf("There are " SIZE_T_FMT " (0x" SIZE_T_FMT_HEX ") bytes of non-parse-able data left in the buffer:\n%s",
+			m_ReceivedData.GetReadableSpace(), m_ReceivedData.GetReadableSpace(), Hex.c_str()
+		);
+		m_CommLogFile.Flush();
+	}
+}
+
+
+
+
+bool cProtocol180::HandlePacket(cByteBuffer & a_ByteBuffer, UInt32 a_PacketType)
+{
+	switch (m_State)
+	{
+		case 1:
+		{
+			// Status
+			switch (a_PacketType)
+			{
+				case 0x00: HandlePacketStatusRequest(a_ByteBuffer); return true;
+				case 0x01: HandlePacketStatusPing   (a_ByteBuffer); return true;
+			}
+			break;
+		}
+		
+		case 2:
+		{
+			// Login
+			switch (a_PacketType)
+			{
+				case 0x00: HandlePacketLoginStart             (a_ByteBuffer); return true;
+				case 0x01: HandlePacketLoginEncryptionResponse(a_ByteBuffer); return true;
+			}
+			break;
+		}
+		
+		case 3:
+		{
+			// Game
+			switch (a_PacketType)
+			{
+				case 0x00: HandlePacketKeepAlive              (a_ByteBuffer); return true;
+				case 0x01: HandlePacketChatMessage            (a_ByteBuffer); return true;
+				case 0x02: HandlePacketUseEntity              (a_ByteBuffer); return true;
+				case 0x03: HandlePacketPlayer                 (a_ByteBuffer); return true;
+				case 0x04: HandlePacketPlayerPos              (a_ByteBuffer); return true;
+				case 0x05: HandlePacketPlayerLook             (a_ByteBuffer); return true;
+				case 0x06: HandlePacketPlayerPosLook          (a_ByteBuffer); return true;
+				case 0x07: HandlePacketBlockDig               (a_ByteBuffer); return true;
+				case 0x08: HandlePacketBlockPlace             (a_ByteBuffer); return true;
+				case 0x09: HandlePacketSlotSelect             (a_ByteBuffer); return true;
+				case 0x0a: HandlePacketAnimation              (a_ByteBuffer); return true;
+				case 0x0b: HandlePacketEntityAction           (a_ByteBuffer); return true;
+				case 0x0c: HandlePacketSteerVehicle           (a_ByteBuffer); return true;
+				case 0x0d: HandlePacketWindowClose            (a_ByteBuffer); return true;
+				case 0x0e: HandlePacketWindowClick            (a_ByteBuffer); return true;
+				case 0x0f:  // Confirm transaction - not used in MCS
+				case 0x10: HandlePacketCreativeInventoryAction(a_ByteBuffer); return true;
+				case 0x11: HandlePacketEnchantItem            (a_ByteBuffer); return true;
+				case 0x12: HandlePacketUpdateSign             (a_ByteBuffer); return true;
+				case 0x13: HandlePacketPlayerAbilities        (a_ByteBuffer); return true;
+				case 0x14: HandlePacketTabComplete            (a_ByteBuffer); return true;
+				case 0x15: HandlePacketClientSettings         (a_ByteBuffer); return true;
+				case 0x16: HandlePacketClientStatus           (a_ByteBuffer); return true;
+				case 0x17: HandlePacketPluginMessage          (a_ByteBuffer); return true;
+			}
+			break;
+		}
+		default:
+		{
+			// Received a packet in an unknown state, report:
+			LOGWARNING("Received a packet in an unknown protocol state %d. Ignoring further packets.", m_State);
+			
+			// Cannot kick the client - we don't know this state and thus the packet number for the kick packet
+			
+			// Switch to a state when all further packets are silently ignored:
+			m_State = 255;
+			return false;
+		}
+		case 255:
+		{
+			// This is the state used for "not processing packets anymore" when we receive a bad packet from a client.
+			// Do not output anything (the caller will do that for us), just return failure
+			return false;
+		}
+	}  // switch (m_State)
+	
+	// Unknown packet type, report to the ClientHandle:
+	m_Client->PacketUnknown(a_PacketType);
+	return false;
+}
+
+
+
+
+
+void cProtocol180::HandlePacketStatusPing(cByteBuffer & a_ByteBuffer)
+{
+	HANDLE_READ(a_ByteBuffer, ReadBEInt64, Int64, Timestamp);
+
+	cPacketizer Pkt(*this, 0x01);  // Ping packet
+	Pkt.WriteInt64(Timestamp);
+}
+
+
+
+
+
+void cProtocol180::HandlePacketStatusRequest(cByteBuffer & a_ByteBuffer)
+{
+	cServer * Server = cRoot::Get()->GetServer();
+	AString ServerDescription = Server->GetDescription();
+	int NumPlayers = Server->GetNumPlayers();
+	int MaxPlayers = Server->GetMaxPlayers();
+	AString Favicon = Server->GetFaviconData();
+	cRoot::Get()->GetPluginManager()->CallHookServerPing(*m_Client, ServerDescription, NumPlayers, MaxPlayers, Favicon);
+
+	// Version:
+	Json::Value Version;
+	Version["name"] = "1.8";
+	Version["protocol"] = 47;
+
+	// Players:
+	Json::Value Players;
+	Players["online"] = NumPlayers;
+	Players["max"] = MaxPlayers;
+	// TODO: Add "sample"
+
+	// Description:
+	Json::Value Description;
+	Description["text"] = ServerDescription.c_str();
+
+	// Create the response:
+	Json::Value ResponseValue;
+	ResponseValue["version"] = Version;
+	ResponseValue["players"] = Players;
+	ResponseValue["description"] = Description;
+	if (!Favicon.empty())
+	{
+		ResponseValue["favicon"] = Printf("data:image/png;base64,%s", Favicon.c_str());
+	}
+
+	Json::StyledWriter Writer;
+	AString Response = Writer.write(ResponseValue);
+
+	cPacketizer Pkt(*this, 0x00);  // Response packet
+	Pkt.WriteString(Response);
+}
+
+
+
+
+
+void cProtocol180::HandlePacketLoginEncryptionResponse(cByteBuffer & a_ByteBuffer)
+{
+	UInt32 EncKeyLength, EncNonceLength;
+	if (!a_ByteBuffer.ReadVarInt(EncKeyLength))
+	{
+		return;
+	}
+	AString EncKey;
+	if (!a_ByteBuffer.ReadString(EncKey, EncKeyLength))
+	{
+		return;
+	}
+	if (!a_ByteBuffer.ReadVarInt(EncNonceLength))
+	{
+		return;
+	}
+	AString EncNonce;
+	if (!a_ByteBuffer.ReadString(EncNonce, EncNonceLength))
+	{
+		return;
+	}
+	if ((EncKeyLength > MAX_ENC_LEN) || (EncNonceLength > MAX_ENC_LEN))
+	{
+		LOGD("Too long encryption");
+		m_Client->Kick("Hacked client");
+		return;
+	}
+
+	// Decrypt EncNonce using privkey
+	cRsaPrivateKey & rsaDecryptor = cRoot::Get()->GetServer()->GetPrivateKey();
+	Int32 DecryptedNonce[MAX_ENC_LEN / sizeof(Int32)];
+	int res = rsaDecryptor.Decrypt((const Byte *)EncNonce.data(), EncNonce.size(), (Byte *)DecryptedNonce, sizeof(DecryptedNonce));
+	if (res != 4)
+	{
+		LOGD("Bad nonce length: got %d, exp %d", res, 4);
+		m_Client->Kick("Hacked client");
+		return;
+	}
+	if (ntohl(DecryptedNonce[0]) != (unsigned)(uintptr_t)this)
+	{
+		LOGD("Bad nonce value");
+		m_Client->Kick("Hacked client");
+		return;
+	}
+	
+	// Decrypt the symmetric encryption key using privkey:
+	Byte DecryptedKey[MAX_ENC_LEN];
+	res = rsaDecryptor.Decrypt((const Byte *)EncKey.data(), EncKey.size(), DecryptedKey, sizeof(DecryptedKey));
+	if (res != 16)
+	{
+		LOGD("Bad key length");
+		m_Client->Kick("Hacked client");
+		return;
+	}
+	
+	StartEncryption(DecryptedKey);
+	m_Client->HandleLogin(4, m_Client->GetUsername());
+}
+
+
+
+
+
+void cProtocol180::HandlePacketLoginStart(cByteBuffer & a_ByteBuffer)
+{
+	AString Username;
+	if (!a_ByteBuffer.ReadVarUTF8String(Username))
+	{
+		m_Client->Kick("Bad username");
+		return;
+	}
+	
+	if (!m_Client->HandleHandshake(Username))
+	{
+		// The client is not welcome here, they have been sent a Kick packet already
+		return;
+	}
+	
+	cServer * Server = cRoot::Get()->GetServer();
+	// If auth is required, then send the encryption request:
+	if (Server->ShouldAuthenticate())
+	{
+		cPacketizer Pkt(*this, 0x01);
+		Pkt.WriteString(Server->GetServerID());
+		const AString & PubKeyDer = Server->GetPublicKeyDER();
+		Pkt.WriteVarInt((short)PubKeyDer.size());
+		Pkt.WriteBuf(PubKeyDer.data(), PubKeyDer.size());
+		Pkt.WriteVarInt(4);
+		Pkt.WriteInt((int)(intptr_t)this);  // Using 'this' as the cryptographic nonce, so that we don't have to generate one each time :)
+		m_Client->SetUsername(Username);
+		return;
+	}
+	
+	m_Client->HandleLogin(4, Username);
+}
+
+
+
+
+
+void cProtocol180::HandlePacketAnimation(cByteBuffer & a_ByteBuffer)
+{
+	HANDLE_READ(a_ByteBuffer, ReadBEInt, int,  EntityID);
+	HANDLE_READ(a_ByteBuffer, ReadByte,  Byte, Animation);
+	m_Client->HandleAnimation(Animation);
+}
+
+
+
+
+
+void cProtocol180::HandlePacketBlockDig(cByteBuffer & a_ByteBuffer)
+{
+	HANDLE_READ(a_ByteBuffer, ReadByte,  Byte, Status);
+
+	int BlockX, BlockY, BlockZ;
+	if (!a_ByteBuffer.ReadPosition(BlockX, BlockY, BlockZ))
+	{
+		return;
+	}
+
+	HANDLE_READ(a_ByteBuffer, ReadByte,  Byte, Face);
+	m_Client->HandleLeftClick(BlockX, BlockY, BlockZ, static_cast<eBlockFace>(Face), Status);
+}
+
+
+
+
+
+void cProtocol180::HandlePacketBlockPlace(cByteBuffer & a_ByteBuffer)
+{
+	int BlockX, BlockY, BlockZ;
+	if (!a_ByteBuffer.ReadPosition(BlockX, BlockY, BlockZ))
+	{
+		return;
+	}
+
+	HANDLE_READ(a_ByteBuffer, ReadByte,  Byte, Face);
+	if (Face == 255)
+	{
+		Face = 0;
+	}
+
+	cItem Item;
+	ReadItem(a_ByteBuffer, Item, 3);
+
+	HANDLE_READ(a_ByteBuffer, ReadByte,  Byte, CursorX);
+	HANDLE_READ(a_ByteBuffer, ReadByte,  Byte, CursorY);
+	HANDLE_READ(a_ByteBuffer, ReadByte,  Byte, CursorZ);
+	m_Client->HandleRightClick(BlockX, BlockY, BlockZ, static_cast<eBlockFace>(Face), CursorX, CursorY, CursorZ, m_Client->GetPlayer()->GetEquippedItem());
+}
+
+
+
+
+
+void cProtocol180::HandlePacketChatMessage(cByteBuffer & a_ByteBuffer)
+{
+	HANDLE_READ(a_ByteBuffer, ReadVarUTF8String, AString, Message);
+	m_Client->HandleChat(Message);
+}
+
+
+
+
+
+void cProtocol180::HandlePacketClientSettings(cByteBuffer & a_ByteBuffer)
+{
+	HANDLE_READ(a_ByteBuffer, ReadVarUTF8String, AString, Locale);
+	HANDLE_READ(a_ByteBuffer, ReadByte,          Byte,    ViewDistance);
+	HANDLE_READ(a_ByteBuffer, ReadByte,          Byte,    ChatFlags);
+	HANDLE_READ(a_ByteBuffer, ReadBool,          bool,    ChatColors);
+	HANDLE_READ(a_ByteBuffer, ReadChar,          char,    SkinFlags);
+	
+	m_Client->SetLocale(Locale);
+	// TODO: Handle other values
+}
+
+
+
+
+
+void cProtocol180::HandlePacketClientStatus(cByteBuffer & a_ByteBuffer)
+{
+	HANDLE_READ(a_ByteBuffer, ReadChar, char, ActionID);
+	switch (ActionID)
+	{
+		case 0:
+		{
+			// Respawn
+			m_Client->HandleRespawn();
+			break;
+		}
+		case 1:
+		{
+			// Request stats
+			const cStatManager & Manager = m_Client->GetPlayer()->GetStatManager();
+			SendStatistics(Manager);
+
+			break;
+		}
+		case 2:
+		{
+			// Open Inventory achievement
+			m_Client->GetPlayer()->AwardAchievement(achOpenInv);
+			break;
+		}
+	}
+}
+
+
+
+
+
+void cProtocol180::HandlePacketCreativeInventoryAction(cByteBuffer & a_ByteBuffer)
+{
+	HANDLE_READ(a_ByteBuffer, ReadBEShort, short, SlotNum);
+	cItem Item;
+	if (!ReadItem(a_ByteBuffer, Item))
+	{
+		return;
+	}
+	m_Client->HandleCreativeInventory(SlotNum, Item);
+}
+
+
+
+
+
+void cProtocol180::HandlePacketEntityAction(cByteBuffer & a_ByteBuffer)
+{
+	HANDLE_READ(a_ByteBuffer, ReadVarInt, UInt32,  PlayerID);
+	HANDLE_READ(a_ByteBuffer, ReadChar,   char,    Action);
+	HANDLE_READ(a_ByteBuffer, ReadVarInt, UInt32,  JumpBoost);
+
+	switch (Action)
+	{
+		case 0: m_Client->HandleEntityCrouch(PlayerID, true);     break;  // Crouch
+		case 1: m_Client->HandleEntityCrouch(PlayerID, false);    break;  // Uncrouch
+		case 2: m_Client->HandleEntityLeaveBed(PlayerID);         break;  // Leave Bed
+		case 3: m_Client->HandleEntitySprinting(PlayerID, true);  break;  // Start sprinting
+		case 4: m_Client->HandleEntitySprinting(PlayerID, false); break;  // Stop sprinting
+	}
+}
+
+
+
+
+
+void cProtocol180::HandlePacketKeepAlive(cByteBuffer & a_ByteBuffer)
+{
+	HANDLE_READ(a_ByteBuffer, ReadVarInt, UInt32, KeepAliveID);
+	m_Client->HandleKeepAlive((int)KeepAliveID);
+}
+
+
+
+
+
+void cProtocol180::HandlePacketPlayer(cByteBuffer & a_ByteBuffer)
+{
+	HANDLE_READ(a_ByteBuffer, ReadBool, bool, IsOnGround);
+	// TODO: m_Client->HandlePlayerOnGround(IsOnGround);
+}
+
+
+
+
+
+void cProtocol180::HandlePacketPlayerAbilities(cByteBuffer & a_ByteBuffer)
+{
+	HANDLE_READ(a_ByteBuffer, ReadByte,    Byte,  Flags);
+	HANDLE_READ(a_ByteBuffer, ReadBEFloat, float, FlyingSpeed);
+	HANDLE_READ(a_ByteBuffer, ReadBEFloat, float, WalkingSpeed);
+
+	bool IsFlying = false, CanFly = false;
+	if ((Flags & 2) != 0)
+	{
+		IsFlying = true;
+	}
+	if ((Flags & 4) != 0)
+	{
+		CanFly = true;
+	}
+
+	m_Client->HandlePlayerAbilities(CanFly, IsFlying, FlyingSpeed, WalkingSpeed);
+}
+
+
+
+
+
+void cProtocol180::HandlePacketPlayerLook(cByteBuffer & a_ByteBuffer)
+{
+	HANDLE_READ(a_ByteBuffer, ReadBEFloat, float, Yaw);
+	HANDLE_READ(a_ByteBuffer, ReadBEFloat, float, Pitch);
+	HANDLE_READ(a_ByteBuffer, ReadBool,    bool,  IsOnGround);
+	m_Client->HandlePlayerLook(Yaw, Pitch, IsOnGround);
+}
+
+
+
+
+
+void cProtocol180::HandlePacketPlayerPos(cByteBuffer & a_ByteBuffer)
+{
+	HANDLE_READ(a_ByteBuffer, ReadBEDouble, double, PosX);
+	HANDLE_READ(a_ByteBuffer, ReadBEDouble, double, PosY);
+	HANDLE_READ(a_ByteBuffer, ReadBEDouble, double, PosZ);
+	HANDLE_READ(a_ByteBuffer, ReadBool,     bool,   IsOnGround);
+	m_Client->HandlePlayerPos(PosX, PosY, PosZ, PosY + 1.62, IsOnGround);
+}
+
+
+
+
+
+void cProtocol180::HandlePacketPlayerPosLook(cByteBuffer & a_ByteBuffer)
+{
+	HANDLE_READ(a_ByteBuffer, ReadBEDouble, double, PosX);
+	HANDLE_READ(a_ByteBuffer, ReadBEDouble, double, PosY);
+	HANDLE_READ(a_ByteBuffer, ReadBEDouble, double, PosZ);
+	HANDLE_READ(a_ByteBuffer, ReadBEFloat,  float,  Yaw);
+	HANDLE_READ(a_ByteBuffer, ReadBEFloat,  float,  Pitch);
+	HANDLE_READ(a_ByteBuffer, ReadBool,     bool,   IsOnGround);
+	m_Client->HandlePlayerMoveLook(PosX, PosY, PosZ, PosY + 1.62, Yaw, Pitch, IsOnGround);
+}
+
+
+
+
+
+void cProtocol180::HandlePacketPluginMessage(cByteBuffer & a_ByteBuffer)
+{
+	HANDLE_READ(a_ByteBuffer, ReadVarUTF8String, AString, Channel);
+	HANDLE_READ(a_ByteBuffer, ReadVarInt, UInt32, DataLen);
+	AString Data;
+	a_ByteBuffer.ReadString(Data, DataLen);
+	m_Client->HandlePluginMessage(Channel, Data);
+}
+
+
+
+
+
+void cProtocol180::HandlePacketSlotSelect(cByteBuffer & a_ByteBuffer)
+{
+	HANDLE_READ(a_ByteBuffer, ReadBEShort, short, SlotNum);
+	m_Client->HandleSlotSelected(SlotNum);
+}
+
+
+
+
+
+void cProtocol180::HandlePacketSteerVehicle(cByteBuffer & a_ByteBuffer)
+{
+	HANDLE_READ(a_ByteBuffer, ReadBEFloat, float, Forward);
+	HANDLE_READ(a_ByteBuffer, ReadBEFloat, float, Sideways);
+	HANDLE_READ(a_ByteBuffer, ReadChar,    char,  Flags);
+
+	if ((Flags & 0x2) != 0)
+	{
+		m_Client->HandleUnmount();
+	}
+	else if ((Flags & 0x1) != 0)
+	{
+		m_Client->HandleSteerVehicle(Forward, Sideways);
+	}
+}
+
+
+
+
+
+void cProtocol180::HandlePacketTabComplete(cByteBuffer & a_ByteBuffer)
+{
+	HANDLE_READ(a_ByteBuffer, ReadVarUTF8String, AString, Text);
+	HANDLE_READ(a_ByteBuffer, ReadBool, bool, HasPosition);
+
+	if (HasPosition)
+	{
+		HANDLE_READ(a_ByteBuffer, ReadBEInt64, Int64, Position);
+	}
+
+	m_Client->HandleTabCompletion(Text);
+}
+
+
+
+
+
+void cProtocol180::HandlePacketUpdateSign(cByteBuffer & a_ByteBuffer)
+{
+	int BlockX, BlockY, BlockZ;
+	if (!a_ByteBuffer.ReadPosition(BlockX, BlockY, BlockZ))
+	{
+		return;
+	}
+
+	AString Lines[4];
+	for (int i = 0; i < 4; i++)
+	{
+		HANDLE_READ(a_ByteBuffer, ReadVarUTF8String, AString, Line);
+		Lines[i] = Line.substr(1, Line.length() - 2);  // Remove ""
+	}
+
+	m_Client->HandleUpdateSign(BlockX, BlockY, BlockZ, Lines[0], Lines[1], Lines[2], Lines[3]);
+}
+
+
+
+
+
+void cProtocol180::HandlePacketUseEntity(cByteBuffer & a_ByteBuffer)
+{
+	HANDLE_READ(a_ByteBuffer, ReadVarInt, UInt32, EntityID);
+	HANDLE_READ(a_ByteBuffer, ReadVarInt, UInt32, Type);
+
+	switch (Type)
+	{
+		case 0:
+		{
+			m_Client->HandleUseEntity((int)EntityID, false);
+			break;
+		}
+		case 1:
+		{
+			m_Client->HandleUseEntity((int)EntityID, true);
+			break;
+		}
+		case 2:
+		{
+			HANDLE_READ(a_ByteBuffer, ReadBEFloat, float, TargetX);
+			HANDLE_READ(a_ByteBuffer, ReadBEFloat, float, TargetY);
+			HANDLE_READ(a_ByteBuffer, ReadBEFloat, float, TargetZ);
+
+			// TODO: Do anything
+			break;
+		}
+		default:
+		{
+			ASSERT(!"Unhandled use entity type!");
+			return;
+		}
+	}
+}
+
+
+
+
+
+void cProtocol180::HandlePacketEnchantItem(cByteBuffer & a_ByteBuffer)
+{
+	HANDLE_READ(a_ByteBuffer, ReadByte, Byte, WindowID);
+	HANDLE_READ(a_ByteBuffer, ReadByte, Byte, Enchantment);
+
+	m_Client->HandleEnchantItem(WindowID, Enchantment);
+}
+
+
+
+
+
+void cProtocol180::HandlePacketWindowClick(cByteBuffer & a_ByteBuffer)
+{
+	HANDLE_READ(a_ByteBuffer, ReadChar,    char,  WindowID);
+	HANDLE_READ(a_ByteBuffer, ReadBEShort, short, SlotNum);
+	HANDLE_READ(a_ByteBuffer, ReadByte,    Byte,  Button);
+	HANDLE_READ(a_ByteBuffer, ReadBEShort, short, TransactionID);
+	HANDLE_READ(a_ByteBuffer, ReadByte,    Byte,  Mode);
+	cItem Item;
+	ReadItem(a_ByteBuffer, Item);
+
+	// Convert Button, Mode, SlotNum and HeldItem into eClickAction:
+	eClickAction Action;
+	switch ((Mode << 8) | Button)
+	{
+		case 0x0000: Action = (SlotNum != -999) ? caLeftClick  : caLeftClickOutside;  break;
+		case 0x0001: Action = (SlotNum != -999) ? caRightClick : caRightClickOutside; break;
+		case 0x0100: Action = caShiftLeftClick;  break;
+		case 0x0101: Action = caShiftRightClick; break;
+		case 0x0200: Action = caNumber1;         break;
+		case 0x0201: Action = caNumber2;         break;
+		case 0x0202: Action = caNumber3;         break;
+		case 0x0203: Action = caNumber4;         break;
+		case 0x0204: Action = caNumber5;         break;
+		case 0x0205: Action = caNumber6;         break;
+		case 0x0206: Action = caNumber7;         break;
+		case 0x0207: Action = caNumber8;         break;
+		case 0x0208: Action = caNumber9;         break;
+		case 0x0300: Action = caMiddleClick;     break;
+		case 0x0400: Action = (SlotNum == -999) ? caLeftClickOutsideHoldNothing  : caDropKey;     break;
+		case 0x0401: Action = (SlotNum == -999) ? caRightClickOutsideHoldNothing : caCtrlDropKey; break;
+		case 0x0500: Action = (SlotNum == -999) ? caLeftPaintBegin               : caUnknown;     break;
+		case 0x0501: Action = (SlotNum != -999) ? caLeftPaintProgress            : caUnknown;     break;
+		case 0x0502: Action = (SlotNum == -999) ? caLeftPaintEnd                 : caUnknown;     break;
+		case 0x0504: Action = (SlotNum == -999) ? caRightPaintBegin              : caUnknown;     break;
+		case 0x0505: Action = (SlotNum != -999) ? caRightPaintProgress           : caUnknown;     break;
+		case 0x0506: Action = (SlotNum == -999) ? caRightPaintEnd                : caUnknown;     break;
+		case 0x0600: Action = caDblClick; break;
+		default:
+		{
+			LOGWARNING("Unhandled window click mode / button combination: %d (0x%x)", (Mode << 8) | Button, (Mode << 8) | Button);
+			Action = caUnknown;
+			break;
+		}
+	}
+
+	m_Client->HandleWindowClick(WindowID, SlotNum, Action, Item);
+}
+
+
+
+
+
+void cProtocol180::HandlePacketWindowClose(cByteBuffer & a_ByteBuffer)
+{
+	HANDLE_READ(a_ByteBuffer, ReadChar, char, WindowID);
+	m_Client->HandleWindowClose(WindowID);
+}
+
+
+
+
+
+void cProtocol180::WritePacket(cByteBuffer & a_Packet)
+{
+	cCSLock Lock(m_CSPacket);
+	AString Pkt;
+	a_Packet.ReadAll(Pkt);
+	WriteVarInt((UInt32)Pkt.size());
+	SendData(Pkt.data(), Pkt.size());
+	Flush();
+}
+
+
+
+
+
+void cProtocol180::SendData(const char * a_Data, size_t a_Size)
+{
+	if (m_IsEncrypted)
+	{
+		Byte Encrypted[8192];  // Larger buffer, we may be sending lots of data (chunks)
+		while (a_Size > 0)
+		{
+			size_t NumBytes = (a_Size > sizeof(Encrypted)) ? sizeof(Encrypted) : a_Size;
+			m_Encryptor.ProcessData(Encrypted, (Byte *)a_Data, NumBytes);
+			m_Client->SendData((const char *)Encrypted, NumBytes);
+			a_Size -= NumBytes;
+			a_Data += NumBytes;
+		}
+	}
+	else
+	{
+		m_Client->SendData(a_Data, a_Size);
+	}
+}
+
+
+
+
+
+bool cProtocol180::ReadItem(cByteBuffer & a_ByteBuffer, cItem & a_Item, size_t a_KeepRemainingBytes)
+{
+	HANDLE_PACKET_READ(a_ByteBuffer, ReadBEShort, short, ItemType);
+	if (ItemType == -1)
+	{
+		// The item is empty, no more data follows
+		a_Item.Empty();
+		return true;
+	}
+	a_Item.m_ItemType = ItemType;
+	
+	HANDLE_PACKET_READ(a_ByteBuffer, ReadChar,    char,  ItemCount);
+	HANDLE_PACKET_READ(a_ByteBuffer, ReadBEShort, short, ItemDamage);
+	a_Item.m_ItemCount  = ItemCount;
+	a_Item.m_ItemDamage = ItemDamage;
+	if (ItemCount <= 0)
+	{
+		a_Item.Empty();
+	}
+
+	AString Metadata;
+	if (!a_ByteBuffer.ReadString(Metadata, a_ByteBuffer.GetReadableSpace() - a_KeepRemainingBytes - 1) || (Metadata.size() == 0) || (Metadata[0] == 0))
+	{
+		// No metadata
+		return true;
+	}
+
+	ParseItemMetadata(a_Item, Metadata);
+	return true;
+}
+
+
+
+
+
+void cProtocol180::ParseItemMetadata(cItem & a_Item, const AString & a_Metadata)
+{
+	// Parse into NBT:
+	cParsedNBT NBT(a_Metadata.data(), a_Metadata.size());
+	if (!NBT.IsValid())
+	{
+		AString HexDump;
+		CreateHexDump(HexDump, a_Metadata.data(), a_Metadata.size(), 16);
+		LOGWARNING("Cannot parse NBT item metadata: (" SIZE_T_FMT " bytes)\n%s", a_Metadata.size(), HexDump.c_str());
+		return;
+	}
+	
+	// Load enchantments and custom display names from the NBT data:
+	for (int tag = NBT.GetFirstChild(NBT.GetRoot()); tag >= 0; tag = NBT.GetNextSibling(tag))
+	{
+		AString TagName = NBT.GetName(tag);
+		switch (NBT.GetType(tag))
+		{
+			case TAG_List:
+			{
+				if ((TagName == "ench") || (TagName == "StoredEnchantments"))  // Enchantments tags
+				{
+					EnchantmentSerializer::ParseFromNBT(a_Item.m_Enchantments, NBT, tag);
+				}
+				break;
+			}
+			case TAG_Compound:
+			{
+				if (TagName == "display")  // Custom name and lore tag
+				{
+					for (int displaytag = NBT.GetFirstChild(tag); displaytag >= 0; displaytag = NBT.GetNextSibling(displaytag))
+					{
+						if ((NBT.GetType(displaytag) == TAG_String) && (NBT.GetName(displaytag) == "Name"))  // Custon name tag
+						{
+							a_Item.m_CustomName = NBT.GetString(displaytag);
+						}
+						else if ((NBT.GetType(displaytag) == TAG_List) && (NBT.GetName(displaytag) == "Lore"))  // Lore tag
+						{
+							AString Lore;
+
+							for (int loretag = NBT.GetFirstChild(displaytag); loretag >= 0; loretag = NBT.GetNextSibling(loretag))  // Loop through array of strings
+							{
+								AppendPrintf(Lore, "%s`", NBT.GetString(loretag).c_str());  // Append the lore with a grave accent/backtick, used internally by MCS to display a new line in the client; don't forget to c_str ;)
+							}
+
+							a_Item.m_Lore = Lore;
+						}
+					}
+				}
+				else if ((TagName == "Fireworks") || (TagName == "Explosion"))
+				{
+					cFireworkItem::ParseFromNBT(a_Item.m_FireworkItem, NBT, tag, (ENUM_ITEM_ID)a_Item.m_ItemType);
+				}
+				break;
+			}
+			case TAG_Int:
+			{
+				if (TagName == "RepairCost")
+				{
+					a_Item.m_RepairCost = NBT.GetInt(tag);
+				}
+			}
+			default: LOGD("Unimplemented NBT data when parsing!"); break;
+		}
+	}
+}
+
+
+
+
+
+void cProtocol180::StartEncryption(const Byte * a_Key)
+{
+	m_Encryptor.Init(a_Key, a_Key);
+	m_Decryptor.Init(a_Key, a_Key);
+	m_IsEncrypted = true;
+	
+	// Prepare the m_AuthServerID:
+	cSha1Checksum Checksum;
+	cServer * Server = cRoot::Get()->GetServer();
+	const AString & ServerID = Server->GetServerID();
+	Checksum.Update((const Byte *)ServerID.c_str(), ServerID.length());
+	Checksum.Update(a_Key, 16);
+	Checksum.Update((const Byte *)Server->GetPublicKeyDER().data(), Server->GetPublicKeyDER().size());
+	Byte Digest[20];
+	Checksum.Finalize(Digest);
+	cSha1Checksum::DigestToJava(Digest, m_AuthServerID);
+}
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// cProtocol180::cPacketizer:
+
+cProtocol180::cPacketizer::~cPacketizer()
+{
+	UInt32 PacketLen = (UInt32)m_Out.GetUsedSpace();
+	AString PacketData, CompressedPacket;
+	m_Out.ReadAll(PacketData);
+	m_Out.CommitRead();
+
+	if ((m_Protocol.m_State == 3) && (PacketLen >= 256))
+	{
+		if (!cProtocol180::CompressPacket(PacketData, CompressedPacket))
+		{
+			return;
+		}
+	}
+	else if (m_Protocol.m_State == 3)
+	{
+		m_Protocol.m_OutPacketLenBuffer.WriteVarInt(PacketLen + 1);
+		m_Protocol.m_OutPacketLenBuffer.WriteVarInt(0);
+
+		AString LengthData;
+		m_Protocol.m_OutPacketLenBuffer.ReadAll(LengthData);
+		m_Protocol.SendData(LengthData.data(), LengthData.size());
+	}
+	else
+	{
+		m_Protocol.m_OutPacketLenBuffer.WriteVarInt(PacketLen);
+
+		AString LengthData;
+		m_Protocol.m_OutPacketLenBuffer.ReadAll(LengthData);
+		m_Protocol.SendData(LengthData.data(), LengthData.size());
+	}
+
+	if (CompressedPacket.empty())
+	{
+		m_Protocol.m_OutPacketLenBuffer.CommitRead();
+		m_Protocol.SendData(PacketData.data(), PacketData.size());
+	}
+	else
+	{
+		m_Protocol.SendData(CompressedPacket.data(), CompressedPacket.size());
+	}
+
+	// Log the comm into logfile:
+	if (g_ShouldLogCommOut)
+	{
+		AString Hex;
+		ASSERT(PacketData.size() > 0);
+		CreateHexDump(Hex, PacketData.data() + 1, PacketData.size() - 1, 16);
+		m_Protocol.m_CommLogFile.Printf("Outgoing packet: type %d (0x%x), length %u (0x%x), state %d. Payload:\n%s\n",
+			PacketData[0], PacketData[0], PacketLen, PacketLen, m_Protocol.m_State, Hex.c_str()
+		);
+	}
+}
+
+
+
+
+
+void cProtocol180::cPacketizer::WriteUUID(const AString & a_UUID)
+{
+	if (a_UUID.length() != 32)
+	{
+		LOGWARNING("Attempt to send a bad uuid (length isn't 32): %s", a_UUID.c_str());
+		ASSERT(!"Wrong uuid length!");
+		return;
+	}
+	AString UUID_1 = a_UUID.substr(0, 16);
+	AString UUID_2 = a_UUID.substr(16);
+
+	Int64 Value_1, Value_2;
+	sscanf(UUID_1.c_str(), "%llx", &Value_1);
+	sscanf(UUID_2.c_str(), "%llx", &Value_2);
+
+	WriteInt64(Value_1);
+	WriteInt64(Value_2);
+}
+
+
+
+
+
+void cProtocol180::cPacketizer::WriteItem(const cItem & a_Item)
+{
+	short ItemType = a_Item.m_ItemType;
+	ASSERT(ItemType >= -1);  // Check validity of packets in debug runtime
+	if (ItemType <= 0)
+	{
+		// Fix, to make sure no invalid values are sent.
+		ItemType = -1;
+	}
+	
+	if (a_Item.IsEmpty())
+	{
+		WriteShort(-1);
+		return;
+	}
+	
+	WriteShort(ItemType);
+	WriteByte (a_Item.m_ItemCount);
+	WriteShort(a_Item.m_ItemDamage);
+	
+	if (a_Item.m_Enchantments.IsEmpty() && a_Item.IsBothNameAndLoreEmpty() && (a_Item.m_ItemType != E_ITEM_FIREWORK_ROCKET) && (a_Item.m_ItemType != E_ITEM_FIREWORK_STAR))
+	{
+		WriteChar(0);
+		return;
+	}
+
+	// Send the enchantments and custom names:
+	cFastNBTWriter Writer;
+	if (a_Item.m_RepairCost != 0)
+	{
+		Writer.AddInt("RepairCost", a_Item.m_RepairCost);
+	}
+	if (!a_Item.m_Enchantments.IsEmpty())
+	{
+		const char * TagName = (a_Item.m_ItemType == E_ITEM_BOOK) ? "StoredEnchantments" : "ench";
+		EnchantmentSerializer::WriteToNBTCompound(a_Item.m_Enchantments, Writer, TagName);
+	}
+	if (!a_Item.IsBothNameAndLoreEmpty())
+	{
+		Writer.BeginCompound("display");
+		if (!a_Item.IsCustomNameEmpty())
+		{
+			Writer.AddString("Name", a_Item.m_CustomName.c_str());
+		}
+		if (!a_Item.IsLoreEmpty())
+		{
+			Writer.BeginList("Lore", TAG_String);
+
+			AStringVector Decls = StringSplit(a_Item.m_Lore, "`");
+			for (AStringVector::const_iterator itr = Decls.begin(), end = Decls.end(); itr != end; ++itr)
+			{
+				if (itr->empty())
+				{
+					// The decl is empty (two `s), ignore
+					continue;
+				}
+				Writer.AddString("", itr->c_str());
+			}
+
+			Writer.EndList();
+		}
+		Writer.EndCompound();
+	}
+	if ((a_Item.m_ItemType == E_ITEM_FIREWORK_ROCKET) || (a_Item.m_ItemType == E_ITEM_FIREWORK_STAR))
+	{
+		cFireworkItem::WriteToNBTCompound(a_Item.m_FireworkItem, Writer, (ENUM_ITEM_ID)a_Item.m_ItemType);
+	}
+	Writer.Finish();
+
+	AString Result = Writer.GetResult();
+	if (Result.size() == 0)
+	{
+		WriteChar(0);
+		return;
+	}
+	WriteBuf(Result.data(), Result.size());
+}
+
+
+
+
+
+void cProtocol180::cPacketizer::WriteBlockEntity(const cBlockEntity & a_BlockEntity)
+{
+	cFastNBTWriter Writer;
+
+	switch (a_BlockEntity.GetBlockType())
+	{
+		case E_BLOCK_BEACON:
+		{
+			cBeaconEntity & BeaconEntity = (cBeaconEntity &)a_BlockEntity;
+
+			Writer.AddInt("x", BeaconEntity.GetPosX());
+			Writer.AddInt("y", BeaconEntity.GetPosY());
+			Writer.AddInt("z", BeaconEntity.GetPosZ());
+			Writer.AddInt("Primary", BeaconEntity.GetPrimaryEffect());
+			Writer.AddInt("Secondary", BeaconEntity.GetSecondaryEffect());
+			Writer.AddInt("Levels", BeaconEntity.GetBeaconLevel());
+			Writer.AddString("id", "Beacon");  // "Tile Entity ID" - MC wiki; vanilla server always seems to send this though
+			break;
+		}
+		case E_BLOCK_COMMAND_BLOCK:
+		{
+			cCommandBlockEntity & CommandBlockEntity = (cCommandBlockEntity &)a_BlockEntity;
+
+			Writer.AddByte("TrackOutput", 1);  // Neither I nor the MC wiki has any idea about this
+			Writer.AddInt("SuccessCount", CommandBlockEntity.GetResult());
+			Writer.AddInt("x", CommandBlockEntity.GetPosX());
+			Writer.AddInt("y", CommandBlockEntity.GetPosY());
+			Writer.AddInt("z", CommandBlockEntity.GetPosZ());
+			Writer.AddString("Command", CommandBlockEntity.GetCommand().c_str());
+			// You can set custom names for windows in Vanilla
+			// For a command block, this would be the 'name' prepended to anything it outputs into global chat
+			// MCS doesn't have this, so just leave it @ '@'. (geddit?)
+			Writer.AddString("CustomName", "@");
+			Writer.AddString("id", "Control");  // "Tile Entity ID" - MC wiki; vanilla server always seems to send this though
+
+			if (!CommandBlockEntity.GetLastOutput().empty())
+			{
+				AString Output;
+				Printf(Output, "{\"text\":\"%s\"}", CommandBlockEntity.GetLastOutput().c_str());
+
+				Writer.AddString("LastOutput", Output.c_str());
+			}
+			break;
+		}
+		case E_BLOCK_HEAD:
+		{
+			cMobHeadEntity & MobHeadEntity = (cMobHeadEntity &)a_BlockEntity;
+
+			Writer.AddInt("x", MobHeadEntity.GetPosX());
+			Writer.AddInt("y", MobHeadEntity.GetPosY());
+			Writer.AddInt("z", MobHeadEntity.GetPosZ());
+			Writer.AddByte("SkullType", MobHeadEntity.GetType() & 0xFF);
+			Writer.AddByte("Rot", MobHeadEntity.GetRotation() & 0xFF);
+			Writer.AddString("ExtraType", MobHeadEntity.GetOwner().c_str());
+			Writer.AddString("id", "Skull");  // "Tile Entity ID" - MC wiki; vanilla server always seems to send this though
+			break;
+		}
+		case E_BLOCK_FLOWER_POT:
+		{
+			cFlowerPotEntity & FlowerPotEntity = (cFlowerPotEntity &)a_BlockEntity;
+
+			Writer.AddInt("x", FlowerPotEntity.GetPosX());
+			Writer.AddInt("y", FlowerPotEntity.GetPosY());
+			Writer.AddInt("z", FlowerPotEntity.GetPosZ());
+			Writer.AddInt("Item", (Int32) FlowerPotEntity.GetItem().m_ItemType);
+			Writer.AddInt("Data", (Int32) FlowerPotEntity.GetItem().m_ItemDamage);
+			Writer.AddString("id", "FlowerPot");  // "Tile Entity ID" - MC wiki; vanilla server always seems to send this though
+			break;
+		}
+		default: break;
+	}
+
+	Writer.Finish();
+	WriteBuf(Writer.GetResult().data(), Writer.GetResult().size());
+}
+
+
+
+
+
+void cProtocol180::cPacketizer::WriteByteAngle(double a_Angle)
+{
+	WriteByte((char)(255 * a_Angle / 360));
+}
+
+
+
+
+
+void cProtocol180::cPacketizer::WriteFPInt(double a_Value)
+{
+	int Value = (int)(a_Value * 32);
+	WriteInt(Value);
+}
+
+
+
+
+
+void cProtocol180::cPacketizer::WriteEntityMetadata(const cEntity & a_Entity)
+{
+	// Common metadata:
+	Byte Flags = 0;
+	if (a_Entity.IsOnFire())
+	{
+		Flags |= 0x01;
+	}
+	if (a_Entity.IsCrouched())
+	{
+		Flags |= 0x02;
+	}
+	if (a_Entity.IsSprinting())
+	{
+		Flags |= 0x08;
+	}
+	if (a_Entity.IsRclking())
+	{
+		Flags |= 0x10;
+	}
+	if (a_Entity.IsInvisible())
+	{
+		Flags |= 0x20;
+	}
+	WriteByte(0);  // Byte(0) + index 0
+	WriteByte(Flags);
+	
+	switch (a_Entity.GetEntityType())
+	{
+		case cEntity::etPlayer: break;  // TODO?
+		case cEntity::etPickup:
+		{
+			WriteByte((5 << 5) | 10);  // Slot(5) + index 10
+			WriteItem(((const cPickup &)a_Entity).GetItem());
+			break;
+		}
+		case cEntity::etMinecart:
+		{
+			WriteByte(0x51);
+
+			// The following expression makes Minecarts shake more with less health or higher damage taken
+			// It gets half the maximum health, and takes it away from the current health minus the half health:
+			/*
+			Health: 5 | 3 - (5 - 3) = 1 (shake power)
+			Health: 3 | 3 - (3 - 3) = 3
+			Health: 1 | 3 - (1 - 3) = 5
+			*/
+			WriteInt((((a_Entity.GetMaxHealth() / 2) - (a_Entity.GetHealth() - (a_Entity.GetMaxHealth() / 2))) * ((const cMinecart &)a_Entity).LastDamage()) * 4);
+			WriteByte(0x52);
+			WriteInt(1);  // Shaking direction, doesn't seem to affect anything
+			WriteByte(0x73);
+			WriteFloat((float)(((const cMinecart &)a_Entity).LastDamage() + 10));  // Damage taken / shake effect multiplyer
+			
+			if (((cMinecart &)a_Entity).GetPayload() == cMinecart::mpNone)
+			{
+				cRideableMinecart & RideableMinecart = ((cRideableMinecart &)a_Entity);
+				const cItem & MinecartContent = RideableMinecart.GetContent();
+				if (!MinecartContent.IsEmpty())
+				{
+					WriteByte(0x54);
+					int Content = MinecartContent.m_ItemType;
+					Content |= MinecartContent.m_ItemDamage << 8;
+					WriteInt(Content);
+					WriteByte(0x55);
+					WriteInt(RideableMinecart.GetBlockHeight());
+					WriteByte(0x56);
+					WriteByte(1);
+				}
+			}
+			else if (((cMinecart &)a_Entity).GetPayload() == cMinecart::mpFurnace)
+			{
+				WriteByte(0x10);
+				WriteByte(((const cMinecartWithFurnace &)a_Entity).IsFueled() ? 1 : 0);
+			}
+			break;
+		}
+		case cEntity::etProjectile:
+		{
+			cProjectileEntity & Projectile = (cProjectileEntity &)a_Entity;
+			switch (Projectile.GetProjectileKind())
+			{
+				case cProjectileEntity::pkArrow:
+				{
+					WriteByte(0x10);
+					WriteByte(((const cArrowEntity &)a_Entity).IsCritical() ? 1 : 0);
+					break;
+				}
+				case cProjectileEntity::pkFirework:
+				{
+					WriteByte(0xA8);
+					WriteItem(((const cFireworkEntity &)a_Entity).GetItem());
+					break;
+				}
+				default: break;
+			}
+			break;
+		}
+		case cEntity::etMonster:
+		{
+			WriteMobMetadata((const cMonster &)a_Entity);
+			break;
+		}
+		case cEntity::etItemFrame:
+		{
+			cItemFrame & Frame = (cItemFrame &)a_Entity;
+			WriteByte(0xA8);
+			WriteItem(Frame.GetItem());
+			WriteByte(0x09);
+			WriteByte(Frame.GetRotation());
+			break;
+		}
+		default: break;
+	}
+}
+
+
+
+
+
+void cProtocol180::cPacketizer::WriteMobMetadata(const cMonster & a_Mob)
+{
+	switch (a_Mob.GetMobType())
+	{
+		case mtCreeper:
+		{
+			WriteByte(0x10);
+			WriteByte(((const cCreeper &)a_Mob).IsBlowing() ? 1 : -1);
+			WriteByte(0x11);
+			WriteByte(((const cCreeper &)a_Mob).IsCharged() ? 1 : 0);
+			break;
+		}
+		
+		case mtBat:
+		{
+			WriteByte(0x10);
+			WriteByte(((const cBat &)a_Mob).IsHanging() ? 1 : 0);
+			break;
+		}
+		
+		case mtPig:
+		{
+			WriteByte(0x10);
+			WriteByte(((const cPig &)a_Mob).IsSaddled() ? 1 : 0);
+			break;
+		}
+		
+		case mtVillager:
+		{
+			WriteByte(0x50);
+			WriteInt(((const cVillager &)a_Mob).GetVilType());
+			break;
+		}
+		
+		case mtZombie:
+		{
+			WriteByte(0x0c);
+			WriteByte(((const cZombie &)a_Mob).IsBaby() ? 1 : 0);
+			WriteByte(0x0d);
+			WriteByte(((const cZombie &)a_Mob).IsVillagerZombie() ? 1 : 0);
+			WriteByte(0x0e);
+			WriteByte(((const cZombie &)a_Mob).IsConverting() ? 1 : 0);
+			break;
+		}
+		
+		case mtGhast:
+		{
+			WriteByte(0x10);
+			WriteByte(((const cGhast &)a_Mob).IsCharging());
+			break;
+		}
+		
+		case mtWolf:
+		{
+			const cWolf & Wolf = (const cWolf &)a_Mob;
+			Byte WolfStatus = 0;
+			if (Wolf.IsSitting())
+			{
+				WolfStatus |= 0x1;
+			}
+			if (Wolf.IsAngry())
+			{
+				WolfStatus |= 0x2;
+			}
+			if (Wolf.IsTame())
+			{
+				WolfStatus |= 0x4;
+			}
+			WriteByte(0x10);
+			WriteByte(WolfStatus);
+
+			WriteByte(0x72);
+			WriteFloat((float)(a_Mob.GetHealth()));
+			WriteByte(0x13);
+			WriteByte(Wolf.IsBegging() ? 1 : 0);
+			WriteByte(0x14);
+			WriteByte(Wolf.GetCollarColor());
+			break;
+		}
+		
+		case mtSheep:
+		{
+			WriteByte(0x10);
+			Byte SheepMetadata = 0;
+			SheepMetadata = ((const cSheep &)a_Mob).GetFurColor();
+			if (((const cSheep &)a_Mob).IsSheared())
+			{
+				SheepMetadata |= 0x10;
+			}
+			WriteByte(SheepMetadata);
+			break;
+		}
+		
+		case mtEnderman:
+		{
+			WriteByte(0x30);
+			WriteShort((Byte)(((const cEnderman &)a_Mob).GetCarriedBlock()));
+			WriteByte(0x11);
+			WriteByte((Byte)(((const cEnderman &)a_Mob).GetCarriedMeta()));
+			WriteByte(0x12);
+			WriteByte(((const cEnderman &)a_Mob).IsScreaming() ? 1 : 0);
+			break;
+		}
+		
+		case mtSkeleton:
+		{
+			WriteByte(0x0d);
+			WriteByte(((const cSkeleton &)a_Mob).IsWither() ? 1 : 0);
+			break;
+		}
+		
+		case mtWitch:
+		{
+			WriteByte(0x15);
+			WriteByte(((const cWitch &)a_Mob).IsAngry() ? 1 : 0);
+			break;
+		}
+
+		case mtWither:
+		{
+			WriteByte(0x54);  // Int at index 20
+			WriteInt(((const cWither &)a_Mob).GetWitherInvulnerableTicks());
+			WriteByte(0x66);  // Float at index 6
+			WriteFloat((float)(a_Mob.GetHealth()));
+			break;
+		}
+		
+		case mtSlime:
+		{
+			WriteByte(0x10);
+			WriteByte(((const cSlime &)a_Mob).GetSize());
+			break;
+		}
+		
+		case mtMagmaCube:
+		{
+			WriteByte(0x10);
+			WriteByte(((const cMagmaCube &)a_Mob).GetSize());
+			break;
+		}
+		
+		case mtHorse:
+		{
+			const cHorse & Horse = (const cHorse &)a_Mob;
+			int Flags = 0;
+			if (Horse.IsTame())
+			{
+				Flags |= 0x02;
+			}
+			if (Horse.IsSaddled())
+			{
+				Flags |= 0x04;
+			}
+			if (Horse.IsChested())
+			{
+				Flags |= 0x08;
+			}
+			if (Horse.IsBaby())
+			{
+				Flags |= 0x10;
+			}
+			if (Horse.IsEating())
+			{
+				Flags |= 0x20;
+			}
+			if (Horse.IsRearing())
+			{
+				Flags |= 0x40;
+			}
+			if (Horse.IsMthOpen())
+			{
+				Flags |= 0x80;
+			}
+			WriteByte(0x50);  // Int at index 16
+			WriteInt(Flags);
+			WriteByte(0x13);  // Byte at index 19
+			WriteByte(Horse.GetHorseType());
+			WriteByte(0x54);  // Int at index 20
+			int Appearance = 0;
+			Appearance = Horse.GetHorseColor();
+			Appearance |= Horse.GetHorseStyle() << 8;
+			WriteInt(Appearance);
+			WriteByte(0x56);  // Int at index 22
+			WriteInt(Horse.GetHorseArmour());
+			break;
+		}
+	}  // switch (a_Mob.GetType())
+}
+
+
+
+
+
+void cProtocol180::cPacketizer::WriteEntityProperties(const cEntity & a_Entity)
+{
+	if (!a_Entity.IsMob())
+	{
+		// No properties for anything else than mobs
+		WriteInt(0);
+		return;
+	}
+
+	// const cMonster & Mob = (const cMonster &)a_Entity;
+
+	// TODO: Send properties and modifiers based on the mob type
+	
+	WriteInt(0);  // NumProperties
+}
+
+
+
diff --git a/src/Protocol/Protocol18x.h b/src/Protocol/Protocol18x.h
new file mode 100644
index 000000000..554edecc8
--- /dev/null
+++ b/src/Protocol/Protocol18x.h
@@ -0,0 +1,337 @@
+
+// Protocol18x.h
+
+/*
+Declares the 1.8.x protocol classes:
+	- cProtocol180
+		- release 1.8.0 protocol (#47)
+(others may be added later in the future for the 1.8 release series)
+*/
+
+
+
+
+
+#pragma once
+
+#include "Protocol.h"
+#include "../ByteBuffer.h"
+
+#ifdef _MSC_VER
+	#pragma warning(push)
+	#pragma warning(disable:4127)
+	#pragma warning(disable:4244)
+	#pragma warning(disable:4231)
+	#pragma warning(disable:4189)
+	#pragma warning(disable:4702)
+#endif
+
+#ifdef _MSC_VER
+	#pragma warning(pop)
+#endif
+
+#include "PolarSSL++/AesCfb128Decryptor.h"
+#include "PolarSSL++/AesCfb128Encryptor.h"
+
+
+
+
+
+// fwd:
+namespace Json
+{
+	class Value;
+}
+
+
+
+
+
+class cProtocol180 :
+	public cProtocol
+{
+	typedef cProtocol super;
+	
+public:
+
+	cProtocol180(cClientHandle * a_Client, const AString & a_ServerAddress, UInt16 a_ServerPort, UInt32 a_State);
+	
+	/** Called when client sends some data: */
+	virtual void DataReceived(const char * a_Data, size_t a_Size) override;
+
+	/** Sending stuff to clients (alphabetically sorted): */
+	virtual void SendAttachEntity               (const cEntity & a_Entity, const cEntity * a_Vehicle) override;
+	virtual void SendBlockAction                (int a_BlockX, int a_BlockY, int a_BlockZ, char a_Byte1, char a_Byte2, BLOCKTYPE a_BlockType) override;
+	virtual void SendBlockBreakAnim	            (int a_EntityID, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Stage) override;
+	virtual void SendBlockChange                (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) override;
+	virtual void SendBlockChanges               (int a_ChunkX, int a_ChunkZ, const sSetBlockVector & a_Changes) override;
+	virtual void SendChat                       (const AString & a_Message) override;
+	virtual void SendChat                       (const cCompositeChat & a_Message) override;
+	virtual void SendChunkData                  (int a_ChunkX, int a_ChunkZ, cChunkDataSerializer & a_Serializer) override;
+	virtual void SendCollectEntity              (const cEntity & a_Entity, const cPlayer & a_Player) override;
+	virtual void SendDestroyEntity              (const cEntity & a_Entity) override;
+	virtual void SendDisconnect                 (const AString & a_Reason) override;
+	virtual void SendEditSign                   (int a_BlockX, int a_BlockY, int a_BlockZ) override;  ///< Request the client to open up the sign editor for the sign (1.6+)
+	virtual void SendEntityEffect               (const cEntity & a_Entity, int a_EffectID, int a_Amplifier, short a_Duration) override;
+	virtual void SendEntityEquipment            (const cEntity & a_Entity, short a_SlotNum, const cItem & a_Item) override;
+	virtual void SendEntityHeadLook             (const cEntity & a_Entity) override;
+	virtual void SendEntityLook                 (const cEntity & a_Entity) override;
+	virtual void SendEntityMetadata             (const cEntity & a_Entity) override;
+	virtual void SendEntityProperties           (const cEntity & a_Entity) override;
+	virtual void SendEntityRelMove              (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ) override;
+	virtual void SendEntityRelMoveLook          (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ) override;
+	virtual void SendEntityStatus               (const cEntity & a_Entity, char a_Status) override;
+	virtual void SendEntityVelocity             (const cEntity & a_Entity) override;
+	virtual void SendExplosion                  (double a_BlockX, double a_BlockY, double a_BlockZ, float a_Radius, const cVector3iArray & a_BlocksAffected, const Vector3d & a_PlayerMotion) override;
+	virtual void SendGameMode                   (eGameMode a_GameMode) override;
+	virtual void SendHealth                     (void) override;
+	virtual void SendInventorySlot              (char a_WindowID, short a_SlotNum, const cItem & a_Item) override;
+	virtual void SendKeepAlive                  (int a_PingID) override;
+	virtual void SendLogin                      (const cPlayer & a_Player, const cWorld & a_World) override;
+	virtual void SendLoginSuccess               (void) override;
+	virtual void SendMapColumn                  (int a_ID, int a_X, int a_Y, const Byte * a_Colors, unsigned int a_Length, unsigned int m_Scale) override;
+	virtual void SendMapDecorators              (int a_ID, const cMapDecoratorList & a_Decorators, unsigned int m_Scale) override;
+	virtual void SendMapInfo                    (int a_ID, unsigned int a_Scale) override;
+	virtual void SendPaintingSpawn              (const cPainting & a_Painting) override;
+	virtual void SendPickupSpawn                (const cPickup & a_Pickup) override;
+	virtual void SendPlayerAbilities            (void) override;
+	virtual void SendEntityAnimation            (const cEntity & a_Entity, char a_Animation) override;
+	virtual void SendParticleEffect             (const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmount) override;
+	virtual void SendPlayerListAddPlayer        (const cPlayer & a_Player) override;
+	virtual void SendPlayerListRemovePlayer     (const cPlayer & a_Player) override;
+	virtual void SendPlayerListUpdateGameMode   (const cPlayer & a_Player) override;
+	virtual void SendPlayerListUpdatePing       (const cPlayer & a_Player) override;
+	virtual void SendPlayerListUpdateDisplayName(const cPlayer & a_Player, const AString & a_CustomName) override;
+	virtual void SendPlayerMaxSpeed             (void) override;
+	virtual void SendPlayerMoveLook             (void) override;
+	virtual void SendPlayerPosition             (void) override;
+	virtual void SendPlayerSpawn                (const cPlayer & a_Player) override;
+	virtual void SendPluginMessage              (const AString & a_Channel, const AString & a_Message) override;
+	virtual void SendRemoveEntityEffect         (const cEntity & a_Entity, int a_EffectID) override;
+	virtual void SendRespawn                    (eDimension a_Dimension, bool a_ShouldIgnoreDimensionChecks) override;
+	virtual void SendSoundEffect                (const AString & a_SoundName, double a_X, double a_Y, double a_Z, float a_Volume, float a_Pitch) override;
+	virtual void SendExperience                 (void) override;
+	virtual void SendExperienceOrb              (const cExpOrb & a_ExpOrb) override;
+	virtual void SendScoreboardObjective        (const AString & a_Name, const AString & a_DisplayName, Byte a_Mode) override;
+	virtual void SendScoreUpdate                (const AString & a_Objective, const AString & a_Player, cObjective::Score a_Score, Byte a_Mode) override;
+	virtual void SendDisplayObjective           (const AString & a_Objective, cScoreboard::eDisplaySlot a_Display) override;
+	virtual void SendSoundParticleEffect        (int a_EffectID, int a_SrcX, int a_SrcY, int a_SrcZ, int a_Data) override;
+	virtual void SendSpawnFallingBlock          (const cFallingBlock & a_FallingBlock) override;
+	virtual void SendSpawnMob                   (const cMonster & a_Mob) override;
+	virtual void SendSpawnObject                (const cEntity & a_Entity, char a_ObjectType, int a_ObjectData, Byte a_Yaw, Byte a_Pitch) override;
+	virtual void SendSpawnVehicle               (const cEntity & a_Vehicle, char a_VehicleType, char a_VehicleSubType) override;
+	virtual void SendStatistics                 (const cStatManager & a_Manager) override;
+	virtual void SendTabCompletionResults       (const AStringVector & a_Results) override;
+	virtual void SendTeleportEntity             (const cEntity & a_Entity) override;
+	virtual void SendThunderbolt                (int a_BlockX, int a_BlockY, int a_BlockZ) override;
+	virtual void SendTimeUpdate                 (Int64 a_WorldAge, Int64 a_TimeOfDay, bool a_DoDaylightCycle) override;
+	virtual void SendUnloadChunk                (int a_ChunkX, int a_ChunkZ) override;
+	virtual void SendUpdateBlockEntity          (cBlockEntity & a_BlockEntity) override;
+	virtual void SendUpdateSign                 (int a_BlockX, int a_BlockY, int a_BlockZ, const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4) override;
+	virtual void SendUseBed                     (const cEntity & a_Entity, int a_BlockX, int a_BlockY, int a_BlockZ) override;
+	virtual void SendWeather                    (eWeather a_Weather) override;
+	virtual void SendWholeInventory             (const cWindow & a_Window) override;
+	virtual void SendWindowClose                (const cWindow & a_Window) override;
+	virtual void SendWindowOpen                 (const cWindow & a_Window) override;
+	virtual void SendWindowProperty             (const cWindow & a_Window, int a_Property, int a_Value) override;
+
+	virtual AString GetAuthServerID(void) override { return m_AuthServerID; }
+
+	/** Compress the packet. a_Packet must be without packet length.
+	a_Compressed will be set to the compressed packet includes packet length and data length.
+	If compression fails, the function returns false. */
+	static bool CompressPacket(const AString & a_Packet, AString & a_Compressed);
+
+	/** The 1.8 protocol use a particle id instead of a string. This function converts the name to the id. If the name is incorrect, it returns 0. */
+	static int GetParticleID(const AString & a_ParticleName);
+
+	/** Minecraft 1.8 use other locations to spawn the item frame. This function converts the 1.7 positions to 1.8 positions. */
+	static void FixItemFramePositions(int a_ObjectData, double & a_PosX, double & a_PosZ, double & a_Yaw);
+
+protected:
+
+	/** Composes individual packets in the protocol's m_OutPacketBuffer; sends them upon being destructed */
+	class cPacketizer
+	{
+	public:
+		cPacketizer(cProtocol180 & a_Protocol, UInt32 a_PacketType) :
+			m_Protocol(a_Protocol),
+			m_Out(a_Protocol.m_OutPacketBuffer),
+			m_Lock(a_Protocol.m_CSPacket)
+		{
+			m_Out.WriteVarInt(a_PacketType);
+		}
+		
+		~cPacketizer();
+
+		void WriteBool(bool a_Value)
+		{
+			m_Out.WriteBool(a_Value);
+		}
+		
+		void WriteByte(Byte a_Value)
+		{
+			m_Out.WriteByte(a_Value);
+		}
+		
+		void WriteChar(char a_Value)
+		{
+			m_Out.WriteChar(a_Value);
+		}
+		
+		void WriteShort(short a_Value)
+		{
+			m_Out.WriteBEShort(a_Value);
+		}
+		
+		void WriteInt(int a_Value)
+		{
+			m_Out.WriteBEInt(a_Value);
+		}
+		
+		void WriteInt64(Int64 a_Value)
+		{
+			m_Out.WriteBEInt64(a_Value);
+		}
+		
+		void WriteFloat(float a_Value)
+		{
+			m_Out.WriteBEFloat(a_Value);
+		}
+		
+		void WriteDouble(double a_Value)
+		{
+			m_Out.WriteBEDouble(a_Value);
+		}
+		
+		void WriteVarInt(UInt32 a_Value)
+		{
+			m_Out.WriteVarInt(a_Value);
+		}
+		
+		void WriteString(const AString & a_Value)
+		{
+			m_Out.WriteVarUTF8String(a_Value);
+		}
+
+		void WritePosition(int a_BlockX, int a_BlockY, int a_BlockZ)
+		{
+			m_Out.WritePosition(a_BlockX, a_BlockY, a_BlockZ);
+		}
+		
+		void WriteUUID(const AString & a_UUID);
+		
+		void WriteBuf(const char * a_Data, size_t a_Size)
+		{
+			m_Out.Write(a_Data, a_Size);
+		}
+		
+		void WriteItem(const cItem & a_Item);
+		void WriteByteAngle(double a_Angle);  // Writes the specified angle using a single byte
+		void WriteFPInt(double a_Value);  // Writes the double value as a 27:5 fixed-point integer
+		void WriteEntityMetadata(const cEntity & a_Entity);  // Writes the metadata for the specified entity, not including the terminating 0x7f
+		void WriteMobMetadata(const cMonster & a_Mob);  // Writes the mob-specific metadata for the specified mob
+		void WriteEntityProperties(const cEntity & a_Entity);  // Writes the entity properties for the specified entity, including the Count field
+		void WriteBlockEntity(const cBlockEntity & a_BlockEntity);
+		
+	protected:
+		cProtocol180 & m_Protocol;
+		cByteBuffer & m_Out;
+		cCSLock m_Lock;
+	} ;
+
+	AString m_ServerAddress;
+	
+	UInt16 m_ServerPort;
+	
+	AString m_AuthServerID;
+	
+	/** State of the protocol. 1 = status, 2 = login, 3 = game */
+	UInt32 m_State;
+
+	/** Buffer for the received data */
+	cByteBuffer m_ReceivedData;
+	
+	/** Buffer for composing the outgoing packets, through cPacketizer */
+	cByteBuffer m_OutPacketBuffer;
+	
+	/** Buffer for composing packet length (so that each cPacketizer instance doesn't allocate a new cPacketBuffer) */
+	cByteBuffer m_OutPacketLenBuffer;
+	
+	bool m_IsEncrypted;
+	
+	cAesCfb128Decryptor m_Decryptor;
+	cAesCfb128Encryptor m_Encryptor;
+
+	/** The logfile where the comm is logged, when g_ShouldLogComm is true */
+	cFile m_CommLogFile;
+	
+	/** The dimension that was last sent to a player in a Respawn or Login packet.
+	Used to avoid Respawning into the same dimension, which confuses the client. */
+	eDimension m_LastSentDimension;
+	
+	
+	/** Adds the received (unencrypted) data to m_ReceivedData, parses complete packets */
+	void AddReceivedData(const char * a_Data, size_t a_Size);
+
+	/** Reads and handles the packet. The packet length and type have already been read.
+	Returns true if the packet was understood, false if it was an unknown packet
+	*/
+	bool HandlePacket(cByteBuffer & a_ByteBuffer, UInt32 a_PacketType);
+
+	// Packet handlers while in the Status state (m_State == 1):
+	void HandlePacketStatusPing(cByteBuffer & a_ByteBuffer);
+	void HandlePacketStatusRequest(cByteBuffer & a_ByteBuffer);
+
+	// Packet handlers while in the Login state (m_State == 2):
+	void HandlePacketLoginEncryptionResponse(cByteBuffer & a_ByteBuffer);
+	void HandlePacketLoginStart(cByteBuffer & a_ByteBuffer);
+	
+	// Packet handlers while in the Game state (m_State == 3):
+	void HandlePacketAnimation              (cByteBuffer & a_ByteBuffer);
+	void HandlePacketBlockDig               (cByteBuffer & a_ByteBuffer);
+	void HandlePacketBlockPlace             (cByteBuffer & a_ByteBuffer);
+	void HandlePacketChatMessage            (cByteBuffer & a_ByteBuffer);
+	void HandlePacketClientSettings         (cByteBuffer & a_ByteBuffer);
+	void HandlePacketClientStatus           (cByteBuffer & a_ByteBuffer);
+	void HandlePacketCreativeInventoryAction(cByteBuffer & a_ByteBuffer);
+	void HandlePacketEntityAction           (cByteBuffer & a_ByteBuffer);
+	void HandlePacketKeepAlive              (cByteBuffer & a_ByteBuffer);
+	void HandlePacketPlayer                 (cByteBuffer & a_ByteBuffer);
+	void HandlePacketPlayerAbilities        (cByteBuffer & a_ByteBuffer);
+	void HandlePacketPlayerLook             (cByteBuffer & a_ByteBuffer);
+	void HandlePacketPlayerPos              (cByteBuffer & a_ByteBuffer);
+	void HandlePacketPlayerPosLook          (cByteBuffer & a_ByteBuffer);
+	void HandlePacketPluginMessage          (cByteBuffer & a_ByteBuffer);
+	void HandlePacketSlotSelect             (cByteBuffer & a_ByteBuffer);
+	void HandlePacketSteerVehicle           (cByteBuffer & a_ByteBuffer);
+	void HandlePacketTabComplete            (cByteBuffer & a_ByteBuffer);
+	void HandlePacketUpdateSign             (cByteBuffer & a_ByteBuffer);
+	void HandlePacketUseEntity              (cByteBuffer & a_ByteBuffer);
+	void HandlePacketEnchantItem            (cByteBuffer & a_ByteBuffer);
+	void HandlePacketWindowClick            (cByteBuffer & a_ByteBuffer);
+	void HandlePacketWindowClose            (cByteBuffer & a_ByteBuffer);
+	
+	
+	/** Writes an entire packet into the output stream. a_Packet is expected to start with the packet type; data length is prepended here. */
+	void WritePacket(cByteBuffer & a_Packet);
+
+	/** Sends the data to the client, encrypting them if needed. */
+	virtual void SendData(const char * a_Data, size_t a_Size) override;
+
+	void SendCompass(const cWorld & a_World);
+	
+	/** Reads an item out of the received data, sets a_Item to the values read.
+	Returns false if not enough received data.
+	a_KeepRemainingBytes tells the function to keep that many bytes at the end of the buffer. */
+	virtual bool ReadItem(cByteBuffer & a_ByteBuffer, cItem & a_Item, size_t a_KeepRemainingBytes = 0);
+	
+	/** Parses item metadata as read by ReadItem(), into the item enchantments. */
+	void ParseItemMetadata(cItem & a_Item, const AString & a_Metadata);
+	
+	void StartEncryption(const Byte * a_Key);
+
+} ;
+
+
+
diff --git a/src/Protocol/ProtocolRecognizer.cpp b/src/Protocol/ProtocolRecognizer.cpp
index d836291c3..fe53aede1 100644
--- a/src/Protocol/ProtocolRecognizer.cpp
+++ b/src/Protocol/ProtocolRecognizer.cpp
@@ -13,6 +13,7 @@
 #include "Protocol15x.h"
 #include "Protocol16x.h"
 #include "Protocol17x.h"
+#include "Protocol18x.h"
 #include "../ClientHandle.h"
 #include "../Root.h"
 #include "../Server.h"
@@ -51,7 +52,7 @@ AString cProtocolRecognizer::GetVersionTextFromInt(int a_ProtocolVersion)
 	{
 		case PROTO_VERSION_1_2_5: return "1.2.5";
 		case PROTO_VERSION_1_3_2: return "1.3.2";
-		case PROTO_VERSION_1_4_2: return "1.4.2";
+		// case PROTO_VERSION_1_4_2: return "1.4.2";
 		case PROTO_VERSION_1_4_4: return "1.4.4";
 		case PROTO_VERSION_1_4_6: return "1.4.6";
 		case PROTO_VERSION_1_5_0: return "1.5";
@@ -62,6 +63,7 @@ AString cProtocolRecognizer::GetVersionTextFromInt(int a_ProtocolVersion)
 		case PROTO_VERSION_1_6_4: return "1.6.4";
 		case PROTO_VERSION_1_7_2: return "1.7.2";
 		case PROTO_VERSION_1_7_6: return "1.7.6";
+		case PROTO_VERSION_1_8_0: return "1.8";
 	}
 	ASSERT(!"Unknown protocol version");
 	return Printf("Unknown protocol (%d)", a_ProtocolVersion);
@@ -409,20 +411,20 @@ void cProtocolRecognizer::SendLoginSuccess(void)
 
 
 
-void cProtocolRecognizer::SendMapColumn(int a_ID, int a_X, int a_Y, const Byte * a_Colors, unsigned int a_Length)
+void cProtocolRecognizer::SendMapColumn(int a_ID, int a_X, int a_Y, const Byte * a_Colors, unsigned int a_Length, unsigned int m_Scale)
 {
 	ASSERT(m_Protocol != NULL);
-	m_Protocol->SendMapColumn(a_ID, a_X, a_Y, a_Colors, a_Length);
+	m_Protocol->SendMapColumn(a_ID, a_X, a_Y, a_Colors, a_Length, m_Scale);
 }
 
 
 
 
 
-void cProtocolRecognizer::SendMapDecorators(int a_ID, const cMapDecoratorList & a_Decorators)
+void cProtocolRecognizer::SendMapDecorators(int a_ID, const cMapDecoratorList & a_Decorators, unsigned int m_Scale)
 {
 	ASSERT(m_Protocol != NULL);
-	m_Protocol->SendMapDecorators(a_ID, a_Decorators);
+	m_Protocol->SendMapDecorators(a_ID, a_Decorators, m_Scale);
 }
 
 
@@ -439,10 +441,10 @@ void cProtocolRecognizer::SendMapInfo(int a_ID, unsigned int a_Scale)
 
 
 
-void cProtocolRecognizer::SendParticleEffect(const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmmount)
+void cProtocolRecognizer::SendParticleEffect(const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmount)
 {
 	ASSERT(m_Protocol != NULL);
-	m_Protocol->SendParticleEffect(a_ParticleName, a_SrcX, a_SrcY, a_SrcZ, a_OffsetX, a_OffsetY, a_OffsetZ, a_ParticleData, a_ParticleAmmount);
+	m_Protocol->SendParticleEffect(a_ParticleName, a_SrcX, a_SrcY, a_SrcZ, a_OffsetX, a_OffsetY, a_OffsetZ, a_ParticleData, a_ParticleAmount);
 }
 
 
@@ -487,10 +489,50 @@ void cProtocolRecognizer::SendEntityAnimation(const cEntity & a_Entity, char a_A
 
 
 
-void cProtocolRecognizer::SendPlayerListItem(const cPlayer & a_Player, bool a_IsOnline)
+void cProtocolRecognizer::SendPlayerListAddPlayer(const cPlayer & a_Player)
 {
 	ASSERT(m_Protocol != NULL);
-	m_Protocol->SendPlayerListItem(a_Player, a_IsOnline);
+	m_Protocol->SendPlayerListAddPlayer(a_Player);
+}
+
+
+
+
+
+void cProtocolRecognizer::SendPlayerListRemovePlayer(const cPlayer & a_Player)
+{
+	ASSERT(m_Protocol != NULL);
+	m_Protocol->SendPlayerListRemovePlayer(a_Player);
+}
+
+
+
+
+
+void cProtocolRecognizer::SendPlayerListUpdateGameMode(const cPlayer & a_Player)
+{
+	ASSERT(m_Protocol != NULL);
+	m_Protocol->SendPlayerListUpdateGameMode(a_Player);
+}
+
+
+
+
+
+void cProtocolRecognizer::SendPlayerListUpdatePing(const cPlayer & a_Player)
+{
+	ASSERT(m_Protocol != NULL);
+	m_Protocol->SendPlayerListUpdatePing(a_Player);
+}
+
+
+
+
+
+void cProtocolRecognizer::SendPlayerListUpdateDisplayName(const cPlayer & a_Player, const AString & a_CustomName)
+{
+	ASSERT(m_Protocol != NULL);
+	m_Protocol->SendPlayerListUpdateDisplayName(a_Player, a_CustomName);
 }
 
 
@@ -1016,6 +1058,27 @@ bool cProtocolRecognizer::TryRecognizeLengthedProtocol(UInt32 a_PacketLengthRema
 			m_Protocol = new cProtocol176(m_Client, ServerAddress, (UInt16)ServerPort, NextState);
 			return true;
 		}
+		case PROTO_VERSION_1_8_0:
+		{
+			AString ServerAddress;
+			short ServerPort;
+			UInt32 NextState;
+			if (!m_Buffer.ReadVarUTF8String(ServerAddress))
+			{
+				break;
+			}
+			if (!m_Buffer.ReadBEShort(ServerPort))
+			{
+				break;
+			}
+			if (!m_Buffer.ReadVarInt(NextState))
+			{
+				break;
+			}
+			m_Buffer.CommitRead();
+			m_Protocol = new cProtocol180(m_Client, ServerAddress, (UInt16)ServerPort, NextState);
+			return true;
+		}
 	}
 	LOGINFO("Client \"%s\" uses an unsupported protocol (lengthed, version %u)",
 		m_Client->GetIPString().c_str(), ProtocolVersion
diff --git a/src/Protocol/ProtocolRecognizer.h b/src/Protocol/ProtocolRecognizer.h
index a05aeda70..e4419f6ae 100644
--- a/src/Protocol/ProtocolRecognizer.h
+++ b/src/Protocol/ProtocolRecognizer.h
@@ -18,7 +18,7 @@
 
 
 // Adjust these if a new protocol is added or an old one is removed:
-#define MCS_CLIENT_VERSIONS "1.2.4, 1.2.5, 1.3.1, 1.3.2, 1.4.2, 1.4.4, 1.4.5, 1.4.6, 1.4.7, 1.5, 1.5.1, 1.5.2, 1.6.1, 1.6.2, 1.6.3, 1.6.4, 1.7.2, 1.7.4, 1.7.5, 1.7.6, 1.7.7, 1.7.8, 1.7.9, 1.7.10"
+#define MCS_CLIENT_VERSIONS "1.2.4, 1.2.5, 1.3.1, 1.3.2, 1.4.2, 1.4.4, 1.4.5, 1.4.6, 1.4.7, 1.5, 1.5.1, 1.5.2, 1.6.1, 1.6.2, 1.6.3, 1.6.4, 1.7.2, 1.7.4, 1.7.5, 1.7.6, 1.7.7, 1.7.8, 1.7.9, 1.7.10, 1.8"
 #define MCS_PROTOCOL_VERSIONS "29, 39, 47, 49, 51, 60, 61, 73, 74, 77, 78, 4, 5"
 
 
@@ -51,6 +51,7 @@ public:
 		// These will be kept "under" the next / latest, because the next and latest are only needed for previous protocols
 		PROTO_VERSION_1_7_2 = 4,
 		PROTO_VERSION_1_7_6 = 5,
+		PROTO_VERSION_1_8_0 = 47,
 	} ;
 
 	cProtocolRecognizer(cClientHandle * a_Client);
@@ -63,76 +64,80 @@ public:
 	virtual void DataReceived(const char * a_Data, size_t a_Size) override;
 	
 	/// Sending stuff to clients (alphabetically sorted):
-	virtual void SendAttachEntity        (const cEntity & a_Entity, const cEntity * a_Vehicle) override;
-	virtual void SendBlockAction         (int a_BlockX, int a_BlockY, int a_BlockZ, char a_Byte1, char a_Byte2, BLOCKTYPE a_BlockType) override;
-	virtual void SendBlockBreakAnim      (int a_EntityID, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Stage) override;
-	virtual void SendBlockChange         (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) override;
-	virtual void SendBlockChanges        (int a_ChunkX, int a_ChunkZ, const sSetBlockVector & a_Changes) override;
-	virtual void SendChat                (const AString & a_Message) override;
-	virtual void SendChat                (const cCompositeChat & a_Message) override;
-	virtual void SendChunkData           (int a_ChunkX, int a_ChunkZ, cChunkDataSerializer & a_Serializer) override;
-	virtual void SendCollectEntity       (const cEntity & a_Entity, const cPlayer & a_Player) override;
-	virtual void SendDestroyEntity       (const cEntity & a_Entity) override;
-	virtual void SendDisconnect          (const AString & a_Reason) override;
-	virtual void SendEditSign            (int a_BlockX, int a_BlockY, int a_BlockZ) override;  ///< Request the client to open up the sign editor for the sign (1.6+)
-	virtual void SendEntityEffect        (const cEntity & a_Entity, int a_EffectID, int a_Amplifier, short a_Duration) override;
-	virtual void SendEntityEquipment     (const cEntity & a_Entity, short a_SlotNum, const cItem & a_Item) override;
-	virtual void SendEntityHeadLook      (const cEntity & a_Entity) override;
-	virtual void SendEntityLook          (const cEntity & a_Entity) override;
-	virtual void SendEntityMetadata      (const cEntity & a_Entity) override;
-	virtual void SendEntityProperties    (const cEntity & a_Entity) override;
-	virtual void SendEntityRelMove       (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ) override;
-	virtual void SendEntityRelMoveLook   (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ) override;
-	virtual void SendEntityStatus        (const cEntity & a_Entity, char a_Status) override;
-	virtual void SendEntityVelocity      (const cEntity & a_Entity) override;
-	virtual void SendExplosion           (double a_BlockX, double a_BlockY, double a_BlockZ, float a_Radius, const cVector3iArray & a_BlocksAffected, const Vector3d & a_PlayerMotion) override;
-	virtual void SendGameMode            (eGameMode a_GameMode) override;
-	virtual void SendHealth              (void) override;
-	virtual void SendInventorySlot       (char a_WindowID, short a_SlotNum, const cItem & a_Item) override;
-	virtual void SendKeepAlive           (int a_PingID) override;
-	virtual void SendLogin               (const cPlayer & a_Player, const cWorld & a_World) override;
-	virtual void SendLoginSuccess        (void) override;
-	virtual void SendMapColumn           (int a_ID, int a_X, int a_Y, const Byte * a_Colors, unsigned int a_Length) override;
-	virtual void SendMapDecorators       (int a_ID, const cMapDecoratorList & a_Decorators) override;
-	virtual void SendMapInfo             (int a_ID, unsigned int a_Scale) override;
-	virtual void SendParticleEffect      (const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmmount) override;
-	virtual void SendPaintingSpawn       (const cPainting & a_Painting) override;
-	virtual void SendPickupSpawn         (const cPickup & a_Pickup) override;
-	virtual void SendPlayerAbilities     (void) override;
-	virtual void SendEntityAnimation     (const cEntity & a_Entity, char a_Animation) override;
-	virtual void SendPlayerListItem      (const cPlayer & a_Player, bool a_IsOnline) override;
-	virtual void SendPlayerMaxSpeed      (void) override;
-	virtual void SendPlayerMoveLook      (void) override;
-	virtual void SendPlayerPosition      (void) override;
-	virtual void SendPlayerSpawn         (const cPlayer & a_Player) override;
-	virtual void SendPluginMessage       (const AString & a_Channel, const AString & a_Message) override;
-	virtual void SendRemoveEntityEffect  (const cEntity & a_Entity, int a_EffectID) override;
-	virtual void SendRespawn             (eDimension a_Dimension, bool a_ShouldIgnoreDimensionChecks) override;
-	virtual void SendExperience          (void) override;
-	virtual void SendExperienceOrb       (const cExpOrb & a_ExpOrb) override;
-	virtual void SendScoreboardObjective (const AString & a_Name, const AString & a_DisplayName, Byte a_Mode) override;
-	virtual void SendScoreUpdate         (const AString & a_Objective, const AString & a_Player, cObjective::Score a_Score, Byte a_Mode) override;
-	virtual void SendDisplayObjective    (const AString & a_Objective, cScoreboard::eDisplaySlot a_Display) override;
-	virtual void SendSoundEffect         (const AString & a_SoundName, double a_X, double a_Y, double a_Z, float a_Volume, float a_Pitch) override;
-	virtual void SendSoundParticleEffect (int a_EffectID, int a_SrcX, int a_SrcY, int a_SrcZ, int a_Data) override;
-	virtual void SendSpawnFallingBlock   (const cFallingBlock & a_FallingBlock) override;
-	virtual void SendSpawnMob            (const cMonster & a_Mob) override;
-	virtual void SendSpawnObject         (const cEntity & a_Entity, char a_ObjectType, int a_ObjectData, Byte a_Yaw, Byte a_Pitch) override;
-	virtual void SendSpawnVehicle        (const cEntity & a_Vehicle, char a_VehicleType, char a_VehicleSubType) override;
-	virtual void SendStatistics          (const cStatManager & a_Manager) override;
-	virtual void SendTabCompletionResults(const AStringVector & a_Results) override;
-	virtual void SendTeleportEntity      (const cEntity & a_Entity) override;
-	virtual void SendThunderbolt         (int a_BlockX, int a_BlockY, int a_BlockZ) override;
-	virtual void SendTimeUpdate          (Int64 a_WorldAge, Int64 a_TimeOfDay, bool a_DoDaylightCycle) override;
-	virtual void SendUnloadChunk         (int a_ChunkX, int a_ChunkZ) override;
-	virtual void SendUpdateBlockEntity   (cBlockEntity & a_BlockEntity) override;
-	virtual void SendUpdateSign          (int a_BlockX, int a_BlockY, int a_BlockZ, const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4) override;
-	virtual void SendUseBed              (const cEntity & a_Entity, int a_BlockX, int a_BlockY, int a_BlockZ) override;
-	virtual void SendWeather             (eWeather a_Weather) override;
-	virtual void SendWholeInventory      (const cWindow & a_Window) override;
-	virtual void SendWindowClose         (const cWindow & a_Window) override;
-	virtual void SendWindowOpen          (const cWindow & a_Window) override;
-	virtual void SendWindowProperty      (const cWindow & a_Window, int a_Property, int a_Value) override;
+	virtual void SendAttachEntity               (const cEntity & a_Entity, const cEntity * a_Vehicle) override;
+	virtual void SendBlockAction                (int a_BlockX, int a_BlockY, int a_BlockZ, char a_Byte1, char a_Byte2, BLOCKTYPE a_BlockType) override;
+	virtual void SendBlockBreakAnim             (int a_EntityID, int a_BlockX, int a_BlockY, int a_BlockZ, char a_Stage) override;
+	virtual void SendBlockChange                (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) override;
+	virtual void SendBlockChanges               (int a_ChunkX, int a_ChunkZ, const sSetBlockVector & a_Changes) override;
+	virtual void SendChat                       (const AString & a_Message) override;
+	virtual void SendChat                       (const cCompositeChat & a_Message) override;
+	virtual void SendChunkData                  (int a_ChunkX, int a_ChunkZ, cChunkDataSerializer & a_Serializer) override;
+	virtual void SendCollectEntity              (const cEntity & a_Entity, const cPlayer & a_Player) override;
+	virtual void SendDestroyEntity              (const cEntity & a_Entity) override;
+	virtual void SendDisconnect                 (const AString & a_Reason) override;
+	virtual void SendEditSign                   (int a_BlockX, int a_BlockY, int a_BlockZ) override;  ///< Request the client to open up the sign editor for the sign (1.6+)
+	virtual void SendEntityEffect               (const cEntity & a_Entity, int a_EffectID, int a_Amplifier, short a_Duration) override;
+	virtual void SendEntityEquipment            (const cEntity & a_Entity, short a_SlotNum, const cItem & a_Item) override;
+	virtual void SendEntityHeadLook             (const cEntity & a_Entity) override;
+	virtual void SendEntityLook                 (const cEntity & a_Entity) override;
+	virtual void SendEntityMetadata             (const cEntity & a_Entity) override;
+	virtual void SendEntityProperties           (const cEntity & a_Entity) override;
+	virtual void SendEntityRelMove              (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ) override;
+	virtual void SendEntityRelMoveLook          (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ) override;
+	virtual void SendEntityStatus               (const cEntity & a_Entity, char a_Status) override;
+	virtual void SendEntityVelocity             (const cEntity & a_Entity) override;
+	virtual void SendExplosion                  (double a_BlockX, double a_BlockY, double a_BlockZ, float a_Radius, const cVector3iArray & a_BlocksAffected, const Vector3d & a_PlayerMotion) override;
+	virtual void SendGameMode                   (eGameMode a_GameMode) override;
+	virtual void SendHealth                     (void) override;
+	virtual void SendInventorySlot              (char a_WindowID, short a_SlotNum, const cItem & a_Item) override;
+	virtual void SendKeepAlive                  (int a_PingID) override;
+	virtual void SendLogin                      (const cPlayer & a_Player, const cWorld & a_World) override;
+	virtual void SendLoginSuccess               (void) override;
+	virtual void SendMapColumn                  (int a_ID, int a_X, int a_Y, const Byte * a_Colors, unsigned int a_Length, unsigned int m_Scale) override;
+	virtual void SendMapDecorators              (int a_ID, const cMapDecoratorList & a_Decorators, unsigned int m_Scale) override;
+	virtual void SendMapInfo                    (int a_ID, unsigned int a_Scale) override;
+	virtual void SendParticleEffect             (const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmount) override;
+	virtual void SendPaintingSpawn              (const cPainting & a_Painting) override;
+	virtual void SendPickupSpawn                (const cPickup & a_Pickup) override;
+	virtual void SendPlayerAbilities            (void) override;
+	virtual void SendEntityAnimation            (const cEntity & a_Entity, char a_Animation) override;
+	virtual void SendPlayerListAddPlayer        (const cPlayer & a_Player) override;
+	virtual void SendPlayerListRemovePlayer     (const cPlayer & a_Player) override;
+	virtual void SendPlayerListUpdateGameMode   (const cPlayer & a_Player) override;
+	virtual void SendPlayerListUpdatePing       (const cPlayer & a_Player) override;
+	virtual void SendPlayerListUpdateDisplayName(const cPlayer & a_Player, const AString & a_CustomName) override;
+	virtual void SendPlayerMaxSpeed             (void) override;
+	virtual void SendPlayerMoveLook             (void) override;
+	virtual void SendPlayerPosition             (void) override;
+	virtual void SendPlayerSpawn                (const cPlayer & a_Player) override;
+	virtual void SendPluginMessage              (const AString & a_Channel, const AString & a_Message) override;
+	virtual void SendRemoveEntityEffect         (const cEntity & a_Entity, int a_EffectID) override;
+	virtual void SendRespawn                    (eDimension a_Dimension, bool a_ShouldIgnoreDimensionChecks) override;
+	virtual void SendExperience                 (void) override;
+	virtual void SendExperienceOrb              (const cExpOrb & a_ExpOrb) override;
+	virtual void SendScoreboardObjective        (const AString & a_Name, const AString & a_DisplayName, Byte a_Mode) override;
+	virtual void SendScoreUpdate                (const AString & a_Objective, const AString & a_Player, cObjective::Score a_Score, Byte a_Mode) override;
+	virtual void SendDisplayObjective           (const AString & a_Objective, cScoreboard::eDisplaySlot a_Display) override;
+	virtual void SendSoundEffect                (const AString & a_SoundName, double a_X, double a_Y, double a_Z, float a_Volume, float a_Pitch) override;
+	virtual void SendSoundParticleEffect        (int a_EffectID, int a_SrcX, int a_SrcY, int a_SrcZ, int a_Data) override;
+	virtual void SendSpawnFallingBlock          (const cFallingBlock & a_FallingBlock) override;
+	virtual void SendSpawnMob                   (const cMonster & a_Mob) override;
+	virtual void SendSpawnObject                (const cEntity & a_Entity, char a_ObjectType, int a_ObjectData, Byte a_Yaw, Byte a_Pitch) override;
+	virtual void SendSpawnVehicle               (const cEntity & a_Vehicle, char a_VehicleType, char a_VehicleSubType) override;
+	virtual void SendStatistics                 (const cStatManager & a_Manager) override;
+	virtual void SendTabCompletionResults       (const AStringVector & a_Results) override;
+	virtual void SendTeleportEntity             (const cEntity & a_Entity) override;
+	virtual void SendThunderbolt                (int a_BlockX, int a_BlockY, int a_BlockZ) override;
+	virtual void SendTimeUpdate                 (Int64 a_WorldAge, Int64 a_TimeOfDay, bool a_DoDaylightCycle) override;
+	virtual void SendUnloadChunk                (int a_ChunkX, int a_ChunkZ) override;
+	virtual void SendUpdateBlockEntity          (cBlockEntity & a_BlockEntity) override;
+	virtual void SendUpdateSign                 (int a_BlockX, int a_BlockY, int a_BlockZ, const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4) override;
+	virtual void SendUseBed                     (const cEntity & a_Entity, int a_BlockX, int a_BlockY, int a_BlockZ) override;
+	virtual void SendWeather                    (eWeather a_Weather) override;
+	virtual void SendWholeInventory             (const cWindow & a_Window) override;
+	virtual void SendWindowClose                (const cWindow & a_Window) override;
+	virtual void SendWindowOpen                 (const cWindow & a_Window) override;
+	virtual void SendWindowProperty             (const cWindow & a_Window, int a_Property, int a_Value) override;
 	
 	virtual AString GetAuthServerID(void) override;
 
diff --git a/src/Simulator/CMakeLists.txt b/src/Simulator/CMakeLists.txt
index 521b145b6..5aa406717 100644
--- a/src/Simulator/CMakeLists.txt
+++ b/src/Simulator/CMakeLists.txt
@@ -10,7 +10,6 @@ SET (SRCS
 	FloodyFluidSimulator.cpp
 	FluidSimulator.cpp
 	IncrementalRedstoneSimulator.cpp
-	RedstoneSimulator.cpp
 	SandSimulator.cpp
 	Simulator.cpp
 	SimulatorManager.cpp
diff --git a/src/Simulator/FireSimulator.cpp b/src/Simulator/FireSimulator.cpp
index cdb5abde2..7ae84af7b 100644
--- a/src/Simulator/FireSimulator.cpp
+++ b/src/Simulator/FireSimulator.cpp
@@ -179,6 +179,17 @@ bool cFireSimulator::IsFuel(BLOCKTYPE a_BlockType)
 		case E_BLOCK_WOOL:
 		case E_BLOCK_BOOKCASE:
 		case E_BLOCK_FENCE:
+		case E_BLOCK_SPRUCE_FENCE:
+		case E_BLOCK_BIRCH_FENCE:
+		case E_BLOCK_JUNGLE_FENCE:
+		case E_BLOCK_DARK_OAK_FENCE:
+		case E_BLOCK_ACACIA_FENCE:
+		case E_BLOCK_FENCE_GATE:
+		case E_BLOCK_SPRUCE_FENCE_GATE:
+		case E_BLOCK_BIRCH_FENCE_GATE:
+		case E_BLOCK_JUNGLE_FENCE_GATE:
+		case E_BLOCK_DARK_OAK_FENCE_GATE:
+		case E_BLOCK_ACACIA_FENCE_GATE:
 		case E_BLOCK_TNT:
 		case E_BLOCK_VINES:
 		case E_BLOCK_HAY_BALE:
diff --git a/src/Simulator/FireSimulator.h b/src/Simulator/FireSimulator.h
index 9ccc3ef4f..f76dbe342 100644
--- a/src/Simulator/FireSimulator.h
+++ b/src/Simulator/FireSimulator.h
@@ -16,7 +16,7 @@ it progresses to the next step (blockmeta++). This value is updated if a neighbo
 The simulator reads its parameters from the ini file given to the constructor.
 */
 class cFireSimulator :
-	public cSimulator
+	public cSimulator<cChunk, cWorld>
 {
 public:
 	cFireSimulator(cWorld & a_World, cIniFile & a_IniFile);
diff --git a/src/Simulator/FloodyFluidSimulator.cpp b/src/Simulator/FloodyFluidSimulator.cpp
index 2c5c4b658..b839aa746 100644
--- a/src/Simulator/FloodyFluidSimulator.cpp
+++ b/src/Simulator/FloodyFluidSimulator.cpp
@@ -12,6 +12,7 @@
 #include "../BlockArea.h"
 #include "../Blocks/BlockHandler.h"
 #include "../BlockInServerPluginInterface.h"
+#include "../Blocks/ChunkInterface.h"
 
 
 
diff --git a/src/Simulator/FluidSimulator.h b/src/Simulator/FluidSimulator.h
index 672b740a2..0877a7bf1 100644
--- a/src/Simulator/FluidSimulator.h
+++ b/src/Simulator/FluidSimulator.h
@@ -4,7 +4,8 @@
 #include "Simulator.h"
 
 
-
+class cChunk;
+class cWorld;
 
 
 enum Direction
@@ -36,9 +37,9 @@ public:
 
 
 class cFluidSimulator :
-	public cSimulator
+	public cSimulator<cChunk, cWorld>
 {
-	typedef cSimulator super;
+	typedef cSimulator<cChunk, cWorld> super;
 	
 public:
 	cFluidSimulator(cWorld & a_World, BLOCKTYPE a_Fluid, BLOCKTYPE a_StationaryFluid);
diff --git a/src/Simulator/IncrementalRedstoneSimulator.cpp b/src/Simulator/IncrementalRedstoneSimulator.cpp
index 7b3a2c2fa..df05a9fee 100644
--- a/src/Simulator/IncrementalRedstoneSimulator.cpp
+++ b/src/Simulator/IncrementalRedstoneSimulator.cpp
@@ -1,2216 +1,24 @@
 
-#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
+#include "Globals.h"
 
-#include "IncrementalRedstoneSimulator.h"
-#include "BoundingBox.h"
-#include "../BlockEntities/RedstonePoweredEntity.h"
-#include "../BlockEntities/ChestEntity.h"
-#include "../BlockEntities/CommandBlockEntity.h"
-#include "../Entities/Pickup.h"
-#include "../Blocks/BlockTorch.h"
-#include "../Blocks/BlockDoor.h"
-#include "../Blocks/BlockButton.h"
-#include "../Blocks/BlockLever.h"
-#include "../Blocks/BlockPiston.h"
-#include "../Blocks/BlockTripwireHook.h"
+#include "BlockEntities/ChestEntity.h"
 
+typedef cItemCallback<cChestEntity> cChestCallback;
 
+#include "IncrementalRedstoneSimulator.inc"
 
+#include "Chunk.h"
+#include "World.h"
+#include "Blocks/GetHandlerCompileTimeTemplate.h"
+#include "Blocks/BlockTorch.h"
+#include "Blocks/BlockLever.h"
+#include "Blocks/BlockButton.h"
+#include "Blocks/BlockTripwireHook.h"
+#include "Blocks/BlockDoor.h"
+#include "Blocks/BlockPiston.h"
 
-
-cIncrementalRedstoneSimulator::cIncrementalRedstoneSimulator(cWorld & a_World) :
-	super(a_World),
-	m_RedstoneSimulatorChunkData(),
-	m_PoweredBlocks(),
-	m_LinkedPoweredBlocks(),
-	m_SimulatedPlayerToggleableBlocks(),
-	m_RepeatersDelayList(),
-	m_Chunk()
-{
-}
-
-
-
-
-
-cIncrementalRedstoneSimulator::~cIncrementalRedstoneSimulator()
-{
-}
-
-
-
-
-
-void cIncrementalRedstoneSimulator::RedstoneAddBlock(int a_BlockX, int a_BlockY, int a_BlockZ, cChunk * a_Chunk, cChunk * a_OtherChunk)
-{
-	if ((a_Chunk == NULL) || !a_Chunk->IsValid())
-	{
-		return;
-	}
-	else if ((a_BlockY < 0) || (a_BlockY > cChunkDef::Height))
-	{
-		return;
-	}
-
-	// We may be called with coordinates in a chunk that is not the first chunk parameter
-	// In that case, the actual chunk (which the coordinates are in), will be passed as the second parameter
-	// Use that Chunk pointer to get a relative position
-
-	int RelX = 0;
-	int RelZ = 0;
-	BLOCKTYPE Block;
-	NIBBLETYPE Meta;
-
-	if (a_OtherChunk != NULL)
-	{
-		RelX = a_BlockX - a_OtherChunk->GetPosX() * cChunkDef::Width;
-		RelZ = a_BlockZ - a_OtherChunk->GetPosZ() * cChunkDef::Width;
-		a_OtherChunk->GetBlockTypeMeta(RelX, a_BlockY, RelZ, Block, Meta);
-
-		// If a_OtherChunk is passed (not NULL), it is the chunk that had a block change, and a_Chunk will be the neighbouring chunk of that block
-		// Because said neighbouring chunk does not know of this change but still needs to update its redstone, we set it to dirty
-		a_Chunk->SetIsRedstoneDirty(true);
-	}
-	else
-	{
-		RelX = a_BlockX - a_Chunk->GetPosX() * cChunkDef::Width;
-		RelZ = a_BlockZ - a_Chunk->GetPosZ() * cChunkDef::Width;
-		a_Chunk->GetBlockTypeMeta(RelX, a_BlockY, RelZ, Block, Meta);
-	}
-
-	// Every time a block is changed (AddBlock called), we want to go through all lists and check to see if the coordiantes stored within are still valid
-	// Checking only when a block is changed, as opposed to every tick, also improves performance
-
-	PoweredBlocksList * PoweredBlocks = a_Chunk->GetRedstoneSimulatorPoweredBlocksList();
-	for (PoweredBlocksList::iterator itr = PoweredBlocks->begin(); itr != PoweredBlocks->end();)
-	{
-		if (!itr->a_SourcePos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)))
-		{
-			++itr;
-			continue;
-		}
-
-		if (!IsPotentialSource(Block))
-		{
-			LOGD("cIncrementalRedstoneSimulator: Erased block @ {%i, %i, %i} from powered blocks list as it no longer connected to a source", itr->a_BlockPos.x, itr->a_BlockPos.y, itr->a_BlockPos.z);
-			itr = PoweredBlocks->erase(itr);
-			continue;
-		}
-		else if (
-			// Changeable sources
-			((Block == E_BLOCK_REDSTONE_WIRE) && (Meta == 0)) ||
-			((Block == E_BLOCK_LEVER) && !IsLeverOn(Meta)) ||
-			((Block == E_BLOCK_DETECTOR_RAIL) && ((Meta & 0x08) == 0)) ||
-			(((Block == E_BLOCK_STONE_BUTTON) || (Block == E_BLOCK_WOODEN_BUTTON)) && (!IsButtonOn(Meta))) ||
-			((Block == E_BLOCK_TRIPWIRE_HOOK) && ((Meta & 0x08) == 0))
-			)
-		{
-			LOGD("cIncrementalRedstoneSimulator: Erased block @ {%i, %i, %i} from powered blocks list due to present/past metadata mismatch", itr->a_BlockPos.x, itr->a_BlockPos.y, itr->a_BlockPos.z);
-			itr = PoweredBlocks->erase(itr);
-			continue;
-		}
-		++itr;
-	}
-
-	LinkedBlocksList * LinkedPoweredBlocks = a_Chunk->GetRedstoneSimulatorLinkedBlocksList();
-	// We loop through all values (insteading of breaking out at the first) to make sure everything is gone, as there can be multiple SourceBlock entries for one AddBlock coordinate
-	for (LinkedBlocksList::iterator itr = LinkedPoweredBlocks->begin(); itr != LinkedPoweredBlocks->end();)
-	{
-		if (itr->a_SourcePos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)))
-		{
-			if (!IsPotentialSource(Block))
-			{
-				LOGD("cIncrementalRedstoneSimulator: Erased block @ {%i, %i, %i} from linked powered blocks list as it is no longer connected to a source", itr->a_BlockPos.x, itr->a_BlockPos.y, itr->a_BlockPos.z);
-				itr = LinkedPoweredBlocks->erase(itr);
-				continue;
-			}
-			else if (
-				// Things that can send power through a block but which depends on meta
-				((Block == E_BLOCK_REDSTONE_WIRE) && (Meta == 0)) ||
-				((Block == E_BLOCK_LEVER) && !IsLeverOn(Meta)) ||
-				(((Block == E_BLOCK_STONE_BUTTON) || (Block == E_BLOCK_WOODEN_BUTTON)) && (!IsButtonOn(Meta)))
-				)
-			{
-				LOGD("cIncrementalRedstoneSimulator: Erased block @ {%i, %i, %i} from linked powered blocks list due to present/past metadata mismatch", itr->a_BlockPos.x, itr->a_BlockPos.y, itr->a_BlockPos.z);
-				itr = LinkedPoweredBlocks->erase(itr);
-				continue;
-			}
-		}
-		else if (itr->a_MiddlePos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)))
-		{
-			if (!IsViableMiddleBlock(Block))
-			{
-				LOGD("cIncrementalRedstoneSimulator: Erased block @ {%i, %i, %i} from linked powered blocks list as it is no longer powered through a valid middle block", itr->a_BlockPos.x, itr->a_BlockPos.y, itr->a_BlockPos.z);
-				itr = LinkedPoweredBlocks->erase(itr);
-				continue;
-			}
-		}
-		++itr;
-	}
-
-	SimulatedPlayerToggleableList * SimulatedPlayerToggleableBlocks = a_Chunk->GetRedstoneSimulatorSimulatedPlayerToggleableList();
-	for (SimulatedPlayerToggleableList::iterator itr = SimulatedPlayerToggleableBlocks->begin(); itr != SimulatedPlayerToggleableBlocks->end(); ++itr)
-	{
-		if (!itr->a_RelBlockPos.Equals(Vector3i(RelX, a_BlockY, RelZ)))
-		{
-			continue;
-		}
-
-		if (!IsAllowedBlock(Block))
-		{
-			LOGD("cIncrementalRedstoneSimulator: Erased block @ {%i, %i, %i} from toggleable simulated list as it is no longer redstone", itr->a_RelBlockPos.x, itr->a_RelBlockPos.y, itr->a_RelBlockPos.z);
-			SimulatedPlayerToggleableBlocks->erase(itr);
-			break;
-		}
-	}
-
-	RepeatersDelayList * RepeatersDelayList = a_Chunk->GetRedstoneSimulatorRepeatersDelayList();
-	for (RepeatersDelayList::iterator itr = RepeatersDelayList->begin(); itr != RepeatersDelayList->end(); ++itr)
-	{
-		if (!itr->a_RelBlockPos.Equals(Vector3i(RelX, a_BlockY, RelZ)))
-		{
-			continue;
-		}
-
-		if ((Block != E_BLOCK_REDSTONE_REPEATER_ON) && (Block != E_BLOCK_REDSTONE_REPEATER_OFF))
-		{
-			RepeatersDelayList->erase(itr);
-			break;
-		}
-	}
-
-	if (a_OtherChunk != NULL)
-	{
-		// DO NOT touch our chunk's data structure if we are being called with coordinates from another chunk - this one caused me massive grief :P
-		return;
-	}
-
-	cRedstoneSimulatorChunkData * RedstoneSimulatorChunkData = a_Chunk->GetRedstoneSimulatorData();
-	for (cRedstoneSimulatorChunkData::iterator itr = RedstoneSimulatorChunkData->begin(); itr != RedstoneSimulatorChunkData->end(); ++itr)
-	{
-		if ((itr->x == RelX) && (itr->y == a_BlockY) && (itr->z == RelZ))  // We are at an entry matching the current (changed) block
-		{
-			if (!IsAllowedBlock(Block))
-			{
-				itr->DataTwo = true;  // The new blocktype is not redstone; it must be queued to be removed from this list
-			}
-			else
-			{
-				itr->DataTwo = false;
-				itr->Data = Block;  // Update block information
-			}
-			return;
-		}
-	}
-
-	if (!IsAllowedBlock(Block))
-	{
-		return;
-	}
-	
-	for (cRedstoneSimulatorChunkData::iterator itr = a_Chunk->GetRedstoneSimulatorQueuedData()->begin(); itr != a_Chunk->GetRedstoneSimulatorQueuedData()->end(); ++itr)
-	{
-		if ((itr->x == RelX) && (itr->y == a_BlockY) && (itr->z == RelZ))
-		{
-			// Can't have duplicates in here either, in case something adds the block again before the structure can written to the main chunk data
-			return;
-		}
-	}
-	a_Chunk->GetRedstoneSimulatorQueuedData()->push_back(cCoordWithBlockAndBool(RelX, a_BlockY, RelZ, Block, false));
-}
-
-
-
-
-
-void cIncrementalRedstoneSimulator::SimulateChunk(float a_Dt, int a_ChunkX, int a_ChunkZ, cChunk * a_Chunk)
-{
-	m_RedstoneSimulatorChunkData = a_Chunk->GetRedstoneSimulatorData();
-	if (m_RedstoneSimulatorChunkData->empty() && a_Chunk->GetRedstoneSimulatorQueuedData()->empty())
-	{
-		return;
-	}
-
-	m_RedstoneSimulatorChunkData->insert(m_RedstoneSimulatorChunkData->end(), a_Chunk->GetRedstoneSimulatorQueuedData()->begin(), a_Chunk->GetRedstoneSimulatorQueuedData()->end());
-	a_Chunk->GetRedstoneSimulatorQueuedData()->clear();
-
-	m_PoweredBlocks = a_Chunk->GetRedstoneSimulatorPoweredBlocksList();
-	m_RepeatersDelayList = a_Chunk->GetRedstoneSimulatorRepeatersDelayList();
-	m_SimulatedPlayerToggleableBlocks = a_Chunk->GetRedstoneSimulatorSimulatedPlayerToggleableList();
-	m_LinkedPoweredBlocks = a_Chunk->GetRedstoneSimulatorLinkedBlocksList();
-	m_Chunk = a_Chunk;
-	bool ShouldUpdateSimulateOnceBlocks = false;
-
-	if (a_Chunk->IsRedstoneDirty())
-	{
-		// Simulate the majority of devices only if something (blockwise or power-wise) has changed
-		// Make sure to allow the chunk to resimulate after the initial run if there was a power change (ShouldUpdateSimulateOnceBlocks helps to do this)
-		a_Chunk->SetIsRedstoneDirty(false);
-		ShouldUpdateSimulateOnceBlocks = true;
-	}
-
-	HandleRedstoneRepeaterDelays();
-
-	for (cRedstoneSimulatorChunkData::iterator dataitr = m_RedstoneSimulatorChunkData->begin(); dataitr != m_RedstoneSimulatorChunkData->end();)
-	{
-		if (dataitr->DataTwo)
-		{
-			dataitr = m_RedstoneSimulatorChunkData->erase(dataitr);
-			continue;
-		}
-
-		switch (dataitr->Data)
-		{
-			case E_BLOCK_DAYLIGHT_SENSOR: HandleDaylightSensor(dataitr->x, dataitr->y, dataitr->z); break;
-			case E_BLOCK_TRIPWIRE:        HandleTripwire(dataitr->x, dataitr->y, dataitr->z);       break;
-			case E_BLOCK_TRIPWIRE_HOOK:   HandleTripwireHook(dataitr->x, dataitr->y, dataitr->z);   break;
-
-			case E_BLOCK_WOODEN_PRESSURE_PLATE:
-			case E_BLOCK_STONE_PRESSURE_PLATE:
-			case E_BLOCK_LIGHT_WEIGHTED_PRESSURE_PLATE:
-			case E_BLOCK_HEAVY_WEIGHTED_PRESSURE_PLATE:
-			{
-				HandlePressurePlate(dataitr->x, dataitr->y, dataitr->z, dataitr->Data);
-				break;
-			}
-			default: break;
-		}
-
-		if (ShouldUpdateSimulateOnceBlocks)
-		{
-			switch (dataitr->Data)
-			{
-				case E_BLOCK_REDSTONE_WIRE:         HandleRedstoneWire(dataitr->x, dataitr->y, dataitr->z);	  break;
-				case E_BLOCK_COMMAND_BLOCK:         HandleCommandBlock(dataitr->x, dataitr->y, dataitr->z);   break;
-				case E_BLOCK_NOTE_BLOCK:            HandleNoteBlock(dataitr->x, dataitr->y, dataitr->z);      break;
-				case E_BLOCK_BLOCK_OF_REDSTONE:     HandleRedstoneBlock(dataitr->x, dataitr->y, dataitr->z);  break;
-				case E_BLOCK_LEVER:                 HandleRedstoneLever(dataitr->x, dataitr->y, dataitr->z);  break;
-				case E_BLOCK_FENCE_GATE:            HandleFenceGate(dataitr->x, dataitr->y, dataitr->z);      break;
-				case E_BLOCK_TNT:                   HandleTNT(dataitr->x, dataitr->y, dataitr->z);            break;
-				case E_BLOCK_TRAPDOOR:              HandleTrapdoor(dataitr->x, dataitr->y, dataitr->z);       break;
-				case E_BLOCK_TRAPPED_CHEST:         HandleTrappedChest(dataitr->x, dataitr->y, dataitr->z);   break;
-
-				case E_BLOCK_ACTIVATOR_RAIL:
-				case E_BLOCK_DETECTOR_RAIL:
-				case E_BLOCK_POWERED_RAIL:
-				{
-					HandleRail(dataitr->x, dataitr->y, dataitr->z, dataitr->Data);
-					break;
-				}
-				case E_BLOCK_WOODEN_DOOR:
-				case E_BLOCK_IRON_DOOR:
-				{
-					HandleDoor(dataitr->x, dataitr->y, dataitr->z);
-					break;
-				}
-				case E_BLOCK_REDSTONE_LAMP_OFF:
-				case E_BLOCK_REDSTONE_LAMP_ON:
-				{
-					HandleRedstoneLamp(dataitr->x, dataitr->y, dataitr->z, dataitr->Data);
-					break;
-				}
-				case E_BLOCK_DISPENSER:
-				case E_BLOCK_DROPPER:
-				{
-					HandleDropSpenser(dataitr->x, dataitr->y, dataitr->z);
-					break;
-				}
-				case E_BLOCK_PISTON:
-				case E_BLOCK_STICKY_PISTON:
-				{
-					HandlePiston(dataitr->x, dataitr->y, dataitr->z);
-					break;
-				}
-				case E_BLOCK_REDSTONE_REPEATER_OFF:
-				case E_BLOCK_REDSTONE_REPEATER_ON:
-				{
-					HandleRedstoneRepeater(dataitr->x, dataitr->y, dataitr->z, dataitr->Data);
-					break;
-				}
-				case E_BLOCK_REDSTONE_TORCH_OFF:
-				case E_BLOCK_REDSTONE_TORCH_ON:
-				{
-					HandleRedstoneTorch(dataitr->x, dataitr->y, dataitr->z, dataitr->Data);
-					break;
-				}
-				case E_BLOCK_STONE_BUTTON:
-				case E_BLOCK_WOODEN_BUTTON:
-				{
-					HandleRedstoneButton(dataitr->x, dataitr->y, dataitr->z);
-					break;
-				}
-				default: break;
-			}
-		}
-		++dataitr;
-	}
-}
-
-
-
-
-void cIncrementalRedstoneSimulator::WakeUp(int a_BlockX, int a_BlockY, int a_BlockZ, cChunk * a_Chunk)
-{
-	if (AreCoordsOnChunkBoundary(a_BlockX, a_BlockY, a_BlockZ))
-	{
-		// On a chunk boundary, alert all four sides (i.e. at least one neighbouring chunk)
-		AddBlock(a_BlockX, a_BlockY, a_BlockZ, a_Chunk);
-
-		// Pass the original coordinates, because when adding things to our simulator lists, we get the chunk that they are in, and therefore any updates need to preseve their position
-		// RedstoneAddBlock to pass both the neighbouring chunk and the chunk which the coordinates are in and +- 2 in GetNeighbour() to accomodate for LinkedPowered blocks being 2 away from chunk boundaries
-		RedstoneAddBlock(a_BlockX, a_BlockY, a_BlockZ, a_Chunk->GetNeighborChunk(a_BlockX - 2, a_BlockZ), a_Chunk);
-		RedstoneAddBlock(a_BlockX, a_BlockY, a_BlockZ, a_Chunk->GetNeighborChunk(a_BlockX + 2, a_BlockZ), a_Chunk);
-		RedstoneAddBlock(a_BlockX, a_BlockY, a_BlockZ, a_Chunk->GetNeighborChunk(a_BlockX, a_BlockZ - 2), a_Chunk);
-		RedstoneAddBlock(a_BlockX, a_BlockY, a_BlockZ, a_Chunk->GetNeighborChunk(a_BlockX, a_BlockZ + 2), a_Chunk);
-
-		return;
-	}
-
-	// Not on boundary, just alert this chunk for speed
-	AddBlock(a_BlockX, a_BlockY, a_BlockZ, a_Chunk);
-}
-
-
-
-
-
-void cIncrementalRedstoneSimulator::HandleRedstoneTorch(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, BLOCKTYPE a_MyState)
-{
-	static const struct  // Define which directions the torch can power
-	{
-		int x, y, z;
-	} gCrossCoords[] =
-	{
-		{ 1, 0,  0},
-		{-1, 0,  0},
-		{ 0, 0,  1},
-		{ 0, 0, -1},
-		{ 0, 1,  0},
-	} ;
-
-	if (a_MyState == E_BLOCK_REDSTONE_TORCH_ON)
-	{
-		// Check if the block the torch is on is powered
-		int X = a_RelBlockX; int Y = a_RelBlockY; int Z = a_RelBlockZ;
-		AddFaceDirection(X, Y, Z, cBlockTorchHandler::MetaDataToDirection(m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ)), true);  // Inverse true to get the block torch is on
-
-		cChunk * Neighbour = m_Chunk->GetRelNeighborChunk(X, Z);
-		if ((Neighbour == NULL) || !Neighbour->IsValid())
-		{
-			return;
-		}
-
-		if (AreCoordsDirectlyPowered(X, Y, Z, Neighbour))
-		{
-			// There was a match, torch goes off
-			m_Chunk->SetBlock(a_RelBlockX, a_RelBlockY, a_RelBlockZ, E_BLOCK_REDSTONE_TORCH_OFF, m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ));
-			return;
-		}
-
-		// Torch still on, make all 4(X, Z) + 1(Y) sides powered
-		for (size_t i = 0; i < ARRAYCOUNT(gCrossCoords); i++)
-		{
-			BLOCKTYPE Type = 0;
-			if (!m_Chunk->UnboundedRelGetBlockType(a_RelBlockX + gCrossCoords[i].x, a_RelBlockY + gCrossCoords[i].y, a_RelBlockZ + gCrossCoords[i].z, Type))
-			{
-				continue;
-			}
-			if (i + 1 < ARRAYCOUNT(gCrossCoords))  // Sides of torch, not top (top is last)
-			{
-				if (
-					IsMechanism(Type) &&  // Is it a mechanism? Not block/other torch etc.
-					(!Vector3i(a_RelBlockX + gCrossCoords[i].x, a_RelBlockY + gCrossCoords[i].y, a_RelBlockZ + gCrossCoords[i].z).Equals(Vector3i(X, Y, Z)))  // CAN'T power block is that it is on
-					)
-				{
-					SetBlockPowered(a_RelBlockX + gCrossCoords[i].x, a_RelBlockY + gCrossCoords[i].y, a_RelBlockZ + gCrossCoords[i].z, a_RelBlockX, a_RelBlockY, a_RelBlockZ);
-				}
-			}
-			else
-			{
-				// Top side, power whatever is there, including blocks
-				SetBlockPowered(a_RelBlockX + gCrossCoords[i].x, a_RelBlockY + gCrossCoords[i].y, a_RelBlockZ + gCrossCoords[i].z, a_RelBlockX, a_RelBlockY, a_RelBlockZ);
-				// Power all blocks surrounding block above torch
-				SetDirectionLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, BLOCK_FACE_YP);
-			}
-		}
-
-		if (m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ) != 0x5)  // Is torch standing on ground? If NOT (i.e. on wall), power block beneath
-		{
-			BLOCKTYPE Type = m_Chunk->GetBlock(a_RelBlockX, a_RelBlockY - 1, a_RelBlockZ);
-
-			if (IsMechanism(Type))  // Still can't make a normal block powered though!
-			{
-				SetBlockPowered(a_RelBlockX, a_RelBlockY - 1, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ);
-			}
-		}
-	}
-	else
-	{
-		// Check if the block the torch is on is powered
-		int X = a_RelBlockX; int Y = a_RelBlockY; int Z = a_RelBlockZ;
-		AddFaceDirection(X, Y, Z, cBlockTorchHandler::MetaDataToDirection(m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ)), true);  // Inverse true to get the block torch is on
-		
-		cChunk * Neighbour = m_Chunk->GetRelNeighborChunk(X, Z);
-		if ((Neighbour == NULL) || !Neighbour->IsValid())
-		{
-			return;
-		}
-		
-		// See if off state torch can be turned on again
-		if (AreCoordsDirectlyPowered(X, Y, Z, Neighbour))
-		{
-			return;  // Something matches, torch still powered
-		}
-
-		// Block torch on not powered, can be turned on again!
-		m_Chunk->SetBlock(a_RelBlockX, a_RelBlockY, a_RelBlockZ, E_BLOCK_REDSTONE_TORCH_ON, m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ));
-	}
-}
-
-
-
-
-
-void cIncrementalRedstoneSimulator::HandleRedstoneBlock(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
-{
-	SetAllDirsAsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ);
-	SetBlockPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ);  // Set self as powered
-}
-
-
-
-
-
-void cIncrementalRedstoneSimulator::HandleRedstoneLever(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
-{
-	NIBBLETYPE Meta = m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ);
-	if (IsLeverOn(Meta))
-	{
-		SetAllDirsAsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ);
-
-		eBlockFace Dir = cBlockLeverHandler::BlockMetaDataToBlockFace(Meta);
-		
-		Dir = ReverseBlockFace(Dir);
-		
-		SetDirectionLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, Dir);
-	}
-}
-
-
-
-
-
-void cIncrementalRedstoneSimulator::HandleFenceGate(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
-{
-	int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX;
-	int BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ;
-	NIBBLETYPE MetaData = m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ);
-
-	if (AreCoordsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ))
-	{
-		if (!AreCoordsSimulated(a_RelBlockX, a_RelBlockY, a_RelBlockZ, true))
-		{
-			if ((MetaData & 0x4) == 0)
-			{
-				m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, MetaData | 0x4);
-				m_Chunk->BroadcastSoundParticleEffect(1003, BlockX, a_RelBlockY, BlockZ, 0);
-			}
-			SetPlayerToggleableBlockAsSimulated(a_RelBlockX, a_RelBlockY, a_RelBlockZ, true);
-		}
-	}
-	else
-	{
-		if (!AreCoordsSimulated(a_RelBlockX, a_RelBlockY, a_RelBlockZ, false))
-		{
-			if ((MetaData & 0x4) != 0)
-			{
-				m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, MetaData & ~0x04);
-				m_Chunk->BroadcastSoundParticleEffect(1003, BlockX, a_RelBlockY, BlockZ, 0);
-			}
-			SetPlayerToggleableBlockAsSimulated(a_RelBlockX, a_RelBlockY, a_RelBlockZ, false);
-		}
-	}
-}
-
-
-
-
-
-void cIncrementalRedstoneSimulator::HandleRedstoneButton(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
-{
-	NIBBLETYPE Meta = m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ);
-	if (IsButtonOn(Meta))
-	{
-		SetAllDirsAsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ);
-		
-		eBlockFace Dir = cBlockButtonHandler::BlockMetaDataToBlockFace(Meta);
-		Dir = ReverseBlockFace(Dir);
-		SetDirectionLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, Dir);
-	}
-}
-
-
-
-
-
-void cIncrementalRedstoneSimulator::HandleRedstoneWire(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
-{
-	static const struct  // Define which directions the wire can receive power from
-	{
-		int x, y, z;
-	} gCrossCoords[] =
-	{
-		{ 1, 0,  0}, /* Wires on same level start */
-		{-1, 0,  0},
-		{ 0, 0,  1},
-		{ 0, 0, -1}, /* Wires on same level stop */
-		{ 1, 1,  0}, /* Wires one higher, surrounding self start */
-		{-1, 1,  0},
-		{ 0, 1,  1},
-		{ 0, 1, -1}, /* Wires one higher, surrounding self stop */
-		{ 1, -1,  0}, /* Wires one lower, surrounding self start */
-		{-1, -1,  0},
-		{ 0, -1,  1},
-		{ 0, -1, -1}, /* Wires one lower, surrounding self stop */
-	} ;
-
-	static const struct  // Define which directions the wire will check for repeater prescence
-	{
-		int x, y, z;
-	} gSideCoords[] =
-	{
-		{ 1, 0, 0 },
-		{-1, 0, 0 },
-		{ 0, 0, 1 },
-		{ 0, 0, -1 },
-		{ 0, 1, 0 },
-	};
-
-	// Check to see if directly beside a power source
-	unsigned char MyPower;
-	if (!IsWirePowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, MyPower))
-	{
-		int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX;
-		int BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ;
-		m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, 0);
-		m_World.WakeUpSimulators(BlockX, a_RelBlockY, BlockZ);
-		return;
-	}
-	
-	m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, MyPower);
-
-	if (MyPower < 1)
-	{
-		return;
-	}
-
-	MyPower--;
-
-	for (size_t i = 0; i < ARRAYCOUNT(gCrossCoords); i++)  // Loop through all directions to transfer or receive power
-	{
-		if ((i >= 4) && (i <= 7))  // If we are currently checking for wire surrounding ourself one block above...
-		{
-			BLOCKTYPE Type = 0;
-			if (a_RelBlockY + 1 >= cChunkDef::Height)
-			{
-				continue;
-			}
-			if (!m_Chunk->UnboundedRelGetBlockType(a_RelBlockX, a_RelBlockY + 1, a_RelBlockZ, Type))
-			{
-				continue;
-			}
-			if (cBlockInfo::IsSolid(Type))  // If there is something solid above us (wire cut off)...
-			{
-				continue;  // We don't receive power from that wire
-			}
-		}
-		else if ((i >= 8) && (i <= 11))  // See above, but this is for wire below us
-		{
-			BLOCKTYPE Type = 0;
-			if (!m_Chunk->UnboundedRelGetBlockType(a_RelBlockX + gCrossCoords[i].x, a_RelBlockY, a_RelBlockZ + gCrossCoords[i].z, Type))
-			{
-				continue;
-			}
-			if (cBlockInfo::IsSolid(Type))
-			{
-				continue;
-			}
-		}
-
-		BLOCKTYPE Type = 0;
-		if (!m_Chunk->UnboundedRelGetBlockType(a_RelBlockX + gCrossCoords[i].x, a_RelBlockY + gCrossCoords[i].y, a_RelBlockZ + gCrossCoords[i].z, Type))
-		{
-			continue;
-		}
-		if (Type == E_BLOCK_REDSTONE_WIRE)
-		{
-			SetBlockPowered(a_RelBlockX + gCrossCoords[i].x, a_RelBlockY + gCrossCoords[i].y, a_RelBlockZ + gCrossCoords[i].z, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MyPower);
-		}
-	}
-
-	for (size_t i = 0; i < ARRAYCOUNT(gSideCoords); i++)  // Look for repeaters immediately surrounding self and try to power them
-	{
-		BLOCKTYPE Type = 0;
-		if (!m_Chunk->UnboundedRelGetBlockType(a_RelBlockX + gSideCoords[i].x, a_RelBlockY + gSideCoords[i].y, a_RelBlockZ + gSideCoords[i].z, Type))
-		{
-			continue;
-		}
-		if (Type == E_BLOCK_REDSTONE_REPEATER_OFF)
-		{
-			SetBlockPowered(a_RelBlockX + gSideCoords[i].x, a_RelBlockY + gSideCoords[i].y, a_RelBlockZ + gSideCoords[i].z, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MyPower);
-		}
-	}
-
-	// Wire still powered, power blocks beneath
-	SetBlockPowered(a_RelBlockX, a_RelBlockY - 1, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MyPower);
-	SetDirectionLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, BLOCK_FACE_YM, MyPower);
-
-	switch (GetWireDirection(a_RelBlockX, a_RelBlockY, a_RelBlockZ))
-	{
-		case REDSTONE_NONE:
-		{
-			SetBlockPowered(a_RelBlockX + 1, a_RelBlockY, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MyPower);
-			SetBlockPowered(a_RelBlockX - 1, a_RelBlockY, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MyPower);
-			SetBlockPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ + 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MyPower);
-			SetBlockPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ - 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MyPower);
-
-			SetDirectionLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, BLOCK_FACE_XM, MyPower);
-			SetDirectionLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, BLOCK_FACE_XP, MyPower);
-			SetDirectionLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, BLOCK_FACE_ZM, MyPower);
-			SetDirectionLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, BLOCK_FACE_ZP, MyPower);
-			break;
-		}
-		case REDSTONE_X_POS:
-		{
-			SetBlockPowered(a_RelBlockX + 1, a_RelBlockY, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MyPower);
-			SetDirectionLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, BLOCK_FACE_XP, MyPower);
-			break;
-		}
-		case REDSTONE_X_NEG:
-		{
-			SetBlockPowered(a_RelBlockX - 1, a_RelBlockY, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MyPower);
-			SetDirectionLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, BLOCK_FACE_XM, MyPower);
-			break;
-		}
-		case REDSTONE_Z_POS:
-		{
-			SetBlockPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ + 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MyPower);
-			SetDirectionLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, BLOCK_FACE_ZP, MyPower);
-			break;
-		}
-		case REDSTONE_Z_NEG:
-		{
-			SetBlockPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ - 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MyPower);
-			SetDirectionLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, BLOCK_FACE_ZM, MyPower);
-			break;
-		}
-	}
-}
-
-
-
-
-
-void cIncrementalRedstoneSimulator::HandleRedstoneRepeater(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, BLOCKTYPE a_MyState)
-{
-	/* Repeater Orientation Mini Guide:
-	===================================
-
-	|
-	| Z Axis
-	V
-
-	X Axis ---->
-
-	Repeater directions, values from a cWorld::GetBlockMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ) lookup:
-
-	East (Right) (X+): 0x1
-	West (Left) (X-): 0x3
-	North (Up) (Z-): 0x2
-	South (Down) (Z+): 0x0
-	// TODO: Add E_META_XXX enum entries for all meta values and update project with them
-
-	Sun rises from East (X+)
-
-	*/
-
-	// Create a variable holding my meta to avoid multiple lookups.
-	NIBBLETYPE a_Meta = m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ);
-	bool IsOn = (a_MyState == E_BLOCK_REDSTONE_REPEATER_ON);
-
-	if (!IsRepeaterLocked(a_RelBlockX, a_RelBlockY, a_RelBlockZ, a_Meta))  // If we're locked, change nothing. Otherwise:
-	{
-		bool IsSelfPowered = IsRepeaterPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, a_Meta);
-		if (IsSelfPowered && !IsOn)  // Queue a power change if powered, but not on and not locked.
-		{
-			QueueRepeaterPowerChange(a_RelBlockX, a_RelBlockY, a_RelBlockZ, a_Meta, true);
-		}
-		else if (!IsSelfPowered && IsOn)  // Queue a power change if unpowered, on, and not locked.
-		{
-			QueueRepeaterPowerChange(a_RelBlockX, a_RelBlockY, a_RelBlockZ, a_Meta, false);
-		}
-	}
-}
-
-void cIncrementalRedstoneSimulator::HandleRedstoneRepeaterDelays()
-{
-	for (RepeatersDelayList::iterator itr = m_RepeatersDelayList->begin(); itr != m_RepeatersDelayList->end();)
-	{
-		if (itr->a_ElapsedTicks >= itr->a_DelayTicks)  // Has the elapsed ticks reached the target ticks?
-		{
-			int RelBlockX = itr->a_RelBlockPos.x;
-			int RelBlockY = itr->a_RelBlockPos.y;
-			int RelBlockZ = itr->a_RelBlockPos.z;
-			BLOCKTYPE Block;
-			NIBBLETYPE Meta;
-			m_Chunk->GetBlockTypeMeta(RelBlockX, RelBlockY, RelBlockZ, Block, Meta);
-			if (itr->ShouldPowerOn)
-			{
-				if (Block != E_BLOCK_REDSTONE_REPEATER_ON)  // For performance
-				{
-					m_Chunk->SetBlock(itr->a_RelBlockPos, E_BLOCK_REDSTONE_REPEATER_ON, Meta);
-				}
-
-				switch (Meta & 0x3)  // We only want the direction (bottom) bits
-				{
-					case 0x0:
-					{
-						SetBlockPowered(RelBlockX, RelBlockY, RelBlockZ - 1, RelBlockX, RelBlockY, RelBlockZ);
-						SetDirectionLinkedPowered(RelBlockX, RelBlockY, RelBlockZ, BLOCK_FACE_ZM);
-						break;
-					}
-					case 0x1:
-					{
-						SetBlockPowered(RelBlockX + 1, RelBlockY, RelBlockZ, RelBlockX, RelBlockY, RelBlockZ);
-						SetDirectionLinkedPowered(RelBlockX, RelBlockY, RelBlockZ, BLOCK_FACE_XP);
-						break;
-					}
-					case 0x2:
-					{
-						SetBlockPowered(RelBlockX, RelBlockY, RelBlockZ + 1, RelBlockX, RelBlockY, RelBlockZ);
-						SetDirectionLinkedPowered(RelBlockX, RelBlockY, RelBlockZ, BLOCK_FACE_ZP);
-						break;
-					}
-					case 0x3:
-					{
-						SetBlockPowered(RelBlockX - 1, RelBlockY, RelBlockZ, RelBlockX, RelBlockY, RelBlockZ);
-						SetDirectionLinkedPowered(RelBlockX, RelBlockY, RelBlockZ, BLOCK_FACE_XM);
-						break;
-					}
-				}
-			}
-			else if (Block != E_BLOCK_REDSTONE_REPEATER_OFF)
-			{
-				m_Chunk->SetBlock(RelBlockX, RelBlockY, RelBlockZ, E_BLOCK_REDSTONE_REPEATER_OFF, Meta);
-			}
-			itr = m_RepeatersDelayList->erase(itr);
-		}
-		else
-		{
-			LOGD("Incremented a repeater @ {%i %i %i} | Elapsed ticks: %i | Target delay: %i", itr->a_RelBlockPos.x, itr->a_RelBlockPos.y, itr->a_RelBlockPos.z, itr->a_ElapsedTicks, itr->a_DelayTicks);
-			itr->a_ElapsedTicks++;
-			itr++;
-		}
-	}
-}
-
-
-
-
-
-void cIncrementalRedstoneSimulator::HandlePiston(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
-{
-	int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX;
-	int BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ;
-
-	if (IsPistonPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ) & 0x7))  // We only want the bottom three bits (4th controls extended-ness)
-	{
-		cBlockPistonHandler::ExtendPiston(BlockX, a_RelBlockY, BlockZ, &m_World);
-	}
-	else
-	{
-		cBlockPistonHandler::RetractPiston(BlockX, a_RelBlockY, BlockZ, &m_World);
-	}
-}
-
-
-
-
-
-void cIncrementalRedstoneSimulator::HandleDropSpenser(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
-{
-	class cSetPowerToDropSpenser :
-		public cRedstonePoweredCallback
-	{
-		bool m_IsPowered;
-	public:
-		cSetPowerToDropSpenser(bool a_IsPowered) : m_IsPowered(a_IsPowered) {}
-
-		virtual bool Item(cRedstonePoweredEntity * a_DropSpenser) override
-		{
-			a_DropSpenser->SetRedstonePower(m_IsPowered);
-			return false;
-		}
-	} DrSpSP (AreCoordsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ));
-
-	int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX;
-	int BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ;
-	m_Chunk->DoWithRedstonePoweredEntityAt(BlockX, a_RelBlockY, BlockZ, DrSpSP);
-}
-
-
-
-
-
-void cIncrementalRedstoneSimulator::HandleRedstoneLamp(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, BLOCKTYPE a_MyState)
-{
-	if (a_MyState == E_BLOCK_REDSTONE_LAMP_OFF)
-	{
-		if (AreCoordsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ))
-		{
-			m_Chunk->SetBlock(a_RelBlockX, a_RelBlockY, a_RelBlockZ, E_BLOCK_REDSTONE_LAMP_ON, 0);
-		}
-	}
-	else
-	{
-		if (!AreCoordsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ))
-		{
-			m_Chunk->SetBlock(a_RelBlockX, a_RelBlockY, a_RelBlockZ, E_BLOCK_REDSTONE_LAMP_OFF, 0);
-		}
-	}
-}
-
-
-
-
-
-void cIncrementalRedstoneSimulator::HandleTNT(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
-{
-	int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX;
-	int BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ;
-
-	if (AreCoordsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ))
-	{
-		m_Chunk->BroadcastSoundEffect("game.tnt.primed", (double)BlockX, (double)a_RelBlockY, (double)BlockZ, 0.5f, 0.6f);
-		m_Chunk->SetBlock(a_RelBlockX, a_RelBlockY, a_RelBlockZ, E_BLOCK_AIR, 0);
-		m_World.SpawnPrimedTNT(BlockX + 0.5, a_RelBlockY + 0.5, BlockZ + 0.5);  // 80 ticks to boom
-	}
-}
-
-
-
-
-
-void cIncrementalRedstoneSimulator::HandleDoor(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
-{
-	int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX;
-	int BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ;
-
-	if (AreCoordsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ))
-	{
-		if (!AreCoordsSimulated(a_RelBlockX, a_RelBlockY, a_RelBlockZ, true))
-		{
-			cChunkInterface ChunkInterface(m_World.GetChunkMap());
-			if (!cBlockDoorHandler::IsOpen(ChunkInterface, BlockX, a_RelBlockY, BlockZ))
-			{
-				cBlockDoorHandler::SetOpen(ChunkInterface, BlockX, a_RelBlockY, BlockZ, true);
-				m_Chunk->BroadcastSoundParticleEffect(1003, BlockX, a_RelBlockY, BlockZ, 0);
-			}
-			SetPlayerToggleableBlockAsSimulated(a_RelBlockX, a_RelBlockY, a_RelBlockZ, true);
-		}
-	}
-	else
-	{
-		if (!AreCoordsSimulated(a_RelBlockX, a_RelBlockY, a_RelBlockZ, false))
-		{
-			cChunkInterface ChunkInterface(m_World.GetChunkMap());
-			if (cBlockDoorHandler::IsOpen(ChunkInterface, BlockX, a_RelBlockY, BlockZ))
-			{
-				cBlockDoorHandler::SetOpen(ChunkInterface, BlockX, a_RelBlockY, BlockZ, false);
-				m_Chunk->BroadcastSoundParticleEffect(1003, BlockX, a_RelBlockY, BlockZ, 0);
-			}
-			SetPlayerToggleableBlockAsSimulated(a_RelBlockX, a_RelBlockY, a_RelBlockZ, false);
-		}
-	}
-}
-
-
-
-
-
-void cIncrementalRedstoneSimulator::HandleCommandBlock(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
-{
-	class cSetPowerToCommandBlock :
-		public cCommandBlockCallback
-	{
-		bool m_IsPowered;
-	public:
-		cSetPowerToCommandBlock(bool a_IsPowered) : m_IsPowered(a_IsPowered) {}
-
-		virtual bool Item(cCommandBlockEntity * a_CommandBlock) override
-		{
-			a_CommandBlock->SetRedstonePower(m_IsPowered);
-			return false;
-		}
-	} CmdBlockSP (AreCoordsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ));
-
-	int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX;
-	int BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ;
-	m_Chunk->DoWithCommandBlockAt(BlockX, a_RelBlockY, BlockZ, CmdBlockSP);
-}
-
-
-
-
-
-void cIncrementalRedstoneSimulator::HandleRail(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, BLOCKTYPE a_MyType)
-{
-	switch (a_MyType)
-	{
-		case E_BLOCK_DETECTOR_RAIL:
-		{
-			if ((m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ) & 0x08) == 0x08)
-			{
-				SetAllDirsAsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, a_MyType);
-			}
-			break;
-		}
-		case E_BLOCK_ACTIVATOR_RAIL:
-		case E_BLOCK_POWERED_RAIL:
-		{
-			if (AreCoordsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ))
-			{
-				m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ) | 0x08);
-			}
-			else
-			{
-				m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ) & 0x07);
-			}
-			break;
-		}
-		default: LOGD("Unhandled type of rail in %s", __FUNCTION__);
-	}
-}
-
-
-
-
-
-void cIncrementalRedstoneSimulator::HandleTrapdoor(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
-{
-	int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX;
-	int BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ;
-
-	if (AreCoordsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ))
-	{
-		if (!AreCoordsSimulated(a_RelBlockX, a_RelBlockY, a_RelBlockZ, true))
-		{
-			m_World.SetTrapdoorOpen(BlockX, a_RelBlockY, BlockZ, true);
-			SetPlayerToggleableBlockAsSimulated(a_RelBlockX, a_RelBlockY, a_RelBlockZ, true);
-		}
-	}
-	else
-	{
-		if (!AreCoordsSimulated(a_RelBlockX, a_RelBlockY, a_RelBlockZ, false))
-		{
-			m_World.SetTrapdoorOpen(BlockX, a_RelBlockY, BlockZ, false);
-			SetPlayerToggleableBlockAsSimulated(a_RelBlockX, a_RelBlockY, a_RelBlockZ, false);
-		}
-	}
-}
-
-
-
-
-
-void cIncrementalRedstoneSimulator::HandleNoteBlock(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
-{
-	bool m_bAreCoordsPowered = AreCoordsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ);
-
-	if (m_bAreCoordsPowered)
-	{
-		if (!AreCoordsSimulated(a_RelBlockX, a_RelBlockY, a_RelBlockZ, true))
-		{
-			class cSetPowerToNoteBlock :
-				public cRedstonePoweredCallback
-			{
-			public:
-				cSetPowerToNoteBlock() {}
-
-				virtual bool Item(cRedstonePoweredEntity * a_NoteBlock) override
-				{
-					a_NoteBlock->SetRedstonePower(true);
-					return false;
-				}
-			} NoteBlockSP;
-
-			int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX;
-			int BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ;
-			m_Chunk->DoWithRedstonePoweredEntityAt(BlockX, a_RelBlockY, BlockZ, NoteBlockSP);
-			SetPlayerToggleableBlockAsSimulated(a_RelBlockX, a_RelBlockY, a_RelBlockZ, true);
-		}
-	}
-	else
-	{
-		if (!AreCoordsSimulated(a_RelBlockX, a_RelBlockY, a_RelBlockZ, false))
-		{
-			SetPlayerToggleableBlockAsSimulated(a_RelBlockX, a_RelBlockY, a_RelBlockZ, false);
-		}
-	}
-}
-
-
-
-
-
-void cIncrementalRedstoneSimulator::HandleDaylightSensor(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
-{
-	int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX, BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ;
-	int ChunkX, ChunkZ;
-	cChunkDef::BlockToChunk(BlockX, BlockZ, ChunkX, ChunkZ);
-
-	if (!m_World.IsChunkLighted(ChunkX, ChunkZ))
-	{
-		m_World.QueueLightChunk(ChunkX, ChunkZ);
-	}
-	else
-	{
-		if (m_Chunk->GetTimeAlteredLight(m_World.GetBlockSkyLight(BlockX, a_RelBlockY + 1, BlockZ)) > 8)
-		{
-			SetAllDirsAsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ);
-		}
-		else
-		{
-			WakeUp(BlockX, a_RelBlockY, BlockZ, m_Chunk);
-		}
-	}
-}
-
-
-
-
-
-void cIncrementalRedstoneSimulator::HandlePressurePlate(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, BLOCKTYPE a_MyType)
-{
-	int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX;
-	int BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ;
-
-	switch (a_MyType)
-	{
-		case E_BLOCK_STONE_PRESSURE_PLATE:
-		{
-			// MCS feature - stone pressure plates can only be triggered by players :D
-			cPlayer * a_Player = m_World.FindClosestPlayer(Vector3f(BlockX + 0.5f, (float)a_RelBlockY, BlockZ + 0.5f), 0.5f, false);
-
-			if (a_Player != NULL)
-			{
-				m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, 0x1);
-				SetAllDirsAsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ);
-				SetDirectionLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, BLOCK_FACE_YM, a_MyType);
-			}
-			else
-			{
-				m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, 0x0);
-				SetSourceUnpowered(BlockX, a_RelBlockY, BlockZ, m_Chunk);
-			}
-			break;
-		}
-		case E_BLOCK_LIGHT_WEIGHTED_PRESSURE_PLATE:
-		{
-			class cPressurePlateCallback :
-				public cEntityCallback
-			{
-			public:
-				cPressurePlateCallback(int a_BlockX, int a_BlockY, int a_BlockZ) :
-					m_NumberOfEntities(0),
-					m_X(a_BlockX),
-					m_Y(a_BlockY),
-					m_Z(a_BlockZ)
-				{
-				}
-
-				virtual bool Item(cEntity * a_Entity) override
-				{
-					Vector3f EntityPos = a_Entity->GetPosition();
-					Vector3f BlockPos(m_X + 0.5f, (float)m_Y, m_Z + 0.5f);
-					double Distance = (EntityPos - BlockPos).Length();
-
-					if (Distance <= 0.5)
-					{
-						m_NumberOfEntities++;
-					}
-					return false;
-				}
-
-				bool GetPowerLevel(unsigned char & a_PowerLevel) const
-				{
-					a_PowerLevel = std::min(m_NumberOfEntities, MAX_POWER_LEVEL);
-					return (a_PowerLevel > 0);
-				}
-
-			protected:
-				int m_NumberOfEntities;
-
-				int m_X;
-				int m_Y;
-				int m_Z;
-			};
-
-			cPressurePlateCallback PressurePlateCallback(BlockX, a_RelBlockY, BlockZ);
-			m_World.ForEachEntityInChunk(m_Chunk->GetPosX(), m_Chunk->GetPosZ(), PressurePlateCallback);
-
-			unsigned char Power;
-			NIBBLETYPE Meta = m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ);
-			if (PressurePlateCallback.GetPowerLevel(Power))
-			{
-				if (Meta == E_META_PRESSURE_PLATE_RAISED)
-				{
-					m_Chunk->BroadcastSoundEffect("random.click", (double)BlockX + 0.5, (double)a_RelBlockY + 0.1, (double)BlockZ + 0.5, 0.3F, 0.5F);
-				}
-				m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, E_META_PRESSURE_PLATE_DEPRESSED);
-				SetAllDirsAsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, Power);
-				SetDirectionLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, BLOCK_FACE_YM, a_MyType);
-			}
-			else
-			{
-				if (Meta == E_META_PRESSURE_PLATE_DEPRESSED)
-				{
-					m_Chunk->BroadcastSoundEffect("random.click", (double)BlockX + 0.5, (double)a_RelBlockY + 0.1, (double)BlockZ + 0.5, 0.3F, 0.6F);
-				}
-				m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, E_META_PRESSURE_PLATE_RAISED);
-				SetSourceUnpowered(BlockX, a_RelBlockY, BlockZ, m_Chunk);
-			}
-
-			break;
-		}
-		case E_BLOCK_HEAVY_WEIGHTED_PRESSURE_PLATE:
-		{
-			class cPressurePlateCallback :
-				public cEntityCallback
-			{
-			public:
-				cPressurePlateCallback(int a_BlockX, int a_BlockY, int a_BlockZ) :
-					m_NumberOfEntities(0),
-					m_X(a_BlockX),
-					m_Y(a_BlockY),
-					m_Z(a_BlockZ)
-				{
-				}
-
-				virtual bool Item(cEntity * a_Entity) override
-				{
-					Vector3f EntityPos = a_Entity->GetPosition();
-					Vector3f BlockPos(m_X + 0.5f, (float)m_Y, m_Z + 0.5f);
-					double Distance = (EntityPos - BlockPos).Length();
-
-					if (Distance <= 0.5)
-					{
-						m_NumberOfEntities++;
-					}
-					return false;
-				}
-
-				bool GetPowerLevel(unsigned char & a_PowerLevel) const
-				{
-					a_PowerLevel = std::min((int)ceil(m_NumberOfEntities / 10.f), MAX_POWER_LEVEL);
-					return (a_PowerLevel > 0);
-				}
-
-			protected:
-				int m_NumberOfEntities;
-
-				int m_X;
-				int m_Y;
-				int m_Z;
-			};
-
-			cPressurePlateCallback PressurePlateCallback(BlockX, a_RelBlockY, BlockZ);
-			m_World.ForEachEntityInChunk(m_Chunk->GetPosX(), m_Chunk->GetPosZ(), PressurePlateCallback);
-
-			unsigned char Power;
-			NIBBLETYPE Meta = m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ);
-			if (PressurePlateCallback.GetPowerLevel(Power))
-			{
-				if (Meta == E_META_PRESSURE_PLATE_RAISED)
-				{
-					m_Chunk->BroadcastSoundEffect("random.click", (double)BlockX + 0.5, (double)a_RelBlockY + 0.1, (double)BlockZ + 0.5, 0.3F, 0.5F);
-				}
-				m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, E_META_PRESSURE_PLATE_DEPRESSED);
-				SetAllDirsAsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, Power);
-				SetDirectionLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, BLOCK_FACE_YM, a_MyType);
-			}
-			else
-			{
-				if (Meta == E_META_PRESSURE_PLATE_DEPRESSED)
-				{
-					m_Chunk->BroadcastSoundEffect("random.click", (double)BlockX + 0.5, (double)a_RelBlockY + 0.1, (double)BlockZ + 0.5, 0.3F, 0.6F);
-				}
-				m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, E_META_PRESSURE_PLATE_RAISED);
-				SetSourceUnpowered(BlockX, a_RelBlockY, BlockZ, m_Chunk);
-			}
-
-			break;
-		}
-		case E_BLOCK_WOODEN_PRESSURE_PLATE:
-		{
-			class cPressurePlateCallback :
-				public cEntityCallback
-			{
-			public:
-				cPressurePlateCallback(int a_BlockX, int a_BlockY, int a_BlockZ) :
-					m_FoundEntity(false),
-					m_X(a_BlockX),
-					m_Y(a_BlockY),
-					m_Z(a_BlockZ)
-				{
-				}
-
-				virtual bool Item(cEntity * a_Entity) override
-				{
-					Vector3f EntityPos = a_Entity->GetPosition();
-					Vector3f BlockPos(m_X + 0.5f, (float)m_Y, m_Z + 0.5f);
-					double Distance = (EntityPos - BlockPos).Length();
-
-					if (Distance <= 0.5)
-					{
-						m_FoundEntity = true;
-						return true;  // Break out, we only need to know for plates that at least one entity is on top
-					}
-					return false;
-				}
-
-				bool FoundEntity(void) const
-				{
-					return m_FoundEntity;
-				}
-
-			protected:
-				bool m_FoundEntity;
-
-				int m_X;
-				int m_Y;
-				int m_Z;
-			} ;
-
-			cPressurePlateCallback PressurePlateCallback(BlockX, a_RelBlockY, BlockZ);
-			m_World.ForEachEntityInChunk(m_Chunk->GetPosX(), m_Chunk->GetPosZ(), PressurePlateCallback);
-
-			NIBBLETYPE Meta = m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ);
-			if (PressurePlateCallback.FoundEntity())
-			{
-				if (Meta == E_META_PRESSURE_PLATE_RAISED)
-				{
-					m_Chunk->BroadcastSoundEffect("random.click", (double)BlockX + 0.5, (double)a_RelBlockY + 0.1, (double)BlockZ + 0.5, 0.3F, 0.5F);
-				}
-				m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, E_META_PRESSURE_PLATE_DEPRESSED);
-				SetAllDirsAsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ);
-				SetDirectionLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, BLOCK_FACE_YM, a_MyType);
-			}
-			else
-			{
-				if (Meta == E_META_PRESSURE_PLATE_DEPRESSED)
-				{
-					m_Chunk->BroadcastSoundEffect("random.click", (double)BlockX + 0.5, (double)a_RelBlockY + 0.1, (double)BlockZ + 0.5, 0.3F, 0.6F);
-				}
-				m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, E_META_PRESSURE_PLATE_RAISED);
-				SetSourceUnpowered(BlockX, a_RelBlockY, BlockZ, m_Chunk);
-			}
-			break;
-		}
-		default:
-		{
-			LOGD("Unimplemented pressure plate type %s in cRedstoneSimulator", ItemToFullString(a_MyType).c_str());
-			break;
-		}
-	}
-}
-
-
-
-
-
-void cIncrementalRedstoneSimulator::HandleTripwireHook(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
-{
-	int BlockX = m_Chunk->GetPosX() * cChunkDef::Width + a_RelBlockX;
-	int BlockZ = m_Chunk->GetPosZ() * cChunkDef::Width + a_RelBlockZ;
-	int RelX = a_RelBlockX, RelZ = a_RelBlockZ;
-	bool FoundActivated = false;
-	eBlockFace FaceToGoTowards = cBlockTripwireHookHandler::MetadataToDirection(m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ));
-
-	for (int i = 0; i < 40; ++i)  // Tripwires can be connected up to 40 blocks
-	{
-		BLOCKTYPE Type;
-		NIBBLETYPE Meta;
-
-		AddFaceDirection(RelX, a_RelBlockY, RelZ, FaceToGoTowards);
-		m_Chunk->UnboundedRelGetBlock(RelX, a_RelBlockY, RelZ, Type, Meta);
-
-		if (Type == E_BLOCK_TRIPWIRE)
-		{
-			if (Meta == 0x1)
-			{
-				FoundActivated = true;
-			}
-		}
-		else if (Type == E_BLOCK_TRIPWIRE_HOOK)
-		{
-			if (ReverseBlockFace(cBlockTripwireHookHandler::MetadataToDirection(Meta)) == FaceToGoTowards)
-			{
-				// Other hook facing in opposite direction - circuit completed!
-				break;
-			}
-			else
-			{
-				// Tripwire hook not connected at all, AND away all the power state bits
-				m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ) & 0x3);
-				SetSourceUnpowered(BlockX, a_RelBlockY, BlockZ, m_Chunk);
-				return;
-			}
-		}
-		else
-		{
-			// Tripwire hook not connected at all, AND away all the power state bits
-			m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ) & 0x3);
-			SetSourceUnpowered(BlockX, a_RelBlockY, BlockZ, m_Chunk);
-			return;
-		}
-	}
-
-	if (FoundActivated)
-	{
-		// Connected and activated, set the 3rd and 4th highest bits
-		m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ) | 0xC);
-		SetAllDirsAsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ);
-	}
-	else
-	{
-		// Connected but not activated, AND away the highest bit
-		m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, (m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ) & 0x7) | 0x4);
-		SetSourceUnpowered(BlockX, a_RelBlockY, BlockZ, m_Chunk);
-	}
-}
-
-
-
-
-
-void cIncrementalRedstoneSimulator::HandleTrappedChest(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
-{
-	class cGetTrappedChestPlayers :
-		public cChestCallback
-	{
-	public:
-		cGetTrappedChestPlayers(void) :
-			m_NumberOfPlayers(0)
-		{
-		}
-
-		virtual bool Item(cChestEntity * a_Chest) override
-		{
-			ASSERT(a_Chest->GetBlockType() == E_BLOCK_TRAPPED_CHEST);
-			m_NumberOfPlayers = a_Chest->GetNumberOfPlayers();
-			return (m_NumberOfPlayers <= 0);
-		}
-
-		unsigned char GetPowerLevel(void) const
-		{
-			return std::min(m_NumberOfPlayers, MAX_POWER_LEVEL);
-		}
-
-	private:
-		int m_NumberOfPlayers;
-
-	} GTCP;
-
-	int BlockX = m_Chunk->GetPosX() * cChunkDef::Width + a_RelBlockX;
-	int BlockZ = m_Chunk->GetPosZ() * cChunkDef::Width + a_RelBlockZ;
-	if (m_Chunk->DoWithChestAt(BlockX, a_RelBlockY, BlockZ, GTCP))
-	{
-		SetAllDirsAsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, GTCP.GetPowerLevel());
-	}
-	else
-	{
-		SetSourceUnpowered(BlockX, a_RelBlockY, BlockZ, m_Chunk);
-	}
-}
-
-
-
-
-
-void cIncrementalRedstoneSimulator::HandleTripwire(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
-{
-	int BlockX = m_Chunk->GetPosX() * cChunkDef::Width + a_RelBlockX;
-	int BlockZ = m_Chunk->GetPosZ() * cChunkDef::Width + a_RelBlockZ;
-
-	class cTripwireCallback :
-		public cEntityCallback
-	{
-	public:
-		cTripwireCallback(int a_BlockX, int a_BlockY, int a_BlockZ) :
-			m_FoundEntity(false),
-			m_X(a_BlockX),
-			m_Y(a_BlockY),
-			m_Z(a_BlockZ)
-		{
-		}
-
-		virtual bool Item(cEntity * a_Entity) override
-		{
-			cBoundingBox bbWire(m_X, m_X + 1, m_Y, m_Y + 0.1, m_Z, m_Z + 1);
-			cBoundingBox bbEntity(a_Entity->GetPosition(), a_Entity->GetWidth() / 2, a_Entity->GetHeight());
-
-			if (bbEntity.DoesIntersect(bbWire))
-			{
-				m_FoundEntity = true;
-				return true;  // One entity is sufficient to trigger the wire
-			}
-			return false;
-		}
-
-		bool FoundEntity(void) const
-		{
-			return m_FoundEntity;
-		}
-
-	protected:
-		bool m_FoundEntity;
-
-		int m_X;
-		int m_Y;
-		int m_Z;
-	};
-
-	cTripwireCallback TripwireCallback(BlockX, a_RelBlockY, BlockZ);
-	m_World.ForEachEntityInChunk(m_Chunk->GetPosX(), m_Chunk->GetPosZ(), TripwireCallback);
-
-	if (TripwireCallback.FoundEntity())
-	{
-		m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, 0x1);
-	}
-	else
-	{
-		m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, 0x0);
-	}
-}
-
-
-
-
-
-bool cIncrementalRedstoneSimulator::AreCoordsDirectlyPowered(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, cChunk * a_Chunk)
+cRedstoneSimulator<cChunk, cWorld> * MakeIncrementalRedstoneSimulator(cWorld & a_World)
 {
-	// Torches want to access neighbour's data when on a wall, hence the extra chunk parameter
-
-	int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX;
-	int BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ;
-
-	for (PoweredBlocksList::const_iterator itr = a_Chunk->GetRedstoneSimulatorPoweredBlocksList()->begin(); itr != a_Chunk->GetRedstoneSimulatorPoweredBlocksList()->end(); ++itr)  // Check powered list
-	{
-		if (itr->a_BlockPos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ)))
-		{
-			return true;
-		}
-	}
-	return false;
+	return new cIncrementalRedstoneSimulator<cChunk, cWorld, GetHandlerCompileTime, cChestEntity>(a_World);
 }
 
-
-
-
-
-bool cIncrementalRedstoneSimulator::AreCoordsLinkedPowered(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
-{
-	int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX;
-	int BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ;
-
-	for (LinkedBlocksList::const_iterator itr = m_LinkedPoweredBlocks->begin(); itr != m_LinkedPoweredBlocks->end(); ++itr)  // Check linked powered list
-	{
-		if (itr->a_BlockPos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ)))
-		{
-			return true;
-		}
-	}
-	return false;
-}
-
-
-
-
-
-bool cIncrementalRedstoneSimulator::IsRepeaterPowered(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, NIBBLETYPE a_Meta)
-{
-	// Repeaters cannot be powered by any face except their back; verify that this is true for a source
-	int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX;
-	int BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ;
-
-	for (PoweredBlocksList::const_iterator itr = m_PoweredBlocks->begin(); itr != m_PoweredBlocks->end(); ++itr)
-	{
-		if (!itr->a_BlockPos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ))) { continue; }
-
-		switch (a_Meta & 0x3)
-		{
-			case 0x0:
-			{
-				// Flip the coords to check the back of the repeater
-				if (itr->a_SourcePos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ + 1))) { return true; }
-				break;
-			}
-			case 0x1:
-			{
-				if (itr->a_SourcePos.Equals(Vector3i(BlockX - 1, a_RelBlockY, BlockZ))) { return true; }
-				break;
-			}
-			case 0x2:
-			{
-				if (itr->a_SourcePos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ - 1))) { return true; }
-				break;
-			}
-			case 0x3:
-			{
-				if (itr->a_SourcePos.Equals(Vector3i(BlockX + 1, a_RelBlockY, BlockZ))) { return true; }
-				break;
-			}
-		}
-	}
-
-	for (LinkedBlocksList::const_iterator itr = m_LinkedPoweredBlocks->begin(); itr != m_LinkedPoweredBlocks->end(); ++itr)
-	{
-		if (!itr->a_BlockPos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ))) { continue; }
-
-		switch (a_Meta & 0x3)
-		{
-			case 0x0:
-			{
-				if (itr->a_MiddlePos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ + 1))) { return true; }
-				break;
-			}
-			case 0x1:
-			{
-				if (itr->a_MiddlePos.Equals(Vector3i(BlockX - 1, a_RelBlockY, BlockZ))) { return true; }
-				break;
-			}
-			case 0x2:
-			{
-				if (itr->a_MiddlePos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ - 1))) { return true; }
-				break;
-			}
-			case 0x3:
-			{
-				if (itr->a_MiddlePos.Equals(Vector3i(BlockX + 1, a_RelBlockY, BlockZ))) { return true; }
-				break;
-			}
-		}
-	}
-	return false;  // Couldn't find power source behind repeater
-}
-
-
-
-
-
-bool cIncrementalRedstoneSimulator::IsRepeaterLocked(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, NIBBLETYPE a_Meta)
-{
-	switch (a_Meta & 0x3)  // We only want the 'direction' part of our metadata
-	{
-		// If the repeater is looking up or down (If parallel to the Z axis)
-		case 0x0:
-		case 0x2:
-		{
-			// Check if eastern(right) neighbor is a powered on repeater who is facing us
-			BLOCKTYPE Block = 0;
-			if (m_Chunk->UnboundedRelGetBlockType(a_RelBlockX + 1, a_RelBlockY, a_RelBlockZ, Block) && (Block == E_BLOCK_REDSTONE_REPEATER_ON))  // Is right neighbor a powered repeater?
-			{
-				NIBBLETYPE OtherRepeaterDir = m_Chunk->GetMeta(a_RelBlockX + 1, a_RelBlockY, a_RelBlockZ) & 0x3;
-				if (OtherRepeaterDir == 0x3) { return true; }  // If so, I am latched/locked
-			}
-
-			// Check if western(left) neighbor is a powered on repeater who is facing us
-			if (m_Chunk->UnboundedRelGetBlockType(a_RelBlockX - 1, a_RelBlockY, a_RelBlockZ, Block) && (Block == E_BLOCK_REDSTONE_REPEATER_ON))
-			{
-				NIBBLETYPE OtherRepeaterDir = m_Chunk->GetMeta(a_RelBlockX -1, a_RelBlockY, a_RelBlockZ) & 0x3;
-				if (OtherRepeaterDir == 0x1) { return true; }  // If so, I am latched/locked
-			}
-
-			break;
-		}
-
-		// If the repeater is looking left or right (If parallel to the x axis)
-		case 0x1:
-		case 0x3:
-		{
-			// Check if southern(down) neighbor is a powered on repeater who is facing us
-			BLOCKTYPE Block = 0;
-			if (m_Chunk->UnboundedRelGetBlockType(a_RelBlockX, a_RelBlockY, a_RelBlockZ + 1, Block) && (Block == E_BLOCK_REDSTONE_REPEATER_ON))
-			{
-				NIBBLETYPE OtherRepeaterDir = m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ + 1) & 0x3;
-				if (OtherRepeaterDir == 0x0) { return true; }  // If so,  am latched/locked
-			}
-			
-			// Check if northern(up) neighbor is a powered on repeater who is facing us
-			if (m_Chunk->UnboundedRelGetBlockType(a_RelBlockX, a_RelBlockY, a_RelBlockZ - 1, Block) && (Block == E_BLOCK_REDSTONE_REPEATER_ON))
-			{
-				NIBBLETYPE OtherRepeaterDir = m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ - 1) & 0x3;
-				if (OtherRepeaterDir == 0x2) { return true; }  // If so, I am latched/locked
-			}
-
-			break;
-		}
-	}
-
-	return false;  // None of the checks succeeded, I am not a locked repeater
-}
-
-
-
-
-bool cIncrementalRedstoneSimulator::IsPistonPowered(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, NIBBLETYPE a_Meta)
-{
-	// Pistons cannot be powered through their front face; this function verifies that a source meets this requirement
-
-	eBlockFace Face = cBlockPistonHandler::MetaDataToDirection(a_Meta);
-	int BlockX = m_Chunk->GetPosX() * cChunkDef::Width + a_RelBlockX;
-	int BlockZ = m_Chunk->GetPosZ() * cChunkDef::Width + a_RelBlockZ;
-
-	for (PoweredBlocksList::const_iterator itr = m_PoweredBlocks->begin(); itr != m_PoweredBlocks->end(); ++itr)
-	{
-		if (!itr->a_BlockPos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ))) { continue; }
-
-		AddFaceDirection(BlockX, a_RelBlockY, BlockZ, Face);
-
-		if (!itr->a_SourcePos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ)))
-		{
-			return true;
-		}
-
-		AddFaceDirection(BlockX, a_RelBlockY, BlockZ, Face, true);
-	}
-
-	for (LinkedBlocksList::const_iterator itr = m_LinkedPoweredBlocks->begin(); itr != m_LinkedPoweredBlocks->end(); ++itr)
-	{
-		if (!itr->a_BlockPos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ))) { continue; }
-
-		AddFaceDirection(BlockX, a_RelBlockY, BlockZ, Face);
-
-		if (!itr->a_MiddlePos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ)))
-		{
-			return true;
-		}
-
-		AddFaceDirection(BlockX, a_RelBlockY, BlockZ, Face, true);
-	}
-	return false;  // Source was in front of the piston's front face
-}
-
-
-
-
-bool cIncrementalRedstoneSimulator::IsWirePowered(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, unsigned char & a_PowerLevel)
-{
-	a_PowerLevel = 0;
-	int BlockX = m_Chunk->GetPosX() * cChunkDef::Width + a_RelBlockX;
-	int BlockZ = m_Chunk->GetPosZ() * cChunkDef::Width + a_RelBlockZ;
-
-	for (PoweredBlocksList::const_iterator itr = m_PoweredBlocks->begin(); itr != m_PoweredBlocks->end(); ++itr)  // Check powered list
-	{
-		if (!itr->a_BlockPos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ)))
-		{
-			continue;
-		}
-		a_PowerLevel = std::max(itr->a_PowerLevel, a_PowerLevel);  // Get the highest power level (a_PowerLevel is initialised already and there CAN be multiple levels for one block)
-	}
-
-	for (LinkedBlocksList::const_iterator itr = m_LinkedPoweredBlocks->begin(); itr != m_LinkedPoweredBlocks->end(); ++itr)  // Check linked powered list
-	{
-		if (!itr->a_BlockPos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ)))
-		{
-			continue;
-		}
-
-		BLOCKTYPE Type = E_BLOCK_AIR;
-		int RelSourceX = itr->a_SourcePos.x - m_Chunk->GetPosX() * cChunkDef::Width;
-		int RelSourceZ = itr->a_SourcePos.z - m_Chunk->GetPosZ() * cChunkDef::Width;
-		if (!m_Chunk->UnboundedRelGetBlockType(RelSourceX, itr->a_SourcePos.y, RelSourceZ, Type) || (Type == E_BLOCK_REDSTONE_WIRE))
-		{
-			continue;
-		}
-		a_PowerLevel = std::max(itr->a_PowerLevel, a_PowerLevel);
-	}
-
-	return (a_PowerLevel != 0);  // Answer the inital question: is the wire powered?
-}
-
-
-
-
-
-bool cIncrementalRedstoneSimulator::AreCoordsSimulated(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, bool IsCurrentStatePowered)
-{
-	for (SimulatedPlayerToggleableList::const_iterator itr = m_SimulatedPlayerToggleableBlocks->begin(); itr != m_SimulatedPlayerToggleableBlocks->end(); ++itr)
-	{
-		if (itr->a_RelBlockPos.Equals(Vector3i(a_RelBlockX, a_RelBlockY, a_RelBlockZ)))
-		{
-			if (itr->WasLastStatePowered != IsCurrentStatePowered)  // Was the last power state different to the current?
-			{
-				return false;  // It was, coordinates are no longer simulated
-			}
-			else
-			{
-				return true;  // It wasn't, don't resimulate block, and allow players to toggle
-			}
-		}
-	}
-	return false;  // Block wasn't even in the list, not simulated
-}
-
-
-
-
-
-void cIncrementalRedstoneSimulator::SetDirectionLinkedPowered(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, char a_Direction, unsigned char a_PowerLevel)
-{
-	BLOCKTYPE MiddleBlock = 0;
-	switch (a_Direction)
-	{
-		case BLOCK_FACE_XM:
-		{
-			if (!m_Chunk->UnboundedRelGetBlockType(a_RelBlockX - 1, a_RelBlockY, a_RelBlockZ, MiddleBlock))
-			{
-				return;
-			}
-
-			SetBlockLinkedPowered(a_RelBlockX - 2, a_RelBlockY, a_RelBlockZ, a_RelBlockX - 1, a_RelBlockY, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
-			SetBlockLinkedPowered(a_RelBlockX - 1, a_RelBlockY + 1, a_RelBlockZ, a_RelBlockX - 1, a_RelBlockY, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
-			SetBlockLinkedPowered(a_RelBlockX - 1, a_RelBlockY - 1, a_RelBlockZ, a_RelBlockX - 1, a_RelBlockY, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
-			SetBlockLinkedPowered(a_RelBlockX - 1, a_RelBlockY, a_RelBlockZ + 1, a_RelBlockX - 1, a_RelBlockY, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
-			SetBlockLinkedPowered(a_RelBlockX - 1, a_RelBlockY, a_RelBlockZ - 1, a_RelBlockX - 1, a_RelBlockY, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
-
-			break;
-		}
-		case BLOCK_FACE_XP:
-		{
-			if (!m_Chunk->UnboundedRelGetBlockType(a_RelBlockX + 1, a_RelBlockY, a_RelBlockZ, MiddleBlock))
-			{
-				return;
-			}
-
-			SetBlockLinkedPowered(a_RelBlockX + 2, a_RelBlockY, a_RelBlockZ, a_RelBlockX + 1, a_RelBlockY, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
-			SetBlockLinkedPowered(a_RelBlockX + 1, a_RelBlockY + 1, a_RelBlockZ, a_RelBlockX + 1, a_RelBlockY, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
-			SetBlockLinkedPowered(a_RelBlockX + 1, a_RelBlockY - 1, a_RelBlockZ, a_RelBlockX + 1, a_RelBlockY, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
-			SetBlockLinkedPowered(a_RelBlockX + 1, a_RelBlockY, a_RelBlockZ + 1, a_RelBlockX + 1, a_RelBlockY, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
-			SetBlockLinkedPowered(a_RelBlockX + 1, a_RelBlockY, a_RelBlockZ - 1, a_RelBlockX + 1, a_RelBlockY, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
-
-			break;
-		}
-		case BLOCK_FACE_YM:
-		{
-			if (!m_Chunk->UnboundedRelGetBlockType(a_RelBlockX, a_RelBlockY - 1, a_RelBlockZ, MiddleBlock))
-			{
-				return;
-			}
-
-			SetBlockLinkedPowered(a_RelBlockX, a_RelBlockY - 2, a_RelBlockZ, a_RelBlockX, a_RelBlockY - 1, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
-			SetBlockLinkedPowered(a_RelBlockX + 1, a_RelBlockY - 1, a_RelBlockZ, a_RelBlockX, a_RelBlockY - 1, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
-			SetBlockLinkedPowered(a_RelBlockX - 1, a_RelBlockY - 1, a_RelBlockZ, a_RelBlockX, a_RelBlockY - 1, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
-			SetBlockLinkedPowered(a_RelBlockX, a_RelBlockY - 1, a_RelBlockZ + 1, a_RelBlockX, a_RelBlockY - 1, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
-			SetBlockLinkedPowered(a_RelBlockX, a_RelBlockY - 1, a_RelBlockZ - 1, a_RelBlockX, a_RelBlockY - 1, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
-
-			break;
-		}
-		case BLOCK_FACE_YP:
-		{
-			if (!m_Chunk->UnboundedRelGetBlockType(a_RelBlockX, a_RelBlockY + 1, a_RelBlockZ, MiddleBlock))
-			{
-				return;
-			}
-
-			SetBlockLinkedPowered(a_RelBlockX, a_RelBlockY + 2, a_RelBlockZ, a_RelBlockX, a_RelBlockY + 1, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
-			SetBlockLinkedPowered(a_RelBlockX + 1, a_RelBlockY + 1, a_RelBlockZ, a_RelBlockX, a_RelBlockY + 1, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
-			SetBlockLinkedPowered(a_RelBlockX - 1, a_RelBlockY + 1, a_RelBlockZ, a_RelBlockX, a_RelBlockY + 1, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
-			SetBlockLinkedPowered(a_RelBlockX, a_RelBlockY + 1, a_RelBlockZ + 1, a_RelBlockX, a_RelBlockY + 1, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
-			SetBlockLinkedPowered(a_RelBlockX, a_RelBlockY + 1, a_RelBlockZ - 1, a_RelBlockX, a_RelBlockY + 1, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
-
-			break;
-		}
-		case BLOCK_FACE_ZM:
-		{
-			if (!m_Chunk->UnboundedRelGetBlockType(a_RelBlockX, a_RelBlockY, a_RelBlockZ - 1, MiddleBlock))
-			{
-				return;
-			}
-
-			SetBlockLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ - 2, a_RelBlockX, a_RelBlockY, a_RelBlockZ - 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
-			SetBlockLinkedPowered(a_RelBlockX + 1, a_RelBlockY, a_RelBlockZ - 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ - 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
-			SetBlockLinkedPowered(a_RelBlockX - 1, a_RelBlockY, a_RelBlockZ - 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ - 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
-			SetBlockLinkedPowered(a_RelBlockX, a_RelBlockY + 1, a_RelBlockZ - 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ - 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
-			SetBlockLinkedPowered(a_RelBlockX, a_RelBlockY - 1, a_RelBlockZ - 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ - 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
-
-			break;
-		}
-		case BLOCK_FACE_ZP:
-		{
-			if (!m_Chunk->UnboundedRelGetBlockType(a_RelBlockX, a_RelBlockY, a_RelBlockZ + 1, MiddleBlock))
-			{
-				return;
-			}
-			
-			SetBlockLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ + 2, a_RelBlockX, a_RelBlockY, a_RelBlockZ + 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
-			SetBlockLinkedPowered(a_RelBlockX + 1, a_RelBlockY, a_RelBlockZ + 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ + 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
-			SetBlockLinkedPowered(a_RelBlockX - 1, a_RelBlockY, a_RelBlockZ + 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ + 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
-			SetBlockLinkedPowered(a_RelBlockX, a_RelBlockY + 1, a_RelBlockZ + 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ + 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
-			SetBlockLinkedPowered(a_RelBlockX, a_RelBlockY - 1, a_RelBlockZ + 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ + 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
-
-			break;
-		}
-		default:
-		{
-			ASSERT(!"Unhandled face direction when attempting to set blocks as linked powered!");  // Zombies, that wasn't supposed to happen...
-			break;
-		}
-	}
-}
-
-
-
-
-
-void cIncrementalRedstoneSimulator::SetAllDirsAsPowered(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, unsigned char a_PowerLevel)
-{
-	static const struct
-	{
-		int x, y, z;
-	} gCrossCoords[] =
-	{
-		{ 1, 0, 0 },
-		{ -1, 0, 0 },
-		{ 0, 0, 1 },
-		{ 0, 0, -1 },
-		{ 0, 1, 0 },
-		{ 0, -1, 0 }
-	};
-
-	for (size_t i = 0; i < ARRAYCOUNT(gCrossCoords); i++)  // Loop through struct to power all directions
-	{
-		SetBlockPowered(a_RelBlockX + gCrossCoords[i].x, a_RelBlockY + gCrossCoords[i].y, a_RelBlockZ + gCrossCoords[i].z, a_RelBlockX, a_RelBlockY, a_RelBlockZ, a_PowerLevel);
-	}
-}
-
-
-
-
-
-void cIncrementalRedstoneSimulator::SetBlockPowered(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, int a_RelSourceX, int a_RelSourceY, int a_RelSourceZ, unsigned char a_PowerLevel)
-{
-	int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX;
-	int BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ;
-	int SourceX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelSourceX;
-	int SourceZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelSourceZ;
-
-	cChunk * Neighbour = m_Chunk->GetRelNeighborChunkAdjustCoords(a_RelBlockX, a_RelBlockZ);  // Adjust coordinates for the later call using these values
-	if ((Neighbour == NULL) || !Neighbour->IsValid())
-	{
-		return;
-	}
-
-	PoweredBlocksList * Powered = Neighbour->GetRedstoneSimulatorPoweredBlocksList();  // We need to insert the value into the chunk who owns the block position
-	for (PoweredBlocksList::iterator itr = Powered->begin(); itr != Powered->end(); ++itr)
-	{
-		if (
-			itr->a_BlockPos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ)) &&
-			itr->a_SourcePos.Equals(Vector3i(SourceX, a_RelSourceY, SourceZ))
-			)
-		{
-			// Check for duplicates, update power level, don't add a new listing
-			itr->a_PowerLevel = a_PowerLevel;
-			return;
-		}
-	}
-
-	// No need to get neighbouring chunk as we can guarantee that when something is powering us, the entry will be in our chunk
-	// TODO: on C++11 support, change this to a llama function pased to a std::remove_if
-	for (PoweredBlocksList::iterator itr = m_PoweredBlocks->begin(); itr != m_PoweredBlocks->end(); ++itr)
-	{
-		if (
-			itr->a_BlockPos.Equals(Vector3i(SourceX, a_RelSourceY, SourceZ)) &&
-			itr->a_SourcePos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ)) &&
-			(m_Chunk->GetBlock(a_RelSourceX, a_RelSourceY, a_RelSourceZ) == E_BLOCK_REDSTONE_WIRE)
-			)
-		{
-			BLOCKTYPE Block;
-			NIBBLETYPE Meta;
-			Neighbour->GetBlockTypeMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, Block, Meta);
-
-			if (Block == E_BLOCK_REDSTONE_WIRE)
-			{
-				if (Meta < a_PowerLevel)
-				{
-					m_PoweredBlocks->erase(itr);  // Powering source with higher power level, allow it
-					break;
-				}
-				else
-				{
-					// Powered wires try to power their source - don't let them!
-					return;
-				}
-			}
-		}
-	}
-
-	sPoweredBlocks RC;
-	RC.a_BlockPos = Vector3i(BlockX, a_RelBlockY, BlockZ);
-	RC.a_SourcePos = Vector3i(SourceX, a_RelSourceY, SourceZ);
-	RC.a_PowerLevel = a_PowerLevel;
-	Powered->push_back(RC);
-	Neighbour->SetIsRedstoneDirty(true);
-	m_Chunk->SetIsRedstoneDirty(true);
-}
-
-
-
-
-
-void cIncrementalRedstoneSimulator::SetBlockLinkedPowered(
-	int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ,
-	int a_RelMiddleX, int a_RelMiddleY, int a_RelMiddleZ,
-	int a_RelSourceX, int a_RelSourceY, int a_RelSourceZ,
-	BLOCKTYPE a_MiddleBlock, unsigned char a_PowerLevel
-	)
-{
-	int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX;
-	int BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ;
-	int MiddleX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelMiddleX;
-	int MiddleZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelMiddleZ;
-	int SourceX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelSourceX;
-	int SourceZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelSourceZ;
-
-	if (!IsViableMiddleBlock(a_MiddleBlock))
-	{
-		return;
-	}
-
-	cChunk * Neighbour = m_Chunk->GetNeighborChunk(BlockX, BlockZ);
-	if ((Neighbour == NULL) || !Neighbour->IsValid())
-	{
-		return;
-	}
-
-	LinkedBlocksList * Linked = Neighbour->GetRedstoneSimulatorLinkedBlocksList();
-	for (LinkedBlocksList::iterator itr = Linked->begin(); itr != Linked->end(); ++itr)  // Check linked powered list
-	{
-		if (
-			itr->a_BlockPos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ)) &&
-			itr->a_MiddlePos.Equals(Vector3i(MiddleX, a_RelMiddleY, MiddleZ)) &&
-			itr->a_SourcePos.Equals(Vector3i(SourceX, a_RelSourceY, SourceZ))
-		)
-		{
-			// Check for duplicates, update power level, don't add a new listing
-			itr->a_PowerLevel = a_PowerLevel;
-			return;
-		}
-	}
-
-	sLinkedPoweredBlocks RC;
-	RC.a_BlockPos = Vector3i(BlockX, a_RelBlockY, BlockZ);
-	RC.a_MiddlePos = Vector3i(MiddleX, a_RelMiddleY, MiddleZ);
-	RC.a_SourcePos = Vector3i(SourceX, a_RelSourceY, SourceZ);
-	RC.a_PowerLevel = a_PowerLevel;
-	Linked->push_back(RC);
-	Neighbour->SetIsRedstoneDirty(true);
-	m_Chunk->SetIsRedstoneDirty(true);
-}
-
-
-
-
-
-void cIncrementalRedstoneSimulator::SetPlayerToggleableBlockAsSimulated(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, bool WasLastStatePowered)
-{
-	for (SimulatedPlayerToggleableList::iterator itr = m_SimulatedPlayerToggleableBlocks->begin(); itr != m_SimulatedPlayerToggleableBlocks->end(); ++itr)
-	{
-		if (!itr->a_RelBlockPos.Equals(Vector3i(a_RelBlockX, a_RelBlockY, a_RelBlockZ)))
-		{
-			continue;
-		}
-
-		if (itr->WasLastStatePowered != WasLastStatePowered)
-		{
-			// If power states different, update listing
-			itr->WasLastStatePowered = WasLastStatePowered;
-			return;
-		}
-		else
-		{
-			// If states the same, just ignore
-			return;
-		}
-	}
-
-	// We have arrive here; no block must be in list - add one
-	sSimulatedPlayerToggleableList RC;
-	RC.a_RelBlockPos = Vector3i(a_RelBlockX, a_RelBlockY, a_RelBlockZ);
-	RC.WasLastStatePowered = WasLastStatePowered;
-	m_SimulatedPlayerToggleableBlocks->push_back(RC);
-}
-
-
-
-
-
-bool cIncrementalRedstoneSimulator::QueueRepeaterPowerChange(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, NIBBLETYPE a_Meta, bool ShouldPowerOn)
-{
-	for (RepeatersDelayList::iterator itr = m_RepeatersDelayList->begin(); itr != m_RepeatersDelayList->end(); ++itr)
-	{
-		if (itr->a_RelBlockPos.Equals(Vector3i(a_RelBlockX, a_RelBlockY, a_RelBlockZ)))
-		{
-			if (ShouldPowerOn == itr->ShouldPowerOn)  // We are queued already for the same thing, don't replace entry
-			{
-				return false;
-			}
-
-			// Already in here (normal to allow repeater to continue on powering and updating blocks in front) - just update info and quit
-			itr->a_DelayTicks = (((a_Meta & 0xC) >> 0x2) + 1) * 2;  // See below for description
-			itr->a_ElapsedTicks = 0;
-			itr->ShouldPowerOn = ShouldPowerOn;
-			return false;
-		}
-	}
-
-	// Self not in list, add self to list
-	sRepeatersDelayList RC;
-	RC.a_RelBlockPos = Vector3i(a_RelBlockX, a_RelBlockY, a_RelBlockZ);
-	
-	// Gets the top two bits (delay time), shifts them into the lower two bits, and adds one (meta 0 = 1 tick; 1 = 2 etc.)
-	// Multiply by 2 because in MCS, 1 redstone tick = 1 world tick, but in Vanilla, 1 redstone tick = 2 world ticks, and we need to maintain compatibility
-	RC.a_DelayTicks = (((a_Meta & 0xC) >> 0x2) + 1) * 2;
-
-	RC.a_ElapsedTicks = 0;
-	RC.ShouldPowerOn = ShouldPowerOn;
-	m_RepeatersDelayList->push_back(RC);
-	return true;
-}
-
-
-
-
-
-void cIncrementalRedstoneSimulator::SetSourceUnpowered(int a_SourceX, int a_SourceY, int a_SourceZ, cChunk * a_Chunk, bool a_IsFirstCall)
-{
-	if (!a_IsFirstCall)  // The neighbouring chunks passed when this parameter is false may be invalid
-	{
-		if ((a_Chunk == NULL) || !a_Chunk->IsValid())
-		{
-			return;
-		}
-	}
-	// TODO: on C++11 support, change both of these to llama functions pased to a std::remove_if
-
-	for (PoweredBlocksList::iterator itr = a_Chunk->GetRedstoneSimulatorPoweredBlocksList()->begin(); itr != a_Chunk->GetRedstoneSimulatorPoweredBlocksList()->end();)
-	{
-		if (itr->a_SourcePos.Equals(Vector3i(a_SourceX, a_SourceY, a_SourceZ)))
-		{
-			itr = a_Chunk->GetRedstoneSimulatorPoweredBlocksList()->erase(itr);
-			a_Chunk->SetIsRedstoneDirty(true);
-			continue;
-		}
-		++itr;
-	}
-	for (LinkedBlocksList::iterator itr = a_Chunk->GetRedstoneSimulatorLinkedBlocksList()->begin(); itr != a_Chunk->GetRedstoneSimulatorLinkedBlocksList()->end();)
-	{
-		if (itr->a_SourcePos.Equals(Vector3i(a_SourceX, a_SourceY, a_SourceZ)))
-		{
-			itr = a_Chunk->GetRedstoneSimulatorLinkedBlocksList()->erase(itr);
-			a_Chunk->SetIsRedstoneDirty(true);
-			continue;
-		}
-		++itr;
-	}
-
-	if (a_IsFirstCall && AreCoordsOnChunkBoundary(a_SourceX, a_SourceY, a_SourceZ))
-	{
-		// +- 2 to accomodate linked powered blocks
-		SetSourceUnpowered(a_SourceX, a_SourceY, a_SourceZ, a_Chunk->GetNeighborChunk(a_SourceX - 2, a_SourceZ), false);
-		SetSourceUnpowered(a_SourceX, a_SourceY, a_SourceZ, a_Chunk->GetNeighborChunk(a_SourceX + 2, a_SourceZ), false);
-		SetSourceUnpowered(a_SourceX, a_SourceY, a_SourceZ, a_Chunk->GetNeighborChunk(a_SourceX, a_SourceZ - 2), false);
-		SetSourceUnpowered(a_SourceX, a_SourceY, a_SourceZ, a_Chunk->GetNeighborChunk(a_SourceX, a_SourceZ + 2), false);
-	}
-}
-
-
-
-
-
-cIncrementalRedstoneSimulator::eRedstoneDirection cIncrementalRedstoneSimulator::GetWireDirection(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
-{
-	int Dir = REDSTONE_NONE;
-
-	BLOCKTYPE NegX = 0;
-	if (m_Chunk->UnboundedRelGetBlockType(a_RelBlockX - 1, a_RelBlockY, a_RelBlockZ, NegX))
-	{
-		if (IsPotentialSource(NegX))
-		{
-			Dir |= (REDSTONE_X_POS);
-		}
-	}
-	
-	BLOCKTYPE PosX = 0;
-	if (m_Chunk->UnboundedRelGetBlockType(a_RelBlockX + 1, a_RelBlockY, a_RelBlockZ, PosX))
-	{
-		if (IsPotentialSource(PosX))
-		{
-			Dir |= (REDSTONE_X_NEG);
-		}
-	}
-	
-	BLOCKTYPE NegZ = 0;
-	if (m_Chunk->UnboundedRelGetBlockType(a_RelBlockX, a_RelBlockY, a_RelBlockZ - 1, NegZ))
-	{
-		if (IsPotentialSource(NegZ))
-		{
-			if ((Dir & REDSTONE_X_POS) && !(Dir & REDSTONE_X_NEG))  // corner
-			{
-				Dir ^= REDSTONE_X_POS;
-				Dir |= REDSTONE_X_NEG;
-			}
-			if ((Dir & REDSTONE_X_NEG) && !(Dir & REDSTONE_X_POS))  // corner
-			{
-				Dir ^= REDSTONE_X_NEG;
-				Dir |= REDSTONE_X_POS;
-			}
-			Dir |= REDSTONE_Z_POS;
-		}
-	}
-	
-	BLOCKTYPE PosZ = 0;
-	if (m_Chunk->UnboundedRelGetBlockType(a_RelBlockX, a_RelBlockY, a_RelBlockZ + 1, PosZ))
-	{
-		if (IsPotentialSource(PosZ))
-		{
-			if ((Dir & REDSTONE_X_POS) && !(Dir & REDSTONE_X_NEG))  // corner
-			{
-				Dir ^= REDSTONE_X_POS;
-				Dir |= REDSTONE_X_NEG;
-			}
-			if ((Dir & REDSTONE_X_NEG) && !(Dir & REDSTONE_X_POS))  // corner
-			{
-				Dir ^= REDSTONE_X_NEG;
-				Dir |= REDSTONE_X_POS;
-			}
-			Dir |= REDSTONE_Z_NEG;
-		}
-	}
-	return (eRedstoneDirection)Dir;
-}
-
-
-
-
-
-bool cIncrementalRedstoneSimulator::IsLeverOn(NIBBLETYPE a_BlockMeta)
-{
-	// Extract the ON bit from metadata and return if true if it is set:
-	return ((a_BlockMeta & 0x8) == 0x8);
-}
-
-
-
-
diff --git a/src/Simulator/IncrementalRedstoneSimulator.h b/src/Simulator/IncrementalRedstoneSimulator.h
index 79740a8f6..5bd1ad95d 100644
--- a/src/Simulator/IncrementalRedstoneSimulator.h
+++ b/src/Simulator/IncrementalRedstoneSimulator.h
@@ -3,314 +3,7 @@
 
 #include "RedstoneSimulator.h"
 
-/// Per-chunk data for the simulator, specified individual chunks to simulate
-typedef cCoordWithBlockAndBoolVector cRedstoneSimulatorChunkData;
-
-
-
-
-
-class cIncrementalRedstoneSimulator :
-	public cRedstoneSimulator
-{
-	typedef cRedstoneSimulator super;
-public:
-
-	cIncrementalRedstoneSimulator(cWorld & a_World);
-	~cIncrementalRedstoneSimulator();
-
-	virtual void Simulate(float a_Dt) override { UNUSED(a_Dt);}  // not used
-	virtual void SimulateChunk(float a_Dt, int a_ChunkX, int a_ChunkZ, cChunk * a_Chunk) override;
-	virtual bool IsAllowedBlock(BLOCKTYPE a_BlockType) override { return IsRedstone(a_BlockType); }
-	virtual void WakeUp(int a_BlockX, int a_BlockY, int a_BlockZ, cChunk * a_Chunk) override;
-
-	enum eRedstoneDirection
-	{
-		REDSTONE_NONE =  0,
-		REDSTONE_X_POS = 0x1,
-		REDSTONE_X_NEG = 0x2,
-		REDSTONE_Z_POS = 0x4,
-		REDSTONE_Z_NEG = 0x8,
-	};
-	eRedstoneDirection GetWireDirection(int a_BlockX, int a_BlockY, int a_BlockZ);
-
-private:
-
-	#define MAX_POWER_LEVEL 15
-
-	struct sPoweredBlocks  // Define structure of the directly powered blocks list
-	{
-		Vector3i a_BlockPos;  // Position of powered block
-		Vector3i a_SourcePos;  // Position of source powering the block at a_BlockPos
-		unsigned char a_PowerLevel;
-	};
-
-	struct sLinkedPoweredBlocks  // Define structure of the indirectly powered blocks list (i.e. repeaters powering through a block to the block at the other side)
-	{
-		Vector3i a_BlockPos;
-		Vector3i a_MiddlePos;  // Position of block that is betwixt a source and the destination
-		Vector3i a_SourcePos;
-		unsigned char a_PowerLevel;
-	};
-
-	struct sSimulatedPlayerToggleableList  // Define structure of the list containing simulate-on-update blocks (such as trapdoors that respond once to a block update, and can be toggled by a player)
-	{
-		Vector3i a_RelBlockPos;
-		bool WasLastStatePowered;  // Was the last state powered or not? Determines whether a source update has happened and if I should resimulate
-	};
-
-	struct sRepeatersDelayList  // Define structure of list containing repeaters' delay states
-	{
-		Vector3i a_RelBlockPos;
-		unsigned char a_DelayTicks;  // For how many ticks should the repeater delay
-		unsigned char a_ElapsedTicks;  // How much of the previous has been elapsed?
-		bool ShouldPowerOn;  // What happens when the delay time is fulfilled?
-	};
-
-public:
-
-	typedef std::vector <sPoweredBlocks> PoweredBlocksList;
-	typedef std::vector <sLinkedPoweredBlocks> LinkedBlocksList;
-	typedef std::vector <sSimulatedPlayerToggleableList> SimulatedPlayerToggleableList;
-	typedef std::vector <sRepeatersDelayList> RepeatersDelayList;
-
-private:
-
-	cRedstoneSimulatorChunkData * m_RedstoneSimulatorChunkData;
-	PoweredBlocksList * m_PoweredBlocks;
-	LinkedBlocksList * m_LinkedPoweredBlocks;
-	SimulatedPlayerToggleableList * m_SimulatedPlayerToggleableBlocks;
-	RepeatersDelayList * m_RepeatersDelayList;
-
-	virtual void AddBlock(int a_BlockX, int a_BlockY, int a_BlockZ, cChunk * a_Chunk) override { RedstoneAddBlock(a_BlockX, a_BlockY, a_BlockZ, a_Chunk); }
-	void RedstoneAddBlock(int a_BlockX, int a_BlockY, int a_BlockZ, cChunk * a_Chunk, cChunk * a_OtherChunk = NULL);
-	cChunk * m_Chunk;
-
-	// We want a_MyState for devices needing a full FastSetBlock (as opposed to meta) because with our simulation model, we cannot keep setting the block if it is already set correctly
-	// In addition to being non-performant, it would stop the player from actually breaking said device
-
-	/* ====== SOURCES ====== */
-	/** Handles the redstone torch */
-	void HandleRedstoneTorch(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, BLOCKTYPE a_MyState);
-	/** Handles the redstone block */
-	void HandleRedstoneBlock(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ);
-	/** Handles levers */
-	void HandleRedstoneLever(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ);
-	/** Handles buttons */
-	void HandleRedstoneButton(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ);
-	/** Handles daylight sensors */
-	void HandleDaylightSensor(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ);
-	/** Handles pressure plates */
-	void HandlePressurePlate(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, BLOCKTYPE a_MyType);
-	/** Handles tripwire hooks
-	Performs correct meta and power setting for self by going in the direction it faces and looking for a continous line of tripwire bounded by another oppositely facing hook
-	If this line is complete, it verifies that at least on wire reports an entity is on top (via its meta), and performs its task
-	*/
-	void HandleTripwireHook(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ);
-	/** Handles trapped chests */
-	void HandleTrappedChest(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ);
-	/* ==================== */
-
-	/* ====== CARRIERS ====== */
-	/** Handles redstone wire */
-	void HandleRedstoneWire(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ);
-	/** Handles repeaters */
-	void HandleRedstoneRepeater(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, BLOCKTYPE a_MyState);
-	/* ====================== */
-
-	/* ====== DEVICES ====== */
-	/** Handles pistons */
-	void HandlePiston(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ);
-	/** Handles dispensers and droppers */
-	void HandleDropSpenser(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ);
-	/** Handles TNT (exploding) */
-	void HandleTNT(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ);
-	/** Handles redstone lamps */
-	void HandleRedstoneLamp(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, BLOCKTYPE a_MyState);
-	/** Handles doords */
-	void HandleDoor(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ);
-	/** Handles command blocks */
-	void HandleCommandBlock(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ);
-	/** Handles activator, detector, and powered rails */
-	void HandleRail(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, BLOCKTYPE a_MyType);
-	/** Handles trapdoors */
-	void HandleTrapdoor(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ);
-	/** Handles fence gates */
-	void HandleFenceGate(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ);
-	/** Handles noteblocks */
-	void HandleNoteBlock(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ);
-	/** Handles tripwires */
-	void HandleTripwire(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ);
-	/* ===================== */
-
-	/* ====== Helper functions ====== */
-	/** Marks a block as powered */
-	void SetBlockPowered(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, int a_RelSourceX, int a_RelSourceY, int a_RelSourceZ, unsigned char a_PowerLevel = MAX_POWER_LEVEL);
-	/** Marks a block as being powered through another block */
-	void SetBlockLinkedPowered(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, int a_RelMiddleX, int a_RelMiddleY, int a_RelMiddleZ, int a_RelSourceX, int a_RelSourceY, int a_RelSourceZ, BLOCKTYPE a_MiddeBlock, unsigned char a_PowerLevel = MAX_POWER_LEVEL);
-	/** Marks a block as simulated, who should not be simulated further unless their power state changes, to accomodate a player manually toggling the block without triggering the simulator toggling it back */
-	void SetPlayerToggleableBlockAsSimulated(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, bool WasLastStatePowered);
-	/** Marks the second block in a direction as linked powered */
-	void SetDirectionLinkedPowered(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, char a_Direction, unsigned char a_PowerLevel = MAX_POWER_LEVEL);
-	/** Marks all blocks immediately surrounding a coordinate as powered */
-	void SetAllDirsAsPowered(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, unsigned char a_PowerLevel = MAX_POWER_LEVEL);
-	/** Queues a repeater to be powered or unpowered and returns if the m_RepeatersDelayList iterators were invalidated */
-	bool QueueRepeaterPowerChange(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, NIBBLETYPE a_Meta, bool ShouldPowerOn);
-	/** Removes a block from the Powered and LinkedPowered lists
-	Used for variable sources such as tripwire hooks, daylight sensors, and trapped chests
-	*/
-	void SetSourceUnpowered(int a_RelSourceX, int a_RelSourceY, int a_RelSourceZ, cChunk * a_Chunk, bool a_IsFirstCall = true);
-
-	/** Returns if a coordinate is powered or linked powered */
-	bool AreCoordsPowered(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ) { return AreCoordsDirectlyPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, m_Chunk) || AreCoordsLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ); }
-	/** Returns if a coordinate is in the directly powered blocks list */
-	bool AreCoordsDirectlyPowered(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, cChunk * a_Chunk);
-	/** Returns if a coordinate is in the indirectly powered blocks list */
-	bool AreCoordsLinkedPowered(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ);
-	/** Returns if a coordinate was marked as simulated (for blocks toggleable by players) */
-	bool AreCoordsSimulated(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, bool IsCurrentStatePowered);
-	/** Returns if a repeater is powered by testing for power sources behind the repeater */
-	bool IsRepeaterPowered(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, NIBBLETYPE a_Meta);
-	/** Returns if a repeater is locked */
-	bool IsRepeaterLocked(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, NIBBLETYPE a_Meta);
-	/** Returns if a piston is powered */
-	bool IsPistonPowered(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, NIBBLETYPE a_Meta);
-	/** Returns if a wire is powered
-	The only diffence between this and a normal AreCoordsPowered is that this function checks for a wire powering another wire */
-	bool IsWirePowered(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, unsigned char & a_PowerLevel);
-	/** Handles delayed updates to repeaters **/
-	void HandleRedstoneRepeaterDelays(void);
-
-	/** Returns if lever metadata marks it as emitting power */
-	bool IsLeverOn(NIBBLETYPE a_BlockMeta);
-	/** Returns if button metadata marks it as emitting power */
-	bool IsButtonOn(NIBBLETYPE a_BlockMeta) { return IsLeverOn(a_BlockMeta); }
-	/* ============================== */
-
-	/* ====== Misc Functions ====== */
-	/** Returns if a block is viable to be the MiddleBlock of a SetLinkedPowered operation */
-	inline static bool IsViableMiddleBlock(BLOCKTYPE Block) { return cBlockInfo::FullyOccupiesVoxel(Block); }
-
-	/** Returns if a block is a mechanism (something that accepts power and does something)
-	Used by torches to determine if they power a block whilst not standing on the ground
-	*/
-	inline static bool IsMechanism(BLOCKTYPE Block)
-	{
-		switch (Block)
-		{
-			case E_BLOCK_ACTIVATOR_RAIL:
-			case E_BLOCK_COMMAND_BLOCK:
-			case E_BLOCK_PISTON:
-			case E_BLOCK_STICKY_PISTON:
-			case E_BLOCK_DISPENSER:
-			case E_BLOCK_DROPPER:
-			case E_BLOCK_FENCE_GATE:
-			case E_BLOCK_HOPPER:
-			case E_BLOCK_NOTE_BLOCK:
-			case E_BLOCK_TNT:
-			case E_BLOCK_TRAPDOOR:
-			case E_BLOCK_REDSTONE_LAMP_OFF:
-			case E_BLOCK_REDSTONE_LAMP_ON:
-			case E_BLOCK_WOODEN_DOOR:
-			case E_BLOCK_IRON_DOOR:
-			case E_BLOCK_REDSTONE_REPEATER_OFF:
-			case E_BLOCK_REDSTONE_REPEATER_ON:
-			case E_BLOCK_POWERED_RAIL:
-			case E_BLOCK_REDSTONE_WIRE:
-			{
-				return true;
-			}
-			default: return false;
-		}
-	}
-
-	/** Returns if a block has the potential to output power */
-	inline static bool IsPotentialSource(BLOCKTYPE Block)
-	{
-		switch (Block)
-		{
-			case E_BLOCK_DETECTOR_RAIL:
-			case E_BLOCK_DAYLIGHT_SENSOR:
-			case E_BLOCK_WOODEN_BUTTON:
-			case E_BLOCK_STONE_BUTTON:
-			case E_BLOCK_REDSTONE_WIRE:
-			case E_BLOCK_REDSTONE_TORCH_ON:
-			case E_BLOCK_LEVER:
-			case E_BLOCK_REDSTONE_REPEATER_ON:
-			case E_BLOCK_BLOCK_OF_REDSTONE:
-			case E_BLOCK_ACTIVE_COMPARATOR:
-			case E_BLOCK_HEAVY_WEIGHTED_PRESSURE_PLATE:
-			case E_BLOCK_LIGHT_WEIGHTED_PRESSURE_PLATE:
-			case E_BLOCK_STONE_PRESSURE_PLATE:
-			case E_BLOCK_WOODEN_PRESSURE_PLATE:
-			case E_BLOCK_TRAPPED_CHEST:
-			{
-				return true;
-			}
-			default: return false;
-		}
-	}
-
-	/** Returns if a block is any sort of redstone device */
-	inline static bool IsRedstone(BLOCKTYPE Block)
-	{
-		switch (Block)
-		{
-			// All redstone devices, please alpha sort
-			case E_BLOCK_ACTIVATOR_RAIL:
-			case E_BLOCK_ACTIVE_COMPARATOR:
-			case E_BLOCK_BLOCK_OF_REDSTONE:
-			case E_BLOCK_COMMAND_BLOCK:
-			case E_BLOCK_DETECTOR_RAIL:
-			case E_BLOCK_DISPENSER:
-			case E_BLOCK_DAYLIGHT_SENSOR:
-			case E_BLOCK_DROPPER:
-			case E_BLOCK_FENCE_GATE:
-			case E_BLOCK_HEAVY_WEIGHTED_PRESSURE_PLATE:
-			case E_BLOCK_HOPPER:
-			case E_BLOCK_INACTIVE_COMPARATOR:
-			case E_BLOCK_IRON_DOOR:
-			case E_BLOCK_LEVER:
-			case E_BLOCK_LIGHT_WEIGHTED_PRESSURE_PLATE:
-			case E_BLOCK_NOTE_BLOCK:
-			case E_BLOCK_POWERED_RAIL:
-			case E_BLOCK_REDSTONE_LAMP_OFF:
-			case E_BLOCK_REDSTONE_LAMP_ON:
-			case E_BLOCK_REDSTONE_REPEATER_OFF:
-			case E_BLOCK_REDSTONE_REPEATER_ON:
-			case E_BLOCK_REDSTONE_TORCH_OFF:
-			case E_BLOCK_REDSTONE_TORCH_ON:
-			case E_BLOCK_REDSTONE_WIRE:
-			case E_BLOCK_STICKY_PISTON:
-			case E_BLOCK_STONE_BUTTON:
-			case E_BLOCK_STONE_PRESSURE_PLATE:
-			case E_BLOCK_TNT:
-			case E_BLOCK_TRAPDOOR:
-			case E_BLOCK_TRAPPED_CHEST:
-			case E_BLOCK_TRIPWIRE_HOOK:
-			case E_BLOCK_TRIPWIRE:
-			case E_BLOCK_WOODEN_BUTTON:
-			case E_BLOCK_WOODEN_DOOR:
-			case E_BLOCK_WOODEN_PRESSURE_PLATE:
-			case E_BLOCK_PISTON:
-			{
-				return true;
-			}
-			default: return false;
-		}
-	}
-
-	inline static bool AreCoordsOnChunkBoundary(int a_BlockX, int a_BlockY, int a_BlockZ)
-	{
-		return (  // Are we on a chunk boundary? +- 2 because of LinkedPowered blocks
-			((a_BlockX % cChunkDef::Width) <= 1) ||
-			((a_BlockX % cChunkDef::Width) >= 14) ||
-			((a_BlockZ % cChunkDef::Width) <= 1) ||
-			((a_BlockZ % cChunkDef::Width) >= 14)
-		);
-	}
-};
-
-
-
+class cWorld;
+class cChunk;
 
+cRedstoneSimulator<cChunk, cWorld> * MakeIncrementalRedstoneSimulator(cWorld & a_World);
diff --git a/src/Simulator/IncrementalRedstoneSimulator.inc b/src/Simulator/IncrementalRedstoneSimulator.inc
new file mode 100644
index 000000000..6fda9824c
--- /dev/null
+++ b/src/Simulator/IncrementalRedstoneSimulator.inc
@@ -0,0 +1,2583 @@
+
+#include "IncrementalRedstoneSimulator.h"
+#include "BoundingBox.h"
+#include "BlockEntities/RedstonePoweredEntity.h"
+#include "Blocks/ChunkInterface.h"
+#include "RedstoneSimulator.h"
+
+
+typedef cItemCallback<cEntity> cEntityCallback;
+
+
+
+
+
+typedef cItemCallback<cRedstonePoweredEntity> cRedstonePoweredCallback;
+
+
+template<class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+class cIncrementalRedstoneSimulator :
+	public cRedstoneSimulator<ChunkType, WorldType>
+{
+	typedef cRedstoneSimulator<ChunkType, WorldType> super;
+public:
+
+	cIncrementalRedstoneSimulator(WorldType & a_World)
+		: cRedstoneSimulator<ChunkType, WorldType>(a_World)
+	{
+	}
+	~cIncrementalRedstoneSimulator();
+
+	virtual void Simulate(float a_Dt) override { UNUSED(a_Dt);}  // not used
+	virtual void SimulateChunk(float a_Dt, int a_ChunkX, int a_ChunkZ, ChunkType * a_Chunk) override;
+	virtual bool IsAllowedBlock(BLOCKTYPE a_BlockType) override { return IsRedstone(a_BlockType); }
+	virtual void WakeUp(int a_BlockX, int a_BlockY, int a_BlockZ, ChunkType * a_Chunk) override;
+
+	enum eRedstoneDirection
+	{
+		REDSTONE_NONE =  0,
+		REDSTONE_X_POS = 0x1,
+		REDSTONE_X_NEG = 0x2,
+		REDSTONE_Z_POS = 0x4,
+		REDSTONE_Z_NEG = 0x8,
+	};
+	eRedstoneDirection GetWireDirection(int a_BlockX, int a_BlockY, int a_BlockZ);
+
+private:
+
+	#define MAX_POWER_LEVEL 15
+
+	struct sPoweredBlocks  // Define structure of the directly powered blocks list
+	{
+		Vector3i a_BlockPos;  // Position of powered block
+		Vector3i a_SourcePos;  // Position of source powering the block at a_BlockPos
+		unsigned char a_PowerLevel;
+	};
+
+	struct sLinkedPoweredBlocks  // Define structure of the indirectly powered blocks list (i.e. repeaters powering through a block to the block at the other side)
+	{
+		Vector3i a_BlockPos;
+		Vector3i a_MiddlePos;  // Position of block that is betwixt a source and the destination
+		Vector3i a_SourcePos;
+		unsigned char a_PowerLevel;
+	};
+
+	struct sSimulatedPlayerToggleableList  // Define structure of the list containing simulate-on-update blocks (such as trapdoors that respond once to a block update, and can be toggled by a player)
+	{
+		Vector3i a_RelBlockPos;
+		bool WasLastStatePowered;  // Was the last state powered or not? Determines whether a source update has happened and if I should resimulate
+	};
+
+	struct sRepeatersDelayList  // Define structure of list containing repeaters' delay states
+	{
+		Vector3i a_RelBlockPos;
+		unsigned char a_DelayTicks;  // For how many ticks should the repeater delay
+		unsigned char a_ElapsedTicks;  // How much of the previous has been elapsed?
+		bool ShouldPowerOn;  // What happens when the delay time is fulfilled?
+	};
+	
+	class cIncrementalRedstoneSimulatorChunkData :
+	cRedstoneSimulatorChunkData
+	{
+	public:
+		/// Per-chunk data for the simulator, specified individual chunks to simulate
+		cCoordWithBlockAndBoolVector m_ChunkData;
+		cCoordWithBlockAndBoolVector m_QueuedChunkData;
+		std::vector<sPoweredBlocks> m_PoweredBlocks;
+		std::vector<sLinkedPoweredBlocks> m_LinkedBlocks;
+		std::vector<sSimulatedPlayerToggleableList> m_SimulatedPlayerToggleableBlocks;
+		std::vector<sRepeatersDelayList> m_RepeatersDelayList;
+	};
+
+public:
+
+	typedef std::vector <sPoweredBlocks> PoweredBlocksList;
+	typedef std::vector <sLinkedPoweredBlocks> LinkedBlocksList;
+	typedef std::vector <sSimulatedPlayerToggleableList> SimulatedPlayerToggleableList;
+	typedef std::vector <sRepeatersDelayList> RepeatersDelayList;
+
+private:
+
+	cIncrementalRedstoneSimulatorChunkData * m_RedstoneSimulatorChunkData;
+	PoweredBlocksList * m_PoweredBlocks;
+	LinkedBlocksList * m_LinkedPoweredBlocks;
+	SimulatedPlayerToggleableList * m_SimulatedPlayerToggleableBlocks;
+	RepeatersDelayList * m_RepeatersDelayList;
+
+	virtual void AddBlock(int a_BlockX, int a_BlockY, int a_BlockZ, ChunkType * a_Chunk) override { RedstoneAddBlock(a_BlockX, a_BlockY, a_BlockZ, a_Chunk); }
+	void RedstoneAddBlock(int a_BlockX, int a_BlockY, int a_BlockZ, ChunkType * a_Chunk, ChunkType * a_OtherChunk = NULL);
+	ChunkType * m_Chunk;
+
+	// We want a_MyState for devices needing a full FastSetBlock (as opposed to meta) because with our simulation model, we cannot keep setting the block if it is already set correctly
+	// In addition to being non-performant, it would stop the player from actually breaking said device
+
+	/* ====== SOURCES ====== */
+	/** Handles the redstone torch */
+	void HandleRedstoneTorch(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, BLOCKTYPE a_MyState);
+	/** Handles the redstone block */
+	void HandleRedstoneBlock(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ);
+	/** Handles levers */
+	void HandleRedstoneLever(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ);
+	/** Handles buttons */
+	void HandleRedstoneButton(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ);
+	/** Handles daylight sensors */
+	void HandleDaylightSensor(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ);
+	/** Handles pressure plates */
+	void HandlePressurePlate(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, BLOCKTYPE a_MyType);
+	/** Handles tripwire hooks
+	Performs correct meta and power setting for self by going in the direction it faces and looking for a continous line of tripwire bounded by another oppositely facing hook
+	If this line is complete, it verifies that at least on wire reports an entity is on top (via its meta), and performs its task
+	*/
+	void HandleTripwireHook(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ);
+	/** Handles trapped chests */
+	void HandleTrappedChest(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ);
+	/* ==================== */
+
+	/* ====== CARRIERS ====== */
+	/** Handles redstone wire */
+	void HandleRedstoneWire(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ);
+	/** Handles repeaters */
+	void HandleRedstoneRepeater(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, BLOCKTYPE a_MyState);
+	/* ====================== */
+
+	/* ====== DEVICES ====== */
+	/** Handles pistons */
+	void HandlePiston(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ);
+	/** Handles dispensers and droppers */
+	void HandleDropSpenser(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ);
+	/** Handles TNT (exploding) */
+	void HandleTNT(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ);
+	/** Handles redstone lamps */
+	void HandleRedstoneLamp(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, BLOCKTYPE a_MyState);
+	/** Handles doords */
+	void HandleDoor(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ);
+	/** Handles command blocks */
+	void HandleCommandBlock(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ);
+	/** Handles activator, detector, and powered rails */
+	void HandleRail(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, BLOCKTYPE a_MyType);
+	/** Handles trapdoors */
+	void HandleTrapdoor(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ);
+	/** Handles fence gates */
+	void HandleFenceGate(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ);
+	/** Handles noteblocks */
+	void HandleNoteBlock(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ);
+	/** Handles tripwires */
+	void HandleTripwire(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ);
+	/* ===================== */
+
+	/* ====== Helper functions ====== */
+	/** Marks a block as powered */
+	void SetBlockPowered(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, int a_RelSourceX, int a_RelSourceY, int a_RelSourceZ, unsigned char a_PowerLevel = MAX_POWER_LEVEL);
+	/** Marks a block as being powered through another block */
+	void SetBlockLinkedPowered(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, int a_RelMiddleX, int a_RelMiddleY, int a_RelMiddleZ, int a_RelSourceX, int a_RelSourceY, int a_RelSourceZ, BLOCKTYPE a_MiddeBlock, unsigned char a_PowerLevel = MAX_POWER_LEVEL);
+	/** Marks a block as simulated, who should not be simulated further unless their power state changes, to accomodate a player manually toggling the block without triggering the simulator toggling it back */
+	void SetPlayerToggleableBlockAsSimulated(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, bool WasLastStatePowered);
+	/** Marks the second block in a direction as linked powered */
+	void SetDirectionLinkedPowered(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, char a_Direction, unsigned char a_PowerLevel = MAX_POWER_LEVEL);
+	/** Marks all blocks immediately surrounding a coordinate as powered */
+	void SetAllDirsAsPowered(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, unsigned char a_PowerLevel = MAX_POWER_LEVEL);
+	/** Queues a repeater to be powered or unpowered and returns if the m_RepeatersDelayList iterators were invalidated */
+	bool QueueRepeaterPowerChange(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, NIBBLETYPE a_Meta, bool ShouldPowerOn);
+	/** Removes a block from the Powered and LinkedPowered lists
+	Used for variable sources such as tripwire hooks, daylight sensors, and trapped chests
+	*/
+	void SetSourceUnpowered(int a_RelSourceX, int a_RelSourceY, int a_RelSourceZ, ChunkType * a_Chunk, bool a_IsFirstCall = true);
+
+	/** Returns if a coordinate is powered or linked powered */
+	bool AreCoordsPowered(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ) { return AreCoordsDirectlyPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, m_Chunk) || AreCoordsLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ); }
+	/** Returns if a coordinate is in the directly powered blocks list */
+	bool AreCoordsDirectlyPowered(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, ChunkType * a_Chunk);
+	/** Returns if a coordinate is in the indirectly powered blocks list */
+	bool AreCoordsLinkedPowered(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ);
+	/** Returns if a coordinate was marked as simulated (for blocks toggleable by players) */
+	bool AreCoordsSimulated(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, bool IsCurrentStatePowered);
+	/** Returns if a repeater is powered by testing for power sources behind the repeater */
+	bool IsRepeaterPowered(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, NIBBLETYPE a_Meta);
+	/** Returns if a repeater is locked */
+	bool IsRepeaterLocked(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, NIBBLETYPE a_Meta);
+	/** Returns if a piston is powered */
+	bool IsPistonPowered(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, NIBBLETYPE a_Meta);
+	/** Returns if a wire is powered
+	The only diffence between this and a normal AreCoordsPowered is that this function checks for a wire powering another wire */
+	bool IsWirePowered(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, unsigned char & a_PowerLevel);
+	/** Handles delayed updates to repeaters **/
+	void HandleRedstoneRepeaterDelays(void);
+
+	/** Returns if lever metadata marks it as emitting power */
+	bool IsLeverOn(NIBBLETYPE a_BlockMeta);
+	/** Returns if button metadata marks it as emitting power */
+	bool IsButtonOn(NIBBLETYPE a_BlockMeta) { return IsLeverOn(a_BlockMeta); }
+	/* ============================== */
+
+	/* ====== Misc Functions ====== */
+	/** Returns if a block is viable to be the MiddleBlock of a SetLinkedPowered operation */
+	inline static bool IsViableMiddleBlock(BLOCKTYPE Block) { return cBlockInfo::FullyOccupiesVoxel(Block); }
+
+	/** Returns if a block is a mechanism (something that accepts power and does something)
+	Used by torches to determine if they power a block whilst not standing on the ground
+	*/
+	inline static bool IsMechanism(BLOCKTYPE Block)
+	{
+		switch (Block)
+		{
+			case E_BLOCK_ACACIA_DOOR:
+			case E_BLOCK_ACACIA_FENCE_GATE:
+			case E_BLOCK_ACTIVATOR_RAIL:
+			case E_BLOCK_BIRCH_DOOR:
+			case E_BLOCK_BIRCH_FENCE_GATE:
+			case E_BLOCK_COMMAND_BLOCK:
+			case E_BLOCK_DARK_OAK_DOOR:
+			case E_BLOCK_DARK_OAK_FENCE_GATE:
+			case E_BLOCK_DISPENSER:
+			case E_BLOCK_DROPPER:
+			case E_BLOCK_FENCE_GATE:
+			case E_BLOCK_HOPPER:
+			case E_BLOCK_IRON_DOOR:
+			case E_BLOCK_IRON_TRAPDOOR:
+			case E_BLOCK_JUNGLE_DOOR:
+			case E_BLOCK_JUNGLE_FENCE_GATE:
+			case E_BLOCK_NOTE_BLOCK:
+			case E_BLOCK_PISTON:
+			case E_BLOCK_POWERED_RAIL:
+			case E_BLOCK_REDSTONE_LAMP_OFF:
+			case E_BLOCK_REDSTONE_LAMP_ON:
+			case E_BLOCK_REDSTONE_REPEATER_OFF:
+			case E_BLOCK_REDSTONE_REPEATER_ON:
+			case E_BLOCK_REDSTONE_WIRE:
+			case E_BLOCK_SPRUCE_DOOR:
+			case E_BLOCK_SPRUCE_FENCE_GATE:
+			case E_BLOCK_STICKY_PISTON:
+			case E_BLOCK_TNT:
+			case E_BLOCK_TRAPDOOR:
+			case E_BLOCK_WOODEN_DOOR:
+			{
+				return true;
+			}
+			default: return false;
+		}
+	}
+
+	/** Returns if a block has the potential to output power */
+	inline static bool IsPotentialSource(BLOCKTYPE Block)
+	{
+		switch (Block)
+		{
+			case E_BLOCK_DETECTOR_RAIL:
+			case E_BLOCK_DAYLIGHT_SENSOR:
+			case E_BLOCK_WOODEN_BUTTON:
+			case E_BLOCK_STONE_BUTTON:
+			case E_BLOCK_REDSTONE_WIRE:
+			case E_BLOCK_REDSTONE_TORCH_ON:
+			case E_BLOCK_LEVER:
+			case E_BLOCK_REDSTONE_REPEATER_ON:
+			case E_BLOCK_BLOCK_OF_REDSTONE:
+			case E_BLOCK_ACTIVE_COMPARATOR:
+			case E_BLOCK_HEAVY_WEIGHTED_PRESSURE_PLATE:
+			case E_BLOCK_LIGHT_WEIGHTED_PRESSURE_PLATE:
+			case E_BLOCK_STONE_PRESSURE_PLATE:
+			case E_BLOCK_WOODEN_PRESSURE_PLATE:
+			case E_BLOCK_TRAPPED_CHEST:
+			{
+				return true;
+			}
+			default: return false;
+		}
+	}
+
+	/** Returns if a block is any sort of redstone device */
+	inline static bool IsRedstone(BLOCKTYPE Block)
+	{
+		switch (Block)
+		{
+			// All redstone devices, please alpha sort
+			case E_BLOCK_ACACIA_DOOR:
+			case E_BLOCK_ACACIA_FENCE_GATE:
+			case E_BLOCK_ACTIVATOR_RAIL:
+			case E_BLOCK_ACTIVE_COMPARATOR:
+			case E_BLOCK_BIRCH_DOOR:
+			case E_BLOCK_BIRCH_FENCE_GATE:
+			case E_BLOCK_BLOCK_OF_REDSTONE:
+			case E_BLOCK_COMMAND_BLOCK:
+			case E_BLOCK_DARK_OAK_DOOR:
+			case E_BLOCK_DARK_OAK_FENCE_GATE:
+			case E_BLOCK_DAYLIGHT_SENSOR:
+			case E_BLOCK_DETECTOR_RAIL:
+			case E_BLOCK_DISPENSER:
+			case E_BLOCK_DROPPER:
+			case E_BLOCK_FENCE_GATE:
+			case E_BLOCK_HEAVY_WEIGHTED_PRESSURE_PLATE:
+			case E_BLOCK_HOPPER:
+			case E_BLOCK_INACTIVE_COMPARATOR:
+			case E_BLOCK_IRON_DOOR:
+			case E_BLOCK_IRON_TRAPDOOR:
+			case E_BLOCK_JUNGLE_DOOR:
+			case E_BLOCK_JUNGLE_FENCE_GATE:
+			case E_BLOCK_LEVER:
+			case E_BLOCK_LIGHT_WEIGHTED_PRESSURE_PLATE:
+			case E_BLOCK_NOTE_BLOCK:
+			case E_BLOCK_POWERED_RAIL:
+			case E_BLOCK_REDSTONE_LAMP_OFF:
+			case E_BLOCK_REDSTONE_LAMP_ON:
+			case E_BLOCK_REDSTONE_REPEATER_OFF:
+			case E_BLOCK_REDSTONE_REPEATER_ON:
+			case E_BLOCK_REDSTONE_TORCH_OFF:
+			case E_BLOCK_REDSTONE_TORCH_ON:
+			case E_BLOCK_REDSTONE_WIRE:
+			case E_BLOCK_SPRUCE_DOOR:
+			case E_BLOCK_SPRUCE_FENCE_GATE:
+			case E_BLOCK_STICKY_PISTON:
+			case E_BLOCK_STONE_BUTTON:
+			case E_BLOCK_STONE_PRESSURE_PLATE:
+			case E_BLOCK_TNT:
+			case E_BLOCK_TRAPDOOR:
+			case E_BLOCK_TRAPPED_CHEST:
+			case E_BLOCK_TRIPWIRE_HOOK:
+			case E_BLOCK_TRIPWIRE:
+			case E_BLOCK_WOODEN_BUTTON:
+			case E_BLOCK_WOODEN_DOOR:
+			case E_BLOCK_WOODEN_PRESSURE_PLATE:
+			case E_BLOCK_PISTON:
+			{
+				return true;
+			}
+			default: return false;
+		}
+	}
+
+	inline static bool AreCoordsOnChunkBoundary(int a_BlockX, int a_BlockY, int a_BlockZ)
+	{
+		return (  // Are we on a chunk boundary? +- 2 because of LinkedPowered blocks
+			((a_BlockX % cChunkDef::Width) <= 1) ||
+			((a_BlockX % cChunkDef::Width) >= 14) ||
+			((a_BlockZ % cChunkDef::Width) <= 1) ||
+			((a_BlockZ % cChunkDef::Width) >= 14)
+		);
+	}
+};
+
+
+
+
+
+template<class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::~cIncrementalRedstoneSimulator()
+{
+}
+
+
+
+
+template<class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+void cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::RedstoneAddBlock(int a_BlockX, int a_BlockY, int a_BlockZ, ChunkType * a_Chunk, ChunkType * a_OtherChunk)
+{
+	if ((a_Chunk == NULL) || !a_Chunk->IsValid())
+	{
+		return;
+	}
+	else if ((a_BlockY < 0) || (a_BlockY > cChunkDef::Height))
+	{
+		return;
+	}
+
+	// We may be called with coordinates in a chunk that is not the first chunk parameter
+	// In that case, the actual chunk (which the coordinates are in), will be passed as the second parameter
+	// Use that Chunk pointer to get a relative position
+
+	int RelX = 0;
+	int RelZ = 0;
+	BLOCKTYPE Block;
+	NIBBLETYPE Meta;
+
+	if (a_OtherChunk != NULL)
+	{
+		RelX = a_BlockX - a_OtherChunk->GetPosX() * cChunkDef::Width;
+		RelZ = a_BlockZ - a_OtherChunk->GetPosZ() * cChunkDef::Width;
+		a_OtherChunk->GetBlockTypeMeta(RelX, a_BlockY, RelZ, Block, Meta);
+
+		// If a_OtherChunk is passed (not NULL), it is the chunk that had a block change, and a_Chunk will be the neighbouring chunk of that block
+		// Because said neighbouring chunk does not know of this change but still needs to update its redstone, we set it to dirty
+		a_Chunk->SetIsRedstoneDirty(true);
+	}
+	else
+	{
+		RelX = a_BlockX - a_Chunk->GetPosX() * cChunkDef::Width;
+		RelZ = a_BlockZ - a_Chunk->GetPosZ() * cChunkDef::Width;
+		a_Chunk->GetBlockTypeMeta(RelX, a_BlockY, RelZ, Block, Meta);
+	}
+
+	// Every time a block is changed (AddBlock called), we want to go through all lists and check to see if the coordiantes stored within are still valid
+	// Checking only when a block is changed, as opposed to every tick, also improves performance
+
+	PoweredBlocksList & PoweredBlocks = ((cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::cIncrementalRedstoneSimulatorChunkData *)a_Chunk->GetRedstoneSimulatorData())->m_PoweredBlocks;
+	for (typename PoweredBlocksList::iterator itr = PoweredBlocks.begin(); itr != PoweredBlocks.end();)
+	{
+		if (!itr->a_SourcePos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)))
+		{
+			++itr;
+			continue;
+		}
+
+		if (!IsPotentialSource(Block))
+		{
+			LOGD("cIncrementalRedstoneSimulator: Erased block @ {%i, %i, %i} from powered blocks list as it no longer connected to a source", itr->a_BlockPos.x, itr->a_BlockPos.y, itr->a_BlockPos.z);
+			itr = PoweredBlocks.erase(itr);
+			continue;
+		}
+		else if (
+			// Changeable sources
+			((Block == E_BLOCK_REDSTONE_WIRE) && (Meta == 0)) ||
+			((Block == E_BLOCK_LEVER) && !IsLeverOn(Meta)) ||
+			((Block == E_BLOCK_DETECTOR_RAIL) && ((Meta & 0x08) == 0)) ||
+			(((Block == E_BLOCK_STONE_BUTTON) || (Block == E_BLOCK_WOODEN_BUTTON)) && (!IsButtonOn(Meta))) ||
+			((Block == E_BLOCK_TRIPWIRE_HOOK) && ((Meta & 0x08) == 0))
+			)
+		{
+			LOGD("cIncrementalRedstoneSimulator: Erased block @ {%i, %i, %i} from powered blocks list due to present/past metadata mismatch", itr->a_BlockPos.x, itr->a_BlockPos.y, itr->a_BlockPos.z);
+			itr = PoweredBlocks.erase(itr);
+			continue;
+		}
+		++itr;
+	}
+
+	LinkedBlocksList & LinkedPoweredBlocks = ((cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::cIncrementalRedstoneSimulatorChunkData *)a_Chunk->GetRedstoneSimulatorData())->m_LinkedBlocks;
+	// We loop through all values (insteading of breaking out at the first) to make sure everything is gone, as there can be multiple SourceBlock entries for one AddBlock coordinate
+	for (typename LinkedBlocksList::iterator itr = LinkedPoweredBlocks.begin(); itr != LinkedPoweredBlocks.end();)
+	{
+		if (itr->a_SourcePos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)))
+		{
+			if (!IsPotentialSource(Block))
+			{
+				LOGD("cIncrementalRedstoneSimulator: Erased block @ {%i, %i, %i} from linked powered blocks list as it is no longer connected to a source", itr->a_BlockPos.x, itr->a_BlockPos.y, itr->a_BlockPos.z);
+				itr = LinkedPoweredBlocks.erase(itr);
+				continue;
+			}
+			else if (
+				// Things that can send power through a block but which depends on meta
+				((Block == E_BLOCK_REDSTONE_WIRE) && (Meta == 0)) ||
+				((Block == E_BLOCK_LEVER) && !IsLeverOn(Meta)) ||
+				(((Block == E_BLOCK_STONE_BUTTON) || (Block == E_BLOCK_WOODEN_BUTTON)) && (!IsButtonOn(Meta)))
+				)
+			{
+				LOGD("cIncrementalRedstoneSimulator: Erased block @ {%i, %i, %i} from linked powered blocks list due to present/past metadata mismatch", itr->a_BlockPos.x, itr->a_BlockPos.y, itr->a_BlockPos.z);
+				itr = LinkedPoweredBlocks.erase(itr);
+				continue;
+			}
+		}
+		else if (itr->a_MiddlePos.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)))
+		{
+			if (!IsViableMiddleBlock(Block))
+			{
+				LOGD("cIncrementalRedstoneSimulator: Erased block @ {%i, %i, %i} from linked powered blocks list as it is no longer powered through a valid middle block", itr->a_BlockPos.x, itr->a_BlockPos.y, itr->a_BlockPos.z);
+				itr = LinkedPoweredBlocks.erase(itr);
+				continue;
+			}
+		}
+		++itr;
+	}
+
+	SimulatedPlayerToggleableList & SimulatedPlayerToggleableBlocks = ((cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::cIncrementalRedstoneSimulatorChunkData *)a_Chunk->GetRedstoneSimulatorData())->m_SimulatedPlayerToggleableBlocks;
+	for (typename SimulatedPlayerToggleableList::iterator itr = SimulatedPlayerToggleableBlocks.begin(); itr != SimulatedPlayerToggleableBlocks.end(); ++itr)
+	{
+		if (!itr->a_RelBlockPos.Equals(Vector3i(RelX, a_BlockY, RelZ)))
+		{
+			continue;
+		}
+
+		if (!IsAllowedBlock(Block))
+		{
+			LOGD("cIncrementalRedstoneSimulator: Erased block @ {%i, %i, %i} from toggleable simulated list as it is no longer redstone", itr->a_RelBlockPos.x, itr->a_RelBlockPos.y, itr->a_RelBlockPos.z);
+			SimulatedPlayerToggleableBlocks.erase(itr);
+			break;
+		}
+	}
+
+	RepeatersDelayList & RepeatersDelayList = ((cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::cIncrementalRedstoneSimulatorChunkData *)a_Chunk->GetRedstoneSimulatorData())->m_RepeatersDelayList;
+	for (typename RepeatersDelayList::iterator itr = RepeatersDelayList.begin(); itr != RepeatersDelayList.end(); ++itr)
+	{
+		if (!itr->a_RelBlockPos.Equals(Vector3i(RelX, a_BlockY, RelZ)))
+		{
+			continue;
+		}
+
+		if ((Block != E_BLOCK_REDSTONE_REPEATER_ON) && (Block != E_BLOCK_REDSTONE_REPEATER_OFF))
+		{
+			RepeatersDelayList.erase(itr);
+			break;
+		}
+	}
+
+	if (a_OtherChunk != NULL)
+	{
+		// DO NOT touch our chunk's data structure if we are being called with coordinates from another chunk - this one caused me massive grief :P
+		return;
+	}
+
+	cCoordWithBlockAndBoolVector & RedstoneSimulatorChunkData = ((cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::cIncrementalRedstoneSimulatorChunkData *)a_Chunk->GetRedstoneSimulatorData())->m_ChunkData;
+	for (cCoordWithBlockAndBoolVector::iterator itr = RedstoneSimulatorChunkData.begin(); itr != RedstoneSimulatorChunkData.end(); ++itr)
+	{
+		if ((itr->x == RelX) && (itr->y == a_BlockY) && (itr->z == RelZ))  // We are at an entry matching the current (changed) block
+		{
+			if (!IsAllowedBlock(Block))
+			{
+				itr->DataTwo = true;  // The new blocktype is not redstone; it must be queued to be removed from this list
+			}
+			else
+			{
+				itr->DataTwo = false;
+				itr->Data = Block;  // Update block information
+			}
+			return;
+		}
+	}
+
+	if (!IsAllowedBlock(Block))
+	{
+		return;
+	}
+	
+	cCoordWithBlockAndBoolVector & QueuedData = ((cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::cIncrementalRedstoneSimulatorChunkData *)a_Chunk->GetRedstoneSimulatorData())->m_QueuedChunkData;
+	for (cCoordWithBlockAndBoolVector::iterator itr = QueuedData.begin(); itr != QueuedData.end(); ++itr)
+	{
+		if ((itr->x == RelX) && (itr->y == a_BlockY) && (itr->z == RelZ))
+		{
+			// Can't have duplicates in here either, in case something adds the block again before the structure can written to the main chunk data
+			return;
+		}
+	}
+	QueuedData.push_back(cCoordWithBlockAndBool(RelX, a_BlockY, RelZ, Block, false));
+}
+
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+void cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::SimulateChunk(float a_Dt, int a_ChunkX, int a_ChunkZ, ChunkType * a_Chunk)
+{
+	m_RedstoneSimulatorChunkData = (cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::cIncrementalRedstoneSimulatorChunkData *)a_Chunk->GetRedstoneSimulatorData();
+	if (m_RedstoneSimulatorChunkData->m_ChunkData.empty() && ((cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::cIncrementalRedstoneSimulatorChunkData *)a_Chunk->GetRedstoneSimulatorData())->m_QueuedChunkData.empty())
+	{
+		return;
+	}
+
+	m_RedstoneSimulatorChunkData->m_ChunkData.insert(
+		m_RedstoneSimulatorChunkData->m_ChunkData.end(), 
+		m_RedstoneSimulatorChunkData ->m_QueuedChunkData.begin(), 
+		m_RedstoneSimulatorChunkData ->m_QueuedChunkData.end());
+		
+	m_RedstoneSimulatorChunkData->m_QueuedChunkData.clear();
+
+	m_PoweredBlocks = &m_RedstoneSimulatorChunkData->m_PoweredBlocks;
+	m_RepeatersDelayList = &m_RedstoneSimulatorChunkData->m_RepeatersDelayList;
+	m_SimulatedPlayerToggleableBlocks = &m_RedstoneSimulatorChunkData->m_SimulatedPlayerToggleableBlocks;
+	m_LinkedPoweredBlocks = &m_RedstoneSimulatorChunkData->m_LinkedBlocks;
+	m_Chunk = a_Chunk;
+	bool ShouldUpdateSimulateOnceBlocks = false;
+
+	if (a_Chunk->IsRedstoneDirty())
+	{
+		// Simulate the majority of devices only if something (blockwise or power-wise) has changed
+		// Make sure to allow the chunk to resimulate after the initial run if there was a power change (ShouldUpdateSimulateOnceBlocks helps to do this)
+		a_Chunk->SetIsRedstoneDirty(false);
+		ShouldUpdateSimulateOnceBlocks = true;
+	}
+
+	HandleRedstoneRepeaterDelays();
+
+	for (cCoordWithBlockAndBoolVector::iterator dataitr = m_RedstoneSimulatorChunkData->m_ChunkData.begin(); dataitr != m_RedstoneSimulatorChunkData->m_ChunkData.end();)
+	{
+		if (dataitr->DataTwo)
+		{
+			dataitr = m_RedstoneSimulatorChunkData->m_ChunkData.erase(dataitr);
+			continue;
+		}
+
+		switch (dataitr->Data)
+		{
+			case E_BLOCK_DAYLIGHT_SENSOR: HandleDaylightSensor(dataitr->x, dataitr->y, dataitr->z); break;
+			case E_BLOCK_TRIPWIRE:        HandleTripwire(dataitr->x, dataitr->y, dataitr->z);       break;
+			case E_BLOCK_TRIPWIRE_HOOK:   HandleTripwireHook(dataitr->x, dataitr->y, dataitr->z);   break;
+
+			case E_BLOCK_WOODEN_PRESSURE_PLATE:
+			case E_BLOCK_STONE_PRESSURE_PLATE:
+			case E_BLOCK_LIGHT_WEIGHTED_PRESSURE_PLATE:
+			case E_BLOCK_HEAVY_WEIGHTED_PRESSURE_PLATE:
+			{
+				HandlePressurePlate(dataitr->x, dataitr->y, dataitr->z, dataitr->Data);
+				break;
+			}
+			default: break;
+		}
+
+		if (ShouldUpdateSimulateOnceBlocks)
+		{
+			switch (dataitr->Data)
+			{
+				case E_BLOCK_REDSTONE_WIRE:         HandleRedstoneWire(dataitr->x, dataitr->y, dataitr->z);	  break;
+				case E_BLOCK_COMMAND_BLOCK:         HandleCommandBlock(dataitr->x, dataitr->y, dataitr->z);   break;
+				case E_BLOCK_NOTE_BLOCK:            HandleNoteBlock(dataitr->x, dataitr->y, dataitr->z);      break;
+				case E_BLOCK_BLOCK_OF_REDSTONE:     HandleRedstoneBlock(dataitr->x, dataitr->y, dataitr->z);  break;
+				case E_BLOCK_LEVER:                 HandleRedstoneLever(dataitr->x, dataitr->y, dataitr->z);  break;
+				case E_BLOCK_TNT:                   HandleTNT(dataitr->x, dataitr->y, dataitr->z);            break;
+				case E_BLOCK_IRON_TRAPDOOR:         HandleTrapdoor(dataitr->x, dataitr->y, dataitr->z);       break;
+				case E_BLOCK_TRAPDOOR:              HandleTrapdoor(dataitr->x, dataitr->y, dataitr->z);       break;
+				case E_BLOCK_TRAPPED_CHEST:         HandleTrappedChest(dataitr->x, dataitr->y, dataitr->z);   break;
+
+				case E_BLOCK_ACTIVATOR_RAIL:
+				case E_BLOCK_DETECTOR_RAIL:
+				case E_BLOCK_POWERED_RAIL:
+				{
+					HandleRail(dataitr->x, dataitr->y, dataitr->z, dataitr->Data);
+					break;
+				}
+				case E_BLOCK_ACACIA_DOOR:
+				case E_BLOCK_BIRCH_DOOR:
+				case E_BLOCK_DARK_OAK_DOOR:
+				case E_BLOCK_JUNGLE_DOOR:
+				case E_BLOCK_SPRUCE_DOOR:
+				case E_BLOCK_WOODEN_DOOR:
+				case E_BLOCK_IRON_DOOR:
+				{
+					HandleDoor(dataitr->x, dataitr->y, dataitr->z);
+					break;
+				}
+				case E_BLOCK_ACACIA_FENCE_GATE:
+				case E_BLOCK_BIRCH_FENCE_GATE:
+				case E_BLOCK_DARK_OAK_FENCE_GATE:
+				case E_BLOCK_FENCE_GATE:
+				case E_BLOCK_JUNGLE_FENCE_GATE:
+				case E_BLOCK_SPRUCE_FENCE_GATE:
+				{
+					HandleFenceGate(dataitr->x, dataitr->y, dataitr->z);
+					break;
+				}
+				case E_BLOCK_REDSTONE_LAMP_OFF:
+				case E_BLOCK_REDSTONE_LAMP_ON:
+				{
+					HandleRedstoneLamp(dataitr->x, dataitr->y, dataitr->z, dataitr->Data);
+					break;
+				}
+				case E_BLOCK_DISPENSER:
+				case E_BLOCK_DROPPER:
+				{
+					HandleDropSpenser(dataitr->x, dataitr->y, dataitr->z);
+					break;
+				}
+				case E_BLOCK_PISTON:
+				case E_BLOCK_STICKY_PISTON:
+				{
+					HandlePiston(dataitr->x, dataitr->y, dataitr->z);
+					break;
+				}
+				case E_BLOCK_REDSTONE_REPEATER_OFF:
+				case E_BLOCK_REDSTONE_REPEATER_ON:
+				{
+					HandleRedstoneRepeater(dataitr->x, dataitr->y, dataitr->z, dataitr->Data);
+					break;
+				}
+				case E_BLOCK_REDSTONE_TORCH_OFF:
+				case E_BLOCK_REDSTONE_TORCH_ON:
+				{
+					HandleRedstoneTorch(dataitr->x, dataitr->y, dataitr->z, dataitr->Data);
+					break;
+				}
+				case E_BLOCK_STONE_BUTTON:
+				case E_BLOCK_WOODEN_BUTTON:
+				{
+					HandleRedstoneButton(dataitr->x, dataitr->y, dataitr->z);
+					break;
+				}
+				default: break;
+			}
+		}
+		++dataitr;
+	}
+}
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+void cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::WakeUp(int a_BlockX, int a_BlockY, int a_BlockZ, ChunkType * a_Chunk)
+{
+	if (AreCoordsOnChunkBoundary(a_BlockX, a_BlockY, a_BlockZ))
+	{
+		// On a chunk boundary, alert all four sides (i.e. at least one neighbouring chunk)
+		AddBlock(a_BlockX, a_BlockY, a_BlockZ, a_Chunk);
+
+		// Pass the original coordinates, because when adding things to our simulator lists, we get the chunk that they are in, and therefore any updates need to preseve their position
+		// RedstoneAddBlock to pass both the neighbouring chunk and the chunk which the coordinates are in and +- 2 in GetNeighbour() to accomodate for LinkedPowered blocks being 2 away from chunk boundaries
+		RedstoneAddBlock(a_BlockX, a_BlockY, a_BlockZ, a_Chunk->GetNeighborChunk(a_BlockX - 2, a_BlockZ), a_Chunk);
+		RedstoneAddBlock(a_BlockX, a_BlockY, a_BlockZ, a_Chunk->GetNeighborChunk(a_BlockX + 2, a_BlockZ), a_Chunk);
+		RedstoneAddBlock(a_BlockX, a_BlockY, a_BlockZ, a_Chunk->GetNeighborChunk(a_BlockX, a_BlockZ - 2), a_Chunk);
+		RedstoneAddBlock(a_BlockX, a_BlockY, a_BlockZ, a_Chunk->GetNeighborChunk(a_BlockX, a_BlockZ + 2), a_Chunk);
+
+		return;
+	}
+
+	// Not on boundary, just alert this chunk for speed
+	AddBlock(a_BlockX, a_BlockY, a_BlockZ, a_Chunk);
+}
+
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+void cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::HandleRedstoneTorch(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, BLOCKTYPE a_MyState)
+{
+	static const struct  // Define which directions the torch can power
+	{
+		int x, y, z;
+	} gCrossCoords[] =
+	{
+		{ 1, 0,  0},
+		{-1, 0,  0},
+		{ 0, 0,  1},
+		{ 0, 0, -1},
+		{ 0, 1,  0},
+	} ;
+
+	if (a_MyState == E_BLOCK_REDSTONE_TORCH_ON)
+	{
+		// Check if the block the torch is on is powered
+		int X = a_RelBlockX; int Y = a_RelBlockY; int Z = a_RelBlockZ;
+		AddFaceDirection(X, Y, Z, GetHandlerCompileTime<E_BLOCK_TORCH>::type::MetaDataToDirection(m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ)), true);  // Inverse true to get the block torch is on
+
+		ChunkType * Neighbour = m_Chunk->GetRelNeighborChunk(X, Z);
+		if ((Neighbour == NULL) || !Neighbour->IsValid())
+		{
+			return;
+		}
+
+		if (AreCoordsDirectlyPowered(X, Y, Z, Neighbour))
+		{
+			// There was a match, torch goes off
+			m_Chunk->SetBlock(a_RelBlockX, a_RelBlockY, a_RelBlockZ, E_BLOCK_REDSTONE_TORCH_OFF, m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ));
+			return;
+		}
+
+		// Torch still on, make all 4(X, Z) + 1(Y) sides powered
+		for (size_t i = 0; i < ARRAYCOUNT(gCrossCoords); i++)
+		{
+			BLOCKTYPE Type = 0;
+			if (!m_Chunk->UnboundedRelGetBlockType(a_RelBlockX + gCrossCoords[i].x, a_RelBlockY + gCrossCoords[i].y, a_RelBlockZ + gCrossCoords[i].z, Type))
+			{
+				continue;
+			}
+			if (i + 1 < ARRAYCOUNT(gCrossCoords))  // Sides of torch, not top (top is last)
+			{
+				if (
+					IsMechanism(Type) &&  // Is it a mechanism? Not block/other torch etc.
+					(!Vector3i(a_RelBlockX + gCrossCoords[i].x, a_RelBlockY + gCrossCoords[i].y, a_RelBlockZ + gCrossCoords[i].z).Equals(Vector3i(X, Y, Z)))  // CAN'T power block is that it is on
+					)
+				{
+					SetBlockPowered(a_RelBlockX + gCrossCoords[i].x, a_RelBlockY + gCrossCoords[i].y, a_RelBlockZ + gCrossCoords[i].z, a_RelBlockX, a_RelBlockY, a_RelBlockZ);
+				}
+			}
+			else
+			{
+				// Top side, power whatever is there, including blocks
+				SetBlockPowered(a_RelBlockX + gCrossCoords[i].x, a_RelBlockY + gCrossCoords[i].y, a_RelBlockZ + gCrossCoords[i].z, a_RelBlockX, a_RelBlockY, a_RelBlockZ);
+				// Power all blocks surrounding block above torch
+				SetDirectionLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, BLOCK_FACE_YP);
+			}
+		}
+
+		if (m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ) != 0x5)  // Is torch standing on ground? If NOT (i.e. on wall), power block beneath
+		{
+			BLOCKTYPE Type = m_Chunk->GetBlock(a_RelBlockX, a_RelBlockY - 1, a_RelBlockZ);
+
+			if (IsMechanism(Type))  // Still can't make a normal block powered though!
+			{
+				SetBlockPowered(a_RelBlockX, a_RelBlockY - 1, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ);
+			}
+		}
+	}
+	else
+	{
+		// Check if the block the torch is on is powered
+		int X = a_RelBlockX; int Y = a_RelBlockY; int Z = a_RelBlockZ;
+		AddFaceDirection(X, Y, Z, GetHandlerCompileTime<E_BLOCK_TORCH>::type::MetaDataToDirection(m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ)), true);  // Inverse true to get the block torch is on
+		
+		ChunkType * Neighbour = m_Chunk->GetRelNeighborChunk(X, Z);
+		if ((Neighbour == NULL) || !Neighbour->IsValid())
+		{
+			return;
+		}
+		
+		// See if off state torch can be turned on again
+		if (AreCoordsDirectlyPowered(X, Y, Z, Neighbour))
+		{
+			return;  // Something matches, torch still powered
+		}
+
+		// Block torch on not powered, can be turned on again!
+		m_Chunk->SetBlock(a_RelBlockX, a_RelBlockY, a_RelBlockZ, E_BLOCK_REDSTONE_TORCH_ON, m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ));
+	}
+}
+
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+void cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::HandleRedstoneBlock(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
+{
+	SetAllDirsAsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ);
+	SetBlockPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ);  // Set self as powered
+}
+
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+void cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::HandleRedstoneLever(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
+{
+	NIBBLETYPE Meta = m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ);
+	if (IsLeverOn(Meta))
+	{
+		SetAllDirsAsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ);
+
+		eBlockFace Dir = GetHandlerCompileTime<E_BLOCK_LEVER>::type::BlockMetaDataToBlockFace(Meta);
+		
+		Dir = ReverseBlockFace(Dir);
+		
+		SetDirectionLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, Dir);
+	}
+}
+
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+void cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::HandleFenceGate(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
+{
+	int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX;
+	int BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ;
+	NIBBLETYPE MetaData = m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ);
+
+	if (AreCoordsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ))
+	{
+		if (!AreCoordsSimulated(a_RelBlockX, a_RelBlockY, a_RelBlockZ, true))
+		{
+			if ((MetaData & 0x4) == 0)
+			{
+				m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, MetaData | 0x4);
+				m_Chunk->BroadcastSoundParticleEffect(1003, BlockX, a_RelBlockY, BlockZ, 0);
+			}
+			SetPlayerToggleableBlockAsSimulated(a_RelBlockX, a_RelBlockY, a_RelBlockZ, true);
+		}
+	}
+	else
+	{
+		if (!AreCoordsSimulated(a_RelBlockX, a_RelBlockY, a_RelBlockZ, false))
+		{
+			if ((MetaData & 0x4) != 0)
+			{
+				m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, MetaData & ~0x04);
+				m_Chunk->BroadcastSoundParticleEffect(1003, BlockX, a_RelBlockY, BlockZ, 0);
+			}
+			SetPlayerToggleableBlockAsSimulated(a_RelBlockX, a_RelBlockY, a_RelBlockZ, false);
+		}
+	}
+}
+
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+void cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::HandleRedstoneButton(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
+{
+	NIBBLETYPE Meta = m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ);
+	if (IsButtonOn(Meta))
+	{
+		SetAllDirsAsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ);
+		
+		eBlockFace Dir = GetHandlerCompileTime<E_BLOCK_STONE_BUTTON>::type::BlockMetaDataToBlockFace(Meta);
+		Dir = ReverseBlockFace(Dir);
+		SetDirectionLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, Dir);
+	}
+}
+
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+void cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::HandleRedstoneWire(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
+{
+	static const struct  // Define which directions the wire can receive power from
+	{
+		int x, y, z;
+	} gCrossCoords[] =
+	{
+		{ 1, 0,  0}, /* Wires on same level start */
+		{-1, 0,  0},
+		{ 0, 0,  1},
+		{ 0, 0, -1}, /* Wires on same level stop */
+		{ 1, 1,  0}, /* Wires one higher, surrounding self start */
+		{-1, 1,  0},
+		{ 0, 1,  1},
+		{ 0, 1, -1}, /* Wires one higher, surrounding self stop */
+		{ 1, -1,  0}, /* Wires one lower, surrounding self start */
+		{-1, -1,  0},
+		{ 0, -1,  1},
+		{ 0, -1, -1}, /* Wires one lower, surrounding self stop */
+	} ;
+
+	static const struct  // Define which directions the wire will check for repeater prescence
+	{
+		int x, y, z;
+	} gSideCoords[] =
+	{
+		{ 1, 0, 0 },
+		{-1, 0, 0 },
+		{ 0, 0, 1 },
+		{ 0, 0, -1 },
+		{ 0, 1, 0 },
+	};
+
+	// Check to see if directly beside a power source
+	unsigned char MyPower;
+	if (!IsWirePowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, MyPower))
+	{
+		int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX;
+		int BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ;
+		m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, 0);
+		this->m_World.WakeUpSimulators(BlockX, a_RelBlockY, BlockZ);
+		return;
+	}
+	
+	m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, MyPower);
+
+	if (MyPower < 1)
+	{
+		return;
+	}
+
+	MyPower--;
+
+	for (size_t i = 0; i < ARRAYCOUNT(gCrossCoords); i++)  // Loop through all directions to transfer or receive power
+	{
+		if ((i >= 4) && (i <= 7))  // If we are currently checking for wire surrounding ourself one block above...
+		{
+			BLOCKTYPE Type = 0;
+			if (a_RelBlockY + 1 >= cChunkDef::Height)
+			{
+				continue;
+			}
+			if (!m_Chunk->UnboundedRelGetBlockType(a_RelBlockX, a_RelBlockY + 1, a_RelBlockZ, Type))
+			{
+				continue;
+			}
+			if (cBlockInfo::IsSolid(Type))  // If there is something solid above us (wire cut off)...
+			{
+				continue;  // We don't receive power from that wire
+			}
+		}
+		else if ((i >= 8) && (i <= 11))  // See above, but this is for wire below us
+		{
+			BLOCKTYPE Type = 0;
+			if (!m_Chunk->UnboundedRelGetBlockType(a_RelBlockX + gCrossCoords[i].x, a_RelBlockY, a_RelBlockZ + gCrossCoords[i].z, Type))
+			{
+				continue;
+			}
+			if (cBlockInfo::IsSolid(Type))
+			{
+				continue;
+			}
+		}
+
+		BLOCKTYPE Type = 0;
+		if (!m_Chunk->UnboundedRelGetBlockType(a_RelBlockX + gCrossCoords[i].x, a_RelBlockY + gCrossCoords[i].y, a_RelBlockZ + gCrossCoords[i].z, Type))
+		{
+			continue;
+		}
+		if (Type == E_BLOCK_REDSTONE_WIRE)
+		{
+			SetBlockPowered(a_RelBlockX + gCrossCoords[i].x, a_RelBlockY + gCrossCoords[i].y, a_RelBlockZ + gCrossCoords[i].z, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MyPower);
+		}
+	}
+
+	for (size_t i = 0; i < ARRAYCOUNT(gSideCoords); i++)  // Look for repeaters immediately surrounding self and try to power them
+	{
+		BLOCKTYPE Type = 0;
+		if (!m_Chunk->UnboundedRelGetBlockType(a_RelBlockX + gSideCoords[i].x, a_RelBlockY + gSideCoords[i].y, a_RelBlockZ + gSideCoords[i].z, Type))
+		{
+			continue;
+		}
+		if (Type == E_BLOCK_REDSTONE_REPEATER_OFF)
+		{
+			SetBlockPowered(a_RelBlockX + gSideCoords[i].x, a_RelBlockY + gSideCoords[i].y, a_RelBlockZ + gSideCoords[i].z, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MyPower);
+		}
+	}
+
+	// Wire still powered, power blocks beneath
+	SetBlockPowered(a_RelBlockX, a_RelBlockY - 1, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MyPower);
+	SetDirectionLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, BLOCK_FACE_YM, MyPower);
+
+	switch (GetWireDirection(a_RelBlockX, a_RelBlockY, a_RelBlockZ))
+	{
+		case REDSTONE_NONE:
+		{
+			SetBlockPowered(a_RelBlockX + 1, a_RelBlockY, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MyPower);
+			SetBlockPowered(a_RelBlockX - 1, a_RelBlockY, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MyPower);
+			SetBlockPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ + 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MyPower);
+			SetBlockPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ - 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MyPower);
+
+			SetDirectionLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, BLOCK_FACE_XM, MyPower);
+			SetDirectionLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, BLOCK_FACE_XP, MyPower);
+			SetDirectionLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, BLOCK_FACE_ZM, MyPower);
+			SetDirectionLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, BLOCK_FACE_ZP, MyPower);
+			break;
+		}
+		case REDSTONE_X_POS:
+		{
+			SetBlockPowered(a_RelBlockX + 1, a_RelBlockY, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MyPower);
+			SetDirectionLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, BLOCK_FACE_XP, MyPower);
+			break;
+		}
+		case REDSTONE_X_NEG:
+		{
+			SetBlockPowered(a_RelBlockX - 1, a_RelBlockY, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MyPower);
+			SetDirectionLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, BLOCK_FACE_XM, MyPower);
+			break;
+		}
+		case REDSTONE_Z_POS:
+		{
+			SetBlockPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ + 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MyPower);
+			SetDirectionLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, BLOCK_FACE_ZP, MyPower);
+			break;
+		}
+		case REDSTONE_Z_NEG:
+		{
+			SetBlockPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ - 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MyPower);
+			SetDirectionLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, BLOCK_FACE_ZM, MyPower);
+			break;
+		}
+	}
+}
+
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+void cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::HandleRedstoneRepeater(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, BLOCKTYPE a_MyState)
+{
+	/* Repeater Orientation Mini Guide:
+	===================================
+
+	|
+	| Z Axis
+	V
+
+	X Axis ---->
+
+	Repeater directions, values from a WorldType::GetBlockMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ) lookup:
+
+	East (Right) (X+): 0x1
+	West (Left) (X-): 0x3
+	North (Up) (Z-): 0x2
+	South (Down) (Z+): 0x0
+	// TODO: Add E_META_XXX enum entries for all meta values and update project with them
+
+	Sun rises from East (X+)
+
+	*/
+
+	// Create a variable holding my meta to avoid multiple lookups.
+	NIBBLETYPE a_Meta = m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ);
+	bool IsOn = (a_MyState == E_BLOCK_REDSTONE_REPEATER_ON);
+
+	if (!IsRepeaterLocked(a_RelBlockX, a_RelBlockY, a_RelBlockZ, a_Meta))  // If we're locked, change nothing. Otherwise:
+	{
+		bool IsSelfPowered = IsRepeaterPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, a_Meta);
+		if (IsSelfPowered && !IsOn)  // Queue a power change if powered, but not on and not locked.
+		{
+			QueueRepeaterPowerChange(a_RelBlockX, a_RelBlockY, a_RelBlockZ, a_Meta, true);
+		}
+		else if (!IsSelfPowered && IsOn)  // Queue a power change if unpowered, on, and not locked.
+		{
+			QueueRepeaterPowerChange(a_RelBlockX, a_RelBlockY, a_RelBlockZ, a_Meta, false);
+		}
+	}
+}
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+void cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::HandleRedstoneRepeaterDelays()
+{
+	for (typename RepeatersDelayList::iterator itr = m_RepeatersDelayList->begin(); itr != m_RepeatersDelayList->end();)
+	{
+		if (itr->a_ElapsedTicks >= itr->a_DelayTicks)  // Has the elapsed ticks reached the target ticks?
+		{
+			int RelBlockX = itr->a_RelBlockPos.x;
+			int RelBlockY = itr->a_RelBlockPos.y;
+			int RelBlockZ = itr->a_RelBlockPos.z;
+			BLOCKTYPE Block;
+			NIBBLETYPE Meta;
+			m_Chunk->GetBlockTypeMeta(RelBlockX, RelBlockY, RelBlockZ, Block, Meta);
+			if (itr->ShouldPowerOn)
+			{
+				if (Block != E_BLOCK_REDSTONE_REPEATER_ON)  // For performance
+				{
+					m_Chunk->SetBlock(itr->a_RelBlockPos, E_BLOCK_REDSTONE_REPEATER_ON, Meta);
+				}
+
+				switch (Meta & 0x3)  // We only want the direction (bottom) bits
+				{
+					case 0x0:
+					{
+						SetBlockPowered(RelBlockX, RelBlockY, RelBlockZ - 1, RelBlockX, RelBlockY, RelBlockZ);
+						SetDirectionLinkedPowered(RelBlockX, RelBlockY, RelBlockZ, BLOCK_FACE_ZM);
+						break;
+					}
+					case 0x1:
+					{
+						SetBlockPowered(RelBlockX + 1, RelBlockY, RelBlockZ, RelBlockX, RelBlockY, RelBlockZ);
+						SetDirectionLinkedPowered(RelBlockX, RelBlockY, RelBlockZ, BLOCK_FACE_XP);
+						break;
+					}
+					case 0x2:
+					{
+						SetBlockPowered(RelBlockX, RelBlockY, RelBlockZ + 1, RelBlockX, RelBlockY, RelBlockZ);
+						SetDirectionLinkedPowered(RelBlockX, RelBlockY, RelBlockZ, BLOCK_FACE_ZP);
+						break;
+					}
+					case 0x3:
+					{
+						SetBlockPowered(RelBlockX - 1, RelBlockY, RelBlockZ, RelBlockX, RelBlockY, RelBlockZ);
+						SetDirectionLinkedPowered(RelBlockX, RelBlockY, RelBlockZ, BLOCK_FACE_XM);
+						break;
+					}
+				}
+			}
+			else if (Block != E_BLOCK_REDSTONE_REPEATER_OFF)
+			{
+				m_Chunk->SetBlock(RelBlockX, RelBlockY, RelBlockZ, E_BLOCK_REDSTONE_REPEATER_OFF, Meta);
+			}
+			itr = m_RepeatersDelayList->erase(itr);
+		}
+		else
+		{
+			LOGD("Incremented a repeater @ {%i %i %i} | Elapsed ticks: %i | Target delay: %i", itr->a_RelBlockPos.x, itr->a_RelBlockPos.y, itr->a_RelBlockPos.z, itr->a_ElapsedTicks, itr->a_DelayTicks);
+			itr->a_ElapsedTicks++;
+			itr++;
+		}
+	}
+}
+
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+void cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::HandlePiston(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
+{
+	int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX;
+	int BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ;
+
+	if (IsPistonPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ) & 0x7))  // We only want the bottom three bits (4th controls extended-ness)
+	{
+		GetHandlerCompileTime<E_BLOCK_PISTON>::type::ExtendPiston(BlockX, a_RelBlockY, BlockZ, &this->m_World);
+	}
+	else
+	{
+		GetHandlerCompileTime<E_BLOCK_PISTON>::type::RetractPiston(BlockX, a_RelBlockY, BlockZ, &this->m_World);
+	}
+}
+
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+void cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::HandleDropSpenser(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
+{
+	class cSetPowerToDropSpenser :
+		public cRedstonePoweredCallback
+	{
+		bool m_IsPowered;
+	public:
+		cSetPowerToDropSpenser(bool a_IsPowered) : m_IsPowered(a_IsPowered) {}
+
+		virtual bool Item(cRedstonePoweredEntity * a_DropSpenser) override
+		{
+			a_DropSpenser->SetRedstonePower(m_IsPowered);
+			return false;
+		}
+	} DrSpSP (AreCoordsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ));
+
+	int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX;
+	int BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ;
+	m_Chunk->DoWithRedstonePoweredEntityAt(BlockX, a_RelBlockY, BlockZ, DrSpSP);
+}
+
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+void cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::HandleRedstoneLamp(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, BLOCKTYPE a_MyState)
+{
+	if (a_MyState == E_BLOCK_REDSTONE_LAMP_OFF)
+	{
+		if (AreCoordsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ))
+		{
+			m_Chunk->SetBlock(a_RelBlockX, a_RelBlockY, a_RelBlockZ, E_BLOCK_REDSTONE_LAMP_ON, 0);
+		}
+	}
+	else
+	{
+		if (!AreCoordsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ))
+		{
+			m_Chunk->SetBlock(a_RelBlockX, a_RelBlockY, a_RelBlockZ, E_BLOCK_REDSTONE_LAMP_OFF, 0);
+		}
+	}
+}
+
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+void cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::HandleTNT(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
+{
+	int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX;
+	int BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ;
+
+	if (AreCoordsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ))
+	{
+		m_Chunk->BroadcastSoundEffect("game.tnt.primed", (double)BlockX, (double)a_RelBlockY, (double)BlockZ, 0.5f, 0.6f);
+		m_Chunk->SetBlock(a_RelBlockX, a_RelBlockY, a_RelBlockZ, E_BLOCK_AIR, 0);
+		this->m_World.SpawnPrimedTNT(BlockX + 0.5, a_RelBlockY + 0.5, BlockZ + 0.5);  // 80 ticks to boom
+	}
+}
+
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+void cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::HandleDoor(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
+{
+	int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX;
+	int BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ;
+
+	typedef typename GetHandlerCompileTime<E_BLOCK_WOODEN_DOOR>::type DoorHandler;
+			
+	if (AreCoordsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ))
+	{
+		if (!AreCoordsSimulated(a_RelBlockX, a_RelBlockY, a_RelBlockZ, true))
+		{
+			cChunkInterface ChunkInterface(this->m_World.GetChunkMap());
+			if (!DoorHandler::IsOpen(ChunkInterface, BlockX, a_RelBlockY, BlockZ))
+			{
+				DoorHandler::SetOpen(ChunkInterface, BlockX, a_RelBlockY, BlockZ, true);
+				m_Chunk->BroadcastSoundParticleEffect(1003, BlockX, a_RelBlockY, BlockZ, 0);
+			}
+			SetPlayerToggleableBlockAsSimulated(a_RelBlockX, a_RelBlockY, a_RelBlockZ, true);
+		}
+	}
+	else
+	{
+		if (!AreCoordsSimulated(a_RelBlockX, a_RelBlockY, a_RelBlockZ, false))
+		{
+			cChunkInterface ChunkInterface(this->m_World.GetChunkMap());
+			if (DoorHandler::IsOpen(ChunkInterface, BlockX, a_RelBlockY, BlockZ))
+			{
+				DoorHandler::SetOpen(ChunkInterface, BlockX, a_RelBlockY, BlockZ, false);
+				m_Chunk->BroadcastSoundParticleEffect(1003, BlockX, a_RelBlockY, BlockZ, 0);
+			}
+			SetPlayerToggleableBlockAsSimulated(a_RelBlockX, a_RelBlockY, a_RelBlockZ, false);
+		}
+	}
+}
+
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+void cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::HandleCommandBlock(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
+{
+	class cSetPowerToCommandBlock :
+		public cRedstonePoweredCallback
+	{
+		bool m_IsPowered;
+	public:
+		cSetPowerToCommandBlock(bool a_IsPowered) : m_IsPowered(a_IsPowered) {}
+
+		virtual bool Item(cRedstonePoweredEntity * a_CommandBlock) override
+		{
+			a_CommandBlock->SetRedstonePower(m_IsPowered);
+			return false;
+		}
+	} CmdBlockSP (AreCoordsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ));
+
+	int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX;
+	int BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ;
+	m_Chunk->DoWithRedstonePoweredEntityAt(BlockX, a_RelBlockY, BlockZ, CmdBlockSP);
+}
+
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+void cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::HandleRail(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, BLOCKTYPE a_MyType)
+{
+	switch (a_MyType)
+	{
+		case E_BLOCK_DETECTOR_RAIL:
+		{
+			if ((m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ) & 0x08) == 0x08)
+			{
+				SetAllDirsAsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, a_MyType);
+			}
+			break;
+		}
+		case E_BLOCK_ACTIVATOR_RAIL:
+		case E_BLOCK_POWERED_RAIL:
+		{
+			if (AreCoordsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ))
+			{
+				m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ) | 0x08);
+			}
+			else
+			{
+				m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ) & 0x07);
+			}
+			break;
+		}
+		default: LOGD("Unhandled type of rail in %s", __FUNCTION__);
+	}
+}
+
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+void cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::HandleTrapdoor(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
+{
+	int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX;
+	int BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ;
+
+	if (AreCoordsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ))
+	{
+		if (!AreCoordsSimulated(a_RelBlockX, a_RelBlockY, a_RelBlockZ, true))
+		{
+			this->m_World.SetTrapdoorOpen(BlockX, a_RelBlockY, BlockZ, true);
+			SetPlayerToggleableBlockAsSimulated(a_RelBlockX, a_RelBlockY, a_RelBlockZ, true);
+		}
+	}
+	else
+	{
+		if (!AreCoordsSimulated(a_RelBlockX, a_RelBlockY, a_RelBlockZ, false))
+		{
+			this->m_World.SetTrapdoorOpen(BlockX, a_RelBlockY, BlockZ, false);
+			SetPlayerToggleableBlockAsSimulated(a_RelBlockX, a_RelBlockY, a_RelBlockZ, false);
+		}
+	}
+}
+
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+void cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::HandleNoteBlock(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
+{
+	bool m_bAreCoordsPowered = AreCoordsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ);
+
+	if (m_bAreCoordsPowered)
+	{
+		if (!AreCoordsSimulated(a_RelBlockX, a_RelBlockY, a_RelBlockZ, true))
+		{
+			class cSetPowerToNoteBlock :
+				public cRedstonePoweredCallback
+			{
+			public:
+				cSetPowerToNoteBlock() {}
+
+				virtual bool Item(cRedstonePoweredEntity * a_NoteBlock) override
+				{
+					a_NoteBlock->SetRedstonePower(true);
+					return false;
+				}
+			} NoteBlockSP;
+
+			int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX;
+			int BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ;
+			m_Chunk->DoWithRedstonePoweredEntityAt(BlockX, a_RelBlockY, BlockZ, NoteBlockSP);
+			SetPlayerToggleableBlockAsSimulated(a_RelBlockX, a_RelBlockY, a_RelBlockZ, true);
+		}
+	}
+	else
+	{
+		if (!AreCoordsSimulated(a_RelBlockX, a_RelBlockY, a_RelBlockZ, false))
+		{
+			SetPlayerToggleableBlockAsSimulated(a_RelBlockX, a_RelBlockY, a_RelBlockZ, false);
+		}
+	}
+}
+
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+void cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::HandleDaylightSensor(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
+{
+	int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX, BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ;
+	int ChunkX, ChunkZ;
+	cChunkDef::BlockToChunk(BlockX, BlockZ, ChunkX, ChunkZ);
+
+	if (!this->m_World.IsChunkLighted(ChunkX, ChunkZ))
+	{
+		this->m_World.QueueLightChunk(ChunkX, ChunkZ);
+	}
+	else
+	{
+		if (m_Chunk->GetTimeAlteredLight(this->m_World.GetBlockSkyLight(BlockX, a_RelBlockY + 1, BlockZ)) > 8)
+		{
+			SetAllDirsAsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ);
+		}
+		else
+		{
+			WakeUp(BlockX, a_RelBlockY, BlockZ, m_Chunk);
+		}
+	}
+}
+
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+void cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::HandlePressurePlate(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, BLOCKTYPE a_MyType)
+{
+	int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX;
+	int BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ;
+
+	switch (a_MyType)
+	{
+		case E_BLOCK_STONE_PRESSURE_PLATE:
+		{
+			// MCS feature - stone pressure plates can only be triggered by players :D
+			cPlayer * a_Player = this->m_World.FindClosestPlayer(Vector3f(BlockX + 0.5f, (float)a_RelBlockY, BlockZ + 0.5f), 0.5f, false);
+
+			if (a_Player != NULL)
+			{
+				m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, 0x1);
+				SetAllDirsAsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ);
+				SetDirectionLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, BLOCK_FACE_YM, a_MyType);
+			}
+			else
+			{
+				m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, 0x0);
+				SetSourceUnpowered(BlockX, a_RelBlockY, BlockZ, m_Chunk);
+			}
+			break;
+		}
+		case E_BLOCK_LIGHT_WEIGHTED_PRESSURE_PLATE:
+		{
+			class cPressurePlateCallback :
+				public cEntityCallback
+			{
+			public:
+				cPressurePlateCallback(int a_BlockX, int a_BlockY, int a_BlockZ) :
+					m_NumberOfEntities(0),
+					m_X(a_BlockX),
+					m_Y(a_BlockY),
+					m_Z(a_BlockZ)
+				{
+				}
+
+				virtual bool Item(cEntity * a_Entity) override
+				{
+					Vector3f EntityPos = a_Entity->GetPosition();
+					Vector3f BlockPos(m_X + 0.5f, (float)m_Y, m_Z + 0.5f);
+					double Distance = (EntityPos - BlockPos).Length();
+
+					if (Distance <= 0.5)
+					{
+						m_NumberOfEntities++;
+					}
+					return false;
+				}
+
+				bool GetPowerLevel(unsigned char & a_PowerLevel) const
+				{
+					a_PowerLevel = std::min(m_NumberOfEntities, MAX_POWER_LEVEL);
+					return (a_PowerLevel > 0);
+				}
+
+			protected:
+				int m_NumberOfEntities;
+
+				int m_X;
+				int m_Y;
+				int m_Z;
+			};
+
+			cPressurePlateCallback PressurePlateCallback(BlockX, a_RelBlockY, BlockZ);
+			this->m_World.ForEachEntityInChunk(m_Chunk->GetPosX(), m_Chunk->GetPosZ(), PressurePlateCallback);
+
+			unsigned char Power;
+			NIBBLETYPE Meta = m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ);
+			if (PressurePlateCallback.GetPowerLevel(Power))
+			{
+				if (Meta == E_META_PRESSURE_PLATE_RAISED)
+				{
+					m_Chunk->BroadcastSoundEffect("random.click", (double)BlockX + 0.5, (double)a_RelBlockY + 0.1, (double)BlockZ + 0.5, 0.3F, 0.5F);
+				}
+				m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, E_META_PRESSURE_PLATE_DEPRESSED);
+				SetAllDirsAsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, Power);
+				SetDirectionLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, BLOCK_FACE_YM, a_MyType);
+			}
+			else
+			{
+				if (Meta == E_META_PRESSURE_PLATE_DEPRESSED)
+				{
+					m_Chunk->BroadcastSoundEffect("random.click", (double)BlockX + 0.5, (double)a_RelBlockY + 0.1, (double)BlockZ + 0.5, 0.3F, 0.6F);
+				}
+				m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, E_META_PRESSURE_PLATE_RAISED);
+				SetSourceUnpowered(BlockX, a_RelBlockY, BlockZ, m_Chunk);
+			}
+
+			break;
+		}
+		case E_BLOCK_HEAVY_WEIGHTED_PRESSURE_PLATE:
+		{
+			class cPressurePlateCallback :
+				public cEntityCallback
+			{
+			public:
+				cPressurePlateCallback(int a_BlockX, int a_BlockY, int a_BlockZ) :
+					m_NumberOfEntities(0),
+					m_X(a_BlockX),
+					m_Y(a_BlockY),
+					m_Z(a_BlockZ)
+				{
+				}
+
+				virtual bool Item(cEntity * a_Entity) override
+				{
+					Vector3f EntityPos = a_Entity->GetPosition();
+					Vector3f BlockPos(m_X + 0.5f, (float)m_Y, m_Z + 0.5f);
+					double Distance = (EntityPos - BlockPos).Length();
+
+					if (Distance <= 0.5)
+					{
+						m_NumberOfEntities++;
+					}
+					return false;
+				}
+
+				bool GetPowerLevel(unsigned char & a_PowerLevel) const
+				{
+					a_PowerLevel = std::min((int)ceil(m_NumberOfEntities / 10.f), MAX_POWER_LEVEL);
+					return (a_PowerLevel > 0);
+				}
+
+			protected:
+				int m_NumberOfEntities;
+
+				int m_X;
+				int m_Y;
+				int m_Z;
+			};
+
+			cPressurePlateCallback PressurePlateCallback(BlockX, a_RelBlockY, BlockZ);
+			this->m_World.ForEachEntityInChunk(m_Chunk->GetPosX(), m_Chunk->GetPosZ(), PressurePlateCallback);
+
+			unsigned char Power;
+			NIBBLETYPE Meta = m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ);
+			if (PressurePlateCallback.GetPowerLevel(Power))
+			{
+				if (Meta == E_META_PRESSURE_PLATE_RAISED)
+				{
+					m_Chunk->BroadcastSoundEffect("random.click", (double)BlockX + 0.5, (double)a_RelBlockY + 0.1, (double)BlockZ + 0.5, 0.3F, 0.5F);
+				}
+				m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, E_META_PRESSURE_PLATE_DEPRESSED);
+				SetAllDirsAsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, Power);
+				SetDirectionLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, BLOCK_FACE_YM, a_MyType);
+			}
+			else
+			{
+				if (Meta == E_META_PRESSURE_PLATE_DEPRESSED)
+				{
+					m_Chunk->BroadcastSoundEffect("random.click", (double)BlockX + 0.5, (double)a_RelBlockY + 0.1, (double)BlockZ + 0.5, 0.3F, 0.6F);
+				}
+				m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, E_META_PRESSURE_PLATE_RAISED);
+				SetSourceUnpowered(BlockX, a_RelBlockY, BlockZ, m_Chunk);
+			}
+
+			break;
+		}
+		case E_BLOCK_WOODEN_PRESSURE_PLATE:
+		{
+			class cPressurePlateCallback :
+				public cEntityCallback
+			{
+			public:
+				cPressurePlateCallback(int a_BlockX, int a_BlockY, int a_BlockZ) :
+					m_FoundEntity(false),
+					m_X(a_BlockX),
+					m_Y(a_BlockY),
+					m_Z(a_BlockZ)
+				{
+				}
+
+				virtual bool Item(cEntity * a_Entity) override
+				{
+					Vector3f EntityPos = a_Entity->GetPosition();
+					Vector3f BlockPos(m_X + 0.5f, (float)m_Y, m_Z + 0.5f);
+					double Distance = (EntityPos - BlockPos).Length();
+
+					if (Distance <= 0.5)
+					{
+						m_FoundEntity = true;
+						return true;  // Break out, we only need to know for plates that at least one entity is on top
+					}
+					return false;
+				}
+
+				bool FoundEntity(void) const
+				{
+					return m_FoundEntity;
+				}
+
+			protected:
+				bool m_FoundEntity;
+
+				int m_X;
+				int m_Y;
+				int m_Z;
+			} ;
+
+			cPressurePlateCallback PressurePlateCallback(BlockX, a_RelBlockY, BlockZ);
+			this->m_World.ForEachEntityInChunk(m_Chunk->GetPosX(), m_Chunk->GetPosZ(), PressurePlateCallback);
+
+			NIBBLETYPE Meta = m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ);
+			if (PressurePlateCallback.FoundEntity())
+			{
+				if (Meta == E_META_PRESSURE_PLATE_RAISED)
+				{
+					m_Chunk->BroadcastSoundEffect("random.click", (double)BlockX + 0.5, (double)a_RelBlockY + 0.1, (double)BlockZ + 0.5, 0.3F, 0.5F);
+				}
+				m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, E_META_PRESSURE_PLATE_DEPRESSED);
+				SetAllDirsAsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ);
+				SetDirectionLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, BLOCK_FACE_YM, a_MyType);
+			}
+			else
+			{
+				if (Meta == E_META_PRESSURE_PLATE_DEPRESSED)
+				{
+					m_Chunk->BroadcastSoundEffect("random.click", (double)BlockX + 0.5, (double)a_RelBlockY + 0.1, (double)BlockZ + 0.5, 0.3F, 0.6F);
+				}
+				m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, E_META_PRESSURE_PLATE_RAISED);
+				SetSourceUnpowered(BlockX, a_RelBlockY, BlockZ, m_Chunk);
+			}
+			break;
+		}
+		default:
+		{
+			LOGD("Unimplemented pressure plate type %s in cRedstoneSimulator", ItemToFullString(cItem(a_MyType)).c_str());
+			break;
+		}
+	}
+}
+
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+void cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::HandleTripwireHook(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
+{
+	int BlockX = m_Chunk->GetPosX() * cChunkDef::Width + a_RelBlockX;
+	int BlockZ = m_Chunk->GetPosZ() * cChunkDef::Width + a_RelBlockZ;
+	int RelX = a_RelBlockX, RelZ = a_RelBlockZ;
+	bool FoundActivated = false;
+	eBlockFace FaceToGoTowards = GetHandlerCompileTime<E_BLOCK_TRIPWIRE_HOOK>::type::MetadataToDirection(m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ));
+
+	for (int i = 0; i < 40; ++i)  // Tripwires can be connected up to 40 blocks
+	{
+		BLOCKTYPE Type;
+		NIBBLETYPE Meta;
+
+		AddFaceDirection(RelX, a_RelBlockY, RelZ, FaceToGoTowards);
+		m_Chunk->UnboundedRelGetBlock(RelX, a_RelBlockY, RelZ, Type, Meta);
+
+		if (Type == E_BLOCK_TRIPWIRE)
+		{
+			if (Meta == 0x1)
+			{
+				FoundActivated = true;
+			}
+		}
+		else if (Type == E_BLOCK_TRIPWIRE_HOOK)
+		{
+			if (ReverseBlockFace( GetHandlerCompileTime<E_BLOCK_TRIPWIRE_HOOK>::type::MetadataToDirection(Meta)) == FaceToGoTowards)
+			{
+				// Other hook facing in opposite direction - circuit completed!
+				break;
+			}
+			else
+			{
+				// Tripwire hook not connected at all, AND away all the power state bits
+				m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ) & 0x3);
+				SetSourceUnpowered(BlockX, a_RelBlockY, BlockZ, m_Chunk);
+				return;
+			}
+		}
+		else
+		{
+			// Tripwire hook not connected at all, AND away all the power state bits
+			m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ) & 0x3);
+			SetSourceUnpowered(BlockX, a_RelBlockY, BlockZ, m_Chunk);
+			return;
+		}
+	}
+
+	if (FoundActivated)
+	{
+		// Connected and activated, set the 3rd and 4th highest bits
+		m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ) | 0xC);
+		SetAllDirsAsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ);
+	}
+	else
+	{
+		// Connected but not activated, AND away the highest bit
+		m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, (m_Chunk->GetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ) & 0x7) | 0x4);
+		SetSourceUnpowered(BlockX, a_RelBlockY, BlockZ, m_Chunk);
+	}
+}
+
+template <class ChestType>
+class cGetTrappedChestPlayers :
+	public cItemCallback<ChestType>
+{
+public:
+	cGetTrappedChestPlayers(void) :
+		m_NumberOfPlayers(0)
+	{
+	}
+
+	virtual ~cGetTrappedChestPlayers()
+	{
+	}
+
+	virtual bool Item(ChestType * a_Chest) override
+	{
+		ASSERT(a_Chest->GetBlockType() == E_BLOCK_TRAPPED_CHEST);
+		m_NumberOfPlayers = a_Chest->GetNumberOfPlayers();
+		return (m_NumberOfPlayers <= 0);
+	}
+
+	unsigned char GetPowerLevel(void) const
+	{
+		return std::min(m_NumberOfPlayers, MAX_POWER_LEVEL);
+	}
+
+private:
+	int m_NumberOfPlayers;
+
+};
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+void cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::HandleTrappedChest(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
+{
+	cGetTrappedChestPlayers<ChestType> GTCP;
+
+	int BlockX = m_Chunk->GetPosX() * cChunkDef::Width + a_RelBlockX;
+	int BlockZ = m_Chunk->GetPosZ() * cChunkDef::Width + a_RelBlockZ;
+	if (m_Chunk->DoWithChestAt(BlockX, a_RelBlockY, BlockZ, GTCP))
+	{
+		SetAllDirsAsPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ, GTCP.GetPowerLevel());
+	}
+	else
+	{
+		SetSourceUnpowered(BlockX, a_RelBlockY, BlockZ, m_Chunk);
+	}
+}
+
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+void cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::HandleTripwire(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
+{
+	int BlockX = m_Chunk->GetPosX() * cChunkDef::Width + a_RelBlockX;
+	int BlockZ = m_Chunk->GetPosZ() * cChunkDef::Width + a_RelBlockZ;
+
+	class cTripwireCallback :
+		public cEntityCallback
+	{
+	public:
+		cTripwireCallback(int a_BlockX, int a_BlockY, int a_BlockZ) :
+			m_FoundEntity(false),
+			m_X(a_BlockX),
+			m_Y(a_BlockY),
+			m_Z(a_BlockZ)
+		{
+		}
+
+		virtual bool Item(cEntity * a_Entity) override
+		{
+			cBoundingBox bbWire(m_X, m_X + 1, m_Y, m_Y + 0.1, m_Z, m_Z + 1);
+			cBoundingBox bbEntity(a_Entity->GetPosition(), a_Entity->GetWidth() / 2, a_Entity->GetHeight());
+
+			if (bbEntity.DoesIntersect(bbWire))
+			{
+				m_FoundEntity = true;
+				return true;  // One entity is sufficient to trigger the wire
+			}
+			return false;
+		}
+
+		bool FoundEntity(void) const
+		{
+			return m_FoundEntity;
+		}
+
+	protected:
+		bool m_FoundEntity;
+
+		int m_X;
+		int m_Y;
+		int m_Z;
+	};
+
+	cTripwireCallback TripwireCallback(BlockX, a_RelBlockY, BlockZ);
+	this->m_World.ForEachEntityInChunk(m_Chunk->GetPosX(), m_Chunk->GetPosZ(), TripwireCallback);
+
+	if (TripwireCallback.FoundEntity())
+	{
+		m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, 0x1);
+	}
+	else
+	{
+		m_Chunk->SetMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, 0x0);
+	}
+}
+
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+bool cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::AreCoordsDirectlyPowered(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, ChunkType * a_Chunk)
+{
+	// Torches want to access neighbour's data when on a wall, hence the extra chunk parameter
+
+	int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX;
+	int BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ;
+
+	for (typename PoweredBlocksList::const_iterator itr = ((cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::cIncrementalRedstoneSimulatorChunkData *)a_Chunk->GetRedstoneSimulatorData())->m_PoweredBlocks.begin(); itr != ((cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::cIncrementalRedstoneSimulatorChunkData *)a_Chunk->GetRedstoneSimulatorData())->m_PoweredBlocks.end(); ++itr)  // Check powered list
+	{
+		if (itr->a_BlockPos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ)))
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+bool cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::AreCoordsLinkedPowered(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
+{
+	int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX;
+	int BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ;
+
+	for (typename LinkedBlocksList::const_iterator itr = m_LinkedPoweredBlocks->begin(); itr != m_LinkedPoweredBlocks->end(); ++itr)  // Check linked powered list
+	{
+		if (itr->a_BlockPos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ)))
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+bool cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::IsRepeaterPowered(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, NIBBLETYPE a_Meta)
+{
+	// Repeaters cannot be powered by any face except their back; verify that this is true for a source
+	int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX;
+	int BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ;
+
+	for (typename PoweredBlocksList::const_iterator itr = m_PoweredBlocks->begin(); itr != m_PoweredBlocks->end(); ++itr)
+	{
+		if (!itr->a_BlockPos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ))) { continue; }
+
+		switch (a_Meta & 0x3)
+		{
+			case 0x0:
+			{
+				// Flip the coords to check the back of the repeater
+				if (itr->a_SourcePos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ + 1))) { return true; }
+				break;
+			}
+			case 0x1:
+			{
+				if (itr->a_SourcePos.Equals(Vector3i(BlockX - 1, a_RelBlockY, BlockZ))) { return true; }
+				break;
+			}
+			case 0x2:
+			{
+				if (itr->a_SourcePos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ - 1))) { return true; }
+				break;
+			}
+			case 0x3:
+			{
+				if (itr->a_SourcePos.Equals(Vector3i(BlockX + 1, a_RelBlockY, BlockZ))) { return true; }
+				break;
+			}
+		}
+	}
+
+	for (typename LinkedBlocksList::const_iterator itr = m_LinkedPoweredBlocks->begin(); itr != m_LinkedPoweredBlocks->end(); ++itr)
+	{
+		if (!itr->a_BlockPos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ))) { continue; }
+
+		switch (a_Meta & 0x3)
+		{
+			case 0x0:
+			{
+				if (itr->a_MiddlePos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ + 1))) { return true; }
+				break;
+			}
+			case 0x1:
+			{
+				if (itr->a_MiddlePos.Equals(Vector3i(BlockX - 1, a_RelBlockY, BlockZ))) { return true; }
+				break;
+			}
+			case 0x2:
+			{
+				if (itr->a_MiddlePos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ - 1))) { return true; }
+				break;
+			}
+			case 0x3:
+			{
+				if (itr->a_MiddlePos.Equals(Vector3i(BlockX + 1, a_RelBlockY, BlockZ))) { return true; }
+				break;
+			}
+		}
+	}
+	return false;  // Couldn't find power source behind repeater
+}
+
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+bool cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::IsRepeaterLocked(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, NIBBLETYPE a_Meta)
+{
+	switch (a_Meta & 0x3)  // We only want the 'direction' part of our metadata
+	{
+		// If the repeater is looking up or down (If parallel to the Z axis)
+		case 0x0:
+		case 0x2:
+		{
+			// Check if eastern(right) neighbor is a powered on repeater who is facing us
+			BLOCKTYPE Block = 0;
+			NIBBLETYPE OtherRepeaterDir = 0;
+			if (m_Chunk->UnboundedRelGetBlock(a_RelBlockX + 1, a_RelBlockY, a_RelBlockZ, Block, OtherRepeaterDir) && (Block == E_BLOCK_REDSTONE_REPEATER_ON)) // Is right neighbor a powered repeater?
+			{
+				if ((OtherRepeaterDir & 0x03) == 0x3) 
+				{
+					return true;
+				}  // If so, I am latched/locked
+			}
+
+			// Check if western(left) neighbor is a powered on repeater who is facing us
+			if (m_Chunk->UnboundedRelGetBlock(a_RelBlockX - 1, a_RelBlockY, a_RelBlockZ, Block, OtherRepeaterDir) && (Block == E_BLOCK_REDSTONE_REPEATER_ON))
+			{
+				NIBBLETYPE OtherRepeaterDir = m_Chunk->GetMeta(a_RelBlockX -1, a_RelBlockY, a_RelBlockZ) & 0x3;
+				if ((OtherRepeaterDir & 0x03) == 0x1) 
+				{ 
+					return true; 
+				}  // If so, I am latched/locked
+			}
+
+			break;
+		}
+
+		// If the repeater is looking left or right (If parallel to the x axis)
+		case 0x1:
+		case 0x3:
+		{
+			// Check if southern(down) neighbor is a powered on repeater who is facing us
+			BLOCKTYPE Block = 0;
+			NIBBLETYPE OtherRepeaterDir = 0;
+			
+			if (m_Chunk->UnboundedRelGetBlock(a_RelBlockX, a_RelBlockY, a_RelBlockZ + 1, Block, OtherRepeaterDir) && (Block == E_BLOCK_REDSTONE_REPEATER_ON))
+			{
+				if ((OtherRepeaterDir & 0x30 ) == 0x00) 
+				{ 
+					return true; 
+				}  // If so,  am latched/locked
+			}
+			
+			// Check if northern(up) neighbor is a powered on repeater who is facing us
+			if (m_Chunk->UnboundedRelGetBlock(a_RelBlockX, a_RelBlockY, a_RelBlockZ - 1, Block, OtherRepeaterDir) && (Block == E_BLOCK_REDSTONE_REPEATER_ON))
+			{
+				if ((OtherRepeaterDir & 0x03) == 0x02)
+				{ 
+					return true;
+				}  // If so, I am latched/locked
+			}
+
+			break;
+		}
+	}
+
+	return false;  // None of the checks succeeded, I am not a locked repeater
+}
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+bool cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::IsPistonPowered(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, NIBBLETYPE a_Meta)
+{
+	// Pistons cannot be powered through their front face; this function verifies that a source meets this requirement
+
+	eBlockFace Face = GetHandlerCompileTime<E_BLOCK_PISTON>::type::MetaDataToDirection(a_Meta);
+	int BlockX = m_Chunk->GetPosX() * cChunkDef::Width + a_RelBlockX;
+	int BlockZ = m_Chunk->GetPosZ() * cChunkDef::Width + a_RelBlockZ;
+
+	for (typename PoweredBlocksList::const_iterator itr = m_PoweredBlocks->begin(); itr != m_PoweredBlocks->end(); ++itr)
+	{
+		if (!itr->a_BlockPos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ))) { continue; }
+
+		AddFaceDirection(BlockX, a_RelBlockY, BlockZ, Face);
+
+		if (!itr->a_SourcePos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ)))
+		{
+			return true;
+		}
+
+		AddFaceDirection(BlockX, a_RelBlockY, BlockZ, Face, true);
+	}
+
+	for (typename LinkedBlocksList::const_iterator itr = m_LinkedPoweredBlocks->begin(); itr != m_LinkedPoweredBlocks->end(); ++itr)
+	{
+		if (!itr->a_BlockPos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ))) { continue; }
+
+		AddFaceDirection(BlockX, a_RelBlockY, BlockZ, Face);
+
+		if (!itr->a_MiddlePos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ)))
+		{
+			return true;
+		}
+
+		AddFaceDirection(BlockX, a_RelBlockY, BlockZ, Face, true);
+	}
+	return false;  // Source was in front of the piston's front face
+}
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+bool cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::IsWirePowered(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, unsigned char & a_PowerLevel)
+{
+	a_PowerLevel = 0;
+	int BlockX = m_Chunk->GetPosX() * cChunkDef::Width + a_RelBlockX;
+	int BlockZ = m_Chunk->GetPosZ() * cChunkDef::Width + a_RelBlockZ;
+
+	for (typename PoweredBlocksList::const_iterator itr = m_PoweredBlocks->begin(); itr != m_PoweredBlocks->end(); ++itr)  // Check powered list
+	{
+		if (!itr->a_BlockPos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ)))
+		{
+			continue;
+		}
+		a_PowerLevel = std::max(itr->a_PowerLevel, a_PowerLevel);  // Get the highest power level (a_PowerLevel is initialised already and there CAN be multiple levels for one block)
+	}
+
+	for (typename LinkedBlocksList::const_iterator itr = m_LinkedPoweredBlocks->begin(); itr != m_LinkedPoweredBlocks->end(); ++itr)  // Check linked powered list
+	{
+		if (!itr->a_BlockPos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ)))
+		{
+			continue;
+		}
+
+		BLOCKTYPE Type = E_BLOCK_AIR;
+		int RelSourceX = itr->a_SourcePos.x - m_Chunk->GetPosX() * cChunkDef::Width;
+		int RelSourceZ = itr->a_SourcePos.z - m_Chunk->GetPosZ() * cChunkDef::Width;
+		if (!m_Chunk->UnboundedRelGetBlockType(RelSourceX, itr->a_SourcePos.y, RelSourceZ, Type) || (Type == E_BLOCK_REDSTONE_WIRE))
+		{
+			continue;
+		}
+		a_PowerLevel = std::max(itr->a_PowerLevel, a_PowerLevel);
+	}
+
+	return (a_PowerLevel != 0);  // Answer the inital question: is the wire powered?
+}
+
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+bool cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::AreCoordsSimulated(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, bool IsCurrentStatePowered)
+{
+	for (typename SimulatedPlayerToggleableList::const_iterator itr = m_SimulatedPlayerToggleableBlocks->begin(); itr != m_SimulatedPlayerToggleableBlocks->end(); ++itr)
+	{
+		if (itr->a_RelBlockPos.Equals(Vector3i(a_RelBlockX, a_RelBlockY, a_RelBlockZ)))
+		{
+			if (itr->WasLastStatePowered != IsCurrentStatePowered)  // Was the last power state different to the current?
+			{
+				return false;  // It was, coordinates are no longer simulated
+			}
+			else
+			{
+				return true;  // It wasn't, don't resimulate block, and allow players to toggle
+			}
+		}
+	}
+	return false;  // Block wasn't even in the list, not simulated
+}
+
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+void cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::SetDirectionLinkedPowered(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, char a_Direction, unsigned char a_PowerLevel)
+{
+	BLOCKTYPE MiddleBlock = 0;
+	switch (a_Direction)
+	{
+		case BLOCK_FACE_XM:
+		{
+			if (!m_Chunk->UnboundedRelGetBlockType(a_RelBlockX - 1, a_RelBlockY, a_RelBlockZ, MiddleBlock))
+			{
+				return;
+			}
+
+			SetBlockLinkedPowered(a_RelBlockX - 2, a_RelBlockY, a_RelBlockZ, a_RelBlockX - 1, a_RelBlockY, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
+			SetBlockLinkedPowered(a_RelBlockX - 1, a_RelBlockY + 1, a_RelBlockZ, a_RelBlockX - 1, a_RelBlockY, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
+			SetBlockLinkedPowered(a_RelBlockX - 1, a_RelBlockY - 1, a_RelBlockZ, a_RelBlockX - 1, a_RelBlockY, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
+			SetBlockLinkedPowered(a_RelBlockX - 1, a_RelBlockY, a_RelBlockZ + 1, a_RelBlockX - 1, a_RelBlockY, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
+			SetBlockLinkedPowered(a_RelBlockX - 1, a_RelBlockY, a_RelBlockZ - 1, a_RelBlockX - 1, a_RelBlockY, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
+
+			break;
+		}
+		case BLOCK_FACE_XP:
+		{
+			if (!m_Chunk->UnboundedRelGetBlockType(a_RelBlockX + 1, a_RelBlockY, a_RelBlockZ, MiddleBlock))
+			{
+				return;
+			}
+
+			SetBlockLinkedPowered(a_RelBlockX + 2, a_RelBlockY, a_RelBlockZ, a_RelBlockX + 1, a_RelBlockY, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
+			SetBlockLinkedPowered(a_RelBlockX + 1, a_RelBlockY + 1, a_RelBlockZ, a_RelBlockX + 1, a_RelBlockY, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
+			SetBlockLinkedPowered(a_RelBlockX + 1, a_RelBlockY - 1, a_RelBlockZ, a_RelBlockX + 1, a_RelBlockY, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
+			SetBlockLinkedPowered(a_RelBlockX + 1, a_RelBlockY, a_RelBlockZ + 1, a_RelBlockX + 1, a_RelBlockY, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
+			SetBlockLinkedPowered(a_RelBlockX + 1, a_RelBlockY, a_RelBlockZ - 1, a_RelBlockX + 1, a_RelBlockY, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
+
+			break;
+		}
+		case BLOCK_FACE_YM:
+		{
+			if (!m_Chunk->UnboundedRelGetBlockType(a_RelBlockX, a_RelBlockY - 1, a_RelBlockZ, MiddleBlock))
+			{
+				return;
+			}
+
+			SetBlockLinkedPowered(a_RelBlockX, a_RelBlockY - 2, a_RelBlockZ, a_RelBlockX, a_RelBlockY - 1, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
+			SetBlockLinkedPowered(a_RelBlockX + 1, a_RelBlockY - 1, a_RelBlockZ, a_RelBlockX, a_RelBlockY - 1, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
+			SetBlockLinkedPowered(a_RelBlockX - 1, a_RelBlockY - 1, a_RelBlockZ, a_RelBlockX, a_RelBlockY - 1, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
+			SetBlockLinkedPowered(a_RelBlockX, a_RelBlockY - 1, a_RelBlockZ + 1, a_RelBlockX, a_RelBlockY - 1, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
+			SetBlockLinkedPowered(a_RelBlockX, a_RelBlockY - 1, a_RelBlockZ - 1, a_RelBlockX, a_RelBlockY - 1, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
+
+			break;
+		}
+		case BLOCK_FACE_YP:
+		{
+			if (!m_Chunk->UnboundedRelGetBlockType(a_RelBlockX, a_RelBlockY + 1, a_RelBlockZ, MiddleBlock))
+			{
+				return;
+			}
+
+			SetBlockLinkedPowered(a_RelBlockX, a_RelBlockY + 2, a_RelBlockZ, a_RelBlockX, a_RelBlockY + 1, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
+			SetBlockLinkedPowered(a_RelBlockX + 1, a_RelBlockY + 1, a_RelBlockZ, a_RelBlockX, a_RelBlockY + 1, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
+			SetBlockLinkedPowered(a_RelBlockX - 1, a_RelBlockY + 1, a_RelBlockZ, a_RelBlockX, a_RelBlockY + 1, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
+			SetBlockLinkedPowered(a_RelBlockX, a_RelBlockY + 1, a_RelBlockZ + 1, a_RelBlockX, a_RelBlockY + 1, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
+			SetBlockLinkedPowered(a_RelBlockX, a_RelBlockY + 1, a_RelBlockZ - 1, a_RelBlockX, a_RelBlockY + 1, a_RelBlockZ, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
+
+			break;
+		}
+		case BLOCK_FACE_ZM:
+		{
+			if (!m_Chunk->UnboundedRelGetBlockType(a_RelBlockX, a_RelBlockY, a_RelBlockZ - 1, MiddleBlock))
+			{
+				return;
+			}
+
+			SetBlockLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ - 2, a_RelBlockX, a_RelBlockY, a_RelBlockZ - 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
+			SetBlockLinkedPowered(a_RelBlockX + 1, a_RelBlockY, a_RelBlockZ - 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ - 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
+			SetBlockLinkedPowered(a_RelBlockX - 1, a_RelBlockY, a_RelBlockZ - 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ - 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
+			SetBlockLinkedPowered(a_RelBlockX, a_RelBlockY + 1, a_RelBlockZ - 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ - 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
+			SetBlockLinkedPowered(a_RelBlockX, a_RelBlockY - 1, a_RelBlockZ - 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ - 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
+
+			break;
+		}
+		case BLOCK_FACE_ZP:
+		{
+			if (!m_Chunk->UnboundedRelGetBlockType(a_RelBlockX, a_RelBlockY, a_RelBlockZ + 1, MiddleBlock))
+			{
+				return;
+			}
+			
+			SetBlockLinkedPowered(a_RelBlockX, a_RelBlockY, a_RelBlockZ + 2, a_RelBlockX, a_RelBlockY, a_RelBlockZ + 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
+			SetBlockLinkedPowered(a_RelBlockX + 1, a_RelBlockY, a_RelBlockZ + 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ + 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
+			SetBlockLinkedPowered(a_RelBlockX - 1, a_RelBlockY, a_RelBlockZ + 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ + 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
+			SetBlockLinkedPowered(a_RelBlockX, a_RelBlockY + 1, a_RelBlockZ + 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ + 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
+			SetBlockLinkedPowered(a_RelBlockX, a_RelBlockY - 1, a_RelBlockZ + 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ + 1, a_RelBlockX, a_RelBlockY, a_RelBlockZ, MiddleBlock, a_PowerLevel);
+
+			break;
+		}
+		default:
+		{
+			ASSERT(!"Unhandled face direction when attempting to set blocks as linked powered!");  // Zombies, that wasn't supposed to happen...
+			break;
+		}
+	}
+}
+
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+void cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::SetAllDirsAsPowered(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, unsigned char a_PowerLevel)
+{
+	static const struct
+	{
+		int x, y, z;
+	} gCrossCoords[] =
+	{
+		{ 1, 0, 0 },
+		{ -1, 0, 0 },
+		{ 0, 0, 1 },
+		{ 0, 0, -1 },
+		{ 0, 1, 0 },
+		{ 0, -1, 0 }
+	};
+
+	for (size_t i = 0; i < ARRAYCOUNT(gCrossCoords); i++)  // Loop through struct to power all directions
+	{
+		SetBlockPowered(a_RelBlockX + gCrossCoords[i].x, a_RelBlockY + gCrossCoords[i].y, a_RelBlockZ + gCrossCoords[i].z, a_RelBlockX, a_RelBlockY, a_RelBlockZ, a_PowerLevel);
+	}
+}
+
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+void cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::SetBlockPowered(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, int a_RelSourceX, int a_RelSourceY, int a_RelSourceZ, unsigned char a_PowerLevel)
+{
+	int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX;
+	int BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ;
+	int SourceX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelSourceX;
+	int SourceZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelSourceZ;
+
+	ChunkType * Neighbour = m_Chunk->GetRelNeighborChunkAdjustCoords(a_RelBlockX, a_RelBlockZ);  // Adjust coordinates for the later call using these values
+	if ((Neighbour == NULL) || !Neighbour->IsValid())
+	{
+		return;
+	}
+
+	PoweredBlocksList & Powered = ((cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::cIncrementalRedstoneSimulatorChunkData *)Neighbour->GetRedstoneSimulatorData())->m_PoweredBlocks;  // We need to insert the value into the chunk who owns the block position
+	for (typename PoweredBlocksList::iterator itr = Powered.begin(); itr != Powered.end(); ++itr)
+	{
+		if (
+			itr->a_BlockPos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ)) &&
+			itr->a_SourcePos.Equals(Vector3i(SourceX, a_RelSourceY, SourceZ))
+			)
+		{
+			// Check for duplicates, update power level, don't add a new listing
+			itr->a_PowerLevel = a_PowerLevel;
+			return;
+		}
+	}
+
+	// No need to get neighbouring chunk as we can guarantee that when something is powering us, the entry will be in our chunk
+	// TODO: on C++11 support, change this to a llama function pased to a std::remove_if
+	for (typename PoweredBlocksList::iterator itr = m_PoweredBlocks->begin(); itr != m_PoweredBlocks->end(); ++itr)
+	{
+		if (
+			itr->a_BlockPos.Equals(Vector3i(SourceX, a_RelSourceY, SourceZ)) &&
+			itr->a_SourcePos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ)) &&
+			(m_Chunk->GetBlock(a_RelSourceX, a_RelSourceY, a_RelSourceZ) == E_BLOCK_REDSTONE_WIRE)
+			)
+		{
+			BLOCKTYPE Block;
+			NIBBLETYPE Meta;
+			Neighbour->GetBlockTypeMeta(a_RelBlockX, a_RelBlockY, a_RelBlockZ, Block, Meta);
+
+			if (Block == E_BLOCK_REDSTONE_WIRE)
+			{
+				if (Meta < a_PowerLevel)
+				{
+					m_PoweredBlocks->erase(itr);  // Powering source with higher power level, allow it
+					break;
+				}
+				else
+				{
+					// Powered wires try to power their source - don't let them!
+					return;
+				}
+			}
+		}
+	}
+
+	sPoweredBlocks RC;
+	RC.a_BlockPos = Vector3i(BlockX, a_RelBlockY, BlockZ);
+	RC.a_SourcePos = Vector3i(SourceX, a_RelSourceY, SourceZ);
+	RC.a_PowerLevel = a_PowerLevel;
+	Powered.push_back(RC);
+	Neighbour->SetIsRedstoneDirty(true);
+	m_Chunk->SetIsRedstoneDirty(true);
+}
+
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+void cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::SetBlockLinkedPowered(
+	int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ,
+	int a_RelMiddleX, int a_RelMiddleY, int a_RelMiddleZ,
+	int a_RelSourceX, int a_RelSourceY, int a_RelSourceZ,
+	BLOCKTYPE a_MiddleBlock, unsigned char a_PowerLevel
+	)
+{
+	int BlockX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelBlockX;
+	int BlockZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelBlockZ;
+	int MiddleX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelMiddleX;
+	int MiddleZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelMiddleZ;
+	int SourceX = (m_Chunk->GetPosX() * cChunkDef::Width) + a_RelSourceX;
+	int SourceZ = (m_Chunk->GetPosZ() * cChunkDef::Width) + a_RelSourceZ;
+
+	if (!IsViableMiddleBlock(a_MiddleBlock))
+	{
+		return;
+	}
+
+	ChunkType * Neighbour = m_Chunk->GetNeighborChunk(BlockX, BlockZ);
+	if ((Neighbour == NULL) || !Neighbour->IsValid())
+	{
+		return;
+	}
+
+	LinkedBlocksList & Linked = ((cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::cIncrementalRedstoneSimulatorChunkData *)Neighbour->GetRedstoneSimulatorData())->m_LinkedBlocks;
+	for (typename LinkedBlocksList::iterator itr = Linked.begin(); itr != Linked.end(); ++itr)  // Check linked powered list
+	{
+		if (
+			itr->a_BlockPos.Equals(Vector3i(BlockX, a_RelBlockY, BlockZ)) &&
+			itr->a_MiddlePos.Equals(Vector3i(MiddleX, a_RelMiddleY, MiddleZ)) &&
+			itr->a_SourcePos.Equals(Vector3i(SourceX, a_RelSourceY, SourceZ))
+		)
+		{
+			// Check for duplicates, update power level, don't add a new listing
+			itr->a_PowerLevel = a_PowerLevel;
+			return;
+		}
+	}
+
+	sLinkedPoweredBlocks RC;
+	RC.a_BlockPos = Vector3i(BlockX, a_RelBlockY, BlockZ);
+	RC.a_MiddlePos = Vector3i(MiddleX, a_RelMiddleY, MiddleZ);
+	RC.a_SourcePos = Vector3i(SourceX, a_RelSourceY, SourceZ);
+	RC.a_PowerLevel = a_PowerLevel;
+	Linked.push_back(RC);
+	Neighbour->SetIsRedstoneDirty(true);
+	m_Chunk->SetIsRedstoneDirty(true);
+}
+
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+void cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::SetPlayerToggleableBlockAsSimulated(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, bool WasLastStatePowered)
+{
+	for (typename SimulatedPlayerToggleableList::iterator itr = m_SimulatedPlayerToggleableBlocks->begin(); itr != m_SimulatedPlayerToggleableBlocks->end(); ++itr)
+	{
+		if (!itr->a_RelBlockPos.Equals(Vector3i(a_RelBlockX, a_RelBlockY, a_RelBlockZ)))
+		{
+			continue;
+		}
+
+		if (itr->WasLastStatePowered != WasLastStatePowered)
+		{
+			// If power states different, update listing
+			itr->WasLastStatePowered = WasLastStatePowered;
+			return;
+		}
+		else
+		{
+			// If states the same, just ignore
+			return;
+		}
+	}
+
+	// We have arrive here; no block must be in list - add one
+	sSimulatedPlayerToggleableList RC;
+	RC.a_RelBlockPos = Vector3i(a_RelBlockX, a_RelBlockY, a_RelBlockZ);
+	RC.WasLastStatePowered = WasLastStatePowered;
+	m_SimulatedPlayerToggleableBlocks->push_back(RC);
+}
+
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+bool cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::QueueRepeaterPowerChange(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ, NIBBLETYPE a_Meta, bool ShouldPowerOn)
+{
+	for (typename RepeatersDelayList::iterator itr = m_RepeatersDelayList->begin(); itr != m_RepeatersDelayList->end(); ++itr)
+	{
+		if (itr->a_RelBlockPos.Equals(Vector3i(a_RelBlockX, a_RelBlockY, a_RelBlockZ)))
+		{
+			if (ShouldPowerOn == itr->ShouldPowerOn)  // We are queued already for the same thing, don't replace entry
+			{
+				return false;
+			}
+
+			// Already in here (normal to allow repeater to continue on powering and updating blocks in front) - just update info and quit
+			itr->a_DelayTicks = (((a_Meta & 0xC) >> 0x2) + 1) * 2;  // See below for description
+			itr->a_ElapsedTicks = 0;
+			itr->ShouldPowerOn = ShouldPowerOn;
+			return false;
+		}
+	}
+
+	// Self not in list, add self to list
+	sRepeatersDelayList RC;
+	RC.a_RelBlockPos = Vector3i(a_RelBlockX, a_RelBlockY, a_RelBlockZ);
+	
+	// Gets the top two bits (delay time), shifts them into the lower two bits, and adds one (meta 0 = 1 tick; 1 = 2 etc.)
+	// Multiply by 2 because in MCS, 1 redstone tick = 1 world tick, but in Vanilla, 1 redstone tick = 2 world ticks, and we need to maintain compatibility
+	RC.a_DelayTicks = (((a_Meta & 0xC) >> 0x2) + 1) * 2;
+
+	RC.a_ElapsedTicks = 0;
+	RC.ShouldPowerOn = ShouldPowerOn;
+	m_RepeatersDelayList->push_back(RC);
+	return true;
+}
+
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+void cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::SetSourceUnpowered(int a_SourceX, int a_SourceY, int a_SourceZ, ChunkType * a_Chunk, bool a_IsFirstCall)
+{
+	if (!a_IsFirstCall)  // The neighbouring chunks passed when this parameter is false may be invalid
+	{
+		if ((a_Chunk == NULL) || !a_Chunk->IsValid())
+		{
+			return;
+		}
+	}
+	// TODO: on C++11 support, change both of these to llama functions pased to a std::remove_if
+
+	for (typename PoweredBlocksList::iterator itr = ((cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::cIncrementalRedstoneSimulatorChunkData *)a_Chunk->GetRedstoneSimulatorData())->m_PoweredBlocks.begin(); itr != ((cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::cIncrementalRedstoneSimulatorChunkData *)a_Chunk->GetRedstoneSimulatorData())->m_PoweredBlocks.end();)
+	{
+		if (itr->a_SourcePos.Equals(Vector3i(a_SourceX, a_SourceY, a_SourceZ)))
+		{
+			itr = ((cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::cIncrementalRedstoneSimulatorChunkData *)a_Chunk->GetRedstoneSimulatorData())->m_PoweredBlocks.erase(itr);
+			a_Chunk->SetIsRedstoneDirty(true);
+			continue;
+		}
+		++itr;
+	}
+	for (typename LinkedBlocksList::iterator itr = ((cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::cIncrementalRedstoneSimulatorChunkData *)a_Chunk->GetRedstoneSimulatorData())->m_LinkedBlocks.begin(); itr != ((cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::cIncrementalRedstoneSimulatorChunkData *)a_Chunk->GetRedstoneSimulatorData())->m_LinkedBlocks.end();)
+	{
+		if (itr->a_SourcePos.Equals(Vector3i(a_SourceX, a_SourceY, a_SourceZ)))
+		{
+			itr = ((cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::cIncrementalRedstoneSimulatorChunkData *)a_Chunk->GetRedstoneSimulatorData())->m_LinkedBlocks.erase(itr);
+			a_Chunk->SetIsRedstoneDirty(true);
+			continue;
+		}
+		++itr;
+	}
+
+	if (a_IsFirstCall && AreCoordsOnChunkBoundary(a_SourceX, a_SourceY, a_SourceZ))
+	{
+		// +- 2 to accomodate linked powered blocks
+		SetSourceUnpowered(a_SourceX, a_SourceY, a_SourceZ, a_Chunk->GetNeighborChunk(a_SourceX - 2, a_SourceZ), false);
+		SetSourceUnpowered(a_SourceX, a_SourceY, a_SourceZ, a_Chunk->GetNeighborChunk(a_SourceX + 2, a_SourceZ), false);
+		SetSourceUnpowered(a_SourceX, a_SourceY, a_SourceZ, a_Chunk->GetNeighborChunk(a_SourceX, a_SourceZ - 2), false);
+		SetSourceUnpowered(a_SourceX, a_SourceY, a_SourceZ, a_Chunk->GetNeighborChunk(a_SourceX, a_SourceZ + 2), false);
+	}
+}
+
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+typename cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::eRedstoneDirection cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::GetWireDirection(int a_RelBlockX, int a_RelBlockY, int a_RelBlockZ)
+{
+	int Dir = REDSTONE_NONE;
+
+	BLOCKTYPE NegX = 0;
+	if (m_Chunk->UnboundedRelGetBlockType(a_RelBlockX - 1, a_RelBlockY, a_RelBlockZ, NegX))
+	{
+		if (IsPotentialSource(NegX))
+		{
+			Dir |= (REDSTONE_X_POS);
+		}
+	}
+	
+	BLOCKTYPE PosX = 0;
+	if (m_Chunk->UnboundedRelGetBlockType(a_RelBlockX + 1, a_RelBlockY, a_RelBlockZ, PosX))
+	{
+		if (IsPotentialSource(PosX))
+		{
+			Dir |= (REDSTONE_X_NEG);
+		}
+	}
+	
+	BLOCKTYPE NegZ = 0;
+	if (m_Chunk->UnboundedRelGetBlockType(a_RelBlockX, a_RelBlockY, a_RelBlockZ - 1, NegZ))
+	{
+		if (IsPotentialSource(NegZ))
+		{
+			if ((Dir & REDSTONE_X_POS) && !(Dir & REDSTONE_X_NEG))  // corner
+			{
+				Dir ^= REDSTONE_X_POS;
+				Dir |= REDSTONE_X_NEG;
+			}
+			if ((Dir & REDSTONE_X_NEG) && !(Dir & REDSTONE_X_POS))  // corner
+			{
+				Dir ^= REDSTONE_X_NEG;
+				Dir |= REDSTONE_X_POS;
+			}
+			Dir |= REDSTONE_Z_POS;
+		}
+	}
+	
+	BLOCKTYPE PosZ = 0;
+	if (m_Chunk->UnboundedRelGetBlockType(a_RelBlockX, a_RelBlockY, a_RelBlockZ + 1, PosZ))
+	{
+		if (IsPotentialSource(PosZ))
+		{
+			if ((Dir & REDSTONE_X_POS) && !(Dir & REDSTONE_X_NEG))  // corner
+			{
+				Dir ^= REDSTONE_X_POS;
+				Dir |= REDSTONE_X_NEG;
+			}
+			if ((Dir & REDSTONE_X_NEG) && !(Dir & REDSTONE_X_POS))  // corner
+			{
+				Dir ^= REDSTONE_X_NEG;
+				Dir |= REDSTONE_X_POS;
+			}
+			Dir |= REDSTONE_Z_NEG;
+		}
+	}
+	return (eRedstoneDirection)Dir;
+}
+
+
+
+
+template <class ChunkType, class WorldType, template <BLOCKTYPE block> class GetHandlerCompileTime, class ChestType>
+bool cIncrementalRedstoneSimulator<ChunkType, WorldType, GetHandlerCompileTime, ChestType>::IsLeverOn(NIBBLETYPE a_BlockMeta)
+{
+	// Extract the ON bit from metadata and return if true if it is set:
+	return ((a_BlockMeta & 0x8) == 0x8);
+}
+
+
+
+
diff --git a/src/Simulator/NoopRedstoneSimulator.h b/src/Simulator/NoopRedstoneSimulator.h
index f9ed47982..88e141e85 100644
--- a/src/Simulator/NoopRedstoneSimulator.h
+++ b/src/Simulator/NoopRedstoneSimulator.h
@@ -8,9 +8,9 @@
 
 
 class cRedstoneNoopSimulator :
-	public cRedstoneSimulator
+	public cRedstoneSimulator<cChunk, cWorld>
 {
-	typedef cRedstoneSimulator super;
+	typedef cRedstoneSimulator<cChunk, cWorld> super;
 public:
 
 	cRedstoneNoopSimulator(cWorld & a_World) :
diff --git a/src/Simulator/RedstoneSimulator.cpp b/src/Simulator/RedstoneSimulator.cpp
deleted file mode 100644
index a83f21106..000000000
--- a/src/Simulator/RedstoneSimulator.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-
-#include "Globals.h"
-
-#include "RedstoneSimulator.h"
-#include "../World.h"
-
-
-
-
-
-cRedstoneSimulator::cRedstoneSimulator(cWorld & a_World) :
-	super(a_World)
-{
-}
-
-
-
-
-
diff --git a/src/Simulator/RedstoneSimulator.h b/src/Simulator/RedstoneSimulator.h
index b3e20c9a5..f6d36f869 100644
--- a/src/Simulator/RedstoneSimulator.h
+++ b/src/Simulator/RedstoneSimulator.h
@@ -4,14 +4,25 @@
 #include "Simulator.h"
 
 
+class cRedstoneSimulatorChunkData
+{
+public:
+	virtual ~cRedstoneSimulatorChunkData() = 0;
+} ;
+
 
+inline cRedstoneSimulatorChunkData::~cRedstoneSimulatorChunkData() {}
 
+template <class ChunkType, class WorldType>
 class cRedstoneSimulator :
-	public cSimulator
+	public cSimulator<ChunkType, WorldType>
 {
-	typedef cSimulator super;
+	typedef cSimulator<ChunkType, WorldType> super;
 	
 public:
-	cRedstoneSimulator(cWorld & a_World);
+	cRedstoneSimulator(WorldType & a_World) :
+	super(a_World)
+	{
+	}
 
 } ;
diff --git a/src/Simulator/SandSimulator.cpp b/src/Simulator/SandSimulator.cpp
index 1380f8841..e8887ce59 100644
--- a/src/Simulator/SandSimulator.cpp
+++ b/src/Simulator/SandSimulator.cpp
@@ -7,6 +7,7 @@
 #include "../Defines.h"
 #include "../Entities/FallingBlock.h"
 #include "../Chunk.h"
+#include "inifile/iniFile.h"
 
 
 
diff --git a/src/Simulator/SandSimulator.h b/src/Simulator/SandSimulator.h
index 1262f2792..feb82b4d5 100644
--- a/src/Simulator/SandSimulator.h
+++ b/src/Simulator/SandSimulator.h
@@ -3,13 +3,15 @@
 
 #include "Simulator.h"
 
+/// Per-chunk data for the simulator, specified individual chunks to simulate; Data is not used
+typedef cCoordWithIntList cSandSimulatorChunkData;
 
-
+#include "Chunk.h"
 
 
 /// Despite the class name, this simulator takes care of all blocks that fall when suspended in the air.
 class cSandSimulator :
-	public cSimulator
+	public cSimulator<cChunk, cWorld>
 {
 public:
 	cSandSimulator(cWorld & a_World, cIniFile & a_IniFile);
@@ -55,8 +57,7 @@ protected:
 
 
 
-/// Per-chunk data for the simulator, specified individual chunks to simulate; Data is not used
-typedef cCoordWithIntList cSandSimulatorChunkData;
+
 
 
 
diff --git a/src/Simulator/Simulator.cpp b/src/Simulator/Simulator.cpp
index 0739f0187..d26702166 100644
--- a/src/Simulator/Simulator.cpp
+++ b/src/Simulator/Simulator.cpp
@@ -1,50 +1,13 @@
 
-#include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
+#include "Globals.h"
 
-#include "Simulator.h"
 #include "../World.h"
 #include "../BlockID.h"
 #include "../Defines.h"
 #include "../Chunk.h"
 
+#include "Simulator.inc"
 
-
-
-
-cSimulator::cSimulator(cWorld & a_World)
-	: m_World(a_World)
-{
-}
-
-
-
-
-
-cSimulator::~cSimulator()
-{
-}
-
-
-
-
-
-void cSimulator::WakeUp(int a_BlockX, int a_BlockY, int a_BlockZ, cChunk * a_Chunk)
-{
-	AddBlock(a_BlockX,     a_BlockY,     a_BlockZ,     a_Chunk);
-	AddBlock(a_BlockX - 1, a_BlockY,     a_BlockZ,     a_Chunk->GetNeighborChunk(a_BlockX - 1, a_BlockZ));
-	AddBlock(a_BlockX + 1, a_BlockY,     a_BlockZ,     a_Chunk->GetNeighborChunk(a_BlockX + 1, a_BlockZ));
-	AddBlock(a_BlockX,     a_BlockY,     a_BlockZ - 1, a_Chunk->GetNeighborChunk(a_BlockX,     a_BlockZ - 1));
-	AddBlock(a_BlockX,     a_BlockY,     a_BlockZ + 1, a_Chunk->GetNeighborChunk(a_BlockX,     a_BlockZ + 1));
-	if (a_BlockY > 0)
-	{
-		AddBlock(a_BlockX,   a_BlockY - 1, a_BlockZ,     a_Chunk);
-	}
-	if (a_BlockY < cChunkDef::Height - 1)
-	{
-		AddBlock(a_BlockX,   a_BlockY + 1, a_BlockZ,     a_Chunk);
-	}
-}
-
-
-
+#pragma clang diagnostic ignored "-Wweak-template-vtables"
+template class cSimulator<cChunk, cWorld>;
 
diff --git a/src/Simulator/Simulator.h b/src/Simulator/Simulator.h
index 4d9a18867..7cc2f1344 100644
--- a/src/Simulator/Simulator.h
+++ b/src/Simulator/Simulator.h
@@ -2,23 +2,17 @@
 #pragma once
 
 #include "../Vector3.h"
-#include "inifile/iniFile.h"
 
 
 
 
 
-class cWorld;
-class cChunk;
-
-
-
-
 
+template <class ChunkType, class WorldType>
 class cSimulator
 {
 public:
-	cSimulator(cWorld & a_World);
+	cSimulator(WorldType & a_World);
 	virtual ~cSimulator();
 
 	/// Called in each tick, a_Dt is the time passed since the last tick, in msec
@@ -26,7 +20,7 @@ public:
 	
 	/// Called in each tick for each chunk, a_Dt is the time passed since the last tick, in msec; direct access to chunk data available
 	virtual void SimulateChunk(float a_Dt, int a_ChunkX,
-		int a_ChunkZ, cChunk * a_Chunk)
+		int a_ChunkZ, ChunkType * a_Chunk)
 	{
 		UNUSED(a_Dt);
 		UNUSED(a_ChunkX);
@@ -35,7 +29,7 @@ public:
 	}
 	
 	/// Called when a block changes
-	virtual void WakeUp(int a_BlockX, int a_BlockY, int a_BlockZ, cChunk * a_Chunk);
+	virtual void WakeUp(int a_BlockX, int a_BlockY, int a_BlockZ, ChunkType * a_Chunk);
 
 	virtual bool IsAllowedBlock(BLOCKTYPE a_BlockType) = 0;
 
@@ -43,9 +37,9 @@ protected:
 	friend class cChunk;  // Calls AddBlock() in its WakeUpSimulators() function, to speed things up
 	
 	/// Called to simulate a new block
-	virtual void AddBlock(int a_BlockX, int a_BlockY, int a_BlockZ, cChunk * a_Chunk) = 0;
+	virtual void AddBlock(int a_BlockX, int a_BlockY, int a_BlockZ, ChunkType * a_Chunk) = 0;
 
-	cWorld & m_World;
+	WorldType & m_World;
 } ;
 
 
diff --git a/src/Simulator/Simulator.inc b/src/Simulator/Simulator.inc
new file mode 100644
index 000000000..511a6b4c2
--- /dev/null
+++ b/src/Simulator/Simulator.inc
@@ -0,0 +1,45 @@
+
+
+#include "Simulator.h"
+
+
+
+
+template <class ChunkType, class WorldType>
+cSimulator<ChunkType, WorldType>::cSimulator(WorldType & a_World)
+	: m_World(a_World)
+{
+}
+
+
+
+
+template <class ChunkType, class WorldType>
+cSimulator<ChunkType, WorldType>::~cSimulator()
+{
+}
+
+
+
+
+template <class ChunkType, class WorldType>
+void cSimulator<ChunkType, WorldType>::WakeUp(int a_BlockX, int a_BlockY, int a_BlockZ, ChunkType * a_Chunk)
+{
+	AddBlock(a_BlockX,     a_BlockY,     a_BlockZ,     a_Chunk);
+	AddBlock(a_BlockX - 1, a_BlockY,     a_BlockZ,     a_Chunk->GetNeighborChunk(a_BlockX - 1, a_BlockZ));
+	AddBlock(a_BlockX + 1, a_BlockY,     a_BlockZ,     a_Chunk->GetNeighborChunk(a_BlockX + 1, a_BlockZ));
+	AddBlock(a_BlockX,     a_BlockY,     a_BlockZ - 1, a_Chunk->GetNeighborChunk(a_BlockX,     a_BlockZ - 1));
+	AddBlock(a_BlockX,     a_BlockY,     a_BlockZ + 1, a_Chunk->GetNeighborChunk(a_BlockX,     a_BlockZ + 1));
+	if (a_BlockY > 0)
+	{
+		AddBlock(a_BlockX,   a_BlockY - 1, a_BlockZ,     a_Chunk);
+	}
+	if (a_BlockY < cChunkDef::Height - 1)
+	{
+		AddBlock(a_BlockX,   a_BlockY + 1, a_BlockZ,     a_Chunk);
+	}
+}
+
+
+
+
diff --git a/src/Simulator/SimulatorManager.cpp b/src/Simulator/SimulatorManager.cpp
index 918bac7a1..dafdcd239 100644
--- a/src/Simulator/SimulatorManager.cpp
+++ b/src/Simulator/SimulatorManager.cpp
@@ -70,7 +70,7 @@ void cSimulatorManager::WakeUp(int a_BlockX, int a_BlockY, int a_BlockZ, cChunk
 
 
 
-void cSimulatorManager::RegisterSimulator(cSimulator * a_Simulator, int a_Rate)
+void cSimulatorManager::RegisterSimulator(cSimulator<cChunk, cWorld> * a_Simulator, int a_Rate)
 {
 	m_Simulators.push_back(std::make_pair(a_Simulator, a_Rate));
 }
diff --git a/src/Simulator/SimulatorManager.h b/src/Simulator/SimulatorManager.h
index 31a709316..185141764 100644
--- a/src/Simulator/SimulatorManager.h
+++ b/src/Simulator/SimulatorManager.h
@@ -37,10 +37,10 @@ public:
 	
 	void WakeUp(int a_BlockX, int a_BlockY, int a_BlockZ, cChunk * a_Chunk);
 
-	void RegisterSimulator(cSimulator * a_Simulator, int a_Rate);  // Takes ownership of the simulator object!
+	void RegisterSimulator(cSimulator<cChunk, cWorld> * a_Simulator, int a_Rate);  // Takes ownership of the simulator object!
 
 protected:
-	typedef std::vector <std::pair<cSimulator *, int> > cSimulators;
+	typedef std::vector <std::pair<cSimulator<cChunk, cWorld> *, int> > cSimulators;
 	
 	cWorld & m_World;
 	cSimulators m_Simulators;
diff --git a/src/Tracer.cpp b/src/Tracer.cpp
index 756147a7b..e125c6aa4 100644
--- a/src/Tracer.cpp
+++ b/src/Tracer.cpp
@@ -250,7 +250,7 @@ int LinesCross(float x0, float y0, float x1, float y1, float x2, float y2, float
 	// float linx, liny;
 
 	float d=(x1-x0)*(y3-y2)-(y1-y0)*(x3-x2);
-	if (abs(d)<0.001) {return 0;}
+	if (std::abs(d)<0.001) {return 0;}
 	float AB=((y0-y2)*(x3-x2)-(x0-x2)*(y3-y2))/d;
 	if (AB>=0.0 && AB<=1.0)
 	{
@@ -283,7 +283,7 @@ int cTracer::intersect3D_SegmentPlane( const Vector3f & a_Origin, const Vector3f
 	if (fabs(D) < EPSILON)
 	{
 		// segment is parallel to plane
-		if (N == 0)
+		if (N == 0.0)
 		{
 			// segment lies in plane
 			return 2;
diff --git a/src/UI/Window.cpp b/src/UI/Window.cpp
index 66900269f..1b7b07f77 100644
--- a/src/UI/Window.cpp
+++ b/src/UI/Window.cpp
@@ -57,6 +57,34 @@ cWindow::~cWindow()
 
 
 
+const AString cWindow::GetWindowTypeName(void) const
+{
+	switch (m_WindowType)
+	{
+		case wtChest:       return "minecraft:chest";
+		case wtWorkbench:   return "minecraft:crafting_table";
+		case wtFurnace:     return "minecraft:furnace";
+		case wtDropSpenser: return "minecraft:dispenser";
+		case wtEnchantment: return "minecraft:enchanting_table";
+		case wtBrewery:     return "minecraft:brewing_stand";
+		case wtNPCTrade:    return "minecraft:villager";
+		case wtBeacon:      return "minecraft:beacon";
+		case wtAnvil:       return "minecraft:anvil";
+		case wtHopper:      return "minecraft:hopper";
+		case wtDropper:     return "minecraft:dropper";
+		case wtAnimalChest: return "EntityHorse";
+		default:
+		{
+			ASSERT(!"Unknown inventory type!");
+			return "";
+		}
+	}
+}
+
+
+
+
+
 int cWindow::GetNumSlots(void) const
 {
 	int res = 0;
diff --git a/src/UI/Window.h b/src/UI/Window.h
index 3d860407f..bc5becf11 100644
--- a/src/UI/Window.h
+++ b/src/UI/Window.h
@@ -63,7 +63,7 @@ public:
 		wtBeacon      = 7,
 		wtAnvil       = 8,
 		wtHopper      = 9,
-		// Unknown: 10
+		wtDropper     = 10,
 		wtAnimalChest = 11,
 	};
 	
@@ -76,6 +76,7 @@ public:
 
 	char GetWindowID(void) const { return m_WindowID; }  // tolua_export
 	int GetWindowType(void) const { return m_WindowType; }  // tolua_export
+	const AString GetWindowTypeName(void) const;  // tolua_export
 
 	cWindowOwner * GetOwner(void) { return m_Owner; }
 	void SetOwner( cWindowOwner * a_Owner) { m_Owner = a_Owner; }
diff --git a/src/World.cpp b/src/World.cpp
index fe0be00ae..61c061867 100644
--- a/src/World.cpp
+++ b/src/World.cpp
@@ -681,8 +681,19 @@ void cWorld::GenerateRandomSpawn(void)
 {
 	LOGD("Generating random spawnpoint...");
 
-	while (IsBlockWaterOrIce(GetBlock((int)m_SpawnX, GetHeight((int)m_SpawnX, (int)m_SpawnZ), (int)m_SpawnZ)))
+	// Look for a spawn point at most 100 chunks away from map center:
+	for (int i = 0; i < 100; i++)
 	{
+		EMCSBiome biome = GetBiomeAt((int)m_SpawnX, (int)m_SpawnZ);
+		if (
+			(biome != biOcean) && (biome != biFrozenOcean) &&  // The biome is acceptable (don't want a small ocean island)
+			!IsBlockWaterOrIce(GetBlock((int)m_SpawnX, GetHeight((int)m_SpawnX, (int)m_SpawnZ), (int)m_SpawnZ))  // The terrain is acceptable (don't want to spawn inside a lake / river)
+		)
+		{
+			// A good spawnpoint was found
+			break;
+		}
+		// Try a neighboring chunk:
 		if ((GetTickRandomNumber(4) % 2) == 0)  // Randomise whether to increment X or Z coords
 		{
 			m_SpawnX += cChunkDef::Width;
@@ -691,11 +702,11 @@ void cWorld::GenerateRandomSpawn(void)
 		{
 			m_SpawnZ += cChunkDef::Width;
 		}
-	}
+	}  // for i - 100*
 
 	m_SpawnY = (double)GetHeight((int)m_SpawnX, (int)m_SpawnZ) + 1.6f;  // 1.6f to accomodate player height
 
-	LOGD("Generated random spawnpoint %i %i %i", (int)m_SpawnX, (int)m_SpawnY, (int)m_SpawnZ);
+	LOGINFO("Generated random spawnpoint position {%i, %i, %i}", (int)m_SpawnX, (int)m_SpawnY, (int)m_SpawnZ);
 }
 
 
@@ -791,8 +802,8 @@ void cWorld::InitialiseAndLoadMobSpawningValues(cIniFile & a_IniFile)
 	AStringVector SplitList = StringSplitAndTrim(AllMonsters, ",");
 	for (AStringVector::const_iterator itr = SplitList.begin(), end = SplitList.end(); itr != end; ++itr)
 	{
-		cMonster::eType ToAdd = cMonster::StringToMobType(*itr);
-		if (ToAdd != cMonster::mtInvalidType)
+		eMonsterType ToAdd = cMonster::StringToMobType(*itr);
+		if (ToAdd != mtInvalidType)
 		{
 			m_AllowedMobs.insert(ToAdd);
 			LOGD("Allowed mob: %s", itr->c_str());
@@ -2144,16 +2155,52 @@ void cWorld::BroadcastEntityAnimation(const cEntity & a_Entity, char a_Animation
 
 
 
-void cWorld::BroadcastParticleEffect(const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmmount, cClientHandle * a_Exclude)
+void cWorld::BroadcastParticleEffect(const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmount, cClientHandle * a_Exclude)
+{
+	m_ChunkMap->BroadcastParticleEffect(a_ParticleName, a_SrcX, a_SrcY, a_SrcZ, a_OffsetX, a_OffsetY, a_OffsetZ, a_ParticleData, a_ParticleAmount, a_Exclude);
+}
+
+
+
+
+
+void cWorld::BroadcastPlayerListAddPlayer(const cPlayer & a_Player, const cClientHandle * a_Exclude)
+{
+	cCSLock Lock(m_CSPlayers);
+	for (cPlayerList::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
+	{
+		cClientHandle * ch = (*itr)->GetClientHandle();
+		if ((ch == a_Exclude) || (ch == NULL) || !ch->IsLoggedIn() || ch->IsDestroyed())
+		{
+			continue;
+		}
+		ch->SendPlayerListAddPlayer(a_Player);
+	}
+}
+
+
+
+
+
+void cWorld::BroadcastPlayerListRemovePlayer(const cPlayer & a_Player, const cClientHandle * a_Exclude)
 {
-	m_ChunkMap->BroadcastParticleEffect(a_ParticleName, a_SrcX, a_SrcY, a_SrcZ, a_OffsetX, a_OffsetY, a_OffsetZ, a_ParticleData, a_ParticleAmmount, a_Exclude);
+	cCSLock Lock(m_CSPlayers);
+	for (cPlayerList::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
+	{
+		cClientHandle * ch = (*itr)->GetClientHandle();
+		if ((ch == a_Exclude) || (ch == NULL) || !ch->IsLoggedIn() || ch->IsDestroyed())
+		{
+			continue;
+		}
+		ch->SendPlayerListRemovePlayer(a_Player);
+	}
 }
 
 
 
 
 
-void cWorld::BroadcastPlayerListItem (const cPlayer & a_Player, bool a_IsOnline, const cClientHandle * a_Exclude)
+void cWorld::BroadcastPlayerListUpdateGameMode(const cPlayer & a_Player, const cClientHandle * a_Exclude)
 {
 	cCSLock Lock(m_CSPlayers);
 	for (cPlayerList::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
@@ -2163,7 +2210,43 @@ void cWorld::BroadcastPlayerListItem (const cPlayer & a_Player, bool a_IsOnline,
 		{
 			continue;
 		}
-		ch->SendPlayerListItem(a_Player, a_IsOnline);
+		ch->SendPlayerListUpdateGameMode(a_Player);
+	}
+}
+
+
+
+
+
+void cWorld::BroadcastPlayerListUpdatePing(const cPlayer & a_Player, const cClientHandle * a_Exclude)
+{
+	cCSLock Lock(m_CSPlayers);
+	for (cPlayerList::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
+	{
+		cClientHandle * ch = (*itr)->GetClientHandle();
+		if ((ch == a_Exclude) || (ch == NULL) || !ch->IsLoggedIn() || ch->IsDestroyed())
+		{
+			continue;
+		}
+		ch->SendPlayerListUpdatePing(a_Player);
+	}
+}
+
+
+
+
+
+void cWorld::BroadcastPlayerListUpdateDisplayName(const cPlayer & a_Player, const AString & a_CustomName, const cClientHandle * a_Exclude)
+{
+	cCSLock Lock(m_CSPlayers);
+	for (cPlayerList::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
+	{
+		cClientHandle * ch = (*itr)->GetClientHandle();
+		if ((ch == a_Exclude) || (ch == NULL) || !ch->IsLoggedIn() || ch->IsDestroyed())
+		{
+			continue;
+		}
+		ch->SendPlayerListUpdateDisplayName(a_Player, a_CustomName);
 	}
 }
 
@@ -2686,7 +2769,7 @@ void cWorld::SendPlayerList(cPlayer * a_DestPlayer)
 		cClientHandle * ch = (*itr)->GetClientHandle();
 		if ((ch != NULL) && !ch->IsDestroyed())
 		{
-			a_DestPlayer->GetClientHandle()->SendPlayerListItem(*(*itr), true);
+			a_DestPlayer->GetClientHandle()->SendPlayerListAddPlayer(*(*itr));
 		}
 	}
 }
@@ -3126,7 +3209,7 @@ bool cWorld::IsBlockDirectlyWatered(int a_BlockX, int a_BlockY, int a_BlockZ)
 
 
 
-int cWorld::SpawnMob(double a_PosX, double a_PosY, double a_PosZ, cMonster::eType a_MonsterType)
+int cWorld::SpawnMob(double a_PosX, double a_PosY, double a_PosZ, eMonsterType a_MonsterType)
 {
 	cMonster * Monster = NULL;
 
@@ -3216,13 +3299,17 @@ void cWorld::TabCompleteUserName(const AString & a_Text, AStringVector & a_Resul
 	for (cPlayerList::iterator itr = m_Players.begin(), end = m_Players.end(); itr != end; ++itr)
 	{
 		AString PlayerName ((*itr)->GetName());
+		if ((*itr)->HasCustomName())
+		{
+			PlayerName = (*itr)->GetCustomName();
+		}
+
 		AString::size_type Found = PlayerName.find(LastWord);  // Try to find last word in playername
-		
 		if (Found == AString::npos)
 		{
 			continue;  // No match
 		}
-		
+
 		UsernamesByWeight.push_back(std::make_pair(Found, PlayerName));  // Match! Store it with the position of the match as a weight
 	}
 	Lock.Unlock();
@@ -3258,7 +3345,7 @@ void cWorld::SetChunkAlwaysTicked(int a_ChunkX, int a_ChunkZ, bool a_AlwaysTicke
 
 
 
-cRedstoneSimulator * cWorld::InitializeRedstoneSimulator(cIniFile & a_IniFile)
+cRedstoneSimulator<cChunk, cWorld> * cWorld::InitializeRedstoneSimulator(cIniFile & a_IniFile)
 {
 	AString SimulatorName = a_IniFile.GetValueSet("Physics", "RedstoneSimulator", "Incremental");
 
@@ -3268,11 +3355,11 @@ cRedstoneSimulator * cWorld::InitializeRedstoneSimulator(cIniFile & a_IniFile)
 		SimulatorName = "Incremental";
 	}
 	
-	cRedstoneSimulator * res = NULL;
+	cRedstoneSimulator<cChunk, cWorld> * res = NULL;
 
 	if (NoCaseCompare(SimulatorName, "Incremental") == 0)
 	{
-		res = new cIncrementalRedstoneSimulator(*this);
+		res = MakeIncrementalRedstoneSimulator(*this);
 	}
 	else if (NoCaseCompare(SimulatorName, "noop") == 0)
 	{
diff --git a/src/World.h b/src/World.h
index 8b40037af..90dada259 100644
--- a/src/World.h
+++ b/src/World.h
@@ -33,6 +33,7 @@
 class cFireSimulator;
 class cFluidSimulator;
 class cSandSimulator;
+template <class ChunkType, class WorldType>
 class cRedstoneSimulator;
 class cItem;
 class cPlayer;
@@ -226,33 +227,37 @@ public:
 	void BroadcastChat       (const cCompositeChat & a_Message, const cClientHandle * a_Exclude = NULL);
 	// tolua_end
 
-	void BroadcastChunkData              (int a_ChunkX, int a_ChunkZ, cChunkDataSerializer & a_Serializer, const cClientHandle * a_Exclude = NULL);
-	void BroadcastCollectEntity          (const cEntity & a_Pickup, const cPlayer & a_Player, const cClientHandle * a_Exclude = NULL);
-	void BroadcastDestroyEntity          (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityEffect           (const cEntity & a_Entity, int a_EffectID, int a_Amplifier, short a_Duration, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityEquipment        (const cEntity & a_Entity, short a_SlotNum, const cItem & a_Item, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityHeadLook         (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityLook             (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityMetadata         (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityRelMove          (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityRelMoveLook      (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityStatus           (const cEntity & a_Entity, char a_Status, const cClientHandle * a_Exclude = NULL);
-	void BroadcastEntityVelocity         (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	virtual void BroadcastEntityAnimation(const cEntity & a_Entity, char a_Animation, const cClientHandle * a_Exclude = NULL) override;  // tolua_export
-	void BroadcastParticleEffect         (const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmmount, cClientHandle * a_Exclude = NULL);  // tolua_export
-	void BroadcastPlayerListItem         (const cPlayer & a_Player, bool a_IsOnline, const cClientHandle * a_Exclude = NULL);
-	void BroadcastRemoveEntityEffect     (const cEntity & a_Entity, int a_EffectID, const cClientHandle * a_Exclude = NULL);
-	void BroadcastScoreboardObjective    (const AString & a_Name, const AString & a_DisplayName, Byte a_Mode);
-	void BroadcastScoreUpdate            (const AString & a_Objective, const AString & a_Player, cObjective::Score a_Score, Byte a_Mode);
-	void BroadcastDisplayObjective       (const AString & a_Objective, cScoreboard::eDisplaySlot a_Display);
-	void BroadcastSoundEffect            (const AString & a_SoundName, double a_X, double a_Y, double a_Z, float a_Volume, float a_Pitch, const cClientHandle * a_Exclude = NULL);   // tolua_export
-	void BroadcastSoundParticleEffect    (int a_EffectID, int a_SrcX, int a_SrcY, int a_SrcZ, int a_Data, const cClientHandle * a_Exclude = NULL);  // tolua_export
-	void BroadcastSpawnEntity            (cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastTeleportEntity         (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
-	void BroadcastThunderbolt            (int a_BlockX, int a_BlockY, int a_BlockZ, const cClientHandle * a_Exclude = NULL);
-	void BroadcastTimeUpdate             (const cClientHandle * a_Exclude = NULL);
-	virtual void BroadcastUseBed         (const cEntity & a_Entity, int a_BlockX, int a_BlockY, int a_BlockZ) override;
-	void BroadcastWeather                (eWeather a_Weather, const cClientHandle * a_Exclude = NULL);
+	void BroadcastChunkData                  (int a_ChunkX, int a_ChunkZ, cChunkDataSerializer & a_Serializer, const cClientHandle * a_Exclude = NULL);
+	void BroadcastCollectEntity              (const cEntity & a_Pickup, const cPlayer & a_Player, const cClientHandle * a_Exclude = NULL);
+	void BroadcastDestroyEntity              (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
+	void BroadcastEntityEffect               (const cEntity & a_Entity, int a_EffectID, int a_Amplifier, short a_Duration, const cClientHandle * a_Exclude = NULL);
+	void BroadcastEntityEquipment            (const cEntity & a_Entity, short a_SlotNum, const cItem & a_Item, const cClientHandle * a_Exclude = NULL);
+	void BroadcastEntityHeadLook             (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
+	void BroadcastEntityLook                 (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
+	void BroadcastEntityMetadata             (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
+	void BroadcastEntityRelMove              (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ, const cClientHandle * a_Exclude = NULL);
+	void BroadcastEntityRelMoveLook          (const cEntity & a_Entity, char a_RelX, char a_RelY, char a_RelZ, const cClientHandle * a_Exclude = NULL);
+	void BroadcastEntityStatus               (const cEntity & a_Entity, char a_Status, const cClientHandle * a_Exclude = NULL);
+	void BroadcastEntityVelocity             (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
+	virtual void BroadcastEntityAnimation    (const cEntity & a_Entity, char a_Animation, const cClientHandle * a_Exclude = NULL) override;  // tolua_export
+	void BroadcastParticleEffect             (const AString & a_ParticleName, float a_SrcX, float a_SrcY, float a_SrcZ, float a_OffsetX, float a_OffsetY, float a_OffsetZ, float a_ParticleData, int a_ParticleAmount, cClientHandle * a_Exclude = NULL);  // tolua_export
+	void BroadcastPlayerListAddPlayer        (const cPlayer & a_Player, const cClientHandle * a_Exclude = NULL);
+	void BroadcastPlayerListRemovePlayer     (const cPlayer & a_Player, const cClientHandle * a_Exclude = NULL);
+	void BroadcastPlayerListUpdateGameMode   (const cPlayer & a_Player, const cClientHandle * a_Exclude = NULL);
+	void BroadcastPlayerListUpdatePing       (const cPlayer & a_Player, const cClientHandle * a_Exclude = NULL);
+	void BroadcastPlayerListUpdateDisplayName(const cPlayer & a_Player, const AString & a_CustomName, const cClientHandle * a_Exclude = NULL);
+	void BroadcastRemoveEntityEffect         (const cEntity & a_Entity, int a_EffectID, const cClientHandle * a_Exclude = NULL);
+	void BroadcastScoreboardObjective        (const AString & a_Name, const AString & a_DisplayName, Byte a_Mode);
+	void BroadcastScoreUpdate                (const AString & a_Objective, const AString & a_Player, cObjective::Score a_Score, Byte a_Mode);
+	void BroadcastDisplayObjective           (const AString & a_Objective, cScoreboard::eDisplaySlot a_Display);
+	void BroadcastSoundEffect                (const AString & a_SoundName, double a_X, double a_Y, double a_Z, float a_Volume, float a_Pitch, const cClientHandle * a_Exclude = NULL);   // tolua_export
+	void BroadcastSoundParticleEffect        (int a_EffectID, int a_SrcX, int a_SrcY, int a_SrcZ, int a_Data, const cClientHandle * a_Exclude = NULL);  // tolua_export
+	void BroadcastSpawnEntity                (cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
+	void BroadcastTeleportEntity             (const cEntity & a_Entity, const cClientHandle * a_Exclude = NULL);
+	void BroadcastThunderbolt                (int a_BlockX, int a_BlockY, int a_BlockZ, const cClientHandle * a_Exclude = NULL);
+	void BroadcastTimeUpdate                 (const cClientHandle * a_Exclude = NULL);
+	virtual void BroadcastUseBed             (const cEntity & a_Entity, int a_BlockX, int a_BlockY, int a_BlockZ) override;
+	void BroadcastWeather                    (eWeather a_Weather, const cClientHandle * a_Exclude = NULL);
 	
 	virtual cBroadcastInterface & GetBroadcastManager(void) override
 	{
@@ -505,7 +510,7 @@ public:
 	
 	inline cFluidSimulator * GetWaterSimulator(void) { return m_WaterSimulator; }
 	inline cFluidSimulator * GetLavaSimulator (void) { return m_LavaSimulator; }
-	inline cRedstoneSimulator * GetRedstoneSimulator(void) { return m_RedstoneSimulator; }
+	inline cRedstoneSimulator<cChunk, cWorld> * GetRedstoneSimulator(void) { return m_RedstoneSimulator; }
 	
 	/** Calls the callback for each block entity in the specified chunk; returns true if all block entities processed, false if the callback aborted by returning true */
 	bool ForEachBlockEntityInChunk(int a_ChunkX, int a_ChunkZ, cBlockEntityCallback & a_Callback);  // Exported in ManualBindings.cpp
@@ -770,7 +775,7 @@ public:
 	bool IsBlockDirectlyWatered(int a_BlockX, int a_BlockY, int a_BlockZ);  // tolua_export
 	
 	/** Spawns a mob of the specified type. Returns the mob's EntityID if recognized and spawned, <0 otherwise */
-	virtual int SpawnMob(double a_PosX, double a_PosY, double a_PosZ, cMonster::eType a_MonsterType) override;  // tolua_export
+	virtual int SpawnMob(double a_PosX, double a_PosY, double a_PosZ, eMonsterType a_MonsterType) override;  // tolua_export
 	int SpawnMobFinalize(cMonster* a_Monster);
 	
 	/** Creates a projectile of the specified type. Returns the projectile's EntityID if successful, <0 otherwise
@@ -913,7 +918,7 @@ private:
 	cFluidSimulator *    m_WaterSimulator;
 	cFluidSimulator *    m_LavaSimulator;
 	cFireSimulator *     m_FireSimulator;
-	cRedstoneSimulator * m_RedstoneSimulator;
+	cRedstoneSimulator<cChunk, cWorld> * m_RedstoneSimulator;
 	
 	cCriticalSection m_CSPlayers;
 	cPlayerList      m_Players;
@@ -925,7 +930,7 @@ private:
 	cChunkMap * m_ChunkMap;
 
 	bool m_bAnimals;
-	std::set<cMonster::eType> m_AllowedMobs;
+	std::set<eMonsterType> m_AllowedMobs;
 
 	eWeather m_Weather;
 	int m_WeatherInterval;
@@ -1054,7 +1059,7 @@ private:
 	cFluidSimulator * InitializeFluidSimulator(cIniFile & a_IniFile, const char * a_FluidName, BLOCKTYPE a_SimulateBlock, BLOCKTYPE a_StationaryBlock);
 
 	/** Creates a new redstone simulator.*/
-	cRedstoneSimulator * InitializeRedstoneSimulator(cIniFile & a_IniFile);
+	cRedstoneSimulator<cChunk, cWorld> * InitializeRedstoneSimulator(cIniFile & a_IniFile);
 
 	/** Adds the players queued in the m_PlayersToAdd queue into the m_Players list.
 	Assumes it is called from the Tick thread. */
diff --git a/src/WorldStorage/FastNBT.cpp b/src/WorldStorage/FastNBT.cpp
index c6294b99c..ed8e8bb14 100644
--- a/src/WorldStorage/FastNBT.cpp
+++ b/src/WorldStorage/FastNBT.cpp
@@ -310,7 +310,7 @@ int cParsedNBT::FindTagByPath(int a_Tag, const AString & a_Path) const
 		{
 			continue;
 		}
-		Tag = FindChildByName(Tag, a_Path.c_str() + Begin, i - Begin - 1);
+		Tag = FindChildByName(Tag, a_Path.c_str() + Begin, i - Begin);
 		if (Tag < 0)
 		{
 			return -1;
diff --git a/src/WorldStorage/FastNBT.h b/src/WorldStorage/FastNBT.h
index ebf99103f..c6225eacf 100644
--- a/src/WorldStorage/FastNBT.h
+++ b/src/WorldStorage/FastNBT.h
@@ -213,8 +213,8 @@ public:
 		// If your platform produces a compiler error here, you'll need to add code that manually decodes 32-bit floats
 		char Check1[5 - sizeof(float)];  // Fails if sizeof(float) > 4
 		char Check2[sizeof(float) - 3];  // Fails if sizeof(float) < 4
-		UNUSED(Check1);
-		UNUSED(Check2);
+		UNUSED_VAR(Check1);
+		UNUSED_VAR(Check2);
 		
 		Int32 i = GetBEInt(m_Data + m_Tags[(size_t)a_Tag].m_DataStart);
 		float f;
@@ -229,8 +229,8 @@ public:
 		// If your platform produces a compiler error here, you'll need to add code that manually decodes 64-bit doubles
 		char Check1[9 - sizeof(double)];  // Fails if sizeof(double) > 8
 		char Check2[sizeof(double) - 7];  // Fails if sizeof(double) < 8
-		UNUSED(Check1);
-		UNUSED(Check2);
+		UNUSED_VAR(Check1);
+		UNUSED_VAR(Check2);
 
 		ASSERT(m_Tags[(size_t)a_Tag].m_Type == TAG_Double);
 		return NetworkToHostDouble8(m_Data + m_Tags[(size_t)a_Tag].m_DataStart);
diff --git a/src/WorldStorage/MapSerializer.cpp b/src/WorldStorage/MapSerializer.cpp
index 012fc52f3..4a913c81a 100644
--- a/src/WorldStorage/MapSerializer.cpp
+++ b/src/WorldStorage/MapSerializer.cpp
@@ -130,14 +130,14 @@ bool cMapSerializer::LoadMapFromNBT(const cParsedNBT & a_NBT)
 	}
 
 	int CurrLine = a_NBT.FindChildByName(Data, "scale");
-	if (CurrLine >= 0)
+	if ((CurrLine >= 0) && (a_NBT.GetType(CurrLine) == TAG_Byte))
 	{
-		unsigned int Scale = a_NBT.GetByte(CurrLine);
+		unsigned int Scale = (unsigned int)a_NBT.GetByte(CurrLine);
 		m_Map->SetScale(Scale);
 	}
 
 	CurrLine = a_NBT.FindChildByName(Data, "dimension");
-	if (CurrLine >= 0)
+	if ((CurrLine >= 0) && (a_NBT.GetType(CurrLine) == TAG_Byte))
 	{
 		eDimension Dimension = (eDimension) a_NBT.GetByte(CurrLine);
 		
@@ -149,9 +149,9 @@ bool cMapSerializer::LoadMapFromNBT(const cParsedNBT & a_NBT)
 	}
 
 	CurrLine = a_NBT.FindChildByName(Data, "width");
-	if (CurrLine >= 0)
+	if ((CurrLine >= 0) && (a_NBT.GetType(CurrLine) == TAG_Short))
 	{
-		unsigned int Width = a_NBT.GetShort(CurrLine);
+		unsigned int Width = (unsigned int)a_NBT.GetShort(CurrLine);
 		if (Width != 128)
 		{
 			return false;
@@ -160,9 +160,9 @@ bool cMapSerializer::LoadMapFromNBT(const cParsedNBT & a_NBT)
 	}
 
 	CurrLine = a_NBT.FindChildByName(Data, "height");
-	if (CurrLine >= 0)
+	if ((CurrLine >= 0) && (a_NBT.GetType(CurrLine) == TAG_Short))
 	{
-		unsigned int Height = a_NBT.GetShort(CurrLine);
+		unsigned int Height = (unsigned int)a_NBT.GetShort(CurrLine);
 		if (Height >= 256)
 		{
 			return false;
@@ -171,14 +171,14 @@ bool cMapSerializer::LoadMapFromNBT(const cParsedNBT & a_NBT)
 	}
 
 	CurrLine = a_NBT.FindChildByName(Data, "xCenter");
-	if (CurrLine >= 0)
+	if ((CurrLine >= 0) && (a_NBT.GetType(CurrLine) == TAG_Int))
 	{
 		int CenterX = a_NBT.GetInt(CurrLine);
 		m_Map->m_CenterX = CenterX;
 	}
 
 	CurrLine = a_NBT.FindChildByName(Data, "zCenter");
-	if (CurrLine >= 0)
+	if ((CurrLine >= 0) && (a_NBT.GetType(CurrLine) == TAG_Int))
 	{
 		int CenterZ = a_NBT.GetInt(CurrLine);
 		m_Map->m_CenterZ = CenterZ;
diff --git a/src/WorldStorage/MapSerializer.h b/src/WorldStorage/MapSerializer.h
index 4fa40f6f9..e13a75c8f 100644
--- a/src/WorldStorage/MapSerializer.h
+++ b/src/WorldStorage/MapSerializer.h
@@ -28,10 +28,10 @@ public:
 
 	cMapSerializer(const AString& a_WorldName, cMap * a_Map);
 
-	/** Try to load the scoreboard */
+	/** Try to load the map */
 	bool Load(void);
 
-	/** Try to save the scoreboard */
+	/** Try to save the map */
 	bool Save(void);
 
 
diff --git a/src/WorldStorage/NBTChunkSerializer.cpp b/src/WorldStorage/NBTChunkSerializer.cpp
index a2bf3f8e1..d32ef52b3 100644
--- a/src/WorldStorage/NBTChunkSerializer.cpp
+++ b/src/WorldStorage/NBTChunkSerializer.cpp
@@ -82,6 +82,18 @@ void cNBTChunkSerializer::Finish(void)
 		memset(m_BlockLight,    0, sizeof(m_BlockLight));
 		memset(m_BlockSkyLight, 0, sizeof(m_BlockSkyLight));
 	}
+
+	// Check if "Entity" and "TileEntities" lists exists. MCEdit requires this.
+	if (!m_HasHadEntity)
+	{
+		m_Writer.BeginList("Entities", TAG_Compound);
+		m_Writer.EndList();
+	}
+	if (!m_HasHadBlockEntity)
+	{
+		m_Writer.BeginList("TileEntities", TAG_Compound);
+		m_Writer.EndList();
+	}
 }
 
 
@@ -472,35 +484,35 @@ void cNBTChunkSerializer::AddMonsterEntity(cMonster * a_Monster)
 	const char * EntityClass = NULL;
 	switch (a_Monster->GetMobType())
 	{
-		case cMonster::mtBat:           EntityClass = "Bat";            break;
-		case cMonster::mtBlaze:         EntityClass = "Blaze";          break;
-		case cMonster::mtCaveSpider:    EntityClass = "CaveSpider";     break;
-		case cMonster::mtChicken:       EntityClass = "Chicken";        break;
-		case cMonster::mtCow:           EntityClass = "Cow";            break;
-		case cMonster::mtCreeper:       EntityClass = "Creeper";        break;
-		case cMonster::mtEnderDragon:   EntityClass = "EnderDragon";    break;
-		case cMonster::mtEnderman:      EntityClass = "Enderman";       break;
-		case cMonster::mtGhast:         EntityClass = "Ghast";          break;
-		case cMonster::mtGiant:         EntityClass = "Giant";          break;
-		case cMonster::mtHorse:         EntityClass = "Horse";          break;
-		case cMonster::mtIronGolem:     EntityClass = "VillagerGolem";  break;
-		case cMonster::mtMagmaCube:     EntityClass = "LavaSlime";      break;
-		case cMonster::mtMooshroom:     EntityClass = "MushroomCow";    break;
-		case cMonster::mtOcelot:        EntityClass = "Ozelot";         break;
-		case cMonster::mtPig:           EntityClass = "Pig";            break;
-		case cMonster::mtSheep:         EntityClass = "Sheep";          break;
-		case cMonster::mtSilverfish:    EntityClass = "Silverfish";     break;
-		case cMonster::mtSkeleton:      EntityClass = "Skeleton";       break;
-		case cMonster::mtSlime:         EntityClass = "Slime";          break;
-		case cMonster::mtSnowGolem:     EntityClass = "SnowMan";        break;
-		case cMonster::mtSpider:        EntityClass = "Spider";         break;
-		case cMonster::mtSquid:         EntityClass = "Squid";          break;
-		case cMonster::mtVillager:      EntityClass = "Villager";       break;
-		case cMonster::mtWitch:         EntityClass = "Witch";          break;
-		case cMonster::mtWither:        EntityClass = "WitherBoss";     break;
-		case cMonster::mtWolf:          EntityClass = "Wolf";           break;
-		case cMonster::mtZombie:        EntityClass = "Zombie";         break;
-		case cMonster::mtZombiePigman:  EntityClass = "PigZombie";      break;
+		case mtBat:           EntityClass = "Bat";            break;
+		case mtBlaze:         EntityClass = "Blaze";          break;
+		case mtCaveSpider:    EntityClass = "CaveSpider";     break;
+		case mtChicken:       EntityClass = "Chicken";        break;
+		case mtCow:           EntityClass = "Cow";            break;
+		case mtCreeper:       EntityClass = "Creeper";        break;
+		case mtEnderDragon:   EntityClass = "EnderDragon";    break;
+		case mtEnderman:      EntityClass = "Enderman";       break;
+		case mtGhast:         EntityClass = "Ghast";          break;
+		case mtGiant:         EntityClass = "Giant";          break;
+		case mtHorse:         EntityClass = "Horse";          break;
+		case mtIronGolem:     EntityClass = "VillagerGolem";  break;
+		case mtMagmaCube:     EntityClass = "LavaSlime";      break;
+		case mtMooshroom:     EntityClass = "MushroomCow";    break;
+		case mtOcelot:        EntityClass = "Ozelot";         break;
+		case mtPig:           EntityClass = "Pig";            break;
+		case mtSheep:         EntityClass = "Sheep";          break;
+		case mtSilverfish:    EntityClass = "Silverfish";     break;
+		case mtSkeleton:      EntityClass = "Skeleton";       break;
+		case mtSlime:         EntityClass = "Slime";          break;
+		case mtSnowGolem:     EntityClass = "SnowMan";        break;
+		case mtSpider:        EntityClass = "Spider";         break;
+		case mtSquid:         EntityClass = "Squid";          break;
+		case mtVillager:      EntityClass = "Villager";       break;
+		case mtWitch:         EntityClass = "Witch";          break;
+		case mtWither:        EntityClass = "WitherBoss";     break;
+		case mtWolf:          EntityClass = "Wolf";           break;
+		case mtZombie:        EntityClass = "Zombie";         break;
+		case mtZombiePigman:  EntityClass = "PigZombie";      break;
 		default:
 		{
 			ASSERT(!"Unhandled monster type");
@@ -518,26 +530,28 @@ void cNBTChunkSerializer::AddMonsterEntity(cMonster * a_Monster)
 			m_Writer.AddFloat("", a_Monster->GetDropChanceBoots());
 		m_Writer.EndList();
 		m_Writer.AddByte("CanPickUpLoot", (char)a_Monster->CanPickUpLoot());
+		m_Writer.AddString("CustomName", a_Monster->GetCustomName());
+		m_Writer.AddByte("CustomNameVisible", (char)a_Monster->IsCustomNameAlwaysVisible());
 		switch (a_Monster->GetMobType())
 		{
-			case cMonster::mtBat:
+			case mtBat:
 			{
 				m_Writer.AddByte("BatFlags", ((const cBat *)a_Monster)->IsHanging());
 				break;
 			}
-			case cMonster::mtCreeper:
+			case mtCreeper:
 			{
 				m_Writer.AddByte("powered", ((const cCreeper *)a_Monster)->IsCharged());
 				m_Writer.AddByte("ignited", ((const cCreeper *)a_Monster)->IsBlowing());
 				break;
 			}
-			case cMonster::mtEnderman:
+			case mtEnderman:
 			{
 				m_Writer.AddShort("carried",     (Int16)((const cEnderman *)a_Monster)->GetCarriedBlock());
 				m_Writer.AddShort("carriedData", (Int16)((const cEnderman *)a_Monster)->GetCarriedMeta());
 				break;
 			}
-			case cMonster::mtHorse:
+			case mtHorse:
 			{
 				const cHorse & Horse = *((const cHorse *)a_Monster);
 				m_Writer.AddByte("ChestedHorse",   Horse.IsChested());
@@ -550,38 +564,38 @@ void cNBTChunkSerializer::AddMonsterEntity(cMonster * a_Monster)
 				m_Writer.AddByte("Saddle",         Horse.IsSaddled());
 				break;
 			}
-			case cMonster::mtMagmaCube:
+			case mtMagmaCube:
 			{
 				m_Writer.AddInt("Size", ((const cMagmaCube *)a_Monster)->GetSize());
 				break;
 			}
-			case cMonster::mtSheep:
+			case mtSheep:
 			{
 				m_Writer.AddByte("Sheared", ((const cSheep *)a_Monster)->IsSheared());
 				m_Writer.AddByte("Color",   ((const cSheep *)a_Monster)->GetFurColor());
 				break;
 			}
-			case cMonster::mtSlime:
+			case mtSlime:
 			{
 				m_Writer.AddInt("Size", ((const cSlime *)a_Monster)->GetSize());
 				break;
 			}
-			case cMonster::mtSkeleton:
+			case mtSkeleton:
 			{
 				m_Writer.AddByte("SkeletonType", (((const cSkeleton *)a_Monster)->IsWither() ? 1 : 0));
 				break;
 			}
-			case cMonster::mtVillager:
+			case mtVillager:
 			{
 				m_Writer.AddInt("Profession", ((const cVillager *)a_Monster)->GetVilType());
 				break;
 			}
-			case cMonster::mtWither:
+			case mtWither:
 			{
 				m_Writer.AddInt("Invul", ((const cWither *)a_Monster)->GetWitherInvulnerableTicks());
 				break;
 			}
-			case cMonster::mtWolf:
+			case mtWolf:
 			{
 				const cWolf & Wolf = *((cWolf *)a_Monster);
 				if (!Wolf.GetOwnerName().empty())
@@ -594,10 +608,10 @@ void cNBTChunkSerializer::AddMonsterEntity(cMonster * a_Monster)
 				}
 				m_Writer.AddByte("Sitting",     Wolf.IsSitting() ? 1 : 0);
 				m_Writer.AddByte("Angry",       Wolf.IsAngry() ? 1 : 0);
-				m_Writer.AddInt("CollarColor",  Wolf.GetCollarColor());
+				m_Writer.AddByte("CollarColor", (unsigned char)Wolf.GetCollarColor());
 				break;
 			}
-			case cMonster::mtZombie:
+			case mtZombie:
 			{
 				m_Writer.AddByte("IsVillager",   (((const cZombie *)a_Monster)->IsVillagerZombie() ? 1 : 0));
 				m_Writer.AddByte("IsBaby",       (((const cZombie *)a_Monster)->IsBaby() ? 1 : 0));
@@ -637,9 +651,9 @@ void cNBTChunkSerializer::AddProjectileEntity(cProjectileEntity * a_Projectile)
 			{
 				cArrowEntity * Arrow = (cArrowEntity *)a_Projectile;
 
-				m_Writer.AddInt("xTile", (Int16)Arrow->GetBlockHit().x);
-				m_Writer.AddInt("yTile", (Int16)Arrow->GetBlockHit().y);
-				m_Writer.AddInt("zTile", (Int16)Arrow->GetBlockHit().z);
+				m_Writer.AddShort("xTile", (Int16)Arrow->GetBlockHit().x);
+				m_Writer.AddShort("yTile", (Int16)Arrow->GetBlockHit().y);
+				m_Writer.AddShort("zTile", (Int16)Arrow->GetBlockHit().z);
 				m_Writer.AddByte("pickup",   Arrow->GetPickupState());
 				m_Writer.AddDouble("damage", Arrow->GetDamageCoeff());
 				break;
@@ -777,6 +791,22 @@ void cNBTChunkSerializer::LightIsValid(bool a_IsLightValid)
 
 
 
+void cNBTChunkSerializer::HeightMap(const cChunkDef::HeightMap * a_HeightMap)
+{
+	for (int RelX = 0; RelX < cChunkDef::Width; RelX++)
+	{
+		for (int RelZ = 0; RelZ < cChunkDef::Width; RelZ++)
+		{
+			int Height = cChunkDef::GetHeight(*a_HeightMap, RelX, RelZ);
+			m_VanillaHeightMap[(RelZ << 4) | RelX] = Height;
+		}
+	}
+}
+
+
+
+
+
 void cNBTChunkSerializer::BiomeData(const cChunkDef::BiomeMap * a_BiomeMap)
 {
 	memcpy(m_Biomes, a_BiomeMap, sizeof(m_Biomes));
diff --git a/src/WorldStorage/NBTChunkSerializer.h b/src/WorldStorage/NBTChunkSerializer.h
index 7ff4b0e9b..4c066b9af 100644
--- a/src/WorldStorage/NBTChunkSerializer.h
+++ b/src/WorldStorage/NBTChunkSerializer.h
@@ -60,6 +60,7 @@ class cNBTChunkSerializer :
 public:
 	cChunkDef::BiomeMap m_Biomes;
 	unsigned char m_VanillaBiomes[cChunkDef::Width * cChunkDef::Width];
+	int m_VanillaHeightMap[cChunkDef::Width * cChunkDef::Width];
 	bool m_BiomesAreValid;
 
 
@@ -127,6 +128,7 @@ protected:
 	
 	// cChunkDataSeparateCollector overrides:
 	virtual void LightIsValid(bool a_IsLightValid) override;
+	virtual void HeightMap(const cChunkDef::HeightMap * a_HeightMap) override;
 	virtual void BiomeData(const cChunkDef::BiomeMap * a_BiomeMap) override;
 	virtual void Entity(cEntity * a_Entity) override;
 	virtual void BlockEntity(cBlockEntity * a_Entity) override;
diff --git a/src/WorldStorage/WSSAnvil.cpp b/src/WorldStorage/WSSAnvil.cpp
index fe309ce4e..092b9514c 100644
--- a/src/WorldStorage/WSSAnvil.cpp
+++ b/src/WorldStorage/WSSAnvil.cpp
@@ -51,6 +51,7 @@
 #include "../Entities/ItemFrame.h"
 
 #include "../Protocol/MojangAPI.h"
+#include "Server.h"
 
 
 
@@ -96,10 +97,26 @@ cWSSAnvil::cWSSAnvil(cWorld * a_World, int a_CompressionFactor) :
 	if (!cFile::Exists(fnam))
 	{
 		cFastNBTWriter Writer;
-		Writer.BeginCompound("");
-		Writer.AddInt("SpawnX", (int)(a_World->GetSpawnX()));
-		Writer.AddInt("SpawnY", (int)(a_World->GetSpawnY()));
-		Writer.AddInt("SpawnZ", (int)(a_World->GetSpawnZ()));
+		Writer.BeginCompound("Data");
+		Writer.AddByte("allowCommands", 1);
+		Writer.AddByte("Difficulty", 2);
+		Writer.AddByte("hardcore", cRoot::Get()->GetServer()->IsHardcore() ? 1 : 0);
+		Writer.AddByte("initialized", 1);
+		Writer.AddByte("MapFeatures", 1);
+		Writer.AddByte("raining", a_World->IsWeatherRain() ? 1 : 0);
+		Writer.AddByte("thundering", a_World->IsWeatherStorm() ? 1 : 0);
+		Writer.AddInt("GameType", (int)a_World->GetGameMode());
+		Writer.AddInt("generatorVersion", 1);
+		Writer.AddInt("SpawnX", (int)a_World->GetSpawnX());
+		Writer.AddInt("SpawnY", (int)a_World->GetSpawnY());
+		Writer.AddInt("SpawnZ", (int)a_World->GetSpawnZ());
+		Writer.AddInt("version", 19133);
+		Writer.AddLong("DayTime", (Int64)a_World->GetTimeOfDay());
+		Writer.AddLong("Time", a_World->GetWorldAge());
+		Writer.AddLong("SizeOnDisk", 0);
+		Writer.AddString("generatorName", "default");
+		Writer.AddString("generatorOptions", "");
+		Writer.AddString("LevelName", a_World->GetName());
 		Writer.EndCompound();
 		Writer.Finish();
 		
@@ -440,6 +457,7 @@ bool cWSSAnvil::SaveChunkToNBT(const cChunkCoords & a_Chunk, cFastNBTWriter & a_
 	a_Writer.BeginCompound("Level");
 	a_Writer.AddInt("xPos", a_Chunk.m_ChunkX);
 	a_Writer.AddInt("zPos", a_Chunk.m_ChunkZ);
+
 	cNBTChunkSerializer Serializer(a_Writer);
 	if (!m_World->GetChunkData(a_Chunk.m_ChunkX, a_Chunk.m_ChunkZ, Serializer))
 	{
@@ -454,7 +472,10 @@ bool cWSSAnvil::SaveChunkToNBT(const cChunkCoords & a_Chunk, cFastNBTWriter & a_
 		a_Writer.AddByteArray("Biomes",    (const char *)(Serializer.m_VanillaBiomes), ARRAYCOUNT(Serializer.m_VanillaBiomes));
 		a_Writer.AddIntArray ("MCSBiomes", (const int *)(Serializer.m_Biomes),         ARRAYCOUNT(Serializer.m_Biomes));
 	}
-	
+
+	// Save heightmap (Vanilla require this):
+	a_Writer.AddIntArray("HeightMap", (const int *)Serializer.m_VanillaHeightMap, ARRAYCOUNT(Serializer.m_VanillaHeightMap));
+
 	// Save blockdata:
 	a_Writer.BeginList("Sections", TAG_Compound);
 	size_t SliceSizeBlock  = cChunkDef::Width * cChunkDef::Width * 16;
@@ -485,6 +506,9 @@ bool cWSSAnvil::SaveChunkToNBT(const cChunkCoords & a_Chunk, cFastNBTWriter & a_
 	{
 		a_Writer.AddByte("MCSIsLightValid", 1);
 	}
+
+	// Save the world age to the chunk data. Required by vanilla and mcedit.
+	a_Writer.AddLong("LastUpdate", m_World->GetWorldAge());
 	
 	// Store the flag that the chunk has all the ores, trees, dungeons etc. MCS chunks are always complete.
 	a_Writer.AddByte("TerrainPopulated", 1);
@@ -1640,7 +1664,7 @@ void cWSSAnvil::LoadHangingFromNBT(cHangingEntity & a_Hanging, const cParsedNBT
 	if (Direction > 0)
 	{
 		Direction = (int)a_NBT.GetByte(Direction);
-		if ((Direction < 0) || (Direction > 5))
+		if ((Direction < 2) || (Direction > 5))
 		{
 			a_Hanging.SetDirection(BLOCK_FACE_NORTH);
 		}
@@ -1728,7 +1752,7 @@ void cWSSAnvil::LoadArrowFromNBT(cEntityList & a_Entities, const cParsedNBT & a_
 	
 	// Load pickup state:
 	int PickupIdx = a_NBT.FindChildByName(a_TagIdx, "pickup");
-	if (PickupIdx > 0)
+	if ((PickupIdx > 0) && (a_NBT.GetType(PickupIdx) == TAG_Byte))
 	{
 		Arrow->SetPickupState((cArrowEntity::ePickupState)a_NBT.GetByte(PickupIdx));
 	}
@@ -1736,7 +1760,7 @@ void cWSSAnvil::LoadArrowFromNBT(cEntityList & a_Entities, const cParsedNBT & a_
 	{
 		// Try the older "player" tag:
 		int PlayerIdx = a_NBT.FindChildByName(a_TagIdx, "player");
-		if (PlayerIdx > 0)
+		if ((PlayerIdx > 0) && (a_NBT.GetType(PlayerIdx) == TAG_Byte))
 		{
 			Arrow->SetPickupState((a_NBT.GetByte(PlayerIdx) == 0) ? cArrowEntity::psNoPickup : cArrowEntity::psInSurvivalOrCreative);
 		}
@@ -1744,7 +1768,7 @@ void cWSSAnvil::LoadArrowFromNBT(cEntityList & a_Entities, const cParsedNBT & a_
 	
 	// Load damage:
 	int DamageIdx = a_NBT.FindChildByName(a_TagIdx, "damage");
-	if (DamageIdx > 0)
+	if ((DamageIdx > 0) && (a_NBT.GetType(DamageIdx) == TAG_Double))
 	{
 		Arrow->SetDamageCoeff(a_NBT.GetDouble(DamageIdx));
 	}
@@ -1755,7 +1779,24 @@ void cWSSAnvil::LoadArrowFromNBT(cEntityList & a_Entities, const cParsedNBT & a_
 	int InBlockZIdx = a_NBT.FindChildByName(a_TagIdx, "zTile");
 	if ((InBlockXIdx > 0) && (InBlockYIdx > 0) && (InBlockZIdx > 0))
 	{
-		Arrow->SetBlockHit(Vector3i(a_NBT.GetInt(InBlockXIdx), a_NBT.GetInt(InBlockYIdx), a_NBT.GetInt(InBlockZIdx)));
+		if (a_NBT.GetType(InBlockXIdx) == a_NBT.GetType(InBlockYIdx) == a_NBT.GetType(InBlockZIdx))
+		{
+			switch (a_NBT.GetType(InBlockXIdx))
+			{
+				case TAG_Int:
+				{
+					// Old MCS code used this, keep reading it for compatibility reasons:
+					Arrow->SetBlockHit(Vector3i(a_NBT.GetInt(InBlockXIdx), a_NBT.GetInt(InBlockYIdx), a_NBT.GetInt(InBlockZIdx)));
+					break;
+				}
+				case TAG_Short:
+				{
+					// Vanilla uses this
+					Arrow->SetBlockHit(Vector3i((int)a_NBT.GetShort(InBlockXIdx), (int)a_NBT.GetShort(InBlockYIdx), (int)a_NBT.GetShort(InBlockZIdx)));
+					break;
+				}
+			}
+		}
 	}
 	
 	// Store the new arrow in the entities list:
@@ -2464,13 +2505,13 @@ void cWSSAnvil::LoadWolfFromNBT(cEntityList & a_Entities, const cParsedNBT & a_N
 	LoadWolfOwner(*Monster.get(), a_NBT, a_TagIdx);
 
 	int SittingIdx = a_NBT.FindChildByName(a_TagIdx, "Sitting");
-	if (SittingIdx > 0)
+	if ((SittingIdx > 0) && (a_NBT.GetType(SittingIdx) == TAG_Byte))
 	{
 		bool Sitting = ((a_NBT.GetByte(SittingIdx) == 1) ? true : false);
 		Monster->SetIsSitting(Sitting);
 	}
 	int AngryIdx = a_NBT.FindChildByName(a_TagIdx, "Angry");
-	if (AngryIdx > 0)
+	if ((AngryIdx > 0) && (a_NBT.GetType(AngryIdx) == TAG_Byte))
 	{
 		bool Angry = ((a_NBT.GetByte(AngryIdx) == 1) ? true : false);
 		Monster->SetIsAngry(Angry);
@@ -2478,8 +2519,22 @@ void cWSSAnvil::LoadWolfFromNBT(cEntityList & a_Entities, const cParsedNBT & a_N
 	int CollarColorIdx = a_NBT.FindChildByName(a_TagIdx, "CollarColor");
 	if (CollarColorIdx > 0)
 	{
-		int CollarColor = a_NBT.GetInt(CollarColorIdx);
-		Monster->SetCollarColor(CollarColor);
+		switch (a_NBT.GetType(CollarColorIdx))
+		{
+			case TAG_Byte:
+			{
+				// Vanilla uses this
+				unsigned char CollarColor = a_NBT.GetByte(CollarColorIdx);
+				Monster->SetCollarColor(CollarColor);
+				break;
+			}
+			case TAG_Int:
+			{
+				// Old MCS code used this, keep reading it for compatibility reasons:
+				Monster->SetCollarColor(a_NBT.GetInt(CollarColorIdx));
+				break;
+			}
+		}
 	}
 	a_Entities.push_back(Monster.release());
 }
@@ -2652,6 +2707,19 @@ bool cWSSAnvil::LoadMonsterBaseFromNBT(cMonster & a_Monster, const cParsedNBT &
 		a_Monster.SetCanPickUpLoot(CanPickUpLoot);
 	}
 
+	int CustomNameTag = a_NBT.FindChildByName(a_TagIdx, "CustomName");
+	if ((CustomNameTag > 0) && (a_NBT.GetType(CustomNameTag) == TAG_String))
+	{
+		a_Monster.SetCustomName(a_NBT.GetString(CustomNameTag));
+	}
+
+	int CustomNameVisibleTag = a_NBT.FindChildByName(a_TagIdx, "CustomNameVisible");
+	if ((CustomNameVisibleTag > 0) && (a_NBT.GetType(CustomNameVisibleTag) == TAG_Byte))
+	{
+		bool CustomNameVisible = (a_NBT.GetByte(CustomNameVisibleTag) == 1);
+		a_Monster.SetCustomNameAlwaysVisible(CustomNameVisible);
+	}
+
 	return true;
 }
 
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 1fbd88f04..7e21ff94f 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -5,3 +5,4 @@ enable_testing()
 include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 
 add_subdirectory(ChunkData)
+add_subdirectory(Redstone)
diff --git a/tests/Redstone/CMakeLists.txt b/tests/Redstone/CMakeLists.txt
new file mode 100644
index 000000000..ee4a7a64f
--- /dev/null
+++ b/tests/Redstone/CMakeLists.txt
@@ -0,0 +1,10 @@
+cmake_minimum_required (VERSION 2.6) 
+
+enable_testing()
+
+include_directories(${CMAKE_SOURCE_DIR}/src/)
+
+add_definitions(-DTEST_GLOBALS=1)
+
+add_executable(Redstone-creatable-exe creatable.cpp ../../src/BoundingBox.cpp)
+add_test(NAME creatable-test COMMAND Redstone-creatable-exe)
diff --git a/tests/Redstone/creatable.cpp b/tests/Redstone/creatable.cpp
new file mode 100644
index 000000000..f26ebe85c
--- /dev/null
+++ b/tests/Redstone/creatable.cpp
@@ -0,0 +1,163 @@
+
+#include "Globals.h"
+
+class MockChest;
+typedef cItemCallback<MockChest> cChestCallback;
+
+AString ItemToFullString(const cItem & a_Item)
+{
+return "";
+}
+
+class cEntity
+{
+public:
+	const Vector3d & GetPosition (void) const { return m_pos;}
+	double GetWidth (void) const { return 0; }
+	double GetHeight (void) const { return 0; }
+	static const Vector3d m_pos;
+};
+
+const Vector3d cEntity::m_pos = Vector3d(0,0,0);
+
+class cItem
+{
+public:
+	cItem(BLOCKTYPE val) {}
+};
+
+void cBlockInfo::Initialize(cBlockInfoArray & a_Info) {}
+cBlockInfo::~cBlockInfo () {}
+
+#include "Blocks/ChunkInterface.h"
+
+bool cChunkInterface::ForEachChunkInRect(int a_MinChunkX, int a_MaxChunkX, int a_MinChunkZ, int a_MaxChunkZ, cChunkDataCallback & a_Callback)
+{
+	return false;
+}
+
+bool cChunkInterface::WriteBlockArea(cBlockArea & a_Area, int a_MinBlockX, int a_MinBlockY, int a_MinBlockZ, int a_DataTypes)
+{
+	return false;
+}
+
+#include "Simulator/Simulator.inc"
+
+#include "Simulator/IncrementalRedstoneSimulator.inc"
+
+class MockWorld;
+
+
+class MockHandler
+{
+public:
+	static eBlockFace MetadataToDirection(NIBBLETYPE a_MetaData) { return BLOCK_FACE_NONE; }
+	static eBlockFace MetaDataToDirection(NIBBLETYPE a_MetaData) { return BLOCK_FACE_NONE; }
+	static eBlockFace BlockMetaDataToBlockFace(NIBBLETYPE a_MetaData) { return BLOCK_FACE_NONE; }
+	static NIBBLETYPE IsOpen(cChunkInterface & a_ChunkInterface, int a_BlockX, int a_BlockY, int a_BlockZ) { return 0; }
+	static void ExtendPiston(int a_BlockX, int a_BlockY, int a_BlockZ, MockWorld * a_World) {}
+	static void RetractPiston(int a_BlockX, int a_BlockY, int a_BlockZ, MockWorld * a_World) {}
+	static void SetOpen(cChunkInterface & a_ChunkInterface, int a_BlockX, int a_BlockY, int a_BlockZ, bool a_Open) {}
+
+};
+
+template<unsigned char val>
+class MockHandlerFetcher
+{
+public:
+	typedef MockHandler type;
+};
+
+class MockWorld 
+{
+public:
+	bool IsChunkLighted(int a_ChunkX, int a_ChunkZ) { return false; }
+	bool ForEachEntityInChunk(int a_ChunkX, int a_ChunkZ, cEntityCallback & a_Callback) { return false; }
+	
+	void QueueLightChunk(int a_ChunkX, int a_ChunkZ, cChunkCoordCallback * a_Callback = NULL) {}
+
+
+	NIBBLETYPE GetBlockSkyLight (int a_BlockX, int a_BlockY, int a_BlockZ) { return 0; }
+	
+	cPlayer * FindClosestPlayer(const Vector3d & a_Pos, float a_SightLimit, bool a_CheckLineOfSight = true) { return NULL; }
+	
+	
+	void WakeUpSimulators(int a_BlockX, int a_BlockY, int a_BlockZ) {}
+
+	void SpawnPrimedTNT(double a_X, double a_Y, double a_Z, int a_FuseTimeInSec = 80, double a_InitialVelocityCoeff = 1) {}
+
+
+	bool SetTrapdoorOpen(int a_BlockX, int a_BlockY, int a_BlockZ, bool a_Open) {return false; }
+	
+	
+	cChunkMap * GetChunkMap (void) { return NULL; }
+
+};
+
+
+class MockChunk 
+{
+public:
+	cRedstoneSimulatorChunkData * GetRedstoneSimulatorData() { return NULL; }
+	bool IsRedstoneDirty() { return true; }
+	void SetIsRedstoneDirty(bool a_Param) {}
+	
+	void GetBlockTypeMeta(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta) {}
+
+	void SetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, bool a_SendToClients = true) {}
+	void SetBlock( const Vector3i & a_RelBlockPos, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) {}
+
+	int GetPosX(void) const { return 0; }
+	int GetPosZ(void) const { return 0; }
+	
+	MockChunk * GetRelNeighborChunkAdjustCoords(int & a_RelX, int & a_RelZ) const { return NULL; }
+
+
+	BLOCKTYPE GetBlock(int a_RelX, int a_RelY, int a_RelZ) const { return 0; }
+	BLOCKTYPE GetBlock(const Vector3i & a_RelCoords) const { return 0; }
+	
+	NIBBLETYPE GetMeta(int a_RelX, int a_RelY, int a_RelZ) const { return 0; }
+	void SetMeta(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_Meta) {}
+
+
+	bool UnboundedRelGetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta) const { return false; }
+
+	bool UnboundedRelGetBlockType(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE & a_BlockType) const { return false; }
+	
+	MockChunk * GetNeighborChunk(int a_BlockX, int a_BlockZ) { return NULL; }
+
+	MockChunk * GetRelNeighborChunk(int a_RelX, int a_RelZ) { return NULL; }
+
+	bool IsValid(void) const { return false; }
+	
+	NIBBLETYPE GetTimeAlteredLight(NIBBLETYPE a_Skylight) const { return 0; }
+
+	void BroadcastSoundParticleEffect(int a_EffectID, int a_SrcX, int a_SrcY, int a_SrcZ, int a_Data, const cClientHandle * a_Exclude = NULL) {}
+	void BroadcastSoundEffect (const AString & a_SoundName, double a_X, double a_Y, double a_Z, float a_Volume, float a_Pitch, const cClientHandle * a_Exclude = NULL) {}
+
+	bool DoWithRedstonePoweredEntityAt(int a_BlockX, int a_BlockY, int a_BlockZ, cRedstonePoweredCallback & a_Callback) { return false; }
+
+	template <class T>
+	bool DoWithChestAt(int a_BlockX, int a_BlockY, int a_BlockZ, T & a_Callback)
+	{
+		return false;
+	}
+
+};
+class MockChest 
+{
+public:
+	BLOCKTYPE GetBlockType(void) const { return 0; }
+	int GetNumberOfPlayers(void) const { return 0; }
+};
+
+int main(int argc, char** argv)
+{
+	
+	
+
+	MockWorld World;
+
+	cIncrementalRedstoneSimulator<MockChunk, MockWorld, MockHandlerFetcher, MockChest> Simulator(World);
+	return 0;
+}