/// <summary>
 /// 부모 오브젝트로부터 자식 오브젝트를 받아와서 이벤트 바인딩 적용
 /// </summary>
 /// <param name="itemsParent">이벤트를 바인딩할 오브젝트들을 담은 부모 오브젝트</param>
 /// <param name="type">바인딩할 오브젝트 타입</param>
 private void BindItems(Transform itemsParent, DecorateType type)
 {
     for (int i = 0; i < itemsParent.childCount; i++)
     {
         BindItem(itemsParent.GetChild(i), type);
     }
 }
Example #2
0
 /// <summary>
 /// 동일한 속성을 가지는 Item 클래스 배열 생성
 /// </summary>
 /// <param name="length">배열 길이</param>
 /// <param name="type">아이템 타입(가구 or 재질)</param>
 /// <param name="subType">아이템 적용 타입(벽 or 천장 or 바닥)</param>
 /// <returns>생성한 아이템배열</returns>
 private Item[] GetItemArray(int length, Item.Type type, DecorateType subType)
 {
     Item[] _items = new Item[length];
     for (int i = 0; i < length; i++)
     {
         _items[i] = new Item(type, subType);
     }
     return(_items);
 }
Example #3
0
 internal TableDecoratorBigQueryable(IFromBigQueryable <T> parent, DecorateType type, DateTimeOffset?absoluteTime1 = null, DateTimeOffset?absoluteTime2 = null, TimeSpan?relativeTime1 = null, TimeSpan?relativeTime2 = null)
     : base(new RootBigQueryable <T>(parent.QueryContext))
 {
     this.type          = type;
     this.typedParent   = parent;
     this.absoluteTime1 = absoluteTime1;
     this.absoluteTime2 = absoluteTime2;
     this.relativeTime1 = relativeTime1;
     this.relativeTime2 = relativeTime2;
 }
        public static IStringDecorator Resolve(DecorateType decorateType)
        {
            var success = DecoratorDictionary.TryGetValue(decorateType, out var decorator);

            if (success)
            {
                return(decorator);
            }

            // このアサートがされる場合はおそらくDecoratorDictionaryへの追記漏れ
            Debug.Assert(false);

            // [異常系]
            // 登録されていないデコレータが指定された場合は
            // 何もしないデコレータを返す
            return(DecoratorDictionary.TryGetValue(DecorateType.None, out decorator)
                ? decorator
                : new NoneDecorator());
        }
    /// <summary>
    /// 해당 가구 오브젝트가 가능한 위치 범위를 벗어났는지 체크하는 함수.
    /// </summary>
    /// <param name="furniture"></param>
    /// <param name="type"></param>
    /// <param name="hit">가구와 가구가 배치된 오브젝트(ex: 벽)가 맞닿는 위치와 normal 정보</param>
    /// <returns></returns>
    bool checkFuniture(Transform furniture, DecorateType type, RaycastHit hit)
    {
        if (hit.normal == null)
        {
            return(false);
        }
        Vector3 delta = hit.normal * 0.05f;
        Vector3 p0    = hit.point;
        Vector3 dir   = -hit.normal;

        Vector3 p1 = p0 + (furniture.GetChild(1).TransformPoint(new Vector3(-0.5f, -0.5f, -0.5f)) - furniture.transform.position);
        Vector3 p2 = p0 + (furniture.GetChild(1).TransformPoint(new Vector3(-0.5f, -0.5f, 0.5f)) - furniture.transform.position);
        Vector3 p3 = p0 + (furniture.GetChild(1).TransformPoint(new Vector3(0.5f, -0.5f, -0.5f)) - furniture.transform.position);
        Vector3 p4 = p0 + (furniture.GetChild(1).TransformPoint(new Vector3(0.5f, -0.5f, 0.5f)) - furniture.transform.position);


        // position +- furniture scale*0.5 위치에 lay를 쏴서 네개 다  target에 맞으면 true
        // 벽의 경우 p1~4가 바뀜
        RaycastHit _hit1, _hit2, _hit3, _hit4;

        Physics.Raycast(p1 + delta, dir, out _hit1, 0.1f);
        Physics.Raycast(p2 + delta, dir, out _hit2, 0.1f);
        Physics.Raycast(p3 + delta, dir, out _hit3, 0.1f);
        Physics.Raycast(p4 + delta, dir, out _hit4, 0.1f);
        if (_hit1.transform == null || _hit2.transform == null || _hit3.transform == null || _hit4.transform == null)
        {
            return(false);
        }
        if (FindType(_hit1.transform) == type && _hit1.transform == _hit2.transform && _hit1.transform == _hit3.transform && _hit1.transform == _hit4.transform)
        {
            return(true);
        }
        else
        {
            return(false);
        }
    }
        //加个返回值判断下事件触发了需不要删除
        bool doEventTrigger(GameEventConfig gEvent)
        {
            bool deleteEventTrigger = true; //默认触发了就删掉, 除非触发失败或者事件可以多次触发

            if (!isEventTrigger(gEvent.eventTriggers))
            {
                return(false); //不能触发事件就返回
            }
            DecorateType eventType = gEvent.eventType;

            //Debug.Log("SceneDecorateItem::doTrigger: " + m_eDecType);
            if (eventType == DecorateType.DecType_Random)
            {
                if (null != m_lDecList && m_lDecList.Count > 0)
                {
                    int randInt = Random.Range(0, m_lDecList.Count - 1);
                    m_spRenderer.sprite = m_lDecList[randInt];
                    if (true == m_bNeedFall)
                    {
                        if (m_gColliderGo.transform.position.x <= transform.position.x)
                        {
                            m_vEulerRotation   = this.transform.localEulerAngles;
                            m_vEulerRotation.z = -90.0f;
                            this.transform.localEulerAngles = m_vEulerRotation;
                        }
                        else
                        {
                            m_vEulerRotation   = this.transform.localEulerAngles;
                            m_vEulerRotation.z = 90.0f;
                            this.transform.localEulerAngles = m_vEulerRotation;
                        }
                    }
                }
            }
            else if (eventType == DecorateType.DecType_Talk)
            {
                if (null == DialogManage.m_me)
                {
                    return(false);
                }
                else if (gEvent.eventResult > 0)
                {
                    DialogManage.m_me.StartDialogByID(gEvent.eventResult);
                }
            }
            else if (eventType == DecorateType.DecType_GetItem)
            {
                if (null == GameManager.instance)
                {
                    return(false);
                }
                else if (gEvent.eventResult > 0)
                {
                    GameManager.instance.AddItemToPlayer(gEvent.eventResult);
                }
            }
            else if (eventType == DecorateType.DecType_GameOver)
            {
                if (null == GameManager.instance)
                {
                    return(false);
                }
                else if (gEvent.eventResult > 0)
                {
                    //GameManager.instance.GameOver(); 暂时就让他自己走吧
                }
            }

            destroyTouchItem();
            if (deleteEventTrigger)
            {
                deleteEventTrigger = gEvent.isRepeat == 0; //可以重复触发的事件不能删除,不能重复触发的触发完删除
            }

            return(deleteEventTrigger);
        }
