コード例 #1
0
def enter():
    hide_cursor()
    global background, cursor, x, y, isCollide, isBattle, rooms, font, start, play_turn, font_size_30
    isCollide = False
    isBattle = False
    play_turn = battle_state.turn
    background = Background()
    cursor = Cursor()
    font = load_font('font\\gothic.ttf', 20)
    font_size_30 = load_font('font\\gothic.ttf', 30)
    cursor.x, cursor.y = x, y
    rooms = [Room() for i in range(7)]
    for i in range(0, 7):
        rooms[i].num = i
        rooms[i].x, rooms[i].y = room_location_table[i][
            0], room_location_table[i][1]
    if not start:
        create_room(1, 7)
    else:
        rooms = battle_state.rooms
        if rooms[i].boss:
            del rooms
            rooms = [Room() for i in range(7)]
            for i in range(0, 7):
                rooms[i].num = i
                rooms[i].x, rooms[i].y = room_location_table[i][
                    0], room_location_table[i][1]
            create_room(1, 7)
コード例 #2
0
ファイル: file.py プロジェクト: ChopChopKodi/pelisalacarta
class File(object):
    def __init__(self, path, base, index, size, fmap, piece_size, client):
        self._client = client
        self.path=path
        self.base=base
        self.index=index
        self.size=size

        self.piece_size=piece_size

        self.full_path= os.path.join(base,path)
        self.first_piece=fmap.piece
        self.offset=fmap.start
        self.last_piece=self.first_piece + max((size-1+fmap.start),0) // piece_size

        self.cursor = None

    def create_cursor(self, offset=None):
        self.cursor = Cursor(self)
        if offset:
            self.cursor.seek(offset)
        return self.cursor

    def map_piece(self, ofs):
        return self.first_piece+ (ofs+self.offset) // self.piece_size , (ofs+self.offset) % self.piece_size

    def update_piece(self, n, data):
        if self.cursor:
            self.cursor.update_piece(n,data)

    def __str__(self):
        return self.path
コード例 #3
0
    def select_all_rows(self, table):
        cursor = Cursor(table)
        leaf_node = Leaf_Node(table.get_page(cursor.page_num))

        while cursor.end_of_table == False:
            leaf_node.get_row(cursor.cell_num).print()
            cursor.advance(leaf_node.num_cells)
コード例 #4
0
    def __refresh_new_target(self, resp):
        warning("Refresh Checking")
        Parser.get_next_target
        next_path = Parser.get_next_target(resp)
        self.__sid = Parser.get_sid(resp, self.__sid)

        if next_path:
            parse_res = urlparse(next_path)
            domain = parse_res.netloc
            query = parse_res.query
            if domain and self.__domain != domain:
                self.__domain = domain
                info(f"Find New Domain: {self.__domain}")
                Cursor.create_new_domain(self.__domain)
                return self.session.get(self.__main_url)

            if query:
                query = dict((item.split("=") for item in query.split("&")))
                if "autim" in query:
                    self.__autim = int(query["autim"])
                    info(f"autim: {self.__autim}")

            self.__make_links()
            next_url = urljoin(resp.url, next_path)
            warning(f"Refresh To: {next_url}")
            return self.__refresh_new_target(self.session.get(next_url))
        return resp
コード例 #5
0
    def __login(self):
        try:
            """
                ### 再次尝试
                1.因为网络问题重试

                ### 重新注册
                2.因为账户被封重试
                3.因为账户认证错误重试
            """
            warning(f"Login -> [{self.usr}:{self.pwd}]")
            self.__login_payload.update({
                "password": self.pwd,
                "username": self.usr
            })
            resp = self.__refresh_new_target(
                self.session.post(
                    self.__login_url,
                    data=self.__login_payload,
                    verify=False,
                    timeout=120,
                ))
            if self.usr in resp.text and "暗网欢迎您" in resp.text:
                success("Auth Success")
                self.types = Parser.get_current_type(resp)
                # assert self.types != {}
            else:
                error(f"Auth Faild: {self.__clean_log(resp)}")
                self.__save_error("__login.html", resp)
                if "已被封禁" in resp.text:
                    Cursor.ban_user(self.usr)
                    self.__reg()
                raise ValueError
        except KeyboardInterrupt:
            exit()
コード例 #6
0
class Document:
    """Represents document"""
    def __init__(self):
        """Initializes variables"""
        self.characters = []
        self.cursor = Cursor(self)
        self.filename = ''

    def insert(self, character):
        """Insert character on cursor's position 
        (limitations described in document_test.py)"""
        if not hasattr(character, 'character'):
            character = Character(character)
        self.characters.insert(self.cursor.position, character)
        self.cursor.forward()

    def delete(self):
        """Delete character on cursor's position 
        (limitations described in document_test.py)"""
        del self.characters[self.cursor.position]

    def save(self):
        """Save file
        but we should input filename in __init__()"""
        f = open(self.filename, 'w')
        f.write(''.join(self.characters))
        f.close()

    @property
    def string(self):
        "Returns string of characters"
        return ''.join((str(c) for c in self.characters))
コード例 #7
0
ファイル: processor.py プロジェクト: pangbo-1988/data_diff
 def process(self):
     # load data
     data = self.load()
     # index to elastic search
     print "\nStart processing"
     cursor = Cursor(self.es, self.data_from)
     cursor_num = cursor.get_new_cursor()
     for each_data in data:
         key_string = ''
         for each_key_string in key_value:
             key_string += each_data[each_key_string]
         hashkey = mmh3.hash(key_string)
         print "parsing id: ", hashkey
         # try to read record
         try:
             res = self.es.get(   index="deltadb", 
                             doc_type="data", 
                             id=hashkey)
             if res["found"]:
                 node = self.update_node(res["_source"], each_data, cursor_num)
             else:
                 node = self.create_node(each_data, cursor_num)
         except:
             node = self.create_node(each_data, cursor_num)
         # insert back to es
         try:
             res = self.es.index(index="deltadb", 
                                 doc_type="data", 
                                 id=hashkey, 
                                 body=node)
         except:
             continue
     print "\nProcess finish."
コード例 #8
0
ファイル: file.py プロジェクト: Reunion90/raiz
class File(object):
    def __init__(self, path, base, index, size, fmap, piece_size, client):
        self._client = client
        self.path = path
        self.base = base
        self.index = index
        self.size = size

        self.piece_size = piece_size

        self.full_path = os.path.join(base, path)
        self.first_piece = fmap.piece
        self.offset = fmap.start
        self.last_piece = self.first_piece + max(
            (size - 1 + fmap.start), 0) // piece_size

        self.cursor = None

    def create_cursor(self, offset=None):
        self.cursor = Cursor(self)
        if offset:
            self.cursor.seek(offset)
        return self.cursor

    def map_piece(self, ofs):
        return self.first_piece + (ofs + self.offset) // self.piece_size, (
            ofs + self.offset) % self.piece_size

    def update_piece(self, n, data):
        if self.cursor:
            self.cursor.update_piece(n, data)

    def __str__(self):
        return self.path
コード例 #9
0
 def register(self):
     try:
         warning("register confirm")
         resp = self.refresh_new_target(
             self.session.get(
                 self.register_url,
                 headers={
                     "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3",
                     "Content-Type": "application/x-www-form-urlencoded",
                     "Referer": self.register_url,
                 },
             )
         )
         token, creation_time = Parser.get_token_and_creation_time(resp)
         warning("start register")
         resp = self.session.post(
             self.register_url,
             data={
                 "agreed": "===好的,我已明白,请跳转到下一页继续注册====",
                 "autim": self.autim,
                 "change_lang": "",
                 "creation_time": creation_time,
                 "form_token": token,
             },
             headers=self.make_reg_headers(resp),
         )
         token, creation_time = Parser.get_token_and_creation_time(resp)
         confirm_code, confirm_id = Parser.get_captcha(self.get_pic, resp)
         self.create_random_author()
         data = {
             "username": self.usr,
             "new_password": self.pwd,
             "password_confirm": self.pwd,
             "email": "*****@*****.**",
             "lang": "zh_cmn_hans",
             "tz_date": "UTC+08:00 - Antarctica/Casey - "
             + moment.now().format("YYYY-MM-DD HH:mm"),
             "tz": "Asia/Hong_Kong",
             "agreed": "true",
             "change_lang": "0",
             "confirm_code": confirm_code,
             "confirm_id": [confirm_id, confirm_id],
             "creation_time": creation_time,
             "form_token": token,
             "submit": " 用户名与密码已填好, 点此提交 ",
             "autim": self.autim,
         }
         resp = self.session.post(
             self.register_url, data=data, headers=self.make_reg_headers(resp)
         )
         assert "感谢注册" in resp.text
         success("register success")
         Cursor.create_new_user({"user": self.usr, "pwd": self.pwd})
     except KeyboardInterrupt:
         exit()
     except AssertionError as e:
         error("register failed")
         error(self.clean_log(resp))
         raise e
コード例 #10
0
 def __init__(self):
     """
     inits a new instance of Document class with attributes characters,
     cursor and filename
     """
     self.characters = []
     self.cursor = Cursor(self)
     self.filename = ''
コード例 #11
0
    def __init__(self):
        self.__message_queue = []
        self.__cur_stat_surf = None
        self.__actors = []
        self.__items = []
        self.__gfx = None
        self.__quit_loop = False
        self.__last_id = 0
        self.__id_gen = self.__gen_id()
        self.__actors_on_screen = []
        self.__timer = 0
        self.__world_time = 0
        self.__load_fonts()
        self.__build_surf_cache()
        self.__set_game_instance()
        self.__player_actions = PlayerActions(self)
        self.__state_worker = StateWorker(self)

        self.__actor_grid = []
        self.__item_grid = []
        for y in xrange(200):
            aline = []
            iline = []
            for x in xrange(200):
                aline.append([])
                iline.append([])
            self.__actor_grid.append(aline)
            self.__item_grid.append(iline)

        self.map = None
        self.dungeon = dungeon.DungeonsOfGogadan()
        self.quit_mes = QUIT

        self.stats = [
            att.Att('Strength', 'Important for Melee-Fighter', 20),
            att.Att('Endurance', 'Important for Melee-Fighter'),
            att.Att('Mind', 'Important for Spellcaster'),
            att.Att('Health', 'How much can you take?', 45)
        ]

        self.camera = Camera(20, 26)
        self.state = S_RUN
        self.__await_target = None

        Debug.init_debug(self)
        Debug.debug('init pygame')

        pygame.init()
        self.screen = pygame.display.set_mode((1024, 768))
        self.__clock = pygame.time.Clock()
        self.item_to_throw = None
        self.cursor = Cursor(self)
        self._items_to_choose = {}
        self._symbols = []
        c = 'abcdefghijklmonpqrstuvwxyz'
        for s in c:
            self._symbols.append(s)
コード例 #12
0
ファイル: main.py プロジェクト: digilist/BaconBulb
 def __init__(self):
     self._window = sf.RenderWindow(
         sf.VideoMode(settings.windowWidth, settings.windowHeight),
         "BaconBulb")
     self._window.vertical_synchronization = True
     self._window.framerate_limit = 60
     self._window.mouse_cursor_visible = False
     self._cursor = Cursor(self._window)
     self._game_menu = GameMenu(self._window)
コード例 #13
0
ファイル: distance.py プロジェクト: bmayse/adventofcode
def build_until_square_satisfies_criteria(end, check, calculate):
    squares = SquareMap()
    cursor = Cursor(mode=Mode.build_x, x=0, y=0, max_degree=0)
    square: Square
    while cursor.id == 1 or not check(square, end):
        square = Square(id=cursor.id, x=cursor.x, y=cursor.y, data=calculate(squares, cursor.x, cursor.y))
        squares.add(square)
        cursor.move_cursor()
    return squares
コード例 #14
0
ファイル: grammar.py プロジェクト: jake-miles/grammar-py
 def parse_non_empty(self, start, level):
     grammars = Cursor(self.grammars)
     result = False
     end = start
     while grammars.not_empty() and not result:
         (result, end) = grammars.head().parse(start, level + 1)
         if not result:
             grammars = grammars.tail()
     return (result, end)
コード例 #15
0
    def login(self):
        try:
            """
                ### 再次尝试
                1.因为网络问题重试

                ### 重新注册
                2.因为账户被封重试
                3.因为账户认证错误重试
            """
            warning(f"login -> [{self.usr}:{self.pwd}]")
            self.login_payload.update({
                "password": self.pwd,
                "username": self.usr
            })
            resp = self.session.post(
                self.login_url,
                data=self.login_payload,
                headers={
                    "Content-Type": "application/x-www-form-urlencoded",
                    "Referer": f"http://{self.domain}/ucp.php?mode=login",
                },
                allow_redirects=False,
            )
            debug(f"login[1] requests header: {resp.request.headers}")
            debug(f"login[1] response header: {resp.headers}")
            if resp.status_code == 302 and "Location" in resp.headers:
                resp = self.refresh_new_target(
                    self.session.get(
                        resp.headers.get("Location"),
                        headers={
                            "Referer":
                            f"http://{self.domain}/ucp.php?mode=login&sid={self.sid}",
                            "Cookie": self.get_cookie_string(),
                        },
                    ))
            else:
                Cursor.ban_user(self.usr)
                self.update_random_user()
                return
            debug(f"login[2] requests header: {resp.request.headers}")
            debug(f"login[2] response header: {resp.headers}")
            if self.usr in resp.text and "暗网欢迎您" in resp.text:
                success("Auth Success")
                self.types = Parser.get_current_type(resp)
            else:
                error(f"Auth Faild: {self.clean_log(resp)}")
                if re.findall("已被封禁|无效的|违规被处理", resp.text):
                    Cursor.ban_user(self.usr)
                    self.update_random_user()
                    # if not self.register():
                    #     return
                    # else:
                    #     raise ValueError
        except KeyboardInterrupt:
            exit()
コード例 #16
0
class Document:
    def __init__(self):
        """
        inits a new instance of Document class with attributes characters,
        cursor and filename
        """
        self.characters = []
        self.cursor = Cursor(self)
        self.filename = ''

    @property
    def string(self):
        """
        returns a string of styled chars
        """
        return "".join((str(c) for c in self.characters))

    """
c. збереження файлу без імені
d. введення декількох символів

    """

    def insert(self, character):
        """
        insters the character to the position, where the cursor is
        located now
        """
        if not hasattr(character, 'character'):
            character = Character(character)
        if len(character.character) > 1:
            raise NotChar
        self.characters.insert(self.cursor.position, character)
        self.cursor.forward()

    def delete(self):
        """
        deletes the character from the position, where the cursor is
        located now
        """
        try:
            del self.characters[self.cursor.position]
        except:
            raise CharacterDontExist

    def save(self):
        """
        saves the document to the file with its filename
        """
        if not self.filename:
            raise NoFilename
        f = open(self.filename, 'w')
        f.write(''.join(self.characters))
        f.close()
コード例 #17
0
 def __init__(self, opciones):
     self.fondo = pygame.image.load("imagen/fondo-menu.jpg").convert()
     self.fuente = pygame.font.Font('fuentes/ninja-turtles-regular.otf', 80)
     self.texto = self.fuente.render('TURTLE NINJA ', True, Color.VERDE)
     self.opciones = list()
     self.cursor = Cursor()
     self.seleccionado = 0
     self.total = len(opciones)
     self.mantiene_pulsado = False
     self.sonido_menu = pygame.mixer.Sound('audio/an_8_bit_story.ogg')
     self.sonido_menu.play(loops=-1)
     self.construir_opciones(opciones)
コード例 #18
0
ファイル: editor.py プロジェクト: austinthresher/luna-proto
    def __init__(self, stdscr):
        # Set member values
        self.screen = stdscr
        self.height, self.width = self.screen.getmaxyx()
        self.file = text.TextFile("cursor.py")
        self.quit = False
        self.cursor = Cursor(self.file)
        self.status = ""

        # Set curses to non-blocking input
        self.screen.nodelay(True)
        self.screen.timeout(0)
コード例 #19
0
 def __init__(self, _engine):
     super(Scene, self).__init__()
     self._ais = []
     self._engine = _engine
     self._resx, self._resy = _engine.getResolution()
     self.surface = pygame.Surface((self._resx, self._resy))
     drawText(self.surface, "Wczytywanie mapy...", 48, (255, 255, 255),
              (self._resx / 2, self._resy / 2))
     self._map = Map(_engine)
     self._hub = Hub(_engine, self._map)
     self._cursor = Cursor(_engine, self._map)
     self._ais.append(AI(_engine, self._map, _engine.players[0], 0))
     self._ais.append(AI(_engine, self._map, _engine.players[1], 1))
コード例 #20
0
 def __init__(self, size=9):
     self.players = [Player('B', 300), Player('W', 300)]
     self.currentPlayer = 0
     self.board = Board(size)
     self.territories = Board(size)
     self.previousBoard = self.board.getMatrix()
     self.currentBoard = self.board.getMatrix()
     self.cursor = Cursor(self.board)
     self.attemptedPlace = False
     self.handler = EventHandler()
     self.UI = UIMatch(size, self.handler)
     self.newGame = False
     self.exit = False
コード例 #21
0
ファイル: client.py プロジェクト: thabaptiser/bdgame
def main(stdscr):
    cursor = Cursor(stdscr)
    url = utils.ip + "token/get"
    token = utils.request(url)['token']
    grid = Grid(stdscr, x_limit, y_limit, cursor)
 
    sel_bool = False
    sel_soldiers = []
    
    while True:
        key = stdscr.getch()

        # quit game
        if key == ord('q'):
            exit(stdscr)
    
        # create soldier
        elif key == ord('c'):
            create_soldier(token)
        
        # move cursor
        elif key in directions:
            cursor.move_cursor(key)
        
        # select tiles
        elif key == ord('s') and not sel_bool:
            cursor.select()
            key = 0
            sel_bool = True
            sel_soldiers = []

        # finish selecting
        elif key is ord('s') and sel_bool:
            cursor.deselect()
            x_r = sorted((cursor.select_coords[0], cursor.x))
            y_r = sorted((cursor.select_coords[1], cursor.y))
            debug_file.write(str(x_r) + "\n" + str(y_r) + "\n")
            for x in range(x_r[0], x_r[1]+1):
                for y in range(y_r[0], y_r[1]+1):
                    if (x,y) in grid.grid:
                        debug_file.write("inserting")
                        sel_soldiers.append(grid.grid[(x,y)])
            sel_bool = False
        if key is ord('q'):
            exit(stdscr)
    
        # move soldiers (soldiers must be selected first)
        elif key == ord('m'):
            key = 69
            debug_file.write(str(sel_soldiers))
            if sel_soldiers:
                debug_file.write("moving soldiers\n")   
                move_soldiers(cursor.position(), sel_soldiers)
                sel_bool = False
        elif key == ord('d'):
            raise Exception(grid.request())
        
        grid.debug(str(key))
        grid.update(key, sel_bool)
        grid.display()
コード例 #22
0
ファイル: reproductor.py プロジェクト: sebalogue/Hola-Musica
    def __init__(self, cancion=None):
        """
		Pre: Recibe una cancion (ubicacion de un archivo.plp).
		Post: incia un reproductor con la cancion recibida cargada. 
		Si no se recibe cancion, el reproductor inicia con una 
		cancion vacia.
		"""
        self.canales = 0
        self.tracks = []
        self.info_tracks = []
        self.cancion = ListaEnlazada()
        self.cursor = Cursor(self.cancion)
        if cancion:
            self.cargar(cancion)
コード例 #23
0
class TestCursorMovement(unittest.TestCase):
    @vals([Cursor.MoveLeft, Cursor.MoveRight, Cursor.MoveUp, Cursor.MoveDown])
    def test_MovementEmptyContent(self, cursorFunc):
        contents = [[]]
        expectedCursor = Cursor(0, 0)
        cursor = Cursor(0, 0)
        cursorFunc(cursor, contents)
        self.assertEqual(cursor, expectedCursor)

    def name_test(original_name, cursorFunc, expectedCursor):
        return '{0}_Cursor_{1}_{2}_{3}'.format(original_name,
                                               cursorFunc.__name__,
                                               str(expectedCursor.x),
                                               str(expectedCursor.y))

    @vals([(Cursor.MoveLeft, Cursor(0, 0)), (Cursor.MoveRight, Cursor(1, 0)),
           (Cursor.MoveUp, Cursor(0, 0)), (Cursor.MoveDown, Cursor(0, 0))],
          name=name_test)
    def test_MovementOneChar_StartLeft(self, cursorFunc, expectedCursor):
        contents = [['a']]
        cursor = Cursor(0, 0)
        cursorFunc(cursor, contents)
        self.assertEqual(cursor, expectedCursor)

    @vals([(Cursor.MoveLeft, Cursor(0, 0)), (Cursor.MoveRight, Cursor(1, 0)),
           (Cursor.MoveUp, Cursor(0, 0)), (Cursor.MoveDown, Cursor(0, 0))],
          name=name_test)
    def test_MovementOneChar_StartRight(self, cursorFunc, expectedCursor):
        contents = [['a']]
        cursor = Cursor(1, 0)
        cursorFunc(cursor, contents)
        self.assertEqual(cursor, expectedCursor)
コード例 #24
0
ファイル: order66.py プロジェクト: mpostaire/deathstick
    def __init__(self, name):
        super(Game, self).__init__()

        self.name = name

        self.keys_pressed = set()

        self.projectiles = list()

        self.background = Sprite(
            image=get_background_path()
        )
        # à cacher
        global BACKGROUND_RECT
        BACKGROUND_RECT = self.background.get_rect()
        offset = BACKGROUND_RECT.width/2, BACKGROUND_RECT.height/2
        load_wall_array()

        global SPAWN
        self.cursor = Cursor(SPAWN)
        ##

        self.background.position = offset

        spawn_delayed([self], [self.cursor])
        self.add(self.background)

        self.adstop = AdStop(self.cursor)
        self.add(self.adstop)

        self.bullettime = BulletTime(self.cursor)
        self.add(self.bullettime)

        self.add(self.cursor)


        # adding stuff to the collision world
        global COL_MGR
        COL_MGR = cocos.collision_model.CollisionManagerGrid(
            BACKGROUND_RECT.x + BACKGROUND_RECT.width/2,
            BACKGROUND_RECT.x + 3*BACKGROUND_RECT.width/2,
            BACKGROUND_RECT.y + BACKGROUND_RECT.height/2,
            BACKGROUND_RECT.y + 3*BACKGROUND_RECT.height / 2,
            16,
            16
        )

        # self.debug()
        self.schedule(self.update)
コード例 #25
0
    def __login(self):
        try:
            """
                ### 再次尝试
                1.因为网络问题重试

                ### 重新注册
                2.因为账户被封重试
                3.因为账户认证错误重试
            """
            warning(f"Login -> [{self.usr}:{self.pwd}]")
            self.__login_payload.update({"password": self.pwd, "username": self.usr})
            resp = self.__refresh_new_target(
                self.session.post(
                    self.__login_url,
                    data=self.__login_payload,
                    verify=False,
                    timeout=120,
                    # headers={
                    #     "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3",
                    #     "Accept-Encoding": "gzip, deflate",
                    #     "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
                    #     "Cache-Control": "no-cache",
                    #     "DNT": "1",
                    #     "Host": self.__domain,
                    #     "Pragma": "no-cache",
                    #     "Origin":self.__main_url,
                    #     "Referer": f"{self.__main_url}/ucp.php?mode=login&autim={self.__login_payload['autim']}",
                    #     "Upgrade-Insecure-Requests": "1",
                    #     "User-Agent": "Mozilla/5.0 (Windows NT 6.1; rv:60.0) Gecko/20100101 Firefox/60.0"
                    # }
                )
            )
            debug(resp.history)
            debug(resp.request.headers)
            if self.usr in resp.text and "暗网欢迎您" in resp.text:
                success("Auth Success")
                self.types = Parser.get_current_type(resp)
                # assert self.types != {}
            else:
                error(f"Auth Faild: {self.__clean_log(resp)}")
                self.__save_error("__login.html", resp)
                if "已被封禁" in resp.text:
                    Cursor.ban_user(self.usr)
                    self.__reg()
                raise ValueError
        except KeyboardInterrupt:
            exit()
