Research: [RUBY] IV/EV Viewer

#include "include/gba_types.h"
#include "include/gba_keys.h"

//definizione di alcuni offset utili
#define StartROM	0x08700000
#define TIMER		((u8*)0x02024F50)
#define PALRAM		((u16*)0x0202EEC8)
#define PALFADE		((u16*)0x0202EAC8)
#define CANVAS		((u32*)0x0600CC80)
#define RAW		((u16*)0x0600F9A0)
#define BLANK		0xEEEEEEEE
#define STATS		((u32*)0x08710000)
#define AMOUNT		(*(u8*)0x03004350)
#define FIRST_SLOT	0x03004360
#define SIZE_OF_SLOT	100
#define HP		0x27		//IV
#define HP_2		0x1A		//EV
#define BACKGROUND_PAL 	0x77BD
#define BUFFER		0x02024F80

#define DEFAULT 0	//1 se si vuole mantenere la grafica originale di pokémon rubino
#define ISTO	1	//1 se si vuole l'istogramma come metodo di visualizzazione delle IV/EV

#if ISTO		//se voglio l'istogramma
	#define SX	0x58
	#define SY	0x28
	#define SHIFT	0x88
#endif

/*
table STATS
EB F7 40 08 10 00 98 00 D9 F7 40 08 38 00 C8 00
E1 F7 40 08 58 00 C8 00 D5 F7 40 08 70 00 90 00
DD F7 40 08 58 00 58 00 E5 F7 40 08 38 00 58 00
*/

//dichiarazione dei prototipi delle funzioni

//protitipi per grafico con espansione
void initCanvas(u8 page);
void drawCanvas();
void setPixel(u8 x, u8 y, u8 color);
int getPixel(u8 x, u8 y);
void drawLine(u8 x1, u8 y1, u8 x2, u8 y2, u8 color);
void paintArea(u8 x1, u8 y1, u8 x2, u8 y2, u8 color);
void swap(u8* a, u8* b);

//protitipi per grafico con espansione
void drawBar(u8 x, u8 y, u8 value);
void vid_vsync();

//protitipi generali
int div(u32 a, u32 b);
int mod(u32 a, u32 b);
int module(int a);
void printString(u32 offset, u8 x, u8 y);
int getPokemonData(u32 slot, u8 field, u8 zero);
int getMonGender(u32 slot);
void intToString(u32 buffer, u32 number);
void printString2(u32 buffer, u8 x, u8 y);
void printString3(u32 string, u8 x, u8 y, u8 color);
void printString4(u32 string, u8 x, u8 y, u8 color);
void refreshInfo(u8 current, u8 page);
void showbox(u8 x, u8 y, u8 L, u8 H);
void hidebox(u8 x, u8 y, u8 L, u8 H);
int maxValue(int arr[]);
int minValue(int arr[]);
void pic(u8 zero, u8 x, u8 y);
void closePic();
u32 oam(u32 value);
void sound(u16 s);
void cry(u16 cr);
void callback(void* addr);
void LZ77UnCompVram(u32 source, u32 dest);
void CpuFastSet(u32 source, u32 dest, u32 size);

void main();
void main2();

/*
Primo main, utilizzato per:
- visualizzare l'immagine del primo pokémon in squadra mediante la funzione pic().
- setto il TIMER a 0
- richiamo il secondo main
*/
void main()
{
    pic(getPokemonData(FIRST_SLOT, 0xB, 0), 0, 6);
    TIMER[0] = 0;
    callback((void*)(StartROM + main2 + 1));
}

