vehicles.c

Go to the documentation of this file.

#if defined(macintosh)
#include <types.h>
#include <time.h>
#else
#include <sys/types.h>
#include <sys/time.h>
#endif
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include "merc.h"
#include "interp.h"
#include "recycle.h"
#include "tables.h"
#include "lookup.h"
#include "vehicles.h" // Main header file for vehicles.
#include "olc.h"
#define VEDIT( fun )        bool fun( CHAR_DATA *ch, char *argument )
void update_vehicle (VDATA *veh);
void send_to_room (char*str,unsigned long int vnum);
/* Create new vehicle, allocate memory for it and return pointer to that vehicle.
 * NOTE: this does NOT add it to the v_list. It simple creates it's memory location.
 * To add it to the linked list, call add_vehicle(vehicle).
 *
 * Usage: vehicle = new_vehicle(); Where vehicle is a variable declared as a VDATA *
 * type.
 */
VDATA * new_vehicle()
{
    static VDATA vd;
    VDATA *vehicle;

    if (v_free == NULL)
        vehicle = alloc_perm(sizeof(*vehicle));
    else
    {
        vehicle = v_free;
        v_free = v_free->next;
    }
    *vehicle = vd;
    vehicle->room = alloc_perm(sizeof(*vehicle->room));
    vehicle->vnum = 0;
    vehicle->armor = 0;
    vehicle->max_armor = 0;
    vehicle->max_riders = 0;
    vehicle->path = NULL;
    vehicle->terrain = 0;
    vehicle->speed = 0;
    vehicle->max_speed = 0;
    vehicle->type = 0;
    vehicle->name = NULL;
    vehicle->s_vnum = 0;
    vehicle->i_vnum = 0;
    vehicle->cur_path_pos = 0;
    vehicle->loaded = FALSE;
    
    return vehicle;
}

/* Add a vehicle to the vehicle linked list. This does NOT allocate the memory for the
 * vehicle. You must do that via new_vehicle.
 *
 * Usage: add_vehicle(vehicle) where vehicle is an already-created VDATA struct called with
 * new_vehicle
 */
void add_vehicle(VDATA *vehicle)
{
    vehicle->next = v_list;
    v_list = vehicle;
    logf("Vehicle->path=%s", vehicle->path);
    logf("Vehicle->s_vnum=%d", vehicle->s_vnum);
    logf("Vehicle->i_vnum=%d", vehicle->i_vnum);
    
    return;
}

/* Delete a vehicle from the list. This does NOT delete the vehicle from memory, per-se.
 * Why? Because we don't want to disrupt the linked list. Since it will be NULL, no
 * use of it will be availble and it'll dissapear upon next copyover/reboot. The save
 * code will NOT save a null'd vehicle.
 *
 * Usage: delete_vehicle(vehicle); where Vehicle is an already allocated vehicle of type
 * VDATA struct.
 */

void delete_vehicle(VDATA *vehicle)
{
    if (vehicle == NULL)
        return; // no vehicle? We won't free it then.

    vehicle->room = NULL;
    vehicle->vnum = 0;
    
    vehicle->armor = 0;
    vehicle->max_armor = 0;
    vehicle->max_riders = 0;
    vehicle->path = NULL;
    vehicle->name = NULL;
    vehicle->terrain = 0;
    vehicle->speed = 0;
    vehicle->max_speed = 0;
    vehicle->type = 0;
    vehicle->s_vnum = 0;
    vehicle->i_vnum = 0;
    vehicle->cur_path_pos = 0;
    vehicle->loaded = FALSE;

    logf("Vehicle freed.");
}



