public override bool CanHappen(string msg, [NotNull] Viewer viewer)
{
if (!PurchaseHelper.TryGetPawn(viewer.username, out _pawn))
{
MessageHelper.ReplyToUser(viewer.username, "TKUtils.NoPawn".Localize());
return(false);
}
var worker = ArgWorker.CreateInstance(CommandFilter.Parse(msg).Skip(2));
if (!worker.TryGetNextAsItem(out _item) || !_item.IsValid())
{
MessageHelper.ReplyToUser(viewer.username, "TKUtils.InvalidItemQuery".LocalizeKeyed(worker.GetLast()));
return(false);
}
if (_item.TryGetError(out string error))
{
MessageHelper.ReplyToUser(viewer.username, error);
return(false);
}
if (!(_item.Thing.Thing is { IsWeapon : true }) || _item.Thing.ItemData?.IsEquippable != true)
public override bool CanHappen(string msg, [NotNull] Viewer viewer)
{
if (!PurchaseHelper.TryGetPawn(viewer.username, out _pawn))
{
MessageHelper.ReplyToUser(viewer.username, "TKUtils.NoPawn".Localize());
return(false);
}
var worker = ArgWorker.CreateInstance(CommandFilter.Parse(msg).Skip(2));
if (!worker.TryGetNextAsSkill(out SkillDef skillDef))
{
return(false);
}
_target = _pawn !.skills.skills.Where(s => !s.TotallyDisabled).FirstOrDefault(s => s.def.Equals(skillDef));
if (_target == null)
{
MessageHelper.ReplyToUser(viewer.username, "TKUtils.InvalidSkillQuery".LocalizeKeyed(worker.GetLast()));
return(false);
}
if ((int)_target.passion < 3)
{
return(true);
}
MessageHelper.ReplyToUser(viewer.username, "TKUtils.Passion.Full".Localize());
return(false);
}
public override void RunCommand([NotNull] ITwitchMessage twitchMessage)
{
if (!PurchaseHelper.TryGetPawn(twitchMessage.Username, out Pawn pawn))
{
twitchMessage.Reply("TKUtils.NoPawn".Localize());
return;
}
List <string> queries = CommandFilter.Parse(twitchMessage.Message).Skip(1).Select(PurchaseHelper.ToToolkit).ToList();
if (queries.Count <= 0)
{
queries.AddRange(DefaultStats);
}
List <StatDef> container = queries.Select(FindStat).Where(s => s != null).ToList();
if (container.Count <= 0)
{
return;
}
CommandRouter.MainThreadCommands.Enqueue(
() =>
{
MessageHelper.ReplyToUser(twitchMessage.Username, container.Select(s => FormatStat(pawn, s)).SectionJoin());
}
);
}
public override void RunCommand([NotNull] ITwitchMessage twitchMessage)
{
var worker = ArgWorker.CreateInstance(CommandFilter.Parse(twitchMessage.Message).Skip(1));
if (!worker.TryGetNextAsInt(out int amount, 1))
{
return;
}
List <string> viewers = Viewers.ParseViewersFromJsonAndFindActiveViewers();
if (viewers == null || viewers.Count <= 0)
{
return;
}
var count = 0;
foreach (string username in viewers)
{
Viewers.GetViewer(username).GiveViewerCoins(amount);
count++;
}
twitchMessage.Reply("TKUtils.GiveAll".LocalizeKeyed(amount.ToString("N0"), count.ToString("N0")));
}
public override void RunCommand([NotNull] ITwitchMessage twitchMessage)
{
var worker = ArgWorker.CreateInstance(CommandFilter.Parse(twitchMessage.Message).Skip(1));
string argument = worker.GetNext();
switch (argument.ToLowerInvariant())
{
case "accept":
ProcessAccept(twitchMessage.Username, worker.GetNextAsViewer());
return;
case "decline":
ProcessDecline(twitchMessage.Username, worker.GetNextAsViewer());
return;
default:
Viewer viewer = Viewers.All.Find(v => string.Equals(v.username, argument, StringComparison.InvariantCultureIgnoreCase));
if (viewer != null)
{
ProcessRequest(twitchMessage.Username, viewer);
}
else
{
MessageHelper.ReplyToUser(twitchMessage.Username, "TKUtils.InvalidViewerQuery".LocalizeKeyed(worker.GetLast()));
}
return;
}
}
public override void RunCommand([NotNull] ITwitchMessage message)
{
string code = CommandFilter.Parse(message.Message).Skip(1).FirstOrDefault();
if (code.NullOrEmpty())
{
return;
}
if (!Data.ColorIndex.TryGetValue(code !.ToLowerInvariant(), out Color color) && !ColorUtility.TryParseHtmlString(code, out color))
{
MessageHelper.ReplyToUser(message.Username, "TKUtils.NotAColor".LocalizeKeyed(code));
return;
}
if (!PurchaseHelper.TryGetPawn(message.Username, out Pawn pawn))
{
MessageHelper.ReplyToUser(message.Username, "TKUtils.NoPawn".Localize());
return;
}
pawn.story.favoriteColor = new Color(color.r, color.g, color.b, 1f);
message.Reply("TKUtils.FavoriteColor.Complete".Localize());
}
public override bool CanHappen(string msg, [NotNull] Viewer viewer)
{
if (!PurchaseHelper.TryGetPawn(viewer.username, out _pawn))
{
MessageHelper.ReplyToUser(viewer.username, "TKUtils.NoPawn".Localize());
return(false);
}
var worker = ArgWorker.CreateInstance(CommandFilter.Parse(msg).Skip(2));
if (!worker.TryGetNextAsTrait(out _thisShop) || !worker.TryGetNextAsTrait(out _thatShop))
{
MessageHelper.ReplyToUser(viewer.username, "TKUtils.InvalidTraitQuery".LocalizeKeyed(worker.GetLast()));
return(false);
}
if (!IsUsable(_thisShop, _thatShop))
{
MessageHelper.ReplyToUser(
viewer.username,
$"TKUtils.{(_thisShop.CanRemove ? "" : "Remove")}Trait.Disabled".LocalizeKeyed((_thisShop.CanRemove ? _thatShop : _thisShop).Name.CapitalizeFirst())
);
return(false);
}
if (TraitHelper.GetTotalTraits(_pawn) >= AddTraitSettings.maxTraits && WouldExceedLimit())
{
MessageHelper.ReplyToUser(viewer.username, "TKUtils.ReplaceTrait.Violation".LocalizeKeyed(_thisShop.Name, _thatShop.Name));
return(false);
}
if (!viewer.CanAfford(TotalPrice))
{
MessageHelper.ReplyToUser(viewer.username, "TKUtils.InsufficientBalance".LocalizeKeyed(TotalPrice.ToString("N0"), viewer.GetViewerCoins().ToString("N0")));
return(false);
}
if (!PassesCharacterCheck(viewer))
{
return(false);
}
if (!PassesModCheck(viewer))
{
return(false);
}
if (!PassesValidationCheck(viewer))
{
return(false);
}
return(true);
}
public override bool CanHappen(string msg, [NotNull] Viewer viewer)
{
if (CommandBase.GetOrFindPawn(viewer.username) != null)
{
MessageHelper.ReplyToUser(viewer.username, "TKUtils.HasPawn".Localize());
return(false);
}
_map = Helper.AnyPlayerMap;
if (_map == null)
{
MessageHelper.ReplyToUser(viewer.username, "TKUtils.NoMap".Localize());
return(false);
}
if (!CellFinder.TryFindRandomEdgeCellWith(p => _map.reachability.CanReachColony(p) && !p.Fogged(_map), _map, CellFinder.EdgeRoadChance_Neutral, out _loc))
{
TkUtils.Logger.Warn("No reachable location to spawn a viewer pawn!");
return(false);
}
GetDefaultKind();
if (!TkSettings.PurchasePawnKinds)
{
return(CanPurchaseRace(viewer, _pawnKindItem));
}
var worker = ArgWorker.CreateInstance(CommandFilter.Parse(msg).Skip(2));
if (!worker.TryGetNextAsPawn(out PawnKindItem temp) || _pawnKindItem?.ColonistKindDef == null)
{
if (worker.GetLast().NullOrEmpty())
{
return(CanPurchaseRace(viewer, _pawnKindItem !));
}
MessageHelper.ReplyToUser(viewer.username, "TKUtils.InvalidKindQuery".LocalizeKeyed(worker.GetLast()));
return(false);
}
_pawnKindItem = temp;
_kindDef = _pawnKindItem.ColonistKindDef;
if (_kindDef.RaceProps.Humanlike)
{
return(CanPurchaseRace(viewer, _pawnKindItem));
}
MessageHelper.ReplyToUser(viewer.username, "TKUtils.BuyPawn.Humanlike".Localize());
return(false);
}
public override void RunCommand([NotNull] ITwitchMessage twitchMessage)
{
string query = CommandFilter.Parse(twitchMessage.Message).Skip(1).FirstOrDefault();
ResearchProjectDef project;
if (query.NullOrEmpty())
{
project = Current.Game.researchManager.currentProj;
}
else
{
project = DefDatabase <ResearchProjectDef> .AllDefs.FirstOrDefault(
p => p.defName.EqualsIgnoreCase(query) || p.label.ToToolkit().EqualsIgnoreCase(query !.ToToolkit())
);
if (project == null)
{
ThingDef thing = DefDatabase <ThingDef> .AllDefs.FirstOrDefault(
t => t.defName.EqualsIgnoreCase(query) || t.label?.ToToolkit()?.EqualsIgnoreCase(query !.ToToolkit()) == true
);
project = thing?.recipeMaker?.researchPrerequisite;
project ??= thing?.recipeMaker?.researchPrerequisites?.FirstOrDefault(p => !p.IsFinished);
}
}
if (project == null)
{
twitchMessage.Reply(
(!query.NullOrEmpty() ? "TKUtils.Research.InvalidQuery".LocalizeKeyed(query) : "TKUtils.Research.None".Localize()).WithHeader("Research".Localize())
);
return;
}
var segments = new List <string> {
ResponseHelper.JoinPair(project.LabelCap, project.ProgressPercent.ToStringPercent())
};
if (project.prerequisites != null && !project.PrerequisitesCompleted)
{
List <ResearchProjectDef> prerequisites = project.prerequisites;
string[] container = prerequisites.Where(prerequisite => !prerequisite.IsFinished)
.Select(prerequisite => ResponseHelper.JoinPair(prerequisite.LabelCap, prerequisite.ProgressPercent.ToStringPercent()))
.ToArray();
segments.Add(ResponseHelper.JoinPair("ResearchPrerequisites".Localize(), container.SectionJoin()));
}
twitchMessage.Reply(segments.GroupedJoin().WithHeader("Research".Localize()));
}
public static ToolkitChatCommand GetChatCommand(string commandText)
{
string baseCommand = CommandFilter.Parse(commandText).FirstOrDefault();
if (baseCommand == null)
{
return(null);
}
return(DefDatabase <ToolkitChatCommand> .AllDefsListForReading.FirstOrDefault(
c => c.commandText.EqualsIgnoreCase(baseCommand)
));
}
public override void RunCommand([NotNull] ITwitchMessage twitchMessage)
{
var worker = ArgWorker.CreateInstance(CommandFilter.Parse(twitchMessage.Message).Skip(1));
if (!worker.TryGetNextAsViewer(out Viewer viewer) || !worker.TryGetNextAsInt(out int amount))
{
return;
}
viewer.GiveViewerCoins(amount);
Store_Logger.LogGiveCoins(twitchMessage.Username, viewer.username, amount);
twitchMessage.Reply("TKUtils.GiveCoins.Done".LocalizeKeyed(amount.ToString("N0"), viewer.username, viewer.GetViewerCoins().ToString("N0")));
}
public override void RunCommand([NotNull] ITwitchMessage twitchMessage)
{
_invoker = twitchMessage.Username;
string[] segments = CommandFilter.Parse(twitchMessage.Message).Skip(1).ToArray();
string category = segments.FirstOrFallback("");
string query = segments.Skip(1).FirstOrFallback("");
if (!Index.TryGetValue(category.ToLowerInvariant(), out Category result))
{
query = category;
}
PerformLookup(result, query);
}
private static bool ResolvePurchasePrefix([NotNull] Viewer viewer, [NotNull] ITwitchMessage twitchMessage)
{
if (Purchase_Handler.CheckIfViewerIsInVariableCommandList(viewer.username))
{
return(false);
}
List <string> segments = CommandFilter.Parse(twitchMessage.Message).ToList();
var worker = ArgWorker.CreateInstance(segments);
if (!worker.HasNext())
{
return(false);
}
string query = segments.Skip(1).FirstOrFallback("");
if (TryProcessIncident(viewer, twitchMessage, query))
{
return(false);
}
Helper.Log($"abr: {query} ");
segments.Insert(1, "item");
if (segments.Count < 4)
{
segments.Add("1");
}
if (!int.TryParse(segments[3], out int _))
{
segments.Insert(3, "1");
}
try
{
Purchase_Handler.ResolvePurchaseVariables(viewer, twitchMessage, StoreIncidentDefOf.Item, string.Join(" ", segments.ToArray()));
}
catch (Exception e)
{
TkUtils.Logger.Error("Could not resolve purchase", e);
}
return(false);
}
public override bool CanHappen(string msg, [NotNull] Viewer viewer)
{
if (!PurchaseHelper.TryGetPawn(viewer.username, out _pawn))
{
MessageHelper.ReplyToUser(viewer.username, "TKUtils.NoPawn".Localize());
return(false);
}
var worker = ArgWorker.CreateInstance(CommandFilter.Parse(msg).Skip(2));
if (!worker.TryGetNextAsTrait(out _buyableTrait) || !_buyableTrait.CanAdd || _buyableTrait.TraitDef == null)
{
MessageHelper.ReplyToUser(viewer.username, "TKUtils.InvalidTraitQuery".LocalizeKeyed(worker.GetLast()));
return(false);
}
if (!viewer.CanAfford(_buyableTrait !.CostToAdd))
{
MessageHelper.ReplyToUser(
viewer.username,
"TKUtils.InsufficientBalance".LocalizeKeyed(_buyableTrait.CostToAdd.ToString("N0"), viewer.GetViewerCoins().ToString("N0"))
);
return(false);
}
if (TraitHelper.GetTotalTraits(_pawn) >= AddTraitSettings.maxTraits && _buyableTrait.TraitData?.CanBypassLimit != true)
{
MessageHelper.ReplyToUser(viewer.username, "TKUtils.Trait.LimitReached".LocalizeKeyed(AddTraitSettings.maxTraits));
return(false);
}
if (!PassesCharacterChecks(viewer, worker))
{
return(false);
}
_trait = new Trait(_buyableTrait.TraitDef, _buyableTrait.Degree);
return(PassesValidationChecks(viewer) && PassesModChecks(viewer));
}
/// <inheritdoc/>
public override void RunCommand([NotNull] ITwitchMessage twitchMessage)
{
if (!PurchaseHelper.TryGetPawn(twitchMessage.Username, out Pawn pawn))
{
MessageHelper.ReplyToUser(twitchMessage.Username, "TKUtils.NoPawn".Localize());
return;
}
var worker = ArgWorker.CreateInstance(CommandFilter.Parse(twitchMessage.Message).Skip(1));
if (!worker.TryGetNextAsViewer(out Viewer viewer) || !PurchaseHelper.TryGetPawn(viewer.username, out Pawn target))
{
MessageHelper.ReplyToUser(twitchMessage.Username, "TKUtils.PawnNotFound".LocalizeKeyed(worker.GetLast()));
return;
}
TkUtils.Context.Post(c => PerformDivorce(pawn, target), null);
}
public override void RunCommand([NotNull] ITwitchMessage twitchMessage)
{
if (!PurchaseHelper.TryGetPawn(twitchMessage.Username, out Pawn pawn))
{
twitchMessage.Reply("TKUtils.NoPawn".Localize());
return;
}
var component = Current.Game.GetComponent <GameComponentPawns>();
if (component == null)
{
return;
}
string viewer = CommandFilter.Parse(twitchMessage.Message).Skip(1).FirstOrFallback();
if (!viewer.NullOrEmpty() && component.pawnHistory.TryGetValue(viewer.ToLowerInvariant(), out Pawn viewerPawn))
{
int theirOpinion = viewerPawn.relations.OpinionOf(pawn);
int myOpinion = pawn !.relations.OpinionOf(viewerPawn);
string relationship = GetSocialString(pawn, viewerPawn, myOpinion, true);
if (relationship.NullOrEmpty())
{
return;
}
var container = new List <string>
{
$"{myOpinion.ToStringWithSign()} ({twitchMessage.Username!.ToLowerInvariant()})", $"{theirOpinion.ToStringWithSign()} ({viewer.ToLowerInvariant()})"
};
twitchMessage.Reply(new[] { relationship, container.SectionJoin() }.GroupedJoin());
return;
}
ShowRelationshipOverview(twitchMessage, component, pawn);
}
public override bool CanHappen(string msg, [NotNull] Viewer viewer)
{
if (!PurchaseHelper.TryGetPawn(viewer.username, out _pawn))
{
MessageHelper.ReplyToUser(viewer.username, "TKUtils.NoPawn".Localize());
return(false);
}
int passions = _pawn !.skills.skills.Sum(skill => (int)skill.passion);
if (passions <= 0)
{
MessageHelper.ReplyToUser(viewer.username, "TKUtils.PassionShuffle.None".Localize());
return(false);
}
string query = CommandFilter.Parse(msg).Skip(2).FirstOrDefault();
if (query.NullOrEmpty())
{
return(_pawn.skills.skills.Any(s => (int)s.passion > (int)Passion.None));
}
_target = _pawn.skills.skills.FirstOrDefault(
s => s.def.defName.EqualsIgnoreCase(query !.ToToolkit()) || (s.def.skillLabel?.ToToolkit().EqualsIgnoreCase(query.ToToolkit()) ?? false) ||
(s.def.label?.ToToolkit().EqualsIgnoreCase(query.ToToolkit()) ?? false)
)
?.def;
if (_target != null)
{
return(_pawn.skills.skills.Any(s => (int)s.passion > (int)Passion.None));
}
MessageHelper.ReplyToUser(viewer.username, "TKUtils.InvalidSkillQuery".LocalizeKeyed(query));
return(false);
}
private static bool Prefix([CanBeNull] ITwitchMessage twitchMessage)
{
if (!TkSettings.Commands || twitchMessage?.Message == null)
{
return(!TkSettings.Commands);
}
Viewer viewer = Viewers.GetViewer(twitchMessage.Username);
viewer.last_seen = DateTime.Now;
if (viewer.IsBanned)
{
return(false);
}
string sanitized = GetCommandString(twitchMessage.Message);
if (sanitized == null)
{
return(false);
}
List <string> segments = CommandFilter.Parse(sanitized).ToList();
bool text = segments.Any(i => i.EqualsIgnoreCase("--text"));
if (segments.Count <= 0)
{
return(false);
}
if (text)
{
segments = segments.Where(i => !i.EqualsIgnoreCase("--text")).ToList();
}
LocateCommand(segments.ToArray())?.Execute(twitchMessage.WithMessage("!" + CombineSegments(segments).Trim()) !, text);
return(false);
}
public override void RunCommand([NotNull] ITwitchMessage message)
{
_invoker = message.Username;
if (!PurchaseHelper.TryGetPawn(message.Username, out _pawn))
{
message.Reply("TKUtils.NoPawn".Localize());
return;
}
string hexcode = CommandFilter.Parse(message.Message).Skip(1).FirstOrDefault();
List <KeyValuePair <string, string> > apparelPairs = CommandParser.ParseKeyed(message.Message);
if (!apparelPairs.NullOrEmpty())
{
CommandRouter.MainThreadCommands.Enqueue(() => DyeApparel(apparelPairs));
return;
}
if (hexcode.NullOrEmpty())
{
CommandRouter.MainThreadCommands.Enqueue(() => DyeAll(null));
return;
}
string s = hexcode !.ToToolkit();
if (!Data.ColorIndex.TryGetValue(s, out Color color) && !ColorUtility.TryParseHtmlString(s, out color))
{
message.Reply("TKUtils.NotAColor".LocalizeKeyed(s));
return;
}
CommandRouter.MainThreadCommands.Enqueue(() => DyeAll(new Color(color.r, color.g, color.b, 1f)));
}
public override bool CanHappen(string msg, Viewer viewer)
{
if (!Data.TryGetValue(storeIncident.defName, out _data))
{
return(false);
}
if (!_data.UseStoryteller)
{
string rawPoints = CommandFilter.Parse(msg).Skip(2).FirstOrDefault();
if (rawPoints.NullOrEmpty() || !VariablesHelpers.PointsWagerIsValid(rawPoints, viewer, ref _wager, ref storeIncident))
{
return(false);
}
}
Map map = Find.RandomPlayerHomeMap;
_worker = Activator.CreateInstance(_data.WorkerClass) as IncidentWorker;
if (_worker == null || map == null)
{
return(false);
}
_params = StorytellerUtility.DefaultParmsNow(_data.ResolveCategory(_worker, storeIncident), map);
if (!_data.UseStoryteller)
{
_params.points = IncidentHelper_PointsHelper.RollProportionalGamePoints(storeIncident, _wager, _params.points);
}
_params.forced = true;
_data.DoExtraSetup(_worker, _params, storeIncident);
return(_worker.CanFireNow(_params));
}
public override bool CanHappen(string msg, [NotNull] Viewer viewer)
{
if (!PurchaseHelper.TryGetPawn(viewer.username, out _pawn))
{
MessageHelper.ReplyToUser(viewer.username, "TKUtils.NoPawn".Localize());
return(false);
}
string query = CommandFilter.Parse(msg).Skip(2).FirstOrDefault();
if (query.NullOrEmpty())
{
return(false);
}
_target = _pawn !.skills.skills.Where(s => !s.TotallyDisabled)
.FirstOrDefault(
s => s.def.defName.EqualsIgnoreCase(query !.ToToolkit()) || (s.def.skillLabel?.ToToolkit().EqualsIgnoreCase(query.ToToolkit()) ?? false) ||
(s.def.label?.ToToolkit().EqualsIgnoreCase(query.ToToolkit()) ?? false)
);
if (_target == null)
{
MessageHelper.ReplyToUser(viewer.username, "TKUtils.InvalidSkillQuery".LocalizeKeyed(query));
return(false);
}
if ((int)_target.passion is { } passion&& passion > 0 && passion < 3)
{
return(true);
}
MessageHelper.ReplyToUser(viewer.username, "TKUtils.RemovePassion.None".LocalizeKeyed(query));
return(false);
}
public override void RunCommand([NotNull] ITwitchMessage msg)
{
if (!PurchaseHelper.TryGetPawn(msg.Username, out Pawn pawn))
{
msg.Reply("TKUtils.NoPawn".Localize());
}
string skill = CommandFilter.Parse(msg.Message).Skip(1).FirstOrDefault();
if (skill == null)
{
return;
}
CommandRouter.MainThreadCommands.Enqueue(
() =>
{
string error;
var magicUser = pawn.TryGetComp <CompAbilityUserMagic>();
if (magicUser is { IsMagicUser: true })
{
if (TryLevelMagic(magicUser, skill.ToToolkit(), out error))
{
msg.Reply("Done!");
}
else if (!error.NullOrEmpty())
{
msg.Reply(error);
}
return;
}
var mightUser = pawn.TryGetComp <CompAbilityUserMight>();
if (!(mightUser is { IsMightUser: true }))
public override void RunCommand([NotNull] ITwitchMessage twitchMessage)
{
if (!PurchaseHelper.TryGetPawn(twitchMessage.Username, out Pawn pawn))
{
twitchMessage.Reply("TKUtils.NoPawn".Localize().WithHeader("TabHealth".Localize()));
return;
}
string segment = CommandFilter.Parse(twitchMessage.Message).Skip(1).FirstOrFallback("");
if (segment.NullOrEmpty())
{
twitchMessage.Reply(HealthReport(pawn !).WithHeader("TabHealth".Localize()));
return;
}
PawnCapacityDef capacity = DefDatabase <PawnCapacityDef> .AllDefs.FirstOrDefault(
d => d.defName.EqualsIgnoreCase(segment) || d.LabelCap.RawText.ToToolkit().EqualsIgnoreCase(segment.ToToolkit())
);
twitchMessage.Reply((capacity == null ? HealthReport(pawn !) : HealthCapacityReport(pawn !, capacity)).WithHeader("TabHealth".Localize()));
}
public override void RunCommand([NotNull] ITwitchMessage twitchMessage)
{
if (!InteractionIndex.TryGetValue(command.defName, out InteractionProxy interaction))
{
TkUtils.Logger.Warn($@"{command.label}({command.defName}) is bound to the {nameof(PawnInteraction)} class, but has no interaction registered.");
return;
}
Viewer data = Viewers.GetViewer(twitchMessage.Username);
if (!PurchaseHelper.TryGetPawn(twitchMessage.Username, out Pawn pawn))
{
twitchMessage.Reply("TKUtils.NoPawn".Localize());
return;
}
string query = CommandFilter.Parse(twitchMessage.Message).Skip(1).FirstOrFallback("");
Pawn target = null;
if (!query.NullOrEmpty())
{
if (query.StartsWith("@"))
{
query = query.Substring(1);
}
Viewer viewer = Viewers.All.FirstOrDefault(v => v.username.EqualsIgnoreCase(query));
if (viewer == null)
{
return;
}
target = GetOrFindPawn(viewer.username);
if (target == null)
{
twitchMessage.Reply("TKUtils.PawnNotFound".LocalizeKeyed(query));
return;
}
}
target ??= Find.ColonistBar.Entries.Where(p => p.pawn != pawn).RandomElement().pawn;
CommandRouter.MainThreadCommands.Enqueue(
() =>
{
string result = ForcedInteractionWorker.InteractWith(pawn, target, interaction.Interaction);
if (interaction.IsBad)
{
data.SetViewerKarma(Mathf.Max(data.karma - (int)Mathf.Ceil(data.karma * 0.1f), ToolkitSettings.KarmaMinimum));
}
twitchMessage.Reply(result);
}
);
}
public static ArgWorker CreateInstance([NotNull] string input) => new ArgWorker(CommandFilter.Parse(input));
public override bool CanHappen(string msg, [NotNull] Viewer viewer)
{
if (!PurchaseHelper.TryGetPawn(viewer.username, out _pawn))
{
MessageHelper.ReplyToUser(viewer.username, "TKUtils.NoPawn".Localize());
return(false);
}
List <Trait> traits = _pawn !.story.traits.allTraits;
if (traits?.Count <= 0)
{
MessageHelper.ReplyToUser(viewer.username, "TKUtils.RemoveTrait.None".Localize());
return(false);
}
var worker = ArgWorker.CreateInstance(CommandFilter.Parse(msg).Skip(2));
if (!worker.TryGetNextAsTrait(out _buyable))
{
MessageHelper.ReplyToUser(viewer.username, "TKUtils.InvalidTraitQuery".LocalizeKeyed(worker.GetLast()));
return(false);
}
if (!_buyable !.CanRemove)
{
MessageHelper.ReplyToUser(viewer.username, "TKUtils.RemoveTrait.Disabled".LocalizeKeyed(worker.GetLast()));
return(false);
}
if (!viewer.CanAfford(_buyable.CostToRemove))
{
MessageHelper.ReplyToUser(
viewer.username,
"TKUtils.InsufficientBalance".LocalizeKeyed(_buyable.CostToRemove.ToString("N0"), viewer.GetViewerCoins().ToString("N0"))
);
return(false);
}
Trait target = traits?.FirstOrDefault(t => TraitHelper.CompareToInput(_buyable.GetDefaultName(_pawn.gender) !, t.Label));
if (target == null)
{
MessageHelper.ReplyToUser(viewer.username, "TKUtils.RemoveTrait.Missing".LocalizeKeyed(worker.GetLast()));
return(false);
}
if (!PassesModChecks(viewer, target, worker))
{
return(false);
}
_trait = target;
return(true);
}
public override bool CanHappen(string msg, Viewer viewer)
{
string[] traitQueries = CommandFilter.Parse(msg).Skip(2).ToArray();
if (traitQueries.Length <= 0)
{
return(false);
}
if (!PurchaseHelper.TryGetPawn(viewer.username, out _pawn))
{
MessageHelper.ReplyToUser(viewer.username, "TKUtils.NoPawn".Localize());
return(false);
}
var worker = ArgWorker.CreateInstance(CommandFilter.Parse(msg).Skip(2));
List <TraitItem> items = worker.GetAllAsTrait().ToList();
if (worker.HasNext() && !worker.GetLast().NullOrEmpty())
{
MessageHelper.ReplyToUser(viewer.username, "TKUtils.InvalidTraitQuery".LocalizeKeyed(worker.GetLast()));
return(false);
}
if (!TryProcessTraits(_pawn !, items, out _events))
{
TraitEvent errored = _events.FirstOrDefault(e => !e.Error.NullOrEmpty());
if (errored != null)
{
MessageHelper.ReplyToUser(viewer.username, errored.Error);
}
return(false);
}
if (_events.Count(e => e.ContributesToLimit) > AddTraitSettings.maxTraits)
{
MessageHelper.ReplyToUser(viewer.username, "TKUtils.Trait.LimitReached".LocalizeKeyed(AddTraitSettings.maxTraits));
return(false);
}
int total = _events.Sum(
i =>
{
switch (i.Type)
{
case EventType.Add:
return(i.Item.CostToAdd);
case EventType.Remove:
return(i.Item.CostToRemove);
default:
return(0);
}
}
);
if (!viewer.CanAfford(total))
{
MessageHelper.ReplyToUser(viewer.username, "TKUtils.InsufficientBalance".LocalizeKeyed(total.ToString("N0"), viewer.GetViewerCoins().ToString("N0")));
return(false);
}
return(true);
}
public override bool CanHappen(string msg, [NotNull] Viewer viewer)
{
string[] segments = CommandFilter.Parse(msg).Skip(2).ToArray();
string partQuery = segments.FirstOrFallback();
if (!PurchaseHelper.TryGetPawn(viewer.username, out Pawn pawn))
{
MessageHelper.ReplyToUser(viewer.username, "TKUtils.NoPawn".Localize());
return(false);
}
_appointment = Appointment.ParseInput(pawn, segments);
if (_appointment.ThingDef == null || _appointment.Item == null)
{
MessageHelper.ReplyToUser(viewer.username, "TKUtils.InvalidItemQuery".LocalizeKeyed(partQuery));
return(false);
}
if (_appointment.ThingDef.IsMedicine || _appointment.Surgery == null)
{
MessageHelper.ReplyToUser(viewer.username, "TKUtils.Surgery.HasNoSurgery".LocalizeKeyed(partQuery));
return(false);
}
if (BuyItemSettings.mustResearchFirst && _appointment.ThingDef.GetUnfinishedPrerequisites() is { } projects&& projects.Count > 0)
{
MessageHelper.ReplyToUser(
viewer.username,
"TKUtils.ResearchRequired".LocalizeKeyed(_appointment.ThingDef.LabelCap.RawText, projects.Select(p => p.LabelCap.RawText).SectionJoin())
);
return(false);
}
if (!viewer.CanAfford(_appointment.Cost))
{
MessageHelper.ReplyToUser(
viewer.username,
"TKUtils.InsufficientBalance".LocalizeKeyed(_appointment.Cost.ToString("N0"), viewer.GetViewerCoins().ToString("N0"))
);
return(false);
}
if (_appointment.Overflowed)
{
MessageHelper.ReplyToUser(viewer.username, "TKUtils.Overflowed".Localize());
return(false);
}
if (_appointment.BodyParts.NullOrEmpty())
{
MessageHelper.ReplyToUser(viewer.username, "TKUtils.Surgery.NoSlotAvailable".Localize());
return(false);
}
_map = Current.Game.AnyPlayerHomeMap;
if (_map != null)
{
return(true);
}
MessageHelper.ReplyToUser(viewer.username, "TKUtils.NoMap".Localize());
return(false);
}
public override bool CanHappen(string msg, [NotNull] Viewer viewer)
{
if (!PurchaseHelper.TryGetPawn(viewer.username, out _pawn))
{
MessageHelper.ReplyToUser(viewer.username, "TKUtils.NoPawn".Localize());
return(false);
}
var worker = ArgWorker.CreateInstance(CommandFilter.Parse(msg).Skip(2));
if (!worker.TryGetNextAsItem(out ArgWorker.ItemProxy item) || !item.IsValid())
{
MessageHelper.ReplyToUser(viewer.username, "TKUtils.InvalidItemQuery".LocalizeKeyed(item?.Thing?.Name ?? worker.GetLast()));
return(false);
}
_buyableItem = item.Thing;
if (item.TryGetError(out string error))
{
MessageHelper.ReplyToUser(viewer.username, error);
return(false);
}
if (!worker.TryGetNextAsInt(out _amount, 1, viewer.GetMaximumPurchaseAmount(_buyableItem.Cost)))
{
_amount = 1;
}
if (!PurchaseHelper.TryMultiply(_buyableItem.Cost, _amount, out int cost))
{
MessageHelper.ReplyToUser(viewer.username, "TKUtils.Overflowed".Localize());
return(false);
}
if (!viewer.CanAfford(cost))
{
MessageHelper.ReplyToUser(viewer.username, "TKUtils.InsufficientBalance".LocalizeKeyed(cost.ToString("N0"), viewer.GetViewerCoins().ToString("N0")));
return(false);
}
List <ResearchProjectDef> prerequisites = item.Thing.Thing.GetUnfinishedPrerequisites();
if (BuyItemSettings.mustResearchFirst && prerequisites.Count > 0)
{
MessageHelper.ReplyToUser(
viewer.username,
"TKUtils.ResearchRequired".LocalizeKeyed(item.Thing.Thing.LabelCap.RawText, prerequisites.Select(p => p.LabelCap.RawText).SectionJoin())
);
return(false);
}
foreach (IUsabilityHandler h in CompatRegistry.AllUsabilityHandlers)
{
if (!h.IsUsable(item.Thing.Thing))
{
continue;
}
_handler = h;
break;
}
if (_handler == null || item.Thing.ItemData?.IsUsable != true)
{
MessageHelper.ReplyToUser(viewer.username, "TKUtils.DisabledItem".Localize());
return(false);
}
_buyableItem = item !.Thing;
return(true);
}
[NotNull] public static List <KeyValuePair <string, string> > ParseKeyed(string input) => ParseKeyed(CommandFilter.Parse(input));