File content as of revision 2:eaf245af2aae:

#include "Ghost.h"
#include "mbed.h"

const string Ghost::_suffix = ".ghost";

Ghost::Ghost(const std::string path, const std::string root)
{
    _root = root;
    // Connections to SD card holder on K64F (SPI interface)
    SDFileSystem sd(PTE3, PTE1, PTE2, PTE4, "sd"); // MOSI, MISO, SCK, CS

    FILE *fp;

    fp = fopen(path.c_str(), "r");

    int lines=0;  // going to store the number of lines in the file
    stringvec values;

    if (fp == NULL) {  // if it can't open the file then print error message
        printf("Error! Unable to open file: %s\n", path.c_str());
        //listdir(path);
    } else {
        //Since we may not know the
        // number of lines in the files ahead of time, we'll first count them
        // * means scan but don't save

        while (fscanf(fp, "%*s") != EOF) {
            lines++;  // increment counter when read a line
        }

        rewind(fp); // 'scrolled' to end of file, so go back to beginning

        char buffer[15];

        for(int i = 0; i < lines; i++) {
            fscanf(fp, "%s", buffer);
            if(buffer[0] != '\\') {
                values.push_back(buffer);
            }
        }

        for(int i = 0; i < values.size(); i++) {
            _type = string_to_type(values[0]);
            _name = values[1];
            sscanf(values[2].c_str(), "%d", &_attack);
            sscanf(values[3].c_str(), "%d", &_defense);
            sscanf(values[4].c_str(), "%d", &_level);
            sscanf(values[5].c_str(), "%d", &_xp);
            sscanf(values[6].c_str(), "%d", &_value);
            sscanf(values[7].c_str(), "%d", &_hp_max);
            sscanf(values[8].c_str(), "%d", &_hp);
            sscanf(values[9].c_str(), "%d", &_uid);
        }
    }
    
    _name = "casper";
}

Ghost::Ghost(int num, const std::string root)
{
    _root = root;
    _uid = gen_uid();
    int type = 0;
    if (num < 50) {
        type = 0;
    } else if (num < 65) {
        type = 1;
    } else if (num < 80) {
        type = 2;
    } else if (num < 95) {
        type = 3;
    } else {
        type = 4;
    }

    if(type == 0) {
        _attack = 10;
        _defense = 10;
        _level = 1;
        _xp = 0;
        _value = 10;
        _hp_max = 10;
        _hp = _hp_max;
        _type = BASIC;
    } else if(type == 1) {
        _attack = 15;
        _defense = 5;
        _level = 1;
        _xp = 0;
        _value = 15;
        _hp_max = 7;
        _hp = _hp_max;
        _type = ECTO;
    } else if(type == 2) {
        _attack = 5;
        _defense = 15;
        _level = 1;
        _xp = 0;
        _value = 15;
        _hp_max = 13;
        _hp = _hp_max;
        _type = POLTER;
    } else if(type == 3) {
        _attack = 15;
        _defense = 15;
        _level = 1;
        _xp = 0;
        _value = 20;
        _hp_max = 5;
        _hp = _hp_max;
        _type = ORB;
    } else if(type == 4) {
        _attack = 5;
        _defense = 5;
        _level = 10;
        _xp = 10;
        _value = 10;
        _hp_max = 20;
        _hp = _hp_max;
        _type = FUNNEL;
    }
    _name = "casper";
}

void Ghost::listdir(std::string path)
{
    // Connections to SD card holder on K64F (SPI interface)
    SDFileSystem sd(PTE3, PTE1, PTE2, PTE4, "sd"); // MOSI, MISO, SCK, CS

    printf("Listing directory: %s\n", path.c_str());
    DIR *d;
    struct dirent *p;

    d = opendir(path.c_str());
    if (d != NULL) {
        while ((p = readdir(d)) != NULL) {
            printf(" - %s\n", p->d_name);
        }
    } else {
        printf("Could not open directory!\n");
    }
    closedir(d);
}

void Ghost::save(void)
{
    SDFileSystem sd(PTE3, PTE1, PTE2, PTE4, "sd"); // MOSI, MISO, SCK, CS
    FILE *fp; // this is our file pointer
    
    std::string filepath = "/sd";
    
    filepath.append(_root);
    
    char buf[10];
    sprintf(buf, "%d", _uid);
    
    filepath.append(buf);
    filepath.append(_suffix);
    
    fp = fopen(filepath.c_str(), "w");

    if (fp == NULL) {  // if it can't open the file then print error message
        printf("Error! Unable to open file!\n");
    } else {  // opened file so can write
        fprintf(fp, "// Type\n");
        fprintf(fp, "%s\n", get_type_string().c_str());
        fprintf(fp, "// Name\n");
        fprintf(fp, "%s\n", get_name().c_str());
        fprintf(fp, "// Defense\n");
        fprintf(fp, "%d\n", get_defense());
        fprintf(fp, "// Level\n");
        fprintf(fp, "%d\n", get_level());
        fprintf(fp, "// XP\n");
        fprintf(fp, "%d\n", get_xp());
        fprintf(fp, "// Value\n");
        fprintf(fp, "%d\n", get_value());
        fprintf(fp, "// HP Max\n");
        fprintf(fp, "%d\n", get_hp_max());
        fprintf(fp, "// HP\n");
        fprintf(fp, "%d\n", get_hp());
        fprintf(fp, "// UID\n");
        fprintf(fp, "%d\n", get_uid());        
        fclose(fp);  // ensure you close the file after writing
    }
}

