Lock() public method

public Lock ( ) : void
return void
Exemplo n.º 1
0
        private void NetHooks_GetData(GetDataEventArgs e)
        {
            switch (e.MsgID)
            {
            case PacketTypes.ChestGetContents:
                if (!e.Handled)
                {
                    using (var data = new MemoryStream(e.Msg.readBuffer, e.Index, e.Length))
                    {
                        var reader = new BinaryReader(data);
                        int x      = reader.ReadInt32();
                        int y      = reader.ReadInt32();
                        reader.Close();
                        int      id      = Terraria.Chest.FindChest(x, y);
                        CPlayer  player  = Players[e.Msg.whoAmI];
                        TPPlayer tplayer = tPulse.Players[e.Msg.whoAmI];
                        if (id != -1)
                        {
                            Chest chest           = ChestManager.GetChest(id);
                            bool  naggedAboutLock = false;

                            switch (player.GetState())
                            {
                            case SettingState.Setting:
                                if (chest.HasOwner())
                                {
                                    if (chest.IsOwnerConvert(player))
                                    {
                                        player.SendMessage("You already own this chest!", Color.Red);
                                    }
                                    else
                                    {
                                        player.SendMessage("This chest is already owned by someone!", Color.Red);
                                        naggedAboutLock = true;
                                    }
                                }
                                else
                                {
                                    chest.SetID(id);
                                    chest.SetPosition(x, y);
                                    chest.SetOwner(player);
                                    chest.Lock();

                                    player.SendMessage("This chest is now yours, and yours only.", Color.Red);
                                }

                                //end player setting
                                player.SetState(SettingState.None);
                                break;

                            case SettingState.RegionSetting:
                                if (chest.HasOwner())
                                {
                                    if (chest.IsOwnerConvert(player))
                                    {
                                        if (chest.IsRegionLocked())
                                        {
                                            chest.regionLock(false);

                                            player.SendMessage(
                                                "Region share disabled. This chest is now only yours. To fully remove protection use \"cunset\".",
                                                Color.Red);
                                        }
                                        else if (tPulse.Regions.InArea(x, y))
                                        {
                                            chest.regionLock(true);

                                            player.SendMessage(
                                                "This chest is now shared between region users. Use this command again to disable it.",
                                                Color.Red);
                                        }
                                        else
                                        {
                                            player.SendMessage(
                                                "You can region share chest only if the chest is inside region!",
                                                Color.Red);
                                        }
                                    }
                                    else
                                    {
                                        player.SendMessage("This chest isn't yours!", Color.Red);
                                        naggedAboutLock = true;
                                    }
                                }
                                else if (tPulse.Regions.InArea(x, y))
                                {
                                    chest.SetID(id);
                                    chest.SetPosition(x, y);
                                    chest.SetOwner(player);
                                    chest.Lock();
                                    chest.regionLock(true);

                                    player.SendMessage(
                                        "This chest is now shared between region users with you as owner. Use this command again to disable region sharing (You will still be owner).",
                                        Color.Red);
                                }
                                else
                                {
                                    player.SendMessage(
                                        "You can region share chest only if the chest is inside region!",
                                        Color.Red);
                                }

                                //end player setting
                                player.SetState(SettingState.None);
                                break;

                            case SettingState.PublicSetting:
                                if (chest.HasOwner())
                                {
                                    if (chest.IsOwnerConvert(player))
                                    {
                                        if (chest.IsLocked())
                                        {
                                            chest.UnLock();
                                            player.SendMessage(
                                                "This chest is now public! Use \"/cpset\" to set it private.",
                                                Color.Red);
                                        }
                                        else
                                        {
                                            chest.Lock();
                                            player.SendMessage(
                                                "This chest is now private! Use \"/cpset\" to set it public.",
                                                Color.Red);
                                        }
                                    }
                                    else
                                    {
                                        player.SendMessage("This chest isn't yours!", Color.Red);
                                        naggedAboutLock = true;
                                    }
                                }
                                else
                                {
                                    chest.SetID(id);
                                    chest.SetPosition(x, y);
                                    chest.SetOwner(player);

                                    player.SendMessage(
                                        "This chest is now yours. This chest is public. Use \"/cpset\" to set it private.",
                                        Color.Red);
                                }
                                break;

                            case SettingState.Deleting:
                                if (chest.HasOwner())
                                {
                                    if (chest.IsOwnerConvert(player) ||
                                        tplayer.Group.HasPermission("removechestprotection"))
                                    {
                                        chest.Reset();
                                        player.SendMessage("This chest is no longer yours!", Color.Red);
                                    }
                                    else
                                    {
                                        player.SendMessage("This chest isn't yours!", Color.Red);
                                        naggedAboutLock = true;
                                    }
                                }
                                else
                                {
                                    player.SendMessage("This chest is not protected!", Color.Red);
                                }

                                //end player setting
                                player.SetState(SettingState.None);
                                break;

                            case SettingState.PasswordSetting:
                                if (chest.HasOwner())
                                {
                                    if (chest.IsOwnerConvert(player))
                                    {
                                        chest.SetPassword(player.PasswordForChest);
                                        player.SendMessage("This chest is now protected with password.",
                                                           Color.Red);
                                    }
                                    else
                                    {
                                        player.SendMessage("This chest isn't yours!", Color.Red);
                                        naggedAboutLock = true;
                                    }
                                }
                                else
                                {
                                    chest.SetID(id);
                                    chest.SetPosition(x, y);
                                    chest.SetOwner(player);
                                    chest.Lock();
                                    chest.SetPassword(player.PasswordForChest);

                                    player.SendMessage(
                                        "This chest is now protected with password, with you as owner.",
                                        Color.Red);
                                }

                                //end player setting
                                player.SetState(SettingState.None);
                                break;

                            case SettingState.PasswordUnSetting:
                                if (chest.HasOwner())
                                {
                                    if (chest.IsOwnerConvert(player))
                                    {
                                        chest.SetPassword("");
                                        player.SendMessage("This chest password has been removed.", Color.Red);
                                    }
                                    else
                                    {
                                        player.SendMessage("This chest isn't yours!", Color.Red);
                                        naggedAboutLock = true;
                                    }
                                }
                                else
                                {
                                    player.SendMessage("This chest is not protected!", Color.Red);
                                }

                                //end player setting
                                player.SetState(SettingState.None);
                                break;

                            case SettingState.RefillSetting:
                                if (chest.HasOwner())
                                {
                                    if (chest.IsOwnerConvert(player))
                                    {
                                        chest.SetRefill(true);
                                        player.SendMessage("This chest is will now always refill with items.",
                                                           Color.Red);
                                    }
                                    else
                                    {
                                        player.SendMessage("This chest isn't yours!", Color.Red);
                                        naggedAboutLock = true;
                                    }
                                }
                                else
                                {
                                    chest.SetID(id);
                                    chest.SetPosition(x, y);
                                    chest.SetOwner(player);
                                    chest.SetRefill(true);

                                    player.SendMessage(
                                        "This chest is will now always refill with items, with you as owner.",
                                        Color.Red);
                                }

                                //end player setting
                                player.SetState(SettingState.None);
                                break;

                            case SettingState.RefillUnSetting:
                                if (chest.IsRefill())
                                {
                                    if (chest.HasOwner())
                                    {
                                        if (chest.IsOwnerConvert(player))
                                        {
                                            chest.SetRefill(false);
                                            player.SendMessage(
                                                "This chest is will no longer refill with items.", Color.Red);
                                        }
                                        else
                                        {
                                            player.SendMessage("This chest isn't yours!", Color.Red);
                                            naggedAboutLock = true;
                                        }
                                    }
                                    else
                                    {
                                        chest.SetID(id);
                                        chest.SetPosition(x, y);
                                        chest.SetOwner(player);
                                        chest.SetRefill(false);

                                        player.SendMessage("This chest is will no longer refill with items",
                                                           Color.Red);
                                    }
                                }
                                else
                                {
                                    player.SendMessage("This chest is not refilling!", Color.Red);
                                }

                                //end player setting
                                player.SetState(SettingState.None);
                                break;

                            case SettingState.UnLocking:
                                if (chest.HasOwner())
                                {
                                    if (chest.IsLocked())
                                    {
                                        if (chest.GetPassword() == "")
                                        {
                                            player.SendMessage("This chest can't be unlocked with password!",
                                                               Color.Red);
                                            naggedAboutLock = true;
                                        }
                                        else if (chest.IsOwnerConvert(player))
                                        {
                                            player.SendMessage(
                                                "You are owner of this chest, you dont need to unlock it. If you want to remove password use \"/lockchest remove\".",
                                                Color.Red);
                                        }
                                        else if (player.HasAccessToChest(chest.GetID()))
                                        {
                                            player.SendMessage("You already have access to this chest!",
                                                               Color.Red);
                                        }
                                        else if (chest.CheckPassword(player.PasswordForChest))
                                        {
                                            player.UnlockedChest(chest.GetID());
                                            player.SendMessage(
                                                "Chest unlocked! When you leave game you must unlock it again.",
                                                Color.Red);
                                        }
                                        else
                                        {
                                            player.SendMessage("Wrong password for chest!", Color.Red);
                                            naggedAboutLock = true;
                                        }
                                    }
                                    else
                                    {
                                        player.SendMessage("This chest is not locked!", Color.Red);
                                    }
                                }
                                else
                                {
                                    player.SendMessage("This chest is not protected!", Color.Red);
                                }

                                //end player setting
                                player.SetState(SettingState.None);
                                break;
                            }

                            if (tplayer.Group.HasPermission("showchestinfo"))     //if player should see chest info
                            {
                                player.SendMessage(
                                    string.Format(
                                        "Chest Owner: {0} || Public: {1} || RegionShare: {2} || Password: {3} || Refill: {4}",
                                        chest.GetOwner() == "" ? "-None-" : chest.GetOwner(),
                                        chest.IsLocked() ? "No" : "Yes", chest.IsRegionLocked() ? "Yes" : "No",
                                        chest.GetPassword() == "" ? "No" : "Yes",
                                        chest.IsRefill() ? "Yes" : "No"), Color.Yellow);
                            }

                            if (!tplayer.Group.HasPermission("openallchests") && !chest.IsOpenFor(player))
                            //if player doesnt has permission to see inside chest, then break and message
                            {
                                e.Handled = true;
                                if (!naggedAboutLock)
                                {
                                    player.SendMessage(
                                        chest.GetPassword() != ""
                                                ? "This chest is magically locked with password. ( Use \"/cunlock PASSWORD\" to unlock it. )"
                                                : "This chest is magically locked.", Color.IndianRed);
                                }
                                return;
                            }
                        }
                        if (player.GetState() != SettingState.None)
                        {
                            //if player is still setting something - end his setting
                            player.SetState(SettingState.None);
                        }
                    }
                }
                break;

            case PacketTypes.TileKill:
            case PacketTypes.Tile:
                using (var data = new MemoryStream(e.Msg.readBuffer, e.Index, e.Length))
                    try
                    {
                        var reader = new BinaryReader(data);
                        if (e.MsgID == PacketTypes.Tile)
                        {
                            byte type = reader.ReadByte();
                            if (!(type == 0 || type == 4))
                            {
                                return;
                            }
                        }
                        int x = reader.ReadInt32();
                        int y = reader.ReadInt32();
                        reader.Close();

                        if (Chest.TileIsChest(x, y))     //if is Chest
                        {
                            int      id      = Terraria.Chest.FindChest(x, y);
                            CPlayer  player  = Players[e.Msg.whoAmI];
                            TPPlayer tplayer = tPulse.Players[e.Msg.whoAmI];

                            //dirty fix for finding chest, try to find chest point around
                            if (id == -1)
                            {
                                try
                                {
                                    id = Terraria.Chest.FindChest(x - 1, y);     //search one tile left
                                    if (id == -1)
                                    {
                                        id = Terraria.Chest.FindChest(x - 1, y - 1);
                                        //search one tile left and one tile up
                                        if (id == -1)
                                        {
                                            id = Terraria.Chest.FindChest(x, y - 1);     //search one tile up
                                        }
                                    }
                                }
                                catch (Exception ex)
                                {
                                    Log.Write(ex.ToString(), LogLevel.Error);
                                }
                            }

                            if (id != -1)     //if have found chest
                            {
                                Chest chest = ChestManager.GetChest(id);
                                if (chest.HasOwner())     //if owned stop removing
                                {
                                    if (tplayer.Group.HasPermission("removechestprotection") ||
                                        chest.IsOwnerConvert(player))
                                    {
                                        //display more verbose info to player who has permission to remove protection on this chest
                                        player.SendMessage(
                                            "This chest is protected. To remove it, first remove protection using \"/cunset\" command.",
                                            Color.Red);
                                    }
                                    else
                                    {
                                        player.SendMessage("This chest is protected!", Color.Red);
                                    }

                                    player.SendTileSquare(x, y);
                                    e.Handled = true;
                                }
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        Log.Write(ex.ToString(), LogLevel.Error);
                    }
                break;

            case PacketTypes.ChestItem:
                using (var data = new MemoryStream(e.Msg.readBuffer, e.Index, e.Length))
                {
                    var   reader = new BinaryReader(data);
                    short id     = reader.ReadInt16();
                    byte  slot   = reader.ReadByte();
                    byte  stack  = reader.ReadByte();
                    byte  prefix = reader.ReadByte();
                    short type   = reader.ReadByte();
                    if (id != -1)
                    {
                        Chest chest = ChestManager.GetChest(id);
                        if (chest.IsRefill())
                        {
                            e.Handled = true;
                        }
                        if (!e.Handled)
                        {
                            var item    = Main.chest[id].item[slot];
                            var newitem = new Item();
                            newitem.netDefaults(type);
                            newitem.Prefix(prefix);
                            newitem.AffixName();
                            Log.Write(string.Format("{0}({1}) in slot {2} in chest at {3}x{4} was modified to {5}({6}) by {7}",
                                                    item.name, item.stack, slot, Main.chest[id].x, Main.chest[id].y, newitem.name, stack, tPulse.Players[e.Msg.whoAmI].UserAccountName),
                                      LogLevel.Info, false);
                        }
                    }
                }
                break;
            }
        }
Exemplo n.º 2
0
        public static void Load()
        {
            ChestSavePath = Path.Combine(ChestControlDirectory, Main.worldID + ".txt");
            if (!Directory.Exists(ChestControlDirectory))
                Directory.CreateDirectory(ChestControlDirectory);

            if (!File.Exists(ChestSavePath))
                File.Create(ChestSavePath).Close();

            for (int i = 0; i < Chests.Length; i++)
                Chests[i] = new Chest();

            bool error = false;
            foreach (
                var args in
                    File.ReadAllLines(ChestSavePath).Select(line => line.Split('|')).Where(args => args.Length >= 7))
                try
                {
                    var chest = new Chest();

                    chest.SetPosition(new Vector2(int.Parse(args[1]), int.Parse(args[2])));
                    chest.SetOwner(args[3]);
                    chest.SetID(int.Parse(args[0]));
                    if (bool.Parse(args[4]))
                        chest.Lock();
                    if (bool.Parse(args[5]))
                        chest.regionLock(true);
                    if (args[6] != "")
                        chest.SetPassword(args[6], true);
                    //provide backwards compatibility
                    if (args.Length == 9)
                        if (bool.Parse(args[7]))
                        {
                            chest.SetRefill(true);
                            //chest.SetRefillItems(args[8]);
                        }

                    //check if chest still exists in world
                    if (!Chest.TileIsChest(chest.GetPosition()))
                        //chest dont exists - so reset it
                        chest.Reset();
                    //check if chest in array didn't move
                    if (!VerifyChest(chest.GetID(), chest.GetPosition()))
                    {
                        int id = Terraria.Chest.FindChest((int) chest.GetPosition().X, (int) chest.GetPosition().Y);
                        if (id != -1)
                            chest.SetID(id);
                        else
                            chest.Reset();
                    }

                    if (Chests.Length > chest.GetID()) Chests[chest.GetID()] = chest;
                }
                catch
                {
                    error = true;
                }

            if (error)
                Log.Write("Failed to load some chests data, corresponding chests will be left unprotected.", LogLevel.Error);
        }
Exemplo n.º 3
0
        // LoadFromTextFile ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        /* If the legacy file exists,
         * . read legacy file
         * . populate the chest info
         * . save the chest info into the database
         * . rename the legacy file
         * . return true
         * else
         * . return false - chests will be loaded from db
         */
        private bool LoadFromTextFile()
        {
            bool result = false;
              string ChestControlDirectory = Path.Combine(TShock.SavePath, "chestcontrol");
              string ChestSaveFileName = Path.Combine(ChestControlDirectory, Main.worldID + ".txt");

              try {
              if ( Directory.Exists( ChestControlDirectory ) )
              {
            if ( File.Exists( ChestSaveFileName ) )
            {
              Log.Write( "Legacy Data File Found", LogLevel.Info );

              bool error = false;
              foreach (
              var args in
                  File.ReadAllLines( ChestSaveFileName ).Select( line => line.Split( '|' ) ).Where( args => args.Length >= 7 ) )
            try
            {
              var chest = new Chest();

              // ID
              chest.SetID( int.Parse( args[0] ) );

              // Position
              chest.SetPosition( new Vector2( int.Parse( args[1] ), int.Parse( args[2] ) ) );

              // Owner
              chest.SetOwner( args[3] );

              // locked
              if ( bool.Parse( args[4] ) )
                chest.Lock();

              // region lock
              if ( bool.Parse( args[5] ) )
                chest.regionLock( true );

              // password
              if ( args[6] != "" )
                chest.SetPassword( args[6], true );

              // provide backwards compatibility
              if ( args.Length == 9 ) // if refill
                if ( bool.Parse( args[7] ) ) // refill
                {
                  chest.SetRefill( true );
                  //- chest.SetRefillItems(args[8]); // not used - Terraria stores chest contents
                } // if

              // check if chest still exists in world
              if ( !Chest.TileIsChest( chest.GetPosition() ) )
                chest.Reset(); // chest doesnt exists - so reset it

              // check if chest in array didn't move
              if ( !VerifyChest( chest.GetID(), chest.GetPosition() ) )
              {
                int id = Terraria.Chest.FindChest( (int) chest.GetPosition().X, (int) chest.GetPosition().Y );
                if ( id != -1 )
                  chest.SetID( id );
                else
                  chest.Reset();
              } // if

              if ( Chests.Length > chest.GetID() )
              {
                Chests[chest.GetID()] = chest;
                Log.Write( "[LegacyChest]: " + chest.GetOwner() + "(id:" + chest.GetID() + ")", LogLevel.Info );
              } // if

            } // try
            catch
            {
              error = true;
            } // catch

              if ( error )
            Log.Write( "Failed to load some chests data, corresponding chests will be left unprotected.", LogLevel.Error );

              /* Save the recently loaded chests into database
               * This will be re-done when the world exits, but if there is a crash, the rename will prevent
               *  loading this information this way again.
               */
              SaveChests();
              File.Move( ChestSaveFileName, ChestSaveFileName + "-old.txt" );
              result = true;
            } // if - File.Exists

              } // if - dir exist
              } // try
              catch
              {
            Log.Write( "! Error: LoadFromTextFile", LogLevel.Error );
              } // catch

              return result;
        }
Exemplo n.º 4
0
        // LoadChests ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        public void LoadChests()
        {
            // Initialize local array of all chests in world for our tacking purposes
              for ( int i = 0; i < Chests.Length; i++ )
            Chests[i] = new Chest();

              // older versions used text file, if it exists, read that.
              if ( !LoadFromTextFile() )
              {
            try
            {
              using ( var reader = database.QueryReader( "SELECT * FROM " + tableName + " WHERE WorldID=@0", Main.worldID.ToString() ) )
              {
            while ( reader.Read() )
            {
              int    chestID  = reader.Get<int>( "ChestID" );
              int    x        = reader.Get<int>( "X" );
              int    y        = reader.Get<int>( "Y" );
              string owner    = reader.Get<string>( "Owner" );
              int    isLocked = reader.Get<int>( "IsLocked" );
              int    isRegionLocked = reader.Get<int>( "IsRegionLocked" );
              string password = reader.Get<string>( "Password" );
              int    isRefill = reader.Get<int>(    "IsRefill" );
              int    refillDelay = reader.Get<int>( "RefillDelay" );

              Chest chest = new Chest();
              chest.SetID( chestID );
              chest.SetPosition( new Vector2( x, y ) );
              chest.SetOwner( owner );
              if ( isLocked != 0  )      { chest.Lock(); }
              if ( isRegionLocked != 0 ) { chest.regionLock( true ); }
              if ( password != "" )      { chest.SetPassword( password, true ); }
              if ( isRefill != 0  )      { chest.SetRefill( true ); }
              chest.SetRefillDelay( refillDelay );

              // check if chest still exists in world
              if ( !Chest.TileIsChest( chest.GetPosition() ) )
              {
                chest.Reset(); // chest doesnt exist - so reset it
              } // if

              // check if chest in array didn't move
              if ( !VerifyChest( chest.GetID(), chest.GetPosition() ) )
              {
                int id = Terraria.Chest.FindChest( (int) chest.GetPosition().X, (int) chest.GetPosition().Y );
                if ( id != -1 )
                {
                  Log.Write( "found chest: " + chest.GetID() + ":" + refillDelay, LogLevel.Debug );
                  chest.SetID( id );  // chest id and contents may have changed
                  if ( isRefill != 0 ) { chest.SetRefill( true ); } // delayed refill stores contents
                  chest.SetRefillDelay( refillDelay );
                }
                else // moved, reset it
                  chest.Reset();
              } // if

              if ( Chests.Length > chest.GetID() ) {
                Chests[chest.GetID()] = chest;
                Item[] refillItems = chest.GetRefillItems();
                string itemName = ".";
                itemName = chest.GetFirstItemName();
                Log.Write( "[LoadChests]: " +
                           "(id:"  + chest.GetID() + ")" +
                           "(rf:"  + chest.IsRefill() + ")" +
                           "(rd:"  + chest.GetRefillDelay() + ")" +
                           "(1st:" + itemName + ")", LogLevel.Info );
              } // if

            } // while
              } // using
            } // try
            catch ( Exception ex )
            {
              Log.Write( "! [LoadChests]: " + ex.ToString(), LogLevel.Error );
            } // catch
              } // if
        }
Exemplo n.º 5
0
        public static void Load()
        {
            ChestSavePath = Path.Combine(ChestControlDirectory, Main.worldID + ".txt");
            if (!Directory.Exists(ChestControlDirectory))
            {
                Directory.CreateDirectory(ChestControlDirectory);
            }

            if (!File.Exists(ChestSavePath))
            {
                File.Create(ChestSavePath).Close();
            }

            for (int i = 0; i < Chests.Length; i++)
            {
                Chests[i] = new Chest();
            }

            bool error = false;

            foreach (
                var args in
                File.ReadAllLines(ChestSavePath).Select(line => line.Split('|')).Where(args => args.Length >= 7))
            {
                try
                {
                    var chest = new Chest();

                    chest.SetPosition(new Vector2(int.Parse(args[1]), int.Parse(args[2])));
                    chest.SetOwner(args[3]);
                    chest.SetID(int.Parse(args[0]));
                    if (bool.Parse(args[4]))
                    {
                        chest.Lock();
                    }
                    if (bool.Parse(args[5]))
                    {
                        chest.regionLock(true);
                    }
                    if (args[6] != "")
                    {
                        chest.SetPassword(args[6], true);
                    }
                    //provide backwards compatibility
                    if (args.Length == 9)
                    {
                        if (bool.Parse(args[7]))
                        {
                            chest.SetRefill(true);
                            //chest.SetRefillItems(args[8]);
                        }
                    }

                    //check if chest still exists in world
                    if (!Chest.TileIsChest(chest.GetPosition()))
                    {
                        //chest dont exists - so reset it
                        chest.Reset();
                    }
                    //check if chest in array didn't move
                    if (!VerifyChest(chest.GetID(), chest.GetPosition()))
                    {
                        int id = Terraria.Chest.FindChest((int)chest.GetPosition().X, (int)chest.GetPosition().Y);
                        if (id != -1)
                        {
                            chest.SetID(id);
                        }
                        else
                        {
                            chest.Reset();
                        }
                    }

                    if (Chests.Length > chest.GetID())
                    {
                        Chests[chest.GetID()] = chest;
                    }
                }
                catch
                {
                    error = true;
                }
            }

            if (error)
            {
                Log.Write("Failed to load some chests data, corresponding chests will be left unprotected.", LogLevel.Error);
            }
        }