Hello! So I've got this assignement from my school to create a Bouncing Ball animation using SDL.

I have been provided a header file which contains an array of all the triangles that make up the ball. Also I have been provided some empty methods that needs implementation.

Each ball must be represented as a separate object data structure (see "object.h" in the zip file). The object data structure contains all variables pertinent to rendering the object on the screen (translation, scale, model coordinates, etc.). Note that the object data structure uses floats to represent translation coordinates. This is to make it easier to handle very small movements (at points, a ball might be moving at a speed less than a pixel). Cast the translation coordinates into integers before drawing the triangles on the screen.

Your code must keep track of objects (balls) by placing the object data structures in a linked list. You need to create your own linked list implementation. Below is a brief description of the object programming interface:

• CreateObject - Create a new object. The function accepts as input parameters a pointer to the SDL screen, a pointer to a model triangle array, and a variable telling the size of the model triangle array. The function returns a pointer to a new object data structure. The model triangle array specified as input parameter should not be shared across objects. (Not sharing the model triangle array allows e.g. objects to have different colors.) Perform the necessary memory allocation and copying.
• DestroyObject - Free object. The function accepts as input parameters a pointer to an object data structure. The function should free all memory allocated to represent the object (memory allocated for the model triangle array and the object data structure itself).
• Drawobject - Draw object on screen. The function accepts as input parameters a pointer to an object data structure. The function must draw the object on the screen by calling DrawTriangle on each of the model triangles. Remember to update scale, translation, etc., in each triangle data structure before invoking DrawTriangle.

This is my assignment. I dont want anyone to post entire code, because I want to learn myself. So far I have 1 single ball on the screen(not moving yet) However I'm having some difficulties with storing the Objects. To make 1 ball i need to iterate with a for loop through the entire triangle array.

int i;
for(i = 0; i < SPHERE_NUMTRIANGLES; i++){
    object = CreateObject(screen,&sphere_model[i],SPHERE_NUMTRIANGLES);			
    DrawObject(object);			
}

This creates 1 ball, but then i need to save my object into a linked list. How do i store my entire object into ONE object? instead of storing each object for each sphere_model? The reason is because i need to create multiple balls to be shown on the screen at once.

object_t *CreateObject(SDL_Surface *screen, triangle_t *model, int numtriangles)
{
    // Implement me
	object_t *object = malloc(sizeof(object_t));
	object->model = malloc(sizeof(triangle_t) * numtriangles);
	object->screen = screen;
	object->ttl = 5000;
	//TODO: ADD RANDOM SPEED
	object->speedx = 10;
	object->speedy = 5;
	object->model = model;
	object->model->scale = 0.1f;
	object->model->tx = screen->w/2.f;
	object->model->ty = 70.0f;
        return object;

I see! Thanks. Linked lists are entirely new to us so I'm having a little bit of struggle with that. This is the list.c that was included.

typedef struct listnode listnode_t;
struct listnode {
    listnode_t  *next;
    void        *item;
};

struct list {
    listnode_t *head;
    int numitems;
};

// Create new list
list_t *list_create(void)
{
    // Implement me
    list_t *myHead;
    myHead->next = NULL; <- this is as far as i have gotten with the lists
}

// Free list. items not freed.
void list_destroy(list_t *list)
{
    // Implement me
}

// Insert item first in list
int list_addfirst(list_t *list, void *item)
{
    // Implement me
}

// Insert item last in list.
int list_addlast(list_t *list, void *item)
{
    // Implement me
}

// Remove item from list
void list_remove(list_t *list, void *item)
{
    // Implement me
}

// Return # of items in list
int list_size(list_t *list)
{
    // Implement me
}

/*
 * Iterator implementation
 */

struct list_iterator {
    listnode_t *next;
    list_t *list;
};

// Create new list iterator
list_iterator_t *list_createiterator(list_t *list)
{
    // Implement me
}

// Free iterator
void list_destroyiterator(list_iterator_t *iter)
{
    // Implement me
}

// Move iterator to next item in list and return current.
void *list_next(list_iterator_t *iter)
{
    // Implement me
}

// Let iterator point to first item in list again
void list_resetiterator(list_iterator_t *iter)
{
    // Implement me
}

So, what I do know about lists, is that the head should contain a pointer to the first node? Further, all nodes should contain pointers to the next node? I do have a book on linked lists, but it only has 1 list and not one type for the iterator and one for the node. Any tips perhaps?

Also, in the loop i posted in the first post, does this seem about right?

list_t *myList = list_create();


int i;
for(i = 0; i < SPHERE_NUMTRIANGLES; i++){
    object = CreateObject(screen,&sphere_model[i],SPHERE_NUMTRIANGLES);	
    //save each object into the list
    list_addfirst(myList,object);
   		
}

and in the list.c
list_t *list_create(void){
 
  list_t *myList = (list_t *) malloc(sizeof(list_t));
  mylist->head = NULL;
numitems -> not sure about this one.
}

#include <stdio.h>
#include <stdlib.h>
#include "list.h"


/*
 * List implementation
 */
 
typedef struct listnode listnode_t;
struct listnode {
    listnode_t  *next;
    void        *item;
};

struct list {
    listnode_t *head;
    int numitems;
};
// Create new list
list_t *list_create(void)
{
    // Implement me
	list_t *listHead = (list_t*)malloc(sizeof(list_t));
	
	listHead->head = NULL;
	listHead->numitems = 0;
	
	return listHead;
}
// Free list. items not freed.
void list_destroy(list_t *list)
{
    // Implement me
	free(list);
}
// Insert item first in list
int list_addfirst(list_t *list, void *item)
{	
    // Implement me	
	listnode_t *node = (listnode_t *)malloc(sizeof(listnode_t));
	node->item = item;
	//Set the next element to be the first element
	node->next = list->head;
	list->head = node;
	list->numitems++;	
	
	return 0;
}
// Insert item last in list.
int list_addlast(list_t *list, void *item)
{
    // Implement me
	list->numitems++;
	return 0;
}
// Remove item from list
void list_remove(list_t *list, void *item)
{
    // Implement me
	free(item);
	list->numitems--;
}
// Return # of items in list
int list_size(list_t *list)
{
    // Implement me
	printf("Number of items in list: %d\n",list->numitems);
	return 0;
}
/*
 * Iterator implementation
 */ 
struct list_iterator {
    listnode_t *next;
    list_t *list;
};
// Create new list iterator
list_iterator_t *list_createiterator(list_t *list)
{
    // Implement me
	list_iterator_t *iterator = (list_iterator_t*)malloc(sizeof(list_iterator_t));
	//point the iterator to the first element
	iterator->next = list->head;
	
	return iterator;
}
// Free iterator
void list_destroyiterator(list_iterator_t *iter)
{
    // Implement me
	free(iter);
}
// Move iterator to next item in list and return current.
void *list_next(list_iterator_t *iter)
{
    // Implement me	

	if(iter->next == NULL){
		//end of list
		printf("Reached end of the list");
	}	
	else{
		printf("Going through the list");	
		iter = iter->next;
	}
}
// Let iterator point to first item in list again
void list_resetiterator(list_iterator_t *iter)
{
    // Implement me
	iter->next = iter->list->head;
}

Thanks for all your help so far! I'm having some issue with resetiterator and list_next. When I call resetiterator i get a segment fault and list_next it never moves to the next object in the list.Do you see what i'm doing wrong here?