Пример #1
0
        private string _handleToonMessage(string[] sections)
        {
            switch (sections[1])
            {
            case "SETQUESTCOMPLETED":
                int                 questId  = Convert.ToInt32(sections[3]);
                string              toonName = sections[2];
                QuestDefinition     quest    = _questRepository.GetByRomId(questId);
                CharacterDefinition toon     = _characterRepository.FindByName(toonName);
                if (toon == null)
                {
                    toon      = new CharacterDefinition();
                    toon.Name = toonName;
                    LogManager.GetLogger(typeof(RomMessageProcessor)).Warn("Could not load character: " + toonName + " so created a new one.");
                }
                if (!toon.CompletedQuests.Contains(quest))
                {
                    toon.CompletedQuests.Add(quest);
                    _characterRepository.Update(toon);
                }
                break;
            }

            return(null);
        }
 private void Start()
 {
     questsScreenController = GetComponentInParent <QuestsScreenController>();
     questsScreenController.GetComponent <MainNavBarBackButtonEventToFSMEvent>().enabled = false;
     currentMascot = Service.Get <MascotService>().ActiveMascot;
     if (currentMascot == null)
     {
         string currentMascotID = questsScreenController.CurrentMascotID;
         if (!string.IsNullOrEmpty(currentMascotID))
         {
             currentMascot = Service.Get <MascotService>().GetMascot(currentMascotID);
         }
     }
     currentChapter = questsScreenController.CurrentChapterData;
     if (currentMascot != null)
     {
         if (currentChapter.Number > 0)
         {
             LoadQuestsForMascot(currentMascot.Name, currentChapter.Number);
             return;
         }
         QuestDefinition nextAvailableQuest = currentMascot.GetNextAvailableQuest();
         int             chapterNumber      = ((nextAvailableQuest != null) ? (nextAvailableQuest.ChapterNumber - 1) : currentMascot.Definition.ChapterData[currentMascot.Definition.ChapterData.Length - 1].Number);
         LoadQuestsForMascot(currentMascot.Name, chapterNumber);
     }
 }
Пример #3
0
    public QuestDefinition GetNextAvailableQuest(int chapterNumber = -1)
    {
        Quest                  quest       = null;
        QuestDefinition        result      = null;
        List <QuestDefinition> validQuests = GetValidQuests(chapterNumber);

        for (int i = 0; i < validQuests.Count; i++)
        {
            QuestDefinition questDefinition = validQuests[i];
            foreach (Quest availableQuest in AvailableQuests)
            {
                if (availableQuest.Definition.name == questDefinition.name)
                {
                    quest = availableQuest;
                    break;
                }
            }
            if (quest == null || quest.State == Quest.QuestState.Locked || quest.TimesCompleted == 0)
            {
                result = questDefinition;
                break;
            }
            quest = null;
        }
        return(result);
    }
Пример #4
0
        public override void OnAddUser(AgentPrivate agent)
        {
            try
            {
                if (!PerUserStatus.ContainsKey(agent.AgentInfo.SessionId))
                {
                    PerUserStatus[agent.AgentInfo.SessionId] = new Status();
                }

                for (int i = 0; i < Definitions.Count; ++i)
                {
                    QuestDefinition def = Definitions[i];
                    if (!def.IsValid || !def.Ready)
                    {
                        Log.Write(LogLevel.Warning, "Error getting quest state for quest for user " + agent.AgentInfo.Name + " : " + agent.AgentInfo.AvatarUuid);
                    }
                    int Index = i;
                    if (agent != null && agent.IsValid)
                    {
                        def.GetQuest(agent, (data) => HandleQuest(data, Index));
                    }
                }
            }
            catch (Exception)
            {
                if (agent != null)
                { // The following are cached and okay to access as long as agent itself isn't null
                    Log.Write(LogLevel.Warning, "Error getting quest state for quest for user " + agent.AgentInfo.Name + " : " + agent.AgentInfo.AvatarUuid);
                }
                else
                {
                    Log.Write(LogLevel.Warning, "Error getting quest state for quest: agent is null");
                }
            }
        }
        public void LoadQuestsForMascot(string mascotID, int chapterNumber)
        {
            clearCurrentLog();
            Mascot mascot = Service.Get <MascotService>().GetMascot(mascotID);

            LogPanel.SetActive(value: true);
            QuestDefinition        nextAvailableQuest = mascot.GetNextAvailableQuest(chapterNumber);
            int                    num         = ((nextAvailableQuest != null) ? (nextAvailableQuest.QuestNumber - 1) : (-1));
            List <QuestDefinition> validQuests = mascot.GetValidQuests(chapterNumber);

            totalAdventuresItems = validQuests.Count;
            adventureItemsLoaded = 0;
            if (num != -1)
            {
                scrollPosition = (float)num / (float)(totalAdventuresItems - 1);
            }
            else
            {
                scrollPosition = 0f;
            }
            for (int i = 0; i < validQuests.Count; i++)
            {
                CoroutineRunner.Start(loadQuestLogAdventureItem(validQuests[i]), this, "loadQuestLogAdventureItem");
            }
        }
