Merge branch 'master' of https://codefirst.iut.uca.fr/git/jeremy.mouyon/sae201_qwirkle

Qwirkle/QwirkleClassLibrary/Game.cs

@@ -363,54 +363,119 @@ namespace QwirkleClassLibrary
             return false;
         } 
 
-        public int GetPlayerScore(Player player, List<Cell> cellsPlayed, Board board)
+        // public int GetPlayerScore(Player player, List<Cell> cellsPlayed, Board b)
+        // {
+        //     // Compte le nombre de tuiles et ajoute ce nombre au score
+        //     int score = cellsPlayed.Count;
+        //
+        //     // Check les lignes / colonnes adjacentes aux tuiles placées
+        //     for(int i= 0; i < cellsPlayed.Count; i++)
+        //     {
+        //         // A chaque tour, crée la liste des 4 cellules adjacentes à la cellule sélectionnée
+        //         var surroundingCells = new[]
+        //         {
+        //             b.GetCell(cellsPlayed[i].GetX + 1, cellsPlayed[i].GetY),
+        //             b.GetCell(cellsPlayed[i].GetX - 1, cellsPlayed[i].GetY),
+        //             b.GetCell(cellsPlayed[i].GetX, cellsPlayed[i].GetY + 1),
+        //             b.GetCell(cellsPlayed[i].GetX, cellsPlayed[i].GetY - 1)
+        //         };
+        //
+        //         // Parcourt le tableau dans la direction par rapport à ces cellules adjacentes
+        //         foreach (var cell in surroundingCells)
+        //         {
+        //             // Si la cellule adjacente ne contient pas de tuile, on passe à la cellule adjacente suivante 
+        //             if (cell?.GetTile == null) break;
+        //
+        //             if (cellsPlayed.Contains(cell) != true)
+        //             {
+        //
+        //                 var dx = cell.GetX - cellsPlayed[i].GetX;
+        //                 var dy = cell.GetY - cellsPlayed[i].GetY;
+        //
+        //                 for (int j = 1; j < b.Rows; j++)
+        //                 {
+        //                     var extendedCell = b.GetCell(cellsPlayed[i].GetX + j * dx, cellsPlayed[i].GetY + j * dy);
+        //
+        //                     if (extendedCell?.GetTile == null)
+        //                     {
+        //                         break;
+        //                     }
+        //
+        //                     score += 1;
+        //
+        //                 }
+        //             }
+        //         }
+        //
+        //     }
+        //
+        //     ScoreBoard.Add(player, score);
+        //
+        //     return score;
+        // }
+
+        public int GetPlayerScore(Player player, ReadOnlyCollection<Cell> cellsPlayed, Board b)
         {
-            // Compte le nombre de tuiles et ajoute ce nombre au score
             int score = cellsPlayed.Count;
 
-            // Check les lignes / colonnes adjacentes aux tuiles placées
+            foreach (var cell in cellsPlayed)
-            for(int i= 0; i < cellsPlayed.Count; i++)
             {
-                // A chaque tour, crée la liste des 4 cellules adjacentes à la cellule sélectionnée
+                score += CalculateAdjacentScore(cell, b, cellsPlayed);
-                var surroundingCells = new[]
+            }
-                {
+
-                    board.GetCell(cellsPlayed[i].GetX + 1, cellsPlayed[i].GetY),
+            
-                    board.GetCell(cellsPlayed[i].GetX - 1, cellsPlayed[i].GetY),
+            if(ScoreBoard.TryAdd(player, score) == false)
-                    board.GetCell(cellsPlayed[i].GetX, cellsPlayed[i].GetY + 1),
+            {
-                    board.GetCell(cellsPlayed[i].GetX, cellsPlayed[i].GetY - 1)
+                ScoreBoard[player] += score;
-                };
+            }
-
+
-                // Parcourt le tableau dans la direction par rapport à ces cellules adjacentes
+            return score;
-                foreach (var cell in surroundingCells)
+        }
+
+        private int CalculateAdjacentScore(Cell cell, Board b, ReadOnlyCollection<Cell> cellsPlayed)
+        {
+            int score = 0;
+
+            var surroundingCells = new[]
+            {
+                b.GetCell(cell.GetX + 1, cell.GetY),
+                b.GetCell(cell.GetX - 1, cell.GetY),
+                b.GetCell(cell.GetX, cell.GetY + 1),
+                b.GetCell(cell.GetX, cell.GetY - 1)
+            };
+
+            foreach (var adjacentCell in surroundingCells)
+            {
+                if (adjacentCell?.GetTile == null || cellsPlayed.Contains(adjacentCell))
                 {
-                    // Si la cellule adjacente ne contient pas de tuile, on passe à la cellule adjacente suivante 
+                    continue;
-                    if (cell?.GetTile == null) break;
+                }
 
-                    else if (cellsPlayed.Contains(cell) != true)
+                int dx = adjacentCell.GetX - cell.GetX;
-                    {
+                int dy = adjacentCell.GetY - cell.GetY;
 
-                        var dx = cell.GetX - cellsPlayed[i].GetX;
+                score += CalculateLineScore(cell, dx, dy, b);
-                        var dy = cell.GetY - cellsPlayed[i].GetY;
+            }
 
-                        for (int j = 1; j < board.Rows; j++)
+            return score;
-                        {
+        }
-                            var extendedCell = board.GetCell(cellsPlayed[i].GetX + j * dx, cellsPlayed[i].GetY + j * dy);
 
-                            if (extendedCell?.GetTile == null)
+        private int CalculateLineScore(Cell cell, int dx, int dy, Board b)
-                            {
+        {
-                                break;
+            int score = 0;
-                            }
 
-                            score += 1;
+            for (int i = 1; i < b.Rows; i++)
+            {
+                var extendedCell = b.GetCell(cell.GetX + i * dx, cell.GetY + i * dy);
 
-                        }
+                if (extendedCell?.GetTile == null)
-                    }
+                {
+                    break;
                 }
 
+                score++;
             }
 
-            ScoreBoard.Add(player, score);
-
             return score;
         }
 

