예제 #1
0
    // Use this for initialization
    void Awake()
    {
        //다른컴포넌트 받아오기위한 선언
        _vector = GameObject.Find("Initial").GetComponent <Initial>();
        move    = GameObject.Find("Character").GetComponent <Move>();
        ifpop   = GameObject.Find("ColorField").GetComponent <IfPopUp>();
        ft      = GameObject.Find("Map").GetComponent <FindTile>();

        if (GameObject.FindWithTag("BlinkingObstacle"))
        {
            bo = GameObject.FindWithTag("BlinkingObstacle").GetComponent <BlinkingObstacle>();
        }
        if (GameObject.FindWithTag("MovingObstacle"))
        {
            mo = GameObject.FindWithTag("MovingObstacle").GetComponent <MovingObstacle>();
        }


        startPos = GameObject.Find("Character").transform.position; //처음위치를 기억한다.
        flow     = GameObject.Find("Flow").GetComponent <RawImage>();

        if (GameObject.Find("StepText"))
        {
            StepText = GameObject.Find("StepText").GetComponent <Text>();
        }

#pragma warning disable CS0618 // 형식 또는 멤버는 사용되지 않습니다.
        stagename = Application.loadedLevelName;
#pragma warning restore CS0618 // 형식 또는 멤버는 사용되지 않습니다.
    }
예제 #2
0
 public static void ClearRoute(FindTile Route)
 {
     if (null != Route && null != Route.Tile)
     {
         Route.Tile.transform.GetChild(KeyTerm.OUTLINE_INDEX).GetComponent <SpriteRenderer>().color = new Color(0, 0, 0, 0);
         ClearRoute(Route.Previous);
     }
 }
예제 #3
0
    void Awake()
    {
        move = GameObject.Find("Character").GetComponent <Move>();
        ft   = GameObject.Find("Map").GetComponent <FindTile>();


        tileName = transform.name;
        tileNum  = Convert.ToInt32(tileName.Substring(4));
        tilePos  = transform.localPosition;

        x = tileNum / 7;
        y = tileNum % 7 - 1;
    }
예제 #4
0
    public static FindTile FlipRoute(FindTile Route)
    {
        FindTile Current = Route;
        FindTile Result  = null;

        while (null != Current)
        {
            FindTile temp = Current;
            Current       = Current.Previous;
            temp.Previous = Result;
            Result        = temp;
        }
        Result = Result.Previous;
        return(Result);
    }
예제 #5
0
파일: Move.cs 프로젝트: sungho8/StepByStep
    void Awake()
    {
#pragma warning disable CS0618 // 형식 또는 멤버는 사용되지 않습니다.
        stagename = Application.loadedLevelName;
#pragma warning restore CS0618 // 형식 또는 멤버는 사용되지 않습니다.

        rigid = GetComponent <Rigidbody>();

        //다른컴포넌트 받아오기위한 선언
        pl      = GameObject.Find("Play").GetComponent <Play>();
        _vector = GameObject.Find("Initial").GetComponent <Initial>();
        if (GameObject.Find("Score"))
        {
            sc = GameObject.Find("Score").GetComponent <Score>();
        }
        ft = GameObject.Find("Map").GetComponent <FindTile>();
        if (GameObject.FindWithTag("BlinkingObstacle"))
        {
            bo = GameObject.FindWithTag("BlinkingObstacle").GetComponent <BlinkingObstacle>();
        }
        if (GameObject.FindWithTag("MovingObstacle"))
        {
            mo = GameObject.FindWithTag("MovingObstacle").GetComponent <MovingObstacle>();
        }

        Blinkingobject = new List <GameObject>();
        Movingobject   = new List <GameObject>();
        color_list     = new List <Color>();
        tile           = new List <GameObject[]>();
        itemPos        = new Vector3[10];

        // 텍스트 설정
        if (!(stagename.Substring(0, 5) == "Guide"))
        {
            PlayText      = GameObject.Find("PlayCount").GetComponent <Text>();
            LineText      = GameObject.Find("LineCount").GetComponent <Text>();
            ForText       = GameObject.Find("ForCount").GetComponent <Text>();
            FuncText      = GameObject.Find("FuncCount").GetComponent <Text>();
            IfText        = GameObject.Find("IfCount").GetComponent <Text>();
            CodeText      = GameObject.Find("Code").GetComponent <Text>();
            bestCode      = GameObject.Find("BestCode").GetComponent <Text>();
            frequencyCode = GameObject.Find("FrequencyCode").GetComponent <Text>();
        }

        popCanvas = GameObject.Find("ClearPopUp").GetComponent <Canvas>();
    }
