Voila contrairement à mon premier post celui si je prendrait le temps de  bien lire .

Donc j'ai une petite question , je fait en se moment un espèce de  minecraft en 2D pour l'instant je ne travaille que sur la génération du monde.

Dans mon code il y a des images qui sont charger au début (Les Texture) ensuite je leur donne des coordonnées de départ puis je leur applique un

random.randrange(380,500,40) #Sa c'est pour la terre et le 40 c'est la taille de la texture 40x40

ensuite pour ce qui est de charger les textures

#load texture
#block
darksoulinteblock = pygame.image.load("texture/darksoulinte.png")
glicentoneblock = pygame.image.load("texture/glicentone.png")
armaniteblock = pygame.image.load("texture/armanite.png")
grassblock = pygame.image.load("texture/grass.png")
stoneblock = pygame.image.load("texture/stone.png")
sandblock = pygame.image.load("texture/sand.png")
#special
cielstatic = pygame.image.load("texture/ciel.png")
waterstatic = pygame.image.load("texture/water.png")
print("texture charger")

Voila je voudrait savoir si il était possible de faire que en dessous de  la terre Python mette de la pierre sans encore mettre des coordonnée .

Merci , cette fois je prendrait le temps de bien lire et examiner vos reponsse

Bonjour

La question n'est pas trèsclaire..

Peux-tu préciser ? et nous montrer un peu + de code ?

Parce que "pour que python mette de la pierre...".......

Python ne fait rien tout seul, c'est toi qui fait via ton code.

Si je comprends (pas sûr...) tu veux appliquer aléatoirement à une carte différentes textures et tu voudrais que "sous" la texture "terre" il y ait une texture de base "pierre" ??

P.S : une espèce / des images sont chargées / je prendrai / je fais / je voudrais / réponses

En fait je voudrait que en dessous la terre que l'on a généré aléatoirement il y ais de la pierre dans le code "stoneblock" .

pour mon code le voici

import random
import os


pygame.display.init()
windows = width , height = 800, 600
screen = pygame.display.set_mode((800 , 600))  




tex = False
#load texture
#block
darksoulinteblock = pygame.image.load("texture/darksoulinte.png")
glicentoneblock = pygame.image.load("texture/glicentone.png")
armaniteblock = pygame.image.load("texture/armanite.png")
grassblock = pygame.image.load("texture/grass.png")
stoneblock = pygame.image.load("texture/stone.png")
sandblock = pygame.image.load("texture/sand.png")
#special
cielstatic = pygame.image.load("texture/ciel.png")
waterstatic = pygame.image.load("texture/water.png")
print("texture charger")
#generation based
a  = random.randrange(380,500,40)
b  = random.randrange(380,500,40)
c  = random.randrange(380,500,40)
d  = random.randrange(380,500,40)
e  = random.randrange(380,500,40)
f  = random.randrange(380,500,40)



#map
#static
screen.blit(cielstatic,(0,0))
screen.blit(waterstatic, (520,500))
screen.blit(waterstatic, (560,500))
screen.blit(waterstatic, (600,500))
#block
#grass
screen.blit(grassblock, (0,a)) #1
screen.blit(grassblock, (40,b)) #2
screen.blit(grassblock, (80,c)) #3
screen.blit(grassblock, (120,d)) #4
screen.blit(grassblock, (160,e)) #5
screen.blit(grassblock, (200,e)) #6
screen.blit(grassblock, (240,a)) #7
screen.blit(grassblock, (280,b)) #8
screen.blit(grassblock, (320,420)) #9
screen.blit(grassblock, (360,500)) #10
screen.blit(grassblock, (400,540)) #11
screen.blit(grassblock, (440,540)) #12
screen.blit(grassblock, (680,500))
screen.blit(grassblock, (720,460))
screen.blit(grassblock, (760,300))

#stone
#sol
screen.blit(stoneblock, (0,580))
screen.blit(stoneblock, (40,580))
screen.blit(stoneblock, (80,580))
screen.blit(stoneblock, (120,580))
screen.blit(stoneblock, (160,580))
screen.blit(stoneblock, (200,580))
screen.blit(stoneblock, (240,580))
screen.blit(glicentoneblock, (240,580))
screen.blit(stoneblock, (280,580))
screen.blit(stoneblock, (280,580))
screen.blit(stoneblock, (320,580))
screen.blit(stoneblock, (320,580))
screen.blit(stoneblock, (320,580))
screen.blit(stoneblock, (360,580))
screen.blit(stoneblock, (380,580))
screen.blit(stoneblock, (420,580))
screen.blit(stoneblock, (460,580))
screen.blit(stoneblock, (500,580))
screen.blit(stoneblock, (540,580))
screen.blit(stoneblock, (580,580))
screen.blit(stoneblock, (620,580))
screen.blit(stoneblock, (660,580))
screen.blit(stoneblock, (700,580))
screen.blit(stoneblock, (740,580))
screen.blit(stoneblock, (780,580))
screen.blit(stoneblock, (820,580))
screen.blit(stoneblock, (480,540))
screen.blit(stoneblock, (640,540))
screen.blit(stoneblock, (680,540))
screen.blit(stoneblock, (720,540))
screen.blit(stoneblock, (720,500))
screen.blit(stoneblock, (760,500))
screen.blit(stoneblock, (760,460))
screen.blit(stoneblock, (760,420))
screen.blit(stoneblock, (760,380))
screen.blit(stoneblock, (760,340))
#sand
screen.blit(sandblock, (520,540))
screen.blit(sandblock, (560,540))
screen.blit(sandblock, (600,540))
screen.blit(sandblock, (480,500))
screen.blit(sandblock, (640,500))

