Inheritance: Component
Example #1
1
 void Start()
 {
     player = GameObject.FindWithTag ("Player").transform;
     pHealth = player.GetComponent<PlayerHealth> ();
     eHealth = GetComponent<EnemyHealth> ();
     Rigidbody = GetComponent<Rigidbody> ();
 }
Example #2
1
        // Rotate this target towards a position
        public void RotateTo(Vector3 position)
        {
            if (pivot == null) return;

            if (pivot != lastPivot) {
                defaultLocalRotation = pivot.localRotation;
                lastPivot = pivot;
            }

            // Rotate to the default local rotation
            pivot.localRotation = defaultLocalRotation;

            // Twisting around the twist axis
            if (twistWeight > 0f) {
                Vector3 targetTangent = transform.position - pivot.position;
                Vector3 n = pivot.rotation * twistAxis;
                Vector3 normal = n;
                Vector3.OrthoNormalize(ref normal, ref targetTangent);

                normal = n;
                Vector3 direction = position - pivot.position;
                Vector3.OrthoNormalize(ref normal, ref direction);

                Quaternion q = QuaTools.FromToAroundAxis(targetTangent, direction, n);
                pivot.rotation = Quaternion.Lerp(Quaternion.identity, q, twistWeight) * pivot.rotation;
            }

            // Swinging freely
            if (swingWeight > 0f) {
                Quaternion s = Quaternion.FromToRotation(transform.position - pivot.position, position - pivot.position);
                pivot.rotation = Quaternion.Lerp(Quaternion.identity, s, swingWeight) * pivot.rotation;
            }
        }
        public static GameObject Create(GameObject prefab, Transform parent)
        {
            if (parent == null) return Create(prefab);

            prefab.AddOrGetComponent<EarlyParentSetter>().Init(parent);
            return UnityEngine.Object.Instantiate(prefab, parent.position, parent.rotation) as GameObject;
        }
 public static void Log(string message, Transform context, bool logInEditMode = false)
 {
     if (!logInEditMode && !Application.isPlaying) return;
     if (logged) return;
     Debug.LogWarning(message, context);
     logged = true;
 }
Example #5
0
        public static void move(Transform transform)
        {
            var velocity = new Vector3();
            var movement = new Vector3();

            var inAirMultiplier = 0.25f;
            var speed = 17f;

            if (Input.GetKey(KeyCode.W) || Input.GetKey(KeyCode.A) || Input.GetKey(KeyCode.S) || Input.GetKey(KeyCode.D))
            {
                var z = Input.GetKey(KeyCode.W) ? 1.0f : 0;
                z = Input.GetKey(KeyCode.S) ? -1.0f : z;

                var x = Input.GetKey(KeyCode.D) ? 1.0f : 0;
                x = Input.GetKey(KeyCode.A) ? -1.0f : x;

                movement.z = speed * z;
                movement.x = speed * x;

                //face movement dir
                Vector3 keyboardPosition = new Vector3(x, 0, z);
                transform.LookAt(transform.position + keyboardPosition);
            }

            velocity.y += Physics.gravity.y * Time.deltaTime;
            movement.x *= inAirMultiplier;
            movement.z *= inAirMultiplier;

            movement += velocity;
            movement += Physics.gravity;
            movement *= Time.deltaTime;
            transform.GetComponent<CharacterController>().Move(movement);
        }
 internal static void CalculateAnchorSnapValues(Transform parentSpace, Transform self, RectTransform gui, int minmaxX, int minmaxY)
 {
   for (int mainAxis = 0; mainAxis < 2; ++mainAxis)
   {
     RectTransformSnapping.s_SnapGuides[mainAxis].Clear();
     parentSpace.GetComponent<RectTransform>().GetWorldCorners(RectTransformSnapping.s_Corners);
     for (int index = 0; index < RectTransformSnapping.kSidesAndMiddle.Length; ++index)
     {
       float alongMainAxis = RectTransformSnapping.kSidesAndMiddle[index];
       RectTransformSnapping.s_SnapGuides[mainAxis].AddGuide(new SnapGuide(alongMainAxis, new Vector3[2]
       {
         RectTransformSnapping.GetInterpolatedCorner(RectTransformSnapping.s_Corners, mainAxis, alongMainAxis, 0.0f),
         RectTransformSnapping.GetInterpolatedCorner(RectTransformSnapping.s_Corners, mainAxis, alongMainAxis, 1f)
       }));
     }
     foreach (Transform transform in parentSpace)
     {
       if (!((Object) transform == (Object) self))
       {
         RectTransform component = transform.GetComponent<RectTransform>();
         if ((bool) ((Object) component))
         {
           RectTransformSnapping.s_SnapGuides[mainAxis].AddGuide(new SnapGuide(component.anchorMin[mainAxis], new Vector3[0]));
           RectTransformSnapping.s_SnapGuides[mainAxis].AddGuide(new SnapGuide(component.anchorMax[mainAxis], new Vector3[0]));
         }
       }
     }
     int num = mainAxis != 0 ? minmaxY : minmaxX;
     if (num == 0)
       RectTransformSnapping.s_SnapGuides[mainAxis].AddGuide(new SnapGuide(gui.anchorMax[mainAxis], new Vector3[0]));
     if (num == 1)
       RectTransformSnapping.s_SnapGuides[mainAxis].AddGuide(new SnapGuide(gui.anchorMin[mainAxis], new Vector3[0]));
   }
 }
 private static void ExportAnimations(Transform transform, BabylonIAnimatable animatable)
 {
     var animator = transform.gameObject.GetComponent<Animator>();
     if (animator != null)
     {
         AnimatorController ac = animator.runtimeAnimatorController as AnimatorController;
         if (ac == null)
         {
             return;
         }
         var layer = ac.layers[0];
         if (layer == null)
         {
             return;
         }
         AnimatorStateMachine sm = layer.stateMachine;
         if (sm.states.Length > 0)
         {
             var state = sm.states[0].state; // We only support the first one
             AnimationClip clip = state.motion as AnimationClip;
             if (clip != null)
             {
                 ExportAnimationClip(clip, true, animatable);
             }
         }
     }
     else
     {
         var animation = transform.gameObject.GetComponent<Animation>();
         if (animation != null && animation.clip != null)
         {
             ExportAnimationClip(animation.clip, animation.playAutomatically, animatable);
         }
     }
 }
 public static void ActiveRecursively(Transform obj, bool active)
 {
     foreach (Transform child in obj) {
         InfiniteRunnerStarterPackUtility.ActiveRecursively(child, active);
     }
     obj.gameObject.SetActive(active);
 }
 public override void OnStart(PartModule.StartState state)
 {
     BaseTransform = this.part.transform.FindChild("model").FindChild("Kethane Small Miner").FindChild("Main Box");
     Cyl3Transform = BaseTransform.FindChild("1 Cyl");
     Cyl2Transform = Cyl3Transform.FindChild("2 Cyl");
     Cyl1Transform = Cyl2Transform.FindChild("3 Cyl");
 }
