485 lines
20 KiB
C#
485 lines
20 KiB
C#
// Decompiled with JetBrains decompiler
|
|
// Type: Terraria.GameContent.Golf.GolfHelper
|
|
// Assembly: Terraria, Version=1.4.0.5, Culture=neutral, PublicKeyToken=null
|
|
// MVID: 67F9E73E-0A81-4937-A22C-5515CD405A83
|
|
// Assembly location: C:\Users\mikeyisbaeyt\Downloads\depotdownloader-2.4.5\depots\105601\6707058\Terraria.exe
|
|
|
|
using Microsoft.Xna.Framework;
|
|
using System;
|
|
using System.Diagnostics;
|
|
using Terraria.Audio;
|
|
using Terraria.Chat;
|
|
using Terraria.GameContent.Metadata;
|
|
using Terraria.ID;
|
|
using Terraria.Localization;
|
|
using Terraria.Physics;
|
|
|
|
namespace Terraria.GameContent.Golf
|
|
{
|
|
public static class GolfHelper
|
|
{
|
|
public const int PointsNeededForLevel1 = 500;
|
|
public const int PointsNeededForLevel2 = 1000;
|
|
public const int PointsNeededForLevel3 = 2000;
|
|
private static readonly PhysicsProperties PhysicsProperties = new PhysicsProperties(0.3f, 0.99f);
|
|
private static readonly GolfHelper.ContactListener Listener = new GolfHelper.ContactListener();
|
|
private static FancyGolfPredictionLine _predictionLine;
|
|
|
|
public static BallStepResult StepGolfBall(
|
|
Entity entity,
|
|
ref float angularVelocity)
|
|
{
|
|
return BallCollision.Step(GolfHelper.PhysicsProperties, entity, ref angularVelocity, (IBallContactListener) GolfHelper.Listener);
|
|
}
|
|
|
|
private static Vector2 FindVectorOnOval(Vector2 vector, Vector2 radius) => (double) Math.Abs(radius.X) < 9.99999974737875E-05 || (double) Math.Abs(radius.Y) < 9.99999974737875E-05 ? Vector2.Zero : Vector2.Normalize(vector / radius) * radius;
|
|
|
|
private static GolfHelper.ShotStrength CalculateShotStrength(
|
|
Vector2 shotVector,
|
|
GolfHelper.ClubProperties clubProperties)
|
|
{
|
|
Vector2.Normalize(shotVector);
|
|
double num1 = (double) shotVector.Length();
|
|
float num2 = GolfHelper.FindVectorOnOval(shotVector, clubProperties.MaximumStrength).Length();
|
|
float num3 = GolfHelper.FindVectorOnOval(shotVector, clubProperties.MinimumStrength).Length();
|
|
double num4 = (double) num3;
|
|
double num5 = (double) num2;
|
|
double num6 = (double) MathHelper.Clamp((float) num1, (float) num4, (float) num5);
|
|
return new GolfHelper.ShotStrength((float) (num6 * 32.0), Math.Max((float) ((num6 - (double) num3) / ((double) num2 - (double) num3)), 1f / 1000f), clubProperties.RoughLandResistance);
|
|
}
|
|
|
|
public static bool IsPlayerHoldingClub(Player player)
|
|
{
|
|
if (player == null || player.HeldItem == null)
|
|
return false;
|
|
int type = player.HeldItem.type;
|
|
switch (type)
|
|
{
|
|
case 4039:
|
|
case 4092:
|
|
case 4093:
|
|
case 4094:
|
|
return true;
|
|
default:
|
|
if ((uint) (type - 4587) > 11U)
|
|
return false;
|
|
goto case 4039;
|
|
}
|
|
}
|
|
|
|
public static GolfHelper.ShotStrength CalculateShotStrength(
|
|
Projectile golfHelper,
|
|
Entity golfBall)
|
|
{
|
|
int num1 = Main.screenWidth;
|
|
if (num1 > Main.screenHeight)
|
|
num1 = Main.screenHeight;
|
|
int num2 = 150;
|
|
int num3 = (num1 - num2) / 2;
|
|
if (num3 < 200)
|
|
num3 = 200;
|
|
float num4 = 300f;
|
|
return (double) golfHelper.ai[0] != 0.0 ? new GolfHelper.ShotStrength() : GolfHelper.CalculateShotStrength((golfHelper.Center - golfBall.Center) / num4, GolfHelper.GetClubPropertiesFromGolfHelper(golfHelper));
|
|
}
|
|
|
|
private static GolfHelper.ClubProperties GetClubPropertiesFromGolfHelper(
|
|
Projectile golfHelper)
|
|
{
|
|
return GolfHelper.GetClubProperties((short) Main.player[golfHelper.owner].HeldItem.type);
|
|
}
|
|
|
|
private static GolfHelper.ClubProperties GetClubProperties(short itemId)
|
|
{
|
|
Vector2 vector2 = new Vector2(0.25f, 0.25f);
|
|
switch (itemId)
|
|
{
|
|
case 4039:
|
|
return new GolfHelper.ClubProperties(vector2, Vector2.One, 0.0f);
|
|
case 4092:
|
|
return new GolfHelper.ClubProperties(Vector2.Zero, vector2, 0.0f);
|
|
case 4093:
|
|
return new GolfHelper.ClubProperties(vector2, new Vector2(0.65f, 1.5f), 1f);
|
|
case 4094:
|
|
return new GolfHelper.ClubProperties(vector2, new Vector2(1.5f, 0.65f), 0.0f);
|
|
case 4587:
|
|
return new GolfHelper.ClubProperties(vector2, Vector2.One, 0.0f);
|
|
case 4588:
|
|
return new GolfHelper.ClubProperties(Vector2.Zero, vector2, 0.0f);
|
|
case 4589:
|
|
return new GolfHelper.ClubProperties(vector2, new Vector2(0.65f, 1.5f), 1f);
|
|
case 4590:
|
|
return new GolfHelper.ClubProperties(vector2, new Vector2(1.5f, 0.65f), 0.0f);
|
|
case 4591:
|
|
return new GolfHelper.ClubProperties(vector2, Vector2.One, 0.0f);
|
|
case 4592:
|
|
return new GolfHelper.ClubProperties(Vector2.Zero, vector2, 0.0f);
|
|
case 4593:
|
|
return new GolfHelper.ClubProperties(vector2, new Vector2(0.65f, 1.5f), 1f);
|
|
case 4594:
|
|
return new GolfHelper.ClubProperties(vector2, new Vector2(1.5f, 0.65f), 0.0f);
|
|
case 4595:
|
|
return new GolfHelper.ClubProperties(vector2, Vector2.One, 0.0f);
|
|
case 4596:
|
|
return new GolfHelper.ClubProperties(Vector2.Zero, vector2, 0.0f);
|
|
case 4597:
|
|
return new GolfHelper.ClubProperties(vector2, new Vector2(0.65f, 1.5f), 1f);
|
|
case 4598:
|
|
return new GolfHelper.ClubProperties(vector2, new Vector2(1.5f, 0.65f), 0.0f);
|
|
default:
|
|
return new GolfHelper.ClubProperties();
|
|
}
|
|
}
|
|
|
|
public static Projectile FindHelperFromGolfBall(Projectile golfBall)
|
|
{
|
|
for (int index = 0; index < 1000; ++index)
|
|
{
|
|
Projectile projectile = Main.projectile[index];
|
|
if (projectile.active && projectile.type == 722 && projectile.owner == golfBall.owner)
|
|
return Main.projectile[index];
|
|
}
|
|
return (Projectile) null;
|
|
}
|
|
|
|
public static Projectile FindGolfBallForHelper(Projectile golfHelper)
|
|
{
|
|
for (int index = 0; index < 1000; ++index)
|
|
{
|
|
Projectile projectile = Main.projectile[index];
|
|
Vector2 shotVector = golfHelper.Center - projectile.Center;
|
|
if (projectile.active && ProjectileID.Sets.IsAGolfBall[projectile.type] && projectile.owner == golfHelper.owner && GolfHelper.ValidateShot((Entity) projectile, Main.player[golfHelper.owner], ref shotVector))
|
|
return Main.projectile[index];
|
|
}
|
|
return (Projectile) null;
|
|
}
|
|
|
|
public static bool IsGolfBallResting(Projectile golfBall) => (int) golfBall.localAI[1] == 0 || (double) Vector2.Distance(golfBall.position, golfBall.oldPos[golfBall.oldPos.Length - 1]) < 1.0;
|
|
|
|
public static bool IsGolfShotValid(Entity golfBall, Player player)
|
|
{
|
|
Vector2 vector2 = golfBall.Center - player.Bottom;
|
|
if (player.direction == -1)
|
|
vector2.X *= -1f;
|
|
return (double) vector2.X >= -16.0 && (double) vector2.X <= 32.0 && (double) vector2.Y <= 16.0 && (double) vector2.Y >= -16.0;
|
|
}
|
|
|
|
public static bool ValidateShot(Entity golfBall, Player player, ref Vector2 shotVector)
|
|
{
|
|
Vector2 vector2 = golfBall.Center - player.Bottom;
|
|
if (player.direction == -1)
|
|
{
|
|
vector2.X *= -1f;
|
|
shotVector.X *= -1f;
|
|
}
|
|
float rotation = shotVector.ToRotation();
|
|
if ((double) rotation > 0.0)
|
|
shotVector = shotVector.Length() * new Vector2((float) Math.Cos(0.0), (float) Math.Sin(0.0));
|
|
else if ((double) rotation < -1.52079641819)
|
|
shotVector = shotVector.Length() * new Vector2((float) Math.Cos(-1.52079641819), (float) Math.Sin(-1.52079641819));
|
|
if (player.direction == -1)
|
|
shotVector.X *= -1f;
|
|
return (double) vector2.X >= -16.0 && (double) vector2.X <= 32.0 && (double) vector2.Y <= 16.0 && (double) vector2.Y >= -16.0;
|
|
}
|
|
|
|
public static void HitGolfBall(Entity entity, Vector2 velocity, float roughLandResistance)
|
|
{
|
|
Vector2 bottom = entity.Bottom;
|
|
++bottom.Y;
|
|
Point tileCoordinates = bottom.ToTileCoordinates();
|
|
Tile tile = Main.tile[tileCoordinates.X, tileCoordinates.Y];
|
|
if (tile != null && tile.active())
|
|
{
|
|
TileMaterial byTileId = TileMaterials.GetByTileId(tile.type);
|
|
velocity = Vector2.Lerp(velocity * byTileId.GolfPhysics.ClubImpactDampening, velocity, byTileId.GolfPhysics.ImpactDampeningResistanceEfficiency * roughLandResistance);
|
|
}
|
|
entity.velocity = velocity;
|
|
if (!(entity is Projectile golfBall))
|
|
return;
|
|
golfBall.timeLeft = 18000;
|
|
if ((double) golfBall.ai[1] < 0.0)
|
|
golfBall.ai[1] = 0.0f;
|
|
++golfBall.ai[1];
|
|
golfBall.localAI[1] = 1f;
|
|
Main.LocalGolfState.RecordSwing(golfBall);
|
|
}
|
|
|
|
public static void DrawPredictionLine(
|
|
Entity golfBall,
|
|
Vector2 impactVelocity,
|
|
float chargeProgress,
|
|
float roughLandResistance)
|
|
{
|
|
if (GolfHelper._predictionLine == null)
|
|
GolfHelper._predictionLine = new FancyGolfPredictionLine(20);
|
|
GolfHelper._predictionLine.Update(golfBall, impactVelocity, roughLandResistance);
|
|
GolfHelper._predictionLine.Draw(Main.Camera, Main.spriteBatch, chargeProgress);
|
|
}
|
|
|
|
[Conditional("DEBUG")]
|
|
private static void UpdateDebugDraw(Vector2 position)
|
|
{
|
|
}
|
|
|
|
private struct ClubProperties
|
|
{
|
|
public readonly Vector2 MinimumStrength;
|
|
public readonly Vector2 MaximumStrength;
|
|
public readonly float RoughLandResistance;
|
|
|
|
public ClubProperties(
|
|
Vector2 minimumStrength,
|
|
Vector2 maximumStrength,
|
|
float roughLandResistance)
|
|
{
|
|
this.MinimumStrength = minimumStrength;
|
|
this.MaximumStrength = maximumStrength;
|
|
this.RoughLandResistance = roughLandResistance;
|
|
}
|
|
}
|
|
|
|
public struct ShotStrength
|
|
{
|
|
public readonly float AbsoluteStrength;
|
|
public readonly float RelativeStrength;
|
|
public readonly float RoughLandResistance;
|
|
|
|
public ShotStrength(
|
|
float absoluteStrength,
|
|
float relativeStrength,
|
|
float roughLandResistance)
|
|
{
|
|
this.AbsoluteStrength = absoluteStrength;
|
|
this.RelativeStrength = relativeStrength;
|
|
this.RoughLandResistance = roughLandResistance;
|
|
}
|
|
}
|
|
|
|
public class ContactListener : IBallContactListener
|
|
{
|
|
public void OnCollision(
|
|
PhysicsProperties properties,
|
|
ref Vector2 position,
|
|
ref Vector2 velocity,
|
|
ref BallCollisionEvent collision)
|
|
{
|
|
TileMaterial byTileId = TileMaterials.GetByTileId(collision.Tile.type);
|
|
Vector2 vector2_1 = velocity * byTileId.GolfPhysics.SideImpactDampening;
|
|
Vector2 vector2_2 = collision.Normal * Vector2.Dot(velocity, collision.Normal) * (byTileId.GolfPhysics.DirectImpactDampening - byTileId.GolfPhysics.SideImpactDampening);
|
|
velocity = vector2_1 + vector2_2;
|
|
Projectile entity = collision.Entity as Projectile;
|
|
switch (collision.Tile.type)
|
|
{
|
|
case 421:
|
|
case 422:
|
|
float num1 = 2.5f * collision.TimeScale;
|
|
Vector2 vector2_3 = new Vector2(-collision.Normal.Y, collision.Normal.X);
|
|
if (collision.Tile.type == (ushort) 422)
|
|
vector2_3 = -vector2_3;
|
|
float num2 = Vector2.Dot(velocity, vector2_3);
|
|
if ((double) num2 < (double) num1)
|
|
{
|
|
velocity += vector2_3 * MathHelper.Clamp(num1 - num2, 0.0f, num1 * 0.5f);
|
|
break;
|
|
}
|
|
break;
|
|
case 476:
|
|
float num3 = velocity.Length() / collision.TimeScale;
|
|
if ((double) collision.Normal.Y <= -0.00999999977648258 && (double) num3 <= 100.0)
|
|
{
|
|
velocity *= 0.0f;
|
|
if (entity != null && entity.active)
|
|
{
|
|
this.PutBallInCup(entity, collision);
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if (entity == null || (double) velocity.Y >= -0.300000011920929 || (double) velocity.Y <= -2.0 || (double) velocity.Length() <= 1.0)
|
|
return;
|
|
Dust dust = Dust.NewDustPerfect(collision.Entity.Center, 31, new Vector2?(collision.Normal), (int) sbyte.MaxValue);
|
|
dust.scale = 0.7f;
|
|
dust.fadeIn = 1f;
|
|
dust.velocity = dust.velocity * 0.5f + Main.rand.NextVector2CircularEdge(0.5f, 0.4f);
|
|
}
|
|
|
|
private void PutBallInCup(Projectile proj, BallCollisionEvent collision)
|
|
{
|
|
if (proj.owner == Main.myPlayer && Main.LocalGolfState.ShouldScoreHole)
|
|
{
|
|
Point tileCoordinates = (collision.ImpactPoint - collision.Normal * 0.5f).ToTileCoordinates();
|
|
int owner = proj.owner;
|
|
int numberOfHits = (int) proj.ai[1];
|
|
int type = proj.type;
|
|
if (numberOfHits > 1)
|
|
Main.LocalGolfState.SetScoreTime();
|
|
Main.LocalGolfState.RecordBallInfo(proj);
|
|
Main.LocalGolfState.LandBall(proj);
|
|
int golfBallScore = Main.LocalGolfState.GetGolfBallScore(proj);
|
|
if (numberOfHits > 0)
|
|
Main.player[owner].AccumulateGolfingScore(golfBallScore);
|
|
GolfHelper.ContactListener.PutBallInCup_TextAndEffects(tileCoordinates, owner, numberOfHits, type);
|
|
Main.LocalGolfState.ResetScoreTime();
|
|
Wiring.HitSwitch(tileCoordinates.X, tileCoordinates.Y);
|
|
NetMessage.SendData(59, number: tileCoordinates.X, number2: ((float) tileCoordinates.Y));
|
|
if (Main.netMode == 1)
|
|
NetMessage.SendData(128, number: owner, number2: ((float) numberOfHits), number3: ((float) type), number5: tileCoordinates.X, number6: tileCoordinates.Y);
|
|
}
|
|
proj.Kill();
|
|
}
|
|
|
|
public static void PutBallInCup_TextAndEffects(
|
|
Point hitLocation,
|
|
int plr,
|
|
int numberOfHits,
|
|
int projid)
|
|
{
|
|
if (numberOfHits == 0)
|
|
return;
|
|
GolfHelper.ContactListener.EmitGolfballExplosion(hitLocation.ToWorldCoordinates(autoAddY: 0.0f));
|
|
string key = "Game.BallBounceResultGolf_Single";
|
|
if (numberOfHits != 1)
|
|
key = "Game.BallBounceResultGolf_Plural";
|
|
NetworkText text = NetworkText.FromKey(key, (object) Main.player[plr].name, (object) NetworkText.FromKey(Lang.GetProjectileName(projid).Key), (object) numberOfHits);
|
|
switch (Main.netMode)
|
|
{
|
|
case 0:
|
|
case 1:
|
|
Main.NewText(text.ToString(), G: (byte) 240, B: (byte) 20);
|
|
break;
|
|
case 2:
|
|
ChatHelper.BroadcastChatMessage(text, new Color((int) byte.MaxValue, 240, 20));
|
|
break;
|
|
}
|
|
}
|
|
|
|
public void OnPassThrough(
|
|
PhysicsProperties properties,
|
|
ref Vector2 position,
|
|
ref Vector2 velocity,
|
|
ref float angularVelocity,
|
|
ref BallPassThroughEvent collision)
|
|
{
|
|
switch (collision.Type)
|
|
{
|
|
case BallPassThroughType.Water:
|
|
velocity *= 0.91f;
|
|
angularVelocity *= 0.91f;
|
|
break;
|
|
case BallPassThroughType.Honey:
|
|
velocity *= 0.8f;
|
|
angularVelocity *= 0.8f;
|
|
break;
|
|
case BallPassThroughType.Tile:
|
|
TileMaterial byTileId = TileMaterials.GetByTileId(collision.Tile.type);
|
|
velocity *= byTileId.GolfPhysics.PassThroughDampening;
|
|
angularVelocity *= byTileId.GolfPhysics.PassThroughDampening;
|
|
break;
|
|
}
|
|
}
|
|
|
|
private static void EmitGolfballExplosion_Old(Vector2 Center) => GolfHelper.ContactListener.EmitGolfballExplosion(Center);
|
|
|
|
private static void EmitGolfballExplosion(Vector2 Center)
|
|
{
|
|
SoundEngine.PlaySound(SoundID.Item129, Center);
|
|
for (float num = 0.0f; (double) num < 1.0; num += 0.085f)
|
|
{
|
|
Dust dust = Dust.NewDustPerfect(Center, 278, new Vector2?((num * 6.283185f).ToRotationVector2() * new Vector2(2f, 0.5f)));
|
|
dust.fadeIn = 1.2f;
|
|
dust.noGravity = true;
|
|
dust.velocity.X *= 0.7f;
|
|
dust.velocity.Y -= 1.5f;
|
|
dust.position.Y += 8f;
|
|
dust.velocity.X *= 2f;
|
|
dust.color = Main.hslToRgb(Main.rand.NextFloat(), 1f, 0.5f);
|
|
}
|
|
float num1 = Main.rand.NextFloat();
|
|
float num2 = (float) Main.rand.Next(5, 10);
|
|
for (int index1 = 0; (double) index1 < (double) num2; ++index1)
|
|
{
|
|
int num3 = Main.rand.Next(5, 22);
|
|
Vector2 vector2 = ((float) (((double) index1 - (double) num2 / 2.0) * 6.28318548202515 / 256.0 - 1.57079637050629)).ToRotationVector2() * new Vector2(5f, 1f) * (float) (0.25 + (double) Main.rand.NextFloat() * 0.0500000007450581);
|
|
Color rgb = Main.hslToRgb((float) (((double) num1 + (double) index1 / (double) num2) % 1.0), 0.7f, 0.7f);
|
|
rgb.A = (byte) 127;
|
|
for (int index2 = 0; index2 < num3; ++index2)
|
|
{
|
|
Dust dust = Dust.NewDustPerfect(Center + new Vector2((float) index1 - num2 / 2f, 0.0f) * 2f, 278, new Vector2?(vector2));
|
|
dust.fadeIn = 0.7f;
|
|
dust.scale = 0.7f;
|
|
dust.noGravity = true;
|
|
dust.position.Y += -1f;
|
|
dust.velocity *= (float) index2;
|
|
dust.scale += (float) (0.200000002980232 - (double) index2 * 0.0299999993294477);
|
|
dust.velocity += Main.rand.NextVector2Circular(0.05f, 0.05f);
|
|
dust.color = rgb;
|
|
}
|
|
}
|
|
for (float num4 = 0.0f; (double) num4 < 1.0; num4 += 0.2f)
|
|
{
|
|
Dust dust = Dust.NewDustPerfect(Center, 278, new Vector2?((num4 * 6.283185f).ToRotationVector2() * new Vector2(1f, 0.5f)));
|
|
dust.fadeIn = 1.2f;
|
|
dust.noGravity = true;
|
|
dust.velocity.X *= 0.7f;
|
|
dust.velocity.Y -= 0.5f;
|
|
dust.position.Y += 8f;
|
|
dust.velocity.X *= 2f;
|
|
dust.color = Main.hslToRgb(Main.rand.NextFloat(), 1f, 0.3f);
|
|
}
|
|
float num5 = Main.rand.NextFloatDirection();
|
|
for (float num6 = 0.0f; (double) num6 < 1.0; num6 += 0.15f)
|
|
{
|
|
Dust dust = Dust.NewDustPerfect(Center, 278, new Vector2?((num5 + num6 * 6.283185f).ToRotationVector2() * 4f));
|
|
dust.fadeIn = 1.5f;
|
|
dust.velocity *= (float) (0.5 + (double) num6 * 0.800000011920929);
|
|
dust.noGravity = true;
|
|
dust.velocity.X *= 0.35f;
|
|
dust.velocity.Y *= 2f;
|
|
--dust.velocity.Y;
|
|
dust.velocity.Y = -Math.Abs(dust.velocity.Y);
|
|
dust.position += dust.velocity * 3f;
|
|
dust.color = Main.hslToRgb(Main.rand.NextFloat(), 1f, (float) (0.600000023841858 + (double) Main.rand.NextFloat() * 0.200000002980232));
|
|
}
|
|
}
|
|
|
|
private static void EmitGolfballExplosion_v1(Vector2 Center)
|
|
{
|
|
for (float num = 0.0f; (double) num < 1.0; num += 0.085f)
|
|
{
|
|
Dust dust = Dust.NewDustPerfect(Center, 278, new Vector2?((num * 6.283185f).ToRotationVector2() * new Vector2(2f, 0.5f)));
|
|
dust.fadeIn = 1.2f;
|
|
dust.noGravity = true;
|
|
dust.velocity.X *= 0.7f;
|
|
dust.velocity.Y -= 1.5f;
|
|
dust.position.Y += 8f;
|
|
dust.color = Color.Lerp(Color.Silver, Color.White, 0.5f);
|
|
}
|
|
for (float num = 0.0f; (double) num < 1.0; num += 0.2f)
|
|
{
|
|
Dust dust = Dust.NewDustPerfect(Center, 278, new Vector2?((num * 6.283185f).ToRotationVector2() * new Vector2(1f, 0.5f)));
|
|
dust.fadeIn = 1.2f;
|
|
dust.noGravity = true;
|
|
dust.velocity.X *= 0.7f;
|
|
dust.velocity.Y -= 0.5f;
|
|
dust.position.Y += 8f;
|
|
dust.color = Color.Lerp(Color.Silver, Color.White, 0.5f);
|
|
}
|
|
float num1 = Main.rand.NextFloatDirection();
|
|
for (float num2 = 0.0f; (double) num2 < 1.0; num2 += 0.15f)
|
|
{
|
|
Dust dust = Dust.NewDustPerfect(Center, 278, new Vector2?((num1 + num2 * 6.283185f).ToRotationVector2() * 4f));
|
|
dust.fadeIn = 1.5f;
|
|
dust.velocity *= (float) (0.5 + (double) num2 * 0.800000011920929);
|
|
dust.noGravity = true;
|
|
dust.velocity.X *= 0.35f;
|
|
dust.velocity.Y *= 2f;
|
|
--dust.velocity.Y;
|
|
dust.velocity.Y = -Math.Abs(dust.velocity.Y);
|
|
dust.position += dust.velocity * 3f;
|
|
dust.color = Color.Lerp(Color.Silver, Color.White, 0.5f);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|