public override void Execute(int userId, bool hasReceivedArguments, string arguments = "")
{
try
{
var s = arguments.Split(' ');
if (s.Length < 2)
{
ChatCommandManager.SendDebugMsgFormatted(DebugMsgType.SYNTAXERROR);
ShowSyntax();
return;
}
var opcode = Convert.ToByte(s[1], 16);
var packet = new Packet((PacketCmd)opcode);
for (var i = 2; i < s.Length; i++)
{
if (s[i].Equals("netid"))
{
packet.Write(_playerManager.GetPeerInfo(userId).Champion.NetId);
}
else
{
packet.Write(Convert.ToByte(s[i], 16));
}
}
_game.PacketNotifier.NotifyDebugPacket(userId, packet.GetBytes());
}
catch
{
// ignored
}
}
public override void Execute(Peer peer, bool hasReceivedArguments, string arguments = "")
{
PlayerManager _playerManager = Program.ResolveDependency <PlayerManager>();
var split = arguments.ToLower().Split(' ');
me = _playerManager.GetPeerInfo(peer).Champion;
owner = _owner;
if (split.Length > 1)
{
float.TryParse(split[1], out a);
}
if (split.Length > 2)
{
float.TryParse(split[2], out speed);
delay = (int)(speed * 1000);
}
run = !run;
if (run)
{
Task.Run(() => TaskRainbow());
}
}
public HandleChatBoxMessage(Game game)
{
_game = game;
_chatCommandManager = game.ChatCommandManager;
_playerManager = game.PlayerManager;
_logger = LoggerProvider.GetLogger();
}
public override void Execute(Peer peer, bool hasReceivedArguments, string arguments = "")
{
var msg = $"The new command added by {ChatCommandManager.CommandStarterCharacter}help has been executed";
ChatCommandManager.SendDebugMsgFormatted(DebugMsgType.INFO, msg);
ChatCommandManager.RemoveCommand(Command);
}
public override void Execute(Peer peer, bool hasReceivedArguments, string arguments = "")
{
var split = arguments.ToLower().Split(' ');
if (split.Length < 2)
{
ChatCommandManager.SendDebugMsgFormatted(DebugMsgType.SYNTAXERROR);
ShowSyntax();
}
else if (split[1] == "minions")
{
var objects = _game.ObjectManager.GetObjects();
foreach (var o in objects)
{
if (o.Value is Minion)
{
(o.Value as Minion).die(_playerManager.GetPeerInfo(peer).Champion); // :(
}
}
}
else
{
ChatCommandManager.SendDebugMsgFormatted(DebugMsgType.SYNTAXERROR);
ShowSyntax();
}
}
public override void Execute(int userId, bool hasReceivedArguments, string arguments = "")
{
var split = arguments.Split(' ');
if (split.Length < 2)
{
ChatCommandManager.SendDebugMsgFormatted(DebugMsgType.SYNTAXERROR);
ShowSyntax();
return;
}
var currentChampion = _playerManager.GetPeerInfo(userId).Champion;
var c = new Champion(
Game,
split[1],
(uint)_playerManager.GetPeerInfo(userId).UserId,
0, // Doesnt matter at this point
currentChampion.RuneList,
_playerManager.GetClientInfoByChampion(currentChampion),
currentChampion.NetId
);
c.SetPosition(
_playerManager.GetPeerInfo(userId).Champion.X,
_playerManager.GetPeerInfo(userId).Champion.Y
);
c.ChangeModel(split[1]); // trigger the "modelUpdate" proc
c.SetTeam(_playerManager.GetPeerInfo(userId).Champion.Team);
Game.ObjectManager.RemoveObject(_playerManager.GetPeerInfo(userId).Champion);
Game.ObjectManager.AddObject(c);
_playerManager.GetPeerInfo(userId).Champion = c;
}
public DebugParticlesCommand(ChatCommandManager chatCommandManager, Game game)
: base(chatCommandManager, game)
{
_logger = LoggerProvider.GetLogger();
_playerManager = game.PlayerManager;
_game = game;
}
public override void Execute(int userId, bool hasReceivedArguments, string arguments = "")
{
try
{
var s = arguments.Split(' ');
if (s.Length < 2)
{
ChatCommandManager.SendDebugMsgFormatted(DebugMsgType.SYNTAXERROR);
ShowSyntax();
return;
}
List <byte> _bytes = new List <byte>();
_bytes.Add(Convert.ToByte(s[1], 16));
for (var i = 2; i < s.Length; i++)
{
if (s[i].Equals("netid"))
{
_bytes.Add(Convert.ToByte(_playerManager.GetPeerInfo((ulong)userId).Champion.NetId));
}
else
{
_bytes.Add(Convert.ToByte(s[i], 16));
}
}
_game.PacketNotifier.NotifyDebugPacket(userId, _bytes.ToArray());
}
catch
{
// ignored
}
}
public CrewProgressionManager(MessageBroker aBroker, List <Account> accountList, CrewProgressionManagerSettings settings)
{
log(() => $"***INITIALIZE CPM");
broker = aBroker;
this.settings = settings;
ccm = new ChatCommandManager(generateInitialChatCommands());
this.verbose = settings.verbose;
log(() => $"***loading accounts: {Serializer.Serialize(accountList)}");
log(() => $"***settings: {Serializer.Serialize(settings)}");
this.accounts = new Dictionary <string, Account>();
accountList.ForEach(SaveAccount);
var playerIds = accountList
.Where(x => x.type == AccountType.Player)
.Select(x => int.Parse(x.id));
initializedPlayerIds = new HashSet <int>(playerIds);
log(() => $"***loaded with accounts: {Serializer.Serialize(this.accounts)}");
this.NextCheckin = aBroker.GameAPI.Game_GetTickTime();
CrewInfoTracker = new Dictionary <int, CrewInfo>();
actionManifest = new Dictionary <string, Action>()
{
{ "Normalize Players", SimpleUpdate },
{ "Update Points", UpdateWithPointIncrement },
{ "Evaluate Research Teams", updateCrewResearchTeams },
{ "Save Accounts", () => Account.SaveAccountListToFile(this.accounts.Values.ToList(), "Content/Mods/CPM/accounts.json") }
};
EventList = generateEventList(settings.actions);
}
public override void Execute(Peer peer, bool hasReceivedArguments, string arguments = "")
{
var split = arguments.ToLower().Split(' ');
if (split.Length < 2)
{
ChatCommandManager.SendDebugMsgFormatted(DebugMsgType.SYNTAXERROR);
ShowSyntax();
return;
}
int team;
if (!int.TryParse(split[1], out team))
{
return;
}
var units = _game.ObjectManager.GetObjects()
.Where(xx => xx.Value.Team == CustomConvert.ToTeamId(team))
.Where(xx => xx.Value is Minion || xx.Value is Monster);
foreach (var unit in units)
{
var ping = new AttentionPingRequest(unit.Value.X, unit.Value.Y, 0, Pings.Ping_Danger);
var client = _playerManager.GetPeerInfo(peer);
var response = new AttentionPingResponse(client, ping);
_game.PacketHandlerManager.broadcastPacketTeam(client.Team, response, Channel.CHL_S2C);
}
}
public override void Execute(Peer peer, bool hasReceivedArguments, string arguments = "")
{
try
{
var s = arguments.Split(' ');
if (s.Length < 2)
{
ChatCommandManager.SendDebugMsgFormatted(DebugMsgType.SYNTAXERROR);
ShowSyntax();
return;
}
var opcode = Convert.ToByte(s[1], 16);
var packet = new Packets.Packet((PacketCmd)opcode);
var buffer = packet.getBuffer();
for (int i = 2; i < s.Length; i++)
{
if (s[i] == "netid")
{
buffer.Write(_playerManager.GetPeerInfo(peer).Champion.NetId);
}
else
{
buffer.Write(Convert.ToByte(s[i], 16));
}
}
_game.PacketHandlerManager.sendPacket(peer, packet, Channel.CHL_S2C);
}
catch { }
}
public override void Execute(int userId, bool hasReceivedArguments, string arguments = "")
{
var split = arguments.ToLower().Split(' ');
if (split.Length < 2)
{
ChatCommandManager.SendDebugMsgFormatted(DebugMsgType.SYNTAXERROR);
ShowSyntax();
return;
}
if (!int.TryParse(split[1], out var team))
{
return;
}
var units = Game.ObjectManager.GetObjects()
.Where(xx => xx.Value.Team == team.ToTeamId())
.Where(xx => xx.Value is Minion || xx.Value is Monster);
var client = _playerManager.GetPeerInfo(userId);
foreach (var unit in units)
{
_game.PacketNotifier.NotifyPing(client, new Vector2(unit.Value.X, unit.Value.Y), 0, Pings.PING_DANGER);
}
}
public HandleChatBoxMessage(Game game, ChatCommandManager chatCommandManager, PlayerManager playerManager,
Logger logger)
{
_game = game;
_chatCommandManager = chatCommandManager;
_playerManager = playerManager;
_logger = logger;
}
public BotController(Bot _bot, ScopesManager _sManager, VotingManager _vManager, ChatCommandManager _ccm)
{
bot = _bot;
sManager = _sManager;
vManager = _vManager;
//userManager = _userManager;
ccm = _ccm;
}
public Game(ItemManager itemManager)
{
_logger = LoggerProvider.GetLogger();
ItemManager = itemManager;
ChatCommandManager = new ChatCommandManager(this);
NetworkIdManager = new NetworkIdManager();
PlayerManager = new PlayerManager(this);
ScriptEngine = new CSharpScriptEngine();
}
public override void Execute(int userId, bool hasReceivedArguments, string arguments = "")
{
var champion = _playerManager.GetPeerInfo(userId).Champion;
_logger.Debug($"At {champion.X}; {champion.Y}");
var msg = $"At Coords - X: {champion.X} Y: {champion.Y} Z: {champion.GetZ()}";
ChatCommandManager.SendDebugMsgFormatted(DebugMsgType.NORMAL, msg);
}
public Game(ItemManager itemManager, ChatCommandManager chatCommandManager, NetworkIdManager networkIdManager,
PlayerManager playerManager, Logger logger, IHandlersProvider handlersProvider)
{
_itemManager = itemManager;
_chatCommandManager = chatCommandManager;
_networkIdManager = networkIdManager;
_playerManager = playerManager;
_logger = logger;
_packetHandlerProvider = handlersProvider;
}
public ChatServer(IPAddress address, int port) : base(address, port)
{
SessionManager = new ChatSessionManager();
CommandManager = new ChatCommandManager();
ChannelManager = new ChatChannelManager();
//use this to add command into chatserver
CommandManager.Start();
ChannelManager.Start();
SessionManager.Start();
}
public bool TryDoCommand(Players.Player player, string chat, List <string> splits)
{
ChatCommandManager.GetCommandlist().TryGetValue(chat.Split(' ')[0], out BaseChatCommand command);
if (command != null)
{
return(command.TryDoCommand(player, chat, splits));
}
return(false);
}
public void AddCommandTest()
{
var chatboxManager = new ChatCommandManager(_game);
var command = new TestCommand(_game, chatboxManager, "ChatboxManagerTestsTestCommand", "");
var result = chatboxManager.AddCommand(command);
Assert.AreEqual(true, result);
result = chatboxManager.AddCommand(command);
Assert.AreEqual(false, result);
}
public void InitTest()
{
t1 = new ChatCommand("test", null);
t2 = new ChatCommand("test2", null);
commandList = commandList = new List <ChatCommand>()
{
t1,
t2
};
ccm = new ChatCommandManager(commandList);
}
public Game()
{
_logger = LoggerProvider.GetLogger();
ItemManager = new ItemManager();
ChatCommandManager = new ChatCommandManager(this);
NetworkIdManager = new NetworkIdManager();
PlayerManager = new PlayerManager(this);
ScriptEngine = new CSharpScriptEngine();
RequestHandler = new NetworkHandler <ICoreRequest>();
ResponseHandler = new NetworkHandler <ICoreResponse>();
}
public override void Execute(int userId, bool hasReceivedArguments, string arguments = "")
{
if (Game.LoadScripts())
{
ChatCommandManager.SendDebugMsgFormatted(DebugMsgType.INFO, "Scripts reloaded.");
}
else
{
ChatCommandManager.SendDebugMsgFormatted(DebugMsgType.INFO, "Scripts failed to reload.");
}
}
public void AddCommandTest()
{
var chatboxManager = new ChatCommandManager();
var command = new HelpCommand("ChatboxManagerTestsTestCommand", "", chatboxManager);
var result = chatboxManager.AddCommand(command);
Assert.AreEqual(true, result);
result = chatboxManager.AddCommand(command);
Assert.AreEqual(false, result);
}
public void testCommandWithArg()
{
var pattern = @"test (?<name>\S*) is (?<disposition>\S*)";
var cc = new ChatCommand(pattern, (x, y) => { });
commandList.Add(cc);
ccm = new ChatCommandManager(commandList);
var result = ccm.MatchCommand("test chris is good");
Assert.AreSame(cc, result.command);
}
public override void Execute(Peer peer, bool hasReceivedArguments, string arguments = "")
{
var champ = _playerManager.GetPeerInfo(peer).Champion;
if (!champ.IsDead)
{
ChatCommandManager.SendDebugMsgFormatted(DebugMsgType.INFO, "Your champion is already alive.");
return;
}
ChatCommandManager.SendDebugMsgFormatted(DebugMsgType.INFO, "Your champion has revived!");
champ.Respawn();
}
public override void Execute(int userId, bool hasReceivedArguments, string arguments = "")
{
List <Package> packageList = _contentManager.GetAllLoadedPackages();
string printedString = "Loaded packages:\n";
foreach (Package dataPackage in packageList)
{
printedString += $"- {dataPackage.PackageName}\n";
}
ChatCommandManager.SendDebugMsgFormatted(DebugMsgType.INFO, printedString);
}
public override void Execute(int userId, bool hasReceivedArguments, string arguments = "")
{
var split = arguments.ToLower().Split(' ');
if (split.Length < 2)
{
ChatCommandManager.SendDebugMsgFormatted(DebugMsgType.SYNTAXERROR);
ShowSyntax();
}
else if (float.TryParse(split[1], out var gold))
{
_playerManager.GetPeerInfo(userId).Champion.Stats.Gold += gold;
}
}
public override void Execute(int userId, bool hasReceivedArguments, string arguments = "")
{
var split = arguments.ToLower().Split(' ');
if (split.Length < 2 || !byte.TryParse(split[1], out var input) || input > 1)
{
ChatCommandManager.SendDebugMsgFormatted(DebugMsgType.SYNTAXERROR);
ShowSyntax();
}
else
{
Game.Map.MapProperties.SpawnEnabled = input != 0;
}
}
public override void Execute(int userId, bool hasReceivedArguments, string arguments = "")
{
var split = arguments.Split(' ');
if (split.Length >= 2)
{
_playerManager.GetPeerInfo(userId).Champion.ChangeModel(split[1]);
}
else
{
ChatCommandManager.SendDebugMsgFormatted(DebugMsgType.SYNTAXERROR);
ShowSyntax();
}
}
