コード例 #1
0
        public static void UpdateLiquid()
        {
            Liquid.cycles    = 25;
            Liquid.maxLiquid = 5000;

            if (!WorldModify.gen)
            {
                if (!Liquid.panicMode)
                {
                    if (Liquid.numLiquid + LiquidBuffer.numLiquidBuffer > 4000)
                    {
                        Liquid.panicCounter++;
                        if (Liquid.panicCounter > 1800 || Liquid.numLiquid + LiquidBuffer.numLiquidBuffer > 13500)
                        {
                            Liquid.StartPanic();
                        }
                    }
                    else
                    {
                        Liquid.panicCounter = 0;
                    }
                }

                if (Liquid.panicMode)
                {
                    try
                    {
                        Terraria_Server.Networking.LiquidUpdateBuffer.ClearQueue();
                        NetMessage.DisableLiquidUpdates = true;

                        int num = 0;
                        while (Liquid.panicY >= 3 && num < 5)
                        {
                            num++;
                            Liquid.QuickWater(0, Liquid.panicY, Liquid.panicY);
                            Liquid.panicY--;
                            if (Liquid.panicY < 3)
                            {
                                ProgramLog.Log("Water has been settled.");
                                Liquid.panicCounter = 0;
                                Liquid.panicMode    = false;
                                using (var prog = new ProgressLogger(Main.maxTilesX - 2, "Performing water check"))
                                    WorldModify.WaterCheck(prog);
                                for (int i = 0; i < 255; i++)
                                {
                                    for (int j = 0; j < Main.maxSectionsX; j++)
                                    {
                                        for (int k = 0; k < Main.maxSectionsY; k++)
                                        {
                                            NetPlay.slots[i].tileSection[j, k] = false;
                                        }
                                    }
                                }
                            }
                        }
                        return;
                    }
                    finally
                    {
                        NetMessage.DisableLiquidUpdates = false;
                    }
                }
            }

            if (Liquid.quickSettle || Liquid.numLiquid > 2000)
            {
                Liquid.quickFall = true;
            }
            else
            {
                Liquid.quickFall = false;
            }

            Liquid.wetCounter++;

            int num2 = Liquid.maxLiquid / Liquid.cycles;

            int num3 = num2 * (Liquid.wetCounter - 1);

            int num4 = num2 * Liquid.wetCounter;

            if (Liquid.wetCounter == Liquid.cycles)
            {
                num4 = Liquid.numLiquid;
            }

            if (num4 > Liquid.numLiquid)
            {
                num4 = Liquid.numLiquid;
                Liquid.wetCounter = Liquid.cycles;
            }

            if (Liquid.quickFall)
            {
                for (int l = num3; l < num4; l++)
                {
                    Main.liquid[l].delay = 10;
                    Main.liquid[l].Update();
                    Main.tile.At(Main.liquid[l].x, Main.liquid[l].y).SetSkipLiquid(false);
                }
            }
            else
            {
                for (int m = num3; m < num4; m++)
                {
                    if (!Main.tile.At(Main.liquid[m].x, Main.liquid[m].y).SkipLiquid)
                    {
                        Main.liquid[m].Update();
                    }
                    else
                    {
                        Main.tile.At(Main.liquid[m].x, Main.liquid[m].y).SetSkipLiquid(false);
                    }
                }
            }

            if (Liquid.wetCounter >= Liquid.cycles)
            {
                Liquid.wetCounter = 0;
                for (int n = Liquid.numLiquid - 1; n >= 0; n--)
                {
                    if (Main.liquid[n].kill > 3)
                    {
                        Liquid.DelWater(n);
                    }
                }

                int num5 = Liquid.maxLiquid - (Liquid.maxLiquid - Liquid.numLiquid);

                if (num5 > LiquidBuffer.numLiquidBuffer)
                {
                    num5 = LiquidBuffer.numLiquidBuffer;
                }

                for (int num6 = 0; num6 < num5; num6++)
                {
                    Main.tile.At(Main.liquidBuffer[0].x, Main.liquidBuffer[0].y).SetCheckingLiquid(false);
                    Liquid.AddWater(Main.liquidBuffer[0].x, Main.liquidBuffer[0].y);
                    LiquidBuffer.DelBuffer(0);
                }

                if (Liquid.numLiquid > 0 && Liquid.numLiquid > Liquid.stuckAmount - 50 && Liquid.numLiquid < Liquid.stuckAmount + 50)
                {
                    Liquid.stuckCount++;
                    if (Liquid.stuckCount >= 10000)
                    {
                        Liquid.stuck = true;
                        for (int num7 = Liquid.numLiquid - 1; num7 >= 0; num7--)
                        {
                            Liquid.DelWater(num7);
                        }
                        Liquid.stuck      = false;
                        Liquid.stuckCount = 0;
                        return;
                    }
                }
                else
                {
                    Liquid.stuckCount  = 0;
                    Liquid.stuckAmount = Liquid.numLiquid;
                }
            }
        }
