Please enable JavaScript.

Coggle requires JavaScript to display documents.

Combined, _combineGoalCheckCoroutineActive, _isCombineGoalCheckCoroutineFo…

- - - - _connectionGraph[a].Add((bind,b));
        
        if (!_connectionGraph[b].Any(x => x.neighbor == a))
        
        _connectionGraph[b].Add((bind, a));
        
        if (bind > 0)
        
        a.SetIsBinded(true);
        
        b.SetIsBinded(true);

SomeGoalEatBlock

for _connectedBlocksList

for _connectionGraph of _connectedBlocksList element

                var connection = _connectionGraph[_connectedBlocksList[i]][a];

                if (connection.bind > 0)
                {
                    connection = (connection.bind - 1, connection.neighbor);
                    _connectionGraph[_connectedBlocksList[i]][a] = connection;

                    var first = _connectedBlocksList[i];
                    var second = connection.neighbor;

                    if (connection.bind > 0)
                    {
                        first.UpdateCombineBind(
                            connection.bind, second.GetJamAbstractBlock());
                        second.UpdateCombineBind(
                            connection.bind, first.GetJamAbstractBlock());
                    }
                    else
                    {
                        first.RemoveCombineVisual(second.GetJamAbstractBlock());
                        second.RemoveCombineVisual(first.GetJamAbstractBlock());

                        RemoveBindedEdge(first, second);
                    }
                }

AddConnectedBlock

_connectedBlocksList = new List<JamBlockController>();

_connectionGraph = new Dictionary<JamBlockController, List<(int, JamBlockController)>>();

_connectedBlocksList.Add(blockControllerSelf)

_connectedBlocksList.Add(blockControllerConnectedTo);

        _combineGoalCheckCoroutineActive = false;
        _isCombineGoalCheckCoroutineForTransformChecked = false;

        Destroy(blockControllerSelf.gameObject.GetComponent<Rigidbody>());
        Destroy(blockControllerConnectedTo.gameObject.GetComponent<Rigidbody>());

        RegisterConnection(bind, blockControllerSelf, blockControllerConnectedTo);

        blockControllerSelf.SetHasParentContainer(true);
        blockControllerConnectedTo.SetHasParentContainer(true);

- 3 more items...

RemoveBindedEdge

        if (_connectionGraph.ContainsKey(a))

            var connectedBlocksList = _connectionGraph[a];

            var connectionsToRemove = connectedBlocksList.Where(x => x.neighbor == b);

if (connectionsToRemove != null && connectionsToRemove.Count() > 0)

var removedList = new List<(int, JamBlockController)>();
foreach (var connectionToRemove in connectionsToRemove)
removedList.Add(connectionToRemove);
foreach (var removedElement in removedList)
_connectionGraph[a].Remove(removedElement);

if (_connectionGraph[a].Count == 0)

               a.RemoveBlockConnections(b.GetJamAbstractBlock());

                a.SetBlockMoveableAndAddRigidbody();
                a.SetIsBinded(false);

                RemoveConnectedBlock(a);
                isRemoveBlockA = true;

else

                for (int i = _connectedBlocksList.Count - 1; i >= 0; i--)
                {
                    var connectionList = _connectionGraph[_connectedBlocksList[i]];

                    for (int n = connectionList.Count - 1; n >= 0; n--)
                    {
                        if (_connectedBlocksList[i] == a
                        || connectionList[n].neighbor == b)
                        {
                            if (connectionList[n].bind > 0)
                                return false;
                        }
                    }
                }

RemoveConnectedBlock

        bool isRemovedCenterBlock = (_connectedBlocksList[0] == blockController);

        var found = _connectedBlocksList.Find(b => b == blockController);

        if (found != null)
        {
            found.OnCombineBlockSomeGoalDetectedPermissionAction -= GoalCheckForMultiBlocks;
            found.OnStopDraggingOfContainerBlockPermissionAction -= StopDraggingForMultiBlocks;
            found.OnBlockRemovingFromGridPermissionAction -= RemoveBlockFromGrid;
        }

        _connectedBlocksList.Remove(blockController);

        RemoveBlockFromGraph(blockController);

        blockController.RemoveBlockConnections();

JamGridplacementController