void save_vehicles()
{
    FILE *fp;
    VDATA *vehicle;
    bool first_pass = TRUE;

    if ((fp = fopen(VEHICLE_FILE, "w")) == NULL)
    {
        logf("Unable to save vehicles!");
        return;
    }

    for (vehicle=v_list;vehicle;vehicle = vehicle->next)
    {
        if (vehicle->name == NULL)
            continue; // DOn't save it
        if (first_pass == FALSE)
            fprintf(fp, "\n");
        fprintf(fp, "Armor %d\n",vehicle->armor); 
        fprintf(fp, "MRiders %d\n",vehicle->max_riders);
            fprintf(fp, "Terrain %d\n", vehicle->terrain);
        fprintf(fp, "Speed %d\n", vehicle->speed);
        fprintf(fp, "MSpeed %d\n", vehicle->max_speed);
        fprintf(fp, "Type %d\n", vehicle->type);
        fprintf(fp, "Path %s~\n", vehicle->path);
        fprintf(fp, "Name %s~\n", vehicle->name);
        fprintf(fp, "Vnum %d\n", vehicle->vnum);
        fprintf(fp, "SVnum %d", vehicle->s_vnum);
        first_pass = FALSE;
        
    }

    fclose(fp);
}
void load_vehicles()
{
    FILE *fp;
    char buf[MSL];
    VDATA *vehicle;
    extern unsigned long int v_count;

    if ((fp = fopen(VEHICLE_FILE, "r")) == NULL)
    {
        logf("Unable to open vehicle file for reading.");
        return;
    }
    
    while (!feof(fp))
    {
        twiddle();
        if (!str_cmp(fread_word(fp), "Armor"))
        {
            logf("Loading armor");
            vehicle = new_vehicle();
            vehicle->armor = fread_number(fp);
        }
        if (!str_cmp(fread_word(fp), "MRiders"))
        {
            logf("Loading max_riders");
            vehicle->max_riders = fread_number(fp);
        }
        if (!str_cmp(fread_word(fp), "Terrain"))
        {
            logf("Loading terrain");
            vehicle->terrain = fread_number(fp);
        }
        if (!str_cmp(fread_word(fp), "Speed"))
        {
            logf("Loading speed");
            vehicle->speed = fread_number(fp);
        }
        if (!str_cmp(fread_word(fp), "MSpeed"))
        {
            logf("Loading max_speed");
            vehicle->max_speed = fread_number(fp);
        }
        if (!str_cmp(fread_word(fp), "Type"))
        {
            logf("Loading type");
            vehicle->type = fread_number(fp);
        }
        if (!str_cmp(fread_word(fp), "Path"))
        {
            logf("Loading path");
            vehicle->path = fread_string(fp);
        }
        if (!str_cmp(fread_word(fp), "Name"))
        {
            logf("Loading Name");
            vehicle->name = fread_string(fp);
        }
        
        if (!str_cmp(fread_word(fp), "Vnum"))
        {
            logf("Loading vnum");
            vehicle->vnum = fread_number(fp);
            logf("Saving vehicle");
            v_count+=1;
            vehicle->room = get_room_index(vehicle->vnum);
            
        }
        if (!str_cmp(fread_word(fp), "SVnum"))
        {
            logf("Loading start vnums");
            vehicle->s_vnum = fread_number(fp);
            vehicle->i_vnum = vehicle->s_vnum;
            vehicle->loaded = TRUE;
            add_vehicle(vehicle);
        }
        continue;
    }
    fclose(fp);
    send_to_all_copyover("\bDone.\n\r");

        
            
        
}

        
        
void do_show_vehicles(CHAR_DATA *ch, char*argument)
{
    char buf[MAX_INPUT_LENGTH];
    char pbuf[MSL];
    int found=0;
    

    VDATA *vehicle;
    
    

    printf_to_char(ch,"{c%-15s %-5s %-5s %-5s %-5s %-8s %-8s %-7s %-7s %-5s {x\n\r","Name","Vnum","SVnum","IVnum", "Armor", "MRiders", 
            "Terrain", "Speed", "MSpeed", "Type");
    send_to_char("{c---------------------------------------------------------------------------------------------{x\n\r",ch);

    for (vehicle=v_list;vehicle;vehicle=vehicle->next)
    {
        if (vehicle->room == NULL)
            continue;
        colourconv2(pbuf, vehicle->name);
        printf_to_char(ch,"%-15.15s %-5d %-5d %-5d %-5d %-8d %-8d %-7d %-7d %-5d\n\r",pbuf,
                vehicle->vnum, vehicle->s_vnum,vehicle->i_vnum,vehicle->armor,vehicle->max_riders,vehicle->terrain,
                vehicle->speed, vehicle->max_speed,vehicle->type);
        found++;
    }
    if (found == 0)
        send_to_char("No vehicles found.\n\r",ch);

    return;
}

