Arakne / Araknemu

public final class MonsterEnvironmentService implements EventsSubscriber, PreloadableService {

    private final ActivityService activityService;

    private final FightService fightService;

    private final MonsterGroupFactory factory;

    private final MonsterGroupPositionRepository positionRepository;

    private final MonsterGroupDataRepository dataRepository;

    private final GameConfiguration.ActivityConfiguration configuration;

    /**

     * Groups indexed by map id

     */

    private final ConcurrentMap<Integer, Collection<LivingMonsterGroupPosition>> groupsByMap = new ConcurrentHashMap<>();

    /**

     * Groups are preloaded ?

     * If true, consider that all data are loaded, so loading maps without loaded groups do not execute a query

     */

    private boolean preloaded = false;

    public MonsterEnvironmentService(ActivityService activityService, FightService fightService, MonsterGroupFactory factory, MonsterGroupPositionRepository positionRepository, MonsterGroupDataRepository dataRepository, GameConfiguration.ActivityConfiguration configuration) {

        this.activityService = activityService;

        this.fightService = fightService;

        this.factory = factory;

        this.positionRepository = positionRepository;

        this.dataRepository = dataRepository;

        this.configuration = configuration;

    }

    @Override

    public void preload(Logger logger) {

        logger.info("Loading monster groups data...");

        final Map<Integer, MonsterGroupData> groupsData = dataRepository.all().stream()

            .collect(Collectors.toMap(MonsterGroupData::id, Function.identity()))

        ;

        logger.info("{} monster groups loaded", groupsData.size());

        logger.info("Loading monster groups positions...");

        for (MonsterGroupPosition position : positionRepository.all()) {

            groupsByMap

                .computeIfAbsent(position.position().map(), mapId -> new ArrayList<>())

                .add(createByPosition(position))

            ;

        }

        logger.info("{} Map positions loaded", groupsByMap.size());

        preloaded = true;

        activityService.periodic(

            new MoveMonsters(

                this,

                Duration.ofSeconds(configuration.monsterMoveInterval()),

                configuration.monsterMovePercent(),

                configuration.monsterMoveDistance()

            )

        );

    }

    @Override

    public Listener[] listeners() {

        return new Listener[] {

            new Listener<MapLoaded>() {

                @Override

                public void on(MapLoaded event) {

                    final ExplorationMap map = event.map();

                    byMap(map.id()).forEach(group -> group.populate(map));

                    map.dispatcher().add(new LaunchMonsterFight());

                }

                @Override

                public Class<MapLoaded> event() {

                    return MapLoaded.class;

                }

            },

        };

    }

    /**

     * Get list of groups for a map

     *

     * @param mapId The map id to load

     */

    public Collection<LivingMonsterGroupPosition> byMap(int mapId) {

        if (groupsByMap.containsKey(mapId)) {

            return groupsByMap.get(mapId);

        }

        if (preloaded) {

            return Collections.emptyList();

        }

        final Collection<LivingMonsterGroupPosition> groups = new ArrayList<>();

        for (MonsterGroupPosition position : positionRepository.byMap(mapId)) {

            groups.add(createByPosition(position));

        }

        groupsByMap.put(mapId, groups);

        return groups;

    }

    /**

     * Put the respawn to the activity service

     */

    void respawn(LivingMonsterGroupPosition position, Duration delay) {

        activityService.execute(

            new SimpleTask(logger -> position.spawn())

                .setDelay(delay.dividedBy(configuration.monsterRespawnSpeedFactor()))

                .setMaxTries(2)

                .setName("Respawn")

        );

    }

    /**

     * Get all loaded groups

     */

    Stream<LivingMonsterGroupPosition> groups() {

        return groupsByMap.values().stream().flatMap(Collection::stream);

    }

    private LivingMonsterGroupPosition createByPosition(MonsterGroupPosition position) {

        return new LivingMonsterGroupPosition(

            factory,

            this,

            fightService,

            dataRepository.get(position.groupId()),

            SpawnCellSelector.forPosition(position.position()),

            position.position().cell() != -1