int
main(int argc, char **argv)
{
pthread_t sparky_thread;
fogger_args_t fogger_args = { 0.01, 0.01 };
track_t *cogs;
if (wb_init() < 0) {
fprintf(stderr, "failed to initialize wb\n");
exit(1);
}
if ((cogs = track_new("cogs.wav")) == NULL) {
exit(1);
}
pthread_create(&sparky_thread, NULL, sparky_main, NULL);
fogger_run_in_background(FOGGER_PIN, &fogger_args);
track_play_loop(cogs, NULL);
blink_main();
return 0;
}
int
main(int argc, char **argv)
{
server_args_t server_args;
pthread_t server_thread;
seed_random();
burp_track = track_new(BURP_WAV);
if (! burp_track) {
perror(BURP_WAV);
exit(1);
}
p = piface_new();
pthread_mutex_init(&event_lock, NULL);
server_args.port = 5555;
server_args.command = remote_event;
server_args.state = NULL;
pthread_create(&server_thread, NULL, server_thread_main, &server_args);
while(true) {
wait_for_trigger();
take_action();
wait_for_trigger_release();
if (n_consecutive_spits) {
wait_for_recharge();
}
}
return 0;
}
static void *
sparky_main(void *unused)
{
track_t *track;
stop_t *stop;
int last_state = 0;
set_lights(false, false);
if ((track = track_new("tesla.wav")) == NULL) {
perror("tesla.wav");
exit(1);
}
if (track) track_set_volume(track, 100);
stop = stop_new();
while (1) {
stop_reset(stop);
if (track) track_play_asynchronously(track, stop);
while (! stop_is_stopped(stop)) {
int ms = random_number_in_range(25, 100);
int state;
while ((state = random_number_in_range(0, 3)) == last_state) {}
last_state = state;
set_lights(state & 1, state & 2);
ms_sleep(ms);
}
}
return NULL;
}
int
main(int argc, char **argv)
{
stop_t *stop;
track_t *track;
fogger_args_t fogger_args = {
.default_duty = 0.01,
.delta_duty = 0.001,
};
seed_random();
if (wb_init() < 0) {
perror("wb_init");
exit(1);
}
if ((track = track_new("coffin-dog.wav")) == NULL) {
perror("coffin-dog.wav");
exit(1);
}
//track_set_volume(track, 50);
stop = stop_new();
fogger_run_in_background(FOGGER_PIN, &fogger_args);
wb_set(LIGHT_PIN, 1);
wb_set(LID_PIN, 0);
while (true) {
bool is_lit = true;
stop_reset(stop);
track_play_asynchronously(track, stop);
ms_sleep(ACTION_START);
while (! stop_is_stopped(stop)) {
int open_time = random_number_in_range(LID_OPEN_LOW, LID_OPEN_HIGH);
int closed_time = random_number_in_range(LID_CLOSED_LOW, LID_CLOSED_HIGH);
printf("\t\tlid %d %d\n", open_time, closed_time); fflush(stdout);
wb_set(LID_PIN, 1);
blink_lights_for(&is_lit, open_time);
wb_set(LID_PIN, 0);
blink_lights_for(&is_lit, closed_time);
}
wb_set(LIGHT_PIN, 1);
wb_set(LID_PIN, 0);
ms_sleep(random_number_in_range(INTERDELAY_LOW, INTERDELAY_HIGH));
}
return 0;
}
static track_t *track_create(const char *path,
AVFormatContext *avctx,
int track_index)
{
track_t *track;
char *tmp;
/*av_dump_format(avctx, 0, NULL, 0);*/
/* For each metadata first try container-level metadata. If no value is
* found, try stream-specific metadata.
*/
track = track_new();
track->file = strcopy(path);
track->title = copy_metadata(avctx, "title") ? : copy_metadata(avctx, "song");
if (!track->title) {
/* No title in metadata, use plain filename (no basename, it's crap). */
for (tmp = (char *)path + strlen(path);
tmp > path && *(tmp - 1) != '/';
--tmp) { }
track->title = strcopy(tmp);
}
track->trackindex = track_index;
tmp = get_metadata(avctx, "track");
if (tmp) {
sscanf(tmp, "%d", &track->track);
} else {
track->track = track_index;
}
track->artist = copy_metadata(avctx, "artist") ? : copy_metadata(avctx, "author");
track->album = copy_metadata(avctx, "album") ? : copy_metadata(avctx, "game");
track->albumartist = copy_metadata(avctx, "albumartist");
if (avctx->duration > 0) {
track->duration = avctx->duration / (double)AV_TIME_BASE;
} else {
track->duration =
avctx->streams[0]->duration * av_q2d(avctx->streams[0]->time_base);
}
if (track->duration <= 0) {
track_free(track);
track = NULL;
}
return track;
}
static void
load_tracks(void)
{
int track;
for (track = 0; track < N_TRACKS; track++) {
char fname[500];
sprintf(fname, "thunder/%d.wav", track);
if ((tracks[track] = track_new(fname)) == NULL) {
fprintf(stderr, "failed to open %s\n", fname);
}
}
}
/**
* @todo FIXME More or less ugly value duplication.
*/
track_t *library_track_by_id(int64_t id)
{
sqlite3_stmt *stmt;
track_t *track;
int result;
static const char *sql =
"SELECT rowid AS id, fileid, file, cuefileid, cuefile, track, title, artistid, artist, albumid, album, start, duration, trackindex FROM tracks WHERE rowid = ?";
if (sqlite3_prepare_v2(db_handle(), sql, -1, &stmt, NULL) != SQLITE_OK) {
musicd_log(LOG_ERROR, "library", "can't prepare '%s': %s", sql,
db_error());
return NULL;
}
sqlite3_bind_int(stmt, 1, id);
result = sqlite3_step(stmt);
if (result == SQLITE_DONE) {
return NULL;
} else if (result != SQLITE_ROW) {
musicd_log(LOG_ERROR, "library", "library_track_by_id: sqlite3_step failed");
return NULL;
}
track = track_new();
track->id = sqlite3_column_int64(stmt, 0);
track->fileid = sqlite3_column_int64(stmt, 1);
track->file = strcopy((const char *)sqlite3_column_text(stmt, 2));
track->cuefileid = sqlite3_column_int64(stmt, 3);
track->cuefile = strcopy((const char *)sqlite3_column_text(stmt, 4));
track->track = sqlite3_column_int(stmt, 5);
track->title = strcopy((const char *)sqlite3_column_text(stmt, 6));
track->artistid = sqlite3_column_int64(stmt, 7);
track->artist = strcopy((const char *)sqlite3_column_text(stmt, 8));
track->albumid = sqlite3_column_int64(stmt, 9);
track->album = strcopy((const char *)sqlite3_column_text(stmt, 10));
track->start = sqlite3_column_double(stmt, 11);
track->duration = sqlite3_column_double(stmt, 12);
track->trackindex = sqlite3_column_double(stmt, 13);
/*musicd_log(LOG_DEBUG, "library", "%" PRId64 " %s %s %d %s %s %s %lf %lf",
track->id, track->file, track->cuefile, track->track, track->title, track->artist,
track->album, track->start, track->duration);*/
sqlite3_finalize(stmt);
return track;
}
int
main(int argc, char **argv)
{
pthread_mutex_init(&station_lock, NULL);
pthread_mutex_init(&mermaid_lock, NULL);
if ((laugh = track_new("laugh.wav")) == NULL) {
perror("laugh.wav");
exit(1);
}
stop = stop_new();
fogger_run_in_background(FOGGER_PIN);
animation_main(stations);
return 0;
}
// Datei in Datenbank eintragen
gboolean register_file (gchar *file)
{
TagLib_File *tagfile;
TagLib_Tag *tag;
gint id_track;
gchar *line;
TrackDetails *track;
// Prüfen ob die Datei gültig ist
tagfile = taglib_file_new (file);
if (tagfile == NULL) {
return FALSE;
}
// Prüfen ob wir Tags haben
tag = taglib_file_tag (tagfile);
if (tagfile == NULL) {
return FALSE;
}
// Track hinzufügen
track = track_new ();
track->number = taglib_tag_track (tag);
track->path = g_strdup (file);
track->title = g_strdup (taglib_tag_title (tag));
track->artist->name = g_strdup (taglib_tag_artist (tag));
track->album->title = g_strdup (taglib_tag_album (tag));
track->album->genre = g_strdup (taglib_tag_genre (tag));
id_track = db_track_add (track);
line = g_strdup_printf ("Importiert: %s - %s (%s)", track->artist->name,
track->title, track->album->title);
settings_import_messages_add (line);
g_free (line);
// Speicher freigeben
track_free (track);
taglib_file_free (tagfile);
return TRUE;
}
int
main(int argc, char **argv)
{
pi_usb_init();
wb_init();
wb_set(LIGHTS, 0);
if ((m = maestro_new()) == NULL) {
fprintf(stderr, "Failed to initialize servo controller\n");
exit(1);
}
song = track_new(SONG_WAV);
if (! song) {
perror(SONG_WAV);
exit(1);
}
init_servos();
while (1) {
wb_set(LIGHTS, 0);
rest_servos();
ween2018_wait_until_valid();
ms_sleep(BETWEEN_SONG_MS);
nano_gettime(&start);
wb_set(LIGHTS, 1);
talking_skull_actor_play(lead);
talking_skull_actor_play(backup);
talking_skull_actor_play(bass);
talking_skull_actor_play(triangle);
track_play(song);
}
return 0;
}
int main(int argc, char **argv)
{
#if 0
CORBA_Environment ev;
CORBA_ORB orb;
Map map_client = CORBA_OBJECT_NIL;
#endif
char *gps;
setenv("LC_NUMERIC","C",1);
setlocale(LC_ALL,"");
setlocale(LC_NUMERIC,"C");
gtk_set_locale();
setlocale(LC_NUMERIC,"C");
debug_init();
gtk_init(&argc, &argv);
gdk_rgb_init();
// i18n basic support
bindtextdomain( "navit", "./locale" );
textdomain( "navit" );
map_data_default=load_maps(NULL);
plugin_load();
co=gui_gtk_window(1300000,7000000,32);
co->route=route_new();
route_mapdata_set(co->route, co->map_data);
gps=getenv("GPSDATA");
if (gps) {
co->vehicle=vehicle_new(gps);
if (co->vehicle) {
co->cursor=cursor_new(co,co->vehicle);
sdl_gui_new(co->vehicle);
}
} else {
g_warning(gettext("Environment-Variable GPSDATA not set - No gps tracking. Set it to file:filename or gpsd://host[:port]"));
}
co->speech=speech_new();
if (! co->speech)
g_warning(gettext("Can't connect to speechd, no speech output available"));
speech_handle=co->speech;
if (co->vehicle)
co->compass=compass_new(co);
if (co->vehicle)
co->track=track_new(co->map_data);
#if 0
CORBA_exception_init(&ev);
orb = CORBA_ORB_init(&argc, argv, "orbit-local-orb", &ev);
g_assert(ev._major == CORBA_NO_EXCEPTION);
map_srv_start_poa(orb, &ev);
g_assert(ev._major == CORBA_NO_EXCEPTION);
map_client = map_srv_start_object(&ev, map);
retval = CORBA_ORB_object_to_string(orb, map_client, &ev);
g_assert(ev._major == CORBA_NO_EXCEPTION);
ior=fopen("map.ior","w");
if (ior) {
fprintf(ior, "%s\n", retval);
fclose(ior);
}
CORBA_free(retval);
#endif
initSDL();
gtk_main();
return 0;
}
/**
* @todo FIXME Multiple files in same cue sheet
* @todo FIXME Rewrite this garbage
*/
bool cue_read(const char *cuepath, int64_t directory)
{
bool result = true;
FILE *file;
char *directory_path, *path, *path2;
bool header_read = false;
char album[512], albumartist[512];
char line[1024], instr[16], string1[512], *ptr;
int64_t track_file;
struct stat status;
//char file[strlen(path) + 1024 + 2], cuefile[strlen(path) + 1024 + 2];
int i;
int index, mins, secs, frames;
/* Track is stored in prev_track until index of the following track is known.
* This is mandatory for figuring out the track's length. Last track's
* length is calculated from file's total length. */
track_t *prev_track = NULL, *track = NULL, *file_track = NULL;
file = fopen(cuepath, "r");
if (!file) {
musicd_perror(LOG_ERROR, "cue", "can't open file %s", cuepath);
return false;
}
directory_path = malloc(strlen(cuepath));
/* Extract directory path. */
for (i = strlen(cuepath) - 1; i > 0 && cuepath[i] != '/'; --i) { }
strncpy(directory_path, cuepath, i);
directory_path[i] = '\0';
/* Directory + 256 4-byte UTF-8 characters + '/' + '\0', more than needed. */
path = malloc(strlen(directory_path) + 1024 + 2);
path2 = malloc(strlen(directory_path) + 1024 + 2);
album[0] = '\0';
albumartist[0] = '\0';
/* Check for BOM, seek back if not found. */
fread(line, 1, 3, file);
if (line[0] != (char)0xef
|| line[1] != (char)0xbb
|| line[2] != (char)0xbf) {
fseek(file, 0, SEEK_SET);
}
while (read_line(file, line, sizeof(line))) {
/* Read instruction, up to 15 characters. */
if (sscanf(line, "%15s", instr) < 1) {
continue;
}
/* Skip comments. */
if (!strcmp(instr, "REM")) {
continue;
}
ptr = line + strlen(instr) + 1;
if (ptr[0] == '"') {
ptr += read_string(ptr, string1) + 1;
}
if (!strcmp(instr, "PERFORMER")) {
/*musicd_log(LOG_DEBUG, "cue", "performer: %s", string1);*/
if (!header_read) {
strcpy(albumartist, string1);
} else if (track) {
free(track->artist);
track->artist = strcopy(string1);
}
} else if (!strcmp(instr, "TITLE")) {
/*musicd_log(LOG_DEBUG, "cue", "title: %s", string1);*/
if (!header_read) {
strcpy(album, string1);
} else if (track) {
free(track->title);
track->title = strcopy(string1);
}
} else if (!strcmp(instr, "FILE")) {
if (file_track) {
musicd_log(LOG_WARNING, "cue", "multiple FILEs in a single cue sheet"
"(%s) is currently unsupported, sorry",
cuepath);
break;
}
header_read = true;
sprintf(path, "%s/%s", directory_path, string1);
if (stat(path, &status)) {
result = false;
break;
}
/* Prioritizing: if there are multiple cue sheets and a cue sheet with
* same base name as the track file exists, it is used for the track.
* otherwise, sheet with highest mtime will result to be selected.
*/
for (i = strlen(path) - 1; i > 0 && path[i] != '.'; --i) { }
strncpy(path2, path, i);
strcpy(path2 + i, ".cue");
if (strcmp(path2, cuepath) && stat(path2, &status) == 0) {
musicd_log(LOG_DEBUG, "cue",
"multiple cue sheets for '%s', trying '%s'",
path, path2);
if (cue_read(path2, directory)) {
break;
}
}
file_track = track_from_path(path);
if (!file_track) {
break;
}
track_file = library_file(path, 0);
if (track_file > 0) {
/* File already exists, clear associated tracks. */
library_file_clear(track_file);
} else {
track_file = library_file(path, directory);
if (track_file <= 0) {
/* Some error... */
break;
}
}
library_file_mtime_set(track_file, status.st_mtime);
musicd_log(LOG_DEBUG, "cue", "audio: %s", path);
continue;
}
if (!file_track) {
continue;
}
if (!strcmp(instr, "TRACK")) {
sscanf(ptr, "%d %s", &index, string1);
/*musicd_log(LOG_DEBUG, "cue", "track: %d '%s'", index, string1);*/
if (track) {
if (!prev_track) {
prev_track = track;
} else {
prev_track->duration = track->start - prev_track->start;
library_track_add(prev_track, directory);
scan_track_added();
track_free(prev_track);
prev_track = track;
}
}
track = track_new();
track->cuefile = strcopy(cuepath);
track->file = strcopy(path);
track->track = index;
/* Set artist same as the album artist and replace if track spefific
* artist is later defined. */
track->artist = strcopy(albumartist);
track->album = strcopy(album);
track->albumartist = strcopy(albumartist);
}
if (!strcmp(instr, "INDEX")) {
sscanf(ptr, "%d %d:%d:%d", &index, &mins, &secs, &frames);
/*musicd_log(LOG_DEBUG, "cue", "index: %d %2.2d:%2.2d.%2.2d", index, mins, secs, frames);*/
if (index == 1) {
/* One frame is 1/75 seconds */
track->start = mins * 60.0 + secs + frames / 75.0;
}
}
}
if (prev_track) {
prev_track->duration = track->start - prev_track->start;
library_track_add(prev_track, directory);
scan_track_added();
track_free(prev_track);
}
if (track) {
track->duration = file_track->duration - track->start;
library_track_add(track, directory);
scan_track_added();
track_free(track);
}
track_free(file_track);
fclose(file);
free(directory_path);
free(path);
free(path2);
return result;
}
void
navit_init(struct navit *this_)
{
struct menu *mapmen,*men,*men2;
struct map *map;
struct mapset_handle *handle;
struct mapset *ms=this_->mapsets->data;
if (this_->menubar) {
mapmen=menu_add(this_->menubar, "Map", menu_type_submenu, NULL, NULL, NULL);
// menu_add(map, "Test", menu_type_menu, NULL, NULL);
men=menu_add(mapmen, "Layout", menu_type_submenu, NULL, NULL, NULL);
menu_add(men, "Test", menu_type_menu, NULL, NULL, NULL);
men=menu_add(mapmen, "Projection", menu_type_submenu, NULL, NULL, NULL);
menu_add(men, "M&G", menu_type_menu, navit_projection_set, this_, (void *)projection_mg);
menu_add(men, "Garmin", menu_type_menu, navit_projection_set, this_, (void *)projection_garmin);
handle=mapset_open(ms);
while ((map=mapset_next(handle,0))) {
char *s=g_strdup_printf("%s:%s", map_get_type(map), map_get_filename(map));
men2=menu_add(mapmen, s, menu_type_toggle, navit_map_toggle, this_, map);
menu_set_toggle(men2, map_get_active(map));
g_free(s);
}
mapset_close(handle);
}
{
struct mapset *ms=this_->mapsets->data;
struct coord c;
int pos,flag=0;
FILE *f;
char buffer[2048];
this_->route=route_new(ms);
this_->navigation=navigation_new(ms);
dbg(0,"navigation_register_callback(%p, ... %p)\n", this_->navigation, this_);
navigation_register_callback(this_->navigation, navigation_mode_long, navit_show_roadbook, this_);
#if 1
this_->track=track_new(ms);
#endif
men=NULL;
if (this_->menubar) {
men=menu_add(this_->menubar, "Route", menu_type_submenu, NULL, NULL, NULL);
men=menu_add(men, "Former Destinations", menu_type_submenu, NULL, NULL, NULL);
}
f=fopen("destination.txt", "r");
if (f) {
while (! feof(f) && fgets(buffer, 2048, f)) {
if ((pos=coord_parse(buffer, projection_mg, &c))) {
if (buffer[pos] && buffer[pos] != '\n' ) {
struct coord *cn=g_new(struct coord, 1);
*cn=c;
buffer[strlen(buffer)-1]='\0';
if (men)
menu_add(men, buffer+pos+1, menu_type_menu, navit_set_destination_menu, this_, cn);
}
flag=1;
}
}
fclose(f);
if (flag)
route_set_destination(this_->route, &c);
}
}
global_navit=this_;
}
void do_track( CHAR_DATA *ch, char *argument )
{
char buf [ MAX_STRING_LENGTH ];
char arg [ MAX_STRING_LENGTH ];
CHAR_DATA *victim;
int direction, skill;
bool fArea=TRUE;
skill=get_skill(ch, gsn_track);
if (IS_NPC(ch))
{
return;
}
if ( ch->mount )
{
send_to_char( "Najpierw zsi±d¼ ze swojego wierzchowca.\n\r", ch );
return;
}
if ( !IS_IMMORTAL( ch ) && IS_AFFECTED( ch, AFF_BLIND ) )
{
act("$n klêka i bezradnie potrz±sa g³ow±.",ch,NULL,NULL,TO_ROOM);
send_to_char("Klekasz, ale przecie¿ niczego nie widzisz.\n\r",ch);
return;
}
if ( room_is_dark( ch, ch->in_room ) && !(IS_AFFECTED( ch, AFF_DARK_VISION ) || IS_IMMORTAL( ch ) ))
{
send_to_char("Klekasz, ale jest tu tak ciemno, ¿e niczego nie widzisz.\n\r",ch);
return;
}
// wycinamy niektóre ze sektorów
switch ( ch->in_room->sector_type )
{
case 6: //woda p³yw
case 7: //woda niep
case 19: //rzeka
case 20: //jezioro
case 21: //morze
case 22: //ocean
case 23: //lawa
case 24: //ruchome piaski
case 25: //gor±ce ¼ród³o
case 34: //pod wod±
case 37: //ciemna woda
case 39: //podziemne jezioro
send_to_char( "Tutaj chyba nie da siê szukaæ ¶ladów.\n\r", ch );
return;
}
// komunikaty dla tych, którzy nie umiej± szukaæ ¶ladów
if ( skill == 0 )
{
switch (number_range(1,7))
{
case 1:
act("$n klêka i nie wie co robiæ dalej.",ch,NULL,NULL,TO_ROOM);
send_to_char("Klêkasz i nie za bardzo wiesz co robiæ dalej.\n\r",ch);
break;
case 2:
act("$n klêka i niczego nie widzi.",ch,NULL,NULL,TO_ROOM);
send_to_char("Klêkasz i niczego nie widzisz.\n\r",ch);
break;
case 3:
act("$n mocno tupie, klêka i przygl±da siê ¶ladom.",ch,NULL,NULL,TO_ROOM);
send_to_char("Mocno tupiesz, klêkasz i przygl±dasz siê ¶ladom.\n\r",ch);
break;
case 4:
act("$n klêka i ¶ledzi tropy, ale nie ma o tym zielonego pojêcia.",ch,NULL,NULL,TO_ROOM);
send_to_char("Klêkasz i ¶ledzisz tropy, choæ nie masz o tym zielonego pojêcia.\n\r",ch);
break;
case 5:
act("$n klêka i robi nieszczê¶liw± minê.",ch,NULL,NULL,TO_ROOM);
send_to_char("Klêkasz i robisz nieszczê¶liw± minê.\n\r",ch);
break;
case 6:
act("$n rozgl±da siê dooko³a.",ch,NULL,NULL,TO_ROOM);
send_to_char("Rozgl±dasz siê dooko³a, ale to nie pomaga.\n\r",ch);
break;
case 7:
act("$n zastanawia siê nad tym, ¿e tropienie to niez³a umiejêtno¶æ.",ch,NULL,NULL,TO_ROOM);
send_to_char("Zastanawiasz siê nad tym, ¿e tropienie to niez³a umiejêtno¶æ.\n\r",ch);
break;
default :
send_to_char( "Nie masz pojêcia jak to siê robi.\n\r", ch );
act("$n klêka i ¶ledzi tropy, ale nie ma o tym zielonego pojêcia.",ch,NULL,NULL,TO_ROOM);
break;
}
return;
}
// bonus/kara od dobrej lokacji s± wiêksze ni¿ od z³ej
if ( EXT_IS_SET( ch->in_room->room_flags, ROOM_CONSECRATE ))
{
if (IS_EVIL( ch ) ) skill -= number_range(1,5);
if (IS_GOOD( ch ) ) skill += number_range(1,5);
}
if ( EXT_IS_SET( ch->in_room->room_flags, ROOM_DESECRATE ))
{
if (IS_EVIL( ch ) ) skill += number_range(0,4);
if (IS_GOOD( ch ) ) skill -= number_range(0,4);
}
// sprawdzamy czy skill nie zrobi³ siê nam mniejszy ni¿ 1
if (skill < 1)
{
skill = 1;
}
// no to zaczynamy w³a¶ciwe trackowanie :D
one_argument( argument, arg );
#ifdef ENABLE_NEW_TRACK
if(MAX_TRACK_LEN > 0)
{
track_new(ch, skill, argument);
return;
}
#endif
if ( arg[0] == '\0' )
{
act("$n klêka i zaczyna z uwag± przygl±daæ siê ¶ladom.",ch,NULL,NULL,TO_ROOM);
act("Klêkasz i z uwag± przygl±dasz siê ¶ladom.",ch,NULL,NULL,TO_CHAR);
return;
}
if ( fArea )
{
victim = get_char_area( ch, arg );
}
else
{
victim = get_char_world( ch, arg );
}
if ( !victim )
{
act("$n klêka i zaczyna z uwag± przygl±daæ siê ¶ladom.",ch,NULL,NULL,TO_ROOM);
act("Klêkasz, przygl±dasz siê ¶ladom, ale nie znajdujesz ¿adnego tropu.",ch,NULL,NULL,TO_CHAR);
WAIT_STATE( ch, skill_table[gsn_track].beats );
return;
}
if(victim==ch)
{
act("Zastanawiasz siê przez chwilê czy to ma sens, no có¿...",ch,NULL,NULL,TO_CHAR);
return;
}
if ( ch->in_room == victim->in_room )
{
act( "Klêkasz i badasz trop, po chwili zdajesz sobie sprawê, ¿e $N stoi ko³o ciebie.", ch, NULL, victim, TO_CHAR );
act("$n klêka i zaczyna z uwag± przygl±daæ siê ¶ladom.",ch,NULL,NULL,TO_ROOM);
return;
}
if ( skill < number_range( 20, 40 ) )
{
act("$n klêka i zaczyna z uwag± przygl±daæ siê ¶ladom.",ch,NULL,NULL,TO_ROOM);
act("Klêkasz, przygl±dasz siê ¶ladom, ale nie znajdujesz ¿adnego tropu.",ch,NULL,NULL,TO_CHAR);
WAIT_STATE( ch, skill_table[gsn_track].beats );
check_improve(ch, NULL, gsn_track, FALSE, 12);
return;
}
if ( IS_AFFECTED ( victim, AFF_SPIRIT_WALK ) )
{
act("$n klêka i zaczyna z uwag± przygl±daæ siê ¶ladom.",ch,NULL,NULL,TO_ROOM);
act("Klêkasz, przygl±dasz siê ¶ladom, ale nie znajdujesz ¿adnego tropu.",ch,NULL,NULL,TO_CHAR);
WAIT_STATE( ch, skill_table[gsn_track].beats );
return;
}
else
{
act("$n klêka i zaczyna z uwag± przygl±daæ siê ¶ladom.",ch,NULL,NULL,TO_ROOM);
act("Klêkasz i przygladasz siê ¶ladom, chyba widzisz jaki¶ trop.",ch,NULL,NULL,TO_CHAR);
}
WAIT_STATE( ch, skill_table[gsn_track].beats );
direction = find_path( ch->in_room->vnum, victim->in_room->vnum, ch, -40000, fArea );
if ( direction == -1 )
{
act( "Niestety, nie mo¿esz nic wiêcej odczytaæ ze ¶ladów.", ch, NULL, victim, TO_CHAR );
return;
}
if ( direction < 0 || direction >= MAX_DIR )
{
send_to_char( "Hmm... co¶ jest nie tak.\n\r", ch );
return;
}
/*
* Give a random direction if the player misses the die roll.
*/
if ( number_percent() > skill )
{
do
{
direction = number_door( );
}
while ( !( ch->in_room->exit[direction] ) || !( ch->in_room->exit[direction]->u1.to_room ) );
}
check_improve(ch, NULL, gsn_track, TRUE, 9);
/*
* Display the results of the search.
*/
sprintf( buf, "Znajdujesz ¶lady $Z prowadz±ce na %s.", direction == 4 ? "górê" : dir_name[direction] );
act( buf, ch, NULL, victim, TO_CHAR );
return;
}
