Play() public method

public Play ( ) : bool
return bool
Ejemplo n.º 1
0
    private IEnumerator ACCELERATE_enum()
    {
        if (is_Grounded && !is_Acceleration_pressed_one_time)
        {
            #region ACT

            forward_speed *= 2f;
            animator.animation.Play("accelerate"); // ----------------------------------------->


            animation_for_accelerationBtn.Play(animation_for_accelerationBtn.name);

            is_Acceleration_pressed_one_time = true;
            #endregion

            yield return(new WaitForSeconds(action_duration));

            #region DEACT
            foreach (var item in acceleration_UI)
            {
                item.SetActive(false);
            }

            forward_speed /= 2f;
            animator.animation.Stop("accelerate"); // ----------------------------------------->


            animation_for_accelerationBtn.Stop(animation_for_accelerationBtn.name);

            is_Acceleration_pressed_one_time = false;
            #endregion
        }
    }
Ejemplo n.º 2
0
        public void Update()
        {
            var currentTime = Time.time;

            foreach (var entry in entries.ToArray())
            {
                if (entry.StartTime <= currentTime)
                {
                    entries.Remove(entry);

                    if (entry.OnlyIfNotPlaying)
                    {
                        if (animation.IsPlaying(entry.Name))
                        {
                            continue;
                        }
                    }

                    if (entry.BlendWeight > 0.0f)
                    {
                        animation.Blend(entry.Name, entry.BlendWeight);
                    }
                    else
                    {
                        animation.Play(entry.Name, entry.PlayMode);
                    }

                    animationStartedCallback(entry.Name, animation.GetClip(entry.Name).length);
                }
            }
        }
Ejemplo n.º 3
0
        public override void OnStart(PartModule.StartState state)
        {
            DragManager = part.gameObject.GetComponent<DragManager>();

            if (DragManager == null) {
                DragManager = part.gameObject.AddComponent<DragManager>();
                DragManager.SetPart(part);
            }

            anim = part.FindModelAnimators(AnimationName)[0];
            animState = anim[AnimationName];
            animState.wrapMode = WrapMode.Clamp;

            if (FixAnimLayers) {
                int i = 0;
                foreach (AnimationState s in anim)
                    s.layer = i++;
            }

            animState.normalizedSpeed = 0;
            if (engaged) {
                animState.normalizedTime = Drag / 100;
                spoilerState = ModuleLandingGear.GearStates.DEPLOYED;
            }
            else {
                animState.normalizedTime = 0;
                spoilerState = ModuleLandingGear.GearStates.RETRACTED;
            }
            anim.Play(AnimationName);
        }
Ejemplo n.º 4
0
		// ============================================================================================================

		public void Start()
		{
			ani = GetComponent<Animation>();
			chara = GetComponent<Chara2_Base>();

			// init idle ani
			if (string.IsNullOrEmpty(idleClip)) idleClip = null; // set to null for faster if() checks
			if (idleClip != null)
			{
				ani[idleClip].speed = idlePlaySpeed;
				ani[idleClip].wrapMode = WrapMode.Loop;
				ani.Play(idleClip);
			}

			// sorted so that lower speedDetect is checked first
			movementAnimations.Sort((a, b) => { return a.maxSpeedDetect.CompareTo(b.maxSpeedDetect); });

			// init movement anis
			for (int i = 0; i < movementAnimations.Count; i++)
			{
				if (!string.IsNullOrEmpty(movementAnimations[i].clipName))
				{
					ani[movementAnimations[i].clipName].speed = movementAnimations[i].playSpeed;
					ani[movementAnimations[i].clipName].wrapMode = WrapMode.Loop;
				}
				else movementAnimations[i] = null; // set to null for faster if() checks
			}

			// init antics
			_anticsOn = (UniRPGGlobal.Instance.state != UniRPGGlobal.State.InMainMenu);
			anticsTimer = anticsWaitTimeMin;
		}
Ejemplo n.º 5
0
 public void PlayAnimation(Animation animation)
 {
     if (_animation == null)
     {
         _animation = GetComponentInChildren <UnityEngine.Animation>();
     }
     _animation.Play(Enum.GetName(typeof(Animation), animation).ToLower());
 }
Ejemplo n.º 6
0
        public AnimationState PlayAnim(AnimGroup group, AnimIndex anim, PlayMode playMode)
        {
            var animState = LoadAnim(group, anim);

            _curAnimGroup = AnimGroup = group;
            _curAnim      = AnimIndex = anim;

            _anim.Play(animState.name, playMode);

            return(animState);
        }
        private Task PlayClip(AnimationClip clip)
        {
            if (clip == null)
            {
                return(Task.CompletedTask);
            }

            m_Animation.clip = clip;
            m_Animation.Play();
            return(Task.Delay(TimeSpan.FromSeconds(clip.length)));
        }
