C# Hashtable.Add方法代码示例

        private Client client; // Socket

        void Start()
        {
            this.client = GameObject.Find("Manager").GetComponent<ClientManager>().Client;
            user = User.Instance;
            if (user.is_connected)
            {
                PhotonNetwork.playerName = user.username;

                PhotonPeer.RegisterType(typeof(Team), (byte)'T', ObjectToByteArray, ByteToTeam);
                PhotonPeer.RegisterType(typeof(Composition), (byte)'C', ObjectToByteArray, ByteToComposition);
                PhotonPeer.RegisterType(typeof(Player), (byte)'P', ObjectToByteArray, ByteToPlayer);
                PhotonPeer.RegisterType(typeof(User), (byte)'U', ObjectToByteArray, ByteToUser);
                PhotonPeer.RegisterType(typeof(List<string>), (byte)'L', ObjectToByteArray, ByteToLS);

                PhotonHastable props = new PhotonHastable();

                props.Add("Team", Settings.Instance.Selected_Team);
                props.Add("User", user);

                PhotonNetwork.player.SetCustomProperties(props);

                PhotonNetwork.ConnectUsingSettings(game_version_);
                this.room_name = user.username + "-" + rand.Next(1000);
            }
        }

	void ReceiveInitialSpawnInfo(int id, PhotonPlayer player, Vector3 pos, Quaternion rot, string playerTypeName, int teamNumber, PhotonMessageInfo info)
	{
		
		if ((info.sender != PhotonNetwork.masterClient) &&
			(info.sender != PhotonNetwork.player))
			return;

		// initialize the newborn player with the mandatory 'on-join-stats'
		ExitGames.Client.Photon.Hashtable stats = new ExitGames.Client.Photon.Hashtable();
		stats.Add("Type", playerTypeName);
		stats.Add("Team", teamNumber);
		stats.Add("Position", pos);
		stats.Add("Rotation", rot);

		// announce arrival of new player
		if (player.ID > PhotonNetwork.player.ID)
			vp_MPDebug.Log("Player " + player.name + " joined"
				+ ((vp_MPTeamManager.Exists && (teamNumber > 0)) ? " team : " + vp_MPTeamManager.GetTeamName(teamNumber).ToUpper() : "")
				);
		else if (player.ID == PhotonNetwork.player.ID)
		{
			vp_Timer.In(0.1f, delegate()
			{
				//Debug.Log("teamNumber: " + teamNumber);
				
				try
				{
					vp_MPDebug.Log(
						"Welcome to '"
						+ PhotonNetwork.room.name
						+ "' with "
						+ PhotonNetwork.room.playerCount.ToString()
						+ ((PhotonNetwork.room.playerCount == 1) ? " player (you)" : " players")
						+ "."
						);
					//vp_MPDebug.Log("Max players for room: " + PhotonNetwork.room.maxPlayers + ".");
					//vp_MPDebug.Log("Total players using app: " + PhotonNetwork.countOfPlayers);
					if (vp_MPTeamManager.Exists && (teamNumber > 0))
						vp_MPDebug.Log("Your team is: " + vp_MPTeamManager.GetTeamName(teamNumber).ToUpper());
				}
				catch
				{
					if (PhotonNetwork.room == null)
						Debug.Log("PhotonNetwork.room = null");
					else if (PhotonNetwork.room.name == null)
						Debug.Log("PhotonNetwork.room.name = null");
					if (vp_MPTeamManager.Instance == null)
						Debug.Log("vp_MPTeamManager.Instance = null");
					else if (vp_MPTeamManager.GetTeamName(teamNumber) == null)
						Debug.Log("vp_MPMaster.GetTeamName(teamNumber) = null");
				}

			});
		}

		InstantiatePlayerPrefab(player, stats);

	}

    /// <summary>
    /// Callback used when the player successfully joins a room.
    /// </summary>
    public void OnJoinedRoom()
    {
        playersInRoom = new List<PhotonPlayer>(PhotonNetwork.playerList);
        myTeam = (TeamTypes)((playersInRoom.Count + 1) % 2);


        ExitGames.Client.Photon.Hashtable properties = new ExitGames.Client.Photon.Hashtable();
        properties.Add("Team", myTeam.GetHashCode());
        properties.Add("Character", myCharacter.GetHashCode());
        properties.Add("PlayFabID", PlayFabManager.instance.GetMyPlayerID());

        bool containsOwner = false;
        for (int i = 0; i < PhotonNetwork.otherPlayers.Length; i++)
        {
            object ownerName;
            if (PhotonNetwork.otherPlayers[i].customProperties.TryGetValue("Owner", out ownerName))
            {
                containsOwner = true;
                break;
            }
        }
        if (!containsOwner)
        {
            properties.Add("Owner", PhotonNetwork.player.name);
        }
        PhotonNetwork.player.SetCustomProperties(properties);

        myRoomInfo = PhotonNetwork.room;

        OnJoinedRoomCallback(PhotonNetwork.room);
    }

    /// <summary>
    /// Updates player status to ready.
    /// </summary>
    public void SetReady()
    {
        ExitGames.Client.Photon.Hashtable properties = new ExitGames.Client.Photon.Hashtable();
        properties.Add("Ready", true);
        PhotonNetwork.player.SetCustomProperties(properties);

        networkLayer.OnPropertiesChanged();
    }

    /// <summary>
    /// Rotates player between teams.
    /// </summary>
    public void ChangeTeam(TeamTypes newTeam, bool syncNetwork)
    {
        myTeam = newTeam;

        ExitGames.Client.Photon.Hashtable properties = new ExitGames.Client.Photon.Hashtable();
        properties.Add("Team", myTeam.GetHashCode());
        PhotonNetwork.player.SetCustomProperties(properties);

        if (syncNetwork)
        {
            networkLayer.OnPropertiesChanged();
        }
    }

    /// <summary>
    /// Changes player avatar, to the one the player has chosen.
    /// </summary>
    /// <param name="myType">New character.</param>
    /// <param name="syncNetwork">If will send data to the network.</param>
    public void ChangePlayerAvatar(CharacterTypes myType, bool syncNetwork)
    {
        if (myCharacter != myType)
        {
            myCharacter = myType;

            ExitGames.Client.Photon.Hashtable properties = new ExitGames.Client.Photon.Hashtable();
            properties.Add("Character", myCharacter.GetHashCode());
            PhotonNetwork.player.SetCustomProperties(properties);

            if (syncNetwork)
            {
                networkLayer.OnPropertiesChanged();
            }
        }
    }

    /// <summary>
    /// Starts game.
    /// </summary>
    public void StartGame()
    {
		ExitGames.Client.Photon.Hashtable properties = new ExitGames.Client.Photon.Hashtable();
		properties.Add("Ready", false);
		PhotonNetwork.player.SetCustomProperties(properties);

        networkLayer.ActivateLevel();
        //networkLayer.AllocateViewIDAndCallInstantiate(myCharacter, myTeam);
    }

    /// <summary>
    /// Method to be called when the user wants to create a new room.
    /// </summary>
    public void CreateNewRoom(int numberOfPlayers,ProjectDelegates.RoomInfoCallback RoomCreatedCallback, int level)
    {
        OnJoinedRoomCallback = RoomCreatedCallback;

        ExitGames.Client.Photon.Hashtable customParams = new ExitGames.Client.Photon.Hashtable();
        customParams.Add("C0", level);

        RoomOptions options = new RoomOptions();
        options.maxPlayers = numberOfPlayers;

        TypedLobby typedLobby = new TypedLobby("GameLobby",LobbyType.Default);

		//PhotonNetwork.CreateRoom ("",options,typedLobby);
		//PhotonNetwork.CreateRoom ("", true, true, numberOfPlayers);
		// testing this to git rid of the build warning
		PhotonNetwork.CreateRoom("", options, typedLobby);
		
    }

 // We have two options here: we either joined(by title, list or random) or created a room.
 public override void OnJoinedRoom()
 {
     Debug.Log("OnJoinedRoom");
     
     Hashtable e = new Hashtable();
     e.Add("PName", LocalName);
     bool master = (PhotonNetwork.player.isMasterClient) ? true : false;
     e.Add("Ready", master);
     PhotonNetwork.player.SendReady(master);
     PhotonNetwork.RaiseEvent(EventID.PlayerJoinPre, e, true, new RaiseEventOptions() { Receivers = ReceiverGroup.All }); 
 }

 /// <summary>
 /// change the state and sync for other players
 /// </summary>
 public void Ready()
 {
     isReady = !isReady;
     PhotonNetwork.player.SendReady(isReady);
     Hashtable e = new Hashtable();
     e.Add("PName",LocalName);
     e.Add("Ready",isReady);
     PhotonNetwork.RaiseEvent(EventID.PlayerJoinPre, e, true, new RaiseEventOptions() { Receivers = ReceiverGroup.All});    
 }

 /// <summary>
 /// Load and sync level
 /// Only masterclient can call this function
 /// </summary>
 public void LoadSyncLevel()
 {
     //Start game only when all are ready
     if (PhotonNetwork.playerList.AllPlayersReady())
     {
         Hashtable e = new Hashtable();
         e.Add("Level", PhotonNetwork.room.RoomScene());
         PhotonNetwork.RaiseEvent(EventID.LoadSyncLevel, e, true, new RaiseEventOptions() { Receivers = ReceiverGroup.All });
     }
     else
     {
         Debug.Log("Some players are not ready, wait for hes");
     }
 }