Serious-Engine/Sources/Entities/Twister.es

507
%{
#include "Entities/StdH/StdH.h"

#define ECF_TWISTER ( \
  ((ECBI_BRUSH|ECBI_MODEL|ECBI_CORPSE|ECBI_ITEM|ECBI_PROJECTILE_MAGIC|ECBI_PROJECTILE_SOLID)<<ECB_TEST) |\
  ((ECBI_MODEL|ECBI_CORPSE|ECBI_ITEM|ECBI_PROJECTILE_MAGIC|ECBI_PROJECTILE_SOLID)<<ECB_PASS) |\
  ((ECBI_MODEL)<<ECB_IS))
#define EPF_TWISTER ( \
  EPF_ONBLOCK_CLIMBORSLIDE|EPF_ORIENTEDBYGRAVITY|\
  EPF_TRANSLATEDBYGRAVITY|EPF_MOVABLE)
%}


uses "Entities/Elemental";


enum TwisterSize {
  0 TWS_SMALL       "",     // small twister
  1 TWS_BIG         "",     // big twister
  2 TWS_LARGE       "",     // large twister
};


// input parameter for twister
event ETwister {
  CEntityPointer penOwner,        // entity which owns it
  enum TwisterSize EtsSize,       // twister size
};


%{
static EntityInfo eiTwister = {
  EIBT_AIR, 0.0f,
  0.0f, 1.0f, 0.0f,
  0.0f, 0.75f, 0.0f,
};


#define MOVE_FREQUENCY 0.1f
#define ROTATE_SPEED 10000.0f
#define MOVE_SPEED 7.5f
%}

class CTwister : CMovableModelEntity {
name      "Twister";
thumbnail "";

properties:
  1 CEntityPointer m_penOwner,                  // entity which owns it
  2 enum TwisterSize m_EtsSize = TWS_SMALL,     // size (type)
  3 FLOAT3D m_vStartPosition = FLOAT3D(0,0,0),  // start position

 // internal -> do not use
 10 FLOAT3D m_vDesiredPosition = FLOAT3D(0,0,0),
 11 FLOAT3D m_vDesiredAngle = FLOAT3D(0,0,0),
 12 FLOAT m_fStopTime = 0.0f,
 13 FLOAT m_fActionRadius = 0.0f,
 14 FLOAT m_fActionTime = 0.0f,
 15 FLOAT m_fDiffMultiply = 0.0f,
 16 FLOAT m_fUpMultiply = 0.0f,
 20 BOOL m_bFadeOut = FALSE,
 21 FLOAT m_fFadeStartTime = 0.0f,
 22 FLOAT m_fFadeTime = 2.0f,

components:
// ********* TWISTER *********
 10 model   MODEL_TWISTER         "Models\\Enemies\\Elementals\\Twister.mdl",
 11 texture TEXTURE_TWISTER       "Models\\Enemies\\Elementals\\AirMan01.tex",

functions:
  /* Entity info */
  void *GetEntityInfo(void) {
    return &eiTwister;
  };

  /* Receive damage */
  void ReceiveDamage(CEntity *penInflictor, enum DamageType dmtType,
    FLOAT fDamageAmmount, const FLOAT3D &vHitPoint, const FLOAT3D &vDirection) 
  {
    return;
  };



/************************************************************
 *                        FADE OUT                          *
 ************************************************************/
  BOOL AdjustShadingParameters(FLOAT3D &vLightDirection, COLOR &colLight, COLOR &colAmbient) {
    if (m_bFadeOut) {
      FLOAT fTimeRemain = m_fFadeStartTime + m_fFadeTime - _pTimer->CurrentTick();
      if (fTimeRemain < 0.0f) { fTimeRemain = 0.0f; }
      COLOR colAlpha = GetModelObject()->mo_colBlendColor;
      colAlpha = (colAlpha&0xffffff00) + (COLOR(fTimeRemain/m_fFadeTime*0xff)&0xff);
      GetModelObject()->mo_colBlendColor = colAlpha;
    }
    return CMovableModelEntity::AdjustShadingParameters(vLightDirection, colLight, colAmbient);
  };



/************************************************************
 *                     MOVING FUNCTIONS                     *
 ************************************************************/
  // calculate rotation
  void CalcHeadingRotation(ANGLE aWantedHeadingRelative, ANGLE &aRotation) {
    // normalize it to [-180,+180] degrees
    aWantedHeadingRelative = NormalizeAngle(aWantedHeadingRelative);

    // if desired position is left
    if (aWantedHeadingRelative < -ROTATE_SPEED*MOVE_FREQUENCY) {
      // start turning left
      aRotation = -ROTATE_SPEED;
    // if desired position is right
    } else if (aWantedHeadingRelative > ROTATE_SPEED*MOVE_FREQUENCY) {
      // start turning right
      aRotation = +ROTATE_SPEED;
    // if desired position is more-less ahead
    } else {
      aRotation = aWantedHeadingRelative/MOVE_FREQUENCY;
    }
  };

  // calculate angle from position
  void CalcAngleFromPosition() {
    // find relative orientation towards the desired position
    m_vDesiredAngle = (m_vDesiredPosition - GetPlacement().pl_PositionVector).Normalize();
  };

  // rotate entity to desired angle
  void RotateToAngle() {
    // find relative heading towards the desired angle
    ANGLE aRotation;
    CalcHeadingRotation(GetRelativeHeading(m_vDesiredAngle), aRotation);

    // start rotating
    SetDesiredRotation(ANGLE3D(aRotation, 0, 0));
  };