コード例 #26
0
ファイル: main.py プロジェクト: digilist/BaconBulb
 def __init__(self):
     self._window = sf.RenderWindow(sf.VideoMode(settings.windowWidth, settings.windowHeight), "BaconBulb")
     self._window.vertical_synchronization = True
     self._window.framerate_limit = 60
     self._window.mouse_cursor_visible = False
     self._cursor = Cursor(self._window)
     self._game_menu = GameMenu(self._window)
コード例 #27
0
ファイル: kassia.py プロジェクト: ilizol/kassia
    def draw_troparion(self, neumes_list: List[Neume],
                       lyrics_list: List[Lyric], dropcap: Dropcap):
        """Draws a troparion with the passed text attributes.
        :param neumes_list: A list of neumes.
        :param lyrics_list: A list of Lyrics.
        :param dropcap: A dropcap object.
        """
        dropcap_offset = 0

        # Pop off first letter of lyrics, since it will be drawn as a dropcap
        if dropcap and len(lyrics_list) > 0:
            lyrics_list[0].text = lyrics_list[0].text[1:]
            lyrics_list[0].recalc_width()
            dropcap_offset = dropcap.width + dropcap.x_padding

        if neumes_list:
            neume_chunks = self.make_neume_chunks(neumes_list)
            glyph_line: List[Glyph] = self.make_glyph_list(
                neume_chunks, lyrics_list)
            lines_list: List[GlyphLine] = self.line_break(
                glyph_line, Cursor(dropcap_offset, 0), self.doc.width,
                self.styleSheet['Neumes'].leading,
                self.styleSheet['Neumes'].wordSpace)
            if len(lines_list
                   ) > 1 or self.styleSheet['Neumes'].alignment is TA_JUSTIFY:
                lines_list: List[GlyphLine] = self.line_justify(
                    lines_list, self.doc.width, dropcap_offset)

            tropar = Troparion(lines_list, dropcap, self.doc.width)
            self.story.append(tropar)
コード例 #28
0
 def __init__(self, screen, camera, organizer, controllernr, lastState):
     self.camera = camera
     self.screen = screen
     self.lastState = lastState
     self.backToLastState = False
     self.backToCalibration = False
     self.organizer = organizer
     self.firstCheck = False
     self.cursor = Cursor(0, 0, 20, self.organizer)
     self.upperLeftButton = CursorRecognition("1", 20, [50, 50, 200, 200],
                                              self.organizer)
     self.upperRightButton = CursorRecognition("2", 20,
                                               [1850 - 250, 50, 200, 200],
                                               self.organizer)
     self.lowerRightButton = CursorRecognition(
         "3", 20, [1850 - 250, 1080 - 250, 200, 200], self.organizer)
     self.lowerLeftButton = CursorRecognition(
         "4", 20, [50, 1080 - 250, 200, 200],
         self.organizer)  # I hate hardcoding, resolution is 1850,1080
     self.controllernr = controllernr
     self.objectCoordinates, self.cameraImage = OR.getCoords(
         self.camera, 0)  # Get the coordinates for controller '0'
     self.allowedTime = 15  # Time to complete the calibration
     self.startTime = time.time(
     )  # Starttime when the program gets initialized
     self.elapsedTime = time.time()  # gets updated every loop
     self.timer = self.elapsedTime - self.startTime  # Time left
コード例 #29
0
    def cursor(self,
               query=None,
               order_by=None,
               reply=None,
               page_size=18,
               **filters):
        """Query resource objects.

        :param query:
            full text search query string in Xapian format
        :param order_by:
            name of property to sort by; might be prefixed by either `+` or `-`
            to change order's direction
        :param reply:
            list of property names to return for found objects;
            by default, only GUIDs will be returned; for missed properties,
            will be sent additional requests to a server on getting access
            to particular object.
        :param page_size:
            number of items in one cached page, there are might be several
            (at least two) pages
        :param filters:
            a dictionary of properties to filter resulting list

        """
        from cursor import Cursor
        return Cursor(self.mountpoint, self.document, query, order_by, reply,
                      page_size, **filters)
コード例 #30
0
ファイル: cursor_test.py プロジェクト: jake-miles/grammar-py
    def test_traversal(self):
        items = []

        cursor = Cursor([1, 2, 3])
        items.append(cursor.head())

        tail1 = cursor.tail()
        items.append(tail1.head())

        tail2 = tail1.tail()
        items.append(tail2.head())

        tail3 = tail2.tail()

        self.assertEqual(items, [1, 2, 3])
        self.assertTrue(tail3.empty())
コード例 #31
0
ファイル: text.py プロジェクト: jaredwindover/TextEditor
def main():
    file = sys.argv[1]
    contents = [[y for y in x] for x in open(file).read().split('\n')]
    cursor = Cursor()

    done = False
    draw(contents, cursor)
    while not done:
        if msvcrt.kbhit():
            a = msvcrt.getch()
            b = b'\x00'
            if a == b'\x00' or a == b'\xe0':
                b = msvcrt.getch()
            if a == b'\x11':
                done = True
            if a == b'\xe0':
                {
                    Keys.LeftArrow: cursor.MoveLeft,
                    Keys.RightArrow: cursor.MoveRight,
                    Keys.UpArrow: cursor.MoveUp,
                    Keys.DownArrow: cursor.MoveDown
                }[b](contents)
            print("Last Key: {},{}".format(a, b))
            print("Cursor: {}".format(cursor))
            print('_________________________')
            draw(contents, cursor)
        time.sleep(0.01)
コード例 #32
0
 def __init__(self, organizer, screenSize, camera, clock, fps):
     self.organizer = organizer
     self.screenSize = screenSize
     self.width = screenSize[0]
     self.height = screenSize[1]
     self.closePlatform = False  #The main while loop looks if this is true or false to break out of the while loop
     self.clock = clock
     self.fps = fps
     self.cursor = Cursor(
         0, 0, 20, self.organizer
     )  # Initialize a cursor in coord (0,0) with radius 20
     self.pongButton = CursorRecognition(
         "Pong", 30, [100, 200, 200, 200], self.organizer
     )  # Make a button for the areaSurveillance with left corner coords (100,200) & length/width = 200
     self.spaceInvadersButton = CursorRecognition("Space Invaders", 30,
                                                  [500, 200, 400, 200],
                                                  self.organizer)
     self.calibrationButton = CursorRecognition(" Calibrate", 30,
                                                [1000, 200, 300, 200],
                                                self.organizer)
     self.closeButton = CursorRecognition("CLOSE", 30, [1500, 50, 200, 150],
                                          self.organizer)
     self.camera = camera
     OR.calibrate(self.screenSize, self.camera,
                  0)  # Initialize the color for controller '0'
     organizer.state = "calibrationTest"
     self.objectCoordinates, self.cameraImage = OR.getCoords(
         self.camera, 0)  # Get the coordinates for controller '0'
     self.controllernr = 0
コード例 #33
0
ファイル: program.py プロジェクト: damasko/a_star
    def __init__(self):

        self.tablero = Tablero(80, 80)

        self.screen = pygame.display.set_mode((len(self.tablero.matrix[0]) * 10,
                    len(self.tablero.matrix) * 10 + 32), pygame.DOUBLEBUF)

        pygame.display.set_caption("Pathfinder")

        self.clock = pygame.time.Clock()

        self.pausa = True
        self.velocidad = 100
        self.velocidad_algoritmo = 8

        # a star
        self.pathfinder = PathFinder(self.tablero)

        # cursor
        self.cursor = Cursor(self.tablero, self.pathfinder)

        #fuente
        pygame.font.init()
        self.fuente = pygame.font.SysFont("default", 24)
        self.texto = self.fuente.render("Pausado", True, (255, 0, 255))
        self.texto_algo = self.fuente.render("Velocidad: " + str(self.velocidad_algoritmo),
                                True, (255, 0, 255))
コード例 #34
0
def enter():
    global boss_exist, middle_boss_exist
    boss_exist = 0
    middle_boss_exist = 0
    global boss_gauge
    boss_gauge = 0
    global hero
    global cursor
    global boss
    global boss_right_arm
    global boss_left_arm
    global enemy_genarate
    global middle_boss

    map = Map()
    cursor = Cursor()
    boss = Boss()
    boss_right_arm = Boss_right_arm()
    boss_left_arm = Boss_left_arm()
    middle_boss = Middle_boss()
    hero = Hero()

    hide_cursor()
    game_world.add_object(map, 0)

    enemy_genarate = Enemy_genarate()
    game_world.add_object(hero, 1)
    game_world.add_object(cursor, 4)

    game_world.add_object(enemy_genarate, 0)
コード例 #35
0
class OverworldUI(ui.TacticsUI):
    def __init__(self, *args, **kwargs):
        super(OverworldUI, self).__init__(*args, **kwargs)
        self.size = SCREEN_SIZE

        self.board = Board((20, 20, 30), (40, 20, 10), self.size)
        player = Unit("trainee")
        self.cursor = Cursor(player)
        self.board.set_unit(0, 0, player)
        self.board.redraw()

        self.board.set_display_position(*self.cursor.board_pos)
        self.keys = set()

    def redraw(self):
        pass

    def reblit(self, screen):
        self.board.reblit(screen)

    def keydown(self, event):
        if self.cursor.handle_key(event.key, self.board):
            self.board.set_display_position(*self.cursor.board_pos)
            self.board.redraw()
            self.keys.add(event.key)

    def keyup(self, event):
        self.keys.discard(event.key)

    def keep_moving(self):
        if self.cursor.keep_moving():
            self.board.set_display_position(*self.cursor.board_pos)
        elif self.cursor.unit.tile is None:
            self.board.set_unit(*self.cursor.set_unit_here())
            self.board.redraw()
            try:
                e = self.keys.pop()
                self.keys.add(e)
                x = Stupid()
                x.key = e
                self.keydown(x)
            except KeyError:
                print "no key"

    @staticmethod
    def name():
        return "overworld"
コード例 #36
0
 def __init__(self, screen):
     self.clock = pygame.time.Clock()
     self.screen = screen
     self.buffer = pygame.Surface(self.screen.get_size())
     self.font = pygame.font.Font(FONT, FONT_SIZE)
     self.menu_items = ['Items','Equip','Magic','Status','Save','Close','Quit']
     self.menu_image = pygame.image.load(IMAGES_DIR+'menu.png').convert_alpha()
     self.cursor = Cursor(ypos=[5,30,55,80,105,130,155])
コード例 #37
0
    def open_status(self):
        menu = True
        statuscursor = Cursor(ypos=[25, 85, 145, 205], xpos=[0])
        while menu:
            for event in pygame.event.get():
                if event.type == KEYDOWN:
                    if event.key == K_ESCAPE:
                        menu = False
                    if event.key == K_DOWN:
                        statuscursor.move_down()
                    if event.key == K_UP:
                        statuscursor.move_up()
                    if event.key == K_RETURN:
                        if statuscursor.position.y == 25:
                            self.status(self.team[0])
                        if statuscursor.position.y == 85:
                            self.status(self.team[1])
                        if statuscursor.position.y == 145:
                            self.status(self.team[2])
                        if statuscursor.position.y == 205:
                            self.status(self.team[3])

            self.buffer.blit(self.menu_image, (0,0))
            self.render_menu()
            statuscursor.update()
            self.buffer.blit(statuscursor.image, statuscursor.position)
            pygame.transform.scale(self.buffer, self.screen.get_size(), self.screen)
            pygame.display.flip()
            self.clock.tick(60)
コード例 #38
0
ファイル: battle_ui.py プロジェクト: orez-/Orez-Summer-2012
    def __init__(self, *args, **kwargs):
        super(BattleUI, self).__init__(*args, **kwargs)
        self.size = SCREEN_SIZE

        self.cursor = Cursor()
        self.board = Board((20, 20, 30), (40, 20, 10), self.size)
        # TODO: not a fan of the magic numbers

        self.board.set_display_position(*self.cursor.board_pos)
コード例 #39
0
ファイル: battle_ui.py プロジェクト: orez-/Orez-Summer-2012
class BattleUI(ui.TacticsUI):
    def __init__(self, *args, **kwargs):
        super(BattleUI, self).__init__(*args, **kwargs)
        self.size = SCREEN_SIZE

        self.cursor = Cursor()
        self.board = Board((20, 20, 30), (40, 20, 10), self.size)
        # TODO: not a fan of the magic numbers

        self.board.set_display_position(*self.cursor.board_pos)

    def redraw(self):
        pass

    def reblit(self, screen):
        self.board.reblit(screen)
        self.cursor.reblit(screen)

    def keydown(self, event):
        if self.cursor.handle_key(event.key, self.board):
            self.board.set_display_position(*self.cursor.board_pos)

    def k_UP(self):
        if self.cursor.k_UP(self.board):
            self.board.set_display_position(*self.cursor.board_pos)

    def k_DOWN(self):
        if self.cursor.k_DOWN(self.board):
            self.board.set_display_position(*self.cursor.board_pos)

    def k_LEFT(self):
        if self.cursor.k_LEFT(self.board):
            self.board.set_display_position(*self.cursor.board_pos)

    def k_RIGHT(self):
        if self.cursor.k_RIGHT(self.board):
            self.board.set_display_position(*self.cursor.board_pos)

    def k_CANCEL(self):
        pass

    def k_OK(self):
        pass

    def k_PAUSE(self):
        self.main.push_ui("team")

    def keep_moving(self):
        if self.cursor.keep_moving():
            self.board.set_display_position(*self.cursor.board_pos)

    @staticmethod
    def name():
        return "battle"
コード例 #40
0
    def __init__(self):
        self.__message_queue = []
        self.__cur_stat_surf = None
        self.__actors = []
        self.__items = []
        self.__gfx = None
        self.__quit_loop = False
        self.__last_id = 0
        self.__id_gen = self.__gen_id()
        self.__actors_on_screen = []
        self.__timer = 0
        self.__world_time = 0
        self.__load_fonts()
        self.__build_surf_cache()
        self.__set_game_instance()
        self.__player_actions = PlayerActions(self)
        self.__state_worker = StateWorker(self)

        self.__actor_grid = []
        self.__item_grid = []
        for y in xrange(200):
            aline = []
            iline = []
            for x in xrange(200):
                aline.append([])
                iline.append([])
            self.__actor_grid.append(aline)
            self.__item_grid.append(iline)
                    
        self.map = None
        self.dungeon = dungeon.DungeonsOfGogadan()
        self.quit_mes = QUIT
        
        self.stats = [att.Att('Strength', 'Important for Melee-Fighter', 20),
                      att.Att('Endurance', 'Important for Melee-Fighter'),
                      att.Att('Mind', 'Important for Spellcaster'),
                      att.Att('Health', 'How much can you take?', 45)]
        
        self.camera = Camera(20, 26)
        self.state = S_RUN
        self.__await_target = None
        
        Debug.init_debug(self)
        Debug.debug('init pygame')

        pygame.init()
        self.screen = pygame.display.set_mode((1024, 768))
        self.__clock = pygame.time.Clock()
        self.item_to_throw = None
        self.cursor = Cursor(self)
        self._items_to_choose = {}
        self._symbols = []
        c = 'abcdefghijklmonpqrstuvwxyz'
        for s in c:
            self._symbols.append(s)
コード例 #41
0
    def __init__(self, *args, **kwargs):
        super(OverworldUI, self).__init__(*args, **kwargs)
        self.size = SCREEN_SIZE

        self.board = Board((20, 20, 30), (40, 20, 10), self.size)
        player = Unit("trainee")
        self.cursor = Cursor(player)
        self.board.set_unit(0, 0, player)
        self.board.redraw()

        self.board.set_display_position(*self.cursor.board_pos)
        self.keys = set()
コード例 #42
0
ファイル: scene.py プロジェクト: Neverous/ii-python11
	def __init__(self, _engine):
		super(Scene, self).__init__()
		self._ais = []
		self._engine = _engine
		self._resx, self._resy = _engine.getResolution()
		self.surface = pygame.Surface((self._resx, self._resy))
		drawText(self.surface, "Wczytywanie mapy...", 48, (255, 255, 255), (self._resx / 2, self._resy / 2))
		self._map = Map(_engine)
		self._hub = Hub(_engine, self._map)
		self._cursor = Cursor(_engine, self._map)
		self._ais.append(AI(_engine, self._map, _engine.players[0], 0))
		self._ais.append(AI(_engine, self._map, _engine.players[1], 1))
コード例 #43
0
ファイル: main.py プロジェクト: digilist/BaconBulb
class Startup():

    def __init__(self):
        self._window = sf.RenderWindow(sf.VideoMode(settings.windowWidth, settings.windowHeight), "BaconBulb")
        self._window.vertical_synchronization = True
        self._window.framerate_limit = 60
        self._window.mouse_cursor_visible = False
        self._cursor = Cursor(self._window)
        self._game_menu = GameMenu(self._window)

    def run(self):
        settings.music.play()
        while self._window.is_open:
            self.loop()

    def loop(self):
        self._window.clear(sf.Color(50, 50, 50))
        self._cursor.setPosition(sf.Mouse.get_position(self._window))
        self._cursor.rotate(2)
        self._game_menu.dispatch()
        self._window.draw(self._cursor)
        self._window.display()
コード例 #44
0
ファイル: logger.py プロジェクト: 568/ThirdPlugin
    def __init__(self, debuggable=False, interval=0.1, unit="s"):
        self.debuggable = debuggable
        self.interval = interval
        self.unit = unit

        if not is_windows_system():
            from cursor import Cursor
            from terminal import Terminal
            self.cursor = Cursor(Terminal())

        self.sorted_tasks = []

        self.tpl_running_task = '[+][{}] {} in {}{}\n'
        self.tpl_waiting_task = '[+][{}] {}\n'
        self.tpl_finished_task = '[-][{}] {} in {}{}\n'
        # self.tpl_faied_task = '[-]{}:{} in {}{}\n'
        logging.basicConfig(level=logging.DEBUG)
コード例 #45
0
 def __init__(self,*args):
     super(ViewingWindow,self).__init__(*args)
     self.graph = BridgeConceptGraph()
     self.nodeSelected = SignalSlotObject()
     self.nodeUnselected = SignalSlotObject()
     self.cursor = Cursor()
     self.cursor.leftClick.connect(self.onLeftClick)
     self.cursor.leftHover.connect(self.onHover)
     self.cursor.leftDrag.connect(self.onLeftDrag)
     self.cursor.leftPress.connect(self.onLeftPress)
     self.cursor.leftRelease.connect(self.onLeftRelease)
     self.cursor.rightClick.connect(self.onRightClick)
     self.cursor.rightDrag.connect(self.onRightDrag)
     self.cursor.rightPress.connect(self.onRightPress)
     self.cursor.rightRelease.connect(self.onRightRelease)
     self.cursor.rightPull.connect(self.onRightPull)
     self.cursor.rightHover.connect(self.onHover)
     self.worldCursor = QPointF(0,0)
     self.leftClickB = False
     self.leftDragB = False
     self.HoverB = False
     self.leftPressB = False
     self.leftReleaseB = False
     self.rightClickB = False
     self.rightDragB = False
     self.rightPressB = False
     self.rightReleaseB = False
     self.rightPullB = False
     self.selectedNode = None
     self.heldNode = None
     self.hoverNode = None
     self.edgeDragNode = None
     self.fps = 30
     self.translation = QPointF(0.0,0.0)
     self.scale = 1.0
     self.minScale = 0.1
     self.maxScale = 10.0
     self.initUI()
コード例 #46
0
ファイル: file.py プロジェクト: ChopChopKodi/pelisalacarta
 def create_cursor(self, offset=None):
     self.cursor = Cursor(self)
     if offset:
         self.cursor.seek(offset)
     return self.cursor
コード例 #47
0
ファイル: graphcontext.py プロジェクト: ulethHCI/GLuskap
    def __init__(self, graph=None, camera=None, orthocamera=None, netcli=False):
        print "Calling graph context init"
        #
        # Cacheable: Keep track of observers
        #
        self.__dict__['observers'] = []
        if not config.current['global:highlight']:
            self.highLight = False
        else:
            self.highLight = True
        self.highLightNow = True
        self.ready = False

        if not graph:
            print "Making a graph object"
            self.graph = Graph(parent=self)
        else:
            self.graph = graph

        if netcli:
            self.UndoStack = undo.DummyStack(self)
            self.RedoStack = undo.DummyStack(self)
        else:
            self.UndoStack = undo.UndoStack(self)
            self.RedoStack = undo.RedoStack(self)

        self.graphgl = graphgl.GraphGL(self.graph)
        self.decor = interfacegl.InterfaceGL()

        if not camera:
            self.camera = Camera()
            self.camera.lookAt = (0.0, 0.0, 0.0)
        else:
            self.camera = camera

        if not orthocamera:
            self.orthocamera = OrthoCamera()
        else:
            self.orthocamera = orthocamera

        self.cursor = Cursor()

        self.path = None

        # This should default to False and turn on automatically
        # when you have a 3D input device.
        # XXX#
        self.showCursor = False

        # The drawList should be a dictionary of Drawables,
        # used by the InputManager to enable transient objects,
        # menus, etc to be drawn.
        self.drawList = {}

        self.orthoMode = None
        self.showAxes = config.current['default:show-axes']
        self.showLocalAxes = config.current['default:show-local-axes']
        self.showHUD = config.current['default:show-hud']
        self.showGrid = config.current['default:show-grid']
        self.showGridLines = config.current['default:show-grid-lines']
        self.showPlane = config.current['default:show-plane']
        self.planeColor = config.current['default:plane-color']
        self.bgColor = config.current['default:background-color']
        self.showVertexLabels = config.current['default:show-vertex-labels']
        self.showDummyLabels = config.current['default:show-dummy-labels']
        self.vertexLabelName = config.current['default:vertex-label-name']
        self.vertexLabelColor = config.current['default:vertex-label-color']
        self.vertexShadowColor = config.current['default:vertex-shadow-color']
        self.vertexLabelStroke = config.current['default:vertex-label-stroke']

        self.showGridPlane = "XZ"
        self.pos = (0.0, 0.0, 0.0)
        self.sizeX = 5
        self.sizeY = 5
        self.sizeZ = 5
        self.spacing = 2.0

        # The HUD status text line.
        self.HUDstatus = ''


        #If no highlight object exists, create one.
        if self.highLight:
            print "Creating highlight for active context"
            self.highLight = True
            from interfacegl import DrawObjectHighLight

            self.setDraw('wandaHighLight',
                         DrawObjectHighLight(
                             ctx=self,
                             tolerance=5.0,
                             restrict=None,
                         )
            )
