public void drawBefore(QuarterViewDrawer view, DrawContextEx canvas)
{
if (anchor != UNPLACED && isPlacing)
{
canvas.tag = type.canBeBuilt(anchor, currentPos);
}
}
public void drawVoxel(QuarterViewDrawer view, DrawContextEx canvas, Location loc, Point pt)
{
if (currentCube.contains(loc))
{
alphaSprites.getSprite(loc - this.location).drawAlpha(canvas.surface, pt);
}
}
public void drawVoxel(QuarterViewDrawer view, DrawContextEx dc, Location loc, Point pt)
{
if (World.world[loc] == null)
{
ResourceUtil.emptyChip.drawShape(dc.surface, pt, Color.Red);
}
}
public void drawVoxel(QuarterViewDrawer view, DrawContextEx canvas, Location loc, Point pt)
{
if (Cube.createExclusive(baseLoc, alphaSprites.size).contains(loc))
{
alphaSprites.getSprite(loc - baseLoc).drawAlpha(canvas.surface, pt);
}
}
public void drawBefore(QuarterViewDrawer view, DrawContextEx canvas)
{
if (anchor != UNPLACED && isPlacing && isPassage)
{
canvas.tag = canBuildPassageway(anchor, location);
}
}
public override void drawVoxel(QuarterViewDrawer view, DrawContextEx canvas, Location loc, Point pt)
{
if (base.currentPos != loc)
{
return;
}
if (!contribution.canBeBuilt(loc))
{
return;
}
int x;
RoadPattern rp = TrafficVoxel.get(loc).road.pattern;
if (rp.hasRoad(Direction.NORTH))
{
x = 0;
}
else
{
x = 1;
}
contribution.sprites[color, x].drawAlpha(canvas.surface, pt);
}
public void drawVoxel(QuarterViewDrawer view, DrawContextEx canvas, Location loc, Point pt)
{
if (loc.z != currentLoc.z)
{
return;
}
if (anchor != UNPLACED && loc.inBetween(anchor, currentLoc))
{
Location loc1 = base.location1;
Location loc2 = base.location2;
//contrib.sprites[contrib.getIndex(loc1.x,loc.x,loc2.x), contrib.getIndex(loc1.y,loc.y,loc2.y)]
if (loc1.x == loc.x)
{
contrib.sprites[Direction.WEST.index / 2].drawAlpha(canvas.surface, pt);
}
if (loc1.y == loc.y)
{
contrib.sprites[Direction.NORTH.index / 2].drawAlpha(canvas.surface, pt);
}
if (loc2.x == loc.x)
{
contrib.sprites[Direction.EAST.index / 2].drawAlpha(canvas.surface, pt);
}
if (loc2.y == loc.y)
{
contrib.sprites[Direction.SOUTH.index / 2].drawAlpha(canvas.surface, pt);
}
}
}
public void drawVoxel(QuarterViewDrawer view, DrawContextEx dc, Location loc, Point pt)
{
if (baseLoc == loc)
{
strategy.drawVoxel(view, dc, loc, pt);
}
}
/// <summary>
///
/// </summary>
/// <param name="view"></param>
/// <param name="canvas"></param>
public void DrawBefore(QuarterViewDrawer view, DrawContext canvas)
{
if (anchor != Unplaced && isPlacing)
{
canvas.Tag = Type.CanBeBuilt(anchor, currentPos);
}
}
//
// MapOverlay implementation
//
public void drawVoxel(QuarterViewDrawer view, DrawContextEx context, Location loc, Point pt)
{
JunctionRailRoad jrr = JunctionRailRoad.get(loc);
if (jrr == null)
{
return;
}
// draw an arrow that indicates the direction to go
JunctionRoute go; bool isSimple = true;
Junction j = controller.getJunction(loc);
if (j == null)
{
go = JunctionRoute.Straight;
}
else
{
go = j.defaultRoute;
if (j.advancedRules.Count != 0)
{
isSimple = false;
}
}
// draw an arrow.
pt.Y -= 2;
jrr.getDirection(go).drawArrow(context.surface, pt, !isSimple);
}
/// <summary>
///
/// </summary>
/// <param name="view"></param>
/// <param name="canvas"></param>
/// <param name="loc"></param>
/// <param name="pt"></param>
public void DrawVoxel(QuarterViewDrawer view, DrawContext canvas, Location loc, Point pt)
{
if (loc != anchor)
{
return;
}
if (anchor.Equals(currentPos))
{
cursors[0].Draw(canvas.Surface, pt);
}
else
{
//HalfDividedVoxel v = World.world[loc] as HalfDividedVoxel;
int n, m, l;
n = remover ? 5 : 1;
m = front.isParallelToX ? 0 : 1;
l = (currentSide == PlaceSide.Back) ? 0 : 2;
cursors[n + m + l].Draw(canvas.Surface, pt);
if (!remover)
{
contrib.GetSprite(front, currentSide, contrib.currentColor).DrawAlpha(canvas.Surface, pt);
ISprite hls = contrib.GetHighLightSprite(front, currentSide, contrib.currentHighlight);
if (hls != null)
{
hls.DrawAlpha(canvas.Surface, pt);
}
}
}
}
public void drawVoxel(QuarterViewDrawer view, DrawContextEx dc, Location loc, Point pt)
{
if (World.world[loc] is MountainVoxel)
{
ResourceUtil.emptyChip.drawAlpha(dc.surface, new Point(pt.X, pt.Y - 16));
TerraceVoxel.image.drawAlpha(dc.surface, pt);
}
}
public void drawVoxel(QuarterViewDrawer view, DrawContextEx dc, Location loc, Point pt)
{
if (loc == baseLoc)
{
RailPattern.get(currentDirection, currentDirection.opposite)
.drawAlpha(dc.surface, pt);
currentType.getSprite(currentDirection)
.drawAlpha(dc.surface, pt);
}
}
public void drawAfter(QuarterViewDrawer view, DrawContextEx canvas)
{
// determine the rect
Rectangle r = _rect;
Point pt = view.origin;
r.Offset(-pt.X, -pt.Y);
canvas.graphics.DrawRectangle(pen, r);
}
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
ddraw = new WindowedDirectDraw(this);
drawer = new QuarterViewDrawer(world, ddraw,
new Rectangle(this.scrollPos, ClientSize));
drawer.OnUpdated += new EventHandler(onDrawerUpdated);
weatherOverlay = NullWeatherOverlay.theInstance;
}
public void drawVoxel(QuarterViewDrawer view, DrawContextEx canvas, Location loc, Point pt)
{
object tag = canvas.tag;
if (tag != null && (bool)tag && loc.inBetween(anchor, location))
{
PassagewayRail.getFloatingSprite(anchor.getDirectionTo(location))
.drawAlpha(canvas.surface, pt);
}
}
/// <summary>
///
/// </summary>
/// <param name="view"></param>
/// <param name="canvas"></param>
/// <param name="loc"></param>
/// <param name="pt"></param>
public void DrawVoxel(QuarterViewDrawer view, DrawContext canvas, Location loc, Point pt)
{
object tag = canvas.Tag;
if (tag != null && (bool)tag && inBetween(loc, anchor, currentPos))
{
Direction d = anchor.getDirectionTo(currentPos);
Draw(d, canvas, pt);
}
}
public void drawBefore(QuarterViewDrawer view, DrawContextEx surface)
{
if (anchor != UNPLACED && currentLoc != UNPLACED)
{
// compute the route
route = contrib.computeRoute(anchor, currentLoc);
}
else
{
route = null;
}
}
public void drawVoxel(QuarterViewDrawer view, DrawContextEx canvas, Location loc, Point pt)
{
if (loc.z != currentLoc.z)
{
return;
}
if (anchor != UNPLACED && loc.inBetween(anchor, currentLoc))
{
spriteBuilder().drawAlpha(canvas.surface, pt);
}
}
public void drawBefore(QuarterViewDrawer view, DrawContextEx canvas)
{
if (anchor != UNPLACED && isPlacing)
{
int cost;
canvas.tag = SingleRailRoad.comupteRoute(anchor, currentPos, out cost);
if (canvas.tag != null)
{
Debug.WriteLine(((IDictionary)canvas.tag).Count);
}
}
}
public void drawVoxel(QuarterViewDrawer view, DrawContextEx canvas, Location loc, Point pt)
{
if (loc.z != currentLoc.z)
{
return;
}
if (route != null && route.Contains(loc))
{
contrib.getSprite((Dir)route[loc]).drawAlpha(canvas.surface, pt);
}
}
/// <summary>
///
/// </summary>
/// <param name="view"></param>
/// <param name="canvas"></param>
/// <param name="loc"></param>
/// <param name="pt"></param>
public void DrawVoxel(QuarterViewDrawer view, DrawContext canvas, Location loc, Point pt)
{
if (loc.z != CurrentLocation.z)
{
return;
}
if (Anchor != Unplaced && loc.inBetween(Anchor, CurrentLocation))
{
spriteBuilder().DrawAlpha(canvas.Surface, pt);
}
}
/// <summary>
///
/// </summary>
/// <param name="view"></param>
/// <param name="canvas"></param>
public void DrawBefore(QuarterViewDrawer view, DrawContext canvas)
{
if (anchor != unplaced && IsPlacing)
{
int cost;
canvas.Tag = SingleRailRoad.ComputeRoute(anchor, currentPosition, out cost);
if (canvas.Tag != null)
{
Debug.WriteLine(((IDictionary)canvas.Tag).Count);
}
}
}
public HeightCutWindow(MapViewWindow mapView, QuarterViewDrawer drawer)
{
this.mapView = mapView;
this.drawer = drawer;
InitializeComponent();
trackBar.Minimum = 0;
trackBar.Maximum = world.World.world.size.z - 1;
trackBar.Value = drawer.heightCutHeight;
drawer.OnHeightCutChanged += new EventHandler(onHeightCutChange);
}
public void drawVoxel(QuarterViewDrawer view, DrawContextEx canvas, Location loc, Point pt)
{
//if( loc.z != currentLoc.z ) return;
if (anchor != UNPLACED && loc.inBetween(anchor, currentPos))
{
Location loc1 = base.location1;
Location loc2 = base.location2;
Direction side = base.currentSide;
//contrib.sprites[contrib.getIndex(loc1.x,loc.x,loc2.x), contrib.getIndex(loc1.y,loc.y,loc2.y)]
contrib.sprites[currentSide.index / 2].drawAlpha(canvas.surface, pt);
}
}
public override void drawVoxel(QuarterViewDrawer view, DrawContextEx canvas, Location loc, Point pt)
{
if (base.currentPos != loc)
{
return;
}
ElectricPole e = ElectricPole.get(loc);
if (e != null)
{
ResourceUtil.emptyChip.drawShape(canvas.surface, pt, Color.Red);
}
}
/// <summary>
///
/// </summary>
/// <param name="view"></param>
/// <param name="canvas"></param>
/// <param name="loc"></param>
/// <param name="pt"></param>
public void DrawVoxel(QuarterViewDrawer view, DrawContext canvas, Location loc, Point pt)
{
if (!IsPlacing)
{
return;
}
if (alphaSprites != null)
{
if (Cube.CreateExclusive(baseLoc, alphaSprites.size).Contains(loc))
{
alphaSprites.getSprite(loc - baseLoc).DrawAlpha(canvas.Surface, pt);
}
}
}
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
ddraw = new WindowedDirectDraw(this);
drawer = new QuarterViewDrawer(World.world, ddraw,
new Rectangle(this.scrollPos, ClientSize));
drawer.OnUpdated += new EventHandler(onDrawerUpdated);
weatherOverlay = NullWeatherOverlay.theInstance;
// TODO
// TEST: TODO
// weatherOverlay = new WeatherOverlayImpl( new WeatherOverlaySpriteSet(
// "{9B411B87-07F4-451b-93D0-2922EE62461B}",8,new Size(64,128)));
}
/// <summary>
///
/// </summary>
/// <param name="view"></param>
/// <param name="canvas"></param>
/// <param name="loc"></param>
/// <param name="pt"></param>
public void DrawVoxel(QuarterViewDrawer view, DrawContext canvas, Location loc, Point pt)
{
if (loc.z != CurrentLocation.z)
{
return;
}
if (Anchor != Unplaced && loc.inBetween(Anchor, CurrentLocation))
{
Location loc1 = base.LocationNW;
Location loc2 = base.LocationSE;
contrib.Sprites[contrib.GetSpriteIndex(loc.x, loc.y, loc1.x, loc1.y, loc2.x, loc2.y)]
.DrawAlpha(canvas.Surface, pt);
}
}
public void drawVoxel(QuarterViewDrawer view, DrawContextEx canvas, Location loc, Point pt)
{
if (loc.z != currentLoc.z)
{
return;
}
if (anchor != UNPLACED && loc.inBetween(anchor, currentLoc))
{
Location loc1 = base.location1;
Location loc2 = base.location2;
contrib.sprites[contrib.getSpriteIndex(loc.x, loc.y, loc1.x, loc1.y, loc2.x, loc2.y)]
.drawAlpha(canvas.surface, pt);
}
}
