コード例 #1
0
    // Start is called before the first frame update
    void Start()
    {
        currentState      = AI_STATE.HEALTH_HIGH;
        seekComponent     = GetComponent <KinematicSeek>();
        fleeComponent     = GetComponent <KinematicFlee>();
        arriveComponent   = GetComponent <KinematicArrive>();
        sidestepComponent = GetComponent <KinematicSidestep>();
        playerScript      = GetComponent <PlayerScript>();

        lowHealthTargetNearby = new TargetNearbyDecision(5.0f);
        lowHealthTargetNearIncomingProjectile = new IncomingProjectileDecision();
        lowHealthTargetFarIncomingProjectile  = new IncomingProjectileDecision();

        highHealthTargetNearby = new TargetNearbyDecision(5.0f);
        highHealthTargetNearIncomingProjectile = new IncomingProjectileDecision();
        highHealthTargetFarIncomingProjectile  = new IncomingProjectileDecision();

        arrivePlayerAction    = new ArrivePlayerAction();
        shootPlayerAction     = new ShootPlayerAction();
        seekHealthAction      = new SeekHealthAction();
        avoidPlayerAction     = new AvoidPlayerAction();
        avoidProjectileAction = new AvoidProjectileAction();

        avoidProjectileAction.kinematicComponent = seekComponent;
        avoidProjectileAction.character          = gameObject;
        arrivePlayerAction.kinematicComponent    = arriveComponent;
        arrivePlayerAction.character             = gameObject;
        seekHealthAction.kinematicComponent      = seekComponent;
        seekHealthAction.character           = gameObject;
        avoidPlayerAction.kinematicComponent = fleeComponent;
        avoidPlayerAction.character          = gameObject;
        shootPlayerAction.kinematicComponent = arriveComponent;
        shootPlayerAction.character          = gameObject;

        lowHealthTargetNearby.character   = gameObject;
        lowHealthTargetNearby.target      = target;
        lowHealthTargetNearby.trueBranch  = lowHealthTargetNearIncomingProjectile;
        lowHealthTargetNearby.falseBranch = lowHealthTargetFarIncomingProjectile;

        lowHealthTargetNearIncomingProjectile.character   = gameObject;
        lowHealthTargetNearIncomingProjectile.trueBranch  = avoidProjectileAction;
        lowHealthTargetNearIncomingProjectile.falseBranch = avoidPlayerAction;

        lowHealthTargetFarIncomingProjectile.character   = gameObject;
        lowHealthTargetFarIncomingProjectile.trueBranch  = avoidProjectileAction;
        lowHealthTargetFarIncomingProjectile.falseBranch = seekHealthAction;

        highHealthTargetNearby.character   = gameObject;
        highHealthTargetNearby.target      = target;
        highHealthTargetNearby.trueBranch  = highHealthTargetNearIncomingProjectile;
        highHealthTargetNearby.falseBranch = highHealthTargetFarIncomingProjectile;

        highHealthTargetNearIncomingProjectile.character   = gameObject;
        highHealthTargetNearIncomingProjectile.trueBranch  = avoidProjectileAction;
        highHealthTargetNearIncomingProjectile.falseBranch = shootPlayerAction;

        highHealthTargetFarIncomingProjectile.character   = gameObject;
        highHealthTargetFarIncomingProjectile.trueBranch  = avoidProjectileAction;
        highHealthTargetFarIncomingProjectile.falseBranch = arrivePlayerAction;
    }
コード例 #2
0
 void Awake()
 {
     seek   = GetComponent <KinematicSeek>();
     flee   = GetComponent <KinematicFlee>();
     arrive = GetComponent <KinematicArrive>();
     wander = GetComponent <KinematicWander>();
 }
コード例 #3
0
        public void ManageAI(MovementAI ai, Rigidbody2D character)
        {
            Kinematic characterKinematic = KinematicAdapter.FromRigidbody2DToKinematic(character);
            Kinematic targetKinematic    = new Kinematic();
            Algorithm algorithm          = new KinematicNone();

            switch (ai.aiAlgorithm)
            {
            case AIAlgorithm.KinematicSeek:
                targetKinematic = KinematicAdapter.FromRigidbody2DToKinematic(ai.target);
                algorithm       = new KinematicSeek(characterKinematic, targetKinematic, ai.maxSpeed);
                break;

            case AIAlgorithm.KinematicFlee:
                targetKinematic = KinematicAdapter.FromRigidbody2DToKinematic(ai.target);
                algorithm       = new KinematicFlee(characterKinematic, targetKinematic, ai.maxSpeed);
                break;

            case AIAlgorithm.KinematicArrive:
                targetKinematic = KinematicAdapter.FromRigidbody2DToKinematic(ai.target);
                algorithm       = new KinematicArrive(characterKinematic, targetKinematic, ai.maxSpeed, ai.satisfactionRadius, ai.timeToTarget);
                break;

            case AIAlgorithm.KinematicWander:
                algorithm = new KinematicWander(characterKinematic, ai.maxSpeed, ai.maxRotation);
                break;
            }
            SteeringOutput steering = algorithm.getSteering();

            steering.Apply(characterKinematic, ai.lookWhereYoureGoing, ai.maxSpeed, Time.deltaTime);
            KinematicAdapter.UpdateRigidbody2DWithKinematic(character, characterKinematic);
        }
コード例 #4
0
 private void Start()
 {
     seek = GetComponent <KinematicSeek>();
     tank = transform.position;
     flee = GetComponent <KinematicFlee>();
 }
コード例 #5
0
 // Use this for initialization
 void Start()
 {
     StaticTransform charStatic = new StaticTransform(transform);
     StaticTransform targetStatic = new StaticTransform(target);
     flee = new KinematicFlee(charStatic, targetStatic, maxSpeed);
 }
コード例 #6
0
 void Awake()
 {
     kinematicFlee = new KinematicFlee(GetComponent <Rigidbody>(), getTargetPosition(), magnitude);
 }