Batch Index du Forum
S’enregistrerRechercherFAQMembresGroupesConnexion
Répondre au sujet Page 1 sur 1
[C#] Un simulateur de porte des étoiles
Auteur Message
Répondre en citant
Message [C#] Un simulateur de porte des étoiles 
Bonjour,




Je tiens à vous montrer un programme de ma composition, un programme qui simule l'ouverture et la fermeture d'une porte des étoiles,


Voici le lien : https://www.box.com/s/f30aba1b8bddec41f51a

Il s'agit simplement d'une animation, vous commander l'ouverture et la fermeture en appuyant sur "Entrer"


Edit : Lien du code source : https://www.box.com/s/a975467c44acda37375f

Voici le contenu du fichier database_anim.h :

Code:
[lang=c]
#define NBMAXANIMVORTEX_SHUTDOWN 32
_animvrtx animvrtx_shutdown[NBMAXANIMVORTEX_SHUTDOWN] =
{
/// aftertime,animstatus,nbcircle,*circle,,,
/// ///////////////////////////////r    ,aff ,color////////
    {1       ,false     ,2       ,{{RI   ,177 ,9  },
                                   {1    ,178 ,9 },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },}},
    {1       ,false     ,2       ,{{RI   ,177 ,9  },
                                   {2    ,178 ,9  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },}},
    {1       ,false     ,2       ,{{RI   ,177 ,9  },
                                   {3    ,178 ,9  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },}},
    {1       ,false     ,2       ,{{RI   ,177 ,9  },
                                   {4    ,178 ,9  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },}},
    {1       ,false     ,3       ,{{RI   ,177 ,9  },
                                   {5    ,178 ,9  },
                                   {1    ,176 ,15 },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },}},
    {1       ,false     ,3       ,{{RI   ,177 ,9  },
                                   {6    ,178 ,9  },
                                   {2    ,176 ,15 },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },}},
    {1       ,false     ,3       ,{{RI   ,177 ,9  },
                                   {7    ,178 ,9  },
                                   {3    ,176 ,15 },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },}},
    {1       ,false     ,3       ,{{RI   ,177 ,9  },
                                   {8    ,178 ,9  },
                                   {4    ,176 ,15 },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },}},
    {1       ,false     ,2       ,{{RI   ,178 ,9  },
                                   {5    ,176 ,15 },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },}},
    {1       ,false     ,2       ,{{6    ,176 ,15 },
                                   {1    ,177 ,15 },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },}},
    {1       ,false     ,2       ,{{7    ,176 ,15 },
                                   {2    ,177 ,15 },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },}},
    {1       ,false     ,2       ,{{8    ,176 ,15 },
                                   {5    ,177 ,15 },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },}},
    {1       ,false     ,2       ,{{RI   ,176 ,15 },
                                   {7    ,177 ,15 },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },}},
    {1       ,false     ,1       ,{{RI   ,177 ,15 },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },}},
    {1       ,false     ,1       ,{{RI   ,178 ,15 },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },}},
    /// ///////// début grand cercle blanc ///////// ///
    {1       ,false     ,1       ,{{1    ,178 ,15 },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },}},
    {1       ,false     ,1       ,{{2    ,178 ,15 },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },}},
    {1       ,false     ,1       ,{{3    ,178 ,15 },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },}},
    {1       ,false     ,1       ,{{4    ,178 ,15 },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },}},
    {1       ,false     ,1       ,{{5    ,178 ,15 },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },}},
    {1       ,false     ,1       ,{{6    ,178 ,15 },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },}},
    {1       ,false     ,1       ,{{7    ,178 ,15 },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },}},
    {1       ,false     ,1       ,{{RI   ,178 ,15 },    /// grand cercle blanc
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },}},
    {1       ,false     ,1       ,{{1    ,32  ,15 },    /// début de son effacement
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },}},
    {1       ,false     ,1       ,{{2    ,32  ,15 },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },}},
    {1       ,false     ,1       ,{{3    ,32  ,15 },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },}},
    {1       ,false     ,1       ,{{4    ,32  ,15 },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },}},
    {1       ,false     ,1       ,{{5    ,32  ,15 },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },}},
    {1       ,false     ,1       ,{{6    ,32  ,15 },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },}},
    {1       ,false     ,1       ,{{7    ,32  ,15 },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },}},
    {1       ,false     ,1       ,{{8    ,32  ,15 },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },}},
    {1       ,false     ,1       ,{{RI   ,32  ,15 },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },}},
};



Voici le contenu du fichier MotorStargate.h :

Code:

[lang=c]
void MotorStargate(void);

#define TIME_TO_NEXTCHEVRON 20
#define TIME_TO_ACTIVATECHEVRON 5
#define TIME_TO_ACTIVATEVORTEXANIM 20