コード例 #48
0
class ViewingWindow(QWidget):
    def __init__(self,*args):
        super(ViewingWindow,self).__init__(*args)
        self.graph = BridgeConceptGraph()
        self.nodeSelected = SignalSlotObject()
        self.nodeUnselected = SignalSlotObject()
        self.cursor = Cursor()
        self.cursor.leftClick.connect(self.onLeftClick)
        self.cursor.leftHover.connect(self.onHover)
        self.cursor.leftDrag.connect(self.onLeftDrag)
        self.cursor.leftPress.connect(self.onLeftPress)
        self.cursor.leftRelease.connect(self.onLeftRelease)
        self.cursor.rightClick.connect(self.onRightClick)
        self.cursor.rightDrag.connect(self.onRightDrag)
        self.cursor.rightPress.connect(self.onRightPress)
        self.cursor.rightRelease.connect(self.onRightRelease)
        self.cursor.rightPull.connect(self.onRightPull)
        self.cursor.rightHover.connect(self.onHover)
        self.worldCursor = QPointF(0,0)
        self.leftClickB = False
        self.leftDragB = False
        self.HoverB = False
        self.leftPressB = False
        self.leftReleaseB = False
        self.rightClickB = False
        self.rightDragB = False
        self.rightPressB = False
        self.rightReleaseB = False
        self.rightPullB = False
        self.selectedNode = None
        self.heldNode = None
        self.hoverNode = None
        self.edgeDragNode = None
        self.fps = 30
        self.translation = QPointF(0.0,0.0)
        self.scale = 1.0
        self.minScale = 0.1
        self.maxScale = 10.0
        self.initUI()

    def initUI(self):
        self.setAutoFillBackground(True)
        self.setMouseTracking(True)
        palette = QPalette()
        palette.setColor(QPalette.Window,QColor(0,100,0))
        self.setPalette(palette)

    def sizeHint(self):
        return QSize(800,500)

    def minimumSizeHint(self):
        return QSize(300,300)

    def paintEvent(self,event):
        qp = QPainter()
        qp.begin(self)
        qp.scale(self.scale,self.scale)
        qp.translate(self.translation)
        qp.setRenderHint(QPainter.Antialiasing)
        self.drawGraph(qp)
        self.drawUI(qp)
        qp.end()

    def wheelEvent(self,event):
        self.cursor.update(event,'o')
        d = float(event.delta())
        self.updateWorldCursor()
        p = self.worldCursor
        oldScale = self.scale
        oldTranslation = self.translation
        self.scale += d/360
        self.scale = min(self.maxScale,self.scale)
        self.scale = max(self.minScale,self.scale)
        self.translation=((self.translation+p)*(oldScale/self.scale))-p

    def drawUI(self,qp):
        pen = QPen()
        brush = QBrush(QColor(0,100,0,200))
        qp.setPen(pen)
        qp.setBrush(brush)
        p = self.worldCursor
        if self.edgeDragNode != None:
            qp.drawPath(
                getArrowPath(self.edgeDragNode.position,
                             p,
                             4,
                             40,
                             20,
                             pi/3,
                             0,
                             0
                         )
            )
        #qp.drawText(0,20,str(self.translation))
        #qp.drawText(0,50,str(self.cursor.x)+','+str(self.cursor.y))
        #qp.drawText(0,110,str(self.scale))
        #qp.drawEllipse(QPointF(0,0),10,10)
        #qp.drawEllipse(QPointF(0,100),10,10)
        #qp.drawEllipse(QPointF(100,100),10,10)
        #qp.drawEllipse(QPointF(100,0),10,10)
        #print self.scale

    def drawGraph(self, qp):
        for index, concept in self.graph.concepts.items():
            self.drawConceptToBridgeEdges(qp,
                                          concept,
                                          self.graph.ForwardEdges[index])
        for index, bridge in self.graph.bridges.items():
            self.drawBridgeToConceptEdges(qp,
                                          bridge,
                                          self.graph.ForwardEdges[index])
        for index in self.graph.concepts:
            self.drawConcept(qp,self.graph.concepts[index])
        for index in self.graph.bridges:
            self.drawBridge(qp,self.graph.bridges[index])

    def drawBridgeToConceptEdges(self,qp,bridge,edges):
        pen = QPen()
        brush = QBrush(QColor(100,0,0,200))
        qp.setPen(pen)
        qp.setBrush(brush)
        for e in edges:
            qp.drawPath(
                getArrowPath(bridge.position,
                             self.graph.concepts[e].position,10,65,30, pi/3,0,self.graph.concepts[e].radius))
            
    def drawConceptToBridgeEdges(self,qp,concept,edges):
        pen = QPen()
        brush = QBrush(QColor(0,0,100,200))
        qp.setPen(pen)
        qp.setBrush(brush)
        for e in edges:
            qp.drawPath(
                getArrowPath(concept.position,
                             self.graph.bridges[e].position,6,40,20, pi/3,0,self.graph.bridges[e].radius))
            
    def drawBridge(self,qp,bridge):
        self.drawNode(qp,bridge)
        pen = QPen(QColor(0,0,0))
        font = QFont()
        font.setPointSizeF(12.0/(self.scale**(3.0/4)))
        font.setItalic(True)
        font.setBold(True)
        qp.setPen(pen)
        qp.setFont(font)
        bTitle = bridge.title
        pos = bridge.position + QPointF(1,-1)*bridge.radius
        qp.drawText(pos,bTitle)
        
    def drawConcept(self,qp,concept):
        self.drawNode(qp,concept)
        pen = QPen(QColor(0,0,0))
        bgBrush = QBrush(QColor(255,255,255,20))
        font = QFont()
        font.setPointSizeF(12.0/(self.scale**(3.0/4)))
        font.setBold(True)
        qp.setPen(pen)
        qp.setFont(font)
        qp.setBackgroundMode(Qt.OpaqueMode)
        qp.setBackground(bgBrush)
        cTitle = concept.title
        pos = concept.position + QPointF(1,-1)*concept.radius
        qp.drawText(pos,cTitle)

    def drawNode(self,qp,node):
        ring = False
        ringRadius = 5
        if node.selected:
            pen = QPen(node.palette[2])
            brush = QBrush(node.palette[2])
        elif node.held:
            pen = QPen(node.palette[0])
            brush = QBrush(node.palette[0])
        elif node.hovered:
            pen = QPen(node.palette[1])
            brush = QBrush(node.palette[1])
        elif node.highlighted:
            ring = True
            pen = QPen(node.palette[3])
            brush = QBrush(node.palette[3])
        else:
            pen = QPen(node.palette[3])
            brush = QBrush(node.palette[3])
        qp.setPen(pen)
        qp.setBrush(brush)
        qp.drawEllipse(node.position,node.radius,node.radius)
        if ring:
            pen = QPen(node.palette[2])
            brush = QBrush()
            qp.setPen(pen)
            qp.setBrush(brush)
            qp.drawEllipse(node.position,\
                           node.radius + ringRadius,\
                           node.radius + ringRadius)
        

    def setGraph(self,graph):
        self.graph = graph
        
    def mousePressEvent(self,event):
        self.cursor.update(event,'p')
        
    def mouseReleaseEvent(self,event):
        self.cursor.update(event,'r')
        
    def mouseMoveEvent(self,event):
        self.cursor.update(event,'m')

    def onLeftClick(self):
        self.leftClickB = True

    def onLeftDrag(self):
        self.leftDragB = True
        
    def onHover(self):
        self.HoverB = True

    def onLeftPress(self):
        self.leftPressB = True

    def onLeftRelease(self):
        self.leftReleaseB = True

    def onRightClick(self):
        self.rightClickB = True

    def onRightDrag(self):
        self.rightDragB = True

    def onRightPress(self):
        self.rightPressB = True

    def onRightRelease(self):
        self.rightReleaseB = True

    def onRightPull(self):
        self.rightPullB = True

    def getClosestNode(self,pos):
        try:
            G = self.graph
            distances=[(node,norm(pos - node.position)) for node in G.Nodes()]
            r = reduce(ltIndex(1),distances)
            return r
        except:
            return (None,None)

    def updateWorldCursor(self):
        c = self.cursor
        s = QPointF(self.scale,self.scale)
        t = self.translation
        self.worldCursor = QPointF((c.x/s.x())-t.x(),(c.y/s.y())-t.y())
            
    def readCursorEvents(self):
        c = self.cursor
        self.cursor.resetPrevious = True
        s = QPointF(self.scale,self.scale)
        t = self.translation
        self.updateWorldCursor()
        pos = self.worldCursor
        prevPos = QPointF((c._px/s.x())-t.x(),(c._py/s.y())-t.y())
        (node,dist) = self.getClosestNode(pos)
        #Due to the ascynchronous design, it's necessary to order these
        #properly
        if (self.leftDragB):
            try:
                self.heldNode.position = pos
            except:
                self.translation += pos - prevPos
            self.leftDragB = False
            
        if (self.HoverB):
            if node == None: pass
            elif (dist < node.radius):
                self.unhover()
                self.hover(node)
            else:
                self.unhover()
            self.leftHoverB = False
            
        if (self.leftPressB):
            if node == None: pass
            elif (dist < node.radius):
                self.unhold()
                self.unhover()
                self.hold(node)
            self.leftPressB = False
            
        if (self.leftReleaseB):
            self.unhold()
            self.leftReleaseB = False
            
        if (self.leftClickB):
            if node == None: pass
            elif (dist < node.radius):
                self.unhover()
                self.unhold()
                if not self.selectedNode == node:
                    self.unselect()
                    self.select(node)
                else:
                    self.unselect()
            else:
                self.unselect()
            self.leftClickB = False

        if (self.rightClickB):
            if node == None: self.addConcept(pos)
            elif (dist < node.radius):
                self.deleteNode(node)
            else:
                self.addConcept(pos)
            self.rightClickB = False

        if (self.rightPullB):
            if node == None:
                pass
            elif dist < node.radius:
                self.edgeDragNode = node
            elif self.selectedNode != None:
                self.edgeDragNode = self.selectedNode
            else:
                pass
            self.rightPullB = False
                
        if (self.rightDragB):
            pass
            
        if (self.rightPressB):
            pass

        if (self.rightReleaseB):
            if self.edgeDragNode != None and self.edgeDragNode != node:
                if dist < node.radius:
                    if isinstance(self.edgeDragNode,Bridge):
                        if isinstance(node,Concept):
                            self.graph.ConnectBridgeToConcept(
                                self.edgeDragNode.key,
                                node.key)
                    elif isinstance(self.edgeDragNode,Concept):
                        if isinstance(node,Bridge):
                            self.graph.ConnectConceptToBridge(
                                self.edgeDragNode.key,
                                node.key)
                        elif isinstance(node,Concept):
                            k =self.addBridge((pos + self.edgeDragNode.position)/2)
                            self.graph.ConnectConceptToBridge(self.edgeDragNode.key,k)
                            self.graph.ConnectBridgeToConcept(k,node.key)
            self.edgeDragNode = None
            self.rightReleaseB = False

    def update(self):
        self.readCursorEvents()
        #print "Held Node: ",self.heldNode
        #print "Selected Node: ",self.selectedNode
        #print "Hovered Node: ",self.hoverNode
        self.repaint()

    def animate(self):
        t1 = clock()
        self.update()
        QTimer.singleShot(max(0,1000/self.fps-(clock()-t1)),self.animate)
            
    def select(self,node):
        self.selectedNode = node
        self.selectedNode.selected = True
        for pn in self.graph.ReverseEdges[node.key]:
            try:
                self.graph.bridges[pn].highlighted = True
            except:
                self.graph.concepts[pn].highlighted = True
        self.nodeSelected.emit()

    def unselect(self,node=None):
        if self.selectedNode == node or node == None:
            try:
                self.selectedNode.selected = False
                for pn in self.graph.ReverseEdges[self.selectedNode.key]:
                    try:
                        self.graph.bridges[pn].highlighted = False
                    except:
                        self.graph.concepts[pn].highlighted = False
                self.selectedNode = None
                self.nodeUnselected.emit()
            except:
                pass

    def hold(self, node):
        self.heldNode = node
        self.heldNode.held = True

    def unhold(self, node=None):
        if self.heldNode == node or node == None:
            try:
                self.heldNode.held = False
                self.heldNode = None
            except:
                pass
            
    def hover(self,node):
        self.hoverNode = node
        self.hoverNode.hovered = True

    def unhover(self, node=None):
        if self.hoverNode == node or node == None:
            try:
                self.hoverNode.hovered = False
                self.hoverNode = None
            except:
                pass

    def deleteNode(self,node):
        self.unselect(node)
        self.unhold(node)
        self.unhover(node)
        try:
            self.graph.RemoveBridge(node.key)
        except:
            self.graph.RemoveConcept(node.key)

    def addConcept(self,pos):
        C = Concept()
        C.position = pos
        k = self.graph.AddConcept(C)
        C.key = k
        return k

    def addBridge(self,pos):
        B = Bridge()
        B.position = pos
        k = self.graph.AddBridge(B)
        B.key = k
        return k

    def writeTo(self, filename):
        f = open(filename,'w')
        dump(self.graph,f)
        f.close()

    def readFrom(self,filename):
        f = open(str(filename),'r')
        self.graph = load(f)
        f.close()
コード例 #49
0
ファイル: graphcontext.py プロジェクト: ulethHCI/GLuskap
class GraphContext(pb.Cacheable):
    """
    GraphContext binds together the elements required to present a Graph
    in an OpenGL environment. It includes:
	- The graph
	- The primary camera
	- The orthogonal camera
	- Display settings:
	    - ortho vs. standard camera
	    - whether to show local axes
	    - whether to show ground plane
	    - whether to show HUD
	    - whether to show, and color of, ground plane
	    - color of background
	    - whether to show vertex labels (IDs or names) and whether to show labels for bendpoints
	    - colors for vertex labels and their shadows, and the stroke width for drawing labels
    """

    def __setattr__(self, name, value):
        # Don't update the remote 'ready' state; it's a local flag.
        if name != 'observers' and name != 'ready':
            for o in self.observers:
                o.callRemote('setattr', {name: value}).addErrback(connectionError, 'context setattr')
        self.__dict__[name] = value

    def __init__(self, graph=None, camera=None, orthocamera=None, netcli=False):
        print "Calling graph context init"
        #
        # Cacheable: Keep track of observers
        #
        self.__dict__['observers'] = []
        if not config.current['global:highlight']:
            self.highLight = False
        else:
            self.highLight = True
        self.highLightNow = True
        self.ready = False

        if not graph:
            print "Making a graph object"
            self.graph = Graph(parent=self)
        else:
            self.graph = graph

        if netcli:
            self.UndoStack = undo.DummyStack(self)
            self.RedoStack = undo.DummyStack(self)
        else:
            self.UndoStack = undo.UndoStack(self)
            self.RedoStack = undo.RedoStack(self)

        self.graphgl = graphgl.GraphGL(self.graph)
        self.decor = interfacegl.InterfaceGL()

        if not camera:
            self.camera = Camera()
            self.camera.lookAt = (0.0, 0.0, 0.0)
        else:
            self.camera = camera

        if not orthocamera:
            self.orthocamera = OrthoCamera()
        else:
            self.orthocamera = orthocamera

        self.cursor = Cursor()

        self.path = None

        # This should default to False and turn on automatically
        # when you have a 3D input device.
        # XXX#
        self.showCursor = False

        # The drawList should be a dictionary of Drawables,
        # used by the InputManager to enable transient objects,
        # menus, etc to be drawn.
        self.drawList = {}

        self.orthoMode = None
        self.showAxes = config.current['default:show-axes']
        self.showLocalAxes = config.current['default:show-local-axes']
        self.showHUD = config.current['default:show-hud']
        self.showGrid = config.current['default:show-grid']
        self.showGridLines = config.current['default:show-grid-lines']
        self.showPlane = config.current['default:show-plane']
        self.planeColor = config.current['default:plane-color']
        self.bgColor = config.current['default:background-color']
        self.showVertexLabels = config.current['default:show-vertex-labels']
        self.showDummyLabels = config.current['default:show-dummy-labels']
        self.vertexLabelName = config.current['default:vertex-label-name']
        self.vertexLabelColor = config.current['default:vertex-label-color']
        self.vertexShadowColor = config.current['default:vertex-shadow-color']
        self.vertexLabelStroke = config.current['default:vertex-label-stroke']

        self.showGridPlane = "XZ"
        self.pos = (0.0, 0.0, 0.0)
        self.sizeX = 5
        self.sizeY = 5
        self.sizeZ = 5
        self.spacing = 2.0

        # The HUD status text line.
        self.HUDstatus = ''


        #If no highlight object exists, create one.
        if self.highLight:
            print "Creating highlight for active context"
            self.highLight = True
            from interfacegl import DrawObjectHighLight

            self.setDraw('wandaHighLight',
                         DrawObjectHighLight(
                             ctx=self,
                             tolerance=5.0,
                             restrict=None,
                         )
            )

    def getStateToCacheAndObserveFor(self, perspective, observer):
        """
        Add an observer to the list, and return our current
        state with the observer list stripped out.
        """
        print "adding observer to GraphContext:", perspective, observer
        self.observers.append(observer)

        d = self.__dict__.copy()
        # XXX# What other Cacheable-specific data do we have to remove?
        if 'parent' in d:
            d['parent'] = None
        del d['observers']
        del d['graphgl']
        del d['decor']
        del d['UndoStack']
        del d['RedoStack']
        return d

    def stoppedObserving(self, perspective, observer):
        """
        Remove an observer from the list.
        """
        self.observers.remove(observer)
        print "stopped observing:", perspective, observer

    def init(self):
        """
        Should be called the first time this context is drawn, after OpenGL
        has been set up. It ensures that the initial viewpoint reflects
        the initial camera.
        """
        glEnable(GL_COLOR_MATERIAL)
        glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE)
        glEnable(GL_LIGHT0)

        if self.orthoMode:
            self.orthocamera.use()
        else:
            self.camera.use()

            # glLightfv(GL_LIGHT0, GL_POSITION, (-0.1, 1.0, 0.1, 0.0))

        self.graphgl.init()
        self.decor.init()
        self.ready = True

    def loadFromFile(self, filename, format, queryCallback=None, warningCallback=None):
        """Loads a graph into this context. Sets up defaults for ground plane
           and camera."""

        filepath = path.realpath(filename)
        (dir, basename) = path.split(filepath)
        (prefix, ext) = path.splitext(basename)

        fobj = file(filepath, 'rU')
        format.load(self.graph, fobj, queryCallback=queryCallback, warningCallback=warningCallback)
        fobj.close()

        self.graph.new = False
        self.graph.change(False)
        # Set this to force a rendering update of the graph - maybe there's
        # a better way to do it? It hasn't been changed (for saving purposes)
        # but the graph object itself has changed (for display purposes).
        self.graph.dirty = True

        # Store the path
        self.path = filename

        # These should be user preferences.Cursor()
        self.showAxes = config.current['default:show-axes']
        self.showLocalAxes = config.current['default:show-local-axes']
        self.showPlane = config.current['default:show-plane']
        self.showHUD = config.current['default:show-hud']
        self.showGrid = config.current['default:show-grid']
        self.showGridLines = config.current['default:show-grid-lines']
        self.planeColor = config.current['default:plane-color']
        self.bgColor = config.current['default:background-color']
        self.showVertexLabels = config.current['default:show-vertex-labels']
        self.showDummyLabels = config.current['default:show-dummy-labels']
        self.vertexLabelName = config.current['default:vertex-label-name']
        self.vertexLabelColor = config.current['default:vertex-label-color']
        self.vertexShadowColor = config.current['default:vertex-shadow-color']
        self.vertexLabelStroke = config.current['default:vertex-label-stroke']
        self.orthoMode = None

        # Cacheable: Send all these parameters across the wire
        if self.observers:
            d = self.__dict__.copy()
            del d['observers']
            del d['graphgl']
            del d['decor']
            for o in self.observers: o.callRemote('setattr', d).addErrback(connectionError, 'context loadfromfile')
            # Update the graph edge and vertex lists.
            for o in self.graph.observers:
                o.callRemote('setattr', {
                'vertices': self.graph.vertices,
                'vertices_selected': self.graph.vertices_selected,
                'edges': self.graph.edges,
                'edges_selected': self.graph.edges_selected,
                })
                o.callRemote('change', True)

        self.camera.lookAtGraph(self.graph, self.graph.centerOfMass(), offset=self.graph.viewpoint())

    def writeToFile(self, format=None, filename=None, options={}):
        """GraphContext.writeToFile(filename = None) -> void
           Writes the graph in this context out to a file, autodetecting
           the filetype from the name of the file. If filename == None,
           will attempt to use self.path. If self.path == None and
           filename == None, raises ExportError."""
        # Detect what kind of file we're loading and
        # call a specialized loader
        if filename == None or format == None:
            if not self.path == None:
                filename = self.path
                filepath = path.realpath(filename)
                (dir, basename) = path.split(filepath)
                (prefix, ext) = path.splitext(basename)
                if not ext == '.mg' and not ext == '.mg2':
                    raise ExportError, "Couldn't save into exported type."
                format = formatmanager.formats[ext[1:]]
            else:
                raise ExportError, "Couldn't save new file without filename."

        filepath = path.realpath(filename)
        format.write(self.graph, filepath, options=options)
        self.path = filename

        self.graph.change(False)

    def exportToFile(self, filename, format, options={}):
        """GraphContext.exportToFile(filename) -> void
           Writes the graph in this context out to a file, autodetecting
           the filetype from the name of the file. Will not change the path
           or reset the changed flag."""
        filepath = path.realpath(filename)
        format.write(self.graph, filepath, options=options)

    def writeToPOVRay(self, filename, options={}):
        """Draw the graph to a .pov POVRay file

        Arguments:
        filename -- name of the file with path and extension
        options -- a dictionary of POVRay options

        """
        filepath = path.realpath(filename)
        if 'skyColor' not in options:
            options['skyColor'] = self.bgColor
        if 'planeColor' not in options:
            options['planeColor'] = self.planeColor
        if self.orthoMode:
            formatmanager.formats['pov'].write(self.graph, filepath,
                                               self.orthocamera,
                                               options=options)
        else:
            formatmanager.formats['pov'].write(self.graph, filepath,
                                               self.camera,
                                               options=options)

    def revert(self):
        """GraphContext.revert() -> void
           Reloads a context from the last saved state.
           Raises ImportError if there is no last saved state."""
        if self.path == None:
            raise ImportError, "Can't revert an unsaved context."
        filepath = path.realpath(self.path)
        (dir, basename) = path.split(filepath)
        (prefix, ext) = path.splitext(basename)

        self.graph.clear()
        self.loadFromFile(self.path, formatmanager.formats[ext[1:]])

    def setDraw(self, slot, drawable):
        self.drawList[slot] = drawable
        for o in self.observers:
            o.callRemote('setattr', {'drawList': self.drawList}).addErrback(connectionError, 'context setDraw')

    def delDraw(self, slot):
        if slot in self.drawList:
            del self.drawList[slot]
            for o in self.observers:
                o.callRemote('setattr', {'drawList': self.drawList}).addErrback(connectionError, 'context removeDraw')

    def getDraw(self, slot):
        return self.drawList[slot]

    def draw(self, edgeNameBase=None, vertNameBase=None):
        """Draw the elements of this context on the current GL canvas."""

        if not self.ready:
            self.init()

        # Set up the camera
        if self.orthoMode:
            activecam = self.orthocamera
        else:
            activecam = self.camera

        activecam.use()
        # Apply the tracker offsets.
        activecam.useTracker()

        if self.graph.vertices_selected:
            orbitCentre = self.graph.vertices_selected[0]
        else:
            orbitCentre = self.graph.centerOfMass()
        # Multiply points if snapping to grid
        if self.showGrid:
            ocp = utilities.mult3D(orbitCentre.pos, self.spacing)
        else:
            ocp = orbitCentre.pos

        if config.current['global:camera-orbit'] == "cw":
            self.camera.absorbit(ocp, Y_AXIS, -1)
        elif config.current['global:camera-orbit'] == "ccw":
            self.camera.absorbit(ocp, Y_AXIS, 1)


        # Only draw decorations if we're in render mode - not in
        # selection mode.
        if glGetInteger(GL_RENDER_MODE) == GL_RENDER:
            # Draw the ground plane if it's enabled, but not when we're
            # using ortho mode
            glEnable(GL_CULL_FACE)
            if self.showPlane and not self.orthoMode:
                self.decor.drawGroundPlane(height=self.graph.findGroundPlane(), color=self.planeColor,
                                           reference=self.camera.pos)
        #
        # Draw the graph
        #
        glEnable(GL_TEXTURE_2D)
        self.graphgl.draw(edgeNameBase=edgeNameBase, vertNameBase=vertNameBase)

        #
        # Draw A grid if the user wants one
        #
        if self.showGridLines:
            self.decor.drawGrid(parent=self, pos=self.pos, sizeX=self.sizeX, sizeY=self.sizeY, sizeZ=self.sizeZ,
                                spacing=self.spacing)

        # Only draw decorations if we're in render mode - not in
        # selection mode.
        if glGetInteger(GL_RENDER_MODE) == GL_RENDER:
            glEnable(GL_CULL_FACE)
            # Draw the coordinate axes if they're enabled
            if self.showAxes:
                self.decor.drawAxes()

                # Draw local axes if required
                # print "window:",wx.Window.FindFocus(), "\n canvas:", self.parent.canvas
            showA = False
            if not self.parent == None:
                if wx.Window.FindFocus() == self.parent.canvas:
                    showA = True

            if self.showLocalAxes and showA:
                localAxes = (X_AXIS, Y_AXIS, Z_AXIS)
                labels = ('Q', 'A', 'W', 'S', 'E', 'D')
                if self.orthoMode:
                    if self.orthoMode[0] == X_AXIS:
                        localAxes = (Y_AXIS, Z_AXIS)
                        if self.orthoMode[1] > 0:
                            labels = (None, None, 'W', 'S', 'D', 'A')
                        else:
                            labels = (None, None, 'W', 'S', 'A', 'D')
                    elif self.orthoMode[0] == Y_AXIS:
                        localAxes = (X_AXIS, Z_AXIS)
                        if self.orthoMode[1] > 0:
                            labels = ('A', 'D', None, None, 'S', 'W')
                        else:
                            labels = ('D', 'A', None, None, 'S', 'W')
                    elif self.orthoMode[0] == Z_AXIS:
                        localAxes = (X_AXIS, Y_AXIS)
                        if self.orthoMode[1] > 0:
                            labels = ('A', 'D', 'W', 'S', None, None)
                        else:
                            labels = ('D', 'A', 'W', 'S', None, None)

                for v in self.graph.vertices_selected:
                    if v.hidden:
                        continue
                    self.decor.draw_localaxes(self, v, axes=localAxes, labels=labels)

            # Draw vertex labels if selected.
            if self.showVertexLabels:
                if self.showDummyLabels:
                    vxlist = self.graph.vertices
                else:
                    vxlist = [x for x in self.graph.vertices if not isinstance(x, DummyVertex)]
                if len(vxlist) > 0:
                    if self.vertexLabelName:
                        labelFunc = lambda v: str(v.name)
                    else:
                        labelFunc = lambda v: str(v.id)
                    self.decor.drawVertexLabels(parent=self, vxlist=vxlist, labelFunc=labelFunc,
                                                labelStrokeWidth=self.vertexLabelStroke,
                                                labelColor=self.vertexLabelColor, shadowColor=self.vertexShadowColor)

            if self.showHUD:
                if self.showCursor:
                    self.decor.drawHUD(activecam, self.graph.vertices_selected, pos=self.cursor.realPosition(activecam),
                                       status=self.HUDstatus)
                else:
                    self.decor.drawHUD(activecam, self.graph.vertices_selected, status=self.HUDstatus)

            if self.showCursor:
                # First, draw the local grid around the cursor position.
                #		self.decor.drawLocalGrid(pos = self.cursor.realPosition(activecam), size=1, spacing=5.0, snap=5.0)
                glEnable(GL_CULL_FACE)
                glDisable(GL_TEXTURE_2D)
                glDisable(GL_POLYGON_SMOOTH)

                self.decor.drawCursor(camera=activecam, cursor=self.cursor)

            for d in self.drawList.values():
                d.draw()

    def goPersp(self):
        """
        Restore and unlock the perspective camera in this context.
        """
        self.orthoMode = None
        for o in self.observers: o.callRemote('setOrtho', None).addErrback(connectionError, 'abc')

    def goOrtho(self, axis, look):
        """
        Align and lock in this context for orthographic movement.
        axis and side specify the alignment of the camera.

        eg. goOrtho(Y_AXIS, -1) will place the camera on the Y axis
        looking in the negative direction with movement restricted
        to the XZ plane.
        """
        self.orthoMode = (axis, look)
        for o in self.observers: o.callRemote('setOrtho', self.orthoMode).addErrback(connectionError, 'abc')
        self.orthocamera.setOnAxis(axis, look * -20.0)

    def vertexWarp(self, vertex, refresh=None):
        """
        Warp to vertex, using the Animator.
        """
        from utilities import add3D, diff3D, mult3D

        offset = add3D(mult3D(self.camera.vpn, -10.0), (0.0, vertex.radius * 3.0, 0.0))

        if self.showGrid:
            npos = utilities.mult3D(vertex.pos, self.spacing)
        else:
            npos = vertex.pos

        targetpos = add3D(npos, offset)

        self.parent.animator.perspCameraMove(self.camera, newPos=targetpos, newLook=npos, duration=1.0)

    def lookAt(self, target, refresh=None):
        """
        Re-point the current camera to look at some object in the graph.
        Target can be:
        - a position in 3-space expressed as a 3-tuple of floats
        - a Vertex object
        - an Edge object (will look at the midpoint)
        """

        if isinstance(target, Vertex):
            if self.showGrid:
                tgt = target
                tgt.pos = utilities.mult3D(target.pos, self.spacing)
            else:
                tgt = target
        elif isinstance(target, Edge):
            if self.showGrid:
                tgt = target
                tgt.source.pos = utilities.mult3D(target.source.pos, self.spacing)
                tgt.target.pos = utilities.mult3D(target.target.pos, self.spacing)
            else:
                tgt = target
        elif self.showGrid:
            tgt = utilities.mult3D(target, self.spacing)
        else:
            tgt = target

        if self.orthoMode:
            # XXX# Do something
            pass
        else:
            self.parent.animator.perspCameraMove(
                camera=self.camera,
                newLook=tgt,
                duration=1.2,
            )