Example #10
0
 public MapData(Transform parent, string mapName, int width, int height)
 {
     this.ParentTransform = parent;
     this.Name = mapName;
     this.Width = width;
     this.Height = height;
 }
Example #11
0
 protected override void Initialize()
 {
     Player.Player temp = FindObjectOfType<Player.Player>();
     if (temp == null)
         Destroy(this.gameObject);
     player = temp.gameObject.transform;
 }
Example #12
0
        /*
         * Constructor
         * Input: The owning part's transform.
         * Purpose: This constructor will start up the owning part's camera object. The idea behind this
         * was to allow for multiple telescopes on the same craft.
         */
        public CactEyeCamera(Transform Position)
        {
            this.CameraTransform = Position;

            CameraWidth = (int)(Screen.width*0.4f);
            CameraHeight = (int)(Screen.height*0.4f);

            ScopeRenderTexture = new RenderTexture(CameraWidth, CameraHeight, 24);
            ScopeRenderTexture.Create();

            FullResolutionTexture = new RenderTexture(Screen.width, Screen.height, 24);
            FullResolutionTexture.Create();

            ScopeTexture2D = new Texture2D(CameraWidth, CameraHeight);
            FullTexture2D = new Texture2D(Screen.width, Screen.height);

            CameraSetup(0, "GalaxyCamera"); //As of KSP 1.0, the GalaxyCamera object was added. Thanks to MOARDv for figuring this one out.
            CameraSetup(1, "Camera ScaledSpace");
            CameraSetup(2, "Camera 01");
            CameraSetup(3, "Camera 00");
            CameraSetup(4, "Camera VE Underlay");
            CameraSetup(5, "Camera VE Overlay");

            skyboxRenderers = (from Renderer r in (FindObjectsOfType(typeof(Renderer)) as IEnumerable<Renderer>) where (r.name == "XP" || r.name == "XN" || r.name == "YP" || r.name == "YN" || r.name == "ZP" || r.name == "ZN") select r).ToArray<Renderer>();
            if (skyboxRenderers == null)
            {
                Debug.Log("CactEye 2: Logical Error: skyboxRenderers is null!");
            }

            scaledSpaceFaders = FindObjectsOfType(typeof(ScaledSpaceFader)) as ScaledSpaceFader[];
            if (scaledSpaceFaders == null)
            {
                Debug.Log("CactEye 2: Logical Error: scaledSpaceFaders is null!");
            }
        }
Example #13
0
 private void Start()
 {
     m_moveEnabled = true;
     // get the third person character ( this should never be null due to require component )
     m_character = GetComponent<ThirdPersonCharacter>();
     player = GameObject.FindGameObjectWithTag("Player").transform;
 }
Example #14
0
        public override Status Update () {
            // Get the transform1
            if (m_Transform1 == null || m_Transform1.gameObject != gameObject1.Value)
                m_Transform1 = gameObject1.Value != null ? gameObject1.Value.transform : null;

            // Get the transform2
            if (m_Transform2 == null || m_Transform2.gameObject != gameObject2.Value)
                m_Transform2 = gameObject2.Value != null ? gameObject2.Value.transform : null;

            // Validate members
            if (m_Transform1 == null || m_Transform2 == null)
                return Status.Error;

            // Store distance
            if (relativeTo == Space.World)
                storeDistance.Value = m_Transform1.position - m_Transform2.position;
            else
                storeDistance.Value = m_Transform1.localPosition - m_Transform2.localPosition;

            storeX.Value = storeDistance.Value.x;
            storeY.Value = storeDistance.Value.y;
            storeZ.Value = storeDistance.Value.z;

            return Status.Success;
        }
Example #15
0
 public void setBounds(Transform leftBound, Transform rightBound, Transform upperBound, Transform lowerBound)
 {
     this.leftBound = leftBound;
     this.rightBound = rightBound;
     this.upperBound = upperBound;
     this.lowerBound = lowerBound;
 }
Example #16
0
        public void SetLookAt(Transform lookAtObject, LookAtAxis axis)
        {
            if (m_transformComponent == null)
                m_transformComponent = this.GetComponent<Transform>();

            if (m_transformComponent != null)
            {
                Vector3 currentLookAtAxis = Vector3.zero;
                switch (axis)
                {
                case LookAtAxis.Up:
                    currentLookAtAxis = m_transformComponent.up;
                    break;
                case LookAtAxis.Down:
                    currentLookAtAxis = -m_transformComponent.up;
                    break;
                case LookAtAxis.Right:
                    currentLookAtAxis = m_transformComponent.right;
                    break;
                case LookAtAxis.Left:
                    currentLookAtAxis = -m_transformComponent.right;
                    break;
                case LookAtAxis.Forward:
                    currentLookAtAxis = m_transformComponent.forward;
                    break;
                }

                m_transformComponent.LookAt(LookAtObject, currentLookAtAxis);
            }
        }
