Maus auf Bild Zentrieren

[Giben]

Hallo ich bin der neue hier:)
Da ich ja bedingt der aktuellen Situation ein bischen mehr Zeit habe als sonst, dachte ich mir ich tue endlich mal das was ich schon lange tun wollte und lerne Python.
Nun ein bischen weit bin ich schon gekommen.
Ich möchte mir gerne ein Moorhuhn-Clone programmieren.Habe es auch geschaff einezelne Sprites auf den Bildschirm zu bekommen unter anderem auch das Fadenkreuz.
Nun Habe ich folgendes Problem, dass der Mauszeiche NICHT genau in der Mitte vom Fadenkreuz ist.Wie kann ich das am besten bewerkstelligen.(Irgend wie mit RECT.CENTER)?
Bin schon länger am rumprobieren aber ich komme nicht drauf.Darum hoffe ich hier auf ein paar tolle Tips!
Bitte nicht lachen über mein Code ,ich bin wie gesagt noch blutiger Anfänger was Python angeht und ich versuche noch zu verstehen wie das mit den Klassen und Definitionen funktioniert.

https://github.com/Rolli73/Rolli73

Ich hoffe der Link passt so .sonst kopiere ich den Code hier rein.

Danke!

[__deets__]

Du musst bei sowas die Breite und Hoehe des Bildes durch 2 teilen und von der gewuenschten Position abziehen. Denn die linke obere Ecke muss ja weiter nach oben links verschoben werden. Beziehungsweise allgemein bezeichnet man den aktiven Punkt als Hotspot, der wird relativ zur linken oberen Ecke angegeben. Und dann eben wie gerade beschrieben vor dem zeichen abgezogen. Damit kann man zB auch Figuren die an den Fuessen bewegt werden sollen sauber definieren, oder bei Animationen bei denen das Zentrum von Frame zu Frame abweicht das angeben.

[Giben]

So,

Code: Alles auswählen

screen.blit(Fkreuz.bildname,(Fkreuz.x-(Fkreuz.rect.centerx),Fkreuz.y-(Fkreuz.rect.centery)))
    

Hat wunderbar geklappt, danke für den Tip!!

[__blackjack__]

@Giben: Die Zeile sieht sehr kompliziert aus. Normalerweise speichert man ein `Rect`-Objekt für die Position und nicht `x` und `y` getrennt, weil man bei einem `rect`-Objekt dann einfach das `center`-Attribut setzen kann, was dann so aussähe:

Code: Alles auswählen

            Fkreuz.rect.center = event.pos

Danach braucht man nichts mehr anzupassen.

Anmerkungen zum Quelltext: Es wird alles mögliche Importiert, aber nur `pygame` wird auch tatsächlich verwendet.

Auf Modulebene gehört nur Code der Konstanten, Funktionen, und Klassen definiert. Das Hauptprogramm steht üblicherweise in einer Funktion die `main()` heisst.

Namen werden in Python klein_mit_unterstrichen geschrieben. Ausnahmen sind Konstanten (KOMPLETT_GROSS) und Klassen (MixedCase). Namen sollten auch nicht kryptisch abgekürzt werden. Wenn man `fadenkreuz` meint, sollte man nicht `Fkreuz` schreiben.

`pos` wird definiert, dann aber überhaupt nicht verwendet weil die Information direkt auf dem `event`-Objekt vorhanden ist.

Die Kommentare sind alle überflüssig. Faustregel: Ein Kommentar beschreibt nicht *was* der Code tut, denn das steht da ja bereits als Code, sondern warum er das so tut. Sofern das nicht offentlichtlich ist. Zu offensichtlichen Sachen gehört auch was in der Dokumentation steht.

Bei der `figur`-Klasse ist das `bildname`-Attribut irreführend, weil inhaltlich falsch. Da wird kein Name von einem Bild dran gebunden, sondern ein Bild.

Die Klasse sieht ausserdem so aus als würdest Du `pygame.sprite.Sprite` selbst neu erfinden. Das gibt es schon, das Modul kann man bei einem Moorhuhn-Spiel super benutzen, das sollte man also nicht selbst nachbasteln.

