mesen_socket_client.h

Go to the documentation of this file.

#ifndef YAZE_APP_EMU_MESEN_MESEN_SOCKET_CLIENT_H_
#define YAZE_APP_EMU_MESEN_MESEN_SOCKET_CLIENT_H_
 
#include <atomic>
#include <cstdint>
#include <functional>
#include <memory>
#include <mutex>
#include <string>
#include <thread>
#include <unordered_map>
#include <vector>
 
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "app/emu/input/input_backend.h"
 
namespace yaze {
namespace emu {
namespace mesen {
 
#ifdef _WIN32
using SocketHandle = std::uintptr_t;
#else
using SocketHandle = int;
#endif
 
inline constexpr SocketHandle kInvalidSocketHandle =
    static_cast<SocketHandle>(-1);
 
struct CpuState {
  uint16_t A;
  uint16_t X;
  uint16_t Y;
  uint16_t SP;
  uint16_t D;  // Direct page
  uint32_t PC;
  uint8_t K;    // Program bank
  uint8_t DBR;  // Data bank
  uint8_t P;    // Processor status
  bool emulation_mode;
};
 
struct MesenState {
  bool running;
  bool paused;
  bool debugging;
  uint64_t frame;
  double fps;
  int console_type;
};
 
struct LinkState {
  uint16_t x;
  uint16_t y;
  uint8_t layer;
  uint8_t direction;  // 0=up, 2=down, 4=left, 6=right
  uint8_t state;
  uint8_t pose;
};
 
struct GameItems {
  uint8_t current_health;
  uint8_t max_health;
  uint8_t magic;
  uint16_t rupees;
  uint8_t bombs;
  uint8_t arrows;
};
 
struct GameMode {
  uint8_t mode;
  uint8_t submode;
  bool indoors;
  uint16_t room_id;        // Valid when indoors
  uint8_t overworld_area;  // Valid when !indoors
};
 
struct GameState {
  LinkState link;
  GameItems items;
  GameMode game;
};
 
struct SpriteInfo {
  int slot;
  uint8_t type;
  uint8_t state;
  uint16_t x;
  uint16_t y;
  uint8_t health;
  uint8_t subtype;
};
 
enum class BreakpointType { kExecute, kRead, kWrite, kReadWrite };
 
struct MesenEvent {
  std::string type;      // "breakpoint_hit", "frame_complete", etc.
  std::string raw_json;  // Full event payload
  uint32_t address;      // For breakpoint events
  uint64_t frame;        // Frame number when event occurred
};
 
using EventCallback = std::function<void(const MesenEvent&)>;
using EventListenerId = uint64_t;
 
class MesenSocketClient {
 public:
  MesenSocketClient();
  ~MesenSocketClient();
 
  // Disable copy
  MesenSocketClient(const MesenSocketClient&) = delete;
  MesenSocketClient& operator=(const MesenSocketClient&) = delete;
 
  // ──────────────────────────────────────────────────────────────────────────
  // Connection Management
  // ──────────────────────────────────────────────────────────────────────────
 
  absl::Status Connect();
 
  absl::Status Connect(const std::string& socket_path);
 
  void Disconnect();
 
  bool IsConnected() const;
 
  const std::string& GetSocketPath() const { return socket_path_; }
 
  static std::vector<std::string> ListAvailableSockets();
 
  // ──────────────────────────────────────────────────────────────────────────
  // Control Commands
  // ──────────────────────────────────────────────────────────────────────────
 
  absl::Status Ping();
 
  absl::StatusOr<MesenState> GetState();
 
  absl::Status Pause();
 
  absl::Status Resume();
 
  absl::Status Reset();
 
  absl::Status Frame();
 
  absl::Status Step(int count = 1, const std::string& mode = "into");
 
  // ──────────────────────────────────────────────────────────────────────────
  // Input Commands
  // ──────────────────────────────────────────────────────────────────────────
 
  absl::Status SetButton(emu::input::SnesButton button, bool pressed);
 
