Magnum.c

Go to the documentation of this file.

const float MAGNUM_ROTATION_POSITION_M1 = -0.167;
const float MAGNUM_ROTATION_POSITION_0 = 0.0;
const float MAGNUM_ROTATION_POSITION_1 = 0.167;
const float MAGNUM_ROTATION_POSITION_2 = 0.334;
const float MAGNUM_ROTATION_POSITION_3 = 0.500;
const float MAGNUM_ROTATION_POSITION_4 = 0.668;
const float MAGNUM_ROTATION_POSITION_5 = 0.835;
const float MAGNUM_ROTATION_POSITION_6 = 1.0;
 
 
enum MagnumAnimState
{
  DEFAULT = 0, 
};
 
enum MagnumStableStateID
{
  UNKNOWN = 0,
  DEFAULT = 1,
}
 
class Magnum_Static_State extends WeaponStableState
{
  bool init = false;
  override void OnEntry(WeaponEventBase e)
  {
    if (LogManager.IsWeaponLogEnable()) wpnPrint("[wpnstate] { Magnum stable state");
    super.OnEntry(e);
    if (init)
    {
      Magnum_Base magnum;
      if (CastTo(magnum, m_weapon))
      {
        magnum.SyncCylinderRotation();
        //magnum.SyncSelectionStateFromState();
      }
    }
    init = true;
  }
  override void OnExit(WeaponEventBase e) { super.OnExit(e); if (LogManager.IsWeaponLogEnable()) wpnPrint("[wpnstate] }  Magnum stable state"); }
  override int GetCurrentStateID() { return MagnumStableStateID.DEFAULT; }
  override bool HasBullet() { return m_weapon.IsChamberFull(m_weapon.GetCurrentMuzzle()); }
  override bool HasMagazine() { return false; }
  override bool IsJammed() { return m_weapon.IsJammed(); }
  override bool IsSingleState() { return true; }
};
 
 
class Magnum_Base extends Weapon_Base
{
  ref WeaponStableState C;
  int m_LastMuzzleloaded;
  int m_ActiveMuzzle;
  const string ATT_SLOT_CYLINDER = "RevolverCylinder";
  const string ATT_SLOT_EJECTOR = "RevolverEjector";
 
  override void SetActions()
  {
    super.SetActions();
    AddAction(FirearmActionLoadMultiBullet);
 
    RemoveAction(FirearmActionLoadBulletQuick); // Easy reload
    AddAction(FirearmActionLoadMultiBulletQuick); // Easy reload
 
  }
 
  override RecoilBase SpawnRecoilObject()
  {
    return new MagnumRecoil(this);
  }
 
  void Magnum_Base()
  {
    m_LastMuzzleloaded = 0;
    m_ActiveMuzzle = 0;
 
    /*m_abilities.Insert(new AbilityRecord(WeaponActions.CHAMBERING, WeaponActionTypes.CHAMBERING_STARTLOOPABLE_CLOSED));
      m_abilities.Insert(new AbilityRecord(WeaponActions.CHAMBERING, WeaponActionTypes.CHAMBERING_ENDLOOPABLE));
      m_abilities.Insert(new AbilityRecord(WeaponActions.MECHANISM, WeaponActionTypes.MECHANISM_CLOSED));
      m_abilities.Insert(new AbilityRecord(WeaponActions.MECHANISM, WeaponActionTypes.MECHANISM_SPECIAL));
      m_abilities.Insert(new AbilityRecord(WeaponActions.UNJAMMING, WeaponActionTypes.UNJAMMING_START));
      m_abilities.Insert(new AbilityRecord(WeaponActions.UNJAMMING, WeaponActionTypes.UNJAMMING_END));
      m_abilities.Insert(new AbilityRecord(WeaponActions.FIRE, WeaponActionTypes.FIRE_NORMAL));
      m_abilities.Insert(new AbilityRecord(WeaponActions.FIRE, WeaponActionTypes.FIRE_COCKED));*/
  }
 