#view
screen.blit(stoneblock, (0,540))
screen.blit(stoneblock, (40,540))
screen.blit(stoneblock, (80,540))
screen.blit(stoneblock, (120,540))
screen.blit(stoneblock, (160,540))
screen.blit(stoneblock, (200,540))
screen.blit(stoneblock, (240,540))
screen.blit(armaniteblock, (240,500))
screen.blit(stoneblock, (280,540))
screen.blit(stoneblock, (280,500))
screen.blit(stoneblock, (320,540))
screen.blit(stoneblock, (320,500))
screen.blit(stoneblock, (320,460))
screen.blit(stoneblock, (360,540))
print("map charger")
print(a)
print(b)
print(c)
print(d)
print(e)
print(f)







tex = True
pygame.display.flip()


if tex == True:
    print("Jeux Charger avec succes ! ")

continuer = True
while(continuer): 
        for event in pygame.event.get(): 
                if(event.type==pygame.QUIT or (event.type==pygame.KEYDOWN and event.key==pygame.K_ESCAPE)):
                        continuer=False
                        
pygame.quit()

Voila

En gros je voudrait que se soit généré aléatoirement pas avec les coordonnée 

-
Edité par Anonyme 12 juillet 2013 à 15:43:25

Bonjour,

Je comprend pas trop ton code mais je te conseillerai de travailler avec un tableau bidimensionnel où ce n'est pas les coordonnées qui changent mais leurs contenues ( avec la possibilité d'avoir du vide et quelques cases en plus, à toi de voir ). Sinon si tu veux vraiment faire quelque chose de * Whaaouw * il faudra passer par un algorithme plus évolué ( qui va créer des zones ayant le même écosystème, où simplement par exemple pour avoir les minerais en bloc comme dans une vraie mine ).

Donc c'est à toi de voir en fonction du résultat que tu veux avoir ce qu'il te faut. Par exemple pose toi des questions sur la taille de tes maps, les types de surfaces, ce que tu veux toi ! Et toujours dans l'optique d'optimiser au maximum ton code ( soit le plus fainéant possible dans ton code, n'écrit jamais 100 lignes à peu près identiques ).

Voilà donc j'attends tes précisions, à bientôt !

Bouture.

Que veut tu dire par le contenue ?

je ne m'y connais pas trop sur pygame donc je ne permettrais pas trop de critiques sur cet aspect des choses mais quelques remarques :

tu importes le module os mais tu ne t'en sers pas ?

pourquoi Tex = False ? si ce booléen n'est lié à aucune condition (par exemple while not Tex: <instructions>)

Tu décides 110 lignes plus bas que Tex = True ; et alors ?

ligne 137: if Tex == True: (qui d'ailleurs peut s'écrire plus simplement -> if Tex:)

vu qu'il n'y a pas de else derrière, cette variable en l'état n'est donc pas très utile

les variables a b c d e f sont identiques ; tu pourrais n'avoir qu'une seule variable qui renvoie un nombre aléatoire dans une boucle ; à chaque tour de boucle cette variable prendrait une valeur différente

exemple bête:

from random import randrange

x = 0
while x < 10:
    x += 1
    y = randrange(1, 11)
    print(y)

désolé là je n'ai pas trop le temps (et en + je ne réponds pas à ta question), mais il me semble que ton code pourrait être grandement simplifié et raccourci.

bon courage

@minelitch ; pour rebondir sur ce que te dit Bouture:

pour créer, modifier, afficher une carte, un plan, un plateau de jeu 2d il est courant de passer par une liste de listes:

carte = [
    ['0', '0', '0'],
    ['0', '0', '0'],
    ['0', '0', '0']]

en bouclant sur ce tableau, tu peux facilement modifier (aléatoirement ou non) la valeur (le contenu) de chaque "cellule"

dans le cadre d'une interface graphique il est facile de dire

si cell vaut '0' alors image_a_charger = 'pierre.jpg'

sinon

si cell vaut '1' alors image_a_charger = 'eau.jpg'

etc

etc

pour le parcours de listes voir la fonction enumerate

Moi je fais même plus ( mais en AS3, un autre langage de programmation ), j'ai au départ un tableau 2D avec les identifiants de mes images ( je favorise les nombres au lieu des chaînes de caractère : çà nous fait un index pour un tableau ), puis après l'initialisation j'ai un second tableau 2D aussi que je vais utiliser qui lui contient les images ( enfin, les objets 'Cases' / 'Tiles' ).

Pour toi c'est surement pas très utile car toutes les même cases sont issues du même objet, du coup tu peux pas les éditer en cours de route ( c'est embêtant pour les cases dynamiques surtout, mais plus lent je reconnais ). 

