Card Jitsu game handlers

houdini/__init__.py

@@ -78,8 +78,8 @@ class IWaddle(ABC):
         self.penguins.remove(p)
         p.waddle = None
 
-    async def send_xt(self, *data):
-        for penguin in self.penguins:
+    async def send_xt(self, *data, f=None):
+        for penguin in filter(f, self.penguins):
             await penguin.send_xt(*data)
 
     def get_seat_id(self, p):

houdini/data/ninja.py

@@ -13,6 +13,9 @@ class Card(db.Model):
     value = db.Column(db.SmallInteger, nullable=False, server_default=db.text("2"))
     description = db.Column(db.String(255), nullable=False, server_default=db.text("''::character varying"))
 
+    def get_string(self):
+        return f'{self.id}|{self.element}|{self.value}|{self.color}|{self.power_id}'
+
 
 class CardStarterDeck(db.Model):
     __tablename__ = 'card_starter_deck'

houdini/handlers/games/match.py

@@ -5,9 +5,9 @@ from dataclasses import dataclass
 from houdini import handlers
 from houdini.data.room import RoomWaddle
 from houdini.handlers import XTPacket
-from houdini.handlers.games.ninja.card import CardJitsuLogic
-from houdini.handlers.games.ninja.fire import CardJitsuFireLogic
-from houdini.handlers.games.ninja.water import CardJitsuWaterLogic
+from houdini.handlers.games.ninja.card import SenseiLogic, CardJitsuLogic, CardJitsuMatLogic
+from houdini.handlers.games.ninja.fire import FireSenseiLogic, CardJitsuFireLogic
+from houdini.handlers.games.ninja.water import WaterSenseiLogic, CardJitsuWaterLogic
 from houdini.penguin import Penguin
 
 
@@ -89,13 +89,15 @@ async def card_color_tick(matched):
         await mm.penguin.send_xt('tmm', len(matched), mm.tick, *nicknames)
 
 
-def card_match(waddle_room_id, waddle_game):
+def card_match(waddle_game):
     async def match(matched):
         nicknames = [f'{mm.penguin.safe_name}|{mm.penguin.color}' for mm in matched]
         host = matched[0].penguin
 
-        waddle_room = host.server.rooms[waddle_room_id]
+        waddle_room = host.server.rooms[waddle_game.room_id]
         rw = RoomWaddle(id=host.id, room_id=waddle_room.id, seats=len(matched), game=waddle_game, temporary=True)
+        rw.room = waddle_room
+        rw.logic = waddle_game
         waddle_room.waddles[rw.id] = rw
 
         for mm in matched:
@@ -103,9 +105,9 @@ def card_match(waddle_room_id, waddle_game):
     return match
 
 
-card_matched = card_match(CardJitsuLogic.room_id, 'card')
-card_fire_matched = card_match(CardJitsuFireLogic.room_id, 'fire')
-card_water_matched = card_match(CardJitsuWaterLogic.room_id, 'water')
+card_matched = card_match(CardJitsuLogic)
+card_fire_matched = card_match(CardJitsuFireLogic)
+card_water_matched = card_match(CardJitsuWaterLogic)
 
 
 @handlers.boot
@@ -142,11 +144,23 @@ async def handle_join_water_match_making(p):
     await p.send_xt('jmm', p.safe_name)
 
 
+@handlers.handler(XTPacket('gwcj', ext='z'))
+async def handle_get_card_jitsu_mat(p, waddle_id: int):
+    waddle_id = max(200, min(300, waddle_id))
+    if p.room.igloo and waddle_id not in p.room.waddles:
+        rw = RoomWaddle(id=waddle_id, room_id=p.room.id, seats=2, game='card', temporary=True)
+        rw.room = p.room
+        rw.logic = CardJitsuMatLogic
+        p.room.waddles[rw.id] = rw
+
+
 @handlers.handler(XTPacket('jsen', ext='z'))
 @handlers.player_in_room(MatchMaking.SenseiRoom)
 async def handle_join_sensei_match(p):
-    waddle_room = p.server.rooms[CardJitsuLogic.room_id]
+    waddle_room = p.server.rooms[SenseiLogic.room_id]
     rw = RoomWaddle(id=p.id, room_id=waddle_room.id, seats=1, game='sensei', temporary=True)
+    rw.room = waddle_room
+    rw.logic = SenseiLogic
     waddle_room.waddles[rw.id] = rw
 
     await p.send_xt('scard', waddle_room.id, rw.id, 1, 0, f'{p.safe_name}|{p.color}')
@@ -155,8 +169,10 @@ async def handle_join_sensei_match(p):
 @handlers.handler(XTPacket('jsen', ext='z'))
 @handlers.player_in_room(MatchMaking.SenseiFireRoom)
 async def handle_join_fire_sensei_match(p):
-    waddle_room = p.server.rooms[CardJitsuFireLogic.room_id]
+    waddle_room = p.server.rooms[FireSenseiLogic.room_id]
     rw = RoomWaddle(id=p.id, room_id=waddle_room.id, seats=1, game='firesensei', temporary=True)
+    rw.room = waddle_room
+    rw.logic = FireSenseiLogic
     waddle_room.waddles[rw.id] = rw
 
     await p.send_xt('scard', waddle_room.id, rw.id, 1, 0, f'{p.safe_name}|{p.color}')
@@ -165,8 +181,10 @@ async def handle_join_fire_sensei_match(p):
 @handlers.handler(XTPacket('jsen', ext='z'))
 @handlers.player_in_room(MatchMaking.SenseiWaterRoom)
 async def handle_join_water_sensei_match(p):
-    waddle_room = p.server.rooms[CardJitsuWaterLogic.room_id]
+    waddle_room = p.server.rooms[WaterSenseiLogic.room_id]
     rw = RoomWaddle(id=p.id, room_id=waddle_room.id, seats=1, game='watersensei', temporary=True)
+    rw.room = waddle_room
+    rw.logic = WaterSenseiLogic
     waddle_room.waddles[rw.id] = rw
 
     await p.send_xt('scard', waddle_room.id, rw.id, 1, 0, f'{p.safe_name}|{p.color}')

houdini/handlers/games/ninja/card.py

@@ -1,9 +1,13 @@
 import itertools
+import math
+import random
+from collections import Counter
 from dataclasses import dataclass
 from typing import Dict, List, Union
 
-from houdini import IWaddle
+from houdini import IWaddle, handlers
 from houdini.data.ninja import Card
+from houdini.handlers import XTPacket
 from houdini.penguin import Penguin
 
 
@@ -13,34 +17,47 @@ class Played:
     card: Card
     player: int
     opponent: int
+    value: int
+    element: str
 
 
 @dataclass
 class Ninja:
     penguin: Penguin
-    deck: Dict[int, Card]
+    deck: Dict[int, Played]
     bank: Dict[str, List[Played]]
     chosen: Union[Played, None]
 
 
 class CardJitsuLogic(IWaddle):
     room_id = 998
-    rule_set = {'f': 's', 'w': 'f', 's': 'w'}
-    discard_elements = {4: 's', 5: 'w', 6: 'f'}
-    discard_colors = {7: 'r', 8: 'b', 9: 'g', 10: 'y', 11: 'o', 12: 'p'}
-    replacements = {16: ['w', 'f'], 17: ['s', 'w'], 18: ['f', 's']}
-    rank_speed = 1
+
+    RuleSet = {'f': 's', 'w': 'f', 's': 'w'}
+    DiscardElements = {4: 's', 5: 'w', 6: 'f'}
+    DiscardColors = {7: 'r', 8: 'b', 9: 'g', 10: 'y', 11: 'o', 12: 'p'}
+    Replacements = {16: ['w', 'f'], 17: ['s', 'w'], 18: ['f', 's']}
+    PowerLimiters = {13: 's', 14: 'f', 15: 'w'}
+
+    OnPlayed = {1, 16, 17, 18}
+    CurrentRound = {4, 5, 6, 7, 8, 9, 10, 11, 12, 16, 17, 18}
+    AffectsOwnPlayer = {2}
+
+    ItemAwards = [4025, 4026, 4027, 4028, 4029, 4030, 4031, 4032, 4033, 104]
+    PostcardAwards = {0: 177, 4: 178, 8: 179}
+    StampAwards = {0: 230, 4: 232, 8: 234, 9: 236}
+    StampGroupId = 38
+
+    RankSpeed = 1
 
     def __init__(self, waddle):
         super().__init__(waddle)
 
-        self.ninjas = [
-            Ninja(
-                penguin=p,
-                deck={},
-                bank={'f': [], 'w': [], 's': []},
-                chosen=None
-            ) for p in waddle.penguins]
+        self.ninjas = [Ninja(
+            penguin=p,
+            deck={},
+            bank={'f': [], 'w': [], 's': []},
+            chosen=None
+        ) for p in waddle.penguins]
 
         self.card_id = 1
         self.powers = {}
@@ -64,29 +81,28 @@ class CardJitsuLogic(IWaddle):
         return False, -1
 
     def has_cards_to_play(self, seat_id):
-        power_limiters = {13: 's', 14: 'f', 15: 'w'}
-        for power_id, element in power_limiters.items():
+        for power_id, element in CardJitsuLogic.PowerLimiters.items():
             if power_id in self.powers:
                 power_card = self.powers[power_id]
                 if power_card.opponent == seat_id:
                     opponent_deck = self.ninjas[power_card.opponent].deck
                     for card_id, card in opponent_deck.items():
-                        if card.element != element:
+                        if card.card.element != element:
                             return True
                     return False
         return True
 
     def discard_opponent_card(self, power_id, opponent_seat_id):
         opponent_cards = self.ninjas[opponent_seat_id].bank
-        if power_id in self.discard_elements:
-            element_to_discard = self.discard_elements[power_id]
+        if power_id in self.DiscardElements:
+            element_to_discard = self.DiscardElements[power_id]
             if len(opponent_cards[element_to_discard]) > 0:
                 card_to_discard = self.ninjas[opponent_seat_id].bank[element_to_discard][-1]
                 self.discards.append(card_to_discard.id)
                 del self.ninjas[opponent_seat_id].bank[element_to_discard][-1]
                 return True
-        if power_id in self.discard_colors:
-            color_to_discard = self.discard_colors[power_id]
+        if power_id in self.DiscardColors:
+            color_to_discard = self.DiscardColors[power_id]
             for element, cards in opponent_cards.items():
                 for index, card in enumerate(cards):
                     if card.card.color == color_to_discard:
@@ -98,76 +114,81 @@ class CardJitsuLogic(IWaddle):
 
     def adjust_card_values(self, first_card, second_card):
         for power_id, power_card in self.powers.items():
-            if power_card.card.power_id == 1 and first_card.card.element == second_card.card.element:
-                first_card.card.value = 1
-                second_card.card.value = 1
+            if power_card.card.power_id == 1 and first_card.element == second_card.element:
+                swap_value = first_card.value
+                first_card.value = second_card.value
+                second_card.value = swap_value
             if power_card.card.power_id == 2:
                 if power_card.player == 0:
-                    first_card.card.value += 2
+                    first_card.value += 2
                 else:
-                    second_card.card.value += 2
+                    second_card.value += 2
             if power_card.card.power_id == 3:
                 if power_card.player == 0:
-                    second_card.card.value -= 2
+                    second_card.value -= 2
                 else:
-                    first_card.card.value -= 2
-
-    def get_round_winner(self):
-        first_card, second_card = self.ninjas[0].chosen, self.ninjas[1].chosen
-        winner_seat_id = self.get_winner_seat_id(first_card, second_card)
-        self.adjust_card_values(first_card, second_card)
+                    first_card.value -= 2
 
+    def on_played_effects(self, first_card, second_card):
         for ninja_seat_id, ninja in enumerate(self.ninjas):
             played_card = ninja.chosen
             power_id = played_card.card.power_id
             if not power_id:
                 continue
-
-            opponent_seat_id = 1 if ninja_seat_id == 0 else 0
-
-            on_played = power_id in {1, 16, 17, 18}
-            on_scored = not on_played
-            current_round = power_id in {4, 5, 6, 7, 8, 9, 10, 11, 12, 16, 17, 18}
+            on_played = power_id in CardJitsuLogic.OnPlayed
+            current_round = power_id in CardJitsuLogic.CurrentRound
             next_round = not current_round
-
-            if on_played and next_round:
-                self.powers[power_id] = played_card
-            if on_scored and ninja_seat_id == winner_seat_id:
+            if on_played:
                 if next_round:
                     self.powers[power_id] = played_card
                 if current_round:
-                    self.discard_opponent_card(power_id, opponent_seat_id)
-            if on_played and current_round:
-                self.replace_opponent_card(power_id, first_card, second_card, played_card.player)
-        winner_seat_id = self.get_winner_seat_id(first_card, second_card)
+                    self.replace_cards(power_id, first_card, second_card)
 
-        self.ninjas[0].chosen = None
-        self.ninjas[1].chosen = None
+    def on_scored_effects(self, first_card, second_card):
+        winner_seat_id = self.get_winner_seat_id(first_card, second_card)
+        for ninja_seat_id, ninja in enumerate(self.ninjas):
+            power_id = ninja.chosen.card.power_id
+            if power_id:
+                opponent_seat_id = (ninja_seat_id + 1) % 2
+                on_scored = power_id not in CardJitsuLogic.OnPlayed
+                current_round = power_id in CardJitsuLogic.CurrentRound
+                next_round = not current_round
+                if on_scored and ninja_seat_id == winner_seat_id:
+                    if next_round:
+                        self.powers[power_id] = ninja.chosen
+                    if current_round:
+                        self.discard_opponent_card(power_id, opponent_seat_id)
+
+    def get_round_winner(self):
+        first_card, second_card = self.ninjas[0].chosen, self.ninjas[1].chosen
+        self.adjust_card_values(first_card, second_card)
+        self.powers = {}
+        self.on_played_effects(first_card, second_card)
+        self.on_scored_effects(first_card, second_card)
+        winner_seat_id = self.get_winner_seat_id(first_card, second_card)
         return winner_seat_id
 
     @classmethod
-    def replace_opponent_card(cls, power_id, first_card, second_card, seat_id):
-        for replace_power_id, replacement in cls.replacements.items():
-            if power_id == replace_power_id:
-                original, replace = replacement
-                if seat_id == 1 and first_card.card.element == original:
-                    first_card.card.element = replace
-                if seat_id == 0 and second_card.card.element == original:
-                    second_card.card.element = replace
+    def replace_cards(cls, power_id, first_card, second_card):
+        original, replace = cls.Replacements[power_id]
+        if first_card.element == original:
+            first_card.element = replace
+        if second_card.element == original:
+            second_card.element = replace
 
     @classmethod
     def get_winner_seat_id(cls, first_card, second_card):
-        if first_card.card.element != second_card.card.element:
-            return 0 if cls.rule_set[first_card.card.element] == second_card.card.element else 1
-        elif first_card.card.value > second_card.card.value:
+        if first_card.element != second_card.element:
+            return 0 if cls.RuleSet[first_card.element] == second_card.element else 1
+        elif first_card.value > second_card.value:
             return 0
-        elif second_card.card.value > first_card.card.value:
+        elif second_card.value > first_card.value:
             return 1
         return -1
 
 
 class CardJitsuMatLogic(CardJitsuLogic):
-    rank_speed = 0.5
+    RankSpeed = 0.5
 
 
 class SenseiLogic(CardJitsuLogic):
@@ -175,27 +196,341 @@ class SenseiLogic(CardJitsuLogic):
     def __init__(self, waddle):
         super().__init__(waddle)
 
-        self.ninja = Ninja(
-                penguin=waddle.penguins[0],
-                deck={},
-                bank={'f': [], 'w': [], 's': []},
-                chosen=None
-        )
+        self.ninjas.insert(0, Ninja(
+            penguin=waddle.penguins[0],
+            deck={},
+            bank={'f': [], 'w': [], 's': []},
+            chosen=None
+        ))
 
         self.sensei_move = {}
         self.colors = []
 
     def get_win_card(self, card):
         self.colors = [] if len(self.colors) >= 6 else self.colors
-        for card_check in self.ninja.penguin.server.cards.values():
-            if self.beats_card(card_check, card) and card_check.color not in self.colors:
+        for card_check in self.penguins[0].server.cards.values():
+            if card_check.color not in self.colors and self.beats_card(card_check, card):
                 self.colors.append(card_check.color)
                 return card_check
 
     @classmethod
     def beats_card(cls, card_check, card_play):
-        if card_check.card.element != card_play.card.element:
-            return True if cls.rule_set[card_check.card.element] == card_play.card.element else False
-        elif card_check.card.value > card_play.card.value:
+        if card_check.element != card_play.element:
+            return True if cls.RuleSet[card_check.element] == card_play.element else False
+        elif card_check.value > card_play.value:
             return True
         return False