void do_board (CHAR_DATA *ch, char * argument)
{
    char pbuf[MSL];
    VDATA *vehicle;
    if (argument[0] == '\0')
    {
        send_to_char("What do you want to board?\n\r",ch);
        return;
    }
    for (vehicle=v_list;vehicle;vehicle=vehicle->next)
    {
        if (vehicle->i_vnum != ch->in_room->vnum)
        {
            send_to_char("I don't see that here.\n\r",ch);
            return;
        }
        colourconv2(pbuf,vehicle->name);
        if (!str_prefix(argument, pbuf))
        {
            printf_to_char(ch,"You board the %s.\n\r", vehicle->name);
            char_from_room(ch);
            char_to_room(ch, get_room_index(vehicle->vnum));
            return;
        }
    }
    send_to_char("You don't see that here.\n\r",ch);
    return;
}
                
void do_disembark (CHAR_DATA *ch, char *argument)
{
    VDATA *vehicle;

    for (vehicle=v_list;vehicle;vehicle=vehicle->next)
    {
        if (vehicle->room->area == ch->in_room->area)
        {
                
            printf_to_char(ch,"You disembark from the %s.\n\r",vehicle->name);
            char_from_room(ch);
            char_to_room(ch, get_room_index(vehicle->i_vnum));
            return;
        }
    }
    send_to_char("You're not ON a vehicle, how can you disembark?\n\r",ch);
    
    return;
}

/* Simple function for redit to see if a vehicle is assigned
 * to that room or not. */

int vehicle_here (unsigned long int vnum)
{
    VDATA *vehicle;
    int vcount=0;

    for (vehicle=v_list;vehicle;vehicle=vehicle->next)
    {
        if (vehicle->vnum == vnum || vehicle->i_vnum == vnum)
            vcount+=1;
    }
    return vcount;
}
VEDIT (vedit_create)
{
    VDATA *vehicle;
    vehicle = new_vehicle();
    add_vehicle(vehicle);

    ch->desc->pEdit = (void*)vehicle;

    send_to_char("VEdit: Vehicle created.\n\r",ch);
    vehicle->name = str_dup(argument);
    return;
}

VEDIT (vedit_show)
{
    VDATA *vehicle;
    EDIT_VEHICLE (ch, vehicle);

    printf_to_char(ch, "Name      : [{c%s{x]\n\r", vehicle->name);
    printf_to_char(ch, "Vnum      : [{c%d{x]\n\r", vehicle->vnum);
    printf_to_char(ch, "Start Vnum: [{c%d{x]\n\r", vehicle->s_vnum);
    printf_to_char(ch, "Armor     : [{c%d{x]\n\r", vehicle->armor);
    printf_to_char(ch, "Max riders: [{c%d{x]\n\r",vehicle->max_riders);
    printf_to_char(ch, "Path      : [{c%s{x]\n\r", vehicle->path);
    printf_to_char(ch, "Terrain   : [{c%d{x]\n\r",vehicle->terrain);
    printf_to_char(ch, "Speed     : [{c%d{x]\n\r", vehicle->speed);
    printf_to_char(ch, "Type      : [{c%d{x]\n\r\n\r", vehicle->type);
    return;
}

VEDIT (vedit_name)
{
    VDATA *vehicle;
    EDIT_VEHICLE(ch, vehicle);

    if (argument[0] == '\0')
    {
        printf_to_char(ch, "Name is: %s\n\r", vehicle->name);
        return;
    }
    vehicle->name = str_dup(argument);

    printf_to_char(ch, "Name set to: %s\n\r",vehicle->name);
    return;
}

VEDIT (vedit_vnum)
{
    VDATA *vehicle;
    EDIT_VEHICLE(ch, vehicle);
    

    if (argument[0] == '\0' || !is_number(argument))
    {
        send_to_char("Vedit: Please enter a numeric value. This value must point to an already-created room.\n\r",ch);
        return;
    }
    if (atoi(argument) < 0)
    {
        send_to_char("Vedit: Vnum must be above zero!\n\r",ch);
        return;
    }
    if (get_room_index(atoi(argument)) == NULL)
    {
        send_to_char("Vedit: Room not found. Please make sure vnum is an already created room!\n\r",ch);
        return;
    }
    vehicle->vnum = atoi(argument);
    send_to_char("Vedit: Vnum set.\n\r",ch);
    vehicle->room = get_room_index(atoi(argument));
    return;
}

VEDIT (vedit_svnum)
{
    VDATA *vehicle;
    EDIT_VEHICLE(ch,vehicle);

    if (argument[0] == '\0' || !is_number(argument))
    {
        send_to_char("Vedit: Please enter a numerical value. This value must point to an already-created room.\n\r",ch);
        return;
    }
    if (atoi(argument) < 0)
    {
        send_to_char("VEdit: Start vnum must be above zero!\n\r",ch);
        return;
    }
    if (get_room_index(atoi(argument)) == NULL)
    {
        send_to_char("Vedit: Room not found. Please make sure this vnum is already created!\n\r",ch);
        return;
    }
    vehicle->s_vnum = atoi(argument);
    send_to_char("Vedit: Start vnum set.\n\r",ch);
    return;
}