/*
Secondo main, Il TIMER menzionato in precedenza serve per scandire due fasi:
- la prima, in cui verrà corretta la paletta dello sprite visualizzato attraverso pic()
- la seconda, il cui compito principale è quello di ricevere gli input da parte dell'utente ed elaborarli
*/
void main2()
{
    //seconda fase
    if (TIMER[0] == 0x2) {
        //current indica lo slot pokémon in cui ci si trova attualmente
        //pageIV, 0 visualizzazione IV, 1 visualizzazione EV
        int current = 0, pageIV = 0;

        refreshInfo(current, pageIV);

        //ciclo while per ricevere gli input dei tasti
        while (keyDown(KEY_B))
            ;
        while (!keyDown(KEY_B)) {
            if (keyDown(KEY_DOWN)) {
                while (keyDown(KEY_DOWN))
                    ;
                if (current < (AMOUNT - 1)) {
                    sound(5);
                    current++;
                    refreshInfo(current, pageIV);
                }
            }
            else if (keyDown(KEY_UP)) {
                while (keyDown(KEY_UP))
                    ;
                if (current > 0) {
                    sound(5);
                    current--;
                    refreshInfo(current, pageIV);
                }
            }
            else if (keyDown(KEY_RIGHT)) {
                while (keyDown(KEY_RIGHT))
                    ;
                if (!pageIV) {
                    sound(5);
                    pageIV = 1;
                    refreshInfo(current, pageIV);
                }
            }
            else if (keyDown(KEY_LEFT)) {
                while (keyDown(KEY_LEFT))
                    ;
                if (pageIV) {
                    sound(5);
                    pageIV = 0;
                    refreshInfo(current, pageIV);
                }
            }
        }
        //una volta chiuso il menu con il tasto B, elimino lo sprite e pulisco il BG
        closePic();
        hidebox(0, 0, 0x1E, 0x13);
        //ripristino il callback con il valore originale
        callback((void*)0x0807CA35);
    }
    else if (TIMER[0] == 1) //prima fase
    {
        //ricerco lo sprite all'interno della ram
        u32 sprite = oam((*(u32*)0x07000000));
        //correggo la paletta dell'oam
        (*(u16*)(sprite + 4)) = ((*(u16*)(sprite + 4)) & 0xFFF) | 0xE000;

#if !DEFAULT
        CpuFastSet(0x08XXXXXX, 0x0202F068, 8); //palette
        CpuFastSet(0x08XXXXXX, 0x0202EE68, 8); //palette
        LZ77UnCompVram(0x08YYYYYY, 0x0600D480); //tile
        (*(u16*)0x0202F0A4) = BACKGROUND_PAL;
        (*(u16*)0x0202EEA4) = BACKGROUND_PAL;
        (*(u16*)0x0202F0C6) = BACKGROUND_PAL;
        (*(u16*)0x0202EEC6) = BACKGROUND_PAL;
#endif

#if ISTO
        CpuFastSet(0x08ZZZZZZ, 0x0600CC80, 0x30);
#endif
        TIMER[0]++;
    }
    else
        TIMER[0]++;
}

