Exemplo n.º 1
0
    //private void OnClick(GameObject obj)
    //{

    //    ((CartoonRotate)(this.m_model)).ClockwiseRotate();

    //    Vector3 next_ang = this.transform.localEulerAngles + new Vector3(0.0f, 0.0f, -90.0f);

    //    CustomTweenRotation.Begin(this.gameObject, 0.5f, Quaternion.Euler(next_ang));

    //}

    public void Dragging(GameObject go, Vector2 delta, Vector2 pos)
    {
        Vector2 from = pos + delta;

        Vector2 local_pos;

        if (RectTransformUtility.ScreenPointToLocalPointInRectangle(this.m_rect, from, null, out local_pos))
        {
            from = local_pos;

            if (RectTransformUtility.ScreenPointToLocalPointInRectangle(this.m_rect, pos, null, out local_pos))
            {
                Vector2 to = local_pos;

                Vector3 normal     = Vector3.Cross(to, from);
                Vector3 normal_one = normal.normalized;
                Vector3 delta_ang  = new Vector3(0, 0, Vector2.Angle(from, to) * normal_one.z);

                //Debug.Log("delta ang " + delta_ang + "normal one " + normal_one.z);

                if (null != IsCanDrag)
                {
                    ENUM_ROTATE_DIR r_dir = delta_ang.z < 0.0f ? ENUM_ROTATE_DIR.E_CLOCKWISE : ENUM_ROTATE_DIR.E_ANTI_CLOCKWISE;
                    if (false == IsCanDrag(this, (CartoonRotate)this.m_model, r_dir))
                    {
                        if (CanTurnButNotChangeDir(delta_ang.z, r_dir))
                        {
                            transform.Rotate(delta_ang, Space.World);
                        }

                        return;
                    }
                }

                transform.Rotate(delta_ang, Space.World);

                ENUM_ITEM_DIRECTION next_dir = this.CalcCurDir();

                if (this.m_dir != next_dir)
                {
                    this.m_dir = next_dir;

                    if (normal_one.z < 0)
                    {
                        ((CartoonRotate)(this.m_model)).ClockwiseRotate();
                    }
                    else
                    {
                        ((CartoonRotate)(this.m_model)).AntiClockwiseRotate();
                    }
                }
            }
        }
    }
    //public void DragBegin(GameObject go, Vector2 pos)
    //{



    //}


    public void Dragging(GameObject go, Vector2 delta, Vector2 pos)
    {
        Vector2 From = pos + delta;

        Vector2 local_pos;

        if (RectTransformUtility.ScreenPointToLocalPointInRectangle(this.m_rect, From, m_cam, out local_pos))
        {
            From = local_pos;

            if (RectTransformUtility.ScreenPointToLocalPointInRectangle(this.m_rect, pos, m_cam, out local_pos))
            {
                Vector2 to = local_pos;

                Vector3 normal = Vector3.Cross(to, From);

                Vector3 delta_ang = new Vector3(0, 0, Vector2.Angle(From, to) * normal.normalized.z);

                //Debug.Log("delta ang " + delta_ang);

                if (null != IsCanDrag)
                {
                    ENUM_ROTATE_DIR r_dir = delta_ang.z < 0.0f ? ENUM_ROTATE_DIR.E_CLOCKWISE : ENUM_ROTATE_DIR.E_ANTI_CLOCKWISE;
                    if (false == IsCanDrag(this, (CartoonRotate)this.m_model, r_dir))
                    {
                        return;
                    }
                }

                transform.Rotate(delta_ang, Space.World);

                ENUM_ITEM_DIRECTION next_dir = this.CalcCurDir();

                if (this.m_dir != next_dir)
                {
                    this.m_dir = next_dir;

                    if (null != OnDragging)
                    {
                        OnDragging(this, (CartoonRotate)this.m_model);
                    }
                }
            }
        }
    }