Zwischenstand (ungetestet):

Code: Alles auswählen

#!/usr/bin/env python3
import pygame

SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
GRAU = (125, 125, 125)
WEISS = (255, 255, 255)

#
# FIXME Das sieht nach einer Neuerfindung des Rades `pygame.sprite.Sprite` aus.
#
class Figur:
    def __init__(self, x, y, bild_dateipfad):
        self.image = pygame.image.load(bild_dateipfad)
        self.rect = self.image.get_rect(center=(x, y))


def main():
    pygame.init()

    screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
    pygame.display.set_caption("MOORHUHN")
    clock = pygame.time.Clock()
    pygame.mouse.set_visible(True)
    hintergrund = pygame.image.load("Bilder/wiese.jpg")

    fadenkreuz = Figur(100, 100, "Bilder/Daco50x49.png")
    biene = Figur(50, 250, "Bilder/Biene.png")

    is_running = True
    while is_running:
        for event in pygame.event.get():
            if (
                event.type == pygame.QUIT
                or event.type == pygame.KEYDOWN
                and event.key == pygame.K_ESCAPE
            ):
                is_running = False
            if event.type == pygame.MOUSEMOTION:
                fadenkreuz.rect.center = event.pos
        #
        # TODO Deckt `hintergrund` nicht den gesamten `screen` ab? Dann wäre
        # das vorherige einfarbige füllen überflüssig.
        #
        screen.fill(GRAU)
        screen.blit(hintergrund, (0, 0))
        screen.blit(biene.image, biene.rect)
        screen.blit(fadenkreuz.image, fadenkreuz.rect)

        pygame.display.flip()
        clock.tick(60)

    pygame.quit()


if __name__ == "__main__":
    main()

[__blackjack__]

@Giben: Weiter zum Taschenrechner-Quelltext:

Es gelten weiterhin die allgemeinen Anmerkungen zum Mohrhun-Quelltext bezüglich Namensgebungen und so weiter.

`sys.exit()` sollte nur verwendet werden wenn man auch tatsächlich, mindestens potentiell, einen anderen Rückgabecode als 0 an den Aufrufer übermitteln will. Nicht einfach so nur weil man das Programm beenden will. In dem Fall sollte man den Programmablauf einfach zu seinem natürlichen Ende kommen lassen. Im vorliegenden Programm in dem man die Schleife mit ``break`` verlässt.

Bei den Funktionen für die Rechenarten braucht man das Ergebnis nicht an einen Namen binden wenn alles was man damit macht ist, den beim ``return`` zu verwenden. Allerdings braucht man diese Funktionen auch gar nicht selbst schreiben, denn die gibt es bereits fertig im `operator`-Modul.

Vergiss am besten gleich das es ``global`` gibt. Wenn eine Funktion ein Ergebnis hat, dann gibt man das per ``return`` an den Aufrufer zurück, und müllt damit nicht den Modulnamensraum zu.

Statt `choise` meintest Du sicher `choice`.

Beim Code für die Auswertung der Eingabe für die vier Rechenarten wiederholt sich der Code bis auf kleine Änderungen. Die Gemeinsamkeiten lassen sich in eine Funktion herausziehen, mit den Unterschieden als Parameter.

Feste, literale Zahlen in eine Zeichenkette formatieren macht wenig Sinn. Die 5 sollte auch nicht hart kodiert im Code stehen, sondern sich aus der Anzahl der Menüpunkte ergeben. Dazu kann man die in eine Liste stecken, deren Länge man abfragen kann.

Zwischenstand (ungetestet):

Code: Alles auswählen

#!/usr/bin/env python3
from operator import add, mul, sub, truediv


def eingabe():
    while True:
        try:
            a = int(input("1. Zahl: "))
            b = int(input("2. Zahl: "))
        except ValueError:
            print("Fehler: Zahl muss eine Ganzzahl sein!")
        else:
            return a, b


