Beispiel #1
0
    void Start()
    {
        inputHandler = gameObject.GetComponent <InputHandler>();
        TimeSystem.GetTimeSystem().AddTimer(this);
        uiModule = GiraffeSystem.FindModule <UIModule>();

        playerCamera = gameObject.GetComponentInChildren <RaceCamera>();
        rigidbody    = gameObject.GetComponentInChildren <Rigidbody>();

        var root = GameObject.Find("Root");

        indicator = root.FindChildByName("Billboard").GetComponent <EmoticonIndicator>();
        ghost     = root.FindChildByName("Ghost");

        //inputHandler.OnUpKey = () => { AddForce(Vector3.back); };
        inputHandler.OnDownKey     = () => { AddForce(Vector3.forward); };
        inputHandler.OnLeftKey     = () => { AddForce(Vector3.left); };
        inputHandler.OnRightKey    = () => { AddForce(Vector3.right); };
        inputHandler.OnInputFinish = ProcessForce;
        inputHandler.OnSpaceDown   = TryBooster;

        // audio
        dragging = gameObject.FindChildByName("Dragging").GetComponent <AudioSource>();
        booster  = gameObject.FindChildByName("Booster").GetComponent <AudioSource>();
    }
Beispiel #2
0
 void OnTriggerEnter(Collider col)
 {
     if (col.gameObject.name != target)
     {
         return;
     }
     if (raceCamera == null)
     {
         raceCamera = transform.GetComponentInParent <RaceCamera>();
     }
     raceCamera.CameraTriggered(col);
 }
Beispiel #3
0
    public void StartCar()
    {
        isCarStopped = false;
        if (inputHandler != null)
        {
            inputHandler.enabled = true;
        }

        if (playerCamera == null)
        {
            playerCamera = gameObject.GetComponentInChildren <RaceCamera>();
        }

        playerCamera.ChangeToPlayingMode();
    }
Beispiel #4
0
 void UpdatePosition(RaceCamera camera)
 {
     if (!draftingBehind) {
         transform.position += Vector3.right * (velocity - camera.velocity) * Time.deltaTime;
     } else {
         transform.position += Vector3.right * (draftingBehind.velocity - velocity) * Time.deltaTime;
     }
 }
Beispiel #5
0
 void Scroll(RaceCamera camera)
 {
     renderer.material.mainTextureOffset -= camera.velocity * Vector2.right * Time.deltaTime * 0.0045f;
 }
Beispiel #6
0
 public void OnCameraUpdateComplete(RaceCamera camera)
 {
     CameraUpdateComplete.Invoke(camera);
 }
Beispiel #7
0
 public void Move(RaceCamera camera)
 {
     transform.position -= Vector3.right * camera.velocity * Time.deltaTime;
 }
    public void Init()
    {
        if (!GlobalState.raceCameras)
        {
            return;
        }

        if (pathManager.carPath.centerNodes.Count < 1)
        {
            return;
        }

        // Detect where to put cameras
        Vector3 prev_point = pathManager.carPath.centerNodes[0].pos;

        nodeIndexes.Add(0);
        deltaAngles.Add(0);
        distance = startIndexOffset;

        for (int i = 1; i < pathManager.carPath.centerNodes.Count; i++)
        {
            PathNode node     = pathManager.carPath.centerNodes[i];
            PathNode nextNode = pathManager.carPath.centerNodes[(i + 1) % pathManager.carPath.centerNodes.Count];

            float deltaAngle = Vector3.SignedAngle(nextNode.pos - node.pos, node.rotation * Vector3.forward, Vector3.up);
            deltaAngles.Add(deltaAngle);

            distance = Vector3.Distance(node.pos, nextNode.pos) + distance;
            if (distance > distanceBetweenCameras)
            {
                nodeIndexes.Add(i);
                prev_point = node.pos;
                distance   = 0;
            }
        }

        // Add cameras
        for (int i = 0; i < nodeIndexes.Count; i++)
        {
            int nodeIndex;
            if (i < nodeIndexes.Count - 1)
            {
                nodeIndex = ((nodeIndexes[i] + nodeIndexes[(i + 1)]) / 2) % pathManager.carPath.centerNodes.Count;
            }
            else
            {
                nodeIndex = ((nodeIndexes[nodeIndexes.Count - 1] + nodeIndexes[0] + pathManager.carPath.centerNodes.Count) / 2) % pathManager.carPath.centerNodes.Count;
            }
            float    sign       = Mathf.Sign(deltaAngles[nodeIndex]);
            PathNode node       = pathManager.carPath.centerNodes[nodeIndexes[i]];
            PathNode midNode    = pathManager.carPath.centerNodes[nodeIndex];
            Vector3  nodepos    = node.pos + node.rotation * (laneXOffset * Vector3.right);
            Vector3  midNodepos = midNode.pos + midNode.rotation * (laneXOffset * Vector3.right);


            GameObject goRaceCamChild = new GameObject(string.Format("RaceCamera {0}", i));
            goRaceCamChild.transform.SetParent(transform);
            RaceCamera cmp = goRaceCamChild.AddComponent <RaceCamera>();
            cmp.SetCameraTrigger(nodepos, node.rotation * Quaternion.AngleAxis(90, Vector3.up), new Vector3(0.1f, roadHeight, roadWidth));
            cmp.SetCam(midNodepos + midNode.rotation * (6f * sign * Vector3.right) + (cameraHeight * Vector3.up), midNodepos);
            cmp.index = i;
            cmp.camera.cullingMask = cullMask;
            raceCameras.Add(cmp);
        }

        // Enable first camera
        raceCameras[0].camera.enabled = true;

        float coverage = GetCoverage(raceCameras.ToArray(), pathManager.carPath.centerNodes.ToArray(), nodeIndexes.ToArray());

        Debug.Log(string.Format("Race cameras coverage: {0}%", coverage));
    }