public async Task <HasActionsLeft> DoInventoryAction(string category, string name, string action, bool dryRun = false)
{
await GoBackIfInStorylet();
var item = await _session.GetPossession(category, name);
if (item != null && item.effectiveLevel >= 1)
{
var result = await _session.UseQuality(item.id);
if (result.isSuccess && !dryRun)
{
_cachedList = null;
var hasActionsLeft = await PerformAction(action); // performaction defaults to available, until we figure out phase for storyletlist, handle this manually
if (hasActionsLeft == HasActionsLeft.Available)
{
return(HasActionsLeft.Consumed);
}
else
{
return(hasActionsLeft);
}
}
// todo the following two could possibly be thrown instead
return(HasActionsLeft.Faulty); // usequality failed
}
return(HasActionsLeft.Faulty); // we don't actually have that possession, some prereq failed
}
public async Task <HasActionsLeft> ActivateOpportunityCard(CardAction card)
{
if (card.eventId == null)
{
throw new Exception("card has no eventId set");
}
if (_cachedOpportunity == null || _cachedOpportunity.isInAStorylet)
{
await _session.GoBack();
}
Log.Info($"doing card {card.name} action {card.action}");
_cachedList = await _session.BeginStorylet(card.eventId.Value);
if (!string.IsNullOrWhiteSpace(card.action))
{
return(await PerformActions(card.action.Split(',')));
}
else
{
_cachedList.LogMessages();
}
return(HasActionsLeft.Consumed);
}
public async Task <HasActionsLeft> PerformAction(string name)
{
if (_cachedList == null || _cachedList.phase == "End")
{
_cachedList = await _session.ListStorylet();
}
if (_cachedList.phase == "Act")
{
var branchId = _cachedList.socialAct.inviteeData.branchId;
var friend = _cachedList.socialAct.inviteeData.eligibleFriends.SelectFriend(name);
_cachedList = await _session.SendInternalSocialAct(branchId, friend.id);
return(HasActionsLeft.Consumed);
}
if (_cachedList.phase == "Available")
{
throw new Exception($"Trying to perform action {name} while phase: Available");
}
var branch = _cachedList.storylet.childBranches.GetChildBranch(name);
if (branch == null)
{
return(HasActionsLeft.Faulty);
}
var branchResult = await _session.ChooseBranch(branch.id);
if (branchResult != null)
{
_cachedList = branchResult;
}
return(HasActionsLeft.Available); // can technically be consumed, but until we figure out list.phase and stuff, we have to depend on upstream calls knowing what they are doing
}
public async Task MoveIfNeeded(string location)
{
if (string.Equals("any", location, StringComparison.InvariantCultureIgnoreCase))
{
return;
}
if (await _session.IsInLocation(location))
{
return;
}
if (await _session.GetLocationId(location) == await _session.GetLocationId("empress court"))
{
//todo require route shuttered plaace
await _session.MoveTo("shutteredpalace");
_cachedList = await _session.ListStorylet();
await EnterStorylet("spend");
await PerformAction("1");
_cachedList = await _session.ListStorylet();
return;
}
// todo test if race condition since we throw away result from moveto?
await _session.MoveTo(location);
_cachedList = await _session.ListStorylet();
}
public async Task GoBackIfInStorylet()
{
if (_cachedList == null || _cachedList.phase == "End")
{
_cachedList = await _session.ListStorylet();
}
if (_cachedList.phase == "Available")
{
return;
}
if (_cachedList.storylet == null)
{
return;
}
if (_cachedList.storylet.canGoBack.HasValue && _cachedList.storylet.canGoBack.Value)
{
Log.Debug("DEBUG: exiting storylet");
_cachedList = await _session.GoBack();
return;
}
else
{
// # we check for this much earlier, this is redundant. Also it is a forced action, not locked storylet
// $done = HandleLockedStorylet $list
// return $null
throw new Exception("called GoBackIfInStorylet on what looks like locked storylet");
}
}
public async Task <bool> HasForcedAction()
{
if (_cachedList == null)
{
_cachedList = await _session.ListStorylet();
}
return(_cachedList.phase != "Available" && _cachedList.storylet != null && (_cachedList.storylet.canGoBack.HasValue && !_cachedList.storylet.canGoBack.Value));
}
public async Task <string> GetStoryletName()
{
if (_cachedList == null)
{
_cachedList = await _session.ListStorylet();
}
return(_cachedList.storylet?.name);
}
public async Task <StoryletList> BeginStorylet(long id)
{
StoryletList ev = await Post <StoryletList>("storylet/begin", new { eventId = id });
if (ev.storylet != null)
{
Log.Info($"BeginStorylet: {ev.storylet.name} -> {ev.storylet.description}");
}
return(ev);
}
public static void LogMessages(this StoryletList list)
{
if (list.endStorylet != null)
{
fl.Log.Info($"EndStorylet: {list.endStorylet.eventValue.name} -> {list.endStorylet.eventValue.description}");
}
if (list.messages != null && list.messages.defaultMessages != null)
{
foreach (var m in list.messages.defaultMessages)
{
fl.Log.Info($"message: {m.message}");
}
}
}
public async Task <StoryletList> ChooseBranch(long id)
{
if (TestModeEnabled)
{
TestPostedBranches.Add(id);
return(null);
}
else
{
StoryletList ev = await Post <StoryletList>("storylet/choosebranch", new { branchId = id, secondChanceIds = new int[0] });
ev.LogMessages();
return(ev);
}
}
// returned bool here is an IsSuccess flag, not hasactionsleft
// it isnt used afaict, so just throw on error?
public async Task <bool> EnterStorylet(string storyletname)
{
var sid = await _session.GetStoryletId(storyletname, _cachedList);
if (sid != null)
{
_cachedList = await _session.BeginStorylet(sid.Value);
return(true);
}
else
{
_cachedList = null;
return(false);
}
}
public async Task <HasActionsLeft> SocialInteraction(long id)
{
await _session.BeginSocialEvent(id);
_cachedList = await _session.ListStorylet();
var action = SocialEventsHandler.GetActionFor(_cachedList.storylet.name);
if (action == null)
{
// todo add discard message here
return(HasActionsLeft.Available);
}
Log.Info($"Doing interaction {_cachedList.storylet.name}");
return(await PerformActions(action.Split(',')));
}
public async Task <HasActionsLeft> PerformActions(IEnumerable <string> actions)
{
if (actions == null)
{
return(HasActionsLeft.Faulty); // todo throw exception here?
}
foreach (var action in actions)
{
if (!string.IsNullOrWhiteSpace(action))
{
if (_cachedList.phase == "End")
{
_cachedList = await _session.ListStorylet();
}
var result = await PerformAction(action);
if (_cachedList == null || result == HasActionsLeft.Faulty)
{
return(HasActionsLeft.Faulty);
}
}
}
return(HasActionsLeft.Consumed);
}
public static async Task <long?> GetStoryletId(this Session s, string name, StoryletList list = null)
{
if (list == null)
{
list = await s.ListStorylet();
}
var n = name.AsNumber();
if (n != null)
{
return(list.storylets[n.Value - 1].id);
}
var r = new Regex(name, RegexOptions.IgnoreCase);
foreach (var item in list.storylets)
{
if (r.IsMatch(item.name))
{
return(item.id);
}
}
return(null);
}
// for testing
public static StoryletList AsDryrun(this StoryletList list, string message)
{
return(new StoryletList {
phase = message, isSuccess = list.isSuccess
});
}
