示例#1
0
        private void BattleResult(kcsapi_battle_result br)
        {
            string ShipName = "";
            string ItemName = "";
            string MapType  = "";

            if (br.api_get_ship != null)
            {
                ShipName = KanColleClient.Current.Translations.GetTranslation(br.api_get_ship.api_ship_name, TranslationType.Ships, false, br);
            }

            var _item = KanColleClient.Current.Master.UseItems
                        .SingleOrDefault(x => x.Value.Id == br.api_get_useitem?.api_useitem_id).Value
                        ?.Name;

            if (_item != null)
            {
                ItemName = KanColleClient.Current.Translations.GetTranslation(
                    _item,
                    TranslationType.Useitems,
                    false,
                    br
                    );
            }

            MapType = KanColleClient.Current.Translations.GetTranslation(br.api_quest_name, TranslationType.OperationMaps, false, br);

            string currentTime = DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss");

            #region CSV파일 저장
            //날짜,해역이름,해역,보스,적 함대,랭크,드랍
            Log(
                LogType.ShipDrop,
                "{0},{1},{2},{3},{4},{5},{6},{7}",
                currentTime,
                MapType,
                $"{NodeData.SelectToken("world").ToString()}-{(int)NodeData.SelectToken("mapnum")}-{(int)NodeData.SelectToken("node")}",
                IsBossCell ? "O" : "X",
                KanColleClient.Current.Translations.GetTranslation(br.api_enemy_info.api_deck_name, TranslationType.OperationSortie, false, br, -1),
                br.api_win_rank,
                ShipName,
                ItemName
                );
            #endregion
        }
示例#2
0
 public PracticeResultEventArgs(kcsapi_battle_result data) : base("SAB".Contains(data.api_win_rank))
 {
 }
示例#3
0
        public BattleResultEventArgs(TrackerMapInfo MapInfo, ShipBattleInfo[] enemyFirstShips, ShipBattleInfo[] enemSecondShips, kcsapi_battle_result data)
        {
            var enemyShips = new ShipBattleInfo[0];

            if (enemyFirstShips != null)
            {
                enemyShips = enemyShips.Concat(enemyFirstShips.Where(x => x != null)).ToArray();
            }
            if (enemSecondShips != null)
            {
                enemyShips = enemyShips.Concat(enemSecondShips.Where(x => x != null)).ToArray();
            }

            IsFirstCombat = MapInfo.IsFirstCombat;
            MapWorldId    = MapInfo.WorldId;
            MapAreaId     = MapInfo.MapId;
            MapNodeId     = MapInfo.NodeId;
            IsBoss        = MapInfo.IsBoss;
            EnemyName     = data.api_enemy_info.api_deck_name;
            EnemyShips    = enemyShips;
            Rank          = data.api_win_rank;
        }
