Update(master): README

Model/Sources/Model/Game.swift

@@ -5,6 +5,8 @@
 //  Created by Louis DUFOUR on 05/02/2024.
 //
 
+import Foundation
+
 public struct Game {
     public var rules: VerySimpleRules
     public var board: Board

README.md

@@ -6,6 +6,9 @@ Le projet DouShouQi en Swift est une implémentation console du jeu de plateau D
 - **Système d'exploitation**: macOS Ventura 13.1
 - **Logiciel**: Xcode version 14.2
 
+## Cas d'erreur connus
+La persistance marche partiellement *(lorsqu'on appel save dans main cela plante)*
+
 ## Installation et Configuration
 ### Étape 1 : Clonage du projet
 ```

Sujets/README.md

@@ -1,196 +0,0 @@
-**Home** | [Semaine 1](./subject_week1.md)  
-  
-
-# Introduction
-
-- [Introduction](#introduction)
-- [Dou Shou Qi](#dou-shou-qi)
-  - [**But du jeu** :](#but-du-jeu-)
-  - [**Matériel** :](#matériel-)
-  - [Pouvoir des animaux](#pouvoir-des-animaux)
-  - [Déroulement du jeu](#déroulement-du-jeu)
-- [Déroulement des TP](#déroulement-des-tp)
-- [Évaluation](#évaluation)
-- [Structure de l'application](#structure-de-lapplication)
-- [Énoncés](#énoncés)
-
-
-Cette introduction explique comment cette ressource va se dérouler, ce qu'il y aura à réaliser, et comment vous serez évaluées et évalués.  
-Pour découvrir le langage **Swift**, nous proposons de développer le modèle d'un jeu traditionnel chinois appelé le **Dou Shou Qi** dont les origines remontraient au Vème siècle.  
-
-# Dou Shou Qi
-## **But du jeu** : 
-- occuper la tanière de son adversaire
-- ou manger toutes ses pièces
-- ou l'empêcher de bouger.
-## **Matériel** :  
-Chaque joueur possède 8 pions numérotés (pour représenter leur force) et représentant des animaux : **Rat** 🐭 (1), **Chat** 🐱 (2), **Chien** 🐶 (3), **Loup** 🐺 (4), **Léopard** 🐆 (5), **Tigre** 🐯 (6), **Lion** 🦁 (7) et **Éléphant** 🐘 (8).  
-  
-Le plateau de jeu est une grille à deux dimensions de 10 lignes et 7 colonnes. Il est fait de 4 types de cases :
-- **Jungle** 🌿 : aucune particularité
-- **Lac** 💧 : interdit à tous les animaux sauf le **Rat** ; le **Lion** et le **Tigre** peuvent sauter par-dessus.  
-- **Tanière** 🪹 : un joueur ne peut pas se déplacer sur sa propre **Tanière** et doit aller sur la **Tanière** de l'adversaire pour gagner
-- **Piège** 🪤 : un pion sur un piège (quel que soit le côté du plateau) a une force de **0**.  
-
-La grille originale ressemble à :
-
-🌿  🌿  🪤  🪹  🪤  🌿  🌿    
-🌿  🌿  🌿  🪤  🌿  🌿  🌿    
-🌿  🌿  🌿  🌿  🌿  🌿  🌿    
-🌿  💧  💧  🌿  💧  💧  🌿    
-🌿  💧  💧  🌿  💧  💧  🌿    
-🌿  💧  💧  🌿  💧  💧  🌿    
-🌿  💧  💧  🌿  💧  💧  🌿    
-🌿  🌿  🌿  🌿  🌿  🌿  🌿    
-🌿  🌿  🌿  🪤  🌿  🌿  🌿    
-🌿  🌿  🪤  🪹  🪤  🌿  🌿    
-(la tanière du haut est celle du joueur 1, celle du bas du joueur 2).
-
-De plus, certaines cases sont les cases de départ des pions :  
-🦁  🌿  🪤  🪹  🪤  🌿  🐯    
-🌿  🐶  🌿  🪤  🌿  🐱  🌿    
-🐭  🌿  🐆  🌿  🐺  🌿  🐘    
-🌿  💧  💧  🌿  💧  💧  🌿    
-🌿  💧  💧  🌿  💧  💧  🌿    
-🌿  💧  💧  🌿  💧  💧  🌿    
-🌿  💧  💧  🌿  💧  💧  🌿    
-🐘  🌿  🐺  🌿  🐆  🌿  🐭    
-🌿  🐱  🌿  🪤  🌿  🐶  🌿    
-🐯  🌿  🪤  🪹  🪤  🌿  🦁    
-(où les animaux du haut sont ceux du joueur 1, et ceux du bas du joueur 2).  
-
-## Pouvoir des animaux
-- Tous les animaux peuvent _manger_ un animal de force égale ou inférieure, avec les exceptions suivantes :
-  - l'éléphant ne peut pas _manger_ le rat,
-  - le rat peut _manger_ l'éléphant,
-  - on ne peut pas _manger_ son propre animal.
-- Les animaux ne peuvent se déplacer que sur une case adjacente (même ligne ou même colonne)
-- Les animaux ne peuvent pas se déplacer sur leur propre **Tanière**
-- Les animaux ne peuvent pas se déplacer dans l'eau (sauf le **Rat**). Attention, le **Rat** ne peut pas sortir de l'eau pour attaquer l'**éléphant** adverse, mais il peut le faire pour attaquer le **rat** adverse. 
-- Le **lion** et le **tigre** peuvent sauter par-dessus les lacs (en restant sur la même ligne ou sur la même colonne), **sauf** si un **rat** est dans le lac, sur la trajectoire du saut.  
-
-## Déroulement du jeu
-Chaque joueur doit à son tour de jeu déplacer l'un de ses animaux.
-
-# Déroulement des TP
-
-L'objectif des TP est de réaliser cette application en 5 TP durant 6 semaines.  
-Les énoncés seront donnés en début de semaine ainsi qu'une liste de thème à travailler pour bien réussir le TP.  
-La sixième semaine sert de tampon, pour rattraper le retard accumulé pendant les semaines précédentes.  
-Pour chacune des 5 premières semaines, il est conseillé de :
-- avant le TP :
-  - travailler les thèmes donnés en avance, via :
-    - la [documentation officielle du langage Swift](https://www.swift.org/documentation/)
-    - le [livre Apple sur le langage Swift](https://docs.swift.org/swift-book/documentation/the-swift-programming-language/)
-    - les [ressources de cours sur code first](https://codefirst.iut.uca.fr/documentation/mchCoursDocusaurus/docusaurus/Swift/)
-  - profiter du résumé en cours et poser des questions sur les parties non comprises
-- pendant le TP :
-  - réaliser au maximum les tâches demandées
-  - et les faire valider par l'enseignant pour obtenir validation de l'acquisition des compétences
-- après le TP :
-  - faire le point sur le "reste à faire" et s'organiser pour la semaine suivante
-  - faire le point sur les acquis que vous n'avez pas fait valider pour solliciter l'enseignant à la séance suivante  
-  
-Pour la sixième semaine :
-- profiter du dernier cours pour poser les dernières questions techniques
-- profiter du dernier TP pour rattraper le retard et faire valider ses derniers acquis non validés par l'enseignant.
-
-> Note :  
-> Les ressources de cours sur code first ne remplacent pas la documentation officielle. Elles apportent des conseils sur l'ordre de lecture dans la réalisation des TP. 
-> 
-# Évaluation
-
-Une fiche de compétences à acquérir et des points à réaliser en TP sera préparée et accessible pour chaque TP sur code first.  
-Vous aurez accès aux évaluations de l'enseignant au fur et à mesure de son évaluation.  
-Pour obtenir une validation, vous devrez prouver votre acquisition des compétences à l'enseignant via : un entretien oral ou un examen écrit.  
-La note finale sera composée de l'ensemble des acquis validés par l'enseignant à la dernière minute du dernier TP.  
-
-# Structure de l'application
-
-Voici un diagramme de classes volontairement simplifié présentant grossièrement les différents acteurs de l'application que vous devez réaliser :
-
-```mermaid
-classDiagram
-direction TB
-
-Game --> "1" Rules : rules
-Game --> "1" Board : board
-Game --> "2" Player: players
-
-Rules <|.. ClassicRules
-Rules <|.. VerySimpleRules
-
-Rules ..> Board
-Board --> "*,*" Cell : grid
-
-Player <|-- RandomPlayer
-Player <|-- HumanPlayer
-
-class Board {
-    +insert(piece:, atRow:, andColumn:)
-    +removePiece(atRow:, andColumn:)
-}
-
-class Cell {
-    +cellType : CellType
-    +initialOwner: Owner
-    +piece : Piece?
-}
-
-class Rules {
-    +createBoard() : Board$
-    +getNextPlayer() : Owner
-    +isMoveValid(Board, Move) : Bool
-    +isGameOver(Board, Int, Int) : Bool
-}
-
-class Player {
-    +chooseMove(in: Board, with: Rules) Move?
-}
-
-class Game {
-    +init(withRules:, andPlayer1:, andPlayer2: Player)
-    +start()
-}
-```
-
-- ```Board``` représente le plateau de jeu et est composé d'un tableau à deux dimensions de ```Cell``` : il est responsable de l'insertion, de la suppression et donc du déplacement des pions.
-- ```Rules``` représente les règles du jeu. Comme elles sont assez touffues (```ClassicRules```), je vous proposerai des règles simplifiées (```VerySimpleRules```). ```Rules``` indique qui est le prochain joueur, si un coup est valide, si la partie est terminée, etc.
-- ```Player``` représente un joueur. Nous en réaliserons deux versions en particulier : une *IA* qui jouera aléatoirement (```RandomPlayer```) et un joueur humain (```HumanPlayer```).
-- ```Game``` : sert de médiateur et d'ordonnanceur pour la gestion globale du jeu.  
-
-L'application à réaliser est une application en lignes de commandes qui permettra de jouer dans un terminal et ressemblera au résultat ci-dessous :  
-    
-<img src="./images/Terminal.png" width="600px"/>
-
-Vous travaillerez sur :
-- ```Board``` et ```Cell``` pendant les deux premières semaines,
-- ```Rules``` et ```VerySimpleRules``` pendant la 3ème semaine,
-- ```Player```, ```RandomPlayer``` et ```HumanPlayer``` pendant la 4ème semaine,
-- ```Game``` et l'application finale pendant la 5ème semaine.
-
-Des énoncés plus détaillés vous seront donnés au début de chaque semaine.  
-
-# Énoncés
-- [Semaine 1](./subject_week1.md)
-
-**Home** | [Semaine 1](./subject_week1.md)  
-
----
-Copyright &copy; 2023-2024 Marc Chevaldonné
-
-While writing this tutorial, I was listening to...  
-
-<table>
-    <tr>
-        <td>
-            <img src="./images/listeningto/on_the_corner.jpg" width="120"/>
-        </td>
-        <td>
-            <div>
-                <p><b>On The Corner</b></p>
-                <p><i>Miles Davis</i> (1972)</p>
-            </div>
-        </td>
-    </tr>
-</table>

Sujets/subject_week1.md

@@ -1,325 +0,0 @@
-[Home](./README.md) | **Semaine 1**  
-  
-# Énoncé - Semaine 1
-
-- [Énoncé - Semaine 1](#énoncé---semaine-1)
-- [Délai de livraison](#délai-de-livraison)
-- [Travail demandé](#travail-demandé)
-  - [Package 1 : Modèle](#package-1--modèle)
-  - [Package 2 : Extensions pour les tests en CLI](#package-2--extensions-pour-les-tests-en-cli)
-  - [Premier test : Command Line Tool](#premier-test--command-line-tool)
-- [Critères d'évaluation](#critères-dévaluation)
-
-# Délai de livraison
-Votre travail est à rendre sur une branche tp1 et doit être fusionné à la branche principale lorsqu'il est terminé.  
-La livraison est attendue à la fin du TP.  
-Un retard jusqu'à la fin du second ou du troisième TP est autorisé mais se verra attribué des pénalités (cf. [Critères d'évaluation](#critères-dévaluation)).  
-
-# Travail demandé
-
-Durant la première semaine, il vous est demandé de réaliser la première partie de la gestion du plateau de jeu.  
-
-## Package 1 : Modèle
-
-Le premier *Package* à créer correspond au modèle (*Model*).  
-
-Voici un diagramme de classes de ce qui est attendu :  
-```mermaid
-classDiagram
-direction LR
-class Board {
-    <<struct>>
-    +nbRows : Int
-    +nbColumns : Int
-    +init?(withGrid:)
-}
-
-class Cell {
-    <<struct>>
-    +init(ofType:ownedBy:withPiece:)
-}
-
-class CellType {
-    <<enum>>
-    unknown
-    jungle
-    water
-    trap
-    den
-}
-
-class Owner {
-    noOne
-    player1
-    player2
-}
-
-Cell --> "1" CellType : cellType
-Cell --> "1" Owner : initialOwner
-Board --> "*" Cell : grid
-
-class Animal {
-    <<enum>>
-    rat
-    cat
-    dog
-    wolf
-    leopard
-    tiger
-    lion
-    elephant
-}
-
-class Piece {
-    <<struct>>
-    +init(withOwner:andAnimal:)
-}
-
-Piece --> "1" Owner : owner
-Piece --> "1" Animal : animal
-Cell --> "?" Piece : piece
-```
-
-En français, vous avez donc à préparer les types suivants :
-- les *enums* :
-  - ```CellType``` : représente le type d'une cellule (case) du plateau de jeu. Ces cellules peuvent être de type jungle (```jungle```), lac (```water```), piège (```trap```) ou tannière (```den```). La valeur ```unknown``` sera surtout utile comme valeur par défaut et pour le débogage. 
-  - ```Owner``` : représente le propriétaire d'une cellule du plateau (au démarrage du jeu, ou pour les tannières) ou d'une pièce. C'est un jeu à deux joueurs, les deux valeurs possibles sont donc ```player1``` et ```player2```. Mais puisqu'une cellule peut n'appartenir à personne, la valeur ```noOne``` existe également et est utilisée pour cela.  
-  - ```Animal``` : représente le type d'animal du jeu (rat ```rat```, chat ```cat```, chien ```dog```, loup ```wolf```, lépoard ```leopard```, tigre ```tiger```, lion ```lion``` ou éléphant ```elephant```). 
-  - ```Owner``` doit se transformer facilement en ```String``` pour permettre le débogage et le test en lignes de commande. Les transformations seront les suivantes :  
-    valeur | String  
-    --- | ---  
-    ```noOne``` | ```"x"```
-    ```player1``` | ```"1"```
-    ```player2``` | ```"2"```
-- la structure ```Piece``` qui représente une pièce du jeu. Elle possède donc :
-  - deux propriétés en lecture seule, et non-modifiables :
-    - un propriétaire (```owner```)
-    - un type d'animal (```animal```)
-  - un initialiseur permettant d'écrire ces deux propriétés lors de l'initialisation
-  - la possibilité de transformer une valeur de ```Piece``` en ```String``` sous la forme : ```"[1:leopard]"``` par exemple pour un léopard du joueur 1.
-- la structure ```Cell``` qui représente une cellule ou une case du jeu. Elle possède donc :
-  - des propriétés en lecture seule et non-modifiables :
-    - un type de case (```cellType```)
-    - un propriétaire de case (pour les tannières et les cases de départ) (```initialOwner```)
-    - éventuellement une pièce s'il y en a une dessus (```piece```)
-  - un initialiseur permettant de choisir le type de cellule, un propriétaire (avec la valeur par défaut ```noOne```), une pièce (par défaut il n'y en a pas)
-  - la possibilité de transformer une ```Cellule``` en ```String``` sous la forme : ```"<piece> on <cellType>, <owner>"``` (avec ```<piece>``` qui vaut ```ø``` s'il n'y a pas de pièce), par exemple : ```"[1:leopard] on .jungle, x"``` ou ```"ø on .water, x"``` ou ```"[2:tiger] on den, 1"```.  
-- la structure ```Board``` qui représente le plateau de jeu. Elle possède donc :
-  - des propriétés en lecture seule et non-modifiables :
-    - ```nbRows``` représentant le nombre de lignes du plateau de jeu,
-    - ```nbColumns``` représentant le nombre de colonnes du plateau de jeu.
-  - une propriété représentant un tableau à deux dimensions de cellules (```grid```). Cette propriété devra être uniquement lisible à l'extérieur de ```Board```, mais modifiable au sein de cette structure.
-  - un initialiseur prenant un tableau à deux dimensions de cellules en paramètre. Cet initialiseur devra faire des vérifications :
-    - toutes les lignes doivent avoir la même taille, sinon, l'initialiseur rend ```nil```.
-  
-## Package 2 : Extensions pour les tests en CLI
-Pour permettre un affichage simplifié en lignes de commande, il vous est demandé de permettre l'affichage des pièces, cellules, etc. avec des emojis. Or, ceci étant spécifique à une application en lignes de commande, il n'est pas utile de les ajouter au *Package* précédent. En conséquence, il vous est demandé de créer un deuxième *Package* avec des extensions des types précédents afin de permettre l'affichage de :
-- ```CellType``` (via une propriété ```symbol```) :
-  valeur | ```String```   
-  --- | ---   
-  ```unknown``` | ```"   "```
-  ```jungle``` | ```"🌿"```
-  ```den``` | ```"🪹"```
-  ```trap``` | ```"🪤"```
-  ```water``` | ```"💧"```
-- ```Animal``` (via une propriété ```symbol```) :
-  valeur | ```String```   
-  --- | ---   
-  ```rat``` | ```"🐭"```
-  ```cat``` | ```"🐱"```
-  ```dog``` | ```"🐶"```
-  ```wolf``` | ```"🐺"```
-  ```leopard``` | ```"🐆"```
-  ```tiger``` | ```"🐯"```
-  ```lion``` | ```"🦁"```
-  ```elephant``` | ```"🐘"```
-- ```Owner``` (via une propriété ```symbol```) :
-  valeur | ```String```   
-  --- | ---   
-  ```noOne``` | ```" "```
-  ```player1``` | ```"🟡"```
-  ```player2``` | ```"🔴"```
-- ```Board``` (via la propriété classique), pour que cela donne par exemple (à peu près) :
-  ```
-    🌿🦁🟡  🌿      🪤      🪹      🪤      🌿      🌿🐯🟡  
-
-    🌿     🌿🐶🟡   🌿      🪤      🌿      🌿🐱🟡   🌿      
-
-    🌿🐭🟡  🌿      🌿🐆🟡   🌿      🌿🐺🟡   🌿       🌿🐘🟡  
-
-    🌿      💧      💧      🌿      💧      💧      🌿      
-
-    🌿      💧      💧      🌿      💧      💧      🌿      
-
-    🌿      💧      💧      🌿      💧      💧      🌿      
-
-    🌿      💧      💧      🌿      💧      💧      🌿      
-
-    🌿🐘🔴   🌿      🌿🐺🔴  🌿      🌿🐆🔴   🌿      🌿🐭🔴  
-
-    🌿      🌿🐱🔴   🌿      🪤      🌿      🌿🐶🔴  🌿      
-
-    🌿🐯🔴   🌿      🪤      🪹      🪤      🌿      🌿🦁🔴  
-  ```
-  c'est-à-dire que chaque cellule sera représentée par : son type, le type de la pièce, la couleur du joueur propriétaire de cette pièce.  
-
-## Premier test : Command Line Tool
-Pour cette première semaine, nous allons créer un test en lignes de commande (qui s'affichera dans l'interface d'XCode).  
-
-Le test demandé est très simple :  
-=> initialiser une valeur de ```Board``` et l'afficher.  
-> Note :  
-> Essayez de refaire la grille de départ (comme ci-dessus).  
- 
-# Critères d'évaluation
-
-Pour être obtenir les points, vous devez faire valider vos aquis par l'enseignant à l'oral pendant les TP (ou si l'enseignant le propose, lors d'une évaluation écrite).  
-  
-Cette validation doit avoir lieu avant la fin du TP pour obtenir tous les points. Si la validation a lieu pendant le TP2, une pénalité de 50% est appliquée. Si elle a lieu pendant le TP3, une pénalité de 75% est appliquée. Par la suite, plus aucun point n'est attribué.       
-
-**Légende**  
-symbole | signification  
---- | --- 
-☢️ | si ce critère n'est pas respecté => 0/20
-🎬 |  évalué à la fin du TP  
-1️⃣ | ctirère de niveau 1 : tant que vous n'avez pas obtenu tous les points sur les critères de niveau 1, les points sur les critères suivants ne sont pas attribués
-2️⃣ | critère de niveau 2 : tant que vous n'avez pas obtenu tous les points sur les critères de niveau 1 et 2, les points sur les critères de niveau 3 ne sont pas attribués
-3️⃣ | critère de niveau 3  
-
-**Critères**
-niveau | description | coeff | pénalités TP2 | pénalités TP3 
---- | --- | --- | --- | ---
-☢️ | Le dépôt doit être accessible par l'enseignant | ☢️ 
-☢️ | un .gitignore doit exister au premier push | ☢️
-🎬 | les *Packages* et le test compilent | 4 | 50% | 75%
-🎬 | le test s'exécute sans bug | 4 | 50% | 75%
-3️⃣ | tous mes projets sont dans le même _workspace_ | 2 | 50% | 75%
-1️⃣ | j'ai créé un *Package* *Model* | 2 | 50% | 75%
-1️⃣ | j'ai créé l'enum ```CellType``` | 1 | 50% | 75%
-1️⃣ | j'ai créé l'enum ```Owner``` | 1 | 50% | 75%
-1️⃣ | j'ai créé l'enum ```Animal``` | 1 | 50% | 75%
-3️⃣ | ```Owner``` s'affiche comme demandé sous la forme d'un ```String``` | 1 | 50% | 75%
-1️⃣ | ```Piece``` possède bien les propriétés demandées en lecture seule non-modifiables | 1 | 50% | 75%
-1️⃣ | ```Piece``` possède un initialiseur | 2 | 50% | 75%
-3️⃣ | ```Piece``` est transformable en ```String``` comme demandé | 1 | 50% | 75%
-1️⃣ | ```Cell``` possède bien les propriétés demandées en lecture seule non-modifiables | 1 | 50% | 75%
-1️⃣ | ```Cell``` possède bien une propriété ```piece``` pouvant ne pas avoir de valeur | 2 | 50% | 75%
-1️⃣ | ```Cell``` possède un initialiseur utilisant des valeurs par défaut pour deux paramètres | 2 | 50% | 75%
-3️⃣ | ```Cell``` est transformable en ```String``` comme demandé | 1 | 50% | 75%
-1️⃣ | ```Board``` possède bien les propriétés demandées en lecture seule non-modifiables | 1 | 50% | 75%
-1️⃣ | ```Board``` possède bien un tableau à deux dimensions de cellule | 2 | 50% | 75%
-2️⃣ | ```Board.grid``` est en lecture seule mais modifiable au sein de ```Board``` | 2 | 50% | 75%
-1️⃣ | ```Board``` possède un initialiseur permettant d'initialiser toutes ses propriétés | 2 | 50% | 75%
-2️⃣ | l'initialiseur de ```Board``` vérifie les contraintes et renvoie ```nil``` si nécessaire | 3 | 50% | 75%
-3️⃣ | j'ai créé un *Package* avec les extensions pour l'affichage en lignes de commande | 2 | 50% | 75%
-3️⃣ | j'ai créé une extensions pour ```CellType``` | 1 | 50% | 75%
-3️⃣ | j'ai créé une extensions pour ```Animal``` | 1 | 50% | 75%
-3️⃣ | j'ai créé une extensions pour ```Owner``` | 1 | 50% | 75%
-3️⃣ | j'ai créé une extensions pour ```Board``` | 2 | 50% | 75%
-2️⃣ | j'ai créé une application de type *Command Line Tool* utilisant les deux *Packages* précédents | 2 | 50% | 75%
-2️⃣ | j'initialise correctement ```Board``` dans le test | 2 | 50% | 75%
-3️⃣ | j'affiche correctement ```Board``` dans le test | 1 | 50% | 75%
-3️⃣ | mon dépôt possède un readme qui apporte quelque chose... | 2 | 50% | 75%
-3️⃣ | mon code est commenté | 1   | 50% | 75%
-
-> Note :  
-> Les coefficients peuvent être amenés à changer et sont donnés à titre indicatif  
-  
-[Home](./README.md) | **Semaine 1**    
-
----
-Copyright &copy; 2023-2024 Marc Chevaldonné
-
-Pendant la préparation de ce TP et de cet énoncé, j'écoutais...  
-
-<table>
-    <tr>
-        <td>
-            <img src="./images/listeningto/fuse_one.jpg" width="120"/>
-        </td>
-        <td>
-            <div>
-                <p><b>Fuse One</b></p>
-                <p><i>Silk</i> (1981)</p>
-            </div>
-        </td>
-    </tr>
-</table>
-<table>
-    <tr>
-        <td>
-            <img src="./images/listeningto/mingus_at_monterey.jpg" width="120"/>
-        </td>
-        <td>
-            <div>
-                <p><b>Mingus At Monterey</b></p>
-                <p><i>Charles Mingus</i> (1964)</p>
-            </div>
-        </td>
-    </tr>
-</table>
-<table>
-    <tr>
-        <td>
-            <img src="./images/listeningto/upon_the_wings_of_music.jpg" width="120"/>
-        </td>
-        <td>
-            <div>
-                <p><b>Upon The Wings Of Music</b></p>
-                <p><i>Jean-Luc Ponty</i> (1975)</p>
-            </div>
-        </td>
-    </tr>
-</table>
-<table>
-    <tr>
-        <td>
-            <img src="./images/listeningto/bayou_country.jpg" width="120"/>
-        </td>
-        <td>
-            <div>
-                <p><b>Bayou Country</b></p>
-                <p><i>Creedence Clearwater Revival</i> (1969)</p>
-            </div>
-        </td>
-    </tr>
-</table>
-<table>
-    <tr>
-        <td>
-            <img src="./images/listeningto/friday_night.jpg" width="120"/>
-        </td>
-        <td>
-            <div>
-                <p><b>Live At The Old Absinthe House bar ...Friday Night</b></p>
-                <p><i>Bryan Lee</i> (1997)</p>
-            </div>
-        </td>
-    </tr>
-</table>
-<table>
-    <tr>
-        <td>
-            <img src="./images/listeningto/vanguard_potter.jpg" width="120"/>
-        </td>
-        <td>
-            <div>
-                <p><b>Follow The Red Line - Live At The Village Vanguard</b></p>
-                <p><i>Chris Potter Underground</i> (2007)</p>
-            </div>
-        </td>
-    </tr>
-</table>
-<table>
-    <tr>
-        <td>
-            <img src="./images/listeningto/digital_works.jpg" width="120"/>
-        </td>
-        <td>
-            <div>
-                <p><b>Digital Works</b></p>
-                <p><i>Ahmad Jamal</i> (1985)</p>
-            </div>
-        </td>
-    </tr>
-</table>