Пример #6
0
        public void TestCanAddItem()
        {
            ISessionFactory fac     = RomViewContainer.Container.GetInstance <ISessionFactory>();
            ISession        session = fac.OpenSession();
            ITransaction    tx      = session.BeginTransaction();

            CallSessionContext.Bind(session);

            try
            {
                IRepository <CharacterDefinition> rep = RomViewContainer.Container.GetInstance <IRepository <CharacterDefinition> >();

                CharacterDefinition def = new CharacterDefinition
                {
                    Name = "Remedial", Race = "Human"
                };

                IRepository <QuestDefinition> qRep = RomViewContainer.Container.GetInstance <IRepository <QuestDefinition> >();
                QuestDefinition dummy = new QuestDefinition()
                {
                    RomId = -1, Name = "TestQuest"
                };
                session.Save(dummy);

                def.CompletedQuests.Add(dummy);
                session.Save(def);
            }
            finally
            {
                tx.Rollback();
                session.Close();
            }
        }
Пример #7
0
    public void fullfill_quest_if_active(QuestDefinition questDefinition)
    {
        if (questDefinition == null)
        {
            //Quest definition doesn't exist.
            return;
        }

        // Debug.Log("Try to fullfill " + questDefinition.name);

        //faster version, only accessing active quests from additional List
        foreach (C_QuestState qs in questBook.activeQuests)
        {
            if (qs.quest == questDefinition)
            {
                //Debug.Log("Fullfill " + questDefinition.name);

                qs.activeState = E_QuestActiveState.finished;
                GenerateQuestEvent(qs.quest, E_QuestEventType.finished);
                qs.quest.fullfillmentResult.ExecuteEffect();
                questBook.activeQuests.Remove(qs);                      //remove quest from temporary activeQuest list
                createQuestFinishedPopup(qs);
                questsChanged();
                save();
                break;
            }
        }
        TryAutomaticRefill();
    }
Пример #8
0
        public QuestRewardsCollection QuestRewards(string questId)
        {
            QuestRewardsCollection result = default(QuestRewardsCollection);
            Dictionary <string, QuestDefinition> knownQuests = Service.Get <QuestService>().knownQuests;

            if (knownQuests.ContainsKey(questId))
            {
                QuestDefinition questDefinition = knownQuests[questId];
                if ((bool)questDefinition.StartReward)
                {
                    result.StartReward = questDefinition.StartReward.ToReward();
                }
                if ((bool)questDefinition.CompleteReward)
                {
                    result.CompleteReward = questDefinition.CompleteReward.ToReward();
                }
                result.ObjectiveRewards = new Dictionary <string, Reward>();
                if (questDefinition.ObjectiveRewards.Length > 0)
                {
                    Quest activeQuest = Service.Get <QuestService>().ActiveQuest;
                    if (activeQuest != null)
                    {
                        foreach (KeyValuePair <string, int> objectiveRewardIndex in activeQuest.ObjectiveRewardIndexes)
                        {
                            if (objectiveRewardIndex.Value >= 0 && objectiveRewardIndex.Value < questDefinition.ObjectiveRewards.Length)
                            {
                                result.ObjectiveRewards.Add(objectiveRewardIndex.Key, questDefinition.ObjectiveRewards[objectiveRewardIndex.Value].ToReward());
                            }
                        }
                    }
                }
            }
            return(result);
        }
