sashite-ggn 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3841392373c865dd1e96e3cd8321cb8720767585d815fc16449f05a00c8d0900
-  data.tar.gz: a00ebca510e8af7ff2e77ea8056009ca2198a43d79885a61fd8ea682f6c9aaf3
+  metadata.gz: 1af50f2e0d1bcc29f645560a6889184b953b18cc5a10096e2fd5042b61adac22
+  data.tar.gz: d01e4f3b4dfe6d34dd68d6155c541dd5fd17488e4b86e08710e9872ccd901cba
 SHA512:
-  metadata.gz: 9cc52a786d043b1e2ed437d58f9c939268d23f97df82211732dacf955964bbc27fbc24a3ac280c5cb63a84e6aeaf7fb22aa88e659832020802ac1e78e949f6b5
-  data.tar.gz: 35a6f1b1d9d0f5878ebef7c443f675a0c15027d0895ca96c92c69c1f9a6864c152b7c58fb25e57cbb5ff50223a007003eb994ddb265d1e0e67707fa5b692a6b3
+  metadata.gz: 8565e8a83cac905bf9cfd368c136964c83e26f81b8e0fbd0c11c28c4c9da358511cda025688304cb37a16a21b79e07965209dd1027aab478b1fd49e976f00a80
+  data.tar.gz: 4bc9121f894dc379b85c4440a1844946f88cd5c9aa3cf25c8036845fc76060072e7d66579efed704b20f4b8ef851ded94e09b267c8249c231a09ae777d9ebf2e

data/README.md

@@ -1,413 +1,130 @@
 # Ggn.rb
 
