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 Akteur 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 Akteur an der aktuellen Mausposition:

from miniworlds import *

world = World()

@world.register
def act(self):
    Actor(self.get_mouse_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`	Ein Actor mit der Eigenschaft `is_blockable` kann sich nicht durch Actor mit der Eigenschaft `is_blocking` bewegen.
`is_blocking`	Ein Actor mit der Eigenschaft `is_blockable` kann sich nicht durch Actor mit der Eigenschaft `is_blocking` bewegen.
`layer`	Definiert die Ebene, auf der der Akteur gezeichnet wird, wenn mehrere Akteure überlappen.
`last_position`	Akteurposition im letzten Frame
`last_direction`
`costume_count`	Gibt die Anzahl der Kostüme des Actors zurück, 0 wenn der Actor kein Kostüm hat
`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`	Richtungen werden genau wie in der Scratch-Programmiersprache behandelt, siehe: `Scratch Wiki <https://en.scratch-wiki.info/wiki/Direction_(value)>`_
`direction_at_unit_circle`	Erhält die Richtung als Wert im Einheitskreis (0° rechts, 90° oben, 180° links…)
`dirty`	Wenn der Akteur dirty ist, wird er neu gezeichnet.
`size`	Größe des Actors
`width`	Die Breite des Akteurs in Pixeln.
`height`	Die Höhe des Actors in Pixeln.
`x`	Der x-Wert eines Akteurs
`y`	Der y-Wert eines Akteurs
`class_name`
`topleft_x`	x-Wert der oberen linken Position des Akteurs
`topleft_y`	x-Wert der oberen linken Position des Akteurs
`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`	Sollte der Akteur auf Ereignisse reagieren? Sie können diese Option deaktivieren, um die Leistung weiter zu steigern.
`fill_color`	Die Füllfarbe des Akteurs als RGBA-Wert, z.B. (255, 0, 0) für Rot.
`color`	Die Füllfarbe des Akteurs als RGBA-Wert, z.B. (255, 0, 0) für Rot.
`is_filled`	Ist der Actor mit Farbe gefüllt?
`border_color`	Randfarbe des Akteurs.
`stroke_color`	Randfarbe des Akteurs.
`border`	Die Randgröße des Akteurs.
`visible`	Sie können diesen Sprite verschwinden lassen, ohne ihn aus der Gruppe zu entfernen, indem Sie 0 für unsichtbar und 1 für sichtbar zuweisen
`rect`	Das umgebende Rechteck als pygame.Rect.
`world`
`image`	Das Bild des Actors:
`position_manager`
`sensor_manager`
`costume_manager`
`position`	Die Position des Actors als Position(x, y)
`actor_id`
`speed`

Inherited from DirtySprite

`visible`	Sie können diesen Sprite verschwinden lassen, ohne ihn aus der Gruppe zu entfernen, indem Sie 0 für unsichtbar und 1 für sichtbar zuweisen
`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`	Dynamische, schreibgeschützte Eigenschaft für das geschützte Attribut _layer.

Öffentliche Methoden:

`__init__`([position])
`switch_origin`(value)
`create_on_world`(world)	Erstellt einen Akteur für eine bestimmte Welt
`from_topleft`(topleft_position, args, *kwargs)	Erstellt einen Akteur mit dem Zentrum bei center_position
`from_center`(center_position, args, *kwargs)	Erstellt einen Akteur mit dem Zentrum bei center_position
`flip_x`()	Dreht den Akteur um 180° Grad.
`add_costume`([source])	Fügt einem Darsteller ein neues Kostüm hinzu.
`add_costumes`(sources)	Fügt mehrere Kostüme hinzu
`remove_costume`([source])	Entfernt ein Kostüm vom Actor
`switch_costume`(source)	Wechselt das Kostüm des Actors
`set_costume`(costume)
`reset_costumes`()
`set_background_color`(color)
`next_costume`()	Wechselt zum nächsten Kostüm des Actors
`has_costume`()
:py:obj:`turn_left <miniworlds.actors.actor.Actor.turn_left>`\ ([Grad])	Turns actor by degrees degrees left :rtype: `int`
:py:obj:`turn_right <miniworlds.actors.actor.Actor.turn_right>`\ ([Grad])	Dreht den Akteur um degrees Grad nach rechts
:py:obj:`set_direction <miniworlds.actors.actor.Actor.set_direction>`\ (Richtung)	Der Actor zeigt in die angegebene Richtung.
`point_towards_position`(destination)	Der Actor zeigt auf eine bestimmte Position
`point_towards_actor`(other)	Der Actor zeigt auf einen anderen Actor.
`set_size`(value)
`scale_width`(value)
`scale_height`(value)
`move`([distance, direction])	Bewegt den Akteur distance Schritte in die aktuelle Richtung
:py:obj:`move_vector <miniworlds.actors.actor.Actor.move_vector>`\ (Vektor)	Bewegt den Akteur in die durch den Vektor definierte Richtung
:py:obj:`move_back <miniworlds.actors.actor.Actor.move_back>`\ (Entfernung)
`undo_move`()	Mache den letzten Zug rückgängig.
`move_towards`(target)
:py:obj:`move_in_direction <miniworlds.actors.actor.Actor.move_in_direction>`\ (Richtung[, distance])	Bewegt den Akteur distance Schritte in eine direction oder zu einer Position
`move_to`(position)	Bewegt den Akteur distance zu einer bestimmten Weltposition
`remove`([kill])	Entfernt diesen Akteur aus der Welt
`before_remove`()
`bounce_from_border`(borders)	Der Actor “prallt” von einem Rand ab.
:py:obj:`detect_all <miniworlds.actors.actor.Actor.detect_all>`\ ([Akteure, Richtung, distance])	Erkennt, ob sich Akteure an der Akteurposition befinden.
`detect`(args, *kwargs)	Erkennt, ob sich Akteure an der Akteurposition befinden.
`detect_borders`([distance])	Erkennt Grenzen
`detect_left_border`()	Berührt der Actor den linken Rand?
`detect_right_border`()	Berührt der Actor den rechten Rand?
`detect_top_border`()	Berührt der Actor den unteren Rand?
`detecting_bottom_border`()	Berührt der Actor den unteren Rand?
:py:obj:`detect_color <miniworlds.actors.actor.Actor.detect_color>`\ ([Farbe])	Erkennt Farben im Welt-Hintergrund an der Actor-Mittelposition
:py:obj:`detect_color_at <miniworlds.actors.actor.Actor.detect_color_at>`\ ([direction, Entfernung])	Erkennt Farben im Welt-Hintergrund an der Actorposition
:py:obj:`detect_actors_at <miniworlds.actors.actor.Actor.detect_actors_at>`\ ([direction, Entfernung, Akteure])	Erkennt einen Akteur in der angegebenen Richtung und Entfernung.
:py:obj:`detect_actor_at <miniworlds.actors.actor.Actor.detect_actor_at>`\ ([Richtung, Entfernung, Actor])
:py:obj:`detect_actors_in_front <miniworlds.actors.actor.Actor.detect_actors_in_front>`\ ([Akteure, distance])
:py:obj:`detect_actor_in_front <miniworlds.actors.actor.Actor.detect_actor_in_front>`\ ([Akteure, distance])
`detect_point`(position)	Kollidiert der Actor mit einem bestimmten (globalen) Punkt?
`detect_pixel`(position)	Kollidiert der Actor mit einem Pixel?
`detect_rect`(rect)	Kollidiert der Actor mit einem statischen Rechteck?
`is_inside_world`()	Is the actor colliding with current ....
`bounce_from_actor`(other)
`animate`([speed])
:py:obj:`animate_costume <miniworlds.actors.actor.Actor.animate_costume>`\ (Kostüm[, speed])
`animate_loop`([speed])	Animiert ein Kostüm mit einer Schleifenanimation
`stop_animation`()	Stoppt die aktuelle Animation.
:py:obj:`send_message <miniworlds.actors.actor.Actor.send_message>`\ (Nachricht)	Sendet eine Nachricht an die World.
`on_key_down`(key)	on_key_down wird einmal aufgerufen, wenn eine Taste gedrückt wird.
`on_key_pressed`(key)	on_key_pressed wird aufgerufen, während eine Taste gedrückt wird.
`on_key_up`(key)
`on_mouse_over`(position)	on_mouse_over wird aufgerufen, wenn die Maus über den Akteur bewegt wird :type position: :param position: Die Mausposition
`on_mouse_leave`(position)	on_mouse_over wird aufgerufen, wenn die Maus über den Akteur 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 wird aufgerufen, wenn die linke Maustaste gedrückt wurde.
`on_mouse_right`(position)	Die Methode wird aufgerufen, wenn die rechte Maustaste gedrückt wurde.
`on_mouse_motion`(position)	Die Methode wird aufgerufen, wenn die Maus bewegt wird.
`on_mouse_left_released`(position)	Methode wird aufgerufen, wenn die linke Maustaste losgelassen wird.
`on_mouse_right_released`(position)	Methode wird aufgerufen, wenn die rechte Maustaste losgelassen wird.
`on_clicked_left`(position)	Die Maus befindet sich auf einem Actor und die Maus wurde geklickt.
`on_clicked_right`(position)	Die Maus befindet sich auf einem Actor und die Maus wurde geklickt.
`on_detecting_world`()	`on_detecting_world` wird aufgerufen, wenn der Akteur in der Welt ist
`on_not_detecting_world`()	`on_detecting_world` wird aufgerufen, wenn der Akteur in der Welt ist
`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 Akteur 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)
:py:obj:`register <miniworlds.actors.actor.Actor.register>`\ (Methode[, erzwingen, Name])	Diese Methode wird für den @register-Dekorator verwendet.
`register_message`(args, *kwargs)	Registriert eine Methode bei einem Objekt, um bestimmte `on_message`-Ereignisse zu bearbeiten.
`register_sensor`(args, *kwargs)	Diese Methode wird für den @register_sensor Dekorator verwendet.
`get_local_rect`()
`__str__`()	Gib str(self) zurück.
`set_world`(new_world)
`new_costume`()
`get_costume_class`()
`set_position`(value)
`get_distance_to`(obj)	Ermittelt die Entfernung zu einem anderen Akteur oder einer Position
`on_shape_change`()

Inherited from DirtySprite

`__init__`(*groups)
`__repr__`()	Gib repr(self) zurück.

Inherited from Sprite

`__init__`(*groups)
:py:obj:`add <miniworlds.actors.actor.pygame.sprite.Sprite.add>`\ (*Gruppen)	füge den Sprite zu Gruppen hinzu
:py:obj:`remove <miniworlds.actors.actor.pygame.sprite.Sprite.remove>`\ (*Gruppen)	entferne den Sprite aus den Gruppen
`add_internal`(group)	Um diesen Sprite intern zu einer Gruppe hinzuzufügen.
`remove_internal`(group)	Um diesen Sprite intern aus einer Gruppe zu entfernen.
`update`(args, *kwargs)	Methode zur Steuerung des Verhaltens von Sprites
`kill`()	entferne den Sprite aus allen Gruppen
:py:obj:`Gruppen <miniworlds.actors.actor.pygame.sprite.Sprite.groups>`\ ()	Liste der Gruppen, die diesen Sprite enthalten
`alive`()	gehört der Sprite zu irgendwelchen Gruppen
`__repr__`()	Gib repr(self) zurück.

Private Datenattribute:

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

Private Methoden:

`_validate_arguments`(position, args, *kwargs)
`_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`()	den sichtbaren Wert dieses Sprites zurückgeben

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]#

Fügt mehrere Kostüme hinzu

Rückgabetyp:: Costume

animate(speed=10)[Quellcode]#

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

animate_loop(speed=10)[Quellcode]#

Animiert ein Kostüm mit einer Schleifenanimation

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 Akteurs.

Der Wert ist 0, wenn der Akteur 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 Akteurs 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 Akteurs.

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]#

Der Actor “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 Akteure auf derselben Kachel? (nur TiledWorld)
rect: Kollidieren die Akteure beim Überprüfen ihrer Begrenzungsrahmen? (Nur PixelWorld)
static-rect: Kollidieren Akteure beim Überprüfen eines Kreises mit Radius = Begrenzungsrahmenradius. (Nur PixelWorld)
circle: Kollidieren Akteure beim Überprüfen des Kreises mit Radius = Begrenzungsrahmenradius. (Nur PixelWorld)
mask: Überprüfen die Akteure, ob ihre Bildmasken sich überschneiden, wenn sie kollidieren.

property color#

Die Füllfarbe des Akteurs 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#

Gibt die Anzahl der Kostüme des Actors zurück, 0 wenn der Actor kein Kostüm hat

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 costume_manager#

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]#

Erstellt einen Akteur für eine bestimmte Welt

in Unterklassen überschrieben

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

Erkennt, ob sich Akteure an der Position eines Akteurs befinden. Gibt den zuerst gefundenen Akteur 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 Akteure 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]#

Erkennt einen Akteur in der angegebenen Richtung und Entfernung.

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 Akteure 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 Akteure an der Position eines Akteurs befinden. Gibt eine Liste von Akteuren 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 Akteure erkannt werden sollten (Startpunkt ist actor.center)

Rückgabe:

Alle von Sensor gefundenen Akteure

detect_borders(distance=0)[Quellcode]#

Erkennt Grenzen

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]#

Erkennt Farben im Welt-Hintergrund an der Actor-Mittelposition

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

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

Erkennt Farben im Welt-Hintergrund an der Actorposition

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]#

Berührt der Actor den linken Rand?

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

detect_pixel(position)[Quellcode]#

Kollidiert der Actor mit einem Pixel?

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

detect_point(position)[Quellcode]#

Kollidiert der Actor mit einem bestimmten (globalen) Punkt?

Rückgabetyp:: bool

Warnung

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

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

detect_rect(rect)[Quellcode]#: Kollidiert der Actor mit einem statischen Rechteck?

detect_right_border()[Quellcode]#

Berührt der Actor den rechten Rand?

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

detect_top_border()[Quellcode]#

Berührt der Actor den unteren Rand?

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

detecting_bottom_border()[Quellcode]#

Berührt der Actor den unteren Rand?

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

property direction: int#

Richtungen werden genau wie in der Scratch-Programmiersprache behandelt, siehe: Scratch Wiki <https://en.scratch-wiki.info/wiki/Direction_(value)>_

Die Standardrichtung ist 0°. Alle Akteure 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 Akteurs 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…)

property dirty: int#

Wenn der Akteur dirty ist, wird er neu gezeichnet.

Rückgabe:: 1, wenn der Akteur schmutzig ist/0 andernfalls
Rückgabetyp:: int

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

property fill_color#

Die Füllfarbe des Akteurs 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]#

Erstellt einen Akteur mit dem Zentrum bei center_position

Arg`s:: center_position: Mittelpunkt des Akteurs

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

Erstellt einen Akteur mit dem Zentrum bei center_position

Arg`s:: center_position: Mittelpunkt des Akteurs

get_costume_class()[Quellcode]#

Rückgabetyp:: type[costume_mod.Costume]

get_distance_to(obj)[Quellcode]#

Ermittelt die Entfernung zu einem anderen Akteur oder einer Position

Rückgabetyp:: float
Parameter:: obj – Actor oder Position
Rückgabe:: Der Abstand zwischen dem Akteur (gemessen von actor.center) zum Akteur 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 Akteur 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#: Ein Actor mit der Eigenschaft is_blockable kann sich nicht durch Actor mit der Eigenschaft is_blocking bewegen.

property is_blocking#: Ein Actor mit der Eigenschaft is_blockable kann sich nicht durch Actor mit der Eigenschaft is_blocking bewegen.

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 Akteur 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 Akteur

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]#

Akteurposition im letzten Frame

Kann verwendet werden, um Änderungen zu verfolgen.

property layer: int#: Definiert die Ebene, auf der der Akteur gezeichnet wird, wenn mehrere Akteure überlappen.

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

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

Bewegt den Akteur distance Schritte in die aktuelle Richtung

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

Beispiele

wenn der Akteur 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 Akteur 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 Akteur.

Rückgabe:

Der Actor selbst

move_to(position)[Quellcode]#

Bewegt den Akteur distance zu einer bestimmten Weltposition

Parameter:

position – Die Position, zu der sich der Akteur 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]#

Bewegt den Akteur in die durch den Vektor definierte Richtung

Rückgabe:: Der bewegte Actor

new_costume()[Quellcode]#

next_costume()[Quellcode]#

Wechselt zum nächsten Kostüm des Actors

Rückgabe:: Das neue Kostüm

on_clicked_left(position)[Quellcode]#

Die Maus befindet sich auf einem Actor und die Maus wurde geklickt.

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]#

Die Maus befindet sich auf einem Actor und die Maus wurde geklickt.

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 Akteur 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 wird aufgerufen, wenn der Akteur in der Welt ist

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 wird einmal aufgerufen, wenn eine Taste gedrückt wird.

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 Akteur 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 Akteurs in Zusammenhang steht.

Sie können :py:meth:Actor.detect_pixel verwenden, um zu überprüfen, ob sich die mouse_position innerhalb des Akteurs 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]#

Methode wird aufgerufen, wenn die linke Maustaste losgelassen wird.

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 Akteurs in Zusammenhang steht.

Sie können :py:meth:Actor.detect_pixel verwenden, um zu überprüfen, ob sich die mouse_position innerhalb des Akteurs 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 Akteur 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 Akteurs in Zusammenhang steht.

Sie können :py:meth:Actor.detect_pixel verwenden, um zu überprüfen, ob sich die mouse_position innerhalb des Akteurs 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 wird aufgerufen, wenn der Akteur in der Welt ist

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]#

Der Actor zeigt auf einen anderen Actor.

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

point_towards_position(destination)[Quellcode]#

Der Actor zeigt auf eine bestimmte 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.get_mouse_position()
if mouse:
    self.point_towards_position(mouse)
self.move()

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

property position_manager#

property rect: Rect#: Das umgebende Rechteck als pygame.Rect. Die Rechteckkoordinaten beschreiben die lokalen Koordinaten und hängen von der Kameraperspektive ab.

Warnung

Wenn der Actor gedreht wird, sind die Eckpunkte des Rechtecks nicht die Eckpunkte des Actorbildes.

register(method, force=False, name=None)[Quellcode]#

Diese Methode wird für den @register-Dekorator verwendet. Sie fügt einem Objekt eine Methode hinzu

Parameter:

method (callable) – Die Methode, die dem Akteur hinzugefügt werden sollte
force – Sollte erzwungen registriert werden, auch wenn die Methode kein gültiges Ereignis verarbeitet?
name – Registriert Methode mit spezifischem Namen

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

Registriert eine Methode bei einem Objekt, um bestimmte on_message-Ereignisse zu bearbeiten.

Dieser Dekorator verknüpft eine Methode mit einer bestimmten Ereignisnachricht und löst sie automatisch aus, wenn die vorgesehene Nachricht empfangen wird.

Beispiele

Beispiel von zwei Actorn, die kommunizieren.

# Registering a method to trigger on a key-down event
@player1.register_message("on_key_down")
def on_key_down(self, keys):
    if 'a' in keys:
        self.move()
        self.send_message("p1moved")

# Registering a method to respond to the "p1moved" message
@player2.register_message("p1moved")
def follow(self, data):
    print(move_towards(player1))

Parameter:: message (str) – Das spezifische Nachrichtenereignis, auf das diese Methode reagieren wird.

register_sensor(*args, **kwargs)[Quellcode]#: Diese Methode wird für den @register_sensor Dekorator verwendet.

remove(kill=True)[Quellcode]#

Entfernt diesen Akteur 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]#

Entfernt ein Kostüm vom 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]#

Sendet eine Nachricht an die 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.

property sensor_manager#

set_background_color(color)[Quellcode]#

set_costume(costume)[Quellcode]#

set_direction(direction)[Quellcode]#

Der Actor zeigt in die angegebene Richtung.

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#: Sollte der Akteur auf Ereignisse reagieren? Sie können diese Option deaktivieren, um die Leistung weiter zu steigern.

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 Akteurs.

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]#

Wechselt das Kostüm des Actors

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 Akteurs

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

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 Akteur 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]#

Dreht den Akteur um degrees Grad nach rechts

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 Akteur gedreht wird.

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

undo_move()[Quellcode]#

Mache den letzten Zug rückgängig. Bewegt den Akteur 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#: Sie können diesen Sprite verschwinden lassen, ohne ihn aus der Gruppe zu entfernen, indem Sie 0 für unsichtbar und 1 für sichtbar zuweisen

property width#

Die Breite des Akteurs in Pixeln.

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

Beispiele

Erstellen Sie einen Akteur 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 Akteurs

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