    001package net.minecraft.world.gen.structure;
    002
    003import java.util.Iterator;
    004import java.util.List;
    005import java.util.Random;
    006import net.minecraft.block.Block;
    007import net.minecraft.block.BlockDirectional;
    008import net.minecraft.item.ItemDoor;
    009import net.minecraft.tileentity.TileEntityChest;
    010import net.minecraft.tileentity.TileEntityDispenser;
    011import net.minecraft.util.Direction;
    012import net.minecraft.util.Facing;
    013import net.minecraft.util.WeightedRandomChestContent;
    014import net.minecraft.world.ChunkPosition;
    015import net.minecraft.world.World;
    016
    017public abstract class StructureComponent
    018{
    019    protected StructureBoundingBox boundingBox;
    020
    021    /** switches the Coordinate System base off the Bounding Box */
    022    protected int coordBaseMode;
    023
    024    /** The type ID of this component. */
    025    protected int componentType;
    026
    027    protected StructureComponent(int par1)
    028    {
    029        this.componentType = par1;
    030        this.coordBaseMode = -1;
    031    }
    032
    033    /**
    034     * Initiates construction of the Structure Component picked, at the current Location of StructGen
    035     */
    036    public void buildComponent(StructureComponent par1StructureComponent, List par2List, Random par3Random) {}
    037
    038    /**
    039     * second Part of Structure generating, this for example places Spiderwebs, Mob Spawners, it closes Mineshafts at
    040     * the end, it adds Fences...
    041     */
    042    public abstract boolean addComponentParts(World var1, Random var2, StructureBoundingBox var3);
    043
    044    public StructureBoundingBox getBoundingBox()
    045    {
    046        return this.boundingBox;
    047    }
    048
    049    /**
    050     * Returns the component type ID of this component.
    051     */
    052    public int getComponentType()
    053    {
    054        return this.componentType;
    055    }
    056
    057    /**
    058     * Discover if bounding box can fit within the current bounding box object.
    059     */
    060    public static StructureComponent findIntersecting(List par0List, StructureBoundingBox par1StructureBoundingBox)
    061    {
    062        Iterator var2 = par0List.iterator();
    063        StructureComponent var3;
    064
    065        do
    066        {
    067            if (!var2.hasNext())
    068            {
    069                return null;
    070            }
    071
    072            var3 = (StructureComponent)var2.next();
    073        }
    074        while (var3.getBoundingBox() == null || !var3.getBoundingBox().intersectsWith(par1StructureBoundingBox));
    075
    076        return var3;
    077    }
    078
    079    public ChunkPosition getCenter()
    080    {
    081        return new ChunkPosition(this.boundingBox.getCenterX(), this.boundingBox.getCenterY(), this.boundingBox.getCenterZ());
    082    }
    083
    084    /**
    085     * checks the entire StructureBoundingBox for Liquids
    086     */
    087    protected boolean isLiquidInStructureBoundingBox(World par1World, StructureBoundingBox par2StructureBoundingBox)
    088    {
    089        int var3 = Math.max(this.boundingBox.minX - 1, par2StructureBoundingBox.minX);
    090        int var4 = Math.max(this.boundingBox.minY - 1, par2StructureBoundingBox.minY);
    091        int var5 = Math.max(this.boundingBox.minZ - 1, par2StructureBoundingBox.minZ);
    092        int var6 = Math.min(this.boundingBox.maxX + 1, par2StructureBoundingBox.maxX);
    093        int var7 = Math.min(this.boundingBox.maxY + 1, par2StructureBoundingBox.maxY);
    094        int var8 = Math.min(this.boundingBox.maxZ + 1, par2StructureBoundingBox.maxZ);
    095        int var9;
    096        int var10;
    097        int var11;
    098
    099        for (var9 = var3; var9 <= var6; ++var9)
    100        {
    101            for (var10 = var5; var10 <= var8; ++var10)
    102            {
    103                var11 = par1World.getBlockId(var9, var4, var10);
    104
    105                if (var11 > 0 && Block.blocksList[var11].blockMaterial.isLiquid())
    106                {
    107                    return true;
    108                }
    109
    110                var11 = par1World.getBlockId(var9, var7, var10);
    111
    112                if (var11 > 0 && Block.blocksList[var11].blockMaterial.isLiquid())
    113                {
    114                    return true;
    115                }
    116            }
    117        }
    118
    119        for (var9 = var3; var9 <= var6; ++var9)
    120        {
    121            for (var10 = var4; var10 <= var7; ++var10)
    122            {
    123                var11 = par1World.getBlockId(var9, var10, var5);
    124
    125                if (var11 > 0 && Block.blocksList[var11].blockMaterial.isLiquid())
    126                {
    127                    return true;
    128                }
    129
    130                var11 = par1World.getBlockId(var9, var10, var8);
    131
    132                if (var11 > 0 && Block.blocksList[var11].blockMaterial.isLiquid())
    133                {
    134                    return true;
    135                }
    136            }
    137        }
    138
    139        for (var9 = var5; var9 <= var8; ++var9)
    140        {
    141            for (var10 = var4; var10 <= var7; ++var10)
    142            {
    143                var11 = par1World.getBlockId(var3, var10, var9);
    144
    145                if (var11 > 0 && Block.blocksList[var11].blockMaterial.isLiquid())
    146                {
    147                    return true;
    148                }
    149
    150                var11 = par1World.getBlockId(var6, var10, var9);
    151
    152                if (var11 > 0 && Block.blocksList[var11].blockMaterial.isLiquid())
    153                {
    154                    return true;
    155                }
    156            }
    157        }
    158
    159        return false;
    160    }
    161
    162    protected int getXWithOffset(int par1, int par2)
    163    {
    164        switch (this.coordBaseMode)
    165        {
    166            case 0:
    167            case 2:
    168                return this.boundingBox.minX + par1;
    169            case 1:
    170                return this.boundingBox.maxX - par2;
    171            case 3:
    172                return this.boundingBox.minX + par2;
    173            default:
    174                return par1;
    175        }
    176    }
    177
    178    protected int getYWithOffset(int par1)
    179    {
    180        return this.coordBaseMode == -1 ? par1 : par1 + this.boundingBox.minY;
    181    }
    182
    183    protected int getZWithOffset(int par1, int par2)
    184    {
    185        switch (this.coordBaseMode)
    186        {
    187            case 0:
    188                return this.boundingBox.minZ + par2;
    189            case 1:
    190            case 3:
    191                return this.boundingBox.minZ + par1;
    192            case 2:
    193                return this.boundingBox.maxZ - par2;
    194            default:
    195                return par2;
    196        }
    197    }
    198
    199    /**
    200     * Returns the direction-shifted metadata for blocks that require orientation, e.g. doors, stairs, ladders.
    201     * Parameters: block ID, original metadata
    202     */
    203    protected int getMetadataWithOffset(int par1, int par2)
    204    {
    205        if (par1 == Block.rail.blockID)
    206        {
    207            if (this.coordBaseMode == 1 || this.coordBaseMode == 3)
    208            {
    209                if (par2 == 1)
    210                {
    211                    return 0;
    212                }
    213
    214                return 1;
    215            }
    216        }
    217        else if (par1 != Block.doorWood.blockID && par1 != Block.doorSteel.blockID)
    218        {
    219            if (par1 != Block.stairCompactCobblestone.blockID && par1 != Block.stairCompactPlanks.blockID && par1 != Block.stairsNetherBrick.blockID && par1 != Block.stairsStoneBrickSmooth.blockID && par1 != Block.stairsSandStone.blockID)
    220            {
    221                if (par1 == Block.ladder.blockID)
    222                {
    223                    if (this.coordBaseMode == 0)
    224                    {
    225                        if (par2 == 2)
    226                        {
    227                            return 3;
    228                        }
    229
    230                        if (par2 == 3)
    231                        {
    232                            return 2;
    233                        }
    234                    }
    235                    else if (this.coordBaseMode == 1)
    236                    {
    237                        if (par2 == 2)
    238                        {
    239                            return 4;
    240                        }
    241
    242                        if (par2 == 3)
    243                        {
    244                            return 5;
    245                        }
    246
    247                        if (par2 == 4)
    248                        {
    249                            return 2;
    250                        }
    251
    252                        if (par2 == 5)
    253                        {
    254                            return 3;
    255                        }
    256                    }
    257                    else if (this.coordBaseMode == 3)
    258                    {
    259                        if (par2 == 2)
    260                        {
    261                            return 5;
    262                        }
    263
    264                        if (par2 == 3)
    265                        {
    266                            return 4;
    267                        }
    268
    269                        if (par2 == 4)
    270                        {
    271                            return 2;
    272                        }
    273
    274                        if (par2 == 5)
    275                        {
    276                            return 3;
    277                        }
    278                    }
    279                }
    280                else if (par1 == Block.stoneButton.blockID)
    281                {
    282                    if (this.coordBaseMode == 0)
    283                    {
    284                        if (par2 == 3)
    285                        {
    286                            return 4;
    287                        }
    288
    289                        if (par2 == 4)
    290                        {
    291                            return 3;
    292                        }
    293                    }
    294                    else if (this.coordBaseMode == 1)
    295                    {
    296                        if (par2 == 3)
    297                        {
    298                            return 1;
    299                        }
    300
    301                        if (par2 == 4)
    302                        {
    303                            return 2;
    304                        }
    305
    306                        if (par2 == 2)
    307                        {
    308                            return 3;
    309                        }
    310
    311                        if (par2 == 1)
    312                        {
    313                            return 4;
    314                        }
    315                    }
    316                    else if (this.coordBaseMode == 3)
    317                    {
    318                        if (par2 == 3)
    319                        {
    320                            return 2;
    321                        }
    322
    323                        if (par2 == 4)
    324                        {
    325                            return 1;
    326                        }
    327
    328                        if (par2 == 2)
    329                        {
    330                            return 3;
    331                        }
    332
    333                        if (par2 == 1)
    334                        {
    335                            return 4;
    336                        }
    337                    }
    338                }
    339                else if (par1 != Block.tripWireSource.blockID && (Block.blocksList[par1] == null || !(Block.blocksList[par1] instanceof BlockDirectional)))
    340                {
    341                    if (par1 == Block.pistonBase.blockID || par1 == Block.pistonStickyBase.blockID || par1 == Block.lever.blockID || par1 == Block.dispenser.blockID)
    342                    {
    343                        if (this.coordBaseMode == 0)
    344                        {
    345                            if (par2 == 2 || par2 == 3)
    346                            {
    347                                return Facing.faceToSide[par2];
    348                            }
    349                        }
    350                        else if (this.coordBaseMode == 1)
    351                        {
    352                            if (par2 == 2)
    353                            {
    354                                return 4;
    355                            }
    356
    357                            if (par2 == 3)
    358                            {
    359                                return 5;
    360                            }
    361
    362                            if (par2 == 4)
    363                            {
    364                                return 2;
    365                            }
    366
    367                            if (par2 == 5)
    368                            {
    369                                return 3;
    370                            }
    371                        }
    372                        else if (this.coordBaseMode == 3)
    373                        {
    374                            if (par2 == 2)
    375                            {
    376                                return 5;
    377                            }
    378
    379                            if (par2 == 3)
    380                            {
    381                                return 4;
    382                            }
    383
    384                            if (par2 == 4)
    385                            {
    386                                return 2;
    387                            }
    388
    389                            if (par2 == 5)
    390                            {
    391                                return 3;
    392                            }
    393                        }
    394                    }
    395                }
    396                else if (this.coordBaseMode == 0)
    397                {
    398                    if (par2 == 0 || par2 == 2)
    399                    {
    400                        return Direction.footInvisibleFaceRemap[par2];
    401                    }
    402                }
    403                else if (this.coordBaseMode == 1)
    404                {
    405                    if (par2 == 2)
    406                    {
    407                        return 1;
    408                    }
    409
    410                    if (par2 == 0)
    411                    {
    412                        return 3;
    413                    }
    414
    415                    if (par2 == 1)
    416                    {
    417                        return 2;
    418                    }
    419
    420                    if (par2 == 3)
    421                    {
    422                        return 0;
    423                    }
    424                }
    425                else if (this.coordBaseMode == 3)
    426                {
    427                    if (par2 == 2)
    428                    {
    429                        return 3;
    430                    }
    431
    432                    if (par2 == 0)
    433                    {
    434                        return 1;
    435                    }
    436
    437                    if (par2 == 1)
    438                    {
    439                        return 2;
    440                    }
    441
    442                    if (par2 == 3)
    443                    {
    444                        return 0;
    445                    }
    446                }
    447            }
    448            else if (this.coordBaseMode == 0)
    449            {
    450                if (par2 == 2)
    451                {
    452                    return 3;
    453                }
    454
    455                if (par2 == 3)
    456                {
    457                    return 2;
    458                }
    459            }
    460            else if (this.coordBaseMode == 1)
    461            {
    462                if (par2 == 0)
    463                {
    464                    return 2;
    465                }
    466
    467                if (par2 == 1)
    468                {
    469                    return 3;
    470                }
    471
    472                if (par2 == 2)
    473                {
    474                    return 0;
    475                }
    476
    477                if (par2 == 3)
    478                {
    479                    return 1;
    480                }
    481            }
    482            else if (this.coordBaseMode == 3)
    483            {
    484                if (par2 == 0)
    485                {
    486                    return 2;
    487                }
    488
    489                if (par2 == 1)
    490                {
    491                    return 3;
    492                }
    493
    494                if (par2 == 2)
    495                {
    496                    return 1;
    497                }
    498
    499                if (par2 == 3)
    500                {
    501                    return 0;
    502                }
    503            }
    504        }
    505        else if (this.coordBaseMode == 0)
    506        {
    507            if (par2 == 0)
    508            {
    509                return 2;
    510            }
    511
    512            if (par2 == 2)
    513            {
    514                return 0;
    515            }
    516        }
    517        else
    518        {
    519            if (this.coordBaseMode == 1)
    520            {
    521                return par2 + 1 & 3;
    522            }
    523
    524            if (this.coordBaseMode == 3)
    525            {
    526                return par2 + 3 & 3;
    527            }
    528        }
    529
    530        return par2;
    531    }
    532
    533    /**
    534     * current Position depends on currently set Coordinates mode, is computed here
    535     */
    536    protected void placeBlockAtCurrentPosition(World par1World, int par2, int par3, int par4, int par5, int par6, StructureBoundingBox par7StructureBoundingBox)
    537    {
    538        int var8 = this.getXWithOffset(par4, par6);
    539        int var9 = this.getYWithOffset(par5);
    540        int var10 = this.getZWithOffset(par4, par6);
    541
    542        if (par7StructureBoundingBox.isVecInside(var8, var9, var10))
    543        {
    544            par1World.setBlockAndMetadata(var8, var9, var10, par2, par3);
    545        }
    546    }
    547
    548    protected int getBlockIdAtCurrentPosition(World par1World, int par2, int par3, int par4, StructureBoundingBox par5StructureBoundingBox)
    549    {
    550        int var6 = this.getXWithOffset(par2, par4);
    551        int var7 = this.getYWithOffset(par3);
    552        int var8 = this.getZWithOffset(par2, par4);
    553        return !par5StructureBoundingBox.isVecInside(var6, var7, var8) ? 0 : par1World.getBlockId(var6, var7, var8);
    554    }
    555
    556    /**
    557     * arguments: (World worldObj, StructureBoundingBox structBB, int minX, int minY, int minZ, int maxX, int maxY, int
    558     * maxZ)
    559     */
    560    protected void fillWithAir(World par1World, StructureBoundingBox par2StructureBoundingBox, int par3, int par4, int par5, int par6, int par7, int par8)
    561    {
    562        for (int var9 = par4; var9 <= par7; ++var9)
    563        {
    564            for (int var10 = par3; var10 <= par6; ++var10)
    565            {
    566                for (int var11 = par5; var11 <= par8; ++var11)
    567                {
    568                    this.placeBlockAtCurrentPosition(par1World, 0, 0, var10, var9, var11, par2StructureBoundingBox);
    569                }
    570            }
    571        }
    572    }
    573
    574    /**
    575     * arguments: (World worldObj, StructureBoundingBox structBB, int minX, int minY, int minZ, int maxX, int maxY, int
    576     * maxZ, int placeBlockId, int replaceBlockId, boolean alwaysreplace)
    577     */
    578    protected void fillWithBlocks(World par1World, StructureBoundingBox par2StructureBoundingBox, int par3, int par4, int par5, int par6, int par7, int par8, int par9, int par10, boolean par11)
    579    {
    580        for (int var12 = par4; var12 <= par7; ++var12)
    581        {
    582            for (int var13 = par3; var13 <= par6; ++var13)
    583            {
    584                for (int var14 = par5; var14 <= par8; ++var14)
    585                {
    586                    if (!par11 || this.getBlockIdAtCurrentPosition(par1World, var13, var12, var14, par2StructureBoundingBox) != 0)
    587                    {
    588                        if (var12 != par4 && var12 != par7 && var13 != par3 && var13 != par6 && var14 != par5 && var14 != par8)
    589                        {
    590                            this.placeBlockAtCurrentPosition(par1World, par10, 0, var13, var12, var14, par2StructureBoundingBox);
    591                        }
    592                        else
    593                        {
    594                            this.placeBlockAtCurrentPosition(par1World, par9, 0, var13, var12, var14, par2StructureBoundingBox);
    595                        }
    596                    }
    597                }
    598            }
    599        }
    600    }
    601
    602    /**
    603     * arguments: (World worldObj, StructureBoundingBox structBB, int minX, int minY, int minZ, int maxX, int maxY, int
    604     * maxZ, int placeBlockId, int placeBlockMetadata, int replaceBlockId, int replaceBlockMetadata, boolean
    605     * alwaysreplace)
    606     */
    607    protected void fillWithMetadataBlocks(World par1World, StructureBoundingBox par2StructureBoundingBox, int par3, int par4, int par5, int par6, int par7, int par8, int par9, int par10, int par11, int par12, boolean par13)
    608    {
    609        for (int var14 = par4; var14 <= par7; ++var14)
    610        {
    611            for (int var15 = par3; var15 <= par6; ++var15)
    612            {
    613                for (int var16 = par5; var16 <= par8; ++var16)
    614                {
    615                    if (!par13 || this.getBlockIdAtCurrentPosition(par1World, var15, var14, var16, par2StructureBoundingBox) != 0)
    616                    {
    617                        if (var14 != par4 && var14 != par7 && var15 != par3 && var15 != par6 && var16 != par5 && var16 != par8)
    618                        {
    619                            this.placeBlockAtCurrentPosition(par1World, par11, par12, var15, var14, var16, par2StructureBoundingBox);
    620                        }
    621                        else
    622                        {
    623                            this.placeBlockAtCurrentPosition(par1World, par9, par10, var15, var14, var16, par2StructureBoundingBox);
    624                        }
    625                    }
    626                }
    627            }
    628        }
    629    }
    630
    631    /**
    632     * arguments: World worldObj, StructureBoundingBox structBB, int minX, int minY, int minZ, int maxX, int maxY, int
    633     * maxZ, boolean alwaysreplace, Random rand, StructurePieceBlockSelector blockselector
    634     */
    635    protected void fillWithRandomizedBlocks(World par1World, StructureBoundingBox par2StructureBoundingBox, int par3, int par4, int par5, int par6, int par7, int par8, boolean par9, Random par10Random, StructurePieceBlockSelector par11StructurePieceBlockSelector)
    636    {
    637        for (int var12 = par4; var12 <= par7; ++var12)
    638        {
    639            for (int var13 = par3; var13 <= par6; ++var13)
    640            {
    641                for (int var14 = par5; var14 <= par8; ++var14)
    642                {
    643                    if (!par9 || this.getBlockIdAtCurrentPosition(par1World, var13, var12, var14, par2StructureBoundingBox) != 0)
    644                    {
    645                        par11StructurePieceBlockSelector.selectBlocks(par10Random, var13, var12, var14, var12 == par4 || var12 == par7 || var13 == par3 || var13 == par6 || var14 == par5 || var14 == par8);
    646                        this.placeBlockAtCurrentPosition(par1World, par11StructurePieceBlockSelector.getSelectedBlockId(), par11StructurePieceBlockSelector.getSelectedBlockMetaData(), var13, var12, var14, par2StructureBoundingBox);
    647                    }
    648                }
    649            }
    650        }
    651    }
    652
    653    /**
    654     * arguments: World worldObj, StructureBoundingBox structBB, Random rand, float randLimit, int minX, int minY, int
    655     * minZ, int maxX, int maxY, int maxZ, int olaceBlockId, int replaceBlockId, boolean alwaysreplace
    656     */
    657    protected void randomlyFillWithBlocks(World par1World, StructureBoundingBox par2StructureBoundingBox, Random par3Random, float par4, int par5, int par6, int par7, int par8, int par9, int par10, int par11, int par12, boolean par13)
    658    {
    659        for (int var14 = par6; var14 <= par9; ++var14)
    660        {
    661            for (int var15 = par5; var15 <= par8; ++var15)
    662            {
    663                for (int var16 = par7; var16 <= par10; ++var16)
    664                {
    665                    if (par3Random.nextFloat() <= par4 && (!par13 || this.getBlockIdAtCurrentPosition(par1World, var15, var14, var16, par2StructureBoundingBox) != 0))
    666                    {
    667                        if (var14 != par6 && var14 != par9 && var15 != par5 && var15 != par8 && var16 != par7 && var16 != par10)
    668                        {
    669                            this.placeBlockAtCurrentPosition(par1World, par12, 0, var15, var14, var16, par2StructureBoundingBox);
    670                        }
    671                        else
    672                        {
    673                            this.placeBlockAtCurrentPosition(par1World, par11, 0, var15, var14, var16, par2StructureBoundingBox);
    674                        }
    675                    }
    676                }
    677            }
    678        }
    679    }
    680
    681    /**
    682     * Randomly decides if placing or not. Used for Decoration such as Torches and Spiderwebs
    683     */
    684    protected void randomlyPlaceBlock(World par1World, StructureBoundingBox par2StructureBoundingBox, Random par3Random, float par4, int par5, int par6, int par7, int par8, int par9)
    685    {
    686        if (par3Random.nextFloat() < par4)
    687        {
    688            this.placeBlockAtCurrentPosition(par1World, par8, par9, par5, par6, par7, par2StructureBoundingBox);
    689        }
    690    }
    691
    692    /**
    693     * arguments: World worldObj, StructureBoundingBox structBB, int minX, int minY, int minZ, int maxX, int maxY, int
    694     * maxZ, int placeBlockId, boolean alwaysreplace
    695     */
    696    protected void randomlyRareFillWithBlocks(World par1World, StructureBoundingBox par2StructureBoundingBox, int par3, int par4, int par5, int par6, int par7, int par8, int par9, boolean par10)
    697    {
    698        float var11 = (float)(par6 - par3 + 1);
    699        float var12 = (float)(par7 - par4 + 1);
    700        float var13 = (float)(par8 - par5 + 1);
    701        float var14 = (float)par3 + var11 / 2.0F;
    702        float var15 = (float)par5 + var13 / 2.0F;
    703
    704        for (int var16 = par4; var16 <= par7; ++var16)
    705        {
    706            float var17 = (float)(var16 - par4) / var12;
    707
    708            for (int var18 = par3; var18 <= par6; ++var18)
    709            {
    710                float var19 = ((float)var18 - var14) / (var11 * 0.5F);
    711
    712                for (int var20 = par5; var20 <= par8; ++var20)
    713                {
    714                    float var21 = ((float)var20 - var15) / (var13 * 0.5F);
    715
    716                    if (!par10 || this.getBlockIdAtCurrentPosition(par1World, var18, var16, var20, par2StructureBoundingBox) != 0)
    717                    {
    718                        float var22 = var19 * var19 + var17 * var17 + var21 * var21;
    719
    720                        if (var22 <= 1.05F)
    721                        {
    722                            this.placeBlockAtCurrentPosition(par1World, par9, 0, var18, var16, var20, par2StructureBoundingBox);
    723                        }
    724                    }
    725                }
    726            }
    727        }
    728    }
    729
    730    /**
    731     * Deletes all continuous blocks from selected position upwards. Stops at hitting air.
    732     */
    733    protected void clearCurrentPositionBlocksUpwards(World par1World, int par2, int par3, int par4, StructureBoundingBox par5StructureBoundingBox)
    734    {
    735        int var6 = this.getXWithOffset(par2, par4);
    736        int var7 = this.getYWithOffset(par3);
    737        int var8 = this.getZWithOffset(par2, par4);
    738
    739        if (par5StructureBoundingBox.isVecInside(var6, var7, var8))
    740        {
    741            while (!par1World.isAirBlock(var6, var7, var8) && var7 < 255)
    742            {
    743                par1World.setBlockAndMetadata(var6, var7, var8, 0, 0);
    744                ++var7;
    745            }
    746        }
    747    }
    748
    749    /**
    750     * Overwrites air and liquids from selected position downwards, stops at hitting anything else.
    751     */
    752    protected void fillCurrentPositionBlocksDownwards(World par1World, int par2, int par3, int par4, int par5, int par6, StructureBoundingBox par7StructureBoundingBox)
    753    {
    754        int var8 = this.getXWithOffset(par4, par6);
    755        int var9 = this.getYWithOffset(par5);
    756        int var10 = this.getZWithOffset(par4, par6);
    757
    758        if (par7StructureBoundingBox.isVecInside(var8, var9, var10))
    759        {
    760            while ((par1World.isAirBlock(var8, var9, var10) || par1World.getBlockMaterial(var8, var9, var10).isLiquid()) && var9 > 1)
    761            {
    762                par1World.setBlockAndMetadata(var8, var9, var10, par2, par3);
    763                --var9;
    764            }
    765        }
    766    }
    767
    768    /**
    769     * Used to generate chests with items in it. ex: Temple Chests, Village Blacksmith Chests, Mineshaft Chests.
    770     */
    771    protected boolean generateStructureChestContents(World par1World, StructureBoundingBox par2StructureBoundingBox, Random par3Random, int par4, int par5, int par6, WeightedRandomChestContent[] par7ArrayOfWeightedRandomChestContent, int par8)
    772    {
    773        int var9 = this.getXWithOffset(par4, par6);
    774        int var10 = this.getYWithOffset(par5);
    775        int var11 = this.getZWithOffset(par4, par6);
    776
    777        if (par2StructureBoundingBox.isVecInside(var9, var10, var11) && par1World.getBlockId(var9, var10, var11) != Block.chest.blockID)
    778        {
    779            par1World.setBlockWithNotify(var9, var10, var11, Block.chest.blockID);
    780            TileEntityChest var12 = (TileEntityChest)par1World.getBlockTileEntity(var9, var10, var11);
    781
    782            if (var12 != null)
    783            {
    784                WeightedRandomChestContent.generateChestContents(par3Random, par7ArrayOfWeightedRandomChestContent, var12, par8);
    785            }
    786
    787            return true;
    788        }
    789        else
    790        {
    791            return false;
    792        }
    793    }
    794
    795    /**
    796     * Used to generate dispenser contents for structures. ex: Jungle Temples.
    797     */
    798    protected boolean generateStructureDispenserContents(World par1World, StructureBoundingBox par2StructureBoundingBox, Random par3Random, int par4, int par5, int par6, int par7, WeightedRandomChestContent[] par8ArrayOfWeightedRandomChestContent, int par9)
    799    {
    800        int var10 = this.getXWithOffset(par4, par6);
    801        int var11 = this.getYWithOffset(par5);
    802        int var12 = this.getZWithOffset(par4, par6);
    803
    804        if (par2StructureBoundingBox.isVecInside(var10, var11, var12) && par1World.getBlockId(var10, var11, var12) != Block.dispenser.blockID)
    805        {
    806            par1World.setBlockAndMetadataWithNotify(var10, var11, var12, Block.dispenser.blockID, this.getMetadataWithOffset(Block.dispenser.blockID, par7));
    807            TileEntityDispenser var13 = (TileEntityDispenser)par1World.getBlockTileEntity(var10, var11, var12);
    808
    809            if (var13 != null)
    810            {
    811                WeightedRandomChestContent.generateDispenserContents(par3Random, par8ArrayOfWeightedRandomChestContent, var13, par9);
    812            }
    813
    814            return true;
    815        }
    816        else
    817        {
    818            return false;
    819        }
    820    }
    821
    822    protected void placeDoorAtCurrentPosition(World par1World, StructureBoundingBox par2StructureBoundingBox, Random par3Random, int par4, int par5, int par6, int par7)
    823    {
    824        int var8 = this.getXWithOffset(par4, par6);
    825        int var9 = this.getYWithOffset(par5);
    826        int var10 = this.getZWithOffset(par4, par6);
    827
    828        if (par2StructureBoundingBox.isVecInside(var8, var9, var10))
    829        {
    830            ItemDoor.placeDoorBlock(par1World, var8, var9, var10, par7, Block.doorWood);
    831        }
    832    }
    833}