Пример #9
0
        private void AddItemRequirement(QuestDefinition quest, byte itemGroup, short itemNumber, byte itemLevel, byte minimumMonsterLevel, byte maximumMonsterLevel)
        {
            var itemRequirement = this.AddItemRequirement(quest, itemGroup, itemNumber, itemLevel);
            var dropItemGroup   = itemRequirement.DropItemGroup;

            dropItemGroup.MinimumMonsterLevel = minimumMonsterLevel;
            dropItemGroup.MaximumMonsterLevel = maximumMonsterLevel;
        }
Пример #10
0
        private void AddItemRequirement(QuestDefinition quest, byte itemGroup, short itemNumber, byte itemLevel, short monsterNumber, double dropRate)
        {
            var itemRequirement = this.AddItemRequirement(quest, itemGroup, itemNumber, itemLevel);
            var dropItemGroup   = itemRequirement.DropItemGroup;

            dropItemGroup.Monster = this.GameConfiguration.Monsters.First(m => m.Number == monsterNumber);
            dropItemGroup.Chance  = dropRate;
        }
Пример #11
0
        /// <summary>
        /// Adds a <see cref="QuestReward"/> of <see cref="QuestRewardType.Money"/> to this quest definition.
        /// </summary>
        /// <param name="questDefinition">The quest definition.</param>
        /// <param name="moneyAmount">The money amount.</param>
        /// <param name="context">The context.</param>
        /// <returns>This quest definition.</returns>
        public static QuestDefinition WithMoneyReward(this QuestDefinition questDefinition, int moneyAmount, IContext context)
        {
            var reward = context.CreateNew <QuestReward>();

            reward.Value      = moneyAmount;
            reward.RewardType = QuestRewardType.Money;
            questDefinition.Rewards.Add(reward);
            return(questDefinition);
        }
Пример #12
0
        public void ImportFromQuestListXML()
        {
            ISessionFactory fac     = RomViewContainer.Container.GetInstance <ISessionFactory>();
            ISession        session = fac.OpenSession();
            ITransaction    tx      = session.BeginTransaction();

            CallSessionContext.Bind(session);
            //LazySessionContext.Bind(new Lazy<ISession>(() => session), fac);
            try
            {
                IRepository <QuestDefinition> rep  = RomViewContainer.Container.GetInstance <IRepository <QuestDefinition> >();
                IQuestRepository        repository = new QuestRepository(rep);
                IList <QuestDefinition> items      = repository.GetAll();

                string filename = "Data\\questlist.xml";
                if (!File.Exists(filename))
                {
                    throw new Exception("File missing");
                }

                list data = new list();
                data = list.LoadFromFile(filename);

                XmlDocument doc = new XmlDocument();
                doc.Load(filename);

                XmlNodeList quests = doc.SelectNodes("//romquest");

                foreach (XmlNode romquest in quests)
                {
                    int    id   = Convert.ToInt32(romquest.Attributes["id"].Value);
                    string name = romquest.Attributes["name"].Value;

                    QuestDefinition quest = items.FirstOrDefault(definition => definition.RomId == id);
                    if (quest == null)
                    {
                        quest = new QuestDefinition()
                        {
                            RomId = id, Name = name
                        };
                        repository.Add(quest);
                    }
                    else
                    {
                        quest.RomId = id;
                        quest.Name  = name;
                        repository.Update(quest);
                    }
                }

                tx.Commit();
            }
            finally
            {
                session.Close();
            }
        }
Пример #13
0
        /// <summary>
        /// Adds a <see cref="QuestReward"/> of <see cref="QuestRewardType.Experience"/> to this quest definition.
        /// </summary>
        /// <param name="questDefinition">The quest definition.</param>
        /// <param name="experienceAmount">The experience amount.</param>
        /// <param name="context">The context.</param>
        /// <returns>This quest definition.</returns>
        public static QuestDefinition WithExperienceReward(this QuestDefinition questDefinition, int experienceAmount, IContext context)
        {
            var reward = context.CreateNew <QuestReward>();

            reward.Value      = experienceAmount;
            reward.RewardType = QuestRewardType.Experience;
            questDefinition.Rewards.Add(reward);
            return(questDefinition);
        }
Пример #14
0
    public Quest(QuestListDefinition questListDefinition, QuestDefinition questDefinition, DateTime startTime, DateTime endTime, Inventory inventory)
    {
        m_QuestListDefinition = questListDefinition;
        m_QuestDefinition     = questDefinition;
        m_StartTime           = startTime;
        m_EndTime             = endTime;

        m_Inventory = inventory;
    }
