示例#1
0
 public void OnSortieStart(MapId mapId, HomeportFleet fleet1, HomeportFleet fleet2)
 {
     foreach (var c in Counters)
     {
         if (c is SortieStartCounter sc)
         {
             sc.OnSortieStart(StatePersist, mapId, fleet1, fleet2);
         }
     }
     UpdateProgress();
 }
示例#2
0
 public void OnExpeditionComplete(HomeportFleet fleet, ExpeditionInfo expedition, ExpeditionResult result)
 {
     foreach (var c in Counters)
     {
         if (c is ExpeditionCounter ec)
         {
             ec.OnExpeditionComplete(StatePersist, fleet, expedition, result);
         }
     }
     UpdateProgress();
 }
示例#3
0
 public void OnMapRouting(MapRouting routing, HomeportFleet fleet, HomeportFleet fleet2)
 {
     foreach (var c in Counters)
     {
         if (c is MapRoutingCounter rc)
         {
             rc.OnMapRouting(StatePersist, routing, fleet, fleet2);
         }
     }
     UpdateProgress();
 }
示例#4
0
 public void OnExerciseComplete(HomeportFleet fleet, BattleResult currentBattleResult)
 {
     foreach (var c in Counters)
     {
         if (c is ExerciseCounter ec)
         {
             ec.OnExerciseComplete(StatePersist, fleet, currentBattleResult);
         }
     }
     UpdateProgress();
 }
示例#5
0
 public void SetExpeditionCompletion(HomeportFleet fleet, DateTimeOffset?timeStamp)
 {
     SelectedNotifier.RemoveSchedule("Expedition" + fleet.Id);
     if (fleet.Expedition != null && timeStamp is DateTimeOffset t)
     {
         SelectedNotifier.AddSchedule("Expedition" + fleet.Id,
                                      localization.GetLocalized("Notification", "Expedition_Title"),
                                      string.Format(localization.GetLocalized("Notification", "Expedition_Content"),
                                                    fleet.Id, fleet.Name, fleet.Expedition.DisplayId, TryTranslate(fleet.Expedition.Name)), t - TimeSpan.FromMinutes(1));
     }
 }
示例#6
0
        internal BattleManager(GameProvider listener, NavalBase navalBase)
        {
            this.navalBase = navalBase;

            listener.HomeportReturned += (t, m) =>
            {
                using (EnterBatchNotifyScope())
                {
                    CurrentRouting = null;
                    CurrentBattle  = null;
                    sortieFleet    = null;
                    sortieFleet2   = null;
                    exerciseFleet  = null;
                }
            };

            listener.ExerciseStarted += (t, m) =>
            {
                exerciseFleet = this.navalBase.Fleets[m];
                CurrentBattle = new Battle(exerciseFleet, null, CombinedFleetType.None, BattleKind.Normal);
            };

            listener.SortieStarting += (t, m) =>
            {
                sortieFleet = this.navalBase.Fleets[m.FleetId];
                if (m.FleetId == 1 && this.navalBase.CombinedFleet != CombinedFleetType.None)
                {
                    sortieFleet2 = this.navalBase.Fleets[(FleetId)2];
                }
                navalBase.Quests.Knowledges?.OnSortieStart(m.MapId, sortieFleet, sortieFleet2);
            };

            listener.MapRouting += (t, m) =>
            {
                CurrentRouting = new MapRouting(this.navalBase, m);
                CurrentBattle  = new Battle(sortieFleet, sortieFleet2, this.navalBase.CombinedFleet, m.BattleKind);
                navalBase.Quests.Knowledges?.OnMapRouting(CurrentRouting, sortieFleet, sortieFleet2);
            };

            listener.BattleStarted += (t, m) =>
            {
                CurrentBattle.Append(this.navalBase.MasterData, m.Parsed);
            };

            listener.BattleAppended += (t, m) =>
            {
                CurrentBattle.Append(this.navalBase.MasterData, m.Parsed);
            };

            listener.BattleCompleted += (t, m) =>
            {
                CurrentBattleResult = new BattleResult(this.navalBase.MasterData, m, CurrentBattle.Ally);
                if (exerciseFleet is null)
                {
                    navalBase.Quests.Knowledges?.OnBattleComplete(CurrentRouting, CurrentBattle, CurrentBattleResult);
                }
                else
                {
                    navalBase.Quests.Knowledges?.OnExerciseComplete(exerciseFleet, CurrentBattleResult);
                }
            };
        }
