Ejemplo n.º 1
0
        // 触发NPC后得到回应
        public void recvNPCResponse(string strRes)
        {
            if (strRes == null)
            {
                return;
            }

            // 处理NPC返回的数据
            NPCResponse res = new NPCResponse(strRes);

            UNPCResponseData data = new UNPCResponseData();

            data.msgID   = (int)WndMsgID.WND_MSG_NPC_RESPONSE;
            data.npcResp = res;

            UISystem.Instance.SendWndMessage(WndMsgID.WND_MSG_NPC_RESPONSE, data);
        }
        private static void Export_Dialogues(IEnumerable <NPCDialogue> dialogues)
        {
            foreach (NPCDialogue dialogue in dialogues)
            {
                try
                {
                    Directory.CreateDirectory(dir + $@"Dialogues\{dialogue.guid}_{dialogue.id}");
                    using (StreamWriter asset = new StreamWriter(dir + $@"Dialogues\{dialogue.guid}_{dialogue.id}\Asset.dat", false, Encoding.UTF8))
                        using (StreamWriter local = new StreamWriter(dir + $@"Dialogues\{dialogue.guid}_{dialogue.id}\English.dat", false, Encoding.UTF8))
                        {
                            asset.WriteLine(WaterText);
                            local.WriteLine(WaterText);
                            if (AppConfig.Instance.generateGuids)
                            {
                                asset.WriteLine($"GUID {dialogue.guid}");
                            }

                            asset.WriteLine($"Type Dialogue");
                            asset.WriteLine($"ID {dialogue.id}");

                            if (dialogue.MessagesAmount > 0)
                            {
                                asset.WriteLine($"Messages {dialogue.MessagesAmount}");
                                for (int k = 0; k < dialogue.MessagesAmount; k++)
                                {
                                    NPCMessage message = dialogue.messages[k];
                                    if (message.PagesAmount > 0)
                                    {
                                        asset.WriteLine($"Message_{k}_Pages {message.PagesAmount}");
                                    }
                                    List <NPCResponse> visibleResponses = dialogue.responses.Where(d => d.VisibleInAll || d.visibleIn.Length <= k || d.visibleIn[k] == 1).ToList();
                                    if (visibleResponses.Count() > 0 && visibleResponses.Count() < dialogue.responses.Count())
                                    {
                                        asset.WriteLine($"Message_{k}_Responses {visibleResponses.Count()}");
                                        int visResCnt = visibleResponses.Count();
                                        for (int c = 0; c < visResCnt; c++)
                                        {
                                            NPCResponse response = visibleResponses[c];
                                            int         id       = dialogue.responses.IndexOf(response);
                                            asset.WriteLine($"Message_{k}_Response_{c} {id}");
                                        }
                                    }
                                    if (message.conditions.Length > 0)
                                    {
                                        asset.WriteLine($"Message_{k}_Conditions {message.conditions.Length}");
                                        for (int c = 0; c < message.conditions.Length; c++)
                                        {
                                            NPC.Conditions.Condition cond = message.conditions[c];

                                            asset.WriteLine(ExportCondition(cond, $"Message_{k}_", c));

                                            if (!string.IsNullOrEmpty(cond.Localization))
                                            {
                                                local.WriteLine($"Message_{k}_Condition_{c} {cond.Localization}");
                                            }
                                        }
                                    }
                                    if (message.rewards.Length > 0)
                                    {
                                        asset.WriteLine($"Message_{k}_Rewards {message.rewards.Length}");
                                        for (int c = 0; c < message.rewards.Length; c++)
                                        {
                                            Reward rew = message.rewards[c];

                                            asset.WriteLine(ExportReward(rew, $"Message_{k}_", c));

                                            if (!string.IsNullOrEmpty(rew.Localization))
                                            {
                                                local.WriteLine($"Message_{k}_Reward_{c} {rew.Localization}");
                                            }
                                        }
                                    }
                                    if (message.prev > 0)
                                    {
                                        asset.WriteLine($"Message_{k}_Prev {message.prev}");
                                    }
                                }
                            }
                            if (dialogue.ResponsesAmount > 0)
                            {
                                asset.WriteLine($"Responses {dialogue.ResponsesAmount}");
                                for (int k = 0; k < dialogue.ResponsesAmount; k++)
                                {
                                    NPCResponse response = dialogue.responses[k];
                                    if (!response.VisibleInAll)
                                    {
                                        asset.WriteLine($"Response_{k}_Messages {response.visibleIn.Count(d => d == 1)}");
                                        for (int c = 0, ind = 0; c < dialogue.MessagesAmount; c++)
                                        {
                                            NPCMessage currentMessage = dialogue.messages[c];
                                            if (response.visibleIn.Length <= c || response.visibleIn[c] == 1)
                                            {
                                                asset.WriteLine($"Response_{k}_Message_{ind++} {dialogue.messages.IndexOf(currentMessage)}");
                                            }
                                        }
                                    }
                                    if (response.openDialogueId > 0)
                                    {
                                        asset.WriteLine($"Response_{k}_Dialogue {response.openDialogueId}");
                                    }

                                    if (response.openQuestId > 0)
                                    {
                                        asset.WriteLine($"Response_{k}_Quest {response.openQuestId}");
                                    }

                                    if (response.openVendorId > 0)
                                    {
                                        asset.WriteLine($"Response_{k}_Vendor {response.openVendorId}");
                                    }

                                    if (response.conditions.Count() > 0)
                                    {
                                        asset.WriteLine($"Response_{k}_Conditions {response.conditions.Count()}");
                                        int cndCnt = response.conditions.Count();
                                        for (int c = 0; c < cndCnt; c++)
                                        {
                                            NPC.Conditions.Condition cond = response.conditions[c];

                                            asset.WriteLine(ExportCondition(cond, $"Response_{k}_", c));

                                            if (!string.IsNullOrEmpty(cond.Localization))
                                            {
                                                local.WriteLine($"Response_{k}_Condition_{c} {cond.Localization}");
                                            }
                                        }
                                    }
                                    if (response.rewards.Count() > 0)
                                    {
                                        asset.WriteLine($"Response_{k}_Rewards {response.rewards.Count()}");
                                        int rwrdCnt = response.rewards.Count();
                                        for (int c = 0; c < rwrdCnt; c++)
                                        {
                                            Reward rew = response.rewards[c];

                                            asset.WriteLine(ExportReward(rew, $"Response_{k}_", c));

                                            if (!string.IsNullOrEmpty(rew.Localization))
                                            {
                                                local.WriteLine($"Response_{k}_Reward_{c} {rew.Localization}");
                                            }
                                        }
                                    }
                                }
                            }
                            for (int k = 0; k < dialogue.MessagesAmount; k++)
                            {
                                for (int c = 0; c < dialogue.messages[k].PagesAmount; c++)
                                {
                                    local.WriteLine($"Message_{k}_Page_{c} {dialogue.messages[k].pages[c]}");
                                }
                            }
                            for (int k = 0; k < dialogue.ResponsesAmount; k++)
                            {
                                local.WriteLine($"Response_{k} {dialogue.responses[k].mainText}");
                            }
                        }
                }
                catch (Exception ex)
                {
                    App.Logger.LogException($"Can't export dialogue {dialogue.id}", ex: ex);
                    App.NotificationManager.Notify(LocalizationManager.Current.Notification.Translate("Export_Dialogue_Error", dialogue.id));
                }
            }
        }