VEDIT (vedit_armor)
{
    VDATA *vehicle;
    EDIT_VEHICLE(ch,vehicle);

    if (argument[0] == '\0' || !is_number(argument))
    {
        send_to_char("Vedit: Armor must be a numeric value.\n\r",ch);
        return;
    }
    
    if (atoi(argument) < 0)
    {
        send_to_char("Vedit: Armor value must be ATLEAST zero.\n\r",ch);
        return;
    }
    vehicle->armor = atoi(argument);
    send_to_char("Vedit: Vehicle's armor set.\n\r",ch);
}

VEDIT (vedit_path)
{
    VDATA *vehicle;
    EDIT_VEHICLE(ch,vehicle);

    if (argument[0] == '\0')
    {
        send_to_char("Vedit: Path must contain SOMETHING.\n\r",ch);
        return;
    }
    vehicle->path = str_dup(argument);
    send_to_char("Vedit: Vehicle's path set.\n\r",ch);
    return;
}

VEDIT (vedit_terrain)
{
    VDATA *vehicle;
    EDIT_VEHICLE(ch,vehicle);

    if (argument[0] == '\0' || !is_number(argument))
    {
        send_to_char("Vedit: Terrain must be a numberic value.\n\r",ch);
        return;
    }
    if (atoi(argument) < 0)
    {
        send_to_char("Vedit: Value too low. Try something that is NOT lower than zero?\n\r",ch);
        return;
    }
    vehicle->terrain = atoi(argument);
    send_to_char("Vedit: Vehicle's terrain set.\n\r",ch);
    return;

}

VEDIT (vedit_speed)
{
    VDATA *vehicle;
    EDIT_VEHICLE(ch, vehicle);

    if (argument[0] == '\0' || !is_number(argument))
    {
        send_to_char("Vedit: Vehicle's speed MUST be a numeric value.\n\r",ch);
        return;
    }
    if (atoi(argument) < 0)
    {
        send_to_char("Vedit: Value too low.\n\r",ch);
        return;
    }
    vehicle->speed = atoi(argument);
    send_to_char("Vedit: Vehicle's speed set.\n\r",ch);
    return;
}

VEDIT (vedit_type)
{
    VDATA *vehicle;
    EDIT_VEHICLE(ch, vehicle);

    if (argument[0] == '\0' || !is_number(argument))
    {
        send_to_char("Vedit: Vehicle's type MUST be a numberic value.\n\r",ch);
        return;
    }
    if (atoi(argument)< 0)
    {
        send_to_char("Vedit: Value too low.\n\r",ch);
        return;
    }
    vehicle->type = atoi(argument);
    send_to_char("Vedit: Vehicle's type set.\n\r", ch);
    return;
}

VEDIT (vedit_max_riders)
{
    VDATA *vehicle;
    EDIT_VEHICLE(ch,vehicle);

    if (argument[0] == '\0' || !is_number(argument))
    {
        send_to_char("Vedit: Vehicle's max riders MUST be numeric.\n\r",ch);
        return;
    }
    if (atoi(argument) < 0)
    {
        send_to_char("Vedit: Value too low.\n\r",ch);
        return;
    }
    vehicle->max_riders = atoi(argument);
    send_to_char("Vedit: Vehicle's max riders set.\n\r",ch);
    return;
}

VEDIT (vedit_delete)
{
    VDATA *vehicle;
    EDIT_VEHICLE (ch,vehicle);

    delete_vehicle(vehicle);

    send_to_char("Vedit: Vehicle marked for deletion. It shall dissapear after copyover.\n\r",ch);
    return;
}



