Support Forums

example #1 -
c->game->clientPid = gettip(); original
c->game->clientPid = gettid(); updated

example #2 -
I had to add something to make gettid(); work so I added this.

/************************************************************************
/
/ FUNCTION NAME: gettid()
/
/ FUNCTION: get the child processes id
/
/ ARGUMENTS:
/
/
*************************************************************************/
pid_t gettid(void) {
pid_t ret;
__asm__("int $0x80" : "=a" (ret) : "0" (224) /* SYS_gettid */);
if (ret < 0){
ret = -1;
}
return ret;
}

The result of replacing all gettips to gettid and adding the function allowed my game to boot properly.

THIS IS THE OLD FUNCTION

Do_suspend(struct client_t *c, struct event_t *the_event)
{
sigset_t sigMask;
int theAnswer, oldChannel;
bool oldMute, oldVirtual;
double oldEnergy;
char string_buffer[SZ_LINE];
char error_msg[SZ_ERROR_MESSAGE];

/* prepare to unblock SIGIO */
sigprocmask(0, NULL, &sigMask);
sigdelset(&sigMask, SIGIO);

/* set the suspended flag */
c->suspended = TRUE;
oldChannel = c->channel;
c->channel = 9;
oldMute = c->hearBroadcasts;
c->hearBroadcasts = TRUE;

Do_lock_mutex(&c->realm->realm_lock);
Do_player_description©;
oldVirtual = c->game->virtual;
c->game->virtual = TRUE;
Do_unlock_mutex(&c->realm->realm_lock);

Do_send_specification(c, CHANGE_PLAYER_EVENT);

Do_send_clear©;

sprintf(string_buffer, "Your game has been suspended by the Wizard %s. Until released, you will only be heard by game-wizard characters.\n", the_event->arg4);

Do_send_line(c, string_buffer);
free((void *)the_event->arg4);

Do_send_line(c, "Closing the window will kill your character and give you a ban.\n");

while(c->suspended) {

/* before we wait, send anything in the buffer */
Do_send_buffer©;

/* wait for a signal to proceed */
sigsuspend(&sigMask);

Do_get_nothing©;

Do_check_events_in©;

if (c->run_level == EXIT_THREAD || c->socket_up == FALSE) {
c->suspended = FALSE;
c->run_level = EXIT_THREAD;
return;
}
}

Do_more©;
Do_send_clear©;

c->channel = oldChannel;
c->hearBroadcasts = oldMute;

Do_lock_mutex(&c->realm->realm_lock);
Do_player_description©;
c->game->virtual = oldVirtual;
Do_unlock_mutex(&c->realm->realm_lock);

Do_send_specification(c, CHANGE_PLAYER_EVENT);

return;
}


THIS IS WHAT I REPLACED IT WITH

Do_suspend(struct client_t *c, struct event_t *the_event)
{
sigset_t sigMask;
int theAnswer, oldChannel;
bool oldMute, oldVirtual;
double oldEnergy;
char string_buffer[SZ_LINE];
char error_msg[SZ_ERROR_MESSAGE];

/* prepare to unblock SIGIO */
sigprocmask(0, NULL, &sigMask);
sigdelset(&sigMask, SIGIO);

/* set the suspended flag */
c->suspended = TRUE;
oldChannel = c->channel;
c->channel = 9;
oldMute = c->hearBroadcasts;
c->hearBroadcasts = TRUE;

Do_lock_mutex(&c->realm->realm_lock);
Do_player_description©;
oldVirtual = c->game->virtual;
c->game->virtual = TRUE;
Do_unlock_mutex(&c->realm->realm_lock);

Do_send_specification(c, CHANGE_PLAYER_EVENT);

Do_send_clear©;

sprintf(string_buffer, "Your game has been suspended by %s. Until released, you will only be heard by game-wizard characters.\n", the_event->arg4);

Do_send_line(c, string_buffer);
free((void *)the_event->arg4);

Do_send_line(c, "Closing the window will kill your character.\n");

while(c->suspended) {




/* before we wait, send anything in the buffer */

Do_send_buffer©;




/* wait for a signal to proceed */

/* if we run sigsuspend, we crash, why? who knows

sigsuspend(&sigMask);

*/

/* so just sleep for a second instead, same result, just choppy chat */

sleep(1);




Do_get_nothing©;




Do_check_events_in©;




if (c->run_level == EXIT_THREAD || c->socket_up == FALSE) {

c->suspended = FALSE;




c->run_level = EXIT_THREAD;

return;

}

}

Do_more©;
Do_send_clear©;

c->channel = oldChannel;
c->hearBroadcasts = oldMute;

Do_lock_mutex(&c->realm->realm_lock);
Do_player_description©;
c->game->virtual = oldVirtual;
Do_unlock_mutex(&c->realm->realm_lock);

Do_send_specification(c, CHANGE_PLAYER_EVENT);

return;
}