//Funzione che si occupa dell'aggiornamento delle informazioni
void refreshInfo(u8 current, u8 page)
{
    int x, y, statValues[6], points[2][7], progressPoints[2][7];

#if DEFAULT
    showbox(0, 0, 0x1D, 0x13);
#else
    CpuFastSet(0x08KKKKKK, 0x0600F800, 0x140); //raw totale
    if (page)
        CpuFastSet(0x08JJJJJJ, 0x0600F800, 0x20); //raw barra page EV
#endif

#if !ISTO
    //funzione utilizzata per inizializzare il riquadro su cui verrà disegnato il grafico
    initCanvas(page);
    //visualizzo il riquadro
    drawCanvas();
#endif

    //riempio array con le IV o EV del pokemon
    for (x = 0; x < 6; x++)
        statValues[x] = getPokemonData(FIRST_SLOT + (current * SIZE_OF_SLOT), (!page ? HP + x : HP_2 + x), 0);

    //flag utilizzate per colorare solamente una singola statistica, nel caso un cui ci fossero più statistiche con lo stesso valore minimo/massimo
    int maxSet = 0, minSet = 0;
    //ottengo il valore massimo e minimo delle IV/EV
    //questo mi servirà per andare a colorare di rosso/blu la statistica minima/massima
    int max = maxValue(statValues);
    int min = minValue(statValues);

//print stringhe e valori IV/EV
#if !ISTO
    for (x = 0; x < 6; x++) {
        if (((statValues[x] != max) || maxSet) && ((statValues[x] != min) || minSet))
            printString(STATS[(x << 1)], (STATS[(x << 1) + 1] >> 16), STATS[(x << 1) + 1] & 0xFFFF);
        else {
            if ((statValues[x] == max) && !maxSet) {
                printString4(STATS[(x << 1)], (STATS[(x << 1) + 1] >> 16), STATS[(x << 1) + 1] & 0xFFFF, 0x4);
                maxSet = 1;
            }
            else if (!minSet) {
                printString4(STATS[(x << 1)], (STATS[(x << 1) + 1] >> 16), STATS[(x << 1) + 1] & 0xFFFF, 0x2);
                minSet = 1;
            }
        }

        intToString(BUFFER, statValues[x]);
        printString2(BUFFER, ((STATS[(x << 1) + 1] >> 16) >> 3) + 3 - (!x ? 2 : 0) - ((x) && (x < 3) ? 1 : 0), ((STATS[(x << 1) + 1] & 0xFFFF) >> 3) + 2);
    }
#else //ISTOGRAMMA
    for (x = 0; x < 6; x++) {
        if (((statValues[x] != max) || maxSet) && ((statValues[x] != min) || minSet))
            printString(STATS[(x << 1)], SX, SY + (x << 4));
        else {
            if ((statValues[x] == max) && !maxSet) {
                printString4(STATS[(x << 1)], SX, SY + (x << 4), 0x4);
                maxSet = 1;
            }
            else if (!minSet) {
                printString4(STATS[(x << 1)], SX, SY + (x << 4), 0x2);
                minSet = 1;
            }
        }

        intToString(BUFFER, statValues[x]);
        printString2(BUFFER, (SX >> 3) + (SHIFT >> 3), (SY >> 3) + (x << 1));
    }
#endif

    //print numero pokémon attuale
    intToString(BUFFER, (current + 1));
    intToString(BUFFER + 2, AMOUNT);
    (*(u8*)(BUFFER + 1)) = 0xBA; // char '/'
    printString2(BUFFER, 4, 0x10);

#if DEFAULT
    if (!page)
        printString2(0x081F502F, 28, 2);
    else
        printString2(0x0840303A, 28, 2);
#endif

    //ottengo tutti i dati del pokemon che sto tentando di visualizzare e i dati relativi all'oam
    u32 sprite = oam((*(u32*)0x07000000));
    u16 specie = getPokemonData(FIRST_SLOT + (current * SIZE_OF_SLOT), 0xB, 0);
    u8 gender = getMonGender(FIRST_SLOT + (current * SIZE_OF_SLOT));
    u32 tile = ((*(u16*)(sprite + 4)) & 0xFFF);
    u32 pal = ((((*(u16*)(sprite + 4)) & 0xF000) >> 12) << 5) + 0x0202F0C8;

    //update dello sprite del pokemon e print del nome, sesso e livello del pokemon
    if (!getPokemonData(FIRST_SLOT + (current * SIZE_OF_SLOT), 0x2D, 0)) {
        LZ77UnCompVram((*(u32*)(0x081E8354 + (specie << 3))), ((tile << 5) + 0x06010000));
        LZ77UnCompVram((*(u32*)(0x081EA5B4 + (specie << 3))), pal);
        printString2((FIRST_SLOT + 8) + (current * SIZE_OF_SLOT), 8, 2);
        if (!gender) {
            printString3(0x0820C33D, 3, 4, 0xE);
        }
        else if (gender == 0xFE) {
            printString3(0x0820C33F, 3, 4, 2);
        }

        printString2(0x081005C6, 5, 4); //LV
        intToString(BUFFER, (*(u8*)(FIRST_SLOT + (current * SIZE_OF_SLOT) + 0x54)));
        printString2(BUFFER, 8, 4);
        cry(specie);
    }
    else //nel caso in cui fosse un uovo
    {
        for (x = 0; x < 0x200; x++)
            (*(u32*)((tile << 5) + 0x06010000 + (x << 2))) = 0;
        for (x = 0; x < 4; x++)
            CpuFastSet(0x08209AF8 + (x << 7), ((tile << 5) + 0x06010240) + (x << 8), 0x20);
        CpuFastSet(0x08209AD8, pal, 8);
        printString2(0x083B26B0, 8, 2);
    }

#if !ISTO //GRAFICO CON ESPANSIONE
    //calcolo punti grafo
    for (x = 0; x < 6; x++) {
        if (!x) {
            //sopra
            points[0][x] = 31;
            if (!page)
                points[1][x] = 21 - div((21 * statValues[x]), 31);
            else
                points[1][x] = 21 - (div((21 * statValues[x]), 31) >> 3);

            progressPoints[0][x] = 31;
            progressPoints[1][x] = 21;
        }
        else if (x == 3) {
            //sotto
            points[0][x] = 31;
            if (!page)
                points[1][x] = 41 + div((21 * statValues[x]), 31);
            else
                points[1][x] = 41 + (div((21 * statValues[x]), 31) >> 3);
            progressPoints[0][x] = 31;
            progressPoints[1][x] = 41;
        }
        else if (x < 3) {
            //destra
            if (!page)
                points[0][x] = 32 + statValues[x];
            else
                points[0][x] = 32 + (statValues[x] >> 3);
            points[1][x] = 21 + ((1 - mod(x, 2)) * 21);

            progressPoints[0][x] = 32;
            progressPoints[1][x] = points[1][x];
        }
        else {
            //sinistra
            if (!page)
                points[0][x] = 31 - statValues[x];
            else
                points[0][x] = 31 - (statValues[x] >> 3);
            points[1][x] = 21 + ((1 - mod(x, 2)) * 21);

            progressPoints[0][x] = 31;
            progressPoints[1][x] = points[1][x];
        }
    }

    //ricopio il primo punto del grafo
    //questo mi permette di avere un riferimento circolare tra i punti, utile per alleggerire il ciclo for
    points[0][6] = points[0][0];
    points[1][6] = points[1][0];
    progressPoints[0][6] = points[0][0];
    progressPoints[1][6] = points[1][0];

    //nel caso stia visualizzando le EV, riduco la scala di visualizzazione di 8 (shift >> 3).
    if (page)
        max = max >> 3;

    //animazione grafo
    for (y = 0; y < max; y++) {
        for (x = 0; x < 6; x++) {
            drawLine(progressPoints[0][x], progressPoints[1][x], progressPoints[0][x + 1], progressPoints[1][x + 1], 1);
            if (!x) {
                if (progressPoints[1][x] > points[1][x])
                    progressPoints[1][x]--;
                progressPoints[0][6] = progressPoints[0][0];
                progressPoints[1][6] = progressPoints[1][0];
            }
            else if (x == 3) {
                if (progressPoints[1][x] < points[1][x])
                    progressPoints[1][x]++;
            }
            else if (x < 3) {
                if (progressPoints[0][x] < points[0][x])
                    progressPoints[0][x]++;
            }
            else {
                if (progressPoints[0][x] > points[0][x])
                    progressPoints[0][x]--;
            }
            paintArea(progressPoints[0][x], progressPoints[1][x], progressPoints[0][x + 1], progressPoints[1][x + 1], 1);
        }
    }
#else //ISTOGRAMMA
    int progressStat[6] = { 0, 0, 0, 0, 0, 0 };
    if (page)
        max = max >> 3;

    for (y = 0; y <= max; y++) {
        vid_vsync();
        for (x = 0; x < 6; x++) {
            drawBar((SX >> 3) + 5, (SY >> 3) + (x << 1), progressStat[x]);
            if (progressStat[x] < statValues[x])
                progressStat[x]++;
        }
    }
#endif
}