示例#7
0
文件: Logger.cs 项目: lyu0912/ing
        public Logger(IDataService dataService, GameProvider provider, NavalBase navalBase, IStatePersist statePersist)
        {
            this.dataService  = dataService;
            this.navalBase    = navalBase;
            this.statePersist = statePersist;

            provider.EquipmentCreated += (t, m) =>
            {
                using var context = CreateContext();
                context.EquipmentCreationTable.AddRange(m.Equipment.Select((e, i) => new EquipmentCreationEntity
                {
                    TimeStamp        = t.AddMilliseconds(i),
                    Consumption      = m.Consumption,
                    EquipmentCreated = e?.EquipmentInfoId,
                    IsSuccess        = e is object,
                    AdmiralLevel     = this.navalBase.Admiral.Leveling.Level,
                    Secretary        = this.navalBase.Secretary.Info.Id,
                    SecretaryLevel   = this.navalBase.Secretary.Leveling.Level
                }));
                context.SaveChanges();
            };

            provider.ShipCreated += (t, m) =>
            {
                shipCreation = new ShipCreationEntity
                {
                    TimeStamp      = t,
                    Consumption    = m.Consumption,
                    IsLSC          = m.IsLSC,
                    AdmiralLevel   = this.navalBase.Admiral.Leveling.Level,
                    Secretary      = this.navalBase.Secretary.Info.Id,
                    SecretaryLevel = this.navalBase.Secretary.Leveling.Level
                };
                lastBuildingDock = m.BuildingDockId;
            };

            provider.BuildingDockUpdated += (t, m) =>
            {
                if (shipCreation != null)
                {
                    using var context           = CreateContext();
                    shipCreation.ShipBuilt      = m.Single(x => x.Id == lastBuildingDock).BuiltShipId.Value;
                    shipCreation.EmptyDockCount = this.navalBase.BuildingDocks.Count(x => x.State == BuildingDockState.Empty);
                    context.ShipCreationTable.Add(shipCreation);
                    shipCreation     = null;
                    lastBuildingDock = default;
                    context.SaveChanges();
                }
            };

            provider.ExpeditionCompleted += (t, m) =>
            {
                using var context = CreateContext();
                var fleet = this.navalBase.Fleets[m.FleetId];
                context.ExpeditionCompletionTable.Add(new ExpeditionCompletionEntity
                {
                    TimeStamp         = t,
                    ExpeditionId      = fleet.Expedition.Id,
                    ExpeditionName    = m.ExpeditionName,
                    Result            = m.Result,
                    MaterialsAcquired = m.MaterialsAcquired,
                    RewardItem1       = m.RewardItem1,
                    RewardItem2       = m.RewardItem2
                });
                context.SaveChanges();
                foreach (var ship in fleet.HomeportShips)
                {
                    this.statePersist.ClearLastSortie(ship.Id);
                }
                this.statePersist.SaveChanges();
            };

#if DEBUG
            InitializeAdmiral(null);
#endif

            navalBase.AdmiralChanging += (t, _, a) =>
            {
                if (a != null)
                {
                    lock (admiralLock)
                        InitializeAdmiral(a);
                }
            };

            navalBase.MaterialsUpdating += (t, old, @new, reason) =>
            {
                using var context = CreateContext();
                context.MaterialsChangeTable.Add(new MaterialsChangeEntity
                {
                    TimeStamp = t,
                    Materials = @new,
                    Reason    = reason
                });
                context.SaveChanges();
            };

            navalBase.HomeportUpdated += (t, n) =>
            {
                if (this.statePersist.LastSortieTime is DateTimeOffset last)
                {
                    currentBattleContext ??= CreateContext();

                    var consumption = this.navalBase.Fleets[this.statePersist.LastSortieFleets].Sum(f => f.RepairingCost + f.SupplyingCost);
                    var diff        = consumption - this.statePersist.ConsumptionBeforeSortie;
                    var entity      = currentBattleContext.BattleConsumptionTable.Find(last);
                    if (diff != default && entity != null)
                    {
                        entity.Consumption = diff;
                        currentBattleContext.BattleConsumptionTable.Update(entity);
                        currentBattleContext.SaveChanges();
                    }
                }

                currentBattle   = null;
                currentExercise = null;
                currentBattleContext?.Dispose();
                currentFleetInBattle  = null;
                currentFleet2InBattle = null;

                this.statePersist.LastSortieFleets = null;
                this.statePersist.LastSortieTime   = null;
                this.statePersist.SaveChanges();
            };

            navalBase.ShipSupplying += (t, s, raw) =>
            {
                if (this.statePersist.GetLastSortie(s.Id) is DateTimeOffset last)
                {
                    using var context = CreateContext();
                    var entity = context.BattleConsumptionTable.Find(last);
                    if (entity is null)
                    {
                        return;
                    }

                    int  fuel        = raw.CurrentFuel - s.Fuel.Current;
                    int  bullet      = raw.CurrentBullet - s.Bullet.Current;
                    bool isMarriaged = s.Leveling.Level >= 100;
                    entity.ActualConsumption += new Materials
                    {
                        Fuel    = isMarriaged ? (int)(fuel * 0.85) : fuel,
                        Bullet  = isMarriaged ? (int)(bullet * 0.85) : bullet,
                        Bauxite = (raw.SlotAircraft.Sum() - s.Slots.Sum(x => x.Aircraft.Current)) * 5
                    };
                    context.BattleConsumptionTable.Update(entity);
                    context.SaveChanges();
                }
            };

            navalBase.ShipRepairing += (t, s, i) =>
            {
                if (this.statePersist.GetLastSortie(s.Id) is DateTimeOffset last)
                {
                    using var context = CreateContext();
                    var entity = context.BattleConsumptionTable.Find(last);
                    if (entity is null)
                    {
                        return;
                    }

                    entity.ActualConsumption += s.RepairingCost;
                    if (i)
                    {
                        entity.ActualConsumption += new Materials
                        {
                            InstantRepair = 1
                        }
                    }
                    ;
                    context.BattleConsumptionTable.Update(entity);
                    context.SaveChanges();
                }
            };
            navalBase.RepairingDockInstant += (t, d, s) =>
            {
                if (this.statePersist.GetLastSortie(s.Id) is DateTimeOffset last)
                {
                    using var context = CreateContext();
                    var entity = context.BattleConsumptionTable.Find(last);
                    if (entity is null)
                    {
                        return;
                    }


                    entity.ActualConsumption += new Materials
                    {
                        InstantRepair = 1
                    };
                    context.BattleConsumptionTable.Update(entity);
                    context.SaveChanges();
                }
            };

            provider.SortieStarting += (t, m) =>
            {
                FleetId[] fleets;
                currentFleetInBattle = this.navalBase.Fleets[m.FleetId];
                currentCombinedFleet = this.navalBase.CombinedFleet;
                if (currentCombinedFleet != CombinedFleetType.None)
                {
                    currentFleet2InBattle = this.navalBase.Fleets[(FleetId)2];
                    fleets = new[] { (FleetId)1, (FleetId)2 };
                }
                else
                {
                    fleets = new[] { m.FleetId };
                }
                currentBattleContext = CreateContext();
                currentBattleContext.BattleConsumptionTable.Add(new BattleConsumptionEntity
                {
                    TimeStamp = t,
                    MapId     = m.MapId
                });
                currentBattleContext.SaveChanges();

                this.statePersist.ConsumptionBeforeSortie =
                    currentFleetInBattle.RepairingCost +
                    currentFleetInBattle.SupplyingCost +
                    (currentFleet2InBattle?.RepairingCost ?? default) +
                    (currentFleet2InBattle?.SupplyingCost ?? default);
                this.statePersist.LastSortieTime   = t;
                this.statePersist.LastSortieFleets = fleets;
                foreach (var ship in currentFleetInBattle.HomeportShips)
                {
                    this.statePersist.SetLastSortie(ship.Id, t);
                }
                if (currentFleet2InBattle != null)
                {
                    foreach (var ship in currentFleet2InBattle.HomeportShips)
                    {
                        this.statePersist.SetLastSortie(ship.Id, t);
                    }
                }
                this.statePersist.SaveChanges();
            };

            provider.MapRouting += (t, m) =>
            {
                var map = this.navalBase.Maps[m.MapId];
                currentBattle = new BattleEntity
                {
                    TimeStamp         = t,
                    CompletionTime    = t,
                    MapId             = m.MapId,
                    MapName           = map.Info.Name.Origin,
                    RouteId           = m.RouteId,
                    EventKind         = m.EventKind,
                    BattleKind        = m.BattleKind,
                    CombinedFleetType = this.navalBase.CombinedFleet,
                    MapRank           = map.Rank,
                    MapGaugeType      = map.GaugeType,
                    MapGaugeNumber    = map.GaugeIndex,
                    MapGaugeHP        = map.Gauge?.Current,
                    MapGaugeMaxHP     = map.Gauge?.Max
                };
                if (m.UnparsedLandBaseDefence != null)
                {
                    currentBattle.LandBaseDefence = m.UnparsedLandBaseDefence.ToString(Formatting.None);
                }

                Materials acquired = default;
                foreach (var r in m.ItemAcquired)
                {
                    switch ((KnownUseItem)r.ItemId)
                    {
                    case KnownUseItem.Fuel:
                        acquired.Fuel += r.Count;
                        break;

                    case KnownUseItem.Bullet:
                        acquired.Bullet += r.Count;
                        break;

                    case KnownUseItem.Steel:
                        acquired.Steel += r.Count;
                        break;

                    case KnownUseItem.Bauxite:
                        acquired.Bauxite += r.Count;
                        break;

                    case KnownUseItem.InstantBuild:
                        acquired.InstantBuild += r.Count;
                        break;

                    case KnownUseItem.InstantRepair:
                        acquired.InstantRepair += r.Count;
                        break;

                    case KnownUseItem.Development:
                        acquired.Development += r.Count;
                        break;

                    case KnownUseItem.Improvement:
                        acquired.Improvement += r.Count;
                        break;
                    }
                }
                if (acquired != default)
                {
                    var entity = currentBattleContext.BattleConsumptionTable.Find(this.statePersist.LastSortieTime);
                    if (entity != null)
                    {
                        entity.Acquired += acquired;
                        currentBattleContext.BattleConsumptionTable.Update(entity);
                    }
                }

                currentBattleContext.BattleTable.Add(currentBattle);
                currentBattleContext.SaveChanges();
            };

            provider.ExerciseCandidateSelected += (t, m) =>
            {
                currentExercise = new ExerciseEntity
                {
                    TimeStamp  = t,
                    EnemyId    = m.AdmiralId,
                    EnemyName  = m.Name,
                    EnemyLevel = m.Leveling.Level
                };
            };

            provider.ExerciseStarted += (t, m) =>
            {
                currentFleetInBattle = this.navalBase.Fleets[m];
                currentBattleContext = CreateContext();
            };

            provider.BattleStarted += (t, m) =>
            {
                if (currentBattle != null)
                {
                    currentBattle.CompletionTime    = t;
                    currentBattle.SortieFleetState  = currentFleetInBattle.Ships.Select(x => new ShipInBattleEntity(x)).ToArray();
                    currentBattle.SortieFleet2State = currentFleet2InBattle?.Ships.Select(x => new ShipInBattleEntity(x)).ToArray();
                    currentBattle.FirstBattleDetail = m.Unparsed.ToString(Formatting.None);
                    currentBattle.LbasState         = m.Parsed.LandBasePhases
                                                      .Select(x => new AirForceInBattle(this.navalBase.AirForce[(currentBattle.MapId.AreaId, x.GroupId)]))
                                                      .ToArray();
                }