示例#1
0
        private void Start()
        {
            j_Interactable = GetComponent <JMRInteractable>();

            if (j_Interactable)
            {
                j_Interactable.SwipeLeft  += OnHorizontalSwipe;
                j_Interactable.SwipeRight += OnHorizontalSwipe;
                j_Interactable.SwipeUp    += OnVerticalSwipe;
                j_Interactable.SwipeDown  += OnVerticalSwipe;
            }
            else
            {
                throw new MissingComponentException("Interactable component missing from the object");
            }

            if (JMRPointerManager.Instance != null)
            {
                j_RaycastCam = JMRPointerManager.Instance.UIRaycastCamera;
            }
            else
            {
                throw new MissingComponentException("Raycast Camera component missing from the Scene");
            }
            j_SliderRect          = GetComponent <RectTransform>();
            j_SliderStartDistance = j_SliderRect.rect.xMin;
            j_SliderEndDistance   = j_SliderRect.rect.xMax;
            InitializeSliderHandle();
            OnValueUpdated?.Invoke(j_SliderValue);

            j_Cursor = FindObjectOfType(typeof(JMRCursor)) as JMRCursor;
        }
示例#2
0
        public void InvokeValue(float value)
        {
            _value = value;

            onValue?.Invoke(value);
            _onValue?.Invoke(value);
        }
示例#3
0
        public virtual void Progress(Single value, PlaybackDirection direction)
        {
            Initialize();

            onProgress?.Invoke((direction == PlaybackDirection.FORWARD) ? value : 1f - value);
            _onProgress?.Invoke((direction == PlaybackDirection.FORWARD) ? value : 1f - value);

            AtProgress(value, direction);

            if (value >= 1f)
            {
                switch (repeat)
                {
                case RepeatType.ZERO_TO_ONE:
                    if (direction == PlaybackDirection.FORWARD)
                    {
                        PlayForward(true);
                    }
                    else
                    {
                        PlayBackward(true);
                    }
                    break;

                case RepeatType.PING_PONG:
                    Toggle(true);
                    break;
                }
            }
        }
示例#4
0
    public void LaunchVictoryAnimation(CharId winnerCharId)
    {
        // stop music
        GameObject.FindGameObjectWithTag("Music")?.SetActive(false);

        // setup delayed tasks
        float cachedAnimationDuration = SpecialTitleAnimationDuration;

        // play ad
        (this).ExecuteAfterTime(cachedAnimationDuration + VICTORY_SCREEN_DURATION, () =>
        {
            ShowAdThenShowScene();
        });

        // start timer
        this.ExecuteAfterTime(cachedAnimationDuration, () =>
        {
            _timerRemainingTime.StartTimer(VICTORY_SCREEN_DURATION);
        });

        // update canvas activation
        DeactivateGamePanel();
        _victoryCanvas.SetActive(true);

        OnLaunchVictoryAnimation?.Invoke(VICTORY_SCREEN_DURATION);

        CameraEffectController.Instance.EnableBlur(true);

        // update content
        SetWinnerContent(winnerCharId);
        SetSpecialPlayersContent(winnerCharId); // we put it at the end of method, if it has errors
    }
 /// <summary>
 ///   <para>Mark the ContentSizeFitter as dirty.</para>
 /// </summary>
 protected void SetDirty()
 {
     if (IsActive())
     {
         OnRectWidthChange?.Invoke(rectTransform.rect.size.x);
         OnRectHeightChange?.Invoke(rectTransform.rect.size.y);
     }
 }
