Actor

Inhalt

Actor#

class miniworlds.actors.actor.Actor(position=(0, 0), *args, **kwargs)[Quellcode]#

Actor sind Objekte in Ihrer Welt. Actor können sich in der Welt bewegen und haben Sensoren, um andere Actor zu erkennen.

Das Erscheinungsbild / Appearance eines Actors wird durch sein Kostüm bestimmt.

Beispiele

Erstelle einen Actor:

from miniworlds import *

world = World()
world.size = (100,60)
Actor(position=(10, 10))

world.run()

Erstellen Sie einen Actor mit einem Bild:

from miniworlds import *

world = World(100,60)
actor = Actor((10, 10))
actor.add_costume("images/player.png")

world.run()

Erstelle einen Actor als Instanz aus einer benutzerdefinierten Klasse

import miniworlds

class MyActor(miniworlds.Actor):

    def on_setup(self):
        self.add_costume("images/player.png")

world = World(100,60)
my_actor = MyActor(position = (40,130))
world.run()

Erstellen Sie einen Actor an der aktuellen Mausposition:

from miniworlds import *

world = World()

@world.register
def act(self):
    Actor(self.mouse.get_position())

world.run()

Siehe auch

Siehe: :doc:Actor <../api/actor>
Siehe: :doc:Shapes <../api/actor_shapes>
Siehe: :doc:TextActors and NumberActors <../api/actor_text>

Öffentliche Datenattribute:

`actor_count`
`class_image`
`origin`
`collision_type`	collision_type gibt an, wie Kollisionen überprüft werden sollen:
`is_blockable`	A actor with the property `is_blockable` cannot move through actors with the property `is_blocking`.
`is_blocking`	A actor with the property `is_blockable` cannot move through actors with the property `is_blocking`.
`layer`	Defines the layer on which the actor is drawn if several actors overlap.
`last_position`	Actor-Position im letzten Frame
`last_direction`
`costume_count`	Returns number of costumes of actor, 0 if actor has no costume
`is_flipped`	Wenn ein Actor gespiegelt wird, wird er entlang der y-Achse gespiegelt.
`costume`	Gets the costume of the actor, if available.
`costumes`	Ruft den Kostümmanager ab
`orientation`
`direction`	Directions are handled exactly as in the Scratch programming language, see: Scratch Wiki
`direction_at_unit_circle`	Erhält die Richtung als Wert im Einheitskreis (0° rechts, 90° oben, 180° links…)
`size`	Größe des Actors
`width`	Die Breite des Actors in Pixeln.
`height`	Die Höhe des Actors in Pixeln.
`x`	Der x-Wert eines Actors
`y`	Der y-Wert eines Actors
`class_name`
`topleft_x`	x-Wert der oberen linken Position des Actors
`topleft_y`	x-Wert der oberen linken Position des Actors
`topleft`
`local_center`	x-Wert der Actor-Mittelposition innerhalb des aktuellen Kamerabildschirms
`center_x`	x-Wert der Actor-Mittelposition
`center_y`	y-Wert der Actor-Mittelposition
`center`
`is_rotatable`	Legt fest, ob das Kostüm eines Actors drehbar sein soll.
`static`	Should actor react to events? You can turn this option off for additional performance boost.
`fill_color`	Die Füllfarbe des Actors als RGBA-Wert, z.B. (255, 0, 0) für Rot.
`color`	Die Füllfarbe des Actors als RGBA-Wert, z.B. (255, 0, 0) für Rot.
`is_filled`	Ist der Actor mit Farbe gefüllt?
`border_color`	Randfarbe des Actors.
`stroke_color`	Randfarbe des Actors.
`border`	Die Randgröße des Actors.
`visible`	You can make this sprite disappear without removing it from the group assign 0 for invisible and 1 for visible
`world`
`image`	Das Bild des Actors:
`position`	Die Position des Actors als Position(x, y)
`actor_id`
`speed`

Inherited from ActorBase

`dirty`	Wenn der Actor dirty ist, wird er neu gezeichnet.
`rect`	Das umgebende Rechteck als pygame.Rect.
`position_manager`
`sensor_manager`
`costume_manager`

Inherited from DirtySprite

`visible`	You can make this sprite disappear without removing it from the group assign 0 for invisible and 1 for visible
`layer`	Die Ebeneneigenschaft kann nur festgelegt werden, bevor der Sprite zu einer Gruppe hinzugefügt wird. Danach ist sie schreibgeschützt und die Ebene eines Sprites in einer Gruppe sollte über die change_layer()-Methode der Gruppe festgelegt werden.

Inherited from Sprite

`image`
`rect`
`layer`	Dynamic, read only property for protected _layer attribute.

Öffentliche Methoden:

