public void setUp( Vector2 position, int width, int height, ILogic brain = null, BodyBase body = null, IRenderable renderer = null, IMovable mover = null )
{
// Start setUp.
if (!_setUp)
{ // Start not setup if.
_position = position;
_width = width;
_height = height;
_setUp = true;
if (brain != null)
_brain = brain;
if (body != null)
_body = body;
if (renderer != null)
_renderer = renderer;
if ( mover != null)
_mover = mover;
} // End not setup if.
}
/// <summary>
/// Initializes a new instance of GeometryNode.
/// </summary>
public GeometryNode(Renderer renderer, SceneGraph sceneGraph, Matrix localTransform,
IRenderable renderObject)
: base(renderer, sceneGraph)
{
this.localTransform = localTransform;
this.renderObject = renderObject;
}
public void Add(IRenderable renderable)
{
if(Children.Contains(renderable))
return;
Children.Add(renderable);
if(renderable is Mesh3d)
{
Mesh3d mesh = renderable as Mesh3d;
if(mesh.GetCollisionShape() != null || renderable is IPhysical)
{
lock(PhysicalWorld)
{
CollisionObjects.Add(renderable, mesh.CreateRigidBody());
mesh.PhysicalBody.SetSleepingThresholds(0, 0);
mesh.PhysicalBody.ContactProcessingThreshold = 0;
mesh.PhysicalBody.CcdMotionThreshold = 0;
PhysicalWorld.AddRigidBody(mesh.PhysicalBody);
}
}
}
else if(renderable is IPhysical)
{
IPhysical physicalObject = renderable as IPhysical;
lock(PhysicalWorld)
{
PhysicalWorld.AddRigidBody(physicalObject.GetRigidBody());
physicalObject.GetRigidBody().SetSleepingThresholds(0, 0);
physicalObject.GetRigidBody().ContactProcessingThreshold = 0;
physicalObject.GetRigidBody().CcdMotionThreshold = 0;
}
}
}
public RenderableNode(IRenderable renderableObject)
: base(Text.GetCapitalLetters(typeof(RenderableNode).GetType().Name) + '_' + ++count, SceneNodeType.Renderable)
{
IsLeaf = true;
this.RenderableObject = renderableObject;
renderableObject.ParentNode = this;
}
public void EnqueueForRendering(IRenderable obj)
{
char[,] objImage = obj.ImageProfile;
int imageRows = objImage.GetLength(0);
int imageCols = objImage.GetLength(1);
Point objTopLeft = obj.Bounds.TopLeft;
int lastRow = Math.Min(objTopLeft.Y + imageRows, this.consoleHeight);
int lastCol = Math.Min(objTopLeft.X + imageCols, this.consoleWidth);
for (int row = objTopLeft.Y; row < lastRow; row++)
{
for (int col = objTopLeft.X; col < lastCol; col++)
{
if (row >= 0 && row < this.consoleHeight &&
col >= 0 && col < this.consoleWidth)
{
this.consoleMatrix[row, col] =
objImage[row - objTopLeft.Y, col - objTopLeft.X];
}
}
}
}
public ReplaceRenderable(string NodeName, IRenderable NewRenderable)
{
this.NodeName = NodeName;
this.NewRenderable = NewRenderable;
OldRenderable = OutsideSimulatorApp.GetInstance().SceneRootNode.GetDescendant(NodeName).Renderable;
_isPerformed = false;
}
public static string GetDisplayName(IRenderable obj)
{
string name = obj.Name;
string[] parts = name.Split('/');
return parts[parts.Length-1];
}
/// <summary>
/// Add a IRenderable to this group
/// </summary>
/// <param name="renderable">IRenderable instance</param>
internal void AddRenderable(IRenderable renderable)
{
Material material = renderable.Material;
if (!material.IsTransparent) _solids.Add(renderable);
else _transparents.Add(renderable);
}
public void Add(IRenderable renderable)
{
lock (mRenderables)
{
mRenderables.Add(renderable);
}
}
public IconButton(IGameWindow window, Camera<OrthographicProjection> camera, Vector2 position, IRenderable renderable, Key? hotkey = null)
: base(window, camera, position)
{
Renderable = renderable;
IsSelected = false;
Hotkey = hotkey;
}
public void DrawObject(IRenderable obj)
{
Camera cam = (Camera) this.Game.Services.GetService(typeof(ICameraService));
Model m = obj.Model3D;
Matrix[] transforms = new Matrix[m.Bones.Count];
m.CopyAbsoluteBoneTransformsTo(transforms);
Matrix projection = cam.Projection;
Matrix view = cam.View;
foreach (ModelMesh mesh in m.Meshes)
{
foreach (BasicEffect effect in mesh.Effects)
{
effect.EnableDefaultLighting();
effect.View = view;
effect.Projection = projection;
effect.World = transforms[mesh.ParentBone.Index] * Matrix.CreateFromQuaternion(obj.Orientation) * Matrix.CreateTranslation(obj.Position + obj.PositionOffset);
}
mesh.Draw();
}
}
/// <summary>
/// Create the action to create an object
/// </summary>
/// <param name="parent">The parent scene node to which to attach the object</param>
/// <param name="renderable">The renderable to provide to the node</param>
public CreateObject(IRenderable renderable, Matrix transform)
{
IsPerformed = false;
ParentNode = OutsideSimulatorApp.GetInstance().SceneRootNode;
ChildName = (ParentNode.GetHashCode() + DateTime.Now.GetHashCode()).ToString();
Renderable = renderable;
Transform = transform;
}
/// <summary>
/// Setup constructor
/// </summary>
public PlanetSurface( float radius )
{
Graphics.Draw.StartCache( );
Graphics.Draw.Sphere( Graphics.Draw.NewSurface( Color.OliveDrab ), Point3.Origin, radius, 100, 100 );
m_Geometry = Graphics.Draw.StopCache( );
m_Technique = new TechniqueSelector( "Shared/diffuseLit.cgfx", true, "DefaultTechnique" );
}
/// <summary>
/// Initializes a new instance of RenderPacket.
/// </summary>
public RenderPacket( IRenderable renderObject, string materialName, Matrix localTransform,
List<object> extraData)
{
RenderObject = renderObject;
MaterialName = materialName;
LocalTransform = localTransform;
ExtraData = extraData;
}
public void ApplyInstanceParameters(IRenderable rObject)
{
foreach (InstanceParameter p in instanceParameters.Values)
{
//VerboseEvent.InstanceParameterSetting.Log(rObject.Name, p.Type.ToString());
p.Apply(rObject);
}
}
public void Render(IRenderable obj)
{
var image = this.AssetLoader.GetImage(obj.Type);
Canvas.SetLeft(image, obj.X);
Canvas.SetTop(image, obj.Y);
this.Canvas.Children.Add(image);
}
public Ship( )
{
// TODO: AP: Oh dear... get a proper model, loser
Graphics.Draw.StartCache( );
Graphics.Draw.Cylinder( Graphics.Surfaces.Green, Point3.Origin + Vector3.XAxis * 1.5f, Point3.Origin + Vector3.YAxis * 3.0f, 1.0f );
Graphics.Draw.Cylinder( Graphics.Surfaces.Green, Point3.Origin - Vector3.XAxis * 1.5f, Point3.Origin + Vector3.YAxis * 3.0f, 1.0f );
Graphics.Draw.Cylinder( Graphics.Surfaces.Green, Point3.Origin, Point3.Origin + Vector3.YAxis * 2.0f, 0.5f );
m_ShipGraphics = Graphics.Draw.StopCache( );
}
public GBSystem(IRenderable renderWindow, IInputHandler iInputHandler, ITimekeeper timeKeeper)
{
screen = renderWindow;
state = GBSystemState.Stopped;
isFocused = true;
inputHandler = iInputHandler;
frameTimer = timeKeeper;
frameLimitIndex = 1;
}
internal void SetDirection(IRenderable renderer, vec3 direction)
{
direction.y = 0;
direction = direction.normalize();
float cosRadian = direction.dot(new vec3(1, 0, 0));// (1, 0, 0) is teapot's default direction.
float radian = (float)Math.Acos(cosRadian);
if (direction.z > 0) { radian = -radian; }
renderer.RotationAngleDegree = (float)(radian * 180.0 / Math.PI);
}
public static string Render(IRenderable renderable)
{
var memoryStream = new MemoryStream();
var streamWriter = new StreamWriter(memoryStream, Encoding.UTF8);
streamWriter.AutoFlush = true;
renderable.Render(streamWriter);
memoryStream.Seek(0, SeekOrigin.Begin);
return new StreamReader(memoryStream, Encoding.UTF8).ReadToEnd();
}
public void update( IColidable body, IRenderable renderer )
{
// Start Update.
if( body.hasCollided && !( (AnimationComponent) renderer ).isRunning )
{
}
}
public void EnqueueForRendering(IRenderable objForRendering)
{
List<GameFieldCoords> objPosition = objForRendering.GetPosition();
foreach (GameFieldCoords position in objPosition)
{
this.gameField[position.Row, position.Col] = objForRendering.RenderingSymbol;
}
}
public static IRenderable Create(IRenderable parentElement, string ID)
{
var returnObj = new Renderable_IRenderable
{
parentElement = parentElement,
ID = ID,
};
return returnObj;
}
/// <summary>
/// Builds marble geometry
/// </summary>
private void BuildGeometry( Units.Metres radius )
{
DestroyGeometry( );
Graphics.Draw.StartCache( );
Graphics.Draw.Sphere( null, Point3.Origin, ( float )radius.ToAstroRenderUnits, 20, 20 );
m_Geometry = Graphics.Draw.StopCache( );
m_GeometryRadius = radius;
}
public void updateRenderableRenderLayer( IRenderable component, int oldRenderLayer, int newRenderLayer )
{
// a bit of care needs to be taken in case a renderLayer is changed before the component is "live". this can happen when a component
// changes its renderLayer immediately after being created
if( _componentsByRenderLayer.ContainsKey( oldRenderLayer ) && _componentsByRenderLayer[oldRenderLayer].contains( component ) )
{
_componentsByRenderLayer[oldRenderLayer].remove( component );
addToRenderLayerList( component, newRenderLayer );
}
}
static Projectile( )
{
ms_Surface = Graphics.Draw.NewSurface( Color.LimeGreen );
ms_Surface.State.DepthWrite = true;
ms_Surface.State.DepthTest = true;
Graphics.Draw.StartCache( );
Graphics.Draw.Sphere( ms_Surface, Point3.Origin, 0.2f );
ms_Cache = Graphics.Draw.StopCache( );
}
void addToRenderLayerList( IRenderable component, int renderLayer )
{
var list = componentsWithRenderLayer( renderLayer );
Assert.isFalse( list.contains( component ), "Component renderLayer list already contains this component" );
list.add( component );
if( !_unsortedRenderLayers.Contains( renderLayer ) )
_unsortedRenderLayers.Add( renderLayer );
_componentsNeedSort = true;
}
public override void Initialize()
{
_renderList = new Dictionary<IRenderable, List<Instance>>();
_lineRenderList = new List<LineInstance>();
_instance = this;
_cubeMeshWire = new CubeMeshWire();
_cubeMeshSolid = new CubeMeshSolid();
CreateShaderFromFile("debug", "shaders/debug_vs.glsl", "shaders/debug_fs.glsl");
}
internal static bool TryHandleAsBaseType(string baseType, SystemManagers systemManagers, out IRenderable containedObject)
{
bool handledAsBaseType = true;
containedObject = null;
switch (baseType)
{
case "Container":
LineRectangle lineRectangle = new LineRectangle(systemManagers);
containedObject = lineRectangle;
break;
case "Rectangle":
LineRectangle rectangle = new LineRectangle();
rectangle.IsDotted = false;
containedObject = rectangle;
break;
case "Circle":
LineCircle circle = new LineCircle();
circle.CircleOrigin = CircleOrigin.TopLeft;
containedObject = circle;
break;
case "ColoredRectangle":
SolidRectangle solidRectangle = new SolidRectangle();
containedObject = solidRectangle;
break;
case "Sprite":
Texture2D texture = null;
Sprite sprite = new Sprite(texture);
containedObject = sprite;
break;
case "NineSlice":
{
NineSlice nineSlice = new NineSlice();
containedObject = nineSlice;
}
break;
case "Text":
{
Text text = new Text(systemManagers, "");
containedObject = text;
}
break;
default:
handledAsBaseType = false;
break;
}
return handledAsBaseType;
}
/// <summary>
/// Prevents a default instance of the <see cref="GameEngine" /> class from being created.
/// Part of Singleton.
/// Starts the game if there are no errors.
/// </summary>
private GameEngine(IRenderable renderer)
{
try
{
this.StartNewGame(renderer);
}
catch (ArgumentOutOfRangeException ex)
{
renderer.Write(ex.Message);
}
}
private static int ZValueComparer(IRenderable first, IRenderable second)
{
return(first.ZValue - second.ZValue);
}
/// <summary>
/// Draws texture region taking into account the context transformations
/// </summary>
/// <param name="renderable"></param>
/// <param name="rectangle"></param>
/// <param name="color"></param>
public void Draw(IRenderable renderable, Rectangle rectangle, Color?color = null)
{
var c = color != null ? color.Value : Color.White;
renderable.Draw(Batch, rectangle, c * Opacity);
}
protected MeshListTreeNode createTMDNode(string name, TMDDocument tmdDoc)
{
MeshListTreeNode rootNode = new MeshListTreeNode(name, tmdDoc.ObjectMeshes, contextMenu: new ContextMenu(
new Dictionary <string, Action>
{
{
"Export as TMD",
() =>
{
_exportController.OpenDialog(
filePath => { _exportController.ExportOriginal(tmdDoc.Document, filePath); }, ".tmd");
}
},
{
"Export as OBJ",
() =>
{
_exportController.OpenDialog(
filePath => { _exportController.ExportOBJ(tmdDoc.ObjectMeshes, filePath); }, ".obj");
}
},
{
"Export as PLY",
() =>
{
_exportController.OpenDialog(
filePath => { _exportController.ExportPLY(tmdDoc.ObjectMeshes, filePath); }, ".ply");
}
},
}));
for (int i = 0; i < tmdDoc.Document.Header.NumObjects; i++)
{
IRenderable objMesh = tmdDoc.ObjectMeshes[i];
MeshListTreeNode objNode =
new MeshListTreeNode($"Object {i}", new List <IRenderable> {
objMesh
},
contextMenu: new ContextMenu(
new Dictionary <string, Action>
{
{
"Export as OBJ",
() =>
{
_exportController.OpenDialog(
filePath => { _exportController.ExportOBJ(objMesh, filePath); }, ".obj");
}
},
{
"Export as PLY",
() =>
{
_exportController.OpenDialog(
filePath => { _exportController.ExportPLY(objMesh, filePath); }, ".ply");
}
}
}));
rootNode.AddNode(objNode);
}
return(rootNode);
}
public void Remove(IRenderable item)
{
flaggedForRemoval.Add(item); item.OnCanvas = null;
}
/// <summary>
/// Draws texture region taking into account the context transformations
/// </summary>
/// <param name="renderable"></param>
/// <param name="rectangle"></param>
/// <param name="color"></param>
public void Draw(IRenderable renderable, Point location, Color?color = null)
{
var c = color != null ? color.Value : Color.White;
renderable.Draw(Batch, new Rectangle(location.X, location.Y, renderable.Size.X, renderable.Size.Y), c * Opacity);
}
/// <summary>
/// Initializes a new instance of the <see cref="Panel"/> class.
/// </summary>
/// <param name="content">The panel content.</param>
public Panel(IRenderable content)
{
_child = content ?? throw new System.ArgumentNullException(nameof(content));
}
public void AddOpaqueMesh(IRenderable mesh)
{
m_opaqueRenderList.Add(mesh);
}
public override bool Matches(Engine.VPT.Table.Table table, IRenderable item, RenderObject ro, GameObject obj)
{
return(RenderPipeline.Current == _type);
}
internal static bool TryHandleAsBaseType(string baseType, SystemManagers systemManagers, out IRenderable containedObject)
{
bool handledAsBaseType = true;
containedObject = null;
switch (baseType)
{
case "Container":
if (GraphicalUiElement.ShowLineRectangles)
{
LineRectangle lineRectangle = new LineRectangle(systemManagers);
containedObject = lineRectangle;
}
else
{
containedObject = new InvisibleRenderable();
}
break;
case "Rectangle":
LineRectangle rectangle = new LineRectangle(systemManagers);
rectangle.IsDotted = false;
containedObject = rectangle;
break;
case "Circle":
LineCircle circle = new LineCircle(systemManagers);
circle.CircleOrigin = CircleOrigin.TopLeft;
containedObject = circle;
break;
case "ColoredRectangle":
SolidRectangle solidRectangle = new SolidRectangle();
containedObject = solidRectangle;
break;
case "Sprite":
Texture2D texture = null;
Sprite sprite = new Sprite(texture);
containedObject = sprite;
break;
case "NineSlice":
{
NineSlice nineSlice = new NineSlice();
containedObject = nineSlice;
}
break;
case "Text":
{
Text text = new Text(systemManagers, "");
containedObject = text;
}
break;
default:
handledAsBaseType = false;
break;
}
return(handledAsBaseType);
}
public void AddTransparentMesh(IRenderable mesh)
{
m_transparentRenderList.Add(mesh);
}
private PictureBox GetPictureBoxByObject(IRenderable renderableObject)
{
return(this.pictureBoxes.First(p => p.Tag == renderableObject));
}
public void InsertRenderable(IRenderable r, int inder) => Pipeline = Pipeline.Insert(inder, r);
/// <summary>
/// Initializes a new instance of the <see cref="Tree"/> class.
/// </summary>
/// <param name="renderable">The tree label.</param>
public Tree(IRenderable renderable)
{
_root = new TreeNode(renderable);
}
public void AddRenderable(IRenderable r) => Pipeline = Pipeline.Add(r);
public void AddRenderable(IRenderable renderable)
{
_renderables.Add(renderable);
_renderables.Sort(ZValueComparer);
}
public override void InsertItem(int index, IRenderable el)
{
throw new NotImplementedException();
}
public bool Contains(IRenderable renderable)
{
return(_renderables.Contains(renderable));
}
public abstract void Render(IRenderable renderable, SpriteBatch batch);
internal CommandAppException(string message, Exception ex, IRenderable pretty = null)
: base(message, ex)
{
Pretty = pretty;
}
public ViewResult(IRenderable view)
{
this.View = view;
}
public void Render(RenderContext context, IViewport target, CommandList cl, IRenderable renderable, ILocation locationObject)
{
//
}
internal CommandTemplateException(string message, string template, IRenderable pretty)
: base(message, pretty)
{
Template = template;
}
public void Render(GraphicsDevice gd, CommandList cl, SceneContext sc, RenderPasses renderPass, IRenderable r)
{
cl.SetPipeline(_pipeline);
cl.SetGraphicsResourceSet(0, sc.MainSceneViewResourceSet);
cl.SetVertexBuffer(0, _vb);
cl.SetIndexBuffer(_ib, IndexFormat.UInt16);
cl.DrawIndexed(6, 1, 0, 0, 0);
}
public AsteroidActor(IRenderable model, Vector4 position, Vector4 direction, Vector4 rotation, float velocity)
: base(model, position, direction, rotation, velocity)
{
}
protected override UIElement removeItem(IRenderable el)
{
throw new NotImplementedException();
}
//Implement a base rendering of an element
public override void RenderShadow(IRenderable element, Graphics graphics, Render render)
{
Link link = element as Link;
if (link.Points == null)
{
return;
}
if (link.Points.Count < 2)
{
return;
}
PointF startLocation = (PointF)link.Points[0];
PointF startReference = (PointF)link.Points[1];
PointF endLocation = (PointF)link.Points[link.Points.Count - 1];
PointF endReference = (PointF)link.Points[link.Points.Count - 2];
startLocation = Geometry.OffsetPoint(startLocation, link.Bounds.Location);
startReference = Geometry.OffsetPoint(startReference, link.Bounds.Location);
endLocation = Geometry.OffsetPoint(endLocation, link.Bounds.Location);
endReference = Geometry.OffsetPoint(endReference, link.Bounds.Location);
Layer layer = link.Layer;
Pen shadowPen = new Pen(layer.ShadowColor);
GraphicsPath shadowPath = link.GetPath();
shadowPen.Color = render.AdjustColor(layer.ShadowColor, 0, link.Opacity);
//Save the current region
Region current = graphics.Clip;
//Mask out the start marker
if (link.Start.Marker != null)
{
Region region = new Region(link.Start.Marker.GetPath());
region.Transform(Link.GetMarkerTransform(link.Start.Marker, startLocation, startReference, new Matrix()));
region.Translate(layer.ShadowOffset.X, layer.ShadowOffset.Y);
graphics.SetClip(region, CombineMode.Exclude);
}
//Mask out the end marker
if (link.End.Marker != null)
{
Region region = new Region(link.End.Marker.GetPath());
region.Transform(Link.GetMarkerTransform(link.End.Marker, endLocation, endReference, new Matrix()));
region.Translate(layer.ShadowOffset.X, layer.ShadowOffset.Y);
graphics.SetClip(region, CombineMode.Exclude);
}
graphics.TranslateTransform(layer.ShadowOffset.X, layer.ShadowOffset.Y);
//Draw line
if (layer.SoftShadows)
{
shadowPen.Color = Color.FromArgb(20, shadowPen.Color);
graphics.CompositingQuality = CompositingQuality.HighQuality;
graphics.SmoothingMode = SmoothingMode.HighQuality;
}
graphics.DrawPath(shadowPen, shadowPath);
if (layer.SoftShadows)
{
graphics.CompositingQuality = render.CompositingQuality;
graphics.SmoothingMode = link.SmoothingMode;
}
//Restore graphics
if (link.Start.Marker != null || link.End.Marker != null)
{
graphics.Clip = current;
if (link.Start.Marker != null)
{
RenderMarkerShadow(link.Start.Marker, startLocation, startReference, graphics, render);
}
if (link.End.Marker != null)
{
RenderMarkerShadow(link.End.Marker, endLocation, endReference, graphics, render);
}
}
graphics.TranslateTransform(-layer.ShadowOffset.X, -layer.ShadowOffset.Y);
}
public void Add(IRenderable plottable)
{
settings.Plottables.Add(plottable);
}
public void Add(IRenderable item)
{
activeItems.Add(item);
item.OnCanvas = this;
isRenderablesOrderDirty = true;
}
private Image GetImageByDirection(IRenderable renderableObject)
{
Image image;
WarUnit u = (WarUnit)renderableObject;
switch (renderableObject.SpriteType)
{
case SpriteType.Mage:
if (u.Direction.X == 1 && u.Direction.Y == 0)
{
image = this.mageImageR;
}
else if (u.Direction.X == -1 && u.Direction.Y == 0)
{
image = this.mageImageL;
}
else if (u.Direction.X == 0 && u.Direction.Y == -1)
{
image = this.mageImageU;
}
else if (u.Direction.X == 0 && u.Direction.Y == 1)
{
image = this.mageImageD;
}
else
{
image = this.mageImage;
}
break;
case SpriteType.Fire:
image = this.fireImage;
break;
case SpriteType.Ghoul:
if (u.Direction.X == 1 && u.Direction.Y == 0)
{
image = this.ghoulImageL;
}
else if (u.Direction.X == -1 && u.Direction.Y == 0)
{
image = this.ghoulImageR;
}
else if (u.Direction.X == 0 && u.Direction.Y == -1)
{
image = this.ghoulImageU;
}
else if (u.Direction.X == 0 && u.Direction.Y == 1)
{
image = this.ghoulImageD;
}
else
{
image = this.ghoulImageD;
}
break;
case SpriteType.FireMagic:
image = this.fireItem;
break;
case SpriteType.StoneMagic:
image = this.stoneItem;
break;
case SpriteType.LifeMagic:
image = this.lifeItem;
break;
case SpriteType.CharmMagic:
image = this.charmItem;
break;
case SpriteType.Stone:
image = this.stoneOnThrow;
break;
case SpriteType.Spit:
image = this.spitImage;
break;
default:
image = this.wallImage;
break;
}
return(image);
}
private Image GetSpriteImage(IRenderable renderableObject)
{
Image image;
switch (renderableObject.SpriteType)
{
case SpriteType.Mage:
image = this.mageImage;
break;
case SpriteType.Fire:
image = this.fireImage;
break;
case SpriteType.Ghoul:
image = this.ghoulImage;
break;
case SpriteType.Spit:
image = this.spitImage;
break;
case SpriteType.FireMagic:
image = this.fireItem;
break;
case SpriteType.StoneMagic:
image = this.stoneItem;
break;
case SpriteType.LifeMagic:
image = this.lifeItem;
break;
case SpriteType.CharmMagic:
image = this.charmItem;
break;
case SpriteType.Stone:
image = this.stoneOnThrow;
break;
case SpriteType.Blood:
image = this.bloodImage;
break;
case SpriteType.Skeleton1:
image = this.skeleton1;
break;
case SpriteType.Skeleton2:
image = this.skeleton2;
break;
case SpriteType.Skeleton3:
image = this.skeleton3;
break;
case SpriteType.Skeleton4:
image = this.skeleton4;
break;
case SpriteType.MonsterDead:
image = this.MonsterDead;
break;
default:
image = this.wallImage;
break;
}
return(image);
}
