def update_title(self):
title = self.base_title
title += " [HIGH MAP 0x9C00-0x9FFF]" if self.tilemap.map_offset == constants.HIGH_TILEMAP else \
" [LOW MAP 0x9800-0x9BFF]"
title += " [HIGH DATA (SIGNED) 0x8800-0x97FF]" if self.tilemap.signed_tile_data else \
" [LOW DATA (UNSIGNED) 0x8000-0x8FFF]"
if self.tilemap._select == "WINDOW":
title += " [Window]"
if self.tilemap._select == "BACKGROUND":
title += " [Background]"
sdl2.SDL_SetWindowTitle(self._window, title.encode("utf8"))
def run():
out_blocks = ""
out_images = ""
all_blocks = []
sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO | sdl2.SDL_INIT_EVERYTHING)
sdl_image.IMG_Init(sdl_image.IMG_INIT_PNG)
window = sdl2.ext.Window("BAConv", size=(1024, 384))
window.show()
ren = sdl2.ext.Renderer(window, flags=sdl2.SDL_RENDERER_ACCELERATED)
# makes zoomed graphics blocky (for retro effect)
sdl2.SDL_SetHint(sdl2.SDL_HINT_RENDER_SCALE_QUALITY, b"nearest")
# makes the graphics look and act like the desired screen size, even though they may be rendered at a different one
sdl2.SDL_RenderSetLogicalSize(ren.sdlrenderer, 256, 96)
frames = []
count = 0
limit = 8000 # only deal with this many frames
pass1 = True # True means calculate blocks, False means load from pre-calculated file
if pass1:
# pass 1 - gather all the blocks
for i in range(0, int(6565 / 4)):
# for i in range(43, int(600 / 4)):
count += 1
if count > limit: # stop early
break
events = sdl2.ext.get_events() # otherwise window doesn't update
for event in events:
if event.type == sdl2.SDL_QUIT:
exit(0)
ren.clear()
file = f"image-{i*4+1:03}.png"
sdl2.SDL_SetWindowTitle(window.window, file.encode('utf-8'))
frame = processImage(
file, ren) # also draws left hand side pre-processed
frames.append(frame)
renderImage(frame, ren) # right hand side post-process
sdl2.SDL_RenderPresent(ren.sdlrenderer)
window.refresh()
print(f"Processed {count} frames.")
values = 0
size = 0
for frame in frames:
values += len(frame)
size += frame[1] * (len(frame) - 2) + 1
print(frame)
print(f"Raw values: {values}")
print(f"Average values per frame: {values/len(frames)}")
print(f"Theoretical size: {size/8}")
exit(0)
# store blocks in file
file_lines = []
for block in all_blocks:
file_lines.append(block.serialize())
with open("data_file.txt", "w") as write_file:
write_file.writelines("\n".join(file_lines))
else:
# read in blocks from file (quicker)
with open("data_file.txt", "r") as read_file:
file_lines = read_file.readlines()
all_blocks = []
for line in file_lines:
all_blocks.append(Block.fromData(line.split(",")))
# sort and choose top blocks
all_blocks.sort(reverse=True)
# 1024 is currently all you're planning to store
# todo: choose final number of blocks to use
# all_blocks=all_blocks[0:1024]
for i, b in enumerate(all_blocks):
print(f"Block {i}: {b.count}")
# pass 2 - build new images with top blocks
all_images = []
count = 0
# for i in range(43, int(6509 / 4)):
for i in range(0, int(6565 / 4)):
# for i in range(43, int(600 / 4)):
count += 1
if count > limit: # stop early
break
ren.clear()
file = f"image-{i*4+1:03}.png"
sdl2.SDL_SetWindowTitle(window.window, file.encode('utf-8'))
image = reprocessImage(
file, ren, all_blocks) # also draws left hand side pre-processed
all_images.append(image)
renderImage(image, all_blocks, ren) # right hand side post-process
events = sdl2.ext.get_events() # otherwise window doesn't update
sdl2.SDL_RenderPresent(ren.sdlrenderer)
window.refresh()
# play back final frames in loop
fr = 0
while True:
fr = (fr + 1) % len(all_images)
events = sdl2.ext.get_events() # otherwise window doesn't update
for event in events:
if event.type == sdl2.SDL_QUIT:
exit(0)
ren.clear()
file = f"image-{i*2+1:03}.png"
sdl2.SDL_SetWindowTitle(window.window, file.encode('utf-8'))
renderImage(all_images[fr], all_blocks, ren)
sdl2.SDL_RenderPresent(ren.sdlrenderer)
window.refresh()
def set_title(self, title):
sdl2.SDL_SetWindowTitle(self._window, title.encode())
def update_title(self):
title = self.base_title
title += " " if self.mb.lcd.LCDC.sprite_enable else " [Disabled]"
sdl2.SDL_SetWindowTitle(self._window, title.encode("utf8"))
def update_title(self):
title = self.base_title
title += " [8x16]" if self.mb.lcd.LCDC.sprite_height else " [8x8]"
sdl2.SDL_SetWindowTitle(self._window, title.encode("utf8"))
def title(self, value: str):
data = c_char_p(value.encode())
sdl2.SDL_SetWindowTitle(self._window, data)
self._title = value
def set_caption_message(self, msg):
"""Add a message to the window caption."""
title = self.caption + (' - ' + msg if msg else '')
sdl2.SDL_SetWindowTitle(self.display, title)
def _vispy_set_title(self, title):
if self._id is None:
return
# Set the window title. Has no effect for widgets
sdl2.SDL_SetWindowTitle(self._id.window, title.encode('UTF-8'))
def run():
out_blocks = ""
out_images = ""
all_blocks = []
sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO | sdl2.SDL_INIT_EVERYTHING)
sdl_image.IMG_Init(sdl_image.IMG_INIT_PNG)
window = sdl2.ext.Window("BAConv", size=(1024, 384))
window.show()
ren = sdl2.ext.Renderer(window, flags=sdl2.SDL_RENDERER_ACCELERATED)
# makes zoomed graphics blocky (for retro effect)
sdl2.SDL_SetHint(sdl2.SDL_HINT_RENDER_SCALE_QUALITY, b"nearest")
# makes the graphics look and act like the desired screen size, even though they may be rendered at a different one
sdl2.SDL_RenderSetLogicalSize(ren.sdlrenderer, 256, 96)
max_blocks = 0
total_blocks = 0
count = 0
limit = 100
# pass 1 - gather all the blocks
for i in range(0, int(6565 / 4)):
count += 1
if count > limit: # stop early
break
events = sdl2.ext.get_events() # otherwise window doesn't update
ren.clear()
file = f"image-{i*4+1:03}.png"
sdl2.SDL_SetWindowTitle(window.window, file.encode('utf-8'))
image, blocks = processImage(
file, ren) # also draws left hand side pre-processed
# add blocks to master list
for i, block in enumerate(blocks):
found = False
for j, b in enumerate(all_blocks):
if block == b: # better match found update existing record
all_blocks[j].count += blocks[i].count
found = True # found a match of some sort
if not found: # totally new block
all_blocks.append(block)
num_blocks = len(blocks)
total_blocks += num_blocks
if max_blocks < num_blocks:
max_blocks = num_blocks
renderImage(image, blocks, ren) # right hand side post-process
sdl2.SDL_RenderPresent(ren.sdlrenderer)
window.refresh()
print(f"Max blocks: {max_blocks}")
print(f"Total blocks: {total_blocks}")
print(f"Average blocks: {total_blocks/count}")
print(f"Processed {count} frames.")
# sort and choose top blocks
all_blocks.sort(reverse=True)
# 1024 is currently all you're planning to store
# todo: choose final number of blocks to use
# all_blocks=all_blocks[0:1024]
for i, b in enumerate(all_blocks):
print(f"Block {i}: {b.count}")
# pass 2 - build new images with top blocks
all_images = []
count = 0
for i in range(43, int(6509 / 2)):
count += 1
if count > limit: # stop early
break
ren.clear()
file = f"image-{i*2+1:03}.png"
sdl2.SDL_SetWindowTitle(window.window, file.encode('utf-8'))
image = reprocessImage(
file, ren, all_blocks) # also draws left hand side pre-processed
all_images.append(image)
renderImage(image, all_blocks, ren) # right hand side post-process
events = sdl2.ext.get_events() # otherwise window doesn't update
sdl2.SDL_RenderPresent(ren.sdlrenderer)
window.refresh()
fr = 0
while True:
fr = (fr + 1) % len(all_images)
events = sdl2.ext.get_events() # otherwise window doesn't update
ren.clear()
file = f"image-{i*2+1:03}.png"
sdl2.SDL_SetWindowTitle(window.window, file.encode('utf-8'))
renderImage(all_images[fr], all_blocks, ren)
sdl2.SDL_RenderPresent(ren.sdlrenderer)
window.refresh()
sdl2.SDL_Delay(10)
def start_system() -> None:
sdl(sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING))
window = sdl(
sdl2.SDL_CreateWindow(b"Overwritten by game loop",
sdl2.SDL_WINDOWPOS_UNDEFINED,
sdl2.SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH,
SCREEN_HEIGHT, sdl2.SDL_WINDOW_OPENGL))
renderer = sdl(
sdl2.SDL_CreateRenderer(window, -1, sdl2.SDL_RENDERER_ACCELERATED))
entities.initialize_bullet_pool(renderer)
entities.Entities.append(entities.create_player(renderer))
for i in range(5):
for j in range(3):
x = (i / 5) * SCREEN_WIDTH + (entities.ENEMY_SIZE / 2)
y = j * entities.ENEMY_SIZE + \
(entities.ENEMY_SIZE / 2)
entities.Entities.append(
entities.create_enemy(renderer, Vec2f(x, y)))
event = sdl2.SDL_Event()
running = True
while running:
frame_start_time = sdl2.SDL_GetTicks()
while sdl(sdl2.SDL_PollEvent(ctypes.byref(event))) != 0:
if event.type == sdl2.SDL_QUIT:
running = False
break
sdl(sdl2.SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255))
sdl(sdl2.SDL_RenderClear(renderer))
# Start draw and update subsystem. In a naïve ECS implementation every
# system iterates through the complete list of entities. Below we
# operate on only the active subset of entities.
for entity in entities.Entities:
if entity.active:
entity.draw(renderer)
entity.update()
# Start collision subsystem
check_collisions()
sdl(sdl2.SDL_RenderPresent(renderer))
# Add artificial wait to simulate running game on slow computer
# sdl2.SDL_Delay(100)
# If we're running at half TARGET_TICKS_PER_SECOND, delta is 2. If we're
# running at double TARGET_TICKS_PER_SECOND, delta becomes 0.5.
frame_render_time = sdl2.SDL_GetTicks() - frame_start_time
# Alternatively, we could store just frame_render_time in delta_time and
# defer calculation below to each component.
config.delta_time = (frame_render_time / 1000) * \
TARGET_TICKS_PER_SECOND
sdl2.SDL_SetWindowTitle(
window,
f"""Space Invaders - Delta: {config.delta_time:.2f}, Render: {frame_render_time} ms"""
.encode())
sdl(sdl2.SDL_DestroyRenderer(renderer))
sdl(sdl2.SDL_DestroyWindow(window))
def _set_window_title(self, name):
window_name = f'{name} - CASINT: CASIO Basic Interpreter'.encode()
sdl2.SDL_SetWindowTitle(self.window, window_name)
def run():
out_blocks = ""
out_images = ""
sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO | sdl2.SDL_INIT_EVERYTHING)
sdl_image.IMG_Init(sdl_image.IMG_INIT_PNG)
window = sdl2.ext.Window("BAConv", size=(1024, 384))
window.show()
ren = sdl2.ext.Renderer(window, flags=sdl2.SDL_RENDERER_ACCELERATED)
# makes zoomed graphics blocky (for retro effect)
sdl2.SDL_SetHint(sdl2.SDL_HINT_RENDER_SCALE_QUALITY, b"nearest")
# makes the graphics look and act like the desired screen size, even though they may be rendered at a different one
sdl2.SDL_RenderSetLogicalSize(ren.sdlrenderer, 256, 96)
max_blocks = 0
total_blocks = 0
count = 0
cart = 1
for i in range(0, int(6565 / 2)):
count += 1
# for i in range(254, 355):
# while True:
# i=304
events = sdl2.ext.get_events()
ren.clear()
file = f"image-{i*2+1:03}.png"
sdl2.SDL_SetWindowTitle(window.window, file.encode('utf-8'))
image, blocks = processImage(
file, ren) # also draws left hand side pre-processed
num_blocks = len(blocks)
total_blocks += num_blocks
if max_blocks < num_blocks:
max_blocks = num_blocks
# print(f"New max:{num_blocks}")
renderImage(image, blocks, ren) # right hand side post-process
sdl2.SDL_RenderPresent(ren.sdlrenderer)
window.refresh()
# output encoded image
out_images += '"'
for i in range(0, 192):
if image[i] + 35 == 92:
out_images += '\\\\'
else:
out_images += f"{chr(image[i]+35)}"
out_images += '",\n'
# output encoded blocks
out_blocks += "{"
for block in blocks[2:]:
out_blocks += '"'
for y in range(0, 8):
val = 0
for x in range(0, 8):
if block[y * 8 + x] == 1:
val += 2**x
out_blocks += f"{val:02x}"
out_blocks += '",'
out_blocks += "},\n"
if count % 40 == 0:
output = header.replace(
'$$',
f"{(cart+1):02}") + out_images + middle + out_blocks + footer
outfile = open(f"badbadapple{cart:02}.p8", 'w')
outfile.write(output)
outfile.close()
out_images = ''
out_blocks = ''
cart += 1
print(out_images)
print(f"Max blocks: {max_blocks}")
print(f"Total blocks: {total_blocks}")
print(f"Average blocks: {total_blocks/count}")
print(f"Processed {count} frames.")
