示例#1
0
    private IEnumerator Move(Coord dest)
    {
        // Remove branches entering the stages not chosen in the next column and grey them out
        for (int i = 0; i < _currMap[dest.col].Length; i++)
        {
            StageNode stage = _currMap[dest.col][i];
            // Ignore null stages and the current stage
            if (stage == null || i == dest.row)
            {
                continue;
            }
            stage.SetInaccessible();
            stage.DestroyEntryBranch();
        }

        // Readjust length of vertical path leading to next column
        PositionVerticalPath(GetCurrStage().GetVerticalPath(), GetCurrStage(), _currMap[dest.col][dest.row]);

        SetPlayerCoord(dest);
        _canMove = false;

        // TODO: move animation?
        yield return(new WaitForSeconds(1f));

        GetCurrStage().EnterStage();
        _mapDisplay.SetActive(false);
    }
示例#2
0
    private void InitializeStage(ZoneProperties properties, int stageCol, StageNode stage, StageCategory category)
    {
        switch (category)
        {
        case StageCategory.BATTLE:
            BattleType battleType = (BattleType)Random.Range(0, System.Enum.GetValues(typeof(BattleType)).Length - 1);
            stage.SetStage(battleType);
            InitializeCombatStage(properties, stageCol, stage, battleType);
            break;

        case StageCategory.BOSS:
            stage.SetStage(BattleType.BOSS);
            InitializeCombatStage(properties, stageCol, stage, BattleType.BOSS);
            break;

        case StageCategory.EVENT:
            EventType eventType = (EventType)Random.Range(0, System.Enum.GetValues(typeof(EventType)).Length);
            stage.SetStage(eventType);
            break;

        default:
            Debug.LogWarning("No category found when initializing stage.");
            break;
        }
    }
示例#3
0
    private void DrawIcon(StageNode.StageType type, Vector2 pos)
    {
        GameObject newIcon = Instantiate(myIcon, transform);

        activeIcons.Add(newIcon);
        newIcon.GetComponent <SpriteRenderer>().sprite = icons[StageNode.GetStageTypeNum(type)];
        newIcon.transform.localPosition = new Vector3(pos.x, pos.y, newIcon.transform.position.z);
    }
    // Update is called once per frame
    void Update()
    {
        if (IsFreeze)
        {
            return;
        }

        if (Input.GetButtonDown("Attack"))
        {
            if (_targetStage != FirstNode && State != StageSelectState.Title)
            {
                MoveScene();
            }
        }

        var p = Mathf.MoveTowards(Position, _playerPositionTarget, MoveSpeed * _moveSpeedMag * Time.deltaTime);

        MovePlayer(p);

        var forward = p >= Position;
        var low     = forward ? Position : p;
        var high    = forward ? p : Position;

        foreach (var e in _eventList)
        {
            var c = e.GetPosition();
            if (low <= c && c <= high)
            {
                e.OnExecute(this, forward, false);
            }
        }

        if (Input.GetKeyDown(KeyCode.P) && !_isSceneMoving)
        {
            _isSceneMoving          = true;
            _lastSelectedStageIndex = 0;
            GameData.Instance.DeleteDataAll();
            GameData.Instance.Save();
            SceneChanger.Instance.MoveScene("StageSelect", 0.2f, 0.2f, SceneChangeType.BlackFade);
        }

        if (p == Position)
        {
            _currentSelectedStage            = _targetStage;
            _currentSelectedStage.IsSelected = true;
        }
        else
        {
            if (_currentSelectedStage)
            {
                _currentSelectedStage.IsSelected = false;
            }

            _currentSelectedStage = null;
        }

        Position = p;
    }
    // Use this for initialization
    void Start()
    {
        _playerBody = PlayerModel.Find("Body").Find("StarWithBone");

        // イベント読み込み
        _eventList = GetComponentsInChildren <MonoBehaviour>()
                     .Select(x => x as IStageMoveEvent)
                     .Where(x => x != null)
                     .OrderBy(x => x.GetPosition())
                     .ToList();

        GameData.Instance.Load();

        // 進行度読み込み
        var clearedStages = new HashSet <string>();

        GameData.Instance.GetData(StageProgressKey, ref clearedStages);

        var stageProgress = clearedStages.Count;
        var followerCount = 0;

        // ステージノードのセットアップ(+1はタイトル分)
        FirstNode.SetUpNode(null, stageProgress + 1, ref followerCount);

        _targetStage = _currentSelectedStage = GetStageNode(_lastSelectedStageIndex);
        if (_currentSelectedStage != FirstNode)
        {
            State = StageSelectState.Select;
        }

        _playerPositionTarget = GetLength(_targetStage);

        // イベントを実行
        foreach (var item in _eventList)
        {
            if (_playerPositionTarget > item.GetPosition())
            {
                Debug.Log(_playerPositionTarget + " " + item.GetPosition());
                item.OnExecute(this, true, true);
            }
        }

        // プレイヤーを移動
        MovePlayer(_playerPositionTarget);
        Position = _playerPositionTarget;

        // BGMを鳴らす
        AudioManager.FadeIn(1.0f, "vigilante");

        // ステージ選択用
        StartCoroutine(SelectionInput());
    }
