//reponse
public void Phase6_Recolte_Clic_Ouvriere(Pion ouvriere)
{
Debug.Log("Phase6_Recolte_Clic_Ouvriere");
Joueurs[0].PN += ouvriere.tuile.PN;
ouvriere.position = Pion.Position.nid;
Phase6_Recolte();
}
public Action grabPieces(Pion pion, Board board)
{
List <Vector2Int[]> steps = new List <Vector2Int[]>();
bool end = false;
Vector2Int position = pion.position;
Action ac = new Action(pion.position);
// tant qu'on peux prendre un pion on actualise la position du pion
// on ne peux pas sauter 2 fois sur le meme pions
while (!end)
{
for (int i = -1; i <= 1; i += 2)
{
for (int j = -1; j <= 1; j += 2)
{
int xTarget = position.x + i;
int yTarget = position.y + j;
int xDest = position.x + 2 * i;
int yDest = position.y + 2 * j;
if (xTarget < board.size && xTarget >= 0 && yTarget < board.size && yTarget >= 0 && board.grille[xTarget, yTarget] != null &&
xDest < board.size && xDest >= 0 && yDest < board.size && yDest >= 0 && board.grille[xDest, yDest] == null)
{
if (board.grille[xTarget, yTarget].GetType() == typeof(Pion) && board.grille[xTarget, yTarget].color != pion.color)
{
// on interdis de resauter sur un pion deja raflé
if (!ac.alreadyCaptured(new Vector2Int(xTarget, yTarget)))
{
Vector2Int[] step = { new Vector2Int(xDest, yDest), new Vector2Int(xTarget, yTarget) };
steps.Add(step);
}
}
}
}
}
// si plusieurs prise possibles pour cette rafle on en prend une aléatoire
// on banis la position
if (steps.Count != 0)
{
int rand = Random.Range(0, steps.Count);
Vector2Int[] move = steps.ToArray()[rand];
//on banis le pions sur lequel on a sauté et on actualise la position
ac.addCapture(move[1]);
position.x = move[0].x;
position.y = move[0].y;
// on vide les moveùent du premier saut
steps.Clear();
}
else
{
end = true;
}
}
ac.newPosition = position;
return(ac);
}
internal void Add(Pion PionActif, Pion cible)
{
//clic clone
if (cible.IsClone)
{
PionActif.direction = cible.direction;
PionActif.joueur.PM -= TuilesVoisine[PionActif.direction].PM;
ActualiserPions();
jeu.DesactiverDeplacement();
jeu.ControlConflit();
}
//ou ennemi
else
{
if (PionActif.tuile != cible.tuile)
{
PionActif.joueur.PM -= PM;
}
cible.position = Pion.Position.defausse;
PionActif.direction = 6;
PionActif.tuile = this;
jeu.VoleBonus(PionActif.joueur, cible.joueur);
}
}
/* Méthode sur le déplacement des Pions */
// Déplacement des pions avec objectif d'aller dans le camp adverse
public Action movePion(Pion p, Board board)
{
List <Action> availableMove = new List <Action>();
// On cherche les déplacements possibles
for (int i = -1; i <= 1; i += 2)
{
for (int j = -1; j <= 1; j += 2)
{
int x = p.position.x + i;
int y = p.position.y + j;
if (x < board.size && x >= 0 && y < board.size && y >= 0 && board.grille[x, y] == null)
{
availableMove.Add(new Action(p.position, new Vector2Int(x, y)));
}
}
}
// On cherche les prises qui font avancer
availableMove.AddRange(grabPieces(p, board));
//availableMove.Add(grabPieces(p, board));
// On filtre les mouvements disponiblent
p.refreshGoal(board);
List <Action> selectMove = p.goal.filter(board, availableMove);
// On choisie une avancé aleatoirement
if (selectMove.Count != 0)
{
return(selectMove.ToArray()[Random.Range(0, selectMove.Count)]);
}
//Pas de déplacement possible
return(new Action(p.position));
}
private bool checkCondition(int x, int y)
{
GameObject[] whitepion = GameObject.FindGameObjectsWithTag("whitepion");
GameObject[] redpion = GameObject.FindGameObjectsWithTag("redpion");
foreach (GameObject pion in whitepion)
{
Pion daman = pion.GetComponent("Pion") as Pion;
if (daman.CurrentX == x && daman.CurrentY == y)
{
return(false);
}
}
foreach (GameObject pion in redpion)
{
Pion daman = pion.GetComponent("Pion") as Pion;
if (daman.CurrentX == x && daman.CurrentY == y)
{
return(false);
}
}
return(true);
}
/* Méthode de la classe Board*/
// Remplie le tableau en plaçant les pieces au position d'innitialisation du jeu de Dames
public void initBoard()
{
grille = new Piece[10, 10];
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 10; j++)
{
if (i % 2 == 0 && j % 2 == 0)
{
if (i < 3)
{
grille[i, j] = new Pion(i, j, Color.White);
}
else if (i > 6)
{
grille[i, j] = new Pion(i, j, Color.Black);
}
}
else if (i % 2 == 1 && j % 2 == 1)
{
if (i < 3)
{
grille[i, j] = new Pion(i, j, Color.White);
}
else if (i > 6)
{
grille[i, j] = new Pion(i, j, Color.Black);
}
}
}
}
}
/// <summary>
/// Recuperer la liste des zones entourants un pion
/// </summary>
/// <param name="p"></param>
/// <param name="ep"></param>
/// <returns></returns>
public List <ZonePion> GetList(Pion p, List <ZonePion> ep)
{
List <ZonePion> zoneautour = new List <ZonePion>();
var co1 = ep.Single(c => c.X == (p.Position.X - 1) && c.Y == (p.Position.Y - 1));
var co2 = ep.Single(c => c.X == (p.Position.X - 1) && c.Y == (p.Position.Y));
var co3 = ep.Single(c => c.X == (p.Position.X - 1) && c.Y == (p.Position.Y + 1));
var co4 = ep.Single(c => c.X == (p.Position.X) && c.Y == (p.Position.Y - 1));
var co5 = ep.Single(c => c.X == (p.Position.X) && c.Y == (p.Position.Y + 1));
var co6 = ep.Single(c => c.X == (p.Position.X - 1) && c.Y == (p.Position.Y - 1));
var co7 = ep.Single(c => c.X == (p.Position.X) && c.Y == (p.Position.Y - 1));
try
{
var co8 = ep.Single(c => c.X == (p.Position.X + 1) && c.Y == (p.Position.Y - 1));
if (co8 != null)
{
zoneautour.Add(co8);
}
}
catch (Exception e) {
Console.WriteLine(e.Message);
}
zoneautour.Add(co1);
zoneautour.Add(co2);
zoneautour.Add(co3);
zoneautour.Add(co4);
zoneautour.Add(co5);
zoneautour.Add(co6);
zoneautour.Add(co7);
return(zoneautour);
}
public static void genererPions(int x, ConsoleColor color, Joueur joueur)
{
joueur.Color = color;
for (int i = 0; i < joueur.Pions.Length; i++)
{
int Row = x;
while (Row < x + 4)
{
int Column;
if (Row % 2 == 0)
{
Column = 0;
}
else
{
Column = 1;
}
do
{
joueur[i] = new Pion();
joueur[i].X = Row;
joueur[i].Y = Column;
Column += 2;
i++;
} while (Column <= 9);
Row += 1;
}
}
}
/// <summary>
/// Liste des pions environnants not used
/// </summary>
/// <param name="pion"></param>
/// <param name="listeDesZoneAuxAlentours"></param>
/// <returns></returns>
public List <ZonePion> ListePionsEnvironnants(Pion pion, List <ZonePion> listeDesZoneAuxAlentours)
{
List <ZonePion> listePionZoneEnvironnants = new List <ZonePion>();
if (pion.GetType().Equals(typeof(PionBlanc)))
{
foreach (var item in listeDesZoneAuxAlentours)
{
if (item.Occupe.Equals(true) && item.PionPosseder.Equals("PionNoir"))
{
listePionZoneEnvironnants.Add(item);
}
}
return(listePionZoneEnvironnants);
}
else
{
foreach (var item in listeDesZoneAuxAlentours)
{
if (item.Occupe.Equals(true) && item.PionPosseder.Equals("PionBlanc"))
{
listePionZoneEnvironnants.Add(item);
}
}
return(listePionZoneEnvironnants);
}
}
/* Méthode utilisé pour le résolveur*/
// Déplacement des pions avec objectif d'aller dans le camp adverse
public Action movePiece(Pion p, Board board)
{
List <Vector2Int> availableMove = new List <Vector2Int>();
// On cherche les déplacements possibles
for (int i = -1; i <= 1; i += 2)
{
for (int j = -1; j <= 1; j += 2)
{
int x = p.position.x + i;
int y = p.position.y + j;
if (x < board.size && x >= 0 && y < board.size && y >= 0 && board.grille[x, y] == null)
{
availableMove.Add(new Vector2Int(i, j));
}
}
}
Action ac = new Action(p.position);
// On prend un déplacement aleatoire si la piece ne peut pas se rapprocher du camps adverse
if (availableMove.Count != 0)
{
// Le pion ne peux pas se déplacer dans la direction du camp adverse
Vector2Int move = availableMove.ToArray()[Random.Range(0, availableMove.Count)];
ac.newPosition = new Vector2Int(move.x + p.position.x, move.y + p.position.y);
return(ac);
}
//Pas de déplacement possible
return(ac);
}
public PionViewModel(Pion model)
{
pion = model;
id = model.ID;
Karakter = model.Karakter;
Team = model.Team;
isMoveable = model.isMoveable;
}
/// <summary>
/// Plaatst een pion op het veld
/// </summary>
/// <param name="pion">Pion</param>
/// <returns>boolean als het gelukt is of niet</returns>
public override bool Plaats(Pion pion)
{
//staat al iets op
if (Pionnen.Any()) return false;
Pionnen.Add(pion);
return true;
}
private void MutaPionInCasuta(Pion pion, Casuta.UserControl.Casuta casuta, int pozitieCasuta)
{
ElibereazaCasuta(pion.CasutaCurenta);
pion.CasutaCurenta = casuta;
pion.CasutaCurenta.EsteOcupata = true;
pion.PozitiaCurenta = pozitieCasuta;
casuta.ImaginePion.BackgroundImage = pion.Imagine;
}
void ClearPionSelected()
{
foreach (GameObject arrow in activeArrow)
{
Destroy(arrow);
}
activeArrow.Clear();
pionSelectedBool = false;
selectedPion = null;
}
internal void Add(Pion PionActif)
{
if (GetProprietaire() != PionActif.joueur && terrain != Terrain.Nid)
{
PionActif.joueur.PM -= PM;
}
PionActif.direction = 6;
PionActif.tuile = this;
}
void TourSuivant()
{
bool joueurFini = pionCourant != Pion.Bobail;
if (joueurFini)
{
NouveauTour();
}
pionCourant = (Pion)mouvements.Dequeue();
}
public override Piece clone()
{
Pion clone = new Pion(position.x, position.y, color);
clone.life = this.life;
clone.id = this.id;
clone.goal = this.goal;
clone.predictions = this.predictions;
clone.standBy = this.standBy;
return(clone);
}
private void Ambuscade(Pion P)
{
Debug.Log("Ambuscade");
var cible = PionActif;
PionActif = P;
cible.position = Pion.Position.defausse;
PionActif.direction = 6;
PionActif.tuile = TConflit;
VoleBonus(PionActif.joueur, cible.joueur);
}
private void tekenPionnen()
{
foreach (Speler speler in spelerslijst)
{
Pion pion = speler.Pion;
Color color = Colors.White;
if (pion.Kleur.ToLower() == "rood")
{
color = Colors.Red;
}
else if (pion.Kleur.ToLower() == "blauw")
{
color = Colors.Blue;
}
else if (pion.Kleur.ToLower() == "groen")
{
color = Colors.Green;
}
else if (pion.Kleur.ToLower() == "paars")
{
color = Colors.Purple;
}
else if (pion.Kleur.ToLower() == "zwart")
{
color = Colors.Black;
}
else if (pion.Kleur.ToLower() == "geel")
{
color = Colors.Yellow;
}
Ellipse ellipse = new Ellipse();
ellipse.Width = pion.Grootte;
ellipse.Height = pion.Grootte;
ellipse.Fill = new SolidColorBrush(color);
ellipse.Margin = new Thickness(45, 850, 0, 0);
ellipse.VerticalAlignment = VerticalAlignment.Top;
ellipse.HorizontalAlignment = HorizontalAlignment.Left;
ellipse.Stroke = new SolidColorBrush(Colors.Black);
ellipse.StrokeThickness = 2;
testgrid.Children.Add(ellipse);
ellipses.Add(ellipse);
}
}
static void Main(string[] args)
{
var Flower1 = new Iris("Pink", 20);
var Flower2 = new Pion("Red", 22);
var Flower3 = new Rose("Pink", 78);
var Flower4 = new Iris("Blue", 23);
var Flower5 = new Scaevola("Blue", 67);
var Bouquet = new Bouquet(Flower1, Flower2, Flower3, Flower4, Flower5);
System.Console.WriteLine("Bouquet information");
Bouquet.BouqetInfo();
}
void Start()
{
plateau = new Plateau();
pionCourant = Pion.A;
joueurs = new Queue();
joueurs.Enqueue("A");
joueurs.Enqueue("B");
mouvements = new Queue();
mouvements.Enqueue(Pion.A);
mouvements.Enqueue(Pion.Bobail);
mouvements.Enqueue(Pion.B);
destinationsPossibles = new List <Coordonnees>();
PremierTour();
}
private bool CEstMonNid(Pion P, Tuile T)
{
Debug.Log("CestMonNid");
if (T.terrain == Tuile.Terrain.Nid)
{
foreach (Tuile t in Joueurs[0].Nids)
{
if (t == T)
{
return(true);
}
}
}
return(false);
}
public MainPage()
{
InitializeComponent();
ServiceReference1.Service1Client cl = new Service1Client();
cl.AddPionToGameSteCompleted += cl_AddPionToGameSteCompleted;
Pion p = new Pion();
p.Ijsschots = 33;
p.LobbyID = 5;
p.Row = 88;
p.SpelerID = 1;
p.Column = 4;
cl.AddPionToGameSteAsync(p);
}
public Plateau()
{
echiquier = new Piece[8, 8];
pN1 = new Pion(false);
pN2 = new Pion(false);
pN3 = new Pion(false);
pN4 = new Pion(false);
pN5 = new Pion(false);
pN6 = new Pion(false);
pN7 = new Pion(false);
pN8 = new Pion(false);
pB1 = new Pion(true);
pB2 = new Pion(true);
pB3 = new Pion(true);
pB4 = new Pion(true);
pB5 = new Pion(true);
pB6 = new Pion(true);
pB7 = new Pion(true);
pB8 = new Pion(true);
cavN1 = new Cavalier(false);
cavN2 = new Cavalier(false);
cavB1 = new Cavalier(true);
cavB2 = new Cavalier(true);
fouN1 = new Fou(false);
fouN2 = new Fou(false);
fouB1 = new Fou(true);
fouB2 = new Fou(true);
tourN1 = new Tour(false);
tourN2 = new Tour(false);
tourB1 = new Tour(true);
tourB2 = new Tour(true);
reineN = new Reine(false);
reineB = new Reine(true);
roiN = new Roi(false);
roiB = new Roi(true);
roiB.Couleur = true;
initierPlateau(echiquier);
}
/// <summary>
///
/// </summary>
/// <param name="pion"></param>
/// <param name="plateau"></param>
/// <returns></returns>
public Boolean PionADeplacer(Pion pion, PlateauDeJeuDame plateau)
{
var zoneEnvironnantDuPion = pion.Position.GetList(pion, plateau.getZoneForFree());
var zoneFree = zoneEnvironnantDuPion.Where(c => c.Occupe == false).ToList <ZonePion>();
int nbreZoneFree = zoneFree.Count;
//var zoneOfPlateau = plateau.getZoneForFree();
if (zoneFree != null && zoneFree.Count >= 2)
{
return(true);
}
else
{
return(false);
}
}
//Vierkanten maken van fotos in de bestanden
public void CreateVierkanten()
{
GeheugenVierkanten = new ObservableCollection <PionViewModel>();
for (int i = 0; i < 100; i++)
{
if (i == 42 || i == 43 || i == 46 || i == 47 || i == 52 || i == 53 || i == 56 || i == 57) //obstacles
{
var model = new Pion();
model.ID = i + 1;
model.FotoBron = Path.Combine(Environment.CurrentDirectory + "/images/13_Obstacle.png");
model.Karakter = "obstacle";
model.isMoveable = false;
var vierkant = new PionViewModel(model);
GeheugenVierkanten.Add(vierkant);
}
else
{
var model = new Pion();
model.ID = i + 1;
model.FotoBron = Path.Combine(Environment.CurrentDirectory + "/images/00_Null_Grey.png");
model.Karakter = "grey";
model.isMoveable = false;
var vierkant = new PionViewModel(model);
GeheugenVierkanten.Add(vierkant);
}
}
//Cooördinaten definiëren
int x = 0;
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 10; j++)
{
GeheugenVierkanten[x].X = i;
GeheugenVierkanten[x].Y = j;
x++;
}
}
NotifyPropertyChanged();
}
private int GetPozitieCurentaPion(Pion pion)
{
switch (_randJucator)
{
case 0:
return(pion.CasutaCurenta.PozitieRosu);
case 1:
return(pion.CasutaCurenta.PozitieVerde);
case 2:
return(pion.CasutaCurenta.PozitieGalben);
case 3:
return(pion.CasutaCurenta.PozitieAlbastru);
}
//throw new InvalidRandJucator;
return(0);
}
/* Méthode pour la génération des plateau possible */
//Liste les rafles de pion possible
public List <Action> grapPossible(Pion pion, Action current, Board board)
{
List <Action> available = new List <Action>();
for (int i = -1; i <= 1; i += 2)
{
for (int j = -1; j <= 1; j += 2)
{
if (j == i || j == -i)
{
int xTarget = current.newPosition.x + i;
int yTarget = current.newPosition.y + j;
int xDest = current.newPosition.x + 2 * i;
int yDest = current.newPosition.y + 2 * j;
if (board.isCorrect(new Vector2Int(xTarget, yTarget)) &&
board.isCorrect(new Vector2Int(xDest, yDest)) &&
board.grille[xTarget, yTarget] != null &&
board.grille[xDest, yDest] == null)
{
if (board.grille[xTarget, yTarget].GetType() == typeof(Pion) &&
board.grille[xTarget, yTarget].color != pion.color)
{
// on interdis de resauter sur un pion deja raflé
if (!current.alreadyCaptured(new Vector2Int(xTarget, yTarget)))
{
Action tmp = new Action(current);
tmp.newPosition = new Vector2Int(xDest, yDest);
tmp.addCapture(new Vector2Int(xTarget, yTarget));
available.Add(tmp); // On ajoute l'action contenant la capture dans la liste de actions possibles
}
}
}
}
}
}
// On regarde si on peut faire une nouvelle capture
foreach (Action ac in available.ToArray())
{
available.AddRange(grapPossible(pion, new Action(ac), board));
}
return(available);
}
public void AddClone(Pion P, int direction)
{
Transform transform = this.transform.Find("Gue0" + direction.ToString());
GameObject clone = Instantiate(Resources.Load <GameObject>("PrefabGueriere"), transform.position, transform.rotation);
Pion pionClone = clone.GetComponent <Pion>();
jeu.Clones.Add(pionClone);
pionClone.direction = direction;
pionClone.joueur = P.joueur;
pionClone.race = Pion.Race.Gueriere;
pionClone.effet = Pion.Effet.Transparant;
pionClone.name = "clone";
pionClone.IsClone = true;
pionClone.IsSelectable = true;
pionClone.tuile = this;
pionClone.jeu = jeu;
}
/// <summary>
/// plaats een pion op dit veld
/// </summary>
/// <param name="pion">Pion</param>
/// <returns>altijd ja</returns>
public override bool Plaats(Pion pion)
{
CheckBarricade();
//staat al iets op, sla deze pion
if (Pionnen.Any())
{
foreach (var vorig in Pionnen.ToArray())
{
var nieuwVeld = IsDorp ? (IVeld) pion.Speler.Spel.Bos : vorig.Speler.Startveld;
vorig.Verplaats(nieuwVeld);
}
Pionnen.Clear();
}
Pionnen.Add(pion);
return true;
}
//Retourne tous les déplacements que peut le pion fournie en paramètre
public List <Action> getAvalaibleMove(Pion p, Board board)
{
List <Action> availableMove = new List <Action>();
// On cherche les déplacements possibles
for (int i = -1; i <= 1; i += 2)
{
for (int j = -1; j <= 1; j += 2)
{
int x = p.position.x + i;
int y = p.position.y + j;
if (x < board.size && x >= 0 && y < board.size && y >= 0 && board.grille[x, y] == null)
{
availableMove.Add(new Action(p.position, new Vector2Int(x, y)));
}
}
}
availableMove.Add(new Action(p.position));
// On cherche les prises qui font avancer
availableMove.AddRange(grapPossible(p, new Action(p.position), board));
return(availableMove);
}
/// <summary>
/// Recuperer la liste des zones entourants un pion
/// </summary>
/// <param name="p"></param>
/// <param name="ep"></param>
/// <returns></returns>
public List <ZonePion> GetList(Pion p, List <ZonePion> ep)
{
List <ZonePion> zoneautour = new List <ZonePion>();
var co1 = ep.Where(c => c.X == (p.Position.X - 1) && c.Y == (p.Position.Y - 1)).Single();
var co2 = ep.Where(c => c.X == (p.Position.X - 1) && c.Y == (p.Position.Y)).Single();
var co3 = ep.Where(c => c.X == (p.Position.X - 1) && c.Y == (p.Position.Y + 1)).Single();
var co4 = ep.Where(c => c.X == (p.Position.X) && c.Y == (p.Position.Y - 1)).Single();
var co5 = ep.Where(c => c.X == (p.Position.X) && c.Y == (p.Position.Y + 1)).Single();
var co6 = ep.Where(c => c.X == (p.Position.X - 1) && c.Y == (p.Position.Y - 1)).Single();
var co7 = ep.Where(c => c.X == (p.Position.X) && c.Y == (p.Position.Y - 1)).Single();
var co8 = ep.Where(c => c.X == (p.Position.X + 1) && c.Y == (p.Position.Y - 1)).Single();
zoneautour.Add(co1);
zoneautour.Add(co2);
zoneautour.Add(co3);
zoneautour.Add(co4);
zoneautour.Add(co5);
zoneautour.Add(co6);
zoneautour.Add(co7);
zoneautour.Add(co8);
return(zoneautour);
}
/// <summary>
/// Plaats pion op veld
/// </summary>
/// <param name="pion">Pion om er op te zetten</param>
/// <returns>ja of nee</returns>
public override bool Plaats(Pion pion)
{
Pionnen.Add(pion);
return true;
}
/// <summary>
/// Plaats een pion in het bos
/// </summary>
/// <param name="pion">de pion</param>
/// <returns>altijd true</returns>
public bool Plaats(Pion pion)
{
//meerdere pionnen op dit veld toegestaan
Pionnen.Add(pion);
return true;
}
public bool MagPion(Pion pion)
{
return true;
}
public override bool MagPion(Pion pion)
{
return false;
}
/// <summary>
/// Geeft aan of die leeg is of niet.
/// </summary>
/// <param name="pion">Pion</param>
/// <returns>ja of nee</returns>
public override bool MagPion(Pion pion)
{
return Pionnen.Count == 0;
}
public abstract bool Plaats(Pion pion);
/// <summary>
/// Kijkt of er een pion op staat of er een pion geslagen kan worden
/// </summary>
/// <param name="pion">Pion</param>
/// <returns>ja of nee</returns>
public virtual bool MagPion(Pion pion)
{
return Pionnen.Count == 0 || !Pionnen.Select(other => other.Speler).Contains(pion.Speler);
}
/// <summary>
/// Plaats een pion op dit veld
/// </summary>
/// <param name="pion">de pion</param>
/// <returns>een gewonnenexception</returns>
public override bool Plaats(Pion pion)
{
Pionnen.Add(pion);
throw new GewonnenException(pion.Speler);
}
