sb3tosb2.py

import audioop
import hashlib
import io
import json
import sys
import wave
import zipfile

sys.setrecursionlimit(4100)


def printWarning(message):
    print("WARNING: " + message)


def printError(message, gui):
    if gui:
        messagebox.showerror('Error', message, icon='warning')
    else:
        lines = message.split('\n')
        lines = ["       " + line for line in lines]
        lines[0] = "ERROR: " + lines[0][7:]
        print('\n'.join(lines))
        input('Press enter to exit... ')
    exit()


def rightPad(s, l, c):
    assert type(s) == str and type(c) == str
    return s + (l * c)


class BlockArgMapper:
    stageAttrs = {
        'backdrop #',
        'backdrop name',
        'volume'
    }

    spriteAttrs = {
        'x position',
        'y position',
        'direction',
        'costume #',
        'costume name',
        'size',
        'volume'
    }

    def __init__(self, obj):
        assert type(obj) == ProjectConverter
        self.converter = obj

    def mapArgs(self, opcode, block, blocks):
        assert not opcode.startswith('__')
        return getattr(self, opcode)(block, blocks)

    def varName(self, name):
        if type(name) == str:
            return ('\xa0' if self.converter.compat else '') + name
        else:
            if self.converter.compat:
                return ['concatenate:with:', '\xa0', name]
            else:
                return name

    # Motion

    def motion_movesteps(self, block, blocks):
        output = ['forward:', self.converter.inputVal('STEPS', block, blocks)]
        return output

    def motion_turnright(self, block, blocks):
        output = ['turnRight:', self.converter.inputVal('DEGREES', block, blocks)]
        return output

    def motion_turnleft(self, block, blocks):
        output = ['turnLeft:', self.converter.inputVal('DEGREES', block, blocks)]
        return output

    def motion_pointindirection(self, block, blocks):
        output = ['heading:', self.converter.inputVal('DIRECTION', block, blocks)]
        return output

    def motion_pointtowards(self, block, blocks):
        output = ['pointTowards:', self.converter.inputVal('TOWARDS', block, blocks)]
        return output

    def motion_gotoxy(self, block, blocks):
        output = ['gotoX:y:', self.converter.inputVal('X', block, blocks), self.converter.inputVal('Y', block, blocks)]
        return output

    def motion_goto(self, block, blocks):
        output = ['gotoSpriteOrMouse:', self.converter.inputVal('TO', block, blocks)]
        return output

    def motion_glidesecstoxy(self, block, blocks):
        output = ['glideSecs:toX:y:elapsed:from:', self.converter.inputVal('SECS', block, blocks),
                  self.converter.inputVal('X', block, blocks), self.converter.inputVal('Y', block, blocks)]
        return output

    def motion_changexby(self, block, blocks):
        output = ['changeXposBy:', self.converter.inputVal('DX', block, blocks)]
        return output

    def motion_setx(self, block, blocks):
        output = ['xpos:', self.converter.inputVal('X', block, blocks)]
        return output

    def motion_changeyby(self, block, blocks):
        output = ['changeYposBy:', self.converter.inputVal('DY', block, blocks)]
        return output

    def motion_sety(self, block, blocks):
        output = ['ypos:', self.converter.inputVal('Y', block, blocks)]
        return output

    def motion_ifonedgebounce(self, block, blocks):
        return ['bounceOffEdge']

    def motion_setrotationstyle(self, block, blocks):
        output = ['setRotationStyle', self.converter.fieldVal('STYLE', block)]
        return output

    def motion_xposition(self, block, blocks):
        return ['xpos']

    def motion_yposition(self, block, blocks):
        return ['ypos']

    def motion_direction(self, block, blocks):
        return ['heading']

    def motion_scroll_right(self, block, blocks):
        output = ['scrollRight', self.converter.inputVal('DISTANCE', block, blocks)]
        return output

    def motion_scroll_up(self, block, blocks):
        output = ['scrollUp', self.converter.inputVal('DISTANCE', block, blocks)]
        return output

    def motion_align_scene(self, block, blocks):
        output = ['scrollAlign', self.converter.fieldVal('ALIGNMENT', block)]
        return output

    def motion_xscroll(self, block, blocks):
        return ['xScroll']

    def motion_yscroll(self, block, blocks):
        return ['yScroll']

    # Looks

    def looks_sayforsecs(self, block, blocks):
        output = ['say:duration:elapsed:from:', self.converter.inputVal('MESSAGE', block, blocks),
                  self.converter.inputVal('SECS', block, blocks)]
        return output

    def looks_say(self, block, blocks):
        output = ['say:', self.converter.inputVal('MESSAGE', block, blocks)]
        return output

    def looks_thinkforsecs(self, block, blocks):
        output = ['think:duration:elapsed:from:', self.converter.inputVal('MESSAGE', block, blocks),
                  self.converter.inputVal('SECS', block, blocks)]
        return output

    def looks_think(self, block, blocks):
        output = ['think:', self.converter.inputVal('MESSAGE', block, blocks)]
        return output

    def looks_show(self, block, blocks):
        return ['show']

    def looks_hide(self, block, blocks):
        return ['hide']

    def looks_hideallsprites(self, block, blocks):
        return ['hideAll']

    def looks_switchcostumeto(self, block, blocks):
        output = ['lookLike:', self.converter.inputVal('COSTUME', block, blocks)]
        return output

    def looks_nextcostume(self, block, blocks):
        return ['nextCostume']

    def looks_switchbackdropto(self, block, blocks):
        output = ['startScene', self.converter.inputVal('BACKDROP', block, blocks)]
        return output

    def looks_nextbackdrop(self, block, blocks):
        return ['nextScene']

    def looks_changeeffectby(self, block, blocks):
        output = ['changeGraphicEffect:by:']
        field = self.converter.fieldVal('EFFECT', block)
        if type(field) == str:
            field = str.lower(field)
        output.append(field)
        output.append(self.converter.inputVal('CHANGE', block, blocks))
        return output

    def looks_seteffectto(self, block, blocks):
        output = ['setGraphicEffect:to:']
        field = self.converter.fieldVal('EFFECT', block)
        if type(field) == str:
            field = str.lower(field)
        output.append(field)
        output.append(self.converter.inputVal('VALUE', block, blocks))
        return output

    def looks_cleargraphiceffects(self, block, blocks):
        return ['filterReset']

    def looks_changesizeby(self, block, blocks):
        output = ['changeSizeBy:', self.converter.inputVal('CHANGE', block, blocks)]
        return output

    def looks_setsizeto(self, block, blocks):
        output = ['setSizeTo:', self.converter.inputVal('SIZE', block, blocks)]
        return output

    def looks_changestretchby(self, block, blocks):
        output = ['changeStretchBy:', self.converter.inputVal('CHANGE', block, blocks)]
        return output

    def looks_setstretchto(self, block, blocks):
        output = ['setStretchTo:', self.converter.inputVal('STRETCH', block, blocks)]
        return output

    def looks_gotofrontback(self, block, blocks):
        field = self.converter.fieldVal('FRONT_BACK', block)
        if field == 'front':
            return ['comeToFront']
        else:
            return ['goBackByLayers:', 1.79e+308]

    def looks_goforwardbackwardlayers(self, block, blocks):
        layers = self.converter.inputVal('NUM', block, blocks)
        field = self.converter.fieldVal('FORWARD_BACKWARD', block)
        if field == 'forward':
            if type(layers) == str:
                try:
                    layers = float(layers)
                except Exception as ex:
                    pass
            if type(layers) == float or type(layers) == int:
                layers *= -1
            else:
                layers = ['*', -1, layers]
        return ['goBackByLayers:', layers]

    def looks_costumenumbername(self, block, blocks):
        field = self.converter.fieldVal('NUMBER_NAME', block)
        if field == 'number':
            return ['costumeIndex']
        elif field == 'name':
            if not self.converter.convertingMonitors:
                if self.converter.compat:  # Can't use getAttribute:of: because it doesn't work for clones
                    self.converter.costumeName = True
                    return ['getLine:ofList:', ['costumeIndex'], self.converter.compatVarName('costume names')]
                else:
                    self.converter.generateWarning("Incompatible block 'costume [name v]'")
                    self.converter.compatWarning = True
                    return ['costumeName']

    def looks_backdropnumbername(self, block, blocks):
        field = self.converter.fieldVal('NUMBER_NAME', block)
        if field == 'number':
            return ['backgroundIndex']
        elif field == 'name':
            return ['sceneName']

    def looks_size(self, block, blocks):
        return ['scale']

    def looks_switchbackdroptoandwait(self, block, blocks):
        output = ['startSceneAndWait', self.converter.inputVal('BACKDROP', block, blocks)]
        return output

    # Sound

    def sound_play(self, block, blocks):
        output = ['playSound:', self.converter.inputVal('SOUND_MENU', block, blocks)]
        return output

    def sound_playuntildone(self, block, blocks):
        output = ['doPlaySoundAndWait', self.converter.inputVal('SOUND_MENU', block, blocks)]
        return output

    def sound_stopallsounds(self, block, blocks):
        return ['stopAllSounds']

    def sound_changevolumeby(self, block, blocks):
        output = ['changeVolumeBy:', self.converter.inputVal('VOLUME', block, blocks)]
        return output

    def sound_setvolumeto(self, block, blocks):
        output = ['setVolumeTo:', self.converter.inputVal('VOLUME', block, blocks)]
        return output

    def sound_volume(self, block, blocks):
        return ['volume']

    # Music

    def music_playDrumForBeats(self, block, blocks):
        output = ['playDrum', self.converter.inputVal('DRUM', block, blocks),
                  self.converter.inputVal('BEATS', block, blocks)]
        return output

    def music_midiPlayDrumForBeats(self, block, blocks):
        output = ['drum:duration:elapsed:from:', self.converter.inputVal('DRUM', block, blocks),
                  self.converter.inputVal('BEATS', block, blocks)]
        return output

    def music_restForBeats(self, block, blocks):
        output = ['rest:elapsed:from:', self.converter.inputVal('BEATS', block, blocks)]
        return output

    def music_playNoteForBeats(self, block, blocks):
        output = ['noteOn:duration:elapsed:from:', self.converter.inputVal('NOTE', block, blocks),
                  self.converter.inputVal('BEATS', block, blocks)]
        return output

    def music_setInstrument(self, block, blocks):
        output = ['instrument:', self.converter.inputVal('INSTRUMENT', block, blocks)]
        return output

    def music_midiSetInstrument(self, block, blocks):
        output = ['midiInstrument:', self.converter.inputVal('INSTRUMENT', block, blocks)]
        return output

    def music_changeTempo(self, block, blocks):
        output = ['changeTempoBy:', self.converter.inputVal('TEMPO', block, blocks)]
        return output

    def music_setTempo(self, block, blocks):
        output = ['setTempoTo:', self.converter.inputVal('TEMPO', block, blocks)]
        return output

    def music_getTempo(self, block, blocks):
        return ['tempo']

    # Pen

    def pen_clear(self, block, blocks):
        return ['clearPenTrails']

    def pen_stamp(self, block, blocks):
        return ['stampCostume']

    def pen_penDown(self, block, blocks):
        if self.converter.compat:
            self.converter.penUpDown = True
            return ['call', 'pen down']
        else:
            return ['putPenDown']

    def pen_penUp(self, block, blocks):
        if self.converter.compat:
            self.converter.penUpDown = True
            return ['call', 'pen up']
        else:
            return ['putPenUp']

    def pen_setPenColorToColor(self, block, blocks):
        if self.converter.compat:
            self.converter.penColor = True
            output = ['call', 'set pen color to %c']
        else:
            output = ['penColor:']
        output.append(self.converter.inputVal('COLOR', block, blocks))
        return output

    def pen_changePenHueBy(self, block, blocks):
        if self.converter.compat:
            self.converter.penColor = True
            output = ['call', 'change pen color by %n']
        else:
            output = ['changePenHueBy:']
        output.append(self.converter.inputVal('HUE', block, blocks))
        return output

    def pen_setPenHueToNumber(self, block, blocks):
        if self.converter.compat:
            self.converter.penColor = True
            output = ['call', 'set pen color to %n']
        else:
            output = ['setPenHueTo:']
        output.append(self.converter.inputVal('HUE', block, blocks))
        return output

    def pen_changePenShadeBy(self, block, blocks):
        if self.converter.compat:
            self.converter.penColor = True
            output = ['call', 'change pen shade by %n']
        else:
            output = ['changePenShadeBy:']
        output.append(self.converter.inputVal('SHADE', block, blocks))
        return output

    def pen_setPenShadeToNumber(self, block, blocks):
        if self.converter.compat:
            self.converter.penColor = True
            output = ['call', 'set pen shade to %n']
        else:
            output = ['setPenShadeTo:']
        output.append(self.converter.inputVal('SHADE', block, blocks))
        return output

    def pen_changePenColorParamBy(self, block, blocks):
        param = self.converter.inputVal('COLOR_PARAM', block, blocks)
        value = self.converter.inputVal('VALUE', block, blocks)
        if self.converter.compat:
            self.converter.penColor = True
            return ['call', 'change pen %s by %n', param, value]
        else:
            self.converter.compatWarning = True
            if param == 'color':
                if type(value) == str:
                    try:
                        value = float(value)
                    except Exception as ex:
                        pass
                if type(value) == float or type(value) == int:
                    value *= 2
                else:
                    value = ['*', 2, value]
                output = ['changePenHueBy:', value]
                return output
            elif param == 'brightness':
                if type(value) == str:
                    try:
                        value = float(value)
                    except Exception as ex:
                        pass
                if type(value) == float or type(value) == int:
                    value /= 2
                else:
                    value = ['/', value, 2]
                output = ['changePenShadeBy:', value]
                return output
            else:
                if type(param) == list:
                    paramStr = '[blocks...]'
                else:
                    paramStr = param
                self.converter.generateWarning(f"Incompatible block 'change pen [{paramStr} v] by ({value})'")
                return ['pen_changeColorParamBy', value, param]

    def pen_setPenColorParamTo(self, block, blocks):
        param = self.converter.inputVal('COLOR_PARAM', block, blocks)
        value = self.converter.inputVal('VALUE', block, blocks)
        if self.converter.compat:
            self.converter.penColor = True
            return ['call', 'set pen %s to %n', param, value]
        else:
            self.converter.compatWarning = True
            if param == 'color':
                if type(value) == str:
                    try:
                        value = float(value)
                    except Exception as ex:
                        pass
                if type(value) == float or type(value) == int:
                    value *= 2
                else:
                    value = ['*', 2, value]
                output = ['setPenHueTo:', value]
                return output
            elif param == 'brightness':
                if type(value) == str:
                    try:
                        value = float(value)
                    except Exception as ex:
                        pass
                if type(value) == float or type(value) == int:
                    value /= 2
                else:
                    value = ['/', value, 2]
                output = ['setPenShadeTo:', value]
                return output
            else:
                if type(param) == list:
                    paramStr = '[blocks...]'
                else:
                    paramStr = param
                self.converter.generateWarning(f"Incompatible block 'set pen [{paramStr} v] to ({value})'")
                return ['pen_setPenColorParamTo', value, param]

    def pen_changePenSizeBy(self, block, blocks):
        output = ['changePenSizeBy:', self.converter.inputVal('SIZE', block, blocks)]
        return output

    def pen_setPenSizeTo(self, block, blocks):
        output = ['penSize:', self.converter.inputVal('SIZE', block, blocks)]
        return output

    # Events

    def event_whenflagclicked(self, block, blocks):
        return ['whenGreenFlag']

    def event_whenkeypressed(self, block, blocks):
        output = ['whenKeyPressed', self.converter.fieldVal('KEY_OPTION', block)]
        return output

    def event_whenthisspriteclicked(self, block, blocks):
        return ['whenClicked']

    def event_whenstageclicked(self, block, blocks):
        return ['whenClicked']

    def event_whenbackdropswitchesto(self, block, blocks):
        output = ['whenSceneStarts', self.converter.fieldVal('BACKDROP', block)]
        return output

    def event_whengreaterthan(self, block, blocks):
        output = ['whenSensorGreaterThan']
        field = self.converter.fieldVal('WHENGREATERTHANMENU', block)
        if type(field) == str:
            field = str.lower(field)
        output.append(field)
        output.append(self.converter.inputVal('VALUE', block, blocks))
        return output

    def event_whenbroadcastreceived(self, block, blocks):
        output = ['whenIReceive', self.converter.fieldVal('BROADCAST_OPTION', block)]
        return output

    def event_broadcast(self, block, blocks):
        output = ['broadcast:', self.converter.inputVal('BROADCAST_INPUT', block, blocks)]
        return output

    def event_broadcastandwait(self, block, blocks):
        output = ['doBroadcastAndWait', self.converter.inputVal('BROADCAST_INPUT', block, blocks)]
        return output

    # Control

    def control_wait(self, block, blocks):
        output = ['wait:elapsed:from:', self.converter.inputVal('DURATION', block, blocks)]
        return output

    def control_repeat(self, block, blocks):
        output = ['doRepeat', self.converter.inputVal('TIMES', block, blocks),
                  self.converter.substackVal('SUBSTACK', block, blocks)]
        return output

    def control_forever(self, block, blocks):
        output = ['doForever', self.converter.substackVal('SUBSTACK', block, blocks)]
        return output

    def control_if(self, block, blocks):
        output = ['doIf', self.converter.inputVal('CONDITION', block, blocks),
                  self.converter.substackVal('SUBSTACK', block, blocks)]
        return output

    def control_if_else(self, block, blocks):
        output = ['doIfElse', self.converter.inputVal('CONDITION', block, blocks),
                  self.converter.substackVal('SUBSTACK', block, blocks),
                  self.converter.substackVal('SUBSTACK2', block, blocks)]
        return output

    def control_wait_until(self, block, blocks):
        output = ['doWaitUntil', self.converter.inputVal('CONDITION', block, blocks)]
        return output

    def control_repeat_until(self, block, blocks):
        output = ['doUntil', self.converter.inputVal('CONDITION', block, blocks),
                  self.converter.substackVal('SUBSTACK', block, blocks)]
        return output

    def control_while(self, block, blocks):
        output = ['doWhile', self.converter.inputVal('CONDITION', block, blocks),
                  self.converter.substackVal('SUBSTACK', block, blocks)]
        return output

    def control_for_each(self, block, blocks):
        output = ['doForLoop', self.converter.fieldVal('VARIABLE', block),
                  self.converter.inputVal('VALUE', block, blocks),
                  self.converter.substackVal('SUBSTACK', block, blocks)]
        return output

    def control_stop(self, block, blocks):
        output = ['stopScripts', self.converter.fieldVal('STOP_OPTION', block)]
        return output

    def control_start_as_clone(self, block, blocks):
        return ['whenCloned']

    def control_create_clone_of(self, block, blocks):
        output = ['createCloneOf', self.converter.inputVal('CLONE_OPTION', block, blocks)]
        return output

    def control_delete_this_clone(self, block, blocks):
        return ['deleteClone']

    def control_get_counter(self, block, blocks):
        return ['COUNT']

    def control_incr_counter(self, block, blocks):
        return ['INCR_COUNT']

    def control_clear_counter(self, block, blocks):
        return ['CLR_COUNT']

    def control_all_at_once(self, block, blocks):
        output = ['warpSpeed', self.converter.substackVal('SUBSTACK', block, blocks)]
        return output

    # Video Sensing

    def videoSensing_videoOn(self, block, blocks):
        output = ['senseVideoMotion', self.converter.inputVal('ATTRIBUTE', block, blocks),
                  self.converter.inputVal('SUBJECT', block, blocks)]
        return output

    def videoSensing_whenMotionGreaterThan(self, block, blocks):
        output = ['whenSensorGreaterThan', 'video motion', self.converter.inputVal('REFERENCE', block, blocks)]
        return output

    def videoSensing_videoToggle(self, block, blocks):
        output = ['setVideoState', self.converter.inputVal('VIDEO_STATE', block, blocks)]
        return output

    def videoSensing_setVideoTransparency(self, block, blocks):
        output = ['setVideoTransparency', self.converter.inputVal('TRANSPARENCY', block, blocks)]
        return output

    # Sensing

    def sensing_touchingobject(self, block, blocks):
        output = ['touching:', self.converter.inputVal('TOUCHINGOBJECTMENU', block, blocks)]
        return output

    def sensing_touchingcolor(self, block, blocks):
        output = ['touchingColor:', self.converter.inputVal('COLOR', block, blocks)]
        return output

    def sensing_coloristouchingcolor(self, block, blocks):
        output = ['color:sees:', self.converter.inputVal('COLOR', block, blocks),
                  self.converter.inputVal('COLOR2', block, blocks)]
        return output

    def sensing_distanceto(self, block, blocks):
        output = ['distanceTo:', self.converter.inputVal('DISTANCETOMENU', block, blocks)]
        return output

    def sensing_askandwait(self, block, blocks):
        output = ['doAsk', self.converter.inputVal('QUESTION', block, blocks)]
        return output

    def sensing_answer(self, block, blocks):
        return ['answer']

    def sensing_keypressed(self, block, blocks):
        output = ['keyPressed:', self.converter.inputVal('KEY_OPTION', block, blocks)]
        return output

    def sensing_mousedown(self, block, blocks):
        return ['mousePressed']

    def sensing_mousex(self, block, blocks):
        return ['mouseX']

    def sensing_mousey(self, block, blocks):
        return ['mouseY']

    def sensing_setdragmode(self, block, blocks):
        assert self.converter.compat
        self.converter.dragMode = True
        return ['call', 'set drag mode %s', self.converter.fieldVal('DRAG_MODE', block)]

    def sensing_loudness(self, block, blocks):
        return ['soundLevel']

    def sensing_loud(self, block, blocks):
        return ['isLoud']

    def sensing_timer(self, block, blocks):
        if self.converter.compat:
            self.converter.timerCompat = True
            return ['*', 86400, ['-', ['timestamp'], ['readVariable', 'reset time']]]
        else:
            self.converter.compatWarning = True
            return ['timer']

    def sensing_resettimer(self, block, blocks):
        if self.converter.compat:
            self.converter.resetTimer = True
            self.converter.timerCompat = True
            return ['call', 'reset timer']
        else:
            return ['timerReset']

    def sensing_of(self, block, blocks):
        attr = self.converter.fieldVal('PROPERTY', block)
        obj = self.converter.inputVal('OBJECT', block, blocks)
        if obj == '_stage_':
            if (type(attr) == list) or (attr not in BlockArgMapper.stageAttrs):
                attr = self.varName(attr)
        elif (type(attr) == list) or (attr not in BlockArgMapper.spriteAttrs):
            attr = self.varName(attr)
        return ['getAttribute:of:', attr, obj]

    def sensing_current(self, block, blocks):
        output = ['timeAndDate']
        field = self.converter.fieldVal('CURRENTMENU', block)
        if type(field) == str:
            field = str.lower(field)
        output.append(field)
        return output

    def sensing_dayssince2000(self, block, blocks):
        return ['timestamp']

    def sensing_username(self, block, blocks):
        if not self.converter.convertingMonitors:
            return ['getUserName']

    def sensing_userid(self, block, blocks):
        return ['getUserId']

    # Operators

    def operator_add(self, block, blocks):
        output = ['+', self.converter.inputVal('NUM1', block, blocks), self.converter.inputVal('NUM2', block, blocks)]
        return output

    def operator_subtract(self, block, blocks):
        output = ['-', self.converter.inputVal('NUM1', block, blocks), self.converter.inputVal('NUM2', block, blocks)]
        return output

    def operator_multiply(self, block, blocks):
        output = ['*', self.converter.inputVal('NUM1', block, blocks), self.converter.inputVal('NUM2', block, blocks)]
        return output

    def operator_divide(self, block, blocks):
        output = ['/', self.converter.inputVal('NUM1', block, blocks), self.converter.inputVal('NUM2', block, blocks)]
        return output

    def operator_random(self, block, blocks):
        output = ['randomFrom:to:', self.converter.inputVal('FROM', block, blocks),
                  self.converter.inputVal('TO', block, blocks)]
        return output

    def operator_gt(self, block, blocks):
        output = ['>', self.converter.inputVal('OPERAND1', block, blocks),
                  self.converter.inputVal('OPERAND2', block, blocks)]
        return output

    def operator_lt(self, block, blocks):
        output = ['<', self.converter.inputVal('OPERAND1', block, blocks),
                  self.converter.inputVal('OPERAND2', block, blocks)]
        return output

    def operator_equals(self, block, blocks):
        output = ['=', self.converter.inputVal('OPERAND1', block, blocks),
                  self.converter.inputVal('OPERAND2', block, blocks)]
        return output

    def operator_and(self, block, blocks):
        output = ['&', self.converter.inputVal('OPERAND1', block, blocks),
                  self.converter.inputVal('OPERAND2', block, blocks)]
        return output

    def operator_or(self, block, blocks):
        output = ['|', self.converter.inputVal('OPERAND1', block, blocks),
                  self.converter.inputVal('OPERAND2', block, blocks)]
        return output

    def operator_not(self, block, blocks):
        output = ['not', self.converter.inputVal('OPERAND', block, blocks)]
        return output

    def operator_join(self, block, blocks):
        if self.converter.unlimJoin:
            self.converter.joinStr = True
            stackReporter = ['call', 'join %s %s', self.converter.inputVal('STRING1', block, blocks),
                             self.converter.inputVal('STRING2', block, blocks)]
            self.converter.compatStackReporters[-1].append(stackReporter)
            return ['getLine:ofList:', len(self.converter.compatStackReporters[-1]),
                    self.converter.compatVarName('results')]
        else:
            output = ['concatenate:with:', self.converter.inputVal('STRING1', block, blocks),
                      self.converter.inputVal('STRING2', block, blocks)]
            return output

    def operator_letter_of(self, block, blocks):
        output = ['letter:of:', self.converter.inputVal('LETTER', block, blocks),
                  self.converter.inputVal('STRING', block, blocks)]
        return output

    def operator_length(self, block, blocks):
        output = ['stringLength:', self.converter.inputVal('STRING', block, blocks)]
        return output

    def operator_contains(self, block, blocks):
        assert self.converter.compat
        self.converter.strContains = True
        stackReporter = ['call', '%s contains %s ?', self.converter.inputVal('STRING1', block, blocks),
                         self.converter.inputVal('STRING2', block, blocks)]
        self.converter.compatStackReporters[-1].append(stackReporter)
        return ['getLine:ofList:', len(self.converter.compatStackReporters[-1]),
                self.converter.compatVarName('results')]

    def operator_mod(self, block, blocks):
        output = ['%', self.converter.inputVal('NUM1', block, blocks), self.converter.inputVal('NUM2', block, blocks)]
        return output

    def operator_round(self, block, blocks):
        output = ['rounded', self.converter.inputVal('NUM', block, blocks)]
        return output

    def operator_mathop(self, block, blocks):
        output = ['computeFunction:of:', self.converter.fieldVal('OPERATOR', block),
                  self.converter.inputVal('NUM', block, blocks)]
        return output

    # Data

    def data_variable(self, block, blocks):
        output = ['readVariable', self.converter.fieldVal('VARIABLE', block)]
        return output

    def data_setvariableto(self, block, blocks):
        output = ['setVar:to:', self.converter.fieldVal('VARIABLE', block),
                  self.converter.inputVal('VALUE', block, blocks)]
        return output

    def data_changevariableby(self, block, blocks):
        output = ['changeVar:by:', self.converter.fieldVal('VARIABLE', block),
                  self.converter.inputVal('VALUE', block, blocks)]
        return output

    def data_showvariable(self, block, blocks):
        output = ['showVariable:', self.converter.fieldVal('VARIABLE', block)]
        return output

    def data_hidevariable(self, block, blocks):
        output = ['hideVariable:', self.converter.fieldVal('VARIABLE', block)]
        return output

    def data_listcontents(self, block, blocks):
        output = ['contentsOfList:', self.converter.fieldVal('LIST', block)]
        return output

    def data_addtolist(self, block, blocks):
        if self.converter.limList:
            self.converter.addList = True
            output = ['call', 'add %s to %m.list']
        else:
            output = ['append:toList:']
        output.append(self.converter.inputVal('ITEM', block, blocks))
        output.append(self.converter.fieldVal('LIST', block))
        return output

    def data_deleteoflist(self, block, blocks):
        output = ['deleteLine:ofList:', self.converter.inputVal('INDEX', block, blocks),
                  self.converter.fieldVal('LIST', block)]
        return output

    def data_deletealloflist(self, block, blocks):
        output = ['deleteLine:ofList:', 'all', self.converter.fieldVal('LIST', block)]
        return output

    def data_insertatlist(self, block, blocks):
        if self.converter.limList:
            self.converter.insertList = True
            output = ['call', 'insert %s at %n of %m.list']
        else:
            output = ['insert:at:ofList:']
        output.append(self.converter.inputVal('ITEM', block, blocks))
        output.append(self.converter.inputVal('INDEX', block, blocks))
        output.append(self.converter.fieldVal('LIST', block))
        return output

    def data_replaceitemoflist(self, block, blocks):
        output = ['setLine:ofList:to:', self.converter.inputVal('INDEX', block, blocks),
                  self.converter.fieldVal('LIST', block), self.converter.inputVal('ITEM', block, blocks)]
        return output

    def data_itemoflist(self, block, blocks):
        output = ['getLine:ofList:', self.converter.inputVal('INDEX', block, blocks),
                  self.converter.fieldVal('LIST', block)]
        return output

    def data_itemnumoflist(self, block, blocks):
        assert self.converter.compat
        self.converter.listSearch = True
        stackReporter = ['call', 'item # of %s in %m.list', self.converter.inputVal('ITEM', block, blocks),
                         self.converter.fieldVal('LIST', block)]
        self.converter.compatStackReporters[-1].append(stackReporter)
        return ['getLine:ofList:', len(self.converter.compatStackReporters[-1]),
                self.converter.compatVarName('results')]

    def data_lengthoflist(self, block, blocks):
        output = ['lineCountOfList:', self.converter.fieldVal('LIST', block)]
        return output

    def data_listcontainsitem(self, block, blocks):
        output = ['list:contains:', self.converter.fieldVal('LIST', block),
                  self.converter.inputVal('ITEM', block, blocks)]
        return output

    def data_showlist(self, block, blocks):
        output = ['showList:', self.converter.fieldVal('LIST', block)]
        return output

    def data_hidelist(self, block, blocks):
        output = ['hideList:', self.converter.fieldVal('LIST', block)]
        return output

    # Procedures

    def procedures_definition(self, block, blocks):
        block = blocks[block['inputs']['custom_block'][1]]
        procData = block['mutation']
        output = ['procDef', self.varName(procData['proccode']), json.loads(procData['argumentnames']),
                  json.loads(procData['argumentdefaults'])]
        if len(output[-1]) != len(output[-2]):
            output[-1] = len(output[-2]) * ['']
        warp = procData['warp']
        output.append(warp == 'true' or (type(warp) == bool and warp))
        return output

    def procedures_call(self, block, blocks):
        output = ['call', self.varName(block['mutation']['proccode'])]
        ids = json.loads(block['mutation']['argumentids'])
        for i in ids:
            output.append(self.converter.inputVal(i, block, blocks))
        return output

    def argument_reporter_string_number(self, block, blocks):
        output = ['getParam', self.converter.fieldVal('VALUE', block), 'r']
        return output

    def argument_reporter_boolean(self, block, blocks):
        output = ['getParam', self.converter.fieldVal('VALUE', block), 'b']
        return output

    # LEGO WeDo 2.0

    def wedo2_motorOnFor(self, block, blocks):
        output = ['LEGO WeDo 2.0\u001fmotorOnFor', self.converter.inputVal('MOTOR_ID', block, blocks),
                  self.converter.inputVal('DURATION', block, blocks)]
        return output

    def wedo2_motorOn(self, block, blocks):
        output = ['LEGO WeDo 2.0\u001fmotorOn', self.converter.inputVal('MOTOR_ID', block, blocks)]
        return output

    def wedo2_motorOff(self, block, blocks):
        output = ['LEGO WeDo 2.0\u001fmotorOff', self.converter.inputVal('MOTOR_ID', block, blocks)]
        return output

    def wedo2_startMotorPower(self, block, blocks):
        output = ['LEGO WeDo 2.0\u001fstartMotorPower', self.converter.inputVal('MOTOR_ID', block, blocks),
                  self.converter.inputVal('POWER', block, blocks)]
        return output

    def wedo2_setMotorDirection(self, block, blocks):
        output = ['LEGO WeDo 2.0\u001fsetMotorDirection', self.converter.inputVal('MOTOR_ID', block, blocks),
                  self.converter.inputVal('MOTOR_DIRECTION', block, blocks)]
        return output

    def wedo2_setLightHue(self, block, blocks):
        output = ['LEGO WeDo 2.0\u001fsetLED', self.converter.inputVal('HUE', block, blocks)]
        return output

    def wedo2_playNoteFor(self, block, blocks):
        output = ['LEGO WeDo 2.0\u001fplayNote', self.converter.inputVal('NOTE', block, blocks),
                  self.converter.inputVal('DURATION', block, blocks)]
        return output

    def wedo2_whenDistance(self, block, blocks):
        output = ['LEGO WeDo 2.0\u001fwhenDistance', self.converter.inputVal('OP', block, blocks),
                  self.converter.inputVal('REFERENCE', block, blocks)]
        return output

    def wedo2_whenTilted(self, block, blocks):
        output = ['LEGO WeDo 2.0\u001fwhenTilted', self.converter.inputVal('TILT_DIRECTION_ANY', block, blocks)]
        return output

    def wedo2_getDistance(self, block, blocks):
        return ['LEGO WeDo 2.0\u001fgetDistance']

    def wedo2_isTilted(self, block, blocks):
        output = ['LEGO WeDo 2.0\u001fisTilted', self.converter.inputVal('TILT_DIRECTION_ANY', block, blocks)]
        return output

    def wedo2_getTiltAngle(self, block, blocks):
        output = ['LEGO WeDo 2.0\u001fgetTilt', self.converter.inputVal('TILT_DIRECTION', block, blocks)]
        return output