示例#6
0
 private void CheckCollision(Collision2D col)
 {
     CollisionStrength = col.relativeVelocity.magnitude;
     if (ValidateLayer)
     {
         //01000100 (mask)
         //&
         //00100000 (test)
         //=
         //00000000 (test not "in" mask)
         var testMask = 1 << col.gameObject.layer;
         if ((Mask.value & testMask) != 0)
         {
             Callback?.Invoke(CollisionStrength);
         }
     }
     else
     {
         Callback?.Invoke(CollisionStrength);
     }
 }
    private IEnumerator LoadSceneAsyncProcess(int sceneBuildIndex, LoadSceneMode loadSceneMode, UnityEventFloat onLoadingSceneAsync)
    {
        AsyncOperation sceneLoadingAsyncOperation = SceneManager.LoadSceneAsync(sceneBuildIndex, loadSceneMode);

        while (!sceneLoadingAsyncOperation.isDone)
        {
            this._onLoadingSceneAsync.Invoke(sceneLoadingAsyncOperation.progress);
            onLoadingSceneAsync?.Invoke(sceneLoadingAsyncOperation.progress);

            yield return(null);
        }
    }
        public override void UpdateValue()
        {
            handDevice.TryGetFeatureValue(inputFeature, out value);

            if (value != prevValue)
            {
                StateChanged.Invoke(value);

                if (value.x != prevValue.x)
                {
                    MovedX?.Invoke(value.x);
                }
                else if (value.y != prevValue.y)
                {
                    MovedY?.Invoke(value.y);
                }

                prevValue = value;
            }

            handDevice.TryGetFeatureValue(touch, out bool _touched);
            handDevice.TryGetFeatureValue(click, out bool _clicked);

            if (_touched != touched)
            {
                if (_touched)
                {
                    Touched.Invoke();
                }
                else
                {
                    UnTouched.Invoke();
                }

                touched = _touched;
            }

            if (_clicked != clicked)
            {
                if (_clicked)
                {
                    Clicked.Invoke();
                }
                else
                {
                    UnClicked.Invoke();
                }

                clicked = _clicked;
            }
        }
示例#9
0
    public void Hit(int p = 1)
    {
        points -= p;

        isHit = true;

        onPlayerHit?.Invoke();
        onPlayerBecomeInvincible?.Invoke(invincibleDuration);

        if (points <= 0)
        {
            onPlayerDeath?.Invoke();
        }
    }
示例#10
0
    public void TakeDamage(int amount)
    {
        currentHealth -= amount;
        if (currentHealth <= 0)
        {
            currentHealth = 0;

            if (this.transform.root.tag == "Player")
            {
                SceneManager.LoadScene("Menu");
            }
            else
            {
                Destroy(this.gameObject);
            }
        }

        // Notify UI about change of health percentage
        healthPercentageUpdate.Invoke((float)currentHealth / maxHealth);
    }
示例#11
0
    void WasHitEvent(float damage)
    {
        AdjustStatValue(-damage);
        if (GetStatValue() <= 0)    // Health 0
        {
            lives -= 1;             // Decrease lives
            wasKilledEvent.Invoke(lives);

            if (lives <= 0)               // No more lives
            {
                DestroyObject(playerM.tankObj);
                lostEvent.Invoke(0);
            }
            else                 // Respawn
            {
                playerM.tankObj.transform.position = spawnPoint;
                SetStatPercent(100);
            }
        }
    }
示例#12
0
    internal override void ChartPreview(Vector3 worldPosition)
    {
        RectTransform rectTransform = (RectTransform)transform;

        Vector3[] corners = new Vector3[4];
        rectTransform.GetWorldCorners(corners);

        Vector3 middleLine     = Vector3.Lerp(corners[0], corners[1], 0.5f);
        Vector3 position       = ProjectPointOnLine(middleLine, base.transform.right, worldPosition);
        float   lengthPosition = Vector3.Distance(middleLine, position);

        float widthLength = Vector3.Distance(corners[1], corners[2]);
        float ratio       = lengthPosition / widthLength;

        if (_preview != null)
        {
            _preview.position = position;
        }
        onValuePreview.Invoke(ratio);
        _onValuePreview.Invoke(ratio);
    }
示例#13
0
        public override void OnEventRaised(float input)
        {
            base.OnEventRaised(input);

            response.Invoke(input);
        }
示例#14
0
    public void Set(float value)
    {
        var v = (((value - minIn) / (maxIn - minIn)) * (maxOut - minOut)) + minOut;

        onValue.Invoke(v);
    }
示例#15
0
 public void OnEventRaised(float parameter)
 {
     ResponseFloat.Invoke(parameter);
 }
