private bool TryParseChatCommand(string command, out ChatCommands chatCommand)
{
// IMPROVE: Ugly.
switch (command.ToLower().Trim())
{
case "g":
command = "gather";
break;
case "b":
command = "build";
break;
case "j":
command = "job";
break;
case "p":
command = "patrol";
break;
case "m":
command = "move";
break;
case "k":
command = "kill";
break;
}
return(Enum.TryParse <ChatCommands>(command, true, out chatCommand));
}
private static void smethod_18(Session session_0, ClientMessage clientMessage_0)
{
if (!session_0.CharacterInfo.IsMuted)
{
SpaceInstance instanceBySpaceId = SpaceManager.GetInstanceBySpaceId(session_0.CurrentSpaceId);
if (instanceBySpaceId != null)
{
SpaceActor actorByReferenceId = instanceBySpaceId.GetActorByReferenceId(session_0.CharacterId, SpaceActorType.UserCharacter);
if (actorByReferenceId != null)
{
CharacterInfo referenceObject = (CharacterInfo)actorByReferenceId.ReferenceObject;
clientMessage_0.ReadUnsignedInteger();
string input = InputFilter.FilterString(clientMessage_0.ReadString().Trim(), false);
int messageColor = clientMessage_0.ReadInteger();
if (input.Length != 0)
{
if (input.Length > 100)
{
input = input.Substring(0, 100);
}
if (referenceObject.Staff == 0)
{
messageColor = 1;
}
if (referenceObject.Staff == 1)
{
messageColor = 9;
}
if (referenceObject.Staff == 2)
{
messageColor = 2;
}
if (!input.StartsWith("@") || !ChatCommands.HandleCommand(session_0, input))
{
actorByReferenceId.Chat(input, messageColor, referenceObject.Staff == 1);
}
//1 white, 2 gold, 6 pink, 7 red, 8 blue, 9 orange, 10 green
/*
*
* White = Normal
* Gold = RetroMods
* Green = Designer
* Blue = Translators
* Pink = VIP
* Red = Admin
* Orange = XAT Staff
*
*/
}
}
}
}
}
void Start()
{
// Gui component.
chatGui = this.gameObject.AddComponent("FPSChat");
// The messaging actor
messenger = ActorSystem.Instance.Find("Messenger") as Messenger;
// Parses the chat language used by the gui and calls messenger
// Feel free to provide your own implementation, this is mostly a starting point.
// Supported syntax is documented in the source
chatCommands = new ChatCommands(messenger);
// Setup callacks so we get notified when we join/leave channels and receive messages
Messenger.ChannelJoined channelCallback = ChannelJoined;
messenger.OnChannelJoined(channelCallback);
Messenger.ChannelLeft channelLeftCallback = ChannelLeft;
messenger.OnChannelLeft(channelLeftCallback);
Messenger.MessageReceived messageCallback = MessageReceived;
messenger.OnMessageReceived(messageCallback);
// Join an initial channel. The second argument is a flags string
// that sets certain flags on a channel. Currently 'subscribers' is the
// one valid option. If subscribers is set, status updates from the server
// will include a complete subscriber list for each channel.
messenger.joinChannel("global", "subscribers");
// Send this whenever you want a list of subscribed channels, and the optional
// subscriber list if you have set the subscribers flag. Remember you get this
// automatically when you join/leave a channel.
messenger.ChatStatus();
}
public override void Initialize(ModGameAPI aGameAPI)
{
GameAPI = aGameAPI;
TranslateAPI.LogDB = (S, L) => Log(S, L);
Log($"**HandleEmpyrionChatAutoTranslate loaded: {string.Join(" ", Environment.GetCommandLineArgs())}", LogLevel.Message);
InitializeDB();
LogLevel = Configuration.Current.LogLevel;
ChatCommandManager.CommandPrefix = Configuration.Current.CommandPrefix;
Event_ChatMessage += (C) =>
{
try
{
Task.Run(() => EmpyrionChatAutoTranslate_Event_ChatMessage(C));
}
catch (Exception error)
{
Log($"ChatAutoTranslate_Event_ChatMessage: {error}", LogLevel.Error);
}
};
ChatCommands.Add(new ChatCommand(@"trans help", (I, A) => ExecCommand(SubCommand.Help, I, A), "Show the help"));
ChatCommands.Add(new ChatCommand(@"trans set (?<language>.*)", (I, A) => ExecCommand(SubCommand.Set, I, A), "Set the translation language"));
ChatCommands.Add(new ChatCommand(@"trans box (?<text>.+)", (I, A) => ExecCommand(SubCommand.Box, I, A), "Translate to a messagebox"));
ChatCommands.Add(new ChatCommand(@"trans clear", (I, A) => ExecCommand(SubCommand.Clear, I, A), "Back to the Serverlanguage"));
ChatCommands.Add(new ChatCommand(@"trans listall", (I, A) => ExecCommand(SubCommand.ListAll, I, A), "List all translation settings", PermissionType.Moderator));
}
public async Task SendMessage(string name, string message)
{
int msgCountB = ChatWindow.Messages.Count();
if (message != null && !ChatCommands.CheckForCommand(message, name))
{
ChatWindow.Messages.Add(new UserMessage()
{
Name = name, Message = message
});
}
int msgDiff = ChatWindow.Messages.Count() - msgCountB;
if (msgCountB == 0 && message != "/?" && message != "/help")
{
await Clients.All.SendAsync("ReceiveMessage", ChatWindow.Messages.Last().Name, ChatWindow.Messages.Last().Message, ChatWindow.MessageString(), (message.Contains("/w")));
}
else
{
for (int i = 0; i < msgDiff; i++)
{
await Clients.All.SendAsync("ReceiveMessage", ChatWindow.Messages.ElementAt((msgCountB) + i).Name, ChatWindow.Messages.ElementAt((msgCountB) + i).Message, ChatWindow.MessageString());
}
}
}
public override void Initialize(ModGameAPI dediAPI)
{
GameAPI = dediAPI;
try
{
Log($"**EmpyrionGalaxyNavigator loaded: {string.Join(" ", Environment.GetCommandLineArgs())}", LogLevel.Message);
LoadConfiguration();
LogLevel = Configuration.Current.LogLevel;
ChatCommandManager.CommandPrefix = Configuration.Current.ChatCommandPrefix;
GalaxyMap = new GalaxyMap {
GalaxyAutoUpdateMinutes = Configuration.Current.GalaxyAutoUpdateMinutes
};
GalaxyMap.ReadDbData(Path.Combine(EmpyrionConfiguration.SaveGamePath, "global.db"));
ChatCommands.Add(new ChatCommand(@"nav help", (I, A) => DisplayHelp(I.playerId), "display help"));
ChatCommands.Add(new ChatCommand(@"nav stop", (I, A) => StopNavigation(I.playerId), "stops navigation"));
ChatCommands.Add(new ChatCommand(@"nav updategalaxy", (I, A) => UpdateGalayMap(I.playerId), "force update the galaxy db"));
ChatCommands.Add(new ChatCommand(@"nav setwarp (?<LY>.*)", (I, A) => SetWarpDistance(I.playerId, A), "set the warp distance for navigation to (LY)"));
ChatCommands.Add(new ChatCommand(@"nav (?<target>.*)", (I, A) => StartNavigation(I.playerId, A), "start a navigation to (target)"));
Event_Player_ChangedPlayfield += Navigator_Event_Player_ChangedPlayfield;
TaskTools.Intervall(Configuration.Current.MessageLoopMS, () => { try { CheckPlayerNavMessages().Wait(); } catch { } });
}
catch (Exception Error)
{
Log($"**EmpyrionGalaxyNavigator Error: {Error} {string.Join(" ", Environment.GetCommandLineArgs())}", LogLevel.Error);
}
}
public override void Initialize(ModGameAPI aGameAPI)
{
GameAPI = aGameAPI;
Log($"**HandleEmpyrionStructureCleanUp loaded: {string.Join(" ", Environment.GetCommandLineArgs())}", LogLevel.Message);
InitializeDB();
LogLevel = Configuration.Current.LogLevel;
ChatCommandManager.CommandPrefix = Configuration.Current.ChatCommandPrefix;
ChatCommands.Add(new ChatCommand(@"struct help", (I, A) => ExecCommand(SubCommand.Help, I, A), "Show the help", PermissionType.Admin));
ChatCommands.Add(new ChatCommand(@"struct list", (I, A) => ExecCommand(SubCommand.List, I, A), "List all structures", PermissionType.Admin));
ChatCommands.Add(new ChatCommand(@"struct calc", (I, A) => ExecCommand(SubCommand.Calc, I, A), "Calc all structures again", PermissionType.Admin));
ChatCommands.Add(new ChatCommand(@"struct cleanup", (I, A) => ExecCommand(SubCommand.CleanUp, I, A), "CleanUp old and unsued structures", PermissionType.Admin));
new Thread(() =>
{
try
{
CalcStructures(() => { if (Configuration.Current.CleanOnStartUp)
{
CleanUpStructuresWorker();
}
}).Wait();
}
catch (Exception error)
{
Log($"CalcStructures(Initialize): {error}", LogLevel.Error);
}
})
.Start();
}
private bool TryParseCommand(ChatCommands commandType, List <string> args, ref Command command)
{
command.commandType = commandType;
switch (commandType)
{
case ChatCommands.Join:
return(TryParseJoinCommand(args, ref command));
case ChatCommands.Gather:
return(TryParseGatherCommand(args, ref command));
case ChatCommands.Build:
return(TryParseBuildCommand(args, ref command));
case ChatCommands.Job:
return(TryParseJobCommand(args, ref command));
case ChatCommands.Patrol:
return(TryParsePatrolCommand(args, ref command));
case ChatCommands.Move:
return(TryParseMoveCommand(args, ref command));
case ChatCommands.Kill:
return(TryParseKillCommand(args, ref command));
}
return(false);
}
private static void smethod_18(Session session_0, ClientMessage clientMessage_0)
{
if (!session_0.CharacterInfo.IsMuted)
{
SpaceInstance instanceBySpaceId = SpaceManager.GetInstanceBySpaceId(session_0.CurrentSpaceId);
if (instanceBySpaceId != null)
{
SpaceActor actorByReferenceId = instanceBySpaceId.GetActorByReferenceId(session_0.CharacterId, SpaceActorType.UserCharacter);
if (actorByReferenceId != null)
{
CharacterInfo referenceObject = (CharacterInfo)actorByReferenceId.ReferenceObject;
clientMessage_0.ReadUnsignedInteger();
string input = InputFilter.FilterString(clientMessage_0.ReadString().Trim(), false);
int messageColor = clientMessage_0.ReadInteger();
if (input.Length != 0)
{
if (input.Length > 100)
{
input = input.Substring(0, 100);
}
if ((messageColor == 2) && (referenceObject.Staff == 0))
{
messageColor = 1;
}
if (!input.StartsWith("@") || !ChatCommands.HandleCommand(session_0, input))
{
actorByReferenceId.Chat(input, messageColor, referenceObject.Staff == 1);
}
}
}
}
}
}
public ProjectG(TcpClient tcp) : base(tcp)
{
ServerType = ServerTypeEnum.Login;
PacketLogin = new ClientLogin();
PacketGame = new ClientGame();
PacketMessenger = new ClientMessanger();
Commands = new ChatCommands();
}
public static void Send(Character character, int roomId, string message)
{
if (message.StartsWith("/") && character is Player player)
{
//throw new NotImplementedException();
ChatCommands.Handle(player.GetSession(), message);
return;
}
Room(character, roomId, message);
}
private static void UserChat(Session Session, ClientMessage Message)
{
if (Session.CharacterInfo.IsMuted)
{
return;
}
RoomInstance Instance = RoomManager.GetInstanceByRoomId(Session.CurrentRoomId);
if (Instance == null)
{
return;
}
RoomActor Actor = Instance.GetActorByReferenceId(Session.CharacterId);
if (Actor == null)
{
return;
}
bool Shout = (Message.Id == OpcodesIn.ROOM_CHAT_SHOUT);
string MessageText = UserInputFilter.FilterString(Message.PopString());
if (MessageText.Length == 0)
{
return;
}
if (MessageText.Length > 100)
{
MessageText = MessageText.Substring(0, 100);
}
MessageText = Wordfilter.Filter(MessageText);
if (MessageText.StartsWith(":") && (ChatCommands.HandleCommand(Session, MessageText) ||
Session.HasRight("moderation_tool")))
{
return;
}
if (Instance.WiredManager.HandleChat(MessageText, Actor))
{
Actor.Whisper(MessageText, 0);
return;
}
Actor.Chat(MessageText, Shout, Session.HasRight("mute"));
if (Instance.HumanActorCount > 1)
{
QuestManager.ProgressUserQuest(Session, QuestType.SOCIAL_CHAT);
}
}
public MessageHandler(TelegramBotClient client, MainProvider provider, CommandProvider commandProvider, AdminHandler adminHandler)
{
this.client = client;
this.provider = provider;
this.commandProvider = commandProvider;
this.adminHandler = adminHandler;
authSystem = new AuthenticateSystem(client, provider);
chatCommands = new ChatCommands(client, provider);
addCash = new AddCash(client, provider);
}
void MakeSingleton()
{
if (command != null)
{
Destroy(gameObject);
}
else
{
command = this;
DontDestroyOnLoad(gameObject);
}
}
public void SendLobbyMessage(SendMessageEvent e, Node any, [JoinAll] ActiveLobbyChat activeChannel, [JoinAll] SingleNode <SelfUserComponent> self)
{
Event event2;
if (ChatCommands.IsCommand(e.Message, out event2))
{
base.NewEvent(event2).Attach(activeChannel).Attach(self).Schedule();
}
else
{
base.ScheduleEvent(new SendChatMessageEvent(e.Message), activeChannel);
}
}
public PaintGunMod(PaintGun_GameSession session) : base(MOD_NAME, session)
{
string msg = "### PaintGun v23";
VRage.Utils.MyLog.Default.WriteLineAndConsole(msg);
Log.Info(msg);
session.SetUpdateOrder(MyUpdateOrder.AfterSimulation); // define what update types the modAPI session comp should trigger
DisablePaintGunVanillaShoot();
// Systems
Caches = new Caches(this);
Constants = new Constants(this);
PlayerHandler = new PlayerHandler(this);
NetworkLibHandler = new NetworkLibHandler(this);
if (IsPlayer)
{
TextAPI = new TextAPI(this);
DrawUtils = new DrawUtils(this);
GameConfig = new GameConfig(this);
}
// Features
Palette = new Palette(this);
Painting = new Painting(this);
if (IsPlayer)
{
CheckPlayerField = new CheckPlayerField(this);
Settings = new Settings(this);
PaletteInputHandler = new PaletteInputHandler(this);
PaletteScheduledSync = new PaletteScheduledSync(this);
HUDSounds = new HUDSounds(this);
LocalToolHandler = new LocalToolHandler(this);
LocalToolDescription = new LocalToolDescription(this);
SelectionGUI = new SelectionGUI(this);
ToolHandler = new ToolHandler(this);
ChatCommands = new ChatCommands(this);
Notifications = new Notifications(this);
PaletteHUD = new PaletteHUD(this);
ColorPickerGUIWarning = new ColorPickerGUIWarning(this);
ConfigMenuHandler = new ConfigMenuHandler(this);
}
if (Constants.EnableTestComponent)
{
TestComp = new TestComp(this);
}
}
public override void Initialize(ModGameAPI dediAPI)
{
DediAPI = dediAPI;
LogLevel = LogLevel.Message;
Log($"**EmpyrionXChange: loaded");
LoadConfiuration();
LogLevel = Configuration.Current.LogLevel;
ChatCommandManager.CommandPrefix = Configuration.Current.CommandPrefix;
ChatCommands.Add(new ChatCommand(@"ex", HandleOpenXChangeCall, "Hilfe und Status"));
ChatCommands.Add(new ChatCommand(@"ex (?<command>.+)", HandleOpenXChangeCall, "tausche nach {was}"));
}
private void OnChat(ChatData data)
{
// Try to parse the message as a chat command and ignore it if it is not a known command
string cmd = data.Message.Split(' ').First();
if (ChatCommands.ContainsKey(cmd))
{
AgentPrivate agent = ScenePrivate.FindAgent(data.SourceId);
if (agent != null)
{
ChatCommands[cmd].Action(data.Message, agent);
}
}
}
/// <summary>
/// Bot command response handler.
/// </summary>
public void Respond(SocketMessage message, bool outputUnknowns)
{
string messageText = message.Content;
if (messageText.StartsWith(Constants.COMMAND_PREFIX))
{
messageText = messageText.Substring(Constants.COMMAND_PREFIX.Length);
}
string[] messageDataSplit = messageText.Split(' ');
StringBuilder resultBuilder = new StringBuilder(messageText.Length);
List <string> cmds = new List <string>();
for (int i = 0; i < messageDataSplit.Length; i++)
{
if (messageDataSplit[i].Contains("<@") && messageDataSplit[i].Contains(">"))
{
continue;
}
resultBuilder.Append(messageDataSplit[i]).Append(" ");
if (messageDataSplit[i].Length > 0)
{
cmds.Add(messageDataSplit[i]);
}
}
if (cmds.Count == 0)
{
Console.WriteLine("Empty input, ignoring: " + message.Author.Username);
return;
}
string fullMessageCleaned = resultBuilder.ToString();
Console.WriteLine("Found input from: (" + message.Author.Username + "), in channel: " + message.Channel.Name + ": " + fullMessageCleaned);
string commandNameLowered = cmds[0].ToLowerInvariant();
cmds.RemoveAt(0);
if (ChatCommands.TryGetValue(commandNameLowered, out Action <string[], SocketMessage> acto))
{
acto.Invoke(cmds.ToArray(), message);
}
else if (outputUnknowns)
{
message.Channel.SendMessageAsync(embed: UserCommands.GetErrorMessageEmbed("Unknown Command", "Unknown command. Consider the __**help**__ command?")).Wait();
}
else if (cmds.Count == 0 && InformationalData.ContainsKey(commandNameLowered))
{
InfoCmds.CMD_Info(new string[] { commandNameLowered }, message);
}
}
public override void Initialize(ModGameAPI dediAPI)
{
GameAPI = dediAPI;
Log($"**HandleEmpyrionTeleporter loaded: {string.Join(" ", Environment.GetCommandLineArgs())}", LogLevel.Message);
InitializeConfiguration();
LogLevel = Configuration.Current.LogLevel;
ChatCommandManager.CommandPrefix = Configuration.Current.ChatCommandPrefix;
var chatChar = ChatCommandManager.CommandPrefix?.FirstOrDefault() ?? '/';
ChatCommands.Add(new ChatCommand(@"s", (I, A) => SortInventory(I, A), $"Execute sorting, latest slot from '{chatChar}sort set' or '{chatChar}sort' command"));
ChatCommands.Add(new ChatCommand(@"sort (?<number>\d)", (I, A) => SortInventory(I, A), $"Execute sorting (0..9). Set the slot for '{chatChar}s'"));
ChatCommands.Add(new ChatCommand(@"sort set (?<number>\d)", (I, A) => SortSet(I, A), $"Saves the current sorting slot (0..9). Set the slot for '{chatChar}s'"));
ChatCommands.Add(new ChatCommand(@"sort help", (I, A) => DisplayHelp(I.playerId, ""), "Display help"));
}
public override void Initialize(ModGameAPI aGameAPI)
{
GameAPI = aGameAPI;
Log($"**HandleEmpyrionBaseAlign loaded", LogLevel.Message);
LoadConfiguration();
LogLevel = Configuration.Current.LogLevel;
ChatCommandManager.CommandPrefix = Configuration.Current.CommandPrefix;
Event_Entity_PosAndRot += EmpyrionBaseAlign_Event_Entity_PosAndRot;
ChatCommands.Add(new ChatCommand(@"al help", (C, A) => ExecAlignCommand(SubCommand.Help, C, A), "Hilfe anzeigen"));
ChatCommands.Add(new ChatCommand(@"al (?<BaseToAlignId>\d+) (?<MainBaseId>\d+)", (C, A) => ExecAlignCommand(SubCommand.Align, C, A), "Basis {BaseToAlignId} an Basis {MainBaseId} ausrichten, verschieben und drehen"));
ChatCommands.Add(new ChatCommand(@"al (?<BaseToAlignId>\d+)", (C, A) => ExecAlignCommand(SubCommand.Align, C, A), "Basis {BaseToAlignId} verschieben/drehen"));
ChatCommands.Add(new ChatCommand(@"als (?<ShiftX>.+) (?<ShiftY>.+) (?<ShiftZ>.+)", (C, A) => ExecAlignCommand(SubCommand.Shift, C, A), "Letzte /al {BaseToAlignId} um {ShiftX} {ShiftY} {ShiftZ} verschieben"));
ChatCommands.Add(new ChatCommand(@"alr (?<RotateX>.+) (?<RotateY>.+) (?<RotateZ>.+)", (C, A) => ExecAlignCommand(SubCommand.Rotate, C, A), "Letzte /al {BaseToAlignId} um {RotateX} {RotateY} {RotateZ} drehen"));
}
// Sets up all the command hooks
public static void Init()
{
DevCommands.Init();
ModerationCommands.Init();
BuildingCommands.Init();
InfoCommands.Init();
WorldCommands.Init();
ZoneCommands.Init();
MaintenanceCommands.Init();
ChatCommands.Init();
FunCommands.Init();
MathCommands.Init();
Logger.Log(LogType.Debug,
"CommandManager: {0} commands registered ({1} hidden, {2} aliases)",
Commands.Count,
GetCommands(true).Length,
Aliases.Count);
}
private void AddCommandsFor(BackpackConfiguration config, string name, Func <PlayerInfo, string> idFunc)
{
if (config.MaxBackpacks == 0)
{
return;
}
ChatCommands.Add(new ChatCommand($"{config.ChatCommand} help", (I, A) => DisplayHelp(I, config, name, idFunc), $"help and commands for the {name} backpack"));
if (config.MaxBackpacks > 1)
{
ChatCommands.Add(new ChatCommand($"{config.ChatCommand} (?<number>\\d+)", (I, A) => OpenBackpack(I, A, config, name, idFunc), $"Open the <N> = 1, 2, 3,... {name} backpack"));
}
ChatCommands.Add(new ChatCommand($"{config.ChatCommand}", (I, A) => OpenBackpack(I, A, config, name, idFunc), $"Open the current {name} backpack"));
if (config.MaxBackpacks > 1)
{
ChatCommands.Add(new ChatCommand($"{config.ChatCommand} buy", (I, A) => BuyBackpack(I, A, config, name, idFunc), $"buy another {name} backpack"));
}
}
public override void Initialize(ModGameAPI dediAPI)
{
DediAPI = dediAPI;
LogLevel = LogLevel.Message;
Log($"**VotingRewardMod: loaded");
LoadConfiuration();
LogLevel = Configuration.Current.LogLevel;
ChatCommandManager.CommandPrefix = Configuration.Current.CommandPrefix;
ChatCommands.Add(new ChatCommand(@"votereward", (I, A) => VoteReward(I, A, VoteMode.Voting), "Vote to get an award"));
if (Configuration.Current.VotingLottery.Count > 0)
{
ChatCommands.Add(new ChatCommand(@"votelottery", (I, A) => VoteReward(I, A, VoteMode.Lottery), "Vote to play in the lottery"));
}
Configuration.Current.StatsRewards?.ForEach(R => ChatCommands.Add(new ChatCommand($"voteforstat {R.Type.ToString().ToLower()}", (I, A) => VoteReward(I, A, R.Type), $"Vote to boost your {R.Type} for another {R.AddCount} (max: {R.MaxCount})")));
ChatCommands.Add(new ChatCommand(@"vote help", (I, A) => DisplayHelp(I), "Votereward help"));
}
public override void Initialize(ModGameAPI aGameAPI)
{
GameAPI = aGameAPI;
Log($"**HandleEmpyrionPassenger loaded: {string.Join(" ", Environment.GetCommandLineArgs())}", LogLevel.Message);
InitializeDB();
LogLevel = PassengersDB.Configuration.Current.LogLevel;
ChatCommandManager.CommandPrefix = PassengersDB.Configuration.Current.CommandPrefix;
Event_Player_Connected += (P) => EmpyrionPassenger_Event_Player_Connected(P);
ChatCommands.Add(new ChatCommand(@"pass", (I, A) => ExecCommand(SubCommand.Save, I, A), "Saves Passengers als pilot of vessel"));
ChatCommands.Add(new ChatCommand(@"pass (?<ID>\d+)", (I, A) => ExecCommand(SubCommand.Save, I, A), "Saves Passengers manually and if not pilot with vessel ID"));
ChatCommands.Add(new ChatCommand(@"pass exec", (I, A) => ExecCommand(SubCommand.Teleport, I, A), "Execute teleport"));
ChatCommands.Add(new ChatCommand(@"pass help", (I, A) => ExecCommand(SubCommand.Help, I, A), "Display help"));
ChatCommands.Add(new ChatCommand(@"pass back", (I, A) => ExecCommand(SubCommand.Back, I, A), "Teleports the player back to the last (good) position"));
ChatCommands.Add(new ChatCommand(@"pass delete (?<ID>\d+)", (I, A) => ExecCommand(SubCommand.Delete, I, A), "Delete all teleportdata from {ID}"));
ChatCommands.Add(new ChatCommand(@"pass list (?<ID>\d+)", (I, A) => ExecCommand(SubCommand.List, I, A), "List all teleportdata from {ID}"));
ChatCommands.Add(new ChatCommand(@"pass listall", (I, A) => ExecCommand(SubCommand.ListAll, I, A), "List all teleportdata", PermissionType.Moderator));
ChatCommands.Add(new ChatCommand(@"pass cleanup", (I, A) => ExecCommand(SubCommand.CleanUp, I, A), "Removes all teleportdata to deleted structures", PermissionType.Moderator));
}
public override void Initialize(ModGameAPI aGameAPI)
{
GameAPI = aGameAPI;
Log($"**HandleEmpyrionTeleporter loaded: {string.Join(" ", Environment.GetCommandLineArgs())}", LogLevel.Message);
InitializeTeleporterDB();
LogLevel = TeleporterDB.Settings.Current.LogLevel;
ChatCommandManager.CommandPrefix = TeleporterDB.Settings.Current.ChatCommandPrefix;
ChatCommands.Add(new ChatCommand(@"tt", (I, A) => ExecAlignCommand(SubCommand.Teleport, TeleporterPermission.PublicAccess, I, A), "Execute teleport"));
ChatCommands.Add(new ChatCommand(@"tt help", (I, A) => ExecAlignCommand(SubCommand.Help, TeleporterPermission.PublicAccess, I, A), "Display help"));
ChatCommands.Add(new ChatCommand(@"tt back", (I, A) => ExecAlignCommand(SubCommand.Back, TeleporterPermission.PublicAccess, I, A), "Teleports the player back to the last (good) position"));
ChatCommands.Add(new ChatCommand(@"tt delete (?<SourceId>\d+) (?<TargetId>\d+)", (I, A) => ExecAlignCommand(SubCommand.Delete, TeleporterPermission.PublicAccess, I, A), "Delete all teleportdata from {SourceId} {TargetId}"));
ChatCommands.Add(new ChatCommand(@"tt list (?<Id>\d+)", (I, A) => ExecAlignCommand(SubCommand.List, TeleporterPermission.PublicAccess, I, A), "List all teleportdata from {Id}"));
ChatCommands.Add(new ChatCommand(@"tt listall", (I, A) => ExecAlignCommand(SubCommand.ListAll, TeleporterPermission.PublicAccess, I, A), "List all teleportdata", PermissionType.Moderator));
ChatCommands.Add(new ChatCommand(@"tt cleanup", (I, A) => ExecAlignCommand(SubCommand.CleanUp, TeleporterPermission.PublicAccess, I, A), "Removes all teleportdata to deleted structures", PermissionType.Moderator));
ChatCommands.Add(new ChatCommand(@"tt private (?<SourceId>\d+) (?<TargetId>\d+)", (I, A) => ExecAlignCommand(SubCommand.Save, TeleporterPermission.PrivateAccess, I, A), "Init Teleport from {SourceId} (PlayerPosition) to {TargetId} accessible is allowed for you only - must be initialized at {TargetId} too :-)"));
ChatCommands.Add(new ChatCommand(@"tt faction (?<SourceId>\d+) (?<TargetId>\d+)", (I, A) => ExecAlignCommand(SubCommand.Save, TeleporterPermission.FactionAccess, I, A), "Init Teleport from {SourceId} (PlayerPosition) to {TargetId} accessible is allowed for your faction - must be initialized at {TargetId} too :-)"));
ChatCommands.Add(new ChatCommand(@"tt allies (?<SourceId>\d+) (?<TargetId>\d+)", (I, A) => ExecAlignCommand(SubCommand.Save, TeleporterPermission.AlliesAccess, I, A), "Init Teleport from {SourceId} (PlayerPosition) to {TargetId} accessible is allowed for your faction and allies - must be initialized at {TargetId} too :-)"));
ChatCommands.Add(new ChatCommand(@"tt (?<SourceId>\d+) (?<TargetId>\d+)", (I, A) => ExecAlignCommand(SubCommand.Save, TeleporterPermission.PublicAccess, I, A), "Init Teleport from {SourceId} (PlayerPosition) to {TargetId} accessible is allowed for everyone - must be initialized at {TargetId} too :-)"));
}
public override void Initialize(ModGameAPI dediAPI)
{
DediAPI = dediAPI;
try
{
Log($"**EmpyrionPoiRestore loaded: {string.Join(" ", Environment.GetCommandLineArgs())}", LogLevel.Message);
LoadConfiguration();
LogLevel = Configuration.Current.LogLevel;
ChatCommandManager.CommandPrefix = Configuration.Current.ChatCommandPrefix;
ChatCommands.Add(new ChatCommand(@"poipos help", (I, A) => DisplayHelp(I.playerId, null), "display help"));
ChatCommands.Add(new ChatCommand(@"poipos add (?<Name>.+)", (I, A) => StorePoiPosAndRot(I.playerId, A), "store POI pos and rot", PermissionType.Admin));
TaskTools.Intervall(Configuration.Current.CheckPoiPositionsEveryNSeconds * 1000, async() => await CheckPlayfields());
Event_Playfield_Loaded += P => TaskTools.Delay(Configuration.Current.CheckPoiPositionsNSecondsAfterPlayfieldLoaded, async() => await CheckPlayfields());
}
catch (Exception Error)
{
Log($"**EmpyrionPoiRestore Error: {Error} {string.Join(" ", Environment.GetCommandLineArgs())}", LogLevel.Error);
}
}
public static void HandleChatMessage()
{
uint sender = OBJECT_SELF;
string originalMessage = Chat.GetMessage().Trim();
if (!CanHandleChat(sender, originalMessage))
{
return;
}
var split = originalMessage.Split(' ').ToList();
// Commands with no arguments won't be split, so if we didn't split anything then add the command to the split list manually.
if (split.Count <= 0)
{
split.Add(originalMessage);
}
split[0] = split[0].ToLower();
string command = split[0].Substring(1, split[0].Length - 1);
split.RemoveAt(0);
Chat.SkipMessage();
if (!ChatCommands.ContainsKey(command))
{
SendMessageToPC(sender, ColorToken.Red("Invalid chat command. Use '/help' to get a list of available commands."));
return;
}
var chatCommand = ChatCommands[command];
string args = string.Join(" ", split);
if (!chatCommand.RequiresTarget)
{
ProcessChatCommand(command, sender, OBJECT_INVALID, null, args);
}
else
{
string error = chatCommand.ValidateArguments(sender, split.ToArray());
if (!string.IsNullOrWhiteSpace(error))
{
SendMessageToPC(sender, error);
return;
}
SetLocalString(sender, "CHAT_COMMAND", command);
SetLocalString(sender, "CHAT_COMMAND_ARGS", command);
SendMessageToPC(sender, "Please use your 'Chat Command Targeter' feat to select the target of this chat command.");
if (!GetHasFeat(Feat.ChatCommandTargeter, sender) || GetIsDM(sender) || GetIsDMPossessed(sender))
{
Creature.AddFeatByLevel(sender, Feat.ChatCommandTargeter, 1);
if (GetIsDM(sender) || GetIsDMPossessed(sender))
{
var qbs = Player.GetQuickBarSlot(sender, 11);
if (qbs.ObjectType == QuickBarSlotType.Empty)
{
Player.SetQuickBarSlot(sender, 11, PlayerQuickBarSlot.UseFeat(Feat.ChatCommandTargeter));
}
}
}
}
}
public static bool ChatMessage(ClientInfo clientInfo, EChatType _type, int _senderId, string message, string mainName, bool _localizeMain, List <int> _recipientEntityIds)
{
// We make sure there is an actual message and a client, and also ignore the message if it's from the server.
if (!string.IsNullOrEmpty(message) && clientInfo != null && mainName != null)
{
//We check to see if the message starts with a /
if (message.Trim().StartsWith("/"))
{
return(ChatCommands.Handle(message, clientInfo));
/**
* //we then remove that / to get the rest of the message.
* string[] cmd = message.Trim().Remove(0, 1).Split(' ');
*
* if (cmd[0] == "end")
* {
* foreach (ClientInfo pcli in ConnectionManager.Instance.Clients.List)
* {
* if (pcli == null) continue;
*
* Configs.selectedMap = "none";
*
* foreach (string key in Events.TeamDeaths.Keys)
* {
* Events.TeamDeaths[key] = 0;
* }
*
* pcli.SendPackage(NetPackageManager.GetPackage<NetPackageTeleportPlayer>().Setup(Configs.LobbyPosition, null, false));
* pcli.SendPackage(NetPackageManager.GetPackage<NetPackageChat>().Setup(EChatType.Whisper, pcli.entityId, "[FF3333] END", null, false, null));
* }
* return false;
* }
*
* if (Configs.selectedMap != "none") return true;
*
* if (cmd[0] == "zombie")
* {
* try
* {
* World world = GameManager.Instance.World;
* EntityPlayer player = world.Players.dict[clientInfo.entityId];
*
* HashSet<int> classIds = new HashSet<int>();
* foreach (var g in EntityGroups.list.Dict)
* {
* //Log.Out(string.Format("Key = {0}\n\n", g.Key));
* foreach (var gg in g.Value)
* {
* classIds.Add(gg.entityClassId);
*
* //Log.Out(string.Format("prob = {0}", gg.prob));
* //Log.Out(string.Format("reqMin = {0}", gg.reqMin));
* //Log.Out(string.Format("reqMax = {0}", gg.reqMax));
* }
* }
*
* foreach (int id in classIds)
* {
* //Log.Out(string.Format("entityClassId = {0}", id));
* int et = id;//EntityClass.FromString("animalZombieVultureRadiated");
*
* Vector3 vector;
* if (!world.GetRandomSpawnPositionMinMaxToPosition(player.position, 1, 10, 1, false, out vector))
* {
* Log.Out("Cant find spot wtf?");
* return false;
* }
*
* Entity entity = EntityFactory.CreateEntity(et, vector);
* //if (entity.GetType() != typeof(EntityEnemy)) continue;
*
* EntityEnemy entityEnemy = (EntityEnemy)entity;
*
* world.SpawnEntityInWorld(entityEnemy);
* entityEnemy.SetSpawnerSource(EnumSpawnerSource.Dynamic);
* entityEnemy.IsHordeZombie = false;
* entityEnemy.IsBloodMoon = false;
* entityEnemy.bIsChunkObserver = true;
* entityEnemy.timeStayAfterDeath /= 3;
* entityEnemy.lootDropProb = 0;
* }
*
*
*
*
* }
* catch (Exception e)
* {
* Log.Error(string.Format("Error in z cmd: {0}", e.Message));
* Log.Error(e.StackTrace);
* Log.Exception(e);
* }
* }
* else if (cmd[0] == "class")
* {
* if (cmd.Length < 2)
* {
* clientInfo.SendPackage(NetPackageManager.GetPackage<NetPackageChat>().Setup(EChatType.Whisper, _senderId, "[FF3333]Tank / Soldier / Scout ", null, false, null));
* return false;
* }
*
* List<string> classes = new List<string>() { "tank", "soldier", "scout" };
*
* string className = cmd[1].Trim().ToLower();
*
* if (!classes.Contains(className))
* {
* clientInfo.SendPackage(NetPackageManager.GetPackage<NetPackageChat>().Setup(EChatType.Whisper, _senderId, "[FF3333]Tank / Soldier / Scout ", null, false, null));
* return false;
* }
*
* string pId = clientInfo.playerId;
*
* if (!Configs.PlayerClasses.ContainsKey(pId))
* {
* Configs.PlayerClasses.Add(pId, "");
* }
*
* Configs.PlayerClasses[pId] = className;
* clientInfo.SendPackage(NetPackageManager.GetPackage<NetPackageChat>().Setup(EChatType.Whisper, _senderId, string.Format("[FF3333]Selected: {0} ", className), null, false, null));
* }
* else if (cmd[0] == "die")
* {
* World world = GameManager.Instance.World;
* foreach (EntityPlayer entityPlayer in world.Players.list)
* {
* if (!entityPlayer.IsSpawned()) continue;
* if (entityPlayer.IsDead()) continue;
* if (entityPlayer == null) continue;
*
* entityPlayer.DamageEntity(new DamageSource(EnumDamageSource.Internal, EnumDamageTypes.Suicide), 99999, false, 1f);
*
*
*
* /*EntityCreationData entityCreationData = new EntityCreationData()
* {
* clientEntityId = entityPlayer.clientEntityId,
* belongsPlayerId = entityPlayer.belongsPlayerId,
* entityClass = EntityClass.FromString("playerMale"),
* id = EntityFactory.nextEntityID++,
* };
*
*
* EntityPlayerLocal entityPlayerLocal = EntityFactory.CreateEntity(entityCreationData) as EntityPlayerLocal;
*
*
* //EntityPlayerLocal entityPlayerLocal = BuildLocalPlayer(ci);
*
* /*if (entityPlayerLocal == null)
* {
* Log.Out("nah");
* continue;
* }
*
* entityPlayerLocal.clientEntityId = entityPlayer.clientEntityId;
* entityPlayerLocal.belongsPlayerId = entityPlayer.belongsPlayerId;
* entityPlayerLocal.inventory = entityPlayer.inventory;
* entityPlayerLocal.bag = entityPlayer.bag;
* entityPlayerLocal.equipment = entityPlayer.equipment;
* entityPlayerLocal.persistentPlayerData = GameManager.Instance.GetPersistentPlayerList().GetPlayerDataFromEntityID(entityPlayer.entityId);
*
* if (entityPlayerLocal == null)
* {
* Log.Out("nah");
* continue;
* }
*
* //EntityPlayerLocal entityPlayerLocal = entityPlayer.GetAttachedPlayerLocal();
*
* //Log.Out(entityPlayerLocal.ToString());
*
* //entityPlayerLocal.inventory.Clear();
* //entityPlayerLocal.inventory.AddItem(itemStack);
*
* //entityPlayerLocal.bag.Clear();
*
*
* //world.SpawnEntityInWorld(entityItem);
*
*
* //ci.SendPackage(NetPackageManager.GetPackage<NetPackagePlayerInventory>().Setup(entityPlayerLocal, true, true, false));
* //ci.SendPackage(NetPackageManager.GetPackage<NetPackageEntityCollect>().Setup(entityItem.entityId, entityPlayer.entityId));
*
* //world.RemoveEntity(entityItem.entityId, EnumRemoveEntityReason.Despawned);
* }
* }
* else if (cmd[0] == "tp")
* {
* if (cmd.Length < 2)
* {
* clientInfo.SendPackage(NetPackageManager.GetPackage<NetPackageChat>().Setup(EChatType.Whisper, _senderId, "[85144b]You ugly bitch [FF4136]/tp who or what", null, false, null));
* return false;
* }
*
* string what = cmd[1].Trim();
*
* Vector3 destination = new Vector3();
*
* bool found = false;
* foreach (EntityPlayer player in GameManager.Instance.World.Players.list)
* {
* ClientInfo client = ConnectionManager.Instance.Clients.ForEntityId(player.entityId);
* if (client.playerName.Contains(what))
* {
* destination = player.position;
* found = true;
* break;
* }
* }
*
* if (found)
* {
* clientInfo.SendPackage(NetPackageManager.GetPackage<NetPackageTeleportPlayer>().Setup(destination, null, false));
* return false;
* }
*
* foreach (Configs.Map map in Configs.Maps.Values)
* {
* if (map.name.ToLower().Contains(what.ToLower()))
* {
* string type = "team";
* if (cmd.Length >= 3)
* {
* type = cmd[2].Trim().ToLower();
* }
*
* int index = 0;
* if (cmd.Length >= 4)
* {
* index = int.Parse(cmd[3].Trim());
* }
*
* if (type == "team" && map.spawnsForTeams.Count > 0)
* {
* destination = map.spawnsForTeams[index];
* }
* else
* {
* destination = map.spawnsForEnemies[index];
* }
*
* found = true;
* break;
* }
* }
*
* if (found)
* {
* clientInfo.SendPackage(NetPackageManager.GetPackage<NetPackageTeleportPlayer>().Setup(destination, null, false));
* return false;
* }
*
* if (cmd.Length == 3)
* {
* World world = GameManager.Instance.World;
*
* int x = int.Parse(cmd[1].Trim());
* int z = int.Parse(cmd[2].Trim());
*
* int y = 128;
* if (world.IsChunkAreaLoaded(x, 0, z))
* {
* Chunk c = (Chunk)world.GetChunkFromWorldPos(x, 0, z);
* y = c.GetTerrainHeight(x & 0xF, z & 0xF) + 1;
* }
*
* destination = new Vector3(x, y, z);
*
* clientInfo.SendPackage(NetPackageManager.GetPackage<NetPackageTeleportPlayer>().Setup(destination, null, false));
* return false;
* }
*
* clientInfo.SendPackage(NetPackageManager.GetPackage<NetPackageChat>().Setup(EChatType.Whisper, _senderId, "[85144b]You ugly bitch [FF4136]I can't find Your dreamed up hero!", null, false, null));
* return false;
* }
* else if (cmd[0] == "gparty")
* {
*
* World world = GameManager.Instance.World;
*
* try
* {
* EntityPlayer leaderPlayer = world.Players.dict[clientInfo.entityId];
* ClientInfo leaderPlayerCI = ConnectionManager.Instance.Clients.ForEntityId(leaderPlayer.entityId);
*
* leaderPlayer.CreateParty();
* leaderPlayerCI.SendPackage(NetPackageManager.GetPackage<NetPackagePartyData>().Setup(leaderPlayer.Party, clientInfo.entityId, PartyActions.AutoJoin, false));
*
* foreach (EntityPlayer entityPlayer in world.Players.list)
* {
* if (entityPlayer.entityId == leaderPlayer.entityId) continue;
*
* ClientInfo entityPlayerCI = ConnectionManager.Instance.Clients.ForEntityId(entityPlayer.entityId);
*
*
* leaderPlayer.Party.AddPlayer(entityPlayer);
*
* foreach (EntityPlayer entityPlayerSub in world.Players.list)
* {
* entityPlayerCI = ConnectionManager.Instance.Clients.ForEntityId(entityPlayerSub.entityId);
* entityPlayerCI.SendPackage(NetPackageManager.GetPackage<NetPackagePartyData>().Setup(leaderPlayer.Party, entityPlayerCI.entityId, PartyActions.AutoJoin, false));
* }
* }
*
* }
* catch (Exception e)
* {
* Log.Error(string.Format("Error in AddPlayerToTeam: {0}", e.Message));
* Log.Error(e.StackTrace);
* Log.Exception(e);
* }
* }
* else if (cmd[0] == "poi")
* {
* World world = GameManager.Instance.World;
* Vector3 position = world.Players.dict[clientInfo.entityId].position;
* PrefabInstance pi = GameManager.Instance.World.GetPOIAtPosition(position);
*
* if (cmd.Length == 1)
* {
* if (pi == null)
* {
* clientInfo.SendPackage(NetPackageManager.GetPackage<NetPackageChat>().Setup(EChatType.Whisper, _senderId, "[FF0000]No POI found!", null, false, null));
* return false;
* }
*
* clientInfo.SendPackage(NetPackageManager.GetPackage<NetPackageChat>().Setup(EChatType.Whisper, _senderId, "[FFCC00]POI: [DDDDDD]" + pi.name, null, false, null));
* return false;
* }
*
* int num = World.toChunkXZ((int)position.x) - 1;
* int num2 = World.toChunkXZ((int)position.z) - 1;
* int num3 = num + 2;
* int num4 = num2 + 2;
*
* HashSetLong hashSetLong = new HashSetLong();
* for (int k = num; k <= num3; k++)
* {
* for (int l2 = num2; l2 <= num4; l2++)
* {
* hashSetLong.Add(WorldChunkCache.MakeChunkKey(k, l2));
* }
* }
*
* ChunkCluster chunkCache = world.ChunkCache;
* ChunkProviderGenerateWorld chunkProviderGenerateWorld = world.ChunkCache.ChunkProvider as ChunkProviderGenerateWorld;
*
* foreach (long key in hashSetLong)
* {
* if (!chunkProviderGenerateWorld.GenerateSingleChunk(chunkCache, key, true))
* {
* clientInfo.SendPackage(NetPackageManager.GetPackage<NetPackageChat>().Setup(EChatType.Whisper, _senderId, string.Format("Failed regenerating chunk at position {0}/{1}", WorldChunkCache.extractX(key) << 4, WorldChunkCache.extractZ(key) << 4), null, false, null));
* }
* }
*
* world.m_ChunkManager.ResendChunksToClients(hashSetLong);
*
* if (pi != null)
* {
* pi.Reset(world);
* }
*
* clientInfo.SendPackage(NetPackageManager.GetPackage<NetPackageChat>().Setup(EChatType.Whisper, _senderId, "[44FF44]Reseted", null, false, null));
* return false;
* }
* else if (cmd[0] == "prot")
* {
* Vector3i l = GameManager.Instance.World.Players.dict[clientInfo.entityId].GetBlockPosition();
* Chunk c = (Chunk)GameManager.Instance.World.GetChunkFromWorldPos(l);
*
* if (cmd.Length < 2)
* {
* if (c.IsAnyTraderArea())
* {
* clientInfo.SendPackage(NetPackageManager.GetPackage<NetPackageChat>().Setup(EChatType.Whisper, _senderId, string.Format("[F012BE]Pos [FFDC00]X:[F012BE] {0}, [FFDC00]Z:[F012BE] {1}, [01FF70]Protected", l.x, l.z), null, false, null));
* }
* else
* {
* clientInfo.SendPackage(NetPackageManager.GetPackage<NetPackageChat>().Setup(EChatType.Whisper, _senderId, string.Format("[F012BE]Pos [FFDC00]X:[F012BE] {0}, [FFDC00]Z:[F012BE] {1}, [FF4136]Unprotected", l.x, l.z), null, false, null));
*
* }
*
* return false;
* }
*
* bool enable = true;
* try
* {
* enable = bool.Parse(cmd[1]);
* }
* catch (Exception) { }
*
* for (int x = 0; x < 16; x++)
* {
* for (int z = 0; z < 16; z++)
* {
* c.SetTraderArea(x, z, enable);
* }
* }
*
* //int x = l.x & 0xF;
* //int z = l.z & 0xF;
*
* if (enable)
* clientInfo.SendPackage(NetPackageManager.GetPackage<NetPackageChat>().Setup(EChatType.Whisper, _senderId, string.Format("[F012BE]Pos [FFDC00]X:[F012BE] {0}, [FFDC00]Z:[F012BE] {1}, [01FF70]Enabled", l.x, l.z), null, false, null));
* else
* clientInfo.SendPackage(NetPackageManager.GetPackage<NetPackageChat>().Setup(EChatType.Whisper, _senderId, string.Format("[F012BE]Pos [FFDC00]X:[F012BE] {0}, [FFDC00]Z:[F012BE] {1}, [FF4136]Disabled", l.x, l.z), null, false, null));
*
* //clientInfo.SendPackage(NetPackageManager.GetPackage<NetPackageChat>().Setup(EChatType.Whisper, _senderId, string.Format("[4444FF]Chunk X: {0}, Z: {1}", c.GetWorldPos().x, c.GetWorldPos().z), null, false, null));
*
* //clientInfo.SendPackage(NetPackageManager.GetPackage<NetPackageChat>().Setup(EChatType.Whisper, _senderId, string.Format("[44FF44]Done X: {0}, Z: {1}, Rel: {2}, {3}", c.GetBlockWorldPosX(x), c.GetBlockWorldPosZ(z), x, z), null, false, null));
* foreach (var cl in ConnectionManager.Instance.Clients.List)
* {
* cl.SendPackage(NetPackageManager.GetPackage<NetPackageChunk>().Setup(c, true));
* }
* }
* else if (cmd[0] == "start")
* {
* World world = GameManager.Instance.World;
* HashSet<int> playersToSplit = new HashSet<int>();
* foreach (EntityPlayer entityPlayer in world.Players.list)
* {
* playersToSplit.Add(entityPlayer.entityId);
* }
*
* int count = 2;
*
* try
* {
* count = int.Parse(cmd[1]);
* }
* catch (Exception) { }
*
* TeamMaker.SplitPlayers(playersToSplit, count);
*
* Configs.selectedMap = cmd[1].Trim();
*
* Configs.Map map = Configs.Maps[Configs.selectedMap];
*
* int tIndex = 0;
* foreach (string teamName in TeamMaker.teams.Keys)
* {
* HashSet<int> team = TeamMaker.teams[teamName];
*
* Vector3 destination = map.spawnsForTeams[tIndex++];
* PrefabInstance pi = GameManager.Instance.World.GetPOIAtPosition(destination);
*
* //foreach (int member in team)
* //{
* //TeamMaker.AddEnemyMarker(teamName, destination);
* //}
*
* if (cmd.Length == 1)
* {
* if (pi == null)
* {
* clientInfo.SendPackage(NetPackageManager.GetPackage<NetPackageChat>().Setup(EChatType.Whisper, _senderId, "[FF0000]No POI found!", null, false, null));
* return false;
* }
*
* clientInfo.SendPackage(NetPackageManager.GetPackage<NetPackageChat>().Setup(EChatType.Whisper, _senderId, "[FFCC00]POI: [DDDDDD]" + pi.name, null, false, null));
* return false;
* }
*
* int num = World.toChunkXZ((int)destination.x) - 1;
* int num2 = World.toChunkXZ((int)destination.z) - 1;
* int num3 = num + 2;
* int num4 = num2 + 2;
*
* HashSetLong hashSetLong = new HashSetLong();
* for (int k = num; k <= num3; k++)
* {
* for (int l2 = num2; l2 <= num4; l2++)
* {
* hashSetLong.Add(WorldChunkCache.MakeChunkKey(k, l2));
* }
* }
*
* ChunkCluster chunkCache = world.ChunkCache;
* ChunkProviderGenerateWorld chunkProviderGenerateWorld = world.ChunkCache.ChunkProvider as ChunkProviderGenerateWorld;
*
* foreach (long key in hashSetLong)
* {
* if (!chunkProviderGenerateWorld.GenerateSingleChunk(chunkCache, key, true))
* {
* //clientInfo.SendPackage(NetPackageManager.GetPackage<NetPackageChat>().Setup(EChatType.Whisper, _senderId, string.Format("Failed regenerating chunk at position {0}/{1}", WorldChunkCache.extractX(key) << 4, WorldChunkCache.extractZ(key) << 4), null, false, null));
* }
* }
*
* world.m_ChunkManager.ResendChunksToClients(hashSetLong);
*
* if (pi != null)
* {
* pi.Reset(world);
* }
*
* foreach (int player in team)
* {
* ClientInfo ci = ConnectionManager.Instance.Clients.ForEntityId(player);
*
* string pId = clientInfo.playerId;
*
* string className = "tank";
*
* if (Configs.PlayerClasses.ContainsKey(pId))
* {
* className = Configs.PlayerClasses[pId];
* }
*
* Configs.GiveClassItems(ci, className);
*
* ci.SendPackage(NetPackageManager.GetPackage<NetPackageTeleportPlayer>().Setup(destination, null, false));
* }
* }
* }
* else if (cmd[0] == "eq")
* {
* World world = GameManager.Instance.World;
* //LocalPlayerUI uiforPlayer = LocalPlayerUI.GetUIForPlayer(world.GetEntity(clientInfo.entityId) as EntityPlayerLocal);
*
* EntityPlayer player = world.Players.dict[clientInfo.entityId];
*
* GameManager.Instance.TEAccessClient(player.clientEntityId, player.serverPos, -1, player.entityId);
*
* /*EntityTrader entityTrader = null;
*
* foreach (Entity e in GameManager.Instance.World.Entities.list)
* {
* if (e.GetType() == typeof(EntityTrader))
* {
* entityTrader = (EntityTrader)e;
* break;
* }
* }
*
* uiforPlayer.xui.Trader.TraderTileEntity = entityTrader.TileEntityTrader;
* uiforPlayer.xui.Trader.Trader = entityTrader.TraderData;
*
* GameManager.Instance.traderManager.TraderInventoryRequested(entityTrader.TraderData, clientInfo.entityId);
*
* uiforPlayer.windowManager.CloseAllOpenWindows(null, false);
* uiforPlayer.windowManager.Open("trader", true, false, true);
*
* //TraderData trader = new TraderData();
* //trader.TraderInfo.Init();
* //trader.TraderInfo.UseOpenHours = false;
* //trader.TraderInfo.AllowBuy = true;
* //trader.TraderInfo.AllowSell = false;
* //ItemValue itemValue = ItemClass.GetItem("gunAK47", true);
* //ItemStack itemStack = new ItemStack(itemValue, 1);
* //trader.AddToPrimaryInventory(itemStack, true);
*
* /** Object reference not set to an instance of an object. START *
* //GameManager.Instance.traderManager.TraderInventoryRequested(trader, clientInfo.entityId);
* /** Object reference not set to an instance of an object. STOP *
*
* /** I (as player) am at trader protected area during such operation (POI teleporter) *
* //foreach (Entity e in GameManager.Instance.World.Entities.list)
* //{
* // if (e.GetType() == typeof(EntityTrader))
* // {
* // TraderData traderData = ((EntityTrader)e).TraderData;
*
* /** Nothing happens, no errors *
* // GameManager.Instance.traderManager.TraderInventoryRequested(traderData, clientInfo.entityId);
*
* /** Have tried to found packet for such situation but this is the only one that makes any sense to me *
* // clientInfo.SendPackage(NetPackageManager.GetPackage<NetPackageNPCQuestList>().Setup(e.entityId, clientInfo.entityId));
* // break;
* // }
* //}
*
* //GameManager.Instance.World.GetEntity()
* //EntityTrader entityTrader = new EntityTrader();
* //GameManager.Instance.World.SpawnEntityInWorld(entityTrader);
* /*GameManager.Instance.World.SpawnEntityInWorld(entityTrader);
* TraderData trader = new TraderData();
* trader.TraderInfo.Init();
* trader.TraderInfo.UseOpenHours = false;
* trader.
* ItemValue itemValue = ItemClass.GetItem("gunAK47", true);
* ItemStack itemStack = new ItemStack(itemValue, 1);
* trader.AddToPrimaryInventory(itemStack, true);
* //GameManager.Instance.traderManager.TraderInventoryRequested(entityTrader.TraderData, clientInfo.entityId);
*
* /*trader.AvailableMoney = 0;
* trader.PrimaryInventory.Clear();
*
* ItemValue itemValue = ItemClass.GetItem("gunAK47", true);
* SdtdConsole.Instance.Output(string.Format("itemValue: {0}", itemValue == null));
* Log.Out(itemValue.ToString());
* ItemStack itemStack = new ItemStack(itemValue, 1);
* SdtdConsole.Instance.Output(string.Format("ItemStack: {0}", itemStack == null));
*
* //trader.PrimaryInventory.Add(itemStack);
* trader.AddToPrimaryInventory(itemStack, true);*
* //trader.TraderInfo.AllowBuy = true;
* //trader.TraderInfo.AllowBuy = false;
* //trader.TraderInfo.UseOpenHours = false;
*
* // clientInfo.SendPackage(NetPackageManager.GetPackage<NetPackageQuestGotoPoint>().Setup(clientInfo.playerId, ));
* //foreach (EntityPlayerLocal p in GameManager.Instance.World.GetLocalPlayers())
* //{
* // Log.Out(string.Format("LID: {0} == IID: {1}", p.belongsPlayerId, clientInfo.playerId));
* // GameManager.ShowTooltip(p, "Tomasz Hajto przejechał babe na pasach i nie siedzi.");
* //}
* }
* else if (cmd[0] == "pos")
* {
* if (cmd.Length < 2)
* {
* clientInfo.SendPackage(NetPackageManager.GetPackage<NetPackageChat>().Setup(EChatType.Whisper, _senderId, "[FFFF33]Ussage /pos (mapID/lobby/get) [enemy/team] [del index].", null, false, null));
* return false;
* }
*
* Vector3i l = GameManager.Instance.World.Players.dict[clientInfo.entityId].GetBlockPosition();
* string currentPos = string.Format("X: {0}, Y: {1}, Z: {2}", l.x, l.y, l.z);
*
* if (cmd[1] == "get")
* {
* clientInfo.SendPackage(NetPackageManager.GetPackage<NetPackageChat>().Setup(EChatType.Whisper, _senderId, "[85144b]You stupid c**t: [FF4136]" + currentPos, null, false, null));
* }
* else if (cmd[1] == "lobby")
* {
* Configs.LobbyPosition = new Vector3(l.x, l.y, l.z);
* clientInfo.SendPackage(NetPackageManager.GetPackage<NetPackageChat>().Setup(EChatType.Whisper, _senderId, "[DDDDDD]New lobby position: [FFCC00]" + currentPos, null, false, null));
* }
* else
* {
* string type = "team";
* if (cmd.Length >= 3)
* {
* type = cmd[2];
* }
*
* type = type.ToLower().Trim();
* string mapID = cmd[1].ToLower().Trim();
*
* if (cmd.Length > 3)
* {
* int index = int.Parse(cmd[3].Trim());
*
* if (!Configs.Maps.ContainsKey(mapID))
* {
* clientInfo.SendPackage(NetPackageManager.GetPackage<NetPackageChat>().Setup(EChatType.Whisper, _senderId, "[DDDDDD]Missing map: [FFCC00]" + mapID, null, false, null));
* return false;
* }
*
*
* Vector3 ll;
* if (type == "team")
* {
* ll = Configs.Maps[mapID].spawnsForTeams[index];
* Configs.Maps[mapID].spawnsForTeams.RemoveAt(index);
* }
* else
* {
* ll = Configs.Maps[mapID].spawnsForTeams[index];
* Configs.Maps[mapID].spawnsForEnemies.RemoveAt(index);
* }
*
*
* currentPos = string.Format("X: {0}, Y: {1}, Z: {2}", ll.x, ll.y, ll.z);
*
* clientInfo.SendPackage(NetPackageManager.GetPackage<NetPackageChat>().Setup(EChatType.Whisper, _senderId, "[DDDDDD]Removed spawn ([FFCC00]" + type + "[DDDDDD]) for map [FFCC00]" + mapID + "[DDDDDD] with position [FFCC00]" + currentPos, null, false, null));
* Configs.Save();
* return false;
* }
*
* if (!Configs.Maps.ContainsKey(mapID))
* {
* clientInfo.SendPackage(NetPackageManager.GetPackage<NetPackageChat>().Setup(EChatType.Whisper, _senderId, "[DDDDDD]New map: [FFCC00]" + mapID, null, false, null));
* Configs.Maps.Add(mapID, new Configs.Map(mapID));
* }
*
* if (type == "team")
* {
* Configs.Maps[mapID].spawnsForTeams.Add(l.ToVector3());
* }
* else
* {
* Configs.Maps[mapID].spawnsForEnemies.Add(l.ToVector3());
* }
*
* Configs.Save();
* clientInfo.SendPackage(NetPackageManager.GetPackage<NetPackageChat>().Setup(EChatType.Whisper, _senderId, "[DDDDDD]Added spawn ([FFCC00]" + type + "[DDDDDD]) for map [FFCC00]" + mapID + "[DDDDDD] with position [FFCC00]" + currentPos, null, false, null));
* }
* }
* else if (cmd[0] == "give")
* {
* if (cmd.Length < 2)
* {
* clientInfo.SendPackage(NetPackageManager.GetPackage<NetPackageChat>().Setup(EChatType.Whisper, _senderId, "[FF3333] To few args.", null, false, null));
* return false;
* }
*
* ItemValue itemValue = new ItemValue(ItemClass.GetItem(cmd[1].Trim().ToLower(), true).type, 6, 6, true, null, 1);
* World world = GameManager.Instance.World;
* var entityItem = (EntityItem)EntityFactory.CreateEntity(new EntityCreationData
* {
* entityClass = EntityClass.FromString("item"),
* id = EntityFactory.nextEntityID++,
* itemStack = new ItemStack(itemValue, 1),
* pos = world.Players.dict[clientInfo.entityId].position,
* rot = new Vector3(20f, 0f, 20f),
* lifetime = 60f,
* belongsPlayerId = clientInfo.entityId
* });
*
* if (entityItem == null)
* {
* clientInfo.SendPackage(NetPackageManager.GetPackage<NetPackageChat>().Setup(EChatType.Whisper, _senderId, "[FF3333] You are wrong :c", null, false, null));
* return false;
* }
*
* world.SpawnEntityInWorld(entityItem);
* clientInfo.SendPackage(NetPackageManager.GetPackage<NetPackageEntityCollect>().Setup(entityItem.entityId, clientInfo.entityId));
* world.RemoveEntity(entityItem.entityId, EnumRemoveEntityReason.Despawned);
* }
* else
* {
* clientInfo.SendPackage(NetPackageManager.GetPackage<NetPackageChat>().Setup(EChatType.Whisper, _senderId, "[FF3333] Command unknown.", null, false, null));
* }
* return false;*/
}
}
// Returning true allows other listeners to process this message.
return(true);
}
public CommandEventArgs(ChatCommands cmd, string arg1, string arg2)
{
this.Command = cmd;
this.PrimaryArgument = arg1.Trim();
this.SecondaryArgument = arg2.Trim();
}