def rechenaufgabe_bearbeiten(rechenart, ergebnisbezeichnung, funktion):
    print(rechenart.upper())
    a, b = eingabe()
    ergebnis = funktion(a, b)
    print(
        f"\n{ergebnisbezeichnung.capitalize()}"
        f" von {a} und {b} ist {ergebnis}\n"
    )


def main():
    print("Taschenrechner 02.04.2020 By Roli\n")
    rechenarten = [
        "Addition",
        "Subtraktion",
        "Multiplikation",
        "Division",
    ]
    while True:
        for nummer, rechenoperation in enumerate(rechenarten):
            print(f"{nummer}. {rechenoperation}")
        print("0. EXIT")
        choice = int(input("Ihre Wahl? "))
        if choice == 0:
            print("\nAUF WIEDERSEHEN")
            break
        
        if choice == 1:
            rechenaufgabe_bearbeiten("Addition", "die Summe", add)
        elif choice == 2:
            rechenaufgabe_bearbeiten("Subtraktion", "die Differenz", sub)
        elif choice == 3:
            rechenaufgabe_bearbeiten("Multiplikation", "das Produkt", mul)
        elif choice == 4:
            rechenaufgabe_bearbeiten("Division", "der Quotient", truediv)
        else:
            print(
                f"Bitte nur Zahlen zwischen 0 und {len(rechenarten)} eingeben!"
            )


if __name__ == "__main__":
    main()

Die Wiederholung der Rechenartnamen ist hier noch unschön. Hier liessen sich die Informationen zu einer Rechenart schön zu einem Objekt zusammenfassen und statt der Namen in einer Liste ablegen (ungetestet):

Code: Alles auswählen

#!/usr/bin/env python3
from collections import namedtuple
from operator import add, mul, sub, truediv


Rechenart = namedtuple("Rechenart", "name ergebnisbezeichnung funktion")


def eingabe():
    while True:
        try:
            a = int(input("1. Zahl: "))
            b = int(input("2. Zahl: "))
        except ValueError:
            print("Fehler: Zahl muss eine Ganzzahl sein!")
        else:
            return a, b


def rechenaufgabe_bearbeiten(rechenart):
    print(rechenart.name.upper())
    a, b = eingabe()
    ergebnis = rechenart.funktion(a, b)
    print(
        f"\n{rechenart.ergebnisbezeichnung.capitalize()}"
        f" von {a} und {b} ist {ergebnis}\n"
    )


def main():
    print("Taschenrechner 02.04.2020 By Roli\n")
    rechenarten = [
        Rechenart("Addition", "die Summe", add),
        Rechenart("Subtraktion", "die Differenz", sub),
        Rechenart("Multiplikation", "das Produkt", mul),
        Rechenart("Division", "der Quotient", truediv),
    ]
    while True:
        for nummer, rechenart in enumerate(rechenarten, 1):
            print(f"{nummer}. {rechenart.name}")
        print("0. EXIT")
        choice = int(input("Ihre Wahl? "))
        if choice == 0:
            print("\nAUF WIEDERSEHEN")
            break

        if 1 <= choice < len(rechenarten):
            rechenaufgabe_bearbeiten(rechenarten[choice - 1])
        else:
            print(
                f"Bitte nur Zahlen zwischen 0 und {len(rechenarten)} eingeben!"
            )


if __name__ == "__main__":
    main()

[Giben]

Danke für deine Hilfe.
Ich werde es mir heute aben mal genauer anschauen.
Gibt es eigentlich eine Seite wo man nachschauen kann, wie die Pygame Befehle funktionieren?
Pygame.org schein ja down zu sein ...

[__blackjack__]

Seit fast zwei Wochen schon.

Naja, Github ist noch da und die Dokumentation gibt es ja auch in Quelltextform: https://github.com/pygame/pygame/tree/master/docs

Kann man wohl auch alles direkt aus dem Repository lesen wenn einen nicht stört, dass Links zwischen den Dokumenten nicht funktionieren.

