public Reducer(IWebClientWrapper webClientWrapper, IStore store, IMinifier minifier, ISpriteManager spriteManager, ICssImageTransformer cssImageTransformer, IUriBuilder uriBuilder)
{
this.webClientWrapper = webClientWrapper;
this.cssImageTransformer = cssImageTransformer;
this.uriBuilder = uriBuilder;
this.spriteManager = spriteManager;
this.minifier = minifier;
this.store = store;
}
protected override Size Measure(ISpriteManager spriteManager, IDataRogueControl control, ISystemContainer systemContainer, List <MapCoordinate> playerFov, Rectangle boundingBox, Padding padding, HorizontalAlignment horizontalAlignment, VerticalAlignment verticalAlignment)
{
return(new Size(12 * MapEditorActivity.GetToolbarControls().Count(), 12));
}
protected static void RenderEntityDetails(int x, int y, ShopItemControl display, IEntity shopItem, ISystemContainer systemContainer, ISpriteManager spriteManager)
{
BLT.Font("");
SpriteAppearance appearance = shopItem.Has <SpriteAppearance>() ? shopItem.Get <SpriteAppearance>() : new SpriteAppearance {
Bottom = "unknown"
};
AnimationFrame frame = shopItem.Has <Animated>() ? systemContainer.AnimationSystem.GetFrame(shopItem) : AnimationFrame.Idle0;
Price price = shopItem.Get <Price>();
var playerWealth = systemContainer.ItemSystem.CheckWealth(systemContainer.PlayerSystem.Player, price.Currency);
var canAfford = playerWealth >= price.Amount;
BLTLayers.Set(BLTLayers.UIElementPieces, display.ActivityIndex);
string appearanceBottom = appearance.Bottom;
RenderSpriteIfSpecified(x + 4 + BLTTilesIOSystem.TILE_SPACING * 2, y + 4, spriteManager, appearanceBottom, frame);
BLTLayers.Set(BLTLayers.UIElementPieces + 1, display.ActivityIndex);
string appearanceTop = appearance.Top;
RenderSpriteIfSpecified(x + 4 + BLTTilesIOSystem.TILE_SPACING * 2, y + 4, spriteManager, appearanceTop, frame);
BLTLayers.Set(BLTLayers.Text, display.ActivityIndex);
BLT.Font("text");
BLT.Print(new Rectangle(x + 2, y + BLTTilesIOSystem.TILE_SPACING * 2 + 2, 6 * BLTTilesIOSystem.TILE_SPACING, 10), ContentAlignment.TopCenter, shopItem.GetBLTName());
BLT.Color(canAfford ? Color.Gold : Color.Gray);
BLT.Print(new Rectangle(x + 2, y + BLTTilesIOSystem.TILE_SPACING * 2 + 12, 6 * BLTTilesIOSystem.TILE_SPACING, 10), ContentAlignment.TopCenter, $"{price.Amount} {price.Currency}");
BLT.Color(Color.White);
}
public GameManager
(
IBossManager bossManager,
IBulletManager bulletManager,
ICollisionManager collisionManager,
ICommandManager commandManager,
IConfigManager configManager,
IContentManager contentManager,
IControlManager controlManager,
IDebugManager debugManager,
IDelayManager delayManager,
IDeviceManager deviceManager,
IEnemyManager enemyManager,
IEventManager eventManager,
IExplosionManager explosionManager,
IIconManager iconManager,
IImageManager imageManager,
IInputManager inputManager,
ILevelManager levelManager,
IMoverManager moverManager,
IRandomManager randomManager,
IRenderManager renderManager,
IResolutionManager resolutionManager,
IScoreManager scoreManager,
IScreenManager screenManager,
ISoundManager soundManager,
ISpriteManager spriteManager,
IStateManager stateManager,
IStopwatchManager stopwatchManager,
IStorageManager storageManager,
ITextManager textManager,
IThreadManager threadManager,
IFileManager fileManager,
ILogger logger
)
{
BossManager = bossManager;
BulletManager = bulletManager;
CollisionManager = collisionManager;
CommandManager = commandManager;
ConfigManager = configManager;
ContentManager = contentManager;
ControlManager = controlManager;
DebugManager = debugManager;
DelayManager = delayManager;
DeviceManager = deviceManager;
EnemyManager = enemyManager;
EventManager = eventManager;
ExplosionManager = explosionManager;
ImageManager = imageManager;
IconManager = iconManager;
InputManager = inputManager;
LevelManager = levelManager;
MoverManager = moverManager;
RandomManager = randomManager;
RenderManager = renderManager;
ResolutionManager = resolutionManager;
ScoreManager = scoreManager;
ScreenManager = screenManager;
SoundManager = soundManager;
SpriteManager = spriteManager;
StateManager = stateManager;
StopwatchManager = stopwatchManager;
StorageManager = storageManager;
TextManager = textManager;
ThreadManager = threadManager;
FileManager = fileManager;
Logger = logger;
}
protected virtual void RenderMap(ISpriteManager spriteManager, IDataRogueControl mapConfiguration, ISystemContainer systemContainer, List <MapCoordinate> playerFov)
{
var cameraPosition = systemContainer.RendererSystem.CameraPosition;
var currentMap = systemContainer.MapSystem.MapCollection[cameraPosition.Key];
var cameraX = cameraPosition.X;
var cameraY = cameraPosition.Y;
var playerMoving = systemContainer.PlayerSystem.Player?.TryGet <Moving>();
var playerMovingOffsetX = playerMoving == null ? 0 : -playerMoving.OffsetX;
var playerMovingOffsetY = playerMoving == null ? 0 : -playerMoving.OffsetY;
var renderWidth = mapConfiguration.Position.Width / BLTTilesIOSystem.TILE_SPACING;
var renderHeight = mapConfiguration.Position.Height / BLTTilesIOSystem.TILE_SPACING;
int offsetX = renderWidth / 2;
int offsetY = renderHeight / 2;
var tilesTracker = new SpriteAppearance[renderWidth + 2, renderHeight + 2, 2];
var frameTracker = new AnimationFrame[renderWidth + 2, renderHeight + 2, 2];
var offsetTracker = new BLTMapRendererOffset[renderWidth + 2, renderHeight + 2, 2];
var particlesTracker = new List <IEntity> [renderWidth + 2, renderHeight + 2];
var renderTracker = new bool[renderWidth + 2, renderHeight + 2];
var fovTracker = new bool[renderWidth + 2, renderHeight + 2];
for (int x = -1; x < renderWidth + 1; x++)
{
for (int y = -1; y < renderHeight + 1; y++)
{
var lookupX = cameraX - offsetX + x;
var lookupY = cameraY - offsetY + y;
MapCoordinate coordinate = new MapCoordinate(currentMap.MapKey, lookupX, lookupY);
var isInFov = playerFov?.Contains(coordinate) ?? true;
renderTracker[x + 1, y + 1] = isInFov || currentMap.SeenCoordinates.Contains(coordinate);
fovTracker[x + 1, y + 1] = isInFov;
var entities = GetEntitiesAt(systemContainer, currentMap, coordinate);
var particles = entities.Where(e => e.Has <TextParticle>()).ToList();
foreach (var particle in particles)
{
entities.Remove(particle);
}
var mapCell = entities.Last();
var topEntity = entities
.OrderByDescending(a => a.Get <Appearance>().ZOrder)
.FirstOrDefault(e => isInFov || IsRemembered(currentMap, coordinate, e));
if (topEntity == mapCell)
{
topEntity = null;
}
tilesTracker[x + 1, y + 1, 0] = mapCell.Get <SpriteAppearance>();
var animatedCell = mapCell.TryGet <Animated>();
if (animatedCell != null)
{
frameTracker[x + 1, y + 1, 0] = systemContainer.AnimationSystem.GetFrame(mapCell);
}
else
{
frameTracker[x + 1, y + 1, 0] = 0;
}
var movingCell = mapCell.TryGet <Moving>();
if (movingCell != null)
{
offsetTracker[x + 1, y + 1, 0] = new BLTMapRendererOffset(movingCell.OffsetX + playerMovingOffsetX, movingCell.OffsetY + playerMovingOffsetY);
}
else
{
offsetTracker[x + 1, y + 1, 0] = new BLTMapRendererOffset(playerMovingOffsetX, playerMovingOffsetY);
}
if (topEntity != null)
{
var spriteAppearance = topEntity.TryGet <SpriteAppearance>();
if (spriteAppearance != null)
{
tilesTracker[x + 1, y + 1, 1] = spriteAppearance;
}
else
{
tilesTracker[x + 1, y + 1, 1] = new SpriteAppearance {
Top = "unknown"
};
}
var animatedEntity = topEntity.TryGet <Animated>();
if (animatedEntity != null)
{
frameTracker[x + 1, y + 1, 1] = systemContainer.AnimationSystem.GetFrame(topEntity);
}
else
{
frameTracker[x + 1, y + 1, 1] = 0;
}
var moving = topEntity.TryGet <Moving>();
if (moving != null)
{
offsetTracker[x + 1, y + 1, 1] = new BLTMapRendererOffset(moving.OffsetX + playerMovingOffsetX, moving.OffsetY + playerMovingOffsetY);
}
else
{
offsetTracker[x + 1, y + 1, 1] = new BLTMapRendererOffset(playerMovingOffsetX, playerMovingOffsetY);
}
}
particlesTracker[x + 1, y + 1] = particles.ToList();
}
}
RenderMapSprites(spriteManager, mapConfiguration, renderTracker, renderWidth, renderHeight, tilesTracker, frameTracker, offsetTracker, 0, false);
RenderMapSprites(spriteManager, mapConfiguration, renderTracker, renderWidth, renderHeight, tilesTracker, frameTracker, offsetTracker, 1, false);
RenderMapSprites(spriteManager, mapConfiguration, renderTracker, renderWidth, renderHeight, tilesTracker, frameTracker, offsetTracker, 0, true);
RenderMapSprites(spriteManager, mapConfiguration, renderTracker, renderWidth, renderHeight, tilesTracker, frameTracker, offsetTracker, 1, true);
RenderMapParticles(systemContainer, renderTracker, fovTracker, particlesTracker, renderWidth, renderHeight, mapConfiguration);
RenderMapShade(spriteManager, renderTracker, fovTracker, renderWidth, renderHeight, offsetTracker, mapConfiguration);
}
protected override Size Measure(ISpriteManager spriteManager, IDataRogueControl control, ISystemContainer systemContainer, List <MapCoordinate> playerFov, Rectangle boundingBox, Padding padding, HorizontalAlignment horizontalAlignment, VerticalAlignment verticalAlignment)
{
var size = base.Measure(spriteManager, control, systemContainer, playerFov, boundingBox, padding, horizontalAlignment, verticalAlignment);
return(new Size(size.Width, size.Height * 2));
}
public ScreenRenderer(IGraphicsContext <TSurface, TSource> graphicsContext, ISpriteManager <TSource> spriteManager, IRenderingUnit renderingUnit)
{
this.GraphicsContext = graphicsContext;
this.SpriteManager = spriteManager;
UpdateLayers(renderingUnit);
}
protected static void RenderEntitySprite(IDataRogueInfoControl display, IEntity entity, ISystemContainer systemContainer, ISpriteManager spriteManager)
{
BLT.Font("");
SpriteAppearance appearance = entity.Has <SpriteAppearance>() ? entity.Get <SpriteAppearance>() : new SpriteAppearance {
Bottom = "unknown"
};
AnimationFrame frame = entity.Has <Animated>() ? systemContainer.AnimationSystem.GetFrame(entity) : AnimationFrame.Idle0;
BLTLayers.Set(BLTLayers.UIElementPieces, display.ActivityIndex);
string appearanceBottom = appearance.Bottom;
RenderSpriteIfSpecified(display.Position.X, display.Position.Y, spriteManager, appearanceBottom, frame);
BLTLayers.Set(BLTLayers.UIElementPieces + 1, display.ActivityIndex);
string appearanceTop = appearance.Top;
RenderSpriteIfSpecified(display.Position.X, display.Position.Y, spriteManager, appearanceTop, frame);
}
protected static void RenderBackgroundBox(int x, int y, int activityIndex, Size size, ISpriteManager spriteManager, string spriteName = "textbox_blue")
{
BLTLayers.Set(BLTLayers.UIElements, activityIndex);
BLT.Font("");
var width = size.Width / BLTTilesIOSystem.TILE_SPACING;
var height = size.Height / BLTTilesIOSystem.TILE_SPACING;
var spriteSheet = spriteManager.Get(spriteName);
for (int xCoord = 0; xCoord < width; xCoord++)
{
for (int yCoord = 0; yCoord < height; yCoord++)
{
BLT.Put(x + xCoord * BLTTilesIOSystem.TILE_SPACING, y + yCoord * BLTTilesIOSystem.TILE_SPACING, spriteSheet.Tile(BLTTileDirectionHelper.GetDirections(xCoord, width, yCoord, height)));
}
}
}
void RenderItemInHandCursor(IAssetManager assets, ISpriteManager sm, IWindowManager window, Vector3 normPosition)
{
var held = Resolve <IInventoryManager>().ItemInHand;
var itemAmountText = GetAmountText();
if (_lastItemAmountText != itemAmountText)
{
var tm = Resolve <ITextManager>();
_lastItemAmountText = itemAmountText;
_itemAmountSprite?.Dispose();
_itemAmountSprite = itemAmountText == null
? null
: tm.BuildRenderable(new TextBlock(itemAmountText), DrawLayer.MaxLayer, null, this);
}
if (_cursorId != Base.CoreSprite.CursorSmall) // Inventory screen, check what's being held.
{
_itemSprite?.Dispose(); _itemSprite = null;
_itemAmountSprite?.Dispose(); _itemAmountSprite = null;
return;
}
int subItem = 0;
ITexture texture = null;
switch (held.Item)
{
case Gold: texture = assets.LoadTexture(Base.CoreSprite.UiGold); break;
case Rations: texture = assets.LoadTexture(Base.CoreSprite.UiFood); break;
case ItemData item:
{
texture = assets.LoadTexture(item.Icon);
subItem = item.IconSubId + _frame % item.IconAnim;
break;
}
}
if (texture == null)
{
_itemSprite?.Dispose();
_itemSprite = null;
return;
}
if (texture != _itemSprite?.Key.Texture)
{
_itemSprite?.Dispose();
var key = new SpriteKey(texture, SpriteSampler.Point, DrawLayer.Cursor, SpriteKeyFlags.NoDepthTest | SpriteKeyFlags.NoTransform);
_itemSprite = sm.Borrow(key, 1, this);
}
var subImage = texture.Regions[subItem];
bool lockWasTaken = false;
var instances = _itemSprite.Lock(ref lockWasTaken);
try
{
// TODO: Quantity text
instances[0] = new SpriteInstanceData(
normPosition + new Vector3(window.UiToNormRelative(6, 6), 0),
window.UiToNormRelative(subImage.Size),
subImage, SpriteFlags.TopMid);
}
finally { _itemSprite.Unlock(lockWasTaken); }
if (_itemAmountSprite != null)
{
_itemAmountSprite.Position = normPosition + new Vector3(window.UiToNormRelative(6, 18), 0);
}
}
protected override void DisplayInternal(ISpriteManager spriteManager, IDataRogueControl control, ISystemContainer systemContainer, List <MapCoordinate> playerFov)
{
// Do not display anything
}
public BLTTilesUnifiedRenderer(List <IDataRogueControlRenderer> controlRenderers, ISpriteManager spriteManager, IOSystemConfiguration configuration)
{
_spriteManager = spriteManager;
_controlRenderers = controlRenderers;
_ioSystemConfiguration = configuration;
}
protected override Size Measure(ISpriteManager spriteManager, IDataRogueControl control, ISystemContainer systemContainer, List <MapCoordinate> playerFov, Rectangle boundingBox, Padding padding, HorizontalAlignment horizontalAlignment, VerticalAlignment verticalAlignment)
{
return(control.Position.Size);
}
private void ClipSprite <TSurface, TSource>(string spriteName, string spritesheet, Rectangle spriteBounds, IGraphicsContext <TSurface, TSource> graphicsContext, ISpriteManager <TSource> spriteManager)
{
TSurface target = graphicsContext.CreateTarget(spriteBounds.Width, spriteBounds.Height);
graphicsContext.Draw(spriteManager[spritesheet], target, new Rectangle(0, 0, spriteBounds.Width, spriteBounds.Height), spriteBounds);
spriteManager[spriteName] = graphicsContext.TargetToSource(target);
}
protected override void DisplayInternal(ISpriteManager spriteManager, IDataRogueControl control, ISystemContainer systemContainer, List <MapCoordinate> playerFov)
{
var display = control as IDataRogueInfoControl;
RenderEntitySprite(display, display.Entity, systemContainer, spriteManager);
}
protected override Size Measure(ISpriteManager spriteManager, IDataRogueControl control, ISystemContainer systemContainer, List <MapCoordinate> playerFov, Rectangle boundingBox, Padding padding, HorizontalAlignment horizontalAlignment, VerticalAlignment verticalAlignment)
{
return(new Size(BLTTilesIOSystem.TILE_SPACING, BLTTilesIOSystem.TILE_SPACING));
}
protected abstract void DisplayInternal(ISpriteManager spriteManager, IDataRogueControl control, ISystemContainer systemContainer, List <MapCoordinate> playerFov);
public CssReducer(IWebClientWrapper webClientWrapper, IStore store, IMinifier minifier, ISpriteManager spriteManager, ICssImageTransformer cssImageTransformer, IUriBuilder uriBuilder, IRRConfiguration configuration, IRelativeToAbsoluteUtility relativeToAbsoluteUtility)
: base(webClientWrapper, store, minifier, uriBuilder)
{
this.cssImageTransformer = cssImageTransformer;
this.configuration = configuration;
this.relativeToAbsoluteUtility = relativeToAbsoluteUtility;
this.spriteManager = spriteManager;
}
protected abstract Size Measure(ISpriteManager spriteManager, IDataRogueControl control, ISystemContainer systemContainer, List <MapCoordinate> playerFov, Rectangle boundingBox, Padding padding, HorizontalAlignment horizontalAlignment, VerticalAlignment verticalAlignment);
void RenderItemInHandCursor(IAssetManager assets, ISpriteManager sm, IWindowManager window, Vector3 normPosition)
{
var held = Resolve <IInventoryManager>().ItemInHand;
var itemAmountText = GetAmountText();
if (_lastItemAmountText != itemAmountText)
{
var tm = Resolve <ITextManager>();
_lastItemAmountText = itemAmountText;
_itemAmountSprite?.Dispose();
_itemAmountSprite = itemAmountText == null
? null
: tm.BuildRenderable(new TextBlock(itemAmountText), DrawLayer.MaxLayer, null, this);
}
if (_cursorId != CoreSpriteId.CursorSmall) // Inventory screen, check what's being held.
{
_itemSprite?.Dispose(); _itemSprite = null;
_itemAmountSprite?.Dispose(); _itemAmountSprite = null;
return;
}
int subItem = 0;
ITexture texture = null;
switch (held.Item)
{
case Gold _: texture = assets.LoadTexture(CoreSpriteId.UiGold); break;
case Rations _: texture = assets.LoadTexture(CoreSpriteId.UiFood); break;
case ItemData item:
{
ItemSpriteId spriteId = (ItemSpriteId)((int)item.Icon + _frame % item.IconAnim);
texture = assets.LoadTexture(spriteId);
subItem = (int)spriteId;
break;
}
}
if (texture == null)
{
_itemSprite?.Dispose();
_itemSprite = null;
return;
}
if (texture != _itemSprite?.Key.Texture)
{
_itemSprite?.Dispose();
var key = new SpriteKey(texture, DrawLayer.Cursor,
SpriteKeyFlags.NoDepthTest | SpriteKeyFlags.NoTransform);
_itemSprite = sm.Borrow(key, 1, this);
}
var subImage = texture.GetSubImageDetails(subItem);
// TODO: Quantity text
var instances = _itemSprite.Access();
instances[0] = SpriteInstanceData.TopMid(
normPosition + new Vector3(window.UiToNormRelative(6, 6), 0),
window.UiToNormRelative(subImage.Size),
subImage, 0);
if (_itemAmountSprite != null)
{
_itemAmountSprite.Position = normPosition + new Vector3(window.UiToNormRelative(6, 18), 0);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AssetManager"/> class.
/// </summary>
/// <param name="game">The Monogame <see cref="Game"/> dependency.</param>
/// <param name="spriteManager">The ZxenLib <see cref="ISpriteManager"/> dependency.</param>
public AssetManager(Game game, ISpriteManager spriteManager)
{
this.contentManager = game.Content;
this.spriteManager = spriteManager;
}
public MonoGameScreenRenderer(IGraphicsContext <RenderTarget2D, Texture2D> graphicsContext, ISpriteManager <Texture2D> spriteManager, IRenderingUnit renderingUnit) : base(graphicsContext, spriteManager, renderingUnit)
{
}
protected override void DisplayInternal(ISpriteManager spriteManager, IDataRogueControl control, ISystemContainer systemContainer, List <MapCoordinate> playerFov)
{
RenderMap(spriteManager, control, systemContainer, playerFov);
}
