Salut!
Je fait un petit jeu en ce moment, qui n´avance guere avec les bugs. J´utilise une palette de sprite d´un bonhomme.
Jsais pas si ca s´apelle comme ca, mais c´est de ce style :
http://www.aniway.com/exaexamples/character/Sprites.gif

J´affiche les srpites comme je le veux, tout fonctionne correctement.
Mais lors d´une phase de jeu differente, il s´affiche sur l´ecran un rectangle noir de la taille de l´ensemble des sprites.
Je poste pas le code, trop long, mais je me demandais si quelqu´un avait deja connu ce genre de fait.
Ca m´aiderais a trouver plus rapidement la partie a changer.
Mais j´arriverai bien a trouver la solution

Tout le monde a probablement deja vu des bugs dans le genre.
Ta palette de sprite est elle bien chargé dans cette phase de jeu ?
est ce que son chargement a bien fonctionné ?
comment affiches tu ton sprites ?
Il est etrange que la surface noire ait la taille de la palette. Elle devrait seulement avoir la taille du sprite que tu veux afficher. Cela veut dire que tu calcules mal la taille de la surface a afficher.

Ma palette de sprite est en effet bien chargée, puisque le sprite voulu s´affiche correctement. Le rectangle noir s´affiche en meme temps.

http://www.monsterup.com/upload/1186048859.jpg

Quand je colle la palette de sprite dessus, on se rend compte que la hauteur est la meme, mais pas la longueur.

http://www.monsterup.com/upload/1186048938.jpg

Mais quand on y rajoute deux colonnes de sprite, on s´apercoit qu´on arrive pile a occupper la surface du rectangle noir.

http://www.monsterup.com/upload/1186049017.jpg

Il faut que je verifie tout ce qui change avec la phase opposée, l´attaque, ou le rectangle noir ne s´affiche pas.

Bonsoir à tous, voila je code actuellement un petit mario-like en C/C++ avec la SDL, et j´aimerais savoir si quelqu´un pourrait me détailler une fonction(simple, enfin compréhensible à la lecture) permettant de lire les pixels d´un bitmap un par un, et de renvoyer selon la couleur soi un espace vide soi une tuile.
En gro se servir d´un bitmap pour créer une carte facilement

j´ai déjà flâné sur net et je ne trouve que des fonction qui n´affiche que le nombre de bits par pixel..

Ce serai vraiment gentil de m´aider a trouver/me proposer un model
de cette fonction.

Encore une question ^^´ comment cela se passe niveau code pour la conversion pixel-bitmap ver une tuile de 16x16, il se fau quand meme pa découper l´ecran en petits carrés de 16 par 16 ?

PS (j´ai bien sur lu attentivement les explication du tuto de JY²/Fvirtman sur l´utilisation des charset et des tuiles mais je my suis perdu, je ne veu pa dire qu´il code mal, mais c un peu brouillon pour moi ^^´)
Merci d´avoir lu et a ceux qui me repondront !

pourquoi tu pars pas d´un tableau pour faire ta map? chui pas un pro en la matière mais jtrouve ca bizarre comme méthode

un tableau ? de genr un .txt avec des 0 et des 1 ? déja testé, c´est long et peu fonctionnel comme méthode..

long? je sais pas si la méthode sera tellement différente pour les pixels

et qu´est-ce que tu veux dire par peu fonctionnel?
moi aussi je suis sur un mario-like en ce moment et j´y arrive pas mal avec mon tableau

Comment a tu procédé, la méthode .txt que j´ai essayé c´est celle de M@téo21 (cf siteduzero) avec dans son fichier une grande quandtité de chiffre indiquant les tuiles et espaces blancs.
Ce que je cherche c´est un fonction(simple ^^´) qui me permettrai d´afficher mes tuiles de sol et autres, si tu as une astuce pour la gravité je suis tout ouïe ^^ merci de répondre ça fait plaisir

bah j´ai suivi le meme tuto , je sais pas si ya plus simple mais la méthode du tableau ds un fichier txt reste assez simple également. (j´ai utilisé un fscanf pour la lecture)

sinon pour la gravité, suffit de faire tomber (position.y de tt le monde -- ) sauf lorsqu´il ya collision horizontale, c´est comme ca que je m´y suis pris

pas bête.. sinon pour ton .txt (si c´est bien ça) c´est juste une suite de chiffre ou tu as proccedé avec retour a la ligne ?

du genre

TAILLE_BLOC = 16 (au ²)

la largeur et la hauteur en bloc * 16 pr la taille de l´ecran

cela te donne un fichier du genre

0000000000000000000000000000000000000
0000000000000000000000000000000000000
0000000000000000000000000000000000000
0000000000000000000000000000000000000
1100000000000000000000000200000000011
etc..

ou alors juste un suit de nombre ? je trouve plus fonctionelle la 1ere méthode (qui n´est pa prise par mateo21.. dommage)

oué j´utilise la première méthode pour plus de clarté