Wie aufwändig das ist sich die Doku lokal zu generieren müsste man mal ausprobieren. Sieht grundsätzlich nach Sphinx aus, aber die integrieren das ja normalerweise so in ihre Homepage das man zu den einzelnen Abschnitten Kommentare abgeben kann.

[Giben]

So gleich noch ne Frage:)
Wieso wird das Program hier nicht beendet, wenn ich die Funktion "schiessen" aufrufe?
Print wird ausgegeben aber es wird nicht beendet.

Code: Alles auswählen

import pygame
from pygame.locals import *
import pygame_functions as pgf 
#from pygame_functions import *
Breite = 672
Hoehe  = 744
pgf.screenSize(Breite,Hoehe)
pgf.setBackgroundImage('bilder/wiese.jpg')
pygame.display.set_caption("Varroa Invaders")


class Figur:
    def __init__(self,name,x,y):
        self.name = name
        self.x = x
        self.y = y
        self.richtungx = 1
        self.richtungy = 0
    
    def anzeige(self):
        pgf.moveSprite(self.sprite, self.x ,self.y, centre=True)
        pgf.showSprite(self.sprite)
    
    def bewege(self):
        self.x += self.richtungx
        self.y += self.richtungy
      

class Fadenkreuz(Figur):
    def __init__(self,name,x,y):
        Figur.__init__(self,name,x,y)
        self.sprite = pgf.makeSprite('bilder/Daco50x49.png')
    
    def bewege_fadenkreuz(self):
        self.x = pgf.mouseX()
        self.y = pgf.mouseY()
    
    def schiessen(self):
        self.schuss = pgf.mousePressed()
        if self.schuss == True:
            print("Schuss")
            spielaktiv = False
           
            
       
def main():
    spielaktiv = True
    fadenkreuz = Fadenkreuz('rolli',100,200)
    print (fadenkreuz.name)
    pygame.init()
    while spielaktiv:
        for event in pygame.event.get():
            # Beenden bei [ESC] oder [X]
            if event.type==QUIT or (event.type==KEYDOWN and event.key==K_ESCAPE):
                spielaktiv = False
        #Figur.bewege(fadenkreuz)
        Figur.anzeige(fadenkreuz)
        Fadenkreuz.bewege_fadenkreuz(fadenkreuz)
        Fadenkreuz.schiessen(fadenkreuz)
        pgf.updateDisplay()
    pygame.quit()
if __name__ == "__main__":
    main()          

[Sirius3]

`spielaktiv` ist auch eine lokale Variable in `schiessen`, die nichs mit der lokalen Variable gleichen Namens in `main` zu tun hat. Du brauchst für `schiessen` einen Rückgabewert, der sagt, ob die Schleife in main beendet werden soll, oder nicht.

[Giben]

Kannst du mir sagen wie ich da vorgehen muss?
Ich komme einfach nicht darauf.

[Giben]

So geht es nicht.Was mache ich falsch?

Code: Alles auswählen

def schiessen(self,treffer):
        self.schuss = pgf.mousePressed()
        self.treffer = treffer
        print (treffer)
        if self.schuss == True :
            treffer = False
            print(treffer)
            return self.treffer
            
            
            
           
            
       
def main():
    spiel = int
    spielaktiv = True
    fadenkreuz = Fadenkreuz('rolli',100,200)
    print (fadenkreuz.name)
    pygame.init()
    while spielaktiv:
        for event in pygame.event.get():
            # Beenden bei [ESC] oder [X]
            if event.type==QUIT or (event.type==KEYDOWN and event.key==K_ESCAPE):
                spielaktiv = False
        #Figur.bewege(fadenkreuz)
        Figur.anzeige(fadenkreuz)
        Fadenkreuz.bewege_fadenkreuz(fadenkreuz)
        Fadenkreuz.schiessen(fadenkreuz,spielaktiv)

[Sirius3]

Methoden einer Klasse ruft man über ihre Instanz auf.

Code: Alles auswählen