#if !ISTO
/*
Funzione utilizzata per disegnare una retta all'interno del riquadro
Suddivisione in 3 casi:
- rette orizzontali
- rette verticali
- rette completamente verticali
*/
void drawLine(u8 x1, u8 y1, u8 x2, u8 y2, u8 color)
{
    u8 add = 0;
    u8 lastMod = 0;
    int x, y;
    if (x2 < x1) {
        swap(&x1, &x2);
        swap(&y1, &y2);
    }
    int coeff = div(((y2 - y1)), ((x2 - x1)));
    int coeff_2 = mod(((y2 - y1)), ((x2 - x1)));

    if (x1 == x2) {
        //caso speciale, retta completamente verticale
        if (y2 < y1)
            swap(&y1, &y2);
        for (y = y1; y <= y2; y++)
            setPixel(x1, y, color);
    }
    else if (coeff == 0) {
        //rette orizzontali
        u8 segment = module(y2 - y1) + 1;
        u8 len = div((x2 - x1), segment);
        u8 modd = mod((x2 - x1), segment);
        u8 adding = div(segment, modd);
        int yDec = (y1 <= y2) ? 1 : -1;
        for (y = y1; (((yDec == 1) && (y <= y2)) ? 1 : 0) || (((yDec != 1) && (y >= y2)) ? 1 : 0); y += yDec) {
            for (x = (x1 + (module(y - y1) * len) + lastMod); x < ((x1 + len) + (module(y - y1) * len) + ((modd && (!mod(add, adding))) ? 1 : 0) + lastMod); x++) {
                setPixel(x, y, color);
            }
            if (!mod(add, adding)) {
                if (modd > 0) {
                    lastMod++;
                    modd--;
                }
            }

            add++;
        }
        setPixel(x2, y2, color);
    }
    else {
        //rette verticali
        if (coeff <= 0) {
            swap(&x1, &x2);
            swap(&y1, &y2);
        }
        u8 segment = module(x2 - x1) + 1;
        u8 len = div((y2 - y1), segment);
        u8 modd = mod((y2 - y1), segment);
        u8 adding = div(segment, modd);
        int xDec = (coeff > 0) ? 1 : -1;
        for (x = x1; (((xDec == 1) && (x <= x2)) ? 1 : 0) || (((xDec != 1) && (x >= x2)) ? 1 : 0); x += xDec) {
            for (y = (y1 + (module(x - x1) * len) + lastMod); y < ((y1 + len) + (module(x - x1) * len) + ((modd && (!mod(add, adding))) ? 1 : 0) + lastMod); y++) {
                setPixel(x, y, color);
            }

            if (!mod(add, adding)) {
                if (modd > 0) {
                    lastMod++;
                    modd--;
                }
            }

            add++;
        }
        setPixel(x2, y2, color);
    }
}

