internal SpriteDefinition(SpriteSheet spriteSheet, string name, RectangleInt rectangle, Vector? origin)
{
this.SpriteSheet = spriteSheet;
this.Name = name;
this.Rectangle = rectangle;
this.Origin = origin.HasValue ? origin.Value : Vector.Zero;
}
public Sprite(SpriteSheet spriteSheet, string name, Vector2i size, Box2 coordinates)
{
SpriteSheet = spriteSheet;
Name = name;
Size = size;
Coordinates = coordinates;
}
protected Obstacle(SpriteSheet spriteSheet, float x, float y)
{
this.SpriteSheet = spriteSheet;
this.X = x;
this.Y = y;
this.BoundingBox = new FloatRect(this.X + 5, this.Y, 40, 40);
}
private Assets(ContentManager content)
{
Assets.content = content;
player = new SpriteSheet("player");
gremlins = new SpriteSheet("gremlins");
guys = new SpriteSheet("guys");
walls = new SpriteSheet("walls");
titlescreen = content.Load<Texture2D>("titlescreen");
winscreen = content.Load<Texture2D>("winscreen2");
boom = content.Load<SoundEffect>("boom");
death = content.Load<SoundEffect>("death");
gethat = content.Load<SoundEffect>("gethat");
hit = content.Load<SoundEffect>("hit");
jump = content.Load<SoundEffect>("jump");
launch = content.Load<SoundEffect>("launch");
oof = content.Load<SoundEffect>("oof");
pew = content.Load<SoundEffect>("pew");
splat = content.Load<SoundEffect>("splat");
startgame = content.Load<SoundEffect>("startgame");
assets = this;
}
public static void Init()
{
explosions = new List<Explosion>();
explosionsToBeRemoved = new List<Explosion>();
ss = new SpriteSheet(6, 8, spriteWidth, spriteHeight, "Resources\\SpriteSheets\\explosion.png");
//explosions.Add(new Explosion(new Vector3(0,0,-200f), 50, 50));
}
/// <summary>
/// Sets the screen up (UI components, multimedia content, etc.)
/// </summary>
public override void Initialize()
{
base.Initialize();
//Create Physicworld
CreatePhysicWorld(new Vector2(0, -20), true, false, Vector2.Zero);
Sprite sand = new Sprite("sand", ResourceManager.CreateImage(Color.Transparent, (int)Preferences.Width, 65));
AddComponent(sand, 0, 415, BodyShape.SQUARE, BodyType.STATIC, Category.All);
//Background
SetBackground(ResourceManager.CreateImage("Images/background"), Adjustment.CENTER);
spriteSheet = ResourceManager.CreateSpriteSheet("Images/spritesheet");
//Canyon
CreateCanyon(new Vector2(620,274));
//Clowns castle
CreateCastle(new Vector2(28,310));
//Helpers
aux_offset = Vector2.Zero;
timer = TimeSpan.Zero;
iball = ResourceManager.CreateImage("Images/ball");
layer = new Layer();
Button breset = new Button(spriteSheet["bt_reset"], spriteSheet["bt_reset_pressed"]);
breset.Released += new Component.ComponentEventHandler(breset_Released);
AddComponent(breset, Preferences.ViewportManager.RightAnchor - breset.Size.X, 0);
}
public SpriteGameObject(string assetname, int layer = 0, string id = "", int sheetIndex = 0)
: base(layer, id)
{
if (assetname != "")
sprite = new SpriteSheet(assetname, sheetIndex);
else
sprite = null;
}
/// <summary>Create a new sprite game object.</summary>
/// <param name="assetname">The name of the sprite file.</param>
/// <param name="layer">The layer the object is in.</param>
/// <param name="id">The ID to refer to the object.</param>
/// <param name="sheetIndex">The index of the sprite in a sprite string or sheet.</param>
/// <param name="paralax">The paralax mode that applies to this object.</param>
public SpriteGameObject(string assetname, int layer = 0, string id = "", int sheetIndex = 0, Backgroundlayer paralax = Backgroundlayer.solid) : base(layer, id)
{
if (assetname != "")
sprite = new SpriteSheet(assetname, sheetIndex);
else
sprite = null;
this.paralax = paralax;
}
public SpaceWorld(Game game, SpriteSheet spriteSheet, GameplayScreen screen, bool tutorial)
: base(game, new Vector2(0, 0))
{
Tutorial = tutorial;
GameScreen = screen;
this._spriteSheet = spriteSheet;
this._Font = new ImageFont();
}
protected override async Task LoadContent()
{
await base.LoadContent();
spriteBatch = new SpriteBatch(GraphicsDevice);
sphere = Asset.Load<Texture>("Sphere");
rotatedImages = Asset.Load<SpriteSheet>("RotatedImages");
}
protected override async Task LoadContent()
{
await base.LoadContent();
spriteUv = Asset.Load<SpriteSheet>("SpriteUV");
spriteSphere = Asset.Load<SpriteSheet>("SpriteSphere");
spriteBatch = new SpriteBatch(GraphicsDevice);
}
public void ChangeSheet()
{
//Change sheet
currentSheet = spriteSheets[currentAnim.sheetNum];
//Find frame data for new spritesheet
FrameData();
}
public void testOneFrameInSprite()
{
SpriteSheet testSheet = new SpriteSheet(20, 20);
testSheet.createStructure(1, 1);
Assert.AreEqual(1, testSheet.Location.GetLength(0));
Assert.AreEqual(1, testSheet.Location.GetLength(1));
Assert.AreEqual(testSheet.frameDimX * 0, testSheet.getFrameLocationOnSheetAt(0, 0).X, "At Col = 0");
Assert.AreEqual(testSheet.frameDimY * 0, testSheet.getFrameLocationOnSheetAt(0, 0).Y, "At Row = 0");
}
public ThreeColorGameObject(string redAssetName, string greenAssetName, string blueAssetName)
: base("")
{
colorRed = new SpriteSheet(redAssetName);
colorGreen = new SpriteSheet(greenAssetName);
colorBlue = new SpriteSheet(blueAssetName);
Color = Color.Blue;
}
protected override async Task LoadContent()
{
await base.LoadContent();
batch = new Sprite3DBatch(GraphicsDevice);
sphere = Asset.Load<Texture>("Sphere");
rotatedImages = Asset.Load<SpriteSheet>("RotatedImages");
rasterizerState = RasterizerState.New(GraphicsDevice, new RasterizerStateDescription(CullMode.None));
}
public override void loadContent(Microsoft.Xna.Framework.Content.ContentManager contentManager)
{
Texture2D sheet = contentManager.Load<Texture2D>("collectiblePez");
image = new SpriteSheet(Game, sheet, 2, 2, gameScreen.ScreenManager.SpriteBatch) {
position = Position,
framesPerSecond = 8f
};
image.scale = 1f / image.frameWidth;
}
public Sprite(string name, SpriteSheet spriteSheet)
{
Debug.Assert(name.Length > 0, "sprite name was an empty string");
Debug.Assert(spriteSheet != null, "sprite sheet was null");
frame = spriteSheet.SourceRectangle(name);
//this.sourceRectangle = spriteSheet.SourceRectangle(name);
//this.spriteSheet = spriteSheet;
}
public void testCreateStructureWithCorrectSize()
{
//GraphicsDeviceManager graphics = new GraphicsDeviceManager(this);
SpriteSheet testSheet = new SpriteSheet(50, 50);//new SpriteSheet(new Texture2D(graphics.GraphicsDevice,50,50), new SpriteBatch(GraphicsDevice), 50, 50);
//Assert.IsNotNull(testSheet);
testSheet.createStructure(500/testSheet.frameDimX, 2000/testSheet.frameDimY);
Assert.AreEqual(10, testSheet.Location.GetLength(0));
Assert.AreEqual(40, testSheet.Location.GetLength(1));
}
// Master Ovverride
public static GameObject Create(string name, SS.Pivot pivot, Vector2 size, Material material, TextAsset data)
{
GameObject go = new GameObject();
go.AddComponent<MeshFilter>().sharedMesh = NewMesh(pivot, size);
go.AddComponent<MeshRenderer>().material = material;
Sprite sprite = go.AddComponent<Sprite>();
SpriteSheet sheetInfo = new SpriteSheet(material, data);
Debug.Log("Names " + sheetInfo.AnimationNames()[0]);
return go;
}
public Character(SpriteSheet Sheet)
{
this.CharacterData.Sheet = Sheet;
//runAnimation = sheet.GetAnimation("Run");
//runAnimation.Loop = true;
//runAnimation.AnimationSpeed = 0.1f;
//runAnimation.Animating = true;
Weapon = Weapon.DefaultWeapon();
}
protected Character(string id, Stats.Stats stats, SpriteSheet spriteSheet)
{
this.Id = id;
this.Stats = stats;
this.SpriteSheet = spriteSheet;
this.SpriteSheet.CurrentSprite.Position = new Vector2f(this.X, this.Y);
this.BoundingBox = new FloatRect(this.X, this.Y + 50, 30, 30);
this.X = 100;
this.Y = 100;
this.IsDead = false;
}
public Projectile(SpriteSheet sprite, float x, float y, float deltaX, float deltaY, float projectileSpeed)
: base(sprite, x, y)
{
this.DeltaX = deltaX;
this.DeltaY = deltaY;
this.ProjectileSpeed = projectileSpeed;
this.Distance = 1000;
this.BoundingBox = new FloatRect(this.SpriteSheet.CurrentSprite.GetGlobalBounds().Left, this.SpriteSheet.CurrentSprite.GetGlobalBounds().Top, 20, 20);
this.IsActive = true;
Projectiles.Add(this);
}
/// <summary>
/// Loads a <see cref="SpriteSheet"/>'s data onto the form.
/// </summary>
/// <param name="path">The name of the file to load.</param>
protected void LoadFormData(string path)
{
fileName = path;
spriteSheet = SpriteSheet.FromFile(path);
spriteSheet.TileSize = new System.Drawing.Size(24, 24);
Text = System.IO.Path.GetFileName(fileName)
+ " - Sprite Sheet Editor";
spriteSheetImage.Image = spriteSheet.Bitmap;
OnFileLoaded();
}
protected override async Task LoadContent()
{
await base.LoadContent();
var virtualResolution = new Vector3(GraphicsDevice.BackBuffer.ViewWidth, GraphicsDevice.BackBuffer.ViewHeight, 200);
spriteBatch = new SpriteBatch(GraphicsDevice) { VirtualResolution = virtualResolution };
spheres = Asset.Load<SpriteSheet>("SpriteSphere");
round = Asset.Load<Texture>("round");
staticFont = Asset.Load<SpriteFont>("StaticFonts/CourierNew10");
dynamicFont = Asset.Load<SpriteFont>("DynamicFonts/CourierNew10");
colorTexture = Texture.New2D(GraphicsDevice, 1, 1, PixelFormat.R8G8B8A8_UNorm, new[] { Color.White });
}
protected override void LoadContent()
{
_bg.LowerBackground = Content.Load<Texture2D>(@"Graphics\Background1");
_bg.UpperBackground = Content.Load<Texture2D>(@"Graphics\Background2");
mainSheet = Content.Load<SpriteSheet>(@"Graphics\SpriteSheets\16x16");
_supportedAnimations = mainSheet.Animations;
sprite.Name = "testSprite";
G.EditorForm.grdProperty.SelectedObject = sprite;
sprite.Play(_supportedAnimations[_animationIndex].Name);
sprite.Position = G.ScreenCenter;
sprite.Origin = Vector2.One * 0.5f;
base.LoadContent();
}
/// <summary>
/// Loads graphics content for this screen. The background texture is quite
/// big, so we use our own local ContentManager to load it. This allows us
/// to unload before going from the menus into the game itself, wheras if we
/// used the shared ContentManager provided by the Game class, the content
/// would remain loaded forever.
/// </summary>
public override void Activate(bool instancePreserved)
{
if (!instancePreserved)
{
if (content == null)
content = new ContentManager(ScreenManager.Game.Services, "Content");
backgroundTexture = content.Load<Texture2D>("Backgrounds/lobby");
gat = new SpriteSheet(ScreenManager.Game, content.Load<Texture2D>("standSprite"), 2, 3, ScreenManager.SpriteBatch);
Viewport vp = ScreenManager.Game.GraphicsDevice.Viewport;
gat.scale = 0.4f * vp.Height / gat.frameHeight;
gat.position = new Vector2(vp.Width * 0.08f, vp.Height * 0.8f);
gat.framesPerSecond = 3f;
}
}
public void testCorrectFrames()
{
SpriteSheet testSheet = new SpriteSheet(50, 50);
int widthTotalImage = 500;
int heightTotalImage = 2000;
testSheet.createStructure(widthTotalImage / testSheet.frameDimX, heightTotalImage / testSheet.frameDimY);
for (int i = 0; i < testSheet.Location.GetLength(0); ++i)
{
for (int j = 0; j < testSheet.Location.GetLength(1); ++j)
{
Assert.AreEqual(testSheet.frameDimX * i, testSheet.getFrameLocationOnSheetAt(i, j).X, "At Col=" + i );
Assert.AreEqual(testSheet.frameDimY * j, testSheet.getFrameLocationOnSheetAt(i, j).Y, "At Row=" + j );
}
}
}
protected override async Task LoadContent()
{
await base.LoadContent();
spriteBatch = new SpriteBatch(GraphicsDevice);
offlineTarget = Texture.New2D(GraphicsDevice, OfflineWidth, OfflineHeight, PixelFormat.R8G8B8A8_UNorm, TextureFlags.ShaderResource | TextureFlags.RenderTarget).DisposeBy(this);
depthBuffer = Texture.New2D(GraphicsDevice, OfflineWidth, OfflineHeight, PixelFormat.D16_UNorm, TextureFlags.DepthStencil).DisposeBy(this);
uv = Asset.Load<Texture>("uv");
spheres = Asset.Load<SpriteSheet>("SpriteSphere");
arial = Asset.Load<SpriteFont>("StaticFonts/Arial13");
width = GraphicsDevice.BackBuffer.ViewWidth;
height = GraphicsDevice.BackBuffer.ViewHeight;
}
public Screen(int w, int h, SpriteSheet sheet)
{
this.sheet = sheet;
this.w = w;
this.h = h;
pixels = new int[w * h];
// Random random = new Random();
/*
* for (int i = 0; i < MAP_WIDTH * MAP_WIDTH; i++) { colors[i] = Color.get(00, 40, 50, 40); tiles[i] = 0;
*
* if (random.nextInt(40) == 0) { tiles[i] = 32; colors[i] = Color.get(111, 40, 222, 333); databits[i] = random.nextInt(2); } else if (random.nextInt(40) == 0) { tiles[i] = 33; colors[i] = Color.get(20, 40, 30, 550); } else { tiles[i] = random.nextInt(4); databits[i] = random.nextInt(4);
*
* } }
*
* Font.setMap("Testing the 0341879123", this, 0, 0, Color.get(0, 555, 555, 555));
*/
}
public SpriteRenderer(SpriteSheet spriteSheet)
{
SpriteSheet = spriteSheet;
textureFire = Texture2D.Load(typeof(Particle).Assembly.GetManifestResourceStream("Granite.Particle.Textures.fire_color.png"));
m_program = SpriteProgram.Instance;
m_instances = new List<SpriteInstance>();
m_vao = new VertexArray();
GL.BindVertexArray(m_vao);
m_bufferSprite = new Buffer<SpriteData>();
m_bufferQuad = new Buffer<Vector3>();
m_bufferQuad.SetData(new Vector3[] {
new Vector3(0f, 0f, 0f),
new Vector3(0f, 1f, 0f),
new Vector3(1f, 1f, 0f),
new Vector3(1f, 0f, 0f)
});
GL.UseProgram(m_program);
m_program.Position.SetValue(m_bufferQuad.GetView());
//m_program.Color.SetValue(m_bufferSprite.GetView(s => s.Color));
//m_program.Color.SetDivisor(1);
m_program.Transform.SetValue(m_bufferSprite.GetView<Matrix4>("Transform"));
m_program.Transform.SetDivisor(1);
m_program.TextureOrigin.SetValue(m_bufferSprite.GetView<Vector2>("TextureOrigin"));
m_program.TextureOrigin.SetDivisor(1);
m_program.TextureTarget.SetValue(m_bufferSprite.GetView<Vector2>("TextureTarget"));
m_program.TextureTarget.SetDivisor(1);
m_program.Progress.SetValue(m_bufferSprite.GetView(s => s.Progress));
m_program.Progress.SetDivisor(1);
GL.BindVertexArray(null);
m_isDirty = true;
}
public override void LoadContent(ContentManager content)
{
perchSprites = content.Load <SpriteSheet>("ONAF2/OwlPerch");
ventSprites = content.Load <SpriteSheet>("ONAF2/OwlVent");
jumpscareSprites = content.Load <SpriteSheet>("ONAF2/JumpscareOwl");
}
public SpriteRenderer(Actor actor, SpriteSheet spriteSheet) : base(actor)
{
this.spriteSheet = spriteSheet;
this.currentAnimation = spriteSheet.DefaultAnimation;
this.color = Color.White;
}
private void SetSpriteImage(SpriteSheet sprite)
{
spriteComponent.SpriteProvider = new SpriteFromSheet {
Sheet = sprite
};
}
private void Start()
{
this.Icons = AssetManager.Load <SpriteSheet>("UI/TowerRankIcon");
this.RefreshData();
}
public override void Read(AssetReader reader)
{
base.Read(reader);
bool isBoolFlags = IsBoolFlags(reader.Version);
MipMapMode = (TextureImporterMipFilter)reader.ReadInt32();
if (isBoolFlags)
{
EnableMipMapBool = reader.ReadBoolean();
CorrectGammaBool = reader.ReadBoolean();
FadeOutBool = reader.ReadBoolean();
BorderMipMapBool = reader.ReadBoolean();
}
else
{
EnableMipMap = reader.ReadInt32();
if (HasSRGBTexture(reader.Version))
{
SRGBTexture = reader.ReadInt32();
}
if (HasLinearTexture(reader.Version))
{
LinearTexture = reader.ReadInt32();
}
if (HasCorrectGamma(reader.Version))
{
CorrectGamma = reader.ReadInt32();
}
FadeOut = reader.ReadInt32();
BorderMipMap = reader.ReadInt32();
}
if (HasMipMapsPreserveCoverage(reader.Version))
{
MipMapsPreserveCoverage = reader.ReadInt32();
AlphaTestReferenceValue = reader.ReadSingle();
}
MipMapFadeDistanceStart = reader.ReadInt32();
MipMapFadeDistanceEnd = reader.ReadInt32();
if (isBoolFlags)
{
ConvertToNormalMapBool = reader.ReadBoolean();
if (HasIsReadable(reader.Version))
{
IsReadableBool = reader.ReadBoolean();
}
}
else
{
ConvertToNormalMap = reader.ReadInt32();
ExternalNormalMap = reader.ReadInt32();
if (IsReadableFirst(reader.Version))
{
IsReadable = reader.ReadInt32();
reader.AlignStream();
}
}
HeightScale = reader.ReadSingle();
NormalMapFilter = (TextureImporterNormalFilter)reader.ReadInt32();
if (!IsReadableFirst(reader.Version))
{
IsReadable = reader.ReadInt32();
}
if (HasStreamingMipmaps(reader.Version))
{
StreamingMipmaps = reader.ReadInt32();
StreamingMipmapsPriority = reader.ReadInt32();
}
if (isBoolFlags)
{
GrayScaleToAlphaBool = reader.ReadBoolean();
}
else
{
GrayScaleToAlpha = reader.ReadInt32();
}
if (IsAlignGrayScaleToAlpha(reader.Version))
{
reader.AlignStream();
}
GenerateCubemap = (TextureImporterGenerateCubemap)reader.ReadInt32();
if (HasCubemapConvolution(reader.Version))
{
CubemapConvolution = reader.ReadInt32();
}
if (HasCubemapConvolutionSteps(reader.Version))
{
CubemapConvolutionSteps = reader.ReadInt32();
CubemapConvolutionExponent = reader.ReadSingle();
}
if (HasSeamlessCubemap(reader.Version))
{
SeamlessCubemap = reader.ReadInt32();
}
TextureFormat = (TextureFormat)reader.ReadInt32();
if (IsAlignTextureFormat(reader.Version))
{
reader.AlignStream();
}
if (HasRecommendedTextureFormat(reader.Version) && RecommendedTextureFormatFirst(reader.Version))
{
RecommendedTextureFormat = reader.ReadInt32();
reader.AlignStream();
}
MaxTextureSize = reader.ReadInt32();
TextureSettings.Read(reader);
NPOTScale = (TextureImporterNPOTScale)reader.ReadInt32();
if (HasLightmap(reader.Version))
{
Lightmap = reader.ReadInt32();
}
if (HasRGBM(reader.Version))
{
RGBM = reader.ReadInt32();
}
if (HasCompressionQuality(reader.Version))
{
CompressionQuality = reader.ReadInt32();
}
if (HasAllowsAlphaSplitting(reader.Version))
{
AllowsAlphaSplitting = reader.ReadInt32();
reader.AlignStream();
}
if (HasSprite(reader.Version))
{
SpriteMode = (SpriteImportMode)reader.ReadInt32();
SpriteExtrude = reader.ReadUInt32();
SpriteMeshType = (SpriteMeshType)reader.ReadInt32();
Alignment = (SpriteAlignment)reader.ReadInt32();
SpritePivot.Read(reader);
}
if (HasSprite(reader.Version) && SpritePixelsToUnitsFirst(reader.Version))
{
SpritePixelsToUnits = reader.ReadSingle();
}
if (HasSpriteBorder(reader.Version))
{
SpriteBorder.Read(reader);
}
if (HasSprite(reader.Version) && !SpritePixelsToUnitsFirst(reader.Version))
{
SpritePixelsToUnits = reader.ReadSingle();
}
if (HasSpriteGenerateFallbackPhysicsShape(reader.Version))
{
SpriteGenerateFallbackPhysicsShape = reader.ReadInt32();
}
if (HasAlphaUsage(reader.Version))
{
AlphaUsage = (TextureImporterAlphaSource)reader.ReadInt32();
}
if (HasAlphaIsTransparency(reader.Version))
{
AlphaIsTransparency = reader.ReadInt32();
}
if (HasSpriteTessellationDetail(reader.Version))
{
SpriteTessellationDetail = reader.ReadSingle();
}
if (HasTextureType(reader.Version))
{
TextureType = (TextureImporterType)reader.ReadInt32();
}
if (HasRecommendedTextureFormat(reader.Version) && !RecommendedTextureFormatFirst(reader.Version))
{
RecommendedTextureFormat = reader.ReadInt32();
}
if (HasSourceTextureInformation(reader.Version))
{
SourceTextureInformation = reader.ReadAsset<SourceTextureInformation>();
reader.AlignStream();
}
if (HasTextureShape(reader.Version))
{
TextureShape = (TextureImporterShape)reader.ReadInt32();
}
if (HasSingleChannelComponent(reader.Version))
{
SingleChannelComponent = reader.ReadInt32();
}
if (HasMaxTextureSizeSet(reader.Version))
{
MaxTextureSizeSet = reader.ReadInt32();
CompressionQualitySet = reader.ReadInt32();
TextureFormatSet = reader.ReadInt32();
}
if (HasApplyGammaDecoding(reader.Version))
{
ApplyGammaDecoding = reader.ReadInt32();
}
reader.AlignStream();
if (HasPlatformSettings(reader.Version))
{
PlatformSettings = reader.ReadAssetArray<TextureImporterPlatformSettings>();
}
if (HasSprite(reader.Version))
{
SpriteSheet.Read(reader);
SpritePackingTag = reader.ReadString();
}
if (HasOutput(reader.Version))
{
Output.Read(reader);
}
if (HasPSDRemoveMatte(reader.Version))
{
PSDRemoveMatte = reader.ReadBoolean();
PSDShowRemoveMatteOption = reader.ReadBoolean();
}
reader.AlignStream();
PostRead(reader);
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.AddSerializedVersion(ToSerializedVersion(container.ExportVersion));
YAMLMappingNode mipmap = new YAMLMappingNode();
mipmap.Add(MipMapModeName, (int)MipMapMode);
mipmap.Add(EnableMipMapName, EnableMipMap);
if (HasSRGBTexture(container.ExportVersion))
{
mipmap.Add(SRGBTextureName, SRGBTexture);
}
if (HasLinearTexture(container.ExportVersion))
{
mipmap.Add(LinearTextureName, LinearTexture);
}
if (HasCorrectGamma(container.ExportVersion))
{
mipmap.Add(CorrectGammaName, CorrectGamma);
}
mipmap.Add(FadeOutName, FadeOut);
mipmap.Add(BorderMipMapName, BorderMipMap);
if (HasMipMapsPreserveCoverage(container.ExportVersion))
{
mipmap.Add(MipMapsPreserveCoverageName, MipMapsPreserveCoverage);
mipmap.Add(AlphaTestReferenceValueName, AlphaTestReferenceValue);
}
mipmap.Add(MipMapFadeDistanceStartName, MipMapFadeDistanceStart);
mipmap.Add(MipMapFadeDistanceEndName, MipMapFadeDistanceEnd);
node.Add(MipmapsName, mipmap);
YAMLMappingNode bumpmap = new YAMLMappingNode();
bumpmap.Add(ConvertToNormalMapName, ConvertToNormalMap);
if (HasExternalNormalMap(container.ExportVersion))
{
bumpmap.Add(ExternalNormalMapName, ExternalNormalMap);
}
bumpmap.Add(HeightScaleName, HeightScale);
bumpmap.Add(NormalMapFilterName, (int)NormalMapFilter);
node.Add(BumpmapName, bumpmap);
if (HasIsReadable(container.ExportVersion))
{
node.Add(IsReadableName, IsReadable);
}
if (HasStreamingMipmaps(container.ExportVersion))
{
node.Add(StreamingMipmapsName, StreamingMipmaps);
node.Add(StreamingMipmapsPriorityName, StreamingMipmapsPriority);
}
node.Add(GrayScaleToAlphaName, GrayScaleToAlpha);
node.Add(GenerateCubemapName, (int)GenerateCubemap);
if (HasCubemapConvolution(container.ExportVersion))
{
node.Add(CubemapConvolutionName, CubemapConvolution);
}
if (HasCubemapConvolutionSteps(container.ExportVersion))
{
node.Add(CubemapConvolutionStepsName, CubemapConvolutionSteps);
node.Add(CubemapConvolutionExponentName, CubemapConvolutionExponent);
}
if (HasSeamlessCubemap(container.ExportVersion))
{
node.Add(SeamlessCubemapName, SeamlessCubemap);
}
node.Add(TextureFormatName, (int)TextureFormat);
if (HasRecommendedTextureFormat(container.ExportVersion) && RecommendedTextureFormatFirst(container.ExportVersion))
{
node.Add(RecommendedTextureFormatName, RecommendedTextureFormat);
}
node.Add(MaxTextureSizeName, MaxTextureSize);
node.Add(TextureSettingsName, TextureSettings.ExportYAML(container));
node.Add(NPOTScaleName, (int)NPOTScale);
if (HasLightmap(container.ExportVersion))
{
node.Add(LightmapName, Lightmap);
}
if (HasRGBM(container.ExportVersion))
{
node.Add(RGBMName, RGBM);
}
if (HasCompressionQuality(container.ExportVersion))
{
node.Add(CompressionQualityName, CompressionQuality);
}
if (HasAllowsAlphaSplitting(container.ExportVersion))
{
node.Add(AllowsAlphaSplittingName, AllowsAlphaSplitting);
}
if (HasSprite(container.ExportVersion))
{
node.Add(SpriteModeName, (int)SpriteMode);
node.Add(SpriteExtrudeName, SpriteExtrude);
node.Add(SpriteMeshTypeName, (int)SpriteMeshType);
node.Add(AlignmentName, (int)Alignment);
node.Add(SpritePivotName, SpritePivot.ExportYAML(container));
}
if (HasSprite(container.ExportVersion) && SpritePixelsToUnitsFirst(container.ExportVersion))
{
node.Add(SpritePixelsToUnitsName, SpritePixelsToUnits);
}
if (HasSpriteBorder(container.ExportVersion))
{
node.Add(SpriteBorderName, SpriteBorder.ExportYAML(container));
}
if (HasSprite(container.ExportVersion) && !SpritePixelsToUnitsFirst(container.ExportVersion))
{
node.Add(SpritePixelsToUnitsName, SpritePixelsToUnits);
}
if (HasSpriteGenerateFallbackPhysicsShape(container.ExportVersion))
{
node.Add(SpriteGenerateFallbackPhysicsShapeName, SpriteGenerateFallbackPhysicsShape);
}
if (HasAlphaUsage(container.ExportVersion))
{
node.Add(AlphaUsageName, (int)AlphaUsage);
}
if (HasAlphaIsTransparency(container.ExportVersion))
{
node.Add(AlphaIsTransparencyName, AlphaIsTransparency);
}
if (HasSpriteTessellationDetail(container.ExportVersion))
{
node.Add(SpriteTessellationDetailName, SpriteTessellationDetail);
}
if (HasTextureType(container.ExportVersion))
{
node.Add(TextureTypeName, (int)TextureType);
}
if (HasRecommendedTextureFormat(container.ExportVersion) && !RecommendedTextureFormatFirst(container.ExportVersion))
{
node.Add(RecommendedTextureFormatName, RecommendedTextureFormat);
}
if (HasSourceTextureInformation(container.ExportVersion))
{
node.Add(SourceTextureInformationName, SourceTextureInformation.ExportYAML(container));
}
if (HasTextureShape(container.ExportVersion))
{
node.Add(TextureShapeName, (int)TextureShape);
}
if (HasSingleChannelComponent(container.ExportVersion))
{
node.Add(SingleChannelComponentName, SingleChannelComponent);
}
if (HasMaxTextureSizeSet(container.ExportVersion))
{
node.Add(MaxTextureSizeSetName, MaxTextureSizeSet);
node.Add(CompressionQualitySetName, CompressionQualitySet);
node.Add(TextureFormatSetName, TextureFormatSet);
}
if (HasApplyGammaDecoding(container.ExportVersion))
{
node.Add(ApplyGammaDecodingName, GetApplyGammaDecoding(container.Version));
}
if (HasPlatformSettings(container.ExportVersion))
{
node.Add(GetPlatformSettingsName(container.ExportVersion), PlatformSettings.ExportYAML(container));
}
if (HasSprite(container.ExportVersion))
{
node.Add(SpriteSheetName, SpriteSheet.ExportYAML(container));
node.Add(SpritePackingTagName, SpritePackingTag);
}
/*if (HasOutput(container.ExportVersion))
{
node.Add(OutputName, Output.ExportYAML(container));
}*/
if (HasPSDRemoveMatte(container.ExportVersion))
{
node.Add(PSDRemoveMatteName, PSDRemoveMatte);
node.Add(PSDShowRemoveMatteOptionName, PSDShowRemoveMatteOption);
}
PostExportYAML(container, node);
return node;
}
public override void Init(GraphicsDeviceManager graphics, ContentManager contentManager)
{
titleScreen = contentManager.Load <Texture2D>("title");
elementTexture = contentManager.Load <Texture2D>("elements");
elementSpriteSheet = new SpriteSheet(elementTexture, Constants.ELEMENT_IMAGE_SIZE);
}
public TextSprite(SpriteSheet _font, Alignement align = Alignement.LEFT, int x = 0, int y = 0)
{
font = _font;
position = new GridPosition(x, y);
alignement = align;
}
public PlayerDescriptor Load(IDataManagerArguments arguments)
{
var playerDataLoaderArgs = arguments as PlayerDataLoaderArguments;
string filePath = EngineConstants.FILEPATH_ACCOUNTS + playerDataLoaderArgs.Username + EngineConstants.ACC_FILE_EXT;
string name = "";
string password = "";
SpriteSheet sprite;
float speed;
int level;
int health;
int maximumHealth;
int strength;
int intelligence;
int dexterity;
int defense;
Vector position;
string mapID;
Role role;
try
{
using (var fileStream = new FileStream(filePath, FileMode.Open))
{
using (var binaryReader = new BinaryReader(fileStream))
{
name = binaryReader.ReadString();
password = binaryReader.ReadString();
sprite = new SpriteSheet(new SpriteInfo(binaryReader.ReadString()), binaryReader.ReadInt32(),
binaryReader.ReadInt32(), binaryReader.ReadInt32(), binaryReader.ReadInt32());
speed = binaryReader.ReadSingle();
maximumHealth = binaryReader.ReadInt32();
health = binaryReader.ReadInt32();
strength = binaryReader.ReadInt32();
intelligence = binaryReader.ReadInt32();
dexterity = binaryReader.ReadInt32();
defense = binaryReader.ReadInt32();
level = binaryReader.ReadInt32();
position = new Vector(binaryReader.ReadSingle(), binaryReader.ReadSingle());
mapID = binaryReader.ReadString();
role = new Role(binaryReader.ReadString(), binaryReader.ReadInt32());
}
}
var playerDescriptor = new PlayerDescriptor(name, password)
{
SpriteSheet = sprite,
Speed = speed,
Level = level,
Position = position,
MapID = mapID,
Stats = new Stats()
{
Health = health,
MaximumHealth = maximumHealth,
Strength = strength,
Intelligence = intelligence,
Dexterity = dexterity,
Defense = defense,
},
Role = role
};
return(playerDescriptor);
}
catch (Exception ex)
{
return(null);
}
}
public override void CreateCosmeticChildren(ComponentManager manager)
{
base.CreateCosmeticChildren(manager);
Sheet = new SpriteSheet(ContentPaths.Entities.Furniture.elevator, 32, 32);
}
public EntityFactory(SpriteSheet spriteSheet)
{
this.spriteSheet = spriteSheet;
}
partial void InitProjSpecific(XElement element)
{
var paddedFrame = new GUIFrame(new RectTransform(new Vector2(0.85f, 0.65f), GuiFrame.RectTransform, Anchor.Center)
{
RelativeOffset = new Vector2(0, 0.04f)
}, style: null);
var lightsArea = new GUIFrame(new RectTransform(new Vector2(1, 0.38f), paddedFrame.RectTransform, Anchor.TopLeft), style: null);
powerIndicator = new GUITickBox(new RectTransform(new Vector2(0.45f, 0.8f), lightsArea.RectTransform, Anchor.Center, Pivot.CenterRight)
{
RelativeOffset = new Vector2(-0.05f, 0)
}, TextManager.Get("EnginePowered"), font: GUI.SubHeadingFont, style: "IndicatorLightGreen")
{
CanBeFocused = false
};
autoControlIndicator = new GUITickBox(new RectTransform(new Vector2(0.45f, 0.8f), lightsArea.RectTransform, Anchor.Center, Pivot.CenterLeft)
{
RelativeOffset = new Vector2(0.05f, 0)
}, TextManager.Get("PumpAutoControl", fallBackTag: "ReactorAutoControl"), font: GUI.SubHeadingFont, style: "IndicatorLightYellow")
{
CanBeFocused = false
};
powerIndicator.TextBlock.Wrap = autoControlIndicator.TextBlock.Wrap = true;
powerIndicator.TextBlock.OverrideTextColor(GUI.Style.TextColor);
autoControlIndicator.TextBlock.OverrideTextColor(GUI.Style.TextColor);
GUITextBlock.AutoScaleAndNormalize(powerIndicator.TextBlock, autoControlIndicator.TextBlock);
var sliderArea = new GUIFrame(new RectTransform(new Vector2(1, 0.6f), paddedFrame.RectTransform, Anchor.BottomLeft), style: null);
string powerLabel = TextManager.Get("EngineForce");
new GUITextBlock(new RectTransform(new Vector2(1.0f, 0.3f), sliderArea.RectTransform, Anchor.TopCenter), "", textColor: GUI.Style.TextColor, font: GUI.SubHeadingFont, textAlignment: Alignment.Center)
{
AutoScaleHorizontal = true,
TextGetter = () => { return(TextManager.AddPunctuation(':', powerLabel, (int)(targetForce) + " %")); }
};
forceSlider = new GUIScrollBar(new RectTransform(new Vector2(0.95f, 0.45f), sliderArea.RectTransform, Anchor.Center), barSize: 0.1f, style: "DeviceSlider")
{
Step = 0.05f,
OnMoved = (GUIScrollBar scrollBar, float barScroll) =>
{
float newTargetForce = barScroll * 200.0f - 100.0f;
if (Math.Abs(newTargetForce - targetForce) < 0.01)
{
return(false);
}
targetForce = newTargetForce;
if (GameMain.Client != null)
{
correctionTimer = CorrectionDelay;
item.CreateClientEvent(this);
}
return(true);
}
};
var textsArea = new GUIFrame(new RectTransform(new Vector2(1, 0.25f), sliderArea.RectTransform, Anchor.BottomCenter), style: null);
var backwardsLabel = new GUITextBlock(new RectTransform(new Vector2(0.4f, 1.0f), textsArea.RectTransform, Anchor.CenterLeft), TextManager.Get("EngineBackwards"),
textColor: GUI.Style.TextColor, font: GUI.SubHeadingFont, textAlignment: Alignment.CenterLeft);
var forwardsLabel = new GUITextBlock(new RectTransform(new Vector2(0.4f, 1.0f), textsArea.RectTransform, Anchor.CenterRight), TextManager.Get("EngineForwards"),
textColor: GUI.Style.TextColor, font: GUI.SubHeadingFont, textAlignment: Alignment.CenterRight);
GUITextBlock.AutoScaleAndNormalize(backwardsLabel, forwardsLabel);
foreach (XElement subElement in element.Elements())
{
switch (subElement.Name.ToString().ToLowerInvariant())
{
case "propellersprite":
propellerSprite = new SpriteSheet(subElement);
AnimSpeed = subElement.GetAttributeFloat("animspeed", 1.0f);
break;
}
}
}
public SnowTexture()
{
m_backgroundTexture = Texture2D.Load(typeof(Floor).Assembly.GetManifestResourceStream("Zombie.Game.Textures.snow.jpg"));
m_backgroundSheet = new SpriteSheet(m_backgroundTexture);
m_backgroundSprite = m_backgroundSheet.AddSprite("", new Box2i(Vector2i.Zero, m_backgroundTexture.Size));
}
protected virtual SpriteFromSheet BuildSpriteSheet()
{
var ss = new SpriteSheet();
//Each action has 8 directions * actionCount sprites
int spriteSheetId = 0;
foreach (var animation in XGCharacter.RawAnimationsData)
{
FileInfo f = new FileInfo(Path.Combine(_spritesPath, animation.StartSprite));
for (int dir = 0; dir < 5; dir++)
{
int skip = animation.SkipBetweenFiles * dir;
for (int num = 0; num < animation.Count; num++)
{
var spritePath = f.DirectoryName + "\\" + (Convert.ToInt32(Path.GetFileNameWithoutExtension(f.Name)) + ((dir * animation.Count) + num + skip)).ToString().PadLeft(4, '0') + ".png";
if (File.Exists(spritePath)) // Some sprites missing?
{
var bytes = File.ReadAllBytes(spritePath);
var image = Stride.Graphics.Image.Load(bytes);
var texture = Texture.New(this.GraphicsDevice, image, TextureFlags.ShaderResource);
var sprite = new Sprite($"{animation.Name}_{dir}_{num}", texture);
ss.Sprites.Add(sprite);
var animationKey = (animation.Name, (ECameraDirection)dir);
if (!this._animations.ContainsKey(animationKey))
{
this._animations.Add(animationKey, new List <IndividualAnimation>());
}
_animations[animationKey].Add(new IndividualAnimation()
{
Name = animation.Name,
Count = animation.Count,
Direction = (ECameraDirection)dir,
Frame = num,
SpriteSheetId = spriteSheetId++
});
if (dir > 0 && dir < 4) // Get non-north south sprites. Will use for mirror
{
var bitmap = new Bitmap(spritePath);
bitmap.RotateFlip(RotateFlipType.RotateNoneFlipX);
bytes = BitmapToByteArray(bitmap);
image = Stride.Graphics.Image.Load(bytes);
texture = Texture.New(this.GraphicsDevice, image, TextureFlags.ShaderResource);
sprite = new Sprite($"{animation.Name}_{dir}_{num}", texture);
ss.Sprites.Add(sprite);
animationKey = (animation.Name, (ECameraDirection)(8 - dir));
if (!this._animations.ContainsKey(animationKey))
{
this._animations.Add(animationKey, new List <IndividualAnimation>());
}
_animations[animationKey].Add(new IndividualAnimation()
{
Name = animation.Name,
Count = animation.Count,
Direction = (ECameraDirection)(8 - dir),
Frame = num,
SpriteSheetId = spriteSheetId++
});
}
}
}
}
}
_previousAnimation = _animations[(EActionTypes.Idle, ECameraDirection.North)][0];
public override void Write(AssetWriter writer)
{
base.Write(writer);
bool isBoolFlags = IsBoolFlags(writer.Version);
writer.Write((int)MipMapMode);
if (isBoolFlags)
{
writer.Write(EnableMipMapBool);
writer.Write(CorrectGammaBool);
writer.Write(FadeOutBool);
writer.Write(BorderMipMapBool);
}
else
{
writer.Write(EnableMipMap);
if (HasSRGBTexture(writer.Version))
{
writer.Write(SRGBTexture);
}
if (HasLinearTexture(writer.Version))
{
writer.Write(LinearTexture);
}
if (HasCorrectGamma(writer.Version))
{
writer.Write(CorrectGamma);
}
writer.Write(FadeOut);
writer.Write(BorderMipMap);
}
if (HasMipMapsPreserveCoverage(writer.Version))
{
writer.Write(MipMapsPreserveCoverage);
writer.Write(AlphaTestReferenceValue);
}
writer.Write(MipMapFadeDistanceStart);
writer.Write(MipMapFadeDistanceEnd);
if (isBoolFlags)
{
writer.Write(ConvertToNormalMapBool);
if (HasIsReadable(writer.Version))
{
writer.Write(IsReadableBool);
}
}
else
{
writer.Write(ConvertToNormalMap);
writer.Write(ExternalNormalMap);
if (IsReadableFirst(writer.Version))
{
writer.Write(IsReadable);
writer.AlignStream();
}
}
writer.Write(HeightScale);
writer.Write((int)NormalMapFilter);
if (!IsReadableFirst(writer.Version))
{
writer.Write(IsReadable);
}
if (HasStreamingMipmaps(writer.Version))
{
writer.Write(StreamingMipmaps);
writer.Write(StreamingMipmapsPriority);
}
if (isBoolFlags)
{
writer.Write(GrayScaleToAlphaBool);
}
else
{
writer.Write(GrayScaleToAlpha);
}
if (IsAlignGrayScaleToAlpha(writer.Version))
{
writer.AlignStream();
}
writer.Write((int)GenerateCubemap);
if (HasCubemapConvolution(writer.Version))
{
writer.Write(CubemapConvolution);
}
if (HasCubemapConvolutionSteps(writer.Version))
{
writer.Write(CubemapConvolutionSteps);
writer.Write(CubemapConvolutionExponent);
}
if (HasSeamlessCubemap(writer.Version))
{
writer.Write(SeamlessCubemap);
}
writer.Write((int)TextureFormat);
if (IsAlignTextureFormat(writer.Version))
{
writer.AlignStream();
}
if (HasRecommendedTextureFormat(writer.Version) && RecommendedTextureFormatFirst(writer.Version))
{
writer.Write(RecommendedTextureFormat);
writer.AlignStream();
}
writer.Write(MaxTextureSize);
TextureSettings.Write(writer);
writer.Write((int)NPOTScale);
if (HasLightmap(writer.Version))
{
writer.Write(Lightmap);
}
if (HasRGBM(writer.Version))
{
writer.Write(RGBM);
}
if (HasCompressionQuality(writer.Version))
{
writer.Write(CompressionQuality);
}
if (HasAllowsAlphaSplitting(writer.Version))
{
writer.Write(AllowsAlphaSplitting);
writer.AlignStream();
}
if (HasSprite(writer.Version))
{
writer.Write((int)SpriteMode);
writer.Write(SpriteExtrude);
writer.Write((int)SpriteMeshType);
writer.Write((int)Alignment);
SpritePivot.Write(writer);
}
if (HasSprite(writer.Version) && SpritePixelsToUnitsFirst(writer.Version))
{
writer.Write(SpritePixelsToUnits);
}
if (HasSpriteBorder(writer.Version))
{
SpriteBorder.Write(writer);
}
if (HasSprite(writer.Version) && !SpritePixelsToUnitsFirst(writer.Version))
{
writer.Write(SpritePixelsToUnits);
}
if (HasSpriteGenerateFallbackPhysicsShape(writer.Version))
{
writer.Write(SpriteGenerateFallbackPhysicsShape);
}
if (HasAlphaUsage(writer.Version))
{
writer.Write((int)AlphaUsage);
}
if (HasAlphaIsTransparency(writer.Version))
{
writer.Write(AlphaIsTransparency);
}
if (HasSpriteTessellationDetail(writer.Version))
{
writer.Write(SpriteTessellationDetail);
}
if (HasTextureType(writer.Version))
{
writer.Write((int)TextureType);
}
if (HasRecommendedTextureFormat(writer.Version) && !RecommendedTextureFormatFirst(writer.Version))
{
writer.Write(RecommendedTextureFormat);
}
if (HasSourceTextureInformation(writer.Version))
{
SourceTextureInformation.Write(writer);
writer.AlignStream();
}
if (HasTextureShape(writer.Version))
{
writer.Write((int)TextureShape);
}
if (HasSingleChannelComponent(writer.Version))
{
writer.Write(SingleChannelComponent);
}
if (HasMaxTextureSizeSet(writer.Version))
{
writer.Write(MaxTextureSizeSet);
writer.Write(CompressionQualitySet);
writer.Write(TextureFormatSet);
}
if (HasApplyGammaDecoding(writer.Version))
{
writer.Write(ApplyGammaDecoding);
}
writer.AlignStream();
if (HasPlatformSettings(writer.Version))
{
PlatformSettings.Write(writer);
}
if (HasSprite(writer.Version))
{
SpriteSheet.Write(writer);
writer.Write(SpritePackingTag);
}
if (HasOutput(writer.Version))
{
Output.Write(writer);
}
if (HasPSDRemoveMatte(writer.Version))
{
writer.Write(PSDRemoveMatte);
writer.Write(PSDShowRemoveMatteOption);
}
writer.AlignStream();
PostWrite(writer);
}
public static Texture2D RenderPatternIcons(GraphicsDevice device, Microsoft.Xna.Framework.Content.ContentManager Content, Gui.JsonTileSheet Sheet)
{
Initialize();
var shader = new Shader(Content.Load <Effect>(ContentPaths.Shaders.TexturedShaders), true);
var sqrt = (int)(Math.Ceiling(Math.Sqrt(Patterns.Count)));
var width = MathFunctions.NearestPowerOf2(sqrt * Sheet.TileWidth);
var fitHorizontal = width / Sheet.TileWidth;
var rowCount = (int)Math.Ceiling((float)Patterns.Count / (float)fitHorizontal);
var height = MathFunctions.NearestPowerOf2(rowCount * Sheet.TileHeight);
RenderTarget2D toReturn = new RenderTarget2D(device, width, height, false, SurfaceFormat.Color, DepthFormat.Depth16, 16, RenderTargetUsage.PreserveContents);
var tileSheet = new SpriteSheet(ContentPaths.rail_tiles, 32);
device.SetRenderTarget(toReturn);
device.Clear(Color.Transparent);
shader.SetTexturedTechnique();
shader.MainTexture = AssetManager.GetContentTexture(ContentPaths.rail_tiles);
shader.SelfIlluminationEnabled = true;
shader.SelfIlluminationTexture = AssetManager.GetContentTexture(ContentPaths.Terrain.terrain_illumination);
shader.EnableShadows = false;
shader.EnableLighting = false;
shader.ClippingEnabled = false;
shader.CameraPosition = new Vector3(-0.5f, 0.5f, 0.5f);
shader.VertexColorTint = Color.White;
shader.LightRamp = Color.White;
shader.SunlightGradient = AssetManager.GetContentTexture(ContentPaths.Gradients.sungradient);
shader.AmbientOcclusionGradient = AssetManager.GetContentTexture(ContentPaths.Gradients.ambientgradient);
shader.TorchlightGradient = AssetManager.GetContentTexture(ContentPaths.Gradients.torchgradient);
Viewport oldview = device.Viewport;
int rows = height / Sheet.TileWidth;
int cols = width / Sheet.TileWidth;
device.ScissorRectangle = new Rectangle(0, 0, Sheet.TileWidth, Sheet.TileHeight);
device.RasterizerState = RasterizerState.CullNone;
device.DepthStencilState = DepthStencilState.Default;
Vector3 half = Vector3.One * 0.5f;
half = new Vector3(half.X, half.Y, half.Z);
foreach (EffectPass pass in shader.CurrentTechnique.Passes)
{
int ID = 0;
foreach (var type in Patterns)
{
int row = ID / cols;
int col = ID % cols;
var xboundsMin = 0;
var xboundsMax = 0;
var yboundsMin = 0;
var yboundsMax = 0;
var primitive = new RawPrimitive();
foreach (var piece in type.Pieces)
{
var rawPiece = RailLibrary.GetRailPiece(piece.RailPiece);
var bounds = Vector4.Zero;
var uvs = tileSheet.GenerateTileUVs(rawPiece.Tile, out bounds);
primitive.AddQuad(
Matrix.CreateRotationY((float)Math.PI * 0.5f * (float)piece.Orientation)
* Matrix.CreateTranslation(new Vector3(piece.Offset.X, 0.0f, piece.Offset.Y)),
Color.White, Color.White, uvs, bounds);
xboundsMin = Math.Min(xboundsMin, piece.Offset.X);
xboundsMax = Math.Max(xboundsMax, piece.Offset.X);
yboundsMin = Math.Min(yboundsMin, piece.Offset.Y);
yboundsMax = Math.Max(yboundsMax, piece.Offset.Y);
}
float xSize = xboundsMax - xboundsMin + 1;
float ySize = yboundsMax - yboundsMin + 1;
var cameraPos = new Vector3(xboundsMin + (xSize / 2), 2.0f, yboundsMax + 1.0f);
device.Viewport = new Viewport(col * Sheet.TileWidth, row * Sheet.TileHeight, Sheet.TileWidth, Sheet.TileHeight);
shader.View = Matrix.CreateLookAt(cameraPos,
new Vector3((xboundsMin + (xSize / 2)), 0.0f, yboundsMin),
Vector3.UnitY);
shader.Projection = Matrix.CreatePerspectiveFieldOfView(1.0f, 1.0f, 0.1f, 10);
shader.World = Matrix.Identity;
shader.CameraPosition = cameraPos;
pass.Apply();
primitive.Render(device);
++ID;
}
}
device.Viewport = oldview;
device.SetRenderTarget(null);
return((Texture2D)toReturn);
}
public override void Reset()
{
children.Clear();
floors = new GameObjectList();
this.Add(floors);
ladders = new GameObjectList();
this.Add(ladders);
scoreText = new GameObjectList();
this.Add(scoreText);
mario = new Mario(new Vector2(100, 900));
this.Add(mario);
pauline = new Pauline(new Vector2(800, 150));
this.Add(pauline);
barrels = new GameObjectList();
this.Add(barrels);
hammers = new GameObjectList();
this.Add(hammers);
SpriteSheet floorSpriteDimensions = new SpriteSheet("spr_floor");
SpriteSheet ladderSpriteDimensions = new SpriteSheet("spr_ladder_piece");
for (int iFloors = 0; iFloors < floorLayers; iFloors++)
{
for (int jFloors = 0; jFloors < floorsPerLayer; jFloors++)
{
//add Kdanky Dang at first 2 floors
if (iFloors == 0 && jFloors == 1)
{
kdankyDang = new KdankeyDang(new Vector2(jFloors * floorSpriteDimensions.Width,
floorVerticalStartOffset + iFloors * floorSetsHeightDifference + jFloors * floorIndividualOffset));
kdankyDang.Origin = new Vector2(kdankyDang.Center.X, kdankyDang.Sprite.Height);
this.Add(kdankyDang);
}
//create floors from right to left or left to right alternating
//floorSetsHeightDifference gives the difference in height between the first floor of two sets
//floorIndividualOffset gives the height each floor in a set goes down the next iteration
if (iFloors % 2 == 0) //right to left walk direction for these platforms
{
floors.Add(new Floor(new Vector2(
jFloors * floorSpriteDimensions.Width,
floorVerticalStartOffset + iFloors * floorSetsHeightDifference + jFloors * floorIndividualOffset)));
//add ladders to edges
if (jFloors == floorsPerLayer - 1)
{
GameObjectList _ladders = new GameObjectList();
for (int iLadder = 0; iLadder < baseLadderAmount; iLadder++)
{
_ladders.Add(new Ladder(new Vector2(
jFloors * floorSpriteDimensions.Width
- ladderSpriteDimensions.Width / 2,
ladderVerticalStartOffset + iLadder * ladderSpriteDimensions.Sprite.Height +
floorVerticalStartOffset + iFloors * floorSetsHeightDifference + jFloors * floorIndividualOffset)));
}
ladders.Add(_ladders);
}
}
else //left to right walkdirection for these platforms
{
//only spawn if the bottom layer is above the bottom of the screen. This is only present here because
//the bottom layer will always go left to right by design
if (floorVerticalStartOffset + iFloors * floorSetsHeightDifference + (jFloors + 1) * floorIndividualOffset + 48
< GameEnvironment.Screen.Y)
{
floors.Add(new Floor(new Vector2(
GameEnvironment.Screen.X - floorSpriteDimensions.Width - jFloors * floorSpriteDimensions.Width,
floorVerticalStartOffset + iFloors * floorSetsHeightDifference + jFloors * floorIndividualOffset)));
}
else
{
int kFloors = 0;
while (GameEnvironment.Screen.X - floorSpriteDimensions.Width - (jFloors + kFloors) * floorSpriteDimensions.Width > -floorSpriteDimensions.Width)
{
floors.Add(new Floor(new Vector2(
GameEnvironment.Screen.X - floorSpriteDimensions.Width - (jFloors + kFloors) * floorSpriteDimensions.Width,
floorVerticalStartOffset + iFloors * floorSetsHeightDifference + jFloors * floorIndividualOffset)));
kFloors++;
}
break;
}
//add ladders to edges
if (jFloors == floorsPerLayer - 1)
{
GameObjectList _ladders = new GameObjectList();
for (int iLadder = 0; iLadder < baseLadderAmount; iLadder++)
{
_ladders.Add(new Ladder(new Vector2(
GameEnvironment.Screen.X - floorSpriteDimensions.Width - (jFloors - 1) * floorSpriteDimensions.Width
- ladderSpriteDimensions.Width / 2,
ladderVerticalStartOffset + iLadder * ladderSpriteDimensions.Sprite.Height +
floorVerticalStartOffset + iFloors * floorSetsHeightDifference + jFloors * floorIndividualOffset)));
}
ladders.Add(_ladders);
}
}
//add misc ladders
if (jFloors == ladderFloorMisc1 && iFloors == ladderFloorSetMisc1)
{
GameObjectList _ladders = new GameObjectList();
for (int iLadder = 0; iLadder < ladderAmountMisc1; iLadder++)
{
_ladders.Add(new Ladder(new Vector2(
GameEnvironment.Screen.X - floorSpriteDimensions.Width - (jFloors - 1) * floorSpriteDimensions.Width
- ladderSpriteDimensions.Width / 2,
ladderVerticalStartOffset + iLadder * ladderSpriteDimensions.Sprite.Height +
floorVerticalStartOffset + iFloors * floorSetsHeightDifference + jFloors * floorIndividualOffset)));
}
ladders.Add(_ladders);
}
if (jFloors == ladderFloorMisc2 && iFloors == ladderFloorSetMisc2)
{
GameObjectList _ladders = new GameObjectList();
for (int iLadder = 0; iLadder < ladderAmountMisc2; iLadder++)
{
_ladders.Add(new Ladder(new Vector2(
jFloors * floorSpriteDimensions.Width
- ladderSpriteDimensions.Width / 2,
ladderVerticalStartOffset + iLadder * ladderSpriteDimensions.Sprite.Height +
floorVerticalStartOffset + iFloors * floorSetsHeightDifference + jFloors * floorIndividualOffset)));
}
ladders.Add(_ladders);
}
if (jFloors == ladderFloorMisc3 && iFloors == ladderFloorSetMisc3)
{
GameObjectList _ladders = new GameObjectList();
for (int iLadder = 0; iLadder < ladderAmountMisc3; iLadder++)
{
_ladders.Add(new Ladder(new Vector2(
jFloors * floorSpriteDimensions.Width
- ladderSpriteDimensions.Width / 2,
ladderVerticalStartOffset + iLadder * ladderSpriteDimensions.Sprite.Height +
floorVerticalStartOffset + iFloors * floorSetsHeightDifference + jFloors * floorIndividualOffset)));
}
ladders.Add(_ladders);
}
if (jFloors == ladderFloorMisc4 && iFloors == ladderFloorSetMisc4)
{
GameObjectList _ladders = new GameObjectList();
for (int iLadder = 0; iLadder < ladderAmountMisc4; iLadder++)
{
_ladders.Add(new Ladder(new Vector2(
jFloors * floorSpriteDimensions.Width
- ladderSpriteDimensions.Width / 2,
ladderVerticalStartOffset + iLadder * ladderSpriteDimensions.Sprite.Height +
floorVerticalStartOffset + iFloors * floorSetsHeightDifference + jFloors * floorIndividualOffset)));
}
ladders.Add(_ladders);
}
}
}
//Add misc platforms
//Pauline platforms
floors.Add(new Floor(new Vector2(pauline.Position.X, pauline.Position.Y)));
floors.Add(new Floor(new Vector2(pauline.Position.X - floorSpriteDimensions.Width, pauline.Position.Y)));
//pauline ladders
GameObjectList paulineLadders1 = new GameObjectList(0, "1");
GameObjectList paulineLadders2 = new GameObjectList(0, "1");
for (int iLadder = 0; iLadder < paulineMaxLadders; iLadder++)
{
paulineLadders1.Add(new Ladder(new Vector2(pauline.Position.X + floorSpriteDimensions.Width - ladderSpriteDimensions.Width,
pauline.Position.Y + ladderVerticalStartOffset + iLadder * ladderSpriteDimensions.Height)));
paulineLadders2.Add(new Ladder(new Vector2(pauline.Position.X - floorSpriteDimensions.Width,
pauline.Position.Y + ladderVerticalStartOffset + iLadder * ladderSpriteDimensions.Height)));
}
ladders.Add(paulineLadders1);
ladders.Add(paulineLadders2);
hammers.Add(new HammerPowerup(new Vector2(50, 500)));
hammers.Add(new HammerPowerup(new Vector2(1750, 300)));
}
public InfantryDeath(World world, Point position, SpriteSheet sprite, string spriteSequenceName) : base(world, position, sprite, ExplosionHeight.Ground, spriteSequenceName)
{
}
public SpriteGameObject(string assetName, int layer = 0, string id = "", int sheetIndex = 0, float scale = 1f)
: base(layer, id)
{
sprite = assetName != "" ? new SpriteSheet(assetName, sheetIndex) : null;
this.scale = scale;
}
public override async Task Execute()
{
spriteSheet = SpriteSheet;
agentSpriteComponent = Entity.Get <SpriteComponent>();
// Calculate offset of the bullet from the Agent if he is facing left and right side // TODO improve this
var bulletOffset = new Vector3(1f, 0.2f, 0f);
// Initialize game entities
if (!IsLiveReloading)
{
shootDelayCounter = 0f;
isAgentFacingRight = true;
currentAgentAnimation = AgentAnimation.Idle;
}
CurrentAgentAnimation = currentAgentAnimation;
while (Game.IsRunning)
{
await Script.NextFrame();
var inputState = GetKeyboardInputState();
if (inputState == InputState.None)
{
inputState = GetPointerInputState();
}
// Reset the shoot delay, if state changes
if (inputState != InputState.Shoot && CurrentAgentAnimation == AgentAnimation.Shoot)
{
shootDelayCounter = 0;
}
if (inputState == InputState.RunLeft || inputState == InputState.RunRight)
{
// Update Agent's position
var dt = (float)Game.UpdateTime.Elapsed.TotalSeconds;
Entity.Transform.Position.X += ((inputState == InputState.RunRight) ? AgentMoveDistance : -AgentMoveDistance) * dt;
if (Entity.Transform.Position.X < -gameWidthHalfX)
{
Entity.Transform.Position.X = -gameWidthHalfX;
}
if (Entity.Transform.Position.X > gameWidthHalfX)
{
Entity.Transform.Position.X = gameWidthHalfX;
}
isAgentFacingRight = inputState == InputState.RunRight;
// If agent face left, flip the sprite
Entity.Transform.Scale.X = isAgentFacingRight ? 1f : -1f;
// Update the sprite animation and state
CurrentAgentAnimation = AgentAnimation.Run;
}
else if (inputState == InputState.Shoot)
{
// Update shootDelayCounter, and check whether it is time to create a new bullet
shootDelayCounter -= (float)Game.UpdateTime.Elapsed.TotalSeconds;
if (shootDelayCounter > 0)
{
continue;
}
// Reset shoot delay
shootDelayCounter = AgentShootDelay;
// Spawns a new bullet
var bullet = new Entity
{
new SpriteComponent {
SpriteProvider = new SpriteFromSheet {
Sheet = spriteSheet
}, CurrentFrame = spriteSheet.FindImageIndex("bullet")
},
// Will make the beam move along a direction at each frame
new ScriptComponent {
Scripts = { new BeamScript {
DirectionX = isAgentFacingRight ? 1f : -1f, SpriteSheet = SpriteSheet
} }
}
};
bullet.Transform.Position = (isAgentFacingRight) ? Entity.Transform.Position + bulletOffset : Entity.Transform.Position + (bulletOffset * new Vector3(-1, 1, 1));
SceneSystem.SceneInstance.Scene.Entities.Add(bullet);
Logic.WatchBullet(bullet);
// Start animation for shooting
CurrentAgentAnimation = AgentAnimation.Shoot;
}
else
{
CurrentAgentAnimation = AgentAnimation.Idle;
}
}
}
protected override Task <ResultStatus> DoCommandOverride(ICommandContext commandContext)
{
var assetManager = new ContentManager();
// Create atlas texture
Dictionary <SpriteInfo, PackedSpriteInfo> spriteToPackedSprite = null;
// Generate texture atlas
var isPacking = Parameters.SheetAsset.Packing.Enabled;
if (isPacking)
{
var resultStatus = CreateAtlasTextures(commandContext.Logger, out spriteToPackedSprite);
if (resultStatus != ResultStatus.Successful)
{
return(Task.FromResult(resultStatus));
}
}
var imageGroupData = new SpriteSheet();
// add the sprite data to the sprite list.
foreach (var image in Parameters.SheetAsset.Sprites)
{
string textureUrl;
RectangleF region;
ImageOrientation orientation;
var borders = image.Borders;
var center = image.Center + (image.CenterFromMiddle ? new Vector2(image.TextureRegion.Width, image.TextureRegion.Height) / 2 : Vector2.Zero);
if (isPacking &&
spriteToPackedSprite.ContainsKey(image)) // ensure that unpackable elements (invalid because of null size/texture) are properly added in the sheet using the normal path
{
var packedSprite = spriteToPackedSprite[image];
var isOriginalSpriteRotated = image.Orientation == ImageOrientation.Rotated90;
region = packedSprite.Region;
orientation = (packedSprite.IsRotated ^ isOriginalSpriteRotated) ? ImageOrientation.Rotated90 : ImageOrientation.AsIs;
textureUrl = SpriteSheetAsset.BuildTextureAtlasUrl(Url, spriteToPackedSprite[image].AtlasTextureIndex);
// update the center and border info, if the packer rotated the sprite
// note: X->Left, Y->Top, Z->Right, W->Bottom.
if (packedSprite.IsRotated)
{
// turned the sprite CCW
if (isOriginalSpriteRotated)
{
var oldCenterX = center.X;
center.X = center.Y;
center.Y = region.Height - oldCenterX;
var oldBorderW = borders.W;
borders.W = borders.X;
borders.X = borders.Y;
borders.Y = borders.Z;
borders.Z = oldBorderW;
}
else // turned the sprite CW
{
var oldCenterX = center.X;
center.X = region.Width - center.Y;
center.Y = oldCenterX;
var oldBorderW = borders.W;
borders.W = borders.Z;
borders.Z = borders.Y;
borders.Y = borders.X;
borders.X = oldBorderW;
}
}
}
else
{
region = image.TextureRegion;
orientation = image.Orientation;
Parameters.ImageToTextureUrl.TryGetValue(image, out textureUrl);
}
// Affect the texture
Texture texture = null;
if (textureUrl != null)
{
texture = AttachedReferenceManager.CreateProxyObject <Texture>(AssetId.Empty, textureUrl);
}
else
{
commandContext.Logger.Warning($"Image '{image.Name}' has an invalid image source file '{image.Source}', resulting texture will be null.");
}
imageGroupData.Sprites.Add(new Graphics.Sprite
{
Name = image.Name,
Region = region,
Orientation = orientation,
Center = center,
Borders = borders,
PixelsPerUnit = new Vector2(image.PixelsPerUnit),
Texture = texture,
IsTransparent = false,
});
}
// set the transparency information to all the sprites
if (Parameters.SheetAsset.Alpha != AlphaFormat.None) // Skip the calculation when format is forced without alpha.
{
var urlToTexImage = new Dictionary <string, Tuple <TexImage, Image> >();
using (var texTool = new TextureTool())
{
foreach (var sprite in imageGroupData.Sprites)
{
if (sprite.Texture == null) // the sprite texture is invalid
{
continue;
}
var textureUrl = AttachedReferenceManager.GetOrCreateAttachedReference(sprite.Texture).Url;
if (!urlToTexImage.ContainsKey(textureUrl))
{
var image = assetManager.Load <Image>(textureUrl);
var newTexImage = texTool.Load(image, false); // the sRGB mode does not impact on the alpha level
texTool.Decompress(newTexImage, false); // the sRGB mode does not impact on the alpha level
urlToTexImage[textureUrl] = Tuple.Create(newTexImage, image);
}
var texImage = urlToTexImage[textureUrl].Item1;
var region = new Rectangle
{
X = (int)Math.Floor(sprite.Region.X),
Y = (int)Math.Floor(sprite.Region.Y)
};
region.Width = (int)Math.Ceiling(sprite.Region.Right) - region.X;
region.Height = (int)Math.Ceiling(sprite.Region.Bottom) - region.Y;
var alphaLevel = texTool.GetAlphaLevels(texImage, region, null, commandContext.Logger); // ignore transparent color key here because the input image has already been processed
sprite.IsTransparent = alphaLevel != AlphaLevels.NoAlpha;
}
// free all the allocated images
foreach (var tuple in urlToTexImage.Values)
{
tuple.Item1.Dispose();
assetManager.Unload(tuple.Item2);
}
}
}
// save the imageData into the data base
assetManager.Save(Url, imageGroupData);
return(Task.FromResult(ResultStatus.Successful));
}
public Sprite(Texture2D Texture, int GridWidth, int GridHeight)
{
SpriteSheet = new SpriteSheet(Texture).WithGrid((GridWidth, GridHeight));
color = Color.White;
}
public AnimationManager(SpriteSheet spriteSheet, Vector2 initialPosition, Animation[] animations)
{
this.spriteSheet = spriteSheet;
this.animations = animations;
this.currentPosition = initialPosition;
}
/// <summary>
/// Draws all sprite sheets.
/// </summary>
private void DrawSpriteSheet(SpriteSheet spriteSheet)
{
// Updates texture locations in the sprite sheet.
try
{
RefreshImageDimensions(spriteSheet);
}
catch
{
MessageBox.Show(
$"Getting image dimensions for all frames failed for the sprite sheet named '{spriteSheet.Name}'.",
"Export failed before draw",
MessageBoxButton.OK,
MessageBoxImage.Error);
return;
}
TexturePacker texPacker = new TexturePacker();
try
{
texPacker.Pack(spriteSheet.Frames.ToList());
}
catch (NullReferenceException)
{
MessageBox.Show(
$"Packing the texture failed for the sprite sheet named '{spriteSheet.Name}'.",
"Export failed before draw",
MessageBoxButton.OK,
MessageBoxImage.Error);
return;
}
// Loads each image and draws it into the sprite sheet.
using (Bitmap texSheet = new Bitmap(texPacker.Root.bounds.Width, texPacker.Root.bounds.Height))
{
try
{
using (var canvas = Graphics.FromImage(texSheet))
{
canvas.CompositingMode = System.Drawing.Drawing2D.CompositingMode.SourceCopy;
canvas.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.None;
foreach (var frame in spriteSheet.Frames)
{
using (var bitmap = Bitmap.FromFile(frame.GetAbsolutePath(projectSaveUrl)))
{
canvas.DrawImageUnscaled(bitmap, frame.X, frame.Y);
}
}
}
}
catch
{
MessageBox.Show(
$"Drawing the sprite sheet named '{spriteSheet.Name}' failed.",
"Export failed to draw",
MessageBoxButton.OK,
MessageBoxImage.Error);
return;
}
// Saves the final sprite sheet and updates the image source.
try
{
string savePath = spriteSheet.GetAbsolutePath(projectSaveUrl);
texSheet.Save($"{savePath}.png", System.Drawing.Imaging.ImageFormat.Png);
SpritesheetImage.Source = new BitmapImage(new Uri(spriteSheet.ExportUrl, UriKind.Relative));
}
catch
{
MessageBox.Show(
$"The sprite sheet named '{spriteSheet.Name}' can't be saved with its current file path: /{spriteSheet.ExportUrl}.png",
"Export failed to save",
MessageBoxButton.OK,
MessageBoxImage.Error);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SpriteSheetRenderer"/> class.
/// </summary>
/// <param name="texture">The texture.</param>
/// <param name="spriteSheet">The sprite sheet.</param>
public SpriteSheetRenderer(ITexture texture, SpriteSheet spriteSheet)
{
SpriteSheet = spriteSheet;
Texture = texture;
Texture.Filter = TextureFilterMode.Mipmap;
}
/// <summary>
/// Removes the tab linked to the given sprite sheet.
/// </summary>
private void RemoveSpriteSheetTab(SpriteSheet removedSpriteSheet)
{
TabItem tab = GetSpriteSheetTab(removedSpriteSheet);
SpritesheetsList.Items.Remove(tab);
}
public override async Task Execute()
{
spriteSheet = BulletSheet;
agentSpriteComponent = Entity.Get <SpriteComponent>();
var animComponent = Entity.Get <AnimationComponent>();
PlayingAnimation playingAnimation = null;
// Calculate offset of the bullet from the Agent if he is facing left and right side // TODO improve this
var bulletOffset = new Vector3(1.3f, 1.65f, 0f);
// Initialize game entities
if (!IsLiveReloading)
{
shootDelayCounter = 0f;
isAgentFacingRight = true;
currentAgentAnimation = AgentAnimation.Idle;
}
CurrentAgentAnimation = currentAgentAnimation;
var normalScaleX = Entity.Transform.Scale.X;
var bulletCS = BulletColliderShape;
Task animTask = null;
while (Game.IsRunning)
{
await Script.NextFrame();
var inputState = GetKeyboardInputState();
if (inputState == InputState.None)
{
inputState = GetPointerInputState();
}
if (inputState == InputState.RunLeft || inputState == InputState.RunRight)
{
// Update Agent's position
var dt = (float)Game.UpdateTime.Elapsed.TotalSeconds;
Entity.Transform.Position.X += ((inputState == InputState.RunRight) ? AgentMoveDistance : -AgentMoveDistance) * dt;
if (Entity.Transform.Position.X < -gameWidthHalfX)
{
Entity.Transform.Position.X = -gameWidthHalfX;
}
if (Entity.Transform.Position.X > gameWidthHalfX)
{
Entity.Transform.Position.X = gameWidthHalfX;
}
isAgentFacingRight = inputState == InputState.RunRight;
// If agent face left, flip the sprite
Entity.Transform.Scale.X = isAgentFacingRight ? normalScaleX : -normalScaleX;
// Update the sprite animation and state
CurrentAgentAnimation = AgentAnimation.Run;
if (playingAnimation == null || playingAnimation.Name != "Run")
{
playingAnimation = animComponent.Play("Run");
}
}
else if (inputState == InputState.Shoot)
{
if (animTask != null && !animTask.IsCompleted)
{
continue;
}
if (animTask != null && animTask.IsCompleted)
{
playingAnimation = null;
}
animTask = null;
var rb = new RigidbodyComponent {
CanCollideWith = CollisionFilterGroupFlags.CustomFilter1, CollisionGroup = CollisionFilterGroups.DefaultFilter
};
rb.ColliderShapes.Add(new ColliderShapeAssetDesc {
Shape = bulletCS
});
// Spawns a new bullet
var bullet = new Entity
{
new SpriteComponent {
SpriteProvider = SpriteFromSheet.Create(spriteSheet, "bullet")
},
rb,
new BeamScript()
};
bullet.Name = "bullet";
bullet.Transform.Position = (isAgentFacingRight) ? Entity.Transform.Position + bulletOffset : Entity.Transform.Position + (bulletOffset * new Vector3(-1, 1, 1));
bullet.Transform.UpdateWorldMatrix();
SceneSystem.SceneInstance.RootScene.Entities.Add(bullet);
rb.LinearFactor = new Vector3(1, 0, 0);
rb.AngularFactor = new Vector3(0, 0, 0);
rb.ApplyImpulse(isAgentFacingRight ? new Vector3(25, 0, 0) : new Vector3(-25, 0, 0));
// Start animation for shooting
CurrentAgentAnimation = AgentAnimation.Shoot;
if (playingAnimation == null || playingAnimation.Name != "Attack")
{
playingAnimation = animComponent.Play("Attack");
animTask = animComponent.Ended(playingAnimation);
}
}
else
{
CurrentAgentAnimation = AgentAnimation.Idle;
if (playingAnimation == null || playingAnimation.Name != "Stance")
{
playingAnimation = animComponent.Play("Stance");
}
}
}
}
public Professor(SpriteSheet readSprite, SpriteSheet talkSprite, Vector2 position, Game game, Camera cam)
: base(readSprite, talkSprite, position, game, cam)
{
}
protected override async Task LoadContent()
{
await base.LoadContent();
Sprites = Asset.Load <SpriteSheet>("UIImages");
var lifeBar = new ImageElement {
Source = Sprites["Logo"], HorizontalAlignment = HorizontalAlignment.Center
};
lifeBar.DependencyProperties.Set(GridBase.ColumnSpanPropertyKey, 3);
var quitGameButton = new Button
{
Content = new TextBlock {
Text = "Quit Game", Font = Asset.Load <SpriteFont>("MicrosoftSansSerif15")
},
VerticalAlignment = VerticalAlignment.Bottom,
HorizontalAlignment = HorizontalAlignment.Left,
Padding = Thickness.UniformRectangle(10),
};
quitGameButton.DependencyProperties.Set(GridBase.ColumnPropertyKey, 0);
quitGameButton.DependencyProperties.Set(GridBase.RowPropertyKey, 2);
quitGameButton.Click += (sender, args) => Exit();
modalButton1Text = new TextBlock {
Text = "Close Modal window 1", Font = Asset.Load <SpriteFont>("MicrosoftSansSerif15")
};
var modalButton1 = new Button
{
Name = "Button Modal 1",
Content = modalButton1Text,
VerticalAlignment = VerticalAlignment.Center,
HorizontalAlignment = HorizontalAlignment.Center,
Padding = Thickness.UniformRectangle(10),
};
modalButton1.Click += ModalButton1OnClick;
modal1 = new ModalElement {
Content = modalButton1, Name = "Modal 1"
};
modal1.DependencyProperties.Set(Panel.ZIndexPropertyKey, 1);
modal1.DependencyProperties.Set(GridBase.ColumnPropertyKey, 1);
modal1.DependencyProperties.Set(GridBase.RowPropertyKey, 1);
modal1.OutsideClick += Modal1OnOutsideClick;
modalButton2Text = new TextBlock {
Text = "Close Modal window 2", Font = Asset.Load <SpriteFont>("MicrosoftSansSerif15")
};
var modalButton2 = new Button
{
Name = "Button Modal 2",
Content = modalButton2Text,
VerticalAlignment = VerticalAlignment.Center,
HorizontalAlignment = HorizontalAlignment.Center,
Padding = Thickness.UniformRectangle(10),
};
modalButton2.Click += ModalButton2OnClick;
modal2 = new ModalElement {
Content = modalButton2, Name = "Modal 2"
};
modal2.DependencyProperties.Set(Panel.ZIndexPropertyKey, 2);
modal2.DependencyProperties.Set(GridBase.ColumnPropertyKey, 1);
modal2.DependencyProperties.Set(GridBase.RowPropertyKey, 2);
modal2.OutsideClick += Modal2OnOutsideClick;
uniformGrid = new UniformGrid {
Columns = 3, Rows = 3
};
uniformGrid.Children.Add(modal1);
uniformGrid.Children.Add(modal2);
uniformGrid.Children.Add(lifeBar);
uniformGrid.Children.Add(quitGameButton);
UIComponent.RootElement = uniformGrid;
}
public TorchTile(TileId tileId) : base(tileId, SpriteSheet.GetSprites(TileId.Dirt))
{
Tiles[(byte)tileId] = this;
ConnectsToGrass = true;
ConnectsToSand = true;
}