void update_vehicle (VDATA *veh)
{
    char buf[MAX_STRING_LENGTH];
    char arg3[MAX_INPUT_LENGTH];
    char buf3[MSL];
    EXIT_DATA *pexit;
    CHAR_DATA *ch;
    ROOM_INDEX_DATA *t_room= get_room_index(veh->i_vnum);
    OBJ_DATA *obj;
    char *pdesc;
    int door;
    int number, count;
    VDATA *vehicle;
    DESCRIPTOR_DATA *d;
    sprintf(buf, "The %s has arrived.\n\r", veh->name);
    send_to_room(buf, veh->i_vnum);

    for (d=descriptor_list;d;d = d->next)
    {
        
        if (d->connected != CON_PLAYING)
            return;
        
        if (d->character->in_room->area != veh->room->area)
            return;
        ch = d->character;
        
    


        if (ch->position < POS_SLEEPING)
        {
            continue;;
        }



        if (!IS_NPC (ch)
            && !IS_SET (ch->act, PLR_HOLYLIGHT) && room_is_dark (t_room))
        {
            send_to_char ("It is pitch black ... \n\r", ch);
            show_char_to_char (t_room->people, ch);
            continue;
        }

        count = 0;

        if (time_info.hour > 18 || time_info.hour < 7)
        {
                sprintf(buf3, "{D%s {w({rDark{w){x", t_room->name);
                send_to_char(buf3,ch);
        }
        else
        {
                sprintf(buf3, "{c%s{x", t_room->name);
                send_to_char(buf3,ch);
        }
        if ((IS_IMMORTAL (ch)
             && (IS_NPC (ch) || IS_SET (ch->act, PLR_HOLYLIGHT)))
             || IS_BUILDER (ch, t_room->area))
        {
             sprintf (buf, "{r [{RRoom %d{r]{x", t_room->vnum);
             send_to_char (buf, ch);
        }

        send_to_char ("\n\r", ch);
    
        send_to_char ("  ", ch);
        send_to_char ("{S", ch);
        if (time_info.hour >= 18 || time_info.hour < 6)
        {
                printf_to_char(ch, "%s{x", t_room->night_description);
        }
        else
        {
                send_to_char (t_room->description, ch);
        }
        send_to_char ("{x", ch);
        

        for (vehicle=v_list;vehicle;vehicle=vehicle->next)
        {
                if (vehicle->i_vnum == t_room->vnum)
                        printf_to_char(ch,"    The %s is here.\n\r", vehicle->name);
        }

        show_list_to_char (t_room->contents, ch, FALSE, FALSE);
        show_char_to_char (t_room->people, ch);
    
 


        for (obj = t_room->contents; obj != NULL; obj = obj->next_content)
        {
            if (can_see_obj (ch, obj))
            {
                pdesc = get_extra_descr (arg3, obj->extra_descr);
                if (pdesc != NULL)
                    if (++count == number)
                    {
                        send_to_char (pdesc, ch);
                        break;
                    }

                pdesc = get_extra_descr (arg3, obj->pIndexData->extra_descr);
                if (pdesc != NULL)
                    if (++count == number)
                    {
                        send_to_char (pdesc, ch);
                        break;
                    }

                if (is_name (arg3, obj->name))
                    if (++count == number)
                    {
                        send_to_char (obj->description, ch);
                        send_to_char ("\n\r", ch);
                        break;
                    }
            }
        }
    }


    return;
}


void send_to_room (char*str,unsigned long int vnum)
{
    DESCRIPTOR_DATA *d;
    ROOM_INDEX_DATA *rdata;
    
    if (vnum < 0 || (rdata = get_room_index(vnum)) == NULL)
        return;
    
    for (d=descriptor_list;d;d=d->next)
    {
        if (d->connected != CON_PLAYING)
            continue;
        if (d->character->in_room->vnum == vnum)
        {
            send_to_char(str,d->character);
            continue;
        }
    }
    return;
}


