コード例 #1
0
    public void RemoveElement(PuzzleElement element)
    {
        PuzzleContainer container      = puzzle.GetElementContainer(element);
        ContainerFront  containerFront = null;

        foreach (ContainerFront current in nodes)
        {
            if (current.container == container)
            {
                containerFront = current;
            }
        }
        foreach (ContainerFront current in edges)
        {
            if (current.container == container)
            {
                containerFront = current;
            }
        }
        if (containerFront == null)
        {
            return;
        }

        containerFront.SetElement(null);
    }
コード例 #2
0
ファイル: Puzzle.cs プロジェクト: aureliendrouet/puzzlegraph
    public void CheckIsGoal(PuzzleStateNode node)
    {
        bool anyPlayers       = false;
        bool allPlayersInGoal = true;

        foreach (PuzzleItem item in items)
        {
            PuzzlePlayer player = item as PuzzlePlayer;
            if (player == null)
            {
                continue;
            }
            anyPlayers = true;
            PuzzleElement element = player.GetNode(this, node.state).element;
            if (element == null || !(element is PuzzleGoal))
            {
                allPlayersInGoal = false;
            }
        }
        node.goal = false;
        if (anyPlayers && allPlayersInGoal)
        {
            node.goal = true;
            if (goalPathSteps > 0)
            {
                goalPathSteps = Math.Min(goalPathSteps, node.step);
            }
            else
            {
                goalPathSteps = node.step;
            }
            goalStates++;
        }
    }
コード例 #3
0
 public void ClearInfo()
 {
     if (m_Transform is Transform)
     {
         m_Transform     = null;
         m_PuzzleElement = null;
     }
 }
コード例 #4
0
ファイル: Puzzle.cs プロジェクト: aureliendrouet/puzzlegraph
    public void SetElementValue(PuzzleState state, PuzzleElement element, object value)
    {
        int index = dynamicElements.IndexOf(element);

        if (index < 0)
        {
            return;
        }
        state.elementValues[index] = value;
    }
コード例 #5
0
ファイル: Puzzle.cs プロジェクト: aureliendrouet/puzzlegraph
    public object GetElementValue(PuzzleState state, PuzzleElement element)
    {
        int index = dynamicElements.IndexOf(element);

        if (index < 0)
        {
            return(null);
        }
        return(state.elementValues[index]);
    }
コード例 #6
0
 public bool ContainsKey(PuzzleElement key)
 {
     foreach (InteractionObject io in StoredItems)
     {
         if (io.m_PuzzleElement == key)
         {
             return(true);
         }
     }
     return(false);
 }
コード例 #7
0
ファイル: Puzzle.cs プロジェクト: aureliendrouet/puzzlegraph
    public void RemoveElement(PuzzleElement element)
    {
        // Remove receivers from this node.
        PuzzleNode node = GetElementContainer(element) as PuzzleNode;

        if (node != null)
        {
            for (int i = node.receiverElements.Count - 1; i >= 0; i--)
            {
                RemoveReceiver(node, node.receiverElements[i]);
            }
        }

        // Do callback first so it can perform proper lookup in puzzle
        removeElement(element);

        // Remove element from edges and nodes
        for (int i = 0; i < edges.Count; i++)
        {
            if (edges[i].element == element)
            {
                edges[i].element = null;
            }
        }
        for (int i = 0; i < nodes.Count; i++)
        {
            if (nodes[i].element == element)
            {
                nodes[i].element = null;
            }
        }
        PuzzleReceiverElement receiverElement = element as PuzzleReceiverElement;

        if (receiverElement != null)
        {
            for (int i = 0; i < nodes.Count; i++)
            {
                if (nodes[i].receiverElements.Contains(receiverElement))
                {
                    RemoveReceiver(nodes[i], receiverElement);
                }
            }
        }

        // Remove element
        if (element.dynamic)
        {
            dynamicElements.Remove(element);
        }
        else
        {
            staticElements.Remove(element);
        }
    }
