mirror of
https://github.com/Grasscutters/Grasscutter.git
synced 2025-12-16 08:56:04 +01:00
1325 lines
52 KiB
Java
1325 lines
52 KiB
Java
package emu.grasscutter.game.avatar;
|
|
|
|
import dev.morphia.annotations.*;
|
|
import emu.grasscutter.GameConstants;
|
|
import emu.grasscutter.data.GameData;
|
|
import emu.grasscutter.data.binout.OpenConfigEntry;
|
|
import emu.grasscutter.data.binout.OpenConfigEntry.SkillPointModifier;
|
|
import emu.grasscutter.data.common.FightPropData;
|
|
import emu.grasscutter.data.excels.*;
|
|
import emu.grasscutter.data.excels.ItemData.WeaponProperty;
|
|
import emu.grasscutter.data.excels.avatar.*;
|
|
import emu.grasscutter.data.excels.avatar.AvatarSkillDepotData.InherentProudSkillOpens;
|
|
import emu.grasscutter.data.excels.reliquary.*;
|
|
import emu.grasscutter.data.excels.trial.TrialAvatarTemplateData;
|
|
import emu.grasscutter.data.excels.weapon.*;
|
|
import emu.grasscutter.database.DatabaseHelper;
|
|
import emu.grasscutter.game.entity.*;
|
|
import emu.grasscutter.game.inventory.*;
|
|
import emu.grasscutter.game.player.Player;
|
|
import emu.grasscutter.game.props.*;
|
|
import emu.grasscutter.net.proto.AvatarFetterInfoOuterClass.AvatarFetterInfo;
|
|
import emu.grasscutter.net.proto.AvatarInfoOuterClass.AvatarInfo;
|
|
import emu.grasscutter.net.proto.AvatarSkillInfoOuterClass.AvatarSkillInfo;
|
|
import emu.grasscutter.net.proto.FetterDataOuterClass.FetterData;
|
|
import emu.grasscutter.net.proto.ShowAvatarInfoOuterClass;
|
|
import emu.grasscutter.net.proto.ShowAvatarInfoOuterClass.ShowAvatarInfo;
|
|
import emu.grasscutter.net.proto.ShowEquipOuterClass.ShowEquip;
|
|
import emu.grasscutter.net.proto.TrialAvatarGrantRecordOuterClass.TrialAvatarGrantRecord;
|
|
import emu.grasscutter.net.proto.TrialAvatarInfoOuterClass.TrialAvatarInfo;
|
|
import emu.grasscutter.server.packet.send.*;
|
|
import emu.grasscutter.utils.helpers.ProtoHelper;
|
|
import it.unimi.dsi.fastutil.ints.*;
|
|
import lombok.*;
|
|
import org.bson.types.ObjectId;
|
|
|
|
import javax.annotation.*;
|
|
import java.util.*;
|
|
import java.util.stream.Stream;
|
|
|
|
import static emu.grasscutter.config.Configuration.GAME_OPTIONS;
|
|
|
|
@Entity(value = "avatars", useDiscriminator = false)
|
|
public class Avatar {
|
|
@Transient @Getter private final Int2ObjectMap<GameItem> equips;
|
|
@Transient @Getter private final Int2FloatOpenHashMap fightProperties;
|
|
@Transient @Getter private final Int2FloatOpenHashMap fightPropOverrides;
|
|
@Id private ObjectId id;
|
|
@Indexed @Getter private int ownerId; // Id of player that this avatar belongs to
|
|
@Transient private Player owner;
|
|
@Transient @Getter private AvatarData avatarData;
|
|
@Nullable @Transient @Getter private AvatarSkillDepotData skillDepot;
|
|
@Transient @Getter private long guid; // Player unique id
|
|
@Getter private int avatarId; // Id of avatar
|
|
@Getter @Setter private int level = 1;
|
|
@Getter @Setter private int exp;
|
|
@Getter @Setter private int promoteLevel;
|
|
@Getter @Setter private int satiation; // Fullness
|
|
@Getter @Setter private int satiationPenalty; // When eating too much
|
|
@Getter @Setter private float currentHp;
|
|
private float currentEnergy;
|
|
@Transient @Getter private Set<String> extraAbilityEmbryos;
|
|
|
|
private List<Integer> fetters;
|
|
|
|
private Map<Integer, Integer> skillLevelMap = new Int2IntArrayMap(7); // Talent levels
|
|
|
|
@Transient @Getter
|
|
private Map<Integer, Integer> skillExtraChargeMap = new Int2IntArrayMap(2); // Charges
|
|
|
|
@Transient
|
|
private Map<Integer, Integer> proudSkillBonusMap =
|
|
new Int2IntArrayMap(2); // Talent bonus levels (from const)
|
|
|
|
@Getter private int skillDepotId;
|
|
private Set<Integer> talentIdList; // Constellation id list
|
|
@Getter private Set<Integer> proudSkillList; // Character passives
|
|
|
|
@Getter @Setter private int flyCloak;
|
|
@Getter @Setter private int costume;
|
|
@Getter private int bornTime;
|
|
|
|
@Getter @Setter private int fetterLevel = 1;
|
|
@Getter @Setter private int fetterExp;
|
|
|
|
@Getter @Setter private int nameCardRewardId;
|
|
@Getter @Setter private int nameCardId;
|
|
|
|
// trial avatar property
|
|
@Getter @Setter private int trialAvatarId = 0;
|
|
// cannot store to db if grant reason is not integer
|
|
@Getter @Setter
|
|
private int grantReason = TrialAvatarGrantRecord.GrantReason.GRANT_REASON_INVALID.getNumber();
|
|
|
|
@Getter @Setter private int fromParentQuestId = 0;
|
|
// so far no outer class or prop value has information of this, but from packet:
|
|
// 1 = normal, 2 = trial avatar
|
|
@Transient @Getter @Setter private int avatarType = Type.NORMAL.getNumber();
|
|
|
|
@Deprecated // Do not use. Morhpia only!
|
|
public Avatar() {
|
|
this.equips = new Int2ObjectOpenHashMap<>();
|
|
this.fightProperties = new Int2FloatOpenHashMap();
|
|
this.fightPropOverrides = new Int2FloatOpenHashMap();
|
|
this.extraAbilityEmbryos = new HashSet<>();
|
|
this.fetters = new ArrayList<>(); // TODO Move to avatar
|
|
}
|
|
|
|
// On creation
|
|
public Avatar(int avatarId) {
|
|
this(GameData.getAvatarDataMap().get(avatarId));
|
|
}
|
|
|
|
public Avatar(AvatarData data) {
|
|
this();
|
|
|
|
this.avatarId = data.getId();
|
|
this.nameCardRewardId = data.getNameCardRewardId();
|
|
this.nameCardId = data.getNameCardId();
|
|
this.avatarData = data;
|
|
this.bornTime = (int) (System.currentTimeMillis() / 1000);
|
|
this.flyCloak = 140001;
|
|
|
|
this.talentIdList = new HashSet<>();
|
|
this.proudSkillList = new HashSet<>();
|
|
|
|
// Combat properties
|
|
Stream.of(FightProperty.values())
|
|
.map(FightProperty::getId)
|
|
.filter(id -> (id > 0) && (id < 3000))
|
|
.forEach(id -> this.setFightProperty(id, 0f));
|
|
|
|
this.setSkillDepotData(
|
|
switch (this.getAvatarId()) {
|
|
case GameConstants.MAIN_CHARACTER_MALE -> GameData.getAvatarSkillDepotDataMap().get(501);
|
|
case GameConstants.MAIN_CHARACTER_FEMALE -> GameData.getAvatarSkillDepotDataMap()
|
|
.get(701);
|
|
default -> data.getSkillDepot();
|
|
});
|
|
|
|
// Set stats
|
|
this.recalcStats();
|
|
this.currentHp = getFightProperty(FightProperty.FIGHT_PROP_MAX_HP);
|
|
setFightProperty(FightProperty.FIGHT_PROP_CUR_HP, this.currentHp);
|
|
this.currentEnergy = 0f;
|
|
// Load handler
|
|
this.onLoad();
|
|
}
|
|
|
|
public static int getMinPromoteLevel(int level) {
|
|
if (level > 80) {
|
|
return 6;
|
|
} else if (level > 70) {
|
|
return 5;
|
|
} else if (level > 60) {
|
|
return 4;
|
|
} else if (level > 50) {
|
|
return 3;
|
|
} else if (level > 40) {
|
|
return 2;
|
|
} else if (level > 20) {
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @return True if the avatar is a main character.
|
|
*/
|
|
public boolean isMainCharacter() {
|
|
return List.of(GameConstants.MAIN_CHARACTER_MALE, GameConstants.MAIN_CHARACTER_FEMALE)
|
|
.contains(this.getAvatarId());
|
|
}
|
|
|
|
public Player getPlayer() {
|
|
return this.owner;
|
|
}
|
|
|
|
public ObjectId getObjectId() {
|
|
return this.id;
|
|
}
|
|
|
|
protected void setAvatarData(AvatarData data) {
|
|
if (this.avatarData != null) return;
|
|
this.avatarData = data; // Used while loading this from the database
|
|
}
|
|
|
|
public void setOwner(Player player) {
|
|
this.owner = player;
|
|
this.ownerId = player.getUid();
|
|
this.guid = player.getNextGameGuid();
|
|
|
|
if (this.getAvatarId() == player.getMainCharacterId()) {
|
|
// Apply skill depot based on player resonance.
|
|
this.changeElement(player.getMainCharacterElement(), false);
|
|
}
|
|
}
|
|
|
|
public boolean addSatiation(int value) {
|
|
if (this.satiation >= 10000) return false;
|
|
this.satiation += value;
|
|
return true;
|
|
}
|
|
|
|
public float reduceSatiation(int value) {
|
|
if (this.satiation == 0) return 0;
|
|
this.satiation -= value;
|
|
if (this.satiation < 0) {
|
|
this.satiation = 0;
|
|
}
|
|
return this.satiation;
|
|
}
|
|
|
|
public float reduceSatiationPenalty(int value) {
|
|
if (this.satiationPenalty == 0) return 0;
|
|
this.satiationPenalty -= value;
|
|
if (this.satiationPenalty < 0) {
|
|
this.satiationPenalty = 0;
|
|
}
|
|
return this.satiationPenalty;
|
|
}
|
|
|
|
public GameItem getEquipBySlot(EquipType slot) {
|
|
return this.getEquips().get(slot.getValue());
|
|
}
|
|
|
|
private GameItem getEquipBySlot(int slotId) {
|
|
return this.getEquips().get(slotId);
|
|
}
|
|
|
|
/**
|
|
* @return The avatar's equipped weapon.
|
|
*/
|
|
@Nullable public GameItem getWeapon() {
|
|
return this.getEquipBySlot(EquipType.EQUIP_WEAPON);
|
|
}
|
|
|
|
/**
|
|
* @return The avatar's equipped weapon.
|
|
* @throws NullPointerException If the avatar does not have a weapon.
|
|
*/
|
|
public GameItem getWeaponNotNull() {
|
|
return Objects.requireNonNull(this.getWeapon(), "Avatar does not have a weapon.");
|
|
}
|
|
|
|
protected void setSkillDepot(AvatarSkillDepotData skillDepot) {
|
|
if (this.skillDepot != null) return;
|
|
this.skillDepot = skillDepot; // Used while loading this from the database
|
|
}
|
|
|
|
/**
|
|
* Changes this avatar's skill depot. Does not notify the player of the change.
|
|
*
|
|
* @param skillDepot The new skill depot.
|
|
*/
|
|
public void setSkillDepotData(AvatarSkillDepotData skillDepot) {
|
|
this.setSkillDepotData(skillDepot, false);
|
|
}
|
|
|
|
/**
|
|
* Changes this avatar's skill depot.
|
|
*
|
|
* @param skillDepot The new skill depot.
|
|
* @param notify Whether to notify the player of the change.
|
|
*/
|
|
public void setSkillDepotData(AvatarSkillDepotData skillDepot, boolean notify) {
|
|
// Set id and depot
|
|
this.skillDepotId = skillDepot.getId();
|
|
this.skillDepot = skillDepot;
|
|
// Add any missing skills
|
|
this.skillDepot
|
|
.getSkillsAndEnergySkill()
|
|
.forEach(skillId -> this.skillLevelMap.putIfAbsent(skillId, 1));
|
|
// Add proud skills
|
|
this.proudSkillList.clear();
|
|
skillDepot.getInherentProudSkillOpens().stream()
|
|
.filter(openData -> openData.getProudSkillGroupId() > 0)
|
|
.filter(openData -> openData.getNeedAvatarPromoteLevel() <= this.getPromoteLevel())
|
|
.mapToInt(openData -> (openData.getProudSkillGroupId() * 100) + 1)
|
|
.filter(proudSkillId -> GameData.getProudSkillDataMap().containsKey(proudSkillId))
|
|
.forEach(proudSkillId -> this.proudSkillList.add(proudSkillId));
|
|
this.recalcStats();
|
|
|
|
if (notify) {
|
|
owner.sendPacket(new PacketAvatarSkillDepotChangeNotify(this));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Changes the avatar's element to the target element. Only applies if the avatar has the element
|
|
* in its 'candSkillDepot's.
|
|
*
|
|
* @param newElement The new element to change to.
|
|
* @return True if the element was changed, false otherwise.
|
|
*/
|
|
public boolean changeElement(@Nonnull ElementType newElement) {
|
|
return this.changeElement(newElement, true);
|
|
}
|
|
|
|
/**
|
|
* Changes the avatar's element to the target element. Only applies if the avatar has the element
|
|
* in its 'candSkillDepot's.
|
|
*
|
|
* @param elementTypeToChange The new element to change to.
|
|
* @param notify Whether to notify the player of the change.
|
|
* @return True if the element was changed, false otherwise.
|
|
*/
|
|
public boolean changeElement(@Nonnull ElementType elementTypeToChange, boolean notify) {
|
|
var candSkillDepotIdsList = this.getAvatarData().getCandSkillDepotIds();
|
|
var candSkillDepotIndex = elementTypeToChange.getDepotIndex();
|
|
|
|
// if no candidate skill to change or index out of bound
|
|
if (candSkillDepotIdsList == null || candSkillDepotIndex >= candSkillDepotIdsList.size()) {
|
|
return false;
|
|
}
|
|
|
|
var candSkillDepotId = candSkillDepotIdsList.get(candSkillDepotIndex);
|
|
|
|
// Sanity checks for skill depots
|
|
val skillDepot = GameData.getAvatarSkillDepotDataMap().get((int) candSkillDepotId);
|
|
if (skillDepot == null || skillDepot.getId() == skillDepotId) {
|
|
return false;
|
|
}
|
|
|
|
// Set skill depot
|
|
this.setSkillDepotData(skillDepot, notify);
|
|
this.recalcStats(true);
|
|
// Set element.
|
|
this.getPlayer().setMainCharacterElement(elementTypeToChange);
|
|
return true;
|
|
}
|
|
|
|
public List<Integer> getFetterList() {
|
|
return fetters;
|
|
}
|
|
|
|
public void setFetterList(List<Integer> fetterList) {
|
|
this.fetters = fetterList;
|
|
}
|
|
|
|
public void setCurrentEnergy() {
|
|
if (GAME_OPTIONS.energyUsage) {
|
|
this.setCurrentEnergy(this.currentEnergy);
|
|
}
|
|
}
|
|
|
|
public void setCurrentEnergy(float currentEnergy) {
|
|
var depot = this.skillDepot;
|
|
if (depot != null && depot.getEnergySkillData() != null) {
|
|
ElementType element = depot.getElementType();
|
|
var maxEnergy = depot.getEnergySkillData().getCostElemVal();
|
|
this.setFightProperty(element.getMaxEnergyProp(), maxEnergy);
|
|
this.setFightProperty(
|
|
element.getCurEnergyProp(), GAME_OPTIONS.energyUsage ? currentEnergy : maxEnergy);
|
|
}
|
|
}
|
|
|
|
public void setCurrentEnergy(FightProperty curEnergyProp, float currentEnergy) {
|
|
if (GAME_OPTIONS.energyUsage) {
|
|
this.setFightProperty(curEnergyProp, currentEnergy);
|
|
this.currentEnergy = currentEnergy;
|
|
this.save();
|
|
}
|
|
}
|
|
|
|
public void setFightProperty(FightProperty prop, float value) {
|
|
this.getFightProperties().put(prop.getId(), value);
|
|
}
|
|
|
|
private void setFightProperty(int id, float value) {
|
|
this.getFightProperties().put(id, value);
|
|
}
|
|
|
|
public void addFightProperty(FightProperty prop, float value) {
|
|
this.getFightProperties().put(prop.getId(), getFightProperty(prop) + value);
|
|
}
|
|
|
|
public float getFightProperty(FightProperty prop) {
|
|
return getFightProperties().getOrDefault(prop.getId(), 0f);
|
|
}
|
|
|
|
public Map<Integer, Integer>
|
|
getSkillLevelMap() { // Returns a copy of the skill levels for the current skillDepot.
|
|
var map = new Int2IntOpenHashMap();
|
|
this.skillDepot
|
|
.getSkillsAndEnergySkill()
|
|
.forEach(
|
|
skillId -> map.put(skillId, this.skillLevelMap.putIfAbsent(skillId, 1).intValue()));
|
|
return map;
|
|
}
|
|
|
|
// Returns a copy of the skill bonus levels for the current skillDepot, capped to avoid invalid
|
|
// levels.
|
|
public Map<Integer, Integer> getProudSkillBonusMap() {
|
|
var map = new Int2IntArrayMap();
|
|
this.skillDepot
|
|
.getSkillsAndEnergySkill()
|
|
.forEach(
|
|
skillId -> {
|
|
val skillData = GameData.getAvatarSkillDataMap().get(skillId);
|
|
if (skillData == null) return;
|
|
int proudSkillGroupId = skillData.getProudSkillGroupId();
|
|
int bonus = this.proudSkillBonusMap.getOrDefault(proudSkillGroupId, 0);
|
|
int maxLevel = GameData.getProudSkillGroupMaxLevel(proudSkillGroupId);
|
|
int curLevel = this.skillLevelMap.getOrDefault(skillId, 0);
|
|
if (maxLevel > 0) {
|
|
bonus = Math.min(bonus, maxLevel - curLevel);
|
|
}
|
|
map.put(proudSkillGroupId, bonus);
|
|
});
|
|
return map;
|
|
}
|
|
|
|
public IntSet getTalentIdList() { // Returns a copy of the unlocked constellations for the current
|
|
if (this.getSkillDepot() != null) {
|
|
// skillDepot.
|
|
var talents = new IntOpenHashSet(this.getSkillDepot().getTalents());
|
|
talents.removeIf(id -> !this.talentIdList.contains(id));
|
|
return talents;
|
|
} else return new IntOpenHashSet();
|
|
}
|
|
|
|
public int getCoreProudSkillLevel() {
|
|
if (this.getSkillDepot() != null) {
|
|
var lockedTalents = new IntOpenHashSet(this.getSkillDepot().getTalents());
|
|
lockedTalents.removeAll(this.getTalentIdList());
|
|
// One below the lowest locked talent, or 6 if there are no locked talents.
|
|
return lockedTalents.intStream().map(i -> i % 10).min().orElse(7) - 1;
|
|
} else return 0;
|
|
}
|
|
|
|
public boolean equipItem(GameItem item, boolean shouldRecalc) {
|
|
// Sanity check equip type
|
|
EquipType itemEquipType = item.getItemData().getEquipType();
|
|
if (itemEquipType == EquipType.EQUIP_NONE) {
|
|
return false;
|
|
}
|
|
|
|
// Check if other avatars have this item equipped
|
|
Avatar otherAvatar = getPlayer().getAvatars().getAvatarById(item.getEquipCharacter());
|
|
if (otherAvatar != null) {
|
|
// Unequip other avatar's item
|
|
if (otherAvatar.unequipItem(item.getItemData().getEquipType())) {
|
|
getPlayer()
|
|
.sendPacket(
|
|
new PacketAvatarEquipChangeNotify(otherAvatar, item.getItemData().getEquipType()));
|
|
}
|
|
// Swap with other avatar
|
|
if (getEquips().containsKey(itemEquipType.getValue())) {
|
|
GameItem toSwap = this.getEquipBySlot(itemEquipType);
|
|
otherAvatar.equipItem(toSwap, false);
|
|
}
|
|
// Recalc
|
|
otherAvatar.recalcStats();
|
|
} else if (getEquips().containsKey(itemEquipType.getValue())) {
|
|
// Unequip item in current slot if it exists
|
|
unequipItem(itemEquipType);
|
|
}
|
|
|
|
// Set equip
|
|
this.getEquips().put(itemEquipType.getValue(), item);
|
|
|
|
if (itemEquipType == EquipType.EQUIP_WEAPON && getPlayer().getWorld() != null) {
|
|
if (!(item.getWeaponEntity() != null
|
|
&& item.getWeaponEntity().getScene() == getPlayer().getScene())) {
|
|
item.setWeaponEntity(
|
|
new EntityWeapon(this.getPlayer().getScene(), item.getItemData().getGadgetId()));
|
|
this.getPlayer()
|
|
.getScene()
|
|
.getWeaponEntities()
|
|
.put(item.getWeaponEntity().getId(), item.getWeaponEntity());
|
|
}
|
|
// item.setWeaponEntityId(this.getPlayer().getWorld().getNextEntityId(EntityIdType.WEAPON));
|
|
}
|
|
|
|
item.setEquipCharacter(this.getAvatarId());
|
|
item.save();
|
|
|
|
if (this.getPlayer().hasSentLoginPackets()) {
|
|
this.getPlayer().sendPacket(new PacketAvatarEquipChangeNotify(this, item));
|
|
}
|
|
|
|
if (shouldRecalc) {
|
|
this.recalcStats();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public boolean unequipItem(EquipType slot) {
|
|
GameItem item = getEquips().remove(slot.getValue());
|
|
|
|
if (item != null) {
|
|
item.setEquipCharacter(0);
|
|
item.save();
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public void recalcStats() {
|
|
recalcStats(false);
|
|
}
|
|
|
|
public void recalcStats(boolean forceSendAbilityChange) {
|
|
// Setup
|
|
var data = this.getAvatarData();
|
|
var promoteData =
|
|
GameData.getAvatarPromoteData(data.getAvatarPromoteId(), this.getPromoteLevel());
|
|
var setMap = new Int2IntOpenHashMap();
|
|
|
|
// Extra ability embryos
|
|
Set<String> prevExtraAbilityEmbryos = this.getExtraAbilityEmbryos();
|
|
this.extraAbilityEmbryos = new HashSet<>();
|
|
|
|
// Fetters
|
|
this.setFetterList(data.getFetters());
|
|
this.setNameCardRewardId(data.getNameCardRewardId());
|
|
this.setNameCardId(data.getNameCardId());
|
|
|
|
// Get hp percent, set to 100% if none
|
|
float hpPercent =
|
|
this.getFightProperty(FightProperty.FIGHT_PROP_MAX_HP) <= 0
|
|
? 1f
|
|
: this.getFightProperty(FightProperty.FIGHT_PROP_CUR_HP)
|
|
/ this.getFightProperty(FightProperty.FIGHT_PROP_MAX_HP);
|
|
|
|
// Store current energy value for later
|
|
float currentEnergy =
|
|
(this.getSkillDepot() != null)
|
|
? this.getFightProperty(this.getSkillDepot().getElementType().getCurEnergyProp())
|
|
: 0f;
|
|
|
|
// Clear properties
|
|
this.getFightProperties().clear();
|
|
|
|
// Base stats
|
|
this.setFightProperty(FightProperty.FIGHT_PROP_BASE_HP, data.getBaseHp(this.getLevel()));
|
|
this.setFightProperty(
|
|
FightProperty.FIGHT_PROP_BASE_ATTACK, data.getBaseAttack(this.getLevel()));
|
|
this.setFightProperty(
|
|
FightProperty.FIGHT_PROP_BASE_DEFENSE, data.getBaseDefense(this.getLevel()));
|
|
this.setFightProperty(FightProperty.FIGHT_PROP_CRITICAL, data.getBaseCritical());
|
|
this.setFightProperty(FightProperty.FIGHT_PROP_CRITICAL_HURT, data.getBaseCriticalHurt());
|
|
this.setFightProperty(FightProperty.FIGHT_PROP_CHARGE_EFFICIENCY, 1f);
|
|
|
|
if (promoteData != null) {
|
|
for (FightPropData fightPropData : promoteData.getAddProps()) {
|
|
this.addFightProperty(fightPropData.getProp(), fightPropData.getValue());
|
|
}
|
|
}
|
|
|
|
// Set energy usage
|
|
setCurrentEnergy(currentEnergy);
|
|
|
|
// Artifacts
|
|
for (int slotId = 1; slotId <= 5; slotId++) {
|
|
// Get artifact
|
|
GameItem equip = this.getEquipBySlot(slotId);
|
|
if (equip == null) {
|
|
continue;
|
|
}
|
|
// Artifact main stat
|
|
ReliquaryMainPropData mainPropData =
|
|
GameData.getReliquaryMainPropDataMap().get(equip.getMainPropId());
|
|
if (mainPropData != null) {
|
|
ReliquaryLevelData levelData =
|
|
GameData.getRelicLevelData(equip.getItemData().getRankLevel(), equip.getLevel());
|
|
if (levelData != null) {
|
|
this.addFightProperty(
|
|
mainPropData.getFightProp(), levelData.getPropValue(mainPropData.getFightProp()));
|
|
}
|
|
}
|
|
// Artifact sub stats
|
|
for (int appendPropId : equip.getAppendPropIdList()) {
|
|
ReliquaryAffixData affixData = GameData.getReliquaryAffixDataMap().get(appendPropId);
|
|
if (affixData != null) {
|
|
this.addFightProperty(affixData.getFightProp(), affixData.getPropValue());
|
|
}
|
|
}
|
|
// Set bonus
|
|
if (equip.getItemData().getSetId() > 0) {
|
|
setMap.addTo(equip.getItemData().getSetId(), 1);
|
|
}
|
|
}
|
|
|
|
// Set stuff
|
|
setMap.forEach(
|
|
(setId, amount) -> {
|
|
ReliquarySetData setData = GameData.getReliquarySetDataMap().get((int) setId);
|
|
if (setData == null) return;
|
|
|
|
// Calculate how many items are from the set
|
|
// Add affix data from set bonus
|
|
val setNeedNum = setData.getSetNeedNum();
|
|
for (int setIndex = 0; setIndex < setNeedNum.length; setIndex++) {
|
|
if (amount < setNeedNum[setIndex]) break;
|
|
|
|
int affixId = (setData.getEquipAffixId() * 10) + setIndex;
|
|
EquipAffixData affix = GameData.getEquipAffixDataMap().get(affixId);
|
|
if (affix == null) {
|
|
continue;
|
|
}
|
|
|
|
// Add properties from this affix to our avatar
|
|
for (FightPropData prop : affix.getAddProps()) {
|
|
this.addFightProperty(prop.getProp(), prop.getValue());
|
|
}
|
|
|
|
// Add any skill strings from this affix
|
|
this.addToExtraAbilityEmbryos(affix.getOpenConfig(), true);
|
|
}
|
|
});
|
|
|
|
// Weapon
|
|
GameItem weapon = this.getWeapon();
|
|
if (weapon != null) {
|
|
// Add stats
|
|
WeaponCurveData curveData = GameData.getWeaponCurveDataMap().get(weapon.getLevel());
|
|
if (curveData != null) {
|
|
for (WeaponProperty weaponProperty : weapon.getItemData().getWeaponProperties()) {
|
|
this.addFightProperty(
|
|
weaponProperty.getPropType(),
|
|
weaponProperty.getInitValue() * curveData.getMultByProp(weaponProperty.getType()));
|
|
}
|
|
}
|
|
// Weapon promotion stats
|
|
WeaponPromoteData wepPromoteData =
|
|
GameData.getWeaponPromoteData(
|
|
weapon.getItemData().getWeaponPromoteId(), weapon.getPromoteLevel());
|
|
if (wepPromoteData != null) {
|
|
for (FightPropData prop : wepPromoteData.getAddProps()) {
|
|
if (prop.getValue() == 0f || prop.getProp() == null) {
|
|
continue;
|
|
}
|
|
this.addFightProperty(prop.getProp(), prop.getValue());
|
|
}
|
|
}
|
|
// Add weapon skill from affixes
|
|
if (weapon.getAffixes() != null && weapon.getAffixes().size() > 0) {
|
|
// Weapons usually dont have more than one affix but just in case...
|
|
for (int af : weapon.getAffixes()) {
|
|
if (af == 0) {
|
|
continue;
|
|
}
|
|
// Calculate affix id
|
|
int affixId = (af * 10) + weapon.getRefinement();
|
|
EquipAffixData affix = GameData.getEquipAffixDataMap().get(affixId);
|
|
if (affix == null) {
|
|
continue;
|
|
}
|
|
|
|
// Add properties from this affix to our avatar
|
|
for (FightPropData prop : affix.getAddProps()) {
|
|
this.addFightProperty(prop.getProp(), prop.getValue());
|
|
}
|
|
|
|
// Add any skill strings from this affix
|
|
this.addToExtraAbilityEmbryos(affix.getOpenConfig(), true);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Add proud skills and unlock them if needed
|
|
AvatarSkillDepotData skillDepot =
|
|
GameData.getAvatarSkillDepotDataMap().get(this.getSkillDepotId());
|
|
this.getProudSkillList().clear();
|
|
if (skillDepot != null) {
|
|
for (InherentProudSkillOpens openData : skillDepot.getInherentProudSkillOpens()) {
|
|
if (openData.getProudSkillGroupId() == 0) {
|
|
continue;
|
|
}
|
|
if (openData.getNeedAvatarPromoteLevel() <= this.getPromoteLevel()) {
|
|
int proudSkillId = (openData.getProudSkillGroupId() * 100) + 1;
|
|
if (GameData.getProudSkillDataMap().containsKey(proudSkillId)) {
|
|
this.getProudSkillList().add(proudSkillId);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Proud skills
|
|
for (int proudSkillId : this.getProudSkillList()) {
|
|
ProudSkillData proudSkillData = GameData.getProudSkillDataMap().get(proudSkillId);
|
|
if (proudSkillData == null) {
|
|
continue;
|
|
}
|
|
|
|
// Add properties from this proud skill to our avatar
|
|
for (FightPropData prop : proudSkillData.getAddProps()) {
|
|
this.addFightProperty(prop.getProp(), prop.getValue());
|
|
}
|
|
|
|
// Add any embryos from this proud skill
|
|
this.addToExtraAbilityEmbryos(proudSkillData.getOpenConfig());
|
|
}
|
|
|
|
// Constellations
|
|
this.getTalentIdList()
|
|
.intStream()
|
|
.mapToObj(GameData.getAvatarTalentDataMap()::get)
|
|
.filter(Objects::nonNull)
|
|
.map(AvatarTalentData::getOpenConfig)
|
|
.filter(Objects::nonNull)
|
|
.forEach(this::addToExtraAbilityEmbryos);
|
|
// Add any skill strings from this constellation
|
|
|
|
// Set % stats
|
|
FightProperty.forEachCompoundProperty(
|
|
c ->
|
|
this.setFightProperty(
|
|
c.getResult(),
|
|
this.getFightProperty(c.getFlat())
|
|
+ (this.getFightProperty(c.getBase())
|
|
* (1f + this.getFightProperty(c.getPercent())))));
|
|
|
|
// Reapply all overrides
|
|
this.fightProperties.putAll(this.fightPropOverrides);
|
|
|
|
// Set current hp
|
|
this.setFightProperty(
|
|
FightProperty.FIGHT_PROP_CUR_HP,
|
|
this.getFightProperty(FightProperty.FIGHT_PROP_MAX_HP) * hpPercent);
|
|
|
|
// Packet
|
|
if (getPlayer() != null && getPlayer().hasSentLoginPackets()) {
|
|
// Update stats for client
|
|
getPlayer().sendPacket(new PacketAvatarFightPropNotify(this));
|
|
// Update client abilities
|
|
EntityAvatar entity = this.getAsEntity();
|
|
if (entity != null
|
|
&& (!this.getExtraAbilityEmbryos().equals(prevExtraAbilityEmbryos)
|
|
|| forceSendAbilityChange)) {
|
|
getPlayer().sendPacket(new PacketAbilityChangeNotify(entity));
|
|
}
|
|
}
|
|
}
|
|
|
|
public void addToExtraAbilityEmbryos(String openConfig) {
|
|
this.addToExtraAbilityEmbryos(openConfig, false);
|
|
}
|
|
|
|
public void addToExtraAbilityEmbryos(String openConfig, boolean forceAdd) {
|
|
if (openConfig == null || openConfig.length() == 0) {
|
|
return;
|
|
}
|
|
|
|
OpenConfigEntry entry = GameData.getOpenConfigEntries().get(openConfig);
|
|
if (entry == null) {
|
|
if (forceAdd) {
|
|
// Add config string to ability skill list anyways
|
|
this.getExtraAbilityEmbryos().add(openConfig);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (entry.getAddAbilities() != null) {
|
|
for (String ability : entry.getAddAbilities()) {
|
|
this.getExtraAbilityEmbryos().add(ability);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void calcConstellation(OpenConfigEntry entry, boolean notifyClient) {
|
|
if (entry == null) return;
|
|
if (this.getPlayer() == null) notifyClient = false;
|
|
|
|
// Check if new constellation adds +3 to a skill level
|
|
if (this.calcConstellationExtraLevels(entry) && notifyClient) {
|
|
// Packet
|
|
this.getPlayer()
|
|
.sendPacket(new PacketProudSkillExtraLevelNotify(this, entry.getExtraTalentIndex()));
|
|
}
|
|
// Check if new constellation adds skill charges
|
|
if (this.calcConstellationExtraCharges(entry) && notifyClient) {
|
|
// Packet
|
|
Stream.of(entry.getSkillPointModifiers())
|
|
.mapToInt(SkillPointModifier::getSkillId)
|
|
.forEach(
|
|
skillId -> {
|
|
this.getPlayer()
|
|
.sendPacket(
|
|
new PacketAvatarSkillMaxChargeCountNotify(
|
|
this, skillId, this.getSkillExtraChargeMap().getOrDefault(skillId, 0)));
|
|
});
|
|
}
|
|
}
|
|
|
|
public void recalcConstellations() {
|
|
// Clear first
|
|
this.proudSkillBonusMap.clear();
|
|
this.skillExtraChargeMap.clear();
|
|
|
|
// Sanity checks
|
|
if (this.avatarData == null || this.skillDepot == null) {
|
|
return;
|
|
}
|
|
|
|
this.getTalentIdList()
|
|
.intStream()
|
|
.mapToObj(GameData.getAvatarTalentDataMap()::get)
|
|
.filter(Objects::nonNull)
|
|
.map(AvatarTalentData::getOpenConfig)
|
|
.filter(Objects::nonNull)
|
|
.filter(openConfig -> openConfig.length() > 0)
|
|
.map(GameData.getOpenConfigEntries()::get)
|
|
.filter(Objects::nonNull)
|
|
.forEach(e -> this.calcConstellation(e, false));
|
|
}
|
|
|
|
private boolean calcConstellationExtraCharges(OpenConfigEntry entry) {
|
|
var skillPointModifiers = entry.getSkillPointModifiers();
|
|
if (skillPointModifiers == null) return false;
|
|
|
|
for (var mod : skillPointModifiers) {
|
|
AvatarSkillData skillData = GameData.getAvatarSkillDataMap().get(mod.getSkillId());
|
|
|
|
if (skillData == null) continue;
|
|
|
|
int charges = skillData.getMaxChargeNum() + mod.getDelta();
|
|
|
|
this.getSkillExtraChargeMap().put(mod.getSkillId(), charges);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private boolean calcConstellationExtraLevels(OpenConfigEntry entry) {
|
|
int skillId =
|
|
switch (entry.getExtraTalentIndex()) {
|
|
case 9 -> this.skillDepot.getEnergySkill(); // Ult skill
|
|
case 2 -> (this.skillDepot.getSkills().size() >= 2)
|
|
? this.skillDepot.getSkills().get(1)
|
|
: 0; // E skill
|
|
default -> 0;
|
|
};
|
|
// Sanity check
|
|
if (skillId == 0) {
|
|
return false;
|
|
}
|
|
|
|
// Get proud skill group id
|
|
AvatarSkillData skillData = GameData.getAvatarSkillDataMap().get(skillId);
|
|
|
|
if (skillData == null) {
|
|
return false;
|
|
}
|
|
|
|
// Add to bonus list
|
|
this.addProudSkillLevelBonus(skillData.getProudSkillGroupId(), 3);
|
|
return true;
|
|
}
|
|
|
|
private int addProudSkillLevelBonus(int proudSkillGroupId, int bonus) {
|
|
return this.proudSkillBonusMap.compute(
|
|
proudSkillGroupId, (k, v) -> (v == null) ? bonus : v + bonus);
|
|
}
|
|
|
|
public boolean upgradeSkill(int skillId) {
|
|
AvatarSkillData skillData = GameData.getAvatarSkillDataMap().get(skillId);
|
|
if (skillData == null) return false;
|
|
|
|
// Get data for next skill level
|
|
int newLevel = this.skillLevelMap.getOrDefault(skillId, 0) + 1;
|
|
if (newLevel > 10) return false;
|
|
|
|
// Proud skill data
|
|
int proudSkillId = (skillData.getProudSkillGroupId() * 100) + newLevel;
|
|
ProudSkillData proudSkill = GameData.getProudSkillDataMap().get(proudSkillId);
|
|
if (proudSkill == null) return false;
|
|
|
|
// Make sure break level is correct
|
|
if (this.getPromoteLevel() < proudSkill.getBreakLevel()) return false;
|
|
|
|
// Pay materials and mora if possible
|
|
if (!this.getPlayer().getInventory().payItems(proudSkill.getTotalCostItems())) return false;
|
|
|
|
// Upgrade skill
|
|
this.setSkillLevel(skillId, newLevel);
|
|
return true;
|
|
}
|
|
|
|
public boolean setSkillLevel(int skillId, int level) {
|
|
if (level < 0 || level > 15) return false;
|
|
var validLevels = GameData.getAvatarSkillLevels(skillId);
|
|
if (validLevels != null && !validLevels.contains(level)) return false;
|
|
int oldLevel =
|
|
this.skillLevelMap.getOrDefault(
|
|
skillId, 0); // just taking the return value of put would have null concerns
|
|
this.skillLevelMap.put(skillId, level);
|
|
this.save();
|
|
|
|
// Packet
|
|
val player = this.getPlayer();
|
|
if (player != null) {
|
|
player.sendPacket(new PacketAvatarSkillChangeNotify(this, skillId, oldLevel, level));
|
|
player.sendPacket(new PacketAvatarSkillUpgradeRsp(this, skillId, oldLevel, level));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public boolean unlockConstellation() {
|
|
return this.unlockConstellation(false);
|
|
}
|
|
|
|
public boolean unlockConstellation(boolean skipPayment) {
|
|
int currentTalentLevel = this.getCoreProudSkillLevel();
|
|
if (currentTalentLevel < 0) return false;
|
|
int talentId = this.skillDepot.getTalents().get(currentTalentLevel);
|
|
return this.unlockConstellation(talentId, skipPayment);
|
|
}
|
|
|
|
public boolean unlockConstellation(int talentId) {
|
|
return unlockConstellation(talentId, false);
|
|
}
|
|
|
|
public boolean unlockConstellation(int talentId, boolean skipPayment) {
|
|
// Get talent
|
|
AvatarTalentData talentData = GameData.getAvatarTalentDataMap().get(talentId);
|
|
if (talentData == null) return false;
|
|
var player = this.getPlayer();
|
|
|
|
// Pay constellation item if possible
|
|
if (!skipPayment
|
|
&& (player != null)
|
|
&& !player.getInventory().payItem(talentData.getMainCostItemId(), 1)) {
|
|
return false;
|
|
}
|
|
|
|
// Apply + recalc
|
|
this.talentIdList.add(talentData.getId());
|
|
|
|
// Packet
|
|
if (player != null) {
|
|
player.sendPacket(new PacketAvatarUnlockTalentNotify(this, talentId));
|
|
player.sendPacket(new PacketUnlockAvatarTalentRsp(this, talentId));
|
|
}
|
|
|
|
// Proud skill bonus map (Extra skills)
|
|
this.calcConstellation(GameData.getOpenConfigEntries().get(talentData.getOpenConfig()), true);
|
|
|
|
// Recalc + save avatar
|
|
this.recalcStats(true);
|
|
this.save();
|
|
return true;
|
|
}
|
|
|
|
public void forceConstellationLevel(int level) {
|
|
if (level > 6) return; // Sanity check
|
|
|
|
if (level < 0) { // Special case for resetConst to remove inactive depots too
|
|
this.talentIdList.clear();
|
|
this.recalcStats();
|
|
this.save();
|
|
return;
|
|
}
|
|
this.talentIdList.removeAll(
|
|
this.getTalentIdList()); // Only remove constellations from active depot
|
|
for (int i = 0; i < level; i++) this.unlockConstellation(true);
|
|
this.recalcStats();
|
|
this.save();
|
|
}
|
|
|
|
public boolean sendSkillExtraChargeMap() {
|
|
val map = this.getSkillExtraChargeMap();
|
|
if (map.isEmpty()) return false;
|
|
this.getPlayer()
|
|
.sendPacket(
|
|
new PacketAvatarSkillInfoNotify(
|
|
this.guid,
|
|
new Int2IntArrayMap(
|
|
map))); // TODO: Remove this allocation when updating interfaces to FastUtils
|
|
// later
|
|
return true;
|
|
}
|
|
|
|
public EntityAvatar getAsEntity() {
|
|
for (EntityAvatar entity : getPlayer().getTeamManager().getActiveTeam()) {
|
|
if (entity.getAvatar() == this) {
|
|
return entity;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public int getEntityId() {
|
|
EntityAvatar entity = getAsEntity();
|
|
return entity != null ? entity.getId() : 0;
|
|
}
|
|
|
|
public void save() {
|
|
DatabaseHelper.saveAvatar(this);
|
|
}
|
|
|
|
public AvatarInfo toProto() {
|
|
int fetterLevel = this.getFetterLevel();
|
|
AvatarFetterInfo.Builder avatarFetter = AvatarFetterInfo.newBuilder().setExpLevel(fetterLevel);
|
|
|
|
if (fetterLevel != 10) {
|
|
avatarFetter.setExpNumber(this.getFetterExp());
|
|
}
|
|
|
|
if (this.fetters != null) {
|
|
this.fetters.forEach(
|
|
fetterId ->
|
|
avatarFetter.addFetterList(
|
|
FetterData.newBuilder()
|
|
.setFetterId(fetterId)
|
|
.setFetterState(FetterState.FINISH.getValue())));
|
|
}
|
|
|
|
int cardId = this.getNameCardId();
|
|
|
|
if (this.getPlayer().getNameCardList().contains(cardId)) {
|
|
avatarFetter.addRewardedFetterLevelList(10);
|
|
}
|
|
|
|
AvatarInfo.Builder avatarInfo =
|
|
AvatarInfo.newBuilder()
|
|
.setAvatarId(this.getAvatarId())
|
|
.setGuid(this.getGuid())
|
|
.setLifeState(1)
|
|
.addAllTalentIdList(this.getTalentIdList())
|
|
.putAllFightPropMap(this.getFightProperties())
|
|
.setSkillDepotId(this.getSkillDepotId())
|
|
.setCoreProudSkillLevel(this.getCoreProudSkillLevel())
|
|
.putAllSkillLevelMap(this.getSkillLevelMap())
|
|
.addAllInherentProudSkillList(this.getProudSkillList())
|
|
.putAllProudSkillExtraLevelMap(this.getProudSkillBonusMap())
|
|
.setAvatarType(this.getAvatarType())
|
|
.setBornTime(this.getBornTime())
|
|
.setFetterInfo(avatarFetter)
|
|
.setWearingFlycloakId(this.getFlyCloak())
|
|
.setCostumeId(this.getCostume());
|
|
|
|
this.getSkillExtraChargeMap()
|
|
.forEach(
|
|
(skillId, count) ->
|
|
avatarInfo.putSkillMap(
|
|
skillId, AvatarSkillInfo.newBuilder().setMaxChargeCount(count).build()));
|
|
|
|
this.getEquips().forEach((k, item) -> avatarInfo.addEquipGuidList(item.getGuid()));
|
|
|
|
avatarInfo.putPropMap(
|
|
PlayerProperty.PROP_LEVEL.getId(),
|
|
ProtoHelper.newPropValue(PlayerProperty.PROP_LEVEL, this.getLevel()));
|
|
avatarInfo.putPropMap(
|
|
PlayerProperty.PROP_EXP.getId(),
|
|
ProtoHelper.newPropValue(PlayerProperty.PROP_EXP, this.getExp()));
|
|
avatarInfo.putPropMap(
|
|
PlayerProperty.PROP_BREAK_LEVEL.getId(),
|
|
ProtoHelper.newPropValue(PlayerProperty.PROP_BREAK_LEVEL, this.getPromoteLevel()));
|
|
avatarInfo.putPropMap(
|
|
PlayerProperty.PROP_SATIATION_VAL.getId(),
|
|
ProtoHelper.newPropValue(PlayerProperty.PROP_SATIATION_VAL, this.getSatiation()));
|
|
avatarInfo.putPropMap(
|
|
PlayerProperty.PROP_SATIATION_PENALTY_TIME.getId(),
|
|
ProtoHelper.newPropValue(
|
|
PlayerProperty.PROP_SATIATION_PENALTY_TIME, this.getSatiationPenalty()));
|
|
|
|
return avatarInfo.build();
|
|
}
|
|
|
|
// used only in character showcase
|
|
public ShowAvatarInfo toShowAvatarInfoProto() {
|
|
AvatarFetterInfo.Builder avatarFetter =
|
|
AvatarFetterInfo.newBuilder().setExpLevel(this.getFetterLevel());
|
|
|
|
ShowAvatarInfo.Builder showAvatarInfo =
|
|
ShowAvatarInfoOuterClass.ShowAvatarInfo.newBuilder()
|
|
.setAvatarId(avatarId)
|
|
.addAllTalentIdList(this.getTalentIdList())
|
|
.putAllFightPropMap(this.getFightProperties())
|
|
.setSkillDepotId(this.getSkillDepotId())
|
|
.setCoreProudSkillLevel(this.getCoreProudSkillLevel())
|
|
.addAllInherentProudSkillList(this.getProudSkillList())
|
|
.putAllSkillLevelMap(this.getSkillLevelMap())
|
|
.putAllProudSkillExtraLevelMap(this.getProudSkillBonusMap())
|
|
.setFetterInfo(avatarFetter)
|
|
.setCostumeId(this.getCostume());
|
|
|
|
showAvatarInfo.putPropMap(
|
|
PlayerProperty.PROP_LEVEL.getId(),
|
|
ProtoHelper.newPropValue(PlayerProperty.PROP_LEVEL, this.getLevel()));
|
|
showAvatarInfo.putPropMap(
|
|
PlayerProperty.PROP_EXP.getId(),
|
|
ProtoHelper.newPropValue(PlayerProperty.PROP_EXP, this.getExp()));
|
|
showAvatarInfo.putPropMap(
|
|
PlayerProperty.PROP_BREAK_LEVEL.getId(),
|
|
ProtoHelper.newPropValue(PlayerProperty.PROP_BREAK_LEVEL, this.getPromoteLevel()));
|
|
showAvatarInfo.putPropMap(
|
|
PlayerProperty.PROP_SATIATION_VAL.getId(),
|
|
ProtoHelper.newPropValue(PlayerProperty.PROP_SATIATION_VAL, this.getSatiation()));
|
|
showAvatarInfo.putPropMap(
|
|
PlayerProperty.PROP_SATIATION_PENALTY_TIME.getId(),
|
|
ProtoHelper.newPropValue(
|
|
PlayerProperty.PROP_SATIATION_PENALTY_TIME, this.getSatiationPenalty()));
|
|
int maxStamina = this.getPlayer().getProperty(PlayerProperty.PROP_MAX_STAMINA);
|
|
showAvatarInfo.putPropMap(
|
|
PlayerProperty.PROP_MAX_STAMINA.getId(),
|
|
ProtoHelper.newPropValue(PlayerProperty.PROP_MAX_STAMINA, maxStamina));
|
|
|
|
for (GameItem item : this.getEquips().values()) {
|
|
if (item.getItemType() == ItemType.ITEM_RELIQUARY) {
|
|
showAvatarInfo.addEquipList(
|
|
ShowEquip.newBuilder()
|
|
.setItemId(item.getItemId())
|
|
.setReliquary(item.toReliquaryProto()));
|
|
} else if (item.getItemType() == ItemType.ITEM_WEAPON) {
|
|
showAvatarInfo.addEquipList(
|
|
ShowEquip.newBuilder().setItemId(item.getItemId()).setWeapon(item.toWeaponProto()));
|
|
}
|
|
}
|
|
|
|
return showAvatarInfo.build();
|
|
}
|
|
|
|
/**
|
|
* Converts this avatar into a trial avatar.
|
|
*
|
|
* @param level The avatar's level.
|
|
* @param avatarId The ID of the avatar.
|
|
* @param grantReason The reason for granting the avatar.
|
|
* @param questId The ID of the quest that granted the avatar.
|
|
*/
|
|
public void setTrialAvatarInfo(
|
|
int level, int avatarId, TrialAvatarGrantRecord.GrantReason grantReason, int questId) {
|
|
this.setLevel(level);
|
|
this.setPromoteLevel(getMinPromoteLevel(level));
|
|
this.setTrialAvatarId(avatarId);
|
|
this.setGrantReason(grantReason.getNumber());
|
|
this.setFromParentQuestId(questId);
|
|
this.setAvatarType(Type.TRIAL.getNumber());
|
|
this.applyTrialSkillLevels();
|
|
this.applyTrialItems();
|
|
}
|
|
|
|
/**
|
|
* Gets the gear template based on the avatar's level.
|
|
*
|
|
* @return The avatar's template.
|
|
*/
|
|
private int getTrialTemplate() {
|
|
return this.getLevel() <= 9
|
|
? 1
|
|
: (int)
|
|
(Math.floor(this.getLevel() / 10f) * 10); // round trial level to fit template levels
|
|
}
|
|
|
|
/**
|
|
* @return The level to be used for the avatar's skills (talents).
|
|
*/
|
|
public int getTrialSkillLevel() {
|
|
// Use default data if custom data not available.
|
|
if (GameData.getTrialAvatarCustomData().isEmpty()) {
|
|
var template = getTrialTemplate(); // round trial level to fit template levels
|
|
|
|
var templateData = GameData.getTrialAvatarTemplateDataMap().get(template);
|
|
return templateData == null ? 1 : templateData.getTrialAvatarSkillLevel();
|
|
}
|
|
|
|
// Use custom data.
|
|
var trialData = GameData.getTrialAvatarCustomData().get(this.getTrialAvatarId());
|
|
if (trialData == null) return 1;
|
|
|
|
return trialData.getCoreProudSkillLevel(); // enhanced version of weapon
|
|
}
|
|
|
|
/** Applies the correct skill level for the trial avatar. */
|
|
public void applyTrialSkillLevels() {
|
|
this.getSkillLevelMap()
|
|
.keySet()
|
|
.forEach(skill -> this.setSkillLevel(skill, this.getTrialSkillLevel()));
|
|
}
|
|
|
|
/**
|
|
* @return The weapon to use with the avatar.
|
|
*/
|
|
public int getTrialWeaponId() {
|
|
// Use default data if custom data not available.
|
|
if (GameData.getTrialAvatarCustomData().isEmpty()) {
|
|
if (GameData.getTrialAvatarDataMap().get(this.getTrialAvatarId()) == null)
|
|
return this.getAvatarData().getInitialWeapon();
|
|
|
|
return GameData.getItemDataMap().get(this.getAvatarData().getInitialWeapon() + 100) == null
|
|
? getAvatarData().getInitialWeapon()
|
|
: getAvatarData().getInitialWeapon() + 100; // enhanced version of weapon
|
|
}
|
|
|
|
// Use custom data.
|
|
var trialData = GameData.getTrialAvatarCustomData().get(this.getTrialAvatarId());
|
|
if (trialData == null) return 0;
|
|
|
|
var trialCustomParams = trialData.getTrialAvatarParamList();
|
|
return trialCustomParams.size() < 2
|
|
? getAvatarData().getInitialWeapon()
|
|
: Integer.parseInt(trialCustomParams.get(1).split(";")[0]);
|
|
}
|
|
|
|
/**
|
|
* @return A list of artifact IDs to use with the avatar.
|
|
*/
|
|
public List<Integer> getTrialReliquary() {
|
|
// Use default data if custom data not available.
|
|
if (GameData.getTrialAvatarCustomData().isEmpty()) {
|
|
int trialAvatarTemplateLevel = getTrialTemplate();
|
|
|
|
TrialAvatarTemplateData templateData =
|
|
GameData.getTrialAvatarTemplateDataMap().get(trialAvatarTemplateLevel);
|
|
return templateData == null ? List.of() : templateData.getTrialReliquaryList();
|
|
}
|
|
|
|
// Use custom data.
|
|
var trialData = GameData.getTrialAvatarCustomData().get(this.getTrialAvatarId());
|
|
if (trialData == null) return List.of();
|
|
|
|
var trialCustomParams =
|
|
GameData.getTrialAvatarCustomData().get(getTrialAvatarId()).getTrialAvatarParamList();
|
|
return trialCustomParams.size() < 3
|
|
? List.of()
|
|
: Stream.of(trialCustomParams.get(2).split(";")).map(Integer::parseInt).toList();
|
|
}
|
|
|
|
/** Applies the correct items for the trial avatar. */
|
|
public void applyTrialItems() {
|
|
// Use an enhanced version of the weapon if available.
|
|
var weapon = new GameItem(this.getTrialWeaponId());
|
|
weapon.setLevel(this.getLevel());
|
|
weapon.setExp(0);
|
|
weapon.setPromoteLevel(getMinPromoteLevel(this.getLevel()));
|
|
this.getEquips().put(weapon.getEquipSlot(), weapon);
|
|
|
|
// Add artifacts for the trial avatar.
|
|
this.getTrialReliquary()
|
|
.forEach(
|
|
id -> {
|
|
var reliquaryData = GameData.getTrialReliquaryDataMap().get((int) id);
|
|
if (reliquaryData == null) return;
|
|
|
|
var relic = new GameItem(reliquaryData.getReliquaryId());
|
|
relic.setLevel(reliquaryData.getLevel());
|
|
relic.setMainPropId(reliquaryData.getMainPropId());
|
|
relic.getAppendPropIdList().addAll(reliquaryData.getAppendPropList());
|
|
this.getEquips().put(relic.getEquipSlot(), relic);
|
|
});
|
|
|
|
// Add costume if avatar has a costume.
|
|
if (GAME_OPTIONS.trialCostumes) {
|
|
GameData.getAvatarCostumeDataItemIdMap()
|
|
.values()
|
|
.forEach(
|
|
costumeData -> {
|
|
if (costumeData.getCharacterId() != this.getAvatarId()) return;
|
|
this.setCostume(costumeData.getId());
|
|
});
|
|
}
|
|
}
|
|
|
|
/** Equips the items applied from {@link Avatar#applyTrialItems()}. */
|
|
public void equipTrialItems() {
|
|
var player = this.getPlayer();
|
|
|
|
this.getEquips()
|
|
.values()
|
|
.forEach(
|
|
item -> {
|
|
item.setEquipCharacter(this.getAvatarId());
|
|
item.setOwner(player);
|
|
if (item.getItemData().getEquipType() == EquipType.EQUIP_WEAPON) {
|
|
if (!(item.getWeaponEntity() != null
|
|
&& item.getWeaponEntity().getScene() == player.getScene())) {
|
|
item.setWeaponEntity(
|
|
new EntityWeapon(player.getScene(), item.getItemData().getGadgetId()));
|
|
player
|
|
.getScene()
|
|
.getWeaponEntities()
|
|
.put(item.getWeaponEntity().getId(), item.getWeaponEntity());
|
|
}
|
|
|
|
player.sendPacket(new PacketAvatarEquipChangeNotify(this, item));
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Converts this (trial) avatar into a trial info protocol buffer.
|
|
*
|
|
* @return The trial info protocol buffer.
|
|
*/
|
|
public TrialAvatarInfo toTrialInfo() {
|
|
var trialAvatar =
|
|
TrialAvatarInfo.newBuilder()
|
|
.setTrialAvatarId(this.getTrialAvatarId())
|
|
.setGrantRecord(
|
|
TrialAvatarGrantRecord.newBuilder()
|
|
.setGrantReason(this.getGrantReason())
|
|
.setFromParentQuestId(this.getFromParentQuestId()));
|
|
|
|
// Check if the avatar is a trial avatar.
|
|
if (this.getTrialAvatarId() > 0) {
|
|
// Add the artifacts & weapons for the avatar.
|
|
trialAvatar.addAllTrialEquipList(
|
|
this.getEquips().values().stream().map(GameItem::toProto).toList());
|
|
}
|
|
|
|
return trialAvatar.build();
|
|
}
|
|
|
|
@PostLoad
|
|
private void onLoad() {}
|
|
|
|
@PrePersist
|
|
private void prePersist() {
|
|
this.currentHp = this.getFightProperty(FightProperty.FIGHT_PROP_CUR_HP);
|
|
}
|
|
|
|
@AllArgsConstructor
|
|
@Getter
|
|
enum Type {
|
|
NORMAL(1),
|
|
TRIAL(2);
|
|
|
|
final int number;
|
|
}
|
|
}
|