Monogame Platformer Game Programming Tutorial

MonoGame (new XNA) Tutorial:
Platformer Game Programming Tutorial

With Effects and Smooth Animation
(Page1, Page2, Page3, Page4, Page5)

Page4:

53) Let's go back to Game1.cs and add in some of the new things created in the appropriate places:
a) At the top where the variables are, let's add Hud hud; like so near Input inp:

Code Snippet

//INPUT
Input                 inp;                
 
//HUD
Hud                   hud;                                  // heads up display (shows life, player status, etc)

(inp should already be there)

b) We don't have a crystal effect but we will soon so you can leave this uncommented:

Code Snippet

//RENDERTARGETS
RenderTarget2D        MainTarget;                           // render to a standard target and fit it to the desktop resolution
RenderTarget2D        sprite_target;                        // any sprites reflected onto crystals are drawn on here also for crystal effect 
 
//FX
Effect                crystal_fx;                           // reflective crystal effect

(you'll already have MainTarget)

c) Make sure all of these are included somewhere in the variables:

Code Snippet

// PLAYER / MEOMOTION / CAMERA        
static public Vector2 rescale = Vector2.One; // adjusts character scale to screen resolution (static so if altered, all creatures can be scaled in all classes)
static public Vector2 cam_pos;               // world position of camera
Player                player;                // hero-player control and collision detection/response
MeoMotion             meo;                   // meo = MeoMotion manager which loads and stores vector-based blended keyframe animations

- rescale will be optionally set to adjust for resolution
- add camera position(if didn't already), the player, and a MeoMotion system (loads/stores MeoMotion animations)

d) We don't have a MonsterSys to manage monsters yet, but we will very soon so you can leave this uncommented:

Code Snippet

// MONSTERS / NPC's 
MonsterSys            monsterSys;            // holds and controls monsters or npc's
 
// FRAME ANIMATION STUFF / EXPLOSIONS        
ExplodeSys            explodeSys;            // tracks explosion frames for all explosions within it 

e) Initialize a render target to put animated sprites on (this is needed in part to create certain effects):

Code Snippet

quadBatch     = new QuadBatch(Content, GraphicsDevice, "QuadEffect", "FontTexture", screenW, screenH); // setup distortable quad class 
 
// INIT RENDER TARGETS
sprite_target = new RenderTarget2D(GraphicsDevice, screenW, screenH);
 
rnd = new Random(); // INIT UTILS 

(you'll already have quadBatch and rnd setup so just ignore those)

f) Create meo and explodeSys:

Code Snippet

    map        = new Map(sheet, spriteBatch);            
 
    // INIT MEOMOTION
    meo        = new MeoMotion(Content, quadBatch);                            // setup MeoMotion class       
 
    // INIT EXPLOSIONS
    explodeSys = new ExplodeSys(spriteBatch);
 
    base.Initialize();
}

(you already have map created)

54) Go to Game1.cs LoadContent():
a) after LOAD GRAPHICS section, add these (Note that Monster stuff isn't made yet but I will explain the idea):

Code Snippet

// LOAD HUD
hud = new Hud(spriteBatch, font);                                       // init and load heads up display (player status stuff)
hud.Load(Content);
 
// LOAD EXPLOSIONS
explodeSys.Load(Content, 16);
 
// CREATE PLAYER
player    = new Player(screen_center, quadBatch, map, inp, hud, explodeSys); // create a player somewhere
 
// CREATE MONSTER SYSTEM
monsterSys = new MonsterSys(Content, quadBatch, map, player, explodeSys);
monsterSys.Load(1, Content);                                             // load monsters for level 1
 
// INIT EDITOR
editor    = new Editor(map, inp, player, sheet, monsterSys);             // do this here because editor needs player and player needs hud and hud needs font (and font cannot be null)

(editor should be created already)
- make the heads-up display and load it's graphics
- load explosions (use 16 frames)
- create a player
- You may want to comment this for now but:
1) monsterSys will manage monsters and will need to load graphics (MeoMotion inside will need Content), will need to draw distortables (needs quadBatch), will need access to the map and player info, and need access to the explosion manager
2) Load monsters for level 1 (and need Content to load sounds)

55) We haven't made a Crystal.fx yet but we can prepare for it:
a)

Code Snippet

// SET IMAGE FOR TILES
map.SetTilesImage(tiles_image);                                         // this might be used in multiple places so send a reference to map but store tiles here
 
// FX
crystal_fx = Content.Load<Effect>("Crystal");
crystal_fx.Parameters["screen"].SetValue(new Vector2(screenW,screenH)); // screen(target) resolution 
crystal_fx.Parameters["BackMap"].SetValue(far_background);              // image to make shimmer from
 
// later we will want update to check if loading a new area is needed... and then have it call a method to load based on the level or area (game-state in update)
sheet_mgr.Setup_Sheet_Level_1(ref sheet);

(map.SetTilesImage ... and ... sheet.mgr.Setup <--- should already exist)

- Loads crystal.fx (later placed in Content folder although if you wanted you could set it in a Shaders folder in there too)
- Send the display resolution as a float2
- It will need its regular texture, a reflection texture (the sprite target), and a background texture (to make shiney effects)... so for now we can send it the background one since it won't change... so the texture inside called BackMap will be set to the far_background which contains the stars which will work nicely for creating a shimmering shine effect as the crystals pass by.

b) After map.AddBorder,

Code Snippet

// LOAD AND SETUP PLAYER ANIMATIONS: 
float resize = 0.60f; rescale = new Vector2(resize, resize);           // 60% size - scale characters overall
meo.Adjust_Scale_For_ScreenResolution(ref rescale, screenW, screenH);  // adjust final scale for target resolution
player.Load(meo, tiles_image);

- Starting with a resize value of 60% (desired default size), the Adjust method in meo will adjust the size for whatever resolution you change the game to run in (for target display)
- player loads the player related things and keeps track of the image containing some spell effect stuff that it'll use (in this case I put the additive spell effect (particle effect) images on the same sheet as the tiles - but this is totally up to you)

c) Load sounds and start playing some music (optional to do here or elsewhere)

Code Snippet

    // L O A D  L E V E L
    editor.LoadLevel(LEVEL_NAME);
               
 
    // LOAD SOUND AND MUSIC
    Sound.Load(Content);
    MediaPlayer.Play(Sound.music);                                        // already set to repeat in Load
 
}

(should already have: editor.LoadLevel)
- load common sounds (and default music) [didn't need to make a Sound object because use of static]
- play default music (volume set to about half already inside Sound.cs)

d) In Update(), make sure to include these before GameState.play (if didn't make already):

Code Snippet

map.UpdateVars();
explodeSys.Update();
 
switch (gameState) {

e) In the gameState play mode, make sure you have all these now:

Code Snippet

case GameState.play:
    //-----------------
    // P L A Y  M O D E  (input/updates)                                        
 
    // CHECK FOR GAMESTATE CHANGES
    if (inp.Keypress(Keys.E)) { gameState = GameState.edit;      GraphicsDevice.SetRenderTarget(sprite_target);  GraphicsDevice.Clear(Color.TransparentBlack); }
    if (hud.lives < 0)          gameState = GameState.game_over;
 
    // PLAYER INPUT AND ANIMATION UPDATES:
    player.Update();
 
    // MOVE CAMERA
    cam_pos += (player.pos - cam_pos) * 0.1f;                 // smooth pan camera toward player's world position
 
    // MATCH WORLD VIEW TO CAMERA 
    map.world_to_camera(cam_pos, ref background_pos);         // (what you see in the world based on where camera is)
 
    // PLAYER COLLISION DETECTION / RESPONSE: 
    player.WorldCollisions();
 
    // UPDATE BOUNCERS (spring platforms)
    map.bounceMgr.Update();
 
    // INIT ANY NEW ANIMATION:
    player.SetAnimation(gameTime);
    
    // MONSTER AI AND ANIMATION:
    monsterSys.Update(gameTime);                     
 
    break;

- if number of lives less than 0 - game over
- update the player
- update world camera position by finding the difference between where the player is and camera is and shrink that distance by 10% each frame (so if 100, 10% = move to 90... and 10% 90 = move to 81... and 10% 81 = 72.9, etc)... so it quickly homes in on player and but slows down as it approaches player (smooth panning with ease-in)
- tell the map where the camera is (so it updates loc and scroll_offset for tiles) and retrieve the appropriate background position based on it
- process world collision detections/responses for player (sometimes called: "CDCR" or Collision Detection / Collision Response)
- update the bouncers (spring platform animations)
- based on player motion status, update the player animation selection if it has changed
- update monster motions (once we've made this - we'll implement this soon)

f) for GameState.edit, make sure you have all these now:

Code Snippet

case GameState.edit:
    //----------------------
    // E D I T O R   M O D E  (input/updates)
    cam_pos = map.loc.ToVector2() * 64;
    monsterSys.Update(gameTime, false);                                // false = don't engage AI in editor mode
    editor.Update();
 
    // SWITCH TO PLAY MODE
    if (inp.Keypress(Keys.Enter)) gameState = GameState.play;
    break;   //---------------- end editor mode

- camera world pos = tile location(x,y) * (64,64)
- update the monsters (false will tell it to ignore AI since this is edit mode) [not made yet]
- update the editor
- enter to go back to play mode

g) In Draw() at the first GameState.play check, we'll draw any monsters or players (or other sprites) onto a render target called sprite_target:

Code Snippet

