public ActionResult Register(RegisterModel model)
{
if (ModelState.IsValid)
{
// Attempt to register the user
try
{
_db.TeamEntries.Add(new TeamEntry()
{
USENAME = model.UserName,
PHONE = model.PHONE,
EMAIL = model.EMAIL,
ROLE = model.Role,
TEAMCODE = model.TEAMCODE,
NAME = model.NAME
});
_db.SaveChanges();
TeamEntry firstUser = _db.TeamEntries.First(m => m.USENAME == model.UserName);
_db.Users.Add(new Users()
{
UserName = model.UserName, Password = model.Password, Role = "Administrator", SeletUserId = firstUser.id
});
_db.SaveChanges();
Authenticate(model.UserName, model.Password, false);
return(RedirectToAction("Index", "Teams"));
}
catch (MembershipCreateUserException e)
{
ModelState.AddModelError("", ErrorCodeToString(e.StatusCode));
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public List <short> GetSelectedHumanTeamsIds()
{
List <short> idList = new List <short>();
for (int i = 0; i < gamestateTracker.teams.count; i++)
{
bool hasHuman = false;
TeamEntry teamEntry = gamestateTracker.teams.ReadAtIndex((short)i);
PlayerEntry driverEntry = gamestateTracker.players.Read(teamEntry.driverId);
PlayerEntry gunnerEntry = gamestateTracker.players.Read(teamEntry.gunnerId);
if (!driverEntry.isBot)
{
hasHuman = true;
}
if (!gunnerEntry.isBot)
{
hasHuman = true;
}
if (hasHuman && teamEntry.hasSelectedVehicle)
{
idList.Add(teamEntry.id);
}
}
return(idList);
}
public void GamestateApplyTeamPacketErrorCallbackTest()
{
short actorNumber = 1;
GamestateCommitTestHelper <TeamEntry> testHelper = new GamestateCommitTestHelper <TeamEntry>(actorNumber);
GamestateTable <TeamEntry> teams = testHelper.TestTable(GamestateTracker.Table.Teams);
GamestateRandomTestingUnit generator = new GamestateRandomTestingUnit(777);
for (short i = 0; i < 100; i++)
{
TeamEntry teamEntry = teams.Create(i);
generator.RandomiseTeamEntry(teamEntry);
GamestatePacket packet = GamestatePacketManager.GetPacket();
bool errorCallbackCalled = false;
teamEntry.Commit((TeamEntry entry, bool succeeded) => {
Assert.That(succeeded, Is.EqualTo(true));
GamestateAssertionUnit.AssertPacketApplied(entry, packet);
entry.Release();
errorCallbackCalled = true;
});
packet = testHelper.commitedPackets[0];
testHelper.Apply(packet);
Assert.That(errorCallbackCalled, Is.EqualTo(true));
testHelper.commitedPackets.Clear();
}
}
void AddListenerToThisTeam()
{
TeamEntry teamEntry = gamestateTracker.teams.Read((short)teamId);
teamEntry.AddListener(TeamListenerCallback);
// teamEntry.Commit();
}
// spawn each player pair at a respective spawnpoint
// to do this, loop through each player in the gamestate tracker and get a list of the unique teams
// once we have this, get the driver and gunner from both.
// instantiate the driver's vehicle for each of them (driver character)
// instantiate the gunner attached to the vehicle for each of them (gunner character)
// only to be called by the master client when we can be sure that everyone has loaded into the game
IEnumerator SpawnPlayers()
{
spawningPlayersScreenInstance = Instantiate(spawningPlayersScreenPrefab, transform.position, Quaternion.identity);
// yield return new WaitForSecondsRealtime(0.5f);
// if(FindObjectOfType<MakeTheMap>() != null) FindObjectOfType<MakeTheMap>().MakeMap();
yield return(new WaitForSecondsRealtime(1f));
if (PhotonNetwork.IsMasterClient)
{
GamestateTracker gamestateTracker = FindObjectOfType <GamestateTracker>();
// players should have already had their teams validated through the lobby screen
// If we end up with bugs, get Jordan to add extra checks to fill slots with bots at this point.
for (short i = 0; i < gamestateTracker.teams.count; i++)
{
TeamEntry entry = gamestateTracker.teams.GetAtIndex(i);
int teamId = entry.id;
entry.Release();
// instantiate the vehicle from the vehiclePrefabName in the schema, if null, instantiate the testing truck
Spawn(teamId);
yield return(new WaitForSeconds(0.5f));
}
GameFullySetupMaster();
}
}
public ActionResult Delete(int id = 0)
{
if (Session["UserName"] != null)
{
if ((string)Session["Role"] == "Administrator")
{
@ViewBag.ActivePage = "USERS";
TeamEntry teamEntry = _db.TeamEntries.Find(id);
//ViewBag.TeamEntry = teamEntry;
Users user = _db.Users.First(m => m.UserName == teamEntry.USENAME && m.SeletUserId == id);
_db.Entry(teamEntry).State = EntityState.Deleted;
_db.Entry(user).State = EntityState.Deleted;
_db.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
return(RedirectToAction("TeamMemberDelete"));
}
}
else
{
return(RedirectToAction("Login", "MyAccount"));
}
}
public void RandomiseTeamEntry(TeamEntry teamEntry)
{
Random.state = currentState;
if (Random.Range(0, 2) == 1)
{
teamEntry.name = GetRandomUTF8String();
}
if (Random.Range(0, 2) == 1)
{
teamEntry.kills = (short)Random.Range(short.MinValue, short.MaxValue + 1);
}
if (Random.Range(0, 2) == 1)
{
teamEntry.deaths = (short)Random.Range(short.MinValue, short.MaxValue + 1);
}
if (Random.Range(0, 2) == 1)
{
teamEntry.assists = (short)Random.Range(short.MinValue, short.MaxValue + 1);
}
if (Random.Range(0, 2) == 1)
{
teamEntry.checkpoint = (short)Random.Range(short.MinValue, short.MaxValue + 1);
}
if (Random.Range(0, 2) == 1)
{
teamEntry.isDead = Random.Range(0, 2) == 1;
}
currentState = Random.state;
}
public static void AssertPacketApplied(TeamEntry entry, GamestatePacket packet)
{
if (packet.hasName)
{
Assert.That(entry.name, Is.EqualTo(packet.name));
}
int i = 0;
if (packet.hasShortValues[(int)TeamEntry.ShortFields.Kills])
{
Assert.That(entry.kills, Is.EqualTo(packet.shortValues[i]));
i++;
}
if (packet.hasShortValues[(int)TeamEntry.ShortFields.Deaths])
{
Assert.That(entry.deaths, Is.EqualTo(packet.shortValues[i]));
i++;
}
if (packet.hasShortValues[(int)TeamEntry.ShortFields.Assists])
{
Assert.That(entry.assists, Is.EqualTo(packet.shortValues[i]));
i++;
}
if (packet.hasShortValues[(int)TeamEntry.ShortFields.Checkpoint])
{
Assert.That(entry.checkpoint, Is.EqualTo(packet.shortValues[i]));
i++;
}
Assert.That(entry.isDead, Is.EqualTo(packet.boolValues[(int)TeamEntry.BoolFields.IsDead]));
}
// USED
public void LockSelectedVehicle()
{
SetButtonsInteractable(false);
TeamEntry teamEntry = gamestateTracker.teams.Get(ourTeamId);
teamEntry.vehicle = currentVehicleId;
teamEntry.hasSelectedVehicle = true;
teamEntry.Commit();
}
// called whenever the team stuff changes
// update the graphics of the button
void TeamListenerCallback(TeamEntry teamEntry)
{
// display the player details of the driver and gunner in the buttons
// driver stuff
short driverId = teamEntry.driverId;
if (driverId != 0)
{
PlayerEntry driverEntry = gamestateTracker.players.Get((short)driverId);
driverPlayerText.text = driverEntry.name;
driverEntry.Release();
if (driverId == PhotonNetwork.LocalPlayer.ActorNumber)
{
driverFillImage.color = new Color32(0x65, 0xC5, 0x6B, 0xFF);
}
else
{
driverFillImage.color = new Color32(0x44, 0x91, 0xCA, 0xFF);
}
driverButton.interactable = false;
}
else
{
driverPlayerText.text = "Empty";
driverFillImage.color = new Color32(0xB0, 0xB0, 0xB0, 0xFF);
driverButton.interactable = true;
}
// gunner stuff
short gunnerId = teamEntry.gunnerId;
if (gunnerId != 0)
{
PlayerEntry gunnerEntry = gamestateTracker.players.Get((short)gunnerId);
gunnerPlayerText.text = gunnerEntry.name;
gunnerEntry.Release();
if (gunnerId == PhotonNetwork.LocalPlayer.ActorNumber)
{
gunnerFillImage.color = new Color32(0x65, 0xC5, 0x6B, 0xFF);
}
else
{
gunnerFillImage.color = new Color32(0x44, 0x91, 0xCA, 0xFF);
}
gunnerButton.interactable = false;
}
else
{
gunnerPlayerText.text = "Empty";
gunnerFillImage.color = new Color32(0xB0, 0xB0, 0xB0, 0xFF);
gunnerButton.interactable = true;
}
teamEntry.Release();
}
public ActionResult Edit(int id = 0)
{
if (Session["UserName"] != null)
{
if ((string)Session["Role"] == "Administrator")
{
ViewBag.UserRoles = MyAccountController.UserRoles;
@ViewBag.ActivePage = "USERS";
ViewBag.Title = "Edit User";
TeamEntry teamEntry = _db.TeamEntries.Find(id);
//var user = _db.Users.First(u => u.UserName == teamEntry.USENAME);
Users user = _db.Users.Find(id);
RegisterModel editModel = new RegisterModel()
{
UserName = teamEntry.USENAME,
PHONE = teamEntry.PHONE,
EMAIL = teamEntry.EMAIL,
SelectUserId = teamEntry.id,
NAME = teamEntry.NAME,
Password = user.Password,
ConfirmPassword = user.Password,
Role = user.Role
};
if (user.Role != "Administrator")
{
TeamMemberEntry member = _db.TeamMemberEntries.FirstOrDefault(m => m.TEAMMEMBERNAME == teamEntry.NAME && m.TEAMCODE == teamEntry.TEAMCODE);
if (member != null)
{
editModel.Team = member.TEAMCODE;
}
}
ViewBag.EditModel = editModel;
var teams = _db.TeamItems.ToList();
List <string> strTeams = new List <string>();
foreach (TeamItem team in teams)
{
strTeams.Add(team.TEAMNAME);
}
ViewBag.Teams = new SelectList(strTeams);
return(View("Add", editModel));
}
else
{
return(RedirectToAction("TeamMemberEdit"));
}
}
else
{
return(RedirectToAction("Login", "MyAccount"));
}
}
private void buffs()
{
vhm.HealObject(5);
dam.AdjustDriverUltimateProgress(10);
gwm.AdjustGunnerUltimateProgress(5);
TeamEntry team = gamestateTracker.teams.Get((short)vhm.teamId);
team.checkpoint++;
team.Increment();
}
// gets incomplete teams in the gamestate tracker and puts in a bot
// only to be called by master client
public void FillIncompleteTeamsWithBots()
{
if (PhotonNetwork.IsMasterClient)
{
// foreach team in the gamestate tracker, check that valid ids exist for driver and gunner
// if ids are 0 (ie not valid) then create a bot
for (int i = 0; i < gamestateTracker.teams.count; i++)
{
TeamEntry teamEntry = gamestateTracker.teams.GetAtIndex(i);
// add driver bot
if (teamEntry.driverId == 0)
{
PlayerEntry bot = gamestateTracker.players.Create(true, true);
bot.ready = true;
bot.role = (short)PlayerEntry.Role.Driver;
bot.isBot = true;
bot.name = "Bot " + -bot.id;
bot.teamId = (short)teamEntry.id;
bot.Commit();
// now add the entry to the team
teamEntry.driverId = bot.id;
teamEntry.Commit();
}
else
{
teamEntry.Release();
}
teamEntry = gamestateTracker.teams.GetAtIndex(i);
// add gunner bot
if (teamEntry.gunnerId == 0)
{
PlayerEntry bot = gamestateTracker.players.Create(true, true);
bot.ready = true;
bot.role = (short)PlayerEntry.Role.Gunner;
bot.isBot = true;
bot.name = "Bot " + -bot.id;
bot.teamId = (short)teamEntry.id;
bot.Commit();
// now add the entry to the team
teamEntry.gunnerId = bot.id;
teamEntry.Commit();
}
else
{
teamEntry.Release();
}
}
}
}
public void ActivateVehicleInputs()
{
// check if the driver is a human or a bot
// if they are a bot, then get the MASTER CLIENT to turn on ai controls
if (botDriver && PhotonNetwork.IsMasterClient)
{
EnableMonobehaviours(aiDriverScripts);
}
// otherwise, find the driver player by their nickname. Tell their client to turn on player driver controls
//Debug.Log("My local name is " + PhotonNetwork.LocalPlayer.NickName);
TeamEntry team = gamestateTracker.teams.Get((short)teamId);
if (team.name == null)
{
PlayerEntry driver = gamestateTracker.players.Get(team.driverId);
PlayerEntry gunner = gamestateTracker.players.Get(team.gunnerId);
GetComponent <TeamNameSetup>().SetupTeamName($"{driver.name} + {gunner.name}");
driver.Release();
gunner.Release();
}
else
{
GetComponent <TeamNameSetup>().SetupTeamName("Team " + teamId);
}
if (PhotonNetwork.LocalPlayer.ActorNumber == driverId)
{
EnableMonobehaviours(playerDriverScripts);
GetComponent <TeamNameSetup>().SetupTeamName("");
}
//Debug.Log("GOT HERE");
// Do the same again for the gunner
if (botGunner && PhotonNetwork.IsMasterClient)
{
EnableMonobehaviours(aiGunnerScripts);
}
if (PhotonNetwork.LocalPlayer.ActorNumber == gunnerId)
{
EnableMonobehaviours(playerGunnerScripts);
GetComponent <TeamNameSetup>().SetupTeamName("");
}
PhysXSceneManager physXSceneManager = FindObjectOfType <PhysXSceneManager>();
physXSceneManager.doPhysics = true;
//Debug.Log("GOT HERE2");
Debug.Log("Spawn success");
GetComponent <DriverAbilityManager>().SetupDriverAbilityManager();
}
void SetUpScoreboard()
{
for (int i = 0; i < gamestateTracker.teams.count; i++)
{
TeamEntry team = gamestateTracker.teams.GetAtIndex(i);
team.AddListener(TeamListener);
team.Release();
teamPanels[i].gameObject.SetActive(true);
teamPanels[i].Setup();
}
UpdateScores();
}
void Start()
{
gamestateTracker = FindObjectOfType <GamestateTracker>();
gamestateVehicleLookup = FindObjectOfType <GamestateVehicleLookup>();
vehicleNames = gamestateVehicleLookup.sortedVehicleNames;
PlayerEntry playerEntry = gamestateTracker.players.Get((short)PhotonNetwork.LocalPlayer.ActorNumber);
PlayerEntry.Role ourRole = (PlayerEntry.Role)playerEntry.role;
ourTeamId = playerEntry.teamId;
playerEntry.Release();
// get the team we are in
TeamEntry teamEntry = gamestateTracker.teams.Get(ourTeamId);
short driverId = teamEntry.driverId;
short gunnerId = teamEntry.gunnerId;
teamEntry.Release();
// if we are a gunner, check if the driver is a bot.
// if so, get priority
if (ourRole == PlayerEntry.Role.Gunner)
{
PlayerEntry driverEntry = gamestateTracker.players.Get(driverId);
if (driverEntry.isBot)
{
priority = true;
}
driverEntry.Release();
}
// if we are a driver, get priority
if (ourRole == PlayerEntry.Role.Driver)
{
priority = true;
}
// assign other player id, only needed if the other player is human
// hence we only check for if we are a driver
if (priority && ourRole == PlayerEntry.Role.Driver)
{
// get gunner id
PlayerEntry gunnerEntry = gamestateTracker.players.Get(gunnerId);
otherId = gunnerEntry.id;
gunnerEntry.Release();
}
SetButtonsInteractable(priority);
SetupButtons();
}
void Spawn(int teamId)
{
GamestateTracker gamestateTracker = FindObjectOfType <GamestateTracker>();
TeamEntry teamEntry = gamestateTracker.teams.Get((short)teamId);
bool selected = teamEntry.hasSelectedVehicle;
teamEntry.isDead = false;
short vehicle = teamEntry.vehicle;
teamEntry.Commit(RespawnErrorHandler);
Transform sp;
if (teamId > spawnPoints.Count)
{
sp = spawnPoints[0];
}
else
{
sp = spawnPoints[teamId - 1];
}
List <string> vehicleNames = gamestateTracker.GetComponent <GamestateVehicleLookup>().sortedVehicleNames;
string vehiclePrefabName;
if (selected)
{
vehiclePrefabName = "VehiclePrefabs/" + vehicleNames[vehicle];
}
else
{
int randomVehicleNumber = Random.Range(0, defaultPlayerVehiclePrefabNames.Count);
vehiclePrefabName = defaultPlayerVehiclePrefabNames[randomVehicleNumber];
TeamEntry teamEntryAgain = gamestateTracker.teams.Get((short)teamId);
teamEntryAgain.vehicle = (short)randomVehicleNumber;
teamEntryAgain.hasSelectedVehicle = true;
teamEntryAgain.Commit();
}
object[] instantiationData = new object[] { teamId };
//Put strong brakes on for spawn
var spawnedVehicle = PhotonNetwork.Instantiate(vehiclePrefabName, sp.position, sp.rotation, 0, instantiationData);
/*
* PhysXWheelCollider[] wheelColliders = spawnedVehicle.GetComponentsInChildren<PhysXWheelCollider>();
* foreach (PhysXWheelCollider wc in wheelColliders) {
* wc.brakeTorque = 10000;
* }*/
}
// Die is a LOCAL function that is only called by the driver when they get dead.
protected void Die(bool updateDeath, bool updateKill)
{
// Update gamestate
networkManager.CallRespawnVehicle(5f, teamId);
TeamEntry team = gamestateTracker.teams.Get((short)teamId);
myPhotonView.RPC(nameof(SetGunnerHealth_RPC), RpcTarget.All, 0f);
bool hadPotato = hpm.removePotato();
if (!hadPotato)
{
announcerManager.PlayAnnouncerLine(announcerManager.announcerShouts.onKilled, npv.GetDriverID(), npv.GetGunnerID());
}
team.Release();
// update my deaths
if (updateDeath)
{
/*GamestateTracker.TeamDetails myRecord = gamestateTracker.getTeamDetails(teamId);
* myRecord.deaths += 1;
* myRecord.isDead = true;
* gamestateTrackerPhotonView.RPC(nameof(GamestateTracker.UpdateTeamWithNewRecord), RpcTarget.All, teamId,
* JsonUtility.ToJson(myRecord));*/
TeamEntry teamEntry = gamestateTracker.teams.Get((short)teamId);
teamEntry.deaths += 1;
teamEntry.isDead = true;
teamEntry.Increment();
}
if (updateKill)
{
// update their kills
/*GamestateTracker.TeamDetails theirRecord = gamestateTracker.getTeamDetails(lastHitDetails.sourceTeamId);
* theirRecord.kills += 1;
* gamestateTrackerPhotonView.RPC(nameof(GamestateTracker.UpdateTeamWithNewRecord), RpcTarget.All,
* lastHitDetails.sourceTeamId, JsonUtility.ToJson(theirRecord));*/
TeamEntry teamEntry = gamestateTracker.teams.Get((short)lastHitDetails.sourceTeamId);
teamEntry.kills += 1;
teamEntry.Increment();
}
}
public void RespawnErrorHandler(TeamEntry teamEntry, bool succeeded)
{
if (teamEntry != null)
{
if (!succeeded && teamEntry.isDead)
{
teamEntry.isDead = false;
teamEntry.Commit(RespawnErrorHandler);
}
else
{
teamEntry.Release();
}
}
}
// called by the lobby button master when we create a team
public void CreateTeamEntry()
{
lobbySlotMaster = FindObjectOfType <LobbySlotMaster>();
gamestateTracker = FindObjectOfType <GamestateTracker>();
// new gamestate tracker register team
TeamEntry teamEntry = gamestateTracker.teams.Create(true, false);
// add a listener to team record
// TeamEntry teamEntry = gamestateTracker.teams.Get((short)teamId);
teamEntry.Commit();
GetComponent <PhotonView>().RPC(nameof(AddListenerToThisTeam), RpcTarget.AllBufferedViaServer);
}
bool CanSelectGunner()
{
bool canSelect = true;
// check if there is a player occupying the current slot
TeamEntry teamEntry = gamestateTracker.teams.Get((short)teamId);
// if there is a valid player id in the driver slot, return false
if (teamEntry.gunnerId != 0)
{
canSelect = false;
}
teamEntry.Release();
return(canSelect);
}
protected override async Task <IEnumerable <TeamEntry> > GetTeams()
{
var excelApp = new Application();
var book = excelApp.Workbooks.Open(@"C:\Users\robocafaz\Documents\clear rates.xlsx");
var sheet = (Worksheet)book.Sheets[1];
var range = sheet.UsedRange;
var rows = range.Rows.Count;
var columns = range.Columns.Count;
var data = new List <TeamEntry>();
for (var x = 1; x <= rows; x++)
{
for (var y = 1; y <= columns; y++)
{
string value = range.Cells[x, y]?.ToString().Replace("|", ";");
if (value != null)
{
string leader = range.Cells[1, y]?.ToString();
leader = leader.Replace("|", ";");
leader = DigitRegex.Replace(leader, "");
string content = range.Cells[x, 1]?.ToString();
content = content.Replace("|", ";");
content = DigitRegex.Replace(content, "");
string stage = range.Cells[x, 2]?.ToString();
if (x > 1 && y > 2)
{
if (value.Contains("[") && !value.Contains("[V"))
{
int stageId;
var parsed = Int32.TryParse(stage, out stageId);
var entry = new TeamEntry {
Name = $"{leader} vs {content}", CalcLink = value, Desc = value, StageId = parsed ? stageId : (int?)null
};
if (value.Contains("yout"))
{
entry.Video = value;
}
data.Add(entry);
}
}
}
}
}
return(data);
}
public IActionResult EnterTeams(CoachesEnterTeamsViewModel data)
{
var teamId = int.Parse(data.Team);
TeamEntry teamEntry = _context.TeamEntry.Where(t => t.EntryId == data.TeamEntry.EntryId).Single();
teamEntry.IndividualTeamId = teamId;
_context.Update(teamEntry);
_context.SaveChanges();
var tournament = _context.Tournament.FirstOrDefault(t => t.TournamentId == teamEntry.TournamentId);
var enteredTeam = _context.IndividualTeam.FirstOrDefault(t => t.IndividualTeamId == teamId);
var teamCoach = _context.Coach.FirstOrDefault(c => c.CoachId == enteredTeam.CoachId);
teamCoach.Balance = tournament.EntryFee;
_context.Update(teamCoach);
_context.SaveChanges();
return(RedirectToAction("TournamentManagement", "Coaches"));
}
// Return the teams from the gamestate tracker, sorted by score.
public List <TeamEntry> SortTeams(GamestateTracker gamestateTracker)
{
List <TeamEntry> unsortedTeams = new List <TeamEntry>();
for (int i = 0; i < gamestateTracker.teams.count; i++)
{
TeamEntry team = gamestateTracker.teams.GetAtIndex(i);
unsortedTeams.Add(team);
team.Release();
}
List <TeamEntry> sortedTeams = unsortedTeams;
sortedTeams.Sort((t1, t2) => CalcScore(t1).CompareTo(CalcScore(t2)));
sortedTeams.Reverse();
return(sortedTeams);
}
public void GamestateCreateTeamTest()
{
short id = -100;
GamestateCommitTestHelper <TeamEntry> testHelper = new GamestateCommitTestHelper <TeamEntry>(1);
GamestateTable <TeamEntry> teams = testHelper.TestTable(GamestateTracker.Table.Teams);
TeamEntry teamEntry = teams.Create(id);
Assert.That(teamEntry, Is.Not.Null);
Assert.That(teamEntry.id, Is.EqualTo(id));
teamEntry.Commit();
testHelper.Apply(testHelper.commitedPackets[0]);
Assert.That(teams.Get(id), Is.Not.Null);
}
public void GamestateCommitTeamTest()
{
short actorNumber = 17;
short entryId = -100;
GamestateCommitTestHelper <TeamEntry> testHelper = new GamestateCommitTestHelper <TeamEntry>(actorNumber);
GamestateTable <TeamEntry> teams = testHelper.TestTable(GamestateTracker.Table.Teams);
TeamEntry teamEntry = teams.Create(entryId);
Assert.That(teamEntry, Is.Not.Null);
Assert.That(teamEntry.id, Is.EqualTo(entryId));
teamEntry.name = "xrtycuhEEEEE";
teamEntry.isDead = true;
teamEntry.kills = 67;
teamEntry.deaths = 222;
teamEntry.assists = 0;
teamEntry.checkpoint = -9;
teamEntry.Commit();
Assert.That(testHelper.commitedPackets.Count, Is.EqualTo(1));
GamestatePacket packet = testHelper.commitedPackets[0];
Assert.That(packet.revisionNumber, Is.EqualTo(1));
Assert.That(packet.revisionActor, Is.EqualTo(actorNumber));
Assert.That(packet.id, Is.EqualTo(entryId));
Assert.That(packet.hasName, Is.EqualTo(true));
Assert.That(packet.name, Is.EqualTo("xrtycuhEEEEE"));
bool[] hasShortValues = new bool[GamestatePacket.maxShorts];
hasShortValues[(int)TeamEntry.ShortFields.Kills] = true;
hasShortValues[(int)TeamEntry.ShortFields.Deaths] = true;
hasShortValues[(int)TeamEntry.ShortFields.Assists] = true;
hasShortValues[(int)TeamEntry.ShortFields.Checkpoint] = true;
Assert.That(packet.hasShortValues, Is.EquivalentTo(hasShortValues));
Assert.That(packet.shortValues, Is.EquivalentTo(new short[] { 67, 222, 0, -9 }));
bool[] boolValues = new bool[GamestatePacket.maxBools];
boolValues[0] = true;
Assert.That(packet.boolValues, Is.EquivalentTo(boolValues));
}
// USED
// add the driver bot
public void AddDriverBot()
{
if (CanSelectDriver())
{
PlayerEntry bot = gamestateTracker.players.Create(true, true);
bot.ready = true;
bot.role = (short)PlayerEntry.Role.Driver;
bot.isBot = true;
bot.teamId = (short)teamId;
bot.name = "Bot " + -bot.id;
bot.Commit();
// now add the entry to the team
TeamEntry teamEntry = gamestateTracker.teams.Get((short)teamId);
teamEntry.driverId = bot.id;
teamEntry.Commit();
}
}
string GetTeamName(TeamEntry team)
{
string name;
if (team.name == null)
{
PlayerEntry driver = gamestateTracker.players.Get(team.driverId);
PlayerEntry gunner = gamestateTracker.players.Get(team.gunnerId);
name = $"{driver.name} + {gunner.name}";
driver.Release();
gunner.Release();
}
else
{
name = team.name;
}
return(name);
}
void SeparateIntoTeams_RPC()
{
#if UNITY_WEBGL && !UNITY_EDITOR
PlayerEntry self = gamestateTracker.players.Get((short)PhotonNetwork.LocalPlayer.ActorNumber);
TeamEntry team = gamestateTracker.teams.Get(self.teamId);
short teammateID = 0;
if (team.gunnerId == self.id)
{
PlayerEntry partner = gamestateTracker.players.Get(team.driverId);
if (partner.isBot)
{
teammateIsBot = true;
}
else
{
teammateID = partner.id;
}
partner.Release();
}
if (team.driverId == self.id)
{
PlayerEntry partner = gamestateTracker.players.Get(team.gunnerId);
if (partner.isBot)
{
teammateIsBot = true;
}
else
{
teammateID = partner.id;
}
partner.Release();
}
self.Release();
if (!teammateIsBot)
{
string vcID = PhotonNetwork.CurrentRoom.Name + teammateID.ToString();
mute(vcID);
}
else
{
muteAll();
}
#endif
}
public void SelectVehicle(int i)
{
selectedVehicle = vehicleNames[i];
PlayerEntry playerEntry = gamestateTracker.players.Get((short)PhotonNetwork.LocalPlayer.ActorNumber);
int teamId = playerEntry.teamId;
playerEntry.Release();
if (teamId != 0)
{
// get team
TeamEntry teamEntry = gamestateTracker.teams.Get((short)teamId);
teamEntry.vehicle = (short)i;
teamEntry.Commit();
}
}