fadenkreuz.anzeigen()
fadenkreuz.bewege_fadenkreuz()
treffer = fadenkreuz.schiessen()

Und dann mach irgend etwas mit der `treffer`-Information in der Hauptschleife.

Rückgabewert ist etwas anderes als Funktionsargument.

Code: Alles auswählen

    def schiessen(self):
       schuss = pgf.mousePressed()
        if schuss:
            print("Schuss")
            treffer = True
        else:
            treffer = False
        return treffer

Aber warum nutzt Du nicht event im Mausclicks abzufragen?

[Giben]

Danke!
Mir geht es darum, dass ich endlich einmal die Klassen und die Funktionen verstehe.
Aber das will mir nicht so recht in den Kopf

[Giben]

also ich hab das jetzt so gelöst..ob das so "richtig" ist

Code: Alles auswählen

class Fadenkreuz(Figur):
    def __init__(self,name,x,y):
        Figur.__init__(self,name,x,y)
        self.sprite = pgf.makeSprite('bilder/Daco50x49.png')
    
    def bewege_fadenkreuz(self):
        self.x = pgf.mouseX()
        self.y = pgf.mouseY()
    
    def schiessen(self,a):
        self.a = a
        self.schuss = pgf.mousePressed()
        self.ergebnis = True
        if self.schuss == True :
            self.ergebnis= False
            return self.ergebnis
        else:
            return self.ergebnis    

und rufe ich das mit :

Code: Alles auswählen

spielaktiv = (Fadenkreuz.schiessen(fadenkreuz,bool))

rufe ich das ganze auf.
Funktionieren tut`s

[__blackjack__]

@Giben: Deine Klasse `Figur` ist, wie ich ja schon mal geschrieben habe, so etwas wie `pygame.sprite.Sprite`. Jetzt verpasst Du dieser Klasse ein Attribut mit dem Namen `sprite`, das an ein Objekt gebunden wird das von `pygame.sprite.Sprite` abgeleitet ist. Das ist irgendwie schräg.

Diese ganze `pygame_functions`-API finde ich aber auch nicht gut. Nicht nur weil die sich so gar nicht an die Namenskonventionen hält, sondern auch weil die viel mit globalem Zustand arbeitet und beim Importieren schon Sachen mit starken Seiteneffekten macht bei denen viel schief laufen kann, sondern auch weil die Pygame's objektorientierte API hinter Funktionen versteckt. Teilweise IMHO ziemlich sinnlos mit Funktionen denen man ein Objekt übergibt und die dann einfach nur eine Methode auf dem Objekt aufrufen.

Code: Alles auswählen

def makeSprite(filename, frames=1):
    thisSprite = newSprite(filename, frames)
    return thisSprite


def addSpriteImage(sprite, image):
    sprite.addImage(image)


def changeSpriteImage(sprite, index):
    sprite.changeImage(index)

# oder

def playSound(sound, loops=0):
    sound.play(loops)


def stopSound(sound):
    sound.stop()

Wobei `newSprite` eine Klasse ist die von `pygame.sprites.Sprite` abgeleitet ist.

[Sirius3]

Was hast Du Dir bei dem ´a` gedacht und warum übergibst Du mit dem Argument einen Typ? Und warum machst Du dann nichts damit?

Man muß nicht alles an self binden und auch nicht explizit auf True prüfen:

Code: Alles auswählen

    def schiessen(self):
        schuss = pgf.mousePressed()
        ergebnis = True
        if schuss:
            ergebnis= False
        return ergebnis

Das kann man jetzt noch kürzer schreiben:

Code: Alles auswählen

    def schiessen(self):
        return not pgf.mousePressed()

[__blackjack__]

Noch mehr gruseliges in den `pygame_functions`, die `mousePressed()`-Funktion:

Code: Alles auswählen

def mousePressed():
    pygame.event.clear()
    mouseState = pygame.mouse.get_pressed()
    if mouseState[0]:
        return True
    else:
        return False

