def print_stats():
"""
Print statistics about used ids.
"""
num_used = total_numbers - len(free_numbers)
if num_used > 0:
generic.print_info("Town names: {}/{}".format(num_used, total_numbers))
def print_stats():
"""
Print statistics about used ids.
"""
if param_stats[0] > 0:
generic.print_info("GRF parameter registers: {}/{}".format(
param_stats[0], param_stats[1]))
def print_stats():
"""
Print statistics about used ids.
"""
if len(registered_sounds) > 0:
# Currently NML does not optimise the order of sound effects. So we assume NUM_ANIMATION_SOUNDS as the maximum.
generic.print_info("Sound effects: {}/{}".format(len(registered_sounds), NUM_ANIMATION_SOUNDS))
def print_stats():
"""
Print statistics about used ids.
"""
if free_labels.stats[0] > 0:
generic.print_info("Concurrent Action10 labels: {}/{} ({})".format(
free_labels.stats[0], free_labels.total_amount,
str(free_labels.stats[1])))
def print_stats():
"""
Print statistics about used ids.
"""
for feature in used_ids:
used = feature.get_num_allocated()
if used > 0 and feature.dynamic_allocation:
generic.print_info("{} items: {}/{}".format(feature.name, used, feature.get_max_allocated()))
def print_stats():
"""
Print statistics about used ids.
"""
for t, l in string_ranges.items():
if l['random_id']:
num_used = l['total'] - len(l['ids'])
if num_used > 0:
generic.print_info("{:02X}xx strings: {}/{}".format(t, num_used, l['total']))
def print_stats():
"""
Print statistics about used ids.
"""
if spriteset_stats[0] > 0:
# NML uses as many concurrent spritesets as possible to prevent sprite duplication.
# So, instead of the actual amount, we rather print the biggest unsplittable block, since that is what matters.
generic.print_info("Concurrent spritesets: {}/{} ({})".format(
spriteset_stats[0], max_sprite_block_size,
str(spriteset_stats[1])))
def print_stats():
"""
Print statistics about used ids.
"""
if spritegroup_stats[0] > 0:
generic.print_info("Concurrent spritegroups: {}/{} ({})".format(
spritegroup_stats[0], total_action2_ids,
str(spritegroup_stats[1])))
if a2register_stats[0] > 0:
generic.print_info("Concurrent Action2 registers: {}/{} ({})".format(
a2register_stats[0], total_tmp_locations,
str(a2register_stats[1])))
def open(self, sprite_files):
"""
Start the encoder, read caches, and stuff.
@param sprite_files: List of sprites per source image file.
@type sprite_files: C{dict} that maps (C{tuple} of C{str}) to (C{RealSprite})
"""
num_sprites = sum(
len(sprite_list) for sprite_list in sprite_files.values())
generic.print_progress("Encoding ...")
num_cached = 0
num_dup = 0
num_enc = 0
num_orphaned = 0
count_sprites = 0
for sources, sprite_list in sprite_files.items():
# Iterate over sprites grouped by source image file.
# - Open source files only once. (speed)
# - Do not keep files around for long. (memory)
source_name = "_".join(src for src in sources if src is not None)
local_cache = spritecache.SpriteCache(sources)
local_cache.read_cache()
for sprite_info in sprite_list:
count_sprites += 1
generic.print_progress("Encoding {}/{}: {}".format(
count_sprites, num_sprites, source_name),
incremental=True)
cache_key = sprite_info.get_cache_key(self.crop_sprites)
cache_item = local_cache.get_item(cache_key, self.palette)
in_use = False
in_old_cache = False
if cache_item is not None:
# Write a sprite from the cached data
compressed_data, info_byte, crop_rect, pixel_stats, in_old_cache, in_use = cache_item
if in_use:
num_dup += 1
else:
num_cached += 1
else:
(
size_x,
size_y,
xoffset,
yoffset,
compressed_data,
info_byte,
crop_rect,
pixel_stats,
) = self.encode_sprite(sprite_info)
num_enc += 1
# Store sprite in cache, unless already up-to-date
if not in_use:
cache_item = (compressed_data, info_byte, crop_rect,
pixel_stats, in_old_cache, True)
local_cache.add_item(cache_key, self.palette, cache_item)
# Delete all files from dictionary to free memory
self.cached_image_files.clear()
num_orphaned += local_cache.count_orphaned()
# Only write cache if compression is enabled. Uncompressed data is not worth to be cached.
if self.compress_grf:
local_cache.write_cache()
# Transfer data to global cache for later usage
self.sprite_cache.cached_sprites.update(local_cache.cached_sprites)
generic.print_progress("Encoding ...", incremental=True)
generic.clear_progress()
generic.print_info(
"{} sprites, {} cached, {} orphaned, {} duplicates, {} newly encoded ({})"
.format(num_sprites, num_cached, num_orphaned, num_dup, num_enc,
"native" if lz77.is_native else "python"))
