def test_no_start_evaluate_None(self):
        '''

        '''
        timestamp = datetime.datetime(2018, 4, 23, 0, 0)

        sch = Schedule(None, DEFAULT_STOP, DEFAULT_ZONE, DEFAULT_DAYS)
        target = sch.evaluate(timestamp)
        self.assertEqual(target, None)
    def test_no_stop_evaluate_True(self):
        '''

        '''
        timestamp = datetime.datetime(2018, 4, 23, 12, 0)

        sch = Schedule(DEFAULT_START, None, DEFAULT_ZONE, DEFAULT_DAYS)
        target = sch.evaluate(timestamp)
        self.assertEqual(target, True)
    def test_evaluate_False(self):
        '''

        '''
        timestamp = datetime.datetime(2018, 4, 23, 23, 0)

        sch = Schedule(DEFAULT_START, DEFAULT_STOP, DEFAULT_ZONE, DEFAULT_DAYS)
        target = sch.evaluate(timestamp)
        self.assertEqual(target, False)
    def setUp(self):
        self.scheduler = Scheduler()

        self.schedules = self.scheduler.scheduler(10, 'activities.txt')

        self.schedules_1 = Schedule()
        self.schedules_2 = Schedule()

        self.schedules_1.agenda = [('Giant Puzzle Dinosaurs', 30),
                                   ('Enigma Challenge', 45),
                                   ('Human Table Football', 30)]
        self.schedules_2.agenda = [('Salsa & Pickles', 15),
                                   ('Indiano Drizzle', 45),
                                   ('Buggy Driving', 30)]
    def test_empty_start_stop(self):
        '''

        '''
        with self.assertRaises(ValueError) as cm:
            sch = Schedule(None, None, DEFAULT_ZONE, DEFAULT_DAYS)
        self.assertRegex(cm.exception.args[0], 'start_time or stop_time must be set')
    def test_invalid_start_stop(self):
        '''

        '''
        with self.assertRaises(ValueError) as cm:
            sch = Schedule(DEFAULT_START, DEFAULT_START, DEFAULT_ZONE, DEFAULT_DAYS)
        self.assertRegex(cm.exception.args[0], 'stop_time ".*" must be after start_time ".*"')
    def test_invalid_stop_type(self):
        '''

        '''
        stop = '22:00'

        with self.assertRaises(TypeError) as cm:
            sch = Schedule(DEFAULT_START, stop, DEFAULT_ZONE, DEFAULT_DAYS)
        self.assertRegex(cm.exception.args[0], 'stop_time must be a datetime.time object')
    def test_invalid_zone_type(self):
        '''

        '''
        zone = 'UTC'

        with self.assertRaises(TypeError) as cm:
            sch = Schedule(DEFAULT_START, DEFAULT_STOP, zone, DEFAULT_DAYS)
        self.assertRegex(cm.exception.args[0], 'time_zone must be a datetime.tzinfo object')
    def test_invalid_days_value(self):
        '''

        '''
        days = set(['mon','tue','wed','thu','fri'])

        with self.assertRaises(TypeError) as cm:
            sch = Schedule(DEFAULT_START, DEFAULT_STOP, DEFAULT_ZONE, days)
        self.assertRegex(cm.exception.args[0], 'days must be a set of scheduler.Day')
    def test_create_from_string(self):
        '''

        '''
        sch = Schedule.from_string(DEFAULT_SCHEDULE_STRING)
        self.assertTrue(sch)
        self.assertEqual(sch.start_time, DEFAULT_START)
        self.assertEqual(sch.stop_time, DEFAULT_STOP)
        self.assertEqual(sch.time_zone, DEFAULT_ZONE)
        self.assertEqual(sch.days, DEFAULT_DAYS)
 def test_create(self):
     '''
         Create a schedule object
     '''
     sch = Schedule(DEFAULT_START, DEFAULT_STOP, DEFAULT_ZONE, DEFAULT_DAYS)
     self.assertTrue(sch)
     self.assertEqual(sch.start_time, DEFAULT_START)
     self.assertEqual(sch.stop_time, DEFAULT_STOP)
     self.assertEqual(sch.time_zone, DEFAULT_ZONE)
     self.assertEqual(sch.days, DEFAULT_DAYS)
    def test_create_empty_stop(self):
        '''

        '''
        sch = Schedule(DEFAULT_START, None, DEFAULT_ZONE, DEFAULT_DAYS)
        self.assertTrue(sch)
        self.assertEqual(sch.start_time, DEFAULT_START)
        self.assertEqual(sch.stop_time, None)
        self.assertEqual(sch.time_zone, DEFAULT_ZONE)
        self.assertEqual(sch.days, DEFAULT_DAYS)
Example #13
0
    def execute_schedule(self,
                         schedule,
                         track_full_pass=False,
                         compute_ant_points=True,
                         N=None):
        if self._disabled:  # Note, the scheduler itself is also enabled/disabled. But also want to prevent the creation of new schedules.
            raise Exception(
                "RPCSchedulerServer: Currently disabled. Call enable() first")

        schedule = Schedule.from_json(schedule)
        self.scheduler = Scheduler(self.gs,
                                   schedule,
                                   track_full_pass=track_full_pass,
                                   compute_ant_points=compute_ant_points,
                                   enforce_signoffs=self._enforce_signoffs)
        self.scheduler.execute(N=N)
Example #14
0
def send_schedule(date: str):
    group = db.get_group_of_user(event["message"]["from_id"])
    gid = db.get_schedule_descriptor(group)
    s = Schedule(date, gid)
    s.get_raw()
    if s.is_exist():
        sch = s.generate()
        bot.send_message(msg=sch, pid=event["message"]["from_id"])
    else:
        bot.send_message(msg="Расписание отсутствует.",
                         pid=event["message"]["from_id"])
