PyRPG_Mini/Shield.py at master · TonePoems/PyRPG_Mini · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
import Game
import random


# TODO: Make shield, armor, weapon all have similar repair methods.
class Shield:
    # level,class,name,type,basedef,durability
    def __init__(self, shieldlevel, shieldclass, shieldname, shieldtype, shieldbasedefn, shielddur, shieldequipped):
        # shield level
        self.level = shieldlevel

        # shield hero class type
        self.ourshieldclass = shieldclass

        # shield name
        self.name = shieldname

        # shield type
        self.type = shieldtype

        # Shield Quality (rusty, common, great, magical, legendary)
        chance = random.randint(1, 100)

        if chance < 20:
            self.quality = 'Rusty'
        elif chance >= 21 or chance < 65:
            self.quality = 'Common'
        elif chance >= 66 or chance < 86:
            self.quality = 'Great'
        elif chance >= 85 or chance < 96:
            self.quality = 'Magical'
        elif chance >= 96 or chance < 100:
            self.quality = 'Legendary'

        # Defense Values
        self.basedefn = shieldbasedefn
        if self.quality == 'Rusty':
            self.basedefn = int(self.basedefn * 0.9)
        elif self.quality == 'Common':
            self.basedefn = int(self.basedefn * 1)
        elif self.quality == 'Great':
            self.basedefn = int(self.basedefn * 1.25)
        elif self.quality == 'Magical':
            self.basedefn = int(self.basedefn * 1.6)
        elif self.quality == 'Legendary':
            self.basedefn = int(self.basedefn * 2)

        self.defn = self.basedefn

        # shield durability value
        self.maxdur = shielddur
        if self.quality == 'Rusty':
            self.maxdur = int(self.maxdur * 0.9)
        elif self.quality == 'Common':
            self.maxdur = int(self.maxdur * 1)
        elif self.quality == 'Great':
            self.maxdur = int(self.maxdur * 1.25)
        elif self.quality == 'Magical':
            self.maxdur = int(self.maxdur * 1.6)
        elif self.quality == 'Legendary':
            self.maxdur = int(self.maxdur * 2)
        self.dur = self.maxdur

        # equipped
        self.isEquipped = shieldequipped

    # set equip status
    def setIsEquipped(self, shieldequipped):
        """
        Sets Shield equip status, True/False.

         @param shieldequipped Set Shield equipped to True/False.
        """
        self.isEquipped = shieldequipped

    # get equip status
    def getIsEquipped(self):
        """
        Get Shield equip status, True/False.

        @return True/False whether current Shield is equipped.
        """
        return self.isEquipped

    # damage durability, and check to see if broken
    def damagedur(self, aug, curve):
        self.dur -= int(aug * curve)
        self.isbroken()
        pass

    # restore dur and check to see if fixed
    def restoredur(self, aug):
        self.dur += aug
        if self.dur > self.maxdur:
            self.dur = self.maxdur
        if not self.isbroken():
            self.defn = self.basedefn

    # repair entirely
    def repair(self):
        self.defn = self.basedefn
        self.dur = self.maxdur

    # 15% durability = stat reduction
    def isbroken(self):
        if self.dur <= 0:
            self.gearbreak()
            return True
        elif self.dur > 0:
            return False

    # this breaks the gear
    def gearbreak(self):
        self.atk = int(self.basedefn * .3)

    # prints all info about the shield
    def printshieldinfo(self):
        Game.marqueeprint('SHIELD')
        print(Game.lr_justify('Level:', str(self.level), 60))
        print(Game.lr_justify('Name:', str(self.name), 60))
        print(Game.lr_justify('Type:', str(self.type), 60))
        print(Game.lr_justify('Defense:', str(self.defn) + '/' + str(self.basedefn), 60))
        print(Game.lr_justify('Dur:', str(self.dur) + '/' + str(self.maxdur), 60))
        print(Game.lr_justify('Broken?:', str(self.isbroken()), 60))
        print(Game.lr_justify('Quality:', str(self.quality), 60))

    # ['Level', 'Name', 'Defense', 'Dur', 'Broken?', 'Power']
    def datadict(self):
        return {'Level': str(self.level),
                'Name': str(self.name) + ' ' + str(self.type),
                'Def': str(self.defn),
                'Dur': str(self.dur) + '/' + str(self.maxdur),
                'Broken?': str(self.isbroken()),
                'Repair Cost': str(self.maxdur - self.dur) + ' gold',
                'Quality': str(self.quality)
                }