Inheritance: ModelBase
        internal SortieInfo(Fleet rpFleet, int rpMapID)
        {
            r_Current = this;

            Fleet = rpFleet;
            if (KanColleGame.Current.Port.Fleets.CombinedFleetType != 0 && rpFleet.ID == 1)
                EscortFleet = KanColleGame.Current.Port.Fleets[2];

            Map = KanColleGame.Current.Maps[rpMapID];
        }
        static SortieInfo()
        {
            SessionService.Instance.Subscribe("api_port/port", _ => r_Current = null);

            SessionService.Instance.Subscribe(new[] { "api_req_map/start", "api_req_map/next" }, r => r_Current?.Explore(r.Requests, (RawMapExploration)r.Data));

            SessionService.Instance.Subscribe(new[] { "api_req_sortie/battleresult", "api_req_combined_battle/battleresult" }, r =>
            {
                var rData = (RawBattleResult)r.Data;

                if (rData.DroppedShip != null)
                     r_Current.PendingShipCount++;
            });
        }
Esempio n. 3
0
        internal SortieNodeInfo(SortieInfo rpOwner, long rpTimestamp, RawMapExploration rpData)
        {
            r_Owner = rpOwner;

            ID = rpData.Node;

            var rMap = r_Owner.Map;

            WikiID = MapService.Instance.GetNodeWikiID(rMap.ID, ID);

            EventType    = rpData.NodeEventType;
            EventSubType = rpData.NodeEventSubType;

            switch (EventType)
            {
            case SortieEventType.Reward:
                Event = new RewardEvent(rpData);
                break;

            case SortieEventType.Whirlpool:
                Event = new WhirlpoolEvent(r_Owner.Fleet.Ships, r_Owner.EscortFleet, rpData);
                break;

            case SortieEventType.NormalBattle:
            case SortieEventType.BossBattle:
                Event = new BattleEvent(rpTimestamp, rMap, rpData, WikiID);
                break;

            case SortieEventType.NothingHappened:
                Event = new NothingHappenedEvent(rMap, rpData);
                break;

            case SortieEventType.AviationReconnaissance:
                Event = new AviationReconnaissanceEvent(rpData);
                break;

            case SortieEventType.EscortSuccess:
                Event = new EscortSuccessEvent(rpData);
                break;

            case SortieEventType.Landing:
                Event = new LandingEvent(rpData);
                break;
            }

            IsDeadEnd = rpData.NextRouteCount == 0;
        }
        internal SortieViewModel()
        {
            var rGame = KanColleGame.Current;

            var rPropertyChangedSource = Observable.FromEventPattern<PropertyChangedEventArgs>(rGame, nameof(rGame.PropertyChanged))
                .Select(r => r.EventArgs.PropertyName);
            rPropertyChangedSource.Where(r => r == nameof(rGame.Sortie))
                .Subscribe(_ =>
                {
                    var rInfo = KanColleGame.Current.Sortie;
                    if (rInfo == null)
                        Type = DisplayType.MapGauge;
                    else
                    {
                        Info = rInfo;
                        OnPropertyChanged(nameof(Info));

                        Type = rInfo is PracticeInfo ? DisplayType.Practice : DisplayType.Sortie;
                    }
                });
        }
        internal SortieViewModel()
        {
            SessionService.Instance.Subscribe("api_req_map/start", delegate
            {
                Info = SortieInfo.Current;
                Type = DisplayType.Sortie;
            });

            SessionService.Instance.Subscribe("api_req_member/get_practice_enemyinfo", delegate
            {
                Info = KanColleGame.Current.Sortie;
                Type = DisplayType.Practice;
            });

            SessionService.Instance.Subscribe("api_port/port", _ =>
            {
                Info = null;
                Type = DisplayType.MapGauge;
            });

            SessionService.Instance.SubscribeOnce("api_get_member/require_info", delegate
            {
                ShipLockingService.Instance.Initialize();

                var rMasterInfo = KanColleGame.Current.MasterInfo;
                if (ShipLockingService.Instance.ShipLocking.Count > 0 && rMasterInfo.EventMapCount > 0)
                {
                    var rEventMaps = from rArea in rMasterInfo.MapAreas.Values
                                     where rArea.IsEventArea
                                     join rMap in rMasterInfo.Maps.Values on rArea.ID equals rMap.AreaID
                                     select rMap;

                    EventMaps = new EventMapOverviewViewModel(rEventMaps.ToArray());
                    OnPropertyChanged(nameof(EventMaps));
                }
            });
        }
        internal SortieNodeInfo(SortieInfo rpOwner, long rpTimestamp, RawMapExploration rpData)
        {
            r_Owner = rpOwner;

            ID = rpData.Node;

            var rMap = r_Owner.Map;

            WikiID = MapService.Instance.GetNodeWikiID(rMap.ID, ID);

            EventType = rpData.NodeEventType;
            EventSubType = rpData.NodeEventSubType;

            switch (EventType)
            {
                case SortieEventType.Reward:
                    Event = new RewardEvent(rpData);
                    break;

                case SortieEventType.Whirlpool:
                    Event = new WhirlpoolEvent(r_Owner.Fleet.Ships, r_Owner.EscortFleet, rpData);
                    break;

                case SortieEventType.NormalBattle:
                case SortieEventType.BossBattle:
                    Event = new BattleEvent(rpTimestamp, rMap, rpData, WikiID);
                    break;

                case SortieEventType.NothingHappened:
                    Event = new NothingHappenedEvent(rMap, rpData);
                    break;

                case SortieEventType.AviationReconnaissance:
                    Event = new AviationReconnaissanceEvent(rpData);
                    break;

                case SortieEventType.EscortSuccess:
                    Event = new EscortSuccessEvent(rpData);
                    break;

                case SortieEventType.Landing:
                    Event = new LandingEvent(rpData);
                    break;

            }

            IsDeadEnd = rpData.NextRouteCount == 0;

            if (rpData.EnemyAerialRaid != null)
                try
                {
                    EnemyAerialRaid = new EnemyAerialRaid(rpData.EnemyAerialRaid);

                    var rBattleEvent = Event as BattleEvent;
                    if (rBattleEvent != null)
                    {
                        rBattleEvent.EnemyAerialRaid = EnemyAerialRaid;
                        EnemyAerialRaid = null;
                    }
                }
                catch (Exception e)
                {
                    Logger.Write(LoggingLevel.Error, string.Format(StringResources.Instance.Main.Log_Exception_API_ParseException, e.Message));
                }
        }
        void InsertExplorationRecord(SortieInfo rpSortie)
        {
            var rNode = rpSortie.Node;

            using (var rTransaction = Connection.BeginTransaction())
            {
                InsertNodeInfo(rpSortie.Map.ID, rNode);
                InsertRecord(rpSortie.ID, rNode.InternalID, (rNode.Event as IExtraInfo)?.GetExtraInfo());

                rTransaction.Commit();
            }

            r_IsDeadEnd = rpSortie.Node.IsDeadEnd;
        }
 internal void RaiseReturnedFromSortie(SortieInfo rpSortie) => ReturnedFromSortie(rpSortie);
        void OnReturnedFromSortie(SortieInfo rpSortie)
        {
            if (!r_ReturnReason.HasValue)
            {
                IEnumerable<Ship> rShips = rpSortie.Fleet.Ships;
                if (rpSortie.EscortFleet != null)
                    rShips = rShips.Concat(rpSortie.EscortFleet.Ships);

                r_ReturnReason = rShips.Any(rpShip => (rpShip.State & ShipState.HeavilyDamaged) != 0) ? ReturnReason.RetreatWithHeavilyDamagedShip : ReturnReason.Retreat;
            }

            using (var rTransaction = Connection.BeginTransaction())
            {
                InsertReturnReason(r_ReturnReason.Value);
                SetReturnTime(rpSortie.ReturnTime);

                rTransaction.Commit();
            }
        }
        void InsertExplorationRecord(SortieInfo rpSortie)
        {
            var rNode = rpSortie.Node;
            if (rNode.IsDeadEnd)
                r_ReturnReason = ReturnReason.DeadEnd;

            var rCommand = Connection.CreateCommand();

            rCommand.CommandText =
                "INSERT OR IGNORE INTO sortie_node(map, id, type, subtype) VALUES(@map, @node_id, @type, @subtype);" +
                "INSERT INTO sortie_detail(id, step, node, extra_info) VALUES(@id, (SELECT ifnull(max(step), 0) + 1 FROM sortie_detail WHERE id = @id), @node_id, @extra_info);";
            rCommand.Parameters.AddWithValue("@map", rpSortie.Map.ID);
            rCommand.Parameters.AddWithValue("@node_id", rNode.ID);
            rCommand.Parameters.AddWithValue("@type", (int)rNode.EventType);
            rCommand.Parameters.AddWithValue("@subtype", rNode.EventSubType);
            rCommand.Parameters.AddWithValue("@id", rpSortie.ID);
            rCommand.Parameters.AddWithValue("@extra_info", (rNode.Event as IExtraInfo)?.GetExtraInfo());

            if (!rpSortie.Map.IsCleared && rNode.EventType == SortieEventType.EscortSuccess)
            {
                var rHP = rpSortie.Map.HP.Current;

                rCommand.CommandText += "UPDATE sortie SET map_hp = @map_hp WHERE id = @id;";
                rCommand.Parameters.AddWithValue("@map_hp", rHP > 0 ? (int?)rHP : null);
            }

            rCommand.PostToTransactionQueue();
        }