Пример #15
0
    public Quest(QuestListDefinition questListDefinition, Inventory inventory)
    {
        m_QuestListDefinition = questListDefinition;
        m_QuestDefinition     = null;
        m_StartTime           = DateTime.MinValue;
        m_EndTime             = DateTime.MinValue;

        m_Inventory = inventory;
    }
Пример #16
0
        /// <summary>
        /// Adds a <see cref="QuestMonsterKillRequirement"/> to this quest definition.
        /// </summary>
        /// <param name="questDefinition">The quest definition.</param>
        /// <param name="amount">The amount.</param>
        /// <param name="monsterNumber">The monster number.</param>
        /// <param name="context">The context.</param>
        /// <param name="gameConfiguration">The game configuration.</param>
        /// <returns>This quest definition.</returns>
        public static QuestDefinition WithMonsterKillRequirement(this QuestDefinition questDefinition, int amount, int monsterNumber, IContext context, GameConfiguration gameConfiguration)
        {
            var spider = context.CreateNew <QuestMonsterKillRequirement>();

            spider.MinimumNumber = amount;
            spider.Monster       = gameConfiguration.Monsters.First(m => m.Number == monsterNumber);
            questDefinition.RequiredMonsterKills.Add(spider);
            return(questDefinition);
        }
Пример #17
0
    //load the state of all quests from the player prefs
    private void load()
    {
        bool alteredOnLoad = false;

        //load quests states from PlayerPrefs
        string json = SecurePlayerPrefs.GetString(jsonKey);

        if (!string.IsNullOrEmpty(json))
        {
            JsonUtility.FromJsonOverwrite(json, questBook);
        }

        //search through the catalog and add quests if they are new
        foreach (QuestDefinition questDefinition in catalog)
        {
            if (!IsQuestInQuestbook(questDefinition))
            {
                C_QuestState questState = new C_QuestState();
                questState.quest    = questDefinition;
                questState.questKey = questDefinition.name;
                questBook.quests.Add(questState);

                alteredOnLoad = true;
            }
        }

        //clear the temporary list for active quests
        questBook.activeQuests.Clear();

        //regenerate link to the scriptable object and search/add active quests to the temporary list
        foreach (C_QuestState qs in questBook.quests)
        {
            QuestDefinition quest = GetQuestFromCatalogByKey(qs.questKey);
            if (quest != null)
            {
                qs.quest             = quest;
                qs.loadedFromCatalog = true;

                //ifthe quest is active, also add it to the active list
                if (qs.activeState == E_QuestActiveState.active)
                {
                    questBook.activeQuests.Add(qs);
                }
            }
            else
            {
                qs.loadedFromCatalog = false;
            }
        }

        loaded = true;

        if (alteredOnLoad == true)
        {
            save();
        }
    }
        private void skinForQuest(QuestDefinition quest)
        {
            setRewardText(quest);
            int selectedIndexForMascot = getSelectedIndexForMascot(quest.Mascot);

            setTintSelectors(selectedIndexForMascot);
            setSpriteSelectors(selectedIndexForMascot);
            setGameObjectSelectors(selectedIndexForMascot);
            setTitleText(Service.Get <Localizer>().GetTokenTranslation(quest.Title));
        }
Пример #19
0
        /// <inheritdoc/>
        public void QuestCancelled(QuestDefinition quest)
        {
            if (quest.Group == QuestConstants.LegacyQuestGroup)
            {
                this.player.SelectedCharacter?.QuestStates.FirstOrDefault(q => q.Group == QuestConstants.LegacyQuestGroup)?.SendLegacyQuestState(this.player);
                return;
            }

            this.player.Connection?.SendQuestCancelled((ushort)quest.Number, (ushort)quest.Group);
        }
Пример #20
0
 /// <inheritdoc/>
 public void QuestStarted(QuestDefinition quest)
 {
     if (quest.Group == QuestConstants.LegacyQuestGroup)
     {
         this.player.Connection.SendLegacySetQuestStateResponse((byte)quest.Number, 0, this.player.GetLegacyQuestStateByte());
     }
     else
     {
         this.player.Connection.SendQuestStarted((ushort)quest.Number, (ushort)quest.Group);
     }
 }
