<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android">

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.App">

        <!-- המסך היחיד של המשחק. exported + intent-filter: זו נקודת הכניסה מהלאנצ'ר -->
        <activity
            android:name=".MainActivity"
            android:exported="true"
            android:screenOrientation="unspecified">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

    </application>
</manifest>

plugins {
    id 'com.android.application'
}

android {
    namespace 'com.example.hebrewwordle'
    compileSdk 34

    defaultConfig {
        applicationId "com.example.hebrewwordle"
        minSdk 24
        targetSdk 34
        versionCode 1
        versionName "1.0"
        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }

    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }

    compileOptions {
        sourceCompatibility JavaVersion.VERSION_11
        targetCompatibility JavaVersion.VERSION_11
    }
}

dependencies {
    implementation 'androidx.appcompat:appcompat:1.7.0'
    implementation 'com.google.android.material:material:1.12.0'
    implementation 'androidx.constraintlayout:constraintlayout:2.1.4'

    testImplementation 'junit:junit:4.13.2'
}

private static final String TAG = "LIFECYCLE";

@Override
protected void onStart() {
    super.onStart();
    Log.d(TAG, "onStart - המסך נהיה גלוי");
}

@Override
protected void onResume() {
    super.onResume();
    Log.d(TAG, "onResume - המסך בחזית ומגיב ללחיצות");
}

@Override
protected void onPause() {
    super.onPause();
    Log.d(TAG, "onPause - משהו כיסה אותי, אני מאבד פוקוס");
}

@Override
protected void onStop() {
    super.onStop();
    Log.d(TAG, "onStop - אני כבר לא גלוי בכלל");
}

@Override
protected void onDestroy() {
    super.onDestroy();
    Log.d(TAG, "onDestroy - הפעילות נהרסת (סיבוב מסך או סגירה)");
}

<?xml version="1.0" encoding="utf-8"?>
<!--
    שלד המסך: ConstraintLayout אחד שמחזיק ארבעה אזורים מלמעלה למטה.
    הלוח עצמו (boardContainer) ריק ב-XML: שלושים האריחים נבנים בקוד ב-MainActivity.
-->
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:padding="@dimen/screen_padding">

    <TextView
        android:id="@+id/txtTitle"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:gravity="center"
        android:text="@string/title"
        android:textColor="@color/primary"
        android:textSize="28sp"
        android:textStyle="bold"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

    <TextView
        android:id="@+id/txtMessage"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:gravity="center"
        android:text="@string/msg_start"
        android:textColor="@color/ink"
        android:textSize="16sp"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@id/txtTitle" />

    <LinearLayout
        android:id="@+id/boardContainer"
        android:layout_width="wrap_content"
        android:layout_height="0dp"
        android:gravity="center"
        android:orientation="vertical"
        app:layout_constraintBottom_toTopOf="@id/btnNewGame"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@id/txtMessage" />

    <Button
        android:id="@+id/btnNewGame"
        style="@style/Widget.Material3.Button.OutlinedButton"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/new_game"
        app:layout_constraintBottom_toTopOf="@id/keyboard"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent" />

    <!-- שימו לב: ה-id שניתן ל-include דורס את ה-id של שורש התבנית המוכללת.
         לכן בקוד מחפשים R.id.keyboard - ה-id שכתוב כאן, לא זה שבתוך keyboard.xml -->
    <include
        android:id="@+id/keyboard"
        layout="@layout/keyboard"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent" />

</androidx.constraintlayout.widget.ConstraintLayout>

private TextView[][] tiles;                 // [שורה][עמודה] - 6×5
private LinearLayout boardContainer;
private TextView txtMessage;

/**
 * בונה 6 שורות של 5 אריחים בקוד. כל אריח הוא TextView רגיל עם רקע מ-drawable.
 * למה בקוד ולא ב-XML? כי 30 רכיבים זהים ב-XML הם 30 הזדמנויות לטעות העתקה,
 * ואילו לולאה כפולה היא 8 שורות.
 */