コード例 #50
0
class Engine(object):
    
    __world_objects = WeakKeyDictionary()
    
    def __init__(self):
        self.__message_queue = []
        self.__cur_stat_surf = None
        self.__actors = []
        self.__items = []
        self.__gfx = None
        self.__quit_loop = False
        self.__last_id = 0
        self.__id_gen = self.__gen_id()
        self.__actors_on_screen = []
        self.__timer = 0
        self.__world_time = 0
        self.__load_fonts()
        self.__build_surf_cache()
        self.__set_game_instance()
        self.__player_actions = PlayerActions(self)
        self.__state_worker = StateWorker(self)

        self.__actor_grid = []
        self.__item_grid = []
        for y in xrange(200):
            aline = []
            iline = []
            for x in xrange(200):
                aline.append([])
                iline.append([])
            self.__actor_grid.append(aline)
            self.__item_grid.append(iline)
                    
        self.map = None
        self.dungeon = dungeon.DungeonsOfGogadan()
        self.quit_mes = QUIT
        
        self.stats = [att.Att('Strength', 'Important for Melee-Fighter', 20),
                      att.Att('Endurance', 'Important for Melee-Fighter'),
                      att.Att('Mind', 'Important for Spellcaster'),
                      att.Att('Health', 'How much can you take?', 45)]
        
        self.camera = Camera(20, 26)
        self.state = S_RUN
        self.__await_target = None
        
        Debug.init_debug(self)
        Debug.debug('init pygame')

        pygame.init()
        self.screen = pygame.display.set_mode((1024, 768))
        self.__clock = pygame.time.Clock()
        self.item_to_throw = None
        self.cursor = Cursor(self)
        self._items_to_choose = {}
        self._symbols = []
        c = 'abcdefghijklmonpqrstuvwxyz'
        for s in c:
            self._symbols.append(s)
    
    def call_pl_item_throw(self):
        self.__player_actions.throw_fire()        
        
    def re_init(self):
        Debug.debug('re_init')
        self.__quit_loop = False
        self.quit_mes = QUIT
                
        self.__load_fonts()
        self.__build_surf_cache()
        self.__set_game_instance()
        self.__clock = pygame.time.Clock()
        self.__id_gen = self.__gen_id()
        for act in self.__actors:
            self.__world_objects[act] = True
        for item in self.__items:
            self.__world_objects[item] = True
        self.__world_objects[self.map] = True
        self.__clear_surfaces()
        if hasattr(self, 'map'):
            self.redraw_map()
    
    def get_symbol(self):
        s = self._symbols.pop(0)
        return s
    
    def free_symbol(self, s):
        if s == None: return
        self._symbols.append(s)
        self._symbols.sort()
        
    def get_actor_at(self, pos):
        x, y = pos
        act = self.__actor_grid[y][x]
        return act[0] if len(act) > 0 else None
        #for actor in self.__actors:
        #    if actor.pos() == pos:
        #        return actor
        #return None
    def get_all_srd_actors(self, pos, radius=1, null_pos=False):
        mo = []
        for x in xrange(-radius, radius + 1):
            for y in xrange(-radius, radius + 1):
                mo.append((x, y))
        
        if not null_pos:
            mo.remove((0, 0))
        
        poss = []
        for m in mo:
            poss.append((m[0] + pos[0], m[1] + pos[1]))
        
        actors = []
        for p in poss:
            acts = self.get_actor_at(p)
            if not acts == None:
                actors.append(acts)
        return actors
        #for act in self.__actors:
        #    if act.pos() in poss:
        #        actors.append(act)
        #return actors
    def get_free_adj(self, pos):
        new_pos = None
        mo = [(-1, -1), (-1, 0), (-1, 1),
              (1, -1), (1, 0), (1, 1),
              (0, -1), (0, 1)]

        random.shuffle(mo) 
        while new_pos == None and len(mo) > 0: 
            t = mo.pop()
            new_pos = pos[0] + t[0], pos[1] + t[1]
            
            if not self.map.map_array[new_pos[1]][new_pos[0]][MT_FLAGS] & F_WALKABLE:
                new_pos = None
            else:
                for actor in self.__actors:
                    if actor.pos() == new_pos:
                        new_pos = None
                        break
        
        return new_pos
    def get_sc_up_pos(self):
        y = 0
        x = 0
        pos = None
        for line in self.map.map_array:
            x = 0
            for t in line:
                if t == MAP_TILE_up:
                    pos = x, y
                x += 1
            y += 1
        return pos if pos != None else self.map.get_random_pos()
    def get_sc_down_pos(self):
        y = 0
        x = 0
        pos = None
        for line in self.map.map_array:
            x = 0
            for t in line:
                if t == MAP_TILE_down:
                    pos = x, y
                x += 1
            y += 1
        return pos if pos != None else self.map.get_random_pos()
    def get_actor_by_id(self, id):
        for act in self.__actors:
            if act.id == id:
                return act
    def shout(self, text):
        self.__message_queue.insert(0, text)
        print text
    def change_map(self, down=True):
        
        if self.map == None:
            level = 1 
        elif down:
            level = self.map.level + 1
            self.__save_map()
        else:
            level = self.map.level - 1
            self.__save_map()

        if self.__load_map(level):
            return
        if level == 0:
            self.game_over()    
        
        self.__actors = []
        self.__actors.append(self.player)
        self.__items = []
        self.map = self.dungeon.get_map(level)
        
        for act in self.__actors:
            act.sc = sc(self.map.map_array)
            
        if down:
            pos = self.get_sc_up_pos()
        else:
            pos = self.get_sc_down_pos()
        self.player.set_pos(pos)
            
        r = self.camera.adjust(self.player.pos())
        while r:
            r = self.camera.adjust(self.player.pos())
    def create_gold(self, amount, pos):
        gold = dungeon.Populator.create_item('Gold', 'basic_stuff', 0)
        gold.amount = amount
        gold.set_pos(pos)
        self.add_item(gold)
        
    def summon_monster(self, caster, name, file, pos):
        mon = dungeon.Populator.create_creature(name, file)
        mon.ai = henchmanAI.HenchmanAI(mon)
        mon.ai.friends.add(caster.id)
        caster.ai.friends.add(mon.id)
        mon.set_pos(pos)
        mon.sc = sc(self.map.map_array)
        self.add_actor(mon, True)
        
    def create_humanoid(self):
        #man = races[1][3](True, 1)
        man = races[2][3](True, 1)
        #man.classkit = classkits[2][1](man)
        man.classkit = classkits[0][1](man)
        from ai import simpleai
        man.ai = henchmanAI.HenchmanAI(man)
        man.name = 'Nigg Yshur'
        pos = self.get_free_adj(self.player.pos())
        man.set_pos(pos)
        man.ai.friends.add(self.player.id)
        self.player.ai.friends.add(man.id)
        man.sc = sc(self.map.map_array)
                        #self.player = races[race][3](True, gender)
                        #self.player.classkit = classkits[classkit][1](self.player)
                        #self.player.classkit = classkits[classkit][1](self.player)
                        #b = dungeon.Populator.create_item('TomeOfVileUmbrages','tovu',100)
                        #self.player.pick_up(b)
    
    def create_character(self):
        c_res = Res('dc-pl.png', TILESIZE)
        g = 'female', 'male'
        gender = 1
        race = 0
        classkit = 0
        OK = False
        name = ''
        title = 'He'
        title2 = 'His'
        story = ['This is the incredible story of our hero',
               'Long time ago, there was a hero named',
               'There once was a time, long ago, when']
        
        s = random.choice(story)
        
        while not OK:
            self.screen.fill(BLACK)
            
            self.__render_text(self.screen, 'Build your character:', WHITE, ((35, 30)), 'big')
            
            self.screen.blit(self.__surf_cache['mes_block2'], (60, 65))
            
            
            img = pygame.transform.smoothscale(c_res.get(races[race][1 + gender]), (TILESIZE * 2, TILESIZE * 2))
            self.screen.blit(img , (75, 100))
            
            
            self.__render_text(self.screen, name, WHITE, ((73, 170)))
            
            y = 100
            self.__render_text(self.screen, s, WHITE, ((145, y)))
            self.__render_text(self.screen, name, GREEN, ((395, y)))
            y += 20
            self.__render_text(self.screen, 'the' , WHITE, ((145, y)))
            self.__render_text(self.screen, g[gender] + ' ' + races[race][0] + ' ' + classkits[classkit][0] + '.', GREEN, ((167, y)))
            y += 20
            self.__render_text(self.screen, title + ' ' + races[race][3].desc, WHITE, ((145, y)))
            y += 20
            self.__render_text(self.screen, classkits[classkit][1].desc.replace('$$$', title.lower()).replace('%%%', title2.lower()), WHITE, ((145, y)))
            
            
            self.__render_text(self.screen, 'Type in your name', WHITE, ((600, 100)))
            self.__render_text(self.screen, 'press F1 / F2 to change race', WHITE, ((600, 120)))
            self.__render_text(self.screen, 'press F3 / F4 to change class', WHITE, ((600, 140)))
            self.__render_text(self.screen, 'press F5 to change gender', WHITE, ((600, 160)))
            self.__render_text(self.screen, 'press Enter to start', WHITE, ((600, 180)))
            
            pygame.display.flip()
            for e in pygame.event.get():
                if e.type == pygame.QUIT:
                    sys.exit()
                if e.type == pygame.KEYDOWN:
                    if e.key == pygame.K_F5:
                        if gender == 1:
                            gender -= 1
                            title = 'She'
                            title2 = 'Her'
                        else:
                            gender += 1
                            title = 'He'
                            title2 = 'His'
                    if e.key == pygame.K_F3:
                        classkit += 1
                        if classkit >= len(classkits):
                            classkit = 0
                    elif e.key == pygame.K_F4:
                        classkit -= 1
                        if classkit < 0:
                            classkit = len(classkits) - 1
                    
                    elif e.key == pygame.K_F1:
                        race += 1
                        if race >= len(races):
                            race = 0
                    elif e.key == pygame.K_F2:
                        race -= 1
                        if race < 0:
                            race = len(races) - 1
                            
                    elif e.key == pygame.K_RETURN:
                        self.player = races[race][3](True, gender)
                        self.player.classkit = classkits[classkit][1](self.player)
                        b = dungeon.Populator.create_item('TomeOfVileUmbrages', 'tovu', 100)
                        self.player.pick_up(b)
                        self.player.clear_surfaces()
                        self.player.timer = 0
                        OK = True
                    elif e.key == pygame.K_BACKSPACE:
                        if len(name) > 0:
                            name = name[:-1]
                    else:
                        kn = pygame.key.name(e.key)
                        if kn in 'abcdefghijklmnopqrstuvwxyz' and len(name) < 10:
                            if len(name) > 0:
                                name += pygame.key.name(e.key)
                            else:
                                name += pygame.key.name(e.key).upper()
 
        
        
    
    def start(self, ts):
        
        if ts:
            self.create_character()
            self.change_map()
            self.create_humanoid()
            
        Debug.debug('starting mainloop')
        return self._main_loop()
    
    def is_inside_map(self, pos):
        return not (pos[0] < 0 or pos[1] < 0 or pos[0] >= self.map.width or pos[1] >= self.map.height)

    def update_item_pos(self, item, new_pos):
        x, y = item.pos()
        nx, ny = new_pos
        if item in self.__item_grid[y][x]: 
            self.__item_grid[y][x].remove(item)
        self.__item_grid[ny][nx].append(item)
        
    def update_actor_pos(self, act, new_pos):
        x, y = act.pos()
        nx, ny = new_pos
        if act in self.__actor_grid[y][x]:
            self.__actor_grid[y][x].remove(act)
        self.__actor_grid[ny][nx].append(act)
        
    def is_move_valid(self, actor, new_pos):
        if not self.is_inside_map(new_pos):
            return False   

        nx, ny = new_pos
        act = self.__actor_grid[ny][nx]
        if len(act) > 0:
            return act[0]
            
        valid = self.map.can_enter(new_pos, actor.move_mode)
        if valid and actor == self.player: 
            self.map.cur_surf = None    
            items = self.get_items_at(new_pos)
            if len(items) == 1:
                self.shout('You see a %s' % (items[0].get_name()))
            if len(items) > 1:
                 self.shout('You see several items here')
        
        return valid
    
    def get_range_target(self, cpos, tpos):
        return self.get_actor_at(tpos)
#        if cpos != tpos:
#            poss = line(cpos[0], cpos[1], tpos[0], tpos[1])
#            poss.pop(0)
#            for pos in poss:
#                actor = self.get_actor_at(pos)
#                if actor != None:
#                    return actor
#        else:
#            return self.caster
#        return None
    
    def throw_item(self, attacker, item, target_pos):
        t_pos = target_pos
        s_pos = attacker.pos()
        victim = self.get_range_target(attacker.pos(), target_pos)
        if victim != None:
            t_pos = victim.pos()
        dir = attacker.locateDirection(t_pos)
        gfx = throw.ThrowFX(dir, s_pos, t_pos, item)
        self.drawGFX(gfx)
        item.set_pos(t_pos)
        
    def range_attack(self, attacker, target_pos):
        t_pos = target_pos
        s_pos = attacker.pos()
        victim = self.get_range_target(attacker.pos(), target_pos)
        
        if victim != None:
            t_pos = victim.pos()
                
        dir = attacker.locateDirection(t_pos)
        gfx = projectile.ProjectileFX(dir, s_pos, t_pos)
        self.drawGFX(gfx)
        
        #while self.__gfx != None:
        #    self._world_draw()
        
        if victim != None:
            self.attack(attacker, victim, True)
    
    def __c_end_friendship(self, attacker, victim):
        victim.ai.friends.discard(attacker.id)
        victim.ai.hostile.add(attacker.id)
        attacker.ai.friends.discard(victim.id)
        attacker.ai.hostile.add(victim.id)
        todel = []
        for id in victim.ai.friends:
            act = self.get_actor_by_id(id)
            if act == None:
                todel.append(id)
            else:
                act.ai.friends.discard(attacker.id)
                act.ai.hostile.add(attacker.id)
        for id in todel:
            victim.ai.friends.discard(id)
        
        todel = []
        for id in attacker.ai.friends:
            act = self.get_actor_by_id(id)
            if act == None:
                todel.append(id)
            else:
                act.ai.friends.discard(victim.id)
                act.ai.hostile.add(victim.id)
        for id in todel:
            attacker.ai.friends.discard(id)
        
    def __c_apply_effects(self, attacker, victim):
        for fx in attacker.get_av_fx():
            if d(100) <= fx[1]:
                Debug.debug('Applied effect %s to %s by %s' % (fx[0], victim, attacker))
                f = fx[0](victim, attacker)
                f.tick()
            
        for fx in victim.get_dv_fx():
            skip = False
            for nt in fx[0].notrigger:
                if attacker.slot.weapon.flags & nt:
                    skip = True
            
            if not skip and d(100) <= fx[1]:
                Debug.debug('Applied effect %s to %s by %s' % (fx[0], attacker, victim))
                f = fx[0](attacker, victim)
                f.tick()
    
    def attack(self, attacker, victim, ranged=False):
        
        self.__c_end_friendship(attacker, victim)
        
        vi_adress = (victim == self.player and ['you'] or ['the ' + victim.name])[0]
        at_miss_adress = (attacker == self.player and ['You miss'] or [attacker.name + ' misses'])[0]
        at_hit_adress = (attacker == self.player and ['You hit'] or ['The ' + attacker.name + ' hits'])[0]
        at_kill_adress = (attacker == self.player and ['You killed'] or ['The ' + attacker.name + ' killed'])[0]
         
        wpn = attacker.weapon
        if wpn == None:
            wpn = attacker.unarmed_weapon

        highest_skill = None, 0
        for s in wpn.skills:
            v = getattr(attacker.skills, s)
            if v > highest_skill[1]:
                highest_skill = s, v
        
        attack_roll = d(100)
        
        if attack_roll > highest_skill:
            self.shout('%s %s.' % (at_miss_adress, vi_adress))
            Debug.debug('Miss!')
            return
        
        if victim.get_RA() > 0 and not victim.unconscious:
            victim.RA -= 1
            dodge_skill = victim.skills.Dodge
            dodge_roll = d(100)
            if dodge_roll <= dodge_skill:
                self.shout('%s dodged the attack' % (vi_adress))
                return
        
        self.__c_apply_effects(attacker, victim)
        
        hit_zone = victim.HP.get_random_zone()
        z = getattr(victim.HP, hit_zone)[2]
        
        if wpn.type != I_VOID:
            damage = wpn.damage[1]() + attacker.get_DM()[0]()
        else:
            damage = d(3) + attacker.get_DM()[0]()
        dam=self.do_damage(victim, damage, hit_zone, source=attacker)        
        self.shout('%s %s at the %s for %i damage' % (at_hit_adress, vi_adress, z,dam))
        
    def do_damage(self, act, dam, zone, type=D_GENERIC, source=None):
        return act.do_damage(dam, zone, type)
        
    def wait_for_target(self, point_of_entry):
        self.__await_target = point_of_entry
        self.__player_actions.cursor()

    def do_identify(self):
        self.__player_actions.identify()
        
    def target_choosen(self, pos):
        self.__await_target(pos)
        self.__await_target = None
        
        #self.player.fire(pos)
    
    def get_items_at(self, pos):
        x, y = pos
        #print self.__item_grid[y][x]
        return [item for item in self.__item_grid[y][x] if not item.picked_up]
        #return [item for item in self.__items if item.pos() == pos]
    def game_over(self):
        print 'You failed'
        self.__quit_loop = True
        self.__actors = []
    
    def redraw_map(self):
        self.map.cur_surf = None
    def redraw_stats(self):
        self.__cur_stat_surf = None
    
    def add_to_world_objects(self, obj):
        self.__world_objects[obj] = True
    def add_actor(self, actor, add=True):
        if add: self.__actors.append(actor)
        if self.map != None:
            actor.sc = sc(self.map.map_array)
        self.__world_objects[actor] = True
    def add_item(self, item, add=True):
        if add: self.__items.append(item)
        self.__world_objects[item] = True
    def del_actor(self, actor):
        if actor in self.__actors:
            self.__actors.remove(actor)
        if actor in self.__actors_on_screen:
            self.__actors_on_screen.remove(actor)
        x, y = actor.pos()
        if actor in self.__actor_grid[y][x]:
            self.__actor_grid[y][x].remove(actor)
    def del_item(self, item):
        if item in self.__items:
            self.__items.remove(item)
        x, y = item.pos()
        if item in self.__item_grid[y][x]:
            self.__item_grid[y][x].remove(item)
        #if item.player_symbol != None:
        #    self.free_symbol(item.player_symbol)
            
    def get_id(self):
        return self.__id_gen.next()
    
    def drawGFX(self, gfx):
        self.__gfx = gfx
        self.state = S_GFX
        
        # good or bad??
        while self.__gfx != None:
            self._world_draw()

    
    def _main_loop(self):
        while not self.__quit_loop:
            self.__clock.tick(40)
            self._world_move()
            self._world_draw()
            self._world_input()
