private void HandleCommand(CommandAlias cmd, string username)
{
//direct commands for further use
switch (cmd.Command)
{
case TwitchCommand.notCommand:
return;
case TwitchCommand.differentGame:
return;
case TwitchCommand.invalid:
return;
case TwitchCommand.none:
return;
case TwitchCommand.walk:
goto case TwitchCommand.crouch;
case TwitchCommand.shoot:
goto case TwitchCommand.crouch;
case TwitchCommand.crouch:
PlayerManager.instance.OnPlayerAction(username, cmd);
break;
case TwitchCommand.join:
PlayerManager.instance.OnPlayerJoin(username);
break;
}
}
public static string Get(CommandAlias command, params object[] args)
{
if (!commands.ContainsKey(command))
{
throw new ArgumentException(string.Format("The command {0} does not exist", command));
}
return(string.Format(commands[command], args));
}
private void ResetAllActions(TwitchCommand cmd)
{
actionNumber = 0;
firstAction = new CommandAlias(cmd);
secondAction = new CommandAlias(cmd);
newFirstAction = new CommandAlias(cmd);
newSecondAction = new CommandAlias(cmd);
}
public AliasViewModel Clone()
{
var clonedAlias = new CommandAlias();
return(new AliasViewModel(AllGroups, AliasGroup, clonedAlias, _actionDescriptions)
{
ActionsViewModel = ActionsViewModel.Clone(clonedAlias.Actions),
Command = Command
});
}
/// <summary>
/// Sets incoming actions to correct perform order
/// </summary>
public void SetAction(CommandAlias action)
{
if (newFirstAction.Command == TwitchCommand.crouch || newFirstAction.Command == TwitchCommand.none || newFirstAction.Command == action.Command)
{
newFirstAction = action;
}
else if (newSecondAction.Command == TwitchCommand.crouch || newSecondAction.Command == TwitchCommand.none || newSecondAction.Command == action.Command)
{
newSecondAction = action;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AliasViewModel"/> class.
/// </summary>
/// <param name="allGroups">All groups.</param>
/// <param name="aliasGroup">The alias group.</param>
/// <param name="commandAlias">The alias.</param>
/// <param name="actionDescriptions">The action descriptions.</param>
public AliasViewModel([NotNull] IEnumerable <GroupViewModel> allGroups, [NotNull] GroupViewModel aliasGroup, [NotNull] CommandAlias commandAlias, [NotNull] IEnumerable <ActionDescription> actionDescriptions)
{
Assert.ArgumentNotNull(allGroups, "allGroups");
Assert.ArgumentNotNull(aliasGroup, "aliasGroup");
Assert.ArgumentNotNull(commandAlias, "commandAlias");
Assert.ArgumentNotNull(actionDescriptions, "actionDescriptions");
_aliasGroup = aliasGroup;
_actionDescriptions = actionDescriptions;
CommandAlias = commandAlias;
AllGroups = allGroups;
ActionsViewModel = new ActionsViewModel(commandAlias.Actions, actionDescriptions);
}
private void Walk(CommandAlias action)
{
//convert letter-number coordinate input from action.alias[0] to bytepair
BytePair coord = BytePair.StringListToCoordinates(action.Alias, GameManager.instance.MapHandler.MapHeight - 1, -1);
if (coord.x == 255 || coord.y == 255)
{
print("Invalid coordinate"); return;
}
TargetPosition = coord;
transferer.MoveTo(TargetPosition.ToPositionVector2());
}
/// <summary>
/// Handles incoming player action command
/// </summary>
public void OnPlayerAction(string username, CommandAlias action)
{
//Return if game isn't active
if (GameManager.instance.GameState.Phase != GamePhase.game)
{
return;
}
//Search for the same user in 'joinedPlayers'. If found, user is still in game, SetAction
for (int i = 0; i < joinedPlayers.Count; i++)
{
if (joinedPlayers[i].Username == username)
{
joinedPlayers[i].player.SetAction(action);
}
}
}
private void Shoot(CommandAlias action)
{
//convert letter-number coordinate input from action.alias[0] to bytepair
BytePair coord = BytePair.StringListToCoordinates(action.Alias, GameManager.instance.MapHandler.MapHeight - 1, -1);
if (coord.x == 255 || coord.y == 255)
{
print("Invalid coordinate"); return;
}
Snowball newBall = (Snowball)Pool.instance.GetFromPool("Assorted", "Snowball");
newBall.SetTargetAndShoot(this, coord);
newBall.Setup();
Act();
}
public override bool Equals(object obj)
{
if (obj == null)
{
return(false);
}
if (!(obj is ArduinoCommand))
{
return(false);
}
var cmd = (ArduinoCommand)obj;
if (!CommandAlias.Equals(cmd.CommandAlias, StringComparison.OrdinalIgnoreCase))
{
return(false);
}
if (Commands.Count != cmd.Commands.Count)
{
return(false);
}
for (int i = 0; i < Commands.Count; i++)
{
if (!Commands[i].Equals(cmd.Commands[i]))
{
return(false);
}
}
if (Arguments.Count != cmd.Arguments.Count)
{
return(false);
}
for (int i = 0; i < Arguments.Count; i++)
{
if (!Arguments[i].Equals(cmd.Arguments[i]))
{
return(false);
}
}
return(true);
}
private void DoAction(CommandAlias action)
{
switch (action.Command)
{
case TwitchCommand.walk:
Walk(action);
break;
case TwitchCommand.shoot:
Shoot(action);
break;
case TwitchCommand.crouch:
Crouch(action);
break;
case TwitchCommand.none:
Act();
break;
}
}
private void AddAliasCommandExecute([NotNull] object obj)
{
Assert.ArgumentNotNull(obj, "obj");
var commandAlias = new CommandAlias();
commandAlias.Actions.Add(new SendTextAction());
var aliasToAdd = new AliasViewModel(Groups, Groups.First(g => g.IsBuildIn), commandAlias, _actionDescriptions);
var aliasEditDialog = new AliasEditDialog {
DataContext = aliasToAdd, Owner = (Window)obj
};
aliasEditDialog.Show();
aliasEditDialog.Closed += (s, e) =>
{
if (aliasEditDialog.Save)
{
aliasToAdd.AliasGroup.AddAlias(aliasToAdd);
}
};
}
public AliasAttribute(CommandAlias alias)
{
Alias = alias;
}
public static Command Get(CommandAlias alias)
{
return(_commands[alias]);
}
public async Task Alias(string trigger, [Remainder] string mapping = null)
{
var channel = (ITextChannel)Context.Channel;
if (string.IsNullOrWhiteSpace(trigger))
{
return;
}
trigger = trigger.Trim().ToLowerInvariant();
if (string.IsNullOrWhiteSpace(mapping))
{
if (!_service.AliasMaps.TryGetValue(Context.Guild.Id, out var maps) ||
!maps.TryRemove(trigger, out _))
{
await ReplyErrorLocalized("alias_remove_fail", Format.Code(trigger)).ConfigureAwait(false);
return;
}
using (var uow = _db.UnitOfWork)
{
var config = uow.GuildConfigs.For(Context.Guild.Id, set => set.Include(x => x.CommandAliases));
var toAdd = new CommandAlias()
{
Mapping = mapping,
Trigger = trigger
};
config.CommandAliases.RemoveWhere(x => x.Trigger == trigger);
uow.Complete();
}
await ReplyConfirmLocalized("alias_removed", Format.Code(trigger)).ConfigureAwait(false);
return;
}
_service.AliasMaps.AddOrUpdate(Context.Guild.Id, (_) =>
{
using (var uow = _db.UnitOfWork)
{
var config = uow.GuildConfigs.For(Context.Guild.Id, set => set.Include(x => x.CommandAliases));
config.CommandAliases.Add(new CommandAlias()
{
Mapping = mapping,
Trigger = trigger
});
uow.Complete();
}
return(new ConcurrentDictionary <string, string>(new Dictionary <string, string>()
{
{ trigger.Trim().ToLowerInvariant(), mapping.ToLowerInvariant() },
}));
}, (_, map) =>
{
using (var uow = _db.UnitOfWork)
{
var config = uow.GuildConfigs.For(Context.Guild.Id, set => set.Include(x => x.CommandAliases));
var toAdd = new CommandAlias()
{
Mapping = mapping,
Trigger = trigger
};
config.CommandAliases.RemoveWhere(x => x.Trigger == trigger);
config.CommandAliases.Add(toAdd);
uow.Complete();
}
map.AddOrUpdate(trigger, mapping, (key, old) => mapping);
return(map);
});
await ReplyConfirmLocalized("alias_added", Format.Code(trigger), Format.Code(mapping)).ConfigureAwait(false);
}
public ProcessResult RunCommand(CommandAlias command)
{
return(RunCommand(Commands.Get(command)));
}
public async Task Alias(string trigger, [Leftover] string mapping = null)
{
var channel = (ITextChannel)ctx.Channel;
if (string.IsNullOrWhiteSpace(trigger))
{
return;
}
trigger = trigger.Trim().ToLowerInvariant();
if (string.IsNullOrWhiteSpace(mapping))
{
if (!_service.AliasMaps.TryGetValue(ctx.Guild.Id, out var maps) ||
!maps.TryRemove(trigger, out _))
{
await ReplyErrorLocalizedAsync("alias_remove_fail", Format.Code(trigger)).ConfigureAwait(false);
return;
}
using (var uow = _db.GetDbContext())
{
var config = uow.GuildConfigs.ForId(ctx.Guild.Id, set => set.Include(x => x.CommandAliases));
var toAdd = new CommandAlias()
{
Mapping = mapping,
Trigger = trigger
};
var tr = config.CommandAliases.FirstOrDefault(x => x.Trigger == trigger);
if (tr != null)
{
uow._context.Set <CommandAlias>().Remove(tr);
}
uow.SaveChanges();
}
await ReplyConfirmLocalizedAsync("alias_removed", Format.Code(trigger)).ConfigureAwait(false);
return;
}
_service.AliasMaps.AddOrUpdate(ctx.Guild.Id, (_) =>
{
using (var uow = _db.GetDbContext())
{
var config = uow.GuildConfigs.ForId(ctx.Guild.Id, set => set.Include(x => x.CommandAliases));
config.CommandAliases.Add(new CommandAlias()
{
Mapping = mapping,
Trigger = trigger
});
uow.SaveChanges();
}
return(new ConcurrentDictionary <string, string>(new Dictionary <string, string>()
{
{ trigger.Trim().ToLowerInvariant(), mapping.ToLowerInvariant() },
}));
}, (_, map) =>
{
using (var uow = _db.GetDbContext())
{
var config = uow.GuildConfigs.ForId(ctx.Guild.Id, set => set.Include(x => x.CommandAliases));
var toAdd = new CommandAlias()
{
Mapping = mapping,
Trigger = trigger
};
var toRemove = config.CommandAliases.Where(x => x.Trigger == trigger);
if (toRemove.Any())
{
uow._context.RemoveRange(toRemove.ToArray());
}
config.CommandAliases.Add(toAdd);
uow.SaveChanges();
}
map.AddOrUpdate(trigger, mapping, (key, old) => mapping);
return(map);
});
await ReplyConfirmLocalizedAsync("alias_added", Format.Code(trigger), Format.Code(mapping)).ConfigureAwait(false);
}
public CommandAlias(CommandAlias cmd)
{
Command = cmd.command;
Alias = new List <string>(cmd.alias);
}
/// <summary>
/// Sets new actions to be performed
/// </summary>
private void SetNewActionsActive()
{
firstAction = new CommandAlias(newFirstAction);
secondAction = new CommandAlias(newSecondAction);
}
private void Crouch(CommandAlias action)
{
IsCrouching = true;
Act();
}