  override void InitStateMachine()
  {
    m_abilities.Insert(new AbilityRecord(WeaponActions.CHAMBERING, WeaponActionChamberingTypes.CHAMBERING_STARTLOOPABLE_CLOSED));
    m_abilities.Insert(new AbilityRecord(WeaponActions.CHAMBERING, WeaponActionChamberingTypes.CHAMBERING_STARTLOOPABLE_CLOSED_KEEP));
    m_abilities.Insert(new AbilityRecord(WeaponActions.CHAMBERING, WeaponActionChamberingTypes.CHAMBERING_ENDLOOPABLE));
    m_abilities.Insert(new AbilityRecord(WeaponActions.MECHANISM, WeaponActionMechanismTypes.MECHANISM_CLOSED));
    m_abilities.Insert(new AbilityRecord(WeaponActions.MECHANISM, WeaponActionMechanismTypes.MECHANISM_SPECIAL));
    m_abilities.Insert(new AbilityRecord(WeaponActions.FIRE, WeaponActionFireTypes.FIRE_NORMAL));
    m_abilities.Insert(new AbilityRecord(WeaponActions.FIRE, WeaponActionFireTypes.FIRE_COCKED));
    m_abilities.Insert(new AbilityRecord(WeaponActions.FIRE, WeaponActionFireTypes.FIRE_UNCOCKED));
 
 
    // setup state machine
    // basic weapon state
    C = new Magnum_Static_State(this, NULL, MagnumAnimState.DEFAULT);
 
 
    WeaponMagnumChambering Chamber = new WeaponMagnumChambering(this, NULL, WeaponActions.CHAMBERING, WeaponActionChamberingTypes.CHAMBERING_STARTLOOPABLE_CLOSED_KEEP, WeaponActionChamberingTypes.CHAMBERING_ENDLOOPABLE);
    WeaponMagnumChambering Chamber_E = new WeaponMagnumChambering(this, NULL, WeaponActions.CHAMBERING, WeaponActionChamberingTypes.CHAMBERING_STARTLOOPABLE_CLOSED, WeaponActionChamberingTypes.CHAMBERING_ENDLOOPABLE);
    //WeaponMagnumChambering Chamber_CC00 = new WeaponMagnumChambering(this, NULL, WeaponActions.CHAMBERING, WeaponActionChamberingTypes.CHAMBERING_END);
 
    WeaponCharging Mech = new WeaponCharging(this, NULL, WeaponActions.MECHANISM, WeaponActionMechanismTypes.MECHANISM_CLOSED);
 
    WeaponStateBase Trigger_normal = new WeaponFireMagnum(this, NULL, WeaponActions.FIRE, WeaponActionFireTypes.FIRE_NORMAL);
    WeaponStateBase Trigger_dry = new WeaponFireMagnum(this, NULL, WeaponActions.FIRE, WeaponActionFireTypes.FIRE_COCKED);
 
    // events
 
    WeaponEventBase __L__ = new WeaponEventLoad1Bullet;
    WeaponEventBase _fin_ = new WeaponEventHumanCommandActionFinished;
    WeaponEventBase _abt_ = new WeaponEventHumanCommandActionAborted;
    WeaponEventBase __M__ = new WeaponEventMechanism;
    WeaponEventBase __T__ = new WeaponEventTrigger;
 
 
    WeaponEventBase _rto_ = new WeaponEventReloadTimeout;
    WeaponEventBase _dto_ = new WeaponEventDryFireTimeout;
 
 
    m_fsm = new WeaponFSM();
 
 
    m_fsm.AddTransition(new WeaponTransition(C, __L__, Chamber, null, new WeaponGuardAnyChamberFiredOut(this))); // chamber from closed charged
    m_fsm.AddTransition(new WeaponTransition(Chamber, _fin_, C));
    m_fsm.AddTransition(new WeaponTransition(Chamber, _abt_, C));
 
 
    m_fsm.AddTransition(new WeaponTransition(C, __L__, Chamber_E)); // chamber from closed charged
    m_fsm.AddTransition(new WeaponTransition(Chamber_E, _fin_, C));
    m_fsm.AddTransition(new WeaponTransition(Chamber_E, _abt_, C));
 
 
    m_fsm.AddTransition(new WeaponTransition(C, __M__, Mech)); // charge from closed
    m_fsm.AddTransition(new WeaponTransition(Mech, _fin_, C));
    m_fsm.AddTransition(new WeaponTransition(Mech, _abt_, C));
 
 
    m_fsm.AddTransition(new WeaponTransition(C, __T__, Trigger_normal, null, new GuardAnd(new WeaponGuardCurrentChamberFull(this), new GuardNot(new WeaponGuardCurrentChamberFiredOut(this))))); // fire.cocked
    m_fsm.AddTransition(new WeaponTransition(Trigger_normal, _fin_, C));
    m_fsm.AddTransition(new WeaponTransition(Trigger_normal, _dto_, C));
    m_fsm.AddTransition(new WeaponTransition(Trigger_normal, _abt_, C));
 
    m_fsm.AddTransition(new WeaponTransition(C, __T__, Trigger_dry)); // fire.cocked
    m_fsm.AddTransition(new WeaponTransition(Trigger_dry, _fin_, C));
    m_fsm.AddTransition(new WeaponTransition(Trigger_dry, _dto_, C));
    m_fsm.AddTransition(new WeaponTransition(Trigger_dry, _abt_, C));
 
 
    SetInitialState(C);
    SelectionBulletHide();
    SetCurrentMuzzle(0);
    //HideMagazine();
    m_fsm.Start();
  }
 
