void ClearAboutPathTest()
        {
            {
                StartNodeMarker[] markers = GameObject.FindObjectsOfType <StartNodeMarker>();
                foreach (StartNodeMarker marker in markers)
                {
                    DestroyImmediate(marker);
                }
            }

            {
                GoalNodeMarker[] markers = GameObject.FindObjectsOfType <GoalNodeMarker>();
                foreach (GoalNodeMarker marker in markers)
                {
                    DestroyImmediate(marker);
                }
            }

            {
                GameObject pathMarker = GameObject.Find(NodePathMarker.GameObjName);
                if (pathMarker)
                {
                    DestroyImmediate(pathMarker);
                }
            }

            pathFindTestStartNode = null;
            pathFindTestGoalNode  = null;
            selectedTileMapNodes.Clear();
        }
Exemplo n.º 2
0
        void MakeConnectionEachOtherNodes(Dictionary <TilePos, SquareTileMapNode> nodeMap)
        {
            int nodeIndex = 0;

            for (int y = 0; y < tileHeightCount; ++y)
            {
                for (int x = 0; x < tileWidthCount; ++x, ++nodeIndex)
                {
                    TilePos           nodePos = new TilePos(x, y);
                    SquareTileMapNode node    = nodeMap[nodePos];
                    node.ClearConnectionNode();

                    if (TileMapEngine.Instance.Invalid(node))
                    {
                        continue;
                    }

                    List <TilePos> adjacentNodeIndexes = new List <TilePos>();

                    if (x != 0)   //left node
                    {
                        adjacentNodeIndexes.Add(nodePos - new TilePos(1, 0));
                    }

                    if (y < tileHeightCount - 1)   // top node
                    {
                        adjacentNodeIndexes.Add(nodePos + new TilePos(0, 1));
                    }

                    if (x < tileWidthCount - 1)   // rightn node
                    {
                        adjacentNodeIndexes.Add(nodePos + new TilePos(1, 0));
                    }

                    if (y != 0)   // bottom node
                    {
                        adjacentNodeIndexes.Add(nodePos - new TilePos(0, 1));
                    }

                    foreach (TilePos adjacentNodeIndex in adjacentNodeIndexes)
                    {
                        SquareTileMapNode adjacentNode = null;
                        nodeMap.TryGetValue(adjacentNodeIndex, out adjacentNode);

                        if (adjacentNode == null)
                        {
                            Debug.LogError(string.Format("invalid nodePos={0}_{1}", adjacentNodeIndex.x, adjacentNodeIndex.y));
                            continue;
                        }

                        if (TileMapEngine.Instance.Invalid(adjacentNode))
                        {
                            continue;
                        }

                        node.AddConnectionNode(adjacentNode);
                    }
                }
            }
        }
        SquareTileMapNode MakeTileMapOneTile(int nodeIndex, int x, int y, SquareTileMapNode tilePrefab, GameObject tileMapNodeGroup)
        {
            // create tile-map-node-gameobject
            GameObject newTileMapNodeGameObj = PrefabUtility.InstantiatePrefab(tilePrefab.gameObject) as GameObject;

            newTileMapNodeGameObj.transform.parent = tileMapNodeGroup.transform;
            newTileMapNodeGameObj.name             = string.Format("tile_{0}-{1}", x, y);

            SquareTileMapNode squareTileMapNode = newTileMapNodeGameObj.GetComponent <SquareTileMapNode>();

            squareTileMapNode.Init(nodeIndex, x, y);

            Vector3 worldPos = Vector3.zero;

            {
                worldPos.x = x * squareTileMapNode.squareSize.x;

                if (screen2D)
                {
                    worldPos.y = y * squareTileMapNode.squareSize.y;
                }
                else
                {
                    worldPos.z = y * squareTileMapNode.squareSize.y;
                }
            }
            newTileMapNodeGameObj.transform.position = worldPos;

            if (screen2D && newTileMapNodeGameObj.GetComponentInChildren <MeshRenderer>() != null)
            {
                newTileMapNodeGameObj.transform.rotation = Quaternion.AngleAxis(-90.0f, Vector3.right);
            }

            return(squareTileMapNode);
        }
