public static float EstimateScore(PlayerId pId, GameState state, Input move, Vector2 target)
{
// prof.Start ();
float similarity;
if (move == Input.Noop) {
similarity = 0f;
} else {
var player = state.Player (pId);
Vector2 gravOffset = state.IsGrounded (player) ? Vector2.Zero : gravVector;
Vector2 targetVector = Vector2.Subtract (target, player.Target + gravOffset);
Vector2.Normalize (targetVector);
// Debug.WriteLine("targetVector: {0}", gravOffset);
similarity = (float)Util.CosineSimilarity(targetVector, moveVectors [move]);
}
// prof.End ();
return -similarity;
}
public int GetTeamScore(PlayerId playerId)
{
var teamNumber = Globals.Instance.ManageTeam.GetTeamNumber(playerId);
ScoreType scoreType = Globals.Instance.ManageTeam[teamNumber].Objective.Value;
return scores[teamNumber][scoreType];
}
public void OnSetStart(PlayerId startingPlayer)
{
for (int i = 0; i < _scores.Length; ++i)
_scores[i] = 0;
_servingPlayer = startingPlayer;
}
public string GetPlayerAxisName(string axisName, PlayerId playerId)
{
return axisName + AllPlayers
.Where(p => p.PlayerNumber == playerId)
.Select(p => p.ControllerAffix)
.First();
}
private void CheckDiagonal(BoardMeta boardMeta, int row, int column, Direction direction, PlayerId playerId)
{
int nextRow = DirectionUtil.getNextRow (row, direction);
int nextColumn = DirectionUtil.getNextColumn (column, direction);
TileMeta tileMeta = boardMeta.getTile (nextRow, nextColumn);
if (tileMeta != null) {
PieceMeta pieceMeta = tileMeta.pieceMeta;
if (pieceMeta != null) {
if(pieceMeta.playerId == playerId){
// protect
tileMeta.protectList.Add(new MoveMeta(direction, 1));
}
else{
// active threat and move
tileMeta.moveList.Add(new MoveMeta(direction, 1));
tileMeta.activeThreatList.Add(new MoveMeta(direction, 1));
}
} else {
// passive threat
tileMeta.passiveThreatList.Add(new MoveMeta(direction, 1));
}
}
}
public Player(PlayerId id, float maxHealth, int initialCurrency)
{
_id = id;
_maxHealth = _health = maxHealth;
_currency = initialCurrency;
_path = PlayerServices.GetPlayerPath(_id);
}
void GameEnded(PlayerId winner)
{
_overlay.enabled = true;
if (PlayerManager.Instance.ActivePlayer.ID == playerID) {
_endText.text = (playerID == winner) ? "You WON!" : "You LOSE!";
_endText.gameObject.SetActive(true);
}
}
/// <summary>
/// Initializes a player for the game start.
/// </summary>
/// <param name="id">Player ID.</param>
/// <param name="fencesAvailable">How many fences available for the player.</param>
/// <param name="startPosition">Player start position.</param>
/// <param name="boardSize">Board size.</param>
public Player(PlayerId id, int fencesAvailable, Square startPosition, IEnumerable<Square> goalPositions)
{
_playerId = id;
_fencesAvailable = fencesAvailable;
_position = startPosition;
_goalPositions = goalPositions.ToArray();
}
void PlayerIsActive(PlayerId playerID)
{
if (DevUtils.DevMode) {
_overlay.enabled = false;
return;
}
_overlay.enabled = (this.playerID != playerID);
}
private void iterate(PlayerId playerId, BoardMeta boardMeta, int row, int column, Direction direction, int distance)
{
int nextRow = DirectionUtil.getNextRow (row, direction);
int nextColumn = DirectionUtil.getNextColumn (column, direction);
if (base.fillTile (playerId, boardMeta, row, column, direction, distance)) {
iterate(playerId, boardMeta, nextRow, nextColumn, direction, ++distance);
}
}
public void OnRoundWinner(PlayerId prevWinner)
{
((Ball)_ballObj.GetComponent<Ball>()).DestroySlowly(_game);
_roundScore1.text = _game.SetRules.GetFormattedScore(PlayerId.Player1);
_roundScore2.text = _game.SetRules.GetFormattedScore(PlayerId.Player2);
_newRound = true;
_newRoundTimer = NewRoundDelay;
}
private bool usedPower = true; // If the player has used his powerUp
#endregion Fields
#region Constructors
public Player(Vector2 position, int frames, string name, float speed, PlayerId playerId, int team)
: base(position, frames)
{
//F*g
this.name = name;
this.life = 20;
this.playerId = playerId;
this.team = team;
this.position = position;
this.speed = 1;
}
public static string getResourceColor(PlayerId playerId)
{
switch (playerId) {
case PlayerId.White:
return "White";
case PlayerId.Black:
return "Black";
default:
return "";
}
}
public override int GetHashCode()
{
int hash = 1;
if (PlayerId != 0UL)
{
hash ^= PlayerId.GetHashCode();
}
if (Result != 0)
{
hash ^= Result.GetHashCode();
}
return(hash);
}
public int PlayerIdToInt(PlayerId playerId)
{
int idx = (int)playerId;
if (idx < 0)
{
idx = 0;
}
if (idx > 1)
{
idx = 1;
}
return(idx);
}
/// <summary>
///
/// </summary>
/// <param name="newPosition"></param>
public void MoveCurrentPlayer(Square newPosition)
{
if (!GameFinished)
{
Link link = _board.GetLinksFromSquare(CurrentPlayer.Position).Single(l => l.Squares.Contains(newPosition));
_board.MovePlayer(CurrentPlayer, link);
GameFinished = CheckWinningConditions();
if (!GameFinished)
{
_currentPlayer = NextPlayer();
}
}
}
public override int GetHashCode()
{
int hash = 1;
if (AccountId != 0UL)
{
hash ^= AccountId.GetHashCode();
}
if (PlayerId != 0UL)
{
hash ^= PlayerId.GetHashCode();
}
if (Reason != 0)
{
hash ^= Reason.GetHashCode();
}
if (Diamonds != 0)
{
hash ^= Diamonds.GetHashCode();
}
if (Level != 0)
{
hash ^= Level.GetHashCode();
}
if (Exp != 0)
{
hash ^= Exp.GetHashCode();
}
if (Hp != 0)
{
hash ^= Hp.GetHashCode();
}
if (Mp != 0)
{
hash ^= Mp.GetHashCode();
}
if (Food != 0)
{
hash ^= Food.GetHashCode();
}
if (Gold != 0)
{
hash ^= Gold.GetHashCode();
}
hash ^= cards_.GetHashCode();
hash ^= items_.GetHashCode();
hash ^= buffs_.GetHashCode();
hash ^= equips_.GetHashCode();
return(hash);
}
public void PickCard(PlayerId playerId, PositionId positionId)
{
if (!Game.IsGameStarted)
{
return;
}
if (!Game.IsTurnInProgress)
{
return;
}
var pool = Game.Pool;
if (pool.IsPositionLocked(positionId))
{
return;
}
if (!pool.HasDataAt(positionId))
{
return;
}
var isMyTurn = Game.TurnLogic.IsMyTurn(playerId);
if (!isMyTurn)
{
return;
}
var hand = GetPlayerHand(playerId);
var handSize = hand.Cards.Count;
if (handSize >= hand.MaxHandSize)
{
return;
}
var inventory = GetInventory(playerId);
var actionPoints = Parameters.Amounts.ActionPointsConsume;
var hasEnoughActionPoints = inventory.GetAmount(Inventory.ActionPointItem) >= actionPoints;
if (!hasEnoughActionPoints)
{
return;
}
var poolCard = Game.Pool.GetAndRemoveCardAt(positionId);
var data = poolCard.Data;
var cardHand = new CardHand(data);
inventory.RemoveItem(Inventory.ActionPointItem, actionPoints);
hand.Add(cardHand);
OnPickCard(playerId, cardHand, positionId);
}
/// <summary>
/// Returns Bus prefab
/// </summary>
private GameObject GetBusPrefab(PlayerId playerId)
{
for (int i = 0; i < vehiclePrefabs.busPrefabs.Count; i++)
{
if (vehiclePrefabs.busPrefabs[i].playerId == playerId)
{
return(vehiclePrefabs.busPrefabs[i].prefab);
}
}
Debug.LogError("playerId Prefab Does Not Exist");
return(null);
}
public override int GetHashCode()
{
int hash = 1;
if (PlayerId != 0UL)
{
hash ^= PlayerId.GetHashCode();
}
if (mapPlayerData_ != null)
{
hash ^= MapPlayerData.GetHashCode();
}
return(hash);
}
public async Task <IImmutableList <Move> > GetMovesForPlayerAsync(
GameId gameId,
PlayerId player,
CancellationToken cancellationToken)
{
var state = await _provider.GetGameByIdAsync(gameId, cancellationToken);
if (state == null)
{
throw new GameNotFoundException();
}
return(Moves.GenerateMoves(state, player));
}
public override int GetHashCode()
{
int hash = 1;
if (PlayerId != 0UL)
{
hash ^= PlayerId.GetHashCode();
}
if (deck_ != null)
{
hash ^= Deck.GetHashCode();
}
return(hash);
}
public override int GetHashCode()
{
int hash = 1;
if (HasPlayerId)
{
hash ^= PlayerId.GetHashCode();
}
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
private void DeductResourceUnchecked(PlayerId playerId, ResourceDefId resourceDefId, decimal value)
{
if (value < 0)
{
throw new InvalidGameDefException("Resource cost cannot be negative.");
}
if (!Res(playerId).ContainsKey(resourceDefId))
{
throw new CannotAffordException(Cost.FromSingle(resourceDefId, value));
}
// deduct cost
Res(playerId)[resourceDefId] -= value;
}
/// <summary>
/// Queues an action targeted at a WorldEntity by moving along the given move path.
/// <para>Will attempt to perform the action at the end of the move path.</para>
/// </summary>
/// <param name="entityId">The id of the WorldEntity to perform the action on.</param>
/// <param name="ownerId">The id of the owner of the WorldEntity to perform the action on.</param>
/// <param name="action">The name of the action to perform. Import PlayerActionConstants for the complete
/// list of actions.</param>
/// <param name="movePath">The path of Coordinates to follow to the target destination.</param>
public void QueueAction(int entityId, string ownerId, string action, IEnumerable <Coordinate> movePath)
{
SetMovePath(movePath);
// Action is targeting self, is invalid
if (entityId == Entity.Id || PlayerId.ToString() == ownerId)
{
return;
}
_targetEntityId = entityId;
_targetOwnerId = ownerId;
_actionName = action;
}
public void DrawCard(PlayerId playerId)
{
if (!Game.IsGameStarted)
{
return;
}
var data = Game.Library.GetRandomData();
var card = new CardHand(data);
var playerHand = GetPlayerHand(playerId);
playerHand.Add(card);
OnDrawCard(playerId, card);
}
public async Task LoadAndSearch()
{
var playerRepository = new PlayerRepository(MongoClient);
var player = PlayerOverview.Create(new List <PlayerId> {
PlayerId.Create("peter#123")
}, GateWay.Europe, GameMode.GM_1v1, 0);
await playerRepository.UpsertPlayerOverview(player);
var playerLoaded = (await playerRepository.LoadOverviewLike("PeT", GateWay.Europe)).Single();
Assert.AreEqual(player.Id, playerLoaded.Id);
Assert.AreEqual(GateWay.Europe, playerLoaded.GateWay);
}
public static void RequestReportPlayer(
string gameId,
PlayerId playerId,
bool isRequestedFromMission)
{
MultiplayerReportPlayerManager.IncrementReportOfPlayer(playerId);
Action <string, PlayerId, bool> reportHandlers = MultiplayerReportPlayerManager.ReportHandlers;
if (reportHandlers == null)
{
return;
}
reportHandlers(gameId, playerId, isRequestedFromMission);
}
private int TryRemoveUnitCount(PlayerId playerId, UnitId unitId, int count)
{
var unit = Unit(playerId, unitId);
if (count >= unit.Count)
{
// remove full unit
RemoveUnit(playerId, unitId);
return(unit.Count);
}
// only reduce count of existing unit
unit.Count -= count;
return(count);
}
// GET: Planet
public ActionResult LoadGame(int?playerId)
{
//if (playerId == null)
//{
// throw new ArgumentException("ShowGame: PlayerId cannot be null");
//}
PlayerId pId = new PlayerId()
{
Id = playerId.ToString()
};
return(View(pId));
}
public void DeductCost(PlayerId playerId, Cost cost)
{
// TODO: synchronize
if (!resourceRepository.CanAfford(playerId, cost))
{
throw new CannotAffordException(cost);
}
var playerRes = Res(playerId);
foreach (var res in cost.Resources)
{
DeductResourceUnchecked(playerId, res.Key, res.Value);
}
}
public void AdicionaPlacar(PlayerId playerId)
{
if (playerId == PlayerId.PLAYER_1)
{
placar1 += score;
}
else if (playerId == PlayerId.PLAYER_2)
{
placar2 += score;
}
AtualizarPlacar();
}
public override IEnumerable <AttachProgramOptions> Create(AttachProgramOptionsProviderContext context)
{
var groupAddr = IPAddress.Parse("225.0.0.222");
var foundIds = new HashSet <PlayerId>();
using (var receiver = new UnityDataReceiver(maxWaitTime, context.CancellationToken)) {
foreach (var addr in GetAddresses(context.CancellationToken))
{
context.CancellationToken.ThrowIfCancellationRequested();
foreach (var port in multicastPorts)
{
receiver.Add(groupAddr, port, addr);
}
}
receiver.Start();
for (;;)
{
context.CancellationToken.ThrowIfCancellationRequested();
var data = receiver.GetNextData();
if (data is null)
{
break;
}
var s = Encoding.UTF8.GetString(data);
if (!TryParseUnityPlayerData(s, out var ipAddress, out var port, out var id))
{
continue;
}
var playerId = new PlayerId(ipAddress, port);
if (!foundIds.Add(playerId))
{
continue;
}
var pid = NetUtils.GetProcessIdOfListenerLocalAddress(IPAddress.Any.MapToIPv4().GetAddressBytes(), port);
if (pid is null)
{
foundIds.Remove(playerId);
continue;
}
if (!ProcessUtils.IsValidProcess(context, pid.Value, null))
{
continue;
}
ipAddress = "127.0.0.1";
yield return(new UnityAttachProgramOptionsImpl(pid.Value, ipAddress, port, "Unity (" + id + ")"));
}
}
}
public async Task ReturnRanks_WhenPlayersHavePersonalSettingsConfigured_MustHaveCorrectPersonalSettings()
{
// Arrange
var rankRepository = new RankRepository(MongoClient);
var playerRepository = new PlayerRepository(MongoClient);
var personalSettingsRepository = new PersonalSettingsRepository(MongoClient);
var clanRepository = new ClanRepository(MongoClient);
var queryHandler = new RankQueryHandler(rankRepository, playerRepository, clanRepository);
var ranks = new List <Rank> {
new Rank(new List <string> {
"peter#123"
}, 1, 12, 1456, GateWay.America, GameMode.GM_1v1, 1)
};
await rankRepository.InsertRanks(ranks);
var player = PlayerOverview.Create(new List <PlayerId> {
PlayerId.Create("peter#123")
}, GateWay.America, GameMode.GM_1v1, 1);
player.RecordWin(true, 1234);
await playerRepository.UpsertPlayerOverview(player);
var playerStats = new PlayerOverallStats()
{
BattleTag = "peter#123",
};
await playerRepository.UpsertPlayer(playerStats);
var settings = new PersonalSetting("peter#123")
{
ProfilePicture = new ProfilePicture(Race.HU, 5),
Country = "BG"
};
await personalSettingsRepository.Save(settings);
// Act
var playerLoaded = await queryHandler.LoadPlayersOfLeague(1, 1, GateWay.America, GameMode.GM_1v1);
// Assert
Assert.AreEqual(1, playerLoaded.Count);
var playerRank = playerLoaded[0];
Assert.AreEqual("1_peter#123@10_GM_1v1", playerRank.Players.First().Id);
Assert.AreEqual(playerRank.PlayersInfo[0].SelectedRace, Race.HU);
Assert.AreEqual(playerRank.PlayersInfo[0].PictureId, 5);
Assert.AreEqual(playerRank.PlayersInfo[0].Country, "BG");
}
public async Task ShouldBeHttpStatusCodeOk()
{
// Arrange
var userId = new UserId();
var playerId = new PlayerId();
var authentication = new LeagueOfLegendsGameAuthentication(
playerId,
new LeagueOfLegendsGameAuthenticationFactor(
1,
string.Empty,
2,
string.Empty));
var summoner = new Summoner
{
AccountId = playerId,
ProfileIconId = authentication.Factor.CurrentSummonerProfileIconId
};
var request = new LeagueOfLegendsRequest("SwagYoloMlg");
var factory = TestHost.WithClaimsFromDefaultAuthentication(new Claim(JwtClaimTypes.Subject, userId.ToString()))
.WithWebHostBuilder(
builder => builder.ConfigureTestContainer <ContainerBuilder>(
container =>
{
var mockLeagueOfLegendsService = new Mock <ILeagueOfLegendsService>();
mockLeagueOfLegendsService
.Setup(leagueOfLegendsService => leagueOfLegendsService.Summoner.GetSummonerByNameAsync(It.IsAny <Region>(), request.SummonerName))
.ReturnsAsync(summoner)
.Verifiable();
container.RegisterInstance(mockLeagueOfLegendsService.Object).As <ILeagueOfLegendsService>().SingleInstance();
}));
_httpClient = factory.CreateClient();
factory.Server.CleanupDbContext();
// Act
using var response = await this.ExecuteAsync(Game.LeagueOfLegends, request);
// Assert
response.EnsureSuccessStatusCode();
response.StatusCode.Should().Be(HttpStatusCode.OK);
}
public byte _alignment2; // ISSUE 22 change to private ?
// Offset16 ... total size 16byte/128bit
public Header()
{
Ver = Definitions.FrameVersion;
RelayCode = (byte)0;
ContentCode = (byte)0;
Mask = (byte)0;
DestCode = (byte)0;
SrcPid = (PlayerId)0;
_alignment0 = 0;
SrcOid = (PlayerId)0;
DestLen = (UInt16)0;
ContentLen = (UInt16)0;
_alignment1 = 0;
_alignment2 = 0;
}
void Awake()
{
playerID = GetComponent <PlayerId>();
upgrades = GetComponent <Upgrades>();
healthScript = GetComponent <NPCHealth>();
rg = GetComponent <Rigidbody2D>();
if (jetpackSound != null)
{
jetSource = jetpackSound.GetComponent <AudioSource>();
soundBase = jetSource.volume;
}
//drillMask = LayerMask.NameToLayer("Diggable");
oldTimer = unDeployTimer;
engineSound = GetComponent <AudioSource>();
}
public TeamRole DetermineTeamRole(INetworkConnection nwConn)
{
PlayerId playerId = DetermineClientPlayerId(nwConn);
for (int i = 0; i < 4; i++)
{
if (TrueLobbyState.PlayerIds[i] == playerId)
{
return((TeamRole)i);
}
}
Debug.LogError("Lobby.DetermineTeamRole() failed to find team role of network connection.");
return((TeamRole)0);
}
public override int GetHashCode()
{
int hash = 1;
if (TurnId != 0)
{
hash ^= TurnId.GetHashCode();
}
if (PlayerId != 0L)
{
hash ^= PlayerId.GetHashCode();
}
hash ^= commands_.GetHashCode();
return(hash);
}
private void iterate(bool iterateRow, PlayerId playerId, BoardMeta boardMeta, int row, int column, Direction direction, int distance)
{
int nextRow = row;
int nextColumn = column;
if (iterateRow) {
nextColumn = DirectionUtil.getNextColumn (column, direction);
} else {
nextRow = DirectionUtil.getNextRow (row, direction);
}
if (base.fillTile (playerId, boardMeta, nextRow, nextColumn, direction, distance)) {
iterate(iterateRow, playerId, boardMeta, nextRow, nextColumn, direction, ++distance);
}
}
public SoldierController EncounterEnemy(PlayerId playerId, Vector2 pos)
{
// if pos not valid or has no soldier
if (!IsValidPos(pos) || IsTileFree(pos))
{
return(null);
}
Tile tile = GetTile(pos);
if (tile.OccupiedBy.Team != playerId)
{
return(tile.OccupiedBy);
}
return(null);
}
public bool PrerequisitesMet(PlayerId playerId, AssetDef assetDef)
{
if (assetDef.PlayerTypeRestriction != playerRepository.GetPlayerType(playerId))
{
return(false);
}
foreach (var prereq in assetDef.Prerequisites)
{
if (!HasAsset(playerId, prereq))
{
return(false);
}
}
return(true);
}
public decimal AddResources(PlayerId playerId, ResourceDefId resourceDefId, decimal value)
{
// TODO: synchronize
var playerRes = Res(playerId);
if (!playerRes.ContainsKey(resourceDefId))
{
playerRes.Add(resourceDefId, 0);
}
else
{
playerRes[resourceDefId] += value;
}
return(playerRes[resourceDefId]);
}
public override bool Equals(object?obj)
{
if (!(obj is WinPointEvent target))
{
return(false);
}
if (ReferenceEquals(this, obj))
{
return(true);
}
return(Equals(this, target) && TeamId.Equals(target.TeamId) && PlayerId.Equals(target.PlayerId) &&
NewScore.Equals(target.NewScore) && NewStatus.Equals(target.NewStatus));
}
public InitializeLobbyPeer(
NetworkCommunicator peer,
PlayerId providedId,
string bannerCode,
BodyProperties bodyProperties,
int chosenBadgeIndex,
int forcedAvatarIndex)
{
this.Peer = peer;
this.ProvidedId = providedId;
this.BannerCode = bannerCode != null ? bannerCode : string.Empty;
this.BodyProperties = bodyProperties;
this.ChosenBadgeIndex = chosenBadgeIndex;
this.ForcedAvatarIndex = forcedAvatarIndex;
}
private void CheckForward(BoardMeta boardMeta, int row, int column, Direction direction, PlayerId playerId)
{
int forward = (playerId == PlayerId.White)? 1 : -1;
int pawnRow = (playerId == PlayerId.White)? Rows.WHITE_PAWN : Rows.BLACK_PAWN;
TileMeta tileAhead = boardMeta.getTile(row + forward, column);
if(tileAhead.pieceMeta == null){
tileAhead.moveList.Add(new MoveMeta(direction, 1));
if(row == pawnRow){
tileAhead = boardMeta.getTile(row + 2*forward, column);
if(tileAhead.pieceMeta == null){
tileAhead.moveList.Add(new MoveMeta(direction, 2));
}
}
}
}
public void OnSetWinner(PlayerId player)
{
switch (player)
{
case PlayerId.Player1:
case PlayerId.Player2:
_scores[(int)player] += 1;
break;
default:
_scores[(int)PlayerId.Neutral] += 1;
break;
}
for (int i = 1; i <= 2; ++i)
{
if (_scores[i] >= _limit)
OnWinner((PlayerId)i);
}
}
public int GetTeamNumber(PlayerId playerId)
{
AllPlayers = Teams.SelectMany(t => t.Players).ToList();
var matchingPlayerId = AllPlayers.Where(p => p.PlayerNumber == playerId);
if (matchingPlayerId.Count() == 0)
// throw new Exception("player " + playerId + " was not found in the list of " + AllPlayers.Count() + " players.");
return -1; // -1 flag used by PlayerMgr to activate player gameobjects
var targetPlayer = matchingPlayerId.First();
//get teams player is on
var teams = Teams.Where(t => t.Players.Contains(targetPlayer));
if (teams.Count() > 1)
throw new NotSupportedException("Player can not be on more than one team.");
return teams.First().TeamNumber;
// Note: commented out below is if TeamNumber is stored in TeamPlayer
//allPlayers = Teams.SelectMany(t => t.Players).ToList();
//return allPlayers.Where(p => p.PlayerNumber == playerId)
// .First().TeamNumber;
}
public void OnRoundWinner(PlayerId player)
{
_servingPlayer = player;// (PlayerId)(3 - (int)_servingPlayer);
switch (player)
{
case PlayerId.Player1:
case PlayerId.Player2:
_scores[(int)player] += 1;
break;
default:
_scores[(int)PlayerId.Neutral] += 1;
break;
}
for (int i = 1; i <= 2; ++i)
{
if (_scores[i] >= _limit)
OnWinner((PlayerId)i);
}
}
public abstract List<Input> nextInputList(GameState state, PlayerId pId, Heuristic heuristic);
public AI(GameState state, PlayerId pId, Heuristic heuristic)
{
this.pId = pId;
this.forwardModel = new ForwardModel(state);
this.heuristic = heuristic;
}
public override List<Input> nextInputList(GameState state, PlayerId pId, Heuristic heuristic)
{
return new List<Input>() { new Input () };
}
public NullAI(GameState state, PlayerId pId)
: base(state, pId, new LinearHeuristic(pId))
{
}
public static TurretSpot IntToTurretSpot(PlayerId id, int index)
{
TurretHelper[] turretHelpers = FindObjectsOfType<TurretHelper>();
return turretHelpers.FirstOrDefault(obj => obj.player == id).IntToTurretSpot(index);
}
public static int TurretSpotToInt(PlayerId id, TurretSpot spot)
{
TurretHelper[] turretHelpers = FindObjectsOfType<TurretHelper>();
return turretHelpers.FirstOrDefault(obj => obj.player == id).TurretSpotToInt(spot);
}
private float PlatformPathDistance(GameState state, PlayerId pId, GameObject platform)
{
return PlatformPathDistance (pas.PlatformPath (state.Player (pId), state.Goal), platform);
}
public int GetTotalTeamScore(PlayerId playerId)
{
var teamNumber = Globals.Instance.ManageTeam.GetTeamNumber(playerId);
return scores[teamNumber].Sum(x => x.Value);
}
public Heuristic(PlayerId pId)
{
this.pId = pId;
}
/// <summary>
/// Update the player's score and calculates the new team score.
/// </summary>
/// <param name="playerId"></param>
/// <param name="scoreType"></param>
public void Score(PlayerId playerId, ScoreType scoreType)
{
if (!this.startTimer)
{
return;
}
// increment player score
var teamNumber = Globals.Instance.ManageTeam.GetTeamNumber(playerId);
this.scores[teamNumber][scoreType] += this.ScoreModifier(scoreType);
//this.playerScores[playerId][scoreType] += this.ScoreModifier(scoreType);
// get player's team
//var team = this.playerToTeam[playerId];
// aggregate team score
//var teamScore = this.TeamScore(team, scoreType);
// get the text field for this player's team and score type and update it
if (teamNumber < this.scoreboards.Count && this.scoreboards[teamNumber] != null)
{
this.scoreboards[teamNumber].SetScore(scoreType, this.scores[teamNumber][scoreType]);
}
}
/// <summary>
/// Initializes a player for the game start.
/// </summary>
/// <param name="id">Player ID.</param>
/// <param name="fencesAvailable">How many fences available for the player.</param>
/// <param name="startPosition">Player start position.</param>
/// <param name="boardSize">Board size.</param>
public MovablePlayer(PlayerId id, int fencesAvailable, Square startPosition, IEnumerable<Square> goalPositions)
: base(id, fencesAvailable, startPosition, goalPositions)
{
}
