id-software/DoomRTX
1
0
Fork 0
mirror of https://github.com/jmarshall23/DoomRTX.git synced 2026-08-16 08:10:32 +02:00
Code Issues Packages Projects Releases Wiki Activity
Files
3b222499ca22fe56db0b011fdfbab1b75e893d64
DoomRTX/neo/doom3/game/ai/AI_monster_demon_trite.cpp
T
Justin Marshall 293942d07c TypeInfoGen will now autobind doom scripts.
2026-05-23 20:50:12 -07:00

440 lines
18 KiB
C++
Raw Blame History

// AI_monster_demon_trite.cpp
// Native state-machine replacement for ai_monster_demon_trite.script.
#include "precompiled.h"
#pragma hdrstop
#include "../Game_local.h"
rvmMonsterDemonTrite::rvmMonsterDemonTrite() {
explode = false;
nextDodge = 0.0f;
nextLeap = 0.0f;
painNextTime = 0.0f;
jumpVelocity = vec3_zero;
combat_node = NULL;
}
void rvmMonsterDemonTrite::Init( idAI* aiOwner ) {
rvmMonsterBase::Init( aiOwner );
run_distance = TRITE_RUNDISTANCE;
walk_turn = TRITE_WALKTURN;
explode = GetIntKey( "no_explode" ) == 0;
SetState( "state_Begin" );
}
stateResult_t rvmMonsterDemonTrite::RunStateByName( const char* stateName, stateParms_t* parms ) {
AI_DISPATCH_STATE( "Torso_Idle", Torso_Idle );
AI_DISPATCH_STATE( "Torso_Pain", Torso_Pain );
AI_DISPATCH_STATE( "Torso_MeleeAttack", Torso_MeleeAttack );
AI_DISPATCH_STATE( "Torso_LeapAttack", Torso_LeapAttack );
AI_DISPATCH_STATE( "Torso_Walk", Torso_Walk );
AI_DISPATCH_STATE( "Torso_Run", Torso_Run );
AI_DISPATCH_STATE( "Torso_DodgeLeft", Torso_DodgeLeft );
AI_DISPATCH_STATE( "Torso_DodgeRight", Torso_DodgeRight );
AI_DISPATCH_STATE( "state_Begin", state_Begin );
AI_DISPATCH_STATE( "state_Idle", state_Idle );
AI_DISPATCH_STATE( "combat_leap", combat_leap );
AI_DISPATCH_STATE( "combat_melee", combat_melee );
AI_DISPATCH_STATE( "combat_dodge_left", combat_dodge_left );
AI_DISPATCH_STATE( "combat_dodge_right", combat_dodge_right );
AI_DISPATCH_STATE( "path_jump", path_jump );
AI_DISPATCH_STATE( "state_LostCombat", state_LostCombat );
AI_DISPATCH_STATE( "state_Explode", state_Explode );
AI_DISPATCH_STATE( "combat_explode", combat_explode );
AI_DISPATCH_STATE( "state_Killed", state_Killed );
return rvmMonsterBase::RunStateByName( stateName, parms );
}
stateResult_t rvmMonsterDemonTrite::Torso_Idle( stateParms_t* parms ) {
if ( parms->stage == 0 ) { IdleAnim( ANIMCHANNEL_TORSO, "idle" ); parms->stage = 1; }
if ( Pain() ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Pain", 0 ); return SRESULT_DONE; }
if ( run && MovingForward() ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Run", 4 ); return SRESULT_DONE; }
if ( MovingForward() ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Walk", 4 ); return SRESULT_DONE; }
return SRESULT_WAIT;
}
stateResult_t rvmMonsterDemonTrite::Torso_Pain( stateParms_t* parms ) {
enum { STAGE_START, STAGE_RUNNING };
switch ( parms->stage ) {
case STAGE_START:
PlayAnim( ANIMCHANNEL_TORSO, GetPainAnim() );
painNextTime = DelayTime( 0.25f );
parms->stage = STAGE_RUNNING;
return SRESULT_WAIT;
case STAGE_RUNNING:
if ( Pain() && Time() > painNextTime ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Pain", 0 ); return SRESULT_DONE; }
if ( AnimDone( ANIMCHANNEL_TORSO, 2 ) ) {
FinishAction( "pain" );
SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", 2 );
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
stateResult_t rvmMonsterDemonTrite::Torso_MeleeAttack( stateParms_t* parms ) {
enum { STAGE_START, STAGE_RUNNING };
switch ( parms->stage ) {
case STAGE_START:
PlayAnim( ANIMCHANNEL_TORSO, "melee_attack" );
parms->stage = STAGE_RUNNING;
return SRESULT_WAIT;
case STAGE_RUNNING:
if ( AnimDone( ANIMCHANNEL_TORSO, 4 ) ) {
FinishAction( "melee_attack" );
SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", 4 );
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
stateResult_t rvmMonsterDemonTrite::Torso_LeapAttack( stateParms_t* parms ) {
enum { STAGE_START, STAGE_START_WAIT, STAGE_LOOP, STAGE_END_WAIT };
switch ( parms->stage ) {
case STAGE_START:
OverrideAnim( ANIMCHANNEL_LEGS );
PreventPain( 1.0f );
PlayAnim( ANIMCHANNEL_TORSO, "jump_start" );
parms->stage = STAGE_START_WAIT;
return SRESULT_WAIT;
case STAGE_START_WAIT:
if ( !AnimDone( ANIMCHANNEL_TORSO, 0 ) ) { return SRESULT_WAIT; }
FinishAction( "leap_attack_start" );
AttackBegin( "melee_triteLeapAttack" );
SetLinearVelocity( jumpVelocity );
PlayCycle( ANIMCHANNEL_TORSO, "jump_loop" );
parms->stage = STAGE_LOOP;
return SRESULT_WAIT;
case STAGE_LOOP:
if ( owner && !owner->AI_ONGROUND ) { return SRESULT_WAIT; }
AttackEnd();
PlayAnim( ANIMCHANNEL_TORSO, "jump_end" );
parms->stage = STAGE_END_WAIT;
return SRESULT_WAIT;
case STAGE_END_WAIT:
if ( AnimDone( ANIMCHANNEL_TORSO, 4 ) ) {
FinishAction( "leap_attack" );
SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", 4 );
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
stateResult_t rvmMonsterDemonTrite::Torso_Walk( stateParms_t* parms ) {
if ( parms->stage == 0 ) { PlayCycle( ANIMCHANNEL_TORSO, "walk" ); parms->stage = 1; }
if ( Pain() ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Pain", 0 ); return SRESULT_DONE; }
if ( run && MovingForward() ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Run", 4 ); return SRESULT_DONE; }
if ( !MovingForward() ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", 4 ); return SRESULT_DONE; }
return SRESULT_WAIT;
}
stateResult_t rvmMonsterDemonTrite::Torso_Run( stateParms_t* parms ) {
if ( parms->stage == 0 ) { PlayCycle( ANIMCHANNEL_TORSO, "run" ); parms->stage = 1; }
if ( Pain() ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Pain", 0 ); return SRESULT_DONE; }
if ( !run && MovingForward() ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Walk", 4 ); return SRESULT_DONE; }
if ( !MovingForward() ) { SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", 4 ); return SRESULT_DONE; }
return SRESULT_WAIT;
}
stateResult_t rvmMonsterDemonTrite::Torso_DodgeLeft( stateParms_t* parms ) {
if ( parms->stage == 0 ) { PlayAnim( ANIMCHANNEL_TORSO, "evade_left" ); parms->stage = 1; }
if ( AnimDone( ANIMCHANNEL_TORSO, 4 ) ) { FinishAction( "strafe" ); SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", 4 ); return SRESULT_DONE; }
return SRESULT_WAIT;
}
stateResult_t rvmMonsterDemonTrite::Torso_DodgeRight( stateParms_t* parms ) {
if ( parms->stage == 0 ) { PlayAnim( ANIMCHANNEL_TORSO, "evade_right" ); parms->stage = 1; }
if ( AnimDone( ANIMCHANNEL_TORSO, 4 ) ) { FinishAction( "strafe" ); SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", 4 ); return SRESULT_DONE; }
return SRESULT_WAIT;
}
stateResult_t rvmMonsterDemonTrite::state_Begin( stateParms_t* parms ) {
enum { STAGE_START, STAGE_MONSTER_BEGIN };
switch ( parms->stage ) {
case STAGE_START:
SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", 0 );
StartAction( "monster_begin" );
parms->stage = STAGE_MONSTER_BEGIN;
return SRESULT_WAIT;
case STAGE_MONSTER_BEGIN:
if ( InAction() ) { return SRESULT_WAIT; }
SetMoveType( MOVETYPE_ANIM );
SetState( "state_Idle" );
return SRESULT_DONE;
}
return SRESULT_ERROR;
}
stateResult_t rvmMonsterDemonTrite::state_Idle( stateParms_t* parms ) {
enum { STAGE_START, STAGE_WAIT_FOR_ENEMY };
switch ( parms->stage ) {
case STAGE_START:
StartAction( "wait_for_enemy" );
parms->stage = STAGE_WAIT_FOR_ENEMY;
return SRESULT_WAIT;
case STAGE_WAIT_FOR_ENEMY:
if ( InAction() ) { return SRESULT_WAIT; }
nextLeap = RandomTime( TRITE_LEAP_RATE );
nextDodge = RandomTime( TRITE_DODGE_RATE );
SetState( "state_Combat" );
return SRESULT_DONE;
}
return SRESULT_ERROR;
}
int rvmMonsterDemonTrite::check_attacks() {
int flags = 0;
const bool canMelee = CheckForMelee();
const float currentTime = Time();
if ( !canMelee && Pain() && currentTime >= nextDodge ) {
if ( TestAnimMove( "evade_left" ) ) { flags |= ATTACK_DODGE_LEFT; }
if ( TestAnimMove( "evade_right" ) ) {
flags |= ATTACK_DODGE_RIGHT;
if ( flags & ATTACK_DODGE_LEFT ) {
if ( RandomFloat( 100.0f ) < 50.0f ) { flags &= ~ATTACK_DODGE_RIGHT; } else { flags &= ~ATTACK_DODGE_LEFT; }
}
}
}
if ( !canMelee ) {
combat_node = GetCombatNode();
if ( combat_node.GetEntity() ) { flags |= ATTACK_COMBAT_NODE; }
}
if ( canMelee ) { flags |= ATTACK_MELEE; }
if ( EnemyInFOV() ) {
const float range = EnemyRange();
if ( range >= TRITE_LEAP_RANGE_MIN && range < TRITE_LEAP_RANGE_MAX && currentTime >= nextLeap && CanHitEnemy() ) {
const float t = AnimLength( ANIMCHANNEL_TORSO, "jump_start" );
const idVec3 jumpTarget = PredictEnemyPos( t );
jumpVelocity = GetJumpVelocity( jumpTarget, TRITE_LEAP_SPEED, TRITE_LEAP_MAXHEIGHT );
if ( jumpVelocity.LengthSqr() > 0.001f ) { flags |= ATTACK_LEAP; } else { nextLeap = DelayTime( 2.0f ); }
}
}
return static_cast<float>( flags );
}
bool rvmMonsterDemonTrite::do_attack( int attack_flags ) {
const int flags = attack_flags;
if ( flags & ATTACK_DODGE_LEFT ) { StartAction( "combat_dodge_left" ); return true; }
if ( flags & ATTACK_DODGE_RIGHT ) { StartAction( "combat_dodge_right" ); return true; }
if ( flags & ATTACK_COMBAT_NODE ) { scratchEntity = combat_node.GetEntity(); StartAction( "combat_ainode" ); return true; }
if ( flags & ATTACK_MELEE ) { StartAction( "combat_melee" ); return true; }
if ( flags & ATTACK_LEAP ) { StartAction( "combat_leap" ); return true; }
return false;
}
stateResult_t rvmMonsterDemonTrite::combat_leap( stateParms_t* parms ) {
enum { STAGE_START, STAGE_ACTION };
switch ( parms->stage ) {
case STAGE_START:
StopMove();
TurnToPos( GetOrigin() + jumpVelocity );
waitActionName = "leap_attack";
SetAnimState( ANIMCHANNEL_TORSO, "Torso_LeapAttack", 4 );
parms->stage = STAGE_ACTION;
return SRESULT_WAIT;
case STAGE_ACTION:
if ( !ActionDone( "leap_attack" ) ) { return SRESULT_WAIT; }
nextLeap = DelayTime( TRITE_LEAP_RATE );
return SRESULT_DONE;
}
return SRESULT_ERROR;
}
stateResult_t rvmMonsterDemonTrite::combat_melee( stateParms_t* parms ) {
enum { STAGE_START, STAGE_ACTION };
switch ( parms->stage ) {
case STAGE_START:
LookAtEnemy( 100.0f );
FaceEnemy();
waitActionName = "melee_attack";
SetAnimState( ANIMCHANNEL_TORSO, "Torso_MeleeAttack", 5 );
parms->stage = STAGE_ACTION;
return SRESULT_WAIT;
case STAGE_ACTION:
if ( !ActionDone( "melee_attack" ) ) { return SRESULT_WAIT; }
LookAtEnemy( 1.0f );
return SRESULT_DONE;
}
return SRESULT_ERROR;
}
stateResult_t rvmMonsterDemonTrite::combat_dodge_left( stateParms_t* parms ) {
enum { STAGE_START, STAGE_ACTION };
switch ( parms->stage ) {
case STAGE_START:
StopMove();
FaceEnemy();
waitActionName = "strafe";
SetAnimState( ANIMCHANNEL_TORSO, "Torso_DodgeLeft", 2 );
parms->stage = STAGE_ACTION;
return SRESULT_WAIT;
case STAGE_ACTION:
if ( !ActionDone( "strafe" ) ) { return SRESULT_WAIT; }
nextDodge = DelayTime( TRITE_DODGE_RATE );
return SRESULT_DONE;
}
return SRESULT_ERROR;
}
stateResult_t rvmMonsterDemonTrite::combat_dodge_right( stateParms_t* parms ) {
enum { STAGE_START, STAGE_ACTION };
switch ( parms->stage ) {
case STAGE_START:
StopMove();
FaceEnemy();
waitActionName = "strafe";
SetAnimState( ANIMCHANNEL_TORSO, "Torso_DodgeRight", 2 );
parms->stage = STAGE_ACTION;
return SRESULT_WAIT;
case STAGE_ACTION:
if ( !ActionDone( "strafe" ) ) { return SRESULT_WAIT; }
nextDodge = DelayTime( TRITE_DODGE_RATE );
return SRESULT_DONE;
}
return SRESULT_ERROR;
}
stateResult_t rvmMonsterDemonTrite::path_jump( stateParms_t* parms ) {
enum { STAGE_PATH_CORNER, STAGE_SETUP, STAGE_TURN, STAGE_LEAP, STAGE_DONE };
idEntity* path = current_path.GetEntity();
switch ( parms->stage ) {
case STAGE_PATH_CORNER:
StartAction( "path_corner" );
parms->stage = STAGE_SETUP;
return SRESULT_WAIT;
case STAGE_SETUP: {
if ( InAction() ) { return SRESULT_WAIT; }
if ( checkForEnemy( true ) ) { return SRESULT_DONE; }
idEntity* target = RandomPathFrom( path );
if ( !target ) { return SRESULT_DONE; }
scratchEntity = target;
const idVec3 jumpTarget = target->GetPhysics()->GetOrigin();
if ( path && path->spawnArgs.GetString( "up", "" )[0] ) {
float forward = path->spawnArgs.GetFloat( "forward", "0" );
idVec3 dir = jumpTarget - GetOrigin();
dir.z = 0.0f;
dir.Normalize();
jumpVelocity = dir * forward;
jumpVelocity.z = path->spawnArgs.GetFloat( "up", "0" );
} else {
jumpVelocity = GetJumpVelocity( jumpTarget, TRITE_LEAP_SPEED, 1024.0f );
}
StopMove();
TurnToPos( jumpTarget );
parms->stage = STAGE_TURN;
return SRESULT_WAIT;
}
case STAGE_TURN:
if ( checkForEnemy( true ) ) { return SRESULT_DONE; }
if ( !FacingIdeal() ) { return SRESULT_WAIT; }
waitActionName = "leap_attack";
SetAnimState( ANIMCHANNEL_TORSO, "Torso_LeapAttack", 4 );
parms->stage = STAGE_LEAP;
return SRESULT_WAIT;
case STAGE_LEAP:
if ( !ActionDone( "leap_attack" ) ) { return SRESULT_WAIT; }
StopMove();
return SRESULT_DONE;
}
return SRESULT_ERROR;
}
stateResult_t rvmMonsterDemonTrite::combat_explode( stateParms_t* parms ) {
enum { STAGE_START, STAGE_LAUNCH, STAGE_MONITOR };
switch ( parms->stage ) {
case STAGE_START: {
const float t = AnimLength( ANIMCHANNEL_TORSO, "jump_start" );
const idVec3 enemyOrg = PredictEnemyPos( t );
const idVec3 org = GetOrigin();
float maxHeight = ( enemyOrg.z > org.z + 32.0f ) ? enemyOrg.z : ( org.z + 32.0f );
idVec3 vel = enemyOrg - org;
vel.Normalize();
vel *= 320.0f;
vel.z = idMath::Sqrt( ( 2.0f * ( maxHeight - org.z ) * 1066.0f ) > 0.0f ? ( 2.0f * ( maxHeight - org.z ) * 1066.0f ) : 0.0f );
jumpVelocity = vel;
scratchEndTime = maxHeight;
StopMove();
FaceEnemy();
waitActionName = "leap_attack_start";
SetAnimState( ANIMCHANNEL_TORSO, "Torso_LeapAttack", 4 );
parms->stage = STAGE_LAUNCH;
return SRESULT_WAIT;
}
case STAGE_LAUNCH:
if ( !ActionDone( "leap_attack_start" ) ) { return SRESULT_WAIT; }
parms->stage = STAGE_MONITOR;
return SRESULT_WAIT;
case STAGE_MONITOR: {
const idVec3 org = GetOrigin();
const idVec3 enemyOrg = GetEnemyPos();
const idVec3 vel = GetLinearVelocity();
if ( org.z > enemyOrg.z || org.z > scratchEndTime || vel.z <= -10.0f || !InAnimState( ANIMCHANNEL_TORSO, "Torso_LeapAttack" ) ) {
SetState( "state_Explode" );
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
}
return SRESULT_ERROR;
}
stateResult_t rvmMonsterDemonTrite::state_LostCombat( stateParms_t* parms ) {
enum { STAGE_START, STAGE_CHASE, STAGE_WANDER };
switch ( parms->stage ) {
case STAGE_START:
if ( !explode ) { monster_base_lost_combat(); return SRESULT_DONE; }
MoveToEnemy();
scratchEndTime = DelayTime( 1.5f );
parms->stage = STAGE_CHASE;
return SRESULT_WAIT;
case STAGE_CHASE: {
if ( CanReachEnemy() ) { SetState( "state_Combat" ); return SRESULT_DONE; }
if ( EnemyRange() < TRITE_EXPLOSION_RADIUS ) { StartAction( "combat_explode" ); return SRESULT_WAIT; }
const int flags = check_attacks();
if ( flags & ATTACK_LEAP ) { StartAction( "combat_explode" ); return SRESULT_WAIT; }
if ( flags ) { SetState( "state_Combat" ); return SRESULT_DONE; }
if ( MoveDone() ) { Wander(); parms->stage = STAGE_WANDER; }
return SRESULT_WAIT;
}
case STAGE_WANDER:
if ( CanReachEnemy() || Time() >= scratchEndTime ) { SetState( "state_Combat" ); return SRESULT_DONE; }
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
stateResult_t rvmMonsterDemonTrite::state_Explode( stateParms_t* parms ) {
enum { STAGE_START, STAGE_REMOVE };
switch ( parms->stage ) {
case STAGE_START:
RadiusDamageFromJoint( "", GetKey( "def_explode_damage", "damage_trite_explode" ) );
StartSoundKey( "snd_explode", SND_CHANNEL_BODY, false );
if ( owner ) { owner->ActivateTargets( owner ); }
HideOwner();
scratchEndTime = DelayTime( 5.0f );
parms->stage = STAGE_REMOVE;
return SRESULT_WAIT;
case STAGE_REMOVE:
if ( Time() < scratchEndTime ) { return SRESULT_WAIT; }
RemoveOwner();
return SRESULT_DONE;
}
return SRESULT_ERROR;
}
stateResult_t rvmMonsterDemonTrite::state_Killed( stateParms_t* parms ) {
StopMove();
SetAnimState( ANIMCHANNEL_TORSO, "Torso_Death", 0 );
SetAnimState( ANIMCHANNEL_LEGS, "Legs_Death", 0 );
waitActionName = "dead";
SetState( "state_Dead" );
return SRESULT_DONE;
}
Reference in New Issue View Git Blame Copy Permalink