Implement bounty trials

src/main/java/emu/nebula/Config.java

@@ -97,6 +97,7 @@ public class Config {
         public Set<String> defaultPermissions = Set.of("*");
         public boolean autoCreateAccount = true;
         public boolean skipIntro = false;
+        public boolean unlockInstances = true;
     }
     
     @Getter

src/main/java/emu/nebula/GameConstants.java

@@ -9,6 +9,7 @@ public class GameConstants {
     public static final int INTRO_GUIDE_ID = 1;
 
     public static final int GOLD_ITEM_ID = 1;
+    public static final int EXP_ITEM_ID = 21;
     
     public static final int MAX_FORMATIONS = 5;
     

src/main/java/emu/nebula/data/GameData.java

@@ -40,6 +40,12 @@ public class GameData {
     @Getter private static DataTable<DictionaryTabDef> DictionaryTabDataTable = new DataTable<>();
     @Getter private static DataTable<DictionaryEntryDef> DictionaryEntryDataTable = new DataTable<>();
     
+    @Getter private static DataTable<DailyInstanceDef> DailyInstanceDataTable = new DataTable<>();
+    @Getter private static DataTable<RegionBossLevelDef> RegionBossLevelDataTable = new DataTable<>();
+    @Getter private static DataTable<SkillInstanceDef> SkillInstanceDataTable = new DataTable<>();
+    @Getter private static DataTable<CharGemInstanceDef> CharGemInstanceDataTable = new DataTable<>();
+    @Getter private static DataTable<WeekBossLevelDef> WeekBossLevelDataTable = new DataTable<>();
+    
     @Getter private static DataTable<WorldClassDef> WorldClassDataTable = new DataTable<>();
     @Getter private static DataTable<GuideGroupDef> GuideGroupDataTable = new DataTable<>();
     @Getter private static DataTable<StoryDef> StoryDataTable = new DataTable<>();

src/main/java/emu/nebula/data/resources/CharGemInstanceDef.java

@@ -0,0 +1,52 @@
+package emu.nebula.data.resources;
+
+import emu.nebula.data.BaseDef;
+import emu.nebula.data.ResourceType;
+import emu.nebula.game.instance.InstanceData;
+import emu.nebula.game.inventory.ItemParamMap;
+import emu.nebula.util.JsonUtils;
+import lombok.Getter;
+
+@Getter
+@ResourceType(name = "CharGemInstance.json")
+public class CharGemInstanceDef extends BaseDef implements InstanceData {
+    private int Id;
+    private int PreLevelId;
+    private int PreLevelStar;
+    private int NeedWorldClass;
+    private int EnergyConsume;
+    private String BaseAwardPreview;
+    
+    private transient ItemParamMap firstRewards;
+    private transient ItemParamMap rewards;
+    
+    @Override
+    public int getId() {
+        return Id;
+    }
+    
+    @Override
+    public void onLoad() {
+        // Init reward maps
+        this.firstRewards = new ItemParamMap();
+        this.rewards = new ItemParamMap();
+        
+        // Parse rewards
+        var awards = JsonUtils.decodeList(this.BaseAwardPreview, int[].class);
+        if (awards == null) {
+            return;
+        }
+        
+        for (int[] award : awards) {
+            int itemId = award[0];
+            int count = award[1];
+            boolean isFirst = award[2] == 1;
+            
+            if (isFirst) {
+                this.firstRewards.put(itemId, count);
+            } else {
+                this.rewards.put(itemId, count);
+            }
+        }
+    }
+}

src/main/java/emu/nebula/data/resources/DailyInstanceDef.java

@@ -0,0 +1,57 @@
+package emu.nebula.data.resources;
+
+import emu.nebula.data.BaseDef;
+import emu.nebula.data.ResourceType;
+import emu.nebula.game.instance.InstanceData;
+import emu.nebula.game.inventory.ItemParamMap;
+import emu.nebula.util.JsonUtils;
+import lombok.Getter;
+
+@Getter
+@ResourceType(name = "DailyInstance.json")
+public class DailyInstanceDef extends BaseDef implements InstanceData {
+    private int Id;
+    private int PreLevelId;
+    private int PreLevelStar;
+    private int OneStarEnergyConsume;
+    private int NeedWorldClass;
+    private String BaseAwardPreview;
+    
+    private transient ItemParamMap firstRewards;
+    private transient ItemParamMap rewards;
+    
+    @Override
+    public int getId() {
+        return Id;
+    }
+
+    @Override
+    public int getEnergyConsume() {
+        return OneStarEnergyConsume;
+    }
+    
+    @Override
+    public void onLoad() {
+        // Init reward maps
+        this.firstRewards = new ItemParamMap();
+        this.rewards = new ItemParamMap();
+        
+        // Parse rewards
+        var awards = JsonUtils.decodeList(this.BaseAwardPreview, int[].class);
+        if (awards == null) {
+            return;
+        }
+        
+        for (int[] award : awards) {
+            int itemId = award[0];
+            int count = award[1];
+            boolean isFirst = award[2] == 1;
+            
+            if (isFirst) {
+                this.firstRewards.put(itemId, count);
+            } else {
+                this.rewards.put(itemId, count);
+            }
+        }
+    }
+}

src/main/java/emu/nebula/data/resources/RegionBossLevelDef.java

@@ -0,0 +1,52 @@
+package emu.nebula.data.resources;
+
+import emu.nebula.data.BaseDef;
+import emu.nebula.data.ResourceType;
+import emu.nebula.game.instance.InstanceData;
+import emu.nebula.game.inventory.ItemParamMap;
+import emu.nebula.util.JsonUtils;
+import lombok.Getter;
+
+@Getter
+@ResourceType(name = "RegionBossLevel.json")
+public class RegionBossLevelDef extends BaseDef implements InstanceData {
+    private int Id;
+    private int PreLevelId;
+    private int PreLevelStar;
+    private int NeedWorldClass;
+    private int EnergyConsume;
+    private String BaseAwardPreview;
+    
+    private transient ItemParamMap firstRewards;
+    private transient ItemParamMap rewards;
+    
+    @Override
+    public int getId() {
+        return Id;
+    }
+    
+    @Override
+    public void onLoad() {
+        // Init reward maps
+        this.firstRewards = new ItemParamMap();
+        this.rewards = new ItemParamMap();
+        
+        // Parse rewards
+        var awards = JsonUtils.decodeList(this.BaseAwardPreview, int[].class);
+        if (awards == null) {
+            return;
+        }
+        
+        for (int[] award : awards) {
+            int itemId = award[0];
+            int count = award[1];
+            boolean isFirst = award[2] == 1;
+            
+            if (isFirst) {
+                this.firstRewards.put(itemId, count);
+            } else {
+                this.rewards.put(itemId, count);
+            }
+        }
+    }
+}

src/main/java/emu/nebula/data/resources/SkillInstanceDef.java

@@ -0,0 +1,52 @@
+package emu.nebula.data.resources;
+
+import emu.nebula.data.BaseDef;
+import emu.nebula.data.ResourceType;
+import emu.nebula.game.instance.InstanceData;
+import emu.nebula.game.inventory.ItemParamMap;
+import emu.nebula.util.JsonUtils;
+import lombok.Getter;
+
+@Getter
+@ResourceType(name = "SkillInstance.json")
+public class SkillInstanceDef extends BaseDef implements InstanceData {
+    private int Id;
+    private int PreLevelId;
+    private int PreLevelStar;
+    private int NeedWorldClass;
+    private int EnergyConsume;
+    private String BaseAwardPreview;
+    
+    private transient ItemParamMap firstRewards;
+    private transient ItemParamMap rewards;
+    
+    @Override
+    public int getId() {
+        return Id;
+    }
+    
+    @Override
+    public void onLoad() {
+        // Init reward maps
+        this.firstRewards = new ItemParamMap();
+        this.rewards = new ItemParamMap();
+        
+        // Parse rewards
+        var awards = JsonUtils.decodeList(this.BaseAwardPreview, int[].class);
+        if (awards == null) {
+            return;
+        }
+        
+        for (int[] award : awards) {
+            int itemId = award[0];
+            int count = award[1];
+            boolean isFirst = award[2] == 1;
+            
+            if (isFirst) {
+                this.firstRewards.put(itemId, count);
+            } else {
+                this.rewards.put(itemId, count);
+            }
+        }
+    }
+}

src/main/java/emu/nebula/data/resources/WeekBossLevelDef.java

@@ -0,0 +1,54 @@
+package emu.nebula.data.resources;
+
+import emu.nebula.data.BaseDef;
+import emu.nebula.data.ResourceType;
+import emu.nebula.game.instance.InstanceData;
+import emu.nebula.game.inventory.ItemParamMap;
+import emu.nebula.util.JsonUtils;
+import lombok.Getter;
+
+@Getter
+@ResourceType(name = "WeekBossLevel.json")
+public class WeekBossLevelDef extends BaseDef implements InstanceData {
+    private int Id;
+    private int PreLevelId;
+    private int NeedWorldClass;
+    private String BaseAwardPreview;
+    
+    private transient ItemParamMap firstRewards;
+    private transient ItemParamMap rewards;
+    
+    @Override
+    public int getId() {
+        return Id;
+    }
+    
+    public int getEnergyConsume() {
+        return 0;
+    }
+    
+    @Override
+    public void onLoad() {
+        // Init reward maps
+        this.firstRewards = new ItemParamMap();
+        this.rewards = new ItemParamMap();
+        
+        // Parse rewards
+        var awards = JsonUtils.decodeList(this.BaseAwardPreview, int[].class);
+        if (awards == null) {
+            return;
+        }
+        
+        for (int[] award : awards) {
+            int itemId = award[0];
+            int count = award[1];
+            boolean isFirst = award[2] == 1;
+            
+            if (isFirst) {
+                this.firstRewards.put(itemId, count);
+            } else {
+                this.rewards.put(itemId, count);
+            }
+        }
+    }
+}

src/main/java/emu/nebula/game/instance/InstanceData.java

@@ -0,0 +1,34 @@
+package emu.nebula.game.instance;
+
+import emu.nebula.game.inventory.ItemParamMap;
+import emu.nebula.game.player.Player;
+
+public interface InstanceData {
+    
+    public int getId();
+    
+    public int getNeedWorldClass();
+    
+    public int getEnergyConsume();
+    
+    public ItemParamMap getFirstRewards();
+    
+    public ItemParamMap getRewards();
+    
+    /**
+     * Checks if the player has enough energy to complete this instance
+     * @return true if the player has enough energy
+     */
+    public default boolean hasEnergy(Player player) {
+        return this.hasEnergy(player, 1);
+    }
+    
+    /**
+     * Checks if the player has enough energy to complete this instance
+     * @return true if the player has enough energy
+     */
+    public default boolean hasEnergy(Player player, int count) {
+        return (this.getEnergyConsume() * count) <= player.getEnergy();
+    }
+    
+}

src/main/java/emu/nebula/game/instance/InstanceManager.java

@@ -0,0 +1,179 @@
+package emu.nebula.game.instance;
+
+import dev.morphia.annotations.Entity;
+import dev.morphia.annotations.Id;
+import emu.nebula.GameConstants;
+import emu.nebula.Nebula;
+import emu.nebula.data.GameData;
+import emu.nebula.database.GameDatabaseObject;
+import emu.nebula.game.player.Player;
+import emu.nebula.game.player.PlayerChangeInfo;
+import emu.nebula.game.player.PlayerManager;
+import emu.nebula.proto.PlayerData.PlayerInfo;
+import emu.nebula.proto.Public.CharGemInstance;
+import emu.nebula.proto.Public.DailyInstance;
+import emu.nebula.proto.Public.Energy;
+import emu.nebula.proto.Public.RegionBossLevel;
+import emu.nebula.proto.Public.SkillInstance;
+import emu.nebula.proto.Public.WeekBossLevel;
+import it.unimi.dsi.fastutil.ints.Int2IntMap;
+import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Entity(value = "instances", useDiscriminator = false)
+public class InstanceManager extends PlayerManager implements GameDatabaseObject {
+    @Id
+    private int uid;
+    
+    private Int2IntMap dailyInstanceLog;
+    private Int2IntMap regionBossLog;
+    private Int2IntMap skillInstanceLog;
+    private Int2IntMap charGemLog;
+    private Int2IntMap weekBossLog;
+    
+    @Setter
+    private transient int curInstanceId;
+    
+    @Deprecated // Morphia
+    public InstanceManager() {
+        
+    }
+    
+    public InstanceManager(Player player) {
+        super(player);
+        this.uid = player.getUid();
+        
+        this.dailyInstanceLog = new Int2IntOpenHashMap();
+        this.regionBossLog = new Int2IntOpenHashMap();
+        this.skillInstanceLog = new Int2IntOpenHashMap();
+        this.charGemLog = new Int2IntOpenHashMap();
+        this.weekBossLog = new Int2IntOpenHashMap();
+        
+        this.save();
+    }
+    
+    public void saveInstanceLog(Int2IntMap log, String logName, int id, int newStar) {
+        // Get current star
+        int star = log.get(id);
+        
+        // Check star
+        if (newStar <= star || newStar > 7) {
+            return;
+        }
+        
+        // Add to log and update database
+        log.put(id, newStar);
+        Nebula.getGameDatabase().update(this, this.getUid(), logName + "." + id, newStar);
+    }
+    
+    public PlayerChangeInfo settleInstance(InstanceData data, Int2IntMap log, String logName, int star) {
+        // Calculate settle data
+        var settleData = new InstanceSettleData();
+        
+        settleData.setWin(star > 0);
+        settleData.setFirst(settleData.isWin() && !log.containsKey(data.getId()));
+        
+        // Init player changes
+        var changes = new PlayerChangeInfo();
+        
+        // Handle win
+        if (settleData.isWin()) {
+            // Energy
+            settleData.setExp(data.getEnergyConsume());
+            getPlayer().consumeEnergy(settleData.getExp(), changes);
+            
+            // Awards
+            getPlayer().getInventory().addItem(GameConstants.EXP_ITEM_ID, settleData.getExp(), changes);
+            getPlayer().getInventory().addItems(data.getRewards(), changes);
+            
+            if (settleData.isFirst()) {
+                getPlayer().getInventory().addItems(data.getFirstRewards(), changes);
+            }
+            
+            // Log
+            this.saveInstanceLog(log, logName, data.getId(), star);
+        }
+        
+        // Log energy
+        if (data.getEnergyConsume() > 0) {
+            var energyProto = Energy.newInstance()
+                    .setPrimary(getPlayer().getEnergy())
+                    .setUpdateTime(Nebula.getCurrentTime() + 600);
+            
+            changes.add(energyProto);
+        }
+        
+        // Set extra data
+        changes.setExtraData(settleData);
+        
+        // Success
+        return changes.setSuccess(true);
+    }
+
+    // Proto
+    
+    public void toProto(PlayerInfo proto) {
+        // Init
+        int minStars = 0;
+        
+        // Simple hack to unlock all instances
+        if (Nebula.getConfig().getServerOptions().unlockInstances) {
+            minStars = 1;
+        }
+        
+        // Daily instance
+        for (var data : GameData.getDailyInstanceDataTable()) {
+            int stars = Math.max(getDailyInstanceLog().get(data.getId()), minStars);
+            
+            var p = DailyInstance.newInstance()
+                    .setId(data.getId())
+                    .setStar(stars);
+            
+            proto.addDailyInstances(p);
+        }
+        
+        // Regional boss
+        for (var data : GameData.getRegionBossLevelDataTable()) {
+            int stars = Math.max(getRegionBossLog().get(data.getId()), minStars);
+            
+            var p = RegionBossLevel.newInstance()
+                    .setId(data.getId())
+                    .setStar(stars);
+            
+            proto.addRegionBossLevels(p);
+        }
+        
+        // Skill instance
+        for (var data : GameData.getSkillInstanceDataTable()) {
+            int stars = Math.max(getSkillInstanceLog().get(data.getId()), minStars);
+            
+            var p = SkillInstance.newInstance()
+                    .setId(data.getId())
+                    .setStar(stars);
+            
+            proto.addSkillInstances(p);
+        }
+        
+        // Char gem instance
+        for (var data : GameData.getCharGemInstanceDataTable()) {
+            int stars = Math.max(getCharGemLog().get(data.getId()), minStars);
+            
+            var p = CharGemInstance.newInstance()
+                    .setId(data.getId())
+                    .setStar(stars);
+            
+            proto.addCharGemInstances(p);
+        }
+        
+        // Weekly boss
+        for (var data : GameData.getWeekBossLevelDataTable()) {
+            var p = WeekBossLevel.newInstance()
+                    .setId(data.getId())
+                    .setFirst(this.getWeekBossLog().get(data.getId()) == 1);
+            
+            proto.addWeekBossLevels(p);
+        }
+    }
+}

src/main/java/emu/nebula/game/instance/InstanceSettleData.java

@@ -0,0 +1,15 @@
+package emu.nebula.game.instance;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter @Setter
+public class InstanceSettleData {
+    private boolean isWin;
+    private boolean isFirst;
+    private int exp;
+    
+    public InstanceSettleData() {
+        
+    }
+}

src/main/java/emu/nebula/game/inventory/ItemParamMap.java

@@ -70,7 +70,7 @@ public class ItemParamMap extends Int2IntOpenHashMap {
         return list;
     }
 
-    public Stream<ItemTpl> itemTemplateStream() {
+    public Stream<ItemTpl> toItemTemplateStream() {
         return getEntrySet()
                 .stream()
                 .map(e -> ItemTpl.newInstance().setTid(e.getIntKey()).setQty(e.getIntValue()));

src/main/java/emu/nebula/game/mail/GameMail.java

@@ -77,7 +77,7 @@ public class GameMail {
                 .setDeadline(this.getExpiry());
         
         if (this.getAttachments() != null) {
-            this.getAttachments().itemTemplateStream()
+            this.getAttachments().toItemTemplateStream()
                 .forEach(proto::addAttachments);
         }
         

src/main/java/emu/nebula/game/player/Player.java

@@ -14,6 +14,7 @@ import emu.nebula.database.GameDatabaseObject;
 import emu.nebula.game.account.Account;
 import emu.nebula.game.character.CharacterStorage;
 import emu.nebula.game.formation.FormationManager;
+import emu.nebula.game.instance.InstanceManager;
 import emu.nebula.game.inventory.Inventory;
 import emu.nebula.game.mail.Mailbox;
 import emu.nebula.game.story.StoryManager;
@@ -69,6 +70,7 @@ public class Player implements GameDatabaseObject {
     private transient FormationManager formations;
     private transient Mailbox mailbox;
     private transient StarTowerManager starTowerManager;
+    private transient InstanceManager instanceManager;
     private transient StoryManager storyManager;
     
     @Deprecated // Morphia only
@@ -98,6 +100,7 @@ public class Player implements GameDatabaseObject {
         this.titlePrefix = 1;
         this.titleSuffix = 2;
         this.level = 1;
+        this.energy = 240;
         this.boards = new IntOpenHashSet();
         this.headIcons = new IntOpenHashSet();
         this.titles = new IntOpenHashSet();
@@ -278,6 +281,21 @@ public class Player implements GameDatabaseObject {
         
         return changes;
     }
+
+    public PlayerChangeInfo consumeEnergy(int amount, PlayerChangeInfo changes) {
+        // Check if changes is null
+        if (changes == null) {
+            changes = new PlayerChangeInfo();
+        }
+        
+        // Sanity
+        if (amount <= 0) {
+            return changes;
+        }
+        
+        // TODO
+        return changes;
+    }
     
     public void sendMessage(String string) {
         // Empty
@@ -286,6 +304,9 @@ public class Player implements GameDatabaseObject {
     // Login
     
     public void onLoad() {
+        // Debug 
+        this.energy = 240;
+        
         // Load from database
         this.getCharacters().loadFromDatabase();
         this.getInventory().loadFromDatabase();
@@ -309,6 +330,13 @@ public class Player implements GameDatabaseObject {
         } else {
             this.starTowerManager.setPlayer(this);
         }
+
+        this.instanceManager = Nebula.getGameDatabase().getObjectByField(InstanceManager.class, "_id", this.getUid());
+        if (this.instanceManager == null) {
+            this.instanceManager = new InstanceManager(this);
+        } else {
+            this.instanceManager.setPlayer(this);
+        }
         
         this.storyManager = Nebula.getGameDatabase().getObjectByField(StoryManager.class, "_id", this.getUid());
         if (this.storyManager == null) {
@@ -342,7 +370,7 @@ public class Player implements GameDatabaseObject {
             .getMutableEnergy()
                 .setUpdateTime(Nebula.getCurrentTime())
                 .setNextDuration(60)
-                .setPrimary(240)
+                .setPrimary(this.getEnergy())
                 .setIsPrimary(true);
         
         // Add characters/discs/res/items
@@ -442,6 +470,9 @@ public class Player implements GameDatabaseObject {
         // Extra
         proto.setAchievements(new byte[64]);
         
+        // Add instance
+        this.getInstanceManager().toProto(proto);
+        
         proto.getMutableVampireSurvivorRecord()
             .getMutableSeason();
         

src/main/java/emu/nebula/server/handlers/HandlerActivityDetailReq.java

@@ -8,7 +8,6 @@ import emu.nebula.proto.Public.ActivityTrial;
 import emu.nebula.net.HandlerId;
 import emu.nebula.net.GameSession;
 
-@SuppressWarnings("unused")
 @HandlerId(NetMsgId.activity_detail_req)
 public class HandlerActivityDetailReq extends NetHandler {
 

src/main/java/emu/nebula/server/handlers/HandlerCharGemInstanceApplyReq.java

@@ -0,0 +1,35 @@
+package emu.nebula.server.handlers;
+
+import emu.nebula.net.NetHandler;
+import emu.nebula.net.NetMsgId;
+import emu.nebula.proto.CharGemInstanceApply.CharGemInstanceApplyReq;
+import emu.nebula.net.HandlerId;
+import emu.nebula.data.GameData;
+import emu.nebula.net.GameSession;
+
+@HandlerId(NetMsgId.char_gem_instance_apply_req)
+public class HandlerCharGemInstanceApplyReq extends NetHandler {
+
+    @Override
+    public byte[] handle(GameSession session, byte[] message) throws Exception {
+        // Parse request
+        var req = CharGemInstanceApplyReq.parseFrom(message);
+        
+        var data = GameData.getCharGemInstanceDataTable().get(req.getId());
+        if (data == null) {
+            return this.encodeMsg(NetMsgId.char_gem_instance_apply_failed_ack);
+        }
+        
+        // Check player energy
+        if (data.getEnergyConsume() > session.getPlayer().getEnergy()) {
+            return this.encodeMsg(NetMsgId.char_gem_instance_apply_failed_ack);
+        }
+        
+        // Set player
+        session.getPlayer().getInstanceManager().setCurInstanceId(req.getId());
+        
+        // Template
+        return this.encodeMsg(NetMsgId.char_gem_instance_apply_succeed_ack);
+    }
+
+}

src/main/java/emu/nebula/server/handlers/HandlerCharGemInstanceSettleReq.java

@@ -0,0 +1,58 @@
+package emu.nebula.server.handlers;
+
+import emu.nebula.net.NetHandler;
+import emu.nebula.net.NetMsgId;
+import emu.nebula.proto.CharGemInstanceSettle.CharGemInstanceSettleReq;
+import emu.nebula.proto.CharGemInstanceSettle.CharGemInstanceSettleResp;
+import emu.nebula.net.HandlerId;
+import emu.nebula.data.GameData;
+import emu.nebula.game.instance.InstanceSettleData;
+import emu.nebula.net.GameSession;
+
+@HandlerId(NetMsgId.char_gem_instance_settle_req)
+public class HandlerCharGemInstanceSettleReq extends NetHandler {
+
+    @Override
+    public byte[] handle(GameSession session, byte[] message) throws Exception {
+        // Cache player
+        var player = session.getPlayer();
+        
+        // Get boss level data
+        var data = GameData.getCharGemInstanceDataTable().get(player.getInstanceManager().getCurInstanceId());
+        if (data == null || !data.hasEnergy(player)) {
+            return this.encodeMsg(NetMsgId.char_gem_instance_settle_failed_ack);
+        }
+        
+        // Parse request
+        var req = CharGemInstanceSettleReq.parseFrom(message);
+        
+        // Settle instance
+        var changes = player.getInstanceManager().settleInstance(
+                data,
+                player.getInstanceManager().getCharGemLog(),
+                "charGemLog",
+                req.getStar()
+        );
+        
+        var settleData = (InstanceSettleData) changes.getExtraData();
+        
+        // Create response
+        var rsp = CharGemInstanceSettleResp.newInstance()
+                .setExp(settleData.getExp())
+                .setThreeStar(req.getStar() == 7)
+                .setChange(changes.toProto());
+        
+        // Add reward items
+        if (settleData.isWin()) {
+            data.getRewards().toItemTemplateStream().forEach(rsp::addAwardItems);
+            
+            if (settleData.isFirst()) {
+                data.getFirstRewards().toItemTemplateStream().forEach(rsp::addAwardItems);
+            }
+        }
+        
+        // Send response
+        return this.encodeMsg(NetMsgId.char_gem_instance_settle_succeed_ack, rsp);
+    }
+
+}

src/main/java/emu/nebula/server/handlers/HandlerDailyInstanceApplyReq.java

@@ -0,0 +1,35 @@
+package emu.nebula.server.handlers;
+
+import emu.nebula.net.NetHandler;
+import emu.nebula.net.NetMsgId;
+import emu.nebula.proto.DailyInstanceApply.DailyInstanceApplyReq;
+import emu.nebula.net.HandlerId;
+import emu.nebula.data.GameData;
+import emu.nebula.net.GameSession;
+
+@HandlerId(NetMsgId.daily_instance_apply_req)
+public class HandlerDailyInstanceApplyReq extends NetHandler {
+
+    @Override
+    public byte[] handle(GameSession session, byte[] message) throws Exception {
+        // Parse request
+        var req = DailyInstanceApplyReq.parseFrom(message);
+        
+        var data = GameData.getDailyInstanceDataTable().get(req.getId());
+        if (data == null) {
+            return this.encodeMsg(NetMsgId.daily_instance_apply_failed_ack);
+        }
+        
+        // Check player energy
+        if (data.getEnergyConsume() > session.getPlayer().getEnergy()) {
+            return this.encodeMsg(NetMsgId.daily_instance_apply_failed_ack);
+        }
+        
+        // Set player
+        session.getPlayer().getInstanceManager().setCurInstanceId(req.getId());
+        
+        // Template
+        return this.encodeMsg(NetMsgId.daily_instance_apply_succeed_ack);
+    }
+
+}

src/main/java/emu/nebula/server/handlers/HandlerDailyInstanceSettleReq.java

@@ -0,0 +1,48 @@
+package emu.nebula.server.handlers;
+
+import emu.nebula.net.NetHandler;
+import emu.nebula.net.NetMsgId;
+import emu.nebula.proto.DailyInstanceSettle.DailyInstanceSettleReq;
+import emu.nebula.proto.DailyInstanceSettle.DailyInstanceSettleResp;
+import emu.nebula.net.HandlerId;
+import emu.nebula.data.GameData;
+import emu.nebula.game.instance.InstanceSettleData;
+import emu.nebula.net.GameSession;
+
+@HandlerId(NetMsgId.daily_instance_settle_req)
+public class HandlerDailyInstanceSettleReq extends NetHandler {
+
+    @Override
+    public byte[] handle(GameSession session, byte[] message) throws Exception {
+        // Cache player
+        var player = session.getPlayer();
+        
+        // Get boss level data
+        var data = GameData.getDailyInstanceDataTable().get(player.getInstanceManager().getCurInstanceId());
+        if (data == null || !data.hasEnergy(player)) {
+            return this.encodeMsg(NetMsgId.daily_instance_settle_failed_ack);
+        }
+        
+        // Parse request
+        var req = DailyInstanceSettleReq.parseFrom(message);
+        
+        // Settle instance
+        var changes = player.getInstanceManager().settleInstance(
+                data,
+                player.getInstanceManager().getDailyInstanceLog(),
+                "dailyInstanceLog",
+                req.getStar()
+        );
+        
+        var settleData = (InstanceSettleData) changes.getExtraData();
+        
+        // Create response
+        var rsp = DailyInstanceSettleResp.newInstance()
+                .setExp(settleData.getExp())
+                .setChange(changes.toProto());
+        
+        // Send response
+        return this.encodeMsg(NetMsgId.daily_instance_settle_succeed_ack, rsp);
+    }
+
+}

src/main/java/emu/nebula/server/handlers/HandlerRegionBossLevelApplyReq.java

@@ -0,0 +1,35 @@
+package emu.nebula.server.handlers;
+
+import emu.nebula.net.NetHandler;
+import emu.nebula.net.NetMsgId;
+import emu.nebula.proto.RegionBossLevelApply.RegionBossLevelApplyReq;
+import emu.nebula.net.HandlerId;
+import emu.nebula.data.GameData;
+import emu.nebula.net.GameSession;
+
+@HandlerId(NetMsgId.region_boss_level_apply_req)
+public class HandlerRegionBossLevelApplyReq extends NetHandler {
+
+    @Override
+    public byte[] handle(GameSession session, byte[] message) throws Exception {
+        // Parse request
+        var req = RegionBossLevelApplyReq.parseFrom(message);
+        
+        var data = GameData.getRegionBossLevelDataTable().get(req.getId());
+        if (data == null) {
+            return this.encodeMsg(NetMsgId.region_boss_level_apply_failed_ack);
+        }
+        
+        // Check player energy
+        if (data.getEnergyConsume() > session.getPlayer().getEnergy()) {
+            return this.encodeMsg(NetMsgId.region_boss_level_apply_failed_ack);
+        }
+        
+        // Set player
+        session.getPlayer().getInstanceManager().setCurInstanceId(req.getId());
+        
+        // Template
+        return this.encodeMsg(NetMsgId.region_boss_level_apply_succeed_ack);
+    }
+
+}

src/main/java/emu/nebula/server/handlers/HandlerRegionBossLevelSettleReq.java

@@ -0,0 +1,58 @@
+package emu.nebula.server.handlers;
+
+import emu.nebula.net.NetHandler;
+import emu.nebula.net.NetMsgId;
+import emu.nebula.proto.RegionBossLevelSettle.RegionBossLevelSettleReq;
+import emu.nebula.proto.RegionBossLevelSettle.RegionBossLevelSettleResp;
+import emu.nebula.net.HandlerId;
+import emu.nebula.data.GameData;
+import emu.nebula.game.instance.InstanceSettleData;
+import emu.nebula.net.GameSession;
+
+@HandlerId(NetMsgId.region_boss_level_settle_req)
+public class HandlerRegionBossLevelSettleReq extends NetHandler {
+
+    @Override
+    public byte[] handle(GameSession session, byte[] message) throws Exception {
+        // Cache player
+        var player = session.getPlayer();
+        
+        // Get boss level data
+        var data = GameData.getRegionBossLevelDataTable().get(player.getInstanceManager().getCurInstanceId());
+        if (data == null || !data.hasEnergy(player)) {
+            return this.encodeMsg(NetMsgId.region_boss_level_settle_failed_ack);
+        }
+        
+        // Parse request
+        var req = RegionBossLevelSettleReq.parseFrom(message);
+        
+        // Settle instance
+        var changes = player.getInstanceManager().settleInstance(
+                data,
+                player.getInstanceManager().getRegionBossLog(),
+                "regionBossLog",
+                req.getStar()
+        );
+        
+        var settleData = (InstanceSettleData) changes.getExtraData();
+        
+        // Create response
+        var rsp = RegionBossLevelSettleResp.newInstance()
+                .setExp(settleData.getExp())
+                .setThreeStar(req.getStar() == 7)
+                .setChange(changes.toProto());
+        
+        // Add reward items
+        if (settleData.isWin()) {
+            data.getRewards().toItemTemplateStream().forEach(rsp::addAwardItems);
+            
+            if (settleData.isFirst()) {
+                data.getFirstRewards().toItemTemplateStream().forEach(rsp::addAwardItems);
+            }
+        }
+        
+        // Send response
+        return this.encodeMsg(NetMsgId.region_boss_level_settle_succeed_ack, rsp);
+    }
+
+}

src/main/java/emu/nebula/server/handlers/HandlerSkillInstanceApplyReq.java

@@ -0,0 +1,35 @@
+package emu.nebula.server.handlers;
+
+import emu.nebula.net.NetHandler;
+import emu.nebula.net.NetMsgId;
+import emu.nebula.proto.SkillInstanceApply.SkillInstanceApplyReq;
+import emu.nebula.net.HandlerId;
+import emu.nebula.data.GameData;
+import emu.nebula.net.GameSession;
+
+@HandlerId(NetMsgId.skill_instance_apply_req)
+public class HandlerSkillInstanceApplyReq extends NetHandler {
+
+    @Override
+    public byte[] handle(GameSession session, byte[] message) throws Exception {
+        // Parse request
+        var req = SkillInstanceApplyReq.parseFrom(message);
+        
+        var data = GameData.getSkillInstanceDataTable().get(req.getId());
+        if (data == null) {
+            return this.encodeMsg(NetMsgId.skill_instance_apply_failed_ack);
+        }
+        
+        // Check player energy
+        if (data.getEnergyConsume() > session.getPlayer().getEnergy()) {
+            return this.encodeMsg(NetMsgId.skill_instance_apply_failed_ack);
+        }
+        
+        // Set player
+        session.getPlayer().getInstanceManager().setCurInstanceId(req.getId());
+        
+        // Template
+        return this.encodeMsg(NetMsgId.skill_instance_apply_succeed_ack);
+    }
+
+}

src/main/java/emu/nebula/server/handlers/HandlerSkillInstanceSettleReq.java

@@ -0,0 +1,58 @@
+package emu.nebula.server.handlers;
+
+import emu.nebula.net.NetHandler;
+import emu.nebula.net.NetMsgId;
+import emu.nebula.proto.SkillInstanceSettle.SkillInstanceSettleReq;
+import emu.nebula.proto.SkillInstanceSettle.SkillInstanceSettleResp;
+import emu.nebula.net.HandlerId;
+import emu.nebula.data.GameData;
+import emu.nebula.game.instance.InstanceSettleData;
+import emu.nebula.net.GameSession;
+
+@HandlerId(NetMsgId.skill_instance_settle_req)
+public class HandlerSkillInstanceSettleReq extends NetHandler {
+
+    @Override
+    public byte[] handle(GameSession session, byte[] message) throws Exception {
+        // Cache player
+        var player = session.getPlayer();
+        
+        // Get boss level data
+        var data = GameData.getSkillInstanceDataTable().get(player.getInstanceManager().getCurInstanceId());
+        if (data == null || !data.hasEnergy(player)) {
+            return this.encodeMsg(NetMsgId.skill_instance_settle_failed_ack);
+        }
+        
+        // Parse request
+        var req = SkillInstanceSettleReq.parseFrom(message);
+        
+        // Settle instance
+        var changes = player.getInstanceManager().settleInstance(
+                data,
+                player.getInstanceManager().getSkillInstanceLog(),
+                "skillInstanceLog",
+                req.getStar()
+        );
+        
+        var settleData = (InstanceSettleData) changes.getExtraData();
+        
+        // Create response
+        var rsp = SkillInstanceSettleResp.newInstance()
+                .setExp(settleData.getExp())
+                .setThreeStar(req.getStar() == 7)
+                .setChange(changes.toProto());
+        
+        // Add reward items
+        if (settleData.isWin()) {
+            data.getRewards().toItemTemplateStream().forEach(rsp::addAwardItems);
+            
+            if (settleData.isFirst()) {
+                data.getFirstRewards().toItemTemplateStream().forEach(rsp::addAwardItems);
+            }
+        }
+        
+        // Send response
+        return this.encodeMsg(NetMsgId.skill_instance_settle_succeed_ack, rsp);
+    }
+
+}

src/main/java/emu/nebula/server/handlers/HandlerWeekBossApplyReq.java

@@ -0,0 +1,30 @@
+package emu.nebula.server.handlers;
+
+import emu.nebula.net.NetHandler;
+import emu.nebula.net.NetMsgId;
+import emu.nebula.proto.WeekBossApply.WeekBossApplyReq;
+import emu.nebula.net.HandlerId;
+import emu.nebula.data.GameData;
+import emu.nebula.net.GameSession;
+
+@HandlerId(NetMsgId.week_boss_apply_req)
+public class HandlerWeekBossApplyReq extends NetHandler {
+
+    @Override
+    public byte[] handle(GameSession session, byte[] message) throws Exception {
+        // Parse request
+        var req = WeekBossApplyReq.parseFrom(message);
+        
+        var data = GameData.getWeekBossLevelDataTable().get(req.getId());
+        if (data == null) {
+            return this.encodeMsg(NetMsgId.week_boss_apply_failed_ack);
+        }
+        
+        // Set player
+        session.getPlayer().getInstanceManager().setCurInstanceId(req.getId());
+        
+        // Template
+        return this.encodeMsg(NetMsgId.week_boss_apply_succeed_ack);
+    }
+
+}

src/main/java/emu/nebula/server/handlers/HandlerWeekBossSettleReq.java

@@ -0,0 +1,57 @@
+package emu.nebula.server.handlers;
+
+import emu.nebula.net.NetHandler;
+import emu.nebula.net.NetMsgId;
+import emu.nebula.proto.WeekBossSettle.WeekBossLevelSettleResp;
+import emu.nebula.proto.WeekBossSettle.WeekBossSettleReq;
+import emu.nebula.net.HandlerId;
+import emu.nebula.data.GameData;
+import emu.nebula.game.instance.InstanceSettleData;
+import emu.nebula.net.GameSession;
+
+@HandlerId(NetMsgId.week_boss_settle_req)
+public class HandlerWeekBossSettleReq extends NetHandler {
+
+    @Override
+    public byte[] handle(GameSession session, byte[] message) throws Exception {
+        // Cache player
+        var player = session.getPlayer();
+        
+        // Get boss level data
+        var data = GameData.getWeekBossLevelDataTable().get(player.getInstanceManager().getCurInstanceId());
+        if (data == null || !data.hasEnergy(player)) {
+            return this.encodeMsg(NetMsgId.week_boss_settle_failed_ack);
+        }
+        
+        // Parse request
+        var req = WeekBossSettleReq.parseFrom(message);
+        
+        // Settle instance
+        var changes = player.getInstanceManager().settleInstance(
+                data,
+                player.getInstanceManager().getWeekBossLog(),
+                "weekBossLog",
+                req.getResult() ? 1 : 0
+        );
+        
+        var settleData = (InstanceSettleData) changes.getExtraData();
+        
+        // Create response
+        var rsp = WeekBossLevelSettleResp.newInstance()
+                .setFirst(settleData.isFirst())
+                .setChange(changes.toProto());
+        
+        // Add reward items
+        if (settleData.isWin()) {
+            data.getRewards().toItemTemplateStream().forEach(rsp::addAwardItems);
+            
+            if (settleData.isFirst()) {
+                data.getFirstRewards().toItemTemplateStream().forEach(rsp::addAwardItems);
+            }
+        }
+        
+        // Send response
+        return this.encodeMsg(NetMsgId.week_boss_settle_succeed_ack, rsp);
+    }
+
+}