Esempio n. 1
0
    public void SetTileState(TILE_STATE state)
    {
        tileState = state;

        switch (state)
        {
        case TILE_STATE.EMPTY:
            myRenderer.material.color = c_empty;
            break;

        case TILE_STATE.BODY:
            myRenderer.material.color = c_body;
            break;

        case TILE_STATE.SCORE:
            myRenderer.material.color = c_score;
            break;

        case TILE_STATE.TRIGGER:
            myRenderer.material.color = c_trigger;
            break;

        default:
            break;
        }
    }
Esempio n. 2
0
    // 밑에 타일이 비어있어서 떨어지는 추락 모션 실행
    public void Fall(int _NewBoardX, int _NewBoardY, Vector3 _NewPosition)
    {
        IsFalling = true;                        // 떨어지는 중

        float Len = BoardY - _NewBoardY + 0.01f; // 추락 거리

        MovementSpeed = 5.0f / Len;              // 선형 보간을 이용하므로 속도를 늦춰서 같이 떨어지는 것 처럼 보이게 만든다.

        FallToX = _NewBoardX;                    // 떨어질 곳 위치
        FallToY = _NewBoardY;

        State = TILE_STATE.MOVEMENT;                        // 이동 상태로
        Tm.StartMovement(transform.position, _NewPosition); // 이동 모션 실행
    }
Esempio n. 3
0
    private TileFreeFall Tff;                 // 자유낙하 계산

    // 유니티가 매 프레임 호출
    void Update()
    {
        if (State == TILE_STATE.MOVEMENT)                       // 이동 상태면
        {
            Tm.AddTime(MovementSpeed * Time.deltaTime);         // 시간 더하기
            Tm.Update();                                        // 내부값 업데이트
            if (IsNewFallingTile == true &&
                transform.position.y < SpawnLinePosY)           // 새로 떨어지는 타일인데 다음 스폰을 요청해야 한다면
            {
                Bm.RequestSpawnNextTile(FallToX, FallToY + 1);  // 다음 스폰 요청
                IsNewFallingTile = false;                       // 더 이상 새로 떨어지는 타일이 아님
            }
            if (Tm.IsEnd())                                     // 이동이 끝났다면
            {
                if (IsFalling == true)                          // 떨어지고 있다면
                {
                    State     = TILE_STATE.STOP;                // 상태를 멈춤으로
                    IsFalling = false;                          // 떨어지지 않는 상태
                    Bm.RequestFallTile(this, FallToX, FallToY); // 모션이 완료되었고 내부값 정정 요청
                }

                if (SwapTarget != null)                   // 스왑할 대상이 있다면
                {
                    State = TILE_STATE.STOP;              // 멈추기
                    SwapTarget.Tm.SetTime(1.0f);          // 대상의 TileMovement도 강제 끝맺음 처리
                    SwapTarget.Tm.Update();               // 대상 업데이트
                    SwapTarget.State = TILE_STATE.STOP;   // 대상도 멈추기
                    Bm.RequestSwapTile(this, SwapTarget); // 모션이 완료되었고 내부값 정정 요청
                    SwapTarget.SwapTarget = null;         // 대상의 스왑 대상은 더 이상 없음
                    SwapTarget            = null;         // 스왑 대상은 더 이상 없음
                    IsSwapping            = false;        // 스왑 상태 아님

                    // 스왑 끝 매치 확인
                    Bm.FindMatch();
                    Bm.ClearMatch();
                }
            }
        }
        else if (State == TILE_STATE.FREEFALL) // 자유낙하
        {
            Tff.Update(Time.deltaTime);        // 업데이트
            if (transform.position.y <= -10)   // 화면에 안 보이는 저 아래로 떨어졌다면
            {
                Bm.RequestRecycleTile(this);   // 타일 재활용 요청
            }
        }
    }
Esempio n. 4
0
    // 상태 초기화 메서드
    public void ResetState()
    {
        State            = TILE_STATE.STOP; // 멈춤
        isMatched        = false;           // 매치되지 않음
        IsFalling        = false;           // 떨어지지 않음
        IsNewFallingTile = false;           // 새로 떨어지는 타일 아님
        SwapTarget       = null;            // 스왑 대상 없음

        if (Tm == null)                     // 객체 없으면 생성
        {
            Tm = new TileMovement(transform);
        }
        if (Tff == null) // 객체 없으면 생성
        {
            Tff = new TileFreeFall(transform);
        }
    }
