pvpgn-twilight 0.1.1 → 0.2.3

data/Changes

@@ -34,4 +34,16 @@ Version 0.1.0
 	- Changed text formats to UNIX style
 	
 Version 0.1.1
-	- Changed some code to make this Linux/g++ compatable	
+	- Changed some code to make this Linux/g++ compatable	
+	
+Version 0.2.0
+	- Reverted to C code to avoid some weird linux linkage bug
+	
+Version 0.2.1
+	- Bugs fixes from the conversion
+	
+Version 0.2.2
+	- Added some macros for quick exporting to ruby
+	
+Version 0.2.3
+	- Test release

data/ext/extconf.rb

@@ -1,8 +1,8 @@
 # Loads mkmf which is used to make makefiles for Ruby extensions
 require 'mkmf'
 
-# Do the work
-$CC = 'g++'
-$CXX = $CC
-cpp_command('g++')
-create_makefile('pvpgn')
+# C++ removed...
+#$CC = 'g++'
+#$CXX = $CC
+#cpp_command('g++') if RUBY_VERSION < '1.9'
+create_makefile('pvpgn')

data/ext/pvpgn.c

@@ -0,0 +1,373 @@
+#define PVPGN_TWILIGHT_VERSION "0.2.3"
+#define PVPGN_TWILIGHT_MODULE "PVPGN"
+//#define __TEST__
+/**************************************************/
+/*/												 /*/
+/*/				   Comments & Notes				 /*/
+/*/												 /*/
+/**************************************************/
+/*
+	Sat, 2 Jan 2010, 8:43am: This is all 1 file for now so that it is easy to use
+							 gonna fix it later when stuff gets bigger...
+	
+	Mon, 1 Feb 2010, 6:12pm: converted core to ANSI C, to avoid wierd
+							linux/ruby linkage bug 
+*/
+
+#ifdef __TEST__
+	#include <stdio.h>
+#else
+	//#include "d2bitstream.h"
+	//#include "twilight.h"
+	#include "ruby.h"
+#endif
+
+//bit rotation macros, instead of the MSVC _rotl and _rotr instrisics(takens from pvpgn)
+#define ROTL(x,n,w) (((x) << ((n) & (w - 1))) | ((x) >> (((-(n)) & (w - 1)))))
+#define ROTL32(x,n) ROTL(x,n,32)
+#define ROTL16(x,n) ROTL(x,n,16)
+
+//The Ruby Module Name
+#define RUBY_Module vModule
+//Register a varibale arg func
+#define RUBY_RegisterFunc(x) rb_define_module_function(RUBY_Module,#x,RUBY_##x,-1)
+//Register a set arg func
+#define RUBY_RegisterFuncEx(x,a) rb_define_module_function(RUBY_Module,#x,RUBY_##x,a)
+//Register a new class, returns a VALUE
+#define RUBY_RegisterClass(c) rb_define_class_under(RUBY_Module,#c,rb_cObject)
+//Register an allocator for this class
+#define RUBY_RegisterClassAlloc(c,x) rb_define_alloc_func(c,x)
+//Register a variable arg func for a class
+#define RUBY_RegisterClassFunc(c,x) rb_define_method(c,#x,x,-1)
+//Register a set arg func for a class
+#define RUBY_RegisterClassFunc(c,x,a) rb_define_method(c,#x,x,a)
+
+
+/**************************************************/
+/*/												 /*/
+/*/					D2GS & Diablo II	 		 /*/
+/*/												 /*/
+/**************************************************/
+/*
+//removed pending C conversion :(
+class cD2SaveFile
+{
+	public:
+		enum eD2GameFlags
+		{
+			GFLAG_NEWBIE		=		0x001,
+			GFLAG_HARDCORE		=		0x004,
+			GFLAG_HASDIED		=		0x008,
+			GFLAG_EXPANSION		=		0x020,
+			GFLAG_NOTLADDER		=		0x040
+		};
+
+	protected:
+		char szName[16];
+		int nLevel;
+		int nClass;
+		uint_32 fFlags;
+		int nDifficulty;
+		int nAct;
+		
+	public:
+	//object core
+		cD2SaveFile(const char* szName);
+		~cD2SaveFile();
+		
+	//funcs
+	
+	//inlines
+	inline const char* GetClass() const
+	{
+		static const char* szClasses[7] =
+		{
+			"Amazon",
+		    "Sorceress",
+		    "Necromancer",
+		    "Paladin",
+		    "Barberian",
+		    "Druid",
+		    "Assassin"
+		};
+		
+		return szClasses[nClass];
+	}
+	
+	inline int GetLevel() const
+	{
+		return nLevel;
+	}
+
+	inline int GetDifficulty() const
+	{
+		return nDifficulty;
+	}
+	
+	inline int GetAct() const
+	{
+		return nAct;
+	}
+	
+	inline bool CheckFlag(uint_32 fFlag)
+	{
+		return (fFlags & fFlag);
+	}
+
+	//statics
+};*/
+
+	/******* TODO ********/
+	// - base stat parsing
+	// - item parsing
+	// - skill parsing
+	// - merc data
+	// - ???
+	// - profit!
+
+//needs the trading stuff - item parsing basically
+
+//needs the shared stash stuff - more item parsing plus some block management
+
+//needs to be converted into a struct now :/
+
+/**************************************************/
+/*/												 /*/
+/*/					   PVPGN					 /*/
+/*/												 /*/
+/**************************************************/
+
+static void PVPGN_Hash(unsigned long* pHash, unsigned long* pTemp)
+{
+    unsigned long i;
+    unsigned long a;
+    unsigned long b;
+    unsigned long c;
+    unsigned long d;
+    unsigned long e;
+    unsigned long g;
+	 
+    for(i = 0; i < 64; i++)
+    {
+        pTemp[i + 16] = ROTL32(1,pTemp[i] ^ pTemp[i + 8] ^ pTemp[i + 2] ^ pTemp[i + 13]);
+	}
+
+    a = pHash[0];
+    b = pHash[1];
+    c = pHash[2];
+    d = pHash[3];
+    e = pHash[4];
+
+    for(i = 0; i < 20; i++)
+    {
+	   g = pTemp[i] + ROTL32(a,5) + e + ((b & c) | (~b & d)) + 0x5a827999;
+	   e = d;
+	   d = c;
+	   c = ROTL32(b,30);
+	   b = a;
+	   a = g;
+    }
+
+    for(; i < 40; i++)
+    {
+	   g = (d ^ c ^ b) + e + ROTL32(g,5) + pTemp[i] + 0x6ed9eba1;
+	   e = d;
+	   d = c;
+	   c = ROTL32(b,30);
+	   b = a;
+	   a = g;
+    }
+
+    for (; i < 60; i++)
+    {
+	   g = pTemp[i] + ROTL32(g,5) + e + ((c & b) | (d & c) | (d & b)) - 0x70e44324;
+	   e = d;
+	   d = c;
+	   c = ROTL32(b,30);
+	   b = a;
+	   a = g;
+    }
+
+    for (; i < 80; i++)
+    {
+	   g = (d ^ c ^ b) + e + ROTL32(g,5) + pTemp[i] - 0x359d3e2a;
+	   e = d;
+	   d = c;
+	   c = ROTL32(b,30);
+	   b = a;
+	   a = g;
+    }
+
+    pHash[0] += g;
+    pHash[1] += b;
+    pHash[2] += c;
+    pHash[3] += d;
+    pHash[4] += e;
+}
+
+static void PVPGN_Set16(unsigned long* pDest, const unsigned char* pSource, signed int nSize)
+{   
+    unsigned long i;
+	unsigned long dwPos;
+	
+    if(pDest == 0 || pSource == 0 || nSize < 0)
+    {
+        return;
+	}
+        
+    for(dwPos = 0, i = 0; i < 16; i++)
+    {
+        pDest[i] = 0;
+        if(dwPos < nSize)
+	       pDest[i] |= ((unsigned long)pSource[dwPos]);
+	   
+        dwPos++;
+        if(dwPos < nSize)
+	        pDest[i] |= ((unsigned long)pSource[dwPos]) << 8;
+
+	    dwPos++;
+        if(dwPos < nSize)
+	        pDest[i] |= ((unsigned long)pSource[dwPos]) << 16;
+
+	    dwPos++;
+        if(dwPos < nSize)
+	        pDest[i] |= ((unsigned long)pSource[dwPos]) << 24;
+	    
+        dwPos++;
+    }
+}
+
+static void UTILITY_ToLower(char* pString)
+{
+    char nChar;
+	if(pString == 0)
+	{
+		return;
+	}
+		
+    while((nChar = *pString))
+    {
+        *pString++ = ((nChar < 'A' || nChar > 'Z') ? nChar : (nChar + 0x20));
+	}
+}
+
+static void UTILITY_HexToText(char* pBuffer, unsigned int dwHex, unsigned int bUpper)
+{
+	static const char szHex[] = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
+	static const char szHexU[] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};	 
+	unsigned long i;
+	
+	if(pBuffer == 0)
+	{
+		return;
+	}
+		
+	if(!bUpper)
+	{
+		for(i = 7; i > -1; i--)
+		{
+			int nChar;
+			nChar = dwHex % 16;
+			dwHex >>= 4; 
+			pBuffer[i] = szHex[nChar];
+		}
+	}
+	else
+	{
+		for(i = 7; i > -1; i--)
+		{
+			int nChar;
+			nChar = dwHex % 16;
+			dwHex >>= 4; 
+			pBuffer[i] = szHexU[nChar];
+		}		
+	}
+}
+
+static char* PVPGN_CreateHash(char* pHash, signed int nSize, char pHashOut[41])
+{
+    unsigned long dwLength; 
+	unsigned long i;        
+    unsigned char* pData = (unsigned char*)pHash;
+    unsigned long dwHash[5] = {0x67452301,0xefcdab89,0x98badcfe,0x10325476,0xc3d2e1f0};
+    unsigned long dwTemp[80];
+    
+    if(pHash == 0 || nSize < 1)
+    {
+        return 0;
+	}
+
+    pHashOut[40] = 0;
+    UTILITY_ToLower(pHash);    
+    while(nSize > 0)
+    {
+        dwLength = (nSize > 64) ? 64 : nSize;
+        PVPGN_Set16(dwTemp,pData,dwLength);
+        PVPGN_Hash(dwHash,dwTemp);
+        nSize -= dwLength;
+        pData += dwLength;
+    }
+    
+    for(i = 0; i < 5; i++)
+    {
+    	UTILITY_HexToText(&pHashOut[i * 8],dwHash[i],0);
+	}
+      
+   	return pHashOut;
+}
+ 
+#ifdef __TEST__
+/**************************************************/
+/*/												 /*/
+/*/					Testing						 /*/
+/*/												 /*/
+/**************************************************/
+int main(int argc, char *argv[])
+{
+    char szInput[24];
+    char szHashOut[41];
+    printf("Please Enter Password: ");
+    scanf("Please Enter Password: %s",szInput);
+    printf("Hash: %s\n",PVPGN_CreateHash(szInput,strlen(szInput),szHashOut));
+    system("PAUSE");	
+    return 0;
+}
+#else
+/**************************************************/
+/*/												 /*/
+/*/					Ruby Interface				 /*/
+/*/												 /*/
+/**************************************************/
+
+/*
+* call-seq:
+*	PVPGN.BNHash(string_to_hash)
+*
+* Creates the PVPGN hash for the give string, it is automatically
+* converted to a lower case string, the input is also automatically
+* converted to lower case
+*/
+static VALUE RUBY_BNHash(int argc, VALUE* argv, VALUE klass)
+{
+	char szHashOut[41];
+	VALUE vPassword;
+	char* szPass;
+	
+	if(argc != 1)
+	{
+		rb_raise(rb_eRuntimeError,"RUBY_BNHash(): Invalid Argument Count");
+	}
+		
+	vPassword = argv[0];
+	szPass = StringValuePtr(vPassword);
+ 	return rb_str_new2(PVPGN_CreateHash(szPass,strlen(szPass),szHashOut));
+}
+
+void Init_pvpgn()
+{
+	VALUE RUBY_Module;
+	
+	RUBY_Module = rb_define_module(PVPGN_TWILIGHT_MODULE);
+	RUBY_RegisterFunc(BNHash);	
+}
+#endif