  // move in direction
  void MoveInDirection() {
    RotateToAngle();

    // determine translation speed
    FLOAT3D vTranslation(0.0f, 0.0f, 0.0f);
    vTranslation(3) = -MOVE_SPEED;

    // start moving
    SetDesiredTranslation(vTranslation);
  };

  // move entity to desired position
  void MoveToPosition() {
    CalcAngleFromPosition();
    MoveInDirection();
  };

  // rotate entity to desired position
  void RotateToPosition() {
    CalcAngleFromPosition();
    RotateToAngle();
  };

  // stop moving entity
  void StopMoving() {
    StopRotating();
    StopTranslating();
  };

  // stop rotating entity
  void StopRotating() {
    SetDesiredRotation(ANGLE3D(0, 0, 0));
  };

  // stop translating
  void StopTranslating() {
    SetDesiredTranslation(FLOAT3D(0.0f, 0.0f, 0.0f));
  };



/************************************************************
 *                   ATTACK SPECIFIC                        *
 ************************************************************/
  void SpinEntity(CEntity *pen) {
    // don't spin air elemental and another twister
    if (!(IsOfClass(pen, "Elemental") && ((CElemental&)*pen).m_EetType==ELT_AIR) &&
        !(IsOfClass(pen, "Twister"))) {
      if (pen->GetPhysicsFlags()&EPF_MOVABLE) {
        // throw target away
        FLOAT3D vSpeed;
        vSpeed = FLOAT3D(en_mRotation(1, 2), en_mRotation(2, 2), en_mRotation(3, 2)) * m_fUpMultiply;
        FLOAT3D vDiff = (pen->GetPlacement().pl_PositionVector - GetPlacement().pl_PositionVector).Normalize();
        vSpeed += (vDiff*m_fDiffMultiply) * pen->en_mRotation;
        // give absolute speed
        ((CMovableEntity&)*pen).en_vCurrentTranslationAbsolute = vSpeed;
        ((CMovableEntity&)*pen).en_aDesiredRotationRelative = ANGLE3D(180.0f, 0, 0);
        // damage
        FLOAT3D vDirection;
        AnglesToDirectionVector(GetPlacement().pl_OrientationAngle, vDirection);
        InflictDirectDamage(pen, m_penOwner, DMT_IMPACT, 0.1f, GetPlacement().pl_PositionVector, vDirection);
      }
    }
  };



/************************************************************
 *                   P R O C E D U R E S                    *
 ************************************************************/
procedures:
  // --->>> MAIN
  Main(ETwister et) {
    // remember the initial parameters
    ASSERT(et.penOwner!=NULL);
    m_penOwner = et.penOwner;
    m_EtsSize = et.EtsSize;

    // initialization
    InitAsModel();
    SetPhysicsFlags(EPF_TWISTER);
    SetCollisionFlags(ECF_TWISTER);
    SetFlags(GetFlags() | ENF_SEETHROUGH);
    SetModel(MODEL_TWISTER);
    SetModelMainTexture(TEXTURE_TWISTER);

    // setup
    switch(m_EtsSize) {
      case TWS_SMALL:
        m_fActionRadius = 10;
        m_fActionTime = 10;
        m_fUpMultiply = 5.0f;
        m_fDiffMultiply = 1.0f;
        break;
      case TWS_BIG:
        m_fActionRadius = 15;
        m_fActionTime = 20;
        m_fUpMultiply = 10.0f;
        m_fDiffMultiply = 4.0f;
        GetModelObject()->StretchModel(FLOAT3D(4.0f, 4.0f, 4.0f));
        break;
      case TWS_LARGE:
        m_fActionRadius = 20;
        m_fActionTime = 30;
        m_fUpMultiply = 20.0f;
        m_fDiffMultiply = 16.0f;
        GetModelObject()->StretchModel(FLOAT3D(16.0f, 16.0f, 16.0f));
        break;
    }
    ModelChangeNotify();
    
    // start position
    m_vStartPosition = GetPlacement().pl_PositionVector;

    // move in range
    m_fStopTime = _pTimer->CurrentTick() + 10.0f;
    while(_pTimer->CurrentTick() < m_fStopTime) {
      // new destination
      FLOAT fR = FRnd()*10.0f;
      FLOAT fA = FRnd()*360.0f;
      m_vDesiredPosition = m_vStartPosition + FLOAT3D(CosFast(fA)*fR, 0, SinFast(fA)*fR);
      while((m_vDesiredPosition - GetPlacement().pl_PositionVector).Length() > MOVE_SPEED*MOVE_FREQUENCY*2.0f &&
            _pTimer->CurrentTick() < m_fStopTime) {
        MoveToPosition();
        wait(MOVE_FREQUENCY) {
          on (EBegin) : { resume; }
          on (ETimer) : { stop; }
          on (EPass ep) : {
            if (ep.penOther->GetRenderType()&RT_MODEL &&
                ep.penOther->GetPhysicsFlags()&EPF_MOVABLE) {
              SpinEntity(ep.penOther);
            }
            resume;
          }
        }
      }
    }

    // fade out
    m_fFadeStartTime = _pTimer->CurrentTick();
    m_bFadeOut = TRUE;
    m_fFadeTime = 2.0f;
    autowait(m_fFadeTime);

    // cease to exist
    Destroy();

    return;
  }
};