Arakne / Araknemu

public final class GameModule implements ContainerModule {

    private final Araknemu app;

    public GameModule(Araknemu app) {

        this.app = app;

    }

    @Override

    public void configure(ContainerConfigurator configurator) {

        configurator.factory(

            Logger.class,

            container -> LogManager.getLogger(GameService.class)

        );

        configurator.persist(

            GameService.class,

            container -> new GameService(

                container.get(GameConfiguration.class),

                container.get(RealmConnector.class),

                container.get(Server.class),

                container.get(Logger.class),

                container.get(ListenerAggregate.class),

                // Preload

                Arrays.asList(

                    container.get(ItemService.class),

                    container.get(SpellService.class),

                    container.get(DialogService.class),

                    container.get(NpcExchangeService.class),

                    container.get(NpcService.class),

                    container.get(MonsterRewardService.class),

                    container.get(MonsterService.class),

                    container.get(MonsterEnvironmentService.class),

                    container.get(AreaService.class),

                    container.get(MapTriggerService.class),

                    container.get(ExplorationMapService.class),

                    container.get(PlayerRaceService.class),

                    container.get(PlayerExperienceService.class),

                    container.get(GameBanIpSynchronizer.class),

                    container.get(SavingService.class)

                ),

                // Subscribers

                Arrays.asList(

                    container.get(AreaService.class),

                    container.get(ExplorationMapService.class),

                    container.get(MapTriggerService.class),

                    container.get(ChatService.class),

                    container.get(InventoryService.class),

                    container.get(SpellBookService.class),

                    container.get(PlayerExperienceService.class),

                    container.get(FightService.class),

                    container.get(ExplorationService.class),

                    container.get(NpcService.class),

                    container.get(MonsterEnvironmentService.class),

                    container.get(NpcExchangeService.class),

                    container.get(ActivityService.class),

                    container.get(PlayerService.class),

                    container.get(AccountService.class),

                    container.get(ShutdownService.class),

                    container.get(GameBanIpSynchronizer.class),

                    container.get(SavingService.class)

                )

            )

        );

        configurator.factory(

            GameConfiguration.class,

            container -> app.configuration().module(GameConfiguration.MODULE)

        );

        configurator.factory(

            Server.class,

            container -> new NettyServer(

                container.get(SessionFactory.class),

                container.get(GameConfiguration.class).port(),

                container.get(GameConfiguration.class).inactivityTime()

            )

        );

        configurator.factory(

            SessionFactory.class,

            container -> new SessionConfigurator<>(GameSession::new)

                .add(new BanIpCheck<>(container.get(BanIpService.class)))

                .add(new RateLimiter.Configurator<>(container.get(GameConfiguration.class).packetRateLimit()))

                .add(new SessionLogger.Configurator<>(container.get(Logger.class)))

                .add(new GameExceptionConfigurator(container.get(Logger.class)))

                .add(new GamePacketConfigurator(

                    container.get(Dispatcher.class),

                    container.get(PacketParser.class)

                ))

        );

        configurator.factory(

            Dispatcher.class,

            container -> new DefaultDispatcher(

                new AggregateLoader(

                    new CommonLoader(),

                    new LoggedLoader(),

                    new PlayingLoader(),

                    new ExploringLoader(),

                    new FightingLoader(),

                    new ExploringOrFightingLoader()

                ).load(container)

            )

        );

        configurator.factory(

            PacketParser.class,

            container ->  new AggregatePacketParser(

                new AggregateParserLoader(

                    new ParserLoader[]{

                        new CommonParserLoader(),

                        new GameParserLoader(),

                    }

                ).load()

            )

        );

        configurator.factory(

            PlayerConstraints.class,

            container -> new PlayerConstraints(

                container.get(PlayerRepository.class),

                container.get(GameConfiguration.class).player()

            )

        );

        configureServices(configurator);

    }

        configurator.persist(

            ConnectorService.class,

            container -> new ConnectorService(

                container.get(TokenService.class),

                container.get(AccountService.class)

            )

        );

        configurator.persist(

            TokenService.class,

            container -> new TokenService()

        );

        configurator.persist(

            AccountService.class,

            container -> new AccountService(

                container.get(AccountRepository.class),

                container.get(GameConfiguration.class)

            )

        );