-[![Version](https://img.shields.io/github/v/tag/sashite/ggn.rb?label=Version&logo=github)](https://github.com/sashite/ggn.rb/tags)
-[![Yard documentation](https://img.shields.io/badge/Yard-documentation-blue.svg?logo=github)](https://rubydoc.info/github/sashite/ggn.rb/main)
-![Ruby](https://github.com/sashite/ggn.rb/actions/workflows/main.yml/badge.svg?branch=main)
-[![License](https://img.shields.io/github/license/sashite/ggn.rb?label=License&logo=github)](https://github.com/sashite/ggn.rb/raw/main/LICENSE.md)
+A Ruby implementation of the General Gameplay Notation (GGN) specification for describing pseudo-legal moves in abstract strategy board games.
 
-> **GGN** (General Gameplay Notation) support for the Ruby language.
+[![Gem Version](https://badge.fury.io/rb/sashite-ggn.svg)](https://badge.fury.io/rb/sashite-ggn)
+[![Ruby](https://github.com/sashite/ggn.rb/workflows/Ruby/badge.svg)](https://github.com/sashite/ggn.rb/actions)
 
 ## What is GGN?
 
-GGN (General Gameplay Notation) is a rule-agnostic, JSON-based format for describing **pseudo-legal moves** in abstract strategy board games. Unlike move notations that express *what* a move does, GGN expresses *whether* that move is **possible** under basic movement constraints.
+GGN (General Gameplay Notation) is a rule-agnostic, JSON-based format for representing pseudo-legal moves in abstract strategy board games. This gem implements the [GGN Specification v1.0.0](https://sashite.dev/documents/ggn/1.0.0/).
 
-GGN is deliberately silent about higher-level, game-specific legality questions (e.g., check, ko, repetition, castling paths). This neutrality makes the format universal: any engine can pre-compute and share a library of pseudo-legal moves for any mix of games.
+GGN focuses on basic movement constraints rather than game-specific legality rules, making it suitable for:
 
-This gem implements the [GGN Specification v1.0.0](https://sashite.dev/documents/ggn/1.0.0/), providing a Ruby interface for:
-
-- Loading and validating GGN JSON documents
-- Querying pseudo-legal moves for specific pieces and positions
-- Evaluating move validity under current board conditions
-- Processing complex move conditions including captures, drops, and promotions
+- Cross-game move analysis and engine development
+- Hybrid games combining elements from different chess variants
+- Database systems requiring piece disambiguation across game types
+- Performance-critical applications with pre-computed move libraries
 
 ## Installation
 
 ```ruby
-# In your Gemfile
-gem "sashite-ggn"
-```
-
-Or install manually:
-
-```sh
-gem install sashite-ggn
-```
-
-## GGN Format
-
-A single GGN **entry** answers the question:
-
-> Can this piece, currently on this square, reach that square?
-
-It encodes:
-
-1. **Which piece** (via GAN identifier)
-2. **From where** (source square label, or "`*`" for off-board)
-3. **To where** (destination square label)
-4. **Which pre-conditions** must hold (`require`)
-5. **Which pre-conditions** must not hold (`prevent`)
-6. **Which post-conditions** result (`perform`, plus optional `gain` or `drop`)
-
-### JSON Structure
-
-```json
-{
-  "<Source piece GAN>": {
-    "<Source square>": {
-      "<Destination square>": [
-        {
-          "require":  { "<square>": "<required state>", … },
-          "prevent":  { "<square>": "<forbidden state>", … },
-          "perform":  { "<square>": "<new state | null>", … },
-          "gain":     "<piece GAN>" | null,
-          "drop":     "<piece GAN>" | null
-        }
-      ]
-    }
-  }
-}
+gem 'sashite-ggn'
 ```
 
 ## Basic Usage
 
 ### Loading GGN Data
 
-Load GGN data from various sources:
-
 ```ruby
 require "sashite-ggn"
 
-# From file
-piece_data = Sashite::Ggn.load_file("chess_moves.json")
-
-# From JSON string
-json_string = '{"CHESS:P": {"e2": {"e4": [{"require": {"e3": "empty", "e4": "empty"}, "perform": {"e2": null, "e4": "CHESS:P"}}]}}}'
-piece_data = Sashite::Ggn.load_string(json_string)
+# Load from file
+ruleset = Sashite::Ggn.load_file("chess_moves.json")
 
-# From Hash
-ggn_hash = { "CHESS:P" => { "e2" => { "e4" => [{ "require" => { "e3" => "empty", "e4" => "empty" }, "perform" => { "e2" => nil, "e4" => "CHESS:P" } }] } } }
-piece_data = Sashite::Ggn.load_hash(ggn_hash)
+# Load from string
+json = '{"CHESS:P": {"e2": {"e4": [{"perform": {"e2": null, "e4": "CHESS:P"}}]}}}'
+ruleset = Sashite::Ggn.load_string(json)
 ```
 
-### Querying Moves
-
-Navigate through the GGN structure to find specific moves:
+### Evaluating Moves
 
 ```ruby
-require "sashite-ggn"
-
-piece_data = Sashite::Ggn.load_file("chess_moves.json")
-
-# Select a piece type
-source = piece_data.select("CHESS:P")
+# Query specific move
+engine = ruleset.select("CHESS:P").from("e2").to("e4")
 
-# Get destinations from a specific source square
-destinations = source.from("e2")
+# Define board state
+board_state = { "e2" => "CHESS:P", "e3" => nil, "e4" => nil }
 
-# Get the engine for a specific target square
-engine = destinations.to("e4")
+# Evaluate move
+transitions = engine.where(board_state, {}, "CHESS")
+# => [#<Transition diff={"e2"=>nil, "e4"=>"CHESS:P"}>]
 ```
 
-### Evaluating Move Validity
-
-Check if a move is valid under current board conditions:
+### Generating All Moves
 
 ```ruby
-require "sashite-ggn"
+# Get all pseudo-legal moves for current position
+all_moves = ruleset.pseudo_legal_transitions(board_state, captures, "CHESS")
 
-# Load piece data and get the movement engine
-piece_data = Sashite::Ggn.load_file("chess_moves.json")
-engine = piece_data.select("CHESS:P").from("e2").to("e4")
-
-# Define current board state
-board_state = {
-  "e2" => "CHESS:P",  # White pawn on e2
-  "e3" => nil,        # Empty square
-  "e4" => nil         # Empty square
-}
-
-# Evaluate the move
-result = engine.where(board_state, {}, "CHESS")
-
-if result
-  puts "Move is valid!"
-  puts "Board changes: #{result.diff}"
-  # => { "e2" => nil, "e4" => "CHESS:P" }
-  puts "Piece gained: #{result.gain}"  # => nil (no capture)
-  puts "Piece dropped: #{result.drop}" # => nil (not a drop move)
-else
-  puts "Move is not valid under current conditions"
+# Each move is represented as [actor, origin, target, transitions]
+all_moves.each do |actor, origin, target, transitions|
+  puts "#{actor}: #{origin} → #{target} (#{transitions.size} variants)"
 end
 ```
 
-### Handling Captures
+## Move Variants
 
-Process moves that capture enemy pieces:
+GGN supports multiple outcomes for a single move (e.g., promotion choices):
 
 ```ruby
-require "sashite-ggn"
-
-# Load piece data for a capture move
-piece_data = Sashite::Ggn.load_file("chess_moves.json")
-engine = piece_data.select("CHESS:P").from("e5").to("d6")
+# Chess pawn promotion
+engine = ruleset.select("CHESS:P").from("e7").to("e8")
+transitions = engine.where({"e7" => "CHESS:P", "e8" => nil}, {}, "CHESS")
 
-# Board state with enemy piece to capture
-board_state = {
-  "e5" => "CHESS:P",  # Our pawn
-  "d6" => "chess:p"   # Enemy pawn (lowercase = opponent)
-}
-
-result = engine.where(board_state, {}, "CHESS")
-
-if result
-  puts "Capture is valid!"
-  puts "Board changes: #{result.diff}"
-  # => { "e5" => nil, "d6" => "CHESS:P" }
-  puts "Captured piece: #{result.gain}"  # => "CHESS:P" (gained in hand)
+transitions.each do |transition|
+  promoted_piece = transition.diff["e8"]
+  puts "Promote to #{promoted_piece}"
 end
+# Output: CHESS:Q, CHESS:R, CHESS:B, CHESS:N
 ```
 
-### Piece Drops (Shogi-style)
+## Piece Drops
 
-Handle dropping pieces from hand onto the board:
+For games supporting piece drops (e.g., Shogi):
 
 ```ruby
-require "sashite-ggn"
-
-# Load Shogi piece data
-piece_data = Sashite::Ggn.load_file("shogi_moves.json")
-engine = piece_data.select("SHOGI:P").from("*").to("5e")
+# Drop from hand (origin "*")
+engine = ruleset.select("SHOGI:P").from("*").to("5e")
 
-# Player has captured pawns available
-captures = { "SHOGI:P" => 2 }
+captures = { "SHOGI:P" => 1 }  # One pawn in hand
+board_state = { "5e" => nil }   # Empty target square
 
-# Current board state (5th file is clear of unpromoted pawns)
-board_state = {
-  "5e" => nil,  # Target square is empty
-  "5a" => nil, "5b" => nil, "5c" => nil, "5d" => nil,
-  "5f" => nil, "5g" => nil, "5h" => nil, "5i" => nil
-}
-
-result = engine.where(board_state, captures, "SHOGI")
-
-if result
-  puts "Pawn drop is valid!"
-  puts "Board changes: #{result.diff}"  # => { "5e" => "SHOGI:P" }
-  puts "Piece dropped from hand: #{result.drop}"  # => "SHOGI:P"
-end
+transitions = engine.where(board_state, captures, "SHOGI")
+# => [#<Transition diff={"5e"=>"SHOGI:P"} drop="SHOGI:P">]
 ```
 
 ## Validation
 
-### Schema Validation
-
-Validate GGN data against the official JSON Schema:
-
 ```ruby
-require "sashite-ggn"
-
-# Validate during loading (default behavior)
-begin
-  piece_data = Sashite::Ggn.load_file("moves.json")
-  puts "GGN data is valid!"
-rescue Sashite::Ggn::ValidationError => e
-  puts "Validation failed: #{e.message}"
-end
-
-# Skip validation for performance (large files)
-piece_data = Sashite::Ggn.load_file("large_moves.json", validate: false)
-
-# Validate manually
-begin
-  Sashite::Ggn.validate!(my_data)
-  puts "Data is valid"
-rescue Sashite::Ggn::ValidationError => e
-  puts "Invalid: #{e.message}"
-end
-
-# Check validity without exceptions
-if Sashite::Ggn.valid?(my_data)
-  puts "Data is valid"
-else
-  errors = Sashite::Ggn.validation_errors(my_data)
-  puts "Validation errors: #{errors.join(', ')}"
-end
-```
-
-## Occupation States
-
-GGN recognizes several occupation states for move conditions:
-
-| State            | Meaning                                                                      |
-| ---------------- | ---------------------------------------------------------------------------- |
-| `"empty"`        | Square must be empty                                                         |
-| `"enemy"`        | Square must contain a standard opposing piece                                |
-| *GAN identifier* | Square must contain **exactly** the specified piece                          |
-
-### Implicit States
-
-Through the `prevent` field, additional states can be expressed:
-
-| Implicit State   | Expression                   | Meaning                                                  |
-| ---------------- | ---------------------------- | -------------------------------------------------------- |
-| `"occupied"`     | `"prevent": { "a1": "empty" }` | Square must be occupied by any piece                     |
-| `"ally"`         | `"prevent": { "a1": "enemy" }` | Square must contain a friendly piece                     |
-
-## Examples
-
-### Simple Move
-
-A piece moving from one square to another without conditions:
-
-```json
-{
-  "CHESS:K": {
-    "e1": {
-      "e2": [
-        {
-          "perform": { "e1": null, "e2": "CHESS:K" }
-        }
-      ]
-    }
-  }
-}
+# Validate GGN data
+Sashite::Ggn.validate!(data)  # Raises exception on failure
+Sashite::Ggn.valid?(data)     # Returns boolean
 ```
 
-### Sliding Move
-
-A piece that slides along empty squares:
-
-```json
-{
-  "CHESS:R": {
-    "a1": {
-      "a3": [
-        {
-          "require": { "a2": "empty", "a3": "empty" },
-          "perform": { "a1": null, "a3": "CHESS:R" }
-        }
-      ]
-    }
-  }
-}
-```
+## API Reference
 
-### Capture with Gain
-
-A piece capturing an enemy and gaining it in hand:
-
-```json
-{
-  "SHOGI:P": {
-    "5f": {
-      "5e": [
-        {
-          "require": { "5e": "enemy" },
-          "perform": { "5f": null, "5e": "SHOGI:P" },
-          "gain": "SHOGI:P"
-        }
-      ]
-    }
-  }
-}
-```
+### Core Classes
 
-### Piece Drop
-
-Dropping a piece from hand onto the board:
-
-```json
-{
-  "SHOGI:P": {
-    "*": {
-      "5e": [
-        {
-          "require": { "5e": "empty" },
-          "prevent": {
-            "5a": "SHOGI:P", "5b": "SHOGI:P", "5c": "SHOGI:P",
-            "5d": "SHOGI:P", "5f": "SHOGI:P", "5g": "SHOGI:P",
-            "5h": "SHOGI:P", "5i": "SHOGI:P"
-          },
-          "perform": { "5e": "SHOGI:P" },
-          "drop": "SHOGI:P"
-        }
-      ]
-    }
-  }
-}
-```
+- `Sashite::Ggn::Ruleset` - Main entry point for querying moves
+- `Sashite::Ggn::Ruleset::Source` - Piece type with source positions
+- `Sashite::Ggn::Ruleset::Source::Destination` - Available destinations
+- `Sashite::Ggn::Ruleset::Source::Destination::Engine` - Move evaluator
+- `Sashite::Ggn::Ruleset::Source::Destination::Engine::Transition` - Move result
 
-### Promotion
-
-A piece moving and changing to a different piece type:
-
-```json
-{
-  "CHESS:P": {
-    "g7": {
-      "g8": [
-        {
-          "require": { "g8": "empty" },
-          "perform": { "g7": null, "g8": "CHESS:Q" }
-        }
-      ]
-    }
-  }
-}
-```
+### Key Methods
 
-## Error Handling
-
-The library provides comprehensive error handling:
-
-```ruby
-require "sashite-ggn"
-
-begin
-  # Various operations that might fail
-  piece_data = Sashite::Ggn.load_file("nonexistent.json")
-  source = piece_data.select("INVALID:PIECE")
-  destinations = source.from("invalid_square")
-  engine = destinations.to("another_invalid")
-  result = engine.where({}, {}, "")
-rescue Sashite::Ggn::ValidationError => e
-  puts "GGN validation error: #{e.message}"
-rescue KeyError => e
-  puts "Key not found: #{e.message}"
-rescue ArgumentError => e
-  puts "Invalid argument: #{e.message}"
-end
-```
-
-## Performance Considerations
-
-For large GGN files or high-frequency operations:
-
-```ruby
-# Skip validation for better performance
-piece_data = Sashite::Ggn.load_file("large_dataset.json", validate: false)
-
-# Cache frequently used engines
-@engines = {}
-def get_engine(piece, from, to)
-  key = "#{piece}:#{from}:#{to}"
-  @engines[key] ||= piece_data.select(piece).from(from).to(to)
-end
-```
+- `#pseudo_legal_transitions(board_state, captures, turn)` - Generate all moves
+- `#select(actor).from(origin).to(target)` - Query specific move
+- `#where(board_state, captures, turn)` - Evaluate move validity
 
 ## Related Specifications
 
 GGN works alongside other Sashité specifications:
 
-- **[GAN](https://sashite.dev/documents/gan/1.0.0/)** (General Actor Notation): Unique piece identifiers
-- **[FEEN](https://sashite.dev/documents/feen/1.0.0/)** (Forsyth-Edwards Enhanced Notation): Board position representation
-- **[PMN](https://sashite.dev/documents/pmn/1.0.0/)** (Portable Move Notation): Move sequence representation
-
-## Documentation
-
-- [Official GGN Specification](https://sashite.dev/documents/ggn/1.0.0/)
-- [JSON Schema](https://sashite.dev/schemas/ggn/1.0.0/schema.json)
-- [API Documentation](https://rubydoc.info/github/sashite/ggn.rb/main)
+- [GAN](https://sashite.dev/documents/gan/1.0.0/) - General Actor Notation for piece identifiers
+- [FEEN](https://sashite.dev/documents/feen/1.0.0/) - Board position representation
+- [PMN](https://sashite.dev/documents/pmn/1.0.0/) - Move sequence representation
 
 ## License
 

data/lib/sashite/ggn/move_validator.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module Sashite
+  module Ggn
+    # Centralized module for move condition validation.
+    # Contains shared logic between Engine and performance optimizations.
+    module MoveValidator
+      # Reserved for drops from hand
+      DROP_ORIGIN = "*"
+
+      # Separator in GAN (General Actor Notation) identifiers
+      GAN_SEPARATOR = ":"
+
+      private_constant :DROP_ORIGIN, :GAN_SEPARATOR
+
+      private
+
+      # Checks if the piece is available in hand for a drop move.
+      #
+      # @param actor [String] GAN identifier of the piece
+      # @param captures [Hash] Pieces available in hand
+      #
+      # @return [Boolean] true if the piece can be dropped
+      def piece_available_in_hand?(actor, captures)
+        return false unless valid_gan_format?(actor)
+
+        base_piece = extract_base_piece(actor)
+        return false if base_piece.nil?
+
+        (captures[base_piece] || 0) > 0
+      end
+
+      # Checks if the correct piece is present at the origin square on the board.
+      #
+      # @param actor [String] GAN identifier of the piece
+      # @param origin [String] Origin square
+      # @param board_state [Hash] Current board state
+      #
+      # @return [Boolean] true if the piece is at the correct position
+      def piece_on_board_at_origin?(actor, origin, board_state)
+        return false unless valid_gan_format?(actor)
+        return false unless origin.is_a?(String) && !origin.empty?
+        return false unless board_state.is_a?(Hash)
+
+        board_state[origin] == actor
+      end
+
+      # Checks if the piece belongs to the current player.
+      # Fixed version that verifies both the game name AND the case.
+      #
+      # This method now performs strict validation by ensuring:
+      # - The game identifier matches exactly with the turn parameter
+      # - The case convention is consistent (uppercase/lowercase players)
+      # - The piece part follows the same case convention as the game part
+      #
+      # @param actor [String] GAN identifier of the piece
+      # @param turn [String] Current player's game identifier
+      #
+      # @return [Boolean] true if the piece belongs to the current player
+      def piece_belongs_to_current_player?(actor, turn)
+        return false unless valid_gan_format?(actor)
+        return false unless valid_game_identifier?(turn)
+
+        game_part, piece_part = actor.split(GAN_SEPARATOR, 2)
+
+        # Strict verification: the game name must match exactly
+        # while considering case to determine the player
+        case turn
+        when turn.upcase
+          # Current player is the uppercase one
+          game_part == turn && game_part == game_part.upcase && piece_part.match?(/\A[-+]?[A-Z][']?\z/)
+        when turn.downcase
+          # Current player is the lowercase one
+          game_part == turn && game_part == game_part.downcase && piece_part.match?(/\A[-+]?[a-z][']?\z/)
+        else
+          # Turn is neither entirely uppercase nor lowercase
+          false
+        end
+      end
+
+      # Extracts the base form of a piece (removes modifiers).
+      #
+      # According to FEEN specification, pieces in hand are always stored
+      # in their base form without any state modifiers (prefixes/suffixes).
+      #
+      # @param actor [String] Complete GAN identifier
+      #
+      # @return [String, nil] Base form for hand storage, nil if invalid format
+      def extract_base_piece(actor)
+        return nil unless valid_gan_format?(actor)
+
+        game_part, piece_part = actor.split(GAN_SEPARATOR, 2)
+
+        # Safe extraction of the base character
+        match = piece_part.match(/\A[-+]?([A-Za-z])[']?\z/)
+        return nil unless match
+
+        clean_piece = match[1]
+
+        # Case consistency verification
+        game_is_upper = game_part == game_part.upcase
+        piece_is_upper = clean_piece == clean_piece.upcase
+
+        return nil unless game_is_upper == piece_is_upper
+
+        "#{game_part}#{GAN_SEPARATOR}#{clean_piece}"
+      end
+
+      # Validates the GAN format of an identifier.
+      #
+      # A valid GAN identifier must:
+      # - Be a string containing exactly one colon separator
+      # - Have a valid game identifier before the colon
+      # - Have a valid piece identifier after the colon
+      # - Maintain case consistency between game and piece parts
+      #
+      # @param actor [String] Identifier to validate
+      #
+      # @return [Boolean] true if the format is valid
+      def valid_gan_format?(actor)
+        return false unless actor.is_a?(String)
+        return false unless actor.include?(GAN_SEPARATOR)
+
+        parts = actor.split(GAN_SEPARATOR, 2)
+        return false unless parts.length == 2
+
+        game_part, piece_part = parts
+
+        return false unless valid_game_identifier?(game_part)
+        return false unless valid_piece_identifier?(piece_part)
+
+        # Case consistency verification between game and piece
+        game_is_upper = game_part == game_part.upcase
+        piece_match = piece_part.match(/\A[-+]?([A-Za-z])[']?\z/)
+        return false unless piece_match
+
+        piece_char = piece_match[1]
+        piece_is_upper = piece_char == piece_char.upcase
+
+        game_is_upper == piece_is_upper
+      end
+
+      # Validates a game identifier.
+      #
+      # Game identifiers must be non-empty strings containing only
+      # alphabetic characters, either all uppercase or all lowercase.
+      # Mixed case is not allowed as it breaks the player distinction.
+      #
+      # @param game_id [String] Game identifier to validate
+      #
+      # @return [Boolean] true if the identifier is valid
+      def valid_game_identifier?(game_id)
+        return false unless game_id.is_a?(String)
+        return false if game_id.empty?
+
+        # Must be either entirely uppercase or entirely lowercase
+        game_id.match?(/\A[A-Z]+\z/) || game_id.match?(/\A[a-z]+\z/)
+      end
+
+      # Validates a piece identifier (part after the colon).
+      #
+      # Piece identifiers follow the pattern: [optional prefix][letter][optional suffix]
+      # Where:
+      # - Optional prefix: + or -
+      # - Letter: A-Z or a-z (must match game part case)
+      # - Optional suffix: ' (apostrophe)
+      #
+      # @param piece_id [String] Piece identifier to validate
+      #
+      # @return [Boolean] true if the identifier is valid
+      def valid_piece_identifier?(piece_id)
+        return false unless piece_id.is_a?(String)
+        return false if piece_id.empty?
+
+        # Format: [optional prefix][letter][optional suffix]
+        piece_id.match?(/\A[-+]?[A-Za-z][']?\z/)
+      end
+    end
+  end
+end

data/lib/sashite/ggn/{piece → ruleset}/source/destination/engine/transition.rb

@@ -2,7 +2,7 @@
 
 module Sashite
   module Ggn
-    class Piece
+    class Ruleset
       class Source
         class Destination
           class Engine