示例#6
0
    public void Start()
    {
        myPlayer = player.GetComponent <PlayerController>();
        currentLevelStartStage = GenerateLevelStartStage();
        Assert.AreEqual(stageTypeFrequencies.Length, StageNode.NUM_STAGE_TYPES);
        waitingForDeathClick = false;
        deathScreen.enabled  = false;

        currentStage       = currentLevelStartStage;
        currentLevel       = 0;
        myCurrentStageText = currentStageText.GetComponent <Text>();
        GenerateMap();
    }
示例#7
0
    private int RoomDepth(StageNode room, int d)
    {
        if (room.nextStages.Count == 0)
        {
            return(d);
        }
        int maxd = d;

        for (int i = 0; i < room.nextStages.Count; i++)
        {
            maxd = System.Math.Max(maxd, RoomDepth(room.nextStages[i], d + 1));
        }
        return(maxd);
    }
示例#8
0
    // Creates a path segment going into or out of the given transform (isEntryBranch specifies which)
    private void CreateBranch(StageNode stage, bool isEntryBranch)
    {
        float         branchWidth = _horizontalPadding / 2;
        RectTransform branch      = Instantiate(_pathPrefab, stage.transform).GetComponent <RectTransform>();

        branch.sizeDelta = new Vector2(branchWidth + branch.rect.height, branch.rect.height);
        if (isEntryBranch)
        {
            branch.anchoredPosition -= new Vector2(branchWidth / 2, 0);
            stage.SetEntryBranch(branch.gameObject);
        }
        else
        {
            branch.anchoredPosition += new Vector2(branchWidth / 2, 0);
        }
    }
示例#9
0
 public void EnterNextStage()
 {
     if (currentStage.nextStages.Count == 0)
     {
         // final thingy, move on.
         currentLevel          += 1;
         currentLevelStartStage = GenerateLevelStartStage();
         currentStage           = currentLevelStartStage;
     }
     else
     {
         print("moving into next stage, going through way down num " + GetCurrentRoom().wayDownNum);
         currentStage = currentStage.nextStages[GetCurrentRoom().wayDownNum];
     }
     GenerateMap();
 }
    private float GetLength(StageNode to)
    {
        var length  = 0.0f;
        var current = FirstNode;

        while (current != to)
        {
            if (!current.NextStage)
            {
                break;
            }
            length += current.Length;
            current = current.NextStage;
        }

        return(length);
    }
示例#11
0
    void makeMove(CreateNodeAction createNodeAction)
    {
        if (createNodeAction == null)
        {
            return;
        }

        StageNode stageNode = new StageNode(createNodeAction.Position, createNodeAction.Width);

        if (createNodeAction.IndexInList != GlobalConst.INVALID_ID)
        {
            Nodes.Insert(createNodeAction.IndexInList, stageNode);
        }
        else
        {
            Nodes.Add(stageNode);
        }
    }
示例#12
0
    void undoMove(DeleteNodeAction deleteNodeAction)
    {
        if (deleteNodeAction == null)
        {
            return;
        }

        StageNode stageNode = new StageNode(deleteNodeAction.Position, deleteNodeAction.Width);

        if (deleteNodeAction.IndexInList != GlobalConst.INVALID_ID)
        {
            nodes.Insert(deleteNodeAction.IndexInList, stageNode);
        }
        else
        {
            nodes.Add(stageNode);
        }
    }
