/// <summary>
/// Sets the quest's state.
/// </summary>
/// <param name="state">The state to be set.</param>
public void SetState(QuestState state)
{
if (m_State == state)
{
return;
}
m_State = state;
switch (m_State)
{
case QuestState.Inactive:
m_QuestNode.SetState(QuestNodeState.Inactive);
m_QuestCounters.StopListening();
break;
case QuestState.Active:
m_QuestNode.SetState(QuestNodeState.Active);
m_QuestCounters.StartListening();
break;
case QuestState.Success:
m_QuestNode.SetState(QuestNodeState.Succeeded);
m_QuestCounters.StopListening();
break;
case QuestState.Failed:
m_QuestNode.SetState(QuestNodeState.Failed);
m_QuestCounters.StopListening();
break;
}
}
public void StartQuest(TopDownUIDialog dialog)
{
if (questHub != null && questState != QuestState.Started && questFinished == false)
{
this.enabled = true;
if (dialog != null)
{
questGiverDialog = dialog;
}
else
{
Debug.LogError("You must assign TopDownUIDialog component of quest giver to the dialog event action that fires the StartQuest function of quest: " + questName);
}
questState = QuestState.Started;
questHub.startedQuests.Add(this);
questHub.activeQuest = this;
uiManager.questLog.GetComponent <TopDownRpgQuestLog>().UpdateQuestList();
questStartEvents.Invoke();
//SOME NOTIFICATION THAT QUEST STARTED
uiManager.notificationText.GetComponent <TopDownUIShowNotification>().ShowNotification("Quest Started \n''" + questName + "''");
}
}
public void Start()
{
if (Started)
{
Log.Error("Quest already started: " + Name);
return;
}
state = QuestState.Started;
expireTime = Find.TickManager.TicksGame + RandomExpiryTicks();
Find.World.GetComponent <WorldComponent_QuestTracker>().quests.Add(this);
foreach (var part in def.questParts)
{
part.OnStart(this);
}
var slate = new Slate();
handle = RimWorld.QuestUtility.GenerateQuestAndMakeAvailable(DefDatabase <QuestScriptDef> .GetNamed("CityQuest"), slate);
handle.name = Name;
handle.description = DetailText;
handle.challengeRating = ChallengeRating;
OnSetupHandle(handle);
handle.Initiate();
OnStart();
}
public static void SpawnQuestItems(NWPlaceable oChest, NWPlayer oPC)
{
int questID = oChest.GetLocalInt("QUEST_ID");
int questStateSequence = oChest.GetLocalInt("QUEST_SEQUENCE");
string questItemResref = oChest.GetLocalString("QUEST_ITEM_RESREF");
if (questID <= 0 || questStateSequence <= 0 || string.IsNullOrWhiteSpace(questItemResref))
{
return;
}
PCQuestStatus status = DataService.Single <PCQuestStatus>(x => x.PlayerID == oPC.GlobalID && x.QuestID == questID);
QuestState questState = DataService.Get <QuestState>(status.CurrentQuestStateID);
if (questStateSequence != questState.Sequence)
{
return;
}
if (_.GetIsObjectValid(_.GetItemPossessedBy(oPC.Object, questItemResref)) == FALSE)
{
return;
}
// PC is on the correct quest, correct state, the chest creates quest items, and the PC does not already have the quest item.
// Spawn it.
_.CreateItemOnObject(questItemResref, oChest.Object);
}
private void QuestChangedHandler(string title, QuestState newState)
{
if (newState == QuestState.Success)
{
Debug.Log("Quest completed callback");
}
}
public override void Complete()
{
state = QuestState.COMPLETED;
base.Complete();
marker.HideMarker();
GameObject.Destroy(marker.gameObject);
}
// Update is called once per frame
void Update()
{
if (State == QuestState.Completed)
{
if (!done)
{
timer -= Time.deltaTime;
if (timer <= 0f)
{
done = true;
GameMaster.instance.Bonus.TacitusQuest[1].SetActive(true);
//quest stuff?
}
}
return;
}
if (Tacitus.Count != 0 && State == QuestState.NotStarted && GameMaster.instance.Bonus.TacitusQuest[0].activeSelf == true)
{
State = QuestState.Started;
return;
}
if (State == QuestState.Started)
{
for (int i = 0; i < Tacitus.Count; i++)
{
if (Tacitus[i] == null)
{
State = QuestState.Completed;
Tacitus.RemoveAt(i);
return;
}
}
}
}
private void ShowQuests(QuestState questStateMask)
{
currentQuestStateMask = questStateMask;
NoQuestsMessage = GetNoQuestsMessage(questStateMask);
List <QuestInfo> questList = new List <QuestInfo>();
string[] titles = QuestLog.GetAllQuests(questStateMask);
foreach (var title in titles)
{
FormattedText description = FormattedText.Parse(QuestLog.GetQuestDescription(title), DialogueManager.MasterDatabase.emphasisSettings);
FormattedText localizedTitle = FormattedText.Parse(QuestLog.GetQuestTitle(title), DialogueManager.MasterDatabase.emphasisSettings);
FormattedText heading = (questHeadingSource == QuestHeadingSource.Description) ? description : localizedTitle;
bool abandonable = QuestLog.IsQuestAbandonable(title) && IsShowingActiveQuests;
bool trackable = QuestLog.IsQuestTrackingAvailable(title) && IsShowingActiveQuests;
bool track = QuestLog.IsQuestTrackingEnabled(title);
int entryCount = QuestLog.GetQuestEntryCount(title);
FormattedText[] entries = new FormattedText[entryCount];
QuestState[] entryStates = new QuestState[entryCount];
for (int i = 0; i < entryCount; i++)
{
entries[i] = FormattedText.Parse(QuestLog.GetQuestEntry(title, i + 1), DialogueManager.MasterDatabase.emphasisSettings);
entryStates[i] = QuestLog.GetQuestEntryState(title, i + 1);
}
questList.Add(new QuestInfo(title, heading, description, entries, entryStates, trackable, track, abandonable));
}
Quests = questList.ToArray();
OnQuestListUpdated();
}
public static int SaveQuestState(QuestState input)
{
IQuestRepository repo = new EFQuestRepository();
var questState = repo.QuestStates.FirstOrDefault(q => q.Id == input.Id);
if (questState == null)
{
questState = new QuestState();
}
questState.Id = input.Id;
questState.QuestEndId = input.QuestEndId;
questState.QuestStateName = input.QuestStateName;
questState.Text = input.Text;
questState.QuestId = input.QuestId;
questState.HideIfRequirementsNotMet = input.HideIfRequirementsNotMet;
questState.Notes = input.Notes;
questState.PinToDiagram = input.PinToDiagram;
questState.X = input.X;
questState.Y = input.Y;
// always set this to something, even if it's just empty string
if (questState.QuestStateName == null)
{
questState.QuestStateName = "-- QUEST STATE NOT NAMED --";
}
repo.SaveQuestState(questState);
return(questState.Id);
}
private void doFTUECheck(DataEntityHandle handle)
{
ProfileData component = dataEntityCollection.GetComponent <ProfileData>(handle);
component.IsFirstTimePlayer = true;
component.IsFTUEComplete = false;
if (!dataEntityCollection.TryGetComponent <QuestStateData>(dataEntityCollection.LocalPlayerHandle, out var component2) || component2.Data == null)
{
return;
}
for (int i = 0; i < component2.Data.Count; i++)
{
QuestState questState = component2.Data[i];
if (questState.questId == ftueConfig.FtueQuestId)
{
if (questState.timesCompleted > 0 || (questState.completedObjectives != null && questState.completedObjectives.Count > 0))
{
component.IsFirstTimePlayer = false;
}
component.IsFTUEComplete = questState.timesCompleted > 0;
if (MonoSingleton <NativeAccessibilityManager> .Instance.IsEnabled)
{
component.IsFirstTimePlayer = false;
component.IsFTUEComplete = true;
}
break;
}
}
}
public static bool GetQuestStateFoldout(QuestState questState, int nodeIndex)
{
var list = GetQuestStateFoldoutList(questState);
VerifyListSize(list, nodeIndex, true);
return(list[nodeIndex]);
}
public override void OnEnter()
{
if ((questName == null) || (string.IsNullOrEmpty(questName.Value)))
{
LogError(string.Format("{0}: Quest Name is null or blank.", DialogueDebug.Prefix));
}
else
{
QuestState questState = QuestLog.GetQuestState(questName.Value);
if (storeResult != null)
{
storeResult.Value = questState.ToString().ToLower();
}
switch (questState)
{
case QuestState.Unassigned: Fsm.Event(unassignedStateEvent); break;
case QuestState.Active: Fsm.Event(activeStateEvent); break;
case QuestState.Success: Fsm.Event(successStateEvent); break;
case QuestState.Failure: Fsm.Event(failureStateEvent); break;
}
}
Finish();
}
public void CopyFrom(Quest quest)
{
if (quest == null)
{
Debug.LogWarning("Quest Machine: QuestProxy.CopyFrom source quest is null.");
return;
}
isInstance = quest.isInstance;
id = StringField.GetStringValue(quest.id);
displayName = StringField.GetStringValue(quest.title);
iconPath = QuestMachine.GetImagePath(quest.icon);
group = StringField.GetStringValue(quest.group);
labels = StringFieldsToStrings(quest.labels);
giver = StringField.GetStringValue(quest.questGiverID);
isTrackable = quest.isTrackable;
track = quest.showInTrackHUD;
isAbandonable = quest.isAbandonable;
rememberIfAbandoned = quest.rememberIfAbandoned;
autostartConditionSet = new QuestConditionSetProxy(quest.autostartConditionSet);
offerConditionSet = new QuestConditionSetProxy(quest.offerConditionSet);
offerUnmetContentList = QuestContentProxy.NewArray(quest.offerConditionsUnmetContentList);
offerContentList = QuestContentProxy.NewArray(quest.offerContentList);
maxTimes = quest.maxTimes;
timesAccepted = quest.timesAccepted;
cooldownSecs = quest.cooldownSeconds;
cooldownSecsRemain = quest.cooldownSecondsRemaining;
state = quest.GetState();
stateInfoList = QuestStateInfoProxy.NewArray(quest.stateInfoList);
counterList = QuestCounterProxy.NewArray(quest.counterList);
nodeList = QuestNodeProxy.NewArray(quest.nodeList);
tags = new TagDictionary(quest.tagDictionary);
indicators = QuestIndicatorStateRecordProxy.NewArray(quest.indicatorStates);
goalEntity = quest.goalEntityTypeName;
}
public override void OnEnter()
{
if (PlayMakerTools.IsValueAssigned(questName) && PlayMakerTools.IsValueAssigned(entryNumber))
{
QuestState questState = QuestLog.GetQuestEntryState(questName.Value, Mathf.Max(1, entryNumber.Value));
if (storeResult != null)
{
storeResult.Value = questState.ToString().ToLower();
}
switch (questState)
{
case QuestState.Unassigned: Fsm.Event(unassignedStateEvent); break;
case QuestState.Active: Fsm.Event(activeStateEvent); break;
case QuestState.Success: Fsm.Event(successStateEvent); break;
case QuestState.Failure: Fsm.Event(failureStateEvent); break;
}
}
else
{
LogError(string.Format("{0}: Quest Name and Entry Number must be assigned first.", DialogueDebug.Prefix));
}
Finish();
}
private string GetQuestEntryText(string quest, int entryNum, QuestState entryState)
{
if (entryState == QuestState.Unassigned || entryState == QuestState.Abandoned)
{
return(string.Empty);
}
else if ((entryState == QuestState.Success || entryState == QuestState.Failure) && !showCompletedEntryText)
{
return(string.Empty);
}
else if (entryState == QuestState.Success)
{
var text = DialogueLua.GetQuestField(quest, "Entry " + entryNum + " Success").AsString;
if (!string.IsNullOrEmpty(text))
{
return(text);
}
}
else if (entryState == QuestState.Failure)
{
var text = DialogueLua.GetQuestField(quest, "Entry " + entryNum + " Failure").AsString;
if (!string.IsNullOrEmpty(text))
{
return(text);
}
}
return(QuestLog.GetQuestEntry(quest, entryNum));
}
public QuestChanged(QuestChange _change, QuestLine _quest, int _currentQuest, QuestState _state)
{
change = _change;
quest = _quest;
currentQuest = _currentQuest;
state = _state;
}
protected virtual void ShowQuests(QuestState questStateMask)
{
currentQuestStateMask = questStateMask;
noQuestsMessage = GetNoQuestsMessage(questStateMask);
List <QuestInfo> questList = new List <QuestInfo>();
if (useGroups)
{
var records = QuestLog.GetAllGroupsAndQuests(questStateMask, true);
foreach (var record in records)
{
if (!IsQuestVisible(record.questTitle))
{
continue;
}
questList.Add(GetQuestInfo(record.groupName, record.questTitle));
}
}
else
{
string[] titles = QuestLog.GetAllQuests(questStateMask, true, null);
foreach (var title in titles)
{
if (!IsQuestVisible(title))
{
continue;
}
questList.Add(GetQuestInfo(string.Empty, title));
}
}
quests = questList.ToArray();
OnQuestListUpdated();
}
/// <summary>
/// Gets the localized quest description for a specific state.
/// </summary>
/// <returns>
/// The quest description.
/// </returns>
/// <param name='title'>
/// Title of the quest.
/// </param>
/// <param name='state'>
/// State to check.
/// </param>
public static string GetQuestDescription(string title, QuestState state)
{
string descriptionFieldName = GetDefaultDescriptionFieldForState(state);
string result = DialogueLua.GetLocalizedQuestField(title, descriptionFieldName).AsString;
return((string.Equals(result, "nil") || string.IsNullOrEmpty(result)) ? null : result);
}
public static bool GetQuestActionFoldout(QuestState questState)
{
var list = data.actionFoldouts;
VerifyListSize(list, (int)questState, true);
return(list[(int)questState]);
}
protected virtual IEnumerator RefreshAtEndOfFrame()
{
yield return(new WaitForEndOfFrame());
// Move instances to the unused list:
unusedInstances.AddRange(instantiatedItems);
instantiatedItems.Clear();
siblingIndexCounter = 0;
// Add quests, drawing from unused list when possible:
int numTracked = 0;
QuestState flags = (showActiveQuests ? QuestState.Active : 0) |
(showCompletedQuests ? QuestState.Success | QuestState.Failure : 0);
foreach (string quest in QuestLog.GetAllQuests(flags))
{
if (QuestLog.IsQuestTrackingEnabled(quest))
{
AddQuestTrack(quest);
numTracked++;
}
}
if (container != null)
{
container.gameObject.SetActive(showContainerIfEmpty || numTracked > 0);
}
// Destroy remaining unused instances:
for (int i = 0; i < unusedInstances.Count; i++)
{
Destroy(unusedInstances[i].gameObject);
}
unusedInstances.Clear();
refreshCoroutine = null;
}
public static bool GetQuestContentFoldout(QuestContentCategory category, QuestState questState)
{
var list = GetQuestContentFoldoutList(category);
VerifyListSize(list, (int)questState, false);
return(list[(int)questState]);
}
public static QuestRewards Parse(int id, WZProperty data, QuestState state)
{
if (data == null)
{
return(null);
}
QuestRewards result = new QuestRewards();
result.Id = id;
result.State = state;
result.Message = data.ResolveForOrNull <string>("message");
result.Exp = data.ResolveFor <int>("exp");
result.BuffItemId = data.ResolveFor <int>("buffItemId");
result.charmExp = data.ResolveFor <int>("charmEXP");
result.SenseEXP = data.ResolveFor <int>("senseEXP");
result.Fame = data.ResolveFor <int>("pop");
result.PetSkill = data.ResolveFor <int>("petskill");
result.Items = data.Resolve("item")?.Children.Select(c => ItemReward.Parse(c));
result.Skills = data.Resolve("skill")?.Children.Select(c => SkillReward.Parse(c));
result.Meso = data.ResolveFor <int>("money");
result.MoveToMap = (uint?)data.ResolveFor <int>("transferField");
return(result);
}
private void UpdateQuestInfo(QuestState questState)
{
_questTitle.text = questState.QuestName;
_incompleteImage.enabled = questState.Status == QuestStatus.Ongoing;
_completedImage.enabled = questState.Status == QuestStatus.Completed;
_failedImage.enabled = questState.Status == QuestStatus.Failed;
}
public static int SaveQuestStatePreaction(QuestStatePreaction input, QuestState state)
{
IQuestRepository repo = new EFQuestRepository();
var questStatePreaction = repo.QuestStatePreactions.FirstOrDefault(q => q.Id == input.Id);
var dbState = repo.QuestStates.FirstOrDefault(s => s.Id == state.Id);
if (questStatePreaction == null)
{
questStatePreaction = new QuestStatePreaction();
}
questStatePreaction.Id = input.Id;
questStatePreaction.QuestId = input.QuestId;
questStatePreaction.QuestStateId = dbState;
questStatePreaction.QuestStatePreactionName = input.QuestStatePreactionName;
if (input.VariableName != null)
{
questStatePreaction.VariableName = input.VariableName.ToUpper();
}
questStatePreaction.AddOrSet = input.AddOrSet;
questStatePreaction.ActionType = input.ActionType;
questStatePreaction.ActionValue = input.ActionValue;
repo.SaveQuestStatePreaction(questStatePreaction);
return(questStatePreaction.Id);
}
public void SaveQuestState(QuestState QuestState)
{
if (QuestState.Id == 0)
{
context.QuestStates.Add(QuestState);
}
else
{
var editMe = context.QuestStates.Find(QuestState.Id);
if (editMe != null)
{
// dbEntry.Name = QuestState.Name;
// dbEntry.Message = QuestState.Message;
// dbEntry.TimeStamp = QuestState.TimeStamp;
}
}
try
{
context.SaveChanges();
}
catch (OptimisticConcurrencyException)
{
//context.(RefreshMode.ClientWins, dbModels.Models.QuestState);
//context.SaveChanges();
}
// context.SaveChanges();
}
public void AddEntryDescription(string text, QuestState entryState) {
if (entryContainer == null) {
// No container, so make entryDescription a big multi-line string:
alternateEntryDescriptions.SetActive(false);
if (entryDescription != null) {
if (numEntries == 0) {
entryDescription.gameObject.SetActive(true);
entryDescription.text = text;
} else {
entryDescription.text += "\n" + text;
}
}
} else {
// Instantiate into container:
if (numEntries == 0) {
entryContainer.gameObject.SetActive(true);
if (entryDescription != null) entryDescription.gameObject.SetActive(false);
alternateEntryDescriptions.SetActive(false);
}
switch (entryState) {
case QuestState.Active:
InstantiateFirstValidTextElement(text, entryContainer, entryDescription);
break;
case QuestState.Success:
InstantiateFirstValidTextElement(text, entryContainer, alternateEntryDescriptions.successDescription, entryDescription);
break;
case QuestState.Failure:
InstantiateFirstValidTextElement(text, entryContainer, alternateEntryDescriptions.failureDescription, entryDescription);
break;
}
}
numEntries++;
}
public QuestPlayer(int questId, QuestType questType, QuestState questState, QuestClearLimit questClearLimit)
{
this.questId = questId;
this.questType = questType;
this.questState = questState;
this.questClearLimit = questClearLimit;
}
public override QuestState SaveQuestState()
{
QuestState qs = base.SaveQuestState();
qs.questState = progress.ToString();
return(qs);
}
public void UpdateTracker()
{
// Move instances to the unused list:
unusedInstances.AddRange(instantiatedItems);
instantiatedItems.Clear();
siblingIndexCounter = 0;
// Add quests, drawing from unused list when possible:
int numTracked = 0;
QuestState flags = (showActiveQuests ? QuestState.Active : 0) |
(showCompletedQuests ? QuestState.Success | QuestState.Failure : 0);
foreach (string quest in QuestLog.GetAllQuests(flags))
{
if (QuestLog.IsQuestTrackingEnabled(quest))
{
AddQuestTrack(quest);
numTracked++;
}
}
if (container != null)
{
container.gameObject.SetActive(showContainerIfEmpty || numTracked > 0);
}
// Destroy remaining unused instances:
for (int i = 0; i < unusedInstances.Count; i++)
{
Destroy(unusedInstances[i].gameObject);
}
unusedInstances.Clear();
}
void QuestComplete()
{
// Set state to "completed" and proceed with needed animation and audio triggers.
questState = QuestState.Completed;
statusScreenAnimator.SetTrigger("Quest Completed");
audioSource.PlayOneShot(questCompleteAudioClip);
}
public QuestInstruction_UpdateStep(int stepNumber, QuestState state, bool hideRewards) : this()
{
this.StepNumber = stepNumber;
this.State = state;
this.HideRewards = hideRewards;
base.MustBeDelayed = (state == QuestState.Completed);
}
internal ProgressInfo(int rpID, QuestType rpResetType, QuestState rpState, int rpProgress, DateTimeOffset rpUpdateTime)
{
Quest = QuestProgressService.Instance.Infos[rpID];
ResetType = rpResetType;
r_State = rpState;
r_Progress = rpProgress;
UpdateTime = rpUpdateTime;
}
/// <summary>
/// Adds the given state(s) to the quest with the given ID (keeping any old states)
/// </summary>
/// <param name="id">The particular quest</param>
/// <param name="state">The state(s) to add</param>
public static void addQuestState(QuestID id, QuestState state)
{
nullCheck();
triggers[(int)id] |= state;
//push event
QuestEventArgs args = new QuestEventArgs();
args.questID = id;
args.questStateChange = state;
args.add = true;
pushEvent(args);
}
internal ProgressInfo(int rpID, QuestType rpResetType, QuestState rpState, int rpProgress, DateTimeOffset rpUpdateTime)
{
QuestInfo rQuest;
if (QuestProgressService.Instance.Infos.TryGetValue(rpID, out rQuest))
Quest = rQuest;
else
Quest = new QuestInfo(rpID);
r_ResetType = rpResetType;
r_State = rpState;
r_Progress = rpProgress;
UpdateTime = rpUpdateTime;
}
public Quest(int questId, long uniqueId, QuestState state)
{
this.Id = questId;
this.UniqueId = uniqueId;
this.State = state;
this.Data = ChannelServer.Instance.ScriptManager.GetQuestScript(this.Id);
if (this.Data == null)
throw new Exception("Quest '" + questId.ToString() + "' does not exist.");
_progresses = new OrderedDictionary<string, QuestObjectiveProgress>();
foreach (var objective in this.Data.Objectives)
_progresses[objective.Key] = new QuestObjectiveProgress(objective.Key);
_progresses[0].Unlocked = true;
}
public void SetDescription(string text, QuestState questState) {
if (text == null) return;
switch (questState) {
case QuestState.Active:
SetFirstValidTextElement(text, description);
break;
case QuestState.Success:
SetFirstValidTextElement(text, alternateDescriptions.successDescription, description);
break;
case QuestState.Failure:
SetFirstValidTextElement(text, alternateDescriptions.failureDescription, description);
break;
default:
return;
}
}
public void progressState() {
switch (state) {
case(QuestState.Inactive):
state = QuestState.Prologue;
break;
case(QuestState.Prologue):
state = QuestState.Active;
break;
case(QuestState.Active):
state = QuestState.Finished;
questManager.receiveDialogue(progressDialogue());
break;
}
Debug.Log (state.ToString ());
stageDialogueComplete = false;
}
/// <summary>
/// Gets the localized quest description for a specific state.
/// </summary>
/// <returns>
/// The quest description.
/// </returns>
/// <param name='title'>
/// Title of the quest.
/// </param>
/// <param name='state'>
/// State to check.
/// </param>
public static string GetQuestDescription(string title, QuestState state)
{
string descriptionFieldName = GetDefaultDescriptionFieldForState(state);
string result = DialogueLua.GetLocalizedQuestField(title, descriptionFieldName).AsString;
return (string.Equals(result, "nil") || string.IsNullOrEmpty(result)) ? null : result;
}
/// <summary>
/// Reports whether a quest's current state is one of the states marked in a state bit mask.
/// </summary>
/// <returns>
/// <c>true</c> if the quest's current state is in the state bit mask.
/// </returns>
/// <param name='title'>
/// Title of the quest.
/// </param>
/// <param name='stateMask'>
/// A QuestState bit mask (e.g., <c>QuestState.Success | QuestState.Failure</c>).
/// </param>
public static bool IsQuestInStateMask(string title, QuestState stateMask)
{
QuestState state = GetQuestState(title);
return ((stateMask & state) == state);
}
protected override void ReadPacket(BinaryReader reader)
{
Quest = new ClientQuestProgress(reader);
QuestState = (QuestState)reader.ReadByte();
TrackQuest = reader.ReadBoolean();
}
/// <summary>
/// Sendet ein Quest Update zum angegebenen Quest an diesen Client.
/// </summary>
/// <param name="quest">Quest.</param>
/// <param name="progress">Progress.</param>
/// <param name="state">State.</param>
public void SendQuestUpdate(string quest, string progress, QuestState state)
{
try
{
// QuestId[string];Progress[string];State[byte]
writer.Write((byte)MessageType.ServerQuestUpdate);
writer.Write((short)0);
writer.Write(quest);
writer.Write(progress);
writer.Write((byte)state);
int contentend = (int)writerStream.Position;
writerStream.Seek(1, SeekOrigin.Begin);
writer.Write((short)(contentend - 3));
writerStream.Seek(contentend, SeekOrigin.Begin);
Flush();
}
catch (Exception ex)
{
Close(ex, false);
}
}
/// <summary>
/// Adds a quest to the Lua Item[] table.
/// </summary>
/// <param name='title'>
/// Title of the quest.
/// </param>
/// <param name='description'>
/// Description of the quest.
/// </param>
/// <param name='state'>
/// Quest state.
/// </param>
/// <example>
/// QuestLog.AddQuest("Kill 5 Rats", "The baker asked me to bring 5 rat corpses.", QuestState.Unassigned);
/// </example>
public static void AddQuest(string title, string description, QuestState state)
{
if (!string.IsNullOrEmpty(title)) {
Lua.Run(string.Format("Item[\"{0}\"] = {{ Name = \"{1}\", Description = \"{2}\", State = \"{3}\" }}",
new System.Object[] { DialogueLua.StringToTableIndex(title),
DialogueLua.DoubleQuotesToSingle(title),
DialogueLua.DoubleQuotesToSingle(description),
StateToString(state) }),
DialogueDebug.LogInfo);
}
}
/// <summary>
/// Gets an array of all quests matching the specified state bitmask.
/// </summary>
/// <returns>The titles of all quests matching the specified state bitmask, sorted by Name.</returns>
/// <param name="flags">A bitmask of QuestState values.</param>
/// <example>
/// string[] completedQuests = QuestLog.GetAllQuests( QuestState.Success | QuestState.Failure );
/// </example>
public static string[] GetAllQuests(QuestState flags)
{
return GetAllQuests(flags, true);
}
/// <summary>
/// Sets the quest state.
/// </summary>
/// <param name='title'>
/// Title of the quest.
/// </param>
/// <param name='state'>
/// New state.
/// </param>
/// <example>
/// if (PiedPiperIsFree) {
/// QuestLog.SetQuestState("Kill 5 Rats", QuestState.Failure);
/// }
/// </example>
public static void SetQuestState(string title, QuestState state)
{
DialogueLua.SetQuestField(title, "State", StateToString(state));
SendUpdateTracker();
}
/*public dynamic Serialize()
{
dynamic result = new ExpandoObject();
result.id = questId;
result.state = state;
return result;
}*/
public ObjectInstanceQuest(dynamic json)
{
this.questId = json.id;
this.state = json.state;
}
internal void ResetByProgress(QuestState rpState, QuestProgress rpProgress)
{
if (ID == 214)
return;
var rLimit = (int)Math.Ceiling(Total * 0.5);
if (rpProgress == QuestProgress.Progress50 && Current < rLimit)
CurrentInternal = rLimit;
rLimit = (int)Math.Ceiling(Total * 0.8);
if (rpProgress == QuestProgress.Progress80 && Current < rLimit)
CurrentInternal = rLimit;
rLimit = Total;
if (rpState == QuestState.Completed && Current < rLimit)
CurrentInternal = rLimit;
State = rpState;
}
internal void ResetByDate()
{
var rResetState = false;
var rNow = DateTimeOffset.Now.ToOffset(TimeZoneOffset);
if (!UpdateTime.HasValue)
Current = 0;
else
{
var rUpdateTime = UpdateTime.Value;
DateTimeOffset rResetTime;
switch (Type)
{
case QuestType.Daily:
case QuestType.Special1:
case QuestType.Special2:
rResetTime = new DateTimeOffset(rNow.Year, rNow.Month, rNow.Day, 5, 0, 0, TimeZoneOffset);
if (rNow.Hour < 5)
rResetTime -= TimeSpan.FromDays(1.0);
rResetState = rUpdateTime < rResetTime;
break;
case QuestType.Weekly:
var rOffset = rNow.DayOfWeek - DayOfWeek.Monday;
if (rOffset < 0)
rOffset += 7;
rResetTime = rNow.AddDays(-1 * rOffset) - rNow.TimeOfDay + ResetHour;
rResetState = rUpdateTime < rResetTime;
break;
case QuestType.Monthly:
rResetTime = new DateTimeOffset(rNow.Year, rNow.Month, 1, 5, 0, 0, TimeZoneOffset);
if (rNow.Hour < 5)
rResetTime = rResetTime.AddMonths(-1);
rResetState = rUpdateTime < rResetTime;
break;
}
}
if (rResetState)
{
DebugUtil.Log(string.Format("任务 {0}: 被重置 原时间={1}", ID, UpdateTime.Value));
StateInternal = QuestState.None;
CurrentInternal = 0;
UpdateTime = rNow;
RecordManager.Instance.Quest.UpdateProgress(this);
RecordManager.Instance.Quest.UpdateStatus(this);
}
}
/// <summary>
/// Converts a state to its string representation.
/// </summary>
/// <returns>
/// The string representation (e.g., "active").
/// </returns>
/// <param name='state'>
/// The state (e.g., <c>QuestState.Active</c>).
/// </param>
public static string StateToString(QuestState state)
{
switch (state) {
case QuestState.Unassigned: return UnassignedStateString;
case QuestState.Active: return ActiveStateString;
case QuestState.Success: return SuccessStateString;
case QuestState.Failure: return FailureStateString;
case QuestState.Abandoned: return AbandonedStateString;
default: return UnassignedStateString;
}
}
private static string GetDefaultDescriptionFieldForState(QuestState state)
{
switch (state) {
case QuestState.Success:
return "Success_Description";
case QuestState.Failure:
return "Failure_Description";
default:
return "Description";
}
}
/// <summary>
/// Gets an array of all quests matching the specified state bitmask.
/// </summary>
/// <returns>The titles of all quests matching the specified state bitmask.</returns>
/// <param name='flags'>A bitmask of QuestState values.</param>
/// <param name='sortByName'>If `true`, sorts the titles by name.</param>
/// <example>
/// string[] completedQuests = QuestLog.GetAllQuests( QuestState.Success | QuestState.Failure, true );
/// </example>
public static string[] GetAllQuests(QuestState flags, bool sortByName)
{
List<string> titles = new List<string>();
LuaTableWrapper itemTable = Lua.Run("return Item").AsTable;
if (!itemTable.IsValid) {
if (DialogueDebug.LogWarnings) Debug.LogWarning(string.Format("{0}: Quest Log couldn't access Lua Item[] table. Has the Dialogue Manager loaded a database yet?", new System.Object[] { DialogueDebug.Prefix }));
return titles.ToArray();
}
foreach (var itemTableValue in itemTable.Values) {
LuaTableWrapper fields = itemTableValue as LuaTableWrapper;
if (fields == null) continue;
string title = null;
bool isItem = false;
try {
object titleObject = fields["Name"];
title = (titleObject != null) ? titleObject.ToString() : string.Empty;
isItem = false;
object isItemObject = fields["Is_Item"];
if (isItemObject != null) {
if (isItemObject.GetType() == typeof(bool)) {
isItem = (bool) isItemObject;
} else {
isItem = Tools.StringToBool(isItemObject.ToString());
}
}
} catch {}
if (!isItem) {
if (string.IsNullOrEmpty(title)) {
if (DialogueDebug.LogWarnings) Debug.LogWarning(string.Format("{0}: A quest title (item name in Item[] table) is null or empty", new System.Object[] { DialogueDebug.Prefix }));
} else if (IsQuestInStateMask(title, flags)) {
titles.Add(title);
}
}
}
if (sortByName) titles.Sort();
return titles.ToArray();
}
public static void unpackDefaultData()
{
HeroSave hSave = new HeroSave();
hSave.x = 25 * 32;
hSave.y = 4 * 32;
hSave.dir = Direction.North;
hSave.inventorySave = new Inventory().getSaveStructure();
hSave.monologueSave = new InnerMonologue().getSaveStructure();
hSave.name = "No name";
hSave.reputationSave = new int[] { 0, 0, 0, 0, 0 };
hSave.followerID = PersonID.None;
Hero.instance.loadSaveStructure(hSave);
KeyboardManager.loadDefaultKeys();
QuestState[] defQuests = new QuestState[Quest.NUM_QUEST_IDS]; //should all be 0 when initialized
defQuests[(int)QuestID.FoodFight] = QuestState.Available;
Quest.loadQuestStateSave(defQuests);
WorldManager.clearMaps();
WorldManager.setRoomNoTransition(PlaceID.StudentLounge);
GameClock.renewClock();
CharacterBankSave characterSave = new CharacterBankSave();
characterSave.char_x = new int[CharacterManager.NUM_PERSON_IDS];
characterSave.char_y = new int[CharacterManager.NUM_PERSON_IDS];
characterSave.char_room = new PlaceID[CharacterManager.NUM_PERSON_IDS];
characterSave.char_x[(int)PersonID.Phil] = 23 * 32;
characterSave.char_y[(int)PersonID.Phil] = 7 * 32;
characterSave.char_room[(int)PersonID.Phil] = PlaceID.Cafeteria;
characterSave.char_x[(int)PersonID.Librarian] = 4 * 32;
characterSave.char_y[(int)PersonID.Librarian] = 4 * 32;
characterSave.char_room[(int)PersonID.Librarian] = PlaceID.Library;
characterSave.char_x[(int)PersonID.Artie] = 12 * 32;
characterSave.char_y[(int)PersonID.Artie] = 8 * 32;
characterSave.char_room[(int)PersonID.Artie] = PlaceID.Cafeteria;
characterSave.char_x[(int)PersonID.Bill] = 16 * 32;
characterSave.char_y[(int)PersonID.Bill] = 14 * 32;
characterSave.char_room[(int)PersonID.Bill] = PlaceID.Cafeteria;
characterSave.char_x[(int)PersonID.Claude] = 25 * 32;
characterSave.char_y[(int)PersonID.Claude] = 18 * 32;
characterSave.char_room[(int)PersonID.Claude] = PlaceID.Cafeteria;
characterSave.char_x[(int)PersonID.Jay1] = 4 * 32;
characterSave.char_y[(int)PersonID.Jay1] = 18 * 32;
characterSave.char_room[(int)PersonID.Jay1] = PlaceID.Cafeteria;
characterSave.char_x[(int)PersonID.Jay2] = 10 * 32;
characterSave.char_y[(int)PersonID.Jay2] = 2 * 32;
characterSave.char_room[(int)PersonID.Jay2] = PlaceID.Cafeteria;
characterSave.char_x[(int)PersonID.Jay3] = 14 * 32;
characterSave.char_y[(int)PersonID.Jay3] = 18 * 32;
characterSave.char_room[(int)PersonID.Jay3] = PlaceID.Cafeteria;
characterSave.char_x[(int)PersonID.Jay4] = 20 * 32;
characterSave.char_y[(int)PersonID.Jay4] = 2 * 32;
characterSave.char_room[(int)PersonID.Jay4] = PlaceID.Cafeteria;
characterSave.char_x[(int)PersonID.BraceFace] = 10 * 32;
characterSave.char_y[(int)PersonID.BraceFace] = 10 * 32;
characterSave.char_room[(int)PersonID.BraceFace] = PlaceID.Math;
characterSave.char_x[(int)PersonID.Fitz] = 19 * 32;
characterSave.char_y[(int)PersonID.Fitz] = 13 * 32;
characterSave.char_room[(int)PersonID.Fitz] = PlaceID.ComputerLab;
characterSave.char_x[(int)PersonID.ROB] = 8 * 32;
characterSave.char_y[(int)PersonID.ROB] = 11 * 32;
characterSave.char_room[(int)PersonID.ROB] = PlaceID.Science;
characterSave.char_x[(int)PersonID.Enforcer] = 11 * 32;
characterSave.char_y[(int)PersonID.Enforcer] = 49 * 32;
characterSave.char_room[(int)PersonID.Enforcer] = PlaceID.HallwayWest;
characterSave.char_x[(int)PersonID.Tyke] = 11 * 32;
characterSave.char_y[(int)PersonID.Tyke] = 6 * 32;
characterSave.char_room[(int)PersonID.Tyke] = PlaceID.Entrance;
characterSave.char_x[(int)PersonID.Dyke] = 18 * 32;
characterSave.char_y[(int)PersonID.Dyke] = 11 * 32;
characterSave.char_room[(int)PersonID.Dyke] = PlaceID.StudentLounge;
characterSave.char_x[(int)PersonID.Shaq] = 23 * 32;
characterSave.char_y[(int)PersonID.Shaq] = 3 * 32;
characterSave.char_room[(int)PersonID.Shaq] = PlaceID.HallwayEast;
characterSave.char_x[(int)PersonID.Herbert] = 3 * 32;
characterSave.char_y[(int)PersonID.Herbert] = 40 * 32;
characterSave.char_room[(int)PersonID.Herbert] = PlaceID.HallwayWest;
characterSave.char_x[(int)PersonID.Avery] = 8 * 32;
characterSave.char_y[(int)PersonID.Avery] = 7 * 32;
characterSave.char_room[(int)PersonID.Avery] = PlaceID.StudentLounge;
characterSave.char_x[(int)PersonID.Boris] = 25 * 32;
characterSave.char_y[(int)PersonID.Boris] = 5 * 32;
characterSave.char_room[(int)PersonID.Boris] = PlaceID.Entrance;
characterSave.char_x[(int)PersonID.Jarvis] = 17 * 32;
characterSave.char_y[(int)PersonID.Jarvis] = 15 * 32;
characterSave.char_room[(int)PersonID.Jarvis] = PlaceID.Entrance;
characterSave.char_x[(int)PersonID.Zeke] = 10 * 32;
characterSave.char_y[(int)PersonID.Zeke] = 4 * 32;
characterSave.char_room[(int)PersonID.Zeke] = PlaceID.Bathroom;
/*
Fitz,
ROB,
Enforcer,
Tyke,
Dyke,
Shaq,
Herbert,
Avery,
Boris,
Jarvis,
Zeke
*/
CharacterManager.loadSaveStructure(characterSave);
}
/// <summary>
/// Sets the state of the quest entry.
/// </summary>
/// <param name="questTitle">Title of the quest.</param>
/// <param name="entryNumber">Entry number.</param>
/// <param name="state">State.</param>
public static void SetQuestEntryState(string questTitle, int entryNumber, QuestState state)
{
DialogueLua.SetQuestField(questTitle, GetEntryStateFieldName(entryNumber), StateToString(state));
SendUpdateTracker();
}
private string GetQuestEntryText(string quest, int entryNum, QuestState entryState)
{
if (entryState == QuestState.Unassigned || entryState == QuestState.Abandoned) {
return string.Empty;
} else if (entryState == QuestState.Success && showCompletedEntryText) {
var text = DialogueLua.GetQuestField(quest, "Entry " + entryNum + " Success").AsString;
if (!string.IsNullOrEmpty(text)) return text;
} else if (entryState == QuestState.Failure && showCompletedEntryText) {
var text = DialogueLua.GetQuestField(quest, "Entry " + entryNum + " Failure").AsString;
if (!string.IsNullOrEmpty(text)) return text;
}
return QuestLog.GetQuestEntry(quest, entryNum);
}
private string GetTitleStyleName(QuestState state) {
switch (state) {
case QuestState.Active: return TitleStyle;
case QuestState.Success: return SuccessTitleStyle;
case QuestState.Failure: return FailureTitleStyle;
default: return TitleStyle;
}
}
/// <summary>
/// Sets the quest description for a specified state.
/// </summary>
/// <param name='title'>
/// Title of the quest.
/// </param>
/// <param name='state'>
/// Set the description for this state (i.e., regular, success, or failure).
/// </param>
/// <param name='description'>
/// The description.
/// </param>
public static void SetQuestDescription(string title, QuestState state, string description)
{
DialogueLua.SetQuestField(title, GetDefaultDescriptionFieldForState(state), description);
}
protected void returnToDefault() {
foreach (Objective o in inactiveObjectives) {
o.resetObjective();
}
foreach (Objective o in prologueObjectives) {
o.resetObjective();
}
foreach (Objective o in activeObjectives) {
o.resetObjective();
}
readyForCutscene = false;
currentInactiveObj = 0;
currentPrologueObj = 0;
currentActiveObj = 0;
currentInactiveLine = 0;
currentPrologueLine = 0;
currentActiveLine = 0;
state = QuestState.Inactive;
}
private string GetEntryStyleName(QuestState entryState) {
switch (entryState) {
case QuestState.Active: return ActiveEntryStyle;
case QuestState.Success: return SuccessEntryStyle;
case QuestState.Failure: return FailureEntryStyle;
default: return ActiveEntryStyle;
}
}
public ObjectInstanceQuest(int questId, QuestState state)
{
this.questId = questId;
this.state = state;
}
public void SendUpdateQuest(QuestProgressInfo quest, QuestState state, bool trackQuest = false)
{
quest.CheckCompleted();
Enqueue(new S.ChangeQuest
{
Quest = quest.CreateClientQuestProgress(),
QuestState = state,
TrackQuest = trackQuest
});
}
private void SetupProperties()
{
State = QuestState.Unavailable;
Goal = new QuestGoal();
Prize = new QuestPrize();
}
