private double getDanger(Trooper opp, int x, int y, int st, int h)
{
if (GetPlayer(opp.PlayerId) != null && GetPlayer(opp.PlayerId).IsStrategyCrashed)
{
return(0);
}
// Чтобы не бояться одного снайпера
var oppShootingRange = state.opphit.Count(e => e > 0) == 1 && opp.Type == TrooperType.Sniper
? GetVisionRange(opp, Troopers[state.id], state.Stance)
: GetShootingRange(opp, opp.Stance);
int d = GetDistanceToShoot((int)(oppShootingRange + Eps), opp.X, opp.Y, GetStanceId(opp.Stance), x, y, st);
// если он достреливает сразу:
if (d == 0)
{
return(200);
}
int v;
if (world.IsVisible(GetVisionRange(opp, Troopers[state.id], state.Stance), opp.X, opp.Y, opp.Stance, x, y, GetStance(state.Stance)))
{
v = 0;
}
else
{
v = GetDistanceTo((int)(GetVisionRange(opp, Troopers[state.id], state.Stance) + Eps),
opp.X, opp.Y, GetStanceId(opp.Stance), x, y, st);
}
double visiblePenalty = 50 * (v == 0 ? 1 : Math.Exp(-v));
var oppAct = opp.InitialActionPoints;
if (opp.Type != TrooperType.Scout && opp.Type != TrooperType.Soldier && OpponentCommander != null && OpponentCommander.GetDistanceTo(opp) <= game.CommanderAuraRange)
{
oppAct += game.CommanderAuraBonusActionPoints;
}
// если он подходит и убивает
int act = oppAct - d * 2; // TODO: ???
int can = act / opp.ShootCost;
double dam = can * opp.StandingDamage;
if (dam >= h)
{
return(150 + visiblePenalty);
}
// если он подходит и отнимает жизни
// тогда теперь он вынужден отбегать
act = oppAct - (d * 2) * 2; // TODO: ???
can = act / opp.ShootCost;
dam = Math.Max(0, can * opp.StandingDamage) + visiblePenalty;
if (dam <= 0)
{
return(0);
}
return(dam);
}
public void AssignTrooper(Trooper t)
{
switch (t.Role)
{
case Enums.Role.Commander:
Commander = t;
break;
case Enums.Role.XO:
XO = t;
break;
case Enums.Role.CShopCommander:
CShopCommander = t;
break;
case Enums.Role.CShopXO:
CShopXO = t;
break;
case Enums.Role.NCOIC:
NCOIC = t;
break;
case Enums.Role.Medic:
Medic = t;
break;
case Enums.Role.RTO:
RT = t;
break;
}
}
public void run()
{
try
{
remoteProcessClient.WriteToken(token);
int teamSize = remoteProcessClient.ReadTeamSize();
remoteProcessClient.WriteProtocolVersion();
Game game = remoteProcessClient.readGameContext();
IStrategy[] strategies = new IStrategy[teamSize];
for (int strategyIndex = 0; strategyIndex < teamSize; ++strategyIndex)
{
strategies[strategyIndex] = new MyStrategy();
}
PlayerContext playerContext;
while ((playerContext = remoteProcessClient.ReadPlayerContext()) != null)
{
Trooper playerTrooper = playerContext.Trooper;
Move move = new Move();
strategies[playerTrooper.TeammateIndex].Move(playerTrooper, playerContext.World, game, move);
remoteProcessClient.WriteMove(move);
}
}
finally
{
remoteProcessClient.Close();
}
}
protected static bool UpdateRank(int?primary, int?edit, ref Trooper p, ref Trooper s,
[NotNullWhen(true)] out RankChange?update)
{
if (primary != edit)
{
update = new RankChange()
{
ChangedFrom = primary ?? -1,
ChangedTo = edit ?? -1,
ChangedOn = DateTime.UtcNow,
SubmittedByRosterClerk = true
};
p.RankChanges.Add(update);
s.SubmittedRankChanges.Add(update);
if (primary < edit)
{
p.LastPromotion = DateTime.UtcNow;
}
return(true);
}
update = null;
return(false);
}
protected static bool UpdateQuals(Trooper edit, ref Trooper primary, ref Trooper submitter,
[NotNullWhen(true)] out QualificationChange?update)
{
if (primary.Qualifications != edit.Qualifications)
{
var changes = primary.Qualifications ^ edit.Qualifications;
var additions = edit.Qualifications & changes;
var removals = primary.Qualifications & changes;
update = new QualificationChange()
{
Added = additions,
Removed = removals,
OldQualifications = primary.Qualifications,
Revoked = false,
SubmittedByRosterClerk = true,
ChangedOn = DateTime.UtcNow
};
primary.Qualifications = edit.Qualifications;
primary.QualificationChanges.Add(update);
submitter.SubmittedQualificationChanges.Add(update);
return(true);
}
update = null;
return(false);
}
protected static bool UpdateCShop(Trooper edit, ref Trooper primary, ref Trooper submitter,
[NotNullWhen(true)] out CShopChange?update)
{
if (primary.CShops != edit.CShops)
{
var changes = primary.CShops ^ edit.CShops;
var additions = edit.CShops & changes;
var removals = primary.CShops & changes;
update = new CShopChange()
{
Added = additions,
Removed = removals,
OldCShops = primary.CShops,
SubmittedByRosterClerk = true,
ChangedOn = DateTime.UtcNow
};
primary.CShops = edit.CShops;
primary.CShopChanges.Add(update);
submitter.SubmittedCShopChanges.Add(update);
return(true);
}
update = null;
return(false);
}
public async Task <ResultBase> DeleteAccountAsync(Trooper trooper, string password)
{
var actual = await _userManager.FindByIdAsync(trooper.Id.ToString());
var validPassword = await _userManager.CheckPasswordAsync(actual, password);
if (!validPassword)
{
return(new(false, new() { "The proivded password is invalid for your account." }));
}
var identResult = await _userManager.DeleteAsync(actual);
if (!identResult.Succeeded)
{
List <string> errors = new();
foreach (var err in identResult.Errors)
{
errors.Add($"[{err.Code}] {err.Description}");
}
return(new(false, errors));
}
return(new(true, null));
}
public async Task <ResultBase> UpdateNickNameAsync(Trooper trooper, int approver)
{
var actual = await _dbContext.FindAsync <Trooper>(trooper.Id);
if (actual is null)
{
return(new(false, new() { "The Trooper for that ID was not found." }));
}
var old = actual.NickName;
actual.NickName = trooper.NickName;
var update = new NickNameChange()
{
ApprovedById = approver,
ChangedOn = DateTime.UtcNow,
OldNickname = old,
NewNickname = actual.NickName,
};
actual.NickNameChanges.Add(update);
try
{
_dbContext.Update(actual);
await _dbContext.SaveChangesAsync();
return(new(true, null));
}
catch (Exception ex)
{
return(new(false, new() { ex.Message }));
}
}
int GetShoterPath(Trooper self, Point to, int[,] map, bool beginFree, bool endFree)
{
int distance = 0;
GoToUnit(new Point(self), to, map, beginFree, endFree, ref distance);
return(distance);
}
double GetTeamBonusProfit(Bonus bonus, ref Trooper trooper, bool allowTakeBonus)
{
// нужен минимальный вес
double bestWeight = Inf;
foreach (var tr in Team)
{
double weight = GetShoterPath(tr, bonus, notFilledMap, beginFree: true, endFree: false) * (1 + 0.5 * GetQueuePlace(tr, self.Id == tr.Id && self.ActionPoints >= self.InitialActionPoints));
if (tr.Id != commander.Id || !allowTakeBonus)
{
var L = GetShoterPath(tr, bonus, map, beginFree: true, endFree: false);
weight = L <= 2 &&
(self.Id != tr.Id || self.ActionPoints / GetMoveCost() >= 2 * L)
? weight
: Inf;
}
if (!IsHaveBonus(tr, bonus) && weight < bestWeight)
{
bestWeight = weight;
trooper = tr;
}
}
if (bestWeight >= Inf)
{
return(-1);
}
return(1.0 / bestWeight);
}
bool IfNeedHelp(Trooper self = null)
{
if (self == null)
{
self = this.self;
}
return(self.Hitpoints / (double)self.MaximalHitpoints < 0.8);
}
public async Task LoadFlagsAsync(Trooper t)
{
var scope = _services.CreateScope();
var db = scope.ServiceProvider.GetRequiredService <ApplicationDbContext>();
db.Attach(t);
await db.Entry(t).Collection(i => i.Flags).LoadAsync();
}
// Update is called once per frame
void Update()
{
if (Input.GetMouseButtonDown(0))
{
RaycastHit2D hit = Physics2D.Raycast(Camera.main.ScreenToWorldPoint(Input.mousePosition), Vector2.zero);
if (hit && Input.GetKey(KeyCode.LeftControl))
{
if (hit.collider.gameObject.tag == "peons")
{
foreach (GameObject item in troopers)
{
if (item.name == hit.collider.gameObject.name)
{
troopers.Remove(item);
return;
}
}
troopers.Add(hit.collider.gameObject);
}
}
else if (hit && !Input.GetKey(KeyCode.LeftControl))
{
Debug.Log("true");
if (hit.collider.gameObject.tag == "peons")
{
troopers.Clear();
troopers.Add(hit.collider.gameObject);
}
else if (hit.collider.gameObject.tag == "enemy" || hit.collider.gameObject.tag == "Orc_Village")
{
foreach (GameObject item in troopers)
{
item.GetComponent <Trooper>().target = hit.collider.gameObject;
item.GetComponent <Trooper>().destination = hit.collider.gameObject.transform.position;
item.GetComponent <Trooper>().destination.z = 1;
}
}
}
else
{
foreach (GameObject item in troopers)
{
Trooper troop = item.GetComponent <Trooper>();
troop.destination = Camera.main.ScreenToWorldPoint(Input.mousePosition);
troop.destination.z = item.transform.position.z;
item.GetComponent <AudioSource>().Play(0);
troop.target = null;
troop.attacks = false;
// Debug.Log("dest =" + dest);
}
}
}
else if (Input.GetMouseButtonDown(1))
{
troopers.Clear();
}
}
int getInitialActionPoints(Trooper tr)
{
var points = tr.InitialActionPoints;
if (CommanderId != -1 && tr.GetDistanceTo(state.Position[CommanderId].X, state.Position[CommanderId].Y) <= game.CommanderAuraRange)
{
points += game.CommanderAuraBonusActionPoints;
}
return(points);
}
public async Task UpdateAsync(Trooper updateData, bool clerk = false)
{
var scope = _services.CreateScope();
var manager = scope.ServiceProvider.GetRequiredService <UserManager <Trooper> >();
var user = await manager.FindByIdAsync(updateData.Id.ToString());
if (user is not null)
{
user.Slot = updateData.Slot;
user.Team = updateData.Team;
user.Role = updateData.Role;
user.Flight = updateData.Flight;
user.Qualifications = updateData.Qualifications;
await manager.UpdateAsync(user);
var claims = await manager.GetClaimsAsync(user);
var slotClaim = claims.FirstOrDefault(x => x.Type == "Slotted");
if (user.Slot >= Slot.InactiveReserve)
{
if (slotClaim is not null)
{
await manager.RemoveClaimAsync(user, slotClaim);
}
}
else if (user.Slot <= Slot.InactiveReserve)
{
if (slotClaim is null)
{
await manager.AddClaimAsync(user, new("Slotted", DateTime.Now.ToShortDateString()));
}
else
{
await manager.ReplaceClaimAsync(user, slotClaim, new("Slotted", DateTime.Now.ToShortDateString()));
}
}
var clerkClaim = claims.FirstOrDefault(x => x.Type == "Clerk");
if (clerk)
{
if (clerkClaim is null)
{
await manager.AddClaimAsync(user, new("Clerk", "Roster"));
}
}
else
{
if (clerkClaim is not null)
{
await manager.RemoveClaimAsync(user, clerkClaim);
}
}
}
}
public int GetShootingPriority(Trooper opponent)
{
for (var i = 0; i < ShootingPriority.Length; i++)
{
if (opponent.Type == ShootingPriority[i])
{
return(i);
}
}
throw new InvalidDataException();
}
/// <summary>Sends player input to the server.</summary>
public static void TrooperTransformUpdate(Trooper trooper)
{
using (Packet packet = new Packet((int)ClientPackets.trooperTransformUpdate))
{
packet.Write(trooper.transform.position);
packet.Write(trooper.transform.rotation);
packet.Write(trooper.velocity);
packet.Write(trooper.grounded);
SendUdpData(packet);
}
}
public static void TrooperGrappleUpdate(Trooper trooper)
{
using (Packet packet = new Packet((int)ClientPackets.trooperGrappleUpdate))
{
packet.Write(trooper.isGrappling);
packet.Write(trooper.grappleObjectId);
packet.Write(trooper.grapplePoint);
packet.Write(trooper.maxDistanceFromGrapple);
SendUdpData(packet);
}
}
private async Task LoadAsync(Trooper user)
{
var email = await _userManager.GetEmailAsync(user);
Email = email;
Input = new InputModel
{
NewEmail = email,
};
IsEmailConfirmed = await _userManager.IsEmailConfirmedAsync(user);
}
int GetQueuePlace(Trooper trooper, bool MayFirst)
{
var current = queue.IndexOf(self.Id);
for (var idx = current + (MayFirst ? 0 : 1); idx < queue.Count; idx++)
{
if ((long)queue[idx] == trooper.Id)
{
return(idx - current + 1);
}
}
return(1);
}
private async Task LoadAsync(Trooper user)
{
var userName = await _userManager.GetUserNameAsync(user);
if (Input is null)
{
Input = new();
}
Input.Username = userName;
Input.NickName = user.NickName;
Input.TrooperNumber = user.Id;
}
public static void TrooperTransformUpdate(Trooper trooper)
{
using (Packet packet = new Packet((int)ServerPackets.trooperTransformUpdate))
{
packet.Write(trooper.player.client.id);
packet.Write(trooper.transform.position);
packet.Write(trooper.transform.rotation);
packet.Write(trooper.velocity);
packet.Write(trooper.grounded);
SendUdpDataToAll(trooper.player.client.id, packet);
}
}
public static void TrooperGrappleUpdate(Trooper trooper)
{
using (Packet packet = new Packet((int)ServerPackets.trooperGrappleUpdate))
{
packet.Write(trooper.player.client.id);
packet.Write(trooper.isGrappling);
packet.Write(trooper.grappleObjectId);
packet.Write(trooper.grapplePoint);
packet.Write(trooper.distanceFromGrapple);
SendUdpDataToAll(trooper.player.client.id, packet);
}
}
double GetHelperQuality(Trooper tr)
{
double quality = 1.0 / GetShoterPath(self, tr, notFilledMap, beginFree: true, endFree: true);
if (tr.Type == TrooperType.FieldMedic)
{
return(quality * 2);
}
if (!tr.IsHoldingMedikit)
{
return(-Inf);
}
return(quality);
}
void Awake()
{
if (instance == null)
{
instance = this;
}
else if (instance != this)
{
Debug.Log("Instance already exists, destroying object!");
Destroy(this);
}
trooper = GetComponent <Trooper>();
rigidbody = GetComponent <Rigidbody>();
collider = GetComponent <CapsuleCollider>();
}
bool IsHaveBonus(Trooper self, BonusType bonus)
{
if (bonus == BonusType.Medikit)
{
return(self.IsHoldingMedikit);
}
if (bonus == BonusType.Grenade)
{
return(self.IsHoldingGrenade);
}
if (bonus == BonusType.FieldRation)
{
return(self.IsHoldingFieldRation);
}
throw new InvalidDataException();
}
public async Task SaveNewFlag(ClaimsPrincipal claim, Trooper trooper, TrooperFlag flag)
{
var user = await _userManager.GetUserAsync(claim);
if (_dbContext.Entry(trooper).State == EntityState.Detached)
{
_dbContext.Attach(trooper);
}
flag.AuthorId = user.Id;
flag.CreatedOn = DateTime.UtcNow;
trooper.Flags.Add(flag);
await _dbContext.SaveChangesAsync();
}
public async Task <IActionResult> OnPostAsync(string?returnUrl = null)
{
returnUrl ??= Url.Content("~/");
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
var user = new Trooper {
UserName = Input.Email, Email = Input.Email
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = user.Id, code = code, returnUrl = returnUrl },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("RegisterConfirmation", new { email = Input.Email, returnUrl = returnUrl }));
}
else
{
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
Point GoToEncircling(Trooper center, Point goal)
{
var bestPoint = new Point(0, 0, Inf);
double optDanger = self.Type == TrooperType.FieldMedic || self.Type == TrooperType.Sniper ? Inf : -Inf;
for (var i = 0; i < Width; i++)
{
for (var j = 0; j < Height; j++)
{
if (map[i, j] == 0 || i == self.X && j == self.Y)
{
if (self.GetDistanceTo(i, j) > 10) // немного ускорит
{
continue;
}
// Нужно чтобы хватило ходов
int steps = GetShoterPath(self, new Point(i, j), map, beginFree: true, endFree: true);
if (self.ActionPoints / GetMoveCost() >= steps)
{
// и чтобы не закрывали кратчайший путь:
int before = goal == null ? Inf : GetShoterPath(center, goal, map, beginFree: true, endFree: false);
map[self.X, self.Y] = 0;
map[i, j] = 1;
int after = goal == null ? Inf : GetShoterPath(center, goal, map, beginFree: true, endFree: false);
map[i, j] = 0;
map[self.X, self.Y] = 1;
if ((goal == null || after < Inf) && after <= before)
{
double sum = GetShoterPath(center, new Point(i, j), notFilledMap, beginFree: true, endFree: true);
double dang = danger[i, j] + (goal == null ? 0 : goal.GetDistanceTo(i, j) * 0.01);
if (sum < bestPoint.profit ||
EqualF(sum, bestPoint.profit) &&
(self.Type == TrooperType.FieldMedic || self.Type == TrooperType.Sniper ? (dang < optDanger) : (dang > optDanger))
)
{
bestPoint = new Point(i, j, sum);
optDanger = dang;
}
}
}
}
}
}
return(bestPoint.profit >= Inf ? null : bestPoint);
}
private async Task <Trooper> EnsureUser(Trooper trooper, string password)
{
var user = await _manager.FindByIdAsync(trooper.Id.ToString());
if (user is null)
{
user = trooper;
await _manager.CreateAsync(user, password);
}
if (user is null)
{
throw new Exception("The password is probaly not strong enough!");
}
return(user);
}
public PlayerContext(Trooper trooper, World world)
{
this.trooper = trooper;
this.world = world;
}