Inheritance: MonoBehaviour
コード例 #1
0
    public void SelectNextMirror()
    {
        int index = GetNextMirror();

        if (index > -1)
        {
            previousMirror.DeselectAsPrevious();
            previousMirror = currentMirror;
            previousMirror.SelectAsPrevious();
        }

        if (index > -1)
        {
            currentMirror.Deselect();
            current       = index;
            currentMirror = Mirrors[current];
            currentMirror.Select();
        }

        index = GetNextMirror();
        if (index > -1)
        {
            nextMirror.DeselectAsNext();
            nextMirror = Mirrors[index];
            nextMirror.SelectAsNext();
        }
    }
コード例 #2
0
 // Start is called before the first frame update
 void Start()
 {
     m_shooting            = GetComponent <Shooting>();
     m_rotateObject        = GetComponent <RotateObject>();
     m_wanderAiForShooting = GetComponent <WanderAIForShooting>();
     StartCoroutine("CalledUpdateTarget");
 }
コード例 #3
0
ファイル: Sensor.cs プロジェクト: ZhanYi224/Turret-AI
 //RaycastHit hit;
 // Start is called before the first frame update
 void Start()
 {
     m_rotateObject = GetComponent <RotateObject>();
     StartCoroutine("CalledUpdateTarget");
     //InvokeRepeating("OverlapSphereOnTarget", 0f, 0.5f);
     //use coroutine to manage the checking interval(duration between the thing happen, time bettween do thing)
 }
コード例 #4
0
 public TestStateTwo(FiniteStateMachine stateManager, string gameModeText, Timer gameTimer, RotateObject testCube)
 {
     this.stateManager = stateManager;
     this.gameModeText = gameModeText;
     this.gameTimer    = gameTimer;
     this.testCube     = testCube;
 }
コード例 #5
0
 // Use this for initialization
 void Awake()
 {
     _ballBehavior       = FindObjectOfType <ballBehavior>();
     _orbPositionManager = FindObjectOfType <OrbPositionManager>();
     _collider           = GetComponent <Collider>();
     _collider.enabled   = false;
     _rotateObject       = GetComponent <RotateObject>();
     _glowParticle       = GetComponentInChildren <ParticleSystem>();
     _glowParticle.Stop();
 }
コード例 #6
0
    void Start()
    {
        objectVision = GetComponent<ObjectVision> ();
        jumpSlerpObject = GetComponent<JumpSlerpObject> ();
        rotateObject = GetComponent<RotateObject> ();

        int startDir = Random.Range (1, 30);

        currentDirection = startDir >= 15 ? JumperDirection.left : JumperDirection.right;
    }
コード例 #7
0
 // Use this for initialization
 void Start()
 {
     lineMove = GetComponent <Forth>();
     rotate   = GetComponent <RotateObject>();
     if (randTimer)
     {
         countdown = Mathf.RoundToInt(Random.value * 100);
     }
     else
     {
         countdown = setCount;
     }
 }
コード例 #8
0
    // Start is called before the first frame update
    void Start()
    {
        Random.InitState(42);
        randomSeed = new float[10];
        for (int i = 0; i < randomSeed.Length; i++)
        {
            randomSeed[i] = Random.Range(0, 5);
            Debug.Log(randomSeed[i]);
        }

        m_rotateObject = GetComponent <RotateObject>();
        avoidObstacle  = GetComponent <AvoidObstacle>();
    }
コード例 #9
0
ファイル: PolyUI.cs プロジェクト: livazz/Polyhydra
    void Start()
    {
        opPrefabs     = new List <Transform>();
        presetButtons = new List <Button>();
        rotateObject  = poly.GetComponent <RotateObject>();

        BasePolyDropdown.ClearOptions();
        foreach (var polyType in Enum.GetValues(typeof(PolyTypes)))
        {
            var label = new Dropdown.OptionData(polyType.ToString().Replace("_", " "));
            BasePolyDropdown.options.Add(label);
        }

        GridTypeDropdown.ClearOptions();
        foreach (var gridType in Enum.GetValues(typeof(PolyHydra.GridTypes)))
        {
            var label = new Dropdown.OptionData(gridType.ToString());
            GridTypeDropdown.options.Add(label);
        }

        BasePolyDropdown.onValueChanged.AddListener(delegate { BasePolyDropdownChanged(BasePolyDropdown); });
        PrevPolyButton.onClick.AddListener(PrevPolyButtonClicked);
        NextPolyButton.onClick.AddListener(NextPolyButtonClicked);
        TwoSidedToggle.onValueChanged.AddListener(delegate { TwoSidedToggleChanged(); });
        GridTypeDropdown.onValueChanged.AddListener(delegate { GridTypeDropdownChanged(GridTypeDropdown); });
        PrismPInput.onValueChanged.AddListener(delegate { PrismPInputChanged(); });
        PrismQInput.onValueChanged.AddListener(delegate { PrismQInputChanged(); });
        BypassOpsToggle.onValueChanged.AddListener(delegate { BypassOpsToggleChanged(); });
        AddOpButton.onClick.AddListener(AddOpButtonClicked);
        AddRandomOpButton.onClick.AddListener(AddRandomOpButtonClicked);

        PresetNameInput.onValueChanged.AddListener(delegate { PresetNameChanged(); });
        SavePresetButton.onClick.AddListener(SavePresetButtonClicked);
        ResetPresetsButton.onClick.AddListener(ResetPresetsButtonClicked);
        OpenPresetsFolderButton.onClick.AddListener(OpenPersistentDataFolder);

        PrevAPresetButton.onClick.AddListener(PrevAPresetButtonClicked);
        NextAPresetButton.onClick.AddListener(NextAPresetButtonClicked);

        XRotateSlider.onValueChanged.AddListener(delegate { XSliderChanged(); });
        YRotateSlider.onValueChanged.AddListener(delegate { YSliderChanged(); });
        ZRotateSlider.onValueChanged.AddListener(delegate { ZSliderChanged(); });

        ObjExportButton.onClick.AddListener(ObjExportButtonClicked);

        Presets.LoadAllPresets();

        InitUI();
        CreatePresetButtons();
        ShowTab(TabButtons[0].gameObject);
    }
コード例 #10
0
 public void SelectCertainMirror(int mirrorNumber)
 {
     currentMirror.Deselect();
     if (mirrorNumber >= 0 && mirrorNumber < Mirrors.Length && bIsMirrorAvailable[mirrorNumber])
     {
         current       = mirrorNumber;
         currentMirror = Mirrors[current];
         currentMirror.Select();
     }
     else
     {
         Debug.LogWarning("The mirror " + mirrorNumber + " cannot be selected.");
     }
 }
コード例 #11
0
 void Awake( )
 {
    #if !(UNITY_FLASH)
    useGUILayout = false;
    #endif
    ExposedVariables.Awake( );
    ExposedVariables.SetParent( this.gameObject );
    if ( "1.PLE" != uScript_MasterComponent.Version )
    {
       uScriptDebug.Log( "The generated code is not compatible with your current uScript Runtime " + uScript_MasterComponent.Version, uScriptDebug.Type.Error );
       ExposedVariables = null;
       UnityEngine.Debug.Break();
    }
 }
コード例 #12
0
 void Start()
 {
     myTransform = transform;
     mainCam = Camera.main;
     mainCamTransform = mainCam.transform;
     camDiagonal = (new Vector2(mainCam.orthographicSize * mainCam.aspect, mainCam.orthographicSize)).magnitude; // diagonal is a mgnitude of a sum of width and height vectors
     rend = GetComponent<Renderer>();
     anim = GetComponent<Animator>();
     coll = GetComponent<Collider2D>();
     rb = GetComponent<Rigidbody2D>();
     rotObj = GetComponent<RotateObject>();
     if (rb != null) { isKinematic = rb.isKinematic; }
     TurnOff();
 }
