Joda fucked around with this message at 14:26 on Apr 8, 2011

Joda fucked around with this message at 16:20 on Apr 8, 2011

#include <iostream>

int main()
{
  std::cout << "Something!\[2J";

  return 0;
}

Joda fucked around with this message at 20:30 on Apr 8, 2011

Joda fucked around with this message at 18:21 on Apr 20, 2011

currentState = stateList.begin();

Joda fucked around with this message at 22:12 on Mar 19, 2014

    std::vector< std::vector<int> > rules = std::vector< std::vector<int> >();
    std::vector<int> rule = {0,0,0,10000,0};
    
    rules.push_back(rule);
    
    std::cout << "Ruleset size in main(): " << rules.size() << std::endl;
    
    sm.addState(rules,move);
    sm.update(1,false);

void StateMachine::addState(std::vector< std::vector<int> > ruleSet, Move stateMove)
{
  std::cout << "Ruleset size in StateMachine::addState(): " << ruleSet.size() << std::endl;
    
  State newState(ruleSet, stateNumber, stateMove);
  stateList.push_back(&newState);
}

State::State(std::vector< std::vector<int> > ruleSet, int& sMachineState, Move stateMove) {
  this->currentMachineState = sMachineState;
  this->ruleSet = ruleSet;
  startTime = (int) std::time(0);
  this->stateMove = stateMove;
  
  std::cout << "Ruleset size for Class in State constructor: " << this->ruleSet.size() << std::endl;
}

void State::update(int input, bool isJumping)
{
  std::cout << "Ruleset size in state::update(): " << ruleSet.size() << std::endl;
    
  int elapsedTime = (int) std::time(0) - startTime;
  
  for(auto iter = ruleSet.begin(); iter != ruleSet.end(); iter++) {
    
    if(input == iter->at(0) &&
      (int) isJumping == iter->at(1) &&
      elapsedTime > iter->at(2) &&
      elapsedTime < iter->at(3))
    {
        currentMachineState = iter->at(4);
    }
  }
}

Ruleset size in main(): 1
Ruleset size in StateMachine::addState(): 1
Ruleset size for Class in State constructor: 1
Ruleset size in state::update(): 6148908827317490774

RUN FINISHED; Segmentation fault; real time: 0ms; user: 0ms; system: 0ms

Joda fucked around with this message at 05:17 on Mar 21, 2014

class Dummy {
public:
    Dummy();
    Rect bounding;
};

Dummy::Dummy() {
    this->bounding = Rect(100,100,Math::iVec2(100,100));
}

class Rect : public Shape {
public:
    Rect(int width, int height, Math::iVec2 position);
    
    bool intersect(Rect* rectangle);
    bool contains(Math::iVec2 point);
    
    void draw();
    void update();
    
    Math::iVec2 getVertex(int index);
    
private:
    Math::iVec2 vertices[4];
    int width;
    int height;
    
    void updateVertices();
};

Rect::Rect(int width, int height, Math::iVec2 position) {
    this->width = width;
    this->height = height;
    this->position = position;
    updateVertices();
}