        configurator.persist(

            CharactersService.class,

            container -> new CharactersService(

                container.get(PlayerRepository.class),

                container.get(PlayerConstraints.class),

                container.get(PlayerRaceRepository.class),

                container.get(fr.quatrevieux.araknemu.core.event.Dispatcher.class),

                container.get(PlayerItemRepository.class)

            )

        );

        configurator.persist(

            PlayerService.class,

            container -> new PlayerService(

                container.get(PlayerRepository.class),

                container.get(GameConfiguration.class),

                container.get(fr.quatrevieux.araknemu.core.event.Dispatcher.class),

                container.get(InventoryService.class),

                container.get(PlayerRaceService.class),

                container.get(SpellBookService.class),

                container.get(PlayerExperienceService.class)

            )

        );

        configurator.persist(

            ExplorationService.class,

            container -> new ExplorationService(

                container.get(ExplorationMapService.class),

                container.get(GameConfiguration.class).player(),

                container.get(fr.quatrevieux.araknemu.core.event.Dispatcher.class)

            )

        );

        configurator.persist(

            ExplorationMapService.class,

            container -> new ExplorationMapService(

                container.get(MapTemplateRepository.class),

                container.get(FightService.class),

                container.get(AreaService.class),

                container.get(fr.quatrevieux.araknemu.core.event.Dispatcher.class),

                // Use proxy to fix circular reference between ExplorationMapService and MapTriggerService

                (map, cells) -> container.get(CellLoader.class).load(map, cells)

            )

        );

        configurator.persist(

            GeolocationService.class,

            container -> new GeolocationService(

                container.get(ExplorationMapService.class),

                container.get(AreaService.class),

                container.get(MapTemplateRepository.class)

            )

        );

        configurator.persist(

            CellLoader.class,

            container -> new CellLoaderAggregate(new CellLoader[] {

                new TriggerLoader(container.get(MapTriggerService.class)),

            })

        );

        configurator.persist(

            MapTriggerService.class,

            container -> new MapTriggerService(

                container.get(MapTriggerRepository.class),

                container.get(CellActionFactory.class)

            )

        );

        configurator.persist(

            CellActionFactory.class,

            container -> new ActionFactoryRegistry()

                .register(Teleport.ACTION_ID, new TeleportFactory(container.get(ExplorationMapService.class)))

        );

        configurator.persist(

            ActionFactory.class,

            container -> new ExplorationActionRegistry(

                new MoveFactory(

                    new ValidateWalkable(),

                    new ValidateOverweight(),

                    new ValidateRestrictedDirections(),

                    new StopOnTrigger()

                ),

                new ChallengeActionsFactories(container.get(FightService.class)),

                new FightActionsFactories(

                    container.get(FightService.class),

                    container.get(FighterFactory.class),

                    container.get(SpectatorFactory.class)

                )

            )

        );

        configurator.persist(

            ChatService.class,

            container -> new ChatService(

                container.get(GameConfiguration.class).chat(),

                new Channel[] {

                    new MapChannel(),

                    new GlobalChannel(ChannelType.INCARNAM, container.get(PlayerService.class)),

                    new FloodGuardChannel(

                        new GlobalChannel(ChannelType.TRADE, container.get(PlayerService.class)),

                        container.get(GameConfiguration.class).chat()

                    ),

                    new FloodGuardChannel(

                        new GlobalChannel(ChannelType.RECRUITMENT, container.get(PlayerService.class)),

                        container.get(GameConfiguration.class).chat()

                    ),

                    new GlobalChannel(

                        ChannelType.ADMIN,

                        player -> player.account().isMaster(),

                        container.get(PlayerService.class)

                    ),

                    new NullChannel(ChannelType.MEETIC),

                    new PrivateChannel(container.get(PlayerService.class)),

                    new FightChannel(),

                    new FightTeamChannel(),

                    new FightSpectatorChannel(ChannelType.FIGHT_TEAM),

                    new FightSpectatorChannel(ChannelType.MESSAGES),

                }

            )

        );

        configurator.persist(

            AreaService.class,

            container -> new AreaService(

                container.get(AreaRepository.class),

                container.get(SubAreaRepository.class)

            )

        );

        configurator.persist(

            InventoryService.class,

            container -> new InventoryService(

                container.get(PlayerItemRepository.class),

                container.get(ItemService.class)

            )

        );

        configurator.persist(

            ListenerAggregate.class,

            container -> new DefaultListenerAggregate(container.get(Logger.class))

        );

