Copy some files from Grasscutter-Quests

NOT completely finished, nor is it completely done. Protocol issues remain! (including lack of packet IDs)

src/main/java/emu/grasscutter/game/activity/ActivityManager.java

@@ -4,6 +4,7 @@ import com.esotericsoftware.reflectasm.ConstructorAccess;
 import emu.grasscutter.Grasscutter;
 import emu.grasscutter.data.DataLoader;
 import emu.grasscutter.data.GameData;
+import emu.grasscutter.game.activity.condition.*;
 import emu.grasscutter.game.player.BasePlayerManager;
 import emu.grasscutter.game.player.Player;
 import emu.grasscutter.game.props.ActivityType;
@@ -12,6 +13,7 @@ import emu.grasscutter.net.proto.ActivityInfoOuterClass;
 import emu.grasscutter.server.packet.send.PacketActivityScheduleInfoNotify;
 import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.TimeUnit;
 import lombok.Getter;
 import org.reflections.Reflections;
 
@@ -19,6 +21,8 @@ import org.reflections.Reflections;
 public class ActivityManager extends BasePlayerManager {
     private static final Map<Integer, ActivityConfigItem> activityConfigItemMap;
     @Getter private static final Map<Integer, ActivityConfigItem> scheduleActivityConfigMap;
+    private final Map<Integer, PlayerActivityData> playerActivityDataMap;
+    private final ActivityConditionExecutor conditionExecutor;
 
     static {
         activityConfigItemMap = new HashMap<>();
@@ -26,30 +30,6 @@ public class ActivityManager extends BasePlayerManager {
         loadActivityConfigData();
     }
 
-    private final Map<Integer, PlayerActivityData> playerActivityDataMap;
-
-    public ActivityManager(Player player) {
-        super(player);
-
-        playerActivityDataMap = new ConcurrentHashMap<>();
-        // load data for player
-        activityConfigItemMap
-                .values()
-                .forEach(
-                        item -> {
-                            var data = PlayerActivityData.getByPlayer(player, item.getActivityId());
-                            if (data == null) {
-                                data = item.getActivityHandler().initPlayerActivityData(player);
-                                data.save();
-                            }
-                            data.setPlayer(player);
-                            data.setActivityHandler(item.getActivityHandler());
-                            playerActivityDataMap.put(item.getActivityId(), data);
-                        });
-
-        player.sendPacket(new PacketActivityScheduleInfoNotify(activityConfigItemMap.values()));
-    }
-
     private static void loadActivityConfigData() {
         // scan activity type handler & watcher type
         var activityHandlerTypeMap = new HashMap<ActivityType, ConstructorAccess<?>>();
@@ -75,6 +55,7 @@ public class ActivityManager extends BasePlayerManager {
             DataLoader.loadList("ActivityConfig.json", ActivityConfigItem.class)
                     .forEach(
                             item -> {
+                                item.onLoad();
                                 var activityData = GameData.getActivityDataMap().get(item.getActivityId());
                                 if (activityData == null) {
                                     Grasscutter.getLogger().warn("activity {} not exist.", item.getActivityId());
@@ -104,6 +85,36 @@ public class ActivityManager extends BasePlayerManager {
         }
     }
 
+    public ActivityManager(Player player) {
+        super(player);
+
+        playerActivityDataMap = new ConcurrentHashMap<>();
+        // load data for player
+        activityConfigItemMap
+                .values()
+                .forEach(
+                        item -> {
+                            var data = PlayerActivityData.getByPlayer(player, item.getActivityId());
+                            if (data == null) {
+                                data = item.getActivityHandler().initPlayerActivityData(player);
+                                data.save();
+                            }
+                            data.setPlayer(player);
+                            data.setActivityHandler(item.getActivityHandler());
+                            playerActivityDataMap.put(item.getActivityId(), data);
+                        });
+
+        player.sendPacket(new PacketActivityScheduleInfoNotify(activityConfigItemMap.values()));
+
+        conditionExecutor =
+                new BasicActivityConditionExecutor(
+                        activityConfigItemMap,
+                        GameData.getActivityCondExcelConfigDataMap(),
+                        PlayerActivityDataMappingBuilder.buildPlayerActivityDataByActivityCondId(
+                                playerActivityDataMap),
+                        AllActivityConditionBuilder.buildActivityConditions());
+    }
+
     /** trigger activity watcher */
     public void triggerWatcher(WatcherTriggerType watcherTriggerType, String... params) {
         var watchers =
@@ -124,11 +135,71 @@ public class ActivityManager extends BasePlayerManager {
                                 params));
     }
 
+    public boolean isActivityActive(int activityId) {
+        var activityConfig = activityConfigItemMap.get(activityId);
+        if (activityConfig == null) {
+            return false;
+        }
+
+        var now = new Date();
+        return now.after(activityConfig.getBeginTime()) && now.before(activityConfig.getEndTime());
+    }
+
+    public boolean hasActivityEnded(int activityId) {
+        var activityConfig = activityConfigItemMap.get(activityId);
+        if (activityConfig == null) {
+            return true;
+        }
+
+        return new Date().after(activityConfig.getEndTime());
+    }
+
+    public boolean isActivityOpen(int activityId) {
+        var activityConfig = activityConfigItemMap.get(activityId);
+        if (activityConfig == null) {
+            return false;
+        }
+
+        var now = new Date();
+        return now.after(activityConfig.getOpenTime()) && now.before(activityConfig.getCloseTime());
+    }
+
+    public int getOpenDay(int activityId) {
+        var activityConfig = activityConfigItemMap.get(activityId);
+        if (activityConfig == null) {
+            return 0;
+        }
+
+        var now = new Date();
+        return (int)
+                        TimeUnit.DAYS.convert(
+                                now.getTime() - activityConfig.getOpenTime().getTime(), TimeUnit.MILLISECONDS)
+                + 1;
+    }
+
+    public boolean isActivityClosed(int activityId) {
+        var activityConfig = activityConfigItemMap.get(activityId);
+        if (activityConfig == null) {
+            return false;
+        }
+
+        var now = new Date();
+        return now.after(activityConfig.getCloseTime());
+    }
+
+    public boolean meetsCondition(int activityCondId) {
+        return conditionExecutor.meetsCondition(activityCondId);
+    }
+
+    public void triggerActivityConditions() {
+        activityConfigItemMap.forEach((k, v) -> v.getActivityHandler().triggerCondEvents(player));
+    }
+
     public ActivityInfoOuterClass.ActivityInfo getInfoProtoByActivityId(int activityId) {
         var activityHandler = activityConfigItemMap.get(activityId).getActivityHandler();
         var activityData = playerActivityDataMap.get(activityId);
 
-        return activityHandler.toProto(activityData);
+        return activityHandler.toProto(activityData, conditionExecutor);
     }
 
     public Optional<ActivityHandler> getActivityHandler(ActivityType type) {
@@ -138,7 +209,6 @@ public class ActivityManager extends BasePlayerManager {
                 .findFirst();
     }
 
-    @SuppressWarnings("unchecked")
     public <T extends ActivityHandler> Optional<T> getActivityHandlerAs(
             ActivityType type, Class<T> clazz) {
         return getActivityHandler(type).map(x -> (T) x);