themaster1970sf/TShock
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions

Merge branch 'master' of github.com:TShock/TShock into sql

Browse source
This commit is contained in:
high 2011-06-16 10:49:09 -04:00
commit bde8bc8bf2
10 changed files with 1243 additions and 1158 deletions
Download patch file Download diff file Expand all files Collapse all files

1
TShockAPI/BanManager.cs
View file

@ -74,6 +74,7 @@ namespace TShockAPI
public void RemoveBan(Ban ban)
{
Bans.Remove(ban);
SaveBans();
}
/// <summary>

1019
TShockAPI/Commands.cs
View file

File diff suppressed because it is too large Load diff

2
TShockAPI/FileTools.cs
View file

@ -66,6 +66,8 @@ namespace TShockAPI
if (File.Exists(ConfigPath))
{
ConfigurationManager.ReadJsonConfiguration();
// Add all the missing config properties in the json file
ConfigurationManager.WriteJsonConfiguration();
}
else
{

426
TShockAPI/GetDataHandlers.cs Executable file
View file

@ -0,0 +1,426 @@
/*
TShock, a server mod for Terraria
Copyright (C) 2011 The TShock Team
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Text;
using Microsoft.Xna.Framework;
using StreamBinary;
using Terraria;
using TerrariaAPI;
namespace TShockAPI
{
public delegate bool GetDataHandlerDelegate(GetDataHandlerArgs args);
public class GetDataHandlerArgs : EventArgs
{
public TSPlayer Player { get; private set; }
public MemoryStream Data { get; private set; }
public Player TPlayer
{
get { return Player.TPlayer; }
}
public GetDataHandlerArgs(TSPlayer player, MemoryStream data)
{
Player = player;
Data = data;
}
}
public static class GetDataHandlers
{
private static Dictionary<PacketTypes, GetDataHandlerDelegate> GetDataHandlerDelegates;
private static bool[] BlacklistTiles;
public static void InitGetDataHandler()
{
#region Blacklisted tiles
BlacklistTiles = new bool[Main.maxTileSets];
BlacklistTiles[0] = true;
BlacklistTiles[1] = true;
BlacklistTiles[2] = true;
BlacklistTiles[6] = true;
BlacklistTiles[7] = true;
BlacklistTiles[8] = true;
BlacklistTiles[9] = true;
BlacklistTiles[22] = true;
BlacklistTiles[23] = true;
BlacklistTiles[25] = true;
BlacklistTiles[30] = true;
BlacklistTiles[37] = true;
BlacklistTiles[38] = true;
BlacklistTiles[39] = true;
BlacklistTiles[40] = true;
BlacklistTiles[41] = true;
BlacklistTiles[43] = true;
BlacklistTiles[44] = true;
BlacklistTiles[45] = true;
BlacklistTiles[46] = true;
BlacklistTiles[47] = true;
BlacklistTiles[53] = true;
BlacklistTiles[54] = true;
BlacklistTiles[56] = true;
BlacklistTiles[57] = true;
BlacklistTiles[58] = true;
BlacklistTiles[59] = true;
BlacklistTiles[60] = true;
BlacklistTiles[63] = true;
BlacklistTiles[64] = true;
BlacklistTiles[65] = true;
BlacklistTiles[66] = true;
BlacklistTiles[67] = true;
BlacklistTiles[68] = true;
BlacklistTiles[70] = true;
BlacklistTiles[75] = true;
BlacklistTiles[76] = true;
#endregion Blacklisted tiles
GetDataHandlerDelegates = new Dictionary<PacketTypes, GetDataHandlerDelegate>
{
{PacketTypes.PlayerInfo, HandlePlayerInfo},
{PacketTypes.TileSendSection, HandleSendSection},
{PacketTypes.PlayerUpdate, HandlePlayerUpdate},
{PacketTypes.Tile, HandleTile},
{PacketTypes.TileSendSquare, HandleSendTileSquare},
{PacketTypes.NPCUpdate, HandleNpcUpdate},
{PacketTypes.PlayerDamage, HandlePlayerDamage},
{PacketTypes.ProjectileNew, HandleProjectileNew},
{PacketTypes.TogglePVP, HandleTogglePvp},
{PacketTypes.TileKill, HandleTileKill},
{PacketTypes.PlayerKillMe, HandlePlayerKillMe},
{PacketTypes.LiquidSet, HandleLiquidSet},
};
}
public static bool HandlerGetData(PacketTypes type, TSPlayer player, MemoryStream data)
{
GetDataHandlerDelegate handler;
if (GetDataHandlerDelegates.TryGetValue(type, out handler))
{
try
{
return handler(new GetDataHandlerArgs(player, data));
}
catch (Exception ex)
{
Log.Error(ex.ToString());
}
}
return false;
}
private static bool HandlePlayerInfo(GetDataHandlerArgs args)
{
byte playerid = args.Data.ReadInt8();
byte hair = args.Data.ReadInt8();
Color hairColor = new Color(args.Data.ReadInt8(), args.Data.ReadInt8(), args.Data.ReadInt8());
Color skinColor = new Color(args.Data.ReadInt8(), args.Data.ReadInt8(), args.Data.ReadInt8());
Color eyeColor = new Color(args.Data.ReadInt8(), args.Data.ReadInt8(), args.Data.ReadInt8());
Color shirtColor = new Color(args.Data.ReadInt8(), args.Data.ReadInt8(), args.Data.ReadInt8());
Color underShirtColor = new Color(args.Data.ReadInt8(), args.Data.ReadInt8(), args.Data.ReadInt8());
Color pantsColor = new Color(args.Data.ReadInt8(), args.Data.ReadInt8(), args.Data.ReadInt8());
Color shoeColor = new Color(args.Data.ReadInt8(), args.Data.ReadInt8(), args.Data.ReadInt8());
string name = Encoding.ASCII.GetString(args.Data.ReadBytes((int) (args.Data.Length - args.Data.Position - 1)));
if (hair >= Main.maxHair)
{
Tools.ForceKick(args.Player, "Hair crash exploit.");
return true;
}
if (name.Length > 32)
{
Tools.ForceKick(args.Player, "Name exceeded 32 characters.");
return true;
}
if (name.Trim().Length == 0)
{
Tools.ForceKick(args.Player, "Empty Name.");
return true;
}
var ban = TShock.Bans.GetBanByName(name);
if (ban != null)
{
Tools.ForceKick(args.Player, string.Format("You are banned: {0}", ban.Reason));
return true;
}
if (args.Player.ReceivedInfo)
{
return Tools.HandleGriefer(args.Player, "Sent client info more than once");
}
args.Player.ReceivedInfo = true;
return false;
}
private static bool HandleSendTileSquare(GetDataHandlerArgs args)
{
short size = args.Data.ReadInt16();
int x = args.Data.ReadInt32();
int y = args.Data.ReadInt32();
int plyX = Math.Abs(args.Player.TileX);
int plyY = Math.Abs(args.Player.TileY);
int tileX = Math.Abs(x);
int tileY = Math.Abs(y);
if (size > 5 || (ConfigurationManager.RangeChecks && (Math.Abs(plyX - tileX) > 32 || Math.Abs(plyY - tileY) > 32)))
{
Log.Debug(string.Format("SendTileSquare(PlyXY:{0}_{1}, TileXY:{2}_{3}, Result:{4}_{5}, Size:{6})",
plyX, plyY, tileX, tileY, Math.Abs(plyX - tileX), Math.Abs(plyY - tileY), size));
return Tools.HandleGriefer(args.Player, "Send Tile Square Abuse");
}
return false;
}
private static bool HandleTile(GetDataHandlerArgs args)
{
byte type = args.Data.ReadInt8();
int x = args.Data.ReadInt32();
int y = args.Data.ReadInt32();
byte tiletype = args.Data.ReadInt8();
if (type == 1 || type == 3)
{
int plyX = Math.Abs(args.Player.TileX);
int plyY = Math.Abs(args.Player.TileY);
int tileX = Math.Abs(x);
int tileY = Math.Abs(y);
if (ConfigurationManager.RangeChecks && ((Math.Abs(plyX - tileX) > 32) || (Math.Abs(plyY - tileY) > 32)))
{
Log.Debug(string.Format("TilePlaced(PlyXY:{0}_{1}, TileXY:{2}_{3}, Result:{4}_{5}, Type:{6})",
plyX, plyY, tileX, tileY, Math.Abs(plyX - tileX), Math.Abs(plyY - tileY), tiletype));
return Tools.HandleGriefer(args.Player, "Placing impossible to place blocks.");
}
}
if (ConfigurationManager.DisableBuild)
{
if (!args.Player.Group.HasPermission("editspawn"))
{
args.Player.SendMessage("World protected from changes.", Color.Red);
TShock.SendTileSquare(args.Player, x, y);
return true;
}
}
if (ConfigurationManager.SpawnProtect)
{
if (!args.Player.Group.HasPermission("editspawn"))
{
var flag = TShock.CheckSpawn(x, y);
if (flag)
{
args.Player.SendMessage("Spawn protected from changes.", Color.Red);
TShock.SendTileSquare(args.Player, x, y);
return true;
}
}
}
if (type == 0 && BlacklistTiles[Main.tile[x, y].type] && args.Player.Active)
{
args.Player.TileThreshold++;
var coords = new Vector2(x, y);
if (!args.Player.TilesDestroyed.ContainsKey(coords))
args.Player.TilesDestroyed.Add(coords, Main.tile[x, y]);
}
return false;
}
private static bool HandleTogglePvp(GetDataHandlerArgs args)
{
int id = args.Data.ReadByte();
bool pvp = args.Data.ReadBoolean();
args.TPlayer.hostile = pvp;
if (id != args.Player.Index)
args.TPlayer.hostile = true;
if (ConfigurationManager.PermaPvp)
args.TPlayer.hostile = true;
NetMessage.SendData(30, -1, -1, "", args.Player.Index);
return true;
}
private static bool HandleSendSection(GetDataHandlerArgs args)
{
return Tools.HandleGriefer(args.Player, "SendSection abuse.");
}
private static bool HandleNpcUpdate(GetDataHandlerArgs args)
{
return Tools.HandleGriefer(args.Player, "Spawn NPC abuse");
}
private static bool HandlePlayerUpdate(GetDataHandlerArgs args)
{
byte plr = args.Data.ReadInt8();
byte control = args.Data.ReadInt8();
byte item = args.Data.ReadInt8();
float posx = args.Data.ReadSingle();
float posy = args.Data.ReadSingle();
float velx = args.Data.ReadSingle();
float vely = args.Data.ReadSingle();
if (Main.verboseNetplay)
Debug.WriteLine("Update: {{{0},{1}}} {{{2}, {3}}}", (int)posx, (int)posy, (int)velx, (int)vely);
if (plr != args.Player.Index)
{
return Tools.HandleGriefer(args.Player, "Update Player abuse");
}
return false;
}
private static bool HandleProjectileNew(GetDataHandlerArgs args)
{
short ident = args.Data.ReadInt16();
float posx = args.Data.ReadSingle();
float posy = args.Data.ReadSingle();
float velx = args.Data.ReadSingle();
float vely = args.Data.ReadSingle();
float knockback = args.Data.ReadSingle();
short dmg = args.Data.ReadInt16();
byte owner = args.Data.ReadInt8();
byte type = args.Data.ReadInt8();
if (type == 29 || type == 28 || type == 37)
{
Log.Debug(string.Format("Explosive(PlyXY:{0}_{1}, Type:{2})", args.Player.TileX, args.Player.TileY, type));
return Tools.HandleExplosivesUser(args.Player, "Throwing an explosive device.");
}
return false;
}
private static bool HandlePlayerKillMe(GetDataHandlerArgs args)
{
byte id = args.Data.ReadInt8();
byte hitdirection = args.Data.ReadInt8();
short dmg = args.Data.ReadInt16();
bool pvp = args.Data.ReadBoolean();
if (id != args.Player.Index)
{
return Tools.HandleGriefer(args.Player, "Trying to execute KillMe on someone else.");
}
return false;
}
private static bool HandlePlayerDamage(GetDataHandlerArgs args)
{
byte playerid = args.Data.ReadInt8();
byte direction = args.Data.ReadInt8();
Int16 damage = args.Data.ReadInt16();
byte pvp = args.Data.ReadInt8();
return !TShock.Players[playerid].TPlayer.hostile;
}
private static bool HandleLiquidSet(GetDataHandlerArgs args)
{
int x = args.Data.ReadInt32();
int y = args.Data.ReadInt32();
byte liquid = args.Data.ReadInt8();
bool lava = args.Data.ReadBoolean();
//The liquid was picked up.
if (liquid == 0)
return false;
int plyX = Math.Abs(args.Player.TileX);
int plyY = Math.Abs(args.Player.TileY);
int tileX = Math.Abs(x);
int tileY = Math.Abs(y);
bool bucket = false;
for (int i = 0; i < 44; i++)
{
if (args.TPlayer.inventory[i].type >= 205 && args.TPlayer.inventory[i].type <= 207)
{
bucket = true;
break;
}
}
if (lava && !args.Player.Group.HasPermission("canlava"))
{
args.Player.SendMessage("You do not have permission to use lava", Color.Red);
Tools.SendLogs(string.Format("{0} tried using lava", args.Player.Name), Color.Red);
// TODO need to revert player changes so they are insync with server
return true;
}
if (!lava && !args.Player.Group.HasPermission("canwater"))
{
args.Player.SendMessage("You do not have permission to use water", Color.Red);
Tools.SendLogs(string.Format("{0} tried using water", args.Player.Name), Color.Red);
// TODO need to revert player changes so they are insync with server
return true;
}
if (!bucket)
{
Log.Debug(string.Format("{0}(PlyXY:{1}_{2}, TileXY:{3}_{4}, Result:{5}_{6}, Amount:{7})",
lava ? "Lava" : "Water", plyX, plyY, tileX, tileY,
Math.Abs(plyX - tileX), Math.Abs(plyY - tileY), liquid));
return Tools.HandleGriefer(args.Player, "Manipulating liquid without bucket."); ;
}
if (ConfigurationManager.RangeChecks && ((Math.Abs(plyX - tileX) > 32) || (Math.Abs(plyY - tileY) > 32)))
{
Log.Debug(string.Format("Liquid(PlyXY:{0}_{1}, TileXY:{2}_{3}, Result:{4}_{5}, Amount:{6})",
plyX, plyY,
tileX, tileY,
Math.Abs(plyX - tileX), Math.Abs(plyY - tileY),
liquid
));
return Tools.HandleGriefer(args.Player, "Placing impossible to place liquid."); ;
}
if (ConfigurationManager.SpawnProtect)
{
if (!args.Player.Group.HasPermission("editspawn"))
{
var flag = TShock.CheckSpawn(x, y);
if (flag)
{
args.Player.SendMessage("The spawn is protected!", Color.Red);
// TODO need to revert player changes so they are insync with server
return true;
}
}
}
return false;
}
private static bool HandleTileKill(GetDataHandlerArgs args)
{
int tilex = args.Data.ReadInt32();
int tiley = args.Data.ReadInt32();
if (tilex < 0 || tilex >= Main.maxTilesX || tiley < 0 || tiley >= Main.maxTilesY)
return false;
if (Main.tile[tilex, tiley].type != 0x15) //Chest
{
Log.Debug(string.Format("TileKill(TileXY:{0}_{1}, Type:{2})",
tilex, tiley, Main.tile[tilex, tiley].type));
Tools.ForceKick(args.Player, string.Format("Tile Kill abuse ({0})", Main.tile[tilex, tiley].type));
return true;
}
return false;
}
}
}

29
TShockAPI/TSPlayer.cs
View file

@ -33,19 +33,28 @@ namespace TShockAPI
public Group Group { get; set; }
public bool ReceivedInfo { get; set; }
public int Index { get; protected set; }
public bool RealPlayer
{
get { return Index >= 0 && Index < Main.maxNetPlayers; }
}
public bool ConnectionAlive
{
get { return RealPlayer ? Netplay.serverSock[Index].active && !Netplay.serverSock[Index].kill : false; }
}
/// <summary>
/// Terraria Player
/// </summary>
public Player TPlayer { get; protected set; }
public string Name
{
get { return TPlayer.name; }
}
public string IP
{
get { return Tools.GetRealIP(Netplay.serverSock[Index].tcpClient.Client.RemoteEndPoint.ToString()); }
get
{
return RealPlayer ? Tools.GetRealIP(Netplay.serverSock[Index].tcpClient.Client.RemoteEndPoint.ToString()) : "";
}
}
public bool Active
{
@ -55,14 +64,20 @@ namespace TShockAPI
{
get { return TPlayer.team; }
}
public float X
{
get { return TPlayer.position.X; }
get
{
return RealPlayer ? TPlayer.position.X : Main.spawnTileX * 16;
}
}
public float Y
{
get { return TPlayer.position.Y; }
get
{
return RealPlayer ? TPlayer.position.Y : Main.spawnTileY * 16;
}
}
public int TileX
{
@ -70,7 +85,7 @@ namespace TShockAPI
}
public int TileY
{
get { return (int)(X / 16); }
get { return (int)(Y / 16); }
}
public TSPlayer(int index)

786
TShockAPI/TShock.cs
View file

@ -20,10 +20,8 @@ using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Net;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using StreamBinary;
using Terraria;
using TerrariaAPI;
using TerrariaAPI.Hooks;
@ -41,13 +39,8 @@ namespace TShockAPI
public static readonly string VersionCodename = "Forgot to increase the version.";
private static bool[] BlacklistTiles;
public static BanManager Bans = new BanManager(Path.Combine(SavePath, "bans.txt"));
delegate bool HandleGetDataD(MemoryStream data, GetDataEventArgs e);
Dictionary<byte, HandleGetDataD> GetDataFuncs;
public override Version Version
{
get { return VersionNum; }
@ -68,85 +61,15 @@ namespace TShockAPI
get { return "The administration modification of the future."; }
}
static TShock()
{
//Tools.LoadGroups();
#region Blacklisted tiles
BlacklistTiles = new bool[0x80];
BlacklistTiles[0] = true;
BlacklistTiles[1] = true;
BlacklistTiles[2] = true;
BlacklistTiles[6] = true;
BlacklistTiles[7] = true;
BlacklistTiles[8] = true;
BlacklistTiles[9] = true;
BlacklistTiles[22] = true;
BlacklistTiles[23] = true;
BlacklistTiles[25] = true;
BlacklistTiles[30] = true;
BlacklistTiles[37] = true;
BlacklistTiles[38] = true;
BlacklistTiles[39] = true;
BlacklistTiles[40] = true;
BlacklistTiles[41] = true;
BlacklistTiles[43] = true;
BlacklistTiles[44] = true;
BlacklistTiles[45] = true;
BlacklistTiles[46] = true;
BlacklistTiles[47] = true;
BlacklistTiles[53] = true;
BlacklistTiles[54] = true;
BlacklistTiles[56] = true;
BlacklistTiles[57] = true;
BlacklistTiles[58] = true;
BlacklistTiles[59] = true;
BlacklistTiles[60] = true;
BlacklistTiles[63] = true;
BlacklistTiles[64] = true;
BlacklistTiles[65] = true;
BlacklistTiles[66] = true;
BlacklistTiles[67] = true;
BlacklistTiles[68] = true;
BlacklistTiles[70] = true;
BlacklistTiles[75] = true;
BlacklistTiles[76] = true;
#endregion Blacklisted tiles
}
public TShock(Main game)
: base(game)
{
GetDataFuncs = new Dictionary<byte, HandleGetDataD>
{
{(byte)PacketTypes.PlayerInfo, HandlePlayerInfo},
{(byte)PacketTypes.TileSendSection, HandleSendSection},
{(byte)PacketTypes.PlayerUpdate, HandlePlayerUpdate},
{(byte)PacketTypes.Tile, HandleTile},
{(byte)PacketTypes.TileSendSquare, HandleSendTileSquare},
{(byte)PacketTypes.NPCUpdate, HandleNpcUpdate},
{(byte)PacketTypes.PlayerDamage, HandlePlayerDamage},
{(byte)PacketTypes.ProjectileNew, HandleProjectileNew},
{(byte)PacketTypes.TogglePVP, HandleTogglePvp},
{(byte)PacketTypes.TileKill, HandleTileKill},
{(byte)PacketTypes.PlayerKillMe, HandlePlayerKillMe},
{(byte)PacketTypes.LiquidSet, HandleLiquidSet},
};
}
public override void Initialize()
{
try
{
FileTools.SetupConfig();
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
string version = string.Format("TShock Version {0} ({1}) now running.", Version, VersionCodename);
Console.WriteLine(version);
@ -156,13 +79,13 @@ namespace TShockAPI
GameHooks.PostInitialize += OnPostInit;
GameHooks.Update += OnUpdate;
ServerHooks.Chat += OnChat;
ServerHooks.Join += OnJoin;
ServerHooks.Leave += OnLeave;
ServerHooks.Chat += OnChat;
ServerHooks.Command += ServerHooks_OnCommand;
NetHooks.GetData += GetData;
NetHooks.GreetPlayer += OnGreetPlayer;
NpcHooks.StrikeNpc += NpcHooks_OnStrikeNpc;
ServerHooks.Command += ServerHooks_OnCommand;
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
Log.Info("Hooks initialized");
@ -170,6 +93,9 @@ namespace TShockAPI
Bans.LoadBans();
Log.Info("Bans initialized");
GetDataHandlers.InitGetDataHandler();
Log.Info("Get data handlers initialized");
Commands.InitCommands();
Log.Info("Commands initialized");
@ -179,12 +105,11 @@ namespace TShockAPI
public override void DeInitialize()
{
Bans.SaveBans();
ConfigurationManager.WriteJsonConfiguration();
GameHooks.PostInitialize -= OnPostInit;
GameHooks.Update -= OnUpdate;
ServerHooks.Chat -= OnChat;
ServerHooks.Join -= OnJoin;
ServerHooks.Leave -= OnLeave;
ServerHooks.Chat -= OnChat;
ServerHooks.Command -= ServerHooks_OnCommand;
NetHooks.GetData -= GetData;
NetHooks.GreetPlayer -= OnGreetPlayer;
@ -210,524 +135,78 @@ namespace TShockAPI
Log.Error(e.ExceptionObject.ToString());
}
private void HandleCommandLine(string[] parms)
{
for (int i = 0; i < parms.Length; i++)
{
if (parms[i].ToLower() == "-ip")
{
IPAddress ip;
if (IPAddress.TryParse(parms[++i], out ip))
{
Netplay.serverListenIP = ip;
Console.Write("Using IP: {0}", ip);
}
else
{
Console.WriteLine("Bad IP: {0}", parms[i]);
}
}
}
}
/*
* Hooks:
*
*/
/// <summary>
/// When a server command is run.
/// </summary>
/// <param name="cmd"></param>
/// <param name="e"></param>
private void ServerHooks_OnCommand(string text, HandledEventArgs e)
private void OnPostInit()
{
if (text.StartsWith("/"))
if (!File.Exists(Path.Combine(SavePath, "auth.lck")))
{
string cmdStr = text.Remove(0, 1);
var args = Commands.ParseParameters(cmdStr);
if (args.Count < 1)
return;
string scmd = args[0];
args.RemoveAt(0);
Command cmd = null;
for (int i = 0; i < Commands.ChatCommands.Count; i++)
{
if (Commands.ChatCommands[i].Name.Equals(scmd))
{
cmd = Commands.ChatCommands[i];
var r = new Random((int)DateTime.Now.ToBinary());
ConfigurationManager.AuthToken = r.Next(100000, 10000000);
Console.WriteLine("TShock Notice: To become SuperAdmin, join the game and type /auth " +
ConfigurationManager.AuthToken);
Console.WriteLine("This token will only display ONCE. This only works ONCE. If you don't use it and the server goes down, delete auth.lck.");
FileTools.CreateFile(Path.Combine(SavePath, "auth.lck"));
}
}
if (cmd == null)
private void OnUpdate(GameTime time)
{
TSPlayer.Server.SendMessage("That command does not exist, try /help", Color.Red);
}
else
{
Tools.SendLogs(string.Format("{0} executed: /{1}", TSPlayer.Server.Name, cmdStr), Color.Red);
cmd.Run(cmdStr, TSPlayer.Server, args);
}
e.Handled = true;
}
else if (text.StartsWith("exit"))
{
Tools.ForceKickAll("Server shutting down!");
}
else if (text.StartsWith("playing"))
{
int count = 0;
foreach (TSPlayer player in Players)
UpdateManager.UpdateProcedureCheck();
foreach (TSPlayer player in TShock.Players)
{
if (player != null && player.Active)
{
count++;
Console.WriteLine(string.Format("{0} ({1}) [{2}]", player.Name, player.IP, player.Group.Name));
if (player.TileThreshold >= 20)
{
if (Tools.HandleTntUser(player, "Kill tile abuse detected."))
{
RevertKillTile(player);
player.TileThreshold = 0;
player.TilesDestroyed.Clear();
}
}
Console.WriteLine(string.Format("{0} players connected.", count));
e.Handled = true;
}
else if (text.StartsWith("say "))
Log.Info(string.Format("Server said: {0}", text.Remove(0, 4)));
else if (player.TileThreshold > 0)
{
player.TileThreshold = 0;
player.TilesDestroyed.Clear();
}
private void NpcHooks_OnStrikeNpc(NpcStrikeEventArgs e)
}
else if (player.TileThreshold > 0)
{
if (ConfigurationManager.InfiniteInvasion)
{
IncrementKills();
if (Main.invasionSize < 10)
{
Main.invasionSize = 20000000;
player.TileThreshold = 0;
}
}
}
private void GetData(GetDataEventArgs e)
{
if (!Netplay.serverSock[e.Msg.whoAmI].active || Netplay.serverSock[e.Msg.whoAmI].kill)
return;
if (Main.verboseNetplay)
Debug.WriteLine("{0:X} ({2}): {3} ({1:XX})", e.Msg.whoAmI, e.MsgID, Main.player[e.Msg.whoAmI].dead ? "dead " : "alive", MsgNames[e.MsgID]);
HandleGetDataD func;
if (GetDataFuncs.TryGetValue(e.MsgID, out func))
{
using (var data = new MemoryStream(e.Msg.readBuffer, e.Index, e.Length))
{
try
{
e.Handled = func(data, e);
}
catch (Exception ex)
{
Log.Error(ex.ToString());
}
}
}
}
bool HandlePlayerInfo(MemoryStream data, GetDataEventArgs e)
{
var player = Players[e.Msg.whoAmI];
if (player == null)
{
Tools.ForceKick(new TSPlayer(e.Msg.whoAmI), "Player doesn't exist");
return true;
}
var ban = Bans.GetBanByName(player.Name);
if (ban != null)
{
Tools.ForceKick(player, string.Format("You are banned: {0}", ban.Reason));
return true;
}
byte hair = e.Msg.readBuffer[e.Index + 1];
if (hair > 0x10)
{
Tools.ForceKick(player, "Hair crash exploit.");
return true;
}
string name = Encoding.ASCII.GetString(e.Msg.readBuffer, e.Index + 23, (e.Length - (e.Index + 23)) + e.Index - 1);
if (name.Length > 32)
{
Tools.ForceKick(player, "Name exceeded 32 characters.");
return true;
}
if (name.Trim().Length == 0)
{
Tools.ForceKick(player, "Empty Name.");
return true;
}
if (player.ReceivedInfo)
{
return Tools.HandleGriefer(Players[e.Msg.whoAmI], "Sent client info more than once");
}
player.ReceivedInfo = true;
return false;
}
bool HandleSendTileSquare(MemoryStream data, GetDataEventArgs e)
{
short size = data.ReadInt16();
int x = data.ReadInt32();
int y = data.ReadInt32();
int plyX = Math.Abs((int)Main.player[e.Msg.whoAmI].position.X / 16);
int plyY = Math.Abs((int)Main.player[e.Msg.whoAmI].position.Y / 16);
int tileX = Math.Abs(x);
int tileY = Math.Abs(y);
if (size > 5 || (ConfigurationManager.RangeChecks && (Math.Abs(plyX - tileX) > 32 || Math.Abs(plyY - tileY) > 32)))
{
Log.Debug(string.Format("SendTileSquare(PlyXY:{0}_{1}, TileXY:{2}_{3}, Result:{4}_{5}, Size:{6})",
plyX, plyY,
tileX, tileY,
Math.Abs(plyX - tileX), Math.Abs(plyY - tileY),
size
));
return Tools.HandleGriefer(Players[e.Msg.whoAmI], "Send Tile Square Abuse");
}
return false;
}
bool HandleTile(MemoryStream data, GetDataEventArgs e)
{
byte type = data.ReadInt8();
int x = data.ReadInt32();
int y = data.ReadInt32();
byte tiletype = data.ReadInt8();
if (type == 1 || type == 3)
{
int plyX = Math.Abs((int)Main.player[e.Msg.whoAmI].position.X / 16);
int plyY = Math.Abs((int)Main.player[e.Msg.whoAmI].position.Y / 16);
int tileX = Math.Abs(x);
int tileY = Math.Abs(y);
if (Players[e.Msg.whoAmI].TPlayer.selectedItem == 0x72) //Dirt Rod
{
return Tools.Kick(Players[e.Msg.whoAmI], "Using dirt rod");
}
if (ConfigurationManager.RangeChecks && ((Math.Abs(plyX - tileX) > 32) || (Math.Abs(plyY - tileY) > 32)))
{
Log.Debug(string.Format("TilePlaced(PlyXY:{0}_{1}, TileXY:{2}_{3}, Result:{4}_{5}, Type:{6})",
plyX, plyY,
tileX, tileY,
Math.Abs(plyX - tileX), Math.Abs(plyY - tileY),
tiletype
));
return Tools.HandleGriefer(Players[e.Msg.whoAmI], "Placing impossible to place blocks.");
}
}
if (ConfigurationManager.DisableBuild)
{
if (!Players[e.Msg.whoAmI].Group.HasPermission("editspawn"))
{
Players[e.Msg.whoAmI].SendMessage("World protected from changes.", Color.Red);
RevertPlayerChanges(e.Msg.whoAmI, x, y);
return true;
}
}
if (ConfigurationManager.SpawnProtect)
{
if (!Players[e.Msg.whoAmI].Group.HasPermission("editspawn"))
{
var flag = CheckSpawn(x, y);
if (flag)
{
Players[e.Msg.whoAmI].SendMessage("Spawn protected from changes.", Color.Red);
RevertPlayerChanges(e.Msg.whoAmI, x, y);
return true;
}
}
}
if (type == 0 && BlacklistTiles[Main.tile[x, y].type] && Main.player[e.Msg.whoAmI].active)
{
Players[e.Msg.whoAmI].TileThreshold++;
var coords = new Vector2(x, y);
if (!Players[e.Msg.whoAmI].TilesDestroyed.ContainsKey(coords))
Players[e.Msg.whoAmI].TilesDestroyed.Add(coords, Main.tile[x, y]);
}
return false;
}
private static void RevertPlayerChanges(int player, int x, int y)
{
NetMessage.SendData(20, player, -1, "", 10, (float)(x - 5), (float)(y - 5), 0f);
}
bool HandleTogglePvp(MemoryStream data, GetDataEventArgs e)
{
int id = data.ReadByte();
bool pvp = data.ReadBoolean();
Main.player[e.Msg.whoAmI].hostile = pvp;
if (id != e.Msg.whoAmI)
Main.player[e.Msg.whoAmI].hostile = true;
if (ConfigurationManager.PermaPvp)
Main.player[e.Msg.whoAmI].hostile = true;
NetMessage.SendData(30, -1, -1, "", e.Msg.whoAmI);
return true;
}
bool HandleSendSection(MemoryStream data, GetDataEventArgs e)
{
return Tools.HandleGriefer(Players[e.Msg.whoAmI], "SendSection abuse.");
}
bool HandleNpcUpdate(MemoryStream data, GetDataEventArgs e)
{
return Tools.HandleGriefer(Players[e.Msg.whoAmI], "Spawn NPC abuse");
}
bool HandlePlayerUpdate(MemoryStream data, GetDataEventArgs e)
{
byte plr = data.ReadInt8();
byte control = data.ReadInt8();
byte item = data.ReadInt8();
float posx = data.ReadSingle();
float posy = data.ReadSingle();
float velx = data.ReadSingle();
float vely = data.ReadSingle();
if (Main.verboseNetplay)
Debug.WriteLine("Update: {{{0},{1}}} {{{2}, {3}}}", (int)posx, (int)posy, (int)velx, (int)vely);
if (plr != e.Msg.whoAmI)
{
return Tools.HandleGriefer(Players[e.Msg.whoAmI], "Update Player abuse");
}
return false;
}
bool HandleProjectileNew(MemoryStream data, GetDataEventArgs e)
{
short ident = data.ReadInt16();
float posx = data.ReadSingle();
float posy = data.ReadSingle();
float velx = data.ReadSingle();
float vely = data.ReadSingle();
float knockback = data.ReadSingle();
short dmg = data.ReadInt16();
byte owner = data.ReadInt8();
byte type = data.ReadInt8();
if (type == 29 || type == 28 || type == 37)
{
var plr = Main.player[e.Msg.whoAmI];
Log.Debug(string.Format("Explosive(PlyXY:{0}_{1}, Type:{2})",
(int)(plr.position.X / 16),
(int)(plr.position.Y / 16),
type
));
return Tools.HandleExplosivesUser(Players[e.Msg.whoAmI], "Throwing an explosive device.");
}
return false;
}
bool HandlePlayerKillMe(MemoryStream data, GetDataEventArgs e)
{
byte id = data.ReadInt8();
byte hitdirection = data.ReadInt8();
short dmg = data.ReadInt16();
bool pvp = data.ReadBoolean();
if (id != e.Msg.whoAmI)
{
return Tools.HandleGriefer(Players[e.Msg.whoAmI], "Trying to execute KillMe on someone else.");
}
return false;
}
bool HandlePlayerDamage(MemoryStream data, GetDataEventArgs e)
{
byte playerid = data.ReadInt8();
byte direction = data.ReadInt8();
Int16 damage = data.ReadInt16();
byte pvp = data.ReadInt8();
return !Main.player[playerid].hostile;
}
bool HandleLiquidSet(MemoryStream data, GetDataEventArgs e)
{
int x = data.ReadInt32();
int y = data.ReadInt32();
byte liquid = data.ReadInt8();
bool lava = data.ReadBoolean();
//The liquid was picked up.
if (liquid == 0)
return false;
int plyX = Math.Abs((int)Main.player[e.Msg.whoAmI].position.X / 16);
int plyY = Math.Abs((int)Main.player[e.Msg.whoAmI].position.Y / 16);
int tileX = Math.Abs(x);
int tileY = Math.Abs(y);
bool bucket = false;
for (int i = 0; i < 44; i++)
{
if (Main.player[e.Msg.whoAmI].inventory[i].type >= 205 && Main.player[e.Msg.whoAmI].inventory[i].type <= 207)
{
bucket = true;
break;
}
}
if (lava && !Players[e.Msg.whoAmI].Group.HasPermission("canlava"))
{
Players[e.Msg.whoAmI].SendMessage("You do not have permission to use lava", Color.Red);
Tools.SendLogs(string.Format("{0} tried using lava", Main.player[e.Msg.whoAmI].name), Color.Red);
return true;
}
if (!lava && !Players[e.Msg.whoAmI].Group.HasPermission("canwater"))
{
Players[e.Msg.whoAmI].SendMessage("You do not have permission to use water", Color.Red);
Tools.SendLogs(string.Format("{0} tried using water", Main.player[e.Msg.whoAmI].name), Color.Red);
return true;
}
if (!bucket)
{
Log.Debug(string.Format("{0}(PlyXY:{1}_{2}, TileXY:{3}_{4}, Result:{5}_{6}, Amount:{7})",
lava ? "Lava" : "Water",
plyX, plyY,
tileX, tileY,
Math.Abs(plyX - tileX), Math.Abs(plyY - tileY),
liquid
));
return Tools.HandleGriefer(Players[e.Msg.whoAmI], "Manipulating liquid without bucket."); ;
}
if (ConfigurationManager.RangeChecks && ((Math.Abs(plyX - tileX) > 32) || (Math.Abs(plyY - tileY) > 32)))
{
Log.Debug(string.Format("Liquid(PlyXY:{0}_{1}, TileXY:{2}_{3}, Result:{4}_{5}, Amount:{6})",
plyX, plyY,
tileX, tileY,
Math.Abs(plyX - tileX), Math.Abs(plyY - tileY),
liquid
));
return Tools.HandleGriefer(Players[e.Msg.whoAmI], "Placing impossible to place liquid."); ;
}
if (ConfigurationManager.SpawnProtect)
{
if (!Players[e.Msg.whoAmI].Group.HasPermission("editspawn"))
{
var flag = CheckSpawn(x, y);
if (flag)
{
Players[e.Msg.whoAmI].SendMessage("The spawn is protected!", Color.Red);
return true;
}
}
}
return false;
}
bool HandleTileKill(MemoryStream data, GetDataEventArgs e)
{
int tilex = data.ReadInt32();
int tiley = data.ReadInt32();
if (tilex < 0 || tilex >= Main.maxTilesX || tiley < 0 || tiley >= Main.maxTilesY)
return false;
if (Main.tile[tilex, tiley].type != 0x15) //Chest
{
Log.Debug(string.Format("TileKill(TileXY:{0}_{1}, Type:{2})",
tilex, tiley,
Main.tile[tilex, tiley].type
));
Tools.ForceKick(Players[e.Msg.whoAmI], string.Format("Tile Kill abuse ({0})", Main.tile[tilex, tiley].type));
return true;
}
return false;
}
private void OnGreetPlayer(int who, HandledEventArgs e)
{
if (Main.netMode != 2)
return;
TSPlayer player = Players[who];
Log.Info(string.Format("{0} ({1}) from '{2}' group joined.", player.Name, player.IP, player.Group.Name));
Tools.ShowFileToUser(player, "motd.txt");
if (HackedHealth(who))
{
Tools.HandleCheater(player, "Hacked health.");
}
if (ConfigurationManager.PermaPvp)
{
Main.player[who].hostile = true;
NetMessage.SendData(30, -1, -1, "", who);
}
if (Players[who].Group.HasPermission("causeevents") && ConfigurationManager.InfiniteInvasion)
{
StartInvasion();
}
e.Handled = true;
}
private void OnChat(messageBuffer msg, int ply, string text, HandledEventArgs e)
{
if (Main.netMode != 2)
return;
if (msg.whoAmI != ply)
{
e.Handled = Tools.HandleGriefer(Players[ply], "Faking Chat");
return;
}
var tsplr = Players[msg.whoAmI];
if (tsplr.Group.HasPermission("adminchat") && !text.StartsWith("/"))
{
Tools.Broadcast(ConfigurationManager.AdminChatPrefix + "<" + tsplr.Name + "> " + text,
(byte)ConfigurationManager.AdminChatRGB[0], (byte)ConfigurationManager.AdminChatRGB[1], (byte)ConfigurationManager.AdminChatRGB[2]);
e.Handled = true;
return;
}
if (text.StartsWith("/"))
{
text = text.Remove(0, 1);
var args = Commands.ParseParameters(text);
if (args.Count < 1)
return;
string scmd = args[0];
args.RemoveAt(0);
Command cmd = null;
for (int i = 0; i < Commands.ChatCommands.Count; i++)
{
if (Commands.ChatCommands[i].Name.Equals(scmd))
{
cmd = Commands.ChatCommands[i];
}
}
if (cmd == null)
{
tsplr.SendMessage("That command does not exist, try /help", Color.Red);
}
else
{
if (!cmd.CanRun(tsplr))
{
Tools.SendLogs(string.Format("{0} tried to execute {1}", tsplr.Name, cmd.Name), Color.Red);
tsplr.SendMessage("You do not have access to that command.", Color.Red);
}
else
{
Tools.SendLogs(string.Format("{0} executed: /{1}", tsplr.Name, text), Color.Red);
cmd.Run(text, tsplr, args);
}
}
e.Handled = true;
}
else
{
Log.Info(string.Format("{0} said: {1}", tsplr.Name, text));
}
}
private void OnJoin(int ply, HandledEventArgs handler)
{
if (Main.netMode != 2)
{
if (Main.netMode != 2 || handler.Handled)
return;
}
var player = new TSPlayer(ply);
player.Group = Tools.GetGroupForIP(player.IP);
@ -769,65 +248,143 @@ namespace TShockAPI
Players[ply] = null;
}
private void OnPostInit()
private void OnChat(messageBuffer msg, int ply, string text, HandledEventArgs e)
{
if (!File.Exists(Path.Combine(SavePath, "auth.lck")))
if (Main.netMode != 2)
return;
if (msg.whoAmI != ply)
{
var r = new Random((int)DateTime.Now.ToBinary());
ConfigurationManager.AuthToken = r.Next(100000, 10000000);
Console.WriteLine("TShock Notice: To become SuperAdmin, join the game and type /auth " +
ConfigurationManager.AuthToken);
Console.WriteLine("This token will only display ONCE. This only works ONCE. If you don't use it and the server goes down, delete auth.lck.");
FileTools.CreateFile(Path.Combine(SavePath, "auth.lck"));
}
e.Handled = Tools.HandleGriefer(Players[ply], "Faking Chat");
return;
}
void HandleCommandLine(string[] parms)
var tsplr = Players[msg.whoAmI];
if (tsplr.Group.HasPermission("adminchat") && !text.StartsWith("/"))
{
for (int i = 0; i < parms.Length; i++)
Tools.Broadcast(ConfigurationManager.AdminChatPrefix + "<" + tsplr.Name + "> " + text,
(byte)ConfigurationManager.AdminChatRGB[0], (byte)ConfigurationManager.AdminChatRGB[1], (byte)ConfigurationManager.AdminChatRGB[2]);
e.Handled = true;
return;
}
if (text.StartsWith("/"))
{
if (parms[i].ToLower() == "-ip")
{
IPAddress ip;
if (IPAddress.TryParse(parms[++i], out ip))
{
Netplay.serverListenIP = ip;
Console.Write("Using IP: {0}", ip);
if (Commands.HandleCommand(tsplr, text))
e.Handled = true;
}
else
{
Console.WriteLine("Bad IP: {0}", parms[i]);
}
}
Log.Info(string.Format("{0} said: {1}", tsplr.Name, text));
}
}
private void OnUpdate(GameTime time)
/// <summary>
/// When a server command is run.
/// </summary>
/// <param name="cmd"></param>
/// <param name="e"></param>
private void ServerHooks_OnCommand(string text, HandledEventArgs e)
{
UpdateManager.UpdateProcedureCheck();
foreach (TSPlayer player in TShock.Players)
// Damn you ThreadStatic and Redigit
if (Main.rand == null)
{
Main.rand = new Random();
}
if (WorldGen.genRand == null)
{
WorldGen.genRand = new Random();
}
if (text.StartsWith("exit"))
{
Tools.ForceKickAll("Server shutting down!");
}
else if (text.StartsWith("playing") || text.StartsWith("/playing"))
{
int count = 0;
foreach (TSPlayer player in Players)
{
if (player != null && player.Active)
{
if (player.TileThreshold >= 20)
{
if (Tools.HandleTntUser(player, "Kill tile abuse detected."))
{
RevertKillTile(player);
player.TileThreshold = 0;
player.TilesDestroyed.Clear();
count++;
TSPlayer.Server.SendMessage(string.Format("{0} ({1}) [{2}]", player.Name, player.IP, player.Group.Name));
}
else if (player.TileThreshold > 0)
}
TSPlayer.Server.SendMessage(string.Format("{0} players connected.", count));
e.Handled = true;
}
else if (text.StartsWith("say "))
{
player.TileThreshold = 0;
player.TilesDestroyed.Clear();
Log.Info(string.Format("Server said: {0}", text.Remove(0, 4)));
}
else if (text.StartsWith("/"))
{
if (Commands.HandleCommand(TSPlayer.Server, text))
e.Handled = true;
}
}
else if (player.TileThreshold > 0)
private void GetData(GetDataEventArgs e)
{
player.TileThreshold = 0;
PacketTypes type = (PacketTypes) e.MsgID;
TSPlayer player = Players[e.Msg.whoAmI];
if (!player.ConnectionAlive)
return;
if (Main.verboseNetplay)
Debug.WriteLine("{0:X} ({2}): {3} ({1:XX})", player.Index, (byte) type, player.TPlayer.dead ? "dead " : "alive", type.ToString());
using (var data = new MemoryStream(e.Msg.readBuffer, e.Index, e.Length))
{
try
{
if (GetDataHandlers.HandlerGetData(type, player, data))
e.Handled = true;
}
catch (Exception ex)
{
Log.Error(ex.ToString());
}
}
}
private void OnGreetPlayer(int who, HandledEventArgs e)
{
if (Main.netMode != 2)
return;
TSPlayer player = Players[who];
Log.Info(string.Format("{0} ({1}) from '{2}' group joined.", player.Name, player.IP, player.Group.Name));
Tools.ShowFileToUser(player, "motd.txt");
if (HackedHealth(who))
{
Tools.HandleCheater(player, "Hacked health.");
}
if (ConfigurationManager.PermaPvp)
{
Main.player[who].hostile = true;
NetMessage.SendData(30, -1, -1, "", who);
}
if (Players[who].Group.HasPermission("causeevents") && ConfigurationManager.InfiniteInvasion)
{
StartInvasion();
}
e.Handled = true;
}
private void NpcHooks_OnStrikeNpc(NpcStrikeEventArgs e)
{
if (ConfigurationManager.InfiniteInvasion)
{
IncrementKills();
if (Main.invasionSize < 10)
{
Main.invasionSize = 20000000;
}
}
}
@ -929,9 +486,14 @@ namespace TShockAPI
}
}
public static void PlayerDamage(int plr, int damage)
public static void PlayerDamage(TSPlayer player, int damage)
{
NetMessage.SendData(26, -1, -1, "", plr, ((new Random()).Next(-1, 1)), damage, (float)0);
NetMessage.SendData(26, -1, -1, "", player.Index, ((new Random()).Next(-1, 1)), damage, (float)0);
}
public static void SendTileSquare(TSPlayer player, int x, int y, int size = 10)
{
NetMessage.SendData(20, player.Index, -1, "", size, (float)(x - (size / 2)), (float)(y - (size / 2)), 0f);
}
//TODO : Notify the player if there is more than one match. (or do we want a First() kinda thing?)

1
TShockAPI/TShockAPI.csproj
View file

@ -59,6 +59,7 @@
<Compile Include="ConfigFile.cs" />
<Compile Include="ConfigurationManager.cs" />
<Compile Include="FileTools.cs" />
<Compile Include="GetDataHandlers.cs" />
<Compile Include="Group.cs" />
<Compile Include="Log.cs" />
<Compile Include="Resources.Designer.cs">

11
TShockAPI/Tools.cs
View file

@ -101,6 +101,7 @@ namespace TShockAPI
Log.Info(string.Format("Broadcast: {0}", msg));
}
public static void Broadcast(string msg, Color color)
{
Broadcast(msg, color.R, color.G, color.B);
@ -117,7 +118,7 @@ namespace TShockAPI
TSPlayer.Server.SendMessage(log, color);
foreach (TSPlayer player in TShock.Players)
{
if (player != null && player.Group.HasPermission("logs"))
if (player != null && player.Active && player.Group.HasPermission("logs"))
player.SendMessage(log, color);
}
}
@ -198,7 +199,7 @@ namespace TShockAPI
{
foreach(TSPlayer player in TShock.Players)
{
if (player != null && player.TPlayer.active)
if (player != null && player.Active)
{
Tools.ForceKick(player, reason);
}
@ -212,7 +213,7 @@ namespace TShockAPI
/// <param name="reason">string reason</param>
public static void ForceKick(TSPlayer player, string reason)
{
if (!Netplay.serverSock[player.Index].active || Netplay.serverSock[player.Index].kill)
if (!player.ConnectionAlive)
return;
NetMessage.SendData(0x2, player.Index, -1, reason, 0x0, 0f, 0f, 0f);
Log.Info(string.Format("{0} was force kicked for : {1}", player.IP, reason));
@ -225,7 +226,7 @@ namespace TShockAPI
/// <param name="reason">string reason</param>
public static bool Kick(TSPlayer player, string reason, string adminUserName = "")
{
if (!Netplay.serverSock[player.Index].active || Netplay.serverSock[player.Index].kill)
if (!player.ConnectionAlive)
return true;
if (!player.Group.HasPermission("immunetokick"))
{
@ -248,7 +249,7 @@ namespace TShockAPI
/// <param name="reason">string reason</param>
public static bool Ban(TSPlayer player, string reason, string adminUserName = "")
{
if (!Netplay.serverSock[player.Index].active || Netplay.serverSock[player.Index].kill)
if (!player.ConnectionAlive)
return true;
if (!player.Group.HasPermission("immunetoban"))
{

58
TShockAPI/UpdateManager.cs
View file

@ -37,11 +37,30 @@ namespace TShockAPI
/// Check once every X minutes.
/// </summary>
static readonly int CheckXMinutes = 30;
public static void UpdateProcedureCheck()
{
if ((DateTime.Now - lastcheck).TotalMinutes >= CheckXMinutes)
{
ThreadPool.QueueUserWorkItem(CheckUpdate);
lastcheck = DateTime.Now;
}
}
public static void CheckUpdate(object o)
{
if (ServerIsOutOfDate())
{
EnableUpdateCommand();
NotifyAdministrators(globalChanges);
}
}
/// <summary>
/// Checks to see if the server is out of date.
/// </summary>
/// <returns></returns>
public static bool ServerIsOutOfDate()
private static bool ServerIsOutOfDate()
{
WebClient client = new WebClient();
client.Headers.Add("user-agent",
@ -65,17 +84,28 @@ namespace TShockAPI
return false;
}
public static void EnableUpdateCommand()
private static void EnableUpdateCommand()
{
Commands.ChatCommands.Add(new Command("updatenow", "maintenance", Commands.UpdateNow));
if (!updateCmd)
{
Commands.AddUpdateCommand();
updateCmd = true;
}
}
public static void NotifyAdministrators(string[] changes)
private static void NotifyAdministrators(string[] changes)
{
NotifyAdministrator(TSPlayer.Server, changes);
foreach (TSPlayer player in TShock.Players)
{
if (player != null && player.Active && player.Group.HasPermission("maintenance"))
{
NotifyAdministrator(player, changes);
}
}
}
private static void NotifyAdministrator(TSPlayer player, string[] changes)
{
player.SendMessage("The server is out of date. To update, type /updatenow.");
for (int j = 4; j < changes.Length; j++)
@ -84,24 +114,4 @@ namespace TShockAPI
}
}
}
}
public static void UpdateProcedureCheck()
{
if ((DateTime.Now - lastcheck).TotalMinutes >= CheckXMinutes)
{
ThreadPool.QueueUserWorkItem(CheckUpdate);
lastcheck = DateTime.Now;
}
}
public static void CheckUpdate(object o)
{
if (ServerIsOutOfDate())
{
EnableUpdateCommand();
NotifyAdministrators(globalChanges);
}
}
}
}