public EditorActorPreview(WorldRenderer worldRenderer, string id, ActorReference reference, PlayerReference owner)
{
ID = id;
this.reference = reference;
Owner = owner;
this.worldRenderer = worldRenderer;
if (!reference.Contains <FactionInit>())
{
reference.Add(new FactionInit(owner.Faction));
}
if (!reference.Contains <OwnerInit>())
{
reference.Add(new OwnerInit(owner.Name));
}
var world = worldRenderer.World;
if (!world.Map.Rules.Actors.TryGetValue(reference.Type.ToLowerInvariant(), out Info))
{
throw new InvalidDataException($"Actor {id} of unknown type {reference.Type.ToLowerInvariant()}");
}
CenterPosition = PreviewPosition(world, reference);
var location = reference.Get <LocationInit>().Value;
var ios = Info.TraitInfoOrDefault <IOccupySpaceInfo>();
var subCellInit = reference.GetOrDefault <SubCellInit>();
var subCell = subCellInit != null ? subCellInit.Value : SubCell.Any;
var radarColorInfo = Info.TraitInfoOrDefault <RadarColorFromTerrainInfo>();
RadarColor = radarColorInfo == null ? owner.Color : radarColorInfo.GetColorFromTerrain(world);
Footprint = ios?.OccupiedCells(Info, location, subCell) ?? new Dictionary <CPos, SubCell>()
{
{ location, SubCell.FullCell }
};
tooltip = Info.TraitInfos <EditorOnlyTooltipInfo>().FirstOrDefault(info => info.EnabledByDefault) as TooltipInfoBase
?? Info.TraitInfos <TooltipInfo>().FirstOrDefault(info => info.EnabledByDefault);
DescriptiveName = tooltip != null ? tooltip.Name : Info.Name;
GeneratePreviews();
// Bounds are fixed from the initial render.
// If this is a problem, then we may need to fetch the area from somewhere else
var r = previews.SelectMany(p => p.ScreenBounds(worldRenderer, CenterPosition));
Bounds = r.Union();
SelectionBox = new SelectionBoxAnnotationRenderable(new WPos(CenterPosition.X, CenterPosition.Y, 8192),
new Rectangle(Bounds.X, Bounds.Y, Bounds.Width, Bounds.Height), Color.White);
}
public EditorActorPreview Add(string id, ActorReference reference, bool initialSetup = false)
{
var owner = Players.Players[reference.Get <OwnerInit>().InternalName];
var preview = new EditorActorPreview(worldRenderer, id, reference, owner);
Add(preview, initialSetup);
return(preview);
}
public object GetObjectToSerialize(object obj, Type targetType)
{
if (obj == null)
{
return(null);
}
else if (obj is IActor)
{
return(ActorReference.Get(obj));
}
return(obj);
}
void ILintMapPass.Run(Action <string> emitError, Action <string> emitWarning, ModData modData, Map map)
{
var players = new MapPlayers(map.PlayerDefinitions);
var spawns = new List <CPos>();
foreach (var kv in map.ActorDefinitions.Where(d => d.Value.Value == "mpspawn"))
{
var s = new ActorReference(kv.Value.Value, kv.Value.ToDictionary());
spawns.Add(s.Get <LocationInit>().Value);
}
Run(emitError, emitWarning, players, map.Visibility, map.Rules.Actors[SystemActors.World], spawns.ToArray());
}
/// <summary>
/// Registers this Actor as a subscriber for messages of type <paramref name="messageType"/>.
/// </summary>
/// <returns></returns>
public static async Task RegisterMessageTypeAsync(this ActorBase actor, Type messageType)
{
if (messageType == null)
{
throw new ArgumentNullException(nameof(messageType));
}
if (actor == null)
{
throw new ArgumentNullException(nameof(actor));
}
ActorId actorId = new ActorId(messageType.FullName);
IBrokerActor brokerActor = ActorProxy.Create <IBrokerActor>(actorId, actor.ApplicationName, nameof(IBrokerActor));
await brokerActor.RegisterSubscriberAsync(ActorReference.Get(actor));
}
public static async Task <bool> DeleteActor <T>(this ActorId id, Uri serviceUri = null) where T : IActor
{
CancellationToken token = new CancellationToken();
if (serviceUri == null)
{
serviceUri = ServiceUriHelper.Resolve <T>();
}
var proxy = id.Proxy <T>(serviceUri);
ActorReference actorReference = ActorReference.Get(proxy);
var actorServiceProxy = ActorServiceProxy.Create(actorReference.ServiceUri, id);
await actorServiceProxy.DeleteActorAsync(id, token);
return(await Task.FromResult(true));
}
public override async Task UnregisterMessageAsync(Type type, Uri brokerServiceName = null, bool flushQueue = false)
{
if (brokerServiceName == null)
{
brokerServiceName = await PublisherServiceHelper.DiscoverBrokerServiceNameAsync();
if (brokerServiceName == null)
{
throw new InvalidOperationException("No brokerServiceName was provided or discovered in the current application.");
}
}
var brokerService = await ServiceLocator.GetBrokerServiceForMessageAsync(type.Name, brokerServiceName);
await brokerService.UnregisterSubscriberAsync(ActorReference.Get(ContextWrapper.Context), type.FullName, flushQueue);
}
/// <summary>
/// Unregisters a service as a subscriber for messages of type <paramref name="messageType"/> using a relay broker.
/// </summary>
/// <returns></returns>
private static async Task UnregisterMessageTypeWithRelayBrokerAsync(ServiceContext context, ServicePartitionInformation info, Type messageType, ActorId relayBrokerActorId, ActorId sourceBrokerActorId, bool flushQueue)
{
var serviceReference = CreateServiceReference(context, info);
if (sourceBrokerActorId == null)
{
sourceBrokerActorId = new ActorId(messageType.FullName);
}
IRelayBrokerActor relayBrokerActor = ActorProxy.Create <IRelayBrokerActor>(relayBrokerActorId, serviceReference.ApplicationName, nameof(IRelayBrokerActor));
IBrokerActor brokerActor = ActorProxy.Create <IBrokerActor>(sourceBrokerActorId, serviceReference.ApplicationName, nameof(IBrokerActor));
//register relay as subscriber for broker
await brokerActor.UnregisterSubscriberAsync(ActorReference.Get(relayBrokerActor), flushQueue);
//register caller as subscriber for relay broker
await relayBrokerActor.UnregisterServiceSubscriberAsync(serviceReference, flushQueue);
}
/// <summary>
/// Registers this Actor as a subscriber for messages of type <paramref name="messageType"/> with the <see cref="BrokerService"/>.
/// </summary>
/// <returns></returns>
public async Task RegisterMessageTypeAsync(ActorBase actor, Type messageType, Uri brokerServiceName = null)
{
if (messageType == null)
{
throw new ArgumentNullException(nameof(messageType));
}
if (actor == null)
{
throw new ArgumentNullException(nameof(actor));
}
if (brokerServiceName == null)
{
brokerServiceName = await PublisherServiceHelper.DiscoverBrokerServiceNameAsync();
if (brokerServiceName == null)
{
throw new InvalidOperationException("No brokerServiceName was provided or discovered in the current application.");
}
}
var brokerService = await _brokerServiceLocator.GetBrokerServiceForMessageAsync(messageType.Name, brokerServiceName);
await brokerService.RegisterSubscriberAsync(ActorReference.Get(actor), messageType.FullName);
}
public static async Task UnregisterMessageTypeWithBrokerServiceAsync(this ActorBase actor, Type messageType, bool flushQueue, Uri brokerServiceName = null)
{
if (messageType == null)
{
throw new ArgumentNullException(nameof(messageType));
}
if (actor == null)
{
throw new ArgumentNullException(nameof(actor));
}
if (brokerServiceName == null)
{
brokerServiceName = await PublisherServices.PublisherServiceExtensions.DiscoverBrokerServiceNameAsync(new Uri(actor.ApplicationName));
if (brokerServiceName == null)
{
throw new InvalidOperationException("No brokerServiceName was provided or discovered in the current application.");
}
}
var brokerService = await PublisherActors.PublisherActorExtensions.GetBrokerServiceForMessageAsync(messageType.Name, brokerServiceName);
await brokerService.UnregisterSubscriberAsync(ActorReference.Get(actor), messageType.FullName, flushQueue);
}
public void Run(Action <string> emitError, Action <string> emitWarning, ModData modData, Map map)
{
var players = new MapPlayers(map.PlayerDefinitions).Players;
if (players.Count > 64)
{
emitError("Defining more than 64 players is not allowed.");
}
var worldOwnerFound = false;
var playerNames = players.Values.Select(p => p.Name).ToHashSet();
foreach (var player in players.Values)
{
foreach (var ally in player.Allies)
{
if (!playerNames.Contains(ally))
{
emitError("Allies contains player {0} that is not in list.".F(ally));
}
}
foreach (var enemy in player.Enemies)
{
if (!playerNames.Contains(enemy))
{
emitError("Enemies contains player {0} that is not in list.".F(enemy));
}
}
if (player.OwnsWorld)
{
worldOwnerFound = true;
if (player.Enemies.Any() || player.Allies.Any())
{
emitWarning("The player {0} owning the world should not have any allies or enemies.".F(player.Name));
}
if (player.Playable)
{
emitError("The player {0} owning the world can't be playable.".F(player.Name));
}
}
else if (map.Visibility == MapVisibility.MissionSelector && player.Playable && !player.LockFaction)
{
// Missions must lock the faction of the player to force the server to override the default Random faction
emitError("The player {0} must specify LockFaction: True.".F(player.Name));
}
}
if (!worldOwnerFound)
{
emitError("Found no player owning the world.");
}
var worldActor = map.Rules.Actors[SystemActors.World];
var factions = worldActor.TraitInfos <FactionInfo>().Select(f => f.InternalName).ToHashSet();
foreach (var player in players.Values)
{
if (!string.IsNullOrWhiteSpace(player.Faction) && !factions.Contains(player.Faction))
{
emitError("Invalid faction {0} chosen for player {1}.".F(player.Faction, player.Name));
}
}
if (worldActor.HasTraitInfo <MapStartingLocationsInfo>())
{
var playerCount = players.Count(p => p.Value.Playable);
var spawns = new List <CPos>();
foreach (var kv in map.ActorDefinitions.Where(d => d.Value.Value == "mpspawn"))
{
var s = new ActorReference(kv.Value.Value, kv.Value.ToDictionary());
spawns.Add(s.Get <LocationInit>().Value);
}
if (playerCount > spawns.Count)
{
emitError("The map allows {0} possible players, but defines only {1} spawn points".F(playerCount, spawns.Count));
}
if (spawns.Distinct().Count() != spawns.Count)
{
emitError("Duplicate spawn point locations detected.");
}
}
// Check for actors that require specific owners
var actorsWithRequiredOwner = map.Rules.Actors
.Where(a => a.Value.HasTraitInfo <RequiresSpecificOwnersInfo>())
.ToDictionary(a => a.Key, a => a.Value.TraitInfo <RequiresSpecificOwnersInfo>());
foreach (var kv in map.ActorDefinitions)
{
var actorReference = new ActorReference(kv.Value.Value, kv.Value.ToDictionary());
var ownerInit = actorReference.GetOrDefault <OwnerInit>();
if (ownerInit == null)
{
emitError("Actor {0} is not owned by any player.".F(kv.Key));
}
else
{
var ownerName = ownerInit.InternalName;
if (!playerNames.Contains(ownerName))
{
emitError("Actor {0} is owned by unknown player {1}.".F(kv.Key, ownerName));
}
if (actorsWithRequiredOwner.TryGetValue(kv.Value.Value, out var info))
{
if (!info.ValidOwnerNames.Contains(ownerName))
{
emitError("Actor {0} owner {1} is not one of ValidOwnerNames: {2}".F(kv.Key, ownerName, info.ValidOwnerNames.JoinWith(", ")));
}
}
}
}
}
public T Get <T>(TraitInfo info) where T : ActorInit
{
return(reference.Get <T>(info));
}
protected void Run(Utility utility, string[] args)
{
// HACK: The engine code assumes that Game.modData is set.
Game.ModData = ModData = utility.ModData;
var filename = args[1];
var flag = args[2];
if (string.IsNullOrWhiteSpace(flag))
{
flag = "VH";
}
bool flipHorizontal = flag.Contains("H");
bool flipVertical = flag.Contains("V");
MirrorType mirrorType = MirrorType.Horizontal;
if (flipVertical)
{
mirrorType = MirrorType.Vertical;
}
if (flipHorizontal && flipVertical)
{
mirrorType = MirrorType.HorizontalAndVertical;
}
var targetPath = "..\\mods\\dr\\maps";
var package = new Folder(targetPath).OpenPackage(filename, ModData.ModFiles);
if (package == null)
{
Console.WriteLine("Couldn't find map file: " + filename);
return;
}
Map = new Map(ModData, package);
var size = Map.MapSize;
switch (mirrorType)
{
case MirrorType.Horizontal:
size = size.WithX(size.X / 2);
break;
case MirrorType.Vertical:
size = size.WithY(size.Y / 2);
break;
case MirrorType.HorizontalAndVertical:
size = size / 2;
break;
}
// Tiles
for (int x = 0; x < size.X; x++)
{
for (int y = 0; y < size.Y; y++)
{
var pos = new CPos(x, y);
var transformTile = new TileTransform()
{
Tile = Map.Tiles[pos],
MirrorType = mirrorType,
Position = pos
};
foreach (var tt in transformTile.GetTransforms(Map))
{
var newPos = tt.Position;
Map.Tiles[newPos] = tt.Tile;
}
}
}
// Actors
actorIndex = GetHighestActorIndex();
int multiCount = 0;
var actorDefs = new List <ActorReference>();
var removeActors = new List <MiniYamlNode>();
foreach (var a in Map.ActorDefinitions)
{
var existing = new ActorReference(a.Value.Value, a.Value.ToDictionary());
var pos = existing.GetOrDefault <LocationInit>().Value;
var owner = existing.Get <OwnerInit>();
if (pos.X < 0 || pos.X >= size.X ||
pos.Y < 0 || pos.Y >= size.Y)
{
removeActors.Add(a);
continue;
}
var actor = new ActorTransform()
{
Actor = existing,
Position = pos,
MirrorType = mirrorType,
};
if (actor.Actor.Type == "mpspawn")
{
multiCount++;
}
foreach (var at in actor.GetTransforms(Map))
{
var ar = new ActorReference(actor.Actor.Type)
{
new LocationInit(at.Position),
owner
};
actorDefs.Add(ar);
if (at.Actor.Type == "mpspawn")
{
multiCount++;
}
}
}
foreach (var a in actorDefs)
{
Map.ActorDefinitions.Add(new MiniYamlNode("Actor" + ++actorIndex, a.Save()));
}
foreach (var a in removeActors)
{
Map.ActorDefinitions.Remove(a);
}
if (multiCount > 0)
{
var mapPlayers = new MapPlayers(Map.Rules, multiCount);
Map.PlayerDefinitions = mapPlayers.ToMiniYaml();
}
// Resources
for (int x = 0; x < size.X; x++)
{
for (int y = 0; y < size.Y; y++)
{
var pos = new CPos(x, y);
var resource = new ResourceTransform()
{
Tile = Map.Resources[pos],
MirrorType = mirrorType,
Position = pos
};
foreach (var rt in resource.GetTransforms(Map))
{
var newPos = rt.Position;
Map.Resources[newPos] = rt.Tile;
}
}
}
var dest = Path.Combine(targetPath, Path.GetFileNameWithoutExtension(filename) + ".oramap");
Map.Save(ZipFileLoader.Create(dest));
Console.WriteLine(dest + " saved.");
}
/// <summary>
/// Gets <see cref="ActorReference"/> for the actor.
/// </summary>
/// <param name="actor">Actor object to get ActorReference for.</param>
/// <returns><see cref="ActorReference"/> for the actor.</returns>
public static ActorReference GetActorReference(this IActor actor)
{
return ActorReference.Get(actor);
}
/// <summary>
/// Gets <see cref="ActorId"/> for the actor./>
/// </summary>
/// <typeparam name="TIActor">Actor interface type.</typeparam>
/// <param name="actor">Actor object to get ActorId for.</param>
/// <returns><see cref="ActorId"/> for the actor.</returns>
public static ActorId GetActorId<TIActor>(this TIActor actor)
where TIActor : IActor
{
var r = ActorReference.Get(actor);
return r.ActorId;
}