示例#13
0
    void undoMove(CreateNodeAction createNodeAction)
    {
        if (createNodeAction == null)
        {
            return;
        }

        StageNode stageNode = new StageNode(createNodeAction.Position, createNodeAction.Width);

        if (createNodeAction.IndexInList != GlobalConst.INVALID_ID)
        {
            nodes.RemoveAt(createNodeAction.IndexInList);
        }
        else
        {
            nodes.RemoveAt(Nodes.Count - 1);
        }
    }
示例#14
0
    // Change given path's height so that it extends from stageA to stageB
    private void PositionVerticalPath(RectTransform path, StageNode stageA, StageNode stageB)
    {
        if (stageA == null || stageB == null)
        {
            Debug.LogWarning("Cannot position vertical path between null StageNodes");
            return;
        }
        RectTransform rectA = stageA.GetComponent <RectTransform>();
        RectTransform rectB = stageB.GetComponent <RectTransform>();

        path.sizeDelta = new Vector2(path.rect.width, Mathf.Abs(rectA.anchoredPosition.y - rectB.anchoredPosition.y) + path.rect.width);
        // Set absolute y of the path
        float     pathY          = (rectA.anchoredPosition.y + rectB.anchoredPosition.y) / 2;
        Transform originalParent = path.parent;

        path.SetParent(path.parent.parent);
        path.anchoredPosition = new Vector2(path.anchoredPosition.x, pathY);
        path.SetParent(originalParent);
    }
示例#15
0
    public StageNode[][] GenerateZoneMap(ZoneProperties properties)
    {
        StageNode[][] map = new StageNode[properties.columns.Length + 1][];

        // Initialize columns
        for (int col = 0; col < properties.columns.Length + 1; col++)
        {
            // Create column of nodes
            map[col] = new StageNode[properties.mapRows];
            for (int row = 0; row < properties.mapRows; row++)
            {
                map[col][row] = null;
            }
        }

        int middleRow = properties.mapRows / 2;

        _mapContainer.anchoredPosition = Vector3.zero;

        // Create starting column
        StageNode firstStage = InstantiateStageNode(properties, map, 0, middleRow);

        // Create end column (boss)
        StageNode finalStage = InstantiateStageNode(properties, map, properties.columns.Length, middleRow);

        InitializeStage(properties, properties.columns.Length, finalStage, StageCategory.BOSS);

        // Set first and last stage positions as scrolling bounds
        _mapScroller.SetBounds(firstStage.transform.position.x, finalStage.transform.position.x);

        // Create nodes in between
        for (int col = 1; col < properties.columns.Length; col++)
        {
            for (int row = 0; row < properties.mapRows; row++)
            {
                StageNode stage = InstantiateStageNode(properties, map, col, row).GetComponent <StageNode>();
                InitializeStage(properties, col, stage, properties.columns[col - 1].stageType);
            }
        }
        return(map);
    }
    private int GetStageIndex(StageNode stage)
    {
        if (!stage)
        {
            return(0);
        }

        var current = FirstNode;
        var count   = 0;

        while (current != stage)
        {
            if (!current.NextStage)
            {
                break;
            }
            current = current.NextStage;
            count++;
        }

        return(count);
    }
示例#17
0
    public bool Load(string filename)
    {
        try
        {
            FileStream   file = new FileStream(filename, FileMode.Open);
            BinaryReader br   = new BinaryReader(file);

            int version = br.ReadInt32();
            if (version != VERSION)
            {
                Debug.LogError(string.Format("StageData.Load, invalid stage data version({0}, {1} expected)!", version, VERSION));
                return(false);
            }

            _max_xcount = br.ReadInt32();
            _max_ycount = br.ReadInt32();

            int len = br.ReadInt32();
            for (int i = 0; i < len; i++)
            {
                int  key  = br.ReadInt32();
                uint mask = br.ReadUInt32();

                StageNode node = new StageNode();
                node.mask = mask;
                _data.Add(key, node);
            }

            br.Close();
            file.Close();
        }
        catch (IOException e)
        {
            Debug.LogError(e);
            return(false);
        }

        return(true);
    }
