/// <summary>
/// Initializes a new instance of the <see cref="GamePlayMenuLabel"/> class.
/// </summary>
/// <param name="screen">The screen to be drawn on.</param>
/// <param name="id">The id of this item.</param>
/// <param name="graphicsDevice">The graphics device.</param>
public GamePlayMenuLabel(GameScreen screen, int id, IBallerburgGraphicsManager graphicsDevice)
{
this.Id = id;
this.Owner = screen;
this.State = States.Visible;
this.graphicsDevice = graphicsDevice;
}
protected EntityManager(GameScreen screen)
{
Owner = screen;
Owner.Game.Window.ClientSizeChanged += (s, e) => DoRecalcBoundingBox();
DoRecalcBoundingBox();
}
public PathCPUParticleEmitter(GameScreen scrn, Vector2 pos, VectorPath path, ParticleEmitterConfig cfg) : base(scrn, cfg)
{
vectorPath = path;
vectorPathCenter = path.Boundings.Center;
Position = pos;
}
/// <summary>
/// Initializes a new instance of the <see cref="OnOffToggleButton"/> class.
/// </summary>
/// <param name="screen">The screen.</param>
/// <param name="text">The text to display.</param>
/// <param name="on">if set to <c>true</c> [on].</param>
/// <param name="id">The id of this element.</param>
public OnOffToggleButton(GameScreen screen, string text, bool on, int id)
{
this.text = text;
this.Id = id;
this.Owner = screen;
this.value = on;
}
/// <summary>
/// Button class constructor.
/// </summary>
/// <param name="position">The top-left corner of the Button.</param>
/// <param name="width">The Button's width.</param>
/// <param name="height">The Button's height.</param>
/// <param name="screen">Reference to the screen on which the Button exists.</param>
public Button( Point position, int width, int height, GameScreen screen )
: base(position, width, height, screen)
{
// Starting state is inert
state = 0;
textColours = new Color[4];
}
public override void Initialize(GraphicsDevice Device, ScreenManager manager)
{
base.Initialize(Device, manager);
Settings.LoadSettings();
Panel panel = new Panel(this, new Vector2(300, 160), new Vector2(200, 280), Content.ContentInterface.LoadTexture("UITest"));
Button button = new Button(this, new Vector2(60, 30), new Vector2(80, 40), Content.ContentInterface.LoadTexture("UITest"),
delegate { Settings.ServerAddress = "localhost";
_manager.RemoveScreen(this); GameScreen screen = new GameScreen();
screen.SetupLocalServer(); _manager.AddScreen(screen); },
"Local");
AddChild(panel);
panel.AddChild(button);
button = new Button(this, new Vector2(20, 90), new Vector2(160, 40), Content.ContentInterface.LoadTexture("UITest"),
delegate { _manager.RemoveScreen(this); _manager.AddScreen(new GameScreen()); },
"Online");
panel.AddChild(button);
button = new Button(this, new Vector2(20, 150), new Vector2(160, 40), Content.ContentInterface.LoadTexture("UITest"),
delegate { Console.WriteLine("Test2"); },
"Testbutton2");
panel.AddChild(button);
button = new Button(this, new Vector2(20, 210), new Vector2(160, 40), Content.ContentInterface.LoadTexture("UITest"),
delegate { Console.WriteLine("Test3"); },
"Testbutton3");
panel.AddChild(button);
}
public Marble(GameScreen game)
: base(game, "marble")
{
preferPerPixelLighting = true;
// Load the texture of the marble
m_marbleTexture = Engine.Content.Load<Texture2D>(@"Textures\Marble");
}
/// <summary>
/// Initializes a new instance of the <see cref="ActionToggleButton"/> class.
/// </summary>
/// <param name="screen">The screen.</param>
/// <param name="text">The text to display.</param>
/// <param name="stateText">The state text.</param>
/// <param name="id">The id of this element.</param>
public ActionToggleButton(GameScreen screen, string text, string stateText, int id)
{
this.text = text;
this.Id = id;
this.Owner = screen;
this.stateText = stateText;
}
/// <summary>
/// The constructor is private: loading screens should
/// be activated via the static Load method instead.
/// </summary>
private LoadingScreen(ScreenManager screenManager, bool loadingIsSlow, GameScreen[] screensToLoad)
{
this.loadingIsSlow = loadingIsSlow;
this.screensToLoad = screensToLoad;
TransitionOnTime = TimeSpan.FromSeconds(0.5);
}
public ScreenManager(Game game)
: base(game)
{
menuScreen = new MenuScreen();
gameScreen = new GameScreen();
keyboard = new Input();
}
public Marker(GameScreen screen, Vector3 position)
: base(screen.Game)
{
this.Screen = screen;
this.position = position;
DrawOrder = 5;
}
public ScoresBoard(GameScreen i_GameScreen, int i_PlayerNumber, Color i_TextColor)
: base(i_GameScreen.Game)
{
r_TextColor = i_TextColor;
r_PlayerNumber = i_PlayerNumber;
i_GameScreen.Add(this);
}
// Constructors =======================================//
public Hud(GameScreen parent)
: base(parent)
{
// Initialize Fields
maxDamage = 100f;
damageValue = 100f;
resistanceValue = 100f;
scoreValue = GlobalVariables.score;
moneyValue = GlobalVariables.money;
hudSprite = Engine.Content.Load<Texture2D>("Content\\Textures\\damage");
SpriteFont font1 = Engine.Content.Load<SpriteFont>("Content\\Fonts\\FontAgency24");
// Initialize the Damage bars
damageText = new Entity2D(hudSprite, new Vector2(15f, 30f), this.Parent);
damageText.Rectangle = new Rectangle(0, 150, 260, 50);
damageBox = new Entity2D(hudSprite, new Vector2(10f, 10f), this.Parent);
damageBox.Rectangle = new Rectangle(0, 0, 260, 50);
damageBarGlass = new Entity2D(hudSprite, new Vector2(10f, 20f), this.Parent);
damageBarGlass.Rectangle = new Rectangle(0, 50, 260, 50);
damageBar = new Entity2D(hudSprite, new Vector2(20f, 20f), this.Parent);
damageBar.Rectangle = new Rectangle(0, 100, 238, 50);
// Initialize the text
Vector2 bgHudPos = new Vector2(0, Engine.Viewport.Height - 90);
levelText = new EntityText(font1, new Vector2(10, 11), "Level:"+GlobalVariables.level.ToString(), this.Parent);
levelText.Position = new Vector2(Engine.Viewport.Width-120, bgHudPos.Y + 15);
scoreText = new EntityText(font1, new Vector2(10, 11), GlobalVariables.score.ToString(), this.Parent);
scoreText.Position = new Vector2(230, bgHudPos.Y + 15);
moneyText = new EntityText(font1, new Vector2(10, 35), GlobalVariables.money.ToString(), this.Parent);
moneyText.Position = new Vector2(530, bgHudPos.Y + 15);
hudSprite = Engine.Content.Load<Texture2D>("Content\\Textures\\moneyHUD");
// Initialize the score and money fields
scoreGlass = new Entity2D(hudSprite, new Vector2(10, bgHudPos.Y), this.Parent);
scoreGlass.Rectangle = new Rectangle(0, 200, 300, 100);
moneyGlass = new Entity2D(hudSprite, new Vector2(300, bgHudPos.Y), this.Parent);
moneyGlass.Rectangle = new Rectangle(0, 200, 300, 100);
score = new Entity2D(hudSprite, new Vector2(10, bgHudPos.Y), this.Parent);
score.Rectangle = new Rectangle(0, 0, 300, 100);
money = new Entity2D(hudSprite, new Vector2(300, bgHudPos.Y), this.Parent);
money.Rectangle = new Rectangle(0, 100, 300, 100);
// Initialize the black Texture
black = new Entity2D(Engine.Content.Load<Texture2D>("Content\\Textures\\black"),
new Vector2(0, 400), this.Parent);
black.Rectangle = new Rectangle(0, 0, 800, 75);
black.Position = bgHudPos;
black.Alpha = 0.3f;
}
public MenuItem(string i_Title, GameScreen i_GameScreen, IMenuConfiguration i_MenuConfiguration)
{
TitleValue = string.Empty;
Title = i_Title;
GameScreen = i_GameScreen;
r_MenuConfiguration= i_MenuConfiguration;
}
public override void Draw(GameScreen gameScreen, GameTime gameTime)
{
SpriteBatch spriteBatch = gameScreen.ScreenManager.SpriteBatch;
SpriteFont font = gameScreen.ScreenManager.BigFont;
ButtonTexture = ButtonTexture ?? gameScreen.ScreenManager.BlankTexture;
var newPosition = Position;
var textSize = font.MeasureString(Text);
if (ShowText)
{
newPosition.Y -= textSize.Y / 1.5f;
}
Rectangle rec = new Rectangle((int)newPosition.X, (int)newPosition.Y, (int)Size.X, (int)Size.Y);
if(!IsHovered)
spriteBatch.Draw(Icon, rec, Color.White);
else
spriteBatch.Draw(Icon, rec, HoverColor);
var textPosition = newPosition;
textPosition.Y += Size.Y + 10;
textPosition.X += (Size.X - textSize.X)/2;
spriteBatch.DrawString(font, Text, textPosition, TextColor);
}
public MenuScreen(GameScreen screen)
{
TransitionOnTime = TransitionOffTime = TimeSpan.FromSeconds(1.5);
if (screen.ScreenState != ScreenState.Frozen)
screen.ScreenState = ScreenState.Frozen;
parent = screen;
}
public PlayerSpaceInvaders(GameScreen i_GameScreen, string i_PlayerNickname, eSpaceShipType i_SpaceShipType)
: base(i_GameScreen.Game, i_PlayerNickname)
{
m_LoseLifeSound = SoundFactory.CreateSound(this.Game, SoundFactory.eSoundType.LifeDie) as Sound;
m_Nickname = i_PlayerNickname;
m_SpaceShipType = i_SpaceShipType;
m_ScoreText = SpritesFactory.CreateSprite(i_GameScreen, SpritesFactory.eSpriteType.SmallText) as Text;
SpritesFactory.eSpriteType lifeType = SpritesFactory.eSpriteType.LifeBlueSpaceShip;
switch (m_SpaceShipType)
{
case eSpaceShipType.Blue:
m_SpaceShip = SpritesFactory.CreateSprite(i_GameScreen, SpritesFactory.eSpriteType.BlueSpaceShip) as SpaceShip;
m_ScoreText.TintColor = Color.Blue;
lifeType = SpritesFactory.eSpriteType.LifeBlueSpaceShip;
break;
case eSpaceShipType.Green:
m_SpaceShip = SpritesFactory.CreateSprite(i_GameScreen, SpritesFactory.eSpriteType.GreenSpaceShip) as SpaceShip;
m_ScoreText.TintColor = Color.Green;
lifeType = SpritesFactory.eSpriteType.LifeGreenSpaceShip;
break;
}
for (int i = 0; i < this.Lifes; i++)
{
Life life = SpritesFactory.CreateSprite(i_GameScreen, lifeType) as Life;
life.Initialize();
this.LifesSprites.Add(life);
}
}
public Sprite(string i_AssetName, GameScreen i_Game, int i_UpdateOrder, int i_DrawOrder)
: base(i_AssetName, i_Game.Game, i_UpdateOrder, i_DrawOrder)
{
AngularVelocity = 0;
Screen = i_Game;
Screen.Add(this);
}
public MotherShip(GameScreen i_GameScreen, string i_AssetName)
: base(i_AssetName, i_GameScreen)
{
this.Points = m_PointsToBeEarned;
this.Velocity = new Vector2(r_MotherShipVelocity, 0);
m_SoundWhenKilled = SoundFactory.CreateSound(this.GameScreen, SoundFactory.eSoundType.MotherShipKill) as Sound;
}
private LoadingScreen(ScreenManager screenManager, NetworkManager nManager, GameScreen[] screens)
{
isNetworkGame = true;
netManager = nManager;
screensToLoad = screens;
TransitionOnTime = TimeSpan.FromSeconds(1.0);
}
public void ShowScreen()
{
Resolve<Window>().ViewportPixelSize = new Size(1280, 800);
var screen = new GameScreen();
screen.FadeIn();
screen.StartNextLevel();
}
public Effects(GameScreen gameScreen)
{
this.gameScreen = gameScreen;
//Create List Models
ListModelEffects = new List<ModelStruct>();
DiccModelsEffects = new Dictionary<int, string>();
}
public RegisteredComponent(GameScreen i_GameScreen, int i_UpdateOrder = int.MaxValue)
: base(i_GameScreen.Game)
{
Screen = i_GameScreen;
UpdateOrder = i_UpdateOrder;
i_GameScreen.Add(this);
}
public Game(StartupScreen startScreen, GameScreen gameScreen)
{
this.startScreen = startScreen;
startScreen.GameStarted += OnStartupScreenGameStarted;
this.gameScreen = gameScreen;
gameScreen.Hide();
}
/// <summary>
/// ListView class constructor.
/// </summary>
/// <param name="elements">The number of visible elements in ListView.</param>
/// <param name="position">The top-left corner of the ListView.</param>
/// <param name="width">The ListView's width.</param>
/// <param name="height">The ListView's height.</param>
/// <param name="screen">Reference to the screen on which the ListView exists.</param>
public ListView(int elements, Point position, int width, int height, GameScreen screen)
: base(position, width, height, screen)
{
// up button initialization
up = new Button(new Point(base.Position.X + 10 + base.width, position.Y), 50, 50, base.screen);
this.elements = elements;
//listview button height
int buttonHeight = base.height / elements;
//down button initialization
down = new Button(new Point(base.Position.X + 10 + base.width, position.Y + buttonHeight * (elements - 1)), 50, 50, base.screen);
//arrow button callbacks
up.RegisterCallback(Up_OnClick);
down.RegisterCallback(Down_OnClick);
//minimum threshold check for listview buttons height
if (buttonHeight < 21)
{
buttonHeight = 21;
}
//initialize listview buttons
for (int i = 0; i < elements; i++)
{
Buttons.Add(new Button(new Point(base.position.X, base.position.Y + (i * buttonHeight)), base.width, buttonHeight, base.screen));
}
}
public override void Draw(GameScreen gameScreen, GameTime gameTime)
{
base.Draw(gameScreen, gameTime);
ScreenManager screenManager = gameScreen.ScreenManager;
SpriteBatch spriteBatch = screenManager.SpriteBatch;
if (Active)
{
Texture2D drawingTextue = ActiveTexture ??
screenManager.Game.Content.Load<Texture2D>("Images/GUI/CheckBoxX");
Vector2 textureSize = Size;
textureSize.X -= BorderThickness;
textureSize.Y -= BorderThickness;
Vector2 texturePosition = Position;
texturePosition.X += BorderThickness;
texturePosition.Y += BorderThickness;
var rectangle = new Rectangle((int) texturePosition.X, (int) texturePosition.Y,
(int) textureSize.X - BorderThickness,
(int) textureSize.Y - BorderThickness);
spriteBatch.Draw(drawingTextue, rectangle, FillColor);
}
}
public void changeScreens(string screenName)
{
newScreen = (GameScreen)Activator.CreateInstance(Type.GetType("SpaceFighter.Screens." + screenName));
currentScreen.UnloadContent();
currentScreen = newScreen;
currentScreen.Initialize();
currentScreen.LoadContent();
}
public override void Initialize(GameScreen parentScreen)
{
base.Initialize(parentScreen);
LevelScreen screen = (LevelScreen)parentScreen;
Behaviour = screen.BehaviourFactory.Create<AIControlledEntity>(
Settings.BehaviourName);
}
/// <summary>
/// menus
/// </summary>
private LoadingScreen(MenuSystem menuSystem, bool loadingIsSlow,
GameScreen[] screensToLoad)
{
this.loadingIsSlow = loadingIsSlow;
this.screensToLoad = screensToLoad;
TransitionOnTime = TimeSpan.FromSeconds(0.5);
}
/// <summary>
/// Initializes a new instance of the MenuEntry class
/// </summary>
/// <param name="screen">The screen to be drawn on.</param>
/// <param name="text">The text to be drawn.</param>
/// <param name="id">The id of this item.</param>
public MenuEntry(GameScreen screen, string text, int id)
{
this.Id = id;
this.Owner = screen;
this.State = States.Visible;
this.text = text;
this.Activate();
}
public Controleble(GameScreen game) : base(game)
{
}
public DoneButton(Menu i_ParentMenu, GameScreen i_SourceScreen) : base(i_ParentMenu, i_SourceScreen)
{
StaticText = k_DoneButtonStaticText;
}
public MenuItem(string i_Text, GameScreen i_GameScreen, Menu i_LinkedMenu = null, Action <MenuItem> i_CheckMosueOrKBState = null)
: this(new StrokeSpriteFont(i_Text, i_GameScreen), i_GameScreen, i_LinkedMenu, i_CheckMosueOrKBState)
{
}
public RotujciText(GameScreen game, string text, Vector2 pozice) : base(game, text, pozice)
{
Scale = new Vector2(0.5f, 0.5f);
}
public override bool Execute(bool admin)
{
switch (usecaseID)
{
case 0:
if (int.TryParse(GetArg(0), out int id))
{
var gameobject = Game.LocateWithGameID(id);
if (gameobject == null)
{
return(false);
}
if (!(gameobject is Equipable))
{
return(false);
}
var points = new List <GameObject>();
foreach (var part in Game.GetPlayer.LocateObjectsWithType <BodyPart>(false))
{
if (part.CanEquipItem(gameobject as Equipable))
{
if (part.EquipedItem == gameobject)
{
continue;
}
points.Add(part);
}
}
if (!Game.GetPlayer.IsInRangeOf(gameobject, Game.GetPlayer.InteractionRanges.grabRange))
{
GameScreen.PrintLine("\nYou are not close enough to equip this.");
return(false);
}
if (points.Count == 0)
{
GameScreen.PrintLine("\nYou have nowhere to equip that item.");
return(false);
}
Utilities.PromptSelection <GameObject>("Where do you want to equip this item?", points.ToArray(), (part, canceled) =>
{
if (canceled)
{
return;
}
var casted = part as BodyPart;
if (!casted.HasItemEquiped)
{
casted.EquipItem(gameobject as Equipable);
GameScreen.PrintLine($"\nEquiped <{Color.Cyan.ToInteger()},look at {gameobject.ID}>{gameobject.Name}@ to <{Color.Cyan.ToInteger()},look at {casted.ID}>{casted.Name}@");
return;
}
});
}
break;
}
return(false);
}
public StandardDebugMinimapImplementation(GameScreen scrn, float size, float pad) : base(scrn)
{
MaxSize = size;
Padding = pad;
}
public ShooterPlayer(string i_AssetName, GameScreen i_GameScreen, int i_UpdateOrder, int i_DrawOrder)
: base(i_AssetName, i_GameScreen, i_UpdateOrder, i_DrawOrder)
{
m_SoundManager = this.Game.Services.GetService(typeof(SoundManager)) as ISoundManager;
this.Gun = new Gun(k_MaxShotInMidAir, this, Bullet_Collided);
}
public ShooterPlayer(string i_AssetName, GameScreen i_GameScreen, int i_CallsOrder)
: this(i_AssetName, i_GameScreen, int.MaxValue, int.MaxValue)
{
}
public Rectangle(GameScreen i_GameScreen, string i_AssetName)
: base(i_AssetName, i_GameScreen)
{
}
public void Setup(GameScreen gameScreen)
{
_scoreLabel = gameScreen.ScoreLabel;
}
private void UseItem()
{
if (Player.TargetTile != Player.Tile)
{
return;
}
var facing = Player.GetFacingTile();
if (facing == null)
{
return;
}
if (facing.WorldObject != null && facing.WorldObject.CanUse)
{
ContentChest.Sounds[facing.WorldObject.UseSound].Play();
BeginProgress();
return;
}
var slot = UIManager.GetSelectedSlot();
if (slot.Item == null)
{
return;
}
var successful = false;
if (!slot.Item.Usable && slot.Item.RepairID != 0)
{
if (facing.WorldObject != null && facing.WorldObject.Repairable)
{
successful = facing.WorldObject.Repair(slot.Item.ItemName);
if (successful)
{
ContentChest.InsertSound.Play();
}
if (facing.WorldObject.Repaired && facing.WorldObject.EndsLevelOnRepair)
{
var timer = new Timer
{
Interval = 2000
};
ContentChest.WindMillSound.Play();
timer.Elapsed += (e, b) =>
{
timer.Stop();
if (GameScreen.LevelExists(_currentLevel + 1))
{
RequestScreenChange?.Invoke(new GameScreen(_currentLevel + 1));
}
else
{
RequestScreenChange?.Invoke(new FinishScreen());
}
};
timer.Start();
}
}
}
else
{
var protoType = ContentChest.ProtoTypes[slot.Item.FileName];
successful = protoType.CreateInstance(facing);
if (successful)
{
ContentChest.Sounds[protoType.PlaceSound].Play();
PowerUpNeighbours(facing);
AddWorldObject(facing.WorldObject);
}
}
if (!successful)
{
return;
}
slot.Remove(1);
}
public CreditsScreen(ScreenManager screenManager, GameScreen screen) : base(screenManager, screen)
{
}
private UIPage GetPageFromScreen(GameScreen screenToOpen)
{
return(m_AllPages.FirstOrDefault(x => x.screen == screenToOpen));
}
void _popup_Exited(object sender, EventArgs e)
{
_popup = null;
}
public ScriptEval(GameScreen gameScreen)
{
gScreen = gameScreen;
}
public NullState(GameScreen screen) : base(screen)
{
}
public void EmptySpotsTest()
{
GameScreen gs = new GameScreen();
Assert.AreEqual(gs.emptySpots, 9);
}
public ShootingSprite(GameScreen i_GameScreen, string i_AssetName)
: base(i_AssetName, i_GameScreen)
{
m_SerialNumber = Guid.NewGuid().ToString();
}
public MultipleSelectionMenuItem(Game i_Game, GameScreen i_Screen, string i_ItemTitle) : base(i_Game, i_Screen, i_ItemTitle)
{
}
public void DrawDiagonale(GameScreen screen)
{
screen.ScreenManager.SpriteBatch.Draw(texture, _position, null, Color.White, rotation, new Vector2(0, 0), 1, SpriteEffects.None, 0);
}
public RockCharacter(GameScreen gameScreen, LevelElements elements) : base(gameScreen, elements)
{
this._elements = elements;
}
public Background_Ingame(GameScreen _screen, int nombre_carre)
{
_nombre_carre = nombre_carre;
screen = _screen;
Initialization();
}
public Barrier(GameScreen i_GameScreen, string i_AssetName)
: base(i_AssetName, i_GameScreen)
{
m_CollisionServices = this.Game.Services.GetService(typeof(CollisionServices)) as CollisionServices;
m_HitSound = SoundFactory.CreateSound(this.GameScreen, SoundFactory.eSoundType.BarrierHit) as Sound;
}
public Background(Game i_Game, GameScreen i_Screen, string i_AssetName, int i_Opacity)
: base(i_Game, i_Screen, i_AssetName)
{
this.Alpha = i_Opacity;
this.DrawOrder = int.MinValue;
}
public Bullet(Vector2 i_Position, eDirection i_Diraction, GameStructure i_Game, GameScreen i_GameScreen) : base(k_AssteName, i_Game)
{
this.GameScreen = i_GameScreen;
m_Direction = i_Diraction;
Position = i_Position;
Velocity = new Vector2(0, 160);
m_HitBarricadeFinishPotision = new Vector2(-1, -1);
}
public LevelEditorHUD(GameScreen scrn) : base(scrn, Textures.HUDFontRegular)
{
AddElement(ModePanel = new LevelEditorModePanel());
AddElement(AttrPanel = new LevelEditorAttrPanel());
}
public TileMap(int width, int height, MapType type, GameScreen screen, TileMap oldMap)
{
this.GScreen = screen;
this.Width = width;
this.Height = height;
this.OldMap = oldMap;
// Init
numEntities = 0;
DeadEntities = new List <Entity>();
Map = new List <TileBlock>();
Entities = new List <Entity>();
GameObjects = new List <GameObject>();
Attacks = new List <Attack>();
HitTexts = new List <HitText>();
switch (type)
{
case MapType.Treasure:
setBackground(GameScreen.Backgrounds[BackgroundId.Cave1]);
for (int w = 0; w < width; w++)
{
for (int h = 0; h < height; h++)
{
if (h == height - 2 && w == 0)
{
Map.Add(TileBlock.IRON_DOOR.Clone().addEvent(TileBlockEvent.MapGoBack));
}
else if (h == 0 || h == height - 1)
{
Map.Add(TileBlock.STONE_WALL.Clone());
}
else if (w > 2 && w < width - 2 && h == height - 2 && ScreenManager.Rand.Next(width / 3) == 0)
{
Map.Add(TileBlock.CLOSED_CHEST.Clone());
}
else
{
Map.Add(TileBlock.NONE.Clone());
}
}
}
break;
case MapType.Hall:
default: // Hall Way
setBackground(GameScreen.Backgrounds[BackgroundId.Cave1]);
int specialCount = 0;
for (int w = 0; w < width; w++)
{
for (int h = 0; h < height; h++)
{
if (h == height - 2 && w == width - 1)
{
Map.Add(TileBlock.DOOR.Clone());
addRandomEntity(w * SPRITE_SIZE, h * SPRITE_SIZE, screen);
}
else if (h == 0 || h == height - 1)
{
Map.Add(TileBlock.STONE_WALL.Clone());
}
else if (w > 3 && w < width - 2 && h == height - 2 && ScreenManager.Rand.Next(25) == 0)
{
Map.Add(TileBlock.STONE_WALL.Clone());
}
else if (w > 3 && w < width - 2 && h == height - 2 && ScreenManager.Rand.Next(25) == 0)
{
Map.Add(TileBlock.STONE2_WALL.Clone());
}
else if (specialCount == 0 && w > 2 && h == height - 2 && ScreenManager.Rand.Next(150) == 0)
{
specialCount++;
Map.Add(TileBlock.HPPOOL.Clone());
}
else if (specialCount == 0 && w > 2 && h == height - 2 && ScreenManager.Rand.Next(200) == 0)
{
specialCount++;
Map.Add(TileBlock.IRON_DOOR.Clone().addEvent(TileBlockEvent.NewTreasureRoom));
}
else
{
Map.Add(TileBlock.NONE.Clone());
if (h == height - 2 && w > 4 && ScreenManager.Rand.Next(12) == 0)
{
addRandomEntity(w * SPRITE_SIZE, h * SPRITE_SIZE, screen);
}
}
}
}
break;
}
}
public SeedOptionsMenuScreen(ScreenManager screenManager, GameScreen passwordMenuScreen) : base(screenManager, passwordMenuScreen)
{
seedSelectionScreen = screenManager.FirstOrDefault <SeedSelectionMenuScreen>();
}
protected BaseBullet(string i_GraphicPath, GameScreen i_GameScreen)
: base(i_GraphicPath, i_GameScreen)
{
this.LeftWindowBounds += OnLeftBounds;
}
public Sprite(string i_AssetName, GameScreen i_GameScreen)
: this(i_AssetName, i_GameScreen, int.MaxValue)
{
}
