public async Task DiceGame(SocketReaction reaction, IUserMessage _)
{
string[] d = data.Split(';');
//$"{coins};{streak}
int.TryParse(d[0], out int coins);
int.TryParse(d[1], out int streak);
int i = EUI.Dice(reaction.Emote.ToString());
if (i != -1)
{
await GamblingCommands.DiceGame_EvenOdd(player, reaction.Channel, i, coins, streak);
}
switch (reaction.Emote.ToString())
{
case EUI.cancel: await GameCommands.ShortStatsDisplay(player, reaction.Channel); break;
case EUI.prev: await GamblingCommands.DiceGame_EvenOdd(player, reaction.Channel, -1, Math.Max(coins - 10, 10), streak); break;
case EUI.next: await GamblingCommands.DiceGame_EvenOdd(player, reaction.Channel, -1, coins + 10, streak); break;
case EUI.two: await GamblingCommands.DiceGame_EvenOdd(player, reaction.Channel, -1, coins * 2, streak); break;
case EUI.five: await GamblingCommands.DiceGame_EvenOdd(player, reaction.Channel, -1, coins * 5, streak); break;
case EUI.zero: await GamblingCommands.DiceGame_EvenOdd(player, reaction.Channel, -1, coins * 10, streak); break;
}
}
// Use this for initialization
void Start () {
commandsScript = GetComponent<GameCommands> ();
cameraMovmentVector = transform.position;
float startXPos = thePlayer.transform.position.x + startXPosExtra;
float startYPos = thePlayer.transform.position.y + startYPosExtra;
Vector3 cameraStartPos = new Vector3 (startXPos, startYPos, transform.position.z);
transform.position = cameraStartPos;
//float timeToCatchUp = (startXPosExtra-ExtraXPos) / thePlayer.GetComponent<PlayerMovment> ().moveSpeed;
float timeToCatchUp = (startXPosExtra - ExtraXPos) / (thePlayer.GetComponent<PlayerMovment> ().moveSpeed - 3);
float ydistToTravel = startYPos - (thePlayer.transform.position.y + 5.1f);
startYSpeed = ydistToTravel / timeToCatchUp;
}
public override void Initialize()
{
base.Initialize();
GameCommands.CreateTchatCommand("Seek", "Seek <NomDuMonstre>", MonsterSeeker.HandleSeekCommand);
GameCommands.CreateTchatCommand("Stop", "Stop <NomDuMonstre>", MonsterSeeker.HandleStopCommand);
GameCommands.CreateTchatCommand("List", "List", MonsterSeeker.HandleListCommand);
}
public MainWindowViewModel()
{
Players = new ObservableCollection <Player>();
DealerCards = new ObservableCollection <Card>();
DealerStatus = new GameStatus();
_turnCommands = new TurnCommands();
_gameCommands = new GameCommands();
}
internal string GetInfo_MainSkills(string seperator = "| ")
{
return($"END:{stats.endurance}{GameCommands.SkillBuff(0, stats, null)}{seperator}" +
$"INT:{stats.intelligence}{GameCommands.SkillBuff(1, stats, null)}{seperator}" +
$"STR:{stats.strength}{GameCommands.SkillBuff(2, stats, null)}{seperator}" +
$"CHA:{stats.charisma}{GameCommands.SkillBuff(3, stats, null)}{seperator}" +
$"DEX:{stats.intelligence}{GameCommands.SkillBuff(4, stats, null)}{seperator}" +
$"PER:{stats.perception}{GameCommands.SkillBuff(5, stats, null)}{seperator}");
}
public async Task Skills(SocketReaction reaction, IUserMessage msg)
{
if (player.skillPoints > 0)
{
bool changes = true;
switch (reaction.Emote.ToString())
{
case "🇪":
player.stats.endurance++;
player.skillPoints--;
break;
case "🇮":
player.stats.intelligence++;
player.skillPoints--;
break;
case "🇸":
player.stats.strength++;
player.skillPoints--;
break;
case "🇨":
player.stats.charisma++;
player.skillPoints--;
break;
case "🇩":
player.stats.dexterity++;
player.skillPoints--;
break;
case "🇵":
player.stats.perception++;
player.skillPoints--;
break;
default:
changes = false;
break;
}
if (changes)
{
player.SaveFileMongo();
await TryMSGDel(msg);
if (player.skillPoints == 0)
{
await GameCommands.ViewXP(player, reaction.Channel);
}
else
{
await GameCommands.SkillUpgradePage(player, reaction.Channel);
}
}
}
}
internal static async Task AutoCharacter(Player player, IMessageChannel channel, bool ask)
{
if (ask)
{
EmbedBuilder em = DUtils.BuildEmbed("Character Creation",
$"{EUI.ok} - Randomize {Environment.NewLine} {EUI.next} - Manual (Advanced)"
+ Environment.NewLine + Environment.NewLine + $"{EUI.info} - More Info", null, default);
await player.NewUI(null, em.Build(), channel, MsgType.AutoNewCharacter);
}
else
{
int[] rolls = GetRolls();
var s = player.stats;
s.endurance = rolls[0];
s.intelligence = rolls[1];
s.strength = rolls[2];
s.charisma = rolls[3];
s.dexterity = rolls[4];
s.perception = rolls[5];
//
player.abilities.Add(Ability.Load("Strike"));
player.abilities.Add(Ability.Load("Shelter"));
//
player.race = Utils.RandomElement <ReferenceData.HumanoidRaces>();
switch (player.race)
{
case ReferenceData.HumanoidRaces.Human:
player.perks.Add(PerkLoad.Load("Human Adaptation"));
break;
case ReferenceData.HumanoidRaces.Tsiun:
player.perks.Add(PerkLoad.Load("Tsiun Trickery"));
break;
case ReferenceData.HumanoidRaces.Uskavian:
player.perks.Add(PerkLoad.Load("Uskavian Learning"));
break;
case ReferenceData.HumanoidRaces.Miganan:
player.perks.Add(PerkLoad.Load("Migana Skin"));
break;
case ReferenceData.HumanoidRaces.Ireskian:
player.perks.Add(PerkLoad.Load("Ireskian Talent"));
break;
}
//
player.level = 0;
player.health = player.Health();
player.stamina = player.Stamina();
player.SaveFileMongo();
await GameCommands.StatsDisplay(player, channel);
await channel.SendMessageAsync("Welcome to Neitsillia, Traveler. To guide you, you've been given the \"Tutorial\" Quest line."
+ Environment.NewLine + "Use the `Quest` command to view your quest list and inspect the quest using the assigned emote. Follow the Tutorial quest to learn to play.");
}
}
/// <summary>
/// Handles the command packet (chats that start with "::").
/// </summary>
/// <param name="character">The character to handle packet for.</param>
/// <param name="packet">The packet containing handle data.</param>
public void Handle(Character character, Packet packet)
{
// Split up given string to command.
string[] arguments = packet.ReadString().Split(' ');
string command = arguments[0].ToLower();
// Handle the command.
GameCommands.Handle(character, command, arguments);
}
public NetInformation(GameStatus estado, GameCommands _comando, double id, double x, double y)
{
enviadoId = id;
contentOfEnviado = null;
comando = _comando;
_gamesStatus = estado;
vectorX = x;
vectorY = y;
height = -1;
width = -1;
colok = colores.black;
}
public NetInformation(GameStatus _estado, GameCommands _comando, double ID, string Content, double x, double y, double w, double h, colores col)
{
enviadoId = ID;
vectorX = x;
vectorY = y;
height = h;
width = w;
contentOfEnviado = Content;
comando = _comando;
_gamesStatus = _estado;
colok = col;
}
public NetInformation(GameStatus estado, GameCommands _comando, double id, string content)
{
enviadoId = id;
contentOfEnviado = content;
comando = _comando;
_gamesStatus = estado;
width = -1;
height = -1;
vectorX = -1;
vectorY = -1;
colok = colores.black;
}
public NetInformation(GameStatus estado, GameCommands _comando)
{
_gamesStatus = estado;
comando = _comando;
enviadoId = -1;
width = -1;
height = -1;
vectorX = -1;
vectorY = -1;
contentOfEnviado = null;
colok = colores.black;
}
public void SendCallResponse(string user, string name, CallResponse response, bool callChanged)
{
bool unnamed = string.IsNullOrEmpty(name);
if (response == CallResponse.AlreadyCalled)
{
IRCConnection.SendMessageFormat("@{0}, you already called!", user);
return;
}
else if (response == CallResponse.NotEnoughCalls)
{
if (callChanged)
{
IRCConnection.SendMessageFormat("@{0}, your call has been updated to {1}.", user, unnamed ? "the next queued command" : name);
}
GameCommands.CallCountCommand();
return;
}
else if (response == CallResponse.UncommonCalls)
{
if (callChanged)
{
IRCConnection.SendMessageFormat("@{0}, your call has been updated to {1}. Uncommon calls still present.", user, unnamed ? "the next queued command" : name);
}
else
{
IRCConnection.SendMessageFormat("Sorry, uncommon calls were made. Please either correct your call(s) or use “!callnow” followed by the correct command to call.");
GameCommands.ListCalledPlayers();
}
return;
}
else if (response == CallResponse.DifferentName)
{
CommandQueueItem call = CommandQueue.Find(item => item.Message.Text.StartsWith(name));
IRCConnection.SendMessageFormat("@{0}, module {1} is queued with the name “{2}”, please use “!call {2}” to call it.", user, name, call.Name);
return;
}
else
{
unnamed = string.IsNullOrEmpty(commandToCall);
if (callWaiting)
{
IRCConnection.SendMessageFormat("Waiting for {0} to be queued.", unnamed ? "the next unnamed queued command" : commandToCall.StartsWith("!") ? "module " + commandToCall : "the command named “" + commandToCall + "”");
}
else
{
IRCConnection.SendMessageFormat("No {0} in the queue. Calling {1} when it is queued.", unnamed ? "unnamed commands" : commandToCall.StartsWith("!") ? "command for module " + commandToCall : "command named “" + commandToCall + "”", unnamed ? "the next unnamed queued command" : commandToCall.StartsWith("!") ? "module " + commandToCall : "the command named “" + commandToCall + "”");
callWaiting = true;
}
}
}
public async Task Adventure(SocketReaction reaction, IUserMessage msg)
{
string e = reaction.Emote.ToString();
int i = EUI.GetNum(e);
if (i > -1)
{
if (data[0] == 'Q') //Select a quest
{
await Adventures.Adventure.SelectIntensity(player, reaction.Channel, i);
}
else //Select difficulty
{
int.TryParse(data, out int quest);
await Adventures.Adventure.StartAdventure(player, Channel,
((Adventures.Adventure.Intensity[])Enum.GetValues(typeof(Adventures.Adventure.Intensity)))[i - 1],
quest > 0?Adventures.Adventure.currentQuests[quest - 1] : null);
}
return;
}
switch (e)
{
case EUI.ok:
await Adventures.Adventure.SelectIntensity(player, reaction.Channel, 0);
break;
case EUI.sideQuest:
await Adventures.Adventure.SelectQuest(player, reaction.Channel);
break;
case EUI.cycle:
await player.Adventure.Display(player, reaction.Channel, true);
break;
case EUI.cancel:
if (player.IsInAdventure)
{
await player.Adventure.End(player, reaction.Channel, true);
}
else
{
await GameCommands.StatsDisplay(player, reaction.Channel);
}
break;
}
}
public async Task XP(SocketReaction reaction, IUserMessage msg)
{
switch (reaction.Emote.ToString())
{
case skills:
await GameCommands.SkillUpgradePage(player, reaction.Channel);
break;
case pickSpec:
await Specialization.Specialization.SpecializationChoice(player, reaction.Channel);
break;
}
}
public void HandleMessageContents()
{
if (gMessage == null)
return;
if (!Util.GetInstance().DebuggingOn)
return;
var message = gMessage.ToLower();
gMessage = null;
int countToSpawn = 0;
int sizeFlags = 0;
if (message.Contains("help"))
{
Util.GetInstance().Log("[ChatMessageHandler.HandleMessageContents] Displaying Help");
DisplayGameCommands();
return;
}
if (message.Contains("on"))
{
_status = GameCommands.On;
Util.GetInstance().Log("[ChatMessageHandler.HandleMessageContents] Setting game Mode On");
return;
}
if (message.Contains("off"))
{
_status = GameCommands.Off;
Util.GetInstance().Log("[ChatMessageHandler.HandleMessageContents] Setting game Mode Off");
return;
}
if (message.Contains("clear"))
{
_status = GameCommands.Clearing;
Util.GetInstance().Log("[ChatMessageHandler.HandleMessageContents] Setting game Mode Clearing");
return;
}
if (message.Contains("report"))
{
_status = GameCommands.Reporting;
Util.GetInstance().Log("[ChatMessageHandler.HandleMessageContents] Setting game Mode Reporting");
return;
}
}
public async Task Schems(SocketReaction reaction, IUserMessage msg)
{
int.TryParse(data, out int page);
switch (reaction.Emote.ToString())
{
case next:
await GameCommands.ViewSchems(player, reaction.Channel, page + 1);
break;
case prev:
await GameCommands.ViewSchems(player, reaction.Channel, page - 1);
break;
}
}
public IGameCommand Decode(string gameUpdate)
{
string commandData = gameUpdate.Substring(0, 3);
string playerIdData = gameUpdate.Substring(3, 36);
string mainData = gameUpdate.Substring(39, gameUpdate.Length - 39);
GameCommands command = GetCommand(commandData);
IGameCommand gameCommand = new GameCommand
{
Command = command,
Data = ProcessData(command, playerIdData, mainData, null)
};
return(gameCommand);
}
public void HandleMessageContents()
{
if (gMessage == null)
{
return;
}
var message = gMessage.ToLower();
gMessage = null;
int countToSpawn = 0;
int sizeFlags = 0;
if (message.Contains("help"))
{
Util.GetInstance().Log("[ChatMessageHandler.HandleMessageContents] Displaying Help");
DisplayGameCommands();
return;
}
if (message.Contains("on"))
{
_status = GameCommands.On;
Util.GetInstance().Log("[ChatMessageHandler.HandleMessageContents] Setting game Mode On");
return;
}
if (message.Contains("off"))
{
_status = GameCommands.Off;
Util.GetInstance().Log("[ChatMessageHandler.HandleMessageContents] Setting game Mode Off");
return;
}
if (!Util.GetInstance().DebuggingOn)
{
return;
}
if (message.Contains("clear"))
{
_status = GameCommands.Clearing;
Util.GetInstance().Log("[ChatMessageHandler.HandleMessageContents] Setting game Mode Clearing");
return;
}
}
public IGameCommand Decode(IGameUpdate gameUpdate)
{
//002x7000000-0040-0000-0000-000000005555x1000y7899
string commandData = gameUpdate.GameState.Substring(0, 3); //002
string playerIdData = gameUpdate.GameState.Substring(3, 36); //x7000000-0040-0000-0000-000000005555
string mainData = gameUpdate.GameState.Substring(39, gameUpdate.GameState.Length - 39); //10007899
GameCommands command = GetCommand(commandData);
IGameCommand gameCommand = new GameCommand
{
Command = command,
Data = ProcessData(command, playerIdData, mainData, gameUpdate.IPAddress)
};
return(gameCommand);
}
internal static async Task EndRest(Player player, ISocketMessageChannel chan)
{
if (player.IsResting)
{
EmbedBuilder rest = new EmbedBuilder();
DateTime restDateTime = player.userTimers.restTime;
if ((player.ui != null && (player.ui.type == MsgType.Rest || player.ui.type == MsgType.EndRest) &&
player.ui.data != null && player.ui.data != ""))
{
string jsonTime = player.ui.data;
restDateTime = JsonConvert.DeserializeObject <DateTime>(jsonTime);
}
TimeSpan restTime = (DateTime.UtcNow - restDateTime);
if (player.Party != null)
{
foreach (PartyMember m in player.Party.members)
{
Player p = m.id == player.userid ? player : m.LoadPlayer();
rest.AddField(RestRecover(p, restTime.TotalSeconds));
p.userTimers.EndRest();
p.SaveFileMongo();
}
foreach (NPCSystems.NPC n in player.Party.NPCMembers)
{
rest.AddField(RestRecover(n, restTime.TotalSeconds));
}
await player.Party.SaveData();
}
else
{
rest.AddField(RestRecover(player, restTime.TotalSeconds));
player.userTimers.EndRest();
}
await player.NewUI(await chan.SendMessageAsync(embed: rest.Build()), MsgType.Main);
}
else
{
await GameCommands.ShortStatsDisplay(player, chan);
}
}
public override void UpdateBeforeSimulation()
{
if (!MyAPIGateway.Multiplayer.IsServer)
{
return;
}
if (MyAPIGateway.Session == null)
{
return;
}
try
{
GameCommands status = cHandle.GetStatus();
cHandle.HandleMessageContents();
if (_ticks % saveRate == 0)
{
Util.SaveLogs();
}
if (cHandle.GetStatus() == GameCommands.On)
{
Run();
}
else if (cHandle.GetStatus() == GameCommands.Off)
{
manager.StopAllDrones();
}
else if (cHandle.GetStatus() == GameCommands.Clearing)
{
manager.ClearAllDrones();
cHandle.SetStatus(GameCommands.On);
}
_ticks++;
}
catch (Exception e)
{
Util.GetInstance().LogError(e.ToString());
}
}
public async Task StarterAbilities(SocketReaction reaction, IUserMessage msg)
{
string[] split = data.Split('/');
int p = int.Parse(split[0]);
int x = int.Parse(split[1]);
int z = int.Parse(split[2]);
int index = GetNum(reaction.Emote.ToString());
if (index > -1)
{
Ability a = Ability.Load(LoadAbility.Starters[p, index]);
if (player.abilities.Count < 3)
{
player.abilities.Add(a);
}
if (x > -1)
{
string prefix = CommandHandler.GetPrefix(reaction.Channel);
player.level = 0;
await EditMessage("Character creation completed");
await GameCommands.StatsDisplay(player, reaction.Channel);
await reaction.Channel.SendMessageAsync("Welcome to Neitsillia, Traveler. To guide you, you've been given the \"Tutorial\" Quest line."
+ Environment.NewLine + "Use the `Quest` command to view your quest list and inspect the quest using the assigned emote. Follow the Tutorial quest to learn to play.");
}
else
{
await CharacterCommands.StarterAbilities(player, reaction.Channel, p);
}
player.SaveFileMongo();
}
else if (reaction.Emote.ToString() == next)
{
await CharacterCommands.StarterAbilities(player, reaction.Channel, p + 1, x, z);
}
else if (reaction.Emote.ToString() == prev)
{
await CharacterCommands.StarterAbilities(player, reaction.Channel, p - 1, x, z);
}
}
public void CallUpdate(bool response)
{
var callResponse = CheckIfCall(true, false, "", commandToCall, out _);
if (callResponse == CallResponse.Success)
{
GameCommands.CallQueuedCommand("", false, true, commandToCall);
}
else if (callResponse == CallResponse.NotPresent)
{
IRCConnection.SendMessageFormat("Waiting for {0} to be queued.", string.IsNullOrEmpty(commandToCall) ? "the next unnamed queued command" : commandToCall.StartsWith("!") ? "module " + commandToCall : "the command named “" + commandToCall + "”");
}
else
{
callWaiting = false;
}
if (response)
{
GameCommands.CallCountCommand();
}
}
public static void WorldServerNormalChat(NetState netState, PacketReader packetReader)
{
LOGs.WriteLine(LogMessageType.MSG_NONE, " WorldServerNormalChat(...)");
WorldServerExtendData l_ExtendData = netState.ExtendData as WorldServerExtendData;
if (l_ExtendData == null)
{
Debug.WriteLine("WorldPacketHandlers.WorldServerNormalChat(...) - l_ExtendData == null error!");
return;
}
if (l_ExtendData.ROSEMobile.IsLoggedIn == false)
{
Debug.WriteLine("WorldPacketHandlers.WorldServerNormalChat(...) - l_ExtendData.m_bIsLoggedIn == true error!");
return;
}
if (packetReader.Size < 7 /*( 6 + ?)*/)
{
Debug.WriteLine("WorldPacketHandlers.WorldServerStopChar(...) - packetReader.Size < 7 error!");
return;
}
string l_strNormalChat = packetReader.ReadStringSafe();
LOGs.WriteLine(LogMessageType.MSG_NONE, l_strNormalChat);
BaseGameCommand l_GameCommand = GameCommands.GetGameCommand(l_strNormalChat);
if (l_GameCommand != null)
{
l_GameCommand.OnEventGameCommand(netState);
}
else
{
netState.Send(new NormalChatAck(l_ExtendData.ROSEMobile, l_strNormalChat));
}
}
private Tuple <Guid, object> ProcessData(GameCommands command, string playerIdData, string mainData, string IPAddress)
{
switch (command)
{
case GameCommands.None:
break;
case GameCommands.Login:
_gameState.PlayersLoggedIn.AddOrUpdate(Guid.Parse(playerIdData), IPAddress, (key, oldvalue) => IPAddress);
return(new Tuple <Guid, object>(Guid.Parse(playerIdData), IPAddress));
case GameCommands.Position:
PlayerCoordinates playerCoordinates = new PlayerCoordinates()
{
X = uint.Parse(mainData.Substring(0, 4)),
Y = uint.Parse(mainData.Substring(4, 4)),
};
_gameState.PlayerCoordinates.AddOrUpdate(Guid.Parse(playerIdData), playerCoordinates, (key, oldvalue) => playerCoordinates);
return(new Tuple <Guid, object>(Guid.Parse(playerIdData), playerCoordinates));
}
return(null);
}
public async Task Click(SocketReaction reaction, IUserMessage msg, Player argplayer)
{
this.player = argplayer;
this._channel = reaction.Channel;
this.message = msg;
switch (reaction.Emote.ToString())
{
case inv:
await GameCommands.DisplayInventory(player, reaction.Channel, 0);
break;
case sheet:
await GameCommands.SheetDisplay(player, reaction.Channel);
break;
case xp:
await GameCommands.ViewXP(player, reaction.Channel);
break;
case explore:
await Commands.Areas.Exploration(player, reaction.Channel);
break;
case tpost:
await Commands.Areas.ViewJunctions(player, reaction.Channel, 0);
break;
case ability:
await GameCommands.Abilities(player, reaction.Channel);
break;
case enterFloor:
await EnterFloor(null, reaction.Channel);
break;
case loot:
{
if (type == MsgType.Loot)
{
await Loot(reaction, msg);
}
else
{
int.TryParse(data, out int page);
await InventoryCommands.Inventory.ViewLoot(player, reaction.Channel, page);
}
} break;
case schem:
await GameCommands.ViewSchems(player, reaction.Channel);
break;
case stats:
await GameCommands.ShortStatsDisplay(player, reaction.Channel);
break;
default:
await Click2(reaction, msg);
break;
}
}
public async Task Inventory(SocketReaction reaction, IUserMessage msg)
{
(int i, string filter) = InventoryControls(reaction);
await GameCommands.DisplayInventory(player, reaction.Channel, i, filter, true);
}
public void SetStatus(GameCommands val)
{
_status = val;
}
// Use this for initialization
void Start () {
commandsScript = gameCommandsObject.GetComponent<GameCommands> ();
}
// Use this for initialization
void Start () {
CommandScript = transform.parent.GetComponent<GameCommands> ();
}
public void SetStatus(GameCommands val)
{
_status = val;
}
// Use this for initialization
void Start () {
commandScript = Camera.main.GetComponent<GameCommands> ();
}