Example #7
0
 public TypeScriptGenerator WithTypeDecorator(DecorateType decorator)
 {
     _typeDecorator = decorator;
     return(this);
 }
    /// <summary>
    /// 오브젝트에 이벤트를 바인딩하는 함수.
    /// 오브젝트와 항목 선택 상태에 따라 클릭 시 선택/취소 되거나, 재질이 적용되도록 함.
    /// sliding door의 경우 애니메이션을 위해 문짝 모델을 분리하여 별도의 클릭 이벤트를 바인딩 해줌.
    /// no door의 경우 이벤트 바인딩을 하는 대신에
    /// 재질 적용릉 위해 벽지/천장/바닥 부분을 땜빵하는 Quad 모델을 Probuilder로 다시 생성함.
    /// 이때 다시 생성된 mesh들은 nodoor mesh 부모 오브젝트 아래로 들어가서 벽지 또는 바닥재가 적용될 수 있도록 바인딩한다.
    /// </summary>
    /// <param name="item">바인딩 대상 오브젝트</param>
    /// <param name="type">오브젝트 타입</param>
    private void BindItem(Transform item, DecorateType type)
    {
        if (type == DecorateType.None)
        {
            type = FindType(item);
        }
        GameObject itemObject = (type == DecorateType.Furniture ? item.parent.gameObject : item.gameObject);

        #region for door
        Transform d             = null;
        float     dir           = 0;
        Vector3   angle         = Vector3.zero;
        Vector3   localPosition = Vector3.zero;
        // Sliding Door용 X좌표.
        float defaultX = 0;
        float defaultY = 0;
        bool  isMoving = false;
        bool  isOpen = false;
        float startPos = 0, endPos = 0;
        float animationTime = 0.5f;
        float currentTime   = 0;

        if (type == DecorateType.Door)
        {
            if (type == DecorateType.Door && item.name == "NoDoor(Clone)")
            {
                GameObject mesh;
                float      area;
                mesh = MakeMesh.MakeQuad(item.GetChild(0).Find("WallL").gameObject, model.Floor.DefaultFloorMaterial, out area);
                mesh.transform.parent = nodoorMeshParent;
                nodoorMeshs.Add(mesh, area);
                mesh = MakeMesh.MakeQuad(item.GetChild(0).Find("WallR").gameObject, model.Floor.DefaultFloorMaterial, out area);
                mesh.transform.parent = nodoorMeshParent;
                nodoorMeshs.Add(mesh, area);
                mesh = MakeMesh.MakeQuad(item.GetChild(0).Find("Floor").gameObject, model.Floor.DefaultFloorMaterial, out area);
                mesh.transform.parent = nodoorMeshParent;
                nodoorMeshs.Add(mesh, area);
                mesh = MakeMesh.MakeQuad(item.GetChild(0).Find("Ceiling").gameObject, model.Floor.DefaultFloorMaterial, out area);
                mesh.transform.parent = nodoorMeshParent;
                nodoorMeshs.Add(mesh, area);
                return;
            }

            // 애니메이션과 클릭 이벤트가 적용될 문짝 오브젝트
            d             = item.GetChild(0).GetChild(0);
            d.parent      = item.transform;
            dir           = item.GetChild(0).localScale.x > 0 ? 1 : -1;
            angle         = d.eulerAngles;
            localPosition = d.localPosition;
            defaultX      = localPosition.x;
            defaultY      = angle.y;

            item.UpdateAsObservable()
            .Where(condition => isMoving)
            .Subscribe(_ =>
            {
                if (currentTime > animationTime)
                {
                    isMoving    = false;
                    currentTime = 0;
                }
                else
                {
                    currentTime  += Time.deltaTime;
                    angle.y       = Mathf.Lerp(startPos, endPos, currentTime / animationTime);
                    d.eulerAngles = angle;
                }
            });
            Destroy(item.GetComponent <BoxCollider>());
            item = item.GetComponentInChildren <MeshCollider>().transform;
        }
        #endregion

        // 오브젝트 클릭시
        if (item.GetComponent <Collider>() == null)
        {
            item.gameObject.AddComponent <MeshCollider>();
        }
        item.OnMouseDownAsObservable()
        .Where(_ => !EventSystem.current.IsPointerOverGameObject())
        .Subscribe(_ =>
        {
            if (selectedObject == null || selectedObject != itemObject)
            {
                // 처음 클릭시
                if (!selectable)
                {
                    return;
                }
                else
                {
                    Select(itemObject, type);
                }
            }
            else if (selectedObject == itemObject)
            {
                // 두번째 클릭시
                switch (type)
                {
                case DecorateType.Furniture:
                    if (!selectable)
                    {
                        SetFurniture();
                    }
                    else
                    {
                        Cancel();
                    }
                    break;

                case DecorateType.Door:
                    // 문 열기/닫기
                    isMoving = true;
                    if (!isOpen)
                    {
                        isOpen = true;
                        if (item.parent.name == "SwingDoor(Clone)")
                        {
                            startPos = defaultY;
                            endPos   = defaultY + 90 * dir;
                        }
                    }
                    else
                    {
                        isOpen = false;
                        if (item.parent.name == "SwingDoor(Clone)")
                        {
                            startPos = defaultY + 90 * dir;
                            endPos   = defaultY;
                        }
                    }
                    break;

                default:
                    if (!selectable)
                    {
                        return;
                    }
                    // 다른 경우에는 선택취소
                    Cancel();
                    break;
                }
            }
        }).AddTo(this);
    }