Example #17
0
        public override Status Update () {
            // Get the point transform
            if (m_PointTransform == null || m_PointTransform.gameObject != point.Value)
                m_PointTransform = point.Value != null ? point.Value.transform : null;

            // Validate members
            if (m_PointTransform == null)
                return Status.Error;

            // OverlapPoint
            Collider2D collider2D = Physics2D.OverlapPoint(m_PointTransform.position, layers);

            // Is there a collider2D inside the rectangle?
            if (collider2D != null) {
                // Store result
                storeGameObject.Value = collider2D.gameObject;

                // Tick child?
                if (child != null) {
                    child.OnTick();
                    return child.status;
                }
                else
                    return Status.Success;
            }
            else {
                // Store result
                storeGameObject.Value = null;
                return Status.Failure;
            }
        }
Example #18
0
 public AnimatedNode(AttachNode node, Transform node_transform, Part part)
 {
     this.node = node;
     this.part = part;
     nT        = node_transform;
     pT        = part.partTransform;
 }
 /// <inheritdoc />
 public void ApplyTransform(Transform target)
 {
     if (DeltaPosition != Vector3.zero) target.position += DeltaPosition;
     if (!Mathf.Approximately(DeltaRotation, 0f))
         target.rotation = Quaternion.Euler(0, 0, DeltaRotation)*target.rotation;
     if (!Mathf.Approximately(DeltaScale, 1f)) target.localScale *= DeltaScale;
 }
Example #20
0
        /// <summary>
        /// Initializes a new instance of the <see cref="Trackar.WheelDummy"/> class.
        /// </summary>
        /// <param name="col">Col.</param>
        /// <param name="joint">Joint.</param>
        /// <param name="model">Model.</param>
        /// <param name="config">WheelDummyConfigContainer.</param>
        public WheelDummy(WheelCollider col, Transform joint, GameObject model, WheelDummyConfigContainer config)
        {
            if (col == null)
            {
                Debuggar.Error ("WheelDummy: Attempted spawn with null WheelCollider");
                col = new WheelCollider ();
            }
            if(joint == null)
            {
                Debuggar.Error ("WheelDummy: Attempted spawn with null Joint");
                joint = new GameObject ().transform; // lol gg unity
            }
            if(model == null)
            {
                Debuggar.Error ("WheelDummy: Attempted spawn with null Model");
                model = new GameObject ();
            }
            if(config == null)
            {
                Debuggar.Error ("WheelDummy: Attempted spawn with null WheelDummyConfigContainer");
                config = new WheelDummyConfigContainer ();
            }

            Collider = col;
            Joint = joint;
            WheelModel = model;
            Susp = config.SuspConfig;

            Collider.enabled = true;
            Collider.brakeTorque = config.RollingResistance;
            Debuggar.Message ("WheelDummy: brakeTorque is " + Collider.brakeTorque.ToString () + " RollingResistance is " + config.RollingResistance.ToString ());

            Debuggar.Message ("WheelDummy: Spawned");
        }
 public void WaterTileBeingRendered(Transform tr, Camera currentCam)
 {
     if (currentCam && edgeBlend)
     {
         currentCam.depthTextureMode |= DepthTextureMode.Depth;
     }
 }
Example #22
0
 private static void GetDirectParticleSystemChildrenRecursive(Transform transform, List<ParticleSystem> particleSystems)
 {
     IEnumerator enumerator = transform.GetEnumerator();
     try
     {
         while (enumerator.MoveNext())
         {
             Transform current = (Transform) enumerator.Current;
             ParticleSystem component = current.gameObject.GetComponent<ParticleSystem>();
             if (component != null)
             {
                 particleSystems.Add(component);
                 GetDirectParticleSystemChildrenRecursive(current, particleSystems);
             }
         }
     }
     finally
     {
         IDisposable disposable = enumerator as IDisposable;
         if (disposable == null)
         {
         }
         disposable.Dispose();
     }
 }
        public static GameObject Create(GameObject prefab, Vector3 pos, Quaternion rot, Transform parent)
        {
            if (parent == null) return Create(prefab, pos, rot);

            prefab.AddOrGetComponent<EarlyParentSetter>().Init(parent);
            return UnityEngine.Object.Instantiate(prefab, pos, rot) as GameObject;
        }
 private void TryActions(SetQuestStateAction[] actions, Transform actor)
 {
     if (actions == null) return;
     foreach (SetQuestStateAction action in actions) {
         if (action != null && action.condition != null && action.condition.IsTrue(actor)) DoAction(action, actor);
     }
 }
 public void DoAction(SetQuestStateAction action, Transform actor)
 {
     if ((action != null) && !string.IsNullOrEmpty(action.questName)) {
         QuestLog.SetQuestState(action.questName, action.questState);
         if (!string.IsNullOrEmpty(action.alertMessage)) DialogueManager.ShowAlert(action.alertMessage);
     }
 }
Example #26
0
        public override Status Update () {
            // Get the transform
            if (m_Transform == null || m_Transform.gameObject != gameObject.Value)
                m_Transform = gameObject.Value != null ? gameObject.Value.transform : null;

            // Validate members?
            if  (m_Transform == null)
                return Status.Error;

            // Get the desiredTranslation
            Vector3 desiredTranslation =  !translation.isNone ? translation.Value : Vector3.zero;

            // Override values?
            if (!x.isNone) desiredTranslation.x = x.Value;
            if (!y.isNone) desiredTranslation.y = y.Value;
            if (!z.isNone) desiredTranslation.z = z.Value;

            // Translate per second?
            if (perSecond)
                m_Transform.Translate(desiredTranslation * this.owner.deltaTime, relativeTo);
            else
                m_Transform.Translate(desiredTranslation, relativeTo);

            return Status.Success;
        }
		void CaptureTransform(Transform transform, string path, AnimationClip clip)
		{
			path += transform.name;

			//Debug.Log(path);

			if (position.Value)
			{
				CapturePosition(transform, path, clip);
			}

			if (rotation.Value)
			{
				CaptureRotation(transform, path, clip);
			}

			if (scale.Value)
			{
				CaptureScale(transform, path, clip);
			}

			foreach (Transform child in transform)
			{
				CaptureTransform(child, path + "/", clip);
			}
		}