`__init__`([position])
`switch_origin`(value)
`create_on_world`(world)	Creates a actor to a specific world
`from_topleft`(topleft_position, args, *kwargs)	Creates a actor with center at center_position
`from_center`(center_position, args, *kwargs)	Creates a actor with center at center_position
`flip_x`()	Dreht den Actor um 180° Grad.
`add_costume`([source])	Adds a new costume to actor.
`add_costumes`(sources)	Adds multiple costumes
`remove_costume`([source])	Removes a costume from actor
`switch_costume`(source)	Switches the costume of actor
`set_costume`(costume)
`reset_costumes`()
`set_background_color`(color)
`next_costume`()	Switches to the next costume of actor
`has_costume`()
`turn_left`([degrees])	Turns actor by degrees degrees left :rtype: `int`
`turn_right`([degrees])	Turns actor by degrees degrees right
`set_direction`(direction)	Actor points in given direction.
`point_towards_position`(destination)	Actor points towards a given position
`point_towards_actor`(other)	Actor points towards another actor.
`set_size`(value)
`scale_width`(value)
`scale_height`(value)
`move`([distance, direction])	Moves actor distance steps in current direction
`move_vector`(vector)	Moves actor in direction defined by the vector
`move_back`(distance)
`undo_move`()	Mache den letzten Zug rückgängig.
`move_towards`(target)
`move_in_direction`(direction[, distance])	Bewegt den Actor distance Schritte in eine direction oder zu einer Position
`move_to`(position)	Bewegt den Actor distance zu einer bestimmten world_posiition
`remove`([kill])	Entfernt diesen Actor aus der Welt
`before_remove`()
`bounce_from_border`(borders)	“prallt” von einem Rand ab.
`detect_all`([actors, direction, distance])	Detects if actors are on actor position.
`detect`(args, *kwargs)	Detects if actors are on actor position.
`detect_borders`([distance])	Detects borders
`detect_left_border`()	Does the actor touch the left border?
`detect_right_border`()	Does the actor touch the right border?
`detect_top_border`()	Does the actor touch the lower border?
`detecting_bottom_border`()	Does the actor touch the lower border?
`detect_color`([color])	Detects colors in world-background at actor center-position
`detect_color_at`([direction, distance])	Detects colors in world-background at actor-position
`detect_actors_at`([direction, distance, actors])	Detects a actor in given direction and distance.
`detect_actor_at`([direction, distance, actors])
`detect_actors_in_front`([actors, distance])
`detect_actor_in_front`([actors, distance])
`detect_point`(position)	Is the actor colliding with a specific (global) point?
`detect_pixel`(position)	Is the actor colliding with a pixel?
`detect_rect`(rect)	Is the actor colliding with a static rect?
`is_inside_world`()	Is the actor colliding with current ....
`bounce_from_actor`(other)
`animate`([speed])
`animate_costume`(costume[, speed])
`animate_loop`([speed])	Animates a costume with a looping animation
`stop_animation`()	Stops current animation.
`send_message`(message)	Sends a message to world.
`on_key_down`(key)	on_key_down is called one time when a key is pressed down.
`on_key_pressed`(key)	on_key_pressed is called when while key is pressed.
`on_key_up`(key)
`on_mouse_over`(position)	on_mouse_over wird aufgerufen, wenn die Maus über den Actor bewegt wird :type position: :param position: Die Mausposition
`on_mouse_leave`(position)	on_mouse_over wird aufgerufen, wenn die Maus über den Actor bewegt wird :type position: :param position: Die Mausposition
`on_mouse_left_down`(position)
`on_mouse_right_down`(position)
`on_mouse_left`(position)	on_mouse_left is called when left mouse button was pressed.
`on_mouse_right`(position)	Method is called when right mouse button was pressed.
`on_mouse_motion`(position)	Method is called when mouse moves.
`on_mouse_left_released`(position)	Method is called when left mouse key is released.
`on_mouse_right_released`(position)	Method is called when right mouse key is released.
`on_clicked_left`(position)	The mouse is on top of a actor and mouse was clicked.
`on_clicked_right`(position)	The mouse is on top of a actor and mouse was clicked.
`on_detecting_world`()	on_detecting_world is called, when actor is on the world
`on_not_detecting_world`()	on_detecting_world is called, when actor is on the world
`on_detecting_actor`(actor)	on_detecting_actor is called, when actor is detects a actor on same position
`on_detecting_borders`(borders)	on_detecting_border wird aufgerufen, wenn sich der Actor in der Nähe einer Grenze befindet
`fill`(value)	Füllfarbe für Ränder und Linien festlegen
`hide`()	Verbirgt einen Actor (der Actor wird unsichtbar)
`show`()	Zeigt einen Actor an (ein unsichtbarer Actor wird sichtbar)
`register_sensor`(args, *kwargs)	This method is used for the @register_sensor decorator.
`get_local_rect`()
`set_world`(new_world)
`new_costume`()
`set_position`(value)
`get_distance_to`(obj)	Gets the distance to another actor or a position
`on_shape_change`()

Inherited from ActorBase

`register`(method[, force, name])	This method is used for the @register decorator.
`register_message`(args, *kwargs)	Registriert eine Methode bei einem Objekt, um bestimmte `on_message`-Ereignisse zu bearbeiten.
`__str__`()	Gib str(self) zurück.
`get_costume_class`()

Inherited from DirtySprite

`__init__`(*groups)
`__repr__`()	Return repr(self).

Inherited from Sprite

`__init__`(*groups)
`add`(*groups)	add the sprite to groups
`remove`(*groups)	remove the sprite from groups
`add_internal`(group)	For adding this sprite to a group internally.
`remove_internal`(group)	For removing this sprite from a group internally.
`update`(args, *kwargs)	method to control sprite behavior
`kill`()	remove the Sprite from all Groups
`groups`()	list of Groups that contain this Sprite
`alive`()	does the sprite belong to any groups
`__repr__`()	Return repr(self).

Private Data Attributes:

`_abc_impl`
`_world`
`_sensor_manager`
`_position_manager`
`_costume_manager`
`_collision_type`
`_layer`
`_is_acting`
`__image`
`__rect`

Inherited from ActorBase

_abc_impl

Private Methoden:

_validate_arguments(position, *args, **kwargs)

Inherited from ActorBase

_is_actor_repainted()

Inherited from DirtySprite

`_set_visible`(val)	den sichtbaren Wert (0 oder 1) festlegen und den Sprite als verändert markieren
`_get_visible`()	return the visible value of that sprite

actor_count: int = 0#

add_costume(source=None)[Quellcode]#

Fügt dem Actor ein neues Kostüm hinzu. Das Kostüm kann mit self.switch_costume(index) gewechselt werden

Rückgabetyp:: Costume
Parameter:: source – Pfad zum ersten Bild des neuen Kostüms oder Tupel mit Farbwert

Beispiele

Erstes Kostüm aus dem Bild hinzufügen:

from miniworlds import *

world = World(100,60))
actor = Actor((10,10))
costume = actor.add_costume("images/player.png")

world.run()

Ausgabe:

Füge das erste Kostüm aus der Farbe hinzu:

from miniworlds import *

world = World(100,60))
actor = Actor((10,10))
costume = actor.add_costume((255,255,0))

world.run()

Ausgabe:

Erstelle zwei Kostüme und wechsle zwischen den Kostümen

from miniworlds import *

world = World(100,60))
actor = Actor((10,10))
world.speed = 30
costume1 = actor.add_costume((255,255,0))
costume2 = actor.add_costume((255,0,255))
@actor.register
def act(self):
    if self.costume == costume1:
        self.switch_costume(costume2)
    else:
        self.switch_costume(costume1)

world.run()

Ausgabe:

Erstelle mehrere Kostüme und wechsle zwischen den Kostümen

Rückgabe:: Das neue Kostüm.

add_costumes(sources)[Quellcode]#

Adds multiple costumes

