sounds.cpp

Go to the documentation of this file.

/*
 * Crossfire -- cooperative multi-player graphical RPG and adventure game
 *
 * Copyright (c) 1999-2014 Mark Wedel and the Crossfire Development Team
 * Copyright (c) 1992 Frank Tore Johansen
 *
 * Crossfire is free software and comes with ABSOLUTELY NO WARRANTY. You are
 * welcome to redistribute it under certain conditions. For details, please
 * see COPYING and LICENSE.
 *
 * The authors can be reached via e-mail at <crossfire@metalforge.org>.
 */
 
#include "global.h"
 
#include <assert.h>
#include <stdlib.h>
#include <string.h>
 
#include "sounds.h"
#include "sproto.h"
 
#define MAX_SOUND_DISTANCE 10
 
void play_sound_player_only(player *pl, int8_t sound_type, object *emitter, int dir, const char *action) {
    SockList sl;
    int volume = 50;
    sstring name;
    object *source;
 
    if (pl->socket->sound&SND_MUTE || !(pl->socket->sound&SND_EFFECTS))
        return;
    if (pl->socket->sounds_this_tick >= MAX_SOUNDS_TICK)
        return;
    if (!emitter->map && !(emitter->env && emitter->env->map))
        return;
 
    source = emitter->map ? emitter : emitter->env;
 
    // Approximate the distance to the emitter from the source
    int dx = FABS(source->x-pl->ob->x),
        dy = FABS(source->y-pl->ob->y);
    int distance = (MIN(dx, dy) * 3 + FABS(dx-dy) * 2) / 2;
    // Make the sound dissipation more gradual.
    distance >>= 1;
    // Downscale the volume by distance
    volume = distance ? volume / distance : volume;
 
    pl->socket->sounds_this_tick++;
 
    name = emitter->name;
    if (emitter->type == PLAYER) {
        name = emitter->race;
    } else if (emitter->type == EXIT) {
        name = emitter->arch->clone.name;   /* The name may be custom, so use generic exit name */
    }
    if (name == NULL) {
        return;
    }
 
    SockList_Init(&sl);
    SockList_AddString(&sl, "sound2 ");
    SockList_AddChar(&sl, (int8_t)(source->x-pl->ob->x));
    SockList_AddChar(&sl, (int8_t)(source->y-pl->ob->y));
    SockList_AddChar(&sl, dir);
    SockList_AddChar(&sl, volume);
    SockList_AddChar(&sl, sound_type);
    SockList_AddLen8Data(&sl, action, strlen(action));
    SockList_AddLen8Data(&sl, name, strlen(name));
    Send_With_Handling(pl->socket, &sl);
    SockList_Term(&sl);
}
 
#define POW2(x) ((x)*(x))
 
void play_sound_map(int8_t sound_type, object *emitter, int dir, const char *action) {
    player *pl;
    object *source;
 
    if (!emitter->map && !(emitter->env && emitter->env->map))
        return;
 
    source = emitter->map ? emitter : emitter->env;
 
    // If sound_chance is defined, then we skip if the chance fails to generate a sound.
    if (emitter->sound_chance) {
        // Override -- sound chance > 200 acts as 0.
        if (emitter->sound_chance > 200)
            return;
        if (RANDOM() % 100 < emitter->sound_chance)
            return;
    }
 
    for (pl = first_player; pl; pl = pl->next) {
        if (pl->ob->map == emitter->map) {
            int distance = ihypot(pl->ob->x-source->x, pl->ob->y-source->y);
 
            if (distance <= MAX_SOUND_DISTANCE) {
                play_sound_player_only(pl, sound_type, emitter, dir, action);
            }
        }
    }
}
 
void send_background_music(player *pl, const char *music) {
    SockList sl;
 
    if (pl->socket->sound&SND_MUTE || !(pl->socket->sound&SND_MUSIC))
        return;
 
    SockList_Init(&sl);
    SockList_AddString(&sl, "music ");
    SockList_AddString(&sl, music == NULL ? "NONE" : music);
    Send_With_Handling(pl->socket, &sl);
    SockList_Term(&sl);
}
 
static char const* pick_bg_music(mapstruct *map) {
    if (map->background_music != NULL) {
        return map->background_music;
    }
    return get_name_of_region_for_map(map);
}
 
void player_update_bg_music(object *player) {
    assert(player->contr);
    assert(player->type == PLAYER);
    send_background_music(player->contr, pick_bg_music(player->map));
}