Exemplo n.º 1
0
        public override void PostDraw()
        {
            base.PostDraw();

            // Children & Pregnancy || Werewolves transformed
            if (this.Pawn.Map == null || !this.Pawn.Spawned || this.Pawn.Dead)
            {
                return;
            }

            if (Find.TickManager.Paused)
            {
                if (!HarmonyPatchesFS.AnimatorIsOpen() || MainTabWindow_BaseAnimator.Pawn != this.Pawn)
                {
                    return;
                }
            }

            if (this.Props.bipedWithHands)
            {
                this.BodyAnimator.AnimatorTick();
            }

            // Tweener
            Vector3Tween eqTween = this.Vector3Tweens[(int)HarmonyPatchesFS.equipment];

            FloatTween   angleTween = this.AimAngleTween;
            Vector3Tween leftHand   = this.Vector3Tweens[(int)TweenThing.HandLeft];
            Vector3Tween rightHand  = this.Vector3Tweens[(int)TweenThing.HandRight];

            if (leftHand.State == TweenState.Running)
            {
                leftHand.Update(1f * Find.TickManager.TickRateMultiplier);
            }
            if (rightHand.State == TweenState.Running)
            {
                rightHand.Update(1f * Find.TickManager.TickRateMultiplier);
            }
            if (eqTween.State == TweenState.Running)
            {
                eqTween.Update(1f * Find.TickManager.TickRateMultiplier);
            }

            if (angleTween.State == TweenState.Running)
            {
                this.AimAngleTween.Update(3f * Find.TickManager.TickRateMultiplier);
            }

            this.CheckMovement();
        }
