/// <summary>
/// Share supplied <see cref="Quest"/> with another <see cref="Player"/>.
/// </summary>
public void QuestShare(ushort questId)
{
QuestInfo info = GlobalQuestManager.Instance.GetQuestInfo(questId);
if (info == null)
{
throw new ArgumentException($"Invalid quest {questId}!");
}
Quest.Quest quest = GetQuest(questId);
if (quest == null)
{
throw new QuestException($"Player {player.CharacterId} tried to share quest {questId} which they don't have!");
}
if (!quest.CanShare())
{
throw new QuestException($"Player {player.CharacterId} tried to share quest {questId} which can't be shared!");
}
Player recipient = player.GetVisible <Player>(player.TargetGuid);
if (recipient == null)
{
throw new QuestException($"Player {player.CharacterId} tried to share quest {questId} to an invalid player!");
}
// TODO
log.Trace($"Shared quest {questId} with player {recipient.Name}.");
}
/// <summary>
/// Track or hide an active <see cref="Quest"/>.
/// </summary>
public void QuestTrack(ushort questId, bool tracked)
{
if (GlobalQuestManager.Instance.GetQuestInfo(questId) == null)
{
throw new ArgumentException($"Invalid quest {questId}!");
}
Quest.Quest quest = GetQuest(questId, GetQuestFlags.Active);
if (quest == null)
{
throw new QuestException($"Player {player.CharacterId} tried to track quest {questId} which they don't have!");
}
if (quest.State != QuestState.Accepted && quest.State != QuestState.Achieved)
{
throw new QuestException($"Player {player.CharacterId} tried to track quest {questId} with invalid state!");
}
if (tracked)
{
quest.Flags |= QuestFlags.Tracked;
}
else
{
quest.Flags &= ~QuestFlags.Tracked;
}
log.Trace($"Updated tracked state of quest {questId} to {tracked}.");
}
private Quest.Quest LoadQuestItem(QuestUIComponets questUIComponent, SaveData.QuestInfo savedQuestInfo = null, int lvl = 1)
{
if (questUIComponent.quest == null)
{
if (savedQuestInfo != null)
{
Quest.Quest quest = new Quest.Quest(savedQuestInfo.id, savedQuestInfo.level).SetupRandomQuest();
quest.mainCondition.UpdateProgress(savedQuestInfo.progress);
questUIComponent.quest = quest;
questUIComponent.ShowQuestData(questUIComponent.quest);
}
else
{
questUIComponent.quest = new Quest.Quest(0, lvl).SetupRandomQuest();
questUIComponent.ShowQuestData(questUIComponent.quest);
}
}
else
{
Debug.Log($"{GetType().FullName} :: Quest in component is not null");
questUIComponent.ShowQuestData(questUIComponent.quest);
}
//Setup claim btn
questUIComponent.claimBTN.onClick.AddListener(() => OnClaimClicked(questUIComponent, questUIComponent.quest));
return(questUIComponent.quest);
}
public void Init(MySqlConnection connection)
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT * FROM character_quests WHERE char_id=@char_id";
command.Parameters.AddWithValue("@char_id", _character.DbId);
command.Prepare();
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
var quest = new Quest.Quest
{
Id = reader.GetUInt16("quest_id"),
Completed =
{
[0] = reader.GetByte("req_1"),
[1] = reader.GetByte("req_2"),
[2] = reader.GetByte("req_3"),
[3] = reader.GetByte("req_4"),
[4] = reader.GetByte("req_5"),
},
IsDone = reader.GetBoolean("is_done"),
};
quest.QuestData = DataManager.Instance.QuestData.GetData(quest.Id);
if (quest.QuestData != null)
{
_quests.Add(quest.Id, quest);
}
}
}
}
}
/// <summary>
/// Complete single <see cref="QuestObjective"/> for supplied active <see cref="Quest"/>.
/// </summary>
public void QuestAchieveObjective(ushort questId, byte index)
{
if (GlobalQuestManager.Instance.GetQuestInfo(questId) == null)
{
throw new ArgumentException($"Invalid quest {questId}!");
}
Quest.Quest quest = GetQuest(questId);
if (quest == null || quest.PendingDelete)
{
throw new QuestException();
}
if (quest.State != QuestState.Accepted)
{
throw new QuestException();
}
QuestObjective objective = quest.SingleOrDefault(o => o.Index == index);
if (objective == null)
{
throw new QuestException();
}
quest.ObjectiveUpdate((QuestObjectiveType)objective.Entry.Type, objective.Entry.Data, objective.Entry.Count);
}
/// <summary>
/// Create a new <see cref="QuestManager"/> from existing <see cref="CharacterModel"/> database model.
/// </summary>
public QuestManager(Player owner, CharacterModel model)
{
player = owner;
foreach (CharacterQuestModel questModel in model.Quest)
{
QuestInfo info = GlobalQuestManager.Instance.GetQuestInfo(questModel.QuestId);
if (info == null)
{
log.Error($"Player {player.CharacterId} has an invalid quest {questModel.QuestId}!");
continue;
}
var quest = new Quest.Quest(player, info, questModel);
switch (quest.State)
{
case QuestState.Completed:
completedQuests.Add(quest.Id, quest);
break;
case QuestState.Botched:
case QuestState.Ignored:
inactiveQuests.Add(quest.Id, quest);
break;
case QuestState.Accepted:
case QuestState.Achieved:
activeQuests.Add(quest.Id, quest);
break;
}
}
}
private void QuestAdd(QuestInfo info, Quest.Quest quest, Item item)
{
if (quest?.State == QuestState.Accepted || quest?.State == QuestState.Achieved)
{
throw new QuestException($"Player {player.CharacterId} tried to start quest {info.Entry.Id} which is already in progress!");
}
// if quest has already been completed make sure it's repeatable and the reset period has elapsed
if (quest?.State == QuestState.Completed)
{
if (info.Entry.QuestRepeatPeriodEnum == 0u)
{
throw new QuestException($"Player {player.CharacterId} tried to start quest {info.Entry.Id} which they have already completed!");
}
DateTime?resetTime = GetQuest((ushort)info.Entry.Id, GetQuestFlags.Completed).Reset;
if (DateTime.UtcNow < resetTime)
{
throw new QuestException($"Player {player.CharacterId} tried to start quest {info.Entry.Id} which hasn't reset yet!");
}
}
if (item != null)
{
if (info.Entry.Id != item.Entry.Quest2IdActivation)
{
throw new QuestException($"Player {player.CharacterId} tried to start quest {info.Entry.Id} from invalid item {item.Entry.Id}!");
}
// TODO: consume charge
}
else
{
// make sure the player is in range of a quest giver or they are eligible for a communicator message that starts the quest
if (!GlobalQuestManager.Instance.GetQuestGivers((ushort)info.Entry.Id)
.Any(c => player.GetVisibleCreature <WorldEntity>(c).Any()))
{
if (!info.IsCommunicatorReceived())
{
throw new QuestException($"Player {player.CharacterId} tried to start quest {info.Entry.Id} without quest giver!");
}
if (!GlobalQuestManager.Instance.GetQuestCommunicatorMessages((ushort)info.Entry.Id)
.Any(m => m.Meets(player)))
{
throw new QuestException($"Player {player.CharacterId} tried to start quest {info.Entry.Id} without communicator message!");
}
}
}
// server doesn't send an error message for prerequisites since the client does the exact same checks
// it's assumed that a player could never get here without cheating in some way
if (!MeetsPrerequisites(info))
{
throw new QuestException($"Player {player.CharacterId} tried to start quest {info.Entry.Id} without meeting the prerequisites!");
}
QuestAdd(info);
}
public Quest.Quest AddQuest(QuestJson quest)
{
if (_quests.ContainsKey(quest.Id))
{
return(null);
}
var temp = new Quest.Quest
{
Id = quest.Id,
QuestData = quest,
};
return(_quests.TryAdd(quest.Id, temp) ? temp : null);
}
/// <summary>
/// Add a <see cref="Quest"/> from supplied id, optionally supplying <see cref="Item"/> which was used to start the quest.
/// </summary>
public void QuestAdd(ushort questId, Item item)
{
QuestInfo info = GlobalQuestManager.Instance.GetQuestInfo(questId);
if (info == null)
{
throw new ArgumentException($"Invalid quest {questId}!");
}
if (DisableManager.Instance.IsDisabled(DisableType.Quest, questId))
{
player.SendSystemMessage($"Unable to add quest {questId} because it is disabled.");
return;
}
Quest.Quest quest = GetQuest(questId);
QuestAdd(info, quest, item);
}
public void UpdateFromQuestReward(Quest.Quest quest, MaterialItemSheet materialItemSheet)
{
var items = new List <Material>();
foreach (var pair in quest.Reward.ItemMap.OrderBy(kv => kv.Key))
{
var row = materialItemSheet.OrderedList.First(itemRow => itemRow.Id == pair.Key);
var item = ItemFactory.CreateMaterial(row);
var map = inventory.AddItem(item, pair.Value);
itemMap.Add(map);
items.Add(item);
}
quest.IsPaidInAction = true;
questList.UpdateCollectQuest(itemMap);
questList.UpdateItemTypeCollectQuest(items);
UpdateCompletedQuest();
}
public void UpdateFromQuestReward(Quest.Quest quest, IActionContext context)
{
var items = new List <Material>();
foreach (var pair in quest.Reward.ItemMap)
{
var row = TableSheets.FromActionContext(context)
.MaterialItemSheet.Values.First(itemRow => itemRow.Id == pair.Key);
var item = ItemFactory.CreateMaterial(row);
var map = inventory.AddItem(item, pair.Value);
itemMap.Add(map);
items.Add(item);
}
quest.IsPaidInAction = true;
questList.UpdateCollectQuest(itemMap);
questList.UpdateItemTypeCollectQuest(items);
UpdateCompletedQuest();
}
/// <summary>
/// Abandon an active <see cref="Quest"/>.
/// </summary>
public void QuestAbandon(ushort questId)
{
if (GlobalQuestManager.Instance.GetQuestInfo(questId) == null)
{
throw new ArgumentException($"Invalid quest {questId}!");
}
Quest.Quest quest = GetQuest(questId, GetQuestFlags.Active | GetQuestFlags.Inactive);
if (quest == null || quest.PendingDelete)
{
throw new QuestException($"Player {player.CharacterId} tried to abandon quest {questId} which they don't have!");
}
if (!quest.CanAbandon())
{
throw new QuestException($"Player {player.CharacterId} tried to abandon quest {questId} which can't be abandoned!");
}
if (!quest.PendingCreate)
{
quest.EnqueueDelete(true);
}
else
{
switch (quest.State)
{
case QuestState.Accepted:
case QuestState.Achieved:
activeQuests.Remove(questId);
break;
case QuestState.Botched:
inactiveQuests.Remove(quest.Id);
break;
}
}
quest.State = QuestState.Abandoned;
log.Trace($"Abandoned quest {questId}.");
}
/// <summary>
/// Retry an inactive <see cref="Quest"/> that was previously failed.
/// </summary>
public void QuestRetry(ushort questId)
{
QuestInfo info = GlobalQuestManager.Instance.GetQuestInfo(questId);
if (info == null)
{
throw new ArgumentException($"Invalid quest {questId}!");
}
Quest.Quest quest = GetQuest(questId, GetQuestFlags.Inactive);
if (quest == null)
{
throw new QuestException($"Player {player.CharacterId} tried to restart quest {questId} which they don't have!");
}
if (quest.State != QuestState.Botched)
{
throw new QuestException($"Player {player.CharacterId} tried to restart quest {questId} which hasn't been failed!");
}
QuestAdd(info, quest, null);
}
/// <summary>
/// Complete all <see cref="QuestObjective"/>'s for supplied active <see cref="Quest"/>.
/// </summary>
public void QuestAchieve(ushort questId)
{
if (GlobalQuestManager.Instance.GetQuestInfo(questId) == null)
{
throw new ArgumentException($"Invalid quest {questId}!");
}
Quest.Quest quest = GetQuest(questId);
if (quest == null || quest.PendingDelete)
{
throw new QuestException($"Player {player.CharacterId} tried to achieve quest {questId} which they don't have!");
}
if (quest.State != QuestState.Accepted)
{
throw new QuestException($"Player {player.CharacterId} tried to achieve quest {questId} with invalid state!");
}
foreach (QuestObjectiveEntry entry in quest.Info.Objectives)
{
quest.ObjectiveUpdate((QuestObjectiveType)entry.Type, entry.Data, entry.Count);
}
}
private void OnClaimClicked(QuestUIComponets questUIComponent, Quest.Quest quest)
{
if (quest.completed)
{
questUIComponent.claimBTN.onClick.RemoveAllListeners();
questUIComponent.quest = null;
if (saveData.quest1.id == quest.id)
{
saveData.quest1 = null;
saveData.quest1 = LoadQuestItem(questUIComponent, null, 1).GetQuestInfo();
}
if (saveData.quest2.id == quest.id)
{
saveData.quest2 = null;
saveData.quest2 = LoadQuestItem(questUIComponent, null, 2).GetQuestInfo();
}
if (saveData.quest3.id == quest.id)
{
saveData.quest3 = null;
saveData.quest3 = LoadQuestItem(questUIComponent, null, 3).GetQuestInfo();
}
quest.mainCondition.GiveAllRewards();
UpdateAllQuestDisplays();
SaveJson();
}
else
{
Debug.LogError($"{GetType().FullName} :: Quest is not completed and is trying to be redeemed");
}
}
public CommandAddQuest(Quest.Quest quest)
{
m_quest = quest;
}
/// <summary>
/// Add a <see cref="Quest"/> from supplied <see cref="QuestInfo"/>, skipping any prerequisites checks.
/// </summary>
public void QuestAdd(QuestInfo info)
{
// make sure player has room for all pushed items
if (player.Inventory.GetInventoryFreeBagIndexCount()
< info.Entry.PushedItemIds.Count(i => i != 0u))
{
player.SendGenericError(GenericError.ItemInventoryFull);
return;
}
for (int i = 0; i < info.Entry.PushedItemIds.Length; i++)
{
uint itemId = info.Entry.PushedItemIds[i];
if (itemId != 0u)
{
player.Inventory.ItemCreate(itemId, info.Entry.PushedItemCounts[i]);
}
}
// TODO: virtual items
Quest.Quest quest = GetQuest((ushort)info.Entry.Id);
if (quest == null)
{
quest = new Quest.Quest(player, info);
}
else
{
// remove existing quest from its current home before
switch (quest.State)
{
case QuestState.Abandoned:
activeQuests.Remove(quest.Id);
break;
case QuestState.Completed:
completedQuests.Remove(quest.Id);
break;
case QuestState.Botched:
case QuestState.Ignored:
inactiveQuests.Remove(quest.Id);
break;
}
if (quest.PendingDelete)
{
quest.EnqueueDelete(false);
}
// reset previous objective progress
foreach (QuestObjective objective in quest)
{
objective.Progress = 0u;
}
}
quest.Flags |= QuestFlags.Tracked;
quest.State = QuestState.Accepted;
activeQuests.Add((ushort)info.Entry.Id, quest);
quest.InitialiseTimer();
log.Trace($"Accepted new quest {info.Entry.Id}.");
}
/// <summary>
/// Complete an achieved <see cref="Quest"/> supplying an optional reward and whether the quest was completed from the communicator.
/// </summary>
public void QuestComplete(ushort questId, ushort reward, bool communicator)
{
QuestInfo questInfo = GlobalQuestManager.Instance.GetQuestInfo(questId);
if (questInfo == null)
{
throw new ArgumentException($"Invalid quest {questId}!");
}
if (DisableManager.Instance.IsDisabled(DisableType.Quest, questId))
{
player.SendSystemMessage($"Unable to complete quest {questId} because it is disabled.");
return;
}
Quest.Quest quest = GetQuest(questId, GetQuestFlags.Active);
if (quest == null)
{
if (!questInfo.IsAutoComplete())
{
throw new QuestException($"Player {player.CharacterId} tried to complete quest {questId} which they don't have!");
}
QuestAdd(questId, null);
quest = GetQuest(questId);
quest.State = QuestState.Achieved;
}
if (quest.State != QuestState.Achieved)
{
throw new QuestException($"Player {player.CharacterId} tried to complete quest {questId} which wasn't complete!");
}
if (communicator)
{
if (!quest.Info.IsCommunicatorReceived())
{
throw new QuestException($"Player {player.CharacterId} tried to complete quest {questId} without communicator message!");
}
}
else
{
if (!GlobalQuestManager.Instance.GetQuestReceivers(questId).Any(c => player.GetVisibleCreature <WorldEntity>(c).Any()))
{
throw new QuestException($"Player {player.CharacterId} tried to complete quest {questId} without any quest receiver!");
}
}
// reclaim any quest specific items
for (int i = 0; i < quest.Info.Entry.PushedItemIds.Length; i++)
{
uint itemId = quest.Info.Entry.PushedItemIds[i];
if (itemId != 0u)
{
player.Inventory.ItemDelete(itemId, quest.Info.Entry.PushedItemCounts[i]);
}
}
RewardQuest(quest.Info, reward);
quest.State = QuestState.Completed;
// mark repeatable quests for reset
switch ((QuestRepeatPeriod)quest.Info.Entry.QuestRepeatPeriodEnum)
{
case QuestRepeatPeriod.Daily:
quest.Reset = GlobalQuestManager.Instance.NextDailyReset;
break;
case QuestRepeatPeriod.Weekly:
quest.Reset = GlobalQuestManager.Instance.NextWeeklyReset;
break;
}
activeQuests.Remove(questId);
completedQuests.Add(questId, quest);
player.AchievementManager.CheckAchievements(player, AchievementType.QuestComplete, questId);
}
public virtual void AddQuest(Quest.Quest quest)
{
}
