mirror of
https://github.com/Grasscutters/Grasscutter.git
synced 2025-03-13 05:47:20 +08:00
1108 lines
42 KiB
Java
1108 lines
42 KiB
Java
package emu.grasscutter.game.player;
|
|
|
|
import static emu.grasscutter.config.Configuration.GAME_OPTIONS;
|
|
|
|
import dev.morphia.annotations.Entity;
|
|
import dev.morphia.annotations.Transient;
|
|
import emu.grasscutter.GameConstants;
|
|
import emu.grasscutter.Grasscutter;
|
|
import emu.grasscutter.data.GameData;
|
|
import emu.grasscutter.data.binout.config.fields.ConfigAbilityData;
|
|
import emu.grasscutter.data.excels.avatar.AvatarSkillDepotData;
|
|
import emu.grasscutter.game.avatar.Avatar;
|
|
import emu.grasscutter.game.entity.EntityAvatar;
|
|
import emu.grasscutter.game.entity.EntityBaseGadget;
|
|
import emu.grasscutter.game.props.ElementType;
|
|
import emu.grasscutter.game.props.EnterReason;
|
|
import emu.grasscutter.game.props.FightProperty;
|
|
import emu.grasscutter.game.world.Scene;
|
|
import emu.grasscutter.game.world.World;
|
|
import emu.grasscutter.net.packet.BasePacket;
|
|
import emu.grasscutter.net.packet.PacketOpcodes;
|
|
import emu.grasscutter.net.proto.EnterTypeOuterClass.EnterType;
|
|
import emu.grasscutter.net.proto.MotionStateOuterClass.MotionState;
|
|
import emu.grasscutter.net.proto.PlayerDieTypeOuterClass.PlayerDieType;
|
|
import emu.grasscutter.net.proto.RetcodeOuterClass.Retcode;
|
|
import emu.grasscutter.net.proto.TrialAvatarGrantRecordOuterClass.TrialAvatarGrantRecord.GrantReason;
|
|
import emu.grasscutter.net.proto.VisionTypeOuterClass;
|
|
import emu.grasscutter.server.event.player.PlayerTeamDeathEvent;
|
|
import emu.grasscutter.server.packet.send.*;
|
|
import emu.grasscutter.utils.Position;
|
|
import emu.grasscutter.utils.Utils;
|
|
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
|
|
import it.unimi.dsi.fastutil.ints.IntOpenHashSet;
|
|
import it.unimi.dsi.fastutil.ints.IntSet;
|
|
import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
|
|
import java.util.*;
|
|
import java.util.stream.Stream;
|
|
import lombok.Getter;
|
|
import lombok.Setter;
|
|
import lombok.val;
|
|
|
|
@Entity
|
|
public final class TeamManager extends BasePlayerDataManager {
|
|
@Transient private final List<EntityAvatar> avatars;
|
|
@Transient @Getter private final Set<EntityBaseGadget> gadgets;
|
|
@Transient @Getter private final IntSet teamResonances;
|
|
@Transient @Getter private final IntSet teamResonancesConfig;
|
|
// This needs to be a LinkedHashMap to guarantee insertion order.
|
|
@Getter private LinkedHashMap<Integer, TeamInfo> teams;
|
|
private int currentTeamIndex;
|
|
@Getter @Setter private int currentCharacterIndex;
|
|
@Transient @Getter @Setter private TeamInfo mpTeam;
|
|
@Transient @Getter @Setter private int entityId;
|
|
|
|
@Transient private int useTemporarilyTeamIndex = -1;
|
|
@Transient private List<TeamInfo> temporaryTeam; // Temporary Team for tower
|
|
@Transient @Getter @Setter private boolean usingTrialTeam;
|
|
@Transient @Getter @Setter private TeamInfo trialAvatarTeam;
|
|
// hold trial avatars for later use in rebuilding active team
|
|
@Transient @Getter @Setter private Map<Integer, Avatar> trialAvatars;
|
|
|
|
@Transient @Getter @Setter
|
|
private int previousIndex = -1; // index of character selection in team before adding trial avatar
|
|
|
|
public TeamManager() {
|
|
this.mpTeam = new TeamInfo();
|
|
this.avatars = Collections.synchronizedList(new ArrayList<>());
|
|
this.gadgets = new HashSet<>();
|
|
this.teamResonances = new IntOpenHashSet();
|
|
this.teamResonancesConfig = new IntOpenHashSet();
|
|
this.trialAvatars = new HashMap<>();
|
|
this.trialAvatarTeam = new TeamInfo();
|
|
}
|
|
|
|
public TeamManager(Player player) {
|
|
this();
|
|
this.setPlayer(player);
|
|
|
|
this.teams = new LinkedHashMap<>();
|
|
this.currentTeamIndex = 1;
|
|
for (int i = 1; i <= GameConstants.DEFAULT_TEAMS; i++) {
|
|
this.teams.put(i, new TeamInfo());
|
|
}
|
|
}
|
|
|
|
public World getWorld() {
|
|
return this.getPlayer().getWorld();
|
|
}
|
|
|
|
/**
|
|
* Search through all teams and if the team matches, return that index. Otherwise, return -1. No
|
|
* match could mean that the team does not currently belong to the player.
|
|
*/
|
|
public int getTeamId(TeamInfo team) {
|
|
for (int i = 1; i <= this.teams.size(); i++) {
|
|
if (this.teams.get(i).equals(team)) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
public int getCurrentTeamId() {
|
|
// Starts from 1
|
|
return currentTeamIndex;
|
|
}
|
|
|
|
private void setCurrentTeamId(int currentTeamIndex) {
|
|
this.currentTeamIndex = currentTeamIndex;
|
|
}
|
|
|
|
public long getCurrentCharacterGuid() {
|
|
return this.getCurrentAvatarEntity().getAvatar().getGuid();
|
|
}
|
|
|
|
public TeamInfo getCurrentTeamInfo() {
|
|
if (useTemporarilyTeamIndex >= 0 && useTemporarilyTeamIndex < temporaryTeam.size()) {
|
|
return temporaryTeam.get(useTemporarilyTeamIndex);
|
|
}
|
|
if (this.getPlayer().isInMultiplayer()) {
|
|
return this.getMpTeam();
|
|
}
|
|
return this.getTeams().get(this.currentTeamIndex);
|
|
}
|
|
|
|
public TeamInfo getCurrentSinglePlayerTeamInfo() {
|
|
return this.getTeams().get(this.currentTeamIndex);
|
|
}
|
|
|
|
public List<EntityAvatar> getActiveTeam() {
|
|
return avatars;
|
|
}
|
|
|
|
public EntityAvatar getCurrentAvatarEntity() {
|
|
return this.getActiveTeam().get(this.currentCharacterIndex);
|
|
}
|
|
|
|
public boolean isSpawned() {
|
|
return this.getPlayer().getScene() != null
|
|
&& this.getPlayer()
|
|
.getScene()
|
|
.getEntities()
|
|
.containsKey(this.getCurrentAvatarEntity().getId());
|
|
}
|
|
|
|
public int getMaxTeamSize() {
|
|
if (this.getPlayer().isInMultiplayer()) {
|
|
int max = GAME_OPTIONS.avatarLimits.multiplayerTeam;
|
|
if (this.getPlayer().getWorld().getHost() == this.getPlayer()) {
|
|
return Math.max(1, (int) Math.ceil(max / (double) this.getWorld().getPlayerCount()));
|
|
}
|
|
return Math.max(1, (int) Math.floor(max / (double) this.getWorld().getPlayerCount()));
|
|
}
|
|
|
|
return GAME_OPTIONS.avatarLimits.singlePlayerTeam;
|
|
}
|
|
|
|
// Methods
|
|
|
|
/** Returns true if there is space to add the number of avatars to the team. */
|
|
public boolean canAddAvatarsToTeam(TeamInfo team, int avatars) {
|
|
return team.size() + avatars <= this.getMaxTeamSize();
|
|
}
|
|
|
|
/** Returns true if there is space to add to the team. */
|
|
public boolean canAddAvatarToTeam(TeamInfo team) {
|
|
return this.canAddAvatarsToTeam(team, 1);
|
|
}
|
|
|
|
/**
|
|
* Returns true if there is space to add the number of avatars to the current team. If the current
|
|
* team is temporary, returns false.
|
|
*/
|
|
public boolean canAddAvatarsToCurrentTeam(int avatars) {
|
|
if (this.useTemporarilyTeamIndex != -1) {
|
|
return false;
|
|
}
|
|
return this.canAddAvatarsToTeam(this.getCurrentTeamInfo(), avatars);
|
|
}
|
|
|
|
/**
|
|
* Returns true if there is space to add to the current team. If the current team is temporary,
|
|
* returns false.
|
|
*/
|
|
public boolean canAddAvatarToCurrentTeam() {
|
|
return this.canAddAvatarsToCurrentTeam(1);
|
|
}
|
|
|
|
/**
|
|
* Try to add the collection of avatars to the team. Returns true if all were successfully added.
|
|
* If some can not be added, returns false and does not add any.
|
|
*/
|
|
public boolean addAvatarsToTeam(TeamInfo team, Collection<Avatar> avatars) {
|
|
if (!this.canAddAvatarsToTeam(team, avatars.size())) {
|
|
return false;
|
|
}
|
|
|
|
// Convert avatars into a collection of avatar IDs, then add
|
|
team.getAvatars().addAll(avatars.stream().map(a -> a.getAvatarId()).toList());
|
|
|
|
// Update team
|
|
if (this.getPlayer().isInMultiplayer()) {
|
|
if (team.equals(this.getMpTeam())) {
|
|
// MP team Packet
|
|
this.updateTeamEntities(new PacketChangeMpTeamAvatarRsp(this.getPlayer(), team));
|
|
}
|
|
} else {
|
|
// SP team update packet
|
|
this.getPlayer().sendPacket(new PacketAvatarTeamUpdateNotify(this.getPlayer()));
|
|
|
|
int teamId = this.getTeamId(team);
|
|
if (teamId != -1) {
|
|
// This is one of the player's teams
|
|
// Update entites
|
|
if (teamId == this.getCurrentTeamId()) {
|
|
this.updateTeamEntities(new PacketSetUpAvatarTeamRsp(this.getPlayer(), teamId, team));
|
|
} else {
|
|
this.getPlayer().sendPacket(new PacketSetUpAvatarTeamRsp(this.getPlayer(), teamId, team));
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/** Try to add an avatar to a team. Returns true if successful. */
|
|
public boolean addAvatarToTeam(TeamInfo team, Avatar avatar) {
|
|
return this.addAvatarsToTeam(team, Collections.singleton(avatar));
|
|
}
|
|
|
|
/**
|
|
* Try to add the collection of avatars to the current team. Will not modify a temporary team.
|
|
* Returns true if all were successfully added. If some can not be added, returns false and does
|
|
* not add any.
|
|
*/
|
|
public boolean addAvatarsToCurrentTeam(Collection<Avatar> avatars) {
|
|
if (this.useTemporarilyTeamIndex != -1) {
|
|
return false;
|
|
}
|
|
return this.addAvatarsToTeam(this.getCurrentTeamInfo(), avatars);
|
|
}
|
|
|
|
/**
|
|
* Try to add an avatar to the current team. Will not modify a temporary team. Returns true if
|
|
* successful.
|
|
*/
|
|
public boolean addAvatarToCurrentTeam(Avatar avatar) {
|
|
return this.addAvatarsToCurrentTeam(Collections.singleton(avatar));
|
|
}
|
|
|
|
private void updateTeamResonances() {
|
|
this.getTeamResonances().clear();
|
|
this.getTeamResonancesConfig().clear();
|
|
// Official resonances require a full party
|
|
if (this.avatars.size() < 4) return;
|
|
|
|
// TODO: make this actually read from TeamResonanceExcelConfigData.json for the real resonances
|
|
// and conditions
|
|
// Currently we just hardcode these conditions, but this won't work for modded resources or
|
|
// future changes
|
|
var elementCounts = new Object2IntOpenHashMap<ElementType>();
|
|
this.getActiveTeam().stream()
|
|
.map(EntityAvatar::getAvatar)
|
|
.filter(Objects::nonNull)
|
|
.map(Avatar::getSkillDepot)
|
|
.filter(Objects::nonNull)
|
|
.map(AvatarSkillDepotData::getElementType)
|
|
.filter(Objects::nonNull)
|
|
.forEach(elementType -> elementCounts.addTo(elementType, 1));
|
|
|
|
// Dual element resonances
|
|
elementCounts.object2IntEntrySet().stream()
|
|
.filter(e -> e.getIntValue() >= 2)
|
|
.map(e -> e.getKey())
|
|
.filter(elementType -> elementType.getTeamResonanceId() != 0)
|
|
.forEach(
|
|
elementType -> {
|
|
this.teamResonances.add(elementType.getTeamResonanceId());
|
|
this.teamResonancesConfig.add(elementType.getConfigHash());
|
|
});
|
|
|
|
// Four element resonance
|
|
if (elementCounts.size() >= 4) {
|
|
this.teamResonances.add(ElementType.Default.getTeamResonanceId());
|
|
this.teamResonancesConfig.add(ElementType.Default.getConfigHash());
|
|
}
|
|
}
|
|
|
|
/** Updates all properties of the active team. */
|
|
public void updateTeamProperties() {
|
|
this.updateTeamResonances(); // Update team resonances.
|
|
this.getPlayer()
|
|
.sendPacket(new PacketSceneTeamUpdateNotify(this.getPlayer())); // Notify the player.
|
|
|
|
// Skill charges packet - Yes, this is official server behavior as of 2.6.0
|
|
this.getActiveTeam().stream()
|
|
.map(EntityAvatar::getAvatar)
|
|
.forEach(Avatar::sendSkillExtraChargeMap);
|
|
}
|
|
|
|
public void updateTeamEntities(BasePacket responsePacket) {
|
|
// Sanity check - Should never happen
|
|
if (this.getCurrentTeamInfo().getAvatars().size() <= 0) {
|
|
return;
|
|
}
|
|
|
|
// If current team has changed
|
|
var currentEntity = this.getCurrentAvatarEntity();
|
|
var existingAvatars = new Int2ObjectOpenHashMap<EntityAvatar>();
|
|
var prevSelectedAvatarIndex = -1;
|
|
|
|
for (EntityAvatar entity : this.getActiveTeam()) {
|
|
existingAvatars.put(entity.getAvatar().getAvatarId(), entity);
|
|
}
|
|
|
|
// Clear active team entity list
|
|
this.getActiveTeam().clear();
|
|
|
|
// Add back entities into team
|
|
for (int i = 0; i < this.getCurrentTeamInfo().getAvatars().size(); i++) {
|
|
var avatarId = (int) this.getCurrentTeamInfo().getAvatars().get(i);
|
|
EntityAvatar entity;
|
|
if (existingAvatars.containsKey(avatarId)) {
|
|
entity = existingAvatars.get(avatarId);
|
|
existingAvatars.remove(avatarId);
|
|
if (entity == currentEntity) {
|
|
prevSelectedAvatarIndex = i;
|
|
}
|
|
} else {
|
|
entity =
|
|
new EntityAvatar(
|
|
this.getPlayer().getScene(), this.getPlayer().getAvatars().getAvatarById(avatarId));
|
|
}
|
|
|
|
this.getActiveTeam().add(entity);
|
|
}
|
|
|
|
// Unload removed entities
|
|
for (var entity : existingAvatars.values()) {
|
|
this.getPlayer().getScene().removeEntity(entity);
|
|
entity.getAvatar().save();
|
|
}
|
|
|
|
// Set new selected character index
|
|
if (prevSelectedAvatarIndex == -1) {
|
|
// Previous selected avatar is not in the same spot, we will select the current one in the
|
|
// prev slot
|
|
prevSelectedAvatarIndex =
|
|
Math.min(this.currentCharacterIndex, this.getActiveTeam().size() - 1);
|
|
}
|
|
this.currentCharacterIndex = prevSelectedAvatarIndex;
|
|
|
|
// Update properties.
|
|
// Notify player.
|
|
this.updateTeamProperties();
|
|
|
|
// Send response packet.
|
|
if (responsePacket != null) {
|
|
this.getPlayer().sendPacket(responsePacket);
|
|
}
|
|
|
|
// Check if character changed
|
|
if (currentEntity != this.getCurrentAvatarEntity()) {
|
|
// Remove and Add
|
|
this.getPlayer().getScene().replaceEntity(currentEntity, this.getCurrentAvatarEntity());
|
|
}
|
|
}
|
|
|
|
public synchronized void setupAvatarTeam(int teamId, List<Long> list) {
|
|
// Sanity checks
|
|
if (list.size() == 0
|
|
|| list.size() > this.getMaxTeamSize()
|
|
|| this.getPlayer().isInMultiplayer()) {
|
|
return;
|
|
}
|
|
|
|
// Get team
|
|
TeamInfo teamInfo = this.getTeams().get(teamId);
|
|
if (teamInfo == null) {
|
|
return;
|
|
}
|
|
|
|
// Set team data
|
|
LinkedHashSet<Avatar> newTeam = new LinkedHashSet<>();
|
|
for (Long aLong : list) {
|
|
Avatar avatar = this.getPlayer().getAvatars().getAvatarByGuid(aLong);
|
|
if (avatar == null || newTeam.contains(avatar)) {
|
|
// Should never happen
|
|
return;
|
|
}
|
|
newTeam.add(avatar);
|
|
}
|
|
|
|
// Clear current team info and add avatars from our new team
|
|
teamInfo.getAvatars().clear();
|
|
this.addAvatarsToTeam(teamInfo, newTeam);
|
|
}
|
|
|
|
public void setupMpTeam(List<Long> list) {
|
|
// Sanity checks
|
|
if (list.size() == 0
|
|
|| list.size() > this.getMaxTeamSize()
|
|
|| !this.getPlayer().isInMultiplayer()) {
|
|
return;
|
|
}
|
|
|
|
TeamInfo teamInfo = this.getMpTeam();
|
|
|
|
// Set team data
|
|
LinkedHashSet<Avatar> newTeam = new LinkedHashSet<>();
|
|
for (Long aLong : list) {
|
|
Avatar avatar = this.getPlayer().getAvatars().getAvatarByGuid(aLong);
|
|
if (avatar == null || newTeam.contains(avatar)) {
|
|
// Should never happen
|
|
return;
|
|
}
|
|
newTeam.add(avatar);
|
|
}
|
|
|
|
// Clear current team info and add avatars from our new team
|
|
teamInfo.getAvatars().clear();
|
|
this.addAvatarsToTeam(teamInfo, newTeam);
|
|
}
|
|
|
|
/**
|
|
* Setup avatars for a trial avatar team.
|
|
*
|
|
* @param save Should the original team be saved?
|
|
*/
|
|
public void setupTrialAvatars(boolean save) {
|
|
this.setPreviousIndex(this.getCurrentCharacterIndex());
|
|
|
|
if (save) {
|
|
var originalTeam = this.getCurrentTeamInfo();
|
|
this.getTrialAvatarTeam().copyFrom(originalTeam);
|
|
} else this.getActiveTeam().clear();
|
|
|
|
this.usingTrialTeam = true;
|
|
}
|
|
|
|
/**
|
|
* Displays the trial avatars.
|
|
*
|
|
* @param newCharacterIndex The avatar to equip.
|
|
*/
|
|
public void trialAvatarTeamPostUpdate(int newCharacterIndex) {
|
|
this.setCurrentCharacterIndex(Math.min(newCharacterIndex, this.getActiveTeam().size() - 1));
|
|
|
|
this.updateTeamProperties();
|
|
this.getPlayer().getScene().addEntity(this.getCurrentAvatarEntity());
|
|
}
|
|
|
|
/**
|
|
* Adds an avatar to the trial team.
|
|
*
|
|
* @param trialAvatar The avatar to add.
|
|
*/
|
|
public void addAvatarToTrialTeam(Avatar trialAvatar) {
|
|
// Remove the existing team's avatars.
|
|
this.getActiveTeam()
|
|
.forEach(
|
|
x ->
|
|
this.getPlayer()
|
|
.getScene()
|
|
.removeEntity(x, VisionTypeOuterClass.VisionType.VISION_TYPE_REMOVE));
|
|
// Remove the existing avatar from the teams if it exists.
|
|
this.getActiveTeam().removeIf(x -> x.getAvatar().getAvatarId() == trialAvatar.getAvatarId());
|
|
this.getCurrentTeamInfo().getAvatars().removeIf(x -> x == trialAvatar.getAvatarId());
|
|
// Add the avatar to the teams.
|
|
this.getActiveTeam().add(new EntityAvatar(this.getPlayer().getScene(), trialAvatar));
|
|
this.getCurrentTeamInfo().addAvatar(trialAvatar);
|
|
this.getTrialAvatars().put(trialAvatar.getAvatarId(), trialAvatar);
|
|
}
|
|
|
|
/**
|
|
* Get the GUID of a trial avatar.
|
|
*
|
|
* @param trialAvatarId The avatar ID.
|
|
* @return The GUID of the avatar.
|
|
*/
|
|
public long getTrialAvatarGuid(int trialAvatarId) {
|
|
return this.getTrialAvatars().values().stream()
|
|
.filter(avatar -> avatar.getTrialAvatarId() == trialAvatarId)
|
|
.map(Avatar::getGuid)
|
|
.findFirst()
|
|
.orElse(0L);
|
|
}
|
|
|
|
/** Rollback changes from using a trial avatar team. */
|
|
public void unsetTrialAvatarTeam() {
|
|
// Get the previous index.
|
|
var index = this.getPreviousIndex();
|
|
if (index < 0) index = 0;
|
|
|
|
// Remove the trial avatars.
|
|
this.trialAvatarTeamPostUpdate(index);
|
|
// Reset the index.
|
|
this.setPreviousIndex(-1);
|
|
}
|
|
|
|
/** Removes all avatars from the trial avatar team. */
|
|
public void removeTrialAvatarTeam() {
|
|
this.removeTrialAvatarTeam(
|
|
this.getActiveTeam().stream().map(avatar -> avatar.getAvatar().getAvatarId()).toList());
|
|
}
|
|
|
|
/**
|
|
* Removes one avatar from the trial avatar team.
|
|
*
|
|
* @param avatarId The avatar ID to remove.
|
|
*/
|
|
public void removeTrialAvatarTeam(int avatarId) {
|
|
this.removeTrialAvatarTeam(List.of(avatarId));
|
|
}
|
|
|
|
/**
|
|
* Removes a collection of avatars from the trial avatar team.
|
|
*
|
|
* @param trialAvatarIds The avatar IDs to remove.
|
|
*/
|
|
public void removeTrialAvatarTeam(List<Integer> trialAvatarIds) {
|
|
var isTeam = trialAvatarIds.size() == this.getActiveTeam().size();
|
|
|
|
var player = this.getPlayer();
|
|
var scene = player.getScene();
|
|
|
|
// Disable the trial team.
|
|
this.usingTrialTeam = false;
|
|
this.trialAvatarTeam = new TeamInfo();
|
|
|
|
// Remove the avatars from the team.
|
|
this.getActiveTeam().forEach(avatarEntity -> scene
|
|
.removeEntity(avatarEntity, VisionTypeOuterClass.VisionType.VISION_TYPE_REMOVE));
|
|
|
|
if (isTeam) {
|
|
this.getActiveTeam().clear();
|
|
this.getTrialAvatars().clear();
|
|
} else {
|
|
trialAvatarIds.forEach(
|
|
trialAvatarId -> {
|
|
this.getActiveTeam().removeIf(x -> x.getAvatar().getTrialAvatarId() == trialAvatarId);
|
|
this.getTrialAvatars().values().removeIf(x -> x.getTrialAvatarId() == trialAvatarId);
|
|
});
|
|
}
|
|
|
|
// Re-add the avatars to the team.
|
|
if (isTeam) {
|
|
// Restores all avatars from the player's avatar storage.
|
|
this.getCurrentTeamInfo().getAvatars().forEach(avatarId ->
|
|
this.getActiveTeam().add(new EntityAvatar(
|
|
scene, player.getAvatars().getAvatarById(avatarId)
|
|
)));
|
|
} else {
|
|
// Restores all avatars from the player's avatar storage.
|
|
// If the avatar is already in the team, it will not be added.
|
|
// TODO: Fix order in which avatars are added.
|
|
// Currently, they are added from last to first.
|
|
var avatars = this.getCurrentTeamInfo().getAvatars();
|
|
for (var index = 0; index < avatars.size(); index++) {
|
|
var avatar = avatars.get(index);
|
|
if (this.getActiveTeam().stream()
|
|
.map(entity -> entity.getAvatar().getAvatarId())
|
|
.toList()
|
|
.contains(avatar)) continue;
|
|
|
|
// Check if the player owns the avatar.
|
|
var avatarData = player.getAvatars().getAvatarById(avatar);
|
|
if (avatarData == null) continue;
|
|
|
|
this.getActiveTeam().add(index, new EntityAvatar(scene, avatarData));
|
|
}
|
|
}
|
|
|
|
this.unsetTrialAvatarTeam();
|
|
}
|
|
|
|
public void setupTemporaryTeam(List<List<Long>> guidList) {
|
|
this.temporaryTeam =
|
|
guidList.stream()
|
|
.map(
|
|
list -> {
|
|
// Sanity checks
|
|
if (list.size() == 0 || list.size() > this.getMaxTeamSize()) {
|
|
return null;
|
|
}
|
|
|
|
// Set team data
|
|
LinkedHashSet<Avatar> newTeam = new LinkedHashSet<>();
|
|
for (Long aLong : list) {
|
|
Avatar avatar = this.getPlayer().getAvatars().getAvatarByGuid(aLong);
|
|
if (avatar == null || newTeam.contains(avatar)) {
|
|
// Should never happen
|
|
return null;
|
|
}
|
|
newTeam.add(avatar);
|
|
}
|
|
|
|
// convert to avatar ids
|
|
return newTeam.stream().map(Avatar::getAvatarId).toList();
|
|
})
|
|
.filter(Objects::nonNull)
|
|
.map(TeamInfo::new)
|
|
.toList();
|
|
}
|
|
|
|
public void useTemporaryTeam(int index) {
|
|
this.useTemporarilyTeamIndex = index;
|
|
this.updateTeamEntities(null);
|
|
}
|
|
|
|
public void cleanTemporaryTeam() {
|
|
// check if using temporary team
|
|
if (useTemporarilyTeamIndex < 0) {
|
|
return;
|
|
}
|
|
|
|
this.useTemporarilyTeamIndex = -1;
|
|
this.temporaryTeam = null;
|
|
this.updateTeamEntities(null);
|
|
}
|
|
|
|
public synchronized void setCurrentTeam(int teamId) {
|
|
//
|
|
if (this.getPlayer().isInMultiplayer()) {
|
|
return;
|
|
}
|
|
|
|
// Get team
|
|
TeamInfo teamInfo = this.getTeams().get(teamId);
|
|
if (teamInfo == null || teamInfo.getAvatars().size() == 0) {
|
|
return;
|
|
}
|
|
|
|
// Set
|
|
this.setCurrentTeamId(teamId);
|
|
this.updateTeamEntities(new PacketChooseCurAvatarTeamRsp(teamId));
|
|
}
|
|
|
|
public synchronized void setTeamName(int teamId, String teamName) {
|
|
// Get team
|
|
TeamInfo teamInfo = this.getTeams().get(teamId);
|
|
if (teamInfo == null) {
|
|
return;
|
|
}
|
|
|
|
teamInfo.setName(teamName);
|
|
|
|
// Packet
|
|
this.getPlayer().sendPacket(new PacketChangeTeamNameRsp(teamId, teamName));
|
|
}
|
|
|
|
public synchronized void changeAvatar(long guid) {
|
|
EntityAvatar oldEntity = this.getCurrentAvatarEntity();
|
|
|
|
if (guid == oldEntity.getAvatar().getGuid()) {
|
|
return;
|
|
}
|
|
|
|
EntityAvatar newEntity = null;
|
|
int index = -1;
|
|
for (int i = 0; i < this.getActiveTeam().size(); i++) {
|
|
if (guid == this.getActiveTeam().get(i).getAvatar().getGuid()) {
|
|
index = i;
|
|
newEntity = this.getActiveTeam().get(i);
|
|
}
|
|
}
|
|
|
|
if (index < 0 || newEntity == oldEntity) {
|
|
return;
|
|
}
|
|
|
|
// Set index
|
|
this.setCurrentCharacterIndex(index);
|
|
|
|
// Old entity motion state
|
|
oldEntity.setMotionState(MotionState.MOTION_STATE_STANDBY);
|
|
|
|
// Remove and Add
|
|
this.getPlayer().getScene().replaceEntity(oldEntity, newEntity);
|
|
this.getPlayer().sendPacket(new PacketChangeAvatarRsp(guid));
|
|
}
|
|
|
|
/**
|
|
* Applies 10% of the avatar's max HP as damage. This occurs when the avatar is killed by the
|
|
* void.
|
|
*/
|
|
public void applyVoidDamage() {
|
|
this.getActiveTeam()
|
|
.forEach(
|
|
entity -> {
|
|
entity.damage(entity.getFightProperty(FightProperty.FIGHT_PROP_MAX_HP) * .1f);
|
|
player.sendPacket(new PacketAvatarLifeStateChangeNotify(entity.getAvatar()));
|
|
});
|
|
}
|
|
|
|
public void onAvatarDie(long dieGuid) {
|
|
EntityAvatar deadAvatar = this.getCurrentAvatarEntity();
|
|
|
|
if (deadAvatar.isAlive() || deadAvatar.getId() != dieGuid) {
|
|
return;
|
|
}
|
|
|
|
PlayerDieType dieType = deadAvatar.getKilledType();
|
|
int killedBy = deadAvatar.getKilledBy();
|
|
|
|
if (dieType == PlayerDieType.PLAYER_DIE_TYPE_DRAWN) {
|
|
// Died in water. Do not replace
|
|
// The official server has skipped this notify and will just respawn the team immediately
|
|
// after the animation.
|
|
// TODO: Perhaps find a way to get vanilla experience?
|
|
this.getPlayer().sendPacket(new PacketWorldPlayerDieNotify(dieType, killedBy));
|
|
} else {
|
|
// Replacement avatar
|
|
EntityAvatar replacement = null;
|
|
int replaceIndex = -1;
|
|
|
|
for (int i = 0; i < this.getActiveTeam().size(); i++) {
|
|
EntityAvatar entity = this.getActiveTeam().get(i);
|
|
if (entity.isAlive()) {
|
|
replaceIndex = i;
|
|
replacement = entity;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (replacement == null) {
|
|
// No more living team members...
|
|
this.getPlayer().sendPacket(new PacketWorldPlayerDieNotify(dieType, killedBy));
|
|
// Invoke player team death event.
|
|
PlayerTeamDeathEvent event =
|
|
new PlayerTeamDeathEvent(
|
|
this.getPlayer(), this.getActiveTeam().get(this.getCurrentCharacterIndex()));
|
|
event.call();
|
|
} else {
|
|
// Set index and spawn replacement member
|
|
this.setCurrentCharacterIndex(replaceIndex);
|
|
this.getPlayer().getScene().addEntity(replacement);
|
|
}
|
|
}
|
|
|
|
// Response packet
|
|
this.getPlayer().sendPacket(new PacketAvatarDieAnimationEndRsp(deadAvatar.getId(), 0));
|
|
}
|
|
|
|
public boolean reviveAvatar(Avatar avatar) {
|
|
for (EntityAvatar entity : this.getActiveTeam()) {
|
|
if (entity.getAvatar() == avatar) {
|
|
if (entity.isAlive()) {
|
|
return false;
|
|
}
|
|
|
|
entity.setFightProperty(FightProperty.FIGHT_PROP_CUR_HP, 1f);
|
|
// Satiation is reset when reviving an avatar
|
|
player.getSatiationManager().removeSatiationDirectly(entity.getAvatar(), 15000);
|
|
this.getPlayer()
|
|
.sendPacket(
|
|
new PacketAvatarFightPropUpdateNotify(
|
|
entity.getAvatar(), FightProperty.FIGHT_PROP_CUR_HP));
|
|
this.getPlayer().sendPacket(new PacketAvatarLifeStateChangeNotify(entity.getAvatar()));
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public boolean healAvatar(Avatar avatar, int healRate, int healAmount) {
|
|
for (EntityAvatar entity : this.getActiveTeam()) {
|
|
if (entity.getAvatar() == avatar) {
|
|
if (!entity.isAlive()) {
|
|
return false;
|
|
}
|
|
|
|
entity.setFightProperty(
|
|
FightProperty.FIGHT_PROP_CUR_HP,
|
|
(float)
|
|
Math.min(
|
|
(entity.getFightProperty(FightProperty.FIGHT_PROP_CUR_HP)
|
|
+ entity.getFightProperty(FightProperty.FIGHT_PROP_MAX_HP)
|
|
* (float) healRate
|
|
/ 100.0
|
|
+ (float) healAmount / 100.0),
|
|
entity.getFightProperty(FightProperty.FIGHT_PROP_MAX_HP)));
|
|
this.getPlayer()
|
|
.sendPacket(
|
|
new PacketAvatarFightPropUpdateNotify(
|
|
entity.getAvatar(), FightProperty.FIGHT_PROP_CUR_HP));
|
|
this.getPlayer().sendPacket(new PacketAvatarLifeStateChangeNotify(entity.getAvatar()));
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public void respawnTeam() {
|
|
// Make sure all team members are dead
|
|
// Drowning needs revive when there may be other team members still alive.
|
|
// for (EntityAvatar entity : getActiveTeam()) {
|
|
// if (entity.isAlive()) {
|
|
// return;
|
|
// }
|
|
// }
|
|
player
|
|
.getStaminaManager()
|
|
.stopSustainedStaminaHandler(); // prevent drowning immediately after respawn
|
|
|
|
// Revive all team members
|
|
for (EntityAvatar entity : this.getActiveTeam()) {
|
|
entity.setFightProperty(
|
|
FightProperty.FIGHT_PROP_CUR_HP,
|
|
entity.getFightProperty(FightProperty.FIGHT_PROP_MAX_HP) * .4f);
|
|
player.getSatiationManager().removeSatiationDirectly(entity.getAvatar(), 15000);
|
|
this.getPlayer()
|
|
.sendPacket(
|
|
new PacketAvatarFightPropUpdateNotify(
|
|
entity.getAvatar(), FightProperty.FIGHT_PROP_CUR_HP));
|
|
this.getPlayer().sendPacket(new PacketAvatarLifeStateChangeNotify(entity.getAvatar()));
|
|
}
|
|
|
|
// Teleport player and set player position
|
|
try {
|
|
this.getPlayer()
|
|
.sendPacket(
|
|
new PacketPlayerEnterSceneNotify(
|
|
this.getPlayer(),
|
|
EnterType.ENTER_TYPE_SELF,
|
|
EnterReason.Revival,
|
|
player.getSceneId(),
|
|
getRespawnPosition()));
|
|
player.getPosition().set(getRespawnPosition());
|
|
} catch (Exception e) {
|
|
this.getPlayer()
|
|
.sendPacket(
|
|
new PacketPlayerEnterSceneNotify(
|
|
this.getPlayer(),
|
|
EnterType.ENTER_TYPE_SELF,
|
|
EnterReason.Revival,
|
|
3,
|
|
GameConstants.START_POSITION));
|
|
player
|
|
.getPosition()
|
|
.set(GameConstants.START_POSITION); // If something goes wrong, the resurrection is here
|
|
}
|
|
|
|
// Packets
|
|
this.getPlayer().sendPacket(new BasePacket(PacketOpcodes.WorldPlayerReviveRsp));
|
|
}
|
|
|
|
public Position getRespawnPosition() {
|
|
var deathPos = this.getPlayer().getPosition();
|
|
int sceneId = this.getPlayer().getSceneId();
|
|
|
|
// Get the closest trans point to where the player died.
|
|
var respawnPoint =
|
|
this.getPlayer().getUnlockedScenePoints(sceneId).stream()
|
|
.map(pointId -> GameData.getScenePointEntryById(sceneId, pointId))
|
|
.filter(point -> point.getPointData().getType().equals("SceneTransPoint"))
|
|
.min(
|
|
(Comparator.comparingDouble(
|
|
pos -> Utils.getDist(pos.getPointData().getTranPos(), deathPos))));
|
|
|
|
return respawnPoint.get().getPointData().getTranPos();
|
|
}
|
|
|
|
public void saveAvatars() {
|
|
// Save all avatars from active team
|
|
for (EntityAvatar entity : this.getActiveTeam()) {
|
|
entity.getAvatar().save();
|
|
}
|
|
}
|
|
|
|
public void onPlayerLogin() { // Hack for now to fix resonances on login
|
|
this.updateTeamResonances();
|
|
}
|
|
|
|
public synchronized void addNewCustomTeam() {
|
|
// Sanity check - max number of teams.
|
|
if (this.teams.size() == GameConstants.MAX_TEAMS) {
|
|
player.sendPacket(new PacketAddBackupAvatarTeamRsp(Retcode.RET_FAIL));
|
|
return;
|
|
}
|
|
|
|
// The id of the new custom team is the lowest id in [5,MAX_TEAMS] that is not yet taken.
|
|
int id = -1;
|
|
for (int i = 5; i <= GameConstants.MAX_TEAMS; i++) {
|
|
if (!this.teams.containsKey(i)) {
|
|
id = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Create the new team.
|
|
this.teams.put(id, new TeamInfo());
|
|
|
|
// Send packets.
|
|
player.sendPacket(new PacketAvatarTeamAllDataNotify(player));
|
|
player.sendPacket(new PacketAddBackupAvatarTeamRsp());
|
|
}
|
|
|
|
public synchronized void removeCustomTeam(int id) {
|
|
// Check if the target id exists.
|
|
if (!this.teams.containsKey(id)) {
|
|
player.sendPacket(new PacketDelBackupAvatarTeamRsp(Retcode.RET_FAIL, id));
|
|
}
|
|
|
|
// Remove team.
|
|
this.teams.remove(id);
|
|
|
|
// Send packets.
|
|
player.sendPacket(new PacketAvatarTeamAllDataNotify(player));
|
|
player.sendPacket(new PacketDelBackupAvatarTeamRsp(id));
|
|
}
|
|
|
|
/**
|
|
* Applies abilities for the currently selected team. These abilities are sourced from the scene.
|
|
*
|
|
* @param scene The scene with the abilities to apply.
|
|
*/
|
|
public void applyAbilities(Scene scene) {
|
|
try {
|
|
var levelEntityConfig = scene.getSceneData().getLevelEntityConfig();
|
|
var config = GameData.getConfigLevelEntityDataMap().get(levelEntityConfig);
|
|
if (config == null) return;
|
|
|
|
var avatars = this.getPlayer().getAvatars();
|
|
var avatarIds = scene.getSceneData().getSpecifiedAvatarList();
|
|
var specifiedAvatarList = this.getActiveTeam();
|
|
|
|
if (avatarIds != null && avatarIds.size() > 0) {
|
|
// certain scene could limit specific avatars' entry
|
|
specifiedAvatarList.clear();
|
|
for (int id : avatarIds) {
|
|
var avatar = avatars.getAvatarById(id);
|
|
if (avatar == null) continue;
|
|
|
|
specifiedAvatarList.add(new EntityAvatar(scene, avatar));
|
|
}
|
|
}
|
|
|
|
for (var entityAvatar : specifiedAvatarList) {
|
|
var avatarData = entityAvatar.getAvatar().getAvatarData();
|
|
if (avatarData == null) {
|
|
continue;
|
|
}
|
|
|
|
avatarData.buildEmbryo(); // Create avatar abilities.
|
|
if (config.getAvatarAbilities() == null) {
|
|
continue; // continue and not break because has to rebuild ability for the next avatar if
|
|
// any
|
|
}
|
|
|
|
for (ConfigAbilityData abilities : config.getAvatarAbilities()) {
|
|
avatarData.getAbilities().add(Utils.abilityHash(abilities.getAbilityName()));
|
|
}
|
|
}
|
|
} catch (Exception e) {
|
|
Grasscutter.getLogger()
|
|
.error(
|
|
"Error applying level entity config for scene {}", scene.getSceneData().getId(), e);
|
|
}
|
|
}
|
|
|
|
public List<Integer> getTrialAvatarParam(int trialAvatarId) {
|
|
if (GameData.getTrialAvatarCustomData()
|
|
.isEmpty()) { // use default data if custom data not available
|
|
if (GameData.getTrialAvatarDataMap().get(trialAvatarId) == null) return List.of();
|
|
|
|
return GameData.getTrialAvatarDataMap().get(trialAvatarId).getTrialAvatarParamList();
|
|
}
|
|
// use custom data
|
|
if (GameData.getTrialAvatarCustomData().get(trialAvatarId) == null) return List.of();
|
|
|
|
val trialCustomParams =
|
|
GameData.getTrialAvatarCustomData().get(trialAvatarId).getTrialAvatarParamList();
|
|
return trialCustomParams.isEmpty()
|
|
? List.of()
|
|
: Stream.of(trialCustomParams.get(0).split(";")).map(Integer::parseInt).toList();
|
|
}
|
|
|
|
/**
|
|
* Adds a trial avatar to the player's team.
|
|
*
|
|
* @param avatarId The ID of the avatar.
|
|
* @param questMainId The quest ID associated with the quest.
|
|
* @param reason The reason for granting the avatar.
|
|
* @return True if the avatar was added, false otherwise.
|
|
*/
|
|
public boolean addTrialAvatar(int avatarId, int questMainId, GrantReason reason) {
|
|
List<Integer> trialAvatarBasicParam = getTrialAvatarParam(avatarId);
|
|
if (trialAvatarBasicParam.isEmpty()) return false;
|
|
|
|
var avatar = new Avatar(trialAvatarBasicParam.get(0));
|
|
if (avatar.getAvatarData() == null || !this.getPlayer().hasSentLoginPackets()) return false;
|
|
|
|
avatar.setOwner(this.getPlayer());
|
|
// Add trial weapons and relics.
|
|
avatar.setTrialAvatarInfo(trialAvatarBasicParam.get(1), avatarId, reason, questMainId);
|
|
avatar.equipTrialItems();
|
|
// Re-calculate stats
|
|
avatar.recalcStats();
|
|
|
|
// Packet, mimic official server behaviour, add to player's bag but not saving to database.
|
|
this.getPlayer().sendPacket(new PacketAvatarAddNotify(avatar, false));
|
|
// Add to avatar to the temporary trial team.
|
|
this.addAvatarToTrialTeam(avatar);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Adds a trial avatar to the player's team.
|
|
*
|
|
* @param avatarId The ID of the avatar.
|
|
* @param questMainId The quest ID associated with the quest.
|
|
*/
|
|
public void addTrialAvatar(int avatarId, int questMainId) {
|
|
this.addTrialAvatars(List.of(avatarId), questMainId, true);
|
|
|
|
// Packet, mimic official server behaviour, necessary to stop player from modifying team.
|
|
this.getPlayer().sendPacket(new PacketAvatarTeamUpdateNotify(this.getPlayer()));
|
|
}
|
|
|
|
/**
|
|
* Adds a collection of trial avatars to the player's team.
|
|
*
|
|
* @param avatarIds List of trial avatar IDs.
|
|
*/
|
|
public void addTrialAvatars(List<Integer> avatarIds) {
|
|
this.addTrialAvatars(avatarIds, 0, false);
|
|
}
|
|
|
|
/**
|
|
* Adds a collection of trial avatars to the player's team.
|
|
*
|
|
* @param avatarIds List of trial avatar IDs.
|
|
* @param save Whether to retain the currently equipped avatars.
|
|
*/
|
|
public void addTrialAvatars(List<Integer> avatarIds, boolean save) {
|
|
this.addTrialAvatars(avatarIds, 0, save);
|
|
}
|
|
|
|
/**
|
|
* Adds a list of trial avatars to the player's team.
|
|
*
|
|
* @param trialAvatarIds List of trial avatar IDs.
|
|
* @param questId The ID of the quest this trial team is associated with.
|
|
* @param save Whether to retain the currently equipped avatars.
|
|
*/
|
|
public void addTrialAvatars(List<Integer> trialAvatarIds, int questId, boolean save) {
|
|
this.setupTrialAvatars(save); // Perform initial setup.
|
|
|
|
// Add the avatars to the team.
|
|
trialAvatarIds.forEach(
|
|
trialAvatarId -> {
|
|
var result =
|
|
this.addTrialAvatar(
|
|
trialAvatarId,
|
|
questId,
|
|
questId != 0
|
|
? GrantReason.GRANT_REASON_BY_QUEST
|
|
: GrantReason.GRANT_REASON_BY_TRIAL_AVATAR_ACTIVITY);
|
|
|
|
if (!result) throw new RuntimeException("Unable to add trial avatar to team.");
|
|
});
|
|
|
|
// Update the team.
|
|
this.trialAvatarTeamPostUpdate(questId != 0 ? this.getActiveTeam().size() - 1 : 0);
|
|
}
|
|
|
|
/** Removes all trial avatars from the player's team. */
|
|
public void removeTrialAvatar() {
|
|
this.removeTrialAvatar(
|
|
this.getActiveTeam().stream()
|
|
.map(EntityAvatar::getAvatar)
|
|
.map(Avatar::getTrialAvatarId)
|
|
.toList());
|
|
}
|
|
|
|
/**
|
|
* Removes a trial avatar from the player's team. Additionally, unlocks the ability to change the
|
|
* team configuration.
|
|
*
|
|
* @param trialAvatarId The ID of the avatar.
|
|
*/
|
|
public void removeTrialAvatar(int trialAvatarId) {
|
|
this.removeTrialAvatar(List.of(trialAvatarId));
|
|
}
|
|
|
|
/**
|
|
* Removes a collection of trial avatars from the player's team.
|
|
*
|
|
* @param trialAvatarIds List of trial avatar IDs.
|
|
*/
|
|
public void removeTrialAvatar(List<Integer> trialAvatarIds) {
|
|
// Check if the player is using a trial team.
|
|
if (!this.isUsingTrialTeam())
|
|
throw new IllegalStateException("Player is not using trial team.");
|
|
|
|
this.getPlayer()
|
|
.sendPacket(
|
|
new PacketAvatarDelNotify(
|
|
trialAvatarIds.stream().map(this::getTrialAvatarGuid).toList()));
|
|
this.removeTrialAvatarTeam(trialAvatarIds);
|
|
|
|
// Update the team.
|
|
if (trialAvatarIds.size() == 1) this.getPlayer().sendPacket(new PacketAvatarTeamUpdateNotify());
|
|
}
|
|
}
|