private void buildBoard() {
    Resources res = getResources();
    int size = res.getDimensionPixelSize(R.dimen.tile_size);
    int margin = res.getDimensionPixelSize(R.dimen.tile_margin);

    tiles = new TextView[WordleGame.MAX_GUESSES][WordleGame.WORD_LENGTH];
    boardContainer.removeAllViews();

    for (int row = 0; row < WordleGame.MAX_GUESSES; row++) {
        LinearLayout rowLayout = new LinearLayout(this);
        rowLayout.setOrientation(LinearLayout.HORIZONTAL);
        rowLayout.setGravity(Gravity.CENTER);

        for (int col = 0; col < WordleGame.WORD_LENGTH; col++) {
            TextView tile = new TextView(this);
            LinearLayout.LayoutParams lp = new LinearLayout.LayoutParams(size, size);
            lp.setMargins(margin, margin, margin, margin);
            tile.setLayoutParams(lp);
            tile.setGravity(Gravity.CENTER);
            tile.setTextSize(android.util.TypedValue.COMPLEX_UNIT_PX, res.getDimension(R.dimen.tile_text));
            tile.setTypeface(null, android.graphics.Typeface.BOLD);
            paintTile(tile, LetterState.EMPTY);

            tiles[row][col] = tile;
            rowLayout.addView(tile);
        }
        boardContainer.addView(rowLayout);
    }
}

/** צובע אריח אחד לפי מצב. הצבעים עצמם יושבים ב-colors.xml וב-drawable. */
private void paintTile(TextView tile, LetterState state) {
    int bg;
    int textColor = R.color.tile_text_light;
    switch (state) {
        case CORRECT: bg = R.drawable.tile_correct; break;
        case PRESENT: bg = R.drawable.tile_present; break;
        case ABSENT:  bg = R.drawable.tile_absent;  break;
        default:      bg = R.drawable.tile_empty;   textColor = R.color.tile_text; break;
    }
    tile.setBackground(ContextCompat.getDrawable(this, bg));
    tile.setTextColor(ContextCompat.getColor(this, textColor));
}

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="app_name">ווֹרדל בעברית</string>
    <string name="title">ווֹרדל בעברית</string>
    <string name="msg_start">נחשו מילה בת 5 אותיות. יש לכם 6 ניסיונות.</string>
    <string name="msg_too_short">צריך 5 אותיות לפני הבדיקה</string>
    <string name="msg_win">כל הכבוד! ניחשתם ב-%1$d ניסיונות</string>
    <string name="msg_lose">נגמרו הניסיונות. המילה הייתה: %1$s</string>
    <string name="msg_guesses_left">נשארו %1$d ניסיונות</string>
    <string name="key_delete">מחק</string>
    <string name="key_check">בדיקה</string>
    <string name="new_game">משחק חדש</string>
</resources>

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <color name="primary">#538D4E</color>
    <color name="on_primary">#FFFFFF</color>
    <color name="secondary">#B59F3B</color>
    <color name="on_secondary">#FFFFFF</color>
    <color name="white">#FFFFFF</color>
    <color name="ink">#1A1A2E</color>

    <!-- ארבעת מצבי האות -->
    <color name="tile_empty">#FFFFFF</color>
    <color name="tile_border">#9AA0A6</color>
    <color name="tile_absent">#787C7E</color>
    <color name="tile_present">#C9B458</color>
    <color name="tile_correct">#6AAA64</color>
    <color name="tile_text">#1A1A2E</color>
    <color name="tile_text_light">#FFFFFF</color>

    <color name="key_bg">#D3D6DA</color>
    <color name="screen_bg">#F7F7F7</color>
</resources>

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <dimen name="tile_size">52dp</dimen>
    <dimen name="tile_margin">3dp</dimen>
    <dimen name="tile_text">26sp</dimen>
    <dimen name="key_height">46dp</dimen>
    <dimen name="key_margin">2dp</dimen>
    <dimen name="key_text">16sp</dimen>
    <dimen name="screen_padding">12dp</dimen>
</resources>

<?xml version="1.0" encoding="utf-8"?>
<!-- רקע אריח במצב correct -->
<shape xmlns:android="http://schemas.android.com/apk/res/android" android:shape="rectangle">
    <solid android:color="@color/tile_correct" />
    <stroke android:width="2dp" android:color="@color/tile_correct" />
    <corners android:radius="4dp" />