Qwirkle/QwirkleClassLibrary/IPlayer.cs

@@ -1,3 +1,5 @@
+using System.Collections.ObjectModel;
+
 namespace QwirkleClassLibrary;
 
 public interface IPlayer
@@ -12,5 +14,5 @@ public interface IPlayer
     
     public bool SwapTiles(Player player, List<Tile> tilesToSwap);
 
-    public int GetPlayerScore(Player player, List<Cell> cellsPlayed, Board board);
+    public int GetPlayerScore(Player player, ReadOnlyCollection<Cell> cellsPlayed, Board b);
 }

Qwirkle/QwirkleConsoleApp/Program.cs

@@ -134,7 +134,7 @@ static void MenuSwitch(Game game)
 
         WriteLine("[1] Place your tiles");
         WriteLine("[2] Swap your tiles");
-        WriteLine("[3] Skip your turn");
+        WriteLine("[3] End your turn / Skip your turn");
 
         try
         {
@@ -155,6 +155,7 @@ static void MenuSwitch(Game game)
                 enter = 3;
                 break;
             case 3:
+                WriteLine("Your score on this turn : " + game.GetPlayerScore(game.GetPlayingPlayer(), game.CellsUsed, game.GetBoard()));
                 game.EmptyCellUsed();
                 return;
         }

Qwirkle/cm7/cm7.cs

@@ -0,0 +1,28 @@
+// DataBinding Baby !!
+
+// Applcation se basant sur le site wtatennis.com
+
+// class : Player, Place (Birth Places), Manager, IPersistanceManager
+// enum : Hand (lfet-handed or right-handed)
+
+// Player.cs
+
+public string FirstName
+{
+    get => firstName;
+    set
+    {
+        if(value == firstName) return;
+        firstName = value;
+        OnPropertyChanged();
+    }
+}
+
+private string firstName;
+
+public event PropertyChangedEventHandler PropertyChanged;
+
+public void OnPropertyChanged([CallerMemberName] string propertyName = null)
+{
+    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+}

