public void Create(ClassicGame game)
{
var gamdat = new Burntime.Data.BurnGfx.Save.SaveGame();
gamdat.Open();
LogicFactory.SetParameter("gamdat", gamdat);
}
public bool Process(Player player)
{
ClassicGame world = (ClassicGame)container.Root;
// check all locations
for (int i = 0; i < world.World.Locations.Count; i++)
{
Location l = world.World.Locations[i];
// check for neighbored city
bool neighborOfCity = false;
for (int j = 0; j < l.Neighbors.Count; j++)
{
if (l.Neighbors[j].IsCity)
{
neighborOfCity = true;
break;
}
}
if (neighborOfCity)
{
// if the location is not possesed by the player, then he hasn't won yet
if (l.Player != player)
{
return(false);
}
}
}
// all city neighbors conquered, victory
return(true);
}
protected virtual ItemType GetNextItem()
{
List <string> itemTypes = new List <string>();
// list up all item types not yet in inventory
foreach (TraderItemRefreshItem item in itemRefreshs)
{
if (!Items.Contains(item.Type.Object.ID))
{
itemTypes.Add(item.Type.Object.ID);
}
}
ClassicGame game = container.Root as ClassicGame;
// no more item types to choose from
if (itemTypes.Count == 0)
{
return(null);
}
// only one item type, skip randomizer
else if (itemTypes.Count == 1)
{
return(game.ItemTypes[itemTypes[0]]);
}
// get random item type
return(game.ItemTypes[itemTypes[rnd.Next() % itemTypes.Count]]);
}
public void checkmate_white_win_game()
{
var game = new ClassicGame();
Assert.AreEqual(game.GameState, GameState.NotStarted);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(4, 1), new Position(4, 3)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(5, 6), new Position(5, 4)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(5, 1), new Position(5, 3)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(6, 6), new Position(6, 4)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(3, 0), new Position(7, 4)));
Assert.AreEqual(game.GameState, GameState.Ended);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.Checkmated);
}
void LoadTrader(ClassicGame game, Burntime.Data.BurnGfx.Save.SaveGame gamdat)
{
ConfigFile traderItems = new ConfigFile();
traderItems.Open("trader.txt");
for (int i = 0; i < gamdat.Locations.Length; i++)
{
if (gamdat.Locations[i].IsCity)
{
Trader trader = (Trader)game.World.AllCharacters[gamdat.Locations[i].TraderId];
game.World.Locations[i].LocalTrader = trader;
game.World.Traders += trader;
}
}
for (int i = 0; i < game.World.AllCharacters.Count; i++)
{
if (game.World.AllCharacters[i] is Trader)
{
Trader trader = (Trader)game.World.AllCharacters[i];
string[] items = traderItems["trader"].GetStrings(trader.TraderId.ToString());
foreach (string item in items)
{
trader.AddRefreshItem(game.ItemTypes[item], 1);
}
trader.RandomizeInventory();
}
}
}
public void white_left_castle_correct()
{
var game = new ClassicGame();
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(1, 0), new Position(0, 2)));
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(2, 6), new Position(2, 4)));
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(2, 1), new Position(2, 3)));
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(3, 6), new Position(3, 4)));
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(3, 1), new Position(3, 3)));
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(1, 6), new Position(1, 4)));
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(2, 0), new Position(3, 1)));
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(0, 6), new Position(0, 4)));
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(3, 0), new Position(2, 1)));
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(4, 6), new Position(4, 4)));
/*-----------------------------------------------------------------------------------*/
var castleMove = new BoardMove(new Position(4, 0), new Position(2, 0));
var leftRook = game.Board.GetPiece(new Position(0, 0));
ChessAssert.IsMoveCorrect(game, castleMove);
Assert.IsNull(game.Board.GetPiece(new Position(0, 0)));
Assert.AreSame(leftRook, game.Board.GetPiece(new Position(3, 0)));
Assert.AreEqual(leftRook.Position, new Position(3, 0));
}
public override void OnUpdate(float Elapsed)
{
BurntimeClassic classic = app as BurntimeClassic;
classic.ActiveClient = GameClient.NoClient;
news = classic.GameServer.PopNews();
if (news != null)
{
if (news is DeathNews)
{
app.SceneManager.SetScene("DeathScene", (news as DeathNews).Name);
}
else if (news is VictoryNews)
{
app.SceneManager.SetScene("VictoryScene", (news as VictoryNews));
}
}
else
{
bool gameOver = true;
for (int i = 0; i < classic.Clients.Count; i++)
{
if (classic.Clients[i].IsReady)
{
classic.ActiveClient = classic.Clients[i];
}
gameOver &= (classic.Clients[i].IsGameOver || classic.Clients[i].State == GameClientState.Dead);
}
if (gameOver)
{
app.Server.Stop();
app.SceneManager.SetScene("MenuScene");
}
else if (classic.ActiveClient.IsReady)
{
ClassicGame game = app.GameState as ClassicGame;
game.World.ActivePlayer = classic.ActiveClient.Player;
if (!game.World.ActivePlayerObj.OnMainMap)
{
app.SceneManager.SetScene("LocationScene");
}
else
{
app.SceneManager.SetScene("MapScene");
}
}
if (timer < WAIT_DISPLAY_DELAY)
{
timer += Elapsed;
}
}
}
public override void Die()
{
// drop meat
ClassicGame root = (ClassicGame)Container.Root;
Location.Items.DropAt(root.ItemTypes.Generate("item_meat"), Position);
base.Die();
}
public void pawns_move_correct()
{
var game = new ClassicGame();
for (int x = 0; x < game.Board.Width; x++)
{
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(x, 1), new Position(x, 2)));
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(x, 6), new Position(x, 5)));
}
}
void Start() {
_instance = this;
bf = BattlefieldScript.Instance;
//bfc = bf.bf;
su = Submarine.Instance;
sh = Ship.Instance;
//la = LanguageScript.Instance;
mo = move.Instance;
reward = new Reward (false, 2);
}
void LoadProductions(ClassicGame game, Burntime.Data.BurnGfx.Save.SaveGame gamdat)
{
ConfigFile file = new ConfigFile();
file.Open("production.txt");
ConfigSection[] sections = file.GetAllSections();
foreach (ConfigSection section in sections)
{
if (section.Name == "")
{
continue;
}
if (!game.ItemTypes.Contains(section.Name))
{
Log.Warning("LoadProductions: item " + section.Name + " not found.");
continue;
}
string produce = section.GetString("produce");
if (!game.ItemTypes.Contains(produce))
{
Log.Warning("LoadProductions: item " + produce + " not found.");
continue;
}
Production p = container.Create <Production>();
p.MaxCombination = section.GetInt("maxcombination");
p.ProductionPerDay = section.GetInts("amount");
p.ProductionPerDay2Person = section.GetInts("amount2");
if (p.ProductionPerDay2Person.Length == 0)
{
p.ProductionPerDay2Person = p.ProductionPerDay;
}
p.Produce = game.ItemTypes[produce];
p.ID = game.Productions.Count;
game.ItemTypes[section.Name].Production = p;
foreach (string alternative in section.GetStrings("alternatives"))
{
if (!game.ItemTypes.Contains(alternative))
{
Log.Warning("LoadProductions: item " + section.Name + " not found.");
continue;
}
game.ItemTypes[alternative].Production = p;
}
game.Productions.Add(p);
}
}
public static void IsMoveCorrect(ClassicGame game, BoardMove move)
{
var pieceAtCurrectPosition = game.Board.GetPiece(move.Current);
var currentPlayer = game.CurrentPlayerColor;
Assert.IsTrue(game.CanPerformMove(move));
game.TryPerformMove(move);
Assert.IsNull(game.Board.GetPiece(move.Current));
Assert.AreSame(pieceAtCurrectPosition, game.Board.GetPiece(move.Destination));
Assert.AreEqual(game.Board.GetPiece(move.Destination).Position, move.Destination);
Assert.AreNotEqual(game.CurrentPlayerColor, currentPlayer);
}
public void all_piece_get_move_set_not_throwing_error_and_not_null()
{
var game = new ClassicGame();
foreach (var piece in game.Board)
{
if (piece != null)
{
Assert.IsNotNull(piece.MoveSet);
}
}
}
public override void Die()
{
// drop special item
ClassicGame root = (ClassicGame)Container.Root;
if ((Burntime.Platform.Math.Random.Next() % 100) < 3)
{
// drop cookies instead at a chance of 3%
string[] cookies = root.ItemTypes.GetTypesWithClass(new string[] { "cookie" }, new string[0]);
Location.Items.DropAt(root.ItemTypes.Generate(cookies[Burntime.Platform.Math.Random.Next() % cookies.Length]), Position);
}
base.Die();
}
void SetStartInventory(ClassicGame game)
{
foreach (Player player in game.World.Players)
{
// clear
player.Character.Items.Clear();
// add items
string[] items = settings.StartItems;
foreach (string item in items)
{
player.Character.Items.Add(game.ItemTypes[item].Generate());
}
}
}
public void Hire(Player boss)
{
Location = null;
boss.Group.Add(this);
Player = boss;
if (SetBodyId != -1 && boss.BodyColorSet != -1)
{
Body = Helper.GetCharacterBody(SetBodyId, boss.BodyColorSet);
}
Item hireItem = null;
for (int i = 0; hireItem == null && i < HireItems.Count; i++)
{
hireItem = boss.Character.Items.Find(HireItems[i]);
}
boss.Character.Items.Remove(hireItem);
Mind = container.Create <AI.FellowerMind>(new object[] { this, boss.Character });
Path = container.Create <PathFinding.ComplexPath>();
Path.MoveTo = Position;
ClassicGame classic = (ClassicGame)container.Root;
int difficulty = 2 - classic.World.Difficulty; // set inverted difficulty (0 hard, 1 normal, 2 easy)
// if hire item is food or water then use it
if (hireItem.FoodValue != 0)
{
Food = System.Math.Min(MaxFood, Food + hireItem.FoodValue);
}
if (hireItem.WaterValue != 0)
{
Water = System.Math.Min(MaxWater, Water + hireItem.WaterValue);
}
// prevent 0 food / 0 water situation depending on difficulty setting
if (Food < difficulty)
{
Food = difficulty;
}
if (Water < difficulty)
{
Water = difficulty;
}
}
public void RenderOverlay(RenderTarget target, Vector2 offset, Vector2 size)
{
if (map != null)
{
ClassicGame game = (ClassicGame)app.GameState;
for (int i = 0; i < 4; i++)
{
Player p = game.World.Players[i];
if (p.IsDead)
{
continue;
}
int[] icons = new int[] { 17, 16, 19, 18 };
Sprite sprite = app.ResourceManager.GetImage("syst.raw?" + icons[p.IconID]);
Vector2 pos = new Vector2();
if (p.IsTraveling)
{
Vector2 start = map.Entrances[p.Location].Area.Center + offset;
Vector2 end = map.Entrances[p.Destination].Area.Center + offset;
pos = end + ((start - end) * p.RemainingDays / p.TravelDays);
}
else
{
pos.x = map.Entrances[p.Location].Area.Position.x + offset.x;
pos.y = map.Entrances[p.Location].Area.Center.y + offset.y;
for (int j = 0; j < i; j++)
{
if (game.World.Players[j].Location == p.Location)
{
pos += 3;
}
}
}
target.DrawSprite(pos + new Vector2(-sprite.Width / 2, -15), sprite);
}
}
}
public void white_right_castle_correct()
{
var game = new ClassicGame();
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(6, 0), new Position(7, 2)));
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(5, 6), new Position(5, 4)));
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(6, 1), new Position(6, 2)));
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(6, 6), new Position(6, 4)));
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(5, 0), new Position(6, 1)));
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(7, 6), new Position(7, 4)));
/*-----------------------------------------------------------------------------------*/
var castleMove = new BoardMove(new Position(4, 0), new Position(6, 0));
var rightRook = game.Board.GetPiece(new Position(7, 0));
ChessAssert.IsMoveCorrect(game, castleMove);
Assert.IsNull(game.Board.GetPiece(new Position(7, 0)));
Assert.AreSame(rightRook, game.Board.GetPiece(new Position(5, 0)));
Assert.AreEqual(rightRook.Position, new Position(5, 0));
}
public virtual void Die()
{
// drop items
Location.Items.DropPosition = Position;
Items.MoveTo(Location.Items);
// remove from player empire
if (Player != null && Player.Character != this)
{
Dismiss();
}
// reset
health = 0;
ani = new Burntime.Platform.Graphics.SpriteAnimation(4);
ani.Endless = false;
// schedule for respawn
ClassicGame classic = (ClassicGame)container.Root;
classic.World.Respawn.Object.Respawn(this);
}
private void RecalculateExperience()
{
int count = 0;
ClassicGame game = container.Root as ClassicGame;
foreach (Location location in game.World.Locations)
{
if (location.Player == this)
{
count++;
}
}
Character.Experience = count * 3 + BaseExperience;
// limit experience to 99%
if (Character.Experience > 99)
{
Character.Experience = 99;
}
}
public void black_right_castle_correct()
{
var game = new ClassicGame();
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(0, 1), new Position(0, 3)));
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(6, 7), new Position(7, 5)));
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(1, 1), new Position(1, 3)));
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(6, 6), new Position(6, 5)));
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(2, 1), new Position(2, 3)));
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(5, 7), new Position(6, 6)));
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(3, 1), new Position(3, 3)));
/*-----------------------------------------------------------------------------------*/
var castleMove = new BoardMove(new Position(4, 7), new Position(6, 7));
var rightRook = game.Board.GetPiece(new Position(7, 7));
ChessAssert.IsMoveCorrect(game, castleMove);
Assert.IsNull(game.Board.GetPiece(new Position(7, 7)));
Assert.AreSame(rightRook, game.Board.GetPiece(new Position(5, 7)));
Assert.AreEqual(rightRook.Position, new Position(5, 7));
}
void SetStartLocations(ClassicGame game)
{
// copy start locations since we mark used ones with -1
int[] loc = (int[])settings.StartLocations.Clone();
foreach (Player player in game.World.Players)
{
// find free location
int start;
do
{
int index = Burntime.Platform.Math.Random.Next(0, loc.Length);
start = loc[index];
loc[index] = -1;
} while (start == -1);
// set location
player.Location = game.World.Locations[start];
player.Character.Position = new Vector2(game.World.Locations[start].EntryPoint);
player.Character.Path.MoveTo = new Vector2(game.World.Locations[start].EntryPoint);
}
}
public override void OnUpdate(float Elapsed)
{
position += border * Elapsed * scrollSpeed;
if (border != Vector2f.Zero && Scroll != null)
{
Scroll.Invoke(this, new MapScrollArgs(position));
}
position.ThresholdGT(0);
position.ThresholdLT(Boundings.Size - map.TileSize * map.Size);
if (handler != null)
{
ClassicGame game = app.GameState as ClassicGame;
game.World.ActiveLocationObj.Hover = null;
foreach (Maps.IMapViewOverlay overlay in overlays)
{
overlay.MouseMoveOverlay(mousePosition);
overlay.UpdateOverlay(game, Elapsed);
}
if (entrance != -1)
{
if (game.MainMapView)
{
Burntime.Data.BurnGfx.MapEntrance e = game.World.Map.Entrances[entrance];
game.World.ActiveLocationObj.Hover = new MapViewHoverInfo(app.ResourceManager.GetString(e.TitleId), e.Area.Center, new PixelColor(212, 212, 212));
}
else if (entrance < game.World.ActiveLocationObj.Rooms.Count)
{
game.World.ActiveLocationObj.Hover = new MapViewHoverInfo(game.World.ActiveLocationObj.Rooms[entrance], app.ResourceManager, new PixelColor(212, 212, 212));
}
}
}
particles.Update(Elapsed);
}
public override void Update(float elapsed)
{
base.Update(elapsed);
if (IsDead)
{
return;
}
timer += elapsed;
if (timer >= 60)
{
ClassicGame root = (ClassicGame)Container.Root;
if ((Burntime.Platform.Math.Random.Next() % 100) == 0)
{
// drop dogshit at a change of 1% per minute
Location.Items.DropAt(root.ItemTypes.Generate("item_dogshit"), Position);
}
timer = 0;
}
}
public void Create(ClassicGame game)
{
var resources = LogicFactory.GetParameter <ResourceManager>("resource");
var container = game.Container;
// for the time being only add to existing locations
for (int i = game.World.Locations.Count + 1; i < game.World.Map.Entrances.Length + 1; i++)
{
ConfigFile cfg = new ConfigFile();
cfg.Open("maps/mat_" + i.ToString("D3") + ".txt");
Location loc = container.Create <Location>();
loc.Id = i - 1;
loc.Source.Water = cfg[""].GetInt("water_refresh");
loc.Source.Reserve = loc.Source.Water;
loc.Source.Capacity = cfg[""].GetInt("water_capacity");
loc.Production = null; // city.Producing == -1 ? null : game.Productions[city.Producing];
loc.AvailableProducts = new int[] { }; // (int[])city.Production.Clone();
loc.Danger = resources.GetData(cfg[""].GetString("danger")) as Danger;
loc.IsCity = cfg[""].GetBool("city");
loc.EntryPoint = cfg[""].GetVector2("entry_point");
loc.Ways = new int[] { };
loc.NeighborIds = cfg[""].GetInts("ways");
loc.WayLengths = cfg[""].GetInts("way_lengths");
// in case of a burngfx location we need to add new ways
updateBurngfxLocation(loc.Id, loc.NeighborIds, loc.WayLengths, game.World.Locations);
loc.Map = container.Create <Map>(new object[] { "maps/mat_" + i.ToString("D3") + ".burnmap??4" });
loc.Rooms = container.CreateLinkList <Room>();
for (int j = 0; j < loc.Map.Entrances.Length; j++)
{
RoomType type = loc.Map.Entrances[j].RoomType;
Room room = container.Create <Room>();
room.IsWaterSource = type == RoomType.WaterSource;
if (type != RoomType.Normal && type != RoomType.Rope && type != RoomType.WaterSource)
{
room.Items.MaxCount = 0;
}
else
{
room.Items.MaxCount = room.IsWaterSource ? 8 : 32;
}
room.EntryCondition.MaxDistanceOnMap = 15;
if (loc.Map.Entrances[j].RoomType == RoomType.Rope)
{
room.EntryCondition.MaxDistanceOnMap = 75;
room.EntryCondition.RequiredItem = game.ItemTypes["item_rope"];
}
room.EntryCondition.RegionOnMap = loc.Map.Entrances[j].Area;
room.EntryCondition.HasRegionOnMap = true;
room.TitleId = loc.Map.Entrances[j].TitleId;
loc.Rooms += room;
}
game.World.Locations += loc;
i++;
}
// update neighbor links
foreach (Location location in game.World.Locations)
{
for (int k = 0; k < location.NeighborIds.Length; k++)
{
if (location.NeighborIds[k] != -1)
{
var neighbor = game.World.Locations[location.NeighborIds[k]];
// only add if not already in the list
if (!location.Neighbors.Contains(neighbor))
{
location.Neighbors.Add(neighbor);
}
}
}
}
}
public override void OnUpdate(float elapsed)
{
ClassicGame game = app.GameState as ClassicGame;
game.World.Update(elapsed);
}
public void UpdateOverlay(WorldState world, float elapsed)
{
state = world as ClassicGame;
ani.Update(elapsed);
}
public void Create(ClassicGame game)
{
var gamdat = LogicFactory.GetParameter <Burntime.Data.BurnGfx.Save.SaveGame>("gamdat");
if (gamdat == null)
{
return;
}
var container = game.Container;
for (int i = 1; i <= gamdat.Locations.Length; i++)
{
var city = gamdat.Locations[i - 1];
Location loc = container.Create <Location>();
loc.Id = game.World.Locations.Count;
loc.Source.Water = city.WaterSource;
loc.Source.Reserve = city.Water;
loc.Source.Capacity = city.WaterCapacity;
loc.Production = city.Producing == -1 ? null : game.Productions[city.Producing];
loc.AvailableProducts = (int[])city.Production.Clone();
if (city.Danger != 0)
{
loc.Danger = Danger.Instance((city.Danger == 3) ? "radiation" : "gas", city.DangerAmount);
}
loc.IsCity = city.IsCity;
loc.EntryPoint = city.EntryPoint;
loc.Ways = (from x in city.Ways where x != -1 select x).ToArray();
loc.WayLengths = (from x in city.WayLengths where x > 0 select x).ToArray();
loc.NeighborIds = (from x in city.Neighbors where x != -1 select x).ToArray();
loc.Map = container.Create <Map>(new object[] { "maps/mat_" + i.ToString("D3") + ".burnmap??4" });
loc.Rooms = container.CreateLinkList <Room>();
for (int j = 0; j < loc.Map.Entrances.Length; j++)
{
RoomType type = loc.Map.Entrances[j].RoomType;
Room room = container.Create <Room>();
room.IsWaterSource = type == RoomType.WaterSource;
if (type != RoomType.Normal && type != RoomType.Rope && type != RoomType.WaterSource)
{
room.Items.MaxCount = 0;
}
else
{
room.Items.MaxCount = room.IsWaterSource ? 8 : 32;
}
room.EntryCondition.MaxDistanceOnMap = 15;
if (loc.Map.Entrances[j].RoomType == RoomType.Rope)
{
room.EntryCondition.MaxDistanceOnMap = 75;
room.EntryCondition.RequiredItem = game.ItemTypes["item_rope"];
}
room.EntryCondition.RegionOnMap = loc.Map.Entrances[j].Area;
room.EntryCondition.HasRegionOnMap = true;
room.TitleId = loc.Map.Entrances[j].TitleId;
loc.Rooms += room;
}
game.World.Locations += loc;
}
foreach (Location location in game.World.Locations)
{
foreach (int id in location.NeighborIds)
{
location.Neighbors.Add(game.World.Locations[id]);
}
}
}
public void white_stalemate_all_pieces_on_board_full_game()
{
var game = new ClassicGame();
Assert.AreEqual(game.GameState, GameState.NotStarted);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(3, 1), new Position(3, 3)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(3, 6), new Position(3, 5)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(3, 0), new Position(3, 1)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(4, 6), new Position(4, 4)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(0, 1), new Position(0, 3)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(4, 4), new Position(4, 3)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(3, 1), new Position(5, 3)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(5, 6), new Position(5, 4)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(7, 1), new Position(7, 2)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(5, 7), new Position(4, 6)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(5, 3), new Position(7, 1)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(2, 7), new Position(4, 5)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(0, 0), new Position(0, 2)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(2, 6), new Position(2, 4)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(0, 2), new Position(6, 2)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(3, 7), new Position(0, 4)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.Checked);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(1, 0), new Position(3, 1)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(4, 6), new Position(7, 3)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(5, 1), new Position(5, 2)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(4, 5), new Position(1, 2)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(3, 3), new Position(3, 4)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(4, 3), new Position(4, 2)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(2, 1), new Position(2, 3)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
/*----------------------------------------------------------------------------------*/
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(5, 4), new Position(5, 3)));
Assert.AreEqual(game.GameState, GameState.Ended);
Assert.AreEqual(game.WhiteKing.KingState, KingState.Stalemated);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
}
public override void OnRender(RenderTarget Target)
{
base.OnRender(Target);
Target.Layer += 2;
if (Map == null)
{
return;
}
List <int> renderWays = new List <int>();
Vector2 offset = (Vector2)ScrollPosition;
ClassicGame game = (ClassicGame)app.GameState;
for (int i = 0; i < 4; i++)
{
Player p = game.World.Players[i];
if (p.IsDead)
{
continue;
}
if (p.IsTraveling)
{
for (int j = 0; j < p.Location.Neighbors.Count; j++)
{
if (p.Location.Neighbors[j] == p.Destination)
{
renderWays.Add(p.Location.Ways[j]);
}
}
}
}
int active = game.World.ActivePlayer;
if (active != -1)
{
foreach (int way in Ways.Cross[game.World.ActivePlayerObj.Location].Ways)
{
Player p = game.World.ActivePlayerObj;
// get start point and end point
Location start = p.Location;
Location end = game.World.Locations[Ways.Ways[way].End];
if (end == start)
{
end = game.World.Locations[Ways.Ways[way].Start];
}
// check travel allowance
if (p.CanTravel(start, end))
{
renderWays.Add(way);
}
}
}
foreach (int way in renderWays)
{
if (Ways.Ways[way].Images.Length > 0)
{
Vector2 pos = Ways.Ways[way].Position + offset;
foreach (Sprite sprite in Ways.Ways[way].Images)
{
Target.DrawSprite(pos, sprite);
pos.x += 32;
}
}
}
}
public void black_stalemate_full_game()
{
var game = new ClassicGame();
Assert.AreEqual(game.GameState, GameState.NotStarted);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(4, 1), new Position(4, 2)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(0, 6), new Position(0, 4)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(3, 0), new Position(7, 4)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(0, 7), new Position(0, 5)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(7, 4), new Position(0, 4)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(7, 6), new Position(7, 4)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(7, 1), new Position(7, 3)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(0, 5), new Position(7, 5)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(0, 4), new Position(2, 6)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(5, 6), new Position(5, 5)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(2, 6), new Position(3, 6)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.Checked);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(4, 7), new Position(5, 6)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(3, 6), new Position(1, 6)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(3, 7), new Position(3, 2)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(1, 6), new Position(1, 7)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(3, 2), new Position(7, 6)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(1, 7), new Position(2, 7)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(5, 6), new Position(6, 5)));
Assert.AreEqual(game.GameState, GameState.InProgress);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.None);
/*-----------------------------------------------------------------------------------*/
ChessAssert.IsMoveCorrect(game, new BoardMove(new Position(2, 7), new Position(4, 5)));
Assert.AreEqual(game.GameState, GameState.Ended);
Assert.AreEqual(game.WhiteKing.KingState, KingState.None);
Assert.AreEqual(game.BlackKing.KingState, KingState.Stalemated);
}