RemoveConnections

    private void RemoveConnections(JamAbstractBlock block1, JamAbstractBlock block2)
    {
        var jamConnectedBlockDictToList = _jamConnectedBlockDict.ToList();

        if (block2 == null)
        {
            foreach (var kv in jamConnectedBlockDictToList)
            {
                kv.Value.Remove(block1);
            }
            _jamConnectedBlockDict.Remove(block1);
            return;
        }

        var listOfEditedDictEntries = new HashSet<JamAbstractBlock>();
        foreach (var kv in jamConnectedBlockDictToList)
        {
            if (kv.Key == block1)
            {
                kv.Value.Remove(block2);
                listOfEditedDictEntries.Add(kv.Key);
            }
            if (kv.Key == block2)
            {
                kv.Value.Remove(block1);
                listOfEditedDictEntries.Add(kv.Key);
            }
        }

        foreach (var key in listOfEditedDictEntries)
        {
            if (_jamConnectedBlockDict[key] == null
                || _jamConnectedBlockDict[key].Count() == 0)
            {
                _jamConnectedBlockDict.Remove(key);
            }
        }
    }

        if (isRemovedCenterBlock)
        {
            RepositionContainer();
        }

        blockController.gameObject.transform.parent = gameObject.transform.parent;

        CheckForDisconnectedSubgraphs();

        if (_connectedBlocksList.Count == 0)
            gameObject.SetActive(false);

RepositionContainer

        if (_connectedBlocksList == null || _connectedBlocksList.Count < 1)
        {
            return;
        }

        List<Transform> children = new List<Transform>();
        List<Vector3> worldPositions = new List<Vector3>();

        foreach (Transform child in transform)
        {
            children.Add(child);
            worldPositions.Add(child.position);
        }

        transform.position = _connectedBlocksList[0].transform.position;

        for (int i = 0; i < children.Count; i++)
        {
            children[i].position = worldPositions[i];
        }

RemoveBlockFromGraph

if (_connectionGraph != null && _connectionGraph.ContainsKey(block))

var snapshot = new List<(int, JamBlockController)>(_connectionGraph[block]);

foreach (var neighbor in snapshot)

if ((ignoredBlocks == null || !ignoredBlocks.Contains(neighbor.Item2))
&& _connectionGraph.ContainsKey(neighbor.Item2))

                    neighbor.Item2.RemoveCombineVisual(block.GetJamAbstractBlock());

                    var connectionsToRemove = _connectionGraph[neighbor.Item2].Where(x => x.neighbor == block);
                    if (connectionsToRemove != null && connectionsToRemove.Count() > 0)
                    {
                        var removedList = new List<(int, JamBlockController)>();
                        foreach (var connectionToRemove in connectionsToRemove)
                            removedList.Add(connectionToRemove);

                        foreach (var removedElement in removedList)
                            _connectionGraph[neighbor.Item2].Remove(removedElement);
                    }
                }

            _connectionGraph.Remove(block);

CheckForDisconnectedSubgraphs

        var allNodes = _connectionGraph.Keys.ToHashSet();
        var snapshot = allNodes.ToDictionary(
            node => node,
            node => _connectionGraph[node]
                        .Where(e => allNodes.Contains(e.Item2))
                        .ToList()
        );

        var allComponents = new List<List<JamBlockController>>();
        var visited = new HashSet<JamBlockController>();

        foreach (var node in snapshot.Keys)
        {
            if (visited.Contains(node)) continue;
            var comp = new List<JamBlockController>();
            DFSCollect(node, comp, visited, snapshot);
            allComponents.Add(comp);
        }

        if (allComponents.Count <= 1)
            return;

        JamBlockController pivot = _connectedBlocksList.Count > 0
            ? _connectedBlocksList[0]
            : null;

        List<JamBlockController> mainComp;
        if (pivot != null
            && allComponents.Any(c => c.Contains(pivot)))
        {
            mainComp = allComponents.First(c => c.Contains(pivot));
        }
        else
        {
            mainComp = allComponents.OrderByDescending(c => c.Count).First();
        }

        var subComps = allComponents.Where(c => c != mainComp);

        _connectedBlocksList = new List<JamBlockController>(mainComp);

        _connectionGraph = mainComp.ToDictionary(
            node => node,
            node => snapshot[node].Where(n => mainComp.Contains(n.Item2)).ToList()
        );

        foreach (var comp in subComps)
        {
            var subGraph = comp.ToDictionary(
                node => node,
                node => snapshot[node].Where(n => comp.Contains(n.Item2)).ToList()
            );

            _jamGridVisualController.CreateSubgraphBlockMultipleContainer(comp, subGraph);
        }

    private void DFSCollect(
        JamBlockController node,
        List<JamBlockController> comp,
        HashSet<JamBlockController> visited,
        Dictionary<JamBlockController, List<(int bind, JamBlockController neighbor)>> graph
    )
    {
        if (visited.Contains(node))
            return;

        visited.Add(node);
        comp.Add(node);

        if (!graph.ContainsKey(node)) return;

        foreach (var (_, nbr) in graph[node])
            DFSCollect(nbr, comp, visited, graph);
    }

