Keieit and Rabbit SP.Card completed

Card.py

@@ -1,18 +1,11 @@
 class Card:
-    ATK = 0
+    def __init__(self):
-    DEF = 1
+        pass
-    OTHER = 2
-    SP_ATK = 3
-    SP_DEF = 4
-    SP_OTHER = 5
-    
-    def __init__(self, cardtype):
-        self.type = cardtype
 
 
 class ATKCard(Card):
     def __init__(self, id, name):
-        super(ATKCard, self).__init__(Card.ATK)
+        super(ATKCard, self).__init__()
         self.id = id
         self.name = name
         self.damage = 0
@@ -26,7 +19,7 @@ class ATKCard(Card):
 
 class DEFCard(Card):
     def __init__(self, id, name):
-        super(DEFCard, self).__init__(Card.DEF)
+        super(DEFCard, self).__init__()
         self.id = id
         self.name = name
     def __repr__(self):
@@ -37,7 +30,7 @@ class DEFCard(Card):
 
 class OtherCard(Card):
     def __init__(self, id, name):
-        super(OtherCard, self).__init__(Card.OTHER)
+        super(OtherCard, self).__init__()
         self.id = id
         self.name = name
     def __repr__(self):
@@ -45,17 +38,28 @@ class OtherCard(Card):
     def active(self):
         pass
 
+class SPATKCard(ATKCard):
+    def __init__(self, id, name):
+        super(SPATKCard, self).__init__(id, name)
+    def __repr__(self):
+        return self.name + "(SP.ATK)"
+
+class SPDEFCard(DEFCard):
+    def __init__(self, id, name):
+        super(SPDEFCard, self).__init__(id, name)
+    def __repr__(self):
+        return self.name + "(SP.DEF)"
 # Abstract Class Definition
 
 class Attack(ATKCard):
     def __init__(self):
         super(Attack, self).__init__(1 ,"攻擊")
         self.damage = 2
-        self.text = "可悲垃圾{}打了{}2"
+        self.text = "可悲垃圾{}打了{}{}"
     def active(self, cur, ene):
-        self.texts = [cur.name, ene.name]
+        self.texts = [cur.name, ene.name, self.damage]
-        ene.inc_hp(0-self.damage)
+        if not ene.inc_hp(0-self.damage):
-        print(self.text.format(*self.texts))
+            print(self.text.format(*self.texts))
 
 class Defend(DEFCard):
     def __init__(self):
@@ -94,12 +98,12 @@ class Suprise(ATKCard):
     def __init__(self):
         super(Suprise, self).__init__(6 ,"奇襲")
         self.damage = 1
-        self.text = "{}攻擊{}1，並使其掉落了一張{}"
+        self.text = "{}攻擊{}{}，並使其掉落了一張{}"
     def active(self, cur, ene):
         card = ene.drop()
-        self.texts = [cur.name, ene.name]
+        self.texts = [cur.name, ene.name, self.damage]
         if not card:
-            self.text = "{}攻擊{}1"
+            self.text = "{}攻擊{}{}"
         else:
             self.texts.append(card)
         ene.inc_hp(0-self.damage)
@@ -131,7 +135,6 @@ class Plan(OtherCard):
             except:
                 pass
 
-
 class Sweep(ATKCard):
     def __init__(self):
         super(Sweep, self).__init__(10 ,"掃射的啦")
@@ -179,25 +182,68 @@ class Frenzy(ATKCard):
     def __init__(self):
         super(Frenzy, self).__init__(15, "星爆氣流斬")
         self.damage = 3
-        self.text = "可悲垃圾{}打了{}3，並回復了3"
+        self.text = "可悲垃圾{}打了{}{}，並回復了3"
     def active(self, cur, ene):
         
-        self.texts = [cur.name, ene.name]
+        self.texts = [cur.name, ene.name, self.damage]
         ene.inc_hp(0-self.damage)
         cur.inc_hp(3)
-        print(self.text.format(*self.texts))       
+        print(self.text.format(*self.texts))
+
+class Guo1(SPDEFCard):
+    def __init__(self):
+        super(Guo1, self).__init__(101, "空間之鍊(門)")
+    def passive(self, cur, ene, card):
+        print("無效敵方能力並將1張{}加入手中".format(card))
+        cur.get(card)
+
+class Guo2(OtherCard):
+    def __init__(self):
+        super(Guo2, self).__init__(102, "空間之鍊(殼)")
+    def active(self, cur, ene):
+        print("下2個敵方的回合{}將不會受到傷害".format(cur.name))
+        cur.guard = 2
+
+class Guo3(SPATKCard):
+    def __init__(self):
+        super(Guo3, self).__init__(103, "空間之鍊(滅)")
+        self.damage = 5
+    def active(self, cur, ene):
+        print("對敵方造成5點傷害並使敵方損失2張手牌")
+        ene.drop(2)
+        ene.inc_hp(0-self.damage)
+
+class Rabbit1(SPATKCard):
+    def __init__(self):
+        super(Rabbit1, self).__init__(201, "科學無用論(高速砍擊)")
+        self.damage = 3
+    def active(self, cur, ene):
+        ene.inc_hp(0-self.damage)
+        print("優先於一切防禦能力的3點傷害攻擊")
+
+class Rabbit2(OtherCard):
+    def __init__(self):
+        super(Rabbit2, self).__init__(202, "科學無用論(力量增幅)")
+    def active(self, cur, ene):
+        cur.boost = 3
+        print("下3個回合對敵方造成的傷害+1")
+
+class Rabbit3(SPATKCard):
+    def __init__(self):
+        super(Rabbit3, self).__init__(203, "科學無用論(終焉一擊)")
+        self.damage = 5
+    def active(self, cur, ene):
+        ene.inc_hp(0-self.damage)
+        print("優先於一切防禦能力的5點傷害攻擊")
+
+
 """
-v 1   攻擊 	對敵方造成兩點傷害 	攻擊類卡片
+101 空間之鍊(門)x2，無效敵方能力並將1張相同卡牌加入手中 SPDEF
-v 2 	防禦 	抵擋攻擊類卡片 	防禦類卡片
+102 空間之鍊(殼)x2，下2個敵方的回合不會受到傷害 OTHER
-v 3 	治癒 	回復兩點生命 	
+103 空間之鍊(滅)x1，對敵方造成5點傷害並使敵方損失2張手牌 SPATK
-v 4 	補給 	抽取兩張手牌 	
+
-v 5 	強奪 	從敵方手牌中隨機一張加入自己的手牌 	攻擊類卡片
+201 科學無用論(高速砍擊)x3，優先於一切防禦能力的3點傷害攻擊 SPATK
-v 6 	奇襲 	對敵方造成一點傷害，並使其隨機損失一張手牌 	攻擊類卡片 	
+202 科學無用論(力量增幅)x3，下3個回合對敵方造成的傷害+1 OTHER
-v 8 	洞悉 	抵擋攻擊類卡片，並抽取一張(2?)手牌、抵擋強奪的效果 	防禦類卡片
+203 科學無用論(終焉一擊)x1，優先於一切防禦能力的5點傷害攻擊 SPATK
-x 9 	妙策 	從牌庫中隨機挑出三張卡片，選擇一張加入手牌 	
+
-v 10 	掃射 	對敵方造成零～五點傷害 	攻擊類卡片
-v 11 	加護 	回復三點生命，並解除中毒 	
-v 12 	劇毒 	使敵方中毒：每個回合，玩家會損失一點生命 	
-v 14 	反制 	抵擋攻擊類卡片，並反彈其傷害和效果 	防禦類卡片
-v 15 	狂亂 	回復三點生命，並對敵方造成三點傷害 	 攻擊類卡片 
 """

Data.py

@@ -1,4 +1,8 @@
 Deck = [
-    [1, 2, 3] * 7 + [4, 5, 6] * 4 + [8, 9, 10, 11] * 2 + [12, 14, 15], 
+    [1, 2]*7 + [3, 4, 5, 6]*5 + [8, 9]*3 + [101, 102]*2 + [10, 11, 12, 14, 15, 103], 
-    [1, 2, 3] * 7 + [4, 5, 6] * 4 + [8, 9, 10, 11] * 2 + [12, 14, 15]
+    [1,]*10 + [2,8]*4 + [3,4,15, 201, 202]*3 + [5,]*5 + [6,]*9 + [9,]*2 + [203,]
+]
+
+HP = [
+    15, 12, 
 ]

DeckGen.py

@@ -15,6 +15,13 @@ cards = {
     14: Counter, 
     15: Frenzy, 
     
+    101: Guo1,
+    102: Guo2, 
+    103: Guo3,
+
+    201: Rabbit1,
+    202: Rabbit2, 
+    203: Rabbit3,
 }
 def DeckGen(card_ids):
     deck = []

Game.py

@@ -35,11 +35,14 @@ class Game:
                 try:
                     card = self.first.hand[int(use)]
                     if isinstance(card, Card.ATKCard):
-                        # Defence Handle
+                        # Defense Handle
                         if self.second.defend(card, self.first):
                             print("防禦成功～")
                             self.first.hand.remove(card)
                             break
+                        if self.first.boost > 0 and not isinstance(card, Card.Rob):
+                            self.first.hand[int(use)].damage += 1
+                            print("傷害將會+1，效果持續{}回合".format(self.first.boost))
                     elif isinstance(card, Card.DEFCard):
                         print("防禦類卡片無法主動打出")
                         continue
@@ -51,6 +54,13 @@ class Game:
                     print("請輸入數字")
 
             self.first, self.second = self.second, self.first
+
+            # Player Ability Handling
+            if isinstance(self.first, Player.Keieit):
+                self.first.guard -= 1
+
+            if isinstance(self.first, Player.Rabbit):
+                self.first.boost -= 1
         self.end()
     def end(self):
         winner = self.second if self.first.hp <= 0 else self.first

Player.py

@@ -1,16 +1,21 @@
-from Data import Deck
+from Data import *
 from DeckGen import CardGen
-from Card import DEFCard
+from Card import DEFCard, SPATKCard, SPDEFCard, Rabbit1, Rabbit3
-from random import choice
+from random import choice, shuffle
 class Player:
-    def __init__(self, name, deck):
+    def __init__(self, name, deck, hp):
-        self.hp = 15
+        self.hp = hp
         self.name = name
         self.deck = deck[:]
+        shuffle(self.deck)
         self.hand = []
         self.poison = 0
+
+        self.guard = 0
+        self.boost = 0
+
     def __repr__(self):
-        return self.name + "(HP: " + str(self.hp) + ", 手牌: " + str(len(self.hand)) + ")"
+        return self.name + "(HP: " + str(self.hp) + ", 手牌: " + str(len(self.hand)) + ", 牌庫: " + str(len(self.deck)) + ")"
     def draw(self, num=1):
         if not self.deck:
             return False
@@ -18,19 +23,38 @@ class Player:
             self.hand.append(CardGen(self.deck.pop(0)))
         return self.hand[-1]
     def inc_hp(self, hp):
-        self.hp += hp
+        if self.guard > 0 and hp < 0:
+            print("{}在{}回合內不會受到傷害".format(self.name, self.guard))
+            return True
+        else:
+            self.hp += hp
     def get(self, card):
         self.hand.append(card)
-    def drop(self):
+    def drop(self, num=1):
         if not self.hand:
             return False
-        card = choice(self.hand)
+        if num == 1:
-        self.hand.remove(card)
+            card = choice(self.hand)
-        return card
+            self.hand.remove(card)
+            return card
+        else:
+            l = []
+            for _ in range(num):
+                card = choice(self.hand)
+                l.append(card)
+                self.hand.remove(card)
+                if not self.hand:
+                    break
+            return l
     def defend(self, use_card, ene):
 
         print("對手使用了{}".format(use_card))
-        def_cards = list(filter(lambda x: True if isinstance(x, DEFCard) else False, self.hand))
+        def_cards = []
+        if isinstance(use_card, SPATKCard):
+            if not isinstance(use_card, (Rabbit1, Rabbit3)):
+                def_cards = list(filter(lambda x: True if isinstance(x, SPDEFCard) else False, self.hand))
+        else:
+            def_cards = list(filter(lambda x: True if isinstance(x, DEFCard) else False, self.hand))
         if not def_cards:
             return False
         for i, card in enumerate(def_cards):
@@ -42,14 +66,16 @@ class Player:
             self.hand.remove(card)
             return True
         except Exception as e:
-            template = "An exception of type {0} occurred. Arguments:\n{1!r}"
+            #template = "An exception of type {0} occurred. Arguments:\n{1!r}"
-            message = template.format(type(e).__name__, e.args)
+            #message = template.format(type(e).__name__, e.args)
-            print(message)
+            #print(message)
             return False
 class Keieit(Player):
     def __init__(self):
-        super(Keieit, self).__init__("圭月", Deck[0])
+        super(Keieit, self).__init__("圭月", Deck[0], HP[0])
+        self.guard = 0
 
 class Rabbit(Player):
     def __init__(self):
-        super(Rabbit, self).__init__("小兔", Deck[1])
+        super(Rabbit, self).__init__("小兔", Deck[1], HP[1])
+