// DRAW SPRITES TO A SPRITE TARGET (so we can use it in crystal fx):
if (gameState==GameState.play) //PLAY MODE
{
    GraphicsDevice.SetRenderTarget(sprite_target); 
    GraphicsDevice.Clear(Color.TransparentBlack);
 
    // DRAW MONSTERS
    monsterSys.Draw(); 
 
    // DRAW PLAYER(S)
    player.Draw();
}
//-------------------

IF play:
- set render target to sprite_target:
-- clear it (transparent black)
-- draw monsters
-- draw player

h) Next we set out render target to the MainTarget (of the resolution that our game's designed for)

Code Snippet

//-------------------
 
GraphicsDevice.SetRenderTarget(MainTarget);          // this is like a substitute backbuffer set to a desired resolution (stretched to true backbuffer later)
 
// SKIP TO DRAW_OTHER_STATES IF NEEDED:
if ((gameState != GameState.edit) && (gameState != GameState.play)) goto DRAW_OTHER_STATES; // an old tactic to avoid superfluous programming (use goto very sparingly and very cautiously)

- set render target to MainTarget
- if edit or play mode continue... otherwise skip ahead to DRAW_OTHER_STATES label (try to avoid goto when you can)

*DRAWS BACKGROUNDS*

i) After drawing the tiles, we can pass in some values that our crystal shader will need (in typical shader lingo, these are referred to as uniforms (GLSL) or constant buffers[ie: cbuffer, tbuffer] (HLSL) which are aligned and packed for optimal transfer rates and act as constants during each process run of the shader (but can be updated by the CPU software each frame) )

Code Snippet

//-------------------            
spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.LinearClamp, DepthStencilState.None, RasterizerState.CullNone);
map.DrawTiles();      // D R A W  T I L E S
spriteBatch.End();
//-------------------
 
// APPLY A CRYSTAL EFFECT TO THESE:                                     
crystal_fx.Parameters["ReflectMap"].SetValue(sprite_target);            
spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.LinearClamp, DepthStencilState.None, RasterizerState.CullNone, crystal_fx);
map.DrawCrystals();   // D R A W  C R Y S T A L S
spriteBatch.End();

- draw tiles (may already have done this)
- set the texture in the shader called "ReflectMap" to the sprite_target (treating the render target for sprites as a texture)
- pass in the Begin, the crystal_fx (so its pixel shader replaces the default one until End() )
- draw the crystals with the effect

j) Now we can draw the sprite layer over the scene followed by any overlapping stuff and finally any additive blends that we want overtop of that:

Code Snippet

spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.LinearClamp, DepthStencilState.None, RasterizerState.CullNone);
// SHOW SPRITES
spriteBatch.Draw(sprite_target, Vector2.Zero, Color.White);            
// DRAW OVERLAPS
map.DrawOverlaps();            
spriteBatch.End();
 
// DRAW ADDITIVE EFFECTS
spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.Additive, SamplerState.LinearClamp, DepthStencilState.None, RasterizerState.CullNone);
explodeSys.Draw();
spriteBatch.End();  spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.LinearClamp, DepthStencilState.None, RasterizerState.CullNone);

- draw sprites layer from sprite_target (player, monsters, particles)
- draw overlapping tiles (ie: foreground trees)
- draw overlapping explosions with additive blending so they look cool
Include this:

Code Snippet

// E D I T  M O D E  only  - - - - -
if (gameState==GameState.edit)
{
    editor.DrawLocators(spriteBatch, tiles_image, screen_center);
} // - - - - - - - - - - - - - - - -
#if SHOW_PLAYER_COLLIDER          
if ((player.loc.X > map.a1) && (player.loc.X < map.a2) && (player.loc.Y > map.b1) && (player.loc.Y < map.b2)) {       // if in drawn tiles
    Vector2 CDpos = new Vector2(map.sx + 64.0f * (player.loc.X - map.a1), map.sy + 64.0f * (player.loc.Y - map.b1));  // get collision position (corner)
    CDpos -= map.scroll_offset;
    spriteBatch.Draw(tiles_image, CDpos, new Rectangle(960, 0, 63, 63), Color.Yellow, 0f, Vector2.Zero, 1f, SpriteEffects.None, 0f);
    monsterSys.DrawColliders(spriteBatch, tiles_image);
}           
#endif

After we've made the MonsterSys, you can later come back to Game1.cs and Add (at the very very very TOP of the file):
#define SHOW_PLAYER_COLLIDER... this will unlock this section of code for compilation so that you can test the collision regions of the characters. For now you can include this line as a comment: //define SHOW_PLAYER_COLLIDER, and uncomment it later as needed.
CDpos (collision detection position), uses the player location to determine where to draw the tile occupation rectangle (while player is on-screen)... monsterSys.DrawColliders will loop through all the monsters drawing their colliders (body hit region and attack regions)... you can later adjust these properties as needed.

k) You may have all of the following but I suggest checking over it to be sure( ie: hud.Draw() ):

Code Snippet

// TEXT / HUD --- 
if (gameState==GameState.play) { 
    spriteBatch.DrawString(font, "Press E to go to map editor", new Vector2(1, screenH-50), Color.DarkGreen); spriteBatch.DrawString(font, "Press E to go to map editor", new Vector2(0, screenH-49), Color.GreenYellow);
    hud.Draw();                
}
else
{   // EDITOR INSTRUCTIONS
    editor.DrawInstructions(spriteBatch, far_background, font, screenH);                
}
spriteBatch.End();
 
DRAW_OTHER_STATES:                                        // (label for goto to avoid superfluous programming [use sparingly and cautiously] )
//----------------
switch (gameState)
{
    case GameState.game_over:                             // maybe add fade transitions later
        spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.LinearWrap);
        GraphicsDevice.Clear(Color.Black);
        spriteBatch.DrawString(font, "G A M E   O V E R", screen_center + new Vector2(-80, -20), Color.LimeGreen);
        spriteBatch.DrawString(font, "  (press enter)  ", screen_center + new Vector2(-62, 20), Color.LimeGreen);
        spriteBatch.End();
        break;
}
 
 
// DRAW TEMP BACKBUFFER (MainTarget) to TRUE BACKBUFFER IN MAXIMIZED WINDOWED MODE (this resolves some rare but possible compatibility problems): 
GraphicsDevice.SetRenderTarget(null);
spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.Opaque, SamplerState.LinearWrap, DepthStencilState.None, RasterizerState.CullNone);
spriteBatch.Draw(MainTarget, desktopRect, Color.White);
spriteBatch.End();

-------------------------
56) In Solution Explorer, over your c# project_name, right-click and Add>>Folder: "Monsters"
a) Right-Click the folder "Monsters" and Add>>Class: "Monster" (which defines and processes monsters and their AI)
b) Right-Click the folder "Monsters" and Add>>Class: "MonsterSys" (holds the monsters and their sounds and runs their loops)

57) Go into Monster.cs
a) Add an enumeration for types of monsters, then in the class itself, add the following constants and enums:

Code Snippet

enum MonsterType { None, Mouster, Hellcat }
 
class Monster
{
    const float GRAVITY  = 0.25f, MAX_FALL_SPEED = 20;        // using same in player class
    const float MAX_JUMP = -12;
    
    public enum Act      { idle, walk, run, attack, jump, ouch }         // later add things like jump, duck, guard, or whatever
    public enum Mode     { wander, run_away, patrol }                    // what mode of behavior the monster AI is using 

- 2 actual monster types: Mouster, Hellcat
- gravity, maximum falling speed, and maximum upward jump speed are constants (as in player) but you could make them dynamic
- monsters can potentially do animations / Actions: idle, walk, run, attack, jump, ouch (more can be added)
- monsters have decision modes: wander, run_away, patrol

Code Snippet

int screenW, screenH; 
 
// MEO / ANIMATION
MeoMotion         meo;            // reference to MonsterSys's meoMotion player        
MeoPlayer         meo_play;       // for controlling enemy character animations (unique instance)
bool              flip;           // flip horizontally                
Vector2           rescale;        // adjusts meo player image scale for resolution (and movement speed)
Act               motion, last_motion; // if motion changes, it will play the corresponding animation
Mode              mode;           // wander, chase, escape, patrol 
int               walk_index;     // remember index of walk/run to adjust animation speed        
int               jump_index;     // remember index of "jump" if it exists
int               ouch_index;
int               time, total_time;           // current time doing an action, total time to continue that action
bool              must_finish_animation;      // if you want an animation to finish completely before allowing switch to the new one     

- display width/height stored locally for convenience
MonsterSys has a MeoMotion object to hold all monster animations (refers to), flip effect, rescale for resolution, current animation, previous animation, decision mode, walk, jump, ouch animation indices, timing for how long to carry out a decision to do a motion, finish current animation before allowing next animation to take over

Code Snippet

ExplodeSys        explode;        // <-- frame based animations (referenced from Game1) 
 
// MAP / PLAYER
Tile[,]           tiles;          // reference to tiles[,] from map
BounceMgr         bounceMgr;      // refer to Game1's bounceMgr (for spring platforms)
Player            player;         // refer to player 

(explosion manager, map's tiles, bounce manager, player)

Code Snippet

// MONSTER        
MonsterType       type;           // which type of monster                        
public bool       dead;           // if it's dead, skip processing it
public int        life;           // life status 
public Vector2    pos, vel;       // world position, velocity
public Vector2    target_vel;     // velocity goal (either random or deliberate)
public Vector2    old_pos;        // previous position of monster
public Vector2    screen_pos;     // where monster would appear on screen  
public Point      loc, old_loc;   // approximate map tile coordinate of monster
public Rectangle  bbox;           // bounding box for collision detection
public Rectangle  attack_box;     // for collision detection of attack from monster                       
bool              grounded;       // monster on ground or not            
int               attack_key;     // actual animation key where attack begins to be harmful
int               invincible;     // cycles of invincibility (counts down to 0)
 
// SOUND        
Vector2     pan;              // stereo pan (left-right speaker volumes based on monster position)

(monster type, dead, monster life-bar, position, velocity, velocity to aquire, old position, screen position, map location, previous map location, bounding box, attack region, on the ground, first keyframe where attack can harm(after anticipation), invincibility count-down, stereo pan (volume is all left for -1 and all right for +1) )

58) Monster constructor will need a start position, the type of monster to make,
and access to:
MeoMotion in MonsterSys, Quadbatch to draw distortables, map, player, and the explosion manager:

Code Snippet

// CONSTRUCT
public Monster(Vector2 Pos, MeoMotion Meo, QuadBatch QBatch, MonsterType monster_type, Map map, Player playr, ExplodeSys ex)
{
    screenW = Game1.screenW;  screenH = Game1.screenH;  rescale = Game1.rescale;
    meo        = Meo;                        
    tiles      = map.tiles;
    bounceMgr  = map.bounceMgr;
    player     = playr;
    explode    = ex;
 
    type       = monster_type;            
    string sheet_name = get_monster_properties(type);
    meo_play   = new MeoPlayer(sheet_name, Pos, Meo, QBatch);
    pos        = Pos;       old_pos = pos;
    screen_pos = Conv.world_to_screen(pos);
    loc        = Conv.GetTileCoord(pos);
    dead       = false;
    customize_monster();
    motion     = Act.idle; 
    mode       = Mode.wander;
}

- make some values local for convenience
- get references
- set the monster type
- get monster properties of desired monster (return the sheet name for setup of meoPlayer):
--- this determines the monster's collision regions(bbox's), first attack keyframe, and lifebar
- create a meoPlayer using the sheet name (and providing position, meo, & quadBatch)
- set start position and find from that:
--- screen position and map location
- customize the monster's animations (based on type)
--- perhaps adjust certain animation speeds or refer certain index (like walk index) to a different animation name (like "run")
- set starting animation to idle and initial decision mode to wander

