/// <summary>
/// Unregisters an entity on this instance of a map
/// </summary>
/// <param name="entity"></param>
public void RemoveEntity(IWorldEntity entity)
{
Contract.Requires(entity != null);
_entityQuadTree.RemoveEntity(entity);
_entityLookup.Remove(entity.Guid);
}
/// <inheritdoc />
public void SendSpecialEffect(IWorldEntity entity, int specialEffectId, bool sfxNoFollow)
{
if (entity is IPlayerEntity playerEntity)
{
if (playerEntity.PlayerData.Mode.HasFlag(ModeType.TRANSPARENT_MODE))
{
return;
}
}
using var packet = new FFPacket();
packet.StartNewMergedPacket(entity.Id, SnapshotType.CREATESFXOBJ);
packet.Write(specialEffectId);
if (sfxNoFollow)
{
packet.Write(entity.Object.Position.X); // X
packet.Write(entity.Object.Position.Y); // Y
packet.Write(entity.Object.Position.Z); // Z
}
else
{
packet.Write(0f); // X
packet.Write(0f); // Y
packet.Write(0f); // Z
}
packet.Write(false); // Flag
SendToVisible(packet, entity, sendToPlayer: true);
}
public bool RemoveEntity(IWorldEntity entity)
{
Contract.Requires(entity != null);
if (IsLeaf)
{
// ReSharper disable PossibleNullReferenceException
_entities.Remove(entity.Guid);
// ReSharper restore PossibleNullReferenceException
entity.PostAsync(() => entity.Node = null);
return(true);
}
// ReSharper disable PossibleNullReferenceException
var pos = entity.Position;
// ReSharper restore PossibleNullReferenceException
for (var i = 0; i < 2; i++)
{
for (var j = 0; j < 2; j++)
{
var node = _children[i, j];
if (node.Bounds.Contains(pos) != ContainmentType.Contains)
{
continue;
}
return(node.RemoveEntity(entity));
}
}
return(false);
}
/// <summary>
/// Registers an entity on this instance of a map
/// </summary>
/// <param name="entity"></param>
public void AddEntity(IWorldEntity entity)
{
Contract.Requires(entity != null);
_entityQuadTree.AddEntity(entity);
_entityLookup.Add(entity.Guid, entity);
}
/// <inheritdoc />
public void DropGold(IWorldEntity entity, int goldAmount, IWorldEntity owner)
{
int goldItemId = DefineItem.II_GOLD_SEED1;
int gold = goldAmount * _worldServerConfiguration.Rates.Gold;
if (gold <= 0)
{
return;
}
if (gold > (DropGoldLimit1 * _worldServerConfiguration.Rates.Gold))
{
goldItemId = DefineItem.II_GOLD_SEED2;
}
else if (gold > (DropGoldLimit2 * _worldServerConfiguration.Rates.Gold))
{
goldItemId = DefineItem.II_GOLD_SEED3;
}
else if (gold > (DropGoldLimit3 * _worldServerConfiguration.Rates.Gold))
{
goldItemId = DefineItem.II_GOLD_SEED4;
}
DropItem(entity, new Item(goldItemId, gold), owner);
}
/// <summary>
/// Registers an entity on this instance of a map
/// </summary>
/// <param name="entity"></param>
public void AddEntity(IWorldEntity entity)
{
Contract.Requires(entity != null);
_entityQuadTree.AddEntity(entity);
_entityLookup.Add(entity.Guid, entity);
}
public bool RemoveEntity(IWorldEntity entity)
{
Contract.Requires(entity != null);
if (IsLeaf)
{
_entities.Remove(entity.Guid);
entity.PostAsync(() => entity.Node = null);
return(true);
}
var pos = entity.Position;
for (var i = 0; i < 2; i++)
{
for (var j = 0; j < 2; j++)
{
var node = _children[i, j];
if (node.Bounds.Contains(pos) != ContainmentType.Contains)
{
continue;
}
return(node.RemoveEntity(entity));
}
}
return(false);
}
/// <summary>
/// Unregisters an entity on this instance of a map
/// </summary>
/// <param name="entity"></param>
public void RemoveEntity(IWorldEntity entity)
{
Contract.Requires(entity != null);
_entityQuadTree.RemoveEntity(entity);
_entityLookup.Remove(entity.Guid);
}
/// <summary>
/// Updates the player's visibility.
/// </summary>
/// <param name="worldEntity">Current entity.</param>
/// <param name="entities">Entities</param>
private void UpdateVisibility(IWorldEntity worldEntity, IReadOnlyDictionary <uint, IWorldEntity> entities)
{
foreach (var entity in entities)
{
if (entity.Key == worldEntity.Id)
{
continue;
}
IWorldEntity otherEntity = entity.Value;
bool canSee = worldEntity.Object.Position.IsInCircle(otherEntity.Object.Position, VisibilityRange);
if (canSee && otherEntity.Object.Spawned)
{
if (!worldEntity.Object.Entities.Contains(otherEntity))
{
SpawnOtherEntity(worldEntity, otherEntity);
}
}
else
{
if (worldEntity.Object.Entities.Contains(otherEntity))
{
DespawnOtherEntity(worldEntity, otherEntity);
}
}
}
}
private void saveEntity(IWorldEntity ent, FileInfo file)
{
using (FileStream fs = new FileStream(file.FullName, FileMode.Create))
{
var serializer = new XmlSerializer(ent.GetType());
serializer.Serialize(fs, ent);
}
}
/// <inheritdoc />
public void SendDespawnObjectTo(IPlayerEntity player, IWorldEntity entityToDespawn)
{
using var packet = new FFPacket();
packet.StartNewMergedPacket(entityToDespawn.Id, SnapshotType.DEL_OBJ);
SendToPlayer(player, packet);
}
/// <inheritdoc />
public void SendChatTo(IWorldEntity fromEntity, IPlayerEntity toPlayer, string message)
{
using var packet = new FFPacket();
packet.StartNewMergedPacket(fromEntity.Id, SnapshotType.CHAT);
packet.Write(message);
SendToPlayer(toPlayer, packet);
}
/// <inheritdoc />
public void SendSpeedFactor(IWorldEntity entity, float speedFactor)
{
using var packet = new FFPacket();
packet.StartNewMergedPacket(entity.Id, SnapshotType.SET_SPEED_FACTOR);
packet.Write(speedFactor);
SendToVisible(packet, entity);
}
/// <inheritdoc />
public void SendMotion(IWorldEntity entity, ObjectMessageType objectMessage)
{
using var packet = new FFPacket();
packet.StartNewMergedPacket(entity.Id, SnapshotType.MOTION);
packet.Write((int)objectMessage);
SendToVisible(packet, entity, sendToPlayer: true);
}
/// <inheritdoc />
public void Follow(ILivingEntity livingEntity, IWorldEntity targetEntity, float distance = 1f)
{
livingEntity.Follow.Target = targetEntity;
livingEntity.Moves.DestinationPosition.Copy(targetEntity.Object.Position);
livingEntity.Object.MovingFlags &= ~ObjectState.OBJSTA_STAND;
livingEntity.Object.MovingFlags |= ObjectState.OBJSTA_FMOVE;
_moverPacketFactory.SendFollowTarget(livingEntity, targetEntity, distance);
}
/// <inheritdoc />
public void SendDestinationAngle(IWorldEntity entity, bool left)
{
using var packet = new FFPacket();
packet.StartNewMergedPacket(entity.Id, SnapshotType.DESTANGLE);
packet.Write(entity.Object.Angle);
packet.Write(left);
SendToVisible(packet, entity);
}
/// <inheritdoc />
public void SendUpdateAttributes(IWorldEntity entity, DefineAttributes attribute, int newValue)
{
using var packet = new FFPacket();
packet.StartNewMergedPacket(entity.Id, SnapshotType.SETPOINTPARAM);
packet.Write((int)attribute);
packet.Write(newValue);
SendToVisible(packet, entity, true);
}
/// <inheritdoc />
public void Execute(IWorldEntity worldEntity)
{
if (!worldEntity.Object.Spawned || worldEntity.Type != WorldEntityType.Player)
{
return;
}
UpdateVisibility(worldEntity, worldEntity.Object.CurrentMap.Entities);
UpdateVisibility(worldEntity, worldEntity.Object.CurrentLayer.Entities);
}
/// <inheritdoc />
public void SendMoverPosition(IWorldEntity entity)
{
using var packet = new FFPacket();
packet.StartNewMergedPacket(entity.Id, SnapshotType.SETPOS);
packet.Write(entity.Object.Position.X);
packet.Write(entity.Object.Position.Y);
packet.Write(entity.Object.Position.Z);
SendToVisible(packet, entity, sendToPlayer: true);
}
/// <inheritdoc />
public IBehavior GetDefaultBehavior(BehaviorType type, IWorldEntity entity)
{
BehaviorEntryCache behaviorEntry = GetBehaviorEntry(type, x => x.IsDefault);
if (behaviorEntry == null)
{
throw new ArgumentNullException(nameof(behaviorEntry), $"Cannot find default behavior for type {type}.");
}
return(CreateBehaviorInstance(behaviorEntry, entity));
}
/// <inheritdoc />
public void SendMoverPositionAngle(IWorldEntity entity, bool sendOwnPlayer = true)
{
using var packet = new FFPacket();
packet.StartNewMergedPacket(entity.Id, SnapshotType.SETPOSANGLE);
packet.Write(entity.Object.Position.X);
packet.Write(entity.Object.Position.Y);
packet.Write(entity.Object.Position.Z);
packet.Write(entity.Object.Angle);
SendToVisible(packet, entity, sendToPlayer: sendOwnPlayer);
}
public ScreenSpaceText(string text, Color textClr, string fontFace,
FontWeight fontWeight, int fontSize,
Vector3 worldPos, IWorldEntity dependancy)
{
this.text = text;
this.textClr = textClr;
this.fontFace = fontFace;
this.fontWeight = fontWeight;
this.fontSize = fontSize;
this.worldPos = worldPos;
Dependancy = dependancy;
}
/// <inheritdoc />
public void SendUseSkill(ILivingEntity player, IWorldEntity target, SkillInfo skill, int castingTime, SkillUseType skillUseType)
{
using var packet = new FFPacket();
packet.StartNewMergedPacket(player.Id, SnapshotType.USESKILL);
packet.Write(skill.SkillId);
packet.Write(skill.Level);
packet.Write(target.Id);
packet.Write((int)skillUseType);
packet.Write(castingTime);
SendToVisible(packet, player, sendToPlayer: true);
}
/// <inheritdoc />
public void SetStateModeBaseMotion(IWorldEntity entity, StateModeBaseMotion motionState, Item item = null)
{
if (motionState == StateModeBaseMotion.BASEMOTION_ON)
{
entity.Object.StateMode |= StateMode.BASEMOTION_MODE;
}
else
{
entity.Object.StateMode &= ~StateMode.BASEMOTION_MODE;
}
_moverPacketFactory.SendStateMode(entity, motionState, item);
}
// Returns child node that should contain entity,
// BASED ON POSITION ONLY
private DynamicQuadTree GetChildContaining(IWorldEntity e)
{
Contract.Requires(e != null);
Contract.Ensures(Contract.Result<DynamicQuadTree>() != null);
DynamicQuadTree node = null;
foreach (var child in _childNodes)
// ReSharper disable PossibleNullReferenceException
if (child.Boundaries.Contains(e.Position).Equals(ContainmentType.Contains))
// ReSharper restore PossibleNullReferenceException
node = child;
return node;
}
public ScreenSpaceText(string text, Color textClr, string fontFace,
FontWeight fontWeight, int fontSize,
Vector3 worldPos, IWorldEntity dependancy)
{
this.text = text;
this.textClr = textClr;
this.fontFace = fontFace;
this.fontWeight = fontWeight;
this.fontSize = fontSize;
this.worldPos = worldPos;
Dependancy = dependancy;
}
public void SpawnWorldEntity(Coords location, IWorldEntity entity)
{
switch (entity)
{
case IStructure <IStructureDef> structure:
SpawnStructure(location, structure);
break;
case UnitController unit:
SpawnUnit(unit, location);
break;
}
}
/// <summary>
/// Despawns the other entity for the current entity.
/// </summary>
/// <param name="entity">Current entity</param>
/// <param name="otherEntity">other entity</param>
private void DespawnOtherEntity(IWorldEntity entity, IWorldEntity otherEntity)
{
if (entity is IPlayerEntity player)
{
_worldSpawnPacketFactory.SendDespawnObjectTo(player, otherEntity);
}
entity.Object.Entities.Remove(otherEntity);
if (otherEntity.Type != WorldEntityType.Player && otherEntity.Object.Entities.Contains(entity))
{
otherEntity.Object.Entities.Remove(entity);
}
}
/// <inheritdoc />
public void SendStateMode(IWorldEntity entity, StateModeBaseMotion flags, Item item = null)
{
using var packet = new FFPacket();
packet.StartNewMergedPacket(entity.Id, SnapshotType.STATEMODE);
packet.Write((int)entity.Object.StateMode);
packet.Write((byte)flags);
if (flags == StateModeBaseMotion.BASEMOTION_ON && item != null)
{
packet.Write(item.Id);
}
SendToVisible(packet, entity, sendToPlayer: true);
}
// Returns child node that should contain entity,
// BASED ON POSITION ONLY
private DynamicQuadTree GetChildContaining(IWorldEntity e)
{
Contract.Requires(e != null);
Contract.Ensures(Contract.Result <DynamicQuadTree>() != null);
DynamicQuadTree node = null;
foreach (var child in childNodes)
{
if (child.Boundaries.Contains(e.Position).Equals(ContainmentType.Contains))
{
node = child;
}
}
return(node);
}
/// <inheritdoc />
public void DropItem(IWorldEntity entity, ItemDescriptor item, IWorldEntity owner, int quantity = 1)
{
Item droppedItem = _itemFactory.CreateItem(item.Id, item.Refine, item.Element, item.ElementRefine);
IItemEntity newItem = _itemFactory.CreateItemEntity(entity.Object.CurrentMap, entity.Object.CurrentLayer, droppedItem, owner);
newItem.Drop.Item.Quantity = quantity;
newItem.Object.Position = Vector3.GetRandomPositionInCircle(entity.Object.Position, DropCircleRadius);
if (newItem.Drop.HasOwner)
{
newItem.Drop.OwnershipTime = Time.TimeInSeconds() + _worldServerConfiguration.Drops.OwnershipTime;
newItem.Drop.DespawnTime = Time.TimeInSeconds() + _worldServerConfiguration.Drops.DespawnTime;
}
owner.Object.CurrentLayer.AddEntity(newItem);
}
/// <summary>
/// Sends the packet to all visible entities of the specified entity.
/// </summary>
/// <param name="packet">Packet to send.</param>
/// <param name="entity">Entity.</param>
/// <param name="sendToPlayer">Send packet to player if entity is a player.</param>
public void SendToVisible(INetPacketStream packet, IWorldEntity entity, bool sendToPlayer = false)
{
IEnumerable <IPlayerEntity> visiblePlayers = from x in entity.Object.Entities
where x.Type == WorldEntityType.Player
select x as IPlayerEntity;
foreach (IPlayerEntity visiblePlayer in visiblePlayers)
{
visiblePlayer.Connection.Send(packet);
}
if (sendToPlayer && entity is IPlayerEntity player)
{
player.Connection.Send(packet);
}
}
/// <inheritdoc />
public void DespawnEntity(IWorldEntity worldEntity)
{
foreach (IWorldEntity entity in worldEntity.Object.Entities)
{
if (entity.Object.Entities.Contains(worldEntity))
{
if (entity.Type == WorldEntityType.Player)
{
_worldSpawnPacketFactory.SendDespawnObjectTo(entity as IPlayerEntity, worldEntity);
}
entity.Object.Entities.Remove(worldEntity);
}
}
worldEntity.Object.Entities.Clear();
}
// Returns child node that should contain entity,
// BASED ON POSITION ONLY
private DynamicQuadTree GetChildContaining(IWorldEntity e)
{
Contract.Requires(e != null);
Contract.Ensures(Contract.Result <DynamicQuadTree>() != null);
DynamicQuadTree node = null;
foreach (var child in _childNodes)
{
// ReSharper disable PossibleNullReferenceException
if (child.Boundaries.Contains(e.Position).Equals(ContainmentType.Contains))
{
// ReSharper restore PossibleNullReferenceException
node = child;
}
}
return(node);
}
public bool AddEntity(IWorldEntity entity)
{
if (!_isLeaf)
{
var node = GetChildContaining(entity);
_numEntities++;
return node.AddEntity(entity);
}
if (_bucket.Count < _partitionThreshold)
{
_bucket.Add(entity);
entity.PostAsync(() => entity.Node = this);
return true;
}
Partition();
return AddEntity(entity);
}
public bool RemoveEntity(IWorldEntity entity)
{
if (_isLeaf)
{
_bucket.Remove(entity);
entity.PostAsync(() => entity.Node = null);
if (Parent != null)
Parent.BalanceIfNeeded();
return true;
}
// Yeah, now we need to check if our children have it, and pass it on
var node = GetChildContaining(entity);
_numEntities--;
return node.RemoveEntity(entity);
}
public void RemoveChild(IWorldEntity child)
{
throw new NotImplementedException();
}
