Come memorizzare il risultato di un metodo di

Question 1

Sto cercando di disegnare quadrati in posizioni random e casuale i valori rgb e voglio 1000 di loro per essere creato. Il problema che sto affrontando è che ogni volta che il ciclo per il disegno si verifica, si randomizza tutto di nuovo, c'è qualche modo per fare questo non accada

import pygame
import sys
import random
pygame.init()
win = pygame.display.set_mode((800,600))
pygame.display.set_caption("Simulation")

def safeZone():
        #Draws a top rectangle
    pygame.draw.rect(win, (50,205,50), (0, 0, 800, 100))
    
def dot():
    width = 10
    height = 10
    spawnX = random.randrange(1, 801)
    spawnY = random.randrange(1, 601)
    r = random.randrange(1, 256)
    g = random.randrange(1, 256)
    b = random.randrange(1, 256)
    pygame.draw.rect(win, (r, g, b), (spawnX, spawnY, width, height))

def population(size):
    for x in range(size):
        dot()

run = True
while run:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            run = False
    win.fill((255, 255, 255))
    safeZone() # Always draw dots after safe zone
    population(1000)
    pygame.display.update()

pygame.quit()

Question 2

Creare un punto di raccolta, quindi disegnare in quel punto di raccolta. Ora è possibile aggiornare la posizione dei punti separatamente, e saranno ridisegnare in nuove posizioni. Qui, sto avendo ogni punto spostare una quantità casuale in ogni ciclo.

import pygame
import sys
import random
pygame.init()
win = pygame.display.set_mode((800,600))
pygame.display.set_caption("Simulation")

class Dot:
    def __init__(self):
        self.spawnX = random.randrange(0, 800)
        self.spawnY = random.randrange(0, 600)
        self.r = random.randrange(0, 256)
        self.g = random.randrange(0, 256)
        self.b = random.randrange(0, 256)

def safeZone():
        #Draws a top rectangle
    pygame.draw.rect(win, (50,205,50), (0, 0, 800, 100))
    
def drawdot(dot):
    width = 10
    height = 10
    pygame.draw.rect(win, (dot.r, dot.g, dot.b), (dot.spawnX, dot.spawnY, width, height))

def population(dots):
    for dot in dots:
        dot.spawnX += random.randrange(-3,4)
        dot.spawnY += random.randrange(-3,4)
        drawdot(dot)

alldots = [Dot() for _ in range(1000)]

run = True
while run:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            run = False
    win.fill((255, 255, 255))
    safeZone() # Always draw dots after safe zone
    population(alldots)
    pygame.display.update()

Una pena di modifica è quello di memorizzare l'intero rettangolo in oggetto:

...
class Dot:
    def __init__(self):
        self.location = [
            random.randrange(0, 800),
            random.randrange(0, 600),
            10, 10
        ]
        self.color = (
            random.randrange(0, 256),
            random.randrange(0, 256),
            random.randrange(0, 256)
        )
    def move(self, dx, dy ):
        self.location[0] += dx
        self.location[1] += dy

def drawdot(dot):
    pygame.draw.rect(win, dot.color, dot.location)

def population(dots):
    for dot in dots:
        dot.move( random.randrange(-3,4), random.randrange(-3,4) )
        drawdot(dot)
...

Question 3

La chiamata di una funzione dot() in cui hai ricevuto la randomizzazione. Si dovrebbe introdurre un pezzo di codice che randomizza i valori al di fuori del dot() funzione, e li memorizza in un array separato, e quindi chiamare la funzione.

Question 4

La tua descrizione sembra che non necessariamente cercando di memorizzare il risultato tanto quanto si desidera che il processo di essere lo stesso ogni volta, ma ancora una sorta di casuale? Si potrebbe utilizzare un hard-coded seme?

import random
random.seed(10)
print(random.random())

Vedi questo link per maggiori dettagli: Random Seed

Tim Roberts · Answer 1 · 2021-11-22T19:39:00

Creare un punto di raccolta, quindi disegnare in quel punto di raccolta. Ora è possibile aggiornare la posizione dei punti separatamente, e saranno ridisegnare in nuove posizioni. Qui, sto avendo ogni punto spostare una quantità casuale in ogni ciclo.

import pygame
import sys
import random
pygame.init()
win = pygame.display.set_mode((800,600))
pygame.display.set_caption("Simulation")

class Dot:
    def __init__(self):
        self.spawnX = random.randrange(0, 800)
        self.spawnY = random.randrange(0, 600)
        self.r = random.randrange(0, 256)
        self.g = random.randrange(0, 256)
        self.b = random.randrange(0, 256)