Rückgabetyp:: Costume

animate(speed=10)[Quellcode]#

animate_costume(costume, speed=10)[Quellcode]#

animate_loop(speed=10)[Quellcode]#

Animates a costume with a looping animation

Wechselt alle Kostümbilder bei jedem „Geschwindigkeit“-Frame durch.

Beispiele

from miniworlds import *

world = World(columns=280, rows=100)
robo = Actor(position=(0, 0))
robo.costume.add_images(["images/1.png", "images/2.png","images/3.png","images/4.png"])
robo.size = (99, 99)
robo.animate_loop()
world.run()

Parameter:: speed (int, optional) – Jedes speed-Frame wird das Bild gewechselt. Standardmäßig auf 10.

before_remove()[Quellcode]#

property border#

Die Randgröße des Actors.

Der Wert ist 0, wenn der Actor keinen Rand hat.

Bemerkung

Sie können auch den Rand mit costume.border festlegen oder Sie können den Rand mit world.default_border festlegen

Beispiele

Rand des Actors festlegen:

from miniworlds import *

world = World(210,80)
world.default_border_color = (0,0, 255)
world.default_border = 1

t = Actor((10,10)) # default-border and color from world
t.add_costume("images/player.png")

t2 = Actor ((60, 10)) # overwrites default border values
t2.add_costume("images/player.png")
t2.border_color = (0,255, 0)
t2.border = 5

t3 = Actor ((110, 10)) # removes border
t3.add_costume("images/player.png")
t3.border = None

world.run()

Ausgabe:

property border_color#

Randfarbe des Actors.

Die Randfarbe ist ein RGBA-Wert, zum Beispiel (255, 0, 0) für Rot, (0, 255, 0) für Grün und (255, 0, 0, 100).

Wenn der Farbwert 4 Werte hat, definiert der letzte Wert die Transparenz:

0: Voll transparent,
255: Keine Transparenz

Bemerkung

Sie müssen auch :py:attr:Actor.border auf einen Wert > 0 setzen

Aliase: :py:attr:Actor.stroke_color

Beispiele

Siehe :py:attr:Actor.border

bounce_from_actor(other)[Quellcode]#

bounce_from_border(borders)[Quellcode]#

“prallt” von einem Rand ab.

The direction is set according to the principle input angle = output angle. :rtype: Actor

Bemerkung

Sie müssen zuerst die Grenzen überprüfen!

Parameter:: borders – Eine Liste von Rändern als Zeichenfolgen, z.B. [“left”, “right”]

Beispiele

from miniworlds import *
import random

world = World(150, 150)
actor = Actor((50,50))
actor.add_costume("images/ball.png")
actor.direction = 10

@actor.register
def act(self):
    self.move()
    borders = self.detecting_borders()
    if borders:
        self.bounce_from_border(borders)

world.run()

Ausgabe:

Rückgabe:: Der Actor

property center: Tuple[float, float]#

property center_x: float#: x-Wert der Actor-Mittelposition

property center_y: float#: y-Wert der Actor-Mittelposition

class_image: str = ''#

property class_name: str#

property collision_type: str#

collision_type gibt an, wie Kollisionen überprüft werden sollen:

default: Kachel für TiledWorlds, ‘Maske’ für Pixelwelten
tile: Befinden sich die Actors auf derselben Kachel? (nur TiledWorld)
rect: Kollidieren die Actors beim Überprüfen ihrer Begrenzungsrahmen? (Nur PixelWorld)
static-rect: Kollidieren Actors beim Überprüfen eines Kreises mit Radius = Begrenzungsrahmenradius. (Nur PixelWorld)
circle: Kollidieren Actors beim Überprüfen des Kreises mit Radius = Begrenzungsrahmenradius. (Nur PixelWorld)
mask: Überprüfen die Actors, ob ihre Bildmasken sich überschneiden, wenn sie kollidieren.

property color#

Die Füllfarbe des Actors als RGBA-Wert, z.B. (255, 0, 0) für Rot.

Wenn fill_color auf eine Farbe gesetzt ist, wird das Attribut is_filled des Kostüms (siehe: :py:attr:.appearances.appearance.Appearance.is_filled) auf True gesetzt.

Bemerkung

Aliase: :py:attr:Actor.color

Warnung

Wenn Sie ein Kostüm mit einem Bild füllen, wird das Bild vollständig überschrieben, selbst wenn fill_color transparent ist.

Dieses Verhalten kann sich in späteren Versionen ändern!

Beispiele:

from miniworlds import *

world = World(200,80)
world.default_fill_color = (0,0, 255)

t = Actor()

t2 = Actor((40,0))
t2.is_filled = (0, 255, 0)

t3 = Actor((80, 0))
t3.fill_color = (255, 0, 0)

t4 = Actor((120, 0))
t4.add_costume((0,0,0))
t4.fill_color = (255, 255, 0)

t5 = Actor((160, 0))
t5.add_costume("images/player.png")
t5.fill_color = (255, 255, 0, 100) # image is overwritten

t6 = Circle((0, 40), 20)
t6.position = t6.center
t6.fill_color = (255, 255, 255)

t7 = Ellipse((40, 40), 40, 40)
t7.fill_color = (255, 0, 255)

world.run()

Ausgabe:

property costume: Costume#: Gets the costume of the actor, if available.

property costume_count: int#

Returns number of costumes of actor, 0 if actor has no costume

Beispiele

Kostüm hinzufügen und Kostüme zählen

from miniworlds import *
world = World()
actor = Actor()
assert actor.costume_count == 0
actor.add_costume((255,0,0,0))
assert actor.costume_count == 1
world.run()

Rückgabe:: beschreibung
Rückgabetyp:: int

property costumes: CostumesManager#

Ruft den Kostümmanager ab

Der Kostümmanager kann iteriert werden, um alle Kostüme zu erhalten

classmethod create_on_world(world)[Quellcode]#

Creates a actor to a specific world

in Unterklassen überschrieben

detect(*args, **kwargs)[Quellcode]#

Erkennt, ob sich Actors an der Position eines Actors befinden. Gibt den zuerst gefundenen Actor zurück.

Rückgabetyp:

Optional[Actor]

Parameter:

actors – nach Actortyp filtern. Geben Sie einen class_name der Actor ein, nach denen gesucht werden soll Richtung: int = 0, Entfernung: int = 0
direction – Die Richtung, in der Actor erkannt werden sollen.
distance – Die Entfernung, in der Actors erkannt werden sollten (Startpunkt ist actor.center)

Rückgabe:

Erster Actor vom Sensor gefunden

Beispiele

Der grüne Roboter schiebt den gelben Roboter:

from miniworlds import *

world = TiledWorld(8,3)
actor = Actor((1,1))
actor.add_costume("images/robo_green.png")
actor.orientation = -90
actor.direction = 90

actor2 = Actor((4,1))
actor2.add_costume("images/robo_yellow.png")
actor2.orientation = -90
actor2.direction = -90

@actor.register
def act(self):
    self.move()
    actor = self.detecting_actor()
    if actor:
        actor.move_right()
world.run()

Ausgabe:

detect_actor_at(direction=None, distance=0, actors=None)[Quellcode]#

Rückgabetyp:: Actor

detect_actor_in_front(actors=None, distance=1)[Quellcode]#

Rückgabetyp:: Actor

detect_actors_at(direction=None, distance=0, actors=None)[Quellcode]#

Detects a actor in given direction and distance.

Beispiele

from miniworlds import *
world = World()
wall=Rectangle((200,0))
wall.size = (20, 400)

for i in range(7):
    actor = Circle((10,i*60 + 20))
    actor.range = i * 10
    @actor.register
    def act(self):
        if not self.detect_actors_at(self.direction, self.range):
            self.direction = "right"
            self.move()

world.run()

Parameter:

direction – Die Richtung, in der Actor erkannt werden sollen.
distance – Die Entfernung, in der Actors erkannt werden sollten (Startpunkt ist actor.center)

Rückgabetyp:

list

Rückgabe:

Eine Liste von Actorn

detect_actors_in_front(actors=None, distance=1)[Quellcode]#

Rückgabetyp:: list

detect_all(actors=None, direction=0, distance=0)[Quellcode]#

Erkennt, ob sich Actors an der Position eines Actors befinden. Gibt eine Liste von Actorsn zurück.

Rückgabetyp:

List[Actor]

Parameter:

actors – nach Actortyp filtern. Geben Sie hier einen class_name der gesuchten Actor ein
direction – Die Richtung, in der Actor erkannt werden sollen.
distance – Die Entfernung, in der Actors erkannt werden sollten (Startpunkt ist actor.center)

Rückgabe:

Alle von Sensor gefundenen Actors

detect_borders(distance=0)[Quellcode]#

Detects borders

Args: :rtype: List

distance: Specifies the distance in front of the actuator to which the sensors reacts.

Rückgabe:: Wahr, wenn eine Grenze gefunden wurde.

detect_color(color=None)[Quellcode]#

Detects colors in world-background at actor center-position

Rückgabetyp:: bool
Parameter:: color – Farbe als Tupel
Rückgabe:: Wahr, wenn die Farbe gefunden wurde

detect_color_at(direction=None, distance=0)[Quellcode]#

Detects colors in world-background at actor-position

Rückgabetyp:

Union[Tuple, List]

Parameter:

direction – Gibt die Richtung an, in der die Sensoren suchen.
distance – Gibt den Abstand vor dem Aktuator an, auf den die Sensoren reagieren.

Rückgabe:

Alle vom Sensor gefundenen Farben

detect_left_border()[Quellcode]#

Does the actor touch the left border?

Rückgabetyp:: bool
Rückgabe:: Wahr, wenn eine Grenze gefunden wurde.

detect_pixel(position)[Quellcode]#

Is the actor colliding with a pixel?

Rückgabetyp:: bool
Rückgabe:: Wahr, wenn der Pixel unter dem Actor ist

detect_point(position)[Quellcode]#

Is the actor colliding with a specific (global) point?

Rückgabetyp:: bool

Warnung

Wenn Sie überprüfen möchten, ob ein Actor einen bestimmten Pixel erkennt, verwenden Sie detect_pixel

Rückgabe:: Wahr, wenn der Punkt unter dem Actor liegt

detect_rect(rect)[Quellcode]#: Is the actor colliding with a static rect?

detect_right_border()[Quellcode]#

Does the actor touch the right border?

Rückgabetyp:: bool
Rückgabe:: Wahr, wenn eine Grenze gefunden wurde.

detect_top_border()[Quellcode]#

Does the actor touch the lower border?

Rückgabetyp:: bool
Rückgabe:: Wahr, wenn eine Grenze gefunden wurde.

detecting_bottom_border()[Quellcode]#

Does the actor touch the lower border?

Rückgabetyp:: bool
Rückgabe:: Wahr, wenn eine Grenze gefunden wurde.

property direction: int#

Directions are handled exactly as in the Scratch programming language, see: Scratch Wiki

Die Standardrichtung ist 0°. Alle Actors schauen "nach oben"

Werte für Richtung

0° oder "up": oben
90° oder "rechts": Nach rechts bewegen
-90° oder "left": Nach links bewegen
180° oder "down": Nach unten bewegen
"forward": Aktuelle Richtung

Legt die Richtung des Actors fest.

Sie können eine ganze Zahl oder einen String verwenden, um die Richtung zu beschreiben

Optionen

0, "up" - Nachschlagen
90, "right", - Schau nach rechts
-90, "left", - Schau nach links
-180, 180, "down" - Schau nach unten

Beispiele

Bewege dich mit den WASD-Tasten in eine Richtung

def on_key_down(self, keys):
    if "W" in keys:
        self.direction = "up"
    elif "S" in keys:
        self.direction = "down"
    elif "A" in keys:
        self.direction = "left"
    elif "D" in keys:
        self.direction = "right"
    self.move()

Bewege 45°:

from miniworlds import *

world = World(100, 100)
c = Circle ((50,50), 10)

@c.register
def act(self):
    c.direction = 45
    c.move()

world.run()

Bewege -45°:

from miniworlds import *

world = World(100, 100)
c = Circle ((50,50), 10)

@c.register
def act(self):
    c.direction = -45
    c.move()

world.run()

property direction_at_unit_circle: int#: Erhält die Richtung als Wert im Einheitskreis (0° rechts, 90° oben, 180° links…)

fill(value)[Quellcode]#: Füllfarbe für Ränder und Linien festlegen

property fill_color#