#            print self.clock.get_fps()
        self.std_font = None
        self.__clock = None
        self.__cur_stat_surf = None
        self.__last_id = self.__id_gen.next()
        self.__id_gen = None
        self.__clear_surfaces()
        return self.quit_mes
    def _world_input(self):
        for e in pygame.event.get():
            self.__quit_loop = e.type == pygame.QUIT 
            
            if e.type == pygame.KEYDOWN:
                
                if e.key == GAME_SAVE_QUIT:
                    self.__quit_loop = True
                    self.quit_mes = SAVE
                
                # --- cheat keys >>>
                if e.key == pygame.K_F1:
                    for line in self.map.map_array:
                        l = ''
                        for s in line:
                            l = l + str(s[0])
                        print l    
                
                if e.key == pygame.K_F2:
                    self.player.cur_health = 200
                    self.player.cur_endurance = 5000
                    self.player.cur_mind = 5000
                    self.player.cur_strength = 5000
                    
                if e.key == pygame.K_F3:
                    for item in self.__items:
                        print item.name, item.pos()

                if e.key == pygame.K_F4:                        
                    for act in self.__actors:
                        print act.name, act.timer
                              
                if e.key == pygame.K_F5:
                    for S in gc.get_referrers(Surface):
                        if isinstance(S, Surface):
                            print S

                    print gc.get_referrers(Surface)
                if e.key == pygame.K_F6:
                    self.create_humanoid()      
                # <<< cheat keys ---
                
                if not self.state == S_GFX:
                    self.__cur_stat_surf = None
                self.moved = True
                
                if self.state == S_RUN and not self.player.unconscious:
                    if e.key in PLAYER_ACTIONS: 
                        self.__player_actions.__getattribute__(PLAYER_ACTIONS[e.key])()

                elif self.state in STATE_WORKER:
                    self.__state_worker.__getattribute__(STATE_WORKER[self.state])(e.key)

        if self.state == S_PLAYER_CURSOR:
            pygame.event.pump()
            keys = pygame.key.get_pressed()
            for key in MOVES:
                if keys[key]:
                    pygame.time.wait(150)
                    if key == MOVE_WAIT:
                        pos = self.__actors_on_screen[0].pos()
                        if pos == self.cursor.pos():
                            self.__actors_on_screen.append(self.__actors_on_screen.pop(0))
                            pos = self.__actors_on_screen[0].pos()
                        self.cursor.set_pos(pos)
                        self.__actors_on_screen.append(self.__actors_on_screen.pop(0))
                    else:
                        self.cursor.move(key)

        if self.state == S_RUN  and not self.player.unconscious:
            pygame.event.pump()
            keys = pygame.key.get_pressed()
            [self.player.move(key) for key in MOVES if keys[key] and self.player.timer <= 0]
    def _world_move(self):
        if not self.__quit_loop:
            if self.state == S_RUN:
                self.__actors.sort(sort_by_time) #actors with lowest timer first
                diff = self.__actors[0].timer
                self.__timer += diff
                self.__world_time += diff
                
                if self.__timer > 500:             #act-independent issues # one combat-round
                    [act.tick() for act in self.__actors]
                    self.__timer -= 500
                        
                for actor in self.__actors:
                    if actor.timer > 0:
                        actor.timer -= diff
                    else:
                        actor.act()
                
            elif self.state == S_GFX:
               if self.__gfx == None:
                    self.state = S_RUN
    def _world_draw(self):

        if self.__gfx == None or self.__gfx.redraw:

            if self.camera.adjust(self.player.pos()):
                self.map.cur_surf = None
            self.screen.fill((0, 0, 0))
            if not self.player.dazzled:
                self.screen.blit(self.__get_map_surface(), (-self.camera.x * TILESIZE, -self.camera.y * TILESIZE))
                    
            if not self.player.dazzled:
                for item in self.__items: 
                    if not item.picked_up and (self.player.sc.lit(item.x, item.y) or self.player.x == item.x and self.player.y == item.y):
                        try:
                            self.screen.blit(self.__get_item_surface(item), (item.x * TILESIZE - self.camera.x * TILESIZE, item.y * TILESIZE - self.camera.y * TILESIZE))
                        except:
                            print sys.exc_info()
                            print item.name, item.pos(), 'is invalid!!!!'
            
            for act in self.__actors:
                if  act == self.player or self.player.sc.lit(act.x, act.y) and not self.player.dazzled:
                    try:
                        self.screen.blit(self.__get_actor_surface(act), (act.x * TILESIZE - self.camera.x * TILESIZE, act.y * TILESIZE - self.camera.y * TILESIZE))
                        if not act in self.__actors_on_screen:
                            self.__actors_on_screen.append(act)
                    except:
                        print sys.exc_info()
                        print act.name, act.pos(), 'is invalid!!!!'
                else:
                    if act in self.__actors_on_screen:
                        self.__actors_on_screen.remove(act)
                    
            if self.state == S_PLAYER_CURSOR:
                self.screen.blit(self.cursor.get_surf(), (self.cursor.x * TILESIZE - self.camera.x * TILESIZE, self.cursor.y * TILESIZE - self.camera.y * TILESIZE))
            
            self.screen.blit(self.__get_message_surface(), (0, 768 - 128))
            self.screen.blit(self.__get_statblock_surface(), (1024 - 192, 0))
    
        if self.__gfx != None:
            pos = self.__gfx.pos()
            if pos == None:
                self.__gfx = None
                self.__cur_stat_surf = None
            else:
                x, y = pos
                #tiles = __get_affected_tiles(x,y,self.__gfx.get_surf())
                x = x / TILESIZE + self.camera.x
                y = y / TILESIZE + self.camera.y
                #print x,y,self.player.pos(),self.player.sc.lit(x, y)
                if self.player.sc.lit(x, y):
                    self.screen.blit(self.__gfx.get_surf(), pos)
                    self.__gfx.tick()
            
        pygame.display.flip()

    def __get_map_surface(self):
        if self.map.cur_surf == None:
            self.player.sc.do_fov(self.player.x, self.player.y, 15)
            surf_map = pygame.Surface((self.map.width * TILESIZE, self.map.height * TILESIZE))
            cx, cy, cw, ch = self.camera.get_view_port()       
            for x in xrange(max(cx, 0), min(self.map.width, cw + 1)):

                for y in xrange(max(cy, 0), min(self.map.height, ch + 1)):
                    pos = (x, y) == self.player.pos() 
                    lit = self.player.sc.lit(x, y)
                    memo = self.map.map_array[y][x][MT_FLAGS] & F_MEMO
                    if pos or lit or memo:
                        blit_position = ((x) * TILESIZE, (y) * TILESIZE)
                        surf_map.blit(self.map.get_tile_at(x, y), blit_position)
                        
                        if not pos and not lit and memo:
                            surf_map.blit(self.__surf_cache['FOW'], blit_position)
                        
                        if not self.map.map_array[y][x][MT_FLAGS] & F_MEMO:
                            tile = self.map.map_array[y][x]
                            new_tile = tile[0], tile[1], tile[2] ^ F_MEMO
                            self.map.map_array[y][x] = new_tile

            self.map.cur_surf = surf_map
        
        return self.map.cur_surf
    def __get_actor_surface(self, act):
        if act.cur_surf == None:
            surf_act = pygame.Surface((TILESIZE, TILESIZE), pygame.SRCALPHA, 32)
            surf_act.blit(act.get_tile(), (0, 0)) 
            act.cur_surf = surf_act
        return act.cur_surf
    def __get_item_surface(self, item):
        if item.cur_surf == None:
            surf_item = pygame.Surface((TILESIZE, TILESIZE), pygame.SRCALPHA, 32)
            surf_item.blit(item.get_dd_img(), (0, 0)) 
            item.cur_surf = surf_item
        return item.cur_surf
    def __get_message_surface(self):
        surf = pygame.Surface((1024 - 192, 128))
        surf.blit(self.__surf_cache['mes_block'], (0, 0))
        y = 100
        for mes in self.__message_queue:
            self.__render_text(surf, mes, WHITE, (20, y))
            y -= 20
            if y < 10:
                break
        return surf
    def __get_statblock_surface(self):
        if self.__cur_stat_surf == None:
            surf = pygame.Surface((192, 768))
            surf.fill(BLACK)
            #surf.blit(self.__surf_cache['stat_block'], (0, 0))
            
            if self.state in (S_RUN, S_GFX):
                self.__draw_stat_block(surf)    

            if self.state in CHOOSE_STATES:
                self.__draw_item_choose(surf, CHOOSE_STATES[self.state])
            
            self.__cur_stat_surf = surf
            
        return self.__cur_stat_surf
    
    def __set_game_instance(self):
        dungeon.Map.game = self
        Actor.game = self
        Item.game = self
        AI.game = self
        Camera.game = self
        dungeon.Populator.game = self
        magic.Spell.game = self
        GFX.game = self
        att.Att.game = self
        dungeon.SADungeon.game = self
    def __draw_item_choose(self, surf, message):
        self.__render_text(surf, message, WHITE, (16, 20))
        y = 38
        abc = self._items_to_choose.keys()
        #abc.sort(sort_by_type)
        s48 = pygame.Surface.copy(self.__surf_cache['stat_32'])
       
        for key in abc:
            item = self._items_to_choose[key]
            color = WHITE
            if hasattr(item, 'special'):
                if item.special:
                    color = GREEN
            if hasattr(item, 'color'):
                color = item.color    
            if hasattr(item, 'get_name'):
                name = item.get_name()
            else:
                name = item.name
            
            surf.blit(s48, (16, y))
            if hasattr(item, 'cur_surf'):
                surf.blit(self.__get_item_surface(item), (16, y))
            self.__render_text(surf, '%s' % (key), WHITE, (16, y))
            #self.__render_text(surf, '%s -' % (key), WHITE, (16, y))
            self.__render_text(surf, name, color, (64, y)); y += 18
            
            info = item.info()
            for line in info:
                self.__render_text(surf, line, color, (64, y)); y += 18
            if len(info) == 0:
                y += 18
            y += 18
            
    def __draw_stat_block(self, surf):
        
        bt = self.player.get_body_tile()
        bt = pygame.transform.smoothscale(bt, (96, 96))
        bt.set_alpha(122)
        y = 50
        surf.blit(bt, (32, y))
        
        x = 77
        y = 55
        color = WHITE
        if self.player.HP.Head[0] == self.player.HP.Head[1]: color = GREEN
        if self.player.HP.Head[0] == 0: color = YELLOW
        if self.player.HP.Head[0] < 0: color = RED
        self.__render_text(surf, str(self.player.HP.Head[0]), color, (x, y))
        
        y = 75
        color = WHITE
        if self.player.HP.Chest[0] == self.player.HP.Chest[1]: color = GREEN
        if self.player.HP.Chest[0] == 0: color = YELLOW
        if self.player.HP.Chest[0] < 0: color = RED

        self.__render_text(surf, str(self.player.HP.Chest[0]), color, (x, y))
        
        y = 95
        color = WHITE
        if self.player.HP.Abdomen[0] == self.player.HP.Abdomen[1]: color = GREEN
        if self.player.HP.Abdomen[0] == 0: color = YELLOW
        if self.player.HP.Abdomen[0] < 0: color = RED

        self.__render_text(surf, str(self.player.HP.Abdomen[0]), color, (x, y))
        
        x = 40
        y = 85
        color = WHITE
        if self.player.HP.L_Arm[0] == self.player.HP.L_Arm[1]: color = GREEN
        if self.player.HP.L_Arm[0] == 0: color = YELLOW
        if self.player.HP.L_Arm[0] < 0: color = RED

        self.__render_text(surf, str(self.player.HP.L_Arm[0]), color, (x, y))
        
        x = 110
        color = WHITE
        if self.player.HP.R_Arm[0] == self.player.HP.R_Arm[1]: color = GREEN
        if self.player.HP.R_Arm[0] == 0: color = YELLOW
        if self.player.HP.R_Arm[0] < 0: color = RED
        self.__render_text(surf, str(self.player.HP.R_Arm[0]), color, (x, y))
        
        x = 55
        y = 130
        color = WHITE
        if self.player.HP.L_Leg[0] == self.player.HP.L_Leg[1]: color = GREEN
        if self.player.HP.L_Leg[0] == 0: color = YELLOW
        if self.player.HP.L_Leg[0] < 0: color = RED
        self.__render_text(surf, str(self.player.HP.L_Leg[0]), color, (x, y))
        
        x = 95
        color = WHITE
        if self.player.HP.R_Leg[0] == self.player.HP.R_Leg[1]: color = GREEN
        if self.player.HP.R_Leg[0] == 0: color = YELLOW
        if self.player.HP.R_Leg[0] < 0: color = RED
        self.__render_text(surf, str(self.player.HP.R_Leg[0]), color, (x, y))




                    
        stats = [('STR ', self.player.STR, self.player.get_STR()),
                 ('CON ', self.player.CON, self.player.get_CON()),
                 ('DEX ', self.player.DEX, self.player.get_DEX()),
                 ('SIZ ', self.player.SIZ, self.player.get_SIZ()),
                 ('INT ', self.player.INT, self.player.get_INT()),
                 ('POW ', self.player.POW, self.player.get_POW()),
                 ('CHA ', self.player.CHA, self.player.get_CHA()),
                 ('DM  ', self.player.DM[1], self.player.get_DM()[1])]
        y = 245
        for line in stats:
            b = 0
            if len(str(line[1])) > 3:
                b = 18
            self.__render_text(surf, str(line[0]).rjust(2, ' '), WHITE, (16, y)); 
            self.__render_text(surf, str(line[1]).rjust(2, ' '), GREEN, (55, y)); 
            self.__render_text(surf, '/', WHITE, (70 + b, y));
            self.__render_text(surf, str(line[2]).rjust(2, ' '), WHITE, (80 + b, y));
            y += 18

        #pygame.draw.circle(Surface, color, pos, radius, width=0): return Rect
        
       
        
            #r = pygame.Surface((100, 2))
            #r.fill(RED)
            #surf.blit(r, (16, y + 20))
            #size = float(line[2]) / float(line[1]) * 100
            #if size > 0:
            #    g = pygame.Surface((size, 2))
            #    if size > 100:
            #        g.fill(BLUE)
            #    else:
            #        g.fill(GREEN)
            #surf.blit(g, (16, y + 20))
            
            
        
      
        self.__render_text(surf, 'Gold:', WHITE, (16, 510))
        self.__render_text(surf, str(self.player.gold), WHITE, (90, 510))

        self.__render_text(surf, 'XP:', WHITE, (16, 528))
        self.__render_text(surf, str(self.player.xp), WHITE, (90, 528))
        
        i = 0
        y = 600
        count = len(self.player.items)
        s32 = pygame.Surface.copy(self.__surf_cache['stat_32'])
        sgreen = pygame.Surface.copy(self.__surf_cache['sgreen'])
        for h in xrange(3):
            for x in xrange(5):
                pos = (x * TILESIZE + x * 3 + 5, h * TILESIZE + y + h * 3)
                surf.blit(s32, pos)
                if i < count:
                    item = self.player.items[i]
                    if item.equipped:
                        surf.blit(sgreen, pos)
                    surf.blit(self.__get_item_surface(item), pos)
                    self.__render_text(surf, self.player.items[i].get_ps(), WHITE, (pos))
                    i += 1
                #print (x*TILESIZE,h*TILESIZE+y)
        

        self.__render_text(surf, self.dungeon.name, WHITE, (16, 710))
        self.__render_text(surf, 'Level: %i' % (self.map.level), WHITE, (16, 728))
        
        
    def __render_text(self, surf, text, color, pos, font='std'):
        t = self.__font_cache[font].render('%s' % (text), True, color)
        ts = self.__font_cache[font].render('%s' % (text), True, BLACK)
        surf.blit(ts, (pos[0] + 1, pos[1] + 1))
        surf.blit(t, pos)
    def __load_fonts(self):
        #self.std_font = pygame.font.Font(os.path.join('font', 'jesaya.ttf'), 14)
        self.__font_cache = {'std':pygame.font.Font(os.path.join('font', 'alex.ttf'), 17),
                           'big':pygame.font.Font(os.path.join('font', 'alex.ttf'), 25)}
        
    def __save_map(self):
        self.__clear_surfaces()
        self.__actors.remove(self.player)
        data = self.map, self.__actors, self.__items , self.player.pos()
        if os.access('MAP%i.gz' % (self.map.level), os.F_OK):
             os.remove('MAP%i.gz' % (self.map.level))
        FILE = gzip.open('MAP%i.gz' % (self.map.level), 'w')
        pickle.dump(data, FILE, 2)
        FILE.close()
    def __load_map(self, level):
        if os.access('MAP%i.gz' % (level), os.F_OK):
            FILE = gzip.open('MAP%i.gz' % (level), 'r')
            self.map, self.__actors, self.__items, pos = pickle.load(FILE)
            
            self.__set_game_instance()
            FILE.close()
            self.player.set_pos(pos)
            r = self.camera.adjust(self.player.pos())
            while r:
                r = self.camera.adjust(self.player.pos())
            self.__actors.append(self.player)
            for act in self.__actors:
                self.__world_objects[act] = True
                act.sc = sc(self.map.map_array)
            self.player.sc.do_fov(self.player.x, self.player.y, self.player.cur_mind / 20 + 5)
                
            for item in self.__items:
                self.__world_objects[item] = True
                
            self.__world_objects[self.map] = True
            self.__clear_surfaces()
            
            self._world_draw()
            return True
        return False
        self.__quit_loop = True
        self.quit_mes = SAVE
    def __build_surf_cache(self):
        fow_surf = pygame.Surface((TILESIZE, TILESIZE))
        fow_surf.fill(BLACK)
        fow_surf.set_alpha(100)
        sgreen = pygame.Surface((TILESIZE, TILESIZE))
        sgreen.fill(GREEN)
        sgreen.set_alpha(100)
        self.__surf_cache = {'sgreen':sgreen,
                             'FOW': fow_surf,
                             'stat_block': load_image('stat.png'),
                             'stat_48': load_image('48.png'),
                             'stat_32': pygame.transform.smoothscale(load_image('48.png'), (32, 32)),
                             'mes_block':load_image('mes_block.png'),
                             'mes_block2':load_image('mes_block2.png')}
    def __clear_surfaces(self):
        for obj in self.__world_objects.keys():
            obj.clear_surfaces()
        self.cursor.cursor_surf = None
    def __gen_id(self):
        for x in xrange(self.__last_id, 9999999):
            yield x
コード例 #51
0
class Menu(object):
    """docstring for Menu"""
    def __init__(self, screen):
        self.clock = pygame.time.Clock()
        self.screen = screen
        self.buffer = pygame.Surface(self.screen.get_size())
        self.font = pygame.font.Font(FONT, FONT_SIZE)
        self.menu_items = ['Items','Equip','Magic','Status','Save','Close','Quit']
        self.menu_image = pygame.image.load(IMAGES_DIR+'menu.png').convert_alpha()
        self.cursor = Cursor(ypos=[5,30,55,80,105,130,155])

        
    def open_menu(self):
        menu = True
        pygame.key.set_repeat()
        while menu:
            for event in pygame.event.get():
                if event.type == KEYDOWN:
                    if event.key == K_ESCAPE:
                        menu = False
                    if event.key == K_DOWN:
                        self.cursor.move_down()
                    if event.key == K_UP:
                        self.cursor.move_up()
                    if event.key == K_RETURN:
                        if self.cursor.position.y == 30:
                            self.open_equipment()
                        if self.cursor.position.y == 55:
                            self.open_magic()
                        if self.cursor.position.y == 80:
                            self.open_status()
                        if self.cursor.position.y == 105:
                            self.save()
                        if self.cursor.position.y == 130:
                            menu = False
                        if self.cursor.position.y == 155:
                            pygame.quit()

            self.buffer.blit(self.menu_image, (0,0))
            self.render_menu()
            self.render_cursor()
            pygame.transform.scale(self.buffer, self.screen.get_size(), self.screen)
            pygame.display.flip()
            self.clock.tick(60)
        pygame.key.set_repeat(1,5)



    def render_menu(self):
        pos = 5
        for item in self.menu_items:
            self.buffer.blit(self.font.render(item, 0, pygame.Color("white")), (self.buffer.get_width()-110,pos))
            pos += 25

    def render_cursor(self, animate=True):
        if animate:
            self.cursor.update()
        self.buffer.blit(self.cursor.image, self.cursor.position)


    def save(self):
        # Save function goes here !
        print "Game Save"

    def open_magic(self):
        # MAGIC ! TODO
        popup = True
        while popup:
            for event in pygame.event.get():
                if event.type == KEYDOWN:
                    if event.key == K_RETURN:
                        popup = False

            self.buffer.blit(self.menu_image, (0,0))
            self.render_menu()
            self.render_cursor(animate=False)
            self.buffer.blit(self.font.render("You don't have any magic... Yet...", 0,pygame.Color("white")), (10, 50))
            pygame.transform.scale(self.buffer, self.screen.get_size(), self.screen)
            pygame.display.flip()
            self.clock.tick(60)

    def open_equipment(self):
        # EQUIPMENT ! TODO
        popup = True
        while popup:
            for event in pygame.event.get():
                if event.type == KEYDOWN:
                    if event.key == K_RETURN:
                        popup = False

            self.buffer.blit(self.menu_image, (0,0))
            self.render_menu()
            self.render_cursor(animate=False)
            self.buffer.blit(self.font.render("You don't have any equipment...", 0,pygame.Color("white")), (10, 50))
            self.buffer.blit(self.font.render("(Yes I'm a lazy developper...)", 0,pygame.Color("white")), (10, 65))
            pygame.transform.scale(self.buffer, self.screen.get_size(), self.screen)
            pygame.display.flip()
            self.clock.tick(60)

    def open_status(self):
        menu = True
        statuscursor = Cursor(ypos=[25, 85, 145, 205], xpos=[0])
        while menu:
            for event in pygame.event.get():
                if event.type == KEYDOWN:
                    if event.key == K_ESCAPE:
                        menu = False
                    if event.key == K_DOWN:
                        statuscursor.move_down()
                    if event.key == K_UP:
                        statuscursor.move_up()
                    if event.key == K_RETURN:
                        if statuscursor.position.y == 25:
                            self.status(self.team[0])
                        if statuscursor.position.y == 85:
                            self.status(self.team[1])
                        if statuscursor.position.y == 145:
                            self.status(self.team[2])
                        if statuscursor.position.y == 205:
                            self.status(self.team[3])

            self.buffer.blit(self.menu_image, (0,0))
            self.render_menu()
            statuscursor.update()
            self.buffer.blit(statuscursor.image, statuscursor.position)
            pygame.transform.scale(self.buffer, self.screen.get_size(), self.screen)
            pygame.display.flip()
            self.clock.tick(60)

    def status(self, char):
        menu = True
        while menu:
            for event in pygame.event.get():
                if event.type == KEYDOWN:
                    if event.key == K_ESCAPE:
                        menu = False

            self.buffer.blit(self.menu_image, (0,0))
            self.render_char(char, 1)
            self.buffer.blit(self.font.render("Skills", 0,(255,255,255)), (60, 45))
            self.buffer.blit(self.font.render("Stats", 0,(255,255,255)), (60, 60))
            self.buffer.blit(self.font.render("Strength : %d" % char.str, 0,(255,255,255)), (60, 75))
            self.buffer.blit(self.font.render("Defense : %d" % char.defense, 0,(255,255,255)), (300, 75))
            self.buffer.blit(self.font.render("Intelligence : %d" % char.int, 0,(255,255,255)), (60, 90))
            self.buffer.blit(self.font.render("Magic Defense : %d" % char.mdefense, 0,(255,255,255)), (300, 90))
            self.buffer.blit(self.font.render("Dexterity : %d" % char.dex, 0,(255,255,255)), (60, 105))
            pygame.transform.scale(self.buffer, self.screen.get_size(), self.screen)
            pygame.display.flip()
            self.clock.tick(60)