//(STARGATE_CHEVRON_INACTIF_AFF+((STARGATE_CHEVRON_AFF-STARGATE_CHEVRON_INACTIF_AFF)*dtsg.chevronstatus[i]))
#define ACTUALIZECHEV(i) PUTC_WITHORIGIN_ONLYINMAP(STARGATE_YS,STARGATE_XS,(int)(STARGATE_CHEVRONDIST*sin(ANGDOSE*i-pi/2)),(int)(STARGATE_CHEVRONDIST*cos(ANGDOSE*i-pi/2)),STARGATE_CHEVRON_COLOR,(STARGATE_CHEVRON_INACTIF_AFF+((STARGATE_CHEVRON_AFF-STARGATE_CHEVRON_INACTIF_AFF)*dtsg.chevronstatus[i])));
#define ACTIVECHEV(i) {if(i>=0&i<STARGATE_CHEVRONMAX) dtsg.chevronstatus[i]=1;PUTC_WITHORIGIN_ONLYINMAP(STARGATE_YS,STARGATE_XS,(int)(STARGATE_CHEVRONDIST*sin(ANGDOSE*i-pi/2)),(int)(STARGATE_CHEVRONDIST*cos(ANGDOSE*i-pi/2)),STARGATE_CHEVRON_COLOR,STARGATE_CHEVRON_AFF);}
#define DESACTIVECHEV(i) {if(i>=0&i<STARGATE_CHEVRONMAX) dtsg.chevronstatus[i]=0;PUTC_WITHORIGIN_ONLYINMAP(STARGATE_YS,STARGATE_XS,(int)(STARGATE_CHEVRONDIST*sin(ANGDOSE*i-pi/2)),(int)(STARGATE_CHEVRONDIST*cos(ANGDOSE*i-pi/2)),STARGATE_CHEVRON_COLOR,STARGATE_CHEVRON_INACTIF_AFF);}


/// bug 0001 : pas de vortex car pas de vérification de l'id du chevron dans les macro.
enum
{
    ACT_VORTEX_ACTIF,
    ACT_VORTEX_INACTIF,
    ACT_CHEVRONSERIE_ACTIVATION,
    ACT_VORTEX_STABLE,
    ACT_VORTEX_SHUTDOWN,
};

    struct circleprop
    {
        UINT8 rayon,aff,color;
    };

#define NBMAXCIRCLEBYANIM 5
struct _animvrtx
{
    time_t aftertime; /// temps necessaire pour passer à l'animation suivante
    UINT8 animstatus; /// évite de faire plusieur fois la même animation ///
    UINT8 nbcircle;
    circleprop circle[NBMAXCIRCLEBYANIM];
};
/** RAPPEL : ///
#define STARGATE_RAYONMAX 12
#define STARGATE_RAYONMIN 9
*/
#define RI STARGATE_RAYONMIN
#define RA STARGATE_RAYONMAX

#define NBMAXANIMVORTEX 22
_animvrtx animvrtxg[NBMAXANIMVORTEX] =
{
/// aftertime,animstatus,nbcircle,*circle,,,
/// ///////////////////////////////r    ,aff ,color////////
    {1       ,false     ,2       ,{{RI   ,176 ,9  },
                                   {RI-1 ,32  ,15 },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  }}},
    {1       ,false     ,2       ,{{RI   ,176 ,9  },
                                   {RI-2 ,32  ,15 },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  }}},
    {1       ,false     ,2       ,{{RI   ,176 ,9  },
                                   {RI-3 ,32  ,15 },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  }}},
    {1       ,false     ,2       ,{{RI   ,176 ,9  },
                                   {RI-4 ,32  ,15 },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  }}},
    {1       ,false     ,2       ,{{RI   ,176 ,9  },
                                   {RI-5 ,32  ,15 },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  }}},
    {1       ,false     ,2       ,{{RI   ,176 ,9  },
                                   {RI-6 ,32  ,15 },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  }}},
    {1       ,false     ,2       ,{{RI   ,176 ,9  },
                                   {2    ,32  ,15 },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  }}},
    {1       ,false     ,1       ,{{RI   ,176 ,9  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  }}},
    /// ///// 8 anims ///// Kawooch //////// /// Sortie ///
    {1       ,false     ,1       ,{{1    ,177 ,9  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  }}},
    {1       ,false     ,2       ,{{2    ,177 ,9  },
                                   {1    ,178 ,9  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  }}},
    {1       ,false     ,2       ,{{3    ,177 ,9  },
                                   {1    ,178 ,9  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  }}},
    {1       ,false     ,2       ,{{4    ,177 ,9  },
                                   {2    ,178 ,9  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  }}},
    {2       ,false     ,2       ,{{5    ,177 ,9  },
                                   {3    ,178 ,9  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  }}},
    {2       ,false     ,2       ,{{6    ,177 ,9  },
                                   {4    ,178 ,9  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  }}},
    {3       ,false     ,2       ,{{7    ,177 ,9  },
                                   {5    ,178 ,9  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  }}},
    /// ///// 15 anims ///// Kawooch //////// /// Entrée ///
    {2       ,false     ,3       ,{{RI   ,178 ,9  },
                                   {6    ,177 ,9  },
                                   {5    ,178 ,9  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  }}},
    {2       ,false     ,3       ,{{RI   ,178 ,9  },
                                   {5    ,177 ,9  },
                                   {4    ,178 ,9  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  }}},
    {1       ,false     ,3       ,{{RI   ,178 ,9  },
                                   {4    ,177 ,9  },
                                   {2    ,178 ,9  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  }}},
    {1       ,false     ,3       ,{{RI   ,178 ,9  },
                                   {3    ,177 ,9  },
                                   {1    ,178 ,9  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  }}},
    {1       ,false     ,2       ,{{RI   ,178 ,9  },
                                   {2    ,177 ,9  },
                                   {0    ,178 ,9  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  }}},
    {1       ,false     ,2       ,{{RI   ,178 ,9  },
                                   {1    ,177 ,9  },
                                   {0    ,178 ,9  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  }}},
    {1       ,false     ,1       ,{{RI   ,178 ,9  },    /// vortex finale
                                   {0    ,178 ,9  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  },
                                   {0    ,0   ,0  }}},
    /// Anim totale : 22
};