Example #28
0
        public override void OnEnter()
        {
            // get the animator component
            var go = Fsm.GetOwnerDefaultTarget(gameObject);

            if (go==null)
            {
                Finish();
                return;
            }

            _animator = go.GetComponent<Animator>();

            if (_animator==null)
            {
                Finish();
                return;
            }

            GameObject _goal = goal.Value;
            if (_goal!=null)
            {
                _transform = _goal.transform;
            }

            DoGetIKGoal();

            if (!everyFrame)
            {
                Finish();
            }
        }
 private void SetStatsValue(Transform t, float value)
 {
     RectTransform r = t.GetComponent<RectTransform>();
     var size = r.rect.size.x - r.offsetMax.x; // + car value -
     var val = size - ((size / 10) * value);
     r.offsetMax = new Vector2(-val, r.offsetMax.y);
 }
Example #30
0
 public WidgetData(string layer, string name, Transform widget, string type)
 {
     this.layerName = layer;
     this.widgetName = name;
     this.widgetObject = widget;
     this.widgetType = type;
 }
    static int GetEnumerator(IntPtr L)
    {
#if UNITY_EDITOR
        ToluaProfiler.AddCallRecord("UnityEngine.Transform.GetEnumerator");
#endif
        try
        {
            ToLua.CheckArgsCount(L, 1);
            UnityEngine.Transform          obj = (UnityEngine.Transform)ToLua.CheckObject <UnityEngine.Transform>(L, 1);
            System.Collections.IEnumerator o   = obj.GetEnumerator();
            ToLua.Push(L, o);
            return(1);
        }
        catch (Exception e)
        {
            return(LuaDLL.toluaL_exception(L, e));
        }
    }