Mal von dem unnötigen ``if``/``else`` abgesehen, und dass die Pygame-Doku von der `get_pressed()`-Funktion abrät, löscht der `clear()`-Aufruf alle anstehenden Ereignisse. Man verliert also Ereignisse. Absichtlich. Das ist einfach nur kaputt. Das kann das drücken oder loslassen einer Taste sein, Mausbewegungen, Timer-Ereignisse, oder auch selbst definierte Ereignisse. Das kann man alles nicht mehr zuverlässig verwenden. Und `pygame.event.clear()` wird auch noch in ein paar anderen Funktionen in dem Modul aufgerufen.

Der Autor hat also nicht nur was gegen Python's Namenskonventionen, und Objektorientierung, sondern macht auch noch die Ereignisbehandlung kaputt, weil er offenbar den von Pygame/SDL dafür vorgesehenen Weg über eine Schleife die *alle* Ereignisse abarbeitet nicht nehmen will, und anscheinend die Konsequenzen nicht verstanden hat.

[Giben]

'a' war nur der verzweifelte Versuch irgend etwas zum laufen zu bekommen

Code: Alles auswählen

def schiessen(self):
        return not pgf.mousePressed()

kannst du mir das bitte genauer erklären, warum das so funktioniert?

Also sollte ich die Geschichte mit "Pygame:functions" lassen?
Jetzt bin ich verwirrt

[__blackjack__]

@Giben: Das ist einfach nur Dein Code vereinfacht. Fangen wir mal mit Deinem Code an:

Code: Alles auswählen

    def schiessen(self):
        schuss = pgf.mousePressed()
        ergebnis = True
        if schuss:
            ergebnis= False
        return ergebnis

Das ist unschön, weil es unregelmässig ist. Mit ``if``/``else`` sähe es so aus:

Code: Alles auswählen

    def schiessen(self):
        schuss = pgf.mousePressed()
        if schuss:
            ergebnis = False
        else:
            ergebnis = True
        return ergebnis

Wenn `schuss` wahr ist, dann ist das Ergebnis unwahr und umgekehrt. Das Ergebnis ist also genau die logische Umkehr/Negierung von `schuss`:

Code: Alles auswählen

    def schiessen(self):
        schuss = pgf.mousePressed()
        ergebnis = not schuss
        return ergebnis

Und der Rest ist dann einfach nur noch die Zwischenergebnisse nicht extra an Namen zu binden.

Ich würde die `pygame_functions` nicht verwenden.

[Giben]

ok hau weg Pygame_functions

Von vorne:

folgender Code mit den ich das Fadenkreuz mit der Maus steuern kann.Es funktioniert auch, aber warum 'hinkt' das Kreuz dem Maus zeiger nach?(ruckelt)

Code: Alles auswählen

import pygame
from pygame.locals import *

#from pygame_functions import *
BREITE = 800    
HOEHE  = 600
WEIS =(255,255,255)
FPS = 60
pygame.display.set_caption("Varroa Invaders")
clock = pygame.time.Clock()
fenster = pygame.display.set_mode([BREITE,HOEHE])
hintergrund = pygame.image.load("bilder/wiese.jpg")

class Player (pygame.sprite.Sprite):
    def __init__(self):
        super().__init__()
        self.image = pygame.image.load('Bilder/Daco50x49.png')
        self.rect = self.image.get_rect()
        #self.rect.center = (0,0)
    
    def update(self):
            for event in pygame.event.get():
                if event.type == pygame.MOUSEMOTION:
                    self.rect = event.pos
       
def main():
    spielaktiv = True
    spieler = Player()
    spritesall = pygame.sprite.Group(spieler)
   
    pygame.init()
    while spielaktiv:
        for event in pygame.event.get():
            if event.type==QUIT or (event.type==KEYDOWN and event.key==K_ESCAPE):
                spielaktiv = False
        
        fenster.blit(hintergrund,(0,0))
        spritesall.update()
        spritesall.draw(fenster)
        pygame.display.update()

        pygame.display.flip()
        clock.tick(FPS)
    pygame.quit()
if __name__ == "__main__":
    main()