public void RedrawOreAndGems()
{
var tileCollection = _theater.GetTileCollection();
var checkFunc = new Func <OverlayObject, bool>(delegate(OverlayObject ovl) {
return(SpecialOverlays.GetOverlayTibType(ovl, Engine) != OverlayTibType.NotSpecial);
});
// first redraw all required tiles (zigzag method)
for (int y = 0; y < FullSize.Height; y++)
{
for (int x = FullSize.Width * 2 - 2; x >= 0; x -= 2)
{
if (_tiles[x, y].AllObjects.OfType <OverlayObject>().Any(checkFunc))
{
_theater.Draw(_tiles.GetTile(x, y), _drawingSurface);
}
}
for (int x = FullSize.Width * 2 - 3; x >= 0; x -= 2)
{
if (_tiles[x, y].AllObjects.OfType <OverlayObject>().Any(checkFunc))
{
_theater.Draw(_tiles.GetTile(x, y), _drawingSurface);
}
}
}
for (int y = 0; y < FullSize.Height; y++)
{
for (int x = FullSize.Width * 2 - 2; x >= 0; x -= 2)
{
if (_tiles[x, y].AllObjects.OfType <OverlayObject>().Any(checkFunc))
{
List <GameObject> objs = GetObjectsAt(x, y);
foreach (GameObject o in objs)
{
_theater.Draw(o, _drawingSurface);
}
}
}
for (int x = FullSize.Width * 2 - 3; x >= 0; x -= 2)
{
if (_tiles[x, y].AllObjects.OfType <OverlayObject>().Any(checkFunc))
{
List <GameObject> objs = GetObjectsAt(x, y);
foreach (GameObject o in objs)
{
_theater.Draw(o, _drawingSurface);
}
}
}
}
}
public void MarkOreAndGems()
{
Logger.Info("Marking ore and gems");
var markerPalettes = new Dictionary <OverlayTibType, Palette>();
// init sensible defaults
if (Engine >= EngineType.RedAlert2)
{
markerPalettes[OverlayTibType.Ore] = Palette.MakePalette(Color.Yellow);
markerPalettes[OverlayTibType.Gems] = Palette.MakePalette(Color.Purple);
}
// read [Tiberiums] for names or different tiberiums, and the [Color] entry (for TS)
// for their corresponding "remapped" color. In RA2 this isn't actually used,
// but made available for the renderer's preview functionality through a key "MapRendererColor"
var tiberiums = _rules.GetOrCreateSection("Tiberiums").OrderedEntries.Select(kvp => kvp.Value).ToList();
var remaps = tiberiums.Select(tib => _rules.GetOrCreateSection(tib)
.ReadString(Engine >= EngineType.RedAlert2 ? "MapRendererColor" : "Color")).ToList();
// override defaults if specified in rules
for (int i = 0; i < tiberiums.Count; i++)
{
OverlayTibType type = (OverlayTibType)Enum.Parse(typeof(OverlayTibType), tiberiums[i]);
string namedColor = remaps[i];
if (_namedColors.ContainsKey(namedColor))
{
markerPalettes[type] = Palette.MakePalette(_namedColors[namedColor]);
}
}
// apply the 'marking' by replacing the tile containing ore by a partly
// transparent version of its original, merged with a palette of solely
// the color of the tiberium kind stored on it
foreach (var o in _overlayObjects)
{
if (o == null)
{
continue;
}
var ovlType = SpecialOverlays.GetOverlayTibType(o, Engine);
if (!markerPalettes.ContainsKey(ovlType))
{
continue;
}
double opacityBase = ovlType == OverlayTibType.Ore && Engine == EngineType.RedAlert2 ? 0.3 : 0.15;
double opacity = Math.Max(0, 12 - o.OverlayValue) / 11.0 * 0.5 + opacityBase;
o.Tile.Palette = Palette.Merge(o.Tile.Palette, markerPalettes[ovlType], opacity);
o.Palette = Palette.Merge(o.Palette, markerPalettes[ovlType], opacity);
}
}
private void ApplyRemappables()
{
int before = _palettesToBeRecalculated.Count;
foreach (OwnableObject obj in _structureObjects.Cast <OwnableObject>().Union(_unitObjects).Union(_aircraftObjects).Union(_infantryObjects))
{
var g = obj as GameObject;
if (g != null & g.Drawable != null && g.Drawable.IsRemapable)
{
if (g.Palette.IsShared) // don't wanna touch somebody elses palette..
{
g.Palette = g.Palette.Clone();
}
var color = _countryColors.ContainsKey(obj.Owner) ? _countryColors[obj.Owner] : _countryColors.First().Value;
g.Palette.Remap(color);
_palettesToBeRecalculated.Add(g.Palette);
}
}
// TS needs tiberium remapped
if (Engine <= EngineType.Firestorm)
{
var tiberiums = _rules.GetSection("Tiberiums").OrderedEntries.Select(tib => tib.Value.ToString());
var remaps = tiberiums.Select(tib => _rules.GetOrCreateSection(tib).ReadString("Color"));
var tibRemaps = tiberiums.Zip(remaps, (k, v) => new { k, v }).ToDictionary(x => x.k, x => x.v);
foreach (var ovl in _overlayObjects)
{
if (ovl == null)
{
continue;
}
var tibType = SpecialOverlays.GetOverlayTibType(ovl, Engine);
if (tibType != OverlayTibType.NotSpecial)
{
ovl.Palette = ovl.Palette.Clone();
string tibName = SpecialOverlays.GetTibName(ovl, Engine);
if (tibRemaps.ContainsKey(tibName) && _namedColors.ContainsKey(tibRemaps[tibName]))
{
ovl.Palette.Remap(_namedColors[tibRemaps[tibName]]);
}
_palettesToBeRecalculated.Add(ovl.Palette);
}
}
}
Logger.Debug("Determined palettes to be recalculated due to remappables ({0})",
_palettesToBeRecalculated.Count - before);
}
private void LoadOverlayDrawable(Drawable drawable)
{
int objIdx = _drawables.Count - 1;
var ovl = new OverlayObject((byte)objIdx, 0);
var tibType = SpecialOverlays.GetOverlayTibType(ovl, Engine);
DrawProperties props = drawable.Props;
if (Engine >= EngineType.RedAlert2)
{
if (tibType != OverlayTibType.NotSpecial)
{
props.FrameDecider = FrameDeciders.OverlayValueFrameDecider;
props.PaletteType = PaletteType.Overlay;
props.LightingType = LightingType.None;
}
else if (SpecialOverlays.IsHighBridge(ovl))
{
props.OffsetHack = OffsetHacks.RA2BridgeOffsets;
props.ShadowOffsetHack = OffsetHacks.RA2BridgeShadowOffsets;
drawable.TileElevation = 4; // for lighting
drawable.Foundation = new Size(3, 1); // ensures they're drawn later --> fixes overlap
}
}
else if (Engine <= EngineType.Firestorm)
{
if (tibType != OverlayTibType.NotSpecial)
{
props.FrameDecider = FrameDeciders.OverlayValueFrameDecider;
props.PaletteType = PaletteType.Unit;
props.LightingType = LightingType.None;
drawable.IsRemapable = true;
}
else if (SpecialOverlays.IsHighBridge(ovl) || SpecialOverlays.IsTSHighRailsBridge(ovl))
{
props.OffsetHack = OffsetHacks.TSBridgeOffsets;
props.ShadowOffsetHack = OffsetHacks.TSBridgeShadowOffsets;
drawable.TileElevation = 4; // for lighting
//drawable.Foundation = new Size(3, 1); // ensures they're drawn later --> fixes overlap
}
}
}