Pour te donner un exemple c'est comme si tu avais une classe Grassblock qui contient trois attributs ( x, y et image ). Voici donc le schéma que j'aurais utiliser.

# quelque part ...

images = [ 'texture/ciel.png', 'texture/sand.png' ] # pour toutes les images de case.

# ... d'autre ...

class Tiles ( ) :
	def __init__ ( self, x, y, ID_image ) :
		self.x, self.y = x, y
		self.image = pygame.image.load ( images [ ID_image ] )
		
# ... plus loin dans ton code ...

result = [ ]
for i, x in enumerate ( mylist ) :
	line = [ ]
	for j, y in enumerate ( x ) :
		newtile = Tiles ( i, j, y )
		screen.blit ( newtile, ( i * 40, i * 40 ) )
		line.append ( newtile )
	result.append ( line )
	
# ... encore plus loin

result [ x ] [ y ].modifie ( actions )

Après je sais pas si c'est très "Pygamesque" mais je pense que c'est déjà un bon début pour ton projet.

Bouture.

-
Edité par Bouture 12 juillet 2013 à 17:52:06

J'ai pas pu m'en empêcher voici ce que çà donne ( ne regarde pas si tu veux tenter par toi même ! ), qu'en pensez vous les autres ?

import random
import os
import pygame
 
pygame.display.init ( )
windows = width, height = 800, 600
screen = pygame.display.set_mode ( windows )
 
images = [ 'resources/Ground.png', 'resources/Grass.png', 'resources/Stone.png', 'resources/Sky.png' ]

class Tiles ( ) :
	def __init__ ( self, x, y, ID_image ) :
		self.x, self.y = x, y
		self.image = pygame.image.load ( images [ ID_image ] )
		
tableau = [ [ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 ],
			[ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 ],
			[ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 ],
			[ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 ],
			[ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 ],
			[ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 ],
			[ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 ],
			[ 3, 3, 3, 3, 3, 1, 1, 1, 1, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1 ],
			[ 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
			[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
			[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
			[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
			[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
			[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
			[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2 ] ]

result = [ ]
for i, x in enumerate ( tableau ) :
	line = [ ]
	for j, y in enumerate ( x ) :
		newtile = Tiles ( j, i, y )	
		screen.blit ( newtile.image, ( j * 40, i * 40 ) )
		line.append ( newtile )
	result.append ( line )
	
pygame.display.flip()
	
continuer = True
while(continuer): 
        for event in pygame.event.get(): 
                if(event.type==pygame.QUIT or (event.type==pygame.KEYDOWN and event.key==pygame.K_ESCAPE)):
                        continuer=False
                         
pygame.quit()

J'ai gardé le code de départ en grande partie ( reconnaissable grâce au style, même si j'ai modifié certaines parties pour qu'elles me paraissent claires ).

Maintenant il faut trouver l'algorithme pour générer le tableau de départ aléatoirement de sorte qu'il soit jouable ( et ce en fonction de tes besoins ). Je m'y connais pas beaucoup mais en bidouillant on arrive à ce que l'on souhaite, toujours. 

Bouture. ( et désolé pour le double-post )

Vraiment un grand merci à vous ! je vais me penchez vers se système de tableau puis aprés un algorithme encore merci 

sinon ta methode de tableau prend 455 mo de ram xD

-
Edité par Anonyme 13 juillet 2013 à 14:12:39

Je reconnais que c'est loin d'être un bon exemple mais ce qu'il faut comprendre c'est que là tu peux manipuler des objets ( et donc des attributs ) largement plus facilement. L'avantage c'est que tu as tout tes attributs sur le même objet et que tu gardes l'image ( et oui le GC ne fait pas de pitié ) une fois entrée dans la boucle ( et la gestion des événements ).

Bonne chance pour la suite,

Bouture.

Salut, juste en passant, une astuce utile pour pas se taper des longs tableaux répétitifs à la main :

>>>[[3]*2]*5
[[3, 3], [3, 3], [3, 3], [3, 3], [3, 3]]