Terraria v1.4.4.9
Terraria source code documentation
Loading...
Searching...
No Matches
Liquid.cs
Go to the documentation of this file.
1using System;
2using System.Collections.Generic;
3using Terraria.GameContent.NetModules;
4using Terraria.ID;
5using Terraria.Localization;
6using Terraria.ObjectData;
7using Terraria.WorldBuilding;
8
9namespace Terraria;
10
11public class Liquid
12{
13 public const int maxLiquidBuffer = 50000;
14
15 public static int maxLiquid = 25000;
16
17 public static int skipCount;
18
19 public static int stuckCount;
20
21 public static int stuckAmount;
22
23 public static int cycles = 10;
24
25 public static int curMaxLiquid = 0;
26
27 public static int numLiquid;
28
29 public static bool stuck;
30
31 public static bool quickFall;
32
33 public static bool quickSettle;
34
35 private static int wetCounter;
36
37 public static int panicCounter;
38
39 public static bool panicMode;
40
41 public static int panicY;
42
43 public int x;
44
45 public int y;
46
47 public int kill;
48
49 public int delay;
50
51 private static HashSet<int> _netChangeSet = new HashSet<int>();
52
53 private static HashSet<int> _swapNetChangeSet = new HashSet<int>();
54
55 public static void NetSendLiquid(int x, int y)
56 {
57 if (WorldGen.gen)
58 {
59 return;
60 }
61 lock (_netChangeSet)
62 {
63 _netChangeSet.Add(((x & 0xFFFF) << 16) | (y & 0xFFFF));
64 }
65 }
66
67 public static void tilesIgnoreWater(bool ignoreSolids)
68 {
69 Main.tileSolid[138] = !ignoreSolids;
70 Main.tileSolid[484] = !ignoreSolids;
71 Main.tileSolid[546] = !ignoreSolids;
72 }
73
74 public static void worldGenTilesIgnoreWater(bool ignoreSolids)
75 {
76 Main.tileSolid[10] = !ignoreSolids;
77 Main.tileSolid[192] = !ignoreSolids;
78 Main.tileSolid[191] = !ignoreSolids;
79 Main.tileSolid[190] = !ignoreSolids;
80 }
81
82 public static void ReInit()
83 {
84 skipCount = 0;
85 stuckCount = 0;
86 stuckAmount = 0;
87 cycles = 10;
88 curMaxLiquid = maxLiquid;
89 numLiquid = 0;
90 stuck = false;
91 quickFall = false;
92 quickSettle = false;
93 wetCounter = 0;
94 panicCounter = 0;
95 panicMode = false;
96 panicY = 0;
97 if (Main.Setting_UseReducedMaxLiquids)
98 {
99 curMaxLiquid = 5000;
100 }
101 }
102
103 public static void QuickWater(int verbose = 0, int minY = -1, int maxY = -1)
104 {
105 if (WorldGen.gen)
106 {
107 WorldGen.ShimmerRemoveWater();
108 if (WorldGen.noTrapsWorldGen)
109 {
110 Main.tileSolid[138] = false;
111 }
112 }
113 Main.tileSolid[379] = true;
114 tilesIgnoreWater(ignoreSolids: true);
115 if (minY == -1)
116 {
117 minY = 3;
118 }
119 if (maxY == -1)
120 {
121 maxY = Main.maxTilesY - 3;
122 }
123 for (int num = maxY; num >= minY; num--)
124 {
125 UpdateProgressDisplay(verbose, minY, maxY, num);
126 for (int i = 4; i < Main.maxTilesX - 4; i++)
127 {
128 if (Main.tile[i, num].liquid != 0)
129 {
130 SettleWaterAt(i, num);
131 }
132 }
133 }
134 tilesIgnoreWater(ignoreSolids: false);
135 if (WorldGen.gen)
136 {
137 WorldGen.ShimmerRemoveWater();
138 if (WorldGen.noTrapsWorldGen)
139 {
140 Main.tileSolid[138] = true;
141 }
142 }
143 }
144
145 private static void SettleWaterAt(int originX, int originY)
146 {
147 Tile tile = Main.tile[originX, originY];
148 tilesIgnoreWater(ignoreSolids: true);
149 if (tile.liquid == 0)
150 {
151 return;
152 }
153 int num = originX;
154 int num2 = originY;
155 bool tileAtXYHasLava = tile.lava();
156 bool flag = tile.honey();
157 bool flag2 = tile.shimmer();
158 int num3 = tile.liquid;
159 byte b = tile.liquidType();
160 tile.liquid = 0;
161 bool flag3 = true;
162 while (true)
163 {
164 Tile tile2 = Main.tile[num, num2 + 1];
165 bool flag4 = false;
166 while (num2 < Main.maxTilesY - 5 && tile2.liquid == 0 && (!tile2.nactive() || !Main.tileSolid[tile2.type] || Main.tileSolidTop[tile2.type]))
167 {
168 num2++;
169 flag4 = true;
170 flag3 = false;
171 tile2 = Main.tile[num, num2 + 1];
172 }
173 if (WorldGen.gen && flag4 && !flag && !flag2)
174 {
175 if (WorldGen.remixWorldGen)
176 {
177 b = ((num2 > GenVars.lavaLine && ((double)num2 < Main.rockLayer - 80.0 || num2 > Main.maxTilesY - 350) && !WorldGen.oceanDepths(num, num2)) ? ((byte)1) : ((byte)0));
178 }
179 else if (num2 > GenVars.waterLine)
180 {
181 b = 1;
182 }
183 }
184 int num4 = -1;
185 int num5 = 0;
186 int num6 = -1;
187 int num7 = 0;
188 bool flag5 = false;
189 bool flag6 = false;
190 bool flag7 = false;
191 while (true)
192 {
193 if (Main.tile[num + num5 * num4, num2].liquid == 0)
194 {
195 num6 = num4;
196 num7 = num5;
197 }
198 if (num4 == -1 && num + num5 * num4 < 5)
199 {
200 flag6 = true;
201 }
202 else if (num4 == 1 && num + num5 * num4 > Main.maxTilesX - 5)
203 {
204 flag5 = true;
205 }
206 tile2 = Main.tile[num + num5 * num4, num2 + 1];
207 if (tile2.liquid != 0 && tile2.liquid != byte.MaxValue && tile2.liquidType() == b)
208 {
209 int num8 = 255 - tile2.liquid;
210 if (num8 > num3)
211 {
212 num8 = num3;
213 }
214 tile2.liquid += (byte)num8;
215 num3 -= num8;
216 if (num3 == 0)
217 {
218 break;
219 }
220 }
221 if (num2 < Main.maxTilesY - 5 && tile2.liquid == 0 && (!tile2.nactive() || !Main.tileSolid[tile2.type] || Main.tileSolidTop[tile2.type]))
222 {
223 flag7 = true;
224 break;
225 }
226 Tile tile3 = Main.tile[num + (num5 + 1) * num4, num2];
227 if ((tile3.liquid != 0 && (!flag3 || num4 != 1)) || (tile3.nactive() && Main.tileSolid[tile3.type] && !Main.tileSolidTop[tile3.type]))
228 {
229 if (num4 == 1)
230 {
231 flag5 = true;
232 }
233 else
234 {
235 flag6 = true;
236 }
237 }
238 if (flag6 && flag5)
239 {
240 break;
241 }
242 if (flag5)
243 {
244 num4 = -1;
245 num5++;
246 }
247 else if (flag6)
248 {
249 if (num4 == 1)
250 {
251 num5++;
252 }
253 num4 = 1;
254 }
255 else
256 {
257 if (num4 == 1)
258 {
259 num5++;
260 }
261 num4 = -num4;
262 }
263 }
264 num += num7 * num6;
265 if (num3 == 0 || !flag7)
266 {
267 break;
268 }
269 num2++;
270 }
271 Main.tile[num, num2].liquid = (byte)num3;
272 Main.tile[num, num2].liquidType(b);
273 if (Main.tile[num, num2].liquid > 0)
274 {
275 AttemptToMoveLava(num, num2, tileAtXYHasLava);
276 AttemptToMoveHoney(num, num2, flag);
277 AttemptToMoveShimmer(num, num2, flag2);
278 }
279 tilesIgnoreWater(ignoreSolids: false);
280 }
281
282 private static void AttemptToMoveHoney(int X, int Y, bool tileAtXYHasHoney)
283 {
284 if (Main.tile[X - 1, Y].liquid > 0 && Main.tile[X - 1, Y].honey() != tileAtXYHasHoney)
285 {
286 if (tileAtXYHasHoney)
287 {
288 HoneyCheck(X, Y);
289 }
290 else
291 {
292 HoneyCheck(X - 1, Y);
293 }
294 }
295 else if (Main.tile[X + 1, Y].liquid > 0 && Main.tile[X + 1, Y].honey() != tileAtXYHasHoney)
296 {
297 if (tileAtXYHasHoney)
298 {
299 HoneyCheck(X, Y);
300 }
301 else
302 {
303 HoneyCheck(X + 1, Y);
304 }
305 }
306 else if (Main.tile[X, Y - 1].liquid > 0 && Main.tile[X, Y - 1].honey() != tileAtXYHasHoney)
307 {
308 if (tileAtXYHasHoney)
309 {
310 HoneyCheck(X, Y);
311 }
312 else
313 {
314 HoneyCheck(X, Y - 1);
315 }
316 }
317 else if (Main.tile[X, Y + 1].liquid > 0 && Main.tile[X, Y + 1].honey() != tileAtXYHasHoney)
318 {
319 if (tileAtXYHasHoney)
320 {
321 HoneyCheck(X, Y);
322 }
323 else
324 {
325 HoneyCheck(X, Y + 1);
326 }
327 }
328 }
329
330 private static void AttemptToMoveLava(int X, int Y, bool tileAtXYHasLava)
331 {
332 if (Main.tile[X - 1, Y].liquid > 0 && Main.tile[X - 1, Y].lava() != tileAtXYHasLava)
333 {
334 if (tileAtXYHasLava)
335 {
336 LavaCheck(X, Y);
337 }
338 else
339 {
340 LavaCheck(X - 1, Y);
341 }
342 }
343 else if (Main.tile[X + 1, Y].liquid > 0 && Main.tile[X + 1, Y].lava() != tileAtXYHasLava)
344 {
345 if (tileAtXYHasLava)
346 {
347 LavaCheck(X, Y);
348 }
349 else
350 {
351 LavaCheck(X + 1, Y);
352 }
353 }
354 else if (Main.tile[X, Y - 1].liquid > 0 && Main.tile[X, Y - 1].lava() != tileAtXYHasLava)
355 {
356 if (tileAtXYHasLava)
357 {
358 LavaCheck(X, Y);
359 }
360 else
361 {
362 LavaCheck(X, Y - 1);
363 }
364 }
365 else if (Main.tile[X, Y + 1].liquid > 0 && Main.tile[X, Y + 1].lava() != tileAtXYHasLava)
366 {
367 if (tileAtXYHasLava)
368 {
369 LavaCheck(X, Y);
370 }
371 else
372 {
373 LavaCheck(X, Y + 1);
374 }
375 }
376 }
377
378 private static void AttemptToMoveShimmer(int X, int Y, bool tileAtXYHasShimmer)
379 {
380 if (Main.tile[X - 1, Y].liquid > 0 && Main.tile[X - 1, Y].shimmer() != tileAtXYHasShimmer)
381 {
382 if (tileAtXYHasShimmer)
383 {
384 ShimmerCheck(X, Y);
385 }
386 else
387 {
388 ShimmerCheck(X - 1, Y);
389 }
390 }
391 else if (Main.tile[X + 1, Y].liquid > 0 && Main.tile[X + 1, Y].shimmer() != tileAtXYHasShimmer)
392 {
393 if (tileAtXYHasShimmer)
394 {
395 ShimmerCheck(X, Y);
396 }
397 else
398 {
399 ShimmerCheck(X + 1, Y);
400 }
401 }
402 else if (Main.tile[X, Y - 1].liquid > 0 && Main.tile[X, Y - 1].shimmer() != tileAtXYHasShimmer)
403 {
404 if (tileAtXYHasShimmer)
405 {
406 ShimmerCheck(X, Y);
407 }
408 else
409 {
410 ShimmerCheck(X, Y - 1);
411 }
412 }
413 else if (Main.tile[X, Y + 1].liquid > 0 && Main.tile[X, Y + 1].shimmer() != tileAtXYHasShimmer)
414 {
415 if (tileAtXYHasShimmer)
416 {
417 ShimmerCheck(X, Y);
418 }
419 else
420 {
421 ShimmerCheck(X, Y + 1);
422 }
423 }
424 }
425
426 private static void UpdateProgressDisplay(int verbose, int minY, int maxY, int y)
427 {
428 if (verbose > 0)
429 {
430 float num = (float)(maxY - y) / (float)(maxY - minY + 1);
431 num /= (float)verbose;
432 Main.statusText = Lang.gen[27].Value + " " + (int)(num * 100f + 1f) + "%";
433 }
434 else if (verbose < 0)
435 {
436 float num2 = (float)(maxY - y) / (float)(maxY - minY + 1);
437 num2 /= (float)(-verbose);
438 Main.statusText = Lang.gen[18].Value + " " + (int)(num2 * 100f + 1f) + "%";
439 }
440 }
441
442 public void Update()
443 {
444 Main.tileSolid[379] = true;
445 Tile tile = Main.tile[x - 1, y];
446 Tile tile2 = Main.tile[x + 1, y];
447 Tile tile3 = Main.tile[x, y - 1];
448 Tile tile4 = Main.tile[x, y + 1];
449 Tile tile5 = Main.tile[x, y];
450 if (tile5.nactive() && Main.tileSolid[tile5.type] && !Main.tileSolidTop[tile5.type])
451 {
452 _ = tile5.type;
453 _ = 10;
454 kill = 999;
455 return;
456 }
457 byte liquid = tile5.liquid;
458 float num = 0f;
459 if (y > Main.UnderworldLayer && tile5.liquidType() == 0 && tile5.liquid > 0)
460 {
461 byte b = 2;
462 if (tile5.liquid < b)
463 {
464 b = tile5.liquid;
465 }
466 tile5.liquid -= b;
467 }
468 if (tile5.liquid == 0)
469 {
470 kill = 999;
471 return;
472 }
473 if (tile5.lava())
474 {
475 LavaCheck(x, y);
476 if (!quickFall)
477 {
478 if (delay < 5)
479 {
480 delay++;
481 return;
482 }
483 delay = 0;
484 }
485 }
486 else
487 {
488 if (tile.lava())
489 {
490 AddWater(x - 1, y);
491 }
492 if (tile2.lava())
493 {
494 AddWater(x + 1, y);
495 }
496 if (tile3.lava())
497 {
498 AddWater(x, y - 1);
499 }
500 if (tile4.lava())
501 {
502 AddWater(x, y + 1);
503 }
504 if (tile5.honey())
505 {
506 HoneyCheck(x, y);
507 if (!quickFall)
508 {
509 if (delay < 10)
510 {
511 delay++;
512 return;
513 }
514 delay = 0;
515 }
516 }
517 else
518 {
519 if (tile.honey())
520 {
521 AddWater(x - 1, y);
522 }
523 if (tile2.honey())
524 {
525 AddWater(x + 1, y);
526 }
527 if (tile3.honey())
528 {
529 AddWater(x, y - 1);
530 }
531 if (tile4.honey())
532 {
533 AddWater(x, y + 1);
534 }
535 if (tile5.shimmer())
536 {
537 ShimmerCheck(x, y);
538 }
539 else
540 {
541 if (tile.shimmer())
542 {
543 AddWater(x - 1, y);
544 }
545 if (tile2.shimmer())
546 {
547 AddWater(x + 1, y);
548 }
549 if (tile3.shimmer())
550 {
551 AddWater(x, y - 1);
552 }
553 if (tile4.shimmer())
554 {
555 AddWater(x, y + 1);
556 }
557 }
558 }
559 }
560 if ((!tile4.nactive() || !Main.tileSolid[tile4.type] || Main.tileSolidTop[tile4.type]) && (tile4.liquid <= 0 || tile4.liquidType() == tile5.liquidType()) && tile4.liquid < byte.MaxValue)
561 {
562 bool flag = false;
563 num = 255 - tile4.liquid;
564 if (num > (float)(int)tile5.liquid)
565 {
566 num = (int)tile5.liquid;
567 }
568 if (num == 1f && tile5.liquid == byte.MaxValue)
569 {
570 flag = true;
571 }
572 if (!flag)
573 {
574 tile5.liquid -= (byte)num;
575 }
576 tile4.liquid += (byte)num;
577 tile4.liquidType(tile5.liquidType());
578 AddWater(x, y + 1);
579 tile4.skipLiquid(skipLiquid: true);
580 tile5.skipLiquid(skipLiquid: true);
581 if (quickSettle && tile5.liquid > 250)
582 {
583 tile5.liquid = byte.MaxValue;
584 }
585 else if (!flag)
586 {
587 AddWater(x - 1, y);
588 AddWater(x + 1, y);
589 }
590 }
591 if (tile5.liquid > 0)
592 {
593 bool flag2 = true;
594 bool flag3 = true;
595 bool flag4 = true;
596 bool flag5 = true;
597 if (tile.nactive() && Main.tileSolid[tile.type] && !Main.tileSolidTop[tile.type])
598 {
599 flag2 = false;
600 }
601 else if (tile.liquid > 0 && tile.liquidType() != tile5.liquidType())
602 {
603 flag2 = false;
604 }
605 else if (Main.tile[x - 2, y].nactive() && Main.tileSolid[Main.tile[x - 2, y].type] && !Main.tileSolidTop[Main.tile[x - 2, y].type])
606 {
607 flag4 = false;
608 }
609 else if (Main.tile[x - 2, y].liquid == 0)
610 {
611 flag4 = false;
612 }
613 else if (Main.tile[x - 2, y].liquid > 0 && Main.tile[x - 2, y].liquidType() != tile5.liquidType())
614 {
615 flag4 = false;
616 }
617 if (tile2.nactive() && Main.tileSolid[tile2.type] && !Main.tileSolidTop[tile2.type])
618 {
619 flag3 = false;
620 }
621 else if (tile2.liquid > 0 && tile2.liquidType() != tile5.liquidType())
622 {
623 flag3 = false;
624 }
625 else if (Main.tile[x + 2, y].nactive() && Main.tileSolid[Main.tile[x + 2, y].type] && !Main.tileSolidTop[Main.tile[x + 2, y].type])
626 {
627 flag5 = false;
628 }
629 else if (Main.tile[x + 2, y].liquid == 0)
630 {
631 flag5 = false;
632 }
633 else if (Main.tile[x + 2, y].liquid > 0 && Main.tile[x + 2, y].liquidType() != tile5.liquidType())
634 {
635 flag5 = false;
636 }
637 int num2 = 0;
638 if (tile5.liquid < 3)
639 {
640 num2 = -1;
641 }
642 if (tile5.liquid > 250)
643 {
644 flag4 = false;
645 flag5 = false;
646 }
647 if (flag2 && flag3)
648 {
649 if (flag4 && flag5)
650 {
651 bool flag6 = true;
652 bool flag7 = true;
653 if (Main.tile[x - 3, y].nactive() && Main.tileSolid[Main.tile[x - 3, y].type] && !Main.tileSolidTop[Main.tile[x - 3, y].type])
654 {
655 flag6 = false;
656 }
657 else if (Main.tile[x - 3, y].liquid == 0)
658 {
659 flag6 = false;
660 }
661 else if (Main.tile[x - 3, y].liquidType() != tile5.liquidType())
662 {
663 flag6 = false;
664 }
665 if (Main.tile[x + 3, y].nactive() && Main.tileSolid[Main.tile[x + 3, y].type] && !Main.tileSolidTop[Main.tile[x + 3, y].type])
666 {
667 flag7 = false;
668 }
669 else if (Main.tile[x + 3, y].liquid == 0)
670 {
671 flag7 = false;
672 }
673 else if (Main.tile[x + 3, y].liquidType() != tile5.liquidType())
674 {
675 flag7 = false;
676 }
677 if (flag6 && flag7)
678 {
679 num = tile.liquid + tile2.liquid + Main.tile[x - 2, y].liquid + Main.tile[x + 2, y].liquid + Main.tile[x - 3, y].liquid + Main.tile[x + 3, y].liquid + tile5.liquid + num2;
680 num = (float)Math.Round(num / 7f);
681 int num3 = 0;
682 tile.liquidType(tile5.liquidType());
683 if (tile.liquid != (byte)num)
684 {
685 tile.liquid = (byte)num;
686 AddWater(x - 1, y);
687 }
688 else
689 {
690 num3++;
691 }
692 tile2.liquidType(tile5.liquidType());
693 if (tile2.liquid != (byte)num)
694 {
695 tile2.liquid = (byte)num;
696 AddWater(x + 1, y);
697 }
698 else
699 {
700 num3++;
701 }
702 Main.tile[x - 2, y].liquidType(tile5.liquidType());
703 if (Main.tile[x - 2, y].liquid != (byte)num)
704 {
705 Main.tile[x - 2, y].liquid = (byte)num;
706 AddWater(x - 2, y);
707 }
708 else
709 {
710 num3++;
711 }
712 Main.tile[x + 2, y].liquidType(tile5.liquidType());
713 if (Main.tile[x + 2, y].liquid != (byte)num)
714 {
715 Main.tile[x + 2, y].liquid = (byte)num;
716 AddWater(x + 2, y);
717 }
718 else
719 {
720 num3++;
721 }
722 Main.tile[x - 3, y].liquidType(tile5.liquidType());
723 if (Main.tile[x - 3, y].liquid != (byte)num)
724 {
725 Main.tile[x - 3, y].liquid = (byte)num;
726 AddWater(x - 3, y);
727 }
728 else
729 {
730 num3++;
731 }
732 Main.tile[x + 3, y].liquidType(tile5.liquidType());
733 if (Main.tile[x + 3, y].liquid != (byte)num)
734 {
735 Main.tile[x + 3, y].liquid = (byte)num;
736 AddWater(x + 3, y);
737 }
738 else
739 {
740 num3++;
741 }
742 if (tile.liquid != (byte)num || tile5.liquid != (byte)num)
743 {
744 AddWater(x - 1, y);
745 }
746 if (tile2.liquid != (byte)num || tile5.liquid != (byte)num)
747 {
748 AddWater(x + 1, y);
749 }
750 if (Main.tile[x - 2, y].liquid != (byte)num || tile5.liquid != (byte)num)
751 {
752 AddWater(x - 2, y);
753 }
754 if (Main.tile[x + 2, y].liquid != (byte)num || tile5.liquid != (byte)num)
755 {
756 AddWater(x + 2, y);
757 }
758 if (Main.tile[x - 3, y].liquid != (byte)num || tile5.liquid != (byte)num)
759 {
760 AddWater(x - 3, y);
761 }
762 if (Main.tile[x + 3, y].liquid != (byte)num || tile5.liquid != (byte)num)
763 {
764 AddWater(x + 3, y);
765 }
766 if (num3 != 6 || tile3.liquid <= 0)
767 {
768 tile5.liquid = (byte)num;
769 }
770 }
771 else
772 {
773 int num4 = 0;
774 num = tile.liquid + tile2.liquid + Main.tile[x - 2, y].liquid + Main.tile[x + 2, y].liquid + tile5.liquid + num2;
775 num = (float)Math.Round(num / 5f);
776 tile.liquidType(tile5.liquidType());
777 if (tile.liquid != (byte)num)
778 {
779 tile.liquid = (byte)num;
780 AddWater(x - 1, y);
781 }
782 else
783 {
784 num4++;
785 }
786 tile2.liquidType(tile5.liquidType());
787 if (tile2.liquid != (byte)num)
788 {
789 tile2.liquid = (byte)num;
790 AddWater(x + 1, y);
791 }
792 else
793 {
794 num4++;
795 }
796 Main.tile[x - 2, y].liquidType(tile5.liquidType());
797 if (Main.tile[x - 2, y].liquid != (byte)num)
798 {
799 Main.tile[x - 2, y].liquid = (byte)num;
800 AddWater(x - 2, y);
801 }
802 else
803 {
804 num4++;
805 }
806 Main.tile[x + 2, y].liquidType(tile5.liquidType());
807 if (Main.tile[x + 2, y].liquid != (byte)num)
808 {
809 Main.tile[x + 2, y].liquid = (byte)num;
810 AddWater(x + 2, y);
811 }
812 else
813 {
814 num4++;
815 }
816 if (tile.liquid != (byte)num || tile5.liquid != (byte)num)
817 {
818 AddWater(x - 1, y);
819 }
820 if (tile2.liquid != (byte)num || tile5.liquid != (byte)num)
821 {
822 AddWater(x + 1, y);
823 }
824 if (Main.tile[x - 2, y].liquid != (byte)num || tile5.liquid != (byte)num)
825 {
826 AddWater(x - 2, y);
827 }
828 if (Main.tile[x + 2, y].liquid != (byte)num || tile5.liquid != (byte)num)
829 {
830 AddWater(x + 2, y);
831 }
832 if (num4 != 4 || tile3.liquid <= 0)
833 {
834 tile5.liquid = (byte)num;
835 }
836 }
837 }
838 else if (flag4)
839 {
840 num = tile.liquid + tile2.liquid + Main.tile[x - 2, y].liquid + tile5.liquid + num2;
841 num = (float)Math.Round(num / 4f);
842 tile.liquidType(tile5.liquidType());
843 if (tile.liquid != (byte)num || tile5.liquid != (byte)num)
844 {
845 tile.liquid = (byte)num;
846 AddWater(x - 1, y);
847 }
848 tile2.liquidType(tile5.liquidType());
849 if (tile2.liquid != (byte)num || tile5.liquid != (byte)num)
850 {
851 tile2.liquid = (byte)num;
852 AddWater(x + 1, y);
853 }
854 Main.tile[x - 2, y].liquidType(tile5.liquidType());
855 if (Main.tile[x - 2, y].liquid != (byte)num || tile5.liquid != (byte)num)
856 {
857 Main.tile[x - 2, y].liquid = (byte)num;
858 AddWater(x - 2, y);
859 }
860 tile5.liquid = (byte)num;
861 }
862 else if (flag5)
863 {
864 num = tile.liquid + tile2.liquid + Main.tile[x + 2, y].liquid + tile5.liquid + num2;
865 num = (float)Math.Round(num / 4f);
866 tile.liquidType(tile5.liquidType());
867 if (tile.liquid != (byte)num || tile5.liquid != (byte)num)
868 {
869 tile.liquid = (byte)num;
870 AddWater(x - 1, y);
871 }
872 tile2.liquidType(tile5.liquidType());
873 if (tile2.liquid != (byte)num || tile5.liquid != (byte)num)
874 {
875 tile2.liquid = (byte)num;
876 AddWater(x + 1, y);
877 }
878 Main.tile[x + 2, y].liquidType(tile5.liquidType());
879 if (Main.tile[x + 2, y].liquid != (byte)num || tile5.liquid != (byte)num)
880 {
881 Main.tile[x + 2, y].liquid = (byte)num;
882 AddWater(x + 2, y);
883 }
884 tile5.liquid = (byte)num;
885 }
886 else
887 {
888 num = tile.liquid + tile2.liquid + tile5.liquid + num2;
889 num = (float)Math.Round(num / 3f);
890 if (num == 254f && WorldGen.genRand.Next(30) == 0)
891 {
892 num = 255f;
893 }
894 tile.liquidType(tile5.liquidType());
895 if (tile.liquid != (byte)num)
896 {
897 tile.liquid = (byte)num;
898 AddWater(x - 1, y);
899 }
900 tile2.liquidType(tile5.liquidType());
901 if (tile2.liquid != (byte)num)
902 {
903 tile2.liquid = (byte)num;
904 AddWater(x + 1, y);
905 }
906 tile5.liquid = (byte)num;
907 }
908 }
909 else if (flag2)
910 {
911 num = tile.liquid + tile5.liquid + num2;
912 num = (float)Math.Round(num / 2f);
913 if (tile.liquid != (byte)num)
914 {
915 tile.liquid = (byte)num;
916 }
917 tile.liquidType(tile5.liquidType());
918 if (tile5.liquid != (byte)num || tile.liquid != (byte)num)
919 {
920 AddWater(x - 1, y);
921 }
922 tile5.liquid = (byte)num;
923 }
924 else if (flag3)
925 {
926 num = tile2.liquid + tile5.liquid + num2;
927 num = (float)Math.Round(num / 2f);
928 if (tile2.liquid != (byte)num)
929 {
930 tile2.liquid = (byte)num;
931 }
932 tile2.liquidType(tile5.liquidType());
933 if (tile5.liquid != (byte)num || tile2.liquid != (byte)num)
934 {
935 AddWater(x + 1, y);
936 }
937 tile5.liquid = (byte)num;
938 }
939 }
940 if (tile5.liquid != liquid)
941 {
942 if (tile5.liquid == 254 && liquid == byte.MaxValue)
943 {
944 if (quickSettle)
945 {
946 tile5.liquid = byte.MaxValue;
947 kill++;
948 }
949 else
950 {
951 kill++;
952 }
953 }
954 else
955 {
956 AddWater(x, y - 1);
957 kill = 0;
958 }
959 }
960 else
961 {
962 kill++;
963 }
964 }
965
966 public static void StartPanic()
967 {
968 if (!panicMode)
969 {
970 GenVars.waterLine = Main.maxTilesY;
971 numLiquid = 0;
972 LiquidBuffer.numLiquidBuffer = 0;
973 panicCounter = 0;
974 panicMode = true;
975 panicY = Main.maxTilesY - 3;
976 if (Main.dedServ)
977 {
978 Console.WriteLine(Language.GetTextValue("Misc.ForceWaterSettling"));
979 }
980 }
981 }
982
983 public static void UpdateLiquid()
984 {
985 int num = 8;
986 tilesIgnoreWater(ignoreSolids: true);
987 if (Main.netMode == 2)
988 {
989 int num2 = 0;
990 for (int i = 0; i < 15; i++)
991 {
992 if (Main.player[i].active)
993 {
994 num2++;
995 }
996 }
997 cycles = 10 + num2 / 3;
998 curMaxLiquid = maxLiquid - num2 * 250;
999 num = 10 + num2 / 3;
1000 if (Main.Setting_UseReducedMaxLiquids)
1001 {
1002 curMaxLiquid = 5000;
1003 }
1004 }
1005 if (!WorldGen.gen)
1006 {
1007 if (!panicMode)
1008 {
1009 if ((double)LiquidBuffer.numLiquidBuffer >= 45000.0)
1010 {
1011 panicCounter++;
1012 if (panicCounter > 3600)
1013 {
1014 StartPanic();
1015 }
1016 }
1017 else
1018 {
1019 panicCounter = 0;
1020 }
1021 }
1022 if (panicMode)
1023 {
1024 int num3 = 0;
1025 while (panicY >= 3 && num3 < 5)
1026 {
1027 num3++;
1028 QuickWater(0, panicY, panicY);
1029 panicY--;
1030 if (panicY >= 3)
1031 {
1032 continue;
1033 }
1034 Console.WriteLine(Language.GetTextValue("Misc.WaterSettled"));
1035 panicCounter = 0;
1036 panicMode = false;
1037 WorldGen.WaterCheck();
1038 if (Main.netMode != 2)
1039 {
1040 continue;
1041 }
1042 for (int j = 0; j < 255; j++)
1043 {
1044 for (int k = 0; k < Main.maxSectionsX; k++)
1045 {
1046 for (int l = 0; l < Main.maxSectionsY; l++)
1047 {
1048 Netplay.Clients[j].TileSections[k, l] = false;
1049 }
1050 }
1051 }
1052 }
1053 return;
1054 }
1055 }
1056 bool flag = quickSettle;
1057 if (Main.Setting_UseReducedMaxLiquids)
1058 {
1059 flag |= numLiquid > 2000;
1060 }
1061 if (flag)
1062 {
1063 quickFall = true;
1064 }
1065 else
1066 {
1067 quickFall = false;
1068 }
1069 wetCounter++;
1070 int num4 = curMaxLiquid / cycles;
1071 int num5 = num4 * (wetCounter - 1);
1072 int num6 = num4 * wetCounter;
1073 if (wetCounter == cycles)
1074 {
1075 num6 = numLiquid;
1076 }
1077 if (num6 > numLiquid)
1078 {
1079 num6 = numLiquid;
1080 _ = Main.netMode;
1081 wetCounter = cycles;
1082 }
1083 if (quickFall)
1084 {
1085 for (int m = num5; m < num6; m++)
1086 {
1087 Main.liquid[m].delay = 10;
1088 Main.liquid[m].Update();
1089 Main.tile[Main.liquid[m].x, Main.liquid[m].y].skipLiquid(skipLiquid: false);
1090 }
1091 }
1092 else
1093 {
1094 for (int n = num5; n < num6; n++)
1095 {
1096 if (!Main.tile[Main.liquid[n].x, Main.liquid[n].y].skipLiquid())
1097 {
1098 Main.liquid[n].Update();
1099 }
1100 else
1101 {
1102 Main.tile[Main.liquid[n].x, Main.liquid[n].y].skipLiquid(skipLiquid: false);
1103 }
1104 }
1105 }
1106 if (wetCounter >= cycles)
1107 {
1108 wetCounter = 0;
1109 for (int num7 = numLiquid - 1; num7 >= 0; num7--)
1110 {
1111 if (Main.liquid[num7].kill >= num)
1112 {
1113 if (Main.tile[Main.liquid[num7].x, Main.liquid[num7].y].liquid == 254)
1114 {
1115 Main.tile[Main.liquid[num7].x, Main.liquid[num7].y].liquid = byte.MaxValue;
1116 }
1117 DelWater(num7);
1118 }
1119 }
1120 int num8 = curMaxLiquid - (curMaxLiquid - numLiquid);
1121 if (num8 > LiquidBuffer.numLiquidBuffer)
1122 {
1123 num8 = LiquidBuffer.numLiquidBuffer;
1124 }
1125 for (int num9 = 0; num9 < num8; num9++)
1126 {
1127 Main.tile[Main.liquidBuffer[0].x, Main.liquidBuffer[0].y].checkingLiquid(checkingLiquid: false);
1128 AddWater(Main.liquidBuffer[0].x, Main.liquidBuffer[0].y);
1129 LiquidBuffer.DelBuffer(0);
1130 }
1131 if (numLiquid > 0 && numLiquid > stuckAmount - 50 && numLiquid < stuckAmount + 50)
1132 {
1133 stuckCount++;
1134 if (stuckCount >= 10000)
1135 {
1136 stuck = true;
1137 for (int num10 = numLiquid - 1; num10 >= 0; num10--)
1138 {
1139 DelWater(num10);
1140 }
1141 stuck = false;
1142 stuckCount = 0;
1143 }
1144 }
1145 else
1146 {
1147 stuckCount = 0;
1148 stuckAmount = numLiquid;
1149 }
1150 }
1151 if (!WorldGen.gen && Main.netMode == 2 && _netChangeSet.Count > 0)
1152 {
1153 Utils.Swap(ref _netChangeSet, ref _swapNetChangeSet);
1154 NetLiquidModule.CreateAndBroadcastByChunk(_swapNetChangeSet);
1155 _swapNetChangeSet.Clear();
1156 }
1157 tilesIgnoreWater(ignoreSolids: false);
1158 }
1159
1160 public static void AddWater(int x, int y)
1161 {
1162 Tile tile = Main.tile[x, y];
1163 if (Main.tile[x, y] == null || tile.checkingLiquid() || x >= Main.maxTilesX - 5 || y >= Main.maxTilesY - 5 || x < 5 || y < 5 || tile.liquid == 0 || (tile.nactive() && Main.tileSolid[tile.type] && tile.type != 546 && !Main.tileSolidTop[tile.type]))
1164 {
1165 return;
1166 }
1167 if (numLiquid >= curMaxLiquid - 1)
1168 {
1169 LiquidBuffer.AddBuffer(x, y);
1170 return;
1171 }
1172 tile.checkingLiquid(checkingLiquid: true);
1173 tile.skipLiquid(skipLiquid: false);
1174 Main.liquid[numLiquid].kill = 0;
1175 Main.liquid[numLiquid].x = x;
1176 Main.liquid[numLiquid].y = y;
1177 Main.liquid[numLiquid].delay = 0;
1178 numLiquid++;
1179 if (Main.netMode == 2)
1180 {
1181 NetSendLiquid(x, y);
1182 }
1183 if (!tile.active() || WorldGen.gen)
1184 {
1185 return;
1186 }
1187 bool flag = false;
1188 if (tile.lava())
1189 {
1190 if (TileObjectData.CheckLavaDeath(tile))
1191 {
1192 flag = true;
1193 }
1194 }
1195 else if (TileObjectData.CheckWaterDeath(tile))
1196 {
1197 flag = true;
1198 }
1199 if (flag)
1200 {
1201 WorldGen.KillTile(x, y);
1202 if (Main.netMode == 2)
1203 {
1204 NetMessage.SendData(17, -1, -1, null, 0, x, y);
1205 }
1206 }
1207 }
1208
1209 private static bool UndergroundDesertCheck(int x, int y)
1210 {
1211 int num = 3;
1212 for (int i = x - num; i <= x + num; i++)
1213 {
1214 for (int j = y - num; j <= y + num; j++)
1215 {
1216 if (WorldGen.InWorld(i, j) && (Main.tile[i, j].wall == 187 || Main.tile[i, j].wall == 216))
1217 {
1218 return true;
1219 }
1220 }
1221 }
1222 return false;
1223 }
1224
1225 public static void LiquidCheck(int x, int y, int thisLiquidType)
1226 {
1227 if (WorldGen.SolidTile(x, y))
1228 {
1229 return;
1230 }
1231 Tile tile = Main.tile[x - 1, y];
1232 Tile tile2 = Main.tile[x + 1, y];
1233 Tile tile3 = Main.tile[x, y - 1];
1234 Tile tile4 = Main.tile[x, y + 1];
1235 Tile tile5 = Main.tile[x, y];
1236 if ((tile.liquid > 0 && tile.liquidType() != thisLiquidType) || (tile2.liquid > 0 && tile2.liquidType() != thisLiquidType) || (tile3.liquid > 0 && tile3.liquidType() != thisLiquidType))
1237 {
1238 int num = 0;
1239 if (tile.liquidType() != thisLiquidType)
1240 {
1241 num += tile.liquid;
1242 tile.liquid = 0;
1243 }
1244 if (tile2.liquidType() != thisLiquidType)
1245 {
1246 num += tile2.liquid;
1247 tile2.liquid = 0;
1248 }
1249 if (tile3.liquidType() != thisLiquidType)
1250 {
1251 num += tile3.liquid;
1252 tile3.liquid = 0;
1253 }
1254 int liquidMergeTileType = 56;
1255 int liquidMergeType = 0;
1256 bool waterNearby = tile.liquidType() == 0 || tile2.liquidType() == 0 || tile3.liquidType() == 0;
1257 bool lavaNearby = tile.lava() || tile2.lava() || tile3.lava();
1258 bool honeyNearby = tile.honey() || tile2.honey() || tile3.honey();
1259 bool shimmerNearby = tile.shimmer() || tile2.shimmer() || tile3.shimmer();
1260 GetLiquidMergeTypes(thisLiquidType, out liquidMergeTileType, out liquidMergeType, waterNearby, lavaNearby, honeyNearby, shimmerNearby);
1261 if (num < 24 || liquidMergeType == thisLiquidType)
1262 {
1263 return;
1264 }
1265 if (tile5.active() && Main.tileObsidianKill[tile5.type])
1266 {
1267 WorldGen.KillTile(x, y);
1268 if (Main.netMode == 2)
1269 {
1270 NetMessage.SendData(17, -1, -1, null, 0, x, y);
1271 }
1272 }
1273 if (!tile5.active())
1274 {
1275 tile5.liquid = 0;
1276 switch (thisLiquidType)
1277 {
1278 case 1:
1279 tile5.lava(lava: false);
1280 break;
1281 case 2:
1282 tile5.honey(honey: false);
1283 break;
1284 case 3:
1285 tile5.shimmer(shimmer: false);
1286 break;
1287 }
1288 TileChangeType liquidChangeType = WorldGen.GetLiquidChangeType(thisLiquidType, liquidMergeType);
1289 if (!WorldGen.gen)
1290 {
1291 WorldGen.PlayLiquidChangeSound(liquidChangeType, x, y);
1292 }
1293 WorldGen.PlaceTile(x, y, liquidMergeTileType, mute: true, forced: true);
1294 WorldGen.SquareTileFrame(x, y);
1295 if (Main.netMode == 2)
1296 {
1297 NetMessage.SendTileSquare(-1, x - 1, y - 1, 3, liquidChangeType);
1298 }
1299 }
1300 }
1301 else
1302 {
1303 if (tile4.liquid <= 0 || tile4.liquidType() == thisLiquidType)
1304 {
1305 return;
1306 }
1307 bool flag = false;
1308 if (tile5.active() && TileID.Sets.IsAContainer[tile5.type] && !TileID.Sets.IsAContainer[tile4.type])
1309 {
1310 flag = true;
1311 }
1312 if (thisLiquidType != 0 && Main.tileCut[tile4.type])
1313 {
1314 WorldGen.KillTile(x, y + 1);
1315 if (Main.netMode == 2)
1316 {
1317 NetMessage.SendData(17, -1, -1, null, 0, x, y + 1);
1318 }
1319 }
1320 else if (tile4.active() && Main.tileObsidianKill[tile4.type])
1321 {
1322 WorldGen.KillTile(x, y + 1);
1323 if (Main.netMode == 2)
1324 {
1325 NetMessage.SendData(17, -1, -1, null, 0, x, y + 1);
1326 }
1327 }
1328 if (!(!tile4.active() || flag))
1329 {
1330 return;
1331 }
1332 if (tile5.liquid < 24)
1333 {
1334 tile5.liquid = 0;
1335 tile5.liquidType(0);
1336 if (Main.netMode == 2)
1337 {
1338 NetMessage.SendTileSquare(-1, x - 1, y, 3);
1339 }
1340 return;
1341 }
1342 int liquidMergeTileType2 = 56;
1343 int liquidMergeType2 = 0;
1344 bool waterNearby2 = tile4.liquidType() == 0;
1345 bool lavaNearby2 = tile4.lava();
1346 bool honeyNearby2 = tile4.honey();
1347 bool shimmerNearby2 = tile4.shimmer();
1348 GetLiquidMergeTypes(thisLiquidType, out liquidMergeTileType2, out liquidMergeType2, waterNearby2, lavaNearby2, honeyNearby2, shimmerNearby2);
1349 tile5.liquid = 0;
1350 switch (thisLiquidType)
1351 {
1352 case 1:
1353 tile5.lava(lava: false);
1354 break;
1355 case 2:
1356 tile5.honey(honey: false);
1357 break;
1358 case 3:
1359 tile5.shimmer(shimmer: false);
1360 break;
1361 }
1362 tile4.liquid = 0;
1363 TileChangeType liquidChangeType2 = WorldGen.GetLiquidChangeType(thisLiquidType, liquidMergeType2);
1364 if (!Main.gameMenu)
1365 {
1366 WorldGen.PlayLiquidChangeSound(liquidChangeType2, x, y);
1367 }
1368 WorldGen.PlaceTile(x, y + 1, liquidMergeTileType2, mute: true, forced: true);
1369 WorldGen.SquareTileFrame(x, y + 1);
1370 if (Main.netMode == 2)
1371 {
1372 NetMessage.SendTileSquare(-1, x - 1, y, 3, liquidChangeType2);
1373 }
1374 }
1375 }
1376
1377 public static void GetLiquidMergeTypes(int thisLiquidType, out int liquidMergeTileType, out int liquidMergeType, bool waterNearby, bool lavaNearby, bool honeyNearby, bool shimmerNearby)
1378 {
1379 liquidMergeTileType = 56;
1380 liquidMergeType = thisLiquidType;
1381 if (thisLiquidType != 0 && waterNearby)
1382 {
1383 switch (thisLiquidType)
1384 {
1385 case 1:
1386 liquidMergeTileType = 56;
1387 break;
1388 case 2:
1389 liquidMergeTileType = 229;
1390 break;
1391 case 3:
1392 liquidMergeTileType = 659;
1393 break;
1394 }
1395 liquidMergeType = 0;
1396 }
1397 if (thisLiquidType != 1 && lavaNearby)
1398 {
1399 switch (thisLiquidType)
1400 {
1401 case 0:
1402 liquidMergeTileType = 56;
1403 break;
1404 case 2:
1405 liquidMergeTileType = 230;
1406 break;
1407 case 3:
1408 liquidMergeTileType = 659;
1409 break;
1410 }
1411 liquidMergeType = 1;
1412 }
1413 if (thisLiquidType != 2 && honeyNearby)
1414 {
1415 switch (thisLiquidType)
1416 {
1417 case 0:
1418 liquidMergeTileType = 229;
1419 break;
1420 case 1:
1421 liquidMergeTileType = 230;
1422 break;
1423 case 3:
1424 liquidMergeTileType = 659;
1425 break;
1426 }
1427 liquidMergeType = 2;
1428 }
1429 if (thisLiquidType != 3 && shimmerNearby)
1430 {
1431 switch (thisLiquidType)
1432 {
1433 case 0:
1434 liquidMergeTileType = 659;
1435 break;
1436 case 1:
1437 liquidMergeTileType = 659;
1438 break;
1439 case 2:
1440 liquidMergeTileType = 659;
1441 break;
1442 }
1443 liquidMergeType = 3;
1444 }
1445 }
1446
1447 public static void LavaCheck(int x, int y)
1448 {
1449 if (!WorldGen.remixWorldGen && WorldGen.generatingWorld && UndergroundDesertCheck(x, y))
1450 {
1451 for (int i = x - 3; i <= x + 3; i++)
1452 {
1453 for (int j = y - 3; j <= y + 3; j++)
1454 {
1455 Main.tile[i, j].lava(lava: true);
1456 }
1457 }
1458 }
1459 LiquidCheck(x, y, 1);
1460 }
1461
1462 public static void HoneyCheck(int x, int y)
1463 {
1464 LiquidCheck(x, y, 2);
1465 }
1466
1467 public static void ShimmerCheck(int x, int y)
1468 {
1469 LiquidCheck(x, y, 3);
1470 }
1471
1472 public static void DelWater(int l)
1473 {
1474 int num = Main.liquid[l].x;
1475 int num2 = Main.liquid[l].y;
1476 Tile tile = Main.tile[num - 1, num2];
1477 Tile tile2 = Main.tile[num + 1, num2];
1478 Tile tile3 = Main.tile[num, num2 + 1];
1479 Tile tile4 = Main.tile[num, num2];
1480 byte b = 2;
1481 if (tile4.liquid < b)
1482 {
1483 tile4.liquid = 0;
1484 if (tile.liquid < b)
1485 {
1486 tile.liquid = 0;
1487 }
1488 else
1489 {
1490 AddWater(num - 1, num2);
1491 }
1492 if (tile2.liquid < b)
1493 {
1494 tile2.liquid = 0;
1495 }
1496 else
1497 {
1498 AddWater(num + 1, num2);
1499 }
1500 }
1501 else if (tile4.liquid < 20)
1502 {
1503 if ((tile.liquid < tile4.liquid && (!tile.nactive() || !Main.tileSolid[tile.type] || Main.tileSolidTop[tile.type])) || (tile2.liquid < tile4.liquid && (!tile2.nactive() || !Main.tileSolid[tile2.type] || Main.tileSolidTop[tile2.type])) || (tile3.liquid < byte.MaxValue && (!tile3.nactive() || !Main.tileSolid[tile3.type] || Main.tileSolidTop[tile3.type])))
1504 {
1505 tile4.liquid = 0;
1506 }
1507 }
1508 else if (tile3.liquid < byte.MaxValue && (!tile3.nactive() || !Main.tileSolid[tile3.type] || Main.tileSolidTop[tile3.type]) && !stuck && (!Main.tile[num, num2].nactive() || !Main.tileSolid[Main.tile[num, num2].type] || Main.tileSolidTop[Main.tile[num, num2].type]))
1509 {
1510 Main.liquid[l].kill = 0;
1511 return;
1512 }
1513 if (tile4.liquid < 250 && Main.tile[num, num2 - 1].liquid > 0)
1514 {
1515 AddWater(num, num2 - 1);
1516 }
1517 if (tile4.liquid == 0)
1518 {
1519 tile4.liquidType(0);
1520 }
1521 else
1522 {
1523 if (tile2.liquid > 0 && tile2.liquid < 250 && (!tile2.nactive() || !Main.tileSolid[tile2.type] || Main.tileSolidTop[tile2.type]) && tile4.liquid != tile2.liquid)
1524 {
1525 AddWater(num + 1, num2);
1526 }
1527 if (tile.liquid > 0 && tile.liquid < 250 && (!tile.nactive() || !Main.tileSolid[tile.type] || Main.tileSolidTop[tile.type]) && tile4.liquid != tile.liquid)
1528 {
1529 AddWater(num - 1, num2);
1530 }
1531 if (tile4.lava())
1532 {
1533 LavaCheck(num, num2);
1534 for (int i = num - 1; i <= num + 1; i++)
1535 {
1536 for (int j = num2 - 1; j <= num2 + 1; j++)
1537 {
1538 Tile tile5 = Main.tile[i, j];
1539 if (!tile5.active())
1540 {
1541 continue;
1542 }
1543 if (tile5.type == 2 || tile5.type == 23 || tile5.type == 109 || tile5.type == 199 || tile5.type == 477 || tile5.type == 492)
1544 {
1545 tile5.type = 0;
1546 WorldGen.SquareTileFrame(i, j);
1547 if (Main.netMode == 2)
1548 {
1549 NetMessage.SendTileSquare(-1, num, num2, 3);
1550 }
1551 }
1552 else if (tile5.type == 60 || tile5.type == 70 || tile5.type == 661 || tile5.type == 662)
1553 {
1554 tile5.type = 59;
1555 WorldGen.SquareTileFrame(i, j);
1556 if (Main.netMode == 2)
1557 {
1558 NetMessage.SendTileSquare(-1, num, num2, 3);
1559 }
1560 }
1561 }
1562 }
1563 }
1564 else if (tile4.honey())
1565 {
1566 HoneyCheck(num, num2);
1567 }
1568 else if (tile4.shimmer())
1569 {
1570 ShimmerCheck(num, num2);
1571 }
1572 }
1573 if (Main.netMode == 2)
1574 {
1575 NetSendLiquid(num, num2);
1576 }
1577 numLiquid--;
1578 Main.tile[Main.liquid[l].x, Main.liquid[l].y].checkingLiquid(checkingLiquid: false);
1579 Main.liquid[l].x = Main.liquid[numLiquid].x;
1580 Main.liquid[l].y = Main.liquid[numLiquid].y;
1581 Main.liquid[l].kill = Main.liquid[numLiquid].kill;
1582 if (Main.tileAlch[tile4.type])
1583 {
1584 WorldGen.CheckAlch(num, num2);
1585 }
1586 else if (tile4.type == 518)
1587 {
1588 if (quickFall)
1589 {
1590 WorldGen.CheckLilyPad(num, num2);
1591 }
1592 else if (Main.tile[num, num2 + 1].liquid < byte.MaxValue || Main.tile[num, num2 - 1].liquid > 0)
1593 {
1594 WorldGen.SquareTileFrame(num, num2);
1595 }
1596 else
1597 {
1598 WorldGen.CheckLilyPad(num, num2);
1599 }
1600 }
1601 }
1602}
System.Console.WriteLine
static void WriteLine()
Definition Console.cs:733
System.Math.Round
static decimal Round(decimal d)
Definition Math.cs:1096
Terraria.GameContent.NetModules.NetLiquidModule.CreateAndBroadcastByChunk
static void CreateAndBroadcastByChunk(HashSet< int > dirtiedPackedTileCoords)
Definition NetLiquidModule.cs:93
Terraria.ID.TileID.Sets.IsAContainer
static bool[] IsAContainer
Definition TileID.cs:297
Terraria.Lang.gen
static LocalizedText[] gen
Definition Lang.cs:22
Terraria.LiquidBuffer.DelBuffer
static void DelBuffer(int l)
Definition LiquidBuffer.cs:22
Terraria.LiquidBuffer.AddBuffer
static void AddBuffer(int x, int y)
Definition LiquidBuffer.cs:11
Terraria.LiquidBuffer.numLiquidBuffer
static int numLiquidBuffer
Definition LiquidBuffer.cs:5
Terraria.Liquid.AttemptToMoveShimmer
static void AttemptToMoveShimmer(int X, int Y, bool tileAtXYHasShimmer)
Definition Liquid.cs:378
Terraria.Liquid.GetLiquidMergeTypes
static void GetLiquidMergeTypes(int thisLiquidType, out int liquidMergeTileType, out int liquidMergeType, bool waterNearby, bool lavaNearby, bool honeyNearby, bool shimmerNearby)
Definition Liquid.cs:1377
Terraria.Liquid.ShimmerCheck
static void ShimmerCheck(int x, int y)
Definition Liquid.cs:1467
Terraria.Liquid.curMaxLiquid
static int curMaxLiquid
Definition Liquid.cs:25
Terraria.Liquid.panicCounter
static int panicCounter
Definition Liquid.cs:37
Terraria.Liquid.HoneyCheck
static void HoneyCheck(int x, int y)
Definition Liquid.cs:1462
Terraria.Liquid.panicY
static int panicY
Definition Liquid.cs:41
Terraria.Liquid.quickFall
static bool quickFall
Definition Liquid.cs:31
Terraria.Liquid.maxLiquidBuffer
const int maxLiquidBuffer
Definition Liquid.cs:13
Terraria.Liquid.tilesIgnoreWater
static void tilesIgnoreWater(bool ignoreSolids)
Definition Liquid.cs:67
Terraria.Liquid.AttemptToMoveHoney
static void AttemptToMoveHoney(int X, int Y, bool tileAtXYHasHoney)
Definition Liquid.cs:282
Terraria.Liquid.SettleWaterAt
static void SettleWaterAt(int originX, int originY)
Definition Liquid.cs:145
Terraria.Liquid.wetCounter
static int wetCounter
Definition Liquid.cs:35
Terraria.Liquid.worldGenTilesIgnoreWater
static void worldGenTilesIgnoreWater(bool ignoreSolids)
Definition Liquid.cs:74
Terraria.Liquid.maxLiquid
static int maxLiquid
Definition Liquid.cs:15
Terraria.Liquid.stuck
static bool stuck
Definition Liquid.cs:29
Terraria.Liquid.UpdateLiquid
static void UpdateLiquid()
Definition Liquid.cs:983
Terraria.Liquid.StartPanic
static void StartPanic()
Definition Liquid.cs:966
Terraria.Liquid.ReInit
static void ReInit()
Definition Liquid.cs:82
Terraria.Liquid._netChangeSet
static HashSet< int > _netChangeSet
Definition Liquid.cs:51
Terraria.Liquid.AddWater
static void AddWater(int x, int y)
Definition Liquid.cs:1160
Terraria.Liquid._swapNetChangeSet
static HashSet< int > _swapNetChangeSet
Definition Liquid.cs:53
Terraria.Liquid.UpdateProgressDisplay
static void UpdateProgressDisplay(int verbose, int minY, int maxY, int y)
Definition Liquid.cs:426
Terraria.Liquid.UndergroundDesertCheck
static bool UndergroundDesertCheck(int x, int y)
Definition Liquid.cs:1209
Terraria.Liquid.panicMode
static bool panicMode
Definition Liquid.cs:39
Terraria.Liquid.numLiquid
static int numLiquid
Definition Liquid.cs:27
Terraria.Liquid.stuckAmount
static int stuckAmount
Definition Liquid.cs:21
Terraria.Liquid.NetSendLiquid
static void NetSendLiquid(int x, int y)
Definition Liquid.cs:55
Terraria.Liquid.cycles
static int cycles
Definition Liquid.cs:23
Terraria.Liquid.LavaCheck
static void LavaCheck(int x, int y)
Definition Liquid.cs:1447
Terraria.Liquid.stuckCount
static int stuckCount
Definition Liquid.cs:19
Terraria.Liquid.skipCount
static int skipCount
Definition Liquid.cs:17
Terraria.Liquid.DelWater
static void DelWater(int l)
Definition Liquid.cs:1472
Terraria.Liquid.QuickWater
static void QuickWater(int verbose=0, int minY=-1, int maxY=-1)
Definition Liquid.cs:103
Terraria.Liquid.AttemptToMoveLava
static void AttemptToMoveLava(int X, int Y, bool tileAtXYHasLava)
Definition Liquid.cs:330
Terraria.Liquid.Update
void Update()
Definition Liquid.cs:442
Terraria.Liquid.LiquidCheck
static void LiquidCheck(int x, int y, int thisLiquidType)
Definition Liquid.cs:1225
Terraria.Liquid.quickSettle
static bool quickSettle
Definition Liquid.cs:33
Terraria.Localization.Language.GetTextValue
static string GetTextValue(string key)
Definition Language.cs:15
Terraria.Main.maxSectionsY
static int maxSectionsY
Definition Main.cs:1124
Terraria.Main.maxSectionsX
static int maxSectionsX
Definition Main.cs:1122
Terraria.Main.maxTilesY
static int maxTilesY
Definition Main.cs:1116
Terraria.Main.tileSolidTop
static bool[] tileSolidTop
Definition Main.cs:1469
Terraria.Main.tileCut
static bool[] tileCut
Definition Main.cs:1433
Terraria.Main.Setting_UseReducedMaxLiquids
static bool Setting_UseReducedMaxLiquids
Definition Main.cs:1733
Terraria.Main.netMode
static int netMode
Definition Main.cs:2095
Terraria.Main.dedServ
static bool dedServ
Definition Main.cs:1226
Terraria.Main.maxTilesX
static int maxTilesX
Definition Main.cs:1114
Terraria.Main.tileAlch
static bool[] tileAlch
Definition Main.cs:1435
Terraria.Main.tileSolid
static bool[] tileSolid
Definition Main.cs:1471
Terraria.Main.tile
static Tile[,] tile
Definition Main.cs:1675
Terraria.Main.liquidBuffer
static LiquidBuffer[] liquidBuffer
Definition Main.cs:1224
Terraria.Main.tileObsidianKill
static bool[] tileObsidianKill
Definition Main.cs:1493
Terraria.Main.liquid
static Liquid[] liquid
Definition Main.cs:1222
Terraria.Main.UnderworldLayer
static int UnderworldLayer
Definition Main.cs:2825
Terraria.Main.gameMenu
static bool gameMenu
Definition Main.cs:1926
Terraria.Main.player
static Player[] player
Definition Main.cs:1803
Terraria.NetMessage.SendData
static void SendData(int msgType, int remoteClient=-1, int ignoreClient=-1, NetworkText text=null, int number=0, float number2=0f, float number3=0f, float number4=0f, int number5=0, int number6=0, int number7=0)
Definition NetMessage.cs:88
Terraria.NetMessage.SendTileSquare
static void SendTileSquare(int whoAmi, int tileX, int tileY, int xSize, int ySize, TileChangeType changeType=TileChangeType.None)
Definition NetMessage.cs:2602
Terraria.Netplay.Clients
static RemoteClient[] Clients
Definition Netplay.cs:37
Terraria.ObjectData.TileObjectData.CheckWaterDeath
static bool CheckWaterDeath(int type, int style)
Definition TileObjectData.cs:4333
Terraria.ObjectData.TileObjectData.CheckLavaDeath
static bool CheckLavaDeath(int type, int style)
Definition TileObjectData.cs:4347
Terraria.Tile.liquidType
void liquidType(int liquidType)
Definition Tile.cs:233
Terraria.Tile.nactive
bool nactive()
Definition Tile.cs:257
Terraria.Tile.checkingLiquid
bool checkingLiquid()
Definition Tile.cs:470
Terraria.Tile.liquid
byte liquid
Definition Tile.cs:12
Terraria.Tile.type
ushort type
Definition Tile.cs:8
Terraria.Tile.active
bool active()
Definition Tile.cs:565
Terraria.Tile.honey
bool honey()
Definition Tile.cs:379
Terraria.Tile.lava
bool lava()
Definition Tile.cs:362
Terraria.Tile.shimmer
bool shimmer()
Definition Tile.cs:396
Terraria.Tile.skipLiquid
bool skipLiquid()
Definition Tile.cs:487
Terraria.WorldGen.remixWorldGen
static bool remixWorldGen
Definition WorldGen.cs:1148
Terraria.WorldGen.gen
static volatile bool gen
Definition WorldGen.cs:972
Terraria.WorldGen.SolidTile
static bool SolidTile(Tile testTile)
Definition WorldGen.cs:60593
Terraria.WorldGen.CheckLilyPad
static void CheckLilyPad(int x, int y)
Definition WorldGen.cs:50133
Terraria.WorldGen.KillTile
static void KillTile(int i, int j, bool fail=false, bool effectOnly=false, bool noItem=false)
Definition WorldGen.cs:54141
Terraria.WorldGen.CheckAlch
static void CheckAlch(int x, int y)
Definition WorldGen.cs:36898
Terraria.WorldGen.noTrapsWorldGen
static bool noTrapsWorldGen
Definition WorldGen.cs:1152
Terraria.WorldGen.PlaceTile
static bool PlaceTile(int i, int j, int Type, bool mute=false, bool forced=false, int plr=-1, int style=0)
Definition WorldGen.cs:50270
Terraria.WorldGen.genRand
static UnifiedRandom genRand
Definition WorldGen.cs:1215
Terraria.WorldGen.oceanDepths
static bool oceanDepths(int x, int y)
Definition WorldGen.cs:7142
Terraria.WorldGen.generatingWorld
static bool generatingWorld
Definition WorldGen.cs:1122
Terraria.WorldGen.PlayLiquidChangeSound
static void PlayLiquidChangeSound(TileChangeType eventType, int x, int y, int count=1)
Definition WorldGen.cs:1424
Terraria.WorldGen.GetLiquidChangeType
static TileChangeType GetLiquidChangeType(int liquidType, int otherLiquidType)
Definition WorldGen.cs:1449
Terraria.WorldGen.ShimmerRemoveWater
static void ShimmerRemoveWater()
Definition WorldGen.cs:26269
Terraria.WorldGen.InWorld
static bool InWorld(int x, int y, int fluff=0)
Definition WorldGen.cs:5816
Terraria.WorldGen.SquareTileFrame
static void SquareTileFrame(int i, int j, bool resetFrame=true)
Definition WorldGen.cs:70362
Terraria.WorldGen.WaterCheck
static void WaterCheck()
Definition WorldGen.cs:70574