コード例 #52
0
ファイル: game.py プロジェクト: efunn/hemo-control
    def __init__(self):

        ###############
        # load config #
        ###############
        with open('config.yaml') as f:
            CONFIG = yaml.load(f)
        with open('mvc.yaml') as f:
            MVC = yaml.load(f)
        self.subj_id = CONFIG['subject-id']
        self.subj_dir = 'datasets/' + self.subj_id
        self.loc = CONFIG['location']

        #################
        # set constants #
        #################
        if self.loc == 'lab':
            self.FRAME_RATE = 120
        elif self.loc == 'scanner':
            self.FRAME_RATE = 60
        self.SCREEN_WIDTH, self.SCREEN_HEIGHT = 1024, 768
        self.BG_COLOR_REG = 70,70,70
        self.BG_COLOR_REG_2 = 110,110,110
        self.BG_COLOR_REG_3 = 40,40,40
        self.SUCCESS_COLOR = 70,170,70
        self.FAIL_COLOR = 170,70,70
        self.INDICATOR_COLOR = 40,60,40
        self.INDICATOR_COLOR_2 = 30,100,30
        self.GOOD_MSG_COLOR = 160,255,160
        self.BAD_MSG_COLOR = 255,160,160
        self.A_MSG_COLOR = 160,160,255
        self.B_MSG_COLOR = 230,230,160
        self.REG_FIXATION_COLOR = 200,200,200
        self.GOOD_FIXATION_COLOR = self.SUCCESS_COLOR
        self.BAD_FIXATION_COLOR = 240,140,140

        self.BAD_SCORE_COLOR = 200,100,100
        self.GOOD_SCORE_COLOR = 100,200,100
        self.HIGHLIGHT_SCORE_COLOR = 20,255,20
        self.NORM_SCORE_COLOR = 180,180,100

        self.SENSOR_INPUT_OFFSET = np.array([0.5*self.SCREEN_WIDTH,
                                             0.75*self.SCREEN_HEIGHT])
        self.BORDER_COLOR_DICT = {'incomplete':(50,0,0),
                                  'ready':(0,0,50),
                                  'complete':(0,50,0),
                                  'disconnected':(50,0,0),
                                  'idle':(50,50,50),
                                  'rai':(0,50,0),
                                  'rfi':(0,50,0),
                                  'loc':(0,50,0),
                                  'nfb':(0,50,0)}
        self.BG_COLOR_DICT = {'incomplete':(100,0,0),
                              'ready':(0,0,100),
                              'complete':(0,100,0),
                              'disconnected':(100,0,0),
                              'idle':(100,100,100),
                              'rai':(0,100,0),
                              'rfi':(0,100,0),
                              'loc':(0,100,0),
                              'nfb':(0,100,0)}

        # dict entry for current timer set to use
        self.PRE_REST_TIME = {'trial':0}
        self.INTRO_TIME = {'trial':0}
        self.FEEDBACK_TIME = {'trial':0}
        self.ACTIVE_TIME = {'trial':0}
        self.TRIALS = {'trial':0}
        self.TRIAL_TIME = {'trial':0}
        self.INTRO_TRIGGER_TIME = {'trial':0}
        self.ACTIVE_TRIGGER_TIME = {'trial':0}
        self.FEEDBACK_TRIGGER_TIME = {'trial':0}

        # self-paced times
        self.PRE_REST_TIME['s_p'] = 3
        self.INTRO_TIME['s_p'] = 1
        self.FEEDBACK_TIME['s_p'] = 2
        self.ACTIVE_TIME['s_p'] = -1
        self.TRIALS['s_p'] = 5
        self.TRIAL_TIME['s_p'] = (self.PRE_REST_TIME['s_p'] + self.INTRO_TIME['s_p']
                               + self.FEEDBACK_TIME['s_p'])
        self.INTRO_TRIGGER_TIME['s_p'] = self.PRE_REST_TIME['s_p'] 
        self.ACTIVE_TRIGGER_TIME['s_p'] = self.PRE_REST_TIME['s_p'] + self.INTRO_TIME['s_p']
        self.FEEDBACK_TRIGGER_TIME['s_p'] = -1

        self.TRIAL_TYPES = 9
        self.trial_type_count = 0

        # localizer times
        # 40 seconds per trial
        # 480s per run
        self.PRE_REST_TIME['loc'] = 17
        self.INTRO_TIME['loc'] = 1
        self.ACTIVE_TIME['loc'] = 20
        self.FEEDBACK_TIME['loc'] = 2
        self.TRIALS['loc'] = 12

        # neurofeedback times
        # 60 seconds per trial
        # 480s per run
        self.PRE_REST_TIME['nfb'] = 27
        self.INTRO_TIME['nfb'] = 1
        self.ACTIVE_TIME['nfb'] = 30
        self.FEEDBACK_TIME['nfb'] = 2
        self.TRIALS['nfb'] = 8

        self.NFB_INFO_TIME = 0.5
        self.NFB_INFO_HEIGHT = 28
        self.MVC_TIME = 19

        self.INTRO_TRIGGER_TIME['loc'] = self.PRE_REST_TIME['loc'] 
        self.ACTIVE_TRIGGER_TIME['loc'] = self.PRE_REST_TIME['loc'] + self.INTRO_TIME['loc']
        self.FEEDBACK_TRIGGER_TIME['loc'] = self.ACTIVE_TRIGGER_TIME['loc'] + self.ACTIVE_TIME['loc'] 

        self.INTRO_TRIGGER_TIME['nfb'] = self.PRE_REST_TIME['nfb'] 
        self.ACTIVE_TRIGGER_TIME['nfb'] = self.PRE_REST_TIME['nfb'] + self.INTRO_TIME['nfb']
        self.FEEDBACK_TRIGGER_TIME['nfb'] = self.ACTIVE_TRIGGER_TIME['nfb'] + self.ACTIVE_TIME['nfb'] 
        self.CONTROL_TRIGGER_TIME = 1000*int(0.5*self.INTRO_TRIGGER_TIME['nfb'])
        self.BASELINE_CALC_SHIFT = self.PRE_REST_TIME['nfb']-10

        self.TRIAL_TIME['loc'] = (self.PRE_REST_TIME['loc'] + self.INTRO_TIME['loc']
                               + self.ACTIVE_TIME['loc'] + self.FEEDBACK_TIME['loc'])

        self.TRIAL_TIME['nfb'] = (self.PRE_REST_TIME['nfb'] + self.INTRO_TIME['nfb']
                               + self.ACTIVE_TIME['nfb'] + self.FEEDBACK_TIME['nfb'])

        #####################
        # control variables #
        #####################
        self.TR = 1.
        self.ADD_CONTROL_TRS = 5
        self.TF_CONTROL = self.ACTIVE_TIME['nfb']+self.ADD_CONTROL_TRS
        self.N_ACTIVE_TIME = self.ACTIVE_TIME['nfb']/self.TR+1
        self.N_CONTROL_STEPS = self.TF_CONTROL/self.TR+1
        self.CONTROL_MVC_MIN = 0.1
        self.CONTROL_MVC_MAX = 0.4
        self.u_vec = np.zeros((1,self.N_CONTROL_STEPS))
        self.y_vec = np.zeros(self.N_CONTROL_STEPS)
        gc.set_system(self)

        ##########################
        # force sensor variables #
        ##########################
        self.MVC_IN_PIXEL = 900
        self.MVC_MIN = 0#0.05
        self.ANGLE_ADD_DEG = 20
        self.ANGLE_ADD = np.deg2rad(self.ANGLE_ADD_DEG)
        self.ANGLE_MULT = 1+2*self.ANGLE_ADD/np.pi
        self.set_mvc(MVC['mvc'])
        self.DAQ_LPF_CUTOFF = 8
        self.DAQ_LPF_ORDER = 3

        self.CALIBRATE_BOOL = False # False or True
        if self.CALIBRATE_BOOL:
            fu.write_cal_header(self)

        if SENSOR_ACTIVE:
            if self.CALIBRATE_BOOL:
                self.daq = Pydaq('Dev3/ai0:2', self.FRAME_RATE,
                                 lp_filt_freq=14,
                                 lp_filt_order=3,
                                 force_params='force_params_cal.txt')
            else:
                self.daq = Pydaq('Dev3/ai0:1', self.FRAME_RATE,
                                 lp_filt_freq=self.DAQ_LPF_CUTOFF,
                                 lp_filt_order=self.DAQ_LPF_ORDER,
                                 force_params='force_params_lab.txt')
            self.scanner_daq = Pydaq('Dev1/ai2:3', self.FRAME_RATE,
                                     lp_filt_freq=self.DAQ_LPF_CUTOFF,
                                     lp_filt_order=self.DAQ_LPF_ORDER,
                                     force_params='force_params_scanner.txt')

        ########################
        # networking variables #
        ########################
        IP = CONFIG['server-ip']
        PORT = CONFIG['server-port']
        self.SERVER_TARGET = 'http://{ip}:{port}/'.format(ip=IP,
                                                          port=PORT)
        self.requests_running_bool = mp.Value('i', 1)
        self.last_volume_received = mp.Value('i', 0)
        self.pool = mp.Pool()

        self.insta_mode = 'disconnected' # idle, rai, rfi, loc, nfb
        self.roi_name = 'm1_left_a'
        self.next_run_msg = ''
        self.insta_complete = OrderedDict()
        self.insta_complete['roi'] = 'incomplete'
        self.insta_complete['rai'] = 'incomplete'
        self.insta_complete['rfi'] = 'incomplete'
        self.insta_complete['warp2rfi'] = 'incomplete'
        self.insta_complete['glm'] = 'incomplete'
        self.insta_complete['loc'] = 'incomplete'

        self.raw_betas = {'active':0.,
                          'force':0.,
                          'complexity':0.,
                          'constant':0.}

        self.psc_betas = {'active':0.5,
                          'force':1.5,
                          'complexity':1.0}

        self.MAX_CONTROL = 3
        self.MIN_CONTROL = 0.5
        self.PSC_TARGET_LIST = [1.5,1.5,1.5,1.5]
        self.RUN_TYPE_LIST = CONFIG['run-type-list']

        self.NFB_TRS = int(self.TRIAL_TIME['nfb']
                           *self.TRIALS['nfb']/self.TR)
        self.bold_rois_array = []
        self.bold_rois_array.append(mp.Array('d',self.NFB_TRS))
        self.REQUEST_WAIT_TIME = 0.1
        self.requests_process = mp.Process(target = gn.requests_loop,
                                           args = (self.SERVER_TARGET,
                                                   self.REQUEST_WAIT_TIME,
                                                   self.requests_running_bool,
                                                   self.last_volume_received,
                                                   self.bold_rois_array,))

        ####################################################
        # start pygame and initialize default game objects #
        ####################################################
        pygame.init()
        pygame.mouse.set_visible(not pygame.mouse.set_visible)
        self.clock = pygame.time.Clock()
        if CONFIG['fullscreen']:
            self.screen = pygame.display.set_mode(
                            (self.SCREEN_WIDTH, self.SCREEN_HEIGHT),
                             pygame.FULLSCREEN)
        else:
            self.screen = pygame.display.set_mode(
                            (self.SCREEN_WIDTH, self.SCREEN_HEIGHT))

        ##################################
        # initialize custom game objects #
        ##################################
        self.CURSOR_RAD = 75
        self.FIXATION_WIDTH = 1.5*self.CURSOR_RAD
        self.FIXATION_HEIGHT = 8
        self.cursor = Cursor(self.screen, self.CURSOR_RAD)
        self.timers = {}
        self.init_timers()

        self.TARGET_SUCCESS_TIME = .15
        self.TARGET_MIN_TIME = .5
        self.TARGET_RAD_MIN = -25
        self.TARGET_RAD_MAX = 45

        #####################
        # target lists here #
        #####################

        # function to generate x length, all same mvc,
        # all same phase
        # and do {20s length} x {.1, .2, .4} x {0, 180}
        self.MVC_LIST = []
        self.PHASE_LIST = []
        self.MVC_LIST.append(np.array([.1,.1,.1,.1,.1,.1,.1,.1,.1,.1,.1,.1,.1,.1,.1,.1,.1,.1,.1,.1]))
        self.MVC_LIST.append(np.array([.2,.2,.2,.2,.2,.2,.2,.2,.2,.2,.2,.2,.2,.2,.2,.2,.2,.2,.2,.2]))
        self.MVC_LIST.append(np.array([.4,.4,.4,.4,.4,.4,.4,.4,.4,.4,.4,.4,.4,.4,.4,.4,.4,.4,.4,.4]))
        self.PHASE_LIST.append(np.array([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]))
        self.PHASE_LIST.append(np.array([180,180,180,180,180,180,180,180,180,180,180,180,180,180,180,180,180,180,180,180]))

        self.TRAINING_TARGET_LOC_LIST = []

        self.loc_target_order = [0,3,1,4,2,5,1,4,0,5,3,2]

        for mvc in self.MVC_LIST:
            for phase in self.PHASE_LIST:
                self.TRAINING_TARGET_LOC_LIST.append(self.gen_target_list(mvc,phase))

        self.next_mvc_list = []
        self.next_phase_list = []
        self.next_target_loc_list = []

        # auto-generate 1, 1.5, and 2 psc from dummy data
        for psc_target in (1.,1.5,2.):
            new_targets = self.gen_control_targets(psc_target)
            self.TRAINING_TARGET_LOC_LIST.append(new_targets)

        self.SAMPLE_MVC_LIST = np.array([.4,.1,.2,.1,.2,.4])
        self.SAMPLE_PHASE_LIST = np.array([0,0,0,180,180,180])
        self.SAMPLE_TARGET_LOC_LIST = self.gen_target_list(self.SAMPLE_MVC_LIST,
                                                           self.SAMPLE_PHASE_LIST)
        self.set_targets(self.SAMPLE_TARGET_LOC_LIST)

        ######################
        # set game variables #
        ######################
        self.screen_mid = np.array([0.5*self.screen.get_width(),
                                    0.5*self.screen.get_height()])
        self.bg_color = self.BG_COLOR_REG_3
        self.fixation_color = self.REG_FIXATION_COLOR
        self.input_mode = 'mouse'
        self.input_pos = np.array([0.0,0.0])
        self.input_force = np.array([0.0,0.0])
        self.cal_force = 0.
        self.debug_bool = False
        self.nfb_info_bool = False
        self.run_mode = 'idle' # idle, mvc, trials
        self.run_type = 's_p'
        self.self_paced_bool = True
        self.controller_active_bool = False
        self.controller_calc_bool = False
        self.nfb_run_count = 0
        self.calc_score_bool = False
        self.trial_time_array = np.array(())
        self.set_timer_mode('s_p')
        self.current_score = 0
        self.score_color = self.GOOD_SCORE_COLOR
        self.score_fixation_status = 'norm'
        self.max_rec_mvc_both = 0
        self.max_rec_mvc_x = 0
        self.max_rec_mvc_y = 0
        self.MVC_DISPLAY_CEIL = 100.
コード例 #53
0
ファイル: pngscraper.py プロジェクト: mehulsbhatt/snakeeyes
class PngScraperFrame(wx.Frame):
    def __init__(self, *args, **kwargs):

        wx.Frame.__init__(self, *args, **kwargs)


        self.createMenu()

        #self.pngs = ['c:/temp/mibook.png']
        self.pngs = GetPngList(PNGDIR)
        
        self.cursor = Cursor(ListView(self.pngs))

        box = wx.BoxSizer(wx.VERTICAL)

        # next button

        row = wx.BoxSizer(wx.HORIZONTAL)


        def CursorButton(label):
            b = wx.Button(self, label= label)
            b.Bind(wx.EVT_BUTTON, self.OnCursorButton)
            return b
            
        row.Add(CursorButton("<<"))
        row.Add(CursorButton("<"))

        self.which =  wx.TextCtrl(self, -1, '')
        self.updateWhich()
        row.Add(self.which)

        row.Add(CursorButton(">"))
        row.Add(CursorButton(">>"))

        # coords box
        self.coords = wx.TextCtrl(self, -1, '(0,0)')
        row.Add(self.coords, 0, wx.ALIGN_RIGHT)
        row.Add((20,20),1)

        # color box
        self.color = wx.TextCtrl(self, -1, '0x000000')
        row.Add(self.color, 0, wx.ALIGN_RIGHT)
        row.Add((20,20),1)
        
        box.Add(row, 0, wx.ALIGN_CENTER_HORIZONTAL)

        # the image

        pane = wx.ScrolledWindow(self, -1, size=(300,400))
        box.Add(pane, 0, wx.ALIGN_CENTER_HORIZONTAL|wx.ALL|wx.ADJUST_MINSIZE)
        
        self.image = wx.StaticBitmap(pane, bitmap=wx.EmptyBitmap(800, 600))
        self.image.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
        self.image.Bind(wx.EVT_RIGHT_DOWN, self.OnRightDown)
        self.updateImage()

        # the shell
        self.locals = {'self':self, 'wx':wx, 'hook': lambda:None, 'gc':self.getGC() }
        self.shell = py.shell.Shell(self, locals=self.locals)
        self.shell.SetMinSize((500,400))
        box.Add(self.shell, 4, wx.EXPAND)
        self.shell.SetFocus()
        
        self.SetSizerAndFit(box)
        wx.EVT_CLOSE(self, self.OnCloseWindow)


    def createMenu(self):   
        
        # Setting up the menu.
        filemenu= wx.Menu()
        filemenu.Append(ID_OPEN_FILE, "&Open File", "OpenFile")
        filemenu.Append(ID_OPEN_DIR, "Open &Directory", "OpenDir")
        
        filemenu.AppendSeparator()
        filemenu.Append(wx.ID_EXIT,"E&xit"," Terminate the program")

        # Creating the menubar.
        menuBar = wx.MenuBar()      
        menuBar.Append(filemenu,"&File") # Adding the "filemenu" to the MenuBar
        self.SetMenuBar(menuBar)  # Adding the MenuBar to the Frame content.

        wx.EVT_MENU(self, wx.ID_EXIT, self.OnExit)
        wx.EVT_MENU(self, ID_OPEN_FILE, self.OnOpenFile)
        wx.EVT_MENU(self, ID_OPEN_DIR, self.OnOpenDir)


    def OnCursorButton(self, evt):
        buttonMap = {
            "<<":"moveToStart",
            "<" :"movePrevious",
            ">" :"moveNext",
            ">>":"moveToEnd",
        }
        try:
            getattr(self.cursor, buttonMap[evt.GetEventObject().Label])()
            self.updateWhich()
            self.updateImage()
            self.shell.run('hook()')
        except StopIteration:
            pass



    def OnOpenFile(self, event):
        dlg = wx.FileDialog(
            self, message="Choose a file", defaultDir=os.getcwd(), 
            defaultFile="", wildcard='*.png',
            style=wx.OPEN | wx.CHANGE_DIR)
        if dlg.ShowModal() == wx.ID_OK:
            path = dlg.GetPath()
            self.pngs.insert(self.cursor.position,path)
            self.updateWhich()
            self.updateImage()

    def OnOpenDir(self, event):
        dlg = wx.DirDialog(self, "Choose a directory:",
                           defaultPath=os.getcwd(), 
                           style=wx.DD_DEFAULT_STYLE|wx.DD_NEW_DIR_BUTTON)
        if dlg.ShowModal() == wx.ID_OK:
            path = dlg.GetPath()
            while self.pngs:
                self.pngs.pop()
            self.pngs.extend(GetPngList(path))
            self.cursor.moveToStart()
            self.updateWhich()
            self.updateImage()
            self.shell.run('hook()')
            
    def OnExit(self, evt):
        self.Close()

    def updateWhich(self):
        self.which.Value = "%s/%s" % (self.cursor.position, len(self.pngs))

    def updateImage(self):

        # set the visible bitmap
        img = wx.Image(self.pngs[self.cursor.position], wx.BITMAP_TYPE_PNG)
        self.image.SetBitmap(wx.BitmapFromImage(img))
        self.Fit()
        
        # and make the pil image
        self.im = im = Image.new('RGB', (self.image.Size))
        self.im.fromstring(wx.ImageFromBitmap(self.image.GetBitmap()).GetData())


    def OnRightDown(self, e):
        self.image.Refresh()
        
    def OnLeftDown(self, e):
        point = (e.X, e.Y)
        self.coords.Value = "(%s,%s)" % point
        self.color.Value = "0x%s" % "".join(hex(v)[2:].upper()
                                            for v in self.im.getpixel(point))
        
        # draw crosshairs:
        dc = wx.ClientDC(self.image)
        dc.SetPen(wx.Pen("RED"))
        dc.DrawLine(e.X-2, e.Y, e.X, e.Y)
        dc.DrawLine(e.X, e.Y-2, e.X, e.Y)
        dc.DrawLine(e.X+2, e.Y, e.X, e.Y)
        dc.DrawLine(e.X, e.Y+2, e.X, e.Y)

    def getGC(self):
        gc = wx.GCDC(wx.ClientDC(self.image))
        ink = wx.Color(0x99, 0xcc, 0xff, 0x88)
        gc.SetPen(wx.Pen(ink))
        gc.SetBrush(wx.Brush(ink))
        return gc

# @TODO: re-enable drawWords. it was cool. :)
#    def drawWords(self):
#        chars = self.chars()
#        inks = wx.Color(0x99, 0xcc, 0xff, 0x88) , wx.Color(0x99, 0xff, 0xcc, 0x88)
#
#        gc = self.getGC()
#
#        i = 0
#        for c in chars:
#            if c[4] not in ('', ' '):
#
#                ink = inks[i % 2]
#                i += 1 
#                
#                gc.SetPen(wx.Pen(ink))
#                gc.SetBrush(wx.Brush(ink))
#                
#                gc.DrawRectangle(*c[:4])