int Ghost::sell(void){
    
    std::string filepath = "/sd";
    
    filepath.append(_root);
    
    char buf[10];
    sprintf(buf, "%d", _uid);
    
    filepath.append(buf);
    filepath.append(_suffix);
    
    delete_file(filepath.c_str());
    
    return _value;
};

void Ghost::feed(int ammount){
    _xp = _xp + ammount;
    
    int new_level = 0;
    
    if(_xp > 1200){
        new_level = 10;
    } else if(_xp > 600){
        new_level = 9;
    } else if(_xp > 300){
        new_level = 8;
    } else if(_xp > 150){
        new_level = 7;
    } else if(_xp > 75){
        new_level = 6;
    } else if(_xp > 38){
        new_level = 5;
    } else if(_xp > 19){
        new_level = 4;
    } else if(_xp > 10){
        new_level = 3;
    } else if(_xp > 5){
        new_level = 2;
    } else {
        new_level = 1;
    }
    
    if(new_level > _level){
        int difference = new_level - _level;
        for(int i = 0; i < difference; i++){
            _attack++;
            _defense++;
            _level++;
            _hp_max++;
            _hp = _hp_max;
            _value = _attack + _defense + _hp_max;
        }  
    }
    
    save();
}

void Ghost::print_all(void)
{
    printf("\n Print out for Ghost: %s\n", get_name().c_str());
    printf("--------------------");
    printf("\n");
    printf("Type: %s\n", get_type_string().c_str());
    printf("Attack: %d\n", get_attack());
    printf("Defense: %d\n", get_defense());
    printf("Level: %d\n", get_level());
    printf("XP: %d\n", get_xp());
    printf("Value: %d\n", get_value());
    printf("HP Max: %d\n", get_hp_max());
    printf("HP: %d\n", get_hp());
    printf("UID: %d\n", get_uid());
}

Type Ghost::get_type_enum(void)
{
    return _type;
}

std::string Ghost::get_type_string(void)
{
    return type_to_string(_type);
}

std::string Ghost::get_name(void)
{
    return _name;
}

int Ghost::get_attack(void)
{
    return _attack;
}

int Ghost::get_defense(void)
{
    return _defense;
}

int Ghost::get_level(void)
{
    return _level;
}

int Ghost::get_xp(void)
{
    return _xp;
}

int Ghost::get_value(void)
{
    return _value;
}

int Ghost::get_hp_max(void)
{
    return _hp_max;
}

int Ghost::get_hp(void)
{
    return _hp;
}

int Ghost::get_uid(void)
{
    return _uid;
}

int Ghost::gen_uid(void)
{
    // Connections to SD card holder on K64F (SPI interface)
    SDFileSystem sd(PTE3, PTE1, PTE2, PTE4, "sd"); // MOSI, MISO, SCK, CS
    std::string path = "/sd/ghosts";
    printf("Listing directory to generate UID: %s\n", path.c_str());
    DIR *d;
    struct dirent *p;

    stringvec files;

    d = opendir(path.c_str());
    if (d != NULL) {
        while ((p = readdir(d)) != NULL) {
            files.push_back(p->d_name);
        }
    } else {
        printf("Could not open directory!\n");
    }
    closedir(d);
    
    stringvec correct_files;
    
    for(int i = 0; i < files.size(); i++){
        if(hasEnding(files[i], ".ghost")){
            correct_files.push_back(files[i]);
        }
    }
    
    std::vector<int> used_ids;
    
    for(int i = 0; i < correct_files.size(); i++){
        std::string temp = correct_files[i].substr(0, correct_files[i].length() - 6);
        int x; 
        sscanf(temp.c_str(), "%d", &x); 
        used_ids.push_back(x);
    }
    int max = -1;
    for(int i = 0; i < used_ids.size(); i++){
        if(used_ids[i] > max){
            max = used_ids[i];
        }
    }
    
    max++;
    return max;

}

bool Ghost::hasEnding (std::string const &fullString, std::string const &ending) {
    if (fullString.length() >= ending.length()) {
        return (0 == fullString.compare (fullString.length() - ending.length(), ending.length(), ending));
    } else {
        return false;
    }
}

std::string Ghost::type_to_string(Type type)
{
    if(type == BASIC) {
        return "BASIC";
    } else if (type == ECTO) {
        return "ECTOPLASM";
    } else if (type == POLTER) {
        return "POLTERGIEST";
    } else if (type == ORB) {
        return "ORB";
    } else if (type == FUNNEL) {
        return "FUNNEL";
    } else {
        return "NULL";
    }
}

Type Ghost::string_to_type(std::string type)
{
    if(type == "BASIC") {
        return BASIC;
    } else if (type == "ECTOPLASM") {
        return ECTO;
    } else if (type == "POLTERGIEST") {
        return POLTER;
    } else if (type == "ORB") {
        return ORB;
    } else if (type == "FUNNEL") {
        return FUNNEL;
    } else {
        return BASIC;
    }
}


void Ghost::delete_file(const char filename[])
{
    printf("Deleting file '%s'...",filename);
    FILE *fp = fopen(filename, "r");  // try and open file
    if (fp != NULL) {  // if it does open...
        fclose(fp);    // close it
        remove(filename);  // and then delete
        printf("Done!\n");
    }
    // if we can't open it, it doesn't exist and so we can't delete it
}