Example #32
0
 static int DOTo(IntPtr L)
 {
     try
     {
         ToLua.CheckArgsCount(L, 5);
         UnityEngine.Transform arg0 = (UnityEngine.Transform)ToLua.CheckObject <UnityEngine.Transform>(L, 1);
         UnityEngine.Transform arg1 = (UnityEngine.Transform)ToLua.CheckObject <UnityEngine.Transform>(L, 2);
         float arg2 = (float)LuaDLL.luaL_checknumber(L, 3);
         float arg3 = (float)LuaDLL.luaL_checknumber(L, 4);
         float arg4 = (float)LuaDLL.luaL_checknumber(L, 5);
         LuaFramework.Util.DOTo(arg0, arg1, arg2, arg3, arg4);
         return(0);
     }
     catch (Exception e)
     {
         return(LuaDLL.toluaL_exception(L, e));
     }
 }
    static int GetSiblingIndex(IntPtr L)
    {
#if UNITY_EDITOR
        ToluaProfiler.AddCallRecord("UnityEngine.Transform.GetSiblingIndex");
#endif
        try
        {
            ToLua.CheckArgsCount(L, 1);
            UnityEngine.Transform obj = (UnityEngine.Transform)ToLua.CheckObject <UnityEngine.Transform>(L, 1);
            int o = obj.GetSiblingIndex();
            LuaDLL.lua_pushinteger(L, o);
            return(1);
        }
        catch (Exception e)
        {
            return(LuaDLL.toluaL_exception(L, e));
        }
    }
 static public int RotateAround(IntPtr l)
 {
     try {
         UnityEngine.Transform self = (UnityEngine.Transform)checkSelf(l);
         UnityEngine.Vector3   a1;
         checkType(l, 2, out a1);
         UnityEngine.Vector3 a2;
         checkType(l, 3, out a2);
         System.Single a3;
         checkType(l, 4, out a3);
         self.RotateAround(a1, a2, a3);
         pushValue(l, true);
         return(1);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
Example #35
0
 static int GetResourcesPrefabByIdentification(IntPtr L)
 {
     try
     {
         ToLua.CheckArgsCount(L, 5);
         GameResFactory        obj  = (GameResFactory)ToLua.CheckObject(L, 1, typeof(GameResFactory));
         string                arg0 = ToLua.CheckString(L, 2);
         UnityEngine.Transform arg1 = (UnityEngine.Transform)ToLua.CheckUnityObject(L, 3, typeof(UnityEngine.Transform));
         LuaFunction           arg2 = ToLua.CheckLuaFunction(L, 4);
         object                arg3 = ToLua.ToVarObject(L, 5);
         obj.GetResourcesPrefabByIdentification(arg0, arg1, arg2, arg3);
         return(0);
     }
     catch (Exception e)
     {
         return(LuaDLL.toluaL_exception(L, e));
     }
 }
    static int SetSiblingIndex(IntPtr L)
    {
#if UNITY_EDITOR
        ToluaProfiler.AddCallRecord("UnityEngine.Transform.SetSiblingIndex");
#endif
        try
        {
            ToLua.CheckArgsCount(L, 2);
            UnityEngine.Transform obj = (UnityEngine.Transform)ToLua.CheckObject <UnityEngine.Transform>(L, 1);
            int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
            obj.SetSiblingIndex(arg0);
            return(0);
        }
        catch (Exception e)
        {
            return(LuaDLL.toluaL_exception(L, e));
        }
    }
Example #37
0
    static int SetTransParent(IntPtr L)
    {
#if UNITY_EDITOR
        ToluaProfiler.AddCallRecord("Framework.LuaHelper.SetTransParent");
#endif
        try
        {
            ToLua.CheckArgsCount(L, 2);
            UnityEngine.Transform arg0 = (UnityEngine.Transform)ToLua.CheckObject <UnityEngine.Transform>(L, 1);
            UnityEngine.Transform arg1 = (UnityEngine.Transform)ToLua.CheckObject <UnityEngine.Transform>(L, 2);
            Framework.LuaHelper.SetTransParent(arg0, arg1);
            return(0);
        }
        catch (Exception e)
        {
            return(LuaDLL.toluaL_exception(L, e));
        }
    }
 static int ChangeTextColor(IntPtr L)
 {
     try
     {
         ToLua.CheckArgsCount(L, 5);
         UnityEngine.Transform arg0 = (UnityEngine.Transform)ToLua.CheckUnityObject(L, 1, typeof(UnityEngine.Transform));
         float arg1 = (float)LuaDLL.luaL_checknumber(L, 2);
         float arg2 = (float)LuaDLL.luaL_checknumber(L, 3);
         float arg3 = (float)LuaDLL.luaL_checknumber(L, 4);
         float arg4 = (float)LuaDLL.luaL_checknumber(L, 5);
         LuaFramework.LuaHelper.ChangeTextColor(arg0, arg1, arg2, arg3, arg4);
         return(0);
     }
     catch (Exception e)
     {
         return(LuaDLL.toluaL_exception(L, e));
     }
 }
Example #39
0
    static int AddMixingTransform(IntPtr L)
    {
        int count = LuaDLL.lua_gettop(L);

        if (count == 2 && ToLua.CheckTypes(L, 1, typeof(UnityEngine.AnimationState), typeof(UnityEngine.Transform)))
        {
            UnityEngine.AnimationState obj  = (UnityEngine.AnimationState)ToLua.ToObject(L, 1);
            UnityEngine.Transform      arg0 = (UnityEngine.Transform)ToLua.ToObject(L, 2);

            try
            {
                obj.AddMixingTransform(arg0);
            }
            catch (Exception e)
            {
                return(LuaDLL.toluaL_exception(L, e));
            }

            return(0);
        }
        else if (count == 3 && ToLua.CheckTypes(L, 1, typeof(UnityEngine.AnimationState), typeof(UnityEngine.Transform), typeof(bool)))
        {
            UnityEngine.AnimationState obj  = (UnityEngine.AnimationState)ToLua.ToObject(L, 1);
            UnityEngine.Transform      arg0 = (UnityEngine.Transform)ToLua.ToObject(L, 2);
            bool arg1 = LuaDLL.lua_toboolean(L, 3);

            try
            {
                obj.AddMixingTransform(arg0, arg1);
            }
            catch (Exception e)
            {
                return(LuaDLL.toluaL_exception(L, e));
            }

            return(0);
        }
        else
        {
            LuaDLL.luaL_error(L, "invalid arguments to method: UnityEngine.AnimationState.AddMixingTransform");
        }

        return(0);
    }
Example #40
0
    // Use this for initialization
    void Awake()
    {
        try
        {
            m_EventList.Clear();
            object obj = null;
            obj = ArkCrossEngine.LogicSystem.EventChannelForGfx.Subscribe("ge_ui_unsubscribe", "ui", UnSubscribe);
            if (obj != null)
            {
                m_EventList.Add(obj);
            }
            obj = ArkCrossEngine.LogicSystem.EventChannelForGfx.Subscribe("ge_role_dead", "ui", RoleDead);
            if (obj != null)
            {
                m_EventList.Add(obj);
            }
            obj = ArkCrossEngine.LogicSystem.EventChannelForGfx.Subscribe("ge_on_role_relive", "ui", OnRoleRelive);
            if (obj != null)
            {
                m_EventList.Add(obj);
            }
            obj = ArkCrossEngine.LogicSystem.EventChannelForGfx.Subscribe("ge_mpve_role_dead", "ui", MpveRoleDead);
            if (obj != null)
            {
                m_EventList.Add(obj);
            }

            UnityEngine.Transform tf = transform.Find("Time/Label");
            if (tf != null)
            {
                UILabel ul = tf.gameObject.GetComponent <UILabel>();
                if (ul != null)
                {
                    timelabel = ul;
                    ul.text   = "16:00";
                }
            }
            time = 0.0f;
        }
        catch (System.Exception ex)
        {
            ArkCrossEngine.LogicSystem.LogErrorFromGfx("Exception {0}\n{1}", ex.Message, ex.StackTrace);
        }
    }
Example #41
0
    static int FitOnScreen(IntPtr L)
    {
        try
        {
            int count = LuaDLL.lua_gettop(L);

            if (count == 3 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.Camera), typeof(UnityEngine.Transform), typeof(UnityEngine.Vector3)))
            {
                UnityEngine.Camera    arg0 = (UnityEngine.Camera)ToLua.ToObject(L, 1);
                UnityEngine.Transform arg1 = (UnityEngine.Transform)ToLua.ToObject(L, 2);
                UnityEngine.Vector3   arg2 = ToLua.ToVector3(L, 3);
                NGUITools.FitOnScreen(arg0, arg1, arg2);
                return(0);
            }
            else if (count == 4 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.Camera), typeof(UnityEngine.Transform), typeof(UnityEngine.Transform), typeof(UnityEngine.Vector3)))
            {
                UnityEngine.Camera    arg0 = (UnityEngine.Camera)ToLua.ToObject(L, 1);
                UnityEngine.Transform arg1 = (UnityEngine.Transform)ToLua.ToObject(L, 2);
                UnityEngine.Transform arg2 = (UnityEngine.Transform)ToLua.ToObject(L, 3);
                UnityEngine.Vector3   arg3 = ToLua.ToVector3(L, 4);
                NGUITools.FitOnScreen(arg0, arg1, arg2, arg3);
                return(0);
            }
            else if (count == 5 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.Camera), typeof(UnityEngine.Transform), typeof(UnityEngine.Transform), typeof(UnityEngine.Vector3), typeof(LuaInterface.LuaOut <UnityEngine.Bounds>)))
            {
                UnityEngine.Camera    arg0 = (UnityEngine.Camera)ToLua.ToObject(L, 1);
                UnityEngine.Transform arg1 = (UnityEngine.Transform)ToLua.ToObject(L, 2);
                UnityEngine.Transform arg2 = (UnityEngine.Transform)ToLua.ToObject(L, 3);
                UnityEngine.Vector3   arg3 = ToLua.ToVector3(L, 4);
                UnityEngine.Bounds    arg4;
                NGUITools.FitOnScreen(arg0, arg1, arg2, arg3, out arg4);
                ToLua.Push(L, arg4);
                return(1);
            }
            else
            {
                return(LuaDLL.luaL_throw(L, "invalid arguments to method: NGUITools.FitOnScreen"));
            }
        }
        catch (Exception e)
        {
            return(LuaDLL.toluaL_exception(L, e));
        }
    }
    static int Create(IntPtr L)
    {
        try
        {
            int count = LuaDLL.lua_gettop(L);

            if (count == 1)
            {
                SWS.PathManager obj = (SWS.PathManager)ToLua.CheckObject <SWS.PathManager>(L, 1);
                obj.Create();
                return(0);
            }
            else if (count == 2 && TypeChecker.CheckTypes <UnityEngine.Transform[]>(L, 2))
            {
                SWS.PathManager         obj  = (SWS.PathManager)ToLua.CheckObject <SWS.PathManager>(L, 1);
                UnityEngine.Transform[] arg0 = ToLua.ToObjectArray <UnityEngine.Transform>(L, 2);
                obj.Create(arg0);
                return(0);
            }
            else if (count == 2 && TypeChecker.CheckTypes <UnityEngine.Transform>(L, 2))
            {
                SWS.PathManager       obj  = (SWS.PathManager)ToLua.CheckObject <SWS.PathManager>(L, 1);
                UnityEngine.Transform arg0 = (UnityEngine.Transform)ToLua.ToObject(L, 2);
                obj.Create(arg0);
                return(0);
            }
            else if (count == 3)
            {
                SWS.PathManager         obj  = (SWS.PathManager)ToLua.CheckObject <SWS.PathManager>(L, 1);
                UnityEngine.Transform[] arg0 = ToLua.CheckObjectArray <UnityEngine.Transform>(L, 2);
                bool arg1 = LuaDLL.luaL_checkboolean(L, 3);
                obj.Create(arg0, arg1);
                return(0);
            }
            else
            {
                return(LuaDLL.luaL_throw(L, "invalid arguments to method: SWS.PathManager.Create"));
            }
        }
        catch (Exception e)
        {
            return(LuaDLL.toluaL_exception(L, e));
        }
    }
