root/sovereignty/evemap.c @ 246

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct
{
    int alliance;
    double inf;
    struct influence *next;
} influence;

typedef struct
{
    int x;
    struct influence *inf;
    struct System *next;
} System;

typedef struct
{
    signed int y;
    struct System *fields;
    struct row *next;
} row;

typedef System *SystemPointer;
typedef influence *influencePointer;
typedef row *rowPointer;

System *sCur;
System *sTop;
System *sFirst;
row *bFirst;
row *rFirst;
row *rCur;

influencePointer iLast;
influencePointer iCur;

int pow_10(int base, int exp)
{
     int result, i;
    result = base;
    exp--;
    for (i=0; i<exp; i++)
    {
        result *= base;
    }
    return result;
} 
 
double charToFloat(char *string)
{
    float result;
    int i, fCount, fVar, sLen, fract;

    result = atoi(string);
     
    fVar = 0;
    fCount = 0;
    sLen = strlen(string);
    for (i=0; i<sLen; i++)
    {
        if (string[i] == '.')
            break;
    }
    i++;
    fract = atoi(&string[i]);
      
    if (fract != 0)
    {
        fCount = strlen(&string[i]); 
        result += (double)fract/pow_10(10, fCount);
        //printf("[%d^%d -> %d]\n", fract, fCount, pow(10, fCount)); 
    }
    //printf("<> %f %d %s\n", result, fVar, string);
    
    return result;
} 
 
int main()
{
    FILE *f;
    char s[1000];
    char *pch;
    SystemPointer sp;
    influencePointer ip;
    rowPointer rp;
    int sH, sW, sS, sA, pC;
    int tempy, sR, i;
    double sV;
    
    pC = 0;

    f = fopen("evemap_systems.data", "r");
    if (!f)
        return 1;
    
    // fwrite($fp, 'c '.$opt['height'].' '.$opt['width'].' '.$opt['maxrange'].' '.$opt['sensitivity'].' '.$opt['validInf']."\r\n");
    fgets(s, 1000, f);

    pch = (char*)strtok (s, " ");
    pch = (char*)strtok (NULL, " ");
    sH = atoi(pch);
    pch = (char*)strtok (NULL, " ");
    sW = atoi(pch);
    pch = (char*)strtok (NULL, " ");
    sR = atoi(pch);
    pch = (char*)strtok (NULL, " ");
    sS = atoi(pch);
    pch = (char*)strtok (NULL, " ");
    sV = charToFloat(pch);
    pch = (char*)strtok (NULL, " ");
    sA = atoi(pch);    
    
    while (fgets(s, 1000, f) != NULL)
    {
        pch = (char*)strtok (s, " ");
        while (pch != NULL)
        {
            if (strcmp("s", pch) == 0)
            {
                sp = (System *)malloc(sizeof(System)); pC++;
                pch = (char*)strtok (NULL, " ");
                sp->x = atoi(pch);
                pch = (char*)strtok (NULL, " ");
                tempy = atoi(pch);
                
                // create the first row
                if (rCur == NULL)
                {
                    rp = (row *)malloc(sizeof(row)); pC++;
                    rp->y = tempy;
                    rCur = rp;
                    rFirst = rp;
                    rCur->fields = (struct System *)sp;
                    sFirst = sp;
                }
                // create another row, we got more y!
                if (rCur->y != tempy)
                {
                    rp = (row *)malloc(sizeof(row)); pC++;
                    rp->y = tempy;
                    rCur->next = (struct row*)rp;
                    rCur = (row*)rCur->next;
                    rCur->fields = (struct System *)sp;
                    sFirst = sp;
                    sTop = NULL;
                }
                //printf ("%d %d\n", sp->x, sp->y);
                /*if (sFirst == NULL)
                {
                    sFirst = sp;
                } */
                if (sTop != NULL)
                {
                    sTop->next = (struct System*)sp;
                }  
                sTop = sp;
                iLast = NULL;
            }
            if (strcmp("i", pch) == 0)
            {
                ip = (influencePointer)malloc(sizeof(influence)); pC++;
                pch = (char*)strtok (NULL, " ");
                ip->alliance = atoi(pch);
                pch = (char*)strtok (NULL, " ");
                ip->inf = charToFloat(pch);
                //printf ("%d %.2lf", ip->alliance, ip->inf); 
                if (iLast != NULL)
                {
                    iLast->next = (struct influence*)ip;
                    iLast = ip;
                }
                else
                {
                    sTop->inf = (struct influence*)ip;
                    iLast = (influence*)sTop->inf;
                }                
            }            
            pch = (char*)strtok (NULL, " ");
        }
    }
    fclose(f);
     
    int range, dist; 
    int dx, dy, bestA, y, x;
    range = sR*sR;
    
    float influence[sA], bestI;
    for (i = 0; i < sA; i++)
    {
        influence[i] = 0;
    }
    bFirst = rFirst;
    
    for (y = 0; y < sH; y++)
    {
        // iterate to the first needed item
        rCur = bFirst;
        while (rCur != NULL) 
        {
            if (y - rCur->y <= sR)
            {
                bFirst = rCur;
                break;
            }
            rCur = (row*)rCur->next;
        }
        //printf("line: %d, first y: %d\n", y, rFirst->y);
 
        for (x = 0; x < sW; x++)
        {
            //printf("pixel: %d,%d\n", x, y);
            // iterate through all rows
            rCur = bFirst;
            while (rCur != NULL)
            {
                if (rCur->y - y > sR)
                {
                    break;
                }
                
                sCur = (System*)rCur->fields;
                while (sCur != NULL)
                {
                    if (x - sCur->x > sR)
                    {
                        //printf("skipping: %d,%d - %d,%d\n", x, y, sCur->x, rCur->y);
                        sCur = (System*)sCur->next; 
                        continue;
                    }
                    //printf("noskip: %d,%d - %d,%d\n", x, y, sCur->x, rCur->y);                 
                    if (sCur->x - x > sR)
                    {
                        break;
                    }                
                    dy = y - rCur->y;            
                    dx = x - sCur->x;
                    dist = dx*dx + dy*dy;
                    
                    if (dist > range)
                    {
                        sCur = (System*)sCur->next;
                        continue;
                    }
                    
                    iCur = (influencePointer)sCur->inf;
                    while (iCur != NULL)
                    {
                        influence[iCur->alliance] += iCur->inf/(sS+dist);
                        iCur = (influencePointer)iCur->next;
                    }
                    sCur = (System*)sCur->next;
                }
                rCur = (row*)rCur->next;
            }
            
            bestI = 0;
            bestA = -1;
            for (i = 0; i < sA; i++)
            {
                if (influence[i] > bestI)
                {
                    bestI = influence[i];
                    bestA = i;
                }
                influence[i] = 0;
            }
            if (bestI > sV)
            {
                printf("%d,%d,%d,%f\n", x, y, bestA, bestI);
            }
        }
    }
    
    // free up all used memory
    // iterate through the linked lists and free the element we processed
    
    int pointer;
    rCur = rFirst;
    while (rCur != NULL) 
    {      
        sCur = (System*)rCur->fields;
        while (sCur != NULL)
        {
            iCur = (influencePointer)sCur->inf;
            while (iCur != NULL)
            {
                pointer = (int)iCur->next;
                free(iCur);
                iCur = (influencePointer)pointer;
            }
            pointer = (int)sCur->next;
            free(sCur);
            sCur = (System*)pointer;
        }
        pointer = (int)rCur->next;
        free(rCur);
        rCur = (row*)pointer;
    } 

    return 0;
}