private int CalculatePlayerPositionInRace(Opponent player)
{
if (CurrentRace == null)
{
return(0);
}
int output = 1;
int playerCheckpoint = player.CheckpointsPassed;
int beforeYou = Opponents.Count(tuple => {
if (tuple == player)
{
return(false);
}
return(tuple.CheckpointsPassed > playerCheckpoint);
});
output += beforeYou;
var samePosAsYou = Opponents.Where(tuple => tuple.CheckpointsPassed == playerCheckpoint && tuple != player);
output +=
samePosAsYou.Count(
tuple =>
(CurrentRace.Checkpoints[playerCheckpoint].Subtract(tuple.Client.position)).Length() <
(CurrentRace.Checkpoints[playerCheckpoint].Subtract(player.Client.position)).Length());
return(output);
}
public void onResourceStop(object sender, EventArgs e)
{
API.triggerClientEventForAll("resetRace");
Opponents.ForEach(op =>
{
op.HasFinished = false;
op.CheckpointsPassed = 0;
if (!op.Vehicle.IsNull)
{
API.deleteEntity(op.Vehicle);
}
});
foreach (var ent in Objects)
{
API.deleteEntity(ent);
}
foreach (var t in ActiveThreads)
{
if (!t.IsAlive)
{
continue;
}
t.Abort();
}
}
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);
}
void AddOpponent(Opponent opponent)
{
Opponents.Add(opponent);
var command = new RelayCommand();
var callback = Host.OpponentsRejectCallback(opponent);
}
private static void setupDTOs(PlayerDTO playerDTO, IList <PlayerDTO> opponentDTOs, IList <ResourceDTO> resourceDTOs)
{
// create the player
IMoveable playerShip = PlayerAdapter.playerDTOToMoveable(playerDTO, Colors.Black);
playerShip.Mover = new MoveStrategy();
UIDispatcher.Invoke(() => { Player = new Player(Username, UserID, playerDTO.Wallet, playerDTO.Health, playerShip); });
// convert data transfer objects to their respective types and add them to list
foreach (PlayerDTO opponent in opponentDTOs)
{
IMoveable moveable = PlayerAdapter.playerDTOToMoveable(opponent, Colors.Red);
while (!Opponents.TryAdd(opponent.Name, moveable))
{
Task.Delay(1);
}
}
foreach (ResourceDTO resource in resourceDTOs)
{
IResource r = ResourceAdapter.DTOToResource(resource);
while (!Resources.TryAdd(resource.ID, r))
{
Task.Delay(1);
}
}
}
private void StartRace(Race race)
{
race = new Race(race);
CurrentRace = race;
Opponents.ForEach(op =>
{
if (!op.Vehicle.IsNull)
{
API.deleteEntity(op.Vehicle);
}
API.unspectatePlayer(op.Client);
});
foreach (var ent in Objects)
{
API.deleteEntity(ent);
}
Objects.Clear();
foreach (var prop in race.DecorativeProps)
{
Objects.Add(API.createObject(prop.Hash, prop.Position, prop.Rotation));
}
var clients = API.getAllPlayers();
for (int i = 0; i < clients.Count; i++)
{
SetUpPlayerForRace(clients[i], CurrentRace, true, i);
}
RaceStart = DateTime.UtcNow;
API.consoleOutput("RACE: Starting race " + race.Name);
IsRaceStarting = true;
var t = new Thread((ThreadStart) delegate
{
Thread.Sleep(10000);
IsRaceStarting = false;
API.triggerClientEventForAll("startRaceCountdown");
Thread.Sleep(3000);
IsRaceOngoing = true;
var nat = 0x428CA6DBD1094446;
lock (Opponents)
foreach (var opponent in Opponents)
{
API.setEntityPositionFrozen(opponent.Client, opponent.Vehicle, false);
}
});
t.IsBackground = true;
t.Start();
}
private Point TryCreateLine(List <Point> allowedPoints)
{
var lines = new List <List <Point> >();
foreach (var line in Info.GameGeometry.Lines)
{
if (line.All(point => BadgesField[point] == null))
{
continue;
}
if (line.Any(point => Opponents.Contains(BadgesField[point])))
{
continue;
}
lines.Add(line);
}
var random = new Random();
foreach (var line in lines.OrderByDescending(line => line.Count(point => BadgesField[point] != null)))
{
if (allowedPoints.Any(allowedPoint => line.Contains(allowedPoint)))
{
var points = line.Where(point => BadgesField[point] == null);
var allowed = points.Where(allowedPoints.Contains).ToArray();
if (allowed.Length > 0)
{
return(allowed[random.Next(allowed.Length)]);
}
}
}
return(null);
}
private void StartRace(Race race)
{
race = new Race(race);
//Game.FadeScreenOut(500);
CurrentRace = race;
/*if (_raceSettings["Laps"] > 1)
* {
* _totalLaps = race.Checkpoints.Length;
* List<Vector3> tmpCheckpoints = new List<Vector3>();
* for (int i = 0; i < _raceSettings["Laps"]; i++)
* {
* tmpCheckpoints.AddRange(race.Checkpoints);
* }
* _currentRace.Checkpoints = tmpCheckpoints.ToArray();
* }*/
Opponents.ForEach(op =>
{
op.HasFinished = false;
op.CheckpointsPassed = 0;
});
lock (Program.ServerInstance.Clients)
for (int i = 0; i < Program.ServerInstance.Clients.Count; i++)
{
SetUpPlayerForRace(Program.ServerInstance.Clients[i], CurrentRace, true, i);
}
CurrentRaceCheckpoints = race.Checkpoints.ToList();
RaceStart = DateTime.UtcNow;
Console.WriteLine("RACE: Starting race " + race.Name);
var t = new Thread((ThreadStart) delegate
{
Thread.Sleep(10000);
Program.ServerInstance.SendNotificationToAll("3"); // I should probably automate this
Thread.Sleep(1000);
Program.ServerInstance.SendNotificationToAll("2");
Thread.Sleep(1000);
Program.ServerInstance.SendNotificationToAll("1");
Thread.Sleep(1000);
Program.ServerInstance.SendNotificationToAll("Go!");
IsRaceOngoing = true;
lock (Opponents)
foreach (var opponent in Opponents)
{
Program.ServerInstance.SendNativeCallToPlayer(opponent.Client, 0x428CA6DBD1094446, opponent.Vehicle, false);
opponent.HasStarted = true;
}
});
t.Start();
}
public void MapChange(string mapName, XmlGroup map)
{
EndRace();
API.consoleOutput("Parsing map...");
var race = new Race(parseRace(mapName, map));
API.consoleOutput("Map parse done! Race null? " + (race == null));
CurrentRace = race;
Opponents.ForEach(op =>
{
op.HasFinished = false;
op.CheckpointsPassed = 0;
op.TimeFinished = "";
if (!op.Vehicle.IsNull)
{
API.deleteEntity(op.Vehicle);
}
API.freezePlayer(op.Client, true);
});
if (Objects != null)
{
foreach (var ent in Objects)
{
API.deleteEntity(ent);
}
Objects.Clear();
}
else
{
Objects = new List <NetHandle>();
}
var clients = API.getAllPlayers();
for (int i = 0; i < clients.Count; i++)
{
API.freezePlayer(clients[i], false);
SetUpPlayerForRace(clients[i], CurrentRace, true, i);
}
CurrentRaceCheckpoints = race.Checkpoints.ToList();
RaceStart = DateTime.UtcNow;
API.consoleOutput("RACE: Starting race " + race.Name);
RaceStartCountdown = 13;
}
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);
}
public static AITargets FromJsonToken(JToken token)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Invalid comparison between Unknown and I4
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
if ((int)token.get_Type() != 1)
{
Debug.LogWarning((object)("Malformed token : type Object expected, but " + token.get_Type() + " found"));
return(null);
}
JObject val = Extensions.Value <JObject>((IEnumerable <JToken>)token);
JToken val2 = default(JToken);
if (!val.TryGetValue("type", ref val2))
{
Debug.LogWarning((object)"Malformed json: no 'type' property in object of class AITargets");
return(null);
}
string text = Extensions.Value <string>((IEnumerable <JToken>)val2);
AITargets aITargets;
switch (text)
{
case "Nothing":
aITargets = new Nothing();
break;
case "All":
aITargets = new All();
break;
case "Allies":
aITargets = new Allies();
break;
case "AlliesWounded":
aITargets = new AlliesWounded();
break;
case "Opponents":
aITargets = new Opponents();
break;
case "SameAsActionTargets":
aITargets = new SameAsActionTargets();
break;
default:
Debug.LogWarning((object)("Unknown type: " + text));
return(null);
}
aITargets.PopulateFromJson(val);
return(aITargets);
}
public void WriteData()
{
using (FileStream file = new FileStream("paramdb_gtc_eu.db", FileMode.Create, FileAccess.ReadWrite))
{
const uint DataTableCount = 0x24;
file.WriteCharacters("GTAR");
file.WriteUInt(DataTableCount);
uint dataStart = ((DataTableCount + 2) * 4) + 16;
file.WriteUInt(dataStart);
file.WriteUInt(0x07);
file.Position = dataStart;
ushort tableNumber = 0;
BrakeParts.Write(file, dataStart, tableNumber++);
BrakeBalanceControllerParts.Write(file, dataStart, tableNumber++);
SteeringParts.Write(file, dataStart, tableNumber++);
ChassisParts.Write(file, dataStart, tableNumber++);
WeightReductionParts.Write(file, dataStart, tableNumber++);
BodyParts.Write(file, dataStart, tableNumber++);
EngineParts.Write(file, dataStart, tableNumber++);
PortPolishingParts.Write(file, dataStart, tableNumber++);
EngineBalancingParts.Write(file, dataStart, tableNumber++);
DisplacementIncreaseParts.Write(file, dataStart, tableNumber++);
ComputerParts.Write(file, dataStart, tableNumber++);
NATuneParts.Write(file, dataStart, tableNumber++);
TurboKitParts.Write(file, dataStart, tableNumber++);
DrivetrainParts.Write(file, dataStart, tableNumber++);
FlywheelParts.Write(file, dataStart, tableNumber++);
ClutchParts.Write(file, dataStart, tableNumber++);
PropellerShaftParts.Write(file, dataStart, tableNumber++);
GearboxParts.Write(file, dataStart, tableNumber++);
SuspensionParts.Write(file, dataStart, tableNumber++);
IntercoolerParts.Write(file, dataStart, tableNumber++);
MufflerParts.Write(file, dataStart, tableNumber++);
LSDParts.Write(file, dataStart, tableNumber++);
TCSCParts.Write(file, dataStart, tableNumber++);
ASCCParts.Write(file, dataStart, tableNumber++);
WheelsParts.Write(file, dataStart, tableNumber++);
TyreSizeParts.Write(file, dataStart, tableNumber++);
TyreForceVolParts.Write(file, dataStart, tableNumber++);
TyreCompounds.Write(file, dataStart, tableNumber++);
TyresFrontParts.Write(file, dataStart, tableNumber++);
TyresRearParts.Write(file, dataStart, tableNumber++);
Opponents.Write(file, dataStart, tableNumber++);
Events.Write(file, dataStart, tableNumber++);
Regulations.Write(file, dataStart, tableNumber++);
Courses.Write(file, dataStart, tableNumber++);
ArcadeCars.Write(file, dataStart, tableNumber++);
Cars.Write(file, dataStart, tableNumber++);
file.Position = dataStart - 8;
file.WriteUInt((uint)file.Length - dataStart);
}
}
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 AddOpponent(Team team)
{
//Contract.Requires<InvalidOperationException>(!Opponents.Contains(team), $"{this} already played against {team}!");
if (Opponents.Contains(team))
{
Log.Fatal($"!!! Duplicate Matchup recorded: {this} - {team} !!!");
throw new InvalidOperationException($"{this} already played against {team}!");
}
Contract.EndContractBlock();
Opponents.Add(team);
}
private Point MakeBestRandomStep(List <Point> allowedPoints)
{
var lines = new List <List <Point> >();
//lines.AddRange(Lines.Except(Lines.Where(line => line.Any(dot => Opponents.Contains(BadgesField[dot])))));
foreach (var line in Info.GameGeometry.Lines)
{
if (line.Any(dot => Opponents.Contains(BadgesField[dot])))
{
continue;
}
lines.Add(line);
}
var maxCount = 0;
var bestPoints = new List <Point>();
foreach (var point in Info.GameGeometry.Points)
{
var temp = lines.Count(line => line.Contains(point));
if (temp > maxCount)
{
maxCount = temp;
}
}
foreach (var point in Info.GameGeometry.Points)
{
var temp = lines.Count(line => line.Contains(point));
if (temp == maxCount)
{
bestPoints.Add(point);
}
}
var random = new Random();
if (lines.Count == 0)
{
var emptyPoints = BadgesField.Keys.Where(x => BadgesField[x] == null).Where(allowedPoints.Contains).ToArray();
return(emptyPoints[random.Next(emptyPoints.Length)]);
}
var allowed = new List <Point>();
if (allowedPoints.Any(allowedPoint => bestPoints.Contains(allowedPoint)))
{
allowed.AddRange(bestPoints.Where(allowedPoints.Contains));
}
if (allowed.Count > 0)
{
return(allowed[random.Next(allowed.Count)]);
}
return(allowedPoints.First());
}
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 new static Opponents FromJsonToken(JToken token)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Invalid comparison between Unknown and I4
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
if ((int)token.get_Type() != 1)
{
Debug.LogWarning((object)("Malformed token : type Object expected, but " + token.get_Type() + " found"));
return(null);
}
JObject jsonObject = Extensions.Value <JObject>((IEnumerable <JToken>)token);
Opponents opponents = new Opponents();
opponents.PopulateFromJson(jsonObject);
return(opponents);
}
private Vector3 GetBlockDefensivePosition(Vector3 ballPosition)
{
if (_matchStatus?.IsServe ?? false)
{
return(Position);
}
var fowardDirection = TeamFoward.z;
var netDistance = 0.1f * fowardDirection;
if (!Opponents.Any())
{
return(Position);
}
var horizontalPosition = Opponents.OrderBy(x => Position.Distance(x.Position)).First().Position.x;
return(new Vector3(horizontalPosition, 0, netDistance));
}
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;
}
}
private void StartRace(Race race)
{
race = new Race(race);
CurrentRace = race;
Opponents.ForEach(op =>
{
op.HasFinished = false;
op.CheckpointsPassed = 0;
if (!op.Vehicle.IsNull)
{
API.deleteEntity(op.Vehicle);
}
});
foreach (var ent in Objects)
{
API.deleteEntity(ent);
}
Objects.Clear();
foreach (var prop in race.DecorativeProps)
{
Objects.Add(API.createObject(prop.Hash, prop.Position, prop.Rotation));
}
var clients = API.getAllPlayers();
for (int i = 0; i < clients.Count; i++)
{
SetUpPlayerForRace(clients[i], CurrentRace, true, i);
}
CurrentRaceCheckpoints = race.Checkpoints.ToList();
RaceStart = DateTime.UtcNow;
API.consoleOutput("CARRERA: Comenzando la carrera " + race.Name);
RaceStartCountdown = 13;
}
public Snaffle AccioOn(Wizard w)
{
Point w2 = new Point()
{
X = w.X + w.VX,
Y = w.Y + w.VY
};
bool op = Opponents.Any(x => Between(x.X + x.VX, w2.X, MyGoal.X));
List <Snaffle> snf = Snaffles.Where(x => Between(x.X, w2.X, MyGoal.X)).ToList();
if (snf.Count > 0 && op)
{
Snaffle s = GetNearSnuffle(w2, snf);
if (w2.PrecisionLength(s) < 2000)
{
return(s);
}
}
return(null);
}
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
});
}
}
}
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 InsertMatches()
{
if (Competitor == null || Opponents == null || Opponents.Length == 0)
{
Log.WarnDialog("You must select a competitor and at least one opponent");
return;
}
if (TimeSetting == null)
{
Log.WarnDialog("You must select a time control setting");
return;
}
var competitorId = Competitor.Id;
var opponentIds = Opponents.Select(x => x.Id).ToArray();
var timeControlId = TimeSetting.Id;
var matches = new List <ScheduledMatch>();
for (int i = 0; i < MatchCount; i++)
{
for (int j = 0; j < opponentIds.Length; j++)
{
if (PlayWhite)
{
matches.Add(new ScheduledMatch {
WhiteId = competitorId, BlackId = opponentIds[j], TimeControlId = timeControlId
});
}
if (PlayBlack)
{
matches.Add(new ScheduledMatch {
WhiteId = opponentIds[j], BlackId = competitorId, TimeControlId = timeControlId
});
}
}
}
MasterState.Instance.QueueMatches(matches);
}
public void ImportData()
{
BrakeParts.Import();
BrakeBalanceControllerParts.Import();
SteeringParts.Import();
ChassisParts.Import();
WeightReductionParts.Import();
BodyParts.Import();
EngineParts.Import();
PortPolishingParts.Import();
EngineBalancingParts.Import();
DisplacementIncreaseParts.Import();
ComputerParts.Import();
NATuneParts.Import();
TurboKitParts.Import();
DrivetrainParts.Import();
FlywheelParts.Import();
ClutchParts.Import();
PropellerShaftParts.Import();
GearboxParts.Import();
SuspensionParts.Import();
IntercoolerParts.Import();
MufflerParts.Import();
LSDParts.Import();
TCSCParts.Import();
ASCCParts.Import();
WheelsParts.Import();
TyreSizeParts.Import();
TyreForceVolParts.Import();
TyreCompounds.Import();
TyresFrontParts.Import();
TyresRearParts.Import();
Opponents.Import();
Events.Import();
Regulations.Import();
Courses.Import();
ArcadeCars.Import();
Cars.Import();
}
public override bool OnPlayerConnect(Client player)
{
Program.ServerInstance.SetNativeCallOnTickForPlayer(player, "RACE_DISABLE_VEHICLE_EXIT", 0xFE99B66D079CF6BC, 0, 75, true);
Program.ServerInstance.SendNotificationToPlayer(player, "~r~IMPORTANT~w~~n~" + "Quit the server using the ~h~/q~h~ command to remove the blip.");
if (IsRaceOngoing)
{
SetUpPlayerForRace(player, CurrentRace, false, 0);
}
if (DateTime.Now.Subtract(VoteStart).TotalSeconds < 60)
{
Program.ServerInstance.SendNotificationToPlayer(player, GetVoteHelpString());
}
if (RememberedBlips.ContainsKey(player.NetConnection.RemoteUniqueIdentifier))
{
Opponents.Add(new Opponent(player)
{
Blip = RememberedBlips[player.NetConnection.RemoteUniqueIdentifier]
});
}
return(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);
}
public override void OnTick()
{
if (!IsRaceOngoing)
{
return;
}
lock (Opponents)
{
lock (CurrentRaceCheckpoints)
foreach (var opponent in Opponents)
{
if (opponent.HasFinished || !opponent.HasStarted)
{
continue;
}
if (CurrentRaceCheckpoints.Any() && opponent.Client.LastKnownPosition.IsInRangeOf(CurrentRaceCheckpoints[opponent.CheckpointsPassed], 10f))
{
opponent.CheckpointsPassed++;
if (opponent.CheckpointsPassed >= CurrentRaceCheckpoints.Count)
{
if (Opponents.All(op => !op.HasFinished))
{
var t = new Thread((ThreadStart) delegate
{
Thread.Sleep(10000);
Program.ServerInstance.SendChatMessageToAll("Vote for next map will start in 60 seconds!");
Thread.Sleep(30000);
Program.ServerInstance.SendChatMessageToAll("Vote for next map will start in 30 seconds!");
Thread.Sleep(30000);
if (!IsVoteActive())
{
StartVote();
}
});
t.Start();
}
opponent.HasFinished = true;
var pos = Opponents.Count(o => o.HasFinished);
var suffix = pos.ToString().EndsWith("1")
? "st"
: pos.ToString().EndsWith("2") ? "nd" : pos.ToString().EndsWith("3") ? "rd" : "th";
Program.ServerInstance.SendNotificationToAll("~h~" + opponent.Client.DisplayName + "~h~ has finished " + pos + suffix);
Program.ServerInstance.SendNativeCallToPlayer(opponent.Client, 0x45FF974EEE1C8734, opponent.Blip, 0);
Program.ServerInstance.RecallNativeCallOnTickForPlayer(opponent.Client, "RACE_CHECKPOINT_MARKER");
Program.ServerInstance.RecallNativeCallOnTickForPlayer(opponent.Client, "RACE_CHECKPOINT_MARKER_DIR");
continue;
}
Program.ServerInstance.SendNativeCallToPlayer(opponent.Client, 0xAE2AF67E9D9AF65D, opponent.Blip,
CurrentRaceCheckpoints[opponent.CheckpointsPassed].X,
CurrentRaceCheckpoints[opponent.CheckpointsPassed].Y,
CurrentRaceCheckpoints[opponent.CheckpointsPassed].Z);
Program.ServerInstance.SetNativeCallOnTickForPlayer(opponent.Client, "RACE_CHECKPOINT_MARKER",
0x28477EC23D892089, 1, CurrentRaceCheckpoints[opponent.CheckpointsPassed], new Vector3(), new Vector3(),
new Vector3()
{
X = 10f, Y = 10f, Z = 2f
}, 241, 247, 57, 180, false, false, 2, false, false,
false, false);
if (CurrentRaceCheckpoints.Count > opponent.CheckpointsPassed + 1)
{
var nextCp = CurrentRaceCheckpoints[opponent.CheckpointsPassed + 1];
var curCp = CurrentRaceCheckpoints[opponent.CheckpointsPassed];
if (nextCp != null && curCp != null)
{
Vector3 dir = nextCp.Subtract(curCp);
dir = dir.Normalize();
Program.ServerInstance.SetNativeCallOnTickForPlayer(opponent.Client,
"RACE_CHECKPOINT_MARKER_DIR",
0x28477EC23D892089, 20, curCp.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);
}
}
else
{
Program.ServerInstance.RecallNativeCallOnTickForPlayer(opponent.Client, "RACE_CHECKPOINT_MARKER_DIR");
}
}
}
}
}
public void Move(Trooper self, World world, Game game, Move move)
{
if (form == null)
{
thread = new Thread(showWindow);
thread.Start();
Thread.Sleep(1000);
}
var panel = form.panel;
var drawArea = new Bitmap(panel.Size.Width, panel.Size.Height);
panel.Image = drawArea;
Graphics g = Graphics.FromImage(drawArea);
Pen pen = new Pen(Brushes.Black);
g.DrawLine(pen, 1, 1, 40, 40);
this.self = self;
this.world = world;
this.game = game;
this.move = move;
InitializeVariables();
ProcessApproximation();
if (world.MoveIndex == 37 && self.Type == TrooperType.Commander)
{
world = world;
}
var allowHill = !CheckShootMe();
if (BonusGoal != null && GetTrooper(MyStrategy.WhoseBonus) == null)
{
BonusGoal = null;
}
if (BonusGoal != null && IsHaveBonus(GetTrooper(MyStrategy.WhoseBonus), GetBonusAt(BonusGoal)))
{
BonusGoal = null;
}
// Карта где медик и снайпер отдельно (map03)
// Координаты где собираться:
// 18 13
// 11 6
if (MapHash == Lab2Map &&
world.MoveIndex <= 2 &&
(self.Type == TrooperType.FieldMedic || self.Type == TrooperType.Sniper) &&
Opponents.Count() == 0
)
{
var rightLower = new Point(18, 14);
var leftUpper = new Point(11, 5);
var goal = rightLower.GetDistanceTo(self) < leftUpper.GetDistanceTo(self) ? rightLower : leftUpper;
var to = GoScouting(goal, goal);
if (to != null)
{
Go(ActionType.Move, to);
return;
}
}
if (IfFieldRationNeed())
{
Go(ActionType.EatFieldRation);
return;
}
Reached(new Point(self));
if (Opponents.Count() != 0)
{
AllowTakeBonus = false;
// Чтобы знали куда бежать если противник отступит
PointGoal = new Point(Opponents[0]);
PointGoal.profit = world.MoveIndex;
var action = BruteForceDo();
if (action != null)
{
if (Equal(self, action) && action.Action == ActionType.Move && self.ActionPoints < GetMoveCost())
{
Go(ActionType.EndTurn);
}
else
{
Go(action.Action, new Point(action.X, action.Y));
}
return;
}
}
if (self.Type == TrooperType.FieldMedic)
{
var ifHelp = IfHelpTeammate();
if (ifHelp != null)
{
var goal = GetTrooperAt(ifHelp.X, ifHelp.Y);
if (goal != null && goal.Hitpoints < goal.MaximalHitpoints && ifHelp.Nearest(self) && game.FieldMedicHealCost <= self.ActionPoints)
{
Go(ActionType.Heal, ifHelp);
return;
}
if (IsCanMove())
{
var to = GoToUnit(self, ifHelp, map, beginFree: true, endFree: true);
if (to != null)
{
Go(ActionType.Move, to);
return;
}
}
}
}
var ifUseMedikit = IfUseMedikit();
if (ifUseMedikit != null)
{
Go(ActionType.UseMedikit, ifUseMedikit);
return;
}
if (allowHill && IfRequestEnemyDisposition())
{
Go(ActionType.RequestEnemyDisposition);
return;
}
// Группировка
if ((GetTeamRadius() > MaxTeamRadius && self.Id == commander.Id ||
GetTeamRadius() > MaxTeamRadius / 2 && self.Id != commander.Id) &&
self.ActionPoints >= GetMoveCost())
{
var bestTurn = new Point(0, 0, Inf);
for (var i = 0; i < Width; i++)
{
for (var j = 0; j < Height; j++)
{
var r = Math.Max(MaxTeamRadius, GetTeamRadius(self.Id, new Point(i, j)));
if (r < bestTurn.profit && r < GetTeamRadius())
{
bestTurn.Set(i, j, r);
}
}
}
if (bestTurn.profit < Inf)
{
var to = GoScouting(bestTurn, PointGoal ?? (BonusGoal ?? bestTurn));
if (to != null)
{
Go(ActionType.Move, to);
return;
}
}
}
Trooper whoseBonus = null;
var ifTeamBonus = IfTeamBonus(ref whoseBonus, AllowTakeBonus);
if (ifTeamBonus != null && BonusGoal == null && map[ifTeamBonus.X, ifTeamBonus.Y] == 0 && !Equal(ifTeamBonus, self))
{
BonusGoal = ifTeamBonus;
MyStrategy.WhoseBonus = whoseBonus.Id;
}
var waitingHelp = false; //allowHill && IfNeedHelp() && self.Type != TrooperType.FieldMedic && GetBestHelper() != null;
var allowNothing = true;
if (!waitingHelp && IsCanMove() && BonusGoal != null && MyStrategy.WhoseBonus == self.Id)
{
if (IsCanUpper())
{
Go(ActionType.RaiseStance);
return;
}
allowNothing = false;
var to = GoScouting(BonusGoal, PointGoal ?? BonusGoal); //GoToUnit(self, BonusGoal, map, beginFree: true, endFree: false);
// Если путь до бонуса пока что занят, то все равно идти к нему
if (to == null)
{
to = GoToUnit(self, BonusGoal, notFilledMap, beginFree: true, endFree: true);
if (to != null && map[to.X, to.Y] == 0 && self.ActionPoints >= 2 * GetMoveCost(self)) // TODO: ???
{
Go(ActionType.Move, to);
return;
}
}
else
{
if (GetTeamRadius(self.Id, to) > MaxTeamRadius && GetTeamRadius() > GetTeamRadius(self.Id, to))
{
to = GoScouting(new Point(self), PointGoal ?? BonusGoal);
}
Go(ActionType.Move, to);
return;
}
}
// Пытаюсь освободить дорогу до бонуса
if (IsCanMove() && BonusGoal != null && MyStrategy.WhoseBonus != self.Id)
{
if (IsCanUpper())
{
Go(ActionType.RaiseStance);
return;
}
var bestTurn = SkipPath(GetTrooper(MyStrategy.WhoseBonus), PointGoal ?? BonusGoal);
var to = bestTurn == null ? null : GoScouting(bestTurn, PointGoal ?? (BonusGoal ?? new Point(commander))); //GoToUnit(self, bestTurn, map, beginFree: true, endFree: false);
if (to == null || Equal(to, self) && self.ActionPoints < GetMoveCost()) // если Equal(to, self)) тоже делаем move, иначе он не дойдет обратно
{
Go(ActionType.EndTurn);
}
else
{
Go(ActionType.Move, to);
}
return;
}
var ifNothing = IfNothing();
if (allowNothing && ifNothing != null && IsCanMove())
{
if (IsCanUpper())
{
Go(ActionType.RaiseStance);
return;
}
Point to;
if (self.Id == commander.Id)
{
to = GoToUnit(self, ifNothing, map, beginFree: true, endFree: false);
if (GetTeamRadius(self.Id, to) > MaxTeamRadius)
{
to = GoScouting(new Point(self), ifNothing);
}
}
else
{
to = GoScouting(ifNothing, ifNothing);
}
if (to == null || Equal(self, to) && self.ActionPoints < GetMoveCost())
{
if (to == null && changedCommander == -1)
{
// значит мы застряли
// передать коммандование
ChangeCommander();
}
else
{
Go(ActionType.EndTurn);
return;
}
}
else if (!waitingHelp)
{
Go(ActionType.Move, to);
return;
}
}
Point go = GoScouting(new Point(self), IfNothingCommander() ?? new Point(self)); // подумать что делать
if (Equal(self, go) && self.ActionPoints < GetMoveCost())
{
Go(ActionType.EndTurn);
}
else
{
Go(ActionType.Move, go);
}
}
private void newToolStripMenuItem_Click(object sender, EventArgs e)
{
opponent = MessageBox.Show("Play PvP?", "Footbal", MessageBoxButtons.YesNo) == DialogResult.Yes ? Opponents.Player : Opponents.Bot;
firstPlayerGameCards.Clear();
secondPlayerGameCards.Clear();
firstPlayerOutCards.Clear();
secondPlayerOutCards.Clear();
indexArray = MakeRandom();
counter = 0;
round = 0;
for (int i = 0; i < 150; i++)
cards[i].SetImagePosition(-200, -200);
for (int i = 0; i < 10; i++)
{
var cardItem = cards[indexArray[counter]];
if (i%2 == 0)
firstPlayerGameCards.Add(cardItem);
else
secondPlayerGameCards.Add(cardItem);
++counter;
}
var count = 0;
foreach (var item in firstPlayerGameCards)
{
item.SetImagePosition(182 + count*128, 504);
item.SetVisible(false);
item.ImageBox.BringToFront();
item.Status = CardStatus.Player;
item.PlayerOwner = CardOwner.First;
++count;
}
count = 0;
foreach (var item in secondPlayerGameCards)
{
item.SetImagePosition(182 + count*128, 32);
item.SetVisible(false);
item.ImageBox.BringToFront();
item.Status = CardStatus.Player;
item.PlayerOwner = CardOwner.Second;
++count;
}
skip1.Enabled = false;
skip2.Enabled = false;
skip2.Visible = false;
skip1.Visible = true;
turn = Players.Second;
turn = ChangeTurn(turn);
RoundLabel.Visible = true;
TimeLabel.Visible = true;
NumberOutCards1Label.Visible = true;
NumberOutCards2Label.Visible = true;
RoundLabel.Text = "Round " + (round + 1);
TimeLabel.Text = "Time\n" + (round*5) + ":00";
NumberOutCards1Label.Text = firstPlayerOutCards.Count.ToString(CultureInfo.InvariantCulture);
NumberOutCards2Label.Text = secondPlayerOutCards.Count.ToString(CultureInfo.InvariantCulture);
if (opponent == Opponents.Bot)
{
foreach (var card in firstPlayerGameCards)
card.SetVisible(true);
secondPlayerBlocked = true;
}
}