Exemplo n.º 4
0
        public void SetTilePos(SquareTileMapNode tileMapNode)
        {
            SubOnObjectToTileNodesByCurPos();

            this.tilePos            = new TilePos(tileMapNode.TilePosX, tileMapNode.TilePosY);
            this.transform.position = tileMapNode.WorldPosition;

            AddOnObjectToTileNodesByCurPos();
        }
        void MakeTileMap()
        {
            if (tilePrefab == null)
            {
                Debug.LogError("failed to MakeTileMap. null tilePrefab.");
                return;
            }

            // clear
            curTileMap = null;
            ClearAboutPathTest();

            // new root gameobject
            const string tileMapRootGameObjectName = "_TileMapRoot";
            GameObject   tileMapRootGameObj        = new GameObject(tileMapRootGameObjectName);

            tileMapRootGameObj.transform.position = Vector3.zero;
            TileMapRoot tileMapRootCompo = tileMapRootGameObj.AddComponent <TileMapRoot>() as TileMapRoot;

            Vector2 tileSize = Vector2.one;

            if (tilePrefab)
            {
                SquareTileMapNode nodeCompo = tilePrefab.GetComponent <SquareTileMapNode>();
                tileSize = nodeCompo.squareSize;
            }

            tileMapRootCompo.InitFromEditor(screen2D, tileWidthCount, tileHeightCount, tileSize);

            curTileMap             = tileMapRootCompo;
            Selection.activeObject = curTileMap.gameObject;

            // new tilenode group gameobject
            GameObject tileMapNodeGroup = tileMapRootCompo.NodeGroup;

            // create tile-map-nodes
            Dictionary <int, SquareTileMapNode> nodeMap = new Dictionary <int, SquareTileMapNode>();
            int nodeIndex = 0;

            for (int y = 0; y < tileHeightCount; ++y)
            {
                for (int x = 0; x < tileWidthCount; ++x, ++nodeIndex)
                {
                    SquareTileMapNode squareTileMapNode = MakeTileMapOneTile(nodeIndex, x, y, tilePrefab, tileMapNodeGroup);

                    nodeMap[nodeIndex] = squareTileMapNode;
                }
            }

            // connect eachother nodes
            MakeConnectionEachOtherNodes();
        }
        void ExtendTileMap()
        {
            if (curTileMap == null)
            {
                return;
            }

            if (tilePrefab == null)
            {
                Debug.LogError("failed to ExtendTileMap. null tilePrefab.");
                return;
            }

            // clear
            ClearAboutPathTest();

            curTileMap.InitTileMapEngine();

            // new tilenode group gameobject
            GameObject tileMapNodeGroup = curTileMap.NodeGroup;

            // create tile-map-nodes
            int nodeIndex = 0;

            for (int y = 0; y < tileHeightCount; ++y)
            {
                for (int x = 0; x < tileWidthCount; ++x, ++nodeIndex)
                {
                    SquareTileMapNode node = TileMapEngine.Instance.GetTileNode(new TilePos(x, y));
                    if (node == null)
                    {
                        MakeTileMapOneTile(nodeIndex, x, y, tilePrefab, tileMapNodeGroup);
                    }
                    else
                    {
                        node.Init(nodeIndex, x, y);
                        EditorUtility.SetDirty(node);
                    }
                }
            }

            curTileMap.ExtendFromEditor(tileWidthCount, tileHeightCount);
            EditorUtility.SetDirty(curTileMap);

            // connect eachother nodes
            MakeConnectionEachOtherNodes();
        }
        void RemakeTileMap()
        {
            if (curTileMap == null)
            {
                return;
            }

            if (tilePrefab == null)
            {
                Debug.LogError("failed to MakeTileMap. null tilePrefab.");
                return;
            }

            // clear
            ClearAboutPathTest();

            Vector2 tileSize = Vector2.one;

            if (tilePrefab)
            {
                SquareTileMapNode nodeCompo = tilePrefab.GetComponent <SquareTileMapNode>();
                tileSize = nodeCompo.squareSize;
            }

            curTileMap.InitFromEditor(screen2D, tileWidthCount, tileHeightCount, tileSize);

            // new tilenode group gameobject
            GameObject tileMapNodeGroup = curTileMap.NodeGroup;

            // create tile-map-nodes
            Dictionary <int, SquareTileMapNode> nodeMap = new Dictionary <int, SquareTileMapNode>();
            int nodeIndex = 0;

            for (int y = 0; y < tileHeightCount; ++y)
            {
                for (int x = 0; x < tileWidthCount; ++x, ++nodeIndex)
                {
                    SquareTileMapNode squareTileMapNode = MakeTileMapOneTile(nodeIndex, x, y, tilePrefab, tileMapNodeGroup);

                    nodeMap[nodeIndex] = squareTileMapNode;
                }
            }

            // connect eachother nodes
            MakeConnectionEachOtherNodes();
        }
