mirror of
https://github.com/portapack-mayhem/mayhem-firmware.git
synced 2026-08-20 14:39:01 +00:00
Battleship (#2720)
* Made the Battleship 2P 2PP game - FSK is wip * Using POCSAG
This commit is contained in:
RocketGod
GitHub
@@ -0,0 +1,822 @@
|
||||
/*
|
||||
* ------------------------------------------------------------
|
||||
* | Made by RocketGod |
|
||||
* | Find me at https://betaskynet.com |
|
||||
* | Argh matey! |
|
||||
* ------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#include "ui_battleship.hpp"
|
||||
#include "portapack_shared_memory.hpp"
|
||||
#include "utility.hpp"
|
||||
#include "modems.hpp"
|
||||
#include "bch_code.hpp"
|
||||
|
||||
using namespace portapack;
|
||||
using namespace modems;
|
||||
|
||||
namespace ui::external_app::battleship {
|
||||
|
||||
// POCSAG address for battleship game messages
|
||||
constexpr uint32_t BATTLESHIP_BASE_ADDRESS = 1000000;
|
||||
constexpr uint32_t RED_TEAM_ADDRESS = BATTLESHIP_BASE_ADDRESS + 1;
|
||||
constexpr uint32_t BLUE_TEAM_ADDRESS = BATTLESHIP_BASE_ADDRESS + 2;
|
||||
|
||||
BattleshipView::BattleshipView(NavigationView& nav)
|
||||
: nav_{nav} {
|
||||
baseband::run_image(portapack::spi_flash::image_tag_pocsag2);
|
||||
|
||||
add_children({&rssi,
|
||||
&field_frequency,
|
||||
&text_status,
|
||||
&text_score,
|
||||
&button_red_team,
|
||||
&button_blue_team,
|
||||
&button_rotate,
|
||||
&button_place,
|
||||
&button_fire,
|
||||
&button_menu});
|
||||
|
||||
text_score.hidden(true);
|
||||
button_rotate.hidden(true);
|
||||
button_place.hidden(true);
|
||||
button_fire.hidden(true);
|
||||
button_menu.hidden(true);
|
||||
|
||||
field_frequency.set_value(DEFAULT_FREQUENCY);
|
||||
field_frequency.on_change = [this](rf::Frequency freq) {
|
||||
tx_frequency = freq;
|
||||
rx_frequency = freq;
|
||||
if (!is_transmitting) {
|
||||
receiver_model.set_target_frequency(rx_frequency);
|
||||
}
|
||||
};
|
||||
|
||||
button_red_team.on_select = [this](Button&) {
|
||||
start_team(true);
|
||||
};
|
||||
|
||||
button_blue_team.on_select = [this](Button&) {
|
||||
start_team(false);
|
||||
};
|
||||
|
||||
button_rotate.on_select = [this](Button&) {
|
||||
placing_horizontal = !placing_horizontal;
|
||||
set_dirty();
|
||||
};
|
||||
|
||||
button_place.on_select = [this](Button&) {
|
||||
place_ship();
|
||||
};
|
||||
|
||||
button_fire.on_select = [this](Button&) {
|
||||
fire_at_position();
|
||||
};
|
||||
|
||||
button_menu.on_select = [this](Button&) {
|
||||
reset_game();
|
||||
};
|
||||
|
||||
set_focusable(true);
|
||||
init_game();
|
||||
}
|
||||
|
||||
BattleshipView::~BattleshipView() {
|
||||
transmitter_model.disable();
|
||||
receiver_model.disable();
|
||||
audio::output::stop();
|
||||
baseband::shutdown();
|
||||
}
|
||||
|
||||
void BattleshipView::focus() {
|
||||
if (game_state == GameState::MENU) {
|
||||
button_red_team.focus();
|
||||
} else {
|
||||
View::focus();
|
||||
}
|
||||
}
|
||||
|
||||
void BattleshipView::init_game() {
|
||||
for (uint8_t y = 0; y < GRID_SIZE; y++) {
|
||||
for (uint8_t x = 0; x < GRID_SIZE; x++) {
|
||||
my_grid[y][x] = CellState::EMPTY;
|
||||
enemy_grid[y][x] = CellState::EMPTY;
|
||||
}
|
||||
}
|
||||
|
||||
setup_ships();
|
||||
update_score();
|
||||
}
|
||||
|
||||
void BattleshipView::reset_game() {
|
||||
transmitter_model.disable();
|
||||
receiver_model.disable();
|
||||
audio::output::stop();
|
||||
|
||||
game_state = GameState::MENU;
|
||||
is_red_team = false;
|
||||
opponent_ready = false;
|
||||
current_ship_index = 0;
|
||||
placing_horizontal = true;
|
||||
ships_remaining = 5;
|
||||
enemy_ships_remaining = 5;
|
||||
cursor_x = 0;
|
||||
cursor_y = 0;
|
||||
target_x = 0;
|
||||
target_y = 0;
|
||||
is_transmitting = false;
|
||||
last_address = 0;
|
||||
|
||||
init_game();
|
||||
|
||||
current_status = "Choose your team!";
|
||||
update_score();
|
||||
text_status.hidden(false);
|
||||
text_score.hidden(true);
|
||||
field_frequency.hidden(false);
|
||||
button_red_team.hidden(false);
|
||||
button_blue_team.hidden(false);
|
||||
button_rotate.hidden(true);
|
||||
button_place.hidden(true);
|
||||
button_fire.hidden(true);
|
||||
button_menu.hidden(true);
|
||||
|
||||
button_red_team.set_focusable(true);
|
||||
button_blue_team.set_focusable(true);
|
||||
button_red_team.focus();
|
||||
|
||||
set_dirty();
|
||||
}
|
||||
|
||||
void BattleshipView::setup_ships() {
|
||||
static const ShipType types[] = {ShipType::CARRIER, ShipType::BATTLESHIP,
|
||||
ShipType::CRUISER, ShipType::SUBMARINE, ShipType::DESTROYER};
|
||||
for (uint8_t i = 0; i < 5; i++) {
|
||||
my_ships[i] = {types[i], 0, 0, true, 0, false};
|
||||
}
|
||||
}
|
||||
|
||||
void BattleshipView::start_team(bool red) {
|
||||
is_red_team = red;
|
||||
game_state = GameState::PLACING_SHIPS;
|
||||
|
||||
field_frequency.hidden(true);
|
||||
button_red_team.hidden(true);
|
||||
button_blue_team.hidden(true);
|
||||
button_rotate.hidden(false);
|
||||
button_place.hidden(false);
|
||||
button_menu.hidden(false);
|
||||
|
||||
text_status.hidden(true);
|
||||
text_score.hidden(true);
|
||||
|
||||
current_status = "Place carrier (5)";
|
||||
|
||||
button_rotate.set_focusable(false);
|
||||
button_place.set_focusable(false);
|
||||
button_menu.set_focusable(false);
|
||||
|
||||
focus();
|
||||
|
||||
is_transmitting = true;
|
||||
configure_radio_rx();
|
||||
|
||||
set_dirty();
|
||||
}
|
||||
|
||||
void BattleshipView::configure_radio_tx() {
|
||||
if (is_transmitting) return;
|
||||
|
||||
audio::output::stop();
|
||||
receiver_model.disable();
|
||||
baseband::shutdown();
|
||||
|
||||
chThdSleepMilliseconds(100);
|
||||
|
||||
baseband::run_image(portapack::spi_flash::image_tag_fsktx);
|
||||
|
||||
chThdSleepMilliseconds(100);
|
||||
|
||||
transmitter_model.set_target_frequency(tx_frequency);
|
||||
transmitter_model.set_sampling_rate(2280000);
|
||||
transmitter_model.set_baseband_bandwidth(1750000);
|
||||
transmitter_model.set_rf_amp(false);
|
||||
transmitter_model.set_tx_gain(35);
|
||||
|
||||
is_transmitting = true;
|
||||
}
|
||||
|
||||
void BattleshipView::configure_radio_rx() {
|
||||
if (is_transmitting) {
|
||||
transmitter_model.disable();
|
||||
baseband::shutdown();
|
||||
|
||||
chThdSleepMilliseconds(100);
|
||||
}
|
||||
|
||||
baseband::run_image(portapack::spi_flash::image_tag_pocsag2);
|
||||
|
||||
chThdSleepMilliseconds(100);
|
||||
|
||||
receiver_model.set_target_frequency(rx_frequency);
|
||||
receiver_model.set_sampling_rate(3072000);
|
||||
receiver_model.set_baseband_bandwidth(1750000);
|
||||
receiver_model.set_rf_amp(false);
|
||||
receiver_model.set_lna(24);
|
||||
receiver_model.set_vga(24);
|
||||
|
||||
baseband::set_pocsag();
|
||||
|
||||
receiver_model.enable();
|
||||
|
||||
audio::set_rate(audio::Rate::Hz_24000);
|
||||
audio::output::start();
|
||||
|
||||
is_transmitting = false;
|
||||
|
||||
current_status = "RX Ready";
|
||||
set_dirty();
|
||||
}
|
||||
|
||||
void BattleshipView::paint(Painter& painter) {
|
||||
painter.fill_rectangle({0, 0, 240, 320}, Color::black());
|
||||
|
||||
if (game_state == GameState::MENU) {
|
||||
auto style_title = *ui::Theme::getInstance()->fg_light;
|
||||
painter.draw_string({60, 20}, style_title, "BATTLESHIP");
|
||||
painter.draw_string({40, 80}, style_title, "Choose your team:");
|
||||
painter.draw_string({10, 180}, *ui::Theme::getInstance()->fg_medium, "Set same freq on both!");
|
||||
return;
|
||||
}
|
||||
|
||||
Color team_color = is_red_team ? Color::red() : Color::blue();
|
||||
painter.fill_rectangle({0, 5, 240, 16}, team_color);
|
||||
auto style_white = Style{
|
||||
.font = ui::font::fixed_8x16,
|
||||
.background = team_color,
|
||||
.foreground = Color::white()};
|
||||
painter.draw_string({85, 5}, style_white, is_red_team ? "RED TEAM" : "BLUE TEAM");
|
||||
|
||||
auto style_status = *ui::Theme::getInstance()->fg_light;
|
||||
painter.fill_rectangle({0, 21, 240, 16}, Color::black());
|
||||
painter.draw_string({10, 21}, style_status, current_status);
|
||||
|
||||
if (game_state != GameState::MENU) {
|
||||
painter.draw_string({170, 21}, style_status, current_score);
|
||||
}
|
||||
|
||||
if (game_state == GameState::PLACING_SHIPS) {
|
||||
draw_grid(painter, GRID_OFFSET_X, GRID_OFFSET_Y + 5, my_grid, true);
|
||||
if (current_ship_index < 5) {
|
||||
draw_ship_preview(painter);
|
||||
}
|
||||
} else if (game_state == GameState::MY_TURN) {
|
||||
draw_grid(painter, GRID_OFFSET_X, GRID_OFFSET_Y + 5, enemy_grid, false, true);
|
||||
painter.draw_string({10, GRID_OFFSET_Y + GRID_SIZE * CELL_SIZE + 10}, style_status,
|
||||
"Enemy ships: " + to_string_dec_uint(enemy_ships_remaining));
|
||||
} else if (game_state == GameState::OPPONENT_TURN || game_state == GameState::WAITING_FOR_OPPONENT) {
|
||||
draw_grid(painter, GRID_OFFSET_X, GRID_OFFSET_Y + 5, my_grid, true);
|
||||
painter.draw_string({10, GRID_OFFSET_Y + GRID_SIZE * CELL_SIZE + 10}, style_status,
|
||||
"Your ships: " + to_string_dec_uint(ships_remaining));
|
||||
} else if (game_state == GameState::GAME_OVER) {
|
||||
painter.draw_string({50, 150}, style_status, "Game Over!");
|
||||
painter.draw_string({30, 170}, style_status, current_status);
|
||||
}
|
||||
}
|
||||
|
||||
void BattleshipView::draw_grid(Painter& painter, uint8_t grid_x, uint8_t grid_y, const std::array<std::array<CellState, GRID_SIZE>, GRID_SIZE>& grid, bool show_ships, bool is_offense_grid) {
|
||||
painter.fill_rectangle({grid_x, grid_y, GRID_SIZE * CELL_SIZE, GRID_SIZE * CELL_SIZE},
|
||||
Color::dark_blue());
|
||||
|
||||
for (uint8_t i = 0; i <= GRID_SIZE; i++) {
|
||||
painter.draw_vline({grid_x + i * CELL_SIZE, grid_y},
|
||||
GRID_SIZE * CELL_SIZE, Color::grey());
|
||||
painter.draw_hline({grid_x, grid_y + i * CELL_SIZE},
|
||||
GRID_SIZE * CELL_SIZE, Color::grey());
|
||||
}
|
||||
|
||||
for (uint8_t y = 0; y < GRID_SIZE; y++) {
|
||||
for (uint8_t x = 0; x < GRID_SIZE; x++) {
|
||||
draw_cell(painter, grid_x + x * CELL_SIZE + 1, grid_y + y * CELL_SIZE + 1,
|
||||
grid[y][x], show_ships, is_offense_grid,
|
||||
is_cursor_at(x, y, is_offense_grid));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void BattleshipView::draw_cell(Painter& painter, uint8_t cell_x, uint8_t cell_y, CellState state, bool show_ships, bool is_offense_grid, bool is_cursor) {
|
||||
Color cell_color = Color::dark_blue();
|
||||
bool should_fill = false;
|
||||
|
||||
if (game_state == GameState::PLACING_SHIPS && !is_offense_grid && current_ship_index < 5) {
|
||||
uint8_t ship_size = my_ships[current_ship_index].size();
|
||||
for (uint8_t i = 0; i < ship_size; i++) {
|
||||
uint8_t preview_x = placing_horizontal ? cursor_x + i : cursor_x;
|
||||
uint8_t preview_y = placing_horizontal ? cursor_y : cursor_y + i;
|
||||
uint8_t grid_x = (cell_x - 1) / CELL_SIZE;
|
||||
uint8_t grid_y = (cell_y - GRID_OFFSET_Y - 6) / CELL_SIZE;
|
||||
if (grid_x == preview_x && grid_y == preview_y && preview_x < GRID_SIZE && preview_y < GRID_SIZE) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
switch (state) {
|
||||
case CellState::SHIP:
|
||||
if (show_ships) {
|
||||
cell_color = Color::grey();
|
||||
should_fill = true;
|
||||
}
|
||||
break;
|
||||
case CellState::HIT:
|
||||
cell_color = Color::red();
|
||||
should_fill = true;
|
||||
break;
|
||||
case CellState::MISS:
|
||||
cell_color = Color::light_grey();
|
||||
should_fill = true;
|
||||
break;
|
||||
case CellState::SUNK:
|
||||
cell_color = Color::dark_red();
|
||||
should_fill = true;
|
||||
break;
|
||||
default:
|
||||
if (is_offense_grid && state == CellState::EMPTY) {
|
||||
cell_color = Color::dark_grey();
|
||||
should_fill = true;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
if (should_fill) {
|
||||
painter.fill_rectangle({cell_x, cell_y, CELL_SIZE - 2, CELL_SIZE - 2}, cell_color);
|
||||
}
|
||||
|
||||
if (state == CellState::HIT || state == CellState::SUNK) {
|
||||
painter.draw_hline({cell_x + 4, cell_y + 4}, CELL_SIZE - 10, Color::white());
|
||||
painter.draw_hline({cell_x + 4, cell_y + CELL_SIZE - 6}, CELL_SIZE - 10, Color::white());
|
||||
painter.draw_vline({cell_x + 4, cell_y + 4}, CELL_SIZE - 10, Color::white());
|
||||
painter.draw_vline({cell_x + CELL_SIZE - 6, cell_y + 4}, CELL_SIZE - 10, Color::white());
|
||||
} else if (state == CellState::MISS) {
|
||||
painter.draw_hline({cell_x + 8, cell_y + 4}, 8, Color::white());
|
||||
painter.draw_hline({cell_x + 8, cell_y + CELL_SIZE - 6}, 8, Color::white());
|
||||
painter.draw_vline({cell_x + 4, cell_y + 8}, 8, Color::white());
|
||||
painter.draw_vline({cell_x + CELL_SIZE - 6, cell_y + 8}, 8, Color::white());
|
||||
}
|
||||
|
||||
if (is_cursor) {
|
||||
painter.draw_rectangle({cell_x - 1, cell_y - 1, CELL_SIZE, CELL_SIZE},
|
||||
is_offense_grid && game_state == GameState::MY_TURN ? Color::yellow() : Color::cyan());
|
||||
}
|
||||
}
|
||||
|
||||
bool BattleshipView::is_cursor_at(uint8_t x, uint8_t y, bool is_offense_grid) {
|
||||
if (game_state == GameState::PLACING_SHIPS && !is_offense_grid) {
|
||||
return x == cursor_x && y == cursor_y;
|
||||
} else if (is_offense_grid && game_state == GameState::MY_TURN) {
|
||||
return x == target_x && y == target_y;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void BattleshipView::draw_ship_preview(Painter& painter) {
|
||||
if (current_ship_index >= 5) return;
|
||||
|
||||
const Ship& ship = my_ships[current_ship_index];
|
||||
uint8_t size = ship.size();
|
||||
bool can_place = can_place_ship(cursor_x, cursor_y, size, placing_horizontal);
|
||||
|
||||
for (uint8_t i = 0; i < size; i++) {
|
||||
uint8_t x = placing_horizontal ? cursor_x + i : cursor_x;
|
||||
uint8_t y = placing_horizontal ? cursor_y : cursor_y + i;
|
||||
|
||||
if (x < GRID_SIZE && y < GRID_SIZE) {
|
||||
uint8_t cell_x = GRID_OFFSET_X + x * CELL_SIZE + 1;
|
||||
uint8_t cell_y = GRID_OFFSET_Y + 5 + y * CELL_SIZE + 1;
|
||||
|
||||
Color preview_color = can_place ? Color::green() : Color::red();
|
||||
|
||||
painter.fill_rectangle({cell_x, cell_y, CELL_SIZE - 2, CELL_SIZE - 2}, preview_color);
|
||||
painter.draw_rectangle({cell_x, cell_y, CELL_SIZE - 2, CELL_SIZE - 2}, Color::white());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool BattleshipView::can_place_ship(uint8_t x, uint8_t y, uint8_t size, bool horizontal) {
|
||||
if ((horizontal && x + size > GRID_SIZE) || (!horizontal && y + size > GRID_SIZE)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
for (uint8_t i = 0; i < size; i++) {
|
||||
uint8_t check_x = horizontal ? x + i : x;
|
||||
uint8_t check_y = horizontal ? y : y + i;
|
||||
|
||||
if (my_grid[check_y][check_x] != CellState::EMPTY) {
|
||||
return false;
|
||||
}
|
||||
|
||||
for (int dy = -1; dy <= 1; dy++) {
|
||||
for (int dx = -1; dx <= 1; dx++) {
|
||||
int adj_x = check_x + dx;
|
||||
int adj_y = check_y + dy;
|
||||
|
||||
if (adj_x >= 0 && adj_x < GRID_SIZE &&
|
||||
adj_y >= 0 && adj_y < GRID_SIZE) {
|
||||
if (my_grid[adj_y][adj_x] == CellState::SHIP) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void BattleshipView::place_ship() {
|
||||
if (current_ship_index >= 5) return;
|
||||
|
||||
Ship& ship = my_ships[current_ship_index];
|
||||
uint8_t size = ship.size();
|
||||
|
||||
if (!can_place_ship(cursor_x, cursor_y, size, placing_horizontal)) {
|
||||
current_status = "Invalid placement!";
|
||||
set_dirty();
|
||||
return;
|
||||
}
|
||||
|
||||
ship.x = cursor_x;
|
||||
ship.y = cursor_y;
|
||||
ship.horizontal = placing_horizontal;
|
||||
ship.placed = true;
|
||||
|
||||
for (uint8_t i = 0; i < size; i++) {
|
||||
uint8_t x = placing_horizontal ? cursor_x + i : cursor_x;
|
||||
uint8_t y = placing_horizontal ? cursor_y : cursor_y + i;
|
||||
my_grid[y][x] = CellState::SHIP;
|
||||
}
|
||||
|
||||
current_ship_index++;
|
||||
|
||||
if (current_ship_index >= 5) {
|
||||
button_rotate.hidden(true);
|
||||
button_place.hidden(true);
|
||||
|
||||
send_message({MessageType::READY, 0, 0});
|
||||
|
||||
if (is_red_team) {
|
||||
game_state = GameState::MY_TURN;
|
||||
current_status = "Your turn! Fire!";
|
||||
button_fire.hidden(false);
|
||||
button_fire.set_focusable(false);
|
||||
touch_enabled = true;
|
||||
} else {
|
||||
game_state = GameState::WAITING_FOR_OPPONENT;
|
||||
current_status = "Waiting for Red...";
|
||||
touch_enabled = false;
|
||||
}
|
||||
|
||||
focus();
|
||||
} else {
|
||||
static const char* ship_names[] = {"carrier (5)", "battleship (4)", "cruiser (3)",
|
||||
"submarine (3)", "destroyer (2)"};
|
||||
current_status = "Place ";
|
||||
current_status += ship_names[current_ship_index];
|
||||
}
|
||||
|
||||
set_dirty();
|
||||
}
|
||||
|
||||
void BattleshipView::send_message(const GameMessage& msg) {
|
||||
static const char* msg_strings[] = {"READY", "SHOT:", "HIT:", "MISS:", "SUNK:", "WIN"};
|
||||
|
||||
std::string message = msg_strings[static_cast<int>(msg.type)];
|
||||
if (msg.type != MessageType::READY && msg.type != MessageType::WIN) {
|
||||
message += to_string_dec_uint(msg.x) + "," + to_string_dec_uint(msg.y);
|
||||
}
|
||||
|
||||
configure_radio_tx();
|
||||
|
||||
// Use POCSAG encoding
|
||||
uint32_t target_address = is_red_team ? BLUE_TEAM_ADDRESS : RED_TEAM_ADDRESS;
|
||||
|
||||
std::vector<uint32_t> codewords;
|
||||
BCHCode BCH_code{{1, 0, 1, 0, 0, 1}, 5, 31, 21, 2};
|
||||
|
||||
// Use the pocsag namespace to access ALPHANUMERIC
|
||||
pocsag::pocsag_encode(pocsag::MessageType::ALPHANUMERIC, BCH_code, 0, message, target_address, codewords);
|
||||
|
||||
// Copy codewords to shared memory
|
||||
uint8_t* data_ptr = shared_memory.bb_data.data;
|
||||
size_t bi = 0;
|
||||
|
||||
for (size_t i = 0; i < codewords.size(); i++) {
|
||||
uint32_t codeword = codewords[i];
|
||||
data_ptr[bi++] = (codeword >> 24) & 0xFF;
|
||||
data_ptr[bi++] = (codeword >> 16) & 0xFF;
|
||||
data_ptr[bi++] = (codeword >> 8) & 0xFF;
|
||||
data_ptr[bi++] = codeword & 0xFF;
|
||||
}
|
||||
|
||||
// Set baseband FSK data
|
||||
baseband::set_fsk_data(
|
||||
codewords.size() * 32, // Total bits
|
||||
2280000 / 1200, // Bit duration (1200 baud)
|
||||
4500, // Deviation
|
||||
64); // Packet repeat
|
||||
|
||||
transmitter_model.set_baseband_bandwidth(1750000);
|
||||
transmitter_model.enable();
|
||||
|
||||
current_status = "TX: " + message;
|
||||
set_dirty();
|
||||
}
|
||||
|
||||
void BattleshipView::on_pocsag_packet(const POCSAGPacketMessage* message) {
|
||||
if (message->packet.flag() != pocsag::NORMAL) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Decode POCSAG message
|
||||
pocsag_state.codeword_index = 0;
|
||||
pocsag_state.errors = 0;
|
||||
|
||||
while (pocsag::pocsag_decode_batch(message->packet, pocsag_state)) {
|
||||
if (pocsag_state.out_type == pocsag::MESSAGE) {
|
||||
// Check if message is for our team
|
||||
uint32_t expected_address = is_red_team ? RED_TEAM_ADDRESS : BLUE_TEAM_ADDRESS;
|
||||
if (pocsag_state.address == expected_address) {
|
||||
process_message(pocsag_state.output);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void BattleshipView::on_tx_progress(const uint32_t progress, const bool done) {
|
||||
(void)progress;
|
||||
|
||||
if (done) {
|
||||
transmitter_model.disable();
|
||||
chThdSleepMilliseconds(200);
|
||||
configure_radio_rx();
|
||||
|
||||
if (game_state == GameState::MY_TURN) {
|
||||
current_status = "Waiting for response";
|
||||
set_dirty();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool BattleshipView::parse_coords(const std::string& coords, uint8_t& x, uint8_t& y) {
|
||||
size_t comma_pos = coords.find(',');
|
||||
if (comma_pos == std::string::npos) return false;
|
||||
|
||||
x = 0;
|
||||
y = 0;
|
||||
|
||||
for (size_t i = 0; i < comma_pos; i++) {
|
||||
char c = coords[i];
|
||||
if (c >= '0' && c <= '9') {
|
||||
x = x * 10 + (c - '0');
|
||||
}
|
||||
}
|
||||
|
||||
for (size_t i = comma_pos + 1; i < coords.length(); i++) {
|
||||
char c = coords[i];
|
||||
if (c >= '0' && c <= '9') {
|
||||
y = y * 10 + (c - '0');
|
||||
}
|
||||
}
|
||||
|
||||
return x < GRID_SIZE && y < GRID_SIZE;
|
||||
}
|
||||
|
||||
void BattleshipView::mark_ship_sunk(uint8_t x, uint8_t y, std::array<std::array<CellState, GRID_SIZE>, GRID_SIZE>& grid) {
|
||||
for (int dy = -1; dy <= 1; dy++) {
|
||||
for (int dx = -1; dx <= 1; dx++) {
|
||||
int check_x = x + dx;
|
||||
int check_y = y + dy;
|
||||
if (check_x >= 0 && check_x < GRID_SIZE &&
|
||||
check_y >= 0 && check_y < GRID_SIZE) {
|
||||
if (grid[check_y][check_x] == CellState::HIT) {
|
||||
grid[check_y][check_x] = CellState::SUNK;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void BattleshipView::process_message(const std::string& message) {
|
||||
if (message.empty()) return;
|
||||
|
||||
size_t colon_pos = message.find(':');
|
||||
std::string msg_type = (colon_pos != std::string::npos)
|
||||
? message.substr(0, colon_pos)
|
||||
: message;
|
||||
|
||||
if (msg_type == "READY") {
|
||||
opponent_ready = true;
|
||||
if (!is_red_team && game_state == GameState::WAITING_FOR_OPPONENT) {
|
||||
current_status = "Red ready! Waiting...";
|
||||
set_dirty();
|
||||
}
|
||||
} else if (msg_type == "SHOT" && colon_pos != std::string::npos) {
|
||||
if (game_state == GameState::OPPONENT_TURN ||
|
||||
(game_state == GameState::WAITING_FOR_OPPONENT && !is_red_team)) {
|
||||
uint8_t x, y;
|
||||
if (parse_coords(message.substr(colon_pos + 1), x, y)) {
|
||||
process_shot(x, y);
|
||||
}
|
||||
}
|
||||
} else if ((msg_type == "HIT" || msg_type == "MISS" || msg_type == "SUNK") && colon_pos != std::string::npos) {
|
||||
uint8_t x, y;
|
||||
if (parse_coords(message.substr(colon_pos + 1), x, y)) {
|
||||
if (msg_type == "HIT") {
|
||||
enemy_grid[y][x] = CellState::HIT;
|
||||
current_status = "Hit! Fire again!";
|
||||
} else if (msg_type == "MISS") {
|
||||
enemy_grid[y][x] = CellState::MISS;
|
||||
current_status = "Miss! Enemy turn";
|
||||
game_state = GameState::OPPONENT_TURN;
|
||||
button_fire.hidden(true);
|
||||
touch_enabled = false;
|
||||
} else if (msg_type == "SUNK") {
|
||||
enemy_grid[y][x] = CellState::SUNK;
|
||||
enemy_ships_remaining--;
|
||||
current_status = "Ship sunk! Fire!";
|
||||
mark_ship_sunk(x, y, enemy_grid);
|
||||
}
|
||||
|
||||
if (game_state == GameState::MY_TURN) {
|
||||
touch_enabled = true;
|
||||
}
|
||||
}
|
||||
} else if (msg_type == "WIN") {
|
||||
game_state = GameState::GAME_OVER;
|
||||
current_status = (is_red_team ? "BLUE" : "RED") + std::string(" TEAM WINS!");
|
||||
button_fire.hidden(true);
|
||||
touch_enabled = false;
|
||||
losses++;
|
||||
update_score();
|
||||
}
|
||||
|
||||
set_dirty();
|
||||
}
|
||||
|
||||
void BattleshipView::fire_at_position() {
|
||||
if (game_state != GameState::MY_TURN) return;
|
||||
|
||||
if (enemy_grid[target_y][target_x] != CellState::EMPTY) {
|
||||
current_status = "Already fired!";
|
||||
set_dirty();
|
||||
return;
|
||||
}
|
||||
|
||||
send_message({MessageType::SHOT, target_x, target_y});
|
||||
current_status = "Firing...";
|
||||
touch_enabled = false;
|
||||
set_dirty();
|
||||
}
|
||||
|
||||
void BattleshipView::process_shot(uint8_t x, uint8_t y) {
|
||||
if (my_grid[y][x] == CellState::SHIP) {
|
||||
my_grid[y][x] = CellState::HIT;
|
||||
|
||||
bool sunk = false;
|
||||
|
||||
for (auto& ship : my_ships) {
|
||||
if (!ship.placed) continue;
|
||||
|
||||
bool hit_this_ship = false;
|
||||
for (uint8_t i = 0; i < ship.size(); i++) {
|
||||
uint8_t check_x = ship.horizontal ? ship.x + i : ship.x;
|
||||
uint8_t check_y = ship.horizontal ? ship.y : ship.y + i;
|
||||
|
||||
if (check_x == x && check_y == y) {
|
||||
hit_this_ship = true;
|
||||
ship.hits++;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (hit_this_ship && ship.is_sunk()) {
|
||||
sunk = true;
|
||||
ships_remaining--;
|
||||
|
||||
for (uint8_t i = 0; i < ship.size(); i++) {
|
||||
uint8_t sunk_x = ship.horizontal ? ship.x + i : ship.x;
|
||||
uint8_t sunk_y = ship.horizontal ? ship.y : ship.y + i;
|
||||
my_grid[sunk_y][sunk_x] = CellState::SUNK;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (sunk) {
|
||||
send_message({MessageType::SUNK, x, y});
|
||||
|
||||
if (ships_remaining == 0) {
|
||||
send_message({MessageType::WIN, 0, 0});
|
||||
game_state = GameState::GAME_OVER;
|
||||
current_status = (is_red_team ? "RED" : "BLUE") + std::string(" TEAM WINS!");
|
||||
wins++;
|
||||
update_score();
|
||||
}
|
||||
} else {
|
||||
send_message({MessageType::HIT, x, y});
|
||||
}
|
||||
} else {
|
||||
my_grid[y][x] = CellState::MISS;
|
||||
send_message({MessageType::MISS, x, y});
|
||||
|
||||
game_state = GameState::MY_TURN;
|
||||
button_fire.hidden(false);
|
||||
touch_enabled = true;
|
||||
current_status = "Your turn! Fire!";
|
||||
}
|
||||
|
||||
set_dirty();
|
||||
}
|
||||
|
||||
void BattleshipView::update_score() {
|
||||
current_score = "W:" + to_string_dec_uint(wins) + " L:" + to_string_dec_uint(losses);
|
||||
}
|
||||
|
||||
bool BattleshipView::on_touch(const TouchEvent event) {
|
||||
if (event.type != TouchEvent::Type::Start || !touch_enabled) {
|
||||
return false;
|
||||
}
|
||||
|
||||
uint16_t x = event.point.x();
|
||||
uint16_t y = event.point.y();
|
||||
|
||||
if (x >= GRID_OFFSET_X && x < GRID_OFFSET_X + GRID_SIZE * CELL_SIZE &&
|
||||
y >= GRID_OFFSET_Y + 5 && y < GRID_OFFSET_Y + 5 + GRID_SIZE * CELL_SIZE) {
|
||||
uint8_t grid_x = (x - GRID_OFFSET_X) / CELL_SIZE;
|
||||
uint8_t grid_y = (y - GRID_OFFSET_Y - 5) / CELL_SIZE;
|
||||
|
||||
if (game_state == GameState::PLACING_SHIPS) {
|
||||
cursor_x = grid_x;
|
||||
cursor_y = grid_y;
|
||||
} else if (game_state == GameState::MY_TURN) {
|
||||
target_x = grid_x;
|
||||
target_y = grid_y;
|
||||
}
|
||||
set_dirty();
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool BattleshipView::on_encoder(const EncoderEvent delta) {
|
||||
if (delta == 0) return false;
|
||||
|
||||
if (game_state == GameState::PLACING_SHIPS) {
|
||||
placing_horizontal = !placing_horizontal;
|
||||
} else if (game_state == GameState::MY_TURN) {
|
||||
target_x = (delta > 0) ? (target_x + 1) % GRID_SIZE : (target_x == 0) ? GRID_SIZE - 1
|
||||
: target_x - 1;
|
||||
}
|
||||
set_dirty();
|
||||
return true;
|
||||
}
|
||||
|
||||
bool BattleshipView::on_key(const KeyEvent key) {
|
||||
if (key == KeyEvent::Select) {
|
||||
if (game_state == GameState::PLACING_SHIPS) {
|
||||
place_ship();
|
||||
return true;
|
||||
} else if (game_state == GameState::MY_TURN) {
|
||||
fire_at_position();
|
||||
return true;
|
||||
}
|
||||
} else if (key == KeyEvent::Back) {
|
||||
if (game_state != GameState::MENU) {
|
||||
reset_game();
|
||||
return true;
|
||||
}
|
||||
} else if (key == KeyEvent::Up || key == KeyEvent::Down) {
|
||||
uint8_t* coord_y = (game_state == GameState::PLACING_SHIPS) ? &cursor_y : &target_y;
|
||||
if (key == KeyEvent::Up) {
|
||||
*coord_y = (*coord_y == 0) ? GRID_SIZE - 1 : *coord_y - 1;
|
||||
} else {
|
||||
*coord_y = (*coord_y + 1) % GRID_SIZE;
|
||||
}
|
||||
set_dirty();
|
||||
return true;
|
||||
} else if (key == KeyEvent::Left || key == KeyEvent::Right) {
|
||||
uint8_t* coord_x = (game_state == GameState::PLACING_SHIPS) ? &cursor_x : &target_x;
|
||||
if (key == KeyEvent::Left) {
|
||||
*coord_x = (*coord_x == 0) ? GRID_SIZE - 1 : *coord_x - 1;
|
||||
} else {
|
||||
*coord_x = (*coord_x + 1) % GRID_SIZE;
|
||||
}
|
||||
set_dirty();
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
} // namespace ui::external_app::battleship
|
||||
Reference in New Issue
Block a user