コード例 #1
0
        public ViewModelWindowTurret(IStaticWorldObject worldObjectTurret)
        {
            this.worldObjectTurret = worldObjectTurret;
            this.privateState      = worldObjectTurret.GetPrivateState <ObjectTurretPrivateState>();
            this.TurretModes       = Enum.GetValues(typeof(TurretMode))
                                     .Cast <TurretMode>()
                                     .ExceptOne(TurretMode.Disabled)
                                     .Select(e => new ViewModelEnum <TurretMode>(e))
                                     .OrderBy(vm => vm.Order)
                                     .ToArray();

            this.selectedTurretMode = this.privateState.TurretMode;
            this.privateState.ClientSubscribe(_ => _.TurretMode,
                                              _ => this.RefreshTurretMode(),
                                              this);

            this.containerAmmo = this.privateState.ContainerAmmo as IClientItemsContainer;
            if (this.containerAmmo is not null)
            {
                this.containerAmmo.StateHashChanged += this.ContainerAmmoStateHashChanged;

                this.ViewModelItemsContainerExchange = new ViewModelItemsContainerExchange(this.containerAmmo)
                {
                    ContainerTitle             = CoreStrings.Vehicle_Ammo,
                    IsManagementButtonsVisible = false
                };

                this.ProtoItemWeapon =
                    ((BaseItemsContainerTurretAmmo)this.ViewModelItemsContainerExchange.Container.ProtoGameObject)
                    .ProtoWeapon;
            }

            this.RefreshTurretMode();
        }
コード例 #2
0
    void Start()
    {
        player = GameObject.FindGameObjectWithTag("Player");
        mode = TurretMode.Idle;
        turretInformation = GetComponent<TurretInformation>();

        turretInformation.CharacterStateChanged += EnemyInformation_CharacterStateChanged;

        activeCoroutine = StartCoroutine(IdleRotate());
    }
コード例 #3
0
 private void SetTurretMode()
 {
     if (turretMode == TurretMode.AUTO)
     {
         turretMode = TurretMode.MANUAL;
     }
     else
     {
         turretMode = TurretMode.AUTO;
     }
 }
コード例 #4
0
    // Initialization
    void Start()
    {
        slowMo     = transform.root.GetComponentInChildren <SlowMo> ();
        rapidFire  = transform.root.GetComponentInChildren <RapidFire> ();
        turretMode = transform.root.GetComponentInChildren <TurretMode> ();
        // Assign other ability references here

        // Testing:
        //UnlockSlowMo(1);
        //UnlockRapidFire(1);
        //UnlockTurretMode(1);
        //UnlockStarMode(1);
    }
コード例 #5
0
    void Update()
    {
        if (GameInformation.Instance.GameState != GameState.Playing) return;
        if (turretInformation.CharacterState != CharacterState.Alive) return;

        cooldown += Time.deltaTime;

        switch (mode)
        {
            case TurretMode.Idle:
                {
                    if (CanSeePlayer())
                    {
                        mode = TurretMode.SeekingPlayer;

                        StopCoroutine(activeCoroutine);
                        activeCoroutine = StartCoroutine(SeekPlayer());
                    }
                }
                break;
            case TurretMode.SeekingPlayer:
                {
                    if (!CanSeePlayer())
                    {
                        mode = TurretMode.Idle;

                        StopCoroutine(activeCoroutine);
                        activeCoroutine = StartCoroutine(IdleRotate());
                    }

                    if (CanFireOnPlayer())
                    {
                        Fire();
                    }
                }
                break;
            default:
                break;
        }
    }
コード例 #6
0
        protected virtual void ServerUpdateTurret(ServerUpdateData data, TurretMode turretMode)
        {
            var character    = data.GameObject;
            var privateState = data.PrivateState;
            var publicState  = GetPublicState(character);
            var weaponState  = privateState.WeaponState;

            if (privateState.WeaponState.ProtoWeapon is ProtoItemWeaponTurretWithAmmo protoItemWeaponTurretWithAmmo)
            {
                protoItemWeaponTurretWithAmmo.ServerUpdateCurrentAmmo(character, weaponState);
                // attack range may change if the ammo type has changed
                privateState.AttackRange = weaponState.WeaponCache?.RangeMax ?? 0;
            }

            ServerCharacterAiHelper.ProcessAggressiveAi(
                character,
                targetCharacter: ServerTurretAiHelper.GetClosestTargetPlayer(character, turretMode, privateState),
                isRetreating: false,
                isRetreatingForHeavyVehicles: false,
                distanceRetreat: 0,
                distanceEnemyTooClose: 1,
                distanceEnemyTooFar: 8,
                movementDirection: out _,
                rotationAngleRad: out var rotationAngleRad,
                attackFarOnlyIfAggro: true,
                customIsValidTargetCallback: IsValidTargetCallback);

            var currentRotationAngleRad = (double)publicState.AppliedInput.RotationAngleRad;

            rotationAngleRad = MathHelper.LerpAngle(currentRotationAngleRad,
                                                    rotationAngleRad,
                                                    data.DeltaTime,
                                                    this.BarrelRotationRate);

            publicState.AppliedInput.Set(
                new CharacterInput()
            {
                MoveModes        = CharacterMoveModes.None,
                RotationAngleRad = (float)rotationAngleRad
            },
                moveSpeed: 0);

            if (weaponState.SharedGetInputIsFiring() &&
                !ServerCharacterAiHelper.CanHitAnyTargetWithRangedWeapon(
                    character,
                    rotationAngleRad,
                    privateState,
                    isValidTargetCallback: IsValidTargetForceAttackNeutralsCallback))
            {
                // don't shoot as not pointing on the target right now
                weaponState.SharedSetInputIsFiring(false);
            }

            bool IsValidTargetCallback(IWorldObject worldObject)
            => ServerTurretAiHelper.IsValidTarget(character,
                                                  worldObject,
                                                  turretMode,
                                                  forceAttackNeutrals: false);

            bool IsValidTargetForceAttackNeutralsCallback(IWorldObject worldObject)
            => ServerTurretAiHelper.IsValidTarget(character,
                                                  worldObject,
                                                  turretMode,
                                                  forceAttackNeutrals: true);
        }