</shape>

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <style name="Theme.App" parent="Theme.Material3.DayNight.NoActionBar">
        <item name="colorPrimary">@color/primary</item>
        <item name="colorOnPrimary">@color/on_primary</item>
        <item name="colorSecondary">@color/secondary</item>
        <item name="colorOnSecondary">@color/on_secondary</item>
        <item name="android:statusBarColor">@color/primary</item>
        <item name="android:windowBackground">@color/screen_bg</item>
    </style>

    <!-- מקש אות במקלדת: כל 27 המקשים חולקים את הסגנון הזה -->
    <style name="KeyButton" parent="Widget.Material3.Button.TextButton">
        <item name="android:layout_width">0dp</item>
        <item name="android:layout_height">@dimen/key_height</item>
        <item name="android:layout_weight">1</item>
        <item name="android:layout_margin">@dimen/key_margin</item>
        <item name="android:minWidth">0dp</item>
        <item name="android:insetTop">0dp</item>
        <item name="android:insetBottom">0dp</item>
        <item name="android:padding">0dp</item>
        <item name="android:textSize">@dimen/key_text</item>
        <item name="android:textColor">@color/ink</item>
        <item name="backgroundTint">@color/key_bg</item>
        <item name="cornerRadius">6dp</item>
        <item name="android:onClick">onLetterKey</item>
    </style>
</resources>

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <!-- מאגר המילים: כל מילה בת 5 אותיות בדיוק. אפשר להוסיף ולמחוק מילים כאן בלי לגעת בקוד. -->
    <string-array name="words">
        <item>שולחן</item>
        <item>מקלדת</item>
        <item>תלמיד</item>
        <item>מורים</item>
        <item>ספרים</item>
        <item>חברים</item>
        <item>ילדים</item>
        <item>בניין</item>
        <item>מכונה</item>
        <item>מכשיר</item>
        <item>טלפון</item>
        <item>מחברת</item>
        <item>אבטיח</item>
        <item>אגסים</item>
        <item>שמשיה</item>
        <item>מטריה</item>
        <item>מחשבה</item>
        <item>ספינה</item>
        <item>שמיים</item>
        <item>מדינה</item>
        <item>גבינה</item>
        <item>עוגיה</item>
        <item>עוגות</item>
        <item>פלאפל</item>
        <item>חומוס</item>
        <item>סלטים</item>
        <item>בקבוק</item>
        <item>כוסות</item>
        <item>שמיכה</item>
        <item>מדפים</item>
        <item>דלתות</item>
        <item>קירות</item>
        <item>מנהלת</item>
        <item>רופאה</item>
        <item>שוטרת</item>
        <item>כבאים</item>
        <item>נהגים</item>
        <item>כלבים</item>
        <item>חתולה</item>
        <item>סוסים</item>
        <item>ציפור</item>
        <item>נמלים</item>
        <item>פילים</item>
        <item>קופים</item>
        <item>אריות</item>
        <item>נמרים</item>
        <item>זברות</item>
        <item>פרחים</item>
        <item>יערות</item>
        <item>נהרות</item>
        <item>אגמים</item>
        <item>חופים</item>
        <item>גשמים</item>
        <item>רוחות</item>
        <item>עננים</item>
        <item>שלגים</item>
        <item>תוכנה</item>
        <item>חומרה</item>
        <item>מסכים</item>
        <item>רמקול</item>
        <item>מצלמה</item>
        <item>מדפסת</item>
        <item>עברית</item>
        <item>ערבית</item>
        <item>כימיה</item>
        <item>שיעור</item>
        <item>הפסקה</item>
        <item>בחינה</item>
        <item>שאלות</item>
        <item>תשובה</item>
        <item>תעודה</item>
        <item>חידות</item>
        <item>קלפים</item>
        <item>שירים</item>
        <item>ריקוד</item>
        <item>גיטרה</item>
        <item>תופים</item>
        <item>כינור</item>
        <item>חברות</item>
        <item>משפחה</item>
        <item>הורים</item>
        <item>אחיות</item>
        <item>דודים</item>
        <item>תיקים</item>
        <item>מגפים</item>
        <item>חולצה</item>
        <item>שניות</item>
        <item>ארוחה</item>
        <item>לחמים</item>
        <item>ביצים</item>
        <item>ספורט</item>
        <item>שחייה</item>
        <item>גלידה</item>
        <item>סיפור</item>
        <item>משורר</item>
        <item>עיתון</item>
        <item>מספרה</item>
        <item>כרטיס</item>
        <item>תחנות</item>
        <item>רכבות</item>
        <item>טייסת</item>
        <item>קניון</item>
        <item>שכונה</item>
        <item>רמזור</item>
        <item>גשרים</item>
    </string-array>