コード例 #8
0
ファイル: Puzzle.cs プロジェクト: aureliendrouet/puzzlegraph
 public void AddElement(PuzzleElement element)
 {
     if (element.dynamic)
     {
         dynamicElements.Add(element);
     }
     else
     {
         staticElements.Add(element);
     }
     addElement(element);
 }
コード例 #9
0
 void EvaluateLaserTrap(PuzzleElement puzzleElement)
 {
     if (!puzzleElement.isActiveAndEnabled)
     {
         currentItem++;
         return;
     }
     else
     {
         currentItem--;
     }
 }
コード例 #10
0
    //----------------------------------------------------------------------------------------------------------------------------------------------------------
    // Generate puzzle-pieces textures and order them in puzzleGrid
    Vector2 GeneratePuzzlePieces(int _cols, int _rows, Texture2D _subElement, int _elementBaseSize, Texture2D _image)
    {
        int top, left, bottom, right;

        // Calculate piece aspect-ratio accordingly to image size
        Vector2 elementSizeRatio = new Vector2(_image.width / (float)_cols / elementBaseSize, _image.height / (float)_rows / _elementBaseSize);


        // Prepare sub-element variants
        Color[] subElementPixels = _subElement.GetPixels();
        Color[] topPixels        = subElementPixels;
        Color[] leftPixels       = TextureUtility.Rotate90(subElementPixels, _subElement.width, _subElement.height, false);


        // Generation
        for (int y = 0; y < _rows; y++)
        {
            for (int x = 0; x < _cols; x++)
            {
                EditorUtility.DisplayProgressBar("Step 1/4", "Generating textures...", (y * _cols + x) / (_rows * _cols + 0.1f));

                // Calculate shape - which type/variant of sub-elements should be  used for top/left/bottom/right parts of piece (accordingly to shapes of surrounding puzzle-pieces)
                //	(0 - flat, 1-convex, 2-concave)
                top    = y > 0            ?  -puzzleGrid[((y - 1) * _cols + x)].bottom  :  0;
                left   = x > 0            ?  -puzzleGrid[(y * _cols + x - 1)].right     :  0;
                bottom = y < (_rows - 1)  ?  Random.Range(-1, 1) * 2 + 1  :  0;
                right  = x < (_cols - 1)  ?  Random.Range(-1, 1) * 2 + 1  :  0;


                // Prepare element mask
                puzzleGrid[y * _cols + x] = new PuzzleElement(
                    top, left, bottom, right,
                    _elementBaseSize,
                    _subElement,
                    topPixels, leftPixels
                    );

                // Extract and mask image-piece to be used as puzzle-piece texture
                puzzleGrid[y * _cols + x].texture = ExtractFromImage(_image, puzzleGrid[y * _cols + x], x, y, _elementBaseSize, elementSizeRatio);

                // Set pivot to Left-Top corner of puzzle-piece base
                puzzleGrid[y * _cols + x].pivot = new Vector2(
                    ((float)puzzleGrid[y * _cols + x].pixelOffset.x / puzzleGrid[y * _cols + x].texture.width * elementSizeRatio.x),
                    (1.0f - (float)puzzleGrid[y * _cols + x].pixelOffset.y / puzzleGrid[y * _cols + x].texture.height * elementSizeRatio.y)
                    );
            }
        }


        return(elementSizeRatio);
    }