  absl::Status SetButtons(const emu::input::ControllerState& state);
 
  // ──────────────────────────────────────────────────────────────────────────
  // Memory Access
  // ──────────────────────────────────────────────────────────────────────────
 
  absl::StatusOr<uint8_t> ReadByte(uint32_t addr);
 
  absl::StatusOr<uint16_t> ReadWord(uint32_t addr);
 
  absl::StatusOr<std::vector<uint8_t>> ReadBlock(uint32_t addr, size_t len);
 
  absl::Status WriteByte(uint32_t addr, uint8_t value);
 
  absl::Status WriteWord(uint32_t addr, uint16_t value);
 
  absl::Status WriteBlock(uint32_t addr, const std::vector<uint8_t>& data);
 
  // ──────────────────────────────────────────────────────────────────────────
  // Debugging Commands
  // ──────────────────────────────────────────────────────────────────────────
 
  absl::StatusOr<CpuState> GetCpuState();
 
  absl::StatusOr<std::string> Disassemble(uint32_t addr, int count = 10);
 
  absl::StatusOr<int> AddBreakpoint(uint32_t addr, BreakpointType type,
                                    const std::string& condition = "");
 
  absl::Status RemoveBreakpoint(int id);
 
  absl::Status ClearBreakpoints();
 
  absl::StatusOr<std::string> GetTrace(int count = 20);
 
  // ──────────────────────────────────────────────────────────────────────────
  // ALTTP-Specific Commands
  // ──────────────────────────────────────────────────────────────────────────
 
  absl::StatusOr<GameState> GetGameState();
 
  absl::StatusOr<std::vector<SpriteInfo>> GetSprites(bool all = false);
 
  absl::Status SetCollisionOverlay(bool enable,
                                   const std::string& colmap = "A");
 
  // ──────────────────────────────────────────────────────────────────────────
  // Save State Commands
  // ──────────────────────────────────────────────────────────────────────────
 
  absl::Status SaveState(int slot);
 
  absl::Status LoadState(int slot);
 
  absl::StatusOr<std::string> Screenshot();
 
  // ──────────────────────────────────────────────────────────────────────────
  // Event Subscription
  // ──────────────────────────────────────────────────────────────────────────
 
  absl::Status Subscribe(const std::vector<std::string>& events);
 
  absl::Status Unsubscribe();
 
  void SetEventCallback(EventCallback callback);
 
  EventListenerId AddEventListener(EventCallback callback);
 
  void RemoveEventListener(EventListenerId id);
 
  // ──────────────────────────────────────────────────────────────────────────
  // Low-Level Commands
  // ──────────────────────────────────────────────────────────────────────────
 
  absl::StatusOr<std::string> SendCommand(const std::string& json);
 
 private:
  static std::vector<std::string> FindSocketPaths();
 
  absl::StatusOr<std::string> ParseResponse(const std::string& response);
 
  absl::StatusOr<std::string> SendCommandOnSocket(SocketHandle fd,
                                                  const std::string& json,
                                                  bool update_connection_state);
 
  void EventLoop();
 
  SocketHandle socket_fd_ = kInvalidSocketHandle;
  SocketHandle event_socket_fd_ = kInvalidSocketHandle;
#ifdef _WIN32
  int winsock_startup_error_ = 0;
  bool winsock_started_ = false;
#endif
  std::string socket_path_;
  std::atomic<bool> connected_{false};
  std::mutex command_mutex_;
  std::mutex event_callback_mutex_;
 
  // Event handling
  EventCallback event_callback_;
  std::unordered_map<EventListenerId, EventCallback> event_listeners_;
  EventListenerId next_event_listener_id_ = 1;
  std::thread event_thread_;
  std::atomic<bool> event_thread_running_{false};
  std::string pending_event_payload_;
 
  // Input state
  emu::input::ControllerState current_input_;
};
 
}  // namespace mesen
}  // namespace emu
}  // namespace yaze
 
#endif  // YAZE_APP_EMU_MESEN_MESEN_SOCKET_CLIENT_H_