last commit implemented js file

MainPage/younes/Streichholzreatsel.css

@@ -161,7 +161,6 @@
       user-select:none;
     }
 
-    /* 7-seg digit container */
     .digit{
       position:relative;
       width: 110px;
@@ -173,7 +172,6 @@
       flex:0 0 auto;
     }
 
-    /* Match segments */
     .seg{
       position:absolute;
       width: var(--matchL);
@@ -186,7 +184,6 @@
     .seg:hover{ filter: brightness(1.1); }
     .seg:active{ transform: translateY(1px); }
 
-    /* removed (invisible/white) */
     .seg.removed{
       background: rgba(255,255,255,0) !important;
       box-shadow:none;
@@ -194,20 +191,13 @@
       pointer-events:none;
     }
 
-    /* segment positions */
-    /* a (top) */
+    
     .seg.a{ top: 16px; left: 21px; }
-    /* b (top-right) */
     .seg.b{ top: 32px; left: 73px; width: var(--matchW); height: var(--matchL); }
-    /* c (bottom-right) */
     .seg.c{ top: 92px; left: 73px; width: var(--matchW); height: var(--matchL); }
-    /* d (bottom) */
     .seg.d{ top: 146px; left: 21px; }
-    /* e (bottom-left) */
     .seg.e{ top: 92px; left: 23px; width: var(--matchW); height: var(--matchL); }
-    /* f (top-left) */
     .seg.f{ top: 32px; left: 23px; width: var(--matchW); height: var(--matchL); }
-    /* g (middle) */
     .seg.g{ top: 81px; left: 21px; }
 
     .side{

MainPage/younes/Streichholzreatsel.html

@@ -14,7 +14,7 @@
         <div class="title">
           <h1>Allumettes Equation Infinite Levels</h1>
           <div class="sub">Klicke auf die Streichhölzer, um sie zu entfernen (sie werden weiß bzw. unsichtbar).
-Mache die Gleichung wahr, indem du genau die vorgegebene Anzahl entfernst.</div>
+ Mache die Gleichung wahr, indem du genau die vorgegebene Anzahl entfernst.</div>
         </div>
         <div class="controls">
           <button id="btnReset">Reset level</button>
@@ -39,7 +39,7 @@ Mache die Gleichung wahr, indem du genau die vorgegebene Anzahl entfernst.</div>
 
         <div class="footerNote">
           Goal: lösch <b id="goalN">N</b> sodass die Gleichung <b>WAHR</b> wird.
-Es ist nur das Entfernen erlaubt (kein Hinzufügen). Die Ziffern bestehen aus 7 Segmenten.
+ Es ist nur das Entfernen erlaubt (kein Hinzufügen). Die Ziffern bestehen aus 7 Segmenten.
 Der Generator garantiert, dass jedes Level lösbar ist (unendlich viele Level).
         </div>
       </div>

MainPage/younes/Streichholzreatsel.js

@@ -12,16 +12,16 @@ function maskFromSegments(list){
 
 
 const DIGIT_MASK = [
-  maskFromSegments(["a","b","c","d","e","f"]),       // 0
-  maskFromSegments(["b","c"]),                       // 1
-  maskFromSegments(["a","b","d","e","g"]),           // 2
-  maskFromSegments(["a","b","c","d","g"]),           // 3
-  maskFromSegments(["b","c","f","g"]),               // 4
-  maskFromSegments(["a","c","d","f","g"]),           // 5
-  maskFromSegments(["a","c","d","e","f","g"]),       // 6
-  maskFromSegments(["a","b","c"]),                   // 7
-  maskFromSegments(["a","b","c","d","e","f","g"]),   // 8
-  maskFromSegments(["a","b","c","d","f","g"])        // 9
+  maskFromSegments(["a","b","c","d","e","f"]),       
+  maskFromSegments(["b","c"]),                      
+  maskFromSegments(["a","b","d","e","g"]),           
+  maskFromSegments(["a","b","c","d","g"]),           
+  maskFromSegments(["b","c","f","g"]),              
+  maskFromSegments(["a","c","d","f","g"]),           
+  maskFromSegments(["a","c","d","e","f","g"]),      
+  maskFromSegments(["a","b","c"]),                   
+  maskFromSegments(["a","b","c","d","e","f","g"]),   
+  maskFromSegments(["a","b","c","d","f","g"])        
 ];
 
 
@@ -56,13 +56,12 @@ function pick(arr){ return arr[randInt(0, arr.length-1)]; }
 
 let level = 1;
 let targetRemove = 2;
-let current = null;   // {A,B,C} shown digits
-let solution = null;  // {A,B,C} target digits after removals
+let current = null;   
+let solution = null; 
 let removedSoFar = 0;
 
-// Each segment element knows which digit/segment it belongs to
-// We'll store: digitIndex (0..2 for A,B,C) and segName
-let removedSet = new Set(); // keys like "0-a" meaning digit0 seg a removed
+
+let removedSet = new Set(); 
 
 const elEq = document.getElementById("equation");
 const elRemovedGrid = document.getElementById("removedGrid");
@@ -80,13 +79,12 @@ document.getElementById("btnNew").addEventListener("click", () => {
   generateLevel();
 });
 document.getElementById("btnReset").addEventListener("click", () => {
-  // reset current level state but keep the same puzzle
+  
   resetPlayState();
   renderEquation();
   updateTruthUI();
 });
 
-// Turn mask into a set of active segment names
 function segmentsFromMask(mask){
   const set = new Set();
   for(let i=0;i<7;i++){
@@ -95,13 +93,11 @@ function segmentsFromMask(mask){
   return set;
 }
 
-// Compute displayed digit masks after removals
 function displayedMaskForDigit(digitValue, digitIndex){
   let mask = DIGIT_MASK[digitValue];
   for(const s of segNames){
     const key = digitIndex + "-" + s;
     if(removedSet.has(key)){
-      // remove the segment if it exists
       mask &= ~(1 << SEG[s]);
     }
   }
@@ -110,11 +106,11 @@ function displayedMaskForDigit(digitValue, digitIndex){
 
 function displayedDigitValue(digitValue, digitIndex){
   const mask = displayedMaskForDigit(digitValue, digitIndex);
-  return MASK_TO_DIGIT.has(mask) ? MASK_TO_DIGIT.get(mask) : null; // null = invalid digit shape
+  return MASK_TO_DIGIT.has(mask) ? MASK_TO_DIGIT.get(mask) : null; 
 }
 
 function equationIsTrue(){
-  // get displayed digits; if any invalid => false
+
   const a = displayedDigitValue(current.A, 0);
   const b = displayedDigitValue(current.B, 1);
   const c = displayedDigitValue(current.C, 2);
@@ -128,7 +124,7 @@ function updateTruthUI(){
   elTruthText.textContent = ok ? "Equation is TRUE" : "Equation is FALSE";
 }
 
-// Reset removals and removed pile
+
 function resetPlayState(){
   removedSet.clear();
   removedSoFar = 0;
@@ -141,7 +137,6 @@ function syncRemovedCounts(){
   elPileCount.textContent = String(removedSoFar);
 }
 
-// Render a digit as a 7-seg container with clickable match segments
 function renderDigit(digitValue, digitIndex, color){
   const digit = document.createElement("div");
   digit.className = "digit";
@@ -150,7 +145,7 @@ function renderDigit(digitValue, digitIndex, color){
   const baseSegs = segmentsFromMask(baseMask);
 
   for(const s of segNames){
-    if(!baseSegs.has(s)) continue; // no stick here in the original digit
+    if(!baseSegs.has(s)) continue; 
 
     const seg = document.createElement("div");
     seg.className = "seg " + s;
@@ -161,16 +156,15 @@ function renderDigit(digitValue, digitIndex, color){
 
     seg.addEventListener("click", () => {
       if(removedSet.has(key)) return;
-      // If player already removed target count, block further removes
       if(removedSoFar >= targetRemove) return;
 
       removedSet.add(key);
       removedSoFar++;
 
-      // visually remove from equation (turn white/invisible)
+
       seg.classList.add("removed");
 
-      // add to removed pile as a small colored bar
+      
       const clone = document.createElement("div");
       clone.className = "removedSeg";
       clone.style.background = color;
@@ -179,12 +173,11 @@ function renderDigit(digitValue, digitIndex, color){
       syncRemovedCounts();
       updateTruthUI();
 
-      // win condition
       if(removedSoFar === targetRemove){
         if(equationIsTrue()){
-          elHint.innerHTML = "✅ <b>Solved!</b> You removed exactly the target and made the equation true. Click <b>New level</b>.";
+          elHint.innerHTML = "<b>Solved!</b> You removed exactly the target and made the equation true. Click <b>New level</b>.";
         } else {
-          elHint.innerHTML = "❌ <b>Not solved.</b> You used all removals but the equation isn’t true. Click <b>Reset level</b> to try again.";
+          elHint.innerHTML = " <b>Not solved.</b> You used all removals but the equation isn’t true. Click <b>Reset level</b> to try again.";
         }
       }
     });
@@ -197,7 +190,6 @@ function renderDigit(digitValue, digitIndex, color){
 function renderEquation(){
   elEq.innerHTML = "";
 
-  // color palette (A,B,C different)
   const colors = [
     "linear-gradient(180deg,#ff6b6b,#d64545)",
     "linear-gradient(180deg,#6bcBff,#3a7bd5)",
@@ -233,78 +225,57 @@ function renderEquation(){
   updateTruthUI();
 }
 
-// -------- Infinite level generation algorithm --------
-//
-// We generate a "solution equation" (A_s + B_s = C_s) valid in 0..9.
-// Then we create the "shown equation" by turning each solution digit into a SUPERSET digit
-// (i.e., add extra segments) so that the player can remove sticks to get back to the solution.
-// We also ensure the shown equation is NOT already true.
-// We finally choose a removal target N = total segments added across the 3 digits (or some bounded version).
-//
-// This guarantees solvable by removals only, for infinite levels.
-// -----------------------------------------------------
+
 
 function generateLevel(){
   resetPlayState();
 
-  // Level difficulty curve: increase target removals slowly, but never explode.
-  // You can tweak this. Keeps it playable while still "infinite".
+ 
   targetRemove = Math.min(2 + Math.floor(Math.log2(level + 1)), 6);
 
-  // Find a puzzle with exactly targetRemove removals needed to reach a true equation.
-  // We'll attempt random constructions until we hit the required N.
+
   let tries = 0;
   while(true){
     tries++;
     if(tries > 5000){
-      // fallback: relax target a bit if extremely unlucky
       targetRemove = Math.max(2, targetRemove - 1);
       tries = 0;
     }
 
-    // 1) Pick a valid solution equation (A_s + B_s = C_s)
     const As = randInt(0, 9);
     const Bs = randInt(0, 9);
     const Cs = As + Bs;
     if(Cs < 0 || Cs > 9) continue;
 
-    // 2) For each digit, choose a "shown digit" that can be reduced to solution digit by removing sticks.
-    //    i.e., shownMask is a superset of solutionMask.
+    
     const Achoices = superDigits(As);
     const Bchoices = superDigits(Bs);
     const Cchoices = superDigits(Cs);
 
-    // pick a random superset (could be itself)
     const Ashow = pick(Achoices);
     const Bshow = pick(Bchoices);
     const Cshow = pick(Cchoices);
 
-    // Count how many removals required to go from shown -> solution (sum removed bits)
     const need =
       popcount(DIGIT_MASK[Ashow] ^ DIGIT_MASK[As]) +
       popcount(DIGIT_MASK[Bshow] ^ DIGIT_MASK[Bs]) +
       popcount(DIGIT_MASK[Cshow] ^ DIGIT_MASK[Cs]);
 
-    // Require exactly targetRemove removals
     if(need !== targetRemove) continue;
 
-    // 3) Ensure the shown equation is not already true.
-    // (It might accidentally be true with different digit meanings.)
+   
     const shownTrue = (Ashow + Bshow) === Cshow;
     if(shownTrue) continue;
 
-    // Accept puzzle
     solution = { A: As, B: Bs, C: Cs };
     current  = { A: Ashow, B: Bshow, C: Cshow };
     break;
   }
 
-  // UI labels
   elLvl.textContent = String(level);
   elTarget.textContent = String(targetRemove);
   elGoalN.textContent = String(targetRemove);
 
-  // Friendly hint (don’t reveal exact digits)
   elHint.innerHTML =
     `Level <b>${level}</b>: Make the equation true by removing <b>${targetRemove}</b> match(es). ` +
     `You can only remove sticks (click them).`;
@@ -314,19 +285,15 @@ function generateLevel(){
   updateTruthUI();
 }
 
-// Returns digits whose mask is a SUPERSET of base digit's mask (i.e., can remove to base)
 function superDigits(baseDigit){
   const base = DIGIT_MASK[baseDigit];
   const res = [];
   for(let d=0; d<=9; d++){
     const m = DIGIT_MASK[d];
-    // m must contain all base segments
     if((m & base) === base){
       res.push(d);
     }
   }
   return res;
 }
-
-// Start
 generateLevel();