void initCanvas(u8 page)
{
    int x;
    for (x = 0; x < 0x200; x++)
        CANVAS[x] = BLANK;
    drawLine(31, 0, 31, 63, 8);
    drawLine(32, 0, 32, 63, 8);
    drawLine(0, 21, 63, 21, 8);
    drawLine(0, 42, 63, 42, 8);
}

void drawCanvas()
{
    int x, y;
    for (y = 0; y < 8; y++) {
        for (x = 0; x < 8; x++) {
            RAW[x + ((y << 6) >> 1)] = (0xE264 + (x + (y << 3)));
        }
    }
}

int getPixel(u8 x, u8 y)
{
    u8 shift = ((x - ((x >> 3) << 3)) << 2);
    u32 offset = (((x >> 3) << 5) >> 2) + (((y >> 3) << 8) >> 2) + (y - ((y >> 3) << 3));
    u32 lastValue = CANVAS[offset];
    return ((lastValue & (0xF << shift)) >> shift);
}

void setPixel(u8 x, u8 y, u8 color)
{
    u8 shift = ((x - ((x >> 3) << 3)) << 2);
    u32 offset = (((x >> 3) << 5) >> 2) + (((y >> 3) << 8) >> 2) + (y - ((y >> 3) << 3));
    u32 lastValue = CANVAS[offset];
    u32 mask = (lastValue & (~(0xF << shift)));
    CANVAS[offset] = mask | ((color & 0xF) << shift);
}

void paintArea(u8 x1, u8 y1, u8 x2, u8 y2, u8 color)
{
    int x, y, first[2], last[2], boolFirst = 0;
    //apparentemente la funzine swap è parecchio onerosa
    //if (y2 < y1) swap(&y1, &y2);
    //if (x2 < x1) swap(&x1, &x2);

    int xDec = (x1 <= x2) ? 1 : -1;
    int yDec = (y1 <= y2) ? 1 : -1;
    for (y = y1; y != y2; y += yDec) {
        for (x = x1;
             (x != x2); x += xDec) {
            if (getPixel(x, y) == color) {
                if (!boolFirst) {
                    first[0] = x;
                    first[1] = y;
                }
                else {
                    last[0] = x;
                    last[1] = y;
                }
                boolFirst++;
            }
        }
        if (boolFirst > 1)
            drawLine(first[0], first[1], last[0], last[1], 1);
        boolFirst = 0;
    }
}

void swap(u8* a, u8* b)
{
    u8 temp = *a;
    *a = *b;
    *b = temp;
}