Example #43
0
 static int CreateEntry(IntPtr L)
 {
     try
     {
         ToLua.CheckArgsCount(L, 5);
         Nova.IAnimationProperty arg0 = (Nova.IAnimationProperty)ToLua.CheckObject <Nova.IAnimationProperty>(L, 1);
         float arg1 = (float)LuaDLL.luaL_checknumber(L, 2);
         Nova.AnimationEntry.EasingFunction arg2 = (Nova.AnimationEntry.EasingFunction)ToLua.CheckDelegate <Nova.AnimationEntry.EasingFunction>(L, 3);
         int arg3 = (int)LuaDLL.luaL_checknumber(L, 4);
         UnityEngine.Transform arg4 = (UnityEngine.Transform)ToLua.CheckObject <UnityEngine.Transform>(L, 5);
         Nova.AnimationEntry   o    = Nova.AnimationEntry.CreateEntry(arg0, arg1, arg2, arg3, arg4);
         ToLua.Push(L, o);
         return(1);
     }
     catch (Exception e)
     {
         return(LuaDLL.toluaL_exception(L, e));
     }
 }
 static int Instantiate9(IntPtr L)
 {
     try
     {
         ToLua.CheckArgsCount(L, 5);
         UnityEngine.Object     arg0 = (UnityEngine.Object)ToLua.CheckObject <UnityEngine.Object>(L, 1);
         UnityEngine.Vector3    arg1 = ToLua.ToVector3(L, 2);
         UnityEngine.Quaternion arg2 = ToLua.ToQuaternion(L, 3);
         UnityEngine.Transform  arg3 = (UnityEngine.Transform)ToLua.CheckObject <UnityEngine.Transform>(L, 4);
         System.Type            arg4 = ToLua.CheckMonoType(L, 5);
         var o = Generic.ObjectExternions.Instantiate9(arg0, arg1, arg2, arg3, arg4);
         ToLua.Push(L, o);
         return(1);
     }
     catch (Exception e)
     {
         return(LuaDLL.toluaL_exception(L, e));
     }
 }