コード例 #13
0
    public void SyncChild(TargetManager scriptTargetManager)
    {
        Transform transformTarget = scriptTargetManager.gameObject.transform;

        this.transform.position = transformTarget.position;
        this.transform.Rotate(transformTarget.eulerAngles);

        RotateObject scriptRotateObjectTarget = scriptTargetManager.gameObject.GetComponent <RotateObject>();

        this.scriptRotateObject.TempRotation = scriptRotateObjectTarget.TempRotation;

        this.IsRotation  = scriptTargetManager.IsRotation;
        this.IsClockwise = scriptTargetManager.IsClockwise;
        this.SpeedX      = scriptTargetManager.SpeedX;
    }
コード例 #14
0
ファイル: ChestBehaviour.cs プロジェクト: Eliice/RPGRogueLike
    void Awake()
    {
        inventory    = GetComponentInParent <Inventory>();
        rotateObject = GetComponent <RotateObject>();
#if UNITY_EDITOR
        if (inventory == null)
        {
            Debug.LogError("inventory == null");
        }
        if (rotateObject == null)
        {
            Debug.LogError("rotateObject == null");
        }
#endif
    }
コード例 #15
0
    // Vector3 aiDistance;

    //AvoidObstacle avoidObstacle;

    // Start is called before the first frame update
    void Start()
    {
        Random.InitState(42);
        randomSeed = new float[10];
        for (int i = 0; i < randomSeed.Length; i++)
        {
            randomSeed[i] = Random.Range(0, 5);
            //Debug.Log(randomSeed[i]);
        }

        //m_rotateObject = GetComponent<RotateObject>();
        m_moveTowardTarget = GetComponent <SensorAI>();
        avoidObstacle      = wallPosition.GetComponent <AvoidObstacle>();
        rttObject          = GetComponent <RotateObject>();
    }
コード例 #16
0
    public override void OnInspectorGUI()
    {
        GUIStyle HeaderStyle = new GUIStyle();

        HeaderStyle.fontSize  = 15;
        HeaderStyle.fontStyle = FontStyle.Bold;


        RotateObject RotationObject = (RotateObject)target;

        GUILayout.Space(10);
        EditorGUILayout.LabelField("Właściwości obrotu:", HeaderStyle, GUILayout.Height(20));
        RotationObject.RotationSpeed = EditorGUILayout.Slider("Prędkość obrotu:", RotationObject.RotationSpeed, 0, 50);
        RotationObject.turnRight     = EditorGUILayout.Toggle("Obrót w prawo", RotationObject.turnRight);
        RotationObject.turnLeft      = EditorGUILayout.Toggle("Obrót w lewo", RotationObject.turnLeft);
    }
コード例 #17
0
    //功能:遊戲初始化
    //旋轉腳本=RotateObject
    //旋轉腳本(關閉)
    //子物件(關閉)
    //collider.isTrigge(開啟)
    //計算鑰匙數量
    //發送訊息到keyReceiver(複數)
    //發送訊息到lockReceiver
    // Use this for initialization
    void Start()
    {
        rotateScript         = GetComponent <RotateObject>();
        rotateScript.enabled = false;

        transform.GetChild(0).gameObject.SetActive(false);
        transform.GetComponent <Collider>().isTrigger = true;
        keysCount = keys.Length;

        for (int i = 0; i < keys.Length; i++)
        {
            keys[i].gameObject.SendMessage("keyReceiver", transform.gameObject, SendMessageOptions.DontRequireReceiver);
        }

        lockReceiver(0);
    }
コード例 #18
0
ファイル: Posture.cs プロジェクト: hippogyz/mc_unity
    public Posture(Character character)
    {
        head      = character.head;
        wholebody = character.wholebody;
        body      = character.body;
        leftHand  = character.leftHand;
        rightHand = character.rightHand;
        leftLeg   = character.leftLeg;
        rightLeg  = character.rightLeg;

        headObject      = new RotateHead(head);
        bodyObject      = new RotateBody(wholebody);
        leftHandObject  = new RotateLeftHand(leftHand);
        rightHandObject = new RotateRightHand(rightHand);
        leftLegObject   = new RotateRightHand(leftLeg); // same as right hand
        rightLegObject  = new RotateLeftHand(rightLeg); // same as left leg
    }
コード例 #19
0
    public void UpdateRotator()
    {
        if (containerPlayerDisplay == null)
        {
            return;
        }

        if (containerPlayerDisplay.transform.childCount == 0)
        {
            return;
        }

        if (containerRotator == null)
        {
            return;
        }

        if (rotatorRigidbody == null)
        {
            rotatorRigidbody = containerRotator.GetOrSet <Rigidbody>();
        }

        if (rotateObject == null)
        {
            rotateObject = containerRotator.GetOrSet <RotateObject>();
        }

        if (rotatorCollider == null)
        {
            rotatorCollider = containerRotator.GetOrSet <CapsuleCollider>();
        }

        //rotateObject.enabled = false;

        if (allowRotator)
        {
            if (rotatorRigidbody != null)
            {
                rotatorRigidbody.constraints = RigidbodyConstraints.FreezePositionX
                                               | RigidbodyConstraints.FreezePositionY
                                               | RigidbodyConstraints.FreezePositionZ
                                               | RigidbodyConstraints.FreezeRotationX
                                               | RigidbodyConstraints.FreezeRotationZ;
            }

            if (rotateObject != null)
            {
                rotateObject.RotateSpeedAlongY = 2;
            }

            string keyRotation = "rotation-" + uuid;

            if (AnimationEasing.EaseExists(keyRotation))
            {
                currentContainerRotation = AnimationEasing.EaseGetValue(keyRotation, 0.0f);

                currentContainerRotation = (double)Mathf.Clamp((float)currentContainerRotation, (float)rotationMin, (float)rotationMax);

                //Debug.Log("UpdateScale:" + " currentContainerScale:" + currentContainerScale);

                float rotateTo = (float)currentContainerRotation;

                containerRotator.transform.localRotation =
                    Quaternion.Euler(Vector3.zero
                                     .WithX(0)
                                     .WithY(rotateTo * 360)
                                     .WithZ(0));
            }
        }
        else
        {
            containerRotator.ResetObject();

            if (rotatorRigidbody != null)
            {
                rotatorRigidbody.constraints = RigidbodyConstraints.FreezeAll;
            }

            if (rotateObject != null)
            {
                rotateObject.RotateSpeedAlongY = 0;
            }
        }
    }
コード例 #20
0
 private void Awake()
 {
     // Get necessary components
     rotation = gameObject.GetComponent <RotateObject>() as RotateObject;
     rend     = gameObject.GetComponent <Renderer>() as Renderer;
 }
コード例 #21
0
ファイル: Player.cs プロジェクト: sokogames/uptoheven-project
    // Use this for initialization
    void Start()
    {
        rigidBody = GetComponent<Rigidbody> ();
        audioSource = GetComponent<AudioSource> ();
        jumpSlerpObject = GetComponent<JumpSlerpObject> ();
        rotateObject = GetComponent<RotateObject> ();
        objectVision = GetComponent<ObjectVision> ();

        jumpSlerpObject.OnJumpSlerpEnded += OnJumpEnded;
        rotateObject.OnRotationEnded += OnRotateEnded;
        rotateObject.OnRotationStarted += OnRotateStarted;

        animator = GetComponent<Animator> ();

        isDead = false;
    }