for (v= 0; v<NBRE_CASE_V ; v++)
{
for (u = 0; u<NBRE_CASE_H; u++) // pour ttes les cases
{
fscanf(fichier, "%ld,", &lecteur);
carte[v][u] = lecteur;
}
}
en gros c ca, les "u" et "v" te permettent de lire chaque valeur du tableau (chez moi g mis une virgule à chaque fois), et à chaque fois, la valeur lue ds le .txt est disons "importée" au tableau du jeu.
Ca c´est pour le chargement à partir d´un tableau d´un txt, après gérer ce tableau et y dessiner les tuiles c un autre probleme

C´est idiot d´utiliser un tableau pour la map, on utilise un tableau souvent pour des jeux d´échec ou comme dans le site du zéro, des sokoban mais pas dans un mario like ^^
moi je propose une fonction collision parametrable ou un void auquel on envoyera un int(c´est un exemple hein) et pour appliquer cette fonction à toutes les briques,
for(i=0,i=NB_BRIQUES,i++)
{
collision(i)
}

gererai les collisions de toutes les briques par exemple.

ensuite tu mets une classe "mario" e tune classes "ennemis" (ce n´est qu´un exemple tu peux aussi faire une classe personnages et inclure mario ^^

tu peux aussi dans le même sens, créé une fonction qui créé des briques à un certain endroit (comme pour les levels par exemple) et auquel on applique les collisions ^^
je te donne encore un exemple, mettre des briques sur toute la map:

void World::Map() // je préciseque j´ai créé une clase World avant, qui gerera la map, les tiles et les surfaces
{
for(i=0,i=LARGEUR_DE_LA_MAP,i+LARGEUR_BRIQUE)
{
collision(LARGEUR_BRIQUE)
for(i=0,i=LONGUEUR_DE_LA_MAP,i+LONGUEUR_BRIQUE)
{
collision(LONGUEUR_BRIQUE);
// je me répète mais c´est juste un exemple hein, tu peux changer la fonction ^^
}

}

}

En t´esperant t´avoir aidé,
A_Genius

"J´ai bien sur lu attentivement les explication du tuto de JY²/Fvirtman sur l´utilisation des charset et des tuiles mais je my suis perdu, je ne veu pa dire qu´il code mal, mais c un peu brouillon pour moi ^^´) "

--> Dis moi ou tu bloques, ce qui t´a échappe ?

A_Genius > Tous les mario´ like, et énormément de jeux 2D utilisent un tableau 2D en interne : peut importe comment il est représenté : il faut qu´a un x,y donné on donne le bon tile : on a bien une notion de tableau 2D.

for(i=0,i=NB_BRIQUES,i++)
{
collision(i)
}
--> Non, je ne suis pas d´accord, pour la simple raison que si tu es dans un monde en "tilemap", alors, avec 2 divisions, tu peux savoir au dessus de quel tile est ton personnage : il y a ainsi qu´un calcul de collision a faire.
Si tu fais un test de collision sur tous les tiles, meme ceux qui sont tres loin, alors tu fais beaucoup de calculs pour rien.

Meme pour les mondes plus "anarchiques" qui ne sont pas régulierement représenté en tiles, comme par exemple les FPS, qui utilisent finalement une "soupe" de triangles, il est hors de question de tester la collision de tous les triangles du monde a chaque fois : c´est trop calculatoire : on regroupe les triangles par zones (Octree ou BSP) de façon a minimiser au maximum le nombre de triangles a tester.

D´une façon générale, le but est de faire les tests que sur les "briques" pres du joueur, pour cela, il existe donc plein de méthodes. Pour les tiles, cette méthode est immédiate

Fvirtman >> Je cherchais juste une fonction(simple) qui me permettrai de gérer l´affichage de tuiles (pa des masses ^^´) facilement, ta méthode (qui m´intéresse car au contraire d´un txt on "voit" directement la forme du level.

sinon est-ce que cela peu gerer le scroll horizontal ?

loc_screen.x = (marioActuel->w / 2) - (screen->w / 2);

if(loc_screen.x < 0)
loc_screen.x = 0

en blitant l´écran à cette position (je ne sais pas si c´est possible je n´ai jamais vu quelqu´un bliter "screen" ou "ecran")

Merci de votre aide

oup´s j´ai oublié ^^´

if(loc_screen.x > WIDHT_SCREEN)
loc_screen.x = WIDHT_SCREEN)

Fvirtman Oui mais un mario-like c´est simplet, il n´y aura pas des millions de tile(sauf si il veut et fait des millions de tiles bien entendu ^^)
Sinon, poru giganova moi je ne sais pas j´ai jamais fait un jeu avec du scrolling ^^

Je pense plutôt qu´il faut bliter une image background et appliquer mon code sur cette image mais j´ai peur qu´elle ne se déplace avec le perso, et que l´on voit apparaitre le fond blanc applique en SDL_FillRect. Qu´en pensez vous ?

si tu blittes le background à la position du mario,tu ne verras pas le blanc puisqu´il recouvrira tout l´écran.
tu fais un background de la taille de l´écran et tu le mets à la position de mario, mais je pense qu´il y a plus simple.

c´était effectivement mon idée. Faire une image background centrée horizontalement (et surement verticalement car dans un level le mario il ne reste pas tout le temps à au même .y)

Bah rien que pour la fonction "sauter" il faut le "y" non ? Et un mario sans sauter, pas très marrant ;)