code stringlengths 1 2.06M | language stringclasses 1 value |
|---|---|
#include "../global.h"
#define NUMBER_OF_PATH_SEARCH 10
#define MAX_NUMBER_OF_PATH_SEARCH 2000
void AI_PreparePathfinding( monsterCharacter_t *monster, int pathfindingSize )
{
if( pathfindingSize < 50 || pathfindingSize > 300 ) pathfindingSize = 50;
monster->ai.pathFindSize = pathfindingSize;
int size = monster->ai.pathFindSize;
monster->ai.nodeHashTable = (node_t **)malloc( size * size * sizeof( node_t ) );
monster->ai.path = (grid_t *)malloc( size * size * sizeof( grid_t ) );
memset(monster->ai.path,0x00,size * size * sizeof( grid_t ));
monster->ai.wayPath = (grid_t *)malloc( size * size * sizeof( grid_t ) );
monster->ai.nodeBank = (node_t *)malloc( size * size * sizeof( node_t ) );
}
void AI_ReleasePathfinding( monsterCharacter_t *monster )
{
free( monster->ai.nodeHashTable );
free( monster->ai.path );
free( monster->ai.wayPath );
free( monster->ai.nodeBank );
free(monster->ai.aiData);
}
void AI_InitNodeBank( monsterCharacter_t *monster )
{
int size = monster->ai.pathFindSize;
monster->ai.nodeBankNumber = 0;
memset( monster->ai.nodeHashTable, NULL, size * size * sizeof( node_t ) );
monster->ai.heruristic = (float)5.0f;
monster->ai.isGoal = true;
}
void AI_DeleteNodeBank( monsterCharacter_t* monster )
{
int size = monster->ai.pathFindSize;
memset( monster->ai.nodeHashTable, NULL, size * size * sizeof( node_t ) );
monster->ai.nodeBankNumber = 0;
}
node_t *AI_GetFreeNodeFromNodeBank( monsterCharacter_t *monster )
{
node_t *rNode;
rNode = monster->ai.nodeBank;
rNode = rNode + monster->ai.nodeBankNumber ++;
return( rNode );
}
node_t *AI_GetNode( monsterCharacter_t* monster, grid_t pos )
{
node_t *node;
grid_t cpos;
int size = monster->ai.pathFindSize;
cpos[0] = pos[0] - monster->ai.curPos[0];
cpos[1] = pos[1] - monster->ai.curPos[1];
if( abs( cpos[0] ) >= size / 2 || abs( cpos[1] ) >= size / 2 ) return( NULL );
cpos[0] += size / 2;
cpos[1] += size / 2;
node = monster->ai.nodeHashTable[ cpos[1] * size + cpos[0] ];
if( node ) return( node );
else
{
node_t *newNode = AI_GetFreeNodeFromNodeBank( monster );
newNode->pos[0] = pos[0];
newNode->pos[1] = pos[1];
newNode->onOpen = false;
newNode->onClosed = false;
monster->ai.nodeHashTable[ cpos[1] * size + cpos[0] ] = newNode;
return( newNode );
}
}
node_t *AI_PopPriorityQueue( queue_t &pqueue )
{
node_t *node = pqueue.heap.front();
std::pop_heap( pqueue.heap.begin(), pqueue.heap.end(), AI_NodeTotalGreater() );
pqueue.heap.pop_back();
return( node );
}
void AI_PushPriorityQueue( queue_t &pqueue, node_t *node)
{
pqueue.heap.push_back( node );
std::push_heap( pqueue.heap.begin(), pqueue.heap.end(), AI_NodeTotalGreater() );
}
void AI_UpdateNodeOnPriorityQueue( queue_t &pqueue, node_t *node )
{
std::vector<node_t*>::iterator i;
for( i = pqueue.heap.begin(); i != pqueue.heap.end(); i ++ )
{
if( (*i)->pos[0] == node->pos[0] && (*i)->pos[1] == node->pos[1] )
{
std::push_heap( pqueue.heap.begin(), i + 1, AI_NodeTotalGreater() );
return;
}
}
}
bool AI_IsPriorityQueueEmpty( queue_t &pqueue )
{
return( pqueue.heap.empty() );
}
int AI_CanMove( monsterCharacter_t* monster, grid_t pos, int lines )
{
int localWorldIdx;
if( pos[1] < 0 || pos[0] < 0 ) return( 0 );
localWorldIdx = GTH_GetLocalWorldIdx( monster->worldIdx );
if( !AI_CheckCollision( pos[0], pos[1], &g_cmap[localWorldIdx] ) ) return( 0 );
switch( lines )
{
case 1 :
if( AI_CheckCollision( pos[0], pos[1] - 1, &g_cmap[localWorldIdx] ) &&
AI_CheckCollision( pos[0] + 1, pos[1], &g_cmap[localWorldIdx] ) )
return( 1 );
break;
case 3 :
if( AI_CheckCollision( pos[0], pos[1] - 1, &g_cmap[localWorldIdx] ) &&
AI_CheckCollision( pos[0] - 1, pos[1], &g_cmap[localWorldIdx] ) )
return( 1 );
break;
case 5 :
if( AI_CheckCollision( pos[0], pos[1] + 1, &g_cmap[localWorldIdx] ) &&
AI_CheckCollision( pos[0] - 1, pos[1], &g_cmap[localWorldIdx] ) )
return( 1 );
break;
case 7 :
if( AI_CheckCollision( pos[0], pos[1] + 1, &g_cmap[localWorldIdx] ) &&
AI_CheckCollision( pos[0] + 1, pos[1], &g_cmap[localWorldIdx] ) )
return( 1 );
break;
default :
return( 1 );
break;
}
return( 0 );
}
void AI_DeleteQueue( path_t &path )
{
while( !AI_IsPriorityQueueEmpty( path.open ) )
{
path.open.heap.pop_back();
}
}
float AI_CostFromNodeToNode( grid_t pos1, grid_t pos2 )
{
return( sqrtf( ( pos1[0] - pos2[0] ) * (pos1[0] - pos2[0] ) + ( pos1[1] - pos2[1] ) * ( pos1[1] - pos2[1] ) ) );
}
bool AI_FindPath( monsterCharacter_t* monster )
{
node_t *startNode;
node_t *bestNode;
node_t newNode;
node_t *actualNode;
int i;
monster->ai.searchNumber = 0;
if( monster->ai.curPos[0] == monster->ai.goalPos[0] &&
monster->ai.curPos[1] == monster->ai.goalPos[1] ) return( 1 );
if( monster->ai.goalPos[0] == monster->ai.path[0][0] &&
monster->ai.goalPos[1] == monster->ai.path[0][1] ) return( 1 );
if( monster->ai.isGoal )
{
if( monster->ai.totalSearch == 0 )
{
startNode = AI_GetNode( monster, monster->ai.curPos );
startNode->onClosed = false;
startNode->onOpen = true;
startNode->parent = NULL;
startNode->cost = 0;
startNode->total = AI_CostFromNodeToNode( monster->ai.curPos, monster->ai.goalPos ) * monster->ai.heruristic;
monster->ai.pathQueue.goal[0] = monster->ai.goalPos[0];
monster->ai.pathQueue.goal[1] = monster->ai.goalPos[1];
AI_PushPriorityQueue( monster->ai.pathQueue.open, startNode );
monster->ai.totalSearch = 0;
}
}
while( !AI_IsPriorityQueueEmpty( monster->ai.pathQueue.open ) )
{
if( monster->ai.searchNumber > NUMBER_OF_PATH_SEARCH )
{
monster->ai.totalSearch += monster->ai.searchNumber;
if( monster->ai.totalSearch > MAX_NUMBER_OF_PATH_SEARCH )
return( false );
monster->ai.isGoal = false;
return( true );
}
bestNode = AI_PopPriorityQueue( monster->ai.pathQueue.open );
if( bestNode->pos[0] == monster->ai.pathQueue.goal[0] &&
bestNode->pos[1] == monster->ai.pathQueue.goal[1] )
{
AI_PushPriorityQueue( monster->ai.pathQueue.open, bestNode );
AI_MakePath( monster );
monster->ai.isGoal = true;
return( true );
}
for( i = 0; i < 8; i ++ )
{
switch( i )
{
case 0:
newNode.pos[0] = bestNode->pos[0] - 1;
newNode.pos[1] = bestNode->pos[1];
break;
case 1:
newNode.pos[0] = bestNode->pos[0] - 1;
newNode.pos[1] = bestNode->pos[1] + 1;
break;
case 2:
newNode.pos[0] = bestNode->pos[0];
newNode.pos[1] = bestNode->pos[1] + 1;
break;
case 3:
newNode.pos[0] = bestNode->pos[0] + 1;
newNode.pos[1] = bestNode->pos[1] + 1;
break;
case 4:
newNode.pos[0] = bestNode->pos[0] + 1;
newNode.pos[1] = bestNode->pos[1];
break;
case 5:
newNode.pos[0] = bestNode->pos[0] + 1;
newNode.pos[1] = bestNode->pos[1] - 1;
break;
case 6:
newNode.pos[0] = bestNode->pos[0];
newNode.pos[1] = bestNode->pos[1] - 1;
break;
case 7:
newNode.pos[0] = bestNode->pos[0] - 1;
newNode.pos[1] = bestNode->pos[1] - 1;
break;
}
if( !AI_CanMove( monster, newNode.pos, i ) ) continue;
if( bestNode->parent == NULL || \
bestNode->parent->pos[0] != newNode.pos[0] || \
bestNode->parent->pos[1] != newNode.pos[1] )
{
newNode.parent = bestNode;
newNode.cost = bestNode->cost + AI_CostFromNodeToNode( newNode.pos, bestNode->pos );
newNode.total = newNode.cost + AI_CostFromNodeToNode( newNode.pos, monster->ai.pathQueue.goal ) * monster->ai.heruristic;
actualNode = AI_GetNode( monster, newNode.pos );
if( actualNode == NULL ) return( false );
if( !( actualNode->onOpen && newNode.total > actualNode->total ) && \
!( actualNode->onClosed && newNode.total > actualNode->total ) )
{
actualNode->onClosed = false;
actualNode->parent = newNode.parent;
actualNode->cost = newNode.cost;
actualNode->total = newNode.total;
if( actualNode->onOpen )
{
AI_UpdateNodeOnPriorityQueue( monster->ai.pathQueue.open, actualNode );
}
else
{
AI_PushPriorityQueue( monster->ai.pathQueue.open, actualNode );
actualNode->onOpen = true;
}
monster->ai.searchNumber ++;
}
}
}
bestNode->onClosed = true;
}
return( false );
}
void AI_StopPathFinding( monsterCharacter_t* monster )
{
AI_DeleteNodeBank( monster );
AI_DeleteQueue( monster->ai.pathQueue );
monster->ai.isGoal = true;
monster->ai.totalSearch = 0;
int size=monster->ai.pathFindSize;
memset(monster->ai.path,0x00,size * size * sizeof( grid_t ));
}
void AI_MakePath( monsterCharacter_t* monster )
{
node_t *node;
int i = 0;
if( monster->ai.curPos[0] == monster->ai.goalPos[0] &&
monster->ai.curPos[1] == monster->ai.goalPos[1] )
{
monster->ai.pathNumber = 0;
}
else
{
node = AI_PopPriorityQueue( monster->ai.pathQueue.open );
while( 1 )
{
if( !node ) break;
if( i >= monster->ai.pathFindSize * monster->ai.pathFindSize ) break;
monster->ai.path[i][0] = node->pos[0];
monster->ai.path[i][1] = node->pos[1];
i ++;
node = node->parent;
}
monster->ai.pathNumber = i - 1;
}
AI_DeleteNodeBank( monster );
AI_DeleteQueue( monster->ai.pathQueue );
monster->ai.totalSearch = 0;
}
| C++ |
#include "../global.h"
void MONSTER_InitAI( monsterCharacter_t* monster, int isLost )
{
int localWorldIdx;
AI_InitNodeBank( monster );
monster->ai.aiEvent = AI_IDLE;
monster->ai.thinkTime = GTH_Randomize( 5000 );
monster->ai.saveTime = 0;
monster->ai.curWayPath = -1;
monster->ai.directWayPath = -1;
monster->ai.pathNumber = -1;
monster->ai.returnFlag = 0;
monster->ai.moveType = AI_DEF_ENABLE_WALK;
monster->ai.oldMoveType = AI_DEF_ENABLE_WALK;
localWorldIdx = GTH_GetLocalWorldIdx( monster->worldIdx );
AI_GetGridPosition( monster->position, monster->ai.startPos, &g_cmap[localWorldIdx] );
monster->ai.aiAddr = 0;
monster->ai.callProcedureAddr = 0;
monster->ai.isCall = false;
monster->forcedEntityType = -1;
monster->forcedEntityIdx = -1;
monster->damagedEntityType = -1;
monster->damagedEntityIdx = -1;
monster->searchEntityType = -1;
monster->searchEntityIdx = -1;
monster->targetIdx = -1;
monster->targetType = -1;
monster->bossEntityIdx = -1;
monster->bossEntityType = -1;
if( !isLost ) monster->ai.lostPathCount = 0;
AI_StopPathFinding( monster );
}
int MONSTER_AdjustNextAngle( monsterCharacter_t* monster )
{
return ( 0 );
}
int AI_CheckCorrectWay( monsterCharacter_t* monster, int wayType )
{
vec3_t angles, delta, pos;
grid_t nextPos;
float speed;
int localWorldIdx;
localWorldIdx = GTH_GetLocalWorldIdx( monster->worldIdx );
vec_copy( monster->angles, angles );
vec_copy( monster->position, pos );
angles[1] = monster->nextAngle;
vec_set(delta, 1, 0, 0);
RotateYCoord( delta, angles[0] );
RotateZCoord( delta, angles[1] );
Normalize( delta );
speed = SPEED_CONSTANT * monster->calVelocity * g_timer->GetElapsedMilliTime();
vec_scale( delta, speed, delta );
vec_add( pos, delta, pos);
AI_GetGridPosition( pos, nextPos, &g_cmap[localWorldIdx] );
if( !AI_CheckCollision( nextPos[0], nextPos[1], &g_cmap[localWorldIdx] ) )
{
g_logSystem->Write( "%s(%d) Lost the path!, Initialize AI again... speed:%.2f, pos(%.2f,%.2f,%.2f), event:%d, ai event:%d, lostPathCount:%d",
monster->basic.name, monster->idx, speed, pos[0], pos[1], pos[2], monster->event, monster->ai.aiEvent, monster->ai.lostPathCount );
return( 0 );
}
else return( 1 );
}
void MONSTER_Lost( monsterCharacter_t* monster )
{
grid_t goalPos, curPos;
int localWorldIdx;
if( monster->ai.lostPathCount > 5 )
{
MONSTER_ForcedDelete( monster );
return;
}
if( monster->ai.wayPointNumber > 0 )
{
goalPos[0] = monster->ai.goalPos[0];
goalPos[1] = monster->ai.goalPos[1];
if( monster->ai.curWayPath == -1 )
{
goalPos[0] = monster->ai.startPos[0];
goalPos[1] = monster->ai.startPos[1];
}
else
{
goalPos[0] = monster->ai.wayPath[monster->ai.curWayPath][0];
goalPos[1] = monster->ai.wayPath[monster->ai.curWayPath][1];
}
localWorldIdx = GTH_GetLocalWorldIdx( monster->worldIdx );
AI_GetGridPosition( monster->position, curPos, &g_cmap[localWorldIdx] );
AI_StopPathFinding( monster );
monster->ai.curPos[0] = curPos[0];
monster->ai.curPos[1] = curPos[1];
monster->ai.goalPos[0] = goalPos[0];
monster->ai.goalPos[1] = goalPos[1];
AI_FindPath( monster );
monster->ai.aiEvent = AI_MOVE;
}
else
{
MONSTER_InitAI( monster, true );
}
monster->ai.lostPathCount ++;
}
void MONSTER_ForcedDelete( monsterCharacter_t* monster )
{
monster->deathTime = g_globalTime;
g_logSystem->Write( "%s(%d) Forced Delete! Respawn again... speed:%.2f, pos(%.2f,%.2f,%.2f), event:%d, ai event:%d",
monster->basic.name, monster->idx, monster->calVelocity,
monster->position[0], monster->position[1], monster->position[2], (int)monster->event, (int)monster->ai.aiEvent );
monster->aliveState = MON_ALIVE_STATE_DIE;
monster->ai.aiEvent = AI_DIE;
monster->event = GTH_EV_CHAR_DIE;
monster->oldEvent = GTH_EV_CHAR_DIE;
}
void MONSTER_MovePath( monsterCharacter_t* monster )
{
vec3_t tpos;
grid_t myPos;
vec3_t na;
int localWorldIdx;
if( !monster->ai.isGoal )
{
if( AI_FindPath( monster ) )
{
monster->oldEvent = monster->event;
monster->event = GTH_EV_CHAR_SKIP;
return;
}
else
{
if( monster->wayPointNumber > 0 )
{
MONSTER_ForcedDelete( monster );
return;
}
else
{
monster->event = GTH_EV_CHAR_IDLE;
monster->ai.aiEvent = AI_MOVE;
AI_StopPathFinding( monster );
return;
}
}
}
if( monster->ai.pathNumber < 0 )
{
monster->oldEvent = monster->event;
monster->event = GTH_EV_CHAR_IDLE;
monster->ai.aiEvent = AI_IDLE;
return;
}
localWorldIdx = GTH_GetLocalWorldIdx( monster->worldIdx );
AI_GetGridPosition( monster->position, myPos, &g_cmap[localWorldIdx] );
if( myPos[0] == monster->ai.path[ monster->ai.pathNumber ][0] &&
myPos[1] == monster->ai.path[ monster->ai.pathNumber ][1] )
{
monster->ai.pathNumber --;
if( monster->ai.pathNumber < 0 )
{
monster->oldEvent = monster->event;
monster->event = GTH_EV_CHAR_IDLE;
return;
}
AI_GetWorldPosition( monster->ai.path[monster->ai.pathNumber], tpos, &g_cmap[localWorldIdx] );
tpos[0] += g_cmap[localWorldIdx].scale * 0.5f;
tpos[1] += g_cmap[localWorldIdx].scale * 0.5f;
tpos[2] = monster->position[2];
vec_sub( tpos, monster->position, tpos );
vectoangles( tpos, na );
monster->nextAngle = na[1];
}
switch( MONSTER_AdjustNextAngle( monster ) )
{
case -1:
if ( monster->ai.aiEvent == AI_RUNAWAY)
monster->event = GTH_EV_CHAR_TURNLEFT;
else
monster->event = GTH_EV_CHAR_RUNLEFT;
break;
case 1:
if ( monster->ai.aiEvent == AI_RUNAWAY)
monster->event = GTH_EV_CHAR_RUNRIGHT;
else
monster->event = GTH_EV_CHAR_TURNRIGHT;
break;
case 0:
if ( monster->ai.aiEvent == AI_RUNAWAY)
monster->event = GTH_EV_CHAR_RUN;
else
monster->event = GTH_EV_CHAR_WALK;
if( !AI_CheckCorrectWay( monster, 0 ) )
{
monster->event = GTH_EV_CHAR_IDLE;
monster->ai.aiEvent = AI_LOST;
}
break;
}
}
void MONSTER_MoveWayPoint( monsterCharacter_t* monster )
{
vec3_t tpos;
grid_t myPos;
vec3_t na;
int localWorldIdx;
if( monster->ai.returnFlag )
{
MONSTER_MovePath( monster );
return;
}
if( !monster->ai.isGoal )
{
if( AI_FindPath( monster ) )
{
monster->oldEvent = monster->event;
monster->event = GTH_EV_CHAR_SKIP;
return;
} else MONSTER_ForcedDelete( monster );
}
if( monster->ai.curWayPath < 0 || monster->ai.directWayPath == 0 || monster->ai.wayPointNumber <= 1 )
{
monster->event = GTH_EV_CHAR_IDLE;
return;
}
localWorldIdx = GTH_GetLocalWorldIdx( monster->worldIdx );
AI_GetGridPosition( monster->position, myPos, &g_cmap[localWorldIdx] );
if( myPos[0] == monster->ai.wayPath[monster->ai.curWayPath][0] &&
myPos[1] == monster->ai.wayPath[monster->ai.curWayPath][1] )
{
monster->ai.curWayPath += monster->ai.directWayPath;
if( monster->ai.curWayPath < 0 )
{
monster->ai.curWayPath = 0;
monster->event = GTH_EV_CHAR_IDLE;
return;
}
if( monster->ai.curWayPath >= monster->ai.wayPathNumber )
{
monster->ai.curWayPath = monster->ai.wayPathNumber - 1;
monster->event = GTH_EV_CHAR_IDLE;
return;
}
AI_GetWorldPosition( monster->ai.wayPath[monster->ai.curWayPath], tpos, &g_cmap[localWorldIdx] );
tpos[0] += g_cmap[localWorldIdx].scale * 0.5f;
tpos[1] += g_cmap[localWorldIdx].scale * 0.5f;
tpos[2] = monster->position[2];
vec_sub( tpos, monster->position, tpos );
vectoangles( tpos, na );
monster->nextAngle = na[1];
}
switch( MONSTER_AdjustNextAngle( monster ) )
{
case -1:
monster->event = GTH_EV_CHAR_TURNLEFT;
break;
case 1:
monster->event = GTH_EV_CHAR_TURNRIGHT;
break;
case 0:
monster->event = GTH_EV_CHAR_WALK;
if( !AI_CheckCorrectWay( monster, 0 ) )
{
monster->event = GTH_EV_CHAR_IDLE;
monster->ai.aiEvent = AI_LOST;
}
break;
}
}
void MONSTER_Move( monsterCharacter_t* monster )
{
if( monster->ai.moveType == AI_DEF_ENABLE_WALK )
{
if( monster->ai.wayPointNumber > 0 ) MONSTER_MoveWayPoint( monster );
else MONSTER_MovePath( monster );
}
else
{
monster->event = GTH_EV_CHAR_IDLE;
}
}
void MONSTER_Trace( monsterCharacter_t* monster )
{
vec3_t tpos;
grid_t myPos;
vec3_t na;
int localWorldIdx;
if( AI_IsWithinAttackLength( monster ) )
{
AI_StopPathFinding( monster );
monster->oldEvent = monster->event;
monster->event = GTH_EV_CHAR_SKIP;
MONSTER_Attach( monster );
return;
}
if( monster->ai.moveType != AI_DEF_ENABLE_WALK ) return;
if( !monster->ai.isGoal )
{
if( AI_FindPath( monster ) )
{
monster->oldEvent = monster->event;
monster->event = GTH_EV_CHAR_SKIP;
return;
}
else
{
monster->event = GTH_EV_CHAR_IDLE;
monster->ai.aiEvent = AI_MOVE;
AI_StopPathFinding( monster );
return;
}
}
if( monster->ai.pathNumber < 0 )
{
monster->oldEvent = monster->event;
monster->event = GTH_EV_CHAR_SKIP;
MONSTER_Attach( monster );
return;
}
localWorldIdx = GTH_GetLocalWorldIdx( monster->worldIdx );
AI_GetGridPosition( monster->position, myPos, &g_cmap[localWorldIdx] );
if( myPos[0] == monster->ai.path[ monster->ai.pathNumber ][0] &&
myPos[1] == monster->ai.path[ monster->ai.pathNumber ][1] )
{
monster->ai.pathNumber --;
if( monster->ai.pathNumber < 0 )
{
monster->oldEvent = monster->event;
monster->event = GTH_EV_CHAR_SKIP;
AI_InterpretImmediately( monster );
return;
}
AI_GetWorldPosition( monster->ai.path[monster->ai.pathNumber], tpos, &g_cmap[localWorldIdx] );
tpos[0] += g_cmap[localWorldIdx].scale * 0.5f;
tpos[1] += g_cmap[localWorldIdx].scale * 0.5f;
tpos[2] = monster->position[2];
vec_sub( tpos, monster->position, tpos );
vectoangles( tpos, na );
monster->nextAngle = na[1];
}
switch( MONSTER_AdjustNextAngle( monster ) )
{
case -1:
monster->event = GTH_EV_CHAR_TURNLEFT;
break;
case 1:
monster->event = GTH_EV_CHAR_TURNRIGHT;
break;
case 0:
monster->event = GTH_EV_CHAR_WALK;
monster->event = GTH_EV_CHAR_RUN;
if( !AI_CheckCorrectWay( monster, 0 ) )
{
monster->event = GTH_EV_CHAR_IDLE;
monster->ai.aiEvent = AI_LOST;
}
break;
}
}
void MONSTER_Attach( monsterCharacter_t* monster )
{
float range, range2;
float x, y;
grid_t mypos, dest;
vec3_t tpos, na;
int localWorldIdx;
localWorldIdx = GTH_GetLocalWorldIdx( monster->worldIdx );
switch( monster->targetType )
{
case ENTITY_PC :
x = g_pc[monster->targetIdx].position[0];
y = g_pc[monster->targetIdx].position[1];
vec_copy( g_pc[monster->targetIdx].position, tpos );
AI_GetGridPosition( g_pc[monster->targetIdx].position, dest, &g_cmap[localWorldIdx] );
break;
case ENTITY_MONSTER : case ENTITY_NPC :
x = g_monster[monster->targetIdx].position[0];
y = g_monster[monster->targetIdx].position[1];
vec_copy( g_monster[monster->targetIdx].position, tpos );
AI_GetGridPosition( g_monster[monster->targetIdx].position, dest, &g_cmap[localWorldIdx] );
break;
}
AI_GetGridPosition( monster->position, mypos, &g_cmap[localWorldIdx] );
x -= monster->position[0];
y -= monster->position[1];
range = x * x + y * y;
range2 = monster->calAttackLength;
if( (-1 != monster->selectedSkillIdx ) &&
( 0 !=monster->skillNumber ) )
{
if ( monster->skillUsePercent[monster->selectedSkillIdx] != 0)
{
CSkilTable *pSkillTable = g_SkillTableDB.FindDB(monster->selectedSkillIdx);
if(pSkillTable==NULL)
{
TRACE("Error! pSkillTable==NULL \n");
return;
}
range2 = pSkillTable->GetSkillRequire()->m_nLength;
}
}
range2 = range2 * range2;
if( mypos[0] == dest[0] && mypos[1] == dest[1] )
{
if( range > range2 )
{
vec_sub( tpos, monster->position, tpos );
vectoangles( tpos, na );
monster->nextAngle = na[1];
switch( MONSTER_AdjustNextAngle( monster ) )
{
case -1:
monster->event = GTH_EV_CHAR_TURNLEFT;
break;
case 1:
monster->event = GTH_EV_CHAR_TURNRIGHT;
break;
case 0:
if( monster->ai.moveType == AI_DEF_ENABLE_WALK )
{
monster->event = GTH_EV_CHAR_RUN;
}
else
{
monster->event = GTH_EV_CHAR_IDLE;
}
break;
}
return;
}
else
{
vec_sub( tpos, monster->position, tpos );
vectoangles( tpos, na );
if( abs( na[1] - monster->angles[1] ) < 15.0f )
{
if( monster->selectedSkillIdx != -1 )
{
monster->event = GTH_EV_CHAR_SKILL;
}
else
{
monster->event = GTH_EV_CHAR_ATTACK;
}
return;
}
else
{
monster->nextAngle = na[1];
switch( MONSTER_AdjustNextAngle( monster ) )
{
case -1:
monster->event = GTH_EV_CHAR_TURNLEFT;
break;
case 1:
monster->event = GTH_EV_CHAR_TURNRIGHT;
break;
case 0:
if( monster->ai.moveType == AI_DEF_ENABLE_WALK )
{
monster->event = GTH_EV_CHAR_RUN;
}
else
{
monster->event = GTH_EV_CHAR_IDLE;
}
break;
}
return;
}
}
}
else
{
if( range > range2 )
{
if( monster->ai.moveType == AI_DEF_ENABLE_WALK )
{
monster->ai.aiEvent = AI_TRACE;
monster->oldEvent = monster->event;
monster->event = GTH_EV_CHAR_SKIP;
AI_InterpretImmediately( monster );
}
else
{
monster->event = GTH_EV_CHAR_IDLE;
}
return;
}
else
{
vec_sub( tpos, monster->position, tpos );
vectoangles( tpos, na );
if( abs( na[1] - monster->angles[1] ) < 15.0f )
{
if( monster->selectedSkillIdx != -1 )
{
monster->event = GTH_EV_CHAR_SKILL;
}
else
{
monster->event = GTH_EV_CHAR_ATTACK;
}
return;
}
else
{
monster->nextAngle = na[1];
switch( MONSTER_AdjustNextAngle( monster ) )
{
case -1:
monster->event = GTH_EV_CHAR_TURNLEFT;
break;
case 1:
monster->event = GTH_EV_CHAR_TURNRIGHT;
break;
case 0:
if( monster->ai.moveType == AI_DEF_ENABLE_WALK )
{
monster->event = GTH_EV_CHAR_RUN;
}
else
{
monster->event = GTH_EV_CHAR_IDLE;
}
break;
}
return;
}
}
}
}
void MONSTER_ExecuteAIEvent( monsterCharacter_t* monster )
{
if( monster->isSummon && monster->summonValidTime > 0.0f )
{
monster->summonValidTime -= g_timer->GetElapsedMilliTime();
if( monster->summonValidTime <= 0.0f )
{
monster->aliveState = MON_ALIVE_STATE_DISAPPEAR;
monster->ai.aiEvent = AI_DIE;
monster->event = GTH_EV_CHAR_IDLE;
monster->deathTime = g_globalTime;
monster->summonValidTime = -1.0f;
monster->recoveryTime = 0.0f;
}
}
if( monster->aliveState == MON_ALIVE_STATE_NORMAL )
{
monster->recoveryTime -= g_timer->GetElapsedMilliTime();
if( monster->recoveryTime < 0.0f ) monster->recoveryTime = 0.0f;
if( monster->recoveryTime > 0.0f ) return;
}
if( GTH_GetEntityCurseState( ENTITY_MONSTER, monster->idx, AFF_DATA_TYPE_PARALYSIS ) )
{
monster->ai.moveType = AI_DEF_DISABLE_MOVE;
}
else if( GTH_GetEntityCurseState( ENTITY_MONSTER, monster->idx, AFF_DATA_TYPE_SLEEP ) )
{
monster->ai.moveType = AI_DEF_DISABLE_MOVE;
}
else if( GTH_GetEntityCurseState( ENTITY_MONSTER, monster->idx, AFF_DATA_TYPE_STOPPED ) )
{
monster->ai.moveType = AI_DEF_DISABLE_WALK;
}
else
{
monster->ai.moveType = monster->ai.oldMoveType;
}
if( monster->ai.moveType == AI_DEF_DISABLE_MOVE )
{
if( monster->ai.aiEvent != AI_DIE )
{
if( monster->event != GTH_EV_CHAR_FREEZE && monster->event != GTH_EV_CHAR_PUSHED )
monster->event = GTH_EV_CHAR_IDLE;
return;
}
}
switch( monster->ai.aiEvent )
{
case AI_IDLE :
if( monster->aliveState == MON_ALIVE_STATE_SPAWN )
{
monster->recoveryTime -= g_timer->GetElapsedMilliTime();
if( monster->recoveryTime < 0.0f )
{
monster->recoveryTime = 0.0f;
monster->aliveState = MON_ALIVE_STATE_NORMAL;
}
}
break;
case AI_MOVE :
MONSTER_Move( monster );
break;
case AI_TRACE :
MONSTER_Trace( monster );
break;
case AI_DIE :
if( monster->aliveState == MON_ALIVE_STATE_CORPSE )
{
if( g_globalTime - monster->deathTime >= MONSTER_CORPSE_ANIMATION_TIME )
{
monster->aliveState = MON_ALIVE_STATE_DISAPPEAR;
monster->deathTime = g_globalTime;
return;
}
}
if( monster->aliveState == MON_ALIVE_STATE_DISAPPEAR )
{
if( g_globalTime - monster->deathTime >= MONSTER_DISAPPEAR_ANIMATION_TIME )
{
monster->deathTime = g_globalTime;
monster->aliveState = MON_ALIVE_STATE_DIE;
return;
}
}
if( monster->aliveState == MON_ALIVE_STATE_DIE )
{
if( monster->isSummon )
{
MONSTER_Delete( monster );
GTH_Zone_DeleteEntityList(monster->worldIdx, monster->zoneIdx, monster->entityType, monster->idx);
return;
}
float LimitTime = 0.0f;
if (TRUE == monster->bIgnoreRespawnTime)
LimitTime = monster->deathTime + 1000;
else
LimitTime =monster->deathTime + monster->respawnTime;
if ( g_globalTime >= LimitTime )
{
MONSTER_Respawn( monster );
if( monster->aliveState == MON_ALIVE_STATE_SPAWN )
monster->zoneIdx = GTH_Zone_UpdateCurrentZone(monster->entityType, monster->idx, monster->worldIdx, monster->zoneIdx, monster->position);
}
}
if( monster->aliveState == MON_ALIVE_STATE_FADE )
{
if( g_globalTime - monster->deathTime >= MONSTER_DISAPPEAR_ANIMATION_TIME )
{
monster->deathTime = g_globalTime;
monster->aliveState = MON_ALIVE_STATE_DIE;
MONSTER_Delete( monster );
GTH_Zone_DeleteEntityList(monster->worldIdx, monster->zoneIdx, monster->entityType, monster->idx);
return;
}
}
break;
case AI_ATTACK :
MONSTER_Attach( monster );
break;
case AI_RUNAWAY :
MONSTER_MovePath( monster );
break;
case AI_LOST :
MONSTER_Lost( monster );
break;
}
} | C++ |
#include "../global.h"
void NPC_InitAI( playerCharacter_t* pc, int npcIdx )
{
monsterCharacter_t* npc = &g_monster[npcIdx];
if( npc->entityType != ENTITY_NPC ) return;
pc->npcIdx = npcIdx;
pc->npcAi.aiType = npc->npcAi.aiType;
memcpy( &pc->npcAi.aiData, &npc->npcAi.aiData, sizeof( pc->npcAi.aiData ) );
memcpy( &pc->npcAi.aiVariable, &npc->npcAi.aiVariable, sizeof( pc->npcAi.aiVariable ) );
memcpy( &pc->npcAi.aiProcedureAddr, &npc->npcAi.aiProcedureAddr, sizeof( pc->npcAi.aiProcedureAddr ) );
pc->npcAi.aiEvent = AI_NPC_RUN;
pc->npcAi.saveTime = 0;
pc->npcAi.thinkTime = 0;
pc->npcAi.aiAddr = 0;
pc->npcAi.callProcedureAddr = 0;
pc->npcAi.isCall = false;
pc->npcAi.pcReplyIdx = -1;
pc->npcAi.msgWaiting = false;
pc->npcAi.msgFlag = false;
pc->npcAi.sendMsgIdx = 0;
pc->npcAi.replyMsgIdxNumber = 0;
pc->npcAi.replyMsgIdx[0] = 0;
pc->npcAi.replyMsgIdx[1] = 0;
pc->npcAi.replyMsgIdx[2] = 0;
pc->npcAi.replyMsgIdx[3] = 0;
pc->npcAi.replyMsgIdx[4] = 0;
pc->npcAi.globalData[0] = 0;
pc->npcAi.globalData[1] = 0;
pc->npcAi.globalData[2] = 0;
pc->npcAi.globalData[3] = 0;
pc->npcAi.globalData[4] = 0;
GTH_AddNoticePC( pc, ENTITY_NPC, npcIdx, BUSY_STATE_NPC );
}
void NPC_SendEvent( playerCharacter_t *pc )
{
if( !pc->npcAi.msgFlag || pc->npcIdx == -1 ) return;
GTH_SendMessage_NpcMessage( pc );
pc->npcAi.msgFlag = false;
pc->npcAi.replyMsgIdxNumber = 0;
}
int NPC_AddNoticePC( monsterCharacter_t* monster, playerCharacter_t* pc )
{
int noticeIdx = monster->npc.noticePcNumber;
if( noticeIdx >= monster->npc.maxNoticePcNumber ) return( false );
monster->event = GTH_EV_CHAR_IDLE;
monster->ai.aiEvent = AI_IDLE;
for( int i = 0; i < noticeIdx; i ++ )
{
if( monster->npc.noticePcIdx[i] < 0 )
break;
}
monster->npc.noticePcIdx[i] = pc->idx;
if( i == noticeIdx ) monster->npc.noticePcNumber ++;
return( true );
}
int NPC_DeleteNoticePC( monsterCharacter_t* monster, playerCharacter_t* pc )
{
int noticeIdx = monster->npc.noticePcNumber;
int i;
GTH_DeleteNoticePC( pc );
pc->npcIdx = -1;
if( noticeIdx < 0 ) return( false );
for( i = 0; i < noticeIdx; i ++ )
{
if( monster->npc.noticePcIdx[i] == pc->idx )
{
monster->npc.noticePcIdx[i] = -1;
break;
}
}
NPC_CheckNoticePC( monster );
return( true );
}
int NPC_CheckNoticePC( monsterCharacter_t* monster )
{
int noticeIdx = monster->npc.noticePcNumber;
int i, n = 0, pcIdx;
for( i = 0; i < MAX_NUMBER_OF_NPC_NOTICE_PC; i ++ )
{
pcIdx = monster->npc.noticePcIdx[i];
if( pcIdx < 0 || pcIdx >= MAX_PCS )
{
monster->npc.noticePcIdx[i] = -1;
continue;
}
if( g_pc[pcIdx].active )
n ++;
else
monster->npc.noticePcIdx[i] = -1;
}
monster->npc.noticePcNumber = n;
return( true );
}
| C++ |
#include "../global.h"
#include "../Tools/CTools.h"
extern CTools* gcpTools;
#include "..\GolryunBattle\tagGolryunBattle.h"
#include "..\GolryunBattle\CGolryunBattle.h"
extern CGolryunBattle* gcpGolryunBattle;
#include <assert.h>
#include "..\log.h"
#include "..\Terra\GiftCard\CGiftCard.h"
extern CGiftCard* gcpGiftCard;
#include "..\GolryunBattle\CGolryunBattle_Observer.h"
extern CGolryunBattle_Observer* gcpGolryunBattle_Observer;
extern int AI_NPC_ShareMoney( void *pPc, int *pParam );
AIFUNC AI_NPC_FUNC[] =
{
{ AI_NPC_IsMessageWating , 0 },
{ AI_NPC_SendMessage , 1 },
{ AI_NPC_SendMessageButton , 2 },
{ AI_NPC_GetMessageSelect , 0 },
{ AI_NPC_CloseMessage , 0 },
{ AI_NPC_OpenStore , 1 },
{ AI_NPC_CloseStore , 0 },
{ AI_NPC_CheckQuestStep , 2 },
{ AI_NPC_SetQuestStep , 2 },
{ AI_NPC_CheckQuestItem , 3 },
{ AI_NPC_DeleteQuestItem , 3 },
{ AI_NPC_SetQuestStatus , 1 },
{ AI_NPC_ClearQuestStatus , 1 },
{ AI_NPC_AddItem , 4 },
{ AI_NPC_DeleteItem , 2 },
{ AI_NPC_CompleteQuest , 1 },
{ AI_NPC_OpenSkillLevelUp , 1 },
{ AI_NPC_OpenBinding , 1 },
{ AI_NPC_AddLoot , 4 },
{ AI_SendChatMessage , 1 },
{ AI_SetDynamicField , 3 },
{ AI_GetDynamicField , 2 },
{ AI_CheckPlayerClass , 0 },
{ AI_CheckPlayerJob , 0 },
{ AI_CheckPlayerLevel , 0 },
{ AI_CheckPlayerGenLevel , 0 },
{ AI_CheckPlayerStatus , 1 },
{ AI_MoveToBindingPosition , 2 },
{ AI_AwakenPlayerJob , 1 },
{ AI_GetCompleteCount , 1 },
{ AI_OpenDepot , 0 },
{ AI_CloseDepot , 0 },
{ AI_OpenPrecocity , 0 },
{ AI_OpenCraft , 0 },
{ AI_OpenUpgrade , 0 },
{ AI_InitPlayerStatus , 1 },
{ AI_OpenQuestScroll , 0 },
{ AI_NPC_AddQuestItem , 4 },
{ AI_NPC_FindEmptyInventoryPos, 0 },
{ AI_SendDialogMessage , 0 },
{ AI_NPC_CheckAutoQuestType , 0 },
{ AI_OpenNpcInventory , 0 },
{ AI_OpenGambleStore , 1 },
{ AI_OpenRequestDanBattle , 0 },
{ AI_OpenEventCraft , 0 },
{ AI_GonryunBattle , 0 },
{ AI_NPC_TransportGolryun , 0 },
{ AI_NPC_TransportArayan , 0 },
{ AI_NPC_SuggestGolryunBattle, 0 },
{ AI_NPC_BuyGolryunBattleTicket,0 },
{ AI_NPC_ShareMoney , 0 },
{ AI_NPC_DisplayTournament , 0 },
{ AI_NPC_CheckPrize , 0 },
{ AI_OpenPackage , 0 },
{ AI_helpOpen , 0 },
{ AI_OpenGiftCardWin , 0 },
{ AI_NPC_ObserveTournament , 0 },
{ AI_DanBattleEvent , 0 },
{ AI_DanBattlePcPoint , 0 },
};
int AI_NPC_IsMessageWating( void* pPc, int *pParam )
{
playerCharacter_t* pc = static_cast<playerCharacter_t*>(pPc);
if( pc->npcAi.msgWaiting ) return( true );
else return( false );
}
int AI_NPC_SendMessage( void* pPc, int *pParam )
{
playerCharacter_t* pc = static_cast<playerCharacter_t*>(pPc);
int idx = pParam[0];
pc->npcAi.msgWaiting = true;
pc->npcAi.msgFlag = true;
pc->npcAi.sendMsgIdx = idx;
pc->npcAi.pcReplyIdx = -1;
return( true );
}
int AI_NPC_SendMessageButton( void* pPc, int *pParam )
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
int buttonType = pParam[0];
int idx = pParam[1];
if( buttonType + 1 > pc->npcAi.replyMsgIdxNumber )
pc->npcAi.replyMsgIdxNumber = buttonType + 1;
pc->npcAi.replyMsgIdx[buttonType] = idx;
return( true );
}
int AI_NPC_GetMessageSelect( void* pPc, int *pParam )
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
if( pc->npcAi.pcReplyIdx >= 0 )
{
pc->npcAi.msgWaiting = false;
return( pc->npcAi.pcReplyIdx );
}
else return( -1 );
}
int AI_NPC_CloseMessage( void* pPc, int *pParam )
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
if( pc->npcIdx < 0 ) return 0;
NPC_DeleteNoticePC( &g_monster[pc->npcIdx], pc );
GTH_SendMessage_ReplyQuitNpcChat( pc, 1, 1 );
return( true );
}
int AI_NPC_OpenStore(void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
int storeIdx = pParam[0];
GTH_SendMessage_ReplyStore( pc, &g_store[storeIdx] );
pc->storeIdx = storeIdx;
return 0;
}
int AI_NPC_CloseStore(void *pPc, int *pParam )
{
return 1;
}
int AI_NPC_CheckQuestStep(void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
int questIdx = pParam[0];
int step = pParam[1];
if( pc->questVar[questIdx].var.step == step ) return 1;
return 0;
}
int AI_NPC_CheckAutoQuestType(void *pPc,int *pParam)
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
int idx=-1;
for(int i=0; i<MAX_COUNT_QUEST_STATUS; i++)
{
if(pc->questStatus[i].questIdx == AUTOQUESTSCROLL_ITEM_INDEX )
{
idx=i;
break;
}
}
if(idx>-1 && idx<MAX_COUNT_QUEST_STATUS)
{
if(pc->questStatus[idx].dField[5] != -1 )
{
if(pc->questStatus[idx].dField[5] == pc->npcIdx)
{
return 1;
}
}
}
return 0;
}
int AI_NPC_SetQuestStep(void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
int questIdx = pParam[0];
int step = pParam[1];
pc->questVar[questIdx].var.step = step;
g_DBGameServer->SaveQuest( pc );
GTH_SendMessage_QuestStep( pc, questIdx, step, false );
return 1;
}
int AI_NPC_AutoSetQuestType(void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
int questIdx = pParam[0];
int autoindex = pParam[1];
pc->questVar[questIdx].var.step = autoindex;
pc->questVar[questIdx].var.dummy = 0;
pc->questVar[questIdx].var.isComplete=false;
pc->questVar[questIdx].var.completeCount=1;
g_DBGameServer->SaveQuest( pc );
return 1;
}
int AI_NPC_CheckQuestItem(void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
int itemTableIdx = pParam[0];
int questIdx = pParam[1];
int number = pParam[2];
if( GTH_GetQuestItemCount( pc, itemTableIdx, questIdx ) == number ) return 1;
return 0;
}
int AI_NPC_DeleteQuestItem(void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
int itemTableIdx = pParam[0];
int questIdx = pParam[1];
int number = pParam[2];
GTH_DeleteQuestItem( pc, itemTableIdx, questIdx, number );
return 1;
}
int AI_NPC_SetQuestStatus(void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
int questIdx = pParam[0];
int idx;
idx = GTH_GetEmptyQuestStatus( pc );
if( idx < 0 ) return 0;
GTH_SetQuestStatus( pc, idx, questIdx );
return 1;
}
int AI_NPC_ClearQuestStatus(void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
int questIdx = pParam[0];
GTH_ClearQuestStatus( pc, questIdx, 0 );
return 1;
}
int AI_NPC_AddItem(void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
int itemTableIdx = pParam[0];
int optionGroupIdx = pParam[1];
int itemNumber = pParam[2];
int messageFlag = pParam[3];
int stackItemIdx, inventoryPos, itemIdx;
int reply = 1, error = 0;
int bIsStack = false, stackNumber = 1;
char generateID[20];
item_t item, *upItem;
if(itemTableIdx < 0 || itemTableIdx >= MAX_NUMBER_OF_ITEM_TABLE) return false;
if( g_itemTable[itemTableIdx].idx < 0 ) return false;
if( optionGroupIdx >= 0 )
{
SpawnItemByOptionGroup( &item, itemTableIdx, optionGroupIdx );
}
else
{
SpawnItem( &item, itemTableIdx );
}
if (itemTableIdx == MONSTERCARD_ITEM_INDEX )
{
if(itemNumber < 0 || itemNumber >= MAX_NUMBER_OF_SUMMON_MONSTER_TABLE) return false;
item.optionIdx[0] = itemNumber;
item.timer = g_summonMonstertable[itemNumber].SummonTime;
item.optionNumber ++;
}
if( GTH_IsStackItem( &item ) )
{
item.durability = itemNumber - 1;
bIsStack = true;
stackNumber = itemNumber;
}
else if( g_itemTable[itemTableIdx].durability > 0 )
{
item.durability = 100;
}
if(g_itemTable[itemTableIdx].epkChargeType == TypeItemTable_t::EPK_TYPE_MUCH_CAPACITY)
{
gcpTools->SetEpkChargeCount(&item,g_itemTable[itemTableIdx].epkChargeCount);
if(g_itemTable[itemTableIdx].epkChargeCount > 0)
{
item.optionNumber++;
}
}
stackItemIdx = GTH_StackMyItem( pc, &item );
if( stackItemIdx >= 0 )
{
upItem = &pc->item[stackItemIdx];
upItem->durability += item.durability + 1;
if( upItem->durability + 1 >= MAX_COUNT_STACK_ITEM ) upItem->durability = MAX_COUNT_STACK_ITEM - 1;
g_DBGameServer->SaveItem( pc, upItem, stackItemIdx );
g_logSystem->WriteToLog( pc, LOG_CLASS_ITEM, "%d;%d;%d;;;%s;%s",
LOG_CLASS_ITEM_ADD_QUEST, stackNumber, 0, upItem->name,
GetItemInformationLog( bIsStack, upItem->itemTableIdx, stackItemIdx, -1 ) );
}
else
{
strcpy( item.name, g_itemTable[itemTableIdx].name );
if (itemTableIdx == QUESTSCROLL_ITEM_INDEX)
{
item.optionIdx[0] = pParam[4];
item.optionIdx[1] = pParam[5];
item.optionNumber = 2;
}
if (itemTableIdx == AUTOQUESTSCROLL_ITEM_INDEX)
{
item.optionIdx[0] = pParam[4];
item.optionIdx[1] = pParam[5];
item.optionNumber = 2;
}
{
CGolryunBattle_Data* cpData=gcpGolryunBattle->GetDataClassPointer();
assert(NULL != cpData);
CGolryunBattle_Common* cpCommon = gcpGolryunBattle->GetCommonClassPointer();
assert(NULL != cpCommon);
CGolryunBattle_Process* cpProcess = gcpGolryunBattle->GetProcessClassPointer();
assert(NULL != cpProcess);
if (tagGolryunBattle::TwoGyun_100000_Item_Index == itemTableIdx ||
tagGolryunBattle::TwoGyun_1000000_Item_Index == itemTableIdx)
{
int cnt = cpProcess->m_iTournamentIdx;
int time = cpData->m_iBattleGUID;
int winNum = pParam[5];
item.experience = cpProcess->m_iTournamentGUID;
item.optionIdx[0] = time;
item.optionIdx[1] = g_golryunManagerTable[cnt].levelMin;
item.optionIdx[2] = winNum;
item.optionNumber = 3;
g_logSystem->WriteToLog(
pc,
LOG_CLASS_GOLRYUN,
"%d;%d;%d;%d;%d;;",
CLogSystem::enumGolryunSubLog::BattleTicket,
item.experience,
item.optionIdx[0],
item.optionIdx[1],
item.optionIdx[2]);
}
if (itemTableIdx == tagGolryunBattle::Entrance_Ticket_Item_Index)
{
item.experience = cpData->m_EntranceTicket.iMaxAllocGUID++;
item.optionIdx[0] = cpData->m_iBattleGUID;
item.optionNumber = 1;
g_logSystem->WriteToLog(
pc,
LOG_CLASS_GOLRYUN,
"%d;%d;%d;;;;",
CLogSystem::enumGolryunSubLog::EnterTicket,
item.experience,
item.optionIdx[0]);
}
}
inventoryPos = GTH_FindEmptyInventoryPos( pc );
if( inventoryPos < 0 )
{
int itemObjectIdx = GTH_SpawnItemObject( &item, pc->worldIdx, pc->position, LOOTTYPE_INDIVIDUAL, pc->idx );
if ( itemObjectIdx < 0 )
{
g_logSystem->Write("Can't Obtain Item Error!!(pc name:%s, item index:%d, option group index:%d", pc->name, item.itemTableIdx, optionGroupIdx );
}
return 0;
}
itemIdx = GTH_AddMyItem( pc, &item );
if (itemIdx < 0)
{
int itemObjectIdx = GTH_SpawnItemObject( &item, pc->worldIdx, pc->position, LOOTTYPE_INDIVIDUAL, pc->idx );
if ( itemObjectIdx < 0 )
{
g_logSystem->Write("Can't Obtain Item Error!!(pc name:%s, item index:%d, option group index:%d", pc->name, item.itemTableIdx, optionGroupIdx );
}
return 0;
}
pc->inventory[inventoryPos] = itemIdx;
strcpy(generateID, "questGenID");
g_DBGameServer->AddItem(pc, &item, itemIdx, generateID);
g_logSystem->WriteToLog( pc, LOG_CLASS_ITEM, "%d;%d;%d;;;%s;%s",
LOG_CLASS_ITEM_ADD_QUEST, stackNumber, 0, item.name,
GetItemInformationLog( bIsStack, item.itemTableIdx, itemIdx, inventoryPos ) );
}
if ( reply == 1 )
{
error = pParam[3];
}
GTH_SendMessage_AddInvItem( pc, reply, error, &item );
return 1;
}
int AI_NPC_DeleteItem(void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
int itemTableIdx = pParam[0];
int itemNumber = pParam[1];
int reply = 1, error = 0;
int itemIdx, invenPos = -1, equipPos = -1;
item_t *item;
int bIsStack = false, stackNumber = 1;
for( int i = 0; i < MAX_INVENTORY_SIZE; i ++ )
{
itemIdx = pc->inventory[i];
if( itemIdx < 0 ) continue;
if( pc->item[itemIdx].itemTableIdx == itemTableIdx ) break;
}
if( i == MAX_INVENTORY_SIZE )
{
for( i = 0; i < MAX_EQUIPMENT; i ++ )
{
itemIdx = pc->equipment[i];
if( itemIdx < 0 ) continue;
if( pc->item[itemIdx].itemTableIdx == itemTableIdx ) break;
}
if( i == MAX_EQUIPMENT )
{
GTH_SendMessage_DeleteInvItem( pc, reply, error, itemTableIdx, itemNumber );
return 0;
}
equipPos = i;
}
else
{
invenPos = i;
}
item = &pc->item[itemIdx];
if( g_itemTable[item->itemTableIdx].stackFlag )
{
bIsStack = true;
stackNumber = itemNumber;
}
g_logSystem->WriteToLog( pc, LOG_CLASS_ITEM, "%d;%d;;;;%s;%s",
LOG_CLASS_ITEM_DEL_QUEST, stackNumber, item->name,
GetItemInformationLog( bIsStack, item->itemTableIdx, itemIdx, -1 ) );
if( GTH_IsStackItem( item ) )
{
if( item->durability + 1 < itemNumber )
{
reply = 0;
error = 1;
GTH_SendMessage_DeleteInvItem( pc, reply, error, itemTableIdx, itemNumber );
}
else if( item->durability + 1 == itemNumber )
{
if( invenPos >= 0 )
{
pc->inventory[invenPos] = -1;
}
else if( equipPos >= 0 )
{
pc->equipment[equipPos] = -1;
}
GTH_DeleteMyItem( pc, item );
g_DBGameServer->RemoveItem( pc, itemIdx );
}
else
{
item->durability -= itemNumber;
g_DBGameServer->SaveItem( pc, item, itemIdx );
}
}
else
{
if( invenPos >= 0 )
{
pc->inventory[invenPos] = -1;
}
else if( equipPos >= 0 )
{
pc->equipment[equipPos] = -1;
}
GTH_DeleteMyItem( pc, item );
g_DBGameServer->RemoveItem( pc, itemIdx );
}
GTH_SendMessage_DeleteInvItem( pc, reply, error, itemTableIdx, itemNumber );
return 1;
}
int AI_NPC_CompleteQuest(void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
int questIdx = pParam[0];
pc->questVar[questIdx].var.isComplete = true;
pc->questVar[questIdx].var.completeCount ++;
if( pc->questVar[questIdx].var.completeCount > MAX_COUNT_QUEST_COMPLETE )
pc->questVar[questIdx].var.completeCount = MAX_COUNT_QUEST_COMPLETE;
g_DBGameServer->SaveQuest( pc );
GTH_ClearQuestStatus( pc, questIdx, 1 );
return 1;
}
int AI_NPC_OpenSkillLevelUp(void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
int genType = pParam[0];
GTH_SendMessage_ReplyStore( pc, NULL, genType );
return 1;
}
int AI_NPC_OpenBinding(void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
int bindingIdx = pParam[0];
GTH_SendMessage_ReplyBinding( pc, 1, 0, 0, bindingIdx, g_binding[bindingIdx].cost );
return 1;
}
int AI_NPC_AddLoot(void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
int exp = 0, genExp = 0, nak = 0, genCap = 0;
exp = pParam[0];
genExp = pParam[1];
nak = pParam[2];
genCap = pParam[3];
GTH_PC_GetLoot( pc->idx, exp, genExp, nak, genCap, 0 );
return 1;
}
int AI_SendChatMessage(void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
int idx = pParam[0];
GTH_SendMessage_QuestLogic_ChatMsg( pc, idx,0 );
return 1;
}
int AI_SetDynamicField(void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
int questIdx = pParam[0];
int fieldIdx = pParam[1];
int value = pParam[2];
return( GTH_SetQuestStatusDynamicField( pc, questIdx, fieldIdx, value ) );
}
int AI_GetDynamicField(void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
int questIdx = pParam[0];
int fieldIdx = pParam[1];
return( GTH_GetQuestStatusDynamicField( pc, questIdx, fieldIdx ) );
}
int AI_CheckPlayerClass(void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
return( pc->pcClass );
}
int AI_CheckPlayerJob(void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
return( pc->pcJob );
}
int AI_CheckPlayerLevel(void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
return( pc->level );
}
int AI_CheckPlayerGenLevel(void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
return( pc->genLevel );
}
int AI_CheckPlayerStatus(void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
int statType = pParam[0];
switch( statType )
{
case 0 :
return( pc->calForce );
break;
case 1 :
return( pc->calSoulpower );
break;
case 2 :
return( pc->calAgility );
break;
case 3 :
return( pc->calVitality );
break;
}
return 0;
}
int AI_MoveToBindingPosition(void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
int bindingIdx = pParam[0];
int bindingCost = pParam[1];
switch(GetChaosClass(pc)) {
case CHAOS_DISORDER:
bindingCost=bindingCost*3;
break;
case CHAOS_MONSTER:
bindingCost=bindingCost*5;
break;
}
GTH_SendMessage_ReplyBinding( pc, 1, 0, 2, bindingIdx, bindingCost );
return 1;
}
int AI_AwakenPlayerJob( void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
int jobType = pParam[0];
int genType = -1;
int backGenCap[GEN_NUMBER];
for( int i = 0; i < GEN_NUMBER; i ++ ) backGenCap[i] = -1;
backGenCap[pc->pcClass] = pc->genCapability[pc->pcClass];
switch( jobType )
{
case J_MENTALITY :
break;
case J_WIND :
break;
case J_WATER :
break;
case J_EARTH:
break;
case J_DEVOTIONAL_KNIGHT :
genType = 3;
pc->force += 0;
pc->soulpower += 0;
pc->agility += 5;
pc->vitality += 0;
break;
case J_ROMING_KNIGHT :
genType = 1;
pc->force += 0;
pc->soulpower += 0;
pc->agility += 0;
pc->vitality += 5;
break;
case J_PIECING_EYES :
genType = 2;
pc->force += 0;
pc->soulpower += 5;
pc->agility += 0;
pc->vitality += 0;
break;
case J_WINDY_ROMER :
genType = 0;
pc->force += 0;
pc->soulpower += 0;
pc->agility += 0;
pc->vitality += 5;
break;
case J_DESTROYER :
genType = 0;
pc->force += 0;
pc->soulpower += 0;
pc->agility += 5;
pc->vitality += 0;
break;
case J_GUARDIAN :
genType = 3;
pc->force += 0;
pc->soulpower += 0;
pc->agility += 0;
pc->vitality += 5;
break;
case J_PROPHECIER :
genType = 1;
pc->force += 0;
pc->soulpower += 0;
pc->agility += 0;
pc->vitality += 0;
break;
case J_TRANSFORMER :
genType = 1;
pc->force += 0;
pc->soulpower += 0;
pc->agility += 5;
pc->vitality += 0;
break;
case J_DEFENDER :
genType = 0;
pc->force += 0;
pc->soulpower += 0;
pc->agility += 0;
pc->vitality += 5;
break;
case J_STRANGER :
genType = 2;
pc->force += 0;
pc->soulpower += 0;
pc->agility += 0;
pc->vitality += 0;
break;
}
pc->pcJob = jobType;
if( pc->genCapability[genType] < 0 ) backGenCap[genType] = 0;
else backGenCap[genType] = pc->genCapability[genType];
for( i = 0; i < GEN_NUMBER; i ++ )
{
pc->genCapability[i] = backGenCap[i];
}
GTH_SendMessage_QuestLogic_Awaken( pc );
GTH_PC_Calculate( pc );
return 1;
}
int AI_GetCompleteCount( void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
int questIdx = pParam[0];
return( pc->questVar[questIdx].var.completeCount );
}
int AI_OpenDepot( void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
GTH_SendMessage_ItemSystem_DepotOpen( pc );
return 1;
}
int AI_CloseDepot( void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
return 1;
}
int AI_OpenPrecocity( void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
GTH_SendMessage_ItemSystem_PrecocityOpen( pc );
return 1;
}
int AI_OpenCraft( void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
AI_NPC_CloseMessage( pc, pParam );
for( int i = 0; i < MAX_CRAFT_SOURCE_ITEM_SIZE; i ++ )
{
pc->craftSourceInventory[i] = -1;
}
for( i = 0; i < MAX_CRAFT_RESULT_ITEM_SIZE; i ++ )
{
pc->craftResultInventory[i] = -1;
}
GTH_AddNoticePC( pc, -1, -1, BUSY_STATE_CRAFT );
GTH_SendMessage_ItemSystem_CraftOpen( pc );
return 1;
}
int AI_OpenEventCraft( void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
AI_NPC_CloseMessage( pc, pParam );
for( int i = 0; i < MAX_CRAFT_SOURCE_ITEM_SIZE; i ++ )
{
pc->craftSourceInventory[i] = -1;
}
GTH_AddNoticePC( pc, -1, -1, BUSY_STATE_CRAFT );
GTH_SendMessage_ItemSystem_EventCraftOpen( pc );
return 1;
}
int AI_OpenNpcInventory(void *pPc, int *pParam)
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
AI_NPC_CloseMessage( pc, pParam );
for( int i = 0; i < MAX_AUTO_TRADEITEMFILD; i ++ )
{
pc->npcAutoSourceInventory[i] = -1;
}
GTH_AddNoticePC( pc, -1, -1, BUSY_STATE_NPC_INVENTORY );
GTH_SendMessage_ItemSystem_NpcInventoryOpen( pc );
return 1;
}
int AI_OpenUpgrade( void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
AI_NPC_CloseMessage( pc, pParam );
for( int i = 0; i < MAX_UPGRADE_SOURCE_ITEM_SIZE; i ++ )
{
pc->upgradeSourceInventory[i] = -1;
}
pc->upgradeResultInventory = -1;
GTH_AddNoticePC( pc, -1, -1, BUSY_STATE_UPGRADE );
GTH_SendMessage_ItemSystem_UpgradeOpen( pc );
return 1;
}
int AI_InitPlayerStatus( void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
int nak;
int level = pc->level;
nak = ( 100 * level * level * level + 50 * level * level ) / 8;
pc->npcAi.globalData[0] = nak;
GTH_SendMessage_QuestLogic_InitStatus( pc, 1, 0, 0, nak );
return 1;
}
int AI_OpenQuestScroll( void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
AI_NPC_CloseMessage( pc, pParam );
if( pc->level > 10 )
{
GTH_AddNoticePC( pc, -1, -1, BUSY_STATE_QUESTSCROLL );
GTH_SendMessage_QuestScroll_ObtainOpen( pc, 1 );
}
else
{
GTH_SendMessage_QuestScroll_ObtainOpen( pc, 0 );
}
return 1;
}
int AI_NPC_AddQuestItem(void *pPc,int *pParam)
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
int itemTableIdx = pParam[0];
int questIdx = pParam[1];
int number = pParam[2];
int maxnum = pParam[3];
GTH_AddQuestItem(pc,itemTableIdx,questIdx,number,maxnum);
return 1;
}
int AI_NPC_FindEmptyInventoryPos(void *pPc,int *pParam)
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
int inventoryPos=-1;
return inventoryPos = GTH_FindEmptyInventoryPos( pc );
}
int AI_SendDialogMessage(void *pPc,int *pParam)
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
GTH_SendMessage_QuestLogic_ChatMsg( pc, 1, 1 );
return 1;
}
int AI_OpenGambleStore( void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
int storeIdx = pParam[0];
storeStruct_t Makestore;
if ( FALSE == g_GambleSystem.MakeGambleStore(&Makestore, &g_store[storeIdx], pc) )
{
GTH_SendMessage_ChattingMsg(pc, 0, 9, 193 );
return -1;
}
GTH_SendMessage_ReplyStore( pc, &Makestore, 2 );
pc->storeIdx = storeIdx;
return 1;
}
int AI_OpenRequestDanBattle( void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
int ret = g_DanBattleFunc.RecvCC_ReqeustBattle(pc);
if ( ret <= 0)
{
int lpackIdx = 0;
switch ( ret )
{
case 0:
lpackIdx = 60;
break;
case -1:
lpackIdx = 59;
break;
case -2:
lpackIdx = 74;
break;
case -3:
lpackIdx = 60;
break;
}
GTH_SendMessage_ChattingMsg(pc, 0, 9, lpackIdx );
return -1;
}
return 1;
}
#include "..\GonryunPracticeBattle\CGonryunPracticeBattle.h"
extern CGonryunPracticeBattle g_GonryunPracticeBattle;
#include "..\GonryunPracticeBattle\CGonryunPractice_Encoder.h"
#include "..\GonryunPracticeBattle\CGonryunPractice_ProcessCtrl.h"
int AI_GonryunBattle(void *pPc, int *pParam)
{
playerCharacter_t* pPlayer = static_cast< playerCharacter_t* >( pPc );
if((NULL == pPlayer) || (FALSE == pPlayer->active)) return 0;
return g_GonryunPracticeBattle.NPCClick(pPlayer);
}
int AI_OpenPackage(void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
g_DBGameServer->LoadPackageList(pc);
return 1;
}
int AI_NPC_TransportGolryun( void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
(gcpGolryunBattle->GetEncoderClassPointer())->SendTrasportGolryun(&pc->sock);
GTH_DeleteNoticePC(pc);
return 1;
}
int AI_NPC_TransportArayan( void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
(gcpGolryunBattle->GetEncoderClassPointer())->SendTrasportArayan(&pc->sock);
GTH_DeleteNoticePC(pc);
return 1;
}
int AI_NPC_SuggestGolryunBattle( void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
BYTE type=0;
switch((gcpGolryunBattle->GetProcessClassPointer())->GetTournamentStatus())
{
case CGolryunBattle_Process::eTournamentStep::TournamentStep_START_JOIN:
type = 1;
break;
case CGolryunBattle_Process::eTournamentStep::TournamentStep_CLOSE_JOIN:
type = 2;
break;
}
(gcpGolryunBattle->GetEncoderClassPointer())->SendSuggestBattle(&pc->sock, type);
GTH_DeleteNoticePC(pc);
return 1;
}
int AI_NPC_BuyGolryunBattleTicket( void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
(gcpGolryunBattle->GetEncoderClassPointer())->SendOpenBattleTicket(&pc->sock, 1);
GTH_DeleteNoticePC(pc);
return 1;
}
int AI_NPC_DisplayTournament( void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
(gcpGolryunBattle->GetEncoderClassPointer())->SendDisplayTournament(&pc->sock);
GTH_DeleteNoticePC(pc);
return 1;
}
int AI_NPC_CheckPrize( void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
(gcpGolryunBattle->GetEncoderClassPointer())->SendCheckPrize(&pc->sock);
GTH_DeleteNoticePC(pc);
return 1;
}
int AI_NPC_ObserveTournament( void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
if((TRUE == pc->GonryunBattle.Observer.bActive) ||
(pc->worldIdx != tagGolryunBattle::Golryun_Battle_Map_Index)){
(gcpGolryunBattle->GetEncoderClassPointer())->SendObserveStart(pc,FALSE);
GTH_DeleteNoticePC(pc);
return 1;
}
pc->GonryunBattle.Observer.bActive = gcpGolryunBattle_Observer->Insert(pc);
if(TRUE == pc->GonryunBattle.Observer.bActive){
(gcpGolryunBattle->GetEncoderClassPointer())->SendObserveStart(pc,TRUE);
(gcpGolryunBattle->GetProcessClassPointer())->FindOutFighterNumber();
}else{
(gcpGolryunBattle->GetEncoderClassPointer())->SendObserveStart(pc,FALSE);
}
GTH_DeleteNoticePC(pc);
return 1;
}
int AI_helpOpen( void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
if((NULL == pc) || (FALSE == pc->active)) return 0;
return 1;
}
int AI_OpenGiftCardWin( void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
gcpGiftCard->TransmitePacket_SC_Open(pc);
return 1;
}
int AI_DanBattleEvent(void *pPc, int *pParam)
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
int ChoasClass = GetChaosClass(pc);
int KillPoint = pc->nAccumulationBattleKillPoint;
int decKillpoint = 10;
int NextChaosPoint = 0;
switch(ChoasClass)
{
case CHAOS_PURE:
case CHAOS_GENERAL:
{
GTH_SendMessage_ChattingMsg(pc, 0, 9, 657 );
return 1;
}
break;
case CHAOS_DISORDER:NextChaosPoint = CHAOSGENERATE; break;
case CHAOS_MONSTER: NextChaosPoint = CHAOSDISORDER; break;
case CHAOS_ATROCITY:NextChaosPoint = CHAOSMONSTER; break;
}
if ( (KillPoint - decKillpoint) < 0 )
{
GTH_SendMessage_ChattingMsg(pc, 0, 9, 656);
return 2;
}
pc->nAccumulationBattleKillPoint -= decKillpoint;
g_DBGameServer->Save_danbattle_pcpoint(pc, -(decKillpoint) );
pc->chaosPoint = NextChaosPoint;
GTH_SendMessage_ChattingMsg(pc, 0, 9, 655);
GTH_SendMessage_ChaoPointEvent(pc, decKillpoint);
return 1;
}
int AI_DanBattlePcPoint(void *pPc, int *pParam)
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
GTH_SendMessage_ReplyCheatCode(pc, CHEATCODE_DANBATTLE_PCPOINT);
return 1;
}
| C++ |
#ifndef _AI_PATHFINDING_H_
#define _AI_PATHFINDING_H_
class AI_NodeTotalGreater
{
public:
bool operator()( node_t *first, node_t *second ) const
{
return( first->total > second->total );
}
};
void AI_PreparePathfinding( monsterCharacter_t *monster, int pathfindingSize = 30 );
void AI_ReleasePathfinding( monsterCharacter_t *monster );
void AI_LoadCollisionMap( char* filename );
void AI_InitNodeBank( monsterCharacter_t* monster );
void AI_DeleteNodeBank( monsterCharacter_t* monster );
bool AI_FindPath( monsterCharacter_t* monster );
void AI_MakePath( monsterCharacter_t* monster );
void AI_StopPathFinding( monsterCharacter_t* monster );
#endif | C++ |
#include "../global.h"
int AI_LoadCollisionMap( char *fname, collisionMap_t *mapt )
{
FILE *fp;
int size;
GTH_2DMap_Head_t *head;
fp = fopen( fname , "rb" );
if ( !fp ) return 0;
fseek( fp , 0 , SEEK_END );
size = ftell( fp );
fseek( fp , 0 , SEEK_SET );
mapt->buffer = new BYTE[ size ];
fread( mapt->buffer , size , 1 , fp );
fclose( fp );
head = ( GTH_2DMap_Head_t * ) mapt->buffer;
mapt->scale = head->gridSize;
mapt->xsize = head->width;
mapt->ysize = head->height;
mapt->heightMap = (float*) ( mapt->buffer + head->offsetHeightArray );
mapt->flagMap = (BYTE*) ( mapt->buffer + head->offsetFlagArray );
return 1;
}
int AI_CheckCollision( int x, int y, collisionMap_t* mapt )
{
if( x < 0 || x >= mapt->xsize ) return( 0 );
if( y < 0 || y >= mapt->ysize ) return( 0 );
if( mapt->flagMap[ y * mapt->xsize + x ] == 1 ) return( 1 );
else return( 0 );
}
int AI_CheckCollision( vec3_t pos, collisionMap_t* mapt )
{
grid_t gridPos;
AI_GetGridPosition( pos, gridPos, mapt );
return( AI_CheckCollision( gridPos[0], gridPos[1], mapt ) );
}
int AI_GetGridPosition( vec3_t wpos, grid_t cpos, collisionMap_t* mapt )
{
cpos[0] = (int)(wpos[0] / (float)mapt->scale);
cpos[1] = (int)(wpos[1] / (float)mapt->scale);
if( cpos[0] < 0 || cpos[0] >= mapt->xsize ) return( 0 );
if( cpos[1] < 0 || cpos[1] >= mapt->ysize ) return( 0 );
return( 1 );
}
int AI_GetWorldPosition( grid_t cpos, vec3_t wpos, collisionMap_t* mapt )
{
wpos[0] = (float)cpos[0] * (float)mapt->scale;
wpos[1] = (float)cpos[1] * (float)mapt->scale;
if( cpos[0] < 0 || cpos[0] >= mapt->xsize ) return( 0 );
if( cpos[1] < 0 || cpos[1] >= mapt->ysize ) return( 0 );
return( 1 );
}
| C++ |
#include "../global.h"
char sterMonsterAI[60][100]=
{
" 0 : AI_SetTimer",
" 1 : AI_HaveDamaged",
" 2 : AI_SetTarget",
" 3 : AI_MoveToAnywhere",
" 4 : AI_SetAIEvent",
" 5 : AI_IsActiveTarget",
" 6 : AI_RemoveTarget",
" 7 : AI_IsWithinAttackLength",
" 8 : AI_CanTraceTarget",
" 9 : AI_MoveToTarget",
" 10 : AI_SearchTarget",
" 11 : AI_MoveToWayPoint",
" 12 : AI_FleeToTarget",
" 13 : AI_SearchFellow",
" 14 : AI_CheckAbilityRate",
" 15 : AI_GetDistanceFromTarget",
" 16 : AI_IsWithInWayPoint",
" 17 : AI_RunFromTarget",
" 18 : AI_SetMoveType",
" 19 : AI_IsNearTarget",
" 20 : AI_ReceiveHelpMessage",
" 21 : AI_HaveBoss ",
" 22 : AI_MoveToBoss",
" 23 : AI_SendHelpMessage",
" 24 : AI_GetAttackerCount",
" 25 : AI_IsAtkRngLongerThanValue",
" 26 : AI_IsAtkRngShorterThanValue",
" 27 : AI_AddSkillUsePercent",
" 28 : AI_RemoveSkillUsePercent ",
" 29 : AI_UseSkill",
" 30 : AI_HaveSelectedSkill",
" 31 : AI_IsAttackerLevelHigherThanMe",
" 32 : AI_IsPartyPlayer",
" 33 : AI_IsHaveTargetTrace",
" 34 : AI_MoveToSpawnPos",
" 35 : AI_IsOverRangeFromSpawnPos ",
" 36 : AI_GetDamage",
" 37 : AI_MonsterSummon",
" 38 : AI_IsUsedSkill",
" 39 : AI_SetUsedSkill",
" 40 : AI_IsOverDIstansAttackRangeRate",
" 41 : AI_IsHighVelocityThenMonster",
" 42 : AI_GetSkillElapsedTime ",
" 43 : AI_SendHelpMsg",
" 44 : AI_GetAIEvent",
" 45 : AI_GetSummonElapsedTime",
" 46 : AI_GetTimeSkill",
" 47 : AI_SetSkillAnimationTime",
" 48 : NULL",
" 49 : NULL",
" 50 : NULL",
" 51 : AI_GetRandom",
" 52 : NULL",
" 53 : NULL",
" 54 : NULL",
" 55 : NULL",
" 56 : NULL",
" 57 : NULL",
" 58 : NULL",
" 59 : NULL",
};
int AI_InterpretorFunction( monsterCharacter_t* monster )
{
int param[5]={0,0,0,0,0};
int variable = false;
int paramAddr;
paramAddr = AI_GetCharData( monster );
switch( paramAddr )
{
case 0:
AI_InterpretorParameter( monster, param, 1 );
variable = AI_SetTimer( monster, param[0] );
break;
case 1 :
AI_InterpretorParameter( monster, param, 0 );
variable = AI_HaveDamaged( monster );
break;
case 2 :
AI_InterpretorParameter( monster, param, 1 );
variable = AI_SetTarget( monster, param[0] );
break;
case 3 :
AI_InterpretorParameter( monster, param, 1 );
variable = AI_MoveToAnywhere( monster, param[0] );
break;
case 4 :
AI_InterpretorParameter( monster, param, 1 );
variable = AI_SetAIEvent( monster, param[0] );
break;
case 5 :
AI_InterpretorParameter( monster, param, 0 );
variable = AI_IsActiveTarget( monster );
break;
case 6 :
AI_InterpretorParameter( monster, param, 0 );
variable = AI_RemoveTarget( monster );
break;
case 7 :
AI_InterpretorParameter( monster, param, 0 );
variable = AI_IsWithinAttackLength( monster );
break;
case 8 :
AI_InterpretorParameter( monster, param, 1 );
variable = AI_CanTraceTarget( monster, param[0] );
break;
case 9 :
AI_InterpretorParameter( monster, param, 0 );
variable = AI_MoveToTarget( monster );
break;
case 10 :
AI_InterpretorParameter( monster, param, 2 );
variable = AI_SearchTarget( monster, param[0], param[1] );
break;
case 11 :
AI_InterpretorParameter( monster, param, 0 );
variable = AI_MoveToWayPoint( monster );
break;
case 12 :
AI_InterpretorParameter( monster, param, 1 );
variable = AI_FleeToTarget( monster, param[0] );
break;
case 13 :
AI_InterpretorParameter( monster, param, 1 );
variable = AI_SearchFellow( monster, param[0] );
break;
case 14 :
AI_InterpretorParameter( monster, param, 1 );
variable = AI_CheckAbilityRate( monster, param[0] );
break;
case 15 :
AI_InterpretorParameter( monster, param, 0 );
variable = AI_GetDistanceFromTarget( monster );
break;
case 16 :
AI_InterpretorParameter( monster, param, 0 );
variable = AI_IsWithInWayPoint( monster );
break;
case 17 :
AI_InterpretorParameter( monster, param, 0 );
variable = AI_RunFromTarget( monster );
break;
case 18 :
AI_InterpretorParameter( monster, param, 1 );
variable = AI_SetMoveType( monster, param[0] );
break;
case 19 :
AI_InterpretorParameter( monster, param, 1 );
variable = AI_IsNearTarget( monster, param[0] );
break;
case 20 :
AI_InterpretorParameter( monster, param, 0 );
variable = AI_ReceiveHelpMessage( monster );
break;
case 21 :
AI_InterpretorParameter( monster, param, 1 );
variable = AI_HaveBoss( monster, param[0] );
break;
case 22 :
AI_InterpretorParameter( monster, param, 0 );
variable = AI_MoveToBoss( monster );
break;
case 23 :
AI_InterpretorParameter( monster, param, 2 );
variable = AI_SendHelpMessage( monster, param[0], param[1] );
break;
case 24 :
AI_InterpretorParameter( monster, param, 0 );
variable = AI_GetAttackerCount( monster );
break;
case 25 :
AI_InterpretorParameter( monster, param, 1 );
variable = AI_IsAtkRngLongerThanValue( monster, param[0] );
break;
case 26 :
AI_InterpretorParameter( monster, param, 1 );
variable = AI_IsAtkRngShorterThanValue( monster, param[0] );
break;
case 27 :
AI_InterpretorParameter( monster, param, 2 );
variable = AI_AddSkillUsePercent( monster, param[0], param[1] );
break;
case 28 :
AI_InterpretorParameter( monster, param, 0 );
variable = AI_RemoveSkillUsePercent( monster );
break;
case 29 :
AI_InterpretorParameter( monster, param, 0 );
variable = AI_UseSkill( monster );
break;
case 30 :
AI_InterpretorParameter( monster, param, 0 );
variable = AI_HaveSelectedSkill( monster );
break;
case 31 :
AI_InterpretorParameter( monster, param, 0 );
variable = AI_IsAttackerLevelHigherThanMe( monster );
break;
case 32 :
AI_InterpretorParameter( monster, param, 0 );
variable = AI_IsPartyPlayer( monster );
break;
case 33 :
AI_InterpretorParameter( monster, param, 0 );
variable = AI_IsHaveTargetTrace( monster );
break;
case 34 :
AI_InterpretorParameter( monster, param, 0 );
variable = AI_MoveToSpawnPos( monster );
break;
case 35:
AI_InterpretorParameter ( monster, param, 1);
variable = AI_IsOverRangeFromSpawnPos( monster , param[0]);
break;
case 36:
AI_InterpretorParameter( monster, param, 0 );
variable = AI_GetDamage( monster );
break;
case 37:
AI_InterpretorParameter( monster, param, 2 );
variable = AI_MonsterSummon( monster, param[0], param[1] );
break;
case 38:
AI_InterpretorParameter(monster, param, 1);
variable = AI_IsUsedSkill( monster, param[0] );
break;
case 39:
AI_InterpretorParameter(monster, param, 2);
variable = AI_SetUsedSkill( monster, param[0], param[1] );
break;
case 40:
AI_InterpretorParameter(monster, param, 1);
variable = AI_IsOverDIstansAttackRangeRate (monster, param[0] );
break;
case 41:
AI_InterpretorParameter(monster, param, 0);
variable = AI_IsHighVelocityThenMonster(monster);
break;
case 42:
AI_InterpretorParameter(monster, param, 1);
variable = AI_GetSkillElapsedTime(monster, param[0]);
break;
case 43:
AI_InterpretorParameter(monster, param, 3);
variable = AI_SendHelpMsg(monster, param[0], param[1], param[2]);
break;
case 44:
AI_InterpretorParameter(monster, param, 0);
variable = AI_GetAIEvent(monster);
break;
case 45:
AI_InterpretorParameter(monster, param, 0);
variable = AI_GetSummonElapsedTime(monster);
break;
case 46:
AI_InterpretorParameter(monster, param, 3);
variable = AI_GetTimeSkill(monster,param[0], param[1], param[2]);
break;
case 47 :
AI_InterpretorParameter(monster, param, 2);
variable = AI_SetSkillAnimationTime(monster,param[0], param[1]);
break;
case 51 :
AI_InterpretorParameter(monster, param,0);
variable = AI_GetRandom(monster);
break;
default:
break;
}
return( variable );
}
int AI_InterpretorDefine( monsterCharacter_t* monster, int paramAddr )
{
int variable;
switch( paramAddr )
{
case 0 :
variable = true;
break;
case 1 :
variable = false;
break;
case 2 :
variable = AI_MOVE;
break;
case 3 :
variable = AI_ATTACK;
break;
case 4 :
variable = AI_TRACE;
break;
case 5 :
variable = AI_RUNAWAY;
break;
case 6 :
variable = AI_DEF_VERYSLOW_TIMER;
break;
case 7 :
variable = AI_DEF_SLOW_TIMER;
break;
case 8 :
variable = AI_DEF_NORMAL_TIMER;
break;
case 9 :
variable = AI_DEF_FAST_TIMER;
break;
case 10 :
variable = AI_DEF_VERYFAST_TIMER;
break;
case 11 :
variable = AI_DEF_DAMAGED_ENTITY;
break;
case 12 :
variable = AI_DEF_NEAR_ENTITY;
break;
case 13 :
variable = AI_DEF_RANDOM;
break;
case 14 :
variable = AI_DEF_NEAR_FELLOW;
break;
case 15 :
variable = AI_DEF_MY_RA;
break;
case 16 :
variable = AI_DEF_ENABLE_WALK;
break;
case 17 :
variable = AI_DEF_DISABLE_MOVE;
break;
case 18 :
variable = AI_DEF_DISABLE_WALK;
break;
case 19 :
variable = AI_DEF_ENTITY_PC;
break;
case 20 :
variable = AI_DEF_ENTITY_MONSTER;
break;
case 21 :
variable = AI_DEF_ENTITY_NPC;
break;
case 22 :
variable = AI_DEF_MY_SA;
break;
case 23 :
variable = AI_DEF_LESS_RA_ENTITY;
break;
case 24 :
variable = AI_DEF_MORE_POINT_ENTITY;
break;
}
return( variable );
}
int AI_LoadScript( monsterCharacter_t* monster, char* filename )
{
FILE *fp;
int n, l, type, var, i;
char name[MAX_SCRIPT_VAL_LEN];
fp = fopen( filename, "rb" );
if( !fp ) return 0;
fread( &n, sizeof( int ), 1, fp );
for( i = 0; i < n; i ++ )
{
fread( &l, sizeof( int ), 1, fp );
fread( name, l, 1, fp );
fread( &type, sizeof( int ), 1, fp );
fread( &var, sizeof( int ), 1, fp );
monster->ai.aiVariable[ i ] = var;
}
fread( &n, sizeof( int ), 1, fp );
for( i = 0; i < n; i ++ )
{
fread( &l, sizeof( int ), 1, fp );
fread( name, l, 1, fp );
fread( &var, sizeof( int ), 1, fp );
monster->ai.aiProcedureAddr[ i ] = var;
}
fread( &n, sizeof( int ), 1, fp );
monster->ai.aiData = (char*)malloc( n );
fread( monster->ai.aiData, n, 1, fp );
fclose( fp );
monster->ai.aiAddr = 0;
monster->ai.callProcedureAddr = 0;
monster->ai.isCall = false;
return 1;
}
char AI_GetCharData( monsterCharacter_t* monster )
{
return( monster->ai.aiData [ monster->ai.aiAddr++ ] );
}
int AI_GetIntData( monsterCharacter_t* monster )
{
int n;
memcpy( &n, &monster->ai.aiData[ monster->ai.aiAddr ], sizeof( int ) );
monster->ai.aiAddr += sizeof( int );
return( n );
}
void AI_InterpretImmediately( monsterCharacter_t* monster )
{
monster->ai.saveTime = 0;
}
int AI_Interpretor( monsterCharacter_t* monster )
{
char inter;
if( monster->aliveState != MON_ALIVE_STATE_NORMAL ) return( 0 );
if( monster->entityType == ENTITY_NPC )
{
NPC_CheckNoticePC( monster );
}
if( monster->npc.noticePcNumber > 0 ) return( 0 );
if( monster->ai.isCall )
{
monster->ai.isCall = false;
}
if( g_globalTime - monster->ai.saveTime < monster->ai.thinkTime )
return(0);
monster->ai.callProcedureAddr = monster->ai.aiAddr;
while( !monster->ai.isCall )
{
inter = AI_GetCharData( monster );
if( inter == 'x' ) break;
switch( inter )
{
case 'p':
inter = AI_GetCharData( monster );
break;
case 'o':
AI_InterpretorOperation( monster );
break;
case 'i':
AI_InterpretorIF( monster );
break;
case 'c':
AI_InterpretorCall( monster );
break;
case 'f':
AI_InterpretorFunction( monster );
}
}
if( monster->aliveState != MON_ALIVE_STATE_NORMAL )
monster->ai.aiEvent = AI_DIE;
if( !monster->ai.isCall )
{
monster->ai.saveTime = g_globalTime;
}
monster->ai.aiAddr = monster->ai.callProcedureAddr;
return(1);
}
void AI_InterpretorCall( monsterCharacter_t* monster )
{
int paramAddr;
paramAddr = AI_GetCharData( monster );
if( monster->ai.isCall ) return;
monster->ai.callProcedureAddr = monster->ai.aiProcedureAddr[paramAddr];
monster->ai.isCall = true;
}
void AI_InterpretorOperation( monsterCharacter_t* monster )
{
char inter;
int paramAddr1, paramAddr2, operatorParam;
int variable;
inter = AI_GetCharData( monster );
if( inter == 'v' )
{
paramAddr1 = AI_GetCharData( monster );
}
inter = AI_GetCharData( monster );
operatorParam = inter;
inter = AI_GetCharData( monster );
if( inter == 'v' )
{
paramAddr2 = AI_GetCharData( monster );
variable = monster->ai.aiVariable[paramAddr2];
}
if( inter == 'n' )
{
variable = AI_GetIntData( monster );
}
if( inter == 'f' )
{
variable = AI_InterpretorFunction( monster );
}
if( inter == 'd' )
{
paramAddr2 = AI_GetCharData( monster );
variable = AI_InterpretorDefine( monster, paramAddr2 );
}
switch( operatorParam )
{
case 0:
monster->ai.aiVariable[paramAddr1] += variable;
break;
case 1:
monster->ai.aiVariable[paramAddr1] -= variable;
break;
case 2:
monster->ai.aiVariable[paramAddr1] *= variable;
break;
case 3:
monster->ai.aiVariable[paramAddr1] /= variable;
break;
case 4:
monster->ai.aiVariable[paramAddr1] = variable;
break;
}
}
void AI_InterpretorParameter( monsterCharacter_t* monster, int param[], int n )
{
char inter;
int variable, paramAddr;
int i;
for( i = 0; i < n; i ++ )
{
inter = AI_GetCharData( monster );
if( inter == 'n' )
{
variable = AI_GetIntData( monster );
param[ i ] = variable;
continue;
}
if( inter == 'd' )
{
paramAddr = AI_GetCharData( monster );
variable = AI_InterpretorDefine( monster, paramAddr );
param[ i ]= variable;
continue;
}
if( inter == 'v' )
{
paramAddr = AI_GetCharData( monster );
variable = monster->ai.aiVariable[ paramAddr ];
param[ i ] = variable;
continue;
}
if( inter == 'f' )
{
paramAddr = AI_GetCharData( monster );
variable = AI_InterpretorFunction( monster );
param[ i ] = variable;
continue;
}
}
}
int AI_InterpretorCase( monsterCharacter_t* monster )
{
char inter;
int cases[5], casesNumber = 0;
int variable1, variable2, paramAddr, operatorAddr;
int i;
while( !monster->ai.isCall )
{
inter = AI_GetCharData( monster );
if( inter == 't' ) break;
if( inter == 'a' ) inter = AI_GetCharData( monster );
if( inter == 'v' )
{
paramAddr = AI_GetCharData( monster );
variable1 = monster->ai.aiVariable[ paramAddr ];
}
if( inter == 'n' )
{
variable1 = AI_GetIntData( monster );
}
if( inter == 'd' )
{
paramAddr = AI_GetCharData( monster );
variable1 = AI_InterpretorDefine( monster, paramAddr );
}
if( inter == 'f' )
{
variable1 = AI_InterpretorFunction( monster );
}
inter = AI_GetCharData( monster );
operatorAddr = inter;
inter = AI_GetCharData( monster );
if( inter == 'v' )
{
paramAddr = AI_GetCharData( monster );
variable2 = monster->ai.aiVariable[ paramAddr ];
}
if( inter == 'n' )
{
variable2 = AI_GetIntData( monster );
}
if( inter == 'd' )
{
paramAddr = AI_GetCharData( monster );
variable2 = AI_InterpretorDefine( monster, paramAddr );
}
if( inter == 'f' )
{
variable2 = AI_InterpretorFunction( monster );
}
cases[ casesNumber ] = 0;
switch( operatorAddr )
{
case 0:
if( variable1 == variable2 ) cases[ casesNumber ] = 1;
break;
case 1:
if( variable1 != variable2 ) cases[ casesNumber ] = 1;
break;
case 2:
if( variable1 < variable2 ) cases[ casesNumber ] = 1;
break;
case 3:
if( variable1 > variable2 ) cases[ casesNumber ] = 1;
break;
case 4:
if( variable1 <= variable2 ) cases[ casesNumber ] = 1;
break;
case 5:
if( variable1 >= variable2 ) cases[ casesNumber ] = 1;
break;
}
casesNumber ++;
}
for( i = 0; i < casesNumber; i ++ ) if( !cases[ i ] ) return( 0 );
return( 1 );
}
void AI_InterpretorThen( monsterCharacter_t* monster, int addrInfo[] )
{
char inter;
monster->ai.aiAddr = addrInfo[0];
while( !monster->ai.isCall )
{
inter = AI_GetCharData( monster );
if( inter == 'e' || inter == 'q' )
{
monster->ai.aiAddr = addrInfo[ 2 ];
break;
}
switch( inter )
{
case 'o':
AI_InterpretorOperation( monster );
break;
case 'i':
AI_InterpretorIF( monster );
break;
case 'c':
AI_InterpretorCall( monster );
break;
case 'f':
AI_InterpretorFunction( monster );
break;
}
}
}
void AI_InterpretorElse( monsterCharacter_t* monster, int addrInfo[] )
{
char inter;
monster->ai.aiAddr = addrInfo[1];
while( !monster->ai.isCall )
{
inter = AI_GetCharData( monster );
if( inter == 'q' )
{
monster->ai.aiAddr = addrInfo[ 2 ];
break;
}
switch( inter )
{
case 'o':
AI_InterpretorOperation( monster );
break;
case 'i':
AI_InterpretorIF( monster );
break;
case 'c':
AI_InterpretorCall( monster );
break;
case 'f':
AI_InterpretorFunction( monster );
break;
}
}
}
void AI_InterpretorIF( monsterCharacter_t* monster )
{
char inter;
int addrInfo[3];
int cases;
addrInfo[0] = AI_GetIntData( monster );
addrInfo[1] = AI_GetIntData( monster );
addrInfo[2] = AI_GetIntData( monster );
while( !monster->ai.isCall )
{
inter = AI_GetCharData( monster );
if( inter == 'q' ) break;
if( inter == 'a' )
{
cases = AI_InterpretorCase( monster );
if( cases ) AI_InterpretorThen( monster, addrInfo );
else if( addrInfo[1] ) AI_InterpretorElse( monster, addrInfo );
else monster->ai.aiAddr = addrInfo[ 2 ];
}
}
}
| C++ |
#ifndef _FUNTION_OBJECT_H_
#define _FUNTION_OBJECT_H_
template<typename T>
class Tfind_if: public std::binary_function< T*, T* ,bool>{
public:
bool operator()(const T *rT ,const T *rTdec)const
{
if(*rT==*rTdec) return TRUE;
else return FALSE;
}
};
template<typename T>
struct TDelete: public std::unary_function<const T*,void>
{
template<typename T> void operator()(T* pT) const
{
if(pT){
delete pT;
pT=NULL;
}
}
};
#endif _FUNTION_OBJECT_H_ | C++ |
#ifndef _LOG_H_
#define _LOG_H_
#include "./Billing/CriticalSection.h"
#include "./log/CLogFileCtrl.h"
class CLogSystem
{
private:
CLogFileCtrl m_UserLogTTCtrl;
CLogFileCtrl m_UserLogCtrl;
CLogFileCtrl m_DebugLogCtrl;
CLogFileCtrl m_ErrorLogCtrl;
CLogFileCtrl m_NewDanbattleLogCtrl;
CLogFileCtrl m_HackingUserLogCtrl;
char m_logFileName[MAX_PATH];
char m_logTTFileName[MAX_PATH];
char m_debugFileName[MAX_PATH];
char m_NewDanBattleFileName[MAX_PATH];
char m_HackingUserFileName[MAX_PATH];
public:
enum enumGolryunSubLog{
EnterTicket=0,
BattleTicket=1,
JoinBattle=2,
StartMatch=3,
MatchResult=4,
TournamentResult=5,
TournamentCancel=6,
RewardWinner=7,
RewardLoser=8,
RewardWaiter=9,
ShareBattleTicket=10,
RewardWinner_Item=11,
};
private:
unsigned int m_updateTime;
int m_updateCycle;
int m_generationHour;
public:
void Initialize(const BOOL in_bCreateLog,const BOOL in_bCreateDebug);
BOOL Open(void);
BOOL Close(void);
BOOL Update(void);
public:
void WriteToLog(const playerCharacter_t* in_pPlayer,const int in_logClass,const char* in_format, ... );
void Write( const char *format, ... );
void WriteToError( const char *format, ... );
void WriteToLog( const char *format, ... );
void WriteToLogTT( const char *format, ... );
void WriteRLog( const char *format, ... );
void WriteToNewDanBattleLog( const char *format, ... );
void WriteToHackingLog( const char *format, ... );
public:
void WriteItemDeleteLog(const playerCharacter_t* in_pPlayer,const item_t& in_item);
public:
CLogSystem();
~CLogSystem();
};
enum
{
LOG_CLASS_LEVELUP = 0,
LOG_CLASS_GENLEVELUP,
LOG_CLASS_ITEM,
LOG_CLASS_PCDIE,
LOG_CLASS_CONNECT,
LOG_CLASS_DISCONNECT,
LOG_CLASS_PCCREATE,
LOG_CLASS_PCDELETE,
LOG_CLASS_PCERROR,
LOG_CLASS_SKILL,
LOG_CLASS_CHEAT,
LOG_CLASS_GOLRYUN,
LOG_CLASS_POSTSYSTEM,
LOG_CLASS_NEWDANBATTLE,
};
enum
{
LOG_CLASS_NEWDANBATTLE_START =0,
LOG_CLASS_NEWDANBATTLE_END,
LOG_CLASS_NEWDANBATTLE_RESULT
};
enum
{
LOG_CLASS_NEWDANBATTLE_END_LIVECOUNT =0,
LOG_CLASS_NEWDANBATTLE_END_TIMESET,
LOG_CLASS_NEWDANBATTLE_END_GM_COMMAND,
};
enum{
LOG_CLASS_SKILL_RESURRECTION=0,
};
enum
{
LOG_CLASS_ITEM_PICKUP = 0,
LOG_CLASS_ITEM_DROP,
LOG_CLASS_ITEM_STACK,
LOG_CLASS_ITEM_BUY_STORE,
LOG_CLASS_ITEM_SELL_STORE,
LOG_CLASS_ITEM_LEARN_SKILL,
LOG_CLASS_ITEM_SKILL_SCROLL,
LOG_CLASS_ITEM_USE_PORTAL,
LOG_CLASS_ITEM_DESTROY,
LOG_CLASS_ITEM_CONFIRM_TRADE,
LOG_CLASS_ITEM_UNDO_TRADE,
LOG_CLASS_ITEM_ADD_QUEST,
LOG_CLASS_ITEM_DEL_QUEST,
LOG_CLASS_ITEM_DIE_DROP,
LOG_CLASS_ITEM_DIE_DESTROY,
LOG_CLASS_ITEM_COMPLETE_CRAFT,
LOG_CLASS_ITEM_CRAFT_SOURCE,
LOG_CLASS_ITEM_CRAFT_RESULT,
LOG_CLASS_ITEM_UNDO_CRAFT,
LOG_CLASS_ITEM_UNDO_BOOTH,
LOG_CLASS_ITEM_SELL_BOOTH,
LOG_CLASS_ITEM_BUY_BOOTH,
LOG_CLASS_ITEM_COMPLETE_UPGRADE,
LOG_CLASS_ITEM_UPGRADE_SOURCE,
LOG_CLASS_ITEM_UPGRADE_RESULT,
LOG_CLASS_ITEM_UNDO_UPGRADE,
LOG_CLASS_ITEM_CHEAT_LEVEL,
LOG_CLASS_ITEM_CHEAT_ITEM,
LOG_CLASS_ITEM_CHEAT_NAK,
LOG_CLASS_ITEM_CHEAT_SKILL,
LOG_CLASS_ITEM_CHEAT_QUEST,
LOG_CLASS_ITEM_GAMBLE,
LOG_CLASS_ITEM_USE,
};
enum
{
LOG_CLASS_POSTSYSTEM_RECEIVE_WEB = 0,
LOG_CLASS_POSTSYSTEM_SEND_CHA,
LOG_CLASS_POSTSYSTEM_RECEIVE_CHA,
LOG_CLASS_POSTSYSTEM_RECEIVE_ERROR,
};
enum{
LOG_CLASS_POSTSYSTEM_RECEIVE_ERROR_NOT_DELETE_POST=0,
LOG_CLASS_POSTSYSTEM_RECEIVE_ERROR_UNKNOWN_PACKAGE,
LOG_CLASS_POSTSYSTEM_RECEIVE_ERROR_NOT_INSERT_INVENTORY,
};
enum
{
LOG_CLASS_ITEM_MISSMATCH = 0,
};
enum
{
LOG_CLASS_ITEM_MISSMATCH_TYPE_SAVE = 0,
LOG_CLASS_ITEM_MISSMATCH_TYPE_TRADE,
LOG_CLASS_ITEM_MISSMATCH_TYPE_CRAFT,
LOG_CLASS_ITEM_MISSMATCH_TYPE_UPGRADE,
LOG_CLASS_ITEM_MISSMATCH_TYPE_BOOTH,
LOG_CLASS_ITEM_MISSMATCH_TYPE_AUTOQUESTCRAFT,
LOG_CLASS_ITEM_MISSMATCH_TYPE_BATTINGTRADE,
LOG_CLASS_ITEM_UNDO_BATTINGTRADE,
};
char* GetItemInformationLog( int isStack, int itemTableIdx, int itemIdx, int inventoryPos );
#endif
| C++ |
#if !defined(AFX_CGOLRYUNBATTLE_DECODER_H__5203D48E_E804_43E3_931B_92A46DA43E4C__INCLUDED_)
#define AFX_CGOLRYUNBATTLE_DECODER_H__5203D48E_E804_43E3_931B_92A46DA43E4C__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#include "CGolryunBattle_Encoder.h"
#include "CGolryunBattle_Process.h"
#include "CGolryunBattle_DBV2.h"
class CGolryunBattle_Decoder
{
private:
CGolryunBattle_Encoder* m_cpEncoder;
CGolryunBattle_Process* m_cpProcess;
CGolryunBattle_DBV2* m_cpDBV2;
BOOL m_bOK;
private:
inline void Decoder_ProgressCommand(const int in_Command);
inline void Decoder_ProgressCommand_GB_REQUEST_START_JOIN(void);
inline void Decoder_ProgressCommand_GB_START_RECALL_FIGHTER(void);
public:
BOOL isOK(void) const;
void RecvNoticeBattle();
void RecvBattleManorIdx();
void RecvBattleTournamentIdx(const int in_nTournamentLevelIdx);
void RecvWalkOverMatch();
void RecvObserveEnd(playerCharacter_t* pPlayer);
void RecvOpenBattleTicket(playerCharacter_t* pPlayer);
void RecvOpenShareWin(playerCharacter_t* pPlayer);
void RecvDisplayTournament(playerCharacter_t* pPlayer);
void RecvForceEject(playerCharacter_t* pPlayer);
void RecvCheckStatusPvPMode(playerCharacter_t* pPlayer);
void Decoder(void);
inline void Decoder_GB_INSERT_JOIN_LIST(playerCharacter_t* pPlayer);
inline void Decoder_GB_ASSIGN_FIGHTER_NUMBER(void);
public:
CGolryunBattle_Decoder(
CGolryunBattle_DBV2* cpDBV2,
CGolryunBattle_Encoder* cpEncoder,
CGolryunBattle_Process* cpProcess);
virtual ~CGolryunBattle_Decoder();
};
#endif
| C++ |
#if !defined(AFX_CSERVERLPACKCTRL_H__26EF6DC0_F144_451E_9BC4_060E53FB268A__INCLUDED_)
#define AFX_CSERVERLPACKCTRL_H__26EF6DC0_F144_451E_9BC4_060E53FB268A__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CServerLpackCtrl
{
private:
enum {
MaxLineNum=100,
MaxBytes_per_Line=100,
};
enum enumRet{
end_of_token=0,
end_of_file=1,
end_of_line=2,
};
BOOL m_bOK;
char m_LineBuffer[MaxLineNum][MaxBytes_per_Line+1];
static const char m_OverflowMessageLine[MaxBytes_per_Line+1];
private:
BOOL LoadFile(const char* szpFileName);
BOOL Init(void);
public:
BOOL isOK(void) const;
char* GetLpack(const unsigned int Idx);
public:
CServerLpackCtrl();
virtual ~CServerLpackCtrl();
};
#endif
| C++ |
#include "..\global.h"
#include "CLandList.h"
CRandList::CRandList()
{
Initialize();
}
CRandList::~CRandList()
{
m_numList.clear();
}
void CRandList::Initialize()
{
m_numList.clear();
}
void CRandList::PushData(int iData)
{
m_numList.push_back(iData);
}
BOOL CRandList::GetRandomData(int& iData)
{
if (m_numList.empty())
return FALSE;
int randomValue=rand()%m_numList.size();
int i=0;
NUMLIST_ITOR itor;
for (itor=m_numList.begin();itor!=m_numList.end();)
{
if (i==randomValue)
{
iData=(*itor);
m_numList.erase(itor++);
return TRUE;
}
else
{
itor++;
}
i++;
}
return FALSE;
}
| C++ |
#if !defined(AFX_GOLRYUNBATTLE_OBSERVER_H__BF86269C_7F76_4EC0_9986_C604C8DBDAE3__INCLUDED_)
#define AFX_GOLRYUNBATTLE_OBSERVER_H__BF86269C_7F76_4EC0_9986_C604C8DBDAE3__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CGolryunBattle_Observer
{
private:
BOOL m_bOK;
struct tagObserver{
int pcIdx;
char name[NAMESTRING+1];
char id[IDSTRING+1];
};
std::map<int,struct tagObserver> m_mapRecord;
public:
static vec3_t m_position;
private:
BOOL Init(void);
playerCharacter_t* GetPlayerPointer(const struct tagObserver& Observer);
public:
BOOL isOK(void) const;
BOOL Insert(const playerCharacter_t* pPlayer);
BOOL Delete(const playerCharacter_t* pPlayer);
void NET_SendUnreliableMessage(playerCharacter_t* pPlayer);
void NET_SendUnreliableMessage(monsterCharacter_t* pMonster);
public:
CGolryunBattle_Observer();
virtual ~CGolryunBattle_Observer();
};
#endif
| C++ |
#if !defined(AFX_CLANDLISTV2_H__452E36DD_3DC2_4755_971B_6D12EFCE3860__INCLUDED_)
#define AFX_CLANDLISTV2_H__452E36DD_3DC2_4755_971B_6D12EFCE3860__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CLandListV2
{
private:
BOOL m_bOK;
int* m_pArray;
int m_iMaxNum;
public:
BOOL isOK(void) const;
void Push(const int Data);
public:
CLandListV2();
virtual ~CLandListV2();
};
#endif
| C++ |
#include "..\global.h"
#include "CLandListV2.h"
#include <windowsx.h>
CLandListV2::CLandListV2(const int Max)
{
m_bOK=FALSE;
m_pArray = NULL;
m_iMaxNum=0;
m_pArray = (int*)GlobalAllocPtr(GMEM_FIXED,sizeof(int)*Max);
if(NULL == m_pArray) return;
m_bOK=TRUE;
}
CLandListV2::~CLandListV2()
{
if(NULL != m_pArray){ GlobalFreePtr(m_pArray); m_pArray=NULL; }
}
void CLandListV2::Push(const int Data)
{
m_pArray[m_iMaxNum++]=Data;
}
int CLandListV2::Get(void)
{
int idx = rand() % m_iMaxNum ;
int data=0;
while(TRUE){
if(-1 != m_pArray[idx]){
data = m_pArray[idx];
m_pArray[idx]=-1;
return data;
}
idx++;
if(idx >= m_iMaxNum) idx=0;
}
}
| C++ |
#ifndef _CLANDLIST_H_
#define _CLANDLIST_H_
class CRandList
{
public:
typedef std::list<int> NUMLIST;
typedef NUMLIST::iterator NUMLIST_ITOR;
NUMLIST m_numList;
public:
CRandList();
virtual ~CRandList();
void Initialize();
void PushData(int iData);
BOOL GetRandomData(int &iData);
};
#endif
| C++ |
#include "..\global.h"
#include "CGolryunBattle_Common.h"
#include "..\TableStruct\TableStruct.h"
#include "..\GolryunBattle\tagGolryunBattle.h"
#include "..\GolryunBattle\CGolryunBattle.h"
extern CGolryunBattle* gcpGolryunBattle;
#include "..\Tools\CTools.h"
extern CTools* gcpTools;
CGolryunBattle_Common::CGolryunBattle_Common()
{
m_bOK=FALSE;
m_bOK=TRUE;
}
CGolryunBattle_Common::~CGolryunBattle_Common()
{
}
BOOL CGolryunBattle_Common::isOK(void) const
{
return m_bOK;
}
itemTable_t* CGolryunBattle_Common::GetItemTablePointer(const int Idx)
{
if(Idx < 0) return NULL;
if(Idx >= MAX_NUMBER_OF_ITEM_TABLE) return NULL;
return &g_itemTable[Idx];
}
playerCharacter_t* CGolryunBattle_Common::
GetPlayer(const CGolryunBattle_Data::tagFighter& Fighter)
{
playerCharacter_t* pTempPlayer= gcpTools->GetPlayerRecordPointer(Fighter.pcIdx);
if(NULL == pTempPlayer) return NULL;
if(0 != strcmp(Fighter.id,pTempPlayer->userID)) return NULL;
if(0 != strcmp(Fighter.name,pTempPlayer->name)) return NULL;
return pTempPlayer;
}
playerCharacter_t* CGolryunBattle_Common::
GetArenaPlayer(const CGolryunBattle_Data::tagFighter& Fighter)
{
playerCharacter_t* pTempPlayer= gcpTools->GetPlayerRecordPointer(Fighter.pcIdx);
if(NULL == pTempPlayer) return NULL;
if(tagGolryunBattle::Golryun_Battle_Map_Index != pTempPlayer->worldIdx) return NULL;
if(0 != strcmp(Fighter.id,pTempPlayer->userID)) return NULL;
if(0 != strcmp(Fighter.name,pTempPlayer->name)) return NULL;
return pTempPlayer;
}
playerCharacter_t* CGolryunBattle_Common::GetArenaPlayer(const int Idx)
{
playerCharacter_t* pTempPlayer= gcpTools->GetPlayerRecordPointer(Idx);
if(NULL == pTempPlayer) return NULL;
if(tagGolryunBattle::Golryun_Battle_Map_Index != pTempPlayer->worldIdx) return NULL;
return pTempPlayer;
}
void CGolryunBattle_Common::Change_Inventory_Nak(const __int64 i64ParamNak,playerCharacter_t* pPc)
{
__int64 Nak = (__int64)pPc->curChargeSE + i64ParamNak;
if(Nak <= 0) Nak=0;
if(Nak > MAX_OWN_NAK) Nak=MAX_OWN_NAK;
pPc->curChargeSE = (int)Nak;
}
int AI_NPC_ShareMoney( void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
AI_NPC_CloseMessage( pc, pParam );
pc->GonryunBattle.ShareWin.i64TotalNak=0;
pc->GonryunBattle.ShareWin.iFortuneStone=0;
for(int idx = 0; idx < playerCharacter_t::tagGonryunBattle::tagShareWin::MAX_INVENTORY_NUMBER; idx ++ )
{
pc->GonryunBattle.ShareWin.Inventory[idx] = -1;
}
GTH_AddNoticePC( pc, -1, -1, BUSY_STATE_NPC_INVENTORY );
(gcpGolryunBattle->GetEncoderClassPointer())->SendOpenShareWin(&pc->sock);
return 1;
}
void GTH_SendMessage_ItemSystem_ExchangeClose( playerCharacter_t *pc )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, EXCHANGE_CLOSE);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ItemSystem_ExchangeItem( playerCharacter_t *pc, int reply, int error, int pos, int nak )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, EXCHANGE_ITEM);
if( reply > 0 )
{
MSG_WriteByte(&netMessage, reply);
MSG_WriteByte(&netMessage, pos);
MSG_WriteShort( &netMessage, pc->mouseInventory );
MSG_WriteShort( &netMessage, pc->GonryunBattle.ShareWin.Inventory[pos] );
MSG_WriteLong( &netMessage, nak );
}
else
{
MSG_WriteByte(&netMessage, reply);
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ItemSystem_ExchangePrepare( playerCharacter_t *pc, int reply, int error, int nak, float pro )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, EXCHANGE_PREPARE);
MSG_WriteByte(&netMessage, reply);
if( reply )
{
MSG_WriteLong( &netMessage, nak );
MSG_WriteFloat( &netMessage, pro );
}
else
{
MSG_WriteByte( &netMessage, error );
MSG_WriteLong( &netMessage, nak );
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_ExchangeProcess_Goldbar( playerCharacter_t *pPlayer)
{
__int64 i64GoldNum = pPlayer->GonryunBattle.ShareWin.i64TotalNak / (__int64)playerCharacter_t::tagGonryunBattle::NAK_per_ONEGOLD;
__int64 i64RemainNak = pPlayer->GonryunBattle.ShareWin.i64TotalNak - (i64GoldNum * (__int64)playerCharacter_t::tagGonryunBattle::NAK_per_ONEGOLD);
g_logSystem->WriteToLog(
pPlayer,
LOG_CLASS_GOLRYUN,
"%d;%d;%d;;;;",
CLogSystem::enumGolryunSubLog::ShareBattleTicket,
pPlayer->GonryunBattle.ShareWin.i64TotalNak,
(int)i64GoldNum);
CGolryunBattle_Common::Change_Inventory_Nak(i64RemainNak,pPlayer);
pPlayer->GonryunBattle.ShareWin.i64TotalNak=0;
if(i64GoldNum == 0) return;
int addItemData[6];
addItemData[0] = tagGolryunBattle::GoldBar_Item_Index;
addItemData[1] = -1;
addItemData[2] = (int)i64GoldNum;
addItemData[3] = 1;
addItemData[4] = -1;
addItemData[5] = -1;
AI_NPC_AddItem( pPlayer, addItemData );
}
void GTH_ExchangeProcess_FortuneStone( playerCharacter_t *pPlayer)
{
int stoneNum = pPlayer->GonryunBattle.ShareWin.iFortuneStone;
g_logSystem->WriteToLog(
pPlayer,
LOG_CLASS_GOLRYUN,
"%d;%d;;;;;",
CLogSystem::enumGolryunSubLog::ShareBattleTicket,
stoneNum);
pPlayer->GonryunBattle.ShareWin.iFortuneStone=0;
if(stoneNum == 0) return;
int addItemData[6];
addItemData[0] = tagGolryunBattle::Fortune_Stone_Item_Index;
addItemData[1] = -1;
addItemData[2] = stoneNum;
addItemData[3] = 1;
addItemData[4] = -1;
addItemData[5] = -1;
AI_NPC_AddItem( pPlayer, addItemData );
}
void GTH_ExchangeProcess( playerCharacter_t *pc, int &reply, int &error, int &reqNak )
{
int i, itemIdx;
if( pc->curItemWeight >= pc->calItemWeight )
{
reply = 0;
error = ERROR_ITEMSYSTEM_3;
return;
}
for( i = 0; i < playerCharacter_t::tagGonryunBattle::tagShareWin::MAX_INVENTORY_NUMBER; i ++ )
{
if( pc->GonryunBattle.ShareWin.Inventory[i] < 0 ) continue;
itemIdx = pc->GonryunBattle.ShareWin.Inventory[i];
GTH_DeleteMyItem( pc, &pc->item[itemIdx] );
pc->GonryunBattle.ShareWin.Inventory[i] = -1;
g_DBGameServer->RemoveItem( pc, itemIdx );
}
GTH_ExchangeProcess_Goldbar( pc );
GTH_ExchangeProcess_FortuneStone( pc );
}
int GetTournamentIdxFromTwoGyun(int level)
{
int iTournamentIdx=0;
switch(level)
{
case 30:
iTournamentIdx = 0;
break;
case 40:
iTournamentIdx = 1;
break;
case 50:
iTournamentIdx = 2;
break;
case 60:
iTournamentIdx = 3;
break;
case 70:
iTournamentIdx = 4;
break;
case 80:
iTournamentIdx = 5;
break;
case 90:
iTournamentIdx = 6;
break;
}
return iTournamentIdx;
}
__int64 GetTowGyunPrice(const item_t& item)
{
if((item.itemTableIdx != tagGolryunBattle::TwoGyun_100000_Item_Index) &&
(item.itemTableIdx != tagGolryunBattle::TwoGyun_1000000_Item_Index)) return 0;
itemTable_t* pItemTableRecord=CGolryunBattle_Common::GetItemTablePointer(item.itemTableIdx);
if(NULL == pItemTableRecord) return 0;
int iBattleGUID = item.optionIdx[0];
int iTournamentGUID = item.experience;
int level = item.optionIdx[1];
int winNum = item.optionIdx[2];
int iTournamentLevelIdx = GetTournamentIdxFromTwoGyun(level);
CGolryunBattle_Data* cpData = gcpGolryunBattle->GetDataClassPointer();
CGolryunBattle_Encoder* cpEncoder = gcpGolryunBattle->GetEncoderClassPointer();
CGolryunBattle_Process* cpProcess = gcpGolryunBattle->GetProcessClassPointer();
if(cpData->m_iBattleGUID == iBattleGUID){
if(cpProcess->m_iTournamentGUID == iTournamentGUID){
if(cpProcess->GetTournamentStatus() == CGolryunBattle_Process::eTournamentStep::TournamentStep_None){
return pItemTableRecord->sellCost;
}
return 0;
}
struct CGolryunBattle_Data::tagTournament* pTournament=&(cpData->m_Tournament[iTournamentLevelIdx]);
if(pTournament->iTournamentGUID != iTournamentGUID)
{
return pItemTableRecord->sellCost;
}
if(FALSE == pTournament->bComplete)
{
return pItemTableRecord->sellCost;
}
if(0 >= pTournament->FirstWinner.FightNum)
{
return pItemTableRecord->sellCost;
}
if(winNum == pTournament->FirstWinner.FightNum)
{
float rate = pTournament->TwoGyun.fShareRate;
return pItemTableRecord->sellCost * rate;
}
return 0;
}
if(cpData->m_iBattleGUID != iBattleGUID){
CGolryunBattle_DBV2* cpDBV2=gcpGolryunBattle->GetDBV2ClassPointer();
const struct CGolryunBattle_DBV2::tagBattle* pBattleRecord=
cpDBV2->GetBattleRecordPointer(iBattleGUID);
if(NULL == pBattleRecord){
if(cpProcess->m_iTournamentGUIDminmum > iTournamentGUID) return 0;
return pItemTableRecord->sellCost;
}
const struct CGolryunBattle_DBV2::tagTournament* pTournament=&(pBattleRecord->Tournament[iTournamentLevelIdx]);
if(pTournament->nGUID != iTournamentGUID)
{
return pItemTableRecord->sellCost;
}
if(FALSE == pTournament->bComplete)
{
return pItemTableRecord->sellCost;
}
if(0 >= pTournament->firstWinner.Num)
{
return pItemTableRecord->sellCost;
}
if(winNum == pTournament->firstWinner.Num)
{
float rate = pTournament->TwoGyun.Rate;
return pItemTableRecord->sellCost * rate;
}
return 0;
}
return 0;
}
int GetFortuneStone(const item_t& item)
{
if((item.itemTableIdx != tagGolryunBattle::TwoGyun_100000_Item_Index) &&
(item.itemTableIdx != tagGolryunBattle::TwoGyun_1000000_Item_Index)) return 0;
itemTable_t* pItemTableRecord=CGolryunBattle_Common::GetItemTablePointer(item.itemTableIdx);
if(NULL == pItemTableRecord) return 0;
int iBattleGUID = item.optionIdx[0];
int iTournamentGUID = item.experience;
int level = item.optionIdx[1];
int winNum = item.optionIdx[2];
int iTournamentLevelIdx = GetTournamentIdxFromTwoGyun(level);
CGolryunBattle_Data* cpData = gcpGolryunBattle->GetDataClassPointer();
CGolryunBattle_Encoder* cpEncoder = gcpGolryunBattle->GetEncoderClassPointer();
CGolryunBattle_Process* cpProcess = gcpGolryunBattle->GetProcessClassPointer();
int stoneNum=0;
if(cpData->m_iBattleGUID == iBattleGUID){
if(cpProcess->m_iTournamentGUID == iTournamentGUID){
if(cpProcess->GetTournamentStatus() == CGolryunBattle_Process::eTournamentStep::TournamentStep_None){
return 0;
}
return 0;
}
struct CGolryunBattle_Data::tagTournament* pTournament=&(cpData->m_Tournament[iTournamentLevelIdx]);
if(pTournament->iTournamentGUID != iTournamentGUID)
{
return 0;
}
if(FALSE == pTournament->bComplete)
{
return 0;
}
if(0 >= pTournament->FirstWinner.FightNum)
{
return 0;
}
if(winNum != pTournament->FirstWinner.FightNum)
{
stoneNum = pItemTableRecord->sellCost/100000;
return stoneNum;
}
return 0;
}
if(cpData->m_iBattleGUID != iBattleGUID){
CGolryunBattle_DBV2* cpDBV2=gcpGolryunBattle->GetDBV2ClassPointer();
const struct CGolryunBattle_DBV2::tagBattle* pBattleRecord=cpDBV2->GetBattleRecordPointer(iBattleGUID);
if(NULL == pBattleRecord){
if(cpProcess->m_iTournamentGUIDminmum > iTournamentGUID) return 0;
return 0;
}
const struct CGolryunBattle_DBV2::tagTournament*
pTournament=&(pBattleRecord->Tournament[iTournamentLevelIdx]);
if(pTournament->nGUID != iTournamentGUID)
{
return 0;
}
if(FALSE == pTournament->bComplete)
{
return 0;
}
if(0 >= pTournament->firstWinner.Num)
{
return 0;
}
if(winNum != pTournament->firstWinner.Num)
{
stoneNum = pItemTableRecord->sellCost/100000;
return stoneNum;
}
return 0;
}
return 0;
}
BOOL CheckTowGyunStatus(const item_t& item)
{
int iBattleGUID = item.optionIdx[0];
int iTournamentGUID = item.experience;
int level = item.optionIdx[1];
int winNum = item.optionIdx[2];
int iTournamentLevelIdx = GetTournamentIdxFromTwoGyun(level);
CGolryunBattle_Data* cpData = gcpGolryunBattle->GetDataClassPointer();
CGolryunBattle_Encoder* cpEncoder = gcpGolryunBattle->GetEncoderClassPointer();
CGolryunBattle_Process* cpProcess = gcpGolryunBattle->GetProcessClassPointer();
if(cpData->m_iBattleGUID == iBattleGUID){
if(cpProcess->m_iTournamentGUID == iTournamentGUID){
if(cpProcess->GetTournamentStatus() == CGolryunBattle_Process::eTournamentStep::TournamentStep_None){
cpEncoder->SendStatusMatchNotice(&g_curPC->sock,
tagGolryunBattlePacket_GB_STATUS_NOTICE::enumCode::cancel_tournament);
return TRUE;
}
cpEncoder->SendErrorCode(&g_curPC->sock, 0, tagGolryunBattlePacket_GB_ERROR_CODE::not_exchange_twogyun);
return FALSE;
}
struct CGolryunBattle_Data::tagTournament* pTournament=&(cpData->m_Tournament[iTournamentLevelIdx]);
if(pTournament->iTournamentGUID != iTournamentGUID)
{
cpEncoder->SendStatusMatchNotice(&g_curPC->sock,
tagGolryunBattlePacket_GB_STATUS_NOTICE::enumCode::cancel_tournament);
return TRUE;
}
if(FALSE == pTournament->bComplete)
{
cpEncoder->SendStatusMatchNotice(&g_curPC->sock,
tagGolryunBattlePacket_GB_STATUS_NOTICE::enumCode::cancel_tournament);
return TRUE;
}
if(0 >= pTournament->FirstWinner.FightNum){
cpEncoder->SendStatusMatchNotice(&g_curPC->sock,
tagGolryunBattlePacket_GB_STATUS_NOTICE::enumCode::draw_tournament);
return TRUE;
}
return TRUE;
}
if(cpData->m_iBattleGUID != iBattleGUID){
CGolryunBattle_DBV2* cpDBV2=gcpGolryunBattle->GetDBV2ClassPointer();
const struct CGolryunBattle_DBV2::tagBattle* pBattleRecord=cpDBV2->GetBattleRecordPointer(iBattleGUID);
if(NULL == pBattleRecord) return TRUE;
const struct CGolryunBattle_DBV2::tagTournament* pTournament=&(pBattleRecord->Tournament[iTournamentLevelIdx]);
if(FALSE == pTournament->bComplete)
{
cpEncoder->SendStatusMatchNotice(&g_curPC->sock,
tagGolryunBattlePacket_GB_STATUS_NOTICE::enumCode::cancel_tournament);
return TRUE;
}
if(pTournament->nGUID != iTournamentGUID)
{
cpEncoder->SendStatusMatchNotice(&g_curPC->sock,
tagGolryunBattlePacket_GB_STATUS_NOTICE::enumCode::cancel_tournament);
return TRUE;
}
if(0 >= pTournament->firstWinner.Num){
cpEncoder->SendStatusMatchNotice(&g_curPC->sock,
tagGolryunBattlePacket_GB_STATUS_NOTICE::enumCode::draw_tournament);
return TRUE;
}
return TRUE;
}
return FALSE;
}
void GTH_ProcessMessage_ItemSystem_ExchangeItem()
{
if ( FALSE == isValidPCBusy(g_curPC, BUSY_STATE_NPC_INVENTORY))
return;
int battleType = MSG_ReadShort();
int levelType = MSG_ReadShort();
int pos = MSG_ReadShort();
int tempInven;
int reply = 1, error = 0;
if( g_curPC->mouseInventory >= 0 )
{
if( g_curPC->GonryunBattle.ShareWin.Inventory[pos] >= 0 )
{
int itemIdx = g_curPC->mouseInventory;
int itemTableIdx = g_curPC->item[itemIdx].itemTableIdx;
if((itemTableIdx == tagGolryunBattle::TwoGyun_100000_Item_Index) ||
(itemTableIdx == tagGolryunBattle::TwoGyun_1000000_Item_Index))
{
tempInven = g_curPC->mouseInventory;
g_curPC->GonryunBattle.ShareWin.i64TotalNak += GetTowGyunPrice(g_curPC->item[tempInven]);
g_curPC->GonryunBattle.ShareWin.iFortuneStone += GetFortuneStone(g_curPC->item[tempInven]);
int InventoryItemIdx = g_curPC->GonryunBattle.ShareWin.Inventory[pos];
g_curPC->GonryunBattle.ShareWin.i64TotalNak -= GetTowGyunPrice(g_curPC->item[InventoryItemIdx]);
g_curPC->GonryunBattle.ShareWin.iFortuneStone -= GetFortuneStone(g_curPC->item[InventoryItemIdx]);
g_curPC->mouseInventory = g_curPC->GonryunBattle.ShareWin.Inventory[pos];
g_curPC->GonryunBattle.ShareWin.Inventory[pos] = tempInven;
}
else
{
(gcpGolryunBattle->GetEncoderClassPointer())->SendErrorCode(&g_curPC->sock, 0, tagGolryunBattlePacket_GB_ERROR_CODE::unknown_item);
reply = 0;
}
}
else
{
g_curPC->GonryunBattle.ShareWin.Inventory[pos] = g_curPC->mouseInventory;
int itemIdx = g_curPC->GonryunBattle.ShareWin.Inventory[pos];
int itemTableIdx = g_curPC->item[itemIdx].itemTableIdx;
if((itemTableIdx == tagGolryunBattle::TwoGyun_100000_Item_Index) ||
(itemTableIdx == tagGolryunBattle::TwoGyun_1000000_Item_Index))
{
if(TRUE == CheckTowGyunStatus(g_curPC->item[itemIdx]))
{
g_curPC->GonryunBattle.ShareWin.i64TotalNak += GetTowGyunPrice(g_curPC->item[itemIdx]);
g_curPC->GonryunBattle.ShareWin.iFortuneStone += GetFortuneStone(g_curPC->item[itemIdx]);
g_curPC->mouseInventory = -1;
reply = 1;
}
else
{
g_curPC->GonryunBattle.ShareWin.Inventory[pos] = -1;
reply = 0;
}
}
else
{
g_curPC->GonryunBattle.ShareWin.Inventory[pos] = -1;
(gcpGolryunBattle->GetEncoderClassPointer())->SendErrorCode(&g_curPC->sock, 0, tagGolryunBattlePacket_GB_ERROR_CODE::unknown_item);
reply = 0;
}
}
}
else
{
int itemIdx = g_curPC->GonryunBattle.ShareWin.Inventory[pos];
int itemTableIdx = g_curPC->item[itemIdx].itemTableIdx;
if( (itemTableIdx == tagGolryunBattle::TwoGyun_100000_Item_Index) ||
(itemTableIdx == tagGolryunBattle::TwoGyun_1000000_Item_Index))
{
g_curPC->GonryunBattle.ShareWin.i64TotalNak -= GetTowGyunPrice(g_curPC->item[itemIdx]);
g_curPC->GonryunBattle.ShareWin.iFortuneStone -= GetFortuneStone(g_curPC->item[itemIdx]);
g_curPC->mouseInventory = g_curPC->GonryunBattle.ShareWin.Inventory[pos];
g_curPC->GonryunBattle.ShareWin.Inventory[pos] = -1;
}
else
reply = 0;
}
GTH_SendMessage_ItemSystem_ExchangeItem( g_curPC, reply, error, pos, g_curPC->GonryunBattle.ShareWin.i64TotalNak );
}
int GTH_UndoPCExchange( playerCharacter_t *pc, int completeFlag )
{
int itemIdx, inventoryPos;
item_t *item, *upItem;
int bIsStack = false, stackNumber = 1;
for( int i = 0; i < playerCharacter_t::tagGonryunBattle::tagShareWin::MAX_INVENTORY_NUMBER; i ++ )
{
itemIdx = pc->GonryunBattle.ShareWin.Inventory[i];
if( itemIdx < 0 ) continue;
item = &pc->item[itemIdx];
bIsStack = false;
stackNumber = 1;
if( g_itemTable[item->itemTableIdx].stackFlag )
{
bIsStack = true;
stackNumber = item->durability + 1;
}
int stackItemIdx = GTH_StackMyItem( pc, item );
if( stackItemIdx >= 0 )
{
upItem = &pc->item[stackItemIdx];
upItem->durability += item->durability + 1;
if( upItem->durability + 1 >= MAX_COUNT_STACK_ITEM ) upItem->durability = MAX_COUNT_STACK_ITEM - 1;
g_logSystem->WriteToLog( pc, LOG_CLASS_ITEM, "%d;%d;%d;;;%s;%s",
LOG_CLASS_ITEM_UNDO_CRAFT, 0, stackNumber, upItem->name,
GetItemInformationLog( bIsStack, upItem->itemTableIdx, stackItemIdx, -1 ));
GTH_DeleteMyItem( pc, item );
g_DBGameServer->SaveItem( pc, upItem, stackItemIdx );
g_DBGameServer->RemoveItem( pc, itemIdx );
}
else
{
inventoryPos = GTH_FindEmptyInventoryPos( pc );
if( inventoryPos >= 0 )
{
pc->inventory[inventoryPos] = itemIdx;
}
g_logSystem->WriteToLog( pc, LOG_CLASS_ITEM, "%d;%d;%d;;;%s;%s",
LOG_CLASS_ITEM_UNDO_CRAFT, 0, stackNumber, item->name,
GetItemInformationLog( bIsStack, item->itemTableIdx, itemIdx, inventoryPos ));
}
}
if( !completeFlag ) g_logSystem->Write("Make Item Cancel : %s(%s)", pc->name, pc->userID );
else g_logSystem->Write("Make Item Complete : %s(%s)", pc->name, pc->userID );
for( i = 0; i < playerCharacter_t::tagGonryunBattle::tagShareWin::MAX_INVENTORY_NUMBER; i ++ )
{
pc->GonryunBattle.ShareWin.Inventory[i] = -1;
}
return 1;
}
void GTH_ProcessMessage_ItemSystem_ExchangeClose()
{
if ( FALSE == isValidPCBusy(g_curPC, BUSY_STATE_NPC_INVENTORY))
return;
GTH_UndoPCExchange( g_curPC );
GTH_DeleteNoticePC( g_curPC );
GTH_SendMessage_ItemSystem_ExchangeClose( g_curPC );
}
void GTH_ProcessMessage_ItemSystem_ExchangePrepare()
{
if ( FALSE == isValidPCBusy(g_curPC, BUSY_STATE_NPC_INVENTORY))
return;
int reply = 1, error = 0;
int nak = 0;
float pro = 0.0f;
GTH_ExchangeProcess( g_curPC, reply, error, nak );
GTH_SendMessage_ItemSystem_ExchangePrepare( g_curPC, reply, error, nak, pro );
GTH_DeleteNoticePC(g_curPC);
}
| C++ |
#if !defined(AFX_CGOLRYUNBATTLE_PROCESS_H__E16ED788_4286_4757_884F_BDAE691AC9D3__INCLUDED_)
#define AFX_CGOLRYUNBATTLE_PROCESS_H__E16ED788_4286_4757_884F_BDAE691AC9D3__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#include "CGolryunBattle_Encoder.h"
#include "CGolryunBattle_Data.h"
#include "CGolryunBattle_DBV2.h"
#include <map>
class CGolryunBattle_Process
{
public:
enum enumManor{
normal=0,
week=1,
month=2,
ramification=3,
year=4,
};
enum eRound
{
Round16 = 16,
Round8 = 8,
Round4 = 4,
Round2 = 2,
};
enum eMatchIndexRound
{
Offset_MatchIdx_Round16 = 0,
Offset_MatchIdx_Round8 = 8,
Offset_MatchIdx_Round4 = 12,
Offset_MatchIdx_RoundFinal = 14,
End_MatchIdx_Round16 = 7,
End_MatchIdx_Round8 = 11,
End_MatchIdx_Round4 = 13,
End_MatchIdx_RoundFinal = 14,
};
enum eMatchResult
{
RESULT_NORMAL_MATCH = 0,
RESULT_TIMEOVER_MATCH,
RESULT_DRAWN_MATCH,
RESULT_OFFLINE_MATCH,
RESULT_DEFAULT_MATCH,
RESULT_ERROR_MATCH,
};
enum eReward
{
REWARD_WINNER = 0,
REWARD_LOSER,
REWARD_WAITER,
};
enum eTournamentStep{
TournamentStep_None=0,
TournamentStep_Match_Pause,
TournamentStep_END_MATCH,
TournamentStep_PROGRESS_MATCH,
TournamentStep_START_COUNT,
TournamentStep_START_BETTING,
TournamentStep_START_JOIN,
TournamentStep_CLOSE_JOIN,
TournamentStep_READY_TOURNAMENT,
TournamentStep_CANCEL_TOURNAMENT,
TournamentStep_INIT_BATTLE,
TournamentStep_START_BATTLE,
TournamentStep_CLOSE_BATTLE,
TournamentStep_START_PRIZE,
};
struct tagBattleTimer{
public:
enum{
timeSyncPacket_Transmite_Time = 1* 1000,
match_start_count_time = 10*1000,
end_check_time=5 * 60 * 1000,
};
public:
int start_time;
int old_timeSync_transmite_Time;
};
struct tagFightPlayerInfo{
public:
struct tagRecord{
int win;
int lose;
int draw;
};
public:
int Idx;
int Job;
char Name[NAMESTRING+1];
char ID[IDSTRING+1];
struct tagRecord Record;
};
struct tagTicket{
private:
struct tagTicketFighter{
int iTotalNak;
float fShareRate;
};
public:
int iTotalNak;
int iFighterNum;
struct tagTicketFighter Fighter[tagGolryunBattle::Max_Num_Fighter_Per_Tournament];
};
private:
struct tagCheckNormalMatchParam{
public:
struct tagMatchFighterInfo{
struct CGolryunBattle_Data::tagFighter* pFighter;
playerCharacter_t* pPlayer;
};
public:
struct CGolryunBattle_Data::tagMatch* pMatch;
struct tagMatchFighterInfo Red;
struct tagMatchFighterInfo Blue;
struct tagMatchFighterInfo Winner;
struct tagMatchFighterInfo Loser;
enum CGolryunBattle_Data::tagMatch::enumCorner WinnerCorner;
};
private:
BOOL m_bOK;
CGolryunBattle_Data* m_cpData;
CGolryunBattle_Encoder* m_cpEncoder;
CGolryunBattle_DBV2* m_cpDBV2;
eMatchResult m_eResultStatus;
enum eTournamentStep m_eTournamentStep;
enumManor m_eManor;
DWORD m_iStartTime;
struct tagBattleTimer m_BattleTimer;
int m_iNextRound_MatchIdx;
int m_iMatchIdx;
int m_iOffSetMatchIdx;
typedef std::list<CGolryunBattle_Data::tagFighter> ALL_JOINER_LIST;
typedef ALL_JOINER_LIST::iterator ALL_JOINER_ITOR;
ALL_JOINER_LIST m_AllJoinList;
typedef std::map<int,struct CGolryunBattle_Data::tagFighter> JOINER_MAP;
typedef JOINER_MAP::iterator JOINTER_MAP_ITOR;
JOINER_MAP m_JoinMap;
struct CGolryunBattle_Data::tagMatch m_Match[tagGolryunBattle::Max_Num_Match_Per_Tournament];
struct CGolryunBattle_Data::tagFighter m_FirstWinner;
struct CGolryunBattle_Data::tagFighter m_SecondWinner;
public:
struct tagFightPlayerInfo m_Fighter[tagGolryunBattle::Max_Num_Fighter_Per_Tournament];
struct tagTicket m_Ticket;
int m_iTournamentGUID;
int m_iTournamentGUIDminmum;
int m_iTournamentIdx;
BOOL m_bPause;
private:
void SetResultStatus(eMatchResult eResultStatus);
void InitFighterArray(void);
inline void SetCheckNormalMatchParam(struct tagCheckNormalMatchParam& Var);
inline void InitCheckNormalMatchParam(struct tagCheckNormalMatchParam& Var);
void SettingManorColor(playerCharacter_t* pc);
public:
BOOL isOK(void) const;
void SetTournamentStatus(const enum eTournamentStep eTournamentStep);
enum eTournamentStep GetTournamentStatus(void);
void SetManorStatus(enumManor eManor);
BOOL isReady(void);
struct CGolryunBattle_Data::tagMatch* GetCurMatch(void);
void SetProgressMatchStatus(BOOL bPause){ m_bPause = bPause; };
BOOL GetProgressMatchStatus(void){ return m_bPause; };
void InitMatchArray(void);
BOOL InitTournament();
BOOL InitBattle(void);
BOOL isJoinPlayer(const playerCharacter_t *pc);
BOOL isFighterPlayer_and_LogOffMark(const playerCharacter_t *pc);
void CheckJoinerNumGM(void);
void TransWaitingRoomGM(playerCharacter_t* pc);
void TransWatchingRoomGM(playerCharacter_t* pc);
void TransBattleStadiumGM(playerCharacter_t* pc);
BOOL RemoveFighterArrayV2(playerCharacter_t* pc);
struct tagFightPlayerInfo* GetFighterPointer(const int fighterIdx);
struct CGolryunBattle_Data::tagMatch* GetMatchPointer(const int matchIdx);
void UpdateAutoStatus();
public:
void UpdateHandleStatus(void);
inline void UpdateHandleStatus_TournamentStep_PROGRESS_MATCH(void);
void Enter_By_Tournament(playerCharacter_t* pPlayer);
BOOL MoveToWaitingRoom(playerCharacter_t* pPlayer);
void ExtractJoinNumber(void);
void ExtractMatchNumber(void);
void ExtractPrizeNumber();
void MoveToWatchingRoom(playerCharacter_t* pc);
void MoveToWatchingRoomAll_NotBattlePlayer(void);
void MoveToWatchingRoomAll_CancelBattlePlayer(void);
int BuyEntranceTicket();
int BuyBattleTicket();
void ReNewBattleTicket();
inline BOOL inner_MoveToWatchingRoom(playerCharacter_t* pc);
public:
void CheckGameStartMatch();
void FindOutFighterNumber();
void MoveToStartMatch();
void MoveToRedCorner(playerCharacter_t* pc);
void MoveToBlueCorner(playerCharacter_t* pc);
public:
void MoveToEndMatch(void);
void MoveToEndMatch_Result(void);
inline void MoveToEndMatch_NextMatchProgress(void);
inline void MoveToEndMatch_NextMatchProgress_RoundEnd(void);
void CheckFighterWaitingRoomAndJoinNumber(void);
public:
void CheckMatchResult(const int WinnerFightNum=-100);
inline void CheckMatchResult_Effect(struct tagCheckNormalMatchParam& Var);
inline void CheckMatchResult_SetWinnerAndLoser(struct tagCheckNormalMatchParam& Var);
inline void CheckMatchResult_when_BothLive(struct tagCheckNormalMatchParam& Var);
public:
void CheckQuitUser(playerCharacter_t *pc);
inline BOOL CheckQuitUser_Waiter(playerCharacter_t *pc);
BOOL CheckExpelUser(playerCharacter_t *pc);
public:
void RewardBattleResult(playerCharacter_t *pc, int type);
void RewardForLoser(playerCharacter_t *pc);
void RewardForWinner(playerCharacter_t *pc);
void RewardForWaiter(playerCharacter_t *pc);
public:
playerCharacter_t* GetFighterPlayerPointer(const struct tagFightPlayerInfo* pFighter);
playerCharacter_t* GetFighterPlayerPointer(const struct CGolryunBattle_Data::tagFighter* pFighter);
BOOL InsertJoinMap(playerCharacter_t* pPlayer);
struct tagFightPlayerInfo* GetMatchFighter(playerCharacter_t* pPlayer);
BOOL AssignFightNum(const char* szpJoinerName,const int FighterNum);
struct CGolryunBattle_Data::tagMatch* GetMatch(const int FightNum);
BOOL ForceEjectToFighter(playerCharacter_t* pPlayer);
private:
inline void Copy_toDATA_fromDB(const struct CGolryunBattle_DBV2::tagBattle* pBattle);
inline void Copy_toDB_fromDATA(struct CGolryunBattle_DBV2::tagBattle& Battle);
public:
void SaveBattleRecoder(void);
public:
CGolryunBattle_Process(
CGolryunBattle_DBV2* cpDBV2,
CGolryunBattle_Data* cpData,
CGolryunBattle_Encoder* cpEncoder);
virtual ~CGolryunBattle_Process();
};
#endif
| C++ |
#if !defined(AFX_CGOLRYUNBATTLE_ENCODER_H__2778E092_FB08_4928_ABC2_FE2CE3FA9F02__INCLUDED_)
#define AFX_CGOLRYUNBATTLE_ENCODER_H__2778E092_FB08_4928_ABC2_FE2CE3FA9F02__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#include "CGolryunBattle_Data.h"
class CGolryunBattle_Process;
class CGolryunBattle_Encoder
{
private:
BOOL m_bOK;
CGolryunBattle_Data* m_cpData;
CGolryunBattle_Process* m_cpProcess;
public:
BOOL isOK(void) const;
void SetProcessClassPointer(CGolryunBattle_Process* cpProcess);
void SendTrasportGolryun(i3socket_t* sock);
void SendTrasportArayan(i3socket_t* sock);
void SendSuggestBattle(i3socket_t* sock, BYTE eType);
void SendOpenBattleTicket(i3socket_t* sock, BYTE eType);
void SendOpenShareWin(i3socket_t* sock);
void SendDisplayTournament(i3socket_t* sock);
void SendCheckPrize(i3socket_t* sock);
void SendObserveStart(playerCharacter_t* pToPlayer,const BOOL bSuccess);
void SendObserveEnd(playerCharacter_t* pToPlayer,const BOOL bSuccess);
void SendObserveMatchTime(playerCharacter_t* pToPlayer,const int time);
void SendErrorCode(
i3socket_t* sock,
const BYTE eCode,
enum tagGolryunBattlePacket_GB_ERROR_CODE::enumCode eType) const;
void SendEffectCount(i3socket_t* sock, int angle);
void SendEffectResult(i3socket_t* sock, int index);
void SendStartMatch(i3socket_t* sock, const int time);
void SendEndMatch(i3socket_t* sock,enum tagGolryunBattlePacket_GB_REQUEST_END_MATCH::enumCode code);
void SendCancelTournament(i3socket_t* sock);
void SendShareRate(playerCharacter_t* pPlayer);
void SendReNewShareRate(playerCharacter_t* pPlayer);
void SendJoinNumber(playerCharacter_t* pPlayer);
void SendNoticeBattle(i3socket_t* sock, char* notice);
void SendLocalUserNotice(i3socket_t* sock, int lpackIdx);
void SendAllUserData(i3socket_t* sock);
void SendEndMatchNotice(void);
void SendStartMatchNotice(playerCharacter_t* pPlayer, int redNum, int blueNum);
void Send_GB_BATTLE_RASA_Sync(playerCharacter_t* pPlayer);
void SendCheckJoinerNum(i3socket_t* sock, int num);
void SendStatusMatchNotice(i3socket_t* sock, int noticeIdx);
void SendBuyBattleTicket(playerCharacter_t* pPlayer);
void SendTwoGyunTotalNak(playerCharacter_t* pPlayer);
void SendPacketMatchTimePerSecond(playerCharacter_t* pPlayer, const int time);
void SendMessageToGM(const int LpackIdx);
void ManagerNoticeBattle(char* notice);
void ManagerLocalUserNotice(int lpackIdx);
void ManagerAllUserData();
public:
CGolryunBattle_Encoder(CGolryunBattle_Data* cpData);
virtual ~CGolryunBattle_Encoder();
};
#endif
| C++ |
#if !defined(AFX_GOLRYUNBATTLE_H__038E6C79_A7B3_41B2_82D5_44EFC81B077A__INCLUDED_)
#define AFX_GOLRYUNBATTLE_H__038E6C79_A7B3_41B2_82D5_44EFC81B077A__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#include "CGolryunBattle_Data.h"
#include "CGolryunBattle_Common.h"
#include "CGolryunBattle_Encoder.h"
#include "CGolryunBattle_Decoder.h"
#include "CGolryunBattle_Process.h"
#include "CGolryunBattle_DBV2.h"
class CGolryunBattle
{
private:
CGolryunBattle_Data* m_cpData;
CGolryunBattle_Common* m_cpCommon;
CGolryunBattle_Encoder* m_cpEncoder;
CGolryunBattle_Decoder* m_cpDecoder;
CGolryunBattle_Process* m_cpProcess;
CGolryunBattle_DBV2* m_cpDBV2;
BOOL m_bOK;
private:
BOOL Init(void);
BOOL LoadServerConfigFile(void);
public:
BOOL isOK(void) const;
void GTH_ProcessGBBattleSys(void);
CGolryunBattle_Data* GetDataClassPointer(void) const;
CGolryunBattle_Common* GetCommonClassPointer(void) const;
CGolryunBattle_Encoder* GetEncoderClassPointer(void) const;
CGolryunBattle_Process* GetProcessClassPointer(void) const;
CGolryunBattle_Decoder* GetDecoderClassPointer(void) const;
CGolryunBattle_DBV2* GetDBV2ClassPointer(void) const;
public:
CGolryunBattle();
virtual ~CGolryunBattle();
};
extern void GTH_SendMessage_CompleteEffect_To_AllPC( playerCharacter_t *pc, int effectIdx );
extern void GTH_PC_ExpUp( int idx, __int64 &exp, __int64 &genExp, int &lootNSE, int &level, int &genLevel );
#endif
| C++ |
#if !defined(AFX_CGOLRYUNBATTLE_DATA_H__16B835DA_93EA_4963_8562_6BE794844F8D__INCLUDED_)
#define AFX_CGOLRYUNBATTLE_DATA_H__16B835DA_93EA_4963_8562_6BE794844F8D__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#include "tagGolryunBattle.h"
#include "tagGolryunBattlePacket.h"
class CGolryunBattle_Data
{
public:
struct tagFighter{
int pcIdx;
char id[IDSTRING+1];
char name[NAMESTRING+1];
int FightNum;
};
struct tagMatch{
public:
enum enumCorner{
None=0,
Red,
Blue,
};
public:
struct tagFighter RedCornerFighter;
struct tagFighter BlueCornerFighter;
enum enumCorner WinnerCorner;
BOOL bComplete;
};
struct tagTournament{
public:
struct tagTicket{
int iTotalNak;
float fShareRate;
};
public:
BOOL bComplete;
int iTournamentGUID;
int iPlayLevelGroupIdx;
struct tagMatch Match[tagGolryunBattle::Max_Num_Match_Per_Tournament];
struct tagFighter FirstWinner;
struct tagFighter SecondWinner;
struct tagTicket TwoGyun;
};
struct tagEntranceTicket{
int iMaxAllocGUID;
int LotteryGUIDList[tagGolryunBattle::Max_Num_Prize_List_Per_Battle];
};
private:
BOOL m_bOK;
public:
int m_iBattleGUID;
struct tagEntranceTicket m_EntranceTicket;
struct tagTournament m_Tournament[tagGolryunBattle::Max_Num_Tournament_Per_Battle];
public:
BOOL isOK(void) const;
BOOL InitBattle();
struct tagTournament* GetTournamentPointer(const int Idx);
public:
CGolryunBattle_Data();
virtual ~CGolryunBattle_Data();
};
#endif
| C++ |
#include "..\global.h"
#include "CGolryunBattle_Data.h"
#include "CGolryunBattle_Common.h"
#include "CGolryunBattle_Process.h"
CGolryunBattle_Data::CGolryunBattle_Data()
{
m_bOK=FALSE;
m_iBattleGUID = 1;
m_EntranceTicket.iMaxAllocGUID = 1;
memset(&m_EntranceTicket.LotteryGUIDList, 0, sizeof(int)*tagGolryunBattle::Max_Num_Prize_List_Per_Battle);
InitBattle();
m_bOK=TRUE;
}
CGolryunBattle_Data::~CGolryunBattle_Data()
{
}
BOOL CGolryunBattle_Data::isOK(void) const
{
return m_bOK;
}
BOOL CGolryunBattle_Data::InitBattle()
{
struct tagTournament* pTournament=NULL;
for(int TournamentIdx=0; TournamentIdx < tagGolryunBattle::Max_Num_Tournament_Per_Battle; TournamentIdx++){
pTournament = &m_Tournament[TournamentIdx];
memset(pTournament, 0x00, sizeof(struct tagTournament));
struct tagMatch* pMatch=NULL;
for(int MatchIdx=0; MatchIdx < tagGolryunBattle::Max_Num_Match_Per_Tournament; MatchIdx++){
pMatch = &pTournament->Match[MatchIdx];
pMatch->RedCornerFighter.pcIdx=-1;
pMatch->RedCornerFighter.FightNum=-1;
pMatch->BlueCornerFighter.pcIdx=-1;
pMatch->BlueCornerFighter.FightNum=-1;
pMatch->WinnerCorner = tagMatch::enumCorner::None;
}
pTournament->FirstWinner.pcIdx=-1;
pTournament->FirstWinner.FightNum=-1;
pTournament->SecondWinner.pcIdx=-1;
pTournament->SecondWinner.FightNum=-1;
pTournament->TwoGyun.iTotalNak=0;
pTournament->TwoGyun.fShareRate=0.0f;
}
return TRUE;
}
struct CGolryunBattle_Data::tagTournament*
CGolryunBattle_Data::GetTournamentPointer(const int Idx)
{
if(Idx < 0) return NULL;
if(Idx >= tagGolryunBattle::Max_Num_Tournament_Per_Battle) return NULL;
return &m_Tournament[Idx];
}
| C++ |
#include "..\global.h"
#include "CGolryunBattle_Observer.h"
#pragma warning(disable:4786)
vec3_t CGolryunBattle_Observer::m_position={14396.0f,3685.0f,3252.0f};
#include "..\Tools\CTools.h"
extern CTools* gcpTools;
CGolryunBattle_Observer::CGolryunBattle_Observer()
{
m_bOK=FALSE;
if(FALSE == Init()) return;
m_bOK=TRUE;
}
CGolryunBattle_Observer::~CGolryunBattle_Observer()
{
m_mapRecord.clear();
}
BOOL CGolryunBattle_Observer::isOK(void) const
{
return m_bOK;
}
BOOL CGolryunBattle_Observer::Delete(const playerCharacter_t* pPlayer)
{
std::map<int,struct tagObserver>::iterator itor;
itor = m_mapRecord.find( pPlayer->idx );
if ( itor != m_mapRecord.end())
{
m_mapRecord.erase(itor);
return TRUE;
}
return FALSE;
}
BOOL CGolryunBattle_Observer::Insert(const playerCharacter_t* pPlayer)
{
struct tagObserver Observer;
memset(&Observer,0x00,sizeof(struct tagObserver));
Observer.pcIdx = pPlayer->idx;
strncpy(Observer.name,pPlayer->name,NAMESTRING);
Observer.name[NAMESTRING]=NULL;
strncpy(Observer.id,pPlayer->userID,IDSTRING);
Observer.id[IDSTRING]=NULL;
pair<std::map<int,struct tagObserver>::iterator,BOOL> ret;
ret=m_mapRecord.insert(std::map<int,struct tagObserver>::value_type(pPlayer->idx,Observer));
if(FALSE == ret.second) return FALSE;
return TRUE;
}
BOOL CGolryunBattle_Observer::Init(void)
{
m_mapRecord.clear();
return TRUE;
}
playerCharacter_t* CGolryunBattle_Observer::GetPlayerPointer(const struct tagObserver& Observer)
{
playerCharacter_t* pPlayer=gcpTools->GetPlayerRecordPointer(Observer.pcIdx);
if(NULL == pPlayer) return NULL;
if(0 != strcmp(pPlayer->name,Observer.name)) return NULL;
if(0 != strcmp(pPlayer->userID,Observer.id)) return NULL;
return pPlayer;
}
void CGolryunBattle_Observer::NET_SendUnreliableMessage(monsterCharacter_t* pMonster)
{
if(pMonster->worldIdx != tagGolryunBattle::Golryun_Battle_Map_Index) return;
int distance = GTH_GetDistance2D(m_position,pMonster->position);
if (distance > MAX_SEEINGDISTANCE) return;
std::map<int,struct tagObserver>::iterator itor;
playerCharacter_t* pTempPlayer=NULL;
for(itor=m_mapRecord.begin(); itor != m_mapRecord.end(); itor++){
pTempPlayer=GetPlayerPointer(itor->second);
if(NULL == pTempPlayer) continue;
::NET_SendUnreliableMessage(&pTempPlayer->sock, &netMessage);
}
}
void CGolryunBattle_Observer::NET_SendUnreliableMessage(playerCharacter_t* pPlayer)
{
if(pPlayer->worldIdx != tagGolryunBattle::Golryun_Battle_Map_Index) return;
int distance = GTH_GetDistance2D(m_position,pPlayer->position);
if (distance > MAX_SEEINGDISTANCE) return;
std::map<int,struct tagObserver>::iterator itor;
playerCharacter_t* pTempPlayer=NULL;
for(itor=m_mapRecord.begin(); itor != m_mapRecord.end(); itor++){
pTempPlayer=GetPlayerPointer(itor->second);
if(NULL == pTempPlayer) continue;
if(pPlayer == pTempPlayer) continue;
::NET_SendUnreliableMessage(&pTempPlayer->sock, &netMessage);
}
}
| C++ |
#if !defined(AFX_CCSVFILECTRL_H__73B81FA9_85AD_42A3_994F_6842B352AC71__INCLUDED_)
#define AFX_CCSVFILECTRL_H__73B81FA9_85AD_42A3_994F_6842B352AC71__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CCSVFileCtrl
{
private:
enum{
MaxBytes_Token=500,
};
BOOL m_bOK;
unsigned char* m_pFileBuffer;
int m_iFileBytes;
char m_szFileName[_MAX_PATH+1];
unsigned char* m_pCurPos;
unsigned char* m_pEndPos;
char m_Token[MaxBytes_Token+1];
private:
BOOL LoadFile(void);
public:
BOOL isOK(void) const;
const unsigned char* NextToken(void);
public:
CCSVFileCtrl(const char* szpFileName);
virtual ~CCSVFileCtrl();
};
#endif
| C++ |
#if !defined(AFX_CTERRABILLINGCTRL_LOGCTRL_H__1DC2AC1C_FE9B_490E_A4F0_2AF95AA14FDB__INCLUDED_)
#define AFX_CTERRABILLINGCTRL_LOGCTRL_H__1DC2AC1C_FE9B_490E_A4F0_2AF95AA14FDB__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CGolryunBattle_Log
{
private:
BOOL m_bOK;
char m_szFileName[_MAX_PATH];
FILE* m_fp;
int m_NextUpdateTime;
int m_generationHour;
private:
inline BOOL OpenFile(void);
inline void CloseFile(void);
public:
BOOL isOK(void) const;
void Update(void);
void Write(const char* format, ... );
static char* GetYESNOstring(BOOL bYESorNO);
public:
CGolryunBattle_Log();
virtual ~CGolryunBattle_Log();
};
#endif
| C++ |
#include "..\global.h"
#include "CGolryunBattle_Log.h"
#include "tagGolryunBattle.h"
extern struct tagGolryunBattleVar gGolryunBattleVar;
CGolryunBattle_Log::CGolryunBattle_Log()
{
m_bOK=FALSE;
m_generationHour=25;
m_fp=NULL;
m_NextUpdateTime=g_globalTime-100;
m_bOK=TRUE;
}
CGolryunBattle_Log::~CGolryunBattle_Log()
{
CloseFile();
}
BOOL CGolryunBattle_Log::isOK(void) const
{
return m_bOK;
}
void CGolryunBattle_Log::Update(void)
{
if(FALSE == gGolryunBattleVar.Log.bOutput) return;
if(m_NextUpdateTime > (int)g_globalTime) return;
m_NextUpdateTime=g_globalTime + gGolryunBattleVar.Log.UpdateTimeMiliSecond;
CloseFile();
OpenFile();
}
inline void CGolryunBattle_Log::CloseFile(void)
{
if(NULL != m_fp){ fclose(m_fp); m_fp=NULL; }
}
void CGolryunBattle_Log::Write(const char* format, ... )
{
if(FALSE == gGolryunBattleVar.Log.bOutput) return;
if(NULL == m_fp){
if(FALSE == OpenFile()) return;
}
va_list argptr;
const int buffer_maxbytes=4095;
char buffer[buffer_maxbytes+1];
va_start(argptr, format);
_vsnprintf(buffer,buffer_maxbytes, format, argptr);
buffer[buffer_maxbytes]=NULL;
va_end(argptr);
const int bytes_strTime=24;
char strTime[bytes_strTime+1];
time_t Time;
time( &Time );
strncpy(strTime, ::ctime(&Time),bytes_strTime);
strTime[bytes_strTime] = NULL;
fprintf(m_fp,"[%s] %s\n",strTime,buffer);
}
char* CGolryunBattle_Log::GetYESNOstring(BOOL bYESorNO)
{
static char* pYESstring = "yes";
static char* pNOstring = "no";
if(TRUE == bYESorNO) return pYESstring;
return pNOstring;
}
inline BOOL CGolryunBattle_Log::OpenFile(void)
{
struct tm* date_tm;
long Time;
time(&Time);
date_tm = localtime(&Time);
if(m_generationHour != date_tm->tm_hour){
m_generationHour = date_tm->tm_hour;
date_tm->tm_year += 1900;
date_tm->tm_mon += 1;
wsprintf(m_szFileName,"GolryunLogs/Golryun%02d%02d_%04d%02d%02d_%02d.log",g_config.serverGroupNo,g_config.gameServerNo,date_tm->tm_year,date_tm->tm_mon,date_tm->tm_mday,date_tm->tm_hour);
}
m_fp = fopen(m_szFileName,"a+");
if(NULL == m_fp) return FALSE;
return TRUE;
} | C++ |
#if !defined(AFX_CGOLRYUNBATTLE_COMMON_H__00634699_23E3_4965_A6C4_2E6C12227C4C__INCLUDED_)
#define AFX_CGOLRYUNBATTLE_COMMON_H__00634699_23E3_4965_A6C4_2E6C12227C4C__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#include "CGolryunBattle_Data.h"
class CGolryunBattle_Common
{
private:
BOOL m_bOK;
public:
BOOL isOK(void) const;
public:
static playerCharacter_t* GetArenaPlayer(const int Idx);
static playerCharacter_t* GetArenaPlayer(const CGolryunBattle_Data::tagFighter& Fighter);
static playerCharacter_t* GetPlayer(const CGolryunBattle_Data::tagFighter& Fighter);
static void Change_Inventory_Nak(const __int64 i64ParamNak,playerCharacter_t* pPc);
static itemTable_t* GetItemTablePointer(const int Idx);
public:
CGolryunBattle_Common();
virtual ~CGolryunBattle_Common();
};
#endif
| C++ |
#include "..\global.h"
#include "CServerLpackCtrl.h"
#include <windowsx.h>
extern char *g_lTableToken[];
const char CServerLpackCtrl::m_OverflowMessageLine[MaxBytes_per_Line+1]="Server Lpack Overflow";
#include "CCSVFileCtrl.h"
CServerLpackCtrl::CServerLpackCtrl()
{
m_bOK=FALSE;
for(int idx=0; idx < MaxLineNum; idx++){
strncpy(m_LineBuffer[idx],m_OverflowMessageLine,MaxBytes_per_Line);
m_LineBuffer[idx][MaxBytes_per_Line]=NULL;
}
if(FALSE == Init()) return;
m_bOK=TRUE;
}
CServerLpackCtrl::~CServerLpackCtrl()
{
}
BOOL CServerLpackCtrl::Init(void)
{
char szFileName[_MAX_PATH];
wsprintf(szFileName,"l_tables/ServerLpack%s.csv",g_lTableToken[g_config.languageType]);
if(FALSE == LoadFile(szFileName)) return FALSE;
return TRUE;
}
BOOL CServerLpackCtrl::isOK(void) const
{
return m_bOK;
}
char* CServerLpackCtrl::GetLpack(const unsigned int Idx)
{
if(Idx < 0) return (char*)m_OverflowMessageLine;
if(Idx >= MaxLineNum) return (char*)m_OverflowMessageLine;
return m_LineBuffer[Idx];
}
BOOL CServerLpackCtrl::LoadFile(const char* szpFileName)
{
CCSVFileCtrl* cpCSVFileCtrl=NULL;
cpCSVFileCtrl = new CCSVFileCtrl(szpFileName);
if(NULL == cpCSVFileCtrl) return FALSE;
if(FALSE == cpCSVFileCtrl->isOK()){ delete cpCSVFileCtrl; cpCSVFileCtrl=NULL; return FALSE; }
int idx=0;
const unsigned char* pToken=NULL;
while(TRUE){
pToken = cpCSVFileCtrl->NextToken();
if(NULL == pToken) break;
idx = atoi((char*)pToken);
if(idx < 0) break;
if(idx >= MaxLineNum) break;
pToken = cpCSVFileCtrl->NextToken();
if(NULL == pToken) break;
strncpy(m_LineBuffer[idx],(char*)pToken,MaxBytes_per_Line);
m_LineBuffer[idx][MaxBytes_per_Line]=NULL;
}
if(NULL != cpCSVFileCtrl){ delete cpCSVFileCtrl; cpCSVFileCtrl=NULL; }
return TRUE;
}
| C++ |
#include "../Global.h"
#include "CCSVFileCtrl.h"
#include <windowsx.h>
CCSVFileCtrl::CCSVFileCtrl(const char* szpFileName)
{
m_bOK=FALSE;
m_pFileBuffer = NULL;
strncpy(m_szFileName,szpFileName,_MAX_PATH);
m_szFileName[_MAX_PATH]=NULL;
m_iFileBytes=0;
m_pCurPos = NULL;
m_pEndPos = NULL;
if(FALSE == LoadFile()) return;
m_bOK=TRUE;
}
CCSVFileCtrl::~CCSVFileCtrl()
{
if(NULL != m_pFileBuffer){ GlobalFreePtr(m_pFileBuffer); m_pFileBuffer=NULL; }
}
BOOL CCSVFileCtrl::isOK(void) const
{
return m_bOK;
}
const unsigned char* CCSVFileCtrl::NextToken(void)
{
if(m_pCurPos >= m_pEndPos) return NULL;
int bytes=0;
while(TRUE){
if ( m_pCurPos >= m_pEndPos ) break;
if(*m_pCurPos == '\n'){ m_pCurPos++; continue;}
if((*m_pCurPos == ',') || (*m_pCurPos == '\r')){ m_pCurPos++; break; }
if(TRUE == IsDBCSLeadByte((BYTE)*m_pCurPos)){
bytes+=1; m_Token[bytes-1] = *m_pCurPos++;
bytes+=1; m_Token[bytes-1] = *m_pCurPos++;
}else{
bytes+=1; m_Token[bytes-1] = *m_pCurPos++;
}
}
if(bytes <= 0) return NULL;
m_Token[bytes]=NULL;
return (const unsigned char*)m_Token;
}
BOOL CCSVFileCtrl::LoadFile(void)
{
FILE *fp = NULL;
fp = fopen( m_szFileName, "rb" );
if(NULL == fp) return FALSE;
fseek(fp,0,SEEK_END);
m_iFileBytes = ftell(fp);
m_pFileBuffer = (unsigned char*)GlobalAllocPtr(GMEM_FIXED,sizeof(unsigned char) * m_iFileBytes);
if(NULL == m_pFileBuffer) return FALSE;
fseek(fp,0,SEEK_SET);
fread(m_pFileBuffer,m_iFileBytes,1,fp);
if(NULL != fp){ fclose(fp); fp=NULL; }
m_pCurPos = m_pFileBuffer;
m_pEndPos = m_pFileBuffer + m_iFileBytes;
return TRUE;
}
| C++ |
#if !defined(AFX_CGOLRYUNBATTLE_DBV2_H__9A72C178_836E_43E8_B7BD_1EB9128D6228__INCLUDED_)
#define AFX_CGOLRYUNBATTLE_DBV2_H__9A72C178_836E_43E8_B7BD_1EB9128D6228__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CGolryunBattle_DBV2
{
public:
enum enumBattleState{
BattleState_Create=0,
BattleState_Playing=1,
BattleState_Complete=2,
};
struct tagTournament{
public:
struct tagFighter{
char Name[NAMESTRING+1];
int Num;
};
struct tagTwoGyun{
int nTotalNak;
float Rate;
};
public:
int nGUID;
int nLevelGroupIdx;
BOOL bComplete;
struct tagTwoGyun TwoGyun;
struct tagFighter firstWinner;
struct tagFighter secondWinner;
};
struct tagBattle{
BOOL bActive;
int nGUID;
int nMaxTournamentGUID;
int nMaxEntranceTicketGUID;
int nLotteryGUIDList[tagGolryunBattle::Max_Num_Prize_List_Per_Battle];
struct tagTournament Tournament[tagGolryunBattle::Max_Num_Tournament_Per_Battle];
};
enum enumError{
ERROR_NONE=0,
ERROR_NOT_READYa,
ERROR_SQL_LOADING_WHEN_START,
ERROR_SQL_query_AddBattle,
ERROR_SQL_query_SaveBattle,
ERROR_SQL_query_AddTournament,
ERROR_SQL_query_SaveTournament,
};
private:
enum{
MAXNUM_RECORD=10,
};
struct tagLoading{
public:
enum enumLoadingStep{
loadingSTEP_START=0,
loadingSTEP_WAIT,
loadingSTEP_tournament,
loadingSTEP_tournament_wait,
loadingSTEP_complete,
};
public:
enum enumLoadingStep step;
};
struct tagQueryExeMon{
int refcount;
};
enum enumError m_Error;
BOOL m_bOK;
struct tagBattle m_TemporaryPlayingBattle;
struct tagBattle m_Record[MAXNUM_RECORD];
struct tagLoading m_Loading;
int m_nTournamentGUIDminmum;
struct tagQueryExeMon m_QueryExeMon;
private:
inline void SetMinimumTournamentGUID(void);
public:
BOOL isOK(void) const;
void Process(void);
inline void Process_loadingSTEP_tournament(void);
int GetMinimumTournamentGUID(void) const;
BOOL Update(const int in_nUpdateTornamentGroupIdx,const struct tagBattle& in_Battle);
void Update(const struct tagBattle& in_Battle);
void Add(const struct tagBattle& in_Battle);
void Save(const struct tagBattle& in_Battle);
struct tagBattle* GetBattleRecordPointer(const int in_nBattleGUID);
struct tagBattle* GetTemporaryPlayingBattle(void);
public:
enum enumError GetLastError(void) const;
char* GetLastErrorStr(void) const;
BOOL isReady(void) const;
public:
void ODBC_LoadLastBattle(void);
void ODBC_LoadTournament(const int nBattleGUID);
void ODBC_AddBatle(const enum enumBattleState in_BattleState,const struct tagBattle& in_Battle);
void ODBC_SaveBattle(const enum enumBattleState in_BattleState,const struct tagBattle& in_Battle);
void ODBC_AddTournament(const int in_nBattleGUID,const struct tagTournament& in_Tournament);
void ODBC_SaveTournament(const int in_nBattleGUID,const struct tagTournament& in_Tournament);
void ODBC_QueryExecuterThread_Query_GolryunBattle_SaveTournament(const querySet_t& in_request,querySet_t& out_result);
void ODBC_QueryExecuterThread_Query_GolryunBattle_AddTournament(const querySet_t& in_request,querySet_t& out_result);
void ODBC_QueryExecuterThread_Query_GolryunBattle_SaveBattle(const querySet_t& in_request,querySet_t& out_result);
void ODBC_QueryExecuterThread_Query_GolryunBattle_AddBattle(const querySet_t& request,querySet_t& result);
void ODBC_QueryExecuterThread_Query_GolryunBattle_LoadTournament(const querySet_t& request,querySet_t& result);
void ODBC_QueryExecuterThread_Query_GolryunBattle_LoadLastBattle(const querySet_t& in_request,querySet_t& out_result);
void ODBC_ProcessQueryResultQueue_Query_GolryunBattle_LoadLastBattle(const querySet_t& in_result);
void ODBC_ProcessQueryResultQueue_Query_GolryunBattle_AddBattle(const querySet_t& in_result);
void ODBC_ProcessQueryResultQueue_Query_GolryunBattle_LoadTournament(const querySet_t& in_result);
void ODBC_ProcessQueryResultQueue_Query_GolryunBattle_SaveBattle(const querySet_t& in_result);
void ODBC_ProcessQueryResultQueue_Query_GolryunBattle_AddTournament(const querySet_t& in_result);
void ODBC_ProcessQueryResultQueue_Query_GolryunBattle_SaveTournament(const querySet_t& out_result);
public:
CGolryunBattle_DBV2();
virtual ~CGolryunBattle_DBV2();
};
#endif
| C++ |
#include "..\global.h"
#include "CGolryunBattle_DBV2.h"
#include <assert.h>
CGolryunBattle_DBV2::CGolryunBattle_DBV2()
{
m_bOK=FALSE;
m_nTournamentGUIDminmum=0x7fffffff;
m_Loading.step=tagLoading::loadingSTEP_START;
m_Error = ERROR_NOT_READYa;
m_QueryExeMon.refcount=0;
memset(&m_TemporaryPlayingBattle,0x00,sizeof(struct tagBattle));
memset(m_Record,0x00,sizeof(struct tagBattle)* MAXNUM_RECORD);
m_bOK=TRUE;
}
CGolryunBattle_DBV2::~CGolryunBattle_DBV2()
{
Sleep(0);
}
BOOL CGolryunBattle_DBV2::isOK(void) const
{
return m_bOK;
}
BOOL CGolryunBattle_DBV2::isReady(void) const
{
if(ERROR_NONE != GetLastError()) return FALSE;
if(m_QueryExeMon.refcount > 0) return FALSE;
return TRUE;
}
int CGolryunBattle_DBV2::GetMinimumTournamentGUID(void) const
{
return m_nTournamentGUIDminmum;
}
inline void CGolryunBattle_DBV2::Process_loadingSTEP_tournament(void)
{
m_Loading.step = tagLoading::loadingSTEP_tournament_wait;
if(FALSE == m_TemporaryPlayingBattle.bActive){
m_Error = ERROR_SQL_LOADING_WHEN_START;
return;
}
ODBC_LoadTournament(m_TemporaryPlayingBattle.nGUID);
struct tagBattle* pBattle=NULL;
for(int nRecordIdx=0; nRecordIdx < MAXNUM_RECORD; nRecordIdx++){
pBattle = &m_Record[nRecordIdx];
if(FALSE == pBattle->bActive) continue;
ODBC_LoadTournament(pBattle->nGUID);
}
}
void CGolryunBattle_DBV2::Process(void)
{
if(FALSE == GTH_IsLocalServiceWorld(tagGolryunBattle::Golryun_Battle_Map_Index)) return;
switch(m_Loading.step){
case tagLoading::loadingSTEP_complete:
return;
case tagLoading::loadingSTEP_START:
ODBC_LoadLastBattle();
m_Loading.step = tagLoading::loadingSTEP_WAIT;
return;
case tagLoading::loadingSTEP_tournament_wait:
if(m_QueryExeMon.refcount <= 0){
m_Loading.step = tagLoading::loadingSTEP_complete;
SetMinimumTournamentGUID();
if(ERROR_NOT_READYa == m_Error) m_Error = ERROR_NONE;
}
return;
case tagLoading::loadingSTEP_WAIT:
return;
case tagLoading::loadingSTEP_tournament:
Process_loadingSTEP_tournament();
return;
}
}
extern HANDLE hQueryRequestMutex;
extern CQueryQueue* queryRequestQueue;
void CGolryunBattle_DBV2::ODBC_LoadLastBattle(void)
{
querySet_t request;
memset(&request,0x00,sizeof(querySet_t));
_snprintf(g_DBGameServer->m_query,QUERYSIZE, "EXEC LoadLastBattle");
g_DBGameServer->m_query[QUERYSIZE]=NULL;
request.ownerIdx = -1;
request.ownerID[0]=NULL;
request.queryType = Query_GolryunBattle_LoadLastBattle;
strncpy(request.query, g_DBGameServer->m_query,QUERYSIZE);
request.query[QUERYSIZE]=NULL;
request.hStmt = g_DBGameServer->GetStmt();
request.retCode = -1;
request.retStructVariable = NULL;
WaitForSingleObject( hQueryRequestMutex, INFINITE );
queryRequestQueue->Push( &request );
ReleaseMutex( hQueryRequestMutex );
m_QueryExeMon.refcount+=1;
}
inline void CGolryunBattle_DBV2::SetMinimumTournamentGUID(void)
{
m_nTournamentGUIDminmum=0x7fffffff;
struct tagBattle* pBattle=NULL;
for(int nBattleIdx=1; nBattleIdx < MAXNUM_RECORD; nBattleIdx++){
pBattle = &m_Record[nBattleIdx];
for(int nTournamentIdx=0; nTournamentIdx < tagGolryunBattle::Max_Num_Tournament_Per_Battle; nTournamentIdx++){
if(FALSE == pBattle->Tournament[nTournamentIdx].bComplete) continue;
if(pBattle->Tournament[nTournamentIdx].nGUID < m_nTournamentGUIDminmum)
m_nTournamentGUIDminmum = pBattle->Tournament[nTournamentIdx].nGUID;
}
}
}
void CGolryunBattle_DBV2::
ODBC_AddBatle(const enum enumBattleState in_BattleState,const struct tagBattle& in_Battle)
{
querySet_t request;
memset(&request,0x00,sizeof(querySet_t));
_snprintf(g_DBGameServer->m_query,QUERYSIZE,
"EXEC AddBattle %d,%d,%d,%d,"
"%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d",
in_Battle.nGUID,
in_BattleState,
in_Battle.nMaxTournamentGUID,
in_Battle.nMaxEntranceTicketGUID,
in_Battle.nLotteryGUIDList[0],
in_Battle.nLotteryGUIDList[1],
in_Battle.nLotteryGUIDList[2],
in_Battle.nLotteryGUIDList[3],
in_Battle.nLotteryGUIDList[4],
in_Battle.nLotteryGUIDList[5],
in_Battle.nLotteryGUIDList[6],
in_Battle.nLotteryGUIDList[7],
in_Battle.nLotteryGUIDList[8],
in_Battle.nLotteryGUIDList[9],
in_Battle.nLotteryGUIDList[10],
in_Battle.nLotteryGUIDList[11],
in_Battle.nLotteryGUIDList[12],
in_Battle.nLotteryGUIDList[13],
in_Battle.nLotteryGUIDList[14],
in_Battle.nLotteryGUIDList[15]);
g_DBGameServer->m_query[QUERYSIZE]=NULL;
request.ownerIdx = -1;
request.ownerID[0]=NULL;
request.queryType = Query_GolryunBattle_AddBattle;
strncpy(request.query, g_DBGameServer->m_query,QUERYSIZE);
request.query[QUERYSIZE]=NULL;
request.hStmt = g_DBGameServer->GetStmt();
request.retCode = -1;
request.retStructVariable = NULL;
WaitForSingleObject( hQueryRequestMutex, INFINITE );
queryRequestQueue->Push( &request );
ReleaseMutex( hQueryRequestMutex );
m_QueryExeMon.refcount+=1;
}
void CGolryunBattle_DBV2::
ODBC_QueryExecuterThread_Query_GolryunBattle_AddBattle(const querySet_t& request,querySet_t& result)
{
if(SQL_SUCCESS != result.retCode){
m_Error = ERROR_SQL_query_AddBattle;
return;
}
}
void CGolryunBattle_DBV2::
ODBC_QueryExecuterThread_Query_GolryunBattle_LoadLastBattle(
const querySet_t& in_request,
querySet_t& out_result)
{
assert(m_Loading.step == tagLoading::loadingSTEP_WAIT);
RETCODE rCode=SQL_ERROR;
rCode= SQLFetch(in_request.hStmt);
if((SQL_NO_DATA == rCode) || (SQL_ERROR == rCode)){
m_Error = ERROR_SQL_LOADING_WHEN_START;
out_result.retCode=rCode;
rCode = SQLCloseCursor( in_request.hStmt );
if( (rCode == SQL_ERROR) || (rCode == SQL_SUCCESS_WITH_INFO)){
g_DBGameServer->PrintError(in_request);
}
return;
}
out_result.retCode = rCode;
int nBattleRecordIdx=0;
struct tagBattle Battle;
memset(&Battle,0x00,sizeof(struct tagBattle));
long nLength=0;
enum enumBattleState nbattleState=enumBattleState::BattleState_Create;
for(int nIdx=0;rCode == SQL_SUCCESS; rCode = SQLFetch(in_request.hStmt),nIdx++){
SQLGetData(in_request.hStmt, 1, SQL_INTEGER, &Battle.nGUID,sizeof(int), &nLength);
SQLGetData(in_request.hStmt, 2, SQL_INTEGER, &nbattleState,sizeof(int), &nLength);
SQLGetData(in_request.hStmt, 3, SQL_INTEGER, &Battle.nMaxTournamentGUID,sizeof(int), &nLength);
SQLGetData(in_request.hStmt, 4, SQL_INTEGER, &Battle.nMaxEntranceTicketGUID,sizeof(int), &nLength);
for(int nLotteryIdx=0; nLotteryIdx < tagGolryunBattle::Max_Num_Prize_List_Per_Battle; nLotteryIdx++)
SQLGetData(in_request.hStmt, 5 + nLotteryIdx, SQL_INTEGER, &Battle.nLotteryGUIDList[nLotteryIdx],sizeof(int), &nLength);
if(0 == nIdx){
m_TemporaryPlayingBattle = Battle;
m_TemporaryPlayingBattle.bActive=TRUE;
}else{
assert(TRUE == m_TemporaryPlayingBattle.bActive);
m_Record[nBattleRecordIdx]=Battle;
m_Record[nBattleRecordIdx].bActive=TRUE;
nBattleRecordIdx+=1;
if(nBattleRecordIdx >= MAXNUM_RECORD) break;
}
}
m_Loading.step = tagLoading::loadingSTEP_tournament;
rCode = SQLCloseCursor( in_request.hStmt );
if( (rCode == SQL_ERROR) || (rCode == SQL_SUCCESS_WITH_INFO)){
g_DBGameServer->PrintError(in_request);
}
return;
}
void CGolryunBattle_DBV2::ODBC_LoadTournament(const int nBattleGUID)
{
querySet_t request;
memset(&request,0x00,sizeof(querySet_t));
_snprintf(g_DBGameServer->m_query,QUERYSIZE, "EXEC LoadTournament %d",nBattleGUID);
g_DBGameServer->m_query[QUERYSIZE]=NULL;
request.ownerIdx = -1;
request.ownerID[0]=NULL;
request.queryType = Query_GolryunBattle_LoadTournament;
strncpy(request.query, g_DBGameServer->m_query,QUERYSIZE);
request.query[QUERYSIZE]=NULL;
request.hStmt = g_DBGameServer->GetStmt();
request.retCode = -1;
request.retStructVariable = NULL;
WaitForSingleObject( hQueryRequestMutex, INFINITE );
queryRequestQueue->Push( &request );
ReleaseMutex( hQueryRequestMutex );
m_QueryExeMon.refcount+=1;
}
struct CGolryunBattle_DBV2::tagBattle* CGolryunBattle_DBV2::
GetBattleRecordPointer(const int in_nBattleGUID)
{
if(m_Loading.step == tagLoading::loadingSTEP_tournament_wait){
if(m_TemporaryPlayingBattle.nGUID == in_nBattleGUID) return &m_TemporaryPlayingBattle;
}
for(int nRecordIdx=0; nRecordIdx < MAXNUM_RECORD; nRecordIdx++){
if(FALSE == m_Record[nRecordIdx].bActive) continue;
if(m_Record[nRecordIdx].nGUID == in_nBattleGUID) return &m_Record[nRecordIdx];
}
return NULL;
}
struct CGolryunBattle_DBV2::tagBattle* CGolryunBattle_DBV2::GetTemporaryPlayingBattle(void)
{
return &m_TemporaryPlayingBattle;
}
enum CGolryunBattle_DBV2::enumError CGolryunBattle_DBV2::GetLastError(void) const
{
return m_Error;
}
void CGolryunBattle_DBV2::
ODBC_QueryExecuterThread_Query_GolryunBattle_LoadTournament(const querySet_t& request,querySet_t& result)
{
if(m_Loading.step != tagLoading::loadingSTEP_tournament_wait){
m_Error = ERROR_SQL_LOADING_WHEN_START;
}
RETCODE rCode=SQL_ERROR;
rCode= SQLFetch(request.hStmt);
if((SQL_NO_DATA == rCode) || (SQL_ERROR == rCode)){
if(SQL_ERROR == rCode) m_Error = ERROR_SQL_LOADING_WHEN_START;
result.retCode=rCode;
rCode = SQLCloseCursor( request.hStmt );
if( (rCode == SQL_ERROR) || (rCode == SQL_SUCCESS_WITH_INFO)){
g_DBGameServer->PrintError(request);
}
return;
}
result.retCode = rCode;
long lLength=0;
int nBattleGUID=0;
struct tagBattle* pBattle=NULL;
struct tagTournament Tournament;
for(;rCode == SQL_SUCCESS; rCode = SQLFetch(request.hStmt)){
SQLGetData(request.hStmt, 1, SQL_INTEGER, &nBattleGUID,sizeof(int), &lLength);
SQLGetData(request.hStmt, 2, SQL_INTEGER, &Tournament.nGUID,sizeof(int), &lLength);
SQLGetData(request.hStmt, 3, SQL_INTEGER, &Tournament.nLevelGroupIdx,sizeof(int), &lLength);
SQLGetData(request.hStmt, 4, SQL_INTEGER, &Tournament.bComplete,sizeof(int), &lLength);
SQLGetData(request.hStmt, 5, SQL_C_CHAR, Tournament.firstWinner.Name,NAMESTRING, &lLength);
Tournament.firstWinner.Name[NAMESTRING-1]=NULL;
SQLGetData(request.hStmt, 6, SQL_INTEGER, &Tournament.firstWinner.Num,sizeof(int), &lLength);
SQLGetData(request.hStmt, 7, SQL_C_CHAR, Tournament.secondWinner.Name,NAMESTRING, &lLength);
Tournament.secondWinner.Name[NAMESTRING-1]=NULL;
SQLGetData(request.hStmt, 8, SQL_INTEGER, &Tournament.secondWinner.Num,sizeof(int), &lLength);
SQLGetData(request.hStmt, 9, SQL_INTEGER, &Tournament.TwoGyun.nTotalNak,sizeof(int), &lLength);
SQLGetData(request.hStmt,10, SQL_C_FLOAT, &Tournament.TwoGyun.Rate,sizeof(float), &lLength);
pBattle = GetBattleRecordPointer(nBattleGUID);
if(NULL == pBattle){
m_Error = ERROR_SQL_LOADING_WHEN_START;
break;
}
assert(Tournament.nLevelGroupIdx >= 0);
assert(Tournament.nLevelGroupIdx < tagGolryunBattle::Max_Num_Tournament_Per_Battle);
pBattle->Tournament[Tournament.nLevelGroupIdx] = Tournament;
pBattle->Tournament[Tournament.nLevelGroupIdx].bComplete=TRUE;
}
rCode = SQLCloseCursor( request.hStmt );
if( (rCode == SQL_ERROR) || (rCode == SQL_SUCCESS_WITH_INFO)){
g_DBGameServer->PrintError(request);
}
return;
}
void CGolryunBattle_DBV2::ODBC_SaveBattle(const enum enumBattleState in_BattleState,const struct tagBattle& in_Battle)
{
querySet_t request;
memset(&request,0x00,sizeof(querySet_t));
_snprintf(g_DBGameServer->m_query,QUERYSIZE,
"EXEC SaveBattle %d,%d,%d,%d,"
"%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d",
in_Battle.nGUID,
in_BattleState,
in_Battle.nMaxTournamentGUID,
in_Battle.nMaxEntranceTicketGUID,
in_Battle.nLotteryGUIDList[0],
in_Battle.nLotteryGUIDList[1],
in_Battle.nLotteryGUIDList[2],
in_Battle.nLotteryGUIDList[3],
in_Battle.nLotteryGUIDList[4],
in_Battle.nLotteryGUIDList[5],
in_Battle.nLotteryGUIDList[6],
in_Battle.nLotteryGUIDList[7],
in_Battle.nLotteryGUIDList[8],
in_Battle.nLotteryGUIDList[9],
in_Battle.nLotteryGUIDList[10],
in_Battle.nLotteryGUIDList[11],
in_Battle.nLotteryGUIDList[12],
in_Battle.nLotteryGUIDList[13],
in_Battle.nLotteryGUIDList[14],
in_Battle.nLotteryGUIDList[15]);
g_DBGameServer->m_query[QUERYSIZE]=NULL;
request.ownerIdx = -1;
request.ownerID[0]=NULL;
request.queryType = Query_GolryunBattle_SaveBattle;
strncpy(request.query, g_DBGameServer->m_query,QUERYSIZE);
request.query[QUERYSIZE]=NULL;
request.hStmt = g_DBGameServer->GetStmt();
request.retCode = -1;
request.retStructVariable = NULL;
WaitForSingleObject( hQueryRequestMutex, INFINITE );
queryRequestQueue->Push( &request );
ReleaseMutex( hQueryRequestMutex );
m_QueryExeMon.refcount+=1;
}
void CGolryunBattle_DBV2::
ODBC_QueryExecuterThread_Query_GolryunBattle_SaveBattle(const querySet_t& in_request,querySet_t& out_result)
{
if(SQL_SUCCESS != out_result.retCode){
m_Error = ERROR_SQL_query_SaveBattle;
return;
}
}
void CGolryunBattle_DBV2::
ODBC_AddTournament(const int in_nBattleGUID,const struct tagTournament& in_Tournament)
{
querySet_t request;
memset(&request,0x00,sizeof(querySet_t));
_snprintf(g_DBGameServer->m_query,QUERYSIZE,
"EXEC AddTournament "
"%d,%d,%d,%d,"
"'%s',%d,"
"'%s',%d,"
"%d,%.3f",
in_nBattleGUID,in_Tournament.nGUID,in_Tournament.nLevelGroupIdx,in_Tournament.bComplete,
in_Tournament.firstWinner.Name, in_Tournament.firstWinner.Num,
in_Tournament.secondWinner.Name, in_Tournament.secondWinner.Num,
in_Tournament.TwoGyun.nTotalNak,in_Tournament.TwoGyun.Rate);
g_DBGameServer->m_query[QUERYSIZE]=NULL;
request.ownerIdx = -1;
request.ownerID[0]=NULL;
request.queryType = Query_GolryunBattle_AddTournament;
strncpy(request.query, g_DBGameServer->m_query,QUERYSIZE);
request.query[QUERYSIZE]=NULL;
request.hStmt = g_DBGameServer->GetStmt();
request.retCode = -1;
request.retStructVariable = NULL;
WaitForSingleObject( hQueryRequestMutex, INFINITE );
queryRequestQueue->Push( &request );
ReleaseMutex( hQueryRequestMutex );
m_QueryExeMon.refcount+=1;
}
void CGolryunBattle_DBV2::
ODBC_QueryExecuterThread_Query_GolryunBattle_AddTournament(const querySet_t& in_request,querySet_t& out_result)
{
if(SQL_SUCCESS != out_result.retCode){
m_Error = ERROR_SQL_query_AddTournament;
return;
}
}
void CGolryunBattle_DBV2::
ODBC_SaveTournament(const int in_nBattleGUID,const struct tagTournament& in_Tournament)
{
querySet_t request;
memset(&request,0x00,sizeof(querySet_t));
_snprintf(g_DBGameServer->m_query,QUERYSIZE,
"EXEC SaveTournament "
"%d,%d,%d,%d,"
"'%s',%d,"
"'%s',%d,"
"%d,%.3f",
in_nBattleGUID,in_Tournament.nGUID,in_Tournament.nLevelGroupIdx,in_Tournament.bComplete,
in_Tournament.firstWinner.Name, in_Tournament.firstWinner.Num,
in_Tournament.secondWinner.Name, in_Tournament.secondWinner.Num,
in_Tournament.TwoGyun.nTotalNak,in_Tournament.TwoGyun.Rate);
g_DBGameServer->m_query[QUERYSIZE]=NULL;
request.ownerIdx = -1;
request.ownerID[0]=NULL;
request.queryType = Query_GolryunBattle_SaveTournament;
strncpy(request.query, g_DBGameServer->m_query,QUERYSIZE);
request.query[QUERYSIZE]=NULL;
request.hStmt = g_DBGameServer->GetStmt();
request.retCode = -1;
request.retStructVariable = NULL;
WaitForSingleObject( hQueryRequestMutex, INFINITE );
queryRequestQueue->Push( &request );
ReleaseMutex( hQueryRequestMutex );
m_QueryExeMon.refcount+=1;
}
void CGolryunBattle_DBV2::
ODBC_QueryExecuterThread_Query_GolryunBattle_SaveTournament(const querySet_t& in_request,querySet_t& out_result)
{
if(SQL_SUCCESS != out_result.retCode){
m_Error = ERROR_SQL_query_SaveTournament;
return;
}
}
char* CGolryunBattle_DBV2::GetLastErrorStr(void) const
{
static char strMessage[256]="";
switch(m_Error){
case ERROR_NONE:
wsprintf(strMessage,"Success");
break;
case ERROR_NOT_READYa:
wsprintf(strMessage,"db not ready");
break;
case ERROR_SQL_LOADING_WHEN_START:
wsprintf(strMessage,"query AddBattle error");
break;
case ERROR_SQL_query_AddBattle:
wsprintf(strMessage,"query AddBattle error");
break;
case ERROR_SQL_query_SaveBattle:
wsprintf(strMessage,"query SaveBattle error");
break;
case ERROR_SQL_query_AddTournament:
wsprintf(strMessage,"query AddTournament error");
break;
case ERROR_SQL_query_SaveTournament:
wsprintf(strMessage,"query SaverTournament error");
break;
default:
wsprintf(strMessage,"unknown error");
break;
}
return strMessage;
}
void CGolryunBattle_DBV2::
Update(const struct tagBattle& in_Battle)
{
ODBC_SaveBattle(BattleState_Playing,in_Battle);
}
BOOL CGolryunBattle_DBV2::
Update(const int in_nUpdateTornamentGroupIdx,const struct tagBattle& in_Battle)
{
if(in_nUpdateTornamentGroupIdx < 0) return FALSE;
if(in_nUpdateTornamentGroupIdx >= tagGolryunBattle::Max_Num_Tournament_Per_Battle) return FALSE;
ODBC_AddTournament(in_Battle.nGUID,in_Battle.Tournament[in_nUpdateTornamentGroupIdx]);
ODBC_SaveBattle(BattleState_Playing,in_Battle);
return TRUE;
}
void CGolryunBattle_DBV2::Add(const struct tagBattle& in_Battle)
{
ODBC_AddBatle(BattleState_Playing,in_Battle);
}
void CGolryunBattle_DBV2::Save(const struct tagBattle& in_Battle)
{
ODBC_SaveBattle(BattleState_Playing,in_Battle);
for(int nRecordIdx = MAXNUM_RECORD-1; nRecordIdx >= 1; nRecordIdx--){
m_Record[nRecordIdx] = m_Record[nRecordIdx-1];
}
m_Record[0] = in_Battle;
SetMinimumTournamentGUID();
}
void CGolryunBattle_DBV2::ODBC_ProcessQueryResultQueue_Query_GolryunBattle_LoadLastBattle(const querySet_t& )
{
m_QueryExeMon.refcount-=1;
}
void CGolryunBattle_DBV2::ODBC_ProcessQueryResultQueue_Query_GolryunBattle_AddBattle(const querySet_t& )
{
m_QueryExeMon.refcount-=1;
}
void CGolryunBattle_DBV2::ODBC_ProcessQueryResultQueue_Query_GolryunBattle_LoadTournament(const querySet_t& )
{
m_QueryExeMon.refcount-=1;
}
void CGolryunBattle_DBV2::ODBC_ProcessQueryResultQueue_Query_GolryunBattle_SaveBattle(const querySet_t& )
{
m_QueryExeMon.refcount-=1;
}
void CGolryunBattle_DBV2::ODBC_ProcessQueryResultQueue_Query_GolryunBattle_AddTournament(const querySet_t& )
{
m_QueryExeMon.refcount-=1;
}
void CGolryunBattle_DBV2::ODBC_ProcessQueryResultQueue_Query_GolryunBattle_SaveTournament(const querySet_t& )
{
m_QueryExeMon.refcount-=1;
}
| C++ |
#include "../Global.h"
#include <windowsx.h>
#include <assert.h>
#include "tagGolryunBattle.h"
struct tagGolryunBattleVar gGolryunBattleVar;
#include "CGolryunBattle.h"
#include "CGolryunBattle_Log.h"
CGolryunBattle_Log* gcpGolryunBattleLog=NULL;
#include "CGolryunBattle_Observer.h"
CGolryunBattle_Observer* gcpGolryunBattle_Observer=NULL;
CGolryunBattle::CGolryunBattle()
{
m_bOK=FALSE;
m_cpData = NULL;
m_cpCommon = NULL;
m_cpEncoder = NULL;
m_cpDecoder = NULL;
m_cpProcess = NULL;
m_cpDBV2 = NULL;
if(FALSE == Init()) return;
m_bOK=TRUE;
}
CGolryunBattle::~CGolryunBattle()
{
if(NULL != m_cpProcess){ delete m_cpProcess; m_cpProcess=NULL; }
if(NULL != m_cpDecoder){ delete m_cpDecoder; m_cpDecoder=NULL; }
if(NULL != m_cpEncoder){ delete m_cpEncoder; m_cpEncoder=NULL; }
if(NULL != m_cpDBV2) { delete m_cpDBV2; m_cpDBV2=NULL; }
if(NULL != m_cpCommon) { delete m_cpCommon; m_cpCommon=NULL; }
if(NULL != m_cpData) { delete m_cpData; m_cpData=NULL; }
if(NULL != gcpGolryunBattleLog){ delete gcpGolryunBattleLog; gcpGolryunBattleLog=NULL; }
if(NULL != gcpGolryunBattle_Observer){ delete gcpGolryunBattle_Observer; gcpGolryunBattle_Observer=NULL; }
}
BOOL CGolryunBattle::isOK(void) const
{
return m_bOK;
}
BOOL CGolryunBattle::Init(void)
{
if(FALSE == LoadServerConfigFile()) return FALSE;
gcpGolryunBattle_Observer=new CGolryunBattle_Observer();
if(NULL == gcpGolryunBattle_Observer) return FALSE;
if(FALSE == gcpGolryunBattle_Observer->isOK()){ delete gcpGolryunBattle_Observer; gcpGolryunBattle_Observer=NULL; return FALSE; }
gcpGolryunBattleLog=new CGolryunBattle_Log();
if(NULL == gcpGolryunBattleLog) return FALSE;
if(FALSE == gcpGolryunBattleLog->isOK()){ delete gcpGolryunBattleLog; gcpGolryunBattleLog=NULL; return FALSE; }
m_cpCommon= new CGolryunBattle_Common();
if(NULL == m_cpCommon) return FALSE;
if(FALSE == m_cpCommon->isOK()){ delete m_cpCommon; m_cpCommon=NULL; return FALSE; }
m_cpData= new CGolryunBattle_Data();
if(NULL == m_cpData) return FALSE;
if(FALSE == m_cpData->isOK()){ delete m_cpData; m_cpData=NULL; return FALSE; }
m_cpDBV2 = new CGolryunBattle_DBV2();
if(NULL == m_cpDBV2) return FALSE;
if(FALSE == m_cpDBV2->isOK()){ delete m_cpDBV2; m_cpDBV2=NULL; return FALSE; }
m_cpEncoder= new CGolryunBattle_Encoder(m_cpData);
if(NULL == m_cpEncoder) return FALSE;
if(FALSE == m_cpEncoder->isOK()){ delete m_cpEncoder; m_cpEncoder=NULL; return FALSE; }
m_cpProcess=new CGolryunBattle_Process(m_cpDBV2,m_cpData,m_cpEncoder);
if(NULL == m_cpProcess) return FALSE;
if(FALSE == m_cpProcess->isOK()){ delete m_cpProcess; m_cpProcess=NULL; return FALSE; }
m_cpEncoder->SetProcessClassPointer(m_cpProcess);
m_cpDecoder= new CGolryunBattle_Decoder(m_cpDBV2,m_cpEncoder,m_cpProcess);
if(NULL == m_cpDecoder) return FALSE;
if(FALSE == m_cpDecoder->isOK()){ delete m_cpDecoder; m_cpDecoder=NULL; return FALSE; }
gcpGolryunBattleLog->Write("GolryunBattle Start....");
return TRUE;
}
void CGolryunBattle::GTH_ProcessGBBattleSys()
{
m_cpProcess->UpdateHandleStatus();
gcpGolryunBattleLog->Update();
m_cpDBV2->Process();
}
CGolryunBattle_Data* CGolryunBattle::GetDataClassPointer(void) const
{
return m_cpData;
}
CGolryunBattle_Common* CGolryunBattle::GetCommonClassPointer(void) const
{
return m_cpCommon;
}
CGolryunBattle_Encoder* CGolryunBattle::GetEncoderClassPointer(void) const
{
return m_cpEncoder;
}
CGolryunBattle_Process* CGolryunBattle::GetProcessClassPointer(void) const
{
return m_cpProcess;
}
CGolryunBattle_Decoder* CGolryunBattle::GetDecoderClassPointer(void) const
{
return m_cpDecoder;
}
CGolryunBattle_DBV2* CGolryunBattle::GetDBV2ClassPointer(void) const
{
return m_cpDBV2;
}
BOOL CGolryunBattle::LoadServerConfigFile(void)
{
gGolryunBattleVar.Log.bOutput=FALSE;
gGolryunBattleVar.Log.UpdateTimeMiliSecond=1 * 1000;
gGolryunBattleVar.GOLRYUNBATTLE_BEFORE_MATCH_WAIT_TIME= 5 * 1000;
gGolryunBattleVar.GOLRYUNBATTLE_CEREMONY_WAIT_TIME= 20 * 1000;
int size;
char *token;
char* pFileBuffer=NULL;
{
FILE* fp = NULL;
fp = fopen( "server.cfg" , "rb" );
if(NULL == fp) return FALSE;
fseek(fp,0,SEEK_END);
size = ftell(fp);
pFileBuffer=(char*)GlobalAllocPtr(GMEM_FIXED,sizeof(char) * size);
if(NULL == pFileBuffer){
if(NULL != fp){ fclose(fp); fp=NULL; }
return FALSE;
}
fseek(fp,0,SEEK_SET);
fread(pFileBuffer,size,1,fp);
if(NULL != fp){ fclose(fp); fp=NULL; }
}
curpos = pFileBuffer;
endpos = curpos + size;
while((token = NextToken()) != NULL) {
if(0 == stricmp(token,"GOLRYUNBATTLE_LOG_OUTPUT")){
char* pTemp = NextArg();
if((NULL != strstr("yes",pTemp)) || (NULL != strstr("YES",pTemp)))
gGolryunBattleVar.Log.bOutput=TRUE;
else gGolryunBattleVar.Log.bOutput=FALSE;
continue;
}
if(0 == stricmp(token,"GOLRYUNBATTLE_LOG_UPDATE_MILISECOND")){
gGolryunBattleVar.Log.UpdateTimeMiliSecond = atoi(NextArg());
continue;
}
if(0 == stricmp(token,"GOLRYUNBATTLE_BEFORE_MATCH_WAIT_TIME")){
gGolryunBattleVar.GOLRYUNBATTLE_BEFORE_MATCH_WAIT_TIME = atoi(NextArg());
continue;
}
if(0 == stricmp(token,"GOLRYUNBATTLE_CEREMONY_WAIT_TIME")){
gGolryunBattleVar.GOLRYUNBATTLE_CEREMONY_WAIT_TIME = atoi(NextArg());
continue;
}
}
if(NULL != pFileBuffer){ GlobalFreePtr(pFileBuffer); pFileBuffer=NULL; }
return TRUE;
}
| C++ |
#include "..\global.h"
#include "tagGolryunBattle.h"
#include "CGolryunBattle.h"
extern CGolryunBattle* gcpGolryunBattle;
#include "CGolryunBattle_Data.h"
#include "CGolryunBattle_Process.h"
#include "CGolryunBattle_Encoder.h"
#include "CGolryunBattle_Common.h"
#include "..\Tools\CTools.h"
extern CTools* gcpTools;
CGolryunBattle_Encoder::CGolryunBattle_Encoder(CGolryunBattle_Data* cpData)
{
m_bOK=FALSE;
m_cpData = cpData;
m_bOK=TRUE;
}
CGolryunBattle_Encoder::~CGolryunBattle_Encoder()
{
}
BOOL CGolryunBattle_Encoder::isOK(void) const
{
return m_bOK;
}
void CGolryunBattle_Encoder::
SendErrorCode(i3socket_t* sock,
const BYTE eCode,
enum tagGolryunBattlePacket_GB_ERROR_CODE::enumCode eType) const
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_GB_BATTLE);
MSG_WriteByte(&netMessage, tagGolryunBattlePacket::GB_ERROR_CODE);
MSG_WriteByte(&netMessage, eCode);
MSG_WriteByte(&netMessage, eType);
NET_SendMessage( sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CGolryunBattle_Encoder::SendTrasportGolryun(i3socket_t* sock)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_GB_BATTLE);
MSG_WriteByte(&netMessage, tagGolryunBattlePacket::GB_TRANS_GOLRYUN);
MSG_WriteShort(&netMessage, (gcpGolryunBattle->GetProcessClassPointer())->m_iTournamentIdx);
MSG_WriteShort(&netMessage, m_cpData->m_iBattleGUID);
NET_SendMessage( sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CGolryunBattle_Encoder::SendTrasportArayan(i3socket_t* sock)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_GB_BATTLE);
MSG_WriteByte(&netMessage, tagGolryunBattlePacket::GB_TRANS_ARAYAN);
NET_SendMessage( sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CGolryunBattle_Encoder::SendSuggestBattle(i3socket_t* sock, BYTE eType)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_GB_BATTLE);
MSG_WriteByte(&netMessage, tagGolryunBattlePacket::GB_SUGGEST_BATTLE);
MSG_WriteByte(&netMessage, eType);
MSG_WriteShort(&netMessage, m_cpData->m_iBattleGUID);
MSG_WriteShort(&netMessage, m_cpProcess->m_iTournamentIdx);
NET_SendMessage( sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CGolryunBattle_Encoder::SendOpenBattleTicket(i3socket_t* sock, BYTE eType)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_GB_BATTLE);
MSG_WriteByte(&netMessage, tagGolryunBattlePacket::GB_OPEN_BATTLE_TICKET);
MSG_WriteByte(&netMessage, eType);
if(eType)
{
MSG_WriteShort(&netMessage, m_cpProcess->m_iTournamentGUID);
MSG_WriteShort(&netMessage, m_cpData->m_iBattleGUID);
MSG_WriteShort(&netMessage, m_cpProcess->m_iTournamentIdx);
if(m_cpProcess->m_Ticket.iFighterNum>tagGolryunBattle::Max_Num_Fighter_Per_Tournament)
{
m_cpProcess->m_Ticket.iFighterNum = tagGolryunBattle::Max_Num_Fighter_Per_Tournament;
}
MSG_WriteShort(&netMessage, m_cpProcess->m_Ticket.iFighterNum);
struct CGolryunBattle_Process::tagFightPlayerInfo* pTempFighter=NULL;
for(int idx=0; idx < m_cpProcess->m_Ticket.iFighterNum; idx++){
pTempFighter = m_cpProcess->GetFighterPointer(idx);
if(NULL == pTempFighter) continue;
MSG_WriteShort(&netMessage, idx+1);
MSG_WriteByte(&netMessage, pTempFighter->Job);
MSG_WriteShort(&netMessage, pTempFighter->Record.win);
MSG_WriteShort(&netMessage, pTempFighter->Record.lose);
if(m_cpProcess->m_Ticket.Fighter[idx].fShareRate < 1.1f)
m_cpProcess->m_Ticket.Fighter[idx].fShareRate = 1.1f;
MSG_WriteFloat(&netMessage, m_cpProcess->m_Ticket.Fighter[idx].fShareRate);
}
}
NET_SendMessage( sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CGolryunBattle_Encoder::SendOpenShareWin(i3socket_t* sock)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_GB_BATTLE);
MSG_WriteByte(&netMessage, tagGolryunBattlePacket::GB_OPEN_SHARE_WIN);
MSG_WriteShort(&netMessage, m_cpData->m_iBattleGUID);
for(int idx=0; idx<tagGolryunBattle::Max_Num_Tournament_Per_Battle; idx++)
{
MSG_WriteByte(&netMessage, m_cpData->m_Tournament[idx].bComplete);
MSG_WriteShort(&netMessage, m_cpData->m_Tournament[idx].iTournamentGUID);
MSG_WriteShort(&netMessage, m_cpData->m_Tournament[idx].FirstWinner.FightNum);
MSG_WriteFloat(&netMessage, m_cpData->m_Tournament[idx].TwoGyun.fShareRate);
}
int record_strat_idx = m_cpData->m_iBattleGUID - tagGolryunBattle::Max_Num_Battle_Record;
if(record_strat_idx<=0) record_strat_idx = 0;
CGolryunBattle_DBV2* cpDBV2=gcpGolryunBattle->GetDBV2ClassPointer();
struct CGolryunBattle_DBV2::tagBattle* pBattleRecord=NULL;
for(int recordIdx = record_strat_idx; recordIdx<m_cpData->m_iBattleGUID; recordIdx++)
{
pBattleRecord=cpDBV2->GetBattleRecordPointer(recordIdx);
if(NULL == pBattleRecord) continue;
for(int idx=0; idx<tagGolryunBattle::Max_Num_Tournament_Per_Battle; idx++)
{
MSG_WriteShort(&netMessage, pBattleRecord->nGUID);
MSG_WriteByte(&netMessage, pBattleRecord->Tournament[idx].bComplete);
MSG_WriteShort(&netMessage, pBattleRecord->Tournament[idx].nGUID);
MSG_WriteShort(&netMessage, pBattleRecord->Tournament[idx].firstWinner.Num);
MSG_WriteFloat(&netMessage, pBattleRecord->Tournament[idx].TwoGyun.Rate);
}
}
NET_SendMessage( sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CGolryunBattle_Encoder::SendBuyBattleTicket(playerCharacter_t* pPlayer)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_GB_BATTLE);
MSG_WriteByte(&netMessage, tagGolryunBattlePacket::GB_BUY_BATTLE_TICKET);
MSG_WriteLong(&netMessage, pPlayer->curChargeSE);
NET_SendMessage( &pPlayer->sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CGolryunBattle_Encoder::SendTwoGyunTotalNak(playerCharacter_t* pPlayer)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_GB_BATTLE);
MSG_WriteByte(&netMessage, tagGolryunBattlePacket::GB_TWOGYUN_TOTAL_NAK);
MSG_WriteLong(&netMessage, m_cpProcess->m_Ticket.iTotalNak);
NET_SendMessage( &pPlayer->sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CGolryunBattle_Encoder::SendPacketMatchTimePerSecond(playerCharacter_t* pPlayer, const int time)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_GB_BATTLE);
MSG_WriteByte(&netMessage, tagGolryunBattlePacket::GB_MATCH_PROGRESS_TIME);
MSG_WriteLong(&netMessage, time);
NET_SendMessage( &pPlayer->sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CGolryunBattle_Encoder::SendShareRate(playerCharacter_t* pPlayer)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_GB_BATTLE);
MSG_WriteByte(&netMessage, tagGolryunBattlePacket::GB_SHARE_RATE);
for(int i=0; i< tagGolryunBattle::Max_Num_Fighter_Per_Tournament; i++)
{
if(m_cpProcess->m_Ticket.Fighter[i].fShareRate < 1.1f)
m_cpProcess->m_Ticket.Fighter[i].fShareRate = 1.1f;
MSG_WriteFloat(&netMessage, m_cpProcess->m_Ticket.Fighter[i].fShareRate);
}
NET_SendMessage( &pPlayer->sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CGolryunBattle_Encoder::SendReNewShareRate(playerCharacter_t* pPlayer)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_GB_BATTLE);
MSG_WriteByte(&netMessage, tagGolryunBattlePacket::GB_RENEW_BATTLE_TICKET);
NET_SendMessage( &pPlayer->sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CGolryunBattle_Encoder::SendDisplayTournament(i3socket_t* sock)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_GB_BATTLE);
MSG_WriteByte(&netMessage, tagGolryunBattlePacket::GB_DISPLAY_TOURNAMENT);
MSG_WriteShort(&netMessage, (gcpGolryunBattle->GetProcessClassPointer())->m_iTournamentIdx);
for(int TournamentIdx=0; TournamentIdx < tagGolryunBattle::Max_Num_Tournament_Per_Battle; TournamentIdx++)
{
MSG_WriteByte(&netMessage, m_cpData->m_Tournament[TournamentIdx].bComplete);
MSG_WriteShort(&netMessage, m_cpData->m_Tournament[TournamentIdx].FirstWinner.FightNum);
}
struct CGolryunBattle_Data::tagMatch* pMatch=NULL;
for(int MatchIdx=0; MatchIdx < tagGolryunBattle::Max_Num_Match_Per_Tournament; MatchIdx++)
{
pMatch = m_cpProcess->GetMatchPointer(MatchIdx);
MSG_WriteByte(&netMessage,pMatch->bComplete);
MSG_WriteShort(&netMessage, pMatch->RedCornerFighter.FightNum);
if(pMatch->WinnerCorner == CGolryunBattle_Data::tagMatch::enumCorner::Red) MSG_WriteByte(&netMessage,1);
else MSG_WriteByte(&netMessage,0);
MSG_WriteShort(&netMessage, pMatch->BlueCornerFighter.FightNum);
if(pMatch->WinnerCorner == CGolryunBattle_Data::tagMatch::enumCorner::Blue) MSG_WriteByte(&netMessage,1);
else MSG_WriteByte(&netMessage,0);
}
pMatch=m_cpProcess->GetMatchPointer(14);
switch(pMatch->WinnerCorner){
case CGolryunBattle_Data::tagMatch::enumCorner::Red:
MSG_WriteShort(&netMessage, pMatch->RedCornerFighter.FightNum);
break;
case CGolryunBattle_Data::tagMatch::enumCorner::Blue:
MSG_WriteShort(&netMessage, pMatch->BlueCornerFighter.FightNum);
break;
case CGolryunBattle_Data::tagMatch::enumCorner::None:
MSG_WriteShort(&netMessage, -1);
break;
}
NET_SendMessage( sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CGolryunBattle_Encoder::SendCheckPrize(i3socket_t* sock)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_GB_BATTLE);
MSG_WriteByte(&netMessage, tagGolryunBattlePacket::GB_CHECK_PRIZE);
for(int i=0; i<tagGolryunBattle::Max_Num_Prize_List_Per_Battle; i++)
{
MSG_WriteShort(&netMessage, m_cpData->m_EntranceTicket.LotteryGUIDList[i]);
}
NET_SendMessage( sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CGolryunBattle_Encoder::SendObserveStart(playerCharacter_t* pToPlayer,const BOOL bSuccess)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_GB_BATTLE);
MSG_WriteByte(&netMessage, tagGolryunBattlePacket::GB_OBSERVE_START);
MSG_WriteByte(&netMessage, bSuccess);
NET_SendMessage( &(pToPlayer->sock), &netMessage);
MSG_EndWriting(&netMessage);
}
void CGolryunBattle_Encoder::SendObserveMatchTime(playerCharacter_t* pToPlayer,const int time)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_GB_BATTLE);
MSG_WriteByte(&netMessage, tagGolryunBattlePacket::GB_OBSERVE_MATCH_TIME);
MSG_WriteLong(&netMessage, time);
NET_SendMessage( &(pToPlayer->sock), &netMessage);
MSG_EndWriting(&netMessage);
}
void CGolryunBattle_Encoder::SendEffectCount(i3socket_t* sock, int angle)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_GB_BATTLE);
MSG_WriteByte(&netMessage, tagGolryunBattlePacket::GB_REQUEST_START_COUNT);
MSG_WriteShort(&netMessage, angle);
NET_SendMessage( sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CGolryunBattle_Encoder::SendEffectResult(i3socket_t* sock, int index)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_GB_BATTLE);
MSG_WriteByte(&netMessage, tagGolryunBattlePacket::GB_EFFECT_RESULT);
MSG_WriteShort(&netMessage, index);
NET_SendMessage( sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CGolryunBattle_Encoder::SendStartMatch(i3socket_t* sock, const int time)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_GB_BATTLE);
MSG_WriteByte(&netMessage, tagGolryunBattlePacket::GB_REQUEST_PROGRESS_MATCH);
MSG_WriteLong(&netMessage, time);
NET_SendMessage( sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CGolryunBattle_Encoder::Send_GB_BATTLE_RASA_Sync(playerCharacter_t* pPlayer)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_GB_BATTLE);
MSG_WriteByte(&netMessage, tagGolryunBattlePacket::GB_BATTLE_RASA_Sync);
MSG_WriteLong(&netMessage, (int)pPlayer->curRA);
MSG_WriteShort(&netMessage, (int)pPlayer->curSA);
MSG_WriteLong(&netMessage, (int)pPlayer->calMaxRA);
MSG_WriteShort(&netMessage, (int)pPlayer->calMaxSA);
NET_SendMessage(&pPlayer->sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CGolryunBattle_Encoder::SendEndMatchNotice(void)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_GB_BATTLE);
MSG_WriteByte(&netMessage, tagGolryunBattlePacket::GB_END_MATCH_NOTICE);
playerCharacter_t* pTempPlayer=NULL;
for(int pcIdx = 0; pcIdx < MAX_PCS; pcIdx++ ){
pTempPlayer = gcpTools->GetPlayerRecordPointer(pcIdx);
if(NULL == pTempPlayer) continue;
if((pTempPlayer->worldIdx != tagGolryunBattle::Golryun_Battle_Map_Index) && (pTempPlayer->worldIdx != 0)) continue;
NET_SendMessage(&pTempPlayer->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CGolryunBattle_Encoder::SendStartMatchNotice(playerCharacter_t* pPlayer, int redNum, int blueNum)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_GB_BATTLE);
MSG_WriteByte(&netMessage, tagGolryunBattlePacket::GB_START_MATCH_NOTICE);
MSG_WriteShort(&netMessage, redNum);
MSG_WriteShort(&netMessage, blueNum);
NET_SendMessage(&pPlayer->sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CGolryunBattle_Encoder::
SendEndMatch(i3socket_t* sock,enum tagGolryunBattlePacket_GB_REQUEST_END_MATCH::enumCode code)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_GB_BATTLE);
MSG_WriteByte(&netMessage, tagGolryunBattlePacket::GB_REQUEST_END_MATCH);
NET_SendMessage( sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CGolryunBattle_Encoder::SendCancelTournament(i3socket_t* sock)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_GB_BATTLE);
MSG_WriteByte(&netMessage, tagGolryunBattlePacket::GB_REQUEST_CANCEL_TOURNAMENT);
NET_SendMessage( sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CGolryunBattle_Encoder::SendJoinNumber(playerCharacter_t* pPlayer)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_GB_BATTLE);
MSG_WriteByte(&netMessage, tagGolryunBattlePacket::GB_REQUEST_START_BETTING);
MSG_WriteShort(&netMessage, pPlayer->GonryunBattle.m_iJoinNum);
NET_SendMessage( &pPlayer->sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CGolryunBattle_Encoder::SendCheckJoinerNum(i3socket_t* sock, int num)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_GB_BATTLE);
MSG_WriteByte(&netMessage, tagGolryunBattlePacket::GB_CHECK_JOINER_NUM);
MSG_WriteShort(&netMessage, num);
NET_SendMessage( sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CGolryunBattle_Encoder::SendStatusMatchNotice(i3socket_t* sock, int noticeIdx)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_GB_BATTLE);
MSG_WriteByte(&netMessage, tagGolryunBattlePacket::GB_STATUS_MATCH_NOTICE);
MSG_WriteShort(&netMessage, noticeIdx);
NET_SendMessage( sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CGolryunBattle_Encoder::SendNoticeBattle(i3socket_t* sock, char* notice)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_GB_BATTLE);
MSG_WriteByte(&netMessage, tagGolryunBattlePacket::GB_NOTICE_BATTLE);
MSG_WriteString(&netMessage, notice);
NET_SendMessage( sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CGolryunBattle_Encoder::
SendObserveEnd(playerCharacter_t* pToPlayer,const BOOL bSuccess)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_GB_BATTLE);
MSG_WriteByte(&netMessage, tagGolryunBattlePacket::GB_OBSERVE_END);
MSG_WriteByte(&netMessage, bSuccess);
NET_SendMessage( &pToPlayer->sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CGolryunBattle_Encoder::SendLocalUserNotice(i3socket_t* sock, int lpackIdx)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_GB_BATTLE);
MSG_WriteByte(&netMessage, tagGolryunBattlePacket::GB_LOCAL_USER_NOTICE);
MSG_WriteShort(&netMessage, lpackIdx);
NET_SendMessage( sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CGolryunBattle_Encoder::SendAllUserData(i3socket_t* sock)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_GB_BATTLE);
MSG_WriteByte(&netMessage, tagGolryunBattlePacket::GB_ALL_USER_DATA);
MSG_WriteShort(&netMessage, (gcpGolryunBattle->GetProcessClassPointer())->m_iTournamentIdx);
NET_SendMessage( sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CGolryunBattle_Encoder::ManagerNoticeBattle(char* notice)
{
playerCharacter_t* pTempPlayer=NULL;
for(int pcIdx = 0; pcIdx < MAX_PCS; pcIdx++)
{
pTempPlayer = gcpTools->GetPlayerRecordPointer(pcIdx);
if(NULL == pTempPlayer) continue;
if((pTempPlayer->worldIdx != 21) && (pTempPlayer->worldIdx != 0)) continue;
SendNoticeBattle(&pTempPlayer->sock, notice);
}
ShowLogInfo("SendNoticeBattle()");
}
void CGolryunBattle_Encoder::ManagerLocalUserNotice(int lpackIdx)
{
playerCharacter_t* pTempPlayer=NULL;
for(int pcIdx = 0; pcIdx < MAX_PCS; pcIdx++)
{
pTempPlayer = gcpTools->GetPlayerRecordPointer(pcIdx);
if(NULL == pTempPlayer) continue;
if((pTempPlayer->worldIdx != 21) && (pTempPlayer->worldIdx != 0)) continue;
SendLocalUserNotice(&pTempPlayer->sock, lpackIdx);
}
ShowLogInfo("SendLocalUserNotice()");
}
void CGolryunBattle_Encoder::ManagerAllUserData()
{
playerCharacter_t* pTempPlayer=NULL;
for(int pcIdx = 0; pcIdx < MAX_PCS; pcIdx++)
{
pTempPlayer = gcpTools->GetPlayerRecordPointer(pcIdx);
if(NULL == pTempPlayer) continue;
SendAllUserData(&pTempPlayer->sock);
}
ShowLogInfo("SendAllUserData()");
}
void CGolryunBattle_Encoder::SetProcessClassPointer(CGolryunBattle_Process* cpProcess)
{
m_cpProcess = cpProcess;
}
void CGolryunBattle_Encoder::SendMessageToGM(const int LpackIdx)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_GB_BATTLE);
MSG_WriteByte(&netMessage, tagGolryunBattlePacket::GB_GM_NOTICE);
MSG_WriteLong(&netMessage, LpackIdx);
playerCharacter_t* pTempPlayer=NULL;
for(int pcIdx = 0; pcIdx < MAX_PCS; pcIdx++ ){
pTempPlayer = gcpTools->GetPlayerRecordPointer(pcIdx);
if(NULL == pTempPlayer) continue;
if((pTempPlayer->worldIdx != tagGolryunBattle::Golryun_Battle_Map_Index)) continue;
if(!pTempPlayer->gameMaster) continue;
NET_SendMessage( &pTempPlayer->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
| C++ |
#include "global.h"
#include "CPremiumPlayerCtrl.h"
CPremiumPlayerCtrl::CPremiumPlayerCtrl()
{
m_bOK=FALSE;
if(FALSE == LoadIniFile()) return;
m_bOK=TRUE;
}
CPremiumPlayerCtrl::~CPremiumPlayerCtrl()
{
}
BOOL CPremiumPlayerCtrl::isOK(void) const
{
return m_bOK;
}
BOOL CPremiumPlayerCtrl::LoadIniFile(void)
{
char szWorkDir[_MAX_PATH];
::GetCurrentDirectory(_MAX_PATH,szWorkDir);
char szIniFileName[_MAX_PATH];
wsprintf(szIniFileName,"%s\\free.Premium.ini",szWorkDir);
m_PremiumLevelTable[playerCharacter_t::tagPremiumInfo::enumMeberShipType::Free].iMemberShipType=
playerCharacter_t::tagPremiumInfo::enumMeberShipType::Free;
LoadIniFile(szIniFileName,&m_PremiumLevelTable[playerCharacter_t::tagPremiumInfo::enumMeberShipType::Free]);
wsprintf(szIniFileName,"%s\\pay.Premium.ini",szWorkDir);
m_PremiumLevelTable[playerCharacter_t::tagPremiumInfo::enumMeberShipType::Pay].iMemberShipType=
playerCharacter_t::tagPremiumInfo::enumMeberShipType::Pay;
LoadIniFile(szIniFileName,&m_PremiumLevelTable[playerCharacter_t::tagPremiumInfo::enumMeberShipType::Pay]);
return TRUE;
}
BOOL CPremiumPlayerCtrl::
isAccessMap(const int MapIdx,const playerCharacter_t* pPlayerRecord) const
{
if(MapIdx < 0) return FALSE;
if(MapIdx > playerCharacter_t::tagPremiumInfo::maxmap_number) return FALSE;
return pPlayerRecord->PremiumInfo.Map[MapIdx].Cur.bAllow;
}
void CPremiumPlayerCtrl::
SetData(enum playerCharacter_t::tagPremiumInfo::enumMeberShipType MemberShipType,playerCharacter_t* pPlayerRecord) const
{
switch(MemberShipType){
default:
case playerCharacter_t::tagPremiumInfo::enumMeberShipType::Free:
memcpy(&(pPlayerRecord->PremiumInfo),
&(m_PremiumLevelTable[playerCharacter_t::tagPremiumInfo::enumMeberShipType::Free]),
sizeof(struct playerCharacter_t::tagPremiumInfo));
return;
case playerCharacter_t::tagPremiumInfo::enumMeberShipType::Pay:
memcpy(&(pPlayerRecord->PremiumInfo),
&(m_PremiumLevelTable[playerCharacter_t::tagPremiumInfo::enumMeberShipType::Pay]),
sizeof(struct playerCharacter_t::tagPremiumInfo));
return;
}
}
void CPremiumPlayerCtrl::Init_PremiumLevelTable_Pay(void)
{
struct playerCharacter_t::tagPremiumInfo* pPremium = &(m_PremiumLevelTable[playerCharacter_t::tagPremiumInfo::enumMeberShipType::Pay]);
memset(pPremium,0x00,sizeof(struct playerCharacter_t::tagPremiumInfo));
pPremium->iMemberShipType = playerCharacter_t::tagPremiumInfo::enumMeberShipType::Pay;
for(int idx=0; idx < playerCharacter_t::tagPremiumInfo::maxmap_number; idx++){
pPremium->Map[idx].Default.bAllow = TRUE;
pPremium->Map[idx].Default.iRemainSecond=0x7fffffff;
pPremium->Map[idx].Default.bDecreseRemainSecond=FALSE;
pPremium->Map[idx].Default.bDecreseAllRemainSecond = FALSE;
pPremium->Map[idx].Default.fAddExpRatio = 1.0f;
pPremium->Map[idx].Default.fAddGenExpRatio = 1.0f;
pPremium->Map[idx].Default.fAddGenCapabilityRatio=1.0f;
pPremium->Map[idx].Default.fAddItemDropRatio = 1.0f;
pPremium->Map[idx].Default.fAddNarkRatio = 1.0f;
pPremium->Map[idx].Cur = pPremium->Map[idx].Default;
}
pPremium->Gamble.fAddPriceRatio = 1.0f;
for(idx=0; idx < playerCharacter_t::tagPremiumInfo::tagGamble::maxnum_apperance_item_group; idx++){
pPremium->Gamble.ItemGroupArray[idx].bApperance=TRUE;
}
pPremium->ItemOptionUpgrade.iMaxlevel = 10;
pPremium->ItemOptionUpgrade.fAddPriceRatio = 1.0f;
pPremium->Die.fExpRatio = 1.0f;
pPremium->Die.fNakRatio = 1.0f;
pPremium->bCreatePremiumBooth = FALSE;
pPremium->iMaxLevelItemCraft = 10;
pPremium->fItemPrecocityTimeRatio = 1.0f;
pPremium->bItemRecycle = TRUE;
pPremium->GonyounPracticeBattle.lDateV2 = time(NULL);
pPremium->GonyounPracticeBattle.iMaxCount = 5;
pPremium->GonyounPracticeBattle.iDecreseCount = pPremium->GonyounPracticeBattle.iMaxCount;
pPremium->WorldChatting.lDate = 0;
pPremium->WorldChatting.iMaxCount = 10000;
pPremium->WorldChatting.iDecreaseCount = pPremium->WorldChatting.iMaxCount;
pPremium->Status.iDefaultInitCount= 1;
pPremium->Status.iInitCount=1000;
pPremium->ItemDurability.fRepareCostRate = 1.0f;
pPremium->ItemDurability.iPrepareRequirdurability = 0;
}
char* GetFLOATString(const float fValue)
{
static char str[20];
sprintf(str,"%3.02f",fValue);
return str;
}
char* GetINTString(const int iValue)
{
static char str[20];
wsprintf((char*)str,"%d",iValue);
return str;
}
char* GetBOOLString(const BOOL bIs)
{
static char str[2][10]={"YES","NO"};
if(TRUE == bIs) return str[0];
return str[1];
}
void CPremiumPlayerCtrl::Init_PremiumLevelTable_Free(void)
{
char szWorkDir[_MAX_PATH];
::GetCurrentDirectory(_MAX_PATH,szWorkDir);
char szIniFileName[_MAX_PATH];
wsprintf(szIniFileName,"%s\\free.Premium.ini",szWorkDir);
char AppName[_MAX_PATH];
char Session[_MAX_PATH];
struct playerCharacter_t::tagPremiumInfo* pPremium = &(m_PremiumLevelTable[playerCharacter_t::tagPremiumInfo::enumMeberShipType::Free]);
memset(pPremium,0x00,sizeof(struct playerCharacter_t::tagPremiumInfo));
pPremium->iMemberShipType = playerCharacter_t::tagPremiumInfo::enumMeberShipType::Free;
for(int idx=0; idx < playerCharacter_t::tagPremiumInfo::maxmap_number; idx++){
wsprintf(AppName,"Map%02d",idx);
pPremium->Map[idx].Default.bAllow = TRUE;
::WritePrivateProfileString(AppName,"Allow",GetBOOLString(pPremium->Map[idx].Default.bAllow),szIniFileName);
pPremium->Map[idx].Default.iRemainSecond=0x7fffffff;
::WritePrivateProfileString(AppName,"iRemainSecond",GetINTString(pPremium->Map[idx].Default.iRemainSecond),szIniFileName);
pPremium->Map[idx].Default.bDecreseRemainSecond=FALSE;
::WritePrivateProfileString(AppName,"bDecreseRemainSecond",GetBOOLString(pPremium->Map[idx].Default.bDecreseRemainSecond),szIniFileName);
pPremium->Map[idx].Default.bDecreseAllRemainSecond = FALSE;
::WritePrivateProfileString(AppName,"bDecreseAllRemainSecond",GetBOOLString(pPremium->Map[idx].Default.bDecreseAllRemainSecond),szIniFileName);
pPremium->Map[idx].Default.fAddExpRatio = 1.0f;
::WritePrivateProfileString(AppName,"fAddExpRatio",GetFLOATString(pPremium->Map[idx].Default.fAddExpRatio),szIniFileName);
pPremium->Map[idx].Default.fAddGenExpRatio = 1.0f;
::WritePrivateProfileString(AppName,"fAddGenExpRatio",GetFLOATString(pPremium->Map[idx].Default.fAddGenExpRatio),szIniFileName);
pPremium->Map[idx].Default.fAddGenCapabilityRatio=1.0f;
::WritePrivateProfileString(AppName,"fAddGenCapabilityRatio",GetFLOATString(pPremium->Map[idx].Default.fAddGenCapabilityRatio),szIniFileName);
pPremium->Map[idx].Default.fAddItemDropRatio = 1.0f;
::WritePrivateProfileString(AppName,"fAddItemDropRatio",GetFLOATString(pPremium->Map[idx].Default.fAddItemDropRatio),szIniFileName);
pPremium->Map[idx].Default.fAddNarkRatio = 1.0f;
::WritePrivateProfileString(AppName,"fAddNarkRatio",GetFLOATString(pPremium->Map[idx].Default.fAddNarkRatio),szIniFileName);
pPremium->Map[idx].Cur = pPremium->Map[idx].Default;
}
pPremium->Map[Light_Lake].Cur.bAllow=FALSE;
wsprintf(AppName,"Gameble");
pPremium->Gamble.fAddPriceRatio = 1.0f;
::WritePrivateProfileString(AppName,"fAddPriceRatio",GetFLOATString(pPremium->Gamble.fAddPriceRatio),szIniFileName);
for(idx=0; idx < playerCharacter_t::tagPremiumInfo::tagGamble::maxnum_apperance_item_group; idx++){
wsprintf(Session,"Group%02d",idx);
pPremium->Gamble.ItemGroupArray[idx].bApperance=TRUE;
::WritePrivateProfileString(AppName,Session,GetBOOLString(pPremium->Gamble.ItemGroupArray[idx].bApperance),szIniFileName);
}
wsprintf(AppName,"ItemOptionUpgrade");
pPremium->ItemOptionUpgrade.iMaxlevel = 10;
::WritePrivateProfileString(AppName,"iMaxlevel",GetINTString(pPremium->ItemOptionUpgrade.iMaxlevel),szIniFileName);
pPremium->ItemOptionUpgrade.fAddPriceRatio = 1.0f;
::WritePrivateProfileString(AppName,"fAddPriceRatio",GetFLOATString(pPremium->ItemOptionUpgrade.fAddPriceRatio),szIniFileName);
wsprintf(AppName,"Die");
pPremium->Die.fExpRatio = 1.0f;
::WritePrivateProfileString(AppName,"fExpRatio",GetFLOATString(pPremium->Die.fExpRatio),szIniFileName);
pPremium->Die.fNakRatio = 1.0f;
::WritePrivateProfileString(AppName,"fNakRatio",GetFLOATString(pPremium->Die.fNakRatio),szIniFileName);
pPremium->bCreatePremiumBooth = FALSE;
::WritePrivateProfileString("PremiumBooth","Use",GetBOOLString(pPremium->bCreatePremiumBooth),szIniFileName);
pPremium->iMaxLevelItemCraft = 10;
::WritePrivateProfileString("ItemCraft","iMaxLevel",GetINTString(pPremium->iMaxLevelItemCraft),szIniFileName);
pPremium->fItemPrecocityTimeRatio = 1.0f;
::WritePrivateProfileString("ItemPrecocity","TimeRatio",GetFLOATString(pPremium->fItemPrecocityTimeRatio),szIniFileName);
pPremium->bItemRecycle = TRUE;
::WritePrivateProfileString("ItemRecycle","Use",GetBOOLString(pPremium->bItemRecycle),szIniFileName);
pPremium->GonyounPracticeBattle.lDateV2 = time(NULL);
pPremium->GonyounPracticeBattle.iMaxCount = 5;
::WritePrivateProfileString("GonyounPracticeBattle","iMaxCount",GetINTString(pPremium->GonyounPracticeBattle.iMaxCount),szIniFileName);
pPremium->GonyounPracticeBattle.iDecreseCount = pPremium->GonyounPracticeBattle.iMaxCount;
pPremium->WorldChatting.lDate = time(NULL);
pPremium->WorldChatting.iMaxCount = 10;
::WritePrivateProfileString("WorldChatting","iMaxCount",GetINTString(pPremium->WorldChatting.iMaxCount),szIniFileName);
pPremium->WorldChatting.iDecreaseCount = pPremium->WorldChatting.iMaxCount;
pPremium->Status.iDefaultInitCount= 1;
::WritePrivateProfileString("Status","iDefaultInitCount",GetINTString(pPremium->Status.iDefaultInitCount),szIniFileName);
pPremium->Status.iInitCount=1000;
::WritePrivateProfileString("Status","iInitCount",GetINTString(pPremium->Status.iInitCount),szIniFileName);
pPremium->ItemDurability.fRepareCostRate = 1.0f;
::WritePrivateProfileString("Itemdurability","fAddRepareCostRate",GetINTString(pPremium->ItemDurability.fRepareCostRate),szIniFileName);
pPremium->ItemDurability.iPrepareRequirdurability = 0;
::WritePrivateProfileString("Itemdurability","iPrepareRequirdurability",GetINTString(pPremium->ItemDurability.iPrepareRequirdurability),szIniFileName);
}
BOOL GetBOOL(const char* pStr)
{
if(0 == strcmp(pStr,"YES")) return TRUE;
if(0 == strcmp(pStr,"yes")) return TRUE;
if(0 == strcmp(pStr,"Yes")) return TRUE;
return FALSE;
}
int GetINT(const char* pStr)
{
return atoi(pStr);
}
float GetFLOAT(const char* pStr)
{
return atof(pStr);
}
void CPremiumPlayerCtrl::
LoadIniFile(const char* szpIniFileName,struct playerCharacter_t::tagPremiumInfo* pPremium)
{
char AppName[_MAX_PATH];
char inStr[_MAX_PATH];
char Session[_MAX_PATH];
for(int idx=0; idx < playerCharacter_t::tagPremiumInfo::maxmap_number; idx++){
wsprintf(AppName,"Map%02d",idx);
::GetPrivateProfileString(AppName,"Allow","YES",inStr,_MAX_PATH,szpIniFileName);
pPremium->Map[idx].Default.bAllow = GetBOOL(inStr);
::GetPrivateProfileString(AppName,"iRemainSecond","2147483647",inStr,_MAX_PATH,szpIniFileName);
pPremium->Map[idx].Default.iRemainSecond=GetINT(inStr);
::GetPrivateProfileString(AppName,"bDecreseRemainSecond","NO",inStr,_MAX_PATH,szpIniFileName);
pPremium->Map[idx].Default.bDecreseRemainSecond=GetBOOL(inStr);
::GetPrivateProfileString(AppName,"bDecreseAllRemainSecond","NO",inStr,_MAX_PATH,szpIniFileName);
pPremium->Map[idx].Default.bDecreseAllRemainSecond = GetBOOL(inStr);
::GetPrivateProfileString(AppName,"fAddExpRatio","1.0f",inStr,_MAX_PATH,szpIniFileName);
pPremium->Map[idx].Default.fAddExpRatio = GetFLOAT(inStr);
::GetPrivateProfileString(AppName,"fAddGenExpRatio","1.0f",inStr,_MAX_PATH,szpIniFileName);
pPremium->Map[idx].Default.fAddGenExpRatio = GetFLOAT(inStr);
::GetPrivateProfileString(AppName,"fAddGenCapabilityRatio","1.0f",inStr,_MAX_PATH,szpIniFileName);
pPremium->Map[idx].Default.fAddGenCapabilityRatio=GetFLOAT(inStr);
::GetPrivateProfileString(AppName,"fAddItemDropRatio","1.0f",inStr,_MAX_PATH,szpIniFileName);
pPremium->Map[idx].Default.fAddItemDropRatio =GetFLOAT(inStr);
::GetPrivateProfileString(AppName,"fAddNarkRatio","1.0f",inStr,_MAX_PATH,szpIniFileName);
pPremium->Map[idx].Default.fAddNarkRatio = GetFLOAT(inStr);
pPremium->Map[idx].Cur = pPremium->Map[idx].Default;
}
wsprintf(AppName,"Gameble");
::GetPrivateProfileString(AppName,"fAddPriceRatio","1.0f",inStr,_MAX_PATH,szpIniFileName);
pPremium->Gamble.fAddPriceRatio = GetFLOAT(inStr);
for(idx=0; idx < playerCharacter_t::tagPremiumInfo::tagGamble::maxnum_apperance_item_group; idx++){
wsprintf(Session,"Group%02d",idx);
::GetPrivateProfileString(AppName,Session,"YES",inStr,_MAX_PATH,szpIniFileName);
pPremium->Gamble.ItemGroupArray[idx].bApperance=GetBOOL(inStr);
}
wsprintf(AppName,"ItemOptionUpgrade");
::GetPrivateProfileString(AppName,"iMaxlevel","10",inStr,_MAX_PATH,szpIniFileName);
pPremium->ItemOptionUpgrade.iMaxlevel = GetINT(inStr);
::GetPrivateProfileString(AppName,"fAddPriceRatio","1.0f",inStr,_MAX_PATH,szpIniFileName);
pPremium->ItemOptionUpgrade.fAddPriceRatio = GetFLOAT(inStr);
wsprintf(AppName,"Die");
::GetPrivateProfileString(AppName,"fExpRatio","1.0f",inStr,_MAX_PATH,szpIniFileName);
pPremium->Die.fExpRatio = GetFLOAT(inStr);
::GetPrivateProfileString(AppName,"fNakRatio","1.0f",inStr,_MAX_PATH,szpIniFileName);
pPremium->Die.fNakRatio = GetFLOAT(inStr);
::GetPrivateProfileString("PremiumBooth","Use","FALSE",inStr,_MAX_PATH,szpIniFileName);
pPremium->bCreatePremiumBooth = GetBOOL(inStr);
::GetPrivateProfileString("ItemCraft","iMaxLevel","10",inStr,_MAX_PATH,szpIniFileName);
pPremium->iMaxLevelItemCraft = GetINT(inStr);
::GetPrivateProfileString("ItemPrecocity","TimeRatio","1.0f",inStr,_MAX_PATH,szpIniFileName);
pPremium->fItemPrecocityTimeRatio = GetFLOAT(inStr);
::GetPrivateProfileString("ItemRecycle","Use","YES",inStr,_MAX_PATH,szpIniFileName);
pPremium->bItemRecycle = GetBOOL(inStr);
pPremium->GonyounPracticeBattle.lDateV2 = time(NULL);
::GetPrivateProfileString("GonyounPracticeBattle","iMaxCount","5",inStr,_MAX_PATH,szpIniFileName);
pPremium->GonyounPracticeBattle.iMaxCount = GetINT(inStr);
pPremium->GonyounPracticeBattle.iDecreseCount = pPremium->GonyounPracticeBattle.iMaxCount;
pPremium->WorldChatting.lDate = time(NULL);
::GetPrivateProfileString("WorldChatting","iMaxCount","10",inStr,_MAX_PATH,szpIniFileName);
pPremium->WorldChatting.iMaxCount = GetINT(inStr);
pPremium->WorldChatting.iDecreaseCount = pPremium->WorldChatting.iMaxCount;
::GetPrivateProfileString("Status","iDefaultInitCount","1",inStr,_MAX_PATH,szpIniFileName);
pPremium->Status.iDefaultInitCount= GetINT(inStr);
::GetPrivateProfileString("Status","iInitCount","1000",inStr,_MAX_PATH,szpIniFileName);
pPremium->Status.iInitCount=GetINT(inStr);
::GetPrivateProfileString("ItemDurability","fRepareCostRate","1.0f",inStr,_MAX_PATH,szpIniFileName);
pPremium->ItemDurability.fRepareCostRate = GetFLOAT(inStr);
::GetPrivateProfileString("ItemDurability","iPrepareRequirdurability","0",inStr,_MAX_PATH,szpIniFileName);
pPremium->ItemDurability.iPrepareRequirdurability = GetINT(inStr);
}
void CPremiumPlayerCtrl::SaveIniFile(const char* szpIniFileName,const struct playerCharacter_t::tagPremiumInfo* pPremium)
{
char AppName[_MAX_PATH];
char Session[_MAX_PATH];
for(int idx=0; idx < playerCharacter_t::tagPremiumInfo::maxmap_number; idx++){
wsprintf(AppName,"Map%02d",idx);
::WritePrivateProfileString(AppName,"Allow",GetBOOLString(pPremium->Map[idx].Default.bAllow),szpIniFileName);
::WritePrivateProfileString(AppName,"iRemainSecond",GetINTString(pPremium->Map[idx].Default.iRemainSecond),szpIniFileName);
::WritePrivateProfileString(AppName,"bDecreseRemainSecond",GetBOOLString(pPremium->Map[idx].Default.bDecreseRemainSecond),szpIniFileName);
::WritePrivateProfileString(AppName,"bDecreseAllRemainSecond",GetBOOLString(pPremium->Map[idx].Default.bDecreseAllRemainSecond),szpIniFileName);
::WritePrivateProfileString(AppName,"fAddExpRatio",GetFLOATString(pPremium->Map[idx].Default.fAddExpRatio),szpIniFileName);
::WritePrivateProfileString(AppName,"fAddGenExpRatio",GetFLOATString(pPremium->Map[idx].Default.fAddGenExpRatio),szpIniFileName);
::WritePrivateProfileString(AppName,"fAddGenCapabilityRatio",GetFLOATString(pPremium->Map[idx].Default.fAddGenCapabilityRatio),szpIniFileName);
::WritePrivateProfileString(AppName,"fAddItemDropRatio",GetFLOATString(pPremium->Map[idx].Default.fAddItemDropRatio),szpIniFileName);
::WritePrivateProfileString(AppName,"fAddNarkRatio",GetFLOATString(pPremium->Map[idx].Default.fAddNarkRatio),szpIniFileName);
}
wsprintf(AppName,"Gameble");
::WritePrivateProfileString(AppName,"fAddPriceRatio",GetFLOATString(pPremium->Gamble.fAddPriceRatio),szpIniFileName);
for(idx=0; idx < playerCharacter_t::tagPremiumInfo::tagGamble::maxnum_apperance_item_group; idx++){
wsprintf(Session,"Group%02d",idx);
::WritePrivateProfileString(AppName,Session,GetBOOLString(pPremium->Gamble.ItemGroupArray[idx].bApperance),szpIniFileName);
}
wsprintf(AppName,"ItemOptionUpgrade");
::WritePrivateProfileString(AppName,"iMaxlevel",GetINTString(pPremium->ItemOptionUpgrade.iMaxlevel),szpIniFileName);
::WritePrivateProfileString(AppName,"fAddPriceRatio",GetFLOATString(pPremium->ItemOptionUpgrade.fAddPriceRatio),szpIniFileName);
wsprintf(AppName,"Die");
::WritePrivateProfileString(AppName,"fExpRatio",GetFLOATString(pPremium->Die.fExpRatio),szpIniFileName);
::WritePrivateProfileString(AppName,"fNakRatio",GetFLOATString(pPremium->Die.fNakRatio),szpIniFileName);
::WritePrivateProfileString("PremiumBooth","Use",GetBOOLString(pPremium->bCreatePremiumBooth),szpIniFileName);
::WritePrivateProfileString("ItemCraft","iMaxLevel",GetINTString(pPremium->iMaxLevelItemCraft),szpIniFileName);
::WritePrivateProfileString("ItemPrecocity","TimeRatio",GetFLOATString(pPremium->fItemPrecocityTimeRatio),szpIniFileName);
::WritePrivateProfileString("ItemRecycle","Use",GetBOOLString(pPremium->bItemRecycle),szpIniFileName);
::WritePrivateProfileString("GonyounPracticeBattle","iMaxCount",GetINTString(pPremium->GonyounPracticeBattle.iMaxCount),szpIniFileName);
::WritePrivateProfileString("WorldChatting","iMaxCount",GetINTString(pPremium->WorldChatting.iMaxCount),szpIniFileName);
::WritePrivateProfileString("Status","iDefaultInitCount",GetINTString(pPremium->Status.iDefaultInitCount),szpIniFileName);
::WritePrivateProfileString("Status","iInitCount",GetINTString(pPremium->Status.iInitCount),szpIniFileName);
}
| C++ |
#if !defined(AFX_ENTITYLISTMNG_H__06F45DBA_2DB0_493D_88CC_0BEE5AAFB1D4__INCLUDED_)
#define AFX_ENTITYLISTMNG_H__06F45DBA_2DB0_493D_88CC_0BEE5AAFB1D4__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#define MAX_NUMBER_OF_ENTITY_PCLIST 5000
typedef struct
{
int idx;
int serverIdx;
int idxOnServer;
int characterID;
int serverGroupID;
int worldIdx;
int job ;
int level ;
char name[NAMESTRING];
char userID[NAMESTRING];
} entityPCList_t;
typedef std::vector<entityPCList_t *> VECTOR_ENTITYPCLIST_STRUCT;
class CEntityListMng
{
public:
entityPCList_t m_entityPCList[MAX_NUMBER_OF_ENTITY_PCLIST];
VECTOR_ENTITYPCLIST_STRUCT m_vEntityPCList;
CEntityListMng();
virtual ~CEntityListMng();
int FindPCList ( entityPCList_t * pl );
int FindPCList ( char *name, entityPCList_t * pl );
int FindEmptyPCList ()
{
for( int i = 0; i < MAX_NUMBER_OF_ENTITY_PCLIST; ++i )
{
if ( m_entityPCList[i].idx < 0 ) return i;
}
return -1;
}
void MakePCList( playerCharacter_t *pc, entityPCList_t *pl );
void AddPCList( entityPCList_t *pl );
void DeletePCList( entityPCList_t *pl );
void UpdatePCList( entityPCList_t *pl );
int GetPCListNumber() { return( m_vEntityPCList.size() ); }
};
#endif
| C++ |
#if !defined(AFX_USEITEM_H__34296A00_0E39_4F37_A5E5_A95C7017A68A__INCLUDED_)
#define AFX_USEITEM_H__34296A00_0E39_4F37_A5E5_A95C7017A68A__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CUseItem
{
public:
CUseItem();
virtual ~CUseItem();
int RecyleItem(item_t *item,int &raCount,int &saCount,int &reply,int &error,int &itemIdx,int invenPos);
int AutoQuestItemType(item_t *item,int &invenPos,int &raCount,int &saCount,int &bIsStack,int &stackNumber,int &reply,int &error,int &itemIdx);
int QuestScrollItem(item_t *item,int &invenPos,int &reply,int &error,int &itemIdx);
int AutoQuestScrollItem(item_t *item,int &invenPos,int &reply,int &error,int &itemIdx);
int MonsterCardItem(item_t *item,int &invenPos,int &reply,int &error,int &itemIdx);
int DefaultUsetItem(item_t *item,int &invenPos,int &reply,int &error,int &itemIdx,int &raCount,int &saCount);
};
#endif
| C++ |
#include "../Global.h"
extern char *g_lTableToken[];
CGameConfigFlag gGameConfigFlag;
void CGameConfigFlag::SetFlag()
{
m_nFlag=0;
if(m_bPrecocity_Time) m_nFlag +=1 << 1;
if(m_bDie_Reduce_panality) m_nFlag +=1 << 2;
if(m_bMap_Attr_Ratio) m_nFlag +=1 << 3;
if(m_bItem_Upgrade_Limit) m_nFlag +=1 << 4;
if(m_bItem_Craft_Limit) m_nFlag +=1 << 5;
if(m_bWorld_Chat_Limit) m_nFlag +=1 << 6;
return ;
}
void CGameConfigFlag::SetFlag(int flag)
{
m_nFlag = flag;
int f=0;
if(flag & (1 << 1)) m_bPrecocity_Time=TRUE;
if(flag & (1 << 2)) m_bDie_Reduce_panality=TRUE;
if(flag & (1 << 3)) m_bMap_Attr_Ratio=TRUE;
if(flag & (1 << 4)) m_bItem_Upgrade_Limit=TRUE;
if(flag & (1 << 5)) m_bItem_Craft_Limit=TRUE;
if(flag & (1 << 6)) m_bWorld_Chat_Limit=TRUE;
}
int CGameConfigFlag::LoadFlagFile()
{
FILE *fp;
int size;
byte *buffer;
char *token;
char filename[128];
sprintf( filename, "flag%s.cfg", g_lTableToken[g_config.languageType] );
fp = fopen(filename, "rb" );
if( !fp )
{
MessageBox(NULL, "does not exist 'flag.cfg' file", "Error", MB_ICONHAND|MB_OK);
return false;
}
fseek(fp,0,SEEK_END);
size = ftell(fp);
buffer = new byte[size+1];
fseek(fp,0,SEEK_SET);
fread(buffer,size,1,fp);
fclose(fp);
curpos = (char *)buffer;
endpos = curpos + size;
while ((token = NextToken()) != NULL)
{
if( !stricmp( token, "CHARACTER_STORAGE" ) )
{
token = NextArg();
if(!stricmp( token, "TRUE" )) gGameConfigFlag.m_bCharacter_Storage = TRUE;
else if (!stricmp( token, "FALSE" )) gGameConfigFlag.m_bCharacter_Storage = FALSE;
}
else if( !stricmp( token, "PRECOCITY_TIME" ) )
{
token = NextArg();
if(!stricmp( token, "TRUE" )) gGameConfigFlag.m_bPrecocity_Time = TRUE;
else if (!stricmp( token, "FALSE" )) gGameConfigFlag.m_bPrecocity_Time = FALSE;
}
else if( !stricmp( token, "DIE_REDUCE_PANALTY" ) )
{
token = NextArg();
if(!stricmp( token, "TRUE" )) gGameConfigFlag.m_bDie_Reduce_panality = TRUE;
else if (!stricmp( token, "FALSE" )) gGameConfigFlag.m_bDie_Reduce_panality = FALSE;
}
else if( !stricmp( token, "MAP_ATTR_RATIO" ) )
{
token = NextArg();
if(!stricmp( token, "TRUE" )) gGameConfigFlag.m_bMap_Attr_Ratio = TRUE;
else if (!stricmp( token, "FALSE" )) gGameConfigFlag.m_bMap_Attr_Ratio = FALSE;
}
else if( !stricmp( token, "ITEM_UPGRADE_LIMIT" ) )
{
token = NextArg();
if(!stricmp( token, "TRUE" )) gGameConfigFlag.m_bItem_Upgrade_Limit = TRUE;
else if (!stricmp( token, "FALSE" )) gGameConfigFlag.m_bItem_Upgrade_Limit = FALSE;
}
else if( !stricmp( token, "ITEM_CRAFT_LIMIT" ) )
{
token = NextArg();
if(!stricmp( token, "TRUE" )) gGameConfigFlag.m_bItem_Craft_Limit = TRUE;
else if (!stricmp( token, "FALSE" )) gGameConfigFlag.m_bItem_Craft_Limit = FALSE;
}
else if( !stricmp( token, "WORLD_CHAT_LIMIT" ) )
{
token = NextArg();
if(!stricmp( token, "TRUE" )) gGameConfigFlag.m_bWorld_Chat_Limit = TRUE;
else if (!stricmp( token, "FALSE" )) gGameConfigFlag.m_bWorld_Chat_Limit = FALSE;
}
}
fclose(fp);
SetFlag();
if(NULL != buffer){
delete []buffer;
buffer=NULL;
}
return true;
}
| C++ |
#if !defined(AFX_YDCDAMAGECAL_H__F48B2DEC_F20F_4933_8C12_E339828971E0__INCLUDED_)
#define AFX_YDCDAMAGECAL_H__F48B2DEC_F20F_4933_8C12_E339828971E0__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class YDCDamageCal
{
private:
struct tagYDCharactor{
public:
struct tagEntity{
int Idx;
entityType_t Type;
};
public:
struct tagEntity Entity;
float optValue[NUM_OPTION_VALUE];
float calDefensePower;
float calPositiveRes;
float calNegativeRes;
int level;
int calCriticalDmg;
float calMaxRA;
};
struct tagYDResistanceVar{
float physics;
float positive;
float negative;
};
struct tagYDDamageVar{
float physics;
float positive;
float negative;
};
private:
BOOL m_bOK;
private:
static inline void YDMakeCharactorStruct(struct tagYDCharactor& out_Charactor,const playerCharacter_t* in_pPlayer);
static void YDCalResistance(const struct tagYDCharactor* in_pDefenceCharactor,struct tagYDResistanceVar& out_ResistanceVar);
static inline void YDMakeCharactorStruct(struct tagYDCharactor& out_Charactor,const monsterCharacter_t* in_pMonster);
static void YDCalAdditionalDamage(const struct tagYDCharactor& in_pDefenceCharactor,const message_t* in_pMessage,struct tagYDDamageVar& out_AdditionalDamageVar);
static void YDCalDamage(const message_t* in_pMessage,struct tagYDDamageVar& out_DamageVar);
static void YDApplyResistanceAtDamage(
const message_t* in_pMessage,
const struct tagYDDamageVar& in_DamageVar,
const struct tagYDDamageVar& in_AdditionalDamageVar,
const struct tagYDResistanceVar& in_ResistanceVar,
struct tagYDDamageVar& out_ApplyDamageVar,
int in_AttackerLevel);
static void YDApplyRatioAtDamage(
const message_t* in_pMessage,
const struct tagYDCharactor& in_AttackCharactor,
const struct tagYDCharactor& in_DefenceCharactor,
const struct tagYDDamageVar& in_ApplyDamageVar,
struct tagYDDamageVar& out_ApplyRatioDamageVar);
public:
static int YDGetDamage( int TargetEntityIdx, int TargetEntityType, message_t* message, int eachDmg[]);
BOOL isOK(void) const;
public:
YDCDamageCal();
virtual ~YDCDamageCal();
};
#endif
| C++ |
#if !defined(AFX_POSTFUNC_H__947B49AA_99FC_46A5_B041_60462EE5D219__INCLUDED_)
#define AFX_POSTFUNC_H__947B49AA_99FC_46A5_B041_60462EE5D219__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#include "tagGCPacket.h"
class CPostFunc
{
private:
BOOL InsertCheck_atINVENTORY(
const playerCharacter_t* pPlayer,
const CPostManager::PostPackage_t* pPostPack);
public:
void GTH_ProcessMessage_PostSystem();
void GTH_ProcessMessage_RequestPostList();
void GTH_ProcessMessage_PostSend();
void GTH_ProcessMessage_PostWinExit();
void GTH_ProcessMessage_PostDelete();
void GTH_ProcessMessage_PostState();
void GTH_ProcessMessage_PostWriteOpen(void);
void GTH_ProcessMessage_MailBox();
void GTH_ProcessMessage_MailBox_Item();
void GTH_ProcessMessage_MailBox_Open();
void GTH_ProcessMessage_MailBox_CheckAllowReceiveItems();
void GTH_ProcessMessage_MailBox_ReceiveItems(playerCharacter_t* pPlayer);
void GTH_ProcessMessage_MailBox_AddItemToPlayer(
playerCharacter_t* pPlayer,
const int DeletePostPackageIdx,
const BOOL bDelete);
void GTH_ProcessMessage_MailBox_Exit();
void GTH_ProcessMessage_MailBox_UndoInvenItem(playerCharacter_t* pc);
static void GTH_SendMessage_PostList(
playerCharacter_t* pc,
const enum tagGCPacket_POSTSYSTEM_OPEN::enumCode code);
void GTH_SendMessage_MailBox_UndoInvenItem(playerCharacter_t*, int reply, int errorIdx);
void GTH_SendMessage_PostSend(playerCharacter_t*, int reply, int errorIdx);
void GTH_SendMessage_MailBox_Exit( playerCharacter_t* pc );
void GTH_SendMessage_MailBox_Open(playerCharacter_t* pc, int reply, int error, int PostIdx);
void GTH_SendMessage_MailBox_Item(
playerCharacter_t* pc,
const CPostManager::PostPackage_t* pPostPack,
int reply,
int error,
int isOwner,
int pos,
int itemTableIdx );
void GTH_SendMessage_MailBox_ReceiveItems(playerCharacter_t* pc, int reply, int error);
void GTH_SendMessage_PostDelete(playerCharacter_t* pc, int reply, int error);
static void GTH_SendMessage_MailBox_Cnt(playerCharacter_t* pc,const int iUnReadedNum,const int iReadedNum);
void GTH_SendMessage_PostWriteOpen(playerCharacter_t* pc, int reply, int error);
void GTH_SendMessage_PostState(playerCharacter_t* pc, int reply, int error);
void GTH_SendMessage_PostSendComplete(playerCharacter_t* pc,int reply, int error);
public:
CPostFunc();
virtual ~CPostFunc();
};
#endif
| C++ |
#include "../global.h"
extern i3socket_t gsSocket;
#include "../Guild/CGuildCtrl.h"
extern CGuildCtrl* gcpGuildCtrl;
#include "../GonryunPracticeBattle/CGonryunPracticeBattle.h"
extern CGonryunPracticeBattle g_GonryunPracticeBattle;
#include "..\Tools\CTools.h"
extern CTools* gcpTools;
extern void TransmitePacket_sc_disconnect(playerCharacter_t* pPlayer, int MessageIdx =0);
extern void GTH_DisconnectPlayer(playerCharacter_t* pPlayer,const BOOL bForceQuit);
int GTH_AddNoticePC( playerCharacter_t *pc, int entityType, int entityIdx, int busyState )
{
if( entityType == -1 )
{
pc->busyState = busyState;
return 1;
}
else if( entityType != ENTITY_PC )
{
pc->friendlyEntityType = entityType;
pc->friendlyEntityIdx = entityIdx;
pc->friendlyEntityWorldIdx = pc->worldIdx;
pc->busyState = busyState;
strncpy( pc->friendlyEntityName, g_monster[entityIdx].basic.name,NAMESTRING);
pc->friendlyEntityName[NAMESTRING]=NULL;
}
else
{
pc->friendlyEntityType = entityType;
pc->friendlyEntityIdx = entityIdx;
pc->busyState = busyState;
strncpy(pc->friendlyEntityName, g_pc[entityIdx].name,NAMESTRING);
pc->friendlyEntityName[NAMESTRING]=NULL;
}
return 1;
}
int GTH_DeleteNoticePC( playerCharacter_t *pc )
{
pc->friendlyEntityType = -1;
pc->friendlyEntityIdx = -1;
pc->friendlyEntityWorldIdx = -1;
pc->friendlyEntityName[0] = 0;
pc->busyState = BUSY_STATE_NONE;
return 1;
}
int GTH_CheckNoticePC( playerCharacter_t *pc )
{
if( pc->busyState == BUSY_STATE_NONE )
{
GTH_DeleteNoticePC( pc );
return( false );
}
if( pc->busyState == BUSY_STATE_NPC )
{
return( true );
}
int idx = pc->friendlyEntityIdx;
if( idx < 0 )
{
GTH_DeleteNoticePC( pc );
return( false );
}
if( !g_pc[idx].active || !g_pc[idx].ready )
{
GTH_DeleteNoticePC( pc );
return( false );
}
if( stricmp( g_pc[idx].name, pc->friendlyEntityName ) )
{
GTH_DeleteNoticePC( pc );
return( false );
}
if( pc->worldIdx != g_pc[idx].worldIdx )
{
GTH_DeleteNoticePC( pc );
return( false );
}
return( true );
}
int GTH_GetPCMenuType( playerCharacter_t* requestPC, playerCharacter_t* targetPC )
{
return 0;
}
int GTH_GetPCMenuFlag( playerCharacter_t* requestPC, playerCharacter_t* targetPC )
{
int menuFlag = PC_MENU_EXIT;
menuFlag |= PC_MENU_TRADE;
if( requestPC->memberNumber == 0 )
{
if( targetPC->memberNumber == 0 )
{
menuFlag |= PC_MENU_PARTY;
}
}
else
{
if( requestPC->isLeader )
{
if( targetPC->memberNumber == 0 && requestPC->memberNumber < MAX_NUMBER_OF_PARTY_MEMBER )
menuFlag |= PC_MENU_PARTY;
}
}
return( menuFlag );
}
BOOL GTH_ForcedQuit( playerCharacter_t *pc )
{
BOOL BusyState = FALSE;
switch( pc->busyState )
{
case BUSY_STATE_REQUEST :
GTH_DeleteNoticePC( pc );
if( pc->friendlyEntityIdx >= 0 )
GTH_DeleteNoticePC( &g_pc[pc->friendlyEntityIdx] );
BusyState = TRUE;
break;
case BUSY_STATE_NPC :
break;
case BUSY_STATE_TRADE :
GTH_ForcedQuitTrade( pc );
BusyState = TRUE;
break;
case BUSY_STATE_CRAFT :
GTH_ForcedQuitCraft( pc );
BusyState = TRUE;
break;
case BUSY_STATE_UPGRADE :
GTH_ForcedQuitUpgrade( pc );
BusyState = TRUE;
break;
case BUSY_STATE_BOOTH_SELL : case BUSY_STATE_BOOTH_SELL_PREPARE :
GTH_ForcedQuitBooth( pc );
BusyState = TRUE;
break;
case BUSY_STATE_BOOTH_BUY :
GTH_ForcedQuitBooth( pc );
BusyState = TRUE;
break;
case BUSY_STATE_QUESTSCROLL :
GTH_ForcedQuitQuestScroll( pc );
BusyState = TRUE;
break;
case BUSY_STATE_NPC_INVENTORY :
GTH_ForcedQuitAutoQuestScroll( pc );
BusyState = TRUE;
break;
}
return BusyState;
}
int GTH_UndoPCTrade( playerCharacter_t *pc, int flagFromConfirm )
{
int itemIdx, inventoryPos;
int bIsStack = false, stackNumber = 1;
for( int i = 0; i < MAX_TRADE_SIZE; i ++ )
{
itemIdx = pc->myTrade[i];
if ( itemIdx < 0 || itemIdx >= MAX_NUMBER_OF_OWNITEM)
continue;
item_t* pItem = NULL;
pItem = gcpTools->GetMyItem(pc, itemIdx);
if ( NULL == pItem )
{
continue;
}
if ( pItem->itemTableIdx < 0 || pItem->itemTableIdx >= MAX_NUMBER_OF_ITEM_TABLE)
continue;
bIsStack = false;
stackNumber = 1;
if( g_itemTable[pItem->itemTableIdx].stackFlag )
{
bIsStack = true;
stackNumber = pItem->durability + 1;
}
int stackItemInvenIdx = GTH_StackMyItem( pc, pItem );
if( stackItemInvenIdx >= 0 )
{
item_t * pInvenItem = NULL;
pInvenItem = gcpTools->GetMyItem(pc, stackItemInvenIdx);
if (NULL == pInvenItem)
continue;
if ( pInvenItem->itemTableIdx <0 || pInvenItem->itemTableIdx >= MAX_NUMBER_OF_ITEM_TABLE)
continue;
pInvenItem->durability += pItem->durability + 1;
if( pInvenItem->durability + 1 >= MAX_COUNT_STACK_ITEM )
pInvenItem->durability = MAX_COUNT_STACK_ITEM - 1;
g_logSystem->WriteToLog( pc, LOG_CLASS_ITEM, "%d;%d;;;;%s;%s",
LOG_CLASS_ITEM_UNDO_TRADE, stackNumber, pInvenItem->name,
GetItemInformationLog( bIsStack, pInvenItem->itemTableIdx, stackItemInvenIdx, -1 ) );
GTH_DeleteMyItem( pc, pItem );
g_DBGameServer->SaveItem( pc, pInvenItem, stackItemInvenIdx );
g_DBGameServer->RemoveItem( pc, itemIdx );
}
else
{
inventoryPos = GTH_FindEmptyInventoryPos( pc );
if( inventoryPos >= 0 )
{
pc->inventory[inventoryPos] = itemIdx;
}
g_logSystem->WriteToLog( pc, LOG_CLASS_ITEM, "%d;%d;;;;%s;%s",
LOG_CLASS_ITEM_UNDO_TRADE, stackNumber, pItem->name,
GetItemInformationLog( bIsStack, pItem->itemTableIdx, itemIdx, inventoryPos ) );
}
}
switch( flagFromConfirm )
{
case 0 :
g_logSystem->Write("Trade Cancel : %s(%s) To:(%s) (Direct Cancel)", pc->name, pc->userID, pc->friendlyEntityName );
break;
case 1 :
g_logSystem->Write("Trade Cancel : %s(%s) To:(%s) (Error Cancel)", pc->name, pc->userID, pc->friendlyEntityName );
break;
case 2 :
g_logSystem->Write("Trade Cancel : %s(%s) To:(%s) (Force Cancel)", pc->name, pc->userID, pc->friendlyEntityName );
break;
}
return 1;
}
int GTH_CheckConfirmTrade( playerCharacter_t *pc, int& reply, int& error )
{
int myEmptyInven, myItemInven, otherItemInven;
int myItemWeight, otherItemWeight, i;
int itemIdx, itemTableIdx;
if( reply == 0 ) return( 0 );
if( pc->curChargeSE - pc->tradeSE < 0 )
{
reply = 0;
error = ERROR_PCTRADE_5;
return( 0 );
}
if( pc->otherTradeSE + pc->curChargeSE - pc->tradeSE > MAX_OWN_NAK )
{
reply = 0;
error = ERROR_PCTRADE_3;
return( 0 );
}
myItemWeight = 0;
myItemInven = 0;
myEmptyInven = 0;
otherItemInven = 0;
otherItemWeight = 0;
for( i = 0; i < MAX_TRADE_SIZE; i ++ )
{
if( pc->otherTrade[i] < 0 ) continue;
itemIdx = pc->otherTrade[i];
itemTableIdx = pc->tradeItem[itemIdx].itemTableIdx;
myItemWeight += g_itemTable[itemTableIdx].weight;
myItemInven ++;
}
for( i = 0; i < MAX_TRADE_SIZE; i ++ )
{
if( pc->myTrade[i] < 0 ) continue;
itemIdx = pc->myTrade[i];
itemTableIdx = pc->item[itemIdx].itemTableIdx;
otherItemWeight += g_itemTable[itemTableIdx].weight;
otherItemInven ++;
}
if( pc->curItemWeight + myItemWeight - otherItemWeight > pc->calItemWeight )
{
reply = 0;
error = ERROR_PCTRADE_1;
g_logSystem->Write("Trade Failure : Weight Exceed. %s(%s)", pc->name, pc->userID );
return( 0 );
}
for( i = 0; i < MAX_INVENTORY_SIZE; i ++ )
{
if( pc->inventory[i] < 0 ) myEmptyInven ++;
}
if( myEmptyInven < myItemInven )
{
reply = 0;
error = ERROR_PCTRADE_2;
g_logSystem->Write("Trade Failure : Inventory Space Not Enough. %s(%s)", pc->name, pc->userID );
return( 0 );
}
reply = 1;
error = 0;
return( 1 );
}
int GTH_ConfirmTrade( playerCharacter_t *pc, int& reply, int &error )
{
int i;
int itemIdx, inventoryPos, stackItemIdx;
char generateID[20];
item_t* item, *upItem;
char logBuffer[100];
int bIsStack = false, stackNumber = 1;
if( reply == 0 ) return( 0 );
pc->curChargeSE -= pc->tradeSE;
pc->curChargeSE += pc->otherTradeSE;
if( pc->curChargeSE > MAX_OWN_NAK ) pc->curChargeSE = MAX_OWN_NAK;
if (pc->tradeSE > 0 || pc->otherTradeSE > 0 )
{
g_logSystem->WriteToLog( pc, LOG_CLASS_ITEM, "%d;%d;%d;;;%s;%s",
LOG_CLASS_ITEM_CONFIRM_TRADE, 0,
pc->otherTrade - pc->tradeSE,
"NAK",
pc->friendlyEntityName );
}
for( i = 0; i < MAX_TRADE_SIZE; i ++ )
{
if( pc->myTrade[i] < 0 ) continue;
itemIdx = pc->myTrade[i];
item = &pc->item[itemIdx];
bIsStack = false;
stackNumber = 1;
if( g_itemTable[item->itemTableIdx].stackFlag )
{
bIsStack = true;
stackNumber = item->durability + 1;
}
_snprintf( logBuffer, 100, "%s, %s", pc->friendlyEntityName,
GetItemInformationLog( bIsStack, item->itemTableIdx, itemIdx, -1 ));
g_logSystem->WriteToLog( pc, LOG_CLASS_ITEM, "%d;%d;%d;;;%s;%s",
LOG_CLASS_ITEM_CONFIRM_TRADE, 1, stackNumber, item->name,
logBuffer );
g_logSystem->Write("Delete Trade Item : %s(%s) item : %s, To:(%s) ", pc->name, pc->userID, item->name, pc->friendlyEntityName );
GTH_DeleteMyItem( pc, item );
if ( !g_DBGameServer->RemoveItem(pc, itemIdx) )
{
g_logSystem->Write("Can not Delete Item in Database(Item table).(%s, %d, %d, %d", pc->userID, pc->serverGroupID, pc->characterID, itemIdx);
reply = 0;
error = ERROR_PCTRADE_4;
return( 0 );
}
}
for( i = 0; i < MAX_TRADE_SIZE; i ++ )
{
if( pc->otherTrade[i] < 0 ) continue;
itemIdx = pc->otherTrade[i];
item = &pc->tradeItem[itemIdx];
bIsStack = false;
stackNumber = 1;
if( g_itemTable[item->itemTableIdx].stackFlag )
{
bIsStack = true;
stackNumber = item->durability + 1;
}
stackItemIdx = GTH_StackMyItem( pc, item );
if( stackItemIdx >= 0 )
{
upItem = &pc->item[stackItemIdx];
upItem->durability += item->durability + 1;
if( upItem->durability + 1 >= MAX_COUNT_STACK_ITEM ) upItem->durability = MAX_COUNT_STACK_ITEM - 1;
g_DBGameServer->SaveItem( pc, upItem, stackItemIdx );
_snprintf( logBuffer, 100, "%s, %s", pc->friendlyEntityName,
GetItemInformationLog( bIsStack, upItem->itemTableIdx, stackItemIdx, -1 ));
g_logSystem->WriteToLog( pc, LOG_CLASS_ITEM, "%d;%d;%d;;;%s;%s",
LOG_CLASS_ITEM_CONFIRM_TRADE, 2, stackNumber, upItem->name,
logBuffer );
}
else
{
inventoryPos = GTH_FindEmptyInventoryPos( pc );
itemIdx = GTH_AddMyItem( pc, item );
pc->inventory[inventoryPos] = itemIdx;
strcpy(generateID, "tradeGenID");
if ( !g_DBGameServer->AddItem(pc, item, itemIdx, generateID) )
{
g_logSystem->Write("Can not Insert to Database(Item Table).(%s, %d, %d)", pc->userID, pc->serverGroupID, pc->characterID);
reply = 0;
error = ERROR_PCTRADE_4;
return( 0 );
}
_snprintf( logBuffer, 100, "%s, %s", pc->friendlyEntityName,
GetItemInformationLog( bIsStack, item->itemTableIdx, itemIdx, inventoryPos ));
g_logSystem->WriteToLog( pc, LOG_CLASS_ITEM, "%d;%d;%d;;;%s;%s",
LOG_CLASS_ITEM_CONFIRM_TRADE, 2, stackNumber, item->name,
logBuffer );
}
g_logSystem->Write("Insert Trade Item : %s(%s) item : %s, From:(%s) ", pc->name, pc->userID, item->name, pc->friendlyEntityName );
}
reply = 1;
error = 0;
return( 1 );
}
void GTH_InitTrade( playerCharacter_t* pc )
{
int i;
for( i = 0; i < MAX_TRADE_SIZE; i ++ )
{
pc->myTrade[i] = -1;
pc->otherTrade[i] = -1;
memset( &pc->tradeItem[i], 0, sizeof( item_t ) );
pc->tradeItem[i].itemTableIdx = -1;
pc->tradeSE = 0;
pc->otherTradeSE = 0;
}
}
void GTH_ForcedQuitTrade( playerCharacter_t* pc )
{
int reply = 1, error = 0, idx;
idx = pc->friendlyEntityIdx;
if( idx < 0 ) return;
if( !g_pc[idx].active ) return;
if( stricmp( g_pc[idx].name, pc->friendlyEntityName ) ) return;
GTH_UndoPCTrade( pc, 2 );
GTH_UndoPCTrade( &g_pc[idx], 2 );
GTH_InitTrade( pc );
GTH_InitTrade( &g_pc[idx] );
GTH_SendMessage_PCTrade_Exit( pc, reply, error );
GTH_SendMessage_PCTrade_Exit( &g_pc[idx], reply, error );
GTH_DeleteNoticePC( pc );
GTH_DeleteNoticePC( &g_pc[idx] );
}
void GTH_ForcedQuitCraft( playerCharacter_t *pc )
{
GTH_UndoPCCraft( pc );
GTH_DeleteNoticePC( pc );
}
void GTH_ForcedQuitUpgrade( playerCharacter_t *pc )
{
GTH_UndoPCUpgrade( pc );
GTH_DeleteNoticePC( pc );
}
void GTH_ForcedQuitBooth( playerCharacter_t *pc )
{
if( pc->busyState == BUSY_STATE_BOOTH_SELL_PREPARE )
{
GTH_UndoPCBooth( pc );
GTH_DeleteNoticePC( pc );
}
else if( pc->busyState == BUSY_STATE_BOOTH_SELL )
{
int pcIdx;
for( int i = 0; i < MAX_COUNT_BOOTH_BUYER; i ++ )
{
if( pc->boothBuyerIdx[i] < 0 ) continue;
pcIdx = pc->boothBuyerIdx[i];
if( g_pc[pcIdx].busyState == BUSY_STATE_BOOTH_BUY )
{
GTH_SendMessage_ItemSystem_BoothBuyClose( &g_pc[pcIdx], 1, 0, 0 );
GTH_DeleteNoticePC( &g_pc[pcIdx] );
}
else
{
g_logSystem->Write("Shop DeleteBusyState Error : %s(%s) Cur Status(%d)", g_pc[pcIdx].name, g_pc[pcIdx].userID, g_pc[pcIdx].busyState );
g_logSystem->WriteToLog( &g_pc[pcIdx], LOG_CLASS_ITEM, "%d;;;;;%s;%s", g_pc[pcIdx].busyState, "Shop Error", "ForcedQuitBooth" );
}
pc->boothBuyerIdx[i] = -1;
}
GTH_UndoPCBooth( pc );
GTH_DeleteNoticePC( pc );
}
else if( pc->busyState == BUSY_STATE_BOOTH_BUY )
{
int idx = pc->friendlyEntityIdx;
GTH_DeleteNoticePC( pc );
if( idx < 0 ) return;
for( int i = 0; i < MAX_COUNT_BOOTH_BUYER; i ++ )
{
if( g_pc[idx].boothBuyerIdx[i] < 0 ) continue;
if( g_pc[idx].boothBuyerIdx[i] == pc->idx )
{
g_pc[idx].boothBuyerIdx[i] = -1;
break;
}
}
GTH_SendMessage_ItemSystem_BoothBuyClose( &g_pc[idx], 1, 0, 1, pc->name );
}
}
void GTH_ForcedQuitQuestScroll( playerCharacter_t *pc )
{
GTH_DeleteNoticePC( pc );
}
void GTH_ForcedQuitAutoQuestScroll( playerCharacter_t *pc )
{
GTH_DeleteNoticePC( pc );
}
void GTH_UpdatePartyInfo( playerCharacter_t *pc )
{
}
void GTH_GetStackItem( playerCharacter_t *pc, int &reply, int &error, int inventoryPos, int numStack )
{
item_t *item, stackItem;
int itemIdx = pc->inventory[inventoryPos], oldItemIdx;
char generateID[20];
item = &pc->item[itemIdx];
if( item->durability <= numStack - 1 )
{
pc->inventory[inventoryPos] = -1;
pc->mouseInventory = itemIdx;
reply = 1;
return;
}
oldItemIdx = pc->inventory[inventoryPos];
memcpy( &stackItem, item, sizeof( item_t ) );
stackItem.durability = numStack - 1;
itemIdx = GTH_AddMyItem( pc, &stackItem );
if (itemIdx < 0 )
{
reply = 0;
error = ERROR_EQUIPITEM_5;
return;
}
item->durability -= numStack;
pc->mouseInventory = itemIdx;
g_DBGameServer->SaveItem( pc, item, oldItemIdx );
strcpy(generateID, "stackGenID");
g_DBGameServer->AddItem(pc, &stackItem, itemIdx, generateID);
return;
}
void GTH_SetStackItem( playerCharacter_t *pc, int &reply, int &error )
{
int stackItemIdx, mouseItemIdx;
item_t* item, *upItem;
mouseItemIdx = pc->mouseInventory;
item = &pc->item[mouseItemIdx];
stackItemIdx = GTH_StackMyItem( pc, item );
if( stackItemIdx >= 0 )
{
upItem = &pc->item[stackItemIdx];
upItem->durability += item->durability + 1;
if( upItem->durability + 1 >= MAX_COUNT_STACK_ITEM ) upItem->durability = MAX_COUNT_STACK_ITEM - 1;
pc->mouseInventory = -1;
GTH_DeleteMyItem( pc, item );
g_DBGameServer->SaveItem( pc, upItem, stackItemIdx );
g_DBGameServer->RemoveItem( pc, mouseItemIdx );
}
else
{
int inventoryPos;
inventoryPos = GTH_FindEmptyInventoryPos( pc );
if( inventoryPos < 0 )
{
reply = 0;
error = ERROR_EQUIPITEM_5;
return;
}
pc->inventory[inventoryPos] = pc->mouseInventory;
pc->mouseInventory = -1;
}
}
void GTH_GetStackItemForDepot( playerCharacter_t *pc, int &reply, int &error, int depotPos, int numStack )
{
item_t *item, stackItem;
int itemIdx = pc->depot[depotPos], oldItemIdx;
char generateID[20];
item = &pc->item[itemIdx];
if( item->durability <= numStack - 1 )
{
pc->depot[depotPos] = -1;
pc->mouseInventory = itemIdx;
reply = 1;
return;
}
oldItemIdx = pc->depot[depotPos];
memcpy( &stackItem, item, sizeof( item_t ) );
stackItem.durability = numStack - 1;
itemIdx = GTH_AddMyItem( pc, &stackItem );
if (itemIdx < 0 )
{
reply = 0;
error = ERROR_DEPOT_1;
return;
}
item->durability -= numStack;
pc->mouseInventory = itemIdx;
g_DBGameServer->SaveItem( pc, item, oldItemIdx );
strcpy(generateID, "stackGenID");
g_DBGameServer->AddItem(pc, &stackItem, itemIdx, generateID);
return;
}
void GTH_SetStackItemForDepot( playerCharacter_t *pc, int &reply, int &error )
{
int stackItemIdx, mouseItemIdx;
item_t* item, *upItem;
mouseItemIdx = pc->mouseInventory;
item = &pc->item[mouseItemIdx];
stackItemIdx = GTH_StackMyItemForDepot( pc, item );
if( stackItemIdx >= 0 )
{
upItem = &pc->item[stackItemIdx];
upItem->durability += item->durability + 1;
if( upItem->durability + 1 >= MAX_COUNT_STACK_ITEM ) upItem->durability = MAX_COUNT_STACK_ITEM - 1;
pc->mouseInventory = -1;
GTH_DeleteMyItem( pc, item );
g_DBGameServer->SaveItem( pc, upItem, stackItemIdx );
g_DBGameServer->RemoveItem( pc, mouseItemIdx );
}
else
{
int depotPos;
depotPos = GTH_FindEmptyDepotPos( pc );
if( depotPos < 0 )
{
reply = 0;
error = ERROR_DEPOT_1;
return;
}
pc->depot[depotPos] = pc->mouseInventory;
pc->mouseInventory = -1;
}
}
bool GTH_IsOnPlayQuestScroll( playerCharacter_t *pc )
{
int i;
for ( i = 0; i< MAX_COUNT_QUEST_STATUS; i++ )
{
if ( pc->questStatus[i].questIdx == QUEST_SCROLL_INDEX )
return 1;
}
return 0;
}
bool GTH_IsOnPlayAutoQuestScroll(playerCharacter_t *pc)
{
for ( int i = 0; i< MAX_COUNT_QUEST_STATUS; i++ )
{
if ( pc->questStatus[i].questIdx == AUTOQUESTSCROLL_ITEM_INDEX )
{
return 1;
}
}
return 0;
}
int GTH_GetEmptyQuestStatus( playerCharacter_t *pc )
{
int i;
for( i = 0; i < MAX_COUNT_QUEST_STATUS; i ++ )
{
if( pc->questStatus[i].questIdx < 0 ) return i;
}
return -1;
}
void GTH_SetQuestStatus( playerCharacter_t *pc, int idx, int questIdx, int limitTime, int partyFlag, int *dField )
{
pc->questStatus[idx].idx = idx;
pc->questStatus[idx].questIdx = questIdx;
pc->questStatus[idx].limitTime = limitTime;
if( partyFlag )
{
strcpy( pc->questStatus[idx].partyOrganizerName, pc->organizerName );
pc->questStatus[idx].partyOrganizeServer = pc->organizeServer;
pc->questStatus[idx].partyOrganizeTime = pc->organizeTime;
}
if( dField != NULL )
{
memcpy( &pc->questStatus[idx].dField, dField, sizeof( pc->questStatus[idx].dField ) );
}
else
{
memset( pc->questStatus[idx].dField, 0, sizeof( pc->questStatus[idx].dField ) );
}
pc->questStatus[idx].clearTime = 0;
g_DBGameServer->AddQuestStatus( pc, &pc->questStatus[idx] );
pc->questNumber++;
GTH_SendMessage_QuestStatusInfo( pc, 1, questIdx );
}
void GTH_AutoSetQuestStatus( playerCharacter_t *pc, int idx, int questIdx, int limitTime , int partyFlag , int *dField)
{
pc->questStatus[idx].idx = idx;
pc->questStatus[idx].questIdx = questIdx;
pc->questStatus[idx].limitTime = limitTime;
if( partyFlag )
{
strcpy( pc->questStatus[idx].partyOrganizerName, pc->organizerName );
pc->questStatus[idx].partyOrganizeServer = pc->organizeServer;
pc->questStatus[idx].partyOrganizeTime = pc->organizeTime;
}
if( dField != NULL )
{
memcpy( &pc->questStatus[idx].dField, dField, sizeof( pc->questStatus[idx].dField ) );
}
else
{
memset( pc->questStatus[idx].dField, 0, sizeof( pc->questStatus[idx].dField ) );
}
pc->questStatus[idx].clearTime = 0;
g_DBGameServer->AddQuestStatus( pc, &pc->questStatus[idx] );
pc->questNumber++;
int ifild[2];
ifild[0]=questIdx+pc->questStatus[idx].dField[0];
ifild[1]=pc->questStatus[idx].dField[0];
AI_NPC_AutoSetQuestType(pc,ifild);
int type=1;
GTH_SendMessage_AutoQuestStatusInfo( pc, type, pc->questStatus[idx].dField[0] );
ShowLogInfo("autoqueststatusInfo: userID:%s,questIdx:%d,type:%d",pc->name,pc->questStatus[idx].dField[0],type);
}
void GTH_ClearQuestStatus( playerCharacter_t *pc, int idx, int type )
{
int QuestStatusIdx = 0;
for( int i = 0; i < MAX_COUNT_QUEST_STATUS; i ++ )
{
if( pc->questStatus[i].questIdx == idx )
{
QuestStatusIdx = i;
break;
}
}
if( i == MAX_COUNT_QUEST_STATUS ) return ;
pc->questStatus[i].questIdx = -1;
g_DBGameServer->RemoveQuestStatus( pc, i );
pc->questNumber--;
int autoquestindex=-1;
if( !type )
{
if ( idx == QUEST_SCROLL_INDEX )
{
int addItemData[6];
addItemData[0] = QUESTSCROLL_ITEM_INDEX;
addItemData[1] = -1;
addItemData[2] = 1;
addItemData[3] = 0;
addItemData[4] = pc->questStatus[i].dField[0];
addItemData[5] = pc->questStatus[i].dField[5];
if ( g_questscrollTable[pc->questStatus[i].dField[0]].data.rewardField[pc->questStatus[i].dField[5]] < 0 )
addItemData[5] = FindRewardField( pc->questStatus[i].dField[0] );
if ( addItemData[5] < 0 )
{
g_logSystem->Write("Quest Scroll Table has an Error! (User: %s, Index : %d)", pc->name, pc->questStatus[i].dField[0] );
}
else
AI_NPC_AddItem( pc, addItemData );
}
if(idx == AUTOQUESTSCROLL_ITEM_INDEX)
{
}
for( i = 0; i < MAX_COUNT_QUEST_INVENTORY; i ++ )
{
if( pc->questInventory[i].item.itemIdx < 0 ) continue;
switch( idx )
{
case 0 : case 2 :
if( pc->questInventory[i].item.itemIdx != 210 ) continue;
break;
case 1 :
if( pc->questInventory[i].item.itemIdx != 211 ) continue;
break;
case 3 :
if( pc->questInventory[i].item.itemIdx != 268 ) continue;
break;
default :
if( pc->questInventory[i].item.questIdx != idx ) continue;
break;
}
pc->questInventory[i].item.itemIdx = -1;
pc->questInventory[i].item.questIdx = 0;
pc->questInventory[i].item.itemCount = 0;
}
GTH_SendMessage_QuestItemInfo( pc, -1, 0 );
pc->questVar[idx].var.step = -1;
pc->questVar[idx].var.isComplete = 0;
pc->questVar[idx].var.dummy = 0;
if(idx == AUTOQUESTSCROLL_ITEM_INDEX)
{
GTH_SendMessage_AutoQuestStatusInfo(pc,0,autoquestindex);
}
else
{
GTH_SendMessage_QuestStatusInfo( pc, 0, idx );
}
}
else
{
GTH_SendMessage_QuestStatusInfo( pc, 2, idx );
}
memset(pc->questStatus[QuestStatusIdx].dField, -1, sizeof(int)*MAX_COUNT_QUEST_STATUS_DYNAMIC_FIELD );
}
void GTH_AutoClearQuestStatus( playerCharacter_t *pc, int idx, int type )
{
for( int i = 0; i < MAX_COUNT_QUEST_STATUS; i ++ )
{
if( pc->questStatus[i].questIdx == idx ) break;
}
if( i == MAX_COUNT_QUEST_STATUS ) return ;
pc->questStatus[i].questIdx = -1;
pc->questStatus[i].limitTime= -1;
pc->questStatus[i].clearTime= -1;
g_DBGameServer->RemoveQuestStatus( pc, i );
pc->questNumber--;
switch(type) {
case -1:
{
if(idx == AUTOQUESTSCROLL_ITEM_INDEX)
{
int addItemData[6];
addItemData[0] = AUTOQUESTSCROLL_ITEM_INDEX;
addItemData[1] = -1;
addItemData[2] = 1;
addItemData[3] = 0;
addItemData[5] = -1;
addItemData[4] = pc->questStatus[i].dField[0];
AI_NPC_AddItem( pc, addItemData );
}
for( i = 0; i < MAX_COUNT_QUEST_INVENTORY; i ++ )
{
if( pc->questInventory[i].item.itemIdx < 0 ) continue;
switch( idx )
{
case 0 : case 2 :
if( pc->questInventory[i].item.itemIdx != 210 ) continue;
break;
case 1 :
if( pc->questInventory[i].item.itemIdx != 211 ) continue;
break;
case 3 :
if( pc->questInventory[i].item.itemIdx != 268 ) continue;
break;
default :
if( pc->questInventory[i].item.questIdx != idx ) continue;
break;
}
pc->questInventory[i].item.itemIdx = -1;
pc->questInventory[i].item.questIdx = 0;
pc->questInventory[i].item.itemCount = 0;
}
GTH_SendMessage_QuestItemInfo( pc, -1, 0 );
pc->questVar[idx].var.step = -1;
pc->questVar[idx].var.isComplete = 0;
pc->questVar[idx].var.dummy = 0;
pc->questVar[idx].var.completeCount=0;
GTH_SendMessage_AutoQuestStatusInfo(pc,type,pc->questStatus[i].dField[0]);
}
break;
case 1:
{
GTH_SendMessage_AutoQuestStatusInfo(pc,2,pc->questStatus[i].dField[0]);
}
break;
}
memset(pc->questStatus[idx].dField, -1, sizeof(int)*MAX_COUNT_QUEST_STATUS_DYNAMIC_FIELD );
}
int GTH_GetQuestStatusDynamicField( playerCharacter_t *pc, int questIdx, int fieldIdx )
{
for( int i = 0; i < MAX_COUNT_QUEST_STATUS; i ++ )
{
if( pc->questStatus[i].questIdx == questIdx ) break;
}
if( i == MAX_COUNT_QUEST_STATUS ) return -1;
return( pc->questStatus[i].dField[fieldIdx] );
}
int GTH_SetQuestStatusDynamicField( playerCharacter_t *pc, int questIdx, int fieldIdx, int value )
{
for( int i = 0; i < MAX_COUNT_QUEST_STATUS; i ++ )
{
if( pc->questStatus[i].questIdx == questIdx ) break;
}
if( i == MAX_COUNT_QUEST_STATUS ) return -1;
pc->questStatus[i].dField[fieldIdx] = value;
return 1;
}
int GTH_ConsumptiveItemProcess( playerCharacter_t *pc, int inventoryPos )
{
int itemIdx = pc->inventory[inventoryPos];
int itemTableIdx = pc->item[itemIdx].itemTableIdx;
int param[10];
switch( itemTableIdx )
{
case ITEM_TABLE_IDX_ERIN_OF_TIME :
{
GTH_PC_GetLoot( pc->idx, g_itemTable[itemTableIdx].commonField[0], 0, 0, 0, 0 );
param[0] = itemIdx;
param[1] = 0;
AI_NPC_DeleteItem( pc, param );
}
break;
default :
return 0;
}
return 1;
}
void GTH_InitPlayerStatus( playerCharacter_t *pc )
{
int reply = 1, error = 0;
int force, agi, soul, vit;
if( pc->curChargeSE < pc->npcAi.globalData[0] )
{
reply = 0;
error = 1;
GTH_SendMessage_QuestLogic_InitStatus( pc, reply, error, 1, 0 );
return;
}
for( int i = 0; i < MAX_EQUIPMENT; i ++ )
{
if( i == EQUIP_EPACK ) continue;
if( pc->equipment[i] >= 0 ) break;
}
if( i != MAX_EQUIPMENT )
{
reply = 0;
error = 2;
GTH_SendMessage_QuestLogic_InitStatus( pc, reply, error, 1, 0 );
return;
}
if(pc->PremiumInfo.Status.iDefaultInitCount + pc->PremiumInfo.Status.iInitCount <= 0)
{
reply = 0;
error = 3;
GTH_SendMessage_QuestLogic_InitStatus(pc, reply, error, 1, 0);
return;
}
extern int PC_INITIAL_STATUS[8][4];
force = PC_INITIAL_STATUS[pc->pcClass][STATUS_FORCE];
soul = PC_INITIAL_STATUS[pc->pcClass][STATUS_SOULPOWER];
agi = PC_INITIAL_STATUS[pc->pcClass][STATUS_AGILITY];
vit = PC_INITIAL_STATUS[pc->pcClass][STATUS_VITALITY];
pc->curChargeSE -= pc->npcAi.globalData[0];
pc->force = force + ( pc->level - 1 );
pc->soulpower = soul + ( pc->level - 1 );
pc->agility = agi + ( pc->level - 1 );
pc->vitality = vit + ( pc->level - 1 );
pc->bonusStatusPoint = pc->level;
switch(pc->pcJob){
case J_MENTALITY :
break;
case J_WIND :
break;
case J_WATER :
break;
case J_EARTH:
break;
case J_DEVOTIONAL_KNIGHT :
pc->agility += 5;
break;
case J_ROMING_KNIGHT :
pc->vitality += 5;
break;
case J_PIECING_EYES :
pc->soulpower += 5;
break;
case J_WINDY_ROMER :
pc->vitality += 5;
break;
case J_DESTROYER :
pc->agility += 5;
break;
case J_GUARDIAN :
pc->vitality += 5;
break;
case J_PROPHECIER :
break;
case J_TRANSFORMER :
pc->agility += 5;
break;
case J_DEFENDER :
pc->vitality += 5;
break;
case J_STRANGER :
break;
}
pc->PremiumInfo.Status.iInitCount -=1;
if(pc->PremiumInfo.Status.iInitCount <= 0){
pc->PremiumInfo.Status.iInitCount=0;
pc->PremiumInfo.Status.iDefaultInitCount-=1;
if(pc->PremiumInfo.Status.iDefaultInitCount < 0)
pc->PremiumInfo.Status.iDefaultInitCount=0;
}
GTH_SendMessage_QuestLogic_InitStatus( pc, reply, error, 1, 0 );
GTH_PC_Calculate( pc );
}
void GTH_ProcessMessage_QuestLogic()
{
int command;
command = MSG_ReadByte();
switch( command )
{
case QUESTLOGIC_INITSTATUS :
GTH_InitPlayerStatus( g_curPC );
break;
}
}
void GTH_PrecocityProcess( playerCharacter_t *pc )
{
int itemTableIndex, outComeItemTableIndex;
item_t *item;
for( int i = 0; i < MAX_PRECOCITY_SIZE; i ++ )
{
if( pc->precocityInventory[i] < 0 ) continue;
if( pc->precocityTime[i] < 0 )
{
item = &pc->item[pc->precocityInventory[i]];
itemTableIndex = item->itemTableIdx;
if( g_itemTable[itemTableIndex].etcItemType == ETCITEM_TYPE_PRECOCITY )
{
if(gGameConfigFlag.m_bPrecocity_Time)
{
pc->precocityTime[i] = g_itemTable[itemTableIndex].precocity.precocityTime * pc->PremiumInfo.fItemPrecocityTimeRatio;
}
else
{
pc->precocityTime[i] = g_itemTable[itemTableIndex].precocity.precocityTime;
}
}
continue;
}
pc->precocityTime[i] --;
if( pc->precocityTime[i] == 0 )
{
item = &pc->item[pc->precocityInventory[i]];
pc->precocityTime[i] = -1;
itemTableIndex = item->itemTableIdx;
if( g_itemTable[itemTableIndex].etcItemType != ETCITEM_TYPE_PRECOCITY ) continue;
outComeItemTableIndex = g_itemTable[itemTableIndex].precocity.outComeItemIndex;
InitItem( item );
item->itemTableIdx = outComeItemTableIndex;
strcpy( item->name, g_itemTable[outComeItemTableIndex].name );
if( g_itemTable[outComeItemTableIndex].durability > 0 ) item->durability = g_itemTable[outComeItemTableIndex].durability;
g_DBGameServer->SaveItem( pc, item, pc->precocityInventory[i] );
GTH_SendMessage_ItemSystem_PrecocityComplete( pc, i );
if( g_itemTable[outComeItemTableIndex].etcItemType == ETCITEM_TYPE_PRECOCITY )
{
if(gGameConfigFlag.m_bPrecocity_Time)
{
pc->precocityTime[i] = g_itemTable[outComeItemTableIndex].precocity.precocityTime * pc->PremiumInfo.fItemPrecocityTimeRatio;
}
else
{
pc->precocityTime[i] = g_itemTable[outComeItemTableIndex].precocity.precocityTime;
}
}
}
}
}
void GTH_ProcessMessage_PCTrade()
{
int command;
command = MSG_ReadByte();
switch( command )
{
case PCTRADE_REQUEST :
GTH_ProcessMessage_PCTrade_Request();
break;
case PCTRADE_ADMIT :
GTH_ProcessMessage_PCTrade_Admit();
break;
case PCTRADE_REJECT :
GTH_ProcessMessage_PCTrade_Reject();
break;
case PCTRADE_EXIT :
if( g_curPC->busyState != BUSY_STATE_TRADE ) break;
GTH_ProcessMessage_PCTrade_Exit();
break;
case PCTRADE_ITEM :
if( g_curPC->busyState != BUSY_STATE_TRADE ) break;
GTH_ProcessMessage_PCTrade_Item();
break;
case PCTRADE_OK :
if( g_curPC->busyState != BUSY_STATE_TRADE ) break;
GTH_ProcessMessage_PCTrade_Ok();
break;
case PCTRADE_CANCEL :
if( g_curPC->busyState != BUSY_STATE_TRADE ) break;
GTH_ProcessMessage_PCTrade_Cancel();
break;
case PCTRADE_CONFIRM :
if( g_curPC->busyState != BUSY_STATE_TRADE ) break;
GTH_ProcessMessage_PCTrade_Confirm();
break;
case PCTRADE_SE :
if( g_curPC->busyState != BUSY_STATE_TRADE ) break;
GTH_ProcessMessage_PCTrade_SE();
break;
}
}
void GTH_ProcessMessage_PCTrade_Request()
{
int idx, reply = 1, error = 0;
idx = MSG_ReadShort();
if( !g_pc[idx].active || !g_pc[idx].ready || !g_pc[idx].alive )
{
reply = 0;
error = ERROR_ENTITYMENU_1;
}
else if( g_pc[idx].worldIdx != g_curPC->worldIdx )
{
reply = 0;
error = ERROR_ENTITYMENU_2;
}
else if( g_curPC->busyState != BUSY_STATE_NONE || g_pc[idx].busyState != BUSY_STATE_NONE )
{
reply = 0;
error = ERROR_ENTITYMENU_2;
}
if( reply )
{
GTH_AddNoticePC( g_curPC, ENTITY_PC, idx, BUSY_STATE_REQUEST );
GTH_AddNoticePC( &g_pc[idx], ENTITY_PC, g_curPC->idx, BUSY_STATE_REQUEST );
GTH_SendMessage_PCTrade_Request( &g_pc[idx], reply, error, g_curPC->idx, 0 );
}
GTH_SendMessage_PCTrade_Request( g_curPC, reply, error, idx, 1 );
}
void GTH_ProcessMessage_PCTrade_Admit()
{
int idx, reply = 1, error = 0;
idx = MSG_ReadShort();
if( !g_pc[idx].active || !g_pc[idx].ready || !g_pc[idx].alive )
{
reply = 0;
error = ERROR_ENTITYMENU_1;
}
else if( g_pc[idx].worldIdx != g_curPC->worldIdx )
{
reply = 0;
error = ERROR_ENTITYMENU_2;
}
else if( g_pc[idx].busyState != BUSY_STATE_REQUEST )
{
reply = 0;
error = ERROR_ENTITYMENU_2;
}
else
{
g_curPC->tradeSE = 0;
g_curPC->otherTradeSE = 0;
g_curPC->tradeAdmitSignal = false;
g_curPC->tradeOkSignal = false;
g_pc[idx].tradeSE = 0;
g_pc[idx].otherTradeSE = 0;
g_pc[idx].tradeAdmitSignal = false;
g_pc[idx].tradeOkSignal = false;
GTH_AddNoticePC( g_curPC, ENTITY_PC, idx, BUSY_STATE_TRADE );
GTH_AddNoticePC( &g_pc[idx], ENTITY_PC, g_curPC->idx, BUSY_STATE_TRADE );
GTH_InitTrade( g_curPC );
GTH_InitTrade( &g_pc[idx] );
g_logSystem->Write("Trade : Start %s(%s, %d, %d), %s(%s, %d, %d)", g_curPC->name, g_curPC->userID, g_curPC->serverGroupID, g_curPC->characterID,
g_pc[idx].name, g_pc[idx].userID, g_pc[idx].serverGroupID, g_pc[idx].characterID );
}
GTH_SendMessage_PCTrade_Admit( g_curPC, reply, error );
GTH_SendMessage_PCTrade_Admit( &g_pc[idx], reply, error );
}
void GTH_ProcessMessage_PCTrade_Reject()
{
int type, idx, reply = 1, error = 0;
type = MSG_ReadByte();
idx = MSG_ReadShort();
GTH_DeleteNoticePC( g_curPC );
if( idx >= 0 )
GTH_DeleteNoticePC( &g_pc[idx] );
if( !type )
{
GTH_SendMessage_PCTrade_Reject( g_curPC, reply, error, false );
GTH_SendMessage_PCTrade_Reject( &g_pc[idx], reply, error, true );
}
else
{
GTH_SendMessage_PCTrade_Reject( g_curPC, reply, error, true );
GTH_SendMessage_PCTrade_Reject( &g_pc[idx], reply, error, false );
}
}
void GTH_ProcessMessage_PCTrade_Exit()
{
int idx, reply = 1, error = 0;
idx = MSG_ReadShort();
GTH_UndoPCTrade( g_curPC, 0 );
GTH_UndoPCTrade( &g_pc[idx], 0 );
GTH_InitTrade( g_curPC );
GTH_InitTrade( &g_pc[idx] );
GTH_SendMessage_PCTrade_Exit( g_curPC, reply, error );
GTH_SendMessage_PCTrade_Exit( &g_pc[idx], reply, error );
GTH_DeleteNoticePC( g_curPC );
GTH_DeleteNoticePC( &g_pc[idx] );
}
void GTH_ProcessMessage_PCTrade_Item()
{
int idx, pos, itemIdx;
int type = 0;
item_t item;
int reply = 1, error = 0;
idx = MSG_ReadShort();
pos = MSG_ReadByte();
InitItem( &item );
if( g_curPC->friendlyEntityIdx != idx || g_pc[idx].friendlyEntityIdx != g_curPC->idx )
{
reply = 0;
error = 1;
GTH_SendMessage_PCTrade_Item( g_curPC, reply, error, true, type, pos, &item );
return;
}
if( g_curPC->mouseInventory >= 0 && g_curPC->myTrade[pos] < 0 )
{
memcpy( &g_pc[idx].tradeItem[pos], &g_curPC->item[g_curPC->mouseInventory], sizeof( item_t ) );
g_pc[idx].otherTrade[pos] = pos;
memcpy( &item, &g_pc[idx].tradeItem[pos], sizeof( item_t ) );
g_curPC->myTrade[pos] = g_curPC->mouseInventory;
g_curPC->mouseInventory = -1;
type = 0;
}
else if( g_curPC->mouseInventory < 0 && g_curPC->myTrade[pos] >= 0 )
{
InitItem( &g_pc[idx].tradeItem[pos] );
g_pc[idx].otherTrade[pos] = -1;
g_curPC->mouseInventory = g_curPC->myTrade[pos];
g_curPC->myTrade[pos] = -1;
type = 1;
}
else if( g_curPC->mouseInventory >= 0 && g_curPC->myTrade[pos] >= 0 )
{
memcpy( &g_pc[idx].tradeItem[pos], &g_curPC->item[g_curPC->mouseInventory], sizeof( item_t ) );
g_pc[idx].otherTrade[pos] = pos;
memcpy( &item, &g_pc[idx].tradeItem[pos], sizeof( item_t ) );
itemIdx = g_curPC->mouseInventory;
g_curPC->mouseInventory = g_curPC->myTrade[pos];
g_curPC->myTrade[pos] = itemIdx;
type = 2;
}
else
{
reply = 0;
error = 1;
}
GTH_SendMessage_PCTrade_Item( &g_pc[idx], reply, error, false, type, pos, &item );
GTH_SendMessage_PCTrade_Item( g_curPC, reply, error, true, type, pos, &item );
}
void GTH_ProcessMessage_PCTrade_Ok()
{
int idx, reply = 1, error = 0;
idx = MSG_ReadShort();
g_curPC->tradeOkSignal = true;
GTH_SendMessage_PCTrade_Ok( g_curPC, reply, error, true );
GTH_SendMessage_PCTrade_Ok( &g_pc[idx], reply, error, false );
}
void GTH_ProcessMessage_PCTrade_Cancel()
{
int idx, reply = 1, error = 0;
idx = MSG_ReadShort();
g_curPC->tradeOkSignal = false;
g_curPC->tradeAdmitSignal = false;
g_pc[idx].tradeOkSignal = false;
g_pc[idx].tradeAdmitSignal = false;
GTH_SendMessage_PCTrade_Cancel( g_curPC, reply, error, true );
GTH_SendMessage_PCTrade_Cancel( &g_pc[idx], reply, error, false );
}
void GTH_ProcessMessage_PCTrade_Confirm()
{
int idx, reply = 1, error = 0, type;
type = MSG_ReadByte();
idx = MSG_ReadShort();
if( type )
{
g_curPC->tradeAdmitSignal = true;
if( g_curPC->tradeAdmitSignal && g_pc[idx].tradeAdmitSignal )
{
GTH_CheckConfirmTrade( g_curPC, reply, error );
GTH_CheckConfirmTrade( &g_pc[idx], reply, error );
GTH_ConfirmTrade( g_curPC, reply, error );
GTH_ConfirmTrade( &g_pc[idx], reply, error );
GTH_SendMessage_PCTrade_Confirm( g_curPC, reply, error, 2 );
GTH_SendMessage_PCTrade_Confirm( &g_pc[idx], reply, error, 2 );
GTH_InitTrade( g_curPC );
GTH_InitTrade( &g_pc[idx] );
GTH_PC_Calculate( g_curPC, PCINFO_BASIC );
GTH_PC_Calculate( &g_pc[idx], PCINFO_BASIC );
GTH_DeleteNoticePC( g_curPC );
GTH_DeleteNoticePC( &g_pc[idx] );
g_logSystem->Write("Trade Successful : %s(%s) To:(%s)", g_curPC->name, g_curPC->userID, g_curPC->friendlyEntityName );
}
else
{
GTH_SendMessage_PCTrade_Confirm( &g_pc[idx], reply, error, 1 );
}
}
else
{
g_curPC->tradeAdmitSignal = false;
GTH_SendMessage_PCTrade_Confirm( g_curPC, reply, error, 0 );
}
}
void GTH_ProcessMessage_PCTrade_SE()
{
int reply = 1, error = 0, idx, se;
idx = MSG_ReadShort();
se = MSG_ReadLong();
if( g_curPC->friendlyEntityIdx != idx || g_pc[idx].friendlyEntityIdx != g_curPC->idx )
{
reply = 0;
error = 1;
GTH_SendMessage_PCTrade_SE( g_curPC, reply, error, true, se );
return;
}
if( se > g_curPC->curChargeSE )
{
reply = 0;
error = ERROR_PCTRADE_5;
GTH_SendMessage_PCTrade_SE( g_curPC, reply, error, true, se );
}
else
{
g_curPC->tradeSE = se;
g_pc[idx].otherTradeSE = se;
GTH_SendMessage_PCTrade_SE( g_curPC, reply, error, true, se );
GTH_SendMessage_PCTrade_SE( &g_pc[idx], reply, error, false, se );
}
}
void GTH_ProcessMessage_Party()
{
int command;
command = MSG_ReadByte();
switch( command )
{
case PARTY_REQUEST_ORGANIZE :
GTH_ProcessMessage_Party_Request_Organize();
break;
case PARTY_ADMIT_ORGANIZE :
GTH_ProcessMessage_Party_Admit_Organize();
break;
case PARTY_REJECT_ORGANIZE :
GTH_ProcessMessage_Party_Reject_Organize();
break;
case PARTY_REQUEST_JOIN :
GTH_ProcessMessage_Party_Request_Join();
break;
case PARTY_ADMIT_JOIN :
GTH_ProcessMessage_Party_Admit_Join();
break;
case PARTY_REJECT_JOIN :
GTH_ProcessMessage_Party_Reject_Join();
break;
case PARTY_OUT :
GTH_ProcessMessage_Party_Out();
break;
case PARTY_FORCEDOUT :
GTH_ProcessMessage_Party_ForcedOut();
break;
case PARTY_DISORGANIZE :
GTH_ProcessMessage_Party_Disorganize();
break;
case PARTY_CANJOIN :
GTH_ProcessMessage_Party_CanJoin();
break;
case PARTY_ITEMDIVIDETYPE :
GTH_ProcessMessage_Party_ItemDivideType();
break;
case PARTY_CHATMESSAGE :
GTH_ProcessMessage_Party_ChatMessage();
break;
}
}
void GTH_ProcessMessage_Party_Request_Organize()
{
int idx;
int reply = 1, error = 0;
idx = MSG_ReadShort();
if( !g_pc[idx].active )
{
reply = 0;
error = ERROR_PARTY_1;
GTH_SendMessage_Party_Request_Organize( g_curPC, reply, error, idx, true );
} else if( !g_pc[idx].ready || !g_pc[idx].alive || g_pc[idx].busyState != BUSY_STATE_NONE )
{
reply = 0;
error = ERROR_PARTY_2;
GTH_SendMessage_Party_Request_Organize( g_curPC, reply, error, idx, true );
}
else if( g_pc[idx].memberNumber != 0 )
{
reply = 0;
error = ERROR_PARTY_3;
GTH_SendMessage_Party_Request_Organize( g_curPC, reply, error, idx, true );
} else if( g_pc[idx].worldIdx != g_curPC->worldIdx )
{
reply = 0;
error = ERROR_PARTY_4;
GTH_SendMessage_Party_Request_Organize( g_curPC, reply, error, idx, true );
} else if( !g_pc[idx].canJoin )
{
reply = 0;
error = ERROR_PARTY_2;
GTH_SendMessage_Party_Request_Organize( g_curPC, reply, error, idx, true );
}
else
{
GTH_SendMessage_Party_Request_Organize( g_curPC, reply, error, idx, true );
GTH_SendMessage_Party_Request_Organize( &g_pc[idx], reply, error, g_curPC->idx, false );
}
}
void GTH_ProcessMessage_Party_Admit_Organize()
{
int idx;
int reply = 1, error = 0;
idx = MSG_ReadShort();
if( g_curPC->memberNumber != 0 || g_pc[idx].memberNumber != 0 )
{
reply = 0;
error = ERROR_PARTY_3;
GTH_SendMessage_Party_Admit_Organize( g_curPC, reply, error, false );
GTH_SendMessage_Party_Admit_Organize( &g_pc[idx], reply, error, true );
}
else if ( !g_pc[idx].active )
{
reply = 0;
error = ERROR_PARTY_1;
GTH_SendMessage_Party_Admit_Organize( g_curPC, reply, error, false );
GTH_SendMessage_Party_Admit_Organize( &g_pc[idx], reply, error, true );
}
else if( !g_pc[idx].ready || !g_pc[idx].alive || g_pc[idx].busyState != BUSY_STATE_NONE )
{
reply = 0;
error = ERROR_PARTY_2;
GTH_SendMessage_Party_Admit_Organize( g_curPC, reply, error, false );
GTH_SendMessage_Party_Admit_Organize( &g_pc[idx], reply, error, true );
}
else if( g_pc[idx].worldIdx != g_curPC->worldIdx )
{
reply = 0;
error = ERROR_PARTY_4;
GTH_SendMessage_Party_Admit_Organize( g_curPC, reply, error, false );
GTH_SendMessage_Party_Admit_Organize( &g_pc[idx], reply, error, true );
}
else
{
GTH_PartyInfo_Request_Organize( &g_pc[idx], g_curPC );
}
}
void GTH_ProcessMessage_Party_Reject_Organize()
{
int idx, type;
type = MSG_ReadByte();
idx = MSG_ReadShort();
if( type )
{
GTH_SendMessage_Party_Reject_Organize( g_curPC, true );
GTH_SendMessage_Party_Reject_Organize( &g_pc[idx], false );
}
else
{
GTH_SendMessage_Party_Reject_Organize( g_curPC, false );
GTH_SendMessage_Party_Reject_Organize( &g_pc[idx], true );
}
}
void GTH_ProcessMessage_Party_Request_Join()
{
int idx;
int reply = 1, error = 0;
idx = MSG_ReadShort();
if( !g_pc[idx].active )
{
reply = 0;
error = ERROR_PARTY_1;
GTH_SendMessage_Party_Request_Join( g_curPC, reply, error, idx, true );
} else if( !g_pc[idx].ready || !g_pc[idx].alive || g_pc[idx].busyState != BUSY_STATE_NONE )
{
reply = 0;
error = ERROR_PARTY_2;
GTH_SendMessage_Party_Request_Join( g_curPC, reply, error, idx, true );
}
else if( g_pc[idx].memberNumber != 0 )
{
reply = 0;
error = ERROR_PARTY_3;
GTH_SendMessage_Party_Request_Join( g_curPC, reply, error, idx, true );
} else if( g_pc[idx].worldIdx != g_curPC->worldIdx )
{
reply = 0;
error = ERROR_PARTY_4;
GTH_SendMessage_Party_Request_Join( g_curPC, reply, error, idx, true );
} else if( g_curPC->memberNumber >= MAX_NUMBER_OF_PARTY_MEMBER )
{
reply = 0;
error = ERROR_PARTY_6;
GTH_SendMessage_Party_Request_Join( g_curPC, reply, error, idx, true );
} else if( !g_pc[idx].canJoin )
{
reply = 0;
error = ERROR_PARTY_2;
GTH_SendMessage_Party_Request_Join( g_curPC, reply, error, idx, true );
}
else
{
GTH_SendMessage_Party_Request_Join( g_curPC, reply, error, idx, true );
GTH_SendMessage_Party_Request_Join( &g_pc[idx], reply, error, g_curPC->idx, false );
}
}
void GTH_ProcessMessage_Party_Admit_Join()
{
int idx;
int reply = 1, error = 0;
idx = MSG_ReadShort();
if( !g_pc[idx].active )
{
reply = 0;
error = ERROR_PARTY_1;
GTH_SendMessage_Party_Admit_Join( g_curPC, reply, error, false );
GTH_SendMessage_Party_Admit_Join( &g_pc[idx], reply, error, true );
} else if( !g_pc[idx].ready || !g_pc[idx].alive )
{
reply = 0;
error = ERROR_PARTY_2;
GTH_SendMessage_Party_Admit_Join( g_curPC, reply, error, false );
GTH_SendMessage_Party_Admit_Join( &g_pc[idx], reply, error, true );
}
else if( g_pc[idx].worldIdx != g_curPC->worldIdx )
{
reply = 0;
error = ERROR_PARTY_4;
GTH_SendMessage_Party_Admit_Join( g_curPC, reply, error, false );
GTH_SendMessage_Party_Admit_Join( &g_pc[idx], reply, error, true );
}
else if( g_pc[idx].memberNumber >= MAX_NUMBER_OF_PARTY_MEMBER )
{
reply = 0;
error = ERROR_PARTY_6;
GTH_SendMessage_Party_Request_Join( g_curPC, reply, error, -1, false );
GTH_SendMessage_Party_Admit_Join( &g_pc[idx], reply, error, true );
}
else
{
GTH_PartyInfo_Request_Join( &g_pc[idx], g_curPC );
}
}
void GTH_ProcessMessage_Party_Reject_Join()
{
int idx, type;
type = MSG_ReadByte();
idx = MSG_ReadShort();
if( type )
{
GTH_SendMessage_Party_Reject_Join( g_curPC, true );
GTH_SendMessage_Party_Reject_Join( &g_pc[idx], false );
}
else
{
GTH_SendMessage_Party_Reject_Join( g_curPC, false );
GTH_SendMessage_Party_Reject_Join( &g_pc[idx], true );
}
}
void GTH_ProcessMessage_Party_Out()
{
int reply = 1, error = 0;
if( g_curPC->organizeServer == -1 )
{
reply = 0;
error = ERROR_PARTY_5;
}
else
{
GTH_PartyInfo_Request_Out( g_curPC );
}
}
void GTH_ProcessMessage_Party_ForcedOut()
{
int reply = 1, error = 0;
char memberName[NAMESTRING];
strcpy( memberName, MSG_ReadString() );
if( g_curPC->organizeServer == -1 )
{
reply = 0;
error = ERROR_PARTY_7;
GTH_SendMessage_Party_Out( g_curPC, reply, error, 0, 0, 0, 0 );
}
else if( !g_curPC->isLeader )
{
reply = 0;
error = ERROR_PARTY_7;
GTH_SendMessage_Party_Out( g_curPC, reply, error, 0, 0, 0, 0 );
}
else
{
for( int i = 0; i < MAX_NUMBER_OF_PARTY_MEMBER; i ++ )
{
if( g_curPC->member[i].serverIndex == -1 ) continue;
if( !stricmp( g_curPC->member[i].memberName, memberName ) ) break;
}
if( i == MAX_NUMBER_OF_PARTY_MEMBER )
{
reply = 0;
error = ERROR_PARTY_5;
GTH_SendMessage_Party_Out( g_curPC, reply, error, 0, 0, 0, 0 );
}
else
{
GTH_PartyInfo_Request_ForcedOut( g_curPC, g_curPC->member[i].memberName );
}
}
}
void GTH_ProcessMessage_Party_Disorganize()
{
int reply = 1, error = 0;
if( g_curPC->organizeServer == -1 )
{
reply = 0;
error = ERROR_PARTY_5;
GTH_SendMessage_Party_Out( g_curPC, reply, error, 0, 0, 0, 0 );
}
else
{
GTH_PartyInfo_Request_Disorganize( g_curPC );
}
}
void GTH_ProcessMessage_Party_CanJoin()
{
int type;
type = MSG_ReadByte();
g_curPC->canJoin = type;
GTH_SendMessage_Party_CanJoin( g_curPC, type );
}
void GTH_ProcessMessage_Party_ItemDivideType()
{
int type;
type = MSG_ReadByte();
GTH_PartyInfo_Request_ItemDivideType( g_curPC, type );
}
void GTH_ProcessMessage_Party_ChatMessage()
{
char message[256];
if( g_curPC->organizeServer < 0 ) return;
strcpy( message, MSG_ReadString() );
GTH_PartyInfo_Request_ChatMessage( g_curPC, message );
}
void GTH_ProcessMessage_Request_PCInfo()
{
GTH_SendMessage_Reply_PCInfo( g_curPC );
}
void GTH_ProcessMessage_Hotkey()
{
int curIdx;
int hotIdx, hotType;
curIdx = MSG_ReadByte();
hotType = MSG_ReadByte();
hotIdx = MSG_ReadChar();
g_curPC->hotkeyType[curIdx] = hotType;
g_curPC->hotkeyIdx[curIdx] = hotIdx;
}
void GTH_ProcessMessage_Request_Use_Masic_Book()
{
item_t *item;
int itemIdx, itemTableIdx;
int invenPos;
int reply = 1, error = 0;
invenPos = MSG_ReadByte();
itemIdx = g_curPC->inventory[invenPos];
if( itemIdx < 0 )
{
reply = 0;
error = ERROR_CONSUMPTIVE_0;
GTH_SendMessage_Reply_Use_Masic_Book( g_curPC, reply, error, invenPos );
return;
}
else
{
item = &g_curPC->item[itemIdx];
itemTableIdx = item->itemTableIdx;
if(itemTableIdx == 465)
{
GTH_ProcessMessage_AllRepairItem(invenPos);
GTH_UseItem_Delete(invenPos);
}
}
}
bool GTH_UseItem_Delete(int invenPos )
{
int itemIdx = g_curPC->inventory[invenPos];
if(itemIdx < 0)
{
return false;
}
item_t *item = item = &g_curPC->item[itemIdx];
if( item->durability > 0 )
{
item->durability --;
g_DBGameServer->SaveItem( g_curPC, item, itemIdx );
}
else
{
GTH_DeleteMyItem( g_curPC, item );
g_curPC->inventory[invenPos] = -1;
if ( !g_DBGameServer->RemoveItem( g_curPC, itemIdx ) )
{
return false;
}
}
return true;
}
void GTH_ProcessMessage_Request_Use_Portal()
{
item_t *item;
int itemIdx, itemTableIdx, bindingIdx;
int invenPos;
int reply = 1, error = 0;
int zoneIdx;
vec3_t pos, rpos;
int worldIdx;
int memberIdx;
vec3_t savePosition;
int saveWorldIdx;
invenPos = MSG_ReadByte();
itemIdx = g_curPC->inventory[invenPos];
if ( g_curPC->busyState != BUSY_STATE_NONE)
{
reply = 0;
error = ERROR_CONSUMPTIVE_1;
GTH_SendMessage_Reply_Use_Portal( g_curPC, reply, error, invenPos );
g_logSystem->Write("User (%s) Don't Move. User Busy State.", g_curPC->userID);
return;
}
if( itemIdx < 0 )
{
reply = 0;
error = ERROR_CONSUMPTIVE_0;
GTH_SendMessage_Reply_Use_Portal( g_curPC, reply, error, invenPos );
return;
}
else
{
item = &g_curPC->item[itemIdx];
itemTableIdx = item->itemTableIdx;
if( g_itemTable[itemTableIdx].etcItemType != ETCITEM_TYPE_PORTAL )
{
reply = 0;
error = ERROR_CONSUMPTIVE_0;
GTH_SendMessage_Reply_Use_Portal( g_curPC, reply, error, invenPos );
return;
}
else
{
bindingIdx = g_itemTable[itemTableIdx].portal.bindingIdx;
if( bindingIdx < 0 ) bindingIdx = 0;
if( g_binding[bindingIdx].idx < 0 ) bindingIdx = 0;
worldIdx = g_binding[bindingIdx].worldIdx;
if( item->durability > 0 )
{
item->durability --;
g_DBGameServer->SaveItem( g_curPC, item, itemIdx );
g_logSystem->Write("Use Portal : From:(%s) %s", g_curPC->name, item->name);
g_logSystem->WriteToLog( g_curPC, LOG_CLASS_ITEM, "%d;;;;;%s;%s",
LOG_CLASS_ITEM_USE_PORTAL, item->name,
GetItemInformationLog( 1, item->itemTableIdx, itemIdx, -1 ) );
}
else
{
g_logSystem->WriteToLog( g_curPC, LOG_CLASS_ITEM, "%d;;;;;%s;%s",
LOG_CLASS_ITEM_USE_PORTAL, item->name,
GetItemInformationLog( 0, item->itemTableIdx, itemIdx, -1 ) );
g_logSystem->Write("Use Portal : From:(%s) %s", g_curPC->name, item->name);
GTH_DeleteMyItem( g_curPC, item );
g_curPC->inventory[invenPos] = -1;
reply = 1;
if ( !g_DBGameServer->RemoveItem( g_curPC, itemIdx ) )
{
g_logSystem->Write("Can not Item int DataBase(Item Table).(%s, %d, %d, %d", g_curPC->userID, g_curPC->serverGroupID, g_curPC->characterID, itemIdx);
reply = 0;
error = ERROR_CONSUMPTIVE_0;
GTH_SendMessage_Reply_Use_Portal( g_curPC, reply, error, invenPos );
return;
}
}
if ( GTH_IsLocalServiceWorld(worldIdx) )
{
if( worldIdx == g_curPC->worldIdx )
{
vec_copy( g_binding[bindingIdx].pos, pos );
rpos[0] = (float)GTH_Randomize( (int)g_binding[bindingIdx].range ) * 2.0f - g_binding[bindingIdx].range;
rpos[1] = (float)GTH_Randomize( (int)g_binding[bindingIdx].range ) * 2.0f - g_binding[bindingIdx].range;
pos[0] += rpos[0];
pos[1] += rpos[1];
vec_copy( pos, g_curPC->position );
g_curPC->reliableWorldIdx = g_curPC->worldIdx;
vec_copy( g_curPC->position, g_curPC->reliablePosition );
zoneIdx = GTH_Zone_UpdateCurrentZone(ENTITY_PC, g_curPC->idx, g_curPC->worldIdx, g_curPC->zoneIdx, g_curPC->position);
g_curPC->zoneIdx = zoneIdx;
GTH_SendMessage_Reply_Use_Portal( g_curPC, reply, error, invenPos );
GTH_SendMessage_SyncItemObject( g_curPC );
}
else
{
if ( g_curPC->worldIdx == DAN_BATTLEMAP_NO )
{
g_logSystem->WriteRLog("Delete Team....Call by Same world");
g_pDanBattleSys->DeleteTeam( g_curPC );
}
GTH_Zone_DeleteEntityList(g_curPC->worldIdx, g_curPC->zoneIdx, g_curPC->entityType, g_curPC->idx);
g_curPC->worldIdx = worldIdx;
vec_copy( g_binding[bindingIdx].pos, pos );
rpos[0] = (float)GTH_Randomize( (int)g_binding[bindingIdx].range ) * 2.0f - g_binding[bindingIdx].range;
rpos[1] = (float)GTH_Randomize( (int)g_binding[bindingIdx].range ) * 2.0f - g_binding[bindingIdx].range;
pos[0] += rpos[0];
pos[1] += rpos[1];
vec_copy( pos, g_curPC->position );
g_curPC->reliableWorldIdx = g_curPC->worldIdx;
vec_copy( g_curPC->position, g_curPC->reliablePosition );
g_curPC->zoneIdx = GTH_Zone_GetZoneIdx( g_curPC->position );
GTH_SendMessage_Reply_Use_Portal( g_curPC, reply, error, invenPos );
GTH_Zone_AddEntityList(g_curPC->worldIdx, g_curPC->zoneIdx, g_curPC->entityType, g_curPC->idx);
g_curPC->ready = false;
g_logSystem->Write("Use Portal : (%s) Move to Binding Pos, Pos(%.2f, %.2f, %.2f), World : %d",
g_curPC->userID, g_curPC->position[0], g_curPC->position[1], g_curPC->position[2], g_curPC->worldIdx);
}
}
else
{
if ( g_config.isDanBattleMap )
{
if ( g_curPC->worldIdx == DAN_BATTLEMAP_NO )
{
g_logSystem->WriteRLog("Delete Team call by ....DB_SaveGameData");
g_pDanBattleSys->DeleteTeam( g_curPC );
}
}
saveWorldIdx = g_curPC->worldIdx;
vec_copy(g_curPC->position, savePosition);
g_curPC->worldIdx = worldIdx;
vec_copy( g_binding[bindingIdx].pos, pos );
rpos[0] = (float)( rand() % (int)g_binding[bindingIdx].range ) * 2.0f - g_binding[bindingIdx].range;
rpos[1] = (float)( rand() % (int)g_binding[bindingIdx].range ) * 2.0f - g_binding[bindingIdx].range;
pos[0] += rpos[0];
pos[1] += rpos[1];
vec_copy( pos, g_curPC->position );
GTH_SendMessage_Reply_Use_Portal( g_curPC, reply, error, invenPos, true );
memberIdx = GTH_FindServerWithinGroup( worldIdx );
if (memberIdx < 0)
{
g_curPC->flagChangeServer = -1;
DB_SaveGameData( g_curPC, SAVEGAMEDATA_QUIT);
return;
}
else
{
g_curPC->flagChangeServer = 1;
g_curPC->changeServerWorldIdx = worldIdx;
DB_SaveGameData( g_curPC, SAVEGAMEDATA_QUIT);
}
g_curPC->worldIdx = saveWorldIdx;
vec_copy(savePosition, g_curPC->position);
}
}
}
}
void GTH_ProcessMessage_Request_SavePortalPosition()
{
int type;
type = MSG_ReadByte();
g_curPC->skillVariable[0] = g_curPC->worldIdx;
g_curPC->skillVariable[1] = (int)g_curPC->position[0];
g_curPC->skillVariable[2] = (int)g_curPC->position[1];
g_curPC->skillVariable[3] = (int)g_curPC->position[2];
GTH_SendMessage_Reply_SavePortalPosition( g_curPC, 1, 0 );
}
void GTH_ProcessMessage_ItemSystem()
{
int command;
command = MSG_ReadByte();
switch( command )
{
case DEPOT_OPEN :
break;
case DEPOT_GETITEM :
GTH_ProcessMessage_ItemSystem_DepotGetItem();
break;
case DEPOT_ITEM :
GTH_ProcessMessage_ItemSystem_DepotItem();
break;
case DEPOT_NAK :
GTH_ProcessMessage_ItemSystem_DepotNak();
break;
case PRECOCITY_OPEN :
break;
case PRECOCITY_ITEM :
GTH_ProcessMessage_ItemSystem_PrecocityItem();
break;
case PRECOCITY_COMPLETE :
break;
case CRAFT_OPEN :
GTH_ProcessMessage_ItemSystem_CraftOpen();
break;
case CRAFT_CLOSE :
GTH_ProcessMessage_ItemSystem_CraftClose();
break;
case CRAFT_ITEM :
GTH_ProcessMessage_ItemSystem_CraftItem();
break;
case CRAFT_PREPARE :
GTH_ProcessMessage_ItemSystem_CraftPrepare();
break;
case CRAFT_COMPLETE :
GTH_ProcessMessage_ItemSystem_CraftComplete();
break;
case EVENT_CRAFT_OPEN :
GTH_ProcessMessage_ItemSystem_EventCraftOpen();
break;
case EVENT_CRAFT_CLOSE :
GTH_ProcessMessage_ItemSystem_EventCraftClose();
break;
case EVENT_CRAFT_ITEM :
GTH_ProcessMessage_ItemSystem_EventCraftItem();
break;
case EVENT_CRAFT_PREPARE :
GTH_ProcessMessage_ItemSystem_EventCraftPrepare();
break;
case EVENT_CRAFT_COMPLETE :
GTH_ProcessMessage_ItemSystem_EventCraftComplete();
break;
case EVENT_CRAFT_LOADEVENT:
GTH_ProcessMessage_ItemSystem_EventCraftLoadEvent();
break;
case BOOTH_SELL_OPEN :
GTH_ProcessMessage_ItemSystem_BoothSellOpen();
break;
case BOOTH_SELL_ITEM :
GTH_ProcessMessage_ItemSystem_BoothSellItem();
break;
case BOOTH_SELL_START :
GTH_ProcessMessage_ItemSystem_BoothSellStart();
break;
case BOOTH_SELL_CLOSE :
GTH_ProcessMessage_ItemSystem_BoothSellClose();
break;
case BOOTH_BUY_OPEN :
GTH_ProcessMessage_ItemSystem_BoothBuyOpen();
break;
case BOOTH_BUY_ITEM :
GTH_ProcessMessage_ItemSystem_BoothBuyItem();
break;
case BOOTH_BUY_CLOSE :
GTH_ProcessMessage_ItemSystem_BoothBuyClose();
break;
case UPGRADE_OPEN :
GTH_ProcessMessage_ItemSystem_UpgradeOpen();
break;
case UPGRADE_CLOSE :
GTH_ProcessMessage_ItemSystem_UpgradeClose();
break;
case UPGRADE_ITEM :
GTH_ProcessMessage_ItemSystem_UpgradeItem();
break;
case UPGRADE_PREPARE :
GTH_ProcessMessage_ItemSystem_UpgradePrepare();
break;
case UPGRADE_COMPLETE :
GTH_ProcessMessage_ItemSystem_UpgradeComplete();
break;
case DELETE_PREPARE :
GTH_ProcessMessage_ItemSystem_DeletePrepare();
break;
case DELETE_COMPLETE :
GTH_ProcessMessage_ItemSystem_DeleteComplete();
break;
case QUESTSCROLL_OBTAINPREPARE :
GTH_ProcessMessage_QuestScroll_ObtainPrepare();
break;
case QUESTSCROLL_OBTAINCOMPLETE :
GTH_ProcessMessage_QuestScroll_ObtainComplete();
break;
case QUESTSCROLL_OBTAINCLOSE :
GTH_ProcessMessage_QuestScroll_ObtainClose();
break;
case QUESTSCROLL_COMBOLISTCHANGE :
GTH_ProcessMessage_QuestScroll_ComboListChange();
break;
case AUTOQUESTSCROLL_NPCINVENTORYITEM:
GTH_ProcessMessage_ItemSystem_AutoCraftItem();
break;
case AUTOQUESTSCROLL_NPCINVENTORYOPEN :
GTH_ProcessMessage_ItemSystem_NpcInventoryOpen();
break;
case AUTOQUESTSCROLL_NPCINVENTORYCLOSE :
GTH_ProcessMessage_ItemSystem_NpcInventoryClose();
break;
case AUTOQUESTSCROLL_NPCINVENTORYPREPARE :
GTH_ProcessMessage_ItemSystem_AutoCraftPrepare();
break;
case EXCHANGE_CLOSE :
GTH_ProcessMessage_ItemSystem_ExchangeClose();
break;
case EXCHANGE_ITEM :
GTH_ProcessMessage_ItemSystem_ExchangeItem();
break;
case EXCHANGE_PREPARE :
GTH_ProcessMessage_ItemSystem_ExchangePrepare();
break;
}
}
void GTH_ProcessMessage_ItemSystem_DepotGetItem()
{
int depotPos, numStack;
int itemIdx;
int reply = 1, error = 0;
depotPos = MSG_ReadShort();
numStack = MSG_ReadShort();
itemIdx = g_curPC->depot[depotPos];
if( itemIdx >= 0 )
{
if( g_curPC->item[itemIdx].itemTableIdx < 0 )
{
g_curPC->depot[depotPos] = -1;
reply = 8;
GTH_SendMessage_ItemSystem_DepotGetItem( g_curPC, reply, error, depotPos );
return;
}
}
if( g_curPC->curItemWeight > g_curPC->calItemWeight )
{
reply = 0;
error = ERROR_DEPOT_4;
GTH_SendMessage_ItemSystem_DepotGetItem( g_curPC, reply, error, depotPos );
return;
}
if( itemIdx < 0 && g_curPC->mouseInventory < 0 )
{
reply = 0;
}
else if( itemIdx >= 0 && g_curPC->mouseInventory < 0 )
{
if( GTH_IsStackItem( &g_curPC->item[itemIdx] ) && numStack > 0 )
{
reply = 5;
GTH_GetStackItemForDepot( g_curPC, reply, error, depotPos, numStack );
}
else
{
reply = 1;
g_curPC->depot[depotPos] = -1;
g_curPC->mouseInventory = itemIdx;
}
}
else if( itemIdx < 0 && g_curPC->mouseInventory >= 0 )
{
int stackItemIdx = GTH_StackMyItemForDepot( g_curPC, &g_curPC->item[g_curPC->mouseInventory] );
if( GTH_IsStackItem( &g_curPC->item[g_curPC->mouseInventory] ) && stackItemIdx >= 0 )
{
reply = 6;
GTH_SetStackItemForDepot( g_curPC, reply, error );
}
else
{
reply = 2;
g_curPC->depot[depotPos] = g_curPC->mouseInventory;
g_curPC->mouseInventory = -1;
}
}
else if( itemIdx >= 0 && g_curPC->mouseInventory >= 0 )
{
if( GTH_IsStackItem( &g_curPC->item[g_curPC->mouseInventory] ) )
{
reply = 6;
GTH_SetStackItemForDepot( g_curPC, reply, error );
}
else
{
reply = 3;
g_curPC->depot[depotPos] = g_curPC->mouseInventory;
g_curPC->mouseInventory = itemIdx;
}
}
else
{
reply = 0;
}
if( reply )
{
if( g_curPC->mouseInventory >= 0 ) g_curPC->mouseInventoryType = MOUSEINVEN_TYPE_DEPOT;
else g_curPC->mouseInventoryType = MOUSEINVEN_TYPE_NONE;
}
GTH_SendMessage_ItemSystem_DepotGetItem( g_curPC, reply, error, depotPos );
}
void GTH_ProcessMessage_ItemSystem_DepotItem()
{
int depotPos = MSG_ReadShort();
int reply = 1, error = 0;
int depotPrice;
if( g_curPC->depot[depotPos] >= 0 || g_curPC->mouseInventory < 0 ||
g_curPC->mouseInventoryType != MOUSEINVEN_TYPE_INVENTORY )
{
reply = 0;
error = ERROR_DEPOT_2;
}
else
{
depotPrice = GTH_GetDepotPrice( g_curPC, &g_curPC->item[g_curPC->mouseInventory] );
if( g_curPC->curChargeSE < depotPrice )
{
reply = 0;
error = ERROR_DEPOT_3;
}
else
{
g_curPC->curChargeSE -= depotPrice;
int stackItemIdx = GTH_StackMyItemForDepot( g_curPC, &g_curPC->item[g_curPC->mouseInventory] );
if( GTH_IsStackItem( &g_curPC->item[g_curPC->mouseInventory] ) && stackItemIdx >= 0 )
{
reply = 2;
GTH_SetStackItemForDepot( g_curPC, reply, error );
}
else
{
reply = 1;
g_curPC->depot[depotPos] = g_curPC->mouseInventory;
g_curPC->mouseInventory = -1;
}
g_curPC->mouseInventoryType = MOUSEINVEN_TYPE_NONE;
}
}
GTH_SendMessage_ItemSystem_DepotItem( g_curPC, reply, error, depotPos );
}
void GTH_ProcessMessage_ItemSystem_DepotNak()
{
int reply = 1, error = 0;
int type;
int depotSE;
int tempSE;
type = MSG_ReadByte();
depotSE = MSG_ReadLong();
if( type == 0 )
{
if( g_curPC->curChargeSE < depotSE )
{
reply = 0;
error = 1;
GTH_SendMessage_ItemSystem_DepotNak( g_curPC, reply, error );
return;
}
if( g_curPC->depotSE + depotSE > MAX_OWN_NAK )
{
tempSE = g_curPC->depotSE + depotSE - MAX_OWN_NAK;
g_curPC->depotSE = MAX_OWN_NAK;
g_curPC->curChargeSE -= depotSE;
g_curPC->curChargeSE += tempSE;
}
else
{
g_curPC->depotSE += depotSE;
g_curPC->curChargeSE -= depotSE;
}
}
else
{
if( g_curPC->depotSE < depotSE )
{
reply = 0;
error = 1;
GTH_SendMessage_ItemSystem_DepotNak( g_curPC, reply, error );
return;
}
if( g_curPC->curChargeSE + depotSE > MAX_OWN_NAK )
{
tempSE = g_curPC->curChargeSE + depotSE - MAX_OWN_NAK;
g_curPC->curChargeSE = MAX_OWN_NAK;
g_curPC->depotSE -= depotSE;
g_curPC->depotSE += tempSE;
}
else
{
g_curPC->depotSE -= depotSE;
g_curPC->curChargeSE += depotSE;
}
}
if( g_curPC->curChargeSE > MAX_OWN_NAK ) g_curPC->curChargeSE = MAX_OWN_NAK;
if( g_curPC->curChargeSE < 0 ) g_curPC->curChargeSE = 0;
if( g_curPC->depotSE > MAX_OWN_NAK ) g_curPC->depotSE = MAX_OWN_NAK;
if( g_curPC->depotSE < 0 ) g_curPC->depotSE = 0;
GTH_SendMessage_ItemSystem_DepotNak( g_curPC, reply, error );
}
void GTH_ProcessMessage_ItemSystem_PrecocityItem()
{
int pos = MSG_ReadShort();
int tempInven, itemTableIndex;
int reply = 1, error = 0;
if( g_curPC->mouseInventory >= 0 )
{
if( g_curPC->precocityInventory[pos] >= 0 )
{
tempInven = g_curPC->mouseInventory;
g_curPC->mouseInventory = g_curPC->precocityInventory[pos];
g_curPC->precocityInventory[pos] = tempInven;
itemTableIndex = g_curPC->item[g_curPC->precocityInventory[pos]].itemTableIdx;
if( g_itemTable[itemTableIndex].etcItemType == ETCITEM_TYPE_PRECOCITY )
{
if(gGameConfigFlag.m_bPrecocity_Time)
{
g_curPC->precocityTime[pos] = g_itemTable[itemTableIndex].precocity.precocityTime * g_curPC->PremiumInfo.fItemPrecocityTimeRatio;
}
else
{
g_curPC->precocityTime[pos] = g_itemTable[itemTableIndex].precocity.precocityTime;
}
}
else
{
g_curPC->precocityTime[pos] = -1;
}
}
else
{
g_curPC->precocityInventory[pos] = g_curPC->mouseInventory;
g_curPC->mouseInventory = -1;
itemTableIndex = g_curPC->item[g_curPC->precocityInventory[pos]].itemTableIdx;
if( g_itemTable[itemTableIndex].etcItemType == ETCITEM_TYPE_PRECOCITY )
{
if(gGameConfigFlag.m_bPrecocity_Time)
{
g_curPC->precocityTime[pos] = g_itemTable[itemTableIndex].precocity.precocityTime * g_curPC->PremiumInfo.fItemPrecocityTimeRatio;
}
else
{
g_curPC->precocityTime[pos] = g_itemTable[itemTableIndex].precocity.precocityTime;
}
}
else
{
g_curPC->precocityTime[pos] = -1;
}
}
}
else
{
g_curPC->mouseInventory = g_curPC->precocityInventory[pos];
g_curPC->precocityInventory[pos] = -1;
g_curPC->precocityTime[pos] = -1;
}
GTH_SendMessage_ItemSystem_PrecocityItem( g_curPC, reply, error, pos );
}
int GTH_AutoUndoPCCraft( playerCharacter_t *pc, int completeFlag )
{
int itemIdx, inventoryPos;
int bIsStack = false, stackNumber = 1;
for( int i = 0; i < MAX_AUTO_TRADEITEMFILD; i ++ )
{
itemIdx = pc->npcAutoSourceInventory[i];
if ( itemIdx < 0 || itemIdx >= MAX_NUMBER_OF_OWNITEM)
continue;
item_t* pItem = NULL;
pItem = gcpTools->GetMyItem(pc, itemIdx);
if ( NULL == pItem )
{
continue;
}
if ( pItem->itemTableIdx < 0 || pItem->itemTableIdx >= MAX_NUMBER_OF_ITEM_TABLE)
continue;
bIsStack = false;
stackNumber = 1;
if( g_itemTable[pItem->itemTableIdx].stackFlag )
{
bIsStack = true;
stackNumber = pItem->durability + 1;
}
int stackItemInvenIdx = GTH_StackMyItem( pc, pItem );
if( stackItemInvenIdx >= 0 )
{
item_t * pInvenItem = NULL;
pInvenItem = gcpTools->GetMyItem(pc, stackItemInvenIdx);
if (NULL == pInvenItem)
continue;
if ( pInvenItem->itemTableIdx <0 || pInvenItem->itemTableIdx >= MAX_NUMBER_OF_ITEM_TABLE)
continue;
pInvenItem->durability += pItem->durability + 1;
if( pInvenItem->durability + 1 >= MAX_COUNT_STACK_ITEM )
pInvenItem->durability = MAX_COUNT_STACK_ITEM - 1;
g_logSystem->WriteToLog( pc, LOG_CLASS_ITEM, "%d;%d;%d;;;%s;%s",
LOG_CLASS_ITEM_UNDO_CRAFT, 0, stackNumber, pInvenItem->name,
GetItemInformationLog( bIsStack, pInvenItem->itemTableIdx, stackItemInvenIdx, -1 ));
GTH_DeleteMyItem( pc, pItem );
g_DBGameServer->SaveItem( pc, pInvenItem, stackItemInvenIdx );
g_DBGameServer->RemoveItem( pc, itemIdx );
}
else
{
inventoryPos = GTH_FindEmptyInventoryPos( pc );
if( inventoryPos >= 0 )
{
pc->inventory[inventoryPos] = itemIdx;
}
g_logSystem->WriteToLog( pc, LOG_CLASS_ITEM, "%d;%d;%d;;;%s;%s",
LOG_CLASS_ITEM_UNDO_CRAFT, 0, stackNumber, pItem->name,
GetItemInformationLog( bIsStack, pItem->itemTableIdx, itemIdx, inventoryPos ));
}
}
if( !completeFlag ) g_logSystem->Write("Make Item Cancel : %s(%s)", pc->name, pc->userID );
else g_logSystem->Write("Make Item Complete : %s(%s)", pc->name, pc->userID );
for( i = 0; i < MAX_AUTO_TRADEITEMFILD; i ++ )
{
pc->npcAutoSourceInventory[i] = -1;
}
return 1;
}
int GTH_UndoPCCraft( playerCharacter_t *pc, int completeFlag )
{
int itemIdx, inventoryPos;
int bIsStack = false, stackNumber = 1;
for( int i = 0; i < MAX_CRAFT_SOURCE_ITEM_SIZE; i ++ )
{
itemIdx = pc->craftSourceInventory[i];
if ( itemIdx < 0 || itemIdx >= MAX_NUMBER_OF_OWNITEM)
continue;
item_t* pItem = NULL;
pItem = gcpTools->GetMyItem(pc, itemIdx);
if ( NULL == pItem )
{
continue;
}
if ( pItem->itemTableIdx < 0 || pItem->itemTableIdx >= MAX_NUMBER_OF_ITEM_TABLE)
continue;
bIsStack = false;
stackNumber = 1;
if( g_itemTable[pItem->itemTableIdx].stackFlag )
{
bIsStack = true;
stackNumber = pItem->durability + 1;
}
int stackItemInvenIdx = GTH_StackMyItem( pc, pItem );
if( stackItemInvenIdx >= 0 )
{
item_t * pInvenItem = NULL;
pInvenItem = gcpTools->GetMyItem(pc, stackItemInvenIdx);
if (NULL == pInvenItem)
continue;
if ( pInvenItem->itemTableIdx <0 || pInvenItem->itemTableIdx >= MAX_NUMBER_OF_ITEM_TABLE)
continue;
pInvenItem->durability += pItem->durability + 1;
if( pInvenItem->durability + 1 >= MAX_COUNT_STACK_ITEM )
pInvenItem->durability = MAX_COUNT_STACK_ITEM - 1;
g_logSystem->WriteToLog( pc, LOG_CLASS_ITEM, "%d;%d;%d;;;%s;%s",
LOG_CLASS_ITEM_UNDO_CRAFT, 0, stackNumber, pInvenItem->name,
GetItemInformationLog( bIsStack, pInvenItem->itemTableIdx, stackItemInvenIdx, -1 ));
GTH_DeleteMyItem( pc, pItem );
g_DBGameServer->SaveItem( pc, pInvenItem, stackItemInvenIdx );
g_DBGameServer->RemoveItem( pc, itemIdx );
}
else
{
inventoryPos = GTH_FindEmptyInventoryPos( pc );
if( inventoryPos >= 0 )
{
pc->inventory[inventoryPos] = itemIdx;
}
g_logSystem->WriteToLog( pc, LOG_CLASS_ITEM, "%d;%d;%d;;;%s;%s",
LOG_CLASS_ITEM_UNDO_CRAFT, 0, stackNumber, pItem->name,
GetItemInformationLog( bIsStack, pItem->itemTableIdx, itemIdx, inventoryPos ));
}
}
for( i = 0; i < MAX_CRAFT_RESULT_ITEM_SIZE; i ++ )
{
itemIdx = pc->craftResultInventory[i];
if ( itemIdx < 0 || itemIdx >= MAX_NUMBER_OF_OWNITEM)
continue;
item_t* pItem = NULL;
pItem = gcpTools->GetMyItem(pc, itemIdx);
if ( NULL == pItem )
{
continue;
}
if ( pItem->itemTableIdx < 0 || pItem->itemTableIdx >= MAX_NUMBER_OF_ITEM_TABLE)
continue;
bIsStack = false;
stackNumber = 1;
if( g_itemTable[pItem->itemTableIdx].stackFlag )
{
bIsStack = true;
stackNumber = pItem->durability + 1;
}
int stackItemInvenIdx = GTH_StackMyItem( pc, pItem );
if( stackItemInvenIdx >= 0 )
{
item_t * pInvenItem = NULL;
pInvenItem = gcpTools->GetMyItem(pc, stackItemInvenIdx);
if (NULL == pInvenItem)
continue;
if ( pInvenItem->itemTableIdx <0 || pInvenItem->itemTableIdx >= MAX_NUMBER_OF_ITEM_TABLE)
continue;
pInvenItem->durability += pItem->durability + 1;
if( pInvenItem->durability + 1 >= MAX_COUNT_STACK_ITEM )
pInvenItem->durability = MAX_COUNT_STACK_ITEM - 1;
g_logSystem->WriteToLog( pc, LOG_CLASS_ITEM, "%d;%d;%d;;;%s;%s",
LOG_CLASS_ITEM_UNDO_CRAFT, 1, stackNumber, pInvenItem->name,
GetItemInformationLog( bIsStack, pInvenItem->itemTableIdx, stackItemInvenIdx, -1 ));
GTH_DeleteMyItem( pc, pItem );
g_DBGameServer->SaveItem( pc, pInvenItem, stackItemInvenIdx );
g_DBGameServer->RemoveItem( pc, itemIdx );
}
else
{
inventoryPos = GTH_FindEmptyInventoryPos( pc );
if( inventoryPos >= 0 )
{
pc->inventory[inventoryPos] = itemIdx;
}
g_logSystem->WriteToLog( pc, LOG_CLASS_ITEM, "%d;%d;%d;;;%s;%s",
LOG_CLASS_ITEM_UNDO_CRAFT, 1, stackNumber, pItem->name,
GetItemInformationLog( bIsStack, pItem->itemTableIdx, itemIdx, inventoryPos ));
}
}
if( !completeFlag ) g_logSystem->Write("Make Item Cancel : %s(%s)", pc->name, pc->userID );
else g_logSystem->Write("Make Item Complete : %s(%s)", pc->name, pc->userID );
for( i = 0; i < MAX_CRAFT_SOURCE_ITEM_SIZE; i ++ )
{
pc->craftSourceInventory[i] = -1;
}
for( i = 0; i < MAX_CRAFT_RESULT_ITEM_SIZE; i ++ )
{
pc->craftResultInventory[i] = -1;
}
return 1;
}
void GTH_ProcessMessage_ItemSystem_CraftClose()
{
if ( FALSE == isValidPCBusy(g_curPC, BUSY_STATE_CRAFT ) )
return;
GTH_UndoPCCraft( g_curPC );
GTH_DeleteNoticePC( g_curPC );
GTH_SendMessage_ItemSystem_CraftClose( g_curPC );
}
void GTH_ProcessMessage_ItemSystem_CraftOpen()
{
int i;
for( i = 0; i < MAX_CRAFT_SOURCE_ITEM_SIZE; i ++ )
{
g_curPC->craftSourceInventory[i] = -1;
}
for( i = 0; i < MAX_CRAFT_RESULT_ITEM_SIZE; i ++ )
{
g_curPC->craftResultInventory[i] = -1;
}
GTH_AddNoticePC( g_curPC, -1, -1, BUSY_STATE_CRAFT );
GTH_SendMessage_ItemSystem_CraftOpen( g_curPC );
}
void GTH_ProcessMessage_ItemSystem_NpcInventoryOpen()
{
int i;
for( i = 0; i < MAX_AUTO_TRADEITEMFILD; i ++ )
{
g_curPC->npcAutoSourceInventory[i] = -1;
}
GTH_AddNoticePC( g_curPC, -1, -1, BUSY_STATE_NPC_INVENTORY );
GTH_SendMessage_ItemSystem_NpcInventoryOpen( g_curPC );
}
void GTH_ProcessMessage_ItemSystem_NpcInventoryClose()
{
if ( FALSE == isValidPCBusy(g_curPC, BUSY_STATE_NPC_INVENTORY))
return;
GTH_AutoUndoPCCraft( g_curPC );
GTH_DeleteNoticePC( g_curPC );
GTH_SendMessage_ItemSystem_NpcInventoryClose( g_curPC );
}
void GTH_ProcessMessage_ItemSystem_AutoCraftItem()
{
int posType = MSG_ReadShort();
int pos = MSG_ReadShort();
int tempInven;
int reply = 1, error = 0;
if( posType == 0 )
{
if( g_curPC->mouseInventory >= 0 )
{
if( g_curPC->npcAutoSourceInventory[pos] >= 0 )
{
tempInven = g_curPC->mouseInventory;
g_curPC->mouseInventory = g_curPC->npcAutoSourceInventory[pos];
g_curPC->npcAutoSourceInventory[pos] = tempInven;
}
else
{
g_curPC->npcAutoSourceInventory[pos] = g_curPC->mouseInventory;
g_curPC->mouseInventory = -1;
}
}
else
{
g_curPC->mouseInventory = g_curPC->npcAutoSourceInventory[pos];
g_curPC->npcAutoSourceInventory[pos] = -1;
}
}
GTH_SendMessage_ItemSystem_AutoQuestCraftItem( g_curPC, reply, error, posType, pos );
}
void GTH_ProcessMessage_ItemSystem_CraftItem()
{
if ( FALSE == isValidPCBusy(g_curPC, BUSY_STATE_CRAFT ) )
return;
int posType = MSG_ReadShort();
int pos = MSG_ReadShort();
int craftIdx = MSG_ReadShort();
int tempInven;
int reply = 1, error = 0;
if( posType == 0 )
{
if( g_curPC->mouseInventory >= 0 )
{
if( g_curPC->craftSourceInventory[pos] >= 0 )
{
tempInven = g_curPC->mouseInventory;
g_curPC->mouseInventory = g_curPC->craftSourceInventory[pos];
g_curPC->craftSourceInventory[pos] = tempInven;
}
else
{
g_curPC->craftSourceInventory[pos] = g_curPC->mouseInventory;
g_curPC->mouseInventory = -1;
}
}
else
{
g_curPC->mouseInventory = g_curPC->craftSourceInventory[pos];
g_curPC->craftSourceInventory[pos] = -1;
}
}
else
{
if( g_curPC->mouseInventory < 0 && g_curPC->craftResultInventory[pos] >= 0 )
{
g_curPC->mouseInventory = g_curPC->craftResultInventory[pos];
g_curPC->craftResultInventory[pos] = -1;
}
}
GTH_SendMessage_ItemSystem_CraftItem( g_curPC, reply, error, posType, pos );
}
void GTH_ProcessMessage_ItemSystem_CraftPrepare()
{
if ( FALSE == isValidPCBusy(g_curPC, BUSY_STATE_CRAFT ) )
return;
int reply = 1, error = 0,craftIdx=-1;
int nak = 0, resultItemIdx[2];
float pro = 0.0f;
resultItemIdx[0] = -1;
resultItemIdx[1] = -1;
GTH_CraftProcess( g_curPC, reply, error, nak, pro, resultItemIdx, true ,craftIdx);
GTH_SendMessage_ItemSystem_CraftPrepare( g_curPC, reply, error, resultItemIdx, nak, pro,craftIdx);
}
void GTH_ProcessMessage_ItemSystem_AutoCraftPrepare()
{
int reply = 1, error = 0;
int idx=-1;
for(int i=0; i<MAX_COUNT_QUEST_STATUS; i++)
{
if(g_curPC->questStatus[i].questIdx == AUTOQUESTSCROLL_ITEM_INDEX)
{
idx=i;
break;
}
}
GTH_AutoCraftProcess( g_curPC, idx,reply, error);
GTH_SendMessage_ItemSystem_AutoCraftPrepare( g_curPC, reply, error);
if(reply)
{
int &fame=g_autoQuestscrollTable[g_curPC->questStatus[idx].dField[0]].dataField[18];
if(fame == -1) fame=0;
g_curPC->rankPoint+=fame;
int pParam[2];
pParam[0]=AUTOQUESTSCROLL_ITEM_INDEX;
pParam[1]=g_curPC->questStatus[idx].dField[0];
AI_NPC_AutoCompleteQuest(g_curPC, pParam );
g_curPC->bautoeffectisvalid=true;
int addItemData2[4];
addItemData2[0] = g_autoQuestscrollTable[g_curPC->questStatus[idx].dField[0]].dataField[15];
addItemData2[1] = -1;
addItemData2[2] = g_autoQuestscrollTable[g_curPC->questStatus[idx].dField[0]].dataField[16];
addItemData2[3] = 0;
AI_NPC_AddItem( g_curPC, addItemData2 );
int itemIdx=-1;
int bIsStack, stackNumber;
for( i = 0; i < MAX_AUTO_TRADEITEMFILD; i ++ )
{
if( g_curPC->npcAutoSourceInventory[i] < 0 ) continue;
itemIdx = g_curPC->npcAutoSourceInventory[i];
bIsStack = false;
stackNumber = 1;
if( g_itemTable[g_curPC->item[itemIdx].itemTableIdx].stackFlag )
{
bIsStack = true;
stackNumber = g_curPC->item[itemIdx].durability + 1;
}
g_logSystem->WriteToLog( g_curPC, LOG_CLASS_ITEM, "%d;%d;;;;%s;%s",
LOG_CLASS_ITEM_CRAFT_SOURCE, stackNumber, g_curPC->item[itemIdx].name,
GetItemInformationLog( bIsStack, g_curPC->item[itemIdx].itemTableIdx, itemIdx, -1 ));
GTH_DeleteMyItem( g_curPC, &g_curPC->item[itemIdx] );
g_curPC->npcAutoSourceInventory[i] = -1;
g_DBGameServer->RemoveItem( g_curPC, itemIdx );
}
GTH_SendMessage_AutoQuestScrollComplete( g_curPC, g_curPC->questStatus[idx].dField[0]);
}
}
void GTH_ProcessMessage_ItemSystem_CraftComplete()
{
if ( FALSE == isValidPCBusy(g_curPC, BUSY_STATE_CRAFT ) )
return;
int reply = 1, error = 0;
int nak = 0, resultItemIdx[2],craftIdx;
float pro = 0.0f;
int bIsSuccess;
char logBuffer[20];
resultItemIdx[0] = -1;
resultItemIdx[1] = -1;
bIsSuccess = GTH_CraftProcess( g_curPC, reply, error, nak, pro, resultItemIdx, false,craftIdx );
_snprintf( logBuffer, 20, "%.5f", pro );
g_logSystem->WriteToLog( g_curPC, LOG_CLASS_ITEM, "%d;%d;%d;;;%s;",
LOG_CLASS_ITEM_COMPLETE_CRAFT, bIsSuccess, nak, logBuffer );
GTH_SendMessage_ItemSystem_CraftComplete( g_curPC, reply, error, nak );
}
int GTH_UndoPCBooth( playerCharacter_t *pc )
{
int itemIdx, inventoryPos;
int bIsStack = false, stackNumber = 1;
for( int i = 0; i < MAX_BOOTH_INVENTORY_SIZE; i ++ )
{
itemIdx = pc->boothInventory[i].itemIdx;
if ( itemIdx < 0 || itemIdx >= MAX_NUMBER_OF_OWNITEM)
continue;
item_t* pItem = NULL;
pItem = gcpTools->GetMyItem(pc, itemIdx);
if ( NULL == pItem )
{
continue;
}
if ( pItem->itemTableIdx < 0 || pItem->itemTableIdx >= MAX_NUMBER_OF_ITEM_TABLE)
continue;
bIsStack = false;
stackNumber = 1;
if( g_itemTable[pItem->itemTableIdx].stackFlag )
{
bIsStack = true;
stackNumber = pItem->durability + 1;
}
int stackItemInvenIdx = GTH_StackMyItem( pc, pItem );
if( stackItemInvenIdx >= 0 )
{
item_t * pInvenItem = NULL;
pInvenItem = gcpTools->GetMyItem(pc, stackItemInvenIdx);
if (NULL == pInvenItem)
continue;
if ( pInvenItem->itemTableIdx <0 || pInvenItem->itemTableIdx >= MAX_NUMBER_OF_ITEM_TABLE)
continue;
pInvenItem->durability += pItem->durability + 1;
if( pInvenItem->durability + 1 >= MAX_COUNT_STACK_ITEM )
pInvenItem->durability = MAX_COUNT_STACK_ITEM - 1;
g_logSystem->WriteToLog( pc, LOG_CLASS_ITEM, "%d;%d;;;;%s;%s",
LOG_CLASS_ITEM_UNDO_BOOTH, stackNumber, pInvenItem->name,
GetItemInformationLog( bIsStack, pInvenItem->itemTableIdx, stackItemInvenIdx, -1 ));
GTH_DeleteMyItem( pc, pItem );
g_DBGameServer->SaveItem( pc, pInvenItem, stackItemInvenIdx );
g_DBGameServer->RemoveItem( pc, itemIdx );
}
else
{
inventoryPos = GTH_FindEmptyInventoryPos( pc );
if( inventoryPos >= 0 )
{
pc->inventory[inventoryPos] = itemIdx;
}
g_logSystem->WriteToLog( pc, LOG_CLASS_ITEM, "%d;%d;;;;%s;%s",
LOG_CLASS_ITEM_UNDO_BOOTH, stackNumber, pItem->name,
GetItemInformationLog( bIsStack, pItem->itemTableIdx, itemIdx, inventoryPos ));
}
}
g_logSystem->Write("Shop Close : %s(%s)", pc->name, pc->userID );
for( i = 0; i < MAX_BOOTH_INVENTORY_SIZE; i ++ )
{
pc->boothInventory[i].itemIdx = -1;
}
return 1;
}
void GTH_ProcessMessage_ItemSystem_BoothSellOpen()
{
int i;
int reply = 1, error = 0;
if ( g_curPC->event != GTH_EV_CHAR_SIT )
{
reply = 0;
error = 0;
GTH_SendMessage_ItemSystem_BoothSellOpen( g_curPC, reply, error );
return;
}
if( g_curPC->busyState != BUSY_STATE_NONE || !g_curPC->alive || !g_curPC->ready )
{
reply = 0;
error = 0;
GTH_SendMessage_ItemSystem_BoothSellOpen( g_curPC, reply, error );
return;
}
for( i = 0; i < MAX_BOOTH_INVENTORY_SIZE; i ++ )
{
g_curPC->boothInventory[i].itemIdx = -1;
g_curPC->boothInventory[i].price = 0;
}
for( i = 0; i < MAX_COUNT_BOOTH_BUYER; i ++ )
{
g_curPC->boothBuyerIdx[i] = -1;
}
GTH_AddNoticePC( g_curPC, -1, -1, BUSY_STATE_BOOTH_SELL_PREPARE );
GTH_SendMessage_ItemSystem_BoothSellOpen( g_curPC, reply, error );
g_logSystem->Write("Shop Open : %s(%s)", g_curPC->name, g_curPC->userID );
}
#include "../Tools/CTools.h"
extern CTools* gcpTools;
void GTH_ProcessMessage_ItemSystem_BoothSellItem()
{
int Invenpos = MSG_ReadShort();
int nak = MSG_ReadLong();
int tempInven;
if ( Invenpos < 0 || Invenpos >= MAX_BOOTH_INVENTORY_SIZE)
{
GTH_SendMessage_ItemSystem_BoothSellItem( g_curPC, 0, 0, 0 );
return;
}
if ( g_curPC->busyState != BUSY_STATE_BOOTH_SELL_PREPARE )
{
GTH_SendMessage_ItemSystem_BoothSellItem( g_curPC, 0, 0, 0 );
return;
}
item_t* pMouseInItem = NULL;
pMouseInItem = gcpTools->GetMyItem(g_curPC, g_curPC->mouseInventory);
if ( pMouseInItem != NULL)
{
int totalSellPrice = 0;
for (int BoothInvenIdx = 0; BoothInvenIdx < MAX_BOOTH_INVENTORY_SIZE; BoothInvenIdx ++)
{
if ( BoothInvenIdx == Invenpos ) continue;
totalSellPrice += g_curPC->boothInventory[BoothInvenIdx].price;
}
if( GTH_IsStackItem( pMouseInItem ) )
totalSellPrice += (pMouseInItem->durability + 1 ) * nak;
else
totalSellPrice += nak;
if (g_curPC->curChargeSE + totalSellPrice > MAX_OWN_NAK)
{
GTH_SendMessage_ItemSystem_BoothSellItem( g_curPC, 0, 0, 1 );
return;
}
if( g_curPC->boothInventory[Invenpos].itemIdx >= 0 )
{
tempInven = g_curPC->mouseInventory;
g_curPC->mouseInventory = g_curPC->boothInventory[Invenpos].itemIdx;
g_curPC->boothInventory[Invenpos].itemIdx = tempInven;
g_curPC->boothInventory[Invenpos].price = nak;
}
else
{
g_curPC->boothInventory[Invenpos].itemIdx = g_curPC->mouseInventory;
g_curPC->boothInventory[Invenpos].price = nak;
g_curPC->mouseInventory = -1;
}
}
else
{
g_curPC->mouseInventory = g_curPC->boothInventory[Invenpos].itemIdx;
g_curPC->boothInventory[Invenpos].itemIdx = -1;
g_curPC->boothInventory[Invenpos].price = 0;
}
GTH_SendMessage_ItemSystem_BoothSellItem( g_curPC, 1, Invenpos );
}
void GTH_ProcessMessage_ItemSystem_BoothSellStart()
{
strcpy( g_curPC->boothName, MSG_ReadString() );
strcpy( g_curPC->boothInfo, MSG_ReadString() );
GTH_AddNoticePC( g_curPC, -1, -1, BUSY_STATE_BOOTH_SELL );
GTH_SendMessage_ItemSystem_BoothSellStart( g_curPC );
g_logSystem->Write("Shop Sell Start : %s(%s)", g_curPC->name, g_curPC->userID );
}
void GTH_ProcessMessage_ItemSystem_BoothSellClose()
{
if( g_curPC->busyState == BUSY_STATE_BOOTH_SELL_PREPARE )
{
GTH_UndoPCBooth( g_curPC );
GTH_DeleteNoticePC( g_curPC );
GTH_SendMessage_ItemSystem_BoothSellClose( g_curPC, 0 );
}
else if( g_curPC->busyState == BUSY_STATE_BOOTH_SELL )
{
int pcIdx;
for( int i = 0; i < MAX_COUNT_BOOTH_BUYER; i ++ )
{
if( g_curPC->boothBuyerIdx[i] < 0 ) continue;
pcIdx = g_curPC->boothBuyerIdx[i];
if( g_pc[pcIdx].busyState == BUSY_STATE_BOOTH_BUY )
{
GTH_SendMessage_ItemSystem_BoothBuyClose( &g_pc[pcIdx], 1, 0, 0 );
GTH_DeleteNoticePC( &g_pc[pcIdx] );
}
else
{
g_logSystem->Write("Shop DeleteBusyState Error : %s(%s) Cur Status(%d)", g_pc[pcIdx].name, g_pc[pcIdx].userID, g_pc[pcIdx].busyState );
g_logSystem->WriteToLog( &g_pc[pcIdx], LOG_CLASS_ITEM, "%d;;;;;%s;%s", g_pc[pcIdx].busyState, "Shop Error", "ProcessSellClose" );
}
g_curPC->boothBuyerIdx[i] = -1;
}
GTH_AddNoticePC( g_curPC, -1, -1, BUSY_STATE_BOOTH_SELL_PREPARE );
GTH_SendMessage_ItemSystem_BoothSellClose( g_curPC, 1 );
}
}
void GTH_ProcessMessage_ItemSystem_BoothBuyOpen()
{
int boothPCIdx = MSG_ReadShort();
int reply = 1, error = 0;
int boothBuyerIdx;
if( boothPCIdx < 0 )
{
reply = 0;
error = ERROR_ITEMSYSTEM_6;
GTH_SendMessage_ItemSystem_BoothBuyOpen( g_curPC, reply, error, NULL, 0 );
return;
}
if( g_pc[boothPCIdx].busyState != BUSY_STATE_BOOTH_SELL )
{
reply = 0;
error = ERROR_ITEMSYSTEM_4;
GTH_SendMessage_ItemSystem_BoothBuyOpen( g_curPC, reply, error, &g_pc[boothPCIdx], 0 );
return;
}
for( int i = 0 ; i < MAX_COUNT_BOOTH_BUYER; i ++ )
{
if( g_pc[boothPCIdx].boothBuyerIdx[i] < 0 ) break;
}
if( i == MAX_COUNT_BOOTH_BUYER )
{
reply = 0;
error = ERROR_ITEMSYSTEM_5;
GTH_SendMessage_ItemSystem_BoothBuyOpen( g_curPC, reply, error, &g_pc[boothPCIdx], 0 );
return;
}
boothBuyerIdx = i;
GTH_AddNoticePC( g_curPC, ENTITY_PC, boothPCIdx, BUSY_STATE_BOOTH_BUY );
g_pc[boothPCIdx].boothBuyerIdx[boothBuyerIdx] = g_curPC->idx;
GTH_SendMessage_ItemSystem_BoothBuyOpen( g_curPC, reply, error, &g_pc[boothPCIdx], 0 );
GTH_SendMessage_ItemSystem_BoothBuyOpen( &g_pc[boothPCIdx], reply, error, g_curPC, 1 );
}
void GTH_ProcessMessage_ItemSystem_BoothBuyItem()
{
int pos, reply = 1, error = 0;
int itemCount;
int boothPCIdx = g_curPC->friendlyEntityIdx;
int itemIdx, price, itemTableIdx, inventoryPos, buyItemIdx;
item_t buyItem, *upItem;
char generateID[20];
int bIsStack = false, stackNumber = 1;
char logBuffer[100];
pos = MSG_ReadShort();
itemCount = MSG_ReadShort();
if( boothPCIdx < 0 )
{
reply = 0;
error = ERROR_ITEMSYSTEM_6;
GTH_SendMessage_ItemSystem_BoothBuyItem( g_curPC, reply, error, pos, 0, 0 );
return;
}
if( g_pc[boothPCIdx].busyState != BUSY_STATE_BOOTH_SELL )
{
reply = 0;
error = ERROR_ITEMSYSTEM_4;
GTH_SendMessage_ItemSystem_BoothBuyItem( g_curPC, reply, error, pos, 0, 0 );
return;
}
itemIdx = g_pc[boothPCIdx].boothInventory[pos].itemIdx;
if( itemIdx < 0 )
{
reply = 0;
error = ERROR_ITEMSYSTEM_10;
GTH_SendMessage_ItemSystem_BoothBuyItem( g_curPC, reply, error, pos, 0, 0 );
return;
}
if( itemCount > g_pc[boothPCIdx].item[itemIdx].durability + 1 )
{
reply = 0;
error = ERROR_ITEMSYSTEM_8;
GTH_SendMessage_ItemSystem_BoothBuyItem( g_curPC, reply, error, pos, 0, 0 );
return;
}
//lucky 2012 Dupe metod #1 patched.
if( itemCount < 0 )
{
reply = 0;
error = ERROR_ITEMSYSTEM_8;
GTH_SendMessage_ItemSystem_BoothBuyItem( g_curPC, reply, error, pos, 0, 0 );
return;
}
//end
price = g_pc[boothPCIdx].boothInventory[pos].price * itemCount;
if( price > g_curPC->curChargeSE )
{
reply = 0;
error = ERROR_ITEMSYSTEM_7;
GTH_SendMessage_ItemSystem_BoothBuyItem( g_curPC, reply, error, pos, 0, 0 );
return;
}
inventoryPos = GTH_FindEmptyInventoryPos( g_curPC );
if( inventoryPos < 0 )
{
reply = 0;
error = ERROR_ITEMSYSTEM_9;
GTH_SendMessage_ItemSystem_BoothBuyItem( g_curPC, reply, error, pos, 0, 0 );
return;
}
if( g_curPC->curItemWeight > g_curPC->calItemWeight )
{
reply = 0;
error = ERROR_ITEMSYSTEM_11;
GTH_SendMessage_ItemSystem_BoothBuyItem( g_curPC, reply, error, pos, 0, 0 );
return;
}
memcpy( &buyItem, &g_pc[boothPCIdx].item[itemIdx], sizeof( item_t ) );
itemTableIdx = buyItem.itemTableIdx;
if( g_itemTable[itemTableIdx].stackFlag )
{
bIsStack = true;
stackNumber = itemCount;
}
_snprintf( logBuffer, 100, "%s, %s", g_curPC->name,
GetItemInformationLog( bIsStack, g_pc[boothPCIdx].item[itemIdx].itemTableIdx, itemIdx, -1 ) );
g_logSystem->WriteToLog( &g_pc[boothPCIdx], LOG_CLASS_ITEM, "%d;%d;%d;;;%s;%s",
LOG_CLASS_ITEM_SELL_BOOTH, stackNumber, price,
g_pc[boothPCIdx].item[itemIdx].name, logBuffer );
if( g_itemTable[itemTableIdx].stackFlag )
{
bIsStack = true;
stackNumber = itemCount;
if( g_pc[boothPCIdx].item[itemIdx].durability + 1 - itemCount <= 0 )
{
g_pc[boothPCIdx].boothInventory[pos].itemIdx = -1;
GTH_DeleteMyItem( &g_pc[boothPCIdx], &g_pc[boothPCIdx].item[itemIdx] );
g_DBGameServer->RemoveItem( &g_pc[boothPCIdx], itemIdx );
}
else
{
g_pc[boothPCIdx].item[itemIdx].durability -= itemCount;
g_DBGameServer->SaveItem( &g_pc[boothPCIdx], &g_pc[boothPCIdx].item[itemIdx], itemIdx );
}
buyItem.durability = itemCount - 1;
}
else
{
g_pc[boothPCIdx].boothInventory[pos].itemIdx = -1;
GTH_DeleteMyItem( &g_pc[boothPCIdx], &g_pc[boothPCIdx].item[itemIdx] );
g_DBGameServer->RemoveItem( &g_pc[boothPCIdx], itemIdx );
}
int stackItemIdx = GTH_StackMyItem( g_curPC, &buyItem );
if( stackItemIdx >= 0 )
{
upItem = &g_curPC->item[stackItemIdx];
upItem->durability += buyItem.durability + 1;
if( upItem->durability + 1 >= MAX_COUNT_STACK_ITEM ) upItem->durability = MAX_COUNT_STACK_ITEM - 1;
_snprintf( logBuffer, 100, "%s, %s", g_pc[boothPCIdx].name,
GetItemInformationLog( bIsStack, upItem->itemTableIdx, stackItemIdx, -1 ) );
g_logSystem->WriteToLog( g_curPC, LOG_CLASS_ITEM, "%d;%d;%d;;;%s;%s",
LOG_CLASS_ITEM_BUY_BOOTH, stackNumber, price,
upItem->name, logBuffer );
g_DBGameServer->SaveItem( g_curPC, upItem, stackItemIdx );
}
else
{
buyItemIdx = GTH_AddMyItem( g_curPC, &buyItem );
inventoryPos = GTH_FindEmptyInventoryPos( g_curPC );
if( inventoryPos >= 0 )
{
g_curPC->inventory[inventoryPos] = buyItemIdx;
}
_snprintf( logBuffer, 100, "%s, %s", g_pc[boothPCIdx].name,
GetItemInformationLog( bIsStack, buyItem.itemTableIdx, buyItemIdx, inventoryPos ) );
g_logSystem->WriteToLog( g_curPC, LOG_CLASS_ITEM, "%d;%d;%d;;;%s;%s",
LOG_CLASS_ITEM_BUY_BOOTH, stackNumber, price,
buyItem.name, logBuffer );
strcpy( generateID, "boothItem" );
g_DBGameServer->AddItem( g_curPC, &buyItem, buyItemIdx, generateID );
}
g_pc[boothPCIdx].curChargeSE += price;
if( g_pc[boothPCIdx].curChargeSE > MAX_OWN_NAK ) g_pc[boothPCIdx].curChargeSE = MAX_OWN_NAK;
g_curPC->curChargeSE -= price;
GTH_SendMessage_ItemSystem_BoothBuyItem( g_curPC, reply, error, pos, itemCount, 0 );
GTH_SendMessage_ItemSystem_BoothBuyItem( &g_pc[boothPCIdx], reply, error, pos, itemCount, 1 );
int pcIdx;
for( int i = 0; i < MAX_COUNT_BOOTH_BUYER; i ++ )
{
if( g_pc[boothPCIdx].boothBuyerIdx[i] < 0 ) continue;
pcIdx = g_pc[boothPCIdx].boothBuyerIdx[i];
if( g_pc[pcIdx].busyState == BUSY_STATE_BOOTH_BUY )
{
GTH_SendMessage_ItemSystem_BoothBuyUpdate( &g_pc[pcIdx], &g_pc[boothPCIdx] );
}
else
{
g_logSystem->Write("Shop Update Error : %s(%s) Status(%d)", g_pc[pcIdx].name, g_pc[pcIdx].userID, g_pc[pcIdx].busyState );
g_logSystem->WriteToLog( &g_pc[pcIdx], LOG_CLASS_ITEM, "%d;;;;;%s;%s", g_pc[pcIdx].busyState, "Shop Error", "Update" );
}
}
}
void GTH_ProcessMessage_ItemSystem_BoothBuyClose()
{
int boothPCIdx = g_curPC->friendlyEntityIdx;
int reply = 1, error = 0;
if( boothPCIdx < 0 )
{
reply = 0;
error = ERROR_ITEMSYSTEM_6;
GTH_SendMessage_ItemSystem_BoothBuyClose( g_curPC, reply, error, 0 );
return;
}
for( int i = 0; i < MAX_COUNT_BOOTH_BUYER; i ++ )
{
if( g_pc[boothPCIdx].boothBuyerIdx[i] < 0 ) continue;
if( g_pc[boothPCIdx].boothBuyerIdx[i] == g_curPC->idx )
{
g_pc[boothPCIdx].boothBuyerIdx[i] = -1;
break;
}
}
GTH_DeleteNoticePC( g_curPC );
GTH_SendMessage_ItemSystem_BoothBuyClose( g_curPC, reply, error, 0 );
GTH_SendMessage_ItemSystem_BoothBuyClose( &g_pc[boothPCIdx], reply, error, 1, g_curPC->name );
}
int GTH_UndoPCUpgrade( playerCharacter_t *pc, int completeFlag )
{
if ( FALSE == isValidPCBusy(pc, BUSY_STATE_UPGRADE))
return FALSE;
int itemIdx, inventoryPos;
int bIsStack, stackNumber;
for( int i = 0; i < MAX_UPGRADE_SOURCE_ITEM_SIZE; i ++ )
{
itemIdx = pc->upgradeSourceInventory[i];
if ( itemIdx < 0 || itemIdx >= MAX_NUMBER_OF_OWNITEM)
continue;
item_t* pItem = NULL;
pItem = gcpTools->GetMyItem(pc, itemIdx);
if ( NULL == pItem )
{
continue;
}
if ( pItem->itemTableIdx < 0 || pItem->itemTableIdx >= MAX_NUMBER_OF_ITEM_TABLE)
continue;
bIsStack = false;
stackNumber = 1;
if( g_itemTable[pItem->itemTableIdx].stackFlag )
{
bIsStack = true;
stackNumber = pItem->durability + 1;
}
int stackItemInvenIdx = GTH_StackMyItem( pc, pItem );
if( stackItemInvenIdx >= 0 )
{
item_t * pInvenItem = NULL;
pInvenItem = gcpTools->GetMyItem(pc, stackItemInvenIdx);
if (NULL == pInvenItem)
continue;
if ( pInvenItem->itemTableIdx <0 || pInvenItem->itemTableIdx >= MAX_NUMBER_OF_ITEM_TABLE)
continue;
pInvenItem->durability += pItem->durability + 1;
if( pInvenItem->durability + 1 >= MAX_COUNT_STACK_ITEM )
pInvenItem->durability = MAX_COUNT_STACK_ITEM - 1;
g_logSystem->WriteToLog( pc, LOG_CLASS_ITEM, "%d;%d;%d;;;%s;%s",
LOG_CLASS_ITEM_UNDO_UPGRADE, 0, stackNumber, pInvenItem->name,
GetItemInformationLog( bIsStack, pInvenItem->itemTableIdx, stackItemInvenIdx, -1 ));
GTH_DeleteMyItem( pc, pItem );
g_DBGameServer->SaveItem( pc, pInvenItem, stackItemInvenIdx);
g_DBGameServer->RemoveItem( pc, itemIdx );
}
else
{
inventoryPos = GTH_FindEmptyInventoryPos( pc );
if( inventoryPos >= 0 )
{
pc->inventory[inventoryPos] = itemIdx;
}
g_logSystem->WriteToLog( pc, LOG_CLASS_ITEM, "%d;%d;%d;;;%s;%s",
LOG_CLASS_ITEM_UNDO_UPGRADE, 0, stackNumber, pItem->name,
GetItemInformationLog( bIsStack, pItem->itemTableIdx, itemIdx, inventoryPos ));
}
}
itemIdx = pc->upgradeResultInventory;
if( itemIdx >= 0 || itemIdx < MAX_NUMBER_OF_OWNITEM )
{
item_t* pItem = NULL;
pItem = gcpTools->GetMyItem(pc, itemIdx);
if ( NULL == pItem )
{
goto UPGRADE_OUT;
}
if ( pItem->itemTableIdx < 0 || pItem->itemTableIdx >= MAX_NUMBER_OF_ITEM_TABLE)
goto UPGRADE_OUT;
bIsStack = false;
stackNumber = 1;
if( g_itemTable[pItem->itemTableIdx].stackFlag )
{
bIsStack = true;
stackNumber = pItem->durability + 1;
}
int stackItemInvenIdx = GTH_StackMyItem( pc, pItem );
if( stackItemInvenIdx >= 0 )
{
item_t * pInvenItem = NULL;
pInvenItem = gcpTools->GetMyItem(pc, stackItemInvenIdx);
if (NULL == pInvenItem)
goto UPGRADE_OUT;
if ( pInvenItem->itemTableIdx <0 || pInvenItem->itemTableIdx >= MAX_NUMBER_OF_ITEM_TABLE)
goto UPGRADE_OUT;
pInvenItem->durability += pItem->durability + 1;
if( pInvenItem->durability + 1 >= MAX_COUNT_STACK_ITEM )
pInvenItem->durability = MAX_COUNT_STACK_ITEM - 1;
g_logSystem->WriteToLog( pc, LOG_CLASS_ITEM, "%d;%d;%d;;;%s;%s",
LOG_CLASS_ITEM_UNDO_UPGRADE, 1, stackNumber, pInvenItem->name,
GetItemInformationLog( bIsStack, pInvenItem->itemTableIdx, stackItemInvenIdx, -1 ));
GTH_DeleteMyItem( pc, pItem );
g_DBGameServer->SaveItem( pc, pInvenItem, stackItemInvenIdx );
g_DBGameServer->RemoveItem( pc, itemIdx );
}
else
{
inventoryPos = GTH_FindEmptyInventoryPos( pc );
if( inventoryPos >= 0 )
{
pc->inventory[inventoryPos] = itemIdx;
}
g_logSystem->WriteToLog( pc, LOG_CLASS_ITEM, "%d;%d;%d;;;%s;%s",
LOG_CLASS_ITEM_UNDO_UPGRADE, 1, stackNumber, pItem->name,
GetItemInformationLog( bIsStack, pItem->itemTableIdx, itemIdx, inventoryPos ));
}
}
UPGRADE_OUT:
if( !completeFlag ) g_logSystem->Write("Item Upgrade Cancel : %s(%s)", pc->name, pc->userID );
else g_logSystem->Write("Item Upgrade Complete : %s(%s)", pc->name, pc->userID );
for( i = 0; i < MAX_UPGRADE_SOURCE_ITEM_SIZE; i ++ )
{
pc->upgradeSourceInventory[i] = -1;
}
pc->upgradeResultInventory = -1;
return 1;
}
void GTH_ProcessMessage_ItemSystem_UpgradeClose()
{
GTH_UndoPCUpgrade( g_curPC );
GTH_DeleteNoticePC( g_curPC );
GTH_SendMessage_ItemSystem_UpgradeClose( g_curPC );
}
void GTH_ProcessMessage_ItemSystem_UpgradeOpen()
{
int i;
for( i = 0; i < MAX_UPGRADE_SOURCE_ITEM_SIZE; i ++ )
{
g_curPC->upgradeSourceInventory[i] = -1;
}
g_curPC->upgradeResultInventory = -1;
GTH_AddNoticePC( g_curPC, -1, -1, BUSY_STATE_UPGRADE );
GTH_SendMessage_ItemSystem_UpgradeOpen( g_curPC );
}
void GTH_ProcessMessage_ItemSystem_UpgradeItem()
{
if ( FALSE == isValidPCBusy(g_curPC, BUSY_STATE_UPGRADE))
return;
int posType = MSG_ReadShort();
int pos = MSG_ReadShort();
int tempInven;
int reply = 1, error = 0;
if( posType == 0 )
{
if( g_curPC->mouseInventory >= 0 )
{
if( g_curPC->upgradeSourceInventory[pos] >= 0 )
{
tempInven = g_curPC->mouseInventory;
g_curPC->mouseInventory = g_curPC->upgradeSourceInventory[pos];
g_curPC->upgradeSourceInventory[pos] = tempInven;
}
else
{
g_curPC->upgradeSourceInventory[pos] = g_curPC->mouseInventory;
g_curPC->mouseInventory = -1;
}
}
else
{
g_curPC->mouseInventory = g_curPC->upgradeSourceInventory[pos];
g_curPC->upgradeSourceInventory[pos] = -1;
}
}
else
{
if( g_curPC->mouseInventory < 0 && g_curPC->upgradeResultInventory >= 0 )
{
g_curPC->mouseInventory = g_curPC->upgradeResultInventory;
g_curPC->upgradeResultInventory = -1;
}
}
GTH_SendMessage_ItemSystem_UpgradeItem( g_curPC, reply, error, posType, pos );
}
void GTH_ProcessMessage_ItemSystem_UpgradePrepare()
{
if ( FALSE == isValidPCBusy(g_curPC, BUSY_STATE_UPGRADE))
return;
int reply = 1, error = 0;
int nak = 0, resultItemIdx = 0;
int currentGrade = 0, nextGrade = 0;
float pro = 0.0f, vanishPro = 0.0f, downGradePro = 0.0f;
int optionIdx = 0;
resultItemIdx = -1;
optionIdx = MSG_ReadByte();
GTH_UpgradeProcess( g_curPC, optionIdx, reply, error, nak, pro, vanishPro, downGradePro, currentGrade, nextGrade, resultItemIdx, true );
GTH_SendMessage_ItemSystem_UpgradePrepare( g_curPC, reply, error, resultItemIdx, nak, pro, vanishPro, downGradePro, currentGrade, nextGrade, optionIdx );
}
void GTH_ProcessMessage_ItemSystem_UpgradeComplete()
{
if ( FALSE == isValidPCBusy(g_curPC, BUSY_STATE_UPGRADE))
return;
int reply = 1, error = 0;
int nak = 0, resultItemIdx, success;
int currentGrade = 0, nextGrade = 0;
float pro = 0.0f, vanishPro = 0.0f, downGradePro = 0.0f;
int optionIdx = 0;
char logBuffer[20];
resultItemIdx = -1;
optionIdx = MSG_ReadByte();
success = GTH_UpgradeProcess( g_curPC, optionIdx, reply, error, nak, pro, vanishPro, downGradePro, currentGrade, nextGrade, resultItemIdx, false );
_snprintf( logBuffer, 20, "%.5f", pro );
g_logSystem->WriteToLog( g_curPC, LOG_CLASS_ITEM, "%d;%d;%d;;;%s;",
LOG_CLASS_ITEM_COMPLETE_UPGRADE, success, nak, logBuffer );
GTH_SendMessage_ItemSystem_UpgradeComplete( g_curPC, reply, error, nak, success, resultItemIdx, optionIdx, nextGrade );
}
void GTH_ProcessMessage_ItemSystem_DeletePrepare()
{
int reply = 1, error = 0;
int nak = 0, resultItemIdx = 0;
int currentGrade = 0, nextGrade = 0;
float pro = 0.0f, vanishPro = 0.0f;
resultItemIdx = -1;
int optionIdx = MSG_ReadByte();
GTH_DeleteProcess( g_curPC, reply, error, optionIdx, true );
GTH_SendMessage_ItemSystem_DeletePrepare( g_curPC, reply, error, optionIdx );
}
void GTH_ProcessMessage_ItemSystem_DeleteComplete()
{
int reply = 1, error = 0;
int nak = 0, resultItemIdx, success;
resultItemIdx = -1;
int optionIdx = MSG_ReadByte();
success = GTH_DeleteProcess( g_curPC, reply, error, optionIdx, false );
GTH_SendMessage_ItemSystem_DeleteComplete( g_curPC, reply, error, success, optionIdx );
}
void GTH_ProcessMessage_Friends (playerCharacter_t* pPlayer)
{
switch ( MSG_ReadByte () )
{
case FRIENDS_INVITE:
GTH_ProcessMessage_Friends_Invite (pPlayer) ;
break ;
case FRIENDS_ACCEPT:
GTH_ProcessMessage_Friends_Accept () ;
break ;
case FRIENDS_REJECT:
GTH_ProcessMessage_Friends_Reject () ;
break ;
case FRIENDS_REMOVE:
GTH_ProcessMessage_Friends_Remove () ;
break ;
default:
break ;
}
}
void GTH_ProcessMessage_Friends_Invite (playerCharacter_t* pPlayer)
{
int idx = MSG_ReadShort ();
playerCharacter_t* pTarketPlayer = gcpTools->GetPlayerRecordPointer(idx);
if( NULL == pTarketPlayer){
GTH_DisconnectPlayer( pPlayer,FALSE);
return;
}
if ( FALSE == pPlayer->active || FALSE == pTarketPlayer->ready )
{
GTH_SendMessage_Friends_Invite ( pPlayer, 0, FRIENDS_ERROR_NOT_READY, pTarketPlayer->idx, true );
return ;
}
if ( pPlayer->friends.count >= MAX_FRIENDS || pTarketPlayer->friends.count >= MAX_FRIENDS)
{
return;
}
if ( pTarketPlayer->worldIdx != pPlayer->worldIdx )
{
GTH_SendMessage_Friends_Invite ( pPlayer, 0, FRIENDS_ERROR_WRONG_USER, pTarketPlayer->idx, true );
return ;
}
if ( pTarketPlayer->friendsBusy == true || pPlayer->friendsBusy == true )
{
GTH_SendMessage_Friends_Invite ( pPlayer, 0, FRIENDS_ERROR_BUSY, pTarketPlayer->idx, true );
return ;
}
if( (pPlayer->busyState == BUSY_STATE_BATTLEPRACTICE) ||
(pTarketPlayer->busyState == BUSY_STATE_BATTLEPRACTICE)){
GTH_SendMessage_Friends_Invite ( pPlayer, 0, FRIENDS_ERROR_BUSY, pTarketPlayer->idx, true );
return ;
}
bool registered = false;
for (int i = 0 ; i < pPlayer->friends.count ; ++i)
{
if ( !stricmp (pTarketPlayer->name, pPlayer->friends.names[i] ) )
registered = true;
}
if ( registered )
{
GTH_SendMessage_Friends_Invite ( pPlayer, 0, FRIENDS_ERROR_WRONG_USER, idx, true );
return;
}
pPlayer->friendsBusy = true ;
pTarketPlayer->friendsBusy = true ;
GTH_SendMessage_Friends_Invite ( pPlayer, 1, 0, pTarketPlayer->idx, true );
GTH_SendMessage_Friends_Invite ( pTarketPlayer, 1, 0, pPlayer->idx, false );
}
void GTH_ProcessMessage_Friends_Accept ()
{
int idx = MSG_ReadShort();
if ( !g_pc[idx].active || !g_pc[idx].ready )
{
GTH_SendMessage_Friends_Invite ( g_curPC, 0, FRIENDS_ERROR_NOT_READY, idx, true );
return ;
}
if ( g_pc[idx].worldIdx != g_curPC->worldIdx )
{
GTH_SendMessage_Friends_Invite ( g_curPC, 0, FRIENDS_ERROR_WRONG_USER, idx, true );
return ;
}
bool registered = false ;
for (int i = 0; i < g_curPC->friends.count; ++i)
{
if ( !stricmp (g_pc[idx].name, g_curPC->friends.names[i]) )
{
registered = true ;
}
}
if ( !registered ) GTH_Friends_Add ( g_curPC, &g_pc[idx] );
GTH_Friends_Add ( &g_pc[idx], g_curPC );
g_curPC->friendsBusy = false;
g_pc[idx].friendsBusy = false;
}
void GTH_ProcessMessage_Friends_Reject ()
{
int idx = MSG_ReadShort ();
if ( !g_pc[idx].active || !g_pc[idx].ready )
{
return;
}
if ( g_pc[idx].worldIdx != g_curPC->worldIdx )
{
return;
}
GTH_SendMessage_Friends_Reject ( &g_pc[idx], idx );
g_curPC->friendsBusy = false ;
g_pc[idx].friendsBusy = false ;
}
void GTH_ProcessMessage_Friends_Remove ()
{
char targetName[NAMESTRING] ;
strcpy ( targetName, MSG_ReadString () );
GTH_Friends_Remove ( g_curPC, targetName );
}
void GTH_ProcessMessage_Guild_From_Client()
{
int command;
command = MSG_ReadByte();
switch(command){
case GUILD_SYNC:
gcpGuildCtrl->BetweenClientGs_Decoder();
break;
case GUILD_ORGANIZE :
GTH_ProcessMessage_Guild_Organize_Request_From_Client();
break;
case GUILD_DISORGANIZE :
GTH_ProcessMessage_Guild_Disorganize_Request_From_Client();
break;
case GUILD_INVITE_REQUEST :
GTH_ProcessMessage_Guild_Invite_Request_From_Client();
break;
case GUILD_INVITE_CANCEL :
GTH_ProcessMessage_Guild_Invite_Cancel_From_Client();
break;
case GUILD_INVITE_REPLY :
GTH_ProcessMessage_Guild_Invite_Reply_From_Client();
break;
case GUILD_SECEDE:
GTH_ProcessMessage_Guild_Secede_Request_From_Client();
break;
case GUILD_BANISH:
GTH_ProcessMessage_Guild_Banish_Request_From_Client();
break;
case GUILD_GUILDMARK:
GTH_ProcessMessage_Guild_GuildMark_From_Client();
break;
case GUILD_CHANGEMASTER:
GTH_ProcessMessage_Guild_Change_Master_Request_From_Client();
break;
case GUILD_ADDSUBMASTER:
GTH_ProcessMessage_Guild_Add_SubMaster_Request_From_Client();
break;
case GUILD_ADDFACTIONMASTER:
GTH_ProcessMessage_Guild_Add_FactionMaster_Request_From_Client();
break;
case GUILD_DELETE_MASTER:
GTH_ProcessMessage_Guild_Delete_Master_Request_From_Client();
break;
case GUILD_SCHEDULE:
GTH_ProcessMessage_Guild_Schedule_Request();
break;
case GUILD_SUBSCRIBE:
GTH_ProcessMessage_Guild_Subscribe_Request_From_Client();
break;
}
}
void GTH_ProcessMessage_Guild_Organize_Request_From_Client()
{
int i;
int error = -1;
char guildName[GUILDNAMESTRING+1];
char guildMark[GUILDMARKSIZE];
memset( guildMark, 0, GUILDMARKSIZE );
sstrncpy( guildName, MSG_ReadString(), GUILDNAMESTRING - 1 );
guildName[GUILDNAMESTRING]=NULL;
for(i=0; i<GUILDMARKSIZE; i++ ) guildMark[i] = MSG_ReadByte();
if( g_curPC->guildIdx != -1 )
{
error = GUILD_ERROR_ALREADYJOINED;
GTH_SendMessage_Guild_Organize_Reply_To_Client( g_curPC, -1, error );
return;
}
if( g_curPC->level < GUILD_ORGANIZABLE_LEVEL )
{
error = GUILD_ERROR_LEVEL;
GTH_SendMessage_Guild_Organize_Reply_To_Client( g_curPC, -1, error );
return;
}
if( g_curPC->pcJob < J_DEVOTIONAL_KNIGHT )
{
error = GUILD_ERROR_NOTAWAKENED;
GTH_SendMessage_Guild_Organize_Reply_To_Client( g_curPC, -1, error );
return;
}
#ifndef _DEV_TEST
if( g_curPC->rankPoint < GUILD_ORGANIZABLE_RANKPOINT )
{
error = GUILD_ERROR_RANKPOINT;
GTH_SendMessage_Guild_Organize_Reply_To_Client( g_curPC, -1, error );
return;
}
#endif
if( g_curPC->curChargeSE < GUILD_ORGANIZABLE_NAK )
{
error = GUILD_ERROR_NAK;
GTH_SendMessage_Guild_Organize_Reply_To_Client( g_curPC, -1, error );
return;
}
time_t NowTime = time(NULL);
if (g_curPC->GuildDeconstructionTime > NowTime)
{
error = GUILD_ERROR_ALLOW_CREATE;
GTH_SendMessage_Guild_Organize_Reply_To_Client( g_curPC, -1, error , (g_curPC->GuildDeconstructionTime - NowTime));
return;
}
if ( g_config.isManager )
{
g_curPC->guildIdx = GTH_GuildOrganize( g_curPC->name, guildName, guildMark, g_config.serverGroupNo, error );
if( g_curPC->guildIdx >= 0 )
{
g_curPC->curChargeSE -= GUILD_ORGANIZABLE_NAK;
g_curPC->rankPoint -= GUILD_ORGANIZABLE_RANKPOINT;
if( 0 > g_curPC->rankPoint ) g_curPC->rankPoint = 0;
strncpy(g_curPC->guildName,guildName,GUILDNAMESTRING);
g_curPC->guildName[GUILDNAMESTRING]=NULL;
GTH_SendMessage_Guild_Organize_Reply_To_Client( g_curPC, 0, error );
gcpGuildCtrl->ManagerServerProc_Organize(g_curPC->guildIdx,guildName,(const unsigned char*)guildMark);
g_DBGameServer->UpdateGuildIdx(g_curPC->userID,g_curPC->serverGroupID, g_curPC->characterID, g_curPC->guildIdx);
}
else
{
GTH_SendMessage_Guild_Organize_Reply_To_Client( g_curPC, -1, error );
}
}
else
{
GTH_SendMessage_Guild_Organize_Request_To_ManagerServer( g_curPC, guildName, guildMark );
}
}
void GTH_ProcessMessage_Guild_Disorganize_Request_From_Client()
{
int error = -1;
if( g_curPC->guildIdx == -1 )
{
error = GUILD_ERROR_NOTJOINED;
GTH_SendMessage_Guild_Disorganize_Reply_To_Client( g_curPC, -1, error );
return;
}
if( stricmp( g_guild[g_curPC->guildIdx].masterName, g_curPC->name ) != 0 )
{
error = GUILD_ERROR_NOMASTER;
GTH_SendMessage_Guild_Disorganize_Reply_To_Client( g_curPC, -1, error );
return;
}
if ( ( g_curPC->ready == TRUE) && (g_curPC->active == TRUE) ) {
NewDanBattleSystem::DanBattleInfo* pDanBattleInfo = NULL;
pDanBattleInfo = g_NewDanBattleSystem.GetDanBattleInfo(g_curPC->DanBattleInfo.nDanBattleIdx, g_curPC->guildIdx);
if( pDanBattleInfo != NULL ) {
error = -1;
GTH_SendMessage_Guild_Disorganize_Reply_To_Client( g_curPC, -1, error);
return;
}
}
if( g_config.isManager )
{
int result = GTH_GuildDisorganize( g_curPC->guildIdx, g_curPC->name, error );
if ( result != -1 )
{
gcpGuildCtrl->ManagerServerProc_DisOrganize(g_curPC->guildIdx);
g_DBGameServer->UpdateGuildIdx(g_curPC->userID,g_curPC->serverGroupID, g_curPC->characterID,-1);
g_curPC->guildIdx = -1;
g_curPC->rankPoint -= 50;
if( 0 > g_curPC->rankPoint ) g_curPC->rankPoint = 0;
time_t NowTime = time(NULL) + DELAY_DAN_CREATE_SEC;
g_curPC->GuildDeconstructionTime = NowTime;
NowTime = time(NULL) + DELAY_DAN_REJOIN_SEC_FOR_GENERAL_REMOVE;
g_curPC->GuildsecedeTime = NowTime;
}
GTH_SendMessage_Guild_Disorganize_Reply_To_Client( g_curPC, result, error );
}
else
{
GTH_SendMessage_Guild_Disorganize_Request_To_ManagerServer( g_curPC );
}
}
bool IsGuildMasters( playerCharacter_t *pc )
{
int i;
if( stricmp( g_guild[pc->guildIdx].masterName, pc->name ) == 0 )
return true;
for( i=0; i<MAX_GUILD_SUBMASTERS; i++ )
{
if( stricmp( g_guild[pc->guildIdx].subMasterName[i], pc->name ) == 0 )
return true;
}
for( i=0; i<MAX_GUILD_FACTIONMASTERS; i++ )
{
if( stricmp( g_guild[pc->guildIdx].factionMasterName[i], pc->name ) == 0 )
return true;
}
return false;
}
void GTH_ProcessMessage_Guild_Invite_Request_From_Client()
{
int error = -1;
char name[NAMESTRING+1];
sstrncpy( name, MSG_ReadString(), NAMESTRING - 1 );
name[NAMESTRING]=NULL;
strcpy( g_curPC->tempGuildMateName, name );
if( g_curPC->guildIdx == -1 )
{
error = GUILD_ERROR_NOTJOINED;
GTH_SendMessage_Guild_Invite_Request_To_Client( g_curPC, -1, error, 0 );
return;
}
if( !IsGuildMasters( g_curPC ) )
{
error = GUILD_ERROR_INVITE_NOTMASTER;
GTH_SendMessage_Guild_Invite_Request_To_Client( g_curPC, -1, error, 0 );
return;
}
int idx = GTH_FindPCByName( name );
if( idx == -1 )
{
error = GUILD_ERROR_INVITE_NONEPCINDEX;
GTH_SendMessage_Guild_Invite_Request_To_Client( g_curPC, -1, error, 0 );
return;
}
if( g_pc[idx].guildIdx != -1 )
{
error = GUILD_ERROR_INVITE_ALREADY;
GTH_SendMessage_Guild_Invite_Request_To_Client( g_curPC, -1, error, 0 );
return;
}
if( g_pc[idx].level < GUILD_SUBSCRIBABLE_LEVEL )
{
error = GUILD_ERROR_INVITE_NOTLEVEL;
GTH_SendMessage_Guild_Invite_Request_To_Client( g_curPC, -1, error, 0 );
return;
}
if( !g_curPC->ready || !g_pc[idx].ready || !g_curPC->alive || !g_pc[idx].alive )
{
error = GUILD_ERROR_INVITE_NOTREADY;
GTH_SendMessage_Guild_Invite_Request_To_Client( g_curPC, -1, error, 0 );
return;
}
if( g_curPC->worldIdx != g_pc[idx].worldIdx )
{
error = GUILD_ERROR_INVITE_DIFFWORLDINDEX;
GTH_SendMessage_Guild_Invite_Request_To_Client( g_curPC, -1, error, 0 );
return;
}
if( g_curPC->busyState != BUSY_STATE_NONE || g_pc[idx].busyState != BUSY_STATE_NONE )
{
error = GUILD_ERROR_INVITE_PCSTATE;
GTH_SendMessage_Guild_Invite_Request_To_Client( g_curPC, -1, error, 0 );
return;
}
time_t NowTime = time(NULL);
if (g_pc[idx].GuildsecedeTime > NowTime)
{
error = GUILD_ERROR_ALLOW_JOIN;
GTH_SendMessage_Guild_Invite_Request_To_Client( g_curPC, -1, error, 0 , (g_pc[idx].GuildsecedeTime - NowTime ));
return;
}
GTH_AddNoticePC( g_curPC, ENTITY_PC, idx, BUSY_STATE_REQUEST );
GTH_AddNoticePC( &g_pc[idx], ENTITY_PC, g_curPC->idx, BUSY_STATE_REQUEST );
strcpy( g_curPC->tempGuildMateName, g_pc[idx].name );
GTH_SendMessage_Guild_Invite_Request_To_Client( g_curPC, 0, error, 0 );
strcpy( g_pc[idx].guildName, g_guild[g_curPC->guildIdx].name );
strncpy(g_pc[idx].Guild.FromInvite.Name,g_curPC->name,NAMESTRING);
g_pc[idx].Guild.FromInvite.Name[NAMESTRING]=NULL;
GTH_SendMessage_Guild_Invite_Request_To_Client( &g_pc[idx], 0, error, 1 );
}
void GTH_ProcessMessage_Guild_Invite_Cancel_From_Client()
{
int error = -1;
GTH_SendMessage_Guild_Invite_Cancel_To_Client( g_curPC, error, 0, g_curPC->tempGuildMateName );
GTH_DeleteNoticePC( g_curPC );
int idx = GTH_FindPCByName( g_curPC->tempGuildMateName );
if( idx == -1 ) return;
GTH_SendMessage_Guild_Invite_Cancel_To_Client( &g_pc[idx], error, 1, g_curPC->guildName );
GTH_DeleteNoticePC( &g_pc[idx] );
}
void GTH_ProcessMessage_Guild_Invite_Reply_From_Client()
{
int reply;
int error = -1;
reply = MSG_ReadShort();
int idx = GTH_FindPCByName(g_curPC->Guild.FromInvite.Name);
if( reply == 0 )
{
GTH_SendMessage_Guild_Invite_Reply_To_Client( g_curPC, -1, error, 1, g_curPC->guildName );
GTH_DeleteNoticePC( g_curPC );
if( idx >= 0 )
{
GTH_SendMessage_Guild_Invite_Reply_To_Client( &g_pc[idx], -1, error, 0, g_curPC->name );
GTH_DeleteNoticePC( &g_pc[idx] );
}
return;
}
if( idx < 0 )
{
error = GUILD_ERROR_CANNOTFIND;
GTH_SendMessage_Guild_Invite_Reply_To_Client( g_curPC, -1, error, 1, g_curPC->guildName );
GTH_DeleteNoticePC( g_curPC );
return;
}
short guildIdx = GTH_GetGuildIndexByName( g_curPC->guildName );
if( g_curPC->guildIdx != -1 || guildIdx == -1 )
{
error = GUILD_ERROR_CANNOTFIND;
GTH_SendMessage_Guild_Invite_Reply_To_Client( &g_pc[idx], -1, error, 0, g_curPC->name );
GTH_SendMessage_Guild_Invite_Reply_To_Client( g_curPC, -1, error, 1, g_curPC->guildName );
GTH_DeleteNoticePC( &g_pc[idx] );
GTH_DeleteNoticePC( g_curPC );
return;
}
if( !g_curPC->ready || !g_curPC->alive || !g_pc[idx].ready || !g_pc[idx].alive )
{
error = GUILD_ERROR_CANNOTFIND;
GTH_SendMessage_Guild_Invite_Reply_To_Client( &g_pc[idx], -1, error, 0, g_curPC->name );
GTH_SendMessage_Guild_Invite_Reply_To_Client( g_curPC, -1, error, 1, g_curPC->guildName );
GTH_DeleteNoticePC( &g_pc[idx] );
GTH_DeleteNoticePC( g_curPC );
return;
}
if( g_curPC->worldIdx != g_pc[idx].worldIdx )
{
error = GUILD_ERROR_CANNOTFIND;
GTH_SendMessage_Guild_Invite_Reply_To_Client( &g_pc[idx], -1, error, 0, g_curPC->name );
GTH_SendMessage_Guild_Invite_Reply_To_Client( g_curPC, -1, error, 1, g_curPC->guildName );
GTH_DeleteNoticePC( &g_pc[idx] );
GTH_DeleteNoticePC( g_curPC );
return;
}
if( g_config.isManager )
{
int rankIdxInGuild = -1;
int result = GTH_GuildAddUser( guildIdx, g_curPC->name, g_curPC->pcJob, rankIdxInGuild, error );
if( result != -1 )
{
g_curPC->guildIdx = guildIdx;
g_curPC->rankInGuild = GUILD_MATE;
g_curPC->rankIdxInGuild = rankIdxInGuild;
strcpy( g_curPC->guildName, g_guild[guildIdx].name );
g_DBGameServer->UpdateGuildIdx(g_curPC->userID,g_curPC->serverGroupID, g_curPC->characterID, g_curPC->guildIdx);
}
else
{
error = GUILD_ERROR_CANNOTFIND;
}
GTH_SendMessage_Guild_Invite_Reply_To_Client( &g_pc[idx], result, error, 0, g_curPC->name );
GTH_SendMessage_Guild_Invite_Reply_To_Client( g_curPC, result, error, 1, g_curPC->guildName );
GTH_DeleteNoticePC( &g_pc[idx] );
GTH_DeleteNoticePC( g_curPC );
}
else
{
GTH_SendMessage_Guild_Add_Request_To_ManagerServer( &g_pc[idx], g_curPC, GUILD_MATE );
}
}
void GTH_ProcessMessage_Guild_Secede_Request_From_Client()
{
int error = -1;
if( g_curPC->guildIdx == -1 )
{
error = GUILD_ERROR_SECEDE_0;
GTH_SendMessage_Guild_Secede_Reply_To_Client( g_curPC, -1, error );
return;
}
if( !g_curPC->ready || !g_curPC->alive )
{
error = GUILD_ERROR_SECEDE_1;
GTH_SendMessage_Guild_Secede_Reply_To_Client( g_curPC, -1, error );
return;
}
if( g_curPC->busyState != BUSY_STATE_NONE )
{
error = GUILD_ERROR_SECEDE_2;
GTH_SendMessage_Guild_Secede_Reply_To_Client( g_curPC, -1, error );
return;
}
NewDanBattleSystem::DanBattleInfo* pDanBattleInfo = NULL;
pDanBattleInfo = g_NewDanBattleSystem.GetDanBattleInfo(g_curPC->DanBattleInfo.nDanBattleIdx, g_curPC->guildIdx);
if ( pDanBattleInfo != NULL)
{
error = GUILD_ERROR_BANISH_1;
GTH_SendMessage_Guild_Secede_Reply_To_Client( g_curPC, -1, error );
return;
}
if( g_config.isManager )
{
if( stricmp( g_guild[g_curPC->guildIdx].masterName, g_curPC->name ) == 0 )
{
error = GUILD_ERROR_SECEDE_3;
GTH_SendMessage_Guild_Secede_Reply_To_Client( g_curPC, -1, error );
return;
}
int result = GTH_GuildRemoveUser( g_curPC->guildIdx, g_curPC->name, error );
if( result != -1)
{
g_curPC->guildIdx = -1;
g_curPC->rankPoint -= 10;
if( 0 > g_curPC->rankPoint) g_curPC->rankPoint = 0;
time_t NowTime = time(NULL) + DELAY_DAN_REJOIN_SEC_FOR_GENERAL_REMOVE;
g_curPC->GuildsecedeTime = NowTime;
g_DBGameServer->UpdateGuildIdx(g_curPC->userID,g_curPC->serverGroupID, g_curPC->characterID, g_curPC->guildIdx);
}
GTH_SendMessage_Guild_Secede_Reply_To_Client( g_curPC, result, error );
}
else
{
GTH_SendMessage_Guild_Remove_Request_To_ManagerServer( g_curPC, GUILD_MATE );
}
}
void GTH_ProcessMessage_Guild_Banish_Request_From_Client()
{
int result;
int error = -1;
char name[NAMESTRING+1];
sstrncpy( name, MSG_ReadString(), NAMESTRING - 1 );
name[NAMESTRING]=NULL;
if( g_curPC->guildIdx == -1 )
{
error = GUILD_ERROR_BANISH_0;
GTH_SendMessage_Guild_Banish_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
if( !g_curPC->ready || !g_curPC->alive )
{
error = GUILD_ERROR_BANISH_2;
GTH_SendMessage_Guild_Banish_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
if( g_curPC->busyState != BUSY_STATE_NONE )
{
error = GUILD_ERROR_BANISH_3;
GTH_SendMessage_Guild_Banish_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
if( stricmp( g_guild[g_curPC->guildIdx].masterName, name ) == 0 )
{
error = GUILD_ERROR_BANISH_4;
GTH_SendMessage_Guild_Banish_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
int idx = GTH_FindPCByName( name );
if( idx != -1 )
{
if( !g_pc[idx].ready || !g_pc[idx].alive )
{
error = GUILD_ERROR_BANISH_2;
GTH_SendMessage_Guild_Banish_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
}
playerCharacter_t* pPc = gcpTools->GetPlayerRecordPointer(idx);
if (pPc != NULL) {
if ( ( pPc->ready == TRUE) && (pPc->active == TRUE) ) {
NewDanBattleSystem::DanBattleInfo* pDanBattleInfo = NULL;
pDanBattleInfo = g_NewDanBattleSystem.GetDanBattleInfo(pPc->DanBattleInfo.nDanBattleIdx, pPc->guildIdx);
if( pDanBattleInfo != NULL ) {
error = GUILD_ERROR_BANISH_3;
GTH_SendMessage_Guild_Banish_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
}
}
if( g_config.isManager )
{
if( stricmp( g_guild[g_curPC->guildIdx].masterName, g_curPC->name ) != 0 )
{
int i;
for( i=0; i<MAX_GUILD_SUBMASTERS; i++ )
{
if( stricmp( g_guild[g_curPC->guildIdx].subMasterName[i], g_curPC->name ) == 0 )
break;
}
if( i == MAX_GUILD_SUBMASTERS )
{
error = GUILD_ERROR_BANISH_5;
GTH_SendMessage_Guild_Banish_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
}
result = GTH_GuildRemoveUser( g_curPC->guildIdx, name, error );
if( result != -1 )
{
if( idx == -1 )
{
g_DBGameServer->BanishMemberGuild(name, 10 );
}
else
{
g_pc[idx].guildIdx = -1;
g_pc[idx].rankPoint -= 10;
if( 0 > g_pc[idx].rankPoint) g_pc[idx].rankPoint = 0;
g_DBGameServer->UpdateGuildIdx(g_pc[idx].userID,g_pc[idx].serverGroupID, g_pc[idx].characterID, g_pc[idx].guildIdx);
time_t NowTime = time(NULL) + DELAY_DAN_REJOIN_SEC_FOR_POWER_REMOVE;
g_pc[idx].GuildsecedeTime = NowTime;
GTH_SendMessage_Guild_Banish_Reply_To_Client( &g_pc[idx], result, error, 1, g_curPC->guildName );
}
}
GTH_SendMessage_Guild_Banish_Reply_To_Client( g_curPC, result, error, 0, name );
}
else
{
GTH_SendMessage_Guild_Banish_Request_To_ManagerServer( g_curPC->guildIdx, g_curPC->name, name, GUILD_MATE );
}
}
void GTH_ProcessMessage_Guild_Change_Master_Request_From_Client()
{
int result;
int error = -1;
char name[NAMESTRING];
sstrncpy( name, MSG_ReadString(), NAMESTRING - 1 );
if( g_curPC->guildIdx == -1 )
{
error = GUILD_ERROR_NOGUILD;
GTH_SendMessage_Guild_Change_Master_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
int idx = GTH_FindPCByName( name );
if( idx == -1 )
{
error = GUILD_ERROR_CANNOTFIND;
GTH_SendMessage_Guild_Change_Master_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
if( g_pc[idx].guildIdx != g_curPC->guildIdx )
{
error = GUILD_ERROR_NOTJOINED;
GTH_SendMessage_Guild_Change_Master_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
if( !g_curPC->ready || !g_pc[idx].ready || !g_curPC->alive || !g_pc[idx].alive )
{
error = GUILD_ERROR_OFFLINE;
GTH_SendMessage_Guild_Change_Master_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
if( g_curPC->busyState != BUSY_STATE_NONE || g_pc[idx].busyState != BUSY_STATE_NONE )
{
error = GUILD_ERROR_OFFLINE;
GTH_SendMessage_Guild_Change_Master_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
if( stricmp( g_guild[g_curPC->guildIdx].masterName, name ) == 0 )
{
error = GUILD_ERROR_SAMEMATENAME;
GTH_SendMessage_Guild_Change_Master_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
if( stricmp( g_guild[g_curPC->guildIdx].masterName, g_curPC->name ) != 0 )
{
error = GUILD_ERROR_AUTHORITY;
GTH_SendMessage_Guild_Change_Master_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
if( g_pc[idx].level < GUILD_ORGANIZABLE_LEVEL )
{
error = GUILD_ERROR_LEVEL;
GTH_SendMessage_Guild_Change_Master_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
if( g_pc[idx].pcJob < J_DEVOTIONAL_KNIGHT )
{
error = GUILD_ERROR_NOTAWAKENED;
GTH_SendMessage_Guild_Change_Master_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
if( g_config.isManager )
{
int rankIdxInGuild = -1;
result = GTH_GuildChangeMaster( g_curPC->guildIdx, g_curPC->name, name, g_pc[idx].pcJob, rankIdxInGuild, error );
if( result != -1 )
{
g_pc[idx].rankInGuild = GUILD_MASTER;
g_pc[idx].rankIdxInGuild = rankIdxInGuild;
GTH_SendMessage_Guild_Change_Master_Reply_To_Client( &g_pc[idx], result, error, 1, name );
}
GTH_SendMessage_Guild_Change_Master_Reply_To_Client( g_curPC, result, error, 0, name );
}
else
{
GTH_SendMessage_Guild_Change_Master_Request_To_ManagerServer( g_curPC->guildIdx, g_curPC, &g_pc[idx] );
}
}
void GTH_ProcessMessage_Guild_Add_SubMaster_Request_From_Client()
{
int result;
int error = -1;
char name[NAMESTRING];
sstrncpy( name, MSG_ReadString(), NAMESTRING - 1 );
if( g_curPC->guildIdx == -1 )
{
error = GUILD_ERROR_NOGUILD;
GTH_SendMessage_Guild_Add_SubMaster_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
int idx = GTH_FindPCByName( name );
if( idx == -1 )
{
error = GUILD_ERROR_CANNOTFIND;
GTH_SendMessage_Guild_Add_SubMaster_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
if( g_pc[idx].guildIdx != g_curPC->guildIdx )
{
error = GUILD_ERROR_NOTJOINED;
GTH_SendMessage_Guild_Add_SubMaster_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
if( !g_curPC->ready || !g_pc[idx].ready || !g_curPC->alive || !g_pc[idx].alive )
{
error = GUILD_ERROR_OFFLINE;
GTH_SendMessage_Guild_Add_SubMaster_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
if( g_curPC->busyState != BUSY_STATE_NONE || g_pc[idx].busyState != BUSY_STATE_NONE )
{
error = GUILD_ERROR_OFFLINE;
GTH_SendMessage_Guild_Add_SubMaster_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
if( stricmp( g_guild[g_curPC->guildIdx].masterName, name ) == 0 )
{
error = GUILD_ERROR_NOMASTER;
GTH_SendMessage_Guild_Add_SubMaster_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
if( stricmp( g_guild[g_curPC->guildIdx].masterName, g_curPC->name ) != 0 )
{
error = GUILD_ERROR_AUTHORITY;
GTH_SendMessage_Guild_Add_SubMaster_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
if( g_pc[idx].level < GUILD_ORGANIZABLE_LEVEL )
{
error = GUILD_ERROR_LEVEL;
GTH_SendMessage_Guild_Add_SubMaster_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
if( g_pc[idx].pcJob < J_DEVOTIONAL_KNIGHT )
{
error = GUILD_ERROR_NOTAWAKENED;
GTH_SendMessage_Guild_Add_SubMaster_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
if( g_config.isManager )
{
int rankIdxInGuild = -1;
result = GTH_GuildAddSubMaster( g_curPC->guildIdx, name, g_pc[idx].pcJob, rankIdxInGuild, error );
if( result != -1 )
{
g_pc[idx].rankInGuild = GUILD_SUBMASTER;
g_pc[idx].rankIdxInGuild = rankIdxInGuild;
GTH_SendMessage_Guild_Add_SubMaster_Reply_To_Client( &g_pc[idx], result, error, 1, name );
}
GTH_SendMessage_Guild_Add_SubMaster_Reply_To_Client( g_curPC, result, error, 0, name );
}
else
{
GTH_SendMessage_Guild_Add_SubMaster_Request_To_ManagerServer( g_curPC->guildIdx, g_curPC, &g_pc[idx] );
}
}
void GTH_ProcessMessage_Guild_Add_FactionMaster_Request_From_Client()
{
int i;
int result;
int error = -1;
char name[NAMESTRING];
sstrncpy( name, MSG_ReadString(), NAMESTRING - 1 );
if( g_curPC->guildIdx == -1 )
{
error = GUILD_ERROR_NOGUILD;
GTH_SendMessage_Guild_Add_FactionMaster_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
int idx = GTH_FindPCByName( name );
if( idx == -1 )
{
error = GUILD_ERROR_CANNOTFIND;
GTH_SendMessage_Guild_Add_FactionMaster_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
if( g_pc[idx].guildIdx != g_curPC->guildIdx )
{
error = GUILD_ERROR_NOTJOINED;
GTH_SendMessage_Guild_Add_FactionMaster_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
if( !g_curPC->ready || !g_pc[idx].ready || !g_curPC->alive || !g_pc[idx].alive )
{
error = GUILD_ERROR_OFFLINE;
GTH_SendMessage_Guild_Add_FactionMaster_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
if( g_curPC->busyState != BUSY_STATE_NONE )
{
error = GUILD_ERROR_OFFLINE;
GTH_SendMessage_Guild_Add_FactionMaster_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
if( g_pc[idx].busyState != BUSY_STATE_NONE )
{
error = GUILD_ERROR_OFFLINE;
GTH_SendMessage_Guild_Add_FactionMaster_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
if( stricmp( g_guild[g_curPC->guildIdx].masterName, name ) == 0 )
{
error = GUILD_ERROR_NOMASTER;
GTH_SendMessage_Guild_Add_FactionMaster_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
int authority = 0;
if( stricmp( g_guild[g_curPC->guildIdx].masterName, g_curPC->name ) == 0 )
authority = 1;
for( i=0; i<MAX_GUILD_SUBMASTERS; i++ )
{
if( stricmp( g_guild[g_curPC->guildIdx].subMasterName[i], g_curPC->name ) == 0 )
{
authority = 1;
break;
}
}
if( authority == 0 )
{
error = GUILD_ERROR_AUTHORITY;
GTH_SendMessage_Guild_Add_FactionMaster_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
if( g_pc[idx].level < GUILD_ORGANIZABLE_LEVEL )
{
error = GUILD_ERROR_LEVEL;
GTH_SendMessage_Guild_Add_FactionMaster_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
if( g_pc[idx].pcJob < J_DEVOTIONAL_KNIGHT )
{
error = GUILD_ERROR_NOTAWAKENED;
GTH_SendMessage_Guild_Add_FactionMaster_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
if( g_config.isManager )
{
int rankIdxInGuild = -1;
result = GTH_GuildAddFactionMaster( g_curPC->guildIdx, name, g_pc[idx].pcJob, rankIdxInGuild, error );
if( result != -1 )
{
g_pc[idx].rankInGuild = GUILD_FACTIONMASTER;
g_pc[idx].rankIdxInGuild = rankIdxInGuild;
GTH_SendMessage_Guild_Add_FactionMaster_Reply_To_Client( &g_pc[idx], result, error, 1, name );
}
GTH_SendMessage_Guild_Add_FactionMaster_Reply_To_Client( g_curPC, result, error, 0, name );
}
else
{
GTH_SendMessage_Guild_Add_FactionMaster_Request_To_ManagerServer( g_curPC->guildIdx, g_curPC, &g_pc[idx] );
}
}
void GTH_ProcessMessage_Guild_Remove_SubMaster_Request_From_Client( char *name )
{
int result;
int error = -1;
if( g_curPC->guildIdx == -1 )
{
error = GUILD_ERROR_NOGUILD;
GTH_SendMessage_Guild_Remove_SubMaster_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
if( !g_curPC->ready || !g_curPC->alive )
{
error = GUILD_ERROR_OFFLINE;
GTH_SendMessage_Guild_Remove_SubMaster_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
if( g_curPC->busyState != BUSY_STATE_NONE )
{
error = GUILD_ERROR_OFFLINE;
GTH_SendMessage_Guild_Remove_SubMaster_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
int idx = GTH_FindPCByName( name );
if( idx == -1 )
{
if( g_config.isManager )
{
if( stricmp( g_guild[g_curPC->guildIdx].masterName, g_curPC->name ) != 0 )
{
error = GUILD_ERROR_AUTHORITY;
GTH_SendMessage_Guild_Remove_SubMaster_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
result = GTH_GuildRemoveSubMaster( g_curPC->guildIdx, name, error );
GTH_SendMessage_Guild_Remove_SubMaster_Reply_To_Client( g_curPC, result, error, 0, name );
}
else
{
GTH_SendMessage_Guild_Remove_SubMaster_Request_To_ManagerServer( g_curPC, name, -1 );
}
return;
}
else
{
if( !g_pc[idx].ready || !g_pc[idx].alive )
{
error = GUILD_ERROR_OFFLINE;
GTH_SendMessage_Guild_Remove_SubMaster_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
if( g_pc[idx].busyState != BUSY_STATE_NONE )
{
error = GUILD_ERROR_OFFLINE;
GTH_SendMessage_Guild_Remove_SubMaster_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
}
if( g_config.isManager )
{
if( stricmp( g_guild[g_curPC->guildIdx].masterName, g_curPC->name ) != 0 )
{
error = GUILD_ERROR_AUTHORITY;
GTH_SendMessage_Guild_Remove_SubMaster_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
result = GTH_GuildRemoveSubMaster( g_curPC->guildIdx, name, error );
if( result != -1 )
{
GTH_SendMessage_Guild_Remove_SubMaster_Reply_To_Client( &g_pc[idx], result, error, 1, name );
}
GTH_SendMessage_Guild_Remove_SubMaster_Reply_To_Client( g_curPC, result, error, 0, name );
}
else
{
GTH_SendMessage_Guild_Remove_SubMaster_Request_To_ManagerServer( g_curPC, g_pc[idx].name, g_pc[idx].pcJob );
}
}
void GTH_ProcessMessage_Guild_Remove_FactionMaster_Request_From_Client( char *name )
{
int i;
int result;
int error = -1;
if( g_curPC->guildIdx == -1 )
{
error = GUILD_ERROR_NOGUILD;
GTH_SendMessage_Guild_Remove_FactionMaster_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
if( !g_curPC->ready || !g_curPC->alive )
{
error = GUILD_ERROR_OFFLINE;
GTH_SendMessage_Guild_Remove_FactionMaster_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
if( g_curPC->busyState != BUSY_STATE_NONE )
{
error = GUILD_ERROR_OFFLINE;
GTH_SendMessage_Guild_Remove_FactionMaster_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
int idx = GTH_FindPCByName( name );
if( idx == -1 )
{
if( g_config.isManager )
{
char authority = 0;
if( stricmp( g_guild[g_curPC->guildIdx].masterName, g_curPC->name ) == 0 )
authority = 1;
for( i=0; i<MAX_GUILD_SUBMASTERS; i++ )
{
if( stricmp( g_guild[g_curPC->guildIdx].subMasterName[i], g_curPC->name ) == 0 )
{
authority = 1;
break;
}
}
if( authority == 0 )
{
error = GUILD_ERROR_AUTHORITY;
GTH_SendMessage_Guild_Remove_FactionMaster_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
result = GTH_GuildRemoveFactionMaster( g_curPC->guildIdx, name, error );
GTH_SendMessage_Guild_Remove_FactionMaster_Reply_To_Client( g_curPC, result, error, 0, name );
}
else
{
GTH_SendMessage_Guild_Remove_FactionMaster_Request_To_ManagerServer( g_curPC, name, -1 );
}
return;
}
if( !g_pc[idx].ready || !g_pc[idx].alive )
{
error = GUILD_ERROR_OFFLINE;
GTH_SendMessage_Guild_Remove_FactionMaster_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
if( g_pc[idx].busyState != BUSY_STATE_NONE )
{
error = GUILD_ERROR_OFFLINE;
GTH_SendMessage_Guild_Remove_FactionMaster_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
if( g_config.isManager )
{
char authority = 0;
if( stricmp( g_guild[g_curPC->guildIdx].masterName, g_curPC->name ) == 0 )
authority = 1;
for( i=0; i<MAX_GUILD_SUBMASTERS; i++ )
{
if( stricmp( g_guild[g_curPC->guildIdx].subMasterName[i], g_curPC->name ) == 0 )
{
authority = 1;
break;
}
}
if( authority == 0 )
{
error = GUILD_ERROR_AUTHORITY;
GTH_SendMessage_Guild_Remove_FactionMaster_Reply_To_Client( g_curPC, -1, error, 0, name );
return;
}
result = GTH_GuildRemoveFactionMaster( g_curPC->guildIdx, name, error );
if( result != -1 )
{
GTH_SendMessage_Guild_Remove_FactionMaster_Reply_To_Client( &g_pc[idx], result, error, 1, name );
}
GTH_SendMessage_Guild_Remove_FactionMaster_Reply_To_Client( g_curPC, result, error, 0, name );
}
else
{
GTH_SendMessage_Guild_Remove_FactionMaster_Request_To_ManagerServer( g_curPC, g_pc[idx].name, g_pc[idx].pcJob );
}
}
void GTH_ProcessMessage_Guild_Delete_Master_Request_From_Client()
{
int i, error = -1;
int flag = 0;
char name[NAMESTRING];
sstrncpy( name, MSG_ReadString(), NAMESTRING - 1 );
short guildIdx = g_curPC->guildIdx;
if( guildIdx < 0 || guildIdx >= MAX_GUILDS )
{
error = GUILD_ERROR_NOGUILD;
GTH_SendMessage_Guild_Delete_Master_Reply_To_Client( g_curPC, error, name );
}
for( i=0; i<MAX_GUILD_SUBMASTERS; i++)
{
if( g_guild[guildIdx].subMasterName[i][0] == 0 ) continue;
if( stricmp( g_guild[guildIdx].subMasterName[i], name ) == 0 )
{
flag = 1;
}
}
for( i=0; i<MAX_GUILD_FACTIONMASTERS; i++ )
{
if( g_guild[guildIdx].factionMasterName[i][0] == 0 ) continue;
if( stricmp( g_guild[guildIdx].factionMasterName[i], name ) == 0 )
{
flag = 2;
}
}
if( stricmp( g_guild[guildIdx].masterName, name ) == 0 )
flag = 3;
switch( flag )
{
case 1:
GTH_ProcessMessage_Guild_Remove_SubMaster_Request_From_Client( name );
break;
case 2:
GTH_ProcessMessage_Guild_Remove_FactionMaster_Request_From_Client( name );
break;
case 3:
error = GUILD_ERROR_NOMASTER;
GTH_SendMessage_Guild_Delete_Master_Reply_To_Client( g_curPC, error, name );
break;
default:
error = GUILD_ERROR_CANNOTAPPOINT;
GTH_SendMessage_Guild_Delete_Master_Reply_To_Client( g_curPC, error, name );
break;
}
}
void GTH_ProcessMessage_Guild_Schedule_Request()
{
char notice[128];
char name[NAMESTRING];
strcpy( notice, MSG_ReadString() );
bool flag = false;
int i;
short guildIdx = g_curPC->guildIdx;
strcpy( name, g_curPC->name );
if( guildIdx != -1 )
{
if( !stricmp( g_guild[guildIdx].masterName, name ) )
{
flag = true;
}
else
{
for( i=0; i<MAX_GUILD_SUBMASTERS; i++)
{
if( g_guild[guildIdx].subMasterName[i][0] == 0 ) continue;
if( !stricmp( g_guild[guildIdx].subMasterName[i], name ) )
{
flag = true;
break;
}
}
for( i=0; i<MAX_GUILD_FACTIONMASTERS; i++ )
{
if( g_guild[guildIdx].factionMasterName[i][0] == 0 ) continue;
if( !stricmp( g_guild[guildIdx].factionMasterName[i], name ) )
{
flag = true;
break;
}
}
}
}
if( flag )
{
if( g_config.isManager )
{
strcpy( g_guild[guildIdx].notice, notice );
int update = GUILD_NOTICE;
GTH_GuildUpdate( guildIdx, update, -1, -1, GUILD_ALLRANK, -1 );
}
else
{
GTH_SendMessage_Guild_Schedule_Request_To_ManagerServer( g_curPC->guildIdx, g_curPC, notice );
}
}
}
void GTH_ProcessMessage_Guild_Subscribe_Request_From_Client()
{
short guildIdx;
int error = -1;
char guildName[GUILDNAMESTRING];
sstrncpy( guildName, MSG_ReadString(), GUILDNAMESTRING - 1 );
if( g_curPC->guildIdx != -1 )
{
error = GUILD_ERROR_ALREADYJOINED;
GTH_SendMessage_Guild_Subscribe_Reply_To_Client( g_curPC, -1, error );
return;
}
if( g_curPC->level < GUILD_SUBSCRIBABLE_LEVEL )
{
error = GUILD_ERROR_LEVEL;
GTH_SendMessage_Guild_Subscribe_Reply_To_Client( g_curPC, -1, error );
return;
}
if( g_config.isManager )
{
for( int i=0; i<MAX_GUILDS; i++ )
{
if( !stricmp( g_guild[i].name, guildName ) )
{
guildIdx = i;
break;
}
}
if( i == MAX_GUILDS )
{
error = GUILD_ERROR_NOGUILD;
GTH_SendMessage_Guild_Subscribe_Reply_To_Client( g_curPC, -1, error );
return;
}
int bSended = 0;
if( g_guild[guildIdx].userLocation[0] != -1 )
{
GTH_Send_Subscribe_Request_Message_To_Client( g_guild[guildIdx].masterName );
bSended = 1;
GTH_SendMessage_Guild_Subscribe_Reply_To_Client( g_curPC, 0, 0, guildName );
}
else
{
int temp = MAX_GUILD_MASTERS;
for( int i=0; i<MAX_GUILD_SUBMASTERS; i++ )
{
if( g_guild[guildIdx].userLocation[i+temp] != -1 )
{
GTH_Send_Subscribe_Request_Message_To_Client( g_guild[guildIdx].subMasterName[i] );
bSended = 1;
GTH_SendMessage_Guild_Subscribe_Reply_To_Client( g_curPC, 0, i+temp, guildName );
}
}
}
if( bSended == 0 )
{
error = GUILD_ERROR_NOMASTER;
GTH_SendMessage_Guild_Subscribe_Reply_To_Client( g_curPC, -1, error );
return;
}
}
else
{
GTH_SendMessage_Guild_Subscribe_Request_To_ManagerServer( g_curPC, guildName );
}
}
void GTH_ProcessMessage_Guild_GuildMark_From_Client(void)
{
int guildIdx = MSG_ReadShort();
struct CGuildCtrl::tagGuildSummarySyncRecord* pGuildSummarySyncRecord=gcpGuildCtrl->GetSummaryRecordPointer(guildIdx);
if(NULL == pGuildSummarySyncRecord) return;
GTH_SendMessage_Guild_GuildMark_Reply_To_Client(
g_curPC,
guildIdx,
pGuildSummarySyncRecord->Mark.ChangeDate,
pGuildSummarySyncRecord->Mark.Image);
}
void GTH_ProcessMessage_QuestScroll_ObtainOpen()
{
GTH_AddNoticePC( g_curPC, -1, -1, BUSY_STATE_QUESTSCROLL );
GTH_SendMessage_QuestScroll_ObtainOpen( g_curPC, 1 );
}
void GTH_ProcessMessage_QuestScroll_ObtainPrepare()
{
int reply = 1, error = 0, reqNak = 0;
int tableIdx, depart, level, reward;
depart = MSG_ReadByte();
level = MSG_ReadByte();
reward = MSG_ReadByte();
GTH_QuestScroll_ObtainProcess( g_curPC, reply, error, reqNak, tableIdx, depart, level, reward, 0, true );
GTH_SendMessage_QuestScroll_ObtainPrepare( g_curPC, reply, error, reqNak, tableIdx );
}
void GTH_ProcessMessage_QuestScroll_ObtainComplete()
{
int reply = 1, error = 0, reqNak = 0;
int tableIdx, depart, level, reward, selectedQSTableIdx;
depart = MSG_ReadByte();
level = MSG_ReadByte();
reward = MSG_ReadByte();
selectedQSTableIdx = MSG_ReadShort();
GTH_QuestScroll_ObtainProcess( g_curPC, reply, error, reqNak, tableIdx, depart, level, reward, selectedQSTableIdx, false );
GTH_SendMessage_QuestScroll_ObtainComplete( g_curPC, reply, error, reqNak, tableIdx );
}
void GTH_ProcessMessage_QuestScroll_ObtainClose()
{
GTH_DeleteNoticePC( g_curPC );
GTH_SendMessage_QuestScroll_ObtainClose( g_curPC );
}
void GTH_ProcessMessage_QuestScroll_ComboListChange()
{
int depart = MSG_ReadByte();
GTH_SendMessage_QuestScroll_ComboListChange( g_curPC, depart );
}
void GTH_ProcessMessage_AutoQuestScroll_ObtainOpen( playerCharacter_t* pPlayer )
{
for( int idx = 0; idx < g_autoQuestscrollTableNumber; idx++ ){
if( pPlayer->level != g_autoQuestscrollTable[idx].data.level ) continue;
if( ( g_autoQuestscrollTable[idx].data.reward.regClass != -1 )&&
( g_autoQuestscrollTable[idx].data.reward.regClass != pPlayer->pcClass ) ) continue;
float totalexp = g_expTable[pPlayer->level-1].totalexp-pPlayer->exp;
float expRate = ( 1.0f-totalexp / g_expTable[pPlayer->level-1].exp ) * 100.0f;
if( g_autoQuestscrollTable[idx].data.startexp > expRate ) return;
int table = AUTOQUESTSCROLL_ITEM_INDEX + g_autoQuestscrollTable[idx].Index;
if( ( 0 > table ) && ( table >= MAX_COUNT_QUEST_VARIABLE ) ) return;
if( 0 != pPlayer->questVar[table].var.completeCount ) return;
int error = GTH_AutoQuestScroll_ObtainProcess( pPlayer, g_autoQuestscrollTable[idx].Index );
if( error != ERROR_ITEMSYSTEM_NONE ) {
GTH_SendMessage_AutoQuest_Error( pPlayer,error );
return;
}
pPlayer->bautoeffectisvalid = TRUE;
int addItemData[5];
addItemData[0] = AUTOQUESTSCROLL_ITEM_INDEX;
addItemData[1] = -1;
addItemData[2] = 1;
addItemData[3] = 1;
addItemData[4] = g_autoQuestscrollTable[idx].Index;
addItemData[5] = -1;
AI_NPC_AddItem( pPlayer, addItemData );
GTH_SendMessage_AutoQuestScroll_ObtainOpen( pPlayer,g_autoQuestscrollTable[idx].Index );
return;
}
}
int AI_CheckItem( playerCharacter_t* pc, int* pPrarm )
{
int itemIdx;
int itemTableIdx=pPrarm[0];
for( int i = 0; i < MAX_INVENTORY_SIZE; i ++ )
{
itemIdx = pc->inventory[i];
if( itemIdx < 0 ) continue;
if( pc->item[itemIdx].itemTableIdx == itemTableIdx ) return 1;
}
return 0;
}
void GTH_ProcessMessage_AutoQuestProgress()
{
int type = MSG_ReadByte();
int reply = 0;
switch(type) {
case AUTOQUESTSCROLL_START:
{
if ( TRUE == GTH_IsOnPlayAutoQuestScroll( g_curPC) ) {
GTH_SendMessage_AutoQuest_Error(g_curPC,ERROR_ITEMSYSTEM_26);
reply = 0;
}
else if( ( g_curPC->oldEvent!=GTH_EV_CHAR_ATTACK && g_curPC->event != GTH_EV_CHAR_SKIP ) ) {
g_curPC->bautoeffectisvalid=true;
reply=1;
} else {
reply=0;
}
GTH_SendMessage_AutoQuestScroll_effectisvalid( g_curPC,reply,type);
}
break;
case AUTOQUESTSCROLL_END:
{
g_curPC->bautoeffectisvalid=false;
}
break;
}
}
void GTH_ProcessMessage_ChaosValue()
{
GTH_SendMessag_ChaosValue();
}
void GTH_ProcessMessage_SkinPart()
{
BYTE bSaveSQLDB = MSG_ReadByte();
BYTE bHairID = MSG_ReadByte();
BYTE bFaceID = MSG_ReadByte();
g_curPC->skinPart[0]=bHairID;
g_curPC->skinPart[1]=bFaceID;
if(TRUE == bSaveSQLDB) g_DBGameServer->SaveSkin(g_curPC);
}
BOOL isValidPCBusy(playerCharacter_t* pPlayer, int busystate)
{
if ( pPlayer == NULL)
return FALSE;
if ( pPlayer->busyState != busystate)
{
g_logSystem->WriteToHackingLog("[HackingSystemType]:%d [AccountID]=%s, [UserID]=%s", busystate, pPlayer->userID, pPlayer->name);
TransmitePacket_sc_disconnect(pPlayer);
GTH_DisconnectPlayer(pPlayer,TRUE);
return FALSE;
}
return TRUE;
}
void InitItemCraftSystem(playerCharacter_t *pPlayer)
{
if ( pPlayer == NULL)
return;
for( int i = 0; i < MAX_CRAFT_SOURCE_ITEM_SIZE; i ++ )
{
pPlayer->craftSourceInventory[i] = -1;
}
for( i = 0; i < MAX_CRAFT_RESULT_ITEM_SIZE; i ++ )
{
pPlayer->craftResultInventory[i] = -1;
}
}
void InitItemUpgradeSystem(playerCharacter_t *pPlayer)
{
if ( pPlayer == NULL)
return;
for(int i = 0; i < MAX_UPGRADE_SOURCE_ITEM_SIZE; i ++ )
{
pPlayer->upgradeSourceInventory[i] = -1;
}
pPlayer->upgradeResultInventory = -1;
}
void InitBoothSystem(playerCharacter_t* pPlayer)
{
if ( pPlayer == NULL)
return;
for(int i = 0; i < MAX_BOOTH_INVENTORY_SIZE; i ++ )
pPlayer->boothInventory[i].itemIdx = -1;
}
void InitPrecocitySystem(playerCharacter_t* pPlayer)
{
if ( pPlayer == NULL)
return;
for (int nIdx =0; nIdx < MAX_PRECOCITY_SIZE; nIdx++ )
{
pPlayer->precocityTime[nIdx] = -1;
pPlayer->precocityInventory[nIdx] = -1;
}
}
| C++ |
#ifndef _CASHMALL_ITEM_H_
#define _CASHMALL_ITEM_H_
#include <vector>
enum enumPacketCashMallItem
{
REQUEST_USE_STONE_OF_SAGE = 0x0000,
REPLY_USE_STONE_OF_SAGE = 0x0001,
REQUEST_USE_STONE_OF_LUCKY = 0x0002,
REPLY_USE_STONE_OF_LUCKY = 0x0003,
REQUEST_USE_STONE_OF_EACH_NAME = 0x0004,
REPLY_USE_STONE_OF_EACH_NAME = 0x0005,
REQUEST_USE_REVERSE_OF_MEMORY = 0x0006,
REPLY_USE_REVERSE_OF_MEMORY = 0x0007,
REQUEST_OPTION_ITEM_EDIT = 0x0008,
REPLY_OPTION_ITEM_EDIT = 0x0009,
REQUEST_OPTION_ITEM_WINCLOSE = 0x000a,
REPLY_OPTION_ITEM_WINCLOSE = 0x000b,
REQUEST_OPTION_ITEM_MODIFY = 0x000c,
REPLY_OPTION_ITEM_MODIFY = 0x000d,
};
enum enumCashMallItem_Error
{
CASHMALL_ITEM_ERROR_0,
CASHMALL_ITEM_ERROR_1,
CASHMALL_ITEM_ERROR_2,
CASHMALL_ITEM_ERROR_3,
CASHMALL_ITEM_ERROR_4,
CASHMALL_ITEM_ERROR_5,
CASHMALL_ITEM_ERROR_6,
CASHMALL_ITEM_ERROR_7,
};
void GTH_DecodeCashMallItem();
void GTH_ProcessMessageRequest_StoneOfSage();
void GTH_ProcessMessageRequest_StoneOfLucky();
void GTH_ProcessMessageRequest_StoneOfEachName();
void GTH_ProcessMessageRequest_ReverseOfMemory();
void GTH_ProcessMessageRequest_OptionItemEdit();
void GTH_ProcessMessageRequest_OptionItemWinClose();
void GTH_ProcessMessageRequest_OptionItemModify();
void GTH_SendMessageReply_StoneOfSage
(playerCharacter_t* pPc, BOOL Reply, int InvenPos, float DestroyRate =0.0f, float SuccecsRate = 0.0f);
void GTH_SendMessageReply_StoneOfLucky
(playerCharacter_t* pPc, BOOL Reply, int InvenPos, float DestroyRate =0.0f, float SuccecsRate = 0.0f);
void GTH_SendMessageReply_StoneOfEachName
(playerCharacter_t* pPc, BOOL Reply, int InvenPos);
void GTH_SendMessageReply_ReverseOfMemory
(playerCharacter_t* pPc, BOOL Reply, int ErrorIdx,
int InvenPos, vector<int>* pVSkill = NULL);
void GTH_SendMessageReply_OptionItemEdit
(playerCharacter_t* pPc, BOOL bError,
int MouseInvenPos, int EditInevenPos);
void GTH_SendMessageRePly_OptionItemWinClose
(playerCharacter_t* pPc, BOOL bError);
void GTH_SendMessageRePly_OptionItemModify
(playerCharacter_t* pPc, enum CashMallItem_OptionStone::enumUseItemMode,
BOOL Reply, item_t* pItem, int ErrorIdx = -1);
void InitCashMallItem(playerCharacter_t* pPc);
void ItemModify_Stone_of_sage();
void ItemModify_Stone_of_lucky();
void ItemModify_Stone_of_each_name();
int IsExistenceItemOption(item_t *pItem, int OptionIdx);
int SelectOptionGrade(enum CashMallItem_OptionStone::enumUseItemMode mode);
#endif | C++ |
#include "../Global.h"
#include "../new.h"
void CExpEventMng::ProcessExpEvent()
{
short Protocal = static_cast<enum enumProtocal>(MSG_ReadShort());
switch(Protocal)
{
case CC_BROAD_CAST_SET_EVENT:
case SS_BROAD_CAST_SET_EVENT:
{
enumEventType eventType = static_cast<enum enumEventType>(MSG_ReadLong());
float fValue = MSG_ReadFloat();
if ( Protocal == CC_BROAD_CAST_SET_EVENT)
{
if ( g_curPC != NULL)
{
g_logSystem->Write("[EXP_EVENT] USE CHEAT, NAME = %s, CHEAT_EVENT=%d, VALUE=%f",
g_curPC->name, (int)eventType, fValue);
}
}
ProcessMessage_BroadCast_SetEvent(eventType, fValue);
}
break;
case SS_SET_EVENT:
{
enumEventType eventType = static_cast<enum enumEventType>(MSG_ReadLong());
float fValue = MSG_ReadFloat();
SetEvent(eventType, fValue);
}
break;
case SS_REQUEST_EVENT:
ProcessMessage_RequestAllEvent();
break;
case SS_REPLY_EVENT:
ProcessMessage_ReplyAllEvent();
break;
case CC_SET_ACTIVE_SYSTEM:
case SS_SET_ACTIVE_SYSTEM:
ProcessMessage_RequestActiveSystem();
break;
case CC_REQUEST_EVENT_STATUS:
if ( g_curPC != NULL)
{
if (g_curPC->ready == TRUE)
SendMessage_ReplyEventStatus(g_curPC);
}
break;
}
}
void CExpEventMng::ProcessMessage_BroadCast_SetEvent(enum enumEventType eventType, float fValue)
{
if ( g_config.isManager )
{
if ( m_ActiveMng == TRUE)
{
SetEvent(eventType, fValue);
SendMessage_SetEventTo_MemberServer(eventType, fValue);
}
}
else
{
SendMessage_SetEventTo_ManagerServer(eventType, fValue);
}
}
void CExpEventMng::SendMessage_SetEventTo_ManagerServer(enumEventType eventType, float value)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, EXP_EVENT);
MSG_WriteShort(&netMessage, SS_BROAD_CAST_SET_EVENT);
MSG_WriteLong(&netMessage, eventType);
MSG_WriteFloat(&netMessage, value);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CExpEventMng::SendMessage_SetEventTo_MemberServer(enumEventType eventType, float value)
{
SetEvent(eventType, value);
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, EXP_EVENT);
MSG_WriteShort(&netMessage, SS_SET_EVENT);
MSG_WriteLong(&netMessage, eventType);
MSG_WriteFloat(&netMessage, value);
for (int i=1; i < MAX_MEMBER_SERVER; i++)
{
if ( !g_memberServer[i].active )
continue;
NET_SendUnreliableMessage(&g_memberServer[i].sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
void CExpEventMng::SendMessage_RequestEventToManagerServer()
{
if ( g_config.isManager == TRUE)
return;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, EXP_EVENT);
MSG_WriteShort(&netMessage, SS_REQUEST_EVENT);
MSG_WriteLong(&netMessage, g_config.gameServerNo);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CExpEventMng::SendMessage_ReplyEventToServer(int MemberServerIdx, BOOL Active)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, EXP_EVENT);
MSG_WriteShort(&netMessage, SS_REPLY_EVENT);
MSG_WriteLong(&netMessage, Active);
if ( Active == TRUE)
{
MSG_WriteFloat(&netMessage, m_fExpRate);
MSG_WriteFloat(&netMessage, m_fItemDropRate);
MSG_WriteFloat(&netMessage, m_fNakDropRate);
MSG_WriteFloat(&netMessage, m_fGencapability_rate);
}
NET_SendUnreliableMessage(&g_memberServer[MemberServerIdx].sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CExpEventMng::SetEvent(enumEventType eventType, float fValue)
{
switch(eventType)
{
case EXP_RATE:
m_fExpRate = fValue;
g_logic.expRate = fValue;
break;
case ITEM_DROP_RATE:
m_fItemDropRate = fValue;
g_logic.itemDropRate = fValue;
break;
case NAK_DROP_RATE:
m_fNakDropRate = fValue;
g_logic.nseRate = fValue;
break;
case GENCAPABILITY_RATE:
m_fGencapability_rate = fValue;
g_logic.genCapabilityRate= fValue;
break;
case ALL_READ_LOGIC:
GTH_ProcessMessage_LogicReload();
m_fExpRate = g_logic.expRate;
m_fItemDropRate = g_logic.itemDropRate;
m_fNakDropRate = g_logic.nseRate;
m_fGencapability_rate = g_logic.genCapabilityRate;
g_logSystem->Write("[EXP_EVENT], EVENT_END, [EXP_RATE] = %f,"
"[ItemDrop_RATE] = %f, [NakDrop] =%f, [GenCapability] = %f",
g_logic.expRate, g_logic.itemDropRate, g_logic.nseRate, m_fGencapability_rate);
break;
}
}
void CExpEventMng::InitExpEventMng()
{
m_fExpRate = g_logic.expRate;
m_fItemDropRate = g_logic.itemDropRate;
m_fNakDropRate = g_logic.nseRate;
m_fGencapability_rate = g_logic.genCapabilityRate;
m_ActiveMng = FALSE;
}
CExpEventMng::CExpEventMng()
{
}
CExpEventMng::~CExpEventMng()
{
}
void CExpEventMng::ProcessMessage_RequestAllEvent()
{
int MemberServerIdx = MSG_ReadLong();
if ( MemberServerIdx > MAX_MEMBER_SERVER || MemberServerIdx < 0)
return;
if ( g_memberServer[MemberServerIdx].active == FALSE )
return;
SendMessage_ReplyEventToServer(MemberServerIdx, m_ActiveMng);
}
void CExpEventMng::ProcessMessage_ReplyAllEvent()
{
int Reply = 0;
Reply = MSG_ReadLong();
if ( Reply == 0)
{
g_logSystem->Write("[EXP_EVENT] Can't EventSeting Because EventSystem Is inactive ");
return;
}
m_fExpRate = MSG_ReadFloat();
g_logic.expRate = m_fExpRate;
m_fItemDropRate = MSG_ReadFloat();
g_logic.itemDropRate = m_fItemDropRate;
m_fNakDropRate = MSG_ReadFloat();
g_logic.nseRate = m_fNakDropRate;
m_fGencapability_rate = MSG_ReadFloat();
g_logic.genCapabilityRate = m_fGencapability_rate;
g_logSystem->Write("[EXP_EVENT], Restart and EventSeting, [EXP_RATE] = %f,"
"[ItemDrop_RATE] = %f, [NakDrop] =%f, [GenCapability] = %f",
g_logic.expRate, g_logic.itemDropRate, g_logic.nseRate, m_fGencapability_rate);
}
void CExpEventMng::ProcessMessage_RequestActiveSystem()
{
m_ActiveMng = MSG_ReadLong();
if (g_config.isManager == TRUE)
{
if ( m_ActiveMng == FALSE)
SendMessage_SetEventTo_MemberServer(ALL_READ_LOGIC, 1.0);
}
else
SendMessage_SetActiveToManagerServer(m_ActiveMng);
}
void CExpEventMng::SendMessage_SetActiveToManagerServer(BOOL Active)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, EXP_EVENT);
MSG_WriteShort(&netMessage, SS_SET_ACTIVE_SYSTEM);
MSG_WriteLong(&netMessage, Active);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CExpEventMng::SendMessage_ReplyEventStatus(playerCharacter_t* pc)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, EXP_EVENT);
MSG_WriteShort(&netMessage, GSC_REPLY_EVENT_STATUS);
MSG_WriteFloat(&netMessage, m_fExpRate);
MSG_WriteFloat(&netMessage, m_fItemDropRate);
MSG_WriteFloat(&netMessage, m_fNakDropRate);
MSG_WriteFloat(&netMessage, m_fGencapability_rate);
NET_SendUnreliableMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
| C++ |
#include "../global.h"
float g_optValue[NUM_OPTION_VALUE];
itemTable_t g_optItem;
itemTable_t g_oriItem;
void OPTION_InitGlobal()
{
memset( g_optValue, 0, sizeof( g_optValue ) );
}
int OPTION_GetItemType_MatchingAvailableOn( DWORD availableOn )
{
if( availableOn & OPTION_AVAILABLE_ON_WEAPONS ) return OPTION_ITEMTYPE_WEAPONS;
if( availableOn & OPTION_AVAILABLE_ON_DAGGER ) return OPTION_ITEMTYPE_DAGGER;
if( availableOn & OPTION_AVAILABLE_ON_1HSWORD ) return OPTION_ITEMTYPE_1HSWORD;
if( availableOn & OPTION_AVAILABLE_ON_2HSWORD ) return OPTION_ITEMTYPE_2HSWORD;
if( availableOn & OPTION_AVAILABLE_ON_BOW ) return OPTION_ITEMTYPE_BOW;
if( availableOn & OPTION_AVAILABLE_ON_STAFF ) return OPTION_ITEMTYPE_STAFF;
if( availableOn & OPTION_AVAILABLE_ON_SPIRITOR ) return OPTION_ITEMTYPE_SPIRITOR;
if( availableOn & OPTION_AVAILABLE_ON_CLAW ) return OPTION_ITEMTYPE_CLAW;
if( availableOn & OPTION_AVAILABLE_ON_ARMORS ) return OPTION_ITEMTYPE_ARMORS;
if( availableOn & OPTION_AVAILABLE_ON_UPPER ) return OPTION_ITEMTYPE_UPPER;
if( availableOn & OPTION_AVAILABLE_ON_LOWER ) return OPTION_ITEMTYPE_LOWER;
if( availableOn & OPTION_AVAILABLE_ON_AIRPROTECTOR ) return OPTION_ITEMTYPE_AIRPROTECTOR;
if( availableOn & OPTION_AVAILABLE_ON_BODYPROTECTOR ) return OPTION_ITEMTYPE_BODYPROTECTOR;
if( availableOn & OPTION_AVAILABLE_ON_GLOVES ) return OPTION_ITEMTYPE_GLOVES;
if( availableOn & OPTION_AVAILABLE_ON_BOOTS ) return OPTION_ITEMTYPE_BOOTS;
if( availableOn & OPTION_AVAILABLE_ON_RING ) return OPTION_ITEMTYPE_RING;
if( availableOn & OPTION_AVAILABLE_ON_NECKLACE ) return OPTION_ITEMTYPE_NECKLACE;
if( availableOn & OPTION_AVAILABLE_ON_BRACELET ) return OPTION_ITEMTYPE_BRACELET;
if( availableOn & OPTION_AVAILABLE_ON_EARRING ) return OPTION_ITEMTYPE_EARRING;
if( availableOn & OPTION_AVAILABLE_ON_EPACK ) return OPTION_ITEMTYPE_EPACK;
return -1;
}
DWORD OPTION_GetItemAvailalbeOn( int itemTableIdx )
{
int itemClassTableIdx = g_itemTable[itemTableIdx].classIdx;
DWORD availableOn = 0;
if( g_itemTable[itemTableIdx].wearPosition == ITEM_WEAR_POS_WEAPON )
{
availableOn |= OPTION_AVAILABLE_ON_WEAPONS;
if( g_itemClassTable[itemClassTableIdx].weaponType == WEAPON_TYPE_DANGGER ) availableOn |= OPTION_AVAILABLE_ON_DAGGER;
if( g_itemClassTable[itemClassTableIdx].weaponType == WEAPON_TYPE_ONEHAND_SWORD ) availableOn |= OPTION_AVAILABLE_ON_1HSWORD;
if( g_itemClassTable[itemClassTableIdx].weaponType == WEAPON_TYPE_TWOHAND_SWORD ) availableOn |= OPTION_AVAILABLE_ON_2HSWORD;
if( g_itemClassTable[itemClassTableIdx].weaponType == WEAPON_TYPE_MAGIC_BOW ) availableOn |= OPTION_AVAILABLE_ON_BOW;
if( g_itemClassTable[itemClassTableIdx].weaponType == WEAPON_TYPE_STAFF ) availableOn |= OPTION_AVAILABLE_ON_STAFF;
if( g_itemClassTable[itemClassTableIdx].weaponType == WEAPON_TYPE_SPIRITOR ) availableOn |= OPTION_AVAILABLE_ON_SPIRITOR;
if( g_itemClassTable[itemClassTableIdx].weaponType == WEAPON_TYPE_CLAW ) availableOn |= OPTION_AVAILABLE_ON_CLAW;
}
if( g_itemTable[itemTableIdx].wearPosition == ITEM_WEAR_POS_UPPER )
{
availableOn |= OPTION_AVAILABLE_ON_UPPER;
availableOn |= OPTION_AVAILABLE_ON_ARMORS;
}
if( g_itemTable[itemTableIdx].wearPosition == ITEM_WEAR_POS_LOWER )
{
availableOn |= OPTION_AVAILABLE_ON_LOWER;
availableOn |= OPTION_AVAILABLE_ON_ARMORS;
}
if( g_itemTable[itemTableIdx].wearPosition == ITEM_WEAR_POS_AIR_PROTECTOR )
{
availableOn |= OPTION_AVAILABLE_ON_AIRPROTECTOR;
availableOn |= OPTION_AVAILABLE_ON_ARMORS;
}
if( g_itemTable[itemTableIdx].wearPosition == ITEM_WEAR_POS_BODY_PROTECTOR )
{
availableOn |= OPTION_AVAILABLE_ON_BODYPROTECTOR;
availableOn |= OPTION_AVAILABLE_ON_ARMORS;
}
if( g_itemTable[itemTableIdx].wearPosition == ITEM_WEAR_POS_GLOVES )
{
availableOn |= OPTION_AVAILABLE_ON_GLOVES;
availableOn |= OPTION_AVAILABLE_ON_ARMORS;
}
if( g_itemTable[itemTableIdx].wearPosition == ITEM_WEAR_POS_BOOTS )
{
availableOn |= OPTION_AVAILABLE_ON_BOOTS;
availableOn |= OPTION_AVAILABLE_ON_ARMORS;
}
if( g_itemTable[itemTableIdx].wearPosition == ITEM_WEAR_POS_EPACK ) availableOn |= OPTION_AVAILABLE_ON_EPACK;
if( g_itemTable[itemTableIdx].wearPosition == ITEM_WEAR_POS_RING ) availableOn |= OPTION_AVAILABLE_ON_RING;
if( g_itemTable[itemTableIdx].wearPosition == ITEM_WEAR_POS_NECKLACE ) availableOn |= OPTION_AVAILABLE_ON_NECKLACE;
if( g_itemTable[itemTableIdx].wearPosition == ITEM_WEAR_POS_BRACELET ) availableOn |= OPTION_AVAILABLE_ON_BRACELET;
if( g_itemTable[itemTableIdx].wearPosition == ITEM_WEAR_POS_EARRING ) availableOn |= OPTION_AVAILABLE_ON_EARRING;
return( availableOn );
}
int OPTION_GetOptionStoneGrade( item_t *item )
{
if( item->reqLevel >= 0 && item->reqLevel <= 29 ) return 0;
else if( item->reqLevel >= 30 && item->reqLevel <= 49 ) return 1;
else if( item->reqLevel >= 50 && item->reqLevel <= 69 ) return 2;
else if( item->reqLevel >= 70 ) return 3;
return 0;
}
float OPTION_GetOptionValue( item_t *item, int optionTableIdx, int optionGrade )
{
int optionStoneGrade = OPTION_GetOptionStoneGrade( item );
DWORD itemAvailableOn;
DWORD optAvailableOn;
int itemType;
if( optionGrade <= 0 ) return( 0 );
itemAvailableOn = OPTION_GetItemAvailalbeOn( item->itemTableIdx );
optAvailableOn = g_optionTable[optionTableIdx].optValue[optionStoneGrade].availableOn;
itemType = OPTION_GetItemType_MatchingAvailableOn( itemAvailableOn & optAvailableOn );
if( itemType < 0 ) return( 0 );
if( g_optionTable[optionTableIdx].optValue[optionStoneGrade].availableOn == 0 ) return( 0 );
return( g_optionTable[optionTableIdx].optValue[optionStoneGrade].value_item[itemType].value[optionGrade - 1] );
}
void OPTION_ApplyStatusOption( item_t *item, int status[] )
{
int i, statusIdx, optIdx, optGrade;
float optValue;
for( i = 0; i < item->optionNumber; i ++ )
{
statusIdx = -1;
optIdx = item->optionIdx[i];
optGrade = item->optionValue[i];
optValue = 0.0f;
if( optGrade > 10 ) optGrade = 10;
optValue = OPTION_GetOptionValue( item, optIdx, optGrade );
switch( optIdx )
{
case Opt_Bracelet_Add_Force :
statusIdx = 0;
break;
case Opt_Bracelet_Add_Soulpower :
statusIdx = 1;
break;
case Opt_Bracelet_Add_Agility :
statusIdx = 2;
break;
case Opt_Bracelet_Add_Vitality :
statusIdx = 3;
break;
}
if( statusIdx >= 0 ) status[statusIdx] += (int)optValue;
}
}
int OPTION_ApplyItemOption( item_t *item )
{
int i, optIdx, optGrade;
float optValue;
for( i = 0; i < item->optionNumber; i ++ )
{
optIdx = item->optionIdx[i];
optGrade = item->optionValue[i];
optValue = 0.0f;
if( optGrade > 10 ) optGrade = 10;
optValue = OPTION_GetOptionValue( item, optIdx, optGrade );
switch( optIdx )
{
case Opt_Add_PhyDamange :
optIdx = OV_W_PHYDMG;
break;
case Opt_Add_Min_PhyDamage :
optIdx = OV_W_MIN_PHYDMG;
break;
case Opt_Add_Max_PhyDamage :
optIdx = OV_W_MAX_PHYDMG;
break;
case Opt_Add_MagDamage :
optIdx = OV_W_MAGDMG;
break;
case Opt_Add_Min_MagDamage :
optIdx = OV_W_MIN_MAGDMG;
break;
case Opt_Add_Max_MagDamage :
optIdx = OV_W_MAX_MAGDMG;
break;
case Opt_Add_CriticalPro : case Opt_Ring_Add_CriticalPro :
optIdx = OV_CRITICAL_PRO;
break;
case Opt_Ring_Mul_CriticalDamage:
optIdx = OV_CRITICAL_DMG_RATE;
break;
case Opt_Mul_CriticalDamage:
optIdx = OV_CRITICAL_DMG;
break;
case Opt_Dec_CastingTime : case Opt_Bracelet_Dec_CastingTime :
optIdx = OV_DEC_CASTINGTIME_RATE;
optValue = -optValue;
break;
case Opt_Add_AttackSpeed :
optIdx = OV_W_ATKSPEED;
break;
case Opt_Add_HitPower : case Opt_Gloves_Add_HitPower :
optIdx = OV_W_HITPOWER;
break;
case Opt_Steal_RA : case Opt_Ring_Steal_RA :
optIdx = OV_RASTEAL;
break;
case Opt_Steal_SA : case Opt_Ring_Steal_SA :
optIdx = OV_SASTEAL;
break;
case Opt_Steal_RA_Point : case Opt_Ring_Steal_RA_Point :
optIdx = OV_RASTEAL_POINT;
break;
case Opt_Steal_SA_Point : case Opt_Ring_Steal_SA_Point :
optIdx = OV_SASTEAL_POINT;
break;
case Opt_Mul_Che_PhyDamage :
optIdx = OV_CHE_PHY_DMG_RATE;
break;
case Opt_Mul_Che_MagDamage :
optIdx = OV_CHE_MAG_DMG_RATE;
break;
case Opt_Mul_Mamul_PhyDamage :
optIdx = OV_MAMUL_PHY_DMG_RATE;
break;
case Opt_Mul_Mamul_MagDamage :
optIdx = OV_MAMUL_MAG_DMG_RATE;
break;
case Opt_Mul_Yogui_PhyDamage :
optIdx = OV_YO_PHY_DMG_RATE;
break;
case Opt_Mul_Yogui_MagDamage :
optIdx = OV_YO_MAG_DMG_RATE;
break;
case Opt_Mul_Yoguisun_PhyDamage :
optIdx = OV_YOSUN_PHY_DMG_RATE;
break;
case Opt_Mul_Yoguisun_MagDamage :
optIdx = OV_YOSUN_MAG_DMG_RATE;
break;
case Opt_Mul_Younghon_PhyDamage :
optIdx = OV_YOUNG_PHY_DMG_RATE;
break;
case Opt_Mul_Younghon_MagDamage :
optIdx = OV_YOUNG_MAG_DMG_RATE;
break;
case Opt_Armor_Add_DefensePower : case Opt_Bracelet_Add_DefensePower :
optIdx = OV_D_DEFPOWER;
break;
case Opt_Upper_Add_PositiveRes : case Opt_Necklace_Add_PositiveRes :
optIdx = OV_POSRES;
break;
case Opt_Upper_Add_NegativeRes : case Opt_Necklace_Add_NegativeRes :
optIdx = OV_NEGRES;
break;
case Opt_Boots_Add_AvoidPower :
optIdx = OV_AVOIDPOWER;
break;
case Opt_Boots_Add_Velocity :
optIdx = OV_VELOCITY;
break;
case Opt_Ring_Mul_PhyDamage :
optIdx = OV_PHYDMG_RATE;
break;
case Opt_Ring_Mul_MagDamage :
optIdx = OV_MAGDMG_RATE;
break;
case Opt_Necklace_Add_MaxRA :
optIdx = OV_MAX_RA;
break;
case Opt_Necklace_Add_MaxSA :
optIdx = OV_MAX_SA;
break;
case Opt_Necklace_Add_AvoidRate :
optIdx = OV_HIT_RATE;
break;
case Opt_Necklace_Add_HitRate :
optIdx = OV_AVOID_RATE;
break;
case Opt_Necklace_Dec_StunTime :
optIdx = OV_DEC_STUNDELAY_RATE;
break;
case Opt_Necklace_Dec_CursePro :
optIdx = OV_DEC_CURSESKILL_RATE;
break;
case Opt_Necklace_Trans_DamageToRA :
optIdx = OV_RA_STEAL_DAMAGED;
break;
case Opt_Necklace_Trans_DamageToSA :
optIdx = OV_SA_STEAL_DAMAGED;
break;
case Opt_Necklace_Mul_Recovery_RA_Normal :
optIdx = OV_AUTORECOVERY_RA_ATTACK;
break;
case Opt_Necklace_Mul_Recovery_SA_Normal :
optIdx = OV_AUTORECOVERY_SA_ATTACK;
break;
case Opt_Necklace_Mul_Recovery_RA_Rest :
optIdx = OV_AUTORECOVERY_RA_IDLE;
break;
case Opt_Necklace_Mul_Recovery_SA_Rest :
optIdx = OV_AUTORECOVERY_SA_IDLE;
break;
case Opt_Necklace_Mul_Recovery_EpackRA :
optIdx = OV_EPACK_RA_EFFICIENCY;
break;
case Opt_Necklace_Mul_Recovery_EpackSA :
optIdx = OV_EPACK_SA_EFFICIENCY;
break;
case Opt_Bracelet_Dec_CoolTime :
optIdx = OV_DEC_COOLTIME_RATE;
optValue = -optValue;
break;
case Opt_Bracelet_Steal_RAPoint_MonsterDie :
optIdx = OV_RA_STEAL_DIE_MONSTER;
break;
case Opt_Bracelet_Steal_SAPoint_MonsterDie :
optIdx = OV_SA_STEAL_DIE_MONSTER;
break;
case Opt_Gloves_Add_LootExp:
case Opt_Bracelet_Mul_LootExp:
optIdx = OV_ADD_EXP_RATE;
break;
case Opt_Bracelet_Mul_LootGenExp :
optIdx = OV_ADD_GENEXP_RATE;
break;
case Opt_Upper_Add_LootNak :
case Opt_Bracelet_Mul_LootNak :
optIdx = OV_ADD_NAK_RATE;
break;
default :
continue;
break;
}
if( optIdx >= 0 ) g_optValue[optIdx] += optValue;
}
return( 1 );
}
void OPTION_ApplyItem( item_t* item )
{
float backupOptValue[NUM_OPTION_VALUE];
int idx = item->itemTableIdx;
int classIdx = g_itemTable[idx].classIdx;
memcpy( &g_oriItem, &g_itemTable[idx], sizeof( itemTable_t ) );
memcpy( &g_optItem, &g_itemTable[idx], sizeof( itemTable_t ) );
memcpy( &backupOptValue, &g_optValue, sizeof( g_optValue ) );
OPTION_InitGlobal();
OPTION_ApplyItemOption( item );
g_optItem.atkPhyMinDmg += (int)g_optValue[OV_W_MIN_PHYDMG];
g_optItem.atkPhyMaxDmg += (int)g_optValue[OV_W_MAX_PHYDMG];
g_optItem.atkPhyMinDmg += (int)g_optValue[OV_W_PHYDMG];
g_optItem.atkPhyMaxDmg += (int)g_optValue[OV_W_PHYDMG];
g_optItem.atkMagMinDmg += (int)g_optValue[OV_W_MIN_MAGDMG];
g_optItem.atkMagMaxDmg += (int)g_optValue[OV_W_MAX_MAGDMG];
g_optItem.atkMagMinDmg += (int)g_optValue[OV_W_MAGDMG];
g_optItem.atkMagMaxDmg += (int)g_optValue[OV_W_MAGDMG];
if( g_itemClassTable[classIdx].attackAtt )
{
g_optItem.atkHitPower += (int)g_optValue[OV_W_HITPOWER];
}
else if( g_itemClassTable[classIdx].defenseAtt )
{
g_optItem.defHitPower += (int)g_optValue[OV_W_HITPOWER];
}
g_optItem.defVelocity += (int)g_optValue[OV_VELOCITY];
g_optItem.defAvoidPower += (int)g_optValue[OV_AVOIDPOWER];
g_optItem.atkDelay += (int)g_optValue[OV_W_ATKSPEED];
g_optItem.defPower += (int)g_optValue[OV_D_DEFPOWER];
if( g_optItem.atkPhyMinDmg > g_optItem.atkPhyMaxDmg )
{
g_optItem.atkPhyMinDmg = g_optItem.atkPhyMaxDmg;
}
if( g_optItem.atkMagMinDmg > g_optItem.atkMagMaxDmg )
{
g_optItem.atkMagMinDmg = g_optItem.atkMagMaxDmg;
}
memcpy( &g_optValue, &backupOptValue, sizeof( g_optValue ) );
}
void OPTION_CheckOptionValue( float optValue[] )
{
}
| C++ |
#if !defined(AFX_POSTSYSTEM_H__9C90C004_6FE9_43AF_AD79_A1E4ACE78D18__INCLUDED_)
#define AFX_POSTSYSTEM_H__9C90C004_6FE9_43AF_AD79_A1E4ACE78D18__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#include <VECTOR>
class CPostManager
{
public:
enum
{
MAX_POSTPACKAGE_COUNT = 50,
POST_SENDTIME_INFO_STR_LEN = 32,
POST_TITLESIZE = 100,
POST_STRSIZE = 2000,
MAX_ITEMCOUNT_IN_POSTPACKAGE = 12,
};
enum enumPostPackageState
{
POSTPACKAGE_UNCHECK = 0,
POSTPACKAGE_CHECK,
};
enum enumPostSystemMode
{
POSTSYSTEM_READMODE,
POSTSYSTEM_WRITEMODE,
POSTSYSTEM_NONE,
};
enum enumPostSendType
{
POST_SENDTYPE_WEB,
POST_SENDTYPE_CHAR
};
public:
struct tagDetail{
int ItemNumber;
item_t Items[MAX_ITEMCOUNT_IN_POSTPACKAGE];
};
struct PostPackage_t{
BOOL bActive;
int iPostIdx;
char szFromName [NAMESTRING+1];
char szFromAccountID [IDSTRING+1];
char szPostTitle [POST_TITLESIZE+1];
char szSendPostTime [POST_SENDTIME_INFO_STR_LEN+1];
char szMailStr [POST_STRSIZE+1];
union{
item_t Items[MAX_ITEMCOUNT_IN_POSTPACKAGE];
int ItemBox[MAX_ITEMCOUNT_IN_POSTPACKAGE];
};
int ItemNumber;
enum enumPostPackageState MailState;
enum enumPostSendType PostSendType;
int iRemainDays;
int Nak;
bool bCheck;
};
protected:
enumPostSystemMode m_PostSystemState;
std::vector<PostPackage_t> m_PostEntity;
PostPackage_t* m_pOpenPost;
public:
int m_OpenPostIdx;
int GetState();
PostPackage_t* GetPostPackage(int Idx);
PostPackage_t* GetOpenPost();
int GetPostCount();
bool SetPostPackage(PostPackage_t*);
bool AddPostPackage(PostPackage_t*);
bool DeletePostPackage(PostPackage_t*);
void SetPostSystem(enumPostSystemMode);
void SetOpenPost(int idx);
bool IsValidPost(int idx);
void InitPostSystem();
static BOOL InitPost(PostPackage_t*);
CPostManager::enumPostSystemMode GetPostState();
public:
CPostManager();
virtual ~CPostManager();
};
#endif
| C++ |
#if !defined(AFX_ITEMTABLEDATA_H__F3A4BC8C_A73C_4E43_8CDD_2296573B32B0__INCLUDED_)
#define AFX_ITEMTABLEDATA_H__F3A4BC8C_A73C_4E43_8CDD_2296573B32B0__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CItemTableData
{
public:
enum ItemTable_FluxDataType
{
NONE_TYPE=0,
USE_ITEM_FOR_EPK_CHARGE=2,
USE_ITEM_FOR_EPK_MUCH_CHARGE=3,
USE_ITEM_FOR_REPAIR=4,
USE_ITEM_FOR_WEATHER_SNOW=5,
USE_ITEM_FOR_WEATHER_RAIN=6,
USE_ITEM_FOR_QUESTSCROLL=7,
USE_ITEM_FOR_AUTOQUESTSCROLL=8,
USE_ITEM_FOR_SURGERY=9,
USE_ITEM_FOR_CHAT=10,
USE_ITEM_FOR_RECYCLE=11,
USE_ITEM_FOR_SURGERY_MAXHAIRCOUNT_TYPE=12,
USE_ITEM_FOR_SUMMONCARD_ITEM = 13,
USE_ITEM_FOR_OPTION_MANAGE = 14,
USE_ITEM_FOR_AWAKEN = 15,
USE_ITEM_FOR_PC_SUMMON = 16,
USE_ITEM_FOR_PC_MOVE_SUMMON =17,
MAX_ITEM_TABLE_TYPE_DATA,
};
enum ItemTable_FluxDataValue
{
EPK_RATIO=101,
LPACK_TAB=102,
LPACK_INDEX=103,
RECYCLE_DURABILITY_MULTIPLY=104,
RECYCLE_LEVEL_MULTIPLY=105,
RECYCLE_LEVEL_EXP_MULTIPLY=106,
RECYCLE_LEVEL_GENEXP_MULTIPLY=107,
RECYCLE_PARAM_ITEM_FUNCTION=108,
RECYCLE_LEVEL_EXP_AND_GENEXP_MULTIPLY=109,
EPK_NOT_MORE_CHARGE_IS_DELETE=110,
RECYCLE_RA_CHARGE=111,
RECYCLE_SA_CHARGE=112,
RECYCLE_GEN_CAPABLITY=113,
RECYCLE_DESTROYITEM=114,
RUN_SKILL_ITEM=115,
RUN_SKILL_INDEX=116,
RUN_SKILL_ADD_LEVEL=117,
OPTION_MANAGE_TYPE= 118,
EFFECT_ID =119,
MAX_ITEM_TABLE_FLOAT_DATA,
};
enum Surgery_HairItem_Type
{
SURGERY1=0,
SURGERY2,
};
public:
float GetData(const itemTable_t *_pItemTable,const int _Type);
bool IsType(const itemTable_t *_pItemTable,const int _Type);
int GetUseItemType(const itemTable_t *_pItemTable);
float GetData(const int _ItemTableIndex ,const int _Type);
public:
CItemTableData();
virtual ~CItemTableData();
};
#endif
| C++ |
#include "../Global.h"
CChristMasEvent::CChristMasEvent()
{
m_EventState = EVENT_INACTIVE;
InitChristMasEvent();
}
void CChristMasEvent::InitChristMasEvent()
{
if ( m_EventState == EVENT_ACTIVE)
{
for (int WorldCount = 0; WorldCount < MAX_WORLDS; WorldCount++)
{
if ( m_EventWorld[WorldCount].m_EventState == CHRISTMAS_EVENT_WORLD_PROGRESS )
{
m_EventWorld[WorldCount].m_EventState = CHRISTMAS_EVENT_WORLD_NONE;
m_EventWorld[WorldCount].m_EventLimitTime = 0;
GTH_SendMessage_BroadCast_ChristMasEvent(NULL, WorldCount);
}
}
}
else
{
for (int WorldCount = 0; WorldCount < MAX_WORLDS; WorldCount++)
{
m_EventWorld[WorldCount].m_EventLimitTime = 0;
m_EventWorld[WorldCount].m_EventState = CHRISTMAS_EVENT_WORLD_NONE;
}
m_EventState = EVENT_INACTIVE;
}
}
CChristMasEvent::~CChristMasEvent()
{
}
void CChristMasEvent::GTH_Process_ChristMas_Event()
{
int type = MSG_ReadByte();
switch(type)
{
case CC_CHRISTMAS_EVENT_REQUEST_USE_SNOWITEM:
GTH_ProcessMessage_ChristMas_UseItem();
break;
case CC_CHRISTMAS_EVENT_SETING:
GTH_ProcessMessageEventSeting();
break;
case CC_CHRISTMAS_EVENT_REQUEST_WORLD_STATE:
GTH_ProcessMessage_Request_WordlState();
break;
case CC_CHRISTMAS_EVENT_NOTICE:
GTH_ProcessMessage_Event_UserNotice();
break;
case CC_CHRISTMAS_BROAD_CASTING_EVENT_SETING:
GTH_ProcessMessageBroadCastEventSeting();
break;;
default:
return;
}
}
void CChristMasEvent::GTH_ProcessMessage_ChristMas_UseItem(void)
{
item_t *item;
int itemIdx, itemTableIdx;
int invenPos;
int reply = 1, error = 0;
invenPos = MSG_ReadByte();
itemIdx = g_curPC->inventory[invenPos];
if( itemIdx < 0 )
{
reply = 0;
error = ERROR_CHRISTMAS_EVENT_USE_ITEM;
GTH_SendMessage_Reply_ChristMas_UseItem(g_curPC, reply, error, invenPos);
return;
}
if ( m_EventState == EVENT_INACTIVE)
{
reply = 0;
error = ERROR_CHRISTMAS_EVENT_USE_ITEM2;
GTH_SendMessage_Reply_ChristMas_UseItem(g_curPC, reply, error, invenPos);
return;
}
else
{
item = &g_curPC->item[itemIdx];
itemTableIdx = item->itemTableIdx;
if( item->durability > 0 )
{
item->durability --;
g_DBGameServer->SaveItem( g_curPC, item, itemIdx );
}
else
{
GTH_DeleteMyItem( g_curPC, item );
g_curPC->inventory[invenPos] = -1;
if ( !g_DBGameServer->RemoveItem( g_curPC, itemIdx ) )
{
reply = 0;
error = ERROR_CHRISTMAS_EVENT_USE_ITEM;
GTH_SendMessage_Reply_ChristMas_UseItem(g_curPC, reply, error, invenPos);
return;
}
}
GTH_SendMessage_Reply_ChristMas_UseItem(g_curPC, reply, error, invenPos);
m_EventWorld[g_curPC->worldIdx].m_EventState = CHRISTMAS_EVENT_WORLD_PROGRESS;
m_EventWorld[g_curPC->worldIdx].m_EventLimitTime = CHRISTMASEVENT_LIMITTIME;
m_EventWorld[g_curPC->worldIdx].m_WorldIdx = g_curPC->worldIdx;
GTH_SendMessage_BroadCast_ChristMasEvent(g_curPC, g_curPC->worldIdx);
}
}
void CChristMasEvent::GTH_SendMessage_Reply_ChristMas_UseItem(playerCharacter_t* pc, int reply, int error, int invenpos)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_REPLY_CHRISTMAS_EVENT);
MSG_WriteByte(&netMessage, GSC_CHRISTMAS_EVENT_REPLY_USE_SNOWITEM);
MSG_WriteLong(&netMessage, reply);
if ( reply == 1)
MSG_WriteByte(&netMessage, invenpos);
else
MSG_WriteLong(&netMessage, error);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CChristMasEvent::GTH_SendMessage_BroadCast_ChristMasEvent(playerCharacter_t* pPc, int worldidx)
{
for( int PcCount = 0; PcCount < MAX_PCS; PcCount ++ )
{
if ( g_pc[PcCount].idx < 0 || g_pc[PcCount].idx >= MAX_PCS)
continue;
if ( !g_pc[PcCount].active )
continue;
if( g_pc[PcCount].worldIdx != worldidx )
continue;
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_REPLY_CHRISTMAS_EVENT);
MSG_WriteByte(&netMessage, GSC_CHRISTMAS_EVENT_REPLY_CHRISTEVENT);
MSG_WriteLong(&netMessage, (int)m_EventWorld[worldidx].m_EventState);
MSG_WriteLong(&netMessage, m_EventState);
NET_SendMessage(&g_pc[PcCount].sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
}
void CChristMasEvent::ProcessEventTIme()
{
if ( m_EventState == EVENT_INACTIVE)
return;
for (int worldCount = 0; worldCount < MAX_WORLDS; worldCount++)
{
if ( (m_EventWorld[worldCount].m_WorldIdx < 0) ||
(m_EventWorld[worldCount].m_WorldIdx >= MAX_WORLDS ) )
continue;
if ( m_EventWorld[worldCount].m_EventLimitTime > 0 )
m_EventWorld[worldCount].m_EventLimitTime -= g_timer->GetElapsedMilliTime();
if ( m_EventWorld[worldCount].m_EventLimitTime < 0 )
{
m_EventWorld[worldCount].m_EventState = CHRISTMAS_EVENT_WORLD_NONE;
m_EventWorld[worldCount].m_WorldIdx = -1;
m_EventWorld[worldCount].m_EventLimitTime = 0;
GTH_SendMessage_BroadCast_ChristMasEvent(NULL, worldCount);
}
}
}
void CChristMasEvent::GTH_ProcessMessageEventSeting()
{
int event = MSG_ReadByte();
if ( event == 1)
{
m_EventState = EVENT_ACTIVE;
g_logSystem->WriteRLog("ChristMas EventStting");
}
else
{
InitChristMasEvent();
m_EventState = EVENT_INACTIVE;
}
}
void CChristMasEvent::GTH_ProcessMessageBroadCastEventSeting()
{
if ( g_config.isManager )
{
GTH_SendMessage_Reply_WordlStateToMemberServer( MSG_ReadByte());
}
else
{
GTH_SendMessage_Reply_WordlStateToManagerServer( MSG_ReadByte() );
}
}
void CChristMasEvent::GTH_ProcessMessage_Request_WordlState()
{
int worldidx = MSG_ReadLong();
int reply = 1;
enumEventWorldState state = CHRISTMAS_EVENT_WORLD_NONE;
if ( (worldidx < 0) ||
(worldidx >= MAX_WORLDS) ||
(m_EventState == EVENT_INACTIVE) )
{
reply = 0;
state = CHRISTMAS_EVENT_WORLD_NONE;
GTH_SendMessage_Reply_WordlState(g_curPC, reply, state);
return;
}
state = m_EventWorld[worldidx].m_EventState;
GTH_SendMessage_Reply_WordlState(g_curPC, reply, (int)state);
}
void CChristMasEvent::GTH_SendMessage_Reply_WordlState(playerCharacter_t* pc, int reply, int state)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_REPLY_CHRISTMAS_EVENT);
MSG_WriteByte(&netMessage, GSC_CHRISTMAS_EVENT_REQUEST_WORLD_STATE);
MSG_WriteByte(&netMessage, reply);
if ( reply == 1)
MSG_WriteLong(&netMessage, state);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CChristMasEvent::GTH_SendMessage_Reply_WordlStateToMemberServer(int state)
{
if ( state == 1)
{
m_EventState = EVENT_ACTIVE;
}
else
{
InitChristMasEvent();
m_EventState = EVENT_INACTIVE;
}
int i;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_REPLY_CHRISTMAS_EVENT);
MSG_WriteByte(&netMessage, CC_CHRISTMAS_EVENT_SETING);
MSG_WriteByte(&netMessage, state);
for (i=1; i < MAX_MEMBER_SERVER; i++)
{
if ( !g_memberServer[i].active ) continue;
NET_SendUnreliableMessage(&g_memberServer[i].sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
void CChristMasEvent::GTH_SendMessage_Reply_WordlStateToManagerServer(int state)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_REPLY_CHRISTMAS_EVENT);
MSG_WriteByte(&netMessage, CC_CHRISTMAS_BROAD_CASTING_EVENT_SETING);
MSG_WriteByte(&netMessage, state);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
BOOL CChristMasEvent::GTH_IsChristMasItem(int ItemIdx)
{
if (SANTA_UPPER == ItemIdx || SANTA_LOWER == ItemIdx ||
SANTA_GLOVES == ItemIdx || SANTA_BOOTS == ItemIdx )
return TRUE;
return FALSE;
}
BOOL CChristMasEvent::GTH_IsEnableEquipChristMasItem()
{
for( int equipItemCount = 0; equipItemCount < MAX_EQUIPMENT; equipItemCount ++ )
{
int equipmentIdx = g_curPC->equipment[equipItemCount];
if ( equipmentIdx < 0)
continue;
int itemTableIdx = g_curPC->item[equipmentIdx].itemTableIdx;
if ( GTH_IsChristMasItem(itemTableIdx) == TRUE)
continue;
int tableEquipPos = g_itemTable[itemTableIdx].wearPosition;
if ( tableEquipPos == ITEM_WEAR_POS_UPPER ||
tableEquipPos == ITEM_WEAR_POS_LOWER ||
tableEquipPos == ITEM_WEAR_POS_AIR_PROTECTOR ||
tableEquipPos == ITEM_WEAR_POS_BODY_PROTECTOR ||
tableEquipPos == ITEM_WEAR_POS_GLOVES ||
tableEquipPos == ITEM_WEAR_POS_BOOTS )
return FALSE;
}
return TRUE;
}
BOOL CChristMasEvent::GTH_IsEquipChristMasItem()
{
for( int equipItemCount = 0; equipItemCount < MAX_EQUIPMENT; equipItemCount ++ )
{
int equipmentIdx = g_curPC->equipment[equipItemCount];
if ( equipmentIdx < 0)
continue;
int itemTableIdx = g_curPC->item[equipmentIdx].itemTableIdx;
if ( GTH_IsChristMasItem(itemTableIdx) == TRUE )
return TRUE;
}
return FALSE;
}
BOOL CChristMasEvent::GTH_IsAllowItemWerePos(int ItemIdx)
{
if ( g_itemTable[ItemIdx].wearPosition != ITEM_WEAR_POS_WEAPON &&
g_itemTable[ItemIdx].wearPosition != ITEM_WEAR_POS_RING &&
g_itemTable[ItemIdx].wearPosition != ITEM_WEAR_POS_NECKLACE&&
g_itemTable[ItemIdx].wearPosition != ITEM_WEAR_POS_BRACELET&&
g_itemTable[ItemIdx].wearPosition != ITEM_WEAR_POS_EARRING&&
g_itemTable[ItemIdx].wearPosition != ITEM_WEAR_POS_TRANSFER&&
g_itemTable[ItemIdx].wearPosition != ITEM_WEAR_POS_EPACK )
return FALSE;
return TRUE;
}
void CChristMasEvent::GTH_ProcessMessage_Event_UserNotice()
{
char str[MAX_PATH+1];
_snprintf(str, MAX_PATH, MSG_ReadString());
str[MAX_PATH] = NULL;
if ( g_config.isManager )
{
GTH_SendMessage_NoticeToMember( str );
GTH_SystemAdmin_SetNoticeInfo( str );
}
else
{
GTH_SendMessage_NoticeToManager( str );
}
}
| C++ |
#include "../global.h"
CPostManager::CPostManager()
{
}
CPostManager::~CPostManager()
{
}
CPostManager::PostPackage_t* CPostManager::GetPostPackage(int Idx)
{
if ( m_PostEntity.size() <= Idx )
return NULL;
return &m_PostEntity[Idx];
}
bool CPostManager::AddPostPackage(PostPackage_t* pPostPackage)
{
if ( m_PostEntity.size() >= MAX_POSTPACKAGE_COUNT)
return 0;
m_PostEntity.push_back(*pPostPackage);
return 1;
}
void CPostManager::SetPostSystem(enumPostSystemMode state)
{
m_PostSystemState = state;
}
CPostManager::enumPostSystemMode CPostManager::GetPostState()
{
return m_PostSystemState;
}
int CPostManager::GetPostCount()
{
return m_PostEntity.size();
}
bool CPostManager::IsValidPost(int idx)
{
if ( &m_PostEntity[idx] == NULL )
return 0;
if ( m_PostEntity[idx].iPostIdx < 0 )
return 0;
if ( strlen( m_PostEntity[idx].szFromName ) == 0 )
return 0;
if ( strlen( m_PostEntity[idx].szSendPostTime ) == 0 )
return 0;
return 1;
}
void CPostManager::InitPostSystem()
{
m_PostEntity.erase(m_PostEntity.begin(), m_PostEntity.end());
m_PostSystemState = POSTSYSTEM_NONE;
m_pOpenPost = NULL;
m_OpenPostIdx = -1;
}
void CPostManager::SetOpenPost(int idx)
{
m_pOpenPost = GetPostPackage(idx);
m_OpenPostIdx = idx;
}
CPostManager::PostPackage_t* CPostManager::GetOpenPost()
{
return m_pOpenPost;
}
BOOL CPostManager::InitPost(PostPackage_t* pPostPackage)
{
if ( pPostPackage == NULL)
return FALSE;
memset(pPostPackage, 0, sizeof(PostPackage_t));
pPostPackage->bActive = 0;
pPostPackage->bCheck = 0;
pPostPackage->iPostIdx = -1;
pPostPackage->iRemainDays = -1;
pPostPackage->ItemNumber = 0;
for (int itemIdx = 0; itemIdx < MAX_ITEMCOUNT_IN_POSTPACKAGE; itemIdx++){
pPostPackage->Items[itemIdx].itemTableIdx = -1;
pPostPackage->ItemBox[itemIdx]=-1;
}
pPostPackage->MailState = enumPostPackageState::POSTPACKAGE_UNCHECK;
pPostPackage->Nak = 0;
pPostPackage->PostSendType = enumPostSendType::POST_SENDTYPE_CHAR;
return TRUE;
}
| C++ |
#include "../global.h"
void GTH_DeleteAffectAll( void *ent, int entType )
{
playerCharacter_t *pc;
monsterCharacter_t *m;
if( entType == ENTITY_PC )
{
pc = static_cast<playerCharacter_t*>(ent);
for( int i = 0; i < MAX_AFFECT; i ++ )
{
memset( &pc->affect[i], 0, sizeof( affect_t ) );
pc->affect[i].type = AFFECT_NONE;
}
pc->affectNumber = 0;
pc->isTransform = false;
}
else
{
m = static_cast<monsterCharacter_t*>(ent);
for( int i = 0; i < MAX_AFFECT; i ++ )
{
memset( &m->affect[i], 0, sizeof( affect_t ) );
m->affect[i].type = AFFECT_NONE;
}
m->affectNumber = 0;
}
}
void GTH_DeleteAffect( void *ent, int entType, int skillTableIdx )
{
playerCharacter_t *pc;
monsterCharacter_t *m;
if( entType == ENTITY_PC )
{
pc = static_cast<playerCharacter_t*>(ent);
for( int i = 0; i < pc->affectNumber; i ++ )
{
if( pc->affect[i].skillTableIdx == skillTableIdx )
{
pc->affect[i].forcedDelete = true;
break;
}
}
}
else
{
m = static_cast<monsterCharacter_t*>(ent);
for( int i = 0; i < m->affectNumber; i ++ )
{
if( m->affect[i].skillTableIdx == skillTableIdx )
{
m->affect[i].forcedDelete = true;
break;
}
}
}
}
bool GTH_IsActiveAffect( void *ent, int entType, int skillTableIdx )
{
playerCharacter_t *pc;
monsterCharacter_t *m;
if( entType == ENTITY_PC )
{
pc = static_cast<playerCharacter_t*>(ent);
for( int i = 0; i < pc->affectNumber; i ++ )
{
if( pc->affect[i].skillTableIdx == skillTableIdx )
return 1;
}
}
else
{
m = static_cast<monsterCharacter_t*>(ent);
for( int i = 0; i < m->affectNumber; i ++ )
{
if( m->affect[i].skillTableIdx == skillTableIdx )
return 1;
}
}
return 0;
}
void GTH_DeleteTransform( void *ent, int entType )
{
playerCharacter_t *pc;
monsterCharacter_t *m;
if( entType == ENTITY_PC )
{
pc = static_cast<playerCharacter_t*>(ent);
for( int i = 0; i < pc->affectNumber; i ++ )
{
if( pc->affect[i].type == AFFECT_SPECIAL && pc->affect[i].spe.specialType == 0 )
{
pc->affect[i].forcedDelete = true;
break;
}
}
}
else
{
m = static_cast<monsterCharacter_t*>(ent);
for( int i = 0; i < m->affectNumber; i ++ )
{
if( m->affect[i].type == AFFECT_SPECIAL && m->affect[i].spe.specialType == 0 )
{
m->affect[i].forcedDelete = true;
break;
}
}
}
}
void GTH_DeleteToggle( void *ent, int entType, int skillTableIdx )
{
playerCharacter_t *pc;
monsterCharacter_t *m;
if( entType == ENTITY_PC )
{
pc = static_cast<playerCharacter_t*>(ent);
for( int i = 0; i < pc->affectNumber; i ++ )
{
if( pc->affect[i].type == AFFECT_TOGGLE && pc->affect[i].skillTableIdx == skillTableIdx )
{
pc->affect[i].forcedDelete = true;
break;
}
}
}
else
{
m = static_cast<monsterCharacter_t*>(ent);
for( int i = 0; i < m->affectNumber; i ++ )
{
if( m->affect[i].type == AFFECT_TOGGLE )
{
m->affect[i].forcedDelete = true;
break;
}
}
}
}
void GTH_AffectTransform( void *ent, int transformIdx, int entType )
{
playerCharacter_t *pc;
monsterCharacter_t *m;
if( entType == ENTITY_PC )
{
pc = static_cast<playerCharacter_t*>(ent);
switch( transformIdx )
{
case 35 :
{
pc->isTransform = true;
pc->transformEntityIdx = 10;
pc->transformType = TRANSFORM_ETHEREAL;
}
break;
case 70 :
{
pc->isTransform = true;
pc->transformEntityIdx = 2;
pc->transformType = TRANSFORM_NORMAL;
}
break;
}
}
else
{
m = static_cast<monsterCharacter_t*>(ent);
}
}
void GTH_Affect( void *ent, message_t *msg, int entType )
{
int i, j;
float hitRate;
playerCharacter_t *pc;
monsterCharacter_t *m;
hitRate = (float)msg->data[MSG_AFFDATA_HITRATE];
if( entType == ENTITY_PC )
{
pc = static_cast<playerCharacter_t*>(ent);
if( msg->fromType == ENTITY_PC )
{
hitRate += GTH_GetAffectHitRate( &g_pc[msg->fromIdx], ENTITY_PC, pc, ENTITY_PC, msg->data[MSG_AFFDATA_AFFECT_HITTYPE] );
}
else
{
hitRate += GTH_GetAffectHitRate( &g_monster[msg->fromIdx], ENTITY_MONSTER, pc, ENTITY_PC, msg->data[MSG_AFFDATA_AFFECT_HITTYPE] );
}
if( GTH_Random() > hitRate * 0.01f ) return;
for( i = 0; i < MAX_AFFECT; i ++ )
{
if( pc->affect[i].type == AFFECT_NONE ) break;
if( pc->affect[i].skillTableIdx == msg->data[MSG_AFFDATA_SKILLTABLEIDX] )
{
if( pc->affect[i].type == AFFECT_TOGGLE )
{
GTH_DeleteToggle( pc, ENTITY_PC, pc->affect[i].skillTableIdx );
return;
}
if( pc->affect[i].level <= msg->data[MSG_AFFDATA_LEVEL] )
{
pc->affect[i].startTime = g_globalTime;
pc->affect[i].keepTime = msg->data[MSG_AFFDATA_KEEPTIME];
if( pc->affect[i].type == AFFECT_TOGGLE )
{
pc->affect[i].raCostPerSec = msg->data[MSG_AFFDATA_RACOST_PER_SEC];
pc->affect[i].saCostPerSec = msg->data[MSG_AFFDATA_SACOST_PER_SEC];
pc->affect[i].delayTime = msg->data[MSG_AFFDATA_DELAY_TIME];
}
if( msg->data[MSG_AFFDATA_AFFECT_TYPE] == AFFECT_SPECIAL )
{
pc->affect[i].keepTime += pc->optValue[OV_POLYMORPH_KEEPTIME];
pc->affect[i].keepTime += (int)( (float)( msg->data[MSG_AFFDATA_KEEPTIME] - g_globalTime ) * pc->optValue[OV_POLYMORPH_KEEPTIME_RATE] * 0.01f );
}
pc->affect[i].skillTableIdx = msg->data[MSG_AFFDATA_SKILLTABLEIDX];
for( j = 0; j < MAX_COUNT_AFFECT_DATA; j ++ )
{
pc->affect[i].data[j] = msg->data[j + CONVERT_MSG_TO_AFFECT_SIZE];
}
pc->affect[i].level = msg->data[MSG_AFFDATA_LEVEL];
pc->affect[i].flagApply = false;
return;
}
else if( pc->affect[i].level > msg->data[MSG_AFFDATA_LEVEL] )
{
return;
}
}
}
if( i == MAX_AFFECT ) return;
pc->affect[i].type = msg->data[MSG_AFFDATA_AFFECT_TYPE];
pc->affect[i].startTime = g_globalTime;
pc->affect[i].level = msg->data[MSG_AFFDATA_LEVEL];
pc->affect[i].keepTime = msg->data[MSG_AFFDATA_KEEPTIME];
if( msg->data[MSG_AFFDATA_AFFECT_TYPE] == AFFECT_SPECIAL )
{
pc->affect[i].keepTime += pc->optValue[OV_POLYMORPH_KEEPTIME];
pc->affect[i].keepTime += (int)( (float)( msg->data[MSG_AFFDATA_KEEPTIME] - g_globalTime ) * pc->optValue[OV_POLYMORPH_KEEPTIME_RATE] * 0.01f );
}
if( pc->affect[i].type == AFFECT_TOGGLE )
{
pc->affect[i].raCostPerSec = msg->data[MSG_AFFDATA_RACOST_PER_SEC];
pc->affect[i].saCostPerSec = msg->data[MSG_AFFDATA_SACOST_PER_SEC];
pc->affect[i].delayTime = msg->data[MSG_AFFDATA_DELAY_TIME];
}
pc->affect[i].skillTableIdx = msg->data[MSG_AFFDATA_SKILLTABLEIDX];
for( j = 0; j < MAX_COUNT_AFFECT_DATA; j ++ )
{
pc->affect[i].data[j] = msg->data[j + CONVERT_MSG_TO_AFFECT_SIZE];
}
pc->affect[i].flagApply = false;
pc->affectNumber ++;
}
else
{
m = static_cast<monsterCharacter_t*>(ent);
if( msg->fromType == ENTITY_PC )
{
hitRate += GTH_GetAffectHitRate( &g_pc[msg->fromIdx], ENTITY_PC, m, ENTITY_MONSTER, msg->data[MSG_AFFDATA_AFFECT_HITTYPE] );
}
else
{
hitRate += GTH_GetAffectHitRate( &g_monster[msg->fromIdx], ENTITY_MONSTER, m, ENTITY_MONSTER, msg->data[MSG_AFFDATA_AFFECT_HITTYPE] );
}
if( GTH_Random() > hitRate * 0.01f ) return;
for( i = 0; i < MAX_AFFECT; i ++ )
{
if( m->affect[i].type == AFFECT_NONE ) break;
if( m->affect[i].skillTableIdx == msg->data[MSG_AFFDATA_SKILLTABLEIDX] )
{
if( m->affect[i].type == AFFECT_TOGGLE )
{
GTH_DeleteToggle( m, m->entityType, m->affect[i].skillTableIdx );
return;
}
if( m->affect[i].level <= msg->data[MSG_AFFDATA_LEVEL] )
{
m->affect[i].startTime = g_globalTime;
m->affect[i].keepTime = msg->data[MSG_AFFDATA_KEEPTIME];
m->affect[i].skillTableIdx = msg->data[MSG_AFFDATA_SKILLTABLEIDX];
for( j = 0; j < MAX_COUNT_AFFECT_DATA; j ++ )
{
m->affect[i].data[j] = msg->data[j + CONVERT_MSG_TO_AFFECT_SIZE];
}
m->affect[i].flagApply = false;
return;
}
else if( m->affect[i].level > msg->data[MSG_AFFDATA_LEVEL] )
{
return;
}
}
}
if( i == MAX_AFFECT ) return;
m->affect[i].type = msg->data[MSG_AFFDATA_AFFECT_TYPE];
m->affect[i].startTime = g_globalTime;
m->affect[i].level = msg->data[MSG_AFFDATA_LEVEL];
m->affect[i].keepTime = msg->data[MSG_AFFDATA_KEEPTIME];
m->affect[i].skillTableIdx = msg->data[MSG_AFFDATA_SKILLTABLEIDX];
for( j = 0; j < MAX_COUNT_AFFECT_DATA; j ++ )
{
m->affect[i].data[j] = msg->data[j + CONVERT_MSG_TO_AFFECT_SIZE];
}
m->affect[i].flagApply = false;
m->affectNumber ++;
}
}
void GTH_AffectProcess( void *ent, int entType )
{
playerCharacter_t *pc;
monsterCharacter_t *m;
int i = 0, n;
int flagApply = true;
if( entType == ENTITY_PC )
{
pc = static_cast<playerCharacter_t*>(ent);
n = pc->affectNumber;
if( n > MAX_AFFECT || n < 0 )
{
GTH_DeleteAffectAll( pc, ENTITY_PC );
g_logSystem->WriteToError( "Error : Affect Number, PC(%s,%s), affect number : %d",
pc->name, pc->userID, pc->affectNumber );
n = 0;
pc->affectNumber = 0;
flagApply = false;
}
while( i < n )
{
if( pc->affect[i].keepTime <= g_globalTime || pc->affect[i].forcedDelete )
{
if( pc->affect[i].type == AFFECT_TOGGLE )
{
pc->affect[i].keepTime = g_globalTime + pc->affect[i].delayTime;
if(pc->affect[i].delayTime <= 0)
{
TRACE("AFFECT_TOGGLE ... delayTime %d \n",pc->affect[i].delayTime);
pc->affect[i].delayTime = SKILL_AFFECT_TOGGLE_DEFAULT_DELAY_TIME;
}
if( pc->curRA - pc->affect[i].raCostPerSec < 0 ) pc->affect[i].forcedDelete = true;
if( pc->curSA - pc->affect[i].saCostPerSec < 0 ) pc->affect[i].forcedDelete = true;
if( !pc->affect[i].forcedDelete )
{
pc->curRA -= pc->affect[i].raCostPerSec;
pc->curSA -= pc->affect[i].saCostPerSec;
}
if( pc->curRA <= 0 )
pc->affect[i].forcedDelete = true;
if( pc->curSA <= 0 )
pc->affect[i].forcedDelete = true;
}
if( pc->affect[i].forcedDelete || pc->affect[i].type != AFFECT_TOGGLE )
{
if( pc->affect[i].type == AFFECT_SPECIAL && pc->affect[i].spe.specialType == 0 )
{
pc->isTransform = false;
}
if( i < n - 1 )
{
memcpy( &pc->affect[i], &pc->affect[n - 1], sizeof( affect_t ) );
memset( &pc->affect[n - 1], 0, sizeof( affect_t ) );
pc->affect[n - 1].type = AFFECT_NONE;
}
else
{
memset( &pc->affect[i], 0, sizeof( affect_t ) );
pc->affect[i].type = AFFECT_NONE;
}
n --;
pc->affectNumber --;
flagApply = false;
}
}
else
{
if( !pc->affect[i].flagApply )
{
pc->affect[i].flagApply = true;
flagApply = false;
}
i ++;
}
}
if( pc->curRA < 0 )
pc->curRA = 0.0F;
if( pc->curSA < 0 )
pc->curSA = 0.0F;
if( !flagApply )
{
GTH_PC_Calculate( pc );
GTH_SendPCMessage_Affect( pc );
}
}
else
{
m = static_cast<monsterCharacter_t*>(ent);
n = m->affectNumber;
if( n > MAX_AFFECT || n < 0 )
{
for( int index = 0; index < MAX_AFFECT; index++ )
{
memset( &m->affect[i], 0, sizeof( affect_t ) );
m->affect[i].type = AFFECT_NONE;
}
g_logSystem->WriteToError( "Error : Affect Number, Monster(%s,%d), affect number : %d",
m->basic.name, m->idx, m->affectNumber );
n = 0;
m->affectNumber = 0;
flagApply = false;
}
while( i < n )
{
if( m->affect[i].keepTime <= g_globalTime || m->affect[i].forcedDelete )
{
if( m->affect[i].type == AFFECT_TOGGLE )
{
m->affect[i].keepTime = g_globalTime + PC_AUTO_RECOVERY_DELAY;
if( m->curRA - m->affect[i].raCostPerSec < 0 ) m->affect[i].forcedDelete = true;
if( m->curSA - m->affect[i].saCostPerSec < 0 ) m->affect[i].forcedDelete = true;
if( !m->affect[i].forcedDelete )
{
m->curRA -= m->affect[i].raCostPerSec;
m->curSA -= m->affect[i].saCostPerSec;
}
}
if( m->affect[i].forcedDelete || m->affect[i].type != AFFECT_TOGGLE )
{
if( m->affect[i].type == AFFECT_SPECIAL && m->affect[i].spe.specialType == 0 )
{
}
if( i < n - 1 )
{
memcpy( &m->affect[i], &m->affect[n - 1], sizeof( affect_t ) );
memset( &m->affect[n - 1], 0, sizeof( affect_t ) );
m->affect[n - 1].type = AFFECT_NONE;
}
else
{
memset( &m->affect[i], 0, sizeof( affect_t ) );
m->affect[i].type = AFFECT_NONE;
}
n --;
m->affectNumber --;
flagApply = false;
}
}
else
{
if( !m->affect[i].flagApply )
{
m->affect[i].flagApply = true;
flagApply = false;
}
i ++;
}
}
if( !flagApply )
{
MONSTER_Calculate( m );
GTH_SendMonsterMessage_Affect( m );
}
}
}
void GTH_ApplyCommonAffect( void *pEntity, AFFECTDATA_COMMON *data, int entType )
{
playerCharacter_t* pPlayer = NULL;
monsterCharacter_t* pMonster = NULL;
float *pOptValue=NULL;
if( entType == ENTITY_PC )
{
pPlayer = static_cast<playerCharacter_t*>(pEntity);
pOptValue= &(*(pPlayer->optValue));
}
else
{
pMonster = static_cast<monsterCharacter_t*>(pEntity);
pOptValue= &(*(pMonster->optValue));
}
for( int i = 0; i < MAX_COUNT_AFFECT_DATA; i ++ )
{
switch( data->type[i] )
{
case AFF_DATA_TYPE_PHYDAMAGE_RATE_TOTAL :
{
if( entType == ENTITY_PC )
{
pPlayer->calPhyMaxDmg += (int)( (float)pPlayer->calPhyMaxDmg * (float)data->data[i] * 0.01f );
pPlayer->calPhyMinDmg += (int)( (float)pPlayer->calPhyMaxDmg * (float)data->data[i] * 0.01f );
}
else
{
pMonster->calPhyMaxDmg += (int)( (float)pMonster->calPhyMaxDmg * (float)data->data[i] * 0.01f );
pMonster->calPhyMinDmg += (int)( (float)pMonster->calPhyMaxDmg * (float)data->data[i] * 0.01f );
}
}
break;
case AFF_DATA_TYPE_NONE :
break;
case AFF_DATA_TYPE_PHYDAMAGE :
{
if( entType == ENTITY_PC )
{
pPlayer->calPhyMaxDmg += data->data[i];
pPlayer->calPhyMinDmg += data->data[i];
}
else
{
pMonster->calPhyMaxDmg += data->data[i];
pMonster->calPhyMinDmg += data->data[i];
}
}
break;
case AFF_DATA_TYPE_PHYDAMAGE_RATE :
{
if( entType == ENTITY_PC )
{
pPlayer->calPhyMaxDmg += (int)( (float)pPlayer->basePhyMaxDmg * (float)data->data[i] * 0.01f );
pPlayer->calPhyMinDmg += (int)( (float)pPlayer->basePhyMinDmg * (float)data->data[i] * 0.01f );
}
else
{
pMonster->calPhyMaxDmg += (int)( (float)pMonster->basic.atkPhyMaxDmg * (float)data->data[i] * 0.01f );
pMonster->calPhyMinDmg += (int)( (float)pMonster->basic.atkPhyMinDmg * (float)data->data[i] * 0.01f );
}
}
break;
case AFF_DATA_TYPE_MAGDAMAGE :
{
if( entType == ENTITY_PC )
{
pPlayer->calMagMaxDmg += data->data[i];
pPlayer->calMagMinDmg += data->data[i];
}
else
{
pMonster->calMagMaxDmg += data->data[i];
pMonster->calMagMinDmg += data->data[i];
}
}
break;
case AFF_DATA_TYPE_MAGDAMAGE_RATE :
{
if( entType == ENTITY_PC )
{
pPlayer->calMagMaxDmg += (int)( (float)pPlayer->baseMagMaxDmg * (float)data->data[i] * 0.01f );
pPlayer->calMagMinDmg += (int)( (float)pPlayer->baseMagMinDmg * (float)data->data[i] * 0.01f );
}
else
{
pMonster->calMagMaxDmg += (int)( (float)pMonster->basic.atkMagMaxDmg * (float)data->data[i] * 0.01f );
pMonster->calMagMinDmg += (int)( (float)pMonster->basic.atkMagMinDmg * (float)data->data[i] * 0.01f );
}
}
break;
case AFF_DATA_TYPE_POSITIVE_DAMAGE :
{
if( entType == ENTITY_PC )
{
pPlayer->calPosMinDmg += data->data[i];
pPlayer->calPosMaxDmg += data->data[i];
}
else
{
pMonster->calPosMaxDmg += data->data[i];
pMonster->calPosMinDmg += data->data[i];
}
}
break;
case AFF_DATA_TYPE_NEGATIVE_DAMAGE :
{
if( entType == ENTITY_PC )
{
pPlayer->calNegMinDmg += data->data[i];
pPlayer->calNegMaxDmg += data->data[i];
}
else
{
pMonster->calNegMaxDmg += data->data[i];
pMonster->calNegMinDmg += data->data[i];
}
}
break;
case AFF_DATA_TYPE_ATTACK_SPEED_RATE :
{
if( entType == ENTITY_PC )
{
pPlayer->attackSpeedRate += data->data[i];
if( pPlayer->attackSpeedRate < 0 ) pPlayer->attackSpeedRate = 0;
}
else
{
pMonster->attackSpeedRate += data->data[i];
if( pMonster->attackSpeedRate < 0 ) pMonster->attackSpeedRate = 0;
}
}
break;
case AFF_DATA_TYPE_ATTACK_SPEED :
{
if( entType == ENTITY_PC )
{
pPlayer->baseAttackSpeed += (int)data->data[i];
}
}
break;
case AFF_DATA_TYPE_HIT_POWER :
{
if( entType == ENTITY_PC )
{
pPlayer->calHitPower += data->data[i];
}
else
{
pMonster->calHitPower += data->data[i];
}
}
break;
case AFF_DATA_TYPE_HIT_POWRE_RATE :
{
if( entType == ENTITY_PC )
{
pPlayer->calHitPower += (int)( (float)pPlayer->baseHitPower * (float)data->data[i] * 0.01f );
}
else
{
pMonster->calHitPower += (int)( (float)pMonster->basic.atkHitPower * (float)data->data[i] * 0.01f );
}
}
break;
case AFF_DATA_TYPE_DEFENSE :
{
if( entType == ENTITY_PC )
{
pPlayer->calDefensePower += data->data[i];
}
else
{
pMonster->calDefensePower += data->data[i];
}
}
break;
case AFF_DATA_TYPE_DEFENSE_RATE :
{
if( entType == ENTITY_PC )
{
pPlayer->calDefensePower += (int)( (float)pPlayer->baseItemDefensePower * (float)data->data[i] * 0.01f );
}
else
{
pMonster->calDefensePower += (int)( (float)pMonster->basic.defPower * (float)data->data[i] * 0.01f );
}
}
break;
case AFF_DATA_TYPE_AVOID:
{
if( entType == ENTITY_PC )
{
pPlayer->calAvoidPower += data->data[i];
}
else
{
pMonster->calAvoidPower += data->data[i];
}
}
break;
case AFF_DATA_TYPE_AVOID_POWER_RATE :
{
if( entType == ENTITY_PC )
{
pPlayer->calAvoidPower += (int)( (float)pPlayer->baseAvoidPower * (float)data->data[i] * 0.01f );
}
else
{
pMonster->calAvoidPower += (int)( (float)pMonster->basic.defAvoidPower * (float)data->data[i] * 0.01f );
}
}
break;
case AFF_DATA_TYPE_AVOID_RATE :
{
pOptValue[OV_AVOID_RATE] += (int)data->data[i];
}
break;
case AFF_DATA_TYPE_MAX_RA:
{
if( entType == ENTITY_PC )
{
pPlayer->calMaxRA += (float)data->data[i];
}
else
{
pMonster->calMaxRA += (float)data->data[i];
}
}
break;
case AFF_DATA_TYPE_MAX_RA_RATE :
{
if( entType == ENTITY_PC )
{
pPlayer->calMaxRA += pPlayer->baseMaxRA * (float)data->data[i] * 0.01f;
}
else
{
pMonster->calMaxRA += (float)pMonster->basic.maxRA * (float)data->data[i] * 0.01f;
}
}
break;
case AFF_DATA_TYPE_MAX_SA :
{
if( entType == ENTITY_PC )
{
pPlayer->calMaxSA += (float)data->data[i];
}
else
{
pMonster->calMaxSA += (float)data->data[i];
}
}
break;
case AFF_DATA_TYPE_MAX_SA_RATE :
{
if( entType == ENTITY_PC )
{
pPlayer->calMaxSA += (float)pPlayer->baseMaxSA * (float)data->data[i] * 0.01f;
}
else
{
pMonster->calMaxSA += (float)pMonster->basic.maxSA * (float)data->data[i] * 0.01f;
}
}
break;
case AFF_DATA_TYPE_VELOCITY :
{
if( entType == ENTITY_PC )
{
pPlayer->calVelocity += (float)data->data[i] * 0.01f;
}
else
{
pMonster->calVelocity += (float)data->data[i] * 0.01f;
}
}
break;
case AFF_DATA_TYPE_VELOCITY_RATE:
{
if( entType == ENTITY_PC )
{
pPlayer->calVelocity += (float)pPlayer->baseVelocity * (float)data->data[i] * 0.01f;
if( pPlayer->calVelocity < 0.0f ) pPlayer->calVelocity = 0.0f;
if( pPlayer->generalSpeed < 0 )
{
pPlayer->generalSpeed = 0;
pPlayer->calVelocity = 0.0f;
}
}
else
{
pMonster->calVelocity += (float)pMonster->basic.velocity * (float)data->data[i] * 0.01f;
if( pMonster->generalSpeed < 0 )
{
pMonster->generalSpeed = 0;
pMonster->calVelocity = 0.0f;
}
}
}
break;
case AFF_DATA_TYPE_RA_RECOVERY:
{
pOptValue[OV_AUTORECOVERY_RA_IDLE] += (float)data->data[i];
pOptValue[OV_AUTORECOVERY_RA_ATTACK] += (float)data->data[i];
}
break;
case AFF_DATA_TYPE_SA_RECOVERY:
{
pOptValue[OV_AUTORECOVERY_SA_IDLE] += (float)data->data[i];
pOptValue[OV_AUTORECOVERY_SA_ATTACK] += (float)data->data[i];
}
break;
case AFF_DATA_TYPE_DECREASE_SA_USE:
{
pOptValue[OV_DECSA_USE] += (float)data->data[i];
}
break;
case AFF_DATA_TYPE_DECREASE_RA_USE:
{
pOptValue[OV_DECRA_USE] = (float)data->data[i];
}
break;
case AFF_DATA_TYPE_DECREASE_RA:
{
if( entType == ENTITY_PC )
{
pPlayer->curRA -= (float)data->data[i];
if( pPlayer->curRA < 0 ) pPlayer->curRA = 0;
}
else
{
pMonster->curRA -= (float)data->data[i];
if( pMonster->curRA < 0 ) pMonster->curRA = 0;
}
}
break;
case AFF_DATA_TYPE_DECREASE_SA:
{
if( entType == ENTITY_PC )
{
pPlayer->curSA += (float)data->data[i];
if( pPlayer->curSA < 0 ) pPlayer->curSA = 0;
}
else
{
pMonster->curSA += (float)data->data[i];
if( pMonster->curSA < 0 ) pMonster->curSA = 0;
}
}
break;
case AFF_DATA_TYPE_OV_DEFENCE_RATE:
{
pOptValue[OV_DEFENCE_RATE] = (float)data->data[i];
}
break;
case AFF_DATA_TYPE_CASTING_TIME_RATE :
{
pOptValue[OV_DEC_CASTINGTIME_RATE] += (float)data->data[i];
}
break;
case AFF_DATA_TYPE_REFLECT_DAMAGE :
{
pOptValue[OV_REFLECTDMG] += (float)data->data[i];
}
break;
case AFF_DATA_TYPE_REFLECT_DAMAGE_RATE :
{
pOptValue[OV_REFLECTDMG_RATE] += (float)data->data[i];
}
break;
case AFF_DATA_TYPE_MANASHIELD :
{
pOptValue[OV_SKILL_MANASHIELD] = (float)data->data[i];
}
break;
case AFF_DATA_TYPE_PARALYSIS :
{
if( entType == ENTITY_PC )
{
pPlayer->generalSpeed = 0;
}
else
{
pMonster->generalSpeed = 0;
}
}
break;
case AFF_DATA_TYPE_CRITICAL_RATE:
{
if ( entType == ENTITY_PC)
{
pPlayer->calCriticalRate += (float)data->data[i] * 0.01f;
}
else
{
pMonster->calCriticalRate += (float)data->data[i] * 0.01f;
}
}break;
case AFF_DATA_TYPE_ONCE_ATTACK_RACOST:
{
pOptValue[OV_ATK_RACOST] += (float)data->data[i];
}break;
case AFF_DATA_TYPE_ONCE_ATTACK_SACOST:
{
pOptValue[OV_ATK_SACOST] += (float)data->data[i];
}break;
case AFF_DATA_TYPE_CONFUSION:
break;
case AFF_DATA_TYPE_SCANED:
break;
case AFF_DATA_TYPE_GET_EXP_GENEXP_GENCAPABILITY_RATE_INC:
{
pOptValue[OV_ADD_EXP_RATE] += (float)data->data[i];
pOptValue[OV_ADD_GENEXP_RATE] += (float)data->data[i];
pOptValue[OV_ADD_GENCAPABILITY_RATE]+= (float)data->data[i];
}
break;
case AFF_DATA_TYPE_FINAL_ADD_PHY_DMG_RATE:
{
pOptValue[OV_SKILL_FINAL_ADD_PHY_DMG_RATE] += (float)data->data[i];
}
break;
case AFF_DATA_TYPE_FINAL_ADD_MYSTERY_POS_DMG_RATE:
{
pOptValue[OV_SKILL_FINAL_ADD_MYSTERY_POS_DMG_RATE] += (float)data->data[i];
}
break;
case AFF_DATA_TYPE_FINAL_ADD_MYSTERY_NEG_DMG_RATE:
{
pOptValue[OV_SKILL_FINAL_ADD_MYSTERY_NEG_DMG_RATE] += (float)data->data[i];
}
break;
case AFF_DATA_TYPE_DEC_COOLTIME_RATE:
{
pOptValue[OV_DEC_COOLTIME_RATE] += (float)data->data[i];
}
break;
case AFF_DATA_TYPE_FINAL_ADD_DEFENCE_RATE:
{
pOptValue[OV_SKILL_FINAL_ADD_DEFENCE_RATE] += (float)data->data[i];
}
break;
case AFF_DATA_TYPE_RA_RECOVERY_TIME:
{
pOptValue[OV_AUTORECOVERY_RA_TIME] += (float)data->data[i];
}
break;
case AFF_DATA_TYPE_SA_RECOVERY_TIME:
{
pOptValue[OV_AUTORECOVERY_SA_TIME] += (float)data->data[i];
}
break;
case AFF_DATA_TYPE_CRITICAL_DMG_RATE:
{
pOptValue[OV_CRITICAL_DMG_RATE] += (float)data->data[i];
}
break;
case AFF_DATA_TYPE_CRITICAL_DMG:
{
pOptValue[OV_CRITICAL_DMG] += (float)data->data[i];
}
break;
}
}
}
void GTH_ApplySpecialAffect( void *ent, AFFECTDATA_SPECIAL *spe, int entType )
{
playerCharacter_t *pc;
monsterCharacter_t *m;
if( entType == ENTITY_PC )
{
pc = static_cast<playerCharacter_t*>(ent);
if( spe->specialType == 0 )
{
CSkillProcAffectSpe *pSpe = g_SkillProc.GetAffectSpe();
if(pSpe)
{
bool succ = pSpe->Proc(spe->specialIdx,ent,spe);
}
}
}
else
{
m = static_cast<monsterCharacter_t*>(ent);
}
}
void GTH_ApplyAffect( void *ent, int entType )
{
playerCharacter_t *pc;
monsterCharacter_t *m;
int i;
if( entType == ENTITY_PC )
{
pc = static_cast<playerCharacter_t*>(ent);
for( i = 0; i < pc->affectNumber; i ++ )
{
switch( pc->affect[i].type )
{
case AFFECT_ATTACK : case AFFECT_DEFENSE :
case AFFECT_ASSIST : case AFFECT_TOGGLE : case AFFECT_CURSE :
{
GTH_ApplyCommonAffect( pc, &pc->affect[i].common );
}
break;
case AFFECT_SPECIAL :
{
GTH_ApplySpecialAffect( pc, &pc->affect[i].spe );
}
break;
default :
break;
}
}
}
else
{
m = static_cast<monsterCharacter_t*>(ent);
for( i = 0; i < m->affectNumber; i ++ )
{
switch( m->affect[i].type )
{
case AFFECT_ATTACK : case AFFECT_DEFENSE :
case AFFECT_ASSIST : case AFFECT_TOGGLE : case AFFECT_CURSE :
{
GTH_ApplyCommonAffect( m, &m->affect[i].common, m->entityType );
}
break;
case AFFECT_SPECIAL :
{
GTH_ApplySpecialAffect( m, &m->affect[i].spe, m->entityType );
}
break;
default :
break;
}
}
}
}
int GTH_MakeAffectTableIdx( void *ent, int affectIdx[], int entType )
{
playerCharacter_t *pc;
monsterCharacter_t *m;
int i, n = 0;
if( entType == ENTITY_PC )
{
pc = static_cast<playerCharacter_t*>(ent);
n = 0;
for( i = 0; i < pc->affectNumber; i ++ )
{
if( pc->affect[i].type == AFFECT_NONE ) continue;
affectIdx[n] = pc->affect[i].skillTableIdx;
n ++;
}
}
else
{
m = static_cast<monsterCharacter_t*>(ent);
n = 0;
for( i = 0; i < m->affectNumber; i ++ )
{
if( m->affect[i].type == AFFECT_NONE ) continue;
affectIdx[n] = m->affect[i].skillTableIdx;
n ++;
}
}
return( n );
}
int GTH_MakeAffectTime( void *ent, int affectTime[], int entType )
{
playerCharacter_t *pc;
monsterCharacter_t *m;
int i, n = 0;
if( entType == ENTITY_PC )
{
pc = static_cast<playerCharacter_t*>(ent);
n = 0;
for( i = 0; i < pc->affectNumber; i ++ )
{
if( pc->affect[i].type == AFFECT_NONE ) continue;
affectTime[n] = pc->affect[i].keepTime - g_globalTime;
n ++;
}
}
else
{
m = static_cast<monsterCharacter_t*>(ent);
n = 0;
for( i = 0; i < m->affectNumber; i ++ )
{
if( m->affect[i].type == AFFECT_NONE ) continue;
affectTime[n] = m->affect[i].keepTime - g_globalTime;
n ++;
}
}
return( n );
}
int GTH_GetEntityCurseState( int entType, int entIdx, int curseType )
{
playerCharacter_t *pc;
monsterCharacter_t *m;
int i, j;
if( entType == ENTITY_PC )
{
pc = &g_pc[entIdx];
if( !pc->active || !pc->ready || !pc->alive ) return 0;
for( i = 0; i < pc->affectNumber; i ++ )
{
if( pc->affect[i].type == AFFECT_NONE || pc->affect[i].type == AFFECT_SPECIAL ) continue;
for( j = 0; j < MAX_COUNT_AFFECT_DATA; j ++ )
{
if( pc->affect[i].common.type[j] == curseType ) return 1;
}
}
return 0;
}
else
{
m = &g_monster[entIdx];
if( !m->active || m->aliveState != MON_ALIVE_STATE_NORMAL ) return 0;
for( i = 0; i < m->affectNumber; i ++ )
{
if( m->affect[i].type == AFFECT_NONE || m->affect[i].type == AFFECT_SPECIAL ) continue;
for( j = 0; j < MAX_COUNT_AFFECT_DATA; j ++ )
{
if( m->affect[i].common.type[j] == curseType ) return 1;
}
}
}
return 0;
}
int GTH_RemoveEntityCurseState( int entType, int entIdx, int curseType )
{
playerCharacter_t *pc;
monsterCharacter_t *m;
int i, j;
if( entType == ENTITY_PC )
{
pc = &g_pc[entIdx];
if( !pc->active || !pc->ready || !pc->alive ) return 0;
for( i = 0; i < pc->affectNumber; i ++ )
{
if( pc->affect[i].type == AFFECT_NONE || pc->affect[i].type == AFFECT_SPECIAL ) continue;
for( j = 0; j < MAX_COUNT_AFFECT_DATA; j ++ )
{
if( pc->affect[i].common.type[j] == curseType )
{
pc->affect[i].forcedDelete = true;
return 1;
}
}
}
return 0;
}
else
{
m = &g_monster[entIdx];
if( !m->active || m->aliveState != MON_ALIVE_STATE_NORMAL ) return 0;
for( i = 0; i < m->affectNumber; i ++ )
{
if( m->affect[i].type == AFFECT_NONE || m->affect[i].type == AFFECT_SPECIAL ) continue;
for( j = 0; j < MAX_COUNT_AFFECT_DATA; j ++ )
{
if( m->affect[i].common.type[j] == curseType )
{
m->affect[i].forcedDelete = true;
return 1;
}
}
}
}
return 0;
}
| C++ |
#include "../global.h"
void GambleSystemDecode()
{
SHORT Packet = static_cast<enum enumGambleSystem>(MSG_ReadShort());
switch(Packet)
{
case ACTIVE_SYSTEM_REQUEST:
GambleSystem_ActiveSystem_ProcessMessage();
break;
case BUY_GAMBLE_ITEM_REQUEST:
BuyGambleItem_ProcessMessage();
break;
}
}
void GambleSystem_ActiveSystem_ProcessMessage()
{
g_GambleSystem.SetActiveSystem(MSG_ReadByte());
}
#include "../CTools.h"
extern CTools* gcpTools;
void BuyGambleItem_ProcessMessage()
{
if ( g_curPC == NULL)
return;
storeStruct_t *pStore = NULL;
int StoreIdx = 0;
int StoreItemIdx = 0;
int ItemNumber = 0;
int NpcIdx = 0;
StoreItemIdx = MSG_ReadLong();
ItemNumber = MSG_ReadLong();
StoreIdx = g_curPC->storeIdx;
if (StoreIdx< 0 || StoreIdx>= MAX_STORES)
{
BuyGambleItem_ReplyMessage( g_curPC, 0, ERROR_BUYITEM_7, NULL, 0, 0 );
return;
}
if ( StoreItemIdx < 0 || StoreItemIdx >= MAX_NUMBER_OF_STORE_ITEM)
{
BuyGambleItem_ReplyMessage( g_curPC, 0, ERROR_BUYITEM_2, NULL, 0, 0 );
return;
}
if( g_curPC->curItemWeight > g_curPC->calItemWeight )
{
BuyGambleItem_ReplyMessage( g_curPC, 0, ERROR_BUYITEM_5, NULL, 0, 0 );
return;
}
int Selectidx = g_curPC->RegGambleItems[StoreItemIdx];
if ( (Selectidx < 0) ||
(Selectidx >= MAX_NUMBER_OF_ITEM_TABLE) )
{
BuyGambleItem_ReplyMessage( g_curPC, 0, ERROR_BUYITEM_2, NULL, 0, 0 );
return;
}
NpcIdx = g_curPC->npcIdx;
pStore = &g_store[StoreIdx];
int ByeCost = 0;
ByeCost = g_curPC->RegGamblePrice[StoreItemIdx] * ItemNumber;
if( GTH_IsHaveItem(g_curPC, CGambleSystem::LUCKY_STONE_ITEM_TABLE_IDX, ByeCost) == FALSE )
{
BuyGambleItem_ReplyMessage( g_curPC, 0, ERROR_BUYITEM_6, NULL, 0, 0 );
return;
}
float SelectRate = 0.0f;
float accPro = 0.0f;
SelectRate = GTH_Random();
int OptionCount = 0;
for( int OptionTableIdx = 0; OptionTableIdx< MAX_GAMBLE_SELECTOPTION ; OptionTableIdx ++ )
{
accPro += (float) g_logic.gambleSelectOptionTable[OptionTableIdx].SelectOptionRate * 0.01;
if( SelectRate < accPro ) break;
OptionCount++;
}
if ( OptionCount > MAX_NUMBER_OF_ITEM_OPTION )
OptionCount = MAX_NUMBER_OF_ITEM_OPTION;
item_t buyItem;
SpawnItem(&buyItem, Selectidx, OptionCount, 1, 0, 1 );
int itemTableIdx = buyItem.itemTableIdx;
if( itemTableIdx >= g_itemTableNumber || itemTableIdx < 0)
{
g_logSystem->Write( "Shop Error!! Index Out of Range : %s(%s), %s(%d)npc , BuyItem %s(%d), Table Index : %d", g_curPC->name, g_curPC->userID,
g_monster[NpcIdx].basic.name, NpcIdx, buyItem.name, StoreItemIdx, itemTableIdx );
BuyGambleItem_ReplyMessage( g_curPC, 0, ERROR_BUYITEM_2, NULL, 0, 0 );
return;
}
if ( gcpTools->AddItem(g_curPC, buyItem, FALSE) == -1 )
{
BuyGambleItem_ReplyMessage( g_curPC, 0, ERROR_BUYITEM_3, NULL, 0, 0 );
return;
}
g_curPC->curItemWeight += g_itemTable[buyItem.itemTableIdx].weight;
g_logSystem->Write("User [%s](%s) Buy '%s' Item, Pay : %dSE.", g_curPC->name, g_curPC->userID, g_itemTable[itemTableIdx].name, ByeCost );
if( pStore->item[StoreItemIdx].curNumber > 0 )
pStore->item[StoreItemIdx].curNumber --;
int GoldItemIdxOfInven = gcpTools->GetMatchMyInventoryIdx_fromItemTable(g_curPC, CGambleSystem::LUCKY_STONE_ITEM_TABLE_IDX);
gcpTools->DeleteItemFromMyInventory(g_curPC, GoldItemIdxOfInven, CGambleSystem::LUCKY_STONE_ITEM_TABLE_IDX, ByeCost);
BuyGambleItem_ReplyMessage( g_curPC, 1, 0, &buyItem, StoreItemIdx, pStore->item[StoreItemIdx].curNumber );
}
void BuyGambleItem_ReplyMessage(playerCharacter_t *pPc, int reply, int error, item_t *item,
int storeItemIdx, int curNumber)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GAMBLE_SYSTEM);
MSG_WriteShort(&netMessage, BUY_GAMBLE_ITEM_REPLY);
MSG_WriteByte(&netMessage, reply);
if (reply > 0)
{
MSG_WriteShort(&netMessage, storeItemIdx );
MSG_WriteShort(&netMessage, curNumber);
MSG_WriteItem(&netMessage, item);
MSG_WriteShort(&netMessage, pPc->curItemWeight);
}
else
{
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pPc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
} | C++ |
#if !defined(AFX_GAMBLESYSTEM_H__8B1781DF_A9DA_4671_9184_04530D64A692__INCLUDED_)
#define AFX_GAMBLESYSTEM_H__8B1781DF_A9DA_4671_9184_04530D64A692__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#include <VECTOR>
class CGambleSystem
{
public:
enum
{
GOLD_ITEM_TABLE_IDX = 459,
LUCKY_STONE_ITEM_TABLE_IDX = 620,
QUESTION_MARK_ITEM_TABLE_IDX = 97,
MAX_REGSTER_ITEMCOUNT = 3,
GAMBLE_STORE_IDX = 23
};
private:
struct CollectGambleByType_t
{
enum AVAILABLE
{
OPTION_AVAILABLE_ON_DAGGER = 1,
OPTION_AVAILABLE_ON_1HSWORD,
OPTION_AVAILABLE_ON_2HSWORD,
OPTION_AVAILABLE_ON_BOW,
OPTION_AVAILABLE_ON_STAFF,
OPTION_AVAILABLE_ON_SPIRITOR,
OPTION_AVAILABLE_ON_CLAW,
OPTION_AVAILABLE_ON_ARMORS,
OPTION_AVAILABLE_ON_UPPER,
OPTION_AVAILABLE_ON_LOWER,
OPTION_AVAILABLE_ON_AIRPROTECTOR,
OPTION_AVAILABLE_ON_BODYPROTECTOR,
OPTION_AVAILABLE_ON_GLOVES,
OPTION_AVAILABLE_ON_BOOTS,
OPTION_AVAILABLE_ON_RING,
OPTION_AVAILABLE_ON_NECKLACE,
OPTION_AVAILABLE_ON_BRACELET,
OPTION_AVAILABLE_ON_EARRING,
OPTION_AVAILABLE_ON_EPACK,
OPTION_AVAILABLE_ON_ETC,
MAX_COUNT_OPTION_AVAILABLE_TYPE = 21,
};
struct GambleItem_t
{
int ItemIdx;
float GambleRate;
GambleItem_t()
{
ItemIdx = -1;
GambleRate = 0.0F;
};
};
int Type;
std::vector<int> vAvailableOption;
std::vector<GambleItem_t> vGambleItem;
float TotalGamebleRate;
CollectGambleByType_t();
};
private:
CollectGambleByType_t m_CollectGambleItemByType[MAX_COUNT_OPTION_AVAILABLE_TYPE];
int m_CollectGambleTypeNumber;
BOOL m_bActiveSystem;
public:
void CollectGambleItems(void);
void CollectGambleOptions(void);
BOOL MakeGambleStore(storeStruct_t* Makestore,
storeStruct_t* Gamblestore, playerCharacter_t* pPc);
BOOL RandomRegsterItemToDefaultStore(storeStruct_t* pMakestore, int MaxCount, storeItem_t *pStoreItem);
BOOL DefaultItemToStore(playerCharacter_t* pPc, storeStruct_t* pMakestore);
int SelectCollectedItem(storeItem_t* pItem);
int GetGambleItemAvallableOn(int availableon);
void InitMakeStore(storeStruct_t* pMakestore);
void GTH_ProcessMessage_Request_Buy_GambleItem(playerCharacter_t* pPc);
public:
CollectGambleByType_t* GetCollectGambleItem(int Type);
int GetTotalGamebleTableNumber(void);
BOOL isActiveSystem(void);
void SetActiveSystem(BOOL bActive);
public:
void InitGambleSystem();
public:
CGambleSystem();
virtual ~CGambleSystem();
};
#endif
| C++ |
#include "../global.h"
int g_partyTime;
#include "../Tools/CTools.h"
extern CTools* gcpTools;
void GTH_InitPartyInfo()
{
int i, j;
for( i = 0; i < MAX_PARTY_NUMBER; i ++ )
{
memset( &g_partyInfo[i], 0, sizeof( serverPartyInfo_t ) );
for( j = 0; j < MAX_NUMBER_OF_PARTY_MEMBER; j ++ )
g_partyInfo[i].member[j].serverIndex = -1;
g_partyInfo[i].idx = -1;
g_partyInfo[i].isHolding = 0;
}
g_partyTime = g_globalTime;
}
void GTH_InitPartyInfo( serverPartyInfo_t *p )
{
int i;
memset( p, 0, sizeof( serverPartyInfo_t ) );
p->idx = -1;
for( i = 0; i < MAX_NUMBER_OF_PARTY_MEMBER; i ++ )
{
p->member[i].serverIndex = -1;
}
p->isHolding = 0;
}
int GTH_GetEmptyPartyInfo()
{
int i;
for( i = 0; i < MAX_PARTY_NUMBER; i ++ )
{
if( g_partyInfo[i].memberNumber == 0 ) break;
}
if( i == MAX_PARTY_NUMBER ) return -1;
return i;
}
int GTH_GetPartyInfo( char* organizerName, int organizeServer, int organizeTime )
{
int i;
for( i = 0; i < MAX_PARTY_NUMBER; i ++ )
{
if( g_partyInfo[i].memberNumber == 0 ) continue;
if( stricmp( organizerName, g_partyInfo[i].organizerName ) ) continue;
if( organizeServer != g_partyInfo[i].organizeServer ) continue;
if( organizeTime != g_partyInfo[i].organizeTime ) continue;
break;
}
if( i == MAX_PARTY_NUMBER ) return -1;
return i;
}
int GTH_GetEmptyMemberIdx( serverPartyInfo_t *p )
{
int i;
for( i = 0; i < MAX_NUMBER_OF_PARTY_MEMBER; i ++ )
{
if( p->member[i].serverIndex == -1 ) break;
}
if( i == MAX_NUMBER_OF_PARTY_MEMBER ) return( -1 );
return( i );
}
int GTH_FindMemberIdx( serverPartyInfo_t *p, char* memberName )
{
int i;
for( i = 0; i < MAX_NUMBER_OF_PARTY_MEMBER; i ++ )
{
if( p->member[i].serverIndex == -1 ) continue;
if( !stricmp( p->member[i].memberName, memberName ) ) break;
}
if( i == MAX_NUMBER_OF_PARTY_MEMBER ) return( -1 );
return( i );
}
int GTH_FindLeaderIdx( serverPartyInfo_t *p )
{
int i;
for( i = 0; i < MAX_NUMBER_OF_PARTY_MEMBER; i ++ )
{
if( p->member[i].serverIndex == -1 ) continue;
if( p->member[i].isLeader ) break;
}
if( i == MAX_NUMBER_OF_PARTY_MEMBER ) return( -1 );
return( i );
}
int GTH_FindNextLeader( serverPartyInfo_t *p, int exceptMember )
{
int i;
for( i = 0; i < MAX_NUMBER_OF_PARTY_MEMBER; i ++ )
{
if( p->member[i].serverIndex == -1 ) continue;
if( i == exceptMember ) continue;
if( !p->member[i].isActive ) continue;
break;
}
if( i == MAX_NUMBER_OF_PARTY_MEMBER ) return( -1 );
return( i );
}
int GTH_GetCorrectMember( serverPartyInfo_t *p, playerCharacter_t *pc )
{
if( stricmp( p->organizerName, pc->organizerName ) ) return( false );
if( p->organizeServer != pc->organizeServer ) return( false );
if( p->organizeTime != pc->organizeTime ) return( false );
if( !pc->active || !pc->ready ) return( false );
return( true );
}
int GTH_GetActiveMemberNumber( serverPartyInfo_t *p, int exceptMember )
{
int i;
int n = 0;
for( i = 0; i < MAX_NUMBER_OF_PARTY_MEMBER; i ++ )
{
if( p->member[i].serverIndex == -1 ) continue;
if( i == exceptMember ) continue;
if( !p->member[i].isActive ) continue;
n ++;
}
return( n );
}
void GTH_SetServerPartyAckMessage( playerCharacter_t *pc, int errorFlag )
{
pc->serverAckMsgPartyFlag = true;
pc->serverAckMsgPartyWaitTimer = g_globalTime + 1000;
pc->serverPartyErrorFlag = errorFlag;
}
void GTH_ClearServerPartyAckMessage( playerCharacter_t *pc )
{
pc->serverAckMsgPartyFlag = false;
pc->serverAckMsgPartyWaitTimer = 0;
}
int GTH_CheckServerPartyAckMessage( playerCharacter_t *pc )
{
if ( pc->serverAckMsgPartyFlag )
{
if ( g_globalTime >= pc->serverAckMsgPartyWaitTimer )
{
GTH_ClearServerPartyAckMessage( pc );
return( false );
}
}
return( true );
}
int GTH_CheckSameParty( playerCharacter_t *pc1, playerCharacter_t *pc2 )
{
if( stricmp( pc1->organizerName, pc2->organizerName ) ) return( false );
if( pc1->organizeServer != pc2->organizeServer ) return( false );
if( pc1->organizeTime != pc2->organizeTime ) return( false );
return( true );
}
void GTH_PartyInfo_Organize( partyMember_t* l, partyMember_t* m, float organizeTime )
{
int reply = 1, error = 0, idx;
serverPartyInfo_t *pi;
idx = GTH_GetEmptyPartyInfo();
if( idx < 0 )
{
reply = 0;
error = ERROR_PARTY_2;
}
else
{
pi = &g_partyInfo[idx];
pi->canJoin = true;
pi->idx = idx;
pi->itemDivideType = 0;
pi->memberNumber = 2;
strcpy( pi->organizerName, l->memberName );
pi->organizeServer = l->serverIndex;
pi->organizeTime = organizeTime;
memcpy( &pi->member[0], l, sizeof( partyMember_t ) );
memcpy( &pi->member[1], m, sizeof( partyMember_t ) );
if( pi->member[0].serverIndex == g_config.gameServerNo )
{
GTH_PartyInfo_Reply_Organize( l, m, idx, organizeTime, true );
}
else
{
GTH_SendMessage_PartyInfo_Reply_Organize( pi->member[0].serverIndex, idx, l, m, organizeTime, true );
}
if( pi->member[1].serverIndex == g_config.gameServerNo )
{
GTH_PartyInfo_Reply_Organize( l, m, idx, organizeTime, false );
}
else
{
GTH_SendMessage_PartyInfo_Reply_Organize( pi->member[1].serverIndex, idx, l, m, organizeTime, false );
}
}
}
void GTH_PartyInfo_Request_Organize( playerCharacter_t *leader, playerCharacter_t *firstMember )
{
partyMember_t l, m;
int organizeTime;
memset( &l, 0, sizeof( partyMember_t ) );
memset( &m, 0, sizeof( partyMember_t ) );
strcpy( l.memberName, leader->name );
l.idx = 0;
l.isActive = true;
l.isLeader = true;
l.level = leader->level;
l.gen = leader->pcClass;
l.serverIndex = g_config.gameServerNo;
l.idxOnServer = leader->idx;
l.worldIdx = leader->worldIdx;
strcpy( m.memberName, firstMember->name );
m.idx = 1;
m.isActive = true;
m.isLeader = false;
m.level = firstMember->level;
m.gen = firstMember->pcClass;
m.serverIndex = g_config.gameServerNo;
m.idxOnServer = firstMember->idx;
m.worldIdx = firstMember->worldIdx;
organizeTime = g_globalTime;
GTH_SetServerPartyAckMessage( leader, ERROR_PARTY_2 );
GTH_SetServerPartyAckMessage( firstMember, ERROR_PARTY_2 );
if ( g_config.isManager )
{
GTH_PartyInfo_Organize( &l, &m, organizeTime );
}
else
{
GTH_SendMessage_PartyInfo_Request_Organize( &l, &m, organizeTime );
}
}
void GTH_PartyInfo_Reply_Organize( partyMember_t* l, partyMember_t* m, int partyIdx, float organizeTime, int isLeader )
{
playerCharacter_t* pc;
if( isLeader )
{
pc = &g_pc[l->idxOnServer];
strcpy( pc->organizerName, l->memberName );
pc->organizeServer = l->serverIndex;
pc->organizeTime = organizeTime;
pc->memberNumber = 2;
pc->_partyRandomInfo_t.itemDivideType = 0;
pc->canJoin = true;
pc->partyIndex = partyIdx;
pc->isLeader = true;
memcpy( &pc->member[0], l, sizeof( partyMember_t ) );
memcpy( &pc->member[1], m, sizeof( partyMember_t ) );
GTH_ClearServerPartyAckMessage( pc );
GTH_SendMessage_Party_Admit_Organize( pc, 1, 0, true );
}
else
{
pc = &g_pc[m->idxOnServer];
strcpy( pc->organizerName, l->memberName );
pc->organizeServer = l->serverIndex;
pc->organizeTime = organizeTime;
pc->memberNumber = 2;
pc->_partyRandomInfo_t.itemDivideType = 0;
pc->canJoin = true;
pc->partyIndex = partyIdx;
pc->isLeader = false;
memcpy( &pc->member[0], l, sizeof( partyMember_t ) );
memcpy( &pc->member[1], m, sizeof( partyMember_t ) );
GTH_ClearServerPartyAckMessage( pc );
GTH_SendMessage_Party_Admit_Organize( pc, 1, 0, false );
}
}
void GTH_PartyInfo_Join( partyMember_t* m, char* organizerName, int organizeServer, int organizeTime )
{
int reply = 1, error = 0, idx, memberIdx, i;
serverPartyInfo_t *pi;
idx = GTH_GetPartyInfo( organizerName, organizeServer, organizeTime );
if( idx < 0 )
{
reply = 0;
error = ERROR_PARTY_2;
}
else
{
pi = &g_partyInfo[idx];
if( GTH_FindMemberIdx( pi, m->memberName ) >= 0 ) return;
memberIdx = GTH_GetEmptyMemberIdx( pi );
if( memberIdx < 0 ) return;
pi->memberNumber ++;
m->idx = memberIdx;
memcpy( &pi->member[memberIdx], m, sizeof( partyMember_t ) );
for( i = 0; i < MAX_NUMBER_OF_PARTY_MEMBER; i ++ )
{
if( pi->member[i].serverIndex == -1 ) continue;
if( !pi->member[i].isActive ) continue;
if( i == memberIdx ) continue;
if( pi->member[i].serverIndex == g_config.gameServerNo )
{
GTH_PartyInfo_Reply_Join( pi, pi->member[i].idxOnServer, false );
}
else
{
GTH_SendMessage_PartyInfo_Reply_Join( pi, pi->member[i].serverIndex, pi->member[i].idxOnServer, false );
}
}
if( pi->member[memberIdx].serverIndex == g_config.gameServerNo )
{
GTH_PartyInfo_Reply_Join( pi, pi->member[memberIdx].idxOnServer, true );
}
else
{
GTH_SendMessage_PartyInfo_Reply_Join( pi, pi->member[memberIdx].serverIndex, pi->member[memberIdx].idxOnServer, true );
}
}
}
void GTH_PartyInfo_Request_Join( playerCharacter_t *leader, playerCharacter_t *newMember )
{
partyMember_t m;
memset( &m, 0, sizeof( partyMember_t ) );
strcpy( m.memberName, newMember->name );
m.isActive = true;
m.isLeader = false;
m.level = newMember->level;
m.gen = newMember->pcClass;
m.serverIndex = g_config.gameServerNo;
m.idxOnServer = newMember->idx;
m.worldIdx = newMember->worldIdx;
GTH_SetServerPartyAckMessage( leader, ERROR_PARTY_2 );
GTH_SetServerPartyAckMessage( newMember, ERROR_PARTY_2 );
if ( g_config.isManager )
{
GTH_PartyInfo_Join( &m, leader->organizerName, leader->organizeServer, leader->organizeTime );
}
else
{
GTH_SendMessage_PartyInfo_Request_Join( &m, leader->organizerName, leader->organizeServer, leader->organizeTime );
}
}
void GTH_PartyInfo_Reply_Join( serverPartyInfo_t* pi, int currentMemberIdx, int isNewMember )
{
int i;
playerCharacter_t* pc;
pc = &g_pc[currentMemberIdx];
if( !isNewMember )
{
if( !GTH_GetCorrectMember( pi, pc ) ) return;
}
GTH_ClearServerPartyAckMessage( pc );
strcpy( pc->organizerName, pi->organizerName );
pc->organizeServer = pi->organizeServer;
pc->organizeTime = pi->organizeTime;
pc->memberNumber = pi->memberNumber;
pc->_partyRandomInfo_t.itemDivideType = pi->itemDivideType;
pc->canJoin = pi->canJoin;
pc->partyIndex = pi->idx;
for( i = 0; i < MAX_NUMBER_OF_PARTY_MEMBER; i ++ )
{
if( pi->member[i].serverIndex == -1 ) continue;
memcpy( &pc->member[i], &pi->member[i], sizeof( partyMember_t ) );
}
if( isNewMember ) GTH_SendMessage_Party_Admit_Join( pc, 1, 0, true );
else GTH_SendMessage_Party_Admit_Join( pc, 1, 0, false );
}
void GTH_PartyInfo_Out( int isForced, char* memberName, char* organizerName, int organizeServer, int organizeTime )
{
serverPartyInfo_t *pi;
int i;
int idx, reply = 1, memberIdx;
int nextLeaderIdx = -1;
idx = GTH_GetPartyInfo( organizerName, organizeServer, organizeTime );
if( idx < 0 )
{
reply = 0;
return;
}
pi = &g_partyInfo[idx];
memberIdx = GTH_FindMemberIdx( pi, memberName );
if( memberIdx < 0 )
{
reply = 0;
return;
}
if( pi->member[memberIdx].isLeader )
{
nextLeaderIdx = GTH_FindNextLeader( pi, memberIdx );
}
else
{
nextLeaderIdx = GTH_FindLeaderIdx( pi );
}
pi->memberNumber --;
if( pi->memberNumber < 2 || ( pi->member[memberIdx].isLeader && nextLeaderIdx < 0 ) )
{
GTH_PartyInfo_Disorganize( organizerName, organizeServer, organizeTime );
return;
}
for( i = 0; i < MAX_NUMBER_OF_PARTY_MEMBER; i ++ )
{
if( pi->member[i].serverIndex == -1 ) continue;
if( pi->member[i].idx == memberIdx ) continue;
if( !pi->member[i].isActive ) continue;
if( pi->member[i].serverIndex == g_config.gameServerNo )
{
GTH_PartyInfo_Reply_Out( isForced, &pi->member[i], memberIdx, nextLeaderIdx, false );
}
else
{
GTH_SendMessage_PartyInfo_Reply_Out( isForced, &pi->member[i], memberIdx, nextLeaderIdx, false );
}
}
if( pi->member[memberIdx].serverIndex == g_config.gameServerNo )
{
GTH_PartyInfo_Reply_Out( isForced, &pi->member[memberIdx], memberIdx, nextLeaderIdx, true );
}
else
{
GTH_SendMessage_PartyInfo_Reply_Out( isForced, &pi->member[memberIdx], memberIdx, nextLeaderIdx, true );
}
if( nextLeaderIdx >= 0 && pi->member[memberIdx].isLeader )
{
pi->member[nextLeaderIdx].isLeader = true;
}
memset( &pi->member[memberIdx], 0, sizeof( partyMember_t ) );
pi->member[memberIdx].serverIndex = -1;
}
void GTH_PartyInfo_Request_Out( playerCharacter_t *pc )
{
if ( g_config.isManager )
{
GTH_PartyInfo_Out( false, pc->name, pc->organizerName, pc->organizeServer, pc->organizeTime );
}
else
{
GTH_SendMessage_PartyInfo_Request_Out( false, pc->name, pc->organizerName, pc->organizeServer, pc->organizeTime );
}
}
void GTH_PartyInfo_Request_ForcedOut( playerCharacter_t* leader, char* memberName )
{
if ( g_config.isManager )
{
GTH_PartyInfo_Out( true, memberName, leader->organizerName, leader->organizeServer, leader->organizeTime );
}
else
{
GTH_SendMessage_PartyInfo_Request_Out( true, memberName, leader->organizerName, leader->organizeServer, leader->organizeTime );
}
}
void GTH_PartyInfo_Reply_Out( int isForced, partyMember_t *m, int reqMemberIdx, int newLeaderIdx, int reqFlag )
{
playerCharacter_t *pc;
int idx, i;
idx = m->idxOnServer;
if( idx < 0 ) return;
pc = &g_pc[idx];
if( stricmp( pc->name, m->memberName ) ) return;
if( !pc->active || !pc->ready ) return;
if( reqFlag )
{
memset( pc->organizerName, 0, sizeof( pc->organizerName ) );
pc->organizeTime = -1;
pc->organizeServer = -1;
pc->memberNumber = 0;
pc->partyIndex = -1;
for( i = 0; i < MAX_NUMBER_OF_PARTY_MEMBER; i ++ )
{
memset( &pc->member[i], 0, sizeof( partyMember_t ) );
pc->member[i].serverIndex = -1;
}
GTH_SendMessage_Party_Out( pc, 1, 0, isForced, reqMemberIdx, newLeaderIdx, reqFlag);
}
else
{
memset( &pc->member[reqMemberIdx], 0, sizeof( partyMember_t ) );
pc->member[reqMemberIdx].serverIndex = -1;
pc->memberNumber --;
if( newLeaderIdx >= 0 )
{
pc->member[newLeaderIdx].isLeader = true;
if( !stricmp( pc->name, pc->member[newLeaderIdx].memberName ) )
{
pc->isLeader = true;
}
}
GTH_SendMessage_Party_Out( pc, 1, 0, isForced, reqMemberIdx, newLeaderIdx, reqFlag);
}
}
void GTH_PartyInfo_Disorganize( char *organizerName, int organizeServer, int organizeTime )
{
serverPartyInfo_t *pi;
int i;
int idx;
idx = GTH_GetPartyInfo( organizerName, organizeServer, organizeTime );
if( idx < 0 || idx >= MAX_PARTY_NUMBER )
{
return;
}
pi = &g_partyInfo[idx];
for( i = 0; i < MAX_NUMBER_OF_PARTY_MEMBER; i ++ )
{
if( pi->member[i].serverIndex == -1 ) continue;
if( !pi->member[i].isActive ) continue;
if( pi->member[i].serverIndex == g_config.gameServerNo )
{
GTH_PartyInfo_Reply_Disorganize( &pi->member[i] );
}
else
{
GTH_SendMessage_PartyInfo_Reply_Disorganize( &pi->member[i] );
}
}
GTH_InitPartyInfo( pi );
}
void GTH_PartyInfo_Request_Disorganize( playerCharacter_t *pc )
{
if( !pc->isLeader ) return;
if( g_config.isManager )
{
GTH_PartyInfo_Disorganize( pc->organizerName, pc->organizeServer, pc->organizeTime );
}
else
{
GTH_SendMessage_PartyInfo_Request_Disorganize( pc->organizerName, pc->organizeServer, pc->organizeTime );
}
}
void GTH_PartyInfo_Reply_Disorganize( partyMember_t *m )
{
playerCharacter_t *pc;
int idx, i;
idx = m->idxOnServer;
if( idx < 0 ) return;
pc = &g_pc[idx];
if( stricmp( pc->name, m->memberName ) ) return;
if( !pc->active || !pc->ready ) return;
memset( pc->organizerName, 0, sizeof( pc->organizerName ) );
pc->organizeTime = -1;
pc->organizeServer = -1;
pc->memberNumber = 0;
pc->partyIndex = -1;
for( i = 0; i < MAX_NUMBER_OF_PARTY_MEMBER; i ++ )
{
memset( &pc->member[i], 0, sizeof( partyMember_t ) );
pc->member[i].serverIndex = -1;
}
GTH_SendMessage_Party_Disorganize( pc );
}
void GTH_PartyInfo_SendAll( int serverIdx, int pcIdx, char* organizerName, int organizeServer, int organizeTime )
{
serverPartyInfo_t *pi = NULL;
int idx, reply = 1;
idx = GTH_GetPartyInfo( organizerName, organizeServer, organizeTime );
if( idx < 0 )
{
reply = 0;
}
else
{
pi = &g_partyInfo[idx];
}
if( serverIdx == g_config.gameServerNo )
{
GTH_PartyInfo_Reply_SendAll( reply, pcIdx, pi );
}
else
{
GTH_SendMessage_PartyInfo_Reply_SendAll( reply, serverIdx, pcIdx, pi );
}
}
void GTH_PartyInfo_Request_SendAll( playerCharacter_t *pc )
{
if ( g_config.isManager )
{
GTH_PartyInfo_SendAll( g_config.gameServerNo, pc->idx, pc->organizerName, pc->organizeServer, pc->organizeTime );
}
else
{
GTH_SendMessage_PartyInfo_Request_SendAll( pc );
}
}
void GTH_PartyInfo_Reply_SendAll( int reply, int pcIdx, serverPartyInfo_t *pi )
{
playerCharacter_t *pc;
int i;
pc = &g_pc[pcIdx];
if( reply )
{
for( i = 0; i < MAX_NUMBER_OF_PARTY_MEMBER; i ++ )
{
if( pi->member[i].serverIndex < 0 ) continue;
if( !stricmp( pi->member[i].memberName, pc->name ) ) break;
}
if( i == MAX_NUMBER_OF_PARTY_MEMBER )
{
memset( pc->organizerName, 0, sizeof( pc->organizerName ) );
pc->organizeServer = -1;
pc->organizeTime = 0;
GTH_SendMessage_Party_SendAll( pc, false );
}
else
{
pc->memberNumber = pi->memberNumber;
pc->_partyRandomInfo_t.itemDivideType = pi->itemDivideType;
pc->canJoin = pi->canJoin;
pc->partyIndex = pi->idx;
for( i = 0; i < MAX_NUMBER_OF_PARTY_MEMBER; i ++ )
{
if( pi->member[i].serverIndex == -1 ) continue;
memcpy( &pc->member[i], &pi->member[i], sizeof( partyMember_t ) );
if( !stricmp( pc->member[i].memberName, pc->name ) )
{
if( pc->member[i].isLeader ) pc->isLeader = true;
}
}
GTH_SendMessage_Party_SendAll( pc, true );
}
}
else
{
memset( pc->organizerName, 0, sizeof( pc->organizerName ) );
pc->organizeServer = -1;
pc->organizeTime = 0;
GTH_SendMessage_Party_SendAll( pc, false );
}
if( pc->organizeServer >= 0 && pc->isLeader )
{
GTH_PartyInfo_Request_Holding( pc, 0 );
}
}
void GTH_PartyInfo_Update( char* memberName, int active, int serverIdx, int pcIdx, int level, int worldIdx, char* organizerName, int organizeServer, int organizeTime )
{
serverPartyInfo_t *pi;
int i;
int idx, memberIdx, memberNumber;
int nextLeaderIdx = 0;
idx = GTH_GetPartyInfo( organizerName, organizeServer, organizeTime );
if( idx < 0 )
{
return;
}
pi = &g_partyInfo[idx];
memberIdx = GTH_FindMemberIdx( pi, memberName );
if( memberIdx < 0 )
{
return;
}
if( !active )
{
if( pi->member[memberIdx].isLeader )
{
pi->member[memberIdx].isLeader = false;
nextLeaderIdx = GTH_FindNextLeader( pi, memberIdx );
if( nextLeaderIdx >= 0 )
pi->member[nextLeaderIdx].isLeader = true;
}
else
{
nextLeaderIdx = GTH_FindLeaderIdx( pi );
if( nextLeaderIdx < 0 ) return;
}
memberNumber = GTH_GetActiveMemberNumber( pi, memberIdx );
if( memberNumber == 0 )
{
GTH_PartyInfo_Disorganize( organizerName, organizeServer, organizeTime );
return;
}
}
pi->member[memberIdx].level = level;
pi->member[memberIdx].isActive = active;
pi->member[memberIdx].serverIndex = serverIdx;
pi->member[memberIdx].idxOnServer = pcIdx;
pi->member[memberIdx].worldIdx = worldIdx;
for( i = 0; i < MAX_NUMBER_OF_PARTY_MEMBER; i ++ )
{
if( pi->member[i].serverIndex == -1 ) continue;
if( !pi->member[i].isActive ) continue;
if( pi->member[i].idx == memberIdx ) continue;
if( pi->member[i].serverIndex == g_config.gameServerNo )
{
GTH_PartyInfo_Reply_Update( &pi->member[i], memberIdx, nextLeaderIdx, active, serverIdx, pcIdx, level, pi->member[memberIdx].worldIdx );
}
else
{
GTH_SendMessage_PartyInfo_Reply_Update( &pi->member[i], memberIdx, nextLeaderIdx, active, serverIdx, pcIdx, level, pi->member[memberIdx].worldIdx );
}
}
}
void GTH_PartyInfo_Request_Update( playerCharacter_t *pc, int active)
{
if( pc->organizeServer == -1 ) return;
if ( g_config.isManager )
{
GTH_PartyInfo_Update( pc->name, active, g_config.gameServerNo, pc->idx, pc->level, pc->worldIdx, pc->organizerName, pc->organizeServer, pc->organizeTime );
}
else
{
GTH_SendMessage_PartyInfo_Request_Update( pc->name, active, g_config.gameServerNo, pc->idx, pc->level, pc->worldIdx, pc->organizerName, pc->organizeServer, pc->organizeTime );
}
}
void GTH_PartyInfo_Reply_Update(
partyMember_t *m,
int memberIdx,
int nextLeaderIdx,
int in_nActive,
int serverIdx,
int pcIdx,
int level,
int worldIdx )
{
if(memberIdx < 0) return;
if(memberIdx >= MAX_NUMBER_OF_PARTY_MEMBER) return;
if(nextLeaderIdx < 0) return;
if(nextLeaderIdx >= MAX_NUMBER_OF_PARTY_MEMBER) return;
playerCharacter_t* pPlayer=NULL;
pPlayer = gcpTools->GetPlayerRecordPointer(m->idxOnServer);
if(NULL == pPlayer) return;
if(!pPlayer->ready ) return;
if(0 != stricmp( pPlayer->name, m->memberName ) ) return;
partyMember_t* pPartyMember = &pPlayer->member[memberIdx];
pPartyMember->isActive = in_nActive;
pPartyMember->level = level;
pPartyMember->idxOnServer = pcIdx;
pPartyMember->serverIndex = serverIdx;
pPartyMember->worldIdx = worldIdx;
if( !in_nActive ){
pPartyMember->isLeader = false;
}
pPlayer->member[nextLeaderIdx].isLeader = true;
if(0 == stricmp( pPlayer->name, pPlayer->member[nextLeaderIdx].memberName ) )
{
pPlayer->isLeader = true;
}
GTH_SendMessage_Party_Update( pPlayer, memberIdx, nextLeaderIdx, in_nActive, pcIdx, level, worldIdx );
}
void GTH_PartyInfo_Request_ItemDivideType( playerCharacter_t *pc, int type )
{
if( pc->organizeServer == -1 ) return;
if ( g_config.isManager )
{
GTH_PartyInfo_ItemDivideType( pc->organizerName, pc->organizeServer, pc->organizeTime, type );
}
else
{
GTH_SendMessage_PartyInfo_Request_ItemDivideType( pc->organizerName, pc->organizeServer, pc->organizeTime, type );
}
}
void GTH_PartyInfo_ItemDivideType( char* organizerName, int organizeServer, int organizeTime, int type )
{
serverPartyInfo_t *pi;
int i;
int idx;
int nextLeaderIdx = 0;
idx = GTH_GetPartyInfo( organizerName, organizeServer, organizeTime );
if( idx < 0 )
{
return;
}
pi = &g_partyInfo[idx];
pi->itemDivideType = type;
for( i = 0; i < MAX_NUMBER_OF_PARTY_MEMBER; i ++ )
{
if( pi->member[i].serverIndex == -1 ) continue;
if( !pi->member[i].isActive ) continue;
if( pi->member[i].serverIndex == g_config.gameServerNo )
{
GTH_PartyInfo_Reply_ItemDivideType( &pi->member[i], type );
}
else
{
GTH_SendMessage_PartyInfo_Reply_ItemDivideType( &pi->member[i], type );
}
}
}
void GTH_PartyInfo_Reply_ItemDivideType( partyMember_t *m, int type )
{
playerCharacter_t *pc;
int idx;
idx = m->idxOnServer;
if( idx < 0 ) return;
pc = &g_pc[idx];
if( stricmp( pc->name, m->memberName ) ) return;
if( !pc->active || !pc->ready ) return;
}
void GTH_PartyInfo_Request_Holding( playerCharacter_t *pc, int holdingFlag )
{
if( g_config.isManager )
{
GTH_PartyInfo_Holding( pc->organizerName, pc->organizeServer, pc->organizeTime, holdingFlag );
}
else
{
GTH_SendMessage_PartyInfo_Request_Holding( pc->organizerName, pc->organizeServer, pc->organizeTime, holdingFlag );
}
}
void GTH_PartyInfo_Holding( char* organizerName, int organizeServer, int organizeTime, int holdingFlag )
{
serverPartyInfo_t *pi;
int i;
int idx;
int leaderIdx, nextLeaderIdx = 0, memberNumber;
int level, pcIdx, serverIdx;
idx = GTH_GetPartyInfo( organizerName, organizeServer, organizeTime );
if( idx < 0 ) return;
pi = &g_partyInfo[idx];
pi->isHolding = holdingFlag;
pi->holdingCheckTime = g_globalTime;
if( pi->isHolding != 2 ) return;
pi->isHolding = 0;
leaderIdx = GTH_FindLeaderIdx( pi );
pi->member[leaderIdx].isLeader = false;
nextLeaderIdx = GTH_FindNextLeader( pi, leaderIdx );
if( nextLeaderIdx >= 0 )
{
pi->member[nextLeaderIdx].isLeader = true;
}
memberNumber = GTH_GetActiveMemberNumber( pi, leaderIdx );
if( memberNumber == 0 )
{
GTH_PartyInfo_Disorganize( pi->organizerName, pi->organizeServer, pi->organizeTime );
return;
}
level = pi->member[leaderIdx].level;
pi->member[leaderIdx].isActive = false;
pcIdx = pi->member[leaderIdx].idxOnServer;
serverIdx = pi->member[leaderIdx].serverIndex;
for( i = 0; i < MAX_NUMBER_OF_PARTY_MEMBER; i ++ )
{
if( pi->member[i].serverIndex == -1 ) continue;
if( !pi->member[i].isActive ) continue;
if( pi->member[i].idx == leaderIdx ) continue;
if( pi->member[i].serverIndex == g_config.gameServerNo )
{
GTH_PartyInfo_Reply_Update( &pi->member[i], leaderIdx, nextLeaderIdx, false, serverIdx, pcIdx, level, pi->member[leaderIdx].worldIdx );
}
else
{
GTH_SendMessage_PartyInfo_Reply_Update( &pi->member[i], leaderIdx, nextLeaderIdx, false, serverIdx, pcIdx, level, pi->member[leaderIdx].worldIdx );
}
}
}
void GTH_PartyInfo_CheckHolding()
{
int i;
if( g_globalTime - g_partyTime > PARTY_HOLDING_CHECK_TIME )
{
g_partyTime = g_globalTime;
}
else
{
return;
}
for( i = 0; i < MAX_PARTY_NUMBER; i ++ )
{
if( g_partyInfo[i].idx < 0 ) continue;
if( g_partyInfo[i].isHolding != 1 ) continue;
if( g_globalTime - g_partyInfo[i].holdingCheckTime > PARTY_HOLDING_DELAY_TIME )
{
GTH_PartyInfo_Holding( g_partyInfo[i].organizerName, g_partyInfo[i].organizeServer, g_partyInfo[i].organizeTime, 2 );
}
}
}
void GTH_PartyInfo_Request_ChatMessage( playerCharacter_t *pc, char* message )
{
if( g_config.isManager )
{
GTH_PartyInfo_ChatMessage( pc->name, pc->organizerName, pc->organizeServer, pc->organizeTime, message );
}
else
{
GTH_SendMessage_PartyInfo_Request_ChatMessage( pc->name, pc->organizerName, pc->organizeServer, pc->organizeTime, message );
}
}
void GTH_PartyInfo_ChatMessage( char *fromName, char* organizerName, int organizeServer, int organizeTime, char* message )
{
serverPartyInfo_t *pi;
int i;
int idx;
int nextLeaderIdx = 0;
idx = GTH_GetPartyInfo( organizerName, organizeServer, organizeTime );
if( idx < 0 )
{
return;
}
pi = &g_partyInfo[idx];
for( i = 0; i < MAX_NUMBER_OF_PARTY_MEMBER; i ++ )
{
if( pi->member[i].serverIndex == -1 ) continue;
if( !pi->member[i].isActive ) continue;
if( pi->member[i].idxOnServer < 0 || pi->member[i].idxOnServer >= MAX_PCS ) continue;
if( !stricmp( pi->member[i].memberName, fromName ) ) continue;
if( pi->member[i].serverIndex == g_config.gameServerNo )
{
GTH_PartyInfo_Reply_ChatMessage( &pi->member[i], fromName, message );
}
else
{
GTH_SendMessage_PartyInfo_Reply_ChatMessage( &pi->member[i], fromName, message );
}
}
}
void GTH_PartyInfo_Reply_ChatMessage( partyMember_t *m, char* fromName, char* message )
{
playerCharacter_t *pc;
int idx;
idx = m->idxOnServer;
if( idx < 0 ) return;
pc = &g_pc[idx];
if( stricmp( pc->name, m->memberName ) ) return;
if( !pc->active || !pc->ready ) return;
GTH_SendMessage_Party_ChatMessage( pc, fromName, message );
}
| C++ |
#include "../global.h"
CItemTableData gItemTableData;
CItemTableData::CItemTableData()
{
}
CItemTableData::~CItemTableData()
{
}
float CItemTableData::GetData(const int _ItemTableIndex ,const int _Type)
{
if(_ItemTableIndex < 0 && _ItemTableIndex >= MAX_NUMBER_OF_ITEM_TABLE)
{
return 0.0f;
}
itemTable_t * pItemTable = &g_itemTable[_ItemTableIndex];
for(int i=0;i<itemTable_t::MAX_ITEM_TABLE_FLOAT_DATA;i++)
{
if(0 == pItemTable->iFluxDataIndex[i]) break;
if(pItemTable->iFluxDataIndex[i] == _Type)
{
return pItemTable->fFluxData[i];
}
}
return 0.0f;
}
float CItemTableData::GetData(const itemTable_t *_pItemTable,const int _Type)
{
for(int i=0;i<itemTable_t::MAX_ITEM_TABLE_FLOAT_DATA;i++)
{
if(0 == _pItemTable->iFluxDataIndex[i]) break;
if(_pItemTable->iFluxDataIndex[i] == _Type)
{
return _pItemTable->fFluxData[i];
}
}
return 0.0f;
}
bool CItemTableData::IsType(const itemTable_t *_pItemTable,const int _Type)
{
for(int i=0;i<itemTable_t::MAX_ITEM_TABLE_FLOAT_DATA;i++)
{
if(0 == _pItemTable->iFluxDataIndex[i]) break;
if(_pItemTable->iFluxDataIndex[i] == _Type)
{
return true;
}
}
return false;
}
int CItemTableData::GetUseItemType(const itemTable_t *_pItemTable)
{
for(int i=0;i<itemTable_t::MAX_ITEM_TABLE_FLOAT_DATA;i++)
{
if(0 == _pItemTable->iFluxDataIndex[i]) break;
if(0 < _pItemTable->iFluxDataIndex[i] && 100 > _pItemTable->iFluxDataIndex[i])
{
return _pItemTable->iFluxDataIndex[i];
}
}
return -1;
}
| C++ |
#if !defined(AFX_WEATHERSYSTEM_H__43CEA2FD_9BE8_474B_9CF2_AF26C54FBCDF__INCLUDED_)
#define AFX_WEATHERSYSTEM_H__43CEA2FD_9BE8_474B_9CF2_AF26C54FBCDF__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CWeatherSystem
{
public:
enum enumWeatherSystemProtocol
{
CC_WEATHER_SYSTEM_REQUEST_USE_WEATHER_ITEM,
GSC_WEATHER_SYSTEM_REPLY_USE_WEATHER_ITEM,
GSC_WEATHER_SYSTEM_REPLY_CURRENT_WEATHER,
CC_WEATHER_SYSTEM_REQUEST_WORLD_STATE,
GSC_WEATHER_SYSTEM_REQUEST_WORLD_STATE,
CC_WEATHER_SYSTEM_CHEAT_SETING,
CC_WEATHER_SYSTEM_NOTICE,
CC_WEATHER_SYSTEM_CASTING_EVENT_SETING,
};
enum enumEventWorldState
{
WEATHER_SYSTEM_WORLD_PROGRESS,
WEATHER_SYSTEM_WORLD_NONE
};
enum enumWeatherSystemEventState
{
EVENT_INACTIVE,
EVENT_ACTIVE
};
enum enumWeatherSystemEventError
{
ERROR_WEATHER_SYSTEM_USE_ITEM,
ERROR_WEATHER_SYSTEM_USE_ITEM2,
ERROR_WEATHER_SYSTEM_EQUIP_ITEM,
ERROR_WEATHER_SYSTEM_ACTIVE,
};
public:
enum TIMESTATE
{
TIME_DAY = 0,
TIME_DAWN = 1,
TIME_DUSK = 2,
TIME_NIGHT = 3,
TIME_FOG = 4,
TIME_RAIN = 5,
TIME_SNOW = 6,
};
struct EventWorld
{
int m_WorldIdx;
float m_EventLimitTime;
enumEventWorldState m_EventState;
TIMESTATE m_WeatherType;
}m_EventWorld[MAX_WORLDS];
enumWeatherSystemEventState m_EventState;
public:
void GTH_Process_Weather_System();
void GTH_ProcessMessage_WeatherSetting(void);
void GTH_SendMessage_Reply_WeatherSystem_UseItem(playerCharacter_t*, int reply, int error, int invenpos);
void GTH_SendMessage_BroadCast_WeatherSystemEvent(playerCharacter_t*, int worldidx);
void GTH_ProcessMessage_Request_WordlState();
void GTH_SendMessage_Reply_WordlState(playerCharacter_t*, int reply, int state);
void GTH_SendMessage_Reply_WordlStateToMemberServer(int state);
void GTH_SendMessage_Reply_WordlStateToManagerServer(int state);
void GTH_ProcessMessageBroadCastEventSeting();
void GTH_ProcessMessageEventSeting();
void GTH_ProcessMessage_Event_UserNotice();
public:
void ProcessEventTIme();
void InitWeatherSystem();
public:
CWeatherSystem();
virtual ~CWeatherSystem();
};
#endif
| C++ |
#include "../Global.h"
void GTH_ItemExtendSystemDecode()
{
SHORT Packet = static_cast<enum enumGambleSystem>(MSG_ReadShort());
switch(Packet)
{
case REQUEST_ITEM_SYNC_TIME:
GTH_ProcessMessageRequestItemSyncTIme();
break;
case REQUEST_ITEM_TIME_SET:
GTH_ProcessMessageRequestItemTimeSet();
break;
}
}
void GTH_ProcessMessageRequestItemSyncTIme()
{
GTH_CollectItemItem(g_curPC);
GTH_SendMessage_ItemSyncTime(g_curPC);
g_curPC->m_ItemExtendInfo.fItemInfoRequestTime =
g_timer->GetAppMilliTime() + sItemUseTimeInfo::enumItemSyncInfo::ITEM_USETIME_SYNC_TERM;
}
void GTH_ItemUseTimeProcess(playerCharacter_t* pPc)
{
if ( pPc == NULL )
return;
for (int iItemIdx = 0; iItemIdx < MAX_NUMBER_OF_OWNITEM; iItemIdx++)
{
item_t *pItem = &pPc->item[iItemIdx];
int *pItemUseTime = NULL;
if ( IsItemUseFlag( pItem, item_t::sItemExtendInfo::enumItemUseFlag::ITEM_USE_FLAG_USE_TIME) )
pItemUseTime = &pItem->ItemExtendInfo.AllowUseTime;
if ( IsItemUseFlag( pItem, item_t::sItemExtendInfo::enumItemUseFlag::ITEM_USE_FLAG_USE_DATE) )
{
time_t NowTime = time(NULL);
pItem->ItemExtendInfo.CalclateUseDateToSec =
difftime((time_t)pItem->ItemExtendInfo.AllowUseDate, NowTime);
pItemUseTime = &pItem->ItemExtendInfo.AllowUseDate;
}
if ( NULL == pItemUseTime)
continue;
if ( (*pItemUseTime) < 0)
continue;
if ( IsItemUseFlag( pItem, item_t::sItemExtendInfo::enumItemUseFlag::ITEM_USE_FLAG_USE_TIME) )
(*pItemUseTime) --;
}
}
void GTH_SendMessage_ItemSyncTime(playerCharacter_t* pPc)
{
int MaxSize = pPc->m_ItemExtendInfo.v_UseTimeItemInfo.size();
if ( MaxSize <= 0 )
return;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, ITEM_EXTEND_SYSTEM);
MSG_WriteShort(&netMessage, REPLY_ITEM_SYNC_TIME);
MSG_WriteLong(&netMessage, MaxSize);
for (int nSendIdx =0; nSendIdx < MaxSize; nSendIdx ++)
{
int ItemIdx = pPc->m_ItemExtendInfo.v_UseTimeItemInfo[nSendIdx];
if ( ItemIdx >= 0 || ItemIdx < MAX_NUMBER_OF_OWNITEM )
{
MSG_WriteLong(&netMessage, ItemIdx);
MSG_WriteItem(&netMessage, &pPc->item[ItemIdx]);
}
}
NET_SendMessage(&pPc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ItemTimeSet(playerCharacter_t* pPc, int Reply, int iItemIdx , int ErrorIdx ,
item_t *pReplaceItem , enum sItemUseTimeInfo::enumInventoryType type , int InvenIdx)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, ITEM_EXTEND_SYSTEM);
MSG_WriteShort(&netMessage, REPLY_ITEM_TIME_SET);
MSG_WriteLong(&netMessage, Reply);
if ( Reply == TRUE)
{
MSG_WriteItem(&netMessage, pReplaceItem);
MSG_WriteLong(&netMessage, (int)type);
MSG_WriteLong(&netMessage, iItemIdx);
MSG_WriteLong(&netMessage, InvenIdx);
}
else
MSG_WriteLong(&netMessage, ErrorIdx);
NET_SendMessage(&pPc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
#include "../CTools.h"
extern CTools* gcpTools;
void GTH_ProcessMessageRequestItemTimeSet()
{
int iItemIdx = -1;
int iInvenIdx = -1;
enum sItemUseTimeInfo::enumInventoryType invenType;
invenType = static_cast<enum sItemUseTimeInfo::enumInventoryType>(MSG_ReadLong());
iItemIdx = MSG_ReadLong();
iInvenIdx = MSG_ReadLong();
if ( iItemIdx < 0 || iItemIdx >= MAX_NUMBER_OF_OWNITEM)
{
GTH_SendMessage_ItemTimeSet(g_curPC, 0, 0, sItemUseTimeInfo::enumItemExptendError::ITEM_EXTEND_ERROR1);
return;
}
if ( IsInvalideItem_FromInvenType(g_curPC, invenType, iInvenIdx, iItemIdx) == FALSE )
{
GTH_SendMessage_ItemTimeSet(g_curPC, 0, 0, sItemUseTimeInfo::enumItemExptendError::ITEM_EXTEND_ERROR2);
return;
}
item_t Replaceitem;
InitItem( &Replaceitem );
if ( FALSE == SpawnItem(&Replaceitem, sItemUseTimeInfo::enumItemSyncInfo::ITEM_TIMESET_REPLACE_ITEMTABLEIDX))
{
GTH_SendMessage_ItemTimeSet(g_curPC, 0, 0, sItemUseTimeInfo::enumItemExptendError::ITEM_EXTEND_ERROR3);
return;
}
GTH_DeleteMyItem(g_curPC, &g_curPC->item[iItemIdx] );
g_DBGameServer->RemoveItem(g_curPC, iItemIdx);
if ( invenType == sItemUseTimeInfo::enumInventoryType::ITEM_EQUIP)
{
GTH_ReplaceItem(g_curPC, invenType, iInvenIdx, -1);
int Result = gcpTools->AddItem( g_curPC, Replaceitem );
switch(Result)
{
case -1:
GTH_SendMessage_ItemTimeSet( g_curPC, 0, 0, sItemUseTimeInfo::enumItemExptendError::ITEM_EXTEND_ERROR3 );
return;
break;
case 1:
case 2:
GTH_SendMessage_ItemTimeSet(g_curPC, 1, iItemIdx, -1, &Replaceitem, invenType, iInvenIdx );
return;
break;
}
}
int RegItemIdx = GTH_AddMyItem(g_curPC, &Replaceitem);
if ( RegItemIdx < 0)
{
GTH_SendMessage_ItemTimeSet(g_curPC, 0, 0, sItemUseTimeInfo::enumItemExptendError::ITEM_EXTEND_ERROR3);
return;
}
g_DBGameServer->AddItem(g_curPC, &Replaceitem, RegItemIdx, "REPLACEMENT");
GTH_ReplaceItem(g_curPC, invenType, iInvenIdx, RegItemIdx);
GTH_SendMessage_ItemTimeSet(g_curPC, 1, iItemIdx, -1, &Replaceitem, invenType, iInvenIdx );
return;
}
BOOL IsInvalideItem_FromInvenType(playerCharacter_t* pPc, int InvenType, int iInvenPos, int ItemIdx)
{
switch(InvenType)
{
case sItemUseTimeInfo::enumInventoryType::ITEM_INVEN :
{
if ( iInvenPos < 0 || iInvenPos >= MAX_INVENTORY_SIZE)
return FALSE;
if ( pPc->inventory[iInvenPos] < 0 ||
pPc->inventory[iInvenPos] >= MAX_NUMBER_OF_OWNITEM )
return FALSE;
if ( pPc->inventory[iInvenPos] != ItemIdx)
return FALSE;
}break;
case sItemUseTimeInfo::enumInventoryType::ITEM_UPGRADE:
{
if ( iInvenPos < 0 || iInvenPos >= MAX_UPGRADE_SOURCE_ITEM_SIZE)
return FALSE;
if ( pPc->upgradeSourceInventory[iInvenPos] < 0 ||
pPc->upgradeSourceInventory[iInvenPos] >= MAX_NUMBER_OF_OWNITEM )
return FALSE;
if ( pPc->upgradeSourceInventory[iInvenPos] != ItemIdx)
return FALSE;
}break;
case sItemUseTimeInfo::enumInventoryType::ITEM_EQUIP:
{
if ( iInvenPos < 0 || iInvenPos >= MAX_EQUIPMENT)
return FALSE;
if ( pPc->equipment[iInvenPos] < 0 ||
pPc->equipment[iInvenPos] >= MAX_NUMBER_OF_OWNITEM )
return FALSE;
if ( pPc->equipment[iInvenPos] != ItemIdx)
return FALSE;
}
break;
case sItemUseTimeInfo::enumInventoryType::ITEM_GB_BATTING:
{
if ( iInvenPos < 0 || iInvenPos >= playerCharacter_t::tagGonryunBattlePractice::MAX_GBP_INVENTORY_SIZE)
return FALSE;
if ( pPc->GonryunBattlePractice.Inventory[iInvenPos] < 0 ||
pPc->GonryunBattlePractice.Inventory[iInvenPos] >= MAX_NUMBER_OF_OWNITEM )
return FALSE;
if ( pPc->GonryunBattlePractice.Inventory[iInvenPos] != ItemIdx)
return FALSE;
}break;
case sItemUseTimeInfo::enumInventoryType::ITEM_PRECOCITY:
{
if ( iInvenPos < 0 || iInvenPos >= MAX_PRECOCITY_SIZE)
return FALSE;
if ( pPc->precocityInventory[iInvenPos] < 0 ||
pPc->precocityInventory[iInvenPos] >= MAX_NUMBER_OF_OWNITEM )
return FALSE;
if ( pPc->precocityInventory[iInvenPos] != ItemIdx)
return FALSE;
}break;
case sItemUseTimeInfo::enumInventoryType::ITEM_CRAFT:
{
if ( iInvenPos < 0 || iInvenPos >= MAX_CRAFT_SOURCE_ITEM_SIZE)
return FALSE;
if ( pPc->craftSourceInventory[iInvenPos] < 0 ||
pPc->craftSourceInventory[iInvenPos] >= MAX_NUMBER_OF_OWNITEM )
return FALSE;
if ( pPc->craftSourceInventory[iInvenPos] != ItemIdx)
return FALSE;
}break;
case sItemUseTimeInfo::enumInventoryType::ITEM_DEPOT:
{
if ( iInvenPos < 0 || iInvenPos >= MAX_DEPOT_SIZE)
return FALSE;
if ( pPc->depot[iInvenPos] < 0 ||
pPc->depot[iInvenPos] >= MAX_NUMBER_OF_OWNITEM )
return FALSE;
if ( pPc->depot[iInvenPos] != ItemIdx)
return FALSE;
}break;
case sItemUseTimeInfo::enumInventoryType::ITEM_BOOTHINVENTORY:
{
if ( iInvenPos < 0 || iInvenPos >= MAX_BOOTH_INVENTORY_SIZE)
return FALSE;
if ( pPc->boothInventory[iInvenPos].itemIdx < 0 ||
pPc->boothInventory[iInvenPos].itemIdx >= MAX_NUMBER_OF_OWNITEM)
return FALSE;
if ( pPc->boothInventory[iInvenPos].itemIdx != ItemIdx)
return FALSE;
}break;
case sItemUseTimeInfo::enumInventoryType::ITEM_MOUSEIN:
if ( pPc->mouseInventory != ItemIdx)
return FALSE;
break;
}
return TRUE;
}
void GTH_ProcessItemSync(playerCharacter_t *pPc)
{
if ( pPc->m_ItemExtendInfo.fItemInfoRequestTime >= g_timer->GetAppMilliTime() )
return;
GTH_CollectItemItem(pPc);
GTH_SendMessage_ItemSyncTime(pPc);
pPc->m_ItemExtendInfo.fItemInfoRequestTime =
g_timer->GetAppMilliTime() + sItemUseTimeInfo::enumItemSyncInfo::ITEM_USETIME_SYNC_TERM;
}
void GTH_CollectItemItem(playerCharacter_t *pPc)
{
pPc->m_ItemExtendInfo.v_UseTimeItemInfo.clear();
for (int iItemIdx = 0; iItemIdx < MAX_NUMBER_OF_OWNITEM; iItemIdx++)
{
item_t *pItem = &pPc->item[iItemIdx];
if ( IsItemUseFlag( pItem, item_t::sItemExtendInfo::enumItemUseFlag::ITEM_USE_FLAG_USE_TIME) ||
IsItemUseFlag( pItem, item_t::sItemExtendInfo::enumItemUseFlag::ITEM_USE_FLAG_USE_DATE))
{
pPc->m_ItemExtendInfo.v_UseTimeItemInfo.push_back(iItemIdx);
}
}
}
void GTH_DBSaveItemForTimeType(playerCharacter_t *pPc)
{
if ( NULL == pPc )
return ;
int MaxSize = pPc->m_ItemExtendInfo.v_UseTimeItemInfo.size();
for (int nSaveIdx = 0 ;nSaveIdx < MaxSize ; nSaveIdx ++)
{
int ItemIdx = pPc->m_ItemExtendInfo.v_UseTimeItemInfo[nSaveIdx];
if ( ItemIdx >= 0 || ItemIdx < MAX_NUMBER_OF_OWNITEM)
{
item_t *pITem = &pPc->item[ItemIdx];
g_DBGameServer->SaveItem(pPc, pITem, ItemIdx);
}
}
}
BOOL GTH_ReplaceItem(playerCharacter_t *pPc, enum sItemUseTimeInfo::enumInventoryType type, int iInvenPos, int NewItemIdx)
{
switch (type)
{
case sItemUseTimeInfo::enumInventoryType::ITEM_INVEN:
{
if ( iInvenPos < 0 || iInvenPos >= MAX_INVENTORY_SIZE)
return FALSE;
pPc->inventory[iInvenPos] = NewItemIdx;
}
break;
case sItemUseTimeInfo::enumInventoryType::ITEM_UPGRADE:
{
if ( iInvenPos < 0 || iInvenPos >= MAX_UPGRADE_SOURCE_ITEM_SIZE)
return FALSE;
pPc->upgradeSourceInventory[iInvenPos] = NewItemIdx;
}
break;
case sItemUseTimeInfo::enumInventoryType::ITEM_EQUIP:
{
if ( iInvenPos < 0 || iInvenPos >= MAX_EQUIPMENT)
return FALSE;
pPc->equipment[iInvenPos] = NewItemIdx;
}
break;
case sItemUseTimeInfo::enumInventoryType::ITEM_GB_BATTING:
{
if ( iInvenPos < 0 || iInvenPos >=
playerCharacter_t::tagGonryunBattlePractice::MAX_GBP_INVENTORY_SIZE)
return FALSE;
pPc->GonryunBattlePractice.Inventory[iInvenPos] = NewItemIdx;
}
break;
case sItemUseTimeInfo::enumInventoryType::ITEM_PRECOCITY:
{
if ( iInvenPos < 0 || iInvenPos >= MAX_PRECOCITY_SIZE)
return FALSE;
pPc->precocityInventory[iInvenPos] = NewItemIdx;
}
break;
case sItemUseTimeInfo::enumInventoryType::ITEM_CRAFT:
{
if ( iInvenPos < 0 || iInvenPos >= MAX_CRAFT_SOURCE_ITEM_SIZE)
return FALSE;
pPc->craftSourceInventory[iInvenPos] = NewItemIdx;
}
break;
case sItemUseTimeInfo::enumInventoryType::ITEM_DEPOT:
{
if ( iInvenPos < 0 || iInvenPos >= MAX_DEPOT_SIZE)
return FALSE;
pPc->depot[iInvenPos] = NewItemIdx;
}
break;
case sItemUseTimeInfo::enumInventoryType::ITEM_BOOTHINVENTORY:
{
if ( iInvenPos < 0 || iInvenPos >= MAX_BOOTH_INVENTORY_SIZE)
return FALSE;
pPc->boothInventory[iInvenPos].itemIdx = NewItemIdx;
}
break;
case sItemUseTimeInfo::enumInventoryType::ITEM_MOUSEIN:
if ( pPc->mouseInventory = NewItemIdx)
return FALSE;
break;
}
return TRUE;
} | C++ |
#include "../global.h"
extern bool IsGuildMasters( playerCharacter_t *pc );
BOOL InitDanBattleManager()
{
if ( g_pDanBattleManager != NULL )
return FALSE;
g_pDanBattleManager = new CDanBattleManager;
if ( g_pDanBattleManager == NULL )
return FALSE;
if ( !g_pDanBattleManager->InitManager() )
return FALSE;
g_pDanBattleManager->SetStatus( DBTL_STATUS_STARTUP );
return TRUE;
}
BOOL InitDanBattleSystem()
{
if ( g_pDanBattleSys != NULL )
return FALSE;
g_pDanBattleSys = new CDanBattleSys;
if ( g_pDanBattleSys == NULL )
return FALSE;
return TRUE;
}
void GTH_ProcessDanBattleSys()
{
if ( g_config.isManager )
{
g_pDanBattleManager->Update();
}
if ( g_config.isDanBattleMap )
{
g_pDanBattleSys->Update();
}
}
BOOL CDanBattleManager::InitManager()
{
int i;
LPBATTLE_RECORD pBattle;
for (i=0;i<SZ_BATTLE_CACHE;i++)
{
pBattle = new BATTLE_RECORD;
if ( pBattle == NULL )
return FALSE;
m_BattleCache.push_back( pBattle );
}
LPREQUEST_RECORD pRequest;
for (i=0;i<SZ_BATTLE_REQUEST;i++)
{
pRequest = new REQUEST_RECORD;
if ( pRequest == NULL )
return FALSE;
m_RequestCache.push_back( pRequest );
}
return TRUE;
}
LPVOID CDanBattleManager::Get(BATTLE_LIST* pList)
{
if ( pList->empty() )
return NULL;
BATTLE_ITOR itor = pList->begin();
LPVOID pVoid = (*itor);
pList->pop_front();
return pVoid;
}
void CDanBattleManager::Destroy()
{
BATTLE_ITOR iLoop;
for( iLoop = m_BattleCache.begin(); iLoop != m_BattleCache.end(); iLoop++ )
{
delete (*iLoop);
}
for( iLoop = m_RequestCache.begin(); iLoop != m_RequestCache.end(); iLoop++ )
{
delete (*iLoop);
}
m_BattleCache.clear();
m_RequestCache.clear();
}
void CDanBattleManager::Push(BATTLE_LIST* pList, LPVOID pVoid)
{
pList->push_back( pVoid );
}
LPVOID CDanBattleManager::ViewFirst(BATTLE_LIST* pList)
{
if ( pList->empty() )
return NULL;
BATTLE_ITOR itor = pList->begin();
LPVOID pVoid = (*itor);
return pVoid;
}
BOOL CDanBattleManager::First(BATTLE_LIST* pList,LPVOID* lppVoid)
{
if ( pList->empty() )
return FALSE;
m_FindNextItor = pList->begin();
*lppVoid = (*m_FindNextItor++);
return TRUE;
}
BOOL CDanBattleManager::Next(BATTLE_LIST* pList,LPVOID* lppVoid)
{
if ( pList->empty() )
return FALSE;
if ( m_FindNextItor == pList->end() )
return FALSE;
*lppVoid = ( *m_FindNextItor++ );
return TRUE;
}
void CDanBattleManager::SetStatus( int bStatus )
{
m_iBattleStatus = bStatus;
m_dwStatusStartTime = g_globalTime;
switch (m_iBattleStatus)
{
case DBTL_STATUS_STARTUP : ShowLogInfo("BattleManager Status : DBTL_STATUS_STARTUP"); break;
case DBTL_STATUS_READY : ShowLogInfo("BattleManager Status : DBTL_STATUS_READY"); break;
case DBTL_STATUS_MOVE : ShowLogInfo("BattleManager Status : DBTL_STATUS_MOVE"); break;
case DBTL_STATUS_START : ShowLogInfo("BattleManager Status : DBTL_STATUS_START"); break;
case DBTL_STATUS_END : ShowLogInfo("BattleManager Status : DBTL_STATUS_END"); break;
case DBTL_STATUS_CLEAR : ShowLogInfo("BattleManager Status : DBTL_STATUS_CLEAR"); break;
}
if (m_iBattleStatus==DBTL_STATUS_STARTUP)
return;
if ( g_config.isDanBattleMap )
{
g_pDanBattleSys->SetStatus(m_iBattleStatus);
}
else
{
i3socket_t* pDestSock=FindBattleMapServer();
if (pDestSock==NULL)
return;
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
MSG_WriteByte( &netMessage, GSC_EXTEND );
MSG_WriteByte( &netMessage, GMS_DAN_BATTLE );
MSG_WriteByte( &netMessage, DANB_SETSTATUS );
MSG_WriteByte( &netMessage, m_iBattleStatus );
NET_SendMessage( pDestSock, &netMessage );
MSG_EndWriting( &netMessage );
}
}
int CDanBattleManager::GetStatus()
{
return m_iBattleStatus;
}
BOOL CDanBattleManager::FindRequester(LPREQUEST_RECORD pRequest)
{
BATTLE_ITOR iLoop;
LPREQUEST_RECORD pReq;
for ( iLoop=m_RequestList.begin();iLoop!=m_RequestList.end();iLoop++)
{
pReq=static_cast<LPREQUEST_RECORD>(*iLoop);
if (pRequest->DanIdx == pReq->DanIdx)
{
return TRUE;
}
}
return FALSE;
}
LPVOID CDanBattleManager::GetRequestPointer(LPREQUEST_RECORD pRequest)
{
BATTLE_ITOR iLoop;
LPREQUEST_RECORD pReq;
for ( iLoop=m_RequestList.begin();iLoop!=m_RequestList.end();iLoop++)
{
pReq=static_cast<LPREQUEST_RECORD>(*iLoop);
if ( pRequest != NULL)
{
if ( pRequest->DanIdx == pReq->DanIdx )
return pReq;
}
else
return pReq;
}
return NULL;
}
BOOL CDanBattleManager::InsertRquester(LPREQUEST_RECORD pRequest)
{
if ( FindRequester( pRequest ) )
return FALSE;
LPREQUEST_RECORD pCHRequest = static_cast < LPREQUEST_RECORD > ( Get( &m_RequestCache ) );
if ( pCHRequest == NULL )
return FALSE;
memcpy( pCHRequest, pRequest, sizeof( REQUEST_RECORD ) );
Push( &m_RequestList, pCHRequest );
return TRUE;
}
BOOL CDanBattleManager::DeleteRequester(LPREQUEST_RECORD pRequest)
{
LPVOID pDelete = GetRequestPointer(pRequest);
if ( pDelete == NULL)
return FALSE;
BATTLE_ITOR iLoop;
LPVOID pCheck;
for (iLoop=m_RequestList.begin();iLoop!=m_RequestList.end();)
{
pCheck=(*iLoop);
if (pDelete==pCheck)
{
m_RequestList.erase(iLoop++);
memset(pDelete,0,sizeof(REQUEST_RECORD));
Push(&m_RequestCache,pDelete);
return TRUE;
}
else
iLoop++;
}
return FALSE;
}
void CDanBattleManager::SendRequesterList(i3socket_t* sock,BYTE msgType,int serverID)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, msgType);
MSG_WriteByte(&netMessage, DANB_REQUESTER_LIST);
if ( msgType == GMS_DAN_BATTLE )
{
}
BYTE listSize = m_RequestList.size();
MSG_WriteByte(&netMessage, listSize);
BATTLE_ITOR iLoop;
LPREQUEST_RECORD pReq;
for ( iLoop=m_RequestList.begin();iLoop!=m_RequestList.end();iLoop++)
{
pReq=static_cast<LPREQUEST_RECORD>(*iLoop);
MSG_WriteLong(&netMessage, pReq->DanIdx);
MSG_WriteString(&netMessage, pReq->DanName);
MSG_WriteString(&netMessage, pReq->MasterName);
}
NET_SendMessage( sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CDanBattleManager::BroadCast_RequesterList()
{
LPREQUEST_RECORD pReq;
BATTLE_ITOR iLoop;
for ( iLoop=m_RequestList.begin();iLoop!=m_RequestList.end();iLoop++)
{
pReq=static_cast<LPREQUEST_RECORD>(*iLoop);
if( g_pc[pReq->ServerID].npcIdx == -1 || g_pc[pReq->ServerID].npcAi.aiType != 34
|| g_pc[pReq->ServerID].friendlyEntityType != ENTITY_NPC
|| g_pc[pReq->ServerID].busyState != BUSY_STATE_NPC )
continue;
if ( pReq->ServerNo == g_config.gameServerNo )
{
g_pDanBattleManager->SendRequesterList(&g_pc[pReq->ServerID].sock,GSC_DAN_BATTLE,0);
}
else
{
g_pDanBattleManager->SendRequesterList(&g_memberServer[pReq->ServerID].sock,GMS_DAN_BATTLE,0);
}
}
}
void CDanBattleManager::SendBattleDan(i3socket_t* sock,BYTE msgType,int serverID)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, msgType);
MSG_WriteByte(&netMessage, DANB_BATTLE_DAN);
if ( msgType == GMS_DAN_BATTLE )
{
}
MSG_WriteLong(&netMessage, m_BattleDan[0].DanIdx);
MSG_WriteLong(&netMessage, m_BattleDan[1].DanIdx);
MSG_WriteString(&netMessage, m_BattleDan[0].DanName);
MSG_WriteString(&netMessage, m_BattleDan[1].DanName);
NET_SendMessage( sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CDanBattleManager::BroadCast_BattleDan()
{
LPREQUEST_RECORD pReq;
BATTLE_ITOR iLoop;
for ( iLoop=m_RequestList.begin();iLoop!=m_RequestList.end();iLoop++)
{
pReq=static_cast<LPREQUEST_RECORD>(*iLoop);
if ( pReq->ServerNo == g_config.gameServerNo )
{
g_pDanBattleManager->SendBattleDan(&g_pc[pReq->ServerID].sock,GSC_DAN_BATTLE,0);
}
else
{
g_pDanBattleManager->SendBattleDan(&g_memberServer[pReq->ServerID].sock,GMS_DAN_BATTLE,0);
}
}
}
BOOL CDanBattleManager::isSuggester(LPREQUEST_RECORD pSuggest)
{
LPREQUEST_RECORD pRootRester = static_cast< LPREQUEST_RECORD > (ViewFirst(&m_RequestList));
if ( pRootRester == NULL )
return FALSE;
if (pSuggest->DanIdx != pSuggest->DanIdx)
return FALSE;
return TRUE;
}
BOOL CDanBattleManager::SetSuggester(LPREQUEST_RECORD pSuggest)
{
LPREQUEST_RECORD pSuggestData = static_cast<LPREQUEST_RECORD>(GetRequestPointer(pSuggest));
if ( pSuggestData==NULL )
return FALSE;
m_pSuggester = pSuggestData;
return TRUE;
}
LPREQUEST_RECORD CDanBattleManager::GetSuggester()
{
return m_pSuggester;
}
BOOL CDanBattleManager::MakeBattleDan()
{
LPREQUEST_RECORD pReqA=static_cast<LPREQUEST_RECORD>(ViewFirst(&m_RequestList));
if ( pReqA==NULL)
return FALSE;
if (m_pSuggester==NULL)
return FALSE;
BYTE bResult=MSG_ReadByte();
memcpy(&m_BattleDan[0],pReqA,sizeof(REQUEST_RECORD));
memcpy(&m_BattleDan[1],m_pSuggester,sizeof(REQUEST_RECORD));
g_pc[m_BattleDan[0].ServerID].curChargeSE -= g_logic.DanBattlePrice;
g_pc[m_BattleDan[1].ServerID].curChargeSE -= g_logic.DanBattlePrice;
SendGSM_Refresh_PersonData(&g_pc[m_BattleDan[0].ServerID], 0);
SendGSM_Refresh_PersonData(&g_pc[m_BattleDan[1].ServerID], 0);
SetStatus(DBTL_STATUS_MOVE);
BroadCast_BattleDan();
if ( g_config.isDanBattleMap )
{
BATTLE_TEAM_INFO Team[2];
Team[0].danIdx=m_BattleDan[0].DanIdx;
memcpy(Team[0].DanName,m_BattleDan[0].DanName,GUILDNAMESTRING);
Team[1].danIdx=m_BattleDan[1].DanIdx;
memcpy(Team[1].DanName,m_BattleDan[1].DanName,GUILDNAMESTRING);
g_pDanBattleSys->SetTeamInfo(0,&Team[0]);
g_pDanBattleSys->SetTeamInfo(1,&Team[1]);
}
ClearRequestList();
return TRUE;
}
void CDanBattleManager::ClearRequestList()
{
m_pSuggester=NULL;
LPVOID pVoid=Get(&m_RequestList);
while (pVoid!=NULL)
{
memset(pVoid,0,sizeof(REQUEST_RECORD));
Push(&m_RequestCache,pVoid);
pVoid=Get(&m_RequestList);
}
}
BOOL CDanBattleManager::HaveBattleMap(int serviceCount,int* pMemberServer,int MapNo)
{
int j;
for (j=0;j<serviceCount;j++)
{
if (pMemberServer[j]==MapNo)
{
return TRUE;
}
}
return FALSE;
}
i3socket_t* CDanBattleManager::FindBattleMapServer()
{
static int i;
for (i=0;i<MAX_MEMBER_SERVER;i++)
{
if ( HaveBattleMap(g_memberServer[i].serviceWorldNumber,
g_memberServer[i].serviceWorldList,DAN_BATTLEMAP_NO) )
{
return &g_memberServer[i].sock;
}
}
return NULL;
}
void CDanBattleManager::Update()
{
if ( m_iBattleStatus > DBTL_STATUS_MOVE )
return;
if ( m_iBattleStatus == DBTL_STATUS_READY )
{
UpdateRequester();
return;
}
DWORD remainTime=g_globalTime-m_dwStatusStartTime;
if ( remainTime < g_logic.danBattleStatusTime[m_iBattleStatus] )
return;
switch ( m_iBattleStatus )
{
case DBTL_STATUS_STARTUP :
{
SetStatus(DBTL_STATUS_READY);
}
break;
case DBTL_STATUS_MOVE :
{
SetStatus(DBTL_STATUS_START);
}
break;
}
}
LPVOID CDanBattleManager::GetBattleRequestDan()
{
return &m_BattleDan[0];
}
LPVOID CDanBattleManager::GetBattleSuggestDan()
{
return &m_BattleDan[1];
}
void CDanBattleManager::SendGSM_Refresh_PersonData(playerCharacter_t* pc, int type, int etc1, int etc2)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_DAN_BATTLE);
MSG_WriteByte(&netMessage, DANB_BATTLE_REFRESH_PERSONDATA);
MSG_WriteLong(&netMessage, type);
switch(type)
{
case 0:
MSG_WriteLong(&netMessage, pc->curChargeSE);
break;
case 1:
MSG_WriteLong(&netMessage, pc->rankPoint);
MSG_WriteLong(&netMessage, g_guild[pc->guildIdx].famePoint);
case 2:
MSG_WriteLong(&netMessage, etc1);
break;
case 3:
MSG_WriteLong(&netMessage, etc1);
break;
}
NET_SendUnreliableMessage(&pc->sock, &netMessage);
MSG_EndWriting(&netMessage);
}
BOOL CDanBattleSys::InitDanBattleSys()
{
return TRUE;
}
void CDanBattleSys::SendBattleReward(i3socket_t* sock,int type,int danFame,int userFame)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_DAN_BATTLE);
MSG_WriteByte(&netMessage, DANB_BATTLE_REWARD);
MSG_WriteLong(&netMessage, type);
MSG_WriteLong(&netMessage, danFame);
MSG_WriteLong(&netMessage, userFame);
NET_SendMessage( sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CDanBattleSys::CalcBattleResult()
{
int winTeamNo = GetWinTeam();
int looseTeamNo;
if (winTeamNo==2)
return;
if (winTeamNo==1)
looseTeamNo=0;
else
looseTeamNo=1;
g_guild[m_BattleTeamInfo[winTeamNo].danIdx].famePoint+=
g_logic.danBattleReward[DANB_WIN_DAN];
g_guild[m_BattleTeamInfo[looseTeamNo].danIdx].famePoint+=
g_logic.danBattleReward[DANB_LOOSE_DAN];
if (g_guild[m_BattleTeamInfo[looseTeamNo].danIdx].famePoint<0)
g_guild[m_BattleTeamInfo[looseTeamNo].danIdx].famePoint=0;
TEAM_ITOR iLoop;
int userIdx;
for (iLoop=m_BattleTeam[winTeamNo].begin();iLoop!=m_BattleTeam[winTeamNo].end();iLoop++)
{
userIdx=(*iLoop);
g_pc[userIdx].rankPoint+=g_logic.danBattleReward[DANB_WIN_USER];
SendBattleReward(&g_pc[userIdx].sock,1,g_logic.danBattleReward[DANB_WIN_DAN],
g_logic.danBattleReward[DANB_WIN_USER]);
g_pDanBattleManager->SendGSM_Refresh_PersonData(&g_pc[userIdx], 1);
GTH_SendMessage_CompleteEffect_To_AllPC(&g_pc[userIdx],66);
}
for (iLoop=m_BattleTeam[looseTeamNo].begin();iLoop!=m_BattleTeam[looseTeamNo].end();iLoop++)
{
userIdx=(*iLoop);
g_pc[userIdx].rankPoint+=g_logic.danBattleReward[DANB_LOOSE_USER];
SendBattleReward(&g_pc[userIdx].sock,0,g_logic.danBattleReward[DANB_LOOSE_DAN],
g_logic.danBattleReward[DANB_LOOSE_USER]);
g_pDanBattleManager->SendGSM_Refresh_PersonData(&g_pc[userIdx], 1);
GTH_SendMessage_CompleteEffect_To_AllPC(&g_pc[userIdx],67);
}
}
#include "../CTools.h"
extern CTools* gcpTools;
void CDanBattleSys::SetStatus(int iStatus)
{
int oldStatus = m_iBattleStatus;
m_iBattleStatus = iStatus;
m_dwStatusStartTime = g_globalTime;
m_dwBroadCastTime = g_globalTime;
int tempcount =0;
switch (m_iBattleStatus)
{
case DBTL_STATUS_STARTUP : ShowLogInfo("Battle Sys Status : DBTL_STATUS_STARTUP"); break;
case DBTL_STATUS_READY : ShowLogInfo("Battle Sys Status : DBTL_STATUS_READY"); break;
case DBTL_STATUS_MOVE : ShowLogInfo("Battle Sys Status : DBTL_STATUS_MOVE"); break;
case DBTL_STATUS_START :
{
ShowLogInfo("Battle Sys Status : DBTL_STATUS_START");
SendBattleStart();
m_BattleTeamInfo[0].startDanUserCount=m_BattleTeam[0].size();
m_BattleTeamInfo[1].startDanUserCount=m_BattleTeam[1].size();
AutoMoveDanMember();
SendBattleInfo();
break;
}
case DBTL_STATUS_END :
{
ShowLogInfo("Battle Sys Status : DBTL_STATUS_END");
SendBattleResult();
CalcBattleResult();
ShowLogInfo("MessageCount = %d", tempcount);
tempcount++;
break;
}
case DBTL_STATUS_LOOSE_MOVE :
{
ShowLogInfo("Battle Sys Status : DBTL_STATUS_LOOSE_MOVE");
int looseTeam=GetLooseTeam();
if (looseTeam!=2)
{
ClearTeam(looseTeam);
}
else
{
ClearTeam(0);
ClearTeam(1);
}
break;
}
case DBTL_STATUS_CLEAR :
{
ShowLogInfo("Battle Sys Status : DBTL_STATUS_CLEAR");
ClearTeam(0);
ClearTeam(1);
break;
}
case DBTL_STATUS_EVENT:
{
ShowLogInfo("Battle Sys Status : DBTL_STATUS_EVENT");
break;
}
}
int SendStatus =0;
if ( oldStatus == DBTL_STATUS_EVENT)
SendStatus = m_iBattleStatus;
if ( m_iBattleStatus == DBTL_STATUS_EVENT)
SendStatus = 5;
if ( SendStatus ==0 )return;
if ( g_config.isDanBattleMap == FALSE)
return;
for (int idx =0; idx < MAX_PCS; idx++){
playerCharacter_t *pPC = gcpTools->GetPlayerRecordPointer(idx);
if ( pPC == NULL) continue;
if ( pPC->worldIdx == DAN_BATTLEMAP_NO){
g_pDanBattleManager->SendGSM_Refresh_PersonData(pPC, 3, SendStatus);
}
}
}
int CDanBattleSys::GetStatus()
{
return m_iBattleStatus;
}
void CDanBattleSys::SendBattleResult()
{
TEAM_ITOR iLoop;
int userIdx;
BYTE WinTeam;
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
MSG_WriteByte( &netMessage, GSC_EXTEND );
MSG_WriteByte( &netMessage, GSC_DAN_BATTLE );
MSG_WriteByte( &netMessage, DANB_BATTLE_RESULT );
WinTeam=GetWinTeam();
MSG_WriteByte( &netMessage, WinTeam );
for (iLoop=m_BattleTeam[0].begin();iLoop!=m_BattleTeam[0].end();iLoop++)
{
userIdx=(*iLoop);
NET_SendMessage( &g_pc[userIdx].sock, &netMessage );
}
for (iLoop=m_BattleTeam[1].begin();iLoop!=m_BattleTeam[1].end();iLoop++)
{
userIdx=(*iLoop);
NET_SendMessage( &g_pc[userIdx].sock, &netMessage );
}
MSG_EndWriting( &netMessage );
}
void CDanBattleSys::SendBattleStatus()
{
if ( g_config.isManager )
{
g_pDanBattleManager->SetStatus(DBTL_STATUS_STARTUP);
}
else
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
MSG_WriteByte( &netMessage, GSC_EXTEND );
MSG_WriteByte( &netMessage, GMS_DAN_BATTLE );
MSG_WriteByte( &netMessage, DANB_SETSTATUS );
MSG_WriteByte( &netMessage, m_iBattleStatus );
NET_SendMessage( &localSocket, &netMessage );
MSG_EndWriting( &netMessage );
}
}
void CDanBattleSys::BroadCast_BattleInfo()
{
if ( m_iBattleStatus != DBTL_STATUS_START )
return;
DWORD remainTime=g_globalTime-m_dwBroadCastTime;
if ( remainTime >=DAN_BATTLE_BROADCAST_TIME)
{
SendBattleInfo();
m_dwBroadCastTime = g_globalTime;
}
}
int CDanBattleSys::GetWinTeam()
{
int LiveCount[2];
LiveCount[0]=CountLiveUser(0);
LiveCount[1]=CountLiveUser(1);
if (LiveCount[0]>LiveCount[1])
return 0;
if (LiveCount[1]>LiveCount[0])
return 1;
if (m_BattleTeamInfo[0].BattlePoint>m_BattleTeamInfo[1].BattlePoint)
return 0;
if (m_BattleTeamInfo[1].BattlePoint>m_BattleTeamInfo[0].BattlePoint)
return 1;
if (m_BattleTeamInfo[1].BattlePoint==m_BattleTeamInfo[0].BattlePoint)
return 2;
return 2;
}
int CDanBattleSys::GetLooseTeam()
{
if (m_BattleTeamInfo[0].BattlePoint>m_BattleTeamInfo[1].BattlePoint)
return 1;
if (m_BattleTeamInfo[1].BattlePoint>m_BattleTeamInfo[0].BattlePoint)
return 0;
if (m_BattleTeamInfo[1].BattlePoint==m_BattleTeamInfo[0].BattlePoint)
return 2;
return 2;
}
void CDanBattleSys::UpdateStatus()
{
switch ( m_iBattleStatus )
{
case DBTL_STATUS_START :
{
SetStatus(DBTL_STATUS_END);
}
break;
case DBTL_STATUS_END :
{
SetStatus(DBTL_STATUS_LOOSE_MOVE);
}
break;
case DBTL_STATUS_LOOSE_MOVE :
{
SetStatus(DBTL_STATUS_CLEAR);
}
break;
case DBTL_STATUS_CLEAR :
{
SetStatus(DBTL_STATUS_STARTUP);
SendBattleStatus();
}
break;
}
}
void CDanBattleSys::Update()
{
if ( m_iBattleStatus == DBTL_STATUS_MOVE )
{
DWORD remainTime = g_globalTime - m_dwBroadCastTime;
if ( remainTime > DAN_BATTLE_BROADCAST_TIME )
{
SendRemainTime();
m_dwBroadCastTime = g_globalTime;
}
}
if (m_iBattleStatus < DBTL_STATUS_START )
return;
DWORD remainTime=g_globalTime-m_dwStatusStartTime;
if ( remainTime < g_logic.danBattleStatusTime[m_iBattleStatus] )
{
BroadCast_BattleInfo();
return;
}
UpdateStatus();
}
void CDanBattleSys::InsertTeam(int teamNo,int ServerID)
{
m_BattleTeam[teamNo].push_back(ServerID);
DWORD RemainTime =
g_logic.danBattleStatusTime[m_iBattleStatus]-(g_globalTime-m_dwStatusStartTime);
g_pDanBattleManager->SendGSM_Refresh_PersonData(&g_pc[ServerID], 2, RemainTime);
g_pDanBattleManager->SendGSM_Refresh_PersonData(&g_pc[ServerID], 3, m_iBattleStatus);
}
void CDanBattleSys::DeleteTeam(int teamNo,int ServerID)
{
TEAM_ITOR iLoop;
int listID;
for (iLoop=m_BattleTeam[teamNo].begin();iLoop!=m_BattleTeam[teamNo].end();)
{
listID = (*iLoop);
if ( ServerID == listID )
{
m_BattleTeam[teamNo].erase(iLoop++);
}
else
iLoop++;
}
}
int CDanBattleSys::FindMyTeam(const int danIdx) const
{
if (m_BattleTeamInfo[0].danIdx == danIdx)
{
return 0;
}
if (m_BattleTeamInfo[1].danIdx == danIdx)
{
return 1;
}
return -1;
}
void CDanBattleSys::InsertTeam(playerCharacter_t* pUser)
{
int teamIdx=FindMyTeam(pUser->guildIdx);
if (teamIdx==0 || teamIdx==1)
InsertTeam(teamIdx,pUser->idx);
}
void CDanBattleSys::DeleteTeam(playerCharacter_t* pUser)
{
g_logSystem->WriteRLog("Delete Team....");
int teamIdx=FindMyTeam(pUser->guildIdx);
g_logSystem->WriteRLog("Delete Team Index :%d");
if (teamIdx==0 || teamIdx==1)
{
DeleteTeam(teamIdx,pUser->idx);
g_logSystem->WriteRLog("Team Size : %d",m_BattleTeam[teamIdx]);
int LiveCount=CountLiveUser(teamIdx);
g_logSystem->WriteRLog("Live Count : %d",LiveCount);
if (LiveCount==0)
{
SetStatus(DBTL_STATUS_END);
}
}
}
void CDanBattleSys::ClearTeam(int teamNo)
{
TEAM_ITOR iLoop;
int svrIdx;
for (iLoop=m_BattleTeam[teamNo].begin();iLoop!=m_BattleTeam[teamNo].end();iLoop++)
{
svrIdx=(*iLoop);
GTH_PC_Respawn( &g_pc[svrIdx], g_pc[svrIdx].curRA, g_pc[svrIdx].curSA, 0, 0 );
}
m_BattleTeam[teamNo].clear();
}
void CDanBattleSys::SendBattleMassage(i3socket_t* sock,BYTE msgType,BYTE mCode,BYTE mType)
{
}
void CDanBattleSys::SendBattleMassage(int teamNo,BYTE msgType,BYTE mCode,BYTE mType)
{
}
void CDanBattleSys::SendBattleMassage(BYTE msgType,BYTE mCode,BYTE mType)
{
}
void CDanBattleSys::SetTeamInfo(int teamNo,LPBATTLE_TEAM_INFO pInfo)
{
m_BattleTeamInfo[teamNo].danIdx = pInfo->danIdx;
m_BattleTeamInfo[teamNo].BattlePoint = 0;
m_BattleTeamInfo[teamNo].startDanUserCount = 0;
memcpy(m_BattleTeamInfo[teamNo].DanName,pInfo->DanName,GUILDNAMESTRING);
}
void CDanBattleSys::IncTeamPoint(int teamNo, int incValue)
{
m_BattleTeamInfo[teamNo].BattlePoint += incValue;
}
void CDanBattleSys::DecTeamPoint(int teamNo, int decValue)
{
m_BattleTeamInfo[teamNo].BattlePoint -= decValue;
}
void CDanBattleSys::SendBattleStart()
{
TEAM_ITOR iLoop;
int userIdx;
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
MSG_WriteByte( &netMessage, GSC_EXTEND );
MSG_WriteByte( &netMessage, GSC_DAN_BATTLE );
MSG_WriteByte( &netMessage, DANB_BATTLE_START );
for (iLoop=m_BattleTeam[0].begin();iLoop!=m_BattleTeam[0].end();iLoop++)
{
userIdx=(*iLoop);
NET_SendMessage( &g_pc[userIdx].sock, &netMessage );
ShowLogInfo("SendName = %s",g_pc[userIdx].name);
}
for (iLoop=m_BattleTeam[1].begin();iLoop!=m_BattleTeam[1].end();iLoop++)
{
userIdx=(*iLoop);
NET_SendMessage( &g_pc[userIdx].sock, &netMessage );
ShowLogInfo("SendName = %s",g_pc[userIdx].name);
}
MSG_EndWriting( &netMessage );
}
void CDanBattleSys::SendBattleInfo()
{
TEAM_ITOR iLoop;
int userIdx;
int totalUser;
int aliveUser;
DWORD remainTime=g_logic.danBattleStatusTime[m_iBattleStatus]-(g_globalTime-m_dwStatusStartTime);
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
MSG_WriteByte( &netMessage, GSC_EXTEND );
MSG_WriteByte( &netMessage, GSC_DAN_BATTLE );
MSG_WriteByte( &netMessage, DANB_BATTLE_INFO );
MSG_WriteLong( &netMessage, m_BattleTeamInfo[0].BattlePoint );
MSG_WriteLong( &netMessage, m_BattleTeamInfo[1].BattlePoint );
MSG_WriteLong( &netMessage, remainTime );
totalUser=m_BattleTeam[0].size();
aliveUser=CountLiveUser(0);
MSG_WriteLong( &netMessage, totalUser );
MSG_WriteLong( &netMessage, aliveUser );
totalUser=m_BattleTeam[1].size();
aliveUser=CountLiveUser(1);
MSG_WriteLong( &netMessage, totalUser );
MSG_WriteLong( &netMessage, aliveUser );
MSG_WriteLong( &netMessage, m_BattleTeamInfo[0].startDanUserCount );
MSG_WriteLong( &netMessage, m_BattleTeamInfo[1].startDanUserCount );
MSG_WriteString( &netMessage, m_BattleTeamInfo[0].DanName);
MSG_WriteString( &netMessage, m_BattleTeamInfo[1].DanName);
for (iLoop=m_BattleTeam[0].begin();iLoop!=m_BattleTeam[0].end();iLoop++)
{
userIdx=(*iLoop);
NET_SendMessage( &g_pc[userIdx].sock, &netMessage );
}
for (iLoop=m_BattleTeam[1].begin();iLoop!=m_BattleTeam[1].end();iLoop++)
{
userIdx=(*iLoop);
NET_SendMessage( &g_pc[userIdx].sock, &netMessage );
}
MSG_EndWriting( &netMessage );
}
void CDanBattleSys::CalcPoint(playerCharacter_t* pDead, playerCharacter_t* pKiller)
{
if ( GetStatus() != DBTL_STATUS_START )
return;
int TeamNo=FindMyTeam(pKiller->guildIdx);
if (TeamNo==0 || TeamNo==1)
{
IncTeamPoint(TeamNo,DAN_KILL_POINT);
SendBattleInfo();
TeamNo=FindMyTeam(pDead->guildIdx);
if (TeamNo==0 || TeamNo==1)
{
int LiveCount=CountLiveUser(TeamNo);
if (LiveCount==0)
{
SetStatus(DBTL_STATUS_END);
}
}
}
}
int CDanBattleSys::CountLiveUser(int teamNo)
{
TEAM_ITOR iLoop;
int userIdx;
int liveCount=0;
for (iLoop=m_BattleTeam[teamNo].begin();iLoop!=m_BattleTeam[teamNo].end();iLoop++)
{
userIdx=(*iLoop);
if ( g_pc[userIdx].alive && g_pc[userIdx].worldIdx == DAN_BATTLEMAP_NO)
{
liveCount++;
}
}
return liveCount;
}
void CDanBattleSys::MakeDanBattlePortal(int type)
{
LPREQUEST_RECORD requester = static_cast<LPREQUEST_RECORD>(g_pDanBattleManager->GetBattleRequestDan());
LPREQUEST_RECORD suggester = static_cast<LPREQUEST_RECORD>(g_pDanBattleManager->GetBattleSuggestDan());
if ( requester->ServerID < 0 || suggester->ServerID < 0 )
{
return;
}
if ( type == DBTL_STATUS_READY)
{
GTH_MakePortal_fordan(LOOTTYPE_DANBATTLE_TEAMS, g_curPC->entityType,
g_logic.danBattleStatusTime[DBTL_STATUS_MOVE] /2 ,
g_logic.danbattlePortal[DANBATTLE_START_PORTAL].StartworldIdx,
g_logic.danbattlePortal[DANBATTLE_START_PORTAL].StartPos,
g_logic.danbattlePortal[DANBATTLE_START_PORTAL].TargetWorldIdx,
g_logic.danbattlePortal[DANBATTLE_START_PORTAL].TargetPos,
g_logic.danbattlePortal[DANBATTLE_START_PORTAL].TargetWorldIdx2,
g_logic.danbattlePortal[DANBATTLE_START_PORTAL].TargetPos2
);
ShowLogInfo(" RequestUserName = %s", g_pc[requester->ServerID].name);
ShowLogInfo(" SussgstUserName = %s", g_pc[suggester->ServerID].name);
GTH_DeleteNoticePC(&g_pc[requester->ServerID]);
GTH_DeleteNoticePC(&g_pc[suggester->ServerID]);
ShowLogInfo(" RequestUserState = %d", g_pc[requester->ServerID].busyState);
ShowLogInfo(" SussgstUserState = %d", g_pc[suggester->ServerID].busyState);
}
else if ( type == DBTL_STATUS_START)
{
GTH_MakePortal_fordan(ENTITY_NPC, NULL,
g_logic.danBattleStatusTime[DBTL_STATUS_MOVE] / 2,
g_logic.danbattlePortal[DANBATTLE_ATEAM_PORTAL].StartworldIdx,
g_logic.danbattlePortal[DANBATTLE_ATEAM_PORTAL].StartPos,
g_logic.danbattlePortal[DANBATTLE_ATEAM_PORTAL].TargetWorldIdx,
g_logic.danbattlePortal[DANBATTLE_ATEAM_PORTAL].TargetPos,
NULL,NULL);
GTH_MakePortal_fordan(ENTITY_NPC, NULL,
g_logic.danBattleStatusTime[DBTL_STATUS_MOVE] / 2,
g_logic.danbattlePortal[DANBATTLE_BTEAM_PORTAL].StartworldIdx,
g_logic.danbattlePortal[DANBATTLE_BTEAM_PORTAL].StartPos,
g_logic.danbattlePortal[DANBATTLE_BTEAM_PORTAL].TargetWorldIdx,
g_logic.danbattlePortal[DANBATTLE_BTEAM_PORTAL].TargetPos,
NULL, NULL);
}
}
void CDanBattleFunc::RecvCC_DanBattleMessage()
{
BYTE bCommand = MSG_ReadByte();
switch ( bCommand )
{
case DANB_SETSTATUS : RecvCC_SetStatus(); break;
case DANB_REQUEST_BATTLE : RecvCC_ReqeustBattle(); break;
case DANB_SUGGEST_BATTLE : RecvCC_SuggestBattle(); break;
case DANB_SUGGEST_RESULT : RecvCC_SuggestResult(); break;
case DANB_BATTLE_READY : RecvCC_BattleReady(); break;
case DANB_BATTLE_START : RecvCC_Battle_Start(); break;
case DANB_REQUEST_CANCEL : RecvCC_CancelRequest(); break;
case DANB_INIT_CHAO : RecvCC_InitChao(); break;
case DANB_BATTLE_TEST_MODE : RecvCC_SetDanTestMode(); break;
}
}
void CDanBattleFunc::RecvGSM_DanBattleMessage()
{
BYTE bCommand = MSG_ReadByte();
switch ( bCommand )
{
case DANB_SETSTATUS : RecvGSM_SetStatus(); break;
case DANB_REQUEST_BATTLE : RecvGSM_RequestBattle(); break;
}
}
void CDanBattleFunc::SendErrorCode(i3socket_t* sock,BYTE msgType,BYTE eCode,BYTE eType)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, msgType);
MSG_WriteByte(&netMessage, DANB_ERROR);
MSG_WriteByte(&netMessage, eCode);
MSG_WriteByte(&netMessage, eType);
switch ( msgType )
{
case GMS_DAN_BATTLE : NET_SendUnreliableMessage(sock, &netMessage); break;
case GSC_DAN_BATTLE : NET_SendMessage( sock, &netMessage); break;
}
MSG_EndWriting(&netMessage);
}
void CDanBattleFunc::SendGSM_RequestBattle()
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, CC_EXTEND);
MSG_WriteByte(&netMessage, GSM_DAN_BATTLE);
MSG_WriteByte(&netMessage, DANB_REQUEST_BATTLE);
MSG_WriteString(&netMessage, g_curPC->name);
MSG_WriteString(&netMessage, g_curPC->guildName);
NET_SendUnreliableMessage(&localSocket, &netMessage);
MSG_EndWriting(&netMessage);
}
int CDanBattleFunc::CountDanUser(int danIdx)
{
int danCount=0;
for (int i=0;i<MAX_GUILD_MATES;i++)
{
if (g_guild[danIdx].mateName[i][0]!=NULL)
{
danCount++;
}
}
return danCount;
}
int CDanBattleFunc::RecvCC_ReqeustBattle(playerCharacter_t* pc)
{
playerCharacter_t *pPc = NULL;
if ( pc != NULL)
pPc = pc;
else
{
if ( g_curPC != NULL)
pPc = g_curPC;
}
if ( pPc == NULL )
return 0;
if(NULL == g_pDanBattleManager) return 1;
if( !g_config.isManager ) return 1;
if ( !IsGuildMasters( pPc ) )
{
GTH_SendMessage_ChattingMsg(pPc, 1, 9, 59 );
return -1;
}
if ( g_pDanBattleManager->m_bDanTestMode == FALSE )
{
if ( CountDanUser(pPc->guildIdx)<9 )
return -2;
}
if ( !g_config.isManager )
{
SendGSM_RequestBattle();
return 1;
}
if ( g_pDanBattleManager->GetStatus() != DBTL_STATUS_READY )
{
SendErrorCode(&pPc->sock,GSC_DAN_BATTLE,1,0);
return -3;
}
REQUEST_RECORD reqRecord;
reqRecord.No = 0;
reqRecord.ServerNo = g_config.gameServerNo;
reqRecord.ServerID = pPc->idx;
reqRecord.DanIdx = pPc->guildIdx;
memcpy(reqRecord.DanName,pPc->guildName,GUILDNAMESTRING);
memcpy(reqRecord.MasterName,pPc->name,NAMESTRING);
if ( !g_pDanBattleManager->InsertRquester(&reqRecord) )
{
SendErrorCode(&pPc->sock,GSC_DAN_BATTLE,1,0);
}
g_pDanBattleManager->BroadCast_RequesterList();
return 1;
}
#include "../Tools/CTools.h"
extern CTools* gcpTools;
void CDanBattleManager::UpdateRequester()
{
BATTLE_ITOR iLoop;
LPREQUEST_RECORD pReq;
for ( iLoop=m_RequestList.begin();iLoop!=m_RequestList.end();iLoop++)
{
LPREQUEST_RECORD pReq=static_cast<LPREQUEST_RECORD>(*iLoop);
if ( pReq->ServerID <0 || pReq->ServerID>= MAX_PCS)
{
DeleteRequester(pReq);
g_pDanBattleManager->BroadCast_RequesterList();
return;
}
playerCharacter_t* pPC = gcpTools->GetPlayerRecordPointer(pReq->ServerID);
if ( pPC == NULL){
DeleteRequester(pReq);
g_pDanBattleManager->BroadCast_RequesterList();
return;
}
if ( pPC->active == FALSE)
{
DeleteRequester(pReq);
g_pDanBattleManager->BroadCast_RequesterList();
return;
}
}
}
void CDanBattleFunc::RecvGSM_RequestBattle()
{
if ( g_pDanBattleManager->GetStatus() != DBTL_STATUS_READY )
{
entityPCList_t reqPl;
char userName[NAMESTRING];
sstrncpy( userName, MSG_ReadString(), NAMESTRING - 1 );
if( g_entityListMng.FindPCList( userName, &reqPl ) == -1 )
return;
SendErrorCode(&g_memberServer[reqPl.serverIdx].sock,GMS_DAN_BATTLE,1,0);
return;
}
}
void CDanBattleFunc::RecvCC_SetStatus()
{
if ( !g_config.isManager )
{
SendGSM_SetStatus();
return;
}
BYTE bStatus = MSG_ReadByte();
g_pDanBattleManager->SetStatus( bStatus );
}
void CDanBattleFunc::SendGSM_SetStatus()
{
BYTE bStatus = MSG_ReadByte();
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, CC_EXTEND);
MSG_WriteByte(&netMessage, GSM_DAN_BATTLE);
MSG_WriteByte(&netMessage, DANB_SETSTATUS);
MSG_WriteByte(&netMessage, bStatus);
NET_SendUnreliableMessage(&localSocket, &netMessage);
MSG_EndWriting(&netMessage);
}
void CDanBattleFunc::RecvGSM_SetStatus()
{
BYTE bStatus = MSG_ReadByte();
g_pDanBattleManager->SetStatus( bStatus );
}
void CDanBattleFunc::RecvCC_SuggestBattle()
{
if ( !IsGuildMasters( g_curPC ) )
return;
REQUEST_RECORD reqRecord;
REQUEST_RECORD sugRecord;
reqRecord.No = 0;
reqRecord.ServerNo = g_config.gameServerNo;
reqRecord.ServerID = g_curPC->idx;
reqRecord.DanIdx = g_curPC->guildIdx;
memcpy(reqRecord.DanName,g_curPC->guildName,GUILDNAMESTRING);
memcpy(reqRecord.MasterName,g_curPC->name,NAMESTRING);
if ( !g_pDanBattleManager->isSuggester(&reqRecord))
{
SendErrorCode(&g_curPC->sock,GSC_DAN_BATTLE,1,0);
return;
}
if ( g_curPC->curChargeSE < g_logic.DanBattlePrice)
{
SendGSM_SuggestResult(2);
return;
}
sugRecord.DanIdx=MSG_ReadLong();
sstrncpy( sugRecord.DanName, MSG_ReadString(), GUILDNAMESTRING - 1 );
if ( !g_pDanBattleManager->SetSuggester(&sugRecord))
{
SendErrorCode(&g_curPC->sock,GSC_DAN_BATTLE,1,0);
return;
}
LPREQUEST_RECORD pSuggest=g_pDanBattleManager->GetSuggester();
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_DAN_BATTLE);
MSG_WriteByte(&netMessage, DANB_SUGGEST_BATTLE);
LPREQUEST_RECORD pSugg=static_cast<LPREQUEST_RECORD>(g_pDanBattleManager->GetRequestPointer(&sugRecord));
if ( pSuggest->ServerID >= MAX_PCS || pSuggest->ServerID <0)
return;
NET_SendUnreliableMessage(&g_pc[pSuggest->ServerID].sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CDanBattleFunc::RecvCC_SuggestResult()
{
if ( !IsGuildMasters( g_curPC ) )
return;
LPREQUEST_RECORD pSuggest=g_pDanBattleManager->GetSuggester();
LPREQUEST_RECORD pRequest=static_cast<LPREQUEST_RECORD>(g_pDanBattleManager->GetRequestPointer(NULL));
if ( pSuggest == NULL )
return ;
if ( pSuggest->ServerID >= MAX_PCS || pSuggest->ServerID < 0)
return;
if ( g_pc[pSuggest->ServerID].curChargeSE < g_logic.DanBattlePrice)
{
GTH_SendMessage_ChattingMsg(&g_pc[pSuggest->ServerID], 0, 0, 36 );
SendGSM_SuggestResult(0);
return;
}
BYTE bCommand = MSG_ReadByte();
SendGSM_SuggestResult(bCommand);
if ( bCommand <= 0)
return;
if (pSuggest==NULL)
{
SendErrorCode(&g_curPC->sock,GSC_DAN_BATTLE,1,0);
return;
}
if (strcmp(pSuggest->DanName,g_curPC->guildName))
{
SendErrorCode(&g_curPC->sock,GSC_DAN_BATTLE,1,0);
return;
}
if (strcmp(pSuggest->MasterName,g_curPC->name))
{
SendErrorCode(&g_curPC->sock,GSC_DAN_BATTLE,1,0);
return;
}
g_pDanBattleManager->MakeBattleDan();
}
void CDanBattleFunc::RecvCC_ChangeBattleMap()
{
if (g_pDanBattleManager->GetStatus()!=DBTL_STATUS_MOVE)
{
SendErrorCode(&g_curPC->sock,GSC_DAN_BATTLE,1,0);
return;
}
}
void CDanBattleFunc::SendGSM_SuggestResult(BYTE isallow)
{
LPREQUEST_RECORD pSuggest=g_pDanBattleManager->GetSuggester();
LPREQUEST_RECORD pRequest=static_cast<LPREQUEST_RECORD>(g_pDanBattleManager->GetRequestPointer(NULL));
if ( pRequest->ServerID >= MAX_PCS || pRequest->ServerID < 0)
return;
if (pSuggest==NULL)
{
SendErrorCode(&g_pc[pRequest->ServerID].sock,GSC_DAN_BATTLE,1,0);
return;
}
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_DAN_BATTLE);
MSG_WriteByte(&netMessage, DANB_SUGGEST_RESULT);
MSG_WriteByte(&netMessage, isallow);
NET_SendUnreliableMessage(&g_pc[pRequest->ServerID].sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CDanBattleFunc::RecvCC_Battle_Start()
{
}
void CDanBattleFunc::RecvCC_CancelRequest()
{
if ( !IsGuildMasters( g_curPC ) )
return;
REQUEST_RECORD canRecord;
canRecord.No = 0;
canRecord.ServerNo = g_config.gameServerNo;
canRecord.ServerID = g_curPC->idx;
canRecord.DanIdx = g_curPC->guildIdx;
memcpy(canRecord.DanName,g_curPC->guildName,GUILDNAMESTRING);
memcpy(canRecord.MasterName,g_curPC->name,NAMESTRING);
if ( !g_pDanBattleManager->DeleteRequester(&canRecord))
{
SendErrorCode(&g_curPC->sock,GSC_DAN_BATTLE,1,0);
return;
}
g_pDanBattleManager->BroadCast_RequesterList();
}
void CDanBattleFunc::SendGSM_SuggestBattle()
{
}
void CDanBattleFunc::RecvCC_InitChao()
{
g_curPC->chaosPoint=0;
}
void CDanBattleFunc::RecvCC_SetDanTestMode()
{
g_pDanBattleManager->m_bDanTestMode=MSG_ReadByte();
}
void CDanBattleFunc::RecvCC_BattleReady()
{
LPREQUEST_RECORD requester = static_cast<LPREQUEST_RECORD>(g_pDanBattleManager->GetBattleRequestDan());
LPREQUEST_RECORD suggester = static_cast<LPREQUEST_RECORD>(g_pDanBattleManager->GetBattleSuggestDan());
if ( requester->ServerID < 0 || suggester->ServerID < 0 )
{
return;
}
SendGSM_BattleReady(&g_pc[requester->ServerID].sock);
SendGSM_BattleReady(&g_pc[suggester->ServerID].sock);
g_pDanBattleSys->MakeDanBattlePortal(DBTL_STATUS_READY);
}
void CDanBattleFunc::SendGSM_BattleReady(i3socket_t* sock)
{
int Status = g_pDanBattleSys->GetStatus();
DWORD StatusStartTime = g_pDanBattleSys->GetStatusStartTime();
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_DAN_BATTLE);
MSG_WriteByte(&netMessage, DANB_BATTLE_READY);
NET_SendUnreliableMessage(sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CDanBattleSys::AutoMoveDanMember()
{
int userIdx;
int zoneIdx;
typedef std::list<int> TEAM_LIST;
typedef TEAM_LIST::iterator TEAM_ITOR;
TEAM_ITOR iLoop;
for (int TeamCount = 0; TeamCount < 2; TeamCount ++)
{
for (iLoop=m_BattleTeam[TeamCount].begin();iLoop!=m_BattleTeam[TeamCount].end();iLoop++)
{
userIdx=(*iLoop);
vec_copy( g_logic.danbattlePortal[DANBATTLE_ATEAM_PORTAL +TeamCount].TargetPos, g_pc[userIdx].position );
zoneIdx = GTH_Zone_UpdateCurrentZone(ENTITY_PC, g_pc[userIdx].idx, g_pc[userIdx].worldIdx, g_pc[userIdx].zoneIdx, g_pc[userIdx].position);
g_pc[userIdx].zoneIdx = zoneIdx;
GTH_SendPCEventMessage_Respawn( &g_pc[userIdx] );
GTH_SendMessage_SyncItemObject( &g_pc[userIdx] );
}
}
}
void CDanBattleSys::TakeConsideration(playerCharacter_t *pc, int considerTableIdx)
{
if ( pc == NULL)
return;
int addItemData[6];
memset(addItemData, 0, 6);
addItemData[0] = g_ConsiderationTable[considerTableIdx].Idx;
addItemData[1] = -1;
addItemData[2] = g_ConsiderationTable[considerTableIdx].Quantity;
addItemData[3] = 1;
AI_NPC_AddItem( pc, addItemData);
GTH_PC_GetLoot( pc->idx, g_ConsiderationTable[considerTableIdx].Exp,
g_ConsiderationTable[considerTableIdx].GenExp,
0, 0, 0 );
}
DWORD CDanBattleSys::GetStatusStartTime()
{
return m_dwStatusStartTime;
}
void CDanBattleSys::SendRemainTime()
{
TEAM_ITOR iLoop;
int userIdx;
DWORD RemainTime =
g_logic.danBattleStatusTime[m_iBattleStatus]-(g_globalTime-m_dwStatusStartTime);
for (iLoop=m_BattleTeam[0].begin();iLoop!=m_BattleTeam[0].end();iLoop++)
{
userIdx=(*iLoop);
g_pDanBattleManager->SendGSM_Refresh_PersonData(&g_pc[userIdx], 2, RemainTime);
}
for (iLoop=m_BattleTeam[1].begin();iLoop!=m_BattleTeam[1].end();iLoop++)
{
userIdx=(*iLoop);
g_pDanBattleManager->SendGSM_Refresh_PersonData(&g_pc[userIdx], 2, RemainTime);
}
}
| C++ |
#include "../Global.h"
CUseItem g_UseItem;
extern CItemTableData gItemTableData;
CUseItem::CUseItem()
{
}
CUseItem::~CUseItem()
{
}
int CUseItem::DefaultUsetItem(item_t *item,int &invenPos,int &reply,int &error,int &itemIdx,int &raCount,int &saCount)
{
int itemTableIdx = item->itemTableIdx;
if(itemTableIdx < 0 || itemTableIdx >= MAX_NUMBER_OF_ITEM_TABLE) return 0;
int chargeRA, chargeSA;
chargeRA = g_itemTable[itemTableIdx].supplyRA;
chargeSA = g_itemTable[itemTableIdx].supplySA;
if ( g_curPC->PremiumInfo.bItemRecycle == FALSE )
{
reply = 0;
error = ERROR_DESTROYITEM_11;
GTH_SendMessage_DestroyItem( g_curPC, reply, error, itemIdx );
return 0;
}
storeStruct_t *store;
store = &g_store[g_curPC->storeIdx];
int valueRa = (int)GetEpackRechargePrice_RA( g_curPC->onceRecoveryRA, store->chargeRACost, g_itemTable[itemTableIdx].level );
int valueSa = (int)GetEpackRechargePrice_SA( g_curPC->onceRecoverySA, store->chargeSACost, g_itemTable[itemTableIdx].level );
if( g_curPC->onceRecoveryRA > 0 )
raCount = g_itemTable[itemTableIdx].sellCost * 3/10 * chargeRA * 0.01 / valueRa;
else raCount = 0;
if( g_curPC->onceRecoverySA > 0 )
saCount = g_itemTable[itemTableIdx].sellCost * 3/10 * chargeSA * 0.01 / valueSa;
else saCount = 0;
return 1;
}
int CUseItem::MonsterCardItem(item_t *item,int &invenPos,int &reply,int &error,int &itemIdx)
{
if ( invenPos == -1 ) return 0;
if( !CanSummonMonster(g_summonMonstertable[item->optionIdx[0]].idx))
{
g_logSystem->Write("Summonning Failure!! : This Map Can Not Summon.");
reply = 0;
error = ERROR_DESTROYITEM_5;
GTH_SendMessage_DestroyItem( g_curPC, reply, error, itemIdx );
return 0;
}
int ret = GTH_ProcessMessage_SummonMonster(item);
if (ret < 0)
{
g_logSystem->Write("Summonning Failure!! : This Monster Count Is Full.");
reply = 0;
if ( ret == -1)
error = ERROR_DESTROYITEM_4;
if ( ret == -2)
error = ERROR_DESTROYITEM_5;
GTH_SendMessage_DestroyItem( g_curPC, reply, error, itemIdx );
return 0;
}
if( invenPos != -1 )
{
g_curPC->inventory[invenPos] = -1;
error = invenPos;
}
return 1;
}
int CUseItem::AutoQuestScrollItem(item_t *item,int &invenPos,int &reply,int &error,int &itemIdx)
{
if ( invenPos == -1 ) return 0;
int itemTableIdx = item->itemTableIdx;
if(itemTableIdx < 0 || itemTableIdx >= MAX_NUMBER_OF_ITEM_TABLE) return 0;
int idx;
int dField[MAX_COUNT_QUEST_STATUS_DYNAMIC_FIELD];
memset( dField, 0, sizeof(dField) );
idx = GTH_GetEmptyQuestStatus( g_curPC );
if( idx >= 0 )
{
if( item->optionIdx[0] < 0 )
{
g_logSystem->Write("Auto Quest Scroll Item has invalidate data! (User: %s, Item Table Index : %d)", g_curPC->name, itemTableIdx );
reply = 0;
error = ERROR_DESTROYITEM_10;
GTH_SendMessage_DestroyItem( g_curPC, reply, error, itemIdx );
return 0;
}
dField[0] = g_autoQuestscrollTable[item->optionIdx[0]].Index;
dField[1] = g_autoQuestscrollTable[item->optionIdx[0]].dataField[0];
dField[2] = g_autoQuestscrollTable[item->optionIdx[0]].dataField[1];
dField[3] = 0;
dField[4] = g_autoQuestscrollTable[item->optionIdx[0]].dataField[5];
dField[5] = g_autoQuestscrollTable[item->optionIdx[0]].dataField[2];
dField[6] = g_autoQuestscrollTable[item->optionIdx[0]].dataField[6];
dField[7] = g_autoQuestscrollTable[item->optionIdx[0]].dataField[7];
dField[8] = g_autoQuestscrollTable[item->optionIdx[0]].dataField[3];
dField[9] = g_autoQuestscrollTable[item->optionIdx[0]].dataField[4];
int limittime=g_autoQuestscrollTable[item->optionIdx[0]].dataField[4];
GTH_AutoSetQuestStatus( g_curPC, idx, AUTOQUESTSCROLL_ITEM_INDEX, limittime, 0, dField );
if( invenPos != -1 )
{
g_curPC->inventory[invenPos] = -1;
error = invenPos;
}
}
else
{
reply = 0;
error = ERROR_DESTROYITEM_7;
GTH_SendMessage_DestroyItem( g_curPC, reply, error, itemIdx );
return 0;
}
return 1;
}
int CUseItem::QuestScrollItem(item_t *item,int &invenPos,int &reply,int &error,int &itemIdx)
{
if ( invenPos == -1 ) return 0;
int itemTableIdx = item->itemTableIdx;
if(itemTableIdx < 0 || itemTableIdx >= MAX_NUMBER_OF_ITEM_TABLE) return 0;
int idx;
int dField[MAX_COUNT_QUEST_STATUS_DYNAMIC_FIELD];
memset( dField, 0, sizeof(dField) );
int diffLevel;
if ( g_questscrollTable[item->optionIdx[0]].data.level > 10 )
diffLevel = g_curPC->level - g_questscrollTable[item->optionIdx[0]].data.level;
else
diffLevel = 0;
int ret = 0;
switch ( g_questscrollTable[item->optionIdx[0]].data.scrollType )
{
case 1 :
if ( g_curPC->pcClass != GEN_MENTALITY && g_curPC->pcClass != GEN_WIND )
ret = 1;
break;
case 2 :
if ( g_curPC->pcClass != GEN_WATER && g_curPC->pcClass != GEN_EARTH )
ret = 1;
break;
default :
break;
}
if ( ret == 1 )
{
reply = 0;
error = ERROR_DESTROYITEM_9;
GTH_SendMessage_DestroyItem( g_curPC, reply, error, itemIdx );
return 0;
}
if ( diffLevel < 0 || diffLevel > 2 )
{
reply = 0;
error = ERROR_DESTROYITEM_8;
GTH_SendMessage_DestroyItem( g_curPC, reply, error, itemIdx );
return 0;
}
if ( GTH_IsOnPlayQuestScroll( g_curPC ) )
{
reply = 0;
error = ERROR_DESTROYITEM_6;
GTH_SendMessage_DestroyItem( g_curPC, reply, error, itemIdx );
return 0;
}
idx = GTH_GetEmptyQuestStatus( g_curPC );
if( idx >= 0 )
{
if( item->optionIdx[0] < 0 )
{
g_logSystem->Write("Quest Scroll Item has invalidate data! (User: %s, Item Table Index : %d)", g_curPC->name, itemTableIdx );
reply = 0;
error = ERROR_DESTROYITEM_10;
GTH_SendMessage_DestroyItem( g_curPC, reply, error, itemIdx );
return 0;
}
dField[0] = g_questscrollTable[item->optionIdx[0]].Index;
dField[1] = g_questscrollTable[item->optionIdx[0]].data.monsterIndex;
dField[2] = g_questscrollTable[item->optionIdx[0]].data.monsterNo;
dField[3] = 0;
dField[4] = g_questscrollTable[item->optionIdx[0]].data.scrollType;
dField[5] = item->optionIdx[1];
dField[6] = g_questscrollTable[item->optionIdx[0]].data.rewardField[item->optionIdx[1]];
dField[7] = g_questscrollTable[item->optionIdx[0]].data.fame;
dField[8] = g_questscrollTable[item->optionIdx[0]].data.reward.itemNo;
dField[9] = g_questscrollTable[item->optionIdx[0]].data.reward.optionGroup;
if( g_questscrollTable[item->optionIdx[0]].data.rewardField[dField[5]] < 0 )
{
dField[5] = FindRewardField( item->optionIdx[0] );
dField[6] = g_questscrollTable[item->optionIdx[0]].data.rewardField[dField[5]];
if ( dField[5] < 0 )
{
g_logSystem->Write("Quest Scroll Table has an Error! (User: %s, Index : %d)", g_curPC->name, dField[0] );
reply = 0;
error = ERROR_DESTROYITEM_10;
GTH_SendMessage_DestroyItem( g_curPC, reply, error, itemIdx );
return 0;
}
}
GTH_SetQuestStatus( g_curPC, idx, QUEST_SCROLL_INDEX, -1, 0, dField );
if( invenPos != -1 )
{
g_curPC->inventory[invenPos] = -1;
error = invenPos;
}
}
else
{
reply = 0;
error = ERROR_DESTROYITEM_7;
GTH_SendMessage_DestroyItem( g_curPC, reply, error, itemIdx );
return 0;
}
return 1;
}
int CUseItem::RecyleItem(item_t *item,int &raCount,int &saCount,int &reply,int &error,int &itemIdx,int invenPos)
{
int number = item->durability + 1;
int level = item->reqLevel;
int itemTableIdx = item->itemTableIdx;
if(itemTableIdx < 0 || itemTableIdx >= MAX_NUMBER_OF_ITEM_TABLE) return 0;
if(gItemTableData.IsType(&g_itemTable[itemTableIdx],CItemTableData::ItemTable_FluxDataValue::RECYCLE_RA_CHARGE))
{
int iVal = gItemTableData.GetData(&g_itemTable[itemTableIdx],CItemTableData::ItemTable_FluxDataValue::RECYCLE_RA_CHARGE);
raCount = number * iVal;
}
else if(gItemTableData.IsType(&g_itemTable[itemTableIdx],CItemTableData::ItemTable_FluxDataValue::RECYCLE_SA_CHARGE))
{
int iVal = gItemTableData.GetData(&g_itemTable[itemTableIdx],CItemTableData::ItemTable_FluxDataValue::RECYCLE_SA_CHARGE);
saCount = number * iVal;
}
else if(gItemTableData.IsType(&g_itemTable[itemTableIdx],CItemTableData::ItemTable_FluxDataValue::RECYCLE_LEVEL_EXP_AND_GENEXP_MULTIPLY))
{
int iExpVal= (int)gItemTableData.GetData(&g_itemTable[itemTableIdx],CItemTableData::ItemTable_FluxDataValue::RECYCLE_LEVEL_EXP_MULTIPLY);
int iGenExpVal= (int)gItemTableData.GetData(&g_itemTable[itemTableIdx],CItemTableData::ItemTable_FluxDataValue::RECYCLE_LEVEL_GENEXP_MULTIPLY);
int exp, genExp;
exp = level * iExpVal;
genExp = level * iGenExpVal;
GTH_PC_GetLoot( g_curPC->idx, exp, genExp, 0, 0 ,FALSE,TRUE);
}
else if(gItemTableData.IsType(&g_itemTable[itemTableIdx],CItemTableData::ItemTable_FluxDataValue::RECYCLE_GEN_CAPABLITY))
{
int iVal = gItemTableData.GetData(&g_itemTable[itemTableIdx],CItemTableData::ItemTable_FluxDataValue::RECYCLE_GEN_CAPABLITY);
int genCap;
genCap = level * iVal;
GTH_PC_GetLoot( g_curPC->idx, 0, 0, 0, genCap ,FALSE,TRUE);
}
else if(gItemTableData.IsType(&g_itemTable[itemTableIdx],CItemTableData::ItemTable_FluxDataValue::RECYCLE_DESTROYITEM))
{
reply = 0;
error = ERROR_DESTROYITEM_3;
return -1;
}
else if(gItemTableData.IsType(&g_itemTable[itemTableIdx],CItemTableData::ItemTable_FluxDataValue::RUN_SKILL_ITEM))
{
int SkillIndex = gItemTableData.GetData(&g_itemTable[itemTableIdx],CItemTableData::ItemTable_FluxDataValue::RUN_SKILL_INDEX);
int AddLevel = gItemTableData.GetData(&g_itemTable[itemTableIdx],CItemTableData::ItemTable_FluxDataValue::RUN_SKILL_ADD_LEVEL);
g_PcSkill.GTH_PC_SkillNotOwn( g_curPC,CSkillItem::SELECT_ITEM, invenPos,SkillIndex, level + AddLevel, 0);
}
return 1;
}
int CUseItem::AutoQuestItemType(item_t *item,int &invenPos,int &raCount,int &saCount,int &bIsStack,int &stackNumber,int &reply,int &error,int &itemIdx)
{
int itemTableIdx = item->itemTableIdx;
if(itemTableIdx < 0 || itemTableIdx >= MAX_NUMBER_OF_ITEM_TABLE) return 0;
if(g_itemTable[itemTableIdx].etcItemType == ETCITEM_TYPE_AUTOQUESTITEM)
{
if ( invenPos == -1 ) return 0;
int idx;
int dField[MAX_COUNT_QUEST_STATUS_DYNAMIC_FIELD];
memset( dField, 0, sizeof(dField) );
idx = GTH_GetEmptyQuestStatus( g_curPC );
if( idx >= 0 )
{
int questIndex=-1;
for(int index=0; index<4; index++)
{
if(questIndex!=-1)break;
for(int i=0; i<g_autoQuestscrollTableNumber; i++)
{
if(g_itemTable[itemTableIdx].commonField[index] == g_autoQuestscrollTable[i].Index)
{
if(g_autoQuestscrollTable[i].data.reward.regClass ==-1||g_curPC->pcClass == g_autoQuestscrollTable[i].data.reward.regClass)
{
questIndex=i;
break;
}
}
}
}
if(index == 4)
{
return 0;
}
dField[0] = g_autoQuestscrollTable[questIndex].Index;
dField[1] = g_autoQuestscrollTable[questIndex].dataField[0];
dField[2] = g_autoQuestscrollTable[questIndex].dataField[1];
dField[3] = 0;
dField[4] = g_autoQuestscrollTable[questIndex].dataField[5];
dField[5] = g_autoQuestscrollTable[questIndex].dataField[2];
dField[6] = g_autoQuestscrollTable[questIndex].dataField[6];
dField[7] = g_autoQuestscrollTable[questIndex].dataField[7];
dField[8] = g_autoQuestscrollTable[questIndex].dataField[3];
dField[9] = g_autoQuestscrollTable[questIndex].dataField[4];
int limittime=g_autoQuestscrollTable[questIndex].dataField[4];
GTH_AutoSetQuestStatus( g_curPC, idx, AUTOQUESTSCROLL_ITEM_INDEX, limittime, 0, dField );
if( invenPos != -1 )
{
g_curPC->inventory[invenPos] = -1;
error = invenPos;
}
}
else
{
reply = 0;
error = ERROR_DESTROYITEM_7;
GTH_SendMessage_DestroyItem( g_curPC, reply, error, itemIdx );
return 0;
}
g_curPC->curChargeRA += raCount;
if( g_curPC->curChargeRA > g_curPC->maxChargeRA ) g_curPC->curChargeRA = g_curPC->maxChargeRA;
g_curPC->curChargeSA += saCount;
if( g_curPC->curChargeSA > g_curPC->maxChargeSA ) g_curPC->curChargeSA = g_curPC->maxChargeSA;
g_curPC->curItemWeight -= g_itemTable[item->itemTableIdx].weight;
if( g_itemTable[item->itemTableIdx].stackFlag )
{
bIsStack = true;
stackNumber = item->durability + 1;
}
g_logSystem->WriteToLog( g_curPC, LOG_CLASS_ITEM, "%d;%d;;;;%s;%s",
LOG_CLASS_ITEM_DESTROY, stackNumber, item->name,
GetItemInformationLog( bIsStack, item->itemTableIdx, itemIdx, -1 ) );
g_logSystem->Write( "Item Destroy : %s(%s), item : %s Destroyed", g_curPC->name, g_curPC->userID, item->name );
GTH_DeleteMyItem( g_curPC, item );
g_curPC->mouseInventory = -1;
g_DBGameServer->RemoveItem(g_curPC, itemIdx);
GTH_SendMessage_DestroyItem( g_curPC, reply, error, itemIdx );
return 0;
}
return 1;
}
| C++ |
#include "../global.h"
#include "../Tools/CTools.h"
extern CTools* gcpTools;
#include <vector>
#define ITEM_LOOT_TIME_FOR_INDIVIDUAL 10000
#define ITEM_DESTROY_TIME 180000
int g_numFixOpt;
extern float g_optValue[NUM_OPTION_VALUE];
extern itemTable_t g_optItem;
extern itemTable_t g_oriItem;
extern CItemTableData gItemTableData;
using namespace std;
void InitItemOption()
{
g_numFixOpt = 0;
}
void InitItem(item_t *item)
{
memset( item, 0, sizeof( item_t ) );
for(int i = 0; i < MAX_NUMBER_OF_ITEM_OPTION; i ++ )
{
item->optionIdx[i] = -1;
item->optionValue[i] = 0;
}
item->itemTableIdx = -1;
SetItemUseFlag( item, item_t::sItemExtendInfo::enumItemUseFlag::ITEM_USE_FLAG_UN_CHECK);
SetItemSpawnType( item, ITEM_SPAWN_INFO::enumItemSpawnType::ITEM_SPAWN_TYPE_UNKNOW);
}
DWORD GetItemAvailalbeOn( int itemTableIdx )
{
int itemClassTableIdx = g_itemTable[itemTableIdx].classIdx;
DWORD availableOn = 0;
if( g_itemTable[itemTableIdx].wearPosition == ITEM_WEAR_POS_WEAPON )
{
availableOn |= OPTION_AVAILABLE_ON_WEAPONS;
if( g_itemClassTable[itemClassTableIdx].weaponType == WEAPON_TYPE_DANGGER ) availableOn |= OPTION_AVAILABLE_ON_DAGGER;
if( g_itemClassTable[itemClassTableIdx].weaponType == WEAPON_TYPE_ONEHAND_SWORD ) availableOn |= OPTION_AVAILABLE_ON_1HSWORD;
if( g_itemClassTable[itemClassTableIdx].weaponType == WEAPON_TYPE_TWOHAND_SWORD ) availableOn |= OPTION_AVAILABLE_ON_2HSWORD;
if( g_itemClassTable[itemClassTableIdx].weaponType == WEAPON_TYPE_MAGIC_BOW ) availableOn |= OPTION_AVAILABLE_ON_BOW;
if( g_itemClassTable[itemClassTableIdx].weaponType == WEAPON_TYPE_STAFF ) availableOn |= OPTION_AVAILABLE_ON_STAFF;
if( g_itemClassTable[itemClassTableIdx].weaponType == WEAPON_TYPE_SPIRITOR ) availableOn |= OPTION_AVAILABLE_ON_SPIRITOR;
if( g_itemClassTable[itemClassTableIdx].weaponType == WEAPON_TYPE_CLAW ) availableOn |= OPTION_AVAILABLE_ON_CLAW;
}
if( g_itemTable[itemTableIdx].wearPosition == ITEM_WEAR_POS_UPPER )
{
availableOn |= OPTION_AVAILABLE_ON_UPPER;
availableOn |= OPTION_AVAILABLE_ON_ARMORS;
}
if( g_itemTable[itemTableIdx].wearPosition == ITEM_WEAR_POS_LOWER )
{
availableOn |= OPTION_AVAILABLE_ON_LOWER;
availableOn |= OPTION_AVAILABLE_ON_ARMORS;
}
if( g_itemTable[itemTableIdx].wearPosition == ITEM_WEAR_POS_AIR_PROTECTOR )
{
availableOn |= OPTION_AVAILABLE_ON_AIRPROTECTOR;
availableOn |= OPTION_AVAILABLE_ON_ARMORS;
}
if( g_itemTable[itemTableIdx].wearPosition == ITEM_WEAR_POS_BODY_PROTECTOR )
{
availableOn |= OPTION_AVAILABLE_ON_BODYPROTECTOR;
availableOn |= OPTION_AVAILABLE_ON_ARMORS;
}
if( g_itemTable[itemTableIdx].wearPosition == ITEM_WEAR_POS_GLOVES )
{
availableOn |= OPTION_AVAILABLE_ON_GLOVES;
availableOn |= OPTION_AVAILABLE_ON_ARMORS;
}
if( g_itemTable[itemTableIdx].wearPosition == ITEM_WEAR_POS_BOOTS )
{
availableOn |= OPTION_AVAILABLE_ON_BOOTS;
availableOn |= OPTION_AVAILABLE_ON_ARMORS;
}
if( g_itemTable[itemTableIdx].wearPosition == ITEM_WEAR_POS_EPACK ) availableOn |= OPTION_AVAILABLE_ON_EPACK;
if( g_itemTable[itemTableIdx].wearPosition == ITEM_WEAR_POS_RING ) availableOn |= OPTION_AVAILABLE_ON_RING;
if( g_itemTable[itemTableIdx].wearPosition == ITEM_WEAR_POS_NECKLACE ) availableOn |= OPTION_AVAILABLE_ON_NECKLACE;
if( g_itemTable[itemTableIdx].wearPosition == ITEM_WEAR_POS_BRACELET ) availableOn |= OPTION_AVAILABLE_ON_BRACELET;
if( g_itemTable[itemTableIdx].wearPosition == ITEM_WEAR_POS_EARRING ) availableOn |= OPTION_AVAILABLE_ON_EARRING;
return( availableOn );
}
int GetItemType( int itemTableIdx )
{
int wearPosition = g_itemTable[itemTableIdx].wearPosition;
int type = -1;
if( wearPosition == ITEM_WEAR_POS_WEAPON )
{
type = 0;
}
else
if( wearPosition == ITEM_WEAR_POS_UPPER || wearPosition == ITEM_WEAR_POS_LOWER ||
wearPosition == ITEM_WEAR_POS_AIR_PROTECTOR || wearPosition == ITEM_WEAR_POS_BODY_PROTECTOR ||
wearPosition == ITEM_WEAR_POS_GLOVES || wearPosition == ITEM_WEAR_POS_BOOTS )
{
type = 1;
}
else
if( wearPosition == ITEM_WEAR_POS_EPACK )
{
type = 2;
}
else
if( wearPosition == ITEM_WEAR_POS_RING || wearPosition == ITEM_WEAR_POS_NECKLACE ||
wearPosition == ITEM_WEAR_POS_BRACELET || wearPosition == ITEM_WEAR_POS_EARRING )
{
type = 3;
}
return( type );
}
int SpawnItem( item_t *item, int itemTableIdx, int optionNumber, int optionGradeType, int spawnLevel, int bGamble )
{
int reqLevel = 0;
if(itemTableIdx < 0 || itemTableIdx >= MAX_NUMBER_OF_ITEM_TABLE ) return 0;
itemTable_t *pTable = &g_itemTable[itemTableIdx];
itemClassTable_t *pCTable = &g_itemClassTable[pTable->classIdx];
DWORD availableOn;
InitItem( item );
InitItemOption();
if(gItemTableData.IsType(pTable,CItemTableData::ItemTable_FluxDataType::USE_ITEM_FOR_SUMMONCARD_ITEM))
{
item_t tempItem;
memcpy(&tempItem, item, sizeof(item_t) );
GenerateMonsterSpawnItem( tempItem, itemTableIdx, spawnLevel);
memcpy(item, &tempItem, sizeof(item_t));
return 1;
}
item->itemTableIdx = itemTableIdx;
item->reqLevel = pTable->level;
item->durability = 0;
if( pTable->durability > 0 )
{
item->durability = (int)( GTH_Random() * (float)pTable->durability );
}
else
{
item->durability = 0;
}
if(g_itemTable[itemTableIdx].epkChargeType == TypeItemTable_t::EPK_TYPE_MUCH_CAPACITY)
{
gcpTools->SetEpkChargeCount(item,pTable->epkChargeCount);
if(pTable->epkChargeCount > 0)
{
item->optionNumber++;
}
}
item->experience = 0;
item->timer = 0;
strcpy( item->name, pTable->name );
if( optionNumber == 0 || optionGradeType < 0 ) return true;
availableOn = GetItemAvailalbeOn( itemTableIdx );
DWORD optionAvailableOn;
int selectOptionList[MAX_COUNT_OPTION_TABLE];
int selectOptionNumber = 0;
int totalProbability = 0;
for( int i = 0; i < MAX_COUNT_OPTION_TABLE; i ++ )
{
optionAvailableOn = 0;
if( g_optionTable[i].idx < 0 ) break;
if ( !bGamble )
{
if( g_optionTable[i].dropYN <= 0 ) continue;
}
else
{
if( g_optionTable[i].dropYN < 2 ) continue;
}
optionAvailableOn = g_optionTable[i].availableOn;
if( optionAvailableOn & availableOn )
{
selectOptionList[selectOptionNumber ++] = i;
if( g_optionTable[i].fixationPro > 0 || bGamble )
{
totalProbability += g_optionTable[i].fixationPro;
}
}
}
if( selectOptionNumber <= 0 ) return true;
for( i = 0; i < selectOptionNumber; i ++ )
{
if( g_optionTable[selectOptionList[i]].fixationPro < 0 )
{
item->optionIdx[item->optionNumber] = selectOptionList[i];
if ( bGamble )
{
float r = 0.0f, accPro = 0.0f;
r = GTH_Random();
for( int OptionGradeNum = 0; OptionGradeNum < MAX_NUMBER_OF_OPTION_VALUE_GRADE ; OptionGradeNum ++ )
{
accPro += (float) g_logic.gambleSelectOptionTable[optionNumber].SelectOptionGraderate[OptionGradeNum] * 0.01f;
if( r < accPro ) break;
}
OptionGradeNum += 1;
if ( OptionGradeNum < 0 )
OptionGradeNum = 1;
if (OptionGradeNum > MAX_NUMBER_OF_OPTION_VALUE_GRADE )
OptionGradeNum = MAX_NUMBER_OF_OPTION_VALUE_GRADE;
item->optionValue[item->optionNumber] = OptionGradeNum;
}
else
item->optionValue[item->optionNumber] = optionGradeType;
item->optionNumber ++;
if( item->optionNumber >= optionNumber ) return true;
}
}
float accPro, r ;
int j=0;
for( i = 0; i < optionNumber; i ++ )
{
r = GTH_Random();
accPro = 0.0f;
for( j = 0; j < selectOptionNumber; j ++ )
{
if(j >= MAX_COUNT_OPTION_TABLE) continue;
if(selectOptionList[j] < 0 || selectOptionList[j] >= MAX_COUNT_OPTION_TABLE) continue;
if( g_optionTable[selectOptionList[j]].fixationPro < 0 ) continue;
if( selectOptionList[j] < 0 ) continue;
if(totalProbability != 0)
{
accPro += (float)g_optionTable[selectOptionList[j]].fixationPro / (float) totalProbability;
}
if( r < accPro ) break;
}
if( j == selectOptionNumber ) continue;
if(item->optionNumber < 0 || item->optionNumber >= MAX_NUMBER_OF_ITEM_OPTION) continue;
item->optionIdx[item->optionNumber] = selectOptionList[j];
if ( bGamble )
{
float GraderandomVal = 0.0f;
float GradeaccPro = 0.0f;
GraderandomVal = GTH_Random();
for( int OptionGradeNum = 0; OptionGradeNum < MAX_NUMBER_OF_OPTION_VALUE_GRADE ; OptionGradeNum ++ )
{
GradeaccPro += (float) g_logic.gambleSelectOptionTable[optionNumber].SelectOptionGraderate[OptionGradeNum] * 0.01;
if( GraderandomVal < GradeaccPro ) break;
}
OptionGradeNum += 1;
if ( OptionGradeNum < 0 )
OptionGradeNum = 1;
if (OptionGradeNum > MAX_NUMBER_OF_OPTION_VALUE_GRADE )
OptionGradeNum = MAX_NUMBER_OF_OPTION_VALUE_GRADE;
item->optionValue[item->optionNumber] = OptionGradeNum;
}
else
item->optionValue[item->optionNumber] = optionGradeType;
item->optionNumber ++;
totalProbability -= g_optionTable[selectOptionList[j]].fixationPro;
selectOptionList[j] = -1;
if( item->optionNumber >= optionNumber ) return true;
}
return true;
}
int SpawnItemByOptionGroup( item_t *item, int itemTableIdx, int optionGroupIdx )
{
itemTable_t *pTable = &g_itemTable[itemTableIdx];
InitItem( item );
InitItemOption();
item->itemTableIdx = itemTableIdx;
item->reqLevel = pTable->level;
item->durability = 0;
if( pTable->durability > 0 )
{
item->durability = (int)( GTH_Random() * (float)pTable->durability );
}
else
{
item->durability = 0;
}
item->experience = 0;
item->timer = 0;
strcpy( item->name, pTable->name );
if( g_optionGroupTable[optionGroupIdx].idx < 0 ) return false;
for( int i = 0; i < MAX_NUMBER_OF_ITEM_OPTION; i ++ )
{
if( g_optionGroupTable[optionGroupIdx].optionIdx[i] < 0 ) continue;
item->optionIdx[item->optionNumber] = g_optionGroupTable[optionGroupIdx].optionIdx[i];
item->optionValue[item->optionNumber] = g_optionGroupTable[optionGroupIdx].optionGrade[i];
item->optionNumber ++;
}
return true;
}
#define GENERATE_MONSTER_UP_LEVEL 10
float GetItemDropPenalty( int pcLevel, int monsterLevel )
{
float dropPenalty = 1.0f;
int levelDiffer = pcLevel - monsterLevel;
if( levelDiffer == 10 ) dropPenalty = 0.9f;
if( levelDiffer == 11 ) dropPenalty = 0.7f;
if( levelDiffer == 12 ) dropPenalty = 0.6f;
if( levelDiffer == 13 ) dropPenalty = 0.5f;
if( levelDiffer == 14 ) dropPenalty = 0.4f;
if( levelDiffer == 15 ) dropPenalty = 0.3f;
if( levelDiffer == 16 ) dropPenalty = 0.25f;
if( levelDiffer == 17 ) dropPenalty = 0.20f;
if( levelDiffer == 18 ) dropPenalty = 0.15f;
if( levelDiffer == 19 ) dropPenalty = 0.10f;
if( levelDiffer == 20 ) dropPenalty = 0.05f;
if( levelDiffer > 20 ) dropPenalty = 0.0f;
return( dropPenalty );
}
int GTH_GenerateItemFromMonster( monsterCharacter_t *monster )
{
playerCharacter_t* pc = NULL;
lootItem_t* pLoot=NULL;
item_t spawnItem[MAX_NUMBER_OF_ITEM_LOOT];
int nSpawnItem = 0;
vec3_t position[MAX_NUMBER_OF_ITEM_LOOT];
int i, j;
float r, accPro, dropPenalty;
int rx, ry, generateIdx, itemTableIdx;
int lootType, lootIdx;
int optionNumber, optionGrade;
bool bUsedropPenalty = TRUE;
float TotalDroupPenalty = 0.0;
lootType = LOOTTYPE_EVERYONE;
lootIdx = -1;
dropPenalty = 1.0f;
float fAddItemDropRatio =1.0f;
if( monster->mostConEntityType != ENTITY_PC || monster->mostConEntityIdx < 0 )
{
return 0;
}
else if( monster->mostConEntityType == ENTITY_PC && SAFE_PCS(monster->mostConEntityIdx))
{
if( g_pc[monster->mostConEntityIdx].organizeServer >= 0 )
{
lootType = LOOTTYPE_PARTY;
lootIdx = monster->mostConEntityIdx;
}
else
{
lootType = LOOTTYPE_INDIVIDUAL;
lootIdx = monster->mostConEntityIdx;
}
dropPenalty = GetItemDropPenalty( g_pc[monster->mostConEntityIdx].level, monster->basic.level );
if(gGameConfigFlag.m_bMap_Attr_Ratio)
{
PremiumMap *pMap = g_pc[monster->mostConEntityIdx].GetCurMap();
if(pMap)
{
fAddItemDropRatio = pMap->Cur.fAddItemDropRatio;
}
}
}
if( GTH_Random() < 0.8f )
{
GTH_SpawnNak( monster->basic.lootSE, monster->worldIdx, monster->position, lootType, lootIdx );
}
pLoot = &monster->basic.lootItem;
if( pLoot == NULL || pLoot->maxLootNumber <= 0 ) return( false );
for( i = 0; i < pLoot->maxLootNumber; i ++ )
{
accPro = 0.0f;
r = GTH_Random();
float generatePro;
for( j = 0; j < pLoot->generateIdxNumber; j ++ )
{
bUsedropPenalty = true;
if( pLoot->generateProbaility[j] == 0.0f ) continue;
generatePro = pLoot->generateProbaility[j] * (g_logic.itemDropRate * fAddItemDropRatio);
generateIdx = pLoot->generateIdx[j];
for( int ItemIdxInGroup = 0; ItemIdxInGroup < g_itemGenerateTable[generateIdx].itemNumber; ItemIdxInGroup ++ )
{
int itemidx = g_itemGenerateTable[generateIdx].itemIdx[ItemIdxInGroup];
if ( itemidx < 0 ) continue;
if ( g_itemTable[itemidx].level >= 200 )
{
bUsedropPenalty = false;
break;
}
}
if ( bUsedropPenalty )
{
TotalDroupPenalty += generatePro - (generatePro * dropPenalty);
generatePro *= dropPenalty;
}
else
{
accPro += TotalDroupPenalty;
TotalDroupPenalty = 0.0;
}
accPro += generatePro;
if( r < accPro ) break;
}
if( j == pLoot->generateIdxNumber ) continue;
generateIdx = pLoot->generateIdx[j];
accPro = 0.0f;
r = GTH_Random();
for( j = 0; j < g_itemGenerateTable[generateIdx].itemNumber; j ++ )
{
if( g_itemGenerateTable[generateIdx].itemPro[j] == 0.0f ) continue;
accPro += g_itemGenerateTable[generateIdx].itemPro[j];
if( r < accPro ) break;
}
if( j == g_itemGenerateTable[generateIdx].itemNumber ) continue;
itemTableIdx = g_itemGenerateTable[generateIdx].itemIdx[j];
if( itemTableIdx < 0 ) continue;
if ( itemTableIdx == 479 || itemTableIdx == 573)
{
if ( g_pc[monster->mostConEntityIdx].level > 1)
continue;
}
optionNumber = monster->basic.rareItemGrade;
if( optionNumber <= 0 ) optionNumber = 1;
optionGrade = monster->basic.optionGrade;
if( optionGrade <= 0 ) optionGrade = 1;
if( !SpawnItem( &spawnItem[nSpawnItem], itemTableIdx,
GTH_RandomizePower( 1, optionNumber ),
GTH_RandomizePower( 1, optionGrade ),
monster->basic.level ) ) continue;
if( itemTableIdx == 849 || itemTableIdx == 850 )
{
spawnItem[nSpawnItem].reqLevel = monster->basic.level;
}
else if( itemTableIdx >= 864 && itemTableIdx <= 867 )
{
spawnItem[nSpawnItem].reqLevel = monster->basic.level;
}
rx = GTH_Randomize( 3 ) - 1;
ry = GTH_Randomize( 3 ) - 1;
vec_copy( monster->position, position[nSpawnItem] );
position[nSpawnItem][2] = GTH_GetHeightFromCollisionMap(monster->worldIdx, monster->position);
position[nSpawnItem][0] += (float)rx * 40.0f;
position[nSpawnItem][1] += (float)ry * 40.0f;
g_logSystem->Write( "Item spawn Success (Monster:[%s](%d), Item:[%s])",
g_monsterTable[monster->tableIdx].name, monster->idx, g_itemTable[spawnItem[nSpawnItem].itemTableIdx].name );
nSpawnItem ++;
}
if( nSpawnItem > 0 )
GTH_SpawnMultiItemObject( spawnItem, monster->worldIdx, position, lootType, lootIdx, nSpawnItem, monster->position );
return( true );
}
int GTH_SpawnMultiItemObject( item_t item[], int worldIdx, vec3_t position[], int lootType, int lootPCIdx , int number, vec3_t origin )
{
int i, j, nItemObject = 0;
itemObject_t *pItemObject;
itemObject_t itemObject[MAX_NUMBER_OF_ITEM_LOOT];
for( i = 0; i < number; i ++ )
{
pItemObject = &g_object[0];
for ( j = 0; j < MAX_OBJECTS; j++, pItemObject++)
{
if ( !pItemObject->active ) break;
}
if ( j >= MAX_OBJECTS ) break;
if ( g_objectNumber >= MAX_OBJECTS ) break;
pItemObject->idx = j;
pItemObject->objectType = OBJECT_TYPE_ITEM;
pItemObject->worldIdx = worldIdx;
vec_copy( position[i], pItemObject->position );
memcpy( &pItemObject->item, &item[i], sizeof( item_t ) );
pItemObject->entityType = ENTITY_OBJECT;
vec_set(pItemObject->angles, 0, 0, 0);
pItemObject->zoneIdx = GTH_Zone_GetZoneIdx(pItemObject->position);
if ( !GTH_Zone_AddEntityList(pItemObject->worldIdx, pItemObject->zoneIdx, ENTITY_OBJECT, pItemObject->idx) )
{
g_logSystem->Write( "Item Spawn Failure!! : World : %d, Zone : %d, Idx : %d, Pos(%.2f,%.2f,%.2f)",
pItemObject->worldIdx, pItemObject->zoneIdx, pItemObject->idx,
pItemObject->position[0], pItemObject->position[1], pItemObject->position[2] );
break;
}
pItemObject->active = true;
pItemObject->lootPCIdx = lootPCIdx;
pItemObject->lootType = lootType;
if( lootType == LOOTTYPE_PARTY )
{
strncpy( pItemObject->organizerName, g_pc[lootPCIdx].organizerName, NAMESTRING);
pItemObject->organizeServer = g_pc[lootPCIdx].organizeServer;
pItemObject->organizeTime = g_pc[lootPCIdx].organizeTime;
}
ShowLogInfo("ITEMNAME=%s,organizerName=%s,objidx =%d", pItemObject->item.name, pItemObject->organizerName, pItemObject->idx);
pItemObject->lootTime = g_globalTime + ITEM_LOOT_TIME_FOR_INDIVIDUAL;
pItemObject->destroyTime = g_globalTime + ITEM_DESTROY_TIME;
memcpy( &itemObject[nItemObject], pItemObject, sizeof( itemObject_t ) );
nItemObject ++;
g_objectNumber++;
}
if( nItemObject > 0 )
GTH_SendMessage_AddMultiItemObject( itemObject, nItemObject, origin );
return( true );
}
int GTH_SpawnNak( int nak, int worldIdx, vec3_t position, int lootType, int lootPCIdx )
{
int i;
itemObject_t *itemObject;
if ( g_objectNumber >= MAX_OBJECTS ) return -1;
itemObject = &g_object[0];
for (i=0; i < MAX_OBJECTS; i++, itemObject++)
{
if ( !itemObject->active ) break;
}
if ( i >= MAX_OBJECTS ) return -1;
itemObject->idx = i;
itemObject->active = true;
itemObject->objectType = OBJECT_TYPE_NAK;
itemObject->worldIdx = worldIdx;
itemObject->nak = nak;
vec_copy(position, itemObject->position);
vec_set(itemObject->angles, 0, 0, 0);
itemObject->entityType = ENTITY_OBJECT;
itemObject->zoneIdx = GTH_Zone_GetZoneIdx(itemObject->position);
if ( !GTH_Zone_AddEntityList(itemObject->worldIdx, itemObject->zoneIdx, ENTITY_OBJECT, itemObject->idx) )
{
return -1;
}
itemObject->lootPCIdx = lootPCIdx;
itemObject->lootType = lootType;
itemObject->lootTime = g_globalTime + ITEM_LOOT_TIME_FOR_INDIVIDUAL;
itemObject->destroyTime = g_globalTime + ITEM_DESTROY_TIME;
if( lootType == LOOTTYPE_PARTY && lootPCIdx >= 0 )
{
strcpy( itemObject->organizerName, g_pc[lootPCIdx].organizerName );
itemObject->organizeServer = g_pc[lootPCIdx].organizeServer;
itemObject->organizeTime = g_pc[lootPCIdx].organizeTime;
}
g_objectNumber++;
GTH_SendMessage_AddItemObject( itemObject );
return( 1 );
}
int GTH_SpawnItemObject(item_t *item, int worldIdx, vec3_t position, int lootType, int lootPCIdx)
{
int i;
itemObject_t *itemObject;
if ( g_objectNumber >= MAX_OBJECTS ) return -1;
itemObject = &g_object[0];
for (i=0; i < MAX_OBJECTS; i++, itemObject++)
{
if ( !itemObject->active ) break;
}
if ( i >= MAX_OBJECTS ) return -1;
itemObject->idx = i;
itemObject->objectType = OBJECT_TYPE_ITEM;
itemObject->worldIdx = worldIdx;
vec_copy(position, itemObject->position);
memcpy( &itemObject->item, item, sizeof(item_t) );
itemObject->entityType = ENTITY_OBJECT;
vec_set(itemObject->angles, 0, 0, 0);
itemObject->zoneIdx = GTH_Zone_GetZoneIdx(itemObject->position);
if ( !GTH_Zone_AddEntityList(itemObject->worldIdx, itemObject->zoneIdx, ENTITY_OBJECT, itemObject->idx) )
{
g_logSystem->Write( "Item Spawn Failure!! : World : %d, Zone : %d, Idx : %d, Pos(%.2f,%.2f,%.2f)",
itemObject->worldIdx, itemObject->zoneIdx, itemObject->idx,
itemObject->position[0], itemObject->position[1], itemObject->position[2] );
return -1;
}
itemObject->active = true;
itemObject->lootPCIdx = lootPCIdx;
itemObject->lootType = lootType;
itemObject->lootTime = g_globalTime + ITEM_LOOT_TIME_FOR_INDIVIDUAL;
itemObject->destroyTime = g_globalTime + ITEM_DESTROY_TIME;
g_objectNumber++;
GTH_SendMessage_AddItemObject( itemObject );
return i;
}
int GTH_RemoveItemObject(itemObject_t *itemObject)
{
if ( !itemObject->active ) return false;
GTH_Zone_DeleteEntityList(itemObject->worldIdx, itemObject->zoneIdx, ENTITY_OBJECT, itemObject->idx);
itemObject->active = false;
g_objectNumber --;
GTH_SendMessage_DeleteItemObject( itemObject );
return true;
}
void GTH_UpdateItemObject()
{
itemObject_t *itemObject;
int i;
itemObject = &g_object[0];
for (i=0; i<MAX_OBJECTS; i++, itemObject++)
{
if ( !itemObject->active ) continue;
if ( g_globalTime >= itemObject->destroyTime )
{
GTH_RemoveItemObject( itemObject );
}
if ( itemObject->lootType == LOOTTYPE_INDIVIDUAL || itemObject->lootType == LOOTTYPE_PARTY )
{
if ( g_globalTime >= itemObject->lootTime )
{
itemObject->lootType = LOOTTYPE_EVERYONE;
itemObject->lootPCIdx = -1;
itemObject->lootTime = 0;
}
}
}
}
void GTH_DeleteMyItem( playerCharacter_t *pc, item_t *item )
{
int i;
memset(item, 0, sizeof(item_t));
item->itemTableIdx = -1;
for (i=0; i<MAX_NUMBER_OF_ITEM_OPTION; i++)
{
item->optionIdx[i] = -1;
}
pc->itemNumber --;
}
int GTH_AddMyItem( playerCharacter_t *pc, item_t *item )
{
int i;
for (i=0; i<MAX_NUMBER_OF_OWNITEM; i++)
{
if ( pc->item[i].itemTableIdx == -1 ) break;
}
if (i >= MAX_NUMBER_OF_OWNITEM)
return -1;
memcpy(&pc->item[i], item, sizeof(item_t));
pc->itemNumber++;
return i;
}
int GTH_StackMyItem( playerCharacter_t* pc, item_t *item )
{
int i;
int itemIdx;
if( GTH_IsStackItem( item ) )
{
for( i = 0; i < MAX_INVENTORY_SIZE; i ++ )
{
if( pc->inventory[i] < 0 ) continue;
itemIdx = pc->inventory[i];
if( GTH_CheckStackItem( item, &pc->item[itemIdx] ) )
{
return( itemIdx );
}
}
}
return( -1 );
}
int GTH_StackMyItemForDepot( playerCharacter_t* pc, item_t *item )
{
int i;
int itemIdx;
if( GTH_IsStackItem( item ) )
{
for( i = 0; i < MAX_DEPOT_SIZE; i ++ )
{
if( pc->depot[i] < 0 ) continue;
itemIdx = pc->depot[i];
if( GTH_CheckStackItem( item, &pc->item[itemIdx] ) )
{
return( itemIdx );
}
}
}
return( -1 );
}
int GTH_AddQuestItem( playerCharacter_t *pc, int itemTableIdx, int questIdx, int itemNumber, int maxNumber )
{
int i, pos;
for( i = 0; i < MAX_COUNT_QUEST_INVENTORY; i ++ )
{
if( questIdx == 0 || questIdx == 1 || questIdx == 2 || questIdx == 3 )
{
if( pc->questInventory[i].item.itemIdx == itemTableIdx ) break;
}
if( pc->questInventory[i].item.itemIdx == itemTableIdx &&
pc->questInventory[i].item.questIdx == questIdx ) break;
}
if( i == MAX_COUNT_QUEST_INVENTORY )
{
for( i = 0; i < MAX_COUNT_QUEST_INVENTORY; i ++ )
{
if( pc->questInventory[i].item.itemIdx < 0 ) break;
}
if( i == MAX_COUNT_QUEST_INVENTORY ) return 0;
pc->questInventory[i].item.itemIdx = itemTableIdx;
pc->questInventory[i].item.questIdx = questIdx;
pc->questInventory[i].item.itemCount = 0;
pos = i;
}
else
{
pos = i;
}
pc->questInventory[pos].item.itemCount += itemNumber;
if( pc->questInventory[pos].item.itemCount > maxNumber )
{
pc->questInventory[pos].item.itemCount = maxNumber;
return 0;
}
GTH_SendMessage_QuestItemInfo( pc, itemTableIdx, itemNumber );
return 1;
}
int GTH_DeleteQuestItem( playerCharacter_t *pc, int itemTableIdx, int questIdx, int itemNumber )
{
int i;
for( i = 0; i < MAX_COUNT_QUEST_INVENTORY; i ++ )
{
if( questIdx == 0 || questIdx == 1 || questIdx == 2 || questIdx == 3 )
{
if( pc->questInventory[i].item.itemIdx == itemTableIdx ) break;
}
if( pc->questInventory[i].item.itemIdx == itemTableIdx &&
pc->questInventory[i].item.questIdx == questIdx ) break;
}
if( i == MAX_COUNT_QUEST_INVENTORY ) return 0;
pc->questInventory[i].item.itemCount -= itemNumber;
if( itemNumber <= 0 || pc->questInventory[i].item.itemCount <= 0 )
{
pc->questInventory[i].item.itemIdx = -1;
pc->questInventory[i].item.questIdx = 0;
pc->questInventory[i].item.itemCount = 0;
}
itemNumber = -itemNumber;
GTH_SendMessage_QuestItemInfo( pc, itemTableIdx, itemNumber );
return 1;
}
int GTH_GetQuestItemCount( playerCharacter_t* pc, int itemTableIdx, int questIdx )
{
int i;
for( i = 0; i < MAX_COUNT_QUEST_INVENTORY; i ++ )
{
if( questIdx == 0 || questIdx == 1 || questIdx == 2 || questIdx == 3 )
{
if( pc->questInventory[i].item.itemIdx == itemTableIdx ) break;
}
if( pc->questInventory[i].item.itemIdx == itemTableIdx &&
pc->questInventory[i].item.questIdx == questIdx ) break;
}
if( i == MAX_COUNT_QUEST_INVENTORY ) return -1;
return pc->questInventory[i].item.itemCount;
}
int GTH_GenerateQuestItemFromMonster( monsterCharacter_t *monster, int conIdx )
{
int entityIdx;
int questIdx, step, itemTableIdx, maxNumber;
playerCharacter_t *pc;
if( g_qigTable[monster->tableIdx].itemNumber == 0 ) return 0;
entityIdx = monster->conInfo[conIdx].entityIdx;
pc = &g_pc[entityIdx];
if( !pc->active || !pc->alive ) return 0;
if( stricmp( pc->name, monster->conInfo[conIdx].entityName ) ) return 0;
for( int i = 0 ; i < g_qigTable[monster->tableIdx].itemNumber; i ++ )
{
if( g_qigTable[monster->tableIdx].itemTableIdx[i] < 0 ) continue;
if( g_qigTable[monster->tableIdx].questIdx[i] < 0 ) continue;
questIdx = g_qigTable[monster->tableIdx].questIdx[i];
step = g_qigTable[monster->tableIdx].step[i];
for( int j = 0; j < MAX_COUNT_QUEST_STATUS; j ++ )
{
if( pc->questStatus[j].questIdx == questIdx &&
pc->questVar[questIdx].var.step == step ) break;
}
if( j == MAX_COUNT_QUEST_STATUS ) continue;
if( GTH_Random() < g_qigTable[monster->tableIdx].generateProbaility[i] * 0.01f )
{
itemTableIdx = g_qigTable[monster->tableIdx].itemTableIdx[i];
maxNumber = g_qigTable[monster->tableIdx].maxItemCount[i];
GTH_AddQuestItem( pc, itemTableIdx, questIdx, 1, maxNumber );
return 1;
}
}
return 0;
}
int GTH_CheckCraftFormula( playerCharacter_t *pc )
{
int i, j, k, itemIdx;
int itemTableIdx1, itemTableIdx2, checkedNumber;
int numSourceItem, checkedItem[MAX_CRAFT_SOURCE_ITEM_SIZE], checkedIdx[MAX_CRAFT_SOURCE_ITEM_SIZE];
item_t *sourceItem;
numSourceItem = 0;
for( i = 0; i < MAX_CRAFT_SOURCE_ITEM_SIZE; i ++ )
{
if( pc->craftSourceInventory[i] < 0 ) continue;
sourceItem = &pc->item[pc->craftSourceInventory[i]];
checkedIdx[numSourceItem] = i;
numSourceItem ++;
}
if( numSourceItem == 0 ) return -1;
for( i = 0; i < g_itemCraftTableNumber; i ++ )
{
if( numSourceItem != g_itemCraftTable[i].numSourceItem ) continue;
checkedNumber = numSourceItem;
for( j = 0; j < MAX_CRAFT_SOURCE_ITEM_SIZE; j ++ )
{
checkedItem[j] = false;
}
for( j = 0; j < MAX_CRAFT_SOURCE_ITEM_SIZE; j ++ )
{
for( k = 0; k < numSourceItem; k ++ )
{
if( checkedItem[k] ) continue;
itemIdx = pc->craftSourceInventory[checkedIdx[k]];
sourceItem = &pc->item[itemIdx];
itemTableIdx1 = sourceItem->itemTableIdx;
itemTableIdx2 = g_itemCraftTable[i].sourceItem[j].itemIndex;
if( itemTableIdx1 != itemTableIdx2 ) continue;
if( g_itemTable[itemTableIdx1].stackFlag && g_itemTable[itemTableIdx2].stackFlag )
{
if( g_itemCraftTable[i].sourceItem[j].itemCount != sourceItem->durability + 1 ) continue;
}
break;
}
if( k == numSourceItem ) break;
checkedItem[k] = true;
checkedNumber --;
}
if( checkedNumber == 0 ) return i;
}
return -1;
}
int GTH_CraftProcess( playerCharacter_t *pc, int &reply, int &error, int &reqNak, float &pro, int resultItemIdx[], int checkFlag ,int &craftIdx )
{
int i, itemIdx, inventoryCount, specialType, optionGrade, rareItemGrade;
item_t resultItem;
char generateID[20];
int bIsStack, stackNumber;
if( pc->curItemWeight >= pc->calItemWeight )
{
reply = 0;
error = ERROR_ITEMSYSTEM_3;
return 0;
}
if( pc->craftResultInventory[0] >= 0 || pc->craftResultInventory[1] >= 0 )
{
reply = 0;
error = ERROR_ITEMSYSTEM_0;
return 0;
}
craftIdx = GTH_CheckCraftFormula( pc );
if( craftIdx < 0 )
{
reply = 0;
error = ERROR_ITEMSYSTEM_0;
return 0;
}
reqNak = g_itemCraftTable[craftIdx].craftCost;
pro = g_itemCraftTable[craftIdx].successProbability;
for( i = 0; i < g_itemCraftTable[craftIdx].numResultItem; i ++ )
{
resultItemIdx[i] = g_itemCraftTable[craftIdx].resultItem[i].itemIndex;
}
if( pc->curChargeSE < g_itemCraftTable[craftIdx].craftCost )
{
reply = 0;
error = ERROR_ITEMSYSTEM_1;
return 0;
}
inventoryCount = 0;
for( i = 0; i < MAX_INVENTORY_SIZE; i ++ )
{
if( pc->inventory[i] < 0 ) inventoryCount ++;
}
if( g_itemCraftTable[craftIdx].numResultItem > inventoryCount )
{
reply = 0;
error = ERROR_ITEMSYSTEM_2;
return 0;
}
if(gGameConfigFlag.m_bItem_Craft_Limit)
{
if( g_itemCraftTable[craftIdx].m_nMembership_type > -1)
{
if( g_itemCraftTable[craftIdx].m_nMembership_type > pc->PremiumInfo.iMaxLevelItemCraft)
{
reply = 0;
error = ERROR_ITEMSYSTEM_24;
return 0;
}
}
}
if( checkFlag ) return 1;
for( i = 0; i < MAX_CRAFT_SOURCE_ITEM_SIZE; i ++ )
{
if( pc->craftSourceInventory[i] < 0 ) continue;
itemIdx = pc->craftSourceInventory[i];
bIsStack = false;
stackNumber = 1;
if( g_itemTable[pc->item[itemIdx].itemTableIdx].stackFlag )
{
bIsStack = true;
stackNumber = pc->item[itemIdx].durability + 1;
}
g_logSystem->WriteToLog( pc, LOG_CLASS_ITEM, "%d;%d;;;;%s;%s",
LOG_CLASS_ITEM_CRAFT_SOURCE, stackNumber, pc->item[itemIdx].name,
GetItemInformationLog( bIsStack, pc->item[itemIdx].itemTableIdx, itemIdx, -1 ));
GTH_DeleteMyItem( pc, &pc->item[itemIdx] );
pc->craftSourceInventory[i] = -1;
g_DBGameServer->RemoveItem( pc, itemIdx );
}
specialType = g_itemCraftTable[craftIdx].specialType;
if( GTH_Random() <= g_itemCraftTable[craftIdx].successProbability * 0.01f )
{
for( i = 0; i < g_itemCraftTable[craftIdx].numResultItem; i ++ )
{
InitItem( &resultItem );
if( g_itemCraftTable[craftIdx].resultItem[i].optionGroupIdx >= 0 )
{
if( !SpawnItemByOptionGroup( &resultItem,
g_itemCraftTable[craftIdx].resultItem[i].itemIndex,
g_itemCraftTable[craftIdx].resultItem[i].optionGroupIdx ) ) continue;
}
else
{
optionGrade = g_itemCraftTable[craftIdx].resultItem[i].optionGrade;
rareItemGrade = g_itemCraftTable[craftIdx].resultItem[i].rareItemGrade;
if( optionGrade > 0 && rareItemGrade > 0 )
{
if( !SpawnItem( &resultItem,
g_itemCraftTable[craftIdx].resultItem[i].itemIndex,
GTH_RandomizePower( 1, rareItemGrade ),
GTH_RandomizePower( 1, optionGrade ) ) ) continue;
}
else
{
if( !SpawnItem( &resultItem,
g_itemCraftTable[craftIdx].resultItem[i].itemIndex ) ) continue;
}
}
if( g_itemTable[resultItem.itemTableIdx].stackFlag )
{
resultItem.durability = g_itemCraftTable[craftIdx].resultItem[i].itemCount - 1;
}
itemIdx = GTH_AddMyItem( pc, &resultItem );
pc->craftResultInventory[i] = itemIdx;
strcpy( generateID, "craftItem" );
g_DBGameServer->AddItem( pc, &resultItem, itemIdx, generateID );
bIsStack = false;
stackNumber = 1;
if( g_itemTable[resultItem.itemTableIdx].stackFlag )
{
bIsStack = true;
stackNumber = resultItem.durability + 1;
}
g_logSystem->WriteToLog( pc, LOG_CLASS_ITEM, "%d;%d;;;;%s;%s",
LOG_CLASS_ITEM_CRAFT_RESULT, stackNumber, resultItem.name,
GetItemInformationLog( bIsStack, resultItem.itemTableIdx, itemIdx, -1 ));
}
}
pc->curChargeSE -= reqNak;
return 1;
}
int GTH_AutoCraftProcess( playerCharacter_t *pc, int idx,int &reply, int &error)
{
int i=0;
item_t *sourceItem;
int autoQuestindex=pc->questStatus[idx].questIdx+pc->questStatus[idx].dField[0];
if(pc->questStatus[idx].dField[3] < pc->questStatus[idx].dField[2]){
reply=0;
error=ERROR_ITEMSYSTEM_23;
return 0;
}
for( i = 0; i < MAX_AUTO_TRADEITEMFILD; i ++ ){
if( pc->npcAutoSourceInventory[i] < 0 ) continue;
sourceItem = &pc->item[pc->npcAutoSourceInventory[i]];
if(sourceItem->itemTableIdx == pc->questStatus[idx].dField[8]){
reply=1;
break;
}
else{
reply=0;
break;
}
}
if( reply==1){
for(int j=i+1; j<MAX_AUTO_TRADEITEMFILD; j++){
if( pc->npcAutoSourceInventory[j] < 0 ) continue;
sourceItem = &pc->item[pc->npcAutoSourceInventory[j]];
if(sourceItem->itemTableIdx != pc->questStatus[idx].dField[8]){
reply=0;
break;
}
}
}
if(reply==1){
error=ERROR_ITEMSYSTEM_NONE;
return 1;
}
reply=0;
error=ERROR_ITEMSYSTEM_21;
return 0;
}
#define REPLY_FAILE 0
#define REPLY_UPGRADE 1
#define REPLY_GAMBLE 2
int FineOptionStoneType( int itemIdx )
{
int ret;
switch ( itemIdx )
{
case 451 :
ret = OPTION_SPHERE_LEAF;
break;
case 452 :
ret = OPTION_SPHERE_MAD;
break;
case 453 :
ret = OPTION_SPHERE_WAVE;
break;
case 454 :
ret = OPTION_SPHERE_FIRE;
break;
case 455 :
ret = OPTION_SPHERE_ART;
break;
default :
ret = -1;
break;
}
return ret;
}
int GTH_UpgradeProcess( playerCharacter_t *pc, int selectedOptionIdx, int &reply, int &error, int &reqNak, float &pro, float &vanishPro, float &downGradePro, int ¤tGrade, int &nextGrade, int& resultItemIdx, int checkFlag )
{
int optionItemIdx, upItemIdx, preItemIdx, changeOptionIndex = -1;
int maxValue;
DWORD availableOn;
int i, itemIdx, inventoryCount;
item_t resultItem;
char generateID[20];
int bIsStack, stackNumber;
itemUpgradeProbabilityTable_t * pUpgradeTable;
int optionType, optionStoneType;
if( pc->upgradeResultInventory >= 0 )
{
reply = 0;
error = ERROR_ITEMSYSTEM_12;
return 0;
}
if( pc->curItemWeight >= pc->calItemWeight )
{
reply = 0;
error = ERROR_ITEMSYSTEM_3;
return 0;
}
upItemIdx = pc->upgradeSourceInventory[0];
optionItemIdx = pc->upgradeSourceInventory[1];
preItemIdx = pc->upgradeSourceInventory[2];
if( upItemIdx < 0 || optionItemIdx < 0 )
{
reply = 0;
error = ERROR_ITEMSYSTEM_12;
return 0;
}
availableOn = GetItemAvailalbeOn( pc->item[upItemIdx].itemTableIdx );
if( availableOn == 0 )
{
reply = 0;
error = ERROR_ITEMSYSTEM_12;
return 0;
}
if( g_itemTable[pc->item[optionItemIdx].itemTableIdx].etcItemType != ETCITEM_TYPE_OPTIONSPHERE )
{
reply = 0;
error = ERROR_ITEMSYSTEM_12;
return 0;
}
if( pc->item[optionItemIdx].itemTableIdx == 863 )
{
reply = 0;
error = ERROR_ITEMSYSTEM_12;
return 0;
}
int itemType = GetItemType( pc->item[upItemIdx].itemTableIdx );
if( itemType != 0 && itemType != 1 )
{
reply = 0;
error = ERROR_ITEMSYSTEM_12;
return 0;
}
if( pc->item[upItemIdx].optionNumber < 1 || pc->item[upItemIdx].optionNumber <= selectedOptionIdx )
{
reply = 0;
error = ERROR_ITEMSYSTEM_12;
return 0;
}
itemIdx = pc->upgradeSourceInventory[1];
if( g_itemTable[pc->item[itemIdx].itemTableIdx].stackFlag )
{
bIsStack = true;
stackNumber = pc->item[itemIdx].durability + 1;
if ( stackNumber >= 2)
{
reply = 0;
error = ERROR_ITEMSYSTEM_12;
return 0;
}
}
optionType = OPTION_GetOptionStoneGrade( &pc->item[upItemIdx] );
optionStoneType = FineOptionStoneType( pc->item[optionItemIdx].itemTableIdx );
if( optionType != optionStoneType )
{
reply = 0;
error = ERROR_ITEMSYSTEM_21;
resultItemIdx = pc->item[upItemIdx].itemTableIdx;
return 0;
}
switch( optionType )
{
case OPTION_SPHERE_LEAF :
pUpgradeTable = &g_logic.leafStoneProTbl;
break;
case OPTION_SPHERE_MAD :
pUpgradeTable = &g_logic.madStoneProTbl;
break;
case OPTION_SPHERE_WAVE :
pUpgradeTable = &g_logic.waveStoneProTbl;
break;
case OPTION_SPHERE_FIRE :
pUpgradeTable = &g_logic.fireStoneProTbl;
break;
case OPTION_SPHERE_ART :
pUpgradeTable = &g_logic.artStoneProTbl;
break;
default :
{
reply = 0;
error = ERROR_ITEMSYSTEM_12;
return 0;
}
}
maxValue = 10;
if(gGameConfigFlag.m_bItem_Upgrade_Limit)
{
int nFreeUserMaxValue = pc->PremiumInfo.ItemOptionUpgrade.iMaxlevel;
if( pc->item[upItemIdx].optionValue[selectedOptionIdx] >= nFreeUserMaxValue )
{
reply = 0;
error = ERROR_ITEMSYSTEM_25;
return 0;
}
}
if( pc->item[upItemIdx].optionValue[selectedOptionIdx] >= maxValue )
{
reply = 0;
error = ERROR_ITEMSYSTEM_12;
return 0;
}
currentGrade = pc->item[upItemIdx].optionValue[selectedOptionIdx];
nextGrade = currentGrade + 1;
pro = pUpgradeTable->successPro[nextGrade];
reqNak = pUpgradeTable->cost[nextGrade];
vanishPro = pUpgradeTable->vanishPro[nextGrade];
downGradePro = pUpgradeTable->gradeDownPro[nextGrade];
if(gGameConfigFlag.m_bItem_Upgrade_Limit)
{
int ratio = (pc->PremiumInfo.ItemOptionUpgrade.fAddPriceRatio + 0.000001f) * 100;
reqNak = ( ratio * reqNak) / 100;
}
if( currentGrade > nextGrade )
{
reply = 0;
error = ERROR_ITEMSYSTEM_14;
return 0;
}
if( pc->curChargeSE < reqNak )
{
reply = 0;
error = ERROR_ITEMSYSTEM_1;
return 0;
}
inventoryCount = GTH_FindEmptyInventoryPos( pc );
if( inventoryCount < 0 )
{
reply = 0;
error = ERROR_ITEMSYSTEM_2;
return 0;
}
memcpy( &resultItem, &pc->item[upItemIdx], sizeof( item_t ) );
resultItemIdx = resultItem.itemTableIdx;
if( checkFlag ) return 1;
for( i = 0; i < MAX_UPGRADE_SOURCE_ITEM_SIZE; i ++ )
{
if( pc->upgradeSourceInventory[i] < 0 ) continue;
itemIdx = pc->upgradeSourceInventory[i];
bIsStack = false;
stackNumber = 1;
if( g_itemTable[pc->item[itemIdx].itemTableIdx].stackFlag )
{
bIsStack = true;
stackNumber = pc->item[itemIdx].durability + 1;
}
g_logSystem->WriteToLog( pc, LOG_CLASS_ITEM, "%d;%d;;;;%s;%s",
LOG_CLASS_ITEM_UPGRADE_SOURCE, stackNumber, pc->item[itemIdx].name,
GetItemInformationLog( bIsStack, pc->item[itemIdx].itemTableIdx, itemIdx, -1 ));
GTH_DeleteMyItem( pc, &pc->item[itemIdx] );
pc->upgradeSourceInventory[i] = -1;
g_DBGameServer->RemoveItem( pc, itemIdx );
}
pc->curChargeSE -= reqNak;
if( GTH_Random() <= pro * 0.01f )
{
if( resultItem.optionValue[selectedOptionIdx] < 0 )
{
resultItem.optionValue[selectedOptionIdx] = 0;
}
if( resultItem.optionValue[selectedOptionIdx] < maxValue )
{
resultItem.optionValue[selectedOptionIdx] = resultItem.optionValue[selectedOptionIdx] + 1;
}
itemIdx = GTH_AddMyItem( pc, &resultItem );
pc->upgradeResultInventory = itemIdx;
strcpy( generateID, "upgradeItem" );
g_DBGameServer->AddItem( pc, &resultItem, itemIdx, generateID );
bIsStack = false;
stackNumber = 1;
if( g_itemTable[resultItem.itemTableIdx].stackFlag )
{
bIsStack = true;
stackNumber = resultItem.durability + 1;
}
g_logSystem->WriteToLog( pc, LOG_CLASS_ITEM, "%d;%d;;;;%s;%s",
LOG_CLASS_ITEM_UPGRADE_RESULT, stackNumber, resultItem.name,
GetItemInformationLog( bIsStack, resultItem.itemTableIdx, itemIdx, -1 ));
}
else
{
if( GTH_Random() <= 1.0f - ( vanishPro * 0.01f ) || vanishPro <= 0.0f )
{
if ( downGradePro > 0.0f && GTH_Random() <= ( downGradePro * 0.01f ) )
{
resultItem.optionValue[selectedOptionIdx] -= pUpgradeTable->gradeDownLevel[nextGrade];
if ( resultItem.optionValue[selectedOptionIdx] < 0 )
resultItem.optionValue[selectedOptionIdx] = 0;
}
itemIdx = GTH_AddMyItem( pc, &resultItem );
pc->upgradeResultInventory = itemIdx;
strcpy( generateID, "upgradeItem" );
g_DBGameServer->AddItem( pc, &resultItem, itemIdx, generateID );
bIsStack = false;
stackNumber = 1;
if( g_itemTable[resultItem.itemTableIdx].stackFlag )
{
bIsStack = true;
stackNumber = resultItem.durability + 1;
}
g_logSystem->WriteToLog( pc, LOG_CLASS_ITEM, "%d;%d;;;;%s;%s",
LOG_CLASS_ITEM_UPGRADE_RESULT,
stackNumber,
resultItem.name,
GetItemInformationLog( bIsStack, resultItem.itemTableIdx, itemIdx, -1 ));
}
return 0;
}
return 1;
}
int GTH_DeleteProcess( playerCharacter_t *pc, int &reply, int &error, int optionIndex, int checkFlag )
{
int upItemIdx = pc->upgradeSourceInventory[0];
int optionItemIdx = pc->upgradeSourceInventory[1];
int itemIdx;
int resultItemIdx;
item_t resultItem;
char generateID[20];
int bIsStack, stackNumber;
if( pc->upgradeResultInventory >= 0 )
{
reply = 0;
error = ERROR_ITEMSYSTEM_17;
return 0;
}
int itemType = GetItemType( pc->item[upItemIdx].itemTableIdx );
if( itemType != 0 && itemType != 1 )
{
reply = 0;
error = ERROR_ITEMSYSTEM_15;
return 0;
}
if( pc->item[optionItemIdx].itemTableIdx != 861 )
{
reply = 0;
error = ERROR_ITEMSYSTEM_17;
return 0;
}
if( optionIndex < 0 || optionIndex >= pc->item[upItemIdx].optionNumber)
{
reply = 0;
error = ERROR_ITEMSYSTEM_16;
return 0;
}
memcpy( &resultItem, &pc->item[upItemIdx], sizeof( item_t ) );
resultItemIdx = resultItem.itemTableIdx;
if( checkFlag ) return 1;
for( int i = 0; i < MAX_UPGRADE_SOURCE_ITEM_SIZE; i ++ )
{
if( pc->upgradeSourceInventory[i] < 0 ) continue;
itemIdx = pc->upgradeSourceInventory[i];
bIsStack = false;
stackNumber = 1;
if( g_itemTable[pc->item[itemIdx].itemTableIdx].stackFlag )
{
bIsStack = true;
stackNumber = pc->item[itemIdx].durability + 1;
}
g_logSystem->WriteToLog( pc, LOG_CLASS_ITEM, "%d;%d;;;;%s;%s",
LOG_CLASS_ITEM_UPGRADE_SOURCE, stackNumber, pc->item[itemIdx].name,
GetItemInformationLog( bIsStack, pc->item[itemIdx].itemTableIdx, itemIdx, -1 ));
GTH_DeleteMyItem( pc, &pc->item[itemIdx] );
pc->upgradeSourceInventory[i] = -1;
g_DBGameServer->RemoveItem( pc, itemIdx );
}
for( i=0; i<resultItem.optionNumber; i++)
{
if( i == optionIndex )
{
resultItem.optionIdx[optionIndex] = -1;
resultItem.optionValue[optionIndex] = -1;
}
else if( i > optionIndex )
{
resultItem.optionIdx[i-1] = resultItem.optionIdx[i];
resultItem.optionValue[i-1] = resultItem.optionValue[i];
resultItem.optionIdx[i] = -1;
resultItem.optionValue[i] = -1;
}
}
resultItem.optionNumber--;
itemIdx = GTH_AddMyItem( pc, &resultItem );
pc->upgradeResultInventory = itemIdx;
strcpy( generateID, "deleteOptionItem" );
g_DBGameServer->AddItem( pc, &resultItem, itemIdx, generateID );
bIsStack = false;
stackNumber = 1;
if( g_itemTable[resultItem.itemTableIdx].stackFlag )
{
bIsStack = true;
stackNumber = resultItem.durability + 1;
}
g_logSystem->WriteToLog( pc, LOG_CLASS_ITEM, "%d;%d;;;;%s;%s",
LOG_CLASS_ITEM_UPGRADE_RESULT, stackNumber, resultItem.name,
GetItemInformationLog( bIsStack, resultItem.itemTableIdx, itemIdx, -1 ));
return 1;
}
int GTH_QuestScroll_FindTableIndex( playerCharacter_t *pc, int depart, int level, int reward, int selectedQSTableIdx, int checkFlag )
{
int number = 0;
int idx[10];
int ret = 0;
switch ( depart )
{
case 1 :
if ( pc->pcClass != GEN_MENTALITY && pc->pcClass != GEN_WIND )
ret = 1;
break;
case 2 :
if ( pc->pcClass != GEN_WATER && pc->pcClass != GEN_EARTH )
ret = 1;
break;
default :
break;
}
if ( ret == 1 )
return -2;
for (int i=0; i<g_questscrollTableNumber; i++)
{
if ( g_questscrollTable[i].data.scrollType == depart && g_questscrollTable[i].data.level == level )
{
idx[number] = i;
number++;
if ( number > 9 )
break;
}
}
if ( number == 1 )
return idx[0];
if ( number > 1 )
{
if ( checkFlag )
return idx[GTH_Randomize(number)];
else
{
for( i=0; i<number; i++ )
{
if ( idx[i] == selectedQSTableIdx )
return idx[i];
}
}
}
return -1;
}
int GTH_QuestScroll_ObtainProcess( playerCharacter_t *pc, int &reply, int &error, int &reqNak, int &tableIdx, int depart, int level, int reward, int selectedQSTableIdx, int checkFlag )
{
tableIdx = GTH_QuestScroll_FindTableIndex( pc, depart, level, reward, selectedQSTableIdx, checkFlag );
if ( tableIdx == -1 )
{
reply = 0;
error = ERROR_ITEMSYSTEM_18;
return 0;
}
if ( tableIdx == -2 )
{
reply = 0;
error = ERROR_ITEMSYSTEM_20;
return 0;
}
if ( g_questscrollTable[tableIdx].data.rewardField[reward] == -1 )
{
reply = 0;
error = ERROR_ITEMSYSTEM_19;
return 0;
}
if( pc->curItemWeight + g_itemTable[QUESTSCROLL_ITEM_INDEX].weight > pc->calItemWeight )
{
reply = 0;
error = ERROR_ITEMSYSTEM_3;
return 0;
}
reqNak = g_questscrollTable[tableIdx].data.price;
if( pc->curChargeSE < reqNak )
{
reply = 0;
error = ERROR_ITEMSYSTEM_1;
return 0;
}
int inventoryCount = 0;
for( int i = 0; i < MAX_INVENTORY_SIZE; i ++ )
{
if( pc->inventory[i] < 0 ) inventoryCount ++;
}
if( inventoryCount < 1 )
{
reply = 0;
error = ERROR_ITEMSYSTEM_2;
return 0;
}
if( checkFlag ) return 1;
pc->curChargeSE -= reqNak;
int addItemData[6];
addItemData[0] = QUESTSCROLL_ITEM_INDEX;
addItemData[1] = -1;
addItemData[2] = 1;
addItemData[3] = 1;
addItemData[4] = tableIdx;
addItemData[5] = reward;
AI_NPC_AddItem( pc, addItemData );
return 1;
}
int GTH_AutoQuestScroll_ObtainProcess( playerCharacter_t* pPlayer, const int& tableIdx)
{
if( pPlayer->curItemWeight + g_itemTable[AUTOQUESTSCROLL_ITEM_INDEX].weight > pPlayer->calItemWeight )
return ERROR_ITEMSYSTEM_3;
for(int idx = 0; idx < MAX_NUMBER_OF_OWNITEM; idx ++ ) {
if( pPlayer->item[idx].itemTableIdx != AUTOQUESTSCROLL_ITEM_INDEX ) continue;
if( pPlayer->item[idx].optionIdx[0] == tableIdx)
return ERROR_ITEMSYSTEM_22;
}
for(idx = 0; idx < MAX_INVENTORY_SIZE; idx ++ ) {
if(0 > pPlayer->inventory[idx]) return ERROR_ITEMSYSTEM_NONE;
}
return ERROR_ITEMSYSTEM_2;
}
void GenerateMonsterSpawnItem(item_t& item, int itemTableIdx, int monsterLevel)
{
itemTable_t *pTable = &g_itemTable[itemTableIdx];
itemClassTable_t *pCTable = &g_itemClassTable[pTable->classIdx];
InitItem( &item );
InitItemOption();
item.itemTableIdx = itemTableIdx;
strcpy( item.name, pTable->name );
int tableIdx = GTH_RandomizePower( 1, g_summonMonstertableNumber );
item.optionIdx[0] = tableIdx;
item.timer = g_summonMonstertable[tableIdx].SummonTime;
item.optionNumber ++;
chASSERT(item.optionIdx[0] != - 1);
if( item.optionIdx[0] == - 1) return;
}
int DecideMonsterType(int monsterLevel, int & selectedMonsterLevel)
{
int monsterIdx;
selectedMonsterLevel = CalcMonsterLevel(monsterLevel);
bool bBoss = IsBossMonster();
if( bBoss ) {
monsterIdx = FindBossMonster(selectedMonsterLevel);
} else {
monsterIdx = FindNormalMonster(selectedMonsterLevel);
}
return monsterIdx;
}
int CalcMonsterLevel(int monsterLevel)
{
return GTH_RandomizePower( 1, monsterLevel + 10 );
}
bool IsBossMonster()
{
return false;
float rate = GTH_Random();
if( rate <= 0.008 ) return true;
return false;
}
int GetSpawnMapID(int monsterIdx)
{
monsterCharacter_t* pMonster = &g_monster[monsterIdx];
if( pMonster == NULL )
return -1;
return pMonster->spawnWorldIdx;
}
int FindBossMonster(int level)
{
return 0;
}
int FindNormalMonster(int level)
{
int index = -1;
int templevel = level;
bool down = true;
while( index == -1 ) {
index = FindMonster(level);
if( down ) level--;
else level++;
if( level == 0 ) {
level = templevel + 1;
down = false;
} else if( level > 100 ) {
index = -1;
break;
}
}
return index;
}
int FindMonster(int level)
{
std::vector<int> List;
for(int i = 0; i < MAX_NUMBER_OF_MONSTER_TABLE; i++ ) {
if( g_monsterTable[i].level == level )
List.push_back(i);
}
int size = List.size();
if( size == 0 ) return -1;
return List[GTH_RandomizePower(0, size - 1)];
}
void CalcMonsterOptionNum(item_t& item)
{
int monsterLevel = item.optionIdx[0];
chASSERT(monsterLevel >= 0);
int level = g_monsterTable[monsterLevel].level;
int monsterOptionCount = GetOptionNum(monsterLevel, 4);
int playerOptionCount = GetOptionNum(monsterLevel, 5 - monsterOptionCount);
item.optionNumber = monsterOptionCount + playerOptionCount + 1;
float point = 1000 * (1 - pow(0.98, monsterLevel)) * (1 + (item.optionNumber - 1)*0.1) * (GTH_RandomizePower(0.7, 1.0) + 0.2) ;
float totalPoint = point * (1 + playerOptionCount * 0.1);
ShareTotalPoint(item, monsterOptionCount, playerOptionCount, (int)totalPoint);
}
void ShareTotalPoint(item_t &item, int monsterOptNum, int playerOptNum, int totPoint)
{
int tempSlot[5] = { -1, -1, -1, -1, -1};
int tempSlot1[5] = { -1, -1, -1, -1, -1};
int optionIdx = -1, tempIndex = 0;
int maxValue = 0, minValue = 0, resValue = 0, tempValue = 0;
minValue = 10;
maxValue = totPoint - minValue * (monsterOptNum + playerOptNum);
resValue = maxValue - minValue;
srand( (unsigned)time( NULL ) );
int MonGrade = (g_monsterTable[item.optionIdx[0]].level / 10) + 1;
do {
AA:
optionIdx = rand() % MONSTER_OPTION;
if( !CheckOptionGrade(MonGrade, optionIdx) ) goto AA;
if( CheckSameOptionIdx(optionIdx, tempSlot, 5) ) {
tempSlot[tempIndex] = optionIdx;
tempIndex++;
}
} while( tempIndex != monsterOptNum);
optionIdx = -1, tempIndex = 0;
do {
BB:
optionIdx = (rand() % (PLAYER_OPTION - MONSTER_OPTION)) + MONSTER_OPTION;
if( !CheckOptionGrade(MonGrade, optionIdx) ) goto BB;
if( CheckSameOptionIdx(optionIdx, tempSlot1, 5) ) {
tempSlot1[tempIndex] = optionIdx;
tempIndex++;
}
} while( tempIndex != playerOptNum);
if( totPoint < (monsterOptNum + playerOptNum) * 10 || resValue < 0 ) {
minValue = 10;
for(int i = 0; i < monsterOptNum; i++) {
item.optionIdx[i+1] = tempSlot[i];
item.optionValue[i+1] = minValue;
}
for(i = 0; i < playerOptNum; i++) {
item.optionIdx[monsterOptNum+1 + i] = tempSlot1[i];
item.optionValue[monsterOptNum+1 + i] = minValue;
}
return;
}
for(int i = 0; i < monsterOptNum; i++) {
item.optionIdx[i+1] = tempSlot[i];
CheckMinMaxValue(item.optionIdx[i+1], item.optionValue[i+1], resValue, maxValue);
}
int max;
for(i = 0; i < playerOptNum; i++) {
item.optionIdx[monsterOptNum+1 + i] = tempSlot1[i];
max = CheckMinMaxValue(item.optionIdx[monsterOptNum+1 + i], item.optionValue[monsterOptNum+1 + i], resValue, maxValue);
if( i +1 == playerOptNum )
{
if( resValue > max ) resValue = max;
if( resValue < 0 ) resValue = minValue;
item.optionValue[monsterOptNum+1 + i] = resValue;
}
}
}
bool CheckOptionGrade(int MonGrade, int optionIdx)
{
if( g_monsterSpawnOption[optionIdx].optionGrade <= MonGrade )
return true;
return false;
}
bool CheckSameOptionIdx(int index, int *temp, int tempcount )
{
for(int i = 0; i < tempcount; i++)
{
if( index == temp[i] )
return false;
}
return true;
}
int GetOptionNum(int monsterLevel, int limit)
{
int random;
float rate;
int mul[4] = { 100, 90, 70, 50 };
for(int i = 1; i < limit; i++ )
{
random = (int)(GTH_Random() * 100 );
rate = mul[i] * (float)(100.0f / (100.0f + (float)monsterLevel));
if( random > rate ) return i;
}
return limit;
}
int CheckMinMaxValue(int optionIdx, int& optionValue, int& resValue, int maxValue)
{
int min, max, tempValue;
FindSpawnCardMinMaxValue(optionIdx, min, max);
tempValue = rand() % maxValue;
optionValue = min + tempValue;
if( optionValue > max ) optionValue = max;
resValue -= optionValue;
return max;
}
void FindSpawnCardMinMaxValue(int optionIdx, int& minValue, int& maxValue)
{
switch(optionIdx)
{
case MONSTER_OPTION_RA_INC: minValue = 10, maxValue = 400; break;
case MONSTER_OPTION_SA_INC: minValue = 10, maxValue = 50; break;
case MONSTER_OPTION_RA_REC: minValue = 10, maxValue = 50; break;
case MONSTER_OPTION_SA_REC: minValue = 10, maxValue = 70; break;
case MONSTER_OPTION_MIN_ATT: minValue = 10, maxValue = 30; break;
case MONSTER_OPTION_MAX_ATT: minValue = 10, maxValue = 50; break;
case MONSTER_OPTION_MIN_MAG: minValue = 10, maxValue = 400; break;
case MONSTER_OPTION_MAX_MAG: minValue = 10, maxValue = 400; break;
case MONSTER_OPTION_ATT_INC: minValue = 10, maxValue = 400; break;
case MONSTER_OPTION_ASP_INC: minValue = 10, maxValue = 400; break;
case MONSTER_OPTION_DEX_INC: minValue = 10, maxValue = 400; break;
case MONSTER_OPTION_DEF_INC: minValue = 10, maxValue = 400; break;
case MONSTER_OPTION_ESC_INC: minValue = 10, maxValue = 400; break;
case MONSTER_OPTION_PREG_INC: minValue = 10, maxValue = 400; break;
case MONSTER_OPTION_NREG_INC: minValue = 10, maxValue = 400; break;
case MONSTER_OPTION_REG_INC: minValue = 10, maxValue = 400; break;
case MONSTER_OPTION_CRTDMG_INC: minValue = 10, maxValue = 400; break;
case MONSTER_OPTION_CRTRAT_INC: minValue = 10, maxValue = 400; break;
case MONSTER_OPTION_NOSTUN: minValue = 10, maxValue = 400; break;
case PLAYER_OPTION_EXP_INC: minValue = 10, maxValue = 500; break;
case PLAYER_OPTION_GENEXP_INC: minValue = 10, maxValue = 500; break;
case PLAYER_OPTION_GENSKILL_INC: minValue = 10, maxValue = 500; break;
case PLAYER_OPTION_NAC_INC: minValue = 10, maxValue = 500; break;
case PLAYER_OPTION_DROPRATE_INC: minValue = 10, maxValue = 1000; break;
}
}
int GTH_SimulateGenerateItemFromMonster( monsterCharacter_t *monster, item_t* spawnItem, int& nSpawnItem )
{
playerCharacter_t *pc = NULL;
float addPro = 0.0f;
lootItem_t *pLoot;
int i, j;
float r, accPro;
int generateIdx, itemTableIdx, optionNumber;
int lootType, lootIdx;
lootType = LOOTTYPE_EVERYONE;
lootIdx = -1;
pLoot = &monster->basic.lootItem;
if( pLoot == NULL || pLoot->maxLootNumber <= 0 ) return( false );
float fItemDropRate = 1.0f;
if(gGameConfigFlag.m_bMap_Attr_Ratio && SAFE_PCS(monster->mostConEntityIdx))
{
PremiumMap *pMap = g_pc[monster->mostConEntityIdx].GetCurMap();
{
fItemDropRate = pMap->Cur.fAddItemDropRatio;
}
}
for( i = 0; i < pLoot->maxLootNumber; i ++ )
{
accPro = 0.0f;
r = GTH_Random();
float generatePro;
for( j = 0; j < pLoot->generateIdxNumber; j ++ )
{
if( pLoot->generateProbaility[j] == 0.0f ) continue;
generatePro = pLoot->generateProbaility[j] * (g_logic.itemDropRate * fItemDropRate);
accPro += ( generatePro * ( 1.0f + addPro ) );
if( r < accPro ) break;
}
if( j == pLoot->generateIdxNumber ) continue;
generateIdx = pLoot->generateIdx[j];
accPro = 0.0f;
r = GTH_Random();
for( j = 0; j < g_itemGenerateTable[generateIdx].itemNumber; j ++ )
{
if( g_itemGenerateTable[generateIdx].itemPro[j] == 0.0f ) continue;
accPro += g_itemGenerateTable[generateIdx].itemPro[j];
if( r < accPro ) break;
}
if( j == g_itemGenerateTable[generateIdx].itemNumber ) continue;
itemTableIdx = g_itemGenerateTable[generateIdx].itemIdx[j];
if( itemTableIdx < 0 ) continue;
optionNumber = monster->basic.rareItemGrade;
optionNumber = GTH_RandomizePower( 1, ( optionNumber + 1 ) * 10 ) / 10;
if( !SpawnItem( &spawnItem[nSpawnItem], itemTableIdx, monster->basic.optionGrade, monster->basic.level ) )
continue;
if( itemTableIdx == 849 || itemTableIdx == 850 )
{
spawnItem[nSpawnItem].reqLevel = monster->basic.level;
}
else if( itemTableIdx >= 864 && itemTableIdx <= 867 )
{
spawnItem[nSpawnItem].reqLevel = monster->basic.level;
}
nSpawnItem ++;
}
return( true );
}
int Get_EmptyInventoryCount(playerCharacter_t *pc)
{
int empytcount = 0;
for( int i = 0; i < MAX_INVENTORY_SIZE; i ++ )
{
if( pc->inventory[i] >= 0 ) continue;
empytcount++;
}
return empytcount;
}
| C++ |
#if !defined(AFX_CHRISTMASEVENT_H__9C30DEFF_53FB_47D7_9913_165046629D93__INCLUDED_)
#define AFX_CHRISTMASEVENT_H__9C30DEFF_53FB_47D7_9913_165046629D93__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#define CHRISTMASEVENT_LIMITTIME 60 * 1000 * 5
class CChristMasEvent
{
public:
enum enumChristMasProtocol
{
CC_CHRISTMAS_EVENT_REQUEST_USE_SNOWITEM,
GSC_CHRISTMAS_EVENT_REPLY_USE_SNOWITEM,
GSC_CHRISTMAS_EVENT_REPLY_CHRISTEVENT,
CC_CHRISTMAS_EVENT_REQUEST_EQUIPE_ITEM,
GSC_CHRISTMAS_EVENT_REPLY_EQUIPE_ITEM,
CC_CHRISTMAS_EVENT_SETING,
CC_CHRISTMAS_EVENT_REQUEST_WORLD_STATE,
GSC_CHRISTMAS_EVENT_REQUEST_WORLD_STATE,
CC_CHRISTMAS_EVENT_NOTICE,
CC_CHRISTMAS_BROAD_CASTING_EVENT_SETING,
};
enum enumEventWorldState
{
CHRISTMAS_EVENT_WORLD_PROGRESS,
CHRISTMAS_EVENT_WORLD_NONE
};
enum enumChristMasEventState
{
EVENT_INACTIVE,
EVENT_ACTIVE
};
enum enumChristMasEventError
{
ERROR_CHRISTMAS_EVENT_USE_ITEM,
ERROR_CHRISTMAS_EVENT_USE_ITEM2,
ERROR_CHRISTMAS_EVENT_EQUIP_ITEM,
ERROR_CHRISTMAS_EVENT_ACTIVE,
};
enum enumChristMasItemIdx
{
SANTA_WEAPON = 384,
SANTA_UPPER = 497,
SANTA_LOWER = 507,
SANTA_GLOVES = 385,
SANTA_BOOTS = 405,
};
public:
struct EventWorld
{
int m_WorldIdx;
float m_EventLimitTime;
enumEventWorldState m_EventState;
}m_EventWorld[MAX_WORLDS];
enumChristMasEventState m_EventState;
public:
void GTH_Process_ChristMas_Event();
void GTH_ProcessMessage_ChristMas_UseItem(void);
void GTH_SendMessage_Reply_ChristMas_UseItem(playerCharacter_t*, int reply, int error, int invenpos);
void GTH_SendMessage_BroadCast_ChristMasEvent(playerCharacter_t*, int worldidx);
void GTH_ProcessMessage_Request_WordlState();
void GTH_SendMessage_Reply_WordlState(playerCharacter_t*, int reply, int state);
void GTH_SendMessage_Reply_WordlStateToMemberServer(int state);
void GTH_SendMessage_Reply_WordlStateToManagerServer(int state);
void GTH_ProcessMessageBroadCastEventSeting();
void GTH_ProcessMessageEventSeting();
BOOL GTH_IsChristMasItem(int ItemIdx);
BOOL GTH_IsEnableEquipChristMasItem();
BOOL GTH_IsEquipChristMasItem();
BOOL GTH_IsAllowItemWerePos(int ItemIdx);
void GTH_ProcessMessage_Event_UserNotice();
public:
void ProcessEventTIme();
void InitChristMasEvent();
public:
CChristMasEvent();
virtual ~CChristMasEvent();
};
#endif
| C++ |
#include "..\\global.h"
#include "../Tools/CTools.h"
extern CTools* gcpTools;
void GTH_InitGuildList()
{
int i, j, max;
max = MAX_GUILD_MASTERS+MAX_GUILD_SUBMASTERS+MAX_GUILD_FACTIONMASTERS+MAX_GUILD_MATES;
for( i=0; i<MAX_GUILDS; i++ )
{
memset( &g_guild[i], 0, sizeof(guild_t) );
g_guild[i].idx = -1;
g_guild[i].serverGroupID = -1;
for( j=0; j<max; j++ )
{
g_guild[i].userJob[j] = -1;
g_guild[i].userLevel[j] = 0;
g_guild[i].userLocation[j] = -1;
}
}
}
void GTH_InitGuild( guild_t *guild )
{
int i, max;
int idx, serverGroupID;
char name[GUILDNAMESTRING];
memset( name, 0, GUILDNAMESTRING );
idx = guild->idx;
serverGroupID = guild->serverGroupID;
strcpy( name, guild->name );
memset( guild, 0, sizeof(guild_t) );
guild->idx = idx;
guild->serverGroupID = serverGroupID;
strcpy( guild->name, name );
max = MAX_GUILD_MASTERS+MAX_GUILD_SUBMASTERS+MAX_GUILD_FACTIONMASTERS+MAX_GUILD_MATES;
for( i=0; i<max; i++ )
{
guild->userJob[i] = -1;
guild->userLevel[i] = 0;
guild->userLocation[i] = -1;
}
}
int GTH_GetEmptyGuildIndex()
{
int i;
for( i=0; i<MAX_GUILDS; i++ )
{
if( g_guild[i].name[0] == 0 ) break;
}
if( i == MAX_GUILDS ) return -1;
return i;
}
int GTH_GetGuildEmptyIndex( short guildIdx, int rank )
{
if( guildIdx < 0 || guildIdx >= MAX_GUILDS )
return -1;
int i;
if( rank == GUILD_SUBMASTER )
{
for( i=0; i<MAX_GUILD_SUBMASTERS; i++ )
{
if( g_guild[guildIdx].subMasterName[i][0] == 0 ) break;
}
if( i == MAX_GUILD_SUBMASTERS ) return -1;
}
else if( rank == GUILD_FACTIONMASTER )
{
for( i=0; i<MAX_GUILD_FACTIONMASTERS; i++ )
{
if( g_guild[guildIdx].factionMasterName[i][0] == 0 ) break;
}
if( i == MAX_GUILD_FACTIONMASTERS ) return -1;
}
else if( rank == GUILD_MATE )
{
for( i=0; i<MAX_GUILD_MATES; i++ )
{
if( g_guild[guildIdx].mateName[i][0] == 0 ) break;
}
if( i == MAX_GUILD_MATES ) return -1;
}
return i;
}
int GTH_GetGuildMemberIndex(short guildIdx,int rank,char *name)
{
if( guildIdx < 0 || guildIdx >= MAX_GUILDS ) return -1;
int idx=-1;
switch(rank){
case GUILD_MASTER:
if(0 == stricmp( g_guild[guildIdx].masterName,name)) return 0;
return -1;
case GUILD_SUBMASTER:
for(idx=0; idx < MAX_GUILD_SUBMASTERS; idx++ ){
if(0 == stricmp( g_guild[guildIdx].subMasterName[idx], name)) return idx;
}
return -1;
case GUILD_FACTIONMASTER:
for(idx=0; idx < MAX_GUILD_FACTIONMASTERS; idx++){
if(0 == stricmp( g_guild[guildIdx].factionMasterName[idx],name)) return idx;
}
return -1;
case GUILD_MATE:
for( idx=0; idx < MAX_GUILD_MATES; idx++ ){
if(0 == stricmp(g_guild[guildIdx].mateName[idx],name)) return idx;
}
return -1;
}
return -1;
}
int GTH_IsGuildMemberName( short guildIdx, int rank, char *name )
{
if( guildIdx < 0 || guildIdx >= MAX_GUILDS )
return 0;
int i;
if( rank == GUILD_SUBMASTER )
{
for( i=0; i<MAX_GUILD_SUBMASTERS; i++ )
{
if( stricmp( g_guild[guildIdx].subMasterName[i], name ) == 0 ) break;
}
if( i == MAX_GUILD_SUBMASTERS ) return 0;
}
else if( rank == GUILD_FACTIONMASTER )
{
for( i=0; i<MAX_GUILD_FACTIONMASTERS; i++ )
{
if( stricmp( g_guild[guildIdx].factionMasterName[i], name ) == 0 ) break;
}
if( i == MAX_GUILD_FACTIONMASTERS ) return 0;
}
else if( rank == GUILD_MATE )
{
for( i=0; i<MAX_GUILD_MATES; i++ )
{
if( stricmp( g_guild[guildIdx].mateName[i], name ) == 0 ) break;
}
if( i == MAX_GUILD_MATES ) return 0;
}
return 1;
}
int GTH_GetMateIndexByName( short guildIdx, char *name )
{
if( guildIdx < 0 )
return -1;
int i;
for( i=0; i<MAX_GUILD_MATES; i++ )
{
if( g_guild[guildIdx].mateName[i][0] == 0 ) return -1;
if( stricmp( g_guild[guildIdx].mateName[i], name ) == 0 ) break;
}
if( i == MAX_GUILD_MATES ) return -1;
return i;
}
int GTH_GetGuildIndexByName( char *guildName )
{
int i;
for( i=0; i<MAX_GUILDS; i++ )
{
if( stricmp(g_guild[i].name, guildName) == 0 ) break;
}
if( i == MAX_GUILDS ) return -1;
return i;
}
short GTH_GuildOrganize( char *name, char* guildName, char* guildMark, int serverGroupID, int &error )
{
if( GTH_GetGuildIndexByName( guildName ) != -1 )
{
error = GUILD_ERROR_SAMEGUILDNAME;
return -1;
}
short guildIdx = GTH_GetEmptyGuildIndex();
if( guildIdx < 0 )
{
error = GUILD_ERROR_MAXOVERGUILDNUM;
return -1;
}
memset( &g_guild[guildIdx], 0, sizeof( guild_t ) );
g_guild[guildIdx].idx = guildIdx;
g_guild[guildIdx].serverGroupID = serverGroupID;
strncpy(g_guild[guildIdx].name, guildName,GUILDNAMESTRING);
g_guild[guildIdx].name[GUILDNAMESTRING]=NULL;
memcpy( g_guild[guildIdx].mark, guildMark, GUILDMARKSIZE );
g_guild[guildIdx].markUpdateTime = 0;
g_guild[guildIdx].famePoint = 0;
g_guild[guildIdx].expPoint = 0;
g_guild[guildIdx].raidPoint = 0;
g_guild[guildIdx].pvpPoint = 0;
g_guild[guildIdx].hunterPoint = 0;
g_guild[guildIdx].level = 1;
strncpy(g_guild[guildIdx].masterName, name ,NAMESTRING);
g_guild[guildIdx].masterName[NAMESTRING]=NULL;
entityPCList_t pl;
if( g_entityListMng.FindPCList( name, &pl ) != -1 )
{
g_guild[guildIdx].userJob[0] = pl.job;
g_guild[guildIdx].userLevel[0] = pl.level;
g_guild[guildIdx].userLocation[0] = pl.worldIdx;
}
g_DBGameServer->AddGuild( guildIdx );
GTH_GuildUpdate( guildIdx, GUILD_UPDATE_ALL, GUILD_ALLRANK, -1, GUILD_MASTER, -1 );
return guildIdx;
}
int GTH_GuildDisorganize( short guildIdx, char *name, int &error )
{
if( guildIdx < 0 )
{
error = GUILD_ERROR_NOGUILD;
return -1;
}
if( g_guild[guildIdx].idx == -1 && g_guild[guildIdx].name[0] == 0 )
{
error = GUILD_ERROR_NOGUILD;
return -1;
}
if( stricmp( g_guild[guildIdx].masterName, name ) != 0 )
{
error = GUILD_ERROR_NOMASTER;
return -1;
}
g_DBGameServer->RemoveGuild( guildIdx, g_config.serverGroupNo );
GTH_GuildUpdateDisorganize( guildIdx, 1, 0 );
GTH_InitGuild( &g_guild[guildIdx] );
return 0;
}
int GTH_GuildAddUser( short guildIdx, char *name, int job, int &rankIdxInGuild, int &error )
{
int update = 0;
entityPCList_t pl;
if( guildIdx < 0 || guildIdx >= MAX_GUILDS )
return -1;
int mateIdx = GTH_GetGuildEmptyIndex( guildIdx, GUILD_MATE );
if( mateIdx == -1 )
{
error = GUILD_ERROR_NOTEMPTY;
return -1;
}
if( GTH_GetGuildMemberIndex( guildIdx, GUILD_MATE, name ) != -1 ||
GTH_GetGuildMemberIndex( guildIdx, GUILD_FACTIONMASTER, name ) != -1 ||
GTH_GetGuildMemberIndex( guildIdx, GUILD_SUBMASTER, name ) != -1 ||
GTH_GetGuildMemberIndex( guildIdx, GUILD_MASTER, name ) != -1 )
{
error = GUILD_ERROR_SAMEMATENAME;
return -1;
}
if( g_entityListMng.FindPCList( name, &pl ) != -1 )
{
strcpy( g_guild[guildIdx].mateName[mateIdx], name );
rankIdxInGuild = mateIdx;
int userIdx = MAX_GUILD_MASTERS + MAX_GUILD_SUBMASTERS + MAX_GUILD_FACTIONMASTERS + mateIdx;
g_guild[guildIdx].userJob[userIdx] = pl.job;
g_guild[guildIdx].userLevel[userIdx] = pl.level;
g_guild[guildIdx].userLocation[userIdx] = pl.worldIdx;
update = GUILD_UPDATE_ADDUSER | GUILD_MATENAME;
}
GTH_GuildUpdate( guildIdx, GUILD_UPDATE_ALL, GUILD_ALLRANK, -1, GUILD_MATE, mateIdx );
GTH_GuildUpdate( guildIdx, update, GUILD_MATE, mateIdx, GUILD_ALLRANK, -1 );
g_DBGameServer->SaveGuild( guildIdx );
return 0;
}
int GTH_GuildChangeMaster( short guildIdx, char *reqName, char *accName, int job, int &rankIdxInGuild, int &error )
{
int update = 0;
entityPCList_t pl;
if( guildIdx < 0 || guildIdx >= MAX_GUILDS )
return -1;
int smIdx = GTH_GetGuildMemberIndex( guildIdx, GUILD_SUBMASTER, accName );
if( smIdx != -1 )
{
if( GTH_GuildRemoveMaster( guildIdx, reqName, error ) != 0 )
return -1;
memset( g_guild[guildIdx].subMasterName[smIdx], 0, NAMESTRING );
int userIdx = MAX_GUILD_MASTERS + smIdx;
g_guild[guildIdx].userJob[userIdx] = -1;
g_guild[guildIdx].userLevel[userIdx] = 0;
g_guild[guildIdx].userLocation[userIdx] = -1;
update = GUILD_UPDATE_REMOVEUSER | GUILD_SUBMASTERNAME;
GTH_GuildUpdate( guildIdx, update, GUILD_SUBMASTER, smIdx, GUILD_ALLRANK, -1 );
}
else
{
int fmIdx = GTH_GetGuildMemberIndex( guildIdx, GUILD_FACTIONMASTER, accName );
if( fmIdx != -1 )
{
if( GTH_GuildRemoveMaster( guildIdx, reqName, error ) != 0 )
return -1;
memset( g_guild[guildIdx].factionMasterName[fmIdx], 0, NAMESTRING );
int userIdx = MAX_GUILD_MASTERS + MAX_GUILD_SUBMASTERS + fmIdx;
g_guild[guildIdx].userJob[userIdx] = -1;
g_guild[guildIdx].userLevel[userIdx] = 0;
g_guild[guildIdx].userLocation[userIdx] = -1;
update = GUILD_UPDATE_REMOVEUSER | GUILD_FACTIONMASTERNAME;
GTH_GuildUpdate( guildIdx, update, GUILD_FACTIONMASTER, fmIdx, GUILD_ALLRANK, -1 );
}
else
{
int mateIdx = GTH_GetGuildMemberIndex( guildIdx, GUILD_MATE, accName );
if( mateIdx != -1 )
{
bool tempFlag = false;
if( GTH_GuildRemoveMaster( guildIdx, reqName, error ) != 0 )
{
if( error == GUILD_ERROR_NOTEMPTY )
tempFlag = true;
else
return -1;
}
memset( g_guild[guildIdx].mateName[mateIdx], 0, NAMESTRING );
int userIdx = MAX_GUILD_MASTERS + MAX_GUILD_SUBMASTERS + MAX_GUILD_FACTIONMASTERS + mateIdx;
g_guild[guildIdx].userJob[userIdx] = -1;
g_guild[guildIdx].userLevel[userIdx] = 0;
g_guild[guildIdx].userLocation[userIdx] = -1;
update = GUILD_UPDATE_REMOVEUSER | GUILD_MATENAME;
GTH_GuildUpdate( guildIdx, update, GUILD_MATE, mateIdx, GUILD_ALLRANK, -1 );
if( tempFlag )
{
GTH_GuildRemoveMaster( guildIdx, reqName, error );
}
}
else
{
error = GUILD_ERROR_NOTJOINED;
return -1;
}
}
}
strcpy( g_guild[guildIdx].masterName, accName );
if( g_entityListMng.FindPCList( accName, &pl ) != -1 )
{
int userIdx = 0;
g_guild[guildIdx].userJob[userIdx] = pl.job;
g_guild[guildIdx].userLevel[userIdx] = pl.level;
g_guild[guildIdx].userLocation[userIdx] = pl.worldIdx;
}
update = GUILD_UPDATE_ADDUSER | GUILD_MASTERNAME;
GTH_GuildUpdate( guildIdx, GUILD_UPDATE_ALL, GUILD_ALLRANK, -1, GUILD_MASTER, 0 );
GTH_GuildUpdate( guildIdx, update, GUILD_MASTER, 0, GUILD_ALLRANK, -1 );
g_DBGameServer->SaveGuild( guildIdx );
return 0;
}
int GTH_GuildAddSubMaster( short guildIdx, char *name, int job, int &rankIdxInGuild, int &error )
{
int update = 0;
entityPCList_t pl;
if( guildIdx < 0 || guildIdx >= MAX_GUILDS )
return -1;
int smIdx = GTH_GetGuildEmptyIndex( guildIdx, GUILD_SUBMASTER );
if( smIdx == -1 )
{
error = GUILD_ERROR_NOTEMPTY;
return -1;
}
else if( GTH_GetGuildMemberIndex( guildIdx, GUILD_SUBMASTER, name ) != -1)
{
error = GUILD_ERROR_SAMEMATENAME;
return -1;
}
if( GTH_GetGuildMemberIndex( guildIdx, GUILD_FACTIONMASTER, name ) != -1 )
{
error = GUILD_ERROR_CANNOTAPPOINT;
return -1;
}
int mateIdx = GTH_GetGuildMemberIndex( guildIdx, GUILD_MATE, name );
if( mateIdx != -1 )
{
memset( g_guild[guildIdx].mateName[mateIdx], 0, NAMESTRING );
int userIdx = MAX_GUILD_MASTERS + MAX_GUILD_SUBMASTERS + MAX_GUILD_FACTIONMASTERS + mateIdx;
g_guild[guildIdx].userJob[userIdx] = -1;
g_guild[guildIdx].userLevel[userIdx] = 0;
g_guild[guildIdx].userLocation[userIdx] = -1;
update = GUILD_UPDATE_REMOVEUSER | GUILD_MATENAME;
GTH_GuildUpdate( guildIdx, update, GUILD_MATE, mateIdx, GUILD_ALLRANK, -1 );
}
else
{
error = GUILD_ERROR_NOTJOINED;
return -1;
}
update = 0;
strcpy( g_guild[guildIdx].subMasterName[smIdx], name );
if( g_entityListMng.FindPCList( name, &pl ) != -1 )
{
int userIdx = MAX_GUILD_MASTERS + smIdx;
g_guild[guildIdx].userJob[userIdx] = pl.job;
g_guild[guildIdx].userLevel[userIdx] = pl.level;
g_guild[guildIdx].userLocation[userIdx] = pl.worldIdx;
update = GUILD_UPDATE_ADDUSER | GUILD_SUBMASTERNAME;
}
GTH_GuildUpdate( guildIdx, GUILD_UPDATE_ALL, GUILD_ALLRANK, -1, GUILD_SUBMASTER, smIdx );
GTH_GuildUpdate( guildIdx, update, GUILD_SUBMASTER, smIdx, GUILD_ALLRANK, -1 );
g_DBGameServer->SaveGuild( guildIdx );
return 0;
}
int GTH_GuildAddFactionMaster( short guildIdx, char *name, int job, int &rankIdxInGuild, int &error )
{
int update = 0;
entityPCList_t pl;
if( guildIdx < 0 || guildIdx >= MAX_GUILDS )
return -1;
int fmIdx = GTH_GetGenTypeFromJob(job);
if( fmIdx == -1 )
{
return -1;
}
else if( g_guild[guildIdx].factionMasterName[fmIdx][0] != 0 )
{
if( !stricmp( g_guild[guildIdx].factionMasterName[fmIdx], name ) )
{
error = GUILD_ERROR_SAMEMATENAME;
return -1;
}
else
{
error = GUILD_ERROR_NOTEMPTY;
return -1;
}
}
if( GTH_GetGuildMemberIndex( guildIdx, GUILD_SUBMASTER, name ) != -1 )
{
error = GUILD_ERROR_CANNOTAPPOINT;
return -1;
}
int mateIdx = GTH_GetGuildMemberIndex( guildIdx, GUILD_MATE, name );
if( mateIdx != -1 )
{
memset( g_guild[guildIdx].mateName[mateIdx], 0, NAMESTRING );
int userIdx = MAX_GUILD_MASTERS + MAX_GUILD_SUBMASTERS + MAX_GUILD_FACTIONMASTERS + mateIdx;
g_guild[guildIdx].userJob[userIdx] = -1;
g_guild[guildIdx].userLevel[userIdx] = 0;
g_guild[guildIdx].userLocation[userIdx] = -1;
update = GUILD_UPDATE_REMOVEUSER | GUILD_MATENAME;
GTH_GuildUpdate( guildIdx, update, GUILD_MATE, mateIdx, GUILD_ALLRANK, -1 );
}
else
{
error = GUILD_ERROR_NOTJOINED;
return -1;
}
update = 0;
strcpy( g_guild[guildIdx].factionMasterName[fmIdx], name );
if( g_entityListMng.FindPCList( name, &pl ) != -1 )
{
int userIdx = MAX_GUILD_MASTERS + MAX_GUILD_SUBMASTERS + fmIdx;
g_guild[guildIdx].userJob[userIdx] = pl.job;
g_guild[guildIdx].userLevel[userIdx] = pl.level;
g_guild[guildIdx].userLocation[userIdx] = pl.worldIdx;
update = GUILD_UPDATE_ADDUSER | GUILD_FACTIONMASTERNAME;
}
GTH_GuildUpdate( guildIdx, GUILD_UPDATE_ALL, GUILD_ALLRANK, -1, GUILD_FACTIONMASTER, fmIdx );
GTH_GuildUpdate( guildIdx, update, GUILD_FACTIONMASTER, fmIdx, GUILD_ALLRANK, -1 );
g_DBGameServer->SaveGuild( guildIdx );
return 0;
}
int GTH_GuildRemoveUser( short guildIdx, char *name, int &error )
{
int i, update;
int idx;
if( guildIdx < 0 )
{
return -1;
}
for( i=0; i<MAX_GUILD_SUBMASTERS; i++)
{
if( g_guild[guildIdx].subMasterName[i][0] == 0 ) continue;
if( stricmp( g_guild[guildIdx].subMasterName[i], name ) == 0 )
{
memset( g_guild[guildIdx].subMasterName[i], 0, NAMESTRING );
idx = MAX_GUILD_MASTERS + i;
g_guild[guildIdx].userJob[idx] = -1;
g_guild[guildIdx].userLevel[idx] = 0;
g_guild[guildIdx].userLocation[idx] = -1;
update = GUILD_UPDATE_REMOVEUSER | GUILD_SUBMASTERNAME;
GTH_GuildUpdate( guildIdx, update, GUILD_SUBMASTER, i, GUILD_ALLRANK, -1 );
g_DBGameServer->SaveGuild( guildIdx );
return 0;
}
}
for( i=0; i<MAX_GUILD_FACTIONMASTERS; i++ )
{
if( g_guild[guildIdx].factionMasterName[i][0] == 0 ) continue;
if( stricmp( g_guild[guildIdx].factionMasterName[i], name ) == 0 )
{
memset( g_guild[guildIdx].factionMasterName[i], 0, NAMESTRING );
idx = MAX_GUILD_MASTERS + MAX_GUILD_SUBMASTERS + i;
g_guild[guildIdx].userJob[idx] = -1;
g_guild[guildIdx].userLevel[idx] = 0;
g_guild[guildIdx].userLocation[idx] = -1;
update = GUILD_UPDATE_REMOVEUSER | GUILD_FACTIONMASTERNAME;
GTH_GuildUpdate( guildIdx, update, GUILD_FACTIONMASTER, i, GUILD_ALLRANK, -1 );
g_DBGameServer->SaveGuild( guildIdx );
return 0;
}
}
for( i=0; i<MAX_GUILD_MATES; i++)
{
if( g_guild[guildIdx].mateName[i][0] == 0 ) continue;
if( stricmp( g_guild[guildIdx].mateName[i], name ) == 0 )
{
memset( g_guild[guildIdx].mateName[i], 0, NAMESTRING );
idx = MAX_GUILD_MASTERS + MAX_GUILD_SUBMASTERS + MAX_GUILD_FACTIONMASTERS + i;
g_guild[guildIdx].userJob[idx] = -1;
g_guild[guildIdx].userLevel[idx] = 0;
g_guild[guildIdx].userLocation[idx] = -1;
update = GUILD_UPDATE_REMOVEUSER | GUILD_MATENAME;
GTH_GuildUpdate( guildIdx, update, GUILD_MATE, i, GUILD_ALLRANK, -1 );
g_DBGameServer->SaveGuild( guildIdx );
return 0;
}
}
error = GUILD_ERROR_CANNOTFIND;
return -1;
}
int GTH_GuildRemoveMaster( short guildIdx, char *name, int &error )
{
int update1, update2;
int emptyIdx, idx;
entityPCList_t pl;
if( guildIdx < 0 || guildIdx >= MAX_GUILDS )
{
error = -1;
return -1;
}
if( stricmp( g_guild[guildIdx].masterName, name ) == 0 )
{
emptyIdx = GTH_GetGuildEmptyIndex( guildIdx, GUILD_MATE );
if( emptyIdx == -1 )
{
error = GUILD_ERROR_NOTEMPTY;
return -1;
}
else
{
if( stricmp( g_guild[guildIdx].mateName[emptyIdx], name ) == 0 )
{
error = GUILD_ERROR_CANNOTAPPOINT;
return -1;
}
}
memset( g_guild[guildIdx].masterName, 0, NAMESTRING );
idx = 0;
g_guild[guildIdx].userJob[idx] = -1;
g_guild[guildIdx].userLevel[idx] = 0;
g_guild[guildIdx].userLocation[idx] = -1;
update1 = GUILD_UPDATE_REMOVEUSER | GUILD_MASTERNAME;
strcpy( g_guild[guildIdx].mateName[emptyIdx], name );
idx = MAX_GUILD_MASTERS + MAX_GUILD_SUBMASTERS + MAX_GUILD_FACTIONMASTERS + emptyIdx;
if( g_entityListMng.FindPCList( name, &pl ) != -1 )
{
g_guild[guildIdx].userJob[idx] = pl.job;
g_guild[guildIdx].userLevel[idx] = pl.level;
g_guild[guildIdx].userLocation[idx] = pl.worldIdx;
}
update2 = GUILD_UPDATE_ADDUSER | GUILD_MATENAME;
GTH_GuildUpdate( guildIdx, update1, GUILD_MASTER, 0, GUILD_ALLRANK, -1 );
GTH_GuildUpdate( guildIdx, update2, GUILD_MATE, emptyIdx, GUILD_ALLRANK, -1 );
g_DBGameServer->SaveGuild( guildIdx );
return 0;
}
error = GUILD_ERROR_CANNOTFIND;
return -1;
}
int GTH_GuildRemoveSubMaster( short guildIdx, char *name, int &error )
{
int i;
int update1, update2;
int emptyIdx, idx;
entityPCList_t pl;
if( guildIdx < 0 || guildIdx >= MAX_GUILDS )
{
error = -1;
return -1;
}
for( i=0; i<MAX_GUILD_SUBMASTERS; i++)
{
if( g_guild[guildIdx].subMasterName[i][0] == 0 ) continue;
if( stricmp( g_guild[guildIdx].subMasterName[i], name ) == 0 )
{
emptyIdx = GTH_GetGuildEmptyIndex( guildIdx, GUILD_MATE );
if( emptyIdx == -1 )
{
error = GUILD_ERROR_NOTEMPTY;
return -1;
}
else
{
if( stricmp( g_guild[guildIdx].mateName[emptyIdx], name ) == 0 )
{
error = GUILD_ERROR_SAMEMATENAME;
return -1;
}
}
memset( g_guild[guildIdx].subMasterName[i], 0, NAMESTRING );
idx = MAX_GUILD_MASTERS + i;
g_guild[guildIdx].userJob[idx] = -1;
g_guild[guildIdx].userLevel[idx] = 0;
g_guild[guildIdx].userLocation[idx] = -1;
update1 = GUILD_UPDATE_REMOVEUSER | GUILD_SUBMASTERNAME;
strcpy( g_guild[guildIdx].mateName[emptyIdx], name );
idx = MAX_GUILD_MASTERS + MAX_GUILD_SUBMASTERS + MAX_GUILD_FACTIONMASTERS + emptyIdx;
if( g_entityListMng.FindPCList( name, &pl ) != -1 )
{
g_guild[guildIdx].userJob[idx] = pl.job;
g_guild[guildIdx].userLevel[idx] = pl.level;
g_guild[guildIdx].userLocation[idx] = pl.worldIdx;
}
else
{
g_guild[guildIdx].userJob[idx] = -1;
g_guild[guildIdx].userLevel[idx] = 0;
g_guild[guildIdx].userLocation[idx] = -1;
}
update2 = GUILD_UPDATE_ADDUSER | GUILD_MATENAME;
GTH_GuildUpdate( guildIdx, update1, GUILD_SUBMASTER, i, GUILD_ALLRANK, -1 );
GTH_GuildUpdate( guildIdx, update2, GUILD_MATE, emptyIdx, GUILD_ALLRANK, -1 );
g_DBGameServer->SaveGuild( guildIdx );
return 0;
}
}
error = GUILD_ERROR_CANNOTFIND;
return -1;
}
int GTH_GuildRemoveFactionMaster( short guildIdx, char *name, int &error )
{
int i;
int update1, update2;
int emptyIdx, idx;
entityPCList_t pl;
if( guildIdx < 0 || guildIdx >= MAX_GUILDS )
{
error = -1;
return -1;
}
for( i=0; i<MAX_GUILD_FACTIONMASTERS; i++ )
{
if( g_guild[guildIdx].factionMasterName[i][0] == 0 ) continue;
if( stricmp( g_guild[guildIdx].factionMasterName[i], name ) == 0 )
{
emptyIdx = GTH_GetGuildEmptyIndex( guildIdx, GUILD_MATE );
if( emptyIdx == -1 )
{
error = GUILD_ERROR_NOTEMPTY;
return -1;
}
else
{
if( stricmp( g_guild[guildIdx].mateName[emptyIdx], name ) == 0 )
{
error = GUILD_ERROR_SAMEMATENAME;
return -1;
}
}
memset( g_guild[guildIdx].factionMasterName[i], 0, NAMESTRING );
idx = MAX_GUILD_MASTERS + MAX_GUILD_SUBMASTERS + i;
g_guild[guildIdx].userJob[idx] = -1;
g_guild[guildIdx].userLevel[idx] = 0;
g_guild[guildIdx].userLocation[idx] = -1;
update1 = GUILD_UPDATE_REMOVEUSER | GUILD_FACTIONMASTERNAME;
strcpy( g_guild[guildIdx].mateName[emptyIdx], name );
idx = MAX_GUILD_MASTERS + MAX_GUILD_SUBMASTERS + MAX_GUILD_FACTIONMASTERS + emptyIdx;
if( g_entityListMng.FindPCList( name, &pl ) != -1 )
{
g_guild[guildIdx].userJob[idx] = pl.job;
g_guild[guildIdx].userLevel[idx] = pl.level;
g_guild[guildIdx].userLocation[idx] = pl.worldIdx;
}
else
{
g_guild[guildIdx].userJob[idx] = -1;
g_guild[guildIdx].userLevel[idx] = 0;
g_guild[guildIdx].userLocation[idx] = -1;
}
update2 = GUILD_UPDATE_ADDUSER | GUILD_MATENAME;
GTH_GuildUpdate( guildIdx, update1, GUILD_FACTIONMASTER, i, GUILD_ALLRANK, -1 );
GTH_GuildUpdate( guildIdx, update2, GUILD_MATE, emptyIdx, GUILD_ALLRANK, -1 );
g_DBGameServer->SaveGuild( guildIdx );
return 0;
}
}
error = GUILD_ERROR_CANNOTFIND;
return -1;
}
void GTH_GuildUpdateUser( short guildIdx, char *name, int rank, int rankIdx, int type, int value )
{
int idx = -1;
if( rank == GUILD_MATE )
{
if( g_guild[guildIdx].mateName[rankIdx][0] == 0 ) return;
if( stricmp( g_guild[guildIdx].mateName[rankIdx], name ) == 0 )
{
idx = MAX_GUILD_MASTERS+MAX_GUILD_SUBMASTERS+MAX_GUILD_FACTIONMASTERS+rankIdx;
}
}
else if( rank == GUILD_FACTIONMASTER )
{
if( g_guild[guildIdx].factionMasterName[rankIdx][0] == 0 ) return;
if( stricmp( g_guild[guildIdx].factionMasterName[rankIdx], name ) == 0 )
{
idx = MAX_GUILD_MASTERS+MAX_GUILD_SUBMASTERS+rankIdx;
}
}
else if( rank == GUILD_SUBMASTER )
{
if( g_guild[guildIdx].subMasterName[rankIdx][0] == 0 ) return;
if( stricmp( g_guild[guildIdx].subMasterName[rankIdx], name ) == 0 )
{
idx = MAX_GUILD_MASTERS+rankIdx;
}
}
else if( rank = GUILD_MASTER )
{
if( stricmp( g_guild[guildIdx].masterName, name ) == 0 )
{
idx = 0;
}
}
if( idx == -1 ) return;
if( type == GUILD_USERLEVEL )
{
g_guild[guildIdx].userLevel[idx] = value;
}
else if( type == GUILD_USERJOB )
{
g_guild[guildIdx].userJob[idx] = value;
}
else if( type == GUILD_USERLOCATION )
{
g_guild[guildIdx].userLocation[idx] = value;
}
GTH_GuildUpdate( guildIdx, type, rank, rankIdx, GUILD_ALLRANK, -1 );
}
void GTH_GuildUpdate( short guildIdx, int update, int value1, int value2, int rank, int rankIdx )
{
int i;
entityPCList_t pl;
ShowLogInfo( "GuildUpdate, %d, %d, %d, what %d, %d, To %d, %d", guildIdx, update, value1, value2, rank, rankIdx );
if( ( rank & GUILD_MASTER ) != 0 )
{
if( g_entityListMng.FindPCList( g_guild[guildIdx].masterName, &pl ) != -1 )
{
if( pl.serverIdx == 0 )
{
GTH_SendMessage_Guild_Update_To_Client( &g_pc[pl.idxOnServer], &g_guild[guildIdx], update, value1, value2 );
}
else
{
GTH_SendMessage_Guild_Update_To_MemberServer( pl.serverIdx, pl.idxOnServer, &g_guild[guildIdx], update, value1, value2 );
}
}
}
if( ( rank & GUILD_SUBMASTER ) != 0 )
{
for( i=0; i<MAX_GUILD_SUBMASTERS; i++)
{
if( rankIdx == -1 || rankIdx == i )
{
if( g_guild[guildIdx].subMasterName[i][0] != 0 )
{
if( g_entityListMng.FindPCList( g_guild[guildIdx].subMasterName[i], &pl ) != -1 )
{
if( pl.serverIdx == 0 )
{
GTH_SendMessage_Guild_Update_To_Client( &g_pc[pl.idxOnServer], &g_guild[guildIdx], update, value1, value2 );
}
else
{
GTH_SendMessage_Guild_Update_To_MemberServer( pl.serverIdx, pl.idxOnServer, &g_guild[guildIdx], update, value1, value2 );
}
}
}
}
}
}
if( ( rank & GUILD_FACTIONMASTER ) != 0 )
{
for( i=0; i<MAX_GUILD_FACTIONMASTERS; i++)
{
if( rankIdx == -1 || rankIdx == i )
{
if( g_guild[guildIdx].factionMasterName[i][0] != 0 )
{
if( g_entityListMng.FindPCList( g_guild[guildIdx].factionMasterName[i], &pl ) != -1 )
{
if( pl.serverIdx == 0 )
{
GTH_SendMessage_Guild_Update_To_Client( &g_pc[pl.idxOnServer], &g_guild[guildIdx], update, value1, value2 );
}
else
{
GTH_SendMessage_Guild_Update_To_MemberServer( pl.serverIdx, pl.idxOnServer, &g_guild[guildIdx], update, value1, value2 );
}
}
}
}
}
}
if( ( rank & GUILD_MATE ) != 0 )
{
for( i=0; i<MAX_GUILD_MATES; i++)
{
if( rankIdx == -1 || rankIdx == i )
{
if( g_guild[guildIdx].mateName[i][0] != 0 )
{
if( g_entityListMng.FindPCList( g_guild[guildIdx].mateName[i], &pl ) != -1 )
{
if( pl.serverIdx == 0 )
{
GTH_SendMessage_Guild_Update_To_Client( &g_pc[pl.idxOnServer], &g_guild[guildIdx], update, value1, value2 );
}
else
{
GTH_SendMessage_Guild_Update_To_MemberServer( pl.serverIdx, pl.idxOnServer, &g_guild[guildIdx], update, value1, value2 );
}
}
}
}
}
}
}
void GTH_GuildSetUserInfo( short guildIdx, char *name, int &rankInGuild, int &rankIdxInGuild )
{
int i, userIdx;
entityPCList_t pl;
rankInGuild = -1;
rankIdxInGuild = -1;
userIdx = -1;
if( stricmp( g_guild[guildIdx].masterName, name ) == 0 )
{
rankInGuild = GUILD_MASTER;
userIdx = 0;
}
if( rankInGuild == -1 )
{
for( i=0; i<MAX_GUILD_SUBMASTERS; i++)
{
if( stricmp( g_guild[guildIdx].subMasterName[i], name ) == 0 )
{
rankInGuild = GUILD_SUBMASTER;
rankIdxInGuild = i;
userIdx = MAX_GUILD_MASTERS + i;
break;
}
}
}
if( rankInGuild == -1 )
{
for( i=0; i<MAX_GUILD_FACTIONMASTERS; i++)
{
if( stricmp( g_guild[guildIdx].factionMasterName[i], name ) == 0 )
{
rankInGuild = GUILD_FACTIONMASTER;
rankIdxInGuild = i;
userIdx = MAX_GUILD_MASTERS + MAX_GUILD_SUBMASTERS + i;
break;
}
}
}
if( rankInGuild == -1 )
{
for( i=0; i<MAX_GUILD_MATES; i++)
{
if( stricmp( g_guild[guildIdx].mateName[i], name ) == 0 )
{
rankInGuild = GUILD_MATE;
rankIdxInGuild = i;
userIdx = MAX_GUILD_MASTERS + MAX_GUILD_SUBMASTERS + MAX_GUILD_FACTIONMASTERS + i;
break;
}
}
}
if( rankInGuild == -1 && rankIdxInGuild == -1 )
{
return;
}
if( g_entityListMng.FindPCList( name, &pl ) != -1 )
{
g_guild[guildIdx].userJob[userIdx] = pl.job;
g_guild[guildIdx].userLevel[userIdx] = pl.level;
g_guild[guildIdx].userLocation[userIdx] = pl.worldIdx;
}
}
void GTH_GuildChatMessage( short guildIdx, char *name, char *chatMessage )
{
int i;
entityPCList_t pl;
if( g_entityListMng.FindPCList( g_guild[guildIdx].masterName, &pl ) != -1 )
{
if( pl.serverIdx == 0 )
{
GTH_SendMessage_Guild_ChatMessage_Reply_To_Client( &g_pc[pl.idxOnServer], name, chatMessage );
}
else
{
GTH_SendMessage_Guild_ChatMessage_Reply_To_MemberServer( pl.serverIdx, pl.idxOnServer, name, chatMessage );
}
}
for( i=0; i<MAX_GUILD_SUBMASTERS; i++)
{
if( g_guild[guildIdx].subMasterName[i][0] != 0 )
{
if( g_entityListMng.FindPCList( g_guild[guildIdx].subMasterName[i], &pl ) != -1 )
{
if( pl.serverIdx == 0 )
{
GTH_SendMessage_Guild_ChatMessage_Reply_To_Client( &g_pc[pl.idxOnServer], name, chatMessage );
}
else
{
GTH_SendMessage_Guild_ChatMessage_Reply_To_MemberServer( pl.serverIdx, pl.idxOnServer, name, chatMessage );
}
}
}
}
for( i=0; i<MAX_GUILD_FACTIONMASTERS; i++)
{
if( g_guild[guildIdx].factionMasterName[i][0] != 0 )
{
if( g_entityListMng.FindPCList( g_guild[guildIdx].factionMasterName[i], &pl ) != -1 )
{
if( pl.serverIdx == 0 )
{
GTH_SendMessage_Guild_ChatMessage_Reply_To_Client( &g_pc[pl.idxOnServer], name, chatMessage );
}
else
{
GTH_SendMessage_Guild_ChatMessage_Reply_To_MemberServer( pl.serverIdx, pl.idxOnServer, name, chatMessage );
}
}
}
}
for( i=0; i<MAX_GUILD_MATES; i++)
{
if( g_guild[guildIdx].mateName[i][0] != 0 )
{
if( g_entityListMng.FindPCList( g_guild[guildIdx].mateName[i], &pl ) != -1 )
{
if( pl.serverIdx == 0 )
{
GTH_SendMessage_Guild_ChatMessage_Reply_To_Client( &g_pc[pl.idxOnServer], name, chatMessage );
}
else
{
GTH_SendMessage_Guild_ChatMessage_Reply_To_MemberServer( pl.serverIdx, pl.idxOnServer, name, chatMessage );
}
}
}
}
}
void GTH_GuildUpdateDisorganize( short guildIdx, int result, int error )
{
int i;
entityPCList_t pl;
for( i=0; i<MAX_GUILD_SUBMASTERS; i++)
{
if( g_guild[guildIdx].subMasterName[i][0] != 0 )
{
if( g_entityListMng.FindPCList( g_guild[guildIdx].subMasterName[i], &pl ) != -1 )
{
if( pl.serverIdx == 0 )
{
g_pc[pl.idxOnServer].guildIdx = -1;
GTH_SendMessage_Guild_Disorganize_Reply_To_Client( &g_pc[pl.idxOnServer], result, error );
}
else
{
GTH_SendMessage_Guild_Disorganize_Reply_To_MemberServer( pl.serverIdx, pl.idxOnServer, result, error );
}
}
}
}
for( i=0; i<MAX_GUILD_FACTIONMASTERS; i++)
{
if( g_guild[guildIdx].factionMasterName[i][0] != 0 )
{
if( g_entityListMng.FindPCList( g_guild[guildIdx].factionMasterName[i], &pl ) != -1 )
{
if( pl.serverIdx == 0 )
{
g_pc[pl.idxOnServer].guildIdx = -1;
GTH_SendMessage_Guild_Disorganize_Reply_To_Client( &g_pc[pl.idxOnServer], result, error );
}
else
{
GTH_SendMessage_Guild_Disorganize_Reply_To_MemberServer( pl.serverIdx, pl.idxOnServer, result, error );
}
}
}
}
for( i=0; i<MAX_GUILD_MATES; i++)
{
if( g_guild[guildIdx].mateName[i][0] != 0 )
{
if( g_entityListMng.FindPCList( g_guild[guildIdx].mateName[i], &pl ) != -1 )
{
if( pl.serverIdx == 0 )
{
g_pc[pl.idxOnServer].guildIdx = -1;
GTH_SendMessage_Guild_Disorganize_Reply_To_Client( &g_pc[pl.idxOnServer], result, error );
}
else
{
GTH_SendMessage_Guild_Disorganize_Reply_To_MemberServer( pl.serverIdx, pl.idxOnServer, result, error );
}
}
}
}
}
playerCharacter_t* GTH_GetGuildNoneBusyMemberPtr(int GuildIdx, int WorldIdx, int MemberType)
{
if ( WorldIdx < 0 || WorldIdx >= MAX_GUILDS)
return 0;
guild_t* pGuild = NULL;
pGuild = &g_guild[GuildIdx];
playerCharacter_t* pPC = NULL;
if ( MemberType == MAX_GUILD_MASTERS)
{
pPC = gcpTools->GetPlayerRecordPointer(pGuild->masterName);
if ( pPC != NULL )
{
if ( pPC->worldIdx == WorldIdx && pPC->busyState == BUSY_STATE_NONE)
return pPC;
}
}
if ( MemberType == MAX_GUILD_SUBMASTERS)
{
for(int SubMasterIdx=0; SubMasterIdx < MAX_GUILD_SUBMASTERS; SubMasterIdx++)
{
pPC = gcpTools->GetPlayerRecordPointer(pGuild->subMasterName[SubMasterIdx]);
if ( pPC != NULL )
{
if ( pPC->worldIdx == WorldIdx && pPC->busyState == BUSY_STATE_NONE)
return pPC;
}
}
}
return NULL;
}
void GTH_GetGuildNameByIdx(const int idx, char* szString_OUT)
{
if ( idx <0 || idx >= MAX_GUILDS)
{
strncpy(szString_OUT, "UnknowGuild", GUILDNAMESTRING);
szString_OUT[GUILDNAMESTRING-1] = NULL;
return;
}
strncpy(szString_OUT, g_guild[idx].name, GUILDNAMESTRING);
} | C++ |
#if !defined(AFX_ITEMEXTENDSYSTEM_H__3B20E8DC_0D76_4FA7_A15B_B4F85F20C419__INCLUDED_)
#define AFX_ITEMEXTENDSYSTEM_H__3B20E8DC_0D76_4FA7_A15B_B4F85F20C419__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
struct sPlayerItemExtendItemInfo
{
float fItemInfoRequestTime;
std::vector<int> v_UseTimeItemInfo;
};
void SetItemSpawnType(item_t *pItem, ITEM_SPAWN_INFO::enumItemSpawnType type);
ITEM_SPAWN_INFO::enumItemSpawnType
GetItemSpawnType(const item_t *pItem);
void SetItemUseFlag(item_t *pItem, ENUM_ITEM_USE_FLAG flag);
BOOL IsItemUseFlag(item_t *pItem, ENUM_ITEM_USE_FLAG flag);
#endif
| C++ |
#include "../global.h"
extern i3socket_t gsSocket;
#define MAX_OF_CHEAT_LEVEL_SKILL 10
#include "../Tools/CTools.h"
extern CTools* gcpTools;
void GTH_DisconnectPlayer(playerCharacter_t* pPlayer,const BOOL bForceQuit);
void GTH_ProcessMessage_CheatCode_FORCEQUIT_BY_GM(void)
{
const int bytes=NAMESTRING+100;
char message[bytes+1];
char targetPlayerName[NAMESTRING+1];
strncpy(targetPlayerName,MSG_ReadString(),NAMESTRING);
targetPlayerName[NAMESTRING]=NULL;
playerCharacter_t* pTargetPlayer = gcpTools->GetPlayerRecordPointer(targetPlayerName);
if(NULL != pTargetPlayer){
GTH_DisconnectPlayer(pTargetPlayer,TRUE);
_snprintf(message,bytes,"complete force quit [%s]",pTargetPlayer->name);
message[bytes]=NULL;
}else{
_snprintf(message,bytes,"can't find user [%s]",targetPlayerName);
message[bytes]=NULL;
}
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_CHATMESSAGE_WHISPER);
MSG_WriteString(&netMessage,"Server");
MSG_WriteString(&netMessage,message);
NET_SendUnreliableMessage(&(g_curPC->sock), &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_ProcessMessage_CheatCode()
{
int type;
int value;
int skillIdx[5], tableIdx[5], initLevel[5];
type = MSG_ReadByte();
if( !g_logic.cheatEnable ) return;
switch( type )
{
case CHEATCODE_GETEXP :
{
value = MSG_ReadLong();
int OldLevel = g_curPC->level;
GTH_PC_GetLoot( g_curPC->idx, value, 0, 0, 0 );
g_logSystem->WriteToLog(g_curPC, LOG_CLASS_CHEAT, "%d;%d;%d;;;;",
LOG_CLASS_ITEM_CHEAT_LEVEL, OldLevel, g_curPC->level);
}
break;
case CHEATCODE_GETGENEXP :
{
value = MSG_ReadLong();
GTH_PC_GetLoot( g_curPC->idx, 0, value, 0, 0 );
}
break;
case CHEATCODE_SKILLPOINT :
{
value = MSG_ReadLong();
g_curPC->bonusSkillPoint ++;
GTH_SendMessage_ReplyCheatCode( g_curPC, type );
}
break;
case CHEATCODE_GETSKILL :
{
value = MSG_ReadLong();
tableIdx[0] = value;
initLevel[0] = 1;
skillIdx[0] = g_SkillLogic.SKILL_Add( g_curPC, tableIdx[0] );
if( skillIdx[0] >= 0 )
{
GTH_SendMessage_Reply_AddSkill( g_curPC, 1, skillIdx );
CSkilTable *pSkillTable = NULL;
pSkillTable = g_SkillTableDB.FindDB(g_curPC->skill[skillIdx[0]].tableIdx);
if ( pSkillTable != NULL )
{
g_logSystem->WriteToLog(g_curPC, LOG_CLASS_CHEAT, "%d;%d;;;;%s;",
LOG_CLASS_ITEM_CHEAT_SKILL, pSkillTable->m_nId, "noName");
}
}
}
break;
case CHEATCODE_GETMAXSE :
{
value = MSG_ReadLong();
g_curPC->curChargeSE += value;
if( g_curPC->curChargeSE > MAX_OWN_NAK ) g_curPC->curChargeSE = MAX_OWN_NAK;
GTH_SendMessage_ReplyCheatCode( g_curPC, type );
g_logSystem->WriteToLog(g_curPC, LOG_CLASS_CHEAT, "%d;%d;;;;;",
LOG_CLASS_ITEM_CHEAT_NAK, value);
}
break;
case CHEATCODE_CLEARQUEST :
{
value = MSG_ReadLong();
g_curPC->questVar[value].iVar = 65280;
GTH_ClearQuestStatus( g_curPC, value, 0 );
g_logSystem->WriteToLog(g_curPC, LOG_CLASS_CHEAT, "%d;%d;;;;%s;",
LOG_CLASS_ITEM_CHEAT_QUEST, value, "noName");
}
break;
case CHEATCODE_ADDITEM :
{
value = MSG_ReadLong();
int value2 = MSG_ReadShort();
int addItemData[6];
addItemData[0] = value;
addItemData[1] = -1;
addItemData[2] = 10;
addItemData[3] = 1;
if ( value == QUESTSCROLL_ITEM_INDEX )
{
if ( value2 < 0 )
{
switch ( g_curPC->pcJob )
{
case 0 : case 4 : case 5 :
addItemData[4] = 100;
break;
case 1 : case 6 : case 7 :
addItemData[4] = 107;
break;
case 2 : case 8 : case 9 : case 10 :
addItemData[4] = 207;
break;
case 3 : case 11 : case 12 : case 13 :
addItemData[4] = 200;
break;
}
addItemData[5] = FindRewardField( addItemData[4] );
}
else
{
addItemData[4] = value2;
addItemData[5] = FindRewardField ( value2 );
}
}
if ( value == MONSTERCARD_ITEM_INDEX)
addItemData[2] = value2;
GTH_CheatAddItem(g_curPC, addItemData);
}
break;
case CHEATCODE_GETGENCAPABILITY :
{
value = MSG_ReadLong();
g_curPC->genCapability[g_curPC->selectedGen] += value;
GTH_SendMessage_ReplyCheatCode( g_curPC, type );
}
break;
case CHEATCODE_MAXRASA :
{
value = MSG_ReadLong();
g_curPC->curRA = g_curPC->calMaxRA;
g_curPC->curSA = g_curPC->calMaxSA;
}
break;
case CHEATCODE_AWAKEN :
{
value = MSG_ReadLong();
int awakenType[3] = { 0, 0, 0 };
awakenType[0] = value;
if( g_curPC->pcJob <= 3 && awakenType[0] > 3 ) AI_AwakenPlayerJob( g_curPC, awakenType );
}
break;
case CHEATCODE_READYAWAKEN :
{
value = MSG_ReadLong();
GTH_PC_GetLoot( g_curPC->idx, g_expTable[29].totalexp, g_expTable[14].totalGenExp, 100000000, 0 );
g_curPC->force = 200;
g_curPC->soulpower = 200;
g_curPC->agility = 200;
g_curPC->vitality = 200;
GTH_PC_Calculate( g_curPC );
}
break;
case CHEATCODE_GOMONSTER :
{
value = MSG_ReadLong();
int zoneIdx;
int monsterIdx = value;
if (monsterIdx < 0 || monsterIdx >= MAX_MONSTERS)
return;
if( !g_monster[monsterIdx].active ) return;
if ( g_curPC->worldIdx == g_monster[monsterIdx].worldIdx )
{
vec_copy( g_monster[monsterIdx].position, g_curPC->position );
zoneIdx = GTH_Zone_UpdateCurrentZone(ENTITY_PC, g_curPC->idx, g_curPC->worldIdx, g_curPC->zoneIdx, g_curPC->position);
g_curPC->zoneIdx = zoneIdx;
GTH_SendPCEventMessage_Respawn( g_curPC );
GTH_SendMessage_SyncItemObject( g_curPC );
}
}
break;
case CHEATCODE_ITEM :
{
item_t item;
int optionNumber;
InitItem( &item );
item.itemTableIdx = MSG_ReadShort();
optionNumber = MSG_ReadByte();
for( int i=0; i<optionNumber; i++ )
{
item.optionIdx[i] = MSG_ReadShort();
item.optionValue[i] = MSG_ReadShort();
if( item.optionIdx[i] >= 0 ) item.optionNumber = i + 1;
}
GTH_CheatCode_AddItem( g_curPC, &item );
}
break;
case CHEATCODE_MONSTER:
{
int monsterTableIdx = MSG_ReadShort();
int AIType = MSG_ReadShort();
int idx = MONSTER_Summon( monsterTableIdx, g_curPC->worldIdx, g_curPC->position, AIType );
if( idx < 0 ) break;
g_monster[idx].basic.level = MSG_ReadShort();
g_monster[idx].basic.maxRA = MSG_ReadShort();
g_monster[idx].basic.maxSA = MSG_ReadShort();
g_monster[idx].basic.recoveryRARate = MSG_ReadShort();
g_monster[idx].basic.recoverySARate = MSG_ReadShort();
g_monster[idx].basic.atkPhyMinDmg = MSG_ReadShort();
g_monster[idx].basic.atkPhyMaxDmg = MSG_ReadShort();
g_monster[idx].basic.atkMagMinDmg = MSG_ReadShort();
g_monster[idx].basic.atkMagMaxDmg = MSG_ReadShort();
g_monster[idx].basic.atkHitPower = MSG_ReadShort();
g_monster[idx].basic.atkDelay = MSG_ReadShort();
g_monster[idx].basic.atkLength = MSG_ReadShort();
g_monster[idx].basic.atkRange = MSG_ReadShort();
g_monster[idx].basic.atkCriticalPro = MSG_ReadFloat();
g_monster[idx].basic.atkCriticalDmg = MSG_ReadShort();
g_monster[idx].basic.defPower = MSG_ReadShort();
g_monster[idx].basic.defAvoidPower = MSG_ReadShort();
g_monster[idx].basic.defPositiveRes = MSG_ReadShort();
g_monster[idx].basic.defNegativeRes = MSG_ReadShort();
g_monster[idx].basic.velocity = MSG_ReadShort();
g_monster[idx].basic.stunTime = MSG_ReadShort();
g_monster[idx].basic.exp = MSG_ReadShort();
g_monster[idx].basic.genExp = MSG_ReadShort();
g_monster[idx].basic.lootSE = MSG_ReadShort();
g_monster[idx].basic.pathFindingSize = MSG_ReadShort();
MONSTER_Calculate( &g_monster[idx] );
}
break;
case CHEATCODE_ATKDELAY :
{
int forcedAtkDelay = MSG_ReadShort();
if( forcedAtkDelay < 0 ) g_curPC->forceAtkDelay = -1;
else g_curPC->forceAtkDelay = forcedAtkDelay;
GTH_PC_Calculate( g_curPC );
}
break;
case CHEATCODE_LEVEL :
{
int exp, genexp, se, awaken, pcJob;
exp = MSG_ReadLong();
genexp = MSG_ReadLong();
se = MSG_ReadLong();
awaken = MSG_ReadShort();
pcJob = MSG_ReadShort();
int OldLevel = g_curPC->level;
GTH_CheatCode_InitSkill( g_curPC );
if ( awaken < 0 )
g_curPC->pcJob = pcJob;
GTH_PC_GetLoot_Cheat( g_curPC->idx, exp, genexp, se, 0 );
int awakenType[3] = { 0, 0, 0 };
awakenType[0] = awaken;
if( g_curPC->pcJob <= 3 && awakenType[0] > 3 ) AI_AwakenPlayerJob( g_curPC, awakenType );
g_logSystem->WriteToLog(g_curPC, LOG_CLASS_CHEAT, "%d;%d;%d;;;;;",
LOG_CLASS_ITEM_CHEAT_LEVEL, OldLevel, g_curPC->level);
}
break;
case CHEATCODE_SKILL :
{
int gSkillIdx[MAX_OF_CHEAT_LEVEL_SKILL], gSkillLevel[MAX_OF_CHEAT_LEVEL_SKILL];
int skillNumber = MSG_ReadShort();
for( int i=0; i<skillNumber; i++ )
{
gSkillIdx[i] = MSG_ReadShort();
gSkillLevel[i] = MSG_ReadShort();
}
GTH_CheatCode_AddSkill( g_curPC, skillNumber, gSkillIdx, gSkillLevel );
for( i=0; i<skillNumber; i++ )
{
CSkilTable *pSkillTable = NULL;
pSkillTable = g_SkillTableDB.FindDB(gSkillIdx[i]);
if ( pSkillTable != NULL )
{
g_logSystem->WriteToLog(g_curPC, LOG_CLASS_CHEAT, "%d;%d;;;;%s;",
LOG_CLASS_ITEM_CHEAT_SKILL, gSkillIdx[i], "noName");
}
}
}
break;
case CHEATCODE_ITEMDROPTEST :
{
int monsterTableIdx;
long killNumber;
monsterTableIdx = MSG_ReadShort();
killNumber = MSG_ReadLong();
GTH_CheatCode_ItemDropTest( monsterTableIdx, killNumber );
}
break;
case CHEATCODE_MONSTERSPAWN:
{
int montblIdx = -1;
int ai_idx = -1;
montblIdx = MSG_ReadShort();
ai_idx = MSG_ReadShort();
if ( montblIdx < 0 ) return;
int idx = MONSTER_Summon( montblIdx, g_curPC->worldIdx, g_curPC->position, ai_idx );
if( idx < 0 ) break;
g_logSystem->Write("USE CHEAT : MonsterSpawn. %s(%s) )", g_curPC->name, g_curPC->userID );
MONSTER_Calculate( &g_monster[idx] );;
}
break;
case CHEATCODE_MONSTERKILL:
{
int range = MSG_ReadShort();
GTH_CheatCode_MonsterKill(range);
}
break;
case CHEATCODE_ADDQUESTITEM:
{
int itemidx = MSG_ReadShort();
GTH_CheatCode_AddQuestItem(itemidx);
}
break;
case CHEATCODE_OUTPUTGUILDINFO:
{
OutputGuildInfomation();
}
break;
case CHEATCODE_GET_MEMBERSHIP_TYPE:
{
int lpackidx = 3;
if ( g_curPC->PremiumInfo.iMemberShipType ==
playerCharacter_t::tagPremiumInfo::enumMeberShipType::Pay)
lpackidx = 3;
else
lpackidx = 4;
GTH_SendMessage_ChattingMsg(g_curPC, 2, 0, lpackidx );
}break;
case CHEATCODE_FORCEQUIT_BY_GM:
GTH_ProcessMessage_CheatCode_FORCEQUIT_BY_GM();
break;
case CHEATCODE_CLEARINVEN:
{
for (int iInvenPos = 0; iInvenPos < MAX_INVENTORY_SIZE; iInvenPos++)
{
int ItemIdx = g_curPC->inventory[iInvenPos];
if(ItemIdx< 0 || ItemIdx>= MAX_NUMBER_OF_OWNITEM)
continue;
item_t* pTempItem = NULL;
pTempItem= &g_curPC->item[iInvenPos];
if ( pTempItem->itemTableIdx >=0 || pTempItem->itemTableIdx < MAX_NUMBER_OF_ITEM_TABLE)
{
g_curPC->curItemWeight -= g_itemTable[pTempItem->itemTableIdx].weight;
if ( g_curPC->curItemWeight < 0 )
g_curPC->curItemWeight = 0;
}
GTH_DeleteMyItem( g_curPC, pTempItem);
g_curPC->inventory[iInvenPos] = -1;
g_DBGameServer->RemoveItem( g_curPC, ItemIdx );
}
GTH_SendMessage_ReplyCheatCode(g_curPC, CHEATCODE_CLEARINVEN);
}
break;
case CHEATCODE_KILLME:
{
value = MSG_ReadLong();
g_curPC->curRA=value;
}
break;
case CHEATCODE_DANBATTLE_PCPOINT:
{
GTH_SendMessage_ReplyCheatCode(g_curPC, CHEATCODE_DANBATTLE_PCPOINT);
}
break;
}
}
void GTH_CheatCode_AddItem( playerCharacter_t* pc, item_t *cheatItem )
{
item_t item, *upItem;
int bIsStack = false, stackNumber = 1;
int itemTableIdx = cheatItem->itemTableIdx;
int stackItemIdx, inventoryPos, itemIdx;
int reply = 1, error = 0;
char generateID[20];
int itemNumber = 1;
InitItem( &item );
if( g_itemTable[itemTableIdx].idx < 0 ) return;
SpawnItem( &item, itemTableIdx, 1 );
if( GTH_IsStackItem( &item ) )
{
item.durability = itemNumber - 1;
bIsStack = true;
stackNumber = itemNumber;
}
else if( g_itemTable[itemTableIdx].durability > 0 )
{ item.durability = 100;
}
stackItemIdx = GTH_StackMyItem( pc, &item );
if( stackItemIdx >= 0 )
{
upItem = &pc->item[stackItemIdx];
upItem->durability += item.durability + 1;
if( upItem->durability + 1 >= MAX_COUNT_STACK_ITEM ) upItem->durability = MAX_COUNT_STACK_ITEM - 1;
g_DBGameServer->SaveItem( pc, upItem, stackItemIdx );
int SelectInvenIdx = -1;
for( int InvenIdx = 0; InvenIdx < MAX_INVENTORY_SIZE; InvenIdx ++ )
{
if( g_curPC->inventory[InvenIdx] < 0 ) continue;
int itemIdx = g_curPC->inventory[InvenIdx];
if( GTH_CheckStackItem( upItem, &g_curPC->item[itemIdx] ) )
{
SelectInvenIdx = InvenIdx;
break;
}
}
g_logSystem->WriteToLog(g_curPC, LOG_CLASS_CHEAT, "%d;%d;%d;;;%s;%s",
LOG_CLASS_ITEM_CHEAT_ITEM, upItem->itemTableIdx, upItem->durability, upItem->name,
GetItemInformationLog( bIsStack, upItem->itemTableIdx, stackItemIdx, SelectInvenIdx));
}
else
{
item.optionNumber = cheatItem->optionNumber;
for( int i=0; i<item.optionNumber; i++ )
{
item.optionIdx[i] = cheatItem->optionIdx[i];
item.optionValue[i] = cheatItem->optionValue[i];
}
strcpy( item.name, g_itemTable[itemTableIdx].name );
inventoryPos = GTH_FindEmptyInventoryPos( pc );
if( inventoryPos < 0 )
{
g_logSystem->Write("Obtain Quest Item Failure!! : Inventory Space not Enough. %s(%s) )", pc->name, pc->userID );
reply = 0;
error = ERROR_PICKUPITEM_4;
GTH_SendMessage_AddInvItem( pc, reply, error, &item );
return;
}
itemIdx = GTH_AddMyItem( pc, &item );
if (itemIdx < 0)
{
reply = 0;
error = ERROR_PICKUPITEM_5;
GTH_SendMessage_AddInvItem( pc, reply, error, &item );
return;
}
pc->inventory[inventoryPos] = itemIdx;
strcpy(generateID, "questGenID");
g_DBGameServer->AddItem(pc, &item, itemIdx, generateID);
g_logSystem->WriteToLog(g_curPC, LOG_CLASS_CHEAT, "%d;%d;%d;;;%s;%s",
LOG_CLASS_ITEM_CHEAT_ITEM, item.itemTableIdx, 0, item.name,
GetItemInformationLog( bIsStack, item.itemTableIdx, itemIdx, inventoryPos ));
}
GTH_SendMessage_AddInvItem( pc, reply, error, &item );
}
void GTH_CheatCode_AddSkill( playerCharacter_t* pc, int skillNumber, int* skillTableIdx, int* skillLevel )
{
int idx, skillIdx[MAX_OF_CHEAT_LEVEL_SKILL];
for (int i=0; i<skillNumber; i++)
{
idx = g_SkillLogic.SKILL_Add( pc, skillTableIdx[i] );
pc->skill[idx].level.gen[0] = skillLevel[i];
pc->skill[idx].level.gen[1] = skillLevel[i];
pc->skill[idx].level.gen[2] = skillLevel[i];
pc->skill[idx].level.gen[3] = skillLevel[i];
skillIdx[i] = idx;
}
GTH_SendMessage_Reply_AddSkill( pc, skillNumber, skillIdx );
}
void GTH_CheatCode_InitSkill( playerCharacter_t* pc )
{
for( int i = 0; i < MAX_NUMBER_OF_SKILL; i ++ )
{
pc->skill[i].tableIdx = -1;
}
for( i=0; i<MAX_NUMBER_OF_HOTKEY; i++ )
{
pc->hotkeyIdx[i] = -1;
}
pc->skillNumber = 0;
}
void GTH_TestItemSpawnCode()
{
item_t testItem;
int testItemNumber = 0;
FILE *fp;
char cTime[26], optionPrinting[128];
time_t writeTime;
int optionValue;
init_genrand( (unsigned) time( NULL ) );
fp = fopen( "testItem.txt", "w" );
time( &writeTime ); strcpy( cTime, ctime( &writeTime ) );
cTime[24] = '\0';
fprintf( fp, "%s Test Item ----------------------\n", cTime);
while( 1 )
{
int itemTableIdx = GTH_Randomize( MAX_NUMBER_OF_ITEM_TABLE );
int optionNumber = GTH_Randomize( 6 ) + 1;
int optionGrade = GTH_Randomize( 10 );
if( g_itemTable[itemTableIdx].idx < 0 ) continue;
if( g_itemTable[itemTableIdx].name[0] == 0 ) continue;
if( g_itemTable[itemTableIdx].name[0] == 'B' ) continue;
if( g_itemTable[itemTableIdx].etcItemType != ETCITEM_TYPE_NONE ) continue;
SpawnItem( &testItem, itemTableIdx, optionNumber, optionGrade, 100 );
if( testItem.optionNumber == 0 || itemTableIdx == 868 ) continue;
fprintf( fp, "[%d] %s(Lv.%d)\n", testItemNumber, testItem.name, testItem.reqLevel );
for( int k = 0; k < testItem.optionNumber; k ++ )
{
optionValue = OPTION_GetOptionValue( &testItem, testItem.optionIdx[k], testItem.optionValue[k] - 1 );
sprintf( optionPrinting, g_optionTable[testItem.optionIdx[k]].printing, optionValue );
if( optionValue < 0 )
{
fprintf( fp, "[%d, +%d]%s*\n", testItem.optionIdx[k], testItem.optionValue[k], optionPrinting );
}
else
{
fprintf( fp, "[%d, +%d]%s\n", testItem.optionIdx[k], testItem.optionValue[k], optionPrinting );
}
}
fprintf( fp, "\n" );
testItemNumber ++;
if( testItemNumber >= 10000 ) break;
}
fclose( fp );
}
void GTH_CheatCode_ItemDropTest( int monsterTableIdx, long killNumber )
{
monsterCharacter_t monster;
memcpy( &monster.basic, &g_monsterTable[monsterTableIdx], sizeof( monsterBasicTable_t ) );
item_t spawnItem[MAX_NUMBER_OF_ITEM_LOOT];
int nSpawnItem;
int resultItem[1000], resultNumber[1000];
int m = 0;
for( int i=0; i<1000; i++ )
{
resultItem[i] = -1;
resultNumber[i] = 0;
}
for( long idx=0; idx<killNumber; idx++ )
{
for(int j=0;j<MAX_NUMBER_OF_ITEM_LOOT;j++)
{
memset( &spawnItem[j], 0, sizeof( item_t ) );
}
nSpawnItem = 0;
GTH_SimulateGenerateItemFromMonster( &monster, spawnItem, nSpawnItem );
for(int k=0; k<nSpawnItem; k++)
{
int bAlready = 0;
for( int l=0; l<1000; l++ )
{
if ( spawnItem[k].itemTableIdx == resultItem[l] )
{
resultNumber[l]++;
bAlready = 1;
}
}
if ( bAlready == 0 )
{
resultItem[m] = spawnItem[k].itemTableIdx;
resultNumber[m] = 1;
m++;
}
}
}
GTH_SendMessage_ItemDropTest( g_curPC, resultItem, resultNumber );
}
void GTH_CheatCode_MonsterKill( int range )
{
if ( range <= 0)
range = 10;
int localWorldIdx = GTH_GetLocalWorldIdx( g_curPC->worldIdx );
for( int i = 0; i < MAX_MONSTERS; i ++ )
{
if( !g_monster[i].active ) continue;
int localWorldIdx = GTH_GetLocalWorldIdx( g_monster[i].worldIdx );
if( g_monster[i].worldIdx != g_curPC->worldIdx) continue;
float dist = GTH_GetDistance2D( g_monster[i].position, g_curPC->position);
if ( dist < range * g_cmap[localWorldIdx].scale)
{
g_monster[i].aliveState = MON_ALIVE_STATE_NORMAL;
g_monster[i].ai.aiEvent = AI_DIE;
g_monster[i].event = GTH_EV_CHAR_DIE;
g_monster[i].mostConEntityType = ENTITY_PC;
g_monster[i].conInfo[0].entityIdx = g_curPC->idx;
g_monster[i].conInfo[0].atkPoint =1;
g_monster[i].conInfoNumber = 1;
sprintf(g_monster[i].conInfo[0].entityName, "%s", g_curPC->name);
g_monster[i].deathTime = g_globalTime;
g_monster[i].maxAtkContributionPoint = 1;
}
}
}
void GTH_CheatCode_AddQuestItem( int idx )
{
int itemidx = idx;
if ( g_curPC == NULL)
return ;
if ( itemidx < 0)
return;
for (int i = 0; i < MAX_NUMBER_OF_MONSTER_TABLE; i ++)
{
for (int itemnumber = 0; itemnumber < g_qigTable[i].itemNumber; itemnumber++ )
{
if ( g_qigTable[i].itemTableIdx[itemnumber] == itemidx )
{
if ( TRUE == GTH_AddQuestItem( g_curPC, itemidx, g_qigTable[i].questIdx[itemnumber],
g_qigTable[i].maxItemCount[itemnumber], g_qigTable[i].maxItemCount[itemnumber] )
)
{
g_logSystem->WriteToLog(g_curPC, LOG_CLASS_CHEAT, "%d;%d;%d;;;%s",
LOG_CLASS_ITEM_CHEAT_ITEM, itemidx, 1,
g_itemTable[g_qigTable[i].itemTableIdx[itemnumber]].name,
GetItemInformationLog( 1, itemidx, -1, -1 ));
}
return;
}
}
}
}
#include <shlwapi.h>
void OutputGuildInfomation(FILE* fp,const int GuildIdx)
{
if(0 > GuildIdx) return;
if(MAX_GUILDS <= GuildIdx) return;
guild_t* pGuild=&g_guild[GuildIdx];
char buffer[4096];
fprintf(fp,"\n**********************************************************************");
fprintf(fp,"\n idx=[%d]",pGuild->idx);
fprintf(fp,"\n server group=[%d]",pGuild->serverGroupID);
fprintf(fp,"\n name=[%s]",pGuild->name);
StrCpyN(buffer,pGuild->notice,GUILDNOTICESTRING); buffer[GUILDNOTICESTRING]=NULL;
fprintf(fp,"\n notice=[%s]",buffer);
fprintf(fp,"\n famePoint=[%d]",pGuild->famePoint);
fprintf(fp,"\n expPoint=[%d]",pGuild->expPoint);
fprintf(fp,"\n raidPoint=[%d]",pGuild->raidPoint);
fprintf(fp,"\n pvpPoint=[%d]",pGuild->pvpPoint);
fprintf(fp,"\n hunterPoint=[%d]",pGuild->hunterPoint);
fprintf(fp,"\n level=[%d]",pGuild->level);
StrCpyN(buffer,pGuild->masterName,NAMESTRING); buffer[NAMESTRING]=NULL;
fprintf(fp,"\n masterName=[%s]",buffer);
for(int SubMasterIdx=0; SubMasterIdx < MAX_GUILD_SUBMASTERS; SubMasterIdx++){
StrCpyN(buffer,pGuild->subMasterName[SubMasterIdx],NAMESTRING); buffer[NAMESTRING]=NULL;
fprintf(fp,"\n subMaster[%02d] name=[%s]",SubMasterIdx,buffer);
}
for(int factionMasterIdx=0; factionMasterIdx < MAX_GUILD_FACTIONMASTERS; factionMasterIdx++){
StrCpyN(buffer,pGuild->factionMasterName[factionMasterIdx],NAMESTRING); buffer[NAMESTRING]=NULL;
fprintf(fp,"\n factionMaster[%02d] name=[%s]",factionMasterIdx,buffer);
}
for(int mateIdx=0; mateIdx < MAX_GUILD_MATES; mateIdx++){
StrCpyN(buffer,pGuild->mateName[mateIdx],NAMESTRING); buffer[NAMESTRING]=NULL;
fprintf(fp,"\n mate[%2d] name=[%s]",mateIdx,buffer);
}
fprintf(fp,"\n**********************************************************************");
}
void OutputGuildInfomation(void)
{
char szFileName[_MAX_PATH];
struct tm *date_tm;
time_t system_time;
time(&system_time);
date_tm = localtime(&system_time );
sprintf(szFileName,
"GS%02d%02d_%04d%02d%02d_%02d%02d%02d.Guild.Txt",
g_config.serverGroupNo,
g_config.gameServerNo,
date_tm->tm_year,
date_tm->tm_mon,
date_tm->tm_mday,
date_tm->tm_hour,
date_tm->tm_min,
date_tm->tm_sec);
FILE* fp = fopen(szFileName,"at+");
if(NULL == fp) return;
for(int GuildIdx=0; GuildIdx < MAX_GUILDS; GuildIdx++){
if(NULL == g_guild[GuildIdx].name[0]) continue;
OutputGuildInfomation(fp,GuildIdx);
}
fclose(fp); fp=NULL;
}
int GTH_CheatAddItem(void *pPc, int *pParam )
{
playerCharacter_t* pc = static_cast< playerCharacter_t* >( pPc );
int itemTableIdx = pParam[0];
int optionGroupIdx = pParam[1];
int itemNumber = pParam[2];
int messageFlag = pParam[3];
int stackItemIdx, inventoryPos, itemIdx;
int reply = 1, error = 0;
int bIsStack = false, stackNumber = 1;
char generateID[20];
item_t item, *upItem;
itemTable_t* pItemTable = gcpTools->GetItemTablePointer(itemTableIdx);
if(NULL == pItemTable) return FALSE;
if(pItemTable->idx < 0) return FALSE;
if( optionGroupIdx >= 0 )
{
SpawnItemByOptionGroup( &item, itemTableIdx, optionGroupIdx );
}
else
{
SpawnItem( &item, itemTableIdx );
}
if (itemTableIdx == MONSTERCARD_ITEM_INDEX )
{
item.optionIdx[0] = itemNumber;
item.timer = g_summonMonstertable[itemNumber].SummonTime;
item.optionNumber ++;
}
if( GTH_IsStackItem( &item ) )
{
item.durability = itemNumber - 1;
bIsStack = true;
stackNumber = itemNumber;
}
else if( g_itemTable[itemTableIdx].durability > 0 )
{
item.durability = 100;
}
stackItemIdx = GTH_StackMyItem( pc, &item );
if( stackItemIdx >= 0 )
{
upItem = &pc->item[stackItemIdx];
upItem->durability += item.durability + 1;
if( upItem->durability + 1 >= MAX_COUNT_STACK_ITEM ) upItem->durability = MAX_COUNT_STACK_ITEM - 1;
g_DBGameServer->SaveItem( pc, upItem, stackItemIdx );
int SelectInvenIdx = -1;
for( int InvenIdx = 0; InvenIdx < MAX_INVENTORY_SIZE; InvenIdx ++ )
{
if( g_curPC->inventory[InvenIdx] < 0 ) continue;
int itemIdx = g_curPC->inventory[InvenIdx];
if( GTH_CheckStackItem( upItem, &g_curPC->item[itemIdx] ) )
{
SelectInvenIdx = InvenIdx;
break;
}
}
g_logSystem->WriteToLog(g_curPC, LOG_CLASS_CHEAT, "%d;%d;%d;;;%s;%s",
LOG_CLASS_ITEM_CHEAT_ITEM, upItem->itemTableIdx, upItem->durability, upItem->name,
GetItemInformationLog( bIsStack, upItem->itemTableIdx, stackItemIdx, SelectInvenIdx));
}
else
{
strcpy( item.name, g_itemTable[itemTableIdx].name );
if (itemTableIdx == QUESTSCROLL_ITEM_INDEX)
{
item.optionIdx[0] = pParam[4];
item.optionIdx[1] = pParam[5];
item.optionNumber = 2;
}
if (itemTableIdx == AUTOQUESTSCROLL_ITEM_INDEX)
{
item.optionIdx[0] = pParam[4];
item.optionIdx[1] = pParam[5];
item.optionNumber = 2;
}
inventoryPos = GTH_FindEmptyInventoryPos( pc );
if( inventoryPos < 0 )
{
int itemObjectIdx = GTH_SpawnItemObject( &item, pc->worldIdx, pc->position, LOOTTYPE_INDIVIDUAL, pc->idx );
if ( itemObjectIdx < 0 )
{
g_logSystem->Write("Can't Obtain Item Error!!(pc name:%s, item index:%d, option group index:%d", pc->name, item.itemTableIdx, optionGroupIdx );
}
return 0;
}
itemIdx = GTH_AddMyItem( pc, &item );
if (itemIdx < 0)
{
int itemObjectIdx = GTH_SpawnItemObject( &item, pc->worldIdx, pc->position, LOOTTYPE_INDIVIDUAL, pc->idx );
if ( itemObjectIdx < 0 )
{
g_logSystem->Write("Can't Obtain Item Error!!(pc name:%s, item index:%d, option group index:%d", pc->name, item.itemTableIdx, optionGroupIdx );
}
return 0;
}
pc->inventory[inventoryPos] = itemIdx;
strcpy(generateID, "questGenID");
g_DBGameServer->AddItem(pc, &item, itemIdx, generateID);
g_logSystem->WriteToLog(g_curPC, LOG_CLASS_CHEAT, "%d;%d;%d;;;%s;%s",
LOG_CLASS_ITEM_CHEAT_ITEM, item.itemTableIdx, 0, item.name,
GetItemInformationLog( bIsStack, item.itemTableIdx, itemIdx, inventoryPos ));
}
if ( reply == 1 )
error = 1 - pParam[3];
GTH_SendMessage_AddInvItem( pc, reply, error, &item );
return 1;
} | C++ |
#if !defined(AFX_ITEM_SCROLL_PROC_H__7514679D_1C5E_402F_A0C0_E40BDB0F3E26__INCLUDED_)
#define AFX_ITEM_SCROLL_PROC_H__7514679D_1C5E_402F_A0C0_E40BDB0F3E26__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CItem_Scroll_Proc
{
public:
enum enumPacketID{
CC_REQUEST_PC_SUMMON=0x0001,
GSC_REQUEST_PC_SUMMON,
CC_REPLY_PC_SUMMON,
GSC_REPLY_PC_SUMMON,
GSC_ERROR_MES,
GSC_STATE_MES,
CC_ERROR_MES,
CC_STATE_MES,
CC_REQUEST_PC_MOVE_SUMMON,
GSC_REQUEST_PC_MOVE_SUMMON,
CC_REPLY_PC_MOVE_SUMMON,
GSC_REPLY_PC_MOVE_SUMMON,
CC_REDAY_PC_MOVE_SUMMON,
GSC_REPLY_REDAY_PC_MOVE_SUMMON,
};
enum enumErrorCode
{
ERROR_NULL_TARGET_PLAYER=1,
ERROR_ITEM_NOT_HAVE,
ERROR_INVALID_ITEM,
ERROR_NOT_SUMMON_ITEM,
ERROR_NULL_REQUEST_PLAYER,
ERROR_TARGET_PLAYER_NOT_USE_AREA,
ERROR_REQUEST_PLAYER_NOT_USE_AREA,
ERROR_NOT_USE_ME_TO_ME,
ERROR_NOT_MOVE_SUMMON_ITEM,
};
enum enumStateCode
{
STATE_SEND_REQUEST =1,
STATE_TARGET_PLAYER_REFUSE,
STATE_TARGET_PLAYER_OK,
STATE_MSGBOX_POPUP_SUCC,
STATE_MSGBOX_POPUP_FAIL,
STATE_TARGET_PLAYER_MOVE_REFUSE,
STATE_TARGET_PLAYER_MOVE_OK,
};
enum enumTargetPlayerReply
{
REPLY_OK=1,
REPLY_REFUSE,
};
public:
CItem_Scroll_Proc();
virtual ~CItem_Scroll_Proc();
void Decoder(playerCharacter_t* pPlayer);
bool CheckInvalidArea(playerCharacter_t* pFromPlayer);
int GSDecoder();
int ClientRequest_PC_Summon(playerCharacter_t* pPlayer);
int Client_Reply_PC_Summon(playerCharacter_t* pPlayer);
int Client_State_Mes(playerCharacter_t* pPlayer);
int OtherServer_CleintRequest_PC_Summon();
int Otherserver_from_Reply_Pc_Summon();
int GsErrorMes();
int GsStateMes();
int ClientRequest_PC_Move_Summon(playerCharacter_t* pPlayer);
int OtherServer_CleintRequest_PC_Move_Summon();
int Client_Reply_PC_Move_Summon(playerCharacter_t* pPlayer);
int Otherserver_from_Reply_Pc_Move_Summon();
int Client_Error_Mes(playerCharacter_t* pPlayer);
int Client_Ready_PC_Move_Summon(playerCharacter_t* pPlayer);
int ReplySummons(playerCharacter_t *pc);
};
#endif
| C++ |
#include "../global.h"
CItem_Scroll_Proc g_Item_Scroll_Proc;
#include "../Tools/CTools.h"
extern CTools* gcpTools;
#include "..\GolryunBattle\CGolryunBattle.h"
extern CGolryunBattle* gcpGolryunBattle;
#include "..\GonryunPracticeBattle\CGonryunPracticeBattle.h"
#include "..\GonryunPracticeBattle\CGonryunPractice_ProcessCtrl.h"
#include "..\GonryunPracticeBattle\CGonryunPractice_WaiterCtrl.h"
extern CGonryunPracticeBattle g_GonryunPracticeBattle;
#include "../network/Gs_To_Gms.h"
extern CGs_To_Gms g_GsToGms;
#include "../network/Gms_To_Gs.h"
extern CGms_To_Gs g_GmsToGs;
extern CItemTableData gItemTableData;
#include "../network/Gs_To_Cc.h"
extern CGs_To_Cc g_GsToCc;
#include "../LogEvent.h"
extern CLogEvent gLogEvent;
CItem_Scroll_Proc::CItem_Scroll_Proc()
{
}
CItem_Scroll_Proc::~CItem_Scroll_Proc()
{
}
void CItem_Scroll_Proc::Decoder(playerCharacter_t* pPlayer)
{
short PacketID =MSG_ReadShort();
switch(PacketID){
case enumPacketID::CC_REQUEST_PC_SUMMON:
ClientRequest_PC_Summon(pPlayer);
break;
case enumPacketID::CC_REPLY_PC_SUMMON:
Client_Reply_PC_Summon(pPlayer);
break;
case enumPacketID::CC_STATE_MES:
Client_State_Mes(pPlayer);
break;
case enumPacketID::CC_ERROR_MES:
Client_Error_Mes(pPlayer);
break;
case enumPacketID::CC_REQUEST_PC_MOVE_SUMMON:
ClientRequest_PC_Move_Summon(pPlayer);
break;
case enumPacketID::CC_REPLY_PC_MOVE_SUMMON:
Client_Reply_PC_Move_Summon(pPlayer);
break;
case enumPacketID::CC_REDAY_PC_MOVE_SUMMON:
Client_Ready_PC_Move_Summon(pPlayer);
break;
}
}
int CItem_Scroll_Proc::GSDecoder()
{
int mainType = MSG_ReadShort();
switch(mainType)
{
case CC_REQUEST_PC_SUMMON:
{
OtherServer_CleintRequest_PC_Summon();
}
break;
case CC_REPLY_PC_SUMMON:
{
Otherserver_from_Reply_Pc_Summon();
}
break;
case GSC_ERROR_MES:
GsErrorMes();
break;
case GSC_STATE_MES:
GsStateMes();
break;
case CC_REQUEST_PC_MOVE_SUMMON:
{
OtherServer_CleintRequest_PC_Move_Summon();
}
break;
case CC_REPLY_PC_MOVE_SUMMON:
{
Otherserver_from_Reply_Pc_Move_Summon();
}
break;
}
return 1;
}
bool CItem_Scroll_Proc::CheckInvalidArea(playerCharacter_t* pPlayer)
{
if(false == pPlayer->alive)
{
return false;
}
if(false == pPlayer->ready)
{
return false;
}
if(pPlayer->m_WorldChangeSystem.m_SystemMode != WorldChangeSystem::enumWorldChangeMode::WORLD_CHANGESYSTEM_NONE)
{
return false;
}
if(tagGolryunBattle::Golryun_Battle_Map_Index == pPlayer->worldIdx)
{
return false;
}
CGonryunPractice_ProcessCtrl* pProcess = g_GonryunPracticeBattle.GetProcessCtrl();
if(playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_NONE != pPlayer->GonryunBattlePractice.MemberShip)
{
return false;
}
if( DAN_BATTLEMAP_NO == pPlayer->worldIdx )
{
return false;
}
return true;
}
int CItem_Scroll_Proc::ClientRequest_PC_Summon(playerCharacter_t* pPlayer)
{
int InventoryItemPos = MSG_ReadShort();
char targetPlayerName[NAMESTRING+1];
sstrncpy( targetPlayerName, MSG_ReadString(), NAMESTRING - 1 );
targetPlayerName[NAMESTRING]=NULL;
item_t* pItem = gcpTools->GetMyInventoryItem(pPlayer ,InventoryItemPos);
if(NULL == pItem)
{
g_GsToCc.Send(pPlayer,ITEM_SUMMON_SYSTEM,GSC_ERROR_MES,enumErrorCode::ERROR_ITEM_NOT_HAVE,pPlayer->name,targetPlayerName);
return 0;
}
itemTable_t* pItemTable = gcpTools->GetItemTablePointer(pItem->itemTableIdx);
if(NULL == pItemTable)
{
g_GsToCc.Send(pPlayer,ITEM_SUMMON_SYSTEM,GSC_ERROR_MES,enumErrorCode::ERROR_INVALID_ITEM,pPlayer->name,targetPlayerName);
return 0;
}
int UseItemType = gItemTableData.GetUseItemType(pItemTable);
if(CItemTableData::ItemTable_FluxDataType::USE_ITEM_FOR_PC_SUMMON != UseItemType)
{
g_GsToCc.Send(pPlayer,ITEM_SUMMON_SYSTEM,GSC_ERROR_MES,enumErrorCode::ERROR_NOT_SUMMON_ITEM,pPlayer->name,targetPlayerName);
return 0;
}
if(false == CheckInvalidArea(pPlayer))
{
g_GsToCc.Send(pPlayer,ITEM_SUMMON_SYSTEM,GSC_ERROR_MES,enumErrorCode::ERROR_REQUEST_PLAYER_NOT_USE_AREA,pPlayer->name,targetPlayerName);
return 0;
}
playerCharacter_t* pTargetPlayer = gcpTools->GetPlayerRecordPointer(targetPlayerName);
if(NULL != pTargetPlayer)
{
if(false == CheckInvalidArea(pTargetPlayer))
{
g_GsToCc.Send(pPlayer,ITEM_SUMMON_SYSTEM,GSC_ERROR_MES,enumErrorCode::ERROR_TARGET_PLAYER_NOT_USE_AREA,pPlayer->name,targetPlayerName);
return 0;
}
g_GsToCc.Send(pTargetPlayer,ITEM_SUMMON_SYSTEM,GSC_REQUEST_PC_SUMMON, 0,InventoryItemPos,pPlayer->worldIdx,pPlayer->position,pPlayer->name,targetPlayerName);
return 0;
}
int Result = g_GsToGms.Send_GMS(
ITEM_SUMMON_SYSTEM,
CC_REQUEST_PC_SUMMON,
0,
InventoryItemPos,
pPlayer->worldIdx,
pPlayer->position,
pPlayer->name,
targetPlayerName,
g_config.gameServerNo,
CGs_To_Gms::enumCheckType::CHECK_PLAYER2);
if ( -1 == Result )
{
g_GsToCc.Send(pPlayer,ITEM_SUMMON_SYSTEM,GSC_ERROR_MES,enumErrorCode::ERROR_NULL_TARGET_PLAYER,pPlayer->name,targetPlayerName);
return 0;
}
return 0;
}
int CItem_Scroll_Proc::GsStateMes()
{
int SubType = MSG_ReadShort();
switch(SubType) {
case STATE_MSGBOX_POPUP_SUCC:
case STATE_MSGBOX_POPUP_FAIL:
{
int InventoryItemPos = MSG_ReadLong();
char requestPlayerName[NAMESTRING+1];
sstrncpy( requestPlayerName, MSG_ReadString(), NAMESTRING - 1 );
requestPlayerName[NAMESTRING]=NULL;
char targetPlayerName[NAMESTRING+1];
sstrncpy( targetPlayerName, MSG_ReadString(), NAMESTRING - 1 );
targetPlayerName[NAMESTRING]=NULL;
playerCharacter_t* pRequestPlayer = gcpTools->GetPlayerRecordPointer(requestPlayerName);
if(NULL == pRequestPlayer) return 0;
if(STATE_MSGBOX_POPUP_SUCC == SubType)
{
gcpTools->DeleteItemFromMyInventory(pRequestPlayer, InventoryItemPos);
}
g_GsToCc.Send(pRequestPlayer,ITEM_SUMMON_SYSTEM,GSC_STATE_MES,SubType,InventoryItemPos,requestPlayerName,targetPlayerName);
}
break;
case STATE_TARGET_PLAYER_REFUSE:
case STATE_TARGET_PLAYER_OK:
{
char requestPlayerName[NAMESTRING+1];
sstrncpy( requestPlayerName, MSG_ReadString(), NAMESTRING - 1 );
requestPlayerName[NAMESTRING]=NULL;
char targetPlayerName[NAMESTRING+1];
sstrncpy( targetPlayerName, MSG_ReadString(), NAMESTRING - 1 );
targetPlayerName[NAMESTRING]=NULL;
playerCharacter_t* pRequestPlayer = gcpTools->GetPlayerRecordPointer(requestPlayerName);
if(NULL == pRequestPlayer) return 0;
g_GsToCc.Send(pRequestPlayer,ITEM_SUMMON_SYSTEM,GSC_STATE_MES,SubType,requestPlayerName,targetPlayerName);
}
break;
case STATE_TARGET_PLAYER_MOVE_REFUSE:
case STATE_TARGET_PLAYER_MOVE_OK:
{
int worldIdx = MSG_ReadByte();
vec3_t position;
MSG_ReadPosition(position);
char requestPlayerName[NAMESTRING+1];
sstrncpy( requestPlayerName, MSG_ReadString(), NAMESTRING - 1 );
requestPlayerName[NAMESTRING]=NULL;
char targetPlayerName[NAMESTRING+1];
sstrncpy( targetPlayerName, MSG_ReadString(), NAMESTRING - 1 );
targetPlayerName[NAMESTRING]=NULL;
playerCharacter_t* pRequestPlayer = gcpTools->GetPlayerRecordPointer(requestPlayerName);
if(NULL == pRequestPlayer) return 0;
g_GsToCc.Send(pRequestPlayer,ITEM_SUMMON_SYSTEM,GSC_STATE_MES,SubType,worldIdx,position,requestPlayerName,targetPlayerName);
}
break;
}
return 1;
}
int CItem_Scroll_Proc::GsErrorMes()
{
int SubType = MSG_ReadShort();
char requestPlayerName[NAMESTRING+1];
sstrncpy( requestPlayerName, MSG_ReadString(), NAMESTRING - 1 );
requestPlayerName[NAMESTRING]=NULL;
char targetPlayerName[NAMESTRING+1];
sstrncpy( targetPlayerName, MSG_ReadString(), NAMESTRING - 1 );
targetPlayerName[NAMESTRING]=NULL;
switch(SubType) {
case ERROR_NULL_TARGET_PLAYER:
case ERROR_TARGET_PLAYER_NOT_USE_AREA:
{
playerCharacter_t* pRequestPlayer = gcpTools->GetPlayerRecordPointer(requestPlayerName);
if(NULL == pRequestPlayer) return 0;
g_GsToCc.Send(pRequestPlayer,ITEM_SUMMON_SYSTEM,GSC_ERROR_MES,SubType,requestPlayerName,targetPlayerName);
}
break;
case ERROR_NULL_REQUEST_PLAYER:
case ERROR_REQUEST_PLAYER_NOT_USE_AREA:
{
playerCharacter_t* pTargetPlayer = gcpTools->GetPlayerRecordPointer(targetPlayerName);
if(NULL == pTargetPlayer) return 0;
g_GsToCc.Send(pTargetPlayer,ITEM_SUMMON_SYSTEM,GSC_ERROR_MES,SubType,requestPlayerName,targetPlayerName);
}
break;
}
return 1;
}
int CItem_Scroll_Proc::OtherServer_CleintRequest_PC_Summon()
{
int SubType = MSG_ReadShort();
int InventoryItemPos = MSG_ReadLong();
int worldIdx = MSG_ReadByte();
vec3_t position;
MSG_ReadPosition(position);
char requestPlayerName[NAMESTRING+1];
sstrncpy( requestPlayerName, MSG_ReadString(), NAMESTRING - 1 );
requestPlayerName[NAMESTRING]=NULL;
char targetPlayerName[NAMESTRING+1];
sstrncpy( targetPlayerName, MSG_ReadString(), NAMESTRING - 1 );
targetPlayerName[NAMESTRING]=NULL;
playerCharacter_t* pTargetPlayer = gcpTools->GetPlayerRecordPointer(targetPlayerName);
if(NULL == pTargetPlayer)
{
g_GsToGms.Send_GMS(
ITEM_SUMMON_SYSTEM,
GSC_ERROR_MES,
enumErrorCode::ERROR_NULL_TARGET_PLAYER,
requestPlayerName,
targetPlayerName,
g_config.gameServerNo,
CGs_To_Gms::enumCheckType::CHECK_PLAYER1);
return 0;
return 0;
}
if(false == CheckInvalidArea(pTargetPlayer))
{
g_GsToGms.Send_GMS(
ITEM_SUMMON_SYSTEM,
GSC_ERROR_MES,
enumErrorCode::ERROR_TARGET_PLAYER_NOT_USE_AREA,
requestPlayerName,
targetPlayerName,
g_config.gameServerNo,
CGs_To_Gms::enumCheckType::CHECK_PLAYER1);
return 0;
}
g_GsToCc.Send(pTargetPlayer,ITEM_SUMMON_SYSTEM,GSC_REQUEST_PC_SUMMON, 0,InventoryItemPos,worldIdx,position,requestPlayerName,targetPlayerName);
return 0;
}
int CItem_Scroll_Proc::Client_Error_Mes(playerCharacter_t* pPlayer)
{
int ReplyID = MSG_ReadShort();
char requestPlayerName[NAMESTRING+1];
sstrncpy( requestPlayerName, MSG_ReadString(), NAMESTRING - 1 );
requestPlayerName[NAMESTRING]=NULL;
char targetPlayerName[NAMESTRING+1];
sstrncpy( targetPlayerName, MSG_ReadString(), NAMESTRING - 1 );
targetPlayerName[NAMESTRING]=NULL;
switch(ReplyID) {
case ERROR_NULL_TARGET_PLAYER:
case ERROR_TARGET_PLAYER_NOT_USE_AREA:
{
playerCharacter_t* requestPlayer = gcpTools->GetPlayerRecordPointer(requestPlayerName);
if(NULL == requestPlayer)
{
g_GsToGms.Send_GMS(
ITEM_SUMMON_SYSTEM,
CC_ERROR_MES,
ReplyID,
requestPlayerName,
targetPlayerName,
g_config.gameServerNo,
CGs_To_Gms::enumCheckType::CHECK_PLAYER1);
return 0;
}
else
{
g_GsToCc.Send(requestPlayer,ITEM_SUMMON_SYSTEM,GSC_ERROR_MES, ReplyID,requestPlayerName,targetPlayerName);
}
}
break;
case ERROR_NULL_REQUEST_PLAYER:
case ERROR_REQUEST_PLAYER_NOT_USE_AREA:
{
playerCharacter_t* targetPlayer = gcpTools->GetPlayerRecordPointer(targetPlayerName);
if(NULL == targetPlayer)
{
g_GsToGms.Send_GMS(
ITEM_SUMMON_SYSTEM,
CC_ERROR_MES,
ReplyID,
requestPlayerName,
targetPlayerName,
g_config.gameServerNo,
CGs_To_Gms::enumCheckType::CHECK_PLAYER2);
return 0;
}
else
{
g_GsToCc.Send(targetPlayer,ITEM_SUMMON_SYSTEM,GSC_ERROR_MES, ReplyID,requestPlayerName,targetPlayerName);
}
}
break;
}
return 0;
}
int CItem_Scroll_Proc::Client_State_Mes(playerCharacter_t* pPlayer)
{
int ReplyID = MSG_ReadShort();
int InventoryItemPos = MSG_ReadLong();
char requestPlayerName[NAMESTRING+1];
sstrncpy( requestPlayerName, MSG_ReadString(), NAMESTRING - 1 );
requestPlayerName[NAMESTRING]=NULL;
switch(ReplyID) {
case STATE_MSGBOX_POPUP_SUCC:
{
playerCharacter_t* requestPlayer = gcpTools->GetPlayerRecordPointer(requestPlayerName);
if(NULL == requestPlayer)
{
g_GsToGms.Send_GMS(
ITEM_SUMMON_SYSTEM,
GSC_STATE_MES,
enumStateCode::STATE_MSGBOX_POPUP_SUCC,
InventoryItemPos,
requestPlayerName,
pPlayer->name,
g_config.gameServerNo,
CGs_To_Gms::enumCheckType::CHECK_PLAYER1);
return 0;
}
gcpTools->DeleteItemFromMyInventory(requestPlayer, InventoryItemPos);
g_GsToCc.Send(requestPlayer,ITEM_SUMMON_SYSTEM,GSC_STATE_MES,STATE_MSGBOX_POPUP_SUCC,InventoryItemPos,requestPlayerName,pPlayer->name);
}
break;
case STATE_MSGBOX_POPUP_FAIL:
{
playerCharacter_t* requestPlayer = gcpTools->GetPlayerRecordPointer(requestPlayerName);
if(NULL == requestPlayer)
{
g_GsToGms.Send_GMS(
ITEM_SUMMON_SYSTEM,
GSC_STATE_MES,
enumStateCode::STATE_MSGBOX_POPUP_FAIL,
InventoryItemPos,
requestPlayerName,
pPlayer->name,
g_config.gameServerNo,
CGs_To_Gms::enumCheckType::CHECK_PLAYER1);
return 0;
}
g_GsToCc.Send(requestPlayer,ITEM_SUMMON_SYSTEM,GSC_STATE_MES,enumStateCode::STATE_MSGBOX_POPUP_FAIL,InventoryItemPos,requestPlayerName,pPlayer->name);
}
break;
}
return 0;
}
int CItem_Scroll_Proc::Client_Reply_PC_Summon(playerCharacter_t* pPlayer)
{
int ReplyID = MSG_ReadShort();
int worldIdx = MSG_ReadByte();
vec3_t position;
MSG_ReadPosition(position);
char requestPlayerName[NAMESTRING+1];
sstrncpy( requestPlayerName, MSG_ReadString(), NAMESTRING - 1 );
requestPlayerName[NAMESTRING]=NULL;
if(false == CheckInvalidArea(pPlayer))
{
g_GsToGms.Send_GMS(
ITEM_SUMMON_SYSTEM,
GSC_ERROR_MES,
enumErrorCode::ERROR_TARGET_PLAYER_NOT_USE_AREA,
requestPlayerName,
pPlayer->name,
g_config.gameServerNo,
CGs_To_Gms::enumCheckType::CHECK_PLAYER1);
g_GsToCc.Send(pPlayer,ITEM_SUMMON_SYSTEM,GSC_ERROR_MES, enumErrorCode::ERROR_TARGET_PLAYER_NOT_USE_AREA,requestPlayerName,pPlayer->name);
return 0;
}
if(enumTargetPlayerReply::REPLY_OK == ReplyID)
{
GTH_PC_SetSummonsInfo(pPlayer,requestPlayerName,worldIdx,position,tagPcSummonTypedef::enumPcSummonType::PC_SUMMON_MOVE_ITEM);
ReplySummons(pPlayer);
}
playerCharacter_t* requestPlayer = gcpTools->GetPlayerRecordPointer(requestPlayerName);
if(NULL == requestPlayer)
{
switch(ReplyID) {
case REPLY_OK:
{
g_GsToGms.Send_GMS(
ITEM_SUMMON_SYSTEM,
CC_REPLY_PC_SUMMON,
enumTargetPlayerReply::REPLY_OK,
requestPlayerName,
pPlayer->name,
g_config.gameServerNo,
CGs_To_Gms::enumCheckType::CHECK_PLAYER1);
return 0;
}
break;
case REPLY_REFUSE:
g_GsToGms.Send_GMS(
ITEM_SUMMON_SYSTEM,
CC_REPLY_PC_SUMMON,
enumTargetPlayerReply::REPLY_REFUSE,
requestPlayerName,
pPlayer->name,
g_config.gameServerNo,
CGs_To_Gms::enumCheckType::CHECK_PLAYER1);
return 0;
break;
}
return 0;
}
if(enumTargetPlayerReply::REPLY_REFUSE == ReplyID)
{
g_GsToCc.Send(requestPlayer,ITEM_SUMMON_SYSTEM,GSC_STATE_MES,enumStateCode::STATE_TARGET_PLAYER_REFUSE,requestPlayer->name,pPlayer->name);
return 0;
}
g_GsToCc.Send(requestPlayer,ITEM_SUMMON_SYSTEM,GSC_STATE_MES,enumStateCode::STATE_TARGET_PLAYER_OK,requestPlayer->name,pPlayer->name);
return 0;
}
int CItem_Scroll_Proc::Otherserver_from_Reply_Pc_Summon()
{
int SubType = MSG_ReadShort();
char requestPlayerName[NAMESTRING+1];
sstrncpy( requestPlayerName, MSG_ReadString(), NAMESTRING - 1 );
requestPlayerName[NAMESTRING]=NULL;
char targetPlayerName[NAMESTRING+1];
sstrncpy( targetPlayerName, MSG_ReadString(), NAMESTRING - 1 );
targetPlayerName[NAMESTRING]=NULL;
playerCharacter_t* requestPlayer = gcpTools->GetPlayerRecordPointer(requestPlayerName);
if(NULL == requestPlayer)
{
return 0;
}
if(enumTargetPlayerReply::REPLY_REFUSE == SubType)
{
g_GsToCc.Send(requestPlayer,ITEM_SUMMON_SYSTEM,GSC_STATE_MES,enumStateCode::STATE_TARGET_PLAYER_REFUSE,requestPlayer->name,targetPlayerName);
return 0;
}
g_GsToCc.Send(requestPlayer,ITEM_SUMMON_SYSTEM,GSC_STATE_MES,enumStateCode::STATE_TARGET_PLAYER_OK,requestPlayer->name,targetPlayerName);
return 1;
}
int CItem_Scroll_Proc::ClientRequest_PC_Move_Summon(playerCharacter_t* pPlayer)
{
int InventoryItemPos = MSG_ReadShort();
char targetPlayerName[NAMESTRING+1];
sstrncpy( targetPlayerName, MSG_ReadString(), NAMESTRING - 1 );
targetPlayerName[NAMESTRING]=NULL;
item_t* pItem = gcpTools->GetMyInventoryItem(pPlayer ,InventoryItemPos);
if(NULL == pItem)
{
g_GsToCc.Send(pPlayer,ITEM_SUMMON_SYSTEM,GSC_ERROR_MES,enumErrorCode::ERROR_ITEM_NOT_HAVE,pPlayer->name,targetPlayerName);
return 0;
}
itemTable_t* pItemTable = gcpTools->GetItemTablePointer(pItem->itemTableIdx);
if(NULL == pItemTable)
{
g_GsToCc.Send(pPlayer,ITEM_SUMMON_SYSTEM,GSC_ERROR_MES,enumErrorCode::ERROR_INVALID_ITEM,pPlayer->name,targetPlayerName);
return 0;
}
int UseItemType = gItemTableData.GetUseItemType(pItemTable);
if(CItemTableData::ItemTable_FluxDataType::USE_ITEM_FOR_PC_MOVE_SUMMON != UseItemType)
{
g_GsToCc.Send(pPlayer,ITEM_SUMMON_SYSTEM,GSC_ERROR_MES,enumErrorCode::ERROR_NOT_MOVE_SUMMON_ITEM,pPlayer->name,targetPlayerName);
return 0;
}
if(false == CheckInvalidArea(pPlayer))
{
g_GsToCc.Send(pPlayer,ITEM_SUMMON_SYSTEM,GSC_ERROR_MES,enumErrorCode::ERROR_REQUEST_PLAYER_NOT_USE_AREA,pPlayer->name,targetPlayerName);
return 0;
}
playerCharacter_t* pTargetPlayer = gcpTools->GetPlayerRecordPointer(targetPlayerName);
if(NULL != pTargetPlayer)
{
if(false == CheckInvalidArea(pTargetPlayer))
{
g_GsToCc.Send(pPlayer,ITEM_SUMMON_SYSTEM,GSC_ERROR_MES,enumErrorCode::ERROR_TARGET_PLAYER_NOT_USE_AREA,pPlayer->name,targetPlayerName);
return 0;
}
g_GsToCc.Send(pTargetPlayer,ITEM_SUMMON_SYSTEM,GSC_REQUEST_PC_MOVE_SUMMON, 0,InventoryItemPos,pPlayer->name,targetPlayerName);
return 0;
}
int Result = g_GsToGms.Send_GMS(
ITEM_SUMMON_SYSTEM,
CC_REQUEST_PC_MOVE_SUMMON,
0,
InventoryItemPos,
pPlayer->name,
targetPlayerName,
g_config.gameServerNo,
CGs_To_Gms::enumCheckType::CHECK_PLAYER2);
if ( -1 == Result )
{
g_GsToCc.Send(pPlayer,ITEM_SUMMON_SYSTEM,GSC_ERROR_MES,enumErrorCode::ERROR_NULL_TARGET_PLAYER,pPlayer->name,targetPlayerName);
return 0;
}
return 0;
}
int CItem_Scroll_Proc::OtherServer_CleintRequest_PC_Move_Summon()
{
int SubType = MSG_ReadShort();
int InventoryItemPos = MSG_ReadLong();
char requestPlayerName[NAMESTRING+1];
sstrncpy( requestPlayerName, MSG_ReadString(), NAMESTRING - 1 );
requestPlayerName[NAMESTRING]=NULL;
char targetPlayerName[NAMESTRING+1];
sstrncpy( targetPlayerName, MSG_ReadString(), NAMESTRING - 1 );
targetPlayerName[NAMESTRING]=NULL;
playerCharacter_t* pTargetPlayer = gcpTools->GetPlayerRecordPointer(targetPlayerName);
if(NULL == pTargetPlayer)
{
g_GsToGms.Send_GMS(
ITEM_SUMMON_SYSTEM,
GSC_ERROR_MES,
enumErrorCode::ERROR_NULL_TARGET_PLAYER,
requestPlayerName,
targetPlayerName,
g_config.gameServerNo,
CGs_To_Gms::enumCheckType::CHECK_PLAYER1);
return 0;
return 0;
}
if(false == CheckInvalidArea(pTargetPlayer))
{
g_GsToGms.Send_GMS(
ITEM_SUMMON_SYSTEM,
GSC_ERROR_MES,
enumErrorCode::ERROR_TARGET_PLAYER_NOT_USE_AREA,
requestPlayerName,
targetPlayerName,
g_config.gameServerNo,
CGs_To_Gms::enumCheckType::CHECK_PLAYER1);
return 0;
}
g_GsToCc.Send(pTargetPlayer,ITEM_SUMMON_SYSTEM,GSC_REQUEST_PC_MOVE_SUMMON, 0,InventoryItemPos,requestPlayerName,targetPlayerName);
return 0;
}
int CItem_Scroll_Proc::Client_Ready_PC_Move_Summon(playerCharacter_t* pPlayer)
{
int SubType = MSG_ReadShort();
int worldIdx = MSG_ReadByte();
vec3_t position;
MSG_ReadPosition(position);
char targetPlayerName[NAMESTRING+1];
sstrncpy( targetPlayerName, MSG_ReadString(), NAMESTRING - 1 );
targetPlayerName[NAMESTRING]=NULL;
GTH_PC_SetSummonsInfo(pPlayer,targetPlayerName,worldIdx,position,tagPcSummonTypedef::enumPcSummonType::PC_SUMMON_MOVE_ITEM);
ReplySummons(pPlayer);
return 0;
}
int CItem_Scroll_Proc::Client_Reply_PC_Move_Summon(playerCharacter_t* pPlayer)
{
int ReplyID = MSG_ReadShort();
char requestPlayerName[NAMESTRING+1];
sstrncpy( requestPlayerName, MSG_ReadString(), NAMESTRING - 1 );
requestPlayerName[NAMESTRING]=NULL;
if(false == CheckInvalidArea(pPlayer))
{
g_GsToGms.Send_GMS(
ITEM_SUMMON_SYSTEM,
GSC_ERROR_MES,
enumErrorCode::ERROR_TARGET_PLAYER_NOT_USE_AREA,
requestPlayerName,
pPlayer->name,
g_config.gameServerNo,
CGs_To_Gms::enumCheckType::CHECK_PLAYER1);
g_GsToCc.Send(pPlayer,ITEM_SUMMON_SYSTEM,GSC_ERROR_MES, enumErrorCode::ERROR_TARGET_PLAYER_NOT_USE_AREA,requestPlayerName,pPlayer->name);
return 0;
}
playerCharacter_t* requestPlayer = gcpTools->GetPlayerRecordPointer(requestPlayerName);
if(NULL == requestPlayer)
{
g_GsToGms.Send_GMS(
ITEM_SUMMON_SYSTEM,
CC_REPLY_PC_MOVE_SUMMON,
ReplyID,
pPlayer->worldIdx,
pPlayer->position,
requestPlayerName,
pPlayer->name,
g_config.gameServerNo,
CGs_To_Gms::enumCheckType::CHECK_PLAYER1);
return 0;
}
if(enumTargetPlayerReply::REPLY_REFUSE == ReplyID)
{
g_GsToCc.Send(requestPlayer,ITEM_SUMMON_SYSTEM,GSC_STATE_MES,enumStateCode::STATE_TARGET_PLAYER_MOVE_REFUSE,
pPlayer->worldIdx,pPlayer->position,requestPlayer->name,pPlayer->name);
return 0;
}
if(false == CheckInvalidArea(requestPlayer))
{
g_GsToCc.Send(requestPlayer,ITEM_SUMMON_SYSTEM,GSC_ERROR_MES, enumErrorCode::ERROR_REQUEST_PLAYER_NOT_USE_AREA,
requestPlayerName,pPlayer->name);
g_GsToCc.Send(pPlayer,ITEM_SUMMON_SYSTEM,GSC_ERROR_MES, enumErrorCode::ERROR_REQUEST_PLAYER_NOT_USE_AREA,
requestPlayerName,pPlayer->name);
return 0;
}
g_GsToCc.Send(requestPlayer,ITEM_SUMMON_SYSTEM,GSC_STATE_MES,enumStateCode::STATE_TARGET_PLAYER_MOVE_OK,
pPlayer->worldIdx,pPlayer->position,requestPlayer->name,pPlayer->name);
return 0;
}
int CItem_Scroll_Proc::Otherserver_from_Reply_Pc_Move_Summon()
{
int SubType = MSG_ReadShort();
int worldIdx = MSG_ReadByte();
vec3_t position;
MSG_ReadPosition(position);
char requestPlayerName[NAMESTRING+1];
char targetPlayerName[NAMESTRING+1];
sstrncpy( requestPlayerName, MSG_ReadString(), NAMESTRING - 1 );
requestPlayerName[NAMESTRING]=NULL;
sstrncpy( targetPlayerName, MSG_ReadString(), NAMESTRING - 1 );
targetPlayerName[NAMESTRING]=NULL;
playerCharacter_t* requestPlayer = gcpTools->GetPlayerRecordPointer(requestPlayerName);
if(NULL == requestPlayer)
{
g_GsToGms.Send_GMS(
ITEM_SUMMON_SYSTEM,
GSC_ERROR_MES,
ERROR_NULL_REQUEST_PLAYER,
requestPlayerName,
targetPlayerName,
g_config.gameServerNo,
CGs_To_Gms::enumCheckType::CHECK_PLAYER2);
return 0;
return 0;
}
if(enumTargetPlayerReply::REPLY_REFUSE == SubType)
{
g_GsToCc.Send(requestPlayer,ITEM_SUMMON_SYSTEM,GSC_STATE_MES,enumStateCode::STATE_TARGET_PLAYER_MOVE_REFUSE,worldIdx,position,requestPlayer->name,targetPlayerName);
return 0;
}
if(false == CheckInvalidArea(requestPlayer))
{
g_GsToGms.Send_GMS(
ITEM_SUMMON_SYSTEM,
GSC_ERROR_MES,
enumErrorCode::ERROR_REQUEST_PLAYER_NOT_USE_AREA,
requestPlayerName,
targetPlayerName,
g_config.gameServerNo,
CGs_To_Gms::enumCheckType::CHECK_PLAYER2);
g_GsToCc.Send(requestPlayer,ITEM_SUMMON_SYSTEM,GSC_ERROR_MES, enumErrorCode::ERROR_REQUEST_PLAYER_NOT_USE_AREA,requestPlayerName,targetPlayerName);
return 0;
}
g_GsToCc.Send(requestPlayer,ITEM_SUMMON_SYSTEM,GSC_STATE_MES,enumStateCode::STATE_TARGET_PLAYER_MOVE_OK,worldIdx,position,requestPlayer->name,targetPlayerName);
return 1;
}
int CItem_Scroll_Proc::ReplySummons(playerCharacter_t *pc)
{
vec3_t position;
vec3_t savePosition;
int saveWorldIdx;
int worldIdx = pc->summonsInfo.worldIdx;
vec_copy( pc->summonsInfo.position, position );
if( pc->isTransform ) GTH_DeleteTransform( pc );
if ( GTH_IsLocalServiceWorld(worldIdx) )
{
if( worldIdx == pc->worldIdx )
{
vec_copy( position, pc->position );
pc->reliableWorldIdx = pc->worldIdx;
vec_copy( pc->position, pc->reliablePosition );
int zoneIdx = GTH_Zone_UpdateCurrentZone(ENTITY_PC, pc->idx, pc->worldIdx, pc->zoneIdx, pc->position);
pc->zoneIdx = zoneIdx;
GTH_SendPCEventMessage_Respawn( pc );
GTH_SendMessage_SyncItemObject( pc );
}
else
{
GTH_Zone_DeleteEntityList(pc->worldIdx, pc->zoneIdx, pc->entityType, pc->idx);
pc->worldIdx = worldIdx;
vec_copy( position, pc->position );
pc->reliableWorldIdx = pc->worldIdx;
vec_copy( pc->position, pc->reliablePosition );
pc->zoneIdx = GTH_Zone_GetZoneIdx( pc->position );
GTH_Zone_AddEntityList(pc->worldIdx, pc->zoneIdx, pc->entityType, pc->idx);
GTH_SendPCEventMessage_Respawn( pc );
pc->ready = false;
g_logSystem->Write("User [%s] Move To Summonning Pos. Pos(%.2f, %.2f, %.2f), World : %d", pc->userID, pc->position[0], pc->position[1], pc->position[2], pc->worldIdx);
}
}
else
{
int memberIdx = GTH_FindServerWithinGroup( worldIdx );
if (memberIdx < 0)
{
g_logSystem->Write("User [%s] Summon Error(worldIdx:%d)", pc->name, pc->worldIdx);
return 0;
}
else
{
saveWorldIdx = pc->worldIdx;
vec_copy(pc->position, savePosition);
pc->worldIdx = worldIdx;
vec_copy(position, pc->position);
pc->flagChangeServer = 1;
pc->changeServerWorldIdx = worldIdx;
DB_SaveGameData( pc, SAVEGAMEDATA_QUIT);
pc->worldIdx = saveWorldIdx;
vec_copy(savePosition, pc->position);
}
}
GTH_SendMessage_ReplySummons(1, pc->summonsInfo.summoner, pc->name);
GTH_PC_InitSummonsInfo( pc );
return 1;
}
| C++ |
#if !defined(AFX_NEWDANBATTLESYSTEM_H__12E6C569_671E_44EE_93DD_EE548AC47392__INCLUDED_)
#define AFX_NEWDANBATTLESYSTEM_H__12E6C569_671E_44EE_93DD_EE548AC47392__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif _MSC_VER > 1000
class NewDanBattleSystem
{
public:
struct DanBaseInfo
{
int nDanIdx;
char szGuildName[GUILDNAMESTRING+1];
int nKillPoint;
int nRemainPoint;
int nRequest_AcceptPcIdx;
__int64 nRequest_AcceptPcEXP;
tagGCPacket_NewDanBattle::enumwincode wincode;
struct sDanBattleMember
{
char name[NAMESTRING+1];
int PcIdx;
int killPoint;
int nAccumulationBattleKillPoint;
__int64 exp;
};
std::vector<sDanBattleMember> v_GuildMembers;
};
struct DanBattleInfo
{
enum enumBattleMode
{
BATTLEMODE_FRIENDSHIP,
BATTLEMODE_GENERAL,
};
enum enumBattleStatus
{
BATTLESTATUS_NONE,
BATTLESTATUS_REGIST,
BATTLESTATUS_READY,
BATTLESTATUS_BATTLE,
BATTLESTATUS_END,
};
enum enumEndType
{
REMAIN_MEMBER_COUNT =0 ,
TIME_OUT,
SYSTEM,
};
enum enumBattleMode BattleMode;
enum enumBattleStatus BattleStatus;
struct DanBaseInfo RequestDanInfo;
struct DanBaseInfo AcceptDanInfo;
float fRemainTime;
int nBattleMapIdx;
float fItemDropRate;
int nDanBattleIdx;
float fWaitTimeforReady;
float fBattleSec;
float fWaitTimeforEnd;
float fNextSyncdTime;
float fMinBattleProcessTime;
enumEndType endType;
BOOL bPlunderPremiumItem;
int ServerGroupIdx;
char szBestID[NAMESTRING];
};
enum noticetype
{
notice =0,
killpoint_notice,
plunder_notice,
max_notice,
};
public:
enum
{
MIN_GUILD_MEMBER_NUMBER_FOR_DAN_BATTLE = 3,
MAX_DANBATTLE_COUNT = 500,
SYNC_TIME = 60000 * 5,
POWE_END_WAIT_SEC = 60000,
MIN_BATTLE_PROCESS_SEC = 600000,
};
public:
BOOL m_bActive;
int m_nMinPcCount;
int m_nBattleTimeForMin1;
int m_nBattleTimeForMin2;
float m_fItemDropRate;
float m_WaitTimeforReady;
float m_WaitTimeforEnd;
protected:
DanBattleInfo m_DanBattleInfo[MAX_DANBATTLE_COUNT];
public:
void Update();
void BattleReady(DanBattleInfo* pDanBattleInfo);
void Battle(DanBattleInfo* pDanBattleInfo);
void BattleEnd(DanBattleInfo* pDanBattleInfo);
void SetDanBatttleStatus(DanBattleInfo* pDanBattleInfo, DanBattleInfo::enumBattleStatus status);
DanBattleInfo* GetEmptyDanBattleSlot(int& nIdx_OUT);
void InitDanBatlleInfo(DanBattleInfo* pDanBattleInfo);
DanBattleInfo* InsertDanBattle(int RequestDanIdx,
int RequestPcIdx,
std::vector<DanBaseInfo::sDanBattleMember>& vRequestGuildMember,
int AcceptDanIdx,
int AcceptPcIdx,
std::vector<DanBaseInfo::sDanBattleMember>& vAcceptGuildMember,
enum NewDanBattleSystem::DanBattleInfo::enumBattleMode battlemode,
int WorldIdx,
int BattleTIme ,
__int64 RequestPcExp,
__int64 AcceptPcExp,
BOOL IsAllowPrimiumItemPlunder);
BOOL InsertDanBattleMemeber(int DanBattleIdx, int GuildIdx, int Pcidx);
DanBattleInfo* GetDanBattleInfo(const int nGuildIdx);
DanBattleInfo* GetDanBattleInfo(const char* szGuildName);
DanBattleInfo* GetDanBattleInfo(const int nBattleIdx, const int nGuildIdx);
DanBattleInfo* GetDanBattleInfo(const int nBattleIdx, DanBattleInfo::enumBattleStatus status);
DanBaseInfo* GetEnemyDanBaseInfo(const int nBattleIdx, const int nGuildIdx);
DanBaseInfo* GetDanBaseInfo(DanBattleInfo* pDanBattleInfo, const int nGuildIdx);
DanBaseInfo::sDanBattleMember*GetDanBattleMember(DanBattleInfo* pDanBattleInfo, int GuildIdx, char* pcname);
BOOL IsDanBattleEnemy(int myPcIdx, int EnemyIdx);
BOOL IsInsertdDanBattle(int GuildIdx);
BOOL DecsionDanBattleWinTO_LiveMemberNumber(DanBattleInfo* pDanBattleInfo);
BOOL DecsionDanBattleWinTO_TimeOut(DanBattleInfo* pDanBattleInfo);
void DecsionDanBattleBestMember(DanBattleInfo* pDanBattleInfo);
void RemainTimeBroadCastMsg(DanBattleInfo* pDanBattleInfo);
public:
NewDanBattleSystem();
virtual ~NewDanBattleSystem();
};
#endif
| C++ |
#include "../global.h"
extern i3socket_t gsSocket;
#include "../Tools/CTools.h"
extern CTools* gcpTools;
void GTH_ProcessMessage_RequestNpcChat()
{
int idx, reply = 1, error = 1;
idx = MSG_ReadShort();
NPC_InitAI( g_curPC, idx );
GTH_SendMessage_ReplyNpcChat( g_curPC, reply, error );
}
void GTH_ProcessMessage_RequestQuitNpcChat()
{
AI_NPC_CloseMessage( (void*)g_curPC,NULL );
}
void GTH_ProcessMessage_RequestNpcSelectMessage()
{
int reply = 1, error = 1;
int curIdx = -1;
curIdx = MSG_ReadByte();
g_curPC->npcAi.pcReplyIdx = curIdx;
}
void GTH_ProcessMessage_RequestStore()
{
}
void GTH_ProcessMessage_RequestBuyItem()
{
storeStruct_t *store;
int storeItemIdx, itemIdx, npcIdx, storeIdx, inventoryPos, itemTableIdx, num;
int reply = 1, error = 0, buycost;
item_t buyItem;
char generateID[20];
item_t *upItem;
int stackItemIdx;
int bIsStack = false;
int stackNumber = 1;
storeIdx = g_curPC->storeIdx;
npcIdx = g_curPC->npcIdx;
if( storeIdx < 0 )
{
reply = 0;
error = ERROR_BUYITEM_2;
goto REPLY_BUYITEM;
}
store = &g_store[storeIdx];
storeItemIdx = MSG_ReadShort();
num = MSG_ReadShort();
if( store->item[storeItemIdx].curNumber == 0 )
{
reply = 0;
error = ERROR_BUYITEM_2;
goto REPLY_BUYITEM;
}
memcpy( &buyItem, &store->item[storeItemIdx].item, sizeof( item_t ) );
itemTableIdx = buyItem.itemTableIdx;
if( itemTableIdx >= g_itemTableNumber || itemTableIdx < 0 || num <= 0 )
{
g_logSystem->Write( "Shop Error!! Index Out of Range : %s(%s), %s(%d)npc , BuyItem %s(%d), Table Index : %d", g_curPC->name, g_curPC->userID,
g_monster[npcIdx].basic.name, npcIdx, buyItem.name, storeItemIdx, itemTableIdx );
reply = 0;
error = ERROR_BUYITEM_2;
goto REPLY_BUYITEM;
}
buycost = store->item[storeItemIdx].price * num;
if( buycost > g_curPC->curChargeSE )
{
reply = 0;
error = ERROR_BUYITEM_1;
goto REPLY_BUYITEM;
}
if( g_curPC->curItemWeight > g_curPC->calItemWeight )
{
reply = 0;
error = ERROR_BUYITEM_5;
goto REPLY_BUYITEM;
}
if( GTH_IsStackItem( &buyItem ) )
{
buyItem.durability = num - 1;
bIsStack = true;
stackNumber = num;
}
stackItemIdx = GTH_StackMyItem( g_curPC, &buyItem );
if( stackItemIdx >= 0 )
{
upItem = &g_curPC->item[stackItemIdx];
upItem->durability += buyItem.durability + 1;
if( upItem->durability + 1 >= MAX_COUNT_STACK_ITEM ) upItem->durability = MAX_COUNT_STACK_ITEM - 1;
g_DBGameServer->SaveItem( g_curPC, upItem, stackItemIdx );
g_logSystem->WriteToLog( g_curPC, LOG_CLASS_ITEM, "%d;%d;%d;;;%s;%s",
LOG_CLASS_ITEM_BUY_STORE, stackNumber, buycost, buyItem.name,
GetItemInformationLog( bIsStack, buyItem.itemTableIdx, stackItemIdx, -1 ) );
}
else
{
inventoryPos = GTH_FindEmptyInventoryPos( g_curPC );
if( inventoryPos < 0 )
{
reply = 0;
error = ERROR_BUYITEM_3;
goto REPLY_BUYITEM;
}
itemIdx = GTH_AddMyItem( g_curPC, &buyItem );
if (itemIdx == -1)
{
reply = 0;
error = ERROR_BUYITEM_3;
goto REPLY_BUYITEM;
}
g_curPC->inventory[inventoryPos] = itemIdx;
strcpy(generateID, "storeGenID");
g_DBGameServer->AddItem(g_curPC, &buyItem, itemIdx, generateID);
g_logSystem->WriteToLog( g_curPC, LOG_CLASS_ITEM, "%d;%d;%d;;;%s;%s",
LOG_CLASS_ITEM_BUY_STORE, stackNumber, buycost, buyItem.name,
GetItemInformationLog( bIsStack, buyItem.itemTableIdx, itemIdx, inventoryPos ) );
}
g_curPC->curChargeSE -= buycost;
g_curPC->curItemWeight += g_itemTable[buyItem.itemTableIdx].weight;
g_logSystem->Write("User [%s](%s) Buy '%s' Item, Pay : %dSE.", g_curPC->name, g_curPC->userID, g_itemTable[itemTableIdx].name, buycost );
REPLY_BUYITEM :
if( reply && store->item[storeItemIdx].curNumber > 0 ) store->item[storeItemIdx].curNumber --;
GTH_SendMessage_ReplyBuyItem( g_curPC, reply, error, &buyItem, storeItemIdx, store->item[storeItemIdx].curNumber );
}
void GTH_ProcessMessage_RequestSellItem()
{
int reply = 1, error = 0;
int itemIdx, itemTableIdx;
int sellcost;
item_t *item;
int bIsStack = false, stackNumber = 1;
itemIdx = g_curPC->mouseInventory;
if( itemIdx < 0 )
{
reply = 0;
error = ERROR_SELLITEM_1;
g_logSystem->Write( "Shop Error!! : %s(%s), Mouse Inventory, Index Out of Range. %d", g_curPC->name, g_curPC->userID, g_curPC->mouseInventory );
goto REPLY_SELLITEM;
}
item = &g_curPC->item[itemIdx];
itemTableIdx = item->itemTableIdx;
if( itemTableIdx < 0 )
{
reply = 0;
error = ERROR_SELLITEM_1;
g_logSystem->Write( "Shop Error!! : %s(%s), Mouse Inventory, Index Out of Range. %d", g_curPC->name, g_curPC->userID, g_curPC->mouseInventory );
goto REPLY_SELLITEM;
}
if( g_itemTable[itemTableIdx].stackFlag )
{
bIsStack = true;
stackNumber = item->durability + 1;
}
sellcost = GTH_GetSellPrice( item );
g_curPC->curChargeSE += sellcost;
if( g_curPC->curChargeSE > MAX_OWN_NAK ) g_curPC->curChargeSE = MAX_OWN_NAK;
g_curPC->curItemWeight -= g_itemTable[item->itemTableIdx].weight;
g_logSystem->WriteToLog( g_curPC, LOG_CLASS_ITEM, "%d;%d;%d;;;%s;%s",
LOG_CLASS_ITEM_SELL_STORE, stackNumber, sellcost, item->name,
GetItemInformationLog( bIsStack, item->itemTableIdx, itemIdx, -1 ) );
GTH_DeleteMyItem( g_curPC, item );
g_curPC->mouseInventory = -1;
g_DBGameServer->RemoveItem(g_curPC, itemIdx);
g_logSystem->Write("User [%s](ID: %s) Sell Item '%s', Receive : %dSE", g_curPC->name, g_curPC->userID, g_itemTable[itemTableIdx].name, sellcost);
REPLY_SELLITEM:
GTH_SendMessage_ReplySellItem( g_curPC, reply, error, itemIdx );
}
void GTH_ProcessMessage_Binding()
{
int bindingIdx;
int reply = 1, error = 0;
int bindingCost = 0, type;
int worldIdx;
vec3_t position;
type = MSG_ReadByte();
bindingIdx = MSG_ReadByte();
bindingCost = MSG_ReadLong();
if( type == 0 )
{
bindingCost = g_binding[bindingIdx].cost;
if( bindingIdx < 0 || bindingIdx > g_bindingNumber )
{
reply = 0;
error = 0;
GTH_SendMessage_ReplyBinding( g_curPC, reply, error, 1, bindingIdx, bindingCost );
return;
}
if( g_curPC->curChargeSE < bindingCost )
{
reply = 0;
error = 1;
GTH_SendMessage_ReplyBinding( g_curPC, reply, error, 1, bindingIdx, bindingCost );
return;
}
g_curPC->curChargeSE -= bindingCost;
g_curPC->bindingIdx = bindingIdx;
GTH_SendMessage_ReplyBinding( g_curPC, reply, error, 1, bindingIdx, bindingCost );
}
else
{
if( bindingIdx < 0 || bindingIdx > g_bindingNumber )
{
reply = 0;
error = 0;
GTH_SendMessage_ReplyBinding( g_curPC, reply, error, 3, bindingIdx, bindingCost );
return;
}
if( g_curPC->curChargeSE < bindingCost || bindingCost < 0 )
{
reply = 0;
error = 1;
GTH_SendMessage_ReplyBinding( g_curPC, reply, error, 3, bindingIdx, bindingCost );
return;
}
worldIdx = g_binding[bindingIdx].worldIdx;
vec_copy( g_binding[bindingIdx].pos, position );
g_curPC->curChargeSE -= bindingCost;
AI_NPC_CloseMessage( (void*)g_curPC,NULL );
GTH_SendMessage_ReplyBinding( g_curPC, reply, error, 3, bindingIdx, bindingCost );
GTH_TransportWorldWithNPC( g_curPC, worldIdx, position );
}
}
enum
{
EPACK_STORE_ERROR_CHARGE_SE=0,
EPACK_STORE_ERROR_CHARGE_TYPE,
EPACK_STORE_ERROR_EQUIP,
EPACK_STORE_ERROR_CHARGE_COUNT,
EPACK_STORE_ERROR_DELETE_EPK,
};
void GTH_ProcessMessage_EpackStore()
{
int type, storeIdx;
int num;
int reply = 1, error = 0;
int value;
int epackIdx;
int itemTableIdx;
int EpkRemainCount=0;
storeStruct_t *store;
type = MSG_ReadByte();
num = MSG_ReadShort();
storeIdx = g_curPC->storeIdx;
if( storeIdx < 0 )
{
reply = 0;
error = 0;
goto REPLY_EPACKSTORE;
}
if(storeIdx < 0 || storeIdx >= MAX_STORES) return;
store = &g_store[storeIdx];
epackIdx = g_curPC->equipment[EQUIP_EPACK];
if(epackIdx < 0 || epackIdx >= MAX_NUMBER_OF_OWNITEM)
{
reply = 0;
error = EPACK_STORE_ERROR_EQUIP;
goto REPLY_EPACKSTORE;
}
itemTableIdx = g_curPC->item[epackIdx].itemTableIdx;
if(itemTableIdx < 0 || itemTableIdx >= MAX_NUMBER_OF_ITEM_TABLE) return;
if( g_itemTable[itemTableIdx].epkChargeMethod == TypeItemTable_t::EPK_CHARGE_TYPE_ITEM)
{
reply = 0;
error = EPACK_STORE_ERROR_CHARGE_TYPE;
goto REPLY_EPACKSTORE;
}
if(g_itemTable[itemTableIdx].epkChargeType == TypeItemTable_t::EPK_TYPE_CHARGE)
{
EpkRemainCount = gcpTools->GetEpkChargeCount(&g_curPC->item[epackIdx]);
if( EpkRemainCount <= 0 )
{
if((int)g_curPC->curChargeRA <=0 && (int)g_curPC->curChargeSA <=0 )
{
GTH_DeleteMyItem( g_curPC, &g_curPC->item[epackIdx] );
g_curPC->equipment[EQUIP_EPACK] = -1;
g_DBGameServer->RemoveItem( g_curPC, epackIdx );
reply = 0;
error = EPACK_STORE_ERROR_DELETE_EPK;
goto REPLY_EPACKSTORE;
}
else
{
reply = 0;
error = EPACK_STORE_ERROR_CHARGE_COUNT;
goto REPLY_EPACKSTORE;
}
return;
}
}
switch( type )
{
case 0 :
value = (int)GetEpackRechargePrice_RA( g_curPC->onceRecoveryRA, store->chargeRACost, g_itemTable[itemTableIdx].level ) * num;
if( value > g_curPC->curChargeSE )
{
reply = 0;
error = EPACK_STORE_ERROR_CHARGE_SE;
goto REPLY_EPACKSTORE;
}
g_curPC->curChargeSE -= value;
g_curPC->curChargeRA += num;
if( g_curPC->curChargeRA > g_curPC->maxChargeRA ) g_curPC->curChargeRA = g_curPC->maxChargeRA;
break;
case 1 :
value = (int)GetEpackRechargePrice_SA( g_curPC->onceRecoverySA, store->chargeSACost, g_itemTable[itemTableIdx].level ) * num;
if( value > g_curPC->curChargeSE )
{
reply = 0;
error = EPACK_STORE_ERROR_CHARGE_SE;
goto REPLY_EPACKSTORE;
}
g_curPC->curChargeSE -= value;
g_curPC->curChargeSA += num;
if( g_curPC->curChargeSA > g_curPC->maxChargeSA ) g_curPC->curChargeSA = g_curPC->maxChargeSA;
break;
}
if(g_itemTable[itemTableIdx].epkChargeType == TypeItemTable_t::EPK_TYPE_MUCH_CAPACITY && g_itemTable[itemTableIdx].epkChargeType == TypeItemTable_t::EPK_TYPE_CHARGE)
{
EpkRemainCount--;
gcpTools->SetEpkChargeCount(&g_curPC->item[epackIdx],EpkRemainCount);
g_DBGameServer->SaveItem( g_curPC, &g_curPC->item[epackIdx], epackIdx);
}
REPLY_EPACKSTORE :
GTH_SendMessage_ReplyEpackStore( g_curPC, reply, error,EpkRemainCount );
}
void GTH_ProcessMessage_AllRepairItem(int invenPos)
{
int reply = 1, error = 0;
int itemIdx, itemTableIdx, dur;
int numOfRepairItem = 0, i;
int repairItemIdx[NUM_EQUIP_POSITION], repairItemDur[NUM_EQUIP_POSITION];
item_t *item;
for( i = EQUIP_WEAPON_1; i < EQUIP_EPACK; i ++ )
{
itemIdx = g_curPC->equipment[i];
if( itemIdx < 0 ) continue;
item = &g_curPC->item[itemIdx];
itemTableIdx = item->itemTableIdx;
if( !GTH_IsRepairItem( item ) ) continue;
GTH_GetRepairCost( item, g_curPC->curChargeSE, dur );
if( dur == 0 ) continue;
item->durability += dur;
if( item->durability > g_itemTable[itemTableIdx].durability )
item->durability = g_itemTable[itemTableIdx].durability;
g_DBGameServer->SaveItem( g_curPC, item, itemIdx );
repairItemIdx[numOfRepairItem] = itemIdx;
repairItemDur[numOfRepairItem] = item->durability;
numOfRepairItem ++;
}
GTH_SendMessage_Reply_MasicBook_RepairItem( g_curPC, reply, error, repairItemIdx, repairItemDur, numOfRepairItem ,invenPos);
}
void GTH_ProcessMessage_RepairItem()
{
int reply = 1, error = 0;
int type, pos, itemIdx, itemTableIdx, dur;
int cost, numOfRepairItem = 0, i;
int repairItemIdx[NUM_EQUIP_POSITION], repairItemDur[NUM_EQUIP_POSITION];
item_t *item;
type = MSG_ReadByte();
pos = MSG_ReadShort();
if( pos < 0 ) return;
switch( type )
{
case REPAIR_ITEM_SUB0 : case REPAIR_ITEM_SUB1 :
if( type == 0 ) itemIdx = g_curPC->inventory[pos];
else itemIdx = g_curPC->equipment[pos];
if( itemIdx < 0 )
{
reply = 0;
error = ERROR_REPAIRITEM_2;
goto REPLY_REPAIR_ITEM;
}
item = &g_curPC->item[itemIdx];
if( !GTH_IsRepairItem( item ) )
{
reply = 0;
error = ERROR_REPAIRITEM_2;
goto REPLY_REPAIR_ITEM;
}
if ( g_curPC->PremiumInfo.iMemberShipType ==
playerCharacter_t::tagPremiumInfo::enumMeberShipType::Free)
{
if ( item->durability < g_curPC->PremiumInfo.ItemDurability.iPrepareRequirdurability )
{
reply = 0;
error = ERROR_REPAIRITEM_3;
goto REPLY_REPAIR_ITEM;
}
}
itemTableIdx = item->itemTableIdx;
cost = GTH_GetRepairCost( item, g_curPC->curChargeSE, dur );
cost = cost * g_curPC->PremiumInfo.ItemDurability.fRepareCostRate;
if( g_curPC->curChargeSE < cost || dur == 0 )
{
reply = 0;
error = ERROR_REPAIRITEM_1;
goto REPLY_REPAIR_ITEM;
}
g_curPC->curChargeSE -= cost;
item->durability += dur;
if( item->durability > g_itemTable[itemTableIdx].durability )
item->durability = g_itemTable[itemTableIdx].durability;
g_DBGameServer->SaveItem( g_curPC, item, itemIdx );
repairItemIdx[0] = itemIdx;
repairItemDur[0] = item->durability;
goto REPLY_REPAIR_ITEM;
break;
case REPAIR_ITEM_ALL :
for( i = EQUIP_WEAPON_1; i < EQUIP_EPACK; i ++ )
{
itemIdx = g_curPC->equipment[i];
if( itemIdx < 0 ) continue;
item = &g_curPC->item[itemIdx];
itemTableIdx = item->itemTableIdx;
if( !GTH_IsRepairItem( item ) ) continue;
cost = GTH_GetRepairCost( item, g_curPC->curChargeSE, dur );
cost = cost * g_curPC->PremiumInfo.ItemDurability.fRepareCostRate;
if( g_curPC->curChargeSE < cost || dur == 0 ) continue;
g_curPC->curChargeSE -= cost;
item->durability += dur;
if( item->durability > g_itemTable[itemTableIdx].durability )
item->durability = g_itemTable[itemTableIdx].durability;
g_DBGameServer->SaveItem( g_curPC, item, itemIdx );
repairItemIdx[numOfRepairItem] = itemIdx;
repairItemDur[numOfRepairItem] = item->durability;
numOfRepairItem ++;
}
goto REPLY_REPAIR_ITEM;
break;
}
REPLY_REPAIR_ITEM :
GTH_SendMessage_ReplyRepairItem( g_curPC, reply, error, type, repairItemIdx, repairItemDur, numOfRepairItem );
}
void GTH_ProcessMessage_Request_Buy_Skill()
{
storeStruct_t *store;
int storeIdx, storeItemIdx, itemIdx, inventoryPos, i;
int reply = 1, error = 0, buySphereCost;
int skillTableIdx, skillIdx;
item_t *upItem;
CSkilTable *pSkillTable;
storeIdx = g_curPC->storeIdx;
if( storeIdx < 0 )
{
reply = 0;
error = ERROR_BUYSKILL_2;
goto REPLY_BUYSKILL;
}
store = &g_store[storeIdx];
storeItemIdx = MSG_ReadShort();
skillTableIdx = store->item[storeItemIdx].item.itemTableIdx - STORE_SKILL_MASK;
buySphereCost = store->item[storeItemIdx].price;
if( skillTableIdx < 0 || skillTableIdx >= MAX_SKILL_NUMBER )
{
reply = 0;
error = ERROR_BUYSKILL_2;
g_logSystem->Write("User '%s'(ID: %s) Buy TableIdx : %d Skill, Index Out of Range.", g_curPC->name, g_curPC->userID, skillTableIdx );
goto REPLY_BUYSKILL;
}
if( !GTH_CheckRequire( g_curPC, 1, &skillTableIdx ) )
{
reply = 0;
error = ERROR_BUYSKILL_3;
goto REPLY_BUYSKILL;
}
if( g_SkillLogic.SKILL_IsValid( g_curPC, skillTableIdx ) )
{
reply = 0;
error = ERROR_BUYSKILL_4;
goto REPLY_BUYSKILL;
}
for( i = 0; i < MAX_INVENTORY_SIZE; i ++ )
{
itemIdx = g_curPC->inventory[i];
if( itemIdx < 0 ) continue;
upItem = &g_curPC->item[itemIdx];
if( upItem->itemTableIdx == ITEM_TABLE_IDX_GEN_SPHERE ) break;
}
if( i == MAX_INVENTORY_SIZE )
{
reply = 0;
error = ERROR_BUYSKILL_1;
goto REPLY_BUYSKILL;
}
if( upItem->durability + 1 < buySphereCost )
{
reply = 0;
error = ERROR_BUYSKILL_1;
goto REPLY_BUYSKILL;
}
inventoryPos = i;
skillIdx = g_SkillLogic.SKILL_Add( g_curPC, skillTableIdx );
if( skillIdx < 0 )
{
reply = 0;
error = ERROR_BUYSKILL_5;
goto REPLY_BUYSKILL;
}
upItem->durability -= buySphereCost;
if( upItem->durability < 0 )
{
g_curPC->inventory[inventoryPos] = -1;
g_logSystem->WriteToLog( g_curPC, LOG_CLASS_ITEM, "%d;%d;;;;%s;%s",
LOG_CLASS_ITEM_LEARN_SKILL, buySphereCost, upItem->name,
GetItemInformationLog( 0, upItem->itemTableIdx, itemIdx, -1 ) );
GTH_DeleteMyItem( g_curPC, upItem );
g_DBGameServer->RemoveItem( g_curPC, itemIdx );
}
else
{
g_logSystem->WriteToLog( g_curPC, LOG_CLASS_ITEM, "%d;%d;;;;%s;%s",
LOG_CLASS_ITEM_LEARN_SKILL, buySphereCost, upItem->name,
GetItemInformationLog( 1, upItem->itemTableIdx, itemIdx, -1 ) );
g_DBGameServer->SaveItem( g_curPC, upItem, itemIdx );
}
pSkillTable = g_SkillTableDB.FindDB(skillTableIdx);
if(pSkillTable==NULL)
{
g_logSystem->Write("User '%s'(ID: %s) Buy '%s' Skill.", g_curPC->name, g_curPC->userID,"pSkillTable==NULL");
}
else
{
g_logSystem->Write("User '%s'(ID: %s) Buy Skill Table Index %d Skill.", g_curPC->name, g_curPC->userID,skillTableIdx);
}
REPLY_BUYSKILL :
GTH_SendMessage_ReplyBuySkill( g_curPC, reply, error, inventoryPos, buySphereCost, skillIdx );
}
void GTH_ProcessMessage_Request_Buy_GambleItem()
{
storeStruct_t *store;
int storeItemIdx, itemIdx, npcIdx, storeIdx, inventoryPos, itemTableIdx, num;
int reply = 1, error = 0, buycost;
item_t buyItem;
char generateID[20];
item_t *upItem;
int stackItemIdx;
int bIsStack = false;
int stackNumber = 1;
int itemTblIdx = -1;
storeIdx = g_curPC->storeIdx;
npcIdx = g_curPC->npcIdx;
store = &g_store[storeIdx];
storeItemIdx = MSG_ReadShort();
num = MSG_ReadShort();
float r = 0.0f, accPro = 0.0f;
r = GTH_Random();
int selectidx = g_curPC->RegGambleItems[storeItemIdx];;
accPro = 0.0f;
r = GTH_Random();
int OptionCount = 0;
for( int i = 0; i < MAX_GAMBLE_SELECTOPTION ; i ++ )
{
if ( g_logic.gambleSelectOptionTable[i].SelectOptionRate <= 0.0)
continue;
accPro += (float) g_logic.gambleSelectOptionTable[i].SelectOptionRate * 0.01;
if( r < accPro ) break;
OptionCount++;
}
if ( OptionCount > 6) OptionCount = 6;
switch(g_itemTable[selectidx].rarity)
{
case 0:
if ( OptionCount > 2 ) OptionCount = 2;
break;
case 1:
if ( OptionCount > 3 ) OptionCount = 3;
break;
}
SpawnItem(&buyItem,selectidx, OptionCount, 1, 0, 1 );
itemTableIdx = buyItem.itemTableIdx;
if( itemTableIdx >= g_itemTableNumber || itemTableIdx < 0 || num <= 0 )
{
g_logSystem->Write( "Shop Error!! Index Out of Range : %s(%s), %s(%d)npc , BuyItem %s(%d), Table Index : %d", g_curPC->name, g_curPC->userID,
g_monster[npcIdx].basic.name, npcIdx, buyItem.name, storeItemIdx, itemTableIdx );
reply = 0;
error = ERROR_BUYITEM_2;
goto REPLY_BUYITEM;
}
buycost = g_curPC->RegGamblePrice[storeItemIdx] * num;
if( buycost > g_curPC->curChargeSE )
{
reply = 0;
error = ERROR_BUYITEM_1;
goto REPLY_BUYITEM;
}
if( g_curPC->curItemWeight > g_curPC->calItemWeight )
{
reply = 0;
error = ERROR_BUYITEM_5;
goto REPLY_BUYITEM;
}
if( GTH_IsStackItem( &buyItem ) )
{
buyItem.durability = num - 1;
bIsStack = true;
stackNumber = num;
}
stackItemIdx = GTH_StackMyItem( g_curPC, &buyItem );
if( stackItemIdx >= 0 )
{
upItem = &g_curPC->item[stackItemIdx];
upItem->durability += buyItem.durability + 1;
if( upItem->durability + 1 >= MAX_COUNT_STACK_ITEM ) upItem->durability = MAX_COUNT_STACK_ITEM - 1;
g_DBGameServer->SaveItem( g_curPC, upItem, stackItemIdx );
g_logSystem->WriteToLog( g_curPC, LOG_CLASS_ITEM, "%d;%d;%d;;;%s;%s",
LOG_CLASS_ITEM_BUY_STORE, stackNumber, buycost, buyItem.name,
GetItemInformationLog( bIsStack, buyItem.itemTableIdx, stackItemIdx, -1 ) );
}
else
{
inventoryPos = GTH_FindEmptyInventoryPos( g_curPC );
if( inventoryPos < 0 )
{
reply = 0;
error = ERROR_BUYITEM_3;
goto REPLY_BUYITEM;
}
itemIdx = GTH_AddMyItem( g_curPC, &buyItem );
if (itemIdx == -1)
{
reply = 0;
error = ERROR_BUYITEM_3;
goto REPLY_BUYITEM;
}
g_curPC->inventory[inventoryPos] = itemIdx;
strcpy(generateID, "storeGenID");
g_DBGameServer->AddItem(g_curPC, &buyItem, itemIdx, generateID);
g_logSystem->WriteToLog( g_curPC, LOG_CLASS_ITEM, "%d;%d;%d;;;%s;%s",
LOG_CLASS_ITEM_BUY_STORE, stackNumber, buycost, buyItem.name,
GetItemInformationLog( bIsStack, buyItem.itemTableIdx, itemIdx, inventoryPos ) );
}
g_curPC->curChargeSE -= buycost;
g_curPC->curItemWeight += g_itemTable[buyItem.itemTableIdx].weight;
g_logSystem->Write("User [%s](%s) Buy '%s' Item, Pay : %dSE.", g_curPC->name, g_curPC->userID, g_itemTable[itemTableIdx].name, buycost );
REPLY_BUYITEM :
if( reply && store->item[storeItemIdx].curNumber > 0 ) store->item[storeItemIdx].curNumber --;
GTH_SendMessage_ReplyBuyItem( g_curPC, reply, error, &buyItem, storeItemIdx, store->item[storeItemIdx].curNumber );
}
void GTH_ProcessMessage_RepairItemConfirm()
{
short PacketGroup = static_cast<enumExtendSecondPacket_ItemRepare>(MSG_ReadShort());
if ( PacketGroup != CC_ITEM_REPAIR)
return;
enumRepairType repairType;
enumInvenType InvenType;
int pos = 0;
int itemIdxInPc = 0;
int reply = 0;
int error = ERROR_REPAIRITEM_2;
int RepairItemCount = 0;
int cost = 0;
int itemTableIdx= -1;
item_t *pItem = NULL;
repairType = static_cast<enumRepairType>(MSG_ReadByte());
InvenType = static_cast<enumInvenType>(MSG_ReadByte());
pos = MSG_ReadByte();
switch(repairType)
{
case REPAIR_ITEM_SUB0:
case REPAIR_ITEM_SUB1:
{
if( InvenType == INVENTYPE_INVENTORY )
itemIdxInPc = g_curPC->inventory[pos];
else itemIdxInPc = g_curPC->equipment[pos];
if( itemIdxInPc < 0 )
{
reply = 0;
error = ERROR_REPAIRITEM_2;
goto REPLY_REPAIR_ITEM;
}
pItem = &g_curPC->item[itemIdxInPc];
if( !GTH_IsRepairItem( pItem ) )
{
reply = 0;
error = ERROR_REPAIRITEM_2;
goto REPLY_REPAIR_ITEM;
}
if ( g_curPC->PremiumInfo.iMemberShipType ==
playerCharacter_t::tagPremiumInfo::enumMeberShipType::Free)
{
if ( pItem->durability < g_curPC->PremiumInfo.ItemDurability.iPrepareRequirdurability )
{
reply = 0;
error = ERROR_REPAIRITEM_3;
goto REPLY_REPAIR_ITEM;
}
}
if ( pItem->itemTableIdx < 0 )
{
reply = 0;
error = ERROR_REPAIRITEM_2;
goto REPLY_REPAIR_ITEM;
}
itemTableIdx = g_itemTable[pItem->itemTableIdx].idx;
cost = GTH_GetRepairCost( pItem, g_curPC->curChargeSE, RepairItemCount );
cost = cost * g_curPC->PremiumInfo.ItemDurability.fRepareCostRate;
reply = 1;
}break;
case REPAIR_ITEM_ALL:
{
cost = 0;
for( int i = EQUIP_WEAPON_1; i < EQUIP_EPACK; i ++ )
{
itemIdxInPc= g_curPC->equipment[i];
if( itemIdxInPc < 0 ) continue;
pItem = &g_curPC->item[itemIdxInPc];
itemTableIdx = pItem->itemTableIdx;
if( !GTH_IsRepairItem( pItem ) ) continue;
int RepairCost = GTH_GetRepairCost( pItem, g_curPC->curChargeSE, RepairItemCount );
if ( g_curPC->PremiumInfo.iMemberShipType ==
playerCharacter_t::tagPremiumInfo::enumMeberShipType::Free)
{
if ( pItem->durability < g_curPC->PremiumInfo.ItemDurability.iPrepareRequirdurability )
{
reply = 0;
error = ERROR_REPAIRITEM_4;
goto REPLY_REPAIR_ITEM;
}
}
RepairCost = RepairCost * g_curPC->PremiumInfo.ItemDurability.fRepareCostRate;
if( g_curPC->curChargeSE < RepairCost || RepairItemCount == 0 ) continue;
cost += RepairCost;
}
reply = 1;
}
break;
}
REPLY_REPAIR_ITEM:
GTH_SendMessage_Reply_RepairItemConfirm(g_curPC, reply, error, repairType, cost, RepairItemCount, itemTableIdx);
} | C++ |
#ifndef _DAN_H_
#define _DAN_H_
#include <LIST>
#define DAN_BATTLEMAP_NO 20
#define DAN_KILL_POINT 1
#define DAN_BATTLE_BROADCAST_TIME 60000
#define SZ_BATTLE_CACHE 24
#define SZ_BATTLE_REQUEST 20
typedef struct BATTLE_RECORD
{
int No;
}*LPBATTLE_RECORD;
typedef struct REQUEST_RECORD
{
int No;
int ServerNo;
int ServerID;
int DanIdx;
char DanName[GUILDNAMESTRING];
char MasterName[NAMESTRING];
}*LPREQUEST_RECORD;
enum
{
DBTL_STATUS_STARTUP = 0,
DBTL_STATUS_READY,
DBTL_STATUS_MOVE,
DBTL_STATUS_START,
DBTL_STATUS_END,
DBTL_STATUS_LOOSE_MOVE,
DBTL_STATUS_CLEAR,
DBTL_STATUS_EVENT,
DBTL_STATUS_MAX
};
typedef class CDanBattleManager
{
typedef std::list<LPVOID> BATTLE_LIST;
typedef BATTLE_LIST::iterator BATTLE_ITOR;
BATTLE_LIST m_BattleCache;
BATTLE_LIST m_BattleResultList;
BATTLE_LIST m_RequestCache;
BATTLE_LIST m_RequestList;
LPREQUEST_RECORD m_pSuggester;
int m_iBattleStatus;
DWORD m_dwStatusStartTime;
BATTLE_ITOR m_FindNextItor;
REQUEST_RECORD m_BattleDan[2];
public:
BOOL m_bDanTestMode;
public :
CDanBattleManager()
{
m_iBattleStatus = 0;
m_dwStatusStartTime = 0;
memset(m_BattleDan, 0, sizeof (REQUEST_RECORD) * 2);
m_bDanTestMode = FALSE;
}
~CDanBattleManager()
{
Destroy();
}
protected :
LPVOID Get(BATTLE_LIST* pList);
void Push(BATTLE_LIST* pList, LPVOID pVoid);
LPVOID ViewFirst(BATTLE_LIST* pList);
BOOL First(BATTLE_LIST* pList, LPVOID* lppVoid);
BOOL Next(BATTLE_LIST* pList, LPVOID* lppVoid);
void Destroy();
public :
BOOL InitManager();
void SetStatus(int bStatus);
int GetStatus();
void SendStatus2Sys();
public:
BOOL FindRequester(LPREQUEST_RECORD pRequest);
LPVOID GetRequestPointer(LPREQUEST_RECORD pRequest);
LPVOID GetRequestPointer();
public:
LPVOID GetBattleRequestDan();
LPVOID GetBattleSuggestDan();
public :
void SendMessage(i3socket_t* sock,BYTE msgType,BYTE mCode,BYTE mType);
void SendRequesterList(i3socket_t* sock,BYTE msgType,int serverID);
void BroadCast_RequesterList();
void SendBattleDan(i3socket_t* sock,BYTE msgType,int serverID);
void BroadCast_BattleDan();
void SendGSM_Refresh_PersonData(playerCharacter_t* pc, int type, int etc1 = 0, int etc2 = 0);
public :
void ClearRequestList();
public :
i3socket_t* FindBattleMapServer();
BOOL HaveBattleMap(int serviceCount,int* pMemberServer,int MapNo);
public :
BOOL InsertRquester(LPREQUEST_RECORD pRequest);
BOOL DeleteRequester(LPREQUEST_RECORD pRequest);
BOOL isSuggester(LPREQUEST_RECORD pSuggest);
BOOL SetSuggester(LPREQUEST_RECORD pSuggest);
LPREQUEST_RECORD GetSuggester();
BOOL MakeBattleDan();
void Update();
void UpdateRequester();
}*LPDAN_BATTLE_MANAGER;
typedef struct BATTLE_TEAM_INFO
{
int danIdx;
char DanName[GUILDNAMESTRING];
int BattlePoint;
int startDanUserCount;
}*LPBATTLE_TEAM_INFO;
typedef class CDanBattleSys
{
typedef std::list<int> TEAM_LIST;
typedef TEAM_LIST::iterator TEAM_ITOR;
int m_iBattleStatus;
DWORD m_dwStatusStartTime;
DWORD m_dwBroadCastTime;
BATTLE_TEAM_INFO m_BattleTeamInfo[2];
TEAM_LIST m_BattleTeam[2];
public :
CDanBattleSys()
{
m_iBattleStatus = 0;
m_dwStatusStartTime = 0;
m_dwBroadCastTime = 0;
memset(m_BattleTeamInfo, 0, sizeof(BATTLE_TEAM_INFO) * 2 );
}
~CDanBattleSys(){}
public :
void SendBattleResult();
void SendBattleStatus();
protected :
void InsertTeam(int teamNo,int ServerID);
void DeleteTeam(int teamNo,int ServerID);
void ClearTeam(int teamNo);
int FindMyTeam(const int danIdx) const;
public :
void DeleteTeam(playerCharacter_t* pUser);
void InsertTeam(playerCharacter_t* pUser);
public :
void SetTeamInfo(int teamNo, LPBATTLE_TEAM_INFO pInfo );
void IncTeamPoint(int teamNo, int incValue);
void DecTeamPoint(int teamNo, int decValue);
public :
void CalcPoint(playerCharacter_t* pDead, playerCharacter_t* pKiller);
void CalcBattleResult();
public :
int GetWinTeam();
int GetLooseTeam();
public :
void SendBattleMassage(i3socket_t* sock,BYTE msgType,BYTE mCode,BYTE mType);
void SendBattleMassage(int teamNo,BYTE msgType,BYTE mCode,BYTE mType);
void SendBattleMassage(BYTE msgType,BYTE mCode,BYTE mType);
void BroadCast_BattleInfo();
void SendBattleInfo();
void SendBattleStart();
void SendBattleReward(i3socket_t* sock,int type,int danFame,int userFame);
public :
BOOL InitDanBattleSys();
void SetStatus(int iStatus);
int GetStatus();
DWORD GetStatusStartTime();
void Update();
void UpdateStatus();
protected :
int CountLiveUser(int teamNo);
public:
void MakeDanBattlePortal(int);
void AutoMoveDanMember();
void TakeConsideration(playerCharacter_t *pc, int considerTableIdx);
void SendRemainTime();
}*LPDAN_BATTLE_SYS;
class CDanBattleFunc
{
public :
CDanBattleFunc(){}
~CDanBattleFunc(){}
public :
void RecvCC_DanBattleMessage();
int RecvCC_ReqeustBattle(playerCharacter_t* pc = NULL);
void RecvCC_BattleReady();
void SendGSM_BattleReady(i3socket_t* sock);
void SendGSM_SuggestResult(BYTE isAllow);
void SendGSM_RequestBattle();
void RecvCC_SetStatus();
void SendGSM_SetStatus();
void RecvCC_SuggestBattle();
void SendGSM_SuggestBattle();
void RecvCC_SuggestResult();
void RecvCC_ChangeBattleMap();
void RecvCC_Battle_Start();
void RecvCC_CancelRequest();
void RecvCC_InitChao();
void RecvCC_SetDanTestMode();
public :
void RecvGSM_DanBattleMessage();
void RecvGSM_RequestBattle();
void RecvGSM_SetStatus();
public :
void SendErrorCode(i3socket_t* sock,BYTE msgType,BYTE eCode,BYTE eType);
int CountDanUser(int danIdx);
};
#endif | C++ |
#include "../Global.h"
CWeatherSystem::CWeatherSystem()
{
m_EventState = EVENT_ACTIVE;
InitWeatherSystem();
}
void CWeatherSystem::InitWeatherSystem()
{
for (int WorldCount = 0; WorldCount < MAX_WORLDS; WorldCount++)
{
m_EventWorld[WorldCount].m_EventLimitTime = 0;
m_EventWorld[WorldCount].m_EventState = WEATHER_SYSTEM_WORLD_NONE;
m_EventWorld[WorldCount].m_WeatherType = TIME_DAY;
}
}
CWeatherSystem::~CWeatherSystem()
{
}
void CWeatherSystem::GTH_Process_Weather_System()
{
enum enumExtendSecondPacket_WeatherSystem SecoundPacketGroup;
SecoundPacketGroup = static_cast <enum enumExtendSecondPacket_WeatherSystem>(MSG_ReadShort());
if ( SecoundPacketGroup != CC_WEATHER_SYSTEM )
return;
int type = MSG_ReadByte();
switch(type)
{
case CC_WEATHER_SYSTEM_REQUEST_USE_WEATHER_ITEM:
GTH_ProcessMessage_WeatherSetting();
break;
case CC_WEATHER_SYSTEM_CHEAT_SETING:
GTH_ProcessMessageEventSeting();
break;
case CC_WEATHER_SYSTEM_REQUEST_WORLD_STATE:
GTH_ProcessMessage_Request_WordlState();
break;
case CC_WEATHER_SYSTEM_NOTICE:
GTH_ProcessMessage_Event_UserNotice();
break;
case CC_WEATHER_SYSTEM_CASTING_EVENT_SETING:
GTH_ProcessMessageBroadCastEventSeting();
break;;
default:
return;
}
}
void CWeatherSystem::GTH_ProcessMessage_WeatherSetting(void)
{
item_t *item;
int itemIdx, itemTableIdx;
int invenPos = -1;
int reply = 1, error = 0;
int isUseItem = 0;
float limitTime;
TIMESTATE weathertype;
weathertype = static_cast<TIMESTATE>(MSG_ReadByte());
limitTime = MSG_ReadLong();
isUseItem = MSG_ReadByte();
if ( isUseItem == 1 )
{
invenPos = MSG_ReadByte();
if ( invenPos < 0 || invenPos >= MAX_INVENTORY_SIZE)
{
reply = 0;
error = ERROR_WEATHER_SYSTEM_USE_ITEM;
GTH_SendMessage_Reply_WeatherSystem_UseItem(g_curPC, reply, error, invenPos);
return;
}
itemIdx = g_curPC->inventory[invenPos];
if( itemIdx < 0 )
{
reply = 0;
error = ERROR_WEATHER_SYSTEM_USE_ITEM;
GTH_SendMessage_Reply_WeatherSystem_UseItem(g_curPC, reply, error, invenPos);
return;
}
item = &g_curPC->item[itemIdx];
itemTableIdx = item->itemTableIdx;
if( item->durability > 0 )
{
item->durability --;
g_DBGameServer->SaveItem( g_curPC, item, itemIdx );
}
else
{
GTH_DeleteMyItem( g_curPC, item );
g_curPC->inventory[invenPos] = -1;
if ( !g_DBGameServer->RemoveItem( g_curPC, itemIdx ) )
{
reply = 0;
error = ERROR_WEATHER_SYSTEM_USE_ITEM;
GTH_SendMessage_Reply_WeatherSystem_UseItem(g_curPC, reply, error, invenPos);
return;
}
}
GTH_SendMessage_Reply_WeatherSystem_UseItem(g_curPC, reply, error, invenPos);
}
m_EventWorld[g_curPC->worldIdx].m_EventState = WEATHER_SYSTEM_WORLD_PROGRESS;
m_EventWorld[g_curPC->worldIdx].m_EventLimitTime = limitTime;
m_EventWorld[g_curPC->worldIdx].m_WorldIdx = g_curPC->worldIdx;
m_EventWorld[g_curPC->worldIdx].m_WeatherType = weathertype;
GTH_SendMessage_BroadCast_WeatherSystemEvent(g_curPC, g_curPC->worldIdx);
}
void CWeatherSystem::GTH_SendMessage_Reply_WeatherSystem_UseItem(playerCharacter_t* pc, int reply, int error, int invenpos)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, WEATHER_SYSTEM);
MSG_WriteShort(&netMessage, GSC_WEATHER_SYSTEM);
MSG_WriteByte(&netMessage, GSC_WEATHER_SYSTEM_REPLY_USE_WEATHER_ITEM);
MSG_WriteLong(&netMessage, reply);
if ( reply == 1)
MSG_WriteByte(&netMessage, invenpos);
else
MSG_WriteLong(&netMessage, error);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CWeatherSystem::GTH_SendMessage_BroadCast_WeatherSystemEvent(playerCharacter_t* pPc, int worldidx)
{
for( int PcCount = 0; PcCount < MAX_PCS; PcCount ++ )
{
if ( g_pc[PcCount].idx < 0 || g_pc[PcCount].idx >= MAX_PCS)
continue;
if ( !g_pc[PcCount].active )
continue;
if( g_pc[PcCount].worldIdx != worldidx )
continue;
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, WEATHER_SYSTEM);
MSG_WriteShort(&netMessage, GSC_WEATHER_SYSTEM);
MSG_WriteByte(&netMessage, GSC_WEATHER_SYSTEM_REPLY_CURRENT_WEATHER);
MSG_WriteLong(&netMessage, (int)m_EventWorld[worldidx].m_EventState);
MSG_WriteLong(&netMessage, (int)m_EventWorld[worldidx].m_WeatherType);
NET_SendMessage(&g_pc[PcCount].sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
}
void CWeatherSystem::ProcessEventTIme()
{
for (int worldCount = 0; worldCount < MAX_WORLDS; worldCount++)
{
if ( (m_EventWorld[worldCount].m_WorldIdx < 0) ||
(m_EventWorld[worldCount].m_WorldIdx >= MAX_WORLDS) ||
(m_EventWorld[worldCount].m_EventState == WEATHER_SYSTEM_WORLD_NONE ) )
continue;
if ( m_EventWorld[worldCount].m_EventLimitTime > 0 )
m_EventWorld[worldCount].m_EventLimitTime -= g_timer->GetElapsedMilliTime();
if ( m_EventWorld[worldCount].m_EventLimitTime < 0 )
{
m_EventWorld[worldCount].m_EventState = WEATHER_SYSTEM_WORLD_NONE;
m_EventWorld[worldCount].m_WorldIdx = -1;
m_EventWorld[worldCount].m_WeatherType = TIME_DAY;
m_EventWorld[worldCount].m_EventLimitTime = 0;
GTH_SendMessage_BroadCast_WeatherSystemEvent(NULL, worldCount);
}
}
}
void CWeatherSystem::GTH_ProcessMessageEventSeting()
{
int event = MSG_ReadByte();
if ( event == 1)
{
m_EventState = EVENT_ACTIVE;
g_logSystem->WriteRLog("WeatherSystem EventStting");
}
else
{
InitWeatherSystem();
m_EventState = EVENT_INACTIVE;
for (int WorldCount = 0; WorldCount < MAX_WORLDS; WorldCount++)
GTH_SendMessage_BroadCast_WeatherSystemEvent(NULL, WorldCount);
}
}
void CWeatherSystem::GTH_ProcessMessageBroadCastEventSeting()
{
if ( g_config.isManager )
{
GTH_SendMessage_Reply_WordlStateToMemberServer( MSG_ReadByte());
}
else
{
GTH_SendMessage_Reply_WordlStateToManagerServer( MSG_ReadByte() );
}
}
void CWeatherSystem::GTH_ProcessMessage_Request_WordlState()
{
int worldidx = MSG_ReadLong();
int reply = 1;
enumEventWorldState state = WEATHER_SYSTEM_WORLD_NONE;
if ( (worldidx < 0) ||
(worldidx >= MAX_WORLDS) ||
(m_EventState == EVENT_INACTIVE) )
{
reply = 0;
state = WEATHER_SYSTEM_WORLD_NONE;
GTH_SendMessage_Reply_WordlState(g_curPC, reply, state);
return;
}
state = m_EventWorld[worldidx].m_EventState;
GTH_SendMessage_Reply_WordlState(g_curPC, reply, (int)state);
}
void CWeatherSystem::GTH_SendMessage_Reply_WordlState(playerCharacter_t* pc, int reply, int state)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, WEATHER_SYSTEM);
MSG_WriteShort(&netMessage, GSC_WEATHER_SYSTEM);
MSG_WriteByte(&netMessage, GSC_WEATHER_SYSTEM_REQUEST_WORLD_STATE);
MSG_WriteByte(&netMessage, reply);
if ( reply == 1)
MSG_WriteLong(&netMessage, state);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CWeatherSystem::GTH_SendMessage_Reply_WordlStateToMemberServer(int state)
{
if ( state == 1)
{
m_EventState = EVENT_ACTIVE;
}
else
{
InitWeatherSystem();
m_EventState = EVENT_INACTIVE;
}
int i;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, WEATHER_SYSTEM);
MSG_WriteShort(&netMessage, GSC_WEATHER_SYSTEM);
MSG_WriteByte(&netMessage, CC_WEATHER_SYSTEM_CHEAT_SETING);
MSG_WriteByte(&netMessage, state);
for (i=1; i < MAX_MEMBER_SERVER; i++)
{
if ( !g_memberServer[i].active ) continue;
NET_SendUnreliableMessage(&g_memberServer[i].sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
void CWeatherSystem::GTH_SendMessage_Reply_WordlStateToManagerServer(int state)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, WEATHER_SYSTEM);
MSG_WriteShort(&netMessage, GSC_WEATHER_SYSTEM);
MSG_WriteByte(&netMessage, CC_WEATHER_SYSTEM_CASTING_EVENT_SETING);
MSG_WriteByte(&netMessage, state);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CWeatherSystem::GTH_ProcessMessage_Event_UserNotice()
{
char str[MAX_PATH+1];
_snprintf(str, MAX_PATH, MSG_ReadString());
str[MAX_PATH] = NULL;
if ( g_config.isManager )
{
GTH_SendMessage_NoticeToMember( str );
GTH_SystemAdmin_SetNoticeInfo( str );
}
else
{
GTH_SendMessage_NoticeToManager( str );
}
}
| C++ |
#include "../global.h"
#define ERROR_MESSAGE_STRING 255
#define QUEST_LIMITETIME 1000
#include "../Tools/CTools.h"
extern CTools* gcpTools;
#include "YDCDamageCal.h"
extern playerCharacter_t* GetPlayerRecordPointer(const int Idx);
int LoadMonsterSpawnTableForServer( char *filename, worldTable_t* wt )
{
int size;
byte *buffer;
char* token;
int idx, wn = -1, i;
vec3_t pos;
monsterSpawnTable_t *ms;
monsterSpawnZoneTable_t *sz;
FILE *fp;
fp = fopen( filename, "rb" );
fseek(fp,0,SEEK_END);
size = ftell(fp);
buffer = new byte[size+1];
fseek(fp,0,SEEK_SET);
fread(buffer,size,1,fp);
fclose(fp);
SetTokenBuffer( buffer, size );
while( 1 )
{
token = NextToken();
if( token == NULL ) break;
if( !stricmp( token, "SPAWN_MONSTER_NUMBER" ) )
{
token = NextToken();
wt->monsterSpawnTableNumber = atoi( token );
} else if( !stricmp( token, "SPAWN_IDX" ) )
{
token = NextToken();
idx = atoi( token );
ms = &wt->monsterSpawnTable[idx];
ms->idx = idx;
wn = -1;
} else if( !stricmp( token, "ENTITY_TYPE" ) )
{
token = NextToken();
if( !stricmp( token, "MONSTER" ) )
{
ms->entityType = ENTITY_MONSTER;
} else if( !stricmp( token, "NPC" ) )
{
ms->entityType = ENTITY_NPC;
}
} else if( !stricmp( token, "AI_TYPE" ) )
{
token = NextToken();
ms->aiType = atoi( token );
} else if( !stricmp( token, "NPC_AI_TYPE" ) )
{
token = NextToken();
ms->npcAiType = atoi( token );
} else if( !stricmp( token, "WORLD_IDX" ) )
{
token = NextToken();
ms->worldIdx = atoi( token );
ms->worldIdx = wt->idx;
} else if( !stricmp( token, "NPC_TABLE_IDX" ) )
{
token = NextToken();
ms->npcTableIdx = atoi( token );
} else if( !stricmp( token, "MONSTER_TABLE_IDX" ) )
{
token = NextToken();
ms->monsterTableIdx = atoi( token );
}
else if( !stricmp( token, "SMALL_ZONE_FLAG" ) )
{
token = NextToken();
ms->smallZoneFlag = atoi( token );
}
else if( !stricmp( token, "SMALL_ZONE_POSITION" ) )
{
token = NextToken();
pos[0] = atof( token );
token = NextToken();
pos[1] = atof( token );
token = NextToken();
pos[2] = atof( token );
vec_copy( pos, ms->smallZonePosition );
}
else if( !stricmp( token, "RANDOM_POSITION_NUMBER" ) )
{
token = NextToken();
ms->positionNumber = atoi( token );
for( i = 0; i < ms->positionNumber; i ++ )
{
token = NextToken();
token = NextToken();
pos[0] = atof( token );
token = NextToken();
pos[1] = atof( token );
token = NextToken();
pos[2] = atof( token );
vec_copy( pos, ms->position[i] );
token = NextToken();
token = NextToken();
pos[0] = atof( token );
token = NextToken();
pos[1] = atof( token );
token = NextToken();
pos[2] = atof( token );
vec_copy( pos, ms->angles[i] );
}
} else if( !stricmp( token, "SPAWN_WAYPOINT_NUMBER" ) )
{
token = NextToken();
ms->wayPointNumber = atoi( token );
for( i = 0; i < ms->wayPointNumber; i ++ )
{
token = NextToken();
token = NextToken();
pos[0] = atof( token );
token = NextToken();
pos[1] = atof( token );
token = NextToken();
pos[2] = atof( token );
vec_copy( pos, ms->wayPoint[i] );
token = NextToken();
token = NextToken();
pos[0] = atof( token );
token = NextToken();
pos[1] = atof( token );
token = NextToken();
pos[2] = atof( token );
vec_copy( pos, ms->angles[i] );
}
} else if( !stricmp( token, "SPAWN_ZONE_IDX_NUMBER" ) )
{
token = NextToken();
ms->spawnZoneNumber = atoi( token );
for( i = 0; i < ms->spawnZoneNumber; i ++ )
{
token = NextToken();
token = NextToken();
ms->spawnZoneIdx[i] = atoi( token );
token = NextToken();
ms->spawnZoneProbability[i] = atoi( token );
}
} else if( !stricmp( token, "RESPAWN_TIME" ) )
{
token = NextToken();
ms->respawnTime = atoi( token );
}
else if( !stricmp( token, "SPAWN_ZONE_NUMBER" ) )
{
token = NextToken();
wt->monsterSpawnZoneTableNumber = atoi( token );
} else if( !stricmp( token, "SPAWN_ZONE_IDX" ) )
{
token = NextToken();
idx = atoi( token );
sz = &wt->monsterSpawnZoneTable[idx];
sz->idx = idx;
} else if( !stricmp( token, "SPAWN_ZONE_POSITION" ) )
{
token = NextToken();
pos[0] = atof( token );
token = NextToken();
pos[1] = atof( token );
token = NextToken();
pos[2] = atof( token );
vec_copy( pos, sz->position );
} else if( !stricmp( token, "SPAWN_ZONE_ANGLE" ) )
{
token = NextToken();
pos[0] = atof( token );
token = NextToken();
pos[1] = atof( token );
token = NextToken();
pos[2] = atof( token );
vec_copy( pos, sz->angle );
}
else if( !stricmp( token, "SPAWN_ZONE_RANGE" ) )
{
token = NextToken();
sz->range = atoi( token );
}
}
if(buffer!=NULL)
{
delete []buffer;
buffer=NULL;
}
return 1;
}
int GTH_LoadMonsterSpawnTable(worldTable_t *worldTable)
{
char monsterSpawnTableFile[256];
if( !stricmp( worldTable->monsterSpawnTableFileName, "NULL" ) )
{
worldTable->monsterSpawnNumber = 0;
return 1;
}
sprintf(monsterSpawnTableFile, "tables/%s", worldTable->monsterSpawnTableFileName);
LoadMonsterSpawnTableForServer( monsterSpawnTableFile, worldTable );
worldTable->monsterSpawnNumber = worldTable->monsterSpawnTableNumber;
worldTable->specialMonsterCount = 0;
return 1;
}
bool CheckSameMonsterIndex(int monsterIndex, worldTable_t* pWorld)
{
for(int i = 0; i < MAX_WORLD_MONSTER_TYPE; i++)
{
if( i == pWorld->monsterTypeNum ) break;
if( pWorld->monsterType[i] == monsterIndex )
return false;
}
return true;
}
void SetMonsterTable(worldTable_t *pWorld, int worldindex)
{
int monsterIndex;
pWorld->monsterTypeNum = 0;
memset( pWorld->monsterType, -1, sizeof(int) * MAX_WORLD_MONSTER_TYPE);
for(int i = 0; i < pWorld->monsterSpawnNumber; i++ )
{
monsterIndex = pWorld->monsterSpawnTable[i].monsterTableIdx;
if( CheckSameMonsterIndex(monsterIndex, pWorld) )
{
pWorld->monsterType[pWorld->monsterTypeNum] = monsterIndex;
pWorld->monsterTypeNum++;
}
}
}
int GTH_LoadMonster()
{
int i, j;
g_monsterNumber = 0;
for (i=0; i < g_worldTableNumber; i++)
{
if ( !GTH_LoadMonsterSpawnTable(&g_worldTable[i]) )
{
continue;
}
SetMonsterTable(&g_worldTable[i], i);
if ( !GTH_IsLocalServiceWorld( g_worldTable[i].idx ) )
{
continue;
}
for( j = 0; j < g_worldTable[i].monsterSpawnNumber; j ++ )
{
if ( g_monsterNumber >= MAX_MONSTERS)
return 0;
memset( &g_monster[ g_monsterNumber ], 0, sizeof( monsterCharacter_t ) );
g_monster[g_monsterNumber].entityType = ENTITY_MONSTER;
MONSTER_Initialize( &g_monster[ g_monsterNumber ], g_worldTable[i].idx, j );
g_monsterNumber++;
}
}
return true;
}
void Monster_CalculateValue( monsterCharacter_t* monster )
{
}
void GTH_ExecuteMonsterEvent()
{
int i;
monsterCharacter_t *monster;
monster = &g_monster[0];
for (i=0; i<MAX_MONSTERS; i++, monster++)
{
if( !monster->active ) continue;
AI_ReceiveMessage( monster );
GTH_AffectProcess( monster, monster->entityType );
if( monster->event != GTH_EV_CHAR_DIE )
{
if( monster->aliveState != MON_ALIVE_STATE_NORMAL || monster->generalSpeed <= 0 ) continue;
GTH_Monster_SkillCasting( monster );
GTH_Monster_AutoRecovery( monster );
if( monster->recoveryTime < 0.0f ) monster->recoveryTime = 0.0f;
if( monster->recoveryTime > 0.0f && monster->aliveState != MON_ALIVE_STATE_SPAWN )
continue;
}
switch(monster->event)
{
case GTH_EV_CHAR_SKIP :
monster->event = monster->oldEvent;
break;
case GTH_EV_CHAR_IDLE:
GTH_Monster_Idle( monster );
break;
case GTH_EV_CHAR_WALK:
GTH_Monster_Walk( monster );
break;
case GTH_EV_CHAR_BACK:
GTH_Monster_Back( monster );
break;
case GTH_EV_CHAR_TURNLEFT:
GTH_Monster_TurnLeft( monster );
break;
case GTH_EV_CHAR_TURNRIGHT:
GTH_Monster_TurnRight( monster );
break;
case GTH_EV_CHAR_RUN:
GTH_Monster_Run( monster );
break;
case GTH_EV_CHAR_ATTACK:
GTH_Monster_Attack( monster );
break;
case GTH_EV_CHAR_DIE:
GTH_Monster_Die( monster );
break;
case GTH_EV_CHAR_STUN :
monster->event = GTH_EV_CHAR_IDLE;
GTH_Monster_Idle( monster );
break;
break;
case GTH_EV_CHAR_SKILL:
if( monster->selectedSkillIdx != -1 )
{
for( int i=0; i<monster->skillNumber; i++)
{
if( monster->skill[i].tableIdx == monster->selectedSkillIdx )
{
GTH_Monster_Skill(monster, i);
char szTemp[64];
sprintf( szTemp, "%d, GTH_Monster_Skill, %d\n", monster->idx, monster->selectedSkillIdx );
OutputDebugString( szTemp );
}
}
}
monster->selectedSkillIdx = -1;
break;
default:
break;
}
monster->oldEvent = monster->event;
}
}
void GTH_Monster_Idle(monsterCharacter_t *m)
{
if ( m->event != m->oldEvent )
GTH_SendMonsterEventMessage_Idle( m );
}
void GTH_Monster_Walk(monsterCharacter_t *m)
{
vec3_t delta;
float speed;
int isChangeAngle;
isChangeAngle = false;
if (m->angles[1] != m->nextAngle)
{
isChangeAngle = true;
m->angles[1] = m->nextAngle;
}
vec_set(delta, 1, 0, 0);
RotateYCoord( delta, m->angles[0] );
RotateZCoord( delta, m->angles[1] );
Normalize( delta );
speed = SPEED_CONSTANT * m->calVelocity * g_timer->GetElapsedMilliTime();
vec_scale(delta, speed, delta);
vec_add(m->position, delta, m->position);
m->position[2] = GTH_GetHeightFromCollisionMap( m->worldIdx, m->position );
m->zoneIdx = GTH_Zone_UpdateCurrentZone(m->entityType, m->idx, m->worldIdx, m->zoneIdx, m->position);
if( m->zoneIdx < 0 )
{
MONSTER_ForcedDelete( m );
}
if ( m->event != m->oldEvent || isChangeAngle )
GTH_SendMonsterEventMessage_Walk( m );
}
void GTH_Monster_Back(monsterCharacter_t *m)
{
vec3_t delta;
float speed;
vec_set(delta, 1, 0, 0);
RotateYCoord( delta, m->angles[0] );
RotateZCoord( delta, m->angles[1] );
Normalize( delta );
speed = -1 * BACK_SCALE * SPEED_CONSTANT * m->calVelocity * g_timer->GetElapsedMilliTime();
vec_scale(delta, speed, delta);
vec_add(m->position, delta, m->position);
m->position[2] = GTH_GetHeightFromCollisionMap( m->worldIdx, m->position );
m->zoneIdx = GTH_Zone_UpdateCurrentZone(m->entityType, m->idx, m->worldIdx, m->zoneIdx, m->position);
if( m->zoneIdx < 0 )
{
MONSTER_ForcedDelete( m );
}
if ( m->event != m->oldEvent )
GTH_SendMonsterEventMessage_Back( m );
}
void GTH_Monster_Run(monsterCharacter_t *m)
{
vec3_t delta;
float speed;
int isChangeAngle;
isChangeAngle = false;
if (m->angles[1] != m->nextAngle)
{
isChangeAngle = true;
m->angles[1] = m->nextAngle;
}
vec_set(delta, 1, 0, 0);
RotateYCoord( delta, m->angles[0] );
RotateZCoord( delta, m->angles[1] );
Normalize( delta );
speed = MONSTER_RUN_SCALE * SPEED_CONSTANT * m->calVelocity * g_timer->GetElapsedMilliTime();
vec_scale(delta, speed, delta);
vec_add(m->position, delta, m->position);
m->position[2] = GTH_GetHeightFromCollisionMap( m->worldIdx, m->position );
m->zoneIdx = GTH_Zone_UpdateCurrentZone(m->entityType, m->idx, m->worldIdx, m->zoneIdx, m->position);
if( m->zoneIdx < 0 )
{
MONSTER_ForcedDelete( m );
}
if ( m->event != m->oldEvent || isChangeAngle )
GTH_SendMonsterEventMessage_Run( m );
}
void GTH_Monster_TurnLeft(monsterCharacter_t *m)
{
m->angles[1] += TURN_SCALE * g_timer->GetElapsedMilliTime();
if (m->angles[1] >= 360.0f)
m->angles[1] -= 360.0f;
if ( m->event != m->oldEvent )
GTH_SendMonsterEventMessage_TurnLeft( m );
}
void GTH_Monster_TurnRight(monsterCharacter_t *m)
{
m->angles[1] -= TURN_SCALE * g_timer->GetElapsedMilliTime();
if (m->angles[1] < 0)
m->angles[1] += 360.0f;
if ( m->event != m->oldEvent )
GTH_SendMonsterEventMessage_TurnRight( m );
}
void GTH_Monster_Attack( monsterCharacter_t* monster )
{
message_t message;
int range;
if( !AI_IsWithinAttackLength( monster ) )
{
monster->event = GTH_EV_CHAR_IDLE;
return;
}
monster->recoveryTime = (float)monster->calAttackDelay;
AI_MakeMessage( monster, &message, MESSAGE_NORMAL_ATTACK );
range = monster->calAttackRange;
if( range < MON_MIN_RATTACK_RANGE ) range = 0;
CAISendMessage AIMsg;
AIMsg.range = range;
AI_SendMessage( &message, &AIMsg );
vec3_t dir, target, angles;
switch( monster->targetType )
{
case ENTITY_PC :
vec_copy( g_pc[monster->targetIdx].position, target );
break;
case ENTITY_MONSTER : case ENTITY_NPC :
vec_copy( g_monster[monster->targetIdx].position, target );
break;
}
vec_sub( target , monster->position, dir );
dir[2] = 0.0f;
vectoangles( dir , angles );
monster->angles[ YAW ] = angles[ YAW ];
GTH_GetPCListInValidRange(monster->worldIdx, monster->position);
if (g_zonePCListNumber < 1 && monster->entityType != ENTITY_MONSTER) return;
GTH_SendMonsterEventMessage_Attack( monster );
}
void GTH_Monster_Damage( monsterCharacter_t* monster, message_t* message )
{
int dmg, eachDmg[3];
int aiFlag = false;
float hitRate = (float)message->data[MSG_ATKDATA_HITRATE];
float criticalRate = (float)message->data[MSG_ATKDATA_CRITICAL_RATE];
if( monster->damagedEntityIdx < 0 || monster->targetIdx < 0 ) aiFlag = true;
monster->damagedEntityType = message->fromType;
monster->damagedEntityIdx = message->fromIdx;
if( message->fromType == ENTITY_PC )
{
if( message->data[MSG_ATKDATA_ATTACK_TYPE] == MSGINFO_ATK_TYPE_NORMAL )
{
hitRate += GTH_GetHitRate( &g_pc[message->fromIdx], ENTITY_PC, monster, ENTITY_MONSTER, message->data[MSG_ATKDATA_HITPOWER] );
criticalRate += GTH_GetCriticalRate( &g_pc[message->fromIdx], ENTITY_PC, monster, ENTITY_MONSTER );
}
else if( message->data[MSG_ATKDATA_ATTACK_TYPE] == MSGINFO_ATK_TYPE_MAGIC )
{
hitRate += GTH_GetMagicHitRate( &g_pc[message->fromIdx], ENTITY_PC, monster, ENTITY_MONSTER );
criticalRate = 0;
}
else
{
criticalRate = 0;
}
g_pc[message->fromIdx].resultHitRate = (int)hitRate;
}
else
{
if( message->data[MSG_ATKDATA_ATTACK_TYPE] == MSGINFO_ATK_TYPE_NORMAL )
{
hitRate += GTH_GetHitRate( &g_monster[message->fromIdx], ENTITY_MONSTER, monster, ENTITY_MONSTER, message->data[MSG_ATKDATA_HITPOWER] );
criticalRate += GTH_GetCriticalRate( &g_monster[message->fromIdx], ENTITY_MONSTER, monster, ENTITY_MONSTER );
}
else if( message->data[MSG_ATKDATA_ATTACK_TYPE] == MSGINFO_ATK_TYPE_MAGIC )
{
hitRate += GTH_GetMagicHitRate( &g_monster[message->fromIdx], ENTITY_MONSTER, monster, ENTITY_MONSTER );
criticalRate = 0;
}
else
{
criticalRate = 0;
}
}
float fRandCriticalRate = GTH_Random();
if( fRandCriticalRate < criticalRate * 0.01f )
{
message->data[MSG_ATKDATA_STUN_FLAG] = MSG_ATKDATA_STUN_TYPE_CRITICAL;
}
dmg=YDCDamageCal::YDGetDamage( monster->idx, ENTITY_MONSTER, message, eachDmg );
if( GTH_Random() < hitRate * 0.01f )
{
monster->curDamage = dmg;
}
else
{
dmg = 0;
if( message->data[MSG_ATKDATA_ATTACK_TYPE] == MSGINFO_ATK_TYPE_MAGIC )
{
dmg = (int)( (float)dmg * 0.55f );
}
if( message->data[MSG_ATKDATA_STUN_FLAG] != MSG_ATKDATA_STUN_TYPE_FREEZE )
message->data[MSG_ATKDATA_STUN_FLAG] = MSG_ATKDATA_STUN_TYPE_NONE;
monster->curDamage = dmg;
}
if( monster->curDamage > 0 )
{
GTH_RemoveEntityCurseState( ENTITY_MONSTER, monster->idx, AFF_DATA_TYPE_SLEEP );
GTH_AnalyzeAttackMessageEtcInfo( message, eachDmg );
monster->curRA -= (float)monster->curDamage;
GTH_AddAtkContributionPoint( monster, message->fromType, message->fromIdx, dmg );
if( message->fromType == ENTITY_PC )
{
GTH_PC_GetStealPoint( &g_pc[message->fromIdx], eachDmg[0] );
}
if( (int)monster->curRA <= 0 )
{
monster->curRA = 0.0f;
monster->ai.aiEvent = AI_DIE;
monster->event = GTH_EV_CHAR_DIE;
monster->recoveryTime = 0.0f;
monster->killerIdx = message->fromIdx;
monster->killerType = message->fromType;
monster->lastAttackState = message->data[MSG_ATKDATA_STUN_FLAG];
return;
}
}
if( aiFlag ) AI_InterpretImmediately( monster );
GTH_SendMonsterEventMessage_Damage( monster, message->data[MSG_ATKDATA_STUN_FLAG] );
}
void GTH_Monster_Stun(monsterCharacter_t *m)
{
}
int FindRewardField( int index )
{
for( int i=0; i<QS_REWARD_NUMBER; i++ )
{
if ( g_questscrollTable[index].data.rewardField[i] > 0 )
return i;
}
return -1;
}
void GTH_ProcessQuestScrollExecute( monsterCharacter_t *monster, playerCharacter_t *pc )
{
int i, idx = -1;
for ( i=0 ; i<MAX_COUNT_QUEST_STATUS ; i++ )
{
if ( pc->questStatus[i].questIdx == QUEST_SCROLL_INDEX ) idx = i;
}
if ( idx >= 0 )
{
if ( monster->tableIdx == pc->questStatus[idx].dField[1] )
{
pc->questStatus[idx].dField[3]++;
if ( pc->questStatus[idx].dField[3] >= pc->questStatus[idx].dField[2] )
{
int reward = pc->questStatus[idx].dField[6];
int rewardType, itemNumber;
switch( pc->questStatus[idx].dField[5] )
{
case 0 :
GTH_PC_GetLoot_QuestScroll( pc->idx, reward, 0, 0, 0 );
rewardType = QS_REWARD_EXP;
itemNumber = 0;
break;
case 1 :
GTH_PC_GetLoot_QuestScroll( pc->idx, 0, reward, 0, 0 );
rewardType = QS_REWARD_GENEXP;
itemNumber = 0;
break;
case 2 :
GTH_PC_GetLoot_QuestScroll( pc->idx, 0, 0, 0, reward );
rewardType = QS_REWARD_GENCAP;
itemNumber = 0;
break;
case 3 :
GTH_PC_GetLoot_QuestScroll( pc->idx, 0, 0, reward, 0 );
rewardType = QS_REWARD_NAK;
itemNumber = 0;
break;
case 4 :
{
int addItemData[4];
addItemData[0] = reward;
addItemData[1] = pc->questStatus[idx].dField[9];
addItemData[2] = pc->questStatus[idx].dField[8];
addItemData[3] = 0;
AI_NPC_AddItem( pc, addItemData );
rewardType = QS_REWARD_ITEM;
itemNumber = pc->questStatus[idx].dField[8];
}
break;
}
int nextScroll = g_questscrollTable[pc->questStatus[idx].dField[0]].data.nextScroll;
if( nextScroll > 0 )
{
int addItemData2[6];
addItemData2[0] = QUESTSCROLL_ITEM_INDEX;
addItemData2[1] = -1;
addItemData2[2] = 1;
addItemData2[3] = 0;
addItemData2[4] = nextScroll;
addItemData2[5] = FindRewardField( nextScroll );
if ( addItemData2[5] < 0 )
{
g_logSystem->Write("Quest Scroll Table has an Error! (User: %s, Index : %d)", pc->name, nextScroll );
pc->questStatus[idx].dField[3]--;
return;
}
AI_NPC_AddItem( pc, addItemData2 );
}
pc->rankPoint += pc->questStatus[idx].dField[7];
GTH_ClearQuestStatus( pc, QUEST_SCROLL_INDEX, 1 );
GTH_SendMessage_QuestScrollComplete( pc, rewardType, reward, itemNumber, pc->rankPoint, nextScroll );
}
else
{
g_DBGameServer->SaveQuestStatus( pc, &pc->questStatus[idx] );
GTH_SendMessage_QuestStatusInfo( pc, 3, QUEST_SCROLL_INDEX );
}
}
}
}
int AI_NPC_AutoCompleteQuest(playerCharacter_t *pPc, int *pParam )
{
int questIdx = pParam[0];
int autoquestindex = pParam[1];
int talbe=questIdx+autoquestindex;
pPc->questVar[talbe].var.isComplete=1;
pPc->questVar[talbe].var.completeCount+=1;
if( pPc->questVar[talbe].var.completeCount > MAX_COUNT_QUEST_COMPLETE )
pPc->questVar[talbe].var.completeCount = MAX_COUNT_QUEST_COMPLETE;
g_DBGameServer->SaveQuest( pPc );
GTH_AutoClearQuestStatus( pPc, questIdx, 1 );
return 0;
}
void GTH_ProcessAutoQuestScrollExecute( monsterCharacter_t* pMonster, playerCharacter_t* pPlayer)
{
int nQuestArrayIndex = -1;
for ( int nIdx = 0 ; nIdx < MAX_COUNT_QUEST_STATUS ; nIdx++ ) {
if ( pPlayer->questStatus[nIdx].questIdx != AUTOQUESTSCROLL_ITEM_INDEX ) continue;
nQuestArrayIndex = nIdx;
break;
}
if( -1 == nQuestArrayIndex ) return;
if ( pMonster->tableIdx != pPlayer->questStatus[nQuestArrayIndex].dField[1] ) return;
pPlayer->questStatus[nQuestArrayIndex].dField[3]++;
if ( pPlayer->questStatus[nQuestArrayIndex].dField[3] < pPlayer->questStatus[nQuestArrayIndex].dField[2] ) {
g_DBGameServer->SaveQuestStatus( pPlayer, &pPlayer->questStatus[nQuestArrayIndex] );
GTH_SendMessage_AutoQuestStatusInfo( pPlayer, 3, pPlayer->questStatus[nQuestArrayIndex].dField[0] );
return;
}
switch( pPlayer->questStatus[nQuestArrayIndex].dField[4] ) {
case 1:
break;
case 3:
if( pPlayer->questStatus[nQuestArrayIndex].clearTime < pPlayer->questStatus[nQuestArrayIndex].limitTime) {
int addItemData[4];
addItemData[0] = g_autoQuestscrollTable[pPlayer->questStatus[nQuestArrayIndex].dField[0]].dataField[15];
addItemData[1] = -1;
addItemData[2] = g_autoQuestscrollTable[pPlayer->questStatus[nQuestArrayIndex].dField[0]].dataField[16];
addItemData[3] = 0;
AI_NPC_AddItem( pPlayer, addItemData );
ShowLogInfo("autoQuest item reword name: %s,index : %d,option : %d,count : %d",pPlayer->name,addItemData[0],addItemData[1],-1);
}
break;
case 2: case 4:
g_DBGameServer->SaveQuestStatus( pPlayer, &pPlayer->questStatus[nQuestArrayIndex] );
GTH_SendMessage_AutoQuestStatusInfo( pPlayer, 3, pPlayer->questStatus[nQuestArrayIndex].dField[0] );
return;
}
GTH_RewordAutoQuestScroll(pPlayer,nQuestArrayIndex);
}
void GTH_RewordAutoQuestScroll(playerCharacter_t* pPlayer,const int& nQuestArrayIndex)
{
int exp = g_autoQuestscrollTable[pPlayer->questStatus[nQuestArrayIndex].dField[0]].dataField[10];
int genexp = g_autoQuestscrollTable[pPlayer->questStatus[nQuestArrayIndex].dField[0]].dataField[11];
int gencap = g_autoQuestscrollTable[pPlayer->questStatus[nQuestArrayIndex].dField[0]].dataField[12];
int nak = g_autoQuestscrollTable[pPlayer->questStatus[nQuestArrayIndex].dField[0]].dataField[13];
int fame = g_autoQuestscrollTable[pPlayer->questStatus[nQuestArrayIndex].dField[0]].dataField[18];
int chaoPoint = g_autoQuestscrollTable[pPlayer->questStatus[nQuestArrayIndex].dField[0]].dataField[21];
GTH_PC_GetLoot_AutoQuestScroll( pPlayer, exp, genexp, gencap, nak,fame,chaoPoint );
if(g_autoQuestscrollTable[pPlayer->questStatus[nQuestArrayIndex].dField[0]].data.reward.nextScroll != -1) {
int addItemData[5];
int nNextScroll = g_autoQuestscrollTable[pPlayer->questStatus[nQuestArrayIndex].dField[0]].data.reward.nextScroll;
addItemData[0] = AUTOQUESTSCROLL_ITEM_INDEX;
addItemData[1] = -1;
addItemData[2] = 1;
addItemData[3] = 1;
addItemData[4] = nNextScroll;
addItemData[5] = -1;
AI_NPC_AddItem( pPlayer, addItemData );
ShowLogInfo(
"autoQuest item reword name: %s,index : %d,count : %d,option : %d",
pPlayer->name,
addItemData[0],
addItemData[1],
addItemData[2]);
}
if(g_autoQuestscrollTable[pPlayer->questStatus[nQuestArrayIndex].dField[0]].data.reward.itemIdx != -1) {
int addItemData[4];
addItemData[0] = g_autoQuestscrollTable[pPlayer->questStatus[nQuestArrayIndex].dField[0]].data.reward.itemIdx;
addItemData[1] = g_autoQuestscrollTable[pPlayer->questStatus[nQuestArrayIndex].dField[0]].data.reward.optionGroup;
addItemData[2] = g_autoQuestscrollTable[pPlayer->questStatus[nQuestArrayIndex].dField[0]].data.reward.itemNo;
addItemData[3] = 0;
AI_NPC_AddItem( pPlayer, addItemData );
ShowLogInfo(
"autoQuest item reword name: %s,index : %d,count : %d,option : %d",
pPlayer->name,
addItemData[0],
addItemData[1],
addItemData[2]);
}
if(g_autoQuestscrollTable[pPlayer->questStatus[nQuestArrayIndex].dField[0]].data.reward.regItemIndex0 != -1) {
int addItemData[4];
addItemData[0] = g_autoQuestscrollTable[pPlayer->questStatus[nQuestArrayIndex].dField[0]].data.reward.regItemIndex0;
addItemData[1] = g_autoQuestscrollTable[pPlayer->questStatus[nQuestArrayIndex].dField[0]].data.reward.regItemOption0;
addItemData[2] = g_autoQuestscrollTable[pPlayer->questStatus[nQuestArrayIndex].dField[0]].data.reward.regItemNo0;
addItemData[3] = 0;
AI_NPC_AddItem( pPlayer, addItemData );
ShowLogInfo(
"autoQuest item reword name: %s,index : %d,count : %d,option : %d",
pPlayer->name,
addItemData[0],
addItemData[1],
addItemData[2]);
}
if(g_autoQuestscrollTable[pPlayer->questStatus[nQuestArrayIndex].dField[0]].data.reward.regItemIndex1 != -1) {
int addItemData[4];
addItemData[0] = g_autoQuestscrollTable[pPlayer->questStatus[nQuestArrayIndex].dField[0]].data.reward.regItemIndex1;
addItemData[1] = g_autoQuestscrollTable[pPlayer->questStatus[nQuestArrayIndex].dField[0]].data.reward.regItemOption1;
addItemData[2] = g_autoQuestscrollTable[pPlayer->questStatus[nQuestArrayIndex].dField[0]].data.reward.regItemNo1;
addItemData[3] = 0;
AI_NPC_AddItem( pPlayer, addItemData );
ShowLogInfo(
"autoQuest item reword name: %s,index : %d,count : %d,option : %d",
pPlayer->name,
addItemData[0],
addItemData[1],
addItemData[2]);
}
if(g_autoQuestscrollTable[pPlayer->questStatus[nQuestArrayIndex].dField[0]].data.reward.regItemIndex2 != -1) {
int addItemData[4];
addItemData[0] = g_autoQuestscrollTable[pPlayer->questStatus[nQuestArrayIndex].dField[0]].data.reward.regItemIndex2;
addItemData[1] = g_autoQuestscrollTable[pPlayer->questStatus[nQuestArrayIndex].dField[0]].data.reward.regItemOption2;
addItemData[2] = g_autoQuestscrollTable[pPlayer->questStatus[nQuestArrayIndex].dField[0]].data.reward.regItemNo2;
addItemData[3] = 0;
AI_NPC_AddItem( pPlayer, addItemData );
ShowLogInfo(
"autoQuest item reword name: %s,index : %d,count : %d,option : %d",
pPlayer->name,
addItemData[0],
addItemData[1],
addItemData[2]);
}
if(g_autoQuestscrollTable[pPlayer->questStatus[nQuestArrayIndex].dField[0]].data.reward.regItemIndex3 != -1) {
int addItemData[4];
addItemData[0] = g_autoQuestscrollTable[pPlayer->questStatus[nQuestArrayIndex].dField[0]].data.reward.regItemIndex3;
addItemData[1] = g_autoQuestscrollTable[pPlayer->questStatus[nQuestArrayIndex].dField[0]].data.reward.regItemOption3;
addItemData[2] = g_autoQuestscrollTable[pPlayer->questStatus[nQuestArrayIndex].dField[0]].data.reward.regItemNo3;
addItemData[3] = 0;
AI_NPC_AddItem( pPlayer, addItemData );
ShowLogInfo(
"autoQuest item reword name: %s,index : %d,count : %d,option : %d",
pPlayer->name,
addItemData[0],
addItemData[1],
addItemData[2]);
}
int pParam[2];
pParam[0] = AUTOQUESTSCROLL_ITEM_INDEX;
pParam[1] = pPlayer->questStatus[nQuestArrayIndex].dField[0];
AI_NPC_AutoCompleteQuest(pPlayer, pParam );
pPlayer->bautoeffectisvalid = TRUE;
GTH_SendMessage_AutoQuestScrollComplete( pPlayer, pPlayer->questStatus[nQuestArrayIndex].dField[0]);
}
void GTH_Monster_Loot( monsterCharacter_t *monster )
{
playerCharacter_t *pc=NULL;
int exp=0, genExp=0, lootNSE=0, genCapability=0;
float lootRate;
int levelDiffer;
int entityIdx, entityType, contributionCount = 0;
int contributionPartyIdx[MAX_NUMBER_OF_PARTY_MEMBER], partyIdxNumber = 0, firstPartyMemberIdx=-1;
int maxPartyContributionPoint=0, maxAtkConPoint, maxDefConPoint, atkConIdx, defConIdx;
int i;
int maxAtkConPointForQuestItem = 0, maxAtkConIdxForQuestItem = -1;
monster->mostConEntityType = -1;
monster->mostConEntityIdx = -1;
if( monster->maxAtkContributionPoint <= 0 )
{
return;
}
int findcount = 0;
for( i=0; i<MAX_NUMBER_OF_MONSTER_CONTRIBUTION; i++)
{
if ( findcount >= monster->conInfoNumber) break;
if ( monster->conInfo[i].entityIdx < 0) continue;
findcount++;
entityType = monster->conInfo[i].entityType;
entityIdx = monster->conInfo[i].entityIdx;
if( monster->conInfo[i].atkPoint > maxAtkConPointForQuestItem )
{
maxAtkConPointForQuestItem = monster->conInfo[i].atkPoint;
maxAtkConIdxForQuestItem = i;
}
if( entityType != ENTITY_PC )
{
monster->conInfo[i].flag = true;
contributionCount ++;
continue;
}
else if( g_pc[entityIdx].organizeServer < 0 )
{
monster->conInfo[i].flag = true;
contributionCount ++;
if( !GTH_IsValidContributionPoint( monster, &g_pc[entityIdx], i ) ) continue;
lootRate = (float)monster->conInfo[i].atkPoint / (float)monster->maxAtkContributionPoint;
exp = (int)( (float)monster->basic.exp * lootRate );
genExp = (int)( (float)monster->basic.genExp * lootRate );
lootNSE = (int)( (float)monster->basic.lootSE * lootRate );
genCapability = (int)( (float)g_genCapabilityTable.genCapability[monster->basic.level] * lootRate );
levelDiffer = g_pc[entityIdx].level - monster->basic.level;
GTH_GetExpFromLevelDiffer( levelDiffer, exp, genExp, genCapability );
GTH_PC_GetLoot( entityIdx, exp, genExp, 0, genCapability );
}
}
i = 0;
while( contributionCount < monster->conInfoNumber )
{
if( monster->conInfo[i].flag )
{
i ++;
continue;
}
monster->conInfo[i].flag = true;
pc=gcpTools->GetPlayerRecordPointer(monster->conInfo[i].entityIdx);
if(NULL==pc)continue;
firstPartyMemberIdx = pc->idx;
contributionPartyIdx[0] = i;
maxPartyContributionPoint = monster->conInfo[i].atkPoint;
partyIdxNumber = 1;
maxAtkConPoint = 0;
maxDefConPoint = 0;
atkConIdx = -1;
defConIdx = -1;
contributionCount ++;
int findcount = 0;
for( int j = i+1; j < MAX_NUMBER_OF_MONSTER_CONTRIBUTION; j ++)
{
if ( findcount >= monster->conInfoNumber) break;
if ( monster->conInfo[j].entityIdx < 0) continue;
findcount++;
if( monster->conInfo[j].flag ) continue;
entityIdx = monster->conInfo[j].entityIdx;
if( !GTH_CheckSameParty( &g_pc[firstPartyMemberIdx], &g_pc[entityIdx] ) ) continue;
monster->conInfo[j].flag = true;
contributionPartyIdx[partyIdxNumber] = j;
maxPartyContributionPoint += monster->conInfo[j].atkPoint;
partyIdxNumber ++;
contributionCount ++;
}
for( j = 0; j < partyIdxNumber; j ++ )
{
if( monster->conInfo[contributionPartyIdx[j]].atkPoint > maxAtkConPoint )
{
atkConIdx = j;
maxAtkConPoint = monster->conInfo[contributionPartyIdx[j]].atkPoint;
}
if( monster->conInfo[contributionPartyIdx[j]].defPoint > maxDefConPoint )
{
defConIdx = j;
maxDefConPoint = monster->conInfo[contributionPartyIdx[j]].defPoint;
}
}
lootRate = (float)maxPartyContributionPoint / (float)monster->maxAtkContributionPoint;
exp = (int)( (float)monster->basic.exp * lootRate );
genExp = (int)( (float)monster->basic.genExp * lootRate );
lootNSE = (int)( (float)monster->basic.lootSE * lootRate );
genCapability = (int)( (float)g_genCapabilityTable.genCapability[monster->basic.level] * lootRate );
GTH_SharingPartyLoot( monster, &g_pc[firstPartyMemberIdx], exp, genExp, 0, genCapability, atkConIdx, defConIdx );
}
monster->mostConEntityIdx = -1;
monster->mostConEntityType = -1;
if( maxAtkConIdxForQuestItem >= 0 )
{
monster->mostConEntityIdx = monster->conInfo[maxAtkConIdxForQuestItem].entityIdx;
monster->mostConEntityType = monster->conInfo[maxAtkConIdxForQuestItem].entityType;
strcpy( monster->mostConEntityName, monster->conInfo[maxAtkConIdxForQuestItem].entityName );
}
if( monster->mostConEntityType == ENTITY_PC )
{
GTH_GenerateQuestItemFromMonster( monster, maxAtkConIdxForQuestItem );
GTH_GenerateItemFromMonster( monster );
entityIdx = monster->conInfo[maxAtkConIdxForQuestItem].entityIdx;
if( !g_pc[entityIdx].active || !g_pc[entityIdx].alive ) return;
if( stricmp( g_pc[entityIdx].name, monster->conInfo[maxAtkConIdxForQuestItem].entityName ) ) return;
g_pc[entityIdx].curRA += g_pc[entityIdx].optValue[OV_RA_STEAL_DIE_MONSTER];
g_pc[entityIdx].curSA += g_pc[entityIdx].optValue[OV_SA_STEAL_DIE_MONSTER];
GTH_ProcessQuestScrollExecute( monster, &g_pc[entityIdx] );
GTH_ProcessAutoQuestScrollExecute( monster, &g_pc[entityIdx] );
{
int change_point=(exp/((monster->basic.level*CHAOSADDRATE)+CHAOSGENERATE));
gcpTools->IncDecChaosPoint(&(g_pc[entityIdx]),change_point* (-1));
}
}
}
void GTH_Monster_Die(monsterCharacter_t *monster )
{
if ( monster->aliveState != MON_ALIVE_STATE_NORMAL ) return;
AI_InitMessage( monster );
MONSTER_Calculate( monster );
monster->aliveState = MON_ALIVE_STATE_CORPSE;
monster->deathTime = g_globalTime;
if ( monster->event != monster->oldEvent )
{
GTH_Monster_Loot( monster );
GTH_SendMonsterEventMessage_Die( monster );
}
if( monster->specialMonster == 1 )
{
--g_worldTable[monster->spawnWorldIdx].specialMonsterCount;
monster->specialMonster = 0;
}
}
void GTH_Monster_AutoRecovery( monsterCharacter_t *m )
{
float recRAPoint = 0.0f, recSAPoint = 0.0f;
m->autoRecoveryRATime -= g_timer->GetElapsedMilliTime();
m->autoRecoverySATime -= g_timer->GetElapsedMilliTime();
if( m->autoRecoveryRATime < 0.0f )
{
recRAPoint = m->basic.recoveryRARate;
m->autoRecoveryRATime = MONSTER_AUTO_RECOVERY_DELAY;
}
if( m->autoRecoverySATime < 0.0f )
{
recSAPoint = m->basic.recoverySARate;
m->autoRecoverySATime = MONSTER_AUTO_RECOVERY_DELAY;
}
m->curRA += recRAPoint;
m->curSA += recSAPoint;
if( m->curRA > m->calMaxRA ) m->curRA = m->calMaxRA;
if( m->curSA > m->calMaxSA ) m->curSA = m->calMaxSA;
}
void GTH_Monster_Skill(monsterCharacter_t *monster, int skillIndex)
{
int castingTime;
float value[NUM_OF_SKILL_VALUE];
int tableIdx = monster->skill[skillIndex].idx;
if( tableIdx == - 1) return;
g_SkillLogic.SKILL_Monster_GetValue( monster, tableIdx, value );
castingTime = (int)value[1];
monster->curSA -= value[0];
if( (int)monster->curSA < 0 ) monster->curSA = 0.0f;
if( castingTime > 0 )
{
monster->skillCastingtime = (float)castingTime;
monster->skillCastingState = false;
monster->event = GTH_EV_CHAR_IDLE;
monster->saveSkillIdx = skillIndex;
GTH_SendMonsterEventMessage_SkillCasting( monster, castingTime);
}
else
{
monster->event = GTH_EV_CHAR_SKILL;
monster->saveSkillIdx = skillIndex;
return;
}
}
void GTH_Monster_SkillCasting( monsterCharacter_t* pMonster )
{
pMonster->skillCastingtime -= g_timer->GetElapsedMilliTime();
if( pMonster->skillCastingtime < 0.0f )
{
pMonster->skillCastingtime = 0.0f;
pMonster->skillCastingState = true;
if( pMonster->saveSkillIdx >= 0 ) GTH_Monster_SkillExecute( pMonster );
pMonster->saveSkillIdx = -1;
}
}
void GTH_Monster_SkillExecute( monsterCharacter_t *pMonster )
{
int coolTime;
if( pMonster->saveSkillIdx < 0 ) return;
if( pMonster->skill[pMonster->saveSkillIdx].tableIdx < 0 ) return;
MONSTER_Calculate( pMonster );
pMonster->recoveryTime = pMonster->calAttackDelay;
if( pMonster->basic.skillNumber == 0 ) return;
if( !AI_IsWithinAttackLength( pMonster ) )
{
pMonster->event = GTH_EV_CHAR_IDLE;
return;
}
g_SkillLogic.SKILL_Monster_ApplyActive( pMonster, pMonster->saveSkillIdx, coolTime );
GTH_SendMonsterEventMessage_Skill( pMonster, pMonster->saveSkillIdx, coolTime, pMonster->recoveryTime );
}
int GTH_ProcessMessage_SummonMonster(item_t* pItem)
{
monsterCharacter_t* monster = NULL;
int localWorldIdx;
int idx, i;
char summonerName[255];
idx = MONSTER_GetNotActiveIdx();
if( idx < 0 ) return -1;
localWorldIdx = GTH_GetLocalWorldIdx( g_curPC->worldIdx );
if( !AI_CheckCollision( g_curPC->position, &g_cmap[localWorldIdx] ) ) return -2;
monster = &g_monster[idx];
monster->worldIdx = g_curPC->worldIdx;
memset( monster, 0, sizeof( monsterCharacter_t ) );
monster->idx = idx;
monster->tableIdx = g_summonMonstertable[pItem->optionIdx[0]].idx;
monster->spawnWorldIdx = g_curPC->worldIdx;
monster->spawnTableIdx = -1;
monster->respawnTime = -1.0f;
memcpy( &monster->basic, &g_monsterTable[monster->tableIdx], sizeof( monsterBasicTable_t ) );
monster->entityType = ENTITY_MONSTER;
monster->ai.aiType = -1;
monster->npcAi.aiType = -1;
monster->npcTableIdx = -1;
monster->npc.scriptFlag = false;
monsterBasicTable_t *mb;
mb = &g_monsterTable[monster->tableIdx];
monster->skillNumber = mb->skillNumber;
for(int skillidx = 0; skillidx< monster->skillNumber; skillidx++)
{
monster->skill[skillidx].idx = mb->skillIdx[skillidx];
monster->skill[skillidx].tableIdx = mb->skillIdx[skillidx];
}
monster->saveSkillIdx = -1;
int ScriptIdx = g_monsterTable[monster->tableIdx].AIScriptIdx;
AI_LoadScript( monster, g_scriptInfo.aiScript[ScriptIdx].filename );
AI_PreparePathfinding( monster );
monster->deathTime = 0;
monster->worldIdx = monster->spawnWorldIdx;
vec3_t position;
if ( g_curPC != NULL )
{
if( FindMonsterSpawnPlace(localWorldIdx, position ) == -1)
{
return -2;
}
}
vec_copy(g_curPC->position, position);
vec_copy( position, monster->position );
monster->aliveState = MON_ALIVE_STATE_SPAWN;
monster->recoveryTime = MONSTER_SPAWN_ANIMATION_TIME;
MONSTER_Calculate( monster );
monster->curRA = monster->calMaxRA;
monster->curSA = monster->calMaxSA;
monster->totalOptNum = 0;
monster->playerOptNum = 0;
SetMonsterOptionValue(monster);
monster->event = GTH_EV_CHAR_IDLE;
monster->oldEvent = GTH_EV_CHAR_DIE;
for ( i =0; i < MAX_AFFECT; i++ )
{
memset( &monster->affect[i], 0, sizeof( affect_t ) );
monster->affect[i].type = AFFECT_NONE;
}
monster->affectNumber = 0;
GTH_InitContributionPoint( monster );
sprintf( summonerName, "%s", g_monster[monster->tableIdx].basic.name );
g_logSystem->Write( "Monster Summon Complete : %s(%d) Success...pos(%.2f, %.2f, %.2f), Summoner : (%s)",
monster->basic.name, monster->idx, monster->position[0], monster->position[1], monster->position[2], summonerName );
MONSTER_InitAI( monster );
AI_InitMessage( monster );
monster->isSummon = true;
monster->summonTime = g_globalTime;
monster->summonValidTime = (int)g_summonMonstertable[pItem->optionIdx[0]].SummonTime * 1000;
monster->active = 1;
monster->zoneIdx = -1;
monster->zoneIdx = GTH_Zone_GetZoneIdx( monster->position );
GTH_Zone_AddEntityList(monster->worldIdx, monster->zoneIdx, monster->entityType, monster->idx);
return idx;
}
bool CanSummonMonster(int monsterIndex)
{
for(int i = 0; i < g_worldTable[g_curPC->worldIdx].monsterTypeNum; i++ )
{
if( g_worldTable[g_curPC->worldIdx].monsterType[i] == monsterIndex )
return true;
}
return false;
}
int FindMonsterSpawnPlace(int localWorldIdx, vec3_t& position )
{
vec_copy( g_curPC->position, position );
int rx = GTH_Randomize( 3 ) - 1;
int ry = GTH_Randomize( 3 ) - 1;
position[2] = GTH_GetHeightFromCollisionMap(g_curPC->worldIdx, g_curPC->position);
position[0] += (float)rx * 80.0f;
position[1] += (float)ry * 80.0f;
if( !AI_CheckCollision(position, &g_cmap[localWorldIdx]) )
{
return -1;
}
return 1;
}
void GTH_Monster_State(monsterCharacter_t *m)
{
}
int AddMonster_ContributionPoint( playerCharacter_t *pPc, int monsterIdx, int PointType, int point)
{
if ( monsterIdx < 0 || monsterIdx > MAX_MONSTERS ) return 0;
if ( pPc == NULL ) return 0;
if ( PointType > TOTAL_POINT) return 0;
monsterCharacter_t* pMonster = NULL;
pMonster = &g_monster[monsterIdx];
if ( pMonster == NULL )
return 0;
bool findPc = 0;
int findidx = -1;
int findCount = 0;
bool flagfind = 0;
for (int ConIdx = 0; ConIdx < MAX_NUMBER_OF_MONSTER_CONTRIBUTION; ConIdx++)
{
if ( pMonster->conInfo[ConIdx].entityIdx >= 0 )
{
if ( pMonster->conInfo[ConIdx].entityIdx == pPc->idx &&
pMonster->conInfo[ConIdx].entityType == pPc->entityType )
{
findPc = 1;
findidx = ConIdx;
break;
}
}
else
{
if ( findidx < 0)
findidx = ConIdx;
}
}
if ( findidx < 0 || findidx >= MAX_NUMBER_OF_MONSTER_CONTRIBUTION) return false;
if ( !findPc )
{
pMonster->conInfo[findidx].entityType = pPc->entityType;
pMonster->conInfo[findidx].entityIdx = pPc->entityType;
if( pPc->entityType == ENTITY_PC )
strcpy( pMonster->conInfo[findidx].entityName, pPc->name);
pMonster->conInfo[findidx].atkPoint = point;
pMonster->conInfo[findidx].defPoint = 0;
pMonster->conInfoNumber++;
}
else
pMonster->conInfo[findidx].atkPoint += point;
pMonster->conInfo[findidx].flag = false;
pMonster->conInfo[findidx].time = g_globalTime;
switch ( PointType )
{
case FIRST_ATTACK_POINT:
pMonster->conInfo[findidx].ContributionPoints[FIRST_ATTACK_POINT] = pMonster->conInfo[findidx].atkPoint * 1.8f;
break;
case MYSTERY_POINT:
if ( pMonster->message[findidx].data[MSG_ATKDATA_ETC_DATA_2] == MSGINFO_TYPE_ATTACK )
pMonster->conInfo[findidx].ContributionPoints[MYSTERY_POINT] += pMonster->message[pMonster->messageNumber].data[MSG_ATKDATA_PHYSIC_DMG];
break;
default:
pMonster->conInfo[findidx].ContributionPoints[PointType] += point;
}
pMonster->conInfo[findidx].ContributionPoints[TOTAL_POINT] += pMonster->conInfo[findidx].ContributionPoints[FIRST_ATTACK_POINT];
pMonster->conInfo[findidx].ContributionPoints[TOTAL_POINT] += pMonster->conInfo[findidx].ContributionPoints[FIRST_ATTACK_REVERSE_POINT];
pMonster->conInfo[findidx].ContributionPoints[TOTAL_POINT] += pMonster->conInfo[findidx].ContributionPoints[MYSTERY_POINT];
pMonster->conInfo[findidx].ContributionPoints[TOTAL_POINT] += pMonster->conInfo[findidx].ContributionPoints[RECOVER_POINT];
pMonster->conInfo[findidx].ContributionPoints[TOTAL_POINT] += pMonster->conInfo[findidx].ContributionPoints[ATTACK_POINT];
return 1;
}
void GTH_Process_QuestlimiteTimerCheck()
{
for(int i=0; i<g_pcNumber; i++)
{
if(g_pc[i].active == 1 && g_pc[i].questStatus[i].limitTime > 0 )
{
g_pc[i].questStatus[i].clearTime+=g_timer->GetElapsedTime();
if(g_pc[i].questStatus[i].clearTime > g_pc[i].questStatus[i].limitTime)
{
GTH_AutoClearQuestStatus( g_pc, AUTOQUESTSCROLL_ITEM_INDEX, -1 );
}
}
}
}
| C++ |
#if !defined(AFX_EXPEVENTMNG_H__7EFC291A_26E7_4058_BC3E_EA094D46429A__INCLUDED_)
#define AFX_EXPEVENTMNG_H__7EFC291A_26E7_4058_BC3E_EA094D46429A__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CExpEventMng
{
private:
enum enumProtocal
{
CC_BROAD_CAST_SET_EVENT = 0x0001,
SS_BROAD_CAST_SET_EVENT = 0x0002,
SS_SET_EVENT = 0x0003,
SS_REQUEST_EVENT = 0x0004,
SS_REPLY_EVENT = 0x0005,
CC_SET_ACTIVE_SYSTEM = 0x0006,
SS_SET_ACTIVE_SYSTEM = 0x0007,
CC_REQUEST_EVENT_STATUS = 0x0008,
GSC_REPLY_EVENT_STATUS = 0x0009,
};
enum enumEventType
{
EXP_RATE,
ITEM_DROP_RATE,
NAK_DROP_RATE,
GENCAPABILITY_RATE,
ALL_READ_LOGIC,
};
private:
float m_fExpRate;
float m_fItemDropRate;
float m_fNakDropRate;
float m_fGencapability_rate;
private:
BOOL m_ActiveMng;
public:
void ProcessExpEvent();
void ProcessMessage_SetEvent();
void ProcessMessage_BroadCast_SetEvent(enum enumEventType, float fvalue);
void ProcessMessage_RequestAllEvent();
void ProcessMessage_ReplyAllEvent();
void ProcessMessage_RequestActiveSystem();
void SendMessage_SetEventTo_MemberServer(enum enumEventType, float value);
void SendMessage_SetEventTo_ManagerServer(enum enumEventType, float value);
void SetEvent(enum enumEventType, float fValue);
void SendMessage_RequestEventToManagerServer();
void SendMessage_ReplyEventToServer(int MemberServerIdx, BOOL Active = FALSE);
void SendMessage_SetActiveToManagerServer(BOOL Active);
void SendMessage_ReplyEventStatus(playerCharacter_t* pc);
public:
public:
void InitExpEventMng();
public:
CExpEventMng();
virtual ~CExpEventMng();
};
#endif
| C++ |
#include "../global.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
enum
{
EXCEL_FIELD_NORMAL=0,
EXCEL_FIELD_FILE_END,
EXCEL_FIELD_LINE_END,
};
CItemTxt g_TxtApp;
CItemTxt::CItemTxt()
{
m_NameList.reserve(MAX_NUMBER_OF_ITEM_GENERATE_TABLE);
m_DescList.reserve(MAX_NUMBER_OF_ITEM_GENERATE_TABLE);
}
CItemTxt::~CItemTxt()
{
}
void CItemTxt::ClearNameList()
{
int size=m_NameList.size();
for(int i=0;i<size;i++)
{
m_NameList.pop_back();
}
}
LPSTR CItemTxt::GetName(int idx)
{
int size=m_NameList.size();
for(int i=0;i<size;i++)
{
if(m_NameList[i].m_Index == idx)
{
return m_NameList[i].m_Txt;
}
}
return "NULL";
}
LPSTR CItemTxt::GetDesc(int idx)
{
int size=m_DescList.size();
for(int i=0;i<size;i++)
{
if(m_DescList[i].m_Index == idx)
{
return m_DescList[i].m_Txt;
}
}
return "NULL";
}
void CItemTxt::ClearDescList()
{
int size=m_DescList.size();
for(int i=0;i<size;i++)
{
m_DescList.pop_back();
}
}
void CItemTxt::ClearClassNameList()
{
int size=m_ClassNameList.size();
for(int i=0;i<size;i++)
{
m_ClassNameList.pop_back();
}
}
void CItemTxt::GetOnlyTxt()
{
int i,k,j;
char txt[2][256];
wsprintf(txt[0],"%s",m_Token);
char ttt[222];
wsprintf(ttt,"aaa");
int len=strlen(m_Token);
for(i=0;i<len;i++)
{
if(txt[0][i]=='"')
{
i++;
break;
}
}
j=0;
for(k=i;k<len;k++)
{
if(txt[0][k]=='"') break;
txt[1][j++]=txt[0][k];
}
txt[1][j]='\0';
wsprintf(m_Token,"%s",txt[1]);
}
void CItemTxt::BindItemTable()
{
for(int i=0;i<MAX_NUMBER_OF_ITEM_TABLE;i++)
{
}
}
void CItemTxt::STRCPY(char &Dest, char &Source)
{
int DestLen = lstrlen(&Dest);
int SourceLen = lstrlen(&Source);
int DestSize = sizeof(Dest);
int SourceSize = sizeof(Source);
int CopyLen = SourceLen;
if(DestSize < SourceLen)
{
CopyLen = DestSize;
}
lstrcpyn(&Dest,&Source,CopyLen);
}
bool CItemTxt::LoadFile(char * FileName)
{
char seps[] = ":\t\n";
ClearNameList();
ClearDescList();
ClearClassNameList();
char *str_token;
int n=0, endfile,skipFlag = false;
char token[255];
if(!LoadTokenBuffer((char *) (LPCTSTR) FileName)) return false;
m_NameList.clear();
m_DescList.clear();
CItemTxtData tempTxt;
while( 1 )
{
NextCVSTokenReturn(token, endfile );
if( token[0] != NULL )
{
if(token[0] == '/' || token[0] == '[') continue;
str_token = strtok( token, seps );
while( str_token != NULL )
{
if(str_token[0] == '/')
{
}
else if(str_token[0] >= 0x30 && str_token[0] <= 0x39)
{
if(tempTxt.m_Index >=0)
{
wsprintf(m_Token,"%s",tempTxt.m_Txt);
GetOnlyTxt();
wsprintf(tempTxt.m_Txt,"%s",m_Token);
if(tempTxt.m_Index >= 20000)
{
m_ClassNameList.push_back(tempTxt);
}
else if(tempTxt.m_Index >= 10000 && tempTxt.m_Index < 20000)
{
m_DescList.push_back(tempTxt);
}
else if(tempTxt.m_Index >= 1000 && tempTxt.m_Index < 10000)
{
m_NameList.push_back(tempTxt);
}
n++;
}
tempTxt.Init();
tempTxt.m_Index = atoi(str_token);
}
else
{
strcat(tempTxt.m_Txt,str_token);
}
str_token = strtok( NULL, seps );
}
}
else
{
if( endfile == EXCEL_FIELD_FILE_END )
{
break;
}
continue;
}
if( endfile == EXCEL_FIELD_FILE_END )
{
break;
}
}
if(tempTxt.m_Index >=0)
{
GetOnlyTxt();
if(tempTxt.m_Index >= 20000)
{
m_ClassNameList.push_back(tempTxt);
}
else if(tempTxt.m_Index >= 10000 && tempTxt.m_Index < 20000)
{
m_DescList.push_back(tempTxt);
}
else if(tempTxt.m_Index >= 1000 && tempTxt.m_Index < 10000)
{
m_NameList.push_back(tempTxt);
}
n++;
}
DeleteTokenBuffer();
return true;
}
| C++ |
#include "../global.h"
#include "../Tools/CTools.h"
extern CTools* gcpTools;
#include "..\GolryunBattle\tagGolryunBattle.h"
#include "..\GM(Game Master)\CGMCtrl.h"
extern CGMCtrl* gcpGMCtrl;
void GTH_InitGameServer()
{
srand( (unsigned int)time( NULL ) );
GTH_InitGlobalTime();
g_timer->Start();
GTH_Zone_Init();
g_pcNumber = 0;
g_maxPCNumber = 0;
memset(&g_pc[0], 0, MAX_PCS * sizeof(playerCharacter_t));
}
float GTH_GetDistance(vec3_t s, vec3_t t)
{
return sqrt( (t[0]-s[0])*(t[0]-s[0]) + (t[1]-s[1])*(t[1]-s[1]) + (t[2]-s[2])*(t[2]-s[2]) );
}
float GTH_GetDistance2D(vec3_t s, vec3_t t)
{
return sqrt( (t[0]-s[0])*(t[0]-s[0]) + (t[1]-s[1])*(t[1]-s[1]) );
}
void GTH_SaveData_AlivedClient()
{
int i;
int count;
playerCharacter_t *pc;
count = 0;
pc = &g_pc[0];
for (i=0; i < MAX_PCS; i++, pc++)
{
if ( pc->active )
{
GTH_ForcedQuit( pc );
count ++;
DB_SaveGameData( pc, SAVEGAMEDATA_QUIT);
}
if ( count >= 50 )
{
DB_Waiting_ProcessRemainderQuery();
count = 0;
}
}
DB_Waiting_ProcessRemainderQuery();
}
int GTH_GetHeightFromCollisionMap( int worldIdx, vec3_t position )
{
int x, y;
float height;
collisionMap_t *map;
int localWorldIdx;
localWorldIdx = GTH_GetLocalWorldIdx( worldIdx );
map = &g_cmap[localWorldIdx];
x = (int)position[0] / (int)map->scale;
y = (int)position[1] / (int)map->scale;
if( x < 0 || x >= map->xsize ) return( 0 );
if( y < 0 || y >= map->ysize ) return( 0 );
height = (int) map->heightMap[ y * map->xsize + x ];
return height;
}
int GTH_GetLocalWorldIdx( int worldIdx )
{
int i;
for (i=0; i<g_config.serviceWorldNumber; i++)
{
if ( g_config.serviceWorldList[i] == worldIdx )
return i;
}
return -1;
}
int GTH_GetEmptyAffectIdx( playerCharacter_t *pc )
{
int i;
for( i = 0; i < MAX_AFFECT; i ++ )
{
if( pc->affect[i].type == AFFECT_NONE ) break;
}
if( i == MAX_AFFECT ) return( -1 );
return( i );
}
int GTH_GetWeaponClass( playerCharacter_t *pc )
{
int itemIdx = pc->equipment[pc->curWeapon + EQUIP_WEAPON_1];
int tableIdx, classIdx;
if( itemIdx < 0 ) return( -1 );
tableIdx = pc->item[itemIdx].itemTableIdx;
classIdx = g_itemTable[tableIdx].classIdx;
return( classIdx );
}
int GTH_OpenStore( int idx )
{
storeStruct_t *store;
store = &g_store[idx];
int i, j, nItem = 0, itemTableIdx;
for( i = 0; i < MAX_NUMBER_OF_STORE_ITEM_PAGE; i ++ )
{
for( j = 0; j < store->defaultItem[i].defaultNumber; j ++ )
{
InitItem( &store->item[nItem].item );
if( store->defaultItem[i].itemIndex[j] == STORE_ITEM_INDEX_EPACK_RA )
{
if( store->chargeRACost <= 0 ) continue;
store->item[nItem].item.itemTableIdx = STORE_ITEM_INDEX_EPACK_RA;
}
else if( store->defaultItem[i].itemIndex[j] == STORE_ITEM_INDEX_EPACK_SA )
{
if( store->chargeSACost <= 0 ) continue;
store->item[nItem].item.itemTableIdx = STORE_ITEM_INDEX_EPACK_SA;
}
else
{
itemTableIdx = store->defaultItem[i].itemIndex[j];
if( !SpawnItem( &store->item[nItem].item, itemTableIdx ) ) continue;
store->item[nItem].item.durability = g_itemTable[itemTableIdx].durability;
store->item[nItem].price = GTH_GetBuyPrice( &store->item[nItem].item );
}
store->item[nItem].page = i;
store->item[nItem].maxNumber = store->item[nItem].curNumber = store->defaultItem[i].itemNumber[j];
nItem ++;
}
for( j = 0; j < store->skill[i].skillIdxNumber; j ++ )
{
InitItem( &store->item[nItem].item );
CSkilTable *pSkillTable = g_SkillTableDB.FindDB(store->skill[i].skillIndex[j]);
if(pSkillTable==NULL)
{
TRACE("Error! pSkillTable==NULL \n");
return 0;
}
store->item[nItem].price = pSkillTable->m_nSphereCost;
store->item[nItem].item.itemTableIdx = store->skill[i].skillIndex[j] + STORE_SKILL_MASK;
store->item[nItem].page = i;
store->item[nItem].maxNumber = store->item[nItem].curNumber = -1;
nItem ++;
}
}
store->itemNumber = nItem;
return 1;
}
int GTH_GetWeaponItemIdx( playerCharacter_t *pc )
{
int itemIdx = pc->equipment[pc->curWeapon + EQUIP_WEAPON_1];
int tableIdx;
if( itemIdx < 0 ) return( -1 );
tableIdx = pc->item[itemIdx].itemTableIdx;
return( tableIdx );
}
float GTH_GetHitRate( void *attacker, int attackerType, void *defender, int defenderType, int addHitPower )
{
playerCharacter_t *attackerPC, *defenderPC;
monsterCharacter_t *attackerMon, *defenderMon;
float hitPower, avoidPower, hitRate;
int atkLevel, defLevel;
if( attackerType == ENTITY_PC )
{
attackerPC = static_cast<playerCharacter_t*>(attacker);
atkLevel = attackerPC->level;
hitPower = (float)attackerPC->calHitPower;
}
else
{
attackerMon = static_cast<monsterCharacter_t*>(attacker);
atkLevel = attackerMon->basic.level;
hitPower = (float)attackerMon->calHitPower;
}
if( defenderType == ENTITY_PC )
{
defenderPC = static_cast<playerCharacter_t*>(defender);
defLevel = defenderPC->level;
avoidPower = (float)defenderPC->calAvoidPower;
}
else
{
defenderMon = static_cast<monsterCharacter_t*>(defender);
defLevel = defenderMon->basic.level;
avoidPower = (float)defenderMon->calAvoidPower;
}
hitPower += addHitPower;
hitRate = hitPower - avoidPower;
if( attackerType == ENTITY_PC && defenderType != ENTITY_PC )
{
if( defLevel - atkLevel == 5 ) hitRate -= 30;
else if( defLevel - atkLevel == 6 ) hitRate -= 35;
else if( defLevel - atkLevel == 7 ) hitRate -= 40;
else if( defLevel - atkLevel == 8 ) hitRate -= 45;
else if( defLevel - atkLevel >= 9 ) hitRate -= 50;
}
if( attackerType == ENTITY_PC ) hitRate += attackerPC->optValue[OV_HIT_RATE];
if( defenderType == ENTITY_PC ) hitRate -= defenderPC->optValue[OV_AVOID_RATE];
if( attackerType == ENTITY_PC )
{
if( hitRate < 20.0f ) hitRate = 30.0f;
if( hitRate > 95.0f ) hitRate = 95.0f;
}
else
{
if( hitRate < 20.0f ) hitRate = 30.0f;
if( hitRate > 95.0f ) hitRate = 95.0f;
}
return( hitRate );
}
float GTH_GetAffectHitRate( void *attacker, int attackerType, void *defender, int defenderType, int type )
{
return( 0.0f );
}
float GTH_GetMagicHitRate( void *attacker, int attackerType, void *defender, int defenderType )
{
return( 100.0f );
}
float GTH_GetCriticalRate( void *attacker, int attackerType, void *defender, int defenderType )
{
playerCharacter_t *attackerPC, *defenderPC;
monsterCharacter_t *attackerMon, *defenderMon;
float atkLevel, defLevel;
float hitRate;
float deCriticalRate;
if( attackerType == ENTITY_PC )
{
attackerPC = static_cast<playerCharacter_t*>(attacker);
atkLevel = (float)attackerPC->level;
hitRate = (float)attackerPC->calCriticalRate;
}
else
{
attackerMon = static_cast<monsterCharacter_t*>(attacker);
atkLevel = (float)attackerMon->basic.level;
hitRate = (float)attackerMon->calCriticalRate;
}
if( defenderType == ENTITY_PC )
{
defenderPC = static_cast<playerCharacter_t*>(defender);
defLevel = (float)defenderPC->level;
deCriticalRate = (float)defenderPC->optValue[OV_DECRITICAL];
}
else
{
defenderMon = static_cast<monsterCharacter_t*>(defender);
defLevel = (float)defenderMon->basic.level;
deCriticalRate = 0.0f;
}
hitRate -= deCriticalRate;
if( (int)hitRate <= 0 ) hitRate = 0.0f;
return( hitRate );
}
void GTH_GetAttackSkillDamage(const int TargetEntityIdx,const int TargetEntityType,const message_t* message,int &SkillPhyDmg,int &SkillMysteryPosDmg,int &SkillMysteryNegDmg,int &SkillDefence)
{
playerCharacter_t* pPlayer=NULL;
monsterCharacter_t* pMonster=NULL;
if( TargetEntityType == ENTITY_PC)
{
pPlayer = gcpTools->GetPlayerRecordPointer(TargetEntityIdx);
if(NULL == pPlayer) return;
}
else
{
pMonster = gcpTools->GetMonsterRecordPointer(TargetEntityIdx);
if(NULL == pMonster) return;
}
if(message->data[MSG_ATKDATA_ETC_INFO] == MSGINFO_ATK_ETC_RA_RATIO_DAMAGE)
{
if( TargetEntityType == ENTITY_PC )
{
SkillPhyDmg =pPlayer->calMaxRA * ( (float) message->data[MSG_ATKDATA_ETC_DATA_1] * 0.01f);
SkillMysteryPosDmg =pPlayer->calMaxRA * ( (float) message->data[MSG_ATKDATA_ETC_DATA_0] * 0.01f);
}
else
{
SkillPhyDmg =pMonster->calMaxRA * ( (float) message->data[MSG_ATKDATA_ETC_DATA_1] * 0.01f);
SkillMysteryPosDmg =pMonster->calMaxRA * ( (float) message->data[MSG_ATKDATA_ETC_DATA_0] * 0.01f);
}
}
}
void GTH_GeSkillDamage(const int entityIdx,const int entityType,const message_t* message,int _Type,float &Val)
{
playerCharacter_t* pPlayer=NULL;
monsterCharacter_t* pMonster=NULL;
if( entityType == ENTITY_PC)
{
pPlayer = gcpTools->GetPlayerRecordPointer(entityIdx);
if(NULL == pPlayer) return;
}
else
{
pMonster = gcpTools->GetMonsterRecordPointer(entityIdx);
if(NULL == pMonster) return;
}
float *pOptValue=NULL;
if( entityType == ENTITY_PC )
{
pOptValue= &(*(pPlayer->optValue));
}
else
{
pOptValue= &(*(pMonster->optValue));
}
switch(_Type) {
case Skill_Enum_Data_Type::SKILL_DMG_PHYDMG:
Val *= ( 1 + (float) pOptValue[OV_SKILL_FINAL_ADD_PHY_DMG_RATE] * 0.01f);
break;
case Skill_Enum_Data_Type::SKILL_DMG_MYSTERY_POS_DMG:
Val *= ( 1 + (float) pOptValue[OV_SKILL_FINAL_ADD_MYSTERY_POS_DMG_RATE] * 0.01f);
break;
case Skill_Enum_Data_Type::SKILL_DMG_MYSTERY_NEG_DMG:
Val *= ( 1 + (float) pOptValue[OV_SKILL_FINAL_ADD_MYSTERY_NEG_DMG_RATE] * 0.01f);
break;
case Skill_Enum_Data_Type::SKILL_DMG_DEFENCE:
Val *= ( 1 + (float) pOptValue[OV_SKILL_FINAL_ADD_DEFENCE_RATE] * 0.01f);
break;
}
return ;
}
void GTH_AnalyzeAttackMessageEtcInfo( message_t *message, int eachDmg[] )
{
switch( message->data[MSG_ATKDATA_ETC_INFO] )
{
case MSGINFO_ATK_ETC_INFO_RASTEAL :
{
int raStealPoint;
raStealPoint = (int)( (float)eachDmg[0] * (float)message->data[MSG_ATKDATA_ETC_DATA_0] * 0.01f );
if( message->fromType == ENTITY_PC )
{
if( g_pc[message->fromIdx].alive )
{
g_pc[message->fromIdx].curRA += (float)raStealPoint;
if( g_pc[message->fromIdx].curRA > g_pc[message->fromIdx].calMaxRA )
g_pc[message->fromIdx].curRA = g_pc[message->fromIdx].calMaxRA;
}
}
else
{
if( g_monster[message->fromIdx].aliveState == MON_ALIVE_STATE_NORMAL )
{
g_monster[message->fromIdx].curRA += (float)raStealPoint;
if( g_monster[message->fromIdx].curRA > g_monster[message->fromIdx].calMaxRA )
g_monster[message->fromIdx].curRA = g_monster[message->fromIdx].calMaxRA;
}
}
}
case MSGINFO_ATK_ETC_INFO_STUN :
{
float fRandom = GTH_Random();
if( fRandom < (float)message->data[MSG_ATKDATA_ETC_DATA_0] * 0.01f )
{
if( message->toType == ENTITY_PC )
{
g_pc[message->toIdx].recoveryTime = (float)message->data[MSG_ATKDATA_ETC_DATA_1] * 1000.0f;
g_pc[message->toIdx].event = GTH_EV_CHAR_STUN;
g_pc[message->toIdx].saveSkillIdx = -1;
g_pc[message->toIdx].skillCastingtime = 0.0f;
g_pc[message->toIdx].skillCastingState = true;
}
else
{
g_monster[message->toIdx].recoveryTime = (float)message->data[MSG_ATKDATA_ETC_DATA_1] * 1000.0f;
g_monster[message->toIdx].event = GTH_EV_CHAR_STUN;
}
message->data[MSG_ATKDATA_STUN_FLAG] = MSG_ATKDATA_STUN_TYPE_STUN;
}
}
break;
case MSGINFO_ATK_ETC_INFO_SHOCK :
{
if( GTH_Random() < (float)message->data[MSG_ATKDATA_ETC_DATA_0] * 0.01f )
{
if( message->toType == ENTITY_PC )
{
g_pc[message->toIdx].recoveryTime = (float)message->data[MSG_ATKDATA_ETC_DATA_1];
g_pc[message->toIdx].event = GTH_EV_CHAR_STUN;
g_pc[message->toIdx].saveSkillIdx = -1;
g_pc[message->toIdx].skillCastingtime = 0.0f;
g_pc[message->toIdx].skillCastingState = MSG_ATKDATA_STUN_TYPE_SHOCK;
}
else
{
g_monster[message->toIdx].recoveryTime = (float)message->data[MSG_ATKDATA_ETC_DATA_1] * 1000.0f;
g_monster[message->toIdx].event = GTH_EV_CHAR_STUN;
}
message->data[MSG_ATKDATA_STUN_FLAG] = MSG_ATKDATA_STUN_TYPE_SHOCK;
}
}
break;
case MSGINFO_ATK_ECT_INFO_PUSHED:
{
if( message->toType == ENTITY_PC )
{
g_pc[message->toIdx].recoveryTime = (float)message->data[MSG_ATKDATA_ETC_DATA_0];
g_pc[message->toIdx].event = GTH_EV_CHAR_PUSHED;
g_pc[message->toIdx].saveSkillIdx = -1;
g_pc[message->toIdx].skillCastingtime = 0.0f;
g_pc[message->toIdx].skillCastingState = MSG_ATKDATA_STUN_TYPE_PUSHED;
}
else
{
g_monster[message->toIdx].recoveryTime = (float)message->data[MSG_ATKDATA_ETC_DATA_0] * 1000.0f;
g_monster[message->toIdx].event = GTH_EV_CHAR_PUSHED;
}
message->data[MSG_ATKDATA_STUN_FLAG] = MSG_ATKDATA_STUN_TYPE_PUSHED;
}
break;
case MSGINFO_ATK_ETC_INFO_HIDE:
{
if( message->toType == ENTITY_PC )
{
}
else
{
}
}
break;
}
}
void GTH_GetExpFromLevelDiffer( int levelDiffer, int &exp, int &genExp, int &genCapability )
{
float a, b;
if( levelDiffer <= 1 ) return;
if( levelDiffer >= 2 && levelDiffer <= 8 )
{
a = (float)levelDiffer-1;
b = ( a * a + 15.0f * a ) * 0.5f * 0.01f;
exp = (int)( (float)exp * ( 1.0f - b ) );
genExp = (int)( (float)genExp * ( 1.0f - b ) );
genCapability = (int)( (float)genCapability * ( 1.0f - b ) );
}
else
{
exp = (int)( (float)exp * 0.1f );
genExp = (int)( (float)genExp * 0.1f );
genCapability = (int)( (float)genCapability * 0.1f );
}
}
int GTH_IsSharingParty( monsterCharacter_t *m, playerCharacter_t *pc )
{
float dist;
if( m->worldIdx != pc->worldIdx ) return 0;
dist = GTH_GetDistance2D( pc->position, m->position );
if( dist > 2400.0f ) return 0;
return 1;
}
int GTH_MakePortal( int makerType, int makerIdx, int keepTime, int numPerson, int worldIdx, vec3_t position, int targetWorldIdx, vec3_t targetPosition )
{
int i;
itemObject_t *itemObject;
if ( g_objectNumber >= MAX_OBJECTS ) return -1;
itemObject = &g_object[0];
for (i=0; i < MAX_OBJECTS; i++, itemObject++)
{
if ( !itemObject->active ) break;
}
if ( i >= MAX_OBJECTS ) return -1;
itemObject->idx = i;
itemObject->active = true;
itemObject->objectType = OBJECT_TYPE_PORTAL;
itemObject->worldIdx = worldIdx;
vec_copy(position, itemObject->position);
int usePortalNum = 0;
itemObject->portal.portalType = 0;
itemObject->portal.worldIdx[usePortalNum] = targetWorldIdx;
itemObject->portal.numPerson = numPerson;
vec_copy( targetPosition, itemObject->portal.position[usePortalNum] );
itemObject->entityType = ENTITY_OBJECT;
vec_set(itemObject->angles, 0, 0, 0);
itemObject->zoneIdx = GTH_Zone_GetZoneIdx(itemObject->position);
if ( !GTH_Zone_AddEntityList(itemObject->worldIdx, itemObject->zoneIdx, ENTITY_OBJECT, itemObject->idx) )
{
return -1;
}
if( makerType == ENTITY_PC )
{
if( g_pc[makerIdx].organizeServer < 0 )
{
itemObject->lootPCIdx = makerIdx;
itemObject->lootType = LOOTTYPE_INDIVIDUAL;
itemObject->lootTime = keepTime;
itemObject->destroyTime = g_globalTime + keepTime;
}
else
{
itemObject->lootPCIdx = makerIdx;
itemObject->lootType = LOOTTYPE_PARTY;
itemObject->lootTime = keepTime;
itemObject->destroyTime = g_globalTime + keepTime;
itemObject->organizeServer = g_pc[makerIdx].organizeServer;
itemObject->organizeTime = g_pc[makerIdx].organizeTime;
strcpy( itemObject->organizerName, g_pc[makerIdx].organizerName );
}
}
else
{
itemObject->lootPCIdx = -1;
itemObject->lootType = LOOTTYPE_EVERYONE;
itemObject->lootTime = 0;
itemObject->destroyTime = g_globalTime + keepTime;
}
g_objectNumber++;
GTH_SendMessage_AddItemObject( itemObject );
return( 1 );
}
void GTH_TransportWorldWithPortal( playerCharacter_t *pc, itemObject_t *itemObject )
{
int zoneIdx;
vec3_t pos;
int worldIdx;
int memberIdx;
vec3_t savePosition;
int saveWorldIdx;
AI_InitMessage( pc );
GTH_PC_Calculate( pc );
pc->event = GTH_EV_CHAR_IDLE;
int usePortalNum = 0;
if ( itemObject->lootType == LOOTTYPE_DANBATTLE_TEAMS )
{
LPREQUEST_RECORD requester = static_cast<LPREQUEST_RECORD>(g_pDanBattleManager->GetBattleRequestDan());
LPREQUEST_RECORD suggester = static_cast<LPREQUEST_RECORD>(g_pDanBattleManager->GetBattleSuggestDan());
if ( requester != NULL && suggester != NULL )
{
if ( requester->DanIdx == pc->guildIdx )
usePortalNum = 0;
else
usePortalNum = 1;
}
}
worldIdx = itemObject->portal.worldIdx[usePortalNum];
vec_copy( itemObject->portal.position[usePortalNum], pos );
if ( GTH_IsLocalServiceWorld( worldIdx ) )
{
if( worldIdx == pc->worldIdx )
{
vec_copy( pos, pc->position );
pc->reliableWorldIdx = pc->worldIdx;
vec_copy( pos, pc->reliablePosition );
zoneIdx = GTH_Zone_UpdateCurrentZone(ENTITY_PC, pc->idx, pc->worldIdx, pc->zoneIdx, pc->position);
pc->zoneIdx = zoneIdx;
GTH_SendPCEventMessage_Respawn( pc );
GTH_SendMessage_SyncItemObject( pc );
}
else
{
GTH_Zone_DeleteEntityList(pc->worldIdx, pc->zoneIdx, pc->entityType, pc->idx);
pc->worldIdx = worldIdx;
vec_copy( pos, pc->reliablePosition );
pc->reliableWorldIdx = worldIdx;
vec_copy( pos, pc->position );
pc->zoneIdx = GTH_Zone_GetZoneIdx( pc->position );
GTH_Zone_AddEntityList(pc->worldIdx, pc->zoneIdx, pc->entityType, pc->idx);
GTH_SendPCEventMessage_Respawn( pc );
pc->ready = false;
g_logSystem->Write("User [%s] Move to Other World By Portal. Pos(%.2f, %.2f, %.2f), World : %d", pc->userID, pc->position[0], pc->position[1], pc->position[2], pc->worldIdx);
}
}
else
{
saveWorldIdx = pc->worldIdx;
vec_copy(pc->position, savePosition);
pc->worldIdx = worldIdx;
vec_copy( pos, pc->position );
memberIdx = GTH_FindServerWithinGroup( worldIdx );
if (memberIdx < 0)
{
pc->flagChangeServer = -1;
DB_SaveGameData( pc, SAVEGAMEDATA_QUIT);
return;
}
else
{
pc->flagChangeServer = 1;
pc->changeServerWorldIdx = worldIdx;
DB_SaveGameData( pc, SAVEGAMEDATA_QUIT);
}
pc->worldIdx = saveWorldIdx;
vec_copy(savePosition, pc->position);
}
}
void GTH_TransportWorldWithNPC( playerCharacter_t *pc, int worldIdx, vec3_t position )
{
int zoneIdx;
int memberIdx;
vec3_t savePosition;
int saveWorldIdx;
AI_InitMessage( pc );
GTH_PC_Calculate( pc );
pc->event = GTH_EV_CHAR_IDLE;
if ( GTH_IsLocalServiceWorld( worldIdx ) )
{
if( worldIdx == pc->worldIdx )
{
vec_copy( position, pc->position );
pc->reliableWorldIdx = pc->worldIdx;
vec_copy( position, pc->reliablePosition );
zoneIdx = GTH_Zone_UpdateCurrentZone(ENTITY_PC, pc->idx, pc->worldIdx, pc->zoneIdx, pc->position);
pc->zoneIdx = zoneIdx;
GTH_SendPCEventMessage_Respawn( pc );
GTH_SendMessage_SyncItemObject( pc );
}
else
{
GTH_Zone_DeleteEntityList(pc->worldIdx, pc->zoneIdx, pc->entityType, pc->idx);
pc->worldIdx = worldIdx;
vec_copy( position, pc->reliablePosition );
pc->reliableWorldIdx = worldIdx;
vec_copy( position, pc->position );
pc->zoneIdx = GTH_Zone_GetZoneIdx( pc->position );
GTH_Zone_AddEntityList(pc->worldIdx, pc->zoneIdx, pc->entityType, pc->idx);
GTH_SendPCEventMessage_Respawn( pc );
pc->ready = false;
g_logSystem->Write("User [%s] Move to Other World By Portal. Pos(%.2f, %.2f, %.2f), World :%d", pc->userID, pc->position[0], pc->position[1], pc->position[2], pc->worldIdx);
}
}
else
{
saveWorldIdx = pc->worldIdx;
vec_copy(pc->position, savePosition);
pc->worldIdx = worldIdx;
vec_copy( position, pc->position );
memberIdx = GTH_FindServerWithinGroup( worldIdx );
if (memberIdx < 0)
{
pc->flagChangeServer = -1;
DB_SaveGameData( pc, SAVEGAMEDATA_QUIT);
return;
}
else
{
pc->flagChangeServer = 1;
pc->changeServerWorldIdx = worldIdx;
DB_SaveGameData( pc, SAVEGAMEDATA_QUIT);
}
pc->worldIdx = saveWorldIdx;
vec_copy(savePosition, pc->position);
}
return;
}
int GTH_IsEtherealForm( playerCharacter_t *pc )
{
if( pc->isTransform && pc->transformType == TRANSFORM_ETHEREAL ) return( true );
return( false );
}
int GTH_IsValidContributionPoint( monsterCharacter_t *m, playerCharacter_t *pc, int idx )
{
float dist;
if( !pc->active || !pc->alive ) return 0;
if( stricmp( m->conInfo[idx].entityName, pc->name ) ) return 0;
if( m->worldIdx != pc->worldIdx ) return 0;
dist = GTH_GetDistance2D( pc->position, m->position );
if( dist > 2400.0f ) return 0;
return 1;
}
void GTH_InitContributionPoint( monsterCharacter_t *m )
{
memset( &m->conInfo, 0, sizeof( monsterContribution_t ) * MAX_NUMBER_OF_MONSTER_CONTRIBUTION );
for (int i = 0; i < MAX_NUMBER_OF_MONSTER_CONTRIBUTION; i ++)
m->conInfo[i].entityIdx = -1;
m->conInfoNumber = 0;
m->maxAtkContributionPoint = 0;
}
int GTH_AddAtkContributionPoint( monsterCharacter_t *m, int entityType, int entityIdx, int point )
{
if( m->conInfoNumber == MAX_NUMBER_OF_MONSTER_CONTRIBUTION ) return 0;
int findidx = -1;
int findCount = 0;
bool flagfind = 0;
for (int i = 0; i < MAX_NUMBER_OF_MONSTER_CONTRIBUTION; i++)
{
if ( m->conInfo[i].entityIdx >= 0 )
{
if( m->conInfo[i].entityType == entityType && m->conInfo[i].entityIdx == entityIdx )
{
flagfind = 1;
findidx = i;
break;
}
}
else
{
if ( findidx < 0)
findidx = i;
}
}
if ( findidx < 0 || findidx >= MAX_NUMBER_OF_MONSTER_CONTRIBUTION ) return false;
if ( !flagfind )
{
if ( findidx < 0 ) return false;;
m->conInfo[findidx].flag = false;
m->conInfo[findidx].entityType = entityType;
m->conInfo[findidx].entityIdx = entityIdx;
m->conInfo[findidx].defPoint = 0;
m->conInfoNumber++;
if( entityType == ENTITY_PC ) strcpy( m->conInfo[findidx].entityName, g_pc[entityIdx].name );
if ( entityType == ENTITY_PC)
{
if ( g_pc[entityIdx].targetIdx != m->idx)
m->conInfo[findidx].ContributionPoints[FIRST_ATTACK_POINT] = m->conInfo[findidx].atkPoint * 1.8f;
}
else
{
if ( g_monster[entityIdx].targetIdx != m->idx)
m->conInfo[findidx].ContributionPoints[FIRST_ATTACK_POINT] = m->conInfo[findidx].atkPoint * 1.8f;
}
}
m->conInfo[findidx].atkPoint += point;
m->conInfo[findidx].time = g_globalTime;
if ( m->message[findidx].data[MSG_ATKDATA_ETC_DATA_2] == MSGINFO_TYPE_ATTACK )
m->conInfo[findidx].ContributionPoints[MYSTERY_POINT] += m->message[m->messageNumber].data[MSG_ATKDATA_PHYSIC_DMG];
else
{
m->conInfo[findidx].ContributionPoints[ATTACK_POINT] += point;
}
m->conInfo[findidx].ContributionPoints[TOTAL_POINT] += m->conInfo[findidx].ContributionPoints[FIRST_ATTACK_POINT];
m->conInfo[findidx].ContributionPoints[TOTAL_POINT] += m->conInfo[findidx].ContributionPoints[FIRST_ATTACK_REVERSE_POINT];
m->conInfo[findidx].ContributionPoints[TOTAL_POINT] += m->conInfo[findidx].ContributionPoints[MYSTERY_POINT];
m->conInfo[findidx].ContributionPoints[TOTAL_POINT] += m->conInfo[findidx].ContributionPoints[RECOVER_POINT];
m->conInfo[findidx].ContributionPoints[TOTAL_POINT] += m->conInfo[findidx].ContributionPoints[ATTACK_POINT];
m->maxAtkContributionPoint += point;
return 1;
}
int GTH_AddDefContributionPoint( monsterCharacter_t *m, int entityType, int entityIdx, int point )
{
int i;
if( m->conInfoNumber == MAX_NUMBER_OF_MONSTER_CONTRIBUTION ) return 0;
bool flagfind = 0;
int findcount = 0;
int findidx = -1;
for( i = 0; i < MAX_NUMBER_OF_MONSTER_CONTRIBUTION; i ++ )
{
if ( m->conInfo[i].entityIdx >= 0)
{
if( m->conInfo[i].entityType == entityType && m->conInfo[i].entityIdx == entityIdx )
{
flagfind = 1;
findidx = i;
break;
}
}
else
{
if ( findidx < 0)
findidx = i;
}
}
if ( findidx < 0 || findidx >= MAX_NUMBER_OF_MONSTER_CONTRIBUTION)
return 0;
if( !flagfind )
{
m->conInfo[findidx].flag = false;
m->conInfo[findidx].entityType = entityType;
m->conInfo[findidx].entityIdx = entityIdx;
m->conInfo[findidx].atkPoint = 0;
m->conInfo[findidx].defPoint = point;
if( entityType == ENTITY_PC ) strcpy( m->conInfo[findidx].entityName, g_pc[entityIdx].name );
m->conInfo[findidx].time = g_globalTime;
if ( g_monster[m->idx].idx != g_pc[entityIdx].targetIdx )
{
if ( m->conInfo[findidx].ContributionPoints[FIRST_ATTACK_REVERSE_POINT] == 0)
m->conInfo[findidx].ContributionPoints[FIRST_ATTACK_REVERSE_POINT] +=
point * 0.5;
}
m->conInfoNumber ++;
}
else
{
m->conInfo[findidx].defPoint += point;
m->conInfo[findidx].time = g_globalTime;
}
return 1;
}
float GTH_ConvertAttackDelay( float currAtkDelay, float atkSpdRate )
{
float velocity = 1.0f / currAtkDelay;
float newAtkDelay;
velocity = velocity * ( 100.0f - atkSpdRate ) * 0.01f;
newAtkDelay = 1.0f / velocity;
return( newAtkDelay );
}
int GTH_GetNextLevel( __int64& exp )
{
int i;
for( i = 0; i < MAX_NUMBER_OF_LEVEL; i ++ )
{
if( exp < g_expTable[i].totalexp ) return( i+1 );
}
exp = g_expTable[MAX_NUMBER_OF_LEVEL-1].totalexp - 1;
return( MAX_NUMBER_OF_LEVEL );
}
int GTH_GetNextGenLevel( __int64& exp )
{
int i;
for( i = 0; i < MAX_NUMBER_OF_LEVEL/2 ; i ++ )
{
if( exp < g_expTable[i].totalGenExp ) return( i+1 );
}
exp = g_expTable[(MAX_NUMBER_OF_LEVEL/2)-1].totalGenExp - 1;
return( MAX_NUMBER_OF_LEVEL/2 );
}
int GTH_CheckJob( playerCharacter_t *pc, int j0, int j1, int j2, int j3 )
{
int reqBeforeAT, req1st, req2nd, req3rd;
reqBeforeAT = 0;
req1st = 0;
req2nd = 0;
req3rd = 0;
switch( pc->pcJob )
{
case J_MENTALITY :
reqBeforeAT |= AT_MENTALITY;
break;
case J_WIND :
reqBeforeAT |= AT_WIND;
break;
case J_WATER :
reqBeforeAT |= AT_WATER;
break;
case J_EARTH:
reqBeforeAT |= AT_EARTH;
break;
case J_DEVOTIONAL_KNIGHT :
reqBeforeAT |= AT_MENTALITY;
req1st |= AT_DEVOTIONAL_KNIGHT;
break;
case J_ROMING_KNIGHT :
reqBeforeAT |= AT_MENTALITY;
req1st |= AT_ROMING_KNIGHT;
break;
case J_PIECING_EYES :
reqBeforeAT |= AT_WIND;
req1st |= AT_PIECING_EYES;
break;
case J_WINDY_ROMER :
reqBeforeAT |= AT_WIND;
req1st |= AT_WINDY_ROMER;
break;
case J_DESTROYER :
reqBeforeAT |= AT_WATER;
req1st |= AT_DESTROYER;
break;
case J_GUARDIAN :
reqBeforeAT |= AT_WATER;
req1st |= AT_GUARDIAN;
break;
case J_PROPHECIER :
reqBeforeAT |= AT_WATER;
req1st |= AT_PROPHECIER;
break;
case J_TRANSFORMER :
reqBeforeAT |= AT_EARTH;
req1st |= AT_TRANSFORMER;
break;
case J_DEFENDER :
reqBeforeAT |= AT_EARTH;
req1st |= AT_DEFENDER;
break;
case J_STRANGER :
reqBeforeAT |= AT_EARTH;
req1st |= AT_STRANGER;
break;
}
if( j0 != 0 )
{
if( j0 & reqBeforeAT ) return 1;
}
if( j1 != 0 )
{
if( j1 & req1st ) return 1;
}
if( j2 != 0 )
{
if( j2 & req2nd ) return 1;
}
if( j3 != 0 )
{
if( j3 & req3rd ) return 1;
}
return 0;
}
//lucky 2012 ( weapon in ring slots patch #1 )
bool GTH_CheckWearPosion( playerCharacter_t *pc )
{
int i, itemIdx;
item_t *item;
itemTable_t *pItem;
bool bRet = true;
for( i = EQUIP_WEAPON_1; i < MAX_EQUIPMENT; i ++ )
{
if( pc->equipment[i] < 0 ) continue;
itemIdx = pc->equipment[i];
item = &pc->item[itemIdx];
pItem = &g_itemTable[item->itemTableIdx];
if( i == EQUIP_WEAPON_1 || i == EQUIP_WEAPON_2 )
{
if( pItem->wearPosition == ITEM_WEAR_POS_WEAPON )
{
continue;
}
}
if ( pItem->wearPosition == i - 1 )
{
continue;
}
memset( &pc->item[itemIdx], 0, sizeof( item_t ) );
pc->equipment[i] = -1;
bRet = false;
}
return bRet;
}
//end
int GTH_CheckRequire( playerCharacter_t *pc, int requireType, void* pReq )
{
int level, genLevel, force, soul, agi, vit;
int notReq;
level = pc->level;
genLevel = pc->genLevel;
force = pc->calForce;
soul = pc->calSoulpower;
agi = pc->calAgility;
vit = pc->calVitality;
switch( requireType )
{
case 0 :
{
item_t *item = static_cast<item_t*>(pReq);
itemTable_t *pItem;
pItem = &g_itemTable[item->itemTableIdx];
//lucky 2012 Blank sword not allowed exept for GM.
if ((item->itemTableIdx <=0) && (pc->gameMaster<1))
{
return 0;
}
//end
if( pItem->wearPosition == ITEM_WEAR_POS_NONE ) return 1;
notReq = false;
if( !GTH_CheckJob( pc, pItem->reqBeforeAT, pItem->req1stAT, pItem->req2ndAT, pItem->req3rdAT) ) return 0;
if( GTH_IsRepairItem( item ) && item->durability <= 0 ) return 0;
if( !notReq )
{
if( pItem->reqForce > force ) return 0;
if( pItem->reqSoulpower > soul ) return 0;
if( pItem->reqAgility > agi ) return 0;
if( pItem->reqVitality > vit ) return 0;
if( item->reqLevel > level ) return 0;
}
return 1;
}
case 1 :
{
int skillTableIdx = (* static_cast<int *>(pReq) );
CSkilTable *pSkillTable = g_SkillTableDB.FindDB(skillTableIdx);
if(pSkillTable==NULL)
{
TRACE("Error! pSkillTable==NULL \n");
return 0;
}
if( !GTH_CheckJob( pc->pcJob, pSkillTable->m_nJobType ) ) return 0;
if( genLevel < pSkillTable->GetSkillRequire()->m_nGenLevel ) return 0;
return 1;
}
break;
}
return 0;
}
int GTH_GetEquipPos( item_t *item, int equipPos )
{
int itemTableIdx;
int tableEquipPos;
itemTableIdx = item->itemTableIdx;
tableEquipPos = g_itemTable[itemTableIdx].wearPosition;
if( tableEquipPos == ITEM_WEAR_POS_WEAPON )
{
if( equipPos == EQUIP_WEAPON_1 || equipPos == EQUIP_WEAPON_2 ) return( equipPos );
return( EQUIP_WEAPON_1 );
}
else if( tableEquipPos >= ITEM_WEAR_POS_UPPER && tableEquipPos <= ITEM_WEAR_POS_EPACK )
{
return( tableEquipPos + 1 );
}
else return( -1 );
}
int GTH_GetGenTypeFromJob( int pcJob )
{
if( pcJob == J_MENTALITY || pcJob == J_DEVOTIONAL_KNIGHT ||
pcJob == J_ROMING_KNIGHT ) return( 0 );
if( pcJob == J_WIND || pcJob == J_PIECING_EYES ||
pcJob == J_WINDY_ROMER ) return( 1 );
if( pcJob == J_WATER || pcJob == J_DESTROYER ||
pcJob == J_GUARDIAN || pcJob == J_PROPHECIER ) return( 2 );
if( pcJob == J_EARTH || pcJob == J_TRANSFORMER ||
pcJob == J_DEFENDER || pcJob == J_STRANGER ) return( 3 );
return( -1 );
}
int GTH_CheckJob( int job, int reqJob )
{
if( reqJob == J_MENTALITY )
{
if( job == J_MENTALITY || job == J_DEVOTIONAL_KNIGHT ||
job == J_ROMING_KNIGHT ) return 1;
}
if( reqJob == J_WIND )
{
if( job == J_WIND || job == J_PIECING_EYES ||
job == J_WINDY_ROMER ) return 1;
}
if( reqJob == J_WATER )
{
if( job == J_WATER || job == J_DESTROYER ||
job == J_GUARDIAN || job == J_PROPHECIER ) return 1;
}
if( reqJob == J_EARTH )
{
if( job == J_EARTH || job == J_TRANSFORMER ||
job == J_DEFENDER || job == J_STRANGER ) return 1;
}
if( reqJob == job ) return 1;
return 0;
}
int GTH_IsRepairItem( item_t *item )
{
int itemTableIdx = item->itemTableIdx;
if( !g_itemTable[itemTableIdx].durYn ) return 0;
if( !g_itemTable[itemTableIdx].repairYn ) return 0;
if( g_itemTable[itemTableIdx].durability == 0 ) return 0;
if( item->durability == g_itemTable[itemTableIdx].durability ) return 0;
return 1;
}
int GTH_GetAllRepairCost( playerCharacter_t* pc, int curSE )
{
int i, itemIdx, dur, cost = 0;
int itemTableIdx, itemType;
item_t *item;
for( i = EQUIP_WEAPON_1; i < EQUIP_EPACK; i ++ )
{
itemIdx = pc->equipment[i];
if( itemIdx < 0 ) continue;
item = &pc->item[itemIdx];
itemTableIdx = item->itemTableIdx;
itemType = GetItemType( itemTableIdx );
if( item->durability >= g_itemTable[itemTableIdx].durability ) continue;
if( g_itemTable[itemTableIdx].durability <= 0 ) continue;
if( !( itemType == 0 || itemType == 1 ) ) continue;
cost = GTH_GetRepairCost( item, curSE, dur );
if( curSE < cost || dur == 0 ) continue;
curSE -= cost;
}
return( pc->curChargeSE - curSE );
}
int GTH_GetRepairCost( item_t* item, int curSE, int &checkDur )
{
int itemTableIdx;
int cost, dur, decDur, totalPrice;
float a;
itemTableIdx = item->itemTableIdx;
cost = g_itemTable[itemTableIdx].sellCost;
cost = GTH_GetBuyPrice( item );
cost = (int)( (float)cost * 0.1f );
dur = g_itemTable[itemTableIdx].durability;
if( item->durability > dur ) item->durability = dur;
decDur = dur - item->durability;
a = (float)cost / (float)( dur * dur );
totalPrice = (int)( (float)( decDur * decDur ) * a );
if( totalPrice == 0 ) totalPrice = 1;
if( curSE < 0 ) return( totalPrice );
if( curSE < totalPrice )
{
checkDur = (int)sqrtf( (float)curSE / a );
totalPrice = curSE;
}
else checkDur = decDur;
return( totalPrice );
}
int GTH_GetBuyPrice( item_t* item )
{
int cost, realCost;
if( GTH_IsStackItem( item ) )
{
cost = g_itemTable[item->itemTableIdx].sellCost;
cost *= ( item->durability + 1 );
return( cost );
}
switch( item->itemTableIdx )
{
case QUESTSCROLL_ITEM_INDEX:
realCost = (int)( 2.5f * (float) g_questscrollTable[item->optionIdx[0]].data.price );
break;
default:
{
realCost = cost = g_itemTable[item->itemTableIdx].sellCost;
for( int i = 0; i < item->optionNumber; i ++ )
{
if( item->optionIdx[i] < 0 ) continue;
if( item->optionIdx[i] >= MAX_NUMBER_OF_ITEM_OPTION_TABLE ) continue;
realCost += (int)( (float)cost * 0.1f );
}
}
break;
}
if( realCost < 0 ) realCost = 0;
return( realCost );
}
int GTH_GetSellPrice( item_t* item )
{
float a, cost;
int dur, sellcost;
dur = g_itemTable[item->itemTableIdx].durability;
cost = (float)GTH_GetBuyPrice( item );
if( dur <= 0 ) a = cost;
else a = cost - (float)GTH_GetRepairCost( item, -1, dur );
a *= 0.3f;
sellcost = (int)a;
if( sellcost <= 0 ) sellcost = 0;
return( sellcost );
}
int GTH_GetDepotPrice( playerCharacter_t *pc, item_t *item )
{
return( 300 );
}
int GTH_IsConsumptiveItem( item_t* item )
{
int itemTableIdx, classIdx;
itemTableIdx = item->itemTableIdx;
classIdx = g_itemTable[itemTableIdx].classIdx;
if( !g_itemClassTable[classIdx].etcAtt ) return 0;
if( !g_itemClassTable[classIdx].etcAtt ) return 0;
if( g_itemTable[itemTableIdx].useFlag ) return 1;
return 0;
}
int GTH_IsStackItem( item_t* item )
{
int itemTableIdx;
itemTableIdx = item->itemTableIdx;
if( g_itemTable[itemTableIdx].stackFlag ) return 1;
return 0;
}
int GTH_CheckStackItem( item_t* item1, item_t* item2 )
{
if( !GTH_IsStackItem( item1 ) ) return( 0 );
if( !GTH_IsStackItem( item2 ) ) return( 0 );
if( item1->itemTableIdx == item2->itemTableIdx ) return( 1 );
return( 0 );
}
float GTH_GetWeaponTypeBonusPhyDamage( playerCharacter_t *pc, item_t *item )
{
int classIdx;
float bonus = 0.0f;
float force, soul, agi, vit;
force = (float)pc->calForce;
soul = (float)pc->calSoulpower;
agi = (float)pc->calAgility;
vit = (float)pc->calVitality;
classIdx = g_itemTable[item->itemTableIdx].classIdx;
switch( g_itemClassTable[classIdx].weaponType )
{
case WEAPON_TYPE_DANGGER :
bonus += force * 0.4f;
bonus += soul * 0.0f;
bonus += agi * 0.4f;
bonus += vit * 0.0f;
break;
case WEAPON_TYPE_ONEHAND_SWORD :
bonus += force * 0.6f;
bonus += soul * 0.0f;
bonus += agi * 0.2f;
bonus += vit * 0.0f;
break;
case WEAPON_TYPE_TWOHAND_SWORD :
bonus += force * 0.8f;
bonus += soul * 0.0f;
bonus += agi * 0.0f;
bonus += vit * 0.0f;
break;
case WEAPON_TYPE_MAGIC_BOW :
bonus += force * 0.5f;
bonus += soul * 0.0f;
bonus += agi * 0.3f;
bonus += vit * 0.0f;
break;
case WEAPON_TYPE_STAFF :
bonus += force * 0.5f;
bonus += soul * 0.3f;
bonus += agi * 0.0f;
bonus += vit * 0.0f;
break;
case WEAPON_TYPE_SPIRITOR :
bonus += force * 0.5f;
bonus += soul * 0.0f;
bonus += agi * 0.0f;
bonus += vit * 0.3f;
break;
case WEAPON_TYPE_CLAW :
bonus += force * 0.6f;
bonus += soul * 0.0f;
bonus += agi * 0.0f;
bonus += vit * 0.2f;
break;
}
return( bonus * 0.01f );
}
float GTH_GetWeaponTypeBonusMagDamage( playerCharacter_t *pc, item_t *item )
{
float bonus = 0.0f;
float force, soul, agi, vit;
force = (float)pc->calForce;
soul = (float)pc->calSoulpower;
agi = (float)pc->calAgility;
vit = (float)pc->calVitality;
bonus += soul * 1.3f;
return( bonus * 0.01f );
}
int GTH_SetTrainMonster( playerCharacter_t *pc, monsterCharacter_t *mon )
{
int oldestTrainMonsterIdx;
int oldestTrainMonsterTime;
for( int i = 0; i < MAX_COUNT_TRAIN_MONSTER; i ++ )
{
if( pc->trainMonsterIdx[i] < 0 ) continue;
if( pc->trainMonsterIdx[i] == mon->idx ) break;
}
if( i == MAX_COUNT_TRAIN_MONSTER )
{
for( i = 0; i < MAX_COUNT_TRAIN_MONSTER; i ++ )
{
if( pc->trainMonsterIdx[i] < 0 ) break;
}
if( i == MAX_COUNT_TRAIN_MONSTER )
{
oldestTrainMonsterIdx = 0;
oldestTrainMonsterTime = pc->trainMonsterTime[0];
for( i = 0; i < MAX_COUNT_TRAIN_MONSTER; i ++ )
{
if( pc->trainMonsterTime[i] < oldestTrainMonsterTime )
{
oldestTrainMonsterIdx = i;
oldestTrainMonsterTime = pc->trainMonsterTime[i];
}
}
i = oldestTrainMonsterIdx;
AI_RemoveTarget( &g_monster[pc->trainMonsterIdx[i]] );
}
pc->trainMonsterIdx[i] = mon->idx;
pc->trainMonsterTime[i] = g_globalTime;
}
return 1;
}
void GTH_UpdateTrainMonster( playerCharacter_t *pc )
{
pc->numTrainMonster = 0;
for( int i = 0; i < MAX_COUNT_TRAIN_MONSTER; i ++ )
{
if( pc->trainMonsterIdx[i] < 0 ) continue;
if( !g_monster[pc->trainMonsterIdx[i]].active || g_monster[pc->trainMonsterIdx[i]].aliveState != MON_ALIVE_STATE_NORMAL )
{
pc->trainMonsterIdx[i] = -1;
}
else
{
if( g_monster[pc->trainMonsterIdx[i]].targetType == ENTITY_PC && g_monster[pc->trainMonsterIdx[i]].targetIdx == pc->idx )
{
pc->numTrainMonster ++;
}
else
{
pc->trainMonsterIdx[i] = -1;
}
}
}
}
void GTH_DeleteTrainMonster( playerCharacter_t *pc, monsterCharacter_t *mon )
{
for( int i = 0; i < MAX_COUNT_TRAIN_MONSTER; i ++ )
{
if( pc->trainMonsterIdx[i] < 0 ) continue;
if( pc->trainMonsterIdx[i] == mon->idx ) break;
}
if( i == MAX_COUNT_TRAIN_MONSTER ) return;
pc->trainMonsterIdx[i] = -1;
pc->numTrainMonster --;
}
int LoadExpTableForServer( char* filename )
{
int size;
byte *buffer;
char* token;
int level;
int expLevel=0;
FILE *fp;
fp = fopen( filename, "rb" );
fseek(fp,0,SEEK_END);
size = ftell(fp);
buffer = new byte[size+1];
fseek(fp,0,SEEK_SET);
fread(buffer,size,1,fp);
fclose(fp);
SetTokenBuffer( buffer, size );
for( int i = 0; i < MAX_NUMBER_OF_LEVEL; i ++ )
memset( &g_expTable[i], 0, sizeof( expTable_t ) );
while( 1 )
{
token = NextToken();
if( token == NULL ) break;
level = atoi( token );
token = NextToken();
g_expTable[expLevel].totalexp = _atoi64( token );
token = NextToken();
g_expTable[expLevel].exp = _atoi64( token );
expLevel++;
}
if(buffer!=NULL)
{
delete [] buffer;
}
return( 1 );
}
int LoadGenExpTableForServer( char* filename )
{
int size;
byte *buffer;
char* token;
int level;
int genExpLevel=0;
FILE *fp;
fp = fopen( filename, "rb" );
fseek(fp,0,SEEK_END);
size = ftell(fp);
buffer = new byte[size+1];
fseek(fp,0,SEEK_SET);
fread(buffer,size,1,fp);
fclose(fp);
SetTokenBuffer( buffer, size );
while( 1 )
{
token = NextToken();
if( token == NULL ) break;
level = atoi( token );
token = NextToken();
g_expTable[genExpLevel].totalGenExp = _atoi64( token );
token = NextToken();
g_expTable[genExpLevel].genExp = _atoi64( token );
genExpLevel++;
}
if(buffer!=NULL)
{
delete [] buffer;
}
return( 1 );
}
int LoadStoreTableForServer( char* filename )
{
int size;
byte *buffer;
char* token;
FILE *fp;
fp = fopen( filename, "rb" );
fseek(fp,0,SEEK_END);
size = ftell(fp);
buffer = new byte[size+1];
fseek(fp,0,SEEK_SET);
fread(buffer,size,1,fp);
fclose(fp);
SetTokenBuffer( buffer, size );
for( int i = 0; i < MAX_STORES; i ++ )
memset( &g_store[i], 0, sizeof( storeStruct_t ) );
int idx = 0, page;
int *pNumDefault, *pNumGenerate, *pNumSkill;
while( 1 )
{
token = NextToken();
if( token == NULL ) break;
if( !stricmp( token, "STORE_IDX" ) )
{
token = NextToken();
idx = atoi( token );
}
else if( token[0] == '{' )
{
while ( 1 )
{
token = NextToken();
if( token[0] == '}' ) break;
else if( !stricmp( token, "CLOSE_TIME" ) )
{
token = NextToken();
g_store[idx].closeTime = atoi( token );
}
else if( !stricmp( token, "READY_TIME" ) )
{
token = NextToken();
g_store[idx].readyTime = atoi( token );
}
else if( !stricmp( token, "OPEN_TIME" ) )
{
token = NextToken();
g_store[idx].openTime = atoi( token );
}
else if( !stricmp( token, "EPACK_CHARGE_RA_COST" ) )
{
token = NextToken();
g_store[idx].chargeRACost = atof( token );
}
else if( !stricmp( token, "EPACK_CHARGE_SA_COST" ) )
{
token = NextToken();
g_store[idx].chargeSACost = atof( token );
}
else if( !stricmp( token, "PAGE_0" ) )
{
page = 0;
pNumDefault = &g_store[idx].defaultItem[0].defaultNumber;
pNumGenerate = &g_store[idx].generateItem[0].generateIdxNumber;
pNumSkill = &g_store[idx].skill[0].skillIdxNumber;
}
else if( !stricmp( token, "PAGE_1" ) )
{
page = 1;
pNumDefault = &g_store[idx].defaultItem[1].defaultNumber;
pNumGenerate = &g_store[idx].generateItem[1].generateIdxNumber;
pNumSkill = &g_store[idx].skill[1].skillIdxNumber;
}
else if( !stricmp( token, "PAGE_2" ) )
{
page = 2;
pNumDefault = &g_store[idx].defaultItem[2].defaultNumber;
pNumGenerate = &g_store[idx].generateItem[2].generateIdxNumber;
pNumSkill = &g_store[idx].skill[2].skillIdxNumber;
}
else if( token[0] == '{' )
{
while ( 1 )
{
token = NextToken();
if( token[0] == '}' ) break;
else if( !stricmp( token, "DEFAULT_ITEM_INDEX" ) )
{
token = NextToken();
g_store[idx].defaultItem[page].itemIndex[*pNumDefault] = atoi( token );
token = NextToken();
g_store[idx].defaultItem[page].itemNumber[*pNumDefault] = atoi( token );
(*pNumDefault) ++;
}
else if( !stricmp( token, "GENERATE_INDEX" ) )
{
token = NextToken();
g_store[idx].generateItem[page].generateIdx[*pNumGenerate] = atoi( token );
token = NextToken();
g_store[idx].generateItem[page].generateNumber[*pNumGenerate] = atoi( token );
token = NextToken();
g_store[idx].generateItem[page].generateLevel[*pNumGenerate] = atoi( token );
(*pNumGenerate) ++;
}
else if( !stricmp( token, "STORE_SKILL_INDEX" ) )
{
token = NextToken();
g_store[idx].skill[page].skillIndex[*pNumSkill] = atoi( token );
(*pNumSkill) ++;
}
else if( !stricmp( token, "CHARGE_EPACK_RA" ) )
{
g_store[idx].defaultItem[page].itemIndex[*pNumDefault] = STORE_ITEM_INDEX_EPACK_RA;
g_store[idx].defaultItem[page].itemNumber[*pNumDefault] = -1;
(*pNumDefault) ++;
}
else if( !stricmp( token, "CHARGE_EPACK_SA" ) )
{
g_store[idx].defaultItem[page].itemIndex[*pNumDefault] = STORE_ITEM_INDEX_EPACK_SA;
g_store[idx].defaultItem[page].itemNumber[*pNumDefault] = -1;
(*pNumDefault) ++;
}
}
}
}
}
}
for( i = 0; i < MAX_STORES; i ++ )
{
GTH_OpenStore( i );
}
if(buffer!=NULL)
{
delete [] buffer;
}
return 1;
}
int LoadBindingTableForServer( char* filename )
{
int size;
byte *buffer;
char* token;
int idx;
FILE *fp;
fp = fopen( filename, "rb" );
fseek(fp,0,SEEK_END);
size = ftell(fp);
buffer = new byte[size+1];
fseek(fp,0,SEEK_SET);
fread(buffer,size,1,fp);
fclose(fp);
SetTokenBuffer( buffer, size );
for( int i = 0; i < MAX_BINDINGS; i ++ )
{
memset( &g_binding[i], 0, sizeof( bindingStruct_t ) );
g_binding[i].idx = -1;
}
g_bindingNumber = 0;
while( 1 )
{
token = NextToken();
if( token == NULL ) break;
if( !stricmp( token, "BINDING_IDX" ) )
{
token = NextToken();
idx = atoi( token );
g_binding[idx].idx = idx;
if( idx >= g_bindingNumber ) g_bindingNumber = idx + 1;
} else if( !stricmp( token, "BINDING_WORLD" ) )
{
token = NextToken();
g_binding[idx].worldIdx = atoi( token );
} else if( !stricmp( token, "BINDING_POSITION" ) )
{
token = NextToken();
g_binding[idx].pos[0] = atof( token );
token = NextToken();
g_binding[idx].pos[1] = atof( token );
token = NextToken();
g_binding[idx].pos[2] = atof( token );
} else if( !stricmp( token, "BINDING_RANGE" ) )
{
token = NextToken();
g_binding[idx].range = atof( token );
} else if( !stricmp( token, "BINDING_COST" ) )
{
token = NextToken();
g_binding[idx].cost = atoi( token );
}
}
if(buffer!=NULL)
{
delete []buffer;
buffer=NULL;
}
return( 1 );
}
int LoadScriptInfoTableForServer( char* filename )
{
int size;
byte *buffer;
char* token;
int type, idx;
FILE *fp;
fp = fopen( filename, "rb" );
fseek(fp,0,SEEK_END);
size = ftell(fp);
buffer = new byte[size+1];
fseek(fp,0,SEEK_SET);
fread(buffer,size,1,fp);
fclose(fp);
SetTokenBuffer( buffer, size );
memset( &g_scriptInfo, 0, sizeof( scriptInfoStruct_t ) );
while( 1 )
{
token = NextToken();
if( token == NULL ) break;
if( !stricmp( token, "AI_SCRIPT" ) )
{
type = 0;
}
else if( !stricmp( token, "NPC_SCRIPT" ) )
{
type = 1;
}
else if( token[0] == '{' )
{
while ( 1 )
{
token = NextToken();
if( token[0] == '}' ) break;
idx = atoi( token );
token = NextToken();
if( type == 0 )
{
g_scriptInfo.aiScript[idx].idx = idx;
strcpy( g_scriptInfo.aiScript[idx].filename, token );
g_scriptInfo.numAiScript ++;
}
else
{
g_scriptInfo.npcScript[idx].idx = idx;
strcpy( g_scriptInfo.npcScript[idx].filename, token );
g_scriptInfo.numNpcScript ++;
}
}
}
}
if(buffer!=NULL)
{
delete [] buffer;
}
return( 1 );
}
int LoadGenCapabilityTable( char *filename )
{
int size;
byte* buffer=NULL;
char* token=NULL;
int idx, level, genCapability, limitGenLevel, type;
FILE* fp=NULL;
fp = fopen( filename, "rb" );
if(NULL == fp) return 0;
fseek(fp,0,SEEK_END);
size = ftell(fp);
buffer = new byte[size+1];
if(NULL == buffer) return 0;
fseek(fp,0,SEEK_SET);
fread(buffer,size,1,fp);
if(NULL != fp){ fclose(fp); fp=NULL; }
SetTokenBuffer( buffer, size );
for( int i = 0; i < 100; i ++ )
memset( &g_skillGradeClassTable[i], 0, sizeof( skillGradeClass_t ) );
memset( &g_genCapabilityTable, 0, sizeof( genCapabilityTable_t ) );
while( 1 )
{
token = NextToken();
if( token == NULL ) break;
if( !stricmp( token, "SKILL_CLASS" ) )
{
token = NextToken();
idx = atoi( token );
type = 0;
if(idx >= 100){
MessageBox(g_hWnd,"g_skillGradeClassTable idx overflow!","Error!", MB_OK);
return 0;
}
}
else if( !stricmp( token, "MONSTER_GEN_CAPABILITY" ) )
{
type = 1;
}
else if( token[0] == '{' )
{
while ( 1 )
{
token = NextToken();
if( token[0] == '}' ) break;
level = atoi( token );
token = NextToken();
if( type == 0 )
{
if(level >= 10){
MessageBox(
g_hWnd,
"Gen Capability Table Data Loading Failure!\n Level Maximum 10 overflow found!",
"Error!", MB_OK);
return 0;
}
genCapability = atoi( token );
token = NextToken();
limitGenLevel = atoi( token );
g_skillGradeClassTable[idx].genCapability[level] = genCapability;
g_skillGradeClassTable[idx].limitGenLevel[level] = limitGenLevel;
}
else
{
if(level >= 100){
MessageBox(
g_hWnd,
"Gen Capability Table Data Loading Failure!\n Level Maximum 100 overflow found!",
"Error!", MB_OK);
return 0;
}
g_genCapabilityTable.genCapability[level] = atoi( token );
}
}
}
}
if(NULL != buffer){ delete [] buffer; buffer=NULL; }
return( 1 );
}
int LoadItemCraftTableForServer( char* filename )
{
int size;
byte *buffer;
char* token;
int numSourceItem, numRequireSkill, numResultItem, numOptionIdx;
FILE *fp;
fp = fopen( filename, "rb" );
fseek(fp,0,SEEK_END);
size = ftell(fp);
buffer = new byte[size+1];
fseek(fp,0,SEEK_SET);
fread(buffer,size,1,fp);
fclose(fp);
SetTokenBuffer( buffer, size );
for( int i = 0; i < MAX_NUMBER_OF_ITEM_CRAFT_TABLE; i ++ )
memset( &g_itemCraftTable[i], 0, sizeof( itemCraftTable_t ) );
g_itemCraftTableNumber = 0;
itemCraftTable_t TempItemCraftTable;
while( 1 )
{
token = NextToken();
if( token == NULL ) break;
memset(&TempItemCraftTable,0,sizeof(itemCraftTable_t));
TempItemCraftTable.m_nMembership_type=-1;
if( token[0] == '{' )
{
while ( 1 )
{
token = NextToken();
if( token[0] == '}' ) break;
if( token[0] == NULL ) break;
if( !stricmp( token, "craft_grade" ) )
{
token = NextToken();
TempItemCraftTable.craftGrade = atoi( token );
}
else if( !stricmp( token, "success_probability" ) )
{
token = NextToken();
TempItemCraftTable.successProbability = atof( token );
}
else if( !stricmp( token, "craft_cost" ) )
{
token = NextToken();
TempItemCraftTable.craftCost = atoi( token );
}
else if( !stricmp( token, "craft_special_type" ) )
{
token = NextToken();
TempItemCraftTable.specialType = atoi( token );
}
else if( !stricmp( token, "craft_event_index" ) )
{
token = NextToken();
TempItemCraftTable.m_lEventIndex = atoi( token );
}
else if( !stricmp( token, "event_type" ) )
{
token = NextToken();
TempItemCraftTable.m_btEventType = atoi( token );
}
else if( !stricmp( token, "craft_cheat_name" ) )
{
token = NextToken();
int len = strlen(token);
if(len > 20)
{
wsprintf(TempItemCraftTable.m_chCheatName,"NULL");
}
else
{
wsprintf(TempItemCraftTable.m_chCheatName,"%s",token);
}
}
#ifdef _GTH_KOREAN_VERSION
else if( !stricmp( token, "korea" ) )
{
token = NextToken( );
while( 1 )
{
token = NextToken();
if( token[0] == '}' ) break;
if( token[0] == '{' )
{
while( 1 )
{
token = NextToken( );
if( token[0] == '}' ) break;
if( !stricmp( token, "membership_type" ) )
{
token = NextToken( );
TempItemCraftTable.m_nMembership_type = atoi( token );
}
}
}
}
}
#endif
else if( !stricmp( token, "result_etc" ) )
{
token = NextToken( );
while( 1 )
{
token = NextToken();
if( token[0] == '}' ) break;
if( token[0] == '{' )
{
while( 1 )
{
token = NextToken( );
if( token[0] == '}' ) break;
if( !stricmp( token, "nak" ) )
{
token = NextToken( );
TempItemCraftTable.m_lResultNak = atoi( token );
}
else if( !stricmp( token, "exp" ) )
{
token = NextToken( );
TempItemCraftTable.m_lResultExp = atoi( token );
}
else if( !stricmp( token, "icon" ) )
{
token = NextToken( );
TempItemCraftTable.m_nResultNakMark = atoi( token );
}
}
}
}
}
else if( !stricmp( token, "source_item" ) )
{
numSourceItem = 0;
token = NextToken();
while( 1 )
{
token = NextToken();
if( token[0] == '}' ) break;
if( token[0] == '{' )
{
numOptionIdx = 0;
while( 1 )
{
token = NextToken();
if( token[0] == '}' ) break;
if( !stricmp( token, "index" ) )
{
token = NextToken();
TempItemCraftTable.sourceItem[numSourceItem].itemIndex = atoi( token );
}
else if( !stricmp( token, "number" ) )
{
token = NextToken();
TempItemCraftTable.sourceItem[numSourceItem].itemCount = atoi( token );
}
else if( !stricmp( token, "option_index" ) )
{
token = NextToken();
TempItemCraftTable.sourceItem[numSourceItem].reqOptionIndex[numOptionIdx] = atoi( token );
numOptionIdx ++;
}
else if( !stricmp( token, "above_option_number" ) )
{
TempItemCraftTable.sourceItem[numSourceItem].reqOptionCountType = 0;
token = NextToken();
TempItemCraftTable.sourceItem[numSourceItem].reqOptionCount = atoi( token );
}
else if( !stricmp( token, "equal_option_number" ) )
{
TempItemCraftTable.sourceItem[numSourceItem].reqOptionCountType = 1;
token = NextToken();
TempItemCraftTable.sourceItem[numSourceItem].reqOptionCount = atoi( token );
}
else if( !stricmp( token, "below_option_number" ) )
{
TempItemCraftTable.sourceItem[numSourceItem].reqOptionCountType = 2;
token = NextToken();
TempItemCraftTable.sourceItem[numSourceItem].reqOptionCount = atoi( token );
}
}
TempItemCraftTable.sourceItem[numSourceItem].numReqOptionIndex = numOptionIdx;
numSourceItem ++;
}
}
TempItemCraftTable.numSourceItem = numSourceItem;
}
else if( !stricmp( token, "require_skill" ) )
{
numRequireSkill = 0;
token = NextToken();
while( 1 )
{
token = NextToken();
if( token[0] == '}' ) break;
if( token[0] == '{' )
{
while( 1 )
{
token = NextToken();
if( token[0] == '}' ) break;
if( !stricmp( token, "index" ) )
{
token = NextToken();
TempItemCraftTable.requireSkill[numRequireSkill].skillIndex = atoi( token );
}
else if( !stricmp( token, "above_level" ) )
{
TempItemCraftTable.requireSkill[numRequireSkill].reqSkillLevelType = 0;
token = NextToken();
TempItemCraftTable.requireSkill[numRequireSkill].reqSkillLevel = atoi( token );
}
else if( !stricmp( token, "equal_level" ) )
{
TempItemCraftTable.requireSkill[numRequireSkill].reqSkillLevelType = 1;
token = NextToken();
TempItemCraftTable.requireSkill[numRequireSkill].reqSkillLevel = atoi( token );
}
else if( !stricmp( token, "below_level" ) )
{
TempItemCraftTable.requireSkill[numRequireSkill].reqSkillLevelType = 2;
token = NextToken();
TempItemCraftTable.requireSkill[numRequireSkill].reqSkillLevel = atoi( token );
}
}
numRequireSkill ++;
}
}
TempItemCraftTable.numRequireSkill = numRequireSkill;
}
else if( !stricmp( token, "result_item" ) )
{
numResultItem = 0;
token = NextToken();
while( 1 )
{
token = NextToken();
if( token[0] == '}' ) break;
if( token[0] == '{' )
{
TempItemCraftTable.resultItem[numResultItem].optionGroupIdx = -1;
while( 1 )
{
token = NextToken();
if( token[0] == '}' ) break;
if( !stricmp( token, "index" ) )
{
token = NextToken();
TempItemCraftTable.resultItem[numResultItem].itemIndex = atoi( token );
}
else if( !stricmp( token, "number" ) )
{
token = NextToken();
TempItemCraftTable.resultItem[numResultItem].itemCount = atoi( token );
}
else if( !stricmp( token, "option_grade") )
{
token = NextToken();
TempItemCraftTable.resultItem[numResultItem].optionGrade = atoi( token );
}
else if( !stricmp( token, "rareitem_grade") )
{
token = NextToken();
TempItemCraftTable.resultItem[numResultItem].rareItemGrade = atoi( token );
}
else if( !stricmp( token, "optiongroup") )
{
token = NextToken();
TempItemCraftTable.resultItem[numResultItem].optionGroupIdx = atoi( token );
}
}
numResultItem ++;
}
}
TempItemCraftTable.numResultItem = numResultItem;
}
}
if(TempItemCraftTable.specialType == CRAFT_TYPE_EVENT)
{
TempItemCraftTable.idx = g_EventCraftSystem.GetTableSize();
g_EventCraftSystem.Push(TempItemCraftTable);
}
else
{
TempItemCraftTable.idx = g_itemCraftTableNumber;
memcpy(&g_itemCraftTable[g_itemCraftTableNumber],&TempItemCraftTable,sizeof(itemCraftTable_t));
g_itemCraftTableNumber ++;
}
}
}
if(buffer!=NULL)
{
delete [] buffer;
}
return 1;
}
int GetChaosClass( playerCharacter_t *pc )
{
if( pc->chaosPoint == CHAOSPURE ) return( CHAOS_PURE );
else if( 0< pc->chaosPoint && pc->chaosPoint == CHAOSGENERATE ) return( CHAOS_GENERAL );
else if( pc->chaosPoint >CHAOSGENERATE && pc->chaosPoint <= CHAOSDISORDER) return( CHAOS_DISORDER );
else if( pc->chaosPoint >CHAOSDISORDER && pc->chaosPoint <=CHAOSMONSTER ) return( CHAOS_MONSTER );
return( CHAOS_ATROCITY );
}
void AddChaosPoint( playerCharacter_t* attacker, playerCharacter_t* defender )
{
if( attacker->pvpMode || defender->pvpMode) return;
if(attacker->worldIdx == 0 || defender->worldIdx == 0) return;
if(attacker->worldIdx == 9 || defender->worldIdx == 9) return;
if(attacker->worldIdx==tagGolryunBattle::Golryun_Battle_Map_Index ||
defender->worldIdx==tagGolryunBattle::Golryun_Battle_Map_Index) return;
if ( attacker->DanBattleInfo.nDanBattleIdx >= 0)
return;
int atkChaType, defChaType;
atkChaType = GetChaosClass( attacker );
defChaType = GetChaosClass( defender );
if(CHAOSGENERATE > defender->chaosPoint)
{
int ChaosValue=0;
bool Sendclass=false,Sendspeed=false;
attacker->penaltyTime++;
ChaosValue=(CHAOVALUE+(attacker->penaltyTime*CHAOSADDRATE));
attacker->chaosPoint=attacker->chaosPoint+ChaosValue;
if(attacker->chaosPoint>CHAOSMAX)
{
attacker->chaosPoint=CHAOSMAX;
}
int convertchaosType=GetChaosClass(attacker);
int convertchaosTypedefend=GetChaosClass(defender);
if(convertchaosTypedefend!=defChaType)
{
}
GTH_SendMessage_AddChaosInfo(attacker,ChaosValue,Sendclass,false);
}
if(defender->chaosPoint<CHAOSPURE)
{
defender->chaosPoint=0;
}
}
void DecChaosPoint( playerCharacter_t *pc )
{
if(pc->chaosPoint==0)return;
if( pc->chaosTime == CHAOSPURE )
{
pc->chaosTime = g_globalTime;
return;
}
if( g_globalTime - pc->chaosTime > CHAOSTIME )
{
int pcchaosclass =GetChaosClass(pc);
pc->chaosTime = g_globalTime;
pc->chaosPoint=pc->chaosPoint-10;
int pcchaosclassaffer =GetChaosClass(pc);
if(pcchaosclass!=pcchaosclassaffer)
{
}
}
if( pc->chaosPoint < CHAOSPURE ) pc->chaosPoint = 0;
}
void SetChaosGeneral( playerCharacter_t *attacker, playerCharacter_t *defender )
{
if( defender->pvpMode ) return;
if( attacker->pvpMode ) return;
if ( attacker->worldIdx == DAN_BATTLEMAP_NO )
return;
if ( attacker->DanBattleInfo.nDanBattleIdx >= 0)
return;
if(defender->worldIdx==21 || attacker->worldIdx==21) return;
if(defender->worldIdx == 0 || attacker->worldIdx == 0) return;
if(defender->worldIdx == 9 || attacker->worldIdx == 9) return;
if(attacker->chaosPoint > CHAOSGENERATE) return;
if(attacker->chaosPoint < CHAOSGENERATE)attacker->chaosPoint=0;
if(defender->chaosPoint <CHAOSGENERATE)defender->chaosPoint=0;
if(CHAOSPURE<=attacker->chaosPoint && attacker->chaosPoint<=CHAOSGENERATE)
{
if( CHAOSGENERATE > defender->chaosPoint )
{
attacker->chaosPoint=CHAOSGENERATE;
attacker->chaosTime = g_globalTime;
}
}
}
void GTH_PickUpNak( playerCharacter_t *pc, itemObject_t *itemObject )
{
playerCharacter_t *member;
int memberNumber = 0, memberIdx, pcMemberIdx[MAX_NUMBER_OF_PARTY_MEMBER];
float dist;
if( pc->organizeServer < 0 )
{
GTH_PC_GetLoot( pc->idx, 0, 0, itemObject->nak, 0, 0 );
}
else
{
for( int i = 0; i < MAX_NUMBER_OF_PARTY_MEMBER; i ++ )
{
if( pc->member[i].serverIndex < 0 ) continue;
if( pc->member[i].serverIndex != g_config.gameServerNo ) continue;
memberIdx = pc->member[i].idxOnServer;
if(memberIdx < 0) continue;
if(memberIdx >= MAX_PCS) continue;
member = &g_pc[memberIdx];
if( !member->active ) continue;
if( !member->alive ) continue;
if(0 != strcmp( member->name, pc->member[i].memberName ) ) continue;
dist = GTH_GetDistance2D( pc->position, member->position );
if( dist > 2400.0f ) continue;
pcMemberIdx[memberNumber] = memberIdx;
memberNumber ++;
}
if( memberNumber > 0 )
{
for( i = 0; i < memberNumber; i ++ )
{
memberIdx = pcMemberIdx[i];
if(memberIdx < 0) continue;
if(memberIdx >= MAX_PCS) continue;
member = &g_pc[memberIdx];
if( !member->active ) continue;
if( !member->alive ) continue;
GTH_PC_GetLoot( member->idx, 0, 0, itemObject->nak / memberNumber, 0, 0 );
}
}
}
GTH_RemoveItemObject( itemObject );
}
void GetWord(int index, const char *source, char* token)
{
int i=0;
int j=0;
while( source[i] != '\0' )
{
if( source[i] == ' ' )
{
token[j] = '\0';
if( index == 0 )
return;
else
{
i++;
j=0;
index--;
continue;
}
}
else
{
token[j] = source[i];
}
i++;
j++;
}
token[j] = '\0';
}
int IsPKDisableWorld( int worldIdx )
{
return 0;
}
int IsPvPEnablePosition( int worldIdx, vec3_t pos)
{
if(worldIdx== tagGolryunBattle::Golryun_Battle_Map_Index)
{
if((13615<=pos[0] && pos[0]<=15184)&&(2901<=pos[1]&&pos[1]<=4467)) return 30;
}
return 0;
}
float GetEpackRechargePrice_RA( int onceRecovery, float cost, int level )
{
return( (float)onceRecovery * cost * powf( (float)level, 0.67f ) * 1.5f / 8.0f );
}
float GetEpackRechargePrice_SA( int onceRecovery, float cost, int level )
{
return( (float)onceRecovery * cost * powf( (float)level, 0.67f ) * 1.7f / 8.0f );
}
bool CollectItemForGamble(GambleItem_t GambleItem[] )
{
for (int i = 0; i < g_itemTableNumber; i ++)
{
if ( g_itemTable[i].idx < 0 )
continue;
int availableOn = GetItemAvailalbeOn( g_itemTable[i].idx );
int type = GetGambleItemAvallableOn(availableOn);
if ( !strcmp (g_itemTable[i].name, "BLANK" ) )
continue;
if ( g_itemTable[i].sellYn < 2)
continue;
if ( type == -1)
type = GambleItem_t.OPTION_AVAILABLE_ON_ETC;
GambleItem[type].type = availableOn;
if ( !GambleItem[type].vItem.size() )
g_GambleItemTalbleNumber++;
GambleItem[type].vGambleRate.push_back(g_logic.gambleitemSelectRate[g_itemTable[i].rarity]);
GambleItem[type].TotalGamebleRate += g_logic.gambleitemSelectRate[g_itemTable[i].rarity];
GambleItem[type].vItem.push_back(g_itemTable[i].idx);
}
for (i =0; i < MAX_COUNT_OPTION_AVAILABLE_TYPE; i ++)
{
if ( GambleItem[i].type <= 0 ) continue;
for( int o = 0; o < MAX_COUNT_OPTION_TABLE; o ++ )
{
if( g_optionTable[o].idx < 0 ) continue;
if( !( g_optionTable[o].availableOn & GambleItem[i].type ) )
continue;
GambleItem[i].vOption.push_back(g_optionTable[o].idx);
}
}
return 1;
}
int GetGambleItemAvallableOn( int availableon )
{
if ( availableon & OPTION_AVAILABLE_ON_DAGGER )
return GambleItem_t.OPTION_AVAILABLE_ON_DAGGER ;
if ( availableon & OPTION_AVAILABLE_ON_1HSWORD )
return GambleItem_t.OPTION_AVAILABLE_ON_1HSWORD ;
if ( availableon & OPTION_AVAILABLE_ON_2HSWORD )
return GambleItem_t.OPTION_AVAILABLE_ON_2HSWORD;
if ( availableon & OPTION_AVAILABLE_ON_BOW )
return GambleItem_t.OPTION_AVAILABLE_ON_BOW;
if ( availableon & OPTION_AVAILABLE_ON_STAFF )
return GambleItem_t.OPTION_AVAILABLE_ON_STAFF;
if ( availableon & OPTION_AVAILABLE_ON_SPIRITOR )
return GambleItem_t.OPTION_AVAILABLE_ON_SPIRITOR;
if ( availableon & OPTION_AVAILABLE_ON_CLAW )
return GambleItem_t.OPTION_AVAILABLE_ON_CLAW;
if ( availableon & OPTION_AVAILABLE_ON_UPPER )
return GambleItem_t.OPTION_AVAILABLE_ON_UPPER;
if ( availableon & OPTION_AVAILABLE_ON_LOWER )
return GambleItem_t.OPTION_AVAILABLE_ON_LOWER;
if ( availableon & OPTION_AVAILABLE_ON_AIRPROTECTOR )
return GambleItem_t.OPTION_AVAILABLE_ON_AIRPROTECTOR;
if ( availableon & OPTION_AVAILABLE_ON_BODYPROTECTOR )
return GambleItem_t.OPTION_AVAILABLE_ON_BODYPROTECTOR;
if ( availableon & OPTION_AVAILABLE_ON_GLOVES )
return GambleItem_t.OPTION_AVAILABLE_ON_GLOVES;
if ( availableon & OPTION_AVAILABLE_ON_BOOTS )
return GambleItem_t.OPTION_AVAILABLE_ON_BOOTS;
if ( availableon & OPTION_AVAILABLE_ON_RING )
return GambleItem_t.OPTION_AVAILABLE_ON_RING;
if ( availableon & OPTION_AVAILABLE_ON_NECKLACE )
return GambleItem_t.OPTION_AVAILABLE_ON_NECKLACE;
if ( availableon & OPTION_AVAILABLE_ON_BRACELET )
return GambleItem_t.OPTION_AVAILABLE_ON_BRACELET;
if ( availableon & OPTION_AVAILABLE_ON_EARRING )
return GambleItem_t.OPTION_AVAILABLE_ON_EARRING;
if ( availableon & OPTION_AVAILABLE_ON_EPACK )
return GambleItem_t.OPTION_AVAILABLE_ON_EPACK;
return -1;
}
void SelectGambleItem(storeStruct_t* Makestore, storeStruct_t* Gamblestore, int pcIdx )
{
if ( pcIdx < 0)
return;
memcpy( Makestore, Gamblestore, sizeof(storeStruct_t) );
memset(g_pc[pcIdx].RegGambleItems, -1, sizeof(int) * MAX_NUMBER_OF_STORE_ITEM);
memset(Makestore->item, 0, sizeof (storeItem_t ) * MAX_NUMBER_OF_STORE_ITEM);
Makestore->itemNumber = 0;
int curmakepos = 0;
std::vector<int> vpageItems[3];
std::vector<int> vpageItemsRegCount[3];
int WilldbiRegCountofPage[3];
memset(WilldbiRegCountofPage, 0, sizeof (int) * 3);
int SelectdCount = 0;
int CopyItemCount;
for (int i = 0; i < MAX_NUMBER_OF_STORE_ITEM; i ++)
{
if ( Gamblestore->item[i].maxNumber == 0 && Gamblestore->item[i].maxNumber == 0)
continue;
vpageItems[Gamblestore->item[i].page].push_back(i);
float r = GTH_Random();
if ( r < 0.5 )
CopyItemCount = 2;
else
CopyItemCount = 3;
vpageItemsRegCount[Gamblestore->item[i].page].push_back(CopyItemCount);
WilldbiRegCountofPage[Gamblestore->item[i].page] += CopyItemCount;
SelectdCount++;
if ( SelectdCount >= Gamblestore->itemNumber)
break;
}
DWORD RegItemflag = 0;
int frontPageRegeditCount = 0;
int CurSrcGamblePos = 0;
for (int page = 0; page < 3; page ++)
{
int itemcount = vpageItems[page].size();
int regCountOfPage = 0;
for (int i =0; i < itemcount; i ++)
{
CurSrcGamblePos = frontPageRegeditCount + i;
for ( int Idx = 0; Idx < vpageItemsRegCount[page][i]; Idx++)
{
init_genrand( (unsigned) time( NULL ) );
int CurDestPos = (Makestore->itemNumber - regCountOfPage) + (rand() % WilldbiRegCountofPage[page]);
if ( CurDestPos < 0 || CurDestPos >= MAX_NUMBER_OF_STORE_ITEM )
CurDestPos = 0;
if ( Makestore->item[CurDestPos].curNumber != 0 && Makestore->item[CurDestPos].maxNumber != 0)
{
for (CurDestPos = 0; CurDestPos <MAX_NUMBER_OF_STORE_ITEM; CurDestPos++ )
{
if ( Makestore->item[CurDestPos].curNumber != 0 && Makestore->item[CurDestPos].maxNumber != 0)
{
continue;
}
break;
}
}
Makestore->item[CurDestPos].curNumber = Gamblestore->item[CurSrcGamblePos].curNumber;
Makestore->item[CurDestPos].maxNumber = Gamblestore->item[CurSrcGamblePos].maxNumber;
Makestore->item[CurDestPos].page = Gamblestore->item[CurSrcGamblePos].page;
memcpy ( &Makestore->item[CurDestPos].item, &Gamblestore->item[CurSrcGamblePos].item, sizeof (item_t ));
int Selecteditemidx = SelectCollectedItem(&Makestore->item[CurDestPos]);
float AddPrice = (rand() %( (int)g_logic.GamblePriceRate ) )* 0.01;
int CalPrice = 0;
if ( Makestore->item[CurDestPos].item.itemTableIdx == 97)
{
g_pc[pcIdx].RegGamblePrice[CurDestPos] = g_itemTable[97].gambleCost;
Makestore->item[CurDestPos].price = g_itemTable[97].gambleCost;
}
else
{
if ( GTH_Random() > 0.5 )
CalPrice = g_itemTable[Selecteditemidx].gambleCost + (g_itemTable[Selecteditemidx].gambleCost) * AddPrice;
else
CalPrice = g_itemTable[Selecteditemidx].gambleCost - (g_itemTable[Selecteditemidx].gambleCost) * AddPrice;
g_pc[pcIdx].RegGamblePrice[CurDestPos] = CalPrice;
Makestore->item[CurDestPos].price = CalPrice;
}
g_pc[pcIdx].RegGambleItems[CurDestPos] = Selecteditemidx;
Makestore->itemNumber++;
regCountOfPage++;
}
}
frontPageRegeditCount += itemcount;
}
}
int SelectCollectedItem(storeItem_t* pItem)
{
int StorItemIdx = pItem->item.itemTableIdx;
int availableOn = GetItemAvailalbeOn( g_itemTable[StorItemIdx].idx );
int type = GetGambleItemAvallableOn(availableOn);
if ( type < 0 || type > MAX_COUNT_OPTION_AVAILABLE_TYPE)
{
init_genrand( (unsigned) time( NULL ) );
int SelecttypeNum = (rand() % g_GambleItemTalbleNumber+1);
int CurSelectTypeNum = 0;
for (int i = 0; i < MAX_COUNT_OPTION_AVAILABLE_TYPE; i ++)
{
if ( g_GambleItem[i].vItem.size() )
CurSelectTypeNum++;
if ( SelecttypeNum <= CurSelectTypeNum)
{
type = i;
break;
}
}
if ( !g_GambleItem[type].vItem.size() )
type = 1;
}
float r = 0.0f;
float accPro = 0.0f;
init_genrand( (unsigned) time( NULL ) );
r = GTH_Random();
float TotalRate = g_GambleItem[type].TotalGamebleRate;
int selectGambleItemidx = -1;
int selectRanNum = rand() % g_GambleItem[type].vItem.size();
for (int i =0; i < g_GambleItem[type].vItem.size(); i ++, selectRanNum++)
{
if ( selectRanNum >= g_GambleItem[type].vItem.size())
selectRanNum = 0;
accPro += g_GambleItem[type].vGambleRate[selectRanNum] / TotalRate;
if ( r < accPro )
break;
TotalRate -= g_GambleItem[type].vGambleRate[selectRanNum];
}
if ( selectRanNum < 0 )
selectRanNum = 0 ;
if ( selectRanNum > MAX_NUMBER_OF_ITEM_TABLE)
{
if ( g_GambleItem[type].vItem.size() > 0)
selectRanNum = g_GambleItem[type].vItem.size() -1;
}
return g_GambleItem[type].vItem[selectRanNum];
}
int GTH_MakePortal_fordan( int LootType, int makerIdx, int keepTime, int worldIdx, vec3_t position, int targetWorldIdx, vec3_t targetPosition, int targetWorldIdx2, vec3_t targetPosition2)
{
int i;
itemObject_t *itemObject;
if ( g_objectNumber >= MAX_OBJECTS ) return -1;
itemObject = &g_object[0];
for (i=0; i < MAX_OBJECTS; i++, itemObject++)
{
if ( !itemObject->active ) break;
}
if ( i >= MAX_OBJECTS ) return -1;
itemObject->idx = i;
itemObject->active = true;
itemObject->objectType = OBJECT_TYPE_PORTAL;
itemObject->worldIdx = worldIdx;
vec_copy(position, itemObject->position);
itemObject->portal.portalType = 0;
itemObject->portal.worldIdx[0] = targetWorldIdx;
itemObject->portal.worldIdx[1] = targetWorldIdx2;
itemObject->portal.numPerson = 1;
if ( targetPosition != NULL)
vec_copy( targetPosition, itemObject->portal.position[0] );
if ( targetPosition2 != NULL)
vec_copy( targetPosition2, itemObject->portal.position[1] );
itemObject->entityType = ENTITY_OBJECT;
vec_set(itemObject->angles, 0, 0, 0);
itemObject->zoneIdx = GTH_Zone_GetZoneIdx(itemObject->position);
if ( !GTH_Zone_AddEntityList(itemObject->worldIdx, itemObject->zoneIdx, ENTITY_OBJECT, itemObject->idx) )
{
return -1;
}
itemObject->lootPCIdx = makerIdx;
itemObject->lootTime = keepTime;
itemObject->destroyTime = g_globalTime + keepTime;
if ( LootType == LOOTTYPE_DANBATTLE_TEAMS )
itemObject->lootType = LOOTTYPE_DANBATTLE_TEAMS;
else if ( LootType == ENTITY_NPC )
{
itemObject->lootPCIdx = -1;
itemObject->lootType = LOOTTYPE_EVERYONE;
}
else if ( LootType = LOOTTYPE_DAN )
{
{
itemObject->lootType = LOOTTYPE_DAN;
strcpy(itemObject->DanName, g_pc[makerIdx].guildName);
}
}
g_objectNumber++;
GTH_SendMessage_AddItemObject( itemObject );
return( 1 );
}
BOOL IsValidHotKey_Skill(const playerCharacter_t *pc, const int HotkeyIdx)
{
if ( (HotkeyIdx >= MAX_NUMBER_OF_HOTKEY) || (HotkeyIdx < 0) )
return FALSE;
int type =pc->hotkeyType[HotkeyIdx];
int learnIdx =pc->hotkeyIdx[HotkeyIdx];
if(0 != type) return TRUE;
if( FALSE == SAFE_SKILL_INDEX(learnIdx) )
return FALSE;
const skill_t* pSkill = gcpTools->GetMySkillTpointer((playerCharacter_t*)pc,learnIdx);
if( NULL == pSkill )
return FALSE;
CSkilTable *pSkillTable = g_SkillTableDB.FindDB(pSkill->tableIdx);
if( NULL == pSkillTable )
{
TRACE("Error! pSkillTable==NULL \n");
return FALSE;
}
if ((0 > learnIdx) ||
(learnIdx >= pc->skillNumber) ||
(pSkill->tableIdx < 0) ||
(pSkill->tableIdx >= MAX_NUMBER_OF_SKILL) ||
(pSkillTable->m_nUsageType == 1)){
return FALSE;
}
return TRUE;
}
void GTH_PartyRandomItemDivide( playerCharacter_t *pc,itemObject_t *itemObject )
{
serverPartyInfo_t *pi=NULL;
playerCharacter_t *member=NULL;
playerCharacter_t *selectUser=NULL;
int i=0,idx=-1,itemIdx;
int reply, error;
int inventoryPos;
int stackItemIdx;
item_t* upItem;
item_t *item;
int bIsStack = false;
int stackNumber = 1;
char generateID[20];
idx = GTH_GetPartyInfo( pc->organizerName, pc->organizeServer,pc->organizeTime );
pi = &g_partyInfo[idx];
if(pi==NULL) return;
int irandValue = GTH_RandomizePower(0,pi->memberNumber);
for( i = 0; i < MAX_NUMBER_OF_PARTY_MEMBER; i ++ )
{
int memberIdx = pi->member[i].idxOnServer;
if( pi->member[i].serverIndex < 0 ) continue;
if(pi->member[i].serverIndex != g_config.gameServerNo ) continue;
member = &g_pc[memberIdx];
if(member==NULL) return;
if( !member->active || !member->alive ) continue;
if(irandValue>=i) break;
}
item = &itemObject->item;
if( g_itemTable[item->itemTableIdx].stackFlag )
{
bIsStack = true;
stackNumber = item->durability + 1;
}
if( member->curItemWeight > member->calItemWeight )
{
reply = 0;
error = ERROR_PICKUPITEM_7;
goto REPLY_PICKUPITEM;
}
stackItemIdx = GTH_StackMyItem( member, item );
if( stackItemIdx >= 0 )
{
upItem = &member->item[stackItemIdx];
upItem->durability += item->durability + 1;
if( upItem->durability + 1 >= MAX_COUNT_STACK_ITEM ) upItem->durability = MAX_COUNT_STACK_ITEM - 1;
g_DBGameServer->SaveItem( member, upItem, stackItemIdx );
g_logSystem->WriteToLog( member, LOG_CLASS_ITEM, "%d;%d;;;;%s;%s",
LOG_CLASS_ITEM_PICKUP, stackNumber, item->name,
GetItemInformationLog( bIsStack, item->itemTableIdx, stackItemIdx, -1 ) );
}
else
{
inventoryPos = GTH_FindEmptyInventoryPos( member );
if( inventoryPos < 0 )
{
reply = 0;
error = ERROR_PICKUPITEM_4;
g_logSystem->Write("Pick Up Error!! : Inventory Space Not Enough. %s(%s), objectIdx:%d)", member->name, member->userID, itemObject->idx);
goto REPLY_PICKUPITEM;
}
itemIdx = GTH_AddMyItem( member, item );
if (itemIdx < 0)
{
reply = 0;
error = ERROR_PICKUPITEM_5;
goto REPLY_PICKUPITEM;
}
member->inventory[inventoryPos] = itemIdx;
strcpy(generateID, "pickUpGenID");
if ( !g_DBGameServer->AddItem(member, item, itemIdx, generateID) )
{
g_logSystem->Write("Can Not Insert in DataBase(Item Table).(%s, %d, %d)", member->userID, member->serverGroupID, member->characterID);
reply = 0;
error = ERROR_PICKUPITEM_6;
goto REPLY_PICKUPITEM;
}
g_logSystem->WriteToLog( member, LOG_CLASS_ITEM, "%d;%d;;;;%s;%s",
LOG_CLASS_ITEM_PICKUP, stackNumber, item->name,
GetItemInformationLog( bIsStack, item->itemTableIdx, itemIdx, inventoryPos ) );
}
g_logSystem->Write("User '%s'(ID: %s) Obtain Item '%s'", member->name, member->userID, g_itemTable[item->itemTableIdx].name);
GTH_RemoveItemObject( itemObject );
reply = 1;
error = ERROR_PICKUPITEM_NONE;
member->curItemWeight += g_itemTable[item->itemTableIdx].weight;
REPLY_PICKUPITEM:
GTH_SendMessage_ReplyPickUpItem( member, reply, error, item );
}
void GTH_PartyOrderItemDivide( playerCharacter_t *pc,itemObject_t *itemObject )
{
serverPartyInfo_t *pi=NULL;
playerCharacter_t *member=NULL;
playerCharacter_t *selectUser=NULL;
int i=0,idx=-1,itemIdx;
int reply, error;
int inventoryPos;
int stackItemIdx;
item_t* upItem;
item_t *item;
int bIsStack = false;
int stackNumber = 1;
char generateID[20];
idx = GTH_GetPartyInfo( pc->organizerName, pc->organizeServer,pc->organizeTime );
if(idx < 0) return;
if(idx >= MAX_PCS) return;
pi = &g_partyInfo[idx];
if(pi==NULL) return;
for( i = 0; i < MAX_NUMBER_OF_PARTY_MEMBER; i++)
{
int memberIdx = pi->member[i].idxOnServer;
if(memberIdx < 0) return;
if(memberIdx >= MAX_PCS) return;
if( pi->member[i].serverIndex < 0 ) continue;
if(pi->member[i].serverIndex != g_config.gameServerNo ) continue;
selectUser = &g_pc[memberIdx];
if(!selectUser->active || !selectUser->alive) continue;
}
item = &itemObject->item;
if( g_itemTable[item->itemTableIdx].stackFlag )
{
bIsStack = true;
stackNumber = item->durability + 1;
}
if( member->curItemWeight > member->calItemWeight )
{
reply = 0;
error = ERROR_PICKUPITEM_7;
goto REPLY_PICKUPITEM;
}
stackItemIdx = GTH_StackMyItem( member, item );
if( stackItemIdx >= 0 )
{
upItem = &member->item[stackItemIdx];
upItem->durability += item->durability + 1;
if( upItem->durability + 1 >= MAX_COUNT_STACK_ITEM ) upItem->durability = MAX_COUNT_STACK_ITEM - 1;
g_DBGameServer->SaveItem( member, upItem, stackItemIdx );
g_logSystem->WriteToLog( member, LOG_CLASS_ITEM, "%d;%d;;;;%s;%s",
LOG_CLASS_ITEM_PICKUP, stackNumber, item->name,
GetItemInformationLog( bIsStack, item->itemTableIdx, stackItemIdx, -1 ) );
}
else
{
inventoryPos = GTH_FindEmptyInventoryPos( member );
if( inventoryPos < 0 )
{
reply = 0;
error = ERROR_PICKUPITEM_4;
g_logSystem->Write("Pick Up Error!! : Inventory Space Not Enough. %s(%s), objectIdx:%d)", member->name, member->userID, itemObject->idx);
goto REPLY_PICKUPITEM;
}
itemIdx = GTH_AddMyItem( member, item );
if (itemIdx < 0)
{
reply = 0;
error = ERROR_PICKUPITEM_5;
goto REPLY_PICKUPITEM;
}
member->inventory[inventoryPos] = itemIdx;
strcpy(generateID, "pickUpGenID");
if ( !g_DBGameServer->AddItem(member, item, itemIdx, generateID) )
{
g_logSystem->Write("Can Not Insert in DataBase(Item Table).(%s, %d, %d)", member->userID, member->serverGroupID, member->characterID);
reply = 0;
error = ERROR_PICKUPITEM_6;
goto REPLY_PICKUPITEM;
}
g_logSystem->WriteToLog( member, LOG_CLASS_ITEM, "%d;%d;;;;%s;%s",
LOG_CLASS_ITEM_PICKUP, stackNumber, item->name,
GetItemInformationLog( bIsStack, item->itemTableIdx, itemIdx, inventoryPos ) );
}
g_logSystem->Write("User '%s'(ID: %s) Obtain Item '%s'", member->name, member->userID, g_itemTable[item->itemTableIdx].name);
GTH_RemoveItemObject( itemObject );
reply = 1;
error = ERROR_PICKUPITEM_NONE;
member->curItemWeight += g_itemTable[item->itemTableIdx].weight;
REPLY_PICKUPITEM:
GTH_SendMessage_ReplyPickUpItem( member, reply, error, item );
}
void GTH_SharingPartyLoot(
monsterCharacter_t *m,
playerCharacter_t *pc,
int exp,
int genExp,
int lootNSE,
int genCapability,
int atkConIdx,
int defConIdx )
{
if(TRUE == IsBadReadPtr(pc,sizeof(playerCharacter_t*)))
{
g_logSystem->Write("GTH_SharingPartyLoot pc");
return;
}
if(TRUE == IsBadReadPtr(m,sizeof(monsterCharacter_t*)))
{
g_logSystem->Write("GTH_SharingPartyLoot monster");
return;
}
playerCharacter_t *member=NULL, *partymember=NULL;
int memberNumber = 0, memberIdx, pcMemberIdx[MAX_NUMBER_OF_PARTY_MEMBER], levelDiffer;
float incRate;
int maxLv = 0, partyExp, partyGenExp, partyGenCapability, invPartyExp, invPartyGenExp, invPartyNSE, invPartyGenCapability;
int sharingType = 0;
for( int i = 0; i < MAX_NUMBER_OF_PARTY_MEMBER; i ++ )
{
memberIdx = pc->member[i].idxOnServer;
if( pc->member[i].serverIndex < 0 ) continue;
if( pc->member[i].level > maxLv ) maxLv = pc->member[i].level;
if( pc->member[i].serverIndex != g_config.gameServerNo ) continue;
member = gcpTools->GetPlayerRecordPointer(memberIdx);
if(NULL == member) continue;
if(!member->alive) continue;
if(0 !=stricmp( member->name, pc->member[i].memberName ) ) continue;
if( !GTH_IsSharingParty( m, member ) ) continue;
pcMemberIdx[memberNumber] = memberIdx;
memberNumber ++;
}
if( memberNumber <= 0 ) return;
if( memberNumber == 1 )
{
GTH_GetExpFromLevelDiffer( g_pc[pcMemberIdx[0]].level - m->basic.level, exp, genExp, genCapability );
GTH_PC_GetLoot( pcMemberIdx[0], exp, genExp, lootNSE, genCapability, 0 );
return;
}
switch( memberNumber )
{
case 1 :
incRate = 0.0f;
break;
case 2 :
incRate = 0.3f;
break;
case 3 :
incRate = 0.6f;
break;
case 4 :
incRate = 0.9f;
break;
case 5 :
incRate = 1.25f;
break;
case 6 :
incRate = 1.60f;
break;
case 7 :
incRate = 1.95f;
break;
case 8 :
incRate = 2.40f;
break;
}
partyExp = (int)( (float)exp * incRate ) + exp;
partyGenExp = (int)( (float)genExp * incRate ) + genExp;
partyGenCapability = (int)( (float)genCapability * incRate ) + genCapability;
if( atkConIdx == defConIdx ) defConIdx = -1;
for( i = 0; i < memberNumber; i ++ )
{
partymember=gcpTools->GetPlayerRecordPointer(pcMemberIdx[i]);
if(NULL==partymember) continue;
levelDiffer = abs( partymember->level - maxLv );
if( levelDiffer >= 16 ) continue;
invPartyExp = (int)( (float)partyExp / (float)memberNumber );
invPartyGenExp = (int)( (float)partyGenExp / (float)memberNumber );
invPartyNSE = (int)( (float)lootNSE / (float)memberNumber );
invPartyGenCapability = (int)( (float)partyGenCapability / (float)memberNumber );
sharingType = 1;
if( atkConIdx >= 0 )
{
if( partymember->idx == m->conInfo[atkConIdx].entityIdx )
{
invPartyExp = (int)( (float)invPartyExp * 0.2f ) + invPartyExp;
invPartyGenExp = (int)( (float)invPartyGenExp * 0.2f ) + invPartyGenExp;
invPartyGenCapability = (int)( (float)invPartyGenCapability * 0.2f ) + invPartyGenCapability;
sharingType = 2;
}
}
if( defConIdx >= 0 )
{
if( partymember->idx == m->conInfo[defConIdx].entityIdx )
{
invPartyExp = (int)( (float)invPartyExp * 0.1f ) + invPartyExp;
invPartyGenExp = (int)( (float)invPartyGenExp * 0.1f ) + invPartyGenExp;
invPartyGenCapability = (int)( (float)invPartyGenCapability * 0.1f ) + invPartyGenCapability;
sharingType = 3;
}
}
if( levelDiffer >= 8 )
{
incRate = 1.0f - 0.03f * (float)( levelDiffer - 7 );
}
else
{
incRate = 1.0f;
}
invPartyExp = (int)( (float)invPartyExp * incRate );
invPartyGenExp = (int)( (float)invPartyGenExp * incRate );
invPartyGenCapability = (int)( (float)invPartyGenCapability * incRate );
GTH_GetExpFromLevelDiffer( partymember->level - m->basic.level, invPartyExp, invPartyGenExp, invPartyGenCapability );
GTH_PC_GetLoot( partymember->idx, invPartyExp, invPartyGenExp, invPartyNSE, invPartyGenCapability, sharingType );
}
}
BOOL GTH_IsHaveItem(playerCharacter_t* pPc, int itemTableIdx, int StackCount)
{
if ( pPc == NULL )
return FALSE;
if ( itemTableIdx < 0 || itemTableIdx >= MAX_NUMBER_OF_ITEM_TABLE)
return FALSE;
for (int InvenIdx = 0; InvenIdx < MAX_INVENTORY_SIZE; InvenIdx ++)
{
item_t* pItem = NULL;
int ItemIdx = pPc->inventory[InvenIdx];
if ( ItemIdx < 0 || ItemIdx >= MAX_NUMBER_OF_OWNITEM )
continue;
if (pPc->item[ItemIdx].itemTableIdx == itemTableIdx)
{
if ( pPc->item[ItemIdx].durability + 1 >= StackCount )
return TRUE;
else
return FALSE;
}
}
return FALSE;
}
BOOL GTH_IsAwakenJob(playerCharacter_t* pPc)
{
if ( pPc == NULL )
return FALSE;
if ( pPc->pcJob <= J_EARTH )
return FALSE;
return TRUE;
}
BOOL GTH_ClearAwakenJob(playerCharacter_t *pPC, std::vector<int>* pVSkill)
{
if ( pPC == NULL )
return FALSE;
int GenType = GTH_GetGenTypeFromJob(g_curPC->pcJob);
int force = 0;
int SoulPower = 0;
int Agility = 0;
int Vitality = 0;
switch( g_curPC->pcJob )
{
case J_DEVOTIONAL_KNIGHT :
force += 0;
SoulPower += 0;
Agility += 5;
Vitality += 0;
break;
case J_ROMING_KNIGHT :
force += 0;
SoulPower += 0;
Agility += 0;
Vitality += 5;
break;
case J_PIECING_EYES :
force += 0;
SoulPower += 5;
Agility += 0;
Vitality += 0;
break;
case J_WINDY_ROMER :
force += 0;
SoulPower += 0;
Agility += 0;
Vitality += 5;
break;
case J_DESTROYER :
force += 0;
SoulPower += 0;
Agility += 5;
Vitality += 0;
break;
case J_GUARDIAN :
force += 0;
SoulPower += 0;
Agility += 0;
Vitality += 5;
break;
case J_PROPHECIER :
force += 0;
SoulPower += 0;
Agility += 0;
Vitality += 0;
break;
case J_TRANSFORMER :
force += 0;
SoulPower += 0;
Agility += 5;
Vitality += 0;
break;
case J_DEFENDER :
force += 0;
SoulPower += 0;
Agility += 0;
Vitality += 5;
break;
case J_STRANGER :
force += 0;
SoulPower += 0;
Agility += 0;
Vitality += 0;
break;
}
g_curPC->force -= force;
g_curPC->soulpower -= SoulPower;
g_curPC->agility -= Agility;
g_curPC->vitality -= Vitality;
if ( g_curPC->force < 0)
g_curPC->force = 0;
if ( g_curPC->soulpower < 0)
g_curPC->soulpower = 0;
if ( g_curPC->agility < 0)
g_curPC->agility = 0;
if ( g_curPC->vitality < 0)
g_curPC->vitality = 0;
for (int GenIdx = 0; GenIdx < GEN_NUMBER; GenIdx++)
{
if ( GenType != GenIdx)
g_curPC->genCapability[GenIdx] = -1;
}
int QuestIdx = GetAwakenQuestIdx(GenType);
if ( QuestIdx >= 0 || QuestIdx< MAX_COUNT_QUEST_VARIABLE)
{
g_curPC->questVar[QuestIdx].iVar = 65280;
GTH_ClearQuestStatus( g_curPC, QuestIdx, 0 );
}
for (int SkillIdx =0; SkillIdx < MAX_NUMBER_OF_SKILL; SkillIdx++ )
{
skill_t* pSkill = &g_curPC->skill[SkillIdx];
CSkilTable *pSkillTable = g_SkillTableDB.FindDB(pSkill->tableIdx);
if ( pSkillTable == NULL)
continue;
if( g_curPC->pcJob == pSkillTable->m_nJobType )
{
DeleteSkill(g_curPC, SkillIdx);
pVSkill->push_back(SkillIdx);
for (int HotKeyIdx = 0; HotKeyIdx < MAX_NUMBER_OF_HOTKEY; HotKeyIdx++)
{
if ( g_curPC->hotkeyType[HotKeyIdx] == 0 &&
g_curPC->hotkeyIdx[HotKeyIdx] == SkillIdx)
{
g_curPC->hotkeyIdx[HotKeyIdx] = -1;
g_curPC->hotkeyType[HotKeyIdx] = -1;
}
}
}
}
g_curPC->pcJob = GenType;
g_curPC->selectedGen = GenType;
GTH_PC_Calculate( g_curPC );
return TRUE;
}
int GetAwakenQuestIdx(int pcJob)
{
if( pcJob == J_MENTALITY || pcJob == J_DEVOTIONAL_KNIGHT ||
pcJob == J_ROMING_KNIGHT )
return( KNIGHT_QUEST_IDX );
if( pcJob == J_WIND || pcJob == J_PIECING_EYES ||
pcJob == J_WINDY_ROMER )
return( WIND_QUEST_IDX );
if( pcJob == J_WATER || pcJob == J_DESTROYER ||
pcJob == J_GUARDIAN || pcJob == J_PROPHECIER )
return( WATER_QUEST_IDX );
if( pcJob == J_EARTH || pcJob == J_TRANSFORMER ||
pcJob == J_DEFENDER || pcJob == J_STRANGER )
return( EARTH_QUEST_IDX );
return( -1 );
}
void DeleteSkill(playerCharacter_t* pPc, int SkillIdx)
{
if ( SkillIdx <0 || SkillIdx >= MAX_NUMBER_OF_SKILL )
return;
skill_t* pSkill = &pPc->skill[SkillIdx];
pSkill->tableIdx = -1;
pSkill->iLevel = 0;
pPc->skillCooltime[SkillIdx] = 0.0f;
pPc->skillNumber --;
}
BOOL GTH_IsEquipItem(playerCharacter_t* pPc)
{
if ( pPc == NULL )
return FALSE;
for( int equipItemCount = 0; equipItemCount < MAX_EQUIPMENT; equipItemCount ++ )
{
int equipmentIdx = pPc->equipment[equipItemCount];
if ( equipItemCount == EQUIP_EPACK)
continue;
if ( equipmentIdx >= 0)
return TRUE;
}
return FALSE;
}
int LoadMax_Defense_table( char* filename )
{
int size;
byte *buffer;
char* token;
int level;
int expLevel=0;
FILE *fp;
fp = fopen( filename, "rb" );
fseek(fp,0,SEEK_END);
size = ftell(fp);
buffer = new byte[size+1];
fseek(fp,0,SEEK_SET);
fread(buffer,size,1,fp);
fclose(fp);
SetTokenBuffer( buffer, size );
for( int i = 0; i < MAX_NUMBER_OF_LEVEL; i ++ )
memset( &g_MaxDefneseTable[i], 0, sizeof( MaxDefense_t ) );
while( 1 )
{
token = NextToken();
if( token == NULL ) break;
level = atoi( token );
g_MaxDefneseTable[expLevel].Attacklevel = atoi( token );
token = NextToken();
g_MaxDefneseTable[expLevel].MaxDefense = atoi( token );
expLevel++;
if ( expLevel >= MAX_NUMBER_OF_LEVEL )
break;
}
if(buffer!=NULL)
{
delete [] buffer;
}
return( 1 );
}
#include "../GM(Game Master)\CGMCtrl.h"
extern CGMCtrl* gcpGMCtrl;
void PkTimeAutoProcess()
{
if ( g_config.isManager == false)
return;
if ( gcpGMCtrl == NULL)
return;
if ( gcpGMCtrl->m_cpPKTimeCtrl == NULL)
return;
if ( gcpGMCtrl->m_cpPKTimeCtrl->m_cpVirtualServerStateDataCtrl == NULL)
return;
struct tm* pNowTime = NULL;
time_t ltime;
time(<ime);
pNowTime = localtime(<ime);
if ( pNowTime == NULL)
return;
int DayNight = FALSE;
if ( pNowTime->tm_hour >= 12)
{
DayNight = TRUE;
pNowTime->tm_hour -= 12;
}
}
| C++ |
#include "../global.h"
extern i3socket_t gsSocket;
#include "../Tools/CTools.h"
extern CTools* gcpTools;
void GTH_PC_CalcItemWeightPoint(playerCharacter_t* in_pPlayer);
int lastSpawnPCIndex = -1;
int GTH_GetSpawnPCIndex()
{
int i;
int idx;
if( lastSpawnPCIndex < 0 )
{
lastSpawnPCIndex = 0;
}
else
{
lastSpawnPCIndex ++;
if( lastSpawnPCIndex >= MAX_PCS ) lastSpawnPCIndex = 0;
}
idx = lastSpawnPCIndex;
i = 0;
while( 1 )
{
if( i >= MAX_PCS ) break;
if( !g_pc[idx].active ) break;
idx ++;
if( idx >= MAX_PCS ) idx = 0;
i ++;
}
if( i >= MAX_PCS ) return -1;
lastSpawnPCIndex = idx;
return idx;
}
int GTH_SpawnPC(struct sockaddr_in *addr)
{
int i, j;
playerCharacter_t *pc;
i = GTH_GetSpawnPCIndex();
if( i < 0 )
{
g_logSystem->Write("Critical Error!! : PC over Max PC Number");
g_logSystem->Update();
return -1;
}
pc = &g_pc[i];
g_pcNumber++;
if ( g_pcNumber > g_maxPCNumber ) g_maxPCNumber = g_pcNumber;
NET_InitPacketMap( &pc->sock );
memset( pc, 0, sizeof( playerCharacter_t ) );
pc->idx = i;
pc->active = true;
pc->ready = false;
pc->alive = true;
pc->sendReplyConnect = false;
pc->flagDBLoading = false;
pc->normalNetwork = true;
memset( pc->userID, 0, sizeof( pc->userID ) );
pc->pcClass = 0;
pc->entityType = ENTITY_PC;
pc->rankPoint = 0;
vec_set(pc->position, 0, 0, 0);
vec_set(pc->angles, 0, 0, 0);
pc->event = GTH_EV_CHAR_IDLE;
pc->flagChangeServer = -1;
pc->changeServerWorldIdx = -1;
NET_InitSocket(&pc->sock, addr, gsSocket.socket, SocketType_Reliable);
pc->syncTime = g_globalTime + g_config.gameSyncTime;
pc->moveType = 0;
pc->worldIdx = 0;
pc->zoneIdx = 0;
vec_set( pc->reliablePosition, 0, 0, 0);
pc->reliableWorldIdx = -1;
pc->level = 1;
pc->exp = 0;
pc->nextExp = 0;
pc->increaseExpRate = 0;
pc->genLevel = 0;
pc->genExp = 0;
pc->nextGenExp = 0;
pc->increaseGenExpRate = 0;
for( j = 0; j < GEN_NUMBER; j ++ )
{
pc->genCapability[j] = 0;
}
pc->force = 0;
pc->soulpower = 0;
pc->agility = 0;
pc->vitality = 0;
pc->calForce = 0;
pc->calSoulpower = 0;
pc->calAgility = 0;
pc->calVitality = 0;
pc->bonusStatusPoint = 0;
pc->curRA = 0.0f;
pc->curSA = 0.0f;
pc->baseMaxRA = 0.0f;
pc->baseMaxSA = 0.0f;
pc->calMaxRA = 0.0f;
pc->calMaxSA = 0.0f;
pc->maxChargeRA = 0;
pc->maxChargeSA = 0;
pc->onceRecoveryRA = 0;
pc->onceRecoverySA = 0;
pc->curWeapon = 0;
pc->chaosPoint = 0;
pc->targetingType = TARGETING_NORMAL;
pc->targetType = -1;
pc->targetIdx = -1;
pc->basePhyMinDmg = 0;
pc->basePhyMaxDmg = 0;
pc->baseMagMinDmg = 0;
pc->baseMagMaxDmg = 0;
pc->baseHitPower = 0;
pc->baseAttackSpeed = 0;
pc->baseAttackLength = 0;
pc->baseAttackRange = 0;
pc->calPhyMinDmg = 0;
pc->calPhyMaxDmg = 0;
pc->calMagMinDmg = 0;
pc->calMagMaxDmg = 0;
pc->calHitPower = 0;
pc->calAttackDelay = 0;
pc->attackSpeedRate = 0;
pc->calHitRate = 0;
pc->baseDefensePower = 0;
pc->baseVelocity = 0.0f;
pc->baseStunTime = 0;
pc->baseAvoidPower = 0;
pc->calDefensePower = 0;
pc->calPositiveRes = 0;
pc->calNegativeRes = 0;
pc->calAvoidPower = 0;
pc->calVelocity = 0.0f;
pc->calStunTime = 0;
pc->bautoeffectisvalid=false;
GTH_DeleteAffectAll( pc, ENTITY_PC );
for( j = 0; j < MAX_NUMBER_OF_SKILL; j ++ )
{
pc->skill[j].idx = j;
pc->skill[j].tableIdx = -1;
pc->skill[j].iLevel = 0;
pc->skillCooltime[j] = 0.0f;
}
pc->skillCastingtime = 0.0f;
pc->skillCastingState = true;
pc->saveSkillIdx = -1;
for ( j = 0; j < MAX_NUMBER_OF_SKILL_VARIABLE; j ++ )
pc->skillVariable[j] = -1;
pc->skillNumber = 0;
pc->bonusSkillPoint = 0;
pc->itemNumber = 0;
for( j = 0; j < MAX_NUMBER_OF_OWNITEM; j ++ ) InitItem( &pc->item[j] );
for( j = 0; j < MAX_INVENTORY_SIZE; j ++ ) pc->inventory[j] = -1;
for( j = 0; j < MAX_DEPOT_SIZE; j ++ ) pc->depot[j] = -1;
for( j = 0; j < MAX_EQUIPMENT; j ++ ) pc->equipment[j] = -1;
pc->mouseInventory = -1;
for( j = 0; j < MAX_PRECOCITY_SIZE; j ++ )
{
pc->precocityInventory[j] = -1;
pc->precocityTime[j] = 0;
}
pc->curItemWeight = 0;
pc->baseItemWeight = 0;
pc->calItemWeight = 0;
for( i = 0; i < MAX_COUNT_QUEST_INVENTORY; i ++ )
{
pc->questInventory[i].iItem = 65535;
}
for( i = 0; i < MAX_COUNT_QUEST_STATUS; i ++ )
{
pc->questStatus[i].idx = i;
pc->questStatus[i].questIdx=-1;
pc->questStatus[i].limitTime=-1;
memset(pc->questStatus[i].partyOrganizerName,0,sizeof(char)*NAMESTRING);
pc->questStatus[i].partyOrganizeServer=-1;
pc->questStatus[i].partyOrganizeTime=-1;
memset(pc->questStatus[i].dField, -1, sizeof(int)*MAX_COUNT_QUEST_STATUS_DYNAMIC_FIELD );
}
for( i = 0; i < MAX_COUNT_QUEST_VARIABLE; i ++ )
pc->questVar[i].iVar = 65280;
GTH_InitTrade( pc );
memset( &pc->organizerName, 0, sizeof( pc->organizerName ) );
pc->organizeServer = -1;
pc->organizeTime = -1;
pc->partyIndex = -1;
pc->memberNumber = 0;
pc->canJoin = true;
pc->isLeader = false;
pc->partyExp = 0;
pc->partyGenExp = 0;
pc->isSharingParty = false;
pc->_partyRandomInfo_t.itemDivideType = 0;
pc->_partyRandomInfo_t.m_bischange =false;
for( i = 0; i < MAX_NUMBER_OF_PARTY_MEMBER; i ++ )
{
memset( &pc->member[i], 0, sizeof( partyMember_t ) );
pc->member[i].serverIndex = -1;
}
AI_InitMessage( pc );
pc->isTransform = false;
pc->isSetServerShutdown = false;
pc->gameMaster = 0;
pc->nextSaveTime = g_globalTime + PC_GAMEDATA_SAVETIME;
pc->npcIdx = -1;
pc->autoRecoveryRATime = 0;
pc->autoRecoverySATime = 0;
pc->gmBusy = 0;
pc->gmHide = 0;
GTH_DeleteNoticePC( pc );
pc->serverAckMsgNeedFlag = false;
pc->serverAckMsgPartyFlag = false;
pc->recoveryTime = 1000.0f;
pc->pvpMode = false;
pc->GonryunBattlePractice.MemberShip = playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_NONE;
pc->GonryunBattlePractice.bisWaitrespond = FALSE;
pc->forceAtkDelay = -1;
pc->GM.Chat.RemainBanTimePerSecond=0;
pc->m_CashMall_OptionStone.InitCashMallItem_OptionStone();
g_NewDanBattleSystem.InitDanBatlleInfo(&(pc->DanBattleInfo));
for (int ShareWinInventoryIdx =0; ShareWinInventoryIdx < \
playerCharacter_t::tagGonryunBattle::tagShareWin::MAX_INVENTORY_NUMBER;
ShareWinInventoryIdx++)
pc->GonryunBattle.ShareWin.Inventory[ShareWinInventoryIdx] = -1;
InitItemCraftSystem(pc);
InitItemUpgradeSystem(pc);
InitBoothSystem(pc);
InitPrecocitySystem(pc);
pc->fWorldChangeStartTime = 0.0f;
pc->iChangeWorldIdx = -1;
return( pc->idx );
}
int GTH_RemovePC(playerCharacter_t *pc)
{
if ( !pc->active ) return false;
GTH_Zone_DeleteEntityList(pc->worldIdx, pc->zoneIdx, ENTITY_PC, pc->idx);
pc->active = false;
pc->ready = false;
pc->alive = false;
memset( &pc->organizerName, 0, sizeof( pc->organizerName ) );
pc->organizeServer = -1;
pc->organizeTime = -1;
g_pcNumber --;
return true;
}
void GTH_ApplyOption( playerCharacter_t *pc )
{
pc->calCriticalDmg += (int)(pc->optValue[OV_CRITICAL_DMG]);
pc->calCriticalRate += pc->optValue[OV_CRITICAL_PRO] * 0.01f;
pc->calPositiveRes += (int)pc->optValue[OV_POSRES];
pc->calNegativeRes += (int)pc->optValue[OV_NEGRES];
pc->calPhyMinDmg += (int)( (float)pc->basePhyMinDmg * pc->optValue[OV_MIN_PHYDMG_RATE] * 0.01f );
pc->calPhyMaxDmg += (int)( (float)pc->basePhyMaxDmg * pc->optValue[OV_MAX_PHYDMG_RATE] * 0.01f );
pc->calMagMinDmg += (int)( (float)pc->baseMagMinDmg * pc->optValue[OV_MIN_MAGDMG_RATE] * 0.01f );
pc->calMagMaxDmg += (int)( (float)pc->baseMagMaxDmg * pc->optValue[OV_MAX_MAGDMG_RATE] * 0.01f );
pc->calPhyMinDmg += (int)( (float)pc->basePhyMinDmg * pc->optValue[OV_PHYDMG_RATE] * 0.01f );
pc->calPhyMaxDmg += (int)( (float)pc->basePhyMaxDmg * pc->optValue[OV_PHYDMG_RATE] * 0.01f );
pc->calMagMinDmg += (int)( (float)pc->baseMagMinDmg * pc->optValue[OV_MAGDMG_RATE] * 0.01f );
pc->calMagMaxDmg += (int)( (float)pc->baseMagMaxDmg * pc->optValue[OV_MAGDMG_RATE] * 0.01f );
pc->calMaxRA += pc->optValue[OV_MAX_RA];
pc->calMaxSA += pc->optValue[OV_MAX_SA];
pc->calDefensePower += (int)pc->optValue[OV_DEFPOWER];
pc->calPhyMinDmg += (int)pc->optValue[OV_MIN_PHYDMG] + (int)pc->optValue[OV_PHYDMG];
pc->calPhyMaxDmg += (int)pc->optValue[OV_MAX_PHYDMG] + (int)pc->optValue[OV_PHYDMG];
pc->calMagMinDmg += (int)pc->optValue[OV_MIN_MAGDMG] + (int)pc->optValue[OV_MAGDMG];
pc->calMagMaxDmg += (int)pc->optValue[OV_MAX_MAGDMG] + (int)pc->optValue[OV_MAGDMG];
}
enum
{
DivideValue_MaxSA,
DivideValue_PhyDamage_Except_Wind,
DivideValue_PhyDamage_Wind_By_Bow,
DivideValue_PhyDamage_Wind_By_Dagger,
DivideValue_MagDamage,
DivideValue_HitPower,
DivideValue_AvoidPower,
};
int PC_INITIAL_STATUS[8][4] =
{
{ 37, 11, 30, 22 },
{ 22, 19, 44, 15 },
{ 20, 44+1, 24, 11 },
{ 33, 12, 24, 31 },
{ 0, 0, 0, 0 },
{ 0, 0, 0, 0 },
{ 0, 0, 0, 0 },
{ 0, 0, 0, 0 },
};
#define LimitStatusLevel_BeforeAwaken 29
#define LimitStatusLevel_FirstAwaken 69
#define LimitStatusLevel_LastAwaken 99
int PC_LIMIT_STATUS_BEFORE_AWAKEN[8][4] =
{
{ 80, 44, 70, 62 },
{ 55, 59, 87, 55 },
{ 53, 87+1, 64, 52 },
{ 75, 45, 59, 73 },
{ 0, 0, 0, 0 },
{ 0, 0, 0, 0 },
{ 0, 0, 0, 0 },
{ 0, 0, 0, 0 },
};
int PC_LIMIT_STATUS_FIRST_AWAKEN[8][4] =
{
{ 140, 96, 131, 124 },
{ 107, 121, 147, 116 },
{ 105, 147+1, 125, 114 },
{ 133, 97, 127, 137 },
{ 0, 0, 0, 0 },
{ 0, 0, 0, 0 },
{ 0, 0, 0, 0 },
{ 0, 0, 0, 0 },
};
int PC_LIMIT_STATUS_LAST_AWAKEN[8][4] =
{
{ 216, 131, 174, 167 },
{ 142, 164, 223, 159 },
{ 140, 223+1, 168, 157 },
{ 212, 132, 169, 181 },
{ 0, 0, 0, 0 },
{ 0, 0, 0, 0 },
{ 0, 0, 0, 0 },
{ 0, 0, 0, 0 },
};
int CheckLimitStatus( int level, int pcJob, int status, int statusType )
{
int *limitStatus;
if( level <= LimitStatusLevel_BeforeAwaken ) limitStatus = PC_LIMIT_STATUS_BEFORE_AWAKEN[pcJob];
else if( level <= LimitStatusLevel_FirstAwaken ) limitStatus = PC_LIMIT_STATUS_FIRST_AWAKEN[pcJob];
else if( level <= LimitStatusLevel_LastAwaken ) limitStatus = PC_LIMIT_STATUS_LAST_AWAKEN[pcJob];
if( status >= limitStatus[statusType] ) return false;
return true;
}
playerCharacter_t *pCalcPC;
float GetStausWeight( playerCharacter_t *pc, int statusType )
{
switch( statusType )
{
case STATUS_FORCE :
return( (float)pc->calForce );
break;
case STATUS_SOULPOWER :
return( (float)pc->calSoulpower );
break;
case STATUS_AGILITY :
return( (float)pc->calAgility );
break;
case STATUS_VITALITY :
return( (float)pc->calVitality );
break;
}
return( 0.0f );
}
float GetBaseMaxRA()
{
int pcJob = pCalcPC->pcJob;
int level = pCalcPC->level;
float vital = (float)pCalcPC->calVitality;
float ret;
float tvalue1;
float tvalue2;
if( pcJob == J_MENTALITY || pcJob == J_DEVOTIONAL_KNIGHT || pcJob == J_ROMING_KNIGHT )
{
tvalue1 = vital * vital - 200.0f;
tvalue2 = powf( vital, 0.15f );
ret = tvalue1 / tvalue2;
}
else if( pcJob == J_EARTH || pcJob == J_TRANSFORMER || pcJob == J_STRANGER )
{
tvalue1 = vital * vital - 500.0f;
tvalue2 = powf( vital, 0.18f );
ret = tvalue1 / tvalue2;
}
else if( pcJob == J_DEFENDER )
{
tvalue1 = vital * vital;
tvalue2 = powf( vital, 0.15f );
ret = tvalue1 / tvalue2;
}
else if( pcJob == J_WIND || pcJob == J_PIECING_EYES || pcJob == J_WINDY_ROMER )
{
tvalue1 = vital * vital;
tvalue2 = powf( vital, 0.2f );
ret = tvalue1 / tvalue2;
}
else if( pcJob == J_WATER || pcJob == J_DESTROYER || pcJob == J_PROPHECIER )
{
tvalue1 = vital * vital + 100.0f;
tvalue2 = powf( vital, 0.30f );
ret = tvalue1 / tvalue2;
}
else if( pcJob == J_GUARDIAN )
{
tvalue1 = vital * vital;
tvalue2 = powf( vital, 0.2f );
ret = tvalue1 / tvalue2;
}
return( ret );
}
float GetDivideValueInBaseFormula( int valueType )
{
switch( valueType )
{
case DivideValue_MaxSA :
{
return( 6.0f );
}
break;
case DivideValue_PhyDamage_Except_Wind :
{
return( 10.0f * 8.0f );
}
break;
case DivideValue_PhyDamage_Wind_By_Bow :
{
return( 10.0f * 8.0f );
}
break;
case DivideValue_PhyDamage_Wind_By_Dagger :
{
return( 10.0f * 12.0f );
}
break;
case DivideValue_MagDamage :
{
return( 10.0f * 20.0f );
}
break;
case DivideValue_HitPower :
{
return( 20.0f * 12.0f );
}
break;
case DivideValue_AvoidPower :
{
return( 20.0f * 12.0f );
}
break;
}
return( 1.0f );
}
void GTH_PC_InitPCPoint()
{
pCalcPC->baseItemPhyMinDmg = 0;
pCalcPC->baseItemPhyMaxDmg = 0;
pCalcPC->baseItemMagMinDmg = 0;
pCalcPC->baseItemMagMaxDmg = 0;
pCalcPC->baseItemCriticalDmg = 0;
pCalcPC->baseItemCriticalRate = 0;
pCalcPC->baseAttackSpeed = 0;
pCalcPC->atkBowSACost = 0;
pCalcPC->baseDefensePower = 1;
pCalcPC->baseItemDefensePower = 0;
pCalcPC->baseItemPositiveRes = 0;
pCalcPC->baseItemNegativeRes = 0;
pCalcPC->baseVelocity = 0.0f;
pCalcPC->baseItemHitPower = 0;
pCalcPC->baseItemAvoidPower = 0;
pCalcPC->baseAttackLength = 60;
pCalcPC->baseAttackRange = 0;
pCalcPC->curItemWeight = 0;
pCalcPC->generalSpeed = 100;
pCalcPC->atkWeaponType = WEAPON_TYPE_ONEHAND_SWORD;
pCalcPC->attackSpeedRate = 0;
}
void GTH_PC_CalcItemAttackPoint()
{
if( !g_itemClassTable[g_optItem.classIdx].attackAtt ) return;
pCalcPC->baseItemPhyMinDmg += g_optItem.atkPhyMinDmg;
pCalcPC->baseItemPhyMaxDmg += g_optItem.atkPhyMaxDmg;
pCalcPC->baseItemMagMinDmg += g_optItem.atkMagMinDmg;
pCalcPC->baseItemMagMaxDmg += g_optItem.atkMagMaxDmg;
pCalcPC->baseItemHitPower += g_optItem.atkHitPower;
pCalcPC->baseItemCriticalDmg += g_optItem.atkCriticalDmg;
pCalcPC->baseItemCriticalRate += g_optItem.atkCriticalRate;
pCalcPC->baseAttackSpeed += g_optItem.atkDelay;
pCalcPC->atkBowSACost += g_optItem.atkBowSACost;
}
void GTH_PC_CalcItemDefensePoint()
{
if( !g_itemClassTable[g_optItem.classIdx].defenseAtt ) return;
pCalcPC->baseItemDefensePower += g_optItem.defPower;
pCalcPC->baseItemAvoidPower += g_optItem.defAvoidPower;
pCalcPC->baseItemPositiveRes += g_optItem.defPositiveRes;
pCalcPC->baseItemNegativeRes += g_optItem.defNegativeRes;
pCalcPC->baseItemHitPower += g_optItem.defHitPower;
pCalcPC->baseVelocity += g_optItem.defVelocity * 0.01f;
}
void GTH_PC_CalcItemEpackPoint()
{
if(g_optItem.classIdx < 0 || g_optItem.classIdx >= MAX_NUMBER_OF_ITEM_CLASS_TABLE) return;
if( !g_itemClassTable[g_optItem.classIdx].packAtt ) return;
int epackIdx;
int totalRA, totalSA;
epackIdx = pCalcPC->equipment[EQUIP_EPACK];
if( epackIdx < 0 )
{
pCalcPC->maxChargeRA = 0;
pCalcPC->maxChargeSA = 0;
pCalcPC->curChargeRA = 0;
pCalcPC->curChargeSA = 0;
pCalcPC->onceRecoveryRA = 0;
pCalcPC->onceRecoverySA = 0;
return;
}
if( !GTH_CheckRequire( pCalcPC, 0, &pCalcPC->item[epackIdx] ) )
{
pCalcPC->maxChargeRA = 0;
pCalcPC->maxChargeSA = 0;
pCalcPC->curChargeRA = 0;
pCalcPC->curChargeSA = 0;
pCalcPC->onceRecoveryRA = 0;
pCalcPC->onceRecoverySA = 0;
return;
}
OPTION_ApplyItem( &pCalcPC->item[epackIdx] );
totalRA = pCalcPC->curChargeRA * pCalcPC->onceRecoveryRA;
totalSA = pCalcPC->curChargeSA * pCalcPC->onceRecoverySA;
pCalcPC->maxChargeRA = g_optItem.epkMaxChargeRA;
pCalcPC->maxChargeSA = g_optItem.epkMaxChargeSA;
pCalcPC->onceRecoveryRA = g_optItem.epkRecoveryRA;
pCalcPC->onceRecoverySA = g_optItem.epkRecoverySA;
if( totalRA > 0 )
{
if( pCalcPC->onceRecoveryRA > 0 )
{
pCalcPC->curChargeRA = (float)totalRA / (float)pCalcPC->onceRecoveryRA;
}
else pCalcPC->curChargeRA = 0;
if( pCalcPC->curChargeRA > pCalcPC->maxChargeRA ) pCalcPC->curChargeRA = pCalcPC->maxChargeRA;
}
if( totalSA > 0 )
{
if( pCalcPC->onceRecoverySA > 0 )
{
pCalcPC->curChargeSA = (float)totalSA / (float)pCalcPC->onceRecoverySA;
}
else pCalcPC->curChargeSA = 0;
if( pCalcPC->curChargeSA > pCalcPC->maxChargeSA ) pCalcPC->curChargeSA = pCalcPC->maxChargeSA;
}
}
void GTH_PC_CalcStatus()
{
int i, itemIdx;
item_t *item;
int status[4] = { 0, 0, 0, 0 };
for( i = EQUIP_WEAPON_1; i < MAX_EQUIPMENT; i ++ )
{
if( i == EQUIP_WEAPON_1 && pCalcPC->curWeapon == 1 ) continue;
if( i == EQUIP_WEAPON_2 && pCalcPC->curWeapon == 0 ) continue;
if( pCalcPC->equipment[i] < 0 ) continue;
itemIdx = pCalcPC->equipment[i];
item = &pCalcPC->item[itemIdx];
if( !GTH_CheckRequire( pCalcPC, 0, item ) ) continue;
OPTION_ApplyStatusOption( item, status );
}
pCalcPC->calForce = pCalcPC->force + status[0];
pCalcPC->calSoulpower = pCalcPC->soulpower + status[1];
pCalcPC->calAgility = pCalcPC->agility + status[2];
pCalcPC->calVitality = pCalcPC->vitality + status[3];
}
void GTH_PC_CalcItemPoint()
{
int i, itemIdx;
item_t *item;
for( i = EQUIP_WEAPON_1; i < MAX_EQUIPMENT; i ++ )
{
if( i == EQUIP_WEAPON_1 && pCalcPC->curWeapon == 1 ) continue;
if( i == EQUIP_WEAPON_2 && pCalcPC->curWeapon == 0 ) continue;
if( pCalcPC->equipment[i] < 0 ) continue;
itemIdx = pCalcPC->equipment[i];
item = &pCalcPC->item[itemIdx];
if( !GTH_CheckRequire( pCalcPC, 0, item ) ) continue;
OPTION_ApplyItem( item );
GTH_PC_CalcItemAttackPoint();
if( i == pCalcPC->curWeapon )
{
pCalcPC->baseAttackLength = g_optItem.atkLength;
pCalcPC->baseAttackRange = g_optItem.atkRange;
pCalcPC->atkWeaponType = g_itemClassTable[g_itemTable[item->itemTableIdx].classIdx].weaponType;
}
}
for( i = EQUIP_WEAPON_1; i < MAX_EQUIPMENT; i ++ )
{
if( i == EQUIP_WEAPON_1 && pCalcPC->curWeapon == 1 ) continue;
if( i == EQUIP_WEAPON_2 && pCalcPC->curWeapon == 0 ) continue;
if( pCalcPC->equipment[i] < 0 ) continue;
itemIdx = pCalcPC->equipment[i];
item = &pCalcPC->item[itemIdx];
if( !GTH_CheckRequire( pCalcPC, 0, item ) ) continue;
OPTION_ApplyItem( item );
GTH_PC_CalcItemDefensePoint();
}
GTH_PC_CalcItemEpackPoint();
GTH_PC_CalcItemWeightPoint(pCalcPC);
}
void GTH_PC_CalcOptionPoint()
{
item_t *item;
int i, itemIdx;
OPTION_InitGlobal();
for( i = EQUIP_WEAPON_1; i < MAX_EQUIPMENT; i ++ )
{
if( i == EQUIP_WEAPON_1 && pCalcPC->curWeapon == 1 ) continue;
if( i == EQUIP_WEAPON_2 && pCalcPC->curWeapon == 0 ) continue;
if( pCalcPC->equipment[i] < 0 ) continue;
itemIdx = pCalcPC->equipment[i];
item = &pCalcPC->item[itemIdx];
if( !GTH_CheckRequire( pCalcPC, 0, item ) ) continue;
OPTION_ApplyItemOption( item );
}
memcpy( pCalcPC->optValue, g_optValue, sizeof( g_optValue ) );
OPTION_CheckOptionValue( pCalcPC->optValue );
}
void GTH_PC_CalcBasePoint()
{
float tvalue1, tvalue2;
GTH_PC_CalcStatus();
GTH_PC_InitPCPoint();
GTH_PC_CalcItemPoint();
GTH_PC_CalcOptionPoint();
pCalcPC->baseMaxRA = GetBaseMaxRA();
tvalue1 = (float)pCalcPC->calSoulpower;
tvalue2 = GetDivideValueInBaseFormula( DivideValue_MaxSA );
pCalcPC->baseMaxSA = ( tvalue1 * tvalue1 ) / tvalue2;
pCalcPC->calMaxRA = pCalcPC->baseMaxRA;
pCalcPC->calMaxSA = pCalcPC->baseMaxSA;
switch(pCalcPC->pcClass){
case GEN_WIND:
pCalcPC->basePhyMaxDmg=
pCalcPC->basePhyMinDmg=
(int)(( pCalcPC->calAgility * pCalcPC->calAgility ) / (10.0* 16));
break;
default:
case GEN_MENTALITY:
case GEN_WATER:
case GEN_EARTH:
pCalcPC->basePhyMaxDmg=
pCalcPC->basePhyMinDmg=
(int)(( pCalcPC->calForce * pCalcPC->calForce ) / (10.0* 16));
break;
}
pCalcPC->calPhyMinDmg = pCalcPC->basePhyMinDmg + pCalcPC->baseItemPhyMinDmg;
pCalcPC->calPhyMaxDmg = pCalcPC->basePhyMaxDmg + pCalcPC->baseItemPhyMaxDmg;
tvalue1 = (float)pCalcPC->calSoulpower;
tvalue2 = GetDivideValueInBaseFormula( DivideValue_MagDamage );
pCalcPC->baseMagMinDmg = (int)( ( tvalue1 * tvalue1 ) / tvalue2 );
pCalcPC->baseMagMaxDmg = (int)( ( tvalue1 * tvalue1 ) / tvalue2 );
pCalcPC->calMagMinDmg = pCalcPC->baseMagMinDmg + pCalcPC->baseItemMagMinDmg;
pCalcPC->calMagMaxDmg = pCalcPC->baseMagMaxDmg + pCalcPC->baseItemMagMaxDmg;
pCalcPC->baseDefensePower += pCalcPC->baseItemDefensePower;
pCalcPC->calDefensePower = pCalcPC->baseDefensePower;
tvalue1 = 100.0f + (float)pCalcPC->level - 1.0f;
tvalue1 = ( tvalue1 * tvalue1 ) + ( (float)pCalcPC->calAgility / 4.0f );
tvalue2 = GetDivideValueInBaseFormula( DivideValue_HitPower );
pCalcPC->baseHitPower = (int)( tvalue1 / tvalue2 ) + pCalcPC->baseItemHitPower;
pCalcPC->calHitPower = pCalcPC->baseHitPower;
tvalue1 = (float)pCalcPC->calAgility;
tvalue2 = GetDivideValueInBaseFormula( DivideValue_AvoidPower );
pCalcPC->baseAvoidPower = (int)( ( tvalue1 * tvalue1 ) / tvalue2 ) + pCalcPC->baseItemAvoidPower;
pCalcPC->calAvoidPower = pCalcPC->baseAvoidPower;
pCalcPC->basePositiveRes = pCalcPC->baseItemPositiveRes;
pCalcPC->baseNegativeRes = pCalcPC->baseItemNegativeRes;
pCalcPC->calPositiveRes = pCalcPC->basePositiveRes;
pCalcPC->calNegativeRes = pCalcPC->baseNegativeRes;
pCalcPC->baseCriticalDmg = pCalcPC->baseItemCriticalDmg;
pCalcPC->baseCriticalRate = pCalcPC->baseItemCriticalRate;
pCalcPC->calCriticalDmg = pCalcPC->baseCriticalDmg;
pCalcPC->calCriticalRate = pCalcPC->baseCriticalRate;
pCalcPC->baseVelocity += 2.4f + 0.005f * (float)pCalcPC->calAgility;
pCalcPC->calVelocity = pCalcPC->baseVelocity;
pCalcPC->baseStunTime = (int)( 800.0f - ( (float)pCalcPC->calVitality * 2.5f ) );
pCalcPC->calStunTime = pCalcPC->baseStunTime;
pCalcPC->baseItemWeight = (int)( (float)pCalcPC->calVitality * 100.0f );
pCalcPC->calItemWeight = pCalcPC->baseItemWeight;
pCalcPC->calAttackLength = pCalcPC->baseAttackLength;
g_SkillLogic.SKILL_ApplyPassive( pCalcPC );
GTH_ApplyOption( pCalcPC );
GTH_ApplyAffect( pCalcPC );
pCalcPC->calAttackDelay = (int)( 2500.0f - (float)pCalcPC->baseAttackSpeed );
pCalcPC->calAttackDelay = (int)( (float)pCalcPC->calAttackDelay / \
( ( 100.0f + (float)pCalcPC->attackSpeedRate ) / 100.0f ) );
if( pCalcPC->calAttackDelay < 500.0f ) pCalcPC->calAttackDelay = 500.0f;
if( pCalcPC->calStunTime < 100 ) pCalcPC->baseStunTime = 100;
if( pCalcPC->calPositiveRes > 75.0f ) pCalcPC->calPositiveRes = 75.0f;
if( pCalcPC->calPositiveRes < -100.0f ) pCalcPC->calPositiveRes = -100.0f;
if( pCalcPC->calNegativeRes > 75.0f ) pCalcPC->calNegativeRes = 75.0f;
if( pCalcPC->calNegativeRes < -100.0f ) pCalcPC->calNegativeRes = -100.0f;
if( pCalcPC->calPhyMinDmg > pCalcPC->calPhyMaxDmg ) pCalcPC->calPhyMinDmg = pCalcPC->calPhyMaxDmg;
if( pCalcPC->calMagMinDmg > pCalcPC->calMagMaxDmg ) pCalcPC->calMagMinDmg = pCalcPC->calMagMaxDmg;
}
void GTH_PC_Calculate( playerCharacter_t* pc, int type )
{
pCalcPC = pc;
GTH_PC_CalcBasePoint();
if( pc->curRA > pc->calMaxRA ) pc->curRA = pc->calMaxRA;
if( pc->curSA > pc->calMaxSA ) pc->curSA = pc->calMaxSA;
GTH_SendMessage_Reply_PCInfo( pc );
}
void GTH_PC_CalcItemWeightPoint(playerCharacter_t* in_pPlayer)
{
if(NULL == in_pPlayer) return;
item_t* pItemRecord=NULL;
itemTable_t* pItemTableRecord=NULL;
for(int nEquipmentArrayIdx=0; nEquipmentArrayIdx < MAX_EQUIPMENT; nEquipmentArrayIdx++){
pItemRecord = gcpTools->GetMyItem(in_pPlayer,in_pPlayer->equipment[nEquipmentArrayIdx]);
if(NULL == pItemRecord) continue;
pItemTableRecord = gcpTools->GetItemTablePointer(pItemRecord->itemTableIdx);
if(NULL == pItemTableRecord) continue;
in_pPlayer->curItemWeight += pItemTableRecord->weight;
}
for(int nInventoryArrayIdx=0; nInventoryArrayIdx < MAX_INVENTORY_SIZE; nInventoryArrayIdx++){
pItemRecord = gcpTools->GetMyItem(in_pPlayer,in_pPlayer->inventory[nInventoryArrayIdx]);
if(NULL == pItemRecord) continue;
pItemTableRecord = gcpTools->GetItemTablePointer(pItemRecord->itemTableIdx);
if(NULL == pItemTableRecord) continue;
in_pPlayer->curItemWeight += pItemTableRecord->weight;
}
for(int nTradeBoxArrayIdx=0; nTradeBoxArrayIdx < MAX_TRADE_SIZE; nTradeBoxArrayIdx++){
pItemRecord = gcpTools->GetMyItem(in_pPlayer,in_pPlayer->myTrade[nTradeBoxArrayIdx]);
if(NULL == pItemRecord) continue;
pItemTableRecord = gcpTools->GetItemTablePointer(pItemRecord->itemTableIdx);
if(NULL == pItemTableRecord) continue;
in_pPlayer->curItemWeight += pItemTableRecord->weight;
}
if( in_pPlayer->mouseInventory >= 0 ){
pItemRecord = gcpTools->GetMyItem(in_pPlayer,in_pPlayer->mouseInventory);
if(NULL == pItemRecord) return;
pItemTableRecord = gcpTools->GetItemTablePointer(pItemRecord->itemTableIdx);
if(NULL == pItemTableRecord) return;
in_pPlayer->curItemWeight += pItemTableRecord->weight;
}
}
| C++ |
#include "../global.h"
void GTH_Zone_Init()
{
int x, y, zoneIdx;
int localWorldIdx;
g_zonePCListNumber = 0;
for (localWorldIdx=0; localWorldIdx < MAX_LOCALSERVICEWORLDS; localWorldIdx++)
{
zoneIdx = 0;
for (x=0 ; x<ZONE_DIV; x++)
{
for (y=0; y<ZONE_DIV; y++, zoneIdx++)
{
g_zone[localWorldIdx][zoneIdx].localWorldIdx = localWorldIdx;
g_zone[localWorldIdx][zoneIdx].zoneIdx = zoneIdx;
g_zone[localWorldIdx][zoneIdx].pcNumber = 0;
memset(g_zone[localWorldIdx][zoneIdx].pcList, 0, MAX_ZONE_PCS * sizeof(int));
g_zone[localWorldIdx][zoneIdx].monNumber = 0;
memset(g_zone[localWorldIdx][zoneIdx].monList, 0, MAX_ZONE_MONSTERS * sizeof(int));
g_zone[localWorldIdx][zoneIdx].npcNumber = 0;
memset(g_zone[localWorldIdx][zoneIdx].npcList, 0, MAX_ZONE_NPCS * sizeof(int));
g_zone[localWorldIdx][zoneIdx].objectNumber = 0;
memset(g_zone[localWorldIdx][zoneIdx].objectList, 0, MAX_ZONE_OBJECTS * sizeof(int));
}
}
}
}
int GTH_Zone_GetZoneIdx(vec3_t position)
{
int posX, posY;
int zoneX, zoneY;
int zoneIdx;
posX = (int) position[0] / ZONE_GRIDSCALE;
posY = (int) position[1] / ZONE_GRIDSCALE;
zoneX = (int) posX / ZONE_UNIT;
zoneY = (int) posY / ZONE_UNIT;
if (zoneX >= ZONE_DIV || zoneY >= ZONE_DIV)
return -1;
if( zoneX < 0.0f || zoneY < 0.0f )
return -1;
zoneIdx = zoneX * ZONE_DIV + zoneY;
return zoneIdx;
}
int GTH_Zone_UpdateCurrentZone(entityType_t entType, int entIdx, int worldIdx, int preZoneIdx, vec3_t position)
{
int curZoneIdx;
curZoneIdx = GTH_Zone_GetZoneIdx(position);
if ( curZoneIdx == preZoneIdx )
return curZoneIdx;
else if ( curZoneIdx == -1 )
{
if( entType == ENTITY_PC )
{
g_logSystem->Write("Zone Range Error(name: %s, worldIdx: %d, pos: %f, %f, %f)",
g_pc[entIdx].name, g_pc[entIdx].worldIdx, g_pc[entIdx].position[0], g_pc[entIdx].position[1], g_pc[entIdx].position[2]);
vec_copy( g_worldTable[g_pc[entIdx].worldIdx].startPosition, g_pc[entIdx].reliablePosition );
vec_copy( g_pc[entIdx].reliablePosition, g_pc[entIdx].position );
curZoneIdx = GTH_Zone_GetZoneIdx( g_pc[entIdx].position );
}
}
if( preZoneIdx >= 0 ) GTH_Zone_DeleteEntityList(worldIdx, preZoneIdx, entType, entIdx);
GTH_Zone_AddEntityList(worldIdx, curZoneIdx, entType, entIdx);
return curZoneIdx;
}
int GTH_Zone_AddEntityList(int worldIdx, int zoneIdx, entityType_t entType, int entIdx)
{
int number;
vec3_t pos;
int localWorldIdx;
localWorldIdx = GTH_GetLocalWorldIdx( worldIdx );
if (localWorldIdx < 0) return 0;
if( zoneIdx < 0 || localWorldIdx < 0 || entIdx < 0 )
{
if( entType == ENTITY_PC )
{
vec_copy( g_pc[entIdx].position, pos );
} else if( entType == ENTITY_MONSTER || entType == ENTITY_NPC )
{
vec_copy( g_monster[entIdx].position, pos );
} else if( entType == ENTITY_OBJECT )
{
vec_copy( g_object[entIdx].position, pos );
}
g_logSystem->Write( "zoneIdx : %d, worldIdx : %d, localWorldIdx: %d, entIdx : %d, entType : %d, pos(%.2f,%.2f,%.2f)",
zoneIdx, worldIdx, localWorldIdx, entIdx, (int)entType, pos[0], pos[1], pos[2] );
g_logSystem->Update();
}
if (entType == ENTITY_PC)
{
number = g_zone[localWorldIdx][zoneIdx].pcNumber;
if (number >= MAX_ZONE_PCS)
return 0;
g_zone[localWorldIdx][zoneIdx].pcList[number] = entIdx;
g_zone[localWorldIdx][zoneIdx].pcNumber++;
}
else if (entType == ENTITY_MONSTER)
{
number = g_zone[localWorldIdx][zoneIdx].monNumber;
if (number >= MAX_ZONE_MONSTERS)
return 0;
g_zone[localWorldIdx][zoneIdx].monList[number] = entIdx;
g_zone[localWorldIdx][zoneIdx].monNumber++;
}
else if (entType == ENTITY_NPC)
{
number = g_zone[localWorldIdx][zoneIdx].npcNumber;
if (number >= MAX_ZONE_NPCS)
return 0;
g_zone[localWorldIdx][zoneIdx].npcList[number] = entIdx;
g_zone[localWorldIdx][zoneIdx].npcNumber++;
}
else if (entType == ENTITY_OBJECT)
{
number = g_zone[localWorldIdx][zoneIdx].objectNumber;
if (number >= MAX_ZONE_OBJECTS)
return 0;
g_zone[localWorldIdx][zoneIdx].objectList[number] = entIdx;
g_zone[localWorldIdx][zoneIdx].objectNumber++;
}
return 1;
}
int GTH_Zone_DeleteEntityList(int worldIdx, int zoneIdx, entityType_t entType, int entIdx)
{
int i;
int number;
int success ;
int localWorldIdx;
localWorldIdx = GTH_GetLocalWorldIdx( worldIdx );
if (localWorldIdx < 0) return 0;
success = 0;
if (entType == ENTITY_PC)
{
number = g_zone[localWorldIdx][zoneIdx].pcNumber;
for (i=0; i<number; i++)
{
if (g_zone[localWorldIdx][zoneIdx].pcList[i] == entIdx)
{
if (i != number-1)
g_zone[localWorldIdx][zoneIdx].pcList[i] = g_zone[localWorldIdx][zoneIdx].pcList[number-1];
g_zone[localWorldIdx][zoneIdx].pcNumber--;
success = 1;
break;
}
}
}
else if (entType == ENTITY_MONSTER)
{
number = g_zone[localWorldIdx][zoneIdx].monNumber;
for (i=0; i<number; i++)
{
if (g_zone[localWorldIdx][zoneIdx].monList[i] == entIdx)
{
if (i != number-1)
g_zone[localWorldIdx][zoneIdx].monList[i] = g_zone[localWorldIdx][zoneIdx].monList[number-1];
g_zone[localWorldIdx][zoneIdx].monNumber--;
success = 1;
break;
}
}
}
else if (entType == ENTITY_NPC)
{
number = g_zone[localWorldIdx][zoneIdx].npcNumber;
for (i=0; i<number; i++)
{
if (g_zone[localWorldIdx][zoneIdx].npcList[i] == entIdx)
{
if (i != number-1)
g_zone[localWorldIdx][zoneIdx].npcList[i] = g_zone[localWorldIdx][zoneIdx].npcList[number-1];
g_zone[localWorldIdx][zoneIdx].npcNumber--;
success = 1;
break;
}
}
}
else if (entType == ENTITY_OBJECT)
{
number = g_zone[localWorldIdx][zoneIdx].objectNumber;
for (i=0; i<number; i++)
{
if (g_zone[localWorldIdx][zoneIdx].objectList[i] == entIdx)
{
if (i != number-1)
g_zone[localWorldIdx][zoneIdx].objectList[i] = g_zone[localWorldIdx][zoneIdx].objectList[number-1];
g_zone[localWorldIdx][zoneIdx].objectNumber--;
success = 1;
break;
}
}
}
return success;
}
int GTH_Zone_ScanPCList(int localWorldIdx, vec3_t position, int scanDepth)
{
int posX, posY;
int zoneX, zoneY;
int pX, pY;
int x, y;
int i;
float distance;
int zoneIdx;
int myZoneIdx;
posX = (int) position[0] / ZONE_GRIDSCALE;
posY = (int) position[1] / ZONE_GRIDSCALE;
zoneX = (int) posX / ZONE_UNIT;
zoneY = (int) posY / ZONE_UNIT;
if (zoneX >= ZONE_DIV || zoneY >= ZONE_DIV)
return -1;
g_zonePCListNumber = 0;
zoneIdx = zoneX * ZONE_DIV + zoneY;
myZoneIdx = zoneIdx;
for (i=0; i<g_zone[localWorldIdx][zoneIdx].pcNumber; i++)
{
distance = GTH_GetDistance2D(position, g_pc[ g_zone[localWorldIdx][zoneIdx].pcList[i] ].position);
if (distance <= MAX_SEEINGDISTANCE)
{
g_zonePCList[g_zonePCListNumber].entityType = ENTITY_PC;
g_zonePCList[g_zonePCListNumber].idx = g_zone[localWorldIdx][zoneIdx].pcList[i];
g_zonePCList[g_zonePCListNumber].distance = distance;
g_zonePCListNumber++;
}
}
if ( g_zonePCListNumber >= MAX_LIMIT_PCLIST ) return g_zonePCListNumber;
scanDepth = 1;
for (x=-scanDepth; x<=scanDepth; x++)
{
pX = zoneX + x;
if (pX < 0 || pX > ZONE_DIV - 1)
continue;
for (y=-scanDepth; y<=scanDepth; y++)
{
pY = zoneY + y;
if (pY < 0 || pY > ZONE_DIV - 1)
continue;
zoneIdx = pX * ZONE_DIV + pY;
if ( zoneIdx == myZoneIdx )
continue;
for (i=0; i<g_zone[localWorldIdx][zoneIdx].pcNumber; i++)
{
distance = GTH_GetDistance2D(position, g_pc[ g_zone[localWorldIdx][zoneIdx].pcList[i] ].position);
if (distance <= MAX_SEEINGDISTANCE)
{
g_zonePCList[g_zonePCListNumber].entityType = ENTITY_PC;
g_zonePCList[g_zonePCListNumber].idx = g_zone[localWorldIdx][zoneIdx].pcList[i];
g_zonePCList[g_zonePCListNumber].distance = distance;
g_zonePCListNumber++;
}
}
}
if ( g_zonePCListNumber >= MAX_LIMIT_PCLIST ) return g_zonePCListNumber;
}
scanDepth = 2;
for (x=-scanDepth; x<=scanDepth; x++)
{
if ( x > -scanDepth || x < scanDepth )
continue;
pX = zoneX + x;
if (pX < 0 || pX > ZONE_DIV - 1)
continue;
for (y=-scanDepth; y<=scanDepth; y++)
{
if ( y > -scanDepth || y < scanDepth )
continue;
pY = zoneY + y;
if (pY < 0 || pY > ZONE_DIV - 1)
continue;
zoneIdx = pX * ZONE_DIV + pY;
for (i=0; i<g_zone[localWorldIdx][zoneIdx].pcNumber; i++)
{
distance = GTH_GetDistance2D(position, g_pc[ g_zone[localWorldIdx][zoneIdx].pcList[i] ].position);
if (distance <= MAX_SEEINGDISTANCE)
{
g_zonePCList[g_zonePCListNumber].entityType = ENTITY_PC;
g_zonePCList[g_zonePCListNumber].idx = g_zone[localWorldIdx][zoneIdx].pcList[i];
g_zonePCList[g_zonePCListNumber].distance = distance;
g_zonePCListNumber++;
}
if ( g_zonePCListNumber >= MAX_SCAN_PCLIST ) return g_zonePCListNumber;
}
}
}
return g_zonePCListNumber;
}
int GTH_Zone_ScanMonsterList(int localWorldIdx, vec3_t position, int scanDepth)
{
int posX, posY;
int zoneX, zoneY;
int pX, pY;
int x, y;
int i;
float distance;
int zoneIdx;
posX = (int) position[0] / ZONE_GRIDSCALE;
posY = (int) position[1] / ZONE_GRIDSCALE;
zoneX = (int) posX / ZONE_UNIT;
zoneY = (int) posY / ZONE_UNIT;
if (zoneX >= ZONE_DIV || zoneY >= ZONE_DIV)
return -1;
g_zoneMonsterListNumber = 0;
for (x=-scanDepth; x<=scanDepth; x++)
{
pX = zoneX + x;
if (pX < 0 || pX > ZONE_DIV - 1)
continue;
for (y=-scanDepth; y<=scanDepth; y++)
{
pY = zoneY + y;
if (pY < 0 || pY > ZONE_DIV - 1)
continue;
zoneIdx = pX * ZONE_DIV + pY;
for (i=0; i<g_zone[localWorldIdx][zoneIdx].monNumber; i++)
{
distance = GTH_GetDistance2D(position, g_monster[ g_zone[localWorldIdx][zoneIdx].monList[i] ].position);
if (distance <= MAX_SEEINGDISTANCE)
{
g_zoneMonsterList[g_zoneMonsterListNumber].entityType = ENTITY_MONSTER;
g_zoneMonsterList[g_zoneMonsterListNumber].idx = g_zone[localWorldIdx][zoneIdx].monList[i];
g_zoneMonsterList[g_zoneMonsterListNumber].distance = distance;
g_zoneMonsterListNumber++;
if ( g_zoneMonsterListNumber >= MAX_SCAN_MONSTERLIST ) return g_zoneMonsterListNumber;
}
}
}
}
return g_zoneMonsterListNumber;
}
int GTH_Zone_ScanNPCList(int localWorldIdx, vec3_t position, int scanDepth)
{
int posX, posY;
int zoneX, zoneY;
int pX, pY;
int x, y;
int i;
float distance;
int zoneIdx;
posX = (int) position[0] / ZONE_GRIDSCALE;
posY = (int) position[1] / ZONE_GRIDSCALE;
zoneX = (int) posX / ZONE_UNIT;
zoneY = (int) posY / ZONE_UNIT;
if (zoneX >= ZONE_DIV || zoneY >= ZONE_DIV)
return -1;
g_zoneNPCListNumber = 0;
for (x=-scanDepth; x<=scanDepth; x++)
{
pX = zoneX + x;
if (pX < 0 || pX > ZONE_DIV - 1)
continue;
for (y=-scanDepth; y<=scanDepth; y++)
{
pY = zoneY + y;
if (pY < 0 || pY > ZONE_DIV - 1)
continue;
zoneIdx = pX * ZONE_DIV + pY;
for (i=0; i<g_zone[localWorldIdx][zoneIdx].npcNumber; i++)
{
distance = GTH_GetDistance2D(position, g_monster[ g_zone[localWorldIdx][zoneIdx].npcList[i] ].position);
if (distance <= MAX_SEEINGDISTANCE)
{
g_zoneNPCList[g_zoneNPCListNumber].entityType = ENTITY_NPC;
g_zoneNPCList[g_zoneNPCListNumber].idx = g_zone[localWorldIdx][zoneIdx].npcList[i];
g_zoneNPCList[g_zoneNPCListNumber].distance = distance;
g_zoneNPCListNumber++;
if ( g_zoneNPCListNumber >= MAX_SCAN_NPCLIST ) return g_zoneNPCListNumber;
}
}
}
}
return g_zoneNPCListNumber;
}
int GTH_Zone_ScanObjectList(int localWorldIdx, vec3_t position, int scanDepth)
{
int posX, posY;
int zoneX, zoneY;
int pX, pY;
int x, y;
int i;
float distance;
int zoneIdx;
posX = (int) position[0] / ZONE_GRIDSCALE;
posY = (int) position[1] / ZONE_GRIDSCALE;
zoneX = (int) posX / ZONE_UNIT;
zoneY = (int) posY / ZONE_UNIT;
if (zoneX >= ZONE_DIV || zoneY >= ZONE_DIV)
return -1;
g_zoneObjectListNumber = 0;
for (x=-scanDepth; x<=scanDepth; x++)
{
pX = zoneX + x;
if (pX < 0 || pX > ZONE_DIV - 1)
continue;
for (y=-scanDepth; y<=scanDepth; y++)
{
pY = zoneY + y;
if (pY < 0 || pY > ZONE_DIV - 1)
continue;
zoneIdx = pX * ZONE_DIV + pY;
for (i=0; i<g_zone[localWorldIdx][zoneIdx].objectNumber; i++)
{
distance = GTH_GetDistance2D(position, g_object[ g_zone[localWorldIdx][zoneIdx].objectList[i] ].position);
if (distance <= MAX_SEEINGDISTANCE)
{
g_zoneObjectList[g_zoneObjectListNumber].entityType = ENTITY_OBJECT;
g_zoneObjectList[g_zoneObjectListNumber].idx = g_zone[localWorldIdx][zoneIdx].objectList[i];
g_zoneObjectList[g_zoneObjectListNumber].distance = distance;
g_zoneObjectListNumber++;
if ( g_zoneObjectListNumber >= MAX_SCAN_OBJECTLIST ) return g_zoneObjectListNumber;
}
}
}
}
return g_zoneObjectListNumber;
}
int GTH_Zone_ScanEntityList(int localWorldIdx, vec3_t position, int scanDepth)
{
int posX, posY;
int zoneX, zoneY;
int pX, pY;
int x, y;
int i;
float distance;
int zoneIdx;
posX = (int) position[0] / ZONE_GRIDSCALE;
posY = (int) position[1] / ZONE_GRIDSCALE;
zoneX = (int) posX / ZONE_UNIT;
zoneY = (int) posY / ZONE_UNIT;
if (zoneX > ZONE_DIV - 1 || zoneY > ZONE_DIV - 1)
return -1;
g_zoneEntityListNumber = 0;
for (x=-scanDepth; x<=scanDepth; x++)
{
pX = zoneX + x;
if (pX < 0 || pX > ZONE_DIV - 1)
continue;
for (y=-scanDepth; y<=scanDepth; y++)
{
pY = zoneY + y;
if (pY < 0 || pY > ZONE_DIV - 1)
continue;
zoneIdx = pX * ZONE_DIV + pY;
for (i=0; i<g_zone[localWorldIdx][zoneIdx].pcNumber; i++)
{
distance = GTH_GetDistance2D(position, g_pc[ g_zone[localWorldIdx][zoneIdx].pcList[i] ].position);
if (distance <= MAX_SEEINGDISTANCE)
{
g_zoneEntityList[g_zoneEntityListNumber].entityType = ENTITY_PC;
g_zoneEntityList[g_zoneEntityListNumber].idx = g_zone[localWorldIdx][zoneIdx].pcList[i];
g_zoneEntityList[g_zoneEntityListNumber].distance = distance;
g_zoneEntityListNumber++;
if ( g_zoneEntityListNumber >= MAX_SCAN_ENTITYLIST ) return g_zoneEntityListNumber;
}
}
for (i=0; i<g_zone[localWorldIdx][zoneIdx].monNumber; i++)
{
distance = GTH_GetDistance2D(position, g_monster[ g_zone[localWorldIdx][zoneIdx].monList[i] ].position);
if (distance <= MAX_SEEINGDISTANCE)
{
g_zoneEntityList[g_zoneEntityListNumber].entityType = ENTITY_MONSTER;
g_zoneEntityList[g_zoneEntityListNumber].idx = g_zone[localWorldIdx][zoneIdx].monList[i];
g_zoneEntityList[g_zoneEntityListNumber].distance = distance;
g_zoneEntityListNumber++;
if ( g_zoneEntityListNumber >= MAX_SCAN_ENTITYLIST ) return g_zoneEntityListNumber;
}
}
for (i=0; i<g_zone[localWorldIdx][zoneIdx].npcNumber; i++)
{
distance = GTH_GetDistance2D(position, g_monster[ g_zone[localWorldIdx][zoneIdx].npcList[i] ].position);
if (distance <= MAX_SEEINGDISTANCE)
{
g_zoneEntityList[g_zoneEntityListNumber].entityType = ENTITY_NPC;
g_zoneEntityList[g_zoneEntityListNumber].idx = g_zone[localWorldIdx][zoneIdx].npcList[i];
g_zoneEntityList[g_zoneEntityListNumber].distance = distance;
g_zoneEntityListNumber++;
if ( g_zoneEntityListNumber >= MAX_SCAN_ENTITYLIST ) return g_zoneEntityListNumber;
}
}
}
}
return g_zoneEntityListNumber;
}
int GTH_CompareForQsort( const void *arg1, const void *arg2 )
{
int ret;
float dist1, dist2;
dist1 = ((i3zoneScanList_t *) arg1)->distance ;
dist2 = ((i3zoneScanList_t *) arg2)->distance ;
if (dist1 > dist2)
ret = 1;
else if (dist1 < dist2)
ret = -1;
else
ret = 0;
return ret;
}
void GTH_GetEntityListInValidRange(int worldIdx, vec3_t pos, int zoneSize )
{
int i;
int localWorldIdx;
localWorldIdx = GTH_GetLocalWorldIdx( worldIdx );
if (localWorldIdx < 0)
{
g_logSystem->Write("Critical Error1: World(%d) Can not zoning to LocalWorld.", worldIdx);
return ;
}
GTH_Zone_ScanEntityList(localWorldIdx, pos, zoneSize );
if (g_zoneEntityListNumber > MAX_LIMIT_ENTITYLIST)
{
qsort(g_zoneEntityList, g_zoneEntityListNumber, sizeof(i3zoneScanList_t), GTH_CompareForQsort);
g_zoneEntityListNumber = MAX_LIMIT_ENTITYLIST;
}
g_zonePCListNumber = 0;
g_zoneMonsterListNumber = 0;
g_zoneNPCListNumber = 0;
g_zoneObjectListNumber = 0;
for (i=0; i<g_zoneEntityListNumber; i++)
{
if (g_zoneEntityList[i].entityType == ENTITY_PC)
{
if( !g_pc[g_zoneEntityList[i].idx].ready ) continue;
g_zonePCList[g_zonePCListNumber].entityType = ENTITY_PC;
g_zonePCList[g_zonePCListNumber].idx = g_zoneEntityList[i].idx;
g_zonePCList[g_zonePCListNumber].distance = g_zoneEntityList[i].distance;
g_zonePCListNumber++;
}
if (g_zoneEntityList[i].entityType == ENTITY_MONSTER)
{
if( g_monster[g_zoneEntityList[i].idx].aliveState == MON_ALIVE_STATE_DIE ) continue;
g_zoneMonsterList[g_zoneMonsterListNumber].entityType = ENTITY_MONSTER;
g_zoneMonsterList[g_zoneMonsterListNumber].idx = g_zoneEntityList[i].idx;
g_zoneMonsterList[g_zoneMonsterListNumber].distance = g_zoneEntityList[i].distance;
g_zoneMonsterListNumber++;
}
if (g_zoneEntityList[i].entityType == ENTITY_NPC)
{
if( g_monster[g_zoneEntityList[i].idx].aliveState == MON_ALIVE_STATE_DIE ) continue;
g_zoneNPCList[g_zoneNPCListNumber].idx = g_zoneEntityList[i].idx;
g_zoneNPCList[g_zoneNPCListNumber].distance = g_zoneEntityList[i].distance;
g_zoneNPCListNumber++;
}
}
}
void GTH_GetPCListInValidRange(int worldIdx, vec3_t pos, int zoneSize )
{
int localWorldIdx;
localWorldIdx = GTH_GetLocalWorldIdx( worldIdx );
if (localWorldIdx < 0)
{
g_logSystem->Write("Critical Error2: World(%d) Can not zoning to LocalWorld.", worldIdx);
return ;
}
GTH_Zone_ScanPCList(localWorldIdx, pos, zoneSize );
if (g_zonePCListNumber > MAX_LIMIT_PCLIST)
{
qsort(g_zonePCList, g_zonePCListNumber, sizeof(i3zoneScanList_t), GTH_CompareForQsort);
g_zonePCListNumber = MAX_LIMIT_PCLIST;
}
}
void GTH_GetObjectListInValidRange(int worldIdx, vec3_t pos, int zoneSize )
{
int localWorldIdx;
localWorldIdx = GTH_GetLocalWorldIdx( worldIdx );
if (localWorldIdx < 0)
{
g_logSystem->Write("Critical Error3: World(%d) Can not zoning to LocalWorld.", worldIdx);
return ;
}
GTH_Zone_ScanObjectList(localWorldIdx, pos, zoneSize );
if (g_zoneObjectListNumber > MAX_LIMIT_OBJECTLIST)
{
qsort(g_zoneObjectList, g_zoneObjectListNumber, sizeof(i3zoneScanList_t), GTH_CompareForQsort);
g_zoneObjectListNumber = MAX_LIMIT_OBJECTLIST;
}
}
void GTH_GetMonsterListInValidRange(int worldIdx, vec3_t pos, int zoneSize )
{
int localWorldIdx;
localWorldIdx = GTH_GetLocalWorldIdx( worldIdx );
if (localWorldIdx < 0)
{
g_logSystem->Write("Critical Error4: World(%d) Can not zoning to LocalWorld.", worldIdx);
return ;
}
GTH_Zone_ScanMonsterList(localWorldIdx, pos, zoneSize );
if (g_zoneMonsterListNumber > MAX_LIMIT_MONSTERLIST )
{
qsort(g_zoneMonsterList, g_zoneMonsterListNumber, sizeof(i3zoneScanList_t), GTH_CompareForQsort);
g_zoneMonsterListNumber = MAX_LIMIT_MONSTERLIST;
}
}
void GTH_GetNPCListInValidRange(int worldIdx, vec3_t pos, int zoneSize )
{
int localWorldIdx;
localWorldIdx = GTH_GetLocalWorldIdx( worldIdx );
if (localWorldIdx < 0)
{
g_logSystem->Write("Critical Error5: World(%d) Can not zoning to LocalWorld.", worldIdx);
return ;
}
GTH_Zone_ScanNPCList(localWorldIdx, pos, zoneSize );
if (g_zoneNPCListNumber > MAX_LIMIT_NPCLIST)
{
qsort(g_zoneNPCList, g_zoneNPCListNumber, sizeof(i3zoneScanList_t), GTH_CompareForQsort);
g_zoneNPCListNumber = MAX_LIMIT_NPCLIST;
}
}
| C++ |
#if !defined(AFX_ITEMTXT_H__9C5B371A_F93F_48B7_AF4A_EB51F63A3B5A__INCLUDED_)
#define AFX_ITEMTXT_H__9C5B371A_F93F_48B7_AF4A_EB51F63A3B5A__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CItemTxtData
{
public:
CItemTxtData()
{
Init();
}
void Init()
{
m_Index=-1;
m_Txt[0] = '\0';
}
public:
int m_Index;
char m_Txt[256];
};
class CItemTxt
{
public:
CItemTxt();
virtual ~CItemTxt();
bool LoadFile(char * FileName);
void GetOnlyTxt();
void ClearClassNameList();
void ClearDescList();
void ClearNameList();
void BindItemTable();
LPSTR GetName(int idx);
LPSTR GetDesc(int idx);
void STRCPY(char &Dest, char &Soruce);
public:
char m_Token[256];
vector <CItemTxtData> m_DescList;
vector <CItemTxtData> m_NameList;
vector <CItemTxtData> m_ClassNameList;
};
extern CItemTxt g_TxtApp;
#endif
| C++ |
#if !defined(AFX_EVENTCRAFTSYSTEM_H__F66E8CA1_8EB6_4C13_8D43_5975DB596AD7__INCLUDED_)
#define AFX_EVENTCRAFTSYSTEM_H__F66E8CA1_8EB6_4C13_8D43_5975DB596AD7__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#define MAX_EVENT_CRAFT_ITEM 8
enum
{
CRAFT_TYPE_NORMAL=0,
CRAFT_TYPE_RESULT,
CRAFT_TYPE_EVENT,
};
class CEventCraftSystem
{
public:
enum
{
CRAFT_RESISTER=1,
CRAFT_GIVE_ITEM,
};
public:
CEventCraftSystem();
virtual ~CEventCraftSystem();
itemCraftTable_t *Get(int idx)
{
if(idx < 0 || idx >= m_EventItemCraftTable.size()) return NULL;
return &m_EventItemCraftTable[idx];
}
int GetTableSize()
{
return m_EventItemCraftTable.size();
}
void Push(itemCraftTable_t temp)
{
m_EventItemCraftTable.push_back(temp);
}
public:
vector <itemCraftTable_t> m_EventItemCraftTable;
};
int GTH_CheckEventCraftFormula( playerCharacter_t *pc );
int GTH_EventCheckCraftFormula( playerCharacter_t *pc );
int GTH_EventCraftProcess( playerCharacter_t *pc, int &reply, int &error , bool checkFlag = false );
extern CEventCraftSystem g_EventCraftSystem;
#endif
| C++ |
#include "../Global.h"
#include <VECTOR>
#include "..\Tools\CTools.h"
#include "../Tools/CTempPlayerInventoryX.h"
extern CTools* gcpTools;
CPostFunc::CPostFunc()
{
}
CPostFunc::~CPostFunc()
{
}
void CPostFunc::GTH_ProcessMessage_PostSystem()
{
byte command = MSG_ReadByte();
switch ( command )
{
case POSTSYSTEM_OPEN:
GTH_ProcessMessage_RequestPostList();
break;
case POSTSYSTEM_EXIT_WIN:
GTH_ProcessMessage_PostWinExit();
break;
case POSTSYSTEM_SEND:
GTH_ProcessMessage_PostSend();
break;
case POSTSYSTEM_DELETE:
GTH_ProcessMessage_PostDelete();
break;
case POSTSYSTEM_STATE:
GTH_ProcessMessage_PostState();
break;
case POSTSYSTEM_WRITEOPEN:
GTH_ProcessMessage_PostWriteOpen();
break;
case POSTSYSTEM_SENDCOMPLETE:
break;
case POSTSYSTEM_DELETENAK:
break;
case POSTSYSTEM_NOTIFY:
break;
}
}
void CPostFunc::
GTH_SendMessage_PostSendComplete(playerCharacter_t* pc,int reply, int error)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_POSTSYSTEM);
MSG_WriteByte(&netMessage, POSTSYSTEM_SENDCOMPLETE);
MSG_WriteLong(&netMessage, reply);
MSG_WriteByte(&netMessage, error);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CPostFunc::GTH_ProcessMessage_PostWriteOpen(void)
{
CPostManager::PostPackage_t PostPackage;
g_curPC->m_PostMng.InitPostSystem();
g_curPC->m_PostMng.SetPostSystem(CPostManager::enumPostSystemMode::POSTSYSTEM_WRITEMODE);
g_curPC->m_PostMng.InitPost(&PostPackage);
g_curPC->m_PostMng.AddPostPackage(&PostPackage);
g_curPC->m_PostMng.SetOpenPost(g_curPC->m_PostMng.GetPostCount()-1);
GTH_SendMessage_PostWriteOpen(g_curPC, 1,-1);
}
void CPostFunc::GTH_SendMessage_PostWriteOpen(playerCharacter_t* pc, int reply, int error)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_POSTSYSTEM);
MSG_WriteByte(&netMessage, POSTSYSTEM_WRITEOPEN);
MSG_WriteByte(&netMessage, reply);
MSG_WriteByte(&netMessage, error);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CPostFunc::GTH_ProcessMessage_RequestPostList()
{
if ( g_curPC == NULL)
return;
g_DBGameServer->LoadPackageList(g_curPC);
}
void CPostFunc::
GTH_SendMessage_PostList(
playerCharacter_t* pc,
const enum tagGCPacket_POSTSYSTEM_OPEN::enumCode code)
{
CPostManager::PostPackage_t* pPostPackage = NULL;
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND );
MSG_WriteByte(&netMessage, GSC_POSTSYSTEM );
MSG_WriteByte(&netMessage, POSTSYSTEM_OPEN );
MSG_WriteByte(&netMessage, code);
int PostCount = pc->m_PostMng.GetPostCount();
MSG_WriteLong(&netMessage, PostCount);
for (int i =0; i < PostCount; i ++)
{
pPostPackage = pc->m_PostMng.GetPostPackage(i);
MSG_WriteLong( &netMessage, pPostPackage->iPostIdx );
MSG_WriteString( &netMessage, pPostPackage->szFromName );
MSG_WriteString( &netMessage, pPostPackage->szPostTitle );
MSG_WriteString( &netMessage, pPostPackage->szSendPostTime );
MSG_WriteString( &netMessage, pPostPackage->szMailStr );
MSG_WriteLong( &netMessage, (int)pPostPackage->MailState );
MSG_WriteLong( &netMessage, (int)pPostPackage->Nak );
MSG_WriteLong( &netMessage, (int)pPostPackage->PostSendType );
MSG_WriteLong( &netMessage, (int)pPostPackage->iRemainDays );
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CPostFunc::GTH_ProcessMessage_PostSend()
{
CPostManager::PostPackage_t* pPostPackage = NULL;
pPostPackage = g_curPC->m_PostMng.GetOpenPost();
if(NULL == pPostPackage){
GTH_SendMessage_PostSend(g_curPC, -1, 2);
return;
}
g_curPC->busyState = BUSY_STATE_NONE;
sstrncpy(pPostPackage->szFromName, MSG_ReadString(), NAMESTRING);
pPostPackage->szFromName[NAMESTRING] = NULL;
sstrncpy(pPostPackage->szPostTitle, MSG_ReadString(), CPostManager::POST_TITLESIZE);
pPostPackage->szPostTitle[CPostManager::POST_TITLESIZE]=NULL;
sstrncpy(pPostPackage->szMailStr, MSG_ReadString(), CPostManager::POST_STRSIZE);
pPostPackage->szMailStr[CPostManager::POST_STRSIZE] = NULL;
pPostPackage->Nak = MSG_ReadLong();
if(pPostPackage->Nak < 0){
g_PostFunc.GTH_ProcessMessage_MailBox_UndoInvenItem(g_curPC);
g_logSystem->Write("SavePackage Error!! : (ID: %s)", g_curPC->userID);
g_PostFunc.GTH_SendMessage_PostSend(g_curPC, FALSE,0);
return;
}
if ( g_curPC->curChargeSE - pPostPackage->Nak < 0 )
{
g_PostFunc.GTH_ProcessMessage_MailBox_UndoInvenItem(g_curPC);
g_logSystem->Write("SavePackage Error!! : (ID: %s)", g_curPC->userID);
g_PostFunc.GTH_SendMessage_PostSend(g_curPC, FALSE,0);
return;
}
g_DBGameServer->SavePackage(
g_curPC,
pPostPackage->szPostTitle,
pPostPackage->szMailStr,
pPostPackage->szFromName,
pPostPackage->Nak);
return;
}
void CPostFunc::GTH_SendMessage_PostSend(playerCharacter_t* pc, int reply, int errorIdx)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_POSTSYSTEM);
MSG_WriteByte(&netMessage, POSTSYSTEM_SEND);
MSG_WriteByte(&netMessage, reply);
MSG_WriteByte(&netMessage, errorIdx);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CPostFunc::GTH_ProcessMessage_MailBox()
{
int command;
command = MSG_ReadByte();
switch( command )
{
case MAILBOX_OPEN :
GTH_ProcessMessage_MailBox_Open();
break;
case MAILBOX_EXIT :
GTH_ProcessMessage_MailBox_Exit();
break;
case MAILBOX_ITEM :
GTH_ProcessMessage_MailBox_Item();
break;
case MAILBOX_RECEIVE_ITEMS:
GTH_ProcessMessage_MailBox_ReceiveItems(g_curPC);
break;
case MAILBOX_UNDOINVENITEM:
GTH_ProcessMessage_MailBox_UndoInvenItem(g_curPC);
break;
}
}
void CPostFunc::GTH_ProcessMessage_MailBox_UndoInvenItem(playerCharacter_t* pc)
{
CPostManager::PostPackage_t* pPostPackage = NULL;
pPostPackage = pc->m_PostMng.GetOpenPost();
if(NULL == pPostPackage)
{
GTH_SendMessage_MailBox_UndoInvenItem(pc, 1, -1);
return;
}
for(int idx=0; idx < CPostManager::MAX_ITEMCOUNT_IN_POSTPACKAGE; idx++)
{
if(pPostPackage->ItemBox[idx] < 0) continue;
GTH_AddMyInventory_ForRegsitedItem(pc,pPostPackage->ItemBox[idx]);
}
GTH_SendMessage_MailBox_UndoInvenItem(pc, 1, -1);
}
void CPostFunc::GTH_SendMessage_MailBox_UndoInvenItem(playerCharacter_t* pc, int reply, int errorIdx)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_MAILBOX);
MSG_WriteByte(&netMessage, MAILBOX_UNDOINVENITEM);
MSG_WriteLong(&netMessage, reply);
MSG_WriteByte(&netMessage, errorIdx);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CPostFunc::GTH_ProcessMessage_MailBox_Open()
{
int PostIdx = -1;
int PostType= -1;
PostType = MSG_ReadLong();
PostIdx = MSG_ReadLong();
g_curPC->busyState = BUSY_STATE_NONE;
if(g_curPC->m_PostMng.GetPostState() == CPostManager::POSTSYSTEM_READMODE)
{
g_curPC->m_PostMng.SetOpenPost(PostIdx);
if(NULL == g_curPC->m_PostMng.GetOpenPost()){
GTH_SendMessage_MailBox_Open(g_curPC, 1, -1, PostIdx);
return;
}
g_DBGameServer->OpenPost(g_curPC, PostType, g_curPC->m_PostMng.GetOpenPost()->iPostIdx);
return;
}
GTH_SendMessage_MailBox_Open(g_curPC, 1, -1, PostIdx);
}
void CPostFunc::GTH_SendMessage_MailBox_Open(playerCharacter_t* pc, int reply, int error, int PostIdx)
{
CPostManager::PostPackage_t *pPost = NULL;
pPost = pc->m_PostMng.GetPostPackage(PostIdx);
if(NULL == pPost){
reply = 0;
error = 1;
}
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_MAILBOX);
MSG_WriteByte(&netMessage, MAILBOX_OPEN);
MSG_WriteByte(&netMessage, reply);
if( reply > 0 )
{
MSG_WriteLong(&netMessage, PostIdx);
MSG_WriteLong(&netMessage, pPost->ItemNumber);
for(int i = 0; i < CPostManager::MAX_ITEMCOUNT_IN_POSTPACKAGE; i++)
MSG_WriteItem(&netMessage, &pPost->Items[i]);
}else{
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CPostFunc::GTH_ProcessMessage_MailBox_Item()
{
int pos = MSG_ReadByte();
if(g_curPC->m_PostMng.GetPostState() == CPostManager::POSTSYSTEM_READMODE ) {
GTH_SendMessage_MailBox_Item(g_curPC,NULL, -1, 1, TRUE, pos, 0);
return;
}
CPostManager::PostPackage_t* pPostPack = NULL;
pPostPack = g_curPC->m_PostMng.GetOpenPost();
if(NULL == pPostPack){
GTH_SendMessage_MailBox_Item(g_curPC,NULL, -1, 1, TRUE, pos, 0);
return;
}
if( g_curPC->mouseInventory >= 0 )
{
if(pPostPack->ItemBox[pos] >= 0)
{
int tempInven = g_curPC->mouseInventory;
g_curPC->mouseInventory = pPostPack->ItemBox[pos];
pPostPack->ItemBox[pos] = tempInven;
}
else
{
pPostPack->ItemBox[pos] = g_curPC->mouseInventory;
g_curPC->mouseInventory = -1;
}
}
else
{
g_curPC->mouseInventory = pPostPack->ItemBox[pos];
pPostPack->ItemBox[pos]=-1;
}
int itemIdx = pPostPack->ItemBox[pos];
int itemTableIdx = g_curPC->item[itemIdx].itemTableIdx;
GTH_SendMessage_MailBox_Item( g_curPC,pPostPack, 1, -1, FALSE, pos, itemTableIdx);
}
void CPostFunc::
GTH_SendMessage_MailBox_Item(
playerCharacter_t* pc,
const CPostManager::PostPackage_t* pPostPack,
int reply,
int error,
int isOwner,
int pos,
int itemTableIdx )
{
if((reply > 0) && (NULL == pPostPack)){
reply=-1;
error=1;
}
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_MAILBOX);
MSG_WriteByte(&netMessage, MAILBOX_ITEM);
MSG_WriteLong(&netMessage, reply);
if((reply > 0) && (NULL != pPostPack))
{
MSG_WriteByte(&netMessage, isOwner);
MSG_WriteByte(&netMessage, pos);
MSG_WriteShort(&netMessage, pc->mouseInventory );
MSG_WriteShort( &netMessage, pPostPack->ItemBox[pos] );
MSG_WriteShort(&netMessage, itemTableIdx);
}
else
{
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CPostFunc::GTH_ProcessMessage_MailBox_Exit()
{
GTH_SendMessage_MailBox_Exit(g_curPC);
g_DBGameServer->LoadPackageList(g_curPC);
}
void CPostFunc::GTH_SendMessage_MailBox_Exit(playerCharacter_t* pc)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_MAILBOX);
MSG_WriteByte(&netMessage, MAILBOX_EXIT);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CPostFunc::GTH_SendMessage_MailBox_ReceiveItems(playerCharacter_t* pc, int reply, int errorIdx)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_MAILBOX);
MSG_WriteByte(&netMessage, MAILBOX_RECEIVE_ITEMS);
MSG_WriteLong(&netMessage, reply);
if ( reply == 0)
MSG_WriteLong(&netMessage, errorIdx);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CPostFunc::GTH_ProcessMessage_PostWinExit()
{
g_curPC->busyState = BUSY_STATE_NONE;
g_curPC->m_PostMng.SetPostSystem(CPostManager::enumPostSystemMode::POSTSYSTEM_NONE);
NPC_DeleteNoticePC(&g_monster[g_curPC->npcIdx], g_curPC);
}
void CPostFunc::GTH_ProcessMessage_PostDelete()
{
int MaxCount = 0;
int PostIdx = -1;
int PostCount = 0;
std::vector<int> vPostType;
std::vector<int> vPostIdx;
MaxCount = MSG_ReadLong();
int HavePostCount = g_curPC->m_PostMng.GetPostCount();
if ( (MaxCount <= 0) || (MaxCount > HavePostCount)){
GTH_SendMessage_PostDelete(g_curPC, 0,1);
return;
}
for (PostCount = 0; PostCount < MaxCount; PostCount++){
PostIdx = MSG_ReadLong();
if((PostIdx < 0) || (PostIdx > HavePostCount)){
GTH_SendMessage_PostDelete(g_curPC, 0,1);
return;
}
CPostManager::PostPackage_t* pPostPack = NULL;
pPostPack = g_curPC->m_PostMng.GetPostPackage(PostIdx);
if(NULL == pPostPack){
GTH_SendMessage_PostDelete(g_curPC, 0,1);
return;
}
vPostType.push_back((int)pPostPack->PostSendType);
vPostIdx.push_back(pPostPack->iPostIdx);
}
for (PostCount = 0; PostCount < MaxCount; PostCount++){
g_DBGameServer->DeletePost(g_curPC,vPostType[PostCount],vPostIdx[PostCount]);
}
GTH_SendMessage_PostDelete(g_curPC, 1,-1);
}
void CPostFunc::GTH_SendMessage_PostDelete(playerCharacter_t* pc, int reply, int error)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_POSTSYSTEM);
MSG_WriteByte(&netMessage, POSTSYSTEM_DELETE);
MSG_WriteLong(&netMessage, reply);
if ( reply == 0)
MSG_WriteLong(&netMessage, error);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CPostFunc::GTH_ProcessMessage_PostState()
{
int reply = 1;
int error = -1;
int State = 0;
CPostManager::enumPostSystemMode inState;
State = MSG_ReadByte();
if(State == 0)
inState = CPostManager::POSTSYSTEM_WRITEMODE;
else
inState = CPostManager::POSTSYSTEM_READMODE;
g_curPC->m_PostMng.SetPostSystem(inState);
GTH_SendMessage_PostState(g_curPC, reply, error);
}
void CPostFunc::GTH_SendMessage_PostState(playerCharacter_t* pc, int reply, int error)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_POSTSYSTEM);
MSG_WriteByte(&netMessage, POSTSYSTEM_STATE);
MSG_WriteLong(&netMessage, reply);
if ( reply == 0)
MSG_WriteLong(&netMessage, error);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CPostFunc::
GTH_SendMessage_MailBox_Cnt(playerCharacter_t* pc,const int iUnReadedNum,const int iReadedNum)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND );
MSG_WriteByte(&netMessage, GSC_POSTSYSTEM );
MSG_WriteByte(&netMessage, POSTSYSTEM_NOTIFY );
MSG_WriteLong( &netMessage, iUnReadedNum);
MSG_WriteLong( &netMessage, iReadedNum);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
class CTempPlayerInventory{
private:
struct tagTempInventory{
int TableIdx;
int numberIdx;
};
struct tagTempInventory m_TempInventory[MAX_INVENTORY_SIZE];
public:
BOOL Insert(const item_t* pItem);
public:
CTempPlayerInventory(const playerCharacter_t* pPlayer);
~CTempPlayerInventory();
};
CTempPlayerInventory::CTempPlayerInventory(const playerCharacter_t* pPlayer)
{
int ItemArrayidx=-1;
int InventoryIdx=-1;
item_t* pItem=NULL;
itemTable_t* pItemTable=NULL;
for(InventoryIdx=0; InventoryIdx < MAX_INVENTORY_SIZE; InventoryIdx++){
m_TempInventory[InventoryIdx].TableIdx=-1;
m_TempInventory[InventoryIdx].numberIdx=-1;
pItem = gcpTools->GetMyItem((playerCharacter_t*)pPlayer,pPlayer->inventory[InventoryIdx]);
if(NULL == pItem) continue;
pItemTable = gcpTools->GetItemTablePointer(pItem->itemTableIdx);
if(NULL == pItemTable) continue;
m_TempInventory[InventoryIdx].TableIdx = pItem->itemTableIdx;
if(pItemTable->stackFlag) m_TempInventory[InventoryIdx].numberIdx= pItem->durability;
else m_TempInventory[InventoryIdx].numberIdx=-1;
}
}
CTempPlayerInventory::~CTempPlayerInventory()
{
}
BOOL CTempPlayerInventory::Insert(const item_t* pItem)
{
itemTable_t* pItemTable=NULL;
pItemTable = gcpTools->GetItemTablePointer(pItem->itemTableIdx);
if(NULL == pItemTable){
return TRUE;
}
int InventoryIdx=-1;
if(pItemTable->stackFlag){
for(InventoryIdx=0; InventoryIdx < MAX_INVENTORY_SIZE; InventoryIdx++){
if(m_TempInventory[InventoryIdx].TableIdx != pItem->itemTableIdx) continue;
int numberIdx = m_TempInventory[InventoryIdx].numberIdx + (pItem->durability + 1);
if(numberIdx >= MAX_COUNT_STACK_ITEM) return FALSE;
m_TempInventory[InventoryIdx].numberIdx = numberIdx;
return TRUE;
}
}
for(InventoryIdx=0; InventoryIdx < MAX_INVENTORY_SIZE; InventoryIdx++){
if(m_TempInventory[InventoryIdx].TableIdx >= 0) continue;
m_TempInventory[InventoryIdx].TableIdx = pItem->itemTableIdx;
m_TempInventory[InventoryIdx].numberIdx = pItem->durability;
return TRUE;
}
return FALSE;
}
BOOL CPostFunc::InsertCheck_atINVENTORY(
const playerCharacter_t* pPlayer,
const CPostManager::PostPackage_t* pPostPack)
{
class CTempPlayerInventory TempInventory(pPlayer);
const item_t* pPostItem=NULL;
for(int PostPackIdx=0; PostPackIdx < CPostManager::MAX_ITEMCOUNT_IN_POSTPACKAGE; PostPackIdx++){
pPostItem=&pPostPack->Items[PostPackIdx];
if(NULL == pPostItem) continue;
if(FALSE == TempInventory.Insert(pPostItem)) return FALSE;
}
return TRUE;
}
void CPostFunc::GTH_ProcessMessage_MailBox_ReceiveItems(playerCharacter_t* pPlayer)
{
if(NULL == pPlayer) return;
int PostPackageIdx=-1;
PostPackageIdx = MSG_ReadShort();
CPostManager::PostPackage_t* pPostPack = NULL;
pPostPack = pPlayer->m_PostMng.GetPostPackage(PostPackageIdx);
if(NULL == pPostPack){
GTH_SendMessage_MailBox_ReceiveItems(pPlayer,0,1);
return;
}
if( pPlayer->m_PostMng.GetPostState() != CPostManager::POSTSYSTEM_READMODE ){
GTH_SendMessage_MailBox_ReceiveItems(pPlayer,0,2);
return;
}
if ( (pPostPack->Nak <= 0) && (pPostPack->ItemNumber == 0)){
GTH_SendMessage_MailBox_ReceiveItems(pPlayer,0,4);
return;
}
if(FALSE == InsertCheck_atINVENTORY(pPlayer,pPostPack)){
GTH_SendMessage_MailBox_ReceiveItems(pPlayer,0,3);
return;
}
int Nak = pPlayer->curChargeSE + pPostPack->Nak;
if( Nak > MAX_OWN_NAK ){
GTH_SendMessage_MailBox_ReceiveItems(pPlayer,0,3);
return;
}
g_DBGameServer->DeletePostItems(pPlayer,(int)pPostPack->PostSendType, pPostPack->iPostIdx);
}
void CPostFunc::
GTH_ProcessMessage_MailBox_AddItemToPlayer(
playerCharacter_t* pPlayer,
const int DeletePostPackageIdx,
const BOOL bDelete)
{
CPostManager::PostPackage_t* pPostPack = NULL;
pPostPack = pPlayer->m_PostMng.GetOpenPost();
if((NULL == pPostPack) || (pPostPack->iPostIdx != DeletePostPackageIdx)){
g_logSystem->WriteToLog(pPlayer,LOG_CLASS_POSTSYSTEM,"%d;%d;%d;%d;;;",LOG_CLASS_POSTSYSTEM_RECEIVE_ERROR,2,0,LOG_CLASS_POSTSYSTEM_RECEIVE_ERROR_UNKNOWN_PACKAGE);
GTH_SendMessage_MailBox_ReceiveItems(pPlayer,0,5);
return;
}
if(FALSE == bDelete){
g_logSystem->WriteToLog(pPlayer,LOG_CLASS_POSTSYSTEM,"%d;%d;%d;%d;;;",LOG_CLASS_POSTSYSTEM_RECEIVE_ERROR,2,0,LOG_CLASS_POSTSYSTEM_RECEIVE_ERROR_NOT_DELETE_POST);
GTH_SendMessage_MailBox_ReceiveItems(pPlayer,0,5);
return;
}
int PostItemIdx=-1;
item_t* pPostItem=NULL;
itemTable_t* pPostItemTable=NULL;
for(PostItemIdx = 0; PostItemIdx < CPostManager::MAX_ITEMCOUNT_IN_POSTPACKAGE; PostItemIdx ++)
{
pPostItem=&pPostPack->Items[PostItemIdx];
if(pPostItem->itemTableIdx < 0 ) continue;
pPostItemTable = gcpTools->GetItemTablePointer(pPostItem->itemTableIdx);
if(NULL == pPostItemTable) continue;
if(TRUE == gcpTools->IsStackItem(pPostItem)){
int ItemArrayIdx = GTH_StackMyItem(pPlayer,pPostItem);
if( ItemArrayIdx >= 0 ){
item_t* pStackItem= gcpTools->GetMyItem(pPlayer,ItemArrayIdx);
if(NULL != pStackItem){
int numberIdx = pStackItem->durability + (pPostItem->durability + 1);
if(numberIdx >= MAX_COUNT_STACK_ITEM){
g_logSystem->WriteToLog(pPlayer,LOG_CLASS_POSTSYSTEM,"%d;%d;%d;%d;;%s;%s",LOG_CLASS_POSTSYSTEM_RECEIVE_ERROR,1,pPostItem->durability,LOG_CLASS_POSTSYSTEM_RECEIVE_ERROR_NOT_INSERT_INVENTORY,pPostItem->name,pPostPack->szFromName);
continue;
}
pStackItem->durability = numberIdx;
g_DBGameServer->SaveItem(pPlayer, pStackItem, ItemArrayIdx );
if(pPostPack->PostSendType == CPostManager::enumPostSendType::POST_SENDTYPE_WEB){
g_logSystem->WriteToLog(pPlayer,LOG_CLASS_POSTSYSTEM,"%d;%d;%d;;;%s;%s",LOG_CLASS_POSTSYSTEM_RECEIVE_WEB,1,pPostItem->durability,pPostItem->name, "FROM_WEB");
}else{
g_logSystem->WriteToLog(pPlayer,LOG_CLASS_POSTSYSTEM,"%d;%d;%d;;;%s;%s",LOG_CLASS_POSTSYSTEM_RECEIVE_CHA,1,pPostItem->durability,pPostItem->name, pPostPack->szFromName);
}
continue;
}
}
}
int inventoryPos = -1;
inventoryPos = GTH_FindEmptyInventoryPos(pPlayer);
if(inventoryPos < 0){
g_logSystem->WriteToLog(pPlayer,LOG_CLASS_POSTSYSTEM,"%d;%d;%d;%d;;%s;%s",LOG_CLASS_POSTSYSTEM_RECEIVE_ERROR,1,pPostItem->durability,LOG_CLASS_POSTSYSTEM_RECEIVE_ERROR_NOT_INSERT_INVENTORY,pPostItem->name,pPostPack->szFromName);
continue;
}
int itemArrayIdx = -1;
itemArrayIdx = GTH_AddMyItem( pPlayer,pPostItem);
if(itemArrayIdx < 0){
g_logSystem->WriteToLog(pPlayer,LOG_CLASS_POSTSYSTEM,"%d;%d;%d;%d;;%s;%s",LOG_CLASS_POSTSYSTEM_RECEIVE_ERROR,1,pPostItem->durability,LOG_CLASS_POSTSYSTEM_RECEIVE_ERROR_NOT_INSERT_INVENTORY,pPostItem->name,pPostPack->szFromName);
continue;
}
pPlayer->inventory[inventoryPos] = itemArrayIdx;
g_DBGameServer->AddItem(pPlayer, pPostItem, itemArrayIdx,"PostSystem");
if(pPostPack->PostSendType == CPostManager::enumPostSendType::POST_SENDTYPE_WEB){
g_logSystem->WriteToLog(pPlayer,LOG_CLASS_POSTSYSTEM,"%d;%d;%d;;;%s;%s",LOG_CLASS_POSTSYSTEM_RECEIVE_WEB,1,pPostItem->durability,pPostItem->name, "FROM_WEB");
}else{
g_logSystem->WriteToLog(pPlayer,LOG_CLASS_POSTSYSTEM,"%d;%d;%d;;;%s;%s",LOG_CLASS_POSTSYSTEM_RECEIVE_CHA,1,pPostItem->durability,pPostItem->name, pPostPack->szFromName);
}
}
for(PostItemIdx = 0; PostItemIdx < CPostManager::MAX_ITEMCOUNT_IN_POSTPACKAGE; PostItemIdx ++){
InitItem(&pPostPack->Items[PostItemIdx]);
pPostPack->ItemNumber --;
}
if(pPostPack->Nak > 0){
if(pPostPack->PostSendType == CPostManager::enumPostSendType::POST_SENDTYPE_WEB){
g_logSystem->WriteToLog(pPlayer,LOG_CLASS_POSTSYSTEM,"%d;%d;%d;;;;%s",LOG_CLASS_POSTSYSTEM_RECEIVE_WEB,0,pPostPack->Nak, "FROM_WEB");
}else{
g_logSystem->WriteToLog(pPlayer,LOG_CLASS_POSTSYSTEM,"%d;%d;%d;;;;%s",LOG_CLASS_POSTSYSTEM_RECEIVE_CHA,0,pPostPack->Nak, pPostPack->szFromName);
}
pPlayer->curChargeSE += pPostPack->Nak;
pPostPack->Nak = 0;
g_DBGameServer->SaveChaPackageNak(pPlayer, pPostPack);
}
GTH_SendMessage_MailBox_ReceiveItems(pPlayer,1,0);
}
| C++ |
#include "../Global.h"
#include "YDCDamageCal.h"
#include "../Tools/CTools.h"
extern CTools* gcpTools;
YDCDamageCal::YDCDamageCal()
{
m_bOK=FALSE;
m_bOK=TRUE;
}
YDCDamageCal::~YDCDamageCal()
{
}
BOOL YDCDamageCal::isOK(void) const
{
return m_bOK;
}
void YDCDamageCal::YDCalResistance(
const struct tagYDCharactor* in_pDefenceCharactor,
struct tagYDResistanceVar& out_ResistanceVar)
{
out_ResistanceVar.physics = in_pDefenceCharactor->calDefensePower;
out_ResistanceVar.positive = in_pDefenceCharactor->calPositiveRes;
out_ResistanceVar.negative = in_pDefenceCharactor->calNegativeRes;
if( out_ResistanceVar.positive < -100.0f ) out_ResistanceVar.positive = -100.0f;
if( out_ResistanceVar.positive > 75.0f ) out_ResistanceVar.positive = 75.0f;
if( out_ResistanceVar.negative < -100.0f ) out_ResistanceVar.negative = -100.0f;
if( out_ResistanceVar.negative > 75.0f ) out_ResistanceVar.negative = 75.0f;
out_ResistanceVar.physics *= ( 1 + (float) in_pDefenceCharactor->optValue[OV_SKILL_FINAL_ADD_DEFENCE_RATE] * 0.01f);
}
inline void YDCDamageCal::YDMakeCharactorStruct(struct tagYDCharactor& out_Charactor,const playerCharacter_t* in_pPlayer)
{
out_Charactor.Entity.Type = in_pPlayer->entityType;
out_Charactor.Entity.Idx = in_pPlayer->idx;
memcpy(out_Charactor.optValue, in_pPlayer->optValue, sizeof(float) * NUM_OPTION_VALUE);
out_Charactor.calDefensePower =in_pPlayer->calDefensePower;
out_Charactor.calPositiveRes =in_pPlayer->calPositiveRes;
out_Charactor.calNegativeRes =in_pPlayer->calNegativeRes;
out_Charactor.level =in_pPlayer->level;
out_Charactor.calCriticalDmg =in_pPlayer->calCriticalDmg;
out_Charactor.calMaxRA =in_pPlayer->calMaxRA;
}
inline void YDCDamageCal::YDMakeCharactorStruct(struct tagYDCharactor& out_Charactor,const monsterCharacter_t* in_pMonster)
{
out_Charactor.Entity.Type = in_pMonster->entityType;
out_Charactor.Entity.Idx = in_pMonster->idx;
memcpy(out_Charactor.optValue, in_pMonster->optValue, sizeof(float) * NUM_OPTION_VALUE);
out_Charactor.calDefensePower = in_pMonster->calDefensePower;
out_Charactor.calPositiveRes = in_pMonster->calPositiveRes;
out_Charactor.calNegativeRes = in_pMonster->calNegativeRes;
out_Charactor.level = in_pMonster->basic.level;;
out_Charactor.calCriticalDmg = in_pMonster->calCriticalDmg;
out_Charactor.calMaxRA = in_pMonster->calMaxRA;
}
void YDCDamageCal::YDCalAdditionalDamage(
const struct tagYDCharactor& in_pDefenceCharactor,
const message_t* in_pMessage,
struct tagYDDamageVar& out_AdditionalDamageVar)
{
out_AdditionalDamageVar.physics =0;
out_AdditionalDamageVar.positive=0;
out_AdditionalDamageVar.negative=0;
if(in_pMessage->data[MSG_ATKDATA_ETC_INFO] == MSGINFO_ATK_ETC_RA_RATIO_DAMAGE)
{
out_AdditionalDamageVar.physics = in_pDefenceCharactor.calMaxRA * ( (float) in_pMessage->data[MSG_ATKDATA_ETC_DATA_1] * 0.01f);
out_AdditionalDamageVar.positive = in_pDefenceCharactor.calMaxRA * ( (float) in_pMessage->data[MSG_ATKDATA_ETC_DATA_0] * 0.01f);
}
}
void YDCDamageCal::YDCalDamage(const message_t* in_pMessage,struct tagYDDamageVar& out_DamageVar)
{
out_DamageVar.physics =in_pMessage->data[MSG_ATKDATA_PHYSIC_DMG];
out_DamageVar.positive=in_pMessage->data[MSG_ATKDATA_POSITIVE_DMG];
out_DamageVar.negative=in_pMessage->data[MSG_ATKDATA_NEGATIVE_DMG];
}
void YDCDamageCal::YDApplyResistanceAtDamage(
const message_t* in_pMessage,
const struct tagYDDamageVar& in_DamageVar,
const struct tagYDDamageVar& in_AdditionalDamageVar,
const struct tagYDResistanceVar& in_ResistanceVar,
struct tagYDDamageVar& out_ApplyDamageVar,
int in_AttackerLevel)
{
tagYDResistanceVar ResistanceRatio = {0,0,0};
int MaxDefenseTableIdx = in_AttackerLevel-1;
if ( MaxDefenseTableIdx >= MAX_NUMBER_OF_LEVEL)
MaxDefenseTableIdx = MAX_NUMBER_OF_LEVEL -1;
if ( (MaxDefenseTableIdx < 0) ||
(MaxDefenseTableIdx >= MAX_NUMBER_OF_LEVEL))
return;
int DefenseVar = g_MaxDefneseTable[MaxDefenseTableIdx].MaxDefense;
ResistanceRatio.physics = in_ResistanceVar.physics / DefenseVar;
ResistanceRatio.negative = in_ResistanceVar.negative/ DefenseVar;
ResistanceRatio.positive = in_ResistanceVar.positive/ DefenseVar;
if ( ResistanceRatio.physics < 0 ) ResistanceRatio.physics =0;
if ( ResistanceRatio.physics > 0.8 ) ResistanceRatio.physics=0.8;
if ( ResistanceRatio.negative < 0 ) ResistanceRatio.negative=0;
if ( ResistanceRatio.negative > 0.8 ) ResistanceRatio.negative=0.8;
if ( ResistanceRatio.positive < 0 ) ResistanceRatio.positive=0;
if ( ResistanceRatio.positive > 0.8 ) ResistanceRatio.positive=0.8;
out_ApplyDamageVar.physics = (in_DamageVar.physics + in_AdditionalDamageVar.physics) * (1.0f - ResistanceRatio.physics);
out_ApplyDamageVar.positive = (in_DamageVar.positive + in_AdditionalDamageVar.positive) * (1.0f - ResistanceRatio.positive);
out_ApplyDamageVar.negative = (in_DamageVar.negative + in_AdditionalDamageVar.negative) * (1.0f - ResistanceRatio.negative);
if( in_pMessage->data[MSG_ATKDATA_ATTACK_TYPE] == MSGINFO_ATK_TYPE_NONE )
{
out_ApplyDamageVar = in_DamageVar;
}
if( out_ApplyDamageVar.physics < 1 ) out_ApplyDamageVar.physics = 1;
if( out_ApplyDamageVar.positive < 1 ) out_ApplyDamageVar.positive = 1;
if( out_ApplyDamageVar.negative < 1 ) out_ApplyDamageVar.negative = 1;
}
void YDCDamageCal::YDApplyRatioAtDamage(
const message_t* in_pMessage,
const struct tagYDCharactor& in_AttackCharactor,
const struct tagYDCharactor& in_DefenceCharactor,
const struct tagYDDamageVar& in_ApplyDamageVar,
struct tagYDDamageVar& out_ApplyRatioDamageVar)
{
out_ApplyRatioDamageVar = in_ApplyDamageVar;
if( in_pMessage->data[MSG_ATKDATA_STUN_FLAG] > 0)
{
out_ApplyRatioDamageVar.physics = out_ApplyRatioDamageVar.physics * 2;
if(in_AttackCharactor.Entity.Type == ENTITY_PC)
{
out_ApplyRatioDamageVar.physics +=
out_ApplyRatioDamageVar.physics * in_AttackCharactor.optValue[OV_CRITICAL_DMG_RATE] * 0.01f;
out_ApplyRatioDamageVar.physics += in_AttackCharactor.calCriticalDmg;
}
}
if((in_AttackCharactor.Entity.Type == ENTITY_PC) && (in_DefenceCharactor.Entity.Type == ENTITY_MONSTER))
{
monsterCharacter_t* pDefenceMonster = gcpTools->GetMonsterRecordPointer(in_DefenceCharactor.Entity.Idx);
if(NULL != pDefenceMonster){
int monsterType = pDefenceMonster->basic.type;
if((monsterType >= 0) && (monsterType <= 4)){
int optionPhyGroupIdx = monsterType + OV_CHE_PHY_DMG_RATE;
int optionMagGroupIdx = monsterType + OV_CHE_MAG_DMG_RATE;
out_ApplyRatioDamageVar.physics += out_ApplyRatioDamageVar.physics * in_AttackCharactor.optValue[optionPhyGroupIdx] * 0.01f;
out_ApplyRatioDamageVar.positive += out_ApplyRatioDamageVar.positive * in_AttackCharactor.optValue[optionMagGroupIdx] * 0.01f;
out_ApplyRatioDamageVar.negative += out_ApplyRatioDamageVar.negative * in_AttackCharactor.optValue[optionMagGroupIdx] * 0.01f;
}
}
}
out_ApplyRatioDamageVar.physics *= ( 1 + (float) in_AttackCharactor.optValue[OV_SKILL_FINAL_ADD_PHY_DMG_RATE] * 0.01f);
out_ApplyRatioDamageVar.positive *= ( 1 + (float) in_AttackCharactor.optValue[OV_SKILL_FINAL_ADD_MYSTERY_POS_DMG_RATE] * 0.01f);
out_ApplyRatioDamageVar.negative *= ( 1 + (float) in_AttackCharactor.optValue[OV_SKILL_FINAL_ADD_MYSTERY_NEG_DMG_RATE] * 0.01f);
}
int YDCDamageCal::YDGetDamage( int TargetEntityIdx, int TargetEntityType, message_t* message, int eachDmg[] )
{
eachDmg[0] = 0;
eachDmg[1] = 0;
eachDmg[2] = 0;
struct tagYDCharactor AttackCharactor;
struct tagYDCharactor DefenceCharactor;
int AttackerLevel =1;
switch(message->fromType){
case ENTITY_PC:
{
playerCharacter_t* pAttackPlayer=NULL;
pAttackPlayer = gcpTools->GetPlayerRecordPointer(message->fromIdx);
if(NULL == pAttackPlayer) return 0;
YDMakeCharactorStruct(AttackCharactor,pAttackPlayer);
AttackerLevel = pAttackPlayer->level;
}
break;
case ENTITY_MONSTER:
case ENTITY_NPC:
{
monsterCharacter_t* pAttackMonster=NULL;
pAttackMonster = gcpTools->GetMonsterRecordPointer(message->fromIdx);
if(NULL == pAttackMonster) return 0;
YDMakeCharactorStruct(AttackCharactor,pAttackMonster);
AttackerLevel = pAttackMonster->basic.level;
}
break;
default:
return 0;
}
switch(TargetEntityType){
case ENTITY_PC:
{
playerCharacter_t* pDefencePlayer=NULL;
pDefencePlayer = gcpTools->GetPlayerRecordPointer(TargetEntityIdx);
if(NULL == pDefencePlayer) return 0;
YDMakeCharactorStruct(DefenceCharactor,pDefencePlayer);
}
break;
case ENTITY_MONSTER:
case ENTITY_NPC:
{
monsterCharacter_t* pDefencetMonster=NULL;
pDefencetMonster = gcpTools->GetMonsterRecordPointer(TargetEntityIdx);
if(NULL == pDefencetMonster) return 0;
YDMakeCharactorStruct(DefenceCharactor,pDefencetMonster);
}
break;
default:
return 0;
}
struct tagYDDamageVar DamageVar={0,0,0};
YDCalDamage(message,DamageVar);
struct tagYDDamageVar AdditionalDamageVar={0,0,0};
YDCalAdditionalDamage(DefenceCharactor,message,AdditionalDamageVar);
struct tagYDResistanceVar ResistanceVar={0,0,0};
YDCalResistance(&DefenceCharactor,ResistanceVar);
struct tagYDDamageVar ApplyDamageVar={0,0,0};
YDApplyResistanceAtDamage(message,DamageVar,AdditionalDamageVar,ResistanceVar,ApplyDamageVar, AttackerLevel);
struct tagYDDamageVar ApplyRatioDamageVar={0,0,0};
YDApplyRatioAtDamage(message,AttackCharactor,DefenceCharactor,ApplyDamageVar,ApplyRatioDamageVar);
int dmg = ApplyRatioDamageVar.physics + ApplyRatioDamageVar.positive + ApplyRatioDamageVar.negative;
if( dmg <= 0 ) dmg=1;
if((AttackCharactor.Entity.Type == ENTITY_PC) && (DefenceCharactor.Entity.Type == ENTITY_PC))
dmg = (int)( (float)dmg * 0.7f );
eachDmg[0] = ApplyRatioDamageVar.physics;
eachDmg[1] = ApplyRatioDamageVar.positive;
eachDmg[2] = ApplyRatioDamageVar.negative;
return dmg;
}
| C++ |
#define F_PROBABILITY( p ) (p > rand() % 1000 ? 1 : 0)
#define F_RANDOMBETWEEN(a, b) ( a + rand() % (b - a + 1) )
#define F_HOTKEY(t, i) (t < 1 ? i : ( t < 2 ? MASK_HOTKEY_ACTION + i : MASK_HOTKEY_ITEM + i) )
#define MAX_PARTY_NUMBER 500
#define MOVE_SPEED 0.08
#define RUN_SPEED 0.2
#define TURN_SCALE 0.12
#define SAFE_SKILL_INDEX(p) (p < 0 || p >= MAX_NUMBER_OF_SKILL) ? 0 : 1
#define GRID_SCALE 3
#define SPEED_CONSTANT 0.033
#define RUN_SCALE 2
#define MONSTER_RUN_SCALE 1.5
#define BACK_SCALE 0.5f
#define MAX_MEMBER_SERVER 10
#define MAX_SERVICE_WORLD 10
#define AVAILABLE_DISTANCE_DROPITEM 100
#define AVAILABLE_DISTANCE_PICKUPITEM 100
#define AVAILABLE_DISTANCE_ENTITYMENU 200
#define AVAILABLE_DISTANCE_PCMENU 400
#define PC_AUTO_RECOVERY_DELAY 3000
#define MONSTER_AUTO_RECOVERY_DELAY 3000
#define PC_EPACK_USE_RA_DELAY 3000
#define PC_EPACK_USE_SA_DELAY 3000
#define CANCEL_TRANSFORM_SKILL_INDEX 3000
#define PC_DECEREASE_WEAPON_DURABILITY_PROBABILITY 1.0f
#define PC_DECEREASE_DEFENSE_DURABILITY_PROBABILITY 1.0f
#define PC_DECEREASE_PROTECTOR_DURABILITY_PROBABILITY 0.4f
#define PC_DECEREASE_UPPER_DURABILITY_PROBABILITY 0.3f
#define PC_DECEREASE_LOWER_DURABILITY_PROBABILITY 0.2f
#define PC_DECEREASE_BOOTS_DURABILITY_PROBABILITY 0.05f
#define PC_DECEREASE_GLOVES_DURABILITY_PROBABILITY 0.05f
#define PC_DECEREASE_AIR_DURABILITY_PROBABILITY 0.0f
#define PC_FALL_DAMAGE_HEIGHT 300.0f
#define MAX_COUNT_STACK_ITEM 9999
#define MAX_OWN_NAK 1000000000
#define MAX_MASTERSERVER 10
enum
{
GTH_LANGUAGE_TYPE_KOREAN = 0,
GTH_LANGUAGE_TYPE_ENGLISH,
GTH_LANGUAGE_TYPE_JAPANESE,
GTH_LANGUAGE_TYPE_SIMPLIFIED_CHINESE,
GTH_LANGUAGE_TYPE_TRADITIONAL_CHINESE,
};
typedef struct
{
char serverGroupName[NAMESTRING];
int serverGroupNo;
char gameServerName[SERVERSTRING];
int gameServerNo;
char serviceIP[IPSTRING];
int servicePort;
char localIP[IPSTRING];
int localPort;
int masterServerNumber;
char masterServerIP[MAX_MASTERSERVER][IPSTRING];
int masterServerPort[MAX_MASTERSERVER];
int isManager;
char managerServerIP[IPSTRING];
int managerServerPort;
int serviceWorldNumber;
int serviceWorldList[MAX_SERVICE_WORLD];
int ServiceIsPkMapNumber;
int ServiceIsPkMapList[MAX_SERVICE_WORLD];
int odbcDSNType;
char accountDatabase[DATABASESTRING];
char gameDatabase[DATABASESTRING];
int gameSyncTime;
int createLog;
int createDebug;
int languageType;
int isTestServer;
char serverLocation[16];
char billingServerIP[IPSTRING];
int billingServerPort;
BOOL bCheckBilling;
int resendTime;
BOOL isDanBattleMap;
BOOL bPremium;
struct tagTerra{
BOOL bBilling;
}Terra;
BOOL bAhnLab;
} i3gameServerConfig_t;
#define MAX_COUNT_ITEM_UPGRADE_TYPE 10
typedef struct
{
float successPro[MAX_COUNT_ITEM_UPGRADE_TYPE+1];
int cost[MAX_COUNT_ITEM_UPGRADE_TYPE+1];
float vanishPro[MAX_COUNT_ITEM_UPGRADE_TYPE+1];
float gradeDownPro[MAX_COUNT_ITEM_UPGRADE_TYPE+1];
int gradeDownLevel[MAX_COUNT_ITEM_UPGRADE_TYPE+1];
} itemUpgradeProbabilityTable_t;
typedef struct
{
float successPro;
int cost;
float vanishPro;
float gradePro[5];
} optionGambleStoneTable_t;
#define MAX_GAMBLE_SELECTOPTION 7
typedef struct
{
int SelectOptionCount;
float SelectOptionRate;
float SelectOptionGraderate[MAX_NUMBER_OF_OPTION_VALUE_GRADE];
} gambleSelectOptionTable_t;
#define MAX_GAMBLESTONE 2
#define MAX_ITEMRARITY 5
#define MAX_GAMBLESTONE 2
typedef struct
{
vec3_t StartPos;
int StartworldIdx;
vec3_t TargetPos;
int TargetWorldIdx;
vec3_t TargetPos2;
int TargetWorldIdx2;
} DanBattlePortalInfo;
enum
{
DANBATTLE_START_PORTAL,
DANBATTLE_ATEAM_PORTAL,
DANBATTLE_BTEAM_PORTAL,
MAX_BATTLE_PORTAL
};
enum
{
DANB_WIN_DAN,
DANB_WIN_USER,
DANB_LOOSE_DAN,
DANB_LOOSE_USER,
DANB_MAX_REWARD
};
typedef struct {
float m_fbattlein_x;
float m_fbattlein_y;
float m_fbattlein_z;
float m_fbattlein_yaw;
} gonryunFieldPos_t;
#include "../GonryunPracticeBattle/CGonryunPractice_ProcessCtrl.h"
typedef struct {
DWORD PCBStatusTime[CGonryunPractice_ProcessCtrl::Step::STEP_MAX];
int m_iminiLevel;
int m_imaxLevel;
int m_idifferLevel;
int m_iroyalty;
int m_ibattingRoyalty;
int m_iuseCount;
int m_isyenminilevel;
int m_isyenmaxlevel;
float fExpRate;
float fItemRate;
gonryunFieldPos_t m_tarayanReaderPos;
gonryunFieldPos_t m_tarayanOpenentPos;
gonryunFieldPos_t m_tarayanwinnerOutPos;
gonryunFieldPos_t m_tarayandefeatorOutPos;
gonryunFieldPos_t m_tasyenReaderPos;
gonryunFieldPos_t m_tasyenOpenentPos;
gonryunFieldPos_t m_tsyenOutPos;
vec3_t origin_ArayanOutPos;
vec3_t origin_syenOutPos;
float pcpBattleIn;
} gonryunBattle_t;
struct tagHelperLevelPoint
{
int iLevel1;
int iLevel4;
int iLevel10;
int iLevel20;
int iLevel30;
};
typedef struct
{
float expRate;
float nseRate;
float itemDropRate;
float genCapabilityRate;
int cheatEnable;
itemUpgradeProbabilityTable_t leafStoneProTbl;
itemUpgradeProbabilityTable_t madStoneProTbl;
itemUpgradeProbabilityTable_t waveStoneProTbl;
itemUpgradeProbabilityTable_t fireStoneProTbl;
itemUpgradeProbabilityTable_t artStoneProTbl;
optionGambleStoneTable_t gambleTable[MAX_GAMBLESTONE];
float dieItemLossRate[NUM_CHAOS_TYPE];
float dieExpLossRate[NUM_CHAOS_TYPE];
int worldChattingPrice;
gambleSelectOptionTable_t gambleSelectOptionTable[MAX_GAMBLE_SELECTOPTION];
float gambleitemSelectRate[MAX_ITEMRARITY];
int GamblePriceRate;
int DanBattlePrice;
DWORD danBattleStatusTime[DBTL_STATUS_MAX];
DanBattlePortalInfo danbattlePortal[MAX_BATTLE_PORTAL];
int danBattleReward[DANB_MAX_REWARD];
int danMarkChangeDelayHour;
DWORD PCBStatusTime[CGonryunPractice_ProcessCtrl::Step::STEP_MAX];
gonryunBattle_t PCBGonryunCondition;
struct tagHelperLevelPoint HelperLevelPoint;
struct CashMallItem_OptionStone::CashMallItemLogic
OptionStoneItemLogic[CashMallItem_OptionStone::MAX_NUMBER_OF_STONE];
float m_SpawnPosOverRate;
} gthGameLogicCofing_t;
typedef struct
{
int idx;
int active;
int isManager;
unsigned int updateTime;
char name[NAMESTRING];
char hostName[HOSTNAMESTRING];
char serviceIP[IPSTRING];
int servicePort;
char localIP[IPSTRING];
int localPort;
int serviceWorldNumber;
int serviceWorldList[MAX_SERVICE_WORLD];
int curClientNumber;
int maxClientNumber;
i3socket_t sock;
} memberServer_t;
typedef struct
{
__int64 totalexp;
__int64 exp;
__int64 totalGenExp;
__int64 genExp;
} expTable_t;
typedef struct
{
int genCapability[10];
int limitGenLevel[10];
} skillGradeClass_t;
typedef struct
{
int genCapability[100];
} genCapabilityTable_t;
typedef struct {
int Attacklevel;
int MaxDefense;
}MaxDefense_t;
#define BONUS_STATUS_POINT_LEVEL_UP 4
#define BONUS_SKILL_POINT_GEN_LEVEL_UP 1
void GTH_InitGameServer();
float GTH_GetDistance(vec3_t s, vec3_t t);
float GTH_GetDistance2D(vec3_t s, vec3_t t);
void GTH_SaveData_AlivedClient();
int GTH_GetHeightFromCollisionMap( int worldIdx, vec3_t position );
int GTH_GetLocalWorldIdx( int worldIdx );
int GTH_GetEmptyAffectIdx( playerCharacter_t *pc );
int GTH_GetWeaponItemIdx( playerCharacter_t *pc );
int GTH_GetWeaponClass( playerCharacter_t *pc );
int GTH_OpenStore( int idx );
float GTH_GetAffectHitRate( void *attacker, int attackerType, void *defender, int defenderType, int type );
float GTH_GetHitRate( void *attacker, int attackerType, void *defender, int defenderType, int addHitPower = 0 );
float GTH_GetMagicHitRate( void *attacker, int attackerType, void *defender, int defenderType );
float GTH_GetCriticalRate( void *attacker, int attackerType, void *defender, int defenderType );
void GTH_GetExpFromLevelDiffer( int levelDiffer, int &exp, int &genExp, int &genCapability );
int GTH_IsSharingParty( monsterCharacter_t *m, playerCharacter_t *pc );
void GTH_SharingPartyLoot( monsterCharacter_t *m, playerCharacter_t *pc, int exp, int genExp, int lootNSE, int genCapability, int atkConIdx, int defConIdx );
int GTH_MakePortal( int makerType, int makerIdx, int keepTime, int numPerson, int worldIdx, vec3_t position, int targetWorldIdx, vec3_t targetPosition );
void GTH_TransportWorldWithPortal( playerCharacter_t *pc, itemObject_t *itemObject );
void GTH_TransportWorldWithNPC( playerCharacter_t *pc, int worldIdx, vec3_t position );
int GTH_IsEtherealForm( playerCharacter_t *pc );
int GTH_IsValidContributionPoint( monsterCharacter_t *m, playerCharacter_t *pc, int idx );
void GTH_InitContributionPoint( monsterCharacter_t *m );
int GTH_AddAtkContributionPoint( monsterCharacter_t *m, int entityType, int entityIdx, int point );
int GTH_AddDefContributionPoint( monsterCharacter_t *m, int entityType, int entityIdx, int point );
float GTH_ConvertAttackDelay( float currAtkDelay, float atkSpdRate );
int GTH_GetNextLevel( __int64& exp );
int GTH_GetNextGenLevel( __int64& exp );
int GTH_CheckJob( playerCharacter_t *pc, int j0 = 0, int j1 = 0, int j2 = 0, int j3 = 0 );
int GTH_CheckJob( int job, int reqJob );
int GTH_CheckRequire( playerCharacter_t *pc, int requireType, void* pReq );
bool GTH_CheckWearPosion( playerCharacter_t *pc );
int GTH_GetGenTypeFromJob( int pcJob );
int GTH_GetEquipPos( item_t *item, int equipPos );
int GTH_IsRepairItem( item_t *item );
int GTH_GetAllRepairCost( playerCharacter_t* pc, int curSE );
int GTH_GetRepairCost( item_t* item, int curSE, int &checkDur );
int GTH_IsConsumptiveItem( item_t* item );
int GTH_IsStackItem( item_t * item );
int GTH_CheckStackItem( item_t* item1, item_t* item2 );
int GTH_GetBuyPrice( item_t* item );
int GTH_GetSellPrice( item_t* item );
int GTH_GetDepotPrice( playerCharacter_t *pc, item_t *item );
float GTH_GetWeaponTypeBonusPhyDamage( playerCharacter_t *pc, item_t *item );
float GTH_GetWeaponTypeBonusMagDamage( playerCharacter_t *pc, item_t *item );
void GTH_AnalyzeAttackMessageEtcInfo( message_t *message, int eachDmg[] );
int GTH_SetTrainMonster( playerCharacter_t *pc, monsterCharacter_t *mon );
void GTH_UpdateTrainMonster( playerCharacter_t *pc );
void GTH_DeleteTrainMonster( playerCharacter_t *pc, monsterCharacter_t *mon );
int LoadExpTableForServer( char* filename );
int LoadGenExpTableForServer( char* filename );
int LoadStoreTableForServer( char* filename );
int LoadBindingTableForServer( char* filename );
int LoadScriptInfoTableForServer( char* filename );
int LoadGenCapabilityTable( char *filename );
int LoadItemCraftTableForServer( char* filename );
int GetChaosClass( playerCharacter_t *pc );
void AddChaosPoint( playerCharacter_t *attacker, playerCharacter_t *defender );
void DecChaosPoint( playerCharacter_t *pc );
void SetChaosGeneral( playerCharacter_t *attacker, playerCharacter_t *defender );
void GTH_PickUpNak( playerCharacter_t *pc, itemObject_t *itemObject );
void GetWord(int index, const char *source, char* token);
int IsPKDisableWorld( int worldIdx );
int IsPvPEnablePosition( int worldIdx, vec3_t pos);
void GTH_PC_LevelUp( playerCharacter_t *pc, int newLevel );
void GTH_PC_GenLevelUp( playerCharacter_t* pc, int newGenLevel );
float GetEpackRechargePrice_RA( int onceRecovery, float cost, int level );
float GetEpackRechargePrice_SA( int onceRecovery, float cost, int level );
bool CollectItemForGamble(GambleItem_t GambleItem[] );
int GetGambleItemAvallableOn( int availableon );
void SelectGambleItem(storeStruct_t* Makestore, storeStruct_t* Gamblestore, int pcidx);
int SelectCollectedItem(storeItem_t* pItem);
int GTH_MakePortal_fordan( int LootType, int makerIdx, int keepTime, int worldIdx, vec3_t position, int targetWorldIdx, vec3_t targetPosition , int targetWorldIdx2, vec3_t targetPosition2 );
BOOL IsValidHotKey_Skill(const playerCharacter_t *pc, const int HotkeyIdx);
void GTH_PartyRandomItemDivide(playerCharacter_t *pc,itemObject_t *itemObject);
void GTH_PartyOrderItemDivide(playerCharacter_t *pc,itemObject_t *itemObject);
BOOL GTH_IsEquipItem(playerCharacter_t* pPc);
BOOL GTH_IsAwakenJob(playerCharacter_t* pPc);
BOOL GTH_ClearAwakenJob(playerCharacter_t *pPC, std::vector<int>* pVSkill);
int GetAwakenQuestIdx(int pcjob);
void DeleteSkill(playerCharacter_t* pPc, int SkillIdx);
BOOL GTH_IsHaveItem(playerCharacter_t* pPc, int itemTableIdx, int StackCount);
int LoadMax_Defense_table( char* filename );
void PkTimeAutoProcess(); | C++ |
#include "../Global.h"
void GTH_ProcessMessage_BroadCastDanBatttStatus()
{
NewDanBattleSystem::DanBattleInfo::enumBattleStatus status =
(NewDanBattleSystem::DanBattleInfo::enumBattleStatus)MSG_ReadLong();
int GuildIdx = MSG_ReadLong();
int EnemyGuildIdx = MSG_ReadLong();
int nWorldIdx = MSG_ReadLong();
int Value = MSG_ReadLong();
int Value2 = MSG_ReadLong();
GTH_SendMessage_BroadCastDanBattleStatus(status, GuildIdx, EnemyGuildIdx, nWorldIdx, Value, Value2);
}
void GTH_SendMessage_BroadCastDanBattleStatus(NewDanBattleSystem::DanBattleInfo::enumBattleStatus status,
int nGuildIdx,
int nEnemyGuildIDx,
int nWorldIdx,
int value,
int value2)
{
if ( g_config.isManager == FALSE)
{
GTH_SendMessage_DanBattleStatusToManager(status, nGuildIdx, nEnemyGuildIDx, nWorldIdx, value, value2);
}
else{
switch(status){
case NewDanBattleSystem::DanBattleInfo::enumBattleStatus::BATTLESTATUS_READY:
GTH_ProcessMessage_NewDanBattleReady(nGuildIdx, nEnemyGuildIDx, nWorldIdx, value, value2);
GTH_SendMessage_DanBattleStatusToMemberServer_Ready(nGuildIdx, nEnemyGuildIDx, nWorldIdx, value, value2);
break;
case NewDanBattleSystem::DanBattleInfo::enumBattleStatus::BATTLESTATUS_BATTLE:
GTH_ProcessMessage_NewDanBattleStart(nGuildIdx, nEnemyGuildIDx, nWorldIdx, value);
GTH_SendMessage_DanBattleStatusToMemberServer_Start(nGuildIdx, nEnemyGuildIDx, nWorldIdx, value);
break;
case NewDanBattleSystem::DanBattleInfo::enumBattleStatus::BATTLESTATUS_END:
GTH_ProcessMessage_NewDanBattleEnd(nGuildIdx, nEnemyGuildIDx, nWorldIdx, value);
GTH_SendMessage_DanBattleStatusToMemberServer_End(nGuildIdx, nEnemyGuildIDx, nWorldIdx, value);
break;
default:
return;
}
}
}
void GTH_SendMessage_DanBattleStatusToManager(NewDanBattleSystem::DanBattleInfo::enumBattleStatus status,
int nGuildIdx,
int nEnemyGuildIdx,
int nWorldIdx,
int value,
int value2)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, NEW_DANBATTLE);
MSG_WriteShort(&netMessage, SS_DAN_BATTLE_BROADCAST);
MSG_WriteLong(&netMessage, status);
MSG_WriteLong(&netMessage, nGuildIdx);
MSG_WriteLong(&netMessage, nEnemyGuildIdx);
MSG_WriteLong(&netMessage, nWorldIdx);
MSG_WriteLong(&netMessage, value);
MSG_WriteLong(&netMessage, value2);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_DanBattleStatusToMemberServer_Ready( int nGuildIdx, int nEnemyGuildIdx, int nWorldIdx, int value, int value2)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, NEW_DANBATTLE);
MSG_WriteShort(&netMessage, SS_DAN_BATTLE_READY);
MSG_WriteLong(&netMessage, nGuildIdx);
MSG_WriteLong(&netMessage, nEnemyGuildIdx);
MSG_WriteByte(&netMessage, nWorldIdx);
MSG_WriteLong(&netMessage, value);
MSG_WriteByte(&netMessage, value2);
for (int nServerIdx = 1; nServerIdx < MAX_MEMBER_SERVER; nServerIdx++)
{
if ( !g_memberServer[nServerIdx].active ) continue;
NET_SendUnreliableMessage(&g_memberServer[nServerIdx].sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_DanBattleStatusToMemberServer_Start( int nGuildIdx, int nEnemyGuildIdx, int nWorldIdx, int value)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, NEW_DANBATTLE);
MSG_WriteShort(&netMessage, SS_DAN_BATTLE_START);
MSG_WriteLong(&netMessage, nGuildIdx);
MSG_WriteLong(&netMessage, nEnemyGuildIdx);
MSG_WriteByte(&netMessage, nWorldIdx);
MSG_WriteLong(&netMessage, value);
for (int nServerIdx = 1; nServerIdx < MAX_MEMBER_SERVER; nServerIdx++)
{
if ( !g_memberServer[nServerIdx].active ) continue;
NET_SendUnreliableMessage(&g_memberServer[nServerIdx].sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_DanBattleStatusToMemberServer_End( int nGuildIdx, int nEnemyGuildIdx, int nWorldIdx, int value)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, NEW_DANBATTLE);
MSG_WriteShort(&netMessage, SS_DAN_BATTLE_END);
MSG_WriteLong(&netMessage, nGuildIdx);
MSG_WriteLong(&netMessage, nEnemyGuildIdx);
MSG_WriteByte(&netMessage, nWorldIdx);
MSG_WriteByte(&netMessage, value);
for (int nServerIdx = 1; nServerIdx < MAX_MEMBER_SERVER; nServerIdx++)
{
if ( !g_memberServer[nServerIdx].active ) continue;
NET_SendUnreliableMessage(&g_memberServer[nServerIdx].sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
| C++ |
#include "../Global.h"
WorldChangeSystem::WorldChangeSystem()
{
m_SystemMode = WORLD_CHANGESYSTEM_NONE;
m_SelectWorldIdx = -1;
m_SaveInvenPos = -1;
}
| C++ |
#if !defined(AFX_GAMECONFIGFLAG_H__64911BCF_348E_4592_AE6E_C851A9E5E8B1__INCLUDED_)
#define AFX_GAMECONFIGFLAG_H__64911BCF_348E_4592_AE6E_C851A9E5E8B1__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CGameConfigFlag
{
public:
CGameConfigFlag()
{
Init();
}
virtual ~CGameConfigFlag()
{
}
void Init()
{
m_bCharacter_Storage =FALSE;
m_bPrecocity_Time =FALSE;
m_bDie_Reduce_panality =FALSE;
m_bMap_Attr_Ratio =FALSE;
m_bItem_Upgrade_Limit =FALSE;
m_bItem_Craft_Limit =FALSE;
m_bWorld_Chat_Limit =FALSE;
m_nFlag=0;
}
int LoadFlagFile();
int GetFlag()
{
return m_nFlag;
}
void SetFlag(int flag);
void SetFlag();
public:
BOOL m_bCharacter_Storage;
BOOL m_bPrecocity_Time;
BOOL m_bDie_Reduce_panality;
BOOL m_bMap_Attr_Ratio;
BOOL m_bItem_Upgrade_Limit;
BOOL m_bItem_Craft_Limit;
BOOL m_bWorld_Chat_Limit;
int m_nFlag;
};
extern CGameConfigFlag gGameConfigFlag;
#endif
| C++ |
#include "../Global.h"
#include "../Tools/CTools.h"
extern CTools* gcpTools;
void GTH_WorldChangeSystem_Process()
{
int command = MSG_ReadByte();
switch(command)
{
case GTH_REQUEST_USE_ITEM:
GTH_ProcessMessage_Request_WorldChangeUseItem(g_curPC);
break;
case GTH_REQUEST_WORLD_CHANGE:
GTH_ProcessMessage_ReQuest_WorldChange();
break;
}
}
void GTH_SendMessage_Reply_WorldChangeUseItem(playerCharacter_t* pPc, int reply, int erroridx, int InvenPos)
{
MSG_BeginWriting( &netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte ( &netMessage, GSC_EXTEND);
MSG_WriteByte ( &netMessage, GSC_WORLD_CHANGE);
MSG_WriteByte ( &netMessage, GTH_REPLY_USE_ITEM);
MSG_WriteByte ( &netMessage, reply);
if ( reply == 0)
MSG_WriteLong( &netMessage, erroridx);
NET_SendMessage(&pPc->sock, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void GTH_ProcessMessage_ReQuest_WorldChange()
{
int reply = 0;
int erroridx = 0;
int worldIdx = 0;
int saveInvenPos = 0;
saveInvenPos = MSG_ReadLong();
worldIdx = MSG_ReadLong();
if ( worldIdx == g_curPC->worldIdx)
{
GTH_SendMessage_Reply_WorldChange(g_curPC, 0, 0, saveInvenPos);
return;
}
if ( GTH_IsLocalServiceWorld(worldIdx) == false )
{
int memberIdx = GTH_FindServerWithinGroup( worldIdx );
if (memberIdx < 0)
{
GTH_SendMessage_Reply_WorldChange(g_curPC, 0, 2, saveInvenPos);
return;
}
}
if ( g_curPC->busyState != BUSY_STATE_NONE)
{
GTH_SendMessage_Reply_WorldChange(g_curPC, 0, 3, saveInvenPos);
return;
}
if((saveInvenPos < 0) || (saveInvenPos >= MAX_INVENTORY_SIZE)){
GTH_SendMessage_Reply_WorldChange(g_curPC, 0, 1, saveInvenPos);
return;
}
int itemArrayIdx = g_curPC->inventory[saveInvenPos];
if(itemArrayIdx < 0)
{
GTH_SendMessage_Reply_WorldChange(g_curPC, 0, 1, saveInvenPos);
return;
}
item_t* pItem = gcpTools->GetMyItem(g_curPC, itemArrayIdx);
if(NULL == pItem){
GTH_SendMessage_Reply_WorldChange(g_curPC, 0, 1, saveInvenPos);
return;
}
if(TRUE == gcpTools->IsStackItem(pItem)){
item_t DeleteItem = *pItem;
if(FALSE == GTH_UseItem_Delete(saveInvenPos)){
GTH_SendMessage_Reply_WorldChange(g_curPC, 0, 1, saveInvenPos);
return;
}
g_logSystem->WriteToLog(g_curPC,LOG_CLASS_ITEM,"%d;%d;%d;%d;%d;%s;",LOG_CLASS_ITEM_USE,DeleteItem.itemTableIdx,worldIdx,g_curPC->worldIdx,DeleteItem.durability-1,DeleteItem.name);
}
g_curPC->m_WorldChangeSystem.m_SystemMode =
WorldChangeSystem::enumWorldChangeMode::WORLD_CHANGESYSTEM_EFFECT_MODE;
g_curPC->busyState = BUSY_STATE_WORLDCHAGNE;
GTH_SendMessage_CompleteEffect_To_AllPC(g_curPC, WorldChangeSystem::WORLD_CHANGE_EFFECT_IDX);
GTH_SendMessage_Reply_WorldChange(g_curPC, 1, 0, saveInvenPos);
g_curPC->fWorldChangeStartTime = g_timer->GetAppMilliTime();
g_curPC->iChangeWorldIdx = worldIdx;
}
void GTH_SendMessage_Reply_WorldChange(playerCharacter_t* pPc, int reply, int erroridx, int InvenPos)
{
MSG_BeginWriting( &netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte ( &netMessage, GSC_EXTEND);
MSG_WriteByte ( &netMessage, GSC_WORLD_CHANGE);
MSG_WriteByte ( &netMessage, GTH_REPLY_WORLD_CHANGE);
MSG_WriteByte ( &netMessage, reply);
if ( reply == 0)
MSG_WriteLong( &netMessage, erroridx);
else
MSG_WriteLong( &netMessage, InvenPos);
NET_SendMessage(&pPc->sock, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void GTH_ProcessMessage_Request_WorldChangeUseItem(playerCharacter_t* in_pPlayer)
{
if(NULL == in_pPlayer) return;
int nInvenPosIdx = MSG_ReadByte();
if((nInvenPosIdx < 0) || (nInvenPosIdx >= MAX_INVENTORY_SIZE)){
GTH_SendMessage_Reply_WorldChangeUseItem(in_pPlayer, 0, 1 , nInvenPosIdx);
return;
}
item_t* pItemRecord = gcpTools->GetMyItem(in_pPlayer,in_pPlayer->inventory[nInvenPosIdx]);
if(NULL == pItemRecord){
GTH_SendMessage_Reply_WorldChangeUseItem(in_pPlayer, 0, 1 , nInvenPosIdx);
return;
}
if (in_pPlayer->event == GTH_EV_CHAR_IDLE)
GTH_SendMessage_Reply_WorldChangeUseItem(in_pPlayer, 1, 0, nInvenPosIdx);
}
void GTH_SendMessage_ClearWorldChageMode(playerCharacter_t* pPc)
{
MSG_BeginWriting( &netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte ( &netMessage, GSC_EXTEND);
MSG_WriteByte ( &netMessage, GSC_WORLD_CHANGE);
MSG_WriteByte ( &netMessage, GTH_CLEAR_WORLD_CHANGE_MODE);
NET_SendMessage(&pPc->sock, &netMessage);
}
MSG_EndWriting( &netMessage );
}
| C++ |
#include "../Global.h"
#include "../Tools/CTools.h"
extern CTools* gcpTools;
NewDanBattleSystem::NewDanBattleSystem()
{
m_bActive = FALSE;
m_nMinPcCount = 0;
m_nBattleTimeForMin1 = 0;
m_nBattleTimeForMin2 = 0;
m_fItemDropRate = 1.0f;
for (int nDanBattleIdx =0; nDanBattleIdx < MAX_DANBATTLE_COUNT; nDanBattleIdx ++)
{
memset(&m_DanBattleInfo[nDanBattleIdx], 0x00, sizeof(DanBattleInfo));
m_DanBattleInfo[nDanBattleIdx].nDanBattleIdx = nDanBattleIdx;
m_DanBattleInfo[nDanBattleIdx].AcceptDanInfo.nDanIdx =-1;
m_DanBattleInfo[nDanBattleIdx].RequestDanInfo.nDanIdx =-1;
}
}
NewDanBattleSystem::~NewDanBattleSystem()
{
}
void NewDanBattleSystem::Update()
{
for (int nBattleIdx = 0; nBattleIdx < MAX_DANBATTLE_COUNT; nBattleIdx ++ )
{
switch ( m_DanBattleInfo[nBattleIdx].BattleStatus )
{
case DanBattleInfo::enumBattleStatus::BATTLESTATUS_NONE:
case DanBattleInfo::enumBattleStatus::BATTLESTATUS_REGIST:
break;
case DanBattleInfo::enumBattleStatus::BATTLESTATUS_READY:
BattleReady(&m_DanBattleInfo[nBattleIdx]);
break;
case DanBattleInfo::enumBattleStatus::BATTLESTATUS_BATTLE:
Battle(&m_DanBattleInfo[nBattleIdx]);
break;
case DanBattleInfo::enumBattleStatus::BATTLESTATUS_END:
BattleEnd(&m_DanBattleInfo[nBattleIdx]);
break;
}
}
}
void NewDanBattleSystem::BattleReady(DanBattleInfo* pDanBattleInfo)
{
if ( pDanBattleInfo == NULL)
return;
if ( pDanBattleInfo->fRemainTime <= g_timer->GetAppMilliTime()) {
DanBaseInfo *pRequestDanInfo = &pDanBattleInfo->RequestDanInfo;
DanBaseInfo *pAcceptDanInfo = &pDanBattleInfo->AcceptDanInfo;
for (int nDanMemberIdx = 0; nDanMemberIdx < pRequestDanInfo->v_GuildMembers.size(); nDanMemberIdx++)
{
NewDanBattleSystem::DanBaseInfo::sDanBattleMember* pDanBattleMember = NULL;
pDanBattleMember = &pRequestDanInfo->v_GuildMembers[nDanMemberIdx];
playerCharacter_t *pPC = gcpTools->GetPlayerRecordPointer(pDanBattleMember->name);
if ( pPC == NULL)
continue;
if ( pPC->worldIdx != pDanBattleInfo->nBattleMapIdx)
continue;
pPC->DanBattleInfo.nDanBattleIdx = pDanBattleInfo->nDanBattleIdx;
pPC->DanBattleInfo.BattleMode = pDanBattleInfo->BattleMode;
pPC->DanBattleInfo.nBattleMapIdx = pDanBattleInfo->nBattleMapIdx;
}
for (nDanMemberIdx = 0; nDanMemberIdx < pAcceptDanInfo->v_GuildMembers.size(); nDanMemberIdx++)
{
NewDanBattleSystem::DanBaseInfo::sDanBattleMember* pDanBattleMember = NULL;
pDanBattleMember = &pAcceptDanInfo->v_GuildMembers[nDanMemberIdx];
playerCharacter_t *pPC = gcpTools->GetPlayerRecordPointer(pDanBattleMember->name);
if ( pPC == NULL)
continue;
if ( pPC->worldIdx != pDanBattleInfo->nBattleMapIdx)
continue;
pPC->DanBattleInfo.nDanBattleIdx = pDanBattleInfo->nDanBattleIdx;
pPC->DanBattleInfo.BattleMode = pDanBattleInfo->BattleMode;
pPC->DanBattleInfo.nBattleMapIdx = pDanBattleInfo->nBattleMapIdx;
}
pDanBattleInfo->fRemainTime = pDanBattleInfo->fBattleSec + g_timer->GetAppMilliTime();
pDanBattleInfo->fMinBattleProcessTime = g_timer->GetAppMilliTime() + MIN_BATTLE_PROCESS_SEC;
GTH_ProcessMessage_NewDanBattleStart(
pRequestDanInfo->nDanIdx,
pAcceptDanInfo->nDanIdx,
pDanBattleInfo->nBattleMapIdx,
pDanBattleInfo->fBattleSec);
GTH_ProcessMessage_NewDanBattleStart(
pAcceptDanInfo->nDanIdx,
pRequestDanInfo->nDanIdx,
pDanBattleInfo->nBattleMapIdx,
pDanBattleInfo->fBattleSec );
g_NewDanBattleSystem.SetDanBatttleStatus(pDanBattleInfo,
NewDanBattleSystem::DanBattleInfo::enumBattleStatus::BATTLESTATUS_BATTLE);
}
}
void NewDanBattleSystem::Battle(DanBattleInfo* pDanBattleInfo)
{
if ( pDanBattleInfo->fNextSyncdTime <= g_timer->GetAppMilliTime() )
{
GTH_SendMessage_SuncMessageDanBattleInfo(pDanBattleInfo);
pDanBattleInfo->fNextSyncdTime = g_timer->GetAppMilliTime() + SYNC_TIME;
}
DanBaseInfo *pRequestDanInfo = &pDanBattleInfo->RequestDanInfo;
DanBaseInfo *pAcceptDanInfo = &pDanBattleInfo->AcceptDanInfo;
if ( TRUE == DecsionDanBattleWinTO_LiveMemberNumber(pDanBattleInfo) )
{
if (pDanBattleInfo->AcceptDanInfo.wincode != tagGCPacket_NewDanBattle::enumwincode::draw)
{
pDanBattleInfo->endType = DanBattleInfo::enumEndType::REMAIN_MEMBER_COUNT;
DecsionDanBattleBestMember(pDanBattleInfo);
}
else
{
pDanBattleInfo->endType = DanBattleInfo::enumEndType::SYSTEM;
}
GTH_ProcessMessage_NewDanBattleEnd(pRequestDanInfo->nDanIdx,pAcceptDanInfo->nDanIdx, pDanBattleInfo->nBattleMapIdx, 1);
GTH_ProcessMessage_NewDanBattleEnd(pAcceptDanInfo->nDanIdx,pRequestDanInfo->nDanIdx,pDanBattleInfo->nBattleMapIdx, 1);
g_NewDanBattleSystem.SetDanBatttleStatus(pDanBattleInfo,
NewDanBattleSystem::DanBattleInfo::enumBattleStatus::BATTLESTATUS_END);
g_logSystem->WriteToNewDanBattleLog("%s, %d, %d, %s, %d, %d, %d",
"LOG_CLASS_NEWDANBATTLE_RESULT",
pDanBattleInfo->nDanBattleIdx,
pDanBattleInfo->AcceptDanInfo.wincode,
pDanBattleInfo->AcceptDanInfo.szGuildName,
pDanBattleInfo->BattleMode,
pDanBattleInfo->AcceptDanInfo.nRemainPoint,
pDanBattleInfo->nBattleMapIdx);
g_logSystem->WriteToNewDanBattleLog("%s, %d, %d, %s, %d, %d, %d",
"LOG_CLASS_NEWDANBATTLE_RESULT",
pDanBattleInfo->nDanBattleIdx,
pDanBattleInfo->RequestDanInfo.wincode,
pDanBattleInfo->RequestDanInfo.szGuildName,
pDanBattleInfo->BattleMode,
pDanBattleInfo->RequestDanInfo.nRemainPoint,
pDanBattleInfo->nBattleMapIdx);
return;
}
if (pDanBattleInfo->fRemainTime <= g_timer->GetAppMilliTime()) {
DecsionDanBattleWinTO_TimeOut(pDanBattleInfo);
DecsionDanBattleBestMember(pDanBattleInfo);
pDanBattleInfo->endType = DanBattleInfo::enumEndType::TIME_OUT;
GTH_ProcessMessage_NewDanBattleEnd(pRequestDanInfo->nDanIdx,pAcceptDanInfo->nDanIdx, pDanBattleInfo->nBattleMapIdx,1);
GTH_ProcessMessage_NewDanBattleEnd(pAcceptDanInfo->nDanIdx,pRequestDanInfo->nDanIdx,pDanBattleInfo->nBattleMapIdx, 1);
g_NewDanBattleSystem.SetDanBatttleStatus(pDanBattleInfo,
NewDanBattleSystem::DanBattleInfo::enumBattleStatus::BATTLESTATUS_END);
g_logSystem->WriteToNewDanBattleLog("%s, %d, %d, %s, %d, %d, %d",
"LOG_CLASS_NEWDANBATTLE_RESULT",
pDanBattleInfo->nDanBattleIdx,
pDanBattleInfo->AcceptDanInfo.wincode,
pDanBattleInfo->AcceptDanInfo.szGuildName,
pDanBattleInfo->BattleMode,
pDanBattleInfo->AcceptDanInfo.nRemainPoint,
pDanBattleInfo->nBattleMapIdx);
g_logSystem->WriteToNewDanBattleLog("%s, %d, %d, %s, %d, %d, %d",
"LOG_CLASS_NEWDANBATTLE_RESULT",
pDanBattleInfo->nDanBattleIdx,
pDanBattleInfo->RequestDanInfo.wincode,
pDanBattleInfo->RequestDanInfo.szGuildName,
pDanBattleInfo->BattleMode,
pDanBattleInfo->RequestDanInfo.nRemainPoint,
pDanBattleInfo->nBattleMapIdx);
}
}
void NewDanBattleSystem::BattleEnd(DanBattleInfo* pDanBattleInfo)
{
DanBaseInfo *pRequestDanInfo = &pDanBattleInfo->RequestDanInfo;
DanBaseInfo *pAcceptDanInfo = &pDanBattleInfo->AcceptDanInfo;
int RequestWinCount = 0;
int RequestLoseCount = 0;
int AcceeptWinCount = 0;
int AcceeptLoseCount = 0;
if ( pRequestDanInfo->nDanIdx >= 0 || pRequestDanInfo->nDanIdx < MAX_GUILDS)
{
RequestWinCount = g_guild[pRequestDanInfo->nDanIdx].wincount;
RequestLoseCount = g_guild[pRequestDanInfo->nDanIdx].Losecount;
}
if ( pAcceptDanInfo->nDanIdx >= 0 || pAcceptDanInfo->nDanIdx < MAX_GUILDS)
{
AcceeptWinCount = g_guild[pAcceptDanInfo->nDanIdx].wincount;
AcceeptLoseCount = g_guild[pAcceptDanInfo->nDanIdx].Losecount;
}
for (int nDanMemberIdx = 0; nDanMemberIdx < pRequestDanInfo->v_GuildMembers.size(); nDanMemberIdx++)
{
NewDanBattleSystem::DanBaseInfo::sDanBattleMember* pDanBattleMember = NULL;
pDanBattleMember = &pRequestDanInfo->v_GuildMembers[nDanMemberIdx];
playerCharacter_t *pPC = gcpTools->GetPlayerRecordPointer(pDanBattleMember->name);
if ( pPC == NULL )
continue;
if ( pPC->worldIdx != pDanBattleInfo->nBattleMapIdx)
continue;
GTH_SendMessage_DanBattleResult( pPC , pRequestDanInfo->wincode, pAcceptDanInfo->szGuildName, pDanBattleInfo->szBestID, RequestWinCount, RequestLoseCount, pDanBattleMember->killPoint, pDanBattleInfo->endType);
if ( pRequestDanInfo->wincode != tagGCPacket_NewDanBattle::enumwincode::loss)
GTH_SendMessage_CompleteEffect_To_AllPC(pPC,156);
ClearDanBattleInfo(pPC);
}
for (nDanMemberIdx = 0; nDanMemberIdx < pAcceptDanInfo->v_GuildMembers.size(); nDanMemberIdx++)
{
NewDanBattleSystem::DanBaseInfo::sDanBattleMember* pDanBattleMember = NULL;
pDanBattleMember = &pAcceptDanInfo->v_GuildMembers[nDanMemberIdx];
playerCharacter_t *pPC = gcpTools->GetPlayerRecordPointer(pDanBattleMember->name);
if ( pPC == NULL)
continue;
if ( pPC->worldIdx != pDanBattleInfo->nBattleMapIdx)
continue;
GTH_SendMessage_DanBattleResult( pPC, pAcceptDanInfo->wincode, pRequestDanInfo->szGuildName, pDanBattleInfo->szBestID, AcceeptWinCount, AcceeptLoseCount, pDanBattleMember->killPoint, pDanBattleInfo->endType);
if ( pAcceptDanInfo->wincode != tagGCPacket_NewDanBattle::enumwincode::loss)
GTH_SendMessage_CompleteEffect_To_AllPC(pPC,156);
ClearDanBattleInfo(pPC);
}
g_DBGameServer->Delete_Danbattle(pDanBattleInfo->RequestDanInfo.nDanIdx,
pDanBattleInfo->AcceptDanInfo.nDanIdx);
InitDanBatlleInfo(pDanBattleInfo);
}
NewDanBattleSystem::DanBattleInfo* NewDanBattleSystem::GetEmptyDanBattleSlot(int& nIdx_OUT)
{
for (int nSlotIdx =0; nSlotIdx < MAX_DANBATTLE_COUNT; nSlotIdx++)
{
if ( m_DanBattleInfo[nSlotIdx].BattleStatus == DanBattleInfo::enumBattleStatus::BATTLESTATUS_NONE)
{
nIdx_OUT = nSlotIdx;
return &m_DanBattleInfo[nSlotIdx];
}
}
return NULL;
}
NewDanBattleSystem::DanBattleInfo*
NewDanBattleSystem::InsertDanBattle(int RequestDanIdx,
int RequestPcIdx,
std::vector<DanBaseInfo::sDanBattleMember>& vRequestGuildMember,
int AcceptDanIdx,
int AcceptPcIdx,
std::vector<DanBaseInfo::sDanBattleMember>& vAcceptGuildMember,
enum NewDanBattleSystem::DanBattleInfo::enumBattleMode battlemode,
int WorldIdx,
int BattleTIme ,
__int64 RequestPcExp,
__int64 AcceptPcExp,
BOOL IsAllowPrimiumItemPlunder)
{
NewDanBattleSystem::DanBattleInfo* pBattleInfo = NULL;
int DanBattleIdx = -1;
pBattleInfo = GetEmptyDanBattleSlot(DanBattleIdx);
if ( pBattleInfo == NULL){
return NULL;
}
if ( RequestDanIdx < 0 || RequestDanIdx >= MAX_GUILDS)
return NULL;
if ( AcceptDanIdx < 0 || AcceptDanIdx >= MAX_GUILDS)
return NULL;
InitDanBatlleInfo(pBattleInfo);
pBattleInfo->BattleMode = battlemode;
pBattleInfo->BattleStatus = DanBattleInfo::enumBattleStatus::BATTLESTATUS_REGIST;
pBattleInfo->nBattleMapIdx = WorldIdx;
pBattleInfo->nDanBattleIdx = DanBattleIdx;
pBattleInfo->fBattleSec = BattleTIme;
pBattleInfo->RequestDanInfo.nDanIdx = RequestDanIdx;
pBattleInfo->RequestDanInfo.nKillPoint = 0;
pBattleInfo->RequestDanInfo.nRemainPoint = vRequestGuildMember.size();;
pBattleInfo->RequestDanInfo.nRequest_AcceptPcIdx = RequestPcIdx;
_snprintf(pBattleInfo->RequestDanInfo.szGuildName, GUILDNAMESTRING,
g_guild[RequestDanIdx].name);
pBattleInfo->RequestDanInfo.szGuildName[GUILDNAMESTRING] = NULL;
for (int nMemberIdx =0; nMemberIdx < vRequestGuildMember.size(); nMemberIdx++)
pBattleInfo->RequestDanInfo.v_GuildMembers.push_back(vRequestGuildMember[nMemberIdx]);
pBattleInfo->AcceptDanInfo.nDanIdx = AcceptDanIdx;
pBattleInfo->AcceptDanInfo.nKillPoint = 0;
pBattleInfo->AcceptDanInfo.nRemainPoint = vAcceptGuildMember.size();
pBattleInfo->AcceptDanInfo.nRequest_AcceptPcIdx = AcceptPcIdx;
for (nMemberIdx =0; nMemberIdx < vAcceptGuildMember.size(); nMemberIdx++)
pBattleInfo->AcceptDanInfo.v_GuildMembers.push_back(vAcceptGuildMember[nMemberIdx]);
_snprintf(pBattleInfo->AcceptDanInfo.szGuildName, GUILDNAMESTRING,
g_guild[AcceptDanIdx].name);
pBattleInfo->AcceptDanInfo.szGuildName[GUILDNAMESTRING] = NULL;
pBattleInfo->fWaitTimeforReady = g_NewDanBattleSystem.m_WaitTimeforReady;
pBattleInfo->fWaitTimeforEnd = g_NewDanBattleSystem.m_WaitTimeforEnd;
pBattleInfo->AcceptDanInfo.nRequest_AcceptPcEXP = AcceptPcExp;
pBattleInfo->RequestDanInfo.nRequest_AcceptPcEXP = RequestPcExp;
pBattleInfo->bPlunderPremiumItem = IsAllowPrimiumItemPlunder;
return pBattleInfo;
}
NewDanBattleSystem::DanBattleInfo* NewDanBattleSystem::GetDanBattleInfo(const int nGuildIdx)
{
if ( nGuildIdx < 0 || nGuildIdx >= MAX_GUILDS)
return NULL;
for (int nDanBattleIdx = 0; nDanBattleIdx < MAX_DANBATTLE_COUNT; nDanBattleIdx++)
{
DanBattleInfo *pDanBattleInfo = NULL;
pDanBattleInfo = &m_DanBattleInfo[nDanBattleIdx];
if (pDanBattleInfo->RequestDanInfo.nDanIdx == nGuildIdx)
return pDanBattleInfo;
if (pDanBattleInfo->AcceptDanInfo.nDanIdx == nGuildIdx)
return pDanBattleInfo;
}
return NULL;
}
NewDanBattleSystem::DanBattleInfo* NewDanBattleSystem::GetDanBattleInfo(const int nBattleIdx, const int nGuildIdx)
{
if ( nBattleIdx < 0 || nBattleIdx >= MAX_GUILDS)
return NULL;
if ( (m_DanBattleInfo[nBattleIdx].RequestDanInfo.nDanIdx != nGuildIdx) &&
(m_DanBattleInfo[nBattleIdx].AcceptDanInfo.nDanIdx != nGuildIdx))
return NULL;
return &m_DanBattleInfo[nBattleIdx];
}
NewDanBattleSystem::DanBattleInfo* NewDanBattleSystem::GetDanBattleInfo(const int nBattleIdx, DanBattleInfo::enumBattleStatus status)
{
if ( nBattleIdx < 0 || nBattleIdx >= MAX_GUILDS)
return NULL;
if ( m_DanBattleInfo[nBattleIdx].BattleStatus != status )
return NULL;
return &m_DanBattleInfo[nBattleIdx];
}
NewDanBattleSystem::DanBattleInfo* NewDanBattleSystem::GetDanBattleInfo(const char* szGuildName)
{
for (int nDanBattleIdx = 0; nDanBattleIdx < MAX_DANBATTLE_COUNT; nDanBattleIdx++)
{
DanBattleInfo *pDanBattleInfo = NULL;
pDanBattleInfo = &m_DanBattleInfo[nDanBattleIdx];
if ( stricmp (pDanBattleInfo->RequestDanInfo.szGuildName, szGuildName) == 0)
return pDanBattleInfo;
if ( stricmp (pDanBattleInfo->AcceptDanInfo.szGuildName, szGuildName) == 0)
return pDanBattleInfo;
}
return NULL;
}
NewDanBattleSystem::DanBaseInfo* NewDanBattleSystem::GetEnemyDanBaseInfo(const int nBattleIdx, const int nGuildIdx)
{
if ( nBattleIdx < 0 || nBattleIdx >= MAX_GUILDS)
return NULL;
if ( (m_DanBattleInfo[nBattleIdx].RequestDanInfo.nDanIdx != nGuildIdx) )
{
if ( m_DanBattleInfo[nBattleIdx].RequestDanInfo.nDanIdx >0 &&
m_DanBattleInfo[nBattleIdx].RequestDanInfo.nDanIdx < MAX_GUILDS)
return &m_DanBattleInfo[nBattleIdx].RequestDanInfo;
}
else
{
if ( m_DanBattleInfo[nBattleIdx].AcceptDanInfo.nDanIdx >0 &&
m_DanBattleInfo[nBattleIdx].AcceptDanInfo.nDanIdx < MAX_GUILDS)
return &m_DanBattleInfo[nBattleIdx].AcceptDanInfo;
}
return NULL;
}
void NewDanBattleSystem::InitDanBatlleInfo(DanBattleInfo* pDanBattleInfo)
{
if ( pDanBattleInfo == NULL)
return;
memset(pDanBattleInfo, 0x00, sizeof(DanBattleInfo));
pDanBattleInfo->BattleMode = DanBattleInfo::enumBattleMode::BATTLEMODE_FRIENDSHIP;
pDanBattleInfo->BattleStatus = DanBattleInfo::enumBattleStatus::BATTLESTATUS_NONE;
pDanBattleInfo->RequestDanInfo.nDanIdx = -1;
pDanBattleInfo->RequestDanInfo.nRequest_AcceptPcIdx = -1;
pDanBattleInfo->RequestDanInfo.wincode = tagGCPacket_NewDanBattle::enumwincode::draw;
pDanBattleInfo->AcceptDanInfo.nDanIdx = -1;
pDanBattleInfo->AcceptDanInfo.nRequest_AcceptPcIdx = -1;
pDanBattleInfo->AcceptDanInfo.wincode = tagGCPacket_NewDanBattle::enumwincode::draw;
pDanBattleInfo->nBattleMapIdx = -1;
pDanBattleInfo->fItemDropRate = 1.0f;
pDanBattleInfo->fBattleSec = g_NewDanBattleSystem.m_nBattleTimeForMin1;
pDanBattleInfo->nDanBattleIdx = -1;
pDanBattleInfo->endType = DanBattleInfo::enumEndType::REMAIN_MEMBER_COUNT;
}
void NewDanBattleSystem::SetDanBatttleStatus(DanBattleInfo* pDanBattleInfo,
DanBattleInfo::enumBattleStatus status)
{
if ( pDanBattleInfo == NULL)
return ;
pDanBattleInfo->BattleStatus = status;
switch( status )
{
case DanBattleInfo::enumBattleStatus::BATTLESTATUS_READY:
{
g_logSystem->WriteToNewDanBattleLog("%s, %d, %s, %s, %d, %d, %d",
"LOG_CLASS_NEWDANBATTLE_START",
pDanBattleInfo->nDanBattleIdx,
pDanBattleInfo->RequestDanInfo.szGuildName,
pDanBattleInfo->AcceptDanInfo.szGuildName,
pDanBattleInfo->BattleMode,
pDanBattleInfo->fBattleSec,
pDanBattleInfo->nBattleMapIdx);
}
break;
case DanBattleInfo::enumBattleStatus::BATTLESTATUS_END:
{
g_logSystem->WriteToNewDanBattleLog("%s, %d, %s, %s, %d, %d, %d",
"LOG_CLASS_NEWDANBATTLE_END",
pDanBattleInfo->nDanBattleIdx,
pDanBattleInfo->RequestDanInfo.szGuildName,
pDanBattleInfo->AcceptDanInfo.szGuildName,
pDanBattleInfo->BattleMode,
pDanBattleInfo->endType,
pDanBattleInfo->nBattleMapIdx);
}
break;
}
}
BOOL NewDanBattleSystem::IsDanBattleEnemy(int myPcIdx,int EnemyIdx)
{
playerCharacter_t* pMyPc = NULL;
pMyPc = gcpTools->GetPlayerRecordPointer(myPcIdx);
if ( pMyPc == NULL)
return FALSE;
playerCharacter_t* pEnemyPc = NULL;
pEnemyPc = gcpTools->GetPlayerRecordPointer(EnemyIdx);
if ( pEnemyPc == NULL)
return FALSE;
DanBattleInfo* pDanBattleInfo = NULL;
pDanBattleInfo = GetDanBattleInfo(pMyPc->DanBattleInfo.nDanBattleIdx, pMyPc->guildIdx);
if ( pDanBattleInfo == NULL)
return FALSE;
if ( pDanBattleInfo->BattleStatus != DanBattleInfo::enumBattleStatus::BATTLESTATUS_BATTLE)
return FALSE;
if ( pMyPc->DanBattleInfo.nDanBattleIdx != pEnemyPc->DanBattleInfo.nDanBattleIdx)
return FALSE;
if ( pMyPc->guildIdx == pEnemyPc->guildIdx)
return FALSE;
return TRUE;
}
NewDanBattleSystem::DanBaseInfo* NewDanBattleSystem::GetDanBaseInfo(DanBattleInfo* pDanBattleInfo, const int nGuildIdx)
{
if ( pDanBattleInfo == NULL)
return NULL;
if ( pDanBattleInfo->RequestDanInfo.nDanIdx == nGuildIdx)
return &(pDanBattleInfo->RequestDanInfo);
if ( pDanBattleInfo->AcceptDanInfo.nDanIdx == nGuildIdx)
return &(pDanBattleInfo->AcceptDanInfo);
return NULL;
}
BOOL NewDanBattleSystem::InsertDanBattleMemeber(int DanBattleIdx, int GuildIdx, int Pcidx)
{
playerCharacter_t* pMyPc = NULL;
pMyPc = gcpTools->GetPlayerRecordPointer(Pcidx);
if ( pMyPc == NULL)
return FALSE;
DanBattleInfo* pDanBattleInfo = NULL;
pDanBattleInfo = GetDanBattleInfo(DanBattleIdx, pMyPc->guildIdx);
if ( pDanBattleInfo == NULL)
return FALSE;
DanBaseInfo* pMyDanBaseInfo = NULL;
pMyDanBaseInfo = GetDanBaseInfo(pDanBattleInfo, GuildIdx);
if ( pMyDanBaseInfo == NULL)
return FALSE;
DanBaseInfo::sDanBattleMember danbattlemember;
memset(&danbattlemember, 0x00, sizeof(DanBaseInfo::sDanBattleMember));
danbattlemember.PcIdx = Pcidx;
memcpy(danbattlemember.name, pMyPc->name, NAMESTRING);
danbattlemember.name[NAMESTRING] = NULL;
danbattlemember.nAccumulationBattleKillPoint = pMyPc->nAccumulationBattleKillPoint;
pMyDanBaseInfo->v_GuildMembers.push_back(danbattlemember);
return TRUE;
}
BOOL NewDanBattleSystem::IsInsertdDanBattle(int GuildIdx)
{
for (int nBattleIdx = 0; nBattleIdx < MAX_DANBATTLE_COUNT; nBattleIdx ++ )
{
DanBaseInfo *pDanBaseInfo = NULL;
if ( m_DanBattleInfo[nBattleIdx].BattleStatus ==
DanBattleInfo::enumBattleStatus::BATTLESTATUS_NONE )
continue;
pDanBaseInfo = GetDanBaseInfo(&m_DanBattleInfo[nBattleIdx], GuildIdx);
if ( pDanBaseInfo != NULL)
return TRUE;
}
return FALSE;
}
NewDanBattleSystem::DanBaseInfo::sDanBattleMember*
NewDanBattleSystem::GetDanBattleMember(DanBattleInfo* pDanBattleInfo, int GuildIdx, char* pcname)
{
if ( pDanBattleInfo == NULL)
return NULL;
if ( pcname == NULL)
return NULL;
NewDanBattleSystem::DanBaseInfo* pMyDanBaseInfo = NULL;
pMyDanBaseInfo = g_NewDanBattleSystem.GetDanBaseInfo(pDanBattleInfo, GuildIdx);
if ( pMyDanBaseInfo == NULL)
return NULL;
for (int nMemberIdx = 0; nMemberIdx < pMyDanBaseInfo->v_GuildMembers.size(); nMemberIdx++)
{
NewDanBattleSystem::DanBaseInfo::sDanBattleMember* pMember = NULL;
pMember = &pMyDanBaseInfo->v_GuildMembers[nMemberIdx];
if ( stricmp (pMember->name, pcname) == 0)
return pMember;
}
return NULL;
}
BOOL NewDanBattleSystem::DecsionDanBattleWinTO_LiveMemberNumber(DanBattleInfo* pDanBattleInfo)
{
if ( pDanBattleInfo == NULL)
return FALSE;
int RequestDanLivePcNumber = 0;
int AcceptDanLivePcNumber = 0;
int RequestDanIdx = pDanBattleInfo->RequestDanInfo.nDanIdx;
int AcceptDanIdx = pDanBattleInfo->AcceptDanInfo.nDanIdx;
int MaxMemberNumber = pDanBattleInfo->RequestDanInfo.v_GuildMembers.size();
int NowMemberNumber = 0;
pDanBattleInfo->RequestDanInfo.nRemainPoint = 0;
for (int nMemberIdx = 0; nMemberIdx < MaxMemberNumber; nMemberIdx++)
{
NewDanBattleSystem::DanBaseInfo::sDanBattleMember* pDanBattleMember = NULL;
pDanBattleMember = &pDanBattleInfo->RequestDanInfo.v_GuildMembers[nMemberIdx];
playerCharacter_t* pPc = gcpTools->GetPlayerRecordPointer(pDanBattleMember->name);
if ( NULL == pPc)
continue;
if ( pPc->worldIdx != pDanBattleInfo->nBattleMapIdx)
continue;
pDanBattleInfo->RequestDanInfo.nRemainPoint++;
}
MaxMemberNumber = pDanBattleInfo->AcceptDanInfo.v_GuildMembers.size();
pDanBattleInfo->AcceptDanInfo.nRemainPoint = 0;
for (nMemberIdx = 0; nMemberIdx < MaxMemberNumber; nMemberIdx++)
{
NewDanBattleSystem::DanBaseInfo::sDanBattleMember* pDanBattleMember = NULL;
pDanBattleMember = &pDanBattleInfo->AcceptDanInfo.v_GuildMembers[nMemberIdx];
playerCharacter_t* pPc = gcpTools->GetPlayerRecordPointer(pDanBattleMember->name);
if ( NULL == pPc)
continue;
if ( pPc->worldIdx != pDanBattleInfo->nBattleMapIdx)
continue;
pDanBattleInfo->AcceptDanInfo.nRemainPoint++;
}
#ifndef _DEV_TEST
RequestDanLivePcNumber = pDanBattleInfo->RequestDanInfo.nRemainPoint;
AcceptDanLivePcNumber = pDanBattleInfo->AcceptDanInfo.nRemainPoint;
if ( RequestDanLivePcNumber <= 0 && AcceptDanLivePcNumber <=0 )
{
pDanBattleInfo->AcceptDanInfo.wincode = tagGCPacket_NewDanBattle::enumwincode::draw;
pDanBattleInfo->RequestDanInfo.wincode = tagGCPacket_NewDanBattle::enumwincode::draw;
return TRUE;
}
if ( pDanBattleInfo->fMinBattleProcessTime > g_timer->GetAppMilliTime() )
{
if ( (RequestDanLivePcNumber < MIN_GUILD_MEMBER_NUMBER_FOR_DAN_BATTLE) &&
(AcceptDanLivePcNumber < MIN_GUILD_MEMBER_NUMBER_FOR_DAN_BATTLE) )
{
pDanBattleInfo->AcceptDanInfo.wincode = tagGCPacket_NewDanBattle::enumwincode::draw;
pDanBattleInfo->RequestDanInfo.wincode = tagGCPacket_NewDanBattle::enumwincode::draw;
return TRUE;
}
return FALSE;
}
if ( RequestDanLivePcNumber < MIN_GUILD_MEMBER_NUMBER_FOR_DAN_BATTLE)
{
pDanBattleInfo->AcceptDanInfo.wincode = tagGCPacket_NewDanBattle::enumwincode::win;
if ( AcceptDanIdx >=0 && AcceptDanIdx < MAX_GUILDS){
g_DBGameServer->Save_danbattle_guild_AddWinpoint(AcceptDanIdx);
g_guild[AcceptDanIdx].wincount +=1;
}
pDanBattleInfo->RequestDanInfo.wincode= tagGCPacket_NewDanBattle::enumwincode::loss;
if ( RequestDanIdx >=0 && RequestDanIdx < MAX_GUILDS){
g_DBGameServer->Save_danbattle_guild_AddLosepoint(RequestDanIdx);
g_guild[RequestDanIdx].Losecount +=1;
}
return TRUE;
}
if (AcceptDanLivePcNumber < MIN_GUILD_MEMBER_NUMBER_FOR_DAN_BATTLE ){
pDanBattleInfo->RequestDanInfo.wincode = tagGCPacket_NewDanBattle::enumwincode::win;
if ( RequestDanIdx >=0 && RequestDanIdx < MAX_GUILDS){
g_DBGameServer->Save_danbattle_guild_AddWinpoint(pDanBattleInfo->RequestDanInfo.nDanIdx);
g_guild[RequestDanIdx].wincount +=1;
}
pDanBattleInfo->AcceptDanInfo.wincode = tagGCPacket_NewDanBattle::enumwincode::loss;
if ( AcceptDanIdx >=0 && AcceptDanIdx< MAX_GUILDS){
g_DBGameServer->Save_danbattle_guild_AddLosepoint(AcceptDanIdx);
g_guild[AcceptDanIdx ].Losecount +=1;
}
return TRUE;
}
#endif
return FALSE;
}
BOOL NewDanBattleSystem::DecsionDanBattleWinTO_TimeOut(DanBattleInfo* pDanBattleInfo)
{
if ( pDanBattleInfo == NULL)
return FALSE;
int RequestDanIdx = pDanBattleInfo->RequestDanInfo.nDanIdx;
int AcceptDanIdx = pDanBattleInfo->AcceptDanInfo.nDanIdx;
if ( pDanBattleInfo->AcceptDanInfo.nKillPoint > pDanBattleInfo->RequestDanInfo.nKillPoint)
{
pDanBattleInfo->AcceptDanInfo.wincode = tagGCPacket_NewDanBattle::enumwincode::win;
if ( AcceptDanIdx >=0 && AcceptDanIdx < MAX_GUILDS){
g_DBGameServer->Save_danbattle_guild_AddWinpoint(AcceptDanIdx);
g_guild[AcceptDanIdx].wincount +=1;
}
pDanBattleInfo->RequestDanInfo.wincode= tagGCPacket_NewDanBattle::enumwincode::loss;
if ( RequestDanIdx >=0 && RequestDanIdx < MAX_GUILDS){
g_DBGameServer->Save_danbattle_guild_AddLosepoint(RequestDanIdx);
g_guild[RequestDanIdx].Losecount +=1;
}
return TRUE;
}
if ( pDanBattleInfo->AcceptDanInfo.nKillPoint < pDanBattleInfo->RequestDanInfo.nKillPoint)
{
pDanBattleInfo->RequestDanInfo.wincode = tagGCPacket_NewDanBattle::enumwincode::win;
if ( RequestDanIdx >=0 && RequestDanIdx < MAX_GUILDS){
g_DBGameServer->Save_danbattle_guild_AddWinpoint(RequestDanIdx);
g_guild[RequestDanIdx].wincount +=1;
}
pDanBattleInfo->AcceptDanInfo.wincode= tagGCPacket_NewDanBattle::enumwincode::loss;
if ( AcceptDanIdx >=0 && AcceptDanIdx < MAX_GUILDS){
g_DBGameServer->Save_danbattle_guild_AddLosepoint(AcceptDanIdx);
g_guild[AcceptDanIdx].Losecount +=1;
}
return TRUE;
}
if ( pDanBattleInfo->AcceptDanInfo.nKillPoint == pDanBattleInfo->RequestDanInfo.nKillPoint)
{
if ( pDanBattleInfo->AcceptDanInfo.nRequest_AcceptPcEXP > pDanBattleInfo->RequestDanInfo.nRequest_AcceptPcEXP )
{
pDanBattleInfo->AcceptDanInfo.wincode = tagGCPacket_NewDanBattle::enumwincode::win;
if ( AcceptDanIdx >=0 && AcceptDanIdx < MAX_GUILDS){
g_DBGameServer->Save_danbattle_guild_AddWinpoint(AcceptDanIdx);
g_guild[AcceptDanIdx].wincount +=1;
}
pDanBattleInfo->RequestDanInfo.wincode= tagGCPacket_NewDanBattle::enumwincode::loss;
if ( RequestDanIdx >=0 && RequestDanIdx < MAX_GUILDS){
g_DBGameServer->Save_danbattle_guild_AddLosepoint(RequestDanIdx);
g_guild[RequestDanIdx].Losecount +=1;
}
}
else
{
pDanBattleInfo->RequestDanInfo.wincode = tagGCPacket_NewDanBattle::enumwincode::win;
if ( RequestDanIdx >=0 && RequestDanIdx < MAX_GUILDS){
g_DBGameServer->Save_danbattle_guild_AddWinpoint(RequestDanIdx);
g_guild[RequestDanIdx].wincount +=1;
}
pDanBattleInfo->AcceptDanInfo.wincode= tagGCPacket_NewDanBattle::enumwincode::loss;
if ( AcceptDanIdx >=0 && AcceptDanIdx < MAX_GUILDS){
g_DBGameServer->Save_danbattle_guild_AddLosepoint(AcceptDanIdx);
g_guild[AcceptDanIdx].Losecount +=1;
}
return TRUE;
}
}
return TRUE;
}
void NewDanBattleSystem::DecsionDanBattleBestMember(DanBattleInfo* pDanBattleInfo)
{
if ( pDanBattleInfo == NULL)
return;
NewDanBattleSystem::DanBaseInfo::sDanBattleMember* pBestBattleMember = NULL;
for (int nMemberIdx =0; nMemberIdx < pDanBattleInfo->RequestDanInfo.v_GuildMembers.size() ; nMemberIdx++)
{
NewDanBattleSystem::DanBaseInfo::sDanBattleMember* pBattleMember =
pBattleMember = &pDanBattleInfo->RequestDanInfo.v_GuildMembers[nMemberIdx];
if ( pBestBattleMember == NULL){
pBestBattleMember = pBattleMember;
continue;
}
if ( pBestBattleMember->killPoint < pBattleMember->killPoint) {
pBestBattleMember = pBattleMember;
continue;
}
else if (pBestBattleMember->killPoint == pBattleMember->killPoint)
{
if (pBestBattleMember->exp > pBattleMember->exp)
pBestBattleMember = pBattleMember;
}
}
for ( nMemberIdx =0; nMemberIdx < pDanBattleInfo->AcceptDanInfo.v_GuildMembers.size() ; nMemberIdx++)
{
NewDanBattleSystem::DanBaseInfo::sDanBattleMember* pBattleMember =
pBattleMember = &pDanBattleInfo->AcceptDanInfo.v_GuildMembers[nMemberIdx];
if ( pBestBattleMember == NULL){
pBestBattleMember = pBattleMember;
continue;
}
if ( pBestBattleMember->killPoint < pBattleMember->killPoint) {
pBestBattleMember = pBattleMember;
continue;
}
else if (pBestBattleMember->killPoint == pBattleMember->killPoint)
{
if (pBestBattleMember->exp > pBattleMember->exp)
pBestBattleMember = pBattleMember;
}
}
strncpy(pDanBattleInfo->szBestID, pBestBattleMember->name, NAMESTRING);
pDanBattleInfo->szBestID[NAMESTRING-1] = NULL;
}
#include "..\GolryunBattle\CServerLpackCtrl.h"
extern CServerLpackCtrl* gcpServerLpackCtrl;
void NewDanBattleSystem::RemainTimeBroadCastMsg(DanBattleInfo* pDanBattleInfo)
{
int currenttime = pDanBattleInfo->fRemainTime;
if ( pDanBattleInfo->fRemainTime == 60000)
{
char Msg[256];
_snprintf(Msg, 256, gcpServerLpackCtrl->GetLpack(11));
Msg[255] = NULL;
GTH_SendMessage_DanBattleNoticeMsgToDanMember(pDanBattleInfo,
NewDanBattleSystem::noticetype::killpoint_notice, Msg);
return;
}
if ( currenttime % 3600000 == 0)
{
char Msg[256];
_snprintf(Msg, 256, gcpServerLpackCtrl->GetLpack(9), currenttime);
Msg[255] = NULL;
GTH_SendMessage_DanBattleNoticeMsgToDanMember(pDanBattleInfo,
NewDanBattleSystem::noticetype::killpoint_notice, Msg);
}
if ( currenttime % 600000 == 0)
{
char Msg[256];
_snprintf(Msg, 256, gcpServerLpackCtrl->GetLpack(9), currenttime);
Msg[255] = NULL;
GTH_SendMessage_DanBattleNoticeMsgToDanMember(pDanBattleInfo,
NewDanBattleSystem::noticetype::killpoint_notice, Msg);
}
} | C++ |
#include "../global.h"
CEventCraftSystem g_EventCraftSystem;
CEventCraftSystem::CEventCraftSystem()
{
}
CEventCraftSystem::~CEventCraftSystem()
{
}
int GTH_EventCraftProcess( playerCharacter_t *pc, int &reply, int &error ,bool checkFlag)
{
int i, craftIdx, itemIdx;
int bIsStack, stackNumber;
craftIdx = GTH_CheckEventCraftFormula( pc );
if( craftIdx < 0 )
{
reply = 0;
error = ERROR_ITEMSYSTEM_0;
return -1;
}
if( checkFlag ) return 1;
for( i = 0; i < MAX_EVENT_CRAFT_ITEM; i ++ )
{
if( pc->craftSourceInventory[i] < 0 ) continue;
itemIdx = pc->craftSourceInventory[i];
bIsStack = false;
stackNumber = 1;
if( g_itemTable[pc->item[itemIdx].itemTableIdx].stackFlag )
{
bIsStack = true;
stackNumber = pc->item[itemIdx].durability + 1;
}
g_logSystem->WriteToLog( pc, LOG_CLASS_ITEM, "%d;%d;;;;%s;%s",
LOG_CLASS_ITEM_CRAFT_SOURCE, stackNumber, pc->item[itemIdx].name,
GetItemInformationLog( bIsStack, pc->item[itemIdx].itemTableIdx, itemIdx, -1 ));
GTH_DeleteMyItem( pc, &pc->item[itemIdx] );
pc->craftSourceInventory[i] = -1;
g_DBGameServer->RemoveItem( pc, itemIdx );
reply = 1;
}
itemCraftTable_t *pData = g_EventCraftSystem.Get(craftIdx);
if(pData != NULL)
{
g_curPC->curChargeSE += pData->m_lResultNak;
g_curPC->exp += pData->m_lResultExp;
}
return craftIdx;
}
void GTH_ProcessMessage_ItemSystem_EventCraftPrepare()
{
if ( FALSE == isValidPCBusy(g_curPC, BUSY_STATE_CRAFT ) )
return;
int reply = 1, error = 0;
int nak = 0;
float pro = 0.0f;
GTH_EventCraftProcess( g_curPC, reply, error,true);
GTH_SendMessage_ItemSystem_EventCraftPrepare( g_curPC, reply, error );
}
void GTH_ProcessMessage_ItemSystem_EventCraftComplete()
{
if ( FALSE == isValidPCBusy(g_curPC, BUSY_STATE_CRAFT ) )
return;
int reply = 1, error = 0;
int craftIdx;
craftIdx = GTH_EventCraftProcess( g_curPC, reply, error);
itemCraftTable_t * craftData = g_EventCraftSystem.Get(craftIdx);
if(craftData != NULL)
{
if(craftData->m_btEventType == CEventCraftSystem::CRAFT_RESISTER)
{
g_DBGameServer->Send_Save_EventCraftItem(g_curPC,craftIdx);
}
}
GTH_SendMessage_ItemSystem_EventCraftComplete( g_curPC, reply, error ,craftIdx);
}
void GTH_ProcessMessage_ItemSystem_EventCraftLoadEvent()
{
if ( FALSE == isValidPCBusy(g_curPC, BUSY_STATE_CRAFT ) )
return;
int nEventIndex = MSG_ReadLong();
g_DBGameServer->Recv_Load_EventCraftItem(g_curPC,nEventIndex);
}
int GTH_UndoPCEventCraft( playerCharacter_t *pc, int completeFlag )
{
int itemIdx, inventoryPos;
item_t *item, *upItem;
int bIsStack = false, stackNumber = 1;
for( int i = 0; i < MAX_CRAFT_SOURCE_ITEM_SIZE; i ++ )
{
itemIdx = pc->craftSourceInventory[i];
if( itemIdx < 0 ) continue;
item = &pc->item[itemIdx];
bIsStack = false;
stackNumber = 1;
if( g_itemTable[item->itemTableIdx].stackFlag )
{
bIsStack = true;
stackNumber = item->durability + 1;
}
int stackItemIdx = GTH_StackMyItem( pc, item );
if( stackItemIdx >= 0 )
{
upItem = &pc->item[stackItemIdx];
upItem->durability += item->durability + 1;
if( upItem->durability + 1 >= MAX_COUNT_STACK_ITEM ) upItem->durability = MAX_COUNT_STACK_ITEM - 1;
g_logSystem->WriteToLog( pc, LOG_CLASS_ITEM, "%d;%d;%d;;;%s;%s",
LOG_CLASS_ITEM_UNDO_CRAFT, 0, stackNumber, upItem->name,
GetItemInformationLog( bIsStack, upItem->itemTableIdx, stackItemIdx, -1 ));
GTH_DeleteMyItem( pc, item );
g_DBGameServer->SaveItem( pc, upItem, stackItemIdx );
g_DBGameServer->RemoveItem( pc, itemIdx );
}
else
{
inventoryPos = GTH_FindEmptyInventoryPos( pc );
if( inventoryPos >= 0 )
{
pc->inventory[inventoryPos] = itemIdx;
}
g_logSystem->WriteToLog( pc, LOG_CLASS_ITEM, "%d;%d;%d;;;%s;%s",
LOG_CLASS_ITEM_UNDO_CRAFT, 0, stackNumber, item->name,
GetItemInformationLog( bIsStack, item->itemTableIdx, itemIdx, inventoryPos ));
}
}
if( !completeFlag ) g_logSystem->Write("Make Item Cancel : %s(%s)", pc->name, pc->userID );
else g_logSystem->Write("Make Item Complete : %s(%s)", pc->name, pc->userID );
for( i = 0; i < MAX_CRAFT_SOURCE_ITEM_SIZE; i ++ )
{
pc->craftSourceInventory[i] = -1;
}
return 1;
}
void GTH_ProcessMessage_ItemSystem_EventCraftClose()
{
if ( FALSE == isValidPCBusy(g_curPC, BUSY_STATE_CRAFT ) )
return;
GTH_UndoPCEventCraft( g_curPC );
GTH_DeleteNoticePC( g_curPC );
GTH_SendMessage_ItemSystem_EventCraftClose( g_curPC );
}
void GTH_ProcessMessage_ItemSystem_EventCraftOpen()
{
int i;
for( i = 0; i < MAX_CRAFT_SOURCE_ITEM_SIZE; i ++ )
{
g_curPC->craftSourceInventory[i] = -1;
}
GTH_AddNoticePC( g_curPC, -1, -1, BUSY_STATE_CRAFT );
GTH_SendMessage_ItemSystem_EventCraftOpen( g_curPC );
}
void GTH_ProcessMessage_ItemSystem_EventCraftItem()
{
if ( FALSE == isValidPCBusy(g_curPC, BUSY_STATE_CRAFT ) )
return;
int posType = MSG_ReadShort();
int pos = MSG_ReadShort();
int tempInven;
int reply = 1, error = 0;
if( posType == 0 )
{
if( g_curPC->mouseInventory >= 0 )
{
if( g_curPC->craftSourceInventory[pos] >= 0 )
{
tempInven = g_curPC->mouseInventory;
g_curPC->mouseInventory = g_curPC->craftSourceInventory[pos];
g_curPC->craftSourceInventory[pos] = tempInven;
}
else
{
g_curPC->craftSourceInventory[pos] = g_curPC->mouseInventory;
g_curPC->mouseInventory = -1;
}
}
else
{
g_curPC->mouseInventory = g_curPC->craftSourceInventory[pos];
g_curPC->craftSourceInventory[pos] = -1;
}
}
else
{
if( g_curPC->mouseInventory < 0 && g_curPC->craftResultInventory[pos] >= 0 )
{
g_curPC->mouseInventory = g_curPC->craftResultInventory[pos];
g_curPC->craftResultInventory[pos] = -1;
}
}
GTH_SendMessage_ItemSystem_EventCraftItem( g_curPC, reply, error, posType, pos );
}
int GTH_CheckEventCraftFormula( playerCharacter_t *pc )
{
int i, j, k, itemIdx;
int itemTableIdx1, itemTableIdx2, checkedNumber;
int numSourceItem, checkedItem[MAX_EVENT_CRAFT_ITEM], checkedIdx[MAX_EVENT_CRAFT_ITEM];
item_t *sourceItem;
numSourceItem = 0;
for( i = 0; i < MAX_EVENT_CRAFT_ITEM; i ++ )
{
if( pc->craftSourceInventory[i] < 0 ) continue;
sourceItem = &pc->item[pc->craftSourceInventory[i]];
checkedIdx[numSourceItem] = i;
numSourceItem ++;
}
if( numSourceItem == 0 ) return -1;
for( i = 0; i < g_EventCraftSystem.GetTableSize(); i ++ )
{
itemCraftTable_t *pData = g_EventCraftSystem.Get(i);
if(pData == NULL) break;
if( numSourceItem != pData->numSourceItem ) continue;
checkedNumber = numSourceItem;
for( j = 0; j < MAX_EVENT_CRAFT_ITEM; j ++ )
{
checkedItem[j] = false;
}
for( j = 0; j < MAX_EVENT_CRAFT_ITEM; j ++ )
{
for( k = 0; k < numSourceItem; k ++ )
{
if( checkedItem[k] ) continue;
itemIdx = pc->craftSourceInventory[checkedIdx[k]];
sourceItem = &pc->item[itemIdx];
itemTableIdx1 = sourceItem->itemTableIdx;
itemTableIdx2 = pData->sourceItem[j].itemIndex;
if( itemTableIdx1 != itemTableIdx2 ) continue;
if( g_itemTable[itemTableIdx1].stackFlag && g_itemTable[itemTableIdx2].stackFlag )
{
if( pData->sourceItem[j].itemCount != sourceItem->durability + 1 ) continue;
}
break;
}
if( k == numSourceItem ) break;
checkedItem[k] = true;
checkedNumber --;
}
if( checkedNumber == 0 )
{
return i;
}
}
return -1;
}
| C++ |
#include "../global.h"
void SetItemSpawnType(item_t *pItem, ITEM_SPAWN_INFO::enumItemSpawnType type)
{
pItem->ItemExtendInfo.ItemSpawnInfomation.ItemSpawnType = type;
}
ITEM_SPAWN_INFO::enumItemSpawnType GetItemSpawnType(const item_t *pItem)
{
return pItem->ItemExtendInfo.ItemSpawnInfomation.ItemSpawnType;
}
void SetItemUseFlag(item_t *pItem, ENUM_ITEM_USE_FLAG flag)
{
pItem->ItemExtendInfo.UseFlag |= flag;
}
BOOL IsItemUseFlag(item_t *pItem, ENUM_ITEM_USE_FLAG flag)
{
if ( pItem->ItemExtendInfo.UseFlag & flag)
return TRUE;
return FALSE;
}
| C++ |
#include "../global.h"
extern char *curpos, *endpos;
int GTH_LoadWorldTable()
{
FILE *fp;
int size;
byte *buffer;
char *token;
int idx;
int i;
fp = fopen( "tables/world.tbl" , "rb" );
if( !fp )
{
MessageBox(NULL, "Does not exist 'tables/world.tbl' file", "iWorld3D", MB_ICONHAND|MB_OK);
return false;
}
fseek(fp,0,SEEK_END);
size = ftell(fp);
buffer = new byte[size+1];
fseek(fp,0,SEEK_SET);
fread(buffer,size,1,fp);
fclose(fp);
curpos = (char *)buffer;
endpos = curpos + size;
g_worldTableNumber = 0;
idx = 0;
while ((token = NextToken()) != NULL)
{
if( !stricmp( token, "WORLD_IDX" ) )
{
idx = atoi( NextArg() );
memset( &g_worldTable[idx], 0, sizeof( worldTable_t ) );
g_worldTable[idx].idx = idx;
g_worldTableNumber++;
}
else if( !stricmp( token, "NAME" ) )
{
strcpy ( g_worldTable[idx].name, NextArg() );
}
else if( !stricmp( token, "2DWORLD_FILE_NAME" ) )
{
strcpy ( g_worldTable[idx].world2DFileName, NextArg() );
}
else if( !stricmp( token, "MONSTER_SPAWN_TABLE" ) )
{
strcpy ( g_worldTable[idx].monsterSpawnTableFileName, NextArg() );
}
else if( !stricmp( token, "MONSTER_SPAWN_NUMBER" ) )
{
g_worldTable[idx].monsterSpawnNumber = atoi( NextArg() );
}
else if( !stricmp( token, "START_POSITION" ) )
{
g_worldTable[idx].startPosition[0] = atof( NextArg() );
g_worldTable[idx].startPosition[1] = atof( NextArg() );
g_worldTable[idx].startPosition[2] = atof( NextArg() );
}
else if( !stricmp( token, "START_YAW" ) )
{
g_worldTable[idx].startYaw = atof( NextArg() );
}
else if( !stricmp( token, "GATE_NUMBER" ) )
{
g_worldTable[idx].gateNumber = atoi( NextArg() );
}
else if( !stricmp( token, "GATE_IDX" ) )
{
for (i=0; i<g_worldTable[idx].gateNumber; i++)
g_worldTable[idx].gateIdx[i] = atoi( NextArg() );
}
else if( !stricmp( token, "SPAWN_POSITION" ) )
{
for (i=0; i<g_worldTable[idx].gateNumber; i++)
{
g_worldTable[idx].spawnPos[i][0] = atof( NextArg() );
g_worldTable[idx].spawnPos[i][1] = atof( NextArg() );
g_worldTable[idx].spawnPos[i][2] = atof( NextArg() );
}
}
else if( !stricmp( token, "SPAWN_YAW" ) )
{
for (i=0; i<g_worldTable[idx].gateNumber; i++)
g_worldTable[idx].spawnYaw[i] = atof( NextArg() );
}
else if( !stricmp( token, "LINKED_WORLD_IDX" ) )
{
for (i=0; i<g_worldTable[idx].gateNumber; i++)
g_worldTable[idx].linkedWorldIdx[i] = atoi( NextArg() );
}
else if( !stricmp( token, "LINKED_GATE_IDX" ) )
{
for (i=0; i<g_worldTable[idx].gateNumber; i++)
g_worldTable[idx].linkedGateIdx[i] = atoi( NextArg() );
}
}
fclose(fp);
if(buffer!=NULL)
{
delete [] buffer;
}
return true;
}
int GTH_Load2DWorld()
{
char filename[64];
int i;
int localWorldIdx;
for (i=0; i<g_worldTableNumber; i++)
{
if ( !GTH_IsLocalServiceWorld( g_worldTable[i].idx ) )
{
continue;
}
localWorldIdx = GTH_GetLocalWorldIdx( g_worldTable[i].idx );
sprintf(filename, "worlds/%s", g_worldTable[i].world2DFileName);
if ( !AI_LoadCollisionMap( filename, &g_cmap[localWorldIdx] ) )
{
g_logSystem->Write("%s - 2D Map Data Load Failure!!", filename);
MessageBox(g_hWnd, filename, "Error!", MB_OK);
return 0;
}
}
return 1;
}
void GTH_Free2DWorld()
{
int i;
for (i=0; i<g_config.serviceWorldNumber; i++)
{
free( g_cmap[i].buffer );
}
}
int GTH_World_GetGateIdx(int sourceIdx, int targetIdx)
{
int i;
if (sourceIdx < 0 || sourceIdx >= MAX_WORLDS)
return -1;
for (i=0; i<g_worldTable[sourceIdx].gateNumber; i++)
{
if (g_worldTable[sourceIdx].linkedWorldIdx[i] == targetIdx )
return g_worldTable[sourceIdx].gateIdx[i];
}
return -1;
}
| C++ |
#include "../Global.h"
CGambleSystem::CGambleSystem()
{
InitGambleSystem();
}
CGambleSystem::~CGambleSystem()
{
}
CGambleSystem::CollectGambleByType_t::CollectGambleByType_t()
{
Type = -1;
TotalGamebleRate = 0.0f;
}
CGambleSystem::CollectGambleByType_t* CGambleSystem::GetCollectGambleItem(int Type)
{
if ( Type < 0 || Type >= MAX_COUNT_OPTION_AVAILABLE_TYPE)
return NULL;
return &m_CollectGambleItemByType[Type];
}
int CGambleSystem::GetTotalGamebleTableNumber(void)
{
return m_CollectGambleTypeNumber;
}
BOOL CGambleSystem::isActiveSystem(void)
{
return m_bActiveSystem;
}
void CGambleSystem::InitGambleSystem()
{
m_bActiveSystem = TRUE;
m_CollectGambleTypeNumber = 0;
memset(m_CollectGambleItemByType, 0x00,
sizeof(CollectGambleByType_t) * MAX_COUNT_OPTION_AVAILABLE_TYPE);
}
int CGambleSystem::GetGambleItemAvallableOn( int availableon )
{
if ( availableon & OPTION_AVAILABLE_ON_DAGGER )
return CollectGambleByType_t::AVAILABLE::OPTION_AVAILABLE_ON_DAGGER ;
if ( availableon & OPTION_AVAILABLE_ON_1HSWORD )
return CollectGambleByType_t::AVAILABLE::OPTION_AVAILABLE_ON_1HSWORD ;
if ( availableon & OPTION_AVAILABLE_ON_2HSWORD )
return CollectGambleByType_t::AVAILABLE::OPTION_AVAILABLE_ON_2HSWORD;
if ( availableon & OPTION_AVAILABLE_ON_BOW )
return CollectGambleByType_t::AVAILABLE::OPTION_AVAILABLE_ON_BOW;
if ( availableon & OPTION_AVAILABLE_ON_STAFF )
return CollectGambleByType_t::AVAILABLE::OPTION_AVAILABLE_ON_STAFF;
if ( availableon & OPTION_AVAILABLE_ON_SPIRITOR )
return CollectGambleByType_t::AVAILABLE::OPTION_AVAILABLE_ON_SPIRITOR;
if ( availableon & OPTION_AVAILABLE_ON_CLAW )
return CollectGambleByType_t::AVAILABLE::OPTION_AVAILABLE_ON_CLAW;
if ( availableon & OPTION_AVAILABLE_ON_UPPER )
return CollectGambleByType_t::AVAILABLE::OPTION_AVAILABLE_ON_UPPER;
if ( availableon & OPTION_AVAILABLE_ON_LOWER )
return CollectGambleByType_t::AVAILABLE::OPTION_AVAILABLE_ON_LOWER;
if ( availableon & OPTION_AVAILABLE_ON_AIRPROTECTOR )
return CollectGambleByType_t::AVAILABLE::OPTION_AVAILABLE_ON_AIRPROTECTOR;
if ( availableon & OPTION_AVAILABLE_ON_BODYPROTECTOR )
return CollectGambleByType_t::AVAILABLE::OPTION_AVAILABLE_ON_BODYPROTECTOR;
if ( availableon & OPTION_AVAILABLE_ON_GLOVES )
return CollectGambleByType_t::AVAILABLE::OPTION_AVAILABLE_ON_GLOVES;
if ( availableon & OPTION_AVAILABLE_ON_BOOTS )
return CollectGambleByType_t::AVAILABLE::OPTION_AVAILABLE_ON_BOOTS;
if ( availableon & OPTION_AVAILABLE_ON_RING )
return CollectGambleByType_t::AVAILABLE::OPTION_AVAILABLE_ON_RING;
if ( availableon & OPTION_AVAILABLE_ON_NECKLACE )
return CollectGambleByType_t::AVAILABLE::OPTION_AVAILABLE_ON_NECKLACE;
if ( availableon & OPTION_AVAILABLE_ON_BRACELET )
return CollectGambleByType_t::AVAILABLE::OPTION_AVAILABLE_ON_BRACELET;
if ( availableon & OPTION_AVAILABLE_ON_EARRING )
return CollectGambleByType_t::AVAILABLE::OPTION_AVAILABLE_ON_EARRING;
if ( availableon & OPTION_AVAILABLE_ON_EPACK )
return CollectGambleByType_t::AVAILABLE::OPTION_AVAILABLE_ON_EPACK;
return -1;
}
void CGambleSystem::CollectGambleItems(void)
{
for (int tableIdx = 0; tableIdx < g_itemTableNumber; tableIdx ++)
{
if ( g_itemTable[tableIdx].idx < 0 )
continue;
int availableOn = GetItemAvailalbeOn( g_itemTable[tableIdx].idx );
int type = GetGambleItemAvallableOn(availableOn);
if ( !strcmp (g_itemTable[tableIdx].name, "BLANK" ) )
continue;
if ( g_itemTable[tableIdx].sellYn < 2)
continue;
if ( type == -1)
type = CollectGambleByType_t.OPTION_AVAILABLE_ON_ETC;
m_CollectGambleItemByType[type].Type = availableOn;
if ( m_CollectGambleItemByType[type].vGambleItem.empty() )
m_CollectGambleTypeNumber++;
float GamebleRate = g_logic.gambleitemSelectRate[g_itemTable[tableIdx].rarity];
CollectGambleByType_t::GambleItem_t GambleItem;
GambleItem.ItemIdx = g_itemTable[tableIdx].idx;
GambleItem.GambleRate = GamebleRate;
m_CollectGambleItemByType[type].vGambleItem.push_back(GambleItem);
m_CollectGambleItemByType[type].TotalGamebleRate += GamebleRate;
}
}
void CGambleSystem::CollectGambleOptions(void)
{
for (int tableIdx =0; tableIdx < MAX_COUNT_OPTION_AVAILABLE_TYPE; tableIdx ++)
{
if ( m_CollectGambleItemByType[tableIdx].Type <= 0 ) continue;
for( int OptionTableIdx = 0; OptionTableIdx < MAX_COUNT_OPTION_TABLE; OptionTableIdx ++ )
{
if( g_optionTable[OptionTableIdx].idx < 0 ) continue;
if( !( g_optionTable[OptionTableIdx].availableOn & m_CollectGambleItemByType[tableIdx].Type ) )
continue;
m_CollectGambleItemByType[tableIdx].vAvailableOption.push_back(
g_optionTable[OptionTableIdx].idx);
}
}
}
void CGambleSystem::InitMakeStore(storeStruct_t* pMakestore)
{
if ( pMakestore == NULL )
return;
memset(pMakestore, 0, sizeof(storeStruct_t));
pMakestore->itemNumber = 0;
for (int PageIdx = 0; PageIdx < MAX_NUMBER_OF_STORE_ITEM_PAGE; PageIdx++)
{
memset(&pMakestore->defaultItem[PageIdx], 0, sizeof(storeDefaultItemStruct_t));
memset(&pMakestore->defaultItem[PageIdx].itemIndex, -1,
sizeof(int) * MAX_NUMBER_OF_STORE_DEFAULT_ITEM);
pMakestore->defaultItem[PageIdx].defaultNumber =0;
}
for (int ItemIdx = 0; ItemIdx < MAX_NUMBER_OF_STORE_ITEM; ItemIdx++)
pMakestore->item[ItemIdx].item.itemTableIdx = -1;
}
BOOL CGambleSystem::MakeGambleStore(storeStruct_t* pMakeGamblestore,
storeStruct_t* pGamblestore, playerCharacter_t* pPc)
{
if ( pPc == NULL )
return FALSE;
if ( pMakeGamblestore == NULL)
return FALSE;
if ( pGamblestore == NULL)
return FALSE;
if ( m_bActiveSystem == FALSE)
return FALSE;
memset(pPc->RegGambleItems, -1, sizeof(int) * MAX_NUMBER_OF_STORE_ITEM);
memset(pPc->RegGamblePrice, 0, sizeof(int) * MAX_NUMBER_OF_STORE_ITEM);
InitMakeStore(pMakeGamblestore);
srand( (unsigned) time( NULL ) );
for (int StoreSlotIdx = 0; StoreSlotIdx < MAX_NUMBER_OF_STORE_ITEM; StoreSlotIdx ++)
{
storeItem_t* pStoreItem = &pGamblestore->item[StoreSlotIdx];
RandomRegsterItemToDefaultStore(pMakeGamblestore, 2 + ( rand() % MAX_REGSTER_ITEMCOUNT ), pStoreItem);
}
return DefaultItemToStore(pPc, pMakeGamblestore);
}
BOOL CGambleSystem::DefaultItemToStore(playerCharacter_t* pPc, storeStruct_t* pMakestore)
{
if ( pMakestore == NULL)
return FALSE;
int ItemPos =0;
for( int StorePageIdx = 0; StorePageIdx < MAX_NUMBER_OF_STORE_ITEM_PAGE; StorePageIdx ++ )
{
int PageRegCount =0;
for( int SlotIdx = 0; SlotIdx < MAX_NUMBER_OF_STORE_GENERATE_ITEM ; SlotIdx ++ )
{
ItemPos = pMakestore->itemNumber;
if ( ItemPos < 0 || ItemPos >= MAX_NUMBER_OF_STORE_ITEM)
return FALSE;
InitItem( &pMakestore->item[ItemPos].item );
int itemTableIdx = pMakestore->defaultItem[StorePageIdx].itemIndex[SlotIdx];
if ( itemTableIdx < 0 || itemTableIdx >= MAX_NUMBER_OF_ITEM_TABLE)
continue;
SpawnItem ( &pMakestore->item[ItemPos].item, itemTableIdx );
pMakestore->item[ItemPos].page = StorePageIdx;
pMakestore->item[ItemPos].maxNumber = pMakestore->defaultItem[StorePageIdx].itemNumber[SlotIdx];
pMakestore->item[ItemPos].curNumber = pMakestore->defaultItem[StorePageIdx].itemNumber[SlotIdx];
int Selecteditemidx = SelectCollectedItem(&pMakestore->item[ItemPos]);
float AddPrice = (rand() %( (int)g_logic.GamblePriceRate ) )* 0.01;
int CalPrice = 0;
if ( pMakestore->item[ItemPos].item.itemTableIdx == QUESTION_MARK_ITEM_TABLE_IDX)
{
pPc->RegGamblePrice[ItemPos] = g_itemTable[QUESTION_MARK_ITEM_TABLE_IDX].gambleCost;
pMakestore->item[ItemPos].price = g_itemTable[QUESTION_MARK_ITEM_TABLE_IDX].gambleCost;
}
else
{
if ( GTH_Random() > 0.5 )
{
CalPrice = g_itemTable[Selecteditemidx].gambleCost +
(int)( ((float)(g_itemTable[Selecteditemidx].gambleCost) * AddPrice ) + 0.5f);
}
else
{
CalPrice = g_itemTable[Selecteditemidx].gambleCost -
(int)( ((float)(g_itemTable[Selecteditemidx].gambleCost) * AddPrice ) + 0.5f);
}
if ( CalPrice < 0)
CalPrice = 1;
pPc->RegGamblePrice[ItemPos] = CalPrice;
pMakestore->item[ItemPos].price = CalPrice;
}
PageRegCount++;
pPc->RegGambleItems[ItemPos] = Selecteditemidx;
pMakestore->itemNumber++;
}
}
return TRUE;
}
BOOL CGambleSystem::RandomRegsterItemToDefaultStore(storeStruct_t* pMakestore, int MaxCount, storeItem_t *pStoreItem)
{
int RegsterCount = 0;
int SkipCount = 0;
if ( pStoreItem->page < 0 || pStoreItem->page >= MAX_NUMBER_OF_STORE_ITEM_PAGE)
return FALSE;
if (pStoreItem->item.itemTableIdx < 0 || pStoreItem->item.itemTableIdx >= MAX_NUMBER_OF_ITEM_TABLE)
return FALSE;
if (strlen(pStoreItem->item.name) <= 0 )
return FALSE;
if ( MaxCount >= MAX_REGSTER_ITEMCOUNT)
MaxCount = MAX_REGSTER_ITEMCOUNT;
storeDefaultItemStruct_t* pDefaultItem = &pMakestore->defaultItem[pStoreItem->page];
while ( 1 )
{
if ( pMakestore->defaultItem[pStoreItem->page].defaultNumber>= MAX_NUMBER_OF_STORE_GENERATE_ITEM)
return FALSE;
if ( SkipCount >= MAX_NUMBER_OF_STORE_GENERATE_ITEM )
return FALSE;
if ( RegsterCount >= MaxCount )
return TRUE;
int SlotIdx = rand() % MAX_NUMBER_OF_STORE_GENERATE_ITEM;
if ( pDefaultItem->itemIndex[SlotIdx] < 0 )
{
pDefaultItem->itemIndex[SlotIdx] = pStoreItem->item.itemTableIdx;
pDefaultItem->itemNumber[SlotIdx] = 1;
pDefaultItem->defaultNumber++;
RegsterCount++;
continue;
}
SkipCount++;
}
return TRUE;
}
int CGambleSystem::SelectCollectedItem(storeItem_t* pItem)
{
int StorItemIdx = pItem->item.itemTableIdx;
int availableOn = GetItemAvailalbeOn( g_itemTable[StorItemIdx].idx );
int type = GetGambleItemAvallableOn(availableOn);
if ( type < 0 || type > CollectGambleByType_t.MAX_COUNT_OPTION_AVAILABLE_TYPE)
{
float TakeGoldItemRate = 0.8f;
if ( GTH_Random() < TakeGoldItemRate )
return GOLD_ITEM_TABLE_IDX;
int SelecttypeNum = CollectGambleByType_t::OPTION_AVAILABLE_ON_RING +
(rand() % (CollectGambleByType_t::MAX_COUNT_OPTION_AVAILABLE_TYPE -
CollectGambleByType_t::OPTION_AVAILABLE_ON_RING) );
int CurSelectTypeNum = CollectGambleByType_t::OPTION_AVAILABLE_ON_RING;
for (int typeIdx = CollectGambleByType_t::OPTION_AVAILABLE_ON_RING;
typeIdx < CollectGambleByType_t::MAX_COUNT_OPTION_AVAILABLE_TYPE; typeIdx ++)
{
if ( m_CollectGambleItemByType[typeIdx].vGambleItem.size() )
CurSelectTypeNum++;
if ( SelecttypeNum <= CurSelectTypeNum)
{
type = typeIdx;
break;
}
}
if ( !m_CollectGambleItemByType[type].vGambleItem.size() )
return GOLD_ITEM_TABLE_IDX;
}
float SelectRate = 0.0f;
float accPro = 0.0f;
SelectRate = GTH_Random();
float TotalRate = m_CollectGambleItemByType[type].TotalGamebleRate;
int selectGambleItemidx = -1;
int selectRanNum = rand() % m_CollectGambleItemByType[type].vGambleItem.size();
for (int i =0; i < m_CollectGambleItemByType[type].vGambleItem.size(); i ++, selectRanNum++)
{
if ( selectRanNum >= m_CollectGambleItemByType[type].vGambleItem.size())
selectRanNum = 0;
accPro += m_CollectGambleItemByType[type].vGambleItem[selectRanNum].GambleRate / TotalRate;
if ( SelectRate < accPro )
break;
TotalRate -= m_CollectGambleItemByType[type].vGambleItem[selectRanNum].GambleRate;
}
if ( selectRanNum < 0 )
selectRanNum = 0 ;
if ( selectRanNum > MAX_NUMBER_OF_ITEM_TABLE)
{
if ( m_CollectGambleItemByType[type].vGambleItem.size() > 0)
selectRanNum = m_CollectGambleItemByType[type].vGambleItem.size() -1;
}
return m_CollectGambleItemByType[type].vGambleItem[selectRanNum].ItemIdx;
}
#include "../CTools.h"
extern CTools* gcpTools;
void CGambleSystem::SetActiveSystem(BOOL bActive)
{
m_bActiveSystem = bActive;
}
| C++ |
#include "../Global.h"
#include "../Tools/CTools.h"
extern CTools* gcpTools;
extern void TransmitePacket_sc_disconnect(playerCharacter_t* pPlayer, int MessageIdx =0);
void GTH_DecodeCashMallItem()
{
SHORT Packet = static_cast<enum enumPacketCashMallItem>(MSG_ReadShort());
switch(Packet)
{
case REQUEST_USE_STONE_OF_SAGE:
GTH_ProcessMessageRequest_StoneOfSage();
break;
case REQUEST_USE_STONE_OF_LUCKY:
GTH_ProcessMessageRequest_StoneOfLucky();
break;
case REQUEST_USE_STONE_OF_EACH_NAME:
GTH_ProcessMessageRequest_StoneOfEachName();
break;
case REQUEST_USE_REVERSE_OF_MEMORY:
GTH_ProcessMessageRequest_ReverseOfMemory();
break;
case REQUEST_OPTION_ITEM_EDIT:
GTH_ProcessMessageRequest_OptionItemEdit();
break;
case REQUEST_OPTION_ITEM_WINCLOSE:
GTH_ProcessMessageRequest_OptionItemWinClose();
break;
case REQUEST_OPTION_ITEM_MODIFY:
GTH_ProcessMessageRequest_OptionItemModify();
break;
}
}
void GTH_ProcessMessageRequest_StoneOfSage()
{
int InvenPos = MSG_ReadLong();
if ( InvenPos < 0 || InvenPos >= MAX_NUMBER_OF_OWNITEM )
{
GTH_SendMessageReply_StoneOfSage(g_curPC, FALSE, InvenPos );
}
g_curPC->m_CashMall_OptionStone.InitCashMallItem_OptionStone();
g_curPC->m_CashMall_OptionStone.m_iUsingItemInvenIdx = InvenPos;
g_curPC->m_CashMall_OptionStone.m_iUsingItemMode =
CashMallItem_OptionStone::enumUseItemMode::STONE_OF_SAGE;
float DestroyRate =
g_logic.OptionStoneItemLogic[CashMallItem_OptionStone::enumUseItemMode::STONE_OF_SAGE].DestroyRate;
float SuccecsyRate =
g_logic.OptionStoneItemLogic[CashMallItem_OptionStone::enumUseItemMode::STONE_OF_SAGE].SuccecsRate;
GTH_SendMessageReply_StoneOfSage(g_curPC, TRUE, InvenPos , DestroyRate, SuccecsyRate);
}
void GTH_ProcessMessageRequest_StoneOfLucky()
{
int InvenPos = MSG_ReadLong();
if ( InvenPos < 0 || InvenPos >= MAX_NUMBER_OF_OWNITEM )
{
GTH_SendMessageReply_StoneOfLucky(g_curPC, FALSE, InvenPos );
}
g_curPC->m_CashMall_OptionStone.InitCashMallItem_OptionStone();
g_curPC->m_CashMall_OptionStone.m_iUsingItemInvenIdx = InvenPos;
g_curPC->m_CashMall_OptionStone.m_iUsingItemMode =
CashMallItem_OptionStone::enumUseItemMode::STONE_OF_LUCKY;
float DestroyRate =
g_logic.OptionStoneItemLogic[CashMallItem_OptionStone::enumUseItemMode::STONE_OF_LUCKY].DestroyRate;
float SuccecsyRate =
g_logic.OptionStoneItemLogic[CashMallItem_OptionStone::enumUseItemMode::STONE_OF_LUCKY].SuccecsRate;
GTH_SendMessageReply_StoneOfLucky(g_curPC, TRUE, InvenPos , DestroyRate, SuccecsyRate);
}
void GTH_ProcessMessageRequest_StoneOfEachName()
{
int InvenPos = MSG_ReadLong();
if ( InvenPos < 0 || InvenPos >= MAX_NUMBER_OF_OWNITEM )
{
GTH_SendMessageReply_StoneOfEachName(g_curPC, FALSE, InvenPos );
return;
}
g_curPC->m_CashMall_OptionStone.InitCashMallItem_OptionStone();
g_curPC->m_CashMall_OptionStone.m_iUsingItemInvenIdx = InvenPos;
g_curPC->m_CashMall_OptionStone.m_iUsingItemMode =
CashMallItem_OptionStone::enumUseItemMode::STONE_OF_EACH_NAME;
GTH_SendMessageReply_StoneOfEachName(g_curPC, TRUE, InvenPos );
}
void GTH_ProcessMessageRequest_ReverseOfMemory()
{
int InvenPos = MSG_ReadLong();
if ( GTH_IsEquipItem(g_curPC) == TRUE )
{
GTH_SendMessageReply_ReverseOfMemory(g_curPC, FALSE, CASHMALL_ITEM_ERROR_0, InvenPos );
return;
}
if ( GTH_IsAwakenJob ( g_curPC ) == FALSE )
{
GTH_SendMessageReply_ReverseOfMemory(g_curPC, FALSE, CASHMALL_ITEM_ERROR_1, InvenPos);
return;
}
item_t* pUseitem = NULL;
pUseitem = gcpTools->GetMyInventoryItem(g_curPC, InvenPos);
if ( pUseitem == NULL )
{
GTH_SendMessageReply_ReverseOfMemory(g_curPC, FALSE, CASHMALL_ITEM_ERROR_4, InvenPos);
return;
}
vector<int> vDeletedSkill;
if ( GTH_ClearAwakenJob(g_curPC, &vDeletedSkill) == FALSE )
{
GTH_SendMessageReply_ReverseOfMemory(g_curPC, FALSE, CASHMALL_ITEM_ERROR_5, InvenPos);
return;
}
GTH_UseItem_Delete(InvenPos);
GTH_SendPCMessage_ReplyGenChange(g_curPC);
GTH_SendMessageReply_ReverseOfMemory(g_curPC, TRUE, -1, InvenPos , &vDeletedSkill);
return;
}
void GTH_ProcessMessageRequest_OptionItemEdit()
{
if( g_curPC->mouseInventory >= 0 )
{
if ( g_curPC->m_CashMall_OptionStone.m_iEditOptionItemIdx >= 0)
{
int tempInven = g_curPC->mouseInventory;
g_curPC->mouseInventory = g_curPC->m_CashMall_OptionStone.m_iEditOptionItemIdx;
g_curPC->m_CashMall_OptionStone.m_iEditOptionItemIdx = tempInven;
}
else
{
g_curPC->m_CashMall_OptionStone.m_iEditOptionItemIdx = g_curPC->mouseInventory;
g_curPC->mouseInventory = -1;
}
}
else
{
if ( g_curPC->m_CashMall_OptionStone.m_iEditOptionItemIdx >= 0)
{
g_curPC->mouseInventory = g_curPC->m_CashMall_OptionStone.m_iEditOptionItemIdx;
g_curPC->m_CashMall_OptionStone.m_iEditOptionItemIdx =-1;
}
}
GTH_SendMessageReply_OptionItemEdit( g_curPC, FALSE, g_curPC->mouseInventory,
g_curPC->m_CashMall_OptionStone.m_iEditOptionItemIdx);
}
void GTH_SendMessageReply_StoneOfSage(playerCharacter_t* pPc, BOOL Reply, int InvenPos, float DestroyRate, float SuccecsRate)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, CASH_MALL_ITEM );
MSG_WriteShort(&netMessage, REPLY_USE_STONE_OF_SAGE );
MSG_WriteLong(&netMessage, Reply);
if ( Reply == TRUE)
{
MSG_WriteLong(&netMessage, InvenPos);
MSG_WriteFloat(&netMessage, DestroyRate);
MSG_WriteFloat(&netMessage, SuccecsRate);
}
NET_SendMessage(&pPc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessageReply_StoneOfLucky(playerCharacter_t* pPc, BOOL Reply, int InvenPos, float DestroyRate, float SuccecsRate)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, CASH_MALL_ITEM );
MSG_WriteShort(&netMessage, REPLY_USE_STONE_OF_LUCKY );
MSG_WriteLong(&netMessage, Reply);
if ( Reply == TRUE)
{
MSG_WriteLong(&netMessage, InvenPos);
MSG_WriteFloat(&netMessage, DestroyRate);
MSG_WriteFloat(&netMessage, SuccecsRate);
}
NET_SendMessage(&pPc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessageReply_StoneOfEachName(playerCharacter_t* pPc, BOOL Reply, int InvenPos)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, CASH_MALL_ITEM );
MSG_WriteShort(&netMessage, REPLY_USE_STONE_OF_EACH_NAME );
MSG_WriteLong(&netMessage, Reply);
if ( Reply == TRUE)
MSG_WriteLong(&netMessage, InvenPos);
NET_SendMessage(&pPc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessageReply_ReverseOfMemory(playerCharacter_t* pPc, BOOL Reply, int ErrorIdx, int InvenPos, vector<int>* pVSkill)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, CASH_MALL_ITEM );
MSG_WriteShort(&netMessage, REPLY_USE_REVERSE_OF_MEMORY );
MSG_WriteLong(&netMessage, Reply);
if ( Reply == TRUE)
{
MSG_WriteLong(&netMessage, InvenPos);
MSG_WriteLong(&netMessage, pPc->pcJob);
for (int Idx =0; Idx < GEN_NUMBER; Idx ++)
MSG_WriteLong(&netMessage, pPc->genCapability[Idx]);
for (int HotKeyIdx = 0 ; HotKeyIdx< MAX_NUMBER_OF_HOTKEY; HotKeyIdx ++)
{
MSG_WriteLong(&netMessage, pPc->hotkeyType[HotKeyIdx]);
MSG_WriteLong(&netMessage, pPc->hotkeyIdx[HotKeyIdx]);
}
if ( pVSkill != NULL )
{
MSG_WriteLong(&netMessage, pVSkill->size());
for (int SkillIdx = 0; SkillIdx < pVSkill->size(); SkillIdx++)
{
Idx = (*pVSkill)[SkillIdx];
MSG_WriteLong(&netMessage, Idx);
}
}
else
MSG_WriteLong(&netMessage, 0);
}
else
MSG_WriteLong(&netMessage, ErrorIdx);
NET_SendMessage(&pPc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessageReply_OptionItemEdit(playerCharacter_t* pPc, BOOL bError,
int MouseInvenPos, int EditInevenPos)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, CASH_MALL_ITEM );
MSG_WriteShort(&netMessage, REPLY_OPTION_ITEM_EDIT );
MSG_WriteLong(&netMessage, bError);
if ( bError == FALSE)
{
MSG_WriteLong(&netMessage, MouseInvenPos);
MSG_WriteLong(&netMessage, EditInevenPos);
}
NET_SendMessage(&pPc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void InitCashMallItem(playerCharacter_t* pPc)
{
if ( pPc == NULL)
return ;
pPc->m_CashMall_OptionStone.m_iEditOptionItemIdx = -1;
}
void GTH_ProcessMessageRequest_OptionItemWinClose()
{
BOOL bError = FALSE;
if ( g_curPC->m_CashMall_OptionStone.m_iEditOptionItemIdx != -1)
{
bError = !GTH_AddMyInventory_ForRegsitedItem(g_curPC,
g_curPC->m_CashMall_OptionStone.m_iEditOptionItemIdx);
InitCashMallItem(g_curPC);
}
GTH_SendMessageRePly_OptionItemWinClose(g_curPC, bError);
}
void GTH_SendMessageRePly_OptionItemWinClose(playerCharacter_t* pPc, BOOL bError)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, CASH_MALL_ITEM );
MSG_WriteShort(&netMessage, REPLY_OPTION_ITEM_WINCLOSE );
MSG_WriteLong(&netMessage, bError);
NET_SendMessage(&pPc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_ProcessMessageRequest_OptionItemModify()
{
enum CashMallItem_OptionStone::enumUseItemMode mode;
mode = static_cast<enum CashMallItem_OptionStone::enumUseItemMode>(MSG_ReadLong());
switch(mode)
{
case CashMallItem_OptionStone::enumUseItemMode::STONE_OF_SAGE:
ItemModify_Stone_of_sage();
break;
case CashMallItem_OptionStone::enumUseItemMode::STONE_OF_LUCKY:
ItemModify_Stone_of_lucky();
break;
case CashMallItem_OptionStone::enumUseItemMode::STONE_OF_EACH_NAME:
ItemModify_Stone_of_each_name();
break;
}
}
void GTH_SendMessageRePly_OptionItemModify(playerCharacter_t* pPc, enum CashMallItem_OptionStone::enumUseItemMode mode,
BOOL Reply, item_t* pItem, int ErrorIdx)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, CASH_MALL_ITEM );
MSG_WriteShort(&netMessage, REPLY_OPTION_ITEM_MODIFY );
MSG_WriteLong(&netMessage, mode );
MSG_WriteLong(&netMessage, Reply);
if ( Reply == TRUE)
MSG_WriteItem(&netMessage, pItem);
else
MSG_WriteLong(&netMessage, ErrorIdx);
NET_SendMessage(&pPc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void ItemModify_Stone_of_sage()
{
int SelectOptionIdx = MSG_ReadLong();
int ItemIdx = g_curPC->m_CashMall_OptionStone.m_iEditOptionItemIdx;
int UseItemIdx = g_curPC->m_CashMall_OptionStone.m_iUsingItemInvenIdx;
CashMallItem_OptionStone::enumUseItemMode mode =
CashMallItem_OptionStone::enumUseItemMode::STONE_OF_SAGE ;
item_t* pSrcItem = NULL;
item_t* pUsetem = NULL;
item_t TempItem;
pSrcItem = gcpTools->GetMyItem(g_curPC, ItemIdx);
pUsetem = gcpTools->GetMyInventoryItem(g_curPC, UseItemIdx);
if ( pSrcItem == NULL )
{
GTH_SendMessageRePly_OptionItemModify(g_curPC, mode,
FALSE, NULL, CASHMALL_ITEM_ERROR_0);
return;
}
if ( SelectOptionIdx < 0 || SelectOptionIdx >= MAX_NUMBER_OF_ITEM_OPTION)
{
GTH_SendMessageRePly_OptionItemModify(g_curPC, mode,
FALSE, NULL, CASHMALL_ITEM_ERROR_1);
return;
}
if ( pUsetem == NULL )
{
TransmitePacket_sc_disconnect(g_curPC);
return;
}
if ( pUsetem->itemTableIdx !=
CashMallItem_OptionStone::enumCashMall_ItemIdx::STONE_OF_SAGE_IDX)
{
TransmitePacket_sc_disconnect(g_curPC);
return;
}
if ( pSrcItem->itemTableIdx < 0 || pSrcItem->itemTableIdx >= MAX_NUMBER_OF_ITEM_TABLE)
{
GTH_SendMessageRePly_OptionItemModify(g_curPC, mode,
FALSE, NULL, CASHMALL_ITEM_ERROR_0);
return;
}
int availableOn = GetItemAvailalbeOn( pSrcItem->itemTableIdx );
if ( availableOn >= OPTION_AVAILABLE_ON_RING || pSrcItem->itemTableIdx == MONSTERCARD_ITEM_INDEX)
{
GTH_SendMessageRePly_OptionItemModify(g_curPC, mode,
FALSE, NULL, CASHMALL_ITEM_ERROR_7 );
return;
}
float SuccecsRate =
g_logic.OptionStoneItemLogic[CashMallItem_OptionStone::enumUseItemMode::STONE_OF_SAGE].SuccecsRate;
float DestroyRate =
g_logic.OptionStoneItemLogic[CashMallItem_OptionStone::enumUseItemMode::STONE_OF_SAGE].DestroyRate;
if ( GTH_Random() >= SuccecsRate * 0.01)
{
if ( GTH_Random() < DestroyRate * 0.01)
{
GTH_DeleteMyItem(g_curPC, pSrcItem );
g_DBGameServer->RemoveItem(g_curPC, ItemIdx);
GTH_UseItem_Delete(UseItemIdx);
g_curPC->m_CashMall_OptionStone.InitCashMallItem_OptionStone();
g_curPC->m_CashMall_OptionStone.m_iUsingItemMode =
CashMallItem_OptionStone::enumUseItemMode::STONE_OF_SAGE;
GTH_SendMessageRePly_OptionItemModify(g_curPC, mode, FALSE, NULL, CASHMALL_ITEM_ERROR_5);
return;
}
else
{
GTH_UseItem_Delete(UseItemIdx);
GTH_SendMessageRePly_OptionItemModify(g_curPC, mode, FALSE, NULL, CASHMALL_ITEM_ERROR_6);
return;
}
}
int OptionTableIdx = pSrcItem->optionIdx[SelectOptionIdx];
int LoopCount = 0;
while ( 1 )
{
if ( FALSE == SpawnItem(&TempItem, pSrcItem->itemTableIdx, MAX_NUMBER_OF_ITEM_OPTION,
1 ) )
{
GTH_SendMessageRePly_OptionItemModify(g_curPC, mode,
FALSE, NULL, CASHMALL_ITEM_ERROR_2);
return;
}
for (int SpawnOptionArryIdx = 0; SpawnOptionArryIdx < TempItem.optionNumber; SpawnOptionArryIdx++)
{
if ( IsExistenceItemOption(pSrcItem,
TempItem.optionIdx[SpawnOptionArryIdx]) == 0)
{
pSrcItem->optionIdx[SelectOptionIdx] = TempItem.optionIdx[SpawnOptionArryIdx];
pSrcItem->optionValue[SelectOptionIdx] = SelectOptionGrade(g_curPC->m_CashMall_OptionStone.m_iUsingItemMode);;
g_DBGameServer->SaveItem( g_curPC, pSrcItem, ItemIdx );
GTH_UseItem_Delete(UseItemIdx);
GTH_SendMessageRePly_OptionItemModify(g_curPC, mode, TRUE, pSrcItem);
return;
}
}
LoopCount++;
if ( LoopCount >= MAX_NUMBER_OF_ITEM_OPTION )
{
GTH_SendMessageRePly_OptionItemModify(g_curPC, mode,
FALSE, pSrcItem, CASHMALL_ITEM_ERROR_3);
return;
}
}
}
void ItemModify_Stone_of_lucky()
{
int ItemIdx = g_curPC->m_CashMall_OptionStone.m_iEditOptionItemIdx;
int UseItemIdx = g_curPC->m_CashMall_OptionStone.m_iUsingItemInvenIdx;
CashMallItem_OptionStone::enumUseItemMode mode =
CashMallItem_OptionStone::enumUseItemMode::STONE_OF_LUCKY ;
item_t* pSrcItem = NULL;
item_t* pUsetem = NULL;
item_t TempItem;
pSrcItem = gcpTools->GetMyItem(g_curPC, ItemIdx);
pUsetem = gcpTools->GetMyInventoryItem(g_curPC, UseItemIdx);
if ( pSrcItem == NULL )
{
GTH_SendMessageRePly_OptionItemModify(g_curPC, mode,
FALSE, NULL, CASHMALL_ITEM_ERROR_0);
return;
}
if ( pUsetem == NULL )
{
TransmitePacket_sc_disconnect(g_curPC);
return;
}
if ( pUsetem->itemTableIdx !=
CashMallItem_OptionStone::enumCashMall_ItemIdx::STONE_OF_LUCKY_IDX)
{
TransmitePacket_sc_disconnect(g_curPC);
return;
}
if ( pSrcItem->optionNumber >= MAX_NUMBER_OF_ITEM_OPTION )
{
GTH_SendMessageRePly_OptionItemModify(g_curPC, mode,
FALSE, NULL, CASHMALL_ITEM_ERROR_3);
return;
}
if ( pSrcItem->itemTableIdx < 0 || pSrcItem->itemTableIdx >= MAX_NUMBER_OF_ITEM_TABLE)
{
GTH_SendMessageRePly_OptionItemModify(g_curPC, mode,
FALSE, NULL, CASHMALL_ITEM_ERROR_0);
return;
}
int availableOn = GetItemAvailalbeOn( pSrcItem->itemTableIdx );
if ( availableOn >= OPTION_AVAILABLE_ON_RING || pSrcItem->itemTableIdx == MONSTERCARD_ITEM_INDEX )
{
GTH_SendMessageRePly_OptionItemModify(g_curPC, mode,
FALSE, NULL, CASHMALL_ITEM_ERROR_7 );
return;
}
float SuccecsRate =
g_logic.OptionStoneItemLogic[CashMallItem_OptionStone::enumUseItemMode::STONE_OF_LUCKY].SuccecsRate;
float DestroyRate =
g_logic.OptionStoneItemLogic[CashMallItem_OptionStone::enumUseItemMode::STONE_OF_LUCKY].DestroyRate;
if ( GTH_Random() >= SuccecsRate * 0.01)
{
if ( GTH_Random() < DestroyRate * 0.01)
{
GTH_DeleteMyItem(g_curPC, pSrcItem );
g_DBGameServer->RemoveItem(g_curPC, ItemIdx);
GTH_UseItem_Delete(UseItemIdx);
g_curPC->m_CashMall_OptionStone.InitCashMallItem_OptionStone();
g_curPC->m_CashMall_OptionStone.m_iUsingItemMode =
CashMallItem_OptionStone::enumUseItemMode::STONE_OF_LUCKY;
GTH_SendMessageRePly_OptionItemModify(g_curPC, mode, FALSE, NULL, CASHMALL_ITEM_ERROR_5);
return;
}
else
{
GTH_UseItem_Delete(UseItemIdx);
GTH_SendMessageRePly_OptionItemModify(g_curPC, mode, FALSE, NULL, CASHMALL_ITEM_ERROR_6);
return;
}
}
int LoopCount = 0;
while ( 1 )
{
if ( FALSE == SpawnItem(&TempItem, pSrcItem->itemTableIdx, MAX_NUMBER_OF_ITEM_OPTION,
1 ) )
{
GTH_SendMessageRePly_OptionItemModify(g_curPC, mode,
FALSE, NULL, CASHMALL_ITEM_ERROR_2);
return;
}
for (int SpawnOptionArryIdx = 0; SpawnOptionArryIdx < TempItem.optionNumber; SpawnOptionArryIdx++)
{
if ( IsExistenceItemOption(pSrcItem,
TempItem.optionIdx[SpawnOptionArryIdx]) == 0)
{
pSrcItem->optionIdx[pSrcItem->optionNumber] = TempItem.optionIdx[SpawnOptionArryIdx];
pSrcItem->optionValue[pSrcItem->optionNumber] = SelectOptionGrade(g_curPC->m_CashMall_OptionStone.m_iUsingItemMode);
pSrcItem->optionNumber++;
g_DBGameServer->SaveItem( g_curPC, pSrcItem, ItemIdx );
GTH_UseItem_Delete(UseItemIdx);
GTH_SendMessageRePly_OptionItemModify(g_curPC, mode, TRUE, pSrcItem);
return;
}
}
LoopCount++;
if ( LoopCount >= MAX_NUMBER_OF_ITEM_OPTION )
{
GTH_SendMessageRePly_OptionItemModify(g_curPC, mode,
FALSE, pSrcItem, CASHMALL_ITEM_ERROR_3);
return;
}
}
}
void ItemModify_Stone_of_each_name()
{
int SelectOptionIdx = MSG_ReadLong();
int ItemIdx = g_curPC->m_CashMall_OptionStone.m_iEditOptionItemIdx;
int UseItemIdx = g_curPC->m_CashMall_OptionStone.m_iUsingItemInvenIdx;
CashMallItem_OptionStone::enumUseItemMode mode =
CashMallItem_OptionStone::enumUseItemMode::STONE_OF_EACH_NAME ;
item_t* pSrcItem = NULL;
item_t* pUsetem = NULL;
pSrcItem = gcpTools->GetMyItem(g_curPC, ItemIdx);
pUsetem = gcpTools->GetMyInventoryItem(g_curPC, UseItemIdx);
if ( pSrcItem == NULL )
{
GTH_SendMessageRePly_OptionItemModify(g_curPC, mode,
FALSE, NULL, CASHMALL_ITEM_ERROR_0);
return;
}
if ( SelectOptionIdx < 0 || SelectOptionIdx >= MAX_NUMBER_OF_ITEM_OPTION)
{
GTH_SendMessageRePly_OptionItemModify(g_curPC, mode,
FALSE, NULL, CASHMALL_ITEM_ERROR_1);
return;
}
if ( pUsetem == NULL )
{
TransmitePacket_sc_disconnect(g_curPC);
return;
}
if ( pUsetem->itemTableIdx !=
CashMallItem_OptionStone::enumCashMall_ItemIdx::STONE_OF_EACH_NAME_IDX)
{
TransmitePacket_sc_disconnect(g_curPC);
return;
}
if ( pSrcItem->optionNumber <= 0)
{
GTH_SendMessageRePly_OptionItemModify(g_curPC, mode,
FALSE, NULL, CASHMALL_ITEM_ERROR_5);
return;
}
for(int ArryIdx =0; ArryIdx<pSrcItem->optionNumber; ArryIdx++)
{
if( ArryIdx == SelectOptionIdx )
{
pSrcItem->optionIdx[SelectOptionIdx] = -1;
pSrcItem->optionValue[SelectOptionIdx] = -1;
}
else if( ArryIdx > SelectOptionIdx )
{
pSrcItem->optionIdx[ArryIdx-1] = pSrcItem->optionIdx[ArryIdx];
pSrcItem->optionValue[ArryIdx-1] = pSrcItem->optionValue[ArryIdx];
pSrcItem->optionIdx[ArryIdx] = -1;
pSrcItem->optionValue[ArryIdx] = -1;
}
}
pSrcItem->optionNumber--;
g_DBGameServer->SaveItem( g_curPC, pSrcItem, ItemIdx );
GTH_UseItem_Delete(UseItemIdx);
GTH_SendMessageRePly_OptionItemModify(g_curPC, mode, TRUE, pSrcItem);
}
int IsExistenceItemOption(item_t *pItem, int OptionIdx)
{
if ( pItem == NULL)
return -1;
for (int OptionArryIdx = 0; OptionArryIdx < pItem->optionNumber; OptionArryIdx++)
{
if ( pItem->optionIdx[OptionArryIdx] == OptionIdx)
return 1;
}
return 0;
}
int SelectOptionGrade(enum CashMallItem_OptionStone::enumUseItemMode mode)
{
float GraderandomVal = 0.0f;
float GradeaccPro = 0.0f;
GraderandomVal = GTH_Random();
for( int OptionGradeNum = 0; OptionGradeNum < MAX_NUMBER_OF_OPTION_VALUE_GRADE ; OptionGradeNum ++ )
{
GradeaccPro += (float) g_logic.OptionStoneItemLogic[mode].OptionGrade[OptionGradeNum] * 0.01;
if( GraderandomVal < GradeaccPro ) break;
}
OptionGradeNum += 1;
if ( OptionGradeNum < 0 )
OptionGradeNum = 1;
if (OptionGradeNum > MAX_NUMBER_OF_OPTION_VALUE_GRADE )
OptionGradeNum = MAX_NUMBER_OF_OPTION_VALUE_GRADE;
return OptionGradeNum;
} | C++ |
#if !defined(AFX_CGUILDCTRL_H__5DBD128C_7D39_4CF2_8E24_F92494C75936__INCLUDED_)
#define AFX_CGUILDCTRL_H__5DBD128C_7D39_4CF2_8E24_F92494C75936__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CGuildCtrl
{
public:
enum enumGsvrMsvr{
fromGsvr_toMsvr_Summary_Req=0,
fromMsvr_toGsvr_Summary_Res,
fromMsvr_toGsvr_Organize_Notify,
fromMsvr_toGsvr_DisOrganize_Notify,
fromGsvr_toMsvr_MarkChange_Req,
fromMsvr_toGsvr_MarkChange_Notify,
};
enum enumClientGsvr{
fromClient_toGsvr_Summary_Req=0,
fromGsvr_toClient_Summary_Res,
fromClient_toGsvr_MarkChange_Req,
fromGsvr_toClient_MarkCheck_Req,
fromClient_toGsvr_MarkImage_Req,
fromGsvr_toClient_MarkImage_Res,
fromGsvr_toClient_DisOrganize_Notify,
fromGsvr_toClient_MarkChange_Res,
};
struct tagPacket_fromGsvr_toClient_MarkChange_Res{
enum enumCode{
Success=0,
error_delay_hour,
error_unknown,
};
};
private:
struct tagGuildSummarySyncRecord{
public:
struct tagMark{
unsigned char Image[GUILDMARKSIZE];
long ChangeDate;
};
struct tagSync{
public:
struct tagRequest{
BOOL bDo;
int Time;
};
public:
BOOL bComplete;
struct tagRequest Request;
};
public:
struct tagSync Sync;
BOOL bActive;
char Name[GUILDNAMESTRING+1];
struct tagMark Mark;
};
BOOL m_bOK;
struct tagGuildSummarySyncRecord m_SummarySyncRecord[MAX_GUILDS];
int m_transmite_req_sync_at_manager_server_number;
protected:
BOOL Init(void);
inline BOOL ValidCheck_GuildIndex(const int Idx) const;
inline BOOL ValidCheck(const guild_t* pGuild) const;
inline BOOL ValidCheck_MemberServerIndex(const int MemberServerIdx) const;
protected:
inline void GTH_SendMessage_Guild_Summary_Request_To_ManagerServer(const int Idx);
public:
BOOL isOK(void) const;
static void strcpy_null_terminate(char* destStr,const char* sourceStr,const int bytes);
void InitWhenManagerServer(void);
int Get_transmite_req_sync_at_manager_server_number(void) const;
public:
struct tagGuildSummarySyncRecord* GetSummaryRecordPointer(const int Idx);
public:
guild_t* GetRecordPointer(const int Idx);
guild_t* GetRecordPointerWithoutValidCheck(const int Idx);
int GetIndexByName(const char* szpGuildName);
public:
void BetweenMsGs_ManageServerDecoder(void);
inline void BetweenMsGs_ManagerServerDecoder_MarkChange_Req(void);
inline void BetweenMsGs_ManageServerDecoder_Summary_Req(void);
inline void TransmiteAtMs_UpdateMark(const int GuildIdx,const unsigned char* pMark);
public:
void BetweenMsGs_GameServerDecoder(void);
inline void BetweenMsGs_GameServerDecoder_Summary_Res(void);
inline void BetweenMsGs_GameServerDecoder_Organize_Notify(void);
inline void BetweenMsGs_GameServerDecoder_DisOrganize_Notify(void);
inline void BetweenMsGs_GameServerDecoder_MarkChange_Notify(void);
inline void TransmiteAtGs_SyncPacket_Organize(const int GuildIdx);
inline void TransmiteAtGs_SyncPacket_DisOrganize(const int GuildIdx);
inline void TransmiteAtGs_SyncPacket_UpdateMark(const int GuildIdx,const struct tagGuildSummarySyncRecord* pSummaryRecord);
inline void ManagerServerProc_MarkChange(const int GuildIdx,const unsigned char* pMarkImage);
void ManagerServerProc_Organize(const int GuildIdx,const char* pName,const unsigned char* pMarkImage);
void ManagerServerProc_DisOrganize(const int GuildIdx);
public:
void BetweenClientGs_Decoder(void);
inline void BetweenClientGs_Decoder_MarkChange_Req(void);
inline void BetweenClientGs_Decoder_Summary_Req(void);
inline void BetweenClientGs_Decoder_MarkImage_Req(void);
protected:
inline void TransmiteAtClient_MarkCheck_Req(const int GuildIdx,const struct tagGuildSummarySyncRecord* pSummaryRecord);
inline void TransmiteAtClient_DisOrganize_Notify(const int GuildIdx);
inline void TransmiteAtClient_MarkChange_Res(
playerCharacter_t* pPc,
enum tagPacket_fromGsvr_toClient_MarkChange_Res::enumCode code,
const int data) const;
public:
CGuildCtrl();
virtual ~CGuildCtrl();
};
#endif
| C++ |
#include "..\global.h"
#include "CGuildCtrl.h"
#include "Shlwapi.h"
CGuildCtrl::CGuildCtrl()
{
m_bOK=FALSE;
m_transmite_req_sync_at_manager_server_number=0;
if(FALSE == Init()) return;
m_bOK=TRUE;
}
CGuildCtrl::~CGuildCtrl()
{
}
BOOL CGuildCtrl::isOK(void) const
{
return m_bOK;
}
inline BOOL CGuildCtrl::
ValidCheck_MemberServerIndex(const int MemberServerIdx) const
{
if(0 > MemberServerIdx) return FALSE;
if(MAX_MEMBER_SERVER <= MemberServerIdx) return FALSE;
if(!g_memberServer[MemberServerIdx].active) return FALSE;
return TRUE;
}
inline void CGuildCtrl::BetweenMsGs_ManageServerDecoder_Summary_Req(void)
{
int MemberServerIdx = MSG_ReadByte();
if(FALSE == ValidCheck_MemberServerIndex(MemberServerIdx)) return;
int GuildIdx = MSG_ReadShort();
if(FALSE == ValidCheck_GuildIndex(GuildIdx)) return;
struct tagGuildSummarySyncRecord* pSummaryRecord=GetSummaryRecordPointer(GuildIdx);
if(NULL == pSummaryRecord){
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_SYNC);
MSG_WriteByte(&netMessage, enumGsvrMsvr::fromMsvr_toGsvr_Summary_Res);
MSG_WriteShort(&netMessage, GuildIdx);
MSG_WriteByte(&netMessage, FALSE);
NET_SendUnreliableMessage(&g_memberServer[MemberServerIdx].sock, &netMessage);
}
MSG_EndWriting(&netMessage);
return;
}
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_SYNC);
MSG_WriteByte(&netMessage, enumGsvrMsvr::fromMsvr_toGsvr_Summary_Res);
MSG_WriteShort(&netMessage, GuildIdx);
MSG_WriteByte(&netMessage, TRUE);
MSG_WriteString(&netMessage,pSummaryRecord->Name);
MSG_WriteLong(&netMessage, pSummaryRecord->Mark.ChangeDate);
for( int i=0; i<GUILDMARKSIZE; i++ ) MSG_WriteByte(&netMessage,pSummaryRecord->Mark.Image[i]);
NET_SendUnreliableMessage(&g_memberServer[MemberServerIdx].sock, &netMessage);
}
MSG_EndWriting(&netMessage);
return;
}
void CGuildCtrl::BetweenMsGs_ManageServerDecoder(void)
{
switch(MSG_ReadByte()){
case enumGsvrMsvr::fromGsvr_toMsvr_MarkChange_Req:
BetweenMsGs_ManagerServerDecoder_MarkChange_Req();
break;
case enumGsvrMsvr::fromGsvr_toMsvr_Summary_Req:
BetweenMsGs_ManageServerDecoder_Summary_Req();
break;
}
}
inline void CGuildCtrl::BetweenMsGs_GameServerDecoder_Summary_Res(void)
{
int GuildIdx = MSG_ReadShort();
if(FALSE == ValidCheck_GuildIndex(GuildIdx)) return;
struct tagGuildSummarySyncRecord* pSummaryRecord=&m_SummarySyncRecord[GuildIdx];
pSummaryRecord->Sync.bComplete=TRUE;
pSummaryRecord->bActive = MSG_ReadByte();
if(FALSE == pSummaryRecord->bActive) return;
StrCpyN(pSummaryRecord->Name,MSG_ReadString(),GUILDNAMESTRING);
pSummaryRecord->Name[GUILDNAMESTRING]=NULL;
pSummaryRecord->Mark.ChangeDate = MSG_ReadLong();
for(int i=0; i<GUILDMARKSIZE; i++) pSummaryRecord->Mark.Image[i]=MSG_ReadByte();
return;
}
void CGuildCtrl::BetweenMsGs_GameServerDecoder(void)
{
switch(MSG_ReadByte()){
case enumGsvrMsvr::fromMsvr_toGsvr_MarkChange_Notify:
BetweenMsGs_GameServerDecoder_MarkChange_Notify();
break;
case enumGsvrMsvr::fromMsvr_toGsvr_DisOrganize_Notify:
BetweenMsGs_GameServerDecoder_DisOrganize_Notify();
break;
case enumGsvrMsvr::fromMsvr_toGsvr_Summary_Res:
BetweenMsGs_GameServerDecoder_Summary_Res();
break;
case enumGsvrMsvr::fromMsvr_toGsvr_Organize_Notify:
BetweenMsGs_GameServerDecoder_Organize_Notify();
break;
}
}
inline void CGuildCtrl::
TransmiteAtClient_MarkChange_Res(
playerCharacter_t* pPc,
enum tagPacket_fromGsvr_toClient_MarkChange_Res::enumCode code,
const int data) const
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_SYNC);
MSG_WriteByte(&netMessage, enumClientGsvr::fromGsvr_toClient_MarkChange_Res);
MSG_WriteByte(&netMessage, code);
MSG_WriteLong(&netMessage, data);
NET_SendMessage(&(pPc->sock),&netMessage);
}
MSG_EndWriting(&netMessage);
}
inline void CGuildCtrl::TransmiteAtClient_DisOrganize_Notify(const int GuildIdx)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_SYNC);
MSG_WriteByte(&netMessage, enumClientGsvr::fromGsvr_toClient_DisOrganize_Notify);
MSG_WriteShort(&netMessage, GuildIdx);
for (int online_pc_number=0,pcIdx = 0; (pcIdx < MAX_PCS) && (online_pc_number < g_pcNumber); pcIdx++){
if( (!g_pc[pcIdx].active) || (!g_pc[pcIdx].ready)) continue;
NET_SendMessage(&g_pc[pcIdx].sock,&netMessage);
}
}
MSG_EndWriting(&netMessage);
}
inline void CGuildCtrl::BetweenMsGs_GameServerDecoder_DisOrganize_Notify(void)
{
int GuildIdx = MSG_ReadShort();
if(FALSE == ValidCheck_GuildIndex(GuildIdx)) return;
struct tagGuildSummarySyncRecord* pSummaryRecord=&m_SummarySyncRecord[GuildIdx];
pSummaryRecord->bActive=FALSE;
TransmiteAtClient_DisOrganize_Notify(GuildIdx);
}
void CGuildCtrl::
ManagerServerProc_DisOrganize(const int GuildIdx)
{
if(FALSE == ValidCheck_GuildIndex(GuildIdx)) return;
struct tagGuildSummarySyncRecord* pSummaryRecord=GetSummaryRecordPointer(GuildIdx);
if(NULL == pSummaryRecord) return;
pSummaryRecord->bActive=FALSE;
TransmiteAtGs_SyncPacket_DisOrganize(GuildIdx);
TransmiteAtClient_DisOrganize_Notify(GuildIdx);
}
inline void CGuildCtrl::TransmiteAtGs_SyncPacket_DisOrganize(const int GuildIdx)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_SYNC);
MSG_WriteByte(&netMessage, enumGsvrMsvr::fromMsvr_toGsvr_DisOrganize_Notify);
MSG_WriteShort(&netMessage, GuildIdx);
for(int hMemberServerIdx=1; hMemberServerIdx < MAX_MEMBER_SERVER; hMemberServerIdx++){
if(!g_memberServer[hMemberServerIdx].active ) continue;
NET_SendUnreliableMessage(&g_memberServer[hMemberServerIdx].sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
inline void CGuildCtrl::BetweenMsGs_GameServerDecoder_Organize_Notify(void)
{
int GuildIdx=MSG_ReadShort();
if(FALSE == ValidCheck_GuildIndex(GuildIdx)) return;
struct tagGuildSummarySyncRecord* pSummaryRecord=&m_SummarySyncRecord[GuildIdx];
StrCpyN(pSummaryRecord->Name,MSG_ReadString(),GUILDNAMESTRING);
pSummaryRecord->Name[GUILDNAMESTRING]=NULL;
pSummaryRecord->Mark.ChangeDate = MSG_ReadLong();
for(int i=0; i< GUILDMARKSIZE; i++) pSummaryRecord->Mark.Image[i]=MSG_ReadByte();
pSummaryRecord->bActive=TRUE;
pSummaryRecord->Sync.bComplete=TRUE;
}
void CGuildCtrl::ManagerServerProc_Organize(const int GuildIdx,const char* pName,const unsigned char* pMarkImage)
{
if(FALSE == ValidCheck_GuildIndex(GuildIdx)) return;
{
struct tagGuildSummarySyncRecord* pSummarySyncRecord;
pSummarySyncRecord = &m_SummarySyncRecord[GuildIdx];
pSummarySyncRecord->bActive=TRUE;
StrCpyN(pSummarySyncRecord->Name,pName,GUILDNAMESTRING);
pSummarySyncRecord->Name[GUILDNAMESTRING]=NULL;
memcpy(pSummarySyncRecord->Mark.Image,pMarkImage,GUILDMARKSIZE);
g_guild[GuildIdx].markChangeDate=
pSummarySyncRecord->Mark.ChangeDate = time(NULL);
pSummarySyncRecord->Sync.bComplete=TRUE;
g_DBGameServer->SaveGuildMark(GuildIdx);
}
TransmiteAtGs_SyncPacket_Organize(GuildIdx);
}
inline void CGuildCtrl::TransmiteAtGs_SyncPacket_Organize(const int GuildIdx)
{
struct tagGuildSummarySyncRecord* pSummaryRecord=GetSummaryRecordPointer(GuildIdx);
if(NULL == pSummaryRecord) return;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_SYNC);
MSG_WriteByte(&netMessage, enumGsvrMsvr::fromMsvr_toGsvr_Organize_Notify);
MSG_WriteShort(&netMessage, GuildIdx);
MSG_WriteString(&netMessage,pSummaryRecord->Name);
MSG_WriteLong(&netMessage,pSummaryRecord->Mark.ChangeDate);
for(int i=0; i < GUILDMARKSIZE; i++) MSG_WriteByte(&netMessage,pSummaryRecord->Mark.Image[i]);
for(int hMemberServerIdx=1; hMemberServerIdx < MAX_MEMBER_SERVER; hMemberServerIdx++){
if(!g_memberServer[hMemberServerIdx].active ) continue;
NET_SendUnreliableMessage(&g_memberServer[hMemberServerIdx].sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
void CGuildCtrl::InitWhenManagerServer(void)
{
struct tagGuildSummarySyncRecord* pSummarySyncRecord;
guild_t* pGuild;
for(int GuildIdx=0; GuildIdx < MAX_GUILDS; GuildIdx++){
pGuild = &g_guild[GuildIdx];
if(NULL == pGuild) continue;
if(NULL == pGuild->name[0]) continue;
pSummarySyncRecord = &m_SummarySyncRecord[GuildIdx];
pSummarySyncRecord->bActive=TRUE;
StrCpyN(pSummarySyncRecord->Name,pGuild->name,GUILDNAMESTRING);
pSummarySyncRecord->Name[GUILDNAMESTRING]=NULL;
memcpy(pSummarySyncRecord->Mark.Image,pGuild->mark,GUILDMARKSIZE);
pSummarySyncRecord->Mark.ChangeDate = pGuild->markChangeDate;
pSummarySyncRecord->Sync.bComplete=TRUE;
}
}
int CGuildCtrl::Get_transmite_req_sync_at_manager_server_number(void) const
{
return m_transmite_req_sync_at_manager_server_number;
}
inline void CGuildCtrl::GTH_SendMessage_Guild_Summary_Request_To_ManagerServer(const int Idx)
{
m_transmite_req_sync_at_manager_server_number+=1;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REQUEST);
MSG_WriteByte(&netMessage, GUILD_SYNC);
MSG_WriteByte(&netMessage, enumGsvrMsvr::fromGsvr_toMsvr_Summary_Req);
MSG_WriteByte(&netMessage,g_config.gameServerNo);
MSG_WriteShort(&netMessage, Idx);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
struct CGuildCtrl::tagGuildSummarySyncRecord*
CGuildCtrl::GetSummaryRecordPointer(const int Idx)
{
if(FALSE == ValidCheck_GuildIndex(Idx)) return NULL;
struct tagGuildSummarySyncRecord* pSummaryRecord=&m_SummarySyncRecord[Idx];
if(FALSE == pSummaryRecord->Sync.bComplete){
if(TRUE == pSummaryRecord->Sync.Request.bDo){
int cur = timeGetTime();
int elasp = cur - pSummaryRecord->Sync.Request.Time;
if(elasp > 10 * 1000) pSummaryRecord->Sync.Request.bDo=FALSE;
return NULL;
}
GTH_SendMessage_Guild_Summary_Request_To_ManagerServer(Idx);
pSummaryRecord->Sync.Request.bDo=TRUE;
pSummaryRecord->Sync.Request.Time=timeGetTime();
return NULL;
}
if(FALSE == pSummaryRecord->bActive) return NULL;
return pSummaryRecord;
}
BOOL CGuildCtrl::Init(void)
{
memset(m_SummarySyncRecord,0x00,sizeof(struct tagGuildSummarySyncRecord) * MAX_GUILDS);
return TRUE;
}
void CGuildCtrl::strcpy_null_terminate(char* destStr,const char* sourceStr,const int bytes)
{
memcpy(destStr,sourceStr,bytes);
destStr[bytes-1]=NULL;
if(0 != IsDBCSLeadByte(destStr[bytes-2])) destStr[bytes-2]=NULL;
};
inline BOOL CGuildCtrl::ValidCheck_GuildIndex(const int Idx) const
{
if(0 > Idx) return FALSE;
if(MAX_GUILDS <= Idx) return FALSE;
return TRUE;
}
inline BOOL CGuildCtrl::ValidCheck(const guild_t* pGuild) const
{
if(NULL == pGuild->name[0]) return FALSE;
return TRUE;
}
guild_t* CGuildCtrl::GetRecordPointer(const int Idx)
{
if(FALSE == ValidCheck_GuildIndex(Idx)) return NULL;
if(FALSE == ValidCheck(&g_guild[Idx])) return NULL;
return &g_guild[Idx];
}
guild_t* CGuildCtrl::GetRecordPointerWithoutValidCheck(const int Idx)
{
if(FALSE == ValidCheck_GuildIndex(Idx)) return NULL;
return &g_guild[Idx];
}
int CGuildCtrl::GetIndexByName(const char* szpGuildName)
{
int Idx;
for( Idx=0; Idx < MAX_GUILDS; Idx++ ){
if(FALSE == ValidCheck_GuildIndex(Idx)) continue;
if(FALSE == ValidCheck(&g_guild[Idx])) continue;
if(0 == stricmp(g_guild[Idx].name,szpGuildName)) return Idx;
}
return -1;
}
inline void CGuildCtrl::ManagerServerProc_MarkChange(const int GuildIdx,const unsigned char* pMarkImage)
{
struct tagGuildSummarySyncRecord* pSummaryRecordPointer=GetSummaryRecordPointer(GuildIdx);
if(NULL == pSummaryRecordPointer) return;
g_guild[GuildIdx].markChangeDate =
pSummaryRecordPointer->Mark.ChangeDate=time(NULL);
memcpy(pSummaryRecordPointer->Mark.Image,pMarkImage,GUILDMARKSIZE);
memcpy(g_guild[GuildIdx].mark,pSummaryRecordPointer->Mark.Image,GUILDMARKSIZE);
g_DBGameServer->SaveGuild(GuildIdx);
TransmiteAtGs_SyncPacket_UpdateMark(GuildIdx,pSummaryRecordPointer);
TransmiteAtClient_MarkCheck_Req(GuildIdx,pSummaryRecordPointer);
}
inline void CGuildCtrl::BetweenMsGs_ManagerServerDecoder_MarkChange_Req(void)
{
int GuildIdx = MSG_ReadShort();
unsigned char MarkImage[GUILDMARKSIZE];
for(int i=0; i< GUILDMARKSIZE; i++) MarkImage[i]=MSG_ReadByte();
ManagerServerProc_MarkChange(GuildIdx,MarkImage);
}
inline void CGuildCtrl::TransmiteAtMs_UpdateMark(const int GuildIdx,const unsigned char* pMark)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REQUEST);
MSG_WriteByte(&netMessage, GUILD_SYNC);
MSG_WriteByte(&netMessage,enumGsvrMsvr::fromGsvr_toMsvr_MarkChange_Req);
MSG_WriteShort(&netMessage, GuildIdx);
for(int i=0; i< GUILDMARKSIZE; i++) MSG_WriteByte(&netMessage,pMark[i]);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
inline void CGuildCtrl::BetweenClientGs_Decoder_MarkChange_Req(void)
{
int GuildIdx=g_curPC->guildIdx;
if(FALSE == ValidCheck_GuildIndex(GuildIdx)) return;
struct tagGuildSummarySyncRecord* pSummaryRecordPointer=GetSummaryRecordPointer(GuildIdx);
if(NULL == pSummaryRecordPointer){
TransmiteAtClient_MarkChange_Res(g_curPC,tagPacket_fromGsvr_toClient_MarkChange_Res::error_unknown,0);
return;
}
int elasp_second = time(NULL) - pSummaryRecordPointer->Mark.ChangeDate;
if(abs(elasp_second) < (g_logic.danMarkChangeDelayHour * 60 * 60)){
int remain_second = (g_logic.danMarkChangeDelayHour * 60 * 60) - abs(elasp_second);
int remain_hour = remain_second / (60 * 60);
if(remain_hour < 1) remain_hour=1;
TransmiteAtClient_MarkChange_Res(g_curPC,tagPacket_fromGsvr_toClient_MarkChange_Res::error_delay_hour,remain_hour);
return;
}
TransmiteAtClient_MarkChange_Res(g_curPC,tagPacket_fromGsvr_toClient_MarkChange_Res::Success,0);
unsigned char MarkImage[GUILDMARKSIZE];
for(int i=0; i< GUILDMARKSIZE; i++) MarkImage[i]=MSG_ReadByte();
if(g_config.isManager){
ManagerServerProc_MarkChange(GuildIdx,MarkImage);
}else{
TransmiteAtMs_UpdateMark(GuildIdx,MarkImage);
}
}
inline void CGuildCtrl::BetweenClientGs_Decoder_Summary_Req(void)
{
int GuildIdx=MSG_ReadShort();
if(FALSE == ValidCheck_GuildIndex(GuildIdx)) return;
struct tagGuildSummarySyncRecord* pSummaryRecord=GetSummaryRecordPointer(GuildIdx);
if(NULL == pSummaryRecord) return;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_SYNC);
MSG_WriteByte(&netMessage, enumClientGsvr::fromGsvr_toClient_Summary_Res);
MSG_WriteShort(&netMessage, GuildIdx);
MSG_WriteString(&netMessage, pSummaryRecord->Name);
MSG_WriteLong(&netMessage, pSummaryRecord->Mark.ChangeDate);
for( int i=0; i<GUILDMARKSIZE; i++ ) MSG_WriteByte(&netMessage,pSummaryRecord->Mark.Image[i]);
NET_SendMessage(&g_curPC->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
inline void CGuildCtrl::
BetweenClientGs_Decoder_MarkImage_Req(void)
{
int GuildIdx= MSG_ReadShort();
if(FALSE == ValidCheck_GuildIndex(GuildIdx)) return;
struct tagGuildSummarySyncRecord* pSummaryRecord=GetSummaryRecordPointer(GuildIdx);
if(NULL == pSummaryRecord) return;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_SYNC);
MSG_WriteByte(&netMessage, enumClientGsvr::fromGsvr_toClient_MarkImage_Res);
MSG_WriteShort(&netMessage, GuildIdx);
MSG_WriteLong(&netMessage, pSummaryRecord->Mark.ChangeDate);
for( int i=0; i<GUILDMARKSIZE; i++ ) MSG_WriteByte(&netMessage,pSummaryRecord->Mark.Image[i]);
NET_SendMessage(&g_curPC->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CGuildCtrl::BetweenClientGs_Decoder(void)
{
switch(MSG_ReadByte()){
case enumClientGsvr::fromClient_toGsvr_MarkImage_Req:
BetweenClientGs_Decoder_MarkImage_Req();
break;
case enumClientGsvr::fromClient_toGsvr_Summary_Req:
BetweenClientGs_Decoder_Summary_Req();
break;
case enumClientGsvr::fromClient_toGsvr_MarkChange_Req:
BetweenClientGs_Decoder_MarkChange_Req();
break;
}
}
inline void CGuildCtrl::
TransmiteAtClient_MarkCheck_Req(const int GuildIdx,const struct tagGuildSummarySyncRecord* pSummaryRecord)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_SYNC);
MSG_WriteByte(&netMessage, enumClientGsvr::fromGsvr_toClient_MarkCheck_Req);
MSG_WriteShort(&netMessage, GuildIdx);
MSG_WriteLong(&netMessage,pSummaryRecord->Mark.ChangeDate);
for (int online_pc_number=0,pcIdx = 0; (pcIdx < MAX_PCS) && (online_pc_number < g_pcNumber); pcIdx++){
if( (!g_pc[pcIdx].active) || (!g_pc[pcIdx].ready)) continue;
online_pc_number+=1;
NET_SendMessage(&g_pc[pcIdx].sock,&netMessage);
}
}
MSG_EndWriting(&netMessage);
}
void CGuildCtrl::BetweenMsGs_GameServerDecoder_MarkChange_Notify(void)
{
int GuildIdx = MSG_ReadShort();
if(FALSE == ValidCheck_GuildIndex(GuildIdx)) return;
struct tagGuildSummarySyncRecord* pSummaryRecord=GetSummaryRecordPointer(GuildIdx);
if(NULL == pSummaryRecord) return;
g_guild[GuildIdx].markChangeDate =
pSummaryRecord->Mark.ChangeDate = MSG_ReadLong();
for( int i=0; i<GUILDMARKSIZE; i++ )
pSummaryRecord->Mark.Image[i]=MSG_ReadByte();
TransmiteAtClient_MarkCheck_Req(GuildIdx,pSummaryRecord);
}
inline void CGuildCtrl::TransmiteAtGs_SyncPacket_UpdateMark(const int GuildIdx,const struct tagGuildSummarySyncRecord* pSummaryRecord)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_SYNC);
MSG_WriteByte(&netMessage, enumGsvrMsvr::fromMsvr_toGsvr_MarkChange_Notify);
MSG_WriteShort(&netMessage, GuildIdx);
MSG_WriteLong(&netMessage, pSummaryRecord->Mark.ChangeDate);
for( int i=0; i<GUILDMARKSIZE; i++ ) MSG_WriteByte(&netMessage,pSummaryRecord->Mark.Image[i]);
for(int hMemberServerIdx=1; hMemberServerIdx < MAX_MEMBER_SERVER; hMemberServerIdx++){
if(!g_memberServer[hMemberServerIdx].active ) continue;
NET_SendUnreliableMessage(&g_memberServer[hMemberServerIdx].sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
} | C++ |
#include "..\global.h"
#include "CDBQueryResultProcessCtrl.h"
extern int runQueryExecuterThread;
extern HANDLE hQueryResultMutex;
CQueryQueue *queryRequestQueue, *queryResultQueue;
CDBQueryResultProcessCtrl::CDBQueryResultProcessCtrl()
{
m_bOK=FALSE;
m_bOK=TRUE;
}
CDBQueryResultProcessCtrl::~CDBQueryResultProcessCtrl()
{
}
BOOL CDBQueryResultProcessCtrl::isOK(void) const
{
return m_bOK;
}
void DB_ProcessQueryResultQueue_QUERY_LOAD_HELPLIST(const querySet_t result)
{
struct tagHelper* pHelper = (struct tagHelper*)result.pData;
if((result.ownerIdx < 0) ||
(result.ownerIdx >= MAX_PCS)){
if(NULL != pHelper){ GlobalFreePtr(pHelper); pHelper=NULL; }
return;
}
playerCharacter_t* pPlayer=&g_pc[result.ownerIdx];
if(FALSE == pPlayer->active)
{
if(NULL != pHelper){ GlobalFreePtr(pHelper); pHelper=NULL; }
return;
}
if(result.retCode < 0 )
{
g_logSystem->Write ( "Database Error: QUERY_LOAD_HELPLIST, ownerID: %s, query: %s", pPlayer->userID,result.query ) ;
if(NULL != pHelper){ GlobalFreePtr(pHelper); pHelper=NULL; }
return;
}
pPlayer->tHelper = *pHelper;
if(31 <= pPlayer->level)
{
if(tagHelper::tagMemberList::enumMode::TAKER==pPlayer->tHelper.List.mode)
{
if(0==pPlayer->tHelper.List.count)
{
pPlayer->tHelper.List.mode=tagHelper::tagMemberList::enumMode::HELPER;
}
else{
pPlayer->tHelper.List.mode=tagHelper::tagMemberList::enumMode::TAKER;
}
}
}
else if(31 > pPlayer->level)
{
pPlayer->tHelper.List.mode=tagHelper::tagMemberList::enumMode::TAKER;
}
if(NULL != pHelper){ GlobalFreePtr(pHelper); pHelper=NULL; }
}
void CDBQueryResultProcessCtrl::Process(void) const
{
static querySet_t result;
static playerCharacter_t *pc;
int isExist;
static int processedQueryCount;
if ( !runQueryExecuterThread ) return;
processedQueryCount = 0;
while ( processedQueryCount < MAX_QUERY_PER_FRAME ){
WaitForSingleObject( hQueryResultMutex, INFINITE );
if(queryResultQueue->m_count > 0)
{
isExist = queryResultQueue->Pop( &result );
}
else
{
isExist = 0;
}
ReleaseMutex( hQueryResultMutex );
if ( !isExist ) break;
processedQueryCount ++;
if( result.ownerIdx < 0 || result.queryType < 0 || result.queryType >= NUM_QUERY_TYPE || result.ownerIdx >= MAX_PCS ){
static char *queryTypeStr[] =
{
"QUERY_INSERT_LOGIN",
"QUERY_DELETE_LOGIN",
"QUERY_DELETE_LOGIN_HOST",
"QUERY_LOAD_CHARACTER",
"QUERY_LOAD_QUESTSTATUS",
"QUERY_LOAD_QUEST",
"QUERY_LOAD_SKILL",
"QUERY_LOAD_ITEM",
"QUERY_LOAD_FRIENDS",
"QUERY_SAVE_GAME",
"QUERY_SAVE_SKILL",
"QUERY_SAVE_QUEST",
"QUERY_ADD_QUESTSTATUS",
"QUERY_REMOVE_QUESTSTATUS",
"QUERY_SAVE_QUESTSTATUS",
"QUERY_ADD_ITEM",
"QUERY_REMOVE_ITEM",
"QUERY_SAVE_ITEM",
"QUERY_SAVE_FRIENDS",
"QUERY_ADD_GUILD",
"QUERY_LOAD_GUILD",
"QUERY_SAVE_GUILD",
"QUERY_SAVE_GUILDMARK",
"QUERY_REMOVE_GUILD",
"QUERY_BANISHMEMBER_GUILD",
"QUERY_SEND_MAIL",
"QUERY_RECV_MAIL",
"QUERY_GET_MAILSTATE",
"QUERY_DELETE_MAIL",
"QUERY_VIEW_MAIL",
"QUERY_SAVE_MAIL",
"QUERY_SAVE_CHATBAN",
"QUERY_LOAD_CHATBAN",
"QUERY_LOAD_GONRYUNBATTLE",
"QUERY_SAVE_GONRYUNBATTLE",
"QUERY_LOAD_PACKAGELIST",
"QUERY_SEND_POST",
"QUERY_DELETE_POST",
"QUERY_OPEN_POST",
"QUERY_DELETE_POSTITEMS",
"QUERY_SAVECHA_PACKAGE",
"QUERY_SAVECHA_ITEM_DETAIL",
"QUERY_LOAD_PREMIUMINFO",
"QUERY_SAVE_PREMIUMINFO",
"QUERY_SAVECHAPACKAGELIST_BY_SYTEM",
"QUERY_SAVECHA_PACKAGENAK",
"QUERY_POSTSYSTEM_LOADPACKAGECNT",
"QUERY_GolryunBattle_SaveBattleInfo",
"QUERY_SAVE_HELPLIST",
"QUERY_LOAD_HELPLIST",
"QUERY_SAVE_WEBPOINT",
"QUERY_GIFTCARD_LoadGiftCard",
"QUERY_GIFTCARD_LoadGiftCardItembytype",
"QUERY_GIFTCARD_SaveGiftCard",
"QUERY_LOADSERVERSTATUS",
"QUERY_SAVESERVERSTATUS",
"QUERY_GolryunBattle_LoadLastBattle",
"QUERY_GolryunBattle_AddBattle",
"QUERY_GolryunBattle_LoadTournament",
"QUERY_GolryunBattle_SaveBattle",
"QUERY_GolryunBattle_AddTournament",
"QUERY_GolryunBattle_SaveTournament",
"QUERY_INSERT_DANBATTLE",
"QUERY_DELETE_DANBATTLE",
"QUERY_DELETE_ALLDANBATTLE",
"QUERY_SAVE_DANBATTLE_GUILD_ADD_WINPOINT",
"QUERY_SAVE_DANBATTLE_GUILD_ADD_LOSEPOINT",
"QUERY_SAVE_DANBATTLE_GUILD_ADD_ACCPOINT",
"QUERY_LOAD_DANBATTLE_GUILD_INFO",
"QUERY_SAVE_DANBATTLE_PCPOINT",
};
if( result.queryType >= 0 && result.queryType < NUM_QUERY_TYPE )
{
g_logSystem->WriteToError( "QueryError: %s, ownerIdx: %d, query: %s",
queryTypeStr[result.queryType],
result.ownerIdx,
result.query );
}else{
g_logSystem->WriteToError( "QueryError: Unknown(%d), ownerIdx: %d, query: %s",
result.queryType,
result.ownerIdx,
result.query );
}
continue;
}
switch ( result.queryType )
{
case QUERY_GolryunBattle_SaveBattleInfo:
Sleep(0);
break;
case QUERY_OPEN_POST:
DB_ProcessQueryResultQueue_QUERY_OPEN_POST(result);
break;
case QUERY_POSTSYSTEM_LOADPACKAGECNT:
DB_ProcessQueryResultQueue_QUERY_POSTSYSTEM_LOADPACKAGECNT(result);
break;
case QUERY_SAVECHA_PACKAGENAK:
if( result.retCode < 0){
g_logSystem->Write("Database Error: QUERY_SAVECHA_PACKAGENAK query: %s",result.query);
}
break;
case QUERY_SAVECHAPACKAGELIST_BY_SYTEM:
if( result.retCode < 0){
g_logSystem->Write("Database Error: QUERY_SAVECHAPACKAGELIST_BY_SYTEM query: %s",result.query);
}
break;
case QUERY_SAVE_PREMIUMINFO:
if( result.retCode < 0){
g_logSystem->Write("Database Error: QUERY_SAVE_PREMIUMINFO, ownerIdx: %d, query: %s", result.ownerIdx, result.query);
}
break;
case QUERY_LOAD_PREMIUMINFO:
DB_ProcessQueryResultQueue_QUERY_LOAD_PREMIUMINFO(result);
break;
case QUERY_LOAD_PACKAGELIST:
DB_ProcessQueryResultQueue_QUERY_LOAD_PACKAGELIST(result);
break;
case QUERY_DELETE_POSTITEMS:
DB_ProcessQueryResultQueue_QUERY_DELETE_POSTITEMS(result);
break;
case QUERY_DELETE_POST:
DB_ProcessQueryResultQueue_QUERY_DELETE_POST(result);
break;
case QUERY_SAVECHA_PACKAGE:
DB_ProcessQueryResultQueue_QUERY_SAVECHA_PACKAGE(result);
break;
case QUERY_SAVECHA_ITEM_DETAIL:
DB_ProcessQueryResultQueue_QUERY_SAVECHA_PACKAGE_DETAIL(result);
break;
case QUERY_INSERT_LOGIN:
pc = &g_pc[result.ownerIdx];
if ( !pc->active )
{
g_logSystem->Write("Not Active PC's Query Executed Error!! : QUERY_INSERT_LOGIN, ownerIdx: %d)", result.ownerIdx);
break;
}
if ( stricmp(result.ownerID, pc->userID) != 0)
{
g_logSystem->Write("Query Owner Changed Error!! : (QUERY_INSERT_LOGIN, OWNER:%s, PC:%s)", result.ownerID, pc->userID);
break;
}
if ( result.retCode < 0)
{
g_logSystem->Write("Duplicated Login Error!! : (ID: %s)", pc->userID);
break;
}
else
{
DB_LoadGameData( pc );
}
break;
case QUERY_DELETE_LOGIN:
if ( result.retCode < 0)
{
g_logSystem->Write("Database Error: QUERY_DELETE_LOGIN, ownerIdx: %d, query: %s", result.ownerIdx, result.query);
continue;
}
pc = &g_pc[result.ownerIdx];
if ( !pc->active )
{
g_logSystem->Write("Not Active PC's Query Executed Error!! : QUERY_DELETE_LOGIN, ownerIdx: %d)", result.ownerIdx);
break;
}
if ( stricmp(result.ownerID, pc->userID) != 0)
{
g_logSystem->Write("Query Owner Changed Error!! : (QUERY_DELETE_LOGIN, OWNER:%s, PC:%s)", result.ownerID, pc->userID);
break;
}
break;
case QUERY_DELETE_LOGIN_HOST :
if ( result.retCode < 0)
{
g_logSystem->Write("Database Error: QUERY_DELETE_LOGIN_HOST, ownerIdx: %d, query: %s", result.ownerIdx, result.query);
continue;
}
break;
case QUERY_LOAD_FRIENDS:
if ( result.retCode < 0 )
{
g_logSystem->Write ( "Database Error: QUERY_LOAD_FRIENDS, ownerID: %s, query: %s", result.ownerID, result.query ) ;
}
break ;
case QUERY_LOAD_CHARACTER:
if ( result.retCode < 0)
{
g_logSystem->Write("Database Error: QUERY_LOAD_CHARACTER, ownerIdx: %d, query: %s", result.ownerIdx, result.query);
continue;
}
pc = &g_pc[result.ownerIdx];
if ( !pc->active )
{
g_logSystem->Write("Not Active PC's Query Executed Error!! : QUERY_LOAD_CHARACTER, ownerIdx: %d)", result.ownerIdx);
break;
}
if ( stricmp(result.ownerID, pc->userID) != 0)
{
g_logSystem->Write("Query Owner Changed Error!! : (QUERY_LOAD_CHARACTER, OWNER:%s, PC:%s)", result.ownerID, pc->userID);
break;
}
break;
case QUERY_LOAD_ITEM:
if ( result.retCode < 0)
{
g_logSystem->Write("Database Error: QUERY_LOAD_ITEM, ownerIdx: %d, query: %s", result.ownerIdx, result.query);
continue;
}
pc = &g_pc[result.ownerIdx];
if ( !pc->active )
{
g_logSystem->Write("Not Active PC's Query Executed Error!! : QUERY_LOAD_ITEM, ownerIdx: %d)", result.ownerIdx);
break;
}
if ( stricmp(result.ownerID, pc->userID) != 0)
{
g_logSystem->Write("Query Owner Changed Error!! : (QUERY_LOAD_ITEM, OWNER:%s, PC:%s)", result.ownerID, pc->userID);
break;
}
GTH_ReplyConnectGameServer( pc );
break;
case QUERY_LOAD_QUEST :
if ( result.retCode < 0)
{
g_logSystem->Write("Database Error: QUERY_LOAD_QUEST, ownerIdx: %d, query: %s", result.ownerIdx, result.query);
continue;
}
pc = &g_pc[result.ownerIdx];
if ( !pc->active )
{
g_logSystem->Write("Not Active PC's Query Executed Error!! : QUERY_LOAD_QUEST, ownerIdx: %d)", result.ownerIdx);
break;
}
if ( stricmp(result.ownerID, pc->userID) != 0)
{
g_logSystem->Write("Query Owner Changed Error!! : (QUERY_LOAD_QUEST, OWNER:%s, PC:%s)", result.ownerID, pc->userID);
break;
}
break;
case QUERY_LOAD_QUESTSTATUS :
if ( result.retCode < 0)
{
g_logSystem->Write("Database Error: QUERY_LOAD_QUESTSTATUS, ownerIdx: %d, query: %s", result.ownerIdx, result.query);
continue;
}
pc = &g_pc[result.ownerIdx];
if ( !pc->active )
{
g_logSystem->Write("Not Active PC's Query Executed Error!! : QUERY_LOAD_QUESTSTATUS, ownerIdx: %d)", result.ownerIdx);
break;
}
if ( stricmp(result.ownerID, pc->userID) != 0)
{
g_logSystem->Write("Query Owner Changed Error!! : (QUERY_LOAD_QUESTSTATUS, OWNER:%s, PC:%s)", result.ownerID, pc->userID);
break;
}
break;
case QUERY_LOAD_SKILL:
if ( result.retCode < 0)
{
g_logSystem->Write("Database Error: QUERY_LOAD_SKILL, ownerIdx: %d, query: %s", result.ownerIdx, result.query);
continue;
}
pc = &g_pc[result.ownerIdx];
if ( !pc->active )
{
g_logSystem->Write("Not Active PC's Query Executed Error!! : QUERY_LOAD_SKILL, ownerIdx: %d)", result.ownerIdx);
break;
}
if ( stricmp(result.ownerID, pc->userID) != 0)
{
g_logSystem->Write("Query Owner Changed Error!! : (QUERY_LOAD_SKILL, OWNER:%s, PC:%s)", result.ownerID, pc->userID);
break;
}
break;
case QUERY_SAVE_GAME:
DB_ProcessQueryResultQueue_QUERY_SAVE_GAME(result);
break;
case QUERY_SAVE_QUEST :
if ( result.retCode < 0)
{
g_logSystem->Write("Database Error: QUERY_SAVE_QUEST, ownerIdx: %d, query: %s", result.ownerIdx, result.query);
continue;
}
pc = &g_pc[result.ownerIdx];
if ( !pc->active )
{
g_logSystem->Write("Not Active PC's Query Executed Error!! : QUERY_SAVE_QUEST, ownerIdx: %d)", result.ownerIdx);
break;
}
if ( stricmp(result.ownerID, pc->userID) != 0)
{
g_logSystem->Write("Query Owner Changed Error!! : (QUERY_SAVE_QUEST, OWNER:%s, PC:%s)", result.ownerID, pc->userID);
break;
}
break;
case QUERY_SAVE_SKILL:
if ( result.retCode < 0)
{
g_logSystem->Write("Database Error: QUERY_SAVE_SKILL, ownerIdx: %d, query: %s", result.ownerIdx, result.query);
continue;
}
pc = &g_pc[result.ownerIdx];
if ( !pc->active )
{
g_logSystem->Write("Not Active PC's Query Executed Error!! : QUERY_SAVE_SKILL, ownerIdx: %d)", result.ownerIdx);
break;
}
if ( stricmp(result.ownerID, pc->userID) != 0)
{
g_logSystem->Write("Query Owner Changed Error!! : (QUERY_SAVE_SKILL, OWNER:%s, PC:%s)", result.ownerID, pc->userID);
break;
}
break;
case QUERY_SAVE_ITEM:
if ( result.retCode < 0)
{
g_logSystem->Write("Database Error: QUERY_SAVE_ITEM, ownerIdx: %d, query: %s", result.ownerIdx, result.query);
continue;
}
pc = &g_pc[result.ownerIdx];
if ( !pc->active )
{
g_logSystem->Write("Not Active PC's Query Executed Error!! : QUERY_SAVE_ITEM, ownerIdx: %d)", result.ownerIdx);
break;
}
if ( stricmp(result.ownerID, pc->userID) != 0)
{
g_logSystem->Write("Query Owner Changed Error!! : (QUERY_SAVE_ITEM, OWNER:%s, PC:%s)", result.ownerID, pc->userID);
break;
}
break;
case QUERY_SAVE_FRIENDS:
if ( result.retCode < 0 )
{
g_logSystem->Write ( "Database Error: QUERY_SAVE_FRIENDS, ownerIdx: %d, query: %s", result.ownerID, result.query );
}
break ;
case QUERY_ADD_QUESTSTATUS :
if ( result.retCode < 0)
{
g_logSystem->Write("Database Error: QUERY_ADD_QUESTSTATUS, ownerIdx: %d, query: %s", result.ownerIdx, result.query);
continue;
}
pc = &g_pc[result.ownerIdx];
if ( !pc->active )
{
g_logSystem->Write("Not Active PC's Query Executed Error!! : QUERY_ADD_QUESTSTATUS, ownerIdx: %d)", result.ownerIdx);
break;
}
if ( stricmp(result.ownerID, pc->userID) != 0)
{
g_logSystem->Write("Query Owner Changed Error!! : (QUERY_ADD_QUESTSTATUS, OWNER:%s, PC:%s)", result.ownerID, pc->userID);
break;
}
break;
case QUERY_REMOVE_QUESTSTATUS :
if ( result.retCode < 0)
{
g_logSystem->Write("Database Error: QUERY_REMOVE_QUESTSTATUS, ownerIdx: %d, query: %s", result.ownerIdx, result.query);
continue;
}
pc = &g_pc[result.ownerIdx];
if ( !pc->active )
{
g_logSystem->Write("Not Active PC's Query Executed Error!! : QUERY_REMOVE_QUESTSTATUS, ownerIdx: %d)", result.ownerIdx);
break;
}
if ( stricmp(result.ownerID, pc->userID) != 0)
{
g_logSystem->Write("Query Owner Changed Error!! : (QUERY_REMOVE_QUESTSTATUS, OWNER:%s, PC:%s)", result.ownerID, pc->userID);
break;
}
break;
case QUERY_SAVE_QUESTSTATUS :
if ( result.retCode < 0)
{
g_logSystem->Write("Database Error: QUERY_SAVE_QUESTSTATUS, ownerIdx: %d, query: %s", result.ownerIdx, result.query);
continue;
}
pc = &g_pc[result.ownerIdx];
if ( !pc->active )
{
g_logSystem->Write("Not Active PC's Query Executed Error!! : QUERY_SAVE_QUESTSTATUS, ownerIdx: %d)", result.ownerIdx);
break;
}
if ( stricmp(result.ownerID, pc->userID) != 0)
{
g_logSystem->Write("Query Owner Changed Error!! : (QUERY_SAVE_QUESTSTATUS, OWNER:%s, PC:%s)", result.ownerID, pc->userID);
break;
}
break;
case QUERY_ADD_ITEM:
if ( result.retCode < 0)
{
g_logSystem->Write("Database Error: QUERY_ADD_ITEM, ownerIdx: %d, query: %s", result.ownerIdx, result.query);
continue;
}
pc = &g_pc[result.ownerIdx];
if ( !pc->active )
{
g_logSystem->Write("Not Active PC's Query Executed Error!! : QUERY_ADD_ITEM, ownerIdx: %d)", result.ownerIdx);
break;
}
if ( stricmp(result.ownerID, pc->userID) != 0)
{
g_logSystem->Write("Query Owner Changed Error!! : (QUERY_ADD_ITEM, OWNER:%s, PC:%s)", result.ownerID, pc->userID);
break;
}
break;
case QUERY_REMOVE_ITEM:
if ( result.retCode < 0)
{
g_logSystem->Write("Database Error: QUERY_REMOVE_ITEM, ownerIdx: %d, query: %s", result.ownerIdx, result.query);
continue;
}
pc = &g_pc[result.ownerIdx];
if ( !pc->active )
{
g_logSystem->Write("Not Active PC's Query Executed Error!! : QUERY_REMOVE_ITEM, ownerIdx: %d)", result.ownerIdx);
break;
}
if ( stricmp(result.ownerID, pc->userID) != 0)
{
g_logSystem->Write("Query Owner Changed Error!! : (QUERY_REMOVE_ITEM, OWNER:%s, PC:%s)", result.ownerID, pc->userID);
break;
}
break;
case QUERY_ADD_GUILD:
if ( result.retCode < 0 )
{
g_logSystem->Write ( "Database Error: QUERY_ADD_GUILD, ownerIdx: %d, query: %s", result.ownerID, result.query );
}
break;
case QUERY_LOAD_GUILD:
if ( result.retCode < 0 )
{
g_logSystem->Write ( "Database Error: QUERY_LOAD_GUILD, ownerIdx: %d, query: %s", result.ownerID, result.query );
}
break;
case QUERY_UPDATE_GUILDIDX:
if(result.retCode < 0 ){
g_logSystem->Write ( "Database Error: QUERY_UPDATE_GUILDIDX, ownerIdx: %d, query: %s", result.ownerID, result.query );
}
break;
case QUERY_SAVE_GUILD:
if ( result.retCode < 0 )
{
g_logSystem->Write ( "Database Error: QUERY_SAVE_GUILD, ownerIdx: %d, query: %s", result.ownerID, result.query );
}
break;
case QUERY_BANISHMEMBER_GUILD:
if ( result.retCode < 0 )
{
g_logSystem->Write ( "Database Error: QUERY_BANISHMEMBER_GUILD, ownerIdx: %d, query: %s", result.ownerID, result.query );
}
break;
case QUERY_SEND_MAIL:
if ( result.retCode < 0 )
{
g_logSystem->Write ( "Database Error: QUERY_SEND_MAIL, ownerIdx: %d, query: %s", result.ownerID, result.query );
}
break;
case QUERY_RECV_MAIL:
if ( result.retCode < 0 )
{
g_logSystem->Write ( "Database Error: QUERY_RECV_MAIL, ownerIdx: %d, query: %s", result.ownerID, result.query );
}
break;
case QUERY_GET_MAILSTATE:
if ( result.retCode < 0 )
{
g_logSystem->Write ( "Database Error: QUERY_GET_MAILSTATE, ownerIdx: %d, query: %s", result.ownerID, result.query );
}
break;
case QUERY_DELETE_MAIL:
if ( result.retCode < 0 )
{
g_logSystem->Write ( "Database Error: QUERY_DELETE_MAIL, ownerIdx: %d, query: %s", result.ownerID, result.query );
}
break;
case QUERY_VIEW_MAIL:
if ( result.retCode < 0 )
{
g_logSystem->Write ( "Database Error: QUERY_VIEW_MAIL, ownerIdx: %d, query: %s", result.ownerID, result.query );
}
break;
case QUERY_SAVE_MAIL:
if ( result.retCode < 0 )
{
g_logSystem->Write ( "Database Error: QUERY_SAVE_MAIL, ownerIdx: %d, query: %s", result.ownerID, result.query );
}
break;
case QUERY_SAVE_CHATBAN:
if ( result.retCode < 0 )
{
g_logSystem->Write ( "Database Error: QUERY_SAVE_CHATBAN, ownerIdx: %d, query: %s", result.ownerID, result.query );
}
break;
case QUERY_LOAD_CHATBAN:
if ( result.retCode < 0 )
{
g_logSystem->Write ( "Database Error: QUERY_LOAD_CHATBAN, ownerIdx: %d, query: %s", result.ownerID, result.query );
}
break;
case QUERY_SAVE_SKIN :
{
if ( result.retCode < 0 ){
g_logSystem->Write ( "Database Error: QUERY_SAVE_SKIN, ownerIdx: %d, query: %s", result.ownerID, result.query );
}
}
break;
case QUERY_SAVE_EVENTCRAFTITEM:
if ( result.retCode < 0 )
{
g_logSystem->Write ( "Database Error: QUERY_SAVE_EVENTCRAFTITEM, ownerIdx: %d, query: %s", result.ownerID, result.query );
}
break;
case QUERY_LOAD_EVENTCRAFTITEM:
if ( result.retCode < 0 )
{
g_logSystem->Write ( "Database Error: QUERY_LOAD_EVENTCRAFTITEM, ownerIdx: %d, query: %s", result.ownerID, result.query );
}
break;
case QUERY_LOAD_GONRYUNBATTLE:
if ( result.retCode < 0 )
{
g_logSystem->Write ( "Database Error: QUERY_LOAD_GONRYUNBATTLE, ownerIdx: %d, query: %s", result.ownerID, result.query );
}
break;
case QUERY_SAVE_GONRYUNBATTLE:
if ( result.retCode < 0 )
{
g_logSystem->Write ( "Database Error: QUERY_SAVE_GONRYUNBATTLE, ownerIdx: %d, query: %s", result.ownerID, result.query );
}
break;
case QUERY_SAVE_HELPLIST:
if(result.retCode < 0)
{
g_logSystem->Write ( "Database Error: QUERY_SAVE_HELPLIST, ownerIdx: %d, query: %s", result.ownerID, result.query );
}
break;
case QUERY_LOAD_HELPLIST:
DB_ProcessQueryResultQueue_QUERY_LOAD_HELPLIST(result);
break;
case QUERY_SAVE_WEBPOINT:
if(result.retCode < 0)
{
g_logSystem->Write ( "Database Error: QUERY_SAVE_WEBPOINT, ownerIdx: %d, query: %s", result.ownerID, result.query );
}
break;
default:
break;
}
}
} | C++ |
#if !defined(AFX_CDBQUERYRESULTPROCESSCTRL_H__5A82B753_E5C4_4718_ADC7_4DBE2D65B4E2__INCLUDED_)
#define AFX_CDBQUERYRESULTPROCESSCTRL_H__5A82B753_E5C4_4718_ADC7_4DBE2D65B4E2__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CDBQueryResultProcessCtrl
{
private:
BOOL m_bOK;
public:
BOOL isOK(void) const;
void Process(void) const;
public:
CDBQueryResultProcessCtrl();
virtual ~CDBQueryResultProcessCtrl();
};
#endif
| C++ |
#define COLUMNSIZE 200
#define OUTCONNECTIONSIZE 1024
#define MAXNOTICE 5
#define MAX_QUERY_PER_FRAME 200
#include "..\GolryunBattle\CGolryunBattle_Process.h"
#include "tagDataBase.h"
#include "..\Terra\GiftCard\CGiftCard.h"
#define MAX_QUERY_NUMBER 1000
#include "tagQuerySet.h"
class CDBServer
{
protected:
RETCODE m_rCode;
HENV m_hEnv;
HDBC m_hDbc;
HSTMT m_hStmt;
public:
CDBServer();
~CDBServer();
int Initialize(char *DSN, int DSNType);
void Close();
void PrintError ( SQLSMALLINT handleType = SQL_HANDLE_STMT ) ;
void PrintError ( HSTMT hstmt );
void PrintError(const querySet_t& request);
HSTMT GetStmt () { return m_hStmt ; }
HDBC GethDBC() { return m_hDbc; }
char *ReturnString();
char m_query[QUERYSIZE+1];
};
class CDBAccount : public CDBServer
{
public:
CDBAccount();
~CDBAccount();
void InsertLogin(playerCharacter_t* pPlayer);
int DeleteLogin(playerCharacter_t *pc);
int DeleteLoginHost( char *hostName );
};
enum enumQUERY_SAVE_GAMEparameter{
normal=0,
force,
};
class CDBGame : public CDBServer
{
public:
CDBGame();
~CDBGame();
public:
void LoadServerStatus(void);
void SaveServerStatus(const BOOL bPK);
public:
void SaveGiftCard(const char* szpGiftCardSerial,const char* szpGiveItemList,const char* szpPlayerAccountID);
void LoadGiftCard(const playerCharacter_t* pPlayer);
void LoadGiftCardItembytype(const playerCharacter_t* pPlayer,const int type,const int Cnt);
public:
void GolryunBattle_SaveBattleInfo(
playerCharacter_t* pPlayer,
const int iBattleGUID,
const int TournamentLevelIdx,
enum playerCharacter_t::enumNameColor enumManor);
public:
void LoadPremiumInfo(playerCharacter_t *pc);
void SavePremiumInfo(playerCharacter_t* pPlayer);
public:
BOOL PostSystem_LoadPackageCnt(playerCharacter_t* pPc);
public:
void LoadGame(playerCharacter_t* pPlayer);
int LoadItem(playerCharacter_t *pc);
void LoadQuest(playerCharacter_t* pPlayer);
void LoadQuestStatus(playerCharacter_t* pPlayer);
int LoadSkill(playerCharacter_t *pc);
int LoadFriends (playerCharacter_t *pc) ;
void SaveGame(
playerCharacter_t *pc,
enum enumWhySaveGame why,
enum enumQUERY_SAVE_GAMEparameter parameter);
int SaveQuest(playerCharacter_t *pc);
int SaveSkill(playerCharacter_t *pc);
int AddItem(playerCharacter_t *pc, item_t *item, int idx, char *generateID);
int RemoveItem(playerCharacter_t *pc, int idx);
int SaveItem(playerCharacter_t *pc, item_t *item, int idx);
int AddQuestStatus(playerCharacter_t *pc, questStatus_t *questStatus);
int RemoveQuestStatus(playerCharacter_t *pc,int idx);
int SaveQuestStatus(playerCharacter_t *pc, questStatus_t *questStatus);
int SaveFriends ( playerCharacter_t * pc );
void SaveHelpList(const playerCharacter_t* pPlayer);
void LoadHelpList(const playerCharacter_t* pPlayer);
void SaveWepPoint(const playerCharacter_t* pPlayer,const int WepPoint);
int AddGuild( short guildIdx );
int SaveGuild( short guildIdx );
int BanishMemberGuild(const char* szpName,const int decRankPoint);
int SendMail( playerCharacter_t *pc, char* toName, char* mailTitle, char *sendTime, char* mailStr );
int RecvMail( playerCharacter_t *pc );
int GetMailState( playerCharacter_t *pc );
int DeleteMail( playerCharacter_t *pc, int mailIdx[] );
int ViewMail( playerCharacter_t *pc, int mailIdx );
int SaveMail( playerCharacter_t *pc, int mailIdx[] );
int Send_Save_EventCraftItem( playerCharacter_t *pc, int _Point);
int Recv_Load_EventCraftItem( playerCharacter_t *pc,int nEventIndex );
int SaveSkin(playerCharacter_t *pc);
int LoadGonryunBattle(playerCharacter_t *pc);
int SaveGonryunBattle(playerCharacter_t *pc);
BOOL UpdateGuildIdx(const char* pUserID,const int ServerGroupIdx,const int CharactorSlotIdx,const int GuildIdx);
BOOL RemoveGuild(const int guildIdx,const int serverGroupIdx);
BOOL LoadGuild(const int serverGroupIdx);
BOOL SaveGuildMark(const int guildIdx);
int LoadPackageList(playerCharacter_t *pc);
int DeletePost( playerCharacter_t *pc, int PostType, int PostIdx );
void DeletePostItems(const playerCharacter_t* pPlayer,const int PostSendType,const int PostIdx);
int OpenPost( playerCharacter_t *pc, int PostType, int PostIdx );
void SavePackage( playerCharacter_t* pPlayer, char* title, char* message, char* toname, int nak);
void SaveChaPackageListBySystem(
const char* pFromName,
const char* pToName,
const char* title,
const char* message,
const int nak);
void SavePost(playerCharacter_t *pPlayer,const int packageidx,
const int itempos,
const char* generateID,
const char* toname,
item_t* pitem);
int SaveChaPackageNak(playerCharacter_t *pc, CPostManager::PostPackage_t* pPostPackage);
void Insert_Danbattle(int nDanBattleIdx, int nRequestIdx, int AcceptIdx);
void Delete_Danbattle(int nRequestIdx, int nAcceptIdx);
void Delete_Alldanbattle(int MemberServerIdx);
void Save_danbattle_guild_AddWinpoint(const int nGuildIdx);
void Save_danbattle_guild_AddLosepoint(const int nGuildIdx);
void Save_danbattle_guild_AddAccpoint(const int nGuildIdx, int nAccPoint);
void Load_danbattle_guild_Info(const int nGuildIdx);
void Save_danbattle_pcpoint(playerCharacter_t *pc, int nPoint);
};
enum
{
QUERY_INSERT_LOGIN,
QUERY_DELETE_LOGIN,
QUERY_DELETE_LOGIN_HOST,
QUERY_LOAD_CHARACTER,
QUERY_LOAD_QUESTSTATUS,
QUERY_LOAD_QUEST,
QUERY_LOAD_SKILL,
QUERY_LOAD_ITEM,
QUERY_LOAD_FRIENDS,
QUERY_SAVE_GAME,
QUERY_SAVE_SKILL,
QUERY_SAVE_QUEST,
QUERY_ADD_QUESTSTATUS,
QUERY_REMOVE_QUESTSTATUS,
QUERY_SAVE_QUESTSTATUS,
QUERY_ADD_ITEM,
QUERY_REMOVE_ITEM,
QUERY_SAVE_ITEM,
QUERY_SAVE_FRIENDS,
QUERY_ADD_GUILD,
QUERY_LOAD_GUILD,
QUERY_SAVE_GUILD,
QUERY_SAVE_GUILDMARK,
QUERY_REMOVE_GUILD,
QUERY_BANISHMEMBER_GUILD,
QUERY_SEND_MAIL,
QUERY_RECV_MAIL,
QUERY_GET_MAILSTATE,
QUERY_DELETE_MAIL,
QUERY_VIEW_MAIL,
QUERY_SAVE_MAIL,
QUERY_SAVE_SKIN,
QUERY_SAVE_EVENTCRAFTITEM,
QUERY_LOAD_EVENTCRAFTITEM,
QUERY_UPDATE_GUILDIDX,
QUERY_LOAD_GONRYUNBATTLE,
QUERY_SAVE_GONRYUNBATTLE,
QUERY_LOAD_PACKAGELIST,
QUERY_SEND_POST,
QUERY_DELETE_POST,
QUERY_OPEN_POST,
QUERY_DELETE_POSTITEMS,
QUERY_SAVECHA_PACKAGE,
QUERY_SAVECHA_ITEM_DETAIL,
QUERY_LOAD_PREMIUMINFO,
QUERY_SAVE_PREMIUMINFO,
QUERY_SAVECHAPACKAGELIST_BY_SYTEM,
QUERY_SAVECHA_PACKAGENAK,
QUERY_POSTSYSTEM_LOADPACKAGECNT,
QUERY_GolryunBattle_SaveBattleInfo,
QUERY_SAVE_HELPLIST,
QUERY_LOAD_HELPLIST,
QUERY_SAVE_WEBPOINT,
QUERY_GIFTCARD_LoadGiftCard,
QUERY_GIFTCARD_LoadGiftCardItembytype,
QUERY_GIFTCARD_SaveGiftCard,
QUERY_LOADSERVERSTATUS,
QUERY_SAVESERVERSTATUS,
Query_GolryunBattle_LoadLastBattle,
Query_GolryunBattle_AddBattle,
Query_GolryunBattle_LoadTournament,
Query_GolryunBattle_SaveBattle,
Query_GolryunBattle_AddTournament,
Query_GolryunBattle_SaveTournament,
QUERY_INSERT_DANBATTLE,
QUERY_DELETE_DANBATTLE,
QUERY_DELETE_ALLDANBATTLE,
QUERY_SAVE_DANBATTLE_GUILD_ADD_WINPOINT,
QUERY_SAVE_DANBATTLE_GUILD_ADD_LOSEPOINT,
QUERY_SAVE_DANBATTLE_GUILD_ADD_ACCPOINT,
QUERY_LOAD_DANBATTLE_GUILD_INFO,
QUERY_SAVE_DANBATTLE_PCPOINT,
NUM_QUERY_TYPE,
};
class CQueryQueue
{
private:
int m_first;
int m_last;
int m_size;
int m_overflow;
querySet_t m_queue[MAX_QUERY_NUMBER];
public:
int m_count;
int m_maxCount;
CQueryQueue();
~CQueryQueue();
int Push (querySet_t *qSet);
int Pop (querySet_t *qSet);
void Clear ();
};
int DB_CreateQueryExecuterThread();
void DB_DestroyQueryExecuterThread();
DWORD WINAPI DB_QueryExecuterThread(LPVOID param);
void DB_ProcessQueryResultQueue(void);
void DB_ResultQuery_LoadCharacter(querySet_t *request, querySet_t *result );
void DB_ResultQuery_LoadItem(querySet_t *request, querySet_t *result );
void DB_ResultQuery_LoadQuest(querySet_t *request, querySet_t *result );
void DB_ResultQuery_LoadQuestStatus(querySet_t *request, querySet_t *result );
void DB_ResultQuery_LoadSkill( querySet_t *request, querySet_t *result );
void DB_ResultQuery_LoadFriends ( querySet_t *request, querySet_t *result ) ;
void DB_ResultQuery_LoadGuild(querySet_t *request, querySet_t *result);
void DB_ResultQuery_LoadChattingBan(querySet_t *request, querySet_t *result);
void DB_ResultQuery_LoadGonryunBattle(querySet_t *request, querySet_t *result);
void DB_ResultQuery_LoadHelpList(const querySet_t& request, querySet_t& result);
void DB_ResultQuery_SendMail(querySet_t *request, querySet_t *result);
void DB_ResultQuery_RecvMail(querySet_t *request, querySet_t *result);
void DB_ResultQuery_GetMailState(querySet_t *request, querySet_t *result);
void DB_ResultQuery_DeleteMail(querySet_t *request, querySet_t *result);
void DB_ResultQuery_ViewMail(querySet_t *request, querySet_t *result);
void DB_ResultQuery_SaveMail(querySet_t *request, querySet_t *result);
void DB_ResultQuery_Save_EventCraftItem(querySet_t *request, querySet_t *result);
void DB_ResultQuery_Load_EventCraftItem(querySet_t *request, querySet_t *result);
enum
{
SAVEGAMEDATA_CONTINUE = 0,
SAVEGAMEDATA_QUIT,
};
void DB_SaveGameData(
playerCharacter_t *pc,
int quit,
const enum enumWhySaveGame why=unknown,
const BOOL bForceQuit_fromGM=FALSE);
void DB_LoadGameData( playerCharacter_t *pc );
void DB_Waiting_ProcessRemainderQuery();
bool DB_ReconnectAccount ( querySet_t & request ) ;
bool DB_ReconnectGame ( querySet_t & request ) ;
bool DB_Reconnect ( querySet_t & request ) ;
bool CheckDisconnect ( HSTMT hStmt ) ;
void DB_ResultQuery_LoadWebPackageList(const querySet_t& request,querySet_t& result);
BOOL DB_ResultQuery_DeletePost( querySet_t *request, querySet_t *result );
BOOL DB_ResultQuery_OpenPost( querySet_t *request, querySet_t *result );
void DB_ProcessQueryResultQueue_QUERY_LOAD_PACKAGELIST(querySet_t& result);
void DB_ProcessQueryResultQueue_QUERY_LOAD_PACKAGELIST(querySet_t& result);
void DB_ProcessQueryResultQueue_QUERY_DELETE_POST(querySet_t& result);
void DB_ProcessQueryResultQueue_QUERY_INSERT_DANBATTLE(querySet_t& result);
void DB_QueryExecuterThread_INSERT_DANBATTLE(const querySet_t& request,querySet_t& result);
void DB_QueryExecuterThread_DELETE_ALLDANBATTLE(const querySet_t& request,querySet_t& result);
void DB_ProcessQueryResultQueue_DELETE_ALLDANBATTLE(querySet_t& result);
void DB_QueryExecuterThread_DELETE_DANBATTLE(const querySet_t& request,querySet_t& result);
void DB_ProcessQueryResultQueue_DELETE_DANBATTLE(querySet_t& result);
void DB_QueryExecuterThread_Query_LOAD_DANBATTLE_GUILD_INFO(const querySet_t& request,querySet_t& result);
void DB_ProcessQueryResultQueue_LOAD_DANBATTLE_GUILD_INFO(querySet_t& result);
void DB_QueryExecuterThread_Query_SAVE_DANBATTLE_PCPOINT(const querySet_t& request,querySet_t& result);
| C++ |
#ifndef __INI_H__
#define __INI_H__
#include <windows.h>
#include <tchar.h>
#ifdef __AFXWIN_H__
#include <afxtempl.h>
#endif
#define BASE_BINARY 2
#define BASE_OCTAL 8
#define BASE_DECIMAL 10
#define BASE_HEXADECIMAL 16
typedef BOOL (CALLBACK *SUBSTRPROC)(LPCTSTR, LPVOID);
class CIni
{
public:
CIni();
CIni(LPCTSTR lpPathName);
virtual ~CIni();
void SetPathName(LPCTSTR lpPathName);
DWORD GetPathName(LPTSTR lpBuffer, DWORD dwBufSize) const;
#ifdef __AFXWIN_H__
CString GetPathName() const;
#endif
DWORD GetString(LPCTSTR lpSection, LPCTSTR lpKey, LPTSTR lpBuffer, DWORD dwBufSize, LPCTSTR lpDefault = NULL) const;
#ifdef __AFXWIN_H__
CString GetString(LPCTSTR lpSection, LPCTSTR lpKey, LPCTSTR lpDefault = NULL) const;
#endif
BOOL WriteString(LPCTSTR lpSection, LPCTSTR lpKey, LPCTSTR lpValue) const;
BOOL AppendString(LPCTSTR Section, LPCTSTR lpKey, LPCTSTR lpString) const;
DWORD GetArray(LPCTSTR lpSection, LPCTSTR lpKey, LPTSTR lpBuffer, DWORD dwBufSize, LPCTSTR lpDelimiter = NULL, BOOL bTrimString = TRUE) const;
#ifdef __AFXWIN_H__
void GetArray(LPCTSTR lpSection, LPCTSTR lpKey, CStringArray* pArray, LPCTSTR lpDelimiter = NULL, BOOL bTrimString = TRUE) const;
BOOL WriteArray(LPCTSTR lpSection, LPCTSTR lpKey, const CStringArray* pArray, int nWriteCount = -1, LPCTSTR lpDelimiter = NULL) const;
#endif
int GetInt(LPCTSTR lpSection, LPCTSTR lpKey, int nDefault, int nBase = BASE_DECIMAL) const;
BOOL WriteInt(LPCTSTR lpSection, LPCTSTR lpKey, int nValue, int nBase = BASE_DECIMAL) const;
BOOL IncreaseInt(LPCTSTR lpSection, LPCTSTR lpKey, int nIncrease = 1, int nBase = BASE_DECIMAL) const;
UINT GetUInt(LPCTSTR lpSection, LPCTSTR lpKey, UINT nDefault, int nBase = BASE_DECIMAL) const;
BOOL WriteUInt(LPCTSTR lpSection, LPCTSTR lpKey, UINT nValue, int nBase = BASE_DECIMAL) const;
BOOL IncreaseUInt(LPCTSTR lpSection, LPCTSTR lpKey, UINT nIncrease = 1, int nBase = BASE_DECIMAL) const;
BOOL GetBool(LPCTSTR lpSection, LPCTSTR lpKey, BOOL bDefault) const;
BOOL WriteBool(LPCTSTR lpSection, LPCTSTR lpKey, BOOL bValue) const;
BOOL InvertBool(LPCTSTR lpSection, LPCTSTR lpKey) const;
double GetDouble(LPCTSTR lpSection, LPCTSTR lpKey, double fDefault) const;
BOOL WriteDouble(LPCTSTR lpSection, LPCTSTR lpKey, double fValue, int nPrecision = -1) const;
BOOL IncreaseDouble(LPCTSTR lpSection, LPCTSTR lpKey, double fIncrease, int nPrecision = -1) const;
TCHAR GetChar(LPCTSTR lpSection, LPCTSTR lpKey, TCHAR cDefault) const;
BOOL WriteChar(LPCTSTR lpSection, LPCTSTR lpKey, TCHAR c) const;
POINT GetPoint(LPCTSTR lpSection, LPCTSTR lpKey, POINT ptDefault) const;
BOOL WritePoint(LPCTSTR lpSection, LPCTSTR lpKey, POINT pt) const;
RECT GetRect(LPCTSTR lpSection, LPCTSTR lpKey, RECT rcDefault) const;
BOOL WriteRect(LPCTSTR lpSection, LPCTSTR lpKey, RECT rc) const;
DWORD GetDataBlock(LPCTSTR lpSection, LPCTSTR lpKey, LPVOID lpBuffer, DWORD dwBufSize, DWORD dwOffset = 0) const;
BOOL WriteDataBlock(LPCTSTR lpSection, LPCTSTR lpKey, LPCVOID lpData, DWORD dwDataSize) const;
BOOL AppendDataBlock(LPCTSTR lpSection, LPCTSTR lpKey, LPCVOID lpData, DWORD dwDataSize) const;
BOOL IsSectionExist(LPCTSTR lpSection) const;
DWORD GetSectionNames(LPTSTR lpBuffer, DWORD dwBufSize) const;
#ifdef __AFXWIN_H__
void GetSectionNames(CStringArray* pArray) const;
#endif
BOOL CopySection(LPCTSTR lpSrcSection, LPCTSTR lpDestSection, BOOL bFailIfExist) const;
BOOL MoveSection(LPCTSTR lpSrcSection, LPCTSTR lpDestSection, BOOL bFailIfExist = TRUE) const;
BOOL DeleteSection(LPCTSTR lpSection) const;
BOOL IsKeyExist(LPCTSTR lpSection, LPCTSTR lpKey) const;
DWORD GetKeyLines(LPCTSTR lpSection, LPTSTR lpBuffer, DWORD dwBufSize) const;
#ifdef __AFXWIN_H__
void GetKeyLines(LPCTSTR lpSection, CStringArray* pArray) const;
#endif
DWORD GetKeyNames(LPCTSTR lpSection, LPTSTR lpBuffer, DWORD dwBufSize) const;
#ifdef __AFXWIN_H__
void GetKeyNames(LPCTSTR lpSection, CStringArray* pArray) const;
#endif
BOOL CopyKey(LPCTSTR lpSrcSection, LPCTSTR lpSrcKey, LPCTSTR lpDestSection, LPCTSTR lpDestKey, BOOL bFailIfExist) const;
BOOL MoveKey(LPCTSTR lpSrcSection, LPCTSTR lpSrcKey, LPCTSTR lpDestSection, LPCTSTR lpDestKey, BOOL bFailIfExist = TRUE) const;
BOOL DeleteKey(LPCTSTR lpSection, LPCTSTR lpKey) const;
static BOOL ParseDNTString(LPCTSTR lpString, SUBSTRPROC lpFnStrProc, LPVOID lpParam = NULL);
static BOOL StringToBool(LPCTSTR lpString, BOOL bDefault = FALSE);
protected:
static LPTSTR __StrDupEx(LPCTSTR lpStart, LPCTSTR lpEnd);
static BOOL __TrimString(LPTSTR lpBuffer);
LPTSTR __GetStringDynamic(LPCTSTR lpSection, LPCTSTR lpKey, LPCTSTR lpDefault = NULL) const;
static DWORD __StringSplit(LPCTSTR lpString, LPTSTR lpBuffer, DWORD dwBufSize, LPCTSTR lpDelimiter = NULL, BOOL bTrimString = TRUE);
static void __ToBinaryString(UINT nNumber, LPTSTR lpBuffer, DWORD dwBufSize);
static int __ValidateBase(int nBase);
static void __IntToString(int nNumber, LPTSTR lpBuffer, int nBase);
static void __UIntToString(UINT nNumber, LPTSTR lpBuffer, int nBase);
static BOOL CALLBACK __SubStrCompare(LPCTSTR lpString1, LPVOID lpParam);
static BOOL CALLBACK __KeyPairProc(LPCTSTR lpString, LPVOID lpParam);
#ifdef __AFXWIN_H__
static BOOL CALLBACK __SubStrAdd(LPCTSTR lpString, LPVOID lpParam);
#endif
LPTSTR m_pszPathName;
};
#endif | C++ |
#pragma warning(disable:4786)
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <math.h>
#include <tchar.h>
#include <time.h>
#include <vector>
#include <queue>
#include <deque>
#include <winsock2.h>
#include <sql.h>
#include <sqlext.h>
#define SERVERSTRING 20
#define DATABASESTRING 64
#define IPSTRING 16
#define PORTSTRING 8
#define VERSIONSTRING 20
#define IDSTRING 20
#define PASSWORDSTRING 20
#define USERNAMESTRING 20
#define JUMINSTRING 14
#define ADDRESSSTRING 50
#define EMAILSTRING 30
#define TELEPHONESTRING 16
#define NAMESTRING 20
#define PATHSTRING 64
#define WORLDNAMESTRING 64
#define CHATSTRING 256
#define HOSTNAMESTRING 16
#define MAX_FRIENDS_LIST 5000
#define GUILDNAMESTRING 20
#define GUILDNOTICESTRING 100
#define MASTERNOTESTRING 20
#define PITCH 0
#define YAW 1
#define ROLL 2
#define SAFE_MONSTER(p) (p < 0 || p >= MAX_MONSTERS) ? 0 : 1
#include "netlib/netlib.h"
#include "netlib/queue.h"
#include "etc/mtrand.h"
#include "resource.h"
#include "winmain.h"
#include "etc/token.h"
#include "etc/math.h"
#include "etc/timer.h"
#include "TableStruct/TableCommon.h"
#include "game/ItemExtendSystem.h"
#include "structure/aiCommon.h"
#include "structure/entityStruct.h"
#include "structure/itemObjectStruct.h"
#include "game/option.h"
#include "game/PostSystem.h"
#include "game/WorldChangeSystem.h"
#include "game/CashMallItem_OptionStone.h"
#include "game/tagNewDanPacket.h"
#include "game/NewDanBattleSystem.h"
#include "structure/pcStruct.h"
#include "structure/npcStruct.h"
#include "structure/monsterStruct.h"
#include "game/guild.h"
#include "game/Dan.h"
#include "EntityListMng.h"
#include "game/game.h"
#include "game/gameError.h"
#include "game/party.h"
#include "systemAdmin.h"
#include "network/protocol.h"
#include "network/net_main.h"
#include "game/world.h"
#include "game/pc.h"
#include "game/monster.h"
#include "game/bopeitem.h"
#include "game/npc.h"
#include "game/friends.h"
#include "FuntionObject.h"
#include "game/PostFunc.h"
#include "game/WorldChangeFunc.h"
#include "ai/monsterAIEvent.h"
#include "ai/MonsterAIFunction.h"
#include "ai/interpretor.h"
#include "ai/pathfinding.h"
#include "ai/collisionmap.h"
#include "ai/npcInterpretor.h"
#include "skill/skillapp.h"
#include "skill/skills.h"
#include "skill/skillLogic.h"
#include "message/message.h"
#include "message/MessageReceive.h"
#include "message/MessageSend.h"
#include "game/affect.h"
#include "game/zone.h"
#include "log.h"
#include "debugInfo/ConsoleInfo.h"
#include "debugInfo/VCommon.h"
#include "debugInfo/VUtil.h"
#include "Billing/billing.h"
#include "Billing/tcpSocket.h"
#include "battle/GameTarget.h"
#include "battle/Attack.h"
#include "game/ChristMasEvent.h"
#include "game/EventCraftSystem.h"
#include "game/GameConfigFlag.h"
#include "game/WeatherSystem.h"
#include "HelperSystem\HelperManager.h"
#include "game/ItemTxt.h"
#include "game/ItemTableData.h"
#include "game/UseItem.h"
#include "game/ExpEventMng.h"
#include "game/CashMall_Item.h"
#include "game/GambleSystem.h"
#include "game/GambleSystemFunc.h"
#include "game/ItemExtendFunc.h"
#include "game/Item_Scroll_Proc.h"
#include "game/NewDanBattleFunc_Broadcast.h"
#include "game/NewDanBattleFunc.h"
#define MAX_PCS 1000
#define MAX_SERVICE_PCS MAX_PCS - 400
//lucky 2012 Max monster changed to 4000 due of CPU patch :D
#define MAX_MONSTERS 4000
//end
#define MAX_NPCS 100
#define MAX_OBJECTS 1000
#define MAX_STORES 100
#define MAX_BINDINGS 100
#define MAX_GUILDS 500
#define QUEST_SCROLL_INDEX 1000
#define QUESTSCROLL_ITEM_INDEX 869
#define AUTOQUESTSCROLL_ITEM_INDEX 45
#define MONSTERCARD_ITEM_INDEX 868
#define GAMBLE_STORE_IDX 23
extern HINSTANCE g_hInst;
extern TCHAR* g_strAppTitle;
extern TCHAR* g_strWindowClass;
extern TCHAR* g_systemStatusMessage;
extern HWND g_hWnd;
extern unsigned int g_globalTime;
extern i3gameServerConfig_t g_config;
extern gthGameLogicCofing_t g_logic;
extern i3zone_t g_zone[MAX_LOCALSERVICEWORLDS][ZONE_DIV * ZONE_DIV];
extern i3zoneScanList_t g_zoneEntityList[MAX_SCAN_ENTITYLIST];
extern int g_zoneEntityListNumber;
extern i3zoneScanList_t g_zonePCList[MAX_SCAN_PCLIST];
extern int g_zonePCListNumber;
extern i3zoneScanList_t g_zoneMonsterList[MAX_SCAN_MONSTERLIST];
extern int g_zoneMonsterListNumber;
extern i3zoneScanList_t g_zoneNPCList[MAX_SCAN_NPCLIST];
extern int g_zoneNPCListNumber;
extern i3zoneScanList_t g_zoneObjectList[MAX_SCAN_OBJECTLIST];
extern int g_zoneObjectListNumber;
extern int g_pcNumber;
extern playerCharacter_t g_pc[MAX_PCS];
extern playerCharacter_t *g_curPC;
extern int g_maxPCNumber;
extern golryunManagerTable_t g_golryunManagerTable[MAX_NUMBER_OF_GOLRYUN_MANAGER_TABLE];
extern golryunProgressTable_t g_golryunProgressTable[MAX_NUMBER_OF_GOLRYUN_MANAGER_TABLE];
extern golryunRewardManagerTable_t g_golryunRewardManagerTable[MAX_NUMBER_OF_GOLRYUN_MANAGER_TABLE];
extern golryunItemGroupTable_t g_golryunItemGroupTable[MAX_NUMBER_OF_GOLRYUN_ITEM_GROUP_TABLE];
extern int g_monsterNumber;
extern monsterCharacter_t g_monster[MAX_MONSTERS];
extern LIST_NONPLAYER_STRUCT g_sNpcList;
extern int g_objectNumber;
extern itemObject_t g_object[MAX_OBJECTS];
extern itemObject_t *g_curObject;
extern int g_storeNumber;
extern storeStruct_t g_store[MAX_STORES];
extern int g_bindingNumber;
extern bindingStruct_t g_binding[MAX_BINDINGS];
extern scriptInfoStruct_t g_scriptInfo;
extern CTimer *g_timer;
extern CLogSystem *g_logSystem;
extern int g_fixedScreenSize;
extern unsigned long g_dwMaxTextureHeight;
extern unsigned long g_dwMaxTextureWidth;
extern worldTable_t g_worldTable[MAX_WORLDS];
extern int g_worldTableNumber;
extern monsterBasicTable_t g_monsterTable[MAX_NUMBER_OF_MONSTER_TABLE];
extern int g_monsterTableNumber;
extern expTable_t g_expTable[MAX_NUMBER_OF_LEVEL];
extern MaxDefense_t g_MaxDefneseTable[MAX_NUMBER_OF_LEVEL];
extern itemTable_t g_itemTable[MAX_NUMBER_OF_ITEM_TABLE];
extern int g_itemTableNumber;
extern itemClassTable_t g_itemClassTable[MAX_NUMBER_OF_ITEM_CLASS_TABLE];
extern int g_itemClassTableNumber;
extern optionTable_t g_optionTable[MAX_COUNT_OPTION_TABLE];
extern optionGroupTable_t g_optionGroupTable[MAX_COUNT_OPTION_GROUP_TABLE];
extern itemGenerateTable_t g_itemGenerateTable[MAX_NUMBER_OF_ITEM_GENERATE_TABLE];
extern int g_itemGenerateTableNumber;
extern questItemGenerate_t g_qigTable[MAX_NUMBER_OF_MONSTER_TABLE];
extern int g_qigTableNumber;
extern itemCraftTable_t g_itemCraftTable[MAX_NUMBER_OF_ITEM_CRAFT_TABLE];
extern int g_itemCraftTableNumber;
extern GambleItem_t g_GambleItem[MAX_COUNT_OPTION_AVAILABLE_TYPE];
extern int g_GambleItemTalbleNumber;
extern questscrollTable_t g_questscrollTable[MAX_NUMBER_OF_QUESTSCROLL_TABLE];
extern int g_questscrollTableNumber;
extern autoQuestScrollTable_t g_autoQuestscrollTable[MAX_NUMBER_OF_AUTO_QUESTSCROLL_TABLE];
extern int g_autoQuestscrollTableNumber;
extern bool g_AutoQuestScrolltype2;
extern bool g_AutoQuestScrolltype4;
extern SummonMonster_t g_summonMonstertable[MAX_NUMBER_OF_SUMMON_MONSTER_TABLE];
extern int g_summonMonstertableNumber;
extern Consideration_t g_ConsiderationTable[MAX_NUMBER_OF_CONSIDERATION_TABLE];
extern int g_ConsiderationTableNumber;
extern int g_skillTableNumber;
extern skillGradeClass_t g_skillGradeClassTable[100];
extern genCapabilityTable_t g_genCapabilityTable;
extern monsterSpawnOptionTable_t g_monsterSpawnOption[100];
extern collisionMap_t g_cmap[MAX_LOCALSERVICEWORLDS];
extern int g_memberServerNumber;
extern memberServer_t g_memberServer[MAX_MEMBER_SERVER];
extern memberServer_t *g_curMemberServer;
extern serverShutdownTimer_t g_serverShutdownTimer;
extern noticeInfo_t g_noticeInfo;
extern char g_hostName[HOSTNAMESTRING];
extern serverPartyInfo_t g_partyInfo[MAX_PARTY_NUMBER];
extern CEntityListMng g_entityListMng;
extern FriendsList g_friendsList[MAX_FRIENDS_LIST];
extern guild_t g_guild[MAX_GUILDS];
extern CDanBattleFunc g_DanBattleFunc;
extern LPDAN_BATTLE_MANAGER g_pDanBattleManager;
extern LPDAN_BATTLE_SYS g_pDanBattleSys;
extern i3sizebuf_t netMessage;
extern i3socket_t localSocket;
extern CChristMasEvent g_ChristMasEvent;
extern CPostFunc g_PostFunc;
extern CWeatherSystem g_WeatherSystem;
extern CHelperManager g_HelperManager;
extern CExpEventMng g_ExpEventMng;
extern CGambleSystem g_GambleSystem;
extern NewDanBattleSystem g_NewDanBattleSystem;
void GTH_InitGlobalVariable();
void GTH_DestroyVariables();
inline void sstrncpy( char *destStr, const char *sourceStr, int size )
{
memset( destStr, 0, size );
memcpy( destStr, sourceStr, size - 1 );
int idx = 0;
while( idx < size - 1 )
{
if( IsDBCSLeadByte( sourceStr[idx] ) )
idx += 2;
else
idx ++;
}
if( idx == size )
destStr[idx - 2] = 0;
};
extern tcpSocket *g_pBillingSocket ;
#include "Terra\GiftCard\CGiftCard.h"
#include "ODBC(open database connectivity)\tagQuerySet.h"
#include "ODBC(open database connectivity)\database.h"
extern CDBAccount *g_DBAccountServer;
extern CDBGame *g_DBGameServer;
| C++ |
void CreateConsoleInfo();
DWORD WINAPI ConsoleInfoThread(LPVOID param);
void FreeConsoleInfo();
int ConsoleInfoProcess( char* token );
class CGTHConsoleInfo
{
public :
int Process( char* token );
void PartyOutput( serverPartyInfo_t *p );
void Party( char* token );
void CheckDupUser();
void ViewPCList( int type );
void ReloadTable();
void RespawnAllMonster();
}; | C++ |
#ifndef __VEMER_COMMON_H__
#define __VEMER_COMMON_H__
#include <windows.h>
#pragma once
#define chSTR2(x) #x
#define chSTR(x) chSTR2(x)
#define chMSG(desc) message(__FILE__ "(" chSTR(__LINE__) ") : message : " #desc)
#define chINRANGE(low, Num, High) (((low) <= (Num)) && ((Num) <= (High)))
#define chDIMOF(Array) (sizeof(Array) / sizeof(Array[0]))
#define chSIZEOFSTRING(psz) ((lstrlen(psz) + 1) * sizeof(TCHAR))
template <class TV, class TM>
inline TV chROUNDDOWN(TV Value, TM Multiple) {
return((Value / Multiple) * Multiple);
}
template <class TV, class TM>
inline TV chROUNDUP(TV Value, TM Multiple) {
return(chROUNDDOWN(Value, Multiple) +
(((Value % Multiple) > 0) ? Multiple : 0));
}
#ifdef _X86_
#define DebugBreak() _asm { int 3 }
#endif
#define MAKESOFTWAREEXCEPTION(Severity, Facility, Exception) \
((DWORD) ( \
(Severity ) | \
(1 << 29) | \
(0 << 28) | \
(Facility << 16) | \
(Exception << 0)))
inline void chMB(PCSTR s) {
char szTMP[256];
GetModuleFileNameA(NULL, szTMP, chDIMOF(szTMP));
HWND hwnd = GetActiveWindow();
}
inline void chMBANDDEBUG(PSTR szMsg) {
chMB(szMsg);
DebugBreak();
}
inline void chASSERTFAIL(LPCSTR file, int line, PCSTR expr) {
char sz[256];
wsprintfA(sz, "File %s, line %d : %s", file, line, expr);
chMBANDDEBUG(sz);
}
#ifdef _DEBUG
#define chASSERT(x) if (!(x)) chASSERTFAIL(__FILE__, __LINE__, #x)
#else
#define chASSERT(x)
#endif
#ifdef _DEBUG
#define chFAIL() chASSERTFAIL(__FILE__, __LINE__, "")
#else
#define chFAIL()
#endif
#ifdef _DEBUG
#define chVERIFY(x) chASSERT(x)
#else
#define chVERIFY(x) (x)
#endif
#define chHANDLE_DLGMSG(hwnd, message, fn) \
case (message): return (SetDlgMsgResult(hwnd, uMsg, \
HANDLE_##message((hwnd), (wParam), (lParam), (fn))))
inline void chSETDLGICONS(HWND hwnd, int idi) {
SendMessage(hwnd, WM_SETICON, TRUE, (LPARAM)
LoadIcon((HINSTANCE) GetWindowLong(hwnd, GWL_HINSTANCE),
MAKEINTRESOURCE(idi)));
SendMessage(hwnd, WM_SETICON, FALSE, (LPARAM)
LoadIcon((HINSTANCE) GetWindowLong(hwnd, GWL_HINSTANCE),
MAKEINTRESOURCE(idi)));
}
extern bool InitLogWnd(HWND hParentWnd);
#endif | C++ |
#include "../global.h"
HANDLE g_consoleThreadHandle;
DWORD g_consoleThreadID;
HANDLE g_consoleOutHandle;
HANDLE g_consoleInHandle;
char g_seps[4] = { 13, 10, ' ', 0 };
CGTHConsoleInfo g_gthConsoleInfo;
void ConsoleOutput( const char *format, ... )
{
DWORD dw;
va_list argptr;
char buffer[4096];
va_start(argptr, format);
vsprintf(buffer, format, argptr);
va_end(argptr);
WriteFile( g_consoleOutHandle, buffer, strlen( buffer ), &dw, NULL );
}
BOOL ConsoleHandler( DWORD dwEvent )
{
switch( dwEvent )
{
case CTRL_C_EVENT :
return true;
case CTRL_BREAK_EVENT :
return true;
}
return false;
}
void CreateConsoleInfo()
{
AllocConsole();
SetConsoleCtrlHandler( (PHANDLER_ROUTINE)ConsoleHandler, TRUE );
g_consoleOutHandle = GetStdHandle( STD_OUTPUT_HANDLE );
g_consoleInHandle = GetStdHandle( STD_INPUT_HANDLE );
SetConsoleMode( g_consoleInHandle, ENABLE_PROCESSED_INPUT | ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT );
g_consoleThreadHandle = CreateThread( NULL, 0, ConsoleInfoThread, NULL, 0, &g_consoleThreadID );
CloseHandle( g_consoleThreadHandle );
}
DWORD WINAPI ConsoleInfoThread(LPVOID param)
{
DWORD dw;
char szOutput[64];
char *token;
char title[100];
if( g_config.isManager )
strcpy( title, "GTH Manager server debug console window - \n\"quit\" to exit\n\n" );
else
strcpy( title, "GTH Game server debug console window - \n\"quit\" to exit\n\n" );
WriteFile( g_consoleOutHandle, title, strlen( title ), &dw, NULL );
while( 1 )
{
memset( szOutput, 0, sizeof( szOutput ) );
WriteFile( g_consoleOutHandle, "> ", 2, &dw, NULL );
ReadFile( g_consoleInHandle, szOutput, 63, &dw, NULL );
token = strtok( szOutput, g_seps );
if( !g_gthConsoleInfo.Process( token ) ) break;
}
FreeConsoleInfo();
return 0;
}
void FreeConsoleInfo()
{
FreeConsole();
}
int CGTHConsoleInfo::Process( char* token )
{
if( token == NULL ) return true;
if( !stricmp( token, "quit" ) ) return false;
else if( !stricmp( token, "party" ) )
{
Party( token );
}
else if( !stricmp( token, "checkdupuser" ) )
{
CheckDupUser();
}
else if( !stricmp( token, "viewpclist" ) )
{
ViewPCList( 1 );
}
else if( !stricmp( token, "countpclist" ) )
{
ViewPCList( 0 );
}
else if( !stricmp( token, "reloadtable" ) )
{
ReloadTable();
}
else if( !stricmp( token, "respawnall" ) )
{
RespawnAllMonster();
}
else if( !stricmp( token, "checkexp" ) )
{
for( int i = 0; i < MAX_MONSTERS; i ++ )
{
if( !g_monster[i].active || g_monster[i].entityType == ENTITY_MONSTER ) continue;
if( g_monster[i].basic.exp <= 0 )
{
ConsoleOutput( "[%d]%s monster exp = 0", g_monster[i].idx, g_monster[i].basic.name );
}
}
}
else
{
ConsoleOutput( "invaild command\n" );
}
return true;
}
void CGTHConsoleInfo::RespawnAllMonster()
{
for( int i = 0; i < MAX_MONSTERS; i ++ )
{
if( !g_monster[i].active ) continue;
g_monster[i].aliveState = MON_ALIVE_STATE_CORPSE;
g_monster[i].ai.aiEvent = AI_DIE;
g_monster[i].event = GTH_EV_CHAR_DIE;
g_monster[i].oldEvent = GTH_EV_CHAR_DIE;
g_monster[i].deathTime = g_globalTime;
}
ConsoleOutput( "all monster respawn complete!\n\n" );
}
void CGTHConsoleInfo::ReloadTable()
{
LoadAllGameTable();
ConsoleOutput( "reload - sit, slt, sot, sqg, sgt, smt, skt\n" );
LoadBindingTableForServer( "tables/bindingTable.tbl" );
ConsoleOutput( "reload - binding table\n" );
LoadItemCraftTableForServer( "tables/itemcraft.tbl" );
ConsoleOutput( "reload - itemcraft table\n" );
ConsoleOutput( "all table reload complete!\n\n" );
}
void CGTHConsoleInfo::PartyOutput( serverPartyInfo_t *p )
{
char outputStr[2550];
int i;
memset( outputStr, 0, sizeof( outputStr ) );
if( p == NULL )
{
ConsoleOutput( "don't find party data\n" );
return;
}
sprintf( outputStr, "%sparty idx : %d\norganizer name : %s, organize time : %d, organize server : %d\n", outputStr,
p->idx, p->organizerName, p->organizeTime, p->organizeServer );
sprintf( outputStr, "%scan join : %d, item divide type : %d\n", outputStr,
p->canJoin, p->itemDivideType );
sprintf( outputStr, "%smember number : %d\n", outputStr,
p->memberNumber );
for( i = 0; i < MAX_NUMBER_OF_PARTY_MEMBER; i ++ )
{
if( p->member[i].serverIndex == -1 ) continue;
sprintf( outputStr, "%smember name : %s(Lv %d), gen type : %d, leader : %d\n", outputStr,
p->member[i].memberName, p->member[i].level, p->member[i].gen, p->member[i].isLeader );
sprintf( outputStr, "%sactive : %d, server index : %d, world index : %d\n", outputStr,
p->member[i].isActive, p->member[i].serverIndex, p->member[i].worldIdx );
}
ConsoleOutput( outputStr );
}
void CGTHConsoleInfo::Party( char* token )
{
int sort = 0;
char valueStr[255];
int valueInt = 0;
int i, j, ret = 0;
if( !g_config.isManager )
{
ConsoleOutput( "\"party\" command use only manager server\n" );
return;
}
token = strtok( NULL, g_seps );
if( token != NULL )
{
if( !stricmp( token, "name" ) ) sort = 1;
else if( !stricmp( token, "idx" ) ) sort = 2;
else if( !stricmp( token, "?") )
{
ConsoleOutput( "usage : party [sort] [value]\n" );
ConsoleOutput( "[sort] : name, idx\n" );
ConsoleOutput( "[value] : each value\n\n" );
return;
}
memset( valueStr, 0, sizeof( valueStr ) );
token = strtok( NULL, g_seps );
if( token != NULL )
{
if( sort == 1 ) strcpy( valueStr, token );
else if( sort == 2 ) valueInt = atoi( token );
}
}
for( i = 0; i < MAX_PARTY_NUMBER; i ++ )
{
if( g_partyInfo[i].memberNumber == 0 ) continue;
if( sort == 1 )
{
for( j = 0; j < g_partyInfo[i].memberNumber; j ++ )
{
if( g_partyInfo[i].member[j].serverIndex == -1 ) continue;
if( !stricmp( g_partyInfo[i].member[j].memberName, valueStr ) ) break;
}
if( j == g_partyInfo[i].memberNumber ) continue;
PartyOutput( &g_partyInfo[i] );
ret = 1;
break;
}
else if( sort == 2 )
{
if( g_partyInfo[i].idx == valueInt )
{
PartyOutput( &g_partyInfo[i] );
ret = 1;
break;
}
}
else
{
PartyOutput( &g_partyInfo[i] );
ret = 1;
}
}
if( !ret )
{
ConsoleOutput( "has no party result\n" );
}
}
void CGTHConsoleInfo::CheckDupUser()
{
int count = 0;
char szTemp[256];
for( int i = 0; i < MAX_PCS; i ++ )
{
if( !g_pc[i].active ) continue;
if( g_pc[i].idx != i )
{
sprintf( szTemp, "%d Index %s(%d) PC is index miss-match error!\n", i, g_pc[i].name, g_pc[i].idx );
ConsoleOutput( szTemp );
count ++;
}
for( int j = 0; j < MAX_PCS; j ++ )
{
if( !g_pc[j].active ) continue;
if( i == j ) continue;
if( g_pc[i].idx == g_pc[j].idx )
{
sprintf( szTemp, "%d Index %s(%d) PC is index duplicate error!\n", i, g_pc[i].name, g_pc[i].idx );
ConsoleOutput( szTemp );
count ++;
}
if( !stricmp( g_pc[i].name, g_pc[j].name ) )
{
sprintf( szTemp, "%d Index %s(%d) PC is name duplicate error!\n", i, g_pc[i].name, g_pc[i].idx );
ConsoleOutput( szTemp );
count ++;
}
}
}
if( count > 0 )
{
sprintf( szTemp, "%d user error!\n", count );
ConsoleOutput( szTemp );
}
else
{
ConsoleOutput( "no error\n\n" );
}
}
void CGTHConsoleInfo::ViewPCList( int type )
{
char szTemp[256];
if( !g_config.isManager )
{
ConsoleOutput( "\"viewpclist\" command use only manager server\n" );
return;
}
if( !type )
{
sprintf( szTemp, "pc number in server group : %d\n", g_entityListMng.GetPCListNumber() );
ConsoleOutput( szTemp );
}
else
{
entityPCList_t *pPCList = NULL;
VECTOR_ENTITYPCLIST_STRUCT::iterator itor;
for( itor = g_entityListMng.m_vEntityPCList.begin(); itor != g_entityListMng.m_vEntityPCList.end(); itor ++ )
{
pPCList = ( *itor );
sprintf( szTemp, "userID : %s, name : %s, serverIdx : %d, worldName : %s, charInfo : %s(Lv.%d)\n",
pPCList->userID, pPCList->name, pPCList->serverIdx,
g_worldTable[pPCList->worldIdx].name, g_itemReqClassString[pPCList->job], pPCList->level );
ConsoleOutput( szTemp );
}
}
}
| C++ |
#include <windows.h>
#include "VUtil.h"
__int64 g_qnTotalPC, g_qnFreq, g_qnCurrPC;
void ShowLogInfo(char *pszFmtMsg, ...);
void ShowLogInfo(char *pszFmtMsg, ...)
{
DWORD dwTime;
va_list valArg;
char szTime[60];
char szMsg[8192];
DWORD dwThreadID = GetCurrentThreadId();
dwTime = GetTickCount();
wsprintf(szTime, "[info] thrd=%d ", dwThreadID);
va_start(valArg, pszFmtMsg);
wvsprintf( szMsg, pszFmtMsg, valArg );
va_end(valArg);
#ifdef __MYDEBUG
#ifdef SHOW_LOG_SCREEN
#ifdef MT_CLIENT
OutputDebugString(szTime);
OutputDebugString(szMsg);
OutputDebugString("\r\n");
#else
printf(szTime);
printf(szMsg);
printf("\r\n");
#endif
#endif
#endif
}
void InitProfile()
{
QueryPerformanceFrequency( (LARGE_INTEGER*) &g_qnFreq);
QueryPerformanceCounter((LARGE_INTEGER*) &g_qnCurrPC);
g_qnTotalPC = 0;
}
void ShowProfile()
{
double dDiff, dFreq;
dDiff = (double)g_qnTotalPC;
dFreq = (double)g_qnFreq;
dDiff = dDiff/g_qnFreq;
}
void StartProfile()
{
QueryPerformanceCounter((LARGE_INTEGER*) &g_qnCurrPC);
}
void EndProfile(char* pMsg)
{
__int64 qnPC;
int nDiffPC;
float fDiff, fFreq;
QueryPerformanceCounter((LARGE_INTEGER*)&qnPC);
nDiffPC = (int)(qnPC - g_qnCurrPC);
g_qnTotalPC += nDiffPC;
fDiff = (float)nDiffPC;
fFreq = (float)g_qnFreq;
fDiff = fDiff/fFreq;
} | C++ |
#include "Ini.h"
#include <string.h>
#include <stdio.h>
#include <assert.h>
#define DEF_PROFILE_NUM_LEN 64
#define DEF_PROFILE_THRESHOLD 512
#define DEF_PROFILE_DELIMITER _T(",")
#define DEF_PROFILE_TESTSTRING _T("{63788286-AE30-4D6B-95DF-3B451C1C79F9}")
struct STR_LIMIT
{
LPTSTR lpTarget;
DWORD dwRemain;
DWORD dwTotalCopied;
};
CIni::CIni()
{
m_pszPathName = NULL;
}
CIni::CIni(LPCTSTR lpPathName)
{
m_pszPathName = NULL;
SetPathName(lpPathName);
}
CIni::~CIni()
{
if (m_pszPathName != NULL)
delete [] m_pszPathName;
}
void CIni::SetPathName(LPCTSTR lpPathName)
{
if (lpPathName == NULL)
{
if (m_pszPathName != NULL)
*m_pszPathName = _T('\0');
}
else
{
if (m_pszPathName != NULL)
delete [] m_pszPathName;
m_pszPathName = _tcsdup(lpPathName);
}
}
DWORD CIni::GetPathName(LPTSTR lpBuffer, DWORD dwBufSize) const
{
*lpBuffer = _T('\0');
DWORD dwLen = 0;
if (lpBuffer != NULL)
{
_tcsncpy(lpBuffer, m_pszPathName, dwBufSize);
dwLen = _tcslen(lpBuffer);
}
else
{
dwLen = _tcslen(m_pszPathName);
}
return dwLen;
}
#ifdef __AFXWIN_H__
CString CIni::GetPathName() const
{
return CString(m_pszPathName);
}
#endif
DWORD CIni::GetString(LPCTSTR lpSection, LPCTSTR lpKey, LPTSTR lpBuffer, DWORD dwBufSize, LPCTSTR lpDefault) const
{
if (lpBuffer != NULL)
*lpBuffer = _T('\0');
LPTSTR psz = __GetStringDynamic(lpSection, lpKey, lpDefault);
DWORD dwLen = _tcslen(psz);
if (lpBuffer != NULL)
{
_tcsncpy(lpBuffer, psz, dwBufSize);
dwLen = min(dwLen, dwBufSize);
}
delete [] psz;
return dwLen;
}
#ifdef __AFXWIN_H__
CString CIni::GetString(LPCTSTR lpSection, LPCTSTR lpKey, LPCTSTR lpDefault) const
{
LPTSTR psz = __GetStringDynamic(lpSection, lpKey, lpDefault);
CString str(psz);
delete [] psz;
return str;
}
#endif
BOOL CIni::WriteString(LPCTSTR lpSection, LPCTSTR lpKey, LPCTSTR lpValue) const
{
if (lpSection == NULL || lpKey == NULL)
return FALSE;
return ::WritePrivateProfileString(lpSection, lpKey, lpValue == NULL ? _T("") : lpValue, m_pszPathName);
}
BOOL CIni::AppendString(LPCTSTR lpSection, LPCTSTR lpKey, LPCTSTR lpString) const
{
if (lpString == NULL)
return FALSE;
TCHAR* psz = __GetStringDynamic(lpSection, lpKey);
TCHAR* pNewString = new TCHAR[_tcslen(psz) + _tcslen(lpString) + 1];
_stprintf(pNewString, _T("%s%s"), psz, lpString);
const BOOL RES = WriteString(lpSection, lpKey, pNewString);
delete [] pNewString;
delete [] psz;
return RES;
}
DWORD CIni::GetArray(LPCTSTR lpSection, LPCTSTR lpKey, LPTSTR lpBuffer, DWORD dwBufSize, LPCTSTR lpDelimiter, BOOL bTrimString) const
{
if (lpBuffer != NULL)
*lpBuffer = _T('\0');
if (lpSection == NULL || lpKey == NULL)
return 0;
LPTSTR psz = __GetStringDynamic(lpSection, lpKey);
DWORD dwCopied = 0;
if (*psz != _T('\0'))
{
if (lpBuffer == NULL)
{
const DWORD MAX_LEN = _tcslen(psz) + 2;
LPTSTR p = new TCHAR[MAX_LEN + 1];
dwCopied = __StringSplit(psz, p, MAX_LEN, lpDelimiter, bTrimString);
delete [] p;
}
else
{
dwCopied = __StringSplit(psz, lpBuffer, dwBufSize, lpDelimiter, bTrimString);
}
}
delete [] psz;
return dwCopied;
}
#ifdef __AFXWIN_H__
void CIni::GetArray(LPCTSTR lpSection, LPCTSTR lpKey, CStringArray *pArray, LPCTSTR lpDelimiter, BOOL bTrimString) const
{
if (pArray != NULL)
pArray->RemoveAll();
const DWORD LEN = GetArray(lpSection, lpKey, NULL, 0, lpDelimiter);
if (LEN == 0)
return;
LPTSTR psz = new TCHAR[LEN + 3];
GetArray(lpSection, lpKey, psz, LEN + 2, lpDelimiter);
ParseDNTString(psz, __SubStrAdd, (LPVOID)pArray);
delete [] psz;
}
#endif
#ifdef __AFXWIN_H__
BOOL CIni::WriteArray(LPCTSTR lpSection, LPCTSTR lpKey, const CStringArray *pArray, int nWriteCount, LPCTSTR lpDelimiter) const
{
if (pArray == NULL)
return FALSE;
if (nWriteCount < 0)
nWriteCount = pArray->GetSize();
else
nWriteCount = min(nWriteCount, pArray->GetSize());
const CString DELIMITER = (lpDelimiter == NULL || *lpDelimiter == _T('\0')) ? _T(",") : lpDelimiter;
CString sLine;
for (int i = 0; i < nWriteCount; i++)
{
sLine += pArray->GetAt(i);
if (i != nWriteCount - 1)
sLine += DELIMITER;
}
return WriteString(lpSection, lpKey, sLine);
}
#endif
int CIni::GetInt(LPCTSTR lpSection, LPCTSTR lpKey, int nDefault, int nBase) const
{
TCHAR sz[DEF_PROFILE_NUM_LEN + 1] = _T("");
GetString(lpSection, lpKey, sz, DEF_PROFILE_NUM_LEN);
return *sz == _T('\0') ? nDefault : int(_tcstoul(sz, NULL, __ValidateBase(nBase)));
}
UINT CIni::GetUInt(LPCTSTR lpSection, LPCTSTR lpKey, UINT nDefault, int nBase) const
{
TCHAR sz[DEF_PROFILE_NUM_LEN + 1] = _T("");
GetString(lpSection, lpKey, sz, DEF_PROFILE_NUM_LEN);
return *sz == _T('\0') ? nDefault : UINT(_tcstoul(sz, NULL, __ValidateBase(nBase)));
}
BOOL CIni::GetBool(LPCTSTR lpSection, LPCTSTR lpKey, BOOL bDefault) const
{
TCHAR sz[DEF_PROFILE_NUM_LEN + 1] = _T("");
GetString(lpSection, lpKey, sz, DEF_PROFILE_NUM_LEN);
return StringToBool(sz, bDefault);
}
double CIni::GetDouble(LPCTSTR lpSection, LPCTSTR lpKey, double fDefault) const
{
TCHAR sz[DEF_PROFILE_NUM_LEN + 1] = _T("");
GetString(lpSection, lpKey, sz, DEF_PROFILE_NUM_LEN);
return *sz == _T('\0') ? fDefault : _tcstod(sz, NULL);
}
BOOL CIni::WriteInt(LPCTSTR lpSection, LPCTSTR lpKey, int nValue, int nBase) const
{
TCHAR szValue[DEF_PROFILE_NUM_LEN + 1] = _T("");
__IntToString(nValue, szValue, nBase);
return WriteString(lpSection, lpKey, szValue);
}
BOOL CIni::WriteUInt(LPCTSTR lpSection, LPCTSTR lpKey, UINT nValue, int nBase) const
{
TCHAR szValue[DEF_PROFILE_NUM_LEN + 1] = _T("");
__UIntToString(nValue, szValue, nBase);
return WriteString(lpSection, lpKey, szValue);
}
BOOL CIni::WriteDouble(LPCTSTR lpSection, LPCTSTR lpKey, double fValue, int nPrecision) const
{
TCHAR szFmt[16] = _T("%f");
if (nPrecision > 0)
_stprintf(szFmt, _T("%%.%df"), nPrecision);
TCHAR szValue[DEF_PROFILE_NUM_LEN + 1] = _T("");
_stprintf(szValue, szFmt, fValue);
return WriteString(lpSection, lpKey, szValue);
}
BOOL CIni::IncreaseDouble(LPCTSTR lpSection, LPCTSTR lpKey, double fIncrease, int nPrecision) const
{
double f = GetDouble(lpSection, lpKey, 0.0);
f += fIncrease;
return WriteDouble(lpSection, lpKey, f, nPrecision);
}
BOOL CIni::WriteBool(LPCTSTR lpSection, LPCTSTR lpKey, BOOL bValue) const
{
return WriteInt(lpSection, lpKey, bValue ? 1 : 0, BASE_DECIMAL);
}
BOOL CIni::InvertBool(LPCTSTR lpSection, LPCTSTR lpKey) const
{
return WriteBool(lpSection, lpKey, !GetBool(lpSection, lpKey, FALSE));
}
BOOL CIni::IncreaseInt(LPCTSTR lpSection, LPCTSTR lpKey, int nIncrease, int nBase) const
{
int nVal = GetInt(lpSection, lpKey, 0, nBase);
nVal += nIncrease;
return WriteInt(lpSection, lpKey, nVal, nBase);
}
BOOL CIni::IncreaseUInt(LPCTSTR lpSection, LPCTSTR lpKey, UINT nIncrease, int nBase) const
{
UINT nVal = GetUInt(lpSection, lpKey, 0, nBase);
nVal += nIncrease;
return WriteUInt(lpSection, lpKey, nVal, nBase);
}
TCHAR CIni::GetChar(LPCTSTR lpSection, LPCTSTR lpKey, TCHAR cDefault) const
{
TCHAR sz[2] = _T("");
GetString(lpSection, lpKey, sz, 1);
return *sz == _T('\0') ? cDefault : sz[0];
}
BOOL CIni::WriteChar(LPCTSTR lpSection, LPCTSTR lpKey, TCHAR c) const
{
TCHAR sz[2] = { c, _T('\0') };
return WriteString(lpSection, lpKey, sz);
}
DWORD CIni::GetDataBlock(LPCTSTR lpSection, LPCTSTR lpKey, LPVOID lpBuffer, DWORD dwBufSize, DWORD dwOffset) const
{
LPTSTR psz = __GetStringDynamic(lpSection, lpKey);
DWORD dwLen = _tcslen(psz) / 2;
if (dwLen <= dwOffset)
{
delete [] psz;
return 0;
}
for (int i = 0; psz[i] != _T('\0'); i++)
{
TCHAR c = psz[i];
if ((c >= _T('0') && c <= _T('9'))
|| (c >= _T('a') && c <= _T('f'))
|| (c >= _T('A') && c <= _T('F')))
{
}
else
{
delete [] psz;
return 0;
}
}
DWORD dwProcLen = 0;
LPBYTE lpb = (LPBYTE)lpBuffer;
if (lpb != NULL)
{
dwProcLen = min(dwLen - dwOffset, dwBufSize);
LPCTSTR p = &psz[dwOffset * 2];
for (DWORD i = 0; i < dwProcLen; i++)
{
TCHAR sz[3] = _T("");
_tcsncpy(sz, p, 2);
lpb[i] = BYTE(_tcstoul(sz, NULL, 16));
p = &p[2];
}
}
else
{
dwProcLen = dwLen - dwOffset;
}
delete [] psz;
return dwProcLen;
}
BOOL CIni::WriteDataBlock(LPCTSTR lpSection, LPCTSTR lpKey, LPCVOID lpData, DWORD dwDataSize) const
{
const BYTE* lpb = (const BYTE*)lpData;
if (lpb == NULL)
return FALSE;
LPTSTR psz = new TCHAR[dwDataSize * 2 + 1];
for (DWORD i = 0, j = 0; i < dwDataSize; i++, j += 2)
_stprintf(&psz[j], _T("%02X"), lpb[i]);
const BOOL RES = WriteString(lpSection, lpKey, psz);
delete [] psz;
return RES;
}
BOOL CIni::AppendDataBlock(LPCTSTR lpSection, LPCTSTR lpKey, LPCVOID lpData, DWORD dwDataSize) const
{
const BYTE* lpb = (const BYTE*)lpData;
if (lpb == NULL)
return FALSE;
LPTSTR psz = new TCHAR[dwDataSize * 2 + 1];
for (DWORD i = 0, j = 0; i < dwDataSize; i++, j += 2)
_stprintf(&psz[j], _T("%02X"), lpb[i]);
const BOOL RES = AppendString(lpSection, lpKey, psz);
delete [] psz;
return RES;
}
POINT CIni::GetPoint(LPCTSTR lpSection, LPCTSTR lpKey, POINT ptDefault) const
{
POINT pt;
if (GetDataBlock(lpSection, lpKey, &pt, sizeof(POINT)) != sizeof(POINT))
pt = ptDefault;
return pt;
}
RECT CIni::GetRect(LPCTSTR lpSection, LPCTSTR lpKey, RECT rcDefault) const
{
RECT rc;
if (GetDataBlock(lpSection, lpKey, &rc, sizeof(RECT)) != sizeof(RECT))
rc = rcDefault;
return rc;
}
BOOL CIni::WritePoint(LPCTSTR lpSection, LPCTSTR lpKey, POINT pt) const
{
return WriteDataBlock(lpSection, lpKey, &pt, sizeof(POINT));
}
BOOL CIni::WriteRect(LPCTSTR lpSection, LPCTSTR lpKey, RECT rc) const
{
return WriteDataBlock(lpSection, lpKey, &rc, sizeof(RECT));
}
DWORD CIni::GetKeyLines(LPCTSTR lpSection, LPTSTR lpBuffer, DWORD dwBufSize) const
{
if (lpBuffer != NULL)
*lpBuffer = _T('\0');
if (lpSection == NULL)
return 0;
if (lpBuffer == NULL)
{
DWORD dwLen = DEF_PROFILE_THRESHOLD;
LPTSTR psz = new TCHAR[dwLen + 1];
DWORD dwCopied = ::GetPrivateProfileSection(lpSection, psz, dwLen, m_pszPathName);
while (dwCopied + 2 >= dwLen)
{
dwLen += DEF_PROFILE_THRESHOLD;
delete [] psz;
psz = new TCHAR[dwLen + 1];
dwCopied = ::GetPrivateProfileSection(lpSection, psz, dwLen, m_pszPathName);
}
delete [] psz;
return dwCopied + 2;
}
else
{
return ::GetPrivateProfileSection(lpSection, lpBuffer, dwBufSize, m_pszPathName);
}
}
DWORD CIni::GetKeyNames(LPCTSTR lpSection, LPTSTR lpBuffer, DWORD dwBufSize) const
{
if (lpBuffer != NULL)
*lpBuffer = _T('\0');
if (lpSection == NULL)
return 0;
STR_LIMIT sl;
sl.lpTarget = lpBuffer;
sl.dwRemain = dwBufSize;
sl.dwTotalCopied = 0;
const DWORD LEN = GetKeyLines(lpSection, NULL, 0);
if (LEN == 0)
return 0;
LPTSTR psz = new TCHAR[LEN + 1];
GetKeyLines(lpSection, psz, LEN);
ParseDNTString(psz, __KeyPairProc, (LPVOID)(&sl));
delete [] psz;
if (lpBuffer != NULL)
lpBuffer[sl.dwTotalCopied] = _T('\0');
return sl.dwTotalCopied;
}
DWORD CIni::GetSectionNames(LPTSTR lpBuffer, DWORD dwBufSize) const
{
if (lpBuffer == NULL)
{
DWORD dwLen = DEF_PROFILE_THRESHOLD;
LPTSTR psz = new TCHAR[dwLen + 1];
DWORD dwCopied = ::GetPrivateProfileSectionNames(psz, dwLen, m_pszPathName);
while (dwCopied + 2 >= dwLen)
{
dwLen += DEF_PROFILE_THRESHOLD;
delete [] psz;
psz = new TCHAR[dwLen + 1];
dwCopied = ::GetPrivateProfileSectionNames(psz, dwLen, m_pszPathName);
}
delete [] psz;
return dwCopied + 2;
}
else
{
return ::GetPrivateProfileSectionNames(lpBuffer, dwBufSize, m_pszPathName);
}
}
#ifdef __AFXWIN_H__
void CIni::GetSectionNames(CStringArray *pArray) const
{
if (pArray != NULL)
pArray->RemoveAll();
const DWORD LEN = GetSectionNames(NULL, 0);
if (LEN == 0)
return;
LPTSTR psz = new TCHAR[LEN + 1];
GetSectionNames(psz, LEN);
ParseDNTString(psz, __SubStrAdd, pArray);
delete [] psz;
}
#endif
#ifdef __AFXWIN_H__
void CIni::GetKeyLines(LPCTSTR lpSection, CStringArray *pArray) const
{
if (pArray != NULL)
pArray->RemoveAll();
const DWORD LEN = GetKeyLines(lpSection, NULL, 0);
if (LEN == 0)
return;
LPTSTR psz = new TCHAR[LEN + 1];
GetKeyLines(lpSection, psz, LEN);
ParseDNTString(psz, __SubStrAdd, pArray);
delete [] psz;
}
#endif
#ifdef __AFXWIN_H__
void CIni::GetKeyNames(LPCTSTR lpSection, CStringArray *pArray) const
{
if (pArray == NULL)
return;
pArray->RemoveAll();
const LEN = GetKeyNames(lpSection, NULL, 0);
LPTSTR psz = new TCHAR[LEN + 1];
GetKeyNames(lpSection, psz, LEN);
ParseDNTString(psz, __SubStrAdd, (LPVOID)pArray);
delete [] psz;
}
#endif
BOOL CIni::DeleteSection(LPCTSTR lpSection) const
{
return ::WritePrivateProfileString(lpSection, NULL, _T(""), m_pszPathName);
}
BOOL CIni::DeleteKey(LPCTSTR lpSection, LPCTSTR lpKey) const
{
return ::WritePrivateProfileString(lpSection, lpKey, NULL, m_pszPathName);
}
BOOL CIni::IsSectionExist(LPCTSTR lpSection) const
{
if (lpSection == NULL)
return FALSE;
const DWORD LEN = GetSectionNames(NULL, 0);
if (LEN == 0)
return FALSE;
LPTSTR psz = new TCHAR[LEN + 1];
GetSectionNames(psz, LEN);
BOOL RES = !ParseDNTString(psz, __SubStrCompare, (LPVOID)lpSection);
delete [] psz;
return RES;
}
BOOL CIni::IsKeyExist(LPCTSTR lpSection, LPCTSTR lpKey) const
{
if (lpSection == NULL || lpKey == NULL)
return FALSE;
LPTSTR psz = __GetStringDynamic(lpSection, lpKey, DEF_PROFILE_TESTSTRING);
const BOOL RES = (_tcscmp(psz, DEF_PROFILE_TESTSTRING) != 0);
delete [] psz;
return RES;
}
BOOL CIni::CopySection(LPCTSTR lpSrcSection, LPCTSTR lpDestSection, BOOL bFailIfExist) const
{
if (lpSrcSection == NULL || lpDestSection == NULL)
return FALSE;
if (_tcsicmp(lpSrcSection, lpDestSection) == 0)
return FALSE;
if (!IsSectionExist(lpSrcSection))
return FALSE;
if (bFailIfExist && IsSectionExist(lpDestSection))
return FALSE;
DeleteSection(lpDestSection);
const DWORD SRC_LEN = GetKeyLines(lpSrcSection, NULL, 0);
LPTSTR psz = new TCHAR[SRC_LEN + 2];
GetKeyLines(lpSrcSection, psz, SRC_LEN);
const BOOL RES = ::WritePrivateProfileSection(lpDestSection, psz, m_pszPathName);
delete [] psz;
return RES;
}
BOOL CIni::CopyKey(LPCTSTR lpSrcSection, LPCTSTR lpSrcKey, LPCTSTR lpDestSection, LPCTSTR lpDestKey, BOOL bFailIfExist) const
{
if (lpSrcSection == NULL || lpSrcKey == NULL || lpDestKey == NULL)
return FALSE;
if (_tcsicmp(lpSrcSection, lpDestSection) == 0
&& _tcsicmp(lpSrcKey, lpDestKey) == 0)
return FALSE;
if (!IsKeyExist(lpSrcSection, lpSrcKey))
return FALSE;
if (bFailIfExist && IsKeyExist(lpDestSection, lpDestKey))
return FALSE;
LPTSTR psz = __GetStringDynamic(lpSrcSection, lpSrcKey);
const BOOL RES = WriteString(lpDestSection, lpDestKey, psz);
delete [] psz;
return RES;
}
BOOL CIni::MoveSection(LPCTSTR lpSrcSection, LPCTSTR lpDestSection, BOOL bFailIfExist) const
{
return CopySection(lpSrcSection, lpDestSection, bFailIfExist)
&& DeleteSection(lpSrcSection);
}
BOOL CIni::MoveKey(LPCTSTR lpSrcSection, LPCTSTR lpSrcKey, LPCTSTR lpDestSection, LPCTSTR lpDestKey, BOOL bFailIfExist) const
{
return CopyKey(lpSrcSection, lpSrcKey, lpDestSection, lpDestKey, bFailIfExist)
&& DeleteKey(lpSrcSection, lpSrcKey);
}
LPTSTR CIni::__GetStringDynamic(LPCTSTR lpSection, LPCTSTR lpKey, LPCTSTR lpDefault) const
{
TCHAR* psz = NULL;
if (lpSection == NULL || lpKey == NULL)
{
if (lpDefault == NULL)
{
psz = new TCHAR[1];
*psz = _T('\0');
}
else
{
psz = new TCHAR[_tcslen(lpDefault) + 1];
_tcscpy(psz, lpDefault);
}
return psz;
}
DWORD dwLen = DEF_PROFILE_THRESHOLD;
psz = new TCHAR[dwLen + 1];
DWORD dwCopied = ::GetPrivateProfileString(lpSection, lpKey, lpDefault == NULL ? _T("") : lpDefault, psz, dwLen, m_pszPathName);
while (dwCopied + 1 >= dwLen)
{
dwLen += DEF_PROFILE_THRESHOLD;
delete [] psz;
psz = new TCHAR[dwLen + 1];
dwCopied = ::GetPrivateProfileString(lpSection, lpKey, lpDefault == NULL ? _T("") : lpDefault, psz, dwLen, m_pszPathName);
}
return psz;
}
DWORD CIni::__StringSplit(LPCTSTR lpString, LPTSTR lpBuffer, DWORD dwBufSize, LPCTSTR lpDelimiter, BOOL bTrimString)
{
if (lpString == NULL || lpBuffer == NULL || dwBufSize == 0)
return 0;
DWORD dwCopied = 0;
*lpBuffer = _T('\0');
if (*lpString == _T('\0'))
return 0;
if (lpDelimiter != NULL && *lpDelimiter == _T('\0'))
{
_tcsncpy(lpBuffer, lpString, dwBufSize - 1);
return _tcslen(lpBuffer);
}
LPTSTR pszDel = (lpDelimiter == NULL) ? _tcsdup(DEF_PROFILE_DELIMITER) : _tcsdup(lpDelimiter);
const DWORD DEL_LEN = _tcslen(pszDel);
LPTSTR lpTarget = lpBuffer;
LPCTSTR lpPos = lpString;
LPCTSTR lpEnd = _tcsstr(lpPos, pszDel);
while (lpEnd != NULL)
{
LPTSTR pszSeg = __StrDupEx(lpPos, lpEnd);
if (bTrimString)
__TrimString(pszSeg);
const DWORD SEG_LEN = _tcslen(pszSeg);
const DWORD COPY_LEN = min(SEG_LEN, dwBufSize - dwCopied);
if (COPY_LEN > 0)
{
dwCopied += COPY_LEN + 1;
_tcsncpy(lpTarget, pszSeg, COPY_LEN);
lpTarget[COPY_LEN] = _T('\0');
lpTarget = &lpTarget[SEG_LEN + 1];
}
delete [] pszSeg;
lpPos = &lpEnd[DEL_LEN];
lpEnd = _tcsstr(lpPos, pszDel);
}
LPTSTR pszSeg = _tcsdup(lpPos);
if (bTrimString)
__TrimString(pszSeg);
const DWORD SEG_LEN = _tcslen(pszSeg);
const DWORD COPY_LEN = min(SEG_LEN, dwBufSize - dwCopied);
if (COPY_LEN > 0)
{
dwCopied += COPY_LEN + 1;
_tcsncpy(lpTarget, pszSeg, COPY_LEN);
lpTarget[COPY_LEN] = _T('\0');
}
delete [] pszSeg;
lpBuffer[dwCopied] = _T('\0');
delete [] pszDel;
return dwCopied;
}
BOOL CIni::ParseDNTString(LPCTSTR lpString, SUBSTRPROC lpFnStrProc, LPVOID lpParam)
{
if (lpString == NULL || lpFnStrProc == NULL)
return FALSE;
LPCTSTR p = lpString;
DWORD dwLen = _tcslen(p);
while (dwLen > 0)
{
if (!lpFnStrProc(p, lpParam))
return FALSE;
p = &p[dwLen + 1];
dwLen = _tcslen(p);
}
return TRUE;
}
BOOL CALLBACK CIni::__SubStrCompare(LPCTSTR lpString1, LPVOID lpParam)
{
assert(lpString1 != NULL);
LPCTSTR lpString2 = (LPCTSTR)lpParam;
assert(lpString2 != NULL);
return _tcsicmp(lpString1, lpString2) != 0;
}
BOOL CALLBACK CIni:: __KeyPairProc(LPCTSTR lpString, LPVOID lpParam)
{
STR_LIMIT* psl = (STR_LIMIT*)lpParam;
if (lpString == NULL || psl== NULL)
return FALSE;
LPCTSTR p = _tcschr(lpString, _T('='));
if (p == NULL || p == lpString)
return TRUE;
LPTSTR psz = new TCHAR[_tcslen(lpString) + 1];
for (int i = 0; &lpString[i] < p; i++)
psz[i] = lpString[i];
psz[i] = _T('\0');
__TrimString(psz);
DWORD dwNameLen = _tcslen(psz);
DWORD dwCopyLen = 0;
if (psl->lpTarget != NULL)
{
dwCopyLen = (psl->dwRemain > 1) ? min(dwNameLen, psl->dwRemain - 1) : 0;
_tcsncpy(psl->lpTarget, psz, dwCopyLen);
psl->lpTarget[dwCopyLen] = _T('\0');
psl->lpTarget = &(psl->lpTarget[dwCopyLen + 1]);
psl->dwRemain -= dwCopyLen + 1;
}
else
{
dwCopyLen = dwNameLen;
}
delete [] psz;
psl->dwTotalCopied += dwCopyLen + 1;
return TRUE;
}
#ifdef __AFXWIN_H__
BOOL CALLBACK CIni::__SubStrAdd(LPCTSTR lpString, LPVOID lpParam)
{
CStringArray* pArray = (CStringArray*)lpParam;
if (pArray == NULL || lpString == NULL)
return FALSE;
pArray->Add(lpString);
return TRUE;
}
#endif
void CIni::__ToBinaryString(UINT nNumber, LPTSTR lpBuffer, DWORD dwBufSize)
{
if (dwBufSize == 0)
return;
DWORD dwIndex = 0;
do
{
lpBuffer[dwIndex++] = (nNumber % 2) ? _T('1') : _T('0');
nNumber /= 2;
} while (nNumber > 0 && dwIndex < dwBufSize);
lpBuffer[dwIndex] = _T('\0');
_tcsrev(lpBuffer);
}
int CIni::__ValidateBase(int nBase)
{
switch (nBase)
{
case BASE_BINARY:
case BASE_OCTAL:
case BASE_HEXADECIMAL:
break;
default:
nBase = BASE_DECIMAL;
}
return nBase;
}
void CIni::__IntToString(int nNumber, LPTSTR lpBuffer, int nBase)
{
switch (nBase)
{
case BASE_BINARY:
case BASE_OCTAL:
case BASE_HEXADECIMAL:
__UIntToString((UINT)nNumber, lpBuffer, nBase);
break;
default:
_stprintf(lpBuffer, _T("%d"), nNumber);
break;
}
}
void CIni::__UIntToString(UINT nNumber, LPTSTR lpBuffer, int nBase)
{
switch (nBase)
{
case BASE_BINARY:
__ToBinaryString(nNumber, lpBuffer, DEF_PROFILE_NUM_LEN);
break;
case BASE_OCTAL:
_stprintf(lpBuffer, _T("%o"), nNumber);
break;
case BASE_HEXADECIMAL:
_stprintf(lpBuffer, _T("%X"), nNumber);
break;
default:
_stprintf(lpBuffer, _T("%u"), nNumber);
break;
}
}
BOOL CIni::StringToBool(LPCTSTR lpString, BOOL bDefault)
{
if (lpString == NULL || *lpString == _T('\0'))
return bDefault;
return (_tcsicmp(lpString, _T("true")) == 0
|| _tcsicmp(lpString, _T("yes")) == 0
|| _tcstol(lpString, NULL, BASE_DECIMAL) != 0);
}
BOOL CIni::__TrimString(LPTSTR lpString)
{
if (lpString == NULL)
return FALSE;
BOOL bTrimmed = FALSE;
unsigned int nLen = _tcslen(lpString);
while (nLen >= 0
&& (lpString[nLen - 1] == _T(' ')
|| lpString[nLen - 1] == _T('\t')
|| lpString[nLen - 1] == _T('\r')
|| lpString[nLen - 1] == _T('\n')))
{
lpString[--nLen] = _T('\0');
bTrimmed = TRUE;
}
LPCTSTR p = lpString;
while (*p == _T(' ')
|| *p == _T('\t')
|| *p == _T('\r')
|| *p == _T('\n'))
{
p = &p[1];
bTrimmed = TRUE;
}
if (p != lpString)
{
LPTSTR psz = _tcsdup(p);
_tcscpy(lpString, psz);
delete [] psz;
}
return bTrimmed;
}
LPTSTR CIni::__StrDupEx(LPCTSTR lpStart, LPCTSTR lpEnd)
{
const DWORD LEN = ((DWORD)lpEnd - (DWORD)lpStart) / sizeof(TCHAR);
LPTSTR psz = new TCHAR[LEN + 1];
_tcsncpy(psz, lpStart, LEN);
psz[LEN] = _T('\0');
return psz;
}
| C++ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.