コード例 #22
0
    // Use this for initialization
    void Start()
    {
        GameObject[] mirrorsWithTag = GameObject.FindGameObjectsWithTag("Mirror");
        int          size           = 0;

        for (int i = 0; i < mirrorsWithTag.Length; i++)
        {
            RotateObject mirror = mirrorsWithTag[i].GetComponentInParent <RotateObject>();
            mirror.mirrorManager = this;
            if (mirror.MirrorNumber > -1)
            {
                size++;
            }
            else
            {
                Debug.LogWarning("Mirror number did not assign\n");
            }
        }
        Mirrors            = new RotateObject[size];
        bIsMirrorAvailable = new bool[size];
        for (int i = 0; i < size; i++)
        {
            bIsMirrorAvailable[i] = false;
        }

        for (int i = 0; i < mirrorsWithTag.Length; i++)
        {
            RotateObject mirror = mirrorsWithTag[i].GetComponentInParent <RotateObject>();
            if (mirror.MirrorNumber > -1)
            {
                int iMirrors = mirror.MirrorNumber;
                if (iMirrors >= Mirrors.Length)
                {
                    Debug.LogError("Mirror number out of bound, make sure the number is within 0 to total-1\n");
                    break;
                }
                Mirrors[iMirrors] = mirror;
                if (bIsMirrorAvailable[iMirrors])
                {
                    Debug.LogWarning("Mirror number duplicated " + iMirrors + "\n");
                }
                bIsMirrorAvailable[iMirrors] = true;
            }
        }

        current       = 0;
        currentMirror = Mirrors[current];
        currentMirror.Select();

        int NextIndex = GetNextMirror();

        if (NextIndex > -1)
        {
            nextMirror = Mirrors[NextIndex];
            nextMirror.SelectAsNext();
        }

        previousMirror = Mirrors[Mirrors.Length - 1];
        if (previousMirror != null)
        {
            previousMirror.SelectAsPrevious();
        }
    }
コード例 #23
0
    // Update is called once per frame
    void Update()
    {
        Debug.DrawRay(transform.position, transform.forward * raycastLength, Color.red, 0.5f);

        if (Physics.Raycast(transform.position, transform.forward, out vision, raycastLength, mask))
        {
            if (vision.collider.CompareTag("Interactable"))
            {
                objectName.text = vision.collider.name;
                aimImage.sprite = focussedAim;

                Debug.Log("Raycast Hit : " + vision.collider.name);

                if (Input.GetButtonDown("PickUp") && !isGrabbed)       // Rename the Input in Project Settings for LMB to PickUp
                {
                    objectName.text = "";

                    aimImage.color = new Vector4(aimImage.color.r, aimImage.color.g, aimImage.color.b, 0);

                    grabbedObject = vision.rigidbody;
                    rotateObject  = grabbedObject.GetComponent <RotateObject>();

                    // Disable Cast and Receive shadows
                    grabbedObjectRenderer = grabbedObject.GetComponent <MeshRenderer>();
                    grabbedObjectRenderer.receiveShadows    = false;
                    grabbedObjectRenderer.shadowCastingMode = ShadowCastingMode.Off;


                    if (grabbedObject.transform.parent == null)
                    {
                        Debug.LogError("The Object Doesn't have a parent");
                        return;
                    }

                    positionInEnvironment     = rotateObject.objectParent;
                    grabbedObject.isKinematic = true;

                    grabbedObject.transform.SetParent(gameObject.transform);

                    grabbedObject.transform.localPosition = new Vector3(0, 0, distanceOfObjectFromCamera);
                    grabbedObject.transform.localRotation = Quaternion.identity;


                    // Debug.Log("Position of Cube after assignment: " + grabbedObject.transform.position);

                    isGrabbed = true;

                    InspectObject();
                }

                else if (isGrabbed && Input.GetButtonDown("PutDown"))              // Rename the Input in Project Settings for RMB to PutDown
                {
                    objectName.text = "";

                    aimImage.color = new Vector4(aimImage.color.r, aimImage.color.g, aimImage.color.b, 1);
                    grabbedObject.transform.SetParent(positionInEnvironment.transform);
                    grabbedObject.transform.localPosition = Vector3.zero;
                    grabbedObject.transform.localRotation = Quaternion.identity;
                    grabbedObject.isKinematic             = false;

                    // Enable Cast and Receive shadows
                    grabbedObjectRenderer.receiveShadows    = true;
                    grabbedObjectRenderer.shadowCastingMode = ShadowCastingMode.On;



                    isGrabbed = false;

                    StopInspectingObject();
                }
            }

            else if (!vision.collider.CompareTag("Interactable"))
            {
                objectName.text = "";
                aimImage.sprite = unFocussedAim;

                Debug.Log("Raycast has hit : " + vision.collider.name);

                if (isGrabbed && Input.GetButtonDown("PutDown"))              // Rename the Input in Project Settings for RMB to PutDown
                {
                    objectName.text = "";
                    aimImage.color  = new Vector4(aimImage.color.r, aimImage.color.g, aimImage.color.b, 1);
                    grabbedObject.transform.SetParent(positionInEnvironment.transform);
                    grabbedObject.transform.localPosition = Vector3.zero;
                    grabbedObject.transform.localRotation = Quaternion.identity;
                    grabbedObject.isKinematic             = false;

                    // Enable Cast and Receive shadows
                    grabbedObjectRenderer.receiveShadows    = true;
                    grabbedObjectRenderer.shadowCastingMode = ShadowCastingMode.On;



                    isGrabbed = false;

                    StopInspectingObject();
                }
            }
        }
        else
        {
            objectName.text = "";
            aimImage.sprite = unFocussedAim;
        }
    }
コード例 #24
0
 void Awake()
 {
     _instance = this;
 }
