static BattleEffectInfo CreateSimpleEffect(IRenderView renderView, uint tile, CombatGraphicIndex graphicIndex,
Character[] battleField, uint duration, Func <bool, int> yOffsetProvider = null, float scale = 1.0f, bool ground = false)
{
var info = renderView.GraphicProvider.GetCombatGraphicInfo(graphicIndex);
var position = GetCenterPosition(renderView, tile, battleField, yOffsetProvider?.Invoke(battleField[tile] is Monster) ?? 0);
scale *= GetScaleFromRow(renderView, tile, battleField);
if (ground && battleField[tile] is Monster)
{
var offsetY = yOffsetProvider?.Invoke(true) ?? 0;
var groundPositionY = Layout.GetMonsterCombatGroundPosition(renderView, (int)tile).Y + offsetY;
int effectHeight = Util.Round(scale * info.GraphicInfo.Height);
position.Y = groundPositionY - effectHeight / 2;
}
return(new BattleEffectInfo
{
StartPosition = position,
EndPosition = position,
StartScale = scale,
EndScale = scale,
StartTextureIndex = Graphics.CombatGraphicOffset + (uint)graphicIndex,
FrameSize = new Size(info.GraphicInfo.Width, info.GraphicInfo.Height),
FrameCount = info.FrameCount,
Duration = duration,
InitialDisplayLayer = (byte)Math.Min(255, (tile / 6) * 60 + 60), // display over the given row
EndDisplayLayer = (byte)Math.Min(255, (tile / 6) * 60 + 60), // display over the given row
MirrorX = false
});
}
public Popup(Game game, IRenderView renderView, Position position, int columns, int rows, bool transparent,
byte displayLayerOffset = 0)
{
if (columns < 3 || rows < 3)
{
throw new AmbermoonException(ExceptionScope.Application, "Popups must at least have 3 columns and 3 rows.");
}
DisplayLayer = (byte)Math.Min(255, BaseDisplayLayer + displayLayerOffset);
this.game = game;
this.renderView = renderView;
textureAtlas = TextureAtlasManager.Instance.GetOrCreate(Layer.UI);
void AddBorder(PopupFrame frame, int column, int row)
{
var sprite = renderView.SpriteFactory.Create(16, 16, true, DisplayLayer) as ILayerSprite;
sprite.Layer = renderView.GetLayer(Layer.UI);
sprite.TextureAtlasOffset = textureAtlas.GetOffset(Graphics.GetPopupFrameGraphicIndex(frame));
sprite.PaletteIndex = game.UIPaletteIndex;
sprite.X = position.X + column * 16;
sprite.Y = position.Y + row * 16;
sprite.Visible = true;
borders.Add(sprite);
}
if (!transparent)
{
// 4 corners
AddBorder(PopupFrame.FrameUpperLeft, 0, 0);
AddBorder(PopupFrame.FrameUpperRight, columns - 1, 0);
AddBorder(PopupFrame.FrameLowerLeft, 0, rows - 1);
AddBorder(PopupFrame.FrameLowerRight, columns - 1, rows - 1);
// top and bottom border
for (int i = 0; i < columns - 2; ++i)
{
AddBorder(PopupFrame.FrameTop, i + 1, 0);
AddBorder(PopupFrame.FrameBottom, i + 1, rows - 1);
}
// left and right border
for (int i = 0; i < rows - 2; ++i)
{
AddBorder(PopupFrame.FrameLeft, 0, i + 1);
AddBorder(PopupFrame.FrameRight, columns - 1, i + 1);
}
// fill
// TODO: use named palette color
fill = renderView.ColoredRectFactory.Create((columns - 2) * 16, (rows - 2) * 16,
game.GetUIColor(28), DisplayLayer);
fill.Layer = renderView.GetLayer(Layer.UI);
fill.X = position.X + 16;
fill.Y = position.Y + 16;
fill.Visible = true;
ContentArea = new Rect(fill.X, fill.Y, fill.Width, fill.Height);
}
}
public OutroFactory(IRenderView renderView, OutroData outroData, Font outroFont, Font outroFontLarge)
{
this.renderView = renderView;
this.outroData = outroData;
this.outroFont = outroFont;
this.outroFontLarge = outroFontLarge;
}
public RenderMap2D(Game game, Map map, IMapManager mapManager, IRenderView renderView,
uint initialScrollX = 0, uint initialScrollY = 0)
{
this.game = game;
this.mapManager = mapManager;
this.renderView = renderView;
var spriteFactory = renderView.SpriteFactory;
for (int row = 0; row < NUM_VISIBLE_TILES_Y; ++row)
{
for (int column = 0; column < NUM_VISIBLE_TILES_X; ++column)
{
var backgroundSprite = spriteFactory.CreateAnimated(TILE_WIDTH, TILE_HEIGHT, 0, 1);
var foregroundSprite = spriteFactory.CreateAnimated(TILE_WIDTH, TILE_HEIGHT, 0, 1);
backgroundSprite.Visible = true;
backgroundSprite.X = Global.Map2DViewX + column * TILE_WIDTH;
backgroundSprite.Y = Global.Map2DViewY + row * TILE_HEIGHT;
foregroundSprite.Visible = false;
foregroundSprite.X = Global.Map2DViewX + column * TILE_WIDTH;
foregroundSprite.Y = Global.Map2DViewY + row * TILE_HEIGHT;
backgroundTileSprites.Add(backgroundSprite);
foregroundTileSprites.Add(foregroundSprite);
}
}
SetMap(map, initialScrollX, initialScrollY);
}
static BattleEffectInfo CreateFlyingEffect(IRenderView renderView, uint sourceTile, uint targetTile,
CombatGraphicIndex graphicIndex, Character[] battleField, float baseScale = 1.0f)
{
var info = renderView.GraphicProvider.GetCombatGraphicInfo(graphicIndex);
var startPosition = GetProjectileTargetPosition(renderView, sourceTile, battleField);
var endPosition = GetProjectileTargetPosition(renderView, targetTile, battleField);
var sourceScale = GetScaleFromRow(renderView, sourceTile, battleField);
var targetScale = GetScaleFromRow(renderView, targetTile, battleField);
int maxY = Global.CombatBackgroundArea.Bottom;
if (startPosition.Y > maxY)
{
startPosition.Y = maxY;
}
if (endPosition.Y > maxY)
{
endPosition.Y = maxY;
}
return(new BattleEffectInfo
{
StartPosition = startPosition,
EndPosition = endPosition,
StartScale = sourceScale * baseScale,
EndScale = targetScale * baseScale,
StartTextureIndex = Graphics.CombatGraphicOffset + (uint)graphicIndex,
FrameSize = new Size(info.GraphicInfo.Width, info.GraphicInfo.Height),
FrameCount = info.FrameCount,
Duration = GetFlyDuration(sourceTile, targetTile),
InitialDisplayLayer = (byte)Math.Min(255, (sourceTile / 6) * 60 + 60), // display over the given row
EndDisplayLayer = (byte)Math.Min(255, (targetTile / 6) * 60 + 60), // display over the given row
MirrorX = battleField[(int)sourceTile] is Monster ? startPosition.X <endPosition.X : startPosition.X> endPosition.X
});
}
public Text(IRenderView renderView, Layer layer, string text, IReadOnlyDictionary <char, Glyph> glyphs,
List <char> characters, byte displayLayer, int spaceWidth, bool upperOnly, uint textureAtlasIndexOffset)
{
totalWidth = 0;
var textureAtlas = TextureAtlasManager.Instance.GetOrCreate(layer);
if (upperOnly)
{
text = text.ToUpper();
}
foreach (char ch in text)
{
if (ch == ' ')
{
totalWidth += spaceWidth;
}
else if (glyphs.TryGetValue(ch, out var glyph))
{
var sprite = renderView.SpriteFactory.Create(glyph.Graphic.Width, glyph.Graphic.Height, true, displayLayer) as ILayerSprite;
sprite.TextureAtlasOffset = textureAtlas.GetOffset((uint)characters.IndexOf(ch) + textureAtlasIndexOffset);
sprite.X = totalWidth;
sprite.Y = 0;
sprite.Layer = renderView.GetLayer(layer);
sprite.PaletteIndex = (byte)(renderView.GraphicProvider.PrimaryUIPaletteIndex - 1);
sprite.Visible = false;
renderGlyphs.Add(sprite);
totalWidth += glyph.Advance;
}
}
}
public Outro(IRenderView renderView, OutroData outroData, Font outroFont, Font outroFontLarge, Action finishAction)
{
this.finishAction = finishAction;
this.outroData = outroData;
this.outroFont = outroFont;
this.outroFontLarge = outroFontLarge;
this.renderView = renderView;
renderLayer = renderView.GetLayer(Layer.OutroGraphics);
picture = renderView.SpriteFactory.Create(160, 128, true, 1) as ILayerSprite;
picture.Layer = renderLayer;
picture.PaletteIndex = paletteOffset = renderView.GraphicProvider.FirstOutroPaletteIndex;
picture.Visible = false;
renderTextFactory = renderView.RenderTextFactory;
textProcessor = renderView.TextProcessor;
fadeArea = renderView.ColoredRectFactory.Create(Global.VirtualScreenWidth, Global.VirtualScreenHeight, Color.Black, 255);
fadeArea.Layer = renderView.GetLayer(Layer.Effects);
fadeArea.X = 0;
fadeArea.Y = 0;
fadeArea.Visible = false;
graphicInfos = outroData.GraphicInfos;
EnsureTextures(renderView, outroData, outroFont, outroFontLarge);
}
static float GetScaleFromRow(IRenderView renderView, uint tile, Character[] battleField)
{
if (battleField[(int)tile]?.Type == CharacterType.PartyMember)
{
return(2.0f);
}
return(renderView.GraphicProvider.GetMonsterRowImageScaleFactor((MonsterRow)(tile / 6)));
}
static Position GetProjectileTargetPosition(IRenderView renderView, uint tile, Character[] battleField)
{
if (battleField[(int)tile] is Monster monster)
{
return(Layout.GetMonsterCombatCenterPosition(renderView, (int)tile, monster));
}
else
{
return(Layout.GetPlayerSlotTargetPosition((int)tile % 6) - new Position(0, 6));
}
}
readonly List <SpriteInfo> characterSpritesNew = new List <SpriteInfo>(); // shared by all texts
public TextRenderer(IRenderView renderView)
{
spriteFactory = renderView.SpriteFactory;
layerLegacy = renderView.GetLayer(Layer.Gui);
layerNewFont = renderView.GetLayer(Layer.GuiFont);
// original size is 8x8 pixels
characterSizeLegacy = new Size(8, 8);
// new font uses a different size
characterSizeNew = new Size(Global.UIFontCharacterWidth, Global.UIFontCharacterHeight);
}
/// <summary>
/// Returns the number of pixels per unit on the near plane.
/// ISSUE: Does not consider ClippingWindow of projection
/// </summary>
public static V2d PixelsPerUnitOnNearPlane(this IRenderView rv)
{
if (rv.Projection is ICameraProjectionPerspective)
{
var unitsOnNearPlane = Fun.Tan(((ICameraProjectionPerspective)rv.Projection).HorizontalFieldOfViewInDegrees.RadiansFromDegrees() * 0.5) * 2 * rv.Projection.Near;
return((V2d)rv.Region.Size / new V2d(unitsOnNearPlane, unitsOnNearPlane / rv.Projection.AspectRatio));
}
else
{
return((V2d)rv.Region.Size / rv.Projection.ClippingWindow.Size);
}
}
static Position GetCenterPosition(IRenderView renderView, uint tile, Character[] battleField, int yOffset = 0)
{
var offset = new Position(0, yOffset);
if (battleField[(int)tile] is Monster monster)
{
return(Layout.GetMonsterCombatCenterPosition(renderView, (int)tile, monster) + offset);
}
else
{
return(Layout.GetPlayerSlotTargetPosition((int)tile % 6) + offset);
}
}
static void EnsureTextures(IRenderView renderView, OutroData outroData, Font outroFont, Font outroFontLarge)
{
if (textureAtlas == null)
{
TextureAtlasManager.Instance.AddFromGraphics(Layer.OutroGraphics,
outroData.Graphics.Select((g, i) => new { Graphic = g, Index = i }).ToDictionary(g => (uint)g.Index, g => g.Graphic));
textureAtlas = TextureAtlasManager.Instance.GetOrCreate(Layer.OutroGraphics);
renderView.GetLayer(Layer.OutroGraphics).Texture = textureAtlas.Texture;
TextureAtlasManager.Instance.AddFromGraphics(Layer.OutroText, outroFont.GlyphGraphics);
TextureAtlasManager.Instance.AddFromGraphics(Layer.OutroText, outroFontLarge.GlyphGraphics);
renderView.GetLayer(Layer.OutroText).Texture = TextureAtlasManager.Instance.GetOrCreate(Layer.OutroText).Texture;
}
}
public ButtonGrid(IRenderView renderView)
{
area = new Rect(Global.ButtonGridX, Global.ButtonGridY, 3 * Button.Width, 3 * Button.Height);
for (int i = 0; i < 9; ++i)
{
buttons[i] = new Button
(
renderView,
new Position(Global.ButtonGridX + (i % 3) * Button.Width, Global.ButtonGridY + (i / 3) * Button.Height)
);
}
}
private MapCharacter2D(Game game, IRenderView renderView, Layer layer, IMapManager mapManager,
RenderMap2D map, uint characterIndex, Map.CharacterReference characterReference)
: base(game, renderView.GetLayer(layer), TextureAtlasManager.Instance.GetOrCreate(layer),
renderView.SpriteFactory, () => AnimationProvider(game, map.Map, mapManager,
characterReference, renderView.GraphicProvider), map, GetStartPosition(characterReference),
() => Math.Max(1, map.Map.PaletteIndex) - 1, () => NullOffset)
{
this.game = game;
this.map = map.Map;
tileset = mapManager.GetTilesetForMap(this.map);
this.characterIndex = characterIndex;
this.characterReference = characterReference;
lastTimeSlot = game.GameTime.TimeSlot;
}
ListBox(IRenderView renderView, Game game, Popup popup, List <KeyValuePair <string, Action <int, string> > > items,
Rect area, Position itemBasePosition, int itemHeight, int hoverBoxWidth, Position relativeHoverBoxOffset,
bool withIndex, int maxItems, char?fallbackChar = null, bool canEdit = false,
Func <string, TextColor> colorProvider = null)
{
this.game = game;
this.renderView = renderView;
this.items = items;
this.relativeHoverBoxOffset = relativeHoverBoxOffset;
this.maxItems = maxItems;
this.canEdit = canEdit;
this.colorProvider = colorProvider;
popup.AddSunkenBox(area);
hoverBox = popup.FillArea(new Rect(itemBasePosition + relativeHoverBoxOffset, new Size(hoverBoxWidth, itemHeight)),
game.GetTextColor(TextColor.Bright), 3);
hoverBox.Visible = false;
for (int i = 0; i < Util.Min(maxItems, items.Count); ++i)
{
var color = items[i].Value == null ? TextColor.Disabled
: colorProvider?.Invoke(items[i].Key) ?? TextColor.Bright;
if (withIndex)
{
int y = itemBasePosition.Y + i * itemHeight;
itemIndices.Add(popup.AddText(new Position(itemBasePosition.X, y), $"{i + 1,2}", color, true, 4));
itemTexts.Add(popup.AddText(new Position(itemBasePosition.X + 17, y), items[i].Key, color, true, 4, fallbackChar));
}
else
{
itemTexts.Add(popup.AddText(new Position(itemBasePosition.X, itemBasePosition.Y + i * itemHeight),
items[i].Key, color, true, 4, fallbackChar));
}
itemAreas.Add(new Rect(itemBasePosition.X, itemBasePosition.Y + i * itemHeight, area.Right - itemBasePosition.X - 1, itemHeight));
}
if (canEdit && itemTexts.Count != 0)
{
editInput = new TextInput(game, renderView, new Position(), (itemTexts[0].Width / Global.GlyphWidth) - 1,
(byte)(popup.DisplayLayer + 6), TextInput.ClickAction.Submit, TextInput.ClickAction.Abort, TextAlign.Left)
{
ClearOnNewInput = false,
DigitsOnly = false,
ReactToGlobalClicks = true
};
editInput.InputSubmitted += _ => CommitEdit();
}
}
public Cursor(IRenderView renderView, IReadOnlyList <Position> cursorHotspots, TextureAtlasManager textureAtlasManager = null)
{
this.renderView = renderView;
textureAtlas = (textureAtlasManager ?? TextureAtlasManager.Instance).GetOrCreate(Layer.Cursor);
sprite = renderView.SpriteFactory.Create(16, 16, true);
sprite.PaletteIndex = 0;
sprite.Layer = renderView.GetLayer(Layer.Cursor);
for (int i = 0; i < cursorHotspots.Count; ++i)
{
this.cursorHotspots.Add((CursorType)i, cursorHotspots[i]);
}
UpdateCursor();
}
public Interface(IRenderView renderView, Audio.IAudioInterface audioInterface, Viewer viewer)
: base(renderView, audioInterface)
{
RenderView = renderView;
AudioInterface = audioInterface;
Viewer = viewer;
TextRenderer = new TextRenderer(renderView);
displayed = true;
config = UserConfig.Game.Options;
mapCursorSprites[0] = new SpriteLocation {
Sprite = 31
};
mapCursorSprites[1] = new SpriteLocation {
Sprite = 32
};
mapCursorSprites[2] = new SpriteLocation {
Sprite = 32
};
mapCursorSprites[3] = new SpriteLocation {
Sprite = 32
};
mapCursorSprites[4] = new SpriteLocation {
Sprite = 32
};
mapCursorSprites[5] = new SpriteLocation {
Sprite = 32
};
mapCursorSprites[6] = new SpriteLocation {
Sprite = 32
};
cursorSprite = renderView.SpriteFactory.Create(16, 16, 0, 0, false, false, 255);
cursorSprite.Layer = renderView.GetLayer(Freeserf.Layer.Cursor);
cursorSprite.Visible = true;
SetSize(640, 480); // original size
Viewport = null;
PanelBar = new PanelBar(this);
AddChild(PanelBar, 0, 0, false);
Layout();
}
public BaseController()
{
PartialRenderer = this;
ViewRenderer = this;
// Ensure user is in database
//
if (System.Web.HttpContext.Current.User.Identity.IsAuthenticated)
{
Repository db = new Repository();
MFUser user = db.GetUserById(System.Web.HttpContext.Current.User.Identity.Name);
if (user == null)
{
user = db.CreateUser((Facebook.FacebookUser)System.Web.HttpContext.Current.User);
db.SaveChanges();
}
}
}
public static List <BattleEffectInfo> GetEffectInfo(IRenderView renderView, BattleEffect battleEffect, uint sourceTile, uint targetTile,
Character[] battleField, float scale = 1.0f)
{
return(battleEffect switch
{
BattleEffect.HurtMonster => Effects(CreateSimpleEffect(renderView, targetTile, CombatGraphicIndex.Blood, battleField, Game.TicksPerSecond / 3)),
BattleEffect.HurtPlayer => Effects(CreateSimpleEffect(renderView, targetTile, CombatGraphicIndex.AttackClaw, battleField, Game.TicksPerSecond / 2, _ => - 28)),
BattleEffect.MonsterArrowAttack => Effects(CreateFlyingEffect(renderView, sourceTile, targetTile, CombatGraphicIndex.ArrowGreenMonster, battleField)),
BattleEffect.MonsterBoltAttack => Effects(CreateFlyingEffect(renderView, sourceTile, targetTile, CombatGraphicIndex.ArrowRedMonster, battleField)),
BattleEffect.PlayerArrowAttack => Effects(CreateFlyingEffect(renderView, sourceTile, targetTile, CombatGraphicIndex.ArrowGreenHuman, battleField)),
BattleEffect.PlayerBoltAttack => Effects(CreateFlyingEffect(renderView, sourceTile, targetTile, CombatGraphicIndex.ArrowRedHuman, battleField)),
BattleEffect.SlingstoneAttack => Effects(CreateFlyingEffect(renderView, sourceTile, targetTile, CombatGraphicIndex.Slingstone, battleField)),
BattleEffect.SlingdaggerAttack => Effects(CreateFlyingEffect(renderView, sourceTile, targetTile, CombatGraphicIndex.Slingdagger, battleField)),
BattleEffect.SickleAttack => Effects(CreateFlyingEffect(renderView, sourceTile, targetTile, CombatGraphicIndex.FlyingSickle, battleField, 1.5f)),
BattleEffect.Death => Effects(CreateSimpleEffect(renderView, targetTile, CombatGraphicIndex.DeathAnimation, battleField, Game.TicksPerSecond * 5 / 4, null, scale, true)),
BattleEffect.BlockSpell => Effects(CreateSimpleEffect(renderView, targetTile, CombatGraphicIndex.SpellBlock, battleField, Game.TicksPerSecond / 2, monster => monster ? -32 : -46)),
BattleEffect.PlayerAtack => Effects(CreateSimpleEffect(renderView, targetTile, CombatGraphicIndex.AttackSword, battleField, Game.TicksPerSecond / 4, _ => - 10)),
_ => null
});
static BattleEffectInfo CreateSimpleEffect(IRenderView renderView, uint sourceTile, uint targetTile, CombatGraphicIndex graphicIndex,
Character[] battleField, uint duration, float startScale = 1.0f, float scaleChangePerY = 0.0f)
{
var info = renderView.GraphicProvider.GetCombatGraphicInfo(graphicIndex);
var startPosition = GetCenterPosition(renderView, sourceTile, battleField);
var endPosition = GetCenterPosition(renderView, targetTile, battleField);
float endScale = startScale + (endPosition.Y - startPosition.Y) * scaleChangePerY;
return(new BattleEffectInfo
{
StartPosition = startPosition,
EndPosition = endPosition,
StartScale = startScale,
EndScale = endScale,
StartTextureIndex = Graphics.CombatGraphicOffset + (uint)graphicIndex,
FrameSize = new Size(info.GraphicInfo.Width, info.GraphicInfo.Height),
FrameCount = info.FrameCount,
Duration = duration,
InitialDisplayLayer = (byte)Math.Min(255, (sourceTile / 6) * 60 + 60), // display over the given row
EndDisplayLayer = (byte)Math.Min(255, (sourceTile / 6) * 60 + 60), // display over the given row
MirrorX = false
});
}
public Button(IRenderView renderView, Position position,
TextureAtlasManager textureAtlasManager = null)
{
Area = new Rect(position, new Size(Width, Height));
byte paletteIndex = (byte)(renderView.GraphicProvider.PrimaryUIPaletteIndex - 1);
frameSprite = renderView.SpriteFactory.Create(Width, Height, true, 3) as ILayerSprite;
disableOverlay = renderView.SpriteFactory.Create(Width, Height - 6, true, 5) as ILayerSprite;
iconSprite = renderView.SpriteFactory.Create(Width, Height - 4, true, 4) as ILayerSprite;
var layer = renderView.GetLayer(Layer.UI);
frameSprite.Layer = layer;
disableOverlay.Layer = layer;
iconSprite.Layer = layer;
textureAtlas = (textureAtlasManager ?? TextureAtlasManager.Instance).GetOrCreate(Layer.UI);
frameSprite.TextureAtlasOffset = textureAtlas.GetOffset(Graphics.GetUIGraphicIndex(UIGraphic.ButtonFrame));
disableOverlay.TextureAtlasOffset = textureAtlas.GetOffset(Graphics.GetUIGraphicIndex(UIGraphic.ButtonDisabledOverlay));
iconSprite.TextureAtlasOffset = textureAtlas.GetOffset(Graphics.GetButtonGraphicIndex(ButtonType.Empty));
frameSprite.PaletteIndex = paletteIndex;
disableOverlay.PaletteIndex = paletteIndex;
iconSprite.PaletteIndex = paletteIndex;
frameSprite.X = position.X;
frameSprite.Y = position.Y;
disableOverlay.X = position.X;
disableOverlay.Y = position.Y + 3;
iconSprite.X = position.X;
iconSprite.Y = position.Y + 2;
frameSprite.Visible = true;
disableOverlay.Visible = false;
iconSprite.Visible = true;
}
public static ListBox CreateSpellListbox(IRenderView renderView, Game game, Popup popup,
List <KeyValuePair <string, Action <int, string> > > items)
{
return(new ListBox(renderView, game, popup, items, new Rect(48, 56, 162, 115),
new Position(52, 58), 7, 159, new Position(-3, -1), false, 16));
}
public static ListBox CreateDictionaryListbox(IRenderView renderView, Game game, Popup popup,
List <KeyValuePair <string, Action <int, string> > > items, Func <string, TextColor> colorProvider)
{
return(new ListBox(renderView, game, popup, items, new Rect(48, 48, 130, 115),
new Position(52, 50), 7, 127, new Position(-3, -1), false, 16, null, false, colorProvider));
}
public static ListBox CreateSavegameListbox(IRenderView renderView, Game game, Popup popup,
List <KeyValuePair <string, Action <int, string> > > items, bool canEdit)
{
return(new ListBox(renderView, game, popup, items, new Rect(32, 85, 256, 73),
new Position(33, 87), 7, 237, new Position(16, -1), true, 10, '?', canEdit));
}
public static ListBox CreateOptionsListbox(IRenderView renderView, Game game, Popup popup,
List <KeyValuePair <string, Action <int, string> > > items)
{
return(new ListBox(renderView, game, popup, items, new Rect(64, 85, 191, 38), new Position(67, 87), 7, 189, new Position(-2, -1), false, 5));
}
public static ListBox CreateSongListbox(IRenderView renderView, Game game, Popup popup,
List <KeyValuePair <string, Action <int, string> > > items)
{
return(new ListBox(renderView, game, popup, items, new Rect(32, 50, 192, 115),
new Position(36, 52), 7, 189, new Position(-3, -1), false, 16));
}
public RemoteInterface(IRenderView renderView, Audio.IAudioInterface audioInterface, Viewer viewer)
: base(renderView, audioInterface, viewer)
{
}
public ServerInterface(IRenderView renderView, Audio.IAudioInterface audioInterface, Viewer viewer, Network.ILocalServer server)
: base(renderView, audioInterface, viewer)
{
this.server = server;
}
/// <summary>
/// Project a point from world-space to a pixel position.
/// </summary>
public static PixelPosition ProjectPixel(this IRenderView rv, V3d point)
{
var ndcPoint = rv.Project(point);
return(new PixelPosition(ndcPoint, rv.Region));
}
protected override void OnInitialized(EventArgs e)
{
if (!IsD3D10Supported())
return;
var renderView = new RenderView();
var renderer = new TileControl.RendererD3DSharpDX();
renderer.RenderData = renderView.RenderData;
m_renderer = renderer;
m_renderView = renderView;
SetRenderer(renderer);
this.TileLayoutChanged += OnTileArrangementChanged;
this.AboutToRender += OnAboutToRender;
m_renderer.TileSet = GameData.Data.TileSet;
GameData.Data.TileSetChanged += OnTileSetChanged;
base.OnInitialized(e);
}