        configurator.factory(

            fr.quatrevieux.araknemu.core.event.Dispatcher.class,

            container -> container.get(ListenerAggregate.class)

        );

        configurator.persist(

            NameGenerator.class,

            container -> new NameCheckerGenerator(

                new CamelizeName(

                    new SimpleNameGenerator(

                        container.get(GameConfiguration.class).player()

                    )

                ),

                container.get(PlayerRepository.class),

                container.get(GameConfiguration.class)

            )

        );

        configurator.persist(

            ItemService.class,

            container -> new ItemService(

                container.get(ItemTemplateRepository.class),

                container.get(ItemFactory.class),

                container.get(ItemSetRepository.class),

                container.get(ItemTypeRepository.class),

                container.get(EffectToCharacteristicMapping.class),

                container.get(EffectToSpecialMapping.class)

            )

        );

        configurator.persist(

            SpellService.class,

            container -> new SpellService(

                container.get(SpellTemplateRepository.class),

                container.get(SpellEffectService.class)

            )

        );

        configurator.persist(

            SpellEffectService.class,

            container -> new SpellEffectService()

        );

        configurator.persist(

            PlayerRaceService.class,

            container -> new PlayerRaceService(

                container.get(PlayerRaceRepository.class),

                container.get(SpellService.class)

            )

        );

        configurator.persist(

            SpellBookService.class,

            container -> new SpellBookService(

                container.get(PlayerSpellRepository.class),

                container.get(SpellService.class),

                container.get(PlayerRaceService.class)

            )

        );

        configurator.persist(

            PlayerExperienceService.class,

            container -> new PlayerExperienceService(

                container.get(PlayerExperienceRepository.class),

                container.get(GameConfiguration.class).player()

            )

        );

        configurator.persist(

            fr.quatrevieux.araknemu.game.fight.turn.action.move.MoveFactory.class,

            container -> new fr.quatrevieux.araknemu.game.fight.turn.action.move.MoveFactory(new FightPathValidator[] {

                new TackleValidator(),

                new StopOnEnemyValidator(),

            })

        );

        configurator.persist(

            CastFactory.class,

            container -> new CastFactory(

                new SpellConstraintsValidator(),

                container.get(CriticalityStrategy.class)

            )

        );

        configurator.persist(

            CloseCombatFactory.class,

            container -> new CloseCombatFactory(

                new WeaponConstraintsValidator(),

                container.get(CriticalityStrategy.class)

            )

        );

        configurator.persist(

            FightActionsFactoryRegistry.class,

            container -> new FightActionsFactoryRegistry(

                container.get(fr.quatrevieux.araknemu.game.fight.turn.action.move.MoveFactory.class),

                container.get(CastFactory.class),

                container.get(CloseCombatFactory.class)

            )

        );

        configurator.persist(

            FightService.FightFactory.class,

            container -> (id, type, map, teams, statesFlow, executor) -> new Fight(

                id,

                type,

                map,

                teams,

                statesFlow,

                executor,

                container.get(FightActionsFactoryRegistry.class)

            )

        );

        configurator.persist(

            FightService.class,

            container -> new FightService(

                container.get(fr.quatrevieux.araknemu.core.event.Dispatcher.class),

                Arrays.asList(

                    new ChallengeBuilderFactory(

                        container.get(FighterFactory.class),

                        container.get(ChallengeType.class)

                    ),

                    new PvmBuilderFactory(

                        container.get(FighterFactory.class),

                        container.get(PvmType.class)

                    )

                ),

                Arrays.asList(

                    CommonEffectsModule::new,

                    fight -> new IndirectSpellApplyEffectsModule(fight, container.get(SpellService.class)),

                    StatesModule::new,

                    RaulebaqueModule::new,

                    LaunchedSpellsModule::new,

                    fight -> new AiModule(container.get(AiFactory.class)),

                    fight -> new MonsterInvocationModule(container.get(MonsterService.class), container.get(FighterFactory.class), fight)

                ),

                container.get(FightService.FightFactory.class),

                container.get(GameConfiguration.class).fight()

            )

        );

        configurator.persist(

            NpcService.class,

            container -> new NpcService(

                container.get(DialogService.class),

                container.get(NpcTemplateRepository.class),

                container.get(NpcRepository.class),

                Arrays.asList(

                    container.get(NpcStoreService.class),

                    container.get(NpcExchangeService.class)

                )

            )

        );

