Java TurnBasedMultiplayer类代码示例

import com.google.android.gms.games.multiplayer.turnbased.TurnBasedMultiplayer; //导入依赖的package包/类
@Override
public void quickMatch() {
	Bundle autoMatchCriteria = RoomConfig.createAutoMatchCriteria(
			1, 1, 0);

	TurnBasedMatchConfig tbmc = TurnBasedMatchConfig.builder()
			.setAutoMatchCriteria(autoMatchCriteria).build();

	

	// Start the match
	ResultCallback<TurnBasedMultiplayer.InitiateMatchResult> cb = new ResultCallback<TurnBasedMultiplayer.InitiateMatchResult>() {
		@Override
		public void onResult(TurnBasedMultiplayer.InitiateMatchResult result) {
			processResult(result);
		}
	};
	Games.TurnBasedMultiplayer.createMatch(gameHelper.getApiClient(), tbmc).setResultCallback(cb);
}
 

import com.google.android.gms.games.multiplayer.turnbased.TurnBasedMultiplayer; //导入依赖的package包/类
@Override
public void takeTurn(GameModel data) {
	String nextParticipantId = getNextParticipantId();
	// Create the next turn
       mTurnData = new GameModelWrapper(data);

	

	Games.TurnBasedMultiplayer.takeTurn(gameHelper.getApiClient(), mMatch.getMatchId(),
			mTurnData.convertToByteArray(), nextParticipantId).setResultCallback(
			new ResultCallback<TurnBasedMultiplayer.UpdateMatchResult>() {
				@Override
				public void onResult(TurnBasedMultiplayer.UpdateMatchResult result) {
					processResult(result);
				}
			});

	mTurnData = null;
}
 

import com.google.android.gms.games.multiplayer.turnbased.TurnBasedMultiplayer; //导入依赖的package包/类
public void startMatch(TurnBasedMatch match) {
	System.out.println("Started match");

	mTurnData = new GameModelWrapper();

	mMatch = match;

	String playerId = Games.Players.getCurrentPlayerId(gameHelper.getApiClient());
	String myParticipantId = mMatch.getParticipantId(playerId);

	Games.TurnBasedMultiplayer.takeTurn(gameHelper.getApiClient(), match.getMatchId(),
			mTurnData.convertToByteArray(), myParticipantId).setResultCallback(
			new ResultCallback<TurnBasedMultiplayer.UpdateMatchResult>() {
				@Override
				public void onResult(TurnBasedMultiplayer.UpdateMatchResult result) {
					processResult(result);
				}
			});
}
 

import com.google.android.gms.games.multiplayer.turnbased.TurnBasedMultiplayer; //导入依赖的package包/类
public void onQuickMatchClicked(View view) {

        Bundle autoMatchCriteria = RoomConfig.createAutoMatchCriteria(
                1, 1, 0);

        TurnBasedMatchConfig tbmc = TurnBasedMatchConfig.builder()
                .setAutoMatchCriteria(autoMatchCriteria).build();

        showSpinner();

        // Start the match
        ResultCallback<TurnBasedMultiplayer.InitiateMatchResult> cb = new ResultCallback<TurnBasedMultiplayer.InitiateMatchResult>() {
            @Override
            public void onResult(TurnBasedMultiplayer.InitiateMatchResult result) {
                processResult(result);
            }
        };
        Games.TurnBasedMultiplayer.createMatch(mGoogleApiClient, tbmc).setResultCallback(cb);
    }
 

import com.google.android.gms.games.multiplayer.turnbased.TurnBasedMultiplayer; //导入依赖的package包/类
public void onDoneClicked(View view) {
    showSpinner();

    String nextParticipantId = getNextParticipantId();
    // Create the next turn
    mTurnData.turnCounter += 1;
    mTurnData.data = mDataView.getText().toString();

    showSpinner();

    Games.TurnBasedMultiplayer.takeTurn(mGoogleApiClient, mMatch.getMatchId(),
            mTurnData.persist(), nextParticipantId).setResultCallback(
            new ResultCallback<TurnBasedMultiplayer.UpdateMatchResult>() {
        @Override
        public void onResult(TurnBasedMultiplayer.UpdateMatchResult result) {
            processResult(result);
        }
    });

    mTurnData = null;
}
 

import com.google.android.gms.games.multiplayer.turnbased.TurnBasedMultiplayer; //导入依赖的package包/类
public void startMatch(TurnBasedMatch match) {
    mTurnData = new SkeletonTurn();
    // Some basic turn data
    mTurnData.data = "First turn";

    mMatch = match;

    String playerId = Games.Players.getCurrentPlayerId(mGoogleApiClient);
    String myParticipantId = mMatch.getParticipantId(playerId);

    showSpinner();

    Games.TurnBasedMultiplayer.takeTurn(mGoogleApiClient, match.getMatchId(),
            mTurnData.persist(), myParticipantId).setResultCallback(
            new ResultCallback<TurnBasedMultiplayer.UpdateMatchResult>() {
                @Override
                public void onResult(TurnBasedMultiplayer.UpdateMatchResult result) {
                    processResult(result);
                }
            });
}
 

import com.google.android.gms.games.multiplayer.turnbased.TurnBasedMultiplayer; //导入依赖的package包/类
private void processResult(TurnBasedMultiplayer.InitiateMatchResult result) {
    TurnBasedMatch match = result.getMatch();
    dismissSpinner();

    if (!checkStatusCode(match, result.getStatus().getStatusCode())) {
        return;
    }

    if (match.getData() != null) {
        // This is a game that has already started, so I'll just start
        updateMatch(match);
        return;
    }

    startMatch(match);
}
 