示例#16
0
    // Update is called once per frame
    void Update()
    {
        if (health.hasDied())
        {
            return;
        }

        Vector2 thisPos = transform.position;

        //////////////////////////////////////// Oxygen //////////////////////////////////////////////////
        if (submergePhysic.getDiveState() == DiveState.fullyInWater)
        {
            oxygen -= Time.deltaTime * oxygenDepletionRate;
        }
        else
        {
            oxygen = maxOxygen;
        }
        if (oxygen < 0)
        {
            health.damage(health.getHealth());
        }

        //////////////////////////////////////// Movement ///////////////////////////////////////////////

        // Is player touching ground?
        touchGround = Physics2D.CircleCast(thisPos, circleCollider.radius, Vector2.down, 0.05f, TerrainMask).collider != null;
        anim.SetBool("touchground", touchGround);

        Vector2 moveVec = Vector2.zero;
        // Land Movement
        Vector2 landMoveVec = Vector2.zero;

        if (touchGround)
        {
            if (Input.GetKey(left))
            {
                landMoveVec += Vector2.left;
            }
            if (Input.GetKey(right))
            {
                landMoveVec += Vector2.right;
            }
            if (Input.GetKeyDown(keyJump) && Time.time > timeLastJump + jumpCoolDown)
            {
                timeLastJump = Time.time;
                RB.AddForce(Vector2.up * jumpSpeed);
            }
        }

        // Aqua Control
        Vector2 aquaMoveVec = Vector2.zero;

        if (Input.GetKey(up))
        {
            aquaMoveVec += Vector2.up;
        }
        if (Input.GetKey(down))
        {
            aquaMoveVec += Vector2.down;
        }
        if (Input.GetKey(left))
        {
            aquaMoveVec += Vector2.left;
        }
        if (Input.GetKey(right))
        {
            aquaMoveVec += Vector2.right;
        }
        float submergeRatio = Mathf.Clamp(submergePhysic.getSubmergeRatio(), 0.0f, 1.0f);

        // Sum up move force
        moveVec = ((aquaMoveVec.normalized * submergeRatio).normalized * swimSpeed + landMoveVec.normalized * walkSpeed);

        // Move body
        RB.AddForce(moveVec * Time.deltaTime);

        // Limit land walk speed
        float currMovementSpeed = RB.velocity.magnitude;

        if (touchGround && currMovementSpeed > maxLandWalkSpeed)
        {
            RB.velocity *= maxLandWalkSpeed / currMovementSpeed;
        }

        //////////////////////////////////// Animation ////////////////////////////////////////////////////////
        Vector2 animMoveDir;

        if (submergePhysic.getDiveState() != DiveState.fullyInWater)
        {
            animMoveDir = moveVec;
        }
        else
        {
            animMoveDir = RB.velocity;
        }

        // Update moveDirection reference gameobject
        if (animMoveDir.sqrMagnitude != 0.0f)
        {
            float moveAngle = Mathf.Atan2(animMoveDir.y, animMoveDir.x) * 180.0f / 3.14f;
            playerDirectionTransform.rotation = Quaternion.Euler(0, 0, moveAngle);
            OnMoveTowardAngle.Invoke(moveAngle);
        }

        // Facing left or right?
        Vector3 flipScale = anim.transform.localScale;

        if (animMoveDir.x > 0.0f)
        {
            flipScale.x = Mathf.Abs(flipScale.x);
            anim.transform.localScale = flipScale;
        }
        else if (animMoveDir.x < 0.0f)
        {
            flipScale.x = Mathf.Abs(flipScale.x) * -1;
            anim.transform.localScale = flipScale;
        }

        // Rotate via swim direction under water
        if (submergePhysic.getDiveState() == DiveState.fullyInWater)
        {
            // Change rotation only when swimming
            if (animMoveDir != Vector2.zero)
            {
                float movementRightAngle        = Mathf.Atan2(animMoveDir.y, Mathf.Abs(animMoveDir.x)) * 180.0f / 3.14f;
                float movementRightAngleClamped = Mathf.Clamp(movementRightAngle, pitchMinAngle, pitchMaxAngle);

                if (flipScale.x < 0.0f)
                {
                    movementRightAngleClamped *= -1;
                }

                anim.transform.rotation = Quaternion.Euler(0, 0, movementRightAngleClamped);
            }
        }
        // Resume upright rotation
        else
        {
            anim.transform.rotation = Quaternion.identity;
        }

        anim.SetBool("fullyinwater", (submergePhysic.getDiveState() == DiveState.fullyInWater));
        anim.SetFloat("speed", RB.velocity.magnitude / 5.0f);
    }
