def paint(self, wave_data, x, y, output_scroll, output_ennergy, output_spectrum, fft_result): Painter.paint(self, wave_data, x, y, output_scroll, output_ennergy, output_spectrum, fft_result) w, h = pygame.display.get_surface().get_size() self.clear((0, 0, 0)) #self.blur(2) pygame.draw.lines(self._holder.surface, (200, 0, 0), False, list(zip( np.arange(len(wave_data)) / len(wave_data) * w, wave_data / 100 + h / 2))) if len(x) > 0: pygame.draw.lines(self._holder.surface, (0, 255, 0), False, list(zip( x / x[-1] * w, h - y * 300))) if fft_result is not None: pygame.draw.lines(self._holder.surface, (0, 0, 255), False, list(zip( np.arange(len(fft_result)) / len(fft_result) * w, h / 5 * 4 - fft_result * 8 - 50))) self.draw_led(output_scroll, 600) self.draw_led(output_ennergy, 650) self.draw_led(output_spectrum, 700)
def algorithm(picture, args): """ Keep placing the biggest square possible. When only squares of size 1 are possible, fill with lines. """ painter = Painter(picture.empty_copy()) square = Square(-1, -1, 100000) while True: square = get_largest_unpainted_square(picture, painter, square.size) if not square: break painter.paint_square(square.row, square.column, square.size) for row, column in painter.picture.positions_to_paint(picture): if painter.picture[row][column]: continue length = 0 for i in range(row + 1, picture.shape[0]): if picture[i][column]: length += 1 else: break painter.paint_line(row, column, row + length, column) return painter
def __init__(self, holder): Painter.__init__(self, holder) self.clear((0, 0, 0)) self._led_size = 0 self._small_surface = None self._small_surface_w = None self._small_surface_h = None
def __init__(self): threading.Thread.__init__(self) self.lock = threading.Lock() # Start detectors self.personDetector = Detector( 'data/person-detection-retail-0013/FP32/person-detection-retail-0013.xml', 'bin/libcpu_extension.so') self.faceDetector = Detector( 'data/face-detection-retail-0004/face-detection-retail-0004.xml', 'bin/libcpu_extension.so') # Start painter self.painter = Painter() # Data self.personTrackBbIDs = [] self.faceTrackBbIDs = [] self.instantFPS = 0 self.avgFPS = 0 self.frame = None self.startTime = None self.avgFilterStartTime = None self.detectedPersonHist = {} self.detectedFaceHist = {} self.detectedPersonHisFiltered = [] self.sampleTime = 1 # seconds self.framesFactor = 0.3 self.maxIdleTime = 10 self.filteredDetection = [] self.postFrequency = 1 self.videoSize = []
class GUI(Tk): def __init__(self): Tk.__init__(self) self.state('normal') self.title("WELCOME TO GUI") self.painter = Painter() self.painter.set_canvas( Canvas(self, width=WIDTH, height=HEIGHT, bg="white")) draw_listener_manager = DrawListenersManager() draw_listener_manager.set_painter(self.painter) draw_listener_manager.register_draw_listeners() draw_listener_manager.register_draw_key_listeners(self) def create_menu(self): menu = ProgramMenu(self) self.config(menu=menu) def create_style_menu(self): style_menu = StyleMenu(self) interface_listener_manager = InterfaceListenerManager() interface_listener_manager.set_painter(self.painter) interface_listener_manager.set_style_menu(style_menu) interface_listener_manager.register_interface_listeners() StyleManager.set_style_menu(style_menu) def create_figure_menu(self): figure_menu = FigureMenu(self) DrawListenersManager.set_figure_menu(figure_menu) def create_distance_menu(self): distance_menu = DistanceMenu(self) DistanceManager.set_distance_menu(distance_menu)
def start_game(): screen = setup() pacman = Pacman() blinky = Blinky() pinky = Pinky() inky = Inky() clyde = Clyde() painter = Painter(screen, pacman, blinky, pinky, inky, clyde) input_handler = Input_handler() clock = pg.time.Clock() while 1: events = pg.event.get() input_handler.get_input(pacman, events) update_game_state(pacman, [blinky, pinky, inky, clyde]) painter.draw() pg.display.update() clock.tick(2)
def saveImage(self, max_dim, fname): """ """ # Compute the scale parameter t = self._map.getTransform() w, h = t.width - 2*t.xOffset, t.height - 2*t.yOffset # Clamp height if w >= h: scale = max_dim/h width = max_dim height = max_dim*h/w # Clamp width else: scale = max_dim/w height = max_dim width = max_dim*w/h # Instantiate the independent painter object on which we will draw the # image p = Painter(width, height) # Create a new map object from which we'll draw this image _map = Map(width, height, self._map.fname, self._config, scale=scale) # Actually draw the map _map.draw(p) # Save the resulting image p.saveImage(fname, fname[-3:], 100) # Delete the map object del _map
def invalidate(self, invalid_rcs, draw_mouse=True): assert all(isinstance(rc, Rect) for rc in invalid_rcs) update_rcs = map(Rect, invalid_rcs) self.debug('invalidate', {'rects': update_rcs}) wnds_to_draw = [] for wnd in reversed(self.wnds): new_invalid_rcs = [] for invalid_rc in invalid_rcs: draw_rc = invalid_rc.intersected( wnd.window_rect_in_screen_coord()) if draw_rc.is_empty(): new_invalid_rcs.append(invalid_rc) else: wnds_to_draw.append((wnd, draw_rc)) if wnd.attr() & WND_TRANSPARENT: new_invalid_rcs.append(invalid_rc) else: new_invalid_rcs.extend(invalid_rc - draw_rc) invalid_rcs = new_invalid_rcs painter = Painter(self.screen) for wnd, rc in reversed(wnds_to_draw): self.blit_window(painter, wnd, rc) if draw_mouse: painter.draw_bitmap(self.mouse_x, self.mouse_y, self.mouse_img) for rc in update_rcs: self.update_screen(rc)
def start_new_group(): # main queue holding network events main_queue = queue.Queue(maxsize=0) paint_queue = queue.Queue(maxsize=0) # Retrieving time from a ntp server thread time_offset = [0] helpers.initialize_offset(time_offset) time_synchronizer = TimeSynchronizer(time_offset) time_synchronizer.start() # Listening for a new client thread new_client_listener = NewClientListener(main_queue) new_client_listener.start() # Listening for a new predecessor thread new_predecessor_listener = NewPredecessorListener(main_queue) new_predecessor_listener.start() model = ModelThread(main_queue, paint_queue, time_offset) model.start() # We start the painter as it must be in the main thread painter = Painter(paint_queue, main_queue) painter.start_drawing()
def __init__(self, size, fullscreen=False): Painter.__init__(self, Vect(0, 0), Rect((0, 0), size)) pygame.display.init() pygame.font.init() flags = pygame.RESIZABLE self.surface = pygame.display.set_mode(size, flags) pygame.display.set_caption("Tichy")
def painterAgent(self, settings): self._message("Painter starting") painter = Painter() while True and not self.shouldThreadQuit: videos = os.listdir(settings["source"]) for video in videos: if self.shouldThreadQuit: break if video[:1] == '.' or video[-4:] == '.lck' or os.path.exists('%s/%s.lck' % (settings['source'], video)): pass else: source = "%s/%s" % (settings["source"], video) output = "%s/%s-%s.jpg" % (settings["output"], time.time(), video) lockFile = "%s/%s-%s.jpg.lck" % (settings["output"], time.time(), video) self._message("Painting...") image = painter.generate(source) open(lockFile, 'a').close() painter.writeImage(output, image) os.remove(lockFile) os.remove(source) self._message("Painter quitting") return
def save(self): path = filedialog.asksaveasfile(mode='w', defaultextension='.png', filetypes=(('png files', '*.png'), ("all files", "*.*"))) if path is not None: painter = Painter(self.size_button) painter.paint(self.game_field.field, path.name, self.dimension)
def setUp(self) -> None: self.mock_sleep = patch("time.sleep", return_value=None) self.mock_turtle = patch("turtle.Turtle", new=MagicMock()) self.mock_screen = patch("turtle.Screen", new=MagicMock()) self.mock_sleep.start() self.mock_turtle.start() self.mock_screen.start() self.painter = Painter()
def algorithm(picture, args): """ Paint each cell with a single command resulting in a score 0 """ painter = Painter(picture.empty_copy()) for row, column in painter.picture.positions_to_paint(picture): painter.paint_square(row, column, 0) return painter
def paint(self, wave_data, x, y, output_scroll, output_ennergy, output_spectrum, fft_result): Painter.paint(self, wave_data, x, y, output_scroll, output_ennergy, output_spectrum, fft_result) w, h = pygame.display.get_surface().get_size() self.clear((0, 0, 0)) #self.clear_with_alpha((0, 0, 0), 30) #self.blur(2) count = len(y) if count > 0: x_step = w / count bar_posis = [] y = np.log10(y + 1) * 4 for i in range(count): bar_height = y[i] * 500 if bar_height > h - BAR_TOP_THICKNESS: bar_height = h - BAR_TOP_THICKNESS bar_posi = h - bar_height bar_posis.append(bar_posi) pygame.draw.rect( self._holder.surface, BAR_COLOR, (i * x_step + 1, bar_posi, x_step - 2, bar_height)) if self._old_bar_posis is None: self._old_bar_posis = bar_posis self._bar_posi_stay_count = [0 for i in range(len(bar_posis))] for i in range(len(bar_posis)): if bar_posis[i] < self._old_bar_posis[i]: self._old_bar_posis[i] = bar_posis[i] self._bar_posi_stay_count[i] = 0 else: self._bar_posi_stay_count[i] += 1 if self._bar_posi_stay_count[i] > BAR_STAY_MAX_COUNT: drop_speed = h * BAR_DROP_SPEED / 768 self._old_bar_posis[i] += BAR_DROP_SPEED if bar_posis[i] < self._old_bar_posis[i]: self._old_bar_posis[i] = bar_posis[i] self._bar_posi_stay_count[i] = 0 pygame.draw.rect( self._holder.surface, BAR_TOP_COLOR, (i * x_step + 1, self._old_bar_posis[i] - BAR_TOP_THICKNESS, x_step - 2, BAR_TOP_THICKNESS))
def __init__(self): Tk.__init__(self) self.state('normal') self.title("WELCOME TO GUI") self.painter = Painter() self.painter.set_canvas( Canvas(self, width=WIDTH, height=HEIGHT, bg="white")) draw_listener_manager = DrawListenersManager() draw_listener_manager.set_painter(self.painter) draw_listener_manager.register_draw_listeners() draw_listener_manager.register_draw_key_listeners(self)
def start(self): """start main loop""" self.clock = pygame.time.Clock() while not Input.exit: Painter.fill_screen() self.update_delta_time() Input.update() self.current_tab.update() self.current_tab.draw() pygame.display.update()
def test_type(self): jury_state = JuryState(list(range(9))) jury_state.field[2] = 'X' jury_state.field[4] = 'X' jury_state.field[6] = 'X' jury_state.field[3] = 'O' jury_state.line = 7 #jury_state.winner = Player('c', 'Dmitry Philippov') current_painter = Painter([Player('c', 'Petya'), Player('c', 'Dmitry Philippov')] ) byte_string = current_painter.paint(jury_state)
def launch(self): """ launch(self) Called only once on a game start. Initializes the field and launches the start_screen() function. """ self.field.generate_field(10, 10) # self.window.fill((47, 47, 47)) self.painter = Painter(self.window_width, self.window_height, self.window, self.field.field, self.field.cell_size, self.score) self.start_screen()
def main(): """The main game loop.""" world = World() painter = Painter() player = world.player while not libtcod.console_is_window_closed(): world.update() painter.paint(world) player.interact(world) if player.exit: break painter.new_canvas()
def __init__(self): pygame.init() self.exit = False self.framerate = 60 self.clock = None self.delta_time = 0 self.tabs = {} self.add_tab('game', Game(self)) self.add_tab('mainmenu', MainMenu(self)) self.current_tab = self.get_tab('mainmenu') self.current_tab.start() self.screen = pygame.display.set_mode(self.current_tab.get_size().floor().get()) Painter.init(self.screen)
def algorithm(picture, args): """ Keep placing the biggest square possible """ painter = Painter(picture.empty_copy()) square = Square(-1, -1, 100000) while True: square = get_largest_unpainted_square(picture, painter, square.size) if not square: break painter.paint_square(square.row, square.column, square.size) return painter
def pm_render(self, position): if self.running: if time.time() - self.ptime > self.frames[self.cur][1]: if self.reversed: self.cur -= 1 if self.cur < self.startpoint: self.cur = self.breakpoint else: self.cur += 1 if self.cur > self.breakpoint: self.cur = self.startpoint self.ptime = time.time() Painter.draw(self.frames[self.cur][0], position)
class Calendar(object): def __init__(self, filename): self.filename = filename def __enter__(self): self.fManager = FileManager(self.filename) self.events = self.fManager.readEvents() self.painter = Painter() return self def __exit__(self, exc_type, exc_val, exc_tb): self.fManager.rewriteEvents(self.events) def draw(self): self.painter.draw(self.events)
class VisualizeStrategy(Strategy): where = Argument('`where` (questions from or to)') action = Action() user = User() painter = Painter() def parse_args(self, args): self.where = args[0] def process(self): records = self.action.all(fields=('action.what', 'action.at', 'user.name')) filtered_records = self._filter_records(records) data = self._parse_records(filtered_records) self.painter.draw(data) def _parse_records(self, records): split_map = defaultdict(list) for record in records: date = datetime.fromtimestamp(record[1]) split_map[(date.year, date.month, date.day)].append([record[0], date, record[2]]) result = [] for k in sorted(split_map.keys()): result.append(sorted(split_map[k], key=lambda r: r[1])) return result def _filter_records(self, records): return list(filter(lambda r: r[0] == self.where, records))
def __init__(self, master): self.width = 800 self.height = 800 self.move_step = 2 self.zoom_step = 5 self.rotate_step = math.pi / 18 self.canvas = tk.Canvas(master, width=self.width, height=self.height, bg="black") self.canvas.pack() self.painter = Painter(self) self.d = 200 self.shapes = [] self.initialize() self.draw()
def connect_to_existing_client(connection): # main queue holding network events main_queue = queue.Queue(maxsize=0) paint_queue = queue.Queue(maxsize=0) # Retrieving time from a ntp server thread time_offset = [0] helpers.initialize_offset(time_offset) time_synchronizer = TimeSynchronizer(time_offset) time_synchronizer.start() # Listening for a new client thread new_client_listener = NewClientListener(main_queue) new_client_listener.start() # Listening for a new predecessor thread new_predecessor_listener = NewPredecessorListener(main_queue) new_predecessor_listener.start() # We send the client request containing our data so anothe rclient could connect as a predecessor new_client_request = events.NewClientRequestEvent( (helpers.get_self_ip_address(), config.getint('NewPredecessorListener', 'Port'))) message = helpers.event_to_message(new_client_request) message_size = (len(message)).to_bytes(8, byteorder='big') connection.send(message_size) connection.send(message) # After we send the request we are waiting for the response with init_data message_size = connection.recv(8) message_size = int.from_bytes(message_size, byteorder='big') data = b'' while len(data) < message_size: packet = connection.recv(message_size - len(data)) if not packet: return None data += packet init_data = (json.loads(data.decode('utf-8')))['data'] model = ModelThread(main_queue, paint_queue, time_offset, init_data, connection) model.start() # We start the painter as it must be in the main thread painter = Painter(paint_queue, main_queue) painter.start_drawing()
def main(): import cProfile import pstats if (args.hilbert): from hilbertpalette import HilbertPalette as Palette else: from euclidpalette import EuclidPalette as Palette from painter import Painter from PIL import Image palette = None profile = cProfile.Profile() if (args.palette != None): palette = Palette(args.library[0], args.palette[0]) else: palette = Palette(args.library[0], "palette.txt") if (args.create): palette.MakeNewPalette() else: try: palette.OpenPalette() except: print("Could not open palette") print("Creating new palette") palette.MakeNewPalette() if (args.save): palette.SavePalette() print("Palette to hand") image = Image.open(args.picture[0]) print(f"Reference picture {args.picture[0]} open") painter = Painter(palette) print(f"Painting {args.output[0]}") profile.enable() painter.PaintPixels(image, args.pixelsize[0], args.output[0]) profile.disable() if (args.stats): ps = pstats.Stats(profile) ps.sort_stats('cumtime', 'calls') ps.print_stats() image.close()
def on_paint(self, ev): painter = Painter(self) painter.draw_bitmap(0, 0, self.im) for i, icon in enumerate(self.icons): x = ICON_MARGIN y = ICON_MARGIN + i * (ICON_SIZE + ICON_MARGIN) if i == self.cur_icon: rc = Rect(x, y, ICON_SIZE, ICON_SIZE) dx = ICON_SIZE / 10 rc.adjust(-dx, -dx, dx, dx) painter.fill_rect(rc, SteelBlue) painter.draw_bitmap(x, y, icon)
def test1(): from image import Image from painter import Painter from geo import Vect, Rect from style import Style, Frame from sdl_painter import SdlPainter im = Image('frame.png') f = Frame(im) style = Style() style.background = f p = Painter(SdlPainter()) l = Label(None, 'hello', style=style) l.rect = Rect((0, 0), (1, 1)) l.draw(p) p.flip() raw_input()
def algorithm(picture, args): """ Try to use vertical lines for each cell """ painter = Painter(picture.empty_copy()) for row, column in painter.picture.positions_to_paint(picture): if painter.picture[row][column]: continue length = 0 for i in range(row + 1, picture.shape[0]): if picture[i][column]: length += 1 else: break painter.paint_line(row, column, row + length, column) return painter
def paint(self, wave_data, x, y, output_scroll, output_ennergy, output_spectrum, fft_result): Painter.paint(self, wave_data, x, y, output_scroll, output_ennergy, output_spectrum, fft_result) w, h = pygame.display.get_surface().get_size() #led_data = output_scroll led_data = output_ennergy #led_data = output_spectrum if led_data is not None: if self._small_surface is None: self._small_surface_h = len(led_data[0]) self._small_surface_w = int(self._small_surface_h / h * w) self._small_surface = pygame.Surface( (self._small_surface_w, self._small_surface_h)) self._small_surface.fill((0, 0, 0)) alpha_surface = pygame.Surface( (self._small_surface_w, self._small_surface_h)) alpha = 2 alpha_surface.set_alpha(alpha) alpha_surface.fill((0, 0, 0)) self._small_surface.blit(alpha_surface, (0, 0)) self.draw_led_points(led_data) x_posi = self._small_surface.get_width() // 2 self._small_surface.blit(self._small_surface, (x_posi + 1, 0), (x_posi, 0, self._small_surface_w - x_posi, self._small_surface_h)) self._small_surface.blit(self._small_surface, (0, 0), (1, 0, x_posi, self._small_surface_h)) #large_image = pygame.transform.smoothscale(self._small_surface, (w, h)) large_image = pygame.transform.scale(self._small_surface, (w, h)) self._holder.surface.blit(large_image, (0, 0)) """
def get_solve(input_file, output_file): parser = Parser() try: pairs = parser.parse(input_file) except exc.IncorrectFileArgument as e: print('Incorrect file{0}'.format(input_file)) return except Exception as fe: print('Unrecognized error in file') return dimension = pairs[0] game = GameField(dimension, dimension) for cells in pairs[1:]: for key in cells.keys(): game.init_cell(key[0], key[1], cells[key]) solver = Solver(game) painter = Painter(64) try: solution = solver.solve() except exc.KakuroNotSolution as e: print('Not solution') return painter.paint(solution, output_file, dimension)
def main(): #resizePng('ignore/1.png',500,500) toPng('ignore/1.png') s = "裴" s = creatImg(s, 600) #mask = cv.putText(mask, s, (50, 50), cv.FONT_HERSHEY_SIMPLEX, 1.2, (0, 255, 0), 2) p = Painter(s, 500, 1) #p = Painter('1.png',400,1) #p = Painter('2.jpg',200,1) # img=np.full((width,width,3),0,np.uint8) # cv.circle(img,center, 250, (255,255,255), -1) # points =getCirclePoints() # # for p in points: # # cv.circle(img,p, 1, (0,0,255), 1) # # for i in range(0,180,5): # # p1 = points[i] # # interval = 80 # # index = i+interval # # if i+interval >= len(points): # # index -= len(points) # # cv.line(img,p1,points[index],(0,0,255),1) p.run() # for x in range(30,100,1): # print(x / 100) # p.show(x / 100) # cv.waitKey(0) # cv.imshow('opencv',img) cv.waitKey(0) cv.destroyAllWindows() cv.waitKey(1)
def __init__(self): """Initialise the class by creating an instance of each object.""" self._ratio_index = (0.05, 0.1, 0.2, 0.5, 1, 2, 4, 8, 16, 32, 64) # pagal sita dydi turi kisti tasko atstumas nuo zoominimo centro self._zoom_level = self._ratio_index.index(4) # 0-dirbame su realiomis koordinatemis - kitur koordinates yra gaunamos atliekant dalyba... todel nera labai tikslios self._device_area = None # gtk.gdk.Rectangle() self._shapes = [] # shapes data self._index_rtree = Rtree() # shapes indexes in self._shapes self._offset = Point(0, 0) #- naudojamas ctx.translate() #device koordinates self._prj = GisProjection() self._styler = Styler(self) self._painter = Painter(self._styler) self._drag_to_center = True # jeigu norime kad resize metu (bus iskviestas set_device_area) butu iskvietsas center()
def main(): args = parse_args(sys.argv) exit_code = 0 if args.words: word = ' '.join(args.words) entry = Dictionary(args.local).query_word(word) if entry is None: print('Cant find', file=sys.stderr) exit_code = 1 else: color = args.color == 'always' output = Painter(color).paint_entry(entry) print(output) exit_code = 0 elif args.completion: for word in get_completion_words(args.completion): print(word) exit_code = 0 else: raise NotImplementedError('code should not reach here') sys.exit(exit_code)
def __init__(self, dmps, n_dims, n_bfs, n_times, duration, dt): self.dmps = dmps self.n_times = n_times self.n_dims = n_dims self.n_bfs = n_bfs self.ini_theta = np.zeros((self.n_dims, self.n_bfs)) self.dt = dt self.duration = duration self.xi = [] self.prev_action = np.zeros([n_dims, n_bfs]) self.gxi = self.goal() try: self.painter = Painter() except NameError as e: warnings.warn('As your matplotlib backend is {0}, ' 'pyglet and matplotlib will conflict. ' 'So, pyglet wasn\'t loaded. ' 'If you want to use pyglet and motlotlib, ' 'backend should change Qt5Agg or Qt4Agg. ' 'Actual error: {1}'.format(matplotlib.get_backend(), e))
class TestPainter(TestCase): def setUp(self) -> None: self.mock_sleep = patch("time.sleep", return_value=None) self.mock_turtle = patch("turtle.Turtle", new=MagicMock()) self.mock_screen = patch("turtle.Screen", new=MagicMock()) self.mock_sleep.start() self.mock_turtle.start() self.mock_screen.start() self.painter = Painter() def tearDown(self) -> None: self.mock_sleep.stop() self.mock_turtle.stop() self.mock_screen.stop() def test_run_forward(self): self.painter.t.forward = MagicMock() line = Picture("F", 10, 90) self.painter.draw(line) self.painter.t.forward.assert_called_once_with(10) def test_left(self): self.painter.t.left = MagicMock() line = Picture("-", 10, 90) self.painter.draw(line) self.painter.t.left.assert_called_once_with(90) def test_right(self): self.painter.t.right = MagicMock() line = Picture("+", 10, 90) self.painter.draw(line) self.painter.t.right.assert_called_once_with(90)
def __init__(self): self.turn =1 #Create debugging display debug_win = uc.newwin(15, 30, 0, 0) uc.box(debug_win) uc.wmove(debug_win, 1, 1) uc.waddstr(debug_win, "Debug:") uc.wmove(debug_win, 2, 1) debug_pnl = uc.new_panel(debug_win) uc.move_panel(debug_pnl, glob.CAM_HEIGHT, 32) #Generate the world self.world = Map(glob.N_HEX_ROWS, glob.N_HEX_COLS, debug_win) #map_height: 3 + 2*(rows-1) + 2 for border #map_width: 5 + 4*cols + 2 for border map_win = uc.newwin(glob.CAM_HEIGHT, glob.CAM_WIDTH, 0, 0) self.painter = Painter(glob.N_HEX_ROWS, glob.N_HEX_COLS, map_win) self.painter.updateAllTiles(self.world) #Put world window into a panel map_pnl = uc.new_panel(map_win) uc.move_panel(map_pnl, 1, 1) uc.top_panel(debug_pnl) self.status_win = uc.newwin(10, 30, 0, 0) uc.box(self.status_win) uc.wmove(self.status_win, 1, 1) uc.waddstr(self.status_win, "Turn " + str(self.turn)) status_pnl = uc.new_panel(self.status_win) uc.move_panel(status_pnl, glob.CAM_HEIGHT, 2) self.tile_window = TileWindow() self.painter.drawWindow() showChanges() #input loop while True: sys.stdout.flush() ch = uc.getch() uc.waddstr(debug_win, str(ch)) #Exit Key if ch == Key.ESC: break #Movement Keys elif ch == Key.E: self.movePlayer(HexDir.UL) elif ch == Key.R: self.movePlayer(HexDir.UR) elif ch == Key.S: self.movePlayer(HexDir.L) elif ch == Key.G: self.movePlayer(HexDir.R) elif ch == Key.D: self.movePlayer(HexDir.DL) elif ch == Key.F: self.movePlayer(HexDir.DR) #End Turn Key elif ch == Key.SPACE: self.incrementTurn() #Camera Scrolling Keys #TBD: Remaining order checks elif ch == uc.KEY_UP: self.painter.moveCamera(0, -1*glob.CAM_SPEED) elif ch == uc.KEY_DOWN: self.painter.moveCamera(0, glob.CAM_SPEED) elif ch == uc.KEY_LEFT: self.painter.moveCamera(-1*glob.CAM_SPEED, 0) elif ch == uc.KEY_RIGHT: self.painter.moveCamera(glob.CAM_SPEED, 0) #Toggle drawing borders elif ch == Key.B: self.painter.draw_borders = not self.painter.draw_borders self.painter.updateAllTileBorders(self.world) self.painter.drawWindow()
def __enter__(self): self.fManager = FileManager(self.filename) self.events = self.fManager.readEvents() self.painter = Painter() return self
def test_painter(self): field_side = 10 empty_list = [0 for i in range(field_side)] empty_list_tuples = [(0, 0) for i in range(field_side)] empty_field = [empty_list for i in range(field_side)] empty_field_tuples = [empty_list_tuples for i in range(field_side)] jury_state = JuryState( field_side, [empty_field, empty_field], [empty_field, empty_field], [empty_field_tuples, empty_field_tuples] ) jury_state.fields[0] = [ [0, 0, 0, 0, 0, 0, 0, 0, 2, 2], [0, 0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 0, 0], [0, 0, -1, 2, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 1], [0, 3, 3, 3, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 2, 2, 0, -1, 0, 0, 3, 0, 0], [0, 0, 0, 0, 0, 0, 0, 3, 0, 0], [4, 4, 4, 4, 0, 0, 0, 3, 0, 0], ] jury_state.start_fields[0] = [ [0, 0, 0, 0, 0, 0, 0, 0, 2, 2], [0, 0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 2, 2, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 1], [0, 3, 3, 3, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 2, 2, 0, 0, 0, 0, 3, 0, 0], [0, 0, 0, 0, 0, 0, 0, 3, 0, 0], [4, 4, 4, 4, 0, 0, 0, 3, 0, 0], ] jury_state.fields[1] = [ [0, 0, 0, 0, 0, 0, 0, 0, 2, 2], [0, 0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 0, 0], [0, 0, -1, 2, 0, 0, 0, 0, 0, 0], [0, -1, 0, 0, 0, 0, 0, 0, 0, 1], [0, 3, 3, 3, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 2, 2, 0, 0, 0, 0, 3, 0, 0], [0, 0, 0, 0, 0, 0, 0, 3, 0, 0], [4, 4, 4, 4, 0, 0, 0, 3, 0, 0], ] jury_state.start_fields[1] = [ [0, 0, 0, 0, 0, 0, 0, 0, 2, 2], [0, 0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 2, 2, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 1], [0, 3, 3, 3, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 2, 2, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [4, 4, 4, 4, 0, 0, 0, 3, 3, 3], ] jury_state.ships[0] = [ [(1, 3)], [(2, 7)], [(4, 9)], [(5, 5)], [(0, 8), (0, 9)], [(3, 2), (3, 3)], [(7, 1), (7, 2)], [(5, 1), (5, 2), (5, 3)], [(7, 7), (8, 7), (9, 7)], [(9, 0), (9, 1), (9, 2), (9, 3)], ] jury_state.ships[1] = [ [(1, 3)], [(2, 7)], [(4, 9)], [(5, 5)], [(0, 8), (0, 9)], [(3, 2), (3, 3)], [(7, 1), (7, 2)], [(5, 1), (5, 2), (5, 3)], [(9, 7), (9, 8), (9, 9)], [(9, 0), (9, 1), (9, 2), (9, 3)], ] # jury_state.winner = Player('c', 'Dmitry Philippov') current_painter = Painter([Player("c", "Petya"), Player("c", "Dmitry Philippov")]) byte_string = current_painter.paint(jury_state)
def test_type(self): jury_state = JuryState(list(range(20))) current_painter = Painter(["John Smith"]) byte_string = current_painter.paint(jury_state) self.assertTrue(isinstance(byte_string, bytes))
class GisCanvas: """ Top-level drawing class that contains a list of all the objects to draw. """ def __init__(self): """Initialise the class by creating an instance of each object.""" self._ratio_index = (0.05, 0.1, 0.2, 0.5, 1, 2, 4, 8, 16, 32, 64) # pagal sita dydi turi kisti tasko atstumas nuo zoominimo centro self._zoom_level = self._ratio_index.index(4) # 0-dirbame su realiomis koordinatemis - kitur koordinates yra gaunamos atliekant dalyba... todel nera labai tikslios self._device_area = None # gtk.gdk.Rectangle() self._shapes = [] # shapes data self._index_rtree = Rtree() # shapes indexes in self._shapes self._offset = Point(0, 0) #- naudojamas ctx.translate() #device koordinates self._prj = GisProjection() self._styler = Styler(self) self._painter = Painter(self._styler) self._drag_to_center = True # jeigu norime kad resize metu (bus iskviestas set_device_area) butu iskvietsas center() def load(self, name): self._styler.load_css_file("%s.css" % name) self.load_fcad_file("%s.fcad" % name) def save(self, file_name): #self.create_fcad_file("%s.fcad" % file_name) ShapeFile.create_fcad_file("%s.fcad" % file_name, self._shapes) StyleFile.create_css_file("%s.css" % file_name, self._styler.get_shapes_style(), self._styler.get_symbols_style(), prettyprint=True) #self._styler.create_css_file("%s.css" % file_name, prettyprint=True) def clear(self): print "clear canvas!" self._zoom_level = self._ratio_index.index(1) self._offset = Point(0, 0) self._shapes = [] #self._cairo_paths = {} self._index_rtree = Rtree() self._styler.load_default_style() def load_pickle(self, file_path): timer.start("loading shapes.p") if os.path.exists(file_path): self._shapes = pickle.load(open(file_path, "rb")) if len(self._shapes): def generator_function(points): for i, obj in enumerate(points): if obj == None: continue yield (i, self._styler.get_bbox(fshape.Shape.decompress(obj)), obj) self._index_rtree = Rtree(generator_function(self._shapes)) timer.end("loading shapes.p") def save_pickle(self, file_path): pickle.dump(self._shapes, open(file_path, "wb")) def load_fcad_file(self, file_path): timer.start("loading shapes.fcad") self._shapes = ShapeFile.read_fcad_file(file_path) if len(self._shapes): def generator_function(points): for i, obj in enumerate(points): if obj == None: continue yield (i, self._styler.get_bbox(fshape.Shape.decompress(obj)), obj) self._index_rtree = Rtree(generator_function(self._shapes)) timer.end("loading shapes.fcad") def set_device_area(self, area): # atnaujina screen.resize() self._device_area = area if self._drag_to_center: self.center() self._drag_to_center = False def get_shape_by_id(self, id): compressed_shape = self._shapes[id] if compressed_shape == None: return None return fshape.Shape.decompress(compressed_shape) def get_object_by_id(self, id): return self._shapes[id] def draw_100(self, ctx, area): """100% draw for printing, no scale, area in user coordinates""" page_area = Area(0, 0, area.width, area.height) #ctx.rectangle(0, 0, area.width, area.height) #ctx.clip() # tam kad nepaisytu uzh sito staciakampio ribu (tada gaunasi dubliuotos linijos) #self.background(ctx, page_area) # paint white background self._painter.background(ctx, page_area, color=(1,1,1), clip=True) # paint white background self._painter.setup(ctx, transform={"translate":(-area.x, -area.y)}) radius = 0 #self.pixel_radius + self.line_width # ne cia reikia prideti radiusa, o ten kur dedame i cavas'a shape'us elements = self._index_rtree.intersection((area.x-radius, area.y-radius, area.x+area.width+radius, area.y+area.height+radius)) elements_zindex = self._styler.create_zindex(elements) # jis yra pilnas visu galimu zindex'u sarasas - pradzioje dalis ju gali buti ir tusti [] timer.start("draw100") for zindex in sorted(elements_zindex.keys()): for element in elements_zindex[zindex]: self._painter.draw(element, update=elements_zindex) # kazka visada nupaiso - bet dar papildomai gali iterpti elementu su didesniu zindex'u # tie elementai bus nupaisomi veliau. timer.end("draw100") def draw_object(self, ctx, id, fill_or_stroke=True): #self.apply_transforms(ctx) # drag and scale self._painter.setup(ctx, transform={"translate":self.get_offset(), "scale": self.get_ratio()}) elements_zindex = self._styler.create_zindex([id]) timer.start("draw single object") for zindex in sorted(elements_zindex.keys()): for element in elements_zindex[zindex]: self._painter.draw(element, update=elements_zindex, fill_or_stroke=fill_or_stroke) # kazka visada nupaiso - bet dar papildomai gali iterpti elementu su didesniu zindex'u timer.end("draw single object") def draw(self, ctx, area, fill_or_stroke=True): """Draw the complete drawing by drawing each object in turn.""" self._painter.background(ctx, area, color=(1,1,1), clip=True) # paint white background self._painter.setup(ctx, transform={"translate":self.get_offset(), "scale": self.get_ratio()}) # paishysime tik tuos tashkus kurie pakliuna i vartotojo langa # reikia device_area konvertuoti i user koordinates x, y = self.device_to_user(Point(area.x, area.y)) x2, y2 = self.device_to_user(Point(area.x + area.width, area.y + area.height)) radius = 0 #self.pixel_radius + self.line_width # ne cia reikia prideti radiusa, o ten kur dedame i cavas'a shape'us # geriau cia, nes paprasciau yra iskviesti nupaisyti didesni gabala nei paskaiciuoti tikslu pvz linijo simboliu dydi... elements = self._index_rtree.intersection((x-radius, y-radius, x2+radius, y2+radius)) elements_zindex = self._styler.create_zindex(elements) # jis yra pilnas visu galimu zindex'u sarasas - pradzioje dalis ju gali buti ir tusti [] timer.start("draw") for zindex in sorted(elements_zindex.keys()): for element in elements_zindex[zindex]: #print "element: ", element[0][0] self._painter.draw(element, update=elements_zindex, fill_or_stroke=fill_or_stroke) # kazka visada nupaiso - bet dar papildomai gali iterpti elementu su didesniu zindex'u # tie elementai bus nupaisomi veliau. timer.end("draw") def get_ratio(self, level=None): if level == None: level = self._zoom_level return self._ratio_index[level] def drag2(self, drag_offset): self._offset = Point(self._offset.x + drag_offset.x, self._offset.y + drag_offset.y) def get_offset(self): return self._offset def find_objects_at_position(self, point): #ctx = self.get_context(transform=False) # naujas kontekstas kur paisysime, transformuoti nereikia - nes tai padarys .draw() ctx = cairo.Context(cairo.ImageSurface(cairo.FORMAT_ARGB32, 0, 0)) # naujas kontekstas kur paisysime, transformuoti nereikia - nes tai padarys .draw() area = Area(point.x, point.y, 1, 1) listener = ContextObjectsListener(point) listener_id = self._painter.addContextListener(listener) try: self.draw(ctx, area, fill_or_stroke=False) # nepaisysime tik sukursime path'us context'e ir su jais kazka atliks ContextListeneris finally: self._painter.removeContextListener(listener_id) return listener.get_objects() # rastu elementu indeksai def get_shape_redraw_area(self, id): #ctx = self.get_context(transform=False) ctx = cairo.Context(cairo.ImageSurface(cairo.FORMAT_ARGB32, 0, 0)) shape = self.get_object_by_id(id) if shape == None: return None listener = ContextBoundsListener() listener_id = self._painter.addContextListener(listener) try: self.draw_object(ctx, id, fill_or_stroke=False) finally: self._painter.removeContextListener(listener_id) area = listener.get_area() #print "Area: ", area return area def device_to_user(self, point): #x, y = self.ctx.device_to_user(point.x, point.y) #x, y = self.get_context().device_to_user(point.x, point.y) ratio = self.get_ratio() offset = self.get_offset() x, y = (point.x - offset.x)/ratio, (point.y - offset.y)/ratio return Point(x, y) def user_to_device(self, point, offset=(0, 0)): #x, y = self.ctx.user_to_device(point.x, point.y) #x, y = self.get_context().user_to_device(point.x, point.y) ratio = self.get_ratio() drag_offset = self.get_offset() x, y = (point.x * ratio) + drag_offset.x, (point.y * ratio) + drag_offset.y return Point(x + offset[0], y + offset[1]) def add(self, shape): id = len(self._shapes) # top element index self._shapes.append(shape.compress()) self._index_rtree.add(id, self._styler.get_bbox(shape)) return id def remove(self, id): shape = self.get_shape_by_id(id) self._index_rtree.delete(id, shape.bbox()) # po sito as jau niekada tokio id negausiu (nes viskas eina per rtree) self._shapes[id] = None def replace(self, id, shape): old = self.get_shape_by_id(id) #print "before :", list(self._index_rtree.intersection(old.bbox())) if old != None: self._index_rtree.delete(id, old.bbox()) #print "after :", list(self._index_rtree.intersection(old.bbox())) self._shapes[id] = shape.compress() self._index_rtree.add(id, self._styler.get_bbox(shape)) def zoom(self, direction, center=None): """center cia yra device koordinatemis - jeigu butu paspausta su zoom irankiu peles pagalba""" new_zoom_level = self._zoom_level+direction if new_zoom_level in range(0, len(self._ratio_index)): #esamas centro taskas atlikus zooma turi islikti toje pacioje vietoje center = center or Point(self._device_area.width/2, self._device_area.height/2) # vartotojo parinktas tashkas arba tiesiog centras center_user = self.device_to_user(center) # gauname priesh tai buvusio centro koordinates naujame zoom lygyje new_ratio = self.get_ratio(new_zoom_level) new_center = Point(center_user.x * new_ratio, center_user.y * new_ratio) # gauname centro poslinki (per tiek reikia perstumti visa vaizdeli) self._offset = Point(center.x - new_center.x, center.y - new_center.y) # naujas poslinkis #print "zoom: ", self._offset self._zoom_level = new_zoom_level return True return False def center(self, point=None): """center to user point""" if not point: bounds = self._index_rtree.bounds point = Point((bounds[0]+bounds[2])/2.0, (bounds[1]+bounds[3])/2.0) hand = self.user_to_device(point) to = Point(self._device_area.width/2, self._device_area.height/2) self.drag2(Point(to.x-hand.x, to.y-hand.y)) def get_projection(self): return self._prj def get_styler(self): return self._styler def load_ocad_file(self, file_path, generator=True): #import ocadfile #self.add(Shape(1, Point(0, 0), symbol="graphics")) # koordinaciu centras self._prj = GisProjection() self._zoom_level = self._ratio_index.index(4) of = OcadFile(file_path, self._prj) #self._styler.load_ocad_symbols(of, prj) timer.start("Adding ocad symbols") self._styler.set_symbols_style(of.get_symbols_style()) timer.end("Adding ocad symbols") timer.start("Adding ocad elements") shapes = of.get_shapes() print "Shapes: ", len(shapes) for shape in shapes: self.add(shape) timer.end("Adding ocad elements") self.center() def load_shape_file(self, file_path, generator=True): import shapefile from random import randint sf = shapefile.Reader(file_path) print "Number of shapes: ", sf.numRecords self.add(fshape.Shape(1, Point(0, 0), style={"z-index":99})) # koordinaciu centras if self.prj.scale == 1: # pirmas kartas prj = GisProjection(self, sf.bbox) #po sito ciklo jau turesime zemelapio ribas center = prj.map_to_user(prj.get_center()) self.center(center) self.prj = prj timer.start("Adding shapes") symbol = sf.shapeName.split("/")[-1] self._styler.set_symbol_style(symbol, {"color": (randint(0,255),randint(0,255),randint(0,255))}) for shape in sf.ogis_shapes(self.prj): self.add(fshape.Shape(shape.shapeType, shape.points, symbol=symbol)) timer.end("Adding shapes") def add_random_points(self, number, area, generator=True): """Kai generator=False - sunaudoja maziau atminties ikrovimo metu, bet trunka gerokai leciau """ self._shapes = [] timer.start("Adding random data") from random import randint for x in range(0, number): color = 65536 * randint(0,255) + 256 * randint(0,255) + randint(0,255) # RGBint x, y = randint(2, area.width), randint(2, area.height) if not generator: # darysime rtree.add kiekvienam taskui atskirai self.add(fshape.Shape(1, Point(x, y), color=color)) else: self._shapes.append((1, color, x, y)) if generator: def generator_function(points): for i, obj in enumerate(points): yield (i, (obj[2], obj[3], obj[2], obj[3]), obj) self._index_rtree = Rtree(generator_function(self._shapes)) timer.end("Adding random data")
class Core(object): def afterInit(self): self.painter = Painter(self.app.scene) self.app.painter = self.painter self.api = API() def main(self): self.drawMaze(self.genMaze()) self.drawLight() # self.app.graphicsView.centerOn(QPointF(self.player.x(), self.player.y())) def genMaze(self): self.maze = self.simpleMaze(side=self.app.config.options.side, unit=self.app.config.options.unit) # [self.B, self.N] = self.fasterThenEver(self.maze) return self.maze # @try_this(API()) def drawMaze(self, maze): self.map = self.painter.polygon(maze, width=2, bg_color=self.app.config.options.maze_bg_color, is_maze=True) i = random.randrange(len(maze)) # l = self.app.config.options.unit / (2 * math.hypot(self.B[i - 1][0], self.B[i - 1][1])) # megax = (maze[i - 1][0] + maze[i][0]) / 2 - self.B[i - 1][1] * l # megay = (maze[i - 1][1] + maze[i][1]) / 2 + self.B[i - 1][0] * l self.player = self.painter.player(QPointF(100, 100)) # self.app.graphicsView.centerOn(QPointF(megax, megay)) # @try_this(API()) def regenMaze(self): self.app.scene.clear() self.app.scene.init() del self.light del self.player del self.map self.drawMaze(self.genMaze()) self.drawLight() self.api.info("Maze regenerated") # @try_this(API()) def drawLight(self, coord=""): if not coord: coord = self.player coord = (coord.x(), coord.y()) self.light = self.painter.polygon(self.lightUp(coord, self.maze), "yellow", 0, "yellow", 0.5) def redrawLight(self, pos): self.app.scene.removeItem(self.light) del self.light self.drawLight(pos) @try_this(API()) def canMove(self, dx, dy): for i, b in enumerate(self.B): div = dx * self.B[i][1] - dy * self.B[i][0] if div: px = self.player.ox() + 10 - self.maze[i][0] py = self.player.oy() + 10 - self.maze[i][1] k = (py * self.B[i][0] - px * self.B[i][1]) / float(div) if k > 0 and k <= 1: n = (py * dx - px * dy) / float(div) if n >= 0 and n <= 1: return False return True def n(self): if self.canMove(0, -10): self.player.moveBy(0, -10) self.app.refresh() def w(self): if self.canMove(-10, 0): self.player.moveBy(-10, 0) self.app.refresh() def e(self): if self.canMove(10, 0): self.player.moveBy(10, 0) self.app.refresh() def s(self): if self.canMove(0, 10): self.player.moveBy(0, 10) self.app.refresh() # @try_this(API()) def lightUp(self, player, maze): keypoints = [] P = player for ray in maze: for N in ray: A = (N[0] - P[0], N[1] - P[1]) kmin = None semipass = 0 viewBlocked = False for plank in maze: L = plank[-1] for M in plank: B = (M[0] - L[0], M[1] - L[1]) C = (L[0] - P[0], L[1] - P[1]) L = M div = A[0] * B[1] - A[1] * B[0] if div > 0: n = C[0] * A[1] - C[1] * A[0] if n >= 0 and n <= div: k = C[0] * B[1] - C[1] * B[0] if k > 0: if k < div: kmin = None viewBlocked = True break if k == div: if semipass: kmin = 1 if n: semipass += 1 else: semipass -= 1 if k > div: # and n and n != div: k /= float(div) if kmin is None or kmin > k: kmin = k if viewBlocked: break if kmin is not None: R = (P[0] + kmin * A[0], P[1] + kmin * A[1]) if semipass == 0: keypoints.append(N) elif semipass < 0: keypoints.append(N + R) else: keypoints.append(R + N) # print int( atan2(kmin * A[1], kmin * A[0]) * 57.2957 + 360 ) % 360, int(hypot(kmin * A[0], kmin * A[1])), semipass keypoints.sort(key=lambda p: atan2(p[1] - player[1], p[0] - player[0])) i = 0 while i < len(keypoints): if len(keypoints[i]) == 4: tmp = keypoints.pop(i) keypoints.insert(i, (tmp[0], tmp[1])) keypoints.insert(i, (tmp[2], tmp[3])) i += 2 else: i += 1 return keypoints # @try_this(API()) def simpleMaze(self, side=36, unit=20): f = aMaze(side, 50, 75) # view(f) vec = [] for y in xrange(side + 1): for x in xrange(side + 1): if f[x][y]: vec.append(((unit * x, unit * y), (unit * x + unit, unit * y))) vec.append(((unit * x, unit * y), (unit * x, unit * y + unit))) vec.append(((unit * x, unit * y + unit), (unit * x + unit, unit * y + unit))) vec.append(((unit * x + unit, unit * y), (unit * x + unit, unit * y + unit))) vec = sorted(vec) i = 0 while i + 1 < len(vec): if vec[i] == vec[i + 1]: vec.pop(i + 1) vec.pop(i) else: i += 1 i = 0 while i + 1 < len(vec): j = i + 1 while j < len(vec): if vec[i][1] == vec[j][0]: if vec[i][0][0] == vec[j][1][0] or vec[i][0][1] == vec[j][1][1]: # tmp = vec.pop(j)[1] # vec.insert(i, (vec.pop(i)[0], tmp)) vec.insert(i, (vec.pop(i)[0], vec.pop(j - 1)[1])) continue # if vec[i][0] == vec[j][1]: # if vec[j][0][0] == vec[i][1][0] or vec[j][0][1] == vec[i][1][1]: # tmp = vec.pop(j)[0] # vec.insert(i, (tmp, vec.pop(i)[1])) # continue j += 1 i += 1 vec.append(vec[0]) outstand = [] outline = [] v = [vec.pop(0)] while vec: for i, e in enumerate(vec): if v[-1][1] == e[0]: outline.append(e[0]) v.append(vec.pop(i)) break if v[-1][1] == e[1]: outline.append(e[1]) t = vec.pop(i) v.append((t[1], t[0])) break if v[0][0] == e[1]: outline.insert(0, e[1]) v.insert(0, vec.pop(i)) break if v[0][0] == e[0]: outline.insert(0, e[0]) t = vec.pop(i) v.insert(0, (t[1], t[0])) break else: if v[0][0] == v[-1][1]: outline.append(v[0][0]) outstand.append(outline) outline = [] v = [vec.pop(0)] if outline: outstand.append(outline) outstand.pop(0) outstand[0].reverse() return outstand
def afterInit(self): self.painter = Painter(self.app.scene) self.app.painter = self.painter self.api = API()
class Game(object): def __init__(self): self.turn =1 #Create debugging display debug_win = uc.newwin(15, 30, 0, 0) uc.box(debug_win) uc.wmove(debug_win, 1, 1) uc.waddstr(debug_win, "Debug:") uc.wmove(debug_win, 2, 1) debug_pnl = uc.new_panel(debug_win) uc.move_panel(debug_pnl, glob.CAM_HEIGHT, 32) #Generate the world self.world = Map(glob.N_HEX_ROWS, glob.N_HEX_COLS, debug_win) #map_height: 3 + 2*(rows-1) + 2 for border #map_width: 5 + 4*cols + 2 for border map_win = uc.newwin(glob.CAM_HEIGHT, glob.CAM_WIDTH, 0, 0) self.painter = Painter(glob.N_HEX_ROWS, glob.N_HEX_COLS, map_win) self.painter.updateAllTiles(self.world) #Put world window into a panel map_pnl = uc.new_panel(map_win) uc.move_panel(map_pnl, 1, 1) uc.top_panel(debug_pnl) self.status_win = uc.newwin(10, 30, 0, 0) uc.box(self.status_win) uc.wmove(self.status_win, 1, 1) uc.waddstr(self.status_win, "Turn " + str(self.turn)) status_pnl = uc.new_panel(self.status_win) uc.move_panel(status_pnl, glob.CAM_HEIGHT, 2) self.tile_window = TileWindow() self.painter.drawWindow() showChanges() #input loop while True: sys.stdout.flush() ch = uc.getch() uc.waddstr(debug_win, str(ch)) #Exit Key if ch == Key.ESC: break #Movement Keys elif ch == Key.E: self.movePlayer(HexDir.UL) elif ch == Key.R: self.movePlayer(HexDir.UR) elif ch == Key.S: self.movePlayer(HexDir.L) elif ch == Key.G: self.movePlayer(HexDir.R) elif ch == Key.D: self.movePlayer(HexDir.DL) elif ch == Key.F: self.movePlayer(HexDir.DR) #End Turn Key elif ch == Key.SPACE: self.incrementTurn() #Camera Scrolling Keys #TBD: Remaining order checks elif ch == uc.KEY_UP: self.painter.moveCamera(0, -1*glob.CAM_SPEED) elif ch == uc.KEY_DOWN: self.painter.moveCamera(0, glob.CAM_SPEED) elif ch == uc.KEY_LEFT: self.painter.moveCamera(-1*glob.CAM_SPEED, 0) elif ch == uc.KEY_RIGHT: self.painter.moveCamera(glob.CAM_SPEED, 0) #Toggle drawing borders elif ch == Key.B: self.painter.draw_borders = not self.painter.draw_borders self.painter.updateAllTileBorders(self.world) self.painter.drawWindow() #TODO: This needs to become moveCursor def movePlayer(self, dir): for tile in self.world.tiles: if tile.has_player: pos_x, pos_y = tile.pos break _pos = self.world.neighborAt(pos_x, pos_y, dir) if _pos: _tile = self.world.tileAt(_pos[0], _pos[1]) if _tile.terrain != Terrain.WATER: tile = self.world.tileAt(pos_x, pos_y) #update position on tile map tile.has_player = False _tile.has_player = True #update to window self.painter.updateTileCenter(tile) self.painter.updateTileCenter(_tile) self.painter.drawWindow() #update Tile Info Panel tile_list = _tile.getInfo() self.tile_window.write(tile_list) #increment turn self.incrementTurn() def incrementTurn(self): self.turn +=1 uc.wmove(self.status_win, 1, 6) #6 is pos after string "Turn " uc.waddstr(self.status_win, str(self.turn)) worker_old = self.world.entities[0].my_tile self.world.moveEntities() worker_new = self.world.entities[0].my_tile self.painter.updateTileCenter(worker_old) self.painter.updateTileEdges(worker_old) self.painter.updateTileCenter(worker_new) self.painter.drawWindow() showChanges()