// asw - test always advancing the frames
void C_ASW_Alien::ASWUpdateClientSideAnimation()
{
if ( GetSequence() != -1 )
{
// latch old values
//OnLatchInterpolatedVariables( LATCH_ANIMATION_VAR );
// move frame forward
//FrameAdvance( 0.0f ); // 0 means to use the time we last advanced instead of a constant
CStudioHdr *hdr = GetModelPtr();
float cyclerate = hdr ? GetSequenceCycleRate( hdr, GetSequence() ) : 1.0f;
float addcycle = gpGlobals->frametime * cyclerate * m_flPlaybackRate;
float flNewCycle = GetCycle() + addcycle;
m_flAnimTime = gpGlobals->curtime;
if ( (flNewCycle < 0.0f) || (flNewCycle >= 1.0f) )
{
if (flNewCycle >= 1.0f) // asw
ReachedEndOfSequence(); // asw
if ( IsSequenceLooping( hdr, GetSequence() ) )
{
flNewCycle -= (int)(flNewCycle);
}
else
{
flNewCycle = (flNewCycle < 0.0f) ? 0.0f : 1.0f;
}
}
SetCycle( flNewCycle );
}
}
void CAnimating::ResetSequenceInfo()
{
if (GetSequence() == -1)
{
// This shouldn't happen. Setting m_nSequence blindly is a horrible coding practice.
SetSequence( 0 );
}
CStudioHdr *pStudioHdr = GetModelPtr();
m_flGroundSpeed = GetSequenceGroundSpeed( pStudioHdr, GetSequence() );
m_bSequenceLoops = ((GetSequenceFlags( pStudioHdr, GetSequence() ) & STUDIO_LOOPING) != 0);
// m_flAnimTime = gpGlobals->time;
m_flPlaybackRate = 1.0;
m_bSequenceFinished = false;
m_flLastEventCheck = 0;
m_nNewSequenceParity = ( *(m_nNewSequenceParity)+1 ) & EF_PARITY_MASK;
m_nResetEventsParity = ( *(m_nResetEventsParity)+1 ) & EF_PARITY_MASK;
// FIXME: why is this called here? Nothing should have changed to make this nessesary
if ( pStudioHdr )
{
SetEventIndexForSequence( pStudioHdr->pSeqdesc( GetSequence() ) );
}
}
void C_ASW_Simple_Drone::ClientThink()
{
BaseClass::ClientThink();
if (GetSequence() == LookupSequence("run_idle")
|| GetSequence() == LookupSequence("lunge_attack"))
UpdatePoseParams();
}
//=========================================================
// Retire - stop being active
//=========================================================
void CNPC_BaseTurret::Retire(void)
{
// make the turret level
m_vecGoalAngles.x = 0;
m_vecGoalAngles.y = m_flStartYaw;
SetNextThink( gpGlobals->curtime + 0.1 );
StudioFrameAdvance( );
EyeOff( );
if (!MoveTurret())
{
if (m_iSpin)
{
SpinDownCall();
}
else if (GetSequence() != TURRET_ANIM_RETIRE)
{
SetTurretAnim(TURRET_ANIM_RETIRE);
CPASAttenuationFilter filter( this );
EmitSound( filter, entindex(), "Turret.Undeploy" );
m_OnDeactivate.FireOutput(this, this);
}
//else if (IsSequenceFinished())
else if( GetSequence() == TURRET_ANIM_RETIRE && GetCycle() <= 0.0 )
{
m_iOn = 0;
m_flLastSight = 0;
//SetTurretAnim(TURRET_ANIM_NONE);
Vector curmins, curmaxs;
curmins = WorldAlignMins();
curmaxs = WorldAlignMaxs();
curmaxs.z = m_iRetractHeight;
curmins.z = -m_iRetractHeight;
SetCollisionBounds( curmins, curmaxs );
if (m_iAutoStart)
{
SetThink(&CNPC_BaseTurret::AutoSearchThink);
SetNextThink( gpGlobals->curtime + 0.1 );
}
else
{
SetThink( &CBaseEntity::SUB_DoNothing );
}
}
}
else
{
SetTurretAnim(TURRET_ANIM_SPIN);
}
}
void SequencedOutputDatagramChannel::WritePacket(const std::vector<uint8_t>& packet)
{
// copy packet and write it back
std::vector<uint8_t> nextPacket(packet.size() + 4);
memcpy(&nextPacket[4], &packet[0], nextPacket.size());
// write sequence to the packet
SetSequence(GetSequence() + 1);
*reinterpret_cast<uint32_t*>(&nextPacket[0]) = GetSequence();
GetSink()->WritePacket(nextPacket);
}
// process certificate header, set signature offset
void CertDecoder::ReadHeader()
{
if (source_.GetError().What()) return;
GetSequence(); // total
certBegin_ = source_.get_index();
sigIndex_ = GetSequence(); // this cert
sigIndex_ += source_.get_index();
GetExplicitVersion(); // version
GetInteger(Integer().Ref()); // serial number
}
unsigned int C_DynamicProp::ComputeClientSideAnimationFlags()
{
if ( GetSequence() != -1 )
{
CStudioHdr *pStudioHdr = GetModelPtr();
if ( GetSequenceCycleRate(pStudioHdr, GetSequence()) != 0.0f )
{
return BaseClass::ComputeClientSideAnimationFlags();
}
}
// no sequence or no cycle rate, don't do any per-frame calcs
return 0;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output :
//-----------------------------------------------------------------------------
float CAnimating::GetInstantaneousVelocity( float flInterval )
{
CStudioHdr *pstudiohdr = GetModelPtr( );
if (! pstudiohdr)
return 0;
// FIXME: someone needs to check for last frame, etc.
float flNextCycle = GetCycle() + flInterval * GetSequenceCycleRate( GetSequence() ) * m_flPlaybackRate;
Vector vecVelocity;
Studio_SeqVelocity( pstudiohdr, GetSequence(), flNextCycle, GetPoseParameterArray(), vecVelocity );
vecVelocity *= m_flPlaybackRate;
return vecVelocity.Length();
}
// Read public key
void CertDecoder::GetKey()
{
if (source_.GetError().What()) return;
GetSequence();
keyOID_ = GetAlgoId();
if (keyOID_ == RSAk) {
byte b = source_.next();
if (b != BIT_STRING) {
source_.SetError(BIT_STR_E);
return;
}
b = source_.next(); // length, future
b = source_.next();
while(b != 0)
b = source_.next();
}
else if (keyOID_ == DSAk)
; // do nothing
else {
source_.SetError(UNKNOWN_OID_E);
return;
}
StoreKey();
if (keyOID_ == DSAk)
AddDSA();
}
// Decode a BER encoded PKCS12 structure
void PKCS12_Decoder::Decode()
{
ReadHeader();
if (source_.GetError().What()) return;
// Get AuthSafe
GetSequence();
// get object id
byte obj_id = source_.next();
if (obj_id != OBJECT_IDENTIFIER) {
source_.SetError(OBJECT_ID_E);
return;
}
word32 length = GetLength(source_);
word32 algo_sum = 0;
while (length--)
algo_sum += source_.next();
// Get MacData optional
/*
mac digestInfo like certdecoder::getdigest?
macsalt octet string
iter integer
*/
}
void FMovieSceneSequenceInstance::OnSpawnedObjectDestroyed(const FGuid& ObjectId, IMovieScenePlayer& Player)
{
if(MovieSceneSequence.IsValid())
{
auto* BindingInstance = ObjectBindingInstances.Find(ObjectId);
if (!BindingInstance)
{
return;
}
SpawnedObjects.Remove(ObjectId);
// Destroy the object
BindingInstance->RuntimeObjects.Reset();
// Update any child possessable object bindings
UMovieSceneSequence* Sequence = GetSequence();
FMovieSceneSpawnable* Spawnable = Sequence ? Sequence->GetMovieScene()->FindSpawnable(ObjectId) : nullptr;
if (Spawnable)
{
for (const FGuid& Child : Spawnable->GetChildPossessables())
{
UpdateObjectBinding(Child, Player);
}
}
}
}
void FMovieSceneSequenceInstance::OnObjectSpawned(const FGuid& ObjectId, UObject& SpawnedObject, IMovieScenePlayer& Player)
{
if(MovieSceneSequence.IsValid())
{
auto* BindingInstance = ObjectBindingInstances.Find(ObjectId);
if (!BindingInstance)
{
return;
}
SpawnedObjects.Add(ObjectId, &SpawnedObject);
// Add it to the instance's runtime objects array, and update any child possessable binding instances
BindingInstance->RuntimeObjects.Reset();
BindingInstance->RuntimeObjects.Emplace(&SpawnedObject);
UMovieSceneSequence* Sequence = GetSequence();
FMovieSceneSpawnable* Spawnable = Sequence ? Sequence->GetMovieScene()->FindSpawnable(ObjectId) : nullptr;
if (Spawnable)
{
UpdateObjectBinding(ObjectId, Player);
for (const FGuid& Child : Spawnable->GetChildPossessables())
{
UpdateObjectBinding(Child, Player);
}
}
}
}
// process algo OID by summing, return it
word32 CertDecoder::GetAlgoId()
{
if (source_.GetError().What()) return 0;
word32 length = GetSequence();
if (source_.GetError().What()) return 0;
byte b = source_.next();
if (b != OBJECT_IDENTIFIER) {
source_.SetError(OBJECT_ID_E);
return 0;
}
length = GetLength(source_);
if (source_.IsLeft(length) == false) return 0;
word32 oid = 0;
while(length--)
oid += source_.next(); // just sum it up for now
// could have NULL tag and 0 terminator, but may not
b = source_.next();
if (b == TAG_NULL) {
b = source_.next();
if (b != 0) {
source_.SetError(EXPECT_0_E);
return 0;
}
}
else
// go back, didn't have it
b = source_.prev();
return oid;
}
void CNPC_GMan::RunTask( const Task_t *pTask )
{
switch( pTask->iTask )
{
case TASK_WAIT:
// look at who I'm talking to
if (m_flTalkTime > gpGlobals->curtime && m_hTalkTarget != NULL)
{
AddLookTarget( m_hTalkTarget->GetAbsOrigin(), 1.0, 2.0 );
}
// look at player, but only if playing a "safe" idle animation
else if (m_hPlayer != NULL && (GetSequence() == 0 || IsInC5A1()) )
{
AddLookTarget( m_hPlayer->EyePosition(), 1.0, 3.0 );
}
else
{
// Just center the head forward.
Vector forward;
GetVectors( &forward, NULL, NULL );
AddLookTarget( GetAbsOrigin() + forward * 12.0f, 1.0, 1.0 );
SetBoneController( 0, 0 );
}
BaseClass::RunTask( pTask );
break;
}
SetBoneController( 0, 0 );
BaseClass::RunTask( pTask );
}
//-----------------------------------------------------------------------------
// Purpose: find the anim events that may have started sounds, and stop them.
//-----------------------------------------------------------------------------
void C_BaseObject::StopAnimGeneratedSounds( void )
{
MDLCACHE_CRITICAL_SECTION();
CStudioHdr *pStudioHdr = GetModelPtr();
if ( !pStudioHdr )
return;
mstudioseqdesc_t &seqdesc = pStudioHdr->pSeqdesc( GetSequence() );
float flCurrentCycle = GetCycle();
mstudioevent_t *pevent = GetEventIndexForSequence( seqdesc );
for (int i = 0; i < (int)seqdesc.numevents; i++)
{
if ( pevent[i].cycle < flCurrentCycle )
{
if ( pevent[i].event == CL_EVENT_SOUND || pevent[i].event == AE_CL_PLAYSOUND )
{
StopSound( entindex(), pevent[i].options );
}
}
}
}
// process algo OID by summing, return it
word32 CertDecoder::GetAlgoId()
{
if (source_.GetError().What()) return 0;
word32 length = GetSequence();
byte b = source_.next();
if (b != OBJECT_IDENTIFIER) {
source_.SetError(OBJECT_ID_E);
return 0;
}
length = GetLength(source_);
word32 oid = 0;
while(length--)
oid += source_.next(); // just sum it up for now
if (oid != SHAwDSA && oid != DSAk) {
b = source_.next(); // should have NULL tag and 0
if (b != TAG_NULL) {
source_.SetError(TAG_NULL_E);
return 0;
}
b = source_.next();
if (b != 0) {
source_.SetError(EXPECT_0_E);
return 0;
}
}
return oid;
}
void CDAViewModel::PauseAnimation()
{
m_bPaused = true;
m_flPauseCycle = GetCycle();
m_nPauseSequence = GetSequence();
m_flPauseAnimTime = GetAnimTime();
}
//-----------------------------------------------------------------------------
// implements these so ragdolls can handle frustum culling & leaf visibility
//-----------------------------------------------------------------------------
void C_DynamicProp::GetRenderBounds( Vector& theMins, Vector& theMaxs )
{
if ( m_bUseHitboxesForRenderBox )
{
if ( GetModel() )
{
studiohdr_t *pStudioHdr = modelinfo->GetStudiomodel( GetModel() );
if ( !pStudioHdr || GetSequence() == -1 )
{
theMins = vec3_origin;
theMaxs = vec3_origin;
return;
}
// Only recompute if it's a new frame
if ( gpGlobals->framecount != m_iCachedFrameCount )
{
ComputeEntitySpaceHitboxSurroundingBox( &m_vecCachedRenderMins, &m_vecCachedRenderMaxs );
m_iCachedFrameCount = gpGlobals->framecount;
}
theMins = m_vecCachedRenderMins;
theMaxs = m_vecCachedRenderMaxs;
return;
}
}
BaseClass::GetRenderBounds( theMins, theMaxs );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_NPC_Puppet::ClientThink( void )
{
if ( m_hAnimationTarget == NULL )
return;
C_BaseAnimating *pTarget = m_hAnimationTarget->GetBaseAnimating();
if ( pTarget == NULL )
return;
int nTargetSequence = pTarget->GetSequence();
const char *pSequenceName = pTarget->GetSequenceName( nTargetSequence );
int nSequence = LookupSequence( pSequenceName );
if ( nSequence >= 0 )
{
if ( nSequence != GetSequence() )
{
SetSequence( nSequence );
UpdateVisibility();
}
SetCycle( pTarget->GetCycle() );
SetPlaybackRate( pTarget->GetPlaybackRate() );
}
}
//-----------------------------------------------------------------------------
// Purpose: Start playing personality VO list
//-----------------------------------------------------------------------------
void CPropGladosCore::TalkingThink( void )
{
if ( m_speechEvents.Count() <= 0 || !m_speechEvents.IsValidIndex( m_iSpeechIter ) )
{
SetThink ( NULL );
SetNextThink( gpGlobals->curtime );
return;
}
// Loop the 'look around' animation after the first line.
int iCurSequence = GetSequence();
int iLookSequence = LookupSequence( STRING(m_iszLookAnimationName) );
if ( iCurSequence != iLookSequence && m_iSpeechIter > 0 )
{
ResetSequence( iLookSequence );
}
int iPrevIter = m_iSpeechIter-1;
if ( iPrevIter < 0 )
iPrevIter = 0;
StopSound( m_speechEvents[iPrevIter].ToCStr() );
float flCurDuration = GetSoundDuration( m_speechEvents[m_iSpeechIter].ToCStr(), GLADOS_CORE_MODEL_NAME );
EmitSound( m_speechEvents[m_iSpeechIter].ToCStr() );
SetNextThink( gpGlobals->curtime + m_flBetweenVOPadding + flCurDuration );
// wrap if we hit the end of the list
m_iSpeechIter = (m_iSpeechIter+1)%m_speechEvents.Count();
}
// If the local player is visible (thirdperson mode, tf2 taunts, etc., then make sure that we are using the
// w_ (world) model not the v_ (view) model or else the model can flicker, etc.
// Otherwise, if we're not the local player, always use the world model
void C_BaseCombatWeapon::EnsureCorrectRenderingModel()
{
C_BasePlayer *localplayer = C_BasePlayer::GetLocalPlayer();
if ( localplayer &&
localplayer == GetOwner() &&
!localplayer->ShouldDrawLocalPlayer() )
{
return;
}
MDLCACHE_CRITICAL_SECTION();
// BRJ 10/14/02
// FIXME: Remove when Yahn's client-side prediction is done
// It's a hacky workaround for the model indices fighting
// (GetRenderBounds uses the model index, which is for the view model)
SetModelIndex( GetWorldModelIndex() );
// Validate our current sequence just in case ( in theory the view and weapon models should have the same sequences for sequences that overlap at least )
CStudioHdr *pStudioHdr = GetModelPtr();
if ( pStudioHdr &&
GetSequence() >= pStudioHdr->GetNumSeq() )
{
SetSequence( 0 );
}
}
void IlluminateButton( uint8_t theId )
{
volatile t_ATime* KeyTimer = GetKeyTimer( theId );
volatile uint8_t* SequenceState = GetSequenceState( theId );
if ( ( MaturedTimer( KeyTimer ) ) || ( SequenceState == 0 ) )
{
volatile t_Sequences Sequence = GetSequence( theId );
switch ( GetColour( Sequence, SequenceState, KeyTimer ) )
{
case e_Off:
ColourNone( theId );
break;
case e_ColourA:
ColourA( theId );
break;
case e_ColourB:
ColourB( theId );
break;
}
}
}
void CASW_Weapon_Minigun::UpdateSpinningBarrel()
{
if (GetSequenceActivity(GetSequence()) != ACT_VM_PRIMARYATTACK)
{
SetActivity(ACT_VM_PRIMARYATTACK, 0);
}
m_flPlaybackRate = GetSpinRate();
if ( GetSpinRate() > 0.0f )
{
if( !m_pBarrelSpinSound )
{
CPASAttenuationFilter filter( this );
m_pBarrelSpinSound = CSoundEnvelopeController::GetController().SoundCreate( filter, entindex(), "ASW_Minigun.Spin" );
CSoundEnvelopeController::GetController().Play( m_pBarrelSpinSound, 0.0, 100 );
}
CSoundEnvelopeController::GetController().SoundChangeVolume( m_pBarrelSpinSound, MIN( 1.0f, m_flPlaybackRate * 3.0f ), 0.0f );
CSoundEnvelopeController::GetController().SoundChangePitch( m_pBarrelSpinSound, asw_minigun_pitch_min.GetFloat() + ( GetSpinRate() * ( asw_minigun_pitch_max.GetFloat() - asw_minigun_pitch_min.GetFloat() ) ), 0.0f );
}
else
{
if ( m_pBarrelSpinSound )
{
CSoundEnvelopeController::GetController().SoundDestroy( m_pBarrelSpinSound );
m_pBarrelSpinSound = NULL;
}
}
}
AIMotorMoveResult_t CAI_BlendedMotor::MoveGroundExecute( const AILocalMoveGoal_t &move, AIMoveTrace_t *pTraceResult )
{
if ( move.curExpectedDist < 0.001 )
{
AIMotorMoveResult_t result = BaseClass::MoveGroundExecute( move, pTraceResult );
// Msg(" BaseClass::MoveGroundExecute() - remaining %.2f\n", GetMoveInterval() );
SetMoveScriptAnim( 0.0 );
return result;
}
BuildMoveScript( move, pTraceResult );
float flNewSpeed = GetCurSpeed();
float flTotalDist = GetMoveScriptDist( flNewSpeed );
//Assert( move.maxDist < 0.01 || flTotalDist > 0.0 );
// --------------------------------------------
// turn in the direction of movement
// --------------------------------------------
float flNewYaw = GetMoveScriptYaw( );
// get facing based on movement yaw
AILocalMoveGoal_t move2 = move;
move2.facing = UTIL_YawToVector( flNewYaw );
// turn in the direction needed
MoveFacing( move2 );
// reset actual "sequence" ground speed based current movement sequence, orientation
// FIXME: this should be based on
GetOuter()->m_flGroundSpeed = GetSequenceGroundSpeed( GetSequence());
/*
if (1 || flNewSpeed > GetIdealSpeed())
{
// DevMsg( "%6.2f : Speed %.1f : %.1f (%.1f) : %d\n", gpGlobals->curtime, flNewSpeed, move.maxDist, move.transitionDist, GetOuter()->m_pHintNode != NULL );
// DevMsg( "%6.2f : Speed %.1f : %.1f\n", gpGlobals->curtime, flNewSpeed, GetIdealSpeed() );
}
*/
SetMoveScriptAnim( flNewSpeed );
/*
if ((GetOuter()->m_debugOverlays & OVERLAY_NPC_SELECTED_BIT))
{
DevMsg( "%6.2f : Speed %.1f : %.1f : %.2f\n", gpGlobals->curtime, flNewSpeed, GetIdealSpeed(), flNewSpeed / GetIdealSpeed() );
}
*/
AIMotorMoveResult_t result = MoveGroundExecuteWalk( move, flNewSpeed, flTotalDist, pTraceResult );
return result;
}
bool C_BaseViewModel::Interpolate( float currentTime )
{
CStudioHdr *pStudioHdr = GetModelPtr();
// Make sure we reset our animation information if we've switch sequences
UpdateAnimationParity();
bool bret = BaseClass::Interpolate( currentTime );
// Hack to extrapolate cycle counter for view model
float elapsed_time = currentTime - m_flAnimTime;
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
// Predicted viewmodels have fixed up interval
if ( GetPredictable() || IsClientCreated() )
{
Assert( pPlayer );
float curtime = pPlayer ? pPlayer->GetFinalPredictedTime() : gpGlobals->curtime;
elapsed_time = curtime - m_flAnimTime;
// Adjust for interpolated partial frame
if ( !engine->IsPaused() )
{
elapsed_time += ( gpGlobals->interpolation_amount * TICK_INTERVAL );
}
}
// Prediction errors?
if ( elapsed_time < 0 )
{
elapsed_time = 0;
}
float dt = elapsed_time * GetSequenceCycleRate( pStudioHdr, GetSequence() ) * GetPlaybackRate();
if ( dt >= 1.0f )
{
if ( !IsSequenceLooping( GetSequence() ) )
{
dt = 0.999f;
}
else
{
dt = fmod( dt, 1.0f );
}
}
SetCycle( dt );
return bret;
}
CSequence *CInstrumentManager::GetSequence(int InstType, int SeqType, int Index) const
{
auto pManager = GetSequenceManager(InstType);
if (!pManager) return nullptr;
auto pCol = pManager->GetCollection(SeqType);
if (!pCol) return nullptr;
return pCol->GetSequence(Index);
}
void CertDecoder::GetValidity()
{
if (source_.GetError().What()) return;
GetSequence();
GetDate(BEFORE);
GetDate(AFTER);
}
bool WaveClip::Clear(double t0, double t1)
{
sampleCount s0, s1;
TimeToSamplesClip(t0, &s0);
TimeToSamplesClip(t1, &s1);
if (GetSequence()->Delete(s0, s1-s0))
{
// msmeyer
//
// Delete all cutlines that are within the given area, if any.
//
// Note that when cutlines are active, two functions are used:
// Clear() and ClearAndAddCutLine(). ClearAndAddCutLine() is called
// whenever the user directly calls a command that removes some audio, e.g.
// "Cut" or "Clear" from the menu. This command takes care about recursive
// preserving of cutlines within clips. Clear() is called when internal
// operations want to remove audio. In the latter case, it is the right
// thing to just remove all cutlines within the area.
//
double clip_t0 = t0;
double clip_t1 = t1;
if (clip_t0 < GetStartTime())
clip_t0 = GetStartTime();
if (clip_t1 > GetEndTime())
clip_t1 = GetEndTime();
WaveClipList::compatibility_iterator nextIt;
for (WaveClipList::compatibility_iterator it = mCutLines.GetFirst(); it; it=nextIt)
{
nextIt = it->GetNext();
WaveClip* clip = it->GetData();
double cutlinePosition = mOffset + clip->GetOffset();
if (cutlinePosition >= t0 && cutlinePosition <= t1)
{
// This cutline is within the area, delete it
delete clip;
mCutLines.DeleteNode(it);
} else
if (cutlinePosition >= t1)
{
clip->Offset(clip_t0-clip_t1);
}
}
// Collapse envelope
GetEnvelope()->CollapseRegion(t0, t1);
if (t0 < GetStartTime())
Offset(-(GetStartTime() - t0));
MarkChanged();
return true;
}
return false;
}
bool DiffLine::FeedIterator(Environment &env, Signal &sig, size_t iSeq, Iterator *pIterator)
{
Sequence &seq = GetSequence(iSeq);
Value value;
while (pIterator->Next(env, value)) {
seq.push_back(value.ToString());
}
return !sig.IsSignalled();
}
void CASW_Queen_Divers::SetBurrowing(bool bBurrowing)
{
if (bBurrowing)
{
SetSolid(SOLID_BBOX);
SetVisible(true);
int iBurrowSeq = LookupSequence("divers_in");
if (GetSequence() != iBurrowSeq)
ResetSequence(iBurrowSeq);
}
else
{
SetSolid(SOLID_NONE);
int iUnburrowSeq = LookupSequence("divers_out");
if (GetSequence() != iUnburrowSeq)
ResetSequence(iUnburrowSeq);
}
}