</resources>

<?xml version="1.0" encoding="utf-8"?>
<!--
    המקלדת העברית. כל מקש הוא Button עם style="@style/KeyButton", והסגנון מכיל
    android:onClick="onLetterKey" - כלומר כל 27 המקשים קוראים לאותה מתודה בפעילות
    (דרך 1 לטיפול באירועים: מאזין ב-XML).
    הסידור הוא לפי המקלדת הפיזית, מימין לשמאל, כי supportsRtl="true".
-->
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/keyboard"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:orientation="vertical">

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal">
        <Button style="@style/KeyButton" android:text="ק" />
        <Button style="@style/KeyButton" android:text="ר" />
        <Button style="@style/KeyButton" android:text="א" />
        <Button style="@style/KeyButton" android:text="ט" />
        <Button style="@style/KeyButton" android:text="ו" />
        <Button style="@style/KeyButton" android:text="ן" />
        <Button style="@style/KeyButton" android:text="ם" />
        <Button style="@style/KeyButton" android:text="פ" />
    </LinearLayout>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal">
        <Button style="@style/KeyButton" android:text="ש" />
        <Button style="@style/KeyButton" android:text="ד" />
        <Button style="@style/KeyButton" android:text="ג" />
        <Button style="@style/KeyButton" android:text="כ" />
        <Button style="@style/KeyButton" android:text="ע" />
        <Button style="@style/KeyButton" android:text="י" />
        <Button style="@style/KeyButton" android:text="ח" />
        <Button style="@style/KeyButton" android:text="ל" />
        <Button style="@style/KeyButton" android:text="ך" />
        <Button style="@style/KeyButton" android:text="ף" />
    </LinearLayout>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal">
        <Button style="@style/KeyButton" android:text="ז" />
        <Button style="@style/KeyButton" android:text="ס" />
        <Button style="@style/KeyButton" android:text="ב" />
        <Button style="@style/KeyButton" android:text="ה" />
        <Button style="@style/KeyButton" android:text="נ" />
        <Button style="@style/KeyButton" android:text="מ" />
        <Button style="@style/KeyButton" android:text="צ" />
        <Button style="@style/KeyButton" android:text="ת" />
        <Button style="@style/KeyButton" android:text="ץ" />
    </LinearLayout>

    <!-- שני המקשים האלה לא מקבלים onClick ב-XML בכוונה: הם מחוברים מהקוד (דרכים 2 ו-3) -->
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal">
        <Button
            android:id="@+id/btnDelete"
            style="@style/KeyButton"
            android:layout_weight="2"
            android:onClick="@null"
            android:text="@string/key_delete" />
        <Button
            android:id="@+id/btnCheck"
            style="@style/KeyButton"
            android:layout_weight="2"
            android:onClick="@null"
            android:backgroundTint="@color/primary"
            android:textColor="@color/white"
            android:text="@string/key_check" />
    </LinearLayout>
</LinearLayout>

/**
 * דרך 1: מאזין ב-XML. כל 27 מקשי האותיות מצהירים android:onClick="onLetterKey"
 * (דרך הסגנון KeyButton), ולכן אנדרואיד מחפש כאן מתודה public בשם הזה
 * שמקבלת View אחד. הטקסט של הכפתור הוא האות עצמה.
 */
public void onLetterKey(View view) {
    if (game.isOver()) return;
    if (current.length() >= WordleGame.WORD_LENGTH) return;

    char letter = ((Button) view).getText().charAt(0);
    current.append(letter);
    int row = game.getGuessCount();
    tiles[row][current.length() - 1].setText(String.valueOf(letter));
}