コード例 #11
0
ファイル: SC_PuzzelGame.cs プロジェクト: Tlmalesa/Puzzle-Game
 void OnGUI()
 {
     GUI.Label(new Rect(5, 5, 400, 25), "Score:" + score.ToString());
     for (int x = 0; x < columns.Count; x++)
     {
         for (int y = 0; y < columns[x].Count; y++)
         {
             if (columns[x][y].texture)
             {
                 columns[x][y].position = Vector2.Lerp(columns[x][y].position, new Vector2((Screen.width / 2 - (columns.Count * 64) / 2) + x * 64, (Screen.height / 2 - (columns[x].Count * 64) / 2) + y * 64), Time.deltaTime * 7);
                 Rect elementRect = new Rect(columns[x][y].position.x, columns[x][y].position.y, 64, 64);
                 if ((x == selectedColumn && (y == selectedRow - 1 || y == selectedRow + 1)) || ((x == selectedColumn - 1 || x == selectedColumn + 1) && y == selectedRow))
                 {
                     if (GUI.Button(elementRect, columns[x][y].texture))
                     {
                         //switching a puzzle elements
                         PuzzleElement tempElement = columns[x][y];
                         columns[x][y] = columns[selectedColumn][selectedRow];
                         columns[selectedColumn][selectedRow] = tempElement;
                         selectedColumn = -1;
                         selectedRow    = -1;
                         StopCoroutine(DetectCombos());
                         StartCoroutine(DetectCombos());
                     }
                 }
                 else
                 {
                     if (elementRect.Contains(Event.current.mousePosition))
                     {
                         GUI.enabled = false;
                         if (Input.GetMouseButtonDown(0))
                         {
                             selectedColumn = x;
                             selectedRow    = y;
                         }
                     }
                     if (x == selectedColumn && y == selectedRow)
                     {
                         GUI.enabled = false;
                     }
                     GUI.Box(elementRect, columns[x][y].texture);
                 }
                 GUI.enabled = true;
             }
         }
     }
 }
コード例 #12
0
    public void AddStates(Puzzle puzzle, PuzzleStateNode parent, PuzzleNode nodeA, PuzzleNode nodeB, bool forward)
    {
        PuzzleState   state = parent.state;
        PuzzleState   next;
        PuzzleElement e = elementNotNull;
        PuzzleElement n = nodeB.elementNotNull;

        foreach (PuzzleItem player in puzzle.GetItemsInNode <PuzzlePlayer> (state, nodeA))
        {
            // Walk
            if (e.CanWalk(puzzle, state, nodeA, nodeB, forward) && n.CanWalk(puzzle, state, nodeA, nodeB, forward))
            {
                next = parent.CloneAndAddChild("Go here", nodeB).state;
                player.SetNode(puzzle, next, nodeB);
            }

            // Take or push ball
            List <PuzzleBall> balls = puzzle.GetItemsInNode <PuzzleBall> (state, nodeA);
            if (balls.Count > 0)
            {
                PuzzleBall ball = balls[0];
                if (e.CanTakeBall(puzzle, state, nodeA, nodeB, forward) && n.CanTakeBall(puzzle, state, nodeA, nodeB, forward))
                {
                    next = parent.CloneAndAddChild("Bring ball here", nodeB).state;
                    player.SetNode(puzzle, next, nodeB);
                    ball.SetNode(puzzle, next, nodeB);
                }
                if (e.CanPushBall(puzzle, state, nodeA, nodeB, forward) && n.CanPushBall(puzzle, state, nodeA, nodeB, forward))
                {
                    next = parent.CloneAndAddChild("Push ball here", nodeB).state;
                    ball.SetNode(puzzle, next, nodeB);
                }
            }

            // Hit toggle at other end
            if (e.CanSee(puzzle, state, nodeA, nodeB, forward) && n.CanSee(puzzle, state, nodeA, nodeB, forward))
            {
                PuzzleToggle toggle = nodeB.element as PuzzleToggle;
                if (toggle != null)
                {
                    next = parent.CloneAndAddChild("Shoot toggle", nodeB).state;
                    nodeB.TriggerToggle(puzzle, next);
                }
            }
        }
    }
コード例 #13
0
ファイル: Puzzle.cs プロジェクト: aureliendrouet/puzzlegraph
    // Editing API

    public PuzzleContainer GetElementContainer(PuzzleElement element)
    {
        foreach (PuzzleNode node in nodes)
        {
            if (node.element == element)
            {
                return(node);
            }
        }
        foreach (PuzzleEdge edge in edges)
        {
            if (edge.element == element)
            {
                return(edge);
            }
        }
        return(null);
    }
コード例 #14
0
    private ElementData GetElementData()
    {
        PuzzleElement element = container.element;

        if (element == null)
        {
            return(null);
        }
        System.Type type = element.GetType();
        foreach (var elem in elements)
        {
            if (elem.type == type)
            {
                return(elem);
            }
        }
        return(null);
    }