Die Füllfarbe des Actors als RGBA-Wert, z.B. (255, 0, 0) für Rot.

Wenn fill_color auf eine Farbe gesetzt ist, wird das Attribut is_filled des Kostüms (siehe: :py:attr:.appearances.appearance.Appearance.is_filled) auf True gesetzt.

Bemerkung

Aliase: :py:attr:Actor.color

Warnung

Wenn Sie ein Kostüm mit einem Bild füllen, wird das Bild vollständig überschrieben, selbst wenn fill_color transparent ist.

Dieses Verhalten kann sich in späteren Versionen ändern!

Beispiele:

from miniworlds import *

world = World(200,80)
world.default_fill_color = (0,0, 255)

t = Actor()

t2 = Actor((40,0))
t2.is_filled = (0, 255, 0)

t3 = Actor((80, 0))
t3.fill_color = (255, 0, 0)

t4 = Actor((120, 0))
t4.add_costume((0,0,0))
t4.fill_color = (255, 255, 0)

t5 = Actor((160, 0))
t5.add_costume("images/player.png")
t5.fill_color = (255, 255, 0, 100) # image is overwritten

t6 = Circle((0, 40), 20)
t6.position = t6.center
t6.fill_color = (255, 255, 255)

t7 = Ellipse((40, 40), 40, 40)
t7.fill_color = (255, 0, 255)

world.run()

Ausgabe:

flip_x()[Quellcode]#

Flips the actor by 180° degrees. The costume is flipped and the actor’s direction changed by 180 degrees. :rtype: int

Beispiele

Drehe einen Actor in Beispiel flipthefish.py

from miniworlds import *

world=TiledWorld()
world.columns = 4
world.rows = 1
world.add_background("images/water.png")
fish = Actor()
fish.border = 1
fish.add_costume("images/fish.png")
fish.direction = "right"
fish.orientation = -90
@fish.register
def act(self):
    self.move()

@fish.register
def on_not_detecting_world(self):
    self.move_back()
    self.flip_x()

world.run()

Ausgabe:

classmethod from_center(center_position, *args, **kwargs)[Quellcode]#

Creates a actor with center at center_position

Arg`s:: center_position: Mittelpunkt des Actors

classmethod from_topleft(topleft_position, *args, **kwargs)[Quellcode]#

Creates a actor with center at center_position

Arg`s:: center_position: Mittelpunkt des Actors

get_distance_to(obj)[Quellcode]#

Gets the distance to another actor or a position

Rückgabetyp:: float
Parameter:: obj – Actor oder Position
Rückgabe:: Der Abstand zwischen dem Actor (gemessen von actor.center) zum Actor oder zur Position.
Rückgabetyp:: float

get_local_rect()[Quellcode]#

Rückgabetyp:: Rect

has_costume()[Quellcode]#

Rückgabetyp:: bool

property height#

Die Höhe des Actors in Pixeln.

Wenn die Höhe eines Actors geändert wird, wird die Breite proportional skaliert.

Beispiele

Erstellen Sie einen Actor und skalieren Sie die Breite/Höhe proportional:

from miniworlds import *

world = World(800,400)

def create_actor(x, y):
t = Actor()
t.position = (x, y)
t.add_costume("images/alien1.png")
t.border = 1
return t

t0 = create_actor(0,0)
t1 = create_actor(50,0)
t1.height = 400
t2 = create_actor(300,0)
t2.width = 180

world.run()

hide()[Quellcode]#: Verbirgt einen Actor (der Actor wird unsichtbar)

property image: Surface#: Das Bild des Actors:

Warnung

Warnung: Sie sollten nicht direkt auf das Bild zeichnen (mit pygame-Funktionen), da das Bild während der Animationen neu geladen wird

property is_blockable#: A actor with the property is_blockable cannot move through actors with the property is_blocking.

property is_blocking#: A actor with the property is_blockable cannot move through actors with the property is_blocking.

property is_filled#: Ist der Actor mit Farbe gefüllt?

property is_flipped: bool#

Wenn ein Actor gespiegelt wird, erfolgt die Spiegelung entlang der y-Achse. Sie können diese Eigenschaft in 2D-Plattformspielen verwenden, um die Richtung des Actors zu ändern.

Bemerkung

Es kann notwendig sein, is_rotatable = True festzulegen

Beispiele

Drehe ein Kostüm nach 100 Bildern um.

from miniworlds import *

world = World(100,100)
actor = Actor()
actor.add_costume("images/alien1.png")
actor.height= 400
actor.width = 100
actor.is_rotatable = False
@actor.register
def act(self):
    if self.world.frame % 100 == 0:
        if self.is_flipped:
            self.is_flipped = False
        else:
            self.is_flipped = True
world.run()

Ausgabe:

Rückgabe:: Wahr, wenn der Actor umgedreht ist

is_inside_world()[Quellcode]#: Is the actor colliding with current ….

property is_rotatable: bool#

Legt fest, ob das Kostüm eines Actors drehbar sein soll. Der Actor kann immer noch mit der Eigenschaft direction gedreht werden, aber sein Kostüm wird nicht verändert

Bemerkung

Sie können auch actor.costume.is_rotatable verwenden

Beispiele

Erstellen Sie einen drehbaren und einen nicht drehbaren Actor

from miniworlds import *
world = World()

t1 = Actor((100,100))
t1.add_costume("images/alien1.png")

t2 = Actor((200,200))
t2.add_costume("images/alien1.png")
t2.is_rotatable = False

@t1.register
def act(self):
    self.move()
    self.direction += 1

@t2.register
def act(self):
    self.move()
    self.direction += 1

world.run()

Ausgabe:

property last_direction: int#

property last_position: Tuple[float, float]#

Actor-Position im letzten Frame

Kann verwendet werden, um Änderungen zu verfolgen.

property layer: int#: Defines the layer on which the actor is drawn if several actors overlap.

property local_center: Tuple[float, float]#: x-Wert der Actor-Mittelposition innerhalb des aktuellen Kamerabildschirms

move(distance=0, direction=0)[Quellcode]#

Moves actor distance steps in current direction

Parameter:: distance – Anzahl der Schritte, die bewegt werden sollen. Wenn die Entfernung = 0 ist, wird die Geschwindigkeit des Actors verwendet.
Rückgabe:: Der bewegte Actor

Beispiele

wenn der Actor in der Welt ist, vorwärts bewegen:

