Sancaros/stoneage8.5
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
1997fc2045
stoneage8.5/石器时代8.5客户端最新源代码/石器源码/newproto/autil.cpp

972 lines
24 KiB
C++
Raw Normal View History

change file encoding
2020-06-23 15:53:23 +08:00
// Arminius' protocol utilities ver 0.1
reupload
2020-06-23 15:27:59 +08:00
//
// Any questions and bugs, mailto: arminius@mail.hwaei.com.tw
// -------------------------------------------------------------------
// The following definitions is to define game-dependent codes.
// Before compiling, remove the "//".
#define __STONEAGE
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include "autil.h"
#include "../systeminc/chat.h"
#include "../systeminc/font.h"
#include "../systeminc/VMProtectSDK.h"
#ifdef __STONEAGE
#include "../systeminc/version.h"
#include "../systeminc/lssproto_util.h"
//#include "../systeminc/common.h"
#endif
char **MesgSlice;
int SliceCount;
char PersonalKey[32];
#ifdef _STONDEBUG_
extern int g_iMallocCount;
#endif
// -------------------------------------------------------------------
// Initialize utilities
//
void util_Init(void)
{
int i;
MesgSlice = (char **) MALLOC(sizeof(char *) * SLICE_MAX);
#ifdef _STONDEBUG_
g_iMallocCount++;
#endif
for (i=0; i<SLICE_MAX; i++){
MesgSlice[i] = (char *) MALLOC(SLICE_SIZE);
#ifdef _STONDEBUG_
g_iMallocCount++;
#endif
}
SliceCount = 0;
}
// -------------------------------------------------------------------
// Split up a message into slices by spearator. Store those slices
// into a global buffer "char **MesgSlice"
//
// arg: source=message string; separator=message separator (1 byte)
// ret: (none)
void util_SplitMessage(char *source, char *separator)
{
if (source && separator) { // NULL input is invalid.
char *ptr;
char *head = source;
while ((ptr = (char *) strstr(head, separator)) && (SliceCount<=SLICE_MAX)) {
ptr[0] = '\0';
if (strlen(head)<SLICE_SIZE) { // discard slices too large
strcpy(MesgSlice[SliceCount], head);
SliceCount++;
}
head = ptr+1;
}
strcpy(source,head); // remove splited slices
}
}
// -------------------------------------------------------------------
// Encode the message
//
// arg: dst=output src=input
// ret: (none)
void util_EncodeMessage(char *dst, char *src)
{
int rn = rand()%99;
int t1, t2;
char t3[65500], tz[65500];
#ifdef _BACK_VERSION
util_swapint(&t1, &rn, "3421"); // encode seed
#else
util_swapint(&t1, &rn, "2413"); // encode seed
#endif
// t2 = t1 ^ 0x0f0f0f0f;
t2 = t1 ^ 0xffffffff;
util_256to64(tz, (char *) &t2, sizeof(int), DEFAULTTABLE);
util_shlstring(t3, src, rn);
// printf("random number=%d\n", rn);
strcat_s(tz, t3);
util_xorstring(dst, tz);
}
// -------------------------------------------------------------------
// Decode the message
//
// arg: dst=output src=input
// ret: (none)
void util_DecodeMessage(char *dst, char *src)
{
// strcpy(dst, src);
// util_xorstring(dst, src);
#define INTCODESIZE (sizeof(int)*8+5)/6
int rn;
int *t1, t2;
char t3[4096], t4[4096]; // This buffer is enough for an integer.
char tz[65500];
if( src[strlen(src)-1] == '\n')
src[strlen(src)-1] = 0;
util_xorstring(tz, src);
rn=INTCODESIZE;
// printf("INTCODESIZE=%d\n", rn);
strncpy_s(t4, tz, INTCODESIZE);
t4[INTCODESIZE] = '\0';
util_64to256(t3, t4, DEFAULTTABLE);
t1 = (int *) t3;
// t2 = *t1 ^ 0x0f0f0f0f;
t2 = *t1 ^ 0xffffffff;
#ifdef _BACK_VERSION
util_swapint(&rn, &t2, "4312");
#else
util_swapint(&rn, &t2, "3142");
#endif
// printf("random number=%d\n", rn);
util_shrstring(dst, tz + INTCODESIZE, rn);
}
// -------------------------------------------------------------------
// Get a function information from MesgSlice. A function is a complete
// and identifiable message received, beginned at DEFAULTFUNCBEGIN and
// ended at DEFAULTFUNCEND. This routine will return the function ID
// (Action ID) and how many fields this function have.
//
// arg: func=return function ID fieldcount=return fields of the function
// ret: 1=success 0=failed (function not complete)
int util_GetFunctionFromSlice(int *func, int *fieldcount)
{
char t1[16384];
int i;
// if (strcmp(MesgSlice[0], DEFAULTFUNCBEGIN)!=0) util_DiscardMessage();
strcpy(t1, MesgSlice[1]);
// Robin adjust
//*func=atoi(t1);
*func=atoi(t1)-23;
for (i=0; i<SLICE_MAX; i++)
if (strcmp(MesgSlice[i], DEFAULTFUNCEND)==0) {
*fieldcount=i-2; // - "&" - "#" - "func" 3 fields
return 1;
}
return 0; // failed: message not complete
}
// -------------------------------------------------------------------
// Discard a message from MesgSlice.
//
void util_DiscardMessage(void)
{
SliceCount=0;
/*
int i,j;
void *ptr;
i=0;
while ((i<SliceCount)&&(strcmp(MesgSlice[i], DEFAULTFUNCBEGIN)!=0)) i++;
if (i>=SliceCount) {
// discard all message
for (j=0; j<SliceCount; j++) strcpy(MesgSlice[j],"");
} else {
for (j=0; j<SliceCount-i; j++) {
ptr=MesgSlice[j];
MesgSlice[j]=MesgSlice[j+i];
MesgSlice[j+i]=ptr;
}
}
*/
}
#ifdef _NEWNET_
update build setting
2020-06-23 17:31:16 +08:00
extern long TEA加密(long* v, long n, long* k);
reupload
2020-06-23 15:27:59 +08:00
void stringtohexstr(char* dst, char* src,int len)
{
int i;
for (i = 0; i < len; i++) {
sprintf(dst + 2*i, "%02X ", (unsigned char)src[i]);
}
dst[len*2] = '\0';
}
void util_EncodeMessageTea(char *t2,char *t1)
{
#ifdef _VMP_
VMProtectBegin("util_EncodeMessageTea");
#endif
int len = strlen(t1);
len = len%4?len/4+1:len/4;
#ifdef _VMP_
update build setting
2020-06-23 17:31:16 +08:00
TEA加密((long*)t1,len,(long *)VMProtectDecryptStringA(DENGLUKEY1));
reupload
2020-06-23 15:27:59 +08:00
#else
update build setting
2020-06-23 17:31:16 +08:00
TEA加密((long*)t1,len,(long *)DENGLUKEY1);
reupload
2020-06-23 15:27:59 +08:00
#endif
stringtohexstr(t2,t1,len*4);
#ifdef _VMP_
VMProtectEnd();
#endif
}
#endif
// -------------------------------------------------------------------
// Send a message
//
// arg: fd=socket fd func=function ID buffer=data to send
void util_SendMesg(int fd, int func, char *buffer)
{
#ifdef _VMP_
VMProtectBegin("util_SendMesg");
#endif
char t1[16384], t2[16384];
sprintf_s(t1, sizeof(t1),"(&;%d%s;#;", func+13, buffer);
#ifdef _NEWNET_
util_EncodeMessageTea(t2, t1);
#else
util_EncodeMessage(t2, t1);
#endif
#ifdef __STONEAGE
lssproto_Send(fd, t2);
#endif
#ifdef _VMP_
VMProtectEnd();
#endif
}
// -------------------------------------------------------------------
// Convert 8-bit strings into 6-bit strings, buffers that store these strings
// must have enough space.
//
// arg: dst=8-bit string; src=6-bit string; len=src strlen;
// table=mapping table
// ret: 0=failed >0=bytes converted
int util_256to64(char *dst, char *src, int len, char *table)
{
unsigned int dw,dwcounter;
int i;
if (!dst || !src || !table) return 0;
dw=0;
dwcounter=0;
for (i=0; i<len; i++) {
dw = ( ((unsigned int)src[i] & 0xff) << ((i%3)<<1) ) | dw;
dst[ dwcounter++ ] = table[ dw & 0x3f ];
dw = ( dw >> 6 );
if (i%3==2) {
dst[ dwcounter++ ] = table[ dw & 0x3f ];
dw = 0;
}
}
if (dw) dst[ dwcounter++ ] = table[ dw ];
dst[ dwcounter ] = '\0';
return dwcounter;
}
// -------------------------------------------------------------------
// Convert 6-bit strings into 8-bit strings, buffers that store these strings
// must have enough space.
//
// arg: dst=6-bit string; src=8-bit string; table=mapping table
// ret: 0=failed >0=bytes converted
int util_64to256(char *dst, char *src, char *table)
{
unsigned int dw,dwcounter;
unsigned int i, j;
char *ptr = NULL;
dw=0;
dwcounter=0;
if (!dst || !src || !table) return 0;
char c;
for (i=0; i<strlen(src); i++) {
c = src[i];
for( j = 0; j < strlen(table); j++){
if( table[j] == c){
ptr = table+j;
break;
}
}
if (!ptr) return 0;
if (i%4) {
dw = ((unsigned int)(ptr-table) & 0x3f) << ((4-(i%4))<<1) | dw;
dst[ dwcounter++ ] = dw & 0xff;
dw = dw >> 8;
} else {
dw = (unsigned int)(ptr-table) & 0x3f;
}
}
if (dw) dst[ dwcounter++ ] = dw & 0xff;
dst[ dwcounter ] = '\0';
return dwcounter;
}
// -------------------------------------------------------------------
// This basically is a 256to64 encoder. But it shifts the result by key.
//
// arg: dst=6-bit string; src=8-bit string; len=src strlen;
// table=mapping table; key=rotate key;
// ret: 0=failed >0=bytes converted
int util_256to64_shr(char *dst, char *src, int len, char *table, char *key)
{
unsigned int dw,dwcounter,j;
int i;
if (!dst || !src || !table || !key) return 0;
if (strlen(key)<1) return 0; // key can't be empty.
dw=0;
dwcounter=0;
j=0;
for (i=0; i<len; i++) {
dw = ( ((unsigned int)src[i] & 0xff) << ((i%3)<<1) ) | dw;
dst[ dwcounter++ ] = table[ ((dw & 0x3f) + key[j]) % 64 ]; // check!
j++; if (!key[j]) j=0;
dw = ( dw >> 6 );
if (i%3==2) {
dst[ dwcounter++ ] = table[ ((dw & 0x3f) + key[j]) % 64 ];// check!
j++; if (!key[j]) j=0;
dw = 0;
}
}
if (dw) dst[ dwcounter++ ] = table[ (dw + key[j]) % 64 ]; // check!
dst[ dwcounter ] = '\0';
return dwcounter;
}
// -------------------------------------------------------------------
// Decoding function of util_256to64_shr.
//
// arg: dst=8-bit string; src=6-bit string; table=mapping table;
// key=rotate key;
// ret: 0=failed >0=bytes converted
int util_shl_64to256(char *dst, char *src, char *table, char *key)
{
unsigned int dw,dwcounter,i,j,k;
char *ptr = NULL;
if (!key || (strlen(key)<1)) return 0; // must have key
dw=0;
dwcounter=0;
j=0;
if (!dst || !src || !table) return 0;
char c;
for (i=0; i<strlen(src); i++) {
c = src[i];
for( k = 0; k < strlen(table); k++){
if( table[k] == c){
ptr = table+k;
break;
}
}
if (!ptr) return 0;
if (i%4) {
// check!
dw = ((((unsigned int)(ptr-table) & 0x3f) + 64 - key[j]) % 64)
<< ((4-(i%4))<<1) | dw;
j++; if (!key[j]) j=0;
dst[ dwcounter++ ] = dw & 0xff;
dw = dw >> 8;
} else {
// check!
dw = (((unsigned int)(ptr-table) & 0x3f) + 64 - key[j]) % 64;
j++; if (!key[j]) j=0;
}
}
if (dw) dst[ dwcounter++ ] = dw & 0xff;
dst[ dwcounter ] = '\0';
return dwcounter;
}
// -------------------------------------------------------------------
// This basically is a 256to64 encoder. But it shifts the result by key.
//
// arg: dst=6-bit string; src=8-bit string; len=src strlen;
// table=mapping table; key=rotate key;
// ret: 0=failed >0=bytes converted
int util_256to64_shl(char *dst, char *src, int len, char *table, char *key)
{
unsigned int dw,dwcounter;
int i, j;
if (!dst || !src || !table || !key) return 0;
if (strlen(key)<1) return 0; // key can't be empty.
dw=0;
dwcounter=0;
j=0;
for (i=0; i<len; i++) {
dw = ( ((unsigned int)src[i] & 0xff) << ((i%3)<<1) ) | dw;
dst[ dwcounter++ ] = table[ ((dw & 0x3f) + 64 - key[j]) % 64 ]; // check!
j++; if (!key[j]) j=0;
dw = ( dw >> 6 );
if (i%3==2) {
dst[ dwcounter++ ] = table[ ((dw & 0x3f) + 64 - key[j]) % 64 ]; // check!
j++; if (!key[j]) j=0;
dw = 0;
}
}
if (dw) dst[ dwcounter++ ] = table[ (dw + 64 - key[j]) % 64 ]; // check!
dst[ dwcounter ] = '\0';
return dwcounter;
}
// -------------------------------------------------------------------
// Decoding function of util_256to64_shl.
//
// arg: dst=8-bit string; src=6-bit string; table=mapping table;
// key=rotate key;
// ret: 0=failed >0=bytes converted
int util_shr_64to256(char *dst, char *src, char *table, char *key)
{
unsigned int dw,dwcounter,i,j,k;
char *ptr = NULL;
if (!key || (strlen(key)<1)) return 0; // must have key
dw=0;
dwcounter=0;
j=0;
if (!dst || !src || !table) return 0;
char c;
for (i=0; i<strlen(src); i++) {
c = src[i];
for( k = 0; k < strlen(table); k++){
if( table[k] == c){
ptr = table+k;
break;
}
}
if (!ptr) return 0;
if (i%4) {
// check!
dw = ((((unsigned int)(ptr-table) & 0x3f) + key[j]) % 64)
<< ((4-(i%4))<<1) | dw;
j++; if (!key[j]) j=0;
dst[ dwcounter++ ] = dw & 0xff;
dw = dw >> 8;
} else {
// check!
dw = (((unsigned int)(ptr-table) & 0x3f) + key[j]) % 64;
j++; if (!key[j]) j=0;
}
}
if (dw) dst[ dwcounter++ ] = dw & 0xff;
dst[ dwcounter ] = '\0';
return dwcounter;
}
// -------------------------------------------------------------------
// Swap a integer (4 byte).
// The value "rule" indicates the swaping rule. It's a 4 byte string
// such as "1324" or "2431".
//
void util_swapint(int *dst, int *src, char *rule)
{
char *ptr, *qtr;
int i;
ptr = (char *) src;
qtr = (char *) dst;
for (i=0; i<4; i++) qtr[rule[i]-'1']=ptr[i];
}
// -------------------------------------------------------------------
// Xor a string. Be careful that your string contains '0xff'. Your
// data may lose.
//
void util_xorstring(char *dst, char *src)
{
unsigned int i;
for (i=0; i<strlen(src); i++) dst[i]=src[i]^255;
dst[i]='\0';
}
// -------------------------------------------------------------------
// Shift the string right.
//
void util_shrstring(char *dst, char *src, int offs)
{
char *ptr;
int len = strlen(src);
if (!dst || !src || (strlen(src)<1)) return;
offs = strlen(src) - (offs % strlen(src));
ptr = src+offs;
strcpy(dst, ptr);
strncat_s(dst,16384, src, offs);
dst[strlen(src)]='\0';
}
// -------------------------------------------------------------------
// Shift the string left.
//
void util_shlstring(char *dst, char *src, int offs)
{
char *ptr;
if (!dst || !src || (strlen(src)<1)) return;
offs = offs % strlen(src);
ptr = src+offs;
strcpy(dst, ptr);
strncat_s(dst,65500, src, offs);
dst[strlen(src)]='\0';
}
// -------------------------------------------------------------------
// Convert a message slice into integer. Return a checksum.
//
// arg: sliceno=slice index in MesgSlice value=result
// ret: checksum, this value must match the one generated by util_mkint
int util_deint(int sliceno, int *value)
{
int *t1, t2;
char t3[4096]; // This buffer is enough for an integer.
util_shl_64to256(t3, MesgSlice[sliceno], DEFAULTTABLE, PersonalKey);
t1 = (int *) t3;
t2 = *t1 ^ 0xffffffff;
#ifdef _BACK_VERSION
util_swapint(value, &t2, "3421");
#else
util_swapint(value, &t2, "2413");
#endif
return *value;
}
// -------------------------------------------------------------------
// Pack a integer into buffer (a string). Return a checksum.
//
// arg: buffer=output value=data to pack
// ret: checksum, this value must match the one generated by util_deint
int util_mkint(char *buffer, int value)
{
int t1, t2;
char t3[4096]; // This buffer is enough for an integer.
#ifdef _BACK_VERSION
util_swapint(&t1, &value, "4312");
#else
util_swapint(&t1, &value, "3142");
#endif
t2 = t1 ^ 0xffffffff;
util_256to64_shr(t3, (char *) &t2, sizeof(int), DEFAULTTABLE, PersonalKey);
strcat(buffer, ";"); // It's important to append a SEPARATOR between fields
strcat(buffer, t3);
return value;
}
// -------------------------------------------------------------------
// Convert a message slice into string. Return a checksum.
//
// arg: sliceno=slice index in MesgSlice value=result
// ret: checksum, this value must match the one generated by util_mkstring
int util_destring(int sliceno, char *value)
{
util_shr_64to256(value, MesgSlice[sliceno], DEFAULTTABLE, PersonalKey);
return strlen(value);
}
// -------------------------------------------------------------------
// Convert a string into buffer (a string). Return a checksum.
//
// arg: buffer=output value=data to pack
// ret: checksum, this value must match the one generated by util_destring
int util_mkstring(char *buffer, char *value)
{
char t1[SLICE_SIZE];
util_256to64_shl(t1, value, strlen(value), DEFAULTTABLE, PersonalKey);
strcat_s(buffer,16384, ";"); // It's important to append a SEPARATOR between fields
strcat_s(buffer,16384, t1);
return strlen(value);
}
void util_Release(void)
{
int i;
if(MesgSlice){
for(i=0;i<SLICE_MAX;i++){
if(MesgSlice[i]){
FREE(MesgSlice[i]);
#ifdef _STONDEBUG_
g_iMallocCount--;
#endif
}
}
FREE(MesgSlice);
#ifdef _STONDEBUG_
g_iMallocCount--;
#endif
}
}
change file encoding
2020-06-23 15:53:23 +08:00
int strcmptail( char *s1 , char *s2 )
{
int i;
int len1 = strlen( s1 );
int len2 = strlen( s2 );
for(i=0;;i++){
int ind1 = len1 - 1 - i;
int ind2 = len2 - 1 - i;
if( ind1 < 0 || ind2 < 0 ) return 0;
if( s1[ind1] != s2[ind2] ) return 1;
}
}
reupload
2020-06-23 15:27:59 +08:00
#define IS_2BYTEWORD( _a_ ) ( (char)(0x80) <= (_a_) && (_a_) <= (char)(0xFF) )
change file encoding
2020-06-23 15:53:23 +08:00
char * ScanOneByte( char *src, char delim ){
if (!src) return NULL;
for( ;src[0] != '\0'; src ++ ){
if( IS_2BYTEWORD( src[0] ) ){
if( src[1] != 0 ){
src ++;
}
continue;
}
if( src[0] == delim ){
return src;
}
}
return NULL;
}
char* strncpy2( char* dest, const char* src, size_t n )
{
if( n > 0 ){
char* d = dest;
const char* s = src;
unsigned int i;
for( i=0; i<n ; i++ ){
if( *(s+i) == 0 ){
*(d+i) = '\0';
return dest;
}
if( *(s+i) & 0x80 ){
*(d+i) = *(s+i);
i++;
if( i>=n ){
*(d+i-1)='\0';
break;
}
*(d+i) = *(s+i);
}else
*(d+i) = *(s+i);
}
}
return dest;
}
void strcpysafe( char* dest ,size_t n ,const char* src )
{
if (!src) {
*dest = '\0';
return;
}
if( n <= 0 )
return;
else if( n < strlen( src ) + 1 ){
strncpy2( dest , src , n-1 );
dest[n-1]='\0';
}else
strcpy( dest , src );
}
void strncpysafe( char* dest , const size_t n ,
const char* src ,const int length )
{
unsigned int Short;
Short = min( strlen( src ) ,(unsigned int) length );
if( n < Short + 1 ){
strncpy2( dest , src , n-1 );
dest[n-1]='\0';
}else if( n <= 0 ){
return;
}else{
strncpy2( dest , src , Short );
dest[Short]= '\0';
}
}
BOOL getStringFromIndexWithDelim_body( char* src ,char* delim ,int index,char* buf , int buflen)
{
int i;
int length =0;
int addlen=0;
int oneByteMode = 0;
if( strlen( delim ) == 1 ){
oneByteMode = 1;
}
for( i = 0 ; i < index ; i ++ ){
char* last;
src += addlen;
if( oneByteMode ){
last = ScanOneByte( src, delim[0] );
}else{
last = strstr( src , delim );
}
if( last == NULL ){
strcpysafe( buf , buflen, src );
if( i == index - 1 ){
if(buf[0]==0) return FALSE;
return TRUE;
}
buf[0]=0;
return FALSE;
}
length = last - src;
addlen= length + strlen( delim );
}
strncpysafe( buf, buflen , src,length );
if(buf[0]==0) return FALSE;
return TRUE;
}
reupload
2020-06-23 15:27:59 +08:00
void ltrim(char *str){
char *ptr;
for(ptr=str; *ptr == 32; ptr++) ;
}
void rtrim(char *str){
int i;
for(i=(int)strlen(str)-1; str[i] == 32 && i>=0; str[i--]=0);
}
#ifdef _FONT_STYLE_
WM_STR wmstr[25];
extern int getTextLength(char * str);
void getstrstyle(char *str,int index,int pos,int flg,WM_STR wm[])
{
char *stemp,*etemp;
if(flg)
stemp = str;
else
stemp = sunday(str, "[style ");
if(stemp){
if(stemp!= str){
wm[index].flg=TRUE;
wm[index].style[pos].size = FONT_SIZE1;
if(pos==0)
wm[index].style[pos].x = 0;
else
wm[index].style[pos].x = getTextLength(wm[index].style[pos-1].str)+wm[index].style[pos-1].x;
wm[index].style[pos].color = 0;
int len = stemp - str;
memcpy(wm[index].style[pos].str,str,len);
wm[index].style[pos].str[len]=NULL;
pos++;
getstrstyle(stemp,index,pos,TRUE,wm);
}else{
wm[index].flg=TRUE;
stemp=stemp+7;
etemp = sunday(stemp, "]")+1;
char *scolor = sunday(stemp, "c=");
if(scolor){
scolor=scolor+2;
char strnum[3];
int i=0;
for(i;i<2 && scolor[i] !=' ' && scolor[i]!=']';i++){
strnum[i] = scolor[i];
}
strnum[i]=0;
wm[index].style[pos].color = atoi(strnum);
}else wm[index].style[pos].color =0;
char *ssize = sunday(stemp, "s=");
if(ssize){
ssize=ssize+2;
char strsize[3];
int i=0;
for(i;i<2 && ssize[i] !=' ' && ssize[i]!=']';i++){
strsize[i] = ssize[i];
}
strsize[i]=0;
wm[index].style[pos].size = atoi(ssize);
}else wm[index].style[pos].size = FONT_SIZE1;
stemp = sunday(str,"[/style]");
int len = stemp - etemp;
memcpy(wm[index].style[pos].str,etemp,len);
wm[index].style[pos].str[len]=NULL;
if(pos==0)
wm[index].style[pos].x = 0;
else
wm[index].style[pos].x = getTextLength(wm[index].style[pos-1].str)+wm[index].style[pos-1].x;
pos++;
stemp = stemp + 8;
getstrstyle(stemp,index,pos,FALSE,wm);
}
}else{
sprintf(wm[index].style[pos].str,"%s",str);
if(!wm[index].flg){
wm[index].flg=TRUE;
wm[index].style[pos].x = 0;
wm[index].style[pos].color = 0;
wm[index].style[pos].size = FONT_SIZE1;
}else{
wm[index].style[pos].size = FONT_SIZE1;
wm[index].style[pos].x = getTextLength(wm[index].style[pos-1].str)+wm[index].style[pos-1].x;
wm[index].style[pos].color = 0;
}
}
}
void PutWinText(int x,int y,char fontPrio,int color,char *str,BOOL hitFlag,int index )
{
int i=0;
for(;i<30;i++){
if(*wmstr[index].style[i].str)
StockFontBufferExt(x+wmstr[index].style[i].x,y,fontPrio,wmstr[index].style[i].color,
wmstr[index].style[i].str,hitFlag,wmstr[index].style[i].size);
}
}
#ifdef _CHARTITLE_STR_
void PutTitleText(int x,int y,char fontPrio,TITLE_STR str,BOOL hitFlag)
{
int i=0;
for(;i<10;i++){
if(*str.style[i].str)
StockFontBufferExt(x+str.style[i].x,y,fontPrio,str.style[i].color,
str.style[i].str,hitFlag,str.style[i].size);
}
}
extern int getTextLength(char * str);
void getTitlestyle(char *str,int pos,int flg,TITLE_STR* wm)
{
char *stemp,*etemp;
if(flg)
stemp = str;
else
stemp = sunday(str, "[style ");
if(stemp){
if(stemp!= str){
wm->flg=TRUE;
wm->style[pos].size = FONT_SIZE1;
if(pos==0)
wm->style[pos].x = 0;
else
wm->style[pos].x = getTextLength(wm->style[pos-1].str)+wm->style[pos-1].x;
wm->style[pos].color = 0;
int len = stemp - str;
memcpy(wm->style[pos].str,str,len);
wm->style[pos].str[len]=NULL;
pos++;
getTitlestyle(stemp,pos,TRUE,wm);
}else{
wm->flg=TRUE;
stemp=stemp+7;
etemp = sunday(stemp, "]")+1;
char *scolor = sunday(stemp, "c=");
if(scolor){
scolor=scolor+2;
char strnum[3];
int i=0;
for(i;i<2 && scolor[i] !=' ' && scolor[i]!=']';i++){
strnum[i] = scolor[i];
}
strnum[i]=0;
wm->style[pos].color = atoi(strnum);
}else wm->style[pos].color =0;
char *ssize = sunday(stemp, "s=");
if(ssize){
ssize=ssize+2;
char strsize[3];
int i=0;
for(i;i<2 && ssize[i] !=' ' && ssize[i]!=']';i++){
strsize[i] = ssize[i];
}
strsize[i]=0;
wm->style[pos].size = atoi(ssize);
}else wm->style[pos].size = FONT_SIZE1;
stemp = sunday(str,"[/style]");
int len = stemp - etemp;
memcpy(wm->style[pos].str,etemp,len);
wm->style[pos].str[len]=NULL;
if(pos==0)
wm->style[pos].x = 0;
else
wm->style[pos].x = getTextLength(wm->style[pos-1].str)+wm->style[pos-1].x;
pos++;
stemp = stemp + 8;
getTitlestyle(stemp,pos,FALSE,wm);
}
}else{
sprintf(wm->style[pos].str,"%s",str);
if(!wm->flg){
wm->flg=TRUE;
wm->style[pos].x = 0;
wm->style[pos].color = 0;
wm->style[pos].size = FONT_SIZE1;
wm->len = getTextLength(wm->style[pos].str);
}else{
wm->style[pos].size = FONT_SIZE1;
wm->style[pos].x = getTextLength(wm->style[pos-1].str)+wm->style[pos-1].x;
wm->style[pos].color = 0;
wm->len = getTextLength(wm->style[pos].str)+wm->style[pos].x;
}
}
}
void getCharTitleSplit( char *str,TITLE_STR* title)
{
memset(title,0,sizeof(TITLE_STR));
if (str == NULL) return;
int i=0;
for(i;i<25;i++){
if(*str){
getTitlestyle(str,0,FALSE,title);
}
}
}
#endif
void getStrSplitNew( char str[][256])
{
memset(wmstr,0,sizeof(WM_STR)*25);
int i=0;
for(i;i<25;i++){
if(str[i][0]){
getstrstyle(str[i],i,0,FALSE,wmstr);
}
}
}
#endif
Reference in New Issue Copy Permalink