コード例 #15
0
    void EvaluatePressurePlate(PuzzleElement puzzleElement)
    {
        var pressurePlate = puzzleElement.GetRootGameObject().GetComponent <PressurePlate>();

        if (pressurePlate.ToggledState)
        {
            currentItem++;
            return;
        }

        /*if (Vector3.Distance(pressurePlate.transform.position, transform.position) > 0.3f)
         * {
         *  transform.LookAt(pressurePlate.transform.position);
         *  transform.position = Vector3.Lerp(transform.position, pressurePlate.transform.position, 0.01f);
         * }*/

        nav.SetDestination(pressurePlate.transform.position);
    }
コード例 #16
0
    //----------------------------------------------------------------------------------------------------------------------------------------------------------
    // Extract and mask image-piece to be used as puzzle-piece texture
    Texture2D ExtractFromImage(Texture2D _image, PuzzleElement _puzzlElement, int _x, int _y, int _elementBaseSize, Vector2 _elementSizeRatio)
    {
        // Get proper piece of image
        Color[] pixels = _image.GetPixels(
            (int)((_x * _elementBaseSize - _puzzlElement.pixelOffset.x) * _elementSizeRatio.x),
            (int)(_image.height - (_y + 1) * _elementBaseSize * _elementSizeRatio.y - _puzzlElement.pixelOffset.height * _elementSizeRatio.y),
            (int)(_puzzlElement.maskWidth * _elementSizeRatio.x),
            (int)(_puzzlElement.maskHeight * _elementSizeRatio.y)
            );

        Texture2D result = new Texture2D(
            (int)(_puzzlElement.maskWidth * _elementSizeRatio.x),
            (int)(_puzzlElement.maskHeight * _elementSizeRatio.y)
            );

        // Apply mask
        result.wrapMode = TextureWrapMode.Clamp;
        _puzzlElement.ApplyMask(pixels, ref result);

        return(result);
    }
コード例 #17
0
    //----------------------------------------------------------------------------------------------------------------------------------------------------------
    // Generates example puzzle-piece/ to be shown as preview in Editor window
    Texture2D GenerateExamplePiece(Texture2D _subElement, int _elementBaseSize)
    {
        PuzzleElement puzzlePiece;

        // Calculate randomly which sub-element variants should be used
        int top    = Random.Range(-1, 1) * 2 + 1;
        int left   = Random.Range(-1, 1) * 2 + 1;
        int bottom = Random.Range(-1, 1) * 2 + 1;
        int right  = Random.Range(-1, 1) * 2 + 1;


        // Prepare sub-element variants
        Color[] subElementPixels = _subElement.GetPixels();
        Color[] topPixels        = subElementPixels;
        Color[] leftPixels       = TextureUtility.Rotate90(subElementPixels, _subElement.width, _subElement.height, false);


        // Prepare element mask
        puzzlePiece = new PuzzleElement
                      (
            top, left, bottom, right,
            _elementBaseSize,
            _subElement,
            topPixels, leftPixels
                      );

        // Create resultTexture
        puzzlePiece.texture = new Texture2D(puzzlePiece.maskWidth, puzzlePiece.maskHeight);

        Color[] piecePreviewColor = new Color [puzzlePiece.maskWidth * puzzlePiece.maskHeight];
        for (int i = 0; i < piecePreviewColor.Length; i++)
        {
            piecePreviewColor[i] = Color.black;
        }

        puzzlePiece.ApplyMask(piecePreviewColor, ref puzzlePiece.texture);


        return(puzzlePiece.texture);
    }
