private void BattleReinforceAttacker(IBattleManager battle, ICombatGroup combatGroup)
{
var packet = CreatePacket(battle, Command.BattleReinforceAttacker);
PacketHelper.AddToPacket(combatGroup, packet);
channel.Post(channelName, packet);
}
private void ForestInfo(Session session, Packet packet)
{
var reply = new Packet(packet);
uint forestId;
try
{
forestId = packet.GetUInt32();
}
catch (Exception)
{
ReplyError(session, packet, Error.Unexpected);
return;
}
IForest forest;
if (!forestManager.TryGetValue(forestId, out forest))
{
ReplyError(session, packet, Error.ObjectNotFound);
return;
}
locker.Lock(forest).Do(() =>
{
reply.AddUInt32(UnixDateTime.DateTimeToUnix(forest.DepleteTime.ToUniversalTime()));
PacketHelper.AddToPacket(forest.Wood, reply);
});
session.Write(reply);
}
public byte[] GetObjectBytes()
{
while (isDirty)
{
// Players must always be locked first
primaryLock.EnterReadLock();
var playersInRegion = primaryObjects.ToArray <ILockable>();
var currentLastUpdated = regionLastUpdated;
primaryLock.ExitReadLock();
var isDone = lockerFactory().Lock(playersInRegion).Do(() =>
{
// Enter write lock but give up all locks if we cant in 1 second just to be safe
if (!primaryLock.TryEnterWriteLock(1000))
{
return(false);
}
// ReSharper disable ConditionIsAlwaysTrueOrFalse
// ReSharper disable HeuristicUnreachableCode
if (!isDirty)
{
primaryLock.ExitWriteLock();
return(true);
}
// ReSharper restore HeuristicUnreachableCode
// ReSharper restore ConditionIsAlwaysTrueOrFalse
if (currentLastUpdated != regionLastUpdated)
{
primaryLock.ExitWriteLock();
return(false);
}
var dummyPacket = new Packet();
// Write tiles
dummyPacket.AddBytes(map);
// Write objects
dummyPacket.AddUInt16(primaryObjects.Count);
foreach (ISimpleGameObject obj in primaryObjects)
{
PacketHelper.AddToPacket(obj, dummyPacket, true);
}
objects = dummyPacket.GetPayload();
isDirty = false;
primaryLock.ExitWriteLock();
return(true);
});
if (isDone)
{
break;
}
}
return(objects);
}
private void BattleManagerOnGroupUnitAdded(IBattleManager battle,
BattleManager.BattleSide combatObjectSide,
ICombatGroup combatGroup,
ICombatObject combatObject)
{
var packet = CreatePacket(battle, Command.BattleGroupUnitAdded);
packet.AddUInt32(combatGroup.Id);
PacketHelper.AddToPacket(combatObject, packet);
channel.Post(channelName, packet);
}
protected override void UpdateNotification(Notification notification)
{
base.UpdateNotification(notification);
if (Global.Current.FireEvents)
{
var packet = new Packet(Command.NotificationUpdate);
packet.AddUInt32(cityId);
PacketHelper.AddToPacket(notification, packet);
Global.Current.Channel.Post(channelName, packet);
}
}
public void UpdateObject(ISimpleGameObject sender, uint origX, uint origY)
{
if (!sender.InWorld)
{
throw new Exception(string.Format("Received update for obj that is not in world: eventOrigX[{1}] eventOrigY[{2}] {0}",
sender.ToString(),
origX,
origY));
}
var miniMapRegionObject = sender as IMiniMapRegionObject;
if (miniMapRegionObject != null)
{
MiniMapRegions.UpdateObjectRegion(miniMapRegionObject, origX, origY);
}
// Lock regions from both old and new positions
var lockedRegions = LockRegions(GetMultitileRegionIds(sender.PrimaryPosition.X, sender.PrimaryPosition.Y, sender.Size)
.Concat(GetMultitileRegionIds(origX, origY, sender.Size)));
ushort previousPrimaryRegionId = regionLocator.GetRegionIndex(origX, origY);
ushort newPrimaryRegionId = regionLocator.GetRegionIndex(sender);
RemoveFromPrimaryRegionAndAllTiles(sender, origX, origY);
AddToPrimaryRegionAndTiles(sender);
if (previousPrimaryRegionId == newPrimaryRegionId)
{
var packet = new Packet(Command.ObjectUpdate);
packet.AddUInt16(newPrimaryRegionId);
PacketHelper.AddToPacket(sender, packet);
channel.Post("/WORLD/" + newPrimaryRegionId, packet);
}
else
{
var packet = new Packet(Command.ObjectMove);
packet.AddUInt16(previousPrimaryRegionId);
packet.AddUInt16(newPrimaryRegionId);
PacketHelper.AddToPacket(sender, packet);
channel.Post("/WORLD/" + previousPrimaryRegionId, packet);
packet = new Packet(Command.ObjectAdd);
packet.AddUInt16(newPrimaryRegionId);
PacketHelper.AddToPacket(sender, packet);
channel.Post("/WORLD/" + newPrimaryRegionId, packet);
}
UnlockRegions(lockedRegions);
}
private void NewCityUpdate(ICity city)
{
if (city.Owner.Session == null)
{
return;
}
channel.Post(GetChannelName(city), () =>
{
var packet = new Packet(Command.CityNewUpdate);
PacketHelper.AddToPacket(city, packet);
return(packet);
});
}
private void TroopManagerTroopUpdated(ICity city, TroopStubEventArgs args)
{
if (!ShouldUpdate(city))
{
return;
}
channel.Post(GetChannelName(city), () =>
{
var packet = new Packet(Command.TroopUpdated);
packet.AddUInt32(city.Id);
PacketHelper.AddToPacket(args.Stub, packet);
return(packet);
});
}
private void UnitTemplateUnitUpdated(ICity city, EventArgs args)
{
if (!ShouldUpdate(city))
{
return;
}
channel.Post(GetChannelName(city), () =>
{
var packet = new Packet(Command.UnitTemplateUpgraded);
packet.AddUInt32(city.Id);
PacketHelper.AddToPacket(city.Template, packet);
return(packet);
});
}
private void ResourceUpdateEvent(ICity city, EventArgs args)
{
if (!ShouldUpdate(city))
{
return;
}
channel.Post(GetChannelName(city), () =>
{
var packet = new Packet(Command.CityResourcesUpdate);
packet.AddUInt32(city.Id);
PacketHelper.AddToPacket(city.Resource, packet);
return(packet);
});
}
private void ObjectUpdated(ICity city, GameObjectArgs args)
{
if (!ShouldUpdate(city))
{
return;
}
RecalculateValue(city, args.Object);
channel.Post(GetChannelName(city), () =>
{
var packet = new Packet(Command.CityObjectUpdate);
packet.AddUInt16(regionLocator.GetRegionIndex(args.Object));
PacketHelper.AddToPacket(args.Object, packet);
return(packet);
});
}
protected override bool AddNotification(Notification notification)
{
if (base.AddNotification(notification))
{
if (Global.Current.FireEvents)
{
//send add
var packet = new Packet(Command.NotificationAdd);
packet.AddUInt32(cityId);
PacketHelper.AddToPacket(notification, packet);
Global.Current.Channel.Post(channelName, packet);
}
return(true);
}
return(false);
}
private void WorkerActionAdded(ICity city, ActionWorkerEventArgs args)
{
if (!ShouldUpdate(city))
{
return;
}
var passiveAction = args.Stub as PassiveAction;
if (passiveAction != null && !passiveAction.IsVisible)
{
return;
}
channel.Post(GetChannelName(city), () =>
{
var packet = new Packet(Command.ActionStarted);
packet.AddUInt32(city.Id);
PacketHelper.AddToPacket(args.Stub, packet, true);
return(packet);
});
}
public bool Add(ISimpleGameObject obj)
{
if (!AddToPrimaryRegionAndTiles(obj))
{
return(false);
}
// Keeps track of objects that exist in the map
obj.InWorld = true;
RegisterObjectEventListeners(obj);
// Add appropriate objects to the minimap
IMiniMapRegionObject miniMapRegionObject = obj as IMiniMapRegionObject;
if (miniMapRegionObject != null)
{
MiniMapRegions.Add(miniMapRegionObject);
}
// Post to channel
ushort regionId = regionLocator.GetRegionIndex(obj);
channel.Post("/WORLD/" + regionId, () =>
{
var packet = new Packet(Command.ObjectAdd);
packet.AddUInt16(regionId);
PacketHelper.AddToPacket(obj, packet);
return(packet);
});
// Raise event
ObjectAdded.Raise(this, new ObjectEvent(obj));
return(true);
}
private void Subscribe(Session session, Packet packet)
{
uint battleId;
try
{
battleId = packet.GetUInt32();
}
catch (Exception)
{
ReplyError(session, packet, Error.Unexpected);
return;
}
IBattleManager battleManager;
if (!world.TryGetObjects(battleId, out battleManager))
{
ReplyError(session, packet, Error.BattleNotViewable);
return;
}
CallbackLock.CallbackLockHandler lockHandler = delegate
{
var toBeLocked = new List <ILockable>();
toBeLocked.AddRange(battleManager.LockList);
return(toBeLocked.ToArray());
};
locker.Lock(lockHandler, null, session.Player).Do(() =>
{
IEnumerable <string> errorParams;
var canWatchBattle = battleManager.CanWatchBattle(session.Player, out errorParams);
if (!Config.battle_instant_watch && canWatchBattle != Error.Ok)
{
packet = ReplyError(session, packet, canWatchBattle, false);
packet.AddByte((byte)errorParams.Count());
foreach (var errorParam in errorParams)
{
packet.AddString(errorParam);
}
session.Write(packet);
return;
}
var reply = new Packet(packet);
reply.AddByte((byte)battleManager.Location.Type);
reply.AddUInt32(battleManager.Location.Id);
reply.AddString(battleManager.Location.GetName());
reply.AddUInt32(battleManager.Round);
// Battle properties
PacketHelper.AddBattleProperties(battleManager.ListProperties(), reply);
PacketHelper.AddToPacket(battleManager.Attackers, reply);
PacketHelper.AddToPacket(battleManager.Defenders, reply);
try
{
Global.Current.Channel.Subscribe(session, "/BATTLE/" + battleManager.BattleId);
}
catch (DuplicateSubscriptionException)
{
}
session.Write(reply);
});
}