Exemplo n.º 8
0
        public void AddOnObjectToTileNodesByCurPos()
        {
            foreach (TileMapObject obj in tileMapObjects)
            {
                TilePos     objTilePos         = obj.TilePos + this.TilePos;
                TileMapSize objUnitTileMapSize = obj.TileMapSize;
                for (int x = 0; x < objUnitTileMapSize.width; ++x)
                {
                    for (int y = 0; y < objUnitTileMapSize.height; ++y)
                    {
                        TilePos tilePos = objTilePos + new TilePos(x, y);

                        SquareTileMapNode node = TileMapEngine.Instance.GetTileNode(tilePos);
                        if (node)
                        {
                            node.AddOnObject(this);
                        }
                    }
                }
            }
        }
        void OnGUI()
        {
            scrollPos = EditorGUILayout.BeginScrollView(scrollPos);

            selectMode = (SelectMode)EditorGUILayout.EnumPopup("Select Mode: ", selectMode);

            // about create tile
            {
                TileMapRoot beforeTileMap = curTileMap;
                curTileMap = EditorGUILayout.ObjectField("curTileMap", curTileMap, typeof(TileMapRoot), true) as TileMapRoot;
                if (beforeTileMap != curTileMap)
                {
                    UpdateTileMapInfo();
                }

                if (curTileMap)
                {
                    if (GUILayout.Button("select", GUILayout.Width(100.0f)))
                    {
                        Selection.activeObject = curTileMap.gameObject;
                    }
                }

                tilePrefab = EditorGUILayout.ObjectField("Tile Prefab", tilePrefab, typeof(SquareTileMapNode), false) as SquareTileMapNode;
                screen2D   = EditorGUILayout.Toggle("screen2D", screen2D);

                tileWidthCount = EditorGUILayout.IntField("Tile Width Count: ", tileWidthCount);
                if (tileWidthCount < 0)
                {
                    tileWidthCount = 0;
                }
                if (tileWidthCount > maxTileWidthCount)
                {
                    tileWidthCount = maxTileWidthCount;
                }

                tileHeightCount = EditorGUILayout.IntField("Tile Height Count: ", tileHeightCount);
                if (tileHeightCount < 0)
                {
                    tileHeightCount = 0;
                }
                if (tileHeightCount > maxTileHeightCount)
                {
                    tileHeightCount = maxTileHeightCount;
                }

                if (tilePrefab && tileWidthCount > 0 && tileHeightCount > 0)
                {
                    GUILayout.BeginHorizontal();

                    if (GUILayout.Button("Make New TileMap"))
                    {
                        MakeTileMap();
                    }

                    if (curTileMap)
                    {
                        if (GUILayout.Button("Remake TileMap"))
                        {
                            RemakeTileMap();
                        }

                        if (curTileMap.GetMapInfo().tileWidthCount <= tileWidthCount &&
                            curTileMap.GetMapInfo().tileHeightCount <= tileHeightCount)
                        {
                            if (GUILayout.Button("Extend TileMap"))
                            {
                                ExtendTileMap();
                            }
                        }
                    }

                    GUILayout.EndHorizontal();
                }
            }

            GUIDrawLine();

            // about tile selection
            {
                // collect selected tileMapNodes
                selectedTileMapNodes.Clear();
                GameObject[] selectedObjects = Selection.gameObjects;
                foreach (GameObject selectedGameObj in selectedObjects)
                {
                    SquareTileMapNode tileMapNode = selectedGameObj.GetComponent <SquareTileMapNode>();
                    if (tileMapNode && selectedGameObj.activeInHierarchy)
                    {
                        selectedTileMapNodes.Add(tileMapNode);
                    }
                }

                // show selected tileMapNodes count
                GUILayout.Label(string.Format("selectedTileMapNodes count: {0}", selectedTileMapNodes.Count));

                // about tile remake
                tilePrefabForChange = EditorGUILayout.ObjectField("Tile Prefab for change", tilePrefabForChange, typeof(SquareTileMapNode), true) as SquareTileMapNode;
                if (tilePrefabForChange && selectedTileMapNodes.Count > 0)
                {
                    if (GUILayout.Button("Change selected tiles"))
                    {
                        foreach (SquareTileMapNode selectedMapTile in selectedTileMapNodes)
                        {
                            GameObject        tileMapNodeGroup  = selectedMapTile.transform.parent.gameObject;
                            SquareTileMapNode squareTileMapNode = MakeTileMapOneTile(
                                selectedMapTile.NodeID,
                                selectedMapTile.TilePosX,
                                selectedMapTile.TilePosY,
                                tilePrefabForChange,
                                tileMapNodeGroup);
                        }

                        foreach (SquareTileMapNode selectedMapTile in selectedTileMapNodes)
                        {
                            DestroyImmediate(selectedMapTile.gameObject);
                        }

                        MakeConnectionEachOtherNodes();
                    }
                }

                GUIDrawLine();

                // about tile map object creation
                {
                    curTileMapObjectGroup = EditorGUILayout.ObjectField("TileMapObjectGroup ", curTileMapObjectGroup, typeof(TileMapObjectGroup), true) as TileMapObjectGroup;
                    if (curTileMapObjectGroup)
                    {
                        if (IsPrefabTarget(curTileMapObjectGroup.gameObject))
                        {
                            if (selectedTileMapNodes.Count > 0 && curTileMap != null)
                            {
                                if (GUILayout.Button("Create TileMapObjectGroup"))
                                {
                                    if (positionedObjGroupGameObj == null)
                                    {
                                        const string positionGroupOfTileMapObjectGroup = "_PositionedObjectGroups";
                                        positionedObjGroupGameObj = GameObject.Find(positionGroupOfTileMapObjectGroup);
                                        if (positionedObjGroupGameObj == null)
                                        {
                                            positionedObjGroupGameObj = new GameObject(positionGroupOfTileMapObjectGroup);
                                        }
                                    }

                                    foreach (SquareTileMapNode tileMapNode in selectedTileMapNodes)
                                    {
                                        GameObject newTileMapObjGroup = PrefabUtility.InstantiatePrefab(curTileMapObjectGroup.gameObject) as GameObject;
                                        newTileMapObjGroup.transform.parent = positionedObjGroupGameObj.transform;

                                        TileMapObjectGroup newTileMapObjGroupCompo = newTileMapObjGroup.GetComponent <TileMapObjectGroup>();
                                        newTileMapObjGroupCompo.SetTilePos(tileMapNode);
                                    }
                                }
                            }
                        }
                        else
                        {
                            groundTileForChangeAtSelectedObjectBlockPos =
                                EditorGUILayout.ObjectField("GroundTileForChangeAtObjectBlockPositions",
                                                            groundTileForChangeAtSelectedObjectBlockPos,
                                                            typeof(SquareTileMapNode),
                                                            true) as SquareTileMapNode;

                            if (groundTileForChangeAtSelectedObjectBlockPos && curTileMap)
                            {
                                if (GUILayout.Button("Change groundTile at object block pos"))
                                {
                                    MakeConnectionEachOtherNodes();

                                    List <SquareTileMapNode> forChangeGroundTileList = new List <SquareTileMapNode>();
                                    int[,] blockTileData = curTileMapObjectGroup.GetBlockTileData();

                                    for (int x = 0; x < curTileMapObjectGroup.TileMapSize.width; ++x)
                                    {
                                        for (int y = 0; y < curTileMapObjectGroup.TileMapSize.height; ++y)
                                        {
                                            int blockFlag = blockTileData[x, y];

                                            if (blockFlag == 1)
                                            {
                                                TilePos           tilePos = curTileMapObjectGroup.TilePos + new TilePos(x, y);
                                                SquareTileMapNode node    = TileMapEngine.Instance.GetTileNode(tilePos);
                                                if (node == null)
                                                {
                                                    Debug.LogError(string.Format("null node : {0}_{1}", tilePos.x, tilePos.y));
                                                    continue;
                                                }

                                                forChangeGroundTileList.Add(node);
                                            }
                                        }
                                    }

                                    foreach (SquareTileMapNode node in forChangeGroundTileList)
                                    {
                                        GameObject tileMapNodeGroup = node.transform.parent.gameObject;

                                        SquareTileMapNode squareTileMapNode = MakeTileMapOneTile(
                                            node.NodeID,
                                            node.TilePosX,
                                            node.TilePosY,
                                            groundTileForChangeAtSelectedObjectBlockPos,
                                            tileMapNodeGroup);
                                    }

                                    foreach (SquareTileMapNode node in forChangeGroundTileList)
                                    {
                                        DestroyImmediate(node.gameObject);
                                    }
                                }
                            }
                        }
                    }

                    tileMapObjPrefabForCreation = EditorGUILayout.ObjectField("TileMapObj Prefab for Creation", tileMapObjPrefabForCreation, typeof(TileMapObject), true) as TileMapObject;
                    if (tileMapObjPrefabForCreation && selectedTileMapNodes.Count > 0 && curTileMap != null)
                    {
                        if (GUILayout.Button("Create TileMapObjs to selected nodes pos"))
                        {
                            GameObject objectGroupGameObj;
                            if (curTileMapObjectGroup != null)
                            {
                                objectGroupGameObj = curTileMapObjectGroup.gameObject;
                            }

                            // get objectGroup gameobject
                            {
                                const string objectGroupGameObjectName = "_ObjectGroup";

                                objectGroupGameObj = GameObject.Find(objectGroupGameObjectName);
                                if (objectGroupGameObj == null)
                                {
                                    objectGroupGameObj = new GameObject(objectGroupGameObjectName);
                                }

                                objectGroupGameObj.transform.position = Vector3.zero;

                                //BattleObject bo = objectGroupGameObj.GetComponent<BattleObject>();
                                //if (bo == null) {
                                //bo = objectGroupGameObj.AddComponent<BattleObject>();
                                //}

                                TileMapObjectGroup objectGroup = objectGroupGameObj.GetComponent <TileMapObjectGroup>();
                                if (objectGroup == null)
                                {
                                    objectGroup = objectGroupGameObj.AddComponent <TileMapObjectGroup>();
                                }
                                objectGroup.Init(new TileMapSize(curTileMap.TileWidthCount, curTileMap.TileHeightCount), new TilePos(0, 0));

                                curTileMapObjectGroup = objectGroup;
                            }

                            foreach (SquareTileMapNode tileMapNode in selectedTileMapNodes)
                            {
                                // create tile-map-object
                                GameObject newTileMapObj = PrefabUtility.InstantiatePrefab(tileMapObjPrefabForCreation.gameObject) as GameObject;
                                newTileMapObj.transform.position = tileMapNode.transform.position;

                                TileMapObject tileMapObjCompo = newTileMapObj.GetComponent <TileMapObject>();
                                tileMapObjCompo.Init(Kino.TileMap.Direction.Bottom, new TilePos(tileMapNode.TilePosX, tileMapNode.TilePosY));

                                newTileMapObj.transform.parent = objectGroupGameObj.transform;
                            }
                        }
                    }
                }
            }

            GUIDrawLine();

            // about tile map data export
            {
                if (curTileMap)
                {
                    GUILayout.Label(string.Format("tileMapID: {0}, tileMapName: {1}, width: {2}, height: {3}",
                                                  curTileMap.MapID, curTileMap.MapName, curTileMap.TileWidthCount, curTileMap.TileHeightCount));

                    if (GUILayout.Button("select", GUILayout.Width(100.0f)))
                    {
                        Selection.activeObject = curTileMap.gameObject;
                    }

                    if (GUILayout.Button("Export TileMapData"))
                    {
                        ExportCurrentTileMapData();
                    }

                    if (GUILayout.Button("Export TileMapData for client"))
                    {
                        ExportCurrentTileMapDataForClient();
                    }
                }
            }

            // about tile map object data export
            {
                if (curTileMapObjectGroup)
                {
                    //BattleObject bo = curTileMapObjectGroup.GetComponent<BattleObject>();

                    //if (bo) {
                    //GUILayout.Label(string.Format("objectID: {0}, objectName: {1}, width: {2}, height: {3}, hp: {4}, respawnTime: {5}",
                    //bo.ObjectID,
                    //bo.ObjectName,
                    //curTileMapObjectGroup.TileMapSize.width,
                    //curTileMapObjectGroup.TileMapSize.height,
                    //bo.HP,
                    //bo.RespawnTimeBySec));
                    //}

                    if (GUILayout.Button("select", GUILayout.Width(100.0f)))
                    {
                        Selection.activeObject = curTileMapObjectGroup.gameObject;
                    }

                    if (GUILayout.Button("Export TileMapObjectGroupData"))
                    {
                        ExportCurrentTileMapObjectGroupData();
                    }
                }
            }

            // about tile map object groups pos data export
            {
                positionedObjGroupGameObj = EditorGUILayout.ObjectField("positionedObjGroupGameObj for export", positionedObjGroupGameObj, typeof(GameObject), true) as GameObject;

                if (curTileMap && positionedObjGroupGameObj)
                {
                    if (GUILayout.Button("Export PositionInfos about positionedObjectGroups"))
                    {
                        ExportPositionInfosAboutPositionedObjectGroupsDatas();
                    }
                }
            }

            GUIDrawLine();

            // PathFinder Test
            {
                GUILayout.Label("PathFind Test");

                if (GUILayout.Button("Init for Test"))
                {
                    MakeConnectionEachOtherNodes();
                    ClearAboutPathTest();
                }

                if (GUILayout.Button("clear"))
                {
                    ClearAboutPathTest();
                }

                if (selectedTileMapNodes.Count > 0)
                {
                    SquareTileMapNode targetNode = selectedTileMapNodes[0];

                    GUILayout.Label(string.Format("target nodeID:{0}", targetNode.nodeID));

                    if (GUILayout.Button("Set StartNode"))
                    {
                        if (!targetNode.Invalid)
                        {
                            if (pathFindTestStartNode)
                            {
                                DestroyImmediate(pathFindTestStartNode.gameObject.GetComponent <StartNodeMarker>());
                                DestroyImmediate(pathFindTestStartNode.gameObject.GetComponent <GoalNodeMarker>());
                            }

                            pathFindTestStartNode = targetNode;
                            pathFindTestStartNode.gameObject.AddComponent <StartNodeMarker>();
                        }
                    }

                    if (GUILayout.Button("Set GoalNode"))
                    {
                        if (!targetNode.Invalid)
                        {
                            if (pathFindTestGoalNode)
                            {
                                DestroyImmediate(pathFindTestGoalNode.gameObject.GetComponent <StartNodeMarker>());
                                DestroyImmediate(pathFindTestGoalNode.gameObject.GetComponent <GoalNodeMarker>());
                            }

                            pathFindTestGoalNode = targetNode;
                            pathFindTestGoalNode.gameObject.AddComponent <GoalNodeMarker>();
                        }
                    }
                }

                if (pathFindTestStartNode != null && pathFindTestGoalNode != null)
                {
                    if (GUILayout.Button("Find Path"))
                    {
                        List <SquareTileMapNode> findedPath = TileMapEngine.Instance.Calculate(pathFindTestStartNode, pathFindTestGoalNode);

                        GameObject nodePathGameObj = GameObject.Find(NodePathMarker.GameObjName);
                        if (nodePathGameObj)
                        {
                            DestroyImmediate(nodePathGameObj);
                        }

                        if (findedPath == null || findedPath.Count == 0)
                        {
                            ShowNotification(new GUIContent("cannot find path"));
                        }
                        else
                        {
                            nodePathGameObj = new GameObject(NodePathMarker.GameObjName);

                            NodePathMarker nodePathMarker = nodePathGameObj.AddComponent <NodePathMarker>();
                            nodePathMarker.findedPath = findedPath;
                        }
                    }
                }
            }

            GUIDrawLine();

            GUILayout.Label("tood:");

            EditorGUILayout.EndScrollView();

            if (Event.current.type == EventType.MouseMove)
            {
                Repaint();
            }
        }
        List <Object> GetNodeObjectList(SquareTileMapNode beginNode, SquareTileMapNode destNode)
        {
            List <Object>     newSelectionList      = new List <Object>();
            SquareTileMapNode lastSelectedNodeCompo = beginNode;

            GameObject nodeGrp = lastSelectedNodeCompo.transform.parent.gameObject;

            const string nodeNameFormat = "tile_{0}-{1}";

            int loopYGrowUpValue = 0;

            if (lastSelectedNodeCompo.TilePosY < destNode.TilePosY)
            {
                loopYGrowUpValue = 1;
            }
            else if (lastSelectedNodeCompo.TilePosY > destNode.TilePosY)
            {
                loopYGrowUpValue = -1;
            }

            int loopXGrowUpValue = 0;

            if (lastSelectedNodeCompo.TilePosX < destNode.TilePosX)
            {
                loopXGrowUpValue = 1;
            }
            else if (lastSelectedNodeCompo.TilePosX > destNode.TilePosX)
            {
                loopXGrowUpValue = -1;
            }

            for (int y = lastSelectedNodeCompo.TilePosY;
                 loopYGrowUpValue > 0 ?
                 y <= destNode.TilePosY :
                 (loopYGrowUpValue < 0 ?
                  y >= destNode.TilePosY :
                  y == destNode.TilePosY);
                 )
            {
                for (int x = lastSelectedNodeCompo.TilePosX;
                     loopXGrowUpValue > 0 ?
                     x <= destNode.TilePosX :
                     (loopXGrowUpValue < 0 ?
                      x >= destNode.TilePosX :
                      x == destNode.TilePosX);
                     )
                {
                    string    nodeName = string.Format(nodeNameFormat, x, y);
                    Transform nodeTm   = nodeGrp.transform.FindChild(nodeName);

                    newSelectionList.Add(nodeTm.gameObject);

                    if (loopXGrowUpValue == 0)
                    {
                        ++x;
                    }
                    else
                    {
                        x += loopXGrowUpValue;
                    }
                }

                if (loopYGrowUpValue == 0)
                {
                    ++y;
                }
                else
                {
                    y += loopYGrowUpValue;
                }
            }

            return(newSelectionList);
        }
Exemplo n.º 11
0
 public void AddConnectionNode(SquareTileMapNode node)
 {
     connections.Add(node);
 }