59) We'll want the option to change monsters (like if a monster dies and we want to switch the dead one for a new one at another location):

Code Snippet

// C H A N G E  M O N S T E R
public void ChangeMonster(Vector2 Pos, MonsterType monster_type) {
    pos        = Pos;        old_pos = pos;
    screen_pos = Conv.world_to_screen(pos);
    loc        = Conv.GetTileCoord(pos);            
    type = monster_type;
    meo_play.sheet_name = get_monster_properties(type);             
    dead = false;
    customize_monster();
    motion = Act.idle;
}

Using a start position and desired monster type:
- set position data (world, screen, map)
- what kind of monster
- get the sheet name (based on type) and other type-specific properties (like collision boxes)
- make alive
- adjust animation properties and set as idle

60) If the monster jumps, determine if a bounce sound is played (spring), if it should keep current animation(busy), set as not on ground (won't allow new jump if it already is doing one)

Code Snippet

//------------------------
// M O N S T E R   J U M P 
//------------------------
// play_bounce [plays bounce sound], keep_motion [don't change animations]
void MonsterJump(bool play_bounce = false, bool keep_motion = false)
{
    if (motion == Act.jump) return;
    if ((!keep_motion)&&(jump_index>0)) motion = Act.jump;            
    grounded = false;
    if (!play_bounce) Sound.jump.Play(pan.Y, 0.9f, pan.X); else Sound.bounce.Play(pan.Y, 0.9f, pan.X);
    if (must_finish_animation)
    {
        vel.Y = MAX_JUMP; // need to trigger from here instead of state because waiting for animation to finish                
    }
}

- already jumping (return)
- if allowed to, set as jump animation (if jump index is zero then there is no actual animation for the jump - just a velocity change)
- no longer grounded
- if regular jump - play jump sound - but if bouncer caused the jump - play bounce sound
- if waiting for animation/motion to finish - set a jump velocity for now (otherwise it set one already before calling MonsterJump)

61) When a monster recieves damage (lifebar reduced based on power of attack):

Code Snippet

//-----------------------------
// M O N S T E R  D A M A G E D 
//-----------------------------
void MonsterDamaged(int life_loss)
{
    vel.Y = -6f;
    meo_play.SetAnimation(ouch_index, flip); must_finish_animation = true; motion = Act.ouch;
    life-=life_loss;
    invincible = 100;
    
    // (sounds could be referenced with indexing[] too if you have lots of monster types)
    switch (type)  {
        case MonsterType.Mouster: MonsterSys.monster_ouch1.Play(pan.Y, 0.9f, pan.X); break;
        case MonsterType.Hellcat: MonsterSys.monster_ouch2.Play(pan.Y, 0.9f, pan.X); break;
    }
 
    if (life <= 0.0f)
    {
        dead = true;
        // ADD EXPLOSION:
        explode.Add_Explosion(pos);
        Sound.explode.Play(pan.Y, 0.9f, pan.X);
    }
}

- monster hops a bit and plays the ouch animation (must finish it and make sure motion state is ouch)
- loses some life
- briefly invincible while damaged
- depending on monster, type: play the ouch sound based on monster's current pan setting
(we could have passed in a reference to the sound also, from MonsterSys, and set it during get_monster_properties)
IF lifebar is empty:
- dead, add explosion(at world position), play explosion sound (using monster's current pan setting)

62) The monster may sometimes decide to change speeds... let's make something to help decide on a new random speed:

Code Snippet

// GET RANDOM SPEED
float GetRandomSpeed()
{
    float x = Game1.rnd.Next(12)-6;
    if (x > 0) if (x <  4) x =  4;
    if (x < 0) if (x > -4) x = -4;
    return x;
}

- get a random number between -6 and +6
- if positive... make it (+4 to +6) ... and if negative (-4 to -6) [vary these as you like]

63) When we start collision detection, it will be annoying to check for strange circumstances (like boundary violations) all the time, so we'll make a compact helper method to determine if there's a solid there or not:

Code Snippet

// SOLID (collision helper)
bool Solid(int x, int y)
{            
    if ((x < 0) || (x >= Map.TILES_WIDE) || (y < 0) || (y >= Map.TILES_HIGH)) return true; // out of bounds is an obstacle
    if (tiles[x, y].is_solid) return true;
    return false;
}

- this also reduces something like if (tiles[x,y].is_solid to: if Solid(x,y) which makes the code look better (altho not quite as efficient but it definately won't matter).

64) We'll also need a couple helper methods to determine if a monster should jump on or over something or down onto something... but to do that it will need something to help it determine its surroundings a bit better:
a) Need a test for a vertical strip of tiles to see if it can land on something or not:

Code Snippet

// CONTAINS SOLID (test a vertical strip of tiles to see if a solid tile exists to land on)
int ContainsSolid(int x, int y1, int y2)
{            
    if (x < 0) x = 0; if (y1<0) y1=0;
    if (x >= Map.TILES_WIDE) x = Map.TILES_WIDE - 1; if (y2 >= Map.TILES_HIGH) { y2 = Map.TILES_HIGH - 1; if (y1 > y2) y1 = y2; }
    if (y2 < y1) { int tmp = y1; y1 = y2; y2 = tmp; }  // this should never happen (just in case)
    int y = y1;
    do
    {
        if (tiles[x, y].spikes) return 2;   // don't jump down onto spikes (monster's not that dumb)
        if (tiles[x, y].is_solid) return 1;
        if (tiles[x, y].stand_on) return 1;
        y++;
    } while (y < y2);            
    return 0;
}

Given map X coordinate and a starting and ending Y coordinate:
- clip the x and y coordinates to check to be within the map boundaries
- y2 should be greater than y1 for the test (if not, swap the 2 values)
Loop from y1 to y2:
- if spikes return a 2 to prevent monster from jumping on them
- if it's something that you can stand on, return a 1 to indicate that it's ok to proceed
At this point we know there's nothing good to jump onto so return a 0 to indicate this

b) It will also be handy to determine if a vertical strip of tiles is empty or not:

Code Snippet

// CONTAINS EMPTY
bool ContainsEmpty(int x, int y1, int y2)
{            
    if (x < 0) x = 0; if (y1 < 0) y1 = 0;
    if (x >= Map.TILES_WIDE) x = Map.TILES_WIDE - 1; if (y2 >= Map.TILES_HIGH) { y2 = Map.TILES_HIGH - 1; if (y1 > y2) y1 = y2; }
    if (y2 < y1) { int tmp = y1; y1 = y2; y2 = tmp; }  // this should never happen (just in case)
    int y = y1;
    do
    {
        if (!tiles[x, y].is_solid) return true;
        y++;
    } while (y < y2);
    return false;
}

- clip x,y to map
- swap y1,y2 if y2<y1
Loop y1 to y2:
- if NOT solid return true (empty)
otherwise return false (occupied)

c) same sort of helper for finding spikes:

Code Snippet

// SPIKE (collision helper)
bool Spike(int x, int y)
{
    if ((x < 0) || (x >= Map.TILES_WIDE) || (y < 0) || (y >= Map.TILES_HIGH)) return true;
    if (tiles[x, y].spikes) return true;
    return false;
}

- if edge off map or spikes, return as true (hit spikes)
- NO spikes

