Exemplo n.º 1
0
 protected virtual void AwakeObj()
 {
     player = GetComponent<Player>();
     hud = player.GetComponentInChildren<HUD>();
     dialogManager = player.GetComponentInChildren<DialogManager>();
     formationManager = player.GetComponentInChildren<FormationManager>();
     targetManager = player.GetComponentInChildren<TargetManager>();
 }
        public LaissezUnAvisViewModel(string nomseo)
        {
            Formation formation = null;

            if (FormationManager.ObtenirFormation(nomseo, out formation))
            {
                this.Formation = formation;
            }
        }
Exemplo n.º 3
0
    // Use this for initialization
    void Start()
    {
        int squad_size = 0;

        level_generator   = gameObject.GetComponent <LevelGenerator>();
        squad_generator   = gameObject.GetComponent <SquadGenerator>();
        enemy_generator   = gameObject.GetComponent <EnemyGenerator>();
        cover_manager     = gameObject.GetComponent <CoverManager>();
        formation_manager = gameObject.GetComponent <FormationManager>();

        squadies = new List <GameObject>();
        enemies  = new List <GameObject>();

        // Generate Squad
        if (no_of_squadies > 8)
        {
            no_of_squadies = 8;
        }

        //no_of_enemies = no_of_squadies * 2;

        level_generator.GenerateNewLevel(level_height, level_width, grid_section_size);

        Vector3 level_size = new Vector3(level_width * grid_section_size, 0.0f, level_height * grid_section_size);

        // This is to stop duplicate cover spots spawning!
        if (cover_spacing <= 0)
        {
            cover_spacing = 1;
        }

        cover_manager.GenerateCoverPoints(level_size, no_cover_passes_across, no_cover_passes_up, cover_spacing);

        // Set Player position
        player.transform.position = new Vector3(player.transform.position.x, 1.0f, player.transform.position.z);

        // Position ID's
        cover_manager.SetSquads(no_of_squadies);

        squad_generator.GenerateSquad(no_of_squadies, cover_manager.StartupCover(no_of_squadies, player.transform.position), ref squadies);

        if (no_of_squadies % 2 == 1)             // If we have a remainder ie Squad sizes are not even
        {
            squad_size = no_of_squadies / 2 + 1; // We use the biggest squad size
        }

        if (no_of_squadies % 2 == 0) // If they are even all good
        {
            squad_size = no_of_squadies / 2;
        }

        // Tell the formation manager about the largest squad size
        formation_manager.GenerateFormations(player, squad_size);

        //enemy_generator.GenerateEnemies(no_of_enemies, cover_manager.GetEnemyPositions(no_of_enemies, enemy_generator.GetSpawnPoints()), ref enemies);
    }
Exemplo n.º 4
0
    public FlockFormation(List<Vector3> vertices)
    {
        formationManagers = new Dictionary<Entity, FormationManager>();

        updateTimer = new System.Diagnostics.Stopwatch();

        var pattern = new ModelFormation(null, vertices);
        var formationManager = new FormationManager(pattern);
        generalManager = formationManager;
    }
Exemplo n.º 5
0
    // Use this for initialization
    void Start()
    {
        player           = transform.root.GetComponent <Player>();
        targetManager    = transform.root.GetComponentInChildren <TargetManager>();
        formationManager = transform.root.GetComponentInChildren <FormationManager>();
        dialogManager    = transform.root.GetComponentInChildren <DialogManager>();
        hud = transform.root.GetComponentInChildren <HUD>();

        mainCamera = GameObject.FindGameObjectWithTag("MainCamera").GetComponent <Camera>();

        ground = FindObjectOfType <Ground>();
    }
Exemplo n.º 6
0
    void Awake()
    {
        if (current == null)
        {
            current = this;
        }


        if (agentsNum == 0)
        {
            Debug.Log("YOU MUST SELECT THE TAG OF THE AGENTS IN THE FORMATION MANAGER GAME OBJECT");
        }
    }