You can see what I did to improve it. After that part in the loop was fixed the game would stop crashing. Because that was fixed the game stopped randomly crashing aswell fixing about 3 out of 4 of my problems

/***************************************************************************
/ FUNCTION NAME: Do_opponent_struct(struct client_t *c, struct opponent_t *theOpponent)
/
/ FUNCTION: Check to see if a player entered an occupied square
/
/
/ ARGUMENTS:
/ struct server_t s - the server strcture
/ struct game_t this_game - pointer to the player we're checking
/
/ RETURN VALUE: none
/
/ DESCRIPTION:
/ Process arguments, initialize program, and loop forever processing
/ player input.
/
****************************************************************************/

void Do_opponent_struct(struct client_t *c, struct opponent_t *theOpponent)
{
char string_buffer[SZ_LINE];

c->battle.ring_in_use = FALSE;
c->battle.melee_damage = 0.0;
c->battle.skirmish_damage = 0.0;
c->battle.tried_luckout = FALSE;

strcpy(theOpponent->name, c->modifiedName);
theOpponent->processID = c->game->clientPid;

/* passable experience = all player exp now that nicking is capped */
/* Kings and higher are immune to nicking */
if (c->player.special_type >= SC_KING) {
theOpponent->experience = 0.0;
}
else {
theOpponent->experience = floor(c->player.experience /
(30 * c->player.level + 1));
}

theOpponent->strength = c->player.strength + c->player.sword;
theOpponent->max_strength = theOpponent->strength;
theOpponent->energy = c->player.energy;
theOpponent->max_energy = c->player.max_energy + c->player.shield;
theOpponent->speed = c->player.quickness + 1;
theOpponent->max_speed = theOpponent->speed;
theOpponent->brains = c->player.brains;
theOpponent->size = c->player.level;

/* the bigger they are, the harder they fall to all or nothing */
theOpponent->sin = c->player.sin + floor(c->player.level / 100);

sprintf(string_buffer,
"%s, %s, Level %.0lf, Sin %.0f has effective Sin of %.0lf\n",
c->player.lcname,
c->realm->charstats[c->player.type].class_name,
c->player.level,
c->player.sin,
theOpponent->sin);

Do_log(COMBAT_LOG, string_buffer);

theOpponent->shield = 0;
theOpponent->special_type = SM_IT_COMBAT;
theOpponent->treasure_type = 0;
theOpponent->flock_percent = 0;

/* throw up spells for combat */
Do_starting_spells©;
}


/***************************************************************************

/ FUNCTION NAME: Do_setup_it_combat(struct client_t *c, struct game_t *theGame)
/
/ FUNCTION: Check to see if a player entered an occupied square
/
/
/ ARGUMENTS:
/ struct server_t s - the server strcture
/ struct game_t this_game - pointer to the player we're checking
/
/ RETURN VALUE: none
/
/ DESCRIPTION:
/ Process arguments, initialize program, and loop forever processing
/ player input.
/
****************************************************************************/

