Merge branch 'development' into api

# Conflicts:
#	src/main/java/emu/grasscutter/Grasscutter.java

src/main/java/emu/grasscutter/scripts/data/SceneGadget.java

+package emu.grasscutter.scripts.data;
+
+import emu.grasscutter.utils.Position;
+
+public class SceneGadget {
+	public int level;
+	public int config_id;
+	public int gadget_id;
+	public int state;
+	public Position pos;
+	public Position rot;
+}

src/main/java/emu/grasscutter/scripts/data/SceneGroup.java

+package emu.grasscutter.scripts.data;
+
+import java.util.List;
+
+import emu.grasscutter.utils.Position;
+
+public class SceneGroup {
+	public transient int block_id; // Not an actual variable in the scripts but we will keep it here for reference
+	
+	public int id;
+	public int refresh_id;
+	public Position pos;
+	
+	public List<SceneMonster> monsters;
+	public List<SceneGadget> gadgets;
+	public List<SceneTrigger> triggers;
+	public List<SceneSuite> suites;
+	public SceneInitConfig init_config;
+	
+	private transient boolean isLoaded; // Not an actual variable in the scripts either
+
+	public boolean isLoaded() {
+		return isLoaded;
+	}
+	
+	public boolean setLoaded(boolean loaded) {
+		return loaded;
+	}
+	
+	public SceneSuite getSuiteByIndex(int index) {
+		return suites.get(index - 1);
+	}
+}

src/main/java/emu/grasscutter/scripts/data/SceneInitConfig.java

+package emu.grasscutter.scripts.data;
+
+import emu.grasscutter.utils.Position;
+
+public class SceneInitConfig {
+	public int suite;
+	public int end_suite;
+	public int rand_suite;
+}

src/main/java/emu/grasscutter/scripts/data/SceneMonster.java

+package emu.grasscutter.scripts.data;
+
+import emu.grasscutter.utils.Position;
+
+public class SceneMonster {
+	public int level;
+	public int config_id;
+	public int monster_id;
+	public Position pos;
+	public Position rot;
+}

src/main/java/emu/grasscutter/scripts/data/SceneSuite.java

+package emu.grasscutter.scripts.data;
+
+import java.util.List;
+
+import emu.grasscutter.utils.Position;
+
+public class SceneSuite {
+	public List<Integer> monsters;
+	public List<String> triggers;
+	public int rand_weight;
+	
+	public transient List<SceneMonster> sceneMonsters;
+}

src/main/java/emu/grasscutter/scripts/data/SceneTrigger.java

+package emu.grasscutter.scripts.data;
+
+public class SceneTrigger {
+	public String name;
+	public int config_id;
+	public int event;
+	public String source;
+	public String condition;
+	public String action;
+}

src/main/java/emu/grasscutter/scripts/data/SceneVar.java

+package emu.grasscutter.scripts.data;
+
+public class SceneVar {
+	public String name;
+	public int value;
+	public boolean no_refresh;
+}

src/main/java/emu/grasscutter/scripts/data/ScriptArgs.java

+package emu.grasscutter.scripts.data;
+
+public class ScriptArgs {
+	public int param1;
+	public int param2;
+	public int param3;
+	
+	public ScriptArgs() {
+		
+	}
+
+	public ScriptArgs(int param1) {
+		this.param1 = param1;
+	}
+
+	public ScriptArgs(int param1, int param2) {
+		this.param1 = param1;
+		this.param2 = param2;
+	}
+
+	public int getParam1() {
+		return param1;
+	}
+
+	public ScriptArgs setParam1(int param1) {
+		this.param1 = param1;
+		return this;
+	}
+
+	public int getParam2() {
+		return param2;
+	}
+
+	public ScriptArgs setParam2(int param2) {
+		this.param2 = param2;
+		return this;
+	}
+
+	public int getParam3() {
+		return param3;
+	}
+
+	public ScriptArgs setParam3(int param3) {
+		this.param3 = param3;
+		return this;
+	}
+}

src/main/java/emu/grasscutter/scripts/serializer/LuaSerializer.java