def safeZone():
        #Draws a top rectangle
    pygame.draw.rect(win, (50,205,50), (0, 0, 800, 100))
    
def drawdot(dot):
    width = 10
    height = 10
    pygame.draw.rect(win, (dot.r, dot.g, dot.b), (dot.spawnX, dot.spawnY, width, height))

def population(dots):
    for dot in dots:
        dot.spawnX += random.randrange(-3,4)
        dot.spawnY += random.randrange(-3,4)
        drawdot(dot)

alldots = [Dot() for _ in range(1000)]

run = True
while run:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            run = False
    win.fill((255, 255, 255))
    safeZone() # Always draw dots after safe zone
    population(alldots)
    pygame.display.update()

Una pena di modifica è quello di memorizzare l'intero rettangolo in oggetto:

...
class Dot:
    def __init__(self):
        self.location = [
            random.randrange(0, 800),
            random.randrange(0, 600),
            10, 10
        ]
        self.color = (
            random.randrange(0, 256),
            random.randrange(0, 256),
            random.randrange(0, 256)
        )
    def move(self, dx, dy ):
        self.location[0] += dx
        self.location[1] += dy

def drawdot(dot):
    pygame.draw.rect(win, dot.color, dot.location)

def population(dots):
    for dot in dots:
        dot.move( random.randrange(-3,4), random.randrange(-3,4) )
        drawdot(dot)
...

La questione è di circa pygame. Quindi, si prega di utilizzare pygame.Rect. È inoltre possibile utilizzare pygame.Color.
Grazie per una risposta rapida, questo ha funzionato a meraviglia! Stavo cercando di capire come memorizzare tutte le loro posizioni separatamente, in modo da questo è stato molto bello
Risposta casuale.il seme è più elegante e semplice. È possibile utilizzare solo random seed invece di hard coded, che dà esattamente il comportamento desiderato.
Penso di capire, che cosa era una domanda circa. Mettere casuale.seme all'interno dot funzione di risolvere il problema. Nello stesso tempo, sono d'accordo, che questo non è ottimale in generale.

Anna D. · Answer 2 · 2021-11-22T19:33:27

0

La chiamata di una funzione dot() in cui hai ricevuto la randomizzazione. Si dovrebbe introdurre un pezzo di codice che randomizza i valori al di fuori del dot() funzione, e li memorizza in un array separato, e quindi chiamare la funzione.

Anna D.

2021-11-22 19:33:27

Una risposta corretta sarebbe di mostrare il codice a dimostrazione di come fare questo.

Tim Roberts

Penso che non ha senso per le cose semplici. Ma se questa è la regole della comunità -- " io tener conto di questo

Anna D.

Ricordate che l'idea è quella di creare un catalogo di risposte per i posteri. Non stiamo solo rispondendo ad una persona domanda, siamo in grado di offrire un servizio a lungo termine. Così, le risposte devono davvero essere il più completo possibile. Cose come il vostro contributo dovrebbe essere un commento.

Tim Roberts

Nate North · Answer 3 · 2021-11-22T19:39:52

0

La tua descrizione sembra che non necessariamente cercando di memorizzare il risultato tanto quanto si desidera che il processo di essere lo stesso ogni volta, ma ancora una sorta di casuale? Si potrebbe utilizzare un hard-coded seme?

import random
random.seed(10)
print(random.random())

Vedi questo link per maggiori dettagli: Random Seed

Nate North

2021-11-22 19:39:52

No, hai frainteso il problema. Lui non vuole che la stessa sequenza casuale ogni volta. Egli vuole che le posizioni randomizzati una VOLTA.

Tim Roberts

Questo è l'approccio migliore per risolvere problema originale. Si richiede solo una riga di codice e di introdurre anche alcuni risultati deterministici. Quale è l'approccio standard in tutti i giochi che utilizza la procedura generato mondi.

Zada Zorg

@ZadaZorg NON è l'approccio migliore. Hai frainteso il problema. Non ha gli stessi punti ogni volta che il gioco viene eseguito. Egli vuole un diverso insieme di posizioni, MA lui non li vuole cambiare in ogni ciclo. CHE è il problema di base. L'inizializzazione bisogno di essere in giro. Si sono ha risposto a una domanda che è stato chiesto.

Tim Roberts

Come memorizzare il risultato di un metodo di

Domanda

Migliore risposta

In altre lingue

Questa pagina è in altre lingue

Popolare in questa categoria

Domande popolari in questa categoria