internal Projectile PlayerShootProjectile(byte id, ProjectileDesc desc, ushort objType, Position position, float angle)
{
ProjectileId = id;
return(CreateProjectile(desc, objType,
(int)StatsManager.GetAttackDamage(desc.MinDamage, desc.MaxDamage),
position, angle));
}
private void Handle(Player player, PlayerShootPacket packet)
{
if (player.Owner == null)
{
return;
}
Item item = player.Manager.GameData.Items[packet.ContainerType];
ProjectileDesc prjDesc = item.Projectiles[0]; //Assume only one
var dmg = (int)player.statsMgr.GetAttackDamage(prjDesc.MinDamage, prjDesc.MaxDamage, (player.Inventory.Data[0] != null ? player.Inventory.Data[0].DmgPercentage : 0));
Projectile prj = player.PlayerShootProjectile(
packet.BulletId, prjDesc, item.ObjectType,
packet.Time, packet.Position, packet.Angle, dmg, player.Inventory.Data[0], 0);
player.Owner.EnterWorld(prj);
player.BroadcastSync(new AllyShootPacket
{
OwnerId = player.Id,
Angle = packet.Angle,
ContainerType = packet.ContainerType,
BulletId = packet.BulletId,
Damage = dmg
}, p => p != player && player.Dist(p) < 25);
player.FameCounter.Shoot(prj);
}
private void ActivateAbilityShoot(RealmTime time, Ability ability, Position target)
{
double arcGap = ability.ArcGap * Math.PI / 180;
double startAngle = Math.Atan2(target.Y - Y, target.X - X) - (ability.NumProjectiles - 1) / 2 * arcGap;
ProjectileDesc prjDesc = ability.Projectiles[0]; //Assume only one
var batch = new Packet[ability.NumProjectiles];
for (int i = 0; i < ability.NumProjectiles; i++)
{
Projectile proj = CreateProjectile(prjDesc, ObjectDesc.ObjectType,
(int)statsMgr.GetAttackDamage(prjDesc.MinDamage, prjDesc.MaxDamage),
time.tickTimes, new Position {
X = X, Y = Y
}, (float)(startAngle + arcGap * i), 1);
Owner.EnterWorld(proj);
fames.Shoot(proj);
batch[i] = new ShootPacket
{
BulletId = proj.ProjectileId,
OwnerId = Id,
ContainerType = ability.AbilityType,
Position = new Position {
X = X, Y = Y
},
Angle = proj.Angle,
Damage = (short)proj.Damage,
FromAbility = true
};
}
BroadcastSync(batch, p => this.Dist(p) < 25);
}
public Projectile(ProjectileDesc desc)
: base(GameServer.Manager.GameData.IdToObjectType[desc.ObjectId])
{
ProjDesc = desc;
CheatHandler = new GodCheatHandler();
CheatHandler.SetProjectile(this);
}
public Projectile CreateProjectile(ProjectileDesc desc, short container, int dmg, long time, Position pos,
float angle)
{
var ret = new Projectile(desc) //Assume only one
{
ProjectileOwner = this,
ProjectileId = projectileId++,
Container = container,
Damage = dmg,
BeginTime = time,
BeginPos = pos,
Angle = angle,
X = pos.X,
Y = pos.Y
};
if (this.HasConditionEffect(ConditionEffects.Damaging))
{
ret.Damage = ret.Damage * 2;
}
if (this.HasConditionEffect(ConditionEffects.Weak))
{
ret.Damage = ret.Damage / 2;
}
if (projectiles[ret.ProjectileId] != null)
{
projectiles[ret.ProjectileId].Destroy(true);
}
projectiles[ret.ProjectileId] = ret;
return(ret);
}
private void Handle(Player player, PlayerCheatPacket packet)
{
Item item = player.Inventory[0];
ProjectileDesc prjDesc = item.Projectiles[0];
bool CheaterPos =
(packet.atk_ > player.statsMgr.GetStats(2) + 5 || packet.def_ > player.statsMgr.GetStats(3) + 5 || packet.spd_ > player.statsMgr.GetStats(4) + 5 || packet.vit_ > player.statsMgr.GetStats(5) + 5 || packet.wis_ > player.statsMgr.GetStats(6) + 5 || packet.dex_ > player.statsMgr.GetStats(7) + 5);
bool CheaterNeg =
(packet.atk_ < 0 || packet.def_ < -10 || packet.dex_ < 0 || packet.wis_ < 0 || packet.vit_ < 0 || packet.spd_ < 0);
bool WeaponEdit =
(packet.mindmg_ > (prjDesc.MinDamage * 1.20) || packet.maxdmg_ > (prjDesc.MaxDamage * 1.20));
if (player.Owner == null || prjDesc == null || item == null)
{
return;
}
if (CheaterPos || CheaterNeg || WeaponEdit)
{
player.cheatCount++;
player.Owner.Timers.Add(new WorldTimer(5500, (world, t) =>
{
player.cheatCount--;
return;
}));
}
}
public Projectile CreateProjectile(ProjectileDesc desc, ushort container, int dmg, int pen, long time, Position pos,
float angle, ActivateAbility abil = null)
{
var ret = new Projectile(Manager, desc) //Assume only one
{
ProjectileOwner = this,
ProjectileId = projectileId++,
abil = abil,
Container = container,
Damage = dmg,
Penetration = pen,
BeginTime = time,
BeginPos = pos,
Angle = angle,
X = pos.X,
Y = pos.Y
};
if (projectiles[ret.ProjectileId] != null)
{
projectiles[ret.ProjectileId].Destroy(true);
}
projectiles[ret.ProjectileId] = ret;
return(ret);
}
public Projectile CreateProjectile(
ProjectileDesc desc,
ushort container,
int dmg,
long time,
Position pos,
float angle
)
{
Projectile _projectile = new Projectile(desc)
{
ProjectileOwner = this,
ProjectileId = ProjectileId++,
Container = (short)container,
Damage = dmg,
BeginTime = time,
BeginPos = pos,
Angle = angle,
X = pos.X,
Y = pos.Y
};
if (Owner.Projectiles.TryGetValue(new KeyValuePair <int, byte>(Id, _projectile.ProjectileId), out Projectile _projectileSample))
{
if (_projectileSample != null)
{
Owner.RemoveProjectileFromId(Id, _projectileSample.ProjectileId);
}
}
Owner.AddProjectileFromId(Id, _projectile.ProjectileId, _projectile);
return(_projectile);
}
protected override bool TickCore(RealmTime time)
{
int remainingTick;
object o;
if (!Host.StateStorage.TryGetValue(Key, out o))
{
remainingTick = 0;
}
else
{
remainingTick = (int)o;
}
remainingTick -= time.thisTickTimes;
bool ret;
if (remainingTick <= 0)
{
double angle = 0;
switch (Host.Self.ObjectType)
{
case 0x0802: angle = Math.PI / 2; break;
case 0x0803: angle = Math.PI * 3 / 2; break;
case 0x0804: angle = 0; break;
case 0x0805: angle = Math.PI; break;
}
ProjectileDesc desc = Host.Self.ObjectDesc.Projectiles[0];
Projectile proj = Host.Self.CreateProjectile(desc, Host.Self.ObjectType,
5, time.tickTimes, new Position()
{
X = Host.Self.X, Y = Host.Self.Y
},
(float)angle);
Host.Self.Owner.EnterWorld(proj);
Host.Self.Owner.BroadcastPacket(new ShootPacket()
{
BulletId = proj.ProjectileId,
OwnerId = Host.Self.Id,
ContainerType = Host.Self.ObjectType,
Position = proj.BeginPos,
Angle = proj.Angle,
Damage = (short)proj.Damage
}, null);
remainingTick = rand.Next(2000, 3500);
ret = true;
}
else
{
ret = false;
}
Host.StateStorage[Key] = remainingTick;
return(ret);
}
protected override bool TickCore(RealmTime time)
{
if (Host.Self.HasConditionEffect(ConditionEffects.Stunned))
{
return(false);
}
float dist = radius;
Entity entity = radius == 0 ? null : GetNearestEntity(ref dist, null);
if (entity != null || radius == 0)
{
var chr = Host as Character;
if (chr.Owner == null)
{
return(false);
}
ProjectileDesc desc = chr.ObjectDesc.Projectiles[projectileIndex];
double angle = entity == null ? 0 : Math.Atan2(entity.Y - chr.Y, entity.X - chr.X);
angle = Predict(entity, desc);
double angleInc = (2 * Math.PI) / this.count;
int count = this.count;
if (Host.Self.HasConditionEffect(ConditionEffects.Dazed))
{
count = Math.Max(1, count / 2);
}
byte prjId = 0;
var prjPos = new Position {
X = chr.X, Y = chr.Y
};
int dmg = chr.Random.Next(desc.MinDamage, desc.MaxDamage);
for (int i = 0; i < count; i++)
{
Projectile prj = chr.CreateProjectile(
desc, chr.ObjectType, dmg, time.tickTimes,
prjPos, (float)(angle + angleInc * i));
chr.Owner.EnterWorld(prj);
if (i == 0)
{
prjId = prj.ProjectileId;
}
}
chr.Owner.BroadcastPacket(new MultiShootPacket
{
BulletId = prjId,
OwnerId = Host.Self.Id,
BulletType = (byte)desc.BulletType,
Position = prjPos,
Angle = (float)angle,
Damage = (short)dmg,
NumShots = (byte)count,
AngleIncrement = (float)angleInc,
}, null);
return(true);
}
return(false);
}
public GunDesc(TypeCollection collection, XElement e)
{
//Don't modify the original source when we inherit
e = new XElement(e);
inherit = e.TryAtt(nameof(inherit), null);
if (inherit != null)
{
var source = collection.sources[inherit].Element(Tag);
e.InheritAttributes(source);
}
Dictionary <string, int> difficultyMap = new Dictionary <string, int> {
{ "none", 0 },
{ "easy", 20 },
{ "medium", 40 },
{ "hard", 60 },
{ "expert", 80 },
{ "master", 100 },
};
if (Enum.TryParse <WeaponDifficulty>(e.TryAtt(nameof(difficulty)), out var r))
{
difficulty = (int)r;
}
else
{
throw new Exception("Difficulty expected");
}
recoil = e.TryAttInt(nameof(recoil), 0);
noiseRange = e.TryAttInt(nameof(noiseRange), 0);
projectileCount = e.TryAttInt(nameof(projectileCount), 1);
knockback = e.TryAttInt(nameof(knockback), 0);
spread = e.TryAttInt(nameof(spread), 0);
fireTime = e.TryAttInt(nameof(fireTime), 0);
reloadTime = e.TryAttInt(nameof(reloadTime), 0);
critOnLastShot = e.TryAttBool(nameof(critOnLastShot), false);
clipSize = e.TryAttInt(nameof(clipSize), 0);
maxAmmo = e.TryAttInt(nameof(maxAmmo), 0);
initialClip = e.TryAttInt(nameof(initialClip), clipSize);
initialAmmo = e.TryAttInt(nameof(initialAmmo), maxAmmo);
if (e.HasElement("Bullet", out var bulletXml))
{
projectile = new BulletDesc(bulletXml);
}
else if (e.HasElement("Flame", out var flameXml))
{
projectile = new FlameDesc(flameXml);
}
else if (e.HasElement("Grenade", out var grenadeXml))
{
projectile = new GrenadeDesc(grenadeXml);
}
}
internal Projectile PlayerShootProjectile(
byte id, ProjectileDesc desc, ushort objType,
int time, Position position, float angle)
{
projectileId = id;
return(CreateProjectile(desc, objType,
(int)statsMgr.GetAttackDamage(desc.MinDamage, desc.MaxDamage),
time + tickMapping, position, angle));
}
internal Projectile PlayerShootProjectile(
byte id, ProjectileDesc desc, ushort objType,
int time, Position position, float angle, int dmg, ItemData data, int slotId = -1)
{
projectileId = id;
return CreateProjectile(desc, (ushort)objType,
(int)statsMgr.GetAttackDamage(desc.MinDamage, desc.MaxDamage, data != null ? data.DmgPercentage : 0),
time, position, angle, slotId);
}
internal Projectile PlayerShootProjectile(
byte id, ProjectileDesc desc, ushort objType,
int time, Position position, float angle)
{
projectileId = id;
return CreateProjectile(desc, objType,
(int)statsMgr.GetAttackDamage(desc.MinDamage, desc.MaxDamage),
time + tickMapping, position, angle);
}
internal Projectile PlayerShootProjectile(
byte id, ProjectileDesc desc, ushort objType,
int time, Position position, float angle, int dmg, ItemData data, int slotId = -1)
{
projectileId = id;
return(CreateProjectile(desc, (ushort)objType,
(int)statsMgr.GetAttackDamage(desc.MinDamage, desc.MaxDamage, data != null ? data.DmgPercentage : 0),
time, position, angle, slotId));
}
protected override void HandlePacket(Client client, PlayerShootPacket packet)
{
client.Manager.Logic.AddPendingAction(t =>
{
if (client.Player.Owner == null)
{
return;
}
Item item = client.Player.Manager.GameData.Items[(ushort)packet.ContainerType];
int stype = 0;
for (int i = 0; i < 4; i++)
{
if (client.Player.Inventory[i]?.ObjectType == packet.ContainerType)
{
stype = i;
break;
}
}
/* var dex = client.Player.StatsManager.GetStats(7);
* if (!client.Player.HasConditionEffect(ConditionEffectIndex.Berserk) && (item.NumProjectiles > item.RateOfFire * (1.5f + 6.5f * (dex / 75f))))
* {
* log.Error(client.Player.Name + " is shooting too fast. Ignored");
* return;
* } */
if (client.Player.SlotTypes[stype] != item.SlotType && client.Account.Rank < 2)
{
log.FatalFormat("{0} is trying to cheat (Weapon doesnt match the slot type)", client.Player.Name);
client.Player.SendError("This cheating attempt has beed logged and a message was send to all online admins.");
client.Disconnect();
foreach (Player player in client.Player.Owner.Players.Values)
{
if (player.Client.Account.Rank >= 2)
{
player.SendInfo(String.Format("Player {0} is shooting with a weapon that doesnt match the class slot type.", client.Player.Name));
}
}
return;
}
ProjectileDesc prjDesc = item.Projectiles[0]; //Assume only one
Projectile prj = client.Player.PlayerShootProjectile(
packet.BulletId, prjDesc, item.ObjectType,
packet.Time, packet.Position, packet.Angle);
client.Player.Owner.EnterWorld(prj);
client.Player.BroadcastSync(new AllyShootPacket
{
OwnerId = client.Player.Id,
Angle = packet.Angle,
ContainerType = packet.ContainerType,
BulletId = packet.BulletId,
}, p => p != client.Player && client.Player.Dist(p) < 25);
client.Player.FameCounter.Shoot(prj);
}, PendingPriority.Networking);
}
internal Projectile PlayerShootProjectile(
byte id, ProjectileDesc desc, ushort objType,
int time, Position position, float angle)
{
projectileId = id;
var dmg = (int)Stats.GetAttackDamage(Stats[8], Stats[9]);
return(CreateProjectile(desc, objType, dmg,
C2STime(time), position, angle));
}
protected override void HandlePacket(Client client, PlayerShootPacket packet)
{
client.Manager.Logic.AddPendingAction(t =>
{
if (client.Player.Owner == null)
{
return;
}
OldItem item = client.Player.Manager.GameData.Items[(ushort)packet.ContainerType];
int stype = 0;
for (int i = 0; i < 4; i++)
{
if (client.Player.Inventory[i]?.ObjectType == packet.ContainerType)
{
stype = i;
break;
}
}
if (item == Client.Player.SerialConvert(Client.Player.Inventory[1]))
{
return; // ability shoot handled by useitem implement ability check
}
if (client.Player.SlotTypes[stype] != item.SlotType)
{
Client.Player.kickforCheats(Player.possibleExploit.DIFF_WEAPON);
return;
}
if ((Client.Stage != ProtocalStage.Disconnected) && (!Client.Player.CheckShootSpeed(item)))
{
return;
}
if (Client.Stage == ProtocalStage.Disconnected)
{
return;
}
ProjectileDesc prjDesc = item.Projectiles[0]; //Assume only one
Projectile prj = client.Player.PlayerShootProjectile(
packet.BulletId, prjDesc, item.ObjectType,
packet.Time, packet.Position, packet.Angle);
client.Player.Owner.EnterWorld(prj);
client.Player.BroadcastSync(new AllyShootPacket
{
OwnerId = client.Player.Id,
Angle = packet.Angle,
ContainerType = packet.ContainerType,
BulletId = packet.BulletId
}, p => p != client.Player && client.Player.Dist(p) < 25);
client.Player.FameCounter.Shoot(prj);
}, PendingPriority.Networking);
}
protected override bool TickCore(RealmTime time)
{
if (Host.Self.HasConditionEffect(ConditionEffects.Stunned))
{
return(false);
}
int numShot = this.numShot;
if (Host.Self.HasConditionEffect(ConditionEffects.Dazed))
{
numShot = Math.Max(1, numShot / 2);
}
float dist = radius;
Entity player = GetNearestEntityPet(ref dist);
if (player != null)
{
var chr = Host as Character;
double startAngle = Math.Atan2(player.Y - chr.Y, player.X - chr.X)
- angle * (numShot - 1) / 2
+ offset;
ProjectileDesc desc = chr.ObjectDesc.Projectiles[projectileIndex];
byte prjId = 0;
var prjPos = new Position {
X = chr.X, Y = chr.Y
};
int dmg = chr.Random.Next(desc.MinDamage, desc.MaxDamage);
for (int i = 0; i < numShot; i++)
{
Projectile prj = chr.CreateProjectile(
desc, chr.ObjectType, dmg, time.tickTimes,
prjPos, (float)(startAngle + angle * i));
chr.Owner.EnterWorld(prj);
if (i == 0)
{
prjId = prj.ProjectileId;
}
}
chr.Owner.BroadcastPacket(new MultiShootPacket
{
BulletId = prjId,
OwnerId = Host.Self.Id,
BulletType = (byte)desc.BulletType,
Position = prjPos,
Angle = (float)startAngle,
Damage = (short)dmg,
NumShots = (byte)numShot,
AngleIncrement = angle,
}, null);
return(true);
}
return(false);
}
public Projectile(Entity owner, ProjectileDesc desc, int id, int time, float angle, Position startPos, int damage)
{
Owner = owner;
Desc = desc;
Id = id;
Time = time;
Angle = MathUtils.BoundToPI(angle);
StartPosition = startPos;
Damage = damage;
Hit = new HashSet <int>();
}
protected override bool TickCore(RealmTime time)
{
if (Host.Self.HasConditionEffect(ConditionEffects.Stunned))
{
return(false);
}
float dist = radius;
Entity entity = GetNearestEntityPet(ref dist);
if (entity != null)
{
var chr = Host as Character;
ProjectileDesc desc = chr.ObjectDesc.Projectiles[projectileIndex];
double angle = Math.Atan2(entity.Y - chr.Y, entity.X - chr.X) + Predict(entity, desc);
Projectile prj = chr.CreateProjectile(
desc, chr.ObjectType, chr.Random.Next(desc.MinDamage, desc.MaxDamage),
time.tickTimes, new Position {
X = chr.X, Y = chr.Y
}, (float)angle);
chr.Owner.EnterWorld(prj);
if (projectileIndex == 0) //(false)
{
chr.Owner.BroadcastPacket(new ShootPacket
{
BulletId = prj.ProjectileId,
OwnerId = Host.Self.PlayerOwner.Id,
ContainerType = Host.Self.ObjectType,
Position = prj.BeginPos,
Angle = prj.Angle,
Damage = (short)prj.Damage
}, null);
}
else
{
chr.Owner.BroadcastPacket(new MultiShootPacket
{
BulletId = prj.ProjectileId,
OwnerId = Host.Self.Id,
Position = prj.BeginPos,
Angle = prj.Angle,
Damage = (short)prj.Damage,
BulletType = (byte)(desc.BulletType),
AngleIncrement = 0,
NumShots = 1,
}, null);
}
return(true);
}
return(false);
}
private static double Predict(Entity host, Entity target, ProjectileDesc desc)
{
Position? history = target.TryGetHistory(100);
if (history == null)
return 0;
double originalAngle = Math.Atan2(history.Value.Y - host.Y, history.Value.X - host.X);
double newAngle = Math.Atan2(target.Y - host.Y, target.X - host.X);
float bulletSpeed = desc.Speed / 100;
double angularVelo = (newAngle - originalAngle) / (100 / 1000f);
return angularVelo * bulletSpeed;
}
protected override bool TickCore(RealmTime time)
{
if (Host.Self.HasConditionEffect(ConditionEffects.Stunned))
{
return(false);
}
var chr = Host as Character;
if (chr.Owner == null)
{
return(false);
}
ProjectileDesc desc = chr.ObjectDesc.Projectiles[projectileIndex];
Projectile prj = chr.CreateProjectile(
desc, chr.ObjectType, chr.Random.Next(desc.MinDamage, desc.MaxDamage),
time.tickTimes, new Position {
X = chr.X, Y = chr.Y
}, angle);
chr.Owner.EnterWorld(prj);
if (projectileIndex == 0) //(false)
{
chr.Owner.BroadcastPacket(new ShootPacket
{
BulletId = prj.ProjectileId,
OwnerId = Host.Self.Id,
ContainerType = Host.Self.ObjectType,
Position = prj.BeginPos,
Angle = prj.Angle,
Damage = (short)prj.Damage
}, null);
}
else
{
chr.Owner.BroadcastPacket(new MultiShootPacket
{
BulletId = prj.ProjectileId,
OwnerId = Host.Self.Id,
Position = prj.BeginPos,
Angle = prj.Angle,
Damage = (short)prj.Damage,
BulletType = (byte)(desc.BulletType),
AngleIncrement = 0,
NumShots = 1,
}, null);
}
return(true);
}
private double Predict(Entity entity, ProjectileDesc desc)
{
var history = entity.TryGetHistory(100);
if (history == null)
return 0;
var originalAngle = Math.Atan2(history.Value.Y - Host.Self.Y, history.Value.X - Host.Self.X);
var newAngle = Math.Atan2(entity.Y - Host.Self.Y, entity.X - Host.Self.X);
var bulletSpeed = desc.Speed / 100f;
var dist = Dist(entity, Host.Self);
var angularVelo = (newAngle - originalAngle) / (100 / 1000f);
return angularVelo * bulletSpeed;
}
protected override void HandlePacket(Client client, PlayerShootPacket packet)
{
client.Manager.Logic.AddPendingAction(t =>
{
if (client.Player.Owner == null)
{
return;
}
Item item = client.Player.Manager.GameData.Items[(ushort)packet.ContainerType];
int stype = 0;
for (int i = 0; i < 4; i++)
{
if (client.Player.Inventory[i]?.ObjectType == packet.ContainerType)
{
stype = i;
break;
}
}
if (client.Player.SlotTypes[stype] != item.SlotType && client.Account.Rank < 2)
{
Console.WriteLine($"{client.Player.Name} is trying to cheat (Weapon doesnt match the slot type)");
client.Player.SendError("This cheating attempt has been logged and a message was send to all online admins.");
client.Disconnect();
foreach (Player player in client.Player.Owner.Players.Values)
{
if (player.Client.Account.Rank >= 2)
{
player.SendInfo($"Player {client.Player.Name} is shooting with a weapon that doesnt match the class slot type.");
}
}
return;
}
ProjectileDesc prjDesc = item.Projectiles[0]; //Assume only one
Projectile prj = client.Player.PlayerShootProjectile(
packet.BulletId, prjDesc, item.ObjectType,
packet.Time, packet.Position, packet.Angle);
client.Player.Owner.EnterWorld(prj);
client.Player.BroadcastSync(new AllyShootPacket
{
OwnerId = client.Player.Id,
Angle = packet.Angle,
ContainerType = packet.ContainerType,
BulletId = packet.BulletId
}, p => p != client.Player && client.Player.Dist(p) < 25);
client.Player.FameCounter.Shoot(prj);
}, PendingPriority.Networking);
}
internal Projectile PlayerShootProjectile(
byte id, ProjectileDesc desc, ushort objType,
int time, Position position, float angle)
{
if (StatsManager.GetAttackDamage(desc.MinDamage, desc.MaxDamage) > 2100 && Client.Account.Rank < 2)
{
Client.Player.SendError(Client.Player.Name + " stop using modified client.");
Client.Disconnect();
}
ProjectileId = id;
return(CreateProjectile(desc, objType, (int)StatsManager.GetAttackDamage(desc.MinDamage, desc.MaxDamage), time, position, angle));
}
private static float Predict(Entity host, Entity target, ProjectileDesc desc)
{
/*
* // new test prediction method
* const float msPast = 400;
* const long ticks = 4; // ticks equivalent to 400 ms
* var history = target.TryGetHistory(ticks);
* if (history == null)
* return 0;
*
* var position = new Vector2(target.X - host.X, target.Y - host.Y);
* var pastPosition = new Vector2(history.Value.X - host.X, history.Value.Y - host.Y);
* var relativeVelocity = Vector2.Subtract(position / msPast, pastPosition / msPast);
* var bulletSpeed = desc.Speed / 10000f;
*
* var futureHitTime = CollisionTime(position, relativeVelocity, bulletSpeed);
* if (futureHitTime > 0f)
* {
* var relativePosX = target.X + futureHitTime * relativeVelocity.X - host.X;
* var relativePosY = target.Y + futureHitTime * relativeVelocity.Y - host.Y;
*
* return (float) Math.Atan2(relativePosY, relativePosX) -
* (float) Math.Atan2(position.Y, position.X);
* }
*
* return 0;
*/
// trying prod prediction
const int PREDICT_NUM_TICKS = 4; // magic determined by experiement
var history = target.TryGetHistory(1);
if (history == null)
{
return((float)Math.Atan2(target.Y - host.Y, target.X - host.X));
}
var targetX = target.X + PREDICT_NUM_TICKS *
(target.X - history.Value.X);
var targetY = target.Y + PREDICT_NUM_TICKS *
(target.Y - history.Value.Y);
float angle = (float)Math.Atan2(targetY - host.Y, targetX - host.X);
return(angle);
}
private static double Predict(Entity host, Entity target, ProjectileDesc desc)
{
Position?history = target.TryGetHistory(100);
if (history == null)
{
return(0);
}
double originalAngle = Math.Atan2(history.Value.Y - host.Y, history.Value.X - host.X);
double newAngle = Math.Atan2(target.Y - host.Y, target.X - host.X);
float bulletSpeed = desc.Speed / 100;
double angularVelo = (newAngle - originalAngle) / (100 / 1000f);
return(angularVelo * bulletSpeed);
}
private void Shoot(RealmTime time, Item item, Position target)
{
double arcGap = item.ArcGap * Math.PI / 180;
double startAngle = Math.Atan2(target.Y - Y, target.X - X) - (item.NumProjectiles - 1) / 2 * arcGap;
ProjectileDesc prjDesc = item.Projectiles[0]; //Assume only one
for (int i = 0; i < item.NumProjectiles; i++)
{
Projectile proj = CreateProjectile(prjDesc, item.ObjectType,
(int)StatsManager.GetAttackDamage(prjDesc.MinDamage, prjDesc.MaxDamage),
time.TotalElapsedMs, new Position {
X = X, Y = Y
}, (float)(startAngle + arcGap * i));
Owner?.EnterWorld(proj);
FameCounter.Shoot(proj);
}
}
private double Predict(Entity entity, ProjectileDesc desc)
{
Position?history = entity.TryGetHistory(100);
if (history == null)
{
return(0);
}
var originalAngle = Math.Atan2(history.Value.Y - Host.Self.Y, history.Value.X - Host.Self.X);
var newAngle = Math.Atan2(entity.Y - Host.Self.Y, entity.X - Host.Self.X);
var bulletSpeed = desc.Speed / 100f;
var dist = Dist(entity, Host.Self);
var angularVelo = (newAngle - originalAngle) / (100 / 1000f);
return(angularVelo * bulletSpeed);
}
private static double Predict(Entity host, Entity target, ProjectileDesc desc)
{
var history = target.TryGetHistory(100);
if (history == null)
{
return(0);
}
var originalAngle = Math.Atan2(history.Value.Y - host.Y, history.Value.X - host.X);
var newAngle = Math.Atan2(target.Y - host.Y, target.X - host.X);
var bulletSpeed = desc.Speed / 100f;
var dist = target.Dist(host);
var angularVelo = (newAngle - originalAngle) / (100 / 1000f);
return(angularVelo * bulletSpeed);
}
public Projectile CreateProjectile(ProjectileDesc desc, ushort container, int dmg, long time, Position pos,
float angle)
{
var ret = new Projectile(Manager, desc) //Assume only one
{
ProjectileOwner = this,
ProjectileId = ProjectileId++,
Container = (short)container,
Damage = dmg,
BeginTime = time,
BeginPos = pos,
Angle = angle,
X = pos.X,
Y = pos.Y
};
if (projectiles[ret.ProjectileId] != null)
projectiles[ret.ProjectileId].Destroy(true);
projectiles[ret.ProjectileId] = ret;
return ret;
}
protected override bool TickCore(RealmTime time)
{
if (Host.Self.HasConditionEffect(ConditionEffects.Stunned))
{
return(false);
}
var chr = Host as Character;
float startAngle = angle - projAngle * (numShot - 1) / 2;
ProjectileDesc desc = chr.ObjectDesc.Projectiles[projectileIndex];
byte prjId = 0;
var prjPos = new Position {
X = chr.X, Y = chr.Y
};
int dmg = chr.Random.Next(desc.MinDamage, desc.MaxDamage);
for (int i = 0; i < numShot; i++)
{
Projectile prj = chr.CreateProjectile(
desc, chr.ObjectType, dmg, time.tickTimes,
prjPos, startAngle + projAngle * i);
chr.Owner.EnterWorld(prj);
if (i == 0)
{
prjId = prj.ProjectileId;
}
}
chr.Owner.BroadcastPacket(new MultiShootPacket
{
BulletId = prjId,
OwnerId = Host.Self.Id,
BulletType = (byte)desc.BulletType,
Position = prjPos,
Angle = startAngle,
Damage = (short)dmg,
NumShots = (byte)numShot,
AngleIncrement = projAngle,
}, null);
return(true);
}
protected override void BehaveCore(BehaviorCondition cond, RealmTime?time, object state)
{
float dist = 2;
Entity entity = GetNearestEntity(ref dist, null);
if (entity != null)
{
var chr = Host as Character;
double angleInc = (2 * Math.PI) / 12;
ProjectileDesc desc = chr.ObjectDesc.Projectiles[0];
byte prjId = 0;
var prjPos = new Position {
X = chr.X, Y = chr.Y
};
int dmg = chr.Random.Next(desc.MinDamage, desc.MaxDamage);
for (int i = 0; i < 12; i++)
{
Projectile prj = chr.CreateProjectile(
desc, chr.ObjectType, dmg, time.Value.tickTimes,
prjPos, (float)(angleInc * i));
chr.Owner.EnterWorld(prj);
if (i == 0)
{
prjId = prj.ProjectileId;
}
}
chr.Owner.BroadcastPacket(new MultiShootPacket
{
BulletId = prjId,
OwnerId = Host.Self.Id,
BulletType = (byte)desc.BulletType,
Position = prjPos,
Angle = 0,
Damage = (short)dmg,
NumShots = 12,
AngleIncrement = (float)angleInc,
}, null);
chr.Owner.LeaveWorld(chr);
}
}
public Projectile(RealmManager manager, ProjectileDesc desc)
: base(manager, manager.GameData.IdToObjectType[desc.ObjectId])
{
Descriptor = desc;
}
public Projectile(ProjectileDesc desc)
: base(XmlDatas.IdToType[desc.ObjectId])
{
this.Descriptor = desc;
}
public Projectile CreateProjectile(ProjectileDesc desc, short container, int dmg, long time, Position pos, float angle)
{
var ret = new Projectile(desc) //Assume only one
{
ProjectileOwner = this,
ProjectileId = projectileId++,
Container = container,
Damage = dmg,
BeginTime = time,
BeginPos = pos,
Angle = angle,
X = pos.X,
Y = pos.Y
};
if (projectiles[ret.ProjectileId] != null)
projectiles[ret.ProjectileId].Destroy(true);
projectiles[ret.ProjectileId] = ret;
return ret;
}
public Projectile(ProjectileDesc desc)
: base(XmlData.IdToObjectType[desc.ObjectId])
{
Descriptor = desc;
}
static double Predict(Entity host, Entity target, ProjectileDesc desc)
{
Position? history = target.TryGetHistory(100);
if (history == null)
return 0;
var originalAngle = Math.Atan2(history.Value.Y - host.Y, history.Value.X - host.X);
var newAngle = Math.Atan2(target.Y - host.Y, target.X - host.X);
var bulletSpeed = desc.Speed / 100f;
var dist = BehaviorUtils.Dist(target, host);
var angularVelo = (newAngle - originalAngle) / (100 / 1000f);
return angularVelo * bulletSpeed;
}