class ProjectConverter:
    varModes = {
        'default': 1,
        'large': 2,
        'slider': 3
    }

    rotationStyles = {
        'all around': 'normal',
        'left-right': 'leftRight',
        'don\'t rotate': 'none'
    }

    monitorColors = {
        'motion': 4877524,
        'looks': 9065943,
        'sound': 12272323,
        'music': 12272323,
        'sensing': 2926050,
        'data': 15629590
    }

    # Used to change variable names in hacked reporters if in compatibility mode
    sb2BlocksVarFields = {
        'setVar:to:': 1,
        'changeVar:by:': 1,
        'showVariable:': 1,
        'hideVariable:': 1,
        'readVariable': 1,
        'contentsOfList:': 1,
        'append:toList:': 2,
        'deleteLine:ofList:': 2,
        'insert:at:ofList:': 3,
        'setLine:ofList:to:': 2,
        'getLine:ofList:': 2,
        'lineCountOfList:': 1,
        'list:contains:': 1,
        'showList:': 1,
        'hideList:': 1
    }

    compatWarnings = {
        'sensing_setdragmode',
        'operator_contains',
        'data_itemnumoflist'
    }

    @staticmethod
    def hexToDec(hexNum):
        try:
            return int(hexNum[1:], 16)
        except Exception as ex:
            return hexNum

    @staticmethod
    def specialNum(num):
        if num == '-Infinity':
            return float('-inf')
        if num == 'Infinity':
            return float('inf')
        if num == 'NaN':
            return float('nan')
        return num

    def __init__(self):
        self.argmapper = BlockArgMapper(self)
        self.blockID = 0
        self.comments = []
        self.blockComments = {}
        self.compatStackReporters = []
        self.compatWarning = False
        self.convertingMonitors = False

    def varName(self, name):
        if type(name) == str:
            return ('\xa0' if self.compat else '') + name
        else:
            if self.compat:
                return ['concatenate:with:', '\xa0', name]
            else:
                return name

    def compatVarName(self, name):
        return ('Stage: ' if self.targetIsStage else '') + name

    def generateWarning(self, message):
        self.warnings += 1
        printWarning(message)

    def setCommentBlockID(self, id):
        if id in self.blockComments:
            self.comments[self.blockComments[id]][5] = self.blockID

    def convertHackedReporter(self, reporter):
        if self.compat:  # Add underscore to variable names if in compatibility mode
            block = reporter[0]
            if block in ProjectConverter.sb2BlocksVarFields:
                index = ProjectConverter.sb2BlocksVarFields[block]
                reporter[index] = self.varName(reporter[index])
            elif block == 'getAttribute:of:':
                if reporter[2] == '_stage_':
                    if reporter[1] not in BlockArgMapper.stageAttrs:
                        reporter[1] = self.varName(reporter[1])
                elif reporter[1] not in BlockArgMapper.spriteAttrs:
                    reporter[1] = self.varName(reporter[1])
            for value in reporter:
                if type(value) == list:
                    self.convertHackedReporter(value)

    def convertBlock(self, block, blocks):
        opcode = block['opcode']
        try:
            output = self.argmapper.mapArgs(opcode, block, blocks)
            output.append(tuple([block['UID']]))
            return output
        except Exception as ex:
            if len(block['inputs']) == 0 and len(block['fields']) == 1 and block['shadow'] and not block[
                'topLevel']:  # Menu opcodes and shadows
                return self.fieldVal(list(block['fields'].items())[0][0], block)
            elif block['shadow'] and block['topLevel']:
                # Probably an invisible block
                return None
            else:
                self.generateWarning(f"Incompatible opcode '{opcode}'")
                if opcode in ProjectConverter.compatWarnings:
                    self.compatWarning = True

                output = [opcode]
                for i in block['inputs']:
                    value = self.inputVal(i, block, blocks)
                    output.append(value)
                for f in block['fields']:
                    value = self.fieldVal(f, block)
                    output.append(value)
                output.append(tuple([block['UID']]))
                return output

    def inputVal(self, value, block, blocks):

        if not value in block['inputs']:
            return False

        value = block['inputs'][value]
        if value[1] is None:
            return None
        if value[0] == 1:
            if type(value[1]) == str:
                return self.convertBlock(blocks[value[1]], blocks)
            else:
                output = value[1][1]
        else:
            out = value[1]
            if type(out) == list:
                if out[0] == 12:
                    return ['readVariable', self.varName(out[1])]
                elif out[0] == 13:
                    return ['contentsOfList:', self.varName(out[1])]
                else:
                    try:
                        return out[1]
                    except Exception as ex:
                        return
            else:
                try:
                    return self.convertBlock(blocks[out], blocks)
                except Exception as ex:
                    return False

        outType = value[1][0]
        if outType in [4, 5, 8]:
            try:
                string = str(output)
                output = float(output)
                if output % 1 == 0 and not ('.' in string):
                    output = int(output)
            except ValueError:
                pass
        elif outType in [6, 7]:
            try:
                output = float(output)
                if output % 1 == 0:
                    output = int(output)
            except ValueError:
                pass
        elif outType == 9:
            output = ProjectConverter.hexToDec(output)

        return ProjectConverter.specialNum(output)

    def fieldVal(self, value, block):

        if not value in block['fields']:
            return None

        output = block['fields'][value][0]
        if type(output) == list:
            self.convertHackedReporter(output)
        if value in ['VARIABLE', 'LIST']:
            output = self.varName(output)

        return output

    def convertSubstack(self, key, blocks):
        self.compatStackReporters.append([])
        block = blocks[key]
        script = []
        end = False
        while not end:
            self.compatStackReporters[-1] = []
            output = self.convertBlock(block, blocks)
            sReporters = self.compatStackReporters[-1]
            if len(sReporters) > 0:
                script.append(['deleteLine:ofList:', 'all', self.compatVarName('results')])
                script.extend(self.compatStackReporters[-1])
                if output[0] == 'doUntil':
                    if type(output[2]) != list:
                        output[2] = []
                    output[2].append(['deleteLine:ofList:', 'all', self.compatVarName('results')])
                    output[2].extend(self.compatStackReporters[-1])
            script.append(output)
            if block['next'] is None:
                end = True
            else:
                block = blocks[block['next']]
        del self.compatStackReporters[-1]
        return script

    def substackVal(self, stack, block, blocks):

        if not stack in block['inputs']:
            return None

        stack = block['inputs'][stack]
        if len(stack) < 2 or stack[1] is None:
            return []

        return self.convertSubstack(stack[1], blocks)

    def addComment(self, c):
        comment = []
        if c['x'] is None:
            x = None
        else:
            x = round(c['x'] / 1.5, 6)
            if x % 1 == 0:
                x = int(x)
        comment.append(x)
        if c['y'] is None:
            y = None
        else:
            y = round(c['y'] / 1.8, 6)
            if y % 1 == 0:
                y = int(y)
        comment.append(y)
        comment.append(c['width'])
        comment.append(c['height'])
        comment.append(not c['minimized'])
        comment.append(-1)
        comment.append(c['text'])

        if c['blockId'] is not None:
            self.blockComments[c['blockId']] = len(self.comments)

        self.comments.append(comment)

    def addSound(self, s):

        scount = s['sampleCount']
        srate = s['rate']

        if not s['assetId'] in self.soundAssets:

            md5 = s['assetId']
            self.soundAssets[s['assetId']] = [len(self.soundAssets)]

            if s['dataFormat'] == 'wav':
                f = self.zfsb3.open(s['md5ext'], 'r')
                wav = bytes(f.read())
                try:
                    wavData = wave.open(io.BytesIO(wav), 'rb')
                    sampData = wavData.readframes(wavData.getnframes())
                    width = wavData.getsampwidth()
                    channels = wavData.getnchannels()
                    srate = wavData.getframerate()
                    wavData.close()
                except Exception as ex:
                    # Original solution which works in most cases
                    sampData = wav[44:]
                    width = int.from_bytes(wav[34:36], byteorder='little') // 8
                    channels = int.from_bytes(wav[22:24], byteorder='little')
                    srate = int.from_bytes(wav[24:28], byteorder='little')

                modified = False
                error = width * channels == 0 or (len(sampData) - 44) % (width * channels) != 0

                if not error:
                    try:
                        if channels == 2:  # Convert to mono
                            sampData = audioop.tomono(sampData, width, 1, 1)
                            modified = True

                        if srate > 22050 and srate != 44100 and not error:  # Downsample
                            sampData = audioop.ratecv(sampData, width, 1, srate, 22050, None)[0]
                            srate = 22050
                            modified = True
                    except Exception as ex:
                        error = True

                if modified:
                    size = len(sampData)
                    scount = size // width
                    try:
                        wavFile = io.BytesIO()
                        wavData = wave.open(wavFile, 'wb')
                        wavData.setsampwidth(width)
                        wavData.setnchannels(1)
                        wavData.setframerate(srate)
                        wavData.setnframes(scount)
                        wavData.writeframes(sampData)
                        wavData.close()
                        wavFile.seek(0)
                        wav = wavFile.read()
                    except Exception as ex:
                        # Original solution which works in most cases
                        wav = wav[0:22] + (1).to_bytes(2, byteorder='little') + srate.to_bytes(4,
                                                                                               byteorder='little') + wav[
                                                                                                                     28:40] + size.to_bytes(
                            4, byteorder='little') + sampData
                    self.soundAssets[s['assetId']].append(False)
                    md5 = hashlib.md5(wav).hexdigest()
                elif error and not srate <= 22050 and not channels == 1:
                    srate = s['rate']
                    self.soundAssets[s['assetId']].append(True)
                else:
                    self.soundAssets[s['assetId']].append(False)

                self.zfsb2.writestr(f'{len(self.soundAssets) - 1}.{s["dataFormat"]}', wav)
                f.close()
            else:
                self.soundAssets[s['assetId']].append(False)

            self.soundAssets[s['assetId']].append(scount)
            self.soundAssets[s['assetId']].append(srate)
            self.soundAssets[s['assetId']].append(md5)

        if s['dataFormat'] != 'wav':
            self.generateWarning(f"Sound '{s['name']}' cannot be converted into WAV")
        elif self.soundAssets[s['assetId']][1] == True:
            self.generateWarning(f"Sound '{s['name']}' cannot be converted to mono or downsampled")

        fileData = self.soundAssets[s['assetId']]
        sound = {
            'soundName': s['name'],
            'soundID': fileData[0],
            'md5': fileData[4] + '.wav',
            'sampleCount': fileData[2],
            'rate': fileData[3],
            'format': ''
        }

        self.sounds.append(sound)

    def addCostume(self, c):

        if not c['assetId'] in self.costumeAssets:
            if 'md5ext' in c:
                md5ext = c['md5ext']
            else:
                md5ext = f'{c["assetId"]}.{c["dataFormat"]}'
            self.costumeAssets[c['assetId']] = [len(self.costumeAssets)]

            f = self.zfsb3.open(c['md5ext'], 'r')
            img = f.read()
            if c['dataFormat'] == 'svg':
                img = str(img, encoding='utf-8')

                # Remove incorrect attributes added by Scratch 3.0
                # The correct values are found in the style attribute

                img = img.replace('fill="undefined"', '')  # Remove undefined fill

                # Remove incorrect stroke-width
                if ';stroke-width:' in img:  # Check if stroke-width is in style attribute (may incorrectly remove some stroke-width attributes)
                    left = 0
                    while left != -1:
                        left = img.find('stroke-width="', left)
                        if left != -1:
                            right = img.find('"', left + 14) + 1
                            img = img[0:left] + '' + img[right:]
                            left = right

                # Reposition bitmap images to their correct position

                if 'image' in img:

                    left = 0
                    while left != -1:
                        left = img.find('<image ', left)
                        if left != -1:
                            right = img.find('xlink:href=', left)
                            image = img[left:right]

                            try:
                                xLeft = image.find('x="')
                                xRight = image.find('"', xLeft + 3)
                                trX = float(image[xLeft + 3:xRight])
                                image = image[0:xLeft] + image[xRight + 1:]

                                yLeft = image.find('y="')
                                yRight = image.find('"', yLeft + 3)
                                trY = float(image[yLeft + 3:yRight])
                                image = image[0:yLeft] + image[yRight + 1:]

                                transformLeft = image.find('transform="')
                                transformRight = image.find('"', transformLeft + 11)
                                image = image[0:transformRight] + f'translate({trX} {trY})' + image[
                                                                                              transformRight:]

                                img = img[0:left] + image + img[right:]
                            except Exception as ex:
                                # self.generateWarning(f"Costume '{c['name']}' may have incorrect bitmap image positioning")
                                pass

                            left += 1

                # Replace tspan elements with text elements, which aren't supported by Scratch 2.0

                if 'tspan' in img:

                    newImg = ''
                    left = 0
                    while left != -1:
                        oldLeft = left
                        left = img.find('<text', left)
                        if left != -1:
                            newImg += img[oldLeft:left]
                            right = img.find('</text>', left) + 7

                            innerLeft = img.find('>', left) + 1
                            attrs = img[left:innerLeft - 1] + ' '
                            i = attrs.find('id="')  # Remove id attribute
                            if i != -1:
                                j = attrs.find('"', i + 4)
                                attrs = attrs[0:i] + attrs[j + 1:]
                            attrs = attrs.replace('font-family="Sans Serif"', 'font-family="Helvetica"')
                            attrs = attrs.replace('font-family="Serif"', 'font-family="Donegal"')
                            attrs = attrs.replace('font-family="Handwriting"', 'font-family="Gloria"')
                            attrs = attrs.replace('font-family="Curly"', 'font-family="Mystery"')
                            attrs = attrs.replace('xml:space="preserve"', '')

                            left = right

                            # Remove tspan elements
                            text = ''
                            lineCount = 0
                            content = img[innerLeft:right - 7]
                            if 'tspan' in content:
                                while innerLeft != -1:
                                    innerLeft = img.find('<tspan', innerLeft, right)
                                    if innerLeft != -1:
                                        lineCount += 1
                                        innerLeft += 6
                                        innerLeft = img.find('>', innerLeft, right) + 1
                                        innerRight = img.find('</tspan>', innerLeft, right)
                                        text += img[innerLeft:innerRight] + '\n'
                                        innerLeft = innerRight + 7

                                text = text[0:-1]
                                text = text + '</text>'
                            else:
                                text += content + '</text>'

                            # Fix misplaced text
                            matLeft = attrs.find('matrix')
                            if matLeft != -1:
                                try:
                                    matRight = attrs.find('"', matLeft)
                                    matrix = attrs[matLeft:matRight].split(' ')
                                    x = matrix[-2]
                                    if x[-1] == ',':
                                        x = x[0:-1]
                                    scX = matrix[0][7:]
                                    if scX[-1] == ',':
                                        scX = scX[0:-1]
                                    matrix[-2] = str(float(x) - 2.5 * float(scX))
                                    scY = matrix[3]
                                    if scY[-1] == ',':
                                        scY = scY[0:-1]
                                    matrix[-1] = str(float(matrix[-1][0:-1]) + 2.5 * float(scY)) + ')'
                                    matrix = ' '.join(matrix)
                                    attrs = attrs[0:matLeft] + matrix + attrs[matRight:]
                                except Exception as ex:
                                    self.generateWarning(
                                        f"Costume '{c['name']}' may have incorrect text positioning")
                            else:
                                trLeft = attrs.find('translate')
                                scLeft = attrs.find('scale')
                                if not (trLeft == -1 or scLeft == -1):
                                    try:
                                        scRight = attrs.find('"', scLeft)

                                        i = trLeft + 10
                                        trX = ''
                                        while attrs[i] not in ', ':
                                            trX += attrs[i]
                                            i += 1
                                        while attrs[i] in ', ':
                                            i += 1
                                        trY = ''
                                        while attrs[i] not in ' )':
                                            trY += attrs[i]
                                            i += 1
                                        trX = float(trX)
                                        trY = float(trY)

                                        i = scLeft + 6
                                        scX = ''
                                        while attrs[i] not in ', ':
                                            scX += attrs[i]
                                            i += 1
                                        while attrs[i] in ', ':
                                            i += 1
                                        scY = ''
                                        while attrs[i] not in ' )':
                                            scY += attrs[i]
                                            i += 1
                                        scX = float(scX)
                                        scY = float(scY)
                                        if lineCount > 1:
                                            trY -= 40 * scY
                                        else:
                                            trY -= 25 * scY
                                        matrix = f'matrix({scX} 0 0 {scY} {trX} {trY})'
                                        attrs = attrs[0:trLeft] + matrix + attrs[scRight:]
                                    except Exception as ex:
                                        self.generateWarning(
                                            f"Costume '{c['name']}' may have incorrect text positioning")

                            text = attrs + '>' + text
                            newImg += text
                            left = right
                        else:
                            newImg += img[oldLeft:]

                    img = newImg

                md5ext = hashlib.md5(img.encode('utf-8')).hexdigest() + '.svg'
            else:
                img = bytes(img)
            self.zfsb2.writestr(f'{len(self.costumeAssets) - 1}.{c["dataFormat"]}', img)
            f.close()

            self.costumeAssets[c['assetId']].append(md5ext)

        fileData = self.costumeAssets[c['assetId']]
        costume = {
            'costumeName': c['name'],
            'baseLayerID': fileData[0],
            'baseLayerMD5': fileData[1],
            'rotationCenterX': c['rotationCenterX'],
            'rotationCenterY': c['rotationCenterY']
        }

        if ('bitmapResolution' in c) and (fileData[1][-3:] != 'svg'):
            costume['bitmapResolution'] = c['bitmapResolution']
        else:
            costume['bitmapResolution'] = 1

        self.costumes.append(costume)

    def getCommentBlockIDs(self, script):
        if len(script) > 0:
            UID = script[-1]
            if type(UID) == tuple:
                self.setCommentBlockID(UID[0])
                del script[-1]
            if type(script[0]) == str:
                self.blockID += 1
            if script[0] == 'procDef':
                self.blockID += 1 + len(script[2])
            else:
                for block in script:
                    if type(block) == list:
                        self.getCommentBlockIDs(block)

    def convertTarget(self, target, index, maxLen):

        sprite = {}

        sprite['objName'] = target['name']
        self.targetName = sprite['objName']
        scripts = []
        variables = []
        lists = []
        self.sounds = []
        self.costumes = []
        self.comments = []

        isStage = target['isStage']
        self.targetIsStage = isStage

        self.costumeName = False
        self.dragMode = False
        if not isStage:
            self.dragMode = target['draggable']
        self.penUpDown = False
        self.joinStr = False
        self.strContains = False
        self.listSearch = False
        self.addList = False
        self.insertList = False
        self.penColor = False
        self.resetTimer = False

        for s in target['sounds']:
            self.addSound(s)

        for c in target['costumes']:
            self.addCostume(c)

        for key, v in target['variables'].items():
            variable = {
                'name': self.varName(v[0]),
                'value': ProjectConverter.specialNum(v[1]),
                'isPersistent': len(v) >= 3 and v[2]
            }
            variables.append(variable)

        for key, l in target['lists'].items():
            ls = {
                'listName': self.varName(l[0]),
                'contents': [ProjectConverter.specialNum(item) for item in l[1]],
                'isPersistent': False
            }
            lists.append(ls)

        self.blockComments = {}

        for key, c in target['comments'].items():
            self.addComment(c)

        blocks = target['blocks']

        for key, b in blocks.items():
            if type(b) == dict:
                b['UID'] = key

        for key, b in blocks.items():

            if type(b) == list:

                try:
                    x = round(b[3] / 1.5, 6)
                    if x % 1 == 0:
                        x = int(x)
                    y = round(b[4] / 1.8, 6)
                    if y % 1 == 0:
                        y = int(y)
                except Exception as ex:
                    x, y = 0, 0
                script = [x, y]

                if b[0] == 12:
                    script.append([['readVariable', self.varName(b[1])]])
                elif b[0] == 13:
                    script.append([['contentsOfList:', self.varName(b[1])]])
                else:
                    script = None

                if script is not None:
                    scripts.append(script)
                    self.scriptCount += 1

            elif b['topLevel']:

                try:
                    x = round(b['x'] / 1.5, 6)
                    if x % 1 == 0:
                        x = int(x)
                    y = round(b['y'] / 1.8, 6)
                    if y % 1 == 0:
                        y = int(y)
                except Exception as ex:
                    x, y = 0, 0

                self.compatStackReporters = []
                substack = self.convertSubstack(key, blocks)

                if substack != [None]:
                    scripts.append([x, y, self.convertSubstack(key, blocks)])
                    self.scriptCount += 1

        # Find where the pen size is greater than 255 and add a screen fill

        if self.penFill:
            if self.compat and self.penUpDown:
                penDown = ['call', 'pen down']
                penUp = ['call', 'pen up']
            else:
                penDown = ['putPenDown']
                penUp = ['putPenUp']

            def scriptAddFill(script, down, up):
                if type(script) != list or len(script) < 1:
                    return
                if type(script[0]) == str:
                    if script[0] in ['penSize:', 'changePenSizeBy:']:
                        try:
                            if float(script[1]) >= 255.5:
                                return 'bigSize'
                            else:
                                return 'smallSize'
                        except Exception as ex:
                            return
                    else:
                        # Convert subscripts in repeats, ifs, etc.
                        if type(script[-1]) == tuple:
                            if len(script) > 2:
                                for block in script[1:-1]:
                                    scriptAddFill(block, down, up)
                        else:
                            if len(script) > 1:
                                for block in script[1:]:
                                    scriptAddFill(block, down, up)
                        return script
                else:
                    top = None
                    for i in range(len(script)):
                        value = scriptAddFill(script[i], down, up)
                        if value == 'bigSize':
                            self.bigSize = True
                        elif value == 'smallSize':
                            self.bigSize = False
                            top = None
                        elif type(value) != list or len(value) < 1:
                            continue
                        if value[0:len(down)] == down:
                            top = i
                        elif value[0:len(up)] == up and top is not None and self.bigSize:
                            script[top:i + 1] = [
                                ['penSize:', 200],
                                ['gotoX:y:', -350, -100],
                                down,
                                ['xpos:', 250],
                                up,
                                ['gotoX:y:', -350, 100],
                                down,
                                ['xpos:', 250],
                                up,
                                ['penSize:', 255]
                            ]
                            top = None
                        elif value[0] in ['call', 'broadcast:', 'doBroadcastAndWait', 'penColor:', 'changePenHueBy:',
                                          'setPenHueTo:', 'changePenShadeBy:', 'setPenShadeTo:']:
                            top = None

            for script in scripts:
                self.bigSize = False
                if len(script) >= 3:
                    scriptAddFill(script[2], penDown, penUp)

        self.blockID = 0
        for script in scripts:
            self.getCommentBlockIDs(script[2])

        # Add variables, lists, and custom blocks for compatibility mode

        if self.compat:

            if self.costumeName:
                costumeNames = []
                for c in target['costumes']:
                    costumeNames.append(c['name'])
                lists.append({
                    'listName': self.compatVarName('costume names'),
                    'contents': costumeNames,
                    'isPersistent': False,
                    'visible': False
                })

            if self.penUpDown or self.dragMode:
                pen = self.compatVarName('pen')
                variables.append({
                    'name': pen,
                    'value': 'up',
                    'isPersistent': False
                })

                scripts.append(
                    [0,
                     0,
                     [["procDef", "pen down", [], [], True], ["putPenDown"], ["setVar:to:", pen, "down"]]]
                )
                scripts.append(
                    [0,
                     0,
                     [["procDef", "pen up", [], [], True], ["putPenUp"], ["setVar:to:", pen, "up"]]]
                )

                self.scriptCount += 2

            if self.dragMode:
                drag = self.compatVarName('drag')
                variables.append({
                    'name': drag,
                    'value': 'draggable' if (not isStage and target['draggable']) else 'not draggable',
                    'isPersistent': False
                })

                scripts.append(
                    [0,
                     0,
                     [["whenClicked"],
                      ["doIf",
                       ["=", ["readVariable", drag], "draggable"],
                       [["call",
                         "drag %n %n",
                         ["-", ["xpos"], ["mouseX"]],
                         ["-", ["ypos"], ["mouseY"]]]]]]]
                )

                scripts.append(
                    [0,
                     0,
                     [["procDef", "set drag mode %s", ["drag"], ["draggable"], True],
                      ["setVar:to:", drag, ["getParam", "drag", "r"]]]]
                )

                scripts.append(
                    [0,
                     0,
                     [["procDef", "drag %n %n", ["X", "Y"], [0, 0], False],
                      ['comeToFront'],
                      ["doIf", ["=", ["readVariable", pen], "down"], [["putPenUp"]]],
                      ["doUntil",
                       ["not", ["mousePressed"]],
                       [["gotoX:y:",
                         ["+", ["mouseX"], ["getParam", "X", "r"]],
                         ["+", ["mouseY"], ["getParam", "Y", "r"]]]]],
                      ["doIf", ["=", ["readVariable", pen], "down"], [["putPenDown"]]]]]
                )

                self.scriptCount += 3

            if self.joinStr or self.strContains or self.listSearch:
                returnVar = self.compatVarName('return')
                variables.append({
                    'name': returnVar,
                    'value': 0,
                    'isPersistent': False
                })
                results = self.compatVarName('results')
                lists.append({
                    'listName': results,
                    'contents': [],
                    'isPersistent': False,
                    'x': 0,
                    'y': 0,
                    'width': 100,
                    'height': 200,
                    'visible': False
                })

            if self.joinStr or self.strContains:
                i = self.compatVarName('i')
                variables.append({
                    'name': i,
                    'value': 0,
                    'isPersistent': False
                })

            if self.joinStr:
                joinList = self.compatVarName('join')
                lists.append({
                    'listName': joinList,
                    'contents': [],
                    'isPersistent': False,
                    'x': 0,
                    'y': 0,
                    'width': 100,
                    'height': 200,
                    'visible': False
                })
                scripts.append(
                    [0,
                     0,
                     [["procDef", "join %s %s", ["STRING1", "STRING2"], ["", ""], True],
                      ["doIfElse",
                       [">",
                        ["+", ["stringLength:", ["getParam", "STRING1", "r"]],
                         ["stringLength:", ["getParam", "STRING2", "r"]]],
                        10240],
                       [["doIf",
                         ["not", ["=", ["contentsOfList:", joinList], ["getParam", "STRING1", "r"]]],
                         [["deleteLine:ofList:", "all", joinList],
                          ["setVar:to:", "i", "0"],
                          ["doRepeat",
                           ["stringLength:", ["getParam", "STRING1", "r"]],
                           [["changeVar:by:", "i", 1],
                            ["append:toList:", ["letter:of:", ["readVariable", "i"], ["getParam", "STRING1", "r"]],
                             joinList]]]]],
                        ["setVar:to:", "i", "0"],
                        ["doRepeat",
                         ["stringLength:", ["getParam", "STRING2", "r"]],
                         [["changeVar:by:", "i", 1],
                          ["append:toList:", ["letter:of:", ["readVariable", "i"], ["getParam", "STRING2", "r"]],
                           joinList]]],
                        ["append:toList:", ["contentsOfList:", joinList], "results"]],
                       [["append:toList:",
                         ["concatenate:with:", ["getParam", "STRING1", "r"], ["getParam", "STRING2", "r"]],
                         "results"]]]]]
                )
                self.scriptCount += 1

            if self.strContains:
                j = self.compatVarName('j')
                variables.append({
                    'name': j,
                    'value': 0,
                    'isPersistent': False
                })
                k = self.compatVarName('k')
                variables.append({
                    'name': k,
                    'value': 0,
                    'isPersistent': False
                })
                scripts.append(
                    [10,
                     10,
                     [["procDef", "%s contains %s ?", ["STRING1", "STRING2"], ["apple", "a"], True],
                      ["doIfElse",
                       ["=", ["stringLength:", ["getParam", "STRING2", "r"]], 0],
                       [["append:toList:", ["=", 0, 0], results]],
                       [["doIfElse",
                         ["=", ["stringLength:", ["getParam", "STRING2", "r"]], 1],
                         [["setVar:to:", i, 1],
                          ["doRepeat",
                           ["stringLength:", ["getParam", "STRING1", "r"]],
                           [["doIf",
                             ["=",
                              ["letter:of:", ["readVariable", i], ["getParam", "STRING1", "r"]],
                              ["getParam", "STRING2", "r"]],
                             [["append:toList:", ["=", 0, 0], results], ["stopScripts", "this script"]]],
                            ["changeVar:by:", i, 1]]],
                          ["append:toList:", ["=", 1, 0], results]],
                         [["setVar:to:", k, ["-", ["stringLength:", ["getParam", "STRING2", "r"]], 1]],
                          ["setVar:to:", i, 1],
                          ["doRepeat",
                           ["+",
                            ["-", ["stringLength:", ["getParam", "STRING1", "r"]],
                             ["stringLength:", ["getParam", "STRING2", "r"]]],
                            1],
                           [["setVar:to:", j, 0],
                            ["doIf",
                             ["=", ["readVariable", returnVar], "true"],
                             [["append:toList:", ["=", 0, 0], results], ["stopScripts", "this script"]]],
                            ["setVar:to:", returnVar, "true"],
                            ["doUntil",
                             [">", ["readVariable", j], ["readVariable", k]],
                             [["doIfElse",
                               ["=",
                                ["letter:of:", ["+", ["readVariable", i], ["readVariable", j]],
                                 ["getParam", "STRING1", "r"]],
                                ["letter:of:", ["+", ["readVariable", j], 1], ["getParam", "STRING2", "r"]]],
                               [["changeVar:by:", j, 1]],
                               [["setVar:to:", returnVar, "false"],
                                ["setVar:to:", j, ["+", ["readVariable", k], 1]]]]]],
                            ["changeVar:by:", i, 1]]],
                          ["append:toList:", ["=", 1, 0], results]]]]]]]
                )
                self.scriptCount += 1

            if self.listSearch:
                scripts.append(
                    [0,
                     0,
                     [["procDef", "item # of %s in %m.list", ["ITEM", "LIST"], ["thing", ""], True],
                      ["setVar:to:", returnVar, 0],
                      ["doIf",
                       ["list:contains:", ["getParam", "LIST", "r"], ["getParam", "ITEM", "r"]],
                       [["setVar:to:", returnVar, 0],
                        ["doRepeat",
                         ["lineCountOfList:", ["getParam", "LIST", "r"]],
                         [["changeVar:by:", returnVar, 1],
                          ["doIf",
                           ["=",
                            ["getLine:ofList:", ["readVariable", returnVar], ["getParam", "LIST", "r"]],
                            ["getParam", "ITEM", "r"]],
                           [["append:toList:", ["readVariable", returnVar], results],
                            ["stopScripts", "this script"]]]]]]],
                      ["append:toList:", 0, results]]]
                )
                self.scriptCount += 1

            if self.addList:
                scripts.append(
                    [0,
                     0,
                     [["procDef", "add %s to %m.list", ["ITEM", "LIST"], ["thing", ""], True],
                      ["doIf", ["<", ["lineCountOfList:", ["getParam", "LIST", "r"]], 200000],
                       [["append:toList:", ["getParam", "ITEM", "r"], ["getParam", "LIST", "r"]]]]]]
                )
                self.scriptCount += 1

            if self.insertList:
                scripts.append(
                    [0,
                     0,
                     [["procDef", "insert %s at %n of %m.list", ["ITEM", "INDEX", "LIST"], ["thing", 1, ""], True],
                      ["insert:at:ofList:", ["getParam", "ITEM", "r"], ["getParam", "INDEX", "r"],
                       ["getParam", "LIST", "r"]],
                      ["doIf", [">", ["lineCountOfList:", ["getParam", "LIST", "r"]], 200000],
                       [["deleteLine:ofList:", "last", ["getParam", "LIST", "r"]]]]]]
                )
                self.scriptCount += 1

            if self.penColor:
                hue = self.compatVarName('hue')
                variables.append({
                    'name': hue,
                    'value': 200 / 3,
                    'isPersistent': False
                })
                sat = self.compatVarName('sat')
                variables.append({
                    'name': sat,
                    'value': 100,
                    'isPersistent': False
                })
                val = self.compatVarName('val')
                variables.append({
                    'name': val,
                    'value': 100,
                    'isPersistent': False
                })
                alpha = self.compatVarName('alpha')
                variables.append({
                    'name': alpha,
                    'value': 0,
                    'isPersistent': False
                })
                shade = self.compatVarName('shade')
                variables.append({
                    'name': shade,
                    'value': 50,
                    'isPersistent': False
                })
                minVar = self.compatVarName('min')
                variables.append({
                    'name': minVar,
                    'value': 200 / 3,
                    'isPersistent': False
                })
                maxVar = self.compatVarName('max')
                variables.append({
                    'name': maxVar,
                    'value': 100,
                    'isPersistent': False
                })
                diff = self.compatVarName('diff')
                variables.append({
                    'name': diff,
                    'value': 100,
                    'isPersistent': False
                })
                r = self.compatVarName('r')
                variables.append({
                    'name': r,
                    'value': 0,
                    'isPersistent': False
                })
                g = self.compatVarName('g')
                variables.append({
                    'name': g,
                    'value': 50,
                    'isPersistent': False
                })
                b = self.compatVarName('b')
                variables.append({
                    'name': b,
                    'value': 100,
                    'isPersistent': False
                })
                c = self.compatVarName('c')
                variables.append({
                    'name': c,
                    'value': 0,
                    'isPersistent': False
                })
                x = self.compatVarName('x')
                variables.append({
                    'name': x,
                    'value': 50,
                    'isPersistent': False
                })

                scripts.extend(
                    [[0,
                      0,
                      [["procDef", "set pen color to %c", ["COLOR"], [255], True],
                       ["doIfElse",
                        ["=", ["*", 1, ["getParam", "COLOR", "r"]], ["getParam", "COLOR", "r"]],
                        [["penColor:", ["getParam", "COLOR", "r"]],
                         ["setVar:to:",
                          alpha,
                          ["%", ["computeFunction:of:", "floor", ["/", ["getParam", "COLOR", "r"], 16777216]], 256]],
                         ["doIf",
                          ["not", ["=", ["readVariable", alpha], 0]],
                          [["setVar:to:",
                            alpha,
                            ["*", 100, ["-", 1, ["/", ["readVariable", alpha], 255]]]]]],
                         ["call",
                          "store RGB as HSV %n %n %n",
                          ["/",
                           ["%", ["computeFunction:of:", "floor", ["/", ["getParam", "COLOR", "r"], 65536]], 256],
                           255],
                          ["/",
                           ["%", ["computeFunction:of:", "floor", ["/", ["getParam", "COLOR", "r"], 256]], 256],
                           255],
                          ["/", ["%", ["getParam", "COLOR", "r"], 256], 255]]],
                        [["doIfElse",
                          ["=", ["letter:of:", 1, ["getParam", "COLOR", "r"]], "#"],
                          [["doIfElse",
                            ["=", ["stringLength:", ["getParam", "COLOR", "r"]], 7],
                            [["call",
                              "set pen color to %c",
                              ["concatenate:with:",
                               "0x",
                               ["concatenate:with:",
                                ["concatenate:with:",
                                 ["letter:of:", 2, ["getParam", "COLOR", "r"]],
                                 ["letter:of:", 3, ["getParam", "COLOR", "r"]]],
                                ["concatenate:with:",
                                 ["concatenate:with:",
                                  ["letter:of:", 4, ["getParam", "COLOR", "r"]],
                                  ["letter:of:", 5, ["getParam", "COLOR", "r"]]],
                                 ["concatenate:with:",
                                  ["letter:of:", 6, ["getParam", "COLOR", "r"]],
                                  ["letter:of:", 7, ["getParam", "COLOR", "r"]]]]]]]],
                            [["doIfElse",
                              ["=", ["stringLength:", ["getParam", "COLOR", "r"]], 4],
                              [["call",
                                "set pen color to %c",
                                ["concatenate:with:",
                                 "0x",
                                 ["concatenate:with:",
                                  ["concatenate:with:",
                                   ["letter:of:", 2, ["getParam", "COLOR", "r"]],
                                   ["letter:of:", 2, ["getParam", "COLOR", "r"]]],
                                  ["concatenate:with:",
                                   ["concatenate:with:",
                                    ["letter:of:", 3, ["getParam", "COLOR", "r"]],
                                    ["letter:of:", 3, ["getParam", "COLOR", "r"]]],
                                   ["concatenate:with:",
                                    ["letter:of:", 4, ["getParam", "COLOR", "r"]],
                                    ["letter:of:", 4, ["getParam", "COLOR", "r"]]]]]]]],
                              [["call", "set pen color to %c", -16777216]]]]]],
                          [["call", "set pen color to %c", -16777216]]]]]]],
                     [0,
                      0,
                      [["procDef", "change pen %s by %n", ["COLOR_PARAM", "VALUE"], ["color", 10], True],
                       ["doIfElse",
                        ["=", ["getParam", "COLOR_PARAM", "r"], "color"],
                        [["call",
                          "set pen %s to %n",
                          ["getParam", "COLOR_PARAM", "r"],
                          ["+", ["readVariable", hue], ["getParam", "VALUE", "r"]]]],
                        [["doIfElse",
                          ["=", ["getParam", "COLOR_PARAM", "r"], "saturation"],
                          [["call",
                            "set pen %s to %n",
                            ["getParam", "COLOR_PARAM", "r"],
                            ["+", ["readVariable", sat], ["getParam", "VALUE", "r"]]]],
                          [["doIfElse",
                            ["=", ["getParam", "COLOR_PARAM", "r"], "brightness"],
                            [["call",
                              "set pen %s to %n",
                              ["getParam", "COLOR_PARAM", "r"],
                              ["+", ["readVariable", val], ["getParam", "VALUE", "r"]]]],
                            [["doIf",
                              ["=", ["getParam", "COLOR_PARAM", "r"], "transparency"],
                              [["call",
                                "set pen %s to %n",
                                ["getParam", "COLOR_PARAM", "r"],
                                ["+", ["readVariable", alpha], ["getParam", "VALUE", "r"]]]]]]]]]]]]],
                     [0,
                      0,
                      [["procDef", "change pen color by %n", ["HUE"], [10], True],
                       ["call", "change pen %s by %n", "color", ["/", ["getParam", "HUE", "r"], 2]]]],
                     [0,
                      0,
                      [["procDef", "set pen color to %n", ["HUE"], [0], True],
                       ["call", "set pen %s to %n", "color", ["/", ["getParam", "HUE", "r"], 2]]]],
                     [0,
                      0,
                      [["procDef", "change pen shade by %n", ["SHADE"], [10], True],
                       ["call", "set pen shade to %n", ["+", ["readVariable", shade], ["getParam", "SHADE", "r"]]]]],
                     [0,
                      0,
                      [["procDef", "set pen shade to %n", ["SHADE"], [50], True],
                       ["setVar:to:",
                        shade,
                        ["computeFunction:of:",
                         "abs",
                         ["-",
                          ["getParam", "SHADE", "r"],
                          ["*", 200, ["rounded", ["/", ["getParam", "SHADE", "r"], 200]]]]]],
                       ["call", "HSV to RGB %n %n %n", ["readVariable", hue], 100, 100],
                       ["doIfElse",
                        ["<", ["readVariable", shade], 50],
                        [["setVar:to:", x, ["/", ["+", ["readVariable", shade], 10], 60]],
                         ["setVar:to:", r, ["rounded", ["*", ["readVariable", x], ["readVariable", r]]]],
                         ["setVar:to:", g, ["rounded", ["*", ["readVariable", x], ["readVariable", g]]]],
                         ["setVar:to:", b, ["rounded", ["*", ["readVariable", x], ["readVariable", b]]]]],
                        [["setVar:to:", x, ["/", ["-", ["readVariable", shade], 50], 60]],
                         ["setVar:to:",
                          r,
                          ["rounded",
                           ["+",
                            ["*", ["-", 1, ["readVariable", x]], ["readVariable", r]],
                            ["*", ["readVariable", x], 255]]]],
                         ["setVar:to:",
                          g,
                          ["rounded",
                           ["+",
                            ["*", ["-", 1, ["readVariable", x]], ["readVariable", g]],
                            ["*", ["readVariable", x], 255]]]],
                         ["setVar:to:",
                          b,
                          ["rounded",
                           ["+",
                            ["*", ["-", 1, ["readVariable", x]], ["readVariable", b]],
                            ["*", ["readVariable", x], 255]]]]]],
                       ["call",
                        "store RGB as HSV %n %n %n",
                        ["/", ["readVariable", r], 255],
                        ["/", ["readVariable", g], 255],
                        ["/", ["readVariable", b], 255]],
                       ["penColor:",
                        ["+",
                         ["readVariable", b],
                         ["*",
                          256,
                          ["+",
                           ["readVariable", g],
                           ["*",
                            256,
                            ["+",
                             ["readVariable", r],
                             ["*", 256, ["rounded", ["*", 2.55, ["-", 100, ["readVariable", alpha]]]]]]]]]]]]],
                     [0,
                      0,
                      [["procDef", "set pen %s to %n", ["COLOR_PARAM", "VALUE"], ["color", 50], True],
                       ["doIfElse",
                        ["=", ["getParam", "COLOR_PARAM", "r"], "color"],
                        [["setPenHueTo:", ["*", 2, ["getParam", "VALUE", "r"]]],
                         ["setVar:to:", hue, ["%", ["getParam", "VALUE", "r"], 100]],
                         ["stopScripts", "this script"]],
                        [["doIfElse",
                          ["=", ["getParam", "COLOR_PARAM", "r"], "saturation"],
                          [["doIfElse",
                            ["<", ["getParam", "VALUE", "r"], 0],
                            [["setVar:to:", sat, 0]],
                            [["doIfElse",
                              [">", ["getParam", "VALUE", "r"], 100],
                              [["setVar:to:", sat, 100]],
                              [["setVar:to:", sat, ["getParam", "VALUE", "r"]]]]]]],
                          [["doIfElse",
                            ["=", ["getParam", "COLOR_PARAM", "r"], "brightness"],
                            [["doIfElse",
                              ["<", ["getParam", "VALUE", "r"], 0],
                              [["setVar:to:", val, 0]],
                              [["doIfElse",
                                [">", ["getParam", "VALUE", "r"], 100],
                                [["setVar:to:", val, 100]],
                                [["setVar:to:", val, ["getParam", "VALUE", "r"]]]]]]],
                            [["doIfElse",
                              ["=", ["getParam", "COLOR_PARAM", "r"], "transparency"],
                              [["doIfElse",
                                ["<", ["getParam", "VALUE", "r"], 0],
                                [["setVar:to:", alpha, 0]],
                                [["doIfElse",
                                  [">", ["getParam", "VALUE", "r"], 100],
                                  [["setVar:to:", alpha, 100]],
                                  [["setVar:to:", alpha, ["getParam", "VALUE", "r"]]]]]]],
                              [["stopScripts", "this script"]]]]]]]]],
                       ["call", "HSV to RGB %n %n %n", ["readVariable", hue], ["readVariable", sat],
                        ["readVariable", val]],
                       ["penColor:",
                        ["+",
                         ["readVariable", b],
                         ["*",
                          256,
                          ["+",
                           ["readVariable", g],
                           ["*",
                            256,
                            ["+",
                             ["readVariable", r],
                             ["*", 256, ["rounded", ["*", 2.55, ["-", 100, ["readVariable", alpha]]]]]]]]]]]]],
                     [0,
                      0,
                      [["procDef", "store RGB as HSV %n %n %n", ["R", "G", "B"], [0, 0, 0], True],
                       ["doIfElse",
                        ["not",
                         ["|",
                          [">", ["getParam", "R", "r"], ["getParam", "G", "r"]],
                          [">", ["getParam", "R", "r"], ["getParam", "B", "r"]]]],
                        [["setVar:to:", minVar, ["getParam", "R", "r"]]],
                        [["doIfElse",
                          ["not",
                           ["|",
                            [">", ["getParam", "G", "r"], ["getParam", "R", "r"]],
                            [">", ["getParam", "G", "r"], ["getParam", "B", "r"]]]],
                          [["setVar:to:", minVar, ["getParam", "G", "r"]]],
                          [["setVar:to:", minVar, ["getParam", "B", "r"]]]]]],
                       ["doIfElse",
                        ["not",
                         ["|",
                          ["<", ["getParam", "R", "r"], ["getParam", "G", "r"]],
                          ["<", ["getParam", "R", "r"], ["getParam", "B", "r"]]]],
                        [["setVar:to:", maxVar, ["getParam", "R", "r"]]],
                        [["doIfElse",
                          ["not",
                           ["|",
                            ["<", ["getParam", "G", "r"], ["getParam", "R", "r"]],
                            ["<", ["getParam", "G", "r"], ["getParam", "B", "r"]]]],
                          [["setVar:to:", maxVar, ["getParam", "G", "r"]]],
                          [["setVar:to:", maxVar, ["getParam", "B", "r"]]]]]],
                       ["setVar:to:", diff, ["-", ["readVariable", maxVar], ["readVariable", minVar]]],
                       ["doIfElse",
                        ["=", ["readVariable", diff], 0],
                        [["setVar:to:", hue, 0], ["setVar:to:", sat, 0]],
                        [["doIfElse",
                          ["=", ["readVariable", maxVar], ["getParam", "R", "r"]],
                          [["setVar:to:",
                            hue,
                            ["/",
                             ["%",
                              ["/",
                               ["-", ["getParam", "G", "r"], ["getParam", "B", "r"]],
                               ["readVariable", diff]],
                              6],
                             0.06]]],
                          [["doIfElse",
                            ["=", ["readVariable", maxVar], ["getParam", "G", "r"]],
                            [["setVar:to:",
                              hue,
                              ["/",
                               ["+",
                                ["/",
                                 ["-", ["getParam", "B", "r"], ["getParam", "R", "r"]],
                                 ["readVariable", diff]],
                                2],
                               0.06]]],
                            [["setVar:to:",
                              hue,
                              ["/",
                               ["+",
                                ["/",
                                 ["-", ["getParam", "R", "r"], ["getParam", "G", "r"]],
                                 ["readVariable", diff]],
                                4],
                               0.06]]]]]],
                         ["setVar:to:", sat, ["*", 100, ["/", ["readVariable", diff], ["readVariable", maxVar]]]]]],
                       ["setVar:to:", val, ["*", 100, ["readVariable", maxVar]]]]],
                     [0,
                      0,
                      [["procDef", "HSV to RGB %n %n %n", ["H", "S", "V"], [0, 0, 0], True],
                       ["setVar:to:",
                        c,
                        ["/", ["*", ["getParam", "V", "r"], ["getParam", "S", "r"]], 10000]],
                       ["setVar:to:",
                        x,
                        ["*",
                         ["readVariable", c],
                         ["-",
                          1,
                          ["computeFunction:of:",
                           "abs",
                           ["-", ["%", ["*", 0.06, ["getParam", "H", "r"]], 2], 1]]]]],
                       ["doIfElse",
                        ["<", ["getParam", "H", "r"], ["/", 100, 6]],
                        [["setVar:to:", r, ["readVariable", c]],
                         ["setVar:to:", g, ["readVariable", x]],
                         ["setVar:to:", b, 0]],
                        [["doIfElse",
                          ["<", ["getParam", "H", "r"], ["/", 100, 3]],
                          [["setVar:to:", r, ["readVariable", x]],
                           ["setVar:to:", g, ["readVariable", c]],
                           ["setVar:to:", b, 0]],
                          [["doIfElse",
                            ["<", ["getParam", "H", "r"], 50],
                            [["setVar:to:", r, 0],
                             ["setVar:to:", g, ["readVariable", c]],
                             ["setVar:to:", b, ["readVariable", x]]],
                            [["doIfElse",
                              ["<", ["getParam", "H", "r"], ["/", 200, 3]],
                              [["setVar:to:", r, 0],
                               ["setVar:to:", g, ["readVariable", x]],
                               ["setVar:to:", b, ["readVariable", c]]],
                              [["doIfElse",
                                ["<", ["getParam", "H", "r"], ["/", 250, 3]],
                                [["setVar:to:", r, ["readVariable", x]],
                                 ["setVar:to:", g, 0],
                                 ["setVar:to:", b, ["readVariable", c]]],
                                [["setVar:to:", r, ["readVariable", x]],
                                 ["setVar:to:", g, 0],
                                 ["setVar:to:", b, ["readVariable", c]]]]]]]]]]]],
                       ["setVar:to:",
                        x,
                        ["-", ["/", ["getParam", "V", "r"], 100], ["readVariable", c]]],
                       ["setVar:to:",
                        r,
                        ["rounded", ["*", 255, ["+", ["readVariable", r], ["readVariable", x]]]]],
                       ["setVar:to:",
                        g,
                        ["rounded", ["*", 255, ["+", ["readVariable", g], ["readVariable", x]]]]],
                       ["setVar:to:",
                        b,
                        ["rounded", ["*", 255, ["+", ["readVariable", b], ["readVariable", x]]]]]]]]
                )
                self.scriptCount += 9

            if self.resetTimer:
                scripts.append(
                    [0,
                     0,
                     [["procDef", "reset timer", [], [], True], ["setVar:to:", "reset time", ["timestamp"]],
                      ["timerReset"]]]
                )
                self.scriptCount += 1

        sprite['scripts'] = scripts
        sprite['variables'] = variables
        sprite['lists'] = lists
        sprite['sounds'] = self.sounds
        sprite['costumes'] = self.costumes
        sprite['scriptComments'] = self.comments

        if isStage:

            sprite['currentCostumeIndex'] = target['currentCostume']
            sprite['tempoBPM'] = target['tempo']
            sprite['videoAlpha'] = (100 - target['videoTransparency']) / 100
            sprite['penLayerMD5'] = ''

            sprite['objName'] = 'Stage'
            sprite['info'] = {
                'userAgent': self.jsonData['meta']['agent'],
                'videoOn': target['videoState'] == 'on'
            }

        else:

            sprite['currentCostumeIndex'] = target['currentCostume']
            sprite['scratchX'] = target['x']
            sprite['scratchY'] = target['y']
            sprite['scale'] = target['size'] / 100
            sprite['direction'] = target['direction']
            sprite['rotationStyle'] = ProjectConverter.rotationStyles[target['rotationStyle']]
            sprite['isDraggable'] = target['draggable'] and not self.compat
            sprite['indexInLibrary'] = index
            sprite['visible'] = target['visible']
            sprite['spriteInfo'] = {}
            sprite['layerOrder'] = target['layerOrder']

        print("Converted {} ({}/{})".format(
            rightPad(f"'{sprite['objName']}'", maxLen - len(sprite['objName']), ' '), index + 1,
            self.totalTargets))

        return (isStage, sprite)

    def updateList(self, l, ls):
        l['x'] = ls['x']
        l['y'] = ls['y']
        l['width'] = ls['width']
        l['height'] = ls['height']
        l['visible'] = ls['visible']

    # Update list data with monitor info

    def updateListData(self, output, sprites, stageLists, lists):

        for l in output['lists']:

            if l['listName'] in stageLists:
                ls = stageLists[l['listName']]
                self.updateList(l, ls)

        for s in sprites:
            spriteName = s['objName']

            if spriteName in lists:
                for l in s['lists']:

                    if l['listName'] in lists[spriteName]:
                        ls = lists[spriteName][l['listName']]
                        self.updateList(l, ls)

    def addMonitor(self, m):

        if m['opcode'] == 'data_listcontents':

            monitor = {
                'listName': self.varName(m['params']['LIST']),
                'contents': m['value'],
                'isPersistent': False,
                'x': m['x'],
                'y': m['y'],
                'width': 100 if m['width'] == 0 else m['width'],
                'height': 200 if m['height'] == 0 else m['height'],
                'visible': m['visible']
            }

            self.monitors.append(monitor)

            listData = {
                'x': m['x'],
                'y': m['y'],
                'width': monitor['width'],
                'height': monitor['height'],
                'visible': m['visible']
            }

            if m['spriteName'] is None:
                self.stageLists[monitor['listName']] = listData
            else:
                if m['spriteName'] not in self.lists:
                    self.lists[m['spriteName']] = {}
                self.lists[m['spriteName']][monitor['listName']] = listData

        else:

            try:
                block = {'opcode': m['opcode']}
                if 'params' in m:
                    block['fields'] = {}
                    for key, value in m['params'].items():
                        block['fields'][key] = [value]

                monitor = self.argmapper.mapArgs(m['opcode'], block, {})
                cmd = 'getVar:' if monitor[0] == 'readVariable' else monitor[0]
                if len(monitor) > 1:
                    param = monitor[1]
                else:
                    param = None

                assert cmd is not None

                sMin = m['min'] if 'min' in m else m['sliderMin']
                sMax = m['max'] if 'max' in m else m['sliderMax']
                monitor = {
                    'target': 'Stage' if m['spriteName'] is None else m['spriteName'],
                    'cmd': cmd,
                    'param': param,
                    'color': ProjectConverter.monitorColors[m['opcode'].split('_')[0]],
                    'label': '',  # Scratch 2 will handle this
                    'mode': ProjectConverter.varModes[m['mode']],
                    'sliderMin': sMin,
                    'sliderMax': sMax,
                    'isDiscrete': sMin % 1 == 0 and sMax % 1 == 0 and not ('.' in str(sMin)) and not ('.' in str(sMax)),
                    'x': m['x'],
                    'y': m['y'],
                    'visible': m['visible']
                }
                self.monitors.append(monitor)

            except Exception as ex:
                self.generateWarning(f"Stage monitor '{m['opcode']}' will not be converted")

    def convertProject(self, sb3path, sb2path, gui=False, replace=False, compatibility=False, unlimitedJoin=False,
                       limitedLists=False, penFillScreen=False):

        self.compatWarning = False
        self.compat = compatibility
        self.unlimJoin = unlimitedJoin
        self.limList = limitedLists
        self.penFill = penFillScreen

        self.warnings = 0

        if not sb3path[-3:] == 'sb3':
            printError(f"File '{sb3path}' is not an sb3 file", gui)

        if not sb2path[-3:] == 'sb2':
            self.generateWarning(
                f"The converted project will be saved to '{sb2path + '.sb2'}' instead of '{sb2path}'")
            sb2path += '.sb2'

        self.convertingMonitors = False

        try:
            self.zfsb3 = zipfile.ZipFile(sb3path, 'r')
        except Exception as ex:
            printError(f"File '{sb3path}' does not exist", gui)

        print('')
        try:
            self.zfsb2 = zipfile.ZipFile(sb2path, 'x')
        except Exception as ex:
            replaceFile = False
            if replace:
                replaceFile = True
            else:
                if gui:
                    goAhead = messagebox.askquestion('Overwrite SB2',
                                                     f"File {sb2path} already exists.\n\nOverwrite {sb2path}?",
                                                     icon='warning'
                                                     )
                    replaceFile = (goAhead == 'yes')
                else:
                    print(f"File '{sb2path}' already exists")
                    replaceFile = input(f"Overwrite '{sb2path}'? (Y/N): ")
                    print('')
                    replaceFile = replaceFile[0] == 'Y' or replaceFile[0] == 'y'
            if replaceFile:
                import os
                os.remove(sb2path)
                self.zfsb2 = zipfile.ZipFile(sb2path, 'x')
            else:
                exit()

        f = self.zfsb3.open('project.json', 'r')
        self.jsonData = json.loads(f.read())
        f.close()

        output = {}
        self.costumeAssets = {}
        self.soundAssets = {}

        sprites = []

        targetsDone = 0

        self.totalTargets = len(self.jsonData['targets'])
        self.scriptCount = 0

        # Convert Stage and sprites

        maxLen = 0
        for target in self.jsonData['targets']:
            name = 'Stage' if target['isStage'] else target['name']
            maxLen = max(maxLen, len(name))

        self.timerCompat = False

        for target in self.jsonData['targets']:
            sprite = self.convertTarget(target, targetsDone, maxLen)
            if sprite[0]:
                output = sprite[1]
            else:
                sprites.append(sprite[1])
            targetsDone += 1

        if self.timerCompat:
            output['variables'].append(
                {
                    'name': 'reset time',
                    'value': 0,
                    'isPersistent': False
                }
            )
            gfResetTimer = [0,
                            0,
                            [["whenGreenFlag"],
                             ["doIf",
                              [">",
                               ["-", ["*", 86400, ["-", ["timestamp"], ["readVariable", "reset time"]]], ["timer"]],
                               "0.1"],
                              [["setVar:to:", "reset time", ["-", ["timestamp"], ["/", ["timer"], 86400]]]]]]]
            output['scripts'].append(gfResetTimer)
            for sprite in sprites:
                sprite['scripts'].append(gfResetTimer)
            self.scriptCount += 1 + len(sprites)

        output['info']['scriptCount'] = self.scriptCount
        output['info']['spriteCount'] = self.totalTargets - 1

        self.monitors = []

        self.lists = {}
        self.stageLists = {}

        # Convert monitors

        self.convertingMonitors = True
        for m in self.jsonData['monitors']:
            self.addMonitor(m)

        self.updateListData(output, sprites, self.stageLists, self.lists)

        # Sort sprites into their layers

        sprites.sort(key=lambda sprite: sprite['layerOrder'])
        for sprite in sprites:
            del sprite['layerOrder']

        sprites.extend(self.monitors)
        self.convertingMonitors = False

        output['children'] = sprites

        # Add WeDo 2.0 extension if necessary

        if 'wedo2' in self.jsonData['extensions']:
            output['info']['savedExtensions'] = [{'extensionName': 'LEGO WeDo 2.0'}]

        output = json.dumps(output)

        self.zfsb2.writestr('project.json', output)

        self.zfsb3.close()
        self.zfsb2.close()

        return self.warnings, self.compatWarning and not self.compat, sb2path