65) UpdateAI() - we'll make a fairly basic AI that determines some actity options based on some of its surroundings.
a) We'll start with some basic motions(animations) such as idle, walk, jump, etc... and determine how those motions should gradually change to other activities based on current decision mode and what the environment is like.

Code Snippet

// ----------------
// U P D A T E  A I 
// ----------------
void UpdateAI()
{
    int x = loc.X, y = loc.Y;
 
    // just a very basic simple AI for now (later could add pre-calculated path-node awareness(A* or other) 
    // - but limited range of vision and thus awareness of paths [don't make the AI overwhelmingly smart])
    switch (motion)
    {
        case Act.idle: // I D L E ----------------                                     
            if (last_motion != motion) { 
                time = 0; total_time = Game1.rnd.Next(50, 140);                        
            }
            time++;
            if (time > total_time) {
                target_vel.X = GetRandomSpeed();
            }                    
            break;

- for simplicity, get the location as x,y
- based on current motion:
-- Idle: if first time in idle: start a timer
-- if timer reaches time goal: set a random X velocity (somewhere else, this will trigger a different motion)

b) In walk and run mode the logic should be the same and there is a patrol or wander mode... so let's setup the logic:

Code Snippet

case Act.walk: // W A L K / R U N ---------------------
case Act.run:
    if (last_motion != motion) { 
        time = 0; total_time = Game1.rnd.Next(80, 160);                        
    }                    
    if (mode == Mode.wander) {
        time++;
        if (time > total_time) {
            time = 0; total_time = Game1.rnd.Next(90, 160);
            target_vel.X = GetRandomSpeed();
            if (total_time > 150) target_vel.X = 0f;              // force an idle in wander mode sometimes
            if (total_time < 110) mode = Mode.patrol;             // switch between patrol and wander sometimes
        }
    }
    else if (mode == Mode.patrol) {
        time++;
        if (time > total_time) {
            time = 0; total_time = Game1.rnd.Next(90, 160);
            if (total_time < 110) mode = Mode.wander;             // switch between patrol and wander sometimes
        }
    }
    break;

IF first time (as walk or run), set a timer
IF Wander:
- IF timer done:
- - set new timer randomly:(90 to 160)
- - randomize X velocity
- - if timer > 150 set to stop moving
- - if timer < 110 change to Patrol mode
IF Patrol:
- IF timer done:
- - set new timer randomly:(90 to 160)
- - if timer < 110 change to Wander mode

c) If Jump motion, if first time trigger the jump velocity, and if wander mode - periodically adjust velocity.

Code Snippet

    case Act.jump: // J U M P -------------------
        if (motion != last_motion) {
            vel.Y = (float)(-Game1.rnd.Next(6)-6);
        }                    
        if (mode == Mode.wander) {
            time++;
            if (time > total_time) {
                time = 0; total_time = Game1.rnd.Next(80, 160);
                target_vel.X = GetRandomSpeed();
                if (total_time > 150) { target_vel.X = 0f; }
            }                          
        }
        break;
    case Act.attack: // A T T A C K -------------------
        if (meo_play.IsDoneAnimation()) motion = Act.idle;
        break;
    case Act.ouch:
        if (meo_play.IsDoneAnimation()) motion = Act.idle;
        break;
}//^switch(motion)^

JUMP:
IF just changed to jump motion, pick a random jump velocity (between -(0-6) - 6) = (-6 to -12)
IF wander mode:
- IF timer done
- - setup new timer time
- - get a random velocity (left/right)
- - IF new timer > 150, enemy stops moving (will change to idle later)
ATTACK: IF attack finishes, change to idle
OUCH: IF ouch finishes, change to idle

d) If monster has its feet on the ground, make some monster decisions based on mode:

Code Snippet

if (grounded)
{
    switch (mode) {

i) Run away and wander mode use the same decisions in this case:

Code Snippet

// --- W A N D E R ---
case Mode.run_away:
case Mode.wander:
    if (target_vel.X < 0)                                          // going left
    {                    
        bool isSpike = Spike(x-1,y);
        if (Solid(x - 1, y) && !isSpike) {                         // if obstacle (that's not spike) 
            if (ContainsEmpty(x - 1, y - 4, y - 1))                // see if can jump over it (or onto it)
            {
                vel.Y = -12; MonsterJump();
            } 
            else target_vel.X = 4;                                 // if not change direction
        }
        else if (isSpike) target_vel.X = 4;                        // change directions if spikes are directly beside monster (ie: x-1, y)
 
        int isSolid = ContainsSolid(x - 1, y + 1, y + 5);
        if (isSolid == 0) target_vel.X = 4;                        // nothing to jump down onto so change directions
        else if (isSolid == 2) { target_vel.X = -8; vel.Y = -12; MonsterJump(); }       // try to jump over the spikes (x-1, y+(1 to 5))
    }

Going Left:
- if solid in the way:
- - IF can you jump over it or onto it? (1 left, 4 up to 1 up)
- - - - set jump velocity and intialize Monster Jump
- - ELSE change direction
- ELSE IF it's a spike, change direction
- GET if something solid to jump down onto (1 left, 1 down to 5 down)
- IF NO, change direction
- IF spikes, jump over them (or try)

ii) Left's do the same for Going Right:

Code Snippet

else if (target_vel.X > 0)                                     // going right
{
    bool isSpike = Spike(x + 1, y);
    if (Solid(x + 1, y) && !isSpike)                           // if obstacle that's not a spike
    {
        if (ContainsEmpty(x + 1, y - 4, y - 1)) {              // can jump over or onto ? 
            vel.Y = -12; MonsterJump();
        }
        else target_vel.X = -4;                                // no, so go other direction
    }
    else if (isSpike) target_vel.X = -4;                       // change directions if spikes are directly beside monster (ie: x+1, y)
    int isSolid = ContainsSolid(x + 1, y + 1, y + 5);
    if (isSolid == 0) target_vel.X = -4;                       // nothing to jump down onto so change directions
    else if (isSolid == 2) { target_vel.X = 8; vel.Y = -12; MonsterJump(); }     // try to jump over the spikes (x+1, y+(1 to 5))
}

(exact same idea as above but some values changed because going toward the right)

To take this a step further, you could use something like an A* algorythm by doing a sweeping test of an area based on what's there to determine choices and movements and provide a range/direction of vision to the monsters that may influence their behavior in a slightly more realistic way.

iii) When in patrol mode, the monster will only change directions when encountering obstacle:

Code Snippet

        // --- P A T R O L ---
        case Mode.patrol:
            if (target_vel.X < 0)                                          // going left
            {
                if (Solid(x - 1, y) || !tiles[x - 1, y + 1].stand_on || Spike(x-1,y+1)) // if obstacle or drop-off or spikes
                {
                    target_vel.X = Game1.rnd.Next(3) * + 4;                // go the other way (randomize speed a bit)
                }                            
            }
            else if (target_vel.X > 0)                                     // going right
            {
                if (Solid(x + 1, y) || !tiles[x + 1, y + 1].stand_on || Spike(x + 1, y + 1)) // if obstacle or drop-off or spikes
                {
                    target_vel.X = -Game1.rnd.Next(3) * - 4;               // go the other way (randomize speed a bit)
                }                            
            }                        
        break;
        
    }//^switch(mode)^
}//^grounded^

PATROL:
IF going left (check left):
- IF solid_obstacle or nothing-to-stand-on or spikes, change direction
IF going right (check right):
- if solid_obstacle or nothing-to-stand-on, or spikes, change direction

e) IF Chasing player (and wander or patrol mode), find out if close enough to attack and if so attack (and check for success):

Code Snippet

// --- C H A S E ---
if ((mode==Mode.wander)||(mode == Mode.patrol)) {
    if ((pos.X > player.pos.X - 220) && (pos.X < player.pos.X + 220))
    {
        if ((pos.Y > player.pos.Y - 150) && (pos.Y < player.pos.Y + 150))
        {                        
            if (pos.X < player.pos.X) target_vel.X = 6;
            if (pos.X > player.pos.X) target_vel.X = -6;   
            float left  = pos.X+bbox.X,     player_left  = player.bbox.X;
            float right = left+bbox.Width,  player_right = player.bbox.Z;
            float top   = pos.Y+bbox.Y,     player_top   = player.bbox.Y;
            float bot   = top+bbox.Height,  player_bot   = player.bbox.W;
            const float xrange = 100, yrange = 70;
            // IN RANGE TO TRY ATTACK?
            if ((right>player_left-xrange)&&(left<player_right+xrange)&&
                (bot > player_top - yrange) && (top < player_bot - yrange))
            {
                // BEGIN ATTACK
                if (last_motion != Act.attack)
                {
                    motion = Act.attack;                                
                    switch (type) // (sounds could be referenced with indexing[] too if you have lots of monster types)
                    {
                        case MonsterType.Mouster: MonsterSys.monster_attack1.Play(pan.Y, 0.8f, pan.X); break;
                        case MonsterType.Hellcat: MonsterSys.monster_attack2.Play(pan.Y, 0.8f, pan.X); break;
                    }
                }
                // DOES ATTACK HIT PLAYER?  // (only check if the animation's played past the first set of keys [****this may depend on how you made the attack keys****]            
                else if ((motion == Act.attack) && (meo_play.key1 > attack_key) && (player.invincible <= 0))
                {
                    top = pos.Y + attack_box.Y; bot = top + attack_box.Height;
                    if (!flip) { left = pos.X + attack_box.X; right = left + attack_box.Width; }
                    else { right = pos.X - attack_box.X; left = right - attack_box.Width; }
                    if ((right > player_left) && (left < player_right) && // IT HIT? 
                        (bot > player_top) && (top < player_bot))
                    {
                        player.HeroDamaged(0.2f);
                    }
                }
            }
        }
    }
}