/**
 * דרך 2: הפעילות עצמה מממשת OnClickListener. כפתור "מחק" מקבל this כמאזין
 * (ראו wireButtons), ולכן הלחיצה מגיעה לכאן. כשיש כמה כפתורים עם אותו מאזין,
 * מבדילים ביניהם לפי view.getId().
 */
@Override
public void onClick(View view) {
    if (view.getId() == R.id.btnDelete) {
        if (game.isOver() || current.length() == 0) return;
        current.deleteCharAt(current.length() - 1);
        int row = game.getGuessCount();
        tiles[row][current.length()].setText("");
    }
}

/**
 * דרך 3: מחלקה פנימית. למחלקה פנימית (לא static) יש גישה לכל השדות של הפעילות
 * - game, tiles, current - בלי להעביר אותם כפרמטרים.
 */
private class CheckListener implements View.OnClickListener {
    @Override
    public void onClick(View view) {
        if (game.isOver()) return;
        if (current.length() < WordleGame.WORD_LENGTH) {
            txtMessage.setText(R.string.msg_too_short);
            return;
        }
        Guess guess = game.submit(current.toString());
        int row = game.getGuessCount() - 1;
        showGuess(row, guess);
        current.setLength(0);
        updateMessage();
    }
}

package com.example.hebrewwordle.model;

/**
 * מצב של אות אחת בניחוש. כל אריח על הלוח וכל מקש במקלדת מקבל אחד מארבעת המצבים.
 * enum הוא "מחלקה עם מספר קבוע של עצמים" - אין מצב חמישי, והמהדר שומר על זה בשבילנו.
 */
public enum LetterState {
    EMPTY,    // עדיין לא נבדק
    ABSENT,   // האות לא נמצאת במילה (אפור)
    PRESENT,  // האות נמצאת במילה אבל במקום אחר (צהוב)
    CORRECT   // האות נמצאת בדיוק במקום הזה (ירוק)
}

package com.example.hebrewwordle.model;

/**
 * ניחוש אחד: המילה שהוקלדה והמצב של כל אות בה.
 * העצם הזה "קפוא" (immutable): אחרי שנוצר אי אפשר לשנות אותו - כך שורה שכבר נבדקה
 * לעולם לא משתנה בטעות.
 */
public class Guess {

    private final String word;
    private final LetterState[] states;

    public Guess(String word, LetterState[] states) {
        this.word = word;
        this.states = states;
    }

    public String getWord() {
        return word;
    }

    public LetterState getState(int index) {
        return states[index];
    }

    public LetterState[] getStates() {
        return states.clone();   // עותק, כדי שאף אחד בחוץ לא ישנה את המערך הפנימי
    }

    /** ניחוש "מנצח" הוא ניחוש שכל אותיותיו ירוקות. */
    public boolean isAllCorrect() {
        for (LetterState s : states) {
            if (s != LetterState.CORRECT) return false;
        }
        return true;
    }
}

package com.example.hebrewwordle.model;

import java.util.ArrayList;
import java.util.List;

/**
 * חוקי המשחק, ב-Java טהור. המחלקה הזאת לא יודעת שקיים אנדרואיד:
 * אין כאן TextView, אין Button, אין צבעים. בגלל זה אפשר לבדוק אותה ב-JUnit
 * על המחשב, בלי אמולטור.
 */
public class WordleGame {

    public static final int WORD_LENGTH = 5;
    public static final int MAX_GUESSES = 6;

    private final String secret;
    private final List<Guess> guesses = new ArrayList<>();

    public WordleGame(String secret) {
        if (secret == null || secret.length() != WORD_LENGTH) {
            throw new IllegalArgumentException("המילה הסודית חייבת להיות בת " + WORD_LENGTH + " אותיות");
        }
        this.secret = secret;
    }

