485 lines
14 KiB
C#
485 lines
14 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using Server.Engines.MLQuests.Gumps;
|
|
using Server.Engines.MLQuests.Objectives;
|
|
using Server.Mobiles;
|
|
|
|
namespace Server.Engines.MLQuests
|
|
{
|
|
[Flags]
|
|
public enum MLQuestInstanceFlags : byte
|
|
{
|
|
None = 0x00,
|
|
ClaimReward = 0x01,
|
|
Removed = 0x02,
|
|
Failed = 0x04
|
|
}
|
|
|
|
public class MLQuestInstance
|
|
{
|
|
private MLQuestInstanceFlags m_Flags;
|
|
private IQuestGiver m_Quester;
|
|
|
|
private Timer m_Timer;
|
|
|
|
public MLQuestInstance(MLQuest quest, IQuestGiver quester, PlayerMobile player)
|
|
{
|
|
Quest = quest;
|
|
|
|
m_Quester = quester;
|
|
QuesterType = quester?.GetType();
|
|
Player = player;
|
|
|
|
Accepted = DateTime.UtcNow;
|
|
m_Flags = MLQuestInstanceFlags.None;
|
|
|
|
Objectives = new BaseObjectiveInstance[quest.Objectives.Count];
|
|
|
|
BaseObjectiveInstance obj;
|
|
var timed = false;
|
|
|
|
for (var i = 0; i < quest.Objectives.Count; ++i)
|
|
{
|
|
Objectives[i] = obj = quest.Objectives[i].CreateInstance(this);
|
|
|
|
if (obj.IsTimed)
|
|
timed = true;
|
|
}
|
|
|
|
Register();
|
|
|
|
if (timed)
|
|
m_Timer = Timer.DelayCall(TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(5), Slice);
|
|
}
|
|
|
|
public MLQuest Quest { get; set; }
|
|
|
|
public IQuestGiver Quester
|
|
{
|
|
get => m_Quester;
|
|
set
|
|
{
|
|
m_Quester = value;
|
|
QuesterType = value?.GetType();
|
|
}
|
|
}
|
|
|
|
public Type QuesterType { get; private set; }
|
|
|
|
public PlayerMobile Player { get; set; }
|
|
|
|
public MLQuestContext PlayerContext => MLQuestSystem.GetOrCreateContext(Player);
|
|
|
|
public DateTime Accepted { get; set; }
|
|
|
|
public bool ClaimReward
|
|
{
|
|
get => GetFlag(MLQuestInstanceFlags.ClaimReward);
|
|
set => SetFlag(MLQuestInstanceFlags.ClaimReward, value);
|
|
}
|
|
|
|
public bool Removed
|
|
{
|
|
get => GetFlag(MLQuestInstanceFlags.Removed);
|
|
set => SetFlag(MLQuestInstanceFlags.Removed, value);
|
|
}
|
|
|
|
public bool Failed
|
|
{
|
|
get => GetFlag(MLQuestInstanceFlags.Failed);
|
|
set => SetFlag(MLQuestInstanceFlags.Failed, value);
|
|
}
|
|
|
|
public BaseObjectiveInstance[] Objectives { get; set; }
|
|
|
|
public bool SkipReportBack => TextDefinition.IsNullOrEmpty(Quest.CompletionMessage);
|
|
|
|
private void Register()
|
|
{
|
|
Quest?.Instances?.Add(this);
|
|
|
|
if (Player != null)
|
|
PlayerContext.QuestInstances.Add(this);
|
|
}
|
|
|
|
private void Unregister()
|
|
{
|
|
Quest?.Instances?.Remove(this);
|
|
|
|
if (Player != null)
|
|
PlayerContext.QuestInstances.Remove(this);
|
|
|
|
Removed = true;
|
|
}
|
|
|
|
public bool AllowsQuestItem(Item item, Type type)
|
|
{
|
|
foreach (var objective in Objectives)
|
|
if (!objective.Expired && objective.AllowsQuestItem(item, type))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
public bool IsCompleted()
|
|
{
|
|
var requiresAll = Quest.ObjectiveType == ObjectiveType.All;
|
|
|
|
foreach (var obj in Objectives)
|
|
{
|
|
var complete = obj.IsCompleted();
|
|
|
|
if (complete && !requiresAll)
|
|
return true;
|
|
if (!complete && requiresAll)
|
|
return false;
|
|
}
|
|
|
|
return requiresAll;
|
|
}
|
|
|
|
public void CheckComplete()
|
|
{
|
|
if (IsCompleted())
|
|
{
|
|
Player.PlaySound(0x5B5); // public sound
|
|
|
|
foreach (var obj in Objectives)
|
|
obj.OnQuestCompleted();
|
|
|
|
TextDefinition.SendMessageTo(Player, Quest.CompletionNotice, 0x23);
|
|
|
|
/*
|
|
* Advance to the ClaimReward=true stage if this quest has no
|
|
* completion message to show anyway. This suppresses further
|
|
* triggers of CheckComplete.
|
|
*
|
|
* For quests that require collections, this is done later when
|
|
* the player double clicks the quester.
|
|
*/
|
|
if (!Removed && SkipReportBack && !Quest.RequiresCollection
|
|
) // An OnQuestCompleted can potentially have removed this instance already
|
|
ContinueReportBack(false);
|
|
}
|
|
}
|
|
|
|
public void Fail()
|
|
{
|
|
Failed = true;
|
|
}
|
|
|
|
private void Slice()
|
|
{
|
|
if (ClaimReward || Removed)
|
|
{
|
|
StopTimer();
|
|
return;
|
|
}
|
|
|
|
var hasAnyFails = false;
|
|
var hasAnyLeft = false;
|
|
|
|
foreach (var obj in Objectives)
|
|
if (!obj.Expired)
|
|
{
|
|
if (obj.IsTimed && obj.EndTime <= DateTime.UtcNow)
|
|
{
|
|
Player.SendLocalizedMessage(1072258); // You failed to complete an objective in time!
|
|
|
|
obj.Expired = true;
|
|
obj.OnExpire();
|
|
|
|
hasAnyFails = true;
|
|
}
|
|
else
|
|
{
|
|
hasAnyLeft = true;
|
|
}
|
|
}
|
|
|
|
if (Quest.ObjectiveType == ObjectiveType.All && hasAnyFails || !hasAnyLeft)
|
|
Fail();
|
|
|
|
if (!hasAnyLeft)
|
|
StopTimer();
|
|
}
|
|
|
|
public void SendProgressGump()
|
|
{
|
|
Player.SendGump(new QuestConversationGump(Quest, Player, Quest.InProgressMessage));
|
|
}
|
|
|
|
public void SendRewardOffer()
|
|
{
|
|
Quest.GetRewards(this);
|
|
}
|
|
|
|
// TODO: Split next quest stuff from SendRewardGump stuff?
|
|
public void SendRewardGump()
|
|
{
|
|
var nextQuestType = Quest.NextQuest;
|
|
|
|
if (nextQuestType != null)
|
|
{
|
|
ClaimRewards(); // skip reward gump
|
|
|
|
if (Removed) // rewards were claimed successfully
|
|
{
|
|
var nextQuest = MLQuestSystem.FindQuest(nextQuestType);
|
|
|
|
nextQuest?.SendOffer(m_Quester, Player);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Player.SendGump(new QuestRewardGump(this));
|
|
}
|
|
}
|
|
|
|
public void SendReportBackGump()
|
|
{
|
|
if (SkipReportBack)
|
|
ContinueReportBack(true); // skip ahead
|
|
else
|
|
Player.SendGump(new QuestReportBackGump(this));
|
|
}
|
|
|
|
public void ContinueReportBack(bool sendRewardGump)
|
|
{
|
|
// There is a backpack check here on OSI for the rewards as well (even though it's not needed...)
|
|
|
|
if (Quest.ObjectiveType == ObjectiveType.All)
|
|
{
|
|
// TODO: 1115877 - You no longer have the required items to complete this quest.
|
|
foreach (var objective in Objectives)
|
|
if (!objective.IsCompleted())
|
|
return;
|
|
|
|
foreach (var objective in Objectives)
|
|
if (!objective.OnBeforeClaimReward())
|
|
return;
|
|
|
|
foreach (var objective in Objectives)
|
|
objective.OnClaimReward();
|
|
}
|
|
else
|
|
{
|
|
/* The following behavior is unverified, as OSI (currently) has no collect quest requiring
|
|
* only one objective to be completed. It is assumed that only one objective is claimed
|
|
* (the first completed one), even when multiple are complete.
|
|
*/
|
|
var complete = false;
|
|
|
|
foreach (var objective in Objectives)
|
|
if (objective.IsCompleted())
|
|
{
|
|
if (objective.OnBeforeClaimReward())
|
|
{
|
|
complete = true;
|
|
objective.OnClaimReward();
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
if (!complete)
|
|
return;
|
|
}
|
|
|
|
ClaimReward = true;
|
|
|
|
if (Quest.HasRestartDelay)
|
|
PlayerContext.SetDoneQuest(Quest, DateTime.UtcNow + Quest.GetRestartDelay());
|
|
|
|
// This is correct for ObjectiveType.Any as well
|
|
foreach (var objective in Objectives)
|
|
objective.OnAfterClaimReward();
|
|
|
|
if (sendRewardGump)
|
|
SendRewardOffer();
|
|
}
|
|
|
|
public void ClaimRewards()
|
|
{
|
|
if (Quest == null || Player?.Deleted != false || !ClaimReward || Removed)
|
|
return;
|
|
|
|
var rewards = new List<Item>();
|
|
|
|
foreach (var reward in Quest.Rewards)
|
|
reward.AddRewardItems(Player, rewards);
|
|
|
|
if (rewards.Count != 0)
|
|
{
|
|
// On OSI a more naive method of checking is used.
|
|
// For containers, only the actual container item counts.
|
|
var canFit = true;
|
|
|
|
foreach (var rewardItem in rewards)
|
|
if (!Player.AddToBackpack(rewardItem))
|
|
{
|
|
canFit = false;
|
|
break;
|
|
}
|
|
|
|
if (!canFit)
|
|
{
|
|
foreach (var rewardItem in rewards)
|
|
rewardItem.Delete();
|
|
|
|
Player.SendLocalizedMessage(
|
|
1078524
|
|
); // Your backpack is full. You cannot complete the quest and receive your reward.
|
|
return;
|
|
}
|
|
|
|
foreach (var rewardItem in rewards)
|
|
{
|
|
var rewardName = rewardItem.Name ?? $"#{rewardItem.LabelNumber}";
|
|
|
|
if (rewardItem.Stackable)
|
|
Player.SendLocalizedMessage(
|
|
1115917,
|
|
$"{rewardItem.Amount}\t{rewardName}"
|
|
); // You receive a reward: ~1_QUANTITY~ ~2_ITEM~
|
|
else
|
|
Player.SendLocalizedMessage(1074360, rewardName); // You receive a reward: ~1_REWARD~
|
|
}
|
|
}
|
|
|
|
foreach (var objective in Objectives)
|
|
objective.OnRewardClaimed();
|
|
|
|
Quest.OnRewardClaimed(this);
|
|
|
|
var context = PlayerContext;
|
|
|
|
if (Quest.RecordCompletion && !Quest.HasRestartDelay) // Quests with restart delays are logged earlier as per OSI
|
|
context.SetDoneQuest(Quest);
|
|
|
|
if (Quest.IsChainTriggered)
|
|
context.ChainOffers.Remove(Quest);
|
|
|
|
var nextQuestType = Quest.NextQuest;
|
|
|
|
if (nextQuestType != null)
|
|
{
|
|
var nextQuest = MLQuestSystem.FindQuest(nextQuestType);
|
|
|
|
if (nextQuest != null && !context.ChainOffers.Contains(nextQuest))
|
|
context.ChainOffers.Add(nextQuest);
|
|
}
|
|
|
|
Remove();
|
|
}
|
|
|
|
public void Cancel()
|
|
{
|
|
Cancel(false);
|
|
}
|
|
|
|
public void Cancel(bool removeChain)
|
|
{
|
|
Remove();
|
|
|
|
Player.SendSound(0x5B3); // private sound
|
|
|
|
foreach (var obj in Objectives)
|
|
obj.OnQuestCancelled();
|
|
|
|
Quest.OnCancel(this);
|
|
|
|
if (removeChain)
|
|
PlayerContext.ChainOffers.Remove(Quest);
|
|
}
|
|
|
|
public void Remove()
|
|
{
|
|
Unregister();
|
|
StopTimer();
|
|
}
|
|
|
|
private void StopTimer()
|
|
{
|
|
if (m_Timer == null)
|
|
return;
|
|
m_Timer.Stop();
|
|
m_Timer = null;
|
|
}
|
|
|
|
public void OnQuesterDeleted()
|
|
{
|
|
foreach (var obj in Objectives)
|
|
obj.OnQuesterDeleted();
|
|
|
|
Quest.OnQuesterDeleted(this);
|
|
}
|
|
|
|
public void OnPlayerDeath()
|
|
{
|
|
foreach (var obj in Objectives)
|
|
obj.OnPlayerDeath();
|
|
|
|
Quest.OnPlayerDeath(this);
|
|
}
|
|
|
|
private bool GetFlag(MLQuestInstanceFlags flag) => (m_Flags & flag) != 0;
|
|
|
|
private void SetFlag(MLQuestInstanceFlags flag, bool value)
|
|
{
|
|
if (value)
|
|
m_Flags |= flag;
|
|
else
|
|
m_Flags &= ~flag;
|
|
}
|
|
|
|
public void Serialize(IGenericWriter writer)
|
|
{
|
|
// Version info is written in MLQuestPersistence.Serialize
|
|
|
|
MLQuestSystem.WriteQuestRef(writer, Quest);
|
|
|
|
writer.Write(m_Quester?.Deleted != false ? Serial.MinusOne : m_Quester.Serial);
|
|
|
|
writer.Write(ClaimReward);
|
|
writer.Write(Objectives.Length);
|
|
|
|
foreach (var objInstance in Objectives)
|
|
objInstance.Serialize(writer);
|
|
}
|
|
|
|
public static MLQuestInstance Deserialize(IGenericReader reader, int version, PlayerMobile pm)
|
|
{
|
|
var quest = MLQuestSystem.ReadQuestRef(reader);
|
|
|
|
// TODO: Serialize quester TYPE too, the quest giver reference then becomes optional (only for escorts)
|
|
var quester = World.FindEntity(reader.ReadUInt()) as IQuestGiver;
|
|
|
|
var claimReward = reader.ReadBool();
|
|
var objectives = reader.ReadInt();
|
|
|
|
MLQuestInstance instance;
|
|
|
|
if (quest != null && quester != null && pm != null)
|
|
{
|
|
instance = quest.CreateInstance(quester, pm);
|
|
instance.ClaimReward = claimReward;
|
|
}
|
|
else
|
|
{
|
|
instance = null;
|
|
}
|
|
|
|
for (var i = 0; i < objectives; ++i)
|
|
BaseObjectiveInstance.Deserialize(
|
|
reader,
|
|
version,
|
|
instance != null && i < instance.Objectives.Length ? instance.Objectives[i] : null
|
|
);
|
|
|
|
instance?.Slice();
|
|
|
|
return instance;
|
|
}
|
|
}
|
|
}
|