示例#18
0
    private StageNode.StageType MakeRandomStageType(int risk, int reward)
    {
        // todo: this ignores risk, reward for now.
        float valTotal = 0;

        foreach (var freq in stageTypeFrequencies)
        {
            valTotal += freq;
        }

        float random = Random.Range(0, valTotal);

        for (var num = 0; num < StageNode.NUM_STAGE_TYPES; num++)
        {
            random -= stageTypeFrequencies[num];
            if (random <= 0)
            {
                return(StageNode.GetStageTypeFromNum(num));
            }
        }

        return(StageNode.GetStageTypeFromNum(StageNode.NUM_STAGE_TYPES - 1));
    }
示例#19
0
 public void Respawn(StageNode node)
 {
     StageNode        = node;
     _renderer.sprite = Manager.Instance.GameCfg.BubbSprites[(int)node.BubbType];
 }
 private void SetTarget(StageNode node)
 {
     _targetStage          = node;
     _playerPositionTarget = GetLength(_targetStage);
     _moveSpeedMag         = 1 + Mathf.Abs(Position - _playerPositionTarget) * 0.8f;
 }
示例#21
0
    private void EnableNextPaths()
    {
        _mapDisplay.SetActive(true);
        if (_currCoord == null)
        {
            return;
        }
        if (_currCoord.col + 1 >= _currMap.Length)
        {
            NextMap();
            return;
        }
        _canMove = true;

        // Create branch leaving current node
        CreateBranch(GetCurrStage(), false);

        // Go through next column and find the topmost and bottommost stages that can be reached
        // Also, grey out unreachable stages
        int topBranchIndex    = -1;
        int bottomBranchIndex = -1;

        for (int i = 0; i < _currMap[_currCoord.col + 1].Length; i++)
        {
            StageNode stage = _currMap[_currCoord.col + 1][i];
            if (stage == null)
            {
                continue;
            }
            if (i < _currCoord.row - _moveRange || i > _currCoord.row + _moveRange)
            {
                stage.SetInaccessible();
            }
            else
            {
                if (topBranchIndex == -1)
                {
                    topBranchIndex = i;
                }
                if (bottomBranchIndex == -1 || i > bottomBranchIndex)
                {
                    bottomBranchIndex = i;
                }
            }
        }

        // Create branches entering each of the next nodes
        for (int i = topBranchIndex; i <= bottomBranchIndex; i++)
        {
            StageNode stage = _currMap[_currCoord.col + 1][i];
            if (stage != null)
            {
                CreateBranch(stage, true);
            }
        }

        // Connect all the branches with one vertical path
        StageNode stageA = _currMap[_currCoord.col + 1][topBranchIndex];
        StageNode stageB = _currMap[_currCoord.col + 1][bottomBranchIndex];

        if (_currCoord.row < topBranchIndex)
        {
            stageA = GetCurrStage();
        }
        else if (_currCoord.row > bottomBranchIndex)
        {
            stageB = GetCurrStage();
        }
        RectTransform verticalPath = Instantiate(_pathPrefab, GetCurrStage().transform).GetComponent <RectTransform>();

        verticalPath.anchoredPosition += new Vector2(_horizontalPadding / 2, 0);
        GetCurrStage().SetVerticalPath(verticalPath);
        PositionVerticalPath(verticalPath, stageA, stageB);
    }
示例#22
0
    // Use this for initialization
    public void SetUpNode(StageNode prevStage, int clearedCount, ref int followerCount)
    {
        if (GateRenderers.Length > 1)
        {
            _gateMaterial = GateRenderers[0].material;
            foreach (var item in GateRenderers)
            {
                item.sharedMaterial = _gateMaterial;
            }
        }

        _gateAnimator = GetComponentInChildren <Animator>();
        if (_gateAnimator)
        {
            _gateAnimator.SetFloat("DoorSpeed", -1 * _animSpeed);
        }

        OnIsSelectedChanged += e => {
            if (_gateAnimator)
            {
                var t = _gateAnimator.GetCurrentAnimatorStateInfo(0).normalizedTime;
                t = Mathf.Clamp(t, 0, 1);
                _gateAnimator.Play("gate", 0, t);
                _gateAnimator.SetFloat("DoorSpeed", (IsSelected ? 1 : -1) * _animSpeed);
            }
        };

        IsCleared = clearedCount > 0;

        PrevStage = prevStage;

        // クリア状態を表示
        if (_gateMaterial)
        {
            _gateMaterial.EnableKeyword("EMISSION");
            var c = IsCleared ? new Color(2, 2, 0) : new Color(2, 0, 0);
            _gateMaterial.SetColor("_EmissionColor", c);
        }

        // 助けた数を表示
        FollowerFindData followerData = new FollowerFindData();

        GameData.Instance.GetData(TargetStageName + StageController.StageFollowerDataTarget, ref followerData);
        var count = followerData.FindedIndexList.Count;

        followerCount += count;
        for (int i = 0; i < FindedFollowerPositions.Count; i++)
        {
            var        t = FindedFollowerPositions[i];
            GameObject f;
            if (i >= count)
            {
                f = Instantiate(FollowerModelPrefab, t.position, t.rotation);
                // 助けてなければ黒色にする
                var rs = f.GetComponentsInChildren <Renderer>();
                foreach (var item in rs)
                {
                    item.material.EnableKeyword("EMISSION");
                    item.material.SetColor("_EmissionColor", new Color(.25f, .25f, .25f));
                }
            }
            else
            {
                f = Instantiate(FollowerChipPrefab, t.position, t.rotation);
            }
            f.transform.localScale = Vector3.one * 0.75f;
        }


        if (NextStage)
        {
            NextStage.SetUpNode(this, --clearedCount, ref followerCount);
        }
    }
