C# MatchState类代码示例

        public void TestStateClone()
        {
			MatchState state = new MatchState(new PhysicsEngine(new GameWorld(null)));

			IEntity e = new IEntity(IDGenerator.GenerateID(), new Vec2(100f, -99f), 1f, 1f, 1f);
			state.AddEntity(e);

			Assert.True(state.ContainsEntity(e.ID), "entity1 added to match");

			IEntity e2 = new IEntity(IDGenerator.GenerateID(), new Vec2(42f, 24f), 1f, 1f, 1f);
			state.AddEntity(e2);

			Assert.True(state.ContainsEntity(e2.ID), "entity2 added to match");


			MatchState clone = state.Clone() as MatchState;

			Assert.True(clone.ContainsEntity(e.ID), "clone contains entity1");
			Assert.True(clone.ContainsEntity(e2.ID), "clone contains entity2");

			IEntity clonedE = clone.GetEntity(e.ID);
			TestClonedEntityValues(e, clonedE, true, "after clone (e1)");

			ChangeClonedEntity(clonedE, new Vec2(11f, 111f), new Vec2(22f, 222f), 1000f, 2000f, 333f);
			TestClonedEntityValues(e, clonedE, false, "after clone modif (e1)");

			IEntity clonedE2 = clone.GetEntity(e2.ID);
			TestClonedEntityValues(e2, clonedE2, true, "after clone (e2)");

			ChangeClonedEntity(clonedE2, new Vec2(87f, 78f), new Vec2(52f, 25f), 76f, 88f, 2121f);
			TestClonedEntityValues(e2, clonedE2, false, "after clone modif (e2)");
        }

 private static int ClassEnd( MatchState ms, int p )
 {
     var lua = ms.Lua;
     switch( ms.Pattern[p++] )
     {
         case L_ESC:
         {
             if( p == ms.PatternEnd )
                 lua.L_Error( "malformed pattern (ends with '%')" );
             return p+1;
         }
         case '[':
         {
             if( ms.Pattern[p] == '^' ) p++;
             do {
                 if( p == ms.PatternEnd )
                     lua.L_Error( "malformed pattern (missing ']')" );
                 if( ms.Pattern[p++] == L_ESC && p < ms.PatternEnd )
                     p++; // skip escapes (e.g. `%]')
             } while( ms.Pattern[p] != ']' );
             return p+1;
         }
         default: return p;
     }
 }

        private static int ClassEnd( ref MatchState ms, int pPos )
        {
            var pat = ms.Pat;

            switch( pat[pPos++] )
            {
            case (byte)'%':
                if( pPos == pat.Length )
                    throw new ArgumentException( "Malformed pattern (ends with %%)" );
                return pPos + 1;

            case (byte)'[':
                if( pat[pPos] == (byte)'^' )
                    pPos++;

                do
                {
                    if( pPos == pat.Length )
                        throw new ArgumentException( "Malformed pattern (missing ']')" );

                    if( pat[pPos++] == (byte)'%' && pPos < pat.Length )
                        pPos++;
                } while( pat[pPos] != (byte)']' );

                return pPos + 1;

            default:
                return pPos;
            }
        }

 private static int CheckCapture( MatchState ms, char l )
 {
     var lua = ms.Lua;
     int i = (int)(l - '1');
     if( i < 0 || i >= ms.Level || ms.Capture[i].Len == CAP_UNFINISHED )
         return lua.L_Error( "invalid capture index %d", i+1 );
     return i;
 }

 public void Start()
 {
     if (State == MatchState.Ready)
     {
         _broadcastHandler.BroadcastConfiguration(_mode.GetConfiguration());
         State = MatchState.Loading;
     }
 }

    private void GG(int winning_player_num)
    {
        state = MatchState.PostMatch;
        //match_audio.PlayGameOver();
        TimeScaleManager.Instance.AddMultiplier("GG_slow", 0.3f);
        this.winner_player_num = winning_player_num;

        StartCoroutine(TranInGGPage());
    }

        public Match()
        {
            Id = Guid.NewGuid();
            _matchState = MatchState.NotStarted;

            // TODO: set up teams based on docuDB
            Team1 = new Team(0, "red team");
            Team2 = new Team(1, "blue team");
        }

 private static int CaptureToClose( MatchState ms )
 {
     var lua = ms.Lua;
     int level=ms.Level;
     for( level--; level>=0; level-- )
     {
         if( ms.Capture[level].Len == CAP_UNFINISHED )
             return level;
     }
     return lua.L_Error( "invalid pattern capture" );
 }

        public GameMatch(string mapPath)
        {
			World = new GameWorld(mapPath);
			Physics = new PhysicsEngine(World);
			CurrentState = new MatchState(Physics);

			LeftStructures = new TeamStructures(Teams.Left,
				World.Map.Meta.LeftMeta.BaseTileIds,
				World.Map.Meta.LeftMeta.BaseTowerTileIds,
                World.Map.Meta.LeftMeta.TopTowerTileIds,
                World.Map.Meta.LeftMeta.BottomTowerTileIds);
			RightStructures = new TeamStructures(Teams.Right,
				World.Map.Meta.RightMeta.BaseTileIds,
                World.Map.Meta.RightMeta.BaseTowerTileIds,
                World.Map.Meta.RightMeta.TopTowerTileIds,
                World.Map.Meta.RightMeta.BottomTowerTileIds);

			Structures = new List<IStructure>();
			LeftStructures.Structures.ForEach(Structures.Add);
			RightStructures.Structures.ForEach(Structures.Add);
        }

        private void AdvanceState(Side side)
        {
            if (side == Side.One)
            {
                sideOneScore++;
            }

            if (side == Side.Two)
            {
                sideTwoScore++;
            }

            if (sideOneScore >= 2)
            {
                state = MatchState.MatchWonBySideOne;
            }

            if (sideTwoScore >= 2)
            {
                state = MatchState.MatchWonBySideTwo;
            }
        }

		private static int MinExpand( MatchState ms, int s, int p, int ep )
		{
			for(;;)
			{
				int res = Match( ms, s, ep+1 );
				if( res >= 0 )
					return res;
				else if( s < ms.SrcEnd && SingleMatch( ms, ms.Src[s], p, ep ) )
					s++; // try with one more repetition
				else return -1;
			}
		}

		private static int MaxExpand( MatchState ms, int s, int p, int ep )
		{
			int i = 0; // counts maximum expand for item
			while( (s+i) < ms.SrcEnd && SingleMatch( ms, ms.Src[s+i], p, ep ) )
				i++;
			// keeps trying to match with the maximum repetitions
			while( i >= 0 )
			{
				int res = Match( ms, (s+i), (ep+1) );
				if( res >= 0 ) return res;
				i--; // else didn't match; reduce 1 repetition to try again
			}
			return -1;
		}

		private static int Str_Gsub( ILuaState lua )
		{
			
			string src = lua.L_CheckString(1);
			int srcl = src.Length;
			string p = lua.L_CheckString(2);
			LuaType tr = lua.Type(3);
			int max_s = lua.L_OptInt(4, srcl + 1);
			int anchor = 0;
			if (p[0] == '^')
			{
                p = p.Substring(1);
                anchor = 1;
			}
			int n = 0;
			MatchState ms = new MatchState();
			StringBuilder b = new StringBuilder(srcl);
			lua.L_ArgCheck(tr == LuaType.LUA_TNUMBER || tr == LuaType.LUA_TSTRING ||
						   tr == LuaType.LUA_TFUNCTION || tr == LuaType.LUA_TTABLE, 3,
							  "string/function/table expected");
			ms.Lua = lua;
			ms.Src = src;
			ms.SrcInit = 0;
			ms.SrcEnd = srcl;
			ms.Pattern = p;
			ms.PatternEnd = p.Length;
			int s = 0;
			while (n < max_s) {
			   ms.Level = 0;
			   int e = Match(ms, s, 0);
			   if (e != -1) {
			       n++;
				   Add_Value(ms, b, s, e);
			   }
			   if ((e != -1) && e > s) /* non empty match? */
			      s = e;  /* skip it */
			   else if (s < ms.SrcEnd)
			   {
			       char c = src[s];
				   ++s;
			       b.Append(c);
			   }
			   else break;
			   if (anchor != 0) break;
		    }
			b.Append(src.Substring(s, ms.SrcEnd - s));
			lua.PushString(b.ToString());
		    lua.PushInteger(n);  /* number of substitutions */
		    return 2;
		}

		private static void Add_S (MatchState ms, StringBuilder b, int s, int e) {
		  string news = ms.Lua.ToString(3);
		  for (int i = 0; i < news.Length; i++) {
			if (news[i] != L_ESC)
			  b.Append(news[i]);
			else {
			  i++;  /* skip ESC */
			  if (!Char.IsDigit((news[i])))
			      b.Append(news[i]);
			  else if (news[i] == '0')
				  b.Append(ms.Src.Substring(s, (e - s))); 
			  else {
				PushOneCapture(ms, news[i] - '1', s, e);
				b.Append(ms.Lua.ToString(-1));  /* add capture to accumulated result */
			  }
			}
		  }
		}

		private static int StrFindAux( ILuaState lua, bool find )
		{
			string s = lua.L_CheckString( 1 );
			string p = lua.L_CheckString( 2 );
			int init = PosRelative( lua.L_OptInt(3, 1), s.Length );
			if( init < 1 ) init = 1;
			else if( init > s.Length + 1 ) // start after string's end?
			{
				lua.PushNil(); // cannot find anything
				return 1;
			}
			// explicit request or no special characters?
			if( find && (lua.ToBoolean(4) || NoSpecials(p)) )
			{
				// do a plain search
				int pos = s.IndexOf( p, init-1 );
				if( pos >= 0 )
				{
					lua.PushInteger( pos+1 );
					lua.PushInteger( pos+p.Length );
					return 2;
				}
			}
			else
			{
				int s1 = init-1;
				int ppos = 0;
				bool anchor = p[ppos] == '^';
				if( anchor )
					ppos++; // skip anchor character

				MatchState ms = new MatchState();
				ms.Lua = lua;
				ms.Src = s;
				ms.SrcInit = s1;
				ms.SrcEnd = s.Length;
				ms.Pattern = p;
				ms.PatternEnd = p.Length;

				do
				{
					ms.Level = 0;
					int res = Match( ms, s1, ppos );
					if( res != -1 )
					{
						if(find)
						{
							lua.PushInteger( s1+1 ); // start
							lua.PushInteger( res );  // end
							return PushCaptures(lua, ms, -1, 0) + 2;
						}
						else return PushCaptures(lua, ms, s1, res);
					}
				} while( s1++ < ms.SrcEnd && !anchor );
			}
			lua.PushNil(); // not found
			return 1;
		}