Пример #21
0
    public void OnNewUser()
    {
        //TEMP
        QuestDefinition firstQuestDefinition = m_QuestListDefinition.GetQuestDefinition(0);
        Quest           quest = new Quest(m_QuestListDefinition, firstQuestDefinition, GameClock.Instance.GetDateTime(), firstQuestDefinition.CalculateDeadline(), m_Inventory);

        quest.QuestCompleteEvent += OnQuestCompleted;
        quest.QuestRemovedEvent  += OnQuestRewardClaimed;

        AddQuest(quest);
    }
Пример #22
0
 public bool IsQuestInQuestbook(QuestDefinition questDefinition)
 {
     foreach (C_QuestState qs in questBook.quests)
     {
         if (qs.questKey == questDefinition.name)
         {
             return(true);
         }
     }
     return(false);
 }
Пример #23
0
        private void applyLockedState()
        {
            int num = Service.Get <ProgressionService>().MascotLevel(questData.Mascot.name);

            if (num < questData.LevelRequirement)
            {
                LockedOverlay.SetActive(value: true);
                LevelLockIcon.SetActive(value: true);
                MemberLockIcon.SetActive(value: false);
                LevelLockIcon.GetComponentInChildren <Text>().text = questData.LevelRequirement.ToString();
                return;
            }
            Mascot          mascot          = null;
            QuestDefinition questDefinition = null;
            bool            flag            = false;
            bool            flag2           = false;

            for (int i = 0; i < questData.CompletedQuestRequirement.Length; i++)
            {
                questDefinition = questData.CompletedQuestRequirement[i];
                mascot          = mascotService.GetMascot(questDefinition.Mascot.name);
                foreach (Quest availableQuest in mascot.AvailableQuests)
                {
                    if (availableQuest.Definition.name == questDefinition.name)
                    {
                        flag = true;
                        if (availableQuest.TimesCompleted == 0)
                        {
                            flag2 = true;
                            break;
                        }
                    }
                }
            }
            if (flag2 || !flag)
            {
                OffTextNextQuest.SetActive(value: true);
                string tokenTranslation = Service.Get <Localizer>().GetTokenTranslation("QuestLog.CompleteQuest.Text");
                tokenTranslation = string.Format(tokenTranslation, Service.Get <Localizer>().GetTokenTranslation(questDefinition.AbbreviatedTitle));
                OffTextNextQuest.GetComponentInChildren <Text>().text = tokenTranslation;
            }
            else if (associatedQuest != null)
            {
                associatedQuest.UpdateLockedState();
                if (associatedQuest.State != Quest.QuestState.Locked)
                {
                    ShowState(associatedQuest.State);
                    return;
                }
                OffTextTime.SetActive(value: true);
                onTimerTick();
                CoroutineRunner.Start(updateTimer.Start(), this, "QuestLogItemTimer");
            }
        }
Пример #24
0
    public void Init(QuestDefinition quest)
    {
        QuestTitleText.text = Service.Get <Localizer>().GetTokenTranslation(quest.Title);
        CoinsText.text      = CoinRewardableDefinition.Coins(quest.CompleteReward).ToString();
        List <MascotXPRewardDefinition> definitions = quest.CompleteReward.GetDefinitions <MascotXPRewardDefinition>();

        XPText.text = definitions[0].XP.ToString();
        if (quest.isMemberOnly && !Service.Get <CPDataEntityCollection>().IsLocalPlayerMember())
        {
            LockedOverlay.SetActive(value: true);
        }
    }
Пример #25
0
    private void OnQuestRewardClaimed(Quest quest)
    {
        RemoveQuest(quest);

        //TEMP, START A NEW QUEST
        QuestDefinition firstQuestDefinition = m_QuestListDefinition.GetQuestDefinition(1);

        quest = new Quest(m_QuestListDefinition, firstQuestDefinition, GameClock.Instance.GetDateTime(), firstQuestDefinition.CalculateDeadline(), m_Inventory);
        quest.QuestCompleteEvent += OnQuestCompleted;
        quest.QuestRemovedEvent  += OnQuestRewardClaimed;

        AddQuest(quest);
    }