    /**
     * בודק ניחוש ומוסיף אותו לרשימה.
     * @throws IllegalArgumentException אם אורך המילה שגוי
     * @throws IllegalStateException אם המשחק כבר נגמר
     */
    public Guess submit(String word) {
        if (isOver()) {
            throw new IllegalStateException("המשחק נגמר");
        }
        if (word == null || word.length() != WORD_LENGTH) {
            throw new IllegalArgumentException("הניחוש חייב להיות בן " + WORD_LENGTH + " אותיות");
        }
        Guess guess = new Guess(word, evaluate(secret, word));
        guesses.add(guess);
        return guess;
    }

    /**
     * לב המשחק: משווה ניחוש למילה הסודית ומחזיר מצב לכל אות.
     * שני מעברים: קודם מסמנים ירוקים, ורק אחר כך צהובים - אחרת אות כפולה
     * בניחוש הייתה "גונבת" צהוב שלא מגיע לה.
     */
    public static LetterState[] evaluate(String secret, String word) {
        LetterState[] result = new LetterState[WORD_LENGTH];
        char[] s = normalize(secret).toCharArray();
        char[] g = normalize(word).toCharArray();
        boolean[] usedInSecret = new boolean[WORD_LENGTH];

        // מעבר 1: ירוקים
        for (int i = 0; i < WORD_LENGTH; i++) {
            if (g[i] == s[i]) {
                result[i] = LetterState.CORRECT;
                usedInSecret[i] = true;
            }
        }
        // מעבר 2: צהובים ואפורים
        for (int i = 0; i < WORD_LENGTH; i++) {
            if (result[i] != null) continue;          // כבר ירוק
            result[i] = LetterState.ABSENT;
            for (int j = 0; j < WORD_LENGTH; j++) {
                if (!usedInSecret[j] && g[i] == s[j]) {
                    result[i] = LetterState.PRESENT;
                    usedInSecret[j] = true;         // כל אות במילה הסודית "משלמת" פעם אחת
                    break;
                }
            }
        }
        return result;
    }

    /**
     * אותיות סופיות נחשבות כאות הרגילה: מי שהקליד "מ" במקום "ם" עדיין צודק לגבי האות.
     */
    public static String normalize(String word) {
        return word.replace('ך', 'כ')
                   .replace('ם', 'מ')
                   .replace('ן', 'נ')
                   .replace('ף', 'פ')
                   .replace('ץ', 'צ');
    }

    public boolean isWon() {
        return !guesses.isEmpty() && guesses.get(guesses.size() - 1).isAllCorrect();
    }

    public boolean isLost() {
        return !isWon() && guesses.size() >= MAX_GUESSES;
    }

    public boolean isOver() {
        return isWon() || isLost();
    }

    public String getSecret() {
        return secret;
    }

    public List<Guess> getGuesses() {
        return new ArrayList<>(guesses);
    }

    public int getGuessCount() {
        return guesses.size();
    }
}

package com.example.hebrewwordle.model;

import static org.junit.Assert.*;
import static com.example.hebrewwordle.model.LetterState.*;

import org.junit.Test;

public class WordleGameTest {

    @Test
    public void allCorrectWhenGuessEqualsSecret() {
        LetterState[] r = WordleGame.evaluate("שולחן", "שולחן");
        assertArrayEquals(new LetterState[]{CORRECT, CORRECT, CORRECT, CORRECT, CORRECT}, r);
    }

    @Test
    public void letterInWrongPlaceIsPresent() {
        // ל נמצאת במילה הסודית במקום 3, בניחוש היא במקום 1
        LetterState[] r = WordleGame.evaluate("שולחן", "למדים");
        assertEquals(PRESENT, r[0]);
        assertEquals(ABSENT, r[1]);
    }

    @Test
    public void duplicateLetterIsCountedOnce() {
        // במילה הסודית יש ת אחת. בניחוש יש שתיים: רק אחת מקבלת צבע.
        LetterState[] r = WordleGame.evaluate("תלמיד", "תתתתת");
        assertEquals(CORRECT, r[0]);
        for (int i = 1; i < 5; i++) assertEquals(ABSENT, r[i]);
    }