        configurator.persist(

            DialogService.class,

            container -> new DialogService(

                container.get(QuestionRepository.class),

                container.get(ResponseActionRepository.class),

                new fr.quatrevieux.araknemu.game.exploration.npc.dialog.action.ActionFactory[] {

                    new fr.quatrevieux.araknemu.game.exploration.npc.dialog.action.teleport.Teleport.Factory(

                        container.get(ExplorationMapService.class)

                    ),

                    new GoToAstrub.Factory(container.get(ExplorationMapService.class)),

                    new RemoveObject.Factory(),

                    new OpenBank.Factory(container.get(BankService.class)),

                },

                container.get(ParametersResolver.class),

                container.get(Logger.class)

            )

        );

        configurator.persist(

            NpcStoreService.class,

            container -> new NpcStoreService(

                container.get(ItemService.class),

                container.get(ItemTemplateRepository.class),

                container.get(GameConfiguration.class).economy()

            )

        );

        configurator.persist(

            NpcExchangeService.class,

            container -> new NpcExchangeService(

                container.get(ItemService.class),

                container.get(NpcExchangeRepository.class),

                container.get(ItemTemplateRepository.class)

            )

        );

        configurator.persist(

            MonsterService.class,

            container -> new MonsterService(

                container.get(SpellService.class),

                container.get(MonsterRewardService.class),

                container.get(MonsterTemplateRepository.class)

            )

        );

        configurator.persist(

            MonsterEnvironmentService.class,

            container -> new MonsterEnvironmentService(

                container.get(ActivityService.class),

                container.get(FightService.class),

                container.get(MonsterGroupFactory.class),

                container.get(MonsterGroupPositionRepository.class),

                container.get(MonsterGroupDataRepository.class),

                container.get(GameConfiguration.class).activity()

            )

        );

        configurator.persist(

            MonsterRewardService.class,

            container -> new MonsterRewardService(

                container.get(MonsterRewardRepository.class),

                container.get(MonsterRewardItemRepository.class)

            )

        );

        configurator.persist(

            ActivityService.class,

            container -> new ActivityService(

                container.get(GameConfiguration.class).activity(),

            )

        );

        configurator.persist(

            BankService.class,

            container -> new BankService(

                container.get(ItemService.class),

                container.get(AccountBankRepository.class),

                container.get(BankItemRepository.class),

                container.get(GameConfiguration.class).economy()

            )

        );

        configurator.persist(

            BanishmentService.class,

            container -> new BanishmentService<>(

                container.get(BanishmentRepository.class),

                container.get(fr.quatrevieux.araknemu.core.event.Dispatcher.class),

                ids -> container.get(AccountService.class).getByIds(ids)

            )

        );

        configurator.persist(

            BanIpService.class,

            container -> new BanIpService<>(

                container.get(BanIpRepository.class),

                container.get(fr.quatrevieux.araknemu.core.event.Dispatcher.class),

                ids -> container.get(AccountService.class).getByIds(ids)

            )

        );

        configurator.persist(

            GameBanIpSynchronizer.class,

            container -> new GameBanIpSynchronizer(

                container.get(BanIpService.class),

                () -> container.get(GameService.class).sessions(),

                container.get(Logger.class),

                container.get(GameConfiguration.class).banIpRefresh()

            )

        );

        configurator.persist(

            ParametersResolver.class,

            container -> new ParametersResolver(

                new VariableResolver[] {

                    new GetterResolver("name", session -> session.player().name()),

                    new BankCostResolver(container.get(BankService.class)),

                },

                container.get(Logger.class)

            )

        );

        configurator.persist(

            FighterFactory.class,

            container -> new DefaultFighterFactory(

                container.get(fr.quatrevieux.araknemu.core.event.Dispatcher.class)

            )

        );

        configurator.persist(SpectatorFactory.class, container -> new DefaultSpectatorFactory());

        configurator.persist(EffectToSpecialMapping.class, container -> new EffectToSpecialMapping());

        configurator.persist(EffectToWeaponMapping.class, container -> new EffectToWeaponMapping());

        configurator.persist(EffectToCharacteristicMapping.class, container -> new EffectToCharacteristicMapping());

        configurator.persist(EffectToUseMapping.class, container -> new EffectToUseMapping(

            container.get(SpellService.class)

        ));