Exemplo n.º 7
0
    //*****************************************************************************
    // AI can change it's formation to a new one after it deliver or receive a goal.
    //*****************************************************************************
    public IEnumerator changeFormation(int _formationIndex, float _speed)
    {
        //cache the initial position of all units
        List <Vector3> unitsSartingPosition = new List <Vector3>();

        foreach (var unit in myTeam)
        {
            unitsSartingPosition.Add(unit.transform.position);                  //get the initial postion of this unit for later use.
            unit.GetComponent <MeshCollider>().enabled = false;                 //no collision for this unit till we are done with re positioning.
        }

        float t = 0;

        while (t < 1)
        {
            t += Time.deltaTime * _speed;
            for (int cnt = 0; cnt < myTeam.Length; cnt++)
            {
                myTeam[cnt].transform.position = new Vector3(Mathf.SmoothStep(unitsSartingPosition[cnt].x,
                                                                              FormationManager.getPositionInFormation(_formationIndex, cnt).x * -1,
                                                                              t),
                                                             Mathf.SmoothStep(unitsSartingPosition[cnt].y,
                                                                              FormationManager.getPositionInFormation(_formationIndex, cnt).y,
                                                                              t),
                                                             FormationManager.fixedZ);

                /*
                 * myTeam[cnt].transform.position.x = Mathf.SmoothStep(	unitsSartingPosition[cnt].x,
                 *                                                                                                              FormationManager.getPositionInFormation(_formationIndex, cnt).x * -1,
                 *                                                                                                              t);
                 * myTeam[cnt].transform.position.y = Mathf.SmoothStep(	unitsSartingPosition[cnt].y,
                 *                                                                                                              FormationManager.getPositionInFormation(_formationIndex, cnt).y,
                 *                                                                                                              t);
                 * myTeam[cnt].transform.position.z = FormationManager.fixedZ;
                 */
            }
            yield return(0);
        }

        if (t >= 1)
        {
            canChangeFormation = true;
            foreach (var unit in myTeam)
            {
                unit.GetComponent <MeshCollider>().enabled = true;                      //collision is now enabled.
            }
        }
    }
        public static void SwitchFormationType(FormationManager formationManager)
        {
            if (!formationManager)
            {
                return;
            }

            if (formationManager.CurrentFormationType == FormationType.Auto)
            {
                formationManager.CurrentFormationType = FormationType.Manual;
            }
            else if (formationManager.CurrentFormationType == FormationType.Manual)
            {
                formationManager.CurrentFormationType = FormationType.Auto;
            }
        }
Exemplo n.º 9
0
    // Use this for initialization
    IEnumerator Start()
    {
        playerUnitPanels = new List <PlayerUnitPanel>();

        canvas             = GetComponentInChildren <Canvas>();
        player             = transform.root.GetComponent <Player>();
        targetManager      = player.GetComponentInChildren <TargetManager>();
        formationManager   = player.GetComponentInChildren <FormationManager>();
        dialogManager      = player.GetComponentInChildren <DialogManager>();
        playerUnitBar      = GetComponentInChildren <PlayerUnitBar>();
        enemyUnitBar       = GetComponentInChildren <EnemyUnitBar>();
        selectionIndicator = GetComponentInChildren <SelectionIndicator>();
        abilityBar         = GetComponentInChildren <AbilityBar>();
//        upperBar = GetComponentInChildren<UpperBar>();
        generalIndicatorBar = GetComponentInChildren <GeneralIndicatorBar>();
        enemyCountBar       = GetComponentInChildren <EnemyCountBar>();
        unitPanelWrapper    = GetComponentInChildren <UnitPanelWrapper>();

        animator = GetComponent <Animator>();

        if (player && player.human)
        {
            while (!animator || !player || !targetManager || !formationManager)
            {
                yield return(new WaitForSeconds(0.1f));
            }
        }

        ResourceManager.StoreSelectBoxItems(selectBoxSkin, healthy, damaged, critical);

        SetCursorState(CursorState.Select);

        buildAreaHeight = Screen.height - RESOURCE_BAR_HEIGHT - SELECTION_NAME_HEIGHT - 2 * BUTTON_SPACING;

        List <AudioClip> sounds  = new List <AudioClip>();
        List <float>     volumes = new List <float>();

        sounds.Add(clickSound);
        volumes.Add(clickVolume);
        audioElement = new AudioElement(sounds, volumes, "HUD", null);

        Cursor.lockState   = CursorLockMode.Locked;
        cursorPosition     = new Vector3(Screen.width / 2, Screen.height / 2);
        lastCursorPosition = new Vector3(Screen.width / 2, Screen.height / 2);
    }