    @Test
    public void greenWinsOverYellowForDuplicates() {
        // ב"ספינה" יש י אחת, באינדקס 2. בניחוש "ימיים" יש י באינדקסים 0, 2, 3.
        // ה-י היחידה של המילה הסודית "משולמת" לירוק באינדקס 2, ולכן שתי האחרות אפורות.
        LetterState[] r = WordleGame.evaluate("ספינה", "ימיים");
        assertEquals(ABSENT, r[0]);
        assertEquals(CORRECT, r[2]);
        assertEquals(ABSENT, r[3]);
    }

    @Test
    public void finalLettersMatchRegularLetters() {
        LetterState[] r = WordleGame.evaluate("שולחן", "שולחנ");
        assertEquals(CORRECT, r[4]);
    }

    @Test
    public void winOnSixthGuess() {
        WordleGame game = new WordleGame("שולחן");
        for (int i = 0; i < 5; i++) game.submit("תלמיד");
        assertFalse(game.isOver());
        game.submit("שולחן");
        assertTrue(game.isWon());
        assertTrue(game.isOver());
    }

    @Test
    public void loseAfterSixWrongGuesses() {
        WordleGame game = new WordleGame("שולחן");
        for (int i = 0; i < 6; i++) game.submit("תלמיד");
        assertTrue(game.isLost());
        assertFalse(game.isWon());
    }

    @Test(expected = IllegalArgumentException.class)
    public void shortGuessIsRejected() {
        new WordleGame("שולחן").submit("שול");
    }

    @Test(expected = IllegalStateException.class)
    public void noGuessAfterGameOver() {
        WordleGame game = new WordleGame("שולחן");
        game.submit("שולחן");
        game.submit("תלמיד");
    }
}

private WordleGame game;
private final StringBuilder current = new StringBuilder();   // האותיות שהוקלדו בשורה הנוכחית
private final Map<Character, Button> keyByLetter = new HashMap<>();

private void startNewGame() {
    String[] words = getResources().getStringArray(R.array.words);
    String secret = words[new Random().nextInt(words.length)];
    game = new WordleGame(secret);
    current.setLength(0);
    clearBoard();
    txtMessage.setText(R.string.msg_start);
    Log.d(TAG, "משחק חדש. המילה הסודית: " + secret);   // רק לפיתוח - מוחקים לפני הגשה
}

private void clearBoard() {
    for (TextView[] row : tiles) {
        for (TextView tile : row) {
            tile.setText("");
            paintTile(tile, LetterState.EMPTY);
        }
    }
    for (Button key : keyByLetter.values()) {
        key.setBackgroundTintList(ContextCompat.getColorStateList(this, R.color.key_bg));
        key.setTextColor(ContextCompat.getColor(this, R.color.ink));
    }
}

/** מציג ניחוש שנבדק בשורה נתונה: אותיות, צבעי אריחים וצבעי מקשים. */
private void showGuess(int row, Guess guess) {
    String word = guess.getWord();
    for (int col = 0; col < WordleGame.WORD_LENGTH; col++) {
        tiles[row][col].setText(String.valueOf(word.charAt(col)));
        paintTile(tiles[row][col], guess.getState(col));
        paintKey(word.charAt(col), guess.getState(col));
    }
}

/** מקש עולה בדרגה בלבד: אפור -> צהוב -> ירוק, אף פעם לא יורד. */
private void paintKey(char letter, LetterState state) {
    Button key = keyByLetter.get(letter);
    if (key == null) return;
    LetterState old = (LetterState) key.getTag();
    if (old != null && old.ordinal() >= state.ordinal()) return;
    key.setTag(state);

    int color;
    switch (state) {
        case CORRECT: color = R.color.tile_correct; break;
        case PRESENT: color = R.color.tile_present; break;
        default:      color = R.color.tile_absent;  break;
    }
    key.setBackgroundTintList(ContextCompat.getColorStateList(this, color));
    key.setTextColor(ContextCompat.getColor(this, R.color.tile_text_light));
}

private void updateMessage() {
    if (game.isWon()) {
        txtMessage.setText(getString(R.string.msg_win, game.getGuessCount()));
    } else if (game.isLost()) {
        txtMessage.setText(getString(R.string.msg_lose, game.getSecret()));
    } else {
        txtMessage.setText(getString(R.string.msg_guesses_left,
                WordleGame.MAX_GUESSES - game.getGuessCount()));
    }
}

