Hex — 05: מכינים את המחשב

/** Copies the board and turn for a candidate move. */
public HexGame copy() {
    HexGame copy = new HexGame(size);
    System.arraycopy(cells, 0, copy.cells, 0, cells.length);
    copy.currentPlayer = currentPlayer;
    copy.winner = winner;
    copy.moveCount = moveCount;
    return copy;
}

/** Lists every empty cell while the game is active. */
public List<Move> legalMoves() {
    if (isOver()) return Collections.emptyList();

    List<Move> moves = new ArrayList<>(cells.length - moveCount);
    for (int i = 0; i < cells.length; i++) {
        if (cells[i] == EMPTY) moves.add(new Move(i / size, i % size));
    }
    return moves;
}

/** Encodes each cell as [own stone, opponent stone, direction]. */
public float[] encodeForCurrentPlayer() {
    float[] encoded = new float[cells.length * 3];
    int opponent = otherPlayer(currentPlayer);
    float direction = currentPlayer == RED ? 1.0f : 0.0f;

    for (int i = 0; i < cells.length; i++) {
        int base = i * 3;
        encoded[base] = cells[i] == currentPlayer ? 1.0f : 0.0f;
        encoded[base + 1] = cells[i] == opponent ? 1.0f : 0.0f;
        encoded[base + 2] = direction;
    }
    return encoded;
}

/** A move stores only its board row and column. */
public static final class Move {
    public final int row;
    public final int column;

    public Move(int row, int column) {
        this.row = row;
        this.column = column;
    }
}

package com.example.hex;

/** Gives one position value from the point of view of the player to move. */
public interface ValueModel {
    /** Evaluates one board encoding with the fixed shape 7x7x3. */
    float evaluate(float[] encodedBoard);
}

package com.example.hex;

import android.content.Context;

import com.google.ai.edge.litert.CompiledModel;
import com.google.ai.edge.litert.LiteRtException;
import com.google.ai.edge.litert.TensorBuffer;

import java.util.List;

/** Runs the 7x7 value model with LiteRT. */
public final class TfliteValueModel implements ValueModel, AutoCloseable {
    /** Compiled once when the computer player is selected. */
    private final CompiledModel compiledModel;
    /** Reused for every candidate position. */
    private final List<TensorBuffer> inputBuffers;
    /** Receives the predicted value. */
    private final List<TensorBuffer> outputBuffers;

    /** Load the model and create buffers for its first signature. */
    public TfliteValueModel(Context context) throws LiteRtException {
        compiledModel = CompiledModel.create(context.getAssets(),
                "hex_value_v1.tflite", CompiledModel.Options.getCPU());
        inputBuffers = compiledModel.createInputBuffers(0);
        outputBuffers = compiledModel.createOutputBuffers(0);
    }

    @Override
    public float evaluate(float[] encodedBoard) {
        try {
            // Copy the encoded board into the model's input.
            inputBuffers.get(0).writeFloat(encodedBoard);
            // Run the model using its first signature.
            compiledModel.run(inputBuffers, outputBuffers, 0);
            // Read the predicted value.
            return outputBuffers.get(0).readFloat()[0];
        } catch (LiteRtException exception) {
            throw new IllegalStateException("Could not evaluate the model", exception);
        }
    }

    @Override
    public void close() {
        // Release buffers before the compiled model that created them.
        for (TensorBuffer buffer : inputBuffers) buffer.close();
        for (TensorBuffer buffer : outputBuffers) buffer.close();
        compiledModel.close();
    }
}