#    def drawFirstUnkowns(self, cutoff=200, mode='L'):
#        "I *THINK* this was to show a new char to learn in context."
#        chars = self.chars(mode, cutoff) 
#
#        seen = {}
#        
#        gc = self.getGC()
#        ink = wx.Color(0xff, 0x00, 0x00, 0x88)
#        gc.SetPen(wx.Pen(ink))
#        gc.SetBrush(wx.Brush(ink))
#                
#        i = 0
#        for c in chars:
#            if type(c[4]) in (int,long):
#                if c[4] not in seen:
#                    gc.DrawRectangle(*c[:4])
#                    seen[c[4]]=True


#    def chars(self, mode='L', cutoff=200):
#        return list(scrape.letters(self.im.convert(mode), cutoff))
        

    def drawBaseLines(self, baseline_color='#99CCFF', linegap_color='#eeeeee'):
        img_out = self.im

        dc = self.getGC()

        y = 0
        w, h = img_out.size
        for (top, base, bottom) in scrape.guess_lines(img_out):

            # draw the baseline
            dc.SetPen(wx.Pen(baseline_color))

            if not base:
                base = bottom -2
                dc.SetPen(wx.RED_PEN)

            dc.DrawLines([(0,base),(w,base)])

            # shade out the other stuff
            dc.SetPen(wx.Pen(linegap_color))
            dc.SetBrush(wx.Brush(linegap_color))
            dc.DrawRectangle(0,y,w,top-y)
            y = bottom
            
        # shade bottom area
        dc.DrawRectangle(0,y,w,h-y)


    def OnCloseWindow(self, event):
        self.Destroy()