Exemplo n.º 3
0
    private bool CanTurnButNotChangeDir(float delta_ang_, ENUM_ROTATE_DIR turn_dir_)
    {
        float next_ang = CalcCurAng() + delta_ang_;

        ENUM_ITEM_DIRECTION cur_dir = this.CalcCurDir();

        switch (cur_dir)
        {
        case ENUM_ITEM_DIRECTION.E_DOWN:
            if (ENUM_ROTATE_DIR.E_CLOCKWISE == turn_dir_)
            {
                if (90.0f <= next_ang && next_ang <= 135.0f)
                {
                    return(true);
                }
            }
            else
            {
                if (45.0f <= next_ang && next_ang <= 90.0f)
                {
                    return(true);
                }
            }
            break;

        case ENUM_ITEM_DIRECTION.E_LEFT:
            if (ENUM_ROTATE_DIR.E_CLOCKWISE == turn_dir_)
            {
                if (0.0f <= next_ang && next_ang <= 45.0f)
                {
                    return(true);
                }
            }
            else
            {
                if (315.0f <= next_ang && next_ang <= 360.0f)
                {
                    return(true);
                }
            }
            break;

        case ENUM_ITEM_DIRECTION.E_RIGHT:
            if (ENUM_ROTATE_DIR.E_CLOCKWISE == turn_dir_)
            {
                if (180.0f <= next_ang && next_ang <= 225.0f)
                {
                    return(true);
                }
            }
            else
            {
                if (135.0f <= next_ang && next_ang <= 180.0f)
                {
                    return(true);
                }
            }
            break;

        case ENUM_ITEM_DIRECTION.E_UP:
            if (ENUM_ROTATE_DIR.E_CLOCKWISE == turn_dir_)
            {
                if (270.0f <= next_ang && next_ang <= 315.0f)
                {
                    return(true);
                }
            }
            else
            {
                if (225.0f <= next_ang && next_ang <= 270.0f)
                {
                    return(true);
                }
            }
            break;
        }

        return(false);
    }
Exemplo n.º 4
0
        //private bool CanDrag(CartoonLongRotateView view_, CartoonRotate model_, ENUM_ROTATE_DIR r_dir_)
        //{

        //    switch (view_.m_dir)
        //    {
        //        case ENUM_ITEM_DIRECTION.E_LEFT:
        //            {
        //                switch (r_dir_)
        //                {
        //                    case ENUM_ROTATE_DIR.E_CLOCKWISE:
        //                        {
        //                            //up
        //                            return JudgeCanDrag(view_.Item_index, model_.m_width_unit, ENUM_ITEM_DIRECTION.E_UP);
        //                        }
        //                    case ENUM_ROTATE_DIR.E_ANTI_CLOCKWISE:
        //                        {
        //                            //down
        //                            return JudgeCanDrag(view_.Item_index, model_.m_width_unit, ENUM_ITEM_DIRECTION.E_DOWN);
        //                        }
        //                }
        //            }
        //            break;
        //        case ENUM_ITEM_DIRECTION.E_UP:
        //            {
        //                switch (r_dir_)
        //                {
        //                    case ENUM_ROTATE_DIR.E_CLOCKWISE:
        //                        {
        //                            //right
        //                            return JudgeCanDrag(view_.Item_index, model_.m_width_unit, ENUM_ITEM_DIRECTION.E_RIGHT);
        //                        }
        //                    case ENUM_ROTATE_DIR.E_ANTI_CLOCKWISE:
        //                        {
        //                            //left
        //                            return JudgeCanDrag(view_.Item_index, model_.m_width_unit, ENUM_ITEM_DIRECTION.E_LEFT);
        //                        }
        //                }
        //            }
        //            break;
        //        case ENUM_ITEM_DIRECTION.E_RIGHT:
        //            {
        //                switch (r_dir_)
        //                {
        //                    case ENUM_ROTATE_DIR.E_CLOCKWISE:
        //                        {
        //                            //down
        //                            return JudgeCanDrag(view_.Item_index, model_.m_width_unit, ENUM_ITEM_DIRECTION.E_DOWN);
        //                        }
        //                    case ENUM_ROTATE_DIR.E_ANTI_CLOCKWISE:
        //                        {
        //                            //up
        //                            return JudgeCanDrag(view_.Item_index, model_.m_width_unit, ENUM_ITEM_DIRECTION.E_UP);
        //                        }
        //                }
        //            }
        //            break;
        //        case ENUM_ITEM_DIRECTION.E_DOWN:
        //            {
        //                switch (r_dir_)
        //                {
        //                    case ENUM_ROTATE_DIR.E_CLOCKWISE:
        //                        {
        //                            //left
        //                            return JudgeCanDrag(view_.Item_index, model_.m_width_unit, ENUM_ITEM_DIRECTION.E_LEFT);
        //                        }
        //                    case ENUM_ROTATE_DIR.E_ANTI_CLOCKWISE:
        //                        {
        //                            //right
        //                            return JudgeCanDrag(view_.Item_index, model_.m_width_unit, ENUM_ITEM_DIRECTION.E_RIGHT);
        //                        }
        //                }
        //            }
        //            break;

        //    }

        //    return false;
        //}


        private bool CanDrag(CartoonLongRotateView view_, CartoonRotate model_, ENUM_ROTATE_DIR r_dir_)
        {
            switch (view_.m_dir)
            {
            case ENUM_ITEM_DIRECTION.E_LEFT:
            {
                switch (r_dir_)
                {
                case ENUM_ROTATE_DIR.E_CLOCKWISE:
                {
                    //up
                    return(JudgeCanDrag(view_, ENUM_ITEM_DIRECTION.E_UP));
                }

                case ENUM_ROTATE_DIR.E_ANTI_CLOCKWISE:
                {
                    //down
                    return(JudgeCanDrag(view_, ENUM_ITEM_DIRECTION.E_DOWN));
                }
                }
            }
            break;

            case ENUM_ITEM_DIRECTION.E_UP:
            {
                switch (r_dir_)
                {
                case ENUM_ROTATE_DIR.E_CLOCKWISE:
                {
                    //right
                    return(JudgeCanDrag(view_, ENUM_ITEM_DIRECTION.E_RIGHT));
                }

                case ENUM_ROTATE_DIR.E_ANTI_CLOCKWISE:
                {
                    //left
                    return(JudgeCanDrag(view_, ENUM_ITEM_DIRECTION.E_LEFT));
                }
                }
            }
            break;

            case ENUM_ITEM_DIRECTION.E_RIGHT:
            {
                switch (r_dir_)
                {
                case ENUM_ROTATE_DIR.E_CLOCKWISE:
                {
                    //down
                    return(JudgeCanDrag(view_, ENUM_ITEM_DIRECTION.E_DOWN));
                }

                case ENUM_ROTATE_DIR.E_ANTI_CLOCKWISE:
                {
                    //up
                    return(JudgeCanDrag(view_, ENUM_ITEM_DIRECTION.E_UP));
                }
                }
            }
            break;

            case ENUM_ITEM_DIRECTION.E_DOWN:
            {
                switch (r_dir_)
                {
                case ENUM_ROTATE_DIR.E_CLOCKWISE:
                {
                    //left
                    return(JudgeCanDrag(view_, ENUM_ITEM_DIRECTION.E_LEFT));
                }

                case ENUM_ROTATE_DIR.E_ANTI_CLOCKWISE:
                {
                    //right
                    return(JudgeCanDrag(view_, ENUM_ITEM_DIRECTION.E_RIGHT));
                }
                }
            }
            break;
            }

            return(false);
        }