示例#23
0
 public void SetData(StageNode node)
 {
     Data = node.Data;
 }
示例#24
0
    private void InitializeCombatStage(ZoneProperties properties, int stageCol, StageNode stage, BattleType battleType)
    {
        StageInfoContainer stageInfo = new StageInfoContainer(properties.columns[stageCol - 1], battleType);

        stage.SetStageInfoContainer(stageInfo);
    }
示例#25
0
    private StageNode GenerateLevelStartStage()
    {
        int totalDepth   = levelStageDepth;
        int targetWidth  = levelTargetStageWidths[currentLevel];
        int maxWidthDiff = 2;

        Debug.Log("Making stages:");
        List <StageNode> prevStages = new List <StageNode>();
        StageNode        start      = new StageNode(this, 0, 0, firstStageType, 0, 0);

        prevStages.Add(start);
        for (var depth = 1; depth < totalDepth; depth++)
        {
            Debug.Log("Depth=" + depth);
            int prevWidth = prevStages.Count;
            int newWidth  = Math.Max(RandomTowardsTarget(prevWidth, targetWidth, maxWidthDiff), 2);
            if (currentLevel == 0 && depth == 1)
            {
                newWidth = 1;  // initial room only has one way down.
            }
            Debug.Log("Will make" + newWidth + " new");
            List <StageNode> newStages = new List <StageNode>();
            int connectedPrevUntil     = 0;
            for (var newStageNum = 0; newStageNum < newWidth; newStageNum++)
            {
                // if we have an equal mapping, every prev has to point to newWidth / prevWidth.
                int connectToLeft = prevWidth - connectedPrevUntil - 1;
                Debug.Log("Make new " + newStageNum + ", with connectToLeft=" + connectToLeft);
                bool connectAgain = Random.Range(0, 2) == 0;
                connectAgain |= newStageNum == 0;                                   // have to connect to first.
                connectAgain |= connectToLeft == 0;                                 // have to connect if nothing else left
                int willConnectTo = (int)((connectToLeft * 1f / (newWidth - newStageNum)));
                willConnectTo = Random.Range(willConnectTo - 1, willConnectTo + 1); // add some noise
                willConnectTo = Math.Min(Math.Max(willConnectTo, 1), connectToLeft);
                Debug.Log("Decided to connect again=" + connectAgain + " and to news=" + willConnectTo + " from the" + connectToLeft + " that are left");

                var connectToPrevStages = new List <StageNode>();
                var startAtOldStageNum  = connectedPrevUntil + (connectAgain ? 0 : 1);
                var newConnectPrevUntil = connectedPrevUntil + willConnectTo;
                Debug.Log("Thus will connect to prev nodes from " + startAtOldStageNum + " to " + (connectedPrevUntil + 1 + willConnectTo));
                int riskSum   = 0;
                int rewardSum = 0;
                for (var oldStageNum = startAtOldStageNum; oldStageNum <= newConnectPrevUntil; oldStageNum++)
                {
                    connectToPrevStages.Add(prevStages[oldStageNum]);
                    riskSum   += prevStages[oldStageNum].pathRisk;
                    rewardSum += prevStages[oldStageNum].pathReward;
                }

                int risk          = riskSum / connectToPrevStages.Count;
                int reward        = rewardSum / connectToPrevStages.Count;
                var nextStageType = MakeRandomStageType(risk, reward);
                var newStage      = new StageNode(this, depth, newStageNum, nextStageType,
                                                  risk + GetTypeRisk(nextStageType), reward + GetTypeReward(nextStageType));
                foreach (var oldStage in connectToPrevStages)
                {
                    oldStage.nextStages.Add(newStage);
                }
                newStages.Add(newStage);
                connectedPrevUntil = newConnectPrevUntil;
            }
            prevStages = newStages;
        }

        Debug.Log("start stage is:");
        Debug.Log(start);
        return(start);
    }