コード例 #25
0
        public static void Init()
        {
            Material voidCellBaseInidicatorMat = UnityEngine.Object.Instantiate <Material>(Resources.Load <GameObject>("Prefabs/Networkedobjects/NullSafeWard").transform.Find("Indicator").Find("IndicatorSphere").GetComponentInChildren <MeshRenderer>().material);
            Material voidCellReaverFoamMat     = UnityEngine.Object.Instantiate <Material>(Resources.Load <GameObject>("Prefabs/Networkedobjects/NullSafeWard").transform.GetChild(0).GetChild(0).GetComponent <MeshRenderer>().material);
            Material distortionMat             = UnityEngine.Object.Instantiate <Material>(Resources.Load <GameObject>("Prefabs/Networkedobjects/NullSafeWard").transform.GetChild(3).GetChild(1).GetChild(3).GetComponent <ParticleSystemRenderer>().material);

            #region CorruptedTeleporter
            corruptedTeleporter = GameObject.Instantiate(Resources.Load <GameObject>("prefabs/networkedobjects/teleporters/Teleporter1"));
            corruptedTeleporter.SetActive(false);
            CRMissionController missionController = corruptedTeleporter.AddComponent <CRMissionController>();
            corruptedTeleporter.SetActive(true);
            missionController.target = corruptedTeleporter.GetComponent <TeleporterInteraction>();
            missionController.target.holdoutZoneController.radiusIndicator.material = UnityEngine.Object.Instantiate <Material>(voidCellBaseInidicatorMat);
            missionController.target.holdoutZoneController.radiusIndicator.material.SetVector("_TintColor", new Vector4(0.5f, 0.0f, 1.0f, 0.75f));

            GameObject teleRift = GameObject.Instantiate(Assets.teleporterRift);
            teleRift.transform.SetParent(corruptedTeleporter.transform);
            teleRift.transform.localPosition = new Vector3(0.0f, 8.0f, 0.0f);

            RotateObject teleEffectRotator = teleRift.AddComponent <RotateObject>();
            teleEffectRotator.rotationSpeed = new Vector3(0.0f, 35.0f, 0.0f);

            ChildLocator teleporterChildLocator = teleRift.GetComponent <ChildLocator>();
            teleporterChildLocator.FindChild("DistortionParticle").GetComponent <ParticleSystemRenderer>().material = UnityEngine.Object.Instantiate <Material>(distortionMat);
            teleporterChildLocator.FindChild("OrbsModel").GetComponent <MeshRenderer>().material      = UnityEngine.Object.Instantiate <Material>(voidCellReaverFoamMat);
            teleporterChildLocator.FindChild("OrbN").GetComponentInChildren <MeshRenderer>().material = UnityEngine.Object.Instantiate <Material>(voidCellReaverFoamMat);
            teleporterChildLocator.FindChild("OrbE").GetComponentInChildren <MeshRenderer>().material = UnityEngine.Object.Instantiate <Material>(voidCellReaverFoamMat);
            teleporterChildLocator.FindChild("OrbS").GetComponentInChildren <MeshRenderer>().material = UnityEngine.Object.Instantiate <Material>(voidCellReaverFoamMat);
            teleporterChildLocator.FindChild("OrbW").GetComponentInChildren <MeshRenderer>().material = UnityEngine.Object.Instantiate <Material>(voidCellReaverFoamMat);

            missionController.orbLocator = teleporterChildLocator;


            var teleporterDirectors = corruptedTeleporter.GetComponents <CombatDirector>();

            foreach (CombatDirector targetTeleporterDirector in teleporterDirectors)
            {
                if (targetTeleporterDirector.customName == "Monsters")
                {
                    UnityEngine.Object.Destroy(targetTeleporterDirector);
                }
                if (targetTeleporterDirector.customName == "Boss")
                {
                    missionController.bossDirector = targetTeleporterDirector;
                }
            }
            ;


            var protectionWardGO = new GameObject();
            protectionWardGO.transform.parent        = corruptedTeleporter.transform;
            protectionWardGO.transform.localPosition = Vector3.zero;

            var teamFilter1 = protectionWardGO.AddComponent <TeamFilter>();
            teamFilter1.defaultTeam = TeamIndex.Player;

            missionController.protectionWard                    = protectionWardGO.AddComponent <BuffWard>();
            missionController.protectionWard.buffDef            = CRContentPackProvider.protectionBuffDef;
            missionController.protectionWard.buffDuration       = 0.5f;
            missionController.protectionWard.interval           = 0.25f;
            missionController.protectionWard.radius             = 15;
            missionController.protectionWard.floorWard          = false;
            missionController.protectionWard.expires            = false;
            missionController.protectionWard.invertTeamFilter   = false;
            missionController.protectionWard.expireDuration     = 0;
            missionController.protectionWard.removalTime        = 0;
            missionController.protectionWard.removalSoundString = "";
            missionController.protectionWard.requireGrounded    = false;


            var voidWardGO = new GameObject();
            voidWardGO.transform.parent        = corruptedTeleporter.transform;
            voidWardGO.transform.localPosition = Vector3.zero;

            var teamFilter2 = voidWardGO.AddComponent <TeamFilter>();
            teamFilter2.defaultTeam = TeamIndex.Player;

            missionController.voidWard                    = voidWardGO.AddComponent <BuffWard>();
            missionController.voidWard.buffDef            = CRContentPackProvider.voidDebuffDef;
            missionController.voidWard.buffDuration       = 0.5f;
            missionController.voidWard.interval           = 0.25f;
            missionController.voidWard.radius             = 75;
            missionController.voidWard.floorWard          = false;
            missionController.voidWard.expires            = false;
            missionController.voidWard.invertTeamFilter   = false;
            missionController.voidWard.expireDuration     = 0;
            missionController.voidWard.removalTime        = 0;
            missionController.voidWard.removalSoundString = "";
            missionController.voidWard.requireGrounded    = false;

            GameObject voidWardIndicator = GameObject.Instantiate(Resources.Load <GameObject>("prefabs/networkedobjects/NullSafeWard").transform.GetChild(1).gameObject);
            voidWardIndicator.transform.SetParent(voidWardGO.transform);
            voidWardIndicator.transform.localPosition = Vector3.zero;
            missionController.voidWard.rangeIndicator = voidWardIndicator.transform;

            voidWardIndicator.GetComponentInChildren <MeshRenderer>().material = UnityEngine.Object.Instantiate <Material>(voidCellBaseInidicatorMat);
            voidWardIndicator.GetComponentInChildren <MeshRenderer>().material.SetVector("_TintColor", new Vector4(1.0f, 0.0f, 0.25f, 0.35f));

            /*foreach (CombatDirector director in corruptedTeleporter.GetComponents<CombatDirector>())
             * {
             *  Component.DestroyImmediate(director);
             * }*/

            missionController.directors = new CombatDirector[4];
            for (int i = 0; i < 4; i++)
            {
                missionController.directors[i]                      = corruptedTeleporter.AddComponent <CombatDirector>();
                missionController.directors[i].enabled              = false;
                missionController.directors[i].customName           = "CRDirector" + i.ToString();
                missionController.directors[i].monsterCredit        = 0;
                missionController.directors[i].expRewardCoefficient = 0.2f;
                missionController.directors[i].moneyWaveIntervals   = new RangeFloat[1] {
                    new RangeFloat()
                    {
                        min = 0.75f, max = 0.75f
                    }
                };
                missionController.directors[i].minSeriesSpawnInterval = 0.1f;
                missionController.directors[i].maxSeriesSpawnInterval = 1;
                missionController.directors[i].minRerollSpawnInterval = 2.333f;
                missionController.directors[i].maxRerollSpawnInterval = 4.333f;
                missionController.directors[i].teamIndex                          = TeamIndex.Monster;
                missionController.directors[i].creditMultiplier                   = 1f;
                missionController.directors[i].spawnDistanceMultiplier            = 1;
                missionController.directors[i].shouldSpawnOneWave                 = false;
                missionController.directors[i].targetPlayers                      = true;
                missionController.directors[i].skipSpawnIfTooCheap                = false;
                missionController.directors[i].resetMonsterCardIfFailed           = false;
                missionController.directors[i].maximumNumberToSpawnBeforeSkipping = 6;
                missionController.directors[i].eliteBias                          = 1f;
                missionController.directors[i].spawnEffectPrefab                  = Resources.Load <GameObject>("prefabs/effects/NullifierExplosion");
            }

            missionController.inventory = corruptedTeleporter.AddComponent <Inventory>();
            corruptedTeleporter.AddComponent <EnemyInfoPanelInventoryProvider>();

            corruptedTeleporter = PrefabAPI.InstantiateClone(corruptedTeleporter, "CRTeleporter", true);
            Debug.Log("[CRCore3]: Created prefab: " + corruptedTeleporter.name);
            #endregion
            //////////
            #region VoidRifts
            // add custom position indicator and radar scannar icon
            voidRift = GameObject.Instantiate(Assets.voidRift);
            voidRift.transform.GetChild(0).GetComponentInChildren <MeshRenderer>().material = UnityEngine.Object.Instantiate <Material>(missionController.target.holdoutZoneController.radiusIndicator.material);

            ChildLocator childLocator = voidRift.GetComponent <ChildLocator>(); ///todo: convert all to child locator

            childLocator.FindChild("PhysicalOrb").GetComponent <MeshRenderer>().material = UnityEngine.Object.Instantiate <Material>(voidCellReaverFoamMat);
            childLocator.FindChild("DistortionParticle1").GetComponent <ParticleSystemRenderer>().material = UnityEngine.Object.Instantiate <Material>(distortionMat);
            childLocator.FindChild("DistortionParticle2").GetComponent <ParticleSystemRenderer>().material = UnityEngine.Object.Instantiate <Material>(distortionMat);
            childLocator.FindChild("DistortionParticle3").GetComponent <ParticleSystemRenderer>().material = UnityEngine.Object.Instantiate <Material>(distortionMat);
            childLocator.FindChild("DistortionParticle4").GetComponent <ParticleSystemRenderer>().material = UnityEngine.Object.Instantiate <Material>(distortionMat);

            var voidRiftHoldoutZone = voidRift.AddComponent <HoldoutZoneController>();
            voidRiftHoldoutZone.enabled                   = false;
            voidRiftHoldoutZone.baseRadius                = 22;
            voidRiftHoldoutZone.minimumRadius             = 4;
            voidRiftHoldoutZone.chargeRadiusDelta         = 0;
            voidRiftHoldoutZone.baseChargeDuration        = 35;
            voidRiftHoldoutZone.radiusSmoothTime          = 1;
            voidRiftHoldoutZone.healingNovaRoot           = voidRift.transform.GetChild(0).GetChild(1);
            voidRiftHoldoutZone.inBoundsObjectiveToken    = "OBJECTIVE_RIFT_CHARGING_TOKEN";
            voidRiftHoldoutZone.outOfBoundsObjectiveToken = "OBJECTIVE_RIFT_INACTIVE_TOKEN";
            voidRiftHoldoutZone.applyFocusConvergence     = true;
            voidRiftHoldoutZone.applyHealingNova          = true;
            voidRiftHoldoutZone.playerCountScaling        = 1;
            voidRiftHoldoutZone.radiusIndicator           = voidRift.transform.GetChild(0).GetChild(0).GetComponent <MeshRenderer>();
            voidRiftHoldoutZone.baseIndicatorColor        = new Color(0.5f, 0.0f, 1.0f, 0.75f);

            var teamFilter = voidRift.AddComponent <TeamFilter>();
            teamFilter.defaultTeam = TeamIndex.Player;

            var riftNetworkMachine = voidRift.AddComponent <NetworkStateMachine>();
            var stateMachine       = voidRift.AddComponent <EntityStateMachine>();
            stateMachine.customName          = "CRRiftStateMachine";
            stateMachine.initialStateType    = new SerializableEntityStateType(typeof(RiftOffState));
            stateMachine.mainStateType       = new SerializableEntityStateType(typeof(RiftOnState));
            riftNetworkMachine.stateMachines = new EntityStateMachine[] { stateMachine };


            var riftInteraction = voidRift.AddComponent <PurchaseInteraction>();
            riftInteraction.displayNameToken = "CRRIFT_INTERACT_NAME";
            riftInteraction.contextToken     = "CRRIFT_INTERACT_CONTEXT";
            riftInteraction.costType         = CostTypeIndex.None;
            riftInteraction.available        = true;
            riftInteraction.automaticallyScaleCostWithDifficulty = false;
            riftInteraction.requiredUnlockable = "";
            riftInteraction.ignoreSpherecastForInteractability  = false;
            riftInteraction.setUnavailableOnTeleporterActivated = false;
            riftInteraction.isShrine     = false;
            riftInteraction.isGoldShrine = false;

            var riftEntityLocator = voidRift.transform.GetChild(0).GetChild(4).GetChild(0).gameObject.AddComponent <EntityLocator>();
            riftEntityLocator.entity = voidRift;

            var voidProtectionWard = voidRift.AddComponent <BuffWard>();
            voidProtectionWard.buffDef            = CRContentPackProvider.protectionBuffDef;
            voidProtectionWard.buffDuration       = 0.5f;
            voidProtectionWard.interval           = 0.25f;
            voidProtectionWard.radius             = 0;
            voidProtectionWard.floorWard          = false;
            voidProtectionWard.expires            = false;
            voidProtectionWard.invertTeamFilter   = false;
            voidProtectionWard.expireDuration     = 0;
            voidProtectionWard.removalTime        = 0;
            voidProtectionWard.removalSoundString = "";
            voidProtectionWard.requireGrounded    = false;
            voidProtectionWard.rangeIndicator     = voidRift.transform.GetChild(0).GetChild(0);

            var voidRiftWard = voidRift.AddComponent <BuffWard>();
            voidRiftWard.buffDef            = CRContentPackProvider.voidDebuffDef;
            voidRiftWard.buffDuration       = 0.5f;
            voidRiftWard.interval           = 0.25f;
            voidRiftWard.radius             = 75;
            voidRiftWard.floorWard          = false;
            voidRiftWard.expires            = false;
            voidRiftWard.invertTeamFilter   = false;
            voidRiftWard.expireDuration     = 0;
            voidRiftWard.removalTime        = 0;
            voidRiftWard.removalSoundString = "";
            voidRiftWard.requireGrounded    = false;
            voidRiftWard.rangeIndicator     = voidRift.transform.GetChild(0).GetChild(3);
            voidRiftWard.rangeIndicator.gameObject.GetComponentInChildren <MeshRenderer>().material = UnityEngine.Object.Instantiate <Material>(voidWardIndicator.GetComponentInChildren <MeshRenderer>().material);
            voidRiftWard.rangeIndicator.gameObject.GetComponentInChildren <MeshRenderer>().material.SetVector("_TintColor", new Vector4(1.0f, 0.0f, 0.0f, 0.1f));


            VoidRiftTracker voidRiftComponentTracker = voidRift.AddComponent <VoidRiftTracker>();
            voidRiftComponentTracker.protectionWard = voidProtectionWard;
            voidRiftComponentTracker.voidWard       = voidRiftWard;


            voidRift = PrefabAPI.InstantiateClone(voidRift, "CRVoidRift", true);
            Debug.Log("[CRCore3]: Created prefab: " + voidRift.name);
            #endregion
            //////////
            #region ISCs
            InteractableSpawnCard interactableSpawnCard = ScriptableObject.CreateInstance <InteractableSpawnCard>();
            interactableSpawnCard.sendOverNetwork                       = true;
            interactableSpawnCard.hullSize                              = HullClassification.Human;
            interactableSpawnCard.nodeGraphType                         = RoR2.Navigation.MapNodeGroup.GraphType.Ground;
            interactableSpawnCard.requiredFlags                         = RoR2.Navigation.NodeFlags.TeleporterOK;
            interactableSpawnCard.forbiddenFlags                        = RoR2.Navigation.NodeFlags.None;
            interactableSpawnCard.directorCreditCost                    = 0;
            interactableSpawnCard.occupyPosition                        = true;
            interactableSpawnCard.eliteRules                            = SpawnCard.EliteRules.Default;
            interactableSpawnCard.orientToFloor                         = false;
            interactableSpawnCard.slightlyRandomizeOrientation          = false;
            interactableSpawnCard.skipSpawnWhenSacrificeArtifactEnabled = false;
            interactableSpawnCard.prefab = corruptedTeleporter;
            iscCorruptedTeleporter       = interactableSpawnCard;

            Debug.Log("[CRCore3]: Created isc: " + iscCorruptedTeleporter.ToString());

            InteractableSpawnCard riftSpawnCard = ScriptableObject.CreateInstance <InteractableSpawnCard>();
            riftSpawnCard.sendOverNetwork                       = true;
            riftSpawnCard.hullSize                              = HullClassification.Human;
            riftSpawnCard.nodeGraphType                         = RoR2.Navigation.MapNodeGroup.GraphType.Ground;
            riftSpawnCard.requiredFlags                         = RoR2.Navigation.NodeFlags.TeleporterOK;
            riftSpawnCard.forbiddenFlags                        = RoR2.Navigation.NodeFlags.None;
            riftSpawnCard.directorCreditCost                    = 0;
            riftSpawnCard.occupyPosition                        = false;
            riftSpawnCard.eliteRules                            = SpawnCard.EliteRules.Default;
            riftSpawnCard.orientToFloor                         = false;
            riftSpawnCard.slightlyRandomizeOrientation          = false;
            riftSpawnCard.skipSpawnWhenSacrificeArtifactEnabled = false;
            riftSpawnCard.prefab = voidRift;
            iscVoidRift          = riftSpawnCard;

            Debug.Log("[CRCore3]: Created isc: " + riftSpawnCard.ToString());
            #endregion
            /////////
            #region PostProcessing
            voidSickEffect = new GameObject();
            voidSickEffect.SetActive(false);

            var sickCameraEffectPPBase = new GameObject();
            sickCameraEffectPPBase.transform.parent        = voidSickEffect.transform;
            sickCameraEffectPPBase.transform.localPosition = Vector3.zero;

            var sickCameraEffectPP = new GameObject();
            sickCameraEffectPP.transform.parent        = sickCameraEffectPPBase.transform;
            sickCameraEffectPP.transform.localPosition = Vector3.zero;

            var sickVolume = sickCameraEffectPP.AddComponent <PostProcessVolume>();
            sickVolume.isGlobal      = true;
            sickVolume.blendDistance = 1000;
            sickVolume.priority      = 500;
            sickVolume.weight        = 1;
            sickVolume.profile       = Assets.voidSafePPP;
            sickVolume.sharedProfile = Assets.voidSafePPP;
            sickVolume.enabled       = true;

            sickCameraEffectPP.layer = 20;
            var sickSphereCollider = sickCameraEffectPP.AddComponent <SphereCollider>();
            sickSphereCollider.center    = Vector3.zero;
            sickSphereCollider.radius    = 1;
            sickSphereCollider.isTrigger = false;

            var voidSickPPD = sickCameraEffectPP.AddComponent <PostProcessDuration>();
            voidSickPPD.enabled       = false;
            voidSickPPD.ppVolume      = sickVolume;
            voidSickPPD.maxDuration   = 0.4f;
            voidSickPPD.ppWeightCurve = new AnimationCurve();
            voidSickPPD.ppWeightCurve.AddKey(0f, 0f);
            voidSickPPD.ppWeightCurve.AddKey(0.5f, 0.75f);
            voidSickPPD.ppWeightCurve.AddKey(1f, 1f);
            voidSickPPD.ppWeightCurve.preWrapMode  = WrapMode.ClampForever;
            voidSickPPD.ppWeightCurve.postWrapMode = WrapMode.ClampForever;

            /*var voidSickPPD2 = voidSickEffect.AddComponent<PostProcessDuration>();
             * voidSickPPD2.enabled = false;
             * voidSickPPD2.ppVolume = sickVolume;
             * voidSickPPD2.maxDuration = 0.4f;
             * voidSickPPD2.ppWeightCurve = new AnimationCurve();
             * voidSickPPD2.ppWeightCurve.AddKey(1f, 1f);
             * voidSickPPD2.ppWeightCurve.AddKey(0.5f, 0.1f);
             * voidSickPPD2.ppWeightCurve.AddKey(0f, 0f);
             * voidSickPPD2.ppWeightCurve.preWrapMode = WrapMode.ClampForever;
             * voidSickPPD2.ppWeightCurve.postWrapMode = WrapMode.ClampForever;*/

            var destroyOnTimerSick = voidSickEffect.AddComponent <DestroyOnTimer>();
            destroyOnTimerSick.duration          = 0.1f;
            destroyOnTimerSick.resetAgeOnDisable = true;

            var sickCameraEffect = voidSickEffect.AddComponent <LocalCameraEffect>();
            sickCameraEffect.effectRoot = sickCameraEffectPPBase.gameObject;

            var sickTemporaryVFX = voidSickEffect.AddComponent <TemporaryVisualEffect>();
            sickTemporaryVFX.visualState        = TemporaryVisualEffect.VisualState.Enter;
            sickTemporaryVFX.enterComponents    = new MonoBehaviour[1];
            sickTemporaryVFX.enterComponents[0] = voidSickPPD;
            sickTemporaryVFX.exitComponents     = new MonoBehaviour[1];
            sickTemporaryVFX.exitComponents[0]  = destroyOnTimerSick;

            voidSickEffect.SetActive(true);
            voidSickEffect = PrefabAPI.InstantiateClone(voidSickEffect, "CRVoidSickEffect", false);
            Debug.Log("[CRCore3]: Created prefab: " + voidSickEffect.name);

            /////////////////////

            voidSafeEffect = new GameObject();
            voidSafeEffect.SetActive(false);

            var safeCameraEffectPPBase = new GameObject();
            safeCameraEffectPPBase.transform.parent        = voidSafeEffect.transform;
            safeCameraEffectPPBase.transform.localPosition = Vector3.zero;

            var safeCameraEffectPP = new GameObject();
            safeCameraEffectPP.transform.parent        = safeCameraEffectPPBase.transform;
            safeCameraEffectPP.transform.localPosition = Vector3.zero;

            var safeVolume = safeCameraEffectPP.AddComponent <PostProcessVolume>();
            safeVolume.isGlobal      = true;
            safeVolume.blendDistance = 1000;
            safeVolume.priority      = 501;
            safeVolume.weight        = 1;
            safeVolume.profile       = Assets.voidSickPPP;
            safeVolume.sharedProfile = Assets.voidSickPPP;
            safeVolume.enabled       = true;

            safeCameraEffectPP.layer = 20;
            var safeSphereCollider = safeCameraEffectPP.AddComponent <SphereCollider>();
            safeSphereCollider.center    = Vector3.zero;
            safeSphereCollider.radius    = 1;
            safeSphereCollider.isTrigger = false;

            var voidSafePPD = safeCameraEffectPP.AddComponent <PostProcessDuration>();
            voidSafePPD.enabled       = false;
            voidSafePPD.maxDuration   = 0.4f;
            voidSafePPD.ppVolume      = safeVolume;
            voidSafePPD.ppWeightCurve = new AnimationCurve();
            voidSafePPD.ppWeightCurve.AddKey(0f, 0f);
            voidSafePPD.ppWeightCurve.AddKey(0.5f, 0.75f);
            voidSafePPD.ppWeightCurve.AddKey(1f, 1f);
            voidSafePPD.ppWeightCurve.preWrapMode  = WrapMode.ClampForever;
            voidSafePPD.ppWeightCurve.postWrapMode = WrapMode.ClampForever;

            /*var voidSafePPD2 = voidSafeEffect.AddComponent<PostProcessDuration>();
             * voidSafePPD2.enabled = false;
             * voidSafePPD2.ppVolume = safeVolume;
             * voidSafePPD2.maxDuration = 0.4f;
             * voidSafePPD2.ppWeightCurve = new AnimationCurve();
             * voidSafePPD2.ppWeightCurve.AddKey(1f, 1f);
             * voidSafePPD2.ppWeightCurve.AddKey(0.5f, 0.1f);
             * voidSafePPD2.ppWeightCurve.AddKey(0f, 0f);
             * voidSafePPD2.ppWeightCurve.preWrapMode = WrapMode.ClampForever;
             * voidSafePPD2.ppWeightCurve.postWrapMode = WrapMode.ClampForever;*/

            var destroyOnTimerSafe = voidSafeEffect.AddComponent <DestroyOnTimer>();
            destroyOnTimerSafe.duration          = 0.1f;
            destroyOnTimerSafe.resetAgeOnDisable = true;

            var safeCameraEffect = voidSafeEffect.AddComponent <LocalCameraEffect>();
            safeCameraEffect.effectRoot = safeCameraEffectPPBase.gameObject;

            var safeTemporaryVFX = voidSafeEffect.AddComponent <TemporaryVisualEffect>();
            safeTemporaryVFX.visualState        = TemporaryVisualEffect.VisualState.Enter;
            safeTemporaryVFX.enterComponents    = new MonoBehaviour[1];
            safeTemporaryVFX.enterComponents[0] = voidSafePPD;
            safeTemporaryVFX.exitComponents     = new MonoBehaviour[1];
            safeTemporaryVFX.exitComponents[0]  = destroyOnTimerSafe;

            voidSafeEffect.SetActive(true);
            voidSafeEffect = PrefabAPI.InstantiateClone(voidSafeEffect, "CRVoidSafeEffect", false);
            Debug.Log("[CRCore3]: Created prefab: " + voidSafeEffect.name);
            #endregion
        }