예제 #6
0
파일: UI.cs 프로젝트: hanzemeng/GameSqur
    void Update()
    {
        if (Input.GetKey(KeyCode.Escape))
        {
            SceneManager.LoadScene("LevelSelect");
        }
        else if (Input.GetKeyDown("e"))
        {
            Cancel();
            CurrentTurn++;
            ObjectReference.Turn.text = CurrentTurn.ToString();
            UnitManage.UpdateEvent();
            UpdateFog();
            AI.AIMove();
        }
        else if (Input.GetKeyDown("q"))
        {
            FindUnit();
        }

        if (Input.GetMouseButton(1))
        {
            Cursor.SetCursor(ResourceFile.DragCursor, Vector2.zero, CursorMode.ForceSoftware);
            DragScreen();
            Cancel();
        }
        else if (Input.GetMouseButtonUp(1))
        {
            Cursor.SetCursor(null, Vector2.zero, CursorMode.ForceSoftware);
            Check = false;
        }

        if (MoveMode)
        {
            PathFinding.ClearRoute(Route);
            if (Physics.Raycast(ObjectReference.Camera.GetComponent <Camera>().ScreenToWorldPoint(Input.mousePosition), Vector3.forward, out Hit, 11))
            {
                int MouseX = Hit.transform.parent.GetComponent <Tile>().XCor;
                int MouseY = Hit.transform.parent.GetComponent <Tile>().YCor;
                Route = PathFinding.FindPath(Selected.transform.parent.gameObject, Selected.transform.parent.gameObject, Tool.GetTile(MouseX, MouseY));
                PathFinding.DrawRoute(Route);
            }
        }
    }
