001 package net.minecraft.src;
002
003 import java.util.Random;
004
005 public class BlockFlowing extends BlockFluid
006 {
007 /**
008 * Number of horizontally adjacent liquid source blocks. Diagonal doesn't count. Only source blocks of the same
009 * liquid as the block using the field are counted.
010 */
011 int numAdjacentSources = 0;
012
013 /**
014 * Indicates whether the flow direction is optimal. Each array index corresponds to one of the four cardinal
015 * directions.
016 */
017 boolean[] isOptimalFlowDirection = new boolean[4];
018
019 /**
020 * The estimated cost to flow in a given direction from the current point. Each array index corresponds to one of
021 * the four cardinal directions.
022 */
023 int[] flowCost = new int[4];
024
025 protected BlockFlowing(int par1, Material par2Material)
026 {
027 super(par1, par2Material);
028 }
029
030 /**
031 * Updates the flow for the BlockFlowing object.
032 */
033 private void updateFlow(World par1World, int par2, int par3, int par4)
034 {
035 int var5 = par1World.getBlockMetadata(par2, par3, par4);
036 par1World.setBlockAndMetadata(par2, par3, par4, this.blockID + 1, var5);
037 par1World.markBlocksDirty(par2, par3, par4, par2, par3, par4);
038 }
039
040 public boolean getBlocksMovement(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
041 {
042 return this.blockMaterial != Material.lava;
043 }
044
045 /**
046 * Ticks the block if it's been scheduled
047 */
048 public void updateTick(World par1World, int par2, int par3, int par4, Random par5Random)
049 {
050 int var6 = this.getFlowDecay(par1World, par2, par3, par4);
051 byte var7 = 1;
052
053 if (this.blockMaterial == Material.lava && !par1World.provider.isHellWorld)
054 {
055 var7 = 2;
056 }
057
058 boolean var8 = true;
059 int var10;
060
061 if (var6 > 0)
062 {
063 byte var9 = -100;
064 this.numAdjacentSources = 0;
065 int var12 = this.getSmallestFlowDecay(par1World, par2 - 1, par3, par4, var9);
066 var12 = this.getSmallestFlowDecay(par1World, par2 + 1, par3, par4, var12);
067 var12 = this.getSmallestFlowDecay(par1World, par2, par3, par4 - 1, var12);
068 var12 = this.getSmallestFlowDecay(par1World, par2, par3, par4 + 1, var12);
069 var10 = var12 + var7;
070
071 if (var10 >= 8 || var12 < 0)
072 {
073 var10 = -1;
074 }
075
076 if (this.getFlowDecay(par1World, par2, par3 + 1, par4) >= 0)
077 {
078 int var11 = this.getFlowDecay(par1World, par2, par3 + 1, par4);
079
080 if (var11 >= 8)
081 {
082 var10 = var11;
083 }
084 else
085 {
086 var10 = var11 + 8;
087 }
088 }
089
090 if (this.numAdjacentSources >= 2 && this.blockMaterial == Material.water)
091 {
092 if (par1World.getBlockMaterial(par2, par3 - 1, par4).isSolid())
093 {
094 var10 = 0;
095 }
096 else if (par1World.getBlockMaterial(par2, par3 - 1, par4) == this.blockMaterial && par1World.getBlockMetadata(par2, par3, par4) == 0)
097 {
098 var10 = 0;
099 }
100 }
101
102 if (this.blockMaterial == Material.lava && var6 < 8 && var10 < 8 && var10 > var6 && par5Random.nextInt(4) != 0)
103 {
104 var10 = var6;
105 var8 = false;
106 }
107
108 if (var10 == var6)
109 {
110 if (var8)
111 {
112 this.updateFlow(par1World, par2, par3, par4);
113 }
114 }
115 else
116 {
117 var6 = var10;
118
119 if (var10 < 0)
120 {
121 par1World.setBlockWithNotify(par2, par3, par4, 0);
122 }
123 else
124 {
125 par1World.setBlockMetadataWithNotify(par2, par3, par4, var10);
126 par1World.scheduleBlockUpdate(par2, par3, par4, this.blockID, this.tickRate());
127 par1World.notifyBlocksOfNeighborChange(par2, par3, par4, this.blockID);
128 }
129 }
130 }
131 else
132 {
133 this.updateFlow(par1World, par2, par3, par4);
134 }
135
136 if (this.liquidCanDisplaceBlock(par1World, par2, par3 - 1, par4))
137 {
138 if (this.blockMaterial == Material.lava && par1World.getBlockMaterial(par2, par3 - 1, par4) == Material.water)
139 {
140 par1World.setBlockWithNotify(par2, par3 - 1, par4, Block.stone.blockID);
141 this.triggerLavaMixEffects(par1World, par2, par3 - 1, par4);
142 return;
143 }
144
145 if (var6 >= 8)
146 {
147 this.flowIntoBlock(par1World, par2, par3 - 1, par4, var6);
148 }
149 else
150 {
151 this.flowIntoBlock(par1World, par2, par3 - 1, par4, var6 + 8);
152 }
153 }
154 else if (var6 >= 0 && (var6 == 0 || this.blockBlocksFlow(par1World, par2, par3 - 1, par4)))
155 {
156 boolean[] var13 = this.getOptimalFlowDirections(par1World, par2, par3, par4);
157 var10 = var6 + var7;
158
159 if (var6 >= 8)
160 {
161 var10 = 1;
162 }
163
164 if (var10 >= 8)
165 {
166 return;
167 }
168
169 if (var13[0])
170 {
171 this.flowIntoBlock(par1World, par2 - 1, par3, par4, var10);
172 }
173
174 if (var13[1])
175 {
176 this.flowIntoBlock(par1World, par2 + 1, par3, par4, var10);
177 }
178
179 if (var13[2])
180 {
181 this.flowIntoBlock(par1World, par2, par3, par4 - 1, var10);
182 }
183
184 if (var13[3])
185 {
186 this.flowIntoBlock(par1World, par2, par3, par4 + 1, var10);
187 }
188 }
189 }
190
191 /**
192 * flowIntoBlock(World world, int x, int y, int z, int newFlowDecay) - Flows into the block at the coordinates and
193 * changes the block type to the liquid.
194 */
195 private void flowIntoBlock(World par1World, int par2, int par3, int par4, int par5)
196 {
197 if (this.liquidCanDisplaceBlock(par1World, par2, par3, par4))
198 {
199 int var6 = par1World.getBlockId(par2, par3, par4);
200
201 if (var6 > 0)
202 {
203 if (this.blockMaterial == Material.lava)
204 {
205 this.triggerLavaMixEffects(par1World, par2, par3, par4);
206 }
207 else
208 {
209 Block.blocksList[var6].dropBlockAsItem(par1World, par2, par3, par4, par1World.getBlockMetadata(par2, par3, par4), 0);
210 }
211 }
212
213 par1World.setBlockAndMetadataWithNotify(par2, par3, par4, this.blockID, par5);
214 }
215 }
216
217 /**
218 * calculateFlowCost(World world, int x, int y, int z, int accumulatedCost, int previousDirectionOfFlow) - Used to
219 * determine the path of least resistance, this method returns the lowest possible flow cost for the direction of
220 * flow indicated. Each necessary horizontal flow adds to the flow cost.
221 */
222 private int calculateFlowCost(World par1World, int par2, int par3, int par4, int par5, int par6)
223 {
224 int var7 = 1000;
225
226 for (int var8 = 0; var8 < 4; ++var8)
227 {
228 if ((var8 != 0 || par6 != 1) && (var8 != 1 || par6 != 0) && (var8 != 2 || par6 != 3) && (var8 != 3 || par6 != 2))
229 {
230 int var9 = par2;
231 int var11 = par4;
232
233 if (var8 == 0)
234 {
235 var9 = par2 - 1;
236 }
237
238 if (var8 == 1)
239 {
240 ++var9;
241 }
242
243 if (var8 == 2)
244 {
245 var11 = par4 - 1;
246 }
247
248 if (var8 == 3)
249 {
250 ++var11;
251 }
252
253 if (!this.blockBlocksFlow(par1World, var9, par3, var11) && (par1World.getBlockMaterial(var9, par3, var11) != this.blockMaterial || par1World.getBlockMetadata(var9, par3, var11) != 0))
254 {
255 if (!this.blockBlocksFlow(par1World, var9, par3 - 1, var11))
256 {
257 return par5;
258 }
259
260 if (par5 < 4)
261 {
262 int var12 = this.calculateFlowCost(par1World, var9, par3, var11, par5 + 1, var8);
263
264 if (var12 < var7)
265 {
266 var7 = var12;
267 }
268 }
269 }
270 }
271 }
272
273 return var7;
274 }
275
276 /**
277 * Returns a boolean array indicating which flow directions are optimal based on each direction's calculated flow
278 * cost. Each array index corresponds to one of the four cardinal directions. A value of true indicates the
279 * direction is optimal.
280 */
281 private boolean[] getOptimalFlowDirections(World par1World, int par2, int par3, int par4)
282 {
283 int var5;
284 int var6;
285
286 for (var5 = 0; var5 < 4; ++var5)
287 {
288 this.flowCost[var5] = 1000;
289 var6 = par2;
290 int var8 = par4;
291
292 if (var5 == 0)
293 {
294 var6 = par2 - 1;
295 }
296
297 if (var5 == 1)
298 {
299 ++var6;
300 }
301
302 if (var5 == 2)
303 {
304 var8 = par4 - 1;
305 }
306
307 if (var5 == 3)
308 {
309 ++var8;
310 }
311
312 if (!this.blockBlocksFlow(par1World, var6, par3, var8) && (par1World.getBlockMaterial(var6, par3, var8) != this.blockMaterial || par1World.getBlockMetadata(var6, par3, var8) != 0))
313 {
314 if (this.blockBlocksFlow(par1World, var6, par3 - 1, var8))
315 {
316 this.flowCost[var5] = this.calculateFlowCost(par1World, var6, par3, var8, 1, var5);
317 }
318 else
319 {
320 this.flowCost[var5] = 0;
321 }
322 }
323 }
324
325 var5 = this.flowCost[0];
326
327 for (var6 = 1; var6 < 4; ++var6)
328 {
329 if (this.flowCost[var6] < var5)
330 {
331 var5 = this.flowCost[var6];
332 }
333 }
334
335 for (var6 = 0; var6 < 4; ++var6)
336 {
337 this.isOptimalFlowDirection[var6] = this.flowCost[var6] == var5;
338 }
339
340 return this.isOptimalFlowDirection;
341 }
342
343 /**
344 * Returns true if block at coords blocks fluids
345 */
346 private boolean blockBlocksFlow(World par1World, int par2, int par3, int par4)
347 {
348 int var5 = par1World.getBlockId(par2, par3, par4);
349
350 if (var5 != Block.doorWood.blockID && var5 != Block.doorSteel.blockID && var5 != Block.signPost.blockID && var5 != Block.ladder.blockID && var5 != Block.reed.blockID)
351 {
352 if (var5 == 0)
353 {
354 return false;
355 }
356 else
357 {
358 Material var6 = Block.blocksList[var5].blockMaterial;
359 return var6 == Material.portal ? true : var6.blocksMovement();
360 }
361 }
362 else
363 {
364 return true;
365 }
366 }
367
368 /**
369 * getSmallestFlowDecay(World world, intx, int y, int z, int currentSmallestFlowDecay) - Looks up the flow decay at
370 * the coordinates given and returns the smaller of this value or the provided currentSmallestFlowDecay. If one
371 * value is valid and the other isn't, the valid value will be returned. Valid values are >= 0. Flow decay is the
372 * amount that a liquid has dissipated. 0 indicates a source block.
373 */
374 protected int getSmallestFlowDecay(World par1World, int par2, int par3, int par4, int par5)
375 {
376 int var6 = this.getFlowDecay(par1World, par2, par3, par4);
377
378 if (var6 < 0)
379 {
380 return par5;
381 }
382 else
383 {
384 if (var6 == 0)
385 {
386 ++this.numAdjacentSources;
387 }
388
389 if (var6 >= 8)
390 {
391 var6 = 0;
392 }
393
394 return par5 >= 0 && var6 >= par5 ? par5 : var6;
395 }
396 }
397
398 /**
399 * Returns true if the block at the coordinates can be displaced by the liquid.
400 */
401 private boolean liquidCanDisplaceBlock(World par1World, int par2, int par3, int par4)
402 {
403 Material var5 = par1World.getBlockMaterial(par2, par3, par4);
404 return var5 == this.blockMaterial ? false : (var5 == Material.lava ? false : !this.blockBlocksFlow(par1World, par2, par3, par4));
405 }
406
407 /**
408 * Called whenever the block is added into the world. Args: world, x, y, z
409 */
410 public void onBlockAdded(World par1World, int par2, int par3, int par4)
411 {
412 super.onBlockAdded(par1World, par2, par3, par4);
413
414 if (par1World.getBlockId(par2, par3, par4) == this.blockID)
415 {
416 par1World.scheduleBlockUpdate(par2, par3, par4, this.blockID, this.tickRate());
417 }
418 }
419
420 public boolean func_82506_l()
421 {
422 return false;
423 }
424 }