Exemplo n.º 2
0
        //ToDO: Move this and the Face PostDraw to Postfix // Verse.Pawn_DrawTracker.DrawTrackerTick()
        public override void PostDraw()
        {
            base.PostDraw();

            // Children & Pregnancy || Werewolves transformed
            if (this.Pawn.Map == null || !this.Pawn.Spawned || this.Pawn.Dead || this.Pawn.GetCompAnim().Deactivated)
            {
                return;
            }

            //if (Find.TickManager.Paused)
            //{
            //    if (!HarmonyPatchesFS.AnimatorIsOpen() || MainTabWindow_BaseAnimator.Pawn != this.Pawn)
            //    {
            //        if (!Pawn.IsChild()) return;
            //    }
            //}

            if (this.Props.bipedWithHands)
            {
                this.BodyAnimator.AnimatorTick();
            }

            // Tweener
            Vector3Tween eqTween = this.Vector3Tweens[(int)HarmonyPatchesFS.equipment];

            FloatTween   angleTween = this.AimAngleTween;
            Vector3Tween leftHand   = this.Vector3Tweens[(int)TweenThing.HandLeft];
            Vector3Tween rightHand  = this.Vector3Tweens[(int)TweenThing.HandRight];

            if (!Find.TickManager.Paused)
            {
                if (leftHand.State == TweenState.Running)
                {
                    leftHand.Update(1f * Find.TickManager.TickRateMultiplier);
                }
                if (rightHand.State == TweenState.Running)
                {
                    rightHand.Update(1f * Find.TickManager.TickRateMultiplier);
                }
                if (eqTween.State == TweenState.Running)
                {
                    eqTween.Update(1f * Find.TickManager.TickRateMultiplier);
                }

                if (angleTween.State == TweenState.Running)
                {
                    this.AimAngleTween.Update(3f * Find.TickManager.TickRateMultiplier);
                }

                this.CheckMovement();

                if (this.Pawn.IsChild())
                {
                    this.TickDrawers(this.Pawn.Rotation, new PawnGraphicSet(this.Pawn));
                }
            }


            if (this.Pawn.IsChild())
            {
                float      angle    = this.Pawn.Drawer.renderer.BodyAngle();
                Quaternion bodyQuat = Quaternion.AngleAxis(angle, Vector3.up);
                Vector3    rootLoc  = this.Pawn.Drawer.DrawPos;
                if (Controller.settings.UseHands)
                {
                    this.DrawHands(bodyQuat, rootLoc, false, null, false, this.Pawn.GetBodysizeScaling());
                }
                if (Controller.settings.UseFeet)
                {
                    this.DrawFeet(bodyQuat, bodyQuat, rootLoc, false);
                }
            }
        }
        private void Update(float deltaTime)
        {
            if (!mTargetInited)
            {
                return;
            }
            bool flag = false;

            mTweenTargetOffset.Update(deltaTime);
            Vector3 pos = mTweenTargetOffset.Value;

            if (FollowTarget != null)
            {
                pos += FollowTarget.position;
            }
            bool targetMoved = false;

            if ((mPrevPos - pos).sqrMagnitude > 1E-8f)
            {
                targetMoved = true;
                mPrevPos    = pos;
            }
            if (targetMoved || (pos - mTargetPos.Value).sqrMagnitude > 1E-8f)
            {
                switch (mTargetPos.State)
                {
                case ePropTweenState.None:
                    if (mFollowSpeedFactor <= 0f)
                    {
                        mTargetPos.Value = pos;
                    }
                    else
                    {
                        mTargetPos.GoTo(pos, mFollowSpeedFactor, mFollowMinSpeed, mFollowMaxSpeed);
                        mPropTweening = true;
                    }
                    break;

                case ePropTweenState.SpeedControl:
                    mTargetPos.To = pos;
                    break;
                }
                flag = true;
            }
            if (mPropTweening)
            {
                mPropTweening = false;
                if (mTargetPos.Update(deltaTime) != eUpdateReturn.Finished)
                {
                    mPropTweening = true;
                }
                if (mRotY.Update(deltaTime) != eUpdateReturn.Finished)
                {
                    mPropTweening = true;
                }
                if (mLookDown.Update(deltaTime) != eUpdateReturn.Finished)
                {
                    mPropTweening = true;
                }
                if (mDistance.Update(deltaTime) != eUpdateReturn.Finished)
                {
                    mPropTweening = true;
                }
                if (mCamFovOrSize.Update(deltaTime) != eUpdateReturn.Finished)
                {
                    mPropTweening = true;
                }
                flag = true;
            }
            if (flag)
            {
                FlushCamera();
            }
            if (mEarthQuakeTimer > 0f)
            {
                float t0 = (mEarthQuakeTimer / mEarthQuakeDur) % 1f;
                mEarthQuakeTimer -= deltaTime;
                float   t1          = mEarthQuakeTimer > 0f ? (mEarthQuakeTimer / mEarthQuakeDur) % 1f : 0f;
                bool    flush       = false;
                Vector2 flushOffset = Vector2.zero;
                if (mEarthQuakeTimer <= 0f)
                {
                    mCamera.ResetProjectionMatrix();
                }
                else if (t0 < t1)
                {
                    mEarthQuakeOffsetFrom = mEarthQuakeOffsetTo;
                    if (mEarthQuakeTimer < mEarthQuakeDur)
                    {
                        mEarthQuakeOffsetTo = Vector2.zero;
                    }
                    else
                    {
                        if (mEarthQuakeRandomDirection)
                        {
                            float delta = Random.Range(2f, 4f) * Mathf.PI / 3f;
                            if (mEarthQuakeDirection > 0f)
                            {
                                mEarthQuakeDirection -= delta;
                            }
                            else
                            {
                                mEarthQuakeDirection += delta;
                            }
                        }
                        else
                        {
                            if (mEarthQuakeDirection > 0f)
                            {
                                mEarthQuakeDirection -= Mathf.PI;
                            }
                            else
                            {
                                mEarthQuakeDirection += Mathf.PI;
                            }
                        }
                        mEarthQuakeOffsetTo = new Vector2(Mathf.Cos(mEarthQuakeDirection), Mathf.Sin(mEarthQuakeDirection)) * mEarthQuakeAmplitude;
                    }
                    if (mEarthQuakeHardMode)
                    {
                        flush       = true;
                        flushOffset = mEarthQuakeOffsetTo;
                    }
                }
                if (!mEarthQuakeHardMode)
                {
                    flush       = true;
                    flushOffset = Vector2.LerpUnclamped(mEarthQuakeOffsetTo, mEarthQuakeOffsetFrom, Mathf.Sin((t1 - 0.5f) * Mathf.PI) * 0.5f + 0.5f);
                }
                if (flush)
                {
                    flushOffset *= Mathf.Min(Screen.width, Screen.height) / 100f;
                    Vector3 screenOffset = new Vector3(flushOffset.x / Screen.width, flushOffset.y / Screen.height, 0f);
                    mCamera.projectionMatrix = Matrix4x4.Translate(screenOffset) * mCaneraProjection;
                }
            }
        }