floWenoL fucked around with this message at 02:43 on Feb 16, 2013

Hammerite fucked around with this message at 12:15 on Feb 19, 2013

seiken fucked around with this message at 16:01 on Feb 19, 2013

struct PatternPreset {
    /*
     Size of arrays initialised as follows;
        Keypoints[necklaces]
        Pulses[necklaces][depth]
        breakEarly[necklaces][depth]
     */
    PatternPreset(int necklaces, int depth){
        this->necklaces = necklaces;
        this->depth = depth;
        
        keyPoints = new int[necklaces];
        pulses = new int [necklaces][depth];
        breakEarly = new int[necklaces][depth]; //Error here. Only the first dimension may have dynamically allocated size what do?
    }
    
    int necklaces = 0;      //The number of necklaces to form one sequence
    int depth = 0;          //The number of sequences to form one pattern
    
    int*    keyPoints = nullptr;    //The length of each of the necklaces
    int**   pulses = nullptr;       //The number of pulses in each of the necklaces in the pattern
    bool**  breakEarly = nullptr;   //Which necklaces to break early
};

jiggerypokery fucked around with this message at 16:08 on Feb 19, 2013

struct PatternPreset {
    
    PatternPreset(int necklaces, int depth){
        this->necklaces = necklaces;
        this->depth = depth;
    }
    
    struct NecklacePreset{
        NecklacePreset(int intervals, int pulses, bool BreakEarly = false){
            this->intervals = intervals; //should be a small ish number say <20. Maybe should add some protection against big numbers
            this->pulses = pulses;          //HAS to be < Intervals. 
            this->BreakEarly = BreakEarly;
        }
        
        int m(){ return intervals;}
        int p(){ return pulses;}
        bool breakEarly() {return BreakEarly;}
 
    private:
        int intervals  = 0;
        int pulses = 0;
        bool BreakEarly;
    };
    
    int x(){return necklaces;}
    int d(){return depth;}
    
    std::vector<NecklacePreset> N; //Size = necklaces * depth (x * d).
    
private:
    int necklaces;      //The number of necklaces to form one sequence
    int depth;          //The number of sequences to form one pattern
};

jiggerypokery fucked around with this message at 19:48 on Feb 19, 2013

#ifndef MATHEMATICS_FUNCTIONS_H
    #define MATHEMATICS_FUNCTIONS_H

    #include <math.h>

    extern const bool forceArrowMovementPermissions[7][6];
    extern const bool stepBlockerMovementPermissions[3][6];

    int iRoundAwayFromZero (float f);
        // Note: do not attempt to use this function to round floats that are
        // very large (in absolute value), as it may give inaccurate results.
        // "Very large" here means numbers whose integer part is 15+ digits.
#endif

#include "mathematics-functions.h"

const bool forceArrowMovementPermissions[7][6] = {
    {true , true , false, false, false, true }, // Force arrow pointing north
    {true , true , true , false, false, false}, // Force arrow pointing northeast
    {false, true , true , true , false, false}, // Force arrow pointing southeast
    {false, false, true , true , true , false}, // Force arrow pointing south
    {false, false, false, true , true , true }, // Force arrow pointing southwest
    {true , false, false, false, true , true }, // Force arrow pointing northwest
    {true , true , true , true , true , true }  // No force arrow present on hex
};

const bool stepBlockerMovementPermissions[3][6] = {
    {false, true , false, true , false, true }, // Step blocker preventing positive-axis movement
    {true , false, true , false, true , false}, // Step blocker preventing negative-axis movement
    {true , true , true , true , true , true }  // No step blocker present on hex
};

int iRoundAwayFromZero (float f) {
    // Please see the note in the header file re: the limitations of this function.
    return (int)(f > 0 ? floor(f + 0.5) : ceil(f - 0.5));
}

#ifndef MATHEMATICS_FUNCTIONS_H
    #define MATHEMATICS_FUNCTIONS_H

    #include <math.h>

    #define FORCE_ARROW_LAYER_EMPTY  6
    #define STEP_BLOCKER_LAYER_EMPTY 2

    bool forceArrowLayerPermitsMovement (const int forceArrowLayer, const int movementDirection);
    bool stepBlockerLayerPermitsMovement (const int stepBlockerLayer, const int movementDirection);

    int iRoundAwayFromZero (float f);
        // Note: do not attempt to use this function to round floats that are
        // very large (in absolute value), as it may give inaccurate results.
        // "Very large" here means numbers whose integer part is 15+ digits.
#endif

#include "mathematics-functions.h"

bool forceArrowLayerPermitsMovement (const int forceArrowLayer, const int movementDirection) {
    return
        forceArrowLayer == FORCE_ARROW_LAYER_EMPTY ||
        (7 - forceArrowLayer + movementDirection) % 6 < 3;
}

bool stepBlockerLayerPermitsMovement (const int stepBlockerLayer, const int movementDirection) {
    return
        stepBlockerLayer == STEP_BLOCKER_LAYER_EMPTY ||
        (bool)((stepBlockerLayer + movementDirection) % 2);
}

int iRoundAwayFromZero (float f) {
    // Please see the note in the header file re: the limitations of this function.
    return (int)(f > 0 ? floor(f + 0.5) : ceil(f - 0.5));
}

Hammerite fucked around with this message at 07:30 on Feb 20, 2013