C# State.Clone方法代码示例

		public void StateConstruction()
		{
			var blueHand = new PlayHand(new[]
			                            	{
			                            		new PlayCard(CardInfo.CardPool["Squall"]),
			                            		new PlayCard(CardInfo.CardPool["Krysta"]),
			                            		new PlayCard(CardInfo.CardPool["Wendigo"]),
			                            		new PlayCard(CardInfo.CardPool["Behemoth"]),
			                            		new PlayCard(CardInfo.CardPool["Tonberry"]),
			                            	}, true);
			var redHand = new PlayHand(new[]
			                           	{
			                           		new PlayCard(CardInfo.CardPool["Torama"]),
			                           		new PlayCard(CardInfo.CardPool["Gerogero"]),
			                           		new PlayCard(CardInfo.CardPool["Buel"]),
			                           		new PlayCard(CardInfo.CardPool["Bomb"]),
			                           		new PlayCard(CardInfo.CardPool["Diablos"]),
			                           	}, false);
			var state = new State(new PlayField(), RuleModifier.None, blueHand, redHand, true);

			Assert.That(state.bluePoints, Is.EqualTo(5));
			state.bluePoints--;
			Assert.That(state.bluePoints, Is.EqualTo(4));
			State clone = state.Clone();
			Assert.That(clone.bluePoints, Is.EqualTo(4));
			clone.bluePoints--;
			Assert.That(state.bluePoints, Is.EqualTo(4));
			Assert.That(clone.bluePoints, Is.EqualTo(3));
		}

        // Runs a Monte Carlo Tree Search from the given root node
        // Limited by number of iterations
        public Node IterationLimited(State rootState, int iterations)
        {
            Node rootNode = new Node(null, null, rootState);

            for (int i = 0; i < iterations; i++)
            {
                Node node = rootNode;
                State state = rootState.Clone();

                // 1: Select
                while (node.UntriedMoves.Count == 0 && node.Children.Count != 0)
                {
                    if (state.Player == GameEngine.COMPUTER)
                    {
                        Move move = state.GetRandomMove();
                        state = state.ApplyMove(move);
                        Node parent = node;
                        node = new Node(move, parent, state);
                    }
                    else
                    {
                        node = node.SelectChild();
                        state = state.ApplyMove(node.GeneratingMove);
                    }
                }

                // 2: Expand
                if (node.UntriedMoves.Count != 0)
                {
                    Move randomMove = node.UntriedMoves[random.Next(0, node.UntriedMoves.Count)];
                    state = state.ApplyMove(randomMove);
                    node = node.AddChild(randomMove, state);
                }

                // 3: Simulation
                state = SimulateGame(state, EXPECTIMAX_POLICY);

                // 4: Backpropagation
                while (node != null)
                {
                    node.Update(state.GetResult());
                    node = node.Parent;
                }
            }
            return rootNode;
        }

        public override List<KeyValuePair<int, int>> Solve()
        {
            List<KeyValuePair<int, int>> result = new List<KeyValuePair<int, int>>();
            GenColumnValues();
            GenRowValues();

            RemoveEmptyRows();
            _columnIndexes = _columnIndexes.AsParallel()
                .OrderBy(i => GetColumnValue(i))
                .ToList();

            states = new List<State>();
            State state = new State();
            states.Add(state);
            Random rnd = new Random(15);
            while (!Empty())
            {
                State state2 = state.Clone();

                int column;
                int row = GetBestRow(out column);

                state.AddRow(row, GetRowValue(row));
                states.Add(state);

                row = GetBest2Row(out column);

                state2.AddRow(row, GetRowValue(row));
                states.Add(state2);

                state = states.OrderByDescending(x => x.Value *(float)(0.75 + 0.25 * rnd.NextDouble())).First();
                states.Remove(state);
                LoadState(state);
            }

            result = state.Rows.Select(x => new KeyValuePair<int, int>(x, 0)).ToList();
            //while (!Empty())
            //{
            //    int column;
            //    int row = GetSyndromRow(out column);

            //    KeyValuePair<int, int> syndromElement = new KeyValuePair<int, int>(row, column);
            //    result.Add(syndromElement);
            //}
            return result;
        }

        public void StateTests()
        {
            var s = new State();
            Assert.That(s.Start, Is.False);
            Assert.That(s.Final, Is.False);

            s.Start = true;
            Assert.That(s.Start, Is.True);
            Assert.That(s.Final, Is.False);

            s.Final = true;
            Assert.That(s.Start, Is.True);
            Assert.That(s.Final, Is.True);

            s.Start = false;
            Assert.That(s.Start, Is.False);
            Assert.That(s.Final, Is.True);

            var s2 = s.Clone();
            Assert.That(s2, Is.EqualTo(s));
        }

 public State Migrate(State s)
 {
     var newState = s.Clone() as State;
     Execute(newState);
     return newState;
 }

        /// <summary>
        /// FSNSequence 해석. 분기마다 builderState를 복제해야 하므로 새로 호출된다.
        /// </summary>
        /// <param name="builderState"></param>
        /// <param name="snapshotSeq">이번 콜에서 생성할 시퀀스 이전의 스냅샷 인덱스</param>
        /// <param name="bs"></param>
        /// <param name="linkToLast">이 메서드를 호출하기 바로 이전의 Snapshot에 연결할지 여부. 기본은 true. 선택지 등등에서 false로 해줘야함</param>
        /// <returns>이번 콜에서 생성한 시퀀스들 중 제일 첫번째 것. 다른 시퀀스 흐름과 연결할 때 사용 가능</returns>
        static Segment ProcessSnapshotBuild(State bs, FSNSnapshotSequence snapshotSeq, int prevSnapshotIndex, bool linkToLast = true)
        {
            ModuleCallQueue moduleCalls	= new ModuleCallQueue();

            Segment	sseg;														// 새로 생성할 Segment/Snapshot
            FSNSnapshot sshot;
            NewSnapshot(out sseg, out sshot);

            var firstSeg		= sseg;											// 최초 스냅샷
            var prevCallSeg		= snapshotSeq.Get(prevSnapshotIndex);			// 이번에 생성할 시퀀스의 이전 스냅샷

            var lastSeg			= prevCallSeg;									// 바로 이전에 처리한 스냅샷 (최초 루프시에는 실행 이전의 마지막 스냅샷과 동일)

            List<Segments.Control>	jumpSegs	= new List<Segments.Control>();	// 점프(goto, SwipeOption 등) 세그먼트가 등장했을 경우 여기에 보관된다
            List<Segment.CallFuncInfo> funcCalls= new List<Segment.CallFuncInfo>();	// 함수 콜이 있을 경우 여기에 먼저 누적하고 period때 한번에 처리한다

            float snapshotDelay	= 0f;											// 스냅샷에 적용할 지연 시간 (/기다리기 커맨드)
            //

            // 처음 시작할 때는 무조건 모든 객체들을 Hard-Clone한다 (분기점에서 Initial/Final 스테이트 독립을 하기 위해)

            moduleCalls.CatchupPreviousLayerState(prevCallSeg.snapshot);		// 기존의 유효한 Layer들을 활성화 (안그러면 모듈 콜을 누락해버림)
            moduleCalls.AddAllModuleCall(new Segments.HardClone(), bs.settings);

            // 스크립트 Sequence가 끝나거나 특정 명령을 만날 때까지 반복

            bool keepProcess	= true;
            while(keepProcess)
            {
                var curSeg	= bs.sequence[bs.segIndex];							// 현재 명령어 (Sequence 세그먼트)
                FSNDebug.currentProcessingScriptLine = curSeg.scriptLineNumber;	// 디버깅 정보 세팅 (줄 번호)

                switch(curSeg.type)												// 명령어 타입 체크 후 분기
                {
                //////////////////////////////////////////////////////////////
                case FSNScriptSequence.Segment.Type.Setting:							// ** 세팅
                {
                    var settingSeg		= curSeg as Segments.Setting;

                    if(settingSeg.settingMethod == Segments.Setting.SettingMethod.Pop)	// * 세팅 pop
                    {
                        if(bs.settings.ParentChain != null)
                        {
                            bs.settings	= bs.settings.ParentChain;
                        }
                        else
                        {
                            Debug.LogError("Cannot pop settings anymore - there is no settings pushed");
                        }
                    }
                    else
                    {
                        if(settingSeg.settingMethod == Segments.Setting.SettingMethod.Push)	// * Push일 경우에는 새 Chain을 생성한다
                        {
                            bs.settings	= new FSNInGameSetting.Chain(bs.settings);
                        }

                        foreach(var settingPair in settingSeg.RawSettingTable)	// Setting 설정
                        {
                            bs.settings.SetPropertyByString(settingPair.Key, settingPair.Value);
                        }
                    }

                    bs.SetSettingDirty();										// 세팅 변경됨 플래그 올리기
                }
                break;
                //////////////////////////////////////////////////////////////
                case FSNScriptSequence.Segment.Type.Text:						// ** 텍스트
                {
                    var module			= FSNEngine.Instance.GetModule(FSNEngine.ModuleType.Text) as IFSNProcessModule;

                    moduleCalls.AddCall(module, curSeg, bs.FrozenSetting);		// 해당 명령 저장
                }
                break;
                //////////////////////////////////////////////////////////////
                case FSNScriptSequence.Segment.Type.Object:						// ** 오브젝트 (이미지 등)
                {
                    var objSeg	= curSeg as Segments.Object;
                    var module	= FSNEngine.Instance.GetModuleByLayerID(objSeg.layerID) as IFSNProcessModule;

                    moduleCalls.AddCall(module, objSeg, bs.FrozenSetting);
                }
                break;
                //////////////////////////////////////////////////////////////
                case FSNScriptSequence.Segment.Type.Label:						// ** 레이블
                {
                    //var labelSeg		= curSeg as Segments.Label;
                    // 현재 이 시점에서는 labelSeg로 하는 일이 없다...
                    //Debug.Log("Label : " + labelSeg.labelName);
                }
                break;
                //////////////////////////////////////////////////////////////
//.........这里部分代码省略.........

        // Runs a Monte Carlo Tree Search limited by a given time limit
        public Node TimeLimited(State rootState, int timeLimit, Stopwatch timer)
        {
            Node rootNode = new Node(null, null, rootState);
            while (true)
            {
                if (timer.ElapsedMilliseconds > timeLimit)
                {
                    if (FindBestChild(rootNode.Children) == null && !rootNode.state.IsGameOver())
                    {
                        timeLimit += 10;
                        timer.Restart();
                    }
                    else
                    {
                        return rootNode;
                    }
                }
                Node node = rootNode;
                State state = rootState.Clone();

                // 1: Select
                while (node.UntriedMoves.Count == 0 && node.Children.Count != 0)
                {
                    node = node.SelectChild();
                    state = state.ApplyMove(node.GeneratingMove);
                }

                // 2: Expand
                if (node.UntriedMoves.Count != 0)
                {
                    Move randomMove = node.UntriedMoves[random.Next(0, node.UntriedMoves.Count)];
                    state = state.ApplyMove(randomMove);
                    node = node.AddChild(randomMove, state);
                }

                // 3: Simulation
                state = SimulateGame(state, EXPECTIMAX_POLICY);

                // 4: Backpropagation
                while (node != null)
                {
                    node.Update(state.GetResult());
                    node = node.Parent;
                }
            }
        }