        configurator.persist(

            ItemFactory.class,

            container -> new DefaultItemFactory(

                new ResourceFactory(container.get(EffectToSpecialMapping.class)),

                new UsableFactory(

                    container.get(EffectToUseMapping.class),

                    container.get(EffectToSpecialMapping.class)

                ),

                new WeaponFactory(

                    container.get(SpellEffectService.class),

                    container.get(EffectToWeaponMapping.class),

                    container.get(EffectToCharacteristicMapping.class),

                    container.get(EffectToSpecialMapping.class)

                ),

                new WearableFactory(SuperType.AMULET, container.get(EffectToCharacteristicMapping.class), container.get(EffectToSpecialMapping.class)),

                new WearableFactory(SuperType.RING, container.get(EffectToCharacteristicMapping.class), container.get(EffectToSpecialMapping.class)),

                new WearableFactory(SuperType.BELT, container.get(EffectToCharacteristicMapping.class), container.get(EffectToSpecialMapping.class)),

                new WearableFactory(SuperType.BOOT, container.get(EffectToCharacteristicMapping.class), container.get(EffectToSpecialMapping.class)),

                new WearableFactory(SuperType.SHIELD, container.get(EffectToCharacteristicMapping.class), container.get(EffectToSpecialMapping.class)),

                new WearableFactory(SuperType.HELMET, container.get(EffectToCharacteristicMapping.class), container.get(EffectToSpecialMapping.class)),

                new WearableFactory(SuperType.MANTLE, container.get(EffectToCharacteristicMapping.class), container.get(EffectToSpecialMapping.class)),

                new WearableFactory(SuperType.DOFUS, container.get(EffectToCharacteristicMapping.class), container.get(EffectToSpecialMapping.class))

            )

        );

        configurator.persist(CriticalityStrategy.class, container -> new BaseCriticalityStrategy());

        configurator.persist(

            MonsterGroupFactory.class,

            container -> new MonsterGroupFactory(

                new MonsterListGeneratorSwitch(

                    new RandomMonsterListGenerator(container.get(MonsterService.class)),

                    new FixedMonsterListGenerator(container.get(MonsterService.class))

                )

            )

        );

        configurator.persist(

            PvmType.class,

            container -> new PvmType(

                new PvmRewardsGenerator(

                    // Issue #192 (https://github.com/Arakne/Araknemu/issues/192) : Perform SynchronizeLife before AddExperience

                    // to ensure that level up (which trigger restore life) is performed after life synchronisation

                    Arrays.asList(new SynchronizeLife(), new AddExperience(), new AddKamas(), new AddItems(container.get(ItemService.class))),

                    Arrays.asList(new SetDead(), new ReturnToSavePosition()),

                    Arrays.asList(

                        new PvmXpProvider(container.get(GameConfiguration.class).fight().xpRate()),

                        new PvmKamasProvider(),

                        new PvmItemDropProvider(container.get(GameConfiguration.class).fight().dropRate()),

                        new PvmEndFightActionProvider()

                    )

                ),

                container.get(GameConfiguration.class).fight()

            )

        );

        configurator.persist(

            ChallengeType.class,

            container -> new ChallengeType(container.get(GameConfiguration.class).fight())

        );

        configurator.persist(

            AiFactory.class,

            container -> new ChainAiFactory(

                container.get(MonsterAiFactory.class)

            )

        );

