public static void OnUnkownPacketSend(ref HookContext ctx, ref HookArgs.UnkownSendPacket args)
        {
            switch (args.PacketId)
            {
                case (int)Packets.CLIENT_MOD_GOD:
                    {
                        NetMessageExtension msg = new NetMessageExtension();

                        if (args.RemoteClient != -1)
                        {
                            var player = Main.players[args.RemoteClient];

                            if (player.HasClientMod)
                            {
                                if (Server.AllowTDCMRPG)
                                {
                                    Server.notifyOps(
                                        String.Format("Failed attempt to {0} God Mode on an RPG Server.", true, (args.Number == 1) ? "give" : "remove"));
                                    return;
                                }

                                Server.notifyOps(
                                    String.Format("{0} {1} God Mode.", true, player.Name, (args.Number == 1) ? "has" : "doesn't have"));

                                msg.GodTDCMClient(args.Number == 1);
                                args.Message = msg;
                                ctx.SetResult(HookResult.IGNORE); //Let TDSM know it's to ignore returning.
                            }
                        }
                        break;
                    }

            }
        }

        void OnReadConfig(ref HookContext ctx, ref HookArgs.ConfigurationLine args)
        {
            switch (args.Key)
            {
                case "mysql":
                    if (!Storage.IsAvailable)
                    {
                        MySQLConnector cn = null;

                        try
                        {
                            cn = new MySQLConnector(args.Value);
                            cn.Open();
                        }
                        catch (Exception e)
                        {
                            ProgramLog.Error.Log("Exception connecting to MySQL database: {0}", e);
                            return;
                        }
                        Storage.SetConnector(cn);

                        _connector = cn;
                    }
                    break;
            }
        }

 void LeftHook(ref HookContext ctx, ref HookArgs.PlayerLeftGame args)
 {
     // If player has a last command stored, remove it now.
     if ( history.ContainsKey(ctx.Sender.SenderName) ) {
         history.Remove(ctx.Sender.SenderName);
     }
 }

 void OnStateChange(ref HookContext ctx, ref HookArgs.ServerStateChange args)
 {
     if (args.ServerChangeState == TDSM.API.ServerState.Initialising)
     {
         ProgramLog.Plugin.Log("SQLite connector is: " + (_connector == null ? "disabled" : "enabled"));
     }
 }

 /// <summary>
 /// Handles the connection state when receiving a packet
 /// </summary>
 public static void CheckState(ref HookContext ctx, ref HookArgs.CheckBufferState args)
 {
     if (Terraria.Netplay.Clients[args.BufferId].State == (int)ConnectionState.AwaitingUserPassword)
     {
         //Since this is a custom state, we accept it [true to kick the connection, false to accept]
         ctx.SetResult(HookResult.RECTIFY, true, false /* TODO validate packets */);
     }
 }

 void OnStateChange(ref HookContext ctx, ref HookArgs.ServerStateChange args)
 {
     if (args.ServerChangeState == TDSM.API.ServerState.Initialising)
     {
         //Data connectors must have loaded by now
         //Get TDSM to swap the current permission handler to our own
         TDSM.API.Permissions.PermissionsManager.SetHandler(_instance);
     }
 }

 void CommmandHook(ref HookContext ctx, ref HookArgs.Command args)
 {
     // If the command issued is not !...
     if ( args.Prefix != "!" ) {
         string WhoCalled = ctx.Sender.SenderName; // get the name of the sender
         // If there is a command saved for the sender already...
         if ( history.ContainsKey( WhoCalled ) ) {
             history[WhoCalled] = args.Prefix + " " + args.ArgumentString; // Replace the sender's last command.
         } else {
             history.Add( WhoCalled, args.Prefix + " " + args.ArgumentString ); // Record the sender's command for the first time.
         }
     }
 }

 /// <summary>
 /// Handles packets received from OTA
 /// </summary>
 public static void HandlePacket(ref HookContext ctx, ref HookArgs.ReceiveNetMessage args)
 {
     if (_packetHandlers != null)
     {
         if (_packetHandlers[args.PacketId] != null)
         {
             if (_packetHandlers[args.PacketId].Read(args.BufferId, args.Start, args.Length))
             {
                 //Packet informed us that it was read, let OTA know we consumed the packet
                 ctx.SetResult(HookResult.IGNORE, true);
             }
         }
     }
 }

 void OnServerStateChange(ref HookContext ctx, ref HookArgs.ServerStateChange args)
 {
     if (args.ServerChangeState == ServerState.LOADED)
     {
         ProgramLog.Plugin.Log("Starting fishy mod...");
         fishy = new Fishy();
         ProgramLog.Plugin.Log("Fishy mod Started.");
     }
     else if (args.ServerChangeState == ServerState.STOPPING || args.ServerChangeState == ServerState.RESTARTING)
     {
         ProgramLog.Plugin.Log("Stopping fishy mod...");
         fishy.Stop();
         ProgramLog.Plugin.Log("Fishy mod Stopped.");
     }
 }

        void OnReadConfig(ref HookContext ctx, ref HookArgs.ConfigurationLine args)
        {
            switch (args.Key)
            {
                case "sqlite":
                    if (_connector == null)
                    {
                        var cn = new SQLiteConnector(args.Value);

                        cn.Open();

                        Storage.SetConnector(cn);

                        _connector = cn;
                    }
                    break;
            }
        }

        void OnGreetPlayer(ref HookContext ctx, ref HookArgs.PlayerPreGreeting args)
        {
            ctx.SetResult(HookResult.IGNORE);
            var lines = args.Motd.Split(new string[] { "\\0" }, StringSplitOptions.None);
            foreach (var line in lines)
                ctx.Player.SendMessage(line, 255, 0, 0, 255);

            string list = "";
            for (int i = 0; i < 255; i++)
            {
                if (Main.player[i].active)
                {
                    if (list == "")
                        list += Main.player[i].name;
                    else
                        list = list + ", " + Main.player[i].name;
                }
            }

            ctx.Player.SendMessage("Current players: " + list + ".", 255, 255, 240, 20);
        }

 void onPlayerJoin(ref HookContext ctx, ref HookArgs.PlayerEnteringGame args)
 {
     //ctx.Player.A = AccessLevel.OP;
 }

 void OnSignEdit(ref HookContext ctx, ref HookArgs.SignTextSet args)
 {
     foreach (Region rgn in regionManager.Regions)
         {
             if (rgn.HasPoint(new Vector2(args.X, args.Y)))
             {
                 if (ctx.Sender is Player)
                 {
                     if (IsRestrictedForUser(ctx.Player, rgn, DoorChange))
                     {
                         ctx.SetResult(HookResult.IGNORE);
                         ctx.Player.sendMessage("You cannot edit this area!", ChatColor.Red);
                         return;
                     }
                 }
             }
         }
 }

 void OnServerStateChange(ref HookContext ctx, ref HookArgs.ServerStateChange args)
 {
     if (args.ServerChangeState == ServerState.LOADED)
             regionManager.LoadRegions();
 }

        void OnProjectileReceived(ref HookContext ctx, ref HookArgs.ProjectileReceived args)
        {
            Vector2 Position = new Vector2(args.X, args.Y);

                foreach (Region rgn in regionManager.Regions)
                {
                    if (rgn.HasPoint(Position / 16))
                    {
                        if (rgn.ProjectileList.Contains("*") ||
                            rgn.ProjectileList.Contains(args.Type.ToString()))// ||
                            //rgn.ProjectileList.Contains(args.Projectile.Name.ToLower().Replace(" ", "")))
                        {
                            if (IsRestrictedForUser(ctx.Player, rgn, ProjectileUse))
                            {
                                ctx.SetResult(HookResult.ERASE);
                                ctx.Player.sendMessage("You cannot edit this area!", ChatColor.Red);
                                return;
                            }
                        }
                    }
                }
        }

        void OnServerStateChange(ref HookContext ctx, ref HookArgs.ServerStateChange args)
        {
            ProgramLog.Log("Server state changed to: " + args.ServerChangeState.ToString());

            if (args.ServerChangeState == ServerState.Initialising)
            {
                if (!String.IsNullOrEmpty(RConBindAddress))
                {
                    ProgramLog.Log("Starting RCON Server");
                    RemoteConsole.RConServer.Start(Path.Combine(Globals.DataPath, "rcon_logins.properties"));
                }
            }
            if (args.ServerChangeState == ServerState.Stopping)
            {
                RemoteConsole.RConServer.Stop();
            }

            //if (args.ServerChangeState == ServerState.Initialising)
            #if TDSMServer
            if (!Server.IsInitialised)
            {
                Server.Init();

                if (!String.IsNullOrEmpty(RConBindAddress))
                {
                    ProgramLog.Log("Starting RCON Server");
                    RemoteConsole.RConServer.Start(Path.Combine(Globals.DataPath, "rcon_logins.properties"));
                }

                if (!String.IsNullOrEmpty(_webServerAddress))
                {
                    ProgramLog.Log("Starting Web Server");
                    WebInterface.WebServer.Begin(_webServerAddress, _webServerProvider);

                    AddCommand("webauth")
                        .WithAccessLevel(AccessLevel.OP)
                        .Calls(WebInterface.WebServer.WebAuthCommand);
                }
            }

            if (args.ServerChangeState == ServerState.Stopping)
            {
                RemoteConsole.RConServer.Stop();
                WebInterface.WebServer.End();
                //if (properties != null && File.Exists(properties.PIDFile.Trim()))
                //File.Delete(properties.PIDFile.Trim());
            }

            ctx.SetResult(HookResult.IGNORE); //Don't continue on with vanilla code
            #endif
        }

 void OnPlayerDisconnected(ref HookContext ctx, ref HookArgs.PlayerLeftGame args)
 {
     #if TDSMServer
     if (RestartWhenNoPlayers && ClientConnection.All.Count - 1 == 0)
     {
         PerformRestart();
     }
     #endif
 }

 void OnInventoryItemReceived(ref HookContext ctx, ref HookArgs.InventoryItemReceived args)
 {
     #if TDSMSever
     if (Server.ItemRejections.Count > 0)
     {
         if (args.Item != null)
         {
             if (Server.ItemRejections.Contains(args.Item.name) || Server.ItemRejections.Contains(args.Item.type.ToString()))
             {
                 if (!String.IsNullOrEmpty(args.Item.name))
                 {
                     ctx.SetKick(args.Item.name + " is not allowed on this server.");
                 }
                 else
                 {
                     ctx.SetKick("Item type " + args.Item.type.ToString() + " is not allowed on this server.");
                 }
             }
         }
     }
     #endif
 }

        void OnChat(ref HookContext ctx, ref HookArgs.PlayerChat args)
        {
            if (args.Message.Length > 0 && args.Message.Substring(0, 1).Equals("/"))
            {
                ProgramLog.Log(ctx.Player.Name + " sent command: " + args.Message);
                ctx.SetResult(HookResult.IGNORE);

                UserInput.CommandParser.ParsePlayerCommand(ctx.Player, args.Message);
            }
        }

 void OnPluginsLoaded(ref HookContext ctx, ref HookArgs.PluginsLoaded args)
 {
     LoadPerms();
 }