public override void SetDefaults() //MAKE SURE YOU CALL BASE.SETDEFAULTS IF OVERRIDING { Projectile.width = 48; Projectile.height = 48; Projectile.hostile = true; Projectile.alpha = 255; Projectile.penetrate = -1; Projectile.tileCollide = false; Projectile.timeLeft = 3600; CooldownSlot = 1; //not in warning line, test? Projectile.GetGlobalProjectile <FargoSoulsGlobalProjectile>().GrazeCheck = Projectile => { float num6 = 0f; if (CanDamage() != false && Collision.CheckAABBvLineCollision(Main.LocalPlayer.Hitbox.TopLeft(), Main.LocalPlayer.Hitbox.Size(), Projectile.Center, Projectile.Center + Projectile.velocity * Projectile.localAI[1], 22f * Projectile.scale + Main.LocalPlayer.GetModPlayer <FargoSoulsPlayer>().GrazeRadius * 2f + Player.defaultHeight, ref num6)) { return(true); } return(false); }; Projectile.hide = true; //fixes weird issues on spawn with scaling Projectile.GetGlobalProjectile <FargoSoulsGlobalProjectile>().DeletionImmuneRank = 1; }
public override bool?Colliding(Rectangle projHitbox, Rectangle targetHitbox) { try { if (doneDelay) { float point = 0f; Vector2 endPoint = (VectorHelper.GetVectorAtAngle(rotation) * 2048); bool colliding = Collision.CheckAABBvLineCollision(targetHitbox.TopLeft(), targetHitbox.Size(), npcCenter, npcCenter + endPoint, maxThickness, ref point); if (colliding) { Vector2 spawn = (Vector2.Normalize(endPoint) * point) + npcCenter; for (int i = 0; i < Main.rand.Next(1, 16); i++) { Dust.NewDust(spawn, 4, 4, 6); } } return(colliding); } return(false); } catch (Exception e) { Main.NewTextMultiline(e.ToString()); return(null); } }
public override bool? Colliding(Rectangle projHitbox, Rectangle targetHitbox) { if (projHitbox.Intersects(targetHitbox)) return true; float length; switch (Projectile.frame) { case 0: length = 56; break; case 1: length = 40; break; case 2: length = 54; break; case 3: length = 50; break; case 4: length = 44; break; case 5: length = 56; break; case 6: length = 50; break; case 7: length = 32; break; case 8: length = 34; break; case 9: length = 46; break; case 10: length = 34; break; default: goto case 0; } length = (float)Math.Sqrt(2 * length * length); length *= 0.8f; float dummy = 0f; Vector2 offset = length / 2 * Projectile.scale * Projectile.rotation.ToRotationVector2(); Vector2 end = Projectile.Center - offset; Vector2 tip = Projectile.Center + offset; if (Collision.CheckAABBvLineCollision(targetHitbox.TopLeft(), targetHitbox.Size(), end, tip, 8f * Projectile.scale, ref dummy)) return true; return false; }
public override bool?Colliding(Rectangle projHitbox, Rectangle targetHitbox) { float num = 0f; Vector2 end = projectile.Center + length * TrueRotation.ToRotationVector2(); return(Collision.CheckAABBvLineCollision(targetHitbox.TopLeft(), targetHitbox.Size(), projectile.Center, end, projectile.width, ref num)); }
public override bool?Colliding(Rectangle projHitbox, Rectangle targetHitbox) { float point = 0f; Vector2 endPoint = projectile.Center + projectile.velocity * 1000f; return(Collision.CheckAABBvLineCollision(targetHitbox.TopLeft(), targetHitbox.Size(), projectile.Center, endPoint, 4f, ref point)); }
public override bool?Colliding(Rectangle projHitbox, Rectangle targetHitbox) { Player player = Main.player[projectile.owner]; bool ret = false; if (projectile.ai[1] == 0 && channeling) { for (int i = 0; i < Main.projectile.Length; i++) { Projectile proj = Main.projectile[i]; if (proj.active && proj.type == projectile.type && proj.owner == player.whoAmI && proj != projectile) { float collisionPoint = 0f; Vector2 dir = proj.Center - projectile.Center; if (Collision.CheckAABBvLineCollision(targetHitbox.TopLeft(), targetHitbox.Size(), projectile.Center, projectile.Center + dir, (projectile.width + projectile.height) * 0.5f * projectile.scale, ref collisionPoint)) { ret = true; } } } } if (ret) { return(true); } return(base.Colliding(projHitbox, targetHitbox)); }
public override bool?Colliding(Rectangle projHitbox, Rectangle targetHitbox) { Vector2 lineEnd = projectile.position + Vector2.Normalize(projectile.velocity) * this.length; float collisionPoint = 0f; return(Collision.CheckAABBvLineCollision(targetHitbox.TopLeft(), targetHitbox.Size(), projectile.position, lineEnd, 10f, ref collisionPoint)); }
public override bool?Colliding(Rectangle projHitbox, Rectangle targetHitbox) { float point = 0f; Vector2 endPoint = projectile.position + projectile.width * projectile.rotation.ToRotationVector2(); return(Collision.CheckAABBvLineCollision(targetHitbox.TopLeft(), targetHitbox.Size(), projectile.position, endPoint, projectile.height, ref point)); }
public override bool?Colliding(Rectangle projHitbox, Rectangle targetHitbox) { float point = 0f; return(projHitbox.Intersects(targetHitbox) || Collision.CheckAABBvLineCollision(targetHitbox.TopLeft(), targetHitbox.Size(), basePosition, projectile.Center, projectile.width, ref point)); }
//Thank you Iriazul for this! public static bool DoesBeamCollide(Rectangle targetHitbox, Vector2 beamStart, float beamAngle, float beamWidth) { float length = GetBeamLength(beamStart, beamAngle); var endPoint = beamStart + beamAngle.ToRotationVector2() * length; float temp = 0f; return(Collision.CheckAABBvLineCollision(targetHitbox.TopLeft(), targetHitbox.Size(), beamStart, endPoint, beamWidth, ref temp)); }
public override bool?Colliding(Rectangle projHitbox, Rectangle targetHitbox) { if (Collision.CheckAABBvLineCollision(targetHitbox.TopLeft(), targetHitbox.Size(), projectile.Center, projectile.oldPos[ProjectileID.Sets.TrailCacheLength[projectile.type] - 1] + projectile.Size / 2)) { return(true); } return(base.Colliding(projHitbox, targetHitbox)); }
public override bool?Colliding(Rectangle projHitbox, Rectangle targetHitbox) { Player player = Main.player[projectile.owner]; float point = 0f; return(Collision.CheckAABBvLineCollision(targetHitbox.TopLeft(), targetHitbox.Size(), player.MountedCenter, projectile.position, 2, ref point)); }
public override bool?Colliding(Rectangle projHitbox, Rectangle targetHitbox) { Projectile P = projectile; float point = 0f; return(Collision.CheckAABBvLineCollision(targetHitbox.TopLeft(), targetHitbox.Size(), P.Center, P.Center + P.velocity * P.ai[1], (float)P.width * scaleUp, ref point)); }
public override bool?Colliding(Rectangle projHitbox, Rectangle targetHitbox) { Vector2 center = projectile.Center; Vector2 end = center + (projectile.velocity * 4).RotatedBy(angle); float i = 0; return(Collision.CheckAABBvLineCollision(targetHitbox.TopLeft(), targetHitbox.Size(), center, end, 5, ref i)); }
public override bool?Colliding(Rectangle projHitbox, Rectangle targetHitbox) { if (npc == null || !FargoSoulsWorld.EternityMode) { return(base.Colliding(projHitbox, targetHitbox)); } return(Collision.CheckAABBvLineCollision(targetHitbox.TopLeft(), targetHitbox.Size(), ChainOrigin, Projectile.Center)); }
public override bool?Colliding(Rectangle projHitbox, Rectangle targetHitbox) { if (attacking) { return(Collision.CheckAABBvLineCollision(targetHitbox.TopLeft(), targetHitbox.Size(), projectile.Center, new Vector2(projectile.Center.X + flameRange * d, projectile.Center.Y), projectile.height, ref CP)); } return(false); }
public override bool?Colliding(Rectangle projHitbox, Rectangle targetHitbox) { float rot = projectile.ai[0] % 80 / 80f * 6.28f; float x = (float)Math.Cos(-rot) * 160; float y = (float)Math.Sin(-rot) * 70; Vector2 off = new Vector2(x, y); return(Collision.CheckAABBvLineCollision(targetHitbox.TopLeft(), targetHitbox.Size(), projectile.Center, projectile.Center + off)); }
public override bool?Colliding(Rectangle projHitbox, Rectangle targetHitbox) { if (projectile.localAI[0] == 1) { float point = 0f; return(Collision.CheckAABBvLineCollision(targetHitbox.TopLeft(), targetHitbox.Size(), projectile.Center, projectile.Center + projectile.velocity * projectile.localAI[1], projectile.width, ref point)); } return(false); }
public override bool?Colliding(Rectangle projHitbox, Rectangle targetHitbox) { Player player = Main.player[projectile.owner]; Vector2 unit = projectile.velocity; float point = 0f; return(Collision.CheckAABBvLineCollision(targetHitbox.TopLeft(), targetHitbox.Size(), player.Center, player.Center + unit * 2000, (projectile.ai[0] == 0 ? 20 : 44), ref point)); }
public override bool?Colliding(Rectangle projHitbox, Rectangle targetHitbox) { if (projectile.ai[1] == 1) { return(Collision.CheckAABBvLineCollision(targetHitbox.TopLeft(), targetHitbox.Size(), new Vector2(projectile.localAI[0], projectile.localAI[1]), projectile.Center)); } return(false); }
public override bool?Colliding(Rectangle projHitbox, Rectangle targetHitbox) { Vector2 v2 = projectile.velocity; v2.Normalize(); float point = 0f; return(Collision.CheckAABBvLineCollision(targetHitbox.TopLeft(), targetHitbox.Size(), projectile.Center, projectile.Center - v2 * 230f, 16, ref point)); }
public override bool?Colliding(Rectangle projHitbox, Rectangle targetHitbox) { float point = 0f; if (Collision.CheckAABBvLineCollision(targetHitbox.TopLeft(), targetHitbox.Size(), projectile.Center - projectile.velocity * 2, projectile.Center, 22, ref point)) { return(true); } return(null); }
/// <summary> /// Change the way of collision check of the projectile /// </summary> public override bool?Colliding(Rectangle projHitbox, Rectangle targetHitbox) { Player p = Main.player[projectile.owner]; Vector2 unit = (Main.player[projectile.owner].MountedCenter - _targetPos); unit.Normalize(); float point = 0f; return(Collision.CheckAABBvLineCollision(targetHitbox.TopLeft(), targetHitbox.Size(), p.Center - 45f * unit, _targetPos, 24, ref point)); }
public override bool?Colliding(Rectangle projHitbox, Rectangle targetHitbox) { float num3 = 0f; if (Collision.CheckAABBvLineCollision(targetHitbox.TopLeft(), targetHitbox.Size(), projectile.Center, projectile.Center + projectile.velocity * projectile.localAI[1], 22f * projectile.scale, ref num3)) { return(true); } return(false); }
public override bool?Colliding(Rectangle projHitbox, Rectangle targetHitbox) { float collisionPoint = 0f; if (phase == Phases.ATTACKING && frameY == 4) { return(Collision.CheckAABBvLineCollision(targetHitbox.TopLeft(), targetHitbox.Size(), projectile.Center + (projectile.rotation.ToRotationVector2() * 150), projectile.Center - (projectile.rotation.ToRotationVector2() * 150), 30, ref collisionPoint)); } return(false); }
public override bool?Colliding(Rectangle myRect, Rectangle targetRect) { float num = 0f; if (Collision.CheckAABBvLineCollision(targetRect.TopLeft(), targetRect.Size(), projectile.Center, projectile.Center + projectile.velocity * projectile.localAI[1], 22f * projectile.scale, ref num)) { return(true); } return(null); }
public override bool?Colliding(Rectangle projHitbox, Rectangle targetHitbox) { if (Lead != null && Lead.active) { float point = 0f; return(projHitbox.Intersects(targetHitbox) || Collision.CheckAABBvLineCollision(targetHitbox.TopLeft(), targetHitbox.Size(), Lead.Center, projectile.Center, projectile.width, ref point)); } return(false); }
public override bool CanHitPlayer(Player target, ref int cooldownSlot) { float col = 0; if ((attack2Timer < 60 || attack2Timer > 600) && npc.ai[3] == 1) { return(false); } return(Collision.CheckAABBvLineCollision(target.Hitbox.TopLeft(), target.Hitbox.Size(), BladeStart, BladeTip, bladeWidth, ref col)); }
// Change the way of collision check of the projectile public override bool?Colliding(Rectangle projHitbox, Rectangle targetHitbox) { Vector2 unit = projectile.velocity; float point = 0f; // Run an AABB versus Line check to look for collisions, look up AABB collision first to see how it works // It will look for collisions on the given line using AABB return(Collision.CheckAABBvLineCollision(targetHitbox.TopLeft(), targetHitbox.Size(), Main.npc[(int)projectile.ai[1]].Center + new Vector2(0f, 100f), Main.npc[(int)projectile.ai[1]].Center + new Vector2(0f, 100f) + unit * Distance, 22, ref point)); }
public override bool?Colliding(Rectangle projHitbox, Rectangle targetHitbox) { float collisionPoint9 = 0f; if (Collision.CheckAABBvLineCollision(targetHitbox.TopLeft(), targetHitbox.Size(), projectile.Center, projectile.Center + projectile.velocity * 6f, 10f * projectile.scale, ref collisionPoint9)) { return(true); } return(false); }