class Robot(Actor):

    def act(self):
        if self.detecting_world():
            self.move()

move_back(distance)[Quellcode]#

move_in_direction(direction, distance=1)[Quellcode]#

Bewegt den Actor distance Schritte in eine direction oder zu einer Position

Optionen

0, “up” - Nachschlagen
90, “rechts”, - Schau nach rechts
-90, “links”, - Schau nach links
-180, 180, “unten” - Schau nach unten

Parameter:

direction – Richtung als Winkel
distance – Erkennt Objekte “Entfernung” Schritte vor dem aktuellen Actor.

Rückgabe:

Der Actor selbst

move_to(position)[Quellcode]#

Bewegt den Actor distance zu einer bestimmten world_posiition

Parameter:

position – Die Position, zu der sich der Actor bewegen soll. Die Position kann ein 2-Tupel (x, y) sein
world_position (which will be converted to a)

Rückgabe:: Der Actor selbst

Beispiele

bewege zu (3, 2) bei Maus-Klick

def on_clicked_left(self, position):
    self.move_to((3,2))

move_towards(target)[Quellcode]#

move_vector(vector)[Quellcode]#

Moves actor in direction defined by the vector

Rückgabe:: Der bewegte Actor

new_costume()[Quellcode]#

next_costume()[Quellcode]#

Switches to the next costume of actor

Rückgabe:: Das neue Kostüm

on_clicked_left(position)[Quellcode]#

The mouse is on top of a actor and mouse was clicked.

Beispiele

Registrieren eines on_click-Ereignisses:

actor = miniworlds.Actor((2,2))

@actor.register
def on_clicked_left(self, position):
    print("clicked" + str(position))

Parameter:: position (tuple) – Aktuelle Mausposition als Tupel (x,y)
Verursacht:: NotImplementedOrRegisteredError – Der Fehler tritt auf, wenn die Methode nicht überschrieben oder registriert wird.

on_clicked_right(position)[Quellcode]#

The mouse is on top of a actor and mouse was clicked.

Beispiele

Registrieren eines on_click-Ereignisses:

actor = miniworlds.Actor((2,2))

@actor.register
def on_clicked_right(self, position):
    print("clicked" + str(position))

Parameter:: position (tuple) – Aktuelle Mausposition als Tupel (x,y)
Verursacht:: NotImplementedOrRegisteredError – Der Fehler tritt auf, wenn die Methode nicht überschrieben oder registriert wird.

on_detecting_actor(actor)[Quellcode]#

on_detecting_actor is called, when actor is detects a actor on same position

Parameter:: actor (Actor) – Der gefundene Actor

Beispiele

Registriere detect_actor-Ereignis

@player.register
def on_detecting_actor(self, actor):
    print("Player 1: detecting actor:")
    if actor == player2:
    print("Am i detecting player2?" + str(actor == player2))

Verursacht:: NotImplementedOrRegisteredError – Der Fehler tritt auf, wenn die Methode nicht überschrieben oder registriert wird.

on_detecting_borders(borders)[Quellcode]#

on_detecting_border wird aufgerufen, wenn sich der Actor in der Nähe einer Grenze befindet

Parameter:: borders (List) – Eine Liste von Zeichenfolgen mit gefundenen Grenzen, z.B.: [‘left’, ‘top’]

Beispiele

Registrieren Sie on_detecting_border_event:

@player.register
def on_detecting_borders(self, borders):
    print("Player 4: detecting borders:")
    print("Borders are here!", str(borders))

Verursacht:: NotImplementedOrRegisteredError – Der Fehler tritt auf, wenn die Methode nicht überschrieben oder registriert wird.

on_detecting_world()[Quellcode]#

on_detecting_world is called, when actor is on the world

Beispiele

Registrieren Sie die Methode on_detecting_world:

@player.register
    def on_detecting_world(self):
        print("Player 3: I'm on the world:")

Verursacht:: NotImplementedOrRegisteredError – Der Fehler tritt auf, wenn die Methode nicht überschrieben oder registriert wird.

on_key_down(key)[Quellcode]#

on_key_down is called one time when a key is pressed down.

Bemerkung

Statt on_key_down können Sie on_key_down_letter verwenden, z. B. on_key_down_a oder on_key_down_w, wenn Sie ein on_key_down-Ereignis für einen bestimmten Buchstaben behandeln möchten.

Beispiele

Registriere ein key_down-Ereignis:

actor1 = miniworlds.Actor(position = (2, 2) )
actor1.add_costume((100,0,100,100))

@actor1.register
def on_key_down(self, key):
    print(key)

Registriere on_key_down_a Ereignis

actor1 = miniworlds.Actor(position = (2, 2) )
actor1.add_costume((100,0,100,100))

@actor1.register
def on_key_down_a(self):
    print("a")

Parameter:: key (list) – Der eingegebene Schlüssel als Liste (z. B. [‘A’, ‘a’]), die sowohl Groß- als auch Kleinbuchstaben des eingegebenen Buchstabens enthält.
Verursacht:: NotImplementedOrRegisteredError – Der Fehler tritt auf, wenn die Methode nicht überschrieben oder registriert wird.

on_key_pressed(key)[Quellcode]#

on_key_pressed wird aufgerufen, wenn eine Taste gedrückt wird. Wenn Sie die Taste gedrückt halten, wird on_key_pressed immer wieder aufgerufen, bis die Taste losgelassen wird.

Bemerkung

Wie on_key_down kann die Methode in der Variante on_key_pressed_[letter] aufgerufen werden (z.B. on_key_pressed_w(self)).

Beispiele

Registrieren Sie das on_key_pressed-Ereignis:

actor1 = miniworlds.Actor(position = (2, 2) )
actor1.add_costume((100,0,100,100))

@actor1.register
def on_key_pressed(self, key):
    print("pressed", key)

@actor1.register
def on_key_pressed_s(self):
    print("pressed s")

Parameter:

key (list) – Der eingegebene Schlüssel als Liste (z. B. [‘C’, ‘c’, ‘D’, ‘d’]), die sowohl Groß- als auch Kleinbuchstaben enthält
letter. (of typed)

Verursacht:

NotImplementedOrRegisteredError – Der Fehler tritt auf, wenn die Methode nicht überschrieben oder registriert wird.

on_key_up(key)[Quellcode]#