Ejemplo n.º 8
0
 static public int Play(IntPtr l)
 {
     try {
         int argc = LuaDLL.lua_gettop(l);
         if (argc == 4)
         {
             UnityEngine.Animation self = (UnityEngine.Animation)checkSelf(l);
             System.String         a1;
             checkType(l, 3, out a1);
             UnityEngine.PlayMode a2;
             checkEnum(l, 4, out a2);
             var ret = self.Play(a1, a2);
             pushValue(l, true);
             pushValue(l, ret);
             return(2);
         }
         else if (matchType(l, "Play__PlayMode", argc, 2, typeof(UnityEngine.PlayMode)))
         {
             UnityEngine.Animation self = (UnityEngine.Animation)checkSelf(l);
             UnityEngine.PlayMode  a1;
             checkEnum(l, 3, out a1);
             var ret = self.Play(a1);
             pushValue(l, true);
             pushValue(l, ret);
             return(2);
         }
         else if (matchType(l, "Play__String", argc, 2, typeof(string)))
         {
             UnityEngine.Animation self = (UnityEngine.Animation)checkSelf(l);
             System.String         a1;
             checkType(l, 3, out a1);
             var ret = self.Play(a1);
             pushValue(l, true);
             pushValue(l, ret);
             return(2);
         }
         else if (argc == 2)
         {
             UnityEngine.Animation self = (UnityEngine.Animation)checkSelf(l);
             var ret = self.Play();
             pushValue(l, true);
             pushValue(l, ret);
             return(2);
         }
         pushValue(l, false);
         LuaDLL.lua_pushstring(l, "No matched override function to call");
         return(2);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
Ejemplo n.º 9
0
 private IEnumerator <IYieldInstruction> PlayAnimations()
 {
     mAvatarAnimationComponent.Stop();
     while (true)
     {
         if (!mAvatarAnimationComponent.isPlaying)
         {
             AnimationClip clip = mAnimations[mRand.Next(0, mAnimations.Count - 1)];
             mAvatarAnimationComponent.Play(clip.name);
         }
         yield return(new YieldUntilNextFrame());
     }
 }
Ejemplo n.º 10
0
 static public int Play(IntPtr l)
 {
     try {
         UnityEngine.Animation self = (UnityEngine.Animation)checkSelf(l);
         var ret = self.Play();
         pushValue(l, true);
         pushValue(l, ret);
         return(2);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
Ejemplo n.º 11
0
    static int Play(IntPtr L)
    {
#if UNITY_EDITOR
        ToluaProfiler.AddCallRecord("UnityEngine.Animation.Register");
#endif
        try
        {
            int count = LuaDLL.lua_gettop(L);

            if (count == 1)
            {
                UnityEngine.Animation obj = (UnityEngine.Animation)ToLua.CheckObject(L, 1, typeof(UnityEngine.Animation));
                bool o = obj.Play();
                LuaDLL.lua_pushboolean(L, o);
                return(1);
            }
            else if (count == 2 && TypeChecker.CheckTypes <UnityEngine.PlayMode>(L, 2))
            {
                UnityEngine.Animation obj  = (UnityEngine.Animation)ToLua.CheckObject(L, 1, typeof(UnityEngine.Animation));
                UnityEngine.PlayMode  arg0 = (UnityEngine.PlayMode)ToLua.ToObject(L, 2);
                bool o = obj.Play(arg0);
                LuaDLL.lua_pushboolean(L, o);
                return(1);
            }
            else if (count == 2 && TypeChecker.CheckTypes <string>(L, 2))
            {
                UnityEngine.Animation obj = (UnityEngine.Animation)ToLua.CheckObject(L, 1, typeof(UnityEngine.Animation));
                string arg0 = ToLua.ToString(L, 2);
                bool   o    = obj.Play(arg0);
                LuaDLL.lua_pushboolean(L, o);
                return(1);
            }
            else if (count == 3)
            {
                UnityEngine.Animation obj = (UnityEngine.Animation)ToLua.CheckObject(L, 1, typeof(UnityEngine.Animation));
                string arg0 = ToLua.CheckString(L, 2);
                UnityEngine.PlayMode arg1 = (UnityEngine.PlayMode)ToLua.CheckObject(L, 3, typeof(UnityEngine.PlayMode));
                bool o = obj.Play(arg0, arg1);
                LuaDLL.lua_pushboolean(L, o);
                return(1);
            }
            else
            {
                return(LuaDLL.luaL_throw(L, "invalid arguments to method: UnityEngine.Animation.Play"));
            }
        }
        catch (Exception e)
        {
            return(LuaDLL.toluaL_exception(L, e));
        }
    }
Ejemplo n.º 12
0
        public static IEnumerator WaitForPlay(this UnityEngine.Animation anim, string clipName = null, bool forward = true, System.Action endAction = null)
        {
            float length = anim.Play(clipName, forward);

            if (length > 0)
            {
                yield return(new WaitForSeconds(length));
            }

            if (endAction != null)
            {
                endAction();
            }
        }
Ejemplo n.º 13
0
 static public int Play__PlayMode(IntPtr l)
 {
     try {
         UnityEngine.Animation self = (UnityEngine.Animation)checkSelf(l);
         UnityEngine.PlayMode  a1;
         checkEnum(l, 2, out a1);
         var ret = self.Play(a1);
         pushValue(l, true);
         pushValue(l, ret);
         return(2);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
Ejemplo n.º 14
0
 static public int Play__String(IntPtr l)
 {
     try {
         UnityEngine.Animation self = (UnityEngine.Animation)checkSelf(l);
         System.String         a1;
         checkType(l, 2, out a1);
         var ret = self.Play(a1);
         pushValue(l, true);
         pushValue(l, ret);
         return(2);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
    static int Play(IntPtr L)
    {
        try
        {
            int count = LuaDLL.lua_gettop(L);

            if (count == 1 && ToLua.CheckTypes(L, 1, typeof(UnityEngine.Animation)))
            {
                UnityEngine.Animation obj = (UnityEngine.Animation)ToLua.ToObject(L, 1);
                bool o = obj.Play();
                LuaDLL.lua_pushboolean(L, o);
                return(1);
            }
            else if (count == 2 && ToLua.CheckTypes(L, 1, typeof(UnityEngine.Animation), typeof(string)))
            {
                UnityEngine.Animation obj = (UnityEngine.Animation)ToLua.ToObject(L, 1);
                string arg0 = ToLua.ToString(L, 2);
                bool   o    = obj.Play(arg0);
                LuaDLL.lua_pushboolean(L, o);
                return(1);
            }
            else if (count == 2 && ToLua.CheckTypes(L, 1, typeof(UnityEngine.Animation), typeof(UnityEngine.PlayMode)))
            {
                UnityEngine.Animation obj  = (UnityEngine.Animation)ToLua.ToObject(L, 1);
                UnityEngine.PlayMode  arg0 = (UnityEngine.PlayMode)ToLua.ToObject(L, 2);
                bool o = obj.Play(arg0);
                LuaDLL.lua_pushboolean(L, o);
                return(1);
            }
            else if (count == 3 && ToLua.CheckTypes(L, 1, typeof(UnityEngine.Animation), typeof(string), typeof(UnityEngine.PlayMode)))
            {
                UnityEngine.Animation obj = (UnityEngine.Animation)ToLua.ToObject(L, 1);
                string arg0 = ToLua.ToString(L, 2);
                UnityEngine.PlayMode arg1 = (UnityEngine.PlayMode)ToLua.ToObject(L, 3);
                bool o = obj.Play(arg0, arg1);
                LuaDLL.lua_pushboolean(L, o);
                return(1);
            }
            else
            {
                return(LuaDLL.tolua_error(L, "invalid arguments to method: UnityEngine.Animation.Play"));
            }
        }
        catch (Exception e)
        {
            return(LuaDLL.toluaL_exception(L, e));
        }
    }
Ejemplo n.º 16
0
 static public int Play(IntPtr l)
 {
     try{
         int argc = LuaDLL.lua_gettop(l);
         if (argc == 1)
         {
             UnityEngine.Animation self = (UnityEngine.Animation)checkSelf(l);
             System.Boolean        ret  = self.Play();
             pushValue(l, ret);
             return(1);
         }
         else if (matchType(l, argc, 2, typeof(UnityEngine.PlayMode)))
         {
             UnityEngine.Animation self = (UnityEngine.Animation)checkSelf(l);
             UnityEngine.PlayMode  a1;
             checkEnum(l, 2, out a1);
             System.Boolean ret = self.Play(a1);
             pushValue(l, ret);
             return(1);
         }
         else if (argc == 3)
         {
             UnityEngine.Animation self = (UnityEngine.Animation)checkSelf(l);
             System.String         a1;
             checkType(l, 2, out a1);
             UnityEngine.PlayMode a2;
             checkEnum(l, 3, out a2);
             System.Boolean ret = self.Play(a1, a2);
             pushValue(l, ret);
             return(1);
         }
         else if (matchType(l, argc, 2, typeof(string)))
         {
             UnityEngine.Animation self = (UnityEngine.Animation)checkSelf(l);
             System.String         a1;
             checkType(l, 2, out a1);
             System.Boolean ret = self.Play(a1);
             pushValue(l, ret);
             return(1);
         }
         LuaDLL.luaL_error(l, "No matched override function to call");
         return(0);
     }
     catch (Exception e) {
         LuaDLL.luaL_error(l, e.ToString());
         return(0);
     }
 }
    static int Play(IntPtr L)
    {
        try
        {
            int count = LuaDLL.lua_gettop(L);

            if (count == 1)
            {
                UnityEngine.Animation obj = (UnityEngine.Animation)ToLua.CheckObject(L, 1, typeof(UnityEngine.Animation));
                bool o = obj.Play();
                LuaDLL.lua_pushboolean(L, o);
                return(1);
            }
            else if (count == 2 && TypeChecker.CheckTypes <uint>(L, 2))
            {
                UnityEngine.Animation obj  = (UnityEngine.Animation)ToLua.CheckObject(L, 1, typeof(UnityEngine.Animation));
                UnityEngine.PlayMode  arg0 = (UnityEngine.PlayMode)LuaDLL.lua_tonumber(L, 2);
                bool o = obj.Play(arg0);
                LuaDLL.lua_pushboolean(L, o);
                return(1);
            }
            else if (count == 2 && TypeChecker.CheckTypes <string>(L, 2))
            {
                UnityEngine.Animation obj = (UnityEngine.Animation)ToLua.CheckObject(L, 1, typeof(UnityEngine.Animation));
                string arg0 = ToLua.ToString(L, 2);
                bool   o    = obj.Play(arg0);
                LuaDLL.lua_pushboolean(L, o);
                return(1);
            }
            else if (count == 3)
            {
                UnityEngine.Animation obj = (UnityEngine.Animation)ToLua.CheckObject(L, 1, typeof(UnityEngine.Animation));
                string arg0 = ToLua.CheckString(L, 2);
                UnityEngine.PlayMode arg1 = (UnityEngine.PlayMode)LuaDLL.luaL_checknumber(L, 3);
                bool o = obj.Play(arg0, arg1);
                LuaDLL.lua_pushboolean(L, o);
                return(1);
            }
            else
            {
                return(LuaDLL.luaL_throw(L, "invalid arguments to method: UnityEngine.Animation.Play"));
            }
        }
        catch (Exception e)
        {
            return(LuaDLL.toluaL_exception(L, e));
        }
    }
Ejemplo n.º 18
0
        private void PlayAnimation(AnimationClip clip)
        {
            graphicRaycaster.enabled = false;
            if (animator.isPlaying)
            {
                animator.Stop();
            }
            animator.RemoveClip(animator.clip);
            animator.clip = clip;
            animator.AddClip(clip, clip.name);
            animator.Play();
            Debug.Log("Playing " + clip.name, clip);

            StopAnimationEndAwaiter();
            _animationWaitCoroutine = StartCoroutine(WaitForAnimationEnd(clip));
        }
Ejemplo n.º 19
0
 public static int Play_wrap(long L)
 {
     try
     {
         long nThisPtr             = FCLibHelper.fc_get_inport_obj_ptr(L);
         UnityEngine.Animation obj = get_obj(nThisPtr);
         bool ret     = obj.Play();
         long ret_ptr = FCLibHelper.fc_get_return_ptr(L);
         FCLibHelper.fc_set_value_bool(ret_ptr, ret);
     }
     catch (Exception e)
     {
         Debug.LogException(e);
     }
     return(0);
 }
Ejemplo n.º 20
0
        protected override void Compute()
        {
            status = Status.Compute;

            step = Config.Zero;

            if (animation.clip == null)
            {
                return;
            }

            interval = animation.clip.length;

            animation.Play();

            status = Status.Transition;
        }
 static int QPYX_Play_YXQP(IntPtr L_YXQP)
 {
     try
     {
         int QPYX_count_YXQP = LuaDLL.lua_gettop(L_YXQP);
         if (QPYX_count_YXQP == 1)
         {
             UnityEngine.Animation QPYX_obj_YXQP = (UnityEngine.Animation)ToLua.CheckObject(L_YXQP, 1, typeof(UnityEngine.Animation));
             bool QPYX_o_YXQP = QPYX_obj_YXQP.Play();
             LuaDLL.lua_pushboolean(L_YXQP, QPYX_o_YXQP);
             return(1);
         }
         else if (QPYX_count_YXQP == 2 && TypeChecker.CheckTypes <string>(L_YXQP, 2))
         {
             UnityEngine.Animation QPYX_obj_YXQP = (UnityEngine.Animation)ToLua.CheckObject(L_YXQP, 1, typeof(UnityEngine.Animation));
             string QPYX_arg0_YXQP = ToLua.ToString(L_YXQP, 2);
             bool   QPYX_o_YXQP    = QPYX_obj_YXQP.Play(QPYX_arg0_YXQP);
             LuaDLL.lua_pushboolean(L_YXQP, QPYX_o_YXQP);
             return(1);
         }
         else if (QPYX_count_YXQP == 2 && TypeChecker.CheckTypes <UnityEngine.PlayMode>(L_YXQP, 2))
         {
             UnityEngine.Animation QPYX_obj_YXQP  = (UnityEngine.Animation)ToLua.CheckObject(L_YXQP, 1, typeof(UnityEngine.Animation));
             UnityEngine.PlayMode  QPYX_arg0_YXQP = (UnityEngine.PlayMode)ToLua.ToObject(L_YXQP, 2);
             bool QPYX_o_YXQP = QPYX_obj_YXQP.Play(QPYX_arg0_YXQP);
             LuaDLL.lua_pushboolean(L_YXQP, QPYX_o_YXQP);
             return(1);
         }
         else if (QPYX_count_YXQP == 3)
         {
             UnityEngine.Animation QPYX_obj_YXQP = (UnityEngine.Animation)ToLua.CheckObject(L_YXQP, 1, typeof(UnityEngine.Animation));
             string QPYX_arg0_YXQP = ToLua.CheckString(L_YXQP, 2);
             UnityEngine.PlayMode QPYX_arg1_YXQP = (UnityEngine.PlayMode)ToLua.CheckObject(L_YXQP, 3, typeof(UnityEngine.PlayMode));
             bool QPYX_o_YXQP = QPYX_obj_YXQP.Play(QPYX_arg0_YXQP, QPYX_arg1_YXQP);
             LuaDLL.lua_pushboolean(L_YXQP, QPYX_o_YXQP);
             return(1);
         }
         else
         {
             return(LuaDLL.luaL_throw(L_YXQP, "invalid arguments to method: UnityEngine.Animation.Play"));
         }
     }
     catch (Exception e_YXQP)                {
         return(LuaDLL.toluaL_exception(L_YXQP, e_YXQP));
     }
 }
Ejemplo n.º 22
0
        public override void OnStart(PartModule.StartState state) {
            if (state == StartState.Editor) { return; }
            this.part.force_activate();
			anim = part.FindModelAnimators (animName).FirstOrDefault ();
			if (anim != null) {
				anim [animName].layer = 1;
				if (!IsEnabled) {
					anim [animName].normalizedTime = 1f;
					anim [animName].speed = -1f;

				} else {
					anim [animName].normalizedTime = 0f;
					anim [animName].speed = 1f;

				}
				anim.Play ();
			}
        }
Ejemplo n.º 23
0
 public static int Play2_wrap(long L)
 {
     try
     {
         long nThisPtr             = FCLibHelper.fc_get_inport_obj_ptr(L);
         UnityEngine.Animation obj = get_obj(nThisPtr);
         string arg0 = FCLibHelper.fc_get_string_a(L, 0);
         UnityEngine.PlayMode arg1 = (UnityEngine.PlayMode)(FCLibHelper.fc_get_int(L, 1));
         bool ret     = obj.Play(arg0, arg1);
         long ret_ptr = FCLibHelper.fc_get_return_ptr(L);
         FCLibHelper.fc_set_value_bool(ret_ptr, ret);
     }
     catch (Exception e)
     {
         Debug.LogException(e);
     }
     return(0);
 }
        public void PlayAnimation(AnimType animType)
        {
            var clip  = GetClip(animType);
            var speed = GetSpeed(animType);

            if (!clip)
            {
                return;
            }

            if (anim.isPlaying)
            {
                anim.Stop();
            }

            SetClipToStart(animType);
            SetAnimationSpeed(clip, speed);
            anim.Play(clip.name);
        }
Ejemplo n.º 25
0
        public static void Sample(this UnityEngine.Animation anim, float time, string clipName = null, bool normalized = false)
        {
            AnimationState animState = anim.GetAnimState(clipName);

            if (animState != null)
            {
                anim.Play(animState.name);
                if (normalized)
                {
                    animState.normalizedTime = time;
                }
                else
                {
                    animState.time = time;
                }
                animState.enabled = true;
                anim.Sample();
                animState.enabled = false;
            }
        }
Ejemplo n.º 26
0
        /// <summary>
        /// 断点续播,clip正在播放时候,调用当前播放方向的倒播,会从当前点倒着播回去
        /// </summary>
        /// <returns>The with breakpoint.</returns>
        /// <param name="anim">Animation.</param>
        /// <param name="clipName">Clip name.</param>
        /// <param name="forward">If set to <c>true</c> forward.</param>
        public static float PlayWithBreakpoint(this UnityEngine.Animation anim, string clipName = null, bool forward = true)
        {
            AnimationState animState = anim.GetAnimState(clipName);

            if (animState != null)
            {
                animState.time = animState.length * (Mathf.Min(1f, animState.normalizedTime));
                if (forward)
                {
                    animState.speed = Mathf.Abs(animState.speed);
                }
                else
                {
                    animState.speed = -Mathf.Abs(animState.speed);
                }
                anim.Play(animState.name);
                return(animState.length);
            }

            return(0);
        }
 public override void ShowData(DataProvider data)
 {
     base.ShowData(data);
     EventManager.Instance.AddEventListener <PlayerLoadArchiveEvent>(OnPlayerLoadArchive);
     if (isShowLogo)
     {
         if (anim != null)
         {
             anim.playAutomatically = false;
         }
         if (logoAnimCtrl != null)
         {
             logoAnimCtrl.Show(() => {
                 if (anim != null)
                 {
                     anim.Play();
                 }
             });
         }
     }
 }
Ejemplo n.º 28
0
        public static float Play(this UnityEngine.Animation anim, string clipName = null, bool forward = true)
        {
            AnimationState animState = anim.GetAnimState(clipName);

            if (animState != null)
            {
                if (forward)
                {
                    animState.time  = 0;
                    animState.speed = Mathf.Abs(animState.speed);
                }
                else
                {
                    animState.time  = animState.length;
                    animState.speed = -Mathf.Abs(animState.speed);
                }
                anim.Play(animState.name);
                return(animState.length);
            }

            return(0);
        }
        public override void OnStart(PartModule.StartState state) {
            Actions["ActivateTransmitterAction"].guiName = Events["ActivateTransmitter"].guiName = String.Format("Activate Transmitter");
            Actions["DeactivateTransmitterAction"].guiName = Events["DeactivateTransmitter"].guiName = String.Format("Deactivate Transmitter");
            
            if (state == StartState.Editor) { return; }
            this.part.force_activate();

			anim = part.FindModelAnimators (animName).FirstOrDefault ();
			if (anim != null) {
				anim [animName].layer = 1;
				if (!IsEnabled) {
					anim [animName].normalizedTime = 1f;
					anim [animName].speed = -1f;

				} else {
					anim [animName].normalizedTime = 0f;
					anim [animName].speed = 1f;

				}
				anim.Play ();
			}
                        
            List<Part> vesselparts = vessel.parts;
            for (int i = 0; i < vesselparts.Count; ++i) {
                Part cPart = vesselparts.ElementAt(i);
                PartModuleList pml = cPart.Modules;
                for (int j = 0; j < pml.Count; ++j) {
                    var curSolarPan = pml.GetModule(j) as ModuleDeployableSolarPanel;
                    if (curSolarPan != null) {
                        //curSolarPan.powerCurve = PluginHelper.getSatFloatCurve();
                    }
                }
            }


        }
Ejemplo n.º 30
0
        public static void PlayAnimation(this GameObject go, string name = null, State state = State.Play)
        {
            UnityEngine.Animation animation = go.GetComponentInChildren <UnityEngine.Animation>();

            if (animation != null)
            {
                if (string.IsNullOrEmpty(name))
                {
                    name = animation.clip.name;
                }
                switch (state)
                {
                case State.Play:
                {
                    if (animation.isPlaying && animation.IsPlaying(name))
                    {
                    }
                    else
                    {
                        animation.Play(name);
                    }
                }
                break;

                case State.Pause:
                case State.Stop:
                {
                    if (animation.isPlaying && animation.IsPlaying(name))
                    {
                        animation.Stop();
                    }
                }
                break;
                }
            }
        }
        public VariableAnimationSet(ConfigNode node, InternalProp thisProp)
        {
            part = thisProp.part;

            if (!node.HasData)
            {
                throw new ArgumentException("No data?!");
            }

            comp = RasterPropMonitorComputer.Instantiate(thisProp);

            string[] tokens = { };

            if (node.HasValue("scale"))
            {
                tokens = node.GetValue("scale").Split(',');
            }

            if (tokens.Length != 2)
            {
                throw new ArgumentException("Could not parse 'scale' parameter.");
            }

            if (node.HasValue("variableName"))
            {
                string variableName;
                variableName = node.GetValue("variableName").Trim();
                scaleEnds[2] = new VariableOrNumber(variableName, this);
            }
            else if (node.HasValue("stateMethod"))
            {
                Func<bool> stateFunction = (Func<bool>)comp.GetMethod(node.GetValue("stateMethod").Trim(), thisProp, typeof(Func<bool>));
                if (stateFunction != null)
                {
                    scaleEnds[2] = new VariableOrNumber(stateFunction, this);
                }
                else
                {
                    throw new ArgumentException("Unrecognized stateMethod");
                }
            }
            else
            {
                throw new ArgumentException("Missing variable name.");
            }

            scaleEnds[0] = new VariableOrNumber(tokens[0], this);
            scaleEnds[1] = new VariableOrNumber(tokens[1], this);

            // That takes care of the scale, now what to do about that scale:

            if (node.HasValue("reverse"))
            {
                if (!bool.TryParse(node.GetValue("reverse"), out reverse))
                {
                    throw new ArgumentException("So is 'reverse' true or false?");
                }
            }

            if (node.HasValue("animationName"))
            {
                animationName = node.GetValue("animationName");
                if (node.HasValue("animationSpeed"))
                {
                    animationSpeed = float.Parse(node.GetValue("animationSpeed"));

                    if (reverse)
                    {
                        animationSpeed = -animationSpeed;
                    }
                }
                else
                {
                    animationSpeed = 0.0f;
                }
                Animation[] anims = node.HasValue("animateExterior") ? thisProp.part.FindModelAnimators(animationName) : thisProp.FindModelAnimators(animationName);
                if (anims.Length > 0)
                {
                    onAnim = anims[0];
                    onAnim.enabled = true;
                    onAnim[animationName].speed = 0;
                    onAnim[animationName].normalizedTime = reverse ? 1f : 0f;
                    looping = node.HasValue("loopingAnimation");
                    if (looping)
                    {
                        onAnim[animationName].wrapMode = WrapMode.Loop;
                        onAnim.wrapMode = WrapMode.Loop;
                        onAnim[animationName].speed = animationSpeed;
                        mode = Mode.LoopingAnimation;
                    }
                    else
                    {
                        onAnim[animationName].wrapMode = WrapMode.Once;
                        mode = Mode.Animation;
                    }
                    onAnim.Play();
                    alwaysActive = node.HasValue("animateExterior");
                }
                else
                {
                    throw new ArgumentException("Animation could not be found.");
                }

                if (node.HasValue("stopAnimationName"))
                {
                    stopAnimationName = node.GetValue("stopAnimationName");
                    anims = node.HasValue("animateExterior") ? thisProp.part.FindModelAnimators(stopAnimationName) : thisProp.FindModelAnimators(stopAnimationName);
                    if (anims.Length > 0)
                    {
                        offAnim = anims[0];
                        offAnim.enabled = true;
                        offAnim[stopAnimationName].speed = 0;
                        offAnim[stopAnimationName].normalizedTime = reverse ? 1f : 0f;
                        if (looping)
                        {
                            offAnim[stopAnimationName].wrapMode = WrapMode.Loop;
                            offAnim.wrapMode = WrapMode.Loop;
                            offAnim[stopAnimationName].speed = animationSpeed;
                            mode = Mode.LoopingAnimation;
                        }
                        else
                        {
                            offAnim[stopAnimationName].wrapMode = WrapMode.Once;
                            mode = Mode.Animation;
                        }
                    }
                }
            }
            else if (node.HasValue("activeColor") && node.HasValue("passiveColor") && node.HasValue("coloredObject"))
            {
                if (node.HasValue("colorName"))
                    colorName = node.GetValue("colorName");
                passiveColor = ConfigNode.ParseColor32(node.GetValue("passiveColor"));
                activeColor = ConfigNode.ParseColor32(node.GetValue("activeColor"));
                colorShiftRenderer = thisProp.FindModelComponent<Renderer>(node.GetValue("coloredObject"));
                colorShiftRenderer.material.SetColor(colorName, reverse ? activeColor : passiveColor);
                mode = Mode.Color;
            }
            else if (node.HasValue("controlledTransform") && node.HasValue("localRotationStart") && node.HasValue("localRotationEnd"))
            {
                controlledTransform = thisProp.FindModelTransform(node.GetValue("controlledTransform").Trim());
                initialRotation = controlledTransform.localRotation;
                if (node.HasValue("longPath"))
                {
                    longPath = true;
                    vectorStart = ConfigNode.ParseVector3(node.GetValue("localRotationStart"));
                    vectorEnd = ConfigNode.ParseVector3(node.GetValue("localRotationEnd"));
                }
                else
                {
                    rotationStart = Quaternion.Euler(ConfigNode.ParseVector3(node.GetValue("localRotationStart")));
                    rotationEnd = Quaternion.Euler(ConfigNode.ParseVector3(node.GetValue("localRotationEnd")));
                }
                mode = Mode.Rotation;
            }
            else if (node.HasValue("controlledTransform") && node.HasValue("localTranslationStart") && node.HasValue("localTranslationEnd"))
            {
                controlledTransform = thisProp.FindModelTransform(node.GetValue("controlledTransform").Trim());
                initialPosition = controlledTransform.localPosition;
                vectorStart = ConfigNode.ParseVector3(node.GetValue("localTranslationStart"));
                vectorEnd = ConfigNode.ParseVector3(node.GetValue("localTranslationEnd"));
                mode = Mode.Translation;
            }
            else if (node.HasValue("controlledTransform") && node.HasValue("localScaleStart") && node.HasValue("localScaleEnd"))
            {
                controlledTransform = thisProp.FindModelTransform(node.GetValue("controlledTransform").Trim());
                initialScale = controlledTransform.localScale;
                vectorStart = ConfigNode.ParseVector3(node.GetValue("localScaleStart"));
                vectorEnd = ConfigNode.ParseVector3(node.GetValue("localScaleEnd"));
                mode = Mode.Scale;
            }
            else if (node.HasValue("controlledTransform") && node.HasValue("textureLayers") && node.HasValue("textureShiftStart") && node.HasValue("textureShiftEnd"))
            {
                affectedMaterial = thisProp.FindModelTransform(node.GetValue("controlledTransform").Trim()).renderer.material;
                textureLayer = node.GetValue("textureLayers");
                textureShiftStart = ConfigNode.ParseVector2(node.GetValue("textureShiftStart"));
                textureShiftEnd = ConfigNode.ParseVector2(node.GetValue("textureShiftEnd"));
                mode = Mode.TextureShift;
            }
            else if (node.HasValue("controlledTransform") && node.HasValue("textureLayers") && node.HasValue("textureScaleStart") && node.HasValue("textureScaleEnd"))
            {
                affectedMaterial = thisProp.FindModelTransform(node.GetValue("controlledTransform").Trim()).renderer.material;
                textureLayer = node.GetValue("textureLayers");
                textureScaleStart = ConfigNode.ParseVector2(node.GetValue("textureScaleStart"));
                textureScaleEnd = ConfigNode.ParseVector2(node.GetValue("textureScaleEnd"));
                mode = Mode.TextureScale;
            }
            else
            {
                throw new ArgumentException("Cannot initiate any of the possible action modes.");
            }

            if (node.HasValue("threshold"))
            {
                threshold = ConfigNode.ParseVector2(node.GetValue("threshold"));
            }

            resourceAmount = 0.0f;
            if (threshold != Vector2.zero)
            {
                thresholdMode = true;

                float min = Mathf.Min(threshold.x, threshold.y);
                float max = Mathf.Max(threshold.x, threshold.y);
                threshold.x = min;
                threshold.y = max;

                if (node.HasValue("flashingDelay"))
                {
                    flashingDelay = double.Parse(node.GetValue("flashingDelay"));
                }

                if (node.HasValue("alarmSound"))
                {
                    alarmSoundVolume = 0.5f;
                    if (node.HasValue("alarmSoundVolume"))
                        alarmSoundVolume = float.Parse(node.GetValue("alarmSoundVolume"));
                    audioOutput = JUtil.SetupIVASound(thisProp, node.GetValue("alarmSound"), alarmSoundVolume, false);
                    if (node.HasValue("alarmMustPlayOnce"))
                    {
                        if (!bool.TryParse(node.GetValue("alarmMustPlayOnce"), out alarmMustPlayOnce))
                            throw new ArgumentException("So is 'alarmMustPlayOnce' true or false?");
                    }
                    if (node.HasValue("alarmShutdownButton"))
                        SmarterButton.CreateButton(thisProp, node.GetValue("alarmShutdownButton"), AlarmShutdown);
                    if (node.HasValue("alarmSoundLooping"))
                    {
                        if (!bool.TryParse(node.GetValue("alarmSoundLooping"), out alarmSoundLooping))
                            throw new ArgumentException("So is 'alarmSoundLooping' true or false?");
                        audioOutput.audio.loop = alarmSoundLooping;
                    }
                }

                if (node.HasValue("resourceAmount"))
                {
                    resourceAmount = float.Parse(node.GetValue("resourceAmount"));
                }

                TurnOff();
            }
        }
Ejemplo n.º 32
0
        private void thawCryopodWindow(int seatIndx, float speed)
        {
            setCryopodWindowOpaque(seatIndx);
            string windowname = "";
            if (isPartAnimated)
                windowname = "Animated-Cryopod-" + (seatIndx + 1) + "-Window";
            else
                windowname = "Cryopod-" + (seatIndx + 1) + "-Window";

            _windowAnimation = part.internalModel.FindModelComponent<Animation>(windowname);
            Animation _extwindowAnimation = null;
            if (isPodExternal)
            {
                _extwindowAnimation = part.FindModelComponent<Animation>(windowname);
                Utilities.SetInternalDepthMask(part, false, "External_Window_Occluder"); //Set window occluder off
            }

            if (_windowAnimation == null)
            {
                 Utilities.Log_Debug("Why can't I find the window animation?");
            }
            else
            {
                _windowAnimation["CryopodWindowOpen"].speed = speed;
                _windowAnimation.Play("CryopodWindowOpen");
            }
            if (isPodExternal && _extwindowAnimation != null)
            {
                _extwindowAnimation["CryopodWindowOpen"].speed = speed;
                _extwindowAnimation.Play("CryopodWindowOpen");
            }
        }
Ejemplo n.º 33
0
 //only called for animated internal parts
 private void openCryopod(int seatIndx, float speed)
 {
     string podname = "Animated-Cryopod-" + (seatIndx + 1);
     try
     {
         _animation = part.internalModel.FindModelComponent<Animation>(podname);
         if (_animation != null)
         {
             if (cryopodstateclosed[seatIndx])
             {
                 _animation["Open"].speed = speed;
                 _animation.Play("Open");
                 cryopodstateclosed[seatIndx] = false;
                 savecryopodstatepersistent();
             }
         }
         else
              Utilities.Log_Debug("animation not found");
     }
     catch (Exception ex)
     {
         Debug.Log("Unable to find animation in internal model for this part called " + podname);
         Debug.Log("Err: " + ex);
     }
 }
 static public int Play(IntPtr l)
 {
     try {
                     #if DEBUG
         var    method     = System.Reflection.MethodBase.GetCurrentMethod();
         string methodName = GetMethodName(method);
                     #if UNITY_5_5_OR_NEWER
         UnityEngine.Profiling.Profiler.BeginSample(methodName);
                     #else
         Profiler.BeginSample(methodName);
                     #endif
                     #endif
         int argc = LuaDLL.lua_gettop(l);
         if (argc == 1)
         {
             UnityEngine.Animation self = (UnityEngine.Animation)checkSelf(l);
             var ret = self.Play();
             pushValue(l, true);
             pushValue(l, ret);
             return(2);
         }
         else if (matchType(l, argc, 2, typeof(UnityEngine.PlayMode)))
         {
             UnityEngine.Animation self = (UnityEngine.Animation)checkSelf(l);
             UnityEngine.PlayMode  a1;
             a1 = (UnityEngine.PlayMode)LuaDLL.luaL_checkinteger(l, 2);
             var ret = self.Play(a1);
             pushValue(l, true);
             pushValue(l, ret);
             return(2);
         }
         else if (matchType(l, argc, 2, typeof(string)))
         {
             UnityEngine.Animation self = (UnityEngine.Animation)checkSelf(l);
             System.String         a1;
             checkType(l, 2, out a1);
             var ret = self.Play(a1);
             pushValue(l, true);
             pushValue(l, ret);
             return(2);
         }
         else if (argc == 3)
         {
             UnityEngine.Animation self = (UnityEngine.Animation)checkSelf(l);
             System.String         a1;
             checkType(l, 2, out a1);
             UnityEngine.PlayMode a2;
             a2 = (UnityEngine.PlayMode)LuaDLL.luaL_checkinteger(l, 3);
             var ret = self.Play(a1, a2);
             pushValue(l, true);
             pushValue(l, ret);
             return(2);
         }
         pushValue(l, false);
         LuaDLL.lua_pushstring(l, "No matched override function Play to call");
         return(2);
     }
     catch (Exception e) {
         return(error(l, e));
     }
             #if DEBUG
     finally {
                     #if UNITY_5_5_OR_NEWER
         UnityEngine.Profiling.Profiler.EndSample();
                     #else
         Profiler.EndSample();
                     #endif
     }
             #endif
 }
        public override void OnStart(PartModule.StartState state) {
            if (state == StartState.Editor) { return; }

            generators = vessel.FindPartModulesImplementing<FNGenerator>();
            receivers = vessel.FindPartModulesImplementing<MicrowavePowerReceiver>();
            panels = vessel.FindPartModulesImplementing<ModuleDeployableSolarPanel>();
            if (part.FindModulesImplementing<MicrowavePowerReceiver>().Count == 1) {
                part_receiver = part.FindModulesImplementing<MicrowavePowerReceiver>().First();
                has_receiver = true;
            }

            anim = part.FindModelAnimators(animName).FirstOrDefault();
            if (anim != null) {
                anim[animName].layer = 1;
                if (!IsEnabled) {
                    anim[animName].normalizedTime = 1f;
                    anim[animName].speed = -1f;

                } else {
                    anim[animName].normalizedTime = 0f;
                    anim[animName].speed = 1f;

                }
                anim.Play();
            }

            this.part.force_activate();
        }
Ejemplo n.º 36
0
 private void thawCryopodWindow(int seatIndx, float speed)
 {
     setCryopodWindowOpaque(seatIndx);
     string windowname = "Animated-Cryopod-" + (seatIndx + 1).ToString() + "-Window";
     _windowAnimation = this.part.internalModel.FindModelComponent<Animation>(windowname);
     if (_windowAnimation == null)
     {
         this.Log_Debug("Why can't I find the window animation?");
     }
     else
     {
         _windowAnimation["CryopodWindowOpen"].speed = speed;
         _windowAnimation.Play("CryopodWindowOpen");
     }
 }
        //----------------methods-----------------
        /**
         * Called at the start. Initialize animation and state of this module
         */
        public override void OnStart(PartModule.StartState state)
        {
            base.OnStart(state);
            part.CheckTransferDialog();

            isInternalPacked = true;

            //get the deploy animation
            deployAnim = part.FindModelAnimators(animationName).FirstOrDefault();

            //Only initialize when an animation is available
            if (deployAnim != null)
            {
                // Run Only on first launch
                if (!hasBeenInitialized)
                {
                    if (part.protoModuleCrew.Count() > crewCapcityRetracted)
                    {
                        nextIsReverse = true;
                        animationTime = 0.999f;
                        deployAnim[animationName].normalizedTime = 1f;
                    }
                    else
                    {
                        nextIsReverse = false;
                        animationTime = 0f;
                        deployAnim[animationName].normalizedTime = 0f;
                    }

                    hasBeenInitialized = true;
                }

                if (part.protoModuleCrew.Count() > crewCapcityRetracted)
                {
                    animationTime = 0.999f;
                    deployAnim[animationName].speed = 1f;
                }
                else if (nextIsReverse)
                {
                    if (animationTime == 0f)
                    {
                        animationTime = 1f;
                    }

                    if (animationTime == 1f)
                    {
                        status = "Deployed";
                        part.CrewCapacity = crewCapacityDeployed;
                    }
                    else
                    {
                        status = "Deploying..";
                        part.CrewCapacity = crewCapacityDeployed;
                    }
                    deployAnim[animationName].speed = 1f;
                }
                else
                {
                    if (animationTime == 0f)
                    {
                        status = "Retracted";
                    }
                    else
                    {
                        status = "Retracting..";
                    }
                    this.part.CrewCapacity = crewCapcityRetracted;

                    deployAnim[animationName].speed = -1f;
                }

                // Set up animation state according to persistent values
                deployAnim[animationName].layer = layer;
                deployAnim[animationName].normalizedTime = animationTime;
                deployAnim.Play(animationName);

                // Settings for the GUI
                if (nextIsReverse)
                {
                    Events["toggleAnimation"].guiName = endEventGUIName;
                }
                else {
                    Events["toggleAnimation"].guiName = startEventGUIName;
                }

                Events["toggleAnimation"].guiActiveEditor = availableInEditor;
                Events["toggleAnimation"].guiActiveUnfocused = availableInEVA;
                Events["toggleAnimation"].guiActive = availableInVessel;
                Events["toggleAnimation"].unfocusedRange = EVArange;
            }
            // When the animation can not be found deactivate it in the GUI
            else
            {
                Events["toggleAnimation"].guiActiveEditor = false;
                Events["toggleAnimation"].guiActive = false;
                Events["toggleAnimation"].guiActiveUnfocused = false;
                Debug.Log("[KPBS] Deploy animation not found: " + animationName);
            }
        }
Ejemplo n.º 38
0
        private void PlayLoopAnimation(Animation StartAnimation, string startAnimationName, int speed, bool instant)
        {
            if (startAnimationName != "")
            {
                // //print(StartAnimation[startAnimationName].time.ToString() + " " + loopPoint.ToString());
                if (StartAnimation[startAnimationName].time >= StartAnimation[startAnimationName].length || StartAnimation.isPlaying == false)
                {
                    StartAnimation[startAnimationName].time = loopPoint;
                    ////print(StartAnimation[startAnimationName].time.ToString() + " " + loopPoint.ToString());
                    if (instant)
                        StartAnimation[startAnimationName].speed = 999999 * speed;
                    StartAnimation[startAnimationName].speed = speed;
                    StartAnimation[startAnimationName].wrapMode = WrapMode.Default;
                    StartAnimation.Play(startAnimationName);

                }
            }

        }
Ejemplo n.º 39
0
 /**
  * <summary>Initialises and plays a legacy AnimationClip on an Animation component, starting from a set point.</summary>
  * <param name = "_animation">The Animation component</param>
  * <param name = "layer">The layer to play the animation on</param>
  * <param name = "clip">The AnimatonClip to play</param>
  * <param name = "blendMode">The animation's AnimationBlendMode</param>
  * <param name = "wrapMode">The animation's WrapMode</param>
  * <param name = "fadeTime">The transition time to the new animation</param>
  * <param name = "mixingBone">The transform to set as the animation's mixing transform</param>
  * <param name = "normalisedFrame">How far along the timeline the animation should start from (0 to 1)</param>
  */
 public static void PlayAnimClipFrame(Animation _animation, int layer, AnimationClip clip, AnimationBlendMode blendMode, WrapMode wrapMode, float fadeTime, Transform mixingBone, float normalisedFrame)
 {
     if (clip != null)
     {
         AddAnimClip (_animation, layer, clip, blendMode, wrapMode, mixingBone);
         _animation [clip.name].normalizedTime = normalisedFrame;
         _animation [clip.name].speed *= 1f;
         _animation.Play (clip.name);
         CleanUnusedClips (_animation);
     }
 }
Ejemplo n.º 40
0
        public override void OnStart(PartModule.StartState state)
        {
            Actions["DeployRadiatorAction"].guiName = Events["DeployRadiator"].guiName = String.Format("Deploy Radiator");
            Actions["RetractRadiatorAction"].guiName = Events["RetractRadiator"].guiName = String.Format("Retract Radiator");
            Actions["ToggleRadiatorAction"].guiName = String.Format("Toggle Radiator");

            if (state == StartState.Editor) { return; }
            this.part.force_activate();

            anim = part.FindModelAnimators (animName).FirstOrDefault ();
            //orig_emissive_colour = part.renderer.material.GetTexture (emissive_property_name);
            if (anim != null) {
                anim [animName].layer = 1;
                if (!IsEnabled) {
                    anim [animName].normalizedTime = 1f;
                    anim [animName].speed = -1f;

                } else {
                    anim [animName].normalizedTime = 0f;
                    anim [animName].speed = 1f;

                }
                anim.Play ();
            }

            pivot = part.FindModelTransform("suntransform");
            original_eulers = pivot.transform.localEulerAngles;

            if (!isupgraded) {
                radiatorType = originalName;
            } else {
                radiatorType = upgradedName;
                radiatorTemp = upgradedRadiatorTemp;
            }
            radiatorTempStr = radiatorTemp + "K";
        }
        public override void OnStart(PartModule.StartState state)
        {
            if (state == StartState.Editor) return;

            generators = vessel.FindPartModulesImplementing<FNGenerator>();
            receivers = vessel.FindPartModulesImplementing<MicrowavePowerReceiver>();
            panels = vessel.FindPartModulesImplementing<ModuleDeployableSolarPanel>();

            if (part.FindModulesImplementing<MicrowavePowerReceiver>().Count == 1)
            {
                part_receiver = part.FindModulesImplementing<MicrowavePowerReceiver>().First();
                has_receiver = true;
            }

            anim = part.FindModelAnimators(animName).FirstOrDefault();
            if (anim != null)
            {
                anim[animName].layer = 1;
                if (!IsEnabled)
                {
                    anim[animName].normalizedTime = 1f;
                    anim[animName].speed = -1f;
                }
                else
                {
                    anim[animName].normalizedTime = 0f;
                    anim[animName].speed = 1f;
                }
                anim.Play();
            }

            this.part.force_activate();

           // Debug.Log("[KSPI] - MicrowavePowerTransmitter - Looking for externalPowerSources");
           // foreach (Part vesselpart in vessel.Parts)
           // {
           //     if (vesselpart.partName == "reactor-25")
           //     {
           //         externalPowerSources.Add(new ExternalPowerSourePartModule() { Name = "reactor-25", Power = 2 });
           //         Debug.Log("[KSPI] - MicrowavePowerTransmitter - found " + vesselpart.partInfo.title);
           //     }
           //}
        }
Ejemplo n.º 42
0
        public override void OnStart(PartModule.StartState state)
        {
            if (state == StartState.Editor) { return; }

            ConfigNode config = PluginHelper.getPluginSaveFile ();

            if (config.HasNode ("DATA_PACKET")) {
                Events ["ReceivePacket"].active = true;
            } else {
                Events ["ReceivePacket"].active = false;
            }

            part.force_activate();

            anim = part.FindModelAnimators (animName1).FirstOrDefault ();
            anim2 = part.FindModelAnimators (animName2).FirstOrDefault ();
            if (anim != null && anim2 != null) {

                anim [animName1].layer = 1;
                anim2 [animName2].layer = 1;
                if (IsEnabled) {
                    anim [animName1].normalizedTime = 0f;
                    anim [animName1].speed = -1f;
                    anim2 [animName2].normalizedTime = 0f;
                    anim2 [animName2].speed = -1f;
                } else {
                    anim [animName1].normalizedTime = 1f;
                    anim [animName1].speed = 1f;
                    anim2 [animName2].normalizedTime = 1f;
                    anim2 [animName2].speed = 1f;
                }
                anim.Play ();
                anim2.Play ();
            }

            if (IsEnabled && last_active_time != 0) {
                float global_rate_multipliers = 1;
                crew_capacity_ratio = ((float)part.protoModuleCrew.Count) / ((float)part.CrewCapacity);
                global_rate_multipliers = global_rate_multipliers * crew_capacity_ratio;

                if (active_mode == 0) { // Science persistence
                    double now = Planetarium.GetUniversalTime ();
                    double time_diff = now - last_active_time;
                    float altitude_multiplier = (float)(vessel.altitude / (vessel.mainBody.Radius));
                    altitude_multiplier = Math.Max (altitude_multiplier, 1);
                    float stupidity = 0;
                    foreach (ProtoCrewMember proto_crew_member in part.protoModuleCrew) {
                        stupidity += proto_crew_member.stupidity;
                    }
                    stupidity = 1.5f - stupidity / 2.0f;
                    double science_to_add = baseScienceRate * time_diff / 86400 * electrical_power_ratio * stupidity * global_rate_multipliers * PluginHelper.getScienceMultiplier (vessel.mainBody.flightGlobalsIndex,vessel.LandedOrSplashed) / ((float)Math.Sqrt (altitude_multiplier));
                    part.RequestResource ("Science", -science_to_add);
                } else if (active_mode == 2) { // Antimatter persistence
                    double now = Planetarium.GetUniversalTime ();
                    double time_diff = now - last_active_time;

                    List<PartResource> partresources = new List<PartResource>();
                    part.GetConnectedResources(PartResourceLibrary.Instance.GetDefinition("Antimatter").id, partresources);
                    float currentAntimatter_missing = 0;
                    foreach (PartResource partresource in partresources) {
                        currentAntimatter_missing += (float)(partresource.maxAmount-partresource.amount);
                    }

                    float total_electrical_power_provided = electrical_power_ratio * (baseAMFPowerConsumption + basePowerConsumption)*1E6f;
                    float antimatter_mass = total_electrical_power_provided/AlcubierreDrive.warpspeed/AlcubierreDrive.warpspeed*1E6f/20000.0f;
                    float antimatter_peristence_to_add = (float) -Math.Min (currentAntimatter_missing, antimatter_mass * time_diff);
                    part.RequestResource("Antimatter", antimatter_peristence_to_add);
                }
            }
        }
        private void ExportMeshAnimation()
        {
            AnimationClip[] animationClips     = exportParams.AnimationClips;
            string[]        animationClipNames = exportParams.AnimationNames;
            GameObject      instanceObj        = Instantiate(fbx) as GameObject;

            UnityEngine.Animation animation          = instanceObj.GetComponentInChildren <UnityEngine.Animation>();
            SkinnedMeshRenderer[] skinnedMeshRenders = instanceObj.GetComponentsInChildren <SkinnedMeshRenderer>();
            int subMeshLength = skinnedMeshRenders.Length;

            Mesh[] subMeshArr = new Mesh[subMeshLength];
            for (int i = 0; i < subMeshLength; i++)
            {
                subMeshArr[i] = skinnedMeshRenders[i].sharedMesh;
            }
            float interval = 1.0f / exportParams.FrameRate;

            if (File.Exists(exportParams.OutputFilePath))
            {
                File.Delete(exportParams.OutputFilePath);
            }
            ExportMeshAnimationData meshAnimationData = ScriptableObject.CreateInstance <ExportMeshAnimationData>();

            meshAnimationData.GenerateNormal = exportParams.GenerateNormal;
            meshAnimationData.SubMeshLength  = subMeshLength;
            meshAnimationData.Fps            = exportParams.FrameRate;
            meshAnimationData.SubMeshData    = new ExportMeshAnimationData.AnimationSubMeshData[subMeshLength];
            for (int i = 0; i < subMeshLength; i++)
            {
                meshAnimationData.SubMeshData[i].ClipDatas = new ExportMeshAnimationData.AnimationClipData[animationClips.Length];
                meshAnimationData.SubMeshData[i].FrameRate = exportParams.FrameRate;
                for (int j = 0; j < animationClips.Length; j++)
                {
                    AnimationClip clip = animationClips[j];
                    if (clip == null)
                    {
                        return;
                    }
                    animation.AddClip(clip, animationClipNames[j]);
                    animation.clip = clip;
                    AnimationState state = animation[animationClipNames[j]];
                    state.enabled = true;
                    state.weight  = 1;
                    List <float> frameTimes = GetFrameTimes(clip.length, interval);
                    meshAnimationData.SubMeshData[i].ClipDatas[j].FrameDatas = new ExportMeshAnimationData.AnimationFrameData[frameTimes.Count];
                    meshAnimationData.SubMeshData[i].ClipDatas[j].ClipName   = animationClipNames[j];
                    for (int k = 0; k < frameTimes.Count; k++)
                    {
                        state.time = frameTimes[k];
                        animation.Play();
                        animation.Sample();
                        Matrix4x4 matrix4X4 = skinnedMeshRenders[i].transform.localToWorldMatrix;
                        Mesh      backMesh  = BakeFrameAfterMatrixTransform(skinnedMeshRenders[i], matrix4X4);
                        meshAnimationData.SubMeshData[i].ClipDatas[j].FrameDatas[k].Vertexs = backMesh.vertices;
                        backMesh.Clear();
                        DestroyImmediate(backMesh);
                        animation.Stop();
                    }
                }
                meshAnimationData.SubMeshData[i].UVs       = subMeshArr[i].uv;
                meshAnimationData.SubMeshData[i].Triangles = subMeshArr[i].triangles;
            }
            AssetDatabase.CreateAsset(meshAnimationData, GetAssetPath(exportParams.OutputFilePath) + fbx.name + ".asset");
            AssetDatabase.Refresh();
        }
 private void PlayStartAnimation(Animation StartAnimation, string startAnimationName, int speed, bool instant)
 {
     if (startAnimationName != "")
     {
         if (speed < 0)
         {
             StartAnimation[startAnimationName].time = StartAnimation[startAnimationName].length;
         }
         if (instant)
             StartAnimation[startAnimationName].speed = 999999 * speed;
         StartAnimation[startAnimationName].speed = speed;
         StartAnimation.Play(startAnimationName);
     }
 }
        public override void OnStart(PartModule.StartState state) {
            String[] resources_to_supply = { FNResourceManager.FNRESOURCE_MEGAJOULES, FNResourceManager.FNRESOURCE_WASTEHEAT, FNResourceManager.FNRESOURCE_THERMALPOWER };
            this.resources_to_supply = resources_to_supply;
            base.OnStart(state);
            if (state == StartState.Editor) { return; }

            if (part.FindModulesImplementing<MicrowavePowerTransmitter>().Count == 1) {
                part_transmitter = part.FindModulesImplementing<MicrowavePowerTransmitter>().First();
                has_transmitter = true;
            }

            if (animTName != null) {
                animT = part.FindModelAnimators(animTName).FirstOrDefault();
                if (animT != null) {
                    animT[animTName].layer = 1;
                    animT[animTName].normalizedTime = 0f;
                    animT[animTName].speed = 0.001f;
                    animT.Play();
                }
            }

            if (animName != null) {
                anim = part.FindModelAnimators(animName).FirstOrDefault();
                if (anim != null) {
                    anim[animName].layer = 1;
                    if (connectedsatsi > 0 || connectedrelaysi > 0) {
                        anim[animName].normalizedTime = 1f;
                        anim[animName].speed = -1f;

                    } else {
                        anim[animName].normalizedTime = 0f;
                        anim[animName].speed = 1f;

                    }
                    anim.Play();
                }
            }
            vmps = new List<VesselMicrowavePersistence>();
            vrps = new List<VesselRelayPersistence>();
            foreach (Vessel vess in FlightGlobals.Vessels) {
                String vesselID = vess.id.ToString();

                if (vess.isActiveVessel == false && vess.vesselName.ToLower().IndexOf("debris") == -1) {
                    ConfigNode config = PluginHelper.getPluginSaveFile();
                    if (config.HasNode("VESSEL_MICROWAVE_POWER_" + vesselID)) {
                        ConfigNode power_node = config.GetNode("VESSEL_MICROWAVE_POWER_" + vesselID);
                        double nuclear_power = 0;
                        double solar_power = 0;
                        if (power_node.HasValue("nuclear_power")) {
                            nuclear_power = double.Parse(power_node.GetValue("nuclear_power"));

                        }
                        if (power_node.HasValue("solar_power")) {
                            solar_power = double.Parse(power_node.GetValue("solar_power"));
                        }
                        if (nuclear_power > 0 || solar_power > 0) {
                            VesselMicrowavePersistence vmp = new VesselMicrowavePersistence(vess);
                            vmp.setSolarPower(solar_power);
                            vmp.setNuclearPower(nuclear_power);
                            vmps.Add(vmp);
                        }
                    }

                    if (config.HasNode("VESSEL_MICROWAVE_RELAY_" + vesselID)) {
                        ConfigNode relay_node = config.GetNode("VESSEL_MICROWAVE_RELAY_" + vesselID);
                        if (relay_node.HasValue("relay")) {
                            bool relay = bool.Parse(relay_node.GetValue("relay"));
                            if (relay) {
                                VesselRelayPersistence vrp = new VesselRelayPersistence(vess);
                                vrp.setActive(relay);
                                vrps.Add(vrp);
                            }
                        }
                    }
                }
            }
            penaltyFreeDistance = Math.Sqrt(1 / ((microwaveAngleTan * microwaveAngleTan) / collectorArea));

            this.part.force_activate();

        }
Ejemplo n.º 46
0
        public override void OnStart(PartModule.StartState state)
        {
            Actions["ActivateReceiverAction"].guiName = Events["ActivateReceiver"].guiName = String.Format("Activate Receiver");
            Actions["DisableReceiverAction"].guiName = Events["DisableReceiver"].guiName = String.Format("Disable Receiver");
            Actions["ToggleReceiverAction"].guiName = String.Format("Toggle Receiver");

            base.OnStart (state);
            if (state == StartState.Editor) { return; }
            this.part.force_activate();

            anim = part.FindModelAnimators (animName).FirstOrDefault ();
            if (anim != null) {
                anim [animName].layer = 1;
                if (connectedsatsf > 0 || connectedrelaysf > 0) {
                    anim [animName].normalizedTime = 1f;
                    anim [animName].speed = -1f;

                } else {
                    anim [animName].normalizedTime = 0f;
                    anim [animName].speed = 1f;

                }
                anim.Play ();
            }

            if (mycount == -1) {
                mycount = dishcount;
                dishcount++;
            }
        }
Ejemplo n.º 47
0
        public void Start()
        {
            thisTransform = transform;
            thisAnimation = GetComponent<Animation>();
            gameManager = GameManager.instance;

            thisTransform.position = spawnPosition;
            thisTransform.eulerAngles = spawnRotation;
            platformLayer = (1 << LayerMask.NameToLayer("Platform")) | (1 << LayerMask.NameToLayer("PlatformJump")) | (1 << LayerMask.NameToLayer("Floor"));

            // setup the animation wrap modes
            thisAnimation[idleAnimationName].wrapMode = WrapMode.Loop;
            thisAnimation[runAnimationName].wrapMode = WrapMode.Loop;
            thisAnimation[attackAnimationName].wrapMode = WrapMode.Once;
            thisAnimation.Play(idleAnimationName);

            GameManager.instance.OnStartGame += StartGame;
        }
Ejemplo n.º 48
0
 /// <summary>
 /// 播放动画片段
 /// </summary>
 /// <param name="anim"></param>
 /// <param name="name"></param>
 /// <param name="dir"></param>
 /// <returns></returns>
 public static AnimationState PlayAnimation(Animation anim, string name, AnimationOrTween.Direction dir)
 {
     var state = anim[name];
     if (state)
     {
         float speed = Mathf.Abs(state.speed);
         state.speed = speed * (int)dir;
         if (dir == AnimationOrTween.Direction.Reverse && state.time == 0f) state.time = state.length;
         else if (dir == AnimationOrTween.Direction.Forward && state.time == state.length) state.time = 0f;
         //Debug.Log(string.Format(" speed {0},dir ={1},time = {2},length={3}",state.speed,dir,state.time,state.length));
         anim.Play(name);
         anim.Sample();
     }
     return state;
 }
Ejemplo n.º 49
0
 //only called for animated internal parts
 private void closeCryopod(int seatIndx, float speed)
 {
     string podname = "Animated-Cryopod-" + (seatIndx + 1);
     string windowname = "Animated-Cryopod-" + (seatIndx + 1) + "-Window";
      Utilities.Log_Debug("playing animation closecryopod " + podname + " " + windowname);
     try
     {
         _animation = part.internalModel.FindModelComponent<Animation>(podname);
         if (_animation != null)
         {
             if (!cryopodstateclosed[seatIndx])
             {
                 _animation["Close"].speed = speed;
                 _animation.Play("Close");
                 cryopodstateclosed[seatIndx] = true;
                 savecryopodstatepersistent();
             }
         }
         else
              Utilities.Log_Debug("Cryopod animation not found");
     }
     catch (Exception ex)
     {
         Debug.Log("Unable to find animation in internal model for this part called " + podname);
         Debug.Log("Err: " + ex);
     }
 }
Ejemplo n.º 50
0
        public override void OnStart(PartModule.StartState state)
        {
            print("[KSP Interstellar]  Generator OnStart Begin " + startcount);

            String[] resources_to_supply = { FNResourceManager.FNRESOURCE_MEGAJOULES, FNResourceManager.FNRESOURCE_WASTEHEAT };
            this.resources_to_supply = resources_to_supply;

            if (state == PartModule.StartState.Docked)
            {
                base.OnStart(state);
                return;
            }

            // calculate WasteHeat Capacity
            var wasteheatPowerResource = part.Resources.list.FirstOrDefault(r => r.resourceName == FNResourceManager.FNRESOURCE_WASTEHEAT);
            if (wasteheatPowerResource != null)
            {
                var ratio = wasteheatPowerResource.amount / wasteheatPowerResource.maxAmount;
                wasteheatPowerResource.maxAmount = part.mass * 1.0e+5 * wasteHeatMultiplier;
                wasteheatPowerResource.amount = wasteheatPowerResource.maxAmount * ratio;
            }

            previousTimeWarp = TimeWarp.fixedDeltaTime - 1.0e-6f;
            megajouleResource = part.Resources.list.FirstOrDefault(r => r.resourceName == FNResourceManager.FNRESOURCE_MEGAJOULES);

            base.OnStart(state);
            generatorType = originalName;

            Fields["maxChargedPower"].guiActive = chargedParticleMode;
            Fields["maxThermalPower"].guiActive = !chargedParticleMode;

            if (state == StartState.Editor)
            {
                if (this.HasTechsRequiredToUpgrade())
                {
                    isupgraded = true;
                    hasrequiredupgrade = true;
                    upgradePartModule();
                }
                part.OnEditorAttach += OnEditorAttach;
                return;
            }

            if (this.HasTechsRequiredToUpgrade())
                hasrequiredupgrade = true;

            this.part.force_activate();

            anim = part.FindModelAnimators(animName).FirstOrDefault();
            if (anim != null)
            {
                anim[animName].layer = 1;
                if (!IsEnabled)
                {
                    anim[animName].normalizedTime = 1f;
                    anim[animName].speed = -1f;
                }
                else
                {
                    anim[animName].normalizedTime = 0f;
                    anim[animName].speed = 1f;
                }
                anim.Play();
            }

            if (generatorInit == false)
            {
                generatorInit = true;
                IsEnabled = true;
            }

            if (isupgraded)
                upgradePartModule();

            FindAttachedThermalSource();

            UpdateHeatExchangedThrustDivisor();

            print("[KSP Interstellar]  Generator OnStart Finished");
        }
Ejemplo n.º 51
0
        private void freezeCryopodWindow(int seatIndx, float speed)
        {
            if (isPartAnimated || (isPodExternal && DFInstalledMods.IsJSITransparentPodsInstalled && _prevRPMTransparentpodSetting == "ON"))
                setCryopodWindowTransparent(seatIndx);
            else
                speed = float.MaxValue;
            string windowname = "";
            if (isPartAnimated)
                windowname = "Animated-Cryopod-" + (seatIndx + 1) + "-Window";
            else
                windowname = "Cryopod-" + (seatIndx + 1) + "-Window";

            _windowAnimation = part.internalModel.FindModelComponent<Animation>(windowname);
            Animation _extwindowAnimation = null;
            if (isPodExternal)
            {
                _extwindowAnimation = part.FindModelComponent<Animation>(windowname);
                //Utilities.SetInternalDepthMask(part, true, "External_Window_Occluder"); //Set window occluder visible (block internals)
            }

            if (_windowAnimation == null)
            {
                 Utilities.Log_Debug("Why can't I find the window animation?");
            }
            else
            {
                _windowAnimation["CryopodWindowClose"].speed = speed;
                _windowAnimation.Play("CryopodWindowClose");
            }
            if (isPodExternal && _extwindowAnimation != null)
            {
                _extwindowAnimation["CryopodWindowClose"].speed = speed;
                _extwindowAnimation.Play("CryopodWindowClose");
            }
        }
Ejemplo n.º 52
0
		public override void OnStart(PartModule.StartState state) {
			String[] resources_to_supply = {FNResourceManager.FNRESOURCE_MEGAJOULES,FNResourceManager.FNRESOURCE_WASTEHEAT};
			this.resources_to_supply = resources_to_supply;
			base.OnStart (state);
            generatorType = originalName;
            if (state == StartState.Editor) {
                if (hasTechsRequiredToUpgrade()) {
                    isupgraded = true;
                    hasrequiredupgrade = true;
                    upgradePartModule();
                }
                part.OnEditorAttach += OnEditorAttach;
                return;
            }

            if (hasTechsRequiredToUpgrade()) {
                hasrequiredupgrade = true;
            }

			this.part.force_activate();
			

			anim = part.FindModelAnimators (animName).FirstOrDefault ();
			if (anim != null) {
				anim [animName].layer = 1;
				if (!IsEnabled) {
					anim [animName].normalizedTime = 1f;
					anim [animName].speed = -1f;

				} else {
					anim [animName].normalizedTime = 0f;
					anim [animName].speed = 1f;

				}
				anim.Play ();
			}

			if (generatorInit == false) {
				generatorInit = true;
				IsEnabled = true;
			}

			if (isupgraded) {
				upgradePartModule ();
			}

			foreach (AttachNode attach_node in part.attachNodes) {
				if(attach_node.attachedPart != null) {
					List<FNThermalSource> sources = attach_node.attachedPart.FindModulesImplementing<FNThermalSource> ();
					if (sources.Count > 0) {
						myAttachedReactor = sources.First ();
						if (myAttachedReactor != null) {
							break;
						}
					}
				}
			}

			print("[KSP Interstellar] Configuring Generator");
		}
        //----------------methods-----------------
        public override void OnStart(PartModule.StartState state)
        {
            base.OnStart(state);

            //find the animation
            anim = part.FindModelAnimators(animationName).FirstOrDefault();

            //find the dependent module
            dependent = (PlanetaryModule)this.part.GetComponent("PlanetaryModule");

            if (anim != null) //Only Init when an animation is available
            {
                if (!hasBeenInitialized) // Run Only on first launch
                {
                    nextIsReverse = false;
                    animationTime = 0f;
                    anim[animationName].normalizedTime = 0f;
                    hasBeenInitialized = true;
                }

                // make sure you stay in your place on launch, and don't start going in the wrong direction if deployed/retracted
                if (nextIsReverse)
                {
                    anim[animationName].speed = 1f;
                    if (animationTime == 0f)
                    {
                        animationTime = 1f;
                    }

                    if (animationTime == 1f)
                    {
                        lightStatus = "On";
                    }
                    else
                    {
                        lightStatus = "Turning on";
                    }

                }
                else
                {
                    if (animationTime == 0f)
                    {
                        lightStatus = "Off";
                    }
                    else
                    {
                        lightStatus = "Turning off";
                    }

                    anim[animationName].speed = -1f;
                }

                //set up animation state according to persistent values
                anim[animationName].layer = layer;
                anim.Play(animationName);
                anim[animationName].normalizedTime = animationTime;

                //Settings for the GUI
                if (nextIsReverse)
                {
                    Events["toggleAnimation"].guiName = endEventGUIName;
                }
                else
                {
                    Events["toggleAnimation"].guiName = startEventGUIName;
                }

                //check whether the element can be active or not
                bool bShowGUI = true;
                if (dependent != null)
                {
                    bShowGUI = dependent.status.Equals("Deployed");
                }

                Events["toggleAnimation"].guiActiveEditor = availableInEditor;
                Events["toggleAnimation"].guiActiveUnfocused = availableInEVA && bShowGUI;
                Events["toggleAnimation"].guiActive = availableInVessel && bShowGUI;
                Events["toggleAnimation"].unfocusedRange = EVArange;
            }
            else //When the animation can not be found deactivate it in the GUI
            {
                Events["toggleAnimation"].guiActiveEditor = false;
                Events["toggleAnimation"].guiActive = false;
                Events["toggleAnimation"].guiActiveUnfocused = false;
                Debug.Log("KBILightAnimation: Animation not found: " + animationName);
            }
        }
Ejemplo n.º 54
0
		public override void OnStart(PartModule.StartState state) {
            String[] resources_to_supply = { FNResourceManager.FNRESOURCE_THERMALPOWER, FNResourceManager.FNRESOURCE_WASTEHEAT, FNResourceManager.FNRESOURCE_CHARGED_PARTICLES };
			this.resources_to_supply = resources_to_supply;
            //name_to_use = originalName;
			base.OnStart(state);

            Actions["ActivateReactorAction"].guiName = Events["ActivateReactor"].guiName = String.Format("Activate Reactor");
            Actions["DeactivateReactorAction"].guiName = Events["DeactivateReactor"].guiName = String.Format("Deactivate Reactor");
            Actions["ToggleReactorAction"].guiName = String.Format("Toggle Reactor");

            if (state == StartState.Editor) {
                if (startDisabled) {
                    Events["ActivateReactorVAB"].guiActiveEditor = true;
                    Events["DeactivateReactorVAB"].guiActiveEditor = false;
                }
                if (hasTechsRequiredToUpgrade()) {
                    isupgraded = true;
                    upgradePartModule();
                }
                return;
            }

            if (hasTechsRequiredToUpgrade()) {
                hasrequiredupgrade = true;
            }

            if (startDisabled) {
                last_active_time = (float) (Planetarium.GetUniversalTime() - 4.0 * 86400.0);
                IsEnabled = false;
                startDisabled = false;
            }
            
			anim = part.FindModelAnimators (animName).FirstOrDefault ();
			if (anim != null) {
				anim [animName].layer = 1;
				if (!IsEnabled) {
					anim [animName].normalizedTime = 1f;
					anim [animName].speed = -1f;

				} else {
					anim [animName].normalizedTime = 0f;
					anim [animName].speed = 1f;

				}
				anim.Play ();
			}
            
            if (IsEnabled && last_active_time > 0) {
                double now = Planetarium.GetUniversalTime();
                double time_diff = now - last_active_time;
                double resource_to_take = consumeReactorResource(resourceRate*time_diff*ongoing_consumption_rate);
                if (breedtritium) {
                    tritium_rate = (float)(ThermalPower / 1000.0f / GameConstants.tritiumBreedRate);
                    List<PartResource> lithium_resources = new List<PartResource>();
                    part.GetConnectedResources(PartResourceLibrary.Instance.GetDefinition("Lithium").id, lithium_resources);
                    double lithium_current_amount = 0;
                    foreach (PartResource lithium_resource in lithium_resources) {
                        lithium_current_amount += lithium_resource.amount;
                    }

                    List<PartResource> tritium_resources = new List<PartResource>();
                    part.GetConnectedResources(PartResourceLibrary.Instance.GetDefinition("Tritium").id, tritium_resources);
                    double tritium_missing_amount = 0;
                    foreach (PartResource tritium_resource in tritium_resources) {
                        tritium_missing_amount += tritium_resource.maxAmount - tritium_resource.amount;
                    }

                    double lithium_to_take = Math.Min(tritium_rate * time_diff * ongoing_consumption_rate, lithium_current_amount);
                    double tritium_to_add = Math.Min(tritium_rate * time_diff * ongoing_consumption_rate, tritium_missing_amount);
                    ORSHelper.fixedRequestResource(part, "Lithium", Math.Min(tritium_to_add, lithium_to_take));
                    ORSHelper.fixedRequestResource(part, "Tritium", -Math.Min(tritium_to_add, lithium_to_take));
                }
            }
            this.part.force_activate();
        }
Ejemplo n.º 55
0
        void Start()
        {
            m_controller = this.GetComponentInChildren<CharacterController>();
            m_curState = AnimStates.Idle;
            m_animComponent = this.gameObject.GetComponentInChildren<Animation>();

            m_isDead = false;
            m_isSitting = false;

            for (int i = 0; i < (int)AnimationType.DEFAULT; i++)
            {
                m_animComponent.AddClip(characterAnimations[i], ((AnimationType)i).ToString());
            }

            m_animComponent.Play(characterAnimations[(int)AnimationType.Idle].name);

            m_animComponent.wrapMode = WrapMode.Loop;

            m_attackType = AnimAttackType.None;
            m_turnDir = TurningType.None;
        }
Ejemplo n.º 56
0
 public void GoMooCowGo()
 {
     _cowAnimation.Rewind();
     _cowAnimation.Play();
 }
Ejemplo n.º 57
0
 private void PlayStartAnimation(Animation StartAnimation, string startAnimationName, int speed, bool instant)
 {
     if (startAnimationName != "")
     {
         if (speed < 0)
         {
             StartAnimation[startAnimationName].time = StartAnimation[startAnimationName].length;
             if (loopPoint != 0)
                 StartAnimation[startAnimationName].time = loopPoint;
         }
         if (instant)
             StartAnimation[startAnimationName].speed = 999999 * speed;
         StartAnimation[startAnimationName].wrapMode = WrapMode.Default;
         StartAnimation[startAnimationName].speed = speed;
         StartAnimation.Play(startAnimationName);
     }
 }
        public VariableAnimationSet(ConfigNode node, InternalProp thisProp, RasterPropMonitorComputer rpmComp, JSIVariableAnimator parent)
        {
            varAnim = parent;
            onChangeDelegate = (Action<float>)Delegate.CreateDelegate(typeof(Action<float>), this, "OnChange");
            part = thisProp.part;

            if (!node.HasData)
            {
                throw new ArgumentException("No data?!");
            }

            string[] tokens = { };

            if (node.HasValue("scale"))
            {
                tokens = node.GetValue("scale").Split(',');
            }

            if (tokens.Length != 2)
            {
                throw new ArgumentException("Could not parse 'scale' parameter.");
            }

            string variableName = string.Empty;
            if (node.HasValue("variableName"))
            {
                variableName = node.GetValue("variableName").Trim();
            }
            else if (node.HasValue("stateMethod"))
            {
                string stateMethod = node.GetValue("stateMethod").Trim();
                // Verify the state method actually exists
                Func<bool> stateFunction = (Func<bool>)rpmComp.GetMethod(stateMethod, thisProp, typeof(Func<bool>));
                if (stateFunction != null)
                {
                    variableName = "PLUGIN_" + stateMethod;
                }
                else
                {
                    throw new ArgumentException("Unrecognized stateMethod");
                }
            }
            else
            {
                throw new ArgumentException("Missing variable name.");
            }

            if (node.HasValue("modulo"))
            {
                variable = new VariableOrNumberRange(rpmComp, variableName, tokens[0], tokens[1], node.GetValue("modulo"));
                usesModulo = true;
            }
            else
            {
                variable = new VariableOrNumberRange(rpmComp, variableName, tokens[0], tokens[1]);
                usesModulo = false;
            }

            // That takes care of the scale, now what to do about that scale:
            if (node.HasValue("reverse"))
            {
                if (!bool.TryParse(node.GetValue("reverse"), out reverse))
                {
                    throw new ArgumentException("So is 'reverse' true or false?");
                }
            }

            if (node.HasValue("animationName"))
            {
                animationName = node.GetValue("animationName");
                if (node.HasValue("animationSpeed"))
                {
                    animationSpeed = float.Parse(node.GetValue("animationSpeed"));

                    if (reverse)
                    {
                        animationSpeed = -animationSpeed;
                    }
                }
                else
                {
                    animationSpeed = 0.0f;
                }
                Animation[] anims = node.HasValue("animateExterior") ? thisProp.part.FindModelAnimators(animationName) : thisProp.FindModelAnimators(animationName);
                if (anims.Length > 0)
                {
                    onAnim = anims[0];
                    onAnim.enabled = true;
                    onAnim[animationName].speed = 0;
                    onAnim[animationName].normalizedTime = reverse ? 1f : 0f;
                    looping = node.HasValue("loopingAnimation");
                    if (looping)
                    {
                        onAnim[animationName].wrapMode = WrapMode.Loop;
                        onAnim.wrapMode = WrapMode.Loop;
                        onAnim[animationName].speed = animationSpeed;
                        mode = Mode.LoopingAnimation;
                    }
                    else
                    {
                        onAnim[animationName].wrapMode = WrapMode.Once;
                        mode = Mode.Animation;
                    }
                    onAnim.Play();
                    alwaysActive = node.HasValue("animateExterior");
                }
                else
                {
                    throw new ArgumentException("Animation could not be found.");
                }

                if (node.HasValue("stopAnimationName"))
                {
                    stopAnimationName = node.GetValue("stopAnimationName");
                    anims = node.HasValue("animateExterior") ? thisProp.part.FindModelAnimators(stopAnimationName) : thisProp.FindModelAnimators(stopAnimationName);
                    if (anims.Length > 0)
                    {
                        offAnim = anims[0];
                        offAnim.enabled = true;
                        offAnim[stopAnimationName].speed = 0;
                        offAnim[stopAnimationName].normalizedTime = reverse ? 1f : 0f;
                        if (looping)
                        {
                            offAnim[stopAnimationName].wrapMode = WrapMode.Loop;
                            offAnim.wrapMode = WrapMode.Loop;
                            offAnim[stopAnimationName].speed = animationSpeed;
                            mode = Mode.LoopingAnimation;
                        }
                        else
                        {
                            offAnim[stopAnimationName].wrapMode = WrapMode.Once;
                            mode = Mode.Animation;
                        }
                    }
                }
            }
            else if (node.HasValue("activeColor") && node.HasValue("passiveColor") && node.HasValue("coloredObject"))
            {
                string colorNameString = "_EmissiveColor";
                if (node.HasValue("colorName"))
                {
                    colorNameString = node.GetValue("colorName");
                }
                colorName = Shader.PropertyToID(colorNameString);

                if (reverse)
                {
                    activeColor = JUtil.ParseColor32(node.GetValue("passiveColor"), thisProp.part, ref rpmComp);
                    passiveColor = JUtil.ParseColor32(node.GetValue("activeColor"), thisProp.part, ref rpmComp);
                }
                else
                {
                    passiveColor = JUtil.ParseColor32(node.GetValue("passiveColor"), thisProp.part, ref rpmComp);
                    activeColor = JUtil.ParseColor32(node.GetValue("activeColor"), thisProp.part, ref rpmComp);
                }
                Renderer colorShiftRenderer = thisProp.FindModelComponent<Renderer>(node.GetValue("coloredObject"));
                affectedMaterial = colorShiftRenderer.material;
                affectedMaterial.SetColor(colorName, passiveColor);
                mode = Mode.Color;
            }
            else if (node.HasValue("controlledTransform") && node.HasValue("localRotationStart") && node.HasValue("localRotationEnd"))
            {
                controlledTransform = thisProp.FindModelTransform(node.GetValue("controlledTransform").Trim());
                initialRotation = controlledTransform.localRotation;
                if (node.HasValue("longPath"))
                {
                    longPath = true;
                    if (reverse)
                    {
                        vectorEnd = ConfigNode.ParseVector3(node.GetValue("localRotationStart"));
                        vectorStart = ConfigNode.ParseVector3(node.GetValue("localRotationEnd"));
                    }
                    else
                    {
                        vectorStart = ConfigNode.ParseVector3(node.GetValue("localRotationStart"));
                        vectorEnd = ConfigNode.ParseVector3(node.GetValue("localRotationEnd"));
                    }
                }
                else
                {
                    if (reverse)
                    {
                        rotationEnd = Quaternion.Euler(ConfigNode.ParseVector3(node.GetValue("localRotationStart")));
                        rotationStart = Quaternion.Euler(ConfigNode.ParseVector3(node.GetValue("localRotationEnd")));
                    }
                    else
                    {
                        rotationStart = Quaternion.Euler(ConfigNode.ParseVector3(node.GetValue("localRotationStart")));
                        rotationEnd = Quaternion.Euler(ConfigNode.ParseVector3(node.GetValue("localRotationEnd")));
                    }
                }
                mode = Mode.Rotation;
            }
            else if (node.HasValue("controlledTransform") && node.HasValue("localTranslationStart") && node.HasValue("localTranslationEnd"))
            {
                controlledTransform = thisProp.FindModelTransform(node.GetValue("controlledTransform").Trim());
                initialPosition = controlledTransform.localPosition;
                if (reverse)
                {
                    vectorEnd = ConfigNode.ParseVector3(node.GetValue("localTranslationStart"));
                    vectorStart = ConfigNode.ParseVector3(node.GetValue("localTranslationEnd"));
                }
                else
                {
                    vectorStart = ConfigNode.ParseVector3(node.GetValue("localTranslationStart"));
                    vectorEnd = ConfigNode.ParseVector3(node.GetValue("localTranslationEnd"));
                }
                mode = Mode.Translation;
            }
            else if (node.HasValue("controlledTransform") && node.HasValue("localScaleStart") && node.HasValue("localScaleEnd"))
            {
                controlledTransform = thisProp.FindModelTransform(node.GetValue("controlledTransform").Trim());
                initialScale = controlledTransform.localScale;
                if (reverse)
                {
                    vectorEnd = ConfigNode.ParseVector3(node.GetValue("localScaleStart"));
                    vectorStart = ConfigNode.ParseVector3(node.GetValue("localScaleEnd"));
                }
                else
                {
                    vectorStart = ConfigNode.ParseVector3(node.GetValue("localScaleStart"));
                    vectorEnd = ConfigNode.ParseVector3(node.GetValue("localScaleEnd"));
                }
                mode = Mode.Scale;
            }
            else if (node.HasValue("controlledTransform") && node.HasValue("textureLayers") && node.HasValue("textureShiftStart") && node.HasValue("textureShiftEnd"))
            {
                affectedMaterial = thisProp.FindModelTransform(node.GetValue("controlledTransform").Trim()).GetComponent<Renderer>().material;
                var textureLayers = node.GetValue("textureLayers").Split(',');
                for (int i = 0; i < textureLayers.Length; ++i)
                {
                    textureLayer.Add(textureLayers[i].Trim());
                }

                if (reverse)
                {
                    textureShiftEnd = ConfigNode.ParseVector2(node.GetValue("textureShiftStart"));
                    textureShiftStart = ConfigNode.ParseVector2(node.GetValue("textureShiftEnd"));
                }
                else
                {
                    textureShiftStart = ConfigNode.ParseVector2(node.GetValue("textureShiftStart"));
                    textureShiftEnd = ConfigNode.ParseVector2(node.GetValue("textureShiftEnd"));
                }
                mode = Mode.TextureShift;
            }
            else if (node.HasValue("controlledTransform") && node.HasValue("textureLayers") && node.HasValue("textureScaleStart") && node.HasValue("textureScaleEnd"))
            {
                affectedMaterial = thisProp.FindModelTransform(node.GetValue("controlledTransform").Trim()).GetComponent<Renderer>().material;
                var textureLayers = node.GetValue("textureLayers").Split(',');
                for (int i = 0; i < textureLayers.Length; ++i)
                {
                    textureLayer.Add(textureLayers[i].Trim());
                }

                if (reverse)
                {
                    textureScaleEnd = ConfigNode.ParseVector2(node.GetValue("textureScaleStart"));
                    textureScaleStart = ConfigNode.ParseVector2(node.GetValue("textureScaleEnd"));
                }
                else
                {
                    textureScaleStart = ConfigNode.ParseVector2(node.GetValue("textureScaleStart"));
                    textureScaleEnd = ConfigNode.ParseVector2(node.GetValue("textureScaleEnd"));
                }
                mode = Mode.TextureScale;
            }
            else
            {
                throw new ArgumentException("Cannot initiate any of the possible action modes.");
            }

            if (!(node.HasValue("maxRateChange") && float.TryParse(node.GetValue("maxRateChange"), out maxRateChange)))
            {
                maxRateChange = 0.0f;
            }
            if (maxRateChange >= 60.0f)
            {
                // Animation rate is too fast to even notice @60Hz
                maxRateChange = 0.0f;
            }
            else
            {
                lastAnimUpdate = Planetarium.GetUniversalTime();
            }

            if (node.HasValue("threshold"))
            {
                threshold = ConfigNode.ParseVector2(node.GetValue("threshold"));
            }

            resourceAmount = 0.0f;
            if (threshold != Vector2.zero)
            {
                thresholdMode = true;

                float min = Mathf.Min(threshold.x, threshold.y);
                float max = Mathf.Max(threshold.x, threshold.y);
                threshold.x = min;
                threshold.y = max;

                if (node.HasValue("flashingDelay"))
                {
                    flashingDelay = double.Parse(node.GetValue("flashingDelay"));
                }

                if (node.HasValue("alarmSound"))
                {
                    alarmSoundVolume = 0.5f;
                    if (node.HasValue("alarmSoundVolume"))
                    {
                        alarmSoundVolume = float.Parse(node.GetValue("alarmSoundVolume"));
                    }
                    audioOutput = JUtil.SetupIVASound(thisProp, node.GetValue("alarmSound"), alarmSoundVolume, false);
                    if (node.HasValue("alarmMustPlayOnce"))
                    {
                        if (!bool.TryParse(node.GetValue("alarmMustPlayOnce"), out alarmMustPlayOnce))
                        {
                            throw new ArgumentException("So is 'alarmMustPlayOnce' true or false?");
                        }
                    }
                    if (node.HasValue("alarmShutdownButton"))
                    {
                        SmarterButton.CreateButton(thisProp, node.GetValue("alarmShutdownButton"), AlarmShutdown);
                    }
                    if (node.HasValue("alarmSoundLooping"))
                    {
                        if (!bool.TryParse(node.GetValue("alarmSoundLooping"), out alarmSoundLooping))
                        {
                            throw new ArgumentException("So is 'alarmSoundLooping' true or false?");
                        }
                        audioOutput.audio.loop = alarmSoundLooping;
                    }

                    inIVA = (CameraManager.Instance.currentCameraMode == CameraManager.CameraMode.IVA);

                    GameEvents.OnCameraChange.Add(OnCameraChange);
                }

                if (node.HasValue("resourceAmount"))
                {
                    resourceAmount = float.Parse(node.GetValue("resourceAmount"));

                    if (node.HasValue("resourceName"))
                    {
                        resourceName = node.GetValue("resourceName");
                    }
                    else
                    {
                        resourceName = "ElectricCharge";
                    }
                }

                TurnOff(Planetarium.GetUniversalTime());
            }

            rpmComp.RegisterVariableCallback(variable.variableName, onChangeDelegate);
        }
Ejemplo n.º 59
0
        public override void OnStart(PartModule.StartState state)
        {
            DragManager = part.gameObject.GetComponent<DragManager>();

            if (DragManager == null) {
                DragManager = part.gameObject.AddComponent<DragManager>();
                DragManager.SetPart(part);
            }

            gearHandler.Start(ID,part);
            anim = part.FindModelAnimators(AnimationName)[0];
            animState = anim[AnimationName];
            animState.wrapMode = WrapMode.Clamp;

            if (FixAnimLayers) {
                int i = 0;
                foreach (AnimationState s in anim)
                    s.layer = i++;
            }

            part.PhysicsSignificance = 1;

            Transform bounds = part.FindModelTransform("Bounds");
            if (bounds != null)
                UnityEngine.Object.DestroyImmediate(bounds.gameObject);

            gearState = Deployed ? ModuleLandingGear.GearStates.DEPLOYED : ModuleLandingGear.GearStates.RETRACTED;

            animState.normalizedTime = Deployed ? 1 : 0;

            animState.speed = Deployed ? Mathf.Abs(animState.speed) : -Mathf.Abs(animState.speed);

            UpdateDrag();

            anim.Play(AnimationName);

            HashSet<WheelCollider> tmp = new HashSet<WheelCollider>();
            part.transform.FindWheelColliders(ref tmp);
            foreach (WheelCollider w in tmp)
                w.enabled = true;
        }