public void AutoBuyIn()
{
SetMinMax();
PlayerUtility.BuyInFromBankAccount(maxBuy);
PhotonUtility.SetPlayerProperties(PhotonNetwork.player, PhotonEnums.Player.Money, maxBuy);
_PokerGameManager.instance.unsortedPlayers[0].AutoBuyIn(maxBuy);
}
public Movement GetMovementToClosestEnemy()
{
var player = _client.GetPlayerTank();
var closestEnemyPosition = PlayerUtility.GetClosestEnemyPosition(_client, out var movementRoad, 30);
if (closestEnemyPosition.IsNegativePoint())
{
return(GetLongTermRandomDirection());
}
if (_movementRoad?.Count > 0 && _movementTarget != null &&
_client.IsEnemyAt(_movementTarget) &&
player.GetDistance(closestEnemyPosition) == player.GetDistance(_movementTarget) &&
_moveType == MoveType.MovementToClosestEnemy)
{
var movement = _movementRoad.First();
_movementRoad.RemoveAt(0);
return(movement);
}
_movementRoad = movementRoad;
_moveType = MoveType.MovementToClosestEnemy;
{
var movement = _movementRoad.First();
_movementRoad.RemoveAt(0);
_movementTarget = closestEnemyPosition;
return(movement);
}
}
private static MovementData UpdateHorizontal(ref MovementData movementData, PlayerInputData inputData, PlayerMovementAbilityData movementAbilityData,
float deltaTime, PlayerStates states)
{
var vel = movementData.Velocity;
var maxHorizontalSpeed = inputData.FireKeep ? movementAbilityData.MaxHorizontalSpeedDashing : movementAbilityData.MaxHorizontalSpeed;
var horizontalAcc = inputData.FireKeep ? movementAbilityData.HorizontalDashingAcc : movementAbilityData.HorizontalAcc;
if (inputData.HorizontalInput != 0)
{
vel.x = math.clamp(vel.x + inputData.HorizontalInput * horizontalAcc * deltaTime,
-maxHorizontalSpeed, maxHorizontalSpeed);
}
else if (PlayerUtility.IsGrounded(states))
{
var sign = math.sign(vel.x);
var value = math.abs(vel.x);
var amountToReduce = movementAbilityData.HorizontalReverseAcc * deltaTime;
value = value < amountToReduce ? 0 : value - amountToReduce;
vel.x = sign * value;
}
movementData.Velocity = vel;
return(movementData);
}
protected override void OnUpdate()
{
var playerQuery = GetEntityQuery(typeof(PlayerStates));
var playerEntity = playerQuery.GetSingletonEntity();
var playerStates = GetComponentDataFromEntity <PlayerStates>()[playerEntity];
if (!PlayerUtility.IsLevelDownProtection(playerStates))
{
return;
}
var deltaTime = TimeUtility.GetLimitedDeltaTime();
var flashRenderingData = GetComponentDataFromEntity <FlashRenderingData>()[playerEntity];
flashRenderingData.TimeLeftToSwitchRenderer = math.max(0, flashRenderingData.TimeLeftToSwitchRenderer - deltaTime);
if (flashRenderingData.TimeLeftToSwitchRenderer <= 0f)
{
flashRenderingData.TimeLeftToSwitchRenderer = GameEntry.Instance.Config.Global.PlayerLevelDownProtectionRendering.FlashingPeriod;
// TODO: This doesn't work right now.
if (GetComponentDataFromEntity <MaterialColor>().HasComponent(playerEntity))
{
EntityManager.RemoveComponent(playerEntity, typeof(MaterialColor));
}
else
{
EntityManager.AddComponent <MaterialColor>(playerEntity);
}
}
EntityManager.SetComponentData(playerEntity, flashRenderingData);
}
public bool CanBeUsed(int viewSize)
{
var playerX = _client.PlayerX;
var playerY = _client.PlayerY;
var area = new Region(new Region(playerY, playerY, playerX, playerX), viewSize);
return(PlayerUtility.IsInClosureArea(_client, area));
}
public void PlayerJump()
{
if (PlayerUtility.CanJump(onGround, true))
{
PlayerUtility.PlayerAction(body2D, RUNNING_VELOCITY, JUMPING_VELOCITY);
body2D.AddForce((Vector2.right * RUNNING_VELOCITY) * THRUST);
}
}
private void OnTriggerEnter2D(Collider2D collision)
{
if (collision.gameObject.tag == "Danger")
{
Destroy(gameObject);
PlayerUtility.setAttemptText(txt, AttemptsTracker.incrementAndGetAttemptLevelTwo());
SceneManager.LoadScene(3);
}
}
public IEnumerator Set_Attempt_Text_Minus()
{
KillPlayerLevelOne killPlayer = playerOne.GetComponent <KillPlayerLevelOne>();
PlayerUtility.setAttemptText(killPlayer.txt, -5);
Assert.AreEqual("Attempts: 0", killPlayer.txt.text);
yield return(null);
}
public IEnumerator Set_Attempt_Text_Plus()
{
KillPlayerLevelTwo killPlayer = playerTwo.GetComponent <KillPlayerLevelTwo>();
PlayerUtility.setAttemptText(killPlayer.txt, 3);
Assert.AreEqual("Attempts: 3", killPlayer.txt.text);
yield return(null);
}
private static PlayerStates CompleteLevelChange(PlayerStates playerStates, float playerLevelDownProtectionTimeConfig)
{
if (PlayerUtility.IsLevelDown(playerStates))
{
playerStates.LevelDownProtectionTime = playerLevelDownProtectionTimeConfig;
}
playerStates.Level = playerStates.NextLevel;
playerStates.LevelChangeTimeUsed = 0;
return(playerStates);
}
void Update()
{
if (onGround)
{
PlayerUtility.PlayerAction(body2D, RUNNING_VELOCITY, NO_VELOCITY);
PlayerUtility.ChangeAnimation(animator, RUNNING_ANIMATION);
}
// if (this.gameObject.transform.position.x >= FINISH_LOCATION_X_AXIS) {
// PlayerUtility.PlayerAction(body2D, NO_VELOCITY, NO_VELOCITY);
// PlayerUtility.ChangeAnimation(animator, IDLE_ANIMATION);
// }
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
Entities.WithAll <PlayerTag>().WithoutBurst().ForEach((ref PlayerStates states, in MovementData movementData) =>
{
if (states.Main != PlayerMainStatus.Alive)
{
return;
}
var wasGrounded = PlayerUtility.IsGrounded(states);
var lastMotionStatus = states.Motion;
if (states.FallingStopped || wasGrounded && math.abs(movementData.Velocity.y) < float.Epsilon)
{
if (math.abs(movementData.Velocity.x) < float.Epsilon)
{
states.Motion = PlayerMotionStatus.Static;
}
else
{
states.Motion = PlayerMotionStatus.Running;
}
}
else
{
if (movementData.Velocity.y > 0)
{
states.Motion = PlayerMotionStatus.Jumping;
}
else
{
states.Motion = PlayerMotionStatus.Falling;
}
}
// Reset flags.
states.FallingStopped = false;
if (states.Motion != PlayerMotionStatus.Jumping)
{
states.JumpKeepTime = 0;
}
if (lastMotionStatus != states.Motion)
{
var eventArgs = GameEntry.Instance.RefPool.GetOrAdd <PlayerMotionStatusChangeEventArgs>().Acquire();
eventArgs.LastMotionStatus = lastMotionStatus;
eventArgs.PlayerStates = states;
GameEntry.Instance.Event.SendEvent(this, eventArgs);
}
}).Run();
return(default);
public Movement GetPartialMovementToClosestEnemy(int turns)
{
if (_moveType == MoveType.PartialMovementToClosestEnemy && _movementRoad?.Count > 0 &&
_movementTarget != null)
{
var movement = _movementRoad.First();
_movementRoad.RemoveAt(0);
return(movement);
}
var player = _client.GetPlayerTank();
var enemies = new List <Point>();
enemies.AddRange(_client.GetBotsTanks());
enemies.AddRange(_client.GetOtherPlayersTanks());
var closestEnemy = enemies.OrderBy(x => x.GetDistance(player)).First();
var deltaX = player.X - closestEnemy.X;
var deltaY = player.Y - closestEnemy.Y;
var turnsToEnemy = deltaX + deltaY;
var speedX = (float)deltaX / turnsToEnemy;
var speedY = (float)deltaY / turnsToEnemy;
var targetX = (int)(speedX * turns);
var targetY = (int)(speedY * turns);
var target = new Point(targetX, targetY);
var horisontalCorrectionIteration = MapUtility.IterationMap[target.GetHorisontalDirectionTo(player).ToDirection(_client)];
var verticalCorrectionIteration = MapUtility.IterationMap[target.GetVerticalDirectionTo(player).ToDirection(_client)];
var horisontalCorrectedPoint = target;
var verticalCorrectedPoint = target;
while (_client.IsObstacleAt(horisontalCorrectedPoint) && _client.IsObstacleAt(verticalCorrectedPoint))
{
horisontalCorrectedPoint = horisontalCorrectionIteration(horisontalCorrectedPoint);
verticalCorrectedPoint = verticalCorrectionIteration(verticalCorrectedPoint);
}
target = _client.IsObstacleAt(horisontalCorrectedPoint) ? verticalCorrectedPoint : horisontalCorrectedPoint;
var road = PlayerUtility.GetRoad(_client, target);
_moveType = MoveType.PartialMovementToClosestEnemy;
_movementRoad = road;
_movementTarget = target;
{
var movement = _movementRoad.First();
_movementRoad.RemoveAt(0);
return(movement);
}
}
private void OnPlayerMotionStatusChange(object sender, BaseEventArgs e)
{
var eventArgs = (PlayerMotionStatusChangeEventArgs)e;
if (PlayerUtility.IsGrounded(eventArgs.PlayerStates) && PlayerUtility.IsInAir(eventArgs.LastMotionStatus))
{
AudioManager.StopSoundEffect("smb_jump-small");
AudioManager.StopSoundEffect("smb_jump-super");
}
if (eventArgs.PlayerStates.Motion == PlayerMotionStatus.Jumping && !AudioManager.IsPlayingSoundEffect("smb_stomp"))
{
AudioManager.PlaySoundEffect(eventArgs.PlayerStates.Level == PlayerLevel.Default ? "smb_jump-small" : "smb_jump-super");
}
}
public Movement GetMovementToClosestConstruction()
{
PlayerUtility.GetClosestConstructionPosition(_client, out _movementRoad);
_moveType = MoveType.MovementToClosestConstruction;
if ((_movementRoad?.Count ?? 0) == 0)
{
return(GetRandomMovement());
}
var movement = _movementRoad.First();
_movementRoad.RemoveAt(0);
return(movement);
}
protected override void OnUpdate()
{
var playerQuery = GetEntityQuery(typeof(PlayerTag), typeof(PlayerStates));
var systemEnabled = playerQuery.CalculateEntityCount() > 0;
if (systemEnabled)
{
var playerStates = playerQuery.GetSingleton <PlayerStates>();
if (PlayerUtility.IsChangingLevel(playerStates))
{
systemEnabled = false;
}
}
foreach (var system in m_PlayerDrivenComponentSystems)
{
system.Enabled = systemEnabled;
}
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
Entities.WithAll <PlayerTag>().ForEach((ref PlayerStates playerStates, in PlayerInputData inputData) =>
{
if (PlayerUtility.IsInAir(playerStates))
{
return;
}
if (inputData.HorizontalInput > 0)
{
playerStates.IsFacingLeft = false;
}
else if (inputData.HorizontalInput < 0)
{
playerStates.IsFacingLeft = true;
}
}).Run();
return(default);
public IEnumerator PlayerAction_Run_No_Jump()
{
Rigidbody2D body = playerPrefab.GetComponent <Rigidbody2D>();
float yBeforePlayerJumps = playerPrefab.transform.position.x;
yield return(null);
PlayerUtility.PlayerAction(body, 9f, 0f);
float yAfterPlayerJumps = playerPrefab.transform.position.x;
if (yAfterPlayerJumps > yBeforePlayerJumps)
{
yield break;
}
Assert.Fail();
}
void Update()
{
if (onGround)
{
PlayerUtility.PlayerAction(body2D, RUNNING_VELOCITY, NO_VELOCITY);
PlayerUtility.ChangeAnimation(animator, RUNNING_ANIMATION);
}
if (PlayerUtility.CanJump(onGround, Input.GetKey(SPACE)))
{
PlayerUtility.PlayerAction(body2D, RUNNING_VELOCITY, JUMPING_VELOCITY);
body2D.AddForce((Vector2.right * RUNNING_VELOCITY) * THRUST);
}
if (player.transform.position.x >= FINISH_LOCATION_X_AXIS)
{
PlayerUtility.PlayerAction(body2D, NO_VELOCITY, NO_VELOCITY);
PlayerUtility.ChangeAnimation(animator, IDLE_ANIMATION);
txt.text = LEVEL_COMPLETE_MESSAGE;
}
}
public IEnumerator PlayerAction_Jump()
{
Rigidbody2D body = playerPrefab.GetComponent <Rigidbody2D>();
float yBeforePlayerJumps = playerPrefab.transform.position.y;
yield return(null);
PlayerUtility.PlayerAction(body, 9f, 22f);
float yAfterPlayerJumps = playerPrefab.transform.position.y;
Debug.Log("before: " + yBeforePlayerJumps + " after: " + yAfterPlayerJumps);
if (yAfterPlayerJumps > yBeforePlayerJumps)
{
yield break;
}
Assert.Fail();
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
var deltaTime = TimeUtility.GetLimitedDeltaTime();
var playerLevelChangeTimeConfig = m_PlayerLevelChangeTimeConfig;
var playerLevelDownProtectionTimeConfig = m_PlayerLevelDownProtectionTimeConfig;
var playerConfig = GameEntry.Instance.Config.Global.Player;
var defaultScale = playerConfig.DefaultScale;
var superScale = playerConfig.SuperScale;
var jobHandle = Entities
.ForEach((ref PlayerStates playerStates, ref Translation translation, ref CompositeScale scaleComponent, ref PhysicsCollider physicsCollider) =>
{
if (!PlayerUtility.IsChangingLevel(playerStates))
{
return;
}
if (math.abs(playerStates.LevelChangeTimeUsed) <= float.Epsilon)
{
playerStates.LevelDownProtectionTime = 0;
var oldScale = MathUtility.MatrixToScale(scaleComponent.Value);
var newScale = playerStates.NextLevel == PlayerLevel.Default ? defaultScale : superScale;
scaleComponent.Value = MathUtility.ScaleToMatrix(newScale);
translation.Value.y += newScale.y / 2 - oldScale.y / 2;
PhysicsUtility.SetBoxColliderSize(physicsCollider, newScale);
}
if (playerStates.LevelChangeTimeUsed >= playerLevelChangeTimeConfig)
{
playerStates = CompleteLevelChange(playerStates, playerLevelDownProtectionTimeConfig);
}
else
{
playerStates.LevelChangeTimeUsed += deltaTime;
}
}).Schedule(inputDeps);
jobHandle.Complete();
return(jobHandle);
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
var deltaTime = TimeUtility.GetLimitedDeltaTime();
return(Entities.WithAll <PlayerTag>().ForEach((
ref Translation translation,
ref MovementData movementData,
ref PlayerStates states,
ref PlayerBouncedByEnemyData bouncedByEnemyData,
ref PlayerInputData inputData,
in PlayerMovementAbilityData movementAbilityData) =>
{
if (states.Main == PlayerMainStatus.Dying)
{
return;
}
UpdateHorizontal(ref movementData, inputData, movementAbilityData, deltaTime, states);
if (PlayerUtility.IsGrounded(states))
{
UpdateJumpStart(ref states, ref movementData, inputData, movementAbilityData);
}
else if (states.Motion == PlayerMotionStatus.Jumping)
{
UpdateJumpKeep(ref states, ref movementData, movementAbilityData, inputData, deltaTime);
}
else if (states.Motion == PlayerMotionStatus.Falling)
{
UpdateBouncedByEnemy(ref bouncedByEnemyData, ref states, ref inputData, ref movementData, movementAbilityData);
}
bouncedByEnemyData.IsBounced = false;
}).Schedule(inputDeps));
}
void Awake()
{
// Reference to PlayerUtility script
utility = GetComponent <PlayerUtility>();
jumpCount = jumpMax;
}
void Start()
{
PlayerUtility.setAttemptText(txt, AttemptsTracker.getAttemptLevelTwo());
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
var commandBuffer = m_CommandBufferSystem.CreateCommandBuffer().ToConcurrent();
var deadPlayerGenerator = GetEntityQuery(typeof(DeadPlayerCharacterGeneratorData)).GetSingletonEntity();
var deadPlayerGeneratorData = GetComponentDataFromEntity <DeadPlayerCharacterGeneratorData>()[deadPlayerGenerator];
var consequenceQueue = new NativeQueue <PlayerConsequence>(Allocator.Temp);
var consequenceQueueWriter = consequenceQueue.AsParallelWriter();
var jobHandle = Entities
.WithAll <PlayerTag>()
.ForEach((int entityInQueryIndex, Entity playerEntity,
ref PlayerAttackedByEnemyData attackData,
ref PlayerStates playerStates,
ref MovementData movementData,
in Translation translation) =>
{
if (attackData.EnemyAttackType == EnemyAttackType.None)
{
return;
}
if (playerStates.Main == PlayerMainStatus.Dying || PlayerUtility.IsLevelDownProtection(playerStates))
{
attackData.EnemyAttackType = EnemyAttackType.None;
return;
}
attackData.EnemyAttackType = EnemyAttackType.None;
if (playerStates.Level != PlayerLevel.Default)
{
playerStates.NextLevel = PlayerLevel.Default;
consequenceQueueWriter.Enqueue(new PlayerConsequence {
LevelDownOrDead = true, NewLevel = playerStates.NextLevel
});
}
else
{
consequenceQueueWriter.Enqueue(new PlayerConsequence {
LevelDownOrDead = false, DeadPosition = translation.Value
});
commandBuffer.DestroyEntity(entityInQueryIndex, playerEntity);
}
}).Schedule(inputDeps);
jobHandle.Complete();
if (consequenceQueue.TryDequeue(out var playerConsequence))
{
if (playerConsequence.LevelDownOrDead)
{
var eventArgs = GameEntry.Instance.RefPool.GetOrAdd <PlayerLevelChangeEventArgs>().Acquire();
eventArgs.Level = playerConsequence.NewLevel;
GameEntry.Instance.Event.SendEvent(this, eventArgs);
}
else
{
var position = playerConsequence.DeadPosition;
var deadPlayerEntity = EntityManager.Instantiate(deadPlayerGeneratorData.PrefabEntity);
var deadPlayerTranslation = GetComponentDataFromEntity <Translation>()[deadPlayerEntity];
deadPlayerTranslation.Value.x = position.x;
deadPlayerTranslation.Value.y = position.y;
EntityManager.SetComponentData(deadPlayerEntity, deadPlayerTranslation);
GameEntry.Instance.PlayerData.Die();
}
}
consequenceQueue.Dispose();
return(jobHandle);
}
void Start()
{
player = GetComponent <PlayerUtility>();
originalY = transform.position.y;
}
private void OnCollisionExit2D(Collision2D collision)
{
onGround = false;
PlayerUtility.ChangeAnimation(animator, JUMPING_ANIMATION);
}
public void Player_Doesnt_Jump_When_Space_Is_Not_Pressed()
{
Assert.AreNotEqual(true, PlayerUtility.CanJump(true, false));
}
public void Player_Doesnt_Jump_When_Not_onGround()
{
Assert.AreNotEqual(true, PlayerUtility.CanJump(false, true));
}
public void Player_Jumps_When_onGround_And_Space_Is_Pressed()
{
Assert.AreEqual(true, PlayerUtility.CanJump(true, true));
}
