Maus auf Bild Zentrieren
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!
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!
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.
So,
Hat wunderbar geklappt, danke für den Tip!!
Code: Alles auswählen
screen.blit(Fkreuz.bildname,(Fkreuz.x-(Fkreuz.rect.centerx),Fkreuz.y-(Fkreuz.rect.centery)))
- __blackjack__
- User
- Beiträge: 13070
- Registriert: Samstag 2. Juni 2018, 10:21
- Wohnort: 127.0.0.1
- Kontaktdaten:
@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:
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
Fkreuz.rect.center = event.pos
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()
„All religions are the same: religion is basically guilt, with different holidays.” — Cathy Ladman
- __blackjack__
- User
- Beiträge: 13070
- Registriert: Samstag 2. Juni 2018, 10:21
- Wohnort: 127.0.0.1
- Kontaktdaten:
@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):
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):
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()
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()
„All religions are the same: religion is basically guilt, with different holidays.” — Cathy Ladman
- __blackjack__
- User
- Beiträge: 13070
- Registriert: Samstag 2. Juni 2018, 10:21
- Wohnort: 127.0.0.1
- Kontaktdaten:
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.
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.
„All religions are the same: religion is basically guilt, with different holidays.” — Cathy Ladman
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.
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()
`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.
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)
Methoden einer Klasse ruft man über ihre Instanz auf.
Und dann mach irgend etwas mit der `treffer`-Information in der Hauptschleife.
Rückgabewert ist etwas anderes als Funktionsargument.
Aber warum nutzt Du nicht event im Mausclicks abzufragen?
Code: Alles auswählen
fadenkreuz.anzeigen()
fadenkreuz.bewege_fadenkreuz()
treffer = fadenkreuz.schiessen()
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
also ich hab das jetzt so gelöst..ob das so "richtig" ist
und rufe ich das mit :
rufe ich das ganze auf.
Funktionieren tut`s
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
Code: Alles auswählen
spielaktiv = (Fadenkreuz.schiessen(fadenkreuz,bool))
Funktionieren tut`s
- __blackjack__
- User
- Beiträge: 13070
- Registriert: Samstag 2. Juni 2018, 10:21
- Wohnort: 127.0.0.1
- Kontaktdaten:
@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.
Wobei `newSprite` eine Klasse ist die von `pygame.sprites.Sprite` abgeleitet ist.
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()
„All religions are the same: religion is basically guilt, with different holidays.” — Cathy Ladman
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:
Das kann man jetzt noch kürzer schreiben:
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
Code: Alles auswählen
def schiessen(self):
return not pgf.mousePressed()
- __blackjack__
- User
- Beiträge: 13070
- Registriert: Samstag 2. Juni 2018, 10:21
- Wohnort: 127.0.0.1
- Kontaktdaten:
Noch mehr gruseliges in den `pygame_functions`, die `mousePressed()`-Funktion:
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.
Code: Alles auswählen
def mousePressed():
pygame.event.clear()
mouseState = pygame.mouse.get_pressed()
if mouseState[0]:
return True
else:
return False
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.
„All religions are the same: religion is basically guilt, with different holidays.” — Cathy Ladman
'a' war nur der verzweifelte Versuch irgend etwas zum laufen zu bekommen
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
Code: Alles auswählen
def schiessen(self):
return not pgf.mousePressed()
Also sollte ich die Geschichte mit "Pygame:functions" lassen?
Jetzt bin ich verwirrt
- __blackjack__
- User
- Beiträge: 13070
- Registriert: Samstag 2. Juni 2018, 10:21
- Wohnort: 127.0.0.1
- Kontaktdaten:
@Giben: Das ist einfach nur Dein Code vereinfacht. Fangen wir mal mit Deinem Code an:
Das ist unschön, weil es unregelmässig ist. Mit ``if``/``else`` sähe es so aus:
Wenn `schuss` wahr ist, dann ist das Ergebnis unwahr und umgekehrt. Das Ergebnis ist also genau die logische Umkehr/Negierung von `schuss`:
Und der Rest ist dann einfach nur noch die Zwischenergebnisse nicht extra an Namen zu binden.
Ich würde die `pygame_functions` nicht verwenden.
Code: Alles auswählen
def schiessen(self):
schuss = pgf.mousePressed()
ergebnis = True
if schuss:
ergebnis= False
return ergebnis
Code: Alles auswählen
def schiessen(self):
schuss = pgf.mousePressed()
if schuss:
ergebnis = False
else:
ergebnis = True
return ergebnis
Code: Alles auswählen
def schiessen(self):
schuss = pgf.mousePressed()
ergebnis = not schuss
return ergebnis
Ich würde die `pygame_functions` nicht verwenden.
„All religions are the same: religion is basically guilt, with different holidays.” — Cathy Ladman
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)
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()