LoL* tokenize(LinkedList* args) {
int open_p = 0;
Node* i;
LoL* tk_list = LoL_new();
LinkedList* a = LinkedList_new();
if (args->front!=NULL) {
for(i=args->front; i!=NULL; i=i->next) {
if(strcmp(i->value, "(")==0) {
append(a, i->value);
open_p++;
continue;
}
else if (strcmp(i->value, ")")==0) {
append(a, i->value);
open_p--;
continue;
}
if(open_p==0) {
if(strcmp(i->value, ",")==0) {
appendLoL(tk_list, a);
a = LinkedList_new();
continue;
}
}
append(a, i->value);
}
appendLoL(tk_list, a);
}
clear(args);
free(args);
return tk_list;
}
/*
* Retrieves a list of all jump moves currently possible for a player.
*
* @params: (player) - the player whose moves are to be put in the list
* @return: a LinkedList struct of jump moves currently possible for the player, or NULL if any allocation errors occurred
*/
static struct LinkedList* getPossibleJumps (char** board, int player){
struct LinkedList* jumpMoves = LinkedList_new(&PossibleMove_free);
if(jumpMoves == NULL){ //allocation failed
return NULL;
}
for (int x = 1; x <= Board_SIZE; x++){
for (int y = 1; y <= Board_SIZE; y++){
if (Board_evalPiece(board, x, y, player) <= 0){
continue;
}
for (int i = -1; i <= 1; i += 2){
for (int j = -1; j <= 1; j += 2){
struct Tile* destTile = NULL;
if (!isInRange(x+i,y+j) || !isInRange(x+2*i,y+2*j)){
continue;
}
int pieceIsKing = Board_evalPiece(board, x, y, player) == 3;
if (pieceIsKing){
destTile = canKingCaptureInDirection(board, x, y, i, j);
}
else{
int enemyNearby = Board_evalPiece(board, x+i, y+j, player) < 0;
int enemyIsCapturable = Board_isEmpty(board, x+2*i, y+2*j);
if(enemyNearby && enemyIsCapturable){
destTile = Tile_new(x+2*i, y+2*j);
if (destTile == NULL){ // allocation failed
return NULL;
}
}
}
if (!destTile){
continue;
}
struct LinkedList* jumpSteps = LinkedList_new(&Tile_free);
if (jumpSteps == NULL){ // allocation failed
Tile_free(destTile);
return NULL;
}
LinkedList_add(jumpSteps, destTile);
struct PossibleMove* possibleJumpMove = PossibleMove_new(x, y, jumpSteps, board);
if (possibleJumpMove == NULL){ // allocation failed
Tile_free(destTile);
LinkedList_free(jumpSteps);
return NULL;
}
populateJumpList(jumpMoves, possibleJumpMove);
}
}
}
}
return jumpMoves;
}
/*
* Gets a list of all single step moves currently possible for a player.
*
* @params: (player) - the player whose moves are to be put in the list
* @return: a list of single step moves currently possible for the player, or NULL if any allocation errors occurred
*/
static struct LinkedList* getPossibleSingleMoves (char** board, int player){
struct LinkedList* possibleSingleMoves = LinkedList_new(&PossibleMove_free);
if (possibleSingleMoves == NULL){
return NULL;
}
int forward = (player == BLACK) ? -1 : 1; /* for each player's different direction of "forward" */
for (int x = 1; x <= Board_SIZE; x++){
for (int y = 1; y <= Board_SIZE; y++){
if (Board_evalPiece(board, x, y, player) <= 0){ //this tile doesn't contain one of this player's pieces
continue;
}
for (int sideward = -1; sideward <= 1; sideward += 2){
for (int k = -Board_SIZE; k <= Board_SIZE; k++){
if (!isInRange(x+k*sideward, y+k)){
continue;
}
int pieceIsKing = Board_evalPiece(board, x, y, player) == 3;
if (!pieceIsKing && k != forward){
continue;
}
if(Board_isEmpty(board, x+k*sideward, y+k)){
struct Tile* destTile = Tile_new(x+k*sideward, y+k);
if (destTile == NULL){ // allocation failed
return NULL;
}
struct LinkedList* singleSteps = LinkedList_new(&Tile_free);
if (singleSteps == NULL){ // allocation failed
Tile_free(destTile);
return NULL;
}
LinkedList_add(singleSteps, destTile);
struct PossibleMove* possibleSingleMove = PossibleMove_new(x, y, singleSteps, board);
if (possibleSingleMove == NULL){ // allocation failed
Tile_free(destTile);
LinkedList_free(singleSteps);
return NULL;
}
LinkedList_add(possibleSingleMoves, possibleSingleMove);
}
if (!pieceIsKing && k == forward){
break;
}
}
}
}
}
return possibleSingleMoves;
}
END_TEST
START_TEST(test_HeadAndTailOfLinkedListAreInitiallyNULL) {
LinkedList* list = LinkedList_new();
ck_assert_ptr_eq(LinkedList_getHead(list), NULL);
ck_assert_ptr_eq(LinkedList_getTail(list), NULL);
}
END_TEST
START_TEST(test_NodesHaveCorrectPreviousAndNextPointersAfterAddingMultipleElements) {
LinkedList* list = LinkedList_new();
int elem1 = 1337;
LinkedList_add(list, &elem1);
char* elem2 = "theeta";
LinkedList_add(list, &elem2);
int elem3 = 74;
LinkedList_add(list, &elem3);
char elem4 = 'a';
LinkedList_add(list, &elem4);
Node* node = NULL;
Node* prev = NULL;
int i;
for (i = 0; i < 4; i++) {
node = LinkedList_getNode(list, i);
ck_assert_ptr_eq(node->previous, prev);
if (prev != NULL) {
ck_assert_ptr_eq(prev->next, node);
}
prev = node;
}
ck_assert_ptr_eq(node->next, NULL);
}
/* Drier program to test above functions*/
int main()
{
/* Start with the empty list */
LinkedList_T list;
int i;
list = LinkedList_new();
// Insert 6. So linked list becomes 6->NULL
printf("add new item\n");
for(i=0; i<10; i++){
LinkedList_add(list, i) ;
}
printf("append new item\n");
for(i=100; i<110; i++){
LinkedList_append(list, i) ;
}
printf("print list item\n");
LinkedList_print(list);
printf("print list item reverse\n");
LinkedList_print_reverse(list);
printf("the first item is: %d\n", LinkedList_first(list));
printf("the last item is: %d\n", LinkedList_last(list));
getchar();
return 0;
}
/*
* Trims the list of possible jump moves, so it only contains moves that result in the maximum amount of captures
*
* @params: (jumpMovesList) - the list of all possible jump moves
* @return: a trimmed list, or NULL if any allocation errors occurred
*/
static struct LinkedList* trimJumpMovesList (struct LinkedList* jumpMovesList){
int maxCaptures = 0;
//finding the maximum number of captures in a currently possible jump move
struct Iterator iterator;
Iterator_init(&iterator, jumpMovesList);
while(Iterator_hasNext(&iterator)){
struct PossibleMove* currMove = (struct PossibleMove*)(Iterator_next(&iterator));
int currNumOfCaptures = PossibleMove_numOfCaptures(currMove);
if(currNumOfCaptures > maxCaptures){
maxCaptures = currNumOfCaptures;
}
}
//creating a new list and filling it only with the appropriate moves
struct LinkedList* trimmedJumpMoves = LinkedList_new(&PossibleMove_free);
if(trimmedJumpMoves == NULL){ // allocation failed
return NULL;
}
struct Iterator secondIterator;
Iterator_init(&secondIterator, jumpMovesList);
while(Iterator_hasNext(&secondIterator)){
struct PossibleMove* currMove = (struct PossibleMove*)(Iterator_next(&secondIterator));
if(PossibleMove_numOfCaptures(currMove) == maxCaptures){
struct PossibleMove* clonedCurrMove = PossibleMove_clone(currMove);
if (clonedCurrMove == NULL){ // allocation failed
LinkedList_free(trimmedJumpMoves);
return NULL;
}
LinkedList_add(trimmedJumpMoves, clonedCurrMove);
}
}
LinkedList_free(jumpMovesList);
return trimmedJumpMoves;
}
END_TEST
START_TEST(test_SizeOfLinkedListIsOneAfterAddingAnElement) {
LinkedList* list = LinkedList_new();
int elem = 1337;
LinkedList_add(list, &elem);
ck_assert_int_eq(LinkedList_size(list), 1);
}
END_TEST
START_TEST(test_GettingAStoredElementFromListNodeWorks) {
LinkedList* list = LinkedList_new();
int elem = 1337;
LinkedList_add(list, &elem);
ck_assert_int_eq(*(int*) LinkedList_getNode(list, 0)->elem, 1337);
}
END_TEST
START_TEST(test_ListHasSameHeadAndTailNodeAfterAddingAnElement) {
LinkedList* list = LinkedList_new();
int elem = 1337;
LinkedList_add(list, &elem);
ck_assert_ptr_ne(LinkedList_getHead(list), NULL);
ck_assert_ptr_eq(LinkedList_getHead(list), LinkedList_getTail(list));
}
void Physics_addCollisionCallbackOnGameObject(CollisionCallback* callback, GameObject* object)
{
if (object->collisionListeners == NULL)
{
object->collisionListeners = LinkedList_new();
}
LinkedList_addLast(object->collisionListeners, callback);
}
void Physics_addCollisionCallbackOnObjectType(CollisionCallback* callback, ObjectType* type)
{
if (type->collisionListeners == NULL)
{
type->collisionListeners = LinkedList_new();
}
LinkedList_addLast(type->collisionListeners, callback);
}
int main(void) {
LinkedList* list = LinkedList_new();
char* elem1 = "cat";
LinkedList_add(list, &elem1);
char* elem2 = "rat";
LinkedList_add(list, &elem2);
char* elem3 = "dog";
LinkedList_add(list, &elem3);
char* elem4 = "sheep";
LinkedList_add(list, &elem4);
char* elem5 = "goat";
LinkedList_add(list, &elem5);
char* elem6 = "kebab";
LinkedList_add(list, &elem6);
char* elem7 = "pig";
LinkedList_add(list, &elem7);
char* elem8 = "cow";
LinkedList_add(list, &elem8);
char* elem9 = "chicken";
LinkedList_add(list, &elem9);
char* elem10 = "duck";
LinkedList_add(list, &elem10);
char* elem11 = "fox";
LinkedList_add(list, &elem11);
char* elem12 = "rabbit";
LinkedList_add(list, &elem12);
char* elem13 = "mouse";
LinkedList_add(list, &elem13);
char* elem14 = "hedgehog";
LinkedList_add(list, &elem14);
printf("list before: \n");
for (int i = 0; i < LinkedList_size(list); i++) {
if (LinkedList_get(list, i) != NULL) {
printf("%d: %s \n", i, *(char**)LinkedList_get(list, i));
}
}
printf("\nremoving element 5, %s\n", *(char**)LinkedList_get(list, 5));
LinkedList_remove(list, 5);
printf("\nlist after: \n");
for (int i = 0; i < LinkedList_size(list); i++) {
if (LinkedList_get(list, i) != NULL) {
printf("%d: %s \n", i, *(char**)LinkedList_get(list, i));
}
}
LinkedList_destroy(list);
free(list);
}
int maina()
{
LinkedList* l;
l = LinkedList_new();
LinkedListIterator* iter = LinkedList_getIterator(l);
if (LinkedListIterator_hasMore(iter))
{
return 1;
}
if (LinkedListIterator_getNext(iter) != NULL)
{
return 2;
}
if (LinkedListIterator_getSame(iter) != NULL)
{
return 3;
}
LinkedListIterator_delete(iter);
int i;
int* j;
// Add 100 integer pointers to list.
for (i = 0; i < 100; i++)
{
j = malloc(sizeof(int));
*j = i;
LinkedList_addLast(l, j);
}
iter = LinkedList_getIterator(l);
int count = 0;
while (LinkedListIterator_hasMore(iter))
{
j = LinkedListIterator_getNext(iter);
if (count != *j)
{
return 4;
}
count++;
if (j != LinkedListIterator_getSame(iter))
{
return 5;
}
}
if (count != 99)
{
return 6;
}
LinkedListIterator_delete(iter);
LinkedList_deleteContents(l, intDeleter);
LinkedList_delete(l);
return 0;
}
END_TEST
START_TEST(test_RemovingElementFromListDoesNotFreeItFromMemory) {
LinkedList* list = LinkedList_new();
int* elem = malloc(sizeof (int));
*elem = 35;
LinkedList_add(list, elem);
ck_assert_int_eq(*(int*) LinkedList_get(list, 0), 35);
LinkedList_remove(list, 0);
ck_assert_int_eq(*elem, 35);
}
END_TEST
START_TEST(test_GettingANonExistentElementFromListReturnsNULL) {
LinkedList* list = LinkedList_new();
int elem = 24;
LinkedList_add(list, &elem);
int elem1 = 25;
LinkedList_add(list, &elem1);
ck_assert_int_eq(*(int*) LinkedList_get(list, 1), 25);
ck_assert_ptr_eq(LinkedList_get(list, 4), NULL);
ck_assert_ptr_eq(LinkedList_get(list, -1), NULL);
}
END_TEST
START_TEST(test_StoringEvenMoreElementsToListWorks) {
int i;
for (i = 0; i < 10; i++) {
LinkedList* list = LinkedList_new();
int elem1 = 1337;
LinkedList_add(list, &elem1);
char* elem2 = "theeta";
LinkedList_add(list, &elem2);
int elem3 = 74;
LinkedList_add(list, &elem3);
char elem4 = 'a';
LinkedList_add(list, &elem4);
int elem5 = 55;
LinkedList_add(list, &elem5);
int elem6 = 66;
LinkedList_add(list, &elem6);
int elem7 = 77;
LinkedList_add(list, &elem7);
int elem8 = 88;
LinkedList_add(list, &elem8);
int elem9 = 99;
LinkedList_add(list, &elem9);
int elem10 = 110;
LinkedList_add(list, &elem10);
int elem11 = 111;
LinkedList_add(list, &elem11);
int elem12 = 1212;
LinkedList_add(list, &elem12);
int elem13 = 1313;
LinkedList_add(list, &elem13);
int elem14 = 1414;
LinkedList_add(list, &elem14);
ck_assert_int_eq(*(int*) LinkedList_get(list, 0), 1337);
ck_assert_str_eq(*(char**) LinkedList_get(list, 1), "theeta");
ck_assert_int_eq(*(int*) LinkedList_get(list, 2), 74);
ck_assert_int_eq(*(char*) LinkedList_get(list, 3), 'a');
ck_assert_int_eq(*(int*) LinkedList_get(list, 9), 110);
ck_assert_int_eq(*(int*) LinkedList_get(list, 10), 111);
ck_assert_int_eq(*(int*) LinkedList_get(list, 11), 1212);
ck_assert_int_eq(*(int*) LinkedList_get(list, 12), 1313);
ck_assert_int_eq(*(int*) LinkedList_get(list, 13), 1414);
ck_assert_int_eq(LinkedList_size(list), 14);
}
}
int main() {
ALL_TESTS = LinkedList_new();
$(ALL_TESTS, addStart, &dummy_start);
$(ALL_TESTS, addStart, &dummy_tail);
declare_test();
printf("%zu\n", ALL_TESTS->fields->size);
LinkedListNode *p = ALL_TESTS->fields->head;
while(p) {
((TestFunction)(p->data))();
p = p->next;
}
// $(list, removeNode, list->fields->tail); // TODO: allocate the data dynamically.
// assert(_(list, size) == 5);
return 0;
}
RenderBatch* RenderBatch_new(unsigned int objectSize, Texture* texture, unsigned int initialSize)
{
RenderBatch* ret = (RenderBatch*)malloc(sizeof(RenderBatch));
ret->data = BatchData_new(initialSize);
ret->objectSize = objectSize;
ret->dataSize = 0;
ret->texture = texture;
ret->drawables = LinkedList_new();
generateBuffer(&ret->vertexBufferIndex);
generateBuffer(&ret->colorBufferIndex);
generateBuffer(&ret->textureBufferIndex);
return ret;
}
END_TEST
START_TEST(test_StoringMultipleElementsToListWorks) {
LinkedList* list = LinkedList_new();
int elem1 = 1337;
LinkedList_add(list, &elem1);
char* elem2 = "theeta";
LinkedList_add(list, &elem2);
int elem3 = 74;
LinkedList_add(list, &elem3);
char elem4 = 'a';
LinkedList_add(list, &elem4);
ck_assert_int_eq(*(int*) LinkedList_get(list, 0), 1337);
ck_assert_str_eq(*(char**) LinkedList_get(list, 1), "theeta");
ck_assert_int_eq(*(int*) LinkedList_get(list, 2), 74);
ck_assert_int_eq(*(char*) LinkedList_get(list, 3), 'a');
ck_assert_int_eq(LinkedList_size(list), 4);
}
int setSelectedMoveToBest(){
if (movesOfSelectedPiece){
LinkedList_free(movesOfSelectedPiece);
}
movesOfSelectedPiece = LinkedList_new(&PossibleMove_free);
if (!movesOfSelectedPiece){
return -1;
}
PossibleMove* bestMove = getBestMove();
if (!bestMove){
return -1;
}
selectedX = bestMove->fromX;
selectedY = bestMove->fromY;
if(LinkedList_add(movesOfSelectedPiece, bestMove)){
return -1;
}
return 0;
}
END_TEST
START_TEST(test_RemovingElementFromListWorks) {
LinkedList* list = LinkedList_new();
int elem1 = 1337;
LinkedList_add(list, &elem1);
char* elem2 = "theeta";
LinkedList_add(list, &elem2);
int elem3 = 74;
LinkedList_add(list, &elem3);
ck_assert_int_eq(*(int*) LinkedList_get(list, 0), 1337);
ck_assert_str_eq(*(char**) LinkedList_get(list, 1), "theeta");
ck_assert_int_eq(*(int*) LinkedList_get(list, 2), 74);
LinkedList_remove(list, 1);
ck_assert_int_eq(*(int*) LinkedList_get(list, 0), 1337);
ck_assert_int_eq(*(int*) LinkedList_get(list, 1), 74);
ck_assert_int_eq(LinkedList_size(list), 2);
}
#define DEFINE_TEST(name) \
void test_##name() { \
#define END_TEST() \
}
typedef struct {
double height;
int8_t age;
bool gender;
} Person;
DEFINE_TEST(linked_list)
LinkedList *list;
list = LinkedList_new();
// LinkedList_initialize(list, "haha");
assert(list->fields->size == 0);
Person a = {171.1, 16, true};
Person b = {188.8, 18, false};
Person c = {88.8, 8, false};
Person d = {53.8, 8, false};
Person e = {58.8, 8, true};
Person f = {68.8, 8, true};
Person g = {78.8, 8, false};
Person h = {98.8, 8, true};
$(list, addStart, &a);
assert(_(list, size) == 1);
$(list, addEnd, &b);
assert(_(list, size) == 2);
$(list, insertBefore, list->fields->tail, &c);
int Physics_init()
{
activeCollisionChecks = LinkedList_new();
return 0;
}