Example #15
0
    def __init__(self):
        #window setup
        pygame.display.set_caption('Necromonster')
        pygame.display.set_icon(pygame.image.load(os.path.join('rec', 'misc', 'icon.png')))
        self.main_path = os.getcwd()

        # initiate the clock and screen
        self.clock = pygame.time.Clock()
        self.last_tick = pygame.time.get_ticks()
        self.screen_res = [900, 650]
        self.center_point = [470., 350.]
        self.screen = pygame.display.set_mode(self.screen_res, pygame.HWSURFACE, 32)

        #DEBUG values
        self.DEBUG = 1
        self.RECT_DEBUG = 0

        #Init custom game classe(s)
        self.EntityHandler = EntityHandler(self)
        self.Scheduler = Schedule(self)
        self.Projectile = Projectile
        self.Monster = Monster
        self.Item = Item
        self.Invent = Invent(self)
        self.Weapon = Weapon
        self.Garment = Garment
        self.Player = Player(self)
        self.HUD = HUD(self)

        # Init entity manager vars
        self.entities = []

        # load fonts, create font list
        self.text_list = []
        self.default_font = pygame.font.SysFont(None, 20)

        # get the map that you are on
        self.blit_list = mapLoader.load('home', self)

        self.Item(self, 'Mythril', [350, 400], world=1)

        while 1:
            self.Loop()
Example #16
0
    def get_scheduled_instances(self):
        instances = []

        ec2 = boto3.client('ec2')
        regions = [
            region['RegionName']
            for region in ec2.describe_regions()['Regions']
        ]

        for region in regions:
            ec2 = boto3.client('ec2', region_name=region)
            # TODO: Add filters to ignore the following instances
            #   Instance State = shutting-down or terminated
            #   Instances in auto-scaling groups
            filters = [{'Name': 'tag-key', 'Values': [EC2.SCHEDULE_TAG]}]
            result = ec2.describe_instances(Filters=filters)

            # TODO: Get rid of this double 'for' loop
            for reservation in result['Reservations']:
                for ec2_instance in reservation['Instances']:
                    id = region + ':' + ec2_instance['InstanceId']
                    running = self._get_state(ec2_instance['State'])
                    schedule = self._get_schedule(ec2_instance['Tags'])
                    logger.info(
                        'Instance [{}]: Running= {} Schedule= {}'.format(
                            id, running, schedule))
                    # Ignore instances that are not running or stopped
                    if running != None:
                        try:
                            instances.append(
                                Instance(id, running,
                                         Schedule.from_string(schedule),
                                         provider.aws.EC2(id)))
                        except Exception as e:
                            logger.error('Instance [{}]: {}'.format(id, e))

        return instances
Example #17
0
import logging

import pytz
import datetime

from scheduler import Instance, Schedule, Day

DEFAULT_ID = 0

DEFAULT_START = datetime.time(hour=10, minute=0)
DEFAULT_STOP = datetime.time(hour=22, minute=0)
DEFAULT_ZONE = pytz.timezone('UTC')
DEFAULT_DAYS = set(
    [Day.Mon, Day.Tue, Day.Wed, Day.Thu, Day.Fri, Day.Sat, Day.Sun])
DEFAULT_SCHEDULE = Schedule(DEFAULT_START, DEFAULT_STOP, DEFAULT_ZONE,
                            DEFAULT_DAYS)

NO_START_SCHEDULE = Schedule(None, DEFAULT_STOP, DEFAULT_ZONE, DEFAULT_DAYS)
NO_STOP_SCHEDULE = Schedule(DEFAULT_START, None, DEFAULT_ZONE, DEFAULT_DAYS)

logger = logging.getLogger()
logger.setLevel(logging.WARNING)
logger.addHandler(logging.StreamHandler())


class InstanceTestCase(unittest.TestCase):
    """
        Unit tests for Instance
    """

    ######################################################################