        configurator.persist(Simulator.class, container -> {

            final Simulator simulator = new Simulator(container.get(CriticalityStrategy.class));

            simulator.register(91, new StealLifeSimulator(Element.WATER));

            simulator.register(92, new StealLifeSimulator(Element.EARTH));

            simulator.register(93, new StealLifeSimulator(Element.AIR));

            simulator.register(94, new StealLifeSimulator(Element.FIRE));

            simulator.register(95, new StealLifeSimulator(Element.NEUTRAL));

            simulator.register(96,  new DamageSimulator(Element.WATER));

            simulator.register(97,  new DamageSimulator(Element.EARTH));

            simulator.register(98,  new DamageSimulator(Element.AIR));

            simulator.register(99,  new DamageSimulator(Element.FIRE));

            simulator.register(100, new DamageSimulator(Element.NEUTRAL));

            // AP

            simulator.register(111, new AlterActionPointsSimulator(200));

            simulator.register(120, new AlterActionPointsSimulator(200));

            simulator.register(168, new AlterActionPointsSimulator(-200));

            simulator.register(101, new RemovePointsSimulator(Characteristic.ACTION_POINT, Characteristic.RESISTANCE_ACTION_POINT, 200));

            // MP

            simulator.register(78,  new AlterCharacteristicSimulator(200));

            simulator.register(128, new AlterCharacteristicSimulator(200));

            simulator.register(169, new AlterCharacteristicSimulator(-200));

            simulator.register(127, new RemovePointsSimulator(Characteristic.MOVEMENT_POINT, Characteristic.RESISTANCE_MOVEMENT_POINT, 200));

            // Characteristics boost

            simulator.register(112, new AlterCharacteristicSimulator(10)); // damage

            simulator.register(115, new AlterCharacteristicSimulator(5)); // critical

            simulator.register(117, new AlterCharacteristicSimulator(5)); // sight

            simulator.register(118, new AlterCharacteristicSimulator()); // strength

            simulator.register(119, new AlterCharacteristicSimulator()); // agility

            simulator.register(122, new AlterCharacteristicSimulator(-5)); // Fail malus

            simulator.register(123, new AlterCharacteristicSimulator()); // luck

            simulator.register(124, new AlterCharacteristicSimulator()); // wisdom

            simulator.register(126, new AlterCharacteristicSimulator()); // intelligence

            simulator.register(138, new AlterCharacteristicSimulator(2)); // percent damage

            simulator.register(178, new AlterCharacteristicSimulator(8)); // heal

            simulator.register(182, new AlterCharacteristicSimulator(10)); // summoned creature

            simulator.register(606, new AlterCharacteristicSimulator()); // Wisdom not dispellable

            simulator.register(607, new AlterCharacteristicSimulator()); // Strength not dispellable

            simulator.register(608, new AlterCharacteristicSimulator()); // Luck not dispellable

            simulator.register(609, new AlterCharacteristicSimulator()); // Agility not dispellable

            simulator.register(611, new AlterCharacteristicSimulator()); // Intelligence not dispellable

            // Characteristics malus

            simulator.register(116, new AlterCharacteristicSimulator(-5)); // sight malus

            simulator.register(145, new AlterCharacteristicSimulator(-10)); // -damage

            simulator.register(152, new AlterCharacteristicSimulator(-1)); // -luck

            simulator.register(154, new AlterCharacteristicSimulator(-1)); // -agility

            simulator.register(155, new AlterCharacteristicSimulator(-1)); // -intelligence

            simulator.register(156, new AlterCharacteristicSimulator(-1)); // -wisdom

            simulator.register(157, new AlterCharacteristicSimulator(-1)); // -strength

            simulator.register(171, new AlterCharacteristicSimulator(-5)); // -critical

            simulator.register(179, new AlterCharacteristicSimulator(-8)); // -heal

            simulator.register(186, new AlterCharacteristicSimulator(-2)); // -percent damage

            simulator.register(105, new ArmorSimulator());

            simulator.register(265, new ArmorSimulator());

            // Heal

            simulator.register(108, new HealSimulator());

            // Misc

            simulator.register(950, new SetStateSimulator()

                .state(50, -500) // Altruiste

            );

            simulator.register(150, new PunishmentSimulator());

            return simulator;

        });

        configurator.persist(

            MonsterAiFactory.class,

            container -> {

                final MonsterAiFactory factory = new MonsterAiFactory();

                final Simulator simulator = container.get(Simulator.class);

                factory.register("AGGRESSIVE", new Aggressive(simulator));

                factory.register("RUNAWAY", new Runaway(simulator));

                factory.register("SUPPORT", new Support(simulator));

                factory.register("TACTICAL", new Tactical(simulator));

                factory.register("FIXED", new Fixed(simulator));

                return factory;

            }

        );

        configurator.persist(ExchangeFactory.class, container -> new DefaultExchangeFactory(

            new PlayerExchangeFactories(),

            new NpcExchangeFactories()

        ));

        configurator.persist(ShutdownService.class, container -> new ShutdownService(

            app,

            container.get(fr.quatrevieux.araknemu.core.event.Dispatcher.class),

            container.get(GameConfiguration.class)

        ));

        configurator.persist(SessionLogService.class, container -> new SessionLogService(

            container.get(ConnectionLogRepository.class)

        ));

        configurator.persist(SavingService.class, container -> new SavingService(

            container.get(PlayerService.class),

            container.get(GameConfiguration.class),

            container.get(fr.quatrevieux.araknemu.core.event.Dispatcher.class)