Exemplo n.º 10
0
    public static void UpdateMovePosition(Vector3 position)
    {
        if (_selectedShips.Count == 0)
        {
            return;
        }

        List <Vector3> formation = FormationManager.Get(position, _selectedShips[0].transform.forward, _selectedShips.Count).ToList();

        //move to closest position in formation
        for (int i = 0; i < _selectedShips.Count; i++)
        {
            Vector3 np = formation
                         .OrderByDescending(v => Vector3.Distance(v, _selectedShips[i].transform.position))
                         .First();

            formation.Remove(np);

            _selectedShips[i].UpdateMovePosition(np);
        }
    }
Exemplo n.º 11
0
    //    //transform.position = dest;

    //    // seek towards dest
    //    /*
    //    rb.AddForce((dest - (Vector2)transform.position).normalized * acceleration);
    //    if (rb.velocity.magnitude > max_speed)
    //        rb.velocity = (dest - (Vector2)transform.position).normalized * max_speed;
    //    */

    //    // rotate if we are far enough away
    //    if(((Vector2)transform.position - dest).magnitude > 0.25f)
    //    {
    //        Vector2 _direction = (dest - (Vector2)transform.position).normalized;
    //        float angle = Mathf.Atan2(_direction.y, _direction.x) * Mathf.Rad2Deg;

    //        float lerp_angle = Mathf.LerpAngle(transform.eulerAngles.z, angle, Time.deltaTime * rotational_speed);
    //        transform.rotation = Quaternion.Euler(0f, 0f, lerp_angle);
    //    }

    //    if(Vector2.Dot((Vector2)transform.position - dest, transform.right) < 0)
    //    {
    //        // accelerate
    //        rb.AddForce(transform.right * acceleration);
    //        if (rb.velocity.magnitude > max_speed)
    //        {
    //            rb.velocity = rb.velocity.normalized * max_speed;
    //        }
    //    }
    //}

    private void OnCollisionEnter2D(Collision2D collision)
    {
        //print("collision start!");
        if (collision.gameObject.GetComponent <BlackBird>())
        {
            FormationManager f_manager = FindObjectOfType <FormationManager>();
            if (f_manager)
            {
                f_manager.RemoveAgent(this);
            }
            else
            {
                TwoLevelManager tlm = FindObjectOfType <TwoLevelManager>();
                if (tlm)
                {
                    tlm.RemoveAgent(this);
                }
            }
            Destroy(this.gameObject);
        }
    }
Exemplo n.º 12
0
    public static void AddMove(Vector3?position, bool clearQueue)
    {
        if (_selectedShips.Count == 0)
        {
            return;
        }

        List <Vector3> formation = FormationManager.Get((Vector3)position, _selectedShips[0].transform.forward, _selectedShips.Count).ToList();

        //need to map the closest ship to the closest point
        for (int i = 0; i < _selectedShips.Count; i++)
        {
            if (position != null)
            {
                int closestIndex = -1;

                float distance = Mathf.Infinity;

                for (int j = 0; j < formation.Count; j++)
                {
                    float d = Vector3.Distance(_selectedShips[i].transform.position, formation[j]);

                    if (closestIndex == -1 || d < distance)
                    {
                        closestIndex = j;
                    }
                }

                _selectedShips[i].AddMove(new Move(formation[closestIndex], _selectedShips[i]), clearQueue);
                formation.RemoveAt(closestIndex);
            }
            else
            {
                _selectedShips[i].AddMove(new Move(position, _selectedShips[i]), clearQueue);
            }
        }
    }
