+
+
+
+
+
+ Nouvelle rencontre
+Configuration
++ Les reglages ci-dessous preparent les pages chrono et cube. +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+@code {
+ private SetupFormModel Form { get; set; } = new();
+ private bool _ready;
+
+ private MatchState? CurrentMatch => Store.Current;
+
+ private string SetupBodyClass => UsesMoveLimit ? string.Empty : "time-setup-mode";
+
+ private bool UsesMoveLimit => MatchEngine.UsesMoveLimit(Form.Mode);
+
+ private MatchPresetInfo CurrentPreset =>
+ MatchEngine.Presets.TryGetValue(Form.Preset, out var preset)
+ ? preset
+ : MatchEngine.Presets[MatchEngine.PresetFast];
+
+ private MatchModeInfo CurrentMode =>
+ MatchEngine.Modes.TryGetValue(Form.Mode, out var mode)
+ ? mode
+ : MatchEngine.Modes[MatchEngine.ModeTwice];
+
+ private string TimingText =>
+ UsesMoveLimit
+ ? $"Temps configures : Block {MatchEngine.FormatClock(Form.BlockMinutes * 60_000L)}, coup {MatchEngine.FormatClock(Form.MoveSeconds * 1_000L)}."
+ : $"Temps configures : Block {MatchEngine.FormatClock(Form.BlockMinutes * 60_000L)}, temps de chaque joueur {MatchEngine.FormatClock(Form.TimeInitialMinutes * 60_000L)}.";
+
+ private string TimeImpact =>
+ Form.Mode == MatchEngine.ModeTime
+ ? $"Chronos cumules de {MatchEngine.FormatClock(Form.TimeInitialMinutes * 60_000L)} par joueur, ajustes apres chaque phase cube avec plafond de 120 s pris en compte. Aucun temps par coup en mode Time."
+ : "Le gagnant du cube commence le Block suivant, avec double coup V2 possible.";
+
+ private string QuotaText =>
+ UsesMoveLimit
+ ? $"Quota actif : {CurrentPreset.Quota} coups par joueur."
+ : $"Quota actif : {CurrentPreset.Quota} coups par joueur et par Block.";
+
+ protected override async Task OnAfterRenderAsync(bool firstRender)
+ {
+ if (!firstRender)
+ {
+ return;
+ }
+
+ await Store.EnsureLoadedAsync();
+ _ready = true;
+ StateHasChanged();
+ }
+
+ private async Task HandleSubmit()
+ {
+ var match = MatchEngine.CreateMatch(Form.ToMatchConfig());
+ Store.SetCurrent(match);
+ await Store.SaveAsync();
+ Navigation.NavigateTo("/chrono.html");
+ }
+
+ private void LoadDemo()
+ => Form = SetupFormModel.CreateDemo();
+
+ private void SetMode(string mode)
+ => Form.Mode = mode;
+
+ private void SetPreset(string preset)
+ => Form.Preset = preset;
+
+ private void ResumeMatch()
+ {
+ if (CurrentMatch is null)
+ {
+ return;
+ }
+
+ Navigation.NavigateTo(MatchEngine.RouteForMatch(CurrentMatch));
+ }
+
+ private async Task ClearMatchAsync()
+ {
+ await Store.ClearAsync();
+ StateHasChanged();
+ }
+
+ private Task ForceRefreshAsync()
+ => Browser.ForceRefreshAsync("/application.html").AsTask();
+
+ private static string ResumeMatchLabel(MatchState match)
+ => string.IsNullOrWhiteSpace(match.Config.MatchLabel) ? "Rencontre ChessCubing" : match.Config.MatchLabel;
+
+ private static string CurrentMatchMode(MatchState match)
+ => MatchEngine.Modes.TryGetValue(match.Config.Mode, out var mode) ? mode.Label : "ChessCubing Twice";
+
+ private static string ResumePhaseLabel(MatchState match)
+ {
+ if (!string.IsNullOrEmpty(match.Result))
+ {
+ return MatchEngine.ResultText(match);
+ }
+
+ return match.Phase == MatchEngine.PhaseCube ? "Page cube prete" : "Page chrono prete";
+ }
+}
diff --git a/ChessCubing.App/Pages/ChronoPage.razor b/ChessCubing.App/Pages/ChronoPage.razor
new file mode 100644
index 0000000..7bf2658
--- /dev/null
+++ b/ChessCubing.App/Pages/ChronoPage.razor
@@ -0,0 +1,604 @@
+@page "/chrono"
+@page "/chrono.html"
+@implements IAsyncDisposable
+@inject MatchStore Store
+@inject NavigationManager Navigation
+
+Chargement de la phase chrono...
+ 
+ 
+
+
+
+
+ Phase chrono
+@summary.Title
+@summary.Subtitle
+
+
+
+
+
+
+
+
+ Noir
+
+ @blackZone.Name
+
+ @blackZone.Moves
+ @blackZone.Clock
+
+ @blackZone.Hint
+
+
+
+
+ @summary.SpineLabel
+ @summary.SpineHeadline +@summary.SpineText
+
+
+
+
+
+
+
+
+ Blanc
+
+ @whiteZone.Name
+
+ @whiteZone.Moves
+ @whiteZone.Clock
+
+ @whiteZone.Hint
+
+
+
+
+
+
+
+
+ Outils arbitre
+Controles avances
+@summary.ArbiterStatus
+ +
+
+
+
+
+
+
+
+
+
+ Chargement de la phase cube...
+
+
+
+
+
+
+ Phase cube
+@summary.Title
+@summary.Subtitle
+
+
+
+
+
+
+
+
+ Noir
+
+ @blackZone.Name
+
+ @blackZone.ResultText
+ @blackZone.MetaText
+
+ @blackZone.Hint
+
+
+
+
+ @summary.SpineLabel
+ @summary.SpineHeadline +@summary.SpineText
+
+
+
+
+
+
+
+
+ Blanc
+
+ @whiteZone.Name
+
+ @whiteZone.ResultText
+ @whiteZone.MetaText
+
+ @whiteZone.Hint
+
+
+
+
+
+
+
+
+ Outils arbitre
+Phase cube
+@summary.HelpStatus
+ +
+
+
+
+
+
+ }
+
+
+
+
+
+
+ Fin de phase cube
+@resultView.Title
+@resultView.Summary
+ +
+
+ Vainqueur cube
+ @resultView.Winner
+
+
+ Suite
+ @resultView.Outcome
+
+
+
+
+
+ Blanc
+ @resultView.WhiteName
+ @resultView.WhiteTime
+ @resultView.WhiteDetail
+ @resultView.WhiteClock
+
+
+ Noir
+ @resultView.BlackName
+ @resultView.BlackTime
+ @resultView.BlackDetail
+ @resultView.BlackClock
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/ChessCubing.App/Pages/NotFound.razor b/ChessCubing.App/Pages/NotFound.razor
new file mode 100644
index 0000000..4aec759
--- /dev/null
+++ b/ChessCubing.App/Pages/NotFound.razor
@@ -0,0 +1,39 @@
+@page "/not-found"
+
+
+
+
+
+
+
+
+
+
+
+
+ Association ChessCubing
+Les echecs rencontrent le Rubik's Cube
++ ChessCubing propose un jeu hybride simple a comprendre, intense a + vivre et tres plaisant a regarder. On joue une partie d'echecs, on + passe par une phase cube obligatoire, puis la partie repart avec un + nouveau rythme. +
+ +
+
+
+
+
+ L'association
+Une passerelle entre deux passions
++ L'association ChessCubing veut creer des moments de rencontre, de + decouverte et de jeu partage autour d'un format hybride. +
+
+
+ Partager
+ Faire decouvrir un format original
+
+
+ Rassembler
+ Creer un terrain commun
+
+
+ Animer
+ Donner envie de revenir jouer
+
+
+ + L'idee est simple : reunir des profils differents autour d'un + jeu lisible, vivant et immediatement intriguant. +
++ Joueurs d'echecs, cubers, curieux, familles ou clubs peuvent se + retrouver dans une experience facile a lancer et a commenter. +
++ Le melange de reflexion, de vitesse et de rebondissements donne + au format un cote spectaculaire qui marche tres bien en + initiation comme en evenement. +
+
+
+
+
+
+ Le jeu en simple
+Comment se passe une partie
+
+
+ 1
+ On joue une partie d'echecs
+
+
+ 2
+ On resout un cube
+
+
+ 3
+ Le match repart
+
+
+ + La partie avance par sequences courtes, ce qui garde un tres bon + rythme et rend l'action facile a suivre. +
++ Les deux joueurs enchainent avec une phase cube obligatoire qui + sert de relance, de pression et de bascule. +
++ Selon le mode choisi, la phase cube donne l'initiative ou agit + sur les chronos. Le duel ne retombe jamais. +
+
+
+
+
+
+ Pourquoi ca plait
+Un format qui donne envie d'essayer
+
+
+ Tres lisible
+
+
+ Toujours relance
+
+
+ Convivial
+
+
+ Memorable
+
+
+ On comprend vite quand la pression monte et pourquoi le cube change tout.
+Chaque phase cube remet du suspense dans la partie et ouvre de nouvelles options.
+Le format marche bien en initiation, en animation de club ou en demonstration publique.
+On ressort d'une partie avec des coups, des temps et des retournements dont on se souvient.
+
+
+
+
+
+ Deux formats
+Deux manieres de vivre le duel
++ Le reglement officiel propose deux lectures du meme concept, l'une + plus orientee initiative, l'autre plus orientee gestion du temps. +
+
+
+
+
+
+
+
+
+ ChessCubing Twice
+
+ Le cube donne l'elan
++ Le joueur le plus rapide sur la phase cube prend le depart de + la partie suivante et peut meme obtenir un double coup dans + certaines situations. +
+
+ Mode nerveux
+ Initiative forte
+ Effet immediat
+
+
+ ChessCubing Time
+
+ Le cube agit sur les chronos
++ Ici, on garde le trait mais la performance sur le cube retire + ou ajoute du temps selon l'alternance des blocs. +
+
+ Gestion de temps
+ Blocs - et +
+ Suspense permanent
+
+
+
+
+
+
+ Envie de tester
+Choisis ton entree
++ Tu peux decouvrir le jeu tranquillement avec la page reglement ou + aller directement vers l'application officielle de match. +
+
+
+ Application
+ Ouvrir la partie arbitrage
+
+ Configurer une rencontre, lancer le chrono et enchainer avec la phase cube.
+ + + Reglement + Comprendre les formats officiels +Retrouver une presentation claire du Twice, du Time et des regles de match.
+ + + PDF officiel + Lire le texte source +Consulter directement le document officiel si tu veux tous les details.
+ +
+
+
+
diff --git a/ChessCubing.App/Pages/RulesPage.razor b/ChessCubing.App/Pages/RulesPage.razor
new file mode 100644
index 0000000..1c4fafc
--- /dev/null
+++ b/ChessCubing.App/Pages/RulesPage.razor
@@ -0,0 +1,344 @@
+@page "/reglement"
+@page "/reglement.html"
+
+
+
+
+
+
+
+ Navigation
+Page introuvable
++ Le lien demande n'existe pas ou n'est plus expose par l'application Blazor. +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/ChessCubing.App/Program.cs b/ChessCubing.App/Program.cs
new file mode 100644
index 0000000..be6caa2
--- /dev/null
+++ b/ChessCubing.App/Program.cs
@@ -0,0 +1,14 @@
+using ChessCubing.App;
+using ChessCubing.App.Services;
+using Microsoft.AspNetCore.Components.Web;
+using Microsoft.AspNetCore.Components.WebAssembly.Hosting;
+
+var builder = WebAssemblyHostBuilder.CreateDefault(args);
+builder.RootComponents.Add
+
+
+
+
+
+
+
+
+
+
+ Referentiel officiel
+Reglement ChessCubing
++ Cette page reprend les regles officielles en vigueur du + ChessCubing Twice et du ChessCubing Time pour offrir une lecture + rapide, claire et directement exploitable en club, en demonstration + ou en arbitrage. +
+
+ Twice V2
+ Time V1
+ Entree en vigueur le 4 fevrier 2026
+ Fin uniquement par mat ou abandon
+
+
+
+
+
+
+
+ Vue d'ensemble
+Le match en 4 temps
++ Les deux reglements partagent la meme colonne vertebrale : un + match en parties successives, interrompues par une phase cube + obligatoire. +
+
+
+ 1. Avant le match
+ Installation et tirage
+
+
+ 2. Partie d'echecs
+ 180 secondes de jeu
+
+
+ 3. Phase cube
+ Un cube identique par joueur
+
+
+ 4. Fin de partie
+ Jamais au temps
+
+
+ + L'arbitre controle le materiel, les cubes, les caches, les + melanges, puis le tirage au sort qui attribue Blancs ou Noirs. +
++ Chaque partie comporte une phase d'echecs limitee par une duree + fixe et par un quota de coups selon le format FAST, FREEZE ou + MASTERS. +
++ L'application designe le numero du cube, les deux joueurs + resolvent le meme melange, et le resultat influe ensuite selon + le mode choisi. +
++ La partie se termine uniquement par echec et mat ou abandon, + jamais par simple chute au temps ou depassement d'une partie. +
+
+
+
+
+
+ Materiel commun
+Base officielle
+-
+
- Un echiquier et un jeu de pieces reglementaires. +
- Huit Rubik's Cubes 3x3, soit quatre par joueur. +
- Des caches opaques numerotes de 1 a 4. +
- Des melanges strictement identiques pour chaque numero. +
- L'application officielle ChessCubing. +
- Un arbitre pour piloter le match et les transitions. +
+
+
+
+
+ Arbitrage
+Check-list terrain
+-
+
- Verifier la presence des huit cubes et des caches numerotes. +
- Confirmer des melanges identiques sous chaque numero. +
- Preparer l'echiquier et la variante dans l'application. +
- Controler le tirage au sort avant la premiere partie. +
- Declencher chaque phase cube au bon moment. +
- Surveiller le respect du plafond de 120 s en mode Time. +
+
+
+
+
+ Formats officiels
+Twice et Time, cote a cote
++ Les deux formats partagent les parties et la phase cube, mais leur + logique d'avantage differe completement. +
+
+
+
+
+
+
+
+
+ Version V2
+
+
+ ChessCubing Twice
++ Le gagnant du cube obtient l'initiative sur la partie suivante, + avec une regle de double coup encadree. +
+
+ Partie : 180 s
+ Temps par coup : 20 s max
+ FAST / FREEZE / MASTERS : 6 / 8 / 10
+
+
+
+
+
+ Debut et fin des parties
+-
+
- Les Blancs commencent la partie 1. +
- Aucun double coup n'est possible a la partie 1. +
- Une partie s'arrete a 180 s ou quand les deux quotas sont atteints. +
- Il est interdit de finir une partie avec un roi en echec. +
- Si le dernier coup donne echec, les coups necessaires pour parer sont joues hors quota. +
+
+
+ Phase cube
+-
+
- Le numero du cube est designe par l'application. +
- Les deux joueurs recoivent un melange identique. +
- Le joueur le plus rapide gagne la phase cube. +
- En cas d'egalite parfaite, la phase cube est rejouee. +
- Le gagnant du cube commence la partie suivante. +
+ Double coup V2
+ Condition stricte
+
+
+ + Le gagnant du cube ne doit pas avoir joue le dernier coup de + la partie precedente. Le premier coup est gratuit, non compte, + peut capturer mais ne peut pas donner echec. Le second compte + comme premier coup de la partie, peut donner echec, mais ne peut + capturer qu'un pion ou une piece mineure. +
+
+
+ Temps par coup et fin de partie
+-
+
- Chaque coup doit etre joue en 20 secondes maximum. +
- En depassement, le coup est perdu et compte dans le quota. +
- Sur le premier coup d'un double coup, le depassement annule l'avantage. +
- Sur le second coup d'un double coup, le coup est perdu et comptabilise. +
- La partie se termine uniquement par mat ou abandon. +
+ Version V1
+
+
+ ChessCubing Time
++ Ici, la phase cube n'offre pas l'initiative mais modifie les + chronos selon une alternance bloc - puis bloc +. +
+
+ Temps initial : 10 min / joueur
+ Block : 180 s
+ Cap cube pris en compte : 120 s
+
+
+
+
+
+ Structure temporelle
+-
+
- La structure des Blocks est identique a celle du Twice. +
- Les quotas de coups restent les memes : 6, 8 ou 10. +
- Chaque Block est suivi d'une phase cube obligatoire. +
- Le trait est conserve apres la phase cube. +
- Aucun systeme de priorite ou de double coup n'existe. +
+
+ Block impair
+ Bloc -
+
+
+ Block pair
+ Bloc +
+
+
+
+ + Le temps de resolution du cube est retire du chrono du + joueur concerne, avec un plafond de 120 secondes. +
++ Le temps de resolution du cube est ajoute au chrono adverse, + lui aussi plafonne a 120 secondes. +
+
+
+
+ Exemples officiels
+-
+
- Bloc - : 35 s retire 35 s a son propre chrono. +
- Bloc - : 110 s retire 110 s a son propre chrono. +
- Bloc + : 25 s ajoute 25 s au chrono adverse. +
- Bloc + : 150 s ajoute 120 s au chrono adverse. +
+ Reprise du jeu
+ Pas de coup pendant le cube
+
+
+ + Aucun coup ne peut etre joue pendant la phase cube. Des que + les deux resolutions sont terminees, les chronos sont ajustes + et la partie reprend immediatement. +
+
+
+ Fin de partie et vigilance
+-
+
- La partie s'arrete uniquement par mat ou abandon volontaire. +
- L'arbitre surveille le chronometrage exact et le plafond de 120 s. +
- L'absence de priorite et de double coup fait partie des points cles du mode. +
+
+
+
+
+
+ Sources
+Documents officiels
++ Cette synthese reprend les versions officielles actuellement + embarquees dans l'application. +
+
+
+
+
+
+
+ ChessCubing Arena
+ Chargement de l'application Blazor...
+
+
+ Une erreur inattendue est survenue.
+ Recharger
+ x
+
+
+
+
+
diff --git a/ChessCubing.App/wwwroot/js/chesscubing-interop.js b/ChessCubing.App/wwwroot/js/chesscubing-interop.js
new file mode 100644
index 0000000..c1de074
--- /dev/null
+++ b/ChessCubing.App/wwwroot/js/chesscubing-interop.js
@@ -0,0 +1,200 @@
+(() => {
+ const assetTokenStorageKey = "chesscubing-arena-asset-token";
+ let viewportStarted = false;
+ let audioContext = null;
+
+ function syncViewportHeight() {
+ const visibleHeight = window.visualViewport?.height ?? window.innerHeight;
+ const viewportTopOffset = window.visualViewport?.offsetTop ?? 0;
+ const viewportHeight = Math.max(
+ visibleHeight + viewportTopOffset,
+ window.innerHeight,
+ document.documentElement.clientHeight,
+ );
+
+ document.documentElement.style.setProperty("--app-visible-height", `${Math.round(visibleHeight)}px`);
+ document.documentElement.style.setProperty("--app-viewport-top", `${Math.round(viewportTopOffset)}px`);
+ document.documentElement.style.setProperty("--app-viewport-height", `${Math.round(viewportHeight)}px`);
+ }
+
+ function startViewport() {
+ if (viewportStarted) {
+ return;
+ }
+
+ viewportStarted = true;
+ syncViewportHeight();
+ window.addEventListener("load", syncViewportHeight);
+ window.addEventListener("resize", syncViewportHeight);
+ window.addEventListener("scroll", syncViewportHeight, { passive: true });
+ window.addEventListener("pageshow", syncViewportHeight);
+ window.addEventListener("orientationchange", syncViewportHeight);
+ window.visualViewport?.addEventListener("resize", syncViewportHeight);
+ window.visualViewport?.addEventListener("scroll", syncViewportHeight);
+ window.setTimeout(syncViewportHeight, 0);
+ window.setTimeout(syncViewportHeight, 150);
+ window.setTimeout(syncViewportHeight, 400);
+ window.requestAnimationFrame(() => window.requestAnimationFrame(syncViewportHeight));
+ }
+
+ function getAudioContext() {
+ const AudioContextClass = window.AudioContext || window.webkitAudioContext;
+ if (!AudioContextClass) {
+ return null;
+ }
+
+ if (!audioContext) {
+ try {
+ audioContext = new AudioContextClass();
+ } catch {
+ return null;
+ }
+ }
+
+ return audioContext;
+ }
+
+ function primeAudio() {
+ const context = getAudioContext();
+ if (!context || context.state === "running") {
+ return;
+ }
+
+ context.resume().catch(() => undefined);
+ }
+
+ function playCubePhaseAlert() {
+ primeAudio();
+ const context = getAudioContext();
+ if (!context || context.state !== "running") {
+ return false;
+ }
+
+ const pattern = [
+ { frequency: 740, offset: 0, duration: 0.12, gain: 0.035 },
+ { frequency: 988, offset: 0.18, duration: 0.12, gain: 0.04 },
+ { frequency: 1318, offset: 0.36, duration: 0.2, gain: 0.05 },
+ ];
+ const startAt = context.currentTime + 0.02;
+
+ pattern.forEach(({ frequency, offset, duration, gain }) => {
+ const oscillator = context.createOscillator();
+ const envelope = context.createGain();
+ const toneStartAt = startAt + offset;
+
+ oscillator.type = "triangle";
+ oscillator.frequency.setValueAtTime(frequency, toneStartAt);
+ envelope.gain.setValueAtTime(0.0001, toneStartAt);
+ envelope.gain.exponentialRampToValueAtTime(gain, toneStartAt + 0.02);
+ envelope.gain.exponentialRampToValueAtTime(0.0001, toneStartAt + duration);
+
+ oscillator.connect(envelope);
+ envelope.connect(context.destination);
+ oscillator.start(toneStartAt);
+ oscillator.stop(toneStartAt + duration + 0.03);
+ });
+
+ return true;
+ }
+
+ window.chesscubingPage = {
+ setBodyState(page, bodyClass) {
+ if (page) {
+ document.body.dataset.page = page;
+ } else {
+ delete document.body.dataset.page;
+ }
+
+ document.body.className = bodyClass || "";
+ },
+ };
+
+ window.chesscubingViewport = {
+ start: startViewport,
+ };
+
+ window.chesscubingStorage = {
+ getMatchState(storageKey, windowNameKey) {
+ try {
+ const raw = window.localStorage.getItem(storageKey);
+ if (raw) {
+ return raw;
+ }
+ } catch {
+ }
+
+ try {
+ if (!window.name || !window.name.startsWith(windowNameKey)) {
+ return null;
+ }
+
+ return window.name.slice(windowNameKey.length);
+ } catch {
+ return null;
+ }
+ },
+
+ setMatchState(storageKey, windowNameKey, value) {
+ try {
+ window.name = `${windowNameKey}${value}`;
+ } catch {
+ }
+
+ try {
+ window.localStorage.setItem(storageKey, value);
+ } catch {
+ }
+ },
+
+ clearMatchState(storageKey) {
+ try {
+ window.localStorage.removeItem(storageKey);
+ } catch {
+ }
+
+ try {
+ window.name = "";
+ } catch {
+ }
+ },
+ };
+
+ window.chesscubingAudio = {
+ prime: primeAudio,
+ playCubePhaseAlert,
+ };
+
+ window.chesscubingBrowser = {
+ async forceRefresh(path) {
+ const refreshToken = `${Date.now()}`;
+
+ try {
+ window.sessionStorage.setItem(assetTokenStorageKey, refreshToken);
+ } catch {
+ }
+
+ if ("caches" in window) {
+ try {
+ const cacheKeys = await window.caches.keys();
+ await Promise.all(cacheKeys.map((cacheKey) => window.caches.delete(cacheKey)));
+ } catch {
+ }
+ }
+
+ if ("serviceWorker" in navigator) {
+ try {
+ const registrations = await navigator.serviceWorker.getRegistrations();
+ await Promise.all(registrations.map((registration) => registration.update().catch(() => undefined)));
+ await Promise.all(registrations.map((registration) => registration.unregister().catch(() => undefined)));
+ } catch {
+ }
+ }
+
+ const targetUrl = new URL(path, window.location.href);
+ targetUrl.searchParams.set("refresh", refreshToken);
+ window.location.replace(targetUrl.toString());
+ },
+ };
+
+ startViewport();
+})();
diff --git a/Dockerfile b/Dockerfile
index 239d315..a6b54c8 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,4 +1,15 @@
+FROM mcr.microsoft.com/dotnet/sdk:10.0 AS build
+WORKDIR /src
+
+COPY ChessCubing.App/ChessCubing.App.csproj ChessCubing.App/
+RUN dotnet restore ChessCubing.App/ChessCubing.App.csproj
+
+COPY ChessCubing.App/ ChessCubing.App/
+COPY ethan/ ethan/
+COPY favicon.png logo.png transparent.png styles.css site.webmanifest ChessCubing_Time_Reglement_Officiel_V1-1.pdf ChessCubing_Twice_Reglement_Officiel_V2-1.pdf ./
+RUN dotnet publish ChessCubing.App/ChessCubing.App.csproj -c Release -o /app/publish
+
FROM nginx:1.27-alpine
COPY nginx.conf /etc/nginx/conf.d/default.conf
-COPY . /usr/share/nginx/html
+COPY --from=build /app/publish/wwwroot /usr/share/nginx/html
diff --git a/README.md b/README.md
index af0ccc7..ccdd607 100644
--- a/README.md
+++ b/README.md
@@ -1,25 +1,35 @@
# ChessCubing Arena
-Application web mobile-first pour téléphone et tablette, pensée comme application officielle de suivi de match pour `ChessCubing Twice` et `ChessCubing Time`.
+Application web mobile-first pour telephone et tablette, maintenant migree vers **Blazor WebAssembly en C# / .NET 10**.
-## Ce que fait cette première version
+## Ce que fait l'application
- configure une rencontre `Twice` ou `Time`
-- sépare l'application en pages dédiées : configuration, phase chrono, phase cube
-- permet de définir librement le temps de partie et le temps par coup
+- separe l'experience en pages dediees : configuration, phase chrono, phase cube
+- permet de definir librement le temps de partie et le temps par coup
- suit les quotas `FAST`, `FREEZE` et `MASTERS`
-- orchestre la phase cube avec désignation du cube, capture des temps et préparation de la partie suivante
+- orchestre la phase cube avec designation du cube, capture des temps et preparation de la partie suivante
- applique la logique du double coup V2 en `Twice`
- applique les ajustements `bloc -` et `bloc +` en `Time` avec plafond de 120 s pris en compte
-- conserve un historique local dans le navigateur
-- propose une page chrono pensée pour le téléphone avec deux grandes zones tactiles, une par joueur
-- ouvre automatiquement la page cube dès que la phase chess de la partie est terminée
+- conserve l'etat du match dans le navigateur
+- propose une page chrono pensee pour le telephone avec deux grandes zones tactiles
+- ouvre automatiquement la page cube des que la phase chess est terminee
-## Hypothèse de produit
+## Architecture
-Cette version est volontairement construite comme une **application d'arbitrage et de direction de match** autour d'un vrai échiquier physique, et non comme un moteur d'échecs complet. C'est le choix le plus fidèle aux règlements fournis et le plus réaliste pour une utilisation immédiate en club, en démonstration ou en tournoi.
+Le coeur de l'application se trouve dans `ChessCubing.App/`.
-## Démarrage avec Docker
+- `ChessCubing.App/Pages/` : pages Razor du site et de l'application
+- `ChessCubing.App/Services/MatchEngine.cs` : logique metier des matchs
+- `ChessCubing.App/Services/MatchStore.cs` : persistance navigateur
+- `ChessCubing.App/wwwroot/` : assets statiques, manifeste, PDFs, appli Ethan
+- `docker-compose.yml` + `Dockerfile` : build Blazor puis service via nginx
+
+Le projet continue a exposer les routes historiques `index.html`, `application.html`, `chrono.html`, `cube.html` et `reglement.html`.
+
+## Demarrage local
+
+### Avec Docker
```bash
docker compose down
@@ -28,16 +38,23 @@ docker compose up -d --build
L'application est ensuite disponible sur `http://localhost:8080`.
-## Déploiement dans un LXC Proxmox
+### Avec .NET 10
-Deux scripts Bash permettent de créer un conteneur LXC Debian sur Proxmox puis de le mettre à jour depuis Git.
+```bash
+dotnet restore ChessCubing.App/ChessCubing.App.csproj
+dotnet run --project ChessCubing.App/ChessCubing.App.csproj
+```
-Prérequis sur la machine qui lance les scripts :
+## Deploiement dans un LXC Proxmox
+
+Deux scripts Bash permettent de creer un conteneur LXC Debian sur Proxmox puis de le mettre a jour depuis Git.
+
+Prerrequis sur la machine qui lance les scripts :
- en mode distant : `ssh` et `sshpass`
-- en mode local sur l'hôte Proxmox : aucun paquet supplémentaire n'est installé sur Proxmox
+- en mode local sur l'hote Proxmox : aucun paquet supplementaire n'est installe sur Proxmox
-Le déploiement dans le LXC n'utilise pas Docker. Le script installe `nginx`, `git` et `rsync` dans le conteneur, clone le dépôt principal, synchronise aussi le projet d'Ethan, puis publie uniquement les fichiers web.
+Le deploiement dans le LXC n'utilise pas Docker. Le script clone le depot, publie l'application Blazor dans le conteneur, puis sert le resultat via `nginx`.
### Installer un nouveau LXC
@@ -54,38 +71,7 @@ Version "curl | bash" :
bash -c "$(curl -fsSL https://git.jeannerot.fr/christophe/chesscubing/raw/branch/main/install-chesscubing-proxmox.sh)"
```
-Cette version pose les questions nécessaires si les variables d'environnement ne sont pas déjà définies.
-
-Si elle est lancée directement sur l'hôte Proxmox, elle passe automatiquement en mode local :
-
-- elle ne demande ni serveur, ni login, ni mot de passe SSH
-- elle n'installe rien sur l'hôte Proxmox
-- elle crée uniquement le LXC puis installe les dépendances dans ce LXC
-
-Valeurs par défaut utiles :
-
-- LXC nommé `chesscubing-web`
-- IP du LXC en `dhcp`
-- branche Git `main`
-- dépôt `https://git.jeannerot.fr/christophe/chesscubing.git`
-- dépôt Ethan `https://git.jeannerot.fr/Mineloulou/Chesscubing.git`
-
-Options utiles si besoin :
-
-- `--ctid 120`
-- `--lxc-ip 192.168.1.50/24 --gateway 192.168.1.1`
-- `--template-storage local`
-- `--rootfs-storage local-lvm`
-- `--branch main`
-- `--ethan-branch main`
-
-À la fin, le script affiche :
-
-- le `CTID`
-- le mot de passe `root` du LXC
-- l'URL probable du site
-
-### Mettre à jour depuis Git
+### Mettre a jour depuis Git
```bash
./scripts/update-proxmox-lxc.sh \
@@ -101,30 +87,14 @@ Version "curl | bash" :
bash -c "$(curl -fsSL https://git.jeannerot.fr/christophe/chesscubing/raw/branch/main/update-chesscubing-proxmox.sh)"
```
-Sur l'hôte Proxmox, cette commande met à jour le LXC local sans passer par SSH.
-Par défaut, elle cible le conteneur `chesscubing-web` sans demander le `CTID`.
+## Fichiers cles
-On peut aussi cibler le conteneur par nom si on n'a pas le `CTID` :
-
-```bash
-./scripts/update-proxmox-lxc.sh \
- --proxmox-host 10.0.0.2 \
- --proxmox-user root@pam \
- --proxmox-password 'secret' \
- --hostname chesscubing-web
-```
-
-Le script de mise à jour exécute un `git pull --ff-only` pour le dépôt principal et le dépôt d'Ethan dans le conteneur, puis republie les fichiers statiques via `nginx`, y compris la route `/ethan/`.
-
-## Fichiers clés
-
-- `index.html` : page d'accueil du site
-- `application.html` : page de configuration et reprise de match
-- `chrono.html` : page dédiée à la phase chrono
-- `cube.html` : page dédiée à la phase cube
-- `reglement.html` : page éditoriale qui présente le règlement officiel
-- `styles.css` : design mobile/tablette
-- `app.js` : logique de match et arbitrage
-- `docker-compose.yml` + `Dockerfile` : exécution locale
-- `scripts/install-proxmox-lxc.sh` : création et déploiement d'un LXC Proxmox
-- `scripts/update-proxmox-lxc.sh` : mise à jour d'un LXC existant depuis Git
+- `ChessCubing.App/Pages/Home.razor` : page d'accueil du site
+- `ChessCubing.App/Pages/ApplicationPage.razor` : configuration et reprise de match
+- `ChessCubing.App/Pages/ChronoPage.razor` : phase chrono
+- `ChessCubing.App/Pages/CubePage.razor` : phase cube
+- `ChessCubing.App/Pages/RulesPage.razor` : synthese du reglement
+- `ChessCubing.App/Services/MatchEngine.cs` : regles de jeu et transitions
+- `docker-compose.yml` + `Dockerfile` : execution locale
+- `scripts/install-proxmox-lxc.sh` : creation et deploiement d'un LXC Proxmox
+- `scripts/update-proxmox-lxc.sh` : mise a jour d'un LXC existant depuis Git
diff --git a/scripts/install-proxmox-lxc.sh b/scripts/install-proxmox-lxc.sh
index 746f75f..ba7b6c1 100755
--- a/scripts/install-proxmox-lxc.sh
+++ b/scripts/install-proxmox-lxc.sh
@@ -339,10 +339,10 @@ done
pct exec "$ctid" -- true >/dev/null 2>&1 || die "Le LXC n'est pas joignable apres le demarrage."
-printf 'Installation de nginx, git et rsync dans le conteneur...\n'
-ct_exec "apt-get update && apt-get install -y ca-certificates git nginx rsync"
+printf 'Installation de nginx, git, rsync et des prerequis de build dans le conteneur...\n'
+ct_exec "apt-get update && apt-get install -y ca-certificates curl gpg git nginx rsync"
-ct_exec "install -d -m 0755 /opt/chesscubing/repo /opt/chesscubing/ethan-repo /var/www/chesscubing/current"
+ct_exec "install -d -m 0755 /opt/chesscubing/repo /opt/chesscubing/ethan-repo /opt/chesscubing/publish /var/www/chesscubing/current"
printf 'Clonage du depot %s...\n' "$repo_url"
ct_exec "if [ ! -d /opt/chesscubing/repo/.git ]; then \
@@ -363,11 +363,30 @@ trap 'printf \"Erreur: echec de la commande [%s] a la ligne %s.\\n\" \"\$BASH_CO
main_repo_dir='/opt/chesscubing/repo'
ethan_repo_dir='/opt/chesscubing/ethan-repo'
+publish_root='/opt/chesscubing/publish'
web_root='/var/www/chesscubing/current'
main_branch=\"\${1:-${repo_branch}}\"
ethan_repo_url='${ethan_repo_url}'
ethan_branch='${ethan_repo_branch}'
+ensure_dotnet_sdk() {
+ if command -v dotnet >/dev/null 2>&1; then
+ return 0
+ fi
+
+ apt-get update
+ apt-get install -y ca-certificates curl gpg
+
+ if [[ ! -f /etc/apt/sources.list.d/microsoft-prod.list ]]; then
+ curl -fsSL https://packages.microsoft.com/config/debian/12/packages-microsoft-prod.deb -o /tmp/packages-microsoft-prod.deb
+ dpkg -i /tmp/packages-microsoft-prod.deb
+ rm -f /tmp/packages-microsoft-prod.deb
+ fi
+
+ apt-get update
+ apt-get install -y dotnet-sdk-10.0
+}
+
sync_git_repo() {
local repo_dir=\"\$1\"
local repo_url=\"\$2\"
@@ -401,6 +420,15 @@ sync_git_repo() {
git clone --branch \"\$branch\" --single-branch \"\$repo_url\" \"\$repo_dir\"
}
+publish_blazor_app() {
+ local repo_dir=\"\$1\"
+ local output_dir=\"\$2\"
+
+ ensure_dotnet_sdk
+ rm -rf \"\$output_dir\"
+ dotnet publish \"\$repo_dir/ChessCubing.App/ChessCubing.App.csproj\" -c Release -o \"\$output_dir\"
+}
+
publish_static_tree() {
local source_dir=\"\$1\"
local destination_dir=\"\$2\"
@@ -428,17 +456,12 @@ publish_static_tree() {
sync_git_repo \"\$main_repo_dir\" '${repo_url}' \"\$main_branch\" 'principal'
sync_git_repo \"\$ethan_repo_dir\" \"\$ethan_repo_url\" \"\$ethan_branch\" 'Ethan'
-asset_version=\"\$(git -C \"\$main_repo_dir\" rev-parse --short HEAD)-\$(git -C \"\$ethan_repo_dir\" rev-parse --short HEAD)\"
+install -d -m 0755 \"\$web_root\" \"\$publish_root\"
-install -d -m 0755 \"\$web_root\"
-
-publish_static_tree \"\$main_repo_dir\" \"\$web_root\"
+publish_blazor_app \"\$main_repo_dir\" \"\$publish_root/main\"
+rsync -a --delete \"\$publish_root/main/wwwroot/\" \"\$web_root/\"
publish_static_tree \"\$ethan_repo_dir\" \"\$web_root/ethan\"
-while IFS= read -r -d '' html_file; do
- LC_ALL=C LANG=C ASSET_VERSION=\"\$asset_version\" perl -0pi -e 's{((?:href|src)=\")(?!https?://|data:|//)([^\"?]+?\.(?:css|js|mjs|png|jpg|jpeg|svg|webp|ico|pdf|webmanifest))(?:\?[^\"]*)?(\")}{\$1 . \$2 . \"?v=\" . \$ENV{ASSET_VERSION} . \$3}ge' \"\$html_file\"
-done < <(find \"\$web_root\" -type f -name '*.html' -print0)
-
chown -R www-data:www-data \"\$web_root\"
nginx -t
diff --git a/scripts/update-proxmox-lxc.sh b/scripts/update-proxmox-lxc.sh
index 561a9ad..7669cbd 100755
--- a/scripts/update-proxmox-lxc.sh
+++ b/scripts/update-proxmox-lxc.sh
@@ -181,11 +181,30 @@ trap 'printf \"Erreur: echec de la commande [%s] a la ligne %s.\\n\" \"\$BASH_CO
main_repo_dir='/opt/chesscubing/repo'
ethan_repo_dir='/opt/chesscubing/ethan-repo'
+publish_root='/opt/chesscubing/publish'
web_root='/var/www/chesscubing/current'
main_branch=\"\${1:-${repo_branch}}\"
ethan_repo_url='${ethan_repo_url}'
ethan_branch='${ethan_repo_branch}'
+ensure_dotnet_sdk() {
+ if command -v dotnet >/dev/null 2>&1; then
+ return 0
+ fi
+
+ apt-get update
+ apt-get install -y ca-certificates curl gpg
+
+ if [[ ! -f /etc/apt/sources.list.d/microsoft-prod.list ]]; then
+ curl -fsSL https://packages.microsoft.com/config/debian/12/packages-microsoft-prod.deb -o /tmp/packages-microsoft-prod.deb
+ dpkg -i /tmp/packages-microsoft-prod.deb
+ rm -f /tmp/packages-microsoft-prod.deb
+ fi
+
+ apt-get update
+ apt-get install -y dotnet-sdk-10.0
+}
+
sync_git_repo() {
local repo_dir=\"\$1\"
local repo_url=\"\$2\"
@@ -219,6 +238,15 @@ sync_git_repo() {
git clone --branch \"\$branch\" --single-branch \"\$repo_url\" \"\$repo_dir\"
}
+publish_blazor_app() {
+ local repo_dir=\"\$1\"
+ local output_dir=\"\$2\"
+
+ ensure_dotnet_sdk
+ rm -rf \"\$output_dir\"
+ dotnet publish \"\$repo_dir/ChessCubing.App/ChessCubing.App.csproj\" -c Release -o \"\$output_dir\"
+}
+
publish_static_tree() {
local source_dir=\"\$1\"
local destination_dir=\"\$2\"
@@ -246,17 +274,12 @@ publish_static_tree() {
sync_git_repo \"\$main_repo_dir\" '' \"\$main_branch\" 'principal'
sync_git_repo \"\$ethan_repo_dir\" \"\$ethan_repo_url\" \"\$ethan_branch\" 'Ethan'
-asset_version=\"\$(git -C \"\$main_repo_dir\" rev-parse --short HEAD)-\$(git -C \"\$ethan_repo_dir\" rev-parse --short HEAD)\"
+install -d -m 0755 \"\$web_root\" \"\$publish_root\"
-install -d -m 0755 \"\$web_root\"
-
-publish_static_tree \"\$main_repo_dir\" \"\$web_root\"
+publish_blazor_app \"\$main_repo_dir\" \"\$publish_root/main\"
+rsync -a --delete \"\$publish_root/main/wwwroot/\" \"\$web_root/\"
publish_static_tree \"\$ethan_repo_dir\" \"\$web_root/ethan\"
-while IFS= read -r -d '' html_file; do
- LC_ALL=C LANG=C ASSET_VERSION=\"\$asset_version\" perl -0pi -e 's{((?:href|src)=\")(?!https?://|data:|//)([^\"?]+?\.(?:css|js|mjs|png|jpg|jpeg|svg|webp|ico|pdf|webmanifest))(?:\?[^\"]*)?(\")}{\$1 . \$2 . \"?v=\" . \$ENV{ASSET_VERSION} . \$3}ge' \"\$html_file\"
-done < <(find \"\$web_root\" -type f -name '*.html' -print0)
-
chown -R www-data:www-data \"\$web_root\"
nginx -t