private void OnEnable()
    {
        //enemyCount = UnityEngine.Random.Range(1, 5); //I kind of want to tweak this so 4 happens more often or at least it 'feels' random
        enemyCount = 1;
        player.GetComponent <Player_Movement>().enabled  = false;
        player.GetComponent <Rigidbody>().freezeRotation = true;

        alliesList = player.GetComponent <ListofAllies>().allies;

        foreach (GameObject obj in alliesList)
        {
            obj.GetComponent <Character>().CalculateStats();
        }

        characterList.Add(player);
        SpawnEnemies(enemyCount);
        SpawnAllies(alliesList.Count);
        player.GetComponent <HeroStateMachine>().enabled = true;
        activeHeroCount++;

        foreach (GameObject obj in characterList)
        {
            obj.GetComponent <Character>().enabled = true;
        }
        turnCount = characterList.Count;

        //disable camera mouseAim script
        mainCamera.GetComponent <Mouse_Aim>().enabled = false;

        //calculate camera position for battle
        battleCameraPosition    = player.transform.position + (0.5f * (player.transform.forward * enemyOffset)) - (player.transform.right * cameraHorizontalDistance);
        battleCameraPosition.y += cameraVerticalDistance;

        cameraTargetPosition   = player.transform.position + (player.transform.forward * (0.5f * enemyOffset)) + (player.transform.right * (1.5f * characterSpacing));
        cameraTargetPosition.y = 0;

        //enable corresponding camera script and move camera
        mainCamera.GetComponent <Camera_Battle>().enabled = true;
        mainCamera.GetComponent <Camera_Battle>().SetTargetPosition(cameraTargetPosition);
        mainCamera.GetComponent <Camera_Battle>().SetStandbyPosition(battleCameraPosition);

        battleCanvas.gameObject.SetActive(true);
        actionPanel.SetActive(false);
        enemySelectPanel.SetActive(false);
        victoryPanel.SetActive(false);
        defeatPanel.SetActive(false);
        initiativeBar.SetActive(true);
        heroPanel.SetActive(true);
        enemyPanel.SetActive(true);

        CharacterBars();
        EnemyButtons();

        ///FAIR WARNING I HAVE NO IDEA HOW THIS WORKS
        ///I STOLE IT FROM THE SECOND ANSWER ON THIS STACKEXCHANGE POST: https://stackoverflow.com/questions/3309188/how-to-sort-a-listt-by-a-property-in-the-object
        characterList.Sort((x, y) => y.GetComponent <Character>().Initiative.Value.CompareTo(x.GetComponent <Character>().Initiative.Value));

        battleState = BattleState.CollectEnemyActions;
        heroInput   = HeroInput.Wait;
    }
 public void EnemySelection(GameObject target)
 {
     heroAction.target = target;
     target.transform.GetChild(0).gameObject.SetActive(false);
     enemySelectPanel.SetActive(false);
     heroInput = HeroInput.Done;
 }
        public async Task <Hero> InsertAsync(HeroInput input)
        {
            var hero = new Hero(input.Name, new Editor(input.IdEditor), input.Age);

            if (!hero.IsValid())
            {
                _notification.NewNotificationBadRequest("Os dados são obrigatórios");
                return(default);
Exemple #4
0
        public async Task <IActionResult> Post([FromBody] HeroInput input)
        {
            var item = await _heroAppService
                       .InsertAsync(input)
                       .ConfigureAwait(false);

            return(CreatedContent("", item));
        }
 private void Start()
 {
     m_RigidBody = GetComponent <Rigidbody>();
     m_Capsule   = GetComponent <CapsuleCollider>();
     mouseLook.Init(transform, cam.transform);
     moveCam   = cam;
     heroInput = GetComponent <HeroBase>().GetInput();
 }
Exemple #6
0
        public async Task <Hero> Insert(HeroInput input)
        {
            //TODO: Criar metodo de obter o editor pelo Id
            var hero = new Hero(input.Name, new Editor(input.IdEditor), input.Age);

            if (!hero.IsValid())
            {
                _notification.NewNotificationBadRequest("Os dados não foram preenchidos corretamente!");
                return(default);
Exemple #7
0
 private void Awake()
 {
     cachedAnimation = GetComponent <Animator>();
     cachedBody      = GetComponent <Rigidbody2D>();
     cachedHands     = GetComponent <HeroHands>();
     cachedHero      = GetComponent <HeroStats>();
     cachedInput     = GetComponent <HeroInput>();
     cachedCollision = GetComponent <HeroCollisions>();
 }
Exemple #8
0
    //
    private void Awake()
    {
        cachedVisuals = GetComponent <GameVisuals>();

        cachedHero1Stats = hero1.GetComponent <HeroStats>();
        cachedHero1Input = hero1.GetComponent <HeroInput>();
        cachedHero2Stats = hero2.GetComponent <HeroStats>();
        cachedHero2Input = hero2.GetComponent <HeroInput>();
    }
Exemple #9
0
    public void Reset()
    {
        thirdPersonCamPosition = thirdPersonCam.transform.localPosition;
        thirdPersonCamRotation = thirdPersonCam.transform.localRotation;
        firstPerson            = true;
        gameObject.layer       = LayerMask.NameToLayer(team ? "Team1" : "Team2");
        foreach (MonoBehaviour c in GetComponents <MonoBehaviour>())
        {
            c.enabled = true;
        }
        body = GetComponent <Rigidbody>();

        HeroInput[] inputs = GetComponents <HeroInput>();
        camera = firstPersonCam;
        if (ai)
        {
            GetComponent <PlayerInput>().enabled = false;
            foreach (AudioListener al in GetComponentsInChildren <AudioListener>())
            {
                al.enabled = false;
            }
            foreach (Camera cam in GetComponentsInChildren <Camera>())
            {
                cam.enabled = false;
            }
        }
        else
        {
            GetComponent <AIInput>().enabled = false;
        }

        foreach (HeroInput i in inputs)
        {
            if (i.enabled)
            {
                input = i;
            }
        }

        if (ai)
        {
            Material[] theMaterials = new Material[2];
            theMaterials[1] = heroMaterial;
            theMaterials[0] = new Material(outlineMaterial);
            theMaterials[0].SetColor("_OutlineColor", IsClientFriendly() ? Color.blue : Color.red);
            GetComponent <Renderer>().materials = theMaterials;
        }
        else
        {
            GetComponent <Renderer>().material = heroMaterial;

            camera = firstPersonCam;
            firstPersonCam.enabled = true;
            thirdPersonCam.enabled = false;
        }
    }
Exemple #10
0
    //
    private void Awake()
    {
        cachedHands     = GetComponent <HeroHands>();
        cachedInput     = GetComponent <HeroInput>();
        cachedCollision = GetComponent <HeroCollisions>();
        cachedBody      = GetComponent <Rigidbody2D>();
        cachedTransform = GetComponent <Transform>();

        stableRotation = Quaternion.LookRotation(Vector3.forward, Vector3.up);
    }
 public void HeroInputDone()
 {
     heroAction.actor = heroesToManage[0];
     heroesToManage[0].GetComponent <HeroStateMachine>().action = new ActionInfo(heroAction);
     heroesToManage[0].transform.GetChild(0).gameObject.SetActive(false);
     heroesToManage.RemoveAt(0);
     AddAction(heroAction);
     actionPanel.SetActive(false);
     heroInput = HeroInput.Active;
 }
Exemple #12
0
        void Awake()
        {
            input  = new HeroInput();
            random = new System.Random();

            input.Player.Move.performed   += ctx => OnMove(ctx);
            input.Player.Jump.performed   += ctx => OnJump(ctx);
            input.Player.Attack.performed += ctx => OnAttack(ctx);
            input.Player.Block.performed  += ctx => OnBlock(ctx);
            input.Player.Roll.performed   += ctx => OnRoll(ctx);
        }
Exemple #13
0
    //--------------------------------------------------------------------------------
    // EVENT CALLBACKS
    //--------------------------------------------------------------------------------

    void Awake()
    {
        // EAGERLY ACQUIRE SINGLETON REFERENCE
        inst = this;

        // CACHE COMMON SIBLINGS
        input = GetComponent <HeroInput>();
        fx    = GetComponentInChildren <HeroFX>();
        body  = this.rigidbody;
        xform = this.transform;
    }
 public IActionResult Post([FromBody] HeroInput input)
 {
     try
     {
         var item = _heroAppService.Insert(input);
         return(Created("", item));
     }
     catch (ArgumentException ex)
     {
         return(BadRequest($"Erro => {ex.Message}"));
     }
 }
Exemple #15
0
        // Start is called before the first frame update
        void Awake()
        {
            health         = GetComponent <Health>();
            collider2d     = GetComponent <Collider2D>();
            spriteRenderer = GetComponent <SpriteRenderer>();
            animator       = GetComponent <Animator>();

            input  = new HeroInput();
            random = new System.Random();

            input.Player.Move.performed   += ctx => OnMove(ctx);
            input.Player.Jump.performed   += ctx => OnJump(ctx);
            input.Player.Attack.performed += ctx => OnAttack(ctx);
            input.Player.Block.performed  += ctx => OnBlock(ctx);
            input.Player.Roll.performed   += ctx => OnRoll(ctx);
        }
 void returnToCenter(HeroInput input)
 {
     if (locking && toAdd < 0.05f && toAdd > -0.05f)
     {
         locking = false;
         locked  = false;
         return;
     }
     if (toAdd > 0)
     {
         toAdd -= 0.05f;
     }
     if (toAdd < 0)
     {
         toAdd += 0.05f;
     }
 }
    // Update is called once per frame
    void Update()
    {
//				marker.transform.position = new Vector2 (transform.position.x, transform.position.y);
        HeroInput input = hero.GetComponent <HeroInput> ();

        if (input != null)
        {
            //returnToCenter (input);
        }
        if (locking || locked)
        {
            this.transform.position = new Vector3(hero.transform.position.x + toAdd, this.transform.position.y, this.transform.position.z);
        }
        if (input != null)
        {
            if (input.getSpeedX() > 0)
            {
                if (toAdd > -gravyZoneWidth)
                {
                    this.locking = true;
                    this.locked  = false;
                    toAdd       -= input.getSpeedX();
                }
                else
                {
                    this.locking = false;
                    this.locked  = true;
                }
            }
            if (input.getSpeedX() < 0)
            {
                if (toAdd < gravyZoneWidth)
                {
                    this.locking = true;
                    this.locked  = false;
                    toAdd       -= input.getSpeedX();
                }
                else
                {
                    this.locking = false;
                    this.locked  = true;
                }
            }
        }
    }
Exemple #18
0
    public void Grab()
    {
        if (detectedObject == null)
        {
            return;
        }
        if (grabbedObject)
        {
            return;
        }
        if (grabbedJoint)
        {
            return;
        }

        grabbedObject = detectedObject;

        HeroInput grabbedInput = grabbedObject.GetComponent <HeroInput>();

        if (grabbedInput && grabbedInput.IsBlocking())
        {
            grabbedObject = null;
            return;
        }

        JamSuite.Physics2D.IgnoreCollision(grabbedObject.gameObject, cachedBody.gameObject, true);

        grabbedObject.transform.position = cachedTransform.position + Vector3.up * grabOffset;
        grabbedObject.gameObject.BroadcastMessage("PrepareForGrab", SendMessageOptions.DontRequireReceiver);

        grabbedMass        = grabbedObject.mass;
        grabbedObject.mass = grabMass;

        grabbedJoint               = gameObject.AddComponent <HingeJoint2D>();
        grabbedJoint.anchor        = new Vector2(0.0f, grabOffset);
        grabbedJoint.connectedBody = grabbedObject;
        grabbedJoint.useLimits     = true;
        grabbedJoint.limits        = new JointAngleLimits2D()
        {
            min = 0.0f, max = 0.0f
        };
    }
        public async Task Validar_Metodo_Insert_Sem_Dados_Obrigatorios(string name, int idEditor, int age)
        {
            //Arrange
            var input = new HeroInput();

            input.Name     = name;
            input.IdEditor = idEditor;
            input.Age      = age;

            //Act
            var result = await this.heroAppService
                         .InsertAsync(input)
                         .ConfigureAwait(false);

            //Assert
            result
            .Should()
            .Be(default(Hero));

            domainNotificationHandler
            .GetNotifications()
            .Should()
            .HaveCount(1);

            domainNotificationHandler
            .GetNotifications()
            .FirstOrDefault()
            .DomainNotificationType
            .Should()
            .Be(DomainNotificationType.BadRequest);

            domainNotificationHandler
            .GetNotifications()
            .FirstOrDefault()
            .Value
            .Should()
            .Be("Os dados são obrigatórios");
        }
        public async Task Validar_Metodo_Insert_Sem_Dados_Obrigatorios()
        {
            // Arrange
            var input = new HeroInput();

            // Act
            var result = await this
                         .heroAppService
                         .Insert(input)
                         .ConfigureAwait(false);

            // Assert
            result
            .Should()
            .Be(default(Hero));

            domainNotificationHandler
            .GetNotifications()
            .Should()
            .HaveCount(1);


            domainNotificationHandler
            .GetNotifications()
            .FirstOrDefault()
            .DomainNotificationType
            .Should()
            .Be(DomainNotificationType.BadRequest);

            domainNotificationHandler
            .GetNotifications()
            .FirstOrDefault()
            .Value
            .Should()
            .Be("Os dados não foram preenchidos corretamente!");
        }
        public void LookRotation(Transform character, Transform camera, HeroInput input)
        {
            if (!input.mousePosIsFinal)
            {
                float yRot = input.GetMouseX() * XSensitivity;
                float xRot = input.GetMouseY() * YSensitivity;

                m_CharacterTargetRot *= Quaternion.Euler(0f, yRot, 0f);
                m_CameraTargetRot    *= Quaternion.Euler(-xRot, 0f, 0f);
            }
            else
            {
                m_CharacterTargetRot = Quaternion.Euler(0f, input.GetMouseY(), 0f);
                m_CameraTargetRot    = Quaternion.Euler(-input.GetMouseX(), 0f, 0f);
            }

            if (clampVerticalRotation)
            {
                m_CameraTargetRot = ClampRotationAroundXAxis(m_CameraTargetRot);
            }

            if (smooth)
            {
                character.localRotation = Quaternion.Slerp(character.localRotation, m_CharacterTargetRot,
                                                           smoothTime * Time.deltaTime);
                camera.localRotation = Quaternion.Slerp(camera.localRotation, m_CameraTargetRot,
                                                        smoothTime * Time.deltaTime);
            }
            else
            {
                character.localRotation = m_CharacterTargetRot;
                camera.localRotation    = m_CameraTargetRot;
            }

            UpdateCursorLock();
        }
    // Update is called once per frame
    void Update()
    {
        switch (battleState)
        {
        case BattleState.CollectEnemyActions:
            foreach (GameObject obj in characterList)
            {
                if (obj.GetComponent <EnemyStateMachine>() != null && !obj.GetComponent <Character>().isDead)
                {
                    obj.GetComponent <EnemyStateMachine>().currentState = EnemyStateMachine.State.Thinking;
                }
                if (obj.GetComponent <HeroStateMachine>() != null && !obj.GetComponent <Character>().isDead)
                {
                    heroesToManage.Add(obj);
                }
            }
            battleState = BattleState.Wait;
            heroInput   = HeroInput.Active;
            break;

        case BattleState.Wait:
            if (heroesToManage.Count == 0)
            {
                battleState = BattleState.ExecuteActions;
            }
            break;

        case BattleState.ExecuteActions:
            if (turnCount == 0)
            {
                battleState = BattleState.AssessBattleCondition;
                break;
            }

            if (characterList[0].GetComponent <EnemyStateMachine>() != null)
            {
                characterList[0].GetComponent <EnemyStateMachine>().currentState = EnemyStateMachine.State.Acting;
            }
            if (characterList[0].GetComponent <HeroStateMachine>() != null)
            {
                characterList[0].GetComponent <HeroStateMachine>().currentState = HeroStateMachine.State.Acting;
            }
            break;

        case BattleState.AssessBattleCondition:
            if (activeEnemyCount <= 0)
            {
                heroPanel.SetActive(false);
                enemyPanel.SetActive(false);
                initiativeBar.SetActive(false);
                actionPanel.SetActive(false);
                enemySelectPanel.SetActive(false);

                int totalExp = 0;
                foreach (GameObject obj in deadCharacters)
                {
                    if (obj.GetComponent <EnemyStateMachine>() != null)
                    {
                        totalExp += obj.GetComponent <Character>().expIfDefeated;
                        totalExp += UnityEngine.Random.Range(5 * obj.GetComponent <Character>().Level, (100 * obj.GetComponent <Character>().Level) + 1);
                    }
                }
                battleState = BattleState.EndOfBattle;

                DisplayExperience(totalExp);
                DisplayItems();

                victoryPanel.SetActive(true);

                break;
            }
            else if (activeHeroCount <= 0)
            {
                heroPanel.SetActive(false);
                enemyPanel.SetActive(false);
                initiativeBar.SetActive(false);
                actionPanel.SetActive(false);
                enemySelectPanel.SetActive(false);

                defeatPanel.SetActive(true);

                battleState = BattleState.EndOfBattle;
                break;
            }
            else
            {
                foreach (GameObject obj in characterList)
                {
                    obj.GetComponent <Character>().isDefending = false;
                    obj.transform.GetChild(1).gameObject.SetActive(false);
                }

                turnCount   = characterList.Count;
                battleState = BattleState.CollectEnemyActions;
                break;
            }

        case BattleState.EndOfBattle:
            break;

        default:
            Debug.LogError("Battle State Error");
            break;
        }

        switch (heroInput)
        {
        case HeroInput.Active:
            if (heroesToManage.Count > 0)
            {
                //heroAction = new ActionInfo();
                actionPanel.SetActive(true);
                CheckEnemyButtons();
                heroesToManage[0].transform.GetChild(0).gameObject.SetActive(true);
                heroInput = HeroInput.Wait;
            }
            break;

        case HeroInput.Wait:
            break;

        case HeroInput.Done:
            HeroInputDone();
            break;

        default:
            Debug.LogError("Hero Input State Error");
            break;
        }
    }
Exemple #23
0
 void Awake()
 {
     input = new HeroInput();
 }
Exemple #24
0
    //--------------------------------------------------------------------------------
    // EVENT CALLBACKS
    //--------------------------------------------------------------------------------
    void Awake()
    {
        // EAGERLY ACQUIRE SINGLETON REFERENCE
        inst = this;

        // CACHE COMMON SIBLINGS
        input = GetComponent<HeroInput>();
        fx = GetComponentInChildren<HeroFX>();
        body = this.rigidbody;
        xform = this.transform;
    }
Exemple #25
0
 //
 private void Awake()
 {
     cachedRenderer = GetComponent <SpriteRenderer>();
     cachedInput    = GetComponent <HeroInput>();
 }
 public void DefendAction()
 {
     heroAction.actionType = ActionInfo.ActionType.Defend;
     heroInput             = HeroInput.Done;
 }