import com.google.android.gms.games.multiplayer.turnbased.TurnBasedMultiplayer; //导入依赖的package包/类
public TurnBasedMultiplayer.LoadMatchesResult G(final Status paramStatus)
{
  return new TurnBasedMultiplayer.LoadMatchesResult()
  {
    public LoadMatchesResponse getMatches()
    {
      return new LoadMatchesResponse(new Bundle());
    }

    public Status getStatus()
    {
      return paramStatus;
    }

    public void release()
    {
    }
  };
}
 

import com.google.android.gms.games.multiplayer.turnbased.TurnBasedMultiplayer; //导入依赖的package包/类
@Override
public boolean publishRemoteGameState(GameData gameData) {
  if (googleApiClient.isConnected()) {
    Log.d(TAG, "publishRemoteGameState: " + gameData);
    String turnParticipantId = gameDatas.getCurrentPlayer(gameData).getId();
    byte[] gameDataBytes = gameData.toByteArray();
    Log.d(TAG, "takeTurn " + turnParticipantId);
    TurnBasedMultiplayer.takeTurn(googleApiClient, gameData.getMatchId(), gameDataBytes, turnParticipantId);
    if (gameData.getPhase() == Phase.FINISHED) {
      TurnBasedMultiplayer.finishMatch(googleApiClient, gameData.getMatchId());
      fireGameSelected(gameData);
    }
    return true;
  } else {
    gameCache.putUnpublished(gameData.getMatchId(), IGNORED_VALUE);
    return false;
  }
}
 

import com.google.android.gms.games.multiplayer.turnbased.TurnBasedMultiplayer; //导入依赖的package包/类
@Override
public void checkGames() {
	if(isSignedIn()) {
		Intent intent = Games.TurnBasedMultiplayer.getInboxIntent(gameHelper.getApiClient());
		startActivityForResult(intent, RC_LOOK_AT_MATCHES);
	}
	else
		signIn();
}
 

import com.google.android.gms.games.multiplayer.turnbased.TurnBasedMultiplayer; //导入依赖的package包/类
@Override
public void takeLastTurn(GameModel data) {
	
	mTurnData = new GameModelWrapper(data);

	Games.TurnBasedMultiplayer.finishMatch(gameHelper.getApiClient(), mMatch.getMatchId(), mTurnData.convertToByteArray())
			.setResultCallback(new ResultCallback<TurnBasedMultiplayer.UpdateMatchResult>() {
				@Override
				public void onResult(TurnBasedMultiplayer.UpdateMatchResult result) {
					processResult(result);
				}
			});

	isDoingTurn = false;
}
 

import com.google.android.gms.games.multiplayer.turnbased.TurnBasedMultiplayer; //导入依赖的package包/类
@Override
public void finishMatch() {
	Games.TurnBasedMultiplayer.finishMatch(gameHelper.getApiClient(), mMatch.getMatchId())
			.setResultCallback(new ResultCallback<TurnBasedMultiplayer.UpdateMatchResult>() {
				@Override
				public void onResult(TurnBasedMultiplayer.UpdateMatchResult result) {
					processResult(result);
				}
			});

	isDoingTurn = false;
}
 

import com.google.android.gms.games.multiplayer.turnbased.TurnBasedMultiplayer; //导入依赖的package包/类
@Override
public void rematch() {
	Games.TurnBasedMultiplayer.rematch(gameHelper.getApiClient(), mMatch.getMatchId()).setResultCallback(
			new ResultCallback<TurnBasedMultiplayer.InitiateMatchResult>() {
				@Override
				public void onResult(TurnBasedMultiplayer.InitiateMatchResult result) {
					processResult(result);
				}
			});
	mMatch = null;
	isDoingTurn = false;
}
 

import com.google.android.gms.games.multiplayer.turnbased.TurnBasedMultiplayer; //导入依赖的package包/类
private void processResult(TurnBasedMultiplayer.CancelMatchResult result) {
	if (!checkStatusCode(null, result.getStatus().getStatusCode())) {
		return;
	}

	isDoingTurn = false;

	showWarning("Match",
			"This match is canceled.  All other players will have their game ended.");
}
 

import com.google.android.gms.games.multiplayer.turnbased.TurnBasedMultiplayer; //导入依赖的package包/类
@Override
public void onConnected(Bundle connectionHint) {
	Log.d(TAG, "onConnected(): Connection successful");

	// Retrieve the TurnBasedMatch from the connectionHint
	if (connectionHint != null) {
		mTurnBasedMatch = connectionHint.getParcelable(Multiplayer.EXTRA_TURN_BASED_MATCH);

		if (mTurnBasedMatch != null) {
			if (gameHelper.getApiClient() == null || !gameHelper.getApiClient().isConnected()) {
				Log.d(TAG, "Warning: accessing TurnBasedMatch when not connected");
			}

			updateMatch(mTurnBasedMatch);
			return;
		}
	}


	// As a demonstration, we are registering this activity as a handler for
	// invitation and match events.

	// This is *NOT* required; if you do not register a handler for
	// invitation events, you will get standard notifications instead.
	// Standard notifications may be preferable behavior in many cases.
	Games.Invitations.registerInvitationListener(gameHelper.getApiClient(), this);

	// Likewise, we are registering the optional MatchUpdateListener, which
	// will replace notifications you would get otherwise. You do *NOT* have
	// to register a MatchUpdateListener.
	Games.TurnBasedMultiplayer.registerMatchUpdateListener(gameHelper.getApiClient(), this);
}