コード例 #18
0
    public void SetElement(PuzzleElement element)
    {
        PuzzleBoolElement boolElement = element as PuzzleBoolElement;

        if (boolElement != null)
        {
            boolElement.updateState -= UpdateState;
            boolElement.updateState += UpdateState;
        }
        if (element == null)
        {
            staticSprite.sprite  = null;
            dynamicSprite.sprite = null;
            lineSprite.sprite    = defaultLineImage;
            fillSprite.sprite    = defaultFillImage;

            if (staticSprite.GetComponent <Collider>())
            {
                staticSprite.GetComponent <Collider>().enabled = false;
            }
        }
        else
        {
            ElementData elem = GetElementData();
            staticSprite.sprite = elem.imageStatic;
            bool state = false;
            if (boolElement != null)
            {
                state = boolElement.defaultOn;
            }
            SetState(state);
            lineSprite.sprite = (elem.imageLine != null ? elem.imageLine : defaultLineImage);
            fillSprite.sprite = (elem.imageFill != null? elem.imageFill : defaultFillImage);

            if (staticSprite.GetComponent <Collider>())
            {
                staticSprite.GetComponent <Collider>().enabled = (boolElement != null);
            }
        }
    }
コード例 #19
0
    public override void Deserialize(SerializationTool tool, string str)
    {
        string[] tokens = str.Split(new char[] { ' ' }, System.StringSplitOptions.RemoveEmptyEntries);
        int      pos    = 0;

        string[] coords = tokens[pos].Substring(4).Split(',');
        SetPosition(new Point(int.Parse(coords[0]), int.Parse(coords[1])));
        pos++;
        while (pos < tokens.Length)
        {
            if (tokens[pos].StartsWith("notify:"))
            {
                string[] receiverNames = tokens[pos].Substring(7).Split(',');
                foreach (string name in receiverNames)
                {
                    PuzzleElement receiver = tool.puzzle.dynamicElements.Find(e => e.GetName(tool) == name);
                    tool.puzzle.AddReceiver(this, receiver as PuzzleReceiverElement);
                }
            }
            pos++;
        }
    }
コード例 #20
0
    private void generateSubElements(int amount, string parent)
    {
        PuzzleElement parentObject = findElement(elements, parent);

        if (parentObject == null)
        {
            Debug.LogError("The element " + parent + " was not found");
        }
        if (amount >= 0 || parentObject.key == false)           // We must end on a key. Therefore we will continue until we find it.
        {
            objectsToSpawn.Add(parentObject.NAME);
            if (parentObject.generate.Count > 0)
            {
                // Run the function recursively again, if we are out of elements, try to find a key element so we can end the recursion.
                generateSubElements(amount - 1, amount < 0 ? findKeyElement(parentObject.generate) : findNonKeyElement(parentObject.generate));
            }
            else
            {
                if (!parentObject.key)
                {
                    Debug.LogError(parent + " which is a non-key " + parentObject.key + "element has no sub elements");
                }
                else
                {
                    Debug.LogError("The recursion ended to early. Still missing " + amount + " iterations");
                }
            }
        }
        else if (parentObject.key == true)
        {
            objectsToSpawn.Add(parentObject.NAME);
//			print ("Recursion ended");
        }
        else
        {
            Debug.LogError("This state should never be possible");
        }
    }
コード例 #21
0
ファイル: SC_PuzzelGame.cs プロジェクト: Tlmalesa/Puzzle-Game
    IEnumerator RestockEnumrator()
    {
        yield return(new WaitForSeconds(0.25f));

        for (int x = 0; x < columns.Count; x++)
        {
            for (int y = 0; y < columns[x].Count; y++)
            {
                if (!columns[x][y].texture)
                {
                    int randomElement = Random.Range(0, (elements.Length - 1) * 2);
                    if (randomElement > elements.Length - 1)
                    {
                        randomElement -= elements.Length - 1;
                    }
                    PuzzleElement element = new PuzzleElement();
                    element.texture  = elements[randomElement];
                    element.position = new Vector2((Screen.width / 2 - (totNumColumns * 64) / 2) + x * 64, (-Screen.height - (totNumRows * 64) / 2) + y * 64);
                    columns[x][y]    = element;
                }
            }
        }
        StartCoroutine(DetectCombos());
    }
コード例 #22
0
 public void PopulateInfo(PuzzleElement startingInfo)
 {
     m_PuzzleElement = startingInfo;
     m_Transform     = m_PuzzleElement.transform;
 }