#include "database_anim.h"

void MotorStargate(void)
{
    int i;
    if(!dtsg.act)
    {
        dtsg.timenextchevron=-1;
        dtsg.actchevron=1;  /// reset chevron ///
        dtsg.actvortex=ACT_CHEVRONSERIE_ACTIVATION;
        dtsg.actvortexanim=-1;
        dtsg.timenextanim=0;
        dtsg.cmdvortex=CMD_NOTHING;
    }
    if(dtsg.act)
    {
        if(dtsg.timenextchevron==-1) ///premiére activation
        {
            dtsg.actchevron=1;  /// reset chevron ///
            dtsg.xactvortex=!ACT_CHEVRONSERIE_ACTIVATION;
            dtsg.actvortex=ACT_CHEVRONSERIE_ACTIVATION;
            dtsg.actvortexanim=-1;
            dtsg.timenextanim=0;
            dtsg.cmdvortex=CMD_NOTHING;
        }
        if(dtsg.actvortex==ACT_VORTEX_ACTIF) /// Animation du vortex /// au 9 eme chevron
        {
            if(dtsg.actvortexanim==255)  /// en attente
            {
                dtsg.timenextanim+=1;
                if(dtsg.timenextanim>=TIME_TO_ACTIVATEVORTEXANIM) /// temps avant d'activer le vortex ///
                {
                    dtsg.actvortexanim=0; /// mise en route des animation en commencant par la premiére ///
                    dtsg.timenextanim=0;
                }
            }
            else /// Animation du vortex
            {
                #define CORRECTANIM (dtsg.actvortexanim>=0&dtsg.actvortexanim<NBMAXANIMVORTEX)
                if(CORRECTANIM)
                {
                    dtsg.timenextanim+=1;
                    if(dtsg.timenextanim>=animvrtxg[dtsg.actvortexanim].aftertime)
                    {
                        dtsg.actvortexanim+=1;  /// animation suivante
                        dtsg.timenextanim=0;
                        if(CORRECTANIM) animvrtxg[dtsg.actvortexanim].animstatus=0;
                        /// animation suivante ///
                    }
                    if(CORRECTANIM)
                    {
                        if(!animvrtxg[dtsg.actvortexanim].animstatus) /// permet de faire l'animation qu'une fois ///
                        /// ou bien ceci : if(dtsg.timenextanim==0) /// permet de faire l'animation qu'une fois ///
                        {
                            animvrtxg[dtsg.actvortexanim].animstatus=true;  /// participa à empécher de faire l'animation plusieur fois
                            for(i=0;i<animvrtxg[dtsg.actvortexanim].nbcircle;i++) /// Animation (Plusieur cercle concentrique) ///
                            {
                                DrawCircle(STARGATE_YS,STARGATE_XS,animvrtxg[dtsg.actvortexanim].circle[i].rayon,animvrtxg[dtsg.actvortexanim].circle[i].color,animvrtxg[dtsg.actvortexanim].circle[i].aff);
                            }
                        }
                    }
                    /// Il faut forcer l'affichage des chevrons car il sont parfois effacés ///
                    for(i=0;i<STARGATE_CHEVRONMAX;i++)
                    {
                        ACTUALIZECHEV(i);
                    }
                }
                else
                {
                    dtsg.actvortex=ACT_VORTEX_STABLE;
                    dtsg.cmdvortex=0;
                }
            }
            dtsg.cmdvortex=CMD_NOTHING;
        }
        else if(dtsg.actvortex==ACT_CHEVRONSERIE_ACTIVATION)
        {
            dtsg.actvortex=ACT_CHEVRONSERIE_ACTIVATION;
            dtsg.timenextchevron+=1;
            if(dtsg.timenextchevron==TIME_TO_NEXTCHEVRON) /// activation chevron .actchevron & chevron 0
            {
                ACTIVECHEV(0)
                ACTIVECHEV(dtsg.actchevron) /// ACTIVATION CHEV .actchevron
            }
            if(dtsg.actchevron==STARGATE_CHEVRONMAX)
            {
                ACTIVECHEV(0);
                dtsg.actvortex=ACT_VORTEX_ACTIF; /// fin des activation des chevron, démarrage du vortex
                dtsg.timenextanim=0; /// reset temps anim vortex
                dtsg.actvortexanim=-1;
            }
            if(dtsg.timenextchevron>=TIME_TO_NEXTCHEVRON+TIME_TO_ACTIVATECHEVRON)
            {
                DESACTIVECHEV(0) /// désactivation chevron 0 /// DESACTIVATION CHEV 0
                dtsg.timenextchevron=0;
                dtsg.actchevron+=1; /// passage au chevron suivant ///
            }
        }
        if(dtsg.actvortex==ACT_VORTEX_STABLE) /// Si le vortex est stable ///
        {
            if(dtsg.cmdvortex==CMD_SHUTDOWNDEMAND) /// demande de fermeture de la porte ///
            {
                dtsg.actvortex=ACT_VORTEX_SHUTDOWN;
                dtsg.actvortexanim=0;
                dtsg.timenextanim=0;
            }
        }
        if(dtsg.actvortex==ACT_VORTEX_SHUTDOWN)
        {
            #define CORRECTANIM_SHUT (dtsg.actvortexanim>=0&dtsg.actvortexanim<NBMAXANIMVORTEX_SHUTDOWN)
            if(CORRECTANIM_SHUT)
            {
                dtsg.timenextanim+=1;
                if(dtsg.timenextanim>=animvrtx_shutdown[dtsg.actvortexanim].aftertime)
                {
                    dtsg.actvortexanim+=1;  /// animation suivante
                    dtsg.timenextanim=0;
                    if(CORRECTANIM_SHUT) animvrtx_shutdown[dtsg.actvortexanim].animstatus=0;
                    /// animation suivante ///
                }
                if(CORRECTANIM_SHUT)
                {
                    if(!animvrtx_shutdown[dtsg.actvortexanim].animstatus) /// permet de faire l'animation qu'une fois ///
                    /// ou bien ceci : if(dtsg.timenextanim==0) /// permet de faire l'animation qu'une fois ///
                    {
                        animvrtx_shutdown[dtsg.actvortexanim].animstatus=true;  /// participa à empécher de faire l'animation plusieur fois
                        for(i=0;i<animvrtx_shutdown[dtsg.actvortexanim].nbcircle;i++) /// Animation (Plusieur cercle concentrique) ///
                        {
                            DrawCircle(STARGATE_YS,STARGATE_XS,animvrtx_shutdown[dtsg.actvortexanim].circle[i].rayon,animvrtx_shutdown[dtsg.actvortexanim].circle[i].color,animvrtx_shutdown[dtsg.actvortexanim].circle[i].aff);
                        }
                    }
                }
                /// Il faut forcer l'affichage des chevrons car il sont parfois effacés ///
                for(i=0;i<STARGATE_CHEVRONMAX;i++)
                {
                    ACTUALIZECHEV(i);
                }
            }
            else
            {
                dtsg.actvortex=0;
                dtsg.act=0;
                for(i=0;i<STARGATE_CHEVRONMAX;i++)
                {
                    DESACTIVECHEV(i);
                }
            }
        }
    }
}