IF within some general range (-220 to 220, -150 to 150):
- IF Left of player, go right
- IF Right of player, go left
- make some variables to making the bounding box tests easier to understand when reading them
- IF (right-side is within certain distance of player's left side) AND
      (left-side is within a certain distance of player's right side) AND
      (bottom-side is within a certain distance of player's top) AND
      (top-side is within a certain distance of player's bottom) :
- - IF (not already attacking)
- - - motion/animation = attack
- - - IF Mouster - play attack sound 1
- - - IF Hellcat - play attack sound 2
// (NOTE: you can also use a reference to the proper sound passed from MonsterSys so you don't need these switch statements)
- - IF (already attacking):
- - - IF facing right, adjust attack-box for right-facing attack
- - - IF facing left, adjust attack-box for left-facing attack
- - - IF bounding box's (player vs attack-box) overlap: Player takes 0.2 damage (could make monster dependent variable)

f) If the character's running away, set the appropriate direction to run:

Code Snippet

else if (mode == Mode.run_away) // R U N  A W A Y  (simple for now [maybe later add logic to escape spells too])
{
    if (pos.X < player.pos.X) target_vel.X = -6;
    if (pos.X > player.pos.X) target_vel.X = 6;   
}

g) Gradually accelerate the monster's velocity to its target velocity... if the velocity is ZERO, set the animation state (motion) to idle .... but if moving (and idle) then set motion as walk (or run if Mouseter [not that it makes a difference in this case])

Code Snippet

    // ADJUST VELOCITY / MOTION
    if (vel.X < target_vel.X) vel.X +=0.5f;
    if (vel.X > target_vel.X) vel.X -=0.5f;
    if (vel.X == 0) { if (motion != Act.jump) motion = Act.idle; }
    else if (motion==Act.idle)
    {
        motion = Act.walk;
        if (type == MonsterType.Mouster) motion = Act.run;
    }
}

(also don't set to idle if in the middle of a jump)

66) Update will need to know whether it should actually update the AI, (it also takes gameTime in case you want to use this with your MeoPlayer animations instead of the 60fps standard.
a) Much like the player class, we'll want to store the old position and map location in case backtracking is needed. Sweeping vectors tests could be done for high-velocity characters (selecting for the intersection closest to the old_pos). Our characters don't move even a fraction the speed necessary to require this type of CDCR, but it's something to keep in mind.

Code Snippet

//-------------
// U P D A T E  ( monster motions / AI)
//-------------
public void Update(GameTime gameTime, bool update_AI = true)
{
    old_pos = pos;                // previous world position
    old_loc = loc;                // previous map location   (in tiles)                   
    
 
    if (update_AI)
    {   
        UpdateAI();              // eventually you may want to change this to dispatch a unique AI for different types of monsters
    }
 
    // GRAVITY 
    if (vel.Y < MAX_FALL_SPEED) vel.Y += GRAVITY;
    // SLOW DOWN MONSTER:                  
    MeoAnimation walk_anim = meo.anim[walk_index]; // reference the walk for easier access
    if (vel.X > 0) { vel.X -= 0.40f; if (vel.X < 0) vel.X = 0; walk_anim.speed = vel.X *  0.42f; }
    if (vel.X < 0) { vel.X += 0.40f; if (vel.X > 0) vel.X = 0; walk_anim.speed = vel.X * -0.42f; } // animation speeds can only be positive (- x - = +)
    // DETERMINE FLIP (assumes monsters initially facing left)
    if (vel.X < -1) flip = true; else if (vel.X > 1) flip = false;
    // MOVE MONSTER            
    Vector2 tru_vel = vel * rescale; // factors character resize into velocity
    pos += tru_vel;  
    // STEREO PAN
    pan = Sound.GetPan(screen_pos);

- store old position / map_location
- Update the AI (makes some decisions about animation and movement)
- apply gravity
- for simplicty let walk_anim represent meo.anim[walk_index]
- if going right: reduce velocity and adjust walking animation speed accordingly
- same idea for going left...
- determine if should flip_horizontally
- get the velocity (scaled based on resolution adjustment if using)
- move the monster
- get the stereo panning based on the monster's screen position

b) If an animation MUST finish, don't allow animation change until it's done (once it's done, set to idle first)..
If allowed and the desired animation just changed, set the new animation.

Code Snippet

// ANIMATE:
bool allow_switch = true;
if (must_finish_animation)
    if (!meo_play.IsDoneAnimation()) allow_switch = false; else { must_finish_animation = false; motion = Act.idle; }            
if ((allow_switch)&&(motion != last_motion))
{
    switch (motion)
    {
        case Act.idle:   meo_play.SetAnimation("idle",   flip); break;
        case Act.walk:   meo_play.SetAnimation("walk",   flip); break;
        case Act.run:    meo_play.SetAnimation("run",    flip); break;
        case Act.attack: meo_play.SetAnimation("attack", flip); break;
        case Act.ouch:   meo_play.SetAnimation("ouch",   flip); break;
        case Act.jump:   if (jump_index>0) meo_play.SetAnimation("jump",   flip); break;   // if jump animation exists (none for hellcat)
    }
}
meo_play.flip = flip; 
last_motion = motion;

IF: determine if allowed to play a new animation (and if is actually new)
- IDLE: change / initialize idle animation (flip = true = face right... otherwise face left)
- WALK: same idea...
- same idea...
- (Note: IF a jump animation exists, play the jump) otherwise only the jump velocity is set (already did) )
- notify MeoPlayer the direction the monster should be facing (flip)
- remember which animation was playing for next loop to determine if a motion is a new one.

c) If the monster's on screen, Update it's MeoPlayer animation calculations. . . and if the monster's NOT invincible, see it got hurt:

Code Snippet

    if ((screen_pos.X > bbox.X) && (screen_pos.X + bbox.X < screenW) && (screen_pos.Y > bbox.Y) && (screen_pos.Y + bbox.Y < screenH))
        meo_play.Update(gameTime);                               // update character animations if they're going to be visible 
 
    // TEST IF PLAYER ATTACK HITS THIS MONSTER
    // P L A Y E R   A T T A C K E D   M O N S T E R   T E S T --------------------------
    if (invincible <= 0)
    {
        if (mode == Mode.run_away) mode = Mode.patrol;
        const int radius = 32, rad2 = 64; // radius of spell, radius * 2
        Rectangle bound_rec = new Rectangle((int)(pos.X + bbox.X), (int)(pos.Y + bbox.Y), (int)bbox.Width, (int)bbox.Height);
        int i = 0;
        while (i < player.spells.Count)
        {
            Vector2 spos = player.spells[i].emit_world_pos;
            Rectangle spell_rec = new Rectangle((int)(spos.X - radius), (int)(spos.Y - radius), rad2, rad2);
            if (spell_rec.Intersects(bound_rec)) MonsterDamaged(player.spell_power);
            i++;
        }
    }
    else { invincible--; mode = Mode.run_away; }
    // ^^^ player attacked monster test ^^^ ----------------------------------------------
 
} // ^^^ update ^^^

IF monster is visible on screen, make some MeoPlayer calculations for the animation.
IF NOT invincible:
- IF was running away, switch to patrol mode (run away while invincible [could extend this to timer or distance based])
- get current bounding rectangle (adding in position to bbox)
- LOOP spells:
- - get current bounding rectangle of spell (based on an approximate radius)
- - IF bounding rectangles of monster and spell overlap, apply damage to monster based on spell strength
IF invincible(due to damage)... countdown the invincibility and run away

67) Need a method to determine world collisions ...
a) It will work similar to player's world collisions so we can borrow the concept and make a few adjustments. This is preferred over making a universal world-collision class just so there is freedom to make specific tweaks to special cases that may only apply to a player or only to a monster... for now they act almost the same.

Code Snippet

//--------------------------------
// W O R L D  C O L L I S I O N S (monster vs world)
//--------------------------------
bool  on_spikes;
bool  last_grounded;
float bottom;                   // character bottom from center
public void WorldCollisions()
{
    // GET MONSTER'S SCREEN POSITION
    meo_play.position = screen_pos = Conv.world_to_screen(pos);
 
    // get monster tile occupation:                                                 
    loc.X = (int)pos.X / 64;
    loc.Y = (int)pos.Y / 64;
    int x = loc.X, y = loc.Y;
 
    // PREVENT ILLEGAL MEMORY ACCESS: 
    if ((x + 1 >= Map.TILES_WIDE) || (x - 1 < 0) || (y + 1 >= Map.TILES_HIGH) || (y - 1 < 0)) { pos = old_pos; loc = old_loc; }
 
    // GET MOVEMENT VECTOR:
    Vector2 move = pos - old_pos;
    // (! Assume velocity never exceeds tile size of 64 which is extremely fast [otherwise you need a sweep test for closest tile interactions] !)                                                  
 
    float BOUNCE_VEL = MAX_JUMP - 8f;                  // <-- how fast monster jumps up if it hits a spring platform

- on spikes - useful in more than 1 place - indicates if monster is currently on spikes
- last_grounded - if was grounded last time collisions were processed (determines if landing sound should be played)
- bottom - is set in get_monster_properties... (not made yet) - will be used to position monster at correct height when standing on something
- meo player's position and screen position(used here) are set to screen position based on world coord
- get map location from world coord ( /64 because tiles are 64x64) and set x,y for convenience
- clamp x,y to map
- get the movement vector (current position - old position)
- set a bouncer jump velocity (possible that MAX_JUMP is dynamic, otherwise this could be const too)

b) In much the same way player detected things above it and determined the collision response:

Code Snippet

// MOVING UP
if (move.Y < 0)
{                
    if (tiles[x, y - 1].is_solid)                  // WILL HIT SOLID (tile above)
    {
        if ((pos.Y + bbox.Y) < y * 64)             // top offset is distance from center of monster to top of it
        {
            if (tiles[x, y - 1].type == TileType.spring) { vel.Y = BOUNCE_VEL; bounceMgr.Add(x, y - 1); MonsterJump(true); }
            vel.Y = 0; pos.Y = old_pos.Y;
        }
    }
    if (tiles[x - 1, y - 1].is_solid)             // WILL HIT SOLID (up-left)
    {
        if ((pos.Y + bbox.Y) < y * 64)
        {
            if (tiles[x - 1, y - 1].type == TileType.spring) { vel.Y = BOUNCE_VEL; bounceMgr.Add(x - 1, y - 1); MonsterJump(true); }
            if (pos.X < (x - 1) * 64 + 84) { vel.Y = 0; pos.Y = old_pos.Y; }
        }
    }
    if (tiles[x + 1, y - 1].is_solid)             // WILL HIT SOLID (up right)
    {
        if ((pos.Y + bbox.Y) < y * 64)
        {
            if (tiles[x + 1, y - 1].type == TileType.spring) { vel.Y = BOUNCE_VEL; bounceMgr.Add(x + 1, y - 1); MonsterJump(true); }
            if (pos.X > (x + 1) * 64 - 20) { vel.Y = 0; pos.Y = old_pos.Y; }
        }
    }
    if (tiles[x, y].type == TileType.spring) { vel.Y = BOUNCE_VEL; bounceMgr.Add(x, y); MonsterJump(true); }
}

(Note: the values 84 and -20 above seem to work ok still (like with player)... but you can tweak them as you see fit)

c) Keep in mind, that pos is the position of the center of the monster. We get half_width to get the distance from the center to the edge of the bbox for convenience:

Code Snippet

int half_width = bbox.Width / 2;   
 
// MOVING RIGHT            
if (move.X > 0)
{                
    if (tiles[x + 1, y].is_solid)                     // WILL HIT SOLID (to right)
    {
        if ((pos.X + half_width) > (x + 1) * 64)
        {
            if (on_spikes) { if (tiles[x + 1, y].type != TileType.spikes) { pos.X = old_pos.X; x = old_loc.X; } }
            else { pos.X = old_pos.X; x = old_loc.X; }
        }
    }
    else if (tiles[x + 1, y - 1].is_solid)            // HIT SOLID (up-right)
    {
        if ((vel.Y < 0) || (pos.Y < y * 64 + 40))     // hardcoded as +40 (may need to change for other character sizes) 
            if ((pos.X + half_width) > (x + 1) * 64) { pos.X = old_pos.X; x = old_loc.X; }
    }
}
// MOVING LEFT
else if (move.X < 0)
{
    if (tiles[x - 1, y].is_solid)                     // WILL HIT SOLID (to left)
    {
        if ((pos.X - half_width) < x * 64)
        {
            if (on_spikes) { if (tiles[x - 1, y].type != TileType.spikes) { pos.X = old_pos.X; x = old_loc.X; } }
            else { pos.X = old_pos.X; x = old_loc.X; }
        }
    }
    else if (tiles[x - 1, y - 1].is_solid)            // HIT SOLID (up-left)
    {
        if ((vel.Y < 0) || (pos.Y < y * 64 + 40))
            if ((pos.X - half_width) < x * 64) { pos.X = old_pos.X; x = old_loc.X; }
    }
}

IF moving right,
- IF Solid blocking:
- - IF edge of monster passes edge of tile:
- - - IF on spikes IF obstruction is NOT spikes(some other solid): set monster back to old position/location
- - - ELSE just set monster back to old position/location
- IF Solid may be blocking monster's head:
- - IF jumping or at least 24 pixels up from bottom of that tile:
- - - IF edge of monster passes edge of tile: Set monster to old position/location
IF moving left,
[Same idea but for tiles to the left and pos.X - half_width (edge of monster on left side) ]

d) Set on_spikes and grounded as false until determined.
IF moving down:

Code Snippet

// MOVING DOWN
on_spikes = false;
grounded = false;                                         // reset grounded as false until we know: 
if (move.Y > 0)
{
    float offy = 0;                                    // <-possible offset for collision region (ie: if spikes: farther down)                
    if (tiles[x, y].stand_on)                             // WILL HIT SOLID (can stand-on)
    {
        if (tiles[x, y].spikes) offy = 28; else offy = 0; // hit spikes 28 pixels down from tile top
        if ((pos.Y + bottom) > y * 64 + offy)
        {
            pos.Y = y * 64 - bottom + offy; vel.Y = 0;    // set position so on top of tile                        
            grounded = true;                              // grounded   
            if (offy == 28) on_spikes = true;
            if (tiles[x, y].type == TileType.spring) { vel.Y = BOUNCE_VEL; bounceMgr.Add(x, y); MonsterJump(true); }//spring 
        }
    }
    if (tiles[x, y + 1].stand_on)                             // WILL HIT SOLID (can stand-on)
    {
        if (tiles[x, y + 1].spikes) offy = 28; else offy = 0; // hit spikes 28 pixels down from tile top
        if ((pos.Y + bottom) > (y + 1) * 64 + offy)
        {
            pos.Y = (y + 1) * 64 - bottom + offy; vel.Y = 0;  // set position so on top of tile                        
            grounded = true;                                  // grounded   
            if (offy == 28) on_spikes = true;
            if (tiles[x, y + 1].type == TileType.spring) { vel.Y = BOUNCE_VEL; bounceMgr.Add(x, y + 1); MonsterJump(true); } // spring 
        }
    }
    if (tiles[x - 1, y].stand_on)                             // WILL HIT SOLID (can stand-on)
    {
        if (tiles[x - 1, y].spikes) offy = 28; else offy = 0; // hit spikes 28 pixels down from tile top
        if ((pos.Y + bottom) > y * 64 + offy)
        {
            if (pos.X < (x - 1) * 64 + 84)
            {
                pos.Y = y * 64 - bottom + offy; vel.Y = 0;    // set position so on top of tile                        
                grounded = true;                              // grounded   
                if (offy == 28) on_spikes = true;
            }
        }
    }

IF IN a tile that can be stood on:
- IF spikes: set standing offset as 28 pixels from top of tile
- IF bottom of monster passes top of tile (@ standing position):
- - position monster so feet touch where it should stand
- - set as grounded (touching the ground)
- - IF on spikes... set on_spikes = true
- - IF it's a spring/bouncer, bounce monster up and trigger bouncer animation (play bounce sound = true)
IF tile BELOW can be stood on:
(same idea except applied to tile below)
IF tile to the left can be stood on:
Same idea except:
IF monster position's < 20 pixels right of right edge of the tile: (using + 84 as edge tolerance - you can adjust this for your chars)
- set monster standing above the tile (and set on_spikes if so)
Continuing:

Code Snippet

if (tiles[x - 1, y + 1].stand_on)                         // down-left (can stand on)
{
    if (tiles[x - 1, y + 1].spikes) offy = 28; else offy = 0;
    if ((pos.Y + bottom) > (y + 1) * 64 + offy)
    {
        if (pos.X < (x - 1) * 64 + 84)                    // allow monster to stand at the very edge (hard coded as 84 for now)
        {
            pos.Y = (y + 1) * 64 - bottom + offy; vel.Y = 0;
            grounded = true;
            if (offy == 28) on_spikes = true;
            if (tiles[x - 1, y + 1].type == TileType.spring) { vel.Y = BOUNCE_VEL; bounceMgr.Add(x - 1, y + 1); MonsterJump(true); }                            
        }
    }
}
if (tiles[x + 1, y + 1].stand_on)                      // down-right (can stand on)
{
    if (tiles[x + 1, y + 1].spikes) offy = 28; else offy = 0;
    if ((pos.Y + bottom) > (y + 1) * 64 + offy)
    {
        if (pos.X > (x + 1) * 64 - 20)                 // allow monster to stand at the very edge
        {
            pos.Y = (y + 1) * 64 - bottom + offy; vel.Y = 0;
            grounded = true;
            if (offy == 28) on_spikes = true;
            if (tiles[x + 1, y + 1].type == TileType.spring) { vel.Y = BOUNCE_VEL; bounceMgr.Add(x + 1, y + 1); MonsterJump(true); }                            
        }
    }
}
if (tiles[x + 1, y].stand_on)                             // WILL HIT SOLID (can stand-on)
{
    if (tiles[x + 1, y].spikes) offy = 28; else offy = 0;  // hit spikes 28 pixels down from tile top
    if ((pos.Y + bottom) > y * 64 + offy)
    {
        if (pos.X > (x + 1) * 64 - 20)
        {
            pos.Y = y * 64 - bottom + offy; vel.Y = 0;    // set position so on top of tile                        
            grounded = true;                              // grounded   
            if (offy == 28) on_spikes = true;
        }
    }
}

IF tile to the left and below can be stood on:
Same idea applied to tile to left and below... (thus +84 for edge tolerance [ie: so monster can stand on the edge of a tile])
Same idea for tile to the right and below [x+1, y+1]
(used + 20 [thus 64+20 = 84] for left and now -20 for tile to the right)
so: IF monster is to the right of the tile - 20, then should be able to stand on it (now determine if spikes or bouncer or just solid)
Same idea checking tile to the right.

e) If monster is on spikes, monster can take damage (but if monster was a metal robot, you might want to check type and make so it doesn't take damage in that case)

Code Snippet

        // HIT SPIKES: 
        if (on_spikes)
        {
            if (move.Y > 0)
            {
                MonsterDamaged(1);
            }
        }
        if ((on_spikes == false) && (motion != Act.jump) && (grounded) && (!last_grounded)) Sound.land.Play(pan.Y, 0.8f, pan.X);
    }//^^^ move.Y>0 ^^^  
    last_grounded = grounded;
 
} // ^^^ world collisions ^^^

