X-Git-Url: https://jfr.im/git/irc/gameservirc.git/blobdiff_plain/85ce9d3ecb3e6888dae590b3a8e347e0a2131bd9..18f9660ed8965aa37f7f1222e913ff2a1ed0b004:/gameserv/list.h

diff --git a/gameserv/list.h b/gameserv/list.h
index e9e5656..77e353c 100644
--- a/gameserv/list.h
+++ b/gameserv/list.h
@@ -1,59 +1,92 @@
 #ifndef LIST_H
 #define LIST_H
 
-#include <iostream.h>
+#include <iostream>
 #include <cassert>
 #include "listnode.h"
 #include "aClient.h"
+#include "options.h"
+
+using std::cout;
+using std::endl;
+using std::flush;
+
+extern void log(const char *fmt, ...);
 
 template <class T>
 class List {
     public:
 	List();		//constructor
 	~List();	//deconstructor
-	void insertAtFront( const T & );
-	void insertAtBack( T *&);
+	T *insertAtFront( const T & );
+	T *insertAtBack( T *&);
+	T *random(); // Returns a random element in the list
+	ListNode<T> *insertAtBack_RLN( T *&);
 	bool removeFromFront( T & );
 	bool removeFromBack( T & );
-	bool remove( T * );
+	bool del( T *);
+	ListNode < T > *remove( T * );
 	bool isEmpty() const;
+	#ifdef DEBUGMODE
 	void print() const;
+	#endif
+        void deleteNodes();
+
+	ListNode < T > *Find( T * );
         ListNode < T > *First() { return firstPtr; };
 	ListNode < T > *Last() { return lastPtr; };
+	int elements; // Number of elements in the list
     private:
 	ListNode < T > *firstPtr;
 	ListNode < T > *lastPtr;
 
 	ListNode < T > *getNewNode ( const T &  );
+	ListNode < T > *getNewNode ( T &  );
 };
 
 template <class T>
-List<T>::List() : firstPtr (0), lastPtr (0) {}
+List<T>::List() : firstPtr (0), lastPtr (0) {elements = 0;}
 
 template <class T>
-List<T>::~List()
+void List<T>::deleteNodes()
 {
-    if (!isEmpty())
+    if (isEmpty())
+	return;
+    ListNode<T> *it = firstPtr, *tempPtr;
+    while (it)
     {
-	cout << "Destroying Nodes" << endl;
+	tempPtr = it;
+	it = it->Next();
+	delete tempPtr;
+    }
+    firstPtr = NULL;
+    lastPtr = NULL;
+    elements = 0;
+}
 
-	ListNode<T> *currentPtr = firstPtr, *tempPtr;
+template <class T>
+List<T>::~List()
+{
+    deleteNodes();
+}
 
-	while (currentPtr != 0) 
-	{
-	    tempPtr = currentPtr;
-	    currentPtr = currentPtr->next;
-//	    if (!tempPtr->getData()->stats || tempPtr->getData()->stats->started == 0)
-		delete tempPtr;
-//	    else
-//	        tempPtr->getData()->stats->started = 0;
-	}
-	cout << "All Nodes destroyed" << endl;
+template<class T>
+T *List<T>::random()
+{
+    if (isEmpty())
+	return NULL;
+
+    int num = rand() % elements;
+    ListNode<T> *it = firstPtr;
+    for (int x = 0; x < num; x++)
+    {
+	it = it->Next();
     }
+    return it->getData();
 }
 
 template<class T>
-void List<T>::insertAtFront( const T &value )
+T *List<T>::insertAtFront( const T &value )
 {
     ListNode<T> *newPtr = getNewNode ( value );
 
@@ -66,10 +99,12 @@ void List<T>::insertAtFront( const T &value )
 	firstPtr->prev = newPtr;
 	firstPtr = newPtr;
     }
+    elements++;
+    return firstPtr->getData();
 }
 
 template<class T>
-void List<T>::insertAtBack(T *&value )
+T *List<T>::insertAtBack(T *&value )
 {
     ListNode<T> *newPtr = getNewNode(*value);
 
@@ -83,6 +118,27 @@ void List<T>::insertAtBack(T *&value )
 	lastPtr->next = newPtr;
 	lastPtr = newPtr;
     }
+    elements++;
+    return lastPtr->getData();
+}
+
+template<class T>
+ListNode<T> *List<T>::insertAtBack_RLN(T *&value )
+{
+    ListNode<T> *newPtr = getNewNode(*value);
+
+    if (isEmpty())
+    {
+	firstPtr = lastPtr = newPtr;
+    }
+    else
+    {
+	newPtr->prev = lastPtr;
+	lastPtr->next = newPtr;
+	lastPtr = newPtr;
+    }
+    elements++;
+    return lastPtr;
 }
 
 
@@ -102,6 +158,7 @@ bool List<T>::removeFromFront( T &value )
 
 	value = tempPtr->getData();
 	delete tempPtr;