コード例 #23
0
 public void PopulateInfo(Transform startingInfo)
 {
     m_Transform     = startingInfo;
     m_PuzzleElement = m_Transform.GetComponent <PuzzleElement>();
 }
コード例 #24
0
    void ContainerWindow(int id)
    {
        Rect position = GetInnerWindowRect(containerWindowRect);

        position.width  = kLargeButtonSize;
        position.height = kLargeButtonSize;

        PuzzleNode node = selected as PuzzleNode;

        ElementData[] elements = node != null ?
                                 puzzleFrontPrefab.nodePrefab.elements :
                                 puzzleFrontPrefab.edgePrefab.elements;

        // Container options
        for (int i = 0; i < elements.Length; i++)
        {
            ElementData elementData   = elements[i];
            bool        chosenElement = (selected.element != null && selected.element.GetType() == elementData.type);

            if (i % 2 == 0)
            {
                position.x = kBorder + kSpacing;
            }
            else
            {
                position.x += kLargeButtonSize + kSpacing;
            }

            if (ElementButton(position, elementData, chosenElement))
            {
                if (!chosenElement)
                {
                    if (selected.element != null)
                    {
                        puzzle.RemoveElement(selected.element);
                    }
                    PuzzleElement element = (PuzzleElement)Activator.CreateInstance(elementData.type);
                    selected.element = element;
                    puzzle.AddElement(element);
                }
                else
                {
                    puzzle.RemoveElement(selected.element);
                }
            }

            if (i % 2 == 1 || i == elements.Length - 1)
            {
                position.y += kLargeButtonSize + kSpacing;
            }
        }

        position.y += 10;

        if (selected.element != null)
        {
            var boolElement = selected.element as PuzzleBoolElement;
            if (boolElement != null)
            {
                position.x      = kBorder + kSpacing;
                position.width  = GetInnerWindowRect(containerWindowRect).width;
                position.height = 24;
                Rect pos = new Rect(position.x, position.y, position.width, 20);
                boolElement.defaultOn = GUI.Toggle(pos, boolElement.defaultOn, "Enabled");
                position.y           += 24 + kSpacing + 10;
            }
        }

        // Item options
        if (node != null)
        {
            List <PuzzleItem> itemsInNode = puzzle.GetDefaultItemsInNode(node);

            ItemData[] itemDatas = puzzleFront.itemPrefab.items;
            foreach (var data in itemDatas)
            {
                position = new Rect(kBorder + kSpacing, position.y, 32, 48);

                DrawSprite(position, data.image);

                List <PuzzleItem> itemsOfType = itemsInNode.Where(e => e.GetType() == data.type).ToList();

                position.x    += position.width + kSpacing + 1;
                position.width = 33;
                GUI.Label(position, itemsOfType.Count.ToString());

                Rect buttonRect = position;
                buttonRect.y      += 8;
                buttonRect.height -= 16;
                buttonRect.x      += buttonRect.width + kSpacing;
                GUI.enabled        = (itemsOfType.Count > 0);
                if (GUI.Button(buttonRect, "-"))
                {
                    puzzle.RemoveItem(itemsOfType[0]);
                }
                GUI.enabled = true;

                buttonRect.x += buttonRect.width + kSpacing;
                if (GUI.Button(buttonRect, "+"))
                {
                    PuzzleItem item = (PuzzleItem)Activator.CreateInstance(data.type);
                    item.defaultNode = node;
                    puzzle.AddItem(item);
                }

                position.y += 48 - 8;
            }
        }
    }
コード例 #25
0
 /// <summary>
 /// Contain removed puzzle.
 /// </summary>
 public void ContainPuzzle(PuzzleElement element)
 {
     element.gameObject.SetActive(false);
     element.transform.position = puzzleContainer.transform.position;
 }
コード例 #26
0
 void EvaluateGoalDoor(PuzzleElement puzzleElement)
 {
     nav.SetDestination(puzzleElement.transform.position);
 }