IF on spikes (and not jumping), monster takes damage.
IF NOT on spikes and NOT jumping and on the ground (but wasn't last loop), play a landing sound (since monster just hit the ground)
Remember what last grounded was for next time.

68) Draw the monster using MeoPlayer:

Code Snippet

//--------
// D R A W 
//--------
public void Draw()
{            
    // IS VISIBLE? (if no return) 
    if ((screen_pos.X < bbox.X) || (screen_pos.X + bbox.X > screenW) || (screen_pos.Y < bbox.Y) || (screen_pos.Y + bbox.Y > screenH)) return;
   
    // DRAW MONSTER   
    Color col = Color.White;
    if (invincible > 0) {
        int n = invincible % 10;
        if (n > 5) col = new Color(255, 155, 155, 255); // flashing if invincible                
    }       
    meo_play.Draw(col);            
}

IF off screen, return
IF invincible, make red for 5 loops and normal for 5 loops and repeat this.Red, White, Red, white, Red, White...(white = no change)
Draw the monster.

69) Draw colliders will be used for debugging purposes... this way you can see where the attack regions are and where the monster's body can be collided with by players (ie: if they attack)
Before we do this, we'll need to add some extensions to SpriteBatch for drawing bounding rectangles.

a) Right-Click on your c# project_name and Add>>Class: "Extensions"

b) In Extensions.cs, make the class static... ie: static class Extensions
i) Let's start by adding a DrawLine function. GPU's do everything by drawing triangles using a texture source, so we'll need a texture source that it can extract a pixel from. We'll need a point1 and point2 to draw the line between and a line color:

Code Snippet

public static void DrawLine(this SpriteBatch spriteBatch, Texture2D tex, Rectangle pixel, Vector2 begin, Vector2 end, Color color, int thick = 1)
{            
    Vector2 delta = end - begin;
    float rot = (float)Math.Atan2(delta.Y, delta.X);
    if (pixel.Width > 0) { pixel.Width = 1; pixel.Height = 1; }
    spriteBatch.Draw(tex, begin, pixel, color, rot, new Vector2(0, 0.5f), new Vector2(delta.Length(), thick), SpriteEffects.None, 0);
}

So, delta is the vector(relative to 0,0)
Using rule, tan(angle) = Y/X for a triangle... get the angle of the vector using Atan(Y/X)
Draws a pixel from tex at begin point, scaled as: (X-scale: length, Y-scale: 1), and rotated [around (0,0.5)] to angle of rot
So basically it makes a pixel stretched out to the line length and rotates it based on the angle the line would be.

ii) DrawRectLines will be useful for drawing bounding boxes. In this case, since each line is straight verticle or horizontal, we can just modify the destination rectangle (taking from pixel as the source rect):

Code Snippet

public static void DrawRectLines(this SpriteBatch spriteBatch, Texture2D tex, Rectangle pixel, Rectangle r, Color color, int thick = 1) {
    spriteBatch.Draw(tex, new Rectangle(r.X, r.Y, r.Width, thick), pixel, color);
    spriteBatch.Draw(tex, new Rectangle(r.X + r.Width, r.Y, thick, r.Height), pixel, color);
    spriteBatch.Draw(tex, new Rectangle(r.X, r.Y + r.Height, r.Width, thick), pixel, color);
    spriteBatch.Draw(tex, new Rectangle(r.X, r.Y, thick, r.Height), pixel, color);
}

c) Going back into Monster.cs:
Let's show the monster's body bounding-box (where it is vulnerable), and it's attack bounding-box (where it's attacking bounding box is [what parts can effect players])

Code Snippet

//-------------------------
// D R A W  C O L L I D E R (s)  (for debugging collision detections)
//-------------------------
public void DrawCollider(SpriteBatch spriteBatch, Texture2D tex, Rectangle s_box)
{
    // IS VISIBLE? (if no return) 
    if ((screen_pos.X < bbox.X) || (screen_pos.X + bbox.X > screenW) || (screen_pos.Y < bbox.Y) || (screen_pos.Y + bbox.Y > screenH)) return;
    
    float left = screen_pos.X + bbox.X;
    float top = screen_pos.Y + bbox.Y;
    
    Rectangle pixel_source = new Rectangle(896,0,1,1);
    
    // SHOW MONSTER'S VULNERABLE BBOX:
    spriteBatch.DrawRectLines(tex, pixel_source, new Rectangle((int)left,(int)top, bbox.Width, bbox.Height), Color.White);            
   
    // SHOW PLAYER'S VULNERABLE BBOX: 
    spriteBatch.DrawRectLines(tex, pixel_source, s_box, Color.White);
 
    // SHOW MONSTER'S ATTACKING BBOX:
    top = screen_pos.Y + attack_box.Y; 
    if (!flip) { left = screen_pos.X + attack_box.X; } else { left = screen_pos.X - attack_box.X - attack_box.Width; }
    //Console.WriteLine("coord: " + left + "," + top + "," + attack_box.Width + "," + attack_box.Height);
    spriteBatch.DrawRectLines(tex, pixel_source, new Rectangle((int)left, (int)top, attack_box.Width, attack_box.Height), Color.Red);  
}

NOTE: It's not properly optimal to draw the player's bounding box every single time we draw the moster rects, but since this is only for debugging, we don't actually care... so I just put it in here (should put it in a DrawColliders for player class)
s_box - player's bounding box (where player can get hit)
-IF monster's screen position(+bbox.X) is off screen to the left OR it's off screen to the right OR off the top of screen or off bottom: then: return...
For simplicity get the left and top edges.
-Set a pixel source (this rectangle must be somewhere on the supplied texture map that is white)
Using the supplied texture and source, draw the monster's bounding box (where it can be hit)
-Show player's bounding box (s_box) [should probably move this to a DrawColliders in the player class to avoid redundancy]
-Get the left and top edges of the attack-bounding-box.
(If facing left, then left becomes X - attack_box.X - attack_box.Width (where attack_box.X is a negative offset) )
-Draw Attack bounding box (area of monster that when attacking, can hurt player)

d) Monster properties are subject to rescale also so let's make a helper to adjust scale based on resolution:

Code Snippet

// RESCALE RECT (helper for Get Monster Properties) 
Rectangle Rescale_Rect(int X, int Y, int Width, int Height)
{
    Vector2 corner    = new Vector2(X,Y) * rescale;
    Vector2 dimension = new Vector2(Width, Height) * rescale;
    return new Rectangle((int)corner.X, (int)corner.Y, (int)dimension.X, (int)dimension.Y);
}

(X,Y are offsets from a center so rescaling will work fine)
Just returns the rescaled version of a rectangle.

e) We'll now want to make that get_monster_properties method I kept mentioning. It will be used to determing bounding boxes for each monster, where the bottom of the monster is (adjust until feet seem to touch at the right height), and which animation frames the attack should effect the player (ie: charging an attack shouldn't hurt the player).

Code Snippet

// G E T  M O N S T E R  P R O P E R T I E S  (and assign a bounding box) 
string get_monster_properties(MonsterType mType)
{
    string sheet_name = "mouster";                           
    switch (mType)
    {
        case MonsterType.Mouster: 
            sheet_name = "mouster";                    
            bbox       = Rescale_Rect(-150,-115,300,205);    // top-left from center, width, height (box around monster for collision detection [sizes using info in original image before dissection])
            attack_box = Rescale_Rect(30, -130, 120, 180);   // top_left from center, width, height (for attack region that can hit player)                                                                                
            bottom     = bbox.Y + bbox.Height-11;            // bottom = custom value (-52) to make sure it looks right when standing on something
            attack_key = 1;                                  // which animation key does the attack begin to be dangerous
            life       = 3;
            break;
        case MonsterType.Hellcat: 
            sheet_name = "hellcat";                    
            bbox       = Rescale_Rect( -80, -135, 160, 170);
            attack_box = Rescale_Rect(-190, -100, 380, 110);
            bottom     = bbox.Y + bbox.Height-11;             // bottom = custom value (-48) so it looks right when standing on something
            attack_key = 11;
            life       = 2;
            break;
    }            
    return sheet_name;
}

Based on the type of Monster:
- need the associated sheet_name (used with animation lookups to get the correct index)
bbox = bounding box (vulnerable part of monster), attack_box = (dangerous part of monster)
- x,y = offset from center (center to top-left corner of bbox), width,height = size of bbox
bottom = what part of the monster's feet impact the ground
attack_key = first keyframe where attack starts to hurt player (if in range)
life = life bar
sheet_name is returned so the constructor can set it (based on type)

f) We'll also want the customize_monster (which actually customizes animation properties):