+	elements--;
 	return true;
     }
 }
@@ -122,14 +179,14 @@ bool List<T>::removeFromBack( T &value )
 
 	value = tempPtr->getData();
 	delete tempPtr;
+	elements--;
 	return true;
-
     }
 }
 
 template <class T>
 bool List<T>::isEmpty() const
-   { return firstPtr == 0; }
+   { return firstPtr == 0 && lastPtr == 0; }
 
 template <class T>
 ListNode<T> *List<T>::getNewNode( const T &value)
@@ -141,6 +198,34 @@ ListNode<T> *List<T>::getNewNode( const T &value)
     return ptr;
 }
 
+template <class T>
+ListNode<T> *List<T>::getNewNode( T &value)
+{
+    ListNode<T> *ptr = new ListNode<T>(value);
+
+    assert( ptr != 0);
+
+    return ptr;
+}
+
+template<class T>
+ListNode<T> *List<T>::Find( T *value )
+{
+    if (isEmpty()) {return NULL;}
+
+    ListNode<T> *currentPtr;
+    currentPtr = firstPtr;
+    while (currentPtr)
+    {
+	cout << currentPtr->getData() << endl << value << endl;
+	if (currentPtr->getData() == value)
+	    return currentPtr;
+	currentPtr = currentPtr->Next();
+    }
+    return NULL;
+}
+
+#ifdef DEBUGMODE
 template <class T>
 void List<T>::print() const
 {
@@ -154,23 +239,54 @@ void List<T>::print() const
     currentPtr = firstPtr;
     while (currentPtr)
     {
-	cout << "aClient: " << *currentPtr->getData();
+	/*
+	cout << "aClient: " << *currentPtr->getData() << flush;
 
         if (currentPtr->getData()->stats)
-	    cout << "  Player Name:" << currentPtr->getData()->stats->name;
+	    cout << "  Player Name: " << currentPtr->getData()->stats->name 
+		 << "   Password: " << currentPtr->getData()->stats->password << flush;
 	cout << endl;
+	*/
+	/*
+	cout << currentPtr->getData()->getString() << endl;
+	currentPtr = currentPtr->next;
+	*/
+	T *dat;
+	dat = currentPtr->getData();
+	log("name: %s", dat->name.c_str());
+	log("weapon: %s", dat->weapon.c_str());
+	log("death: %s", dat->death.c_str());
+	log("strength: %d", dat->strength);
+	log("exp: %ld", dat->exp);
+	log("gold: %ld", dat->gold);
+	log("maxhp: %d", dat->maxhp);
+	log("hp: %d", dat->hp);
 	currentPtr = currentPtr->next;
     }
+}
+#endif
 
-    cout << endl;
+template <class T>
+bool List<T>::del(T *remPtr)
+{
+    ListNode<T> *removed = remove( remPtr );
+    if (removed != NULL)
+    {
+    	delete removed;
+	return true;
+    }
+    return false;
 }
 
 template <class T>
-bool List<T>::remove(T *remPtr)
+ListNode<T> *List<T>::remove(T *remPtr)
 {
     ListNode<T> *newPtr = firstPtr;
     T *testPtr;
 
+    if (isEmpty())
+	return false;
+
     while (newPtr)
     {
 	testPtr = newPtr->getData();
@@ -178,34 +294,43 @@ bool List<T>::remove(T *remPtr)
 	{
 	    if (firstPtr == lastPtr)
 	    {
-		firstPtr = lastPtr = 0;	
-		delete newPtr;
-		return true;
+		#ifdef DEBUGMODE
+		    log("One Element. Deleting it");
+		#endif
+		firstPtr = lastPtr = NULL;
+		return newPtr;
 	    }
 	    else if (newPtr != lastPtr && newPtr != firstPtr)
 	    {
+		#ifdef DEBUGMODE
+		    log("Many elements, this one is in the middle. Deleting it, linking front to back, and back to front.");
+		#endif
 		newPtr->prev->next = newPtr->next;
 		newPtr->next->prev = newPtr->prev;
-		delete newPtr;
-		return true;
+		return newPtr;
 	    }
 	    else if (newPtr == lastPtr)
 	    {
+		#ifdef DEBUGMODE
+		    log("This was the last element. Deleting it, and pointing the tail to its previous element.");
+		#endif
 		lastPtr = newPtr->prev;
 		lastPtr->next = 0;
-		delete newPtr;
-		return true;
+		return newPtr;
 	    }
 	    else if (newPtr == firstPtr)
 	    {
+		#ifdef DEBUGMODE
+		    log("This was the first element. Deleting it, and pointing the head to its next element.");
+		#endif
 		firstPtr = newPtr->next;
 		firstPtr->prev = 0;
-		delete newPtr;
-		return true;
+		return newPtr;
 	    }
+	    elements--;
 	}
 	newPtr = newPtr->next;
     }
-    return false;
+    return NULL;
 }
 #endif