Dummy.h:19:14: error: no matching function for call to ‘Rect::Rect()’
 Dummy::Dummy() {
              ^
Dummy.h:19:14: note: candidates are:
In file included from Dummy.h:11:0,
                 from main.cpp:6:
Shape.h:38:5: note: Rect::Rect(int, int, Math::iVec2)
     Rect(int width, int height, Math::iVec2 position);
     ^
Shape.h:38:5: note:   candidate expects 3 arguments, 0 provided

class Dummy {
public:
    Dummy();
    Rect* bounding;
};

Dummy::Dummy() {
    this->bounding = new Rect(100,100,Math::iVec2(100,100));
}

Joda fucked around with this message at 14:34 on Apr 7, 2014

template <class T>
void push_back(T elementToAdd)
{
	LinkedList<T>* temp = this;

	while(temp->next != nullptr)
		temp = temp->next;

	temp->next = new LinkedList(T(elementToAdd));
}

Joda fucked around with this message at 01:46 on May 7, 2014

Joda fucked around with this message at 13:56 on May 14, 2014

Joda fucked around with this message at 10:55 on Sep 11, 2014

Joda fucked around with this message at 16:41 on Dec 1, 2014

Joda fucked around with this message at 04:34 on Dec 22, 2014

void foo(int* bar, int size) {
	for(int i = 0; i < size, i++) {
		printf("%d\n", bar[i]); //[i] operator adds size of int*i and dereferences
	}
}

int main() {
	int bar[3] = {1,2,3};
	foo(&(bar[0]),3); //& operator returns pointer to element
	
	return 0;
}

1>c:\users\amir\documents\visual studio 2010\projects\struct2\struct2\appears.c(19): warning C4047: 'function' : 'appear **' differs in levels of indirection from 'appear [26]'
1>c:\users\amir\documents\visual studio 2010\projects\struct2\struct2\appears.c(19): warning C4024: 'initAppearStruct' : different types for formal and actual parameter 1

1>c:\users\amir\documents\visual studio 2010\projects\struct2\struct2\appears.c(25): warning C4028: formal parameter 1 different from declaration

Joda fucked around with this message at 00:35 on Feb 23, 2015

c:/mingw/bin/../lib/gcc/mingw32/4.8.1/../../../../mingw32/bin/ld.exe: cannot find -lSOIL
collect2.exe: error: ld returned 1 exit status

Joda fucked around with this message at 04:33 on Mar 9, 2015

class foo {
	foo(int a, int b);
	int a; 
	int b;
};
//The compiler doesn't automatically know what to initialise a and b to; we have to explicitly tell it.
foo::foo(int a, int b) {
	this->a = a; //the argument a "hides" the member a, so we have to use this->
	this->b = b;
	//All members have now been intialised.
}

Joda fucked around with this message at 07:17 on Mar 14, 2015

Joda fucked around with this message at 16:44 on Apr 22, 2015

Joda fucked around with this message at 10:03 on Apr 23, 2015

class Semaphore {
public:
    Semaphore();
    void V();
    void P();
    int getTokens();
private:
    std::atomic_int tokens;
    std::mutex mut;
};

Semaphore::Semaphore() :
        tokens(1)
{
}

void Semaphore::P() {
    mut.lock();
    while(tokens <= 0) {
        mut.unlock();
        std::this_thread::sleep_for (std::chrono::milliseconds(1));
        mut.lock();
    }

    tokens--;
    mut.unlock();
}

void Semaphore::V() {
    mut.lock();
    tokens++;
    mut.unlock();
}

std::mutex mutex;

void f() {
    mutex.lock();//sem->P();
    for(int i = 0; i < 1000; i++) {
        k++;
        l++;
        y += k - l;
    }
    c++;
    mutex.unlock();//sem->V();
}

Without atomic: 0
With atomic: 1268752
Tokens: 1
Completed threads: 1000

Joda fucked around with this message at 22:29 on Apr 23, 2015

Joda fucked around with this message at 22:44 on Apr 23, 2015

static pthread_mutex_t pmutex = PTHREAD_MUTEX_INITIALIZER;

void f() {
    pthread_mutex_lock(&pmutex);

    for(int i = 0; i < 10000; ++i) {
        k++;
        l++;
        y += k - l;
    }
    c++;
    pthread_mutex_unlock(&pmutex);
}

Without atomic: 0
With atomic: 0
Completed threads: 10000

Joda fucked around with this message at 09:09 on Apr 24, 2015

Joda fucked around with this message at 20:56 on May 2, 2015

class Message {
public:
    Message();
    Message(messageType type);

    template<typename T>
    T extractMsgData();

    const messageType type;
    bool kill = false;
};

template<typename T>
class DataMessage : public Message {
public:
    DataMessage(messageType type, T data);

    T data;
};

Message::Message(messageType type) :
type(type)
{

}

Message::Message() :
type(NO_TYPE)
{

}

template<typename T>
T Message::extractMsgData() {
    return static_cast<DataMessage<T>*>(this)->data;
}

template<typename T>
DataMessage<T>::DataMessage(messageType type, T data) :
Message(type),
data(data)
{
}

//specific templates
template class DataMessage<glm::vec2*>;
template class DataMessage<glm::vec3>;
template class DataMessage<glm::vec2>;
template class DataMessage<std::string>;
template class DataMessage<std::string*>;
template class DataMessage<float>;

Joda fucked around with this message at 18:46 on Aug 2, 2015

Joda fucked around with this message at 02:45 on Aug 3, 2015