def success(sb2path, warnings, gui):
    if gui:
        if warnings == 0:
            messagebox.showinfo("Success", "Completed with no warnings")
        elif warnings == 1:
            messagebox.showinfo("Success", f"Completed with 1 warning")
        else:
            messagebox.showinfo("Success", f"Completed with {warnings} warnings")
    else:
        print('')
        if warnings == 0:
            print(f"Saved to '{sb2path}' with no warnings")
        elif warnings == 1:
            print(f"Saved to '{sb2path}' with 1 warning")
        else:
            print(f"Saved to '{sb2path}' with {warnings} warnings")


if __name__ == '__main__':

    if '-h' in sys.argv:
        print(
            '''
    Arguments: sb3tosb2.py [unordered options] sb3path sb2path
    List of Options:
    -h: Show this list
    -c: Enable Scratch 3.0 compatibility mode; Add workarounds for blocks that are exclusive to or work differently in 3.0
      The indented options will automatically enable compatibility mode:
      -j: Use an unlimited join workaround
      -l: Use custom blocks to automatically limit list length to 200,000
    -p: Tries to insert blocks to fill the screen when the pen size is set to a value greater than 255
    ''')
        exit()

    gui = False
    if len(sys.argv) < 2:
        gui = True
        import tkinter
        from tkinter import filedialog, messagebox

        root = tkinter.Tk()
        root.withdraw()
        sb3path = filedialog.askopenfilename(title="Open SB3 Project", filetypes=[("Scratch 3 Project", "*.sb3")])
        i = sb3path.rfind('.')
        if i > -1:
            sb2path = f'{sb3path[0:i]}.sb2'
        else:
            sb2path = f'{sb3path}.sb2'
    else:
        if len(sys.argv) < 3:
            sb3path = sys.argv[-1]
            i = sb3path.rfind('.')
            if i > -1:
                sb2path = f'{sb3path[0:i]}.sb2'
            else:
                sb2path = f'{sb3path}.sb2'
        else:
            sb3path = sys.argv[-2]
            sb2path = sys.argv[-1]

    if gui:
        if sb3path == '' or sb2path == '':
            exit()

    args = []
    if len(sys.argv) > 3:
        for arg in sys.argv[1:-2]:
            args.append(arg)

    args = ''.join(args)
    c = '-c' in args
    j = '-j' in args
    l = '-l' in args
    p = '-p' in args

    result = ProjectConverter().convertProject(sb3path, sb2path, gui=gui, replace=False, compatibility=(c or j or l),
                                               unlimitedJoin=j, limitedLists=l, penFillScreen=p)
    warnings = result[0]
    sb2path = result[2]

    if result[1]:
        if gui:
            retry = messagebox.askquestion('Enable Compatibility Mode',
                                           "The converted project may not work properly unless compatibility mode is enabled.\n\nWould you like to re-convert the sb3 file with compatibility mode enabled?",
                                           icon='warning'
                                           )
            retry = (retry == 'yes')
        else:
            print('')
            printWarning("The converted project may not work properly unless compatibility mode is enabled.")
            retry = input(f"Would you like to re-convert '{sb3path}' with compatibility mode enabled? (Y/N): ")
            retry = (retry[0] == 'Y' or retry[0] == 'y')

        if retry:
            result = ProjectConverter().convertProject(sb3path, sb2path, gui=gui, replace=True, compatibility=True,
                                                       unlimitedJoin=j, limitedLists=l, penFillScreen=p)
            warnings = result[0]
            sb2path = result[2]

            success(sb2path, warnings, gui)
        else:
            success(sb2path, warnings, gui)
    else:
        success(sb2path, warnings, gui)