001    package net.minecraft.src;
002    
003    import java.util.HashMap;
004    import java.util.Iterator;
005    import java.util.List;
006    import java.util.Map;
007    import java.util.Random;
008    
009    public abstract class MapGenStructure extends MapGenBase
010    {
011        protected Map field_75053_d = new HashMap();
012    
013        /**
014         * Recursively called by generate() (generate) and optionally by itself.
015         */
016        protected void recursiveGenerate(World par1World, int par2, int par3, int par4, int par5, byte[] par6ArrayOfByte)
017        {
018            if (!this.field_75053_d.containsKey(Long.valueOf(ChunkCoordIntPair.chunkXZ2Int(par2, par3))))
019            {
020                this.rand.nextInt();
021    
022                if (this.canSpawnStructureAtCoords(par2, par3))
023                {
024                    StructureStart var7 = this.getStructureStart(par2, par3);
025                    this.field_75053_d.put(Long.valueOf(ChunkCoordIntPair.chunkXZ2Int(par2, par3)), var7);
026                }
027            }
028        }
029    
030        /**
031         * Generates structures in specified chunk next to existing structures. Does *not* generate StructureStarts.
032         */
033        public boolean generateStructuresInChunk(World par1World, Random par2Random, int par3, int par4)
034        {
035            int var5 = (par3 << 4) + 8;
036            int var6 = (par4 << 4) + 8;
037            boolean var7 = false;
038            Iterator var8 = this.field_75053_d.values().iterator();
039    
040            while (var8.hasNext())
041            {
042                StructureStart var9 = (StructureStart)var8.next();
043    
044                if (var9.isSizeableStructure() && var9.getBoundingBox().intersectsWith(var5, var6, var5 + 15, var6 + 15))
045                {
046                    var9.generateStructure(par1World, par2Random, new StructureBoundingBox(var5, var6, var5 + 15, var6 + 15));
047                    var7 = true;
048                }
049            }
050    
051            return var7;
052        }
053    
054        public boolean func_75048_a(int par1, int par2, int par3)
055        {
056            Iterator var4 = this.field_75053_d.values().iterator();
057    
058            while (var4.hasNext())
059            {
060                StructureStart var5 = (StructureStart)var4.next();
061    
062                if (var5.isSizeableStructure() && var5.getBoundingBox().intersectsWith(par1, par3, par1, par3))
063                {
064                    Iterator var6 = var5.getComponents().iterator();
065    
066                    while (var6.hasNext())
067                    {
068                        StructureComponent var7 = (StructureComponent)var6.next();
069    
070                        if (var7.getBoundingBox().isVecInside(par1, par2, par3))
071                        {
072                            return true;
073                        }
074                    }
075                }
076            }
077    
078            return false;
079        }
080    
081        public ChunkPosition getNearestInstance(World par1World, int par2, int par3, int par4)
082        {
083            this.worldObj = par1World;
084            this.rand.setSeed(par1World.getSeed());
085            long var5 = this.rand.nextLong();
086            long var7 = this.rand.nextLong();
087            long var9 = (long)(par2 >> 4) * var5;
088            long var11 = (long)(par4 >> 4) * var7;
089            this.rand.setSeed(var9 ^ var11 ^ par1World.getSeed());
090            this.recursiveGenerate(par1World, par2 >> 4, par4 >> 4, 0, 0, (byte[])null);
091            double var13 = Double.MAX_VALUE;
092            ChunkPosition var15 = null;
093            Iterator var16 = this.field_75053_d.values().iterator();
094            ChunkPosition var19;
095            int var21;
096            int var20;
097            double var23;
098            int var22;
099    
100            while (var16.hasNext())
101            {
102                StructureStart var17 = (StructureStart)var16.next();
103    
104                if (var17.isSizeableStructure())
105                {
106                    StructureComponent var18 = (StructureComponent)var17.getComponents().get(0);
107                    var19 = var18.getCenter();
108                    var20 = var19.x - par2;
109                    var21 = var19.y - par3;
110                    var22 = var19.z - par4;
111                    var23 = (double)(var20 + var20 * var21 * var21 + var22 * var22);
112    
113                    if (var23 < var13)
114                    {
115                        var13 = var23;
116                        var15 = var19;
117                    }
118                }
119            }
120    
121            if (var15 != null)
122            {
123                return var15;
124            }
125            else
126            {
127                List var25 = this.func_75052_o_();
128    
129                if (var25 != null)
130                {
131                    ChunkPosition var26 = null;
132                    Iterator var27 = var25.iterator();
133    
134                    while (var27.hasNext())
135                    {
136                        var19 = (ChunkPosition)var27.next();
137                        var20 = var19.x - par2;
138                        var21 = var19.y - par3;
139                        var22 = var19.z - par4;
140                        var23 = (double)(var20 + var20 * var21 * var21 + var22 * var22);
141    
142                        if (var23 < var13)
143                        {
144                            var13 = var23;
145                            var26 = var19;
146                        }
147                    }
148    
149                    return var26;
150                }
151                else
152                {
153                    return null;
154                }
155            }
156        }
157    
158        protected List func_75052_o_()
159        {
160            return null;
161        }
162    
163        protected abstract boolean canSpawnStructureAtCoords(int var1, int var2);
164    
165        protected abstract StructureStart getStructureStart(int var1, int var2);
166    }