Пример #1
0
    public Dictionary <Direction, Tilespace> GetNeighboringSpaces(TilePosition p)
    {
        Dictionary <Direction, Tilespace> tiles = new Dictionary <Direction, Tilespace>();

        foreach (Direction d in Enum.GetValues(typeof(Direction)))
        {
            Tilespace t = GetTilespaceInDirection(p, d);
            if (t != null)
            {
                tiles.Add(d, t);
            }
        }
        return(tiles);
    }
Пример #2
0
    void Start()
    {
        tilespace = transform.parent.GetComponent <Tilespace>();
        rotation  = 0f;
        transform.localRotation = Quaternion.identity;
        transform.localPosition = new Vector2(0, -0.025f);

        foreach (Transform child in transform)
        {
            if (child.CompareTag("Base"))
            {
                var t = child.localScale;
                t.x *= Direction;
                child.localScale = t;
            }
        }

        animator = GetComponent <Animator>();
        audio    = GetComponent <AudioSource>();
    }
Пример #3
0
    public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
    {
        // Using BeginProperty / EndProperty on the parent property means that
        // prefab override logic works on the entire property.
        EditorGUI.BeginProperty(position, label, property);

        // Draw label
        position = EditorGUI.PrefixLabel(position, label);

        // Don't make child fields be indented
        var indent = EditorGUI.indentLevel;

        EditorGUI.indentLevel = 0;

        // Calculate rects
        var xrect = new Rect(position.x, position.y, 75, position.height);
        var yrect = new Rect(position.x + 90, position.y, 75, position.height);

        EditorGUIUtility.labelWidth = 14f;

        var xprop = property.FindPropertyRelative("x");
        var yprop = property.FindPropertyRelative("y");

        // Draw fields - passs GUIContent.none to each so they are drawn without labels
        EditorGUI.PropertyField(xrect, property.FindPropertyRelative("x"), new GUIContent("X"));
        EditorGUI.PropertyField(yrect, property.FindPropertyRelative("y"), new GUIContent("Y"));

        // Set indent back to what it was
        EditorGUI.indentLevel = indent;

        if (GUI.changed)
        {
            Tilespace t     = property.serializedObject.targetObject as Tilespace;
            float     scale = t.transform.localScale.x;
            t.transform.localPosition = new Vector2(xprop.intValue * scale, yprop.intValue * scale);
        }

        EditorGUI.EndProperty();
    }
Пример #4
0
    // called every frame from context manager
    public override void HandleInput(InputPackage p)
    {
        if (!Won)
        {
            if (p.Touchdown)
            {
                if (p.TouchdownChange)
                {
                    // clicked
                    Tile t = Physics2D.OverlapCircleAll(p.MousePositionWorldSpace, 3f, tileMask)                     // roughly 1/3 of a tile of tap tolerance
                             .Select(g => g.GetComponent <Tile>())
                             .Where(g => g != null && g.Movable)
                             .OrderBy(g => Vector2.Distance(p.MousePositionWorldSpace, g.transform.position))
                             .FirstOrDefault();

                    if (t != null)
                    {
                        SelectedTile = t;
                        grabPoint    = p.MousePositionWorldSpace;
                        SelectedTile.Select(true);

                        MMVibrationManager.Haptic(HapticTypes.Selection);

                        grabMovingVelocityAverage = Vector2.zero;
                    }

                                        #if UNITY_EDITOR
                    if (ShowFingerprint)
                    {
                        Fingerprint = GetComponentInChildren <Fingerprint>(true);
                        Fingerprint.gameObject.SetActive(true);
                        Fingerprint.transform.position = p.MousePositionWorldSpace;
                    }
                                        #endif
                }
                else if (SelectedTile != null)
                {
                    grabMovingVelocityAverage = p.MousePositionWorldSpaceDelta * 0.1f + grabMovingVelocityAverage * 0.9f;

                    float     scale             = SelectedTile.transform.lossyScale.x;
                    Vector2   moveAmount        = (p.MousePositionWorldSpace - grabPoint) / scale;
                    Tilespace tileBeforeMove    = SelectedTile.Space;
                    bool      changedTilespaces = SelectedTile.TryMoveToPosition(SelectedTile.GetPositionFromInput(moveAmount), p.MousePositionWorldSpaceDelta);

                    if (changedTilespaces)
                    {
                        if (SelectedTile.Space.Sticky)
                        {
                            SelectedTile = null;
                        }
                        else
                        {
                            Vector3 move = ((Vector2)SelectedTile.transform.position - SelectedTile.PositionWhenSelected);
                            grabPoint += move;
                            if (Mathf.Abs(move.y) > Mathf.Abs(move.x) && Mathf.Abs(moveAmount.x) < 2 * Tile.BaseThreshold)
                            {
                                grabPoint.x = p.MousePositionWorldSpace.x;
                            }
                            else if (Mathf.Abs(moveAmount.y) < 2 * Tile.BaseThreshold)
                            {
                                grabPoint.y = p.MousePositionWorldSpace.y;
                            }

                            SelectedTile.Select(true);
                        }
                    }

                    if (!TimerRunning && !Won && !SelectedTile.Centered)
                    {
                        StartTimer();
                    }
                }

                Vector3 position = p.MousePositionWorldSpace + Player.Direction * -8.5f;
                if (Vector2.Distance(Player.transform.position, p.MousePositionWorldSpace) < 5)
                {
                    Preview.Show(true, position);
                    Preview.WatchedPosition = Player.transform.position;
                }
                else
                {
                    Preview.Show(false, position);
                }

                                #if UNITY_EDITOR
                if (Fingerprint != null)
                {
                    Fingerprint.transform.position = p.MousePositionWorldSpace;
                }
                                #endif
            }
            else if (!p.Touchdown && p.TouchdownChange)
            {
                Preview.Show(false);
                if (SelectedTile != null)
                {
                    Vector2 avgOnRelease = grabMovingVelocityAverage;
                    if (!SelectedTile.Centered)
                    {
                        avgOnRelease *= SelectedTile.NormalizedPosition;
                    }
                    //Debug.Log(avgOnRelease);

                    SelectedTile.SetResidualVelocity(avgOnRelease);
                    SelectedTile.Select(false);
                    SelectedTile = null;
                }

                                #if UNITY_EDITOR
                if (Fingerprint != null)
                {
                    Fingerprint.gameObject.SetActive(false);
                }
                                #endif
            }
        }
    }