Do_setup_it_combat(struct client_t *c, struct game_t *theGame)
{
float ftemp;

/* WARNING: c->realm->realm_lock is passed LOCKED! */
/*
Do_lock_mutex(&c->realm->realm_lock);
*/
struct it_combat_t *theCombat;
struct event_t *event_ptr;
struct it_combat_t *it_combat_ptr;
char string_buffer[SZ_LINE];

theCombat = (struct it_combat_t *) Do_malloc(SZ_IT_COMBAT);
theCombat->opponentFlag[0] = FALSE;
theCombat->opponentFlag[1] = FALSE;
theCombat->next_opponent = NULL;
theCombat->player_ptr = NULL;
Do_init_mutex(&theCombat->theLock);

c->game->it_combat = theCombat;

if (theGame->it_combat == NULL) {

theGame->it_combat = theCombat;
Do_unlock_mutex(&c->realm->realm_lock);

event_ptr = (struct event_t *) Do_create_event();
event_ptr->type = IT_COMBAT_EVENT;
event_ptr->arg4 = theCombat;
event_ptr->to = theGame;
event_ptr->from = c->game;

Do_send_event(event_ptr);

Do_send_clear©;

if (c->player.blind)
sprintf(string_buffer,
"You hear another player nearby!\n");
else
sprintf(string_buffer,
"You see another player in the distance!\n");
}
else {

it_combat_ptr = theGame->it_combat;

while (it_combat_ptr->next_opponent != NULL)
it_combat_ptr = it_combat_ptr->next_opponent;

it_combat_ptr->next_opponent = theCombat;
Do_unlock_mutex(&c->realm->realm_lock);

Do_send_clear©;

if (c->player.blind)
sprintf(string_buffer,
"You sense that several players are nearby!\n");
else
sprintf(string_buffer,
"You see several players in the distance!\n");
}

Do_send_line(c, string_buffer);

Do_lock_mutex(&theCombat->theLock);
Do_opponent_struct(c, &theCombat->opponent[0]);
c->battle.opponent = &theCombat->opponent[1];
Do_unlock_mutex(&theCombat->theLock);

/* for attacking another player, pick up sin */
Do_sin(c, .5);
sprintf(string_buffer, "%s ATTACKED another player.\n", c->player.lcname);
Do_log(BATTLE_LOG, string_buffer);

Do_send_line(c, "Waiting for the other player(s)...\n");

Do_it_combat_turns(c, theCombat, &theCombat->opponent[0],
&theCombat->opponentFlag[0], &theCombat->opponentFlag[1]);

return;
}


/***************************************************************************
/ FUNCTION NAME: Do_it_combat(struct client_t *c, struct event_t *theEvent)
/
/ FUNCTION: Check to see if a player entered an occupied square
/
/
/ ARGUMENTS:
/ struct server_t s - the server strcture
/ struct game_t this_game - pointer to the player we're checking
/
/ RETURN VALUE: none
/
/ DESCRIPTION:
/ Process arguments, initialize program, and loop forever processing
/ player input.
/
****************************************************************************/

Do_it_combat(struct client_t *c, struct event_t *theEvent, int available)
{
struct it_combat_t *theCombat;
char string_buffer[SZ_LINE];

Do_send_clear©;

theCombat = (struct it_combat_t *) theEvent->arg4;

Do_lock_mutex(&theCombat->theLock);

/* if our flag is set, there is a problem */
if (!theCombat->opponentFlag[1]) {

theCombat->opponentFlag[0] = TRUE;
theCombat->opponentFlag[1] = FALSE;

Do_opponent_struct(c, &theCombat->opponent[1]);

if (c->player.energy <= 0) {

theCombat->message = IT_JUST_DIED;
Do_unlock_mutex(&theCombat->theLock);
kill(theCombat->opponent[0].processID ,SIGIO);
Do_lock_mutex(&c->realm->realm_lock);
c->game->it_combat = NULL;
Do_unlock_mutex(&c->realm->realm_lock);
return;
}
else if (!available) {

theCombat->message = IT_JUST_LEFT;
Do_unlock_mutex(&theCombat->theLock);
kill(theCombat->opponent[0].processID ,SIGIO);
Do_lock_mutex(&c->realm->realm_lock);
c->game->it_combat = NULL;
Do_unlock_mutex(&c->realm->realm_lock);
return;
}
else {
theCombat->message = IT_REPORT;
}
}

c->battle.opponent = &theCombat->opponent[0];

if (c->player.blind) {
if (c->stuck) {
c->stuck = FALSE;
sprintf(string_buffer,
"Before you can move, you hear another player in the area!\n");
}
else {
sprintf(string_buffer,
"You hear another player approach!\n");
}
}
else {
if (c->stuck) {
c->stuck = FALSE;
sprintf(string_buffer,
"Before you can move, %s enters the area!\n",
theCombat->opponent[0].name);
}
else {
sprintf(string_buffer,
"You see %s approaching from the distance!\n",
theCombat->opponent[0].name);
}
}

Do_unlock_mutex(&theCombat->theLock);

kill(theCombat->opponent[0].processID ,SIGIO);

Do_send_line(c, string_buffer);
Do_send_buffer©;
sleep(2);

Do_it_combat_turns(c, theCombat, &theCombat->opponent[1],
&theCombat->opponentFlag[1], &theCombat->opponentFlag[0]);

return;
}