Example #45
0
 static int AddItem(IntPtr L)
 {
     try
     {
         ToLua.CheckArgsCount(L, 6);
         FirClient.Component.CObjectFollow obj = (FirClient.Component.CObjectFollow)ToLua.CheckObject <FirClient.Component.CObjectFollow>(L, 1);
         string arg0 = ToLua.CheckString(L, 2);
         FirClient.Component.FollowType arg1 = (FirClient.Component.FollowType)ToLua.CheckObject(L, 3, typeof(FirClient.Component.FollowType));
         float arg2 = (float)LuaDLL.luaL_checknumber(L, 4);
         UnityEngine.Transform arg3 = (UnityEngine.Transform)ToLua.CheckObject <UnityEngine.Transform>(L, 5);
         UnityEngine.Transform arg4 = (UnityEngine.Transform)ToLua.CheckObject <UnityEngine.Transform>(L, 6);
         obj.AddItem(arg0, arg1, arg2, arg3, arg4);
         return(0);
     }
     catch (Exception e)
     {
         return(LuaDLL.toluaL_exception(L, e));
     }
 }
 static public int InverseTransformPoint__Single__Single__Single(IntPtr l)
 {
     try {
         UnityEngine.Transform self = (UnityEngine.Transform)checkSelf(l);
         System.Single         a1;
         checkType(l, 2, out a1);
         System.Single a2;
         checkType(l, 3, out a2);
         System.Single a3;
         checkType(l, 4, out a3);
         var ret = self.InverseTransformPoint(a1, a2, a3);
         pushValue(l, true);
         pushValue(l, ret);
         return(2);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
Example #47
0
 static int DOPunchScale(IntPtr L)
 {
     try
     {
         ToLua.CheckArgsCount(L, 5);
         UnityEngine.Transform arg0 = (UnityEngine.Transform)ToLua.CheckUnityObject(L, 1, typeof(UnityEngine.Transform));
         UnityEngine.Vector3   arg1 = ToLua.ToVector3(L, 2);
         float arg2            = (float)LuaDLL.luaL_checknumber(L, 3);
         int   arg3            = (int)LuaDLL.luaL_checknumber(L, 4);
         float arg4            = (float)LuaDLL.luaL_checknumber(L, 5);
         DG.Tweening.Tweener o = TweenUtils.DOPunchScale(arg0, arg1, arg2, arg3, arg4);
         ToLua.PushObject(L, o);
         return(1);
     }
     catch (Exception e)
     {
         return(LuaDLL.toluaL_exception(L, e));
     }
 }
    static int IsChildOf(IntPtr L)
    {
#if UNITY_EDITOR
        ToluaProfiler.AddCallRecord("UnityEngine.Transform.IsChildOf");
#endif
        try
        {
            ToLua.CheckArgsCount(L, 2);
            UnityEngine.Transform obj  = (UnityEngine.Transform)ToLua.CheckObject <UnityEngine.Transform>(L, 1);
            UnityEngine.Transform arg0 = (UnityEngine.Transform)ToLua.CheckObject <UnityEngine.Transform>(L, 2);
            bool o = obj.IsChildOf(arg0);
            LuaDLL.lua_pushboolean(L, o);
            return(1);
        }
        catch (Exception e)
        {
            return(LuaDLL.toluaL_exception(L, e));
        }
    }
    static int Find(IntPtr L)
    {
#if UNITY_EDITOR
        ToluaProfiler.AddCallRecord("UnityEngine.Transform.Find");
#endif
        try
        {
            ToLua.CheckArgsCount(L, 2);
            UnityEngine.Transform obj = (UnityEngine.Transform)ToLua.CheckObject <UnityEngine.Transform>(L, 1);
            string arg0             = ToLua.CheckString(L, 2);
            UnityEngine.Transform o = obj.Find(arg0);
            ToLua.Push(L, o);
            return(1);
        }
        catch (Exception e)
        {
            return(LuaDLL.toluaL_exception(L, e));
        }
    }
    static int SetPositionAndRotation(IntPtr L)
    {
#if UNITY_EDITOR
        ToluaProfiler.AddCallRecord("UnityEngine.Transform.SetPositionAndRotation");
#endif
        try
        {
            ToLua.CheckArgsCount(L, 3);
            UnityEngine.Transform  obj  = (UnityEngine.Transform)ToLua.CheckObject <UnityEngine.Transform>(L, 1);
            UnityEngine.Vector3    arg0 = ToLua.ToVector3(L, 2);
            UnityEngine.Quaternion arg1 = ToLua.ToQuaternion(L, 3);
            obj.SetPositionAndRotation(arg0, arg1);
            return(0);
        }
        catch (Exception e)
        {
            return(LuaDLL.toluaL_exception(L, e));
        }
    }
    static int GetChild(IntPtr L)
    {
#if UNITY_EDITOR
        ToluaProfiler.AddCallRecord("UnityEngine.Transform.GetChild");
#endif
        try
        {
            ToLua.CheckArgsCount(L, 2);
            UnityEngine.Transform obj = (UnityEngine.Transform)ToLua.CheckObject <UnityEngine.Transform>(L, 1);
            int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
            UnityEngine.Transform o = obj.GetChild(arg0);
            ToLua.Push(L, o);
            return(1);
        }
        catch (Exception e)
        {
            return(LuaDLL.toluaL_exception(L, e));
        }
    }
    static int Instantiate9(IntPtr L)
    {
        try
        {
            int count = LuaDLL.lua_gettop(L);

            UnityEngine.Object     arg0 = (UnityEngine.Object)ToLua.ToObject(L, 1);
            UnityEngine.Vector3    arg1 = ToLua.ToVector3(L, 2);
            UnityEngine.Quaternion arg2 = ToLua.ToQuaternion(L, 3);
            UnityEngine.Transform  arg3 = (UnityEngine.Transform)ToLua.ToObject(L, 4);
            var o = UnityEngine.Object.Instantiate(arg0, arg1, arg2, arg3);
            ToLua.Push(L, o);
            return(1);
        }
        catch (Exception e)
        {
            return(LuaDLL.toluaL_exception(L, e));
        }
    }
Example #53
0
    static int LoadGameObject(IntPtr L)
    {
        try
        {
            int count = LuaDLL.lua_gettop(L);

            if (count == 3 && TypeChecker.CheckTypes(L, 1, typeof(Game.Loader), typeof(string), typeof(LuaInterface.LuaFunction)))
            {
                Game.Loader obj  = (Game.Loader)ToLua.ToObject(L, 1);
                string      arg0 = ToLua.ToString(L, 2);
                LuaFunction arg1 = ToLua.ToLuaFunction(L, 3);
                obj.LoadGameObject(arg0, arg1);
                return(0);
            }
            else if (count == 4 && TypeChecker.CheckTypes(L, 1, typeof(Game.Loader), typeof(UnityEngine.Transform), typeof(string), typeof(LuaInterface.LuaFunction)))
            {
                Game.Loader           obj  = (Game.Loader)ToLua.ToObject(L, 1);
                UnityEngine.Transform arg0 = (UnityEngine.Transform)ToLua.ToObject(L, 2);
                string      arg1           = ToLua.ToString(L, 3);
                LuaFunction arg2           = ToLua.ToLuaFunction(L, 4);
                obj.LoadGameObject(arg0, arg1, arg2);
                return(0);
            }
            else if (count == 4 && TypeChecker.CheckTypes(L, 1, typeof(Game.Loader), typeof(string), typeof(LuaInterface.LuaFunction), typeof(object)))
            {
                Game.Loader obj  = (Game.Loader)ToLua.ToObject(L, 1);
                string      arg0 = ToLua.ToString(L, 2);
                LuaFunction arg1 = ToLua.ToLuaFunction(L, 3);
                object      arg2 = ToLua.ToVarObject(L, 4);
                obj.LoadGameObject(arg0, arg1, arg2);
                return(0);
            }
            else
            {
                return(LuaDLL.luaL_throw(L, "invalid arguments to method: Game.Loader.LoadGameObject"));
            }
        }
        catch (Exception e)
        {
            return(LuaDLL.toluaL_exception(L, e));
        }
    }
Example #54
0
    static int _CreateNova_RotationAnimationProperty(IntPtr L)
    {
        try
        {
            int count = LuaDLL.lua_gettop(L);

            if (count == 2)
            {
                UnityEngine.Transform          arg0 = (UnityEngine.Transform)ToLua.CheckObject <UnityEngine.Transform>(L, 1);
                UnityEngine.Vector3            arg1 = ToLua.ToVector3(L, 2);
                Nova.RotationAnimationProperty obj  = new Nova.RotationAnimationProperty(arg0, arg1);
                ToLua.PushObject(L, obj);
                return(1);
            }
            else if (count == 3 && TypeChecker.CheckTypes <Nova.UseRelativeValue>(L, 3))
            {
                UnityEngine.Transform          arg0 = (UnityEngine.Transform)ToLua.CheckObject <UnityEngine.Transform>(L, 1);
                UnityEngine.Vector3            arg1 = ToLua.ToVector3(L, 2);
                Nova.UseRelativeValue          arg2 = (Nova.UseRelativeValue)ToLua.ToObject(L, 3);
                Nova.RotationAnimationProperty obj  = new Nova.RotationAnimationProperty(arg0, arg1, arg2);
                ToLua.PushObject(L, obj);
                return(1);
            }
            else if (count == 3 && TypeChecker.CheckTypes <UnityEngine.Vector3>(L, 3))
            {
                UnityEngine.Transform          arg0 = (UnityEngine.Transform)ToLua.CheckObject <UnityEngine.Transform>(L, 1);
                UnityEngine.Vector3            arg1 = ToLua.ToVector3(L, 2);
                UnityEngine.Vector3            arg2 = ToLua.ToVector3(L, 3);
                Nova.RotationAnimationProperty obj  = new Nova.RotationAnimationProperty(arg0, arg1, arg2);
                ToLua.PushObject(L, obj);
                return(1);
            }
            else
            {
                return(LuaDLL.luaL_throw(L, "invalid arguments to ctor method: Nova.RotationAnimationProperty.New"));
            }
        }
        catch (Exception e)
        {
            return(LuaDLL.toluaL_exception(L, e));
        }
    }
    static int set_hierarchyCapacity(IntPtr L)
    {
#if UNITY_EDITOR
        ToluaProfiler.AddCallRecord("UnityEngine.Transform.hierarchyCapacity");
#endif
        object o = null;

        try
        {
            o = ToLua.ToObject(L, 1);
            UnityEngine.Transform obj = (UnityEngine.Transform)o;
            int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
            obj.hierarchyCapacity = arg0;
            return(0);
        }
        catch (Exception e)
        {
            return(LuaDLL.toluaL_exception(L, e, o, "attempt to index hierarchyCapacity on a nil value"));
        }
    }
    static int RotateAround(IntPtr L)
    {
#if UNITY_EDITOR
        ToluaProfiler.AddCallRecord("UnityEngine.Transform.RotateAround");
#endif
        try
        {
            ToLua.CheckArgsCount(L, 4);
            UnityEngine.Transform obj  = (UnityEngine.Transform)ToLua.CheckObject <UnityEngine.Transform>(L, 1);
            UnityEngine.Vector3   arg0 = ToLua.ToVector3(L, 2);
            UnityEngine.Vector3   arg1 = ToLua.ToVector3(L, 3);
            float arg2 = (float)LuaDLL.luaL_checknumber(L, 4);
            obj.RotateAround(arg0, arg1, arg2);
            return(0);
        }
        catch (Exception e)
        {
            return(LuaDLL.toluaL_exception(L, e));
        }
    }
    static int get_localScale(IntPtr L)
    {
#if UNITY_EDITOR
        ToluaProfiler.AddCallRecord("UnityEngine.Transform.localScale");
#endif
        object o = null;

        try
        {
            o = ToLua.ToObject(L, 1);
            UnityEngine.Transform obj = (UnityEngine.Transform)o;
            UnityEngine.Vector3   ret = obj.localScale;
            ToLua.Push(L, ret);
            return(1);
        }
        catch (Exception e)
        {
            return(LuaDLL.toluaL_exception(L, e, o, "attempt to index localScale on a nil value"));
        }
    }
Example #58
0
    static int get_transform(IntPtr L)
    {
#if UNITY_EDITOR
        ToluaProfiler.AddCallRecord("UnityEngine.Component.transform");
#endif
        object o = null;

        try
        {
            o = ToLua.ToObject(L, 1);
            UnityEngine.Component obj = (UnityEngine.Component)o;
            UnityEngine.Transform ret = obj.transform;
            ToLua.Push(L, ret);
            return(1);
        }
        catch (Exception e)
        {
            return(LuaDLL.toluaL_exception(L, e, o, "attempt to index transform on a nil value"));
        }
    }
    static int get_rootBone(IntPtr L)
    {
#if UNITY_EDITOR
        ToluaProfiler.AddCallRecord("UnityEngine.SkinnedMeshRenderer.rootBone");
#endif
        object o = null;

        try
        {
            o = ToLua.ToObject(L, 1);
            UnityEngine.SkinnedMeshRenderer obj = (UnityEngine.SkinnedMeshRenderer)o;
            UnityEngine.Transform           ret = obj.rootBone;
            ToLua.Push(L, ret);
            return(1);
        }
        catch (Exception e)
        {
            return(LuaDLL.toluaL_exception(L, e, o, "attempt to index rootBone on a nil value"));
        }
    }
    static int set_rootBone(IntPtr L)
    {
#if UNITY_EDITOR
        ToluaProfiler.AddCallRecord("UnityEngine.SkinnedMeshRenderer.rootBone");
#endif
        object o = null;

        try
        {
            o = ToLua.ToObject(L, 1);
            UnityEngine.SkinnedMeshRenderer obj  = (UnityEngine.SkinnedMeshRenderer)o;
            UnityEngine.Transform           arg0 = (UnityEngine.Transform)ToLua.CheckObject <UnityEngine.Transform>(L, 2);
            obj.rootBone = arg0;
            return(0);
        }
        catch (Exception e)
        {
            return(LuaDLL.toluaL_exception(L, e, o, "attempt to index rootBone on a nil value"));
        }
    }