コード例 #26
0
 public RotateLeft(RotateObject rotateObject)
 {
     this.rotateObject = rotateObject;
     rotationHistory   = new Stack <Quaternion>();
 }
コード例 #27
0
    void Start()
    {
        audioSource = GetComponent<AudioSource> ();

        rotateObject = GetComponent<RotateObject> ();
        if (!rotateObject) {
            Debug.LogError("rotate object not assigned");
        }
        objectVision = null;
    }
コード例 #28
0
ファイル: Posture.cs プロジェクト: hippogyz/mc_unity
 public float GetPhase(RotateObject sth)
 {
     return(sth.GetPhase());
 }
コード例 #29
0
ファイル: Posture.cs プロジェクト: hippogyz/mc_unity
 public void RotateTo(RotateObject sth, float targetAngle)
 {
     sth.RotateTo(targetAngle);
 }
コード例 #30
0
ファイル: Posture.cs プロジェクト: hippogyz/mc_unity
 public void RotateAngle(RotateObject sth, float angle)
 {
     sth.RotateAngle(angle);
 }
コード例 #31
0
    // Update is called once per frame
    void Update()
    {
        if (gameObject.tag == "Selected")
        {
            //move right
            if (Input.GetKeyDown(KeyCode.RightArrow))
            {
                Command move = new MoveObject(gameObject, new Vector3(1, 0, 0));

                move.Execute();
                CommandManager.Instance().addcommand(move);
            }


            //move left
            if (Input.GetKeyDown(KeyCode.LeftArrow))
            {
                Command move = new MoveObject(gameObject, new Vector3(-1, 0, 0));

                move.Execute();
                CommandManager.Instance().addcommand(move);
            }
            //move backwards
            if (Input.GetKeyDown(KeyCode.DownArrow))
            {
                Command move = new MoveObject(gameObject, new Vector3(0, 0, -1));
                move.Execute();
                CommandManager.Instance().addcommand(move);
            }
            //move forwards
            if (Input.GetKeyDown(KeyCode.UpArrow))
            {
                Command move = new MoveObject(gameObject, new Vector3(0, 0, 1));
                move.Execute();
                CommandManager.Instance().addcommand(move);
            }

            //move up
            if (Input.GetKeyDown(KeyCode.PageUp))
            {
                Command move = new MoveObject(gameObject, new Vector3(0, 1, 0));
                move.Execute();
                CommandManager.Instance().addcommand(move);
            }
            //move down
            if (Input.GetKeyDown(KeyCode.PageDown))
            {
                Command move = new MoveObject(gameObject, new Vector3(0, -1, 0));

                move.Execute();
                CommandManager.Instance().addcommand(move);
            }

            ////rotate
            //rotate left
            if (Input.GetKeyDown(KeyCode.C))
            {
                Command rotate = new RotateObject(gameObject, new Vector3(0, -90, 0));

                rotate.Execute();
                CommandManager.Instance().addcommand(rotate);
            }

            //rotate right
            if (Input.GetKeyDown(KeyCode.V))
            {
                Command rotate = new RotateObject(gameObject, new Vector3(0, 90, 0));
                rotate.Execute();
                CommandManager.Instance().addcommand(rotate);
            }

            //rotate up
            if (Input.GetKeyDown(KeyCode.B))
            {
                Command rotate = new RotateObject(gameObject, new Vector3(-90, 0, 0));
                rotate.Execute();
                CommandManager.Instance().addcommand(rotate);
            }

            //rotate down
            if (Input.GetKeyDown(KeyCode.N))
            {
                Command rotate = new RotateObject(gameObject, new Vector3(90, 0, 0));
                rotate.Execute();
                CommandManager.Instance().addcommand(rotate);
            }
        }
    }