Esempio n. 11
0
        internal SortieNodeInfo(SortieInfo rpOwner, long rpTimestamp, RawMapExploration rpData)
        {
            r_Owner = rpOwner;

            ID = rpData.Node;

            var rMap = r_Owner.Map;

            WikiID = MapService.Instance.GetNodeWikiID(rMap.ID, ID);

            EventType    = rpData.NodeEventType;
            EventSubType = rpData.NodeEventSubType;

            switch (EventType)
            {
            case SortieEventType.Reward:
                Event = new RewardEvent(rpData);
                break;

            case SortieEventType.Whirlpool:
                Event = new WhirlpoolEvent(r_Owner.Fleet.Ships, r_Owner.EscortFleet, rpData);
                break;

            case SortieEventType.NormalBattle:
            case SortieEventType.BossBattle:
                Event = new BattleEvent(rpTimestamp, rMap, rpData, WikiID);
                break;

            case SortieEventType.NothingHappened:
                Event = new NothingHappenedEvent(rMap, rpData);
                break;

            case SortieEventType.AviationReconnaissance:
                Event = new AviationReconnaissanceEvent(rpData);
                break;

            case SortieEventType.EscortSuccess:
                Event = new EscortSuccessEvent(rpData);
                break;

            case SortieEventType.Landing:
                Event = new LandingEvent(rpData);
                break;
            }

            IsDeadEnd = rpData.NextRouteCount == 0;

            if (rpData.EnemyAerialRaid != null)
            {
                try
                {
                    EnemyAerialRaid = new EnemyAerialRaid(rpData.EnemyAerialRaid);

                    var rBattleEvent = Event as BattleEvent;
                    if (rBattleEvent != null)
                    {
                        rBattleEvent.EnemyAerialRaid = EnemyAerialRaid;
                        EnemyAerialRaid = null;
                    }
                }
                catch (Exception e)
                {
                    Logger.Write(LoggingLevel.Error, string.Format(StringResources.Instance.Main.Log_Exception_API_ParseException, e.Message));
                }
            }
        }