예제 #1
0
    public void AddSolution(SplitterSolution ssNewSpliterSolution, Vector3 v3PrevDirection, GameObject goLaser)
    {
        Color32[] clrsToSplit = new Color32[2];
        clrsToSplit[0] = ssNewSpliterSolution.clrLaserColor;
        clrsToSplit[1] = ssNewSpliterSolution.clrLaserColor;
        int iReverse = (bInvertRays) ? -1 : 1;

        ssNewSpliterSolution.tLasers = new Transform[clrsToSplit.Length];

        ssSpliterSolutions.Add(ssNewSpliterSolution);


        float fAngleInBetween = 90 * iReverse; //ANGLE_TO_SPLIT / clrsToSplit.Length;
        float fStartingAngle  = 0;             //ANGLE_TO_SPLIT + fAngleInBetween;

        for (int i = 0; i < clrsToSplit.Length; i++)
        {
            GameObject go = Instantiate(goLaser, transform.position + goLaser.GetComponent <ScenarioObject>().v3Offset - this.v3Offset, Quaternion.LookRotation(v3PrevDirection));
            go.transform.Rotate(new Vector3(0, fStartingAngle, 0), Space.Self);
            fStartingAngle += fAngleInBetween;
            go.transform.SetParent(transform);
            ssNewSpliterSolution.tLasers[i] = go.transform;
            go.GetComponent <RayLaser>().UpdateRayColor(clrsToSplit[i]);
            go.GetComponent <RayLaser>().SetCilinderActive(false);
        }
    }
예제 #2
0
    public void TryToSplit(SplitterSolution ssNewSplitterSolution, Vector3 v3PrevDirection, GameObject goLaser)
    {
        int idx = GetSolutionIndex(ssNewSplitterSolution.v3LaserDirection, ssNewSplitterSolution.clrLaserColor);

        if (idx == -1)
        {
            if (ssSpliterSolutions.Count <= MAX_SPLITTER)
            {
                AddSolution(ssNewSplitterSolution, v3PrevDirection, goLaser);
            }
        }
        else
        {
            RefreshSolution(idx);
        }
    }
예제 #3
0
    IEnumerator RedrawLaser()
    {
        //Debug.Log("Running");
        int  laserSplit     = 1;                        //How many times it got split
        int  laserReflected = 1;                        //How many times it got reflected
        int  vertexCounter  = 1;                        //How many line segments are there
        bool loopActive     = true;                     //Is the reflecting loop active?

        Vector3 laserDirection    = transform.forward;  //direction of the next laser
        Vector3 lastLaserPosition = transform.position; //origin of the next laser

        //TODO
        //mLineRenderer.positionCount

        mLineRenderer.SetVertexCount(1);
        mLineRenderer.SetPosition(0, transform.position);
        RaycastHit hit;

        while (loopActive)
        {
            bHit = Physics.Raycast(lastLaserPosition, laserDirection, out hit, laserDistance);
            if (bHit)
            {
                //print("hit.transform.gameObject.tag: " + hit.transform.gameObject.tag);
            }

            //Debug.Log("Physics.Raycast(" + lastLaserPosition + ", " + laserDirection + ", out hit , " + laserDistance + ")");

            if (bHit && ((hit.transform.gameObject.tag == MMConstants.TAG_MIRROR) || IsRayKiller(hit.transform.gameObject.tag)))
            {
                Vector3 prevDirection = laserDirection;
                laserReflected++;
                vertexCounter += 3;
                mLineRenderer.SetVertexCount(vertexCounter);
                mLineRenderer.SetPosition(vertexCounter - 3, Vector3.MoveTowards(hit.point, lastLaserPosition, 0.01f));
                mLineRenderer.SetPosition(vertexCounter - 2, hit.point);
                mLineRenderer.SetPosition(vertexCounter - 1, hit.point);
                mLineRenderer.SetWidth(.15f, .15f);
                lastLaserPosition = hit.point;
                laserDirection    = Vector3.Reflect(laserDirection, hit.normal);

                if (hit.transform.gameObject.tag == MMConstants.TAG_SPLITTER)
                {
                    SplitterSolution ss = new SplitterSolution(clrLaser, laserDirection);
                    hit.transform.GetComponent <Splitter>().TryToSplit(ss, prevDirection, this.gameObject);

                    loopActive = false;
                }
                else if (hit.transform.gameObject.tag == MMConstants.TAG_DUPLICATOR)
                {
                    SplitterSolution ss = new SplitterSolution(clrLaser, laserDirection);
                    hit.transform.GetComponent <Duplicator>().TryToSplit(ss, prevDirection, this.gameObject);

                    loopActive = false;
                }
                else if (hit.transform.gameObject.tag == MMConstants.TAG_MERGER)
                {
                    MergerSolution ms = new MergerSolution(clrLaser, laserDirection);

                    hit.transform.GetComponentInParent <Merger>().TryToMerge(ms);
                    loopActive = false;
                }
                else if (IsRayKiller(hit.transform.gameObject.tag))
                {
                    loopActive = false;
                }
            }
            else
            {
                //Debug.Log("No Bounce");
                laserReflected++;
                vertexCounter++;
                mLineRenderer.SetVertexCount(vertexCounter);
                Vector3 lastPos = lastLaserPosition + (laserDirection.normalized * laserDistance);
                //Debug.Log("InitialPos " + lastLaserPosition + " Last Pos" + lastPos);
                mLineRenderer.SetPosition(vertexCounter - 1, lastLaserPosition + (laserDirection.normalized * laserDistance));

                loopActive = false;
            }

            if (laserReflected > maxBounce)
            {
                loopActive = false;
            }

            if (bHit && hit.transform.gameObject.tag == MMConstants.TAG_RECEIVER)
            {
                if (timeSinceLastTryToSolve >= MMConstants.TIME_TO_TRYTOSOLVE_AGAIN)
                {
                    timeSinceLastTryToSolve = 0;
                    hit.transform.GetComponentInParent <Receiver>().TryToSolve(clrLaser);
                }
            }
        }

        yield return(new WaitForEndOfFrame());
    }