PlaceBlocksWithGoalCheck (bool isPlaceToGridWithTransformAtFirst)

        if (!_isCombineGoalCheckCoroutineForTransformChecked && isPlaceToGridWithTransformAtFirst)
        {

            _combineGoalCheckCoroutineActive = false;
            _isCombineGoalCheckCoroutineForTransformChecked = true;
        }

        if (_isRemovingBlockFromGridThisFrame || 
            _combineGoalCheckCoroutineActive)
        {
            return;
        }

        _combineGoalCheckCoroutineActive = true;
        _isRemovingBlockFromGridThisFrame = false;

        if (_connectedBlocksList == null
            || _connectedBlocksList.Count == 0)
        {
            return;
        }

        TemporaryRemoveAllBlocks();

        PlaceToGridFromJamGridLocsAllBlocks(isPlaceToGridWithTransformAtFirst);

        InvokeGoalCheckForAllBlocks(isPlaceToGridWithTransformAtFirst);

        if (_connectedBlocksList == null
            || _connectedBlocksList.Count == 0)
        {
            return;
        }

1 more item...

TemporaryRemoveAllBlocks

        _connectedBlocksRemovedFromJamGridLocsList = new Dictionary<JamBlockController, JamGridLoc>();

for _connectedBlocksList

            JamAbstractBlock currentBlock = _connectedBlocksList[i].GetJamAbstractBlock();

            if (_jamGridVisualController.BlockHasLocations(currentBlock))

                var locations = _jamGridVisualController.GetBlockLoc(currentBlock);
                _connectedBlocksRemovedFromJamGridLocsList.Add(_connectedBlocksList[i], locations);
                _connectedBlocksList[i].TemporarilyRemoveFromGrid();

esle

                string debugStr = 
                    "TemporaryRemoveAllBlocks Removed Block Because Couldn't Find Locations! "
                    + _connectedBlocksList[i].GetJamAbstractBlock().GetCurrentColor()
                    + " and shape "
                    + _connectedBlocksList[i].GetJamAbstractBlock().GetShapeType();
                Crashlytics.Log(debugStr);
                Debug.Log(debugStr);

                _connectedBlocksRemovedFromJamGridLocsList.Remove(_connectedBlocksList[i]);
                _connectedBlocksList.RemoveAt(i);
                i--;

- - - - or block didnt exist ever
      - probably at JamGridController.SetBlockLoc()
        
        1 more item...

PlaceToGridFromJamGridLocsAllBlocks

        if (_connectedBlocksList == null 
            || _connectedBlocksList.Count == 0)
        {
            return;
        }

        JamAbstractBlock currentBlock = _connectedBlocksList[0].GetJamAbstractBlock();

        if (!_connectedBlocksRemovedFromJamGridLocsList.ContainsKey(_connectedBlocksList[0]))
        {
            string debugStr =
                    "PlaceToGridFromJamGridLocsAllBlocks _connectedBlocksRemovedFromJamGridLocsList " +
                    "doesnt have 0th index connection";
            Crashlytics.LogException(
                new System.Exception(debugStr));
            Debug.Log(debugStr);
            _connectedBlocksList.RemoveAt(0);
            return;
        }

        JamGridLoc pivotLocationStart = _connectedBlocksRemovedFromJamGridLocsList[_connectedBlocksList[0]];

        PlaceToGridSingleBlock(isPlaceToGridWithTransform, _connectedBlocksList[0], gameObject);

        if (!_jamGridVisualController.BlockHasLocations(_connectedBlocksList[0].GetJamAbstractBlock()))
        {
            string debugStr = "PlaceToGridFromJamGridLocsAllBlocks no 0th index connection";
            Crashlytics.LogException(
                new System.Exception(debugStr));
            Debug.Log(debugStr);
            _connectedBlocksList.RemoveAt(0);
            return;
        }

        JamGridLoc pivotLocationDisplaced = _jamGridVisualController.GetBlockLoc(currentBlock);

        JamGridLoc displacement = pivotLocationDisplaced - pivotLocationStart;

        for (int i = 1; i < _connectedBlocksList.Count; i++)
        {

            if (!_connectedBlocksRemovedFromJamGridLocsList.ContainsKey(_connectedBlocksList[i]))
            {
                string debugStr = $"PlaceToGridFromJamGridLocsAllBlocks no {i}th index connection";
                Crashlytics.LogException(
                    new System.Exception(debugStr));
                Debug.Log(debugStr);
                _connectedBlocksRemovedFromJamGridLocsList.Remove(_connectedBlocksList[i]);
                _connectedBlocksList.RemoveAt(i);
                i--;
                continue;
            }

2 more items...

    private void PlaceToGridSingleBlock(
        bool isPlaceToGridWithTransform, JamBlockController blockController, GameObject overridePlacementGameObject = null)
    {
        if (isPlaceToGridWithTransform)
        {
            blockController.PlaceBlockToSomeLocation(overridePlacementGameObject);
        }
        else
        {
            blockController.PlaceBlockToLastGridLocWithoutTransformOffset(overridePlacementGameObject);
        }
    }