Example #18
0
class Necro():
    def __init__(self):
        """
        Main game class initialization. All other class references point to this class as "game"
        """
        # window setup
        pygame.display.set_caption('Necromonster')
        pygame.display.set_icon(pygame.image.load(os.path.join('rec', 'misc', 'icon.png')))
        self.main_path = os.getcwd()

        # initiate the clock and screen object
        self.clock = pygame.time.Clock()
        self.FPS = 50
        self.last_tick = pygame.time.get_ticks()
        self.screen_res = [900, 650]
        self.center_point = [470, 350]
        self.screen = pygame.display.set_mode(self.screen_res, pygame.HWSURFACE, 32)

        #DEBUG values
        self.DEBUG = 1
        self.RECT_DEBUG = 0
        self.angle = 0

        #Init and assign custom game class(es)
        self.EntityHandler = EntityHandler(self)
        self.ParticleManager = ParticleManager(self)
        self.Scheduler = Schedule(self)
        self.Entity = Entity
        self.Projectile = Projectile
        self.Monster = Monster
        self.NPC = NPC
        self.NPCText = NPCText
        self.Item = Item
        self.Inventory = Invent
        self.Invent = self.Inventory(self)
        self.Weapon = Weapon
        self.Garment = Garment
        self.Player = Player(self)
        self.HUD = HUD(self)

        # Init entity manager vars
        self.entities = []
        self.shadows = []

        # load fonts, create font list
        # do not use pygame.font.SysFont!
        self.text_list = []
        self.default_font = pygame.font.Font(os.path.join('rec', 'font', 'freesansbold.ttf'), 15)
        self.speak_font = pygame.font.Font(os.path.join('rec', 'font', 'freesansbold.ttf'), 30)

        # load the map that player is on
        self.INSIDE = 0
        self.blit_list = mapLoader.load('home', self)

        # spawn initial map items/entities
        self.Item(self, 'Mythril', [350, 400], world=1)
        self.NPC(self, "blacksmith", [400, 400], 100, 'still')
        for i in xrange(4):
            self.Monster(self, 'chicken', [200+(i*50),650], 1, 'neutral')
        self.Monster(self, "goop", [100, 100], 1, 'aggressive')

        # begin main game loop
        while 1:
            self.Loop()

    def Loop(self):
        """
        Main loop of the game. Calls tick, draw, and event processing
        functions. Tick and draw are only called every 20 milliseconds
        """
        self.eventLoop()
        self.Tick()
        self.Draw()
        pygame.display.update()

    def eventLoop(self):
        """
        Uses pygame event handling to process keypresses and mouse clicks.
        Used for chat, interacting with objects, and inventory management
        """
        for event in pygame.event.get():
            event # prevents exit button freeze up
            if event.type == QUIT:
                pygame.quit()
                sys.exit()
            elif event.type == KEYDOWN:
                # toggle chat bar active
                if not self.HUD.chat_active:
                    if event.key == K_e:
                        self.Invent.toggleView()
                    if event.key == K_t:
                        #activate the chat bar
                        self.HUD.chat_message = ''
                        self.HUD.chat_active = 1
                        self.Player.can_move = 0
                        return 0
                # process chat messages. Remove or add characters while chat box is open
                if event.key == K_ESCAPE or event.key == K_RETURN:
                    self.HUD.processCommand(self.HUD.chat_message)
                    self.HUD.chat_active = 0
                    self.Player.can_move = 1
                    self.HUD.chat_message = ''
                elif event.key == K_BACKSPACE:
                    self.HUD.chat_message = self.HUD.chat_message[:-1]
                elif event.key <= 255:
                    char = chr(event.key)
                    if self.keys_pressed[K_LSHIFT] or self.keys_pressed[K_RSHIFT]:
                        char = char.upper()
                    self.HUD.chat_message += char
                # interaction with entities on space bar press
                if event.key == K_SPACE:
                    for monster in self.EntityHandler.monsters:
                        if monster.NPC:
                            if monster.isPlayerClose(75) and monster.interacting == False:
                                monster.interacting = True
                            elif not monster.isPlayerClose(75) or monster.interacting == True:
                                monster.interacting = False
                                self.HUD.delPrompt()
            # inventory management, checks for item throws, and placement in slots.
            elif event.type == MOUSEBUTTONDOWN:
                self.Invent.last_click = pygame.mouse.get_pos()
                if self.Invent.in_hand:
                    self.Invent.testThrow(self.Invent.last_click)
                if self.Invent.shown:
                    self.Invent.inventClick(self.Invent.last_click)
                elif pygame.mouse.get_pressed()[0]:
                    self.Player.attack(pygame.mouse.get_pos())

    def Tick(self):
        """
        Updates all game math and entity states. No drawing is done.
        """
        ttime = self.clock.tick(self.FPS)
        self.keys_pressed = pygame.key.get_pressed()
        if self.keys_pressed[K_EQUALS]:
            self.HUD.daytime_start -= 3
        if self.keys_pressed[K_MINUS]:
            self.HUD.daytime_start += 3
        self.Scheduler.update()
        self.EntityHandler.updateAll(ttime)

        self.Invent.update()
        self.HUD.updateDay()
        for index, text in enumerate(self.text_list):
            if text[2]:
                raise DeprecationWarning
        self.last_tick = pygame.time.get_ticks()

    def off(self, coords):
        """
        Offsets image coordinates to appear correct from the view of the player.
        Should be called on all surface coordinates before blitting.
        """
        newx = coords[0] - self.Player.player_r.x + 450
        newy = coords[1] - self.Player.player_r.y + 325
        return [newx, newy]

    def unoff(self, coords):
        """
        Removes the offset created by the off() function.
        """
        newx = coords[0] + self.Player.player_r.x - 450
        newy = coords[1] + self.Player.player_r.y - 325
        return [newx, newy]

    def getCenterBlit(self, surface, pos):
        pos[0] = pos[0] + surface.get_width() / 2
        pos[1] = pos[1] + surface.get_height() / 2
        return pos

    def rotopoint(self, surface, angle, pos):
        size = surface.get_size()
        if pos[0] > size[0]/2 or pos[1] > size[1]/2:
            print 'BIG ASS HONKEY'
        new_surf_size = [(size[0] - pos[0])*2, (size[1] - pos[1])*2]
        new_surf_blit_pos = [new_surf_size[0] - size[0], new_surf_size[1] - size[1]]
        new_surf = pygame.Surface(new_surf_size, pygame.SRCALPHA, 32)
        new_surf.blit(surface, new_surf_blit_pos)
        return pygame.transform.rotate(new_surf, angle)

    def testrot(self, image, angle):
        loc = image.get_rect().center
        new_rot = pygame.transform.rotate(image, angle)
        new_rot.get_rect(center=loc)
        return new_rot, new_rot.get_rect()


    def Draw(self):
        """
        Completes all blitting to the screend object, includes HUD updates.
        """
        tile_width = self.tile[1][0]
        tile_height = self.tile[1][1]
        tile_extrax = self.Player.player_r.x % tile_width
        tile_extray = self.Player.player_r.y % tile_height
        y = 0

        for i in xrange(self.screen_res[1] / tile_height + 3):
            for i in xrange(self.screen_res[0] / tile_width + 3):
                self.screen.blit(self.tile[0], [i * tile_width - tile_width - tile_extrax, y - tile_height - tile_extray])
            y += self.tile[1][1]
        if self.shadows:
            for s in self.shadows:
                s.update(self.screen)
        for surf in self.blit_list:
            if 'player' in surf:
                self.EntityHandler.blitAll()
            else:
                self.screen.blit(surf[0], self.off(surf[1]))
        for text in self.text_list:
            self.screen.blit(text[0], text[1])
        if self.Invent.shown:
            self.Invent.draw()
        if self.DEBUG:
            self.screen.blit(self.default_font.render(str(round(self.clock.get_fps())), True, (255, 255, 255)), [0, 0])
            self.screen.blit(self.default_font.render(str('%s, %s' % (self.Player.player_r.x, self.Player.player_r.y)), True, (255, 255, 255)), [0, 12])
            self.screen.blit(self.default_font.render(str(pygame.mouse.get_pos()), True, (255, 255, 255)), [0, 24])
        if self.RECT_DEBUG:
            ps = pygame.Surface(self.Player.player_dims)
            ps.fill([255, 0, 0])
            self.screen.blit(ps, self.off([self.Player.player_r.x, self.Player.player_r.y]))
        #Draws player and head text if it exists
        if self.Player.head_drawn:
            if self.Player.head_drawn[3]:
                self.screen.blit(self.Player.head_drawn[0], self.Player.head_drawn[1])
            else:
                self.Player.game.screen.blit(self.Player.head_drawn[0], self.off(self.Player.head_drawn[1]))
        self.ParticleManager.update()
        if self.Player.map_change:
            self.HUD.updateMapTrans()
        self.HUD.blitHUD()