Exemplo n.º 13
0
 void Awake()
 {
     INSTANCE = this;
 }
Exemplo n.º 14
0
    public override void OnInspectorGUI()
    {
        FormationManager _target = (FormationManager)target;

        EditorGUILayout.BeginVertical("box");
        _target.target = (GameObject)EditorGUILayout.ObjectField("Target", _target.target, typeof(GameObject), true);
        EditorGUILayout.EndVertical();



        EditorGUILayout.BeginVertical("box");

        // EditorGUILayout.FloatField("Agents In Formation", _target.agentsNum);
        _target.zLookAhead     = EditorGUILayout.FloatField("Look Ahead", _target.zLookAhead);
        _target.formationSpeed = EditorGUILayout.FloatField("Formation Speed", _target.formationSpeed);

        EditorGUILayout.EndVertical();



        EditorGUILayout.BeginVertical("box");

        FormationManager.Formations newValue = (FormationManager.Formations)EditorGUILayout.EnumPopup("Formation Type:", _target.formation);

        switch (newValue)
        {
        case FormationManager.Formations.SemiCircle:

            _target.radius  = EditorGUILayout.FloatField(new GUIContent("Radius", "The radius of the semicircle"), _target.radius);
            _target.concave = EditorGUILayout.Toggle(new GUIContent("Concave", "If you want that the semicircle will be concave"), _target.concave);

            break;

        case FormationManager.Formations.Circle:

            _target.radius = EditorGUILayout.FloatField(new GUIContent("Radius", "The radius of the semicircle"), _target.radius);

            break;

        case FormationManager.Formations.V:

            _target._separation = EditorGUILayout.FloatField(new GUIContent("Separation", "The separation between agents in the formation."), _target._separation);


            break;

        case FormationManager.Formations.Triangle:
            _target.length = EditorGUILayout.FloatField(new GUIContent("Length", "The separation between agents in the formation."), _target.length);


            break;

        case FormationManager.Formations.Wedge:
            _target._separation = EditorGUILayout.FloatField(new GUIContent("Separation", "The separation between agents in the formation."), _target._separation);
            _target.fill        = EditorGUILayout.Toggle(new GUIContent("Fill", "If you want that the agents fill the formation"), _target.fill);

            break;

        case FormationManager.Formations.Column:
            _target._separation = EditorGUILayout.FloatField(new GUIContent("Separation", "The separation between agents in the formation."), _target._separation);
            _target.columns     = EditorGUILayout.IntSlider(new GUIContent("Columns", "The number of columns to form"), _target.columns, 1, 100);
            break;

        case FormationManager.Formations.Diamond:
            _target.backPositionOffset = EditorGUILayout.Toggle(new GUIContent("backPositionOffset", "Should the back agents have a left and right offset?"), _target.backPositionOffset);
            _target._separation        = EditorGUILayout.FloatField(new GUIContent("Separation", "The separation between agents in the formation."), _target._separation);

            break;

        case FormationManager.Formations.Diagonal:
            _target.right       = EditorGUILayout.Toggle(new GUIContent("Right", "Should the formation be to the right of the leader?"), _target.right);
            _target._separation = EditorGUILayout.FloatField(new GUIContent("Separation", "The separation between agents in the formation."), _target._separation);

            break;

        case FormationManager.Formations.Grid:
            _target.columns     = EditorGUILayout.IntSlider(new GUIContent("Columns", "The number of columns to form"), _target.columns, 1, 100);
            _target._separation = EditorGUILayout.FloatField(new GUIContent("Separation", "The separation between agents in the formation."), _target._separation);

            break;

        case FormationManager.Formations.Line:
            _target._separation = EditorGUILayout.FloatField(new GUIContent("Separation", "The separation between agents in the formation."), _target._separation);
            _target.right       = EditorGUILayout.Toggle(new GUIContent("Right", "Should the formation be to the right of the leader?"), _target.right);

            break;

        default:
            break;
        }


        if (newValue != _target.formation)
        {
            _target.formation = newValue;

            EditorUtility.SetDirty(target);
        }
        EditorGUILayout.EndVertical();
        EditorGUILayout.Space();

        EditorGUILayout.BeginHorizontal("box");
        EditorGUILayout.BeginVertical();
        EditorGUILayout.Space();
        EditorGUILayout.LabelField("Select the tag of the Agents", EditorStyles.boldLabel);
        EditorGUILayout.Space();
        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.Space();
        _target.selectedTag = EditorGUILayout.TagField("Tag of Agents:", _target.selectedTag);


        if (_target.agentes != null && _target.agentes.Length == 0)
        {
            GUI.color = Color.red;
        }
        else
        {
            GUI.color = Color.green;
            if (_target.leaderAgent == null && _target.agentsNum > 1)
            {
                _target.leaderAgent = _target.agentes [_target.agentsNum - 1];
            }
        }


        if (GUILayout.Button("Load Agents from tag"))
        {
            _target.loadFromTags();
            _target.LoadAgentList();
            Debug.Log(_target.agentsNum);
            GUI.color = Color.white;
        }

        //if (GUILayout.Button("Test"))
        //{


        //}

        EditorGUILayout.EndHorizontal();
        EditorGUILayout.EndVertical();
        EditorGUILayout.EndHorizontal();

        EditorUtility.SetDirty(target);
    }