/** מחבר את שלושת הכפתורים שלא מקבלים onClick ב-XML, כל אחד בדרך אחרת. */
private void wireButtons() {
    findViewById(R.id.btnDelete).setOnClickListener(this);                 // דרך 2
    findViewById(R.id.btnCheck).setOnClickListener(new CheckListener());   // דרך 3

    // דרך 4: מאזין אנונימי - מחלקה בלי שם שנכתבת במקום, מתאימה לקוד קצר של פעם אחת
    findViewById(R.id.btnNewGame).setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            startNewGame();
        }
    });
}

/** אוסף את כל מקשי האותיות למפה, כדי שנוכל לצבוע מקש לפי האות שלו. */
private void collectKeyboardButtons() {
    keyByLetter.clear();
    LinearLayout keyboard = findViewById(R.id.keyboard);
    for (int r = 0; r < keyboard.getChildCount(); r++) {
        View rowView = keyboard.getChildAt(r);
        if (!(rowView instanceof LinearLayout)) continue;
        LinearLayout row = (LinearLayout) rowView;
        for (int i = 0; i < row.getChildCount(); i++) {
            View child = row.getChildAt(i);
            if (child instanceof Button && child.getId() == View.NO_ID) {
                Button key = (Button) child;
                keyByLetter.put(key.getText().charAt(0), key);
            }
        }
    }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);      // תמיד קוראים ל-super קודם
    setContentView(R.layout.activity_main);
    Log.d(TAG, "onCreate - המסך נבנה. savedInstanceState=" + (savedInstanceState == null ? "null" : "יש מצב שמור"));

    txtMessage = findViewById(R.id.txtMessage);
    boardContainer = findViewById(R.id.boardContainer);
    buildBoard();                            // שלב 5
    collectKeyboardButtons();                // שלב 9
    wireButtons();                           // שלבים 8-9

    if (savedInstanceState == null) {
        startNewGame();                      // הפעלה רגילה
    } else {
        restoreGame(savedInstanceState);     // שלב 10: חזרה מסיבוב מסך
    }
}

// מפתחות ל-Bundle של שמירת המצב
private static final String KEY_SECRET = "secret";
private static final String KEY_GUESSES = "guesses";
private static final String KEY_CURRENT = "current";

/**
 * נקרא לפני שהפעילות נהרסת בגלל שינוי תצורה (סיבוב מסך, שינוי שפה...).
 * שומרים רק את המינימום שממנו אפשר לשחזר הכול: המילה הסודית, רשימת הניחושים
 * והאותיות שהוקלדו בשורה הנוכחית. את הצבעים לא שומרים - מחשבים אותם מחדש.
 */
@Override
protected void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
    outState.putString(KEY_SECRET, game.getSecret());
    ArrayList<String> words = new ArrayList<>();
    for (Guess g : game.getGuesses()) words.add(g.getWord());
    outState.putStringArrayList(KEY_GUESSES, words);
    outState.putString(KEY_CURRENT, current.toString());
    Log.d(TAG, "onSaveInstanceState - נשמרו " + words.size() + " ניחושים");
}

/** בונה מחדש את המשחק מה-Bundle ומצייר את הלוח. */
private void restoreGame(Bundle state) {
    String secret = state.getString(KEY_SECRET);
    List<String> words = state.getStringArrayList(KEY_GUESSES);
    String typed = state.getString(KEY_CURRENT, "");

    game = new WordleGame(secret);
    clearBoard();
    if (words != null) {
        for (int row = 0; row < words.size(); row++) {
            Guess guess = game.submit(words.get(row));   // הבדיקה מחדש נותנת שוב את הצבעים
            showGuess(row, guess);
        }
    }
    current.setLength(0);
    current.append(typed);
    int row = game.getGuessCount();
    for (int col = 0; col < typed.length() && row < WordleGame.MAX_GUESSES; col++) {
        tiles[row][col].setText(String.valueOf(typed.charAt(col)));
    }
    updateMessage();
    Log.d(TAG, "restoreGame - שוחזרו " + (words == null ? 0 : words.size()) + " ניחושים");
}