private async void InitializeGameDTO(GameDTO game)
{
_targetGame = game;
await game.Assignments.ForEachAsync(async (assignment) => {
AssignmentViewModel assignmentViewModel = ViewModelLocator.Resolve <AssignmentViewModel>();
await assignmentViewModel.InitializeAsync(_targetTeamMember);
await assignmentViewModel.InitializeAsync(assignment);
Assignments.Add(assignmentViewModel);
});
Duration.Value = game.DurationInMinutes.ToString();
IsGameCanceled = game.IsCanceled;
TimeTBD = game.IsTimeTbd;
LocationDetails.Value = game.LocationDetails;
SelectedLocation.Value = Locations.FirstOrDefault(lDTO => lDTO.Id == game.Location.Id);
Arrival.Value = game.MinutesToArriveEarly.ToString();
Notes.Value = game.Notes;
IsTowardStandings = game.NotForStandings;
SelectedOpponent.Value = Opponents.FirstOrDefault(oDTO => oDTO.Id == game.Opponent.Id);
Date.Value = game.StartDate;
Time.Value = game.StartDate.TimeOfDay;
SelectedActionVenue.Value = ActionVenues.FirstOrDefault(aVDI => aVDI.ActionVenue == game.Type);
UniformDescription.Value = game.Uniform;
}
public override bool OnPlayerDisconnect(Client player)
{
Opponent curOp = Opponents.FirstOrDefault(op => op.Client == player);
if (curOp == null)
{
return(true);
}
if (RememberedBlips.ContainsKey(player.NetConnection.RemoteUniqueIdentifier))
{
RememberedBlips[player.NetConnection.RemoteUniqueIdentifier] = curOp.Blip;
}
else
{
RememberedBlips.Add(player.NetConnection.RemoteUniqueIdentifier, curOp.Blip);
}
if (curOp.Vehicle != 0)
{
Program.ServerInstance.SendNativeCallToPlayer(player, 0xAD738C3085FE7E11, curOp.Vehicle, true, false);
Program.ServerInstance.SendNativeCallToPlayer(player, 0xAE3CBE5BF394C9C9, curOp.Vehicle);
}
if (curOp.Blip != 0)
{
Program.ServerInstance.SendNativeCallToPlayer(player, 0x45FF974EEE1C8734, curOp.Blip, 0);
}
lock (Opponents) Opponents.Remove(curOp);
return(true);
}
public void onDisconnect(Client player, string reason)
{
Opponent curOp = Opponents.FirstOrDefault(op => op.Client == player);
if (curOp == null)
{
return;
}
API.deleteEntity(curOp.Vehicle);
lock (Opponents) Opponents.Remove(curOp);
}
private void onClientEvent(Client sender, string eventName, params object[] arguments)
{
if (eventName == "race_requestRespawn")
{
Opponent curOp = Opponents.FirstOrDefault(op => op.Client == sender);
if (curOp == null || curOp.HasFinished || !curOp.HasStarted || curOp.CheckpointsPassed == 0)
{
return;
}
RespawnPlayer(sender, CurrentRace, curOp.CheckpointsPassed - 1);
}
}
public void onPlayerRespawn(Client player)
{
if (IsRaceOngoing)
{
Opponent curOp = Opponents.FirstOrDefault(op => op.Client == player);
if (curOp == null || curOp.HasFinished || !curOp.HasStarted || curOp.CheckpointsPassed == 0)
{
SetUpPlayerForRace(player, CurrentRace, false, 0);
}
else
{
RespawnPlayer(player, CurrentRace, curOp.CheckpointsPassed - 1);
}
}
}
public void onPlayerRespawn(Client player)
{
if (IsRaceStarting)
{
SetUpPlayerForRace(player, CurrentRace, false, 0);
}
else if (IsRaceOngoing)
{
API.setPlayerToSpectator(player);
Opponent curOp = Opponents.FirstOrDefault(op => op.Client == player);
if (curOp == null)
{
return;
}
curOp.IsAlive = false;
}
}
public void onUpdate(object sender, EventArgs e)
{
if (!IsRaceOngoing)
{
return;
}
lock (Opponents)
{
var count = 0;
foreach (var playa in Opponents)
{
if (playa.Client.Position.Z <= 0 || playa.Client.Position.Z <= CurrentRace.Checkpoints[0].Z)
{
API.setPlayerHealth(playa.Client, -1);
playa.IsAlive = false;
}
if (playa.IsAlive)
{
count++;
}
}
if (count <= 1)
{
StartVote();
var winner = Opponents.FirstOrDefault(op => op.IsAlive);
if (winner != null)
{
API.sendChatMessageToAll("The winner is ~b~" + winner.Client.Name + "~w~!");
}
else
{
API.sendChatMessageToAll("There are no winners!");
}
IsRaceOngoing = false;
}
}
}
private void SetUpPlayerForRace(Client client, Race race, bool freeze, int spawnpoint)
{
if (race == null)
{
return;
}
var selectedModel = unchecked ((int)((uint)race.AvailableVehicles[randGen.Next(race.AvailableVehicles.Length)]));
var position = race.SpawnPoints[spawnpoint % race.SpawnPoints.Length].Position;
var heading = race.SpawnPoints[spawnpoint % race.SpawnPoints.Length].Heading;
API.setEntityPosition(client.CharacterHandle, position);
var playerVehicle = API.createVehicle(selectedModel, position, new Vector3(0, 0, heading), 0, 0);
Thread.Sleep(500);
API.setPlayerIntoVehicle(client, playerVehicle, -1);
if (freeze)
{
API.setEntityPositionFrozen(client, playerVehicle, true);
}
Opponent inOp = Opponents.FirstOrDefault(op => op.Client == client);
lock (Opponents)
{
if (inOp != null)
{
inOp.Vehicle = playerVehicle;
inOp.IsAlive = true;
}
else
{
Opponents.Add(new Opponent(client)
{
Vehicle = playerVehicle, IsAlive = true
});
}
}
}
/*private int CalculatePlayerPositionInRace(Client player)
* {
* int output = 0;
* int playerCheckpoint = _currentRace.Checkpoints.Length - _checkpoints.Count;
*
* int beforeYou = _rivalCheckpointStatus.Count(tuple => tuple.Item2 > playerCheckpoint);
* output += beforeYou;
*
* var samePosAsYou = _rivalCheckpointStatus.Where(tuple => tuple.Item2 == playerCheckpoint);
* output +=
* samePosAsYou.Count(
* tuple =>
* (_currentRace.Checkpoints[playerCheckpoint] - tuple.Item1.Vehicle.Position).Length() <
* (_currentRace.Checkpoints[playerCheckpoint] - Game.Player.Character.Position).Length());
*
* return output;
* }*/
private void SetPlayerInVehicle(Client player, int model, Vector3 pos, float heading, bool freeze)
{
Program.ServerInstance.SetNativeCallOnTickForPlayer(player, "RACE_REQUEST_MODEL", 0x963D27A58DF860AC, model);
Thread.Sleep(5000);
Program.ServerInstance.RecallNativeCallOnTickForPlayer(player, "RACE_REQUEST_MODEL");
Program.ServerInstance.GetNativeCallFromPlayer(player, "spawn", 0xAF35D0D2583051B0, new IntArgument(),
delegate(object o)
{
Program.ServerInstance.SendNativeCallToPlayer(player, 0xF75B0D629E1C063D, new LocalPlayerArgument(), (int)o, -1);
if (freeze)
{
Program.ServerInstance.SendNativeCallToPlayer(player, 0x428CA6DBD1094446, (int)o, true);
}
Opponent inOp = Opponents.FirstOrDefault(op => op.Client == player);
lock (Opponents)
{
if (inOp != null)
{
inOp.Vehicle = (int)o;
inOp.HasStarted = true;
}
else
{
Opponents.Add(new Opponent(player)
{
Vehicle = (int)o, HasStarted = true
});
}
}
Program.ServerInstance.SendNativeCallToPlayer(player, 0xE532F5D78798DAAB, model);
}, model, pos.X, pos.Y, pos.Z, heading, false, false);
}
private void SetUpPlayerForRace(Client client, Race race, bool freeze, int spawnpoint)
{
if (race == null)
{
return;
}
var selectedModel = unchecked ((int)((uint)race.AvailableVehicles[randGen.Next(race.AvailableVehicles.Length)]));
var position = race.SpawnPoints[spawnpoint % race.SpawnPoints.Length].Position;
var heading = race.SpawnPoints[spawnpoint % race.SpawnPoints.Length].Heading;
Program.ServerInstance.SendNativeCallToPlayer(client, 0x06843DA7060A026B, new LocalPlayerArgument(),
position.X, position.Y, position.Z, 0, 0, 0, 1);
if (race.Checkpoints.Length >= 2)
{
Vector3 dir = race.Checkpoints[1].Subtract(race.Checkpoints[0]);
dir = dir.Normalize();
Program.ServerInstance.SetNativeCallOnTickForPlayer(client, "RACE_CHECKPOINT_MARKER_DIR",
0x28477EC23D892089, 20, race.Checkpoints[0].Subtract(new Vector3()
{
X = 0f, Y = 0f, Z = -2f
}), dir, new Vector3()
{
X = 60f, Y = 0f, Z = 0f
},
new Vector3()
{
X = 4f, Y = 4f, Z = 4f
}, 87, 193, 250, 200, false, false, 2, false, false,
false, false);
}
Program.ServerInstance.SetNativeCallOnTickForPlayer(client, "RACE_CHECKPOINT_MARKER",
0x28477EC23D892089, 1, race.Checkpoints[0], new Vector3(), new Vector3(),
new Vector3()
{
X = 10f, Y = 10f, Z = 2f
}, 241, 247, 57, 180, false, false, 2, false, false,
false, false);
var nt = new Thread((ThreadStart) delegate
{
SetPlayerInVehicle(client, selectedModel, position, heading, freeze);
});
nt.Start();
Opponent curOp = Opponents.FirstOrDefault(op => op.Client == client);
if (curOp == null || curOp.Blip == 0)
{
Program.ServerInstance.GetNativeCallFromPlayer(client, "start_blip", 0x5A039BB0BCA604B6,
new IntArgument(), // ADD_BLIP_FOR_COORD
delegate(object o)
{
lock (Opponents)
{
Opponent secOp = Opponents.FirstOrDefault(op => op.Client == client);
if (secOp != null)
{
secOp.Blip = (int)o;
}
else
{
Opponents.Add(new Opponent(client)
{
Blip = (int)o
});
}
}
}, race.Checkpoints[0].X, race.Checkpoints[0].Y, race.Checkpoints[0].Z);
}
else
{
Program.ServerInstance.SendNativeCallToPlayer(client, 0x45FF974EEE1C8734, curOp.Blip, 255);
Program.ServerInstance.SendNativeCallToPlayer(client, 0xAE2AF67E9D9AF65D, curOp.Blip, race.Checkpoints[0].X, race.Checkpoints[0].Y, race.Checkpoints[0].Z);
}
}
public override bool OnChatMessage(Client sender, string message)
{
if (message == "/votemap" && !IsVoteActive() && (!IsRaceOngoing || DateTime.UtcNow.Subtract(RaceStart).TotalSeconds > 60))
{
StartVote();
return(false);
}
else if (message.StartsWith("/vote"))
{
if (DateTime.Now.Subtract(VoteStart).TotalSeconds > 60)
{
Program.ServerInstance.SendChatMessageToPlayer(sender, "No current vote is in progress.");
return(false);
}
var args = message.Split();
if (args.Length <= 1)
{
Program.ServerInstance.SendChatMessageToPlayer(sender, "USAGE", "/vote [id]");
return(false);
}
if (Voters.Contains(sender))
{
Program.ServerInstance.SendChatMessageToPlayer(sender, "ERROR", "You have already voted!");
return(false);
}
int choice;
if (!int.TryParse(args[1], out choice) || choice <= 0 || choice > AvailableChoices.Count)
{
Program.ServerInstance.SendChatMessageToPlayer(sender, "USAGE", "/vote [id]");
return(false);
}
Votes[choice]++;
Program.ServerInstance.SendChatMessageToPlayer(sender, "You have voted for " + AvailableChoices[choice].Name);
Voters.Add(sender);
return(false);
}
else if (message == "/q")
{
Opponent curOp = Opponents.FirstOrDefault(op => op.Client == sender);
if (curOp != null)
{
if (curOp.Blip != 0)
{
Program.ServerInstance.SendNativeCallToPlayer(sender, 0x45FF974EEE1C8734, curOp.Blip, 0);
//Program.ServerInstance.SendNativeCallToPlayer(sender, 0x86A652570E5F25DD, new PointerArgumentInt() {Data = curOp.Blip});
}
lock (Opponents) Opponents.Remove(curOp);
}
Program.ServerInstance.KickPlayer(sender, "requested");
return(false);
}
return(true);
}
public void onUpdate()
{
if (DateTime.Now.Subtract(LastSecond).TotalMilliseconds > 1000)
{
LastSecond = DateTime.Now;
if (TimeLeft > 0)
{
TimeLeft--;
if (TimeLeft == 0)
{
if (!IsVoteActive())
{
StartVote();
}
}
else if (TimeLeft == 30)
{
API.sendChatMessageToAll("¡Vota por el próximo mapa que comenzará en 30 segundos!");
}
else if (TimeLeft == 59)
{
API.sendChatMessageToAll("¡Vota por el próximo mapa que comenzará en 60 segundos!");
}
}
if (RaceStartCountdown > 0)
{
RaceStartCountdown--;
if (RaceStartCountdown == 3)
{
API.triggerClientEventForAll("startRaceCountdown");
}
else if (RaceStartCountdown == 0)
{
IsRaceOngoing = true;
lock (Opponents)
foreach (var opponent in Opponents)
{
API.setEntityPositionFrozen(opponent.Client, opponent.Vehicle, false);
opponent.HasStarted = true;
}
RaceTimer = DateTime.Now;
}
}
if (VoteEnd > 0)
{
VoteEnd--;
if (VoteEnd == 0)
{
EndRace();
var raceWon = AvailableChoices[Votes.OrderByDescending(pair => pair.Value).ToList()[0].Key];
API.sendChatMessageToAll("La carrera ~b~" + raceWon.Name + "~w~ ha ganado en votos!");
API.delay(1000, true, () => {
StartRace(raceWon);
});
}
}
}
if (!IsRaceOngoing)
{
return;
}
lock (Opponents)
{
var count = 0;
foreach (var playa in Opponents)
{
if (playa.Client.position.Z <= 0 || playa.Client.position.Z <= CurrentRace.Checkpoints[0].Z)
{
API.setPlayerHealth(playa.Client, -1);
playa.IsAlive = false;
}
if (playa.IsAlive)
{
count++;
}
}
if (count <= 1)
{
StartVote();
var winner = Opponents.FirstOrDefault(op => op.IsAlive);
if (winner != null)
{
API.sendChatMessageToAll("El ganador es ~b~" + winner.Client.name + "~w~!");
}
else
{
API.sendChatMessageToAll("No hay ganadores!");
}
IsRaceOngoing = false;
}
}
}
private void RespawnPlayer(Client client, Race race, int checkpoint)
{
if (race == null)
{
return;
}
Opponent inOp = Opponents.FirstOrDefault(op => op.Client == client);
int selectedModel = 0;
int color1 = 0;
int color2 = 0;
if (inOp != null)
{
selectedModel = API.getEntityModel(inOp.Vehicle);
color1 = API.getVehiclePrimaryColor(inOp.Vehicle);
color2 = API.getVehicleSecondaryColor(inOp.Vehicle);
}
if (selectedModel == 0)
{
selectedModel = unchecked ((int)((uint)race.AvailableVehicles[randGen.Next(race.AvailableVehicles.Length)]));
}
var position = CurrentRaceCheckpoints[checkpoint];
var next = position;
if (CurrentRaceCheckpoints.Count > checkpoint + 1)
{
next = CurrentRaceCheckpoints[checkpoint + 1];
}
else
{
next = CurrentRaceCheckpoints[checkpoint - 1];
}
float heading;
var direction = next - position;
direction.Normalize();
var radAtan = -Math.Atan2(direction.X, direction.Y);
heading = (float)(radAtan * 180f / Math.PI);
API.setEntityPosition(client.handle, position);
Vector3 newDir = null;
if (CurrentRaceCheckpoints.Count > checkpoint + 2)
{
Vector3 dir = CurrentRaceCheckpoints[checkpoint + 2].Subtract(CurrentRaceCheckpoints[checkpoint + 1]);
dir.Normalize();
newDir = dir;
}
var nextPos = CurrentRaceCheckpoints[checkpoint + 1];
if (newDir == null)
{
API.triggerClientEvent(client, "setNextCheckpoint", nextPos, true, false);
}
else
{
API.triggerClientEvent(client, "setNextCheckpoint", nextPos, false, false, newDir, CurrentRaceCheckpoints[checkpoint + 2]);
}
var playerVehicle = API.createVehicle((VehicleHash)selectedModel, position, new Vector3(0, 0, heading), color1, color2);
API.setPlayerIntoVehicle(client, playerVehicle, -1);
lock (Opponents)
{
if (inOp != null)
{
API.deleteEntity(inOp.Vehicle);
inOp.Vehicle = playerVehicle;
inOp.HasStarted = true;
}
else
{
Opponents.Add(new Opponent(client)
{
Vehicle = playerVehicle, HasStarted = true
});
}
}
}
private void SetUpPlayerForRace(Client client, Race race, bool freeze, int spawnpoint)
{
if (race == null)
{
return;
}
var selectedModel = unchecked ((int)((uint)race.AvailableVehicles[randGen.Next(race.AvailableVehicles.Length)]));
var position = race.SpawnPoints[spawnpoint % race.SpawnPoints.Length].Position;
var heading = race.SpawnPoints[spawnpoint % race.SpawnPoints.Length].Heading;
API.setEntityPosition(client.handle, position);
Vector3 newDir = null;
if (race.Checkpoints.Length >= 2)
{
Vector3 dir = race.Checkpoints[1].Subtract(race.Checkpoints[0]);
dir.Normalize();
newDir = dir;
}
var nextPos = race.Checkpoints[0];
if (newDir == null)
{
API.triggerClientEvent(client, "setNextCheckpoint", nextPos, true, false);
}
else
{
API.triggerClientEvent(client, "setNextCheckpoint", nextPos, false, false, newDir, race.Checkpoints[1]);
}
var playerVehicle = API.createVehicle((VehicleHash)selectedModel, position, new Vector3(0, 0, heading), randGen.Next(70), randGen.Next(70));
API.setPlayerIntoVehicle(client, playerVehicle, -1);
if (freeze)
{
API.setEntityPositionFrozen(client, playerVehicle, true);
}
Opponent inOp = Opponents.FirstOrDefault(op => op.Client == client);
lock (Opponents)
{
if (inOp != null)
{
inOp.Vehicle = playerVehicle;
inOp.HasStarted = true;
}
else
{
Opponents.Add(new Opponent(client)
{
Vehicle = playerVehicle, HasStarted = true
});
}
}
}
Move BruteForceDo()
{
var fictive = 0;
if (queue.Count < Team.Count())
{
foreach (var tr in Team)
{
if (!queue.Contains(tr.Id))
{
queue.Add(tr.Id);
fictive++;
}
}
}
OpponentCommander = Opponents.FirstOrDefault(opp => opp.Type == TrooperType.Commander);
state = new State();
state.Position = new Point[Team.Count()];
state.stance = new int[Team.Count()];
state.act = new int[Team.Count()];
state.hit = new int[Team.Count()];
state.medikit = new bool[Team.Count()];
state.grenade = new bool[Team.Count()];
Troopers = new Trooper[Team.Count()];
CommanderId = -1;
foreach (var tr in troopers)
{
if (tr.IsTeammate)
{
int pos = GetQueuePlace2(tr, true) - 1;
state.Position[pos] = new Point(tr);
state.stance[pos] = GetStanceId(tr.Stance);
state.medikit[pos] = tr.IsHoldingMedikit;
state.grenade[pos] = tr.IsHoldingGrenade;
Troopers[pos] = tr;
if (tr.Type == TrooperType.Commander)
{
CommanderId = pos;
}
}
}
state.id = 0;
state.profit = 0;
state.act[0] = Troopers[0].ActionPoints;
MyCount = state.Position.Count();
for (var i = 0; i < MyCount; i++)
{
state.hit[i] = Troopers[i].Hitpoints;
}
for (var i = 1; i < Troopers.Count(); i++)
{
state.act[i] = getInitialActionPoints(Troopers[i]);
}
stack = new ArrayList[MyCount];
bestStack = new ArrayList[MyCount];
for (var i = 0; i < MyCount; i++)
{
stack[i] = new ArrayList();
bestStack[i] = null;
}
bestProfit = -Inf;
counter = 0;
OpponentsCount = Opponents.Count();
MyCount = state.Position.Count();
Multiplier = Math.Min(MyCount, 3);
state.opphit = new int[OpponentsCount];
probab = new double[OpponentsCount];
for (var i = 0; i < probab.Length; i++)
{
probab[i] = 1.0;
}
for (var i = 0; i < OpponentsCount; i++)
{
state.opphit[i] = Opponents[i].Hitpoints;
// Чтобы уменьшить приоритет стрельбы в "мнимую" цель
if (world.MoveIndex - OpponentsMemoryAppearTime[i] > 1)
{
probab[i] /= 2;
}
else if (OpponentsMemoryType[i] == self.Type && world.MoveIndex - OpponentsMemoryAppearTime[i] == 1)
{
probab[i] /= 2;
}
// TODO: можно точнее
else if (!(OpponentsMemoryType[i] == self.Type || IsBetween(OpponentsMemoryType[i], self.Type, Opponents[i].Type)))
{
probab[i] /= 2;
}
}
dfs_changeStance1();
// remove fictive from queue
queue.RemoveRange(queue.Count - fictive, fictive);
var move = new Move();
ReduceStack(bestStack[0]);
if (bestStack[0].Count == 0)
{
// EndTurn
bestStack[0].Add("at " + self.X + " " + self.Y);
}
var cmd = ((string)bestStack[0][0]).Split(' ');
if (cmd[0] == "st")
{
// Change stance
var ds = int.Parse(cmd[1]);
if (ds < 0)
{
move.Action = ActionType.LowerStance;
}
else if (ds > 0)
{
move.Action = ActionType.RaiseStance;
}
else
{
throw new InvalidDataException();
}
}
else if (cmd[0] == "at")
{
var x = int.Parse(cmd[1]);
var y = int.Parse(cmd[2]);
var to = bestStack[0].Count == 1
? GoScouting(new Point(x, y), new Point(Opponents[0]), changeStanceAllow: true)
: GoToUnit(self, new Point(x, y), map, beginFree: true, endFree: false);
if (to.X == -1)
{
move.Action = to.Y == -1 ? ActionType.LowerStance : ActionType.RaiseStance;
}
else
{
move.Action = ActionType.Move;
move.X = to.X;
move.Y = to.Y;
}
}
else if (cmd[0] == "sh")
{
var x = int.Parse(cmd[1]);
var y = int.Parse(cmd[2]);
move.Action = ActionType.Shoot;
move.X = x;
move.Y = y;
}
else if (cmd[0] == "med")
{
var to = new Point(int.Parse(cmd[1]), int.Parse(cmd[2]));
move.Action = ActionType.UseMedikit;
move.X = to.X;
move.Y = to.Y;
}
else if (cmd[0] == "gr")
{
var to = new Point(int.Parse(cmd[1]), int.Parse(cmd[2]));
move.Action = ActionType.ThrowGrenade;
move.X = to.X;
move.Y = to.Y;
}
else if (cmd[0] == "heal")
{
var to = new Point(int.Parse(cmd[1]), int.Parse(cmd[2]));
move.Action = ActionType.Heal;
move.X = to.X;
move.Y = to.Y;
}
else
{
throw new NotImplementedException(cmd.ToString());
}
return(move);
}
public void onUpdate(object sender, EventArgs e)
{
if (DateTime.Now.Subtract(LastSecond).TotalMilliseconds > 1000)
{
LastSecond = DateTime.Now;
if (TimeLeft > 0)
{
TimeLeft--;
if (TimeLeft == 0)
{
if (!IsVoteActive())
{
StartVote();
}
}
else if (TimeLeft == 30)
{
API.sendChatMessageToAll("Vote for next map will start in 30 seconds!");
}
else if (TimeLeft == 59)
{
API.sendChatMessageToAll("Vote for next map will start in 60 seconds!");
}
}
if (RaceStartCountdown > 0)
{
RaceStartCountdown--;
if (RaceStartCountdown == 3)
{
API.triggerClientEventForAll("startRaceCountdown");
}
else if (RaceStartCountdown == 0)
{
IsRaceOngoing = true;
lock (Opponents)
foreach (var opponent in Opponents)
{
API.setEntityPositionFrozen(opponent.Client, opponent.Vehicle, false);
opponent.HasStarted = true;
}
RaceTimer = DateTime.Now;
}
}
if (VoteEnd > 0)
{
VoteEnd--;
if (VoteEnd == 0)
{
EndRace();
var raceWon = AvailableChoices[Votes.OrderByDescending(pair => pair.Value).ToList()[0].Key];
API.sendChatMessageToAll("Race ~b~" + raceWon.name + "~w~ has won the vote!");
API.sleep(1000);
StartRace(raceWon);
}
}
}
if (!IsRaceOngoing)
{
return;
}
lock (Opponents)
{
var count = 0;
foreach (var playa in Opponents)
{
if (playa.Client.Position.Z <= 0 || playa.Client.Position.Z <= CurrentRace.Checkpoints[0].Z)
{
API.setPlayerHealth(playa.Client, -1);
playa.IsAlive = false;
}
if (playa.IsAlive)
{
count++;
}
}
if (count <= 1)
{
StartVote();
var winner = Opponents.FirstOrDefault(op => op.IsAlive);
if (winner != null)
{
API.sendChatMessageToAll("The winner is ~b~" + winner.Client.name + "~w~!");
}
else
{
API.sendChatMessageToAll("There are no winners!");
}
IsRaceOngoing = false;
}
}
}