#else //ISTOGRAMMA, funzioni di visualizzazione
void drawBar(u8 x, u8 y, u8 value)
{
    if (value >= 31)
        value = 32;
    u8 full = (value >> 2);
    u8 rest = mod(value, 4);
    int i, k;
    for (k = 0; k < 2; k++) {
        u32 SRAW = 0x0600F800 + (x << 1) + (y << 6);
        (*(u16*)(SRAW + (k << 6))) = 0xE269 | (k << 11); 				//bordo sinistra
        SRAW += 2;
        for (i = 0; i < full; i++)
            (*(u16*)(SRAW + (i << 1) + (k << 6))) = 0xE268 | (k << 11); 		//tile pieno
        if (full < 8)
            (*(u16*)(SRAW + (full << 1) + (k << 6))) = (0xE264 + rest) | (k << 11); 	//tile resto
        for (i = (full + 1); i < 8; i++)
            (*(u16*)(SRAW + (i << 1) + (k << 6))) = 0xE264 | (k << 11); //tile vuoto
        //(*(u16*)(SRAW+(8<<1)+(k<<6))) = 0xE269 | (k<<11) | 0x400;			//bordo destra
    }
}

void vid_vsync()
{
    __asm("SWI 0x5");
}
#endif

int div(u32 a, u32 b)
{
    int (*func)(void) = (int (*)(void))0x081E0868 + 1;
    return func();
}

int mod(u32 a, u32 b)
{
    int (*func)(void) = (int (*)(void))0x081E0F08 + 1;
    return func();
}

int module(int a)
{
    if (a >= 0)
        return a;
    return (-a);
}

void printString(u32 offset, u8 x, u8 y)
{
    int (*func)(void) = (int (*)(void))0x08072A18 + 1;
    func();
}

int getPokemonData(u32 slot, u8 field, u8 zero)
{
    int (*func)(void) = (int (*)(void))0x0803CB60 + 1;
    return func();
}

int getMonGender(u32 slot)
{
    int (*func)(void) = (int (*)(void))0x0803C4B8 + 1;
    return func();
}

void intToString(u32 buffer, u32 number)
{
    int (*func)(void) = (int (*)(void))0x08006DDC + 1;
    func();
}

void printString2(u32 buffer, u8 x, u8 y)
{
    int (*func)(void) = (int (*)(void))0x08072B4C + 1;
    func();
}

void copyString(u32 offset, u32 offset_2)
{
    int (*func)(void) = (int (*)(void))0x08006AB0 + 1;
    func();
}

void printString3(u32 string, u8 x, u8 y, u8 color)
{
    (*(u16*)BUFFER) = 0x01FC;
    (*(u16*)(BUFFER + 2)) = color;
    copyString(BUFFER + 3, string);
    printString2(BUFFER, x, y);
}

void printString4(u32 string, u8 x, u8 y, u8 color)
{
    (*(u16*)BUFFER) = 0x01FC;
    (*(u16*)(BUFFER + 2)) = color;
    copyString(BUFFER + 3, string);
    printString(BUFFER, x, y);
}

void showbox(u8 x, u8 y, u8 L, u8 H)
{
    int (*func)(u8, u8, u8, u8) = (int (*)(void))0x08071F08 + 1;
    func(x, y, L, H);
}

void hidebox(u8 x, u8 y, u8 L, u8 H)
{
    int (*func)(u8, u8, u8, u8) = (int (*)(void))0x08071E84 + 1;
    func(x, y, L, H);
}

void cry(u16 cr)
{
    int (*func)(u16) = (int (*)(void))0x08075178 + 1;
    func(cr);
}

void sound(u16 s)
{
    int (*func)(u16) = (int (*)(void))0x08075494 + 1;
    func(s);
}

void pic(u8 zero, u8 x, u8 y)
{
    int (*func)(u8, u8, u8) = (int (*)(void))0x080B58C4 + 1;
    func(zero, x, y);
}

void closePic()
{
    int (*func)(void) = (int (*)(void))0x080B5974 + 1;
    func();
}

u32 oam(u32 value)
{
    int i = 0;
    while ((*(u32*)(0x02020004 + (i * 0x44))) != value)
        i++;
    return (0x02020004 + (i * 0x44));
}

void callback(void* addr)
{
    (*(u32*)0x03004B20) = (u32)addr;
}

void LZ77UnCompVram(u32 source, u32 dest)
{
    __asm("SWI 0x12");
}

void CpuFastSet(u32 source, u32 dest, u32 size)
{
    __asm("SWI 0xC");
}

int maxValue(int arr[])
{
    int i, max = 0;
    for (i = 0; i < 6; i++)
        if (arr[i] > max)
            max = arr[i];
    return max;
}

int minValue(int arr[])
{
    int i, min = arr[0];
    for (i = 1; i < 6; i++)
        if (arr[i] < min)
            min = arr[i];
    return min;
}