Exemplo n.º 5
0
        private bool CanTurnAround(CartoonSquareRotateView view_, CartoonRotate model_, ENUM_ROTATE_DIR r_dir_)
        {
            int pre_idx = view_.Item_index - 1;

            while (pre_idx > 0)
            {
                if (this.m_anchor_positions[pre_idx].cur_ocuppied_cartoon_item_id != model_.m_item_id)
                {
                    //发现了前面的块

                    int          path      = 0;
                    CartoonFixed pre_model = this.m_cartoon.m_cartoon_items[this.m_anchor_positions[pre_idx].cur_ocuppied_cartoon_item_id];

                    List <int> pre_video_exits = new List <int>();
                    pre_video_exits.AddRange(pre_model.Video_entrance_2_exit.Values);
                    List <int> pre_door_indexes = pre_model.DoorIndexCopy;

                    List <int> cur_video_entrances = new List <int>();
                    cur_video_entrances.AddRange(model_.Video_entrance_2_exit.Keys);
                    List <int> cur_door_indexes = model_.DoorIndexCopy;

                    if (ENUM_ROTATE_DIR.E_CLOCKWISE == r_dir_)
                    {
                        CartoonUtil.ClockwiseRotate(cur_door_indexes);
                    }
                    else
                    {
                        CartoonUtil.AntiClockwiseRotate(cur_door_indexes);
                    }

                    //前一个块,有向右的出口3, 4 则本块8,7位必须有视频
                    //右侧两出口
                    int pre_right_out_3 = pre_door_indexes[2];
                    int pre_right_out_4 = pre_door_indexes[3];
                    if (pre_video_exits.Contains(pre_right_out_3))
                    {
                        //前一个块,有出口3
                        //检查本块是否有入口8的视频
                        int cur_left_in_8 = cur_door_indexes[7];
                        if (cur_video_entrances.Contains(cur_left_in_8))
                        {
                            ++path;
                        }
                    }
                    if (pre_video_exits.Contains(pre_right_out_4))
                    {
                        //前一个块,有出口4
                        //检查本块是否有入口7的视频
                        int cur_left_in_7 = cur_door_indexes[6];
                        if (cur_video_entrances.Contains(cur_left_in_7))
                        {
                            ++path;
                        }
                    }

                    //前一个块,有向上的出口1,2 则本块6,5位必须有视频

                    //上方两出口
                    int pre_up_out_1 = pre_door_indexes[0];
                    int pre_up_out_2 = pre_door_indexes[1];
                    if (pre_video_exits.Contains(pre_up_out_1))
                    {
                        //前一个块,有出口3
                        //检查本块是否有入口8的视频
                        int cur_down_in_6 = cur_door_indexes[5];
                        if (cur_video_entrances.Contains(cur_down_in_6))
                        {
                            ++path;
                        }
                    }
                    if (pre_video_exits.Contains(pre_up_out_2))
                    {
                        //前一个块,有出口4
                        //检查本块是否有入口7的视频
                        int cur_down_in_5 = cur_door_indexes[4];
                        if (cur_video_entrances.Contains(cur_down_in_5))
                        {
                            ++path;
                        }
                    }

                    //前一个块,有向下的出口6, 5 则本块1,2位必须有视频

                    //下方两出口
                    int pre_down_out_6 = pre_door_indexes[5];
                    int pre_down_out_5 = pre_door_indexes[4];
                    if (pre_video_exits.Contains(pre_down_out_6))
                    {
                        //前一个块,有出口3
                        //检查本块是否有入口8的视频
                        int cur_up_in_1 = cur_door_indexes[0];
                        if (cur_video_entrances.Contains(cur_up_in_1))
                        {
                            ++path;
                        }
                    }
                    if (pre_video_exits.Contains(pre_down_out_5))
                    {
                        //前一个块,有出口4
                        //检查本块是否有入口7的视频
                        int cur_up_in_2 = cur_door_indexes[1];
                        if (cur_video_entrances.Contains(cur_up_in_2))
                        {
                            ++path;
                        }
                    }

                    return(path > 0);
                }

                --pre_idx;
            }



            return(true);
        }