示例#26
0
    public void RerenderMap()
    {
        ClearMap();
        StageNode startNode   = myManager.currentLevelStartStage;
        int       depthLayers = RoomDepth(startNode, 1);

        // create depth linspace
        List <float> linspaceD = new List <float>();

        for (int i = 0; i < (int)depthLayers; i++)
        {
            linspaceD.Add(bound.max.y + (bound.min.y - bound.max.y) * (float)i / (float)((int)depthLayers));
        }

        List <float> lastLinspace = new List <float>();
        Dictionary <int, List <int> > nodeToParents = new Dictionary <int, List <int> >();

        List <StageNode> currLayer = new List <StageNode> {
            startNode
        };

        while (currLayer.Count != 0)
        {
            // Draw the Rooms from the previous layer ...
            List <float> currLayerDrawPosX = new List <float>();
            float        offset            = Mathf.Min(spacing, (float)(bound.max.x - bound.min.x) / currLayer.Count);
            float        middle            = bound.center.x - offset * currLayer.Count / 2f;
            for (int horizontalPos = 0; horizontalPos < currLayer.Count; horizontalPos++)
            {
                currLayerDrawPosX.Add(middle + offset * (float)horizontalPos);
            }

            for (int horizontalPos = 0; horizontalPos < currLayer.Count; horizontalPos++)
            {
                DrawIcon(currLayer[horizontalPos].type, new Vector2(currLayerDrawPosX[horizontalPos], linspaceD[currLayer[horizontalPos].stageDepth]));
                if (SameRoom(currLayer[horizontalPos], myManager.currentStage))
                {
                    DrawPlayer(new Vector2(currLayerDrawPosX[horizontalPos], linspaceD[currLayer[horizontalPos].stageDepth]));
                }
            }

            // Draw the lines
            foreach (StageNode node in currLayer)
            {
                if (node.stageDepth > 0)
                {
                    var parents = nodeToParents[node.horizontalNum];
                    foreach (int parent in parents)
                    {
                        Vector2 p0         = new Vector2(lastLinspace[parent], linspaceD[node.stageDepth - 1]);
                        Vector2 p1         = new Vector2(currLayerDrawPosX[node.horizontalNum], linspaceD[node.stageDepth]);
                        Color   col        = new Color(194, 194, 209);
                        int     wayDownNum = myManager.GetCurrentRoom().wayDownNum;

                        if (myManager.currentStage.stageDepth == node.stageDepth - 1 && myManager.currentStage.horizontalNum == parent && wayDownNum >= 0 && node.horizontalNum == myManager.currentStage.nextStages[wayDownNum].horizontalNum)
                        {
                            DrawLine(p0, p1, true, thickness);
                        }
                        else
                        {
                            DrawLine(p0, p1, false, thickness);
                        }
                    }
                }
            }
            // Prepare next stage
            nodeToParents.Clear();
            List <StageNode> tmp = new List <StageNode>();
            foreach (StageNode node in currLayer)
            {
                foreach (StageNode child in node.nextStages)
                {
                    if (!nodeToParents.ContainsKey(child.horizontalNum))
                    {
                        nodeToParents.Add(child.horizontalNum, new List <int>());
                    }
                    nodeToParents[child.horizontalNum].Add(node.horizontalNum);
                    if (tmp.Count == 0 || !SameRoom(tmp[tmp.Count - 1], child))
                    {
                        tmp.Add(child);
                    }
                }
            }
            lastLinspace = currLayerDrawPosX;
            currLayer    = tmp;
        }
    }
示例#27
0
 private bool SameRoom(StageNode a, StageNode b)
 {
     return(a.horizontalNum == b.horizontalNum && a.stageDepth == b.stageDepth);
 }