コード例 #54
0
ファイル: game.py プロジェクト: efunn/hemo-control
class Game(object):

    def __init__(self):

        ###############
        # load config #
        ###############
        with open('config.yaml') as f:
            CONFIG = yaml.load(f)
        with open('mvc.yaml') as f:
            MVC = yaml.load(f)
        self.subj_id = CONFIG['subject-id']
        self.subj_dir = 'datasets/' + self.subj_id
        self.loc = CONFIG['location']

        #################
        # set constants #
        #################
        if self.loc == 'lab':
            self.FRAME_RATE = 120
        elif self.loc == 'scanner':
            self.FRAME_RATE = 60
        self.SCREEN_WIDTH, self.SCREEN_HEIGHT = 1024, 768
        self.BG_COLOR_REG = 70,70,70
        self.BG_COLOR_REG_2 = 110,110,110
        self.BG_COLOR_REG_3 = 40,40,40
        self.SUCCESS_COLOR = 70,170,70
        self.FAIL_COLOR = 170,70,70
        self.INDICATOR_COLOR = 40,60,40
        self.INDICATOR_COLOR_2 = 30,100,30
        self.GOOD_MSG_COLOR = 160,255,160
        self.BAD_MSG_COLOR = 255,160,160
        self.A_MSG_COLOR = 160,160,255
        self.B_MSG_COLOR = 230,230,160
        self.REG_FIXATION_COLOR = 200,200,200
        self.GOOD_FIXATION_COLOR = self.SUCCESS_COLOR
        self.BAD_FIXATION_COLOR = 240,140,140

        self.BAD_SCORE_COLOR = 200,100,100
        self.GOOD_SCORE_COLOR = 100,200,100
        self.HIGHLIGHT_SCORE_COLOR = 20,255,20
        self.NORM_SCORE_COLOR = 180,180,100

        self.SENSOR_INPUT_OFFSET = np.array([0.5*self.SCREEN_WIDTH,
                                             0.75*self.SCREEN_HEIGHT])
        self.BORDER_COLOR_DICT = {'incomplete':(50,0,0),
                                  'ready':(0,0,50),
                                  'complete':(0,50,0),
                                  'disconnected':(50,0,0),
                                  'idle':(50,50,50),
                                  'rai':(0,50,0),
                                  'rfi':(0,50,0),
                                  'loc':(0,50,0),
                                  'nfb':(0,50,0)}
        self.BG_COLOR_DICT = {'incomplete':(100,0,0),
                              'ready':(0,0,100),
                              'complete':(0,100,0),
                              'disconnected':(100,0,0),
                              'idle':(100,100,100),
                              'rai':(0,100,0),
                              'rfi':(0,100,0),
                              'loc':(0,100,0),
                              'nfb':(0,100,0)}

        # dict entry for current timer set to use
        self.PRE_REST_TIME = {'trial':0}
        self.INTRO_TIME = {'trial':0}
        self.FEEDBACK_TIME = {'trial':0}
        self.ACTIVE_TIME = {'trial':0}
        self.TRIALS = {'trial':0}
        self.TRIAL_TIME = {'trial':0}
        self.INTRO_TRIGGER_TIME = {'trial':0}
        self.ACTIVE_TRIGGER_TIME = {'trial':0}
        self.FEEDBACK_TRIGGER_TIME = {'trial':0}

        # self-paced times
        self.PRE_REST_TIME['s_p'] = 3
        self.INTRO_TIME['s_p'] = 1
        self.FEEDBACK_TIME['s_p'] = 2
        self.ACTIVE_TIME['s_p'] = -1
        self.TRIALS['s_p'] = 5
        self.TRIAL_TIME['s_p'] = (self.PRE_REST_TIME['s_p'] + self.INTRO_TIME['s_p']
                               + self.FEEDBACK_TIME['s_p'])
        self.INTRO_TRIGGER_TIME['s_p'] = self.PRE_REST_TIME['s_p'] 
        self.ACTIVE_TRIGGER_TIME['s_p'] = self.PRE_REST_TIME['s_p'] + self.INTRO_TIME['s_p']
        self.FEEDBACK_TRIGGER_TIME['s_p'] = -1

        self.TRIAL_TYPES = 9
        self.trial_type_count = 0

        # localizer times
        # 40 seconds per trial
        # 480s per run
        self.PRE_REST_TIME['loc'] = 17
        self.INTRO_TIME['loc'] = 1
        self.ACTIVE_TIME['loc'] = 20
        self.FEEDBACK_TIME['loc'] = 2
        self.TRIALS['loc'] = 12

        # neurofeedback times
        # 60 seconds per trial
        # 480s per run
        self.PRE_REST_TIME['nfb'] = 27
        self.INTRO_TIME['nfb'] = 1
        self.ACTIVE_TIME['nfb'] = 30
        self.FEEDBACK_TIME['nfb'] = 2
        self.TRIALS['nfb'] = 8

        self.NFB_INFO_TIME = 0.5
        self.NFB_INFO_HEIGHT = 28
        self.MVC_TIME = 19

        self.INTRO_TRIGGER_TIME['loc'] = self.PRE_REST_TIME['loc'] 
        self.ACTIVE_TRIGGER_TIME['loc'] = self.PRE_REST_TIME['loc'] + self.INTRO_TIME['loc']
        self.FEEDBACK_TRIGGER_TIME['loc'] = self.ACTIVE_TRIGGER_TIME['loc'] + self.ACTIVE_TIME['loc'] 

        self.INTRO_TRIGGER_TIME['nfb'] = self.PRE_REST_TIME['nfb'] 
        self.ACTIVE_TRIGGER_TIME['nfb'] = self.PRE_REST_TIME['nfb'] + self.INTRO_TIME['nfb']
        self.FEEDBACK_TRIGGER_TIME['nfb'] = self.ACTIVE_TRIGGER_TIME['nfb'] + self.ACTIVE_TIME['nfb'] 
        self.CONTROL_TRIGGER_TIME = 1000*int(0.5*self.INTRO_TRIGGER_TIME['nfb'])
        self.BASELINE_CALC_SHIFT = self.PRE_REST_TIME['nfb']-10

        self.TRIAL_TIME['loc'] = (self.PRE_REST_TIME['loc'] + self.INTRO_TIME['loc']
                               + self.ACTIVE_TIME['loc'] + self.FEEDBACK_TIME['loc'])

        self.TRIAL_TIME['nfb'] = (self.PRE_REST_TIME['nfb'] + self.INTRO_TIME['nfb']
                               + self.ACTIVE_TIME['nfb'] + self.FEEDBACK_TIME['nfb'])

        #####################
        # control variables #
        #####################
        self.TR = 1.
        self.ADD_CONTROL_TRS = 5
        self.TF_CONTROL = self.ACTIVE_TIME['nfb']+self.ADD_CONTROL_TRS
        self.N_ACTIVE_TIME = self.ACTIVE_TIME['nfb']/self.TR+1
        self.N_CONTROL_STEPS = self.TF_CONTROL/self.TR+1
        self.CONTROL_MVC_MIN = 0.1
        self.CONTROL_MVC_MAX = 0.4
        self.u_vec = np.zeros((1,self.N_CONTROL_STEPS))
        self.y_vec = np.zeros(self.N_CONTROL_STEPS)
        gc.set_system(self)

        ##########################
        # force sensor variables #
        ##########################
        self.MVC_IN_PIXEL = 900
        self.MVC_MIN = 0#0.05
        self.ANGLE_ADD_DEG = 20
        self.ANGLE_ADD = np.deg2rad(self.ANGLE_ADD_DEG)
        self.ANGLE_MULT = 1+2*self.ANGLE_ADD/np.pi
        self.set_mvc(MVC['mvc'])
        self.DAQ_LPF_CUTOFF = 8
        self.DAQ_LPF_ORDER = 3

        self.CALIBRATE_BOOL = False # False or True
        if self.CALIBRATE_BOOL:
            fu.write_cal_header(self)

        if SENSOR_ACTIVE:
            if self.CALIBRATE_BOOL:
                self.daq = Pydaq('Dev3/ai0:2', self.FRAME_RATE,
                                 lp_filt_freq=14,
                                 lp_filt_order=3,
                                 force_params='force_params_cal.txt')
            else:
                self.daq = Pydaq('Dev3/ai0:1', self.FRAME_RATE,
                                 lp_filt_freq=self.DAQ_LPF_CUTOFF,
                                 lp_filt_order=self.DAQ_LPF_ORDER,
                                 force_params='force_params_lab.txt')
            self.scanner_daq = Pydaq('Dev1/ai2:3', self.FRAME_RATE,
                                     lp_filt_freq=self.DAQ_LPF_CUTOFF,
                                     lp_filt_order=self.DAQ_LPF_ORDER,
                                     force_params='force_params_scanner.txt')

        ########################
        # networking variables #
        ########################
        IP = CONFIG['server-ip']
        PORT = CONFIG['server-port']
        self.SERVER_TARGET = 'http://{ip}:{port}/'.format(ip=IP,
                                                          port=PORT)
        self.requests_running_bool = mp.Value('i', 1)
        self.last_volume_received = mp.Value('i', 0)
        self.pool = mp.Pool()

        self.insta_mode = 'disconnected' # idle, rai, rfi, loc, nfb
        self.roi_name = 'm1_left_a'
        self.next_run_msg = ''
        self.insta_complete = OrderedDict()
        self.insta_complete['roi'] = 'incomplete'
        self.insta_complete['rai'] = 'incomplete'
        self.insta_complete['rfi'] = 'incomplete'
        self.insta_complete['warp2rfi'] = 'incomplete'
        self.insta_complete['glm'] = 'incomplete'
        self.insta_complete['loc'] = 'incomplete'

        self.raw_betas = {'active':0.,
                          'force':0.,
                          'complexity':0.,
                          'constant':0.}

        self.psc_betas = {'active':0.5,
                          'force':1.5,
                          'complexity':1.0}

        self.MAX_CONTROL = 3
        self.MIN_CONTROL = 0.5
        self.PSC_TARGET_LIST = [1.5,1.5,1.5,1.5]
        self.RUN_TYPE_LIST = CONFIG['run-type-list']

        self.NFB_TRS = int(self.TRIAL_TIME['nfb']
                           *self.TRIALS['nfb']/self.TR)
        self.bold_rois_array = []
        self.bold_rois_array.append(mp.Array('d',self.NFB_TRS))
        self.REQUEST_WAIT_TIME = 0.1
        self.requests_process = mp.Process(target = gn.requests_loop,
                                           args = (self.SERVER_TARGET,
                                                   self.REQUEST_WAIT_TIME,
                                                   self.requests_running_bool,
                                                   self.last_volume_received,
                                                   self.bold_rois_array,))

        ####################################################
        # start pygame and initialize default game objects #
        ####################################################
        pygame.init()
        pygame.mouse.set_visible(not pygame.mouse.set_visible)
        self.clock = pygame.time.Clock()
        if CONFIG['fullscreen']:
            self.screen = pygame.display.set_mode(
                            (self.SCREEN_WIDTH, self.SCREEN_HEIGHT),
                             pygame.FULLSCREEN)
        else:
            self.screen = pygame.display.set_mode(
                            (self.SCREEN_WIDTH, self.SCREEN_HEIGHT))

        ##################################
        # initialize custom game objects #
        ##################################
        self.CURSOR_RAD = 75
        self.FIXATION_WIDTH = 1.5*self.CURSOR_RAD
        self.FIXATION_HEIGHT = 8
        self.cursor = Cursor(self.screen, self.CURSOR_RAD)
        self.timers = {}
        self.init_timers()

        self.TARGET_SUCCESS_TIME = .15
        self.TARGET_MIN_TIME = .5
        self.TARGET_RAD_MIN = -25
        self.TARGET_RAD_MAX = 45

        #####################
        # target lists here #
        #####################

        # function to generate x length, all same mvc,
        # all same phase
        # and do {20s length} x {.1, .2, .4} x {0, 180}
        self.MVC_LIST = []
        self.PHASE_LIST = []
        self.MVC_LIST.append(np.array([.1,.1,.1,.1,.1,.1,.1,.1,.1,.1,.1,.1,.1,.1,.1,.1,.1,.1,.1,.1]))
        self.MVC_LIST.append(np.array([.2,.2,.2,.2,.2,.2,.2,.2,.2,.2,.2,.2,.2,.2,.2,.2,.2,.2,.2,.2]))
        self.MVC_LIST.append(np.array([.4,.4,.4,.4,.4,.4,.4,.4,.4,.4,.4,.4,.4,.4,.4,.4,.4,.4,.4,.4]))
        self.PHASE_LIST.append(np.array([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]))
        self.PHASE_LIST.append(np.array([180,180,180,180,180,180,180,180,180,180,180,180,180,180,180,180,180,180,180,180]))

        self.TRAINING_TARGET_LOC_LIST = []

        self.loc_target_order = [0,3,1,4,2,5,1,4,0,5,3,2]

        for mvc in self.MVC_LIST:
            for phase in self.PHASE_LIST:
                self.TRAINING_TARGET_LOC_LIST.append(self.gen_target_list(mvc,phase))

        self.next_mvc_list = []
        self.next_phase_list = []
        self.next_target_loc_list = []

        # auto-generate 1, 1.5, and 2 psc from dummy data
        for psc_target in (1.,1.5,2.):
            new_targets = self.gen_control_targets(psc_target)
            self.TRAINING_TARGET_LOC_LIST.append(new_targets)

        self.SAMPLE_MVC_LIST = np.array([.4,.1,.2,.1,.2,.4])
        self.SAMPLE_PHASE_LIST = np.array([0,0,0,180,180,180])
        self.SAMPLE_TARGET_LOC_LIST = self.gen_target_list(self.SAMPLE_MVC_LIST,
                                                           self.SAMPLE_PHASE_LIST)
        self.set_targets(self.SAMPLE_TARGET_LOC_LIST)

        ######################
        # set game variables #
        ######################
        self.screen_mid = np.array([0.5*self.screen.get_width(),
                                    0.5*self.screen.get_height()])
        self.bg_color = self.BG_COLOR_REG_3
        self.fixation_color = self.REG_FIXATION_COLOR
        self.input_mode = 'mouse'
        self.input_pos = np.array([0.0,0.0])
        self.input_force = np.array([0.0,0.0])
        self.cal_force = 0.
        self.debug_bool = False
        self.nfb_info_bool = False
        self.run_mode = 'idle' # idle, mvc, trials
        self.run_type = 's_p'
        self.self_paced_bool = True
        self.controller_active_bool = False
        self.controller_calc_bool = False
        self.nfb_run_count = 0
        self.calc_score_bool = False
        self.trial_time_array = np.array(())
        self.set_timer_mode('s_p')
        self.current_score = 0
        self.score_color = self.GOOD_SCORE_COLOR
        self.score_fixation_status = 'norm'
        self.max_rec_mvc_both = 0
        self.max_rec_mvc_x = 0
        self.max_rec_mvc_y = 0
        self.MVC_DISPLAY_CEIL = 100.

    def gen_target_list(self, mvc_list, phase_list):
        mvc_list = np.ravel(mvc_list)
        phase_list = np.ravel(phase_list)
        target_list = np.zeros((2,2*len(mvc_list)))
        for idx in range(len(mvc_list)):
            if phase_list[idx] == 0:
                target_list[0][2*idx] = 0
                target_list[1][2*idx] = -self.MVC_IN_PIXEL*mvc_list[idx]
                target_list[0][2*idx+1] = 0
                target_list[1][2*idx+1] = -self.MVC_IN_PIXEL*self.MVC_MIN
            elif phase_list[idx] == 180:
                target_list[0][2*idx] = self.MVC_IN_PIXEL*mvc_list[idx]
                target_list[1][2*idx] = -self.MVC_IN_PIXEL*self.MVC_MIN
                target_list[0][2*idx+1] = -self.MVC_IN_PIXEL*mvc_list[idx]
                target_list[1][2*idx+1] = -self.MVC_IN_PIXEL*self.MVC_MIN
        return np.transpose(target_list)

    def set_mvc(self, mvc):
        self.newtons_2_pixel_both = self.MVC_IN_PIXEL/(.5*mvc['both'])
        self.newtons_2_pixel_x = self.MVC_IN_PIXEL/(mvc['x'])
        self.newtons_2_pixel_y = self.MVC_IN_PIXEL/(mvc['y'])

    def set_targets(self, target_list):
        self.targets = []
        # set targets
        for target_loc in target_list:
            target_rad = (self.TARGET_RAD_MAX - 
                          (self.TARGET_RAD_MAX - self.TARGET_RAD_MIN)
                           * np.sqrt(target_loc[0]**2 + target_loc[1]**2)
                            /float(self.MVC_IN_PIXEL))
            self.targets.append(Target(self.screen,
                                       target_loc,
                                       self.SENSOR_INPUT_OFFSET,
                                       target_rad,
                                       self.CURSOR_RAD,
                                       self.TARGET_SUCCESS_TIME,
                                       self.TARGET_MIN_TIME))
        # link targets
        self.current_target = self.targets[0]
        self.targets[0].prev_target = None
        self.targets[-1].next_target = None
        for idx in range(len(self.targets)-1):
            self.targets[idx].next_target = self.targets[idx+1]
            self.targets[idx+1].prev_target = self.targets[idx]

    def get_pos(self):
        if self.input_mode=='mouse' or not(SENSOR_ACTIVE):
            return pygame.mouse.get_pos()
        else:
            if self.loc == 'lab':
                f_in_x, f_in_y = self.daq.get_force()
            elif self.loc == 'scanner':
                f_in_x, f_in_y = self.scanner_daq.get_force()
            self.input_force = f_in_x, f_in_y
            f_mag = max(f_in_x, f_in_y)
            f_ang = np.arctan2(f_in_x, f_in_y)
            f_out_x = f_mag*np.cos(2*self.ANGLE_MULT*f_ang-self.ANGLE_ADD)
            f_out_y = f_mag*np.sin(2*self.ANGLE_MULT*f_ang-self.ANGLE_ADD)
            ang_blend = (f_ang-.25*np.pi)/(.25*np.pi)
            ang_blend_both = (max(0,(1-abs(ang_blend)))
                              *self.newtons_2_pixel_both)
            if ang_blend < 0:
                ang_blend_side = abs(ang_blend)*self.newtons_2_pixel_y
            else:
                ang_blend_side = abs(ang_blend)*self.newtons_2_pixel_x
            newtons_2_pixel = ang_blend_both + ang_blend_side
            pos_x = (self.SENSOR_INPUT_OFFSET[0]
                     +newtons_2_pixel*f_out_x)
            pos_y = (self.SENSOR_INPUT_OFFSET[1]
                     -newtons_2_pixel*f_out_y)
            return (pos_x, 
                    pos_y)

    def init_timers(self):
        self.timers['loc'] = Timer(self.TRIAL_TIME['loc'],
                                   self.TRIALS['loc'])
        self.timers['nfb'] = Timer(self.TRIAL_TIME['nfb'],
                                   self.TRIALS['nfb'])
        self.timers['s_p'] = Timer(self.TRIAL_TIME['s_p'],
                                   self.TRIALS['s_p'])
        self.timers['trial'] = self.timers['loc']
        self.timers['move'] = Timer(sys.maxint)
        self.timers['mvc'] = Timer(self.MVC_TIME)
        self.timers['nfb_info'] = Timer(self.NFB_INFO_TIME)

    def set_timer_mode(self, mode):
        self.timers['trial'] = self.timers[mode]
        self.PRE_REST_TIME['trial'] = self.PRE_REST_TIME[mode]*1000
        self.INTRO_TIME['trial'] = self.INTRO_TIME[mode]*1000
        self.FEEDBACK_TIME['trial'] = self.FEEDBACK_TIME[mode]*1000
        self.ACTIVE_TIME['trial'] = self.ACTIVE_TIME[mode]*1000
        self.TRIALS['trial'] = self.TRIALS[mode]*1000
        self.TRIAL_TIME['trial'] = self.TRIAL_TIME[mode]*1000
        self.INTRO_TRIGGER_TIME['trial'] = self.INTRO_TRIGGER_TIME[mode]*1000
        self.ACTIVE_TRIGGER_TIME['trial'] = self.ACTIVE_TRIGGER_TIME[mode]*1000
        self.FEEDBACK_TRIGGER_TIME['trial'] = self.FEEDBACK_TRIGGER_TIME[mode]*1000


    def reset_all_timers(self):
        for k,t in self.timers.iteritems():
            t.reset()


    def check_input(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                self.quit()
            elif event.type == pygame.KEYDOWN:
                if event.key == pygame.K_ESCAPE:
                    self.quit()
                elif event.key == pygame.K_0:
                    if self.loc == 'lab':
                        self.daq.set_volts_zero()
                    elif self.loc == 'scanner':
                        self.scanner_daq.set_volts_zero()
                elif event.key == pygame.K_m:
                    if self.input_mode == 'mouse':
                        self.input_mode = 'sensor'
                    elif self.input_mode == 'sensor':
                        self.input_mode = 'mouse'
                elif event.key == pygame.K_d:
                    self.debug_bool = not self.debug_bool
                elif event.key == pygame.K_s:
                    self.nfb_info_bool = not self.nfb_info_bool
                elif event.key == pygame.K_SPACE:
                    self.run_type = 's_p'
                    gr.reset_for_next_run(self)
                    self.run_mode = 'trials'
                elif event.key == pygame.K_7:
                    self.run_mode = 'mvc'
                elif event.key == pygame.K_8:
                    gn.set_mode('loc', self.SERVER_TARGET)
                    self.run_type = 'loc'
                    self.next_run_msg = 'Ready for Localizer'
                elif event.key == pygame.K_9:
                    gn.set_mode('nfb', self.SERVER_TARGET)
                    self.run_type = 'nfb'
                    self.next_run_msg = ('Ready for Run '
                        + str(game.nfb_run_count + 1) + ' of 4')
                elif event.key == pygame.K_5:
                    if ((self.run_type == 'loc'
                            or self.run_type == 'nfb')
                            and self.run_mode == 'idle'):
                        self.run_mode = 'trials'
                        self.next_run_msg = ''
                        gr.reset_for_next_run(self)
                # control of insta_server
                elif event.key == pygame.K_g:
                    gn.set_mode('idle', self.SERVER_TARGET)
                elif event.key == pygame.K_h:
                    gn.set_mode('rai', self.SERVER_TARGET)
                elif event.key == pygame.K_j:
                    gn.set_mode('rfi', self.SERVER_TARGET)
                elif event.key == pygame.K_k:
                    gn.set_mode('loc', self.SERVER_TARGET)
                elif event.key == pygame.K_l:
                    gn.set_mode('nfb', self.SERVER_TARGET)
                # testing controls
                # elif event.key == pygame.K_z:
                #     # figure out when/where to calculate this (add trigger)
                #     # need baseline calculation
                #     # and y_vec calculation
                #     psc_target = 2.
                #     # self.pool.apply_async(func = gc.calc_control,
                #     #                       args = (self,
                #     #                               psc_target,
                #     #                               self.u_vec,
                #     #                               self.y_vec),
                #     #                       callback = self.update_control_targets)
                #     u_vec = gc.calc_control(self,
                #                     psc_target,
                #                     self.u_vec,
                #                     self.y_vec)
                #     self.update_control_targets(u_vec)


    def run(self):
        fu.write_trial_s_p_header(self)
        fu.write_control_file(self)
        fu.write_all_headers_timed(self)
        self.requests_process.start()
        while True:
            time_passed = self.clock.tick_busy_loop(self.FRAME_RATE)
            self.check_input()
            self.input_pos = self.get_pos()
            self.cursor.update(self.input_pos)
            if self.current_target != None:
                self.cursor.update_warn(time_passed,
                                        not(self.current_target.success))
            else:
                self.cursor.update_warn(time_passed,
                                        False)
            self.draw_background()

            if self.run_mode == 'trials':
                gr.frame_based_updates(game, time_passed)

            if self.debug_bool:
                self.draw_debug(time_passed)
            if self.nfb_info_bool:
                self.draw_nfb_info(time_passed)
            if self.run_mode == 'mvc':
                gr.run_mvc(self, time_passed)
            else:
                self.cursor.draw()
            pygame.display.flip()

    def draw_targets(self):
        current_bool = self.current_target != None
        if current_bool:
            next_bool = self.current_target.next_target != None
        else:
            next_bool = False
        if next_bool:
            next_next_bool = self.current_target.next_target.next_target != None
        else:
            next_next_bool = False
        if next_next_bool:
            self.current_target.next_target.next_target.draw(draw_type='next_next')
        if next_bool:
            self.current_target.next_target.draw(draw_type='next')
        if current_bool:
            self.current_target.draw(draw_type='current')


    def draw_debug(self, time_passed):
        fr = 1000/float(time_passed)
        fr_msg = 'frame rate: ' + str(fr)
        x_v_msg = 'x force: ' + str(self.input_force[0])
        y_v_msg = 'y force: ' + str(self.input_force[1])
        betas_active_msg = 'active beta: ' + str(self.psc_betas['active'])
        betas_force_msg = 'force beta: ' + str(self.psc_betas['force'])
        betas_complexity_msg = 'complexity beta: ' + str(self.psc_betas['complexity'])
        lvr_msg = 'last vol: ' + str(self.last_volume_received.value)

        gg.draw_msg(self.screen, fr_msg,
                    loc='left', pos=(10,33), size=28)
        gg.draw_msg(self.screen, x_v_msg,
                    loc='left', pos=(10,66), size=28)
        gg.draw_msg(self.screen, y_v_msg,
                    loc='left', pos=(10,99), size=28)
        gg.draw_msg(self.screen, betas_active_msg,
                    loc='left', pos=(10,132), size=28)
        gg.draw_msg(self.screen, betas_force_msg,
                    loc='left', pos=(10,165), size=28)
        gg.draw_msg(self.screen, betas_complexity_msg,
                    loc='left', pos=(10,198), size=28)
        gg.draw_msg(self.screen, lvr_msg,
                    loc='left', pos=(10,231), size=28)

        if self.CALIBRATE_BOOL:
            self.cal_force = self.daq.force_transform_cal(
                                        self.daq.get_volts_cal())
            z_v_msg = 'z lbs: ' + str(self.cal_force)
            gg.draw_msg(self.screen, z_v_msg,
                        loc='left', pos=(10,231), size=28)
            fu.cal_record(self, self.f_cal)

    def draw_nfb_info(self, time_passed):
        self.timers['nfb_info'].update(time_passed)
        if self.timers['nfb_info'].time_limit_hit:
            self.pool.apply_async(func = gn.get_complete,
                                  args = (self.SERVER_TARGET,
                                          self.insta_complete),
                                  callback = self.update_complete)
            self.pool.apply_async(func = gn.get_mode,
                                  args = (self.SERVER_TARGET,),
                                  callback = self.update_mode)
            self.pool.apply_async(func = gn.get_betas,
                                  args = (self.SERVER_TARGET,
                                          self.roi_name,
                                          self.raw_betas),
                                  callback = self.update_betas)
            self.timers['nfb_info'].time_limit_hit = False
            self.timers['nfb_info'].count = 0

        # show insta_mode and insta_complete
        list_count = 0
        for k,v in self.insta_complete.iteritems():
            gg.draw_info_rect(self.screen, k + ': ' + v,
                              (255,255,255),self.BORDER_COLOR_DICT[v],
                              self.BG_COLOR_DICT[v],350,
                               self.NFB_INFO_HEIGHT,200,
                               50 + list_count*(8+self.NFB_INFO_HEIGHT))
            list_count += 1
        gg.draw_info_rect(self.screen, 'mode: ' + self.insta_mode,
                          (255,255,255),self.BORDER_COLOR_DICT[self.insta_mode],
                          self.BG_COLOR_DICT[self.insta_mode],350,
                           self.NFB_INFO_HEIGHT,200,
                           65 + list_count*(8+self.NFB_INFO_HEIGHT),
                           border_size=12)

    def update_complete(self, insta_complete):
        self.insta_complete = insta_complete

    def update_betas(self, raw_betas):
        self.raw_betas = raw_betas
        if self.raw_betas['constant'] != 0:
            for k,v in self.psc_betas.iteritems():
                self.psc_betas[k] = 100*self.raw_betas[k]/self.raw_betas['constant']
            gc.set_control_limits(self, self.psc_betas)

    def update_control_targets(self, u_vec):
        self.u_vec = self.u_vec + u_vec
        u_vec_reduced = np.ravel(self.u_vec)
        u_vec_reduced = u_vec_reduced[0:self.N_ACTIVE_TIME]
        self.next_mvc_list, self.next_phase_list = gc.betas_to_mvc_phase(self,
                                                                         self.psc_betas,
                                                                         u_vec_reduced)
        self.next_target_loc_list = self.gen_target_list(self.next_mvc_list,
                                                         self.next_phase_list)
        self.set_targets(self.next_target_loc_list)

    def calc_y_psc(self):
        trial_num = self.timers['trial'].count-1
        begin_rest_idx = trial_num*self.TRIAL_TIME['nfb'] + self.BASELINE_CALC_SHIFT
        end_rest_idx = begin_rest_idx + self.PRE_REST_TIME['nfb'] - self.BASELINE_CALC_SHIFT + self.INTRO_TIME['nfb']
        begin_move_idx = end_rest_idx
        end_move_idx = begin_move_idx + self.ACTIVE_TIME['nfb'] + 1
        rest_mean = 10e-9+np.mean(self.bold_rois_array[0][begin_rest_idx:end_rest_idx])
        y_vec_psc = (100*(self.bold_rois_array[0][begin_move_idx:end_move_idx]-rest_mean)
                     /rest_mean)
        self.y_vec[0:self.N_ACTIVE_TIME] = y_vec_psc[0:self.N_ACTIVE_TIME] 
        self.y_vec[self.N_ACTIVE_TIME:] = np.mean(y_vec_psc[self.N_ACTIVE_TIME
                                                            - self.ADD_CONTROL_TRS
                                                            :self.N_ACTIVE_TIME])

    def gen_control_targets(self, psc_target):
        u_vec = gc.calc_control(self, psc_target)
        u_vec_reduced = u_vec[0:self.N_ACTIVE_TIME]
        mvc_list, phase_list = gc.betas_to_mvc_phase(self,
                                                     self.psc_betas,
                                                     u_vec_reduced)
        return self.gen_target_list(mvc_list,
                                    phase_list)

    def update_mode(self, mode):
        self.insta_mode = mode

    def increment_target(self):
        self.current_target = self.current_target.next_target

    def draw_background(self):
        self.screen.fill(self.bg_color)
        if self.run_mode == 'idle' and self.loc == 'lab':
            instr_msg = ('Press Space for Run ' + str(self.trial_type_count+1)
                         + ' of ' + str(self.TRIAL_TYPES))
            gg.draw_msg(self.screen, instr_msg,
                        loc='center', pos=(.5*self.SCREEN_WIDTH,
                                           .5*self.SCREEN_HEIGHT), size=48)
        if self.next_run_msg != '':
            gg.draw_msg(self.screen, self.next_run_msg,
                        loc='center', pos=(.5*self.SCREEN_WIDTH,
                                           .4*self.SCREEN_HEIGHT), size=48)

    def quit(self):
        self.requests_running_bool.value = 0
        self.requests_process.join()
        sys.exit()
コード例 #55
0
ファイル: logger.py プロジェクト: 568/ThirdPlugin
class Logger(object):
    # TODO: check screen height before log messages
    debuggable = False
    debug_messages_queue = Queue.Queue()
    temp_backup_queue = Queue.Queue()
    info_message_array = []
    TPL_DEBUG_MESSAGE = '[DEBUG] {}'

    def __init__(self, debuggable=False, interval=0.1, unit="s"):
        self.debuggable = debuggable
        self.interval = interval
        self.unit = unit

        if not is_windows_system():
            from cursor import Cursor
            from terminal import Terminal
            self.cursor = Cursor(Terminal())

        self.sorted_tasks = []

        self.tpl_running_task = '[+][{}] {} in {}{}\n'
        self.tpl_waiting_task = '[+][{}] {}\n'
        self.tpl_finished_task = '[-][{}] {} in {}{}\n'
        # self.tpl_faied_task = '[-]{}:{} in {}{}\n'
        logging.basicConfig(level=logging.DEBUG)

    def set_sorted_tasks(self, sorted_tasks):
        self.sorted_tasks = sorted_tasks

    def draw(self):
        # if len(self.sorted_tasks) > 0:
        self.cursor.restore()
        self._draw()
        self.cursor.flush()

    def clear_space(self):
        self.cursor.restore()
        self.cursor.clear_lines(self._calculate_lines_num())
        self.cursor.save()

    def update(self):
        self.clear_space()
        self.draw()

    def reset(self):
        if not self.debuggable:
            self.clear_space()
        self.sorted_tasks = []
        Logger.info_message_array = []

    @staticmethod
    def info(message):
        Logger.info_message_array.append(message)

    @staticmethod
    def debug(message):
        Logger.debug_messages_queue.put(message)
        Logger.temp_backup_queue.put(message)

    @staticmethod
    def warn(message):
        pass

    @staticmethod
    def error(message):
        pass

    @staticmethod
    def print_debug_message(message):
        if isinstance(message, dict) or isinstance(message, list):
            print_json(message)
        else:
            print(Logger.TPL_DEBUG_MESSAGE.format(message))

    @staticmethod
    def flush_debug_messages():
        while not Logger.debug_messages_queue.empty():
            message = Logger.debug_messages_queue.get()
            Logger.print_debug_message(message)

    @staticmethod
    def write_error_log(exception=None, extra=None):
        import json
        try:
            log_path = get_error_log_path()
            with open(log_path, 'w') as fp:
                while not Logger.temp_backup_queue.empty():
                    message = Logger.temp_backup_queue.get(timeout=0.5)
                    if isinstance(message, dict) or isinstance(message, list):
                        fp.write(json.dumps(message, indent=4, separators=(',', ': ')))
                    else:
                        fp.write(message)
                    fp.write('\n')

                # write extra info
                if exception:
                    fp.write(exception)
            return log_path
        except Exception as e:
            print(traceback.format_exc())
            print(e.message)
            return None

    def _calculate_lines_num(self):
        lines_count = 0
        for task in self.sorted_tasks:
            if task.can_show_log:
                lines_count += 1
        return lines_count + len(Logger.info_message_array) + 1

    def _draw(self):
        # map(lambda task: self.cursor.write(self._get_formatted_message(task)), self.sorted_tasks)
        map(lambda message: self.cursor.write(message + '\n'), Logger.info_message_array)
        map(lambda task: self.cursor.write(self._get_formatted_message(task)),
            filter(lambda task: task.can_show_log(), self.sorted_tasks))

    def _get_formatted_message(self, task):
        return {
            FAILURE: self.tpl_finished_task.format(task.name, 'failed.', task.cost_time, self.unit),
            READY: self.tpl_running_task.format(task.name, 'not start.', 'N/A', self.unit),
            WAITING: self.tpl_waiting_task.format(task.name, 'waiting...'),
            WORKING: self.tpl_running_task.format(task.name, task.running_message,
                                                  round(time.time() - task.run_start_time, 1), self.unit),
            SUCCESS: self.tpl_finished_task.format(task.name, task.finished_message, task.cost_time, self.unit)
        }.get(task.status, 'NULL')
コード例 #56
0
ファイル: program.py プロジェクト: damasko/a_star
    def execute(self):

        self.salir = False

        while not self.salir:

            self.clock.tick(self.velocidad)

            # eventos de teclado

            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    self.salir = True
                if event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_SPACE:
                        self.pausa = True

            # submenu

            if self.pausa:
                while self.pausa:

                    self.clock.tick(self.velocidad)

                    for event in pygame.event.get():
                        if event.type == pygame.QUIT:
                            self.pausa = False
                            self.salir = True
                        if event.type == pygame.KEYDOWN:
                            if event.key == pygame.K_SPACE:

                                self.pausa = False

                            if event.key == pygame.K_2:
                                if self.velocidad_algoritmo < 30:
                                    self.velocidad_algoritmo += 1
                            if event.key == pygame.K_1:
                                if self.velocidad_algoritmo > 0:
                                    self.velocidad_algoritmo -= 1

                            if event.key == pygame.K_d:
                                if self.cursor.modo_borrar:
                                    self.cursor.modo_borrar = False
                                    self.texto = self.fuente.render("Pausado",
                                                True, (255, 0, 255))
                                else:
                                    self.cursor.modo_borrar = True
                                    self.texto = self.fuente.render("Pausado  Modo borrar paredes",
                                                True, (255, 0, 255))

                            if event.key == pygame.K_r:
                                self.tablero.matrix = self.tablero.rellenaRandom()
                                self.pathfinder.reset()
                                self.tablero.reset_ab()

                    if pygame.key.get_pressed()[pygame.K_l] and pygame.key.get_pressed()[pygame.K_n]:

                        self.tablero = Tablero(80, 80)
                        self.pathfinder = PathFinder(self.tablero)
                        self.cursor = Cursor(self.tablero, self.pathfinder)

                    #updates
                    self.cursor.update()
                    self.cursor.changeState()

                    self.texto_algo = self.fuente.render("Velocidad: " + str(self.velocidad_algoritmo),
                                True, (255, 0, 255))

                    # draws
                    self.screen.fill((0, 0, 0))
                    self.draw_matriz()
                    self.screen.blit(self.texto, (8, self.screen.get_height() - 28))
                    self.screen.blit(self.texto_algo, (self.screen.get_width() - 200,
                                 self.screen.get_height() - 28))
                    pygame.draw.rect(self.screen, (250, 0, 0), self.cursor.rect)
                    pygame.display.update()

             #pathfinder

            #self.pathfinder.run2()
            for i in range(self.velocidad_algoritmo):
                self.pathfinder.run()  # el que funciona
            # updates
            self.cursor.update()

            # draws
            self.screen.fill((0, 0, 0))
            self.draw_matriz()
            pygame.display.update()
コード例 #57
0
ファイル: program.py プロジェクト: damasko/a_star
class Program(object):

    def __init__(self):

        self.tablero = Tablero(80, 80)

        self.screen = pygame.display.set_mode((len(self.tablero.matrix[0]) * 10,
                    len(self.tablero.matrix) * 10 + 32), pygame.DOUBLEBUF)

        pygame.display.set_caption("Pathfinder")

        self.clock = pygame.time.Clock()

        self.pausa = True
        self.velocidad = 100
        self.velocidad_algoritmo = 8

        # a star
        self.pathfinder = PathFinder(self.tablero)

        # cursor
        self.cursor = Cursor(self.tablero, self.pathfinder)

        #fuente
        pygame.font.init()
        self.fuente = pygame.font.SysFont("default", 24)
        self.texto = self.fuente.render("Pausado", True, (255, 0, 255))
        self.texto_algo = self.fuente.render("Velocidad: " + str(self.velocidad_algoritmo),
                                True, (255, 0, 255))



    def draw_matriz(self):

        for linea in self.tablero.matrix:
            for casilla in linea:

                if casilla.estado == "D":

                    pygame.draw.rect(self.screen, (100, 40, 0), casilla.rect)

                elif casilla.estado == "A":

                    pygame.draw.rect(self.screen, (255, 255, 0), casilla.rect)

                elif casilla.estado == "B":

                    pygame.draw.rect(self.screen, (0, 255, 100), casilla.rect)

                else:

                    pygame.draw.rect(self.screen, (20, 170, 170), casilla.rect)

        for posibles in self.pathfinder.open_list:
            pygame.draw.rect(self.screen, (0, 0, 0), posibles.rect)

        if self.pathfinder.encontrado:
            for casillas in self.pathfinder.ruta:
                pygame.draw.rect(self.screen, (0, 255, 0), casillas.rect)
        else:
            for analizados in self.pathfinder.closed_list:
                pygame.draw.rect(self.screen, (255, 255, 240), analizados.rect)

    def execute(self):

        self.salir = False

        while not self.salir:

            self.clock.tick(self.velocidad)

            # eventos de teclado

            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    self.salir = True
                if event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_SPACE:
                        self.pausa = True

            # submenu

            if self.pausa:
                while self.pausa:

                    self.clock.tick(self.velocidad)

                    for event in pygame.event.get():
                        if event.type == pygame.QUIT:
                            self.pausa = False
                            self.salir = True
                        if event.type == pygame.KEYDOWN:
                            if event.key == pygame.K_SPACE:

                                self.pausa = False

                            if event.key == pygame.K_2:
                                if self.velocidad_algoritmo < 30:
                                    self.velocidad_algoritmo += 1
                            if event.key == pygame.K_1:
                                if self.velocidad_algoritmo > 0:
                                    self.velocidad_algoritmo -= 1

                            if event.key == pygame.K_d:
                                if self.cursor.modo_borrar:
                                    self.cursor.modo_borrar = False
                                    self.texto = self.fuente.render("Pausado",
                                                True, (255, 0, 255))
                                else:
                                    self.cursor.modo_borrar = True
                                    self.texto = self.fuente.render("Pausado  Modo borrar paredes",
                                                True, (255, 0, 255))

                            if event.key == pygame.K_r:
                                self.tablero.matrix = self.tablero.rellenaRandom()
                                self.pathfinder.reset()
                                self.tablero.reset_ab()

                    if pygame.key.get_pressed()[pygame.K_l] and pygame.key.get_pressed()[pygame.K_n]:

                        self.tablero = Tablero(80, 80)
                        self.pathfinder = PathFinder(self.tablero)
                        self.cursor = Cursor(self.tablero, self.pathfinder)

                    #updates
                    self.cursor.update()
                    self.cursor.changeState()

                    self.texto_algo = self.fuente.render("Velocidad: " + str(self.velocidad_algoritmo),
                                True, (255, 0, 255))

                    # draws
                    self.screen.fill((0, 0, 0))
                    self.draw_matriz()
                    self.screen.blit(self.texto, (8, self.screen.get_height() - 28))
                    self.screen.blit(self.texto_algo, (self.screen.get_width() - 200,
                                 self.screen.get_height() - 28))
                    pygame.draw.rect(self.screen, (250, 0, 0), self.cursor.rect)
                    pygame.display.update()

             #pathfinder

            #self.pathfinder.run2()
            for i in range(self.velocidad_algoritmo):
                self.pathfinder.run()  # el que funciona
            # updates
            self.cursor.update()

            # draws
            self.screen.fill((0, 0, 0))
            self.draw_matriz()
            pygame.display.update()
コード例 #58
0
ファイル: pngscraper.py プロジェクト: mehulsbhatt/snakeeyes
    def __init__(self, *args, **kwargs):

        wx.Frame.__init__(self, *args, **kwargs)


        self.createMenu()

        #self.pngs = ['c:/temp/mibook.png']
        self.pngs = GetPngList(PNGDIR)
        
        self.cursor = Cursor(ListView(self.pngs))

        box = wx.BoxSizer(wx.VERTICAL)

        # next button

        row = wx.BoxSizer(wx.HORIZONTAL)


        def CursorButton(label):
            b = wx.Button(self, label= label)
            b.Bind(wx.EVT_BUTTON, self.OnCursorButton)
            return b
            
        row.Add(CursorButton("<<"))
        row.Add(CursorButton("<"))

        self.which =  wx.TextCtrl(self, -1, '')
        self.updateWhich()
        row.Add(self.which)

        row.Add(CursorButton(">"))
        row.Add(CursorButton(">>"))

        # coords box
        self.coords = wx.TextCtrl(self, -1, '(0,0)')
        row.Add(self.coords, 0, wx.ALIGN_RIGHT)
        row.Add((20,20),1)

        # color box
        self.color = wx.TextCtrl(self, -1, '0x000000')
        row.Add(self.color, 0, wx.ALIGN_RIGHT)
        row.Add((20,20),1)
        
        box.Add(row, 0, wx.ALIGN_CENTER_HORIZONTAL)

        # the image

        pane = wx.ScrolledWindow(self, -1, size=(300,400))
        box.Add(pane, 0, wx.ALIGN_CENTER_HORIZONTAL|wx.ALL|wx.ADJUST_MINSIZE)
        
        self.image = wx.StaticBitmap(pane, bitmap=wx.EmptyBitmap(800, 600))
        self.image.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
        self.image.Bind(wx.EVT_RIGHT_DOWN, self.OnRightDown)
        self.updateImage()

        # the shell
        self.locals = {'self':self, 'wx':wx, 'hook': lambda:None, 'gc':self.getGC() }
        self.shell = py.shell.Shell(self, locals=self.locals)
        self.shell.SetMinSize((500,400))
        box.Add(self.shell, 4, wx.EXPAND)
        self.shell.SetFocus()
        
        self.SetSizerAndFit(box)
        wx.EVT_CLOSE(self, self.OnCloseWindow)
コード例 #59
0
ファイル: Game.py プロジェクト: ltsissykitty/Game
from cursor import Cursor
 
#Main  
pygame.init()
screenwidth = 640
screenheight = 480
screen = pygame.display.set_mode((screenwidth, screenheight))
pygame.display.set_caption('Game')

#game clock
FPS = 20
clock = pygame.time.Clock()

trooper = Unit(screen, 'trooper', 'spritesheets/trooper.bmp')
background = Background(screen)
cursor = Cursor(screen)

cursor_x, cursor_y = (0,0)

while 1:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            sys.exit()
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_ESCAPE:
                sys.exit()
            elif event.key == pygame.K_z:
                trooper.action()
            elif event.key == pygame.K_UP:
                cursor.update('up')
            elif event.key == pygame.K_DOWN: