def __init__(self, project):
super(Sprite, self).__init__(project=project)
# "@" attributes
self.name = "No name"
self.idx = -1
self.variables.add(data.Variable("@x", data.Literal(0)))
self.variables.add(data.Variable("@y", data.Literal(0)))
self.variables.add(data.Variable("@heading", data.Literal(90)))
self.variables.add(data.Variable("@scale", data.Literal(1)))
self.rotation = 1
self.draggable = False
self.costume = 0
self.color = "80,80,80"
self.pen = "tip"
self.id = -1
# children specific to sprite
self.nest = None # optional child
# Not serialized
self.speech_message = ""
self.speech_is_thought = False # False == though, True == speech
self.speech_image = None
self.create_new_speech_message = False
def deserialize(self, elem):
"""Loads this class from an element tree representation"""
assert (elem.tag == "sprite")
super(Sprite, self).deserialize(elem)
# attributes
self.name = elem.get("name")
self.idx = int(elem.get("idx"))
self.set_property("@x", data.Literal(float(elem.get("x"))))
self.set_property("@y", data.Literal(float(elem.get("y"))))
self.set_property("@heading", data.Literal(float(elem.get("heading"))))
self.set_property("@scale", data.Literal(float(elem.get("scale"))))
self.rotation = float(elem.get("rotation"))
self.draggable = data.bool_from_string(elem.get("draggable"))
self.costume = int(elem.get("costume"))
self.color = elem.get("color")
self.pen = elem.get("pen")
self.id = int(elem.get("id"))
# unique children
self.nest = elem.find("nest")
def value_of_variable(self, actor, name):
v = self.get_variable(actor, name)
if v:
result = v.value()
if result:
return result
return data.Literal(None)
def evaluate(self, target, script):
# evaluate each of the arguments
if self.var_name is None:
args = []
args = [
arg.evaluate(target, script) for arg in self.arguments
if not isinstance(arg, data.Comment)
]
# if not isinstance(arg, (data.Comment, Script))]
else:
args = self.var_name
if self.function is None and self.type is BlockType.custom:
# The definitions have been loaded -- what is this function?
bd = target.find_block_definition(self.function_name)
if bd is not None:
self.function = bd.run
# now, run this function
if self.function is not None:
result = self.function(target, script, args)
else:
print "Unknown function: %s" % self.function_name
result = data.Literal(None)
# to do -- save args and result with timestamp
return result
def value_of_property(self, name):
v = self.get_property(name)
if v:
result = v.value()
if result:
return result
return data.Literal(None)
def doRepeat(target_actor, parent_script, args):
# We are in a loop
initial_count, script = args
# Did we just start for the first time?
if not parent_script.repeat:
# Yes, this is the first time
parent_script.repeat = initial_count.evaluate(
target_actor, parent_script).as_number()
else:
parent_script.repeat -= 1
if parent_script.repeat >= 1:
parent_script.activate_subscript(script)
else:
parent_script.repeat = 0
return data.Literal(parent_script.repeat)
def reportQuotient(target_actor, parent_script, args):
a, b = (args[0].as_number(), args[1].as_number())
return data.Literal(a / b)
def reportProduct(target_actor, parent_script, args):
return data.Literal(args[0].as_number() * args[1].as_number())
def reportTrue(target_actor, parent_script, args):
return data.Literal(True)
def reportOr(target_actor, parent_script, args):
lhs, rhs = args
return data.Literal(lhs.as_bool() or rhs.as_bool())
def reportEquals(target_actor, parent_script, args):
lhs, rhs = args
return data.Literal(lhs == rhs)
def reportRandom(target_actor, parent_script, args):
min, max = (args[0].as_number(), args[1].as_number())
return data.Literal(random.randrange(min, max))
def setScale(target_actor, parent_script, args):
scale = args[0].as_number() / 100
parent_script.set_variable(target_actor, "@scale", data.Literal(scale))
return None
def getCostumeIdx(target_actor, parent_script, args):
return data.Literal(target_actor.costume)
def increment_variable(self, actor, name, increment):
v = self.get_variable(actor, name)
if v:
v.set(data.Literal(v.value().as_number() + increment))
return None
def reportModulus(target_actor, parent_script, args):
return data.Literal(args[0].as_number() % args[1].as_number())
def reportRound(target_actor, parent_script, args):
return data.Literal(math.round(args[0].as_number()))
def getScale(target_actor, parent_script, args):
scale = parent_script.value_of_variable(target_actor, "@scale")
return data.Literal(scale.as_number() * 100)
def reportLessThan(target_actor, parent_script, args):
lhs, rhs = args
return data.Literal(lhs < rhs)
def setHeading(target_actor, parent_script, args):
angle = args[0].as_number()
target_actor.set_property("@heading", data.Literal(angle))
return None # target_actor.value_of_property("@heading")
def reportGreaterThan(target_actor, parent_script, args):
lhs, rhs = args
return data.Literal(lhs > rhs)
def reportSum(target_actor, parent_script, args):
return data.Literal(args[0].as_number() + args[1].as_number())
def reportNot(target_actor, parent_script, args):
value = args[0].as_bool()
return data.Literal(not value)
def reportDifference(target_actor, parent_script, args):
result = data.Literal(args[0].as_number() - args[1].as_number())
return result
def reportFalse(target_actor, parent_script, args):
return data.Literal(False)
def increment_property(self, name, increment):
v = self.get_property(name)
if v:
v.set(data.Literal(v.value().as_number() + increment))
return None
