Initial commit

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

@@ -0,0 +1,12 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+
+public class Packet extends GenshinPacket {
+	
+	public Packet() {
+		super(PacketOpcodes.NONE);
+
+	}
+}

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

@@ -0,0 +1,20 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.entity.EntityAvatar;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.AbilityChangeNotifyOuterClass.AbilityChangeNotify;
+
+public class PacketAbilityChangeNotify extends GenshinPacket {
+	
+	public PacketAbilityChangeNotify(EntityAvatar entity) {
+		super(PacketOpcodes.AbilityChangeNotify);
+		
+		AbilityChangeNotify proto = AbilityChangeNotify.newBuilder()
+				.setEntityId(entity.getId())
+				.setAbilityControlBlock(entity.getAbilityControlBlock())
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,32 @@
+package emu.grasscutter.server.packet.send;
+
+import java.util.List;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.AbilityInvocationsNotifyOuterClass.AbilityInvocationsNotify;
+import emu.grasscutter.net.proto.AbilityInvokeEntryOuterClass.AbilityInvokeEntry;
+
+public class PacketAbilityInvocationsNotify extends GenshinPacket {
+	
+	public PacketAbilityInvocationsNotify(AbilityInvokeEntry entry) {
+		super(PacketOpcodes.AbilityInvocationsNotify, true);
+		
+		AbilityInvocationsNotify proto = AbilityInvocationsNotify.newBuilder()
+				.addInvokes(entry)
+				.build();
+
+		this.setData(proto);
+	}
+	
+	public PacketAbilityInvocationsNotify(List<AbilityInvokeEntry> entries) {
+		super(PacketOpcodes.AbilityInvocationsNotify, true);
+		
+		AbilityInvocationsNotify proto = AbilityInvocationsNotify.newBuilder()
+				.addAllInvokes(entries)
+				.build();
+		
+		this.setData(proto);
+	}
+	
+}

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

@@ -0,0 +1,20 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.friends.Friendship;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.AskAddFriendNotifyOuterClass.AskAddFriendNotify;
+
+public class PacketAskAddFriendNotify extends GenshinPacket {
+	
+	public PacketAskAddFriendNotify(Friendship friendship) {
+		super(PacketOpcodes.AskAddFriendNotify);
+
+		AskAddFriendNotify proto = AskAddFriendNotify.newBuilder()
+				.setTargetUid(friendship.getFriendId())
+				.setTargetFriendBrief(friendship.toProto())
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,18 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.AskAddFriendRspOuterClass.AskAddFriendRsp;
+
+public class PacketAskAddFriendRsp extends GenshinPacket {
+	
+	public PacketAskAddFriendRsp(int targetUid) {
+		super(PacketOpcodes.AskAddFriendRsp);
+		
+		AskAddFriendRsp proto = AskAddFriendRsp.newBuilder()
+				.setTargetUid(targetUid)
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,20 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.avatar.GenshinAvatar;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.AvatarAddNotifyOuterClass.AvatarAddNotify;
+
+public class PacketAvatarAddNotify extends GenshinPacket {
+	
+	public PacketAvatarAddNotify(GenshinAvatar avatar, boolean addedToTeam) {
+		super(PacketOpcodes.AvatarAddNotify);
+		
+		AvatarAddNotify proto = AvatarAddNotify.newBuilder()
+				.setAvatar(avatar.toProto())
+				.setIsInTeam(addedToTeam)
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,19 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.entity.EntityAvatar;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.AvatarChangeCostumeNotifyOuterClass.AvatarChangeCostumeNotify;
+
+public class PacketAvatarChangeCostumeNotify extends GenshinPacket {
+	
+	public PacketAvatarChangeCostumeNotify(EntityAvatar entity) {
+		super(PacketOpcodes.AvatarChangeCostumeNotify);
+
+		AvatarChangeCostumeNotify proto = AvatarChangeCostumeNotify.newBuilder()
+				.setEntity(entity.toProto())
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,29 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.AvatarChangeCostumeRspOuterClass.AvatarChangeCostumeRsp;
+
+public class PacketAvatarChangeCostumeRsp extends GenshinPacket {
+	
+	public PacketAvatarChangeCostumeRsp(long avatarGuid, int costumeId) {
+		super(PacketOpcodes.AvatarChangeCostumeRsp);
+
+		AvatarChangeCostumeRsp proto = AvatarChangeCostumeRsp.newBuilder()
+				.setAvatarGuid(avatarGuid)
+				.setCostumeId(costumeId)
+				.build();
+		
+		this.setData(proto);
+	}
+	
+	public PacketAvatarChangeCostumeRsp() {
+		super(PacketOpcodes.AvatarChangeCostumeRsp);
+
+		AvatarChangeCostumeRsp proto = AvatarChangeCostumeRsp.newBuilder()
+				.setRetcode(1)
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,44 @@
+package emu.grasscutter.server.packet.send;
+
+import java.util.Map.Entry;
+
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.game.TeamInfo;
+import emu.grasscutter.game.avatar.GenshinAvatar;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.AvatarDataNotifyOuterClass.AvatarDataNotify;
+import emu.grasscutter.net.proto.AvatarTeamOuterClass.AvatarTeam;
+
+public class PacketAvatarDataNotify extends GenshinPacket {
+	
+	public PacketAvatarDataNotify(GenshinPlayer player) {
+		super(PacketOpcodes.AvatarDataNotify, 2);
+
+		AvatarDataNotify.Builder proto = AvatarDataNotify.newBuilder()
+				.setCurAvatarTeamId(player.getTeamManager().getCurrentTeamId())
+				.setChooseAvatarGuid(player.getTeamManager().getCurrentCharacterGuid())
+				.addAllOwnedFlycloakList(player.getFlyCloakList())
+				.addAllOwnedCostumeList(player.getCostumeList());
+				
+		for (GenshinAvatar avatar : player.getAvatars()) {
+			proto.addAvatarList(avatar.toProto());
+		}
+		
+		for (Entry<Integer, TeamInfo> entry : player.getTeamManager().getTeams().entrySet()) {
+			TeamInfo teamInfo = entry.getValue();
+			AvatarTeam.Builder avatarTeam = AvatarTeam.newBuilder()
+					.setTeamName(teamInfo.getName());
+			
+			for (int i = 0; i < teamInfo.getAvatars().size(); i++) {
+				GenshinAvatar avatar = player.getAvatars().getAvatarById(teamInfo.getAvatars().get(i));
+				avatarTeam.addAvatarGuidList(avatar.getGuid());
+			}
+			
+			proto.putAvatarTeamMap(entry.getKey(), avatarTeam.build());
+		}
+		
+		this.setData(proto.build());
+	}
+
+}

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

@@ -0,0 +1,19 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.AvatarDieAnimationEndRspOuterClass.AvatarDieAnimationEndRsp;
+
+public class PacketAvatarDieAnimationEndRsp extends GenshinPacket {
+	
+	public PacketAvatarDieAnimationEndRsp(long dieGuid, int skillId) {
+		super(PacketOpcodes.AvatarDieAnimationEndRsp);
+
+		AvatarDieAnimationEndRsp proto = AvatarDieAnimationEndRsp.newBuilder()
+				.setDieGuid(dieGuid)
+				.setSkillId(skillId)
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,39 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.avatar.GenshinAvatar;
+import emu.grasscutter.game.inventory.EquipType;
+import emu.grasscutter.game.inventory.GenshinItem;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.AvatarEquipChangeNotifyOuterClass.AvatarEquipChangeNotify;
+
+public class PacketAvatarEquipChangeNotify extends GenshinPacket {
+	
+	public PacketAvatarEquipChangeNotify(GenshinAvatar avatar, GenshinItem item) {
+		super(PacketOpcodes.AvatarEquipChangeNotify);
+
+		AvatarEquipChangeNotify.Builder proto = AvatarEquipChangeNotify.newBuilder()
+				.setAvatarGuid(avatar.getGuid())
+				.setEquipType(item.getEquipSlot())
+				.setItemId(item.getItemId())
+				.setEquipGuid(item.getGuid());
+		
+		if (item.getItemData().getEquipType() == EquipType.EQUIP_WEAPON) {
+			proto.setWeapon(item.createSceneWeaponInfo());
+		} else {
+			proto.setReliquary(item.createSceneReliquaryInfo());
+		}
+
+		this.setData(proto);
+	}
+	
+	public PacketAvatarEquipChangeNotify(GenshinAvatar avatar, EquipType slot) {
+		super(PacketOpcodes.AvatarEquipChangeNotify);
+
+		AvatarEquipChangeNotify.Builder proto = AvatarEquipChangeNotify.newBuilder()
+				.setAvatarGuid(avatar.getGuid())
+				.setEquipType(slot.getValue());
+
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,20 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.avatar.GenshinAvatar;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.AvatarFightPropNotifyOuterClass.AvatarFightPropNotify;
+
+public class PacketAvatarFightPropNotify extends GenshinPacket {
+	
+	public PacketAvatarFightPropNotify(GenshinAvatar avatar) {
+		super(PacketOpcodes.AvatarFightPropNotify);
+		
+		AvatarFightPropNotify proto = AvatarFightPropNotify.newBuilder()
+				.setAvatarGuid(avatar.getGuid())
+				.putAllFightPropMap(avatar.getFightProperties())
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,21 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.avatar.GenshinAvatar;
+import emu.grasscutter.game.props.FightProperty;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.AvatarFightPropUpdateNotifyOuterClass.AvatarFightPropUpdateNotify;
+
+public class PacketAvatarFightPropUpdateNotify extends GenshinPacket {
+	
+	public PacketAvatarFightPropUpdateNotify(GenshinAvatar avatar, FightProperty prop) {
+		super(PacketOpcodes.AvatarFightPropUpdateNotify);
+		
+		AvatarFightPropUpdateNotify proto = AvatarFightPropUpdateNotify.newBuilder()
+				.setAvatarGuid(avatar.getGuid())
+				.putFightPropMap(prop.getId(), avatar.getFightProperty(prop))
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,20 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.avatar.GenshinAvatar;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.AvatarFlycloakChangeNotifyOuterClass.AvatarFlycloakChangeNotify;
+
+public class PacketAvatarFlycloakChangeNotify extends GenshinPacket {
+	
+	public PacketAvatarFlycloakChangeNotify(GenshinAvatar avatar) {
+		super(PacketOpcodes.AvatarFlycloakChangeNotify);
+
+		 AvatarFlycloakChangeNotify proto = AvatarFlycloakChangeNotify.newBuilder()
+				 .setAvatarGuid(avatar.getGuid())
+				 .setFlycloakId(avatar.getFlyCloak())
+				 .build();
+
+		 this.setData(proto);
+	}
+}

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

@@ -0,0 +1,18 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.AvatarGainCostumeNotifyOuterClass.AvatarGainCostumeNotify;
+
+public class PacketAvatarGainCostumeNotify extends GenshinPacket {
+	
+	public PacketAvatarGainCostumeNotify(int costumeId) {
+		super(PacketOpcodes.AvatarGainCostumeNotify);
+
+		AvatarGainCostumeNotify proto = AvatarGainCostumeNotify.newBuilder()
+				.setCostumeId(costumeId)
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,18 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.AvatarGainFlycloakNotifyOuterClass.AvatarGainFlycloakNotify;
+
+public class PacketAvatarGainFlycloakNotify extends GenshinPacket {
+	
+	public PacketAvatarGainFlycloakNotify(int flycloak) {
+		super(PacketOpcodes.AvatarGainFlycloakNotify);
+
+		AvatarGainFlycloakNotify proto = AvatarGainFlycloakNotify.newBuilder()
+				.setFlycloakId(flycloak)
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,22 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.avatar.GenshinAvatar;
+import emu.grasscutter.game.props.FightProperty;
+import emu.grasscutter.game.props.LifeState;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.AvatarLifeStateChangeNotifyOuterClass.AvatarLifeStateChangeNotify;
+
+public class PacketAvatarLifeStateChangeNotify extends GenshinPacket {
+	
+	public PacketAvatarLifeStateChangeNotify(GenshinAvatar avatar) {
+		super(PacketOpcodes.AvatarLifeStateChangeNotify);
+
+		AvatarLifeStateChangeNotify proto = AvatarLifeStateChangeNotify.newBuilder()
+				.setAvatarGuid(avatar.getGuid())
+				.setLifeState(avatar.getFightProperty(FightProperty.FIGHT_PROP_CUR_HP) > 0 ? LifeState.LIFE_ALIVE.getValue() : LifeState.LIFE_DEAD.getValue())
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,19 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.avatar.GenshinAvatar;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.AvatarPromoteRspOuterClass.AvatarPromoteRsp;
+
+public class PacketAvatarPromoteRsp extends GenshinPacket {
+	
+	public PacketAvatarPromoteRsp(GenshinAvatar avatar) {
+		super(PacketOpcodes.AvatarPromoteRsp);
+
+		AvatarPromoteRsp proto = AvatarPromoteRsp.newBuilder()
+				.setGuid(avatar.getGuid())
+				.build();
+
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,35 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.avatar.GenshinAvatar;
+import emu.grasscutter.game.props.PlayerProperty;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.AvatarPropNotifyOuterClass.AvatarPropNotify;
+
+public class PacketAvatarPropNotify extends GenshinPacket {
+	public PacketAvatarPropNotify(GenshinAvatar avatar) {
+		super(PacketOpcodes.AvatarPropNotify);
+		
+		AvatarPropNotify proto = AvatarPropNotify.newBuilder()
+				.setAvatarGuid(avatar.getGuid())
+				.putPropMap(PlayerProperty.PROP_LEVEL.getId(), avatar.getLevel())
+				.putPropMap(PlayerProperty.PROP_EXP.getId(), avatar.getExp())
+				.putPropMap(PlayerProperty.PROP_BREAK_LEVEL.getId(), avatar.getPromoteLevel())
+				.putPropMap(PlayerProperty.PROP_SATIATION_VAL.getId(), 0)
+				.putPropMap(PlayerProperty.PROP_SATIATION_PENALTY_TIME.getId(), 0)
+				.build();
+		
+		this.setData(proto);
+	}
+	
+	public PacketAvatarPropNotify(GenshinAvatar avatar, PlayerProperty prop, int value) {
+		super(PacketOpcodes.AvatarPropNotify);
+
+		AvatarPropNotify proto = AvatarPropNotify.newBuilder()
+				.setAvatarGuid(avatar.getGuid())
+				.putPropMap(prop.getId(), value)
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,24 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.avatar.GenshinAvatar;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.AvatarSkillChangeNotifyOuterClass.AvatarSkillChangeNotify;
+
+public class PacketAvatarSkillChangeNotify extends GenshinPacket {
+	
+	public PacketAvatarSkillChangeNotify(GenshinAvatar avatar, int skillId, int oldLevel, int curLevel) {
+		super(PacketOpcodes.AvatarSkillChangeNotify);
+		
+		AvatarSkillChangeNotify proto = AvatarSkillChangeNotify.newBuilder()
+				.setAvatarGuid(avatar.getGuid())
+				.setEntityId(avatar.getEntityId())
+				.setSkillDepotId(avatar.getSkillDepotId())
+				.setAvatarSkillId(skillId)
+				.setOldLevel(oldLevel)
+				.setCurLevel(curLevel)
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,22 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.avatar.GenshinAvatar;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.AvatarSkillUpgradeRspOuterClass.AvatarSkillUpgradeRsp;
+
+public class PacketAvatarSkillUpgradeRsp extends GenshinPacket {
+	
+	public PacketAvatarSkillUpgradeRsp(GenshinAvatar avatar, int skillId, int oldLevel, int newLevel) {
+		super(PacketOpcodes.AvatarSkillUpgradeRsp);
+
+		AvatarSkillUpgradeRsp proto = AvatarSkillUpgradeRsp.newBuilder()
+				.setAvatarGuid(avatar.getGuid())
+				.setAvatarSkillId(skillId)
+				.setOldLevel(oldLevel)
+				.setCurLevel(newLevel)
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,35 @@
+package emu.grasscutter.server.packet.send;
+
+import java.util.Map.Entry;
+
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.game.TeamInfo;
+import emu.grasscutter.game.avatar.GenshinAvatar;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.AvatarTeamOuterClass.AvatarTeam;
+import emu.grasscutter.net.proto.AvatarTeamUpdateNotifyOuterClass.AvatarTeamUpdateNotify;
+
+public class PacketAvatarTeamUpdateNotify extends GenshinPacket {
+	
+	public PacketAvatarTeamUpdateNotify(GenshinPlayer player) {
+		super(PacketOpcodes.AvatarTeamUpdateNotify);
+
+		AvatarTeamUpdateNotify.Builder proto = AvatarTeamUpdateNotify.newBuilder();
+		
+		for (Entry<Integer, TeamInfo> entry : player.getTeamManager().getTeams().entrySet()) {
+			TeamInfo teamInfo = entry.getValue();
+			AvatarTeam.Builder avatarTeam = AvatarTeam.newBuilder()
+					.setTeamName(teamInfo.getName());
+			
+			for (int i = 0; i < teamInfo.getAvatars().size(); i++) {
+				GenshinAvatar avatar = player.getAvatars().getAvatarById(teamInfo.getAvatars().get(i));
+				avatarTeam.addAvatarGuidList(avatar.getGuid());
+			}
+			
+			proto.putAvatarTeamMap(entry.getKey(), avatarTeam.build());
+		}
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,22 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.avatar.GenshinAvatar;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.AvatarUnlockTalentNotifyOuterClass.AvatarUnlockTalentNotify;
+
+public class PacketAvatarUnlockTalentNotify extends GenshinPacket {
+	
+	public PacketAvatarUnlockTalentNotify(GenshinAvatar avatar, int talentId) {
+		super(PacketOpcodes.AvatarUnlockTalentNotify);
+
+		AvatarUnlockTalentNotify proto = AvatarUnlockTalentNotify.newBuilder()
+				.setAvatarGuid(avatar.getGuid())
+				.setEntityId(avatar.getEntityId())
+				.setTalentId(talentId)
+				.setSkillDepotId(avatar.getSkillDepotId())
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,27 @@
+package emu.grasscutter.server.packet.send;
+
+import java.util.Map;
+
+import emu.grasscutter.game.avatar.GenshinAvatar;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.AvatarUpgradeRspOuterClass.AvatarUpgradeRsp;
+
+public class PacketAvatarUpgradeRsp extends GenshinPacket {
+	
+	public PacketAvatarUpgradeRsp(GenshinAvatar avatar, int oldLevel, Map<Integer, Float> oldFightPropMap) {
+		super(PacketOpcodes.AvatarUpgradeRsp);
+		
+		this.buildHeader(0);
+
+		AvatarUpgradeRsp proto = AvatarUpgradeRsp.newBuilder()
+				.setAvatarGuid(avatar.getGuid())
+				.setOldLevel(oldLevel)
+				.setCurLevel(avatar.getLevel())
+				.putAllOldFightPropMap(oldFightPropMap)
+				.putAllCurFightPropMap(avatar.getFightProperties())
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,28 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.AvatarWearFlycloakRspOuterClass.AvatarWearFlycloakRsp;
+
+public class PacketAvatarWearFlycloakRsp extends GenshinPacket {
+	public PacketAvatarWearFlycloakRsp(long avatarGuid, int costumeId) {
+		super(PacketOpcodes.AvatarWearFlycloakRsp);
+
+		AvatarWearFlycloakRsp proto = AvatarWearFlycloakRsp.newBuilder()
+				.setAvatarGuid(avatarGuid)
+				.setFlycloakId(costumeId)
+				.build();
+		
+		this.setData(proto);
+	}
+	
+	public PacketAvatarWearFlycloakRsp() {
+		super(PacketOpcodes.AvatarWearFlycloakRsp);
+
+		AvatarWearFlycloakRsp proto = AvatarWearFlycloakRsp.newBuilder()
+				.setRetcode(1)
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,33 @@
+package emu.grasscutter.server.packet.send;
+
+import java.util.List;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.packet.Retcode;
+import emu.grasscutter.net.proto.CalcWeaponUpgradeReturnItemsRspOuterClass.CalcWeaponUpgradeReturnItemsRsp;
+import emu.grasscutter.net.proto.ItemParamOuterClass.ItemParam;
+
+public class PacketCalcWeaponUpgradeReturnItemsRsp extends GenshinPacket {
+	
+	public PacketCalcWeaponUpgradeReturnItemsRsp(long itemGuid, List<ItemParam> returnItems) {
+		super(PacketOpcodes.CalcWeaponUpgradeReturnItemsRsp);
+		
+		CalcWeaponUpgradeReturnItemsRsp proto = CalcWeaponUpgradeReturnItemsRsp.newBuilder()
+				.setTargetWeaponGuid(itemGuid)
+				.addAllItemParamList(returnItems)
+				.build();
+		
+		this.setData(proto);
+	}
+	
+	public PacketCalcWeaponUpgradeReturnItemsRsp() {
+		super(PacketOpcodes.CalcWeaponUpgradeReturnItemsRsp);
+		
+		CalcWeaponUpgradeReturnItemsRsp proto = CalcWeaponUpgradeReturnItemsRsp.newBuilder()
+				.setRetcode(Retcode.FAIL)
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,19 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.ChangeAvatarRspOuterClass.ChangeAvatarRsp;
+
+public class PacketChangeAvatarRsp extends GenshinPacket {
+	
+	public PacketChangeAvatarRsp(long guid) {
+		super(PacketOpcodes.ChangeAvatarRsp);
+
+		ChangeAvatarRsp p = ChangeAvatarRsp.newBuilder()
+				.setRetcode(0)
+				.setCurrGuid(guid)
+				.build();
+		
+		this.setData(p);
+	}
+}

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

@@ -0,0 +1,19 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.World;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.ChangeGameTimeRspOuterClass.ChangeGameTimeRsp;
+
+public class PacketChangeGameTimeRsp extends GenshinPacket {
+	
+	public PacketChangeGameTimeRsp(World world) {
+		super(PacketOpcodes.ChangeGameTimeRsp);
+		
+		ChangeGameTimeRsp proto = ChangeGameTimeRsp.newBuilder()
+				.setCurGameTime(world.getTime())
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,23 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.game.TeamInfo;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.ChangeMpTeamAvatarRspOuterClass.ChangeMpTeamAvatarRsp;
+
+public class PacketChangeMpTeamAvatarRsp extends GenshinPacket {
+	
+	public PacketChangeMpTeamAvatarRsp(GenshinPlayer player, TeamInfo teamInfo) {
+		super(PacketOpcodes.ChangeMpTeamAvatarRsp);
+		
+		ChangeMpTeamAvatarRsp.Builder proto = ChangeMpTeamAvatarRsp.newBuilder()
+				.setCurAvatarGuid(player.getTeamManager().getCurrentCharacterGuid());
+		
+		for (int avatarId : teamInfo.getAvatars()) {
+			proto.addAvatarGuidList(player.getAvatars().getAvatarById(avatarId).getGuid());
+		}
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,19 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.ChangeTeamNameRspOuterClass.ChangeTeamNameRsp;
+
+public class PacketChangeTeamNameRsp extends GenshinPacket {
+	
+	public PacketChangeTeamNameRsp(int teamId, String teamName) {
+		super(PacketOpcodes.ChangeTeamNameRsp);
+
+		ChangeTeamNameRsp proto = ChangeTeamNameRsp.newBuilder()
+				.setTeamId(teamId)
+				.setTeamName(teamName)
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,18 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.ChooseCurAvatarTeamRspOuterClass.ChooseCurAvatarTeamRsp;
+
+public class PacketChooseCurAvatarTeamRsp extends GenshinPacket {
+	
+	public PacketChooseCurAvatarTeamRsp(int teamId) {
+		super(PacketOpcodes.ChooseCurAvatarTeamRsp);
+
+		ChooseCurAvatarTeamRsp proto = ChooseCurAvatarTeamRsp.newBuilder()
+				.setCurTeamId(teamId)
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,32 @@
+package emu.grasscutter.server.packet.send;
+
+import java.util.List;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.CombatInvocationsNotifyOuterClass.CombatInvocationsNotify;
+import emu.grasscutter.net.proto.CombatInvokeEntryOuterClass.CombatInvokeEntry;
+
+public class PacketCombatInvocationsNotify extends GenshinPacket {
+	
+	public PacketCombatInvocationsNotify(CombatInvokeEntry entry) {
+		super(PacketOpcodes.CombatInvocationsNotify, true);
+		
+		CombatInvocationsNotify proto = CombatInvocationsNotify.newBuilder()
+				.addInvokeList(entry)
+				.build();
+		
+		this.setData(proto);
+	}
+	
+	public PacketCombatInvocationsNotify(List<CombatInvokeEntry> entries) {
+		super(PacketOpcodes.CombatInvocationsNotify, true);
+	
+		CombatInvocationsNotify proto = CombatInvocationsNotify.newBuilder()
+				.addAllInvokeList(entries)
+				.build();
+		
+		this.setData(proto);
+	}
+	
+}

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

@@ -0,0 +1,20 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.DealAddFriendResultTypeOuterClass.DealAddFriendResultType;
+import emu.grasscutter.net.proto.DealAddFriendRspOuterClass.DealAddFriendRsp;
+
+public class PacketDealAddFriendRsp extends GenshinPacket {
+	
+	public PacketDealAddFriendRsp(int targetUid, DealAddFriendResultType result) {
+		super(PacketOpcodes.DealAddFriendRsp);
+
+		DealAddFriendRsp proto = DealAddFriendRsp.newBuilder()
+				.setTargetUid(targetUid)
+				.setDealAddFriendResult(result)
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,32 @@
+package emu.grasscutter.server.packet.send;
+
+import java.util.List;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.DelTeamEntityNotifyOuterClass.DelTeamEntityNotify;
+
+public class PacketDelTeamEntityNotify extends GenshinPacket {
+	
+	public PacketDelTeamEntityNotify(int sceneId, int teamEntityId) {
+		super(PacketOpcodes.DelTeamEntityNotify);
+
+		DelTeamEntityNotify proto = DelTeamEntityNotify.newBuilder()
+				.setSceneId(sceneId)
+				.addDelEntityIdList(teamEntityId)
+				.build();
+		
+		this.setData(proto);
+	}
+	
+	public PacketDelTeamEntityNotify(int sceneId, List<Integer> list) {
+		super(PacketOpcodes.DelTeamEntityNotify);
+
+		DelTeamEntityNotify proto = DelTeamEntityNotify.newBuilder()
+				.setSceneId(sceneId)
+				.addAllDelEntityIdList(list)
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,18 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.DeleteFriendNotifyOuterClass.DeleteFriendNotify;
+
+public class PacketDeleteFriendNotify extends GenshinPacket {
+	
+	public PacketDeleteFriendNotify(int targetUid) {
+		super(PacketOpcodes.DeleteFriendNotify);
+
+		DeleteFriendNotify proto = DeleteFriendNotify.newBuilder()
+				.setTargetUid(targetUid)
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,18 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.DeleteFriendRspOuterClass.DeleteFriendRsp;
+
+public class PacketDeleteFriendRsp extends GenshinPacket {
+	
+	public PacketDeleteFriendRsp(int targetUid) {
+		super(PacketOpcodes.DeleteFriendRsp);
+
+		DeleteFriendRsp proto = DeleteFriendRsp.newBuilder()
+				.setTargetUid(targetUid)
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,23 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.DestroyMaterialRspOuterClass.DestroyMaterialRsp;
+import it.unimi.dsi.fastutil.ints.Int2IntMap;
+import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap;
+
+public class PacketDestroyMaterialRsp extends GenshinPacket {
+	
+	public PacketDestroyMaterialRsp(Int2IntOpenHashMap returnMaterialMap) {
+		super(PacketOpcodes.DestroyMaterialRsp);
+		
+		DestroyMaterialRsp.Builder proto = DestroyMaterialRsp.newBuilder();
+		
+		for (Int2IntMap.Entry e : returnMaterialMap.int2IntEntrySet()) {
+			proto.addItemIdList(e.getIntKey());
+			proto.addItemCountList(e.getIntValue());
+		}
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,41 @@
+package emu.grasscutter.server.packet.send;
+
+import java.util.List;
+
+import emu.grasscutter.game.gacha.GachaBanner;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.DoGachaRspOuterClass.DoGachaRsp;
+import emu.grasscutter.net.proto.GachaItemOuterClass.GachaItem;
+
+public class PacketDoGachaRsp extends GenshinPacket {
+	
+	public PacketDoGachaRsp(GachaBanner banner, List<GachaItem> list) {
+		super(PacketOpcodes.DoGachaRsp);
+
+		DoGachaRsp p = DoGachaRsp.newBuilder()
+				.setGachaType(banner.getGachaType())
+				.setGachaScheduleId(banner.getScheduleId())
+				.setGachaTimes(list.size())
+				.setNewGachaRandom(12345)
+				.setLeftGachaTimes(Integer.MAX_VALUE)
+				.setCostItemId(banner.getCostItem())
+	            .setCostItemNum(1)
+	            .setTenCostItemId(banner.getCostItem())
+	            .setTenCostItemNum(10)
+	            .addAllGachaItemList(list)
+				.build();
+		
+		this.setData(p);
+	}
+
+	public PacketDoGachaRsp() {
+		super(PacketOpcodes.DoGachaRsp);
+
+		DoGachaRsp p = DoGachaRsp.newBuilder()
+				.setRetcode(1)
+				.build();
+		
+		this.setData(p);
+	}
+}

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

@@ -0,0 +1,19 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.EnterSceneDoneRspOuterClass.EnterSceneDoneRsp;
+
+public class PacketEnterSceneDoneRsp extends GenshinPacket {
+
+	public PacketEnterSceneDoneRsp(GenshinPlayer player) {
+		super(PacketOpcodes.EnterSceneDoneRsp);
+
+		EnterSceneDoneRsp p = EnterSceneDoneRsp.newBuilder()
+				.setEnterSceneToken(player.getEnterSceneToken())
+				.build();
+		
+		this.setData(p);
+	}
+}

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

@@ -0,0 +1,22 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.EnterScenePeerNotifyOuterClass.EnterScenePeerNotify;
+
+public class PacketEnterScenePeerNotify extends GenshinPacket {
+
+	public PacketEnterScenePeerNotify(GenshinPlayer player) {
+		super(PacketOpcodes.EnterScenePeerNotify);
+		
+		EnterScenePeerNotify proto = EnterScenePeerNotify.newBuilder()
+				.setDestSceneId(player.getSceneId())
+				.setPeerId(player.getPeerId())
+				.setHostPeerId(player.getWorld().getHost().getPeerId())
+				.setEnterSceneToken(player.getEnterSceneToken()) 
+				.build();
+
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,19 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.EnterSceneReadyRspOuterClass.EnterSceneReadyRsp;
+
+public class PacketEnterSceneReadyRsp extends GenshinPacket {
+
+	public PacketEnterSceneReadyRsp(GenshinPlayer player) {
+		super(PacketOpcodes.EnterSceneReadyRsp, 11);
+		
+		EnterSceneReadyRsp p = EnterSceneReadyRsp.newBuilder()
+				.setEnterSceneToken(player.getEnterSceneToken())
+				.build();
+		
+		this.setData(p.toByteArray());
+	}
+}

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

@@ -0,0 +1,20 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.EnterWorldAreaReqOuterClass.EnterWorldAreaReq;
+import emu.grasscutter.net.proto.EnterWorldAreaRspOuterClass.EnterWorldAreaRsp;
+
+public class PacketEnterWorldAreaRsp extends GenshinPacket {
+
+	public PacketEnterWorldAreaRsp(int clientSequence, EnterWorldAreaReq enterWorld) {
+		super(PacketOpcodes.EnterWorldAreaRsp, clientSequence);
+		
+		EnterWorldAreaRsp p = EnterWorldAreaRsp.newBuilder()
+				.setAreaType(enterWorld.getAreaType())
+				.setAreaId(enterWorld.getAreaId())
+				.build();
+		
+		this.setData(p.toByteArray());
+	}
+}

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

@@ -0,0 +1,21 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.AiSyncInfoOuterClass.AiSyncInfo;
+import emu.grasscutter.net.proto.EntityAiSyncNotifyOuterClass.EntityAiSyncNotify;
+
+public class PacketEntityAiSyncNotify extends GenshinPacket {
+	
+	public PacketEntityAiSyncNotify(EntityAiSyncNotify notify) {
+		super(PacketOpcodes.EntityAiSyncNotify, true);
+		
+		EntityAiSyncNotify.Builder proto = EntityAiSyncNotify.newBuilder();
+		
+		for (int monsterId : notify.getLocalAvatarAlertedMonsterListList()) {
+			proto.addInfoList(AiSyncInfo.newBuilder().setEntityId(monsterId));
+		}
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,21 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.entity.GenshinEntity;
+import emu.grasscutter.game.props.FightProperty;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.EntityFightPropUpdateNotifyOuterClass.EntityFightPropUpdateNotify;
+
+public class PacketEntityFightPropUpdateNotify extends GenshinPacket {
+	
+	public PacketEntityFightPropUpdateNotify(GenshinEntity entity, FightProperty prop) {
+		super(PacketOpcodes.EntityFightPropUpdateNotify);
+		
+		EntityFightPropUpdateNotify proto = EntityFightPropUpdateNotify.newBuilder()
+				.setEntityId(entity.getId())
+				.putFightPropMap(prop.getId(), entity.getFightProperty(prop))
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,31 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.entity.EntityGadget;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.GadgetInteractRspOuterClass.GadgetInteractRsp;
+import emu.grasscutter.net.proto.InteractTypeOuterClass.InteractType;
+
+public class PacketGadgetInteractRsp extends GenshinPacket {
+	public PacketGadgetInteractRsp(EntityGadget gadget, InteractType interact) {
+		super(PacketOpcodes.GadgetInteractRsp);
+
+		GadgetInteractRsp proto = GadgetInteractRsp.newBuilder()
+				.setGadgetEntityId(gadget.getId())
+				.setInteractType(interact)
+				.setGadgetId(gadget.getGadgetId())
+				.build();
+		
+		this.setData(proto);
+	}
+	
+	public PacketGadgetInteractRsp() {
+		super(PacketOpcodes.GadgetInteractRsp);
+
+		GadgetInteractRsp proto = GadgetInteractRsp.newBuilder()
+				.setRetcode(1)
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,15 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.GetActivityInfoRspOuterClass.GetActivityInfoRsp;
+
+public class PacketGetActivityInfoRsp extends GenshinPacket {
+	public PacketGetActivityInfoRsp() {
+		super(PacketOpcodes.GetActivityInfoRsp);
+		
+		GetActivityInfoRsp proto = GetActivityInfoRsp.newBuilder().build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,19 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.GetAllUnlockNameCardRspOuterClass.GetAllUnlockNameCardRsp;
+
+public class PacketGetAllUnlockNameCardRsp extends GenshinPacket {
+	
+	public PacketGetAllUnlockNameCardRsp(GenshinPlayer player) {
+		super(PacketOpcodes.GetAllUnlockNameCardRsp);
+		
+		GetAllUnlockNameCardRsp proto = GetAllUnlockNameCardRsp.newBuilder()
+				.addAllNameCardList(player.getNameCardList())
+				.build();
+
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,16 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.GetAuthkeyRspOuterClass.GetAuthkeyRsp;
+
+public class PacketGetAuthkeyRsp extends GenshinPacket {
+	
+	public PacketGetAuthkeyRsp() {
+		super(PacketOpcodes.GetAuthkeyRsp);
+		
+		GetAuthkeyRsp proto = GetAuthkeyRsp.newBuilder().setRetcode(1).build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,14 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.gacha.GachaManager;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+
+public class PacketGetGachaInfoRsp extends GenshinPacket {
+	
+	public PacketGetGachaInfoRsp(GachaManager manager) {
+		super(PacketOpcodes.GetGachaInfoRsp);
+		
+		this.setData(manager.toProto());
+	}
+}

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

@@ -0,0 +1,25 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.game.friends.Friendship;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.GetPlayerAskFriendListRspOuterClass.GetPlayerAskFriendListRsp;
+
+public class PacketGetPlayerAskFriendListRsp extends GenshinPacket {
+	
+	public PacketGetPlayerAskFriendListRsp(GenshinPlayer player) {
+		super(PacketOpcodes.GetPlayerAskFriendListRsp);
+		
+		GetPlayerAskFriendListRsp.Builder proto = GetPlayerAskFriendListRsp.newBuilder();
+
+		for (Friendship friendship : player.getFriendsList().getPendingFriends().values()) {
+			if (friendship.getAskerId() == player.getId()) {
+				continue;
+			}
+			proto.addAskFriendList(friendship.toProto());
+		}
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,48 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.GenshinConstants;
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.game.friends.Friendship;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.FriendBriefOuterClass.FriendBrief;
+import emu.grasscutter.net.proto.FriendOnlineStateOuterClass.FriendOnlineState;
+import emu.grasscutter.net.proto.GetPlayerFriendListRspOuterClass.GetPlayerFriendListRsp;
+import emu.grasscutter.net.proto.HeadImageOuterClass.HeadImage;
+
+public class PacketGetPlayerFriendListRsp extends GenshinPacket {
+	
+	public PacketGetPlayerFriendListRsp(GenshinPlayer player) {
+		super(PacketOpcodes.GetPlayerFriendListRsp);
+		
+		FriendBrief serverFriend = FriendBrief.newBuilder()
+				.setUid(GenshinConstants.SERVER_CONSOLE_UID)
+				.setNickname("Server")
+				.setLevel(1)
+				.setAvatar(HeadImage.newBuilder().setAvatarId(GenshinConstants.MAIN_CHARACTER_FEMALE))
+				.setWorldLevel(0)
+				.setSignature("")
+				.setLastActiveTime((int) (System.currentTimeMillis() / 1000f))
+				.setIsMpModeAvailable(true)
+				.setNameCardId(210001)
+				.setOnlineState(FriendOnlineState.FRIEND_ONLINE)
+				.setParam(1)
+				.setUnk1(1)
+				.setUnk2(3)
+				.build();
+		
+		GetPlayerFriendListRsp.Builder proto = GetPlayerFriendListRsp.newBuilder().addFriendList(serverFriend);
+		
+		for (Friendship friendship : player.getFriendsList().getFriends().values()) {
+			proto.addFriendList(friendship.toProto());
+		}
+		for (Friendship friendship : player.getFriendsList().getPendingFriends().values()) {
+			if (friendship.getAskerId() == player.getId()) {
+				continue;
+			}
+			proto.addAskFriendList(friendship.toProto());
+		}
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,23 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.GetPlayerSocialDetailRspOuterClass.GetPlayerSocialDetailRsp;
+import emu.grasscutter.net.proto.SocialDetailOuterClass.SocialDetail;
+
+public class PacketGetPlayerSocialDetailRsp extends GenshinPacket {
+	
+	public PacketGetPlayerSocialDetailRsp(SocialDetail.Builder detail) {
+		super(PacketOpcodes.GetPlayerSocialDetailRsp);
+
+		GetPlayerSocialDetailRsp.Builder proto = GetPlayerSocialDetailRsp.newBuilder();
+		
+		if (detail != null) {
+			proto.setDetailData(detail);
+		} else {
+			proto.setRetcode(1);
+		}
+
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,35 @@
+package emu.grasscutter.server.packet.send;
+
+import com.google.protobuf.ByteString;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.GetPlayerTokenRspOuterClass.GetPlayerTokenRsp;
+import emu.grasscutter.server.game.GameSession;
+import emu.grasscutter.utils.Crypto;
+
+public class PacketGetPlayerTokenRsp extends GenshinPacket {
+
+	public PacketGetPlayerTokenRsp(GameSession session, boolean doesPlayerExist) {
+		super(PacketOpcodes.GetPlayerTokenRsp, true);
+		
+		this.setUseDispatchKey(true);
+		
+		GetPlayerTokenRsp p = GetPlayerTokenRsp.newBuilder()
+				.setPlayerUid(session.getAccount().getPlayerId())
+				.setAccountToken(session.getAccount().getToken())
+				.setAccountType(1)
+				.setIsProficientPlayer(doesPlayerExist) // Not sure where this goes
+				.setSecretKey(Crypto.ENCRYPT_SEED)
+				.setSecretKeyBuffer(ByteString.copyFrom(Crypto.ENCRYPT_SEED_BUFFER))
+				.setPlatformType(3)
+				.setChannelId(1)
+				.setCountryCode("US")
+				.setUnk1("c25-314dd05b0b5f")
+				.setUnk3(3)
+				.setClientIp(session.getAddress().getAddress().getHostAddress())
+				.build();
+	
+		this.setData(p.toByteArray());
+	}
+}

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

@@ -0,0 +1,28 @@
+package emu.grasscutter.server.packet.send;
+
+import java.util.Arrays;
+import java.util.stream.Collectors;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.CityInfoOuterClass.CityInfo;
+import emu.grasscutter.net.proto.GetSceneAreaRspOuterClass.GetSceneAreaRsp;
+
+public class PacketGetSceneAreaRsp extends GenshinPacket {
+	
+	public PacketGetSceneAreaRsp(int sceneId) {
+		super(PacketOpcodes.GetSceneAreaRsp);
+		
+		this.buildHeader(0);
+		
+		GetSceneAreaRsp p = GetSceneAreaRsp.newBuilder()
+				.setSceneId(3)
+				.addAllAreaIdList(Arrays.stream(new int[] {1,2,3,4,5,6,7,8,9,10,11,12,13,14,17,18,19}).boxed().collect(Collectors.toList()))
+				.addCityInfoList(CityInfo.newBuilder().setCityId(1).setLevel(1).build())
+				.addCityInfoList(CityInfo.newBuilder().setCityId(2).setLevel(1).build())
+				.addCityInfoList(CityInfo.newBuilder().setCityId(3).setLevel(1).build())
+				.build();
+		
+		this.setData(p);
+	}
+}

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

@@ -0,0 +1,25 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.GetScenePointRspOuterClass.GetScenePointRsp;
+
+public class PacketGetScenePointRsp extends GenshinPacket {
+	
+	public PacketGetScenePointRsp(int sceneId) {
+		super(PacketOpcodes.GetScenePointRsp);
+
+		GetScenePointRsp.Builder p = GetScenePointRsp.newBuilder()
+				.setSceneId(sceneId);
+		
+		for (int i = 1; i < 1000; i++) {
+			p.addUnlockedPointList(i);
+		}
+		
+		for (int i = 1; i < 9; i++) {
+			p.addUnlockAreaList(i);
+		}
+
+		this.setData(p);
+	}
+}

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

@@ -0,0 +1,19 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.GetShopRspOuterClass.GetShopRsp;
+import emu.grasscutter.net.proto.ShopOuterClass.Shop;
+
+public class PacketGetShopRsp extends GenshinPacket {
+	
+	public PacketGetShopRsp(int shopType) {
+		super(PacketOpcodes.GetShopRsp);
+
+		GetShopRsp proto = GetShopRsp.newBuilder()
+				.setShop(Shop.newBuilder().setShopType(shopType))
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,16 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.GetShopmallDataRspOuterClass.GetShopmallDataRsp;
+
+public class PacketGetShopmallDataRsp extends GenshinPacket {
+	
+	public PacketGetShopmallDataRsp() {
+		super(PacketOpcodes.GetShopmallDataRsp);
+
+		GetShopmallDataRsp proto = GetShopmallDataRsp.newBuilder().build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,19 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.World;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.GetWorldMpInfoRspOuterClass.GetWorldMpInfoRsp;
+
+public class PacketGetWorldMpInfoRsp extends GenshinPacket {
+	
+	public PacketGetWorldMpInfoRsp(World world) {
+		super(PacketOpcodes.GetWorldMpInfoRsp);
+
+		GetWorldMpInfoRsp proto = GetWorldMpInfoRsp.newBuilder()
+				.setIsInMpMode(world.isMultiplayer())
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,17 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.H5ActivityIdsNotifyOuterClass.H5ActivityIdsNotify;
+
+public class PacketH5ActivityIdsNotify extends GenshinPacket {
+	
+	public PacketH5ActivityIdsNotify() {
+		super(PacketOpcodes.H5ActivityIdsNotify);
+
+		H5ActivityIdsNotify proto = H5ActivityIdsNotify.newBuilder()
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,20 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.World;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.HostPlayerNotifyOuterClass.HostPlayerNotify;
+
+public class PacketHostPlayerNotify extends GenshinPacket {
+	
+	public PacketHostPlayerNotify(World world) {
+		super(PacketOpcodes.HostPlayerNotify);
+		
+		HostPlayerNotify proto = HostPlayerNotify.newBuilder()
+				.setHostUid(world.getHost().getId())
+				.setHostPeerId(world.getHost().getPeerId())
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,36 @@
+package emu.grasscutter.server.packet.send;
+
+import java.util.List;
+
+import emu.grasscutter.game.inventory.GenshinItem;
+import emu.grasscutter.game.props.ActionReason;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.ItemAddHintNotifyOuterClass.ItemAddHintNotify;
+
+public class PacketItemAddHintNotify extends GenshinPacket {
+	
+	public PacketItemAddHintNotify(GenshinItem item, ActionReason reason) {
+		super(PacketOpcodes.ItemAddHintNotify);
+		
+		ItemAddHintNotify proto = ItemAddHintNotify.newBuilder()
+				.addItemList(item.toItemHintProto())
+				.setReason(reason.getValue())
+				.build();
+		
+		this.setData(proto);
+	}
+
+	public PacketItemAddHintNotify(List<GenshinItem> items, ActionReason reason) {
+		super(PacketOpcodes.ItemAddHintNotify);
+		
+		ItemAddHintNotify.Builder proto = ItemAddHintNotify.newBuilder()
+				.setReason(reason.getValue());
+		
+		for (GenshinItem item : items) {
+			proto.addItemList(item.toItemHintProto());
+		}
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,32 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.entity.GenshinEntity;
+import emu.grasscutter.game.props.LifeState;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.LifeStateChangeNotifyOuterClass.LifeStateChangeNotify;
+
+public class PacketLifeStateChangeNotify extends GenshinPacket {
+	public PacketLifeStateChangeNotify(GenshinEntity attacker, GenshinEntity target, LifeState lifeState) {
+		super(PacketOpcodes.LifeStateChangeNotify);
+
+		LifeStateChangeNotify proto = LifeStateChangeNotify.newBuilder()
+				.setEntityId(target.getId())
+				.setLifeState(lifeState.getValue())
+				.setSourceEntityId(attacker.getId())
+				.build();
+		
+		this.setData(proto);
+	}
+	public PacketLifeStateChangeNotify(int attackerId, GenshinEntity target, LifeState lifeState) {
+		super(PacketOpcodes.LifeStateChangeNotify);
+
+		LifeStateChangeNotify proto = LifeStateChangeNotify.newBuilder()
+				.setEntityId(target.getId())
+				.setLifeState(lifeState.getValue())
+				.setSourceEntityId(attackerId)
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,23 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.props.OpenState;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.OpenStateUpdateNotifyOuterClass.OpenStateUpdateNotify;
+
+public class PacketOpenStateUpdateNotify extends GenshinPacket {
+	
+	public PacketOpenStateUpdateNotify() {
+		super(PacketOpcodes.OpenStateUpdateNotify);
+		
+		OpenStateUpdateNotify.Builder proto = OpenStateUpdateNotify.newBuilder();
+		
+		for (OpenState type : OpenState.values()) {
+			if (type.getValue() > 0) {
+				proto.putOpenStateMap(type.getValue(), 1);
+			}
+		}
+
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,13 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+
+public class PacketPathfindingEnterSceneRsp extends GenshinPacket {
+
+	public PacketPathfindingEnterSceneRsp(int clientSequence) {
+		super(PacketOpcodes.PathfindingEnterSceneRsp);
+		
+		this.buildHeader(clientSequence);
+	}
+}

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

@@ -0,0 +1,18 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.PingRspOuterClass.PingRsp;
+
+public class PacketPingRsp extends GenshinPacket {
+
+	public PacketPingRsp(int clientSeq, int time) {
+		super(PacketOpcodes.PingRsp, clientSeq);
+		
+		PingRsp p = PingRsp.newBuilder()
+				.setClientTime(time)
+				.build();
+		
+		this.setData(p.toByteArray());
+	}
+}

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

@@ -0,0 +1,19 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.PlayerApplyEnterMpNotifyOuterClass.PlayerApplyEnterMpNotify;
+
+public class PacketPlayerApplyEnterMpNotify extends GenshinPacket {
+	
+	public PacketPlayerApplyEnterMpNotify(GenshinPlayer srcPlayer) {
+		super(PacketOpcodes.PlayerApplyEnterMpNotify);
+
+		PlayerApplyEnterMpNotify proto = PlayerApplyEnterMpNotify.newBuilder()
+				.setSrcPlayerInfo(srcPlayer.getOnlinePlayerInfo())
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,36 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.PlayerApplyEnterMpReasonOuterClass.PlayerApplyEnterMpReason;
+import emu.grasscutter.net.proto.PlayerApplyEnterMpResultNotifyOuterClass.PlayerApplyEnterMpResultNotify;
+
+public class PacketPlayerApplyEnterMpResultNotify extends GenshinPacket {
+	
+	public PacketPlayerApplyEnterMpResultNotify(GenshinPlayer target, boolean isAgreed, PlayerApplyEnterMpReason reason) {
+		super(PacketOpcodes.PlayerApplyEnterMpResultNotify);
+
+		PlayerApplyEnterMpResultNotify proto = PlayerApplyEnterMpResultNotify.newBuilder()
+				.setTargetUid(target.getId())
+				.setTargetNickname(target.getNickname())
+				.setIsAgreed(isAgreed)
+				.setReason(reason)
+				.build();
+		
+		this.setData(proto);
+	}
+	
+	public PacketPlayerApplyEnterMpResultNotify(int targetId, String targetName, boolean isAgreed, PlayerApplyEnterMpReason reason) {
+		super(PacketOpcodes.PlayerApplyEnterMpResultNotify);
+
+		PlayerApplyEnterMpResultNotify proto = PlayerApplyEnterMpResultNotify.newBuilder()
+				.setTargetUid(targetId)
+				.setTargetNickname(targetName)
+				.setIsAgreed(isAgreed)
+				.setReason(reason)
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,19 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.PlayerApplyEnterMpResultRspOuterClass.PlayerApplyEnterMpResultRsp;
+
+public class PacketPlayerApplyEnterMpResultRsp extends GenshinPacket {
+	
+	public PacketPlayerApplyEnterMpResultRsp(int applyUid, boolean isAgreed) {
+		super(PacketOpcodes.PlayerApplyEnterMpResultRsp);
+
+		PlayerApplyEnterMpResultRsp proto = PlayerApplyEnterMpResultRsp.newBuilder()
+				.setApplyUid(applyUid)
+				.setIsAgreed(isAgreed)
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,18 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.PlayerApplyEnterMpRspOuterClass.PlayerApplyEnterMpRsp;
+
+public class PacketPlayerApplyEnterMpRsp extends GenshinPacket {
+	
+	public PacketPlayerApplyEnterMpRsp(int targetUid) {
+		super(PacketOpcodes.PlayerApplyEnterMpRsp);
+		
+		PlayerApplyEnterMpRsp proto = PlayerApplyEnterMpRsp.newBuilder()
+				.setTargetUid(targetUid)
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,62 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.ChatInfoOuterClass.ChatInfo;
+import emu.grasscutter.net.proto.PlayerChatNotifyOuterClass.PlayerChatNotify;
+import emu.grasscutter.net.proto.SystemHintOuterClass.SystemHint;
+
+public class PacketPlayerChatNotify extends GenshinPacket {
+	
+	public PacketPlayerChatNotify(GenshinPlayer sender, int channelId, String message) {
+		super(PacketOpcodes.PlayerChatNotify);
+		
+		ChatInfo info = ChatInfo.newBuilder()
+				.setTime((int) (System.currentTimeMillis() / 1000))
+				.setUid(sender.getId())
+				.setText(message)
+				.build();
+		
+		PlayerChatNotify proto = PlayerChatNotify.newBuilder()
+				.setChannelId(channelId)
+				.setChatInfo(info)
+				.build();
+		
+		this.setData(proto);
+	}
+	
+	public PacketPlayerChatNotify(GenshinPlayer sender, int channelId, int emote) {
+		super(PacketOpcodes.PlayerChatNotify);
+		
+		ChatInfo info = ChatInfo.newBuilder()
+				.setTime((int) (System.currentTimeMillis() / 1000))
+				.setUid(sender.getId())
+				.setIcon(emote)
+				.build();
+		
+		PlayerChatNotify proto = PlayerChatNotify.newBuilder()
+				.setChannelId(channelId)
+				.setChatInfo(info)
+				.build();
+		
+		this.setData(proto);
+	}
+	
+	public PacketPlayerChatNotify(GenshinPlayer sender, int channelId, SystemHint systemHint) {
+		super(PacketOpcodes.PlayerChatNotify);
+		
+		ChatInfo info = ChatInfo.newBuilder()
+				.setTime((int) (System.currentTimeMillis() / 1000))
+				.setUid(sender.getId())
+				.setSystemHint(systemHint)
+				.build();
+		
+		PlayerChatNotify proto = PlayerChatNotify.newBuilder()
+				.setChannelId(channelId)
+				.setChatInfo(info)
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,16 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.PlayerChatRspOuterClass.PlayerChatRsp;
+
+public class PacketPlayerChatRsp extends GenshinPacket {
+	
+	public PacketPlayerChatRsp() {
+		super(PacketOpcodes.PlayerChatRsp);
+		
+		PlayerChatRsp proto = PlayerChatRsp.newBuilder().build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,26 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.PlayerDataNotifyOuterClass.PlayerDataNotify;
+import emu.grasscutter.net.proto.PropValueOuterClass.PropValue;
+
+public class PacketPlayerDataNotify extends GenshinPacket {
+	
+	public PacketPlayerDataNotify(GenshinPlayer player) {
+		super(PacketOpcodes.PlayerDataNotify, 2);
+		
+		PlayerDataNotify.Builder p = PlayerDataNotify.newBuilder()
+				.setNickName(player.getNickname())
+				.setClientTime(System.currentTimeMillis())
+				.setIsFirstLoginToday(true)
+				.setRegionId(player.getRegionId());
+				
+		player.getProperties().forEach((key, value) -> {
+			p.putPropMap(key, PropValue.newBuilder().setType(key).setIval(value).setVal(value).build());
+		});
+
+		this.setData(p.build());
+	}
+}

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

@@ -0,0 +1,56 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.game.entity.EntityAvatar;
+import emu.grasscutter.game.inventory.GenshinItem;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.AbilitySyncStateInfoOuterClass.AbilitySyncStateInfo;
+import emu.grasscutter.net.proto.AvatarEnterSceneInfoOuterClass.AvatarEnterSceneInfo;
+import emu.grasscutter.net.proto.MPLevelEntityInfoOuterClass.MPLevelEntityInfo;
+import emu.grasscutter.net.proto.PlayerEnterSceneInfoNotifyOuterClass.PlayerEnterSceneInfoNotify;
+import emu.grasscutter.net.proto.TeamEnterSceneInfoOuterClass.TeamEnterSceneInfo;
+
+public class PacketPlayerEnterSceneInfoNotify extends GenshinPacket {
+	
+	public PacketPlayerEnterSceneInfoNotify(GenshinPlayer player) {
+		super(PacketOpcodes.PlayerEnterSceneInfoNotify);
+		
+		AbilitySyncStateInfo empty = AbilitySyncStateInfo.newBuilder().build();
+
+		PlayerEnterSceneInfoNotify.Builder proto = PlayerEnterSceneInfoNotify.newBuilder()
+				.setCurAvatarEntityId(player.getTeamManager().getCurrentAvatarEntity().getId())
+				.setEnterSceneToken(player.getEnterSceneToken());
+		
+		proto.setTeamEnterInfo(
+				TeamEnterSceneInfo.newBuilder()
+					.setTeamEntityId(player.getTeamManager().getEntityId()) // 150995833
+					.setTeamAbilityInfo(empty)
+					.setUnk(empty)
+		);
+		proto.setMpLevelEntityInfo(
+				MPLevelEntityInfo.newBuilder()
+					.setEntityId(player.getWorld().getLevelEntityId()) // 184550274
+					.setAuthorityPeerId(player.getWorld().getHostPeerId())
+					.setAbilityInfo(empty)
+		);
+		
+		for (EntityAvatar avatarEntity : player.getTeamManager().getActiveTeam()) {
+			GenshinItem weapon = avatarEntity.getAvatar().getWeapon();
+			long weaponGuid = weapon != null ? weapon.getGuid() : 0;
+			
+			AvatarEnterSceneInfo avatarInfo = AvatarEnterSceneInfo.newBuilder()
+					.setAvatarGuid(avatarEntity.getAvatar().getGuid())
+					.setAvatarEntityId(avatarEntity.getId())
+					.setWeaponGuid(weaponGuid)
+					.setWeaponEntityId(avatarEntity.getWeaponEntityId())
+					.setAvatarAbilityInfo(empty)
+					.setWeaponAbilityInfo(empty)
+					.build();
+			
+			proto.addAvatarEnterInfo(avatarInfo);
+		}
+		
+		this.setData(proto.build());
+	}
+}

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

@@ -0,0 +1,74 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.game.GenshinPlayer.SceneLoadState;
+import emu.grasscutter.game.props.EnterReason;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.EnterTypeOuterClass.EnterType;
+import emu.grasscutter.net.proto.PlayerEnterSceneNotifyOuterClass.PlayerEnterSceneNotify;
+import emu.grasscutter.utils.Position;
+import emu.grasscutter.utils.Utils;
+
+public class PacketPlayerEnterSceneNotify extends GenshinPacket {
+	
+	// Login
+	public PacketPlayerEnterSceneNotify(GenshinPlayer player) {
+		super(PacketOpcodes.PlayerEnterSceneNotify);
+		
+		player.setSceneLoadState(SceneLoadState.LOADING);
+		player.setEnterSceneToken(Utils.randomRange(1000, 99999));
+
+		PlayerEnterSceneNotify proto = PlayerEnterSceneNotify.newBuilder()
+				.setSceneId(player.getSceneId())
+				.setPos(player.getPos().toProto())
+				.setSceneBeginTime(System.currentTimeMillis())
+				.setType(EnterType.EnterSelf)
+				.setTargetUid(player.getId())
+				.setEnterSceneToken(player.getEnterSceneToken())
+				.setWorldLevel(player.getWorldLevel())
+				.setEnterReason(EnterReason.Login.getValue())
+				.setIsFirstLoginEnterScene(player.isFirstLoginEnterScene())
+				.addSceneTagIdList(102)
+				.addSceneTagIdList(107)
+				.addSceneTagIdList(113)
+				.addSceneTagIdList(117)
+				.setUnk1(1)
+				.setUnk2("3-" + player.getId() + "-" + (int) (System.currentTimeMillis() / 1000) + "-" + 18402)
+				.build();
+		
+		this.setData(proto);
+	}
+	
+	public PacketPlayerEnterSceneNotify(GenshinPlayer player, EnterType type, EnterReason reason, int newScene, Position newPos) {
+		this(player, player, type, reason, newScene, newPos);
+	}
+	
+	// Teleport or go somewhere
+	public PacketPlayerEnterSceneNotify(GenshinPlayer player, GenshinPlayer target, EnterType type, EnterReason reason, int newScene, Position newPos) {
+		super(PacketOpcodes.PlayerEnterSceneNotify);
+		
+		player.setEnterSceneToken(Utils.randomRange(1000, 99999));
+
+		PlayerEnterSceneNotify proto = PlayerEnterSceneNotify.newBuilder()
+				.setPrevSceneId(player.getSceneId())
+				.setPrevPos(player.getPos().toProto())
+				.setSceneId(newScene)
+				.setPos(newPos.toProto())
+				.setSceneBeginTime(System.currentTimeMillis())
+				.setType(EnterType.EnterSelf)
+				.setTargetUid(target.getId())
+				.setEnterSceneToken(player.getEnterSceneToken())
+				.setWorldLevel(target.getWorld().getWorldLevel())
+				.setEnterReason(reason.getValue())
+				.addSceneTagIdList(102)
+				.addSceneTagIdList(107)
+				.addSceneTagIdList(113)
+				.addSceneTagIdList(117)
+				.setUnk1(1)
+				.setUnk2(newScene + "-" + target.getId() + "-" + (int) (System.currentTimeMillis() / 1000) + "-" + 18402)
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,21 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.game.World;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.PlayerGameTimeNotifyOuterClass.PlayerGameTimeNotify;
+
+public class PacketPlayerGameTimeNotify extends GenshinPacket {
+	
+	public PacketPlayerGameTimeNotify(World world, GenshinPlayer player) {
+		super(PacketOpcodes.PlayerGameTimeNotify);
+		
+		PlayerGameTimeNotify proto = PlayerGameTimeNotify.newBuilder()
+				.setGameTime(world.getTime())
+				.setUid(player.getId())
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,18 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.PlayerGetForceQuitBanInfoRspOuterClass.PlayerGetForceQuitBanInfoRsp;
+
+public class PacketPlayerGetForceQuitBanInfoRsp extends GenshinPacket {
+	
+	public PacketPlayerGetForceQuitBanInfoRsp(int retcode) {
+		super(PacketOpcodes.PlayerGetForceQuitBanInfoRsp);
+
+		PlayerGetForceQuitBanInfoRsp proto = PlayerGetForceQuitBanInfoRsp.newBuilder()
+				.setRetcode(retcode)
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,38 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.Grasscutter;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.PlayerLoginRspOuterClass.PlayerLoginRsp;
+import emu.grasscutter.net.proto.RegionInfoOuterClass.RegionInfo;
+import emu.grasscutter.server.game.GameSession;
+
+public class PacketPlayerLoginRsp extends GenshinPacket {
+
+	public PacketPlayerLoginRsp(GameSession session) {
+		super(PacketOpcodes.PlayerLoginRsp, 1);
+		
+		this.setUseDispatchKey(true);
+		
+		RegionInfo info = Grasscutter.getDispatchServer().getCurrRegion().getRegionInfo();
+		
+		PlayerLoginRsp p = PlayerLoginRsp.newBuilder()
+				.setIsUseAbilityHash(true) // true
+				.setAbilityHashCode(1844674) // 1844674
+				.setGameBiz("hk4e_global")
+				.setClientDataVersion(info.getClientDataVersion())
+				.setClientSilenceDataVersion(info.getClientSilenceDataVersion())
+				.setClientMd5(info.getClientDataMd5())
+				.setClientSilenceMd5(info.getClientSilenceDataMd5())
+				.setResVersionConfig(info.getConfig())
+				.setClientVersionSuffix(info.getClientVersionSuffix())
+				.setClientSilenceVersionSuffix(info.getClientSilenceVersionSuffix())
+				.setIsScOpen(false)
+				//.setScInfo(ByteString.copyFrom(new byte[] {}))
+				.setRegisterCps("mihoyo")
+				.setCountryCode("US")
+				.build();
+		
+		this.setData(p.toByteArray());
+	}
+}

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

@@ -0,0 +1,23 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.game.props.PlayerProperty;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.PlayerPropNotifyOuterClass.PlayerPropNotify;
+import emu.grasscutter.utils.ProtoHelper;
+
+public class PacketPlayerPropNotify extends GenshinPacket {
+	
+	public PacketPlayerPropNotify(GenshinPlayer player, PlayerProperty prop) {
+		super(PacketOpcodes.PlayerPropNotify);
+		
+		this.buildHeader(0);
+		
+		PlayerPropNotify proto = PlayerPropNotify.newBuilder()
+				.putPropMap(prop.getId(), ProtoHelper.newPropValue(prop, player.getProperty(prop)))
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,13 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+
+public class PacketPlayerSetPauseRsp extends GenshinPacket {
+
+	public PacketPlayerSetPauseRsp(int clientSequence) {
+		super(PacketOpcodes.PlayerSetPauseRsp);
+		
+		this.buildHeader(clientSequence);
+	}
+}

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

@@ -0,0 +1,30 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.GenshinConstants;
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.game.inventory.GenshinItem;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.ItemOuterClass.Item;
+import emu.grasscutter.net.proto.PlayerStoreNotifyOuterClass.PlayerStoreNotify;
+import emu.grasscutter.net.proto.StoreTypeOuterClass.StoreType;
+
+public class PacketPlayerStoreNotify extends GenshinPacket {
+	
+	public PacketPlayerStoreNotify(GenshinPlayer player) {
+		super(PacketOpcodes.PlayerStoreNotify);
+		
+		this.buildHeader(2);
+		
+		PlayerStoreNotify.Builder p = PlayerStoreNotify.newBuilder()
+				.setStoreType(StoreType.StorePack)
+				.setWeightLimit(GenshinConstants.LIMIT_ALL);
+		
+		for (GenshinItem item : player.getInventory()) {
+			Item itemProto = item.toProto();
+			p.addItemList(itemProto);
+		}
+		
+		this.setData(p.build());
+	}
+}

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

@@ -0,0 +1,21 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.PlayerTimeNotifyOuterClass.PlayerTimeNotify;
+
+public class PacketPlayerTimeNotify extends GenshinPacket {
+	
+	public PacketPlayerTimeNotify(GenshinPlayer player) {
+		super(PacketOpcodes.PlayerTimeNotify);
+
+		PlayerTimeNotify proto = PlayerTimeNotify.newBuilder()
+				.setIsPaused(player.isPaused())
+				.setPlayerTime(player.getClientTime())
+				.setServerTime(System.currentTimeMillis())
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,19 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.PostEnterSceneRspOuterClass.PostEnterSceneRsp;
+
+public class PacketPostEnterSceneRsp extends GenshinPacket {
+
+	public PacketPostEnterSceneRsp(GenshinPlayer player) {
+		super(PacketOpcodes.PostEnterSceneRsp);
+		
+		PostEnterSceneRsp p = PostEnterSceneRsp.newBuilder()
+			.setEnterSceneToken(player.getEnterSceneToken())
+			.build();
+		
+		this.setData(p);
+	}
+}

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

@@ -0,0 +1,42 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.ChatInfoOuterClass.ChatInfo;
+import emu.grasscutter.net.proto.PrivateChatNotifyOuterClass.PrivateChatNotify;
+
+public class PacketPrivateChatNotify extends GenshinPacket {
+	public PacketPrivateChatNotify(int senderId, int recvId, String message) {
+		super(PacketOpcodes.PrivateChatNotify);
+		
+		ChatInfo info = ChatInfo.newBuilder()
+				.setTime((int) (System.currentTimeMillis() / 1000))
+				.setUid(senderId)
+				.setToUid(recvId)
+				.setText(message)
+				.build();
+		
+		PrivateChatNotify proto = PrivateChatNotify.newBuilder()
+				.setChatInfo(info)
+				.build();
+		
+		this.setData(proto);
+	}
+	
+	public PacketPrivateChatNotify(int senderId, int recvId, int emote) {
+		super(PacketOpcodes.PrivateChatNotify);
+		
+		ChatInfo info = ChatInfo.newBuilder()
+				.setTime((int) (System.currentTimeMillis() / 1000))
+				.setUid(senderId)
+				.setToUid(recvId)
+				.setIcon(emote)
+				.build();
+		
+		PrivateChatNotify proto = PrivateChatNotify.newBuilder()
+				.setChatInfo(info)
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,22 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.avatar.GenshinAvatar;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.ProudSkillChangeNotifyOuterClass.ProudSkillChangeNotify;
+
+public class PacketProudSkillChangeNotify extends GenshinPacket {
+	
+	public PacketProudSkillChangeNotify(GenshinAvatar avatar) {
+		super(PacketOpcodes.ProudSkillChangeNotify);
+		
+		ProudSkillChangeNotify proto = ProudSkillChangeNotify.newBuilder()
+				.setAvatarGuid(avatar.getGuid())
+				.setEntityId(avatar.getEntityId())
+				.setSkillDepotId(avatar.getSkillDepotId())
+				.addAllProudSkillList(avatar.getProudSkillList())
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,22 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.avatar.GenshinAvatar;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.ProudSkillExtraLevelNotifyOuterClass.ProudSkillExtraLevelNotify;
+
+public class PacketProudSkillExtraLevelNotify extends GenshinPacket {
+	
+	public PacketProudSkillExtraLevelNotify(GenshinAvatar avatar, int talentIndex) {
+		super(PacketOpcodes.ProudSkillExtraLevelNotify);
+
+		ProudSkillExtraLevelNotify proto = ProudSkillExtraLevelNotify.newBuilder()
+				.setAvatarGuid(avatar.getGuid())
+				.setTalentType(3) // Talent type = 3
+				.setTalentIndex(talentIndex)
+				.setExtraLevel(3)
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,16 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.PullPrivateChatRspOuterClass.PullPrivateChatRsp;
+
+public class PacketPullPrivateChatRsp extends GenshinPacket {
+	
+	public PacketPullPrivateChatRsp() {
+		super(PacketOpcodes.PullPrivateChatRsp);
+
+		PullPrivateChatRsp proto = PullPrivateChatRsp.newBuilder().build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,44 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.Config.ServerOptions;
+import emu.grasscutter.GenshinConstants;
+import emu.grasscutter.Grasscutter;
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.ChatInfoOuterClass.ChatInfo;
+import emu.grasscutter.net.proto.PullRecentChatRspOuterClass.PullRecentChatRsp;
+import emu.grasscutter.utils.Utils;
+
+public class PacketPullRecentChatRsp extends GenshinPacket {
+	public PacketPullRecentChatRsp(GenshinPlayer player) {
+		super(PacketOpcodes.PullRecentChatRsp);
+		
+		ServerOptions serverOptions = Grasscutter.getConfig().getServerOptions();
+		PullRecentChatRsp.Builder proto = PullRecentChatRsp.newBuilder();
+		
+		if (serverOptions.WelcomeEmotes != null && serverOptions.WelcomeEmotes.length > 0) {
+			ChatInfo welcomeEmote = ChatInfo.newBuilder()
+				.setTime((int) (System.currentTimeMillis() / 1000))
+				.setUid(GenshinConstants.SERVER_CONSOLE_UID)
+				.setToUid(player.getId())
+				.setIcon(serverOptions.WelcomeEmotes[Utils.randomRange(0, serverOptions.WelcomeEmotes.length - 1)])
+				.build();
+			
+			proto.addChatInfo(welcomeEmote);
+		}
+		
+		if (serverOptions.WelcomeMotd != null && serverOptions.WelcomeMotd.length() > 0) {
+			ChatInfo welcomeMotd = ChatInfo.newBuilder()
+				.setTime((int) (System.currentTimeMillis() / 1000))
+				.setUid(GenshinConstants.SERVER_CONSOLE_UID)
+				.setToUid(player.getId())
+				.setText(Grasscutter.getConfig().getServerOptions().WelcomeMotd)
+				.build();
+			
+			proto.addChatInfo(welcomeMotd);
+		}
+
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,26 @@
+package emu.grasscutter.server.packet.send;
+
+import java.util.List;
+
+import emu.grasscutter.game.inventory.GenshinItem;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.ReliquaryUpgradeRspOuterClass.ReliquaryUpgradeRsp;
+
+public class PacketReliquaryUpgradeRsp extends GenshinPacket {
+	
+	public PacketReliquaryUpgradeRsp(GenshinItem relic, int rate, int oldLevel, List<Integer> oldAppendPropIdList) {
+		super(PacketOpcodes.ReliquaryUpgradeRsp);
+
+		ReliquaryUpgradeRsp proto = ReliquaryUpgradeRsp.newBuilder()
+				.setTargetReliquaryGuid(relic.getGuid())
+				.setOldLevel(oldLevel)
+				.setCurLevel(relic.getLevel())
+				.setPowerUpRate(rate)
+				.addAllOldAppendPropList(oldAppendPropIdList)
+				.addAllCurAppendPropList(relic.getAppendPropIdList())
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,21 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.game.World;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.SceneAreaWeatherNotifyOuterClass.SceneAreaWeatherNotify;
+
+public class PacketSceneAreaWeatherNotify extends GenshinPacket {
+	
+	public PacketSceneAreaWeatherNotify(World world, GenshinPlayer player) {
+		super(PacketOpcodes.SceneAreaWeatherNotify);
+		
+		SceneAreaWeatherNotify proto = SceneAreaWeatherNotify.newBuilder()
+				.setWeatherAreaId(1)
+				.setClimateType(world.getClimate().getValue())
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,49 @@
+package emu.grasscutter.server.packet.send;
+
+import java.util.Collection;
+
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.game.entity.GenshinEntity;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.SceneEntityAppearNotifyOuterClass.SceneEntityAppearNotify;
+import emu.grasscutter.net.proto.VisionTypeOuterClass.VisionType;
+
+public class PacketSceneEntityAppearNotify extends GenshinPacket {
+	
+	public PacketSceneEntityAppearNotify(GenshinEntity entity) {
+		super(PacketOpcodes.SceneEntityAppearNotify, true);
+
+		SceneEntityAppearNotify.Builder proto = SceneEntityAppearNotify.newBuilder()
+				.setAppearType(VisionType.VisionBorn)
+				.addEntityList(entity.toProto());
+
+		this.setData(proto.build());
+	}
+	
+	public PacketSceneEntityAppearNotify(GenshinEntity entity, VisionType vision, int param) {
+		super(PacketOpcodes.SceneEntityAppearNotify, true);
+
+		SceneEntityAppearNotify.Builder proto = SceneEntityAppearNotify.newBuilder()
+				.setAppearType(vision)
+				.setParam(param)
+				.addEntityList(entity.toProto());
+
+		this.setData(proto.build());
+	}
+	
+	public PacketSceneEntityAppearNotify(GenshinPlayer player) {
+		this(player.getTeamManager().getCurrentAvatarEntity());
+	}
+
+	public PacketSceneEntityAppearNotify(Collection<GenshinEntity> entities, VisionType visionType) {
+		super(PacketOpcodes.SceneEntityAppearNotify, true);
+		
+		SceneEntityAppearNotify.Builder proto = SceneEntityAppearNotify.newBuilder()
+				.setAppearType(visionType);
+		
+		entities.forEach(e -> proto.addEntityList(e.toProto()));
+
+		this.setData(proto.build());
+	}
+}

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

@@ -0,0 +1,21 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.entity.GenshinEntity;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.SceneEntityDisappearNotifyOuterClass.SceneEntityDisappearNotify;
+import emu.grasscutter.net.proto.VisionTypeOuterClass.VisionType;
+
+public class PacketSceneEntityDisappearNotify extends GenshinPacket {
+	
+	public PacketSceneEntityDisappearNotify(GenshinEntity entity, VisionType disappearType) {
+		super(PacketOpcodes.SceneEntityDisappearNotify);
+
+		SceneEntityDisappearNotify proto = SceneEntityDisappearNotify.newBuilder()
+				.setDisappearType(disappearType)
+				.addEntityList(entity.getId())
+				.build();
+
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,22 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.EntityMoveInfoOuterClass.EntityMoveInfo;
+import emu.grasscutter.net.proto.SceneEntityMoveNotifyOuterClass.SceneEntityMoveNotify;
+
+public class PacketSceneEntityMoveNotify extends GenshinPacket {
+	
+	public PacketSceneEntityMoveNotify(EntityMoveInfo moveInfo) {
+		super(PacketOpcodes.SceneEntityMoveNotify, true);
+
+		SceneEntityMoveNotify proto = SceneEntityMoveNotify.newBuilder()
+				.setMotionInfo(moveInfo.getMotionInfo())
+				.setEntityId(moveInfo.getEntityId())
+				.setSceneTime(moveInfo.getSceneTime())
+				.setReliableSeq(moveInfo.getReliableSeq())
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,17 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.SceneInitFinishRspOuterClass.SceneInitFinishRsp;
+
+public class PacketSceneInitFinishRsp extends GenshinPacket {
+
+	public PacketSceneInitFinishRsp(GenshinPlayer player) {
+		super(PacketOpcodes.SceneInitFinishRsp, 11);
+		
+		SceneInitFinishRsp p = SceneInitFinishRsp.newBuilder().setEnterSceneToken(player.getEnterSceneToken()).build();
+		
+		this.setData(p.toByteArray());
+	}
+}

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

@@ -0,0 +1,28 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.SceneKickPlayerRspOuterClass.SceneKickPlayerRsp;
+
+public class PacketSceneKickPlayerRsp extends GenshinPacket {
+	
+	public PacketSceneKickPlayerRsp(int targetUid) {
+		super(PacketOpcodes.SceneKickPlayerRsp);
+
+		SceneKickPlayerRsp proto = SceneKickPlayerRsp.newBuilder()
+				.setTargetUid(targetUid)
+				.build();
+		
+		this.setData(proto);
+	}
+	
+	public PacketSceneKickPlayerRsp() {
+		super(PacketOpcodes.SceneKickPlayerRsp);
+
+		SceneKickPlayerRsp proto = SceneKickPlayerRsp.newBuilder()
+				.setRetcode(1)
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,33 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.game.World;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.ScenePlayerInfoNotifyOuterClass.ScenePlayerInfoNotify;
+import emu.grasscutter.net.proto.ScenePlayerInfoOuterClass.ScenePlayerInfo;
+
+public class PacketScenePlayerInfoNotify extends GenshinPacket {
+	
+	public PacketScenePlayerInfoNotify(World world) {
+		super(PacketOpcodes.ScenePlayerInfoNotify);
+
+		ScenePlayerInfoNotify.Builder proto = ScenePlayerInfoNotify.newBuilder();
+		
+		for (int i = 0; i < world.getPlayers().size(); i++) {
+			GenshinPlayer p = world.getPlayers().get(i);
+
+			ScenePlayerInfo pInfo = ScenePlayerInfo.newBuilder()
+					.setUid(p.getId())
+					.setPeerId(p.getPeerId())
+					.setName(p.getNickname())
+					.setSceneId(world.getSceneId())
+					.setOnlinePlayerInfo(p.getOnlinePlayerInfo())
+					.build();
+			
+			proto.addPlayerInfoList(pInfo);
+		}
+		
+		this.setData(proto.build());
+	}
+}

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

@@ -0,0 +1,22 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.ScenePlayerLocationNotifyOuterClass.ScenePlayerLocationNotify;
+
+public class PacketScenePlayerLocationNotify extends GenshinPacket {
+	
+	public PacketScenePlayerLocationNotify(GenshinPlayer player) {
+		super(PacketOpcodes.ScenePlayerLocationNotify);
+		
+		ScenePlayerLocationNotify.Builder proto = ScenePlayerLocationNotify.newBuilder()
+				.setSceneId(player.getSceneId());
+		
+		for (GenshinPlayer p : player.getWorld().getPlayers()) {
+			proto.addPlayerLocList(p.getPlayerLocationInfo());
+		}
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,46 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.game.entity.EntityAvatar;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.AbilitySyncStateInfoOuterClass.AbilitySyncStateInfo;
+import emu.grasscutter.net.proto.SceneTeamAvatarOuterClass.SceneTeamAvatar;
+import emu.grasscutter.net.proto.SceneTeamUpdateNotifyOuterClass.SceneTeamUpdateNotify;
+
+public class PacketSceneTeamUpdateNotify extends GenshinPacket {
+	
+	public PacketSceneTeamUpdateNotify(GenshinPlayer player) {
+		super(PacketOpcodes.SceneTeamUpdateNotify);
+
+		SceneTeamUpdateNotify.Builder proto = SceneTeamUpdateNotify.newBuilder()
+				.setIsInMp(player.getWorld().isMultiplayer());
+		
+		for (GenshinPlayer p : player.getWorld().getPlayers()) {
+			for (EntityAvatar entityAvatar : p.getTeamManager().getActiveTeam()) {
+				SceneTeamAvatar.Builder avatarProto = SceneTeamAvatar.newBuilder()
+						.setPlayerId(p.getId())
+						.setAvatarGuid(entityAvatar.getAvatar().getGuid())
+						.setSceneId(p.getSceneId())
+						.setEntityId(entityAvatar.getId())
+						.setSceneEntityInfo(entityAvatar.toProto())
+						.setWeaponGuid(entityAvatar.getAvatar().getWeapon().getGuid())
+						.setWeaponEntityId(entityAvatar.getWeaponEntityId())
+						.setIsPlayerCurAvatar(p.getTeamManager().getCurrentAvatarEntity() == entityAvatar)
+						.setIsOnScene(p.getTeamManager().getCurrentAvatarEntity() == entityAvatar)
+						.setAvatarAbilityInfo(AbilitySyncStateInfo.newBuilder())
+						.setWeaponAbilityInfo(AbilitySyncStateInfo.newBuilder())
+						.setAbilityControlBlock(entityAvatar.getAbilityControlBlock());
+				
+				if (player.getWorld().isMultiplayer()) {
+					avatarProto.setAvatarInfo(entityAvatar.getAvatar().toProto());
+					avatarProto.setSceneAvatarInfo(entityAvatar.getSceneAvatarInfo()); // why mihoyo...
+				}
+				
+				proto.addSceneTeamAvatarList(avatarProto);
+			}
+		}
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,20 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.GenshinPlayer;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.SceneTimeNotifyOuterClass.SceneTimeNotify;
+
+public class PacketSceneTimeNotify extends GenshinPacket {
+	
+	public PacketSceneTimeNotify(GenshinPlayer player) {
+		super(PacketOpcodes.SceneTimeNotify);
+
+		SceneTimeNotify proto = SceneTimeNotify.newBuilder()
+				.setSceneId(player.getSceneId())
+				.setSceneTime(0)
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,18 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.ServerTimeNotifyOuterClass.ServerTimeNotify;
+
+public class PacketServerTimeNotify extends GenshinPacket {
+	
+	public PacketServerTimeNotify() {
+		super(PacketOpcodes.ServerTimeNotify);
+
+		ServerTimeNotify proto = ServerTimeNotify.newBuilder()
+				.setServerTime(System.currentTimeMillis())
+				.build();
+		
+		this.setData(proto);
+	}
+}

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

@@ -0,0 +1,22 @@
+package emu.grasscutter.server.packet.send;
+
+import emu.grasscutter.game.inventory.GenshinItem;
+import emu.grasscutter.net.packet.GenshinPacket;
+import emu.grasscutter.net.packet.PacketOpcodes;
+import emu.grasscutter.net.proto.SetEquipLockStateRspOuterClass.SetEquipLockStateRsp;
+
+public class PacketSetEquipLockStateRsp extends GenshinPacket {
+	
+	public PacketSetEquipLockStateRsp(GenshinItem equip) {
+		super(PacketOpcodes.SetEquipLockStateRsp);
+		
+		this.buildHeader(0);
+
+		SetEquipLockStateRsp proto = SetEquipLockStateRsp.newBuilder()
+				.setTargetEquipGuid(equip.getGuid())
+				.setIsLocked(equip.isLocked())
+				.build();
+		
+		this.setData(proto);
+	}
+}