diff --git a/nml/actions/real_sprite.py b/nml/actions/real_sprite.py

 

     @ivar flags: Cropping/warning flags.

     @type flags: L{expression.ConstantNumeric}

     """

 

         self.param_list = param_list

         self.label = label

         self.is_empty = False

         self.ypos = None

         self.xsize = None

         self.ysize = None

 

     def debug_print(self, indentation):

         generic.print_dbg(indentation, 'Real sprite, parameters:')

             labels[self.label.value] = 0

         return labels, 1

 

 

     def check_sprite_size(self):

         generic.check_range(self.xpos.value,  0, 0x7fffFFFF,   "Real sprite paramater 'xpos'", self.xpos.pos)

         return (rgb_file, rgb_rect, mask_file, mask_rect, do_crop)

 

 class SpriteAction(base_action.BaseAction):

     def __init__(self):

         self.sprite_num = None

         self.last = False

         if self.last: file.newline()

 

 class RecolourSprite(object):

         self.mapping = mapping

         self.label = label

 

     def debug_print(self, indentation):

         generic.print_dbg(indentation, 'Recolour sprite, mapping:')

             labels[self.label.value] = 0

         return labels, 1

 

         # create new struct, needed for template expansion

         new_mapping = []

         for old_assignment in self.mapping:

             to_min_value = old_assignment.value.min.reduce_constant([id_dict])

             to_max_value = None if old_assignment.value.max is None else old_assignment.value.max.reduce_constant([id_dict])

             new_mapping.append(assignment.Assignment(assignment.Range(from_min_value, from_max_value), assignment.Range(to_min_value, to_max_value), old_assignment.pos))

 

     def __str__(self):

         ret = "" if self.label is None else str(self.label) + ": "

             labels[self.label.value] = 0

         return labels, offset

 

         if self.name.value not in sprite_template_map:

             raise generic.ScriptError("Encountered unknown template identifier: " + self.name.value, self.name.pos)

         template = sprite_template_map[self.name.value]

                 raise generic.ScriptError("Template parameters should be compile-time constants", param.pos)

             param_dict[template.param_list[i].value] = param.value

 

 

     def __str__(self):

         return "{}({})".format(self.name, ", ".join(str(param) for param in self.param_list))

 

 

     # check the number of parameters

     num_param = len(sprite.param_list)

     if num_param == 0:

 

     # create new sprite struct, needed for template expansion

     new_sprite = RealSprite()

 

     param_offset = 0

 

 

 sprite_template_map = {}

 

     real_sprite_list = []

     for sprite in sprite_list:

     return real_sprite_list

 

 def parse_sprite_data(sprite_container):

     first = True

 

     for sprite_data in all_sprite_data:

         if not first and len(new_sprite_list) != len(action_list):

             msg = "Expected {:d} alternative sprites for {} '{}', got {:d}."

             msg = msg.format(len(action_list), sprite_container.block_type, sprite_container.block_name.value, len(new_sprite_list))

diff --git a/nml/ast/sprite_container.py b/nml/ast/sprite_container.py

     @type block_name: L{Identifier}, or C{None} if N/A

 

     @ivar sprite_data: Mapping of (zoom level, bit-depth) to (sprite list, default file)

     """

     sprite_blocks = {}

 

                    "level / bit depth combination. This data will be overridden.")

             msg = msg.format(self.block_type, self.block_name.value)

             generic.print_warning(msg, pos)

 

     def get_all_sprite_data(self):

         """

         """

 

     @classmethod

     def resolve_sprite_block(cls, block_name):

diff --git a/nml/generic.py b/nml/generic.py

     """

     Generic (not position-dependant) error with an image file

     """

 

     def __str__(self):

         return 'Image file "{}"'.format(self.filename)

         ScriptError.__init__(self, name + " out of range " + str(min_value) + ".." + str(max_value) + ", encountered " + str(value), pos)

 

 class ImageError(ScriptError):

 

 class OnlyOnceError(ScriptError):

     """

diff --git a/nml/parser.py b/nml/parser.py

         '''real_sprite : LBRACKET expression_list RBRACKET

                        | ID COLON LBRACKET expression_list RBRACKET'''

         if len(t) == 4:

         else:

 

     def p_recolour_assignment_list(self, t):

         '''recolour_assignment_list :

diff --git a/nml/spriteencoder.py b/nml/spriteencoder.py

         if filename_32bpp is not None:

             im = self.open_image_file(filename_32bpp.value)

             if im.mode not in ("RGB", "RGBA"):

             info_byte |= INFO_RGB

             if im.mode == "RGBA":

                 info_byte |= INFO_ALPHA

 

             (im_width, im_height) = im.size

             if x < 0 or y < 0 or x + size_x > im_width or y + size_y > im_height:

             sprite = im.crop((x, y, x + size_x, y + size_y))

             rgb_sprite_data = sprite.tostring()

 

         if filename_8bpp is not None:

             mask_im = self.open_image_file(filename_8bpp.value)

             if mask_im.mode != "P":

             im_mask_pal = palette.validate_palette(mask_im, filename_8bpp.value)

             info_byte |= INFO_PAL

 

             (im_width, im_height) = mask_im.size

             if mask_x < 0 or mask_y < 0 or mask_x + size_x > im_width or mask_y + size_y > im_height:

             mask_sprite = mask_im.crop((mask_x, mask_y, mask_x + size_x, mask_y + size_y))

 

             mask_sprite_data = self.palconvert(mask_sprite.tostring(), im_mask_pal)

         else:

             return sprite_str