コード例 #32
0
 void Start()
 {
     rotatePoint  = transform.parent.position;
     rotateObject = GetComponent <RotateObject>();
 }
コード例 #33
0
        internal static GameObject CreateBaseAmmoTracer(Material mainMat, Material trailMat)
        {
            GameObject obj = PrefabsCore.CreatePrefab("Standard Tracer", false);

            Transform tracerHead = new GameObject("TracerHead").transform;

            tracerHead.parent        = obj.transform;
            tracerHead.localPosition = Vector3.zero;
            tracerHead.localRotation = Quaternion.identity;
            //tracerHead.localEulerAngles = new Vector3( 0f, 90f, 0f );
            tracerHead.localScale = Vector3.one;

            Transform tracerTail = new GameObject("TracerTail").transform;

            tracerTail.parent        = obj.transform;
            tracerTail.localPosition = Vector3.zero;
            tracerTail.localRotation = Quaternion.identity;
            tracerTail.localScale    = Vector3.one;



            Transform tailRotate = new GameObject("tailRotate").transform;

            tailRotate.parent        = tracerTail;
            tailRotate.localPosition = Vector3.zero;
            tailRotate.localRotation = Quaternion.identity;
            tailRotate.localScale    = Vector3.one;

            Transform trail = new GameObject("trail").transform;

            trail.parent        = tailRotate;
            trail.localPosition = Vector3.zero;
            trail.localRotation = Quaternion.identity;
            trail.localScale    = Vector3.one;


            Transform headBeam = new GameObject("HeadBeam").transform;

            headBeam.parent           = tracerTail;
            headBeam.localPosition    = Vector3.zero;
            headBeam.localEulerAngles = new Vector3(0f, 90f, 0f);
            headBeam.localScale       = Vector3.one;

            EffectComponent effectComp = obj.AddComponent <EffectComponent>();

            Tracer tracer = obj.AddComponent <Tracer>();

            VFXAttributes vfxAtrib = obj.AddComponent <VFXAttributes>();

            Rigidbody headRb = tracerHead.AddComponent <Rigidbody>();

            Rigidbody tailRb = tracerTail.AddComponent <Rigidbody>();

            RotateObject rotator = tailRotate.AddComponent <RotateObject>();

            ParticleSystem mainPs = headBeam.AddComponent <ParticleSystem>();

            ParticleSystemRenderer mainPsr = headBeam.AddOrGetComponent <ParticleSystemRenderer>();

            ParticleSystem trailPs = trail.AddComponent <ParticleSystem>();

            ParticleSystemRenderer trailPsr = trail.AddOrGetComponent <ParticleSystemRenderer>();

            DestroyTracerOnDelay cleanup = obj.AddComponent <DestroyTracerOnDelay>();

            cleanup.delay  = 2f;
            cleanup.tracer = tracer;

            ZeroTracerLengthOverDuration zeroLength = obj.AddComponent <ZeroTracerLengthOverDuration>();

            zeroLength.tracer = tracer;

            DestroyOnTimer timer = obj.AddComponent <DestroyOnTimer>();

            timer.duration = 10f;


            effectComp.effectIndex = EffectIndex.Invalid;
            effectComp.positionAtReferencedTransform = false;
            effectComp.parentToReferencedTransform   = false;
            effectComp.applyScale      = false;
            effectComp.soundName       = null;
            effectComp.disregardZScale = false;


            tracer.startTransform = null;
            tracer.beamObject     = null;
            tracer.beamDensity    = 0f;
            tracer.speed          = 600f;
            tracer.headTransform  = tracerHead;
            tracer.tailTransform  = tracerTail;
            tracer.length         = 20f;
            tracer.reverse        = false;

            rotator.rotationSpeed = new Vector3(0f, 0f, 1440f);


            headRb.isKinematic = true;
            headRb.useGravity  = false;

            tailRb.isKinematic = true;
            tailRb.useGravity  = false;

            vfxAtrib.optionalLights          = null;
            vfxAtrib.secondaryParticleSystem = null;
            vfxAtrib.vfxIntensity            = VFXAttributes.VFXIntensity.Low;
            vfxAtrib.vfxPriority             = VFXAttributes.VFXPriority.Always;

            mainPs.PlayOnStart();
            mainPs.SetupTracerMain();
            mainPs.SetupTracerEmission();
            mainPs.SetupTracerShape();
            mainPs.SetupTracerColorOverLifetime();
            mainPs.SetupTracerSizeOverLifetime();
            mainPsr.SetupTracerRenderer(mainMat);

            ParticleSystem.VelocityOverLifetimeModule mainPsVol = mainPs.velocityOverLifetime;
            mainPsVol.enabled = false;
            ParticleSystem.LimitVelocityOverLifetimeModule mainPsLvol = mainPs.limitVelocityOverLifetime;
            mainPsLvol.enabled = false;
            ParticleSystem.InheritVelocityModule mainPsIvel = mainPs.inheritVelocity;
            mainPsIvel.enabled = false;
            ParticleSystem.ForceOverLifetimeModule mainPsFol = mainPs.forceOverLifetime;
            mainPsFol.enabled = false;
            ParticleSystem.ColorBySpeedModule mainPsCbs = mainPs.colorBySpeed;
            mainPsCbs.enabled = false;
            ParticleSystem.SizeBySpeedModule mainPsSbs = mainPs.sizeBySpeed;
            mainPsSbs.enabled = false;
            ParticleSystem.RotationOverLifetimeModule mainPsRol = mainPs.rotationOverLifetime;
            mainPsRol.enabled = false;
            ParticleSystem.RotationBySpeedModule mainPsRbs = mainPs.rotationBySpeed;
            mainPsRbs.enabled = false;
            ParticleSystem.ExternalForcesModule mainPsExt = mainPs.externalForces;
            mainPsExt.enabled = false;
            ParticleSystem.NoiseModule mainPsNoise = mainPs.noise;
            mainPsNoise.enabled = false;
            ParticleSystem.CollisionModule mainPsColl = mainPs.collision;
            mainPsColl.enabled = false;
            ParticleSystem.TriggerModule mainPsTrig = mainPs.trigger;
            mainPsTrig.enabled = false;
            ParticleSystem.SubEmittersModule mainPsSub = mainPs.subEmitters;
            mainPsSub.enabled = false;
            ParticleSystem.TextureSheetAnimationModule mainPsTex = mainPs.textureSheetAnimation;
            mainPsTex.enabled = false;
            ParticleSystem.LightsModule mainPsLigh = mainPs.lights;
            mainPsLigh.enabled = false;
            ParticleSystem.TrailModule mainPsTrail = mainPs.trails;
            mainPsTrail.enabled = false;
            ParticleSystem.CustomDataModule mainPsData = mainPs.customData;
            mainPsData.enabled = false;


            trailPs.PlayOnStart();

            trailPs.SetupTracerTrailMain();
            trailPs.SetupTracerTrailEmission();
            trailPs.SetupTracerTrailTrail();
            trailPsr.SetupTracerTrailRenderer(trailMat);

            ParticleSystem.ShapeModule trailPsShape = trailPs.shape;
            trailPsShape.enabled = false;
            ParticleSystem.VelocityOverLifetimeModule trailPsVol = trailPs.velocityOverLifetime;
            trailPsVol.enabled = false;
            ParticleSystem.LimitVelocityOverLifetimeModule trailPsLvol = trailPs.limitVelocityOverLifetime;
            trailPsLvol.enabled = false;
            ParticleSystem.InheritVelocityModule trailPsIvel = trailPs.inheritVelocity;
            trailPsIvel.enabled = false;
            ParticleSystem.ForceOverLifetimeModule trailPsFol = trailPs.forceOverLifetime;
            trailPsFol.enabled = false;
            ParticleSystem.ColorOverLifetimeModule trailPsCol = trailPs.colorOverLifetime;
            trailPsCol.enabled = false;
            ParticleSystem.ColorBySpeedModule trailPsCbs = trailPs.colorBySpeed;
            trailPsCbs.enabled = false;
            ParticleSystem.SizeOverLifetimeModule trailPsSol = trailPs.sizeOverLifetime;
            trailPsSol.enabled = false;
            ParticleSystem.SizeBySpeedModule trailPsSbs = trailPs.sizeBySpeed;
            trailPsSbs.enabled = false;
            ParticleSystem.RotationOverLifetimeModule trailPsRol = trailPs.rotationOverLifetime;
            trailPsRol.enabled = false;
            ParticleSystem.RotationBySpeedModule trailPsRbs = trailPs.rotationBySpeed;
            trailPsRbs.enabled = false;
            ParticleSystem.ExternalForcesModule trailPsExt = trailPs.externalForces;
            trailPsExt.enabled = false;
            ParticleSystem.NoiseModule trailPsNoise = trailPs.noise;
            trailPsNoise.enabled = false;
            ParticleSystem.CollisionModule trailPsColl = trailPs.collision;
            trailPsColl.enabled = false;
            ParticleSystem.TriggerModule trailPsTrig = trailPs.trigger;
            trailPsTrig.enabled = false;
            ParticleSystem.SubEmittersModule trailPsSub = trailPs.subEmitters;
            trailPsSub.enabled = false;
            ParticleSystem.TextureSheetAnimationModule trailPsTex = trailPs.textureSheetAnimation;
            trailPsTex.enabled = false;
            ParticleSystem.LightsModule trailPsLigh = trailPs.lights;
            trailPsLigh.enabled = false;
            ParticleSystem.CustomDataModule trailPsData = trailPs.customData;
            trailPsData.enabled = false;



            trail.localEulerAngles = new Vector3(90f, 0f, 0f);

            Transform trail2 = UnityEngine.Object.Instantiate <GameObject>(trail.gameObject, tailRotate).transform;

            trail2.localEulerAngles = new Vector3(-30f, -90f, 0f);

            Transform trail3 = UnityEngine.Object.Instantiate <GameObject>(trail.gameObject, tailRotate).transform;

            trail3.localEulerAngles = new Vector3(-150f, -90f, 0f);

            return(obj);
        }
