TUPPEN

Download TUPPEN on the App Store

TUPPEN is an open-source iOS adaptation of the traditional German card game Tuppen, played particularly in the Rhineland and Lower Rhine region of Germany.

The app focuses on preserving the character of the game in a simple, offline implementation for iPhone.

About Tuppen

Tuppen is a traditional trick-taking card game played with a 32-card deck. Its distinctive rules include a round decided by the fourth trick and the option to increase the stakes by knocking. After a knock, the other players must decide whether to hold or pass.

Like many traditional card games, Tuppen has regional and table-specific variations. This project's first version implements one fixed ruleset, described in the product specification.

Features

TUPPEN 1.0 is available on the App Store with two computer opponents and the original fixed ruleset. The features below describe the combined V2–V4 update on the development branch, which has not yet been published as an App Store update. Opponent-count selection, difficulty selection, and House Rules are not included in the published 1.0 version.

• Fully offline play for one human player, with a choice of one to three computer opponents for each new match.
• Easy, Medium, or Hard computer difficulty, shared by all opponents in the match. The default is two opponents on Medium.
• Optional House Rules: seven or ten strokes, Poverty, Consecutive Knock Restriction, Four Pictures with bluffing, and Eight-Card-Rule.
• German and English interface, with an optional How to Play guide.
• Automatic local saving and match continuation.
• Local statistics.
• Independently configurable sound and haptics.
• VoiceOver controls and descriptions, Reduce Motion, and support for larger text where practical.
• No accounts, advertising, analytics, or remote backend.

How Tuppen Works

Each active player receives four cards. Players take turns playing one card into a trick and must follow the led suit whenever possible. If they cannot follow suit, they may play any card. There is no trump suit; the highest card of the led suit wins the trick and normally leads the next one.

Ranks run from weakest to strongest:

Jack < Queen < King < Ace < Seven < Eight < Nine < Ten

A normal round has four tricks. Only the fourth determines the round winner; earlier tricks determine who leads next. Losing a round normally costs one stroke (Strich in German). A player is eliminated at seven strokes, and the last remaining player wins the match.

The stake starts at one. On their turn, before playing a card, a player may Knock / Klopfen to raise it by one. The other players respond in table order:

• Hold / Halten: stay in the round and accept the higher stake for a loss.
• Pass / Passen: leave the round and receive the stake from before the raise as strokes.

If every opponent passes, the knocking player wins the round immediately. Otherwise, play resumes with that player, who must now play a card.

Screenshots

Languages

The interface supports German and English. Settings can follow the system language or select either language explicitly.

User-facing text is maintained in Apple's string catalog. Additional languages can be added through the localization and language-selection setup without changing game rules. See App presentation.

Design Philosophy

The app is intentionally small and offline-first. There are no accounts, advertisements, analytics, virtual currencies, or reward systems. The goal is to make Tuppen easy to play on an iPhone while keeping the rules and character of the game at the center.

Architecture

• Tuppen/Domain contains the authoritative Swift game engine, independent of SwiftUI. See Game engine.
• Tuppen/AI receives restricted player views containing only a bot's own hand and public information. Tuppen/Application orchestrates sessions and validates every action through the engine.
• Tuppen/Persistence saves versioned local checkpoints containing match state, random streams, and statistics. See AI and persistence.
• Tuppen/Presentation renders public state and events, with presentation pacing that keeps turns and responses sequential. See App presentation.

The project uses native Apple frameworks and has no third-party dependencies. Cards are drawn in SwiftUI. The original sound effects have documented, reproducible synthesis sources.

Requirements

• iPhone running iOS 18 or later; gameplay is portrait-oriented.
• macOS with Xcode and an iOS SDK supporting the deployment target.
• Swift 6 language mode, as configured in the project.

Debug and Release simulator builds and the non-UI test suite have been verified with Xcode 27.0. Compatibility with older Xcode versions has not been established; 27.0 is the tested version, not a claimed minimum.

Building

1. Clone the repository and open Tuppen.xcodeproj in Xcode.
2. Select the shared Tuppen scheme and an iPhone simulator or device.
3. For device builds, select the Tuppen app target and choose your own Apple Development Team under Signing & Capabilities, if needed.
4. Change the bundle identifier locally if Xcode requires a unique identifier. Apply corresponding local signing overrides to the test target when testing on a device.
5. Build and run.

No third-party dependencies need to be installed. The checked-in team and bundle identifiers identify the maintainer's signing configuration; they are not credentials or secrets and may need local overrides. Keep personal signing changes out of unrelated contributions.

To build for the simulator from the command line:

xcodebuild -project Tuppen.xcodeproj -scheme Tuppen \
  -configuration Debug -destination 'generic/platform=iOS Simulator' build

Use -configuration Release to check the release configuration.

Testing

The Swift Testing suite covers game rules, AI legality and hidden information, persistence, statistics, application/session behavior, and presentation sequencing.

List installed destinations, then run all non-UI tests with an available iPhone simulator ID:

xcodebuild -project Tuppen.xcodeproj -scheme Tuppen -showdestinations
xcodebuild -project Tuppen.xcodeproj -scheme Tuppen \
  -destination 'platform=iOS Simulator,id=SIMULATOR_ID' \
  -only-testing:TuppenTests test

Automated UI tests are intentionally not part of the project at this time. UI, accessibility interaction, sound, and haptic quality are checked manually using the verification checklist.

Privacy

Gameplay works offline and requires no account. The app has no analytics, advertising, tracking, or custom backend. Game progress, statistics, and preferences are stored locally; there is no app-managed cloud synchronization.

The bundled privacy manifest declares app-only preference storage through UserDefaults using reason CA92.1, with no tracking or collected data. Optional multiplayer through Apple Game Center / GameKit is a future roadmap item and is not included in V1.

Roadmap

The current development branch implements V2 opponent-count selection, V3 difficulty, and V4 House Rules, including their interface. These changes will form one combined update and remain unreleased. The published App Store version is TUPPEN 1.0 with the V1 scope below. V5 remains a future plan without a release schedule.

V1

Polished offline Tuppen against computer opponents.

V2 + V3

Choose one, two, or three computer opponents and Easy, Medium, or Hard difficulty in one New Game sheet. Two opponents and Medium are preselected. Medium retains the V1 approach with reduced speculative Knocks; Continue restores the saved match's configuration.

V4

Optional House Rules: maximum strokes 7 or 10, Poverty, Consecutive Knock Restriction, Four Pictures with optional bluffing, and Eight-Card-Rule. Choose these options in the expandable House Rules section of New Game. Defaults remain seven strokes with every optional rule off. Continue preserves the saved configuration, available from Match Information at the table. The tutorial explains the options, and Statistics includes Four Pictures and tiebreak counters. See App presentation for the interface boundary.

V5

Private multiplayer using Apple Game Center / GameKit.

Contributing

Read the repository development guidance and product specification before making changes.

Use English for source-code identifiers, comments, test names, and repository documentation. German and English are the current UI localizations. Keep game rules in the engine rather than SwiftUI, and include non-UI regression tests for rule changes. Useful comments are encouraged around non-obvious rules, state transitions, and architectural decisions.

Build the app and run the non-UI suite before submitting changes. Automated UI tests are intentionally not required; follow the manual verification guidance for presentation changes.

License

TUPPEN is available under the MIT License. This includes the original source code and bundled sound effects. The sounds use no external samples; their provenance is documented in Table sound and haptics.