  override bool CanChamberBullet(int muzzleIndex, Magazine mag)
  {
    for (int i = 0; i < GetMuzzleCount(); i++)
    {
      if (CanChamberFromMag(i, mag))
      {
        if (IsChamberEmpty(i))
          return true;
 
        if (IsChamberFiredOut(i))
          return true;
      }
    }
    return false;
  }
 
  override void AssembleGun()
  {
    super.AssembleGun();
 
    if (!FindAttachmentBySlotName(ATT_SLOT_EJECTOR))
      GetInventory().CreateAttachment("Magnum_Ejector");
 
    if (!FindAttachmentBySlotName(ATT_SLOT_CYLINDER))
      GetInventory().CreateAttachment("Magnum_Cylinder");
 
    ForceSyncSelectionState();
    SyncCylinderRotation();
  }
 
  static float GetCylinderRotation(int muzzleIndex)
  {
    switch (muzzleIndex)
    {
    case 0:
      return MAGNUM_ROTATION_POSITION_0;
    case 1:
      return MAGNUM_ROTATION_POSITION_5;
    case 2:
      return MAGNUM_ROTATION_POSITION_4;
    case 3:
      return MAGNUM_ROTATION_POSITION_3;
    case 4:
      return MAGNUM_ROTATION_POSITION_2;
    case 5:
      return MAGNUM_ROTATION_POSITION_1;
    }
 
    ErrorEx(string.Format("Invalid muzzle index: %1", muzzleIndex));
 
    return MAGNUM_ROTATION_POSITION_0;
  }
 
  void SetCylinderRotationAnimationPhase(float rot, bool reset = false)
  {
    Magnum_Cylinder cylinder = Magnum_Cylinder.Cast(GetAttachmentByType(Magnum_Cylinder));
    Magnum_Ejector ejector = Magnum_Ejector.Cast(GetAttachmentByType(Magnum_Ejector));
    if (cylinder && ejector)
    {
      float anim_phase = cylinder.GetAnimationPhase("Rotate_Cylinder");
      if (Math.AbsFloat(anim_phase - rot) > 0.1)
      {
        if (reset)
        {
          cylinder.ResetAnimationPhase("Rotate_Cylinder", rot);
          ejector.ResetAnimationPhase("Rotate_Ejector", rot);
        }
        else if (rot == MAGNUM_ROTATION_POSITION_0)
        {
          cylinder.ResetAnimationPhase("Rotate_Cylinder", MAGNUM_ROTATION_POSITION_M1);
          ejector.ResetAnimationPhase("Rotate_Ejector", MAGNUM_ROTATION_POSITION_M1);
        }
 
        cylinder.SetAnimationPhase("Rotate_Cylinder", rot);
        ejector.SetAnimationPhase("Rotate_Ejector", rot);
      }
    }
  }
 
  void SyncCylinderRotation(bool reset = true)
  {
    SetCylinderRotationAnimationPhase(GetCylinderRotation(GetCurrentMuzzle()), reset);
  }
 
  override void EEHealthLevelChanged(int oldLevel, int newLevel, string zone)
  {
    super.EEHealthLevelChanged(oldLevel, newLevel, zone);
 
    if (GetGame().IsClient())
      return;
 
    SetAttachmentsHealth();
  }
 
  //sets health of cylinder and ejector objects
  void SetAttachmentsHealth()
  {
    EntityAI entity;
    ItemBase attachment;
    for (int i = 0; i < GetInventory().AttachmentCount(); i++)
    {
      entity = GetInventory().GetAttachmentFromIndex(i);
      if (Class.CastTo(attachment, entity))
        attachment.SetHealth01("", "Health", GetHealth01());
    }
  }
 
