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():
"""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 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()
