def readFlags(optFlags):
if len(argv) > 3:
flags = []
for entry in argv[3:]:
for flag in optFlags:
if entry == flag.a_flag:
flags.append(copy.copy(flag))
break
else:
flags.append(Flag.cFlag(entry, False, False, False, False))
break
else:
try:
flagsdb = open(argv[1] + "/flags.db")
flags = []
try:
for line in flagsdb:
for flag in optFlags:
if line.strip() == flag.a_flag:
flags.append(copy.copy(flag))
flags.append(
Flag.cFlag(line[:len(line) - 1], False, False, False,
False))
finally:
flagsdb.close()
except IOError:
print(
"Could not open flags.db and no flags passed as parameters. Continuing with no flags"
)
flags = [""]
return flags
def add(self, team, name, value, score=None, answer=""):
# todo - enforce global uniqueness of flags!!
#initialize our score-keeping variables as new team names come in
if self.teams.has_key(team):
pass
else:
self.teams[team] = {}
if self.theft.has_key(team):
pass
else:
self.theft[team] = []
if self.integrity.has_key(team):
pass
else:
self.integrity[team] = []
flag_name = "%s_%s" % (team, name)
self.logger.out("Adding %s:%s:%s\n\tfor team %s\n" %
(flag_name, value, score, team))
this_flag = Flag(team, flag_name, value, score, answer)
flag_team = this_flag.get_team()
flag_name = this_flag.get_name()
flag_value = this_flag.get_value()
self.logger.out("Set %s:%s\n\tfor team %s\n" % \
(flag_name,flag_value,flag_team))
if self.flags.has_key(name):
old_value = self.flags[flag_name].get_value()
self.logger.out("Clobbering team %s flag %s:%s with %s:%s\n" %
(team, name, old_value, flag_name, value))
self.flags[flag_name] = this_flag
def add(self, team, name, value, score=None):
#initialize our score-keeping variables as new team names come in
if self.teams.has_key(team):
pass
else:
self.teams[team] = {}
if self.theft.has_key(team):
pass
else:
self.theft[team] = []
if self.integrity.has_key(team):
pass
else:
self.integrity[team] = []
flag_name = "%s_%s" % (team, name)
self.logger.out("Adding %s:%s:%s\n\tfor team %s\n" %
(flag_name,value,score,team))
this_flag = Flag(team, flag_name, value, score)
flag_team = this_flag.get_team()
flag_name = this_flag.get_name()
flag_value = this_flag.get_value()
self.logger.out("Set %s:%s\n\tfor team %s\n" % \
(flag_name,flag_value,flag_team))
if self.flags.has_key(name):
old_value = self.flags[flag_name].get_value()
self.logger.out("Clobbering team %s flag %s:%s with %s:%s\n" %
(team, name, old_value, flag_name, value))
self.flags[flag_name] = this_flag
def read_sensor():
d_flag = Flag(open("sensor_data.flg", "w"))
in_humi, in_temp = 66, 28
out_humi, out_temp = 52, 35
lumi, mois = 1, 740
d_flag.set_stat([
cf.Comp.INPUT, cf.Stat.ANSWERED, in_humi, in_temp, out_humi, out_temp,
mois, lumi
])
del d_flag
def readOptFlags(path=argv[1]):
#Let's read our data from Flag-notes.txt
o1 = o2 = o3 = oS = False
flagClass = []
try:
optFlags = open(path + "/Flag-notes.txt")
try:
for line in optFlags:
text = line.strip() # Avoid calling .strip multiple times
""" Sadly we do not have a switch() function implemented in python..."""
if text == "-o1/-o2/-o3:":
o1 = o2 = o3 = True
oS = False
continue
elif text == "-o2/-o3/-os:":
o2 = o3 = oS = True
o1 = False
continue
elif text == "-o2/-o3:":
o2 = o3 = True
oS = o1 = False
continue
elif text == "-o3:":
o3 = True
o1 = o2 = oS = False
continue
flagClass.append(Flag.cFlag(text, o1, o2, o3, oS))
finally:
optFlags.close()
except IOError:
print("Something went wrong opening flag-notes.txt")
exit(-1)
return flagClass
def __init__(self, gps=True, platform=True, cam=True, lidar=True):
self.run_gps = gps
self.run_platform = platform
self.run_cam = cam
self.run_lidar = lidar
print("\nIntializing Database")
print("──────────────────────────────────────────────────────────────────────────────────────────────────────────────────")
self.flag = Flag()
if gps:
self.gps = GPS('COM2', 19200, flag=self.flag)
self.__gps_thread = threading.Thread(target=self.gps.main)
if platform:
self.platform = Platform('COM6', 115200, flag=self.flag)
self.__platform_thread = threading.Thread(target=self.platform.main)
if cam:
self.main_cam = CAM(0, 'Main', flag=self.flag, params_cam=CAM0_PARMS)
self.sub_cam = CAM(1, 'Sub', flag=self.flag, params_cam=CAM1_PARMS)
self.__main_cam_thread = threading.Thread(target=self.main_cam.main)
self.__sub_cam_thread = threading.Thread(target=self.sub_cam.main)
if lidar:
self.lidar = LiDAR('127.0.0.1', 7248, flag=self.flag)
self.__lidar_thread = threading.Thread(target=self.lidar.main)
print("──────────────────────────────────────────────────────────────────────────────────────────────────────────────────")
print("Database is ready to run!")
def main():
menu()
i = 0
while (i == 0):
Name_country = raw_input("please write your Name Country : ")
image1 = Flag(Name_country)
image1.getImage()
image1.convertData()
menu_reset()
print "\n"
from infi.systray import SysTrayIcon
@staticmethod
def createWindow():
# Get current time
currentDT = datetime.datetime.now()
currentDT = currentDT.strftime("%H:%M")
# Convert from military time
hours, minutes = currentDT.split(":")
hours, minutes = int(hours), int(minutes)
setting = "AM"
if hours > 12:
setting = "PM"
hours = hours - 12
currentDT = str(hours) + ":" + str(minutes) + " " + setting
window = PopUpWindow(currentDT)
if __name__ == "__main__":
menu_options = (("Pop Up Window", None, createWindow()), )
systray = SysTrayIcon("icon.ico", "Example tray icon", menu_options)
systray.start()
Flag.setFlag(0)
while 0 == Flag.getFlag():
createWindow()
if Flag.getFlag() == 1:
break
print("See you in " + str(PopUpWindow.getPopUpCount()) + " minutes")
time.sleep(PopUpWindow.getPopUpCount() * 60)
print("GoodBye")
try:
tmp = tmp.split("$")[1]
datas = tmp.split(',')
except:
datas = ["123123123123123"]
if datas[0] == "GNRMC":
try:
t = float(datas[1])
lad = float(datas[3])
NS = datas[4]
lon = float(datas[5])
EW = datas[6]
quality = datas[2]
self.__data = [t, lad, NS, lon, EW, quality]
except Exception as e:
print(
"[GPS Running \tError] \t\tInvalid data is generated by GPS. Check GPS status:",
e)
time.sleep(1)
@property
def data(self):
return self.__data
if __name__ == "__main__":
gps = GPS('COM3', 19200, Flag())
gps.main()
def __init__(self, cr):
DistributedObject.__init__(self, cr)
Flag.__init__(self, 'flag')
def setDNAString(self, dnaStr):
self.notify.debug('setDNAString: ' + ` dnaStr `)
Flag.setDNAString(self, dnaStr)
self.flatten()
self.__data = [roll, pitch, yaw, ax, ay, az]
except Exception as e:
print("[IMU Running \tError] \t\tInvalid data is generated by IMU. Check IMU status:", e)
time.sleep(1)
def __parse_imu2(self, data):
tmp = ''.join(data)
if data == ['\n']:
return 0
else:
try:
tmp.replace('\r', '').replace('\n', '')
datas = tmp.split(',')
roll = float(datas[1])
pitch = float(datas[2])
yaw = float(datas[3])
self.__data = [roll, pitch, yaw]
except Exception as e:
print("[IMU Running \tError] \t\tInvalid data is generated by IMU. Check IMU status:", e)
time.sleep(1)
@property
def data(self):
return self.__data
if __name__ == "__main__":
imu = Imu('COM5', 115200, Flag())
imu.main()
def __init__(self):
"""
Constructor
"""
self.flags = [Flag() for i in xrange(1, 10)]
def setDNAString(self, dnaStr):
self.notify.debug('setDNAString: ' + `dnaStr`)
Flag.setDNAString(self, dnaStr)
self.flatten()
def ready_stat():
ia_flag = Flag(open("ians.flg", "w"))
ia_flag.set_stat([cf.Comp.INPUT, cf.Stat.READY, 0, 0, 0, 0, 0, 0])
del ia_flag
def write_stat():
ia_flag = Flag(open("ians.flg", "w"))
ia_flag.set_stat([cf.Comp.INPUT, cf.Stat.ANSWERED, 0, 0, 0, 0, 0, 0])
del ia_flag
class Map(object):
"""
This class contains every map object: tiles, mobs and player. Also,
there are camera, event and UI.
"""
def __init__(self, worldNum):
self.obj = []
self.obj_bg = []
self.tubes = []
self.debris = []
self.mobs = []
self.whizbangs = []
self.text_objects = []
self.map = 0
self.flag = None
self.mapSize = (0, 0)
self.sky = 0
self.textures = {}
self.worldNum = worldNum
self.loadWorld_11()
self.is_mob_spawned = [False, False]
self.score_for_killing_mob = 100
self.score_time = 0
self.in_event = False
self.tick = 0
self.time = 400
self.oPlayer = Player(x_pos=128, y_pos=351)
self.oCamera = Camera(self.mapSize[0] * 32, 14)
self.oEvent = Event()
self.oGameUI = GameUI()
def loadWorld_11(self):
tmxData = load_pygame("worlds/1-1/W11.tmx")
self.mapSize = (tmxData.width, tmxData.height)
self.sky = pg.Surface((WINDOW_W, WINDOW_H))
self.sky.fill((pg.Color('#5c94fc')))
# 2D List
self.map = [[0] * tmxData.height for i in range(tmxData.width)]
layer_num = 0
for layer in tmxData.visible_layers:
for y in range(tmxData.height):
for x in range(tmxData.width):
# Getting pygame surface
image = tmxData.get_tile_image(x, y, layer_num)
# It's none if there are no tile in that place
if image is not None:
tileID = tmxData.get_tile_gid(x, y, layer_num)
if layer.name == 'Foreground':
# 22 ID is a question block, so in taht case we shoud load all it's images
if tileID == 22:
image = (
image, # 1
tmxData.get_tile_image(0, 15,
layer_num), # 2
tmxData.get_tile_image(1, 15,
layer_num), # 3
tmxData.get_tile_image(
2, 15, layer_num) # activated
)
# Map class has 1)"map" list, which is used in collision system because we can
# easily get block by x and y coordinate 2)"obj", "obj_bg" and simular arrays -
# they are used in rendering because you don't need to cycle through every
# (x, y) pair. Here we are adding the same platform object in 2 different arrays.
self.map[x][y] = Platform(x * tmxData.tileheight,
y * tmxData.tilewidth,
image, tileID)
self.obj.append(self.map[x][y])
elif layer.name == 'Background':
self.map[x][y] = BGObject(x * tmxData.tileheight,
y * tmxData.tilewidth,
image)
self.obj_bg.append(self.map[x][y])
layer_num += 1
# Tubes
self.spawn_tube(28, 10)
self.spawn_tube(37, 9)
self.spawn_tube(46, 8)
self.spawn_tube(55, 8)
self.spawn_tube(163, 10)
self.spawn_tube(179, 10)
# Mobs
self.mobs.append(Goombas(736, 352, False))
self.mobs.append(Goombas(1295, 352, True))
self.mobs.append(Goombas(1632, 352, False))
self.mobs.append(Goombas(1672, 352, False))
self.mobs.append(Goombas(5570, 352, False))
self.mobs.append(Goombas(5620, 352, False))
self.map[21][8].bonus = 'mushroom'
self.map[78][8].bonus = 'mushroom'
self.map[109][4].bonus = 'mushroom'
self.flag = Flag(6336, 48)
def reset(self, reset_all):
self.obj = []
self.obj_bg = []
self.tubes = []
self.debris = []
self.mobs = []
self.in_event = False
self.flag = None
self.sky = None
self.map = None
self.tick = 0
self.time = 400
self.mapSize = (0, 0)
self.textures = {}
self.loadWorld_11()
self.get_event().reset()
self.get_player().reset(reset_all)
self.get_camera().reset()
def get_name(self):
if self.worldNum == '1-1':
return '1-1'
def get_player(self):
return self.oPlayer
def get_camera(self):
return self.oCamera
def get_event(self):
return self.oEvent
def get_ui(self):
return self.oGameUI
def get_blocks_for_collision(self, x, y):
"""
Returns tiles around the entity
"""
return (self.map[x][y - 1], self.map[x][y + 1], self.map[x][y],
self.map[x - 1][y], self.map[x + 1][y], self.map[x + 2][y],
self.map[x + 1][y - 1], self.map[x + 1][y + 1],
self.map[x][y + 2], self.map[x + 1][y + 2],
self.map[x - 1][y + 1], self.map[x + 2][y + 1],
self.map[x][y + 3], self.map[x + 1][y + 3])
def get_blocks_below(self, x, y):
"""
Returns 2 blocks below entity to check its on_ground parameter
"""
return (self.map[x][y + 1], self.map[x + 1][y + 1])
def get_mobs(self):
return self.mobs
def spawn_tube(self, x_coord, y_coord):
self.tubes.append(Tube(x_coord, y_coord))
# Adding tube's collision just by spawning tiles inside the tube.
# They will not render because we are adding them to "collision" list.
for y in range(y_coord, 12): # 12 because it's ground level.
for x in range(x_coord, x_coord + 2):
self.map[x][y] = Platform(x * 32,
y * 32,
image=None,
type_id=0)
def spawn_mushroom(self, x, y):
self.get_mobs().append(Mushroom(x, y, True))
def spawn_goombas(self, x, y, move_direction):
self.get_mobs().append(Goombas(x, y, move_direction))
def spawn_koopa(self, x, y, move_direction):
self.get_mobs().append(Koopa(x, y, move_direction))
def spawn_flower(self, x, y):
self.mobs.append(Flower(x, y))
def spawn_debris(self, x, y, type):
if type == 0:
self.debris.append(PlatformDebris(x, y))
elif type == 1:
self.debris.append(CoinDebris(x, y))
def spawn_fireball(self, x, y, move_direction):
self.whizbangs.append(Fireball(x, y, move_direction))
def spawn_score_text(self, x, y, score=None):
"""
This text appears when you, for example, kill a mob. It shows how many points
you got.
"""
# Score is none only when you kill a mob. If you got a killstreak,
# amount of points for killing a mob will increase: 100, 200, 400, 800...
# So you don't know how many points you should add.
if score is None:
self.text_objects.append(
Text(str(self.score_for_killing_mob), 16, (x, y)))
# Next score will be bigger
self.score_time = pg.time.get_ticks()
if self.score_for_killing_mob < 1600:
self.score_for_killing_mob *= 2
# That case for all other situations.
else:
self.text_objects.append(Text(str(score), 16, (x, y)))
def remove_object(self, object):
self.obj.remove(object)
self.map[object.rect.x // 32][object.rect.y // 32] = 0
def remove_whizbang(self, whizbang):
self.whizbangs.remove(whizbang)
def remove_text(self, text_object):
self.text_objects.remove(text_object)
def update_player(self, core):
self.get_player().update(core)
def update_entities(self, core):
for mob in self.mobs:
mob.update(core)
if not self.in_event:
self.entity_collisions(core)
def update_time(self, core):
"""
Updating a map time.
"""
# Time updates only if map not in event
if not self.in_event:
self.tick += 1
if self.tick % 40 == 0:
self.time -= 1
self.tick = 0
if self.time == 100 and self.tick == 1:
core.get_sound().start_fast_music(core)
elif self.time == 0:
self.player_death(core)
def update_score_time(self):
"""
When player kill mobs in a row, score for each mob
will increase. When player stops kill mobs, points
will reset to 100. This function updates these points.
"""
if self.score_for_killing_mob != 100:
# Delay is 750 ms
if pg.time.get_ticks() > self.score_time + 750:
self.score_for_killing_mob //= 2
def entity_collisions(self, core):
if not core.get_map().get_player().unkillable:
for mob in self.mobs:
mob.check_collision_with_player(core)
def try_spawn_mobs(self, core):
"""
These mobs will appear when player will reach the certain x-coordinate
"""
if self.get_player().rect.x > 2080 and not self.is_mob_spawned[0]:
self.spawn_goombas(2495, 224, False)
self.spawn_goombas(2560, 96, False)
self.is_mob_spawned[0] = True
elif self.get_player().rect.x > 2460 and not self.is_mob_spawned[1]:
self.spawn_goombas(3200, 352, False)
self.spawn_goombas(3250, 352, False)
self.spawn_koopa(3400, 352, False)
self.spawn_goombas(3700, 352, False)
self.spawn_goombas(3750, 352, False)
self.spawn_goombas(4060, 352, False)
self.spawn_goombas(4110, 352, False)
self.spawn_goombas(4190, 352, False)
self.spawn_goombas(4240, 352, False)
self.is_mob_spawned[1] = True
def player_death(self, core):
self.in_event = True
self.get_player().reset_jump()
self.get_player().reset_move()
self.get_player().numOfLives -= 1
if self.get_player().numOfLives == 0:
self.get_event().start_kill(core, game_over=True)
else:
self.get_event().start_kill(core, game_over=False)
def player_win(self, core):
self.in_event = True
self.get_player().reset_jump()
self.get_player().reset_move()
self.get_event().start_win(core)
def update(self, core):
# All mobs
self.update_entities(core)
if not core.get_map().in_event:
# When player eats a mushroom
if self.get_player().inLevelUpAnimation:
self.get_player().change_powerlvl_animation()
# Unlike the level up animation, player can move there
elif self.get_player().inLevelDownAnimation:
self.get_player().change_powerlvl_animation()
self.update_player(core)
# Common case
else:
self.update_player(core)
else:
self.get_event().update(core)
# Debris is 1) Particles which appears when player destroy a brick block
# 2) Coins which appears when player activate a "question" platform
for debris in self.debris:
debris.update(core)
# Player's fireballs
for whizbang in self.whizbangs:
whizbang.update(core)
# Text which represent how mapy points player get
for text_object in self.text_objects:
text_object.update(core)
# Camera stops moving when player dies or touches a flag
if not self.in_event:
self.get_camera().update(core.get_map().get_player().rect)
self.try_spawn_mobs(core)
self.update_time(core)
self.update_score_time()
def render_map(self, core):
"""
Rendering only tiles. It's used in main menu.
"""
core.screen.blit(self.sky, (0, 0))
for obj_group in (self.obj_bg, self.obj):
for obj in obj_group:
obj.render(core)
for tube in self.tubes:
tube.render(core)
def render(self, core):
"""
Renders every object.
"""
core.screen.blit(self.sky, (0, 0))
for obj in self.obj_bg:
obj.render(core)
for mob in self.mobs:
mob.render(core)
for obj in self.obj:
obj.render(core)
for tube in self.tubes:
tube.render(core)
for whizbang in self.whizbangs:
whizbang.render(core)
for debris in self.debris:
debris.render(core)
self.flag.render(core)
for text_object in self.text_objects:
text_object.render_in_game(core)
self.get_player().render(core)
self.get_ui().render(core)
def getAnswer():
r_flag = Flag(open("request.flg", "r+"))
a_flag = Flag(open("answer.flg", "r+"))
b_flag = Flag(open("busy.flg", "r+"))
# Wait until ready
print("Getting b_flag data... ", end="")
b_flag.get_data()
while b_flag.is_busy():
b_flag.get_data()
print("Done")
# Request data
print("Set r_flag to REQUESTED... ", end="")
r_flag.set_stat([cf.Comp.LINE, cf.Stat.REQUESTED, 0, 0, 0, 0, 0, 0])
print("Done")
while True:
print(" Getting a_flag data... ")
a_flag.get_data()
print(f" got --> {a_flag.buffer}")
print(" Getting r_flag data... ")
r_flag.get_data()
print(f" got --> {r_flag.buffer}")
if a_flag.is_answered() and r_flag.buffer:
print(" Set r_flag to ACQUIRED... ", end="")
r_flag.set_stat([cf.Comp.LINE, cf.Stat.ACQUIRED, 0, 0, 0, 0, 0, 0])
print("Done")
d_flag = Flag(open("sensor_data.flg", "r"))
buffer = d_flag.get_data()
del r_flag
del a_flag
del b_flag
return buffer
def exitApp(self):
Flag.setFlag(1)
self.systray.shutdown()
self.window.destroy()
def loadWorld_11(self):
tmxData = load_pygame("worlds/1-1/W11.tmx")
self.mapSize = (tmxData.width, tmxData.height)
self.sky = pg.Surface((WINDOW_W, WINDOW_H))
self.sky.fill((pg.Color('#5c94fc')))
# 2D List
self.map = [[0] * tmxData.height for i in range(tmxData.width)]
layer_num = 0
for layer in tmxData.visible_layers:
for y in range(tmxData.height):
for x in range(tmxData.width):
# Getting pygame surface
image = tmxData.get_tile_image(x, y, layer_num)
# It's none if there are no tile in that place
if image is not None:
tileID = tmxData.get_tile_gid(x, y, layer_num)
if layer.name == 'Foreground':
# 22 ID is a question block, so in taht case we shoud load all it's images
if tileID == 22:
image = (
image, # 1
tmxData.get_tile_image(0, 15,
layer_num), # 2
tmxData.get_tile_image(1, 15,
layer_num), # 3
tmxData.get_tile_image(
2, 15, layer_num) # activated
)
# Map class has 1)"map" list, which is used in collision system because we can
# easily get block by x and y coordinate 2)"obj", "obj_bg" and simular arrays -
# they are used in rendering because you don't need to cycle through every
# (x, y) pair. Here we are adding the same platform object in 2 different arrays.
self.map[x][y] = Platform(x * tmxData.tileheight,
y * tmxData.tilewidth,
image, tileID)
self.obj.append(self.map[x][y])
elif layer.name == 'Background':
self.map[x][y] = BGObject(x * tmxData.tileheight,
y * tmxData.tilewidth,
image)
self.obj_bg.append(self.map[x][y])
layer_num += 1
# Tubes
self.spawn_tube(28, 10)
self.spawn_tube(37, 9)
self.spawn_tube(46, 8)
self.spawn_tube(55, 8)
self.spawn_tube(163, 10)
self.spawn_tube(179, 10)
# Mobs
self.mobs.append(Goombas(736, 352, False))
self.mobs.append(Goombas(1295, 352, True))
self.mobs.append(Goombas(1632, 352, False))
self.mobs.append(Goombas(1672, 352, False))
self.mobs.append(Goombas(5570, 352, False))
self.mobs.append(Goombas(5620, 352, False))
self.map[21][8].bonus = 'mushroom'
self.map[78][8].bonus = 'mushroom'
self.map[109][4].bonus = 'mushroom'
self.flag = Flag(6336, 48)
def __init__(self, cr):
DistributedObject.__init__(self, cr)
Flag.__init__(self, 'flag')
def start_battle(self, clock):
pygame.display.set_caption("Fight!!")
# ENTITIES
# Background
background = pygame.Surface(self.screen.get_size())
background.fill((0, 0, 0))
self.screen.blit(background, (0, 0))
# Sprites
top_widget_size = (self.screen.get_size()[0],
round(self.screen.get_size()[1] / 10))
top_widget = Boundary((self.screen.get_size()[0] / 2,
round(self.screen.get_size()[1] / 20)),
color=(255, 255, 0),
size=top_widget_size)
# Grids
grid_sprites, safe_grid, grid_position = self.make_grid(
(0, round(self.screen.get_size()[1] / 10)))
curr_map = Map(grid_position)
obsticles = curr_map.make_map(OBSTACLE_GRID_TILE)
potential_box = curr_map.get_box_position()
obsticles = pygame.sprite.Group(obsticles)
# Boundary
top_boundary = Boundary((600, 69), (255, 255, 255), (1200, 20))
left_boundary = Boundary((-4, 350), (255, 255, 255), (20, 700))
right_boundary = Boundary((1204, 350), (255, 255, 255), (20, 700))
bottom_boundary = Boundary((600, 701), (255, 255, 255), (1200, 20))
top_boundary.make_invisible()
left_boundary.make_invisible()
right_boundary.make_invisible()
bottom_boundary.make_invisible()
obsticles.add(top_boundary, left_boundary, right_boundary,
bottom_boundary)
# Player
player_1 = Player(grid_position[7][32])
player_2 = Player(grid_position[7][0])
player_1_attacks = pygame.sprite.Group()
player_2_attacks = pygame.sprite.Group()
# Player score zone
p1_score_zone = Boundary((0, 0), (0, 0, 0), (72, 144))
p1_score_zone.rect.topleft = (grid_position[6][0][0] - 18,
grid_position[6][0][1] - 18)
p1_score_zone.make_invisible()
p2_score_zone = Boundary((0, 0), (0, 0, 0), (72, 144))
p2_score_zone.rect.topleft = (grid_position[6][31][0] - 18,
grid_position[6][31][1] - 18)
p2_score_zone.make_invisible()
score_zone = [p1_score_zone, p2_score_zone]
# Zombies
zombie_group = pygame.sprite.Group()
zombie_group.add(Zombie(player_1, player_2, (500, -5), safe_grid))
zombie_group.add(Zombie(player_1, player_2, (700, -5), safe_grid))
zombie_group.add(Zombie(player_1, player_2, (600, 350), safe_grid))
zombie_group.add(Zombie(player_1, player_2, (500, 705), safe_grid))
zombie_group.add(Zombie(player_1, player_2, (700, 705), safe_grid))
# HP Bar
player_2_bar = StatBar((200, 35), (0, 255, 0), (300, 25), MAX_HP)
player_1_bar = StatBar((1000, 35), (0, 255, 0), (300, 25), MAX_HP)
player_1_bar.set_reversed_direction()
bars = [
player_2_bar.get_full_bar((255, 0, 0)),
player_1_bar.get_full_bar((255, 0, 0))
]
# Box
# Item Box
box_sprites = pygame.sprite.Group()
# Goals
flag = Flag((600, 350))
goal = CaptureFlag([player_1, player_2], score_zone, flag, num_round=3)
# Label color
p1_label_color = (0, 0, 255)
p2_label_color = (255, 0, 0)
# Flag
flag_p2 = Label(44, (400, 35))
flag_p2.set_color(p2_label_color)
flag_p1 = Label(44, (780, 35))
flag_p1.set_color(p1_label_color)
# timer
timer = Timer(30, (560, 35), 4, 20, FRAME_RATE)
# Labels
p2_label = Label(20, (20, 35))
p2_label.set_color(p2_label_color)
p2_label.set_msg("P2 ")
p1_label = Label(20, (1160, 35))
p1_label.set_color(p1_label_color)
p1_label.set_msg("P1")
p1_head = Label(15, (player_1.rect.centerx - 8, player_1.rect.top - 5))
p1_head.set_color(p1_label_color)
p1_head.set_msg("P1")
p2_head = Label(15, (player_2.rect.centerx - 8, player_2.rect.top - 5))
p2_head.set_color(p2_label_color)
p2_head.set_msg("P2")
p1_weapon = Label(20, (990, 56))
p1_weapon.set_msg("sada")
p2_weapon = Label(20, (170, 56))
p2_weapon.set_msg("sada")
labels = [
p1_label, p2_label, p1_head, p2_head, p1_weapon, p2_weapon,
flag_p1, flag_p2
]
keep_going = True
box_flag = True
all_sprites = pygame.sprite.OrderedUpdates(grid_sprites, obsticles,
flag, player_1, player_2,
zombie_group, top_widget,
timer, labels, bars,
player_1_bar, player_2_bar)
# LOOP
while keep_going:
if goal.screen_pause:
pygame.time.wait(1500)
goal.screen_pause = False
# TIME
clock.tick(FRAME_RATE)
if timer.get_real_second() % 5 == 0:
# Box
if box_flag:
box_flag = False
box = self.generate_box(potential_box)
box_sprites.add(box)
all_sprites.add(box)
else:
box_flag = True
if timer.get_real_second() % 20 == 0 and len(zombie_group) <= 1:
zombie_group.add(
Zombie(player_1, player_2, (500, -5), safe_grid))
zombie_group.add(
Zombie(player_1, player_2, (700, -5), safe_grid))
zombie_group.add(
Zombie(player_1, player_2, (600, 350), safe_grid))
zombie_group.add(
Zombie(player_1, player_2, (500, 705), safe_grid))
zombie_group.add(
Zombie(player_1, player_2, (700, 705), safe_grid))
all_sprites.add(zombie_group)
for z in zombie_group:
z.move(zombie_group)
# Check for Goal
if goal.check_for_win():
keep_going = False
if timer.time_up():
keep_going = False
flag_p1.set_msg(str(goal.score[0]))
flag_p2.set_msg(str(goal.score[1]))
# EVENT HANDLING
for event in pygame.event.get():
if event.type == pygame.QUIT:
return 3
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_p:
keep_going = False
#Player 1 event handle
if pygame.key.get_pressed()[pygame.K_RIGHT]:
temp_block = TempBlock(player_1.rect.center,
player_1.rect.size)
temp_block.rect.x += player_1.velocity
if pygame.sprite.spritecollide(temp_block, obsticles, False):
# Check the previous directoin
if player_1.direction == 1 or player_1.prev_direction == 1:
i = 1
# Check if the we continue with previous direction for more frames will be able to pass through
while i < player_1.velocity * SMOOTH_TURNING_FRAME_DELAY:
i += 1
temp_block.rect.y += 1
if not pygame.sprite.spritecollide(
temp_block, obsticles, False):
player_1.go_down()
break
elif player_1.direction == 3 or player_1.prev_direction == 3:
i = 1
while i < player_1.velocity * SMOOTH_TURNING_FRAME_DELAY:
i += 1
temp_block.rect.y -= 1
if not pygame.sprite.spritecollide(
temp_block, obsticles, False):
player_1.go_up()
break
else:
pass
else:
player_1.go_right()
elif pygame.key.get_pressed()[pygame.K_DOWN]:
temp_block = TempBlock(player_1.rect.center,
player_1.rect.size)
temp_block.rect.y += player_1.velocity
if pygame.sprite.spritecollide(temp_block, obsticles, False):
if player_1.direction == 0 or player_1.prev_direction == 0:
i = 1
while i < player_1.velocity * SMOOTH_TURNING_FRAME_DELAY:
i += 1
temp_block.rect.x += 1
if not pygame.sprite.spritecollide(
temp_block, obsticles, False):
player_1.go_right()
break
elif player_1.direction == 2 or player_1.prev_direction == 2:
i = 1
while i < player_1.velocity * SMOOTH_TURNING_FRAME_DELAY:
i += 1
temp_block.rect.x -= 1
if not pygame.sprite.spritecollide(
temp_block, obsticles, False):
player_1.go_left()
break
else:
pass
else:
player_1.go_down()
elif pygame.key.get_pressed()[pygame.K_UP]:
temp_block = TempBlock(player_1.rect.center,
player_1.rect.size)
temp_block.rect.y -= player_1.velocity
if pygame.sprite.spritecollide(temp_block, obsticles, False):
if player_1.direction == 0 or player_1.prev_direction == 0:
i = 1
while i < player_1.velocity * SMOOTH_TURNING_FRAME_DELAY:
i += 1
temp_block.rect.x += 1
if not pygame.sprite.spritecollide(
temp_block, obsticles, False):
player_1.go_right()
break
elif player_1.direction == 2 or player_1.prev_direction == 2:
i = 1
while i < player_1.velocity * SMOOTH_TURNING_FRAME_DELAY:
i += 1
temp_block.rect.x -= 1
if not pygame.sprite.spritecollide(
temp_block, obsticles, False):
player_1.go_left()
break
else:
pass
else:
player_1.go_up()
elif pygame.key.get_pressed()[pygame.K_LEFT]:
temp_block = TempBlock(player_1.rect.center,
player_1.rect.size)
temp_block.rect.x -= player_1.velocity
if pygame.sprite.spritecollide(temp_block, obsticles, False):
if player_1.direction == 1 or player_1.prev_direction == 1:
i = 1
while i < player_1.velocity * SMOOTH_TURNING_FRAME_DELAY:
i += 1
temp_block.rect.y += 1
if not pygame.sprite.spritecollide(
temp_block, obsticles, False):
player_1.go_down()
break
elif player_1.direction == 3 or player_1.prev_direction == 3:
i = 1
while i < player_1.velocity * SMOOTH_TURNING_FRAME_DELAY:
i += 1
temp_block.rect.y -= 1
if not pygame.sprite.spritecollide(
temp_block, obsticles, False):
player_1.go_up()
break
else:
pass
else:
player_1.go_left()
if pygame.key.get_pressed()[pygame.K_RCTRL]:
lst = player_1.attack()
player_1_attacks.add(lst)
all_sprites.add(lst)
# Player 2 event handle
if pygame.key.get_pressed()[pygame.K_d]:
temp_block = TempBlock(player_2.rect.center,
player_2.rect.size)
temp_block.rect.x += player_2.velocity
if pygame.sprite.spritecollide(temp_block, obsticles, False):
# Check the previous directoin
if player_2.direction == 1 or player_2.prev_direction == 1:
i = 1
# Check if the we continue with previous direction for more frames will be able to pass through
while i < player_2.velocity * SMOOTH_TURNING_FRAME_DELAY:
i += 1
temp_block.rect.y += 1
if not pygame.sprite.spritecollide(
temp_block, obsticles, False):
player_2.go_down()
break
elif player_2.direction == 3 or player_2.prev_direction == 3:
i = 1
while i < player_2.velocity * SMOOTH_TURNING_FRAME_DELAY:
i += 1
temp_block.rect.y -= 1
if not pygame.sprite.spritecollide(
temp_block, obsticles, False):
player_2.go_up()
break
else:
pass
else:
player_2.go_right()
elif pygame.key.get_pressed()[pygame.K_s]:
temp_block = TempBlock(player_2.rect.center,
player_2.rect.size)
temp_block.rect.y += player_2.velocity
if pygame.sprite.spritecollide(temp_block, obsticles, False):
if player_2.direction == 0 or player_2.prev_direction == 0:
i = 1
while i < player_2.velocity * SMOOTH_TURNING_FRAME_DELAY:
i += 1
temp_block.rect.x += 1
if not pygame.sprite.spritecollide(
temp_block, obsticles, False):
player_2.go_right()
break
elif player_2.direction == 2 or player_2.prev_direction == 2:
i = 1
while i < player_2.velocity * SMOOTH_TURNING_FRAME_DELAY:
i += 1
temp_block.rect.x -= 1
if not pygame.sprite.spritecollide(
temp_block, obsticles, False):
player_2.go_left()
break
else:
pass
else:
player_2.go_down()
elif pygame.key.get_pressed()[pygame.K_w]:
temp_block = TempBlock(player_2.rect.center,
player_2.rect.size)
temp_block.rect.y -= player_2.velocity
if pygame.sprite.spritecollide(temp_block, obsticles, False):
if player_2.direction == 0 or player_2.prev_direction == 0:
i = 1
while i < player_2.velocity * SMOOTH_TURNING_FRAME_DELAY:
i += 1
temp_block.rect.x += 1
if not pygame.sprite.spritecollide(
temp_block, obsticles, False):
player_2.go_right()
break
elif player_2.direction == 2 or player_2.prev_direction == 2:
i = 1
while i < player_2.velocity * SMOOTH_TURNING_FRAME_DELAY:
i += 1
temp_block.rect.x -= 1
if not pygame.sprite.spritecollide(
temp_block, obsticles, False):
player_2.go_left()
break
else:
pass
else:
player_2.go_up()
elif pygame.key.get_pressed()[pygame.K_a]:
temp_block = TempBlock(player_2.rect.center,
player_2.rect.size)
temp_block.rect.x -= player_2.velocity
if pygame.sprite.spritecollide(temp_block, obsticles, False):
if player_2.direction == 1 or player_2.prev_direction == 1:
i = 1
while i < player_2.velocity * SMOOTH_TURNING_FRAME_DELAY:
i += 1
temp_block.rect.y += 1
if not pygame.sprite.spritecollide(
temp_block, obsticles, False):
player_2.go_down()
break
elif player_2.direction == 3 or player_2.prev_direction == 3:
i = 1
while i < player_2.velocity * SMOOTH_TURNING_FRAME_DELAY:
i += 1
temp_block.rect.y -= 1
if not pygame.sprite.spritecollide(
temp_block, obsticles, False):
player_2.go_up()
break
else:
pass
else:
player_2.go_left()
if pygame.key.get_pressed()[pygame.K_SPACE]:
lst2 = player_2.attack()
player_2_attacks.add(lst2)
all_sprites.add(lst2)
# Collisions handleling
for box1 in pygame.sprite.spritecollide(player_1, box_sprites,
False):
temp_label = TempLabel(
15, (player_1.rect.centerx - 8, player_1.rect.top - 5), 3,
FRAME_RATE)
temp_label.set_msg(box1.__str__())
all_sprites.add(temp_label)
box1.collide(player_1)
for box2 in pygame.sprite.spritecollide(player_2, box_sprites,
False):
box2.collide(player_2)
temp_label = TempLabel(
15, (player_2.rect.centerx - 8, player_2.rect.top - 5), 3,
FRAME_RATE)
temp_label.set_msg(box2.__str__())
all_sprites.add(temp_label)
# Zombie hit player
for zombie in pygame.sprite.spritecollide(player_1, zombie_group,
False):
zombie.collide(player_1)
for zombie in pygame.sprite.spritecollide(player_2, zombie_group,
False):
zombie.collide(player_2)
# Players hit zombies
for zombie in zombie_group:
for bullet in pygame.sprite.spritecollide(
zombie, player_2_attacks, False):
bullet.collide(zombie)
for bullet in pygame.sprite.spritecollide(
zombie, player_1_attacks, False):
bullet.collide(zombie)
# bullet_hit_walls
for wall in obsticles:
for bullet in pygame.sprite.spritecollide(
wall, player_1_attacks, False):
bullet.end()
for bullet in pygame.sprite.spritecollide(
wall, player_2_attacks, False):
bullet.end()
# Player_1 attacks
for hit in pygame.sprite.spritecollide(player_2, player_1_attacks,
False):
hit.collide(player_2)
# Player_2 attacks
for hit in pygame.sprite.spritecollide(player_1, player_2_attacks,
False):
hit.collide(player_1)
# Player hp bar
player_2_bar.set_curr_stat(player_2.health)
player_1_bar.set_curr_stat(player_1.health)
# Player head
p1_head.set_position(
(player_1.rect.centerx - 8, player_1.rect.top - 5))
p2_head.set_position(
(player_2.rect.centerx - 8, player_2.rect.top - 5))
p1_weapon.set_msg(str(player_1.weapon))
p2_weapon.set_msg(str(player_2.weapon))
if player_1.is_dead():
if flag.get_player() == player_1:
flag.drop()
player_1.respawn()
if player_2.is_dead():
if flag.get_player() == player_2:
flag.drop()
player_2.respawn()
for zombie in zombie_group:
if zombie.is_dead(): zombie.kill()
all_sprites.clear(self.screen, background)
all_sprites.update()
all_sprites.draw(self.screen)
pygame.display.flip()
lst = player_1.weapon.update()
player_1_attacks.add(lst)
all_sprites.add(lst)
lst = player_2.weapon.update()
player_2_attacks.add(lst)
all_sprites.add(lst)
end_msg = Label(60, (500, 350))
end_msg.set_color((255, 255, 0))
end_msg.set_msg(goal.get_wining_msg())
self.screen.blit(end_msg.image, end_msg)
pygame.display.flip()
pygame.time.wait(2000)
return 2
def ready_stat():
ia_flag = Flag(open("ians.flg", "w"))
ia_flag.set_stat([cf.Comp.INPUT, cf.Stat.READY, 0, 0, 0, 0, 0, 0])
del ia_flag
def write_stat():
ia_flag = Flag(open("ians.flg", "w"))
ia_flag.set_stat([cf.Comp.INPUT, cf.Stat.ANSWERED, 0, 0, 0, 0, 0, 0])
del ia_flag
print("Pocket Farm's")
print("SENSOR READER MODULE\nVERSION 1.0.0")
print("_________________________\n")
ir_flag = Flag(open("ireq.flg", "r"))
first = False
while True:
ir_flag.get_data()
if ir_flag.is_requested() and not first:
print("Reading... ", end="")
read_sensor()
write_stat()
print("done")
first = True
if ir_flag.is_acquired() and first:
ready_stat()
first = False
print("acquired")
