    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 world, Random random, StructureBoundingBox structureboundingbox);
    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 iterator = par0List.iterator();
    063        StructureComponent structurecomponent;
    064
    065        do
    066        {
    067            if (!iterator.hasNext())
    068            {
    069                return null;
    070            }
    071
    072            structurecomponent = (StructureComponent)iterator.next();
    073        }
    074        while (structurecomponent.getBoundingBox() == null || !structurecomponent.getBoundingBox().intersectsWith(par1StructureBoundingBox));
    075
    076        return structurecomponent;
    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 i = Math.max(this.boundingBox.minX - 1, par2StructureBoundingBox.minX);
    090        int j = Math.max(this.boundingBox.minY - 1, par2StructureBoundingBox.minY);
    091        int k = Math.max(this.boundingBox.minZ - 1, par2StructureBoundingBox.minZ);
    092        int l = Math.min(this.boundingBox.maxX + 1, par2StructureBoundingBox.maxX);
    093        int i1 = Math.min(this.boundingBox.maxY + 1, par2StructureBoundingBox.maxY);
    094        int j1 = Math.min(this.boundingBox.maxZ + 1, par2StructureBoundingBox.maxZ);
    095        int k1;
    096        int l1;
    097        int i2;
    098
    099        for (k1 = i; k1 <= l; ++k1)
    100        {
    101            for (l1 = k; l1 <= j1; ++l1)
    102            {
    103                i2 = par1World.getBlockId(k1, j, l1);
    104
    105                if (i2 > 0 && Block.blocksList[i2].blockMaterial.isLiquid())
    106                {
    107                    return true;
    108                }
    109
    110                i2 = par1World.getBlockId(k1, i1, l1);
    111
    112                if (i2 > 0 && Block.blocksList[i2].blockMaterial.isLiquid())
    113                {
    114                    return true;
    115                }
    116            }
    117        }
    118
    119        for (k1 = i; k1 <= l; ++k1)
    120        {
    121            for (l1 = j; l1 <= i1; ++l1)
    122            {
    123                i2 = par1World.getBlockId(k1, l1, k);
    124
    125                if (i2 > 0 && Block.blocksList[i2].blockMaterial.isLiquid())
    126                {
    127                    return true;
    128                }
    129
    130                i2 = par1World.getBlockId(k1, l1, j1);
    131
    132                if (i2 > 0 && Block.blocksList[i2].blockMaterial.isLiquid())
    133                {
    134                    return true;
    135                }
    136            }
    137        }
    138
    139        for (k1 = k; k1 <= j1; ++k1)
    140        {
    141            for (l1 = j; l1 <= i1; ++l1)
    142            {
    143                i2 = par1World.getBlockId(i, l1, k1);
    144
    145                if (i2 > 0 && Block.blocksList[i2].blockMaterial.isLiquid())
    146                {
    147                    return true;
    148                }
    149
    150                i2 = par1World.getBlockId(l, l1, k1);
    151
    152                if (i2 > 0 && Block.blocksList[i2].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.doorIron.blockID)
    218        {
    219            if (par1 != Block.stairsCobblestone.blockID && par1 != Block.stairsWoodOak.blockID && par1 != Block.stairsNetherBrick.blockID && par1 != Block.stairsStoneBrick.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.oppositeSide[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.rotateOpposite[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 j1 = this.getXWithOffset(par4, par6);
    539        int k1 = this.getYWithOffset(par5);
    540        int l1 = this.getZWithOffset(par4, par6);
    541
    542        if (par7StructureBoundingBox.isVecInside(j1, k1, l1))
    543        {
    544            par1World.setBlock(j1, k1, l1, par2, par3, 2);
    545        }
    546    }
    547
    548    protected int getBlockIdAtCurrentPosition(World par1World, int par2, int par3, int par4, StructureBoundingBox par5StructureBoundingBox)
    549    {
    550        int l = this.getXWithOffset(par2, par4);
    551        int i1 = this.getYWithOffset(par3);
    552        int j1 = this.getZWithOffset(par2, par4);
    553        return !par5StructureBoundingBox.isVecInside(l, i1, j1) ? 0 : par1World.getBlockId(l, i1, j1);
    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 k1 = par4; k1 <= par7; ++k1)
    563        {
    564            for (int l1 = par3; l1 <= par6; ++l1)
    565            {
    566                for (int i2 = par5; i2 <= par8; ++i2)
    567                {
    568                    this.placeBlockAtCurrentPosition(par1World, 0, 0, l1, k1, i2, 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 i2 = par4; i2 <= par7; ++i2)
    581        {
    582            for (int j2 = par3; j2 <= par6; ++j2)
    583            {
    584                for (int k2 = par5; k2 <= par8; ++k2)
    585                {
    586                    if (!par11 || this.getBlockIdAtCurrentPosition(par1World, j2, i2, k2, par2StructureBoundingBox) != 0)
    587                    {
    588                        if (i2 != par4 && i2 != par7 && j2 != par3 && j2 != par6 && k2 != par5 && k2 != par8)
    589                        {
    590                            this.placeBlockAtCurrentPosition(par1World, par10, 0, j2, i2, k2, par2StructureBoundingBox);
    591                        }
    592                        else
    593                        {
    594                            this.placeBlockAtCurrentPosition(par1World, par9, 0, j2, i2, k2, 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 k2 = par4; k2 <= par7; ++k2)
    610        {
    611            for (int l2 = par3; l2 <= par6; ++l2)
    612            {
    613                for (int i3 = par5; i3 <= par8; ++i3)
    614                {
    615                    if (!par13 || this.getBlockIdAtCurrentPosition(par1World, l2, k2, i3, par2StructureBoundingBox) != 0)
    616                    {
    617                        if (k2 != par4 && k2 != par7 && l2 != par3 && l2 != par6 && i3 != par5 && i3 != par8)
    618                        {
    619                            this.placeBlockAtCurrentPosition(par1World, par11, par12, l2, k2, i3, par2StructureBoundingBox);
    620                        }
    621                        else
    622                        {
    623                            this.placeBlockAtCurrentPosition(par1World, par9, par10, l2, k2, i3, 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 k1 = par4; k1 <= par7; ++k1)
    638        {
    639            for (int l1 = par3; l1 <= par6; ++l1)
    640            {
    641                for (int i2 = par5; i2 <= par8; ++i2)
    642                {
    643                    if (!par9 || this.getBlockIdAtCurrentPosition(par1World, l1, k1, i2, par2StructureBoundingBox) != 0)
    644                    {
    645                        par11StructurePieceBlockSelector.selectBlocks(par10Random, l1, k1, i2, k1 == par4 || k1 == par7 || l1 == par3 || l1 == par6 || i2 == par5 || i2 == par8);
    646                        this.placeBlockAtCurrentPosition(par1World, par11StructurePieceBlockSelector.getSelectedBlockId(), par11StructurePieceBlockSelector.getSelectedBlockMetaData(), l1, k1, i2, 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 i2 = par6; i2 <= par9; ++i2)
    660        {
    661            for (int j2 = par5; j2 <= par8; ++j2)
    662            {
    663                for (int k2 = par7; k2 <= par10; ++k2)
    664                {
    665                    if (par3Random.nextFloat() <= par4 && (!par13 || this.getBlockIdAtCurrentPosition(par1World, j2, i2, k2, par2StructureBoundingBox) != 0))
    666                    {
    667                        if (i2 != par6 && i2 != par9 && j2 != par5 && j2 != par8 && k2 != par7 && k2 != par10)
    668                        {
    669                            this.placeBlockAtCurrentPosition(par1World, par12, 0, j2, i2, k2, par2StructureBoundingBox);
    670                        }
    671                        else
    672                        {
    673                            this.placeBlockAtCurrentPosition(par1World, par11, 0, j2, i2, k2, 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 f = (float)(par6 - par3 + 1);
    699        float f1 = (float)(par7 - par4 + 1);
    700        float f2 = (float)(par8 - par5 + 1);
    701        float f3 = (float)par3 + f / 2.0F;
    702        float f4 = (float)par5 + f2 / 2.0F;
    703
    704        for (int l1 = par4; l1 <= par7; ++l1)
    705        {
    706            float f5 = (float)(l1 - par4) / f1;
    707
    708            for (int i2 = par3; i2 <= par6; ++i2)
    709            {
    710                float f6 = ((float)i2 - f3) / (f * 0.5F);
    711
    712                for (int j2 = par5; j2 <= par8; ++j2)
    713                {
    714                    float f7 = ((float)j2 - f4) / (f2 * 0.5F);
    715
    716                    if (!par10 || this.getBlockIdAtCurrentPosition(par1World, i2, l1, j2, par2StructureBoundingBox) != 0)
    717                    {
    718                        float f8 = f6 * f6 + f5 * f5 + f7 * f7;
    719
    720                        if (f8 <= 1.05F)
    721                        {
    722                            this.placeBlockAtCurrentPosition(par1World, par9, 0, i2, l1, j2, 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 l = this.getXWithOffset(par2, par4);
    736        int i1 = this.getYWithOffset(par3);
    737        int j1 = this.getZWithOffset(par2, par4);
    738
    739        if (par5StructureBoundingBox.isVecInside(l, i1, j1))
    740        {
    741            while (!par1World.isAirBlock(l, i1, j1) && i1 < 255)
    742            {
    743                par1World.setBlock(l, i1, j1, 0, 0, 2);
    744                ++i1;
    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 j1 = this.getXWithOffset(par4, par6);
    755        int k1 = this.getYWithOffset(par5);
    756        int l1 = this.getZWithOffset(par4, par6);
    757
    758        if (par7StructureBoundingBox.isVecInside(j1, k1, l1))
    759        {
    760            while ((par1World.isAirBlock(j1, k1, l1) || par1World.getBlockMaterial(j1, k1, l1).isLiquid()) && k1 > 1)
    761            {
    762                par1World.setBlock(j1, k1, l1, par2, par3, 2);
    763                --k1;
    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 i1 = this.getXWithOffset(par4, par6);
    774        int j1 = this.getYWithOffset(par5);
    775        int k1 = this.getZWithOffset(par4, par6);
    776
    777        if (par2StructureBoundingBox.isVecInside(i1, j1, k1) && par1World.getBlockId(i1, j1, k1) != Block.chest.blockID)
    778        {
    779            par1World.setBlock(i1, j1, k1, Block.chest.blockID, 0, 2);
    780            TileEntityChest tileentitychest = (TileEntityChest)par1World.getBlockTileEntity(i1, j1, k1);
    781
    782            if (tileentitychest != null)
    783            {
    784                WeightedRandomChestContent.generateChestContents(par3Random, par7ArrayOfWeightedRandomChestContent, tileentitychest, 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 j1 = this.getXWithOffset(par4, par6);
    801        int k1 = this.getYWithOffset(par5);
    802        int l1 = this.getZWithOffset(par4, par6);
    803
    804        if (par2StructureBoundingBox.isVecInside(j1, k1, l1) && par1World.getBlockId(j1, k1, l1) != Block.dispenser.blockID)
    805        {
    806            par1World.setBlock(j1, k1, l1, Block.dispenser.blockID, this.getMetadataWithOffset(Block.dispenser.blockID, par7), 2);
    807            TileEntityDispenser tileentitydispenser = (TileEntityDispenser)par1World.getBlockTileEntity(j1, k1, l1);
    808
    809            if (tileentitydispenser != null)
    810            {
    811                WeightedRandomChestContent.generateDispenserContents(par3Random, par8ArrayOfWeightedRandomChestContent, tileentitydispenser, 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 i1 = this.getXWithOffset(par4, par6);
    825        int j1 = this.getYWithOffset(par5);
    826        int k1 = this.getZWithOffset(par4, par6);
    827
    828        if (par2StructureBoundingBox.isVecInside(i1, j1, k1))
    829        {
    830            ItemDoor.placeDoorBlock(par1World, i1, j1, k1, par7, Block.doorWood);
    831        }
    832    }
    833}