#define LIST_STATUS_CHEVRON_HAUTEUR (HAUTEURMAP-5-STARGATE_CHEVRONMAX)
#define LIST_STATUS_CHEVRON_LARGEUR (5)

#define LIST_STATUS_STARGATE_HAUTEUR (3)
#define LIST_STATUS_STARGATE_LARGEUR (3)
#define LIST_STATUS_STARGATE_LARGEUR_TEXT (18)

#define LIST_CMD_STARGATE_HAUTEUR (5)
#define LIST_CMD_STARGATE_LARGEUR (3)
#define LIST_CMD_STARGATE_LARGEUR_TEXT (19)

#define LIST_STATUS_CHEVRON_COLOR (7)
#define LIST_STATUS_STARGATE_COLOR (7)
#define LIST_CMD_STARGATE_COLOR (7)
#define LIST_CMD_STARGATE_COLOR_TEXT (14)

void mapprintf(UINT8 ys,UINT8 xs,char *text,UINT8 color)
{
    int x;
    for(x=0;x<strlen(text);x++)
    {
        PUTC_ONLYINMAP(ys,xs+x,color,text[x]);
    }
}


void MotorHUD(void)
{
    int i,y;
    if(!dtsg.hudaff)
    {
        mapprintf(LIST_STATUS_STARGATE_HAUTEUR,LIST_STATUS_STARGATE_LARGEUR,"Stargate Status : ",LIST_STATUS_STARGATE_COLOR);
        mapprintf(LIST_CMD_STARGATE_HAUTEUR,LIST_CMD_STARGATE_LARGEUR,"Stargate Command : ",LIST_CMD_STARGATE_COLOR);
        mapprintf(LIST_STATUS_CHEVRON_HAUTEUR,LIST_STATUS_CHEVRON_LARGEUR,"Chevron Status :",LIST_STATUS_CHEVRON_COLOR);
        for(y=0;y<STARGATE_CHEVRONMAX;y++)
        {
            #define LEN_AFF_STATUSCHEVRON 8
            mapprintf(LIST_STATUS_CHEVRON_HAUTEUR+y+1,LIST_STATUS_CHEVRON_LARGEUR+2,"Status :",LIST_STATUS_CHEVRON_COLOR);
        }
        dtsg.hudaff=1;
    }
    /// /////////////////////////////////////////// /////////////////////////////////////////// ///
    for(i=0;i<STARGATE_CHEVRONMAX;i++)
    {
        if(dtsg.xchevronstatus[i]!=dtsg.chevronstatus[i])
        {
            if(dtsg.chevronstatus[i])
            {
                mapprintf(LIST_STATUS_CHEVRON_HAUTEUR+i+1,LIST_STATUS_CHEVRON_LARGEUR+2+LEN_AFF_STATUSCHEVRON," Active  ",10);
            }
            else
            {
                mapprintf(LIST_STATUS_CHEVRON_HAUTEUR+i+1,LIST_STATUS_CHEVRON_LARGEUR+2+LEN_AFF_STATUSCHEVRON," Inactif",12);
            }
        }
        dtsg.xchevronstatus[i]=dtsg.chevronstatus[i];
    }
    /// ///////////////////////// Stargate Status ///////////////////////// ///
    if(dtsg.act!=dtsg.xact)
    {
        if(dtsg.act)
        {
            mapprintf(LIST_STATUS_STARGATE_HAUTEUR,LIST_STATUS_STARGATE_LARGEUR+LIST_STATUS_STARGATE_LARGEUR_TEXT," Active  ",10);
        }
        else
        {
            mapprintf(LIST_STATUS_STARGATE_HAUTEUR,LIST_STATUS_STARGATE_LARGEUR+LIST_STATUS_STARGATE_LARGEUR_TEXT," Inactive",12);
        }
        dtsg.xact=dtsg.act;
    }
    /// ///////////////////////// Stargate Command ///////////////////////// ///
    if(dtsg.act)
    {
        if(dtsg.xactvortex!=dtsg.actvortex)
        {
            if(dtsg.actvortex==ACT_VORTEX_ACTIF)  /// vortex en formation ///
            {
                mapprintf(LIST_CMD_STARGATE_HAUTEUR,LIST_CMD_STARGATE_LARGEUR+LIST_CMD_STARGATE_LARGEUR_TEXT,"Vortex en formation    ",LIST_CMD_STARGATE_COLOR_TEXT);
            }else
            if(dtsg.actvortex==ACT_VORTEX_INACTIF)  /// porte désactivée ///
            {
                mapprintf(LIST_CMD_STARGATE_HAUTEUR,LIST_CMD_STARGATE_LARGEUR+LIST_CMD_STARGATE_LARGEUR_TEXT,"Porte Inactif          ",LIST_CMD_STARGATE_COLOR_TEXT);
            }else
            if(dtsg.actvortex==ACT_CHEVRONSERIE_ACTIVATION)  ///  ///
            {
                mapprintf(LIST_CMD_STARGATE_HAUTEUR,LIST_CMD_STARGATE_LARGEUR+LIST_CMD_STARGATE_LARGEUR_TEXT,"Entree des coordonnees ",LIST_CMD_STARGATE_COLOR_TEXT);
            }else
            if(dtsg.actvortex==ACT_VORTEX_STABLE)  ///  ///
            {
                mapprintf(LIST_CMD_STARGATE_HAUTEUR,LIST_CMD_STARGATE_LARGEUR+LIST_CMD_STARGATE_LARGEUR_TEXT,"Vortex Stable          ",LIST_CMD_STARGATE_COLOR_TEXT);
            }else
            if(dtsg.actvortex==ACT_VORTEX_SHUTDOWN)  ///  ///
            {
                mapprintf(LIST_CMD_STARGATE_HAUTEUR,LIST_CMD_STARGATE_LARGEUR+LIST_CMD_STARGATE_LARGEUR_TEXT,"Fermeture du Vortex    ",LIST_CMD_STARGATE_COLOR_TEXT);
            }
        }
        dtsg.xactvortex=dtsg.actvortex;
    }
    else
    {
        if(dtsg.xactvortex!=dtsg.actvortex)
        {
            mapprintf(LIST_CMD_STARGATE_HAUTEUR,LIST_CMD_STARGATE_LARGEUR+LIST_CMD_STARGATE_LARGEUR_TEXT,"Porte Inactive         ",LIST_CMD_STARGATE_COLOR_TEXT);
            dtsg.xactvortex=dtsg.actvortex;
        }
    }
}