on_mouse_leave(position)[Quellcode]#: on_mouse_over wird aufgerufen, wenn die Maus über den Actor bewegt wird :type position: :param position: Die Mausposition

on_mouse_left(position)[Quellcode]#

on_mouse_left wird aufgerufen, wenn die linke Maustaste gedrückt wurde. Sie müssen diese Methode als Ereignis registrieren oder implementieren.

Bemerkung

Das Ereignis wird ausgelöst, wenn die linke Maustaste geklickt wurde, selbst wenn die aktuelle Mausposition nicht mit der Position des Actors in Zusammenhang steht.

Sie können :py:meth:Actor.detect_pixel verwenden, um zu überprüfen, ob sich die mouse_position innerhalb des Actors befindet.

Beispiele

Ein Kreis wird verschoben, wenn Sie auf den Kreis klicken.

from miniworlds import *

world = World(120,40)
circle = Circle((20, 20))
circle.direction = 90

@circle.register
def on_mouse_left(self, mouse_pos):
    if self.detect_pixel(mouse_pos):
        self.move()

world.run()

Parameter:: position (tuple) – Aktuelle Mausposition als Tupel (x,y)
Verursacht:: NotImplementedOrRegisteredError – Der Fehler tritt auf, wenn die Methode nicht überschrieben oder registriert wird.

on_mouse_left_down(position)[Quellcode]#

on_mouse_left_released(position)[Quellcode]#

Method is called when left mouse key is released.

Beispiele

Sie können on_mouse_left_release verwenden, um ein drag_and_drop-Ereignis zu implementieren

from miniworlds import *

world = World(200, 200)
circle = Circle((30, 30), 60)
circle.direction = 90
circle.dragged = False

@circle.register
def on_mouse_left(self, mouse_pos):
    if self.detect_pixel(mouse_pos):
        self.dragged = True

@circle.register
def on_mouse_left_released(self, mouse_pos):
    if not world.is_mouse_pressed():
        self.dragged = False
        self.center = mouse_pos

world.run()

Ausgabe:

Parameter:: position (tuple) – Aktuelle Mausposition als Tupel (x,y)
Verursacht:: NotImplementedOrRegisteredError – Der Fehler tritt auf, wenn die Methode nicht überschrieben oder registriert wird.

on_mouse_motion(position)[Quellcode]#

Die Methode wird aufgerufen, wenn die Maus bewegt wird. Sie müssen diese Methode als Ereignis registrieren oder implementieren.

Bemerkung

Das Ereignis wird ausgelöst, wenn die Maus bewegt wird, selbst wenn die aktuelle Mausposition nicht mit der Position des Actors in Zusammenhang steht.

Sie können :py:meth:Actor.detect_pixel verwenden, um zu überprüfen, ob sich die mouse_position innerhalb des Actors befindet.

Beispiele

Ein Kreis wird verschoben, wenn Sie auf den Kreis klicken.

from miniworlds import *

world = World(120,40)
circle = Circle((20, 20))
circle.direction = 90

@circle.register
def on_mouse_motion(self, mouse_pos):
    if self.detect_pixel(mouse_pos):
        self.move()

world.run()

Parameter:: position (tuple) – Aktuelle Mausposition als Tupel (x,y)
Verursacht:: NotImplementedOrRegisteredError – Der Fehler tritt auf, wenn die Methode nicht überschrieben oder registriert wird.

on_mouse_over(position)[Quellcode]#: on_mouse_over wird aufgerufen, wenn die Maus über den Actor bewegt wird :type position: :param position: Die Mausposition

on_mouse_right(position)[Quellcode]#

Methode wird aufgerufen, wenn die rechte Maustaste gedrückt wurde. Sie müssen diese Methode als Ereignis registrieren oder implementieren.

Bemerkung

Das Ereignis wird ausgelöst, wenn die Maus geklickt wurde, selbst wenn die aktuelle Mausposition nicht mit der Position des Actors in Zusammenhang steht.

Sie können :py:meth:Actor.detect_pixel verwenden, um zu überprüfen, ob sich die mouse_position innerhalb des Actors befindet.

Beispiele

Siehe: :py:meth:Actor.on_mouse_left.

Parameter:: position (tuple) – Aktuelle Mausposition als Tupel (x,y)
Verursacht:: NotImplementedOrRegisteredError – Der Fehler tritt auf, wenn die Methode nicht überschrieben oder registriert wird.

on_mouse_right_down(position)[Quellcode]#

on_mouse_right_released(position)[Quellcode]#

Methode wird aufgerufen, wenn die rechte Maustaste losgelassen wird. Siehe :py:meth:Actor.on_mouse_left_released.

Parameter:: position (tuple) – Aktuelle Mausposition als Tupel (x,y)
Verursacht:: NotImplementedOrRegisteredError – Der Fehler tritt auf, wenn die Methode nicht überschrieben oder registriert wird.

on_not_detecting_world()[Quellcode]#

on_detecting_world is called, when actor is on the world

Beispiele

Registrieren Sie die Methode on_detecting_world:

@player.register
    def on_detecting_world(self):
        print("Player 3: I'm on the world:")

Verursacht:: NotImplementedOrRegisteredError – Der Fehler tritt auf, wenn die Methode nicht überschrieben oder registriert wird.

on_shape_change()[Quellcode]#

property orientation: float#

property origin#

point_towards_actor(other)[Quellcode]#

Actor points towards another actor.

Rückgabetyp:: int
Parameter:: other – Der andere Actor
Rückgabe:: Die neue Richtung

point_towards_position(destination)[Quellcode]#

Actor points towards a given position

Rückgabetyp:: Union[int, float]
Parameter:: destination – Die Position, auf die der Actor zeigen sollte
Rückgabe:: Die neue Richtung

Beispiele

Zeige auf mouse_position:

def act(self):
    mouse = self.world.mouse.get_position()
if mouse:
    self.point_towards_position(mouse)
self.move()

property position: Tuple[float, float]#: Die Position des Actors als Position(x, y)

register_sensor(*args, **kwargs)[Quellcode]#: This method is used for the @register_sensor decorator.

remove(kill=True)[Quellcode]#

Entfernt diesen Actor aus der Welt

Examples: :rtype: defaultdict

Entfernt Roboter in thecrash.py :

