diff --git a/src/main/java/emu/nebula/Config.java b/src/main/java/emu/nebula/Config.java index 8b1aa38..561b644 100644 --- a/src/main/java/emu/nebula/Config.java +++ b/src/main/java/emu/nebula/Config.java @@ -97,6 +97,7 @@ public class Config { public Set defaultPermissions = Set.of("*"); public boolean autoCreateAccount = true; public boolean skipIntro = false; + public boolean unlockInstances = true; } @Getter diff --git a/src/main/java/emu/nebula/GameConstants.java b/src/main/java/emu/nebula/GameConstants.java index c5ea5cf..bbfcab4 100644 --- a/src/main/java/emu/nebula/GameConstants.java +++ b/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; diff --git a/src/main/java/emu/nebula/data/GameData.java b/src/main/java/emu/nebula/data/GameData.java index 351cf68..dccc289 100644 --- a/src/main/java/emu/nebula/data/GameData.java +++ b/src/main/java/emu/nebula/data/GameData.java @@ -40,6 +40,12 @@ public class GameData { @Getter private static DataTable DictionaryTabDataTable = new DataTable<>(); @Getter private static DataTable DictionaryEntryDataTable = new DataTable<>(); + @Getter private static DataTable DailyInstanceDataTable = new DataTable<>(); + @Getter private static DataTable RegionBossLevelDataTable = new DataTable<>(); + @Getter private static DataTable SkillInstanceDataTable = new DataTable<>(); + @Getter private static DataTable CharGemInstanceDataTable = new DataTable<>(); + @Getter private static DataTable WeekBossLevelDataTable = new DataTable<>(); + @Getter private static DataTable WorldClassDataTable = new DataTable<>(); @Getter private static DataTable GuideGroupDataTable = new DataTable<>(); @Getter private static DataTable StoryDataTable = new DataTable<>(); diff --git a/src/main/java/emu/nebula/data/resources/CharGemInstanceDef.java b/src/main/java/emu/nebula/data/resources/CharGemInstanceDef.java new file mode 100644 index 0000000..b6d2274 --- /dev/null +++ b/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); + } + } + } +} diff --git a/src/main/java/emu/nebula/data/resources/DailyInstanceDef.java b/src/main/java/emu/nebula/data/resources/DailyInstanceDef.java new file mode 100644 index 0000000..48b151f --- /dev/null +++ b/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); + } + } + } +} diff --git a/src/main/java/emu/nebula/data/resources/RegionBossLevelDef.java b/src/main/java/emu/nebula/data/resources/RegionBossLevelDef.java new file mode 100644 index 0000000..27b2b46 --- /dev/null +++ b/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); + } + } + } +} diff --git a/src/main/java/emu/nebula/data/resources/SkillInstanceDef.java b/src/main/java/emu/nebula/data/resources/SkillInstanceDef.java new file mode 100644 index 0000000..ef6644e --- /dev/null +++ b/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); + } + } + } +} diff --git a/src/main/java/emu/nebula/data/resources/WeekBossLevelDef.java b/src/main/java/emu/nebula/data/resources/WeekBossLevelDef.java new file mode 100644 index 0000000..e42eba4 --- /dev/null +++ b/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); + } + } + } +} diff --git a/src/main/java/emu/nebula/game/instance/InstanceData.java b/src/main/java/emu/nebula/game/instance/InstanceData.java new file mode 100644 index 0000000..5df10e7 --- /dev/null +++ b/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(); + } + +} diff --git a/src/main/java/emu/nebula/game/instance/InstanceManager.java b/src/main/java/emu/nebula/game/instance/InstanceManager.java new file mode 100644 index 0000000..108dddd --- /dev/null +++ b/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); + } + } +} diff --git a/src/main/java/emu/nebula/game/instance/InstanceSettleData.java b/src/main/java/emu/nebula/game/instance/InstanceSettleData.java new file mode 100644 index 0000000..75b2a19 --- /dev/null +++ b/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() { + + } +} diff --git a/src/main/java/emu/nebula/game/inventory/ItemParamMap.java b/src/main/java/emu/nebula/game/inventory/ItemParamMap.java index ac3d0fd..0057ff0 100644 --- a/src/main/java/emu/nebula/game/inventory/ItemParamMap.java +++ b/src/main/java/emu/nebula/game/inventory/ItemParamMap.java @@ -70,7 +70,7 @@ public class ItemParamMap extends Int2IntOpenHashMap { return list; } - public Stream itemTemplateStream() { + public Stream toItemTemplateStream() { return getEntrySet() .stream() .map(e -> ItemTpl.newInstance().setTid(e.getIntKey()).setQty(e.getIntValue())); diff --git a/src/main/java/emu/nebula/game/mail/GameMail.java b/src/main/java/emu/nebula/game/mail/GameMail.java index 510cce2..c9fdcad 100644 --- a/src/main/java/emu/nebula/game/mail/GameMail.java +++ b/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); } diff --git a/src/main/java/emu/nebula/game/player/Player.java b/src/main/java/emu/nebula/game/player/Player.java index e1c834f..ca6b352 100644 --- a/src/main/java/emu/nebula/game/player/Player.java +++ b/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(); diff --git a/src/main/java/emu/nebula/server/handlers/HandlerActivityDetailReq.java b/src/main/java/emu/nebula/server/handlers/HandlerActivityDetailReq.java index c9e73a9..1c087fe 100644 --- a/src/main/java/emu/nebula/server/handlers/HandlerActivityDetailReq.java +++ b/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 { diff --git a/src/main/java/emu/nebula/server/handlers/HandlerCharGemInstanceApplyReq.java b/src/main/java/emu/nebula/server/handlers/HandlerCharGemInstanceApplyReq.java new file mode 100644 index 0000000..7a4f45b --- /dev/null +++ b/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); + } + +} diff --git a/src/main/java/emu/nebula/server/handlers/HandlerCharGemInstanceSettleReq.java b/src/main/java/emu/nebula/server/handlers/HandlerCharGemInstanceSettleReq.java new file mode 100644 index 0000000..17a6af3 --- /dev/null +++ b/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); + } + +} diff --git a/src/main/java/emu/nebula/server/handlers/HandlerDailyInstanceApplyReq.java b/src/main/java/emu/nebula/server/handlers/HandlerDailyInstanceApplyReq.java new file mode 100644 index 0000000..b5925ae --- /dev/null +++ b/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); + } + +} diff --git a/src/main/java/emu/nebula/server/handlers/HandlerDailyInstanceSettleReq.java b/src/main/java/emu/nebula/server/handlers/HandlerDailyInstanceSettleReq.java new file mode 100644 index 0000000..d49df54 --- /dev/null +++ b/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); + } + +} diff --git a/src/main/java/emu/nebula/server/handlers/HandlerRegionBossLevelApplyReq.java b/src/main/java/emu/nebula/server/handlers/HandlerRegionBossLevelApplyReq.java new file mode 100644 index 0000000..dfdaea8 --- /dev/null +++ b/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); + } + +} diff --git a/src/main/java/emu/nebula/server/handlers/HandlerRegionBossLevelSettleReq.java b/src/main/java/emu/nebula/server/handlers/HandlerRegionBossLevelSettleReq.java new file mode 100644 index 0000000..9e25b2e --- /dev/null +++ b/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); + } + +} diff --git a/src/main/java/emu/nebula/server/handlers/HandlerSkillInstanceApplyReq.java b/src/main/java/emu/nebula/server/handlers/HandlerSkillInstanceApplyReq.java new file mode 100644 index 0000000..b78e56a --- /dev/null +++ b/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); + } + +} diff --git a/src/main/java/emu/nebula/server/handlers/HandlerSkillInstanceSettleReq.java b/src/main/java/emu/nebula/server/handlers/HandlerSkillInstanceSettleReq.java new file mode 100644 index 0000000..e83b442 --- /dev/null +++ b/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); + } + +} diff --git a/src/main/java/emu/nebula/server/handlers/HandlerWeekBossApplyReq.java b/src/main/java/emu/nebula/server/handlers/HandlerWeekBossApplyReq.java new file mode 100644 index 0000000..c758c48 --- /dev/null +++ b/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); + } + +} diff --git a/src/main/java/emu/nebula/server/handlers/HandlerWeekBossSettleReq.java b/src/main/java/emu/nebula/server/handlers/HandlerWeekBossSettleReq.java new file mode 100644 index 0000000..91a6576 --- /dev/null +++ b/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); + } + +}