Esempio n. 5
0
        public Tile(MainGame game, TILE_TYPES type, Vector2 mapPosition)
        {
            //Salvando os valores:
            mDrawDepth = 0;
            mHeight = 0;
            mMapPosition = mapPosition;
            mType = type;
            _state = TILE_STATE.NORMAL;
            _fallTimer = TimeSpan.Zero;
            _isAlmostFalling = false;

            //Carregando o sprite:
            _sprite = new Sprite(game.Content.Load<Texture2D>("Images/Tileset"), Vector2.Zero);
            _sprite.Color = Color.White;
            _sprite.Scale = 1f;

            //Calculando o RECT da imagem a ser desenhado:
            switch (type)
            {
                case TILE_TYPES.NORMAL:
                    _sprite.SpriteRect = new Rectangle(0, 0, (int)TILE_SIZE.X, (int)TILE_SIZE.Y + 6);
                    break;
                case TILE_TYPES.HEIGHT_ONE:
                    mHeight = 1;
                    _sprite.SpriteRect = new Rectangle((int)TILE_SIZE.X, 0, (int)TILE_SIZE.X, (int)TILE_SIZE.Y * 2);
                    break;
                case TILE_TYPES.HOLE:
                    _sprite.SpriteRect = new Rectangle(0, 0, (int)TILE_SIZE.X, (int)TILE_SIZE.Y + 6);
                    _sprite.Color = Color.Transparent;
                    break;
                case TILE_TYPES.SPAWN:
                    _sprite.SpriteRect = new Rectangle(0, 0, (int)TILE_SIZE.X, (int)TILE_SIZE.Y + 6);
                    _sprite.Color = Color.LightGreen;
                    break;
                case TILE_TYPES.EXIT:
                    _sprite.SpriteRect = new Rectangle(0, 0, (int)TILE_SIZE.X, (int)TILE_SIZE.Y + 6);
                    _sprite.Color = Color.Blue;
                    break;
                default:
                    mHeight = 0;
                    break;
            }
        }
Esempio n. 6
0
 void updateTiles(TILE_STATE mode)
 {
     switch(mode)
     {
         case TILE_STATE.BUILD:
             foreach(Transform t in instances)
             {
                 Transform pathQuad = t.FindChild("PathQuad");
                 if(pathQuad!= null)
                     pathQuad.renderer.material = build;
             }
             break;
         default:
             foreach (Transform t in instances)
             {
                 Transform pathQuad = t.FindChild("PathQuad");
                 if (pathQuad != null)
                     pathQuad.renderer.material = def;
             }
             break;
     }
 }
Esempio n. 7
0
    // 타일들을 매치시켜 터트릴 때 쓸 자유 낙하 모션 실행
    public void Drop()
    {
        BoardX = -1; // 탈락되어 보드 상에 좌표 배치되지 않음
        BoardY = -1;

        // 속도, 각속도 값 정하기
        float DirX = Random.Range(1, 2); // 오른쪽으로 던짐

        if (transform.position.x > 0)
        {
            DirX *= -1;                                        // 타일이 오른쪽에 있으면 왼쪽으로 던지기
        }
        Vector3 Velocity        = new Vector3(DirX, 5, -0.3f); // 선속도 벡터
        float   AngularVelocity = 360;                         // 각속도

        if (Random.Range(-1, 1) < 0)
        {
            AngularVelocity *= -1; // 회전 방향 랜덤 부여
        }
        // 자유 낙하 상태로 바꾸기
        State = TILE_STATE.FREEFALL;                  // 자유 낙하 상태
        Tff.StartFreeFall(Velocity, AngularVelocity); // 자유 낙하 시작
    }
Esempio n. 8
0
    // 스왑 모션 실행
    public void PlaySwapMotion(Tile Target)
    {
        if (!IsSwapping) // 스왑중이 아니라면
        {
            // 정지상태 확인
            if (State != TILE_STATE.STOP || Target.GetState() != TILE_STATE.STOP)
            {
                return;                                                             // 아니면 취소
            }
            IsSwapping           = true;                                            // 스왑 상태로 설정
            MovementSpeed        = 5.0f;                                            // 스왑 모션 속도 지정
            Target.MovementSpeed = 5.0f;                                            // 스왑 대상도 스왑 모션 속도 지정

            SwapTarget        = Target;                                             // 스왑 대상 지정
            Target.SwapTarget = this;                                               // 스왑 대상의 스왑 대상도 지정

            State = TILE_STATE.MOVEMENT;                                            // 이동 상태로 설정
            Tm.StartMovement(transform.position, Target.transform.position);        // 이동 시작

            Target.State = TILE_STATE.MOVEMENT;                                     // 스왑 대상도 이동 상태로 설정
            Target.Tm.StartMovement(Target.transform.position, transform.position); // 스왑 대상도 이동 시작
        }
    }
Esempio n. 9
0
        public void Fall()
        {
            //Criando o Random:
            Random rand = new Random();

            //Setando a velocidade:
            _state = TILE_STATE.FALLING;
            _speed = new Vector2(0,rand.Next(2, 6));

            //Definindo o tile como caível:
            mType = TILE_TYPES.HOLE;
        }