Qwirkle/cm7/cm7.xaml

@@ -0,0 +1,41 @@
+<!-- Player Page -->
+
+<Grid ColumnDefinition="*, *" RowDefinition="Auto, *">
+    <Grid BackgroundColor="Blue">
+        <VerticalStackLayout>
+            <Label Text="Ranking"/>
+            <Label Text="{Binding Rank}"/>
+            <Label Text="Singles"/>
+        </VerticalStackLayout>
+    </Grid>
+    <Grid BackgroundColor="Blue" Grid.Column="1">
+        <VerticalStackLayout>
+            <Entry Text="{Binding Player.FirstName, Mode=OneWayToSource}"/> 
+            <Label Text="{Binding Player.FirstName}, Mode=(OneWay, TwoWay, OneWayToSource)"/> <!-- Automatically subscribed to the source's property change -->
+            <Label Text="{Binding Player.LastName}"/>
+            <Label Text="{Binding Player.Height, StringFormat=\{0\}m}"/>
+            <Button Text="=>" Clicked="ButtonClicked"/>
+        </VerticalStackLayout>
+    </Grid>
+    <Image Grid.RowSpan="2" Source="{Binding Player.ImageLarge}"/>
+</Grid>
+
+<!-- =================== -->
+
+<!-- Players Page -->
+
+<ListView ItemsSource="{Binding Players}">
+    <ListView.ItemTemplate>
+        <DataTemplate>
+            <ViewCell>
+                <HorizontalStackLayout>
+                    <Label Text="{Binding FirstName}"/>
+                    <Label Text="{Binding LastName}"/>
+                    <Label Text="{Binding Points}"/>
+                </HorizontalStackLayout>
+            </ViewCell>
+        </DataTemplate>
+    </ListView.ItemTemplate>
+</ListView>
+
+<!-- =================== -->

Qwirkle/cm7/cm7_codebehind.cs

@@ -0,0 +1,80 @@
+// Code Behind for PlayerPage
+
+public partial class PlayerPage : ContentPage
+{
+    public Manager Mgr { get; set; } = new Manager(new Stub());
+
+    public int PlayerIndex { get; set; } = 0;
+
+    public RankedPlayer RankedPlayer { get; set; }
+
+    public PlayerPage()
+    {
+        Mgr.LoadPlayers();
+
+        InitializeComponent();
+
+        RankedPlayer = new RankedPlayer(Mgr.Players.ElementAt(2), Mgr);
+        BindingContext = RankedPlayer;
+    }
+
+    public void ButtonClicked(object sender, EventArgs e)
+    {
+        PlayerIndex++;
+        RankedPlayer.Player = Mgr.Players.ElementAt(PlayerIndex); // Source's property changed, not the source itself
+    }
+}
+
+public class RankedPlayer : INotifyPropertyChanged
+{
+    public RankedPlayer(Player player, Manager mgr)
+    {
+        Mgr = mgr;
+        Player = player;
+    }
+
+    private Manager Mgr { get; set; }
+
+    public Player thePlayer
+    {
+        get => thePlayer;
+        set
+        {
+            if(value == thePlayer) return;
+            thePlayer = value;
+            OnPropertyChanged("ThePlayer");
+            OnPropertyChanged(nameof(Rank));
+        }
+    }
+
+    private Player thePlayer;
+
+    public int Rank => Mgr.Players.OrderingByDescending(p => p.Points).ToList().IndexOf(Player) + 1;
+
+    public event PropertyChangedEventHandler PropertyChanged;
+
+    public void OnPropertyChanged(string propertyName)
+    {
+        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+    }
+}
+
+// ===============================
+
+// Code behind for Players Page
+
+public partial class PlayersPage : ContentPage
+{
+    public Manager Mgr { get; set; } = new Manager(new Stub());
+
+    public PlayersPage()
+    {
+        Mgr.LoadPlayers();
+
+        InitializeComponent();
+
+        BindingContext = Mgr;
+    }
+}
+
+// ===============================