void Update()
{
if (pc.attacking == false)
{
if (pc.direction.x >= 5)
{
attackDirection = AttackDirection.Up;
DisableColliders();
}
else if (pc.direction.x <= -5)
{
attackDirection = AttackDirection.Down;
DisableColliders();
}
else if (pc.direction.y <= -5)
{
attackDirection = AttackDirection.Left;
DisableColliders();
}
else if (pc.direction.y >= 5)
{
attackDirection = AttackDirection.Right;
DisableColliders();
}
}
}
public static Vector3 getImpactPositionSimple(this ICombatant initialTarget, AbstractActor attacker, Vector3 attackPosition, int hitLocation)
{
Vector3 impactPoint = initialTarget.CurrentPosition;
AttackDirection attackDirection = AttackDirection.FromFront;
if ((UnityEngine.Object)initialTarget.GameRep != (UnityEngine.Object)null)
{
impactPoint = initialTarget.GameRep.GetHitPosition(hitLocation);
attackDirection = initialTarget.Combat.HitLocation.GetAttackDirection(attackPosition, initialTarget);
if (initialTarget.UnitType == UnitType.Building)
{
impactPoint = attacker.Combat.LOS.GetBuildingHitPosition(attacker, initialTarget as BattleTech.Building, attackPosition, 100f, impactPoint);
}
else
{
Vector3 origin = attackPosition + attacker.HighestLOSPosition;
Vector3 vector3_2 = impactPoint - origin;
Ray ray2 = new Ray(origin, vector3_2.normalized);
foreach (Collider allRaycastCollider in initialTarget.GameRep.AllRaycastColliders)
{
RaycastHit hitInfo;
if (allRaycastCollider.Raycast(ray2, out hitInfo, vector3_2.magnitude))
{
impactPoint = hitInfo.point;
break;
}
}
}
}
return(impactPoint);
}
internal static ArmorLocation GetPassthroughLocation(
ArmorLocation location,
AttackDirection attackDirection
)
{
try
{
if (ComponentExplosionsFeature.IsInternalExplosion && currentMech != null)
{
var chassisLocation = MechStructureRules.GetChassisLocationFromArmorLocation(location);
var properties = ComponentExplosionsFeature.Shared.GetCASEProperties(currentMech, (int)chassisLocation);
if (properties != null)
{
currentMech.PublishFloatieMessage("EXPLOSION CONTAINED");
//Control.mod.Logger.LogDebug($"prevented explosion pass through from {Mech.GetAbbreviatedChassisLocation(chassisLocation)}");
return(ArmorLocation.None); // CASE redirects damage, so lets redirect it to none
}
}
}
catch (Exception e)
{
Control.mod.Logger.LogError(e);
}
return(MechStructureRules.GetPassthroughLocation(location, attackDirection));
}
/// <summary>
/// Calculates Crits on attack
/// </summary>
/// <remarks>
/// This checks if we have FoTF. If we do Damage is calculated based on lost masks. otherwise we revert back to normal
/// </remarks>
/// <param name="dir"></param>
public void OnAttack(AttackDirection dir)
{
Log("Attacking");
defaultNailDamage = 5 + 4 * PlayerData.instance.GetInt("nailSmithUpgrades");
if (PlayerData.instance.GetInt("nailDamage") != defaultNailDamage)
{
PlayerData.instance.SetInt("nailDamage", defaultNailDamage);
}
if (PlayerData.instance.GetBool("equippedCharm_6"))
{
Log("Stronger Attack");
PlayerData.instance.SetInt("nailDamage",
PlayerData.instance.GetInt("nailDamage") +
4 * (PlayerData.instance.GetInt("maxHealth") - PlayerData.instance.GetInt("health")));
PlayMakerFSM.BroadcastEvent("UPDATE NAIL DAMAGE");
_NailDamageTracker = PlayerData.instance.GetInt("nailDamage");
Log("Set Nail Damage to to " + _NailDamageTracker);
}
/// <summary>
/// Reverts damage
/// </summary>
/// <remarks>After the attack is over, we need to reset the nail damage back to what it was.</remarks>
/// <param name="dir"></param>
}
public void Clear()
{
Index = -1;
AttackDir = AttackDirection.Top;
curState = AnimalState.None;
transform.rotation = Quaternion.Euler(new Vector3(0f, 0f, 0f));
}
private void DetectPlayer()
{
float xDiff = player.transform.position.x - transform.position.x;
float yDiff = player.transform.position.y - transform.position.y;
//en bas a gauche
if (xDiff < 0 && yDiff < 0)
{
direction = AttackDirection.SouthWest;
}
//en bas a droite
if (xDiff > 0 && yDiff < 0)
{
direction = AttackDirection.SouthEast;
}
//en haut a gauche
if (xDiff < 0 && yDiff > 0)
{
direction = AttackDirection.NorthWest;
}
//en haut a droite
if (xDiff > 0 && yDiff > 0)
{
direction = AttackDirection.NorthEast;
}
}
public string PlayerAttack(AttackDirection direction)
{
//for some reason I can only attack up and down but not left and right?
int visionIndex = (int)direction;
string failMessage = "Hero attack failed";
if (map.Hero.Vision[visionIndex].Type == TileType.ENEMY)
{
Enemy enemy = (Enemy)map.Hero.Vision[visionIndex];
if (enemy.isDead())
{
return(failMessage);
}
map.Hero.Attack(enemy);
EnemiesAttack();
map.Update();
if (enemy.isDead())
{
return("Hero killed enemy!");
}
return("Hero attacked enemy \n"
+ "Enemy HP: " + enemy.HP + "/" + enemy.MaxHP);
}
return(failMessage);
}
public static void SetDirectionMarker(AttackDirectionIndicator __instance, AttackDirection direction)
{
try {
AttackDirectionIndicator me = __instance;
if (me.Owner == null || me.Owner.IsDead || Combat == null)
{
return;
}
Color orig = me.ColorInactive;
Color?[] activeColors = __instance.Owner?.team?.IsFriendly(Combat?.LocalPlayerTeam) ?? false ? FacingMarkerPlayerColors : FacingMarkerEnemyColors;
object[] colors;
if (direction != AttackDirection.ToProne && direction != AttackDirection.FromTop)
{
colors = new object[] { activeColors?[0] ?? orig, activeColors?[1] ?? orig, activeColors?[2] ?? orig, activeColors?[3] ?? orig };
if (direction != AttackDirection.None)
{
int dirIndex = Math.Max(0, Math.Min((int)direction - 1, LOSDirectionCount - 1));
colors[dirIndex] = FacingMarkerTargetColors?[dirIndex] ?? me.ColorActive;
//Log( $"Direction {direction}, Index {dirIndex}, Color {colors[ dirIndex ]}" );
}
}
else
{
if (ActiveState == null)
{
return;
}
FiringPreviewManager.PreviewInfo info = ActiveState.FiringPreview.GetPreviewInfo(me.Owner);
orig = info.HasLOF ? (FacingMarkerTargetColors?[4] ?? me.ColorActive) : (activeColors?[4] ?? me.ColorInactive);
colors = new object[] { orig, orig, orig, orig };
}
SetColors.Invoke(__instance, colors);
} catch (Exception ex) { Error(ex); }
}
private AttackDirection GetAttackDirection()
{
Vector2 direction;
switch (attackDirectionSource)
{
default:
case AttackDirectionSource.MOUSE: // Get direction from screen
Vector2 screenPoint = Input.mousePosition;
direction = (Camera.main.ScreenToWorldPoint(screenPoint) - transform.position).normalized;
break;
case AttackDirectionSource.PLAYER: // Get direction from player
direction = movement.LastMoveDirection;
break;
}
float bestDot = Vector2.Dot(direction, attackDirections[0].direction);
AttackDirection bestDirection = attackDirections[0];
for (int i = 1; i < attackDirections.Length; i++)
{
float dot = Vector2.Dot(direction, attackDirections[i].direction);
if (dot > bestDot)
{
bestDot = dot;
bestDirection = attackDirections[i];
}
}
return(bestDirection);
}
public KiteAi(AttackDirection ad, HeroType heroType)
: base(heroType)
{
enemyTower = ad == AttackDirection.Left ? new Vec(100, 540) : new Vec(1820, 540);
stepToBase = ad == AttackDirection.Left ? new Vec(70, 0) : new Vec(-70, 0);
Logger.Log(enemyTower.ToString());
}
/// <summary>
/// Deploys the weapon.
/// </summary>
/// <param name="attackDirection">Attack direction.</param>
public void DeployWeapon(AttackDirection attackDirection) //JY- player uses weapon
{
if (_weapon != null)
{
_weapon.Attack(_location, attackDirection);
}
MetaHandler.DisplayAmmunitionLevel(_weapon);
}
void Move(AttackDirection direction)
{
Vector3 pos = transform.localPosition;
pos.x += direction == AttackDirection.Right ? stepDistance : -stepDistance;
pos.x = Mathf.Clamp(pos.x, -maxDistance, maxDistance);
transform.localPosition = pos;
}
public bool HasDirection(AttackDirection d)
{
if (d == AttackDirection.ANY)
{
return(true);
}
return(d == (AttackDirection)direction.x || d == (AttackDirection)direction.y);
}
public static void RecordAttack(AttackDirector.AttackSequence __instance)
{
try {
AttackDirector.AttackSequence me = __instance;
AttackDirection direction = Combat.HitLocation.GetAttackDirection(me.attackPosition, me.chosenTarget);
float range = (me.attackPosition - me.chosenTarget.CurrentPosition).magnitude;
BuildSequenceLine(me.attacker, me.chosenTarget, direction, range);
} catch (Exception ex) { Error(ex); }
}
public void CollectInfomation()
{
if (enemy == null)
{
return;
}
enemyAttackAnimationTime = enemy.animator.GetCurrentAnimatorStateInfo(MeleeController.attackLayer).normalizedTime;
enemyAttackDirection = (AttackDirection)enemy.animator.GetInteger(MeleeController.attackIndex);
}
private void OnAfterAttack(AttackDirection dir)
{
if (Punishment != 0)
{
Punishment = 0;
}
if (PlayerData.instance.GetBool("equippedCharm_6"))
{
Punishment += 1;
}
if (PlayerData.instance.GetBool("equippedCharm_25"))
{
Punishment += 1;
}
if (PlayerData.instance.GetBool("equippedCharm_13"))
{
Punishment += 1;
}
if (PlayerData.instance.GetBool("equippedCharm_18"))
{
Punishment += 1;
}
if (PlayerData.instance.GetBool("equippedCharm_32"))
{
Punishment += 1;
}
if (Punishment == 4)
{
PlayerData.instance.overcharmed = true;
HeroController.instance.ATTACK_DURATION = 0.51f;
HeroController.instance.ATTACK_COOLDOWN_TIME = 0.45f;
HeroController.instance.ATTACK_DURATION_CH = 0.25f;
HeroController.instance.ATTACK_COOLDOWN_TIME_CH = 0.2f;
}
if (Punishment >= 6)
{
PlayerData.instance.overcharmed = true;
PlayerData.instance.SetInt("nailDamage",
1);
PlayMakerFSM.BroadcastEvent("UPDATE NAIL DAMAGE");
HeroController.instance.ATTACK_DURATION = 0.82f;
HeroController.instance.ATTACK_COOLDOWN_TIME = 0.36f;
HeroController.instance.ATTACK_DURATION_CH = 0.75f;
HeroController.instance.ATTACK_COOLDOWN_TIME_CH = 0.36f;
}
}
static Dictionary <VehicleChassisLocations, float> GetLocationDictionary(Vector3 attackerPosition, Vehicle targetVehicle, Vector3 targetPosition, Quaternion targetRotation)
{
//Dictionary<ArmorLocation, float> locDir = new Dictionary<ArmorLocation, float>();
AttackDirection attackDirection = GetAttackDirection(attackerPosition, targetVehicle, targetPosition, targetRotation);
HitLocation hitLocationHelper = targetVehicle.Combat.HitLocation;
Dictionary <VehicleChassisLocations, int> hitTable = hitLocationHelper.GetVehicleHitTable(attackDirection, false);
return(HitTableToLocationDirectory(hitTable));
}
public AnimationData(string clip, float start, float hit, float end, float clipLength, AttackDirection direction, float damage)
{
Clip = clip;
Start = start;
Hit = hit;
End = end;
ClipLength = clipLength;
Direction = direction;
Damage = damage;
}
AttackDirection getCombo(AttackDirection current)
{
var dir = (AttackDirection)MeleeController.r.Next(0, 5);
if (dir == current)
{
return(getCombo(current));
}
return(dir);
}
public void Schutz(AttackDirection aDir)
{
fireball = Instantiate(HeroController.instance.spell1Prefab, HeroController.instance.transform.position - new Vector3(0, 0, 0), new Quaternion(0, 0, 0, 0));
fireball.transform.localScale = new Vector3(1f, 0.1f, 0.01f);
fireballFSM = fireball.LocateMyFSM("Fireball Cast");
fireballFSM.FsmVariables.GetFsmFloat("Fire Speed").Value = AmmunitionControl.currAmmoType.BulletVelocity;
// Destroy the old camera shake actions and replace with a simple small shake.
/*
* FsmState fbState = fireballFSM.GetState("Cast Right");
* fbState.Actions = fbState.Actions.Where(action => !(action is SendEventByName)).ToArray();
* fbState = fireballFSM.GetState("Cast Left");
* fbState.Actions = fbState.Actions.Where(action => !(action is SendEventByName)).ToArray();
*/
// Shake screen
GameCameras.instance.cameraShakeFSM.SendEvent("SmallShake");
//This block removes the default audio and wall hit shake
//Shooting toward the right
if (HeroController.instance.cState.facingRight)
{
fireball.transform.position += new Vector3(0.80f, -0.8f, 0f);
fireballFSM.GetAction <SendEventByName>("Cast Right", 1).sendEvent = "";
fireballFSM.GetAction <AudioPlayerOneShotSingle>("Cast Right", 6).volume = 0;
fireballFSM.GetAction <SpawnObjectFromGlobalPool>("Cast Right", 7).position = new Vector3(0, 0, 0);
//Deviation/Recoil
RecoilIncrease();
recoilVal = recoilNum.Next(-AmmunitionControl.currAmmoType.CurrRecoilDeviation, AmmunitionControl.currAmmoType.CurrRecoilDeviation);
fireball.transform.Rotate(new Vector3(0, 0, recoilVal + FireAtDiagonal()));
fireballFSM.GetAction <SetVelocityAsAngle>("Cast Right", 9).angle = CheckIfRightAngle(0 + recoilVal + FireAtDiagonal());
}
//Shooting toward the left
else if (!HeroController.instance.cState.facingRight)
{
fireball.transform.position += new Vector3(-0.80f, -0.8f, 0f);
fireballFSM.GetAction <SendEventByName>("Cast Left", 1).sendEvent = "";
fireballFSM.GetAction <AudioPlayerOneShotSingle>("Cast Left", 3).volume = 0;
fireballFSM.GetAction <SpawnObjectFromGlobalPool>("Cast Left", 4).position = new Vector3(0, 0, 0);
//Deviation/Recoil
RecoilIncrease();
recoilVal = recoilNum.Next(-AmmunitionControl.currAmmoType.CurrRecoilDeviation, AmmunitionControl.currAmmoType.CurrRecoilDeviation);
fireball.transform.Rotate(new Vector3(0, 0, recoilVal - FireAtDiagonal()));
fireballFSM.GetAction <SetVelocityAsAngle>("Cast Left", 6).angle = CheckIfRightAngle(180 + recoilVal - FireAtDiagonal());
}
//Destroy(fireball, 0.25f);
}
void decideFeint(AttackDirection dir)
{
if (tacticalControl.EnemyController.flinching || dir == AttackDirection.LTR)
{
willFeint = false;
}
else
{
willFeint = MeleeController.r.NextDouble() < feintProb;
}
}
public int GetPoint(AttackDirection dir)
{
if (dir == AttackDirection.Top)
{
return(b2tSide.Points);
}
else
{
return(t2bSide.Points);
}
}
public float GetLastConnectMoveDis(AttackDirection dir)
{
if (dir == AttackDirection.Top)
{
return(b2tSide.GetLastConnectMoveDis());
}
else
{
return(t2bSide.GetLastConnectMoveDis());
}
}
static Dictionary <ArmorLocation, float> GetLocationDictionary(Vector3 attackerPosition, Mech m, Vector3 targetPosition, Quaternion targetRotation)
{
//Dictionary<ArmorLocation, float> locDir = new Dictionary<ArmorLocation, float>();
// TODO handle called shots - see HitLocationRules.cs GetAdjacentHitLocation
AttackDirection attackDirection = GetAttackDirection(attackerPosition, m, targetPosition, targetRotation);
HitLocation hitLocationHelper = m.Combat.HitLocation;
Dictionary <ArmorLocation, int> hitTable = hitLocationHelper.GetMechHitTable(attackDirection, false);
return(HitTableToLocationDirectory(hitTable));
}
public float GetMaxDis(AttackDirection dir)
{
float maxDis = 0;
if (dir == AttackDirection.Top)
{
maxDis = b2tSide.GetFirstMoveDis();
}
else
{
maxDis = t2bSide.GetFirstMoveDis();
}
return(maxDis);
}
public override bool Attacked(AttackDirection direction, float damage)
{
Health -= damage;
if (Health <= 0)
{
Health = 0;
if (Handler)
{
Handler.Lost(this);
}
}
Handler.ActorHit(this);
return(true);
}
public static void PrefixMechCalledShot(ref Dictionary <ArmorLocation, int> hitTable, ArmorLocation bonusLocation, ref float bonusLocationMultiplier)
{
try {
bonusLocationMultiplier = FixMultiplier(bonusLocation, bonusLocationMultiplier);
if (Settings.CalledShotUseClustering && CurrentHitDirection != AttackDirection.None)
{
if (bonusLocation != ArmorLocation.None)
{
hitTable = CombatConstants.GetMechClusterTable(bonusLocation, CurrentHitDirection);
}
CurrentHitDirection = AttackDirection.None;
}
} catch (Exception ex) { Error(ex); }
}
public void handleMainHandResponse()
{
var mainHandAction = Input.GetMouseButtonDown(0);
var mouseScrollDelta = Input.mouseScrollDelta.y;
var currentAttackDirection = getCurrentAttackDirection;
var kicking = Input.GetKeyDown(KeyCode.E);
if (Input.GetKeyDown(KeyCode.Q))
{
feint();
return;
}
AttackDirection response = AttackDirection.NODIRECTION;
if (kicking)
{
response = AttackDirection.KICK;
executeAttack(response, Bodypart.RIGHTFOOT);
return;
}
else
{
if (mainHandAction)
{
if (currentAttackDirection == AttackDirection.NODIRECTION || currentAttackDirection == AttackDirection.LTR)
{
response = AttackDirection.RTL;
}
else
{
response = AttackDirection.LTR;
}
}
else if (mouseScrollDelta > 0)
{
response = AttackDirection.UPWARD;
}
else if (mouseScrollDelta < 0)
{
response = AttackDirection.DOWN;
}
else if (Input.GetMouseButtonDown(2))
{
response = AttackDirection.THRUST;
}
}
executeAttack(response, Bodypart.RIGHTHAND);
}
public void InitData(AttackDirection dir, List <RoadEntity> roads)
{
AttackDir = dir;
m_roads = roads;
UseAI.StartAI = true;
BattleDatas = new AIBattleInfo[roads.Count];
for (int i = 0; i < roads.Count; i++)
{
BattleDatas[i] = new AIBattleInfo();
}
for (int i = 0; i < SeatList.Count; i++)
{
SeatList[i].SeatIndex = i;
}
}
public virtual void StartAttack(AttackDirection direction, AttackTrigger trigger)
{
// if we're attacking and can't cancel, then return
if (isAttacking && !canCancel)
{
return;
}
// get the movement controller state
AttackPositionState state;
if (movementControl.isJumping || movementControl.isFalling)
{
state = AttackPositionState.Air;
}
else if (movementControl.isDashing)
{
state = AttackPositionState.Dash;
}
else
{
state = AttackPositionState.Neutral;
}
if (InputAttackData[state][direction][trigger].Count != 0)
{
if (isAttacking && InputAttackData[state][direction][trigger].ContainsKey(currentAttack.attackID))
{
// go to the combo action this combination is associated with
currentAttack = InputAttackData[state][direction][trigger][currentAttack.attackID];
}
else if (InputAttackData[state][direction][trigger].ContainsKey(""))
{
// go to the non-combo action this combination is associated with
currentAttack = InputAttackData[state][direction][trigger][""];
}
else
{
// there is no attack available for this attack, return
return;
}
// start the attack
isAttacking = true;
canCancel = false;
currentAttack.Activate();
}
}
void Start()
{
wherePlayer = AttackDirection.None;
currentAttackCooldown = attackRate;
gameController = GameObject.Find("Main Camera").GetComponent<GameController>();
mob = gameController.mob;
foreach (Mob m in mob)
{
if (m.mobBody == this.gameObject)
thisMob = m;
else
{
thisMob = new Mob();
thisMob.isPirate = true;
thisMob.mobBody = this.gameObject;
}
}
//Debug.Log(thisMob +" "+ mob.IndexOf(thisMob) + " " + thisMob.isPirate);
player = GameObject.Find("Player");
rb2d = this.GetComponent<Rigidbody2D>();
mobAnimator = this.GetComponent<Animator>();
thisTransform = transform;
}
public virtual void StartAttack(AttackDirection direction, AttackTrigger trigger)
{
// if we're attacking and can't cancel, then return
if (isAttacking && !canCancel) {
return;
}
// get the movement controller state
AttackPositionState state;
if (movementControl.isJumping || movementControl.isFalling) {
state = AttackPositionState.Air;
} else if (movementControl.isDashing) {
state = AttackPositionState.Dash;
} else {
state = AttackPositionState.Neutral;
}
if (InputAttackData[state][direction][trigger].Count != 0) {
if (isAttacking && InputAttackData[state][direction][trigger].ContainsKey (currentAttack.attackID)) {
// go to the combo action this combination is associated with
currentAttack = InputAttackData[state][direction][trigger][currentAttack.attackID];
} else if (InputAttackData[state][direction][trigger].ContainsKey ("")) {
// go to the non-combo action this combination is associated with
currentAttack = InputAttackData[state][direction][trigger][""];
} else {
// there is no attack available for this attack, return
return;
}
// start the attack
isAttacking = true;
canCancel = false;
currentAttack.Activate ();
}
}
