public void ConfirmCreateGame()
{
CloseDropDowns();
m_roomMaxPlayers = int.Parse(m_createGameWindow.transform.FindChild("Max Players").GetComponent <InputField>().text.ToString());
m_roomLevelRangeMax = int.Parse(m_createGameWindow.transform.FindChild("Box 2").GetComponent <InputField>().text.ToString());
m_roomLevelRangeMin = int.Parse(m_createGameWindow.transform.FindChild("Box 1").GetComponent <InputField>().text.ToString());
CreateMatchRequest options = new CreateMatchRequest();
options.size = (uint)m_roomMaxPlayers;
options.advertise = true;
options.password = "";
options.matchAttributes = new Dictionary <string, long>()
{
{ "minLevel", m_roomLevelRangeMin }, { "maxLevel", m_roomLevelRangeMax }
};
CreateNewRoom(m_createGameWindow.transform.FindChild("Room Name").GetComponent <InputField>().text, options);
}
public static async Task<HttpResponseMessage> Create(int firstBoxer, int secondBoxer, string address, DateTime time, string description)
{
var request = new CreateMatchRequest()
{
FirstBoxer = firstBoxer,
SecondBoxer = secondBoxer,
Address = address,
Date = time,
Description = description
};
using (var client = new HttpClient())
{
var uri = UriHelper.GetUri("matches");
var content = new StringContent(JsonConvert.SerializeObject(request), Encoding.UTF8, "application/json");
client.DefaultRequestHeaders.Add(Headers.AdminAuthenticationHeader, AuthHelper.AdminKey);
return await client.PostAsync(uri, content);
}
}
public void createRoom()
{
if (manager.matchMaker == null)
{
manager.StartMatchMaker();
manager.matchMaker.SetProgramAppID((AppID)1093751);
}
if (playerName.text != "")
{
CreateMatchRequest create = new CreateMatchRequest();
create.name = playerName.text;
create.size = 4;
create.advertise = true;
create.password = "";
manager.matchMaker.CreateMatch(create, OnMatchCreate);
}
else
{
noPlayerName.enabled = true;
}
}
public async Task <MatchModel> CreateMatch(CreateMatchCommand command)
{
Player winner = await playersApiClient.GetPlayer(command.WinnerId);
Player loser = await playersApiClient.GetPlayer(command.LoserId);
PlayersRatings ratings = await ratingApiClient.CalculatePlayersRatings(RatingMapper.Map(winner, loser));
UpdatePlayerRequest updateWinnerRequest = new UpdatePlayerRequest(winner.Id, winner.Name, ratings.WinnerRating.Rating, ratings.WinnerRating.Deviation, ratings.WinnerRating.Volatility);
winner = await playersApiClient.UpdatePlayer(updateWinnerRequest);
UpdatePlayerRequest updateLoserRequest = new UpdatePlayerRequest(loser.Id, loser.Name, ratings.LoserRating.Rating, ratings.LoserRating.Deviation, ratings.LoserRating.Volatility);
loser = await playersApiClient.UpdatePlayer(updateLoserRequest);
CreateMatchRequest createMatchRequest = new CreateMatchRequest(winner.Id, loser.Id, command.Score);
Match match = await matchesApiClient.CreateMatch(createMatchRequest);
return(MatchMapper.Map(match, new List <Player> {
winner, loser
}));
}
void OnGUI()
{
// You would normally not join a match you created yourself but this is possible here for demonstration purposes.
if (GUILayout.Button("Create Room"))
{
CreateMatchRequest create = new CreateMatchRequest();
create.name = "NewRoom";
create.size = 4;
create.advertise = true;
create.password = "";
networkMatch.CreateMatch(create, OnMatchCreate);
}
if (GUILayout.Button("List rooms"))
{
networkMatch.ListMatches(0, 20, "", OnMatchList);
}
if (matchList.Count > 0)
{
GUILayout.Label("Current rooms");
}
else
{
GUILayout.Label("No rooms");
}
Debug.Log(matchList.Count);
foreach (var match in matchList)
{
if (GUILayout.Button(match.name))
{
networkMatch.JoinMatch(match.networkId, "", OnMatchJoined);
}
}
}
void CreateNewRoom(string aName, CreateMatchRequest aOptions)
{
List <MatchDesc> rooms = BombersNetworkManager.singleton.matches;
bool roomExists = false;
string roomName = aName;
if (aName == "")
{
roomName = GameObject.Find("BrainCloudStats").GetComponent <BrainCloudStats>().m_playerName + "'s Room";
}
if (rooms != null)
{
for (int i = 0; i < rooms.Count; i++)
{
if (rooms[i].name == aName)
{
roomExists = true;
}
}
}
if (roomExists)
{
GameObject.Find("DialogDisplay").GetComponent <DialogDisplay>().DisplayDialog("There's already a room named " + aName + "!");
return;
}
int playerLevel = GameObject.Find("BrainCloudStats").GetComponent <BrainCloudStats>().GetStats()[0].m_statValue;
if (m_roomLevelRangeMin < 0)
{
m_roomLevelRangeMin = 0;
}
else if (m_roomLevelRangeMin > playerLevel)
{
m_roomLevelRangeMin = playerLevel;
}
if (m_roomLevelRangeMax > 50)
{
m_roomLevelRangeMax = 50;
}
if (m_roomLevelRangeMax < m_roomLevelRangeMin)
{
m_roomLevelRangeMax = m_roomLevelRangeMin;
}
if (aOptions.size > 8)
{
aOptions.size = 8;
}
else if (aOptions.size < 2)
{
aOptions.size = 2;
}
GameObject.Find("Version Text").transform.SetParent(null);
GameObject.Find("FullScreen").transform.SetParent(null);
CreateMatchRequest options = new CreateMatchRequest();
options.name = aName;
options.size = aOptions.size;
options.advertise = true;
options.password = "";
options.matchAttributes = new Dictionary <string, long>();
options.matchAttributes.Add("minLevel", m_roomLevelRangeMin);
options.matchAttributes.Add("maxLevel", m_roomLevelRangeMax);
options.matchAttributes.Add("StartGameTime", 600);
options.matchAttributes.Add("IsPlaying", 0);
options.matchAttributes.Add("MapLayout", m_presetListSelection);
options.matchAttributes.Add("MapSize", m_sizeListSelection);
BrainCloudWrapper.GetBC().EntityService.UpdateSingleton("gameName", "{\"gameName\": \"" + roomName + "\"}", null, -1, null, null, null);
GameObject.Find("BrainCloudStats").GetComponent <BrainCloudStats>().ReadStatistics();
m_state = eMatchmakingState.GAME_STATE_CREATE_NEW_ROOM;
Dictionary <string, string> matchOptions = new Dictionary <string, string>();
matchOptions.Add("gameTime", 600.ToString());
matchOptions.Add("isPlaying", 0.ToString());
matchOptions.Add("mapLayout", m_presetListSelection.ToString());
matchOptions.Add("mapSize", m_sizeListSelection.ToString());
matchOptions.Add("gameName", roomName);
matchOptions.Add("maxPlayers", aOptions.size.ToString());
matchOptions.Add("lightPosition", 0.ToString());
BombersNetworkManager.m_matchOptions = matchOptions;
BombersNetworkManager.singleton.matchMaker.CreateMatch(options, OnMatchCreate);
}
public async Task <int> CreateMatchAsync(
CreateMatchRequest request,
CancellationToken cancellationToken = default)
{
try
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (request.Date == null)
{
throw new ArgumentException("Date cannot be null.");
}
if (request.Date > DateTime.Now)
{
throw new ArgumentException("Cannot register a match that is not yet played.");
}
if (request.HomeTeamId == request.AwayTeamId)
{
throw new ArgumentException("Cannot register match between the same team.");
}
bool homeTeamsExist = await _context.Teams
.AnyAsync(t => t.Id == request.HomeTeamId);
bool awayTeamsExist = await _context.Teams
.AnyAsync(t => t.Id == request.AwayTeamId);
if (!homeTeamsExist || !awayTeamsExist)
{
throw new ArgumentException("Either one of the teams does not exist in the database.");
}
int?winnerID = request.AwayTeamScore > request.HomeTeamScore
? request.AwayTeamId
: request.AwayTeamScore < request.HomeTeamScore
? request.HomeTeamId
: (int?)null;
var entity = new Entities.Match
{
Date = request.Date,
AwayTeamId = request.AwayTeamId,
AwayTeamScore = request.AwayTeamScore,
HomeTeamId = request.HomeTeamId,
HomeTeamScore = request.HomeTeamScore,
WinnerId = winnerID
};
_context.Matches.Add(entity);
await _context.SaveChangesAsync(cancellationToken);
// Update team rankings
if (winnerID.HasValue)
{
await UpdateTeamRankings(winnerID.Value, 3);
}
else
{
await UpdateTeamRankings(entity.AwayTeamId, 1);
await UpdateTeamRankings(entity.HomeTeamId, 1);
}
return(entity.Id);
}
catch (ServiceException)
{
throw;
}
catch (Exception ex)
{
_logger.LogError(ex, "Error creating match.");
throw Conversion.ConvertException(ex);
}
}
public void Post([FromBody] CreateMatchRequest request)
{
_services.CreateMatch(request);
}
public async Task <CreateMatchResponse> CreateMatch(string idFirstTeam, string idSecondTeam, string dateTimeMatch)
{
var request = new CreateMatchRequest(idFirstTeam, idSecondTeam, dateTimeMatch);
return(await _matchActor.Ask <CreateMatchResponse>(request));
}
public void HostGame()
{
if (!LobbyNet.isNetworkActive)
{
bool lan = GameObject.Find("LanToggle").GetComponent <Toggle>().isOn;
string matchName = "Default";
int minplayers = 2;
int maxplayers = 4;
int port = 7777;
if (GameObject.Find("MatchNameInput").transform.Find("Text").GetComponent <Text>().text.Length != 0)
{
matchName = GameObject.Find("MatchNameInput").transform.Find("Text").GetComponent <Text>().text;
}
if (GameObject.Find("MaxPlayersInput").transform.Find("Text").GetComponent <Text>().text.Length != 0)
{
int input; //Max players variable
int.TryParse(GameObject.Find("MaxPlayersInput").transform.Find("Text").GetComponent <Text>().text, out input); //Parse contents into integer
if (input >= 2 && input <= 16) //If entered amount of players is within acceptable ranges
{
maxplayers = input; //Set max players
}
else
{
Debug.Log("INVALID PlAYER AMOUNT ENTERED");
return;
}
}
if (GameObject.Find("MinPlayersInput").transform.Find("Text").GetComponent <Text>().text.Length != 0)
{
int input; //Min players variable;
int.TryParse(GameObject.Find("MinPlayersInput").transform.Find("Text").GetComponent <Text>().text, out input); //Parse contents into integer
if (input > 0 && input <= 16)
{
if (input <= maxplayers)
{
minplayers = input;
}
else
{
Debug.Log("Minimum players cannot be higher than maximum players!");
return;
}
}
else
{
Debug.Log("INVALID PLAYER AMOUNT ENTERED");
return;
}
}
if (GameObject.Find("HostPortInput").transform.Find("Text").GetComponent <Text>().text.Length != 0)
{
int input; //Port variable
int.TryParse(GameObject.Find("HostPortInput").transform.Find("Text").GetComponent <Text>().text, out input); //Parse contents into integer
if (input > 0 && input <= 65535) //If entered port is within acceptable ranges
{
port = input; //Set port
}
else
{
Debug.Log("INVALID PORT ENTERED");
return;
}
}
LobbyNet.networkPort = port;
LobbyNet.maxPlayers = maxplayers + 1;
LobbyNet.minPlayers = minplayers;
if (!lan)
{
if (LobbyNet.matchMaker == null)
{
LobbyNet.StartMatchMaker();
}
NetworkMatch match = LobbyNet.matchMaker;
CreateMatchRequest req = new CreateMatchRequest();
req.name = matchName;
req.size = (uint)maxplayers + 1;
req.advertise = true;
if (GameObject.Find("PasswordInput").transform.Find("Text").GetComponent <Text>().text.Length != 0)
{
req.password = GameObject.Find("PasswordInput").transform.Find("Text").GetComponent <Text>().text;
}
else
{
req.password = "";
}
match.CreateMatch(req, LobbyNet.OnMatchCreate);
}
else
{
LobbyNet.name = matchName;
LobbyNet.StartHost();
}
}
}
public async Task <string> Post(CreateMatchRequest request)
{
var match = request.ToMatch();
return(await _matchService.CreateMatch(match, request.Teams));
}