Voici le contenu du fichier GraphConio2.h :
Code:

[lang=c]
void DrawCircle(UINT8 ys,UINT8 xs,double r,UINT8 color,UINT8 aff)
{
    int x,d,a;
    for(d=0;d<=r;d++)
    {
        x = (int)sqrt((r*r)-(d*d));
        ///
        PUTC_WITHORIGIN_ONLYINMAP(ys,xs,+d,+x,color,aff);
        PUTC_WITHORIGIN_ONLYINMAP(ys,xs,+d,-x,color,aff);
        PUTC_WITHORIGIN_ONLYINMAP(ys,xs,-d,+x,color,aff);
        PUTC_WITHORIGIN_ONLYINMAP(ys,xs,-d,-x,color,aff);
        for(a=-x;a<=+x;a++)
        {
            PUTC_WITHORIGIN_ONLYINMAP(ys,xs,+d,-a,color,aff);
            PUTC_WITHORIGIN_ONLYINMAP(ys,xs,-d,-a,color,aff);
        }
    }
}


Voici le contenu du fichier Main.c :
Code:
[lang=c]
#include <stdio.h>
#include <stdlib.h>
#include <conio2.h>
#include <time.h>
#include <windows.h>
#include <math.h>


#define TIMETOFRAME 75

#define LARGEURSCR 80
#define HAUTEURSCR 50