+
+
+async def ninja_rank_up(p, ranks=1):
+    if p.ninja_rank + ranks > len(CardJitsuLogic.ItemAwards):
+        return False
+    for rank in range(p.ninja_rank, p.ninja_rank+ranks):
+        await p.add_inventory(p.server.items[CardJitsuLogic.ItemAwards[rank]], notify=False)
+        if rank in CardJitsuLogic.PostcardAwards:
+            await p.add_inbox(p.server.postcards[CardJitsuLogic.PostcardAwards[rank]])
+        if rank in CardJitsuLogic.StampAwards:
+            await p.add_stamp(p.server.stamps[CardJitsuLogic.StampAwards[rank]])
+    await p.update(ninja_rank=p.ninja_rank + ranks, ninja_progress=0).apply()
+    return True
+
+
+async def ninja_progress(p, won=False):
+    if p.ninja_rank == 0:
+        await p.update(ninja_progress=100).apply()
+    elif p.ninja_rank < 9:
+        speed = type(p.waddle).RankSpeed
+        if not won:
+            speed *= 0.5
+        points = math.floor((100 / p.ninja_rank) * speed)
+        await p.update(ninja_progress=p.ninja_progress+points).apply()
+    if p.ninja_progress >= 100:
+        await ninja_rank_up(p)
+        await p.send_xt('cza', p.ninja_rank)
+
+
+async def ninja_stamps_earned(p):
+    game_stamps = [stamp for stamp in p.server.stamps.values() if stamp.group_id == p.room.stamp_group]
+    collected_stamps = [stamp for stamp in game_stamps if stamp.id in p.stamps]
+    total_collected_stamps = len(collected_stamps)
+    total_game_stamps = len(game_stamps)
+    collected_stamps_string = '|'.join(str(stamp.id) for stamp in collected_stamps)
+    await p.send_xt('cjsi', collected_stamps_string, total_collected_stamps, total_game_stamps)
+
+
+async def ninja_win(winner, loser):
+    await ninja_progress(winner.penguin, won=True)
+    await ninja_progress(loser.penguin, won=False)
+    await ninja_stamps_earned(winner.penguin)
+    await ninja_stamps_earned(loser.penguin)
+    await winner.penguin.waddle.remove_penguin(winner.penguin)
+    await loser.penguin.waddle.remove_penguin(loser.penguin)
+
+
+@handlers.handler(XTPacket('gz', ext='z'))
+@handlers.waddle(CardJitsuLogic, CardJitsuMatLogic)
+async def handle_get_game(p):
+    seat_id = p.waddle.get_seat_id(p)
+    await p.send_xt('gz', p.waddle.seats, len(p.waddle.penguins))
+    await p.send_xt('jz', seat_id, p.safe_name, p.color, p.ninja_rank)
+
+
+@handlers.handler(XTPacket('uz', ext='z'))
+@handlers.waddle(CardJitsuLogic, CardJitsuMatLogic)
+async def handle_update_game(p):
+    players = [f'{seat_id}|{player.safe_name}|{player.color}|{player.ninja_rank}'
+               for seat_id, player in enumerate(p.waddle.penguins)]
+    await p.send_xt('uz', *players)
+    await p.send_xt('sz')
+
+
+@handlers.handler(XTPacket('lz', ext='z'))
+@handlers.waddle(CardJitsuLogic, CardJitsuMatLogic, SenseiLogic)
+async def handle_leave_game(p):
+    seat_id = p.waddle.get_seat_id(p)
+    await p.waddle.send_xt('cz', p.safe_name, f=lambda penguin: penguin is not p)
+    await p.waddle.send_xt('lz', seat_id, f=lambda penguin: penguin is not p)
+    await p.waddle.remove_penguin(p)
+
+
+@handlers.handler(XTPacket('zm', ext='z'), match=['deal'])
+@handlers.waddle(CardJitsuLogic, CardJitsuMatLogic)
+async def handle_send_deal(p, action: str):
+    seat_id = p.waddle.get_seat_id(p)
+    opponent_seat_id = (seat_id + 1) % 2
+    me = p.waddle.ninjas[seat_id]
+
+    deck = Counter((card.card_id for card in p.cards.values() for _ in range(card.quantity + card.member_quantity)))
+    dealt = Counter((played.card.id for played in me.deck.values()))
+    undealt = random.sample(list((deck - dealt).elements()), 5 - len(me.deck))
+
+    strings = []
+    for card_id in undealt:
+        card = p.server.cards[card_id]
+        me.deck[p.waddle.card_id] = Played(
+            id=p.waddle.card_id,
+            card=card,
+            player=seat_id,
+            opponent=opponent_seat_id,
+            value=card.value,
+            element=card.element
+        )
+        strings.append(f'{p.waddle.card_id}|{card.get_string()}')
+        p.waddle.card_id += 1
+
+    await p.waddle.send_xt('zm', action, seat_id, *strings)
+
+
+@handlers.handler(XTPacket('zm', ext='z'), match=['pick'])
+@handlers.waddle(CardJitsuLogic, CardJitsuMatLogic)
+async def handle_send_pick(p, action: str, card_id: int):
+    seat_id = p.waddle.get_seat_id(p)
+    opponent_seat_id = (seat_id + 1) % 2
+    me = p.waddle.ninjas[seat_id]
+    opponent = p.waddle.ninjas[opponent_seat_id]
+
+    if card_id not in me.deck or me.chosen is not None:
+        return
+
+    me.chosen = me.deck[card_id]
+    del me.deck[card_id]
+    await p.waddle.send_xt('zm', action, seat_id, card_id)
+
+    if me.chosen and opponent.chosen:
+        winner_seat_id = p.waddle.get_round_winner()
+
+        if me.chosen.card.id == 256 or opponent.chosen.card.id == 256:
+            stamp = p.server.stamps[246]
+            await me.penguin.add_stamp(stamp, notify=True)
+            await opponent.penguin.add_stamp(stamp, notify=True)
+
+        if me.chosen.card.power_id and me.chosen.card.power_id in CardJitsuLogic.OnPlayed:
+            await p.waddle.send_xt('zm', 'power', seat_id, opponent_seat_id, me.chosen.card.power_id)
+        if opponent.chosen.card.power_id and opponent.chosen.card.power_id in CardJitsuLogic.OnPlayed:
+            await p.waddle.send_xt('zm', 'power', opponent_seat_id, seat_id, opponent.chosen.card.power_id)
+
+        if winner_seat_id != -1:
+            loser_seat_id = (winner_seat_id + 1) % 2
+            winner = p.waddle.ninjas[winner_seat_id]
+            loser = p.waddle.ninjas[loser_seat_id]
+            winning_card = winner.chosen
+            winner.bank[winning_card.card.element].append(winning_card)
+
+            if winning_card.card.power_id and winning_card.card.power_id not in CardJitsuLogic.OnPlayed:
+                affects_own_player = winning_card.card.power_id in CardJitsuLogic.AffectsOwnPlayer
+                sender, recipient = (winner_seat_id, winner_seat_id) if affects_own_player else (winner_seat_id, loser_seat_id)
+                await p.waddle.send_xt('zm', 'power', sender, recipient, winning_card.card.power_id, *p.waddle.discards)
+                p.waddle.discards = []
+
+            winning_cards, win_method = p.waddle.get_winning_cards(winner_seat_id)
+            if winning_cards:
+                await p.waddle.send_xt('czo', 0, winner_seat_id, *(card.id for card in winning_cards))
+
+                stamp = p.server.stamps[[244, 242][win_method]]
+                await winner.penguin.add_stamp(stamp, notify=True)
+                if all(not cards for cards in loser.bank.values()):
+                    stamp = p.server.stamps[238]
+                    await winner.penguin.add_stamp(stamp, notify=True)
+                if sum(1 for cards in winner.bank.values() for _ in cards) >= 9:
+                    stamp = p.server.stamps[248]
+                    await winner.penguin.add_stamp(stamp, notify=True)
+
+                await winner.penguin.update(ninja_matches_won=winner.penguin.ninja_matches_won+1).apply()
+                if winner.penguin.ninja_matches_won == 25:
+                    stamp = p.server.stamps[240]
+                    await winner.penguin.add_stamp(stamp, notify=True)
+
+                await ninja_win(winner, loser)
+            else:
+                for seat_id, ninja in enumerate(p.waddle.ninjas):
+                    if not p.waddle.has_cards_to_play(seat_id):
+                        winner_seat_id = (seat_id + 1) % 2
+                        winner = p.waddle.ninjas[winner_seat_id]
+                        loser = p.waddle.ninjas[seat_id]
+
+                        await p.waddle.send_xt('czo', 0, winner_seat_id)
+                        await ninja_win(winner, loser)
+        await me.penguin.send_xt('zm', 'judge', winner_seat_id)
+        await opponent.penguin.send_xt('zm', 'judge', winner_seat_id)
+        me.chosen = None
+        opponent.chosen = None
+
+
+@handlers.handler(XTPacket('gz', ext='z'))
+@handlers.waddle(SenseiLogic)
+async def handle_get_sensei_game(p):
+    await p.send_xt('gz', 2, 2)
+    await p.send_xt('jz', 1, p.safe_name, p.color, p.ninja_rank)
+
+
+@handlers.handler(XTPacket('uz', ext='z'))
+@handlers.waddle(SenseiLogic)
+async def handle_update_sensei_game(p):
+    await p.send_xt('uz', '0|Sensei|14|10', f'1|{p.safe_name}|{p.color}|{p.ninja_rank}')
+    await p.send_xt('sz')
+
+
+@handlers.handler(XTPacket('zm', ext='z'), match=['deal'])
+@handlers.waddle(SenseiLogic)
+async def handle_send_sensei_deal(p, action: str):
+    can_beat_sensei = p.ninja_rank > len(CardJitsuLogic.ItemAwards) - 1
+    sensei, me = p.waddle.ninjas
+    deck = Counter((card.card_id for card in p.cards.values() if
+                    can_beat_sensei or p.server.cards[card.card_id].power_id == 0
+                    for _ in range(card.quantity + card.member_quantity)))
+    dealt = Counter((played.card.id for played in me.deck.values()))
+    undealt = random.sample(list((deck - dealt).elements()), 5 - len(me.deck))
+
+    strings = []
+    sensei_strings = []
+    for card_id in undealt:
+        card = p.server.cards[card_id]
+        me.deck[p.waddle.card_id] = Played(
+            id=p.waddle.card_id,
+            card=card,
+            player=1,
+            opponent=0,
+            value=card.value,
+            element=card.element
+        )
+        strings.append(f'{p.waddle.card_id}|{card.get_string()}')
+        p.waddle.card_id += 1
+
+        sensei_card = random.choice(list(p.server.cards.values())) if can_beat_sensei else p.waddle.get_win_card(card)
+
+        sensei.deck[p.waddle.card_id] = Played(
+            id=p.waddle.card_id,
+            card=sensei_card,
+            player=0,
+            opponent=1,
+            value=sensei_card.value,
+            element=sensei_card.element
+        )
+
+        sensei_strings.append(f'{p.waddle.card_id}|{sensei_card.get_string()}')
+        p.waddle.sensei_move[p.waddle.card_id - 1] = p.waddle.card_id
+        p.waddle.card_id += 1
+
+    await p.waddle.send_xt('zm', action, 0, *sensei_strings)
+    await p.waddle.send_xt('zm', action, 1, *strings)
+
+
+@handlers.handler(XTPacket('zm', ext='z'), match=['pick'])
+@handlers.waddle(SenseiLogic)
+async def handle_send_sensei_pick(p, action: str, card_id: int):
+    sensei, me = p.waddle.ninjas
+
+    if card_id not in me.deck or me.chosen is not None:
+        return
+
+    me.chosen = me.deck[card_id]
+    sensei.chosen = sensei.deck[p.waddle.sensei_move[card_id]]
+
+    del me.deck[card_id]
+    del sensei.deck[p.waddle.sensei_move[card_id]]
+    del p.waddle.sensei_move[card_id]
+
+    await p.send_xt('zm', action, 0, sensei.chosen.id)
+    await p.send_xt('zm', action, 1, me.chosen.id)
+
+    winner_seat_id = p.waddle.get_round_winner()
+
+    if me.chosen.card.id == 256 or sensei.chosen.card.id == 256:
+        stamp = p.server.stamps[246]
+        await p.add_stamp(stamp, notify=True)
+
+    if me.chosen.card.power_id and me.chosen.card.power_id in CardJitsuLogic.OnPlayed:
+        await p.send_xt('zm', 'power', 1, 0, me.chosen.card.power_id)
+    if sensei.chosen.card.power_id and sensei.chosen.card.power_id in CardJitsuLogic.OnPlayed:
+        await p.send_xt('zm', 'power', 0, 1, sensei.chosen.card.power_id)
+
+    if winner_seat_id != -1:
+        loser_seat_id = (winner_seat_id + 1) % 2
+        winner = sensei if winner_seat_id == 0 else me
+        winning_card = sensei.chosen if winner_seat_id == 0 else me.chosen
+        winner.bank[winning_card.card.element].append(winning_card)
+
+        if winning_card.card.power_id and winning_card.card.power_id not in CardJitsuLogic.OnPlayed:
+            affects_own_player = winning_card.card.power_id in CardJitsuLogic.AffectsOwnPlayer
+            sender, recipient = (winner_seat_id, winner_seat_id) if affects_own_player else (winner_seat_id, loser_seat_id)
+            await p.send_xt('zm', 'power', sender, recipient, winning_card.card.power_id, *p.waddle.discards)
+            p.waddle.discards = []
+
+        winning_cards, win_method = p.waddle.get_winning_cards(winner_seat_id)
+        if winning_cards:
+            await p.waddle.send_xt('czo', 0, winner_seat_id, *(card.id for card in winning_cards))
+
+            if winner == me:
+                stamp = p.server.stamps[[244, 242][win_method]]
+                await p.add_stamp(stamp, notify=True)
+                if all(not cards for cards in sensei.bank.values()):
+                    stamp = p.server.stamps[238]
+                    await p.add_stamp(stamp, notify=True)
+                if sum(1 for cards in me.bank.values() for _ in cards) >= 9:
+                    stamp = p.server.stamps[248]
+                    await p.add_stamp(stamp, notify=True)
+
+                await p.update(ninja_matches_won=p.ninja_matches_won + 1).apply()
+                if p.ninja_matches_won == 25:
+                    stamp = p.server.stamps[240]
+                    await p.add_stamp(stamp, notify=True)
+
+                await ninja_stamps_earned(p)
+                can_rank_up = await ninja_rank_up(p)
+                if can_rank_up:
+                    await p.send_xt('cza', p.ninja_rank)
+        else:
+            for seat_id, ninja in enumerate(p.waddle.ninjas):
+                if not p.waddle.has_cards_to_play(seat_id):
+                    winner_seat_id = (seat_id + 1) % 2
+                    winner = p.waddle.ninjas[winner_seat_id]
+                    if winner == me:
+                        can_rank_up = await ninja_rank_up(p)
+                        if can_rank_up:
+                            await p.send_xt('cza', p.ninja_rank)
+                    await p.waddle.send_xt('czo', 0, winner_seat_id)
+                    await ninja_stamps_earned(p)
+
+    await p.send_xt('zm', 'judge', winner_seat_id)
+    me.chosen = None
+    sensei.chosen = None

houdini/handlers/play/navigation.py

@@ -13,7 +13,7 @@ from houdini.data.room import PenguinBackyardRoom, PenguinIglooRoom, Room, RoomC
 from houdini.handlers import XTPacket
 from houdini.handlers.games.four import ConnectFourLogic
 from houdini.handlers.games.mancala import MancalaLogic
-from houdini.handlers.games.ninja.card import CardJitsuLogic, SenseiLogic
+from houdini.handlers.games.ninja.card import CardJitsuLogic, CardJitsuMatLogic, SenseiLogic
 from houdini.handlers.games.ninja.fire import CardJitsuFireLogic, FireSenseiLogic
 from houdini.handlers.games.ninja.water import CardJitsuWaterLogic, WaterSenseiLogic
 from houdini.handlers.games.sled import SledRacingLogic
@@ -29,7 +29,8 @@ TableLogicMapping = {
 WaddleLogicMapping = {
     'sled': SledRacingLogic,
 
-    'card': CardJitsuLogic,
+    'card': CardJitsuMatLogic,
+    'match': CardJitsuLogic,
     'sensei': SenseiLogic,
 
     'water': CardJitsuWaterLogic,