private void OnTriggerExit2D(Collider2D collider)
{
CameraSegmentMember member = collider.GetComponent <CameraSegmentMember>();
if (member)
{
OnMemberExit(member);
}
PlayerUnitController unit = InteractiveHelpers.GetPlayer(collider);
if (!unit)
{
return;
}
unitsInside.Remove(unit);
// TODO: do we need to assign null here?
//PlayerUnitCamera camera = unit.di.camera;
//if (camera.CameraSegment == this)
// camera.CameraSegment = null;
//camera.RemoveCameraSegment(this);
}
private void OnTriggerEnter2D(Collider2D collider)
{
CameraSegmentMember member = collider.GetComponent <CameraSegmentMember>();
if (member)
{
OnMemberEnter(member);
}
PlayerUnitController unit = InteractiveHelpers.GetPlayer(collider);
if (!unit)
{
return;
}
PlayerUnitCamera playerCamera = unit.di.camera;
if (playerCamera.CameraSegment == null)
{
unitsInside.Add(unit);
playerCamera.CameraSegment = this;
}
else
{
CheckUnitForSegmentEnter(unit);
}
}
public static IEnumerator AttackCoroutineAndInvokeAction(PlayerUnitController self, bool stopCondition, float attackRate, Action attackAction)
{
self.SM.InitilizeAttackCoroutine(attackCoroutineAndInvokeAction(self, stopCondition, attackRate, attackAction));
yield return(self.SM.StartCoroutine(self.SM.AttackCoroutine));
yield break;
}
public override void TakeDamageFrom(BoxCollider2D damageCollider, PlayerUnitController player)
{
if (animator.IsState(PigmanAnimatorState.Stagger))
{
hasAfterParryRecoil = false;
currentHp--;
if (currentHp == 0)
{
Die();
}
else
{
TakeHit();
}
}
else if (animator.IsState(PigmanAnimatorState.Hit))
{
// do nothing
}
else
{
hasAfterParryRecoil = true;
float tileForce = player.di.stats.IsFullAssembly
? data.parryFullAssemblyRecoilTileForce
: data.parryPartialAssemblyRecoilTileForce;
afterParryRecoil = RecoilHelpers.GetRecoilFromTo(player.transform, controller.transform, tileForce);
stateMachine.attack.StartParry();
}
}
public static Vector2 FindPositionNextToUnit(PlayerUnitController pc, EnemyUnitController ec)
{
Vector2 TargetSpriteExtent = ec.SR.sprite.bounds.extents;
Vector2 SelfSpriteExtent = pc.SR.sprite.bounds.extents;
SelfSpriteExtent.x *= pc.transform.localScale.x;
SelfSpriteExtent.y *= pc.transform.localScale.y;
TargetSpriteExtent.x *= ec.transform.localScale.x;
TargetSpriteExtent.y *= ec.transform.localScale.y;
Vector2 TargetGOPos = ec.transform.position;
Vector2 SelfPos = pc.transform.position;
string LoR = (FindIfTargetIsLeftOrRightOfSelf(pc, ec));
Vector2 pos = SelfPos;
if (LoR == "left")
{
pos.x = (TargetGOPos.x - TargetSpriteExtent.x - 0.1f - SelfSpriteExtent.x);
pos.y = (TargetGOPos.y - TargetSpriteExtent.y + SelfSpriteExtent.y);
}
else if (LoR == "right")
{
pos.x = (TargetGOPos.x + TargetSpriteExtent.x + 0.1f + SelfSpriteExtent.x);
pos.y = (TargetGOPos.y - TargetSpriteExtent.y + SelfSpriteExtent.y);
}
else
{
Debug.Log("Couldn't find if object is left or right.. Default to self transform.position...");
pos = pc.transform.position;
}
return(pos);
}
public void Inject(PlayerUnitDI di)
{
controller = di.controller;
action = di.abilities.action;
action.OnIsAttackingChange += OnIsAttackingChange;
OnIsAttackingChange(false);
}
private void OnTriggerEnter2D(Collider2D collision)
{
PlayerUnitController unit = InteractiveHelpers.GetPlayer(collision);
PlayerBaseStats stats = unit.di.stats;
PlayerRespawnHandler respawnHandler = unit.mainController.di.respawnHandler;
bool playSound = false;
foreach ((SlimeType type, bool acceptsType) in checkpointFor.GetPairEnumerable())
{
if (acceptsType && stats.HasType(type))
{
bool updated = respawnHandler.SetCheckpoint(type, this);
if (updated)
{
playSound = true;
}
if (!segmentMember.Segment)
{
segmentMember.Segment = unit.di.camera.CameraSegment;
}
}
}
if (playSound)
{
AudioSingleton.PlaySound(AudioSingleton.Instance.clips.checkpoint);
}
}
public override void OnPlayerGuardCollision(PlayerUnitController player)
{
if (!physics.canPuff)
{
CheckForReverseOnCollisionWithPlayer(player);
}
}
public void AddUnitToPlayerUnitsFightingDictionary(PlayerUnitController pc)
{
if (!PlayerUnitsFightingMe.ContainsKey(pc.name))
{
PlayerUnitsFightingMe.Add(pc.name, pc);
}
}
//A temporary starting function
private void Awake()
{
instance = this;
playerUnitController = this.gameObject.GetComponent <PlayerUnitController>();
StartCoroutine(LineProcessing());
}
public void ClickedOnTile(PointerEventData ptrED, Tile tile)
{
PlayerUnitController selectedUnit = gameManager.turnManager.currentPlayer.selectedUnit;
if (selectedUnit != null)
{
if (selectedUnit.Mode == "action" || ptrED.button == PointerEventData.InputButton.Right)
{
//Move player unit event
selectedUnit.Move(tile);
gameManager.uiManager.HighlightStep();
}
else
{
//Build/Train player unit event
if (selectedUnit.pickedUnit != null)
{
selectedUnit.TrainOrBuild(tile, selectedUnit.pickedUnit);
selectedUnit.Mode = "action";
gameManager.uiManager.SetBack();
gameManager.uiManager.HighlightStep();
}
}
}
}
private void AttackPlayer(PlayerUnitController player)
{
PlayerVulnerability vulnerability = player.di.vulnerability;
Vector2 lookVector = new Vector2(physics.flip.Direction.ToFloat(), 1);
if (vulnerability.IsGuardingInOpposingDirection(physics.flip.Direction))
{
float recoilTileForce;
if (IsFullAssembly(player))
{
stateMachine.attack.StartStagger();
recoilTileForce = data.guardFullAssemblyRecoilTileForce;
// TODO: short stagger?
}
else
{
recoilTileForce = data.guardPartialAssemblyRecoilTileForce;
Vector2 playerRecoil = RecoilHelpers.GetRecoilFromTo(player.transform, controller.transform, recoilTileForce);
player.di.stateMachine.SetRecoilState(playerRecoil);
}
}
else if (vulnerability.IsVulnerable())
{
PlayerDamageModule damage = player.di.damage;
Vector2 collisionRecoil = RecoilHelpers.GetRecoilNormalFromTo(player.transform, controller.transform);
if (IsFullAssembly(player))
{
damage.TakeDamage(data.attackDamage, TileHelpers.TileToWorld(data.attackFullAssemblyRecoilTileForce) * collisionRecoil);
}
else
{
damage.TakeDamage(data.attackDamage, TileHelpers.TileToWorld(data.attackPartialAssemblyRecoilTileForce) * collisionRecoil);
}
}
}
public void CastRay(Vector2 origin)
{
Vector2 rayVector = Vector2.down;
float skinWidth = Constants.SKIN_WIDTH;
float rayLength = this.rayLength + skinWidth;
if (debug)
{
Debug.DrawLine(origin, origin + (rayVector * rayLength), Color.red);
}
RaycastHit2D hit = Physics2D.Raycast(origin, rayVector, rayLength, layerMask);
if (hit)
{
PlayerUnitController player = InteractiveHelpers.GetPlayer(hit.collider);
if (player)
{
float collideDistance = 1f;
float allowedMove = player.di.physics.movement.GetAllowedMovement(collideDistance, Dir4.down);
if (allowedMove < collideDistance)
{
PlayerDamageModule damage = player.di.damage;
damage.TakeFullDamage();
}
}
}
}
public void ClickedOnPlayerUnit(PointerEventData ptrED, PlayerUnitController unit)
{
PlayerUnitController selectedUnit = gameManager.turnManager.currentPlayer.selectedUnit;
if (unit.owner == gameManager.turnManager.currentPlayer)
{
//Select player unit event
if (selectedUnit != null)
{
selectedUnit.Mode = "";
}
unit.owner.selectedUnit = unit;
selectedUnit.Mode = "";
gameManager.uiManager.SetBack();
gameManager.uiManager.HighlightStep();
}
else
{
//Attack enemy player unit event
if (selectedUnit != null && (selectedUnit.Mode == "action" || ptrED.button == PointerEventData.InputButton.Right))
{
selectedUnit.Attack(unit);
gameManager.uiManager.HighlightStep();
}
}
}
public override bool CanInteract(PlayerUnitController controller)
{
PlayerBaseStats stats = controller.di.stats;
SlimeType type = stats.SlimeType;
bool isAssembly = stats.IsAssembly;
switch (interactionType)
{
case SlimeInteractionType.OnlyUnitNoAssembly:
return(!isAssembly && canInteract.Get(type));
case SlimeInteractionType.UnitOrUnitInAssembly:
return(canInteract.Get(type) || HasMergedAny(stats));
case SlimeInteractionType.UnitOrAnyInAssembly:
return(canInteract.Get(type) || isAssembly);
case SlimeInteractionType.OnlyUnitInAssembly:
return(canInteract.Get(type) && isAssembly);
case SlimeInteractionType.OnlyAllUnitsInAssembly:
return(isAssembly && HasMergedAll(stats));
}
return(false);
}
public void OnDeath(PlayerUnitController unit, Vector2 relictVelocity)
{
PlayerBaseStats stats = unit.di.stats;
SlimeType poofType = stats.SlimeType;
Vector2 spawnPosition = unit.transform.position;
SlimePoof slimePoof = poofs[poofType];
slimePoof.SpawnAt(spawnPosition);
foreach (SlimeType type in SlimeTypeHelpers.GetEnumerable())
{
if (stats.HasType(type))
{
SlimeRelict relict = relicts[type];
relict.SpawnAt(spawnPosition);
Vector2 velocity = GenerateRelictVelocity();
relict.SetVelocity(velocity);
relict.SetRotation(RandomHelpers.Range(relicRotationsPerSecond));
//relictVelocity = Vector2.zero;
}
}
}
private void UpdateUI(PlayerUnitController unitController)
{
selectedUnitController = unitController;
heartsCounter.UpdateUnit(unitController);
selectedType.UpdateUnit(unitController);
breathBar.UpdateUnit(unitController);
}
protected override void OnGuarded(PlayerUnitController player)
{
if (!controller.di.physics.canPuff)
{
CheckForReverseOnCollisionWithPlayer(player);
}
}
private bool AbleToMerge(PlayerUnitController controller)
{
bool yeetingCanMerge = controller.di.stateMachine.yeetState.CanMerge();
bool isVulnerable = !controller.di.vulnerability.flashSprite.IsFlashing;
return(yeetingCanMerge && isVulnerable);
}
public override Vector2 GetGuardedRecoil(PlayerUnitController player)
{
float tileForce = player.di.stats.IsFullAssembly
? data.guardFullAssemblyRecoilTileForce
: data.guardPartialAssemblyRecoilTileForce;
return(RecoilHelpers.GetRecoilFromTo(player.transform, controller.transform, tileForce));
}
private void CmdSpawnPlayer()
{
GameObject _player = Instantiate(playerUnitPrefab, RespawnPositions.Instance.spawnPositions[0].position, Quaternion.identity);
myPlayerUnit = _player.GetComponent <PlayerUnitController>();
NetworkServer.SpawnWithClientAuthority(_player, connectionToClient);
}
private Vector2 GetDirectionToTarget()
{
PlayerUnitController target = controller.range.Target;
Vector2 distance = target.transform.position - controller.transform.position;
Vector2 directionToTarget = distance.normalized;
return(directionToTarget);
}
public static bool StandardIsTargetable(PlayerUnitController pc)
{
if (pc.CurrentStateLegacy != pc.States.Death)
{
return(true);
}
return(false);
}
public bool IsWorker(PlayerUnitController playerUnit)
{
if (Workers.Contains(playerUnit))
{
return(true);
}
return(false);
}
public void Inject(PlayerUnitDI di)
{
controller = di.controller;
merge.Inject(di);
guard.Inject(di);
stomp.Inject(di);
}
private void OnTriggerEnter2D(Collider2D collision)
{
PlayerUnitController unit = InteractiveHelpers.GetPlayer(collision);
if (unit)
{
SceneManager.LoadScene(sceneName);
}
}
private void OnTriggerEnter(Collider other)
{
PlayerUnitController _hitPlayer = other.gameObject.GetComponent <PlayerUnitController>();
if (_hitPlayer != null)
{
_hitPlayer.TakeDamage();
}
}
public static PlayerUnitController SpawnPlayerUnit(PlayerUnitController unitPrefab, Vector2 targetPosition, int unitBaseIndex)
{
PlayerUnitController puc = GameObject.Instantiate(unitPrefab, targetPosition, Quaternion.identity);
puc.name = unitPrefab.name + "_" + UnityEngine.Random.Range(10000, 50000);
puc.UnitBaseIndex = unitBaseIndex;
puc.gameObject.SetActive(true);
return(puc);
}
public void Start()
{
if (PlayerUnitController.GetInstance != null)
{
playerController = PlayerUnitController.GetInstance;
}
EventBroadcaster.Instance.AddObserver(EventNames.UPDATE_VISUAL_SKILLS, UpdateVisualSkills);
EventBroadcaster.Instance.AddObserver(EventNames.RESET_VISUAL_SKILLS, ClearVisualSkills);
}
// Start is called before the first frame update
void Start()
{
playerUnitController = new PlayerUnitController(0);
playerUnitController.controlledUnit = testUnit;
aIController = new AIController();
aIController.player = testUnit.transform;
aIController.controlledUnit = testEnemy;
}