#define LARGEURMAP 78
#define HAUTEURMAP 48

#define LARGEURHUDLEFT ((LARGEURMAP/2)-STARGATE_RAYONMAX-2)
#define LARGEURHUDRIGHT ((LARGEURMAP/2)+STARGATE_RAYONMAX+2)
#define HAUTEURHUDLEFT HAUTEURMAP

#define pi 3.141592

#define STARGATE_CHEVRONMAX 9
#define STARGATE_CHEVRONDIST 9.5
#define STARGATE_CHEVRON_COLOR (12)
#define STARGATE_CHEVRON_AFF (219)
#define STARGATE_CHEVRON_INACTIF_AFF (176)
#define STARGATE_RAYONMAX 12
#define STARGATE_RAYONMIN 9
#define STARGATE_EPAISSEUR 4
#define STARGATE_YS (HAUTEURSCR/2)
#define STARGATE_XS (LARGEURSCR/2)

#define changecolor(col) {if(col!=dtg.color) {textcolor(col);dtg.color=col;}}

#define STARGATE_CORPS_ELEMENT_AFF (176+(rand()%2+rand()%2))
#define STARGATE_CORPS_ELEMENT_COLOR (8)

struct _pmap
{
    UINT8 aff,color,actualized;
};

struct _dtsg    /// données de la porte :
{
    UINT8 act,xact;
    time_t timenextchevron;
    time_t timenextanim;
    UINT8 actchevron;
    UINT8 chevronstatus[STARGATE_CHEVRONMAX],xchevronstatus[STARGATE_CHEVRONMAX];
    UINT8 actvortex,xactvortex;
    UINT8 actvortexanim;
    UINT8 cmdvortex;
    UINT8 hudaff;
};
_dtsg dtsg;

struct _dtg
{
    UINT8 actgame,color;
    UINT16 key;
    _pmap map[HAUTEURMAP][LARGEURMAP];
    FILE* file;
};
_dtg dtg;

enum
{
    CMD_NOTHING,
    CMD_SHUTDOWNDEMAND,
} LIST_SGCMD;

#define PUTC(y,x,color,aff) {gotoxy(x+1,y+1);textcolor(color);printf("%c",aff);}

#define PUTC_INMAP(y,x,col,char) {gotoxy(x+1,y+1);changecolor(col);printf("%c",char);dtg.map[y][x].aff=char;dtg.map[y][x].color=col;}
#define PUTC_ONLYINMAP(y,x,col,char) {dtg.map[y][x].aff=char;dtg.map[y][x].color=col;dtg.map[y][x].actualized=0;}
#define PUTC_WITHORIGIN_ONLYINMAP(ys,xs,y,x,col,char) {dtg.map[ys+y][xs+x].aff=char;dtg.map[ys+y][xs+x].color=col;dtg.map[ys+y][xs+x].actualized=0;}

        #define ANGDOSE ((2*pi)/STARGATE_CHEVRONMAX)

#include "GraphConio2.h"
#include "MotorStargate.h"

