Les membres ayant 30 points peuvent parler sur les canaux annonces, projets et hs du chat.
Menu
Calculatrices
Graph 35 à 100 (CFX)
Graph 25/25+ (Pro) (fx-7400)
Graph 35+USB/75/85/95 (SD)
Graph 100/100+ (AFX)
ClassPad 300/330
Fx-CG 10/20
Fx-CP 400
Graph 90+E
Liens
¤ Transférer un programme sur
sa calculatrice

¤ Vous cherchez une fonction ?
Jeux >> Graphs 75/85/95 (SD) >> Add-ins >> Bomberman
Bomberman
Version : 1.0 Taille : 32000 octets Ajouté le : 2013-09-01 21:31 Modifié le : 2013-09-02 15:47
Auteur et posteur :
DodormeurHors ligneAncien rédacteurPoints: 3964 Défis: 82 Message
Planète Casio - Add-in Casio - Bomberman - dodormeur - Calculatrices
Nombre de visites sur cette page : 21524
Score au progrank : 76
Note actuelle : 9.19/10 noté 7 fois
Vous devez être connecté(e) pour noter (inscription).
5540 téléchargements | Voir les Tests (1)


A cause du changement de processeur des nouvelles Graph 35+ USB, 75 et 95 SD, de nombreux addins sont incompatibles avec ces calculatrices.
Rendre un addin compatible - Plus d'informations sur ce problème - Liste des addins compatibles

Description :

bonjour a tous !

pendant que certain programme ardemment en basic pour les 48h CPC, j'ai décidé de participer a ma manière. en effet, comme je ne peut pas participer (parce que je suis testeur) ou gagner (j'ai déjà gagné cette année), j'ai décide de faire un add-in avec les même condition que les jeux du concours.