Code Snippet

    // C U S T O M I Z E  M O N S T E R 
    void customize_monster() {
        int index;            
        jump_index = meo_play.GetIndex("jump", false); // FALSE = don't show errors for this one since if no jump is available that will be ok
        ouch_index = meo_play.GetIndex("ouch");
        switch (type)
        {
            case MonsterType.Mouster:
                meo_play.SetAnimation("idle", flip); motion = Act.idle;
                index = meo_play.GetIndex("idle");   meo.anim[index].speed = 0.8f;  // slow down the idle a bit    
                walk_index = meo_play.GetIndex("run");                    
                break;
            case MonsterType.Hellcat:
                meo_play.SetAnimation("idle", flip); motion = Act.idle;
                index = meo_play.GetIndex("idle");   meo.anim[index].speed = 0.8f;  // "
                walk_index = meo_play.GetIndex("walk");                    
                break;
        }            
    }
}

- get jump_index (if available ... false means no error if not available) ... if there isn't one, we already coded it to not play an animation jump if jump_index<1 and instead just provide a jump velocity (and sound).
- get damaged index
- start by setting the idle animation (and motion as idle) ... some monsters you may want to start with something different.
- modify the default speed of the idle to be a bit slower
- one monster uses "run" as the walk (has no walk) and the other one obviously just uses "walk" for that (has no run).

----------------------
70) In solution explorer, right-click on the Monsters folder, and Add>>Class: "MonsterSys"
a) In MonsterSys.cs, we'll need to have it store the monster animations, all the different active monsters, monster sound effects... and it will need access to the player(s), the map, and the explosion manager.

Code Snippet

// Loads monster sets, add / delete monsters / calls to draw/update monsters
// In this version, Monsters are added using the map editor to indicate where monsters start... but you could make a off-screen spawn method too
class MonsterSys
{
    const int   MAX_MONSTERS = 30;                    // most number of monsters allowed in a level                
    
    // FOR MEOMOTION ANIMATION
    MeoMotion           meo;                        // MeoMotion class to contain monsters 
    public Monster[]    monsters;                   // unique monsters (which have their own MeoPlayers)         
    int                 num_monst;        
    Vector2             rescale;                    // adjusts character size and motion based on resolution
 
    // OTHER
    QuadBatch           quadBatch;                  // reference to quadBatch (provided to player in Monster class)
    Map                 mp;                         // reference to map   
    Player              player;                     // reference to player
    ExplodeSys          explode;                    // reference to explodeSys (explosion animations)
 
    // SOUND
    static public SoundEffect monster_attack1;  // Mouseter attack sound
    static public SoundEffect monster_attack2;  // HellCat " "
    static public SoundEffect monster_ouch1;    // Mouster ouch
    static public SoundEffect monster_ouch2;    // HellCat ouch

meo - contains each monster and their animations
monsters[] - holds all the monsters (for some number of monsters: num_monst)
quadBatch - used by MeoPlayer of monster to draw distortable quads

b)Construct will need to provide access for loading content, refer to: quadBatch, map, player, and explosion systems:

Code Snippet

// C O N S T R U C T
public MonsterSys(ContentManager Content, QuadBatch QBatch, Map map, Player playr, ExplodeSys ex)
{
    meo       = new MeoMotion(Content, QBatch);
    monsters  = new Monster[MAX_MONSTERS];
    num_monst = 0;
    
    quadBatch = QBatch;
    mp        = map;
    player    = playr;
    explode   = ex;
}

We'll allocate memory for up to 30 monsters for this example (could use lists too if you prefer)

c) Based on the level (or area, we can have it load different monster files and sound effects)
In this example, we only have level 1... so 1 case:

Code Snippet

//--------
// L O A D 
//--------
public void Load(int lev, ContentManager Content)
{
    rescale = Game1.rescale * 0.5f; // make 50% smaller than original monster sizes
    switch (lev) {
        case 1:                     
            meo.Load_TXT("Monsters1", rescale); // load characters/animations (.TXT must be with exe file [ie: BIN - Windows - debug/release] )
            monster_attack1 = Content.Load<SoundEffect>("Sound/MousterHit");
            monster_ouch1   = Content.Load<SoundEffect>("Sound/MousterOuch");
            monster_attack2 = Content.Load<SoundEffect>("Sound/ChainsawHit");
            monster_ouch2   = Content.Load<SoundEffect>("Sound/CatOuch");
            break;
    }                                    
}

Note that the Monsters1.txt in this example is a combined project export containing data for both monster types (which it also placed the images for onto a combo sheet as a png which we put in Content) [see source code for sound effects and images]
The txt is placed in the same file as the exe (either debug or release folder until project is ready for final release)

d) We'll need a method to add new monsters to the scene:

Code Snippet

//---------------------
// A D D  M O N S T E R 
//---------------------
public void AddMonster(MonsterType type, Vector2 Pos)
{
    // Check existing monsters (if any) and try to change any dead ones to the new one (if any)             
    int i = 0;
    while(i<num_monst) {
        if (monsters[i].dead) {
            monsters[i].ChangeMonster(Pos, type);                           // make alive and change to desired monster
            return;                                                         // monster is added so return
        }
        i++;
    }
    // No existing monsters that are dead to replace - see if we can add a new one:
    if (num_monst >= MAX_MONSTERS) return;                                    // maximum - can't add more to this level - return 
    monsters[num_monst] = new Monster(Pos, meo, quadBatch, type, mp, player, explode); // CREATE MONSTER
    num_monst++;
}

- takes type and starting position
- checks for any dead monsters and as soon as it finds one it puts the new monster in this slot (at a new position and type) [return]
- max sure not to exceed the maximum allocated number of monsters
- no monsters were dead so create a new monster supplying access to everything it will need
- increment
(Like I said you could use lists for this and it may even be preferable if your monster quantity will change a lot)

e) Deleting monsters [ FOR EDITOR ONLY - in play mode just set monster as dead = true ]

Code Snippet

//------------
// D E L E T E ( editor delete of monster by map-tile coordinate [ in the game mode you simply set it to dead=true ] ) 
//------------
public void Delete()
{
    int i = 0;
    while (i < num_monst) {
        if (monsters[i].loc == mp.loc) {        // if a monster occupies the editor tile location: 
            int a = i;
            while (a < num_monst-1) {           // shift the list back 1 and delete the last entry since it becomes a duplicate of the 2nd-last    
                if (monsters[a + 1] != null) monsters[a] = monsters[a + 1]; else break;
                a++;
            }
            monsters[a] = null; num_monst--;    // delete last entry since they were copy-shifted back 1
        }
        i++;
    }
}

LOOP:
IF monster location is map location:
- - starting at current index LOOP:
- - - IF next monster(a+1) in list is valid, move it back to current index (a)
- - remove monster at very end of list (since all valid ones have moved back 1 overwriting the one we wanted to delete)

f) For Updating monsters we'll want to optionally update the AI and update collision detections:

Code Snippet

//------------
// U P D A T E  ( AI )
//------------
public void Update(GameTime gameTime, bool updateAI = true)
{
    int i = 0;
    while (i < num_monst)
    {
        if (monsters[i].dead) { i++; continue; }
        monsters[i].Update(gameTime, updateAI);                     // update all monster motions in world
        monsters[i].WorldCollisions();                              // check for world collisions                
        i++;
    }
}

LOOP
- skip the dead ones
- update the monster's choices and animations
- do world collision detections and responses (CDCR)

g) To draw all the monsters:

Code Snippet

//--------
// D R A W  
//--------
public void Draw()
{
    quadBatch.Begin(meo.tex, BlendState.AlphaBlend, SamplerState.LinearClamp, DepthStencilState.None);
    int i = 0;
    while (i < num_monst)
    {
        if (!monsters[i].dead)  monsters[i].Draw();                   //  ( draw visible monsters )
        i++;
    }
    quadBatch.End();
}

- monsters are drawn with distortion animations, so set the quadbatch using the texture stored in the local meo.tex which contains all the monster part images. Premultiplied texture map property so use AlphaBlend. Basic smoothing so use LinearClamp.
LOOP:
- if monster's alive, draw it...
- end the quadbatch [done using meo.tex since all monsters are drawn now]

h) Last thing we'd like to be able to do is show all the monster colliders:

Code Snippet

    //---------------------------
    // D R A W  C O L L I D E R S (for debugging collision detections)
    //---------------------------
    public void DrawColliders(SpriteBatch spriteBatch, Texture2D tx)
    {            
        // get the bounding box in screen coordinates:
        // top left & bottom right coords - used to visualize if enemy attack hits you (monsters.cs):            
        Rectangle sbox  = Conv.bbox_world_to_screen(player.bbox);                        
        
        int i = 0;
        while (i < num_monst)
        {
            if (!monsters[i].dead) monsters[i].DrawCollider(spriteBatch,tx,sbox);  //  ( draw collision boxes for debugging )
            i++;
        }         
    }        
}

- supply access to the spriteBatch and a texture which has a tiny white rectangle in it somewhere that can be used as a pixel source-rectangle for drawing lines with.
- get the player's bounding box to send (later to do this properly you may want to move this part into a new DrawPlayerColliders method to avoid redundant player-box drawing... since this is just for debugging monsters, it is not a concern)
LOOP
- if the monster is alive, draw it's bounding boxes (body region, attack region) [for now also draws player region]

>>> NEXT PAGE(5) <<<

>>> Back to Game Design <<<

MonoGame (new XNA) Tutorial: Platformer Game Programming Tutorial

MonoGame (new XNA) Tutorial:
Platformer Game Programming Tutorial