コード例 #34
0
    // Use this for initialization
    void Start()
    {
        Debug.Log("Starting tutorial level");
        shownBoxAnimation = false;
        endingCenterAnimation = false;
        showingPortalAnimation = false;

        toolbox = Toolbox.Instance;
        toolbox.SetUpForLevelBegin ();

        GameObject tableObj = GameObject.Find ("Table");
        GameObject rotateMiddleObj = GameObject.Find ("Middle_Rotate");
        GameObject padlockObj = GameObject.Find ("Padlock");
        GameObject zinlockObj = GameObject.Find ("Zinlock");
        GameObject dominosaObj = GameObject.Find ("Dominosa");
        GameObject pedestal = GameObject.Find ("Pedestal");
        GameObject pedestalRotator = GameObject.Find ("Pedestal Rotator");

        gemPuzzle = tableObj.GetComponent<GemPuzzle>();
        rotateTablePuzzle = rotateMiddleObj.GetComponent<RotateObject> ();
        padlockPuzzle = padlockObj.GetComponent<PadlockPuzzle> ();
        dominosaPuzzle = dominosaObj.GetComponent<DominosaScript> ();
        zinlockPuzzle = zinlockObj.GetComponent<ZinlockScript> ();
        //pedestalPuzzle = pedestal.GetComponent<PedestalScript> ();
        //skullPuzzle = pedestalRotator.GetComponent<PedestalRotatorScript> ();

        openBox = false;
        padlockActivated = false;
        skullActivated = false;
    }