+package emu.grasscutter.scripts.serializer;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.luaj.vm2.LuaTable;
+import org.luaj.vm2.LuaValue;
+
+public class LuaSerializer implements Serializer {
+	
+	@Override
+	public <T> List<T> toList(Class<T> type, Object obj) {
+		return serializeList(type, (LuaTable) obj);
+	}
+
+	@Override
+	public <T> T toObject(Class<T> type, Object obj) {
+		return serialize(type, (LuaTable) obj);
+	}
+	
+	public <T> List<T> serializeList(Class<T> type, LuaTable table) {
+		List<T> list = new ArrayList();
+		
+		try {
+			LuaValue[] keys = table.keys();
+			for (LuaValue k : keys) {
+				try {
+					LuaValue keyValue = table.get(k);
+					
+					T object = null;
+					
+					if (keyValue.istable()) {
+						object = serialize(type, keyValue.checktable());
+				    } else if (keyValue.isint()) {
+				    	object = (T) (Integer) keyValue.toint();
+				    } else if (keyValue.isnumber()) {
+				    	object = (T) (Float) keyValue.tofloat(); // terrible...
+				    } else if (keyValue.isstring()) {
+				    	object = (T) keyValue.tojstring();
+				    } else {
+				    	object = (T) keyValue;
+				    }
+					
+					if (object != null) {
+						list.add(object);
+					}
+				} catch (Exception ex) {
+
+				}
+			}
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+
+		return list;
+	}
+	
+	public <T> T serialize(Class<T> type, LuaTable table) {
+		T object = null;
+		
+		if (type == List.class) {
+			try {
+				Class<T> listType = (Class<T>) type.getTypeParameters()[0].getClass();
+				return (T) serializeList(listType, table);
+			} catch (Exception e) {
+				e.printStackTrace();
+				return null;
+			}
+		}
+		
+		try {
+			object = type.getDeclaredConstructor().newInstance(null);
+			
+			LuaValue[] keys = table.keys();
+			for (LuaValue k : keys) {
+				try {
+					Field field = object.getClass().getDeclaredField(k.checkjstring());
+					if (field == null) {
+						continue;
+					}
+					
+					field.setAccessible(true);
+					LuaValue keyValue = table.get(k);
+
+					if (keyValue.istable()) {
+				    	field.set(object, serialize(field.getType(), keyValue.checktable()));
+				    } else if (field.getType().equals(float.class)) {
+				    	field.setFloat(object, keyValue.tofloat());
+				    } else if (field.getType().equals(int.class)) {
+				    	field.setInt(object, keyValue.toint());
+				    } else if (field.getType().equals(String.class)) {
+				    	field.set(object, keyValue.tojstring());
+				    } else {
+				    	field.set(object, keyValue);
+				    }
+				} catch (Exception ex) {
+					//ex.printStackTrace();
+					continue;
+				}
+			}
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		
+		return object;
+	}
+}

src/main/java/emu/grasscutter/scripts/serializer/Serializer.java

+package emu.grasscutter.scripts.serializer;
+
+import java.util.List;
+
+import org.luaj.vm2.LuaTable;
+
+public interface Serializer {
+	
+	public <T> List<T> toList(Class<T> type, Object obj);
+	
+	public <T> T toObject(Class<T> type, Object obj);
+}

src/main/java/emu/grasscutter/server/packet/recv/HandlerDungeonEntryInfoReq.java

@@ -2,6 +2,7 @@ package emu.grasscutter.server.packet.recv;
 
 import emu.grasscutter.net.packet.Opcodes;
 import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.DungeonEntryInfoReqOuterClass.DungeonEntryInfoReq;
 import emu.grasscutter.net.packet.PacketHandler;
 import emu.grasscutter.server.game.GameSession;
 
@@ -10,7 +11,9 @@ public class HandlerDungeonEntryInfoReq extends PacketHandler {
 	
 	@Override
 	public void handle(GameSession session, byte[] header, byte[] payload) throws Exception {
+		DungeonEntryInfoReq req = DungeonEntryInfoReq.parseFrom(payload);
 		
+		session.getServer().getDungeonManager().getEntryInfo(session.getPlayer(), req.getPointId());
 	}
 
 }

src/main/java/emu/grasscutter/server/packet/recv/HandlerEvtAvatarLockChairReq.java

+package emu.grasscutter.server.packet.recv;
+
+import emu.grasscutter.game.entity.EntityAvatar;
+import emu.grasscutter.net.packet.Opcodes;
+import emu.grasscutter.net.packet.PacketHandler;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.EvtAvatarLockChairReqOuterClass.EvtAvatarLockChairReq;
+import emu.grasscutter.net.proto.PacketHeadOuterClass.PacketHead;
+import emu.grasscutter.server.game.GameSession;
+import emu.grasscutter.server.packet.send.PacketEvtAvatarLockChairRsp;
+
+@Opcodes(PacketOpcodes.EvtAvatarLockChairReq)
+public class HandlerEvtAvatarLockChairReq extends PacketHandler {
+
+    @Override
+    public void handle(GameSession session, byte[] header, byte[] payload) throws Exception {
+        PacketHead head = PacketHead.parseFrom(header);
+        EvtAvatarLockChairReq lockChairReq = EvtAvatarLockChairReq.parseFrom(payload);
+
+        EntityAvatar entityAvatar = session.getPlayer().getTeamManager().getCurrentAvatarEntity();
+
+        session.send(new PacketEvtAvatarLockChairRsp(head.getClientSequenceId(), entityAvatar, lockChairReq));
+    }
+
+}

src/main/java/emu/grasscutter/server/packet/recv/HandlerEvtAvatarSitDownNotify.java

 package emu.grasscutter.server.packet.recv;
 
 import emu.grasscutter.net.packet.Opcodes;
+import emu.grasscutter.net.packet.PacketHandler;
 import emu.grasscutter.net.packet.PacketOpcodes;
 import emu.grasscutter.net.proto.EvtAvatarSitDownNotifyOuterClass.EvtAvatarSitDownNotify;
-import emu.grasscutter.net.packet.PacketHandler;
 import emu.grasscutter.server.game.GameSession;
 import emu.grasscutter.server.packet.send.PacketEvtAvatarSitDownNotify;
 
@@ -14,7 +14,7 @@ public class HandlerEvtAvatarSitDownNotify extends PacketHandler {
     public void handle(GameSession session, byte[] header, byte[] payload) throws Exception {
         EvtAvatarSitDownNotify notify = EvtAvatarSitDownNotify.parseFrom(payload);
 
-        session.send(new PacketEvtAvatarSitDownNotify(notify));
+        session.getPlayer().getScene().broadcastPacket(new PacketEvtAvatarSitDownNotify(notify));
     }
 
 }

src/main/java/emu/grasscutter/server/packet/recv/HandlerEvtAvatarStandUpNotify.java

+package emu.grasscutter.server.packet.recv;
+
+import emu.grasscutter.net.packet.Opcodes;
+import emu.grasscutter.net.packet.PacketHandler;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.EvtAvatarStandUpNotifyOuterClass.EvtAvatarStandUpNotify;
+import emu.grasscutter.server.game.GameSession;
+import emu.grasscutter.server.packet.send.PacketEvtAvatarStandUpNotify;
+
+@Opcodes(PacketOpcodes.EvtAvatarStandUpNotify)
+public class HandlerEvtAvatarStandUpNotify extends PacketHandler {
+
+    @Override
+    public void handle(GameSession session, byte[] header, byte[] payload) throws Exception {
+        EvtAvatarStandUpNotify notify = EvtAvatarStandUpNotify.parseFrom(payload);
+
+        session.getPlayer().getScene().broadcastPacket(new PacketEvtAvatarStandUpNotify(notify));
+    }
+
+}

src/main/java/emu/grasscutter/server/packet/recv/HandlerGetOnlinePlayerListReq.java

+package emu.grasscutter.server.packet.recv;
+
+import emu.grasscutter.net.packet.Opcodes;
+import emu.grasscutter.net.packet.PacketHandler;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.server.game.GameSession;
+import emu.grasscutter.server.packet.send.PacketGetOnlinePlayerListRsp;
+
+@Opcodes(PacketOpcodes.GetOnlinePlayerListReq)
+public class HandlerGetOnlinePlayerListReq extends PacketHandler {
+    @Override
+    public void handle(GameSession session, byte[] header, byte[] payload) throws Exception {
+        session.send(new PacketGetOnlinePlayerListRsp(session.getPlayer()));
+    }
+}

src/main/java/emu/grasscutter/server/packet/recv/HandlerPlayerEnterDungeonReq.java

+package emu.grasscutter.server.packet.recv;
+
+import emu.grasscutter.net.packet.Opcodes;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.PlayerEnterDungeonReqOuterClass.PlayerEnterDungeonReq;
+import emu.grasscutter.net.packet.PacketHandler;
+import emu.grasscutter.server.game.GameSession;
+
+@Opcodes(PacketOpcodes.PlayerEnterDungeonReq)
+public class HandlerPlayerEnterDungeonReq extends PacketHandler {
+	
+	@Override
+	public void handle(GameSession session, byte[] header, byte[] payload) throws Exception {
+		// Auto template
+		PlayerEnterDungeonReq req = PlayerEnterDungeonReq.parseFrom(payload);
+		
+		session.getServer().getDungeonManager().enterDungeon(session.getPlayer(), req.getPointId(), req.getDungeonId());
+	}
+
+}

src/main/java/emu/grasscutter/server/packet/recv/HandlerPlayerQuitDungeonReq.java

+package emu.grasscutter.server.packet.recv;
+
+import emu.grasscutter.net.packet.Opcodes;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.packet.PacketHandler;
+import emu.grasscutter.server.game.GameSession;
+
+@Opcodes(PacketOpcodes.PlayerQuitDungeonReq)
+public class HandlerPlayerQuitDungeonReq extends PacketHandler {
+	
+	@Override
+	public void handle(GameSession session, byte[] header, byte[] payload) throws Exception {
+		session.getPlayer().getServer().getDungeonManager().exitDungeon(session.getPlayer());
+	}
+
+}

src/main/java/emu/grasscutter/server/packet/recv/HandlerSelectWorktopOptionReq.java

+package emu.grasscutter.server.packet.recv;
+
+import emu.grasscutter.game.entity.EntityGadget;
+import emu.grasscutter.game.entity.GameEntity;
+import emu.grasscutter.net.packet.Opcodes;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.SelectWorktopOptionReqOuterClass.SelectWorktopOptionReq;
+import emu.grasscutter.scripts.constants.EventType;
+import emu.grasscutter.scripts.data.ScriptArgs;
+import emu.grasscutter.net.packet.PacketHandler;
+import emu.grasscutter.server.game.GameSession;
+import emu.grasscutter.server.packet.send.PacketSelectWorktopOptionRsp;
+
+@Opcodes(PacketOpcodes.SelectWorktopOptionReq)
+public class HandlerSelectWorktopOptionReq extends PacketHandler {
+	
+	@Override
+	public void handle(GameSession session, byte[] header, byte[] payload) throws Exception {
+		SelectWorktopOptionReq req = SelectWorktopOptionReq.parseFrom(payload);
+		
+		try {
+			GameEntity entity = session.getPlayer().getScene().getEntityById(req.getGadgetEntityId());
+			
+			if (entity == null || !(entity instanceof EntityGadget)) {
+				return;
+			}
+
+			session.getPlayer().getScene().getScriptManager().callEvent(
+					EventType.EVENT_SELECT_OPTION, 
+					new ScriptArgs(entity.getConfigId(), req.getOptionId())
+			);
+		} finally {
+			// Always send packet
+			session.send(new PacketSelectWorktopOptionRsp(req.getGadgetEntityId(), req.getOptionId()));
+		}
+	}
+
+}

src/main/java/emu/grasscutter/server/packet/send/PacketChallengeDataNotify.java

+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.dungeons.DungeonChallenge;
+import emu.grasscutter.net.packet.BasePacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.ChallengeDataNotifyOuterClass.ChallengeDataNotify;
+
+public class PacketChallengeDataNotify extends BasePacket {
+	
+	public PacketChallengeDataNotify(DungeonChallenge challenge, int index, int value) {
+		super(PacketOpcodes.ChallengeDataNotify);
+
+		ChallengeDataNotify proto = ChallengeDataNotify.newBuilder()
+				.setChallengeIndex(challenge.getChallengeIndex())
+				.setParamIndex(index)
+				.setValue(value)
+				.build();
+		
+		this.setData(proto);
+	}
+}

src/main/java/emu/grasscutter/server/packet/send/PacketDungeonChallengeBeginNotify.java

+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.dungeons.DungeonChallenge;
+import emu.grasscutter.net.packet.BasePacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.DungeonChallengeBeginNotifyOuterClass.DungeonChallengeBeginNotify;
+
+public class PacketDungeonChallengeBeginNotify extends BasePacket {
+	
+	public PacketDungeonChallengeBeginNotify(DungeonChallenge challenge) {
+		super(PacketOpcodes.DungeonChallengeBeginNotify);
+
+		DungeonChallengeBeginNotify proto = DungeonChallengeBeginNotify.newBuilder()
+				.setChallengeId(challenge.getChallengeId())
+				.setChallengeIndex(challenge.getChallengeIndex())
+				.setGroupId(challenge.getGroup().id)
+				.build();
+		
+		this.setData(proto);
+	}
+}