コード例 #2
0
        public static void UpdateLiquid(Func <Int32, Int32, ITile> TileRefs, ISandbox sandbox)
        {
            if (TileRefs == null)
            {
                TileRefs = TileCollection.ITileAt;
            }

            //{
            //Liquid.cycles = 30;
            //    Liquid.maxLiquid = 6000;
            //}

            if (!WorldModify.gen)
            {
                if (!Liquid.panicMode)
                {
                    if (Liquid.numLiquid + LiquidBuffer.numLiquidBuffer > 4000)
                    {
                        Liquid.panicCounter++;
                        if (Liquid.panicCounter > 1800 || Liquid.numLiquid + LiquidBuffer.numLiquidBuffer > 13500)
                        {
                            Liquid.StartPanic();
                        }
                    }
                    else
                    {
                        Liquid.panicCounter = 0;
                    }
                }

                if (Liquid.panicMode)
                {
                    int num = 0;
                    while (Liquid.panicY >= 3 && num < 5)
                    {
                        num++;
                        Liquid.QuickWater(TileRefs, sandbox, 0, Liquid.panicY, Liquid.panicY);
                        Liquid.panicY--;
                        if (Liquid.panicY < 3)
                        {
                            ProgramLog.Log(Languages.Water_WaterHasBeenSettled);
                            Liquid.panicCounter = 0;
                            Liquid.panicMode    = false;

                            using (var prog = new ProgressLogger(Main.maxTilesX - 2, Languages.Water_PerformingWaterCheck))
                                WorldModify.WaterCheck(TileRefs, sandbox, prog);

                            for (int i = 0; i < 255; i++)
                            {
                                for (int j = 0; j < Main.maxSectionsX; j++)
                                {
                                    for (int k = 0; k < Main.maxSectionsY; k++)
                                    {
                                        NetPlay.slots[i].tileSection[j, k] = false;
                                    }
                                }
                            }
                        }
                    }
                    return;
                }
            }

            Liquid.quickFall = Liquid.quickSettle || Liquid.numLiquid > 2000;
            Liquid.wetCounter++;

            int num2 = Liquid.maxLiquid / Liquid.cycles;
            int num3 = num2 * (Liquid.wetCounter - 1);
            int num4 = num2 * Liquid.wetCounter;

            if (Liquid.wetCounter == Liquid.cycles)
            {
                num4 = Liquid.numLiquid;
            }

            if (num4 > Liquid.numLiquid)
            {
                num4 = Liquid.numLiquid;
                Liquid.wetCounter = Liquid.cycles;
            }

            if (Liquid.quickFall)
            {
                for (int l = num3; l < num4; l++)
                {
                    Main.liquid[l].delay = 10;
                    Main.liquid[l].Update(TileRefs, sandbox);
                    TileRefs(Main.liquid[l].x, Main.liquid[l].y).SetSkipLiquid(false);
                }
            }
            else
            {
                for (int m = num3; m < num4; m++)
                {
                    if (!TileRefs(Main.liquid[m].x, Main.liquid[m].y).SkipLiquid)
                    {
                        Main.liquid[m].Update(TileRefs, sandbox);
                    }
                    else
                    {
                        TileRefs(Main.liquid[m].x, Main.liquid[m].y).SetSkipLiquid(false);
                    }
                }
            }

            if (Liquid.wetCounter >= Liquid.cycles)
            {
                Liquid.wetCounter = 0;

                for (int n = Liquid.numLiquid - 1; n >= 0; n--)
                {
                    if (Main.liquid[n].kill > 3)
                    {
                        Liquid.DelWater(TileRefs, sandbox, n);
                    }
                }

                int num5 = Liquid.maxLiquid - (Liquid.maxLiquid - Liquid.numLiquid);
                if (num5 > LiquidBuffer.numLiquidBuffer)
                {
                    num5 = LiquidBuffer.numLiquidBuffer;
                }

                for (int num6 = 0; num6 < num5; num6++)
                {
                    TileRefs(Main.liquidBuffer[0].x, Main.liquidBuffer[0].y).SetCheckingLiquid(false);
                    Liquid.AddWater(TileRefs, sandbox, Main.liquidBuffer[0].x, Main.liquidBuffer[0].y);
                    LiquidBuffer.DelBuffer(0);
                }

                if (Liquid.numLiquid > 0 && Liquid.numLiquid > Liquid.stuckAmount - 50 && Liquid.numLiquid < Liquid.stuckAmount + 50)
                {
                    Liquid.stuckCount++;
                    if (Liquid.stuckCount >= 10000)
                    {
                        Liquid.stuck = true;

                        for (int num7 = Liquid.numLiquid - 1; num7 >= 0; num7--)
                        {
                            Liquid.DelWater(TileRefs, sandbox, num7);
                        }

                        Liquid.stuck      = false;
                        Liquid.stuckCount = 0;
                        return;
                    }
                }
                else
                {
                    Liquid.stuckCount  = 0;
                    Liquid.stuckAmount = Liquid.numLiquid;
                }
            }
        }