예제 #7
0
    public static FindTile FindPath(GameObject Origin, GameObject Start, GameObject Finish, FindTile Previous = null)
    {
        if (Start == Finish)
        {
            Reset();
            return(Previous);
        }
        if (Previous == null)
        {
            Previous              = new FindTile();
            Previous.Previous     = new FindTile();
            Previous.Tile         = Origin;
            Previous.TileScore    = 0;
            CloseList[CloseCount] = Previous;
            CloseCount++;
        }
        else
        {
            CloseList[CloseCount] = OpenList[0];
            CloseCount++;

            for (int i = 0; i < OpenCount; i++)
            {
                OpenList[i] = OpenList[i + 1];
            }
            OpenCount--;
        }

        int StartX = Start.GetComponent <Tile>().XCor;
        int StartY = Start.GetComponent <Tile>().YCor;

        bool Check = false;

        if (Previous.Previous.Tile != Tool.GetTile(StartX, StartY - 1) && null != Tool.GetTile(StartX, StartY - 1))
        {
            FindTile Up = new FindTile();
            Up.Previous  = Previous;
            Up.Tile      = Tool.GetTile(StartX, StartY - 1);
            Up.TileScore = DistanceEstimate(Up.Tile, Finish) + DistanceEstimate(Up.Tile, Origin) + Previous.TileScore;
            for (int i = 0; i < OpenCount; i++)
            {
                if (Up.Tile == OpenList[i].Tile)
                {
                    if (OpenList[i].Previous.TileScore > Up.Previous.TileScore)
                    {
                        OpenList[i].Previous  = Up.Previous;
                        OpenList[i].TileScore = Up.TileScore;
                    }
                    Check = true;
                    break;
                }
            }
            for (int i = 0; i < CloseCount; i++)
            {
                if (Up.Tile == CloseList[i].Tile)
                {
                    Check = true;
                    break;
                }
            }
            if (!Check)
            {
                OpenList[OpenCount] = Up;
                OpenCount++;
            }
        }
        Check = false;
        if (Previous.Previous.Tile != Tool.GetTile(StartX, StartY + 1) && null != Tool.GetTile(StartX, StartY + 1))
        {
            FindTile Down = new FindTile();
            Down.Previous  = Previous;
            Down.Tile      = Tool.GetTile(StartX, StartY + 1);
            Down.TileScore = DistanceEstimate(Down.Tile, Finish) + DistanceEstimate(Down.Tile, Origin) + Previous.TileScore;
            for (int i = 0; i < OpenCount; i++)
            {
                if (Down.Tile == OpenList[i].Tile)
                {
                    if (OpenList[i].Previous.TileScore > Down.Previous.TileScore)
                    {
                        OpenList[i].Previous  = Down.Previous;
                        OpenList[i].TileScore = Down.TileScore;
                    }
                    Check = true;
                    break;
                }
            }
            for (int i = 0; i < CloseCount; i++)
            {
                if (Down.Tile == CloseList[i].Tile)
                {
                    Check = true;
                    break;
                }
            }
            if (!Check)
            {
                OpenList[OpenCount] = Down;
                OpenCount++;
            }
        }
        Check = false;
        if (Previous.Previous.Tile != Tool.GetTile(StartX - 1, StartY) && null != Tool.GetTile(StartX - 1, StartY))
        {
            FindTile Left = new FindTile();
            Left.Previous  = Previous;
            Left.Tile      = Tool.GetTile(StartX - 1, StartY);
            Left.TileScore = DistanceEstimate(Left.Tile, Finish) + DistanceEstimate(Left.Tile, Origin) + Previous.TileScore;
            for (int i = 0; i < OpenCount; i++)
            {
                if (Tool.GetTile(StartX - 1, StartY) == OpenList[i].Tile)
                {
                    if (OpenList[i].Previous.TileScore > Left.Previous.TileScore)
                    {
                        OpenList[i].Previous  = Left.Previous;
                        OpenList[i].TileScore = Left.TileScore;
                    }
                    Check = true;
                    break;
                }
            }
            for (int i = 0; i < CloseCount; i++)
            {
                if (Left.Tile == CloseList[i].Tile)
                {
                    Check = true;
                    break;
                }
            }
            if (!Check)
            {
                OpenList[OpenCount] = Left;
                OpenCount++;
            }
        }
        Check = false;
        if (Previous.Previous.Tile != Tool.GetTile(StartX + 1, StartY) && null != Tool.GetTile(StartX + 1, StartY))
        {
            FindTile Right = new FindTile();
            Right.Previous  = Previous;
            Right.Tile      = Tool.GetTile(StartX + 1, StartY);
            Right.TileScore = DistanceEstimate(Right.Tile, Finish) + DistanceEstimate(Right.Tile, Origin) + Previous.TileScore;
            for (int i = 0; i < OpenCount; i++)
            {
                if (Tool.GetTile(StartX + 1, StartY) == OpenList[i].Tile)
                {
                    if (OpenList[i].Previous.TileScore > Right.Previous.TileScore)
                    {
                        OpenList[i].Previous  = Right.Previous;
                        OpenList[i].TileScore = Right.TileScore;
                    }
                    Check = true;
                    break;
                }
            }
            for (int i = 0; i < CloseCount; i++)
            {
                if (Right.Tile == CloseList[i].Tile)
                {
                    Check = true;
                    break;
                }
            }
            if (!Check)
            {
                OpenList[OpenCount] = Right;
                OpenCount++;
            }
        }
        for (int i = 0; i < OpenCount - 1; i++)
        {
            for (int e = i + 1; e < OpenCount; e++)
            {
                if (OpenList[i].TileScore > OpenList[e].TileScore)
                {
                    FindTile temp = OpenList[e];
                    OpenList[e] = OpenList[i];
                    OpenList[i] = temp;
                }
            }
        }
        return(FindPath(Origin, OpenList[0].Tile, Finish, OpenList[0]));
    }