def measure_height(blocks):
    PATH = "tests/measure.sb"

    if isinstance(blocks, kurt.Block):
        blocks = [blocks]

    p = kurt.Project()
    #s = kurt.Sprite(p, "measure")
    #s.costume = kurt.Costume("b", kurt.Image(PIL.Image.new("RGB", (1, 1))))
    s = p.stage
    s.scripts.append(kurt.Script(blocks))
    s.scripts.append(kurt.Script([kurt.Block("say")]))
    #p.sprites.append(s)
    p.convert("scratch14")
    p.save(PATH)

    mtime = os.stat(PATH).st_mtime
    os.system("open %s" % PATH)
    while 1:
        try:
            if os.stat(PATH).st_mtime != mtime:
                break
        except OSError:
            pass

    cp = kurt.Project.load(PATH)
    #scripts = sorted(cp.sprites[0].scripts, key=lambda s: s.pos[1])
    scripts = sorted(cp.stage.scripts, key=lambda s: s.pos[1])
    (x1, y1) = scripts[0].pos
    (x2, y2) = scripts[1].pos
    height = y2 - y1 - 15
    return height
Ejemplo n.º 2
0
    def __init__(self, fp):
        self.zip_file = zipfile.ZipFile(fp, "r")
        self.json = json.load(self.zip_file.open("project.json"))
        self.project = kurt.Project()
        self.list_watchers = []
        self.loaded_images = {}
        self.loaded_sounds = {}
        self.custom_blocks = {}

        # files
        self.image_filenames = {}
        self.sound_filenames = {}

        for filename in self.zip_file.namelist():
            if filename == 'project.json':
                continue
            (name, extension) = os.path.splitext(filename)

            if extension in SOUND_FORMATS:
                self.sound_filenames[int(name)] = filename
            else:
                self.image_filenames[int(name)] = filename

        # info
        self.project.tempo = self.json['tempoBPM']
        self.project.notes = self.json['info'].get('comment', u"")
        self.project.author = self.json['info'].get('author', u"")

        # stage
        self.project.stage = self.load_scriptable(self.json, is_stage=True)

        # sprites
        actors = []
        for cd in self.json['children']:
            if 'objName' in cd:
                sprite = self.load_scriptable(cd)
                self.project.sprites.append(sprite)
                actors.append(sprite)
            else:
                actors.append(cd)

        # watchers
        for actor in actors:
            if not isinstance(actor, kurt.Sprite):
                if 'listName' in actor:
                    continue
                actor = self.load_watcher(actor)
            self.project.actors.append(actor)

        self.project.actors += self.list_watchers
Ejemplo n.º 3
0
    def load(self, fp):
        self.project = kurt.Project()

        # parse object table
        v14_project = scratch_file.parse_stream(fp)
        self.info = decode_obj_table(v14_project.info, self.plugin)
        self.stage = decode_obj_table(v14_project.stage, self.plugin)

        # project info
        self.project.notes = self.info.get('comment', '')
        self.project.author = self.info.get('author', '')

        thumbnail = self.info['thumbnail']
        if thumbnail and isinstance(thumbnail, Form):
            thumbnail = self.UserObject(
                'ImageMedia',
                name='thumbnail',
                form=thumbnail,
            )
        thumbnail_costume = self.load_image(thumbnail)
        if thumbnail_costume:
            self.project.thumbnail = thumbnail_costume.image

        # stage
        self.load_scriptable(self.project.stage, self.stage)
        self.load_lists(self.stage.lists, self.project)

        # global vars
        self.project.variables = self.project.stage.variables
        self.project.stage.variables = {}

        # sprites
        for v14_sprite in self.stage.sprites:
            kurt_sprite = kurt.Sprite(self.project, v14_sprite.name)
            self.load_scriptable(kurt_sprite, v14_sprite)
            self.load_lists(v14_sprite.lists, kurt_sprite)
            self.project.sprites.append(kurt_sprite)

        # variable watchers
        for v14_morph in self.stage.submorphs:
            if v14_morph.class_name == 'WatcherMorph':
                self.project.actors.append(self.load_watcher(v14_morph))

        # TODO: stacking order of actors.

        self.project._original = (self.info, self.stage)  # DEBUG

        return self.project
Ejemplo n.º 4
0
            yield x
        is_other = not is_other


if len(sys.argv) != 3:
    print __doc__
else:
    (_, image_pathname, project_path) = sys.argv

    image_paths = glob.glob(image_pathname)

    #image_paths = list(every_other(image_paths))

    sort_nicely(image_paths)

    p = kurt.Project()
    sprite = kurt.Sprite(p, "frames")
    p.sprites.append(sprite)

    for image_path in image_paths:
        costume = kurt.Costume.load(image_path)
        sprite.costumes.append(costume)

    sprite.parse("""
    when green flag clicked
    forever
        next costume
    end
    """)

    print "%i costumes" % len(sprite.costumes)
Ejemplo n.º 5
0
### End of settings ###

################################################################################


def text_to_image(font, text, color):
    (w, h) = font.getsize(text)
    image = Image.new("RGB", (w, h), BG_COLOR)  #(w*2, h*2))
    draw = ImageDraw.Draw(image)
    draw.text((0, 0), text, color, font=font)
    draw.fontmode = "1"
    #image = image.resize((w, h), Image.ANTIALIAS)
    return image


project = kurt.Project()

y = 170

project.variables = {
    'Fonts.Message': kurt.Variable(),
    'Fonts.x': kurt.Variable(),
    'Fonts.y': kurt.Variable(),
    'Fonts.line_height': kurt.Variable(),
    'Fonts.Font': kurt.Variable(),
}

stage_script = """
when gf clicked
clear
set Fonts.Message to "{MESSAGE}"