Example #19
0
def simulate(params):
    class ClientSim(object):
        def __init__(self, env, films_list: list, schedule: Schedule):
            self.client = Client(films_list)
            self.client.statistics['hall'] = {}
            self.action = env.process(self.run())
            self.env = env
            self.schedule = schedule
            self.client.statistics['schedule'] = schedule
            self.available_sessions = []

        def run(self):
            if len(ticket_shop.queue) * 1.5 <= len(
                    food_shop.queue
            ):  # TODO: передать ticket и food кассы в класс при инициализации
                with ticket_shop.request() as req:
                    self.client.statistics['went to cinema'] = self.env.now
                    yield req
                    yield self.env.process(self.buy_ticket())
                if self.client.drink_preference + self.client.food_preference != 0:
                    with food_shop.request() as req:
                        yield req
                        yield self.env.process(self.buy_snacks())
            else:
                if self.client.food_preference + self.client.drink_preference != 0:
                    with food_shop.request() as req:
                        yield req
                        yield self.env.process(self.buy_snacks())
                with ticket_shop.request() as req:
                    self.client.statistics['went to cinema'] = self.env.now
                    yield req
                    yield self.env.process(self.buy_ticket())

        def get_available_sessions(self) -> list:
            now = self.new_now(self.env.now)
            now_minus_30min = now - datetime.timedelta(minutes=30)
            now_plus_1hour = now + datetime.timedelta(hours=1)
            sessions = []
            for i in range(len(self.schedule.queues)):
                for j in range(len(self.schedule.queues[i])):
                    start_time = self.schedule.queues[i][j].start_time
                    free_sits = self.schedule.queues[i][j].free_sits
                    if now_minus_30min < start_time < now_plus_1hour and free_sits > 0\
                            and self.schedule.queues[i][j].available is True:
                        sessions.append(self.schedule.queues[i][j])
            return sessions

        def choise_session(self):
            for i in self.client.films:
                session_dict = dict([(session.film_name, session)
                                     for session in self.available_sessions])
                session_films = [
                    session.film_name for session in self.available_sessions
                ]
                if i.name in session_films:
                    return session_dict[i.name]
            return None  # возвращаем пустоту, если для клиента нет подходящего фильма

        def new_now(self, now):
            return datetime.datetime.combine(
                datetime.date.today() + datetime.timedelta(
                    days=(8 + round(now) // 60) // 24),  # точный день
                datetime.time((8 + round(now) // 60) % 24,
                              round(now) % 60))

        def buy_ticket(self):
            # TODO: когда кончаются билеты удалить сессию из расписания (сделать недоступной)
            self.available_sessions = self.get_available_sessions()
            self.chosen_session = self.choise_session()
            if self.chosen_session is not None:
                self.chosen_session.free_sits -= 1
                if self.chosen_session.free_sits == 0:
                    self.chosen_session.available = False
                self.client.statistics['bought ticket'] = True
                self.client.statistics['film'] = self.chosen_session.film_name
                self.client.statistics['hall'][
                    'capacity'] = self.chosen_session.capacity
                self.client.statistics['hall'][
                    'name'] = self.chosen_session.hall_name
                now = self.new_now(self.env.now)
                self.client.statistics['ticket buying time'] = self.env.now
                self.client.statistics[
                    'session begining time'] = self.chosen_session.start_time
                self.client.statistics['spend money'] = self.chosen_session.ticket_price +\
                    (self.client.food_preference + self.client.drink_preference)*250
                print(f'{self.client.id} bought ticket at {now}')
                print(f'на фильм {self.chosen_session.film_name} осталось'
                      f' {self.chosen_session.free_sits} билетов')
                yield self.env.timeout(0.5)
            else:
                self.client.statistics['bought ticket'] = False
                self.client.statistics['ticket buying time'] = None
                print(f'{self.client.id} didnt find needed film and went away')

        def buy_snacks(self):
            now = self.new_now(self.env.now)
            self.client.statistics['snacks buying time'] = now
            timeout_snacks = self.client.drink_preference + self.client.food_preference
            self.client.statistics['bought snacks'] = timeout_snacks
            print(f'{self.client.id} bought snacks at {now}')
            yield self.env.timeout(timeout_snacks)

    daily_schedule = Schedule(FILMS_COUNT, HALLS_COUNT)
    print(daily_schedule)

    #
    films_for_choice = daily_schedule.films_list

    env = simpy.Environment()
    ticket_shop = simpy.Resource(env, capacity=TICKET_SHOP_CAPACITY)
    food_shop = simpy.Resource(env, capacity=FOOD_SHOP_CAPACITY)

    clients = []

    def client_creating(env, clients):
        for i in range(CLIENT_COUNT):
            client = ClientSim(env, films_for_choice, daily_schedule)
            clients.append(client)
            yield env.timeout(CLIENT_GEN_TIMEOUT)

    env.process(client_creating(env, clients))
    env.run(until=990)

    # Перенос статистики в файл
    statistic = []
    for i in range(clients.__len__()):
        statistic.append(clients[i].client.statistics)
    with open('sim.pickle', 'wb') as writer:
        pickle.dump(statistic, writer)
Example #20
0
 elif (db.get_session_state(
         event["message"]["from_id"]) == "ask_for_schedule_date"):
     if re.match(r"^\d\d(.|-|/)\d\d(.|-|/)20\d\d$",
                 event["message"]["text"]):
         try:
             d = datetime.datetime.strptime(
                 event["message"]["text"],
                 "%d-%m-%Y").strftime("%Y-%m-%d")
         except ValueError:
             bot.send_message(
                 msg="Неверный формат даты. Попробуйте еще раз.",
                 pid=event["message"]["from_id"],
             )
         else:
             group = db.get_group_of_user(event["message"]["from_id"])
             s = Schedule(d, group)
             s.get_raw()
             if s.is_exist():
                 schedule = s.generate()
                 bot.send_message(
                     msg=schedule,
                     pid=event["message"]["from_id"],
                     keyboard=kbs.generate_schedule_keyboard(),
                 )
                 db.update_session_state(event["message"]["from_id"],
                                         "main")
             else:
                 bot.send_message(
                     msg=
                     "Расписание отсутствует.\nПопробуй указать другую "
                     "дату.",
Example #21
0
class Necro():
    def __init__(self):
        #window setup
        pygame.display.set_caption('Necromonster')
        pygame.display.set_icon(pygame.image.load(os.path.join('rec', 'misc', 'icon.png')))
        self.main_path = os.getcwd()

        # initiate the clock and screen
        self.clock = pygame.time.Clock()
        self.last_tick = pygame.time.get_ticks()
        self.screen_res = [900, 650]
        self.center_point = [470., 350.]
        self.screen = pygame.display.set_mode(self.screen_res, pygame.HWSURFACE, 32)

        #DEBUG values
        self.DEBUG = 1
        self.RECT_DEBUG = 0

        #Init custom game classe(s)
        self.EntityHandler = EntityHandler(self)
        self.Scheduler = Schedule(self)
        self.Projectile = Projectile
        self.Monster = Monster
        self.Item = Item
        self.Invent = Invent(self)
        self.Weapon = Weapon
        self.Garment = Garment
        self.Player = Player(self)
        self.HUD = HUD(self)

        # Init entity manager vars
        self.entities = []

        # load fonts, create font list
        self.text_list = []
        self.default_font = pygame.font.SysFont(None, 20)

        # get the map that you are on
        self.blit_list = mapLoader.load('home', self)

        self.Item(self, 'Mythril', [350, 400], world=1)

        while 1:
            self.Loop()

    def Loop(self):
        # main game loop
        self.eventLoop()
        if pygame.time.get_ticks() - self.last_tick > 20:
            self.Tick()
            self.Draw()
        pygame.display.update()

    def eventLoop(self):
        # the main event loop, detects keypresses
        for event in pygame.event.get():
            if event.type == QUIT:
                pygame.quit()
                sys.exit()
            elif event.type == KEYDOWN:
                if not self.HUD.chat_active:
                    if event.key == K_e:
                        self.Invent.toggleView()
                    if event.key == K_t:
                        #activate the chat bar
                        self.HUD.chat_message = ''
                        self.HUD.chat_active = 1
                        self.Player.can_move = 0
                        return 0
                if event.key == K_ESCAPE or event.key == K_RETURN:
                    message = self.HUD.chat_message.split()
                    if len(message) >1:
                        if len(message) > 2:
                           self.HUD.command(message[0], message[1], message[2])
                        else:
                            self.HUD.command(message[0], message[1])
                    self.HUD.chat_active = 0
                    self.Player.can_move = 1
                    self.HUD.chat_message = ''
                elif event.key == K_BACKSPACE:
                    self.HUD.chat_message = self.HUD.chat_message[:-1]
                elif event.key <= 255:
                    char = chr(event.key)
                    if self.keys_pressed[K_LSHIFT] or self.keys_pressed[K_RSHIFT]:
                        char = char.upper()
                
                    
                        
                    
                    self.HUD.chat_message += char
            elif event.type == MOUSEBUTTONDOWN:
                if self.Invent.in_hand:
                    self.Invent.testThrow(pygame.mouse.get_pos())
                if self.Invent.shown:
                    self.Invent.inventClick(pygame.mouse.get_pos())
                elif pygame.mouse.get_pressed()[0]:
                    self.Player.attack(pygame.mouse.get_pos())

    def Tick(self):
        # updates to player location and animation frame
        ttime = self.clock.tick()
        self.keys_pressed = pygame.key.get_pressed()
        self.Scheduler.update()
        self.EntityHandler.updateAll(ttime)
        self.Invent.update()
        for index, text in enumerate(self.text_list):
            if text[2]:
                raise DeprecationWarning
        self.last_tick = pygame.time.get_ticks()

    def off(self, coords):
        newx = coords[0] - self.Player.player_r.x + 450
        newy = coords[1] - self.Player.player_r.y + 325
        return [newx, newy]

    def Draw(self):
        #Responsible for calling all functions that draw to the screen
        tile_width = self.tile[1][0]
        tile_height = self.tile[1][1]
        tile_extrax = self.Player.player_r.x % tile_width
        tile_extray = self.Player.player_r.y % tile_height
        y = 0

        for i in xrange(self.screen_res[1] / tile_height + 3):
            for i in xrange(self.screen_res[0] / tile_width + 3):
                self.screen.blit(self.tile[0], [i * tile_width - tile_width - tile_extrax, y - tile_height - tile_extray])
            y += self.tile[1][1]
        for surf in self.blit_list:
            if 'player' in surf:
                self.EntityHandler.blitAll()
            else:
                self.screen.blit(surf[0], self.off(surf[1]))
        for text in self.text_list:
            self.screen.blit(text[0], text[1])
        if self.Invent.shown:
            self.Invent.draw()
        if self.DEBUG:
            self.screen.blit(self.default_font.render(str(round(self.clock.get_fps())), True, (255, 255, 255)), [0, 0])
            self.screen.blit(self.default_font.render(str('%s, %s' % (self.Player.player_r.x, self.Player.player_r.y)), True, (255, 255, 255)), [0, 12])
            self.screen.blit(self.default_font.render(str(pygame.mouse.get_pos()), True, (255, 255, 255)), [0, 24])
        if self.RECT_DEBUG:
            ps = pygame.Surface(self.Player.player_dims)
            ps.fill([255, 0, 0])
            self.screen.blit(ps, self.off([self.Player.player_r.x, self.Player.player_r.y]))
        self.HUD.blitHUD()
Example #22
0
from scheduler import Schedule

Schedule().every(3).do(lambda i, d: print('Fizz', end='')).every(5).do(
    lambda i, d: print("Buzz", end='')).every(1).do(lambda i, d: print(
        i + 1, end='') if ((i + 1) % 3) * ((i + 1) % 5) != 0 else None).every(
            1).do(lambda i, d: print()).forNext(100).execute()
Example #23
0
def test_addtask():
    s = Schedule('maoxu', 'work schedule')
    s.add_task('test', 'test content', 100)
    s.add_task('cs106', 'teach cs106', 10)
    assert 'test' in s.tasks
    assert 'cs106' in s.tasks
Example #24
0
def test_removetask():
    s = Schedule('maoxu', 'personal schedule')
    s.add_task('test', 'test content', 100)
    s.remove_task('test')
    assert s.tasks == {}
Example #25
0
    def __init__(self):
        """
        Main game class initialization. All other class references point to this class as "game"
        """
        # window setup
        pygame.display.set_caption('Necromonster')
        pygame.display.set_icon(
            pygame.image.load(os.path.join('rec', 'misc', 'icon.png')))
        self.main_path = os.getcwd()

        # initiate the clock and screen object
        self.clock = pygame.time.Clock()
        self.FPS = 50
        self.last_tick = pygame.time.get_ticks()
        self.screen_res = [900, 650]
        self.center_point = [470, 350]
        self.screen = pygame.display.set_mode(self.screen_res,
                                              pygame.HWSURFACE, 32)

        #DEBUG values
        self.DEBUG = 1
        self.RECT_DEBUG = 0
        self.angle = 0

        #Init and assign custom game class(es)
        self.EntityHandler = EntityHandler(self)
        self.ParticleManager = ParticleManager(self)
        self.Scheduler = Schedule(self)
        self.Entity = Entity
        self.Projectile = Projectile
        self.Monster = Monster
        self.NPC = NPC
        self.NPCText = NPCText
        self.Item = Item
        self.Inventory = Invent
        self.Invent = self.Inventory(self)
        self.Weapon = Weapon
        self.Garment = Garment
        self.Player = Player(self)
        self.HUD = HUD(self)

        # Init entity manager vars
        self.entities = []
        self.shadows = []

        # load fonts, create font list
        # do not use pygame.font.SysFont!
        self.text_list = []
        self.default_font = pygame.font.Font(
            os.path.join('rec', 'font', 'freesansbold.ttf'), 15)
        self.speak_font = pygame.font.Font(
            os.path.join('rec', 'font', 'freesansbold.ttf'), 30)

        # load the map that player is on
        self.INSIDE = 0
        self.blit_list = mapLoader.load('home', self)

        # spawn initial map items/entities
        self.Item(self, 'Mythril', [350, 400], world=1)
        self.NPC(self, "blacksmith", [400, 400], 100, 'still')
        for i in xrange(4):
            self.Monster(self, 'chicken', [200 + (i * 50), 650], 1, 'neutral')
        self.Monster(self, "goop", [100, 100], 1, 'aggressive')

        # begin main game loop
        while 1:
            self.Loop()
Example #26
0
class Necro():
    def __init__(self):
        """
        Main game class initialization. All other class references point to this class as "game"
        """
        # window setup
        pygame.display.set_caption('Necromonster')
        pygame.display.set_icon(
            pygame.image.load(os.path.join('rec', 'misc', 'icon.png')))
        self.main_path = os.getcwd()

        # initiate the clock and screen object
        self.clock = pygame.time.Clock()
        self.FPS = 50
        self.last_tick = pygame.time.get_ticks()
        self.screen_res = [900, 650]
        self.center_point = [470, 350]
        self.screen = pygame.display.set_mode(self.screen_res,
                                              pygame.HWSURFACE, 32)

        #DEBUG values
        self.DEBUG = 1
        self.RECT_DEBUG = 0
        self.angle = 0

        #Init and assign custom game class(es)
        self.EntityHandler = EntityHandler(self)
        self.ParticleManager = ParticleManager(self)
        self.Scheduler = Schedule(self)
        self.Entity = Entity
        self.Projectile = Projectile
        self.Monster = Monster
        self.NPC = NPC
        self.NPCText = NPCText
        self.Item = Item
        self.Inventory = Invent
        self.Invent = self.Inventory(self)
        self.Weapon = Weapon
        self.Garment = Garment
        self.Player = Player(self)
        self.HUD = HUD(self)

        # Init entity manager vars
        self.entities = []
        self.shadows = []

        # load fonts, create font list
        # do not use pygame.font.SysFont!
        self.text_list = []
        self.default_font = pygame.font.Font(
            os.path.join('rec', 'font', 'freesansbold.ttf'), 15)
        self.speak_font = pygame.font.Font(
            os.path.join('rec', 'font', 'freesansbold.ttf'), 30)

        # load the map that player is on
        self.INSIDE = 0
        self.blit_list = mapLoader.load('home', self)

        # spawn initial map items/entities
        self.Item(self, 'Mythril', [350, 400], world=1)
        self.NPC(self, "blacksmith", [400, 400], 100, 'still')
        for i in xrange(4):
            self.Monster(self, 'chicken', [200 + (i * 50), 650], 1, 'neutral')
        self.Monster(self, "goop", [100, 100], 1, 'aggressive')

        # begin main game loop
        while 1:
            self.Loop()

    def Loop(self):
        """
        Main loop of the game. Calls tick, draw, and event processing
        functions. Tick and draw are only called every 20 milliseconds
        """
        self.eventLoop()
        self.Tick()
        self.Draw()
        pygame.display.update()

    def eventLoop(self):
        """
        Uses pygame event handling to process keypresses and mouse clicks.
        Used for chat, interacting with objects, and inventory management
        """
        for event in pygame.event.get():
            event  # prevents exit button freeze up
            if event.type == QUIT:
                pygame.quit()
                sys.exit()
            elif event.type == KEYDOWN:
                # toggle chat bar active
                if not self.HUD.chat_active:
                    if event.key == K_e:
                        self.Invent.toggleView()
                    if event.key == K_t:
                        #activate the chat bar
                        self.HUD.chat_message = ''
                        self.HUD.chat_active = 1
                        self.Player.can_move = 0
                        return 0
                # process chat messages. Remove or add characters while chat box is open
                if event.key == K_ESCAPE or event.key == K_RETURN:
                    self.HUD.processCommand(self.HUD.chat_message)
                    self.HUD.chat_active = 0
                    self.Player.can_move = 1
                    self.HUD.chat_message = ''
                elif event.key == K_BACKSPACE:
                    self.HUD.chat_message = self.HUD.chat_message[:-1]
                elif event.key <= 255:
                    char = chr(event.key)
                    if self.keys_pressed[K_LSHIFT] or self.keys_pressed[
                            K_RSHIFT]:
                        char = char.upper()
                    self.HUD.chat_message += char
                # interaction with entities on space bar press
                if event.key == K_SPACE:
                    for monster in self.EntityHandler.monsters:
                        if monster.NPC:
                            if monster.isPlayerClose(
                                    75) and monster.interacting == False:
                                monster.interacting = True
                            elif not monster.isPlayerClose(
                                    75) or monster.interacting == True:
                                monster.interacting = False
                                self.HUD.delPrompt()
            # inventory management, checks for item throws, and placement in slots.
            elif event.type == MOUSEBUTTONDOWN:
                self.Invent.last_click = pygame.mouse.get_pos()
                if self.Invent.in_hand:
                    self.Invent.testThrow(self.Invent.last_click)
                if self.Invent.shown:
                    self.Invent.inventClick(self.Invent.last_click)
                elif pygame.mouse.get_pressed()[0]:
                    self.Player.attack(pygame.mouse.get_pos())

    def Tick(self):
        """
        Updates all game math and entity states. No drawing is done.
        """
        ttime = self.clock.tick(self.FPS)
        self.keys_pressed = pygame.key.get_pressed()
        if self.keys_pressed[K_EQUALS]:
            self.HUD.daytime_start -= 3
        if self.keys_pressed[K_MINUS]:
            self.HUD.daytime_start += 3
        self.Scheduler.update()
        self.EntityHandler.updateAll(ttime)

        self.Invent.update()
        self.HUD.updateDay()
        for index, text in enumerate(self.text_list):
            if text[2]:
                raise DeprecationWarning
        self.last_tick = pygame.time.get_ticks()

    def off(self, coords):
        """
        Offsets image coordinates to appear correct from the view of the player.
        Should be called on all surface coordinates before blitting.
        """
        newx = coords[0] - self.Player.player_r.x + 450
        newy = coords[1] - self.Player.player_r.y + 325
        return [newx, newy]

    def unoff(self, coords):
        """
        Removes the offset created by the off() function.
        """
        newx = coords[0] + self.Player.player_r.x - 450
        newy = coords[1] + self.Player.player_r.y - 325
        return [newx, newy]

    def getCenterBlit(self, surface, pos):
        pos[0] = pos[0] + surface.get_width() / 2
        pos[1] = pos[1] + surface.get_height() / 2
        return pos

    def rotopoint(self, surface, angle, pos):
        size = surface.get_size()
        if pos[0] > size[0] / 2 or pos[1] > size[1] / 2:
            print 'BIG ASS HONKEY'
        new_surf_size = [(size[0] - pos[0]) * 2, (size[1] - pos[1]) * 2]
        new_surf_blit_pos = [
            new_surf_size[0] - size[0], new_surf_size[1] - size[1]
        ]
        new_surf = pygame.Surface(new_surf_size, pygame.SRCALPHA, 32)
        new_surf.blit(surface, new_surf_blit_pos)
        return pygame.transform.rotate(new_surf, angle)

    def testrot(self, image, angle):
        loc = image.get_rect().center
        new_rot = pygame.transform.rotate(image, angle)
        new_rot.get_rect(center=loc)
        return new_rot, new_rot.get_rect()

    def Draw(self):
        """
        Completes all blitting to the screend object, includes HUD updates.
        """
        tile_width = self.tile[1][0]
        tile_height = self.tile[1][1]
        tile_extrax = self.Player.player_r.x % tile_width
        tile_extray = self.Player.player_r.y % tile_height
        y = 0

        for i in xrange(self.screen_res[1] / tile_height + 3):
            for i in xrange(self.screen_res[0] / tile_width + 3):
                self.screen.blit(self.tile[0], [
                    i * tile_width - tile_width - tile_extrax,
                    y - tile_height - tile_extray
                ])
            y += self.tile[1][1]
        if self.shadows:
            for s in self.shadows:
                s.update(self.screen)
        for surf in self.blit_list:
            if 'player' in surf:
                self.EntityHandler.blitAll()
            else:
                self.screen.blit(surf[0], self.off(surf[1]))
        for text in self.text_list:
            self.screen.blit(text[0], text[1])
        if self.Invent.shown:
            self.Invent.draw()
        if self.DEBUG:
            self.screen.blit(
                self.default_font.render(str(round(self.clock.get_fps())),
                                         True, (255, 255, 255)), [0, 0])
            self.screen.blit(
                self.default_font.render(
                    str('%s, %s' %
                        (self.Player.player_r.x, self.Player.player_r.y)),
                    True, (255, 255, 255)), [0, 12])
            self.screen.blit(
                self.default_font.render(str(pygame.mouse.get_pos()), True,
                                         (255, 255, 255)), [0, 24])
        if self.RECT_DEBUG:
            ps = pygame.Surface(self.Player.player_dims)
            ps.fill([255, 0, 0])
            self.screen.blit(
                ps, self.off([self.Player.player_r.x, self.Player.player_r.y]))
        #Draws player and head text if it exists
        if self.Player.head_drawn:
            if self.Player.head_drawn[3]:
                self.screen.blit(self.Player.head_drawn[0],
                                 self.Player.head_drawn[1])
            else:
                self.Player.game.screen.blit(
                    self.Player.head_drawn[0],
                    self.off(self.Player.head_drawn[1]))
        self.ParticleManager.update()
        if self.Player.map_change:
            self.HUD.updateMapTrans()
        self.HUD.blitHUD()
Example #27
0
    print(f"Learning rate: {scope['learning_rate']}")


def save(step, scope):
    print("Export...")


def update_g(step, scope):
    print("Update G")


def update_d(step, scope):
    print("Update D")


def plot_training(step, scope):
    print("Plot")


batch = Schedule().first().do(batch_info)
batch.forNext(5).every(1).do(update_g)
batch.then().do(update_d)
training = Schedule()
training.every(1).do(lambda step, scope: batch.withScope(
    learning_rate=scope.get("learning_rate", 5 / (step + 5))))
training.every(10).do(save)
training.every(10).do(plot_training)
training.forNext(20)
training.then().do(training.withScope(learning_rate=0.1).forNext(20))
training.execute()
Example #28
0
def main():
    s = Schedule()
    s.go()
Example #29
0
def main():
    s = Schedule()
    s.run()
    app.run()
from scheduler import Schedule

line = (Schedule(length=10).every(1).do(lambda step, scope: print(
    ".", end="")).whileTrue(lambda step, scope: step < scope["length"]))
line.then().do(lambda step, scope: print())
line.withScope(length=10).execute()
triangle = Schedule().every(1).do(
    lambda step, scope: line.withScope(length=step))
triangle.first().do(line)
triangle.forNext(20).execute()
triangle.then().do(line)
Schedule(h=10).every(1).do(line).until(
    lambda step, scope: step == scope["h"]).execute()
Example #31
0
    def __init__(self):
        """
        Main game class initialization. All other class references point to this class as "game"
        """
        # window setup
        pygame.display.set_caption('Necromonster')
        pygame.display.set_icon(pygame.image.load(os.path.join('rec', 'misc', 'icon.png')))
        self.main_path = os.getcwd()

        # initiate the clock and screen object
        self.clock = pygame.time.Clock()
        self.FPS = 50
        self.last_tick = pygame.time.get_ticks()
        self.screen_res = [900, 650]
        self.center_point = [470, 350]
        self.screen = pygame.display.set_mode(self.screen_res, pygame.HWSURFACE, 32)

        #DEBUG values
        self.DEBUG = 1
        self.RECT_DEBUG = 0
        self.angle = 0

        #Init and assign custom game class(es)
        self.EntityHandler = EntityHandler(self)
        self.ParticleManager = ParticleManager(self)
        self.Scheduler = Schedule(self)
        self.Entity = Entity
        self.Projectile = Projectile
        self.Monster = Monster
        self.NPC = NPC
        self.NPCText = NPCText
        self.Item = Item
        self.Inventory = Invent
        self.Invent = self.Inventory(self)
        self.Weapon = Weapon
        self.Garment = Garment
        self.Player = Player(self)
        self.HUD = HUD(self)

        # Init entity manager vars
        self.entities = []
        self.shadows = []

        # load fonts, create font list
        # do not use pygame.font.SysFont!
        self.text_list = []
        self.default_font = pygame.font.Font(os.path.join('rec', 'font', 'freesansbold.ttf'), 15)
        self.speak_font = pygame.font.Font(os.path.join('rec', 'font', 'freesansbold.ttf'), 30)

        # load the map that player is on
        self.INSIDE = 0
        self.blit_list = mapLoader.load('home', self)

        # spawn initial map items/entities
        self.Item(self, 'Mythril', [350, 400], world=1)
        self.NPC(self, "blacksmith", [400, 400], 100, 'still')
        for i in xrange(4):
            self.Monster(self, 'chicken', [200+(i*50),650], 1, 'neutral')
        self.Monster(self, "goop", [100, 100], 1, 'aggressive')

        # begin main game loop
        while 1:
            self.Loop()