Пример #26
0
    public void Deserialize(JSONClass questNode)
    {
        //Quest ID
        int id = (questNode["quest_id"].AsInt);

        m_QuestDefinition = m_QuestListDefinition.GetQuestDefinition(id);

        //Start Time
        JSONNode startTimeNode = questNode["start_time"];

        if (startTimeNode != null)
        {
            try
            {
                m_StartTime = DateTime.ParseExact(startTimeNode.Value, "dd/MM/yyyy HH:mm:ss", CultureInfo.InvariantCulture);
            }
            catch (Exception e)
            {
                throw new System.Exception("The quest save file has an invalid \"start_time\" node! Expected DateTime. Source: " + startTimeNode.ToString() + " Exception: " + e.Message);
            }
        }

        //Deadline
        JSONNode endTimeNode = questNode["end_time"];

        if (endTimeNode != null)
        {
            try
            {
                m_EndTime = DateTime.ParseExact(endTimeNode.Value, "dd/MM/yyyy HH:mm:ss", CultureInfo.InvariantCulture);
            }
            catch (Exception e)
            {
                throw new System.Exception("The quest save file has an invalid \"end_time\" node! Expected DateTime. Source: " + endTimeNode.ToString() + " Exception: " + e.Message);
            }
        }

        //Selected picture
        JSONClass pictureNode = questNode["selected_picture"].AsObject;

        if (pictureNode != null)
        {
            Picture picture = new Picture();
            bool    success = picture.Deserialize(pictureNode);

            if (success)
            {
                m_SelectedPicture = picture;
            }
        }
    }
        private QuestDefinition getAvailableQuest()
        {
            List <Mascot>   list            = Service.Get <MascotService>().Mascots.ToList();
            QuestDefinition questDefinition = null;

            do
            {
                int    index  = UnityEngine.Random.Range(0, list.Count);
                Mascot mascot = list[index];
                list.RemoveAt(index);
                questDefinition = mascot.GetNextAvailableQuest();
            }while (questDefinition == null && list.Count > 0);
            return(questDefinition);
        }
Пример #28
0
    public int GetID(QuestDefinition QuestDefinition)
    {
        if (m_QuestList == null)
        {
            return(-1);
        }

        if (QuestDefinition == null)
        {
            return(-1);
        }

        return(m_QuestList.IndexOf(QuestDefinition));
    }
Пример #29
0
        private IEnumerator loadQuest(QuestDefinition quest)
        {
            AssetRequest <GameObject> assetRequest = Content.LoadAsync(RewardPopupConstants.RewardPopupQuestsContentKey, quest.Mascot.AbbreviatedName);

            yield return(assetRequest);

            GameObject itemGO = Object.Instantiate(assetRequest.Asset);

            itemGO.transform.SetParent(ItemParentTransform, worldPositionStays: false);
            RewardPopupQuestsItem item = itemGO.GetComponent <RewardPopupQuestsItem>();

            item.Init(quest);
            items.Add(item);
        }
Пример #30
0
 private void addAvailableQuestWidget(Dictionary <CellPhoneActivityDefinition, int> widgetToPriority)
 {
     if (definition.AvailableQuestPriority != ActivityScreenPriorities.Hidden)
     {
         QuestDefinition availableQuest = getAvailableQuest();
         if (availableQuest != null)
         {
             CellPhoneQuestActivityDefinition cellPhoneQuestActivityDefinition = ScriptableObject.CreateInstance <CellPhoneQuestActivityDefinition>();
             cellPhoneQuestActivityDefinition.Quest           = availableQuest;
             cellPhoneQuestActivityDefinition.WidgetPrefabKey = definition.AvailableQuestWidgetKey;
             widgetToPriority.Add(cellPhoneQuestActivityDefinition, (int)definition.AvailableQuestPriority);
         }
     }
 }
Пример #31
0
 public Quest(QuestDefinition.QuestDef qd)
 {
     id = qd.id;
     name = qd.name;
     talk = qd.talk;
     talk_completed = qd.talk_done;
     talk_noncompleted = qd.talk_notdone;
     ok_content = qd.btn_ok_content;
     cancel_content = qd.btn_cancel_content;
     Next = qd.next;
     /*Type type = Type.GetType("demo.quest." + qd.actionfunc);
     if (type != null)
     {
         QuestScript s = type.Assembly.CreateInstance("demo.quest." + qd.actionfunc) as QuestScript;
         if (s != null)
         {
             s.Quest = this;
             s.Initialize();
             this.script = s;
         }
     }*/
     scriptname = qd.actionfunc;
 }
Пример #32
0
 // methods
 public Quest(QuestDefinition definition)
 {
     this._definition = definition;
 }