示例#4
0
        public void AddTranslation(Object RawData, TranslationType Type)
        {
            if (RawData == null || !EnableAddUntranslated)
            {
                return;
            }

            try
            {
                switch (Type)
                {
                case TranslationType.Ships:
                    if (ShipsXML == null)
                    {
                        ShipsXML = new XDocument();
                        ShipsXML.Add(new XElement("Ships"));
                    }

                    kcsapi_mst_ship ShipData = RawData as kcsapi_mst_ship;

                    if (ShipData == null)
                    {
                        return;
                    }

                    ShipsXML.Root.Add(new XElement("Ship",
                                                   new XElement("JP-Name", ShipData.api_name),
                                                   new XElement("TR-Name", KanColleClient.Current.WebTranslator.RawTranslate(ShipData.api_name))
                                                   ));
                    RequestTranslation(Type, ShipData.api_name);

                    SaveXmls(0);
                    break;

                case TranslationType.ShipTypes:
                    if (ShipTypesXML == null)
                    {
                        ShipTypesXML = new XDocument();
                        ShipTypesXML.Add(new XElement("ShipTypes"));
                    }

                    kcsapi_mst_stype TypeData = RawData as kcsapi_mst_stype;

                    if (TypeData == null)
                    {
                        return;
                    }

                    ShipTypesXML.Root.Add(new XElement("Type",
                                                       new XElement("ID", TypeData.api_id),
                                                       new XElement("JP-Name", TypeData.api_name),
                                                       new XElement("TR-Name", KanColleClient.Current.WebTranslator.RawTranslate(TypeData.api_name))
                                                       ));
                    RequestTranslation(Type, TypeData.api_name);

                    SaveXmls(1);
                    break;

                case TranslationType.Equipment:
                    if (EquipmentXML == null)
                    {
                        EquipmentXML = new XDocument();
                        EquipmentXML.Add(new XElement("Equipment"));
                    }

                    kcsapi_mst_slotitem EqiupData = RawData as kcsapi_mst_slotitem;

                    if (EqiupData == null)
                    {
                        return;
                    }

                    EquipmentXML.Root.Add(new XElement("Item",
                                                       new XElement("JP-Name", EqiupData.api_name),
                                                       new XElement("TR-Name", KanColleClient.Current.WebTranslator.RawTranslate(EqiupData.api_name))
                                                       ));
                    RequestTranslation(Type, EqiupData.api_name);

                    SaveXmls(2);
                    break;

                case TranslationType.EquipmentTypes:
                    if (EquipmentTypesXML == null)
                    {
                        EquipmentTypesXML = new XDocument();
                        EquipmentTypesXML.Add(new XElement("EquipmentTypes"));
                    }

                    kcsapi_mst_slotitem_equiptype EqiupTypeData = RawData as kcsapi_mst_slotitem_equiptype;

                    if (EqiupTypeData == null)
                    {
                        return;
                    }

                    EquipmentTypesXML.Root.Add(new XElement("Item",
                                                            new XElement("JP-Name", EqiupTypeData.api_name),
                                                            new XElement("TR-Name", KanColleClient.Current.WebTranslator.RawTranslate(EqiupTypeData.api_name))
                                                            ));
                    RequestTranslation(Type, EqiupTypeData.api_name);

                    SaveXmls(7);
                    break;

                case TranslationType.OperationMaps:
                case TranslationType.OperationSortie:
                    if (OperationsXML == null)
                    {
                        OperationsXML = new XDocument();
                        OperationsXML.Add(new XElement("Operations"));
                    }

                    kcsapi_battle_result OperationsData = RawData as kcsapi_battle_result;

                    if (OperationsData == null)
                    {
                        return;
                    }

                    if (Type == TranslationType.OperationMaps)
                    {
                        OperationsXML.Root.Add(new XElement("Map",
                                                            new XElement("JP-Name", OperationsData.api_quest_name),
                                                            new XElement("TR-Name", KanColleClient.Current.WebTranslator.RawTranslate(OperationsData.api_quest_name))
                                                            ));
                        RequestTranslation(Type, OperationsData.api_quest_name);
                    }
                    else
                    {
                        OperationsXML.Root.Add(new XElement("Sortie",
                                                            new XElement("JP-Name", OperationsData.api_enemy_info.api_deck_name),
                                                            new XElement("TR-Name", KanColleClient.Current.WebTranslator.RawTranslate(OperationsData.api_enemy_info.api_deck_name))
                                                            ));
                        RequestTranslation(Type, OperationsData.api_enemy_info.api_deck_name);
                    }

                    SaveXmls(3);
                    break;

                case TranslationType.Quests:
                case TranslationType.QuestTitle:
                case TranslationType.QuestDetail:
                    if (QuestsXML == null)
                    {
                        QuestsXML = new XDocument();
                        QuestsXML.Add(new XElement("Quests"));
                    }

                    kcsapi_quest QuestData = RawData as kcsapi_quest;

                    if (QuestData == null)
                    {
                        return;
                    }

                    IEnumerable <XElement> FoundTranslationID = QuestsXML.Descendants("Quest").Where(b => b.Element("ID").Value.Equals(QuestData.api_no));
                    //이 부분에 의심이 가지만 확증은 없음
                    if (Type == TranslationType.QuestTitle || Type == TranslationType.QuestDetail && FoundTranslationID != null && FoundTranslationID.Any())
                    {
                        foreach (XElement el in FoundTranslationID)
                        {
                            el.Element("ID").Value = QuestData.api_no.ToString();
                        }
                    }
                    else
                    {
                        // The quest doesn't exist at all. Add it.
                        QuestsXML.Root.Add(new XElement("Quest",
                                                        new XElement("ID", QuestData.api_no),
                                                        new XElement("JP-Name", QuestData.api_title),
                                                        new XElement("TR-Name", "[" + QuestData.api_no.ToString() + "]" + KanColleClient.Current.WebTranslator.RawTranslate(QuestData.api_title)),
                                                        new XElement("JP-Detail", QuestData.api_detail),
                                                        new XElement("TR-Detail", "[" + QuestData.api_no.ToString() + "]" + KanColleClient.Current.WebTranslator.RawTranslate(QuestData.api_detail))
                                                        ));
                        RequestTranslation(Type, $"{QuestData.api_no}::{QuestData.api_title}::{QuestData.api_detail}");
                    }

                    SaveXmls(4);
                    break;

                case TranslationType.Expeditions:
                case TranslationType.ExpeditionTitle:
                case TranslationType.ExpeditionDetail:
                    if (ExpeditionXML == null)
                    {
                        ExpeditionXML = new XDocument();
                        ExpeditionXML.Add(new XElement("Expeditions"));
                    }

                    kcsapi_mission MissionData = RawData as kcsapi_mission;

                    if (MissionData == null)
                    {
                        return;
                    }

                    FoundTranslationID = ExpeditionXML.Descendants("Expedition").Where(b => b.Element("ID").Value.Equals(MissionData.api_id));
                    if (Type == TranslationType.ExpeditionTitle || Type == TranslationType.ExpeditionDetail && FoundTranslationID != null && FoundTranslationID.Any())
                    {
                        foreach (XElement el in FoundTranslationID)
                        {
                            el.Element("ID").Value = MissionData.api_id.ToString();
                        }
                    }
                    else
                    {
                        // The quest doesn't exist at all. Add it.
                        ExpeditionXML.Root.Add(new XElement("Expedition",
                                                            new XElement("ID", MissionData.api_id),
                                                            new XElement("JP-Name", MissionData.api_name),
                                                            new XElement("TR-Name", "[" + MissionData.api_id.ToString() + "]" + KanColleClient.Current.WebTranslator.RawTranslate(MissionData.api_name)),
                                                            new XElement("JP-Detail", MissionData.api_details),
                                                            new XElement("TR-Detail", "[" + MissionData.api_id.ToString() + "]" + KanColleClient.Current.WebTranslator.RawTranslate(MissionData.api_details))
                                                            ));
                        RequestTranslation(Type, $"{MissionData.api_id}::{MissionData.api_name}::{MissionData.api_details}");
                    }

                    SaveXmls(5);
                    break;
                }
            }
            catch { }
        }