int main(int argc,char **argv)
{
    srand(clock());
    char tchar[32];time_t nextf;
    sprintf(tchar,"MODE CON COLS=%d LINES=%d",LARGEURSCR,HAUTEURSCR);system(tchar);
    int y=0,x,d,dist,i;
    /// Initialisation de la MAP ///
    for(y=0;y<HAUTEURMAP;y++)
    for(x=0;x<LARGEURMAP;++x)
    {
        dtg.map[y][x].aff=32;
        dtg.map[y][x].color=0;
    }
    dtg.file = fopen("stdout.txt","w");
    /// Initialisation de la Porte ///
    for(i=0;i<STARGATE_CHEVRONMAX;i++)
    {
        dtsg.chevronstatus[i]=0;
        dtsg.xchevronstatus[i]=1;
    }
    dtsg.actvortexanim=-1;
    dtsg.cmdvortex=CMD_NOTHING;
    dtsg.hudaff=0;
    dtsg.xact=5;
    dtsg.xactvortex=-1;

    /// dessin du grand cercle ///
    for(d=0;d<=STARGATE_RAYONMAX;d++)
    {
        #define PUTC_WITHSTARTPOS_INMAP(ys,xs,y,x,col,char) {PUTC_INMAP(ys+y,xs+x,col,char)}
        #define PUTC_INVERTEDYX_WITHSTARTPOS_INMAP(ys,xs,y,x,col,char) {PUTC_INMAP(ys+y,xs+x,col,char)PUTC_INMAP(ys+x,xs+y,col,char)}
        #define PUTC_INVERTEDYX_WITHSTARTPOS_ONLYINMAP(ys,xs,y,x,col,char) {PUTC_ONLYINMAP(ys+y,xs+x,col,char)PUTC_ONLYINMAP(ys+x,xs+y,col,char)}
        dist=(int)sqrt((STARGATE_RAYONMAX*STARGATE_RAYONMAX)-(d*d));

        PUTC_WITHSTARTPOS_INMAP(STARGATE_YS,STARGATE_XS,-dist,-d,STARGATE_CORPS_ELEMENT_COLOR,STARGATE_CORPS_ELEMENT_AFF)
        PUTC_WITHSTARTPOS_INMAP(STARGATE_YS,STARGATE_XS,-d,-dist,STARGATE_CORPS_ELEMENT_COLOR,STARGATE_CORPS_ELEMENT_AFF)
        for(x=-d;x<+d;x++)
        {
            PUTC_INVERTEDYX_WITHSTARTPOS_INMAP(STARGATE_YS,STARGATE_XS,+dist,-x,STARGATE_CORPS_ELEMENT_COLOR,STARGATE_CORPS_ELEMENT_AFF)
            PUTC_INVERTEDYX_WITHSTARTPOS_INMAP(STARGATE_YS,STARGATE_XS,-dist,+x,STARGATE_CORPS_ELEMENT_COLOR,STARGATE_CORPS_ELEMENT_AFF)
        }
        PUTC_WITHSTARTPOS_INMAP(STARGATE_YS,STARGATE_XS,-dist,+d,STARGATE_CORPS_ELEMENT_COLOR,STARGATE_CORPS_ELEMENT_AFF)
        /// ys - dist, xs - d
        /// de xs-d à xs+d
    }

    /// dessin du petit cercle ///
    for(d=0;d<=STARGATE_RAYONMIN;d++)
    {
        dist=(int)sqrt((STARGATE_RAYONMIN*STARGATE_RAYONMIN)-(d*d));
        for(x=-d;x<+d;x++)
        {
            PUTC_INVERTEDYX_WITHSTARTPOS_INMAP(STARGATE_YS,STARGATE_XS,+dist,-x,15,32) /// on efface cette partie
            PUTC_INVERTEDYX_WITHSTARTPOS_INMAP(STARGATE_YS,STARGATE_XS,-dist,+x,15,32) /// on efface cette partie
        }
    }

    //// remplisage entre les deux cercles :
    /// fixation des chevron sur le corps de la porte :
    for(i=0;i<STARGATE_CHEVRONMAX;i++)
    {
        PUTC_WITHORIGIN_ONLYINMAP(STARGATE_YS,STARGATE_XS,(int)(STARGATE_CHEVRONDIST*sin(ANGDOSE*i-pi/2)),(int)(STARGATE_CHEVRONDIST*cos(ANGDOSE*i-pi/2)),STARGATE_CHEVRON_COLOR,STARGATE_CHEVRON_INACTIF_AFF);
    }
    /// on efface l'écran  :
    clrscr();
    for(y=0;y<HAUTEURMAP;y++)
    {
        for(x=0;x<LARGEURMAP;x++)
        {
            dtg.map[y][x].actualized=1;
            textcolor(dtg.map[y][x].color);
            printf("%c",dtg.map[y][x].aff);
        }
        printf("\n");
    }

    dtg.actgame=1;dtsg.act=0;dtsg.timenextchevron=-1;dtsg.xactvortex=-1;
    while(dtg.actgame)
    {
        for(y=0;y<HAUTEURMAP;y++)
        {
            for(x=LARGEURHUDLEFT;x<LARGEURHUDRIGHT;x++)
            {
                if(dtg.map[y][x].actualized!=1)
                {
                    PUTC_INMAP(y,x,dtg.map[y][x].color,dtg.map[y][x].aff)
                    dtg.map[y][x].actualized=1;
                    for(;x<LARGEURHUDRIGHT;x++)
                    {
                        PUTC_INMAP(y,x,dtg.map[y][x].color,dtg.map[y][x].aff)
                        dtg.map[y][x].actualized=1;
                    }
                }
            }
            for(x=0;x<LARGEURHUDLEFT;x++) /// gestion de l'affichage de l'HUD gauche ///
            {
                if(dtg.map[y][x].actualized!=1)
                {
                    PUTC_INMAP(y,x,dtg.map[y][x].color,dtg.map[y][x].aff)
                    dtg.map[y][x].actualized=1;
                    for(;x<LARGEURHUDLEFT;x++)
                    {
                        PUTC_INMAP(y,x,dtg.map[y][x].color,dtg.map[y][x].aff)
                        dtg.map[y][x].actualized=1;
                    }
                }
            }
            for(x=LARGEURHUDRIGHT;x<LARGEURMAP;x++) /// gestion de l'affichage de l'HUD gauche ///
            {
                if(dtg.map[y][x].actualized!=1)
                {
                    PUTC_INMAP(y,x,dtg.map[y][x].color,dtg.map[y][x].aff)
                    dtg.map[y][x].actualized=1;
                    for(;x<LARGEURMAP;x++)
                    {
                        PUTC_INMAP(y,x,dtg.map[y][x].color,dtg.map[y][x].aff)
                        dtg.map[y][x].actualized=1;
                    }
                }
            }
        }
        nextf=clock()+TIMETOFRAME;dtg.key=0;
        while(clock()<nextf)
        {
            while(kbhit())
            {
                dtg.key=getch();
            }
        }
        switch(dtg.key)
        {
            case 27:
                dtg.actgame=0;
                break;
            case 48:
            case 49:
            case 50:
            case 51:
            case 52:
            case 53:
            case 54:
            case 55:
            case 56:
            case 57:
                i=dtg.key-48;
                PUTC_WITHORIGIN_ONLYINMAP(STARGATE_YS,STARGATE_XS,(int)(STARGATE_CHEVRONDIST*sin(ANGDOSE*i-pi/2)),(int)(STARGATE_CHEVRONDIST*cos(ANGDOSE*i-pi/2)),STARGATE_CHEVRON_COLOR,STARGATE_CHEVRON_AFF);
                break;
            case 13:
                if(dtsg.act)
                {
                    dtsg.cmdvortex=CMD_SHUTDOWNDEMAND;
                }
                else
                dtsg.act=1;
                break;
            case 112:
                getch();
                break;
            default:
                break;
        }
        sprintf(tchar,"TITLE Stargate par Groovitron");system(tchar);
        MotorStargate();
        MotorHUD();
    }
    gotoxy(1,HAUTEURMAP);
}



