ocrm.bsky.social
the game where you go into mines and start crafting! but for consoles (forked directly from smartcmd's github)
1#include "stdafx.h"
2#include "Tile_SPU.h"
3#include "ChunkRebuildData.h"
4#include "GrassTile_SPU.h"
5#include "HalfSlabTile_SPU.h"
6#include "WoodSlabTile_SPU.h"
7#include "StoneSlabTile_SPU.h"
8#include "ChestTile_SPU.h"
9#include "ThinFenceTile_SPU.h"
10#include "FenceTile_SPU.h"
11#include "StairTile_SPU.h"
12#include "DirtTile_SPU.h"
13#include "DoorTile_SPU.h"
14#include "PressurePlateTile_SPU.h"
15#include "FarmTile_SPU.h"
16#include "Bush_SPU.h"
17#include "TallGrass_SPU.h"
18#include "SandStoneTile_SPU.h"
19#include "WoodTile_SPU.h"
20#include "TreeTile_SPU.h"
21#include "LeafTile_SPU.h"
22#include "CropTile_SPU.h"
23#include "ReedTile_SPU.h"
24#include "TorchTile_SPU.h"
25#include "Mushroom_SPU.h"
26#include "FurnaceTile_SPU.h"
27#include "WebTile_SPU.h"
28#include "LiquidTile_SPU.h"
29#include "FireTile_SPU.h"
30#include "Sapling_SPU.h"
31#include "GlassTile_SPU.h"
32#include "IceTile_SPU.h"
33#include "PortalTile_SPU.h"
34#include "DispenserTile_SPU.h"
35#include "RailTile_SPU.h"
36#include "DetectorRailTile_SPU.h"
37#include "TntTile_SPU.h"
38#include "BookshelfTile_SPU.h"
39#include "WorkbenchTile_SPU.h"
40#include "SignTile_SPU.h"
41#include "LadderTile_SPU.h"
42#include "ButtonTile_SPU.h"
43#include "TopSnowTile_SPU.h"
44#include "CactusTile_SPU.h"
45#include "RecordPlayerTile_SPU.h"
46#include "PumpkinTile_SPU.h"
47#include "CakeTile_SPU.h"
48#include "TrapDoorTile_SPU.h"
49#include "StoneMonsterTile_SPU.h"
50#include "SmoothStoneBrickTile_SPU.h"
51#include "HugeMushroomTile_SPU.h"
52#include "MelonTile_SPU.h"
53#include "StemTile_SPU.h"
54#include "VineTile_SPU.h"
55#include "MycelTile_SPU.h"
56#include "WaterlilyTile_SPU.h"
57#include "NetherStalkTile_SPU.h"
58#include "EnchantmentTableTile_SPU.h"
59#include "BrewingStandTile_SPU.h"
60#include "DiodeTile_SPU.h"
61#include "RedStoneDustTile_SPU.h"
62#include "FenceGateTile_SPU.h"
63#include "BedTile_SPU.h"
64#include "PistonBaseTile_SPU.h"
65#include "PistonExtensionTile_SPU.h"
66#include "PistonMovingPiece_SPU.h"
67#include "LeverTile_SPU.h"
68#include "CauldronTile_SPU.h"
69#include "TheEndPortal_SPU.h"
70#include "TheEndPortalFrameTile_SPU.h"
71#include "EggTile_SPU.h"
72#include "CocoaTile_SPU.h"
73#include "RedlightTile_SPU.h"
74#include "ClothTile_SPU.h"
75#include "SkullTile_SPU.h"
76#include "MobSpawnerTile_SPU.h"
77#include "EnderChestTile_SPU.h"
78#include "TripWireSourceTile_SPU.h"
79#include "TripWireTile_SPU.h"
80#include "WallTile_SPU.h"
81#include "FlowerPotTile_SPU.h"
82#include "CarrotTile_SPU.h"
83#include "PotatoTile_SPU.h"
84#include "QuartzBlockTile_SPU.h"
85#include "WoolCarpetTile_SPU.h"
86
87#ifdef SN_TARGET_PS3_SPU
88#include "..\Common\spu_assert.h"
89#endif
90
91#include <assert.h>
92#include <new>
93#include "AnvilTile_SPU.h"
94
95TileData_SPU* Tile_SPU::ms_pTileData = NULL;
96
97Tile_SPU Tile_SPU::m_tiles[256];
98
99
100
101int Tile_SPU::getRenderShape()
102{
103 return SHAPE_BLOCK;
104}
105
106
107void Tile_SPU::setShape(float x0, float y0, float z0, float x1, float y1, float z1)
108{
109 ms_pTileData->xx0[id] = x0;
110 ms_pTileData->yy0[id] = y0;
111 ms_pTileData->zz0[id] = z0;
112 ms_pTileData->xx1[id] = x1;
113 ms_pTileData->yy1[id] = y1;
114 ms_pTileData->zz1[id] = z1;
115}
116
117float Tile_SPU::getBrightness(ChunkRebuildData *level, int x, int y, int z)
118{
119 return level->getBrightness(x, y, z, ms_pTileData->lightEmission[id]);
120}
121//
122// // 4J - brought forward from 1.8.2
123int Tile_SPU::getLightColor(ChunkRebuildData *level, int x, int y, int z)
124{
125 int tileID = level->getTile(x, y, z);
126 return level->getLightColor(x, y, z, ms_pTileData->lightEmission[tileID]);
127}
128//
129// bool Tile_SPU::isFaceVisible(Level *level, int x, int y, int z, int f)
130// {
131// if (f == 0) y--;
132// if (f == 1) y++;
133// if (f == 2) z--;
134// if (f == 3) z++;
135// if (f == 4) x--;
136// if (f == 5) x++;
137// return !level->isSolidRenderTile(x, y, z);
138// }
139//
140bool Tile_SPU::shouldRenderFace(ChunkRebuildData *level, int x, int y, int z, int face)
141{
142 if (face == 0 && getShapeY0() > 0) return true;
143 if (face == 1 && getShapeY1() < 1) return true;
144 if (face == 2 && getShapeZ0() > 0) return true;
145 if (face == 3 && getShapeZ1() < 1) return true;
146 if (face == 4 && getShapeX0() > 0) return true;
147 if (face == 5 && getShapeX1() < 1) return true;
148 return (!level->isSolidRenderTile(x, y, z));
149}
150//
151bool Tile_SPU::isSolidFace(ChunkRebuildData *level, int x, int y, int z, int face)
152{
153 return (level->getMaterial(x, y, z)->isSolid());
154}
155
156Icon_SPU *Tile_SPU::getTexture(ChunkRebuildData *level, int x, int y, int z, int face)
157{
158 // 4J - addition here to make rendering big blocks of leaves more efficient. Normally leaves never consider themselves as solid, so
159 // blocks of leaves will have all sides of each block completely visible. Changing to consider as solid if this block is surrounded by
160 // other leaves. This is paired with another change in Level::isSolidRenderTile/Region::isSolidRenderTile which makes things solid
161 // code-wise (ie for determining visible sides of neighbouring blocks). This change just makes the texture a solid one (tex + 1) which
162 // we already have in the texture map for doing non-fancy graphics. Note: this tile-specific code is here rather than making some new virtual
163 // method in the tiles, for the sake of efficiency - I don't imagine we'll be doing much more of this sort of thing
164
165 int tileId = level->getTile(x, y, z);
166 int tileData = level->getData(x, y, z);
167
168 if( tileId == Tile_SPU::leaves_Id )
169 {
170 bool opaque = true;
171 int axo[6] = { 1,-1, 0, 0, 0, 0};
172 int ayo[6] = { 0, 0, 1,-1, 0, 0};
173 int azo[6] = { 0, 0, 0, 0, 1,-1};
174 for( int i = 0; (i < 6) && opaque; i++ )
175 {
176 int t = level->getTile(x + axo[i], y + ayo[i] , z + azo[i]);
177 if( ( t != Tile_SPU::leaves_Id ) && ( ( Tile_SPU::m_tiles[t].id == -1) || !Tile_SPU::m_tiles[t].isSolidRender() ) )
178 {
179 opaque = false;
180 }
181 }
182
183
184 Icon_SPU *icon = NULL;
185 if(opaque)
186 {
187 LeafTile_SPU::setFancy(false);
188 icon = getTexture(face, tileData);
189 LeafTile_SPU::setFancy(true);
190 }
191 else
192 {
193 icon = getTexture(face, tileData);
194 }
195 return icon;
196 }
197 return getTexture(face, tileData);
198}
199//
200Icon_SPU *Tile_SPU::getTexture(int face, int data)
201{
202 return &ms_pTileData->iconData[id];
203}
204//
205Icon_SPU *Tile_SPU::getTexture(int face)
206{
207 return getTexture(face, 0);
208}
209//
210// AABB *Tile_SPU::getTileAABB(Level *level, int x, int y, int z)
211// {
212// return AABB::newTemp(x + xx0, y + yy0, z + zz0, x + xx1, y + yy1, z + zz1);
213// }
214//
215// void Tile_SPU::addAABBs(Level *level, int x, int y, int z, AABB *box, AABBList *boxes, Entity *source)
216// {
217// AABB *aabb = getAABB(level, x, y, z);
218// if (aabb != NULL && box->intersects(aabb)) boxes->push_back(aabb);
219// }
220//
221// void Tile_SPU::addAABBs(Level *level, int x, int y, int z, AABB *box, AABBList *boxes)
222// {
223// AABB *aabb = getAABB(level, x, y, z);
224// if (aabb != NULL && box->intersects(aabb)) boxes->push_back(aabb);
225// }
226//
227// AABB *Tile_SPU::getAABB(Level *level, int x, int y, int z)
228// {
229// return AABB::newTemp(x + xx0, y + yy0, z + zz0, x + xx1, y + yy1, z + zz1);
230// }
231//
232 bool Tile_SPU::isSolidRender(bool isServerLevel)
233 {
234 return true;
235 }
236
237
238// bool Tile_SPU::mayPick(int data, bool liquid)
239// {
240// return mayPick();
241// }
242//
243// bool Tile_SPU::mayPick()
244// {
245// return true;
246// }
247//
248// void Tile_SPU::tick(Level *level, int x, int y, int z, Random *random)
249// {
250// }
251//
252// void Tile_SPU::animateTick(Level *level, int x, int y, int z, Random *random)
253// {
254// }
255//
256// void Tile_SPU::destroy(Level *level, int x, int y, int z, int data)
257// {
258// }
259//
260// void Tile_SPU::neighborChanged(Level *level, int x, int y, int z, int type)
261// {
262// }
263//
264// void Tile_SPU::addLights(Level *level, int x, int y, int z)
265// {
266// }
267//
268// int Tile_SPU::getTickDelay()
269// {
270// return 10;
271// }
272//
273// void Tile_SPU::onPlace(Level *level, int x, int y, int z)
274// {
275// }
276//
277// void Tile_SPU::onRemove(Level *level, int x, int y, int z)
278// {
279// }
280//
281// int Tile_SPU::getResourceCount(Random *random)
282// {
283// return 1;
284// }
285//
286// int Tile_SPU::getResource(int data, Random *random, int playerBonusLevel)
287// {
288// return id;
289// }
290//
291// float Tile_SPU::getDestroyProgress(shared_ptr<Player> player)
292// {
293// if (destroySpeed < 0) return 0;
294// if (!player->canDestroy(this)) return 1 / destroySpeed / 100.0f;
295// return (player->getDestroySpeed(this) / destroySpeed) / 30;
296// }
297//
298// void Tile_SPU::spawnResources(Level *level, int x, int y, int z, int data, int playerBonusLevel)
299// {
300// spawnResources(level, x, y, z, data, 1, playerBonusLevel);
301// }
302//
303// void Tile_SPU::spawnResources(Level *level, int x, int y, int z, int data, float odds, int playerBonusLevel)
304// {
305// if (level->isClientSide) return;
306// int count = getResourceCountForLootBonus(playerBonusLevel, level->random);
307// for (int i = 0; i < count; i++)
308// {
309// if (level->random->nextFloat() > odds) continue;
310// int type = getResource(data, level->random, playerBonusLevel);
311// if (type <= 0) continue;
312//
313// popResource(level, x, y, z, shared_ptr<ItemInstance>( new ItemInstance(type, 1, getSpawnResourcesAuxValue(data) ) ) );
314// }
315// }
316//
317// void Tile_SPU::popResource(Level *level, int x, int y, int z, shared_ptr<ItemInstance> itemInstance)
318// {
319// if( level->isClientSide ) return;
320//
321// float s = 0.7f;
322// double xo = level->random->nextFloat() * s + (1 - s) * 0.5;
323// double yo = level->random->nextFloat() * s + (1 - s) * 0.5;
324// double zo = level->random->nextFloat() * s + (1 - s) * 0.5;
325// shared_ptr<ItemEntity> item = shared_ptr<ItemEntity>( new ItemEntity(level, x + xo, y + yo, z + zo, itemInstance ) );
326// item->throwTime = 10;
327// level->addEntity(item);
328// }
329//
330// // Brought forward for TU7
331// void Tile_SPU::popExperience(Level *level, int x, int y, int z, int amount)
332// {
333// if (!level->isClientSide)
334// {
335// while (amount > 0)
336// {
337// int newCount = ExperienceOrb::getExperienceValue(amount);
338// amount -= newCount;
339// level->addEntity(shared_ptr<ExperienceOrb>( new ExperienceOrb(level, x + .5, y + .5, z + .5, newCount)));
340// }
341// }
342// }
343//
344// int Tile_SPU::getSpawnResourcesAuxValue(int data)
345// {
346// return 0;
347// }
348//
349// float Tile_SPU::getExplosionResistance(shared_ptr<Entity> source)
350// {
351// return explosionResistance / 5.0f;
352// }
353//
354// HitResult *Tile_SPU::clip(Level *level, int xt, int yt, int zt, Vec3 *a, Vec3 *b)
355// {
356// EnterCriticalSection(&m_csShape);
357// updateShape(level, xt, yt, zt);
358//
359// a = a->add(-xt, -yt, -zt);
360// b = b->add(-xt, -yt, -zt);
361//
362// Vec3 *xh0 = a->clipX(b, xx0);
363// Vec3 *xh1 = a->clipX(b, xx1);
364//
365// Vec3 *yh0 = a->clipY(b, yy0);
366// Vec3 *yh1 = a->clipY(b, yy1);
367//
368// Vec3 *zh0 = a->clipZ(b, zz0);
369// Vec3 *zh1 = a->clipZ(b, zz1);
370//
371// Vec3 *closest = NULL;
372//
373// if (containsX(xh0) && (closest == NULL || a->distanceTo(xh0) < a->distanceTo(closest))) closest = xh0;
374// if (containsX(xh1) && (closest == NULL || a->distanceTo(xh1) < a->distanceTo(closest))) closest = xh1;
375// if (containsY(yh0) && (closest == NULL || a->distanceTo(yh0) < a->distanceTo(closest))) closest = yh0;
376// if (containsY(yh1) && (closest == NULL || a->distanceTo(yh1) < a->distanceTo(closest))) closest = yh1;
377// if (containsZ(zh0) && (closest == NULL || a->distanceTo(zh0) < a->distanceTo(closest))) closest = zh0;
378// if (containsZ(zh1) && (closest == NULL || a->distanceTo(zh1) < a->distanceTo(closest))) closest = zh1;
379//
380// LeaveCriticalSection(&m_csShape);
381//
382// if (closest == NULL) return NULL;
383//
384// int face = -1;
385//
386// if (closest == xh0) face = 4;
387// if (closest == xh1) face = 5;
388// if (closest == yh0) face = 0;
389// if (closest == yh1) face = 1;
390// if (closest == zh0) face = 2;
391// if (closest == zh1) face = 3;
392//
393// return new HitResult(xt, yt, zt, face, closest->add(xt, yt, zt));
394// }
395//
396// bool Tile_SPU::containsX(Vec3 *v)
397// {
398// if( v == NULL) return false;
399// return v->y >= yy0 && v->y <= yy1 && v->z >= zz0 && v->z <= zz1;
400// }
401//
402// bool Tile_SPU::containsY(Vec3 *v)
403// {
404// if( v == NULL) return false;
405// return v->x >= xx0 && v->x <= xx1 && v->z >= zz0 && v->z <= zz1;
406// }
407//
408// bool Tile_SPU::containsZ(Vec3 *v)
409// {
410// if( v == NULL) return false;
411// return v->x >= xx0 && v->x <= xx1 && v->y >= yy0 && v->y <= yy1;
412// }
413//
414// void Tile_SPU::wasExploded(Level *level, int x, int y, int z)
415// {
416// }
417//
418int Tile_SPU::getRenderLayer()
419{
420 return 0;
421}
422//
423// bool Tile_SPU::mayPlace(Level *level, int x, int y, int z, int face)
424// {
425// return mayPlace(level, x, y, z);
426// }
427//
428// bool Tile_SPU::mayPlace(Level *level, int x, int y, int z)
429// {
430// int t = level->getTile(x, y, z);
431// return t == 0 || Tile_SPU::tiles[t]->material->isReplaceable();
432// }
433//
434// // 4J-PB - Adding a TestUse for tooltip display
435// bool Tile_SPU::TestUse()
436// {
437// return false;
438// }
439//
440// bool Tile_SPU::TestUse(Level *level, int x, int y, int z, shared_ptr<Player> player)
441// {
442// return false;
443// }
444//
445// bool Tile_SPU::use(Level *level, int x, int y, int z, shared_ptr<Player> player, int clickedFace, float clickX, float clickY, float clickZ, bool soundOnly/*=false*/) // 4J added soundOnly param
446// {
447// return false;
448// }
449//
450// void Tile_SPU::stepOn(Level *level, int x, int y, int z, shared_ptr<Entity> entity)
451// {
452// }
453//
454// void Tile_SPU::setPlacedOnFace(Level *level, int x, int y, int z, int face)
455// {
456// }
457//
458// void Tile_SPU::prepareRender(Level *level, int x, int y, int z)
459// {
460// }
461//
462// void Tile_SPU::attack(Level *level, int x, int y, int z, shared_ptr<Player> player)
463// {
464// }
465//
466// void Tile_SPU::handleEntityInside(Level *level, int x, int y, int z, shared_ptr<Entity> e, Vec3 *current)
467// {
468// }
469//
470void Tile_SPU::updateShape(ChunkRebuildData *level, int x, int y, int z, int forceData, TileEntity* forceEntity) // 4J added forceData, forceEntity param
471{
472}
473//
474
475int Tile_SPU::getColor(ChunkRebuildData *level, int x, int y, int z)
476{
477 return 0xffffff;
478}
479
480//
481// int Tile_SPU::getColor(LevelSource *level, int x, int y, int z, int data)
482// {
483// return 0xffffff;
484// }
485//
486// bool Tile_SPU::getSignal(LevelSource *level, int x, int y, int z)
487// {
488// return false;
489// }
490//
491// bool Tile_SPU::getSignal(LevelSource *level, int x, int y, int z, int dir)
492// {
493// return false;
494// }
495//
496// bool Tile_SPU::isSignalSource()
497// {
498// return false;
499// }
500//
501// void Tile_SPU::entityInside(Level *level, int x, int y, int z, shared_ptr<Entity> entity)
502// {
503// }
504//
505// bool Tile_SPU::getDirectSignal(Level *level, int x, int y, int z, int dir)
506// {
507// return false;
508// }
509//
510void Tile_SPU::updateDefaultShape()
511{
512}
513//
514// void Tile_SPU::playerDestroy(Level *level, shared_ptr<Player> player, int x, int y, int z, int data)
515// {
516// // 4J Stu - Special case - only record a crop destroy if is fully grown
517// if(id==Tile_SPU::crops_Id)
518// {
519// if( Tile_SPU::crops->getResource(data, NULL, 0) > 0 )
520// player->awardStat(Stats::blocksMined[id], 1);
521// }
522// else
523// {
524// player->awardStat(Stats::blocksMined[id], 1);
525// }
526// player->awardStat(Stats::totalBlocksMined, 1); // 4J : WESTY : Added for other award.
527// player->causeFoodExhaustion(FoodConstants::EXHAUSTION_MINE);
528//
529// if( id == Tile_SPU::treeTrunk_Id )
530// player->awardStat(Achievements::mineWood);
531//
532//
533// if (isCubeShaped() && !isEntityTile[id] && EnchantmentHelper::hasSilkTouch(player->inventory))
534// {
535// shared_ptr<ItemInstance> item = getSilkTouchItemInstance(data);
536// if (item != NULL)
537// {
538// popResource(level, x, y, z, item);
539// }
540// }
541// else
542// {
543// int playerBonusLevel = EnchantmentHelper::getDiggingLootBonus(player->inventory);
544// spawnResources(level, x, y, z, data, playerBonusLevel);
545// }
546// }
547//
548// shared_ptr<ItemInstance> Tile_SPU::getSilkTouchItemInstance(int data)
549// {
550// int popData = 0;
551// if (id >= 0 && id < Item::items.length && Item::items[id]->isStackedByData())
552// {
553// popData = data;
554// }
555// return shared_ptr<ItemInstance>(new ItemInstance(id, 1, popData));
556// }
557//
558// int Tile_SPU::getResourceCountForLootBonus(int bonusLevel, Random *random)
559// {
560// return getResourceCount(random);
561// }
562//
563// bool Tile_SPU::canSurvive(Level *level, int x, int y, int z)
564// {
565// return true;
566// }
567//
568// void Tile_SPU::setPlacedBy(Level *level, int x, int y, int z, shared_ptr<Mob> by)
569// {
570// }
571//
572// Tile *Tile_SPU::setDescriptionId(unsigned int id)
573// {
574// this->descriptionId = id;
575// return this;
576// }
577//
578// wstring Tile_SPU::getName()
579// {
580// return I18n::get(getDescriptionId() + L".name");
581// }
582//
583// unsigned int Tile_SPU::getDescriptionId(int iData /*= -1*/)
584// {
585// return descriptionId;
586// }
587//
588// Tile *Tile_SPU::setUseDescriptionId(unsigned int id)
589// {
590// this->useDescriptionId = id;
591// return this;
592// }
593//
594// unsigned int Tile_SPU::getUseDescriptionId()
595// {
596// return useDescriptionId;
597// }
598//
599// void Tile_SPU::triggerEvent(Level *level, int x, int y, int z, int b0, int b1)
600// {
601// }
602//
603// bool Tile_SPU::isCollectStatistics()
604// {
605// return collectStatistics;
606// }
607//
608// Tile *Tile_SPU::setNotCollectStatistics()
609// {
610// collectStatistics = false;
611// return this;
612// }
613//
614// int Tile_SPU::getPistonPushReaction()
615// {
616// return material->getPushReaction();
617// }
618//
619// // 4J - brought forward from 1.8.2
620float Tile_SPU::getShadeBrightness(ChunkRebuildData *level, int x, int y, int z)
621{
622 return level->isSolidBlockingTile(x, y, z) ? 0.2f : 1.0f;
623}
624
625Tile_SPU* Tile_SPU::createFromID( int tileID )
626{
627 if(tileID == 0)
628 return NULL;
629
630 if(m_tiles[tileID].id != -1)
631 return &m_tiles[tileID];
632
633#ifndef SN_TARGET_PS3_SPU
634 app.DebugPrintf("missing tile ID %d\n", tileID);
635#else
636 spu_print("missing tile ID %d\n", tileID);
637#endif
638 return &m_tiles[1];
639
640}
641
642Material_SPU* Tile_SPU::getMaterial()
643{
644 int matID = ms_pTileData->materialIDs[id];
645 return &ms_pTileData->materials[matID];
646}
647
648//
649// void Tile_SPU::fallOn(Level *level, int x, int y, int z, shared_ptr<Entity> entity, float fallDistance)
650// {
651// }
652//
653// void Tile_SPU::registerIcons(IconRegister *iconRegister)
654// {
655// icon = iconRegister->registerIcon(m_textureName);
656// }
657//
658// wstring Tile_SPU::getTileItemIconName()
659// {
660// return L"";
661// }
662//
663// Tile *Tile_SPU::setTextureName(const wstring &name)
664// {
665// m_textureName = name;
666// return this;
667// }
668
669
670
671void Tile_SPU::initTilePointers()
672{
673
674#define CREATE_TILE_TYPE(index, className) new (&m_tiles[index]) className(index);
675
676
677 CREATE_TILE_TYPE(grass_Id, GrassTile_SPU);
678 CREATE_TILE_TYPE(stoneSlab_Id, StoneSlabTile_SPU);
679 CREATE_TILE_TYPE(stoneSlabHalf_Id, StoneSlabTile_SPU);
680 CREATE_TILE_TYPE(woodSlab_Id, WoodSlabTile_SPU);
681 CREATE_TILE_TYPE(woodSlabHalf_Id, WoodSlabTile_SPU);
682
683 CREATE_TILE_TYPE(chest_Id, ChestTile_SPU);
684
685 CREATE_TILE_TYPE(ironFence_Id, ThinFenceTile_SPU);
686 CREATE_TILE_TYPE(thinGlass_Id, ThinFenceTile_SPU);
687
688 CREATE_TILE_TYPE(fence_Id, FenceTile_SPU);
689 CREATE_TILE_TYPE(netherFence_Id, FenceTile_SPU);
690
691 CREATE_TILE_TYPE(stairs_wood_Id, StairTile_SPU);
692 CREATE_TILE_TYPE(stairs_stone_Id, StairTile_SPU);
693 CREATE_TILE_TYPE(stairs_bricks_Id, StairTile_SPU);
694 CREATE_TILE_TYPE(stairs_stoneBrickSmooth_Id, StairTile_SPU);
695 CREATE_TILE_TYPE(stairs_netherBricks_Id, StairTile_SPU);
696 CREATE_TILE_TYPE(stairs_sandstone_Id, StairTile_SPU);
697 CREATE_TILE_TYPE(stairs_sprucewood_Id, StairTile_SPU);
698 CREATE_TILE_TYPE(stairs_birchwood_Id, StairTile_SPU);
699 CREATE_TILE_TYPE(stairs_junglewood_Id, StairTile_SPU);
700
701 CREATE_TILE_TYPE(dirt_Id, DirtTile_SPU);
702
703 CREATE_TILE_TYPE(door_iron_Id, DoorTile_SPU);
704 CREATE_TILE_TYPE(door_wood_Id, DoorTile_SPU);
705
706 CREATE_TILE_TYPE(pressurePlate_stone_Id, PressurePlateTile_SPU);
707 CREATE_TILE_TYPE(pressurePlate_wood_Id, PressurePlateTile_SPU);
708
709 CREATE_TILE_TYPE(farmland_Id, FarmTile_SPU);
710
711 CREATE_TILE_TYPE(flower_Id, Bush_SPU);
712 CREATE_TILE_TYPE(rose_Id, Bush_SPU);
713 CREATE_TILE_TYPE(deadBush_Id, Bush_SPU); // DeadBushTile
714
715 CREATE_TILE_TYPE(tallgrass_Id, TallGrass_SPU);
716
717 CREATE_TILE_TYPE(sandStone_Id, SandStoneTile_SPU);
718
719 CREATE_TILE_TYPE(wood_Id, WoodTile_SPU);
720
721 CREATE_TILE_TYPE(treeTrunk_Id, TreeTile_SPU);
722
723 CREATE_TILE_TYPE(leaves_Id, LeafTile_SPU);
724
725 CREATE_TILE_TYPE(crops_Id, CropTile_SPU);
726
727 CREATE_TILE_TYPE(reeds_Id, ReedTile_SPU);
728
729 CREATE_TILE_TYPE(torch_Id, TorchTile_SPU);
730 CREATE_TILE_TYPE(notGate_off_Id, TorchTile_SPU); // TorchTile->NotGateTile
731 CREATE_TILE_TYPE(notGate_on_Id, TorchTile_SPU); // TorchTile->NotGateTile
732
733 CREATE_TILE_TYPE(mushroom1_Id, Mushroom_SPU);
734 CREATE_TILE_TYPE(mushroom2_Id, Mushroom_SPU);
735
736 CREATE_TILE_TYPE(mobSpawner_Id, MobSpawnerTile_SPU);
737 CREATE_TILE_TYPE(musicBlock_Id, EntityTile_SPU); // MusicTile->EntityTile
738
739 CREATE_TILE_TYPE(furnace_Id, FurnaceTile_SPU);
740 CREATE_TILE_TYPE(furnace_lit_Id, FurnaceTile_SPU);
741
742 CREATE_TILE_TYPE(web_Id, WebTile_SPU);
743
744 CREATE_TILE_TYPE(water_Id, LiquidTile_SPU);
745 CREATE_TILE_TYPE(lava_Id, LiquidTile_SPU);
746 CREATE_TILE_TYPE(calmLava_Id, LiquidTile_SPU); // LiquidTileStatic
747 CREATE_TILE_TYPE(calmWater_Id, LiquidTile_SPU); // LiquidTileStatic
748
749 CREATE_TILE_TYPE(fire_Id, FireTile_SPU);
750
751 CREATE_TILE_TYPE(sapling_Id, Sapling_SPU);
752
753 CREATE_TILE_TYPE(glass_Id, GlassTile_SPU);
754
755 CREATE_TILE_TYPE(ice_Id, IceTile_SPU);
756
757 CREATE_TILE_TYPE(portalTile_Id, PortalTile_SPU);
758
759 CREATE_TILE_TYPE(dispenser_Id, DispenserTile_SPU);
760
761 CREATE_TILE_TYPE(rail_Id, RailTile_SPU);
762 CREATE_TILE_TYPE(goldenRail_Id, RailTile_SPU);
763
764 CREATE_TILE_TYPE(detectorRail_Id, DetectorRailTile_SPU);
765
766 CREATE_TILE_TYPE(tnt_Id, TntTile_SPU);
767
768 CREATE_TILE_TYPE(bookshelf_Id, BookshelfTile_SPU);
769
770 CREATE_TILE_TYPE(workBench_Id, WorkbenchTile_SPU);
771
772 CREATE_TILE_TYPE(sign_Id, SignTile_SPU);
773 CREATE_TILE_TYPE(wallSign_Id, SignTile_SPU);
774
775 CREATE_TILE_TYPE(ladder_Id, LadderTile_SPU);
776
777 CREATE_TILE_TYPE(button_stone_Id, ButtonTile_SPU);
778 CREATE_TILE_TYPE(button_wood_Id, ButtonTile_SPU);
779
780 CREATE_TILE_TYPE(topSnow_Id, TopSnowTile_SPU);
781
782 CREATE_TILE_TYPE(cactus_Id, CactusTile_SPU);
783
784 CREATE_TILE_TYPE(recordPlayer_Id, RecordPlayerTile_SPU);
785
786 CREATE_TILE_TYPE(pumpkin_Id, PumpkinTile_SPU);
787 CREATE_TILE_TYPE(litPumpkin_Id, PumpkinTile_SPU);
788
789 CREATE_TILE_TYPE(cake_Id, CakeTile_SPU);
790
791 CREATE_TILE_TYPE(trapdoor_Id, TrapDoorTile_SPU);
792
793 CREATE_TILE_TYPE(monsterStoneEgg_Id, StoneMonsterTile_SPU);
794
795 CREATE_TILE_TYPE(stoneBrickSmooth_Id, SmoothStoneBrickTile_SPU);
796
797 CREATE_TILE_TYPE(hugeMushroom1_Id, HugeMushroomTile_SPU);
798 CREATE_TILE_TYPE(hugeMushroom2_Id, HugeMushroomTile_SPU);
799
800 CREATE_TILE_TYPE(melon_Id, MelonTile_SPU);
801
802 CREATE_TILE_TYPE(melonStem_Id, StemTile_SPU);
803 CREATE_TILE_TYPE(pumpkinStem_Id, StemTile_SPU);
804
805 CREATE_TILE_TYPE(vine_Id, VineTile_SPU);
806
807 CREATE_TILE_TYPE(mycel_Id, MycelTile_SPU);
808
809 CREATE_TILE_TYPE(waterLily_Id, WaterlilyTile_SPU);
810
811 CREATE_TILE_TYPE(netherStalk_Id, NetherStalkTile_SPU);
812
813 CREATE_TILE_TYPE(enchantTable_Id, EnchantmentTableTile_SPU);
814
815 CREATE_TILE_TYPE(brewingStand_Id, BrewingStandTile_SPU);
816
817 CREATE_TILE_TYPE(diode_on_Id, DiodeTile_SPU);
818 CREATE_TILE_TYPE(diode_off_Id, DiodeTile_SPU);
819
820 CREATE_TILE_TYPE(redStoneDust_Id, RedStoneDustTile_SPU);
821
822 CREATE_TILE_TYPE(fenceGate_Id, FenceGateTile_SPU);
823
824 CREATE_TILE_TYPE(bed_Id, BedTile_SPU);
825
826 CREATE_TILE_TYPE(pistonBase_Id, PistonBaseTile_SPU);
827 CREATE_TILE_TYPE(pistonStickyBase_Id, PistonBaseTile_SPU);
828
829 CREATE_TILE_TYPE(pistonExtensionPiece_Id, PistonExtensionTile_SPU);
830
831 CREATE_TILE_TYPE(pistonMovingPiece_Id, PistonMovingPiece_SPU);
832
833 CREATE_TILE_TYPE(lever_Id, LeverTile_SPU);
834
835 CREATE_TILE_TYPE(cauldron_Id, CauldronTile_SPU);
836
837 CREATE_TILE_TYPE(endPortalTile_Id, TheEndPortal_SPU);
838
839 CREATE_TILE_TYPE(endPortalFrameTile_Id, TheEndPortalFrameTile_SPU);
840
841 CREATE_TILE_TYPE(dragonEgg_Id, EggTile_SPU);
842
843 CREATE_TILE_TYPE(cocoa_Id, CocoaTile_SPU);
844
845 CREATE_TILE_TYPE(redstoneLight_Id, RedlightTile_SPU);
846 CREATE_TILE_TYPE(redstoneLight_lit_Id, RedlightTile_SPU);
847
848 CREATE_TILE_TYPE(skull_Id, SkullTile_SPU);
849
850 // these tile types don't have any additional code that we need.
851 CREATE_TILE_TYPE(stoneBrick_Id, Tile_SPU); // Tile
852 CREATE_TILE_TYPE(lapisBlock_Id, Tile_SPU);
853 CREATE_TILE_TYPE(redBrick_Id, Tile_SPU);
854 CREATE_TILE_TYPE(mossStone_Id, Tile_SPU);
855 CREATE_TILE_TYPE(netherBrick_Id, Tile_SPU);
856 CREATE_TILE_TYPE(whiteStone_Id, Tile_SPU);
857 CREATE_TILE_TYPE(unbreakable_Id, Tile_SPU);
858 CREATE_TILE_TYPE(sponge_Id, Tile_SPU);
859 CREATE_TILE_TYPE(rock_Id, Tile_SPU); // StoneTile
860 CREATE_TILE_TYPE(obsidian_Id, Tile_SPU); // StoneTile->ObsidianTile
861 CREATE_TILE_TYPE(sand_Id, Tile_SPU); // HeavyTile
862 CREATE_TILE_TYPE(gravel_Id, Tile_SPU); // GravelTile
863 CREATE_TILE_TYPE(goldOre_Id, Tile_SPU); // OreTile
864 CREATE_TILE_TYPE(ironOre_Id, Tile_SPU); // OreTile
865 CREATE_TILE_TYPE(coalOre_Id, Tile_SPU); // OreTile
866 CREATE_TILE_TYPE(lapisOre_Id, Tile_SPU); // OreTile
867 CREATE_TILE_TYPE(diamondOre_Id, Tile_SPU); // OreTile
868 CREATE_TILE_TYPE(clay_Id, Tile_SPU); // ClayTile
869 CREATE_TILE_TYPE(redStoneOre_Id, Tile_SPU); // RedStoneOreTile
870 CREATE_TILE_TYPE(redStoneOre_lit_Id, Tile_SPU); // RedStoneOreTile
871 CREATE_TILE_TYPE(goldBlock_Id, Tile_SPU); // MetalTile
872 CREATE_TILE_TYPE(ironBlock_Id, Tile_SPU); // MetalTile
873 CREATE_TILE_TYPE(diamondBlock_Id, Tile_SPU); // MetalTile
874 CREATE_TILE_TYPE(snow_Id, Tile_SPU); // SnowTile
875 CREATE_TILE_TYPE(hellRock_Id, Tile_SPU); // HellStoneTile
876 CREATE_TILE_TYPE(hellSand_Id, Tile_SPU); // HellSandTile
877 CREATE_TILE_TYPE(lightGem_Id, Tile_SPU); // LightGemTile
878 CREATE_TILE_TYPE(aprilFoolsJoke_Id, Tile_SPU); // LockedChestTile
879
880 CREATE_TILE_TYPE(cloth_Id, ClothTile_SPU); // wool
881
882
883 CREATE_TILE_TYPE(emeraldOre_Id, Tile_SPU); // OreTile
884 CREATE_TILE_TYPE(enderChest_Id, EnderChestTile_SPU);
885 CREATE_TILE_TYPE(tripWireSource_Id, TripWireSourceTile_SPU);
886 CREATE_TILE_TYPE(tripWire_Id, TripWireTile_SPU);
887//
888 CREATE_TILE_TYPE(emeraldBlock_Id, Tile_SPU); // MetalTile
889 CREATE_TILE_TYPE(cobbleWall_Id, WallTile_SPU);
890 CREATE_TILE_TYPE(flowerPot_Id, FlowerPotTile_SPU);
891 CREATE_TILE_TYPE(carrots_Id, CarrotTile_SPU);
892 CREATE_TILE_TYPE(potatoes_Id, PotatoTile_SPU);
893 CREATE_TILE_TYPE(anvil_Id, AnvilTile_SPU);
894 CREATE_TILE_TYPE(netherQuartz_Id, Tile_SPU); // OreTile
895 CREATE_TILE_TYPE(quartzBlock_Id, QuartzBlockTile_SPU);
896 CREATE_TILE_TYPE(stairs_quartz_Id, StairTile_SPU);
897 CREATE_TILE_TYPE(woolCarpet_Id, WoolCarpetTile_SPU);
898
899};