Exemplo n.º 15
0
    void OnSceneGUI()
    {
        FormationManager _target = (FormationManager)target;

        if (_target.leaderAgent != null)
        {
            Handles.color = Color.red;
            Handles.ArrowCap(0, _target.leaderAgent.transform.position, _target.leaderAgent.transform.rotation, 4f);
        }


        switch (_target.formation)
        {
        case FormationManager.Formations.SemiCircle:
            _target.theta = Mathf.PI / (_target.agentsNum * 2);
            for (int i = 0; i < _target.agentsNum; i++)
            {
                var pos = _target.GetSemiCirclePos(i, _target.zLookAhead);
                if (_target.leaderAgent != null)
                {
                    pos = pos + _target.leaderAgent.transform.position;
                }
                Handles.color = Color.red;
                Handles.SphereCap(i, pos, Quaternion.identity, 0.5f);
            }
            break;

        case FormationManager.Formations.Circle:
            _target.theta = Mathf.PI / (_target.agentsNum);
            for (int i = 0; i < _target.agentsNum; i++)
            {
                var pos = _target.GetCirclePos(i, _target.zLookAhead);
                if (_target.leaderAgent != null)
                {
                    pos = pos + _target.leaderAgent.transform.position;
                }
                Handles.color = Color.red;
                Handles.SphereCap(i, pos, Quaternion.identity, 0.5f);
            }
            break;

        case FormationManager.Formations.V:
            _target.separation = new Vector2(_target._separation, _target._separation);
            for (int i = 0; i < _target.agentsNum; i++)
            {
                var pos = _target.GetVPosition(i, _target.zLookAhead);
                if (_target.leaderAgent != null)
                {
                    pos = pos + _target.leaderAgent.transform.position;
                }
                Handles.color = Color.red;
                Handles.SphereCap(i, pos, Quaternion.identity, 0.5f);
            }
            break;

        case FormationManager.Formations.Triangle:
            for (int i = 0; i < 3; ++i)
            {
                _target.agentsPerSide [i] = _target.agentsNum / 3 + (_target.agentsNum % 3 > i ? 1 : 0);
            }
            for (int i = 0; i < _target.agentsNum; i++)
            {
                var pos = _target.GetTrianglePos(i, _target.zLookAhead);
                if (_target.leaderAgent != null)
                {
                    pos = pos + _target.leaderAgent.transform.position;
                }
                Handles.color = Color.red;
                Handles.SphereCap(i, pos, Quaternion.identity, 0.5f);
            }
            break;

        case FormationManager.Formations.Wedge:
            _target.separation = new Vector2(_target._separation, _target._separation);
            for (int i = 0; i < _target.agentsNum; i++)
            {
                var pos = _target.GetWedgePos(i, _target.zLookAhead);
                if (_target.leaderAgent != null)
                {
                    pos = pos + _target.leaderAgent.transform.position;
                }
                Handles.color = Color.red;
                Handles.SphereCap(i, pos, Quaternion.identity, 0.5f);
            }
            break;

        case FormationManager.Formations.Column:
            _target.separation = new Vector2(_target._separation, _target._separation);
            for (int i = 0; i < _target.agentsNum; i++)
            {
                var pos = _target.GetColumnPos(i, _target.zLookAhead);
                if (_target.leaderAgent != null)
                {
                    pos = pos + _target.leaderAgent.transform.position;
                }
                Handles.color = Color.red;
                Handles.SphereCap(i, pos, Quaternion.identity, 0.5f);
            }

            break;


        case FormationManager.Formations.Diamond:

            _target.separation = new Vector2(_target._separation, _target._separation);
            for (int i = 0; i < _target.agentsNum; i++)
            {
                var pos = _target.GetDiamondPos(i, _target.zLookAhead);
                if (_target.leaderAgent != null)
                {
                    pos = pos + _target.leaderAgent.transform.position;
                }
                Handles.color = Color.red;
                Handles.SphereCap(i, pos, Quaternion.identity, 0.5f);
            }
            break;

        case FormationManager.Formations.Diagonal:

            _target.separation = new Vector2(_target._separation, _target._separation);
            for (int i = 0; i < _target.agentsNum; i++)
            {
                var pos = _target.GetDiagonalPos(i, _target.zLookAhead);
                if (_target.leaderAgent != null)
                {
                    pos = pos + _target.leaderAgent.transform.position;
                }
                Handles.color = Color.red;
                Handles.SphereCap(i, pos, Quaternion.identity, 0.5f);
            }
            break;

        case FormationManager.Formations.Grid:

            _target.separation = new Vector2(_target._separation, _target._separation);
            for (int i = 0; i < _target.agentsNum; i++)
            {
                var pos = _target.GetGridPos(i, _target.zLookAhead);
                if (_target.leaderAgent != null)
                {
                    pos = pos + _target.leaderAgent.transform.position;
                }
                Handles.color = Color.red;
                Handles.SphereCap(i, pos, Quaternion.identity, 0.5f);
            }
            break;

        case FormationManager.Formations.Line:

            _target.separation = new Vector2(_target._separation, _target._separation);
            for (int i = 0; i < _target.agentsNum; i++)
            {
                var pos = _target.GetLinePos(i, _target.zLookAhead);
                if (_target.leaderAgent != null)
                {
                    pos = pos + _target.leaderAgent.transform.position;
                }
                Handles.color = Color.red;
                Handles.SphereCap(i, pos, Quaternion.identity, 0.5f);
            }
            break;

        default:
            break;
        }
    }
	public void setup()
	{
		formationManager = new FormationManager();
	}
Exemplo n.º 17
0
 void Awake()
 {
     manager = Object.FindObjectOfType <FormationManager>();
 }
Exemplo n.º 18
0
    Steering getDefaultSteering(Entry e, FormationManager generalManager, Flock flock)
    {
        var pattSteering = new PatternSteering(e.bird, generalManager);
        var separation = new Separation(e.bird, flock, 5.0f, -1f);
        separation.aknnApproxVal = 1.0;
        var obstacleAvoidance = new ObstacleAvoidance(e.bird, 20f, new string[]{"Ground"});

        var blended = new BlendedSteering[3];

        blended[0] = new BlendedSteering(e.bird, new BehaviorAndWeight(obstacleAvoidance, 1f));
        blended[1] = new BlendedSteering(e.bird, new BehaviorAndWeight(separation, 1f));
        blended[2] = new BlendedSteering(e.bird, new BehaviorAndWeight(pattSteering, 1f));

        return new PrioritySteering(1f, blended);
    }