Pour avoir un petit aperçu :

Captures :











Dernière édition par Groovitron le Mar 14 Aoû 2012 - 15:00; édité 3 fois
Message Publicité 
PublicitéSupprimer les publicités ?


Répondre en citant
Message [C#] Un simulateur de porte des étoiles 
Bravo excellent je suis une fan de stargate Okay Okay




______________________________________________________
Faites paraitre votre batch sur BatchClipboard
Visiter le site web du posteur
Répondre en citant
Message [C#] Un simulateur de porte des étoiles 
Trop beau ! Cool

Par contre peux-tu poster le code source s'il te plait ? Je ne peut pas le voir sur mon smartphone.




______________________________________________________
Répondre en citant
Message [C#] Un simulateur de porte des étoiles 
Pas de soucis, je le met de suite.



Répondre en citant
Message [C#] Un simulateur de porte des étoiles 
Merci.

Au fait, c'est du C. Je croyais que c'était du batch avec des commandes externes Arrow Je déplace.




______________________________________________________
Répondre en citant
Message [C#] Un simulateur de porte des étoiles 
Le projet n'est pas en C# mais en C++ car l'extention est .cpp (C++ source file) et .h (C/C++ Header file) alors qu'en C# l'extention est .cs (CSharp classes file).




______________________________________________________
Partager permet le savoir. Le savoir permet de partager de nouveau savoirs.
Message [C#] Un simulateur de porte des étoiles 


Montrer les messages depuis:
Répondre au sujet Page 1 sur 1
  



Index | créer un forum | Forum gratuit d’entraide | Annuaire des forums gratuits | Signaler une violation | Conditions générales d'utilisation
Copyright 2008 - 2016 // Batch