voila donc Bomberman, un jeu programmé en 56 heures, et avec des niveaux de gris (ne vous fiez pas a l'image)

le mode aventure
Cliquer pour enrouler

dans le mode aventure, vous avez été envoyé derrière les lignes ennemies, avec pour but de détruire l'arme secrète de l'ennemi.
quelle ne fut pas votre surprise lorsque vous avez découvert que l'arme secrète est un moyen de faire revenir a la vie les morts, sous forme de momie ! le seul moyen de les détruire définitivement, c'est de les exploser a coup de bombe. et cela tombe bien, vous avez justement une réserve infinie de bombes sur vous ! (la vie est bien faite)
tous les deux niveaux vous perdez vos améliorations, mais vous gagnez un coeur supplémentaire.
les codes doivent être rentré dans l\'écran titre et puis lancez le mode aventure.


le mode infini
Cliquer pour enrouler

dans ce mode, vous devez combattre des vagues d'ennemis dans des niveaux de plus en plus grand !
vous recuperez votre vie tous les 5 niveaux.


les ameliorations
Cliquer pour enrouler

la flamme : augmente la taille de l'explosion
la bombe : augment le nombre de bombes que vous pouvez poser en meme temps
le coeur : vous régénère un PV
la bombe piquante : vos explosions traversent les murs


les options et autres
Cliquer pour enrouler

en appuyant sur alpha/(-) (n'importe quand) vous pouvez modifier le contraste, et eteindre le grayscale (si vous etes sur emulateur par exemple).
si vous appuyez sur F1 vous mettez le jeu en pause, et vous pouvez quitter avec menu/exit.


le jeu n'est sans doute pas compatible SH4 a cause des grayscale, mais ca viendra peut-etre dans une version monochrome
le jeu est desormais compatible SH4, mais seulement en version monochrome (2eme fichier)


Note sur 10 Commentaire Date de notation
9.3Voir le testLe 02.09.2013 à 11:59
9Très bon add-in, sympa à jouer, mais un peu durLe 02.09.2013 à 16:23
8très bon jeu :D Le 07.09.2013 à 17:37
9Bon addin, mais assez dur. Un niveau facile pour le prendre en main ?Le 08.03.2014 à 16:53
10Un addin très sympaLe 15.09.2013 à 11:09
9très bonne add-in, le seul regret étant qu'il soit assez différent d'un bomberman classique... Mais ça reste vraiment divertissantLe 18.09.2013 à 17:39
10Un exellent jeu ! Le 29.11.2013 à 18:06

Commentaires :

Pages: Précédente | 1, 2, 3, 4, 5, 6, 7 | Suivante

DodormeurHors ligneAncien rédacteurPoints: 3964 Défis: 82 Message
Posté le 13-12-2013 à 20:43 | #
@Dark : oui il y a moyen, mais pourquoi de la version Monochrome?

Il faudrait d'ailleurs que je mette a jour le jeu, j'ai créer une version + performante avec détection SH4
Dark stormHors ligneLabélisateurPoints: 11549 Défis: 176 Message
Posté le 13-12-2013 à 20:51 | #
C'est celle compatible SH4
DodormeurHors ligneAncien rédacteurPoints: 3964 Défis: 82 Message
Posté le 13-12-2013 à 21:57 | #
Tiens, je te met le code du gray.c compatible SH4 (et ici avec détection automatique de l'os).

A noter que si l'on a le moindre EBR avec ce code, il suffit de remplacer le define SH3 !isOS2 par define SH3 0 pour passer directement en monochrome et éviter les EBR;)

#define SH3 !isOS2

#include "gray.h"
#include <stdlib.h>
#define INT_OFFSET 0x600

#define set_vbr(base)        _builtin_set_vbr(base)


struct st_tmu {
              union {
                    unsigned char BYTE;
                    struct {
                           unsigned char     :5;
                           unsigned char STR2:1;
                           unsigned char STR1:1;
                           unsigned char STR0:1;
                           }      BIT;
                    }           TSTR;
};
struct st_tmu0 {
               unsigned int     TCOR;
               unsigned int     TCNT;
               union {
                     unsigned short WORD;
                     struct {
                            unsigned short     :7;
                            unsigned short UNF :1;
                            unsigned short     :2;
                            unsigned short UNIE:1;
                            unsigned short CKEG:2;
                            unsigned short TPSC:3;
                            }       BIT;
                     }          TCR;
};
struct st_intc {
               union {
                     unsigned short WORD;
                     struct {
                            unsigned short NMIL:1;
                            unsigned short     :6;
                            unsigned short NMIE:1;
                            }       BIT;
                     }          ICR0;
               union {
                     unsigned short WORD;
                     struct {
                            unsigned short _TMU0:4;
                            unsigned short _TMU1:4;
                            unsigned short _TMU2:4;
                            unsigned short _RTC :4;
                            }       BIT;
                     }          IPRA;
               union {
                     unsigned short WORD;
                     struct {
                            unsigned short _WDT:4;
                            unsigned short _REF:4;
                            }       BIT;
                     }          IPRB;
               char             wk[234];
               unsigned int     TRA;
               unsigned int     EXPEVT;
               unsigned int     INTEVT;
};
struct st_intx {
               unsigned int     INTEVT2;
               union {
                     unsigned char BYTE;
                     struct {
                            unsigned char PINT0R:1;
                            unsigned char PINT1R:1;
                            unsigned char IRQ5R :1;
                            unsigned char IRQ4R :1;
                            unsigned char IRQ3R :1;
                            unsigned char IRQ2R :1;
                            unsigned char IRQ1R :1;
                            unsigned char IRQ0R :1;
                            }      BIT;
                     }          IRR0;
               char             wk1;
               union {
                     unsigned char BYTE;
                     struct {
                            unsigned char TXI0R:1;
                            unsigned char      :1;
                            unsigned char RXI0R:1;
                            unsigned char ERI0R:1;
                            unsigned char DEI3R:1;
                            unsigned char DEI2R:1;
                            unsigned char DEI1R:1;
                            unsigned char DEI0R:1;
                            }      BIT;
                     }          IRR1;
               char             wk2;
               union {
                     unsigned char BYTE;
                     struct {
                            unsigned char      :3;
                            unsigned char ADIR :1;
                            unsigned char TXI2R:1;
                            unsigned char      :1;
                            unsigned char RXI2R:1;
                            unsigned char ERI2R:1;
                            }      BIT;
                     }          IRR2;
               char             wk3[7];
               union {
                     unsigned short WORD;
                     struct {
                            unsigned short MAI   :1;
                            unsigned short IRQLVL:1;
                            unsigned short BLMSK :1;
                            unsigned short       :1;
                            unsigned short IRQ5S :2;
                            unsigned short IRQ4S :2;
                            unsigned short IRQ3S :2;
                            unsigned short IRQ2S :2;
                            unsigned short IRQ1S :2;
                            unsigned short IRQ0S :2;
                            }       BIT;
                     }          ICR1;
               union {
                     unsigned short WORD;
                     struct {
                            unsigned short PINT15S:1;
                            unsigned short PINT14S:1;
                            unsigned short PINT13S:1;
                            unsigned short PINT12S:1;
                            unsigned short PINT11S:1;
                            unsigned short PINT10S:1;
                            unsigned short PINT9S :1;
                            unsigned short PINT8S :1;
                            unsigned short PINT7S :1;
                            unsigned short PINT6S :1;
                            unsigned short PINT5S :1;
                            unsigned short PINT4S :1;
                            unsigned short PINT3S :1;
                            unsigned short PINT2S :1;
                            unsigned short PINT1S :1;
                            unsigned short PINT0S :1;
                            }       BIT;
                     }          ICR2;
               union {
                     unsigned short WORD;
                     struct {
                            unsigned short PINT15E:1;
                            unsigned short PINT14E:1;
                            unsigned short PINT13E:1;
                            unsigned short PINT12E:1;
                            unsigned short PINT11E:1;
                            unsigned short PINT10E:1;
                            unsigned short PINT9E :1;
                            unsigned short PINT8E :1;
                            unsigned short PINT7E :1;
                            unsigned short PINT6E :1;
                            unsigned short PINT5E :1;
                            unsigned short PINT4E :1;
                            unsigned short PINT3E :1;
                            unsigned short PINT2E :1;
                            unsigned short PINT1E :1;
                            unsigned short PINT0E :1;
                            }       BIT;
                     }          PINTER;
               union {
                     unsigned short WORD;
                     struct {
                            unsigned short _IRQ3:4;
                            unsigned short _IRQ2:4;
                            unsigned short _IRQ1:4;
                            unsigned short _IRQ0:4;
                            }       BIT;
                     }          IPRC;
               union {
                     unsigned short WORD;
                     struct {
                            unsigned short _PINT0_7 :4;
                            unsigned short _PINT8_15:4;
                            unsigned short _IRQ5    :4;
                            unsigned short _IRQ4    :4;
                            }       BIT;
                     }          IPRD;
               union {
                     unsigned short WORD;
                     struct {
                            unsigned short _DMAC :4;
                            unsigned short _SCIF0:4;
                            unsigned short _SCIF2:4;
                            unsigned short _ADC  :4;
                            }       BIT;
                     }          IPRE;
               char             wk4[524260];
               union {
                     unsigned short WORD;
                     struct {
                            unsigned short     :8;
                            unsigned short _USB:4;
                            }       BIT;
                     }          IPRF;
               union {
                     unsigned short WORD;
                     struct {
                            unsigned short _TPU0:4;
                            unsigned short _TPU1:4;
                            }       BIT;
                     }          IPRG;
               union {
                     unsigned short WORD;
                     struct {
                            unsigned short _TPU2:4;
                            unsigned short _TPU3:4;
                            }       BIT;
                     }          IPRH;
};

#define INTC   (*(volatile struct st_intc  *)0xFFFFFEE0)
#define INTX   (*(volatile struct st_intx  *)0xA4000000)
#define TMU    (*(volatile struct st_tmu   *)0xFFFFFE92)
#define TMU0   (*(volatile struct st_tmu0  *)0xFFFFFE94)


Screen* screen = NULL;
#pragma interrupt(gray_interrupt)

void gray_interrupt()
{
    if(screen->which == 1)
    {
        draw_all(screen->DD1);
        screen->which = 2;
        TMU.TSTR.BIT.STR0 = 0;
        TMU0.TCNT = TMU0.TCOR = screen->time1;
    } else {
        draw_all(screen->DD2);
        screen->which = 1;
        TMU.TSTR.BIT.STR0 = 0;
        TMU0.TCNT = TMU0.TCOR = screen->time2;
    }
    TMU0.TCR.BIT.UNF = 0;
    TMU.TSTR.BIT.STR0 = 1;
}

int gray_init()
{
    screen = malloc(sizeof(Screen));
    if(!screen) return 0;
    screen->VRAM1 = malloc(1024);
    screen->VRAM2 = malloc(1024);
    screen->DD1 = malloc(1024);
    screen->DD2 = malloc(1024);
    if(!screen->VRAM1 || !screen->VRAM2 || !screen->DD1 || !screen->DD2) return 0;
    screen->time1 = 3269;
    screen->time2 = 6987;
    screen->which = 1;
    if(SH3){set_vbr((void *)((unsigned int)gray_interrupt - INT_OFFSET));
    TMU0.TCR.WORD = 0x0022;
    TMU0.TCNT = TMU0.TCOR = screen->time1;
    INTC.IPRA.WORD = 0xf000;
    INTC.IPRB.WORD = 0x0000;
    INTX.IPRC.WORD = 0x0000;
    INTX.IPRD.WORD = 0x0000;
    INTX.IPRE.WORD = 0x0000;
    INTX.IPRF.WORD = 0x0000;
    INTX.IPRG.WORD = 0x0000;
    INTX.IPRH.WORD = 0x0000;
    TMU.TSTR.BIT.STR0 = 1;}
    return 1;
}

void gray_quit()
{
    TMU0.TCR.WORD = 0x0000;
    TMU0.TCNT = TMU0.TCOR = 0xFFFFFFFF;
    INTC.IPRA.WORD = 0x0000;
    TMU.TSTR.BIT.STR0 = 0;
    TMU.TSTR.BIT.STR1 = 0;
    TMU.TSTR.BIT.STR2 = 0;
    free(screen->VRAM1);
    free(screen->VRAM2);
    free(screen->DD1);
    free(screen->DD2);
    free(screen);
}


void gray_swapBuffers(int emulateur)
{
    char* temp;
    char *LCD_register_selector = (char*)0xB4000000, *LCD_data_register = (char*)0xB4010000, *vram;
    int i, j;
    if(SH3)
        {
        if(emulateur)
            {
            temp = screen->VRAM2;
            screen->VRAM2 = screen->DD1;
            screen->DD1 = temp;
            }
        else
            {
            temp = screen->VRAM1;
            screen->VRAM1 = screen->DD1;
            screen->DD1 = temp;
            }

        temp = screen->VRAM2;
        screen->VRAM2 = screen->DD2;
        screen->DD2= temp;
        }
    else
        {

        vram = screen->VRAM2;
        for(i=0 ; i<64 ; i++)
            {
            *LCD_register_selector = 4;
            *LCD_data_register = i|192;
            *LCD_register_selector = 4;
            *LCD_data_register = 0;
            *LCD_register_selector = 7;
            for(j=0 ; j<16 ; j++) *LCD_data_register = *vram++;
            }
       }
}


void gray_clearVRAM()
{
    memset(screen->VRAM1, 0, 1024);
    memset(screen->VRAM2, 0, 1024);
}

Screen* gray_getScreen()
{
    return screen;
}


void ML_set_contrast(unsigned char contrast)
{
    char *LCD_register_selector = (char*)0xB4000000, *LCD_data_register = (char*)0xB4010000;
    *LCD_register_selector = 6;
    *LCD_data_register = contrast;
}
Dark stormHors ligneLabélisateurPoints: 11549 Défis: 176 Message
Posté le 13-12-2013 à 21:58 | #
C'est pas le gris que je voulais
DodormeurHors ligneAncien rédacteurPoints: 3964 Défis: 82 Message
Posté le 13-12-2013 à 21:59 | # | Fichier joint
tiens, voila les sources complètes
Dark stormHors ligneLabélisateurPoints: 11549 Défis: 176 Message
Posté le 13-12-2013 à 22:01 | #
Merci
AdeloHors ligneMembrePoints: 235 Défis: 4 Message
Posté le 22-12-2013 à 19:30 | #
Bien sûr ce jeu est super !
C'est même le meilleur bomberman !
Mais je te propose de rajouter ces améliorations (après pokémon bien sûr) :
- la vitesse
- un ia pour jouer contre des perso (qui posent aussi des bombes)
- pouvoir créer sa map
- scores
- plus d'objets
- plus de maps (en add ons comme dans 10 sec run)
- plus de monstres différent
Avec ces améliorations, il sera le meilleur bomberman sur calto de tout les temps !
C'est une très bonne idée n'est-ce pas ?
S'il y a un jeu que tu peux améliorer c'est bien celui-là !
AdeloHors ligneMembrePoints: 235 Défis: 4 Message
Posté le 22-12-2013 à 19:32 | #
D'ailleur je t'ai déja donné une note !
Adelo a écrit :
10 Un exellent jeu ! Le 29.11.2013 à 18:06

Si tu l'améliore, il faudra vraiment ajouter la note de 11/10 ! mdr
EltoredoHors ligneModérateurPoints: 4299 Défis: 35 Message
Posté le 22-12-2013 à 19:56 | #
Je suis même pas sûr qu'il y ai d'autres bombermans ou plusieurs autres mais tes idées sont bonnes
GollumHors ligneMembrePoints: 1262 Défis: 2 Message
Posté le 18-03-2014 à 22:12 | #
c'est normal, le reset quand on quite ?

Pages: Précédente | 1, 2, 3, 4, 5, 6, 7 | Suivante

Planète Casio v42 © créé par Neuronix et Muelsaco 2004 - 2022 | Il y a 35 connectés | Nous contacter | Qui sommes-nous ? | Licences et remerciements

Planète Casio est un site communautaire non affilié à Casio. Toute reproduction de Planète Casio, même partielle, est interdite.
Les programmes et autres publications présentes sur Planète Casio restent la propriété de leurs auteurs et peuvent être soumis à des licences ou copyrights.
CASIO est une marque déposée par CASIO Computer Co., Ltd