int testInit() {
LinkedList list;
linkedListInit(&list, INTEGER);
_assert(list.head == NULL);
_assert(list.tail == NULL);
_assert(list.valueType == INTEGER);
LinkedList doubleList;
linkedListInit(&doubleList, DOUBLE);
_assert(doubleList.head == NULL);
_assert(doubleList.tail == NULL);
_assert(doubleList.valueType == DOUBLE);
return 0;
}
int main(){
struct linkedList *deque;
linkedListInit(&deque);
linkedListAddFront(&deque, 1);
linkedListAddFront(&deque, 2);
linkedListAddFront(&deque, 3);
printf("front: %d\n", linkedListFront(&deque));
printf("back: %d\n", linkedListBack(&deque));
linkedListAddBack(&deque, 8);
linkedListAddBack(&deque, 7);
linkedListAddBack(&deque, 6);
printf("front: %d\n", linkedListFront(&deque));
printf("back: %d\n", linkedListBack(&deque));
linkedListRemoveBack(&deque);
printf("front: %d\n", linkedListFront(&deque));
printf("back: %d\n", linkedListBack(&deque));
print(&deque);
return 0;
}
int testAppend() {
LinkedList list;
linkedListInit(&list, INTEGER);
linkedListAppend(&list, (mixed)1);
_assert(linkedListIndexOf(&list, (mixed)1) == 0);
linkedListAppend(&list, (mixed)2);
_assert(linkedListIndexOf(&list, (mixed)2) == 1);
return 0;
}
int main(void) {
//USB initializing
SystemInit();
USBD_Init( &USB_OTG_dev,
USB_OTG_HS_CORE_ID,
&USR_desc,
&USBD_CDC_cb,
&USR_cb);
//receiverQueue
LinkedList receiverQueue;
linkedListInit(&receiverQueue);
//senderQueue
LinkedList senderQueue;
linkedListInit(&senderQueue);
//init allocator
TlvElement tlvEle[noOfTlv]={};
initTlvAllocator(tlvEle,noOfTlv);
//initialize receive tlv structure
TlvPacket buffer={};
TlvInfo tlvReceiveInfo={PROCESS_READY,IDLE_RECEIVE,0,&buffer,&receiverQueue};
//initialize flash structure
FlashObject flashObj={OBJ_IDLE,NULL,0,0,NULL,&senderQueue};
FlashInfo flashInfo={FLASH_IDLE,PROCESS_READY,NULL,tlvReceiveInfo.list,&flashObj};
//initialize send tlv structure
TlvInfo tlvSendingInfo={PROCESS_READY,TYPE1_SEND,0,flashInfo.obj->tlv,&senderQueue};
while(1){
tlvReceivePacket(&tlvReceiveInfo);
tlvInterpreter(&flashInfo);
tlvSendPacket(&tlvSendingInfo);
}
}
int testInsert() {
LinkedList list;
linkedListInit(&list, INTEGER);
_assert(linkedListInsert(&list, 1, (mixed)1) == 1); // it succeeds
// 1
_assert(linkedListIndexOf(&list, (mixed)1) == 0);
_assert(linkedListInsert(&list, 0, (mixed)2) == 1); // it succeeds
// 2 -> 1
_assert(linkedListIndexOf(&list, (mixed)2) == 0);
_assert(linkedListInsert(&list, 1, (mixed)3) == 1); // it succeeds
// 2 -> 3 -> 1
_assert(linkedListIndexOf(&list, (mixed)2) == 0);
_assert(linkedListIndexOf(&list, (mixed)3) == 1);
_assert(linkedListIndexOf(&list, (mixed)1) == 2);
return 0;
}
static void aStar( const BNavmesh *navmesh, const BTriangle *startTriangle, const BTriangle *endTriangle, const BVector *destination, BAStarOutput *output )
{
assert( navmesh != NULL );
assert( startTriangle != NULL );
assert( endTriangle != NULL );
assert( destination != NULL );
assert( output != NULL );
assert( isPointInsideNavmeshTriangle( navmesh, destination, endTriangle) );
assert( startTriangle->connectedComponent == endTriangle->connectedComponent );
BLinkedList openList, closedList;
linkedListInit( &openList, sizeof( BAStarNode ), NULL );
linkedListInit( &closedList, sizeof( BAStarNode ), NULL );
BAStarNode startNode;
startNode.cost = 0;
startNode.previousTriangle = NULL;
startNode.triangle = startTriangle;
startNode.heuristic = heuristic( startNode.triangle, destination );
linkedListPrepend( &openList, &startNode );
BAStarNode arrivalNode;
while ( 1 )
{
BAStarNode current;
assert( !linkedListIsEmpty( &openList ) ); // TODO Handle case where no path exists
linkedListGetHead( &openList, ¤t );
linkedListRemoveHead( &openList );
linkedListPrepend( &closedList, ¤t );
if ( current.triangle == endTriangle )
{
arrivalNode = current;
break;
}
for ( int neighborIndex = 0; neighborIndex < 3; neighborIndex++ )
{
const int neighborTriangleIndex = current.triangle->neighbours[neighborIndex];
assert( neighborTriangleIndex < navmesh->numTriangles );
if ( neighborTriangleIndex < 0 )
{
continue;
}
const BTriangle *neighborTriangle = &navmesh->triangles[neighborTriangleIndex];
const float newCost = current.cost + movementCost( current.triangle, neighborTriangle );
BAStarNode occurenceInOpenList;
int inOpenList = linkedListFind( &openList, isTriangle, ( void * ) neighborTriangle, &occurenceInOpenList );
if ( inOpenList )
{
if ( newCost < occurenceInOpenList.cost )
{
linkedListRemove( &openList, isTriangle, ( void * ) ¤t.triangle );
inOpenList = 0;
}
}
const int inClosedList = linkedListFind( &closedList, isTriangle, ( void * ) neighborTriangle, NULL );
if ( !inOpenList && !inClosedList )
{
BAStarNode newNode;
newNode.cost = newCost;
newNode.triangle = neighborTriangle;
newNode.heuristic = heuristic( newNode.triangle, destination );
newNode.previousTriangle = current.triangle;
linkedListInsertBefore( &openList, &newNode, hasBetterRank );
}
}
}
output->numTriangles = 0;
{
const BTriangle *currentTriangle = endTriangle;
while ( currentTriangle != NULL )
{
assert( currentTriangle >= 0 );
BAStarNode node;
verify( linkedListFind( &closedList, isTriangle, ( void * ) currentTriangle, &node ) );
currentTriangle = node.previousTriangle;
output->numTriangles++;
}
}
output->triangles = malloc( sizeof( BTriangle * ) * output->numTriangles );
{
int nextPathTriangleIndex = output->numTriangles - 1;
const BTriangle *currentTriangle = endTriangle;
while ( currentTriangle != NULL )
{
assert( currentTriangle >= 0 );
assert( nextPathTriangleIndex >= 0 );
assert( nextPathTriangleIndex < output->numTriangles );
output->triangles[nextPathTriangleIndex] = currentTriangle;
BAStarNode node;
verify( linkedListFind( &closedList, isTriangle, ( void * ) currentTriangle, &node ) );
currentTriangle = node.previousTriangle;
nextPathTriangleIndex--;
}
}
linkedListFree( &openList );
linkedListFree( &closedList );
assert( output->triangles[0] == startTriangle );
assert( output->triangles[output->numTriangles - 1] == endTriangle );
}
