public Zombie4()
{
m_walkRightSequence = new SpriteSequence(
EnnemiesSprites.Instance.Z4Right1,
EnnemiesSprites.Instance.Z4Right2,
EnnemiesSprites.Instance.Z4Right3
);
m_walkLeftSequence = new SpriteSequence(
EnnemiesSprites.Instance.Z4Left1,
EnnemiesSprites.Instance.Z4Left2,
EnnemiesSprites.Instance.Z4Left3
);
m_walkFrontSequence = new SpriteSequence(
EnnemiesSprites.Instance.Z4Front1,
EnnemiesSprites.Instance.Z4Front2,
EnnemiesSprites.Instance.Z4Front3
);
m_walkBackSequence = new SpriteSequence(
EnnemiesSprites.Instance.Z4Back1,
EnnemiesSprites.Instance.Z4Back2,
EnnemiesSprites.Instance.Z4Back3
);
m_walkRightSequence.SpritesPerSecond = 5;
m_walkLeftSequence.SpritesPerSecond = 5;
m_walkFrontSequence.SpritesPerSecond = 5;
m_walkBackSequence.SpritesPerSecond = 5;
m_move.Speed = World.World.Instance.Map.Random.Next(2, 15); ;
}
public Zombie6()
{
m_walkRightSequence = new SpriteSequence(
EnnemiesSprites.Instance.Z6Right1,
EnnemiesSprites.Instance.Z6Right2,
EnnemiesSprites.Instance.Z6Right3
);
m_walkLeftSequence = new SpriteSequence(
EnnemiesSprites.Instance.Z6Left1,
EnnemiesSprites.Instance.Z6Left2,
EnnemiesSprites.Instance.Z6Left3
);
m_walkFrontSequence = new SpriteSequence(
EnnemiesSprites.Instance.Z6Front1,
EnnemiesSprites.Instance.Z6Front2,
EnnemiesSprites.Instance.Z6Front3
);
m_walkBackSequence = new SpriteSequence(
EnnemiesSprites.Instance.Z6Back1,
EnnemiesSprites.Instance.Z6Back2,
EnnemiesSprites.Instance.Z6Back3
);
m_walkRightSequence.SpritesPerSecond = 5;
m_walkLeftSequence.SpritesPerSecond = 5;
m_walkFrontSequence.SpritesPerSecond = 5;
m_walkBackSequence.SpritesPerSecond = 5;
m_move.Speed = World.World.Instance.Map.Random.Next(2, 15);
}
public Slime()
{
m_idleLeftSequence = new SpriteSequence(
EnemiesSprites.Instance.SlimeWalkLeft1
);
m_idleRightSequence = new SpriteSequence(
EnemiesSprites.Instance.SlimeWalkRight1
);
m_walkLeftSequence = new SpriteSequence(
EnemiesSprites.Instance.SlimeWalkLeft1,
EnemiesSprites.Instance.SlimeWalkLeft2
);
m_walkRightSequence = new SpriteSequence(
EnemiesSprites.Instance.SlimeWalkRight1,
EnemiesSprites.Instance.SlimeWalkRight2
);
m_walkLeftSequence.SpritesPerSecond = 6;
m_walkRightSequence.SpritesPerSecond = 6;
m_deadSequence = new SpriteSequence(
EnemiesSprites.Instance.SlimeDead
);
}
public Slime()
{
m_idleLeftSequence = new SpriteSequence(
EnemiesSprites.Instance.SlimeWalkLeft1
);
m_idleRightSequence = new SpriteSequence(
EnemiesSprites.Instance.SlimeWalkRight1
);
m_walkLeftSequence = new SpriteSequence(
EnemiesSprites.Instance.SlimeWalkLeft1,
EnemiesSprites.Instance.SlimeWalkLeft2
);
m_walkRightSequence = new SpriteSequence(
EnemiesSprites.Instance.SlimeWalkRight1,
EnemiesSprites.Instance.SlimeWalkRight2
);
m_walkLeftSequence.SpritesPerSecond = 6;
m_walkRightSequence.SpritesPerSecond = 6;
m_deadSequence = new SpriteSequence(
EnemiesSprites.Instance.SlimeDead
);
}
private SpriteSequence GetSpriteSequence()
{
SpriteSequence seq = null;
if (Math.Abs(m_move.LastDirection.X) > Math.Abs(m_move.LastDirection.Y))
{
if (m_move.LastDirection.X > 0)
{
seq = m_walkRightSequence;
}
else if (m_move.LastDirection.X < 0)
{
seq = m_walkLeftSequence;
}
}
else
{
if (m_move.LastDirection.Y > 0)
{
seq = m_walkBackSequence;
}
else if (m_move.LastDirection.Y < 0)
{
seq = m_walkFrontSequence;
}
}
if (seq == null)
{
seq = m_walkFrontSequence;
}
return(seq);
}
public void StartSequence(string name)
{
Debug.Log("start sequence" + name);
SpriteSequence ss = GetSpriteSequence(name);
StartCoroutine(StartSequenceCoroutine(ss));
}
IEnumerator StartSequenceCoroutine(SpriteSequence ss)
{
Debug.Log("In coroutine");
yield return(new WaitForSeconds(ss.delay));
GameObject obj = Instantiate(imagePrefab, transform);
Image image = obj.GetComponent <Image>();
foreach (Sprite sprite in ss.sprites)
{
image.sprite = sprite;
image.color = Color.white;
image.transform.localScale = Vector3.one * .6f;
float elapsedTime = 0;
while (elapsedTime < ss.duration)
{
elapsedTime += Time.deltaTime;
float t = elapsedTime / ss.duration;
image.color = Color.Lerp(Color.white, new Color(1, 1, 1, 0), t);
// Lerp scale
image.transform.localScale = Vector3.Lerp(Vector3.one * .6f, Vector3.one, t);
yield return(null);
}
yield return(new WaitForSeconds(ss.interval));
}
Destroy(obj);
Debug.Log("Coroutine end");
}
/// <summary>
/// Constructs object to managing updating a sprite box element of the
/// composite image.
/// </summary>
/// <param name="pictureBox">The picture box to draw in</param>
/// <param name="spriteSequence">The sprite sequence</param>
/// <param name="spriteRenderMethod">The method to draw in there</param>
public SpriteControl(PictureBox pictureBox, SpriteSequence spriteSequence, string spriteRenderMethod)
{
this.pictureBox = pictureBox;
this.spriteRenderMethod = spriteRenderMethod;
this.spriteSequence = spriteSequence;
// Make a note of the sprite sequences
itr = spriteSequence.Bitmaps.GetEnumerator();
}
protected void UpdateSprite(TimeSpan elapsed, SpriteSequence sequence)
{
m_sequence.Update(elapsed);
m_sprite.Position = new Vector2(m_location.Position.X - m_box.X / 2, m_location.Position.Y - m_box.Y / 2);
m_sprite.Sprite = m_sequence.CurrentSprite;
m_sprite.Size = m_box;
}
/// <summary>
/// Inicializa una nueva instancia de la clase AzulEngine.SpriteEngine.SpriteLayer que permite
/// crear una instancia completa con transparencia, visibilidad, posición,escala,velocidad, independencia de cámara y dirección de movimiento
/// </summary>
/// <param name="spriteCatalog">Catálogo de cuadros</param>
/// <param name="spriteSecuence">Colección de secuencia de cuadros</param>
/// <param name="transparency">Transparencia de la capa</param>
/// <param name="visible">Visibilidad de la capa</param>
/// <param name="position">Posición de la capa</param>
/// <param name="zoomScale">Escala inicial de la capa</param>
/// <param name="velocity">Velocidad de desplazamiento de la capa</param>
/// <param name="spriteEffects">Efecto de rotación sobre el sprite</param>
/// <param name="cameraIndependent">Indica si la capa es independiente del movimiento de la cámara</param>
/// <param name="direction">Dirección de desplazamiento de la capa cuando esta es independiente de la cámara</param>
public SpriteLayer(SpriteCatalog spriteCatalog, SpriteSequence[] spriteSecuence, float transparency, Boolean visible, Vector2 position, Vector2 zoomScale, Vector2 velocity, SpriteEffects spriteEffects, bool cameraIndependent, LayerMovementDirection direction)
: base(transparency, visible, position, zoomScale, velocity, cameraIndependent, direction)
{
this.SpriteCatalog = spriteCatalog;
this.SpriteSequences = spriteSecuence;
this.Anchor = Anchor.None;
this.SpriteEffects = spriteEffects;
this.TotalElapsedTime = 0f;
}
public void LoadSpriteToSeq(SpriteSequence ss, string atlasName, string spriteName, int index)
{
Sprite sprite = loadSprite(atlasName, spriteName);
ss.sprites[index] = sprite;
ImgRes imgRes = getCachedAbRes(ABType.Sprite, atlasName) as ImgRes;
imgRes.AddRefTrs(ss.transform);
}
public BloodFloor1()
{
m_sequence = new SpriteSequence(
BloodSprites.Instance.Blood03
);
m_sequence.SpritesPerSecond = 12;
NeverDie = true;
}
public BloodFloor1()
{
m_sequence = new SpriteSequence(
BloodSprites.Instance.Blood03
);
m_sequence.SpritesPerSecond = 12;
NeverDie = true;
}
private void Initialize()
{
sr = GetComponent <SpriteRenderer>();
ss = GetComponent <SpriteSequence>();
if (hidden)
{
sr.enabled = false;
}
}
private SpriteSequence GetSpriteSequence()
{
SpriteSequence seq = null;
if (seq == null)
{
seq = m_sequence;
}
return(seq);
}
void Awake()
{
listeners = new List <ISpriteSheet>();
sequences = new SpriteSequence[sequenceFrameCount.Count];
int counter = 0;
for (int i = 0; i < sequences.Length; i++)
{
sequences[i] = new SpriteSequence(counter, counter + sequenceFrameCount[i] - 1);
counter += sequenceFrameCount[i];
}
}
public Blood4()
{
m_sequence = new SpriteSequence(
BloodSprites.Instance.Blood30,
BloodSprites.Instance.Blood31,
BloodSprites.Instance.Blood32,
BloodSprites.Instance.Blood33,
BloodSprites.Instance.Blood34,
BloodSprites.Instance.Blood35
);
m_sequence.SpritesPerSecond = 12;
}
public Blood3()
{
m_sequence = new SpriteSequence(
BloodSprites.Instance.Blood20,
BloodSprites.Instance.Blood21,
BloodSprites.Instance.Blood22,
BloodSprites.Instance.Blood23,
BloodSprites.Instance.Blood24,
BloodSprites.Instance.Blood25
);
m_sequence.SpritesPerSecond = 12;
}
public Blood1()
{
m_sequence = new SpriteSequence(
BloodSprites.Instance.Blood00,
BloodSprites.Instance.Blood01,
BloodSprites.Instance.Blood02,
BloodSprites.Instance.Blood03,
BloodSprites.Instance.Blood04,
BloodSprites.Instance.Blood05
);
m_sequence.SpritesPerSecond = 12;
}
public Blood4()
{
m_sequence = new SpriteSequence(
BloodSprites.Instance.Blood30,
BloodSprites.Instance.Blood31,
BloodSprites.Instance.Blood32,
BloodSprites.Instance.Blood33,
BloodSprites.Instance.Blood34,
BloodSprites.Instance.Blood35
);
m_sequence.SpritesPerSecond = 12;
}
public Blood2()
{
m_sequence = new SpriteSequence(
BloodSprites.Instance.Blood10,
BloodSprites.Instance.Blood11,
BloodSprites.Instance.Blood12,
BloodSprites.Instance.Blood13,
BloodSprites.Instance.Blood14,
BloodSprites.Instance.Blood15
);
m_sequence.SpritesPerSecond = 12;
}
/// <summary>
/// When the selection is clicked, start playing the sequence
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void play_Click(object sender, EventArgs e)
{
// Play sprite sequence
var spriteSequenceName = comboBox1.SelectedItem;
// stop timer
timer1.Stop();
// Get the sprite sequence
spriteSequence = assets.SpriteSequence((string)spriteSequenceName);
itr = spriteSequence.Bitmaps.GetEnumerator();
// start the timer
timer1.Start();
}
public Blood2()
{
m_sequence = new SpriteSequence(
BloodSprites.Instance.Blood10,
BloodSprites.Instance.Blood11,
BloodSprites.Instance.Blood12,
BloodSprites.Instance.Blood13,
BloodSprites.Instance.Blood14,
BloodSprites.Instance.Blood15
);
m_sequence.SpritesPerSecond = 12;
}
public Blood1()
{
m_sequence = new SpriteSequence(
BloodSprites.Instance.Blood00,
BloodSprites.Instance.Blood01,
BloodSprites.Instance.Blood02,
BloodSprites.Instance.Blood03,
BloodSprites.Instance.Blood04,
BloodSprites.Instance.Blood05
);
m_sequence.SpritesPerSecond = 12;
}
public Animation(string name, int layer, int[] spriteSequence, int frameDurationMs, bool loopable)
{
this.Name = name;
this.Layers = new List <SpriteSequence>();
SpriteSequence newLayer = new SpriteSequence(layer, spriteSequence, new [] { frameDurationMs });
this.Layers.Add(newLayer);
this.IsLoopable = loopable;
this.Duration = frameDurationMs * spriteSequence.Length;
}
public Blood3()
{
m_sequence = new SpriteSequence(
BloodSprites.Instance.Blood20,
BloodSprites.Instance.Blood21,
BloodSprites.Instance.Blood22,
BloodSprites.Instance.Blood23,
BloodSprites.Instance.Blood24,
BloodSprites.Instance.Blood25
);
m_sequence.SpritesPerSecond = 12;
}
protected void UpdateSprite(TimeSpan elapsed, SpriteSequence sequence)
{
if (sequence != m_currentSequence)
{
m_currentSequence = sequence;
m_currentSequence.Reset();
}
m_currentSequence.Update(elapsed);
m_sprite.Position = new Vector2(m_location.Position.X - m_box.X / 2, m_location.Position.Y - m_box.Y / 2);
m_sprite.Sprite = m_currentSequence.CurrentSprite;
m_sprite.Size = new Vector2(m_sprite.Sprite.Size.X, m_sprite.Sprite.Size.Y);
}
protected void UpdateSprite(TimeSpan elapsed, SpriteSequence sequence)
{
if (sequence != m_currentSequence)
{
m_currentSequence = sequence;
m_currentSequence.Reset();
}
m_currentSequence.Update(elapsed);
m_sprite.Position = new Vector2(m_location.Position.X - m_box.X / 2, m_location.Position.Y - m_box.Y / 2);
m_sprite.Sprite = m_currentSequence.CurrentSprite;
m_sprite.Size = new Vector2(m_sprite.Sprite.Size.X, m_sprite.Sprite.Size.Y);
}
void IHandler <Start> .Handle(FrameArgs frame, Start e)
{
_cam = new Camera2D(e.Size, 1000f, Camera2DOrigin.Center);
// load the atlas
_coin = new Atlas("coin.atlas");
// create a sprite sequence from the frames in
// the spritesheet. by adding it to the scene, it will
// automatically be updated (we could also pump it
// manually in Update). this animation runs at 8 FPS.
_anim = new SpriteSequence(8, true, _coin,
"coin-1", "coin-2", "coin-3", "coin-4");
this.Add(_anim);
}
public bool ReplaceLayer(int layer, int[] spriteSequence, int[] frameFurationMs)
{
int i = Layers.FindIndex(s => s.Layer == layer);
if (i >= 0)
{
Layers[i] = new SpriteSequence(layer, spriteSequence, frameFurationMs);
if (Layers[i].Duration > this.Duration)
{
Duration = Layers[i].Duration;
}
}
return(false);
}
public Animation(string name, int layer, int[] spriteSequence, int[] frameDurationMs, bool loopable)
{
this.Name = name;
this.Layers = new List <SpriteSequence>();
SpriteSequence newLayer = new SpriteSequence(layer, spriteSequence, frameDurationMs);
this.Layers.Add(newLayer);
this.IsLoopable = loopable;
if (newLayer.Duration > this.Duration)
{
this.Duration = newLayer.Duration;
}
}
protected void UpdateSprite(TimeSpan elapsed, SpriteSequence sequence)
{
if (sequence != m_currentSequence)
{
m_currentSequence = sequence;
m_currentSequence.Reset();
}
m_currentSequence.Update(elapsed);
m_sprite.Position = new Vector2(m_location.Position.X, m_location.Position.Y - m_box.Y / 2);
m_sprite.Sprite = m_currentSequence.CurrentSprite;
m_sprite.Size = m_box;
m_sprite.Angle = (float)Math.Atan2(m_move.Direction.Y, m_move.Direction.X);
m_sprite.Color = new Color4ub(255, 255, 150, 255);
m_sprite.RotateFromOrigin = true;
}
// Returns the index of the content arrays at the given position on the specified layer
private int CurrentIdFromPos(float position, SpriteSequence seq)
{
if (position >= 1.0f)
{
return(seq.SpriteIds.Length - 1);
}
// Current position in time (ms) in the current animation
int curr = (int)Math.Round(position * this.Duration);
if (curr >= seq.Duration)
{
if (IsLoopable)
{
curr = curr % seq.Duration;
}
else
{
return(seq.SpriteIds.Length - 1);
}
}
int nextF = 0;
if (seq.MsPerFrame.Length == 1)
{
return((int)curr / seq.MsPerFrame[0]);
}
else
{
for (int i = 0; i < seq.SpriteIds.Length; i++)
{
nextF += seq.MsPerFrame[i % seq.MsPerFrame.Length];
if (curr < nextF)
{
return(i);
}
}
}
// Something has gone wrong here (curr >= seq.Duration and loopable, but is not shorter than seq.Duration after modulo)
return(-1);
}
public FireCamp()
{
m_location = new LocationComponent(this);
m_rigidBody = new RigidBodyComponent(this, m_location);
m_renderer = new SpriteRenderer(FireSprites.Instance);
m_box = new Vector2(48, 48);
m_sequence = new SpriteSequence(
FireSprites.Instance.Camp1,
FireSprites.Instance.Camp2,
FireSprites.Instance.Camp3,
FireSprites.Instance.Camp4,
FireSprites.Instance.Camp5
);
m_sequence.SpritesPerSecond = 7;
SetSprite(m_renderer);
}
public FireCamp()
{
m_location = new LocationComponent(this);
m_rigidBody = new RigidBodyComponent(this, m_location);
m_renderer = new SpriteRenderer(FireSprites.Instance);
m_box = new Vector2(48, 48);
m_sequence = new SpriteSequence(
FireSprites.Instance.Camp1,
FireSprites.Instance.Camp2,
FireSprites.Instance.Camp3,
FireSprites.Instance.Camp4,
FireSprites.Instance.Camp5
);
m_sequence.SpritesPerSecond = 7;
SetSprite(m_renderer);
}
public Animation(string name, List <Tuple <int, int[], int[]> > layerSpritesDurations, bool loopable)
{
this.Name = name;
this.Layers = new List <SpriteSequence>();
this.Duration = 0;
this.IsLoopable = loopable;
foreach (Tuple <int, int[], int[]> t in layerSpritesDurations)
{
SpriteSequence newLayer = new SpriteSequence(t.Item1, t.Item2, t.Item3);
this.Layers.Add(newLayer);
if (newLayer.Duration > this.Duration)
{
this.Duration = newLayer.Duration;
}
}
this.Layers.Sort();
}
// Creates an animation object with the array indices of the spriteSequences/durations as layer indicator
// (i.e. layer 0 => spriteSequence[0] (Background)
public Animation(string name, int[][] spriteSequence, int[][] frameDurationMs, bool loopable)
{
this.Name = name;
this.Layers = new List <SpriteSequence>();
this.Duration = 0;
this.IsLoopable = loopable;
for (int i = 0; i < spriteSequence.Length; i++)
{
SpriteSequence newLayer = new SpriteSequence(i, spriteSequence[i], frameDurationMs[i]);
this.Layers.Add(newLayer);
if (newLayer.Duration > this.Duration)
{
this.Duration = newLayer.Duration;
}
}
this.Layers.Sort();
}
void IHandler <Start> .Handle(FrameArgs frame, Start e)
{
_cam = new Camera2D(e.Size, 100f);
_atlas = new Atlas("mario.atlas");
_batch = new Batch();
_sprites = new Sprite[] {
_atlas["mushroom"],
_atlas["fire-flower"],
_atlas["star"],
_atlas["red-shell"],
_atlas["green-shell"],
_atlas["goomba"]
};
_background = _atlas["background"];
_solidColor = new SpriteMaterial(new SolidColorShader(), null);
_solidColor.Color = new Vector4(0f, 0f, 0f, 0.65f);
_boardBackground = new Quad(_solidColor, Vector4.Zero, Vector4.One);
for (var c = '0'; c <= '9'; c++)
{
_numbers.Add(c, _atlas[c.ToString()]);
}
_poof = new SpriteSequence(7, false, _atlas["smoke-1"], _atlas["smoke-2"], _atlas["smoke-3"], _atlas["smoke-4"]);
this.Add(_poof);
_sfx = new SoundChannel();
_sfx2 = new SoundChannel();
_sndNoMatch = new SoundEffect("no-match.opus");
_sndMatch = new SoundEffect("match.opus");
_sndLanding = new SoundEffect("landing.opus");
_sndCoin = new SoundEffect("coin.opus");
_sndOneUp = new SoundEffect("1-up.opus");
_music = new StreamingSoundChannel();
_musicFile = new StreamingOpusFile("mario.opus");
_musicGameOver = new StreamingOpusFile("game-over.opus");
}
public int CompareTo(object obj)
{
SpriteSequence objSeq = obj as SpriteSequence;
;
if (objSeq != null)
{
if (objSeq.Layer < this.Layer)
{
return(-1);
}
else if (objSeq.Layer > this.Layer)
{
return(1);
}
else
{
return(0);
}
}
throw new ArgumentException("Input object is not of type SpriteSequence or null!");
}
public bool AddNewLayer(int layer, int[] spriteSequence, int[] frameDurationMs)
{
foreach (SpriteSequence seq in Layers)
{
if (seq.Layer == layer)
{
return(false);
}
}
SpriteSequence newLayer = new SpriteSequence(layer, spriteSequence, frameDurationMs);
Layers.Add(newLayer);
Layers.Sort();
if (newLayer.Duration > this.Duration)
{
Duration = newLayer.Duration;
}
return(true);
}
/// <summary>
/// Inicializa una nueva instancia de la clase AzulEngine.SpriteEngine.SpriteLayer que permite
/// crear una instancia solo con un cátalogo y una colección de secuencias
/// </summary>
/// <param name="spriteCatalog">Cátalogo de cuadros </param>
/// <param name="spriteSecuence">Secuencia de cuadros</param>
public SpriteLayer(SpriteCatalog spriteCatalog, SpriteSequence[] spriteSecuence)
: this(spriteCatalog, spriteSecuence, 1.0f, true, Vector2.Zero, Vector2.One, Vector2.One, SpriteEffects.None, false, LayerMovementDirection.None)
{
}
public Tree3()
{
m_sequence = new SpriteSequence(
TreesSprites.Instance.Arbre3
);
}
public BulletSniper()
{
m_sequence = new SpriteSequence(
BulletSprites.Instance.Bullet0
);
}
protected void UpdateSprite(TimeSpan elapsed, SpriteSequence sequence)
{
if (sequence != m_currentSequence)
{
m_currentSequence = sequence;
m_currentSequence.Reset();
}
m_currentSequence.Update(elapsed);
m_sprite.Position = new Vector2(m_location.Position.X, m_location.Position.Y - m_box.Y / 2);
m_sprite.Sprite = m_currentSequence.CurrentSprite;
m_sprite.Size = m_box;
m_sprite.Angle = (float)Math.Atan2(m_move.Direction.Y, m_move.Direction.X);
m_sprite.Color = new Color4ub(255, 255, 150, 255);
m_sprite.RotateFromOrigin = true;
}
protected void UpdateSprite(TimeSpan elapsed, SpriteSequence sequence)
{
m_sequence.Update(elapsed);
m_sprite.Position = new Vector2(m_location.Position.X - m_box.X / 2, m_location.Position.Y - m_box.Y / 2);
m_sprite.Sprite = m_sequence.CurrentSprite;
m_sprite.Size = m_box;
}
void Awake()
{
listeners = new List<ISpriteSheetListener>();
frameListeners = new Dictionary<int, List<ISpriteSheetListener>>();
sequences = new SpriteSequence[sequenceFrameCount.Count];
mnemonics = new Dictionary<string, int>(keys.Count);
for(int i = 0; i < keys.Count; i++){
mnemonics.Add(keys[i], values[i]);
}
/*keys.Clear();
values.Clear();*/
int counter = 0;
for (int i =0 ; i < sequences.Length ; i++){
sequences[i] = new SpriteSequence(counter, counter + sequenceFrameCount[i] - 1);
counter += sequenceFrameCount[i];
}
}
public BulletGatling()
{
m_sequence = new SpriteSequence(
BulletSprites.Instance.Bullet0
);
}
/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
spriteBatch = new SpriteBatch(GraphicsDevice);
camera = new Camera2D(new Vector2(0f, 0f), new Vector2(1f), new Vector2(3f));
this.Services.AddService(typeof(SpriteBatch), spriteBatch);
this.Services.AddService(typeof(Camera2D), camera);
texture1 = this.Content.Load<Texture2D>("tex");
TileCatalog cat1 = new TileCatalog(texture1, 15, 15);
Random rand = new Random(DateTime.Now.Millisecond);
TileMap map1 = new TileMap(100, 100);
for (int i = 0; i < 100; i++)
{
for (int j = 0; j < 100; j++)
{
map1.SetTile(i, j, new Tile(rand.Next(1, cat1.TilePositions.Count)));
}
}
TileLayer layer1 = new TileLayer(cat1, map1, 0.5f, false, new Vector2(0, 0), new Vector2(1f, 1f), new Vector2(3f), false, LayerMovementDirection.None);
texture2 = this.Content.Load<Texture2D>("tiles2");
TileCatalog cat2 = new TileCatalog(texture2, 48, 48);
TileMap map2 = new TileMap(10, 500);
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 500; j++)
{
map2.SetTile(i, j, new Tile(rand.Next(1, cat2.TilePositions.Count)));
}
}
TileLayer layer2 = new TileLayer(cat2, map2, 1.0f, false, new Vector2(0, 0), new Vector2(1f, 1f), new Vector2(3f), true, LayerMovementDirection.Up);
scene = new TileScene();
scene.AddLayer(layer2);
scene.AddLayer(layer1);
TileComponent component = new TileComponent(this, scene, baseScreenSize, resultionIndependent);
this.Components.Add(component);
TextureLayer tLayer1 = new TextureLayer(this.texture1, 1f, false, new Vector2(20f), Vector2.One, new Vector2(1.5f,1.5f), true, Anchor.LowerRight);
TextureLayer tLayer2 = new TextureLayer(this.texture2, 0.5f, false, new Vector2(10f), Vector2.One, new Vector2(5f), true, Anchor.LowerLeft);
TextureScene tScene = new TextureScene();
tScene.AddLayer(tLayer1);
tScene.AddLayer(tLayer2);
TextureComponent tComponent = new TextureComponent(this, tScene, baseScreenSize, resultionIndependent);
this.Components.Add(tComponent);
texture1 = this.Content.Load<Texture2D>("megax");
SpriteCatalog scatalog = new SpriteCatalog(texture1, 36, 42);
SpriteSequence[] spriteSecuences = new SpriteSequence[2];
SpriteSequence spriteSecuence1 = new SpriteSequence(7, 0);
spriteSecuence1.StepTime = 400;
spriteSecuence1.SetFrame(0,new SpriteFrame(1));
spriteSecuence1.SetFrame(1, new SpriteFrame(1));
spriteSecuence1.SetFrame(2, new SpriteFrame(1));
spriteSecuence1.SetFrame(3, new SpriteFrame(1));
spriteSecuence1.SetFrame(4, new SpriteFrame(2));
spriteSecuence1.SetFrame(5, new SpriteFrame(3));
spriteSecuence1.SetFrame(6, new SpriteFrame(1));
spriteSecuences[0] = spriteSecuence1;
SpriteSequence spriteSecuence2 = new SpriteSequence(10, 0);
spriteSecuence2.StepTime = 90;
spriteSecuence2.SetFrame(0, new SpriteFrame(5));
spriteSecuence2.SetFrame(1, new SpriteFrame(6));
spriteSecuence2.SetFrame(2, new SpriteFrame(7));
spriteSecuence2.SetFrame(3, new SpriteFrame(8));
spriteSecuence2.SetFrame(4, new SpriteFrame(9));
spriteSecuence2.SetFrame(5, new SpriteFrame(10));
spriteSecuence2.SetFrame(6, new SpriteFrame(11));
spriteSecuence2.SetFrame(7, new SpriteFrame(12));
spriteSecuence2.SetFrame(8, new SpriteFrame(13));
spriteSecuence2.SetFrame(9, new SpriteFrame(14));
spriteSecuences[1] = spriteSecuence2;
SpriteLayer spLayer = new SpriteLayer(scatalog, spriteSecuences, 1.0f, true, new Vector2(10f), Vector2.One, Vector2.Zero, SpriteEffects.None, true, Anchor.None);
spLayer.CurrentSequence = 2;
SpriteScene spScene = new SpriteScene();
spScene.AddLayer(spLayer);
SpriteComponent spComponent = new SpriteComponent(this, spScene, baseScreenSize, resultionIndependent);
this.Components.Add(spComponent);
}
void Awake()
{
listeners = new List<ISpriteSheet>();
sequences = new SpriteSequence[sequenceFrameCount.Count];
int counter = 0;
for (int i =0 ; i < sequences.Length ; i++){
sequences[i] = new SpriteSequence(counter, counter + sequenceFrameCount[i] - 1);
counter += sequenceFrameCount[i];
}
}
