public static ITexture Load(ICoreFactory factory, MetaFontId id, ITexture regular, ITexture bold)
{
var texture = (EightBitTexture)(id.IsBold ? bold : regular);
var bytes = (byte[])texture.TextureData.Clone();
if (!Mappings.TryGetValue(id.Color, out var mapping))
{
mapping = Mappings[FontColor.White];
}
for (int i = 0; i < bytes.Length; i++)
{
if (bytes[i] == 0)
{
continue;
}
bytes[i] = mapping[bytes[i]];
}
return(factory.CreateEightBitTexture(
$"Font{id.Color}{(id.IsBold ? "Bold" : "")}",
texture.Width, texture.Height,
texture.MipLevels, texture.ArrayLayers,
bytes, texture.SubImages));
}
public object Process(ICoreFactory factory, AssetKey key, object asset, Func <AssetKey, object> loaderFunc)
{
switch (asset)
{
case CharacterSheet sheet: ResolveItemProxies(sheet.Inventory, loaderFunc); break;
case Inventory x: ResolveItemProxies(x, loaderFunc); break;
case SavedGame save:
foreach (var sheet in save.PartyMembers.Values)
{
ResolveItemProxies(sheet.Inventory, loaderFunc);
}
foreach (var inv in save.Chests.Values)
{
ResolveItemProxies(inv, loaderFunc);
}
foreach (var inv in save.Merchants.Values)
{
ResolveItemProxies(inv, loaderFunc);
}
break;
default: throw new InvalidOperationException($"Unexpected asset type in inventory post processor: {asset}");
}
return(asset);
}
public CommandInterpreter(ICoreFactory coreFactory,
IFragmentFactory fragmentFactory, IRepository poweRepository)
{
this.coreFactory = coreFactory;
this.fragmentFactory = fragmentFactory;
this.powerPlant = poweRepository;
}
public object Process(ICoreFactory factory, AssetId key, object asset)
{
var assets = Resolve <IAssetManager>();
switch (asset)
{
case CharacterSheet sheet: ResolveItemProxies(sheet.Inventory, assets); break;
case Inventory x: ResolveItemProxies(x, assets); break;
case SavedGame save:
foreach (var sheet in save.Sheets.Values)
{
ResolveItemProxies(sheet.Inventory, assets);
}
foreach (var inv in save.Inventories.Values)
{
ResolveItemProxies(inv, assets);
}
break;
default: throw new InvalidOperationException($"Unexpected asset type in inventory post processor: {asset}");
}
return(asset);
}
public VeldridRendererContext(GraphicsDevice graphicsDevice, CommandList commandList, SceneContext sceneContext, ICoreFactory factory)
{
GraphicsDevice = graphicsDevice;
CommandList = commandList;
SceneContext = sceneContext;
Factory = factory;
}
public object Process(ICoreFactory factory, AssetKey key, object asset, Func <AssetKey, object> loaderFunc)
{
var bitmap = (InterlacedBitmap)asset;
return(new TrueColorTexture(
key.ToString(), (uint)bitmap.Width, (uint)bitmap.Height,
bitmap.Palette, bitmap.ImageData));
}
/// <summary>
/// Creates a view model.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns>A new instance of T.</returns>
public T CreateViewModel <T>(IWindowService windowService, ICoreFactory coreFactory) where T : IBaseViewModel
{
var inst = CustomActivator.CreateInstance <T>();
inst.WindowService = windowService;
inst.CoreFactory = coreFactory;
return(inst);
}
public CommonColors(ICoreFactory factory)
{
BorderTexture = factory.CreateEightBitTexture(
"CommonColors",
1, 1, 1, (uint)Palette.Count,
Palette.OrderBy(x => x.Value).Select(x => (byte)x.Key).ToArray(),
Palette.OrderBy(x => x.Value)
.Select(x => new SubImage(Vector2.Zero, Vector2.One, Vector2.One, x.Value))
.ToArray());
}
public PlantController(ICoreIdManager nameManager, ICoreFactory coreFactory, IFragmentFactory fragmentFactory)
{
this.idManager = nameManager;
this.coreFactory = coreFactory;
this.fragmentFactory = fragmentFactory;
this.coresByName = new Dictionary <string, ICore>();
this.RegisterCoreTypes();
this.RegisterFragmentTypes();
}
public object Process(ICoreFactory factory, AssetId key, object asset)
{
if (asset == null)
{
throw new ArgumentNullException(nameof(asset));
}
var bitmap = (InterlacedBitmap)asset;
return(new TrueColorTexture(key,
key.ToString(), (uint)bitmap.Width, (uint)bitmap.Height,
bitmap.Palette, bitmap.ImageData));
}
public CommonColors(ICoreFactory factory)
{
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
BorderTexture = factory.CreateEightBitTexture(
AssetId.None,
"CommonColors",
1, 1, 1, (uint)Palette.Count,
Palette.OrderBy(x => x.Value).Select(x => (byte)x.Key).ToArray(),
Palette.OrderBy(x => x.Value)
.Select(x => new SubImage(Vector2.Zero, Vector2.One, Vector2.One, x.Value))
.ToArray());
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
try
{
ICoreFactory factory = CoreService.Container.GetExportedValue <ICoreFactory>();
IPersonService proxy = factory.CreateClient <IPersonService>();
Persons = proxy.GetPersons();
Logger.Log("persons loaded", Logger.Level.Info);
}
catch (Exception ex)
{
Logger.Log(ex.Message + Environment.NewLine + ex.StackTrace, Logger.Level.Error);
MessageBox.Show(ex.Message + Environment.NewLine + ex.StackTrace + Environment.NewLine.ToString());
}
}
public object Process(ICoreFactory factory, AssetId key, object asset)
{
if (asset == null)
{
throw new ArgumentNullException(nameof(asset));
}
var dict = (IDictionary <(int, GameLanguage), string>)asset;
var result = new Dictionary <int, string>();
var settings = Resolve <IGameplaySettings>();
foreach (var kvp in dict)
{
if (kvp.Key.Item2 == settings.Language)
{
result[kvp.Key.Item1] = kvp.Value;
}
}
return(result);
}
object LoadAssetInternal(AssetKey key)
{
var name = $"{key.Type}.{key.Id}";
try
{
ICoreFactory factory = Resolve <ICoreFactory>();
IAssetLocator locator = GetLocator(key.Type);
var asset = locator.LoadAsset(key, name, LoadAssetCached);
if (asset != null && _postProcessors.TryGetValue(asset.GetType(), out var processor))
{
asset = processor.Process(factory, key, asset, LoadAssetCached);
}
return(asset);
}
catch (Exception e)
{
Raise(new LogEvent(LogEvent.Level.Error, $"Could not load asset {name}: {e}"));
return(e);
}
}
private void AddPerson_Executed(object sender, ExecutedRoutedEventArgs e)
{
using (TransactionScope ts = new TransactionScope())
{
try
{
Person person = new Person()
{
Name = txtName.Text
};
ICoreFactory factory = CoreService.Container.GetExportedValue <ICoreFactory>();
IPersonService proxy = factory.CreateClient <IPersonService>();
int value = proxy.AddPerson(person);
ts.Complete();
}
catch (Exception ex)
{
ts.Dispose();
MessageBox.Show(ex.Message + Environment.NewLine + ex.StackTrace);
}
}
}
public object Process(ICoreFactory factory, AssetKey key, object asset, Func <AssetKey, object> loaderFunc) => new ImageSharpTrueColorTexture(key.ToString(), (Image <Rgba32>)asset);
public TileMap(string name, DrawLayer renderOrder, Vector3 tileSize, uint width, uint height, ICoreFactory factory, IPaletteManager paletteManager)
{
RenderOrder = renderOrder;
TileSize = tileSize;
Width = width;
Height = height;
Tiles = new Tile[width * height];
Floors = factory.CreateMultiTexture("FloorTiles:" + name, paletteManager);
Walls = factory.CreateMultiTexture("WallTiles:" + name, paletteManager);
}
public MetafontBuilder(ICoreFactory factory) => _factory = factory ?? throw new ArgumentNullException(nameof(factory));
public object Process(ICoreFactory factory, AssetId key, object asset) => new ImageSharpTrueColorTexture(key, key.ToString(), (Image <Rgba32>)asset);
public MetaFontLocator(ICoreFactory factory)
{
_factory = factory;
}
public SimulationInitializer(Random seed, ICoreFactory coreFactory, ISectionFactory sectionFactory)
{
this.coreFactory = coreFactory;
this.sectionFactory = sectionFactory;
}
public object Process(ICoreFactory factory, AssetId key, object asset)
{
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
if (asset == null)
{
throw new ArgumentNullException(nameof(asset));
}
var sprite = (AlbionSprite)asset;
SubImage[] subImages;
// TODO: Put exemptions into assets.json
if (key.Type == AssetType.Font || key.Type == AssetType.AutomapGraphics || sprite.UniformFrames && sprite.Frames.Count >= 256)
{
const int buffer = 1;
// For things like tilemaps etc we repack into a texture atlas with buffer pixels.
int srcTileWidth = sprite.Width;
int srcTileHeight = sprite.Height / sprite.Frames.Count;
int destTileWidth = srcTileWidth + buffer * 2;
int destTileHeight = srcTileHeight + buffer * 2;
var(width, height) = GetAtlasSize(destTileWidth, destTileHeight, sprite.Frames.Count);
byte[] pixelData = new byte[width * height];
subImages = new SubImage[sprite.Frames.Count];
int curX = 0;
int curY = 0;
for (int n = 0; n < sprite.Frames.Count; n++)
{
for (int j = 0; j < destTileHeight; j++)
{
for (int i = 0; i < destTileWidth; i++)
{
var sourceX = Math.Clamp(i - buffer, 0, srcTileWidth - buffer);
var sourceY = Math.Clamp(j - buffer, 0, srcTileHeight - buffer) + n * srcTileHeight;
var destX = curX + i;
var destY = curY + j;
pixelData[destY * width + destX] = sprite.PixelData[sourceX + sourceY * srcTileWidth];
}
}
subImages[n] = new SubImage(
new Vector2(curX + buffer, curY + buffer),
new Vector2(sprite.Frames[n].Width, sprite.Frames[n].Height),
new Vector2(width, height),
0);
curX += destTileWidth;
if (curX + destTileWidth > width)
{
curX = 0;
curY += destTileHeight;
}
}
return(factory.CreateEightBitTexture(
key,
sprite.Name,
(uint)width,
(uint)height,
1,
1,
pixelData,
subImages));
}
/*
* else if (sprite.UniformFrames) // For reasonably sized uniform sprites use layers to simplify mip mapping / tiling etc
* {
* int tileWidth = sprite.Width;
* int tileHeight = sprite.Height / sprite.Frames.Count;
* subImages = sprite.Frames
* .Select((x, i) => new EightBitTexture.SubImage(0, 0, x.Width, x.Height, i))
* .ToArray();
*
* return new EightBitTexture(
* sprite.Name,
* (uint)tileWidth,
* (uint)tileHeight,
* 1,
* (uint)subImages.Length,
* sprite.PixelData, subImages);
* }*/
else // For non-uniforms just use the on-disk packing
{
subImages = sprite.Frames
.Select(x => new SubImage(
new Vector2(x.X, x.Y),
new Vector2(x.Width, x.Height),
new Vector2(sprite.Width, sprite.Height),
0))
.ToArray();
return(factory.CreateEightBitTexture(
key,
sprite.Name,
(uint)sprite.Width,
(uint)sprite.Height,
1,
1,
sprite.PixelData,
subImages));
}
}
public CoreFactoryHandler(ICoreFactory coreFactory)
{
this.coreFactory = coreFactory;
}
public DungeonTileMap(ITextureId id, string name, DrawLayer renderOrder, Vector3 tileSize, uint width, uint height, ICoreFactory factory, IPaletteManager paletteManager)
{
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
if (paletteManager == null)
{
throw new ArgumentNullException(nameof(paletteManager));
}
RenderOrder = renderOrder;
TileSize = tileSize;
Width = width;
Height = height;
_tiles = new DungeonTile[width * height];
Floors = factory.CreateMultiTexture(id, "FloorTiles:" + name, paletteManager);
Walls = factory.CreateMultiTexture(id, "WallTiles:" + name, paletteManager);
}