void move_vehicle_npc (VDATA *vehicle)
{
    bool returning=FALSE;
    char buf[MIL];
    ROOM_INDEX_DATA *to_room;
    EXIT_DATA *pexit;
    ROOM_INDEX_DATA *t_room;
    char *const d_d[] = {"North", "South", "East", "West", "Northwest", "Northeast", "Southeast", "Southwest"};
    if (vehicle->loaded == FALSE)
        return;
    if (vehicle->path == NULL || vehicle->path[0] == '\0')
    {
        bug("Vehicle does not have a path!",0);
        return;
    }
    if (vehicle->cur_path_pos == strlen(vehicle->path))
        vehicle->cur_path_pos = 0;

    /*
     * n = north
     * s = south
     * w = west
     * e = east
     * N = northwest
     * E = northeast
     * S = southwest
     * W = southeast
     * 0-9 = wait 'ticks' -- explained later. not coded yet.
     */
    t_room = get_room_index(vehicle->i_vnum);
    if (!returning)
    {
        switch(vehicle->path[vehicle->cur_path_pos])
        {
            case 'n':
            {
                if ((pexit = t_room->exit[DIR_NORTH]) == NULL ||
                        (to_room = pexit->u1.to_room) == NULL)
                {
                    bugf("Vehicle's path is incorrect.",0);
                    return;
                }
                sprintf(buf, "The %s goes %s\n\r", vehicle->name, d_d[0]);
                send_to_room(buf,vehicle->i_vnum);
                vehicle->i_vnum = to_room->vnum;
                update_vehicle(vehicle);
                //add that later.
                break;
            }
            case 's':
            {
                if ((pexit = t_room->exit[DIR_SOUTH]) == NULL ||
                        (to_room = pexit->u1.to_room) == NULL)
                {
                    bugf("Vehicle's path is incorrect.",0);
                    return;
                }
                                sprintf(buf, "The %s goes %s\n\r", vehicle->name, d_d[1]);
                    send_to_room(buf, vehicle->i_vnum);
                                
                vehicle->i_vnum = to_room->vnum;
                update_vehicle(vehicle);                
                break;
            }
            case 'w':
            {
                                if ((pexit = t_room->exit[DIR_WEST]) == NULL ||
                                                (to_room = pexit->u1.to_room) == NULL)
                                {
                                        bugf("Vehicle's path is incorrect.",0);
                                        return;
                                }
                                sprintf(buf, "The %s goes %s\n\r", vehicle->name, d_d[3]);
                    send_to_room(buf,vehicle->i_vnum);
                                
                vehicle->i_vnum = to_room->vnum;
                update_vehicle(vehicle);

                break;
            }
            case 'e':
            {
                                if ((pexit = t_room->exit[DIR_EAST]) == NULL ||
                                                (to_room = pexit->u1.to_room) == NULL)
                                {
                                        bugf("Vehicle's path is incorrect.",0);
                                        return;
                                }
                                sprintf(buf, "The %s goes %s\n\r", vehicle->name, d_d[2]);
                                send_to_room(buf,vehicle->i_vnum);
                
                                vehicle->i_vnum = to_room->vnum;
                update_vehicle(vehicle);

                break;
            }
            case 'N':
            {
                                if ((pexit = t_room->exit[DIR_NORTHWEST]) == NULL ||
                                                (to_room = pexit->u1.to_room) == NULL)
                                {
                                        bugf("Vehicle's path is incorrect.",0);
                                        return;
                                }
                                sprintf(buf, "The %s goes %s\n\r", vehicle->name, d_d[4]);
                            send_to_room(buf,vehicle->i_vnum);
                    
                                vehicle->i_vnum = to_room->vnum;
                update_vehicle(vehicle);

                break;
            }
            case 'E':
            {
                                if ((pexit = t_room->exit[DIR_NORTHEAST]) == NULL ||
                                                (to_room = pexit->u1.to_room) == NULL)
                                {
                                        bugf("Vehicle's path is incorrect.",0);
                                        return;
                                }
                                sprintf(buf, "The %s goes %s\n\r", vehicle->name, d_d[5]);
                                send_to_room(buf,vehicle->i_vnum);
                
                                vehicle->i_vnum = to_room->vnum;
                update_vehicle(vehicle);

                break;
            }
            case 'S':
            {
                                if ((pexit = t_room->exit[DIR_SOUTHWEST]) == NULL ||
                                                (to_room = pexit->u1.to_room) == NULL)
                                {
                                        bugf("Vehicle's path is incorrect.",0);
                                        return;
                                }
                                sprintf(buf, "The %s goes %s\n\r", vehicle->name, d_d[7]);
                                send_to_room(buf,vehicle->i_vnum);
                
                                vehicle->i_vnum = to_room->vnum;
                update_vehicle(vehicle);
                

                break;
            }
            case 'W':
            {
                                if ((pexit = t_room->exit[DIR_SOUTHEAST]) == NULL ||
                                                (to_room = pexit->u1.to_room) == NULL)
                                {
                                        bugf("Vehicle's path is incorrect.",0);
                                        return;
                                }
                                sprintf(buf, "The %s goes %s\n\r", vehicle->name, d_d[6]);
                                send_to_room(buf,vehicle->i_vnum);
                
                                vehicle->i_vnum = to_room->vnum;
                update_vehicle(vehicle);

                break;
            }
            default:break;
        }
    }
    vehicle->cur_path_pos++;
    return;
}
            
    

---