示例#17
0
 private void Update()
 {
     updateValue.Invoke(value);
 }
    void FixedUpdate()
    {
        rb.velocity        = Vector3.zero;
        rb.angularVelocity = 0;

        if (MoveInput != Vector2.zero)
        {
            // Input angle, clamped between 0 and 360
            float inputAngle = (Mathf.Atan2(MoveInput.y, MoveInput.x) * Mathf.Rad2Deg);
            while (inputAngle < 0)
            {
                inputAngle += 360;
            }

            float currentAngle = transform.eulerAngles.z;

            // Angle diff, soft clamped between -180 and 180
            float angleDiff = inputAngle - currentAngle;
            if (angleDiff < -180)
            {
                angleDiff += 360;
            }
            else if (angleDiff > 180)
            {
                angleDiff -= 360;
            }
            else if (angleDiff == 180)                 // Prefer clockwise full turns;
            {
                angleDiff = -180;
            }

            // Rotate if needed
            if (angleDiff != 0)
            {
                float rotateAmt = Time.deltaTime * TankTweaksProp.rotationSpeed;                 // Usual rotate amt
                if (angleDiff < 0)
                {
                    rotateAmt *= -1;
                    rotateAmt  = Mathf.Max(rotateAmt, angleDiff);                    // Clamp with angleDiff
                }
                else                                                                 // angleDiff > 0
                {
                    rotateAmt = Mathf.Min(rotateAmt, angleDiff);                     // Clamp with angleDiff
                }
                transform.eulerAngles = new Vector3(0, 0, currentAngle + rotateAmt); // Add to rotation
            }

            // Move
            // if (!IsAnchored) { // Not anchored
            float moveAmt = Time.deltaTime * TankTweaksProp.maxSpeed;    // Usual move amt
            moveAmt *= ((180 - Mathf.Abs(angleDiff)) / 180);             // Reduce if facing away

            Vector3 moveVec3 = transform.right * moveAmt;
            Vector2 moveVec2 = rb.position + (new Vector2(moveVec3.x, moveVec3.y));
            rb.MovePosition(moveVec2);

            moveEvent.Invoke(moveAmt);
            // }

            // Reset vector for next time
            MoveInput = Vector2.zero;
        }
    }
示例#19
0
 public float Update(float duration)
 {
     OnUpdate.Invoke(Values.Evaluate(duration));
     return(Values.Evaluate(duration));
 }
示例#20
0
 public void NotifyValue(float horizontal, float vertical)
 {
     onHorizontalChange.Invoke(horizontal * outputMultiplier);
     onVerticalChange.Invoke(vertical * outputMultiplier);
 }
示例#21
0
 public void SubmitFieldValue()
 {
     m_onEndEdit.Invoke(fieldValue);
 }
示例#22
0
 protected override void SetValue(float normalisedPoint)
 {
     Callback.Invoke(Mathf.Lerp(FromValue, ToValue, normalisedPoint));
 }
示例#23
0
 // -- Public Functions
 public void OnEventRaised(float value)
 {
     EventFloatResponse.Invoke(value);
 }
示例#24
0
 void OnSignal(float f)
 {
     callback.Invoke(f);
 }
示例#25
0
 private void MoveMouseX(float value)
 {
     moveMouseX.Invoke(value);
 }
 public void OnEventRaised(float payload)
 {
     Response.Invoke(payload);
 }
示例#27
0
 public void Axis2DUpdate(Vector2 data)
 {
     Moved2D.Invoke(data);
     Moved2DX.Invoke(data.x);
     Moved2DY.Invoke(data.y);
 }
 private void Awake()
 {
     onAwake.Invoke(variableSO.RuntimeValue);
     listener = new VariableListenerClass <VariableFloat, float, UnityEventFloat>(variableSO, onVariableChanged);
 }
    void OnTriggerEnter(Collider other)
    {
        Debug.Log("OnTargetDirectionDetected :" + targeDirectionValue.ToString());

        OnTargetDirectionDetected.Invoke(targeDirectionValue);
    }
 private void Update()
 {
     t += Time.deltaTime / duration;
     t %= 1;
     onValue.Invoke(curve.Evaluate(t));
 }