class View_characters(__Object_base):
images = tuple(
view_utils.scaled_surface(
pg.image.load(
os.path.join(view_const.IMAGE_PATH, f'move_{_index}.png')),
0.6) for _index in map(str, range(1, 8)))
image_oil = view_utils.scaled_surface(
pg.image.load(os.path.join(view_const.IMAGE_PATH, 'oil_black.png')),
0.4)
@classmethod
def init_convert(cls):
cls.images = tuple(_image.convert_alpha() for _image in cls.images)
cls.image_oil = pg.Surface.convert_alpha(cls.image_oil)
def __init__(self, model):
self.model = model
self.picture_switch = (0, 1, 2, 1, 2, 1, 2, 1, 2, 3, 4, 5, 4, 5, 4, 5,
4, 5, 6)
self.position_switch = (130, 240, 350, 460, 570, 680, 790, 900, 1010,
1010, 900, 790, 680, 570, 460, 350, 240, 130,
120)
self.index = 0
self.counter = 0
def draw(self, screen):
image = self.images[self.picture_switch[self.index]]
screen.blit(image, [self.position_switch[self.index], 520])
if self.index < 10:
screen.blit(self.image_oil, (1220, 700))
if self.counter == 20:
self.index += 1
self.index %= 19
self.counter %= 20
self.counter += 1
class View_players(__Object_base):
images_color = tuple(
view_utils.scaled_surface(
pg.image.load(
os.path.join(view_const.IMAGE_PATH,
f'player_color{_rainbow}.png')), 0.2)
for _rainbow in range(0, 19))
image_freeze = view_utils.scaled_surface(
pg.image.load(os.path.join(view_const.IMAGE_PATH, 'freeze.png')), 0.5)
image_koreanfish = view_utils.scaled_surface(
pg.image.load(os.path.join(view_const.IMAGE_PATH, 'koreanfish.png')),
0.2)
image_captainkaoshiung = view_utils.scaled_surface(
pg.image.load(
os.path.join(view_const.IMAGE_PATH, 'koreanfish_leader.png')), 0.2)
@classmethod
def init_convert(cls):
cls.images = tuple(_image.convert_alpha() for _image in cls.images)
cls.image_freeze = cls.image_freeze.convert_alpha()
cls.images_color = tuple(_image.convert_alpha()
for _image in cls.images_color)
def __init__(self, model):
self.model = model
self.color_switch = [0, 0, 0, 0]
self.images = tuple(
view_utils.scaled_surface(
view_utils.replace_color(
os.path.join(view_const.IMAGE_PATH, 'player_outfit.png'),
view_const.COLOR_WHITE, player.color), 0.2).convert_alpha(
) if player.name != 'master' else self.image_koreanfish
for player in self.model.player_list)
self.theworld_player = None
def set_theworld_player(self, player_index):
self.theworld_player = player_index
def draw(self, screen, theworld=False):
players = self.model.player_list
for _i in range(len(players)):
if theworld and _i != self.theworld_player: continue
angle = ((8 - players[_i].direction_no) % 8 - 3) * 45
image = pg.transform.rotate(self.images[_i], angle)
if not players[_i].is_invincible:
image = pg.transform.rotate(self.images[_i], angle)
else:
if players[_i].name == 'master':
image = pg.transform.rotate(self.image_captainkaoshiung,
angle)
else:
image = pg.transform.rotate(
self.images_color[self.color_switch[_i] % 19], angle)
self.color_switch[_i] += 1
screen.blit(image, image.get_rect(center=players[_i].position))
if players[_i].freeze:
screen.blit(self.image_freeze,
players[_i].position + [-17, -50])
class Animation_freeze(Animation_raster):
frames = {
'ice': tuple(view_utils.scaled_surface(
pg.transform.rotate(pg.image.load(os.path.join(view_const.IMAGE_PATH, 'ice.png')), _i*1),
0.66/30*_i if _i <= 30 else 0.66
)
for _i in range(1, model_const.radius_not_move_duration)
),
'ice_text': tuple(view_utils.scaled_surface(
pg.transform.rotate(pg.image.load(os.path.join(view_const.IMAGE_PATH, 'ice_text.png')), -_i*1),
0.66/30*_i if _i <= 30 else 0.66
)
for _i in range(1, model_const.radius_not_move_duration)
),
'ice_inside': tuple(view_utils.scaled_surface(
pg.transform.rotate(pg.image.load(os.path.join(view_const.IMAGE_PATH, 'ice_inside.png')), _i*3),
0.2376/30*_i if _i <= 30 else 0.2376
)
for _i in range(1, model_const.radius_not_move_duration)
),
}
@classmethod
def init_convert(cls):
for _key in cls.frames:
cls.frames[_key] = tuple( _frame.convert_alpha() for _frame in cls.frames[_key] )
def __init__(self, **pos):
super().__init__(1, model_const.radius_not_move_duration, **pos)
def update(self):
self._timer += 1
if self._timer == self.expire_time:
self.expired = True
elif self._timer % self.delay_of_frames == 0:
self.frame_index_to_draw = (self.frame_index_to_draw + 1) % len(self.frames['ice'])
def draw(self, screen, update=True):
for angle in np.linspace(0, 2*np.pi*5/6, num=6):
dest = pg.math.Vector2(self.pos[next(iter(self.pos))]) + pg.math.Vector2(95*cos(angle + self._timer/180*np.pi), 95*sin(angle + self._timer/180*np.pi))
screen.blit(
self.frames['ice_inside'][self.frame_index_to_draw],
self.frames['ice_inside'][self.frame_index_to_draw].get_rect(center=dest)
)
screen.blit(
self.frames['ice_text'][self.frame_index_to_draw],
self.frames['ice_text'][self.frame_index_to_draw].get_rect(**self.pos),
)
screen.blit(
self.frames['ice'][self.frame_index_to_draw],
self.frames['ice'][self.frame_index_to_draw].get_rect(**self.pos),
)
if update: self.update()
class View_items(__Object_base):
images = {
'IGoHome':
view_utils.scaled_surface(
pg.image.load(os.path.join(view_const.IMAGE_PATH, 'backbag.png')),
0.2),
'MagnetAttract':
view_utils.scaled_surface(
pg.image.load(os.path.join(view_const.IMAGE_PATH, 'magnet.png')),
0.2),
'Invincible':
view_utils.scaled_surface(
pg.image.load(os.path.join(view_const.IMAGE_PATH, 'star.png')),
0.2),
'TheWorld':
view_utils.scaled_surface(
pg.image.load(os.path.join(view_const.IMAGE_PATH, 'clock.png')),
0.23),
'OtherGoHome':
view_utils.scaled_surface(
pg.image.load(os.path.join(view_const.IMAGE_PATH,
'hurricane.png')), 0.2),
'RadiusNotMove':
view_utils.scaled_surface(
pg.image.load(os.path.join(view_const.IMAGE_PATH, 'staff.png')),
0.24),
'RadiationOil':
view_utils.scaled_surface(
pg.image.load(os.path.join(view_const.IMAGE_PATH, 'bomb.png')),
0.15),
'ShuffleBases':
view_utils.scaled_surface(
pg.image.load(os.path.join(view_const.IMAGE_PATH, 'shuffle.png')),
0.2),
'FaDaCai':
view_utils.scaled_surface(
pg.image.load(os.path.join(view_const.IMAGE_PATH, 'shuffle.png')),
0.2)
}
@classmethod
def init_convert(cls):
cls.images = {
_name: cls.images[_name].convert_alpha()
for _name in cls.images
}
def draw(self, screen):
for market in self.model.priced_market_list:
if market.item:
screen.blit(
self.images[market.item.name],
self.images[market.item.name].get_rect(center=(401, 398)))
class View_background(__Object_base):
background = view_utils.scaled_surface(
pg.image.load(os.path.join(view_const.IMAGE_PATH, 'background.png')),
1)
priced_market = view_utils.scaled_surface(
pg.image.load(os.path.join(view_const.IMAGE_PATH, 'market.png')), 0.3)
@classmethod
def init_convert(cls):
cls.background = cls.background.convert()
cls.priced_market = cls.priced_market.convert()
def draw(self, screen):
screen.fill(view_const.COLOR_WHITE)
screen.blit(self.background, (0, 0))
screen.blit(self.priced_market, (322, 328))
class Animation_shuffleBases(Animation_raster):
image = view_utils.scaled_surface(pg.image.load( os.path.join(view_const.IMAGE_PATH, 'base.png') ), 0.3)
def __init__(self, model):
self.model = model
self.expire_time = 90
self.expired = False
self.delay_of_frames = 10
self._timer = 0
@classmethod
def init_convert(cls):
cls.image = cls.image.convert_alpha()
def update(self):
self._timer += 1
if self._timer == self.expire_time:
self.expired = True
def draw(self, screen, update=True):
if self._timer % self.delay_of_frames:
all_color = [player.color for player in self.model.player_list]
random.shuffle(all_color)
for _base in self.model.base_list:
pg.draw.circle(
screen,
all_color[_base.owner_index],
(round(int(_base.center[0]), -2), round(int(_base.center[1]), -2)),
160
)
screen.blit(self.image, self.image.get_rect(center=_base.center))
if update: self.update()
class Animation_shuffleBases_horizontal(Animation_raster):
frames = tuple(
view_utils.scaled_surface(
pg.image.load(os.path.join(view_const.IMAGE_PATH, 'thunder_horizontal.png')),
1/45 * _i
)
for _i in range(1, 45)
)
def __init__(self, **pos):
super().__init__(1, 90, **pos)
class Animation_othergohome(Animation_raster):
frames = tuple(
view_utils.scaled_surface(
pg.image.load(os.path.join(view_const.IMAGE_PATH, 'othergohome.png')),
1/20 * _i
)
for _i in range(1, 20)
)
def __init__(self, **pos):
super().__init__(1, 2*len(self.frames), **pos)
def __init__(self, model):
self.model = model
self.color_switch = [0, 0, 0, 0]
self.images = tuple(
view_utils.scaled_surface(
view_utils.replace_color(
os.path.join(view_const.IMAGE_PATH, 'player_outfit.png'),
view_const.COLOR_WHITE, player.color), 0.2).convert_alpha(
) if player.name != 'master' else self.image_koreanfish
for player in self.model.player_list)
self.theworld_player = None
class Animation_equalize(Animation_raster):
frames = tuple(
view_utils.scaled_surface(
pg.image.load(os.path.join(view_const.IMAGE_PATH, 'equalize_background.png')),
1 / 20 * _i
)
for _i in range(1, 21)
)
def __init__(self, **pos):
super().__init__(2, 2*len(self.frames), **pos)
def __init__(self, model):
self.model = model
self.images = tuple(
view_utils.scaled_surface(
view_utils.replace_color(
os.path.join(view_const.IMAGE_PATH, 'pet_robot_outfit.png'
), view_const.COLOR_WHITE, player.color), 0.08
).convert_alpha() if player.name != 'master' else view_utils.
scaled_surface(
pg.image.
load(os.path.join(view_const.IMAGE_PATH, 'pet_dog.png')
), 0.12).convert_alpha()
for player in self.model.player_list)
class View_bases(__Object_base):
image = view_utils.scaled_surface(
pg.image.load(os.path.join(view_const.IMAGE_PATH, 'base.png')), 0.3)
image_bathtub = view_utils.scaled_surface(
pg.image.load(os.path.join(view_const.IMAGE_PATH, 'bathtub.png')), 0.4)
@classmethod
def init_convert(cls):
cls.image = cls.image.convert_alpha()
def draw(self, screen):
for idx, _base in enumerate(self.model.base_list):
pg.draw.circle(screen,
self.model.player_list[_base.owner_index].color,
(round(int(_base.center[0]),
-2), round(int(_base.center[1]), -2)), 160)
if self.model.player_list[idx].name == 'master':
screen.blit(self.image_bathtub,
self.image_bathtub.get_rect(center=_base.center))
else:
screen.blit(self.image,
self.image.get_rect(center=_base.center))
class View_menu(__Object_base):
menu = view_utils.scaled_surface(
pg.image.load(os.path.join(view_const.IMAGE_PATH, 'menu.png')), 1)
base = view_utils.scaled_surface(
pg.image.load(os.path.join(view_const.IMAGE_PATH, 'base.png')), 0.5)
@classmethod
def init_convert(cls):
cls.menu = cls.menu.convert()
cls.base = cls.base.convert_alpha()
def draw(self, screen):
screen.blit(self.menu, (0, 0))
screen.blit(self.base, (10, 645))
titlefont = pg.font.Font(view_const.digitalt_font, 250)
titlesmallfont = pg.font.Font(view_const.notosans_font, 40)
words_1 = titlefont.render('OIL', True, view_const.COLOR_BLACK)
words_2 = titlefont.render('TYCOON', True, view_const.COLOR_BLACK)
words_3 = titlesmallfont.render('presented by 2019 NTU CSIE CAMP',
True, view_const.COLOR_BLACK)
(size_x_1, size_y_1) = words_1.get_size()
(size_x_2, size_y_2) = words_2.get_size()
(size_x_3, size_y_3) = words_3.get_size()
pos_x_1 = (view_const.screen_size[0] - size_x_1) / 2
pos_y_1 = (view_const.screen_size[1] - size_y_1 - 450 - size_y_3) / 2
pos_x_2 = (view_const.screen_size[0] - size_x_2) / 2
pos_y_2 = (view_const.screen_size[1] - size_y_2 - size_y_3) / 2
pos_x_3 = (view_const.screen_size[0] - size_x_3) / 2
pos_y_3 = (400 + size_y_3)
screen.blit(words_1, (pos_x_1, pos_y_1))
screen.blit(words_2, (pos_x_2, pos_y_2))
screen.blit(words_3, (pos_x_3, pos_y_3))
class Animation_radiationOil(Animation_raster):
'''
stage 1: boom & screen vibration
stage 2: smoke
'''
frames = tuple([
*(view_utils.scaled_surface(
pg.image.load(os.path.join(view_const.IMAGE_PATH, 'boom.png')),
1/40 * (_i**2) / view_const.RADIATIONOIL_STAGE1_DURATION
) for _i in range(1, view_const.RADIATIONOIL_STAGE1_DURATION+1)),
*(pg.transform.scale(
pg.image.load(os.path.join(view_const.IMAGE_PATH, 'boom_smoke.png')),
(375, 375)
) for _ in range(1, view_const.RADIATIONOIL_STAGE2_DURATION+1)),
])
@classmethod
def init_convert(cls):
_tmp_frames = []
for _i in range(view_const.RADIATIONOIL_STAGE1_DURATION):
_tmp_frames.append( cls.frames[_i].convert_alpha() )
for _x, _i in zip(range(view_const.RADIATIONOIL_STAGE2_DURATION), range(view_const.RADIATIONOIL_STAGE1_DURATION, view_const.RADIATIONOIL_STAGE1_DURATION + view_const.RADIATIONOIL_STAGE2_DURATION)):
_tmp_frames.append( cls.frames[_i].convert() )
_tmp_frames[-1].set_colorkey((164, 147, 147))
_tmp_frames[-1].set_alpha( - _x**4 / view_const.RADIATIONOIL_STAGE2_DURATION**3 +view_const.RADIATIONOIL_STAGE2_DURATION )
cls.frames = tuple(_tmp_frames)
def __init__(self, **pos):
super().__init__(1, len(self.frames), **pos)
pos[next(iter(pos))] = pg.math.Vector2(pos[next(iter(pos))]) + view_const.RADIATIONOIL_CENTER_OFFSET
self.pos = pos
self.vibration = tuple([
*((0, 0) for _ in range(10)),
*((random.randint(-9, 9), random.randint(-9, 9)) for _ in range(view_const.RADIATIONOIL_STAGE1_DURATION-10)),
*((0, 0) for _ in range(view_const.RADIATIONOIL_STAGE2_DURATION))
])
def draw(self, screen, update=True):
screen.blit(
self.frames[self.frame_index_to_draw],
self.frames[self.frame_index_to_draw].get_rect(**self.pos),
)
screen.blit(screen.copy(), self.vibration[self.frame_index_to_draw])
if update: self.update()
class Animation_magnetattract(Animation_raster):
frames = tuple(
view_utils.scaled_surface(
pg.image.load(os.path.join(view_const.IMAGE_PATH, 'mag.png')),
1 / 20 * _i
)
for _i in range(1, 11)
)
def __init__(self, player_index, model):
super().__init__(2, model_const.magnet_attract_duration, center=model.player_list[player_index].position)
self.player_index = player_index
self.model = model
def update(self):
super().update()
self.pos[ next(iter(self.pos)) ] = self.model.player_list[self.player_index].position + (10, 0)
class View_oils(__Object_base):
images = tuple(
view_utils.scaled_surface(
pg.image.load(
os.path.join(view_const.IMAGE_PATH, f'oil_{_color}.png')),
0.16) for _color in ('purple', 'pink', 'gray', 'black'))
def draw(self, screen):
for _oil in self.model.oil_list:
max_price = model_const.price_max
if _oil.price < max_price / 3: image = self.images[0]
elif max_price / 3 <= _oil.price < max_price / 2:
image = self.images[1]
elif max_price / 2 <= _oil.price < max_price / 3 * 2:
image = self.images[2]
elif max_price / 3 * 2 <= _oil.price:
image = self.images[3]
screen.blit(image, image.get_rect(center=_oil.position))
def load_and_scale(filename, scalar):
return scaled_surface(
pg.image.load(os.path.join(view_const.IMAGE_PATH, filename)), scalar)
class View_scoreboard(__Object_base):
images = {
'IGoHome':
view_utils.scaled_surface(
pg.image.load(os.path.join(view_const.IMAGE_PATH, 'backbag.png')),
0.3),
'MagnetAttract':
view_utils.scaled_surface(
pg.image.load(os.path.join(view_const.IMAGE_PATH, 'magnet.png')),
0.3),
'Invincible':
view_utils.scaled_surface(
pg.image.load(os.path.join(view_const.IMAGE_PATH, 'star.png')),
0.3),
'TheWorld':
view_utils.scaled_surface(
pg.image.load(os.path.join(view_const.IMAGE_PATH, 'clock.png')),
0.35),
'OtherGoHome':
view_utils.scaled_surface(
pg.image.load(os.path.join(view_const.IMAGE_PATH,
'hurricane.png')), 0.3),
'RadiusNotMove':
view_utils.scaled_surface(
pg.image.load(os.path.join(view_const.IMAGE_PATH, 'staff.png')),
0.32),
'RadiationOil':
view_utils.scaled_surface(
pg.image.load(os.path.join(view_const.IMAGE_PATH, 'bomb.png')),
0.2),
'ShuffleBases':
view_utils.scaled_surface(
pg.image.load(os.path.join(view_const.IMAGE_PATH, 'shuffle.png')),
0.3),
'FaDaCai':
view_utils.scaled_surface(
pg.image.load(os.path.join(view_const.IMAGE_PATH, 'shuffle.png')),
0.3)
}
@classmethod
def init_convert(cls):
cls.images = {
_name: cls.images[_name].convert_alpha()
for _name in cls.images
}
cls.namefont = pg.font.Font(view_const.notosans_font, 55)
cls.numfont = pg.font.Font(view_const.notosans_font, 25)
def draw(self, screen):
pg.draw.rect(screen, view_const.COLOR_WHITE, (800, 0, 480, 800))
pg.draw.rect(screen, view_const.COLOR_KHAKI, (800, 0, 480, 160))
pg.draw.rect(screen, view_const.COLOR_BLACK, (800, 0, 480, 160), 5)
for score in self.model.scoreboard.score_list:
pg.draw.rect(screen, score.player.color,
(score.position, (480, 160)))
pg.draw.rect(screen, view_const.COLOR_BLACK,
(score.position, (480, 160)), 5)
for score in self.model.scoreboard.score_list:
name = self.namefont.render(f'{score.player.name}', True,
view_const.COLOR_BLACK)
base_value = self.numfont.render(
f'Base : {int(score.base.value_sum)}', True,
view_const.COLOR_BLACK)
player_value = self.numfont.render(
f'Carried Value : {int(score.player.value)}', True,
view_const.COLOR_BLACK)
if score.player.item:
item_image = self.images[score.player.item.name]
screen.blit(item_image, score.position + (340, 5))
screen.blit(name, score.position + (10, -5))
screen.blit(base_value, score.position + (10, 75))
screen.blit(player_value, score.position + (10, 115))
for new_score in self.model.scoreboard.p_varition_list:
if new_score.varition >= 0:
carry_value = self.numfont.render(
f'+{int(new_score.varition)}', True, view_const.COLOR_GOLD)
else:
carry_value = self.numfont.render(f'{int(new_score.varition)}',
True, view_const.COLOR_GOLD)
screen.blit(carry_value, new_score.get_position() + [300, 160])
for new_base_score in self.model.scoreboard.b_varition_list:
if new_base_score.varition >= 0:
base_value = self.numfont.render(
f'+{int(new_base_score.varition)}', True,
view_const.COLOR_GOLD)
else:
base_value = self.numfont.render(
f'{int(new_base_score.varition)}', True,
view_const.COLOR_GOLD)
screen.blit(base_value, new_base_score.get_position() + [300, 120])