  override void OnFire(int muzzle_index)
  {
    super.OnFire(muzzle_index);
    Magnum_Cylinder cylinder = Magnum_Cylinder.Cast(GetAttachmentByType(Magnum_Cylinder));
    if (cylinder)
    {
      string bullet_nose = "bullet_nose";
      if (muzzle_index > 0)
        bullet_nose = string.Format("bullet_nose_" + (muzzle_index + 1));
      cylinder.HideSelection(bullet_nose);
    }
  }
 
  override bool IsShowingChamberedBullet()
  {
    return false;
  }
 
  override bool CanEjectBullet()
  {
    for (int i = 0; i < GetMuzzleCount(); i++)
    {
      if (IsChamberFull(i))
        return true;
    }
    return false;
  }
 
  override void ShowBullet(int muzzleIndex)
  {
    super.ShowBullet(muzzleIndex);
 
    Magnum_Cylinder cylinder = Magnum_Cylinder.Cast(GetAttachmentByType(Magnum_Cylinder));
    if (cylinder)
    {
      string bullet = "bullet";
      if (muzzleIndex > 0)
        bullet = string.Format("bullet_" + (muzzleIndex + 1));
 
      cylinder.ShowSelection(bullet);
 
      if (!IsChamberFiredOut(muzzleIndex))
      {
        string bullet_nose = "bullet_nose";
        if (muzzleIndex > 0)
          bullet_nose = string.Format("bullet_nose_" + (muzzleIndex + 1));
        cylinder.ShowSelection(bullet_nose);
      }
    }
  }
 
  override void HideBullet(int muzzleIndex)
  {
    super.HideBullet(muzzleIndex);
 
    Magnum_Cylinder cylinder = Magnum_Cylinder.Cast(GetAttachmentByType(Magnum_Cylinder));
    if (cylinder)
    {
      string bullet = "bullet";
      if (muzzleIndex > 0)
        bullet = string.Format("bullet_" + (muzzleIndex + 1));
 
      cylinder.HideSelection(bullet);
 
      string bullet_nose = "bullet_nose";
      if (muzzleIndex > 0)
        bullet_nose = string.Format("bullet_nose_" + (muzzleIndex + 1));
      cylinder.HideSelection(bullet_nose);
    }
  }
 
  //Debug menu Spawn Ground Special
  override void OnDebugSpawn()
  {
    super.OnDebugSpawn();
 
    EntityAI entity;
    if (Class.CastTo(entity, this))
      entity.SpawnEntityOnGroundPos("Ammo_357", entity.GetPosition());
  }
};
 
class Magnum extends Magnum_Base
{
  override void GetDebugActions(out TSelectableActionInfoArrayEx outputList)
  {
    super.GetDebugActions(outputList);
 
    outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SEPARATOR, "", FadeColors.LIGHT_GREY));
    outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SPIN, "Spin", FadeColors.LIGHT_GREY));
  }
 
  override bool OnAction(int action_id, Man player, ParamsReadContext ctx)
  {
    if (GetGame().IsServer())
    {
      if (action_id == EActions.SPIN)
      {
        const float animPhaseOffset = 0.167;
 
        Magnum_Cylinder cylinder = Magnum_Cylinder.Cast(GetAttachmentByType(Magnum_Cylinder));
        Magnum_Ejector ejector = Magnum_Ejector.Cast(GetAttachmentByType(Magnum_Ejector));
 
        if (cylinder)
        {
          float animPhase = cylinder.GetAnimationPhase("Rotate_Cylinder");
          if (animPhase + animPhaseOffset > 1.0)
          {
            animPhase -= 1.0;
            cylinder.ResetAnimationPhase("Rotate_Cylinder", animPhase);
            ejector.ResetAnimationPhase("Rotate_Ejector", animPhase);
          }
 
          cylinder.SetAnimationPhase("Rotate_Cylinder", animPhase);
          ejector.ResetAnimationPhase("Rotate_Ejector", animPhase);
        }
      }
    }
 
    return super.OnAction(action_id, player, ctx);
  }
}
 
class SawedoffMagnum extends Magnum_Base {};
class Magnum_Cylinder extends DummyItem {};
class Magnum_Ejector extends DummyItem {};