def act(self):
    self.move()
    other = self.detecting_actor(distance = 0, actor_type=Robot)
if other:
    explosion = Explosion(position=self.position)
    self.remove()
    other.remove()

remove_costume(source=None)[Quellcode]#

Removes a costume from actor

Parameter:: source – Der Index des neuen Kostüms oder Kostüm-Objekts. Standardmäßig das aktuelle Kostüm

reset_costumes()[Quellcode]#

scale_height(value)[Quellcode]#

scale_width(value)[Quellcode]#

send_message(message)[Quellcode]#

Sends a message to world.

Die Nachricht kann mit dem on_message-Ereignis empfangen werden

Beispiele

Nachrichten senden und empfangen:

from miniworlds import *

world = World()

actor1 = Actor((2, 2))
actor1.add_costume((100,0,100,100))

@actor1.register
def on_message(self, message):
    print("Received message:" + message)

actor2 = Actor((100,100))
actor2.send_message("Hello from actor2")

@actor2.register
def on_key_down_s(self):
    self.send_message("Hello")
world.run()

Parameter:: message (str) – Eine Zeichenkette, die die Nachricht enthält.

set_background_color(color)[Quellcode]#

set_costume(costume)[Quellcode]#

set_direction(direction)[Quellcode]#

Actor points in given direction.

Sie können eine ganze Zahl oder einen String verwenden, um die Richtung zu beschreiben

Rückgabetyp:: float
Parameter:: string (The direction as integer or)

Optionen

0, "up" - Nachschlagen
90, "right", - Schau nach rechts
-90, "left", - Schau nach links
-180, 180, "down" - Schau nach unten

Beispiele

Bewege dich mit den WASD-Tasten in eine Richtung

def on_key_down(self, keys):
    if "W" in keys:
        self.direction = "up"
    elif "S" in keys:
        self.direction = "down"
    elif "A" in keys:
        self.direction = "left"
    elif "D" in keys:
        self.direction = "right"
    self.move()

set_position(value)[Quellcode]#

set_size(value)[Quellcode]#

set_world(new_world)[Quellcode]#

Rückgabetyp:: Actor

show()[Quellcode]#: Zeigt einen Actor an (ein unsichtbarer Actor wird sichtbar)

property size: tuple#: Größe des Actors

property static#: Should actor react to events? You can turn this option off for additional performance boost.

stop_animation()[Quellcode]#

Stoppt die aktuelle Animation. Das Kostüm is_animated wird auf False gesetzt

Beispiele

from miniworlds import *

world = World(columns=280, rows=100)
robo = Actor(position=(0, 0))
robo.costume.add_images(["images/1.png", "images/2.png","images/3.png","images/4.png"])
robo.size = (99, 99)
robo.animate_loop()
@timer(frames = 100)
def stop():
    robo.stop_animation()
world.run()

property stroke_color#

Randfarbe des Actors.

Die Randfarbe ist ein RGBA-Wert, zum Beispiel (255, 0, 0) für Rot, (0, 255, 0) für Grün und (255, 0, 0, 100).

Wenn der Farbwert 4 Werte hat, definiert der letzte Wert die Transparenz:

0: Voll transparent,
255: Keine Transparenz

Bemerkung

Sie müssen auch :py:attr:Actor.border auf einen Wert > 0 setzen

Aliase: :py:attr:Actor.stroke_color

Beispiele

Siehe :py:attr:Actor.border

switch_costume(source)[Quellcode]#

Switches the costume of actor

Rückgabetyp:: Costume
Parameter:: source – Anzahl der Kostüme oder Kostümobjekt

Beispiele

Ein Kostüm wechseln:

from miniworlds import *

world = World(100,60)
t = Actor()
costume =t1.add_costume("images/1.png")
t.add_costume("images/2.png")
t.switch_costume(1)

@timer(frames = 40)
def switch():
    t1.switch_costume(0)

world.run()

Rückgabe:: Das neue Kostüm

switch_origin(value)[Quellcode]#

property topleft: Tuple[float, float]#

property topleft_x: float#: x-Wert der oberen linken Position des Actors

property topleft_y: float#: x-Wert der oberen linken Position des Actors

turn_left(degrees=90)[Quellcode]#

Turns actor by degrees degrees left :rtype: int

Optionen:

Sie können den Wert actor.is_rotatable = False setzen, wenn Sie nicht möchten, dass der Actor gedreht wird.

Beispiele

from miniworlds import *

world = World(100, 100)
t = Actor()
t.add_costume("images/arrow.png")
t.size = (100,100)

@t.register
def act(self):
    t.turn_left(1)

world.run()

Ausgabe:

Parameter:: degrees – Grad in linker Richtung
Rückgabe:: Neue Richtung

turn_right(degrees=90)[Quellcode]#

Turns actor by degrees degrees right

Beispiele

from miniworlds import *

world = World(100, 100)
t = Actor()
t.add_costume("images/arrow.png")
t.size = (100,100)

@t.register
def act(self):
    t.turn_left(1)

world.run()

Ausgabe:

Optionen:

Sie können den Wert actor.is_rotatable = False setzen, wenn Sie nicht möchten, dass der Actor gedreht wird.

Parameter:: degrees – Grad in linker Richtung
Rückgabe:: Neue Richtung

undo_move()[Quellcode]#

Mache den letzten Zug rückgängig. Bewegt den Actor zur letzten Position und setzt die Richtung zurück.

Rückgabe:: Der bewegte Actor

Beispiele

zurückbewegen, wenn das Feld blockiert ist:

def on_detecting_wall(self, wall):
    self.undo_move()

property visible#: You can make this sprite disappear without removing it from the group assign 0 for invisible and 1 for visible

property width#

Die Breite des Actors in Pixeln.

Wenn die Breite eines Actors geändert wird, wird die Höhe proportional skaliert.

Beispiele

Erstellen Sie einen Actor und skalieren Sie die Breite/Höhe proportional:

from miniworlds import *

world = World(800,400)

def create_actor(x, y):
t = Actor()
t.position = (x, y)
t.add_costume("images/alien1.png")
t.border = 1
return t

t0 = create_actor(0,0)
t1 = create_actor(50,0)
t1.height = 400
t2 = create_actor(300,0)
t2.width = 180

world.run()

property world#

property x: float#: Der x-Wert eines Actors

property y: float#: Der y-Wert eines Actors