5b8509a7f4
Some checks reported errors
studiorailgun/Renderer/pipeline/head Something is wrong with the build of this commit
784 lines
31 KiB
Java
784 lines
31 KiB
Java
package electrosphere.entity.state.attack;
|
|
|
|
|
|
import electrosphere.server.datacell.utils.ServerBehaviorTreeUtils;
|
|
import electrosphere.net.parser.net.message.SynchronizationMessage;
|
|
import electrosphere.server.datacell.utils.DataCellSearchUtils;
|
|
import electrosphere.data.common.treedata.TreeDataState;
|
|
import electrosphere.data.creature.attack.AttackMove;
|
|
import electrosphere.data.creature.equip.EquipPoint;
|
|
import electrosphere.data.item.WeaponData;
|
|
import electrosphere.engine.Globals;
|
|
import electrosphere.entity.Entity;
|
|
import electrosphere.entity.EntityDataStrings;
|
|
import electrosphere.entity.EntityUtils;
|
|
import electrosphere.entity.btree.BehaviorTree;
|
|
import electrosphere.entity.btree.StateTransitionUtil;
|
|
import electrosphere.entity.btree.StateTransitionUtil.StateTransitionUtilItem;
|
|
import electrosphere.entity.state.attach.AttachUtils;
|
|
import electrosphere.entity.state.attack.ClientAttackTree.AttackTreeDriftState;
|
|
import electrosphere.entity.state.attack.ClientAttackTree.AttackTreeState;
|
|
import electrosphere.entity.state.collidable.Impulse;
|
|
import electrosphere.entity.state.equip.ServerEquipState;
|
|
import electrosphere.entity.state.equip.ServerToolbarState;
|
|
import electrosphere.entity.state.hitbox.HitboxCollectionState;
|
|
import electrosphere.entity.state.hitbox.HitboxCollectionState.HitboxState;
|
|
import electrosphere.entity.state.hitbox.HitboxCollectionState.HitboxType;
|
|
import electrosphere.entity.state.movement.fall.ServerFallTree;
|
|
import electrosphere.entity.state.movement.jump.ServerJumpTree;
|
|
import electrosphere.entity.state.rotator.ServerRotatorTree;
|
|
import electrosphere.entity.types.collision.CollisionObjUtils;
|
|
import electrosphere.entity.types.creature.CreatureUtils;
|
|
import electrosphere.entity.types.item.ItemUtils;
|
|
import electrosphere.entity.types.projectile.ProjectileUtils;
|
|
import electrosphere.logger.LoggerInterface;
|
|
import electrosphere.net.parser.net.message.EntityMessage;
|
|
import electrosphere.net.synchronization.annotation.SyncedField;
|
|
import electrosphere.net.synchronization.annotation.SynchronizedBehaviorTree;
|
|
import electrosphere.net.synchronization.enums.BehaviorTreeIdEnums;
|
|
import electrosphere.net.synchronization.enums.FieldIdEnums;
|
|
import electrosphere.renderer.actor.Actor;
|
|
import electrosphere.server.datacell.Realm;
|
|
|
|
import java.util.LinkedList;
|
|
import java.util.List;
|
|
|
|
import org.joml.Quaterniond;
|
|
import org.joml.Vector3d;
|
|
import org.joml.Vector3f;
|
|
|
|
/**
|
|
* Server basic attack tree
|
|
*/
|
|
@SynchronizedBehaviorTree(name = "serverAttackTree", isServer = true, correspondingTree="clientAttackTree")
|
|
public class ServerAttackTree implements BehaviorTree {
|
|
|
|
//the state of the attack tree
|
|
@SyncedField(serverSendTransitionPacket = true)
|
|
AttackTreeState state;
|
|
|
|
//the state of drifting caused by the attack animation
|
|
@SyncedField
|
|
AttackTreeDriftState driftState;
|
|
|
|
Entity parent;
|
|
|
|
List<EntityMessage> networkMessageQueue = new LinkedList<EntityMessage>();
|
|
|
|
long lastUpdateTime = 0;
|
|
|
|
float frameCurrent;
|
|
|
|
String animationName = "SwingWeapon";
|
|
|
|
int maxFrame = 60;
|
|
|
|
List<AttackMove> currentMoveset = null;
|
|
@SyncedField
|
|
String currentMoveId = null; //the id of the current move -- used to synchronize the move to client
|
|
AttackMove currentMove = null; //the actual current move object
|
|
Entity currentWeapon = null;
|
|
boolean currentMoveHasWindup;
|
|
boolean currentMoveCanHold;
|
|
boolean stillHold = true;
|
|
boolean firesProjectile = false;
|
|
String projectileToFire = null;
|
|
String attackingPoint = null;
|
|
|
|
/**
|
|
* The minimum number of fall frames required before it blocks attacking
|
|
*/
|
|
int MIN_FALL_FRAMES_TO_BLOCK_ATTACK = 3;
|
|
|
|
/**
|
|
* The list of entities that have collided with the current attack
|
|
*/
|
|
List<Entity> collidedEntities = new LinkedList<Entity>();
|
|
|
|
//The state transition util
|
|
StateTransitionUtil stateTransitionUtil;
|
|
|
|
/**
|
|
* Private constructor
|
|
* @param e The parent entity
|
|
* @param params The data to construct the tree with
|
|
*/
|
|
private ServerAttackTree(Entity e, Object ... params){
|
|
state = AttackTreeState.IDLE;
|
|
driftState = AttackTreeDriftState.NO_DRIFT;
|
|
parent = e;
|
|
this.stateTransitionUtil = StateTransitionUtil.create(parent, true, new StateTransitionUtilItem[]{
|
|
StateTransitionUtilItem.create(
|
|
AttackTreeState.WINDUP,
|
|
() -> {
|
|
TreeDataState state = currentMove.getWindupState();
|
|
if(state == null){
|
|
return null;
|
|
} else {
|
|
return state.getAnimation();
|
|
}
|
|
},
|
|
() -> {
|
|
TreeDataState state = currentMove.getWindupState();
|
|
if(state == null){
|
|
return null;
|
|
} else {
|
|
return state.getAudioData();
|
|
}
|
|
},
|
|
() -> {
|
|
if(currentMoveCanHold && stillHold){
|
|
this.setState(AttackTreeState.HOLD);
|
|
} else {
|
|
this.setState(AttackTreeState.ATTACK);
|
|
}
|
|
this.stateTransitionUtil.interrupt(AttackTreeState.WINDUP);
|
|
}
|
|
),
|
|
StateTransitionUtilItem.create(
|
|
AttackTreeState.HOLD,
|
|
() -> {
|
|
if(currentMove != null && currentMove.getHoldState() == null){
|
|
return null;
|
|
} else {
|
|
return currentMove.getHoldState().getAnimation();
|
|
}
|
|
},
|
|
() -> {
|
|
TreeDataState state = currentMove.getHoldState();
|
|
if(state == null){
|
|
return null;
|
|
} else {
|
|
return state.getAudioData();
|
|
}
|
|
},
|
|
null
|
|
),
|
|
StateTransitionUtilItem.create(
|
|
AttackTreeState.ATTACK,
|
|
() -> {
|
|
TreeDataState state = currentMove.getAttackState();
|
|
if(state == null){
|
|
return null;
|
|
} else {
|
|
return state.getAnimation();
|
|
}
|
|
},
|
|
null,
|
|
() -> {
|
|
this.stateTransitionUtil.interrupt(AttackTreeState.ATTACK);
|
|
this.setState(AttackTreeState.COOLDOWN);
|
|
}
|
|
),
|
|
StateTransitionUtilItem.create(
|
|
AttackTreeState.BLOCK_RECOIL,
|
|
() -> {
|
|
if(currentMove != null && currentMove.getBlockRecoilState() != null){
|
|
return currentMove.getBlockRecoilState().getAnimation();
|
|
} else {
|
|
return null;
|
|
}
|
|
},
|
|
null,
|
|
() -> {
|
|
this.stateTransitionUtil.interrupt(AttackTreeState.BLOCK_RECOIL);
|
|
this.setState(AttackTreeState.COOLDOWN);
|
|
}
|
|
),
|
|
StateTransitionUtilItem.create(
|
|
AttackTreeState.COOLDOWN,
|
|
() -> {
|
|
TreeDataState state = currentMove.getCooldownState();
|
|
if(state == null){
|
|
return null;
|
|
} else {
|
|
return state.getAnimation();
|
|
}
|
|
},
|
|
null,
|
|
() -> {
|
|
this.setState(AttackTreeState.IDLE);
|
|
this.stateTransitionUtil.interrupt(AttackTreeState.COOLDOWN);
|
|
}
|
|
),
|
|
});
|
|
}
|
|
|
|
/**
|
|
* <p> Automatically generated </p>
|
|
* <p>
|
|
* Gets state.
|
|
* </p>
|
|
*/
|
|
public AttackTreeState getState(){
|
|
return state;
|
|
}
|
|
|
|
/**
|
|
* Starts an attack
|
|
*/
|
|
public void start(){
|
|
currentMoveCanHold = false;
|
|
currentMoveHasWindup = false;
|
|
stillHold = true;
|
|
firesProjectile = false;
|
|
projectileToFire = null;
|
|
currentWeapon = null;
|
|
attackingPoint = null;
|
|
//figure out attack type we should be doing
|
|
String attackType = this.getAttackType();
|
|
//if we can attack, setup doing so
|
|
if(this.canAttack(attackType)){
|
|
this.setAttackMoveTypeActive(attackType);
|
|
currentMoveset = this.getMoveset(attackType);
|
|
if(currentMoveset != null){
|
|
if(currentMove == null){
|
|
currentMove = currentMoveset.get(0);
|
|
} else {
|
|
currentMove = this.getNextMove(currentMoveset,currentMove.getNextMoveId());
|
|
}
|
|
if(currentMove != null){
|
|
firesProjectile = currentMove.getFiresProjectile();
|
|
if(firesProjectile){
|
|
projectileToFire = ItemUtils.getWeaponDataRaw(currentWeapon).getProjectileModel();
|
|
}
|
|
|
|
//set initial stuff (this alerts the client as well)
|
|
this.setCurrentMoveId(currentMove.getAttackMoveId());
|
|
|
|
//start tree
|
|
if(currentMove.getWindupState() != null){
|
|
this.setState(AttackTreeState.WINDUP);
|
|
} else if(currentMove.getAttackState() != null){
|
|
this.setState(AttackTreeState.ATTACK);
|
|
} else {
|
|
LoggerInterface.loggerEngine.ERROR(new IllegalStateException("Trying to start attacking tree, but current move does not have windup or attack states defined!"));
|
|
}
|
|
this.stateTransitionUtil.reset();
|
|
//intuit can hold from presence of windup anim
|
|
currentMoveCanHold = currentMove.getHoldState() != null;
|
|
//clear collided list
|
|
this.collidedEntities.clear();
|
|
frameCurrent = 0;
|
|
} else {
|
|
this.setState(AttackTreeState.IDLE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Releases the tree from holding its animation
|
|
*/
|
|
public void release(){
|
|
stillHold = false;
|
|
}
|
|
|
|
/**
|
|
* Interrupts the tree
|
|
*/
|
|
public void interrupt(){
|
|
this.setState(AttackTreeState.IDLE);
|
|
//activate hitboxes
|
|
List<Entity> attachedEntities = AttachUtils.getChildrenList(parent);
|
|
for(Entity currentAttached : attachedEntities){
|
|
if(HitboxCollectionState.hasHitboxState(currentAttached)){
|
|
HitboxCollectionState currentState = HitboxCollectionState.getHitboxState(currentAttached);
|
|
currentState.setActive(false);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Causes the attack tree to instead enter recoil state
|
|
*/
|
|
public void recoilFromBlock(){
|
|
if(currentMove != null){
|
|
this.setState(AttackTreeState.BLOCK_RECOIL);
|
|
//deactivate hitboxes
|
|
List<Entity> attachedEntities = AttachUtils.getChildrenList(parent);
|
|
for(Entity currentAttached : attachedEntities){
|
|
if(HitboxCollectionState.hasHitboxState(currentAttached)){
|
|
HitboxCollectionState currentState = HitboxCollectionState.getHitboxState(currentAttached);
|
|
currentState.setActive(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void simulate(float deltaTime){
|
|
frameCurrent = frameCurrent + (float)Globals.timekeeper.getDeltaFrames();
|
|
Vector3d movementVector = CreatureUtils.getFacingVector(parent);
|
|
|
|
//parse attached network messages
|
|
for(EntityMessage message : networkMessageQueue){
|
|
networkMessageQueue.remove(message);
|
|
switch(message.getMessageSubtype()){
|
|
case ATTACKUPDATE:
|
|
EntityUtils.getPosition(parent).set(message.getpositionX(),message.getpositionY(),message.getpositionZ());
|
|
break;
|
|
case STARTATTACK: {
|
|
this.start();
|
|
} break;
|
|
default:
|
|
//silently ignore
|
|
break;
|
|
}
|
|
}
|
|
|
|
//handle the drifting if we're supposed to currently
|
|
switch(driftState){
|
|
case DRIFT:
|
|
if(currentMove != null){
|
|
//calculate the vector of movement
|
|
CollisionObjUtils.getCollidable(parent).addImpulse(new Impulse(new Vector3d(movementVector), new Vector3d(0,0,0), new Vector3d(0,0,0), currentMove.getDriftGoal() * Globals.timekeeper.getSimFrameTime(), "movement"));
|
|
if(frameCurrent > currentMove.getDriftFrameEnd()){
|
|
this.setDriftState(AttackTreeDriftState.NO_DRIFT);
|
|
}
|
|
}
|
|
break;
|
|
case NO_DRIFT:
|
|
if(currentMove != null){
|
|
if(frameCurrent > currentMove.getDriftFrameStart() && frameCurrent < currentMove.getDriftFrameEnd()){
|
|
this.setDriftState(AttackTreeDriftState.DRIFT);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
// if(state != AttackTreeState.IDLE){
|
|
// System.out.println(frameCurrent);
|
|
// }
|
|
|
|
//state machine
|
|
switch(state){
|
|
case WINDUP: {
|
|
if(parent.containsKey(EntityDataStrings.SERVER_ROTATOR_TREE)){
|
|
ServerRotatorTree.getServerRotatorTree(parent).setActive(true);
|
|
}
|
|
this.stateTransitionUtil.simulate(AttackTreeState.WINDUP);
|
|
} break;
|
|
case HOLD: {
|
|
this.stateTransitionUtil.simulate(AttackTreeState.HOLD);
|
|
if(!stillHold){
|
|
this.setState(AttackTreeState.ATTACK);
|
|
this.stateTransitionUtil.interrupt(AttackTreeState.HOLD);
|
|
}
|
|
} break;
|
|
case ATTACK: {
|
|
this.stateTransitionUtil.simulate(AttackTreeState.ATTACK);
|
|
//activate hitboxes
|
|
List<Entity> attachedEntities = AttachUtils.getChildrenList(parent);
|
|
if(attachedEntities != null){
|
|
for(Entity currentAttached : attachedEntities){
|
|
if(HitboxCollectionState.hasHitboxState(currentAttached)){
|
|
HitboxCollectionState currentState = HitboxCollectionState.getHitboxState(currentAttached);
|
|
currentState.setActive(true);
|
|
}
|
|
}
|
|
}
|
|
if(this.currentMove.getActiveBones() != null && HitboxCollectionState.hasHitboxState(this.parent)){
|
|
HitboxCollectionState hitboxCollectionState = HitboxCollectionState.getHitboxState(this.parent);
|
|
for(String boneName : this.currentMove.getActiveBones()){
|
|
List<HitboxState> hitboxes = hitboxCollectionState.getHitboxes(boneName);
|
|
for(HitboxState hitbox : hitboxes){
|
|
if(hitbox.getType() == HitboxType.HIT){
|
|
hitbox.setActive(true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(firesProjectile && projectileToFire != null){
|
|
//spawn projectile
|
|
Vector3d spawnPosition = new Vector3d(0,0,0);
|
|
Quaterniond arrowRotation = new Quaterniond();
|
|
String targetBone = null;
|
|
ServerEquipState equipState = ServerEquipState.getEquipState(parent);
|
|
EquipPoint weaponPoint = null;
|
|
if((weaponPoint = equipState.getEquipPoint(attackingPoint)) != null){
|
|
targetBone = weaponPoint.getBone();
|
|
}
|
|
if(targetBone != null){
|
|
Actor parentActor = EntityUtils.getActor(parent);
|
|
//transform bone space
|
|
spawnPosition = new Vector3d(parentActor.getBonePosition(targetBone));
|
|
spawnPosition = spawnPosition.mul(((Vector3f)EntityUtils.getScale(parent)));
|
|
Quaterniond rotation = EntityUtils.getRotation(parent);
|
|
spawnPosition = spawnPosition.rotate(new Quaterniond(rotation.x,rotation.y,rotation.z,rotation.w));
|
|
//transform worldspace
|
|
spawnPosition.add(new Vector3d(EntityUtils.getPosition(parent)));
|
|
//set
|
|
// EntityUtils.getPosition(currentEntity).set(position);
|
|
//set rotation
|
|
// Quaternionf rotation = parentActor.getBoneRotation(targetBone);
|
|
// EntityUtils.getRotation(currentEntity).set(rotation).normalize();
|
|
// Vector3d facingAngle = CreatureUtils.getFacingVector(parent);
|
|
arrowRotation = parentActor.getBoneRotation(targetBone);
|
|
// EntityUtils.getRotation(currentEntity).rotationTo(MathUtils.ORIGIN_VECTORF, new Vector3f((float)facingAngle.x,(float)facingAngle.y,(float)facingAngle.z)).mul(parentActor.getBoneRotation(targetBone)).normalize();
|
|
}
|
|
Vector3f initialVector = new Vector3f((float)movementVector.x,(float)movementVector.y,(float)movementVector.z).normalize();
|
|
Realm parentRealm = Globals.serverState.realmManager.getEntityRealm(parent);
|
|
ProjectileUtils.serverSpawnBasicProjectile(parentRealm, projectileToFire, spawnPosition, arrowRotation, 750, initialVector, 0.03f);
|
|
projectileToFire = null;
|
|
}
|
|
} break;
|
|
case BLOCK_RECOIL: {
|
|
this.stateTransitionUtil.simulate(AttackTreeState.BLOCK_RECOIL);
|
|
//deactivate hitboxes
|
|
List<Entity> attachedEntities = AttachUtils.getChildrenList(parent);
|
|
if(attachedEntities != null){
|
|
for(Entity currentAttached : attachedEntities){
|
|
if(HitboxCollectionState.hasHitboxState(currentAttached)){
|
|
HitboxCollectionState currentState = HitboxCollectionState.getHitboxState(currentAttached);
|
|
currentState.setActive(false);
|
|
}
|
|
}
|
|
}
|
|
if(this.currentMove.getActiveBones() != null && HitboxCollectionState.hasHitboxState(this.parent)){
|
|
HitboxCollectionState hitboxCollectionState = HitboxCollectionState.getHitboxState(this.parent);
|
|
for(String boneName : this.currentMove.getActiveBones()){
|
|
List<HitboxState> hitboxes = hitboxCollectionState.getHitboxes(boneName);
|
|
for(HitboxState hitbox : hitboxes){
|
|
if(hitbox.getType() == HitboxType.HIT){
|
|
hitbox.setActive(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} break;
|
|
case COOLDOWN: {
|
|
this.stateTransitionUtil.simulate(AttackTreeState.COOLDOWN);
|
|
//deactive hitboxes
|
|
List<Entity> attachedEntities = AttachUtils.getChildrenList(parent);
|
|
if(attachedEntities != null){
|
|
for(Entity currentAttached : attachedEntities){
|
|
if(HitboxCollectionState.hasHitboxState(currentAttached)){
|
|
HitboxCollectionState currentState = HitboxCollectionState.getHitboxState(currentAttached);
|
|
currentState.setActive(false);
|
|
}
|
|
}
|
|
}
|
|
if(this.currentMove.getActiveBones() != null && HitboxCollectionState.hasHitboxState(this.parent)){
|
|
HitboxCollectionState hitboxCollectionState = HitboxCollectionState.getHitboxState(this.parent);
|
|
for(String boneName : this.currentMove.getActiveBones()){
|
|
List<HitboxState> hitboxes = hitboxCollectionState.getHitboxes(boneName);
|
|
for(HitboxState hitbox : hitboxes){
|
|
if(hitbox.getType() == HitboxType.HIT){
|
|
hitbox.setActive(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(frameCurrent > currentMove.getWindupFrames() + currentMove.getAttackFrames() + currentMove.getCooldownFrames()){
|
|
this.setState(AttackTreeState.IDLE);
|
|
this.stateTransitionUtil.interrupt(AttackTreeState.COOLDOWN);
|
|
frameCurrent = 0;
|
|
if(parent.containsKey(EntityDataStrings.SERVER_ROTATOR_TREE)){
|
|
ServerRotatorTree.getServerRotatorTree(parent).setActive(false);
|
|
}
|
|
}
|
|
} break;
|
|
case IDLE: {
|
|
currentMove = null;
|
|
currentMoveset = null;
|
|
} break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the movement penalty applied due to this tree
|
|
* @return The movement penalty
|
|
*/
|
|
public double getMovementPenalty(){
|
|
if(currentWeapon != null && ItemUtils.getWeaponDataRaw(currentWeapon) != null){
|
|
WeaponData weaponData = ItemUtils.getWeaponDataRaw(currentWeapon);
|
|
if(this.state != AttackTreeState.IDLE && weaponData.getWeaponActionMovePenalty() != null){
|
|
return weaponData.getWeaponActionMovePenalty();
|
|
}
|
|
}
|
|
return 1.0;
|
|
}
|
|
|
|
/**
|
|
* Adds a network message to the tree
|
|
* @param networkMessage The network message
|
|
*/
|
|
public void addNetworkMessage(EntityMessage networkMessage) {
|
|
networkMessageQueue.add(networkMessage);
|
|
}
|
|
|
|
/**
|
|
* Gets the current attack type
|
|
* @return The current attack type
|
|
*/
|
|
protected String getAttackType(){
|
|
String rVal = null;
|
|
if(ServerToolbarState.getServerToolbarState(parent) != null){
|
|
ServerToolbarState serverToolbarState = ServerToolbarState.getServerToolbarState(parent);
|
|
Entity item = serverToolbarState.getRealWorldItem();
|
|
if(item == null){
|
|
return EntityDataStrings.ATTACK_MOVE_UNARMED;
|
|
}
|
|
if(ItemUtils.isWeapon(item)){
|
|
currentWeapon = item;
|
|
switch(ItemUtils.getWeaponClass(item)){
|
|
case "sword1h":
|
|
rVal = EntityDataStrings.ATTACK_MOVE_TYPE_MELEE_SWING_ONE_HAND;
|
|
break;
|
|
case "sword2h":
|
|
rVal = EntityDataStrings.ATTACK_MOVE_TYPE_MELEE_SWING_TWO_HAND;
|
|
break;
|
|
case "bow2h":
|
|
rVal = EntityDataStrings.ATTACK_MOVE_TYPE_BOW_TWO_HAND;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if(rVal == null && this.getMoveset(EntityDataStrings.ATTACK_MOVE_UNARMED) != null){
|
|
return EntityDataStrings.ATTACK_MOVE_UNARMED;
|
|
}
|
|
return rVal;
|
|
}
|
|
|
|
/**
|
|
* Checks if the tree can perform the specified attack
|
|
* @param attackType The attack type
|
|
* @return true if can attack, false otherwise
|
|
*/
|
|
protected boolean canAttack(String attackType){
|
|
if(attackType == null){
|
|
return false;
|
|
}
|
|
if(state != AttackTreeState.IDLE){
|
|
//checks if we have a next move and if we're in the specified range of frames when we're allowed to chain into it
|
|
if(
|
|
currentMove == null ||
|
|
currentMove.getNextMoveId() == null ||
|
|
currentMove.getNextMoveId().equals("") ||
|
|
frameCurrent < currentMove.getMoveChainWindowStart() ||
|
|
frameCurrent > currentMove.getMoveChainWindowEnd()
|
|
){
|
|
return false;
|
|
}
|
|
}
|
|
if(state == AttackTreeState.IDLE){
|
|
if(!ServerEquipState.hasEquipState(parent)){
|
|
return false;
|
|
}
|
|
}
|
|
if(ServerJumpTree.getServerJumpTree(parent) != null){
|
|
ServerJumpTree serverJumpTree = ServerJumpTree.getServerJumpTree(parent);
|
|
if(serverJumpTree.isJumping()){
|
|
return false;
|
|
}
|
|
}
|
|
if(ServerFallTree.getFallTree(parent) != null){
|
|
ServerFallTree serverFallTree = ServerFallTree.getFallTree(parent);
|
|
if(serverFallTree.isFalling() && serverFallTree.getFrameCurrent() > MIN_FALL_FRAMES_TO_BLOCK_ATTACK){
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Checks if this tree can start an attack
|
|
* @return true if can attack, false otherwise
|
|
*/
|
|
public boolean canAttack(){
|
|
String attackType = getAttackType();
|
|
if(attackType == null){
|
|
return false;
|
|
}
|
|
return this.canAttack(attackType);
|
|
}
|
|
|
|
/**
|
|
* Gets the next attack move
|
|
* @param moveset The moveset
|
|
* @param nextMoveId The next move's id
|
|
* @return The next move if it exists, null otherwise
|
|
*/
|
|
private AttackMove getNextMove(List<AttackMove> moveset, String nextMoveId){
|
|
AttackMove rVal = null;
|
|
for(AttackMove move : moveset){
|
|
if(move.getAttackMoveId().equals(nextMoveId)){
|
|
rVal = move;
|
|
break;
|
|
}
|
|
}
|
|
return rVal;
|
|
}
|
|
|
|
/**
|
|
* Sets the current attack type of the entity
|
|
* @param attackType the current attack type
|
|
*/
|
|
public void setAttackMoveTypeActive(String attackType){
|
|
parent.putData(EntityDataStrings.ATTACK_MOVE_TYPE_ACTIVE, attackType);
|
|
}
|
|
|
|
/**
|
|
* Checks whether the attack tree is active or not
|
|
* @return true if active, false otherwise
|
|
*/
|
|
public boolean isAttacking(){
|
|
return this.state != AttackTreeState.IDLE;
|
|
}
|
|
|
|
/**
|
|
* Gets the current moveset
|
|
* @param attackType the attack type
|
|
* @return The moveset if it exists
|
|
*/
|
|
@SuppressWarnings("unchecked")
|
|
public List<AttackMove> getMoveset(String attackType){
|
|
return (List<AttackMove>)parent.getData(attackType);
|
|
}
|
|
|
|
/**
|
|
* Checks if the target can be collided with
|
|
* @param target The target
|
|
* @return true if can be collided with, false otherwise (ie it has already collided)
|
|
*/
|
|
public boolean canCollideEntity(Entity target){
|
|
return !this.collidedEntities.contains(target);
|
|
}
|
|
|
|
/**
|
|
* Sets that the current attack has collided with the provided entity
|
|
* @param target The target entity
|
|
*/
|
|
public void collideEntity(Entity target){
|
|
this.collidedEntities.add(target);
|
|
}
|
|
|
|
/**
|
|
* Checks if the entity has a copy of this tree
|
|
* @param target The entity
|
|
* @return true if has a copy of this tree, false otherwise
|
|
*/
|
|
public static boolean hasAttackTree(Entity target){
|
|
return target.containsKey(EntityDataStrings.TREE_SERVERATTACKTREE);
|
|
}
|
|
|
|
/**
|
|
* <p> Automatically generated </p>
|
|
* <p>
|
|
* Sets state and handles the synchronization logic for it.
|
|
* </p>
|
|
* @param state The value to set state to.
|
|
*/
|
|
public void setState(AttackTreeState state){
|
|
this.state = state;
|
|
int value = ClientAttackTree.getAttackTreeStateEnumAsShort(state);
|
|
if(DataCellSearchUtils.getEntityDataCell(parent) != null){
|
|
DataCellSearchUtils.getEntityDataCell(parent).broadcastNetworkMessage(SynchronizationMessage.constructServerNotifyBTreeTransitionMessage(parent.getId(), BehaviorTreeIdEnums.BTREE_SERVERATTACKTREE_ID, FieldIdEnums.TREE_SERVERATTACKTREE_SYNCEDFIELD_STATE_ID, value));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* <p> Automatically generated </p>
|
|
* <p>
|
|
* Gets driftState.
|
|
* </p>
|
|
*/
|
|
public AttackTreeDriftState getDriftState(){
|
|
return driftState;
|
|
}
|
|
|
|
/**
|
|
* <p> Automatically generated </p>
|
|
* <p>
|
|
* Sets driftState and handles the synchronization logic for it.
|
|
* </p>
|
|
* @param driftState The value to set driftState to.
|
|
*/
|
|
public void setDriftState(AttackTreeDriftState driftState){
|
|
this.driftState = driftState;
|
|
int value = ClientAttackTree.getAttackTreeDriftStateEnumAsShort(driftState);
|
|
if(DataCellSearchUtils.getEntityDataCell(parent) != null){
|
|
DataCellSearchUtils.getEntityDataCell(parent).broadcastNetworkMessage(SynchronizationMessage.constructUpdateClientStateMessage(parent.getId(), BehaviorTreeIdEnums.BTREE_SERVERATTACKTREE_ID, FieldIdEnums.TREE_SERVERATTACKTREE_SYNCEDFIELD_DRIFTSTATE_ID, value));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* <p> (initially) Automatically generated </p>
|
|
* <p>
|
|
* Attaches this tree to the entity.
|
|
* </p>
|
|
* @param entity The entity to attach to
|
|
* @param tree The behavior tree to attach
|
|
* @param params Optional parameters that will be provided to the constructor
|
|
*/
|
|
public static ServerAttackTree attachTree(Entity parent, Object ... params){
|
|
ServerAttackTree rVal = new ServerAttackTree(parent,params);
|
|
//!!WARNING!! from here below should not be touched
|
|
//This was generated automatically to properly alert various systems that the btree exists and should be tracked
|
|
ServerBehaviorTreeUtils.attachBTreeToEntity(parent, rVal);
|
|
parent.putData(EntityDataStrings.TREE_SERVERATTACKTREE, rVal);
|
|
Globals.entityValueTrackingService.attachTreeToEntity(parent, BehaviorTreeIdEnums.BTREE_SERVERATTACKTREE_ID);
|
|
return rVal;
|
|
}
|
|
|
|
/**
|
|
* <p> Automatically generated </p>
|
|
* <p>
|
|
* Detatches this tree from the entity.
|
|
* </p>
|
|
* @param entity The entity to detach to
|
|
* @param tree The behavior tree to detach
|
|
*/
|
|
public static void detachTree(Entity entity, BehaviorTree tree){
|
|
Globals.entityValueTrackingService.detatchTreeFromEntity(entity, BehaviorTreeIdEnums.BTREE_SERVERATTACKTREE_ID);
|
|
}
|
|
|
|
/**
|
|
* <p>
|
|
* Gets the ServerAttackTree of the entity
|
|
* </p>
|
|
* @param entity the entity
|
|
* @return The ServerAttackTree
|
|
*/
|
|
public static ServerAttackTree getServerAttackTree(Entity entity){
|
|
return (ServerAttackTree)entity.getData(EntityDataStrings.TREE_SERVERATTACKTREE);
|
|
}
|
|
|
|
/**
|
|
* <p> Automatically generated </p>
|
|
* <p>
|
|
* Gets currentMoveId.
|
|
* </p>
|
|
*/
|
|
public String getCurrentMoveId(){
|
|
return currentMoveId;
|
|
}
|
|
|
|
/**
|
|
* <p> Automatically generated </p>
|
|
* <p>
|
|
* Sets currentMoveId and handles the synchronization logic for it.
|
|
* </p>
|
|
* @param currentMoveId The value to set currentMoveId to.
|
|
*/
|
|
public void setCurrentMoveId(String currentMoveId){
|
|
this.currentMoveId = currentMoveId;
|
|
if(DataCellSearchUtils.getEntityDataCell(parent) != null){
|
|
DataCellSearchUtils.getEntityDataCell(parent).broadcastNetworkMessage(SynchronizationMessage.constructUpdateClientStringStateMessage(parent.getId(), BehaviorTreeIdEnums.BTREE_SERVERATTACKTREE_ID, FieldIdEnums.TREE_SERVERATTACKTREE_SYNCEDFIELD_CURRENTMOVEID_ID, currentMoveId));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* <p>
|
|
* Checks if the entity has a ServerAttackTree component
|
|
* </p>
|
|
* @param entity the entity
|
|
* @return true if the entity contains the component, false otherwise
|
|
*/
|
|
public static boolean hasServerAttackTree(Entity entity){
|
|
return entity.containsKey(EntityDataStrings.TREE_SERVERATTACKTREE);
|
|
}
|
|
|
|
}
|