data/pvpgn-twilight.gemspec

@@ -1,14 +1,14 @@
 Gem::Specification.new do |s|
   s.name = %q{pvpgn-twilight}
-  s.version = "0.1.1"
-  s.date = %q{2009-12-02}
-  s.authors = ["Lorenzo Boccetti"]
+  s.version = "0.2.3"
+  s.date = %q{2010-02-04}
+  s.authors = ["Lorenzo 'Necrolis' Boccetti"]
   s.email = %q{necrolis@gamil.com}
   s.summary = %q{A ruby interface for Twilight PVPGN}
   s.homepage = %q{http://www.twilightgaming.co.za}
   s.description = %q{PVPGN-Twilight allows ruby scripts to communicate with pvpgn, while providing faster varients of certain functions, like hashing}
-  s.files = ["pvpgn-twilight.gemspec","ext/pvpgn.cpp","examples/pvpgn_test.rb","ext/extconf.rb","Changes","docs/pvpgn-twilight.txt","pvpgn-twilight.gemspec"]
+  s.files = ["pvpgn-twilight.gemspec","ext/pvpgn.c","examples/pvpgn_test.rb","ext/extconf.rb","Changes","docs/pvpgn-twilight.txt","pvpgn-twilight.gemspec"]
   s.extensions << 'ext/extconf.rb'
   s.has_rdoc = true
-  s.extra_rdoc_files = ["Changes","ext/pvpgn.cpp","docs/pvpgn-twilight.txt"]
+  s.extra_rdoc_files = ["Changes","ext/pvpgn.c","docs/pvpgn-twilight.txt"]
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: pvpgn-twilight
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.2.3
 platform: ruby
 authors: 
-- Lorenzo Boccetti
+- Lorenzo 'Necrolis' Boccetti
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2009-12-02 00:00:00 +02:00
+date: 2010-02-04 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -21,11 +21,11 @@ extensions:
 - ext/extconf.rb
 extra_rdoc_files: 
 - Changes
-- ext/pvpgn.cpp
+- ext/pvpgn.c
 - docs/pvpgn-twilight.txt
 files: 
 - pvpgn-twilight.gemspec
-- ext/pvpgn.cpp
+- ext/pvpgn.c
 - examples/pvpgn_test.rb
 - ext/extconf.rb
 - Changes

data/ext/pvpgn.cpp

@@ -1,206 +0,0 @@
-#define PVPGN_TWILIGHT_VERSION "0.1.0"
-
-#ifdef __TEST__
-#include <iostream>
-#else
-#include "ruby.h"
-#endif
-
-typedef unsigned int t_uint32;
-typedef signed int t_sint32;
-
-#define ROTL(x,n,w) (((x)<<((n)&(w-1))) | ((x)>>(((-(n))&(w-1)))))
-
-#define ROTL32(x,n) ROTL(x,n,32)
-#define ROTL16(x,n) ROTL(x,n,16)
-
-static void PVPGN_Hash(t_uint32* pHash, t_uint32* pTemp)
-{
-    t_uint32 i;
-
-    for(i = 0; i < 64; i++)
-        pTemp[i + 16] = ROTL32(1,pTemp[i] ^ pTemp[i + 8] ^ pTemp[i + 2] ^ pTemp[i + 13]);
-
-    t_uint32 a = pHash[0];
-    t_uint32 b = pHash[1];
-    t_uint32 c = pHash[2];
-    t_uint32 d = pHash[3];
-    t_uint32 e = pHash[4];
-    t_uint32 g;
-
-    for(i = 0; i < 20; i++)
-    {
-	   g = pTemp[i] + ROTL32(a,5) + e + ((b & c) | (~b & d)) + 0x5a827999;
-	   e = d;
-	   d = c;
-	   c = ROTL32(b,30);
-	   b = a;
-	   a = g;
-    }
-
-    for(; i < 40; i++)
-    {
-	   g = (d ^ c ^ b) + e + ROTL32(g,5) + pTemp[i] + 0x6ed9eba1;
-	   e = d;
-	   d = c;
-	   c = ROTL32(b,30);
-	   b = a;
-	   a = g;
-    }
-
-    for (; i < 60; i++)
-    {
-	   g = pTemp[i] + ROTL32(g,5) + e + ((c & b) | (d & c) | (d & b)) - 0x70e44324;
-	   e = d;
-	   d = c;
-	   c = ROTL32(b,30);
-	   b = a;
-	   a = g;
-    }
-
-    for (; i < 80; i++)
-    {
-	   g = (d ^ c ^ b) + e + ROTL32(g,5) + pTemp[i] - 0x359d3e2a;
-	   e = d;
-	   d = c;
-	   c = ROTL32(b,30);
-	   b = a;
-	   a = g;
-    }
-
-    pHash[0] += g;
-    pHash[1] += b;
-    pHash[2] += c;
-    pHash[3] += d;
-    pHash[4] += e;
-}
-
-static void PVPGN_Set16(t_uint32* pDest, const unsigned char* pSource, t_sint32 nSize)
-{   
-    if(pDest == NULL || pSource == NULL || nSize < 0)
-        return;
-        
-    t_uint32 i, dwPos;
-    for(dwPos = 0, i = 0; i < 16; i++)
-    {
-        pDest[i] = 0;
-        if(dwPos < nSize)
-	       pDest[i] |= ((t_uint32)pSource[dwPos]);
-	   
-        dwPos++;
-        if(dwPos < nSize)
-	        pDest[i] |= ((t_uint32)pSource[dwPos]) << 8;
-
-	    dwPos++;
-        if(dwPos < nSize)
-	        pDest[i] |= ((t_uint32)pSource[dwPos]) << 16;
-
-	    dwPos++;
-        if(dwPos < nSize)
-	        pDest[i] |= ((t_uint32)pSource[dwPos]) << 24;
-	    
-        dwPos++;
-    }
-}
-
-static void UTILITY_ToLower(char* pString)
-{
-	if(pString == NULL)
-		return;
-		
-    char nChar = 0;
-    while((nChar = *pString))
-        *pString++ = ((nChar < 'A' || nChar > 'Z') ? nChar : (nChar + 0x20));
-}
-
-static void UTILITY_HexToText(char* pBuffer, t_uint32 dwHex, t_uint32 bUpper = 0)
-{
-	if(pBuffer == NULL)
-		return;
-		
-	static const char szHex[] = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
-	static const char szHexU[] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};	 
-	int i;
-	if(!bUpper)
-	{
-		for(i = 7; i > -1; i--)
-		{
-			int nChar = dwHex % 16;
-			dwHex >>= 4; 
-			pBuffer[i] = szHex[nChar];
-		}
-	}
-	else
-	{
-		for(i = 7; i > -1; i--)
-		{
-			int nChar = dwHex % 16;
-			dwHex >>= 4; 
-			pBuffer[i] = szHexU[nChar];
-		}		
-	}
-}
-
-static char* PVPGN_CreateHash(char* pHash, t_sint32 nSize, char pHashOut[41])
-{
-    if(pHash == NULL || nSize < 1)
-        return NULL;
-
-    t_uint32 dwLength = 0, i;        
-    unsigned char* pData = (unsigned char*)pHash;
-    t_uint32 dwHash[5] = {0x67452301,0xefcdab89,0x98badcfe,0x10325476,0xc3d2e1f0};
-    t_uint32 dwTemp[80];
-
-    pHashOut[40] = 0;
-    UTILITY_ToLower(pHash);    
-    while(nSize > 0)
-    {
-        dwLength = (nSize > 64) ? 64 : nSize;
-        PVPGN_Set16(dwTemp,pData,dwLength);
-        PVPGN_Hash(dwHash,dwTemp);
-        nSize -= dwLength;
-        pData += dwLength;
-    }
-    
-    for(i = 0; i < 5; i++)
-    	UTILITY_HexToText(&pHashOut[i * 8],dwHash[i]);
-      
-   	return pHashOut;
-} 
-#ifdef __TEST__
-int main(int argc, char *argv[])
-{
-    std::string sInput;
-    std::cout << "Please Enter Password: ";
-    std::cin >> sInput;
-    std::cout << "Hash: " << PVPGN_CreateHash((char*)sInput.c_str(),sInput.size()) << std::endl;
-    system("PAUSE");	
-    return 0;
-}
-#else
-/*
-* call-seq:
-*	PVPGN.BNHash(string_to_hash)
-*
-* Creates the PVPGN hash for the give string, it is automatically
-* converted to a lower case string, the input is also automatically
-* converted to lower case
-*/
-static VALUE RUBY_BNHash(int argc, VALUE* argv, VALUE klass)
-{
-	char szHashOut[41];
-	VALUE vPassword;
-	if(argc != 1)
-		rb_raise(rb_eRuntimeError,"RUBY_BNHash(): Invalid Amount of Arguments");
-		
-	vPassword = argv[0];
-	char* szPass = StringValuePtr(vPassword);
- 	return rb_str_new2(PVPGN_CreateHash(szPass,strlen(szPass),szHashOut));
-}
-
-void Init_pvpgn()
-{
-	static VALUE mPVPGN = rb_define_module("PVPGN");
-   	rb_define_module_function(mPVPGN,"BNHash",(VALUE (*)(...))RUBY_BNHash,-1);	
-}
-#endif