coup_s choix_coup_ai(jeu_s jeu)
{
if (get_phase(jeu) == PHASE_PLACEMENT && get_joueur(jeu) == CHEVRE)
return(choix_placement_chevre(jeu));
if (get_joueur(jeu) == TIGRE)
return(choix_deplacement_tigre(jeu));
if (get_phase(jeu) == PHASE_DEPLACEMENT && get_joueur(jeu) == CHEVRE)
return(choix_deplacement_chevre(jeu));
}
int main()
{
init_captain_planet_with_our_powers_combined();
int phase = get_phase(CURRENT_TIME);
while(!black_button())
{
int phase = get_phase(CURRENT_TIME);
printf("%d\n",phase);
}
serializer_disconnect();
}
/* validation de la connexion d'un utilisateur */
void bienvenue(char *name, int sock_com){
char buffer[MAX_SIZE];
client_list *tmp;
pthread_mutex_lock(&mutex_clients);
if(client_exists(clients, name)){
/* si le nom du joueur est déjà pris */
sprintf(buffer, "%s already used\n", name);
write(sock_com, buffer, strlen(buffer));
pthread_mutex_unlock(&mutex_clients);
}else{
/* ajout dans la file d'attente tant que le client n'est pas nommé */
pthread_mutex_lock(&mutex_attente);
file_attente = add_name_client(file_attente, sock_com, name);
if(get_phase() == -1){
/* transfert du client dans la file d'attente vers la liste des clients */
tmp = get_client(file_attente, name);
file_attente = suppr_client(file_attente, name);
tmp->next = clients;
clients = tmp;
}
sprintf(buffer, "BIENVENUE/%s/\n", name);
write(sock_com, buffer, strlen(buffer));
pthread_mutex_unlock(&mutex_clients);
pthread_mutex_unlock(&mutex_attente);
/* Notification à tous les clients de la connexion de ce joueur */
connecte(name);
}
pthread_mutex_unlock(&mutex_clients);
}
void State::write_phase(string fileprefix) {
double *phase = get_phase();
stringstream filename;
filename << fileprefix << "-phase";
int local_no_halo_dim_x = grid->inner_end_x - grid->inner_start_x;
int local_no_halo_dim_y = grid->inner_end_y - grid->inner_start_y;
print_matrix(filename.str(), phase, local_no_halo_dim_x, local_no_halo_dim_x, local_no_halo_dim_y);
delete [] phase;
}
PeakList* find_peaks(int signal_size, sample* signal, MQParameters* params) {
int i;
int num_peaks = 0;
sample prev_amp, current_amp, next_amp;
PeakList* peak_list = (PeakList*)malloc(sizeof(PeakList));
peak_list->next = NULL;
peak_list->prev = NULL;
peak_list->peak = NULL;
// take fft of the signal
memcpy(params->fft_in, signal, sizeof(sample)*params->frame_size);
for(i = 0; i < params->frame_size; i++) {
params->fft_in[i] *= params->window[i];
}
fftw_execute(params->fft_plan);
// get initial magnitudes
prev_amp = get_magnitude(params->fft_out[0][0], params->fft_out[0][1]);
current_amp = get_magnitude(params->fft_out[1][0], params->fft_out[1][1]);
// find all peaks in the amplitude spectrum
for(i = 1; i < params->num_bins-1; i++) {
next_amp = get_magnitude(params->fft_out[i+1][0],
params->fft_out[i+1][1]);
if((current_amp > prev_amp) &&
(current_amp > next_amp) &&
(current_amp > params->peak_threshold)) {
Peak* p = (Peak*)malloc(sizeof(Peak));
p->amplitude = current_amp;
p->frequency = i * params->fundamental;
p->phase = get_phase(params->fft_out[i][0], params->fft_out[i][1]);
p->bin = i;
p->next = NULL;
p->prev = NULL;
add_peak(p, peak_list);
num_peaks++;
}
prev_amp = current_amp;
current_amp = next_amp;
}
// limit peaks to a maximum of max_peaks
if(num_peaks > params->max_peaks) {
PeakList* current = peak_list;
for(i = 0; i < params->max_peaks-1; i++) {
current = current->next;
}
delete_peak_list(current->next);
current->next = NULL;
num_peaks = params->max_peaks;
}
return sort_peaks_by_frequency(peak_list, num_peaks);
}
void Group::generate(float *buf, size_t samples)
{
Waveform type = (Waveform) list.get_cur_value();
float frequency = get_frequency();
float phase = get_phase();
generate_wave(type, buf, samples, t, frequency, phase);
t += dt * samples;
}
static mask_t
create_phase_field (char *s)
{
char *p;
mask_t bitfield = 0;
for (p = s; *p != NIL; p++) {
if (*p == ',') continue;
bitfield |= get_phase_mask(get_phase(*p));
}
return bitfield;
}
void Group::update_labels()
{
char buf[32];
float frequency = get_frequency();
float phase = get_phase();
sprintf(buf, "%4.0f Hz", frequency);
freq_val_label.set_text(buf);
sprintf(buf, "%.2f π", phase/PI);
phase_val_label.set_text(buf);
}
void processing_build_standing_wave(Processing* p, float* wave, float* light, size_t length, float thickness) {
double f = p->peakFrequency;
if(f < 40) f = 40;
if(f > 16000) f = 16000;
double waveLength = p->fd / f;
size_t index = p->previewLength - waveLength * 2;
double* src = &p->preview[index];
double re = 0; double im = 0;
for (size_t i = 0; i < waveLength*2; i++) {
double t = (double)2.0 * M_PI * i / waveLength;
re += src[i] * cos(t);
im += src[i] * sin(t);
}
double phase = get_phase(re, im);
double shift = waveLength * phase / (2.0 * M_PI);
// here something wrong !!!
// p->previewLength - waveLength * 2 - (size_t)(waveLength - shift) - (size_t)waveLength
// p->previewLength - waveLength * 4 + (0 .. waveLength)
double* shiftedSrc = &p->preview[index - (size_t)(waveLength - shift) - (size_t)waveLength];
approximate_sinc(p->points, shiftedSrc, p->pointCount, 2*waveLength);
double avr = data_avr(p->points, p->pointCount);
data_shift(p->points, p->pointCount, -avr);
double dev = data_dev(p->points, p->pointCount);
if(dev != 0){
data_scale(p->points, p->pointCount, 0.2/dev);
}
double dx = (double)2.0 / p->pointCount;
float* dest = wave;
for (size_t j = 0; j < p->pointCount-1; j ++) {
float x0 = dx * j - 1.0;
float y0 = p->points[j];
float x1 = dx*(j + 1) - 1.0;
float y1 = p->points[j+1];
dest = build_edge(dest, x0, y0, x1, y1, thickness);
for (int i = 0; i < 12; i++) {
light = write_point4D(light, x0, y0, x1, y1);
}
}
}
void zerophase(int window_size, void* args, Spectra source,
Spectra result) {
gsl_rng* r = gsl_rng_alloc(gsl_rng_default);
int i;
for (i = 0; i < window_size / 2 + 1; i++) {
set_by_polar(result, i, get_magnitude(source, i),
gsl_rng_uniform (r) * 2 * M_PI);
fprintf(stderr, "%f\n", get_phase(result, i));
if (i > 0 && i < window_size / 2) {
set_value(result, window_size - i, get_real(result, i),
get_imag(result, i));
}
}
}
static void write_stream_reflections_2_1(FILE *fh, RefList *list)
{
Reflection *refl;
RefListIterator *iter;
fprintf(fh, " h k l I phase sigma(I) "
" counts fs/px ss/px\n");
for ( refl = first_refl(list, &iter);
refl != NULL;
refl = next_refl(refl, iter) )
{
signed int h, k, l;
double intensity, esd_i, ph;
int red;
double fs, ss;
char phs[16];
int have_phase;
get_indices(refl, &h, &k, &l);
get_detector_pos(refl, &fs, &ss);
intensity = get_intensity(refl);
esd_i = get_esd_intensity(refl);
red = get_redundancy(refl);
ph = get_phase(refl, &have_phase);
/* Reflections with redundancy = 0 are not written */
if ( red == 0 ) continue;
if ( have_phase ) {
snprintf(phs, 16, "%8.2f", rad2deg(ph));
} else {
strncpy(phs, " -", 15);
}
fprintf(fh,
"%3i %3i %3i %10.2f %s %10.2f %7i %6.1f %6.1f\n",
h, k, l, intensity, phs, esd_i, red, fs, ss);
}
}
coup_s
saisir_coups(jeu_s jeu, aff_s aff)
{
int c;
MEVENT event;
mousemask(ALL_MOUSE_EVENTS, NULL);
int clics_sont_valides = 0;
int err;
coup_s coup = malloc(sizeof(t_coup_s));
int second_click = 0;
if (get_phase(jeu) == PHASE_PLACEMENT && get_joueur(jeu) == CHEVRE)
{
coup->source[ABS]=-1;
coup->source[ORD]=-1;
second_click = 1;
wattron(aff->etat, A_REVERSE | A_BOLD);
mvwprintw(aff->etat, 1, 2, "Positionnez une chèvre");
wattroff(aff->etat, A_REVERSE | A_BOLD);
wrefresh(aff->etat);
}
if (get_phase(jeu) == PHASE_DEPLACEMENT && get_joueur(jeu) == CHEVRE)
{
wattron(aff->etat, A_REVERSE | A_BOLD);
mvwprintw(aff->etat, 1, 2, "Déplacez une chèvre");
wattroff(aff->etat, A_REVERSE | A_BOLD);
wrefresh(aff->etat);
}
if (get_joueur(jeu) == TIGRE)
{
wattron(aff->etat, A_REVERSE | A_BOLD);
mvwprintw(aff->etat, 1, 2, "Déplacez un tigre");
wattroff(aff->etat, A_REVERSE | A_BOLD);
wrefresh(aff->etat);
}
do
{
keypad(stdscr, TRUE);
c = getch();
if (c == KEY_MOUSE)
if(getmouse(&event) == OK)
if(event.bstate & BUTTON1_CLICKED)
{
wmove(aff->etat, 1, 2);
wclrtoeol(aff->etat);
wmove(aff->etat, 2, 2);
wclrtoeol(aff->etat);
wmove(aff->etat, 3, 2);
wclrtoeol(aff->etat);
if (second_click)
{
wattron(aff->etat, A_BOLD);
mvwprintw(aff->etat, 3, 2, "FAIRE SELECTION");
wattroff(aff->etat, A_BOLD);
wrefresh(aff->etat);
err = coord_aff_vers_jeu(aff, event.y, event.x, &(coup->destination[ABS]),
&(coup->destination[ORD]));
if (!err)
{
clics_sont_valides = 1;
wmove(aff->etat, 2, 2);
wclrtoeol(aff->etat);
mvwprintw(aff->etat, 2, 2, "DX: ");
wattroff(aff->etat, A_BOLD);
wattron(aff->etat, A_BOLD);
wprintw(aff->etat, "%d ", coup->destination[ABS]);
wattroff(aff->etat, A_BOLD);
wprintw(aff->etat, "DY: ");
wattron(aff->etat, A_BOLD);
wprintw(aff->etat, "%d", coup->destination[ORD]);
wattroff(aff->etat, A_BOLD);
wrefresh(aff->etat);
}
else
{
wattron(aff->etat, A_REVERSE | A_BOLD);
mvwprintw(aff->etat, 2, 2, "Clic invalide, cliquez sur un pion!");
wattroff(aff->etat, A_REVERSE | A_BOLD);
wrefresh(aff->etat);
}
}
else
{
wattron(aff->etat, A_BOLD);
mvwprintw(aff->etat, 3, 2, "CHOIX DE LA DESTINATION");
wattroff(aff->etat, A_BOLD);
wrefresh(aff->etat);
err = coord_aff_vers_jeu(aff, event.y, event.x, &(coup->source[ABS]),
&(coup->source[ORD]));
if (!err)
{
second_click = 1;
wmove(aff->etat, 1, 2);
wclrtoeol(aff->etat);
wmove(aff->etat, 2, 2);
wclrtoeol(aff->etat);
mvwprintw(aff->etat, 1, 2, "SX: ");
wattroff(aff->etat, A_BOLD);
wattron(aff->etat, A_BOLD);
wprintw(aff->etat, "%d ", coup->source[ABS]);
wattroff(aff->etat, A_BOLD);
wprintw(aff->etat, "SY: ");
wattron(aff->etat, A_BOLD);
wprintw(aff->etat, "%d", coup->source[ORD]);
wattroff(aff->etat, A_BOLD);
wrefresh(aff->etat);
}
else
{
wmove(aff->etat, 1, 2);
wclrtoeol(aff->etat);
wmove(aff->etat, 2, 2);
wclrtoeol(aff->etat);
wattron(aff->etat, A_REVERSE | A_BOLD);
mvwprintw(aff->etat, 1, 2, "Clic invalide, cliquez sur un pion!");
wattroff(aff->etat, A_REVERSE | A_BOLD);
wrefresh(aff->etat);
}
}
}
if (c == 's')
{
sauvegarder(jeu);
afficher_message(aff, "Partie sauvegarder dans save.txt");
}
else if (c == 'c')
{
charger(jeu);
maj_affichage(jeu, aff);
afficher_message(aff, "Partie save.txt chargé");
}
else if (c == 'u')
{
jeu = undo(jeu);
maj_affichage(jeu, aff);
afficher_message(aff, "Action précedente annulée");
}
} while (!clics_sont_valides);
coup->type=get_joueur(jeu);
return coup;
}
void
maj_affichage(jeu_s jeu, aff_s aff)
{
int x, y;
int winmaxx, winmaxy;
getmaxyx(aff->etat, winmaxy, winmaxx);
mvwprintw(aff->etat, winmaxy - 2, 2, "Score TIGRE:");
wattron(aff->etat, A_BOLD);
wprintw(aff->etat, " %d", jeu->participant[TIGRE].score);
wattroff(aff->etat, A_BOLD);
wclrtoeol(aff->etat);
mvwprintw(aff->etat, winmaxy - 3, 2, "Score CHEVRE:");
wattron(aff->etat, A_BOLD);
wprintw(aff->etat, " %d", jeu->participant[CHEVRE].score);
wattroff(aff->etat, A_BOLD);
wclrtoeol(aff->etat);
if (get_phase(jeu) == PHASE_PLACEMENT)
{
mvwprintw(aff->etat, winmaxy - 4, 2, "PHASE: ");
wattron(aff->etat, A_BOLD);
wprintw(aff->etat, "PLACEMENT", get_phase(jeu));
wattroff(aff->etat, A_BOLD);
wclrtoeol(aff->etat);
}
if (get_phase(jeu) == PHASE_DEPLACEMENT)
{
mvwprintw(aff->etat, winmaxy - 4, 2, "PHASE: ");
wattron(aff->etat, A_BOLD);
wprintw(aff->etat, "DEPLACEMENT", get_phase(jeu));
wattroff(aff->etat, A_BOLD);
wclrtoeol(aff->etat);
}
if (get_joueur(jeu) == CHEVRE)
{
mvwprintw(aff->etat, winmaxy - 5, 2, "JOUEUR: ");
wattron(aff->etat, A_BOLD | COLOR_PAIR(20));
wprintw(aff->etat, "CHEVRE", get_joueur(jeu));
wattroff(aff->etat, A_BOLD | COLOR_PAIR(20));
wclrtoeol(aff->etat);
}
if (get_joueur(jeu) == TIGRE)
{
mvwprintw(aff->etat, winmaxy - 5, 2, "JOUEUR: ");
wattron(aff->etat, A_BOLD | COLOR_PAIR(21));
wprintw(aff->etat, "TIGRE", get_joueur(jeu));
wattroff(aff->etat, A_BOLD | COLOR_PAIR(21));
wclrtoeol(aff->etat);
}
mvwprintw(aff->etat, winmaxy - 6, 2, "CHEVRES A PLACER:");
wattron(aff->etat, A_BOLD);
wprintw(aff->etat, " %d", NB_MAX_CHEVRE-jeu->g->nb_chevre);
wattroff(aff->etat, A_BOLD);
wclrtoeol(aff->etat);
wrefresh(aff->etat);
// i = ORD = x
// j = ABS = y
for (int i = 0; i < PLATEAU_LARGEUR; i++)
{
for (int j = 0; j < PLATEAU_HAUTEUR; j++)
{
if (get_pion(jeu->p,j,i) == CHEVRE)
{
coord_jeu_vers_aff(aff, i, j, &y, &x);
retracer_case(aff, y, x, CHEVRE);
wrefresh(aff->plateau);
}
else if (get_pion(jeu->p,j,i) == TIGRE)
{
coord_jeu_vers_aff(aff, i, j, &y, &x);
retracer_case(aff, y, x, TIGRE);
wrefresh(aff->plateau);
}
else
{
coord_jeu_vers_aff(aff, i, j, &y, &x);
retracer_case(aff, y, x, VIDE);
wrefresh(aff->plateau);
}
}
}
mvwprintw(aff->cimetiere, 0, 2, "Pressez sur une touche:");
mvwprintw(aff->cimetiere, 1, 2, "[s] pour sauvegarder save.txt");
mvwprintw(aff->cimetiere, 2, 2, "[c] pour charger save.txt");
mvwprintw(aff->cimetiere, 3, 2, "[u] pour undo l'action précedente");
wrefresh(aff->cimetiere);
}
bool yarprobotinterfaceRpc::read(yarp::os::ConnectionReader& connection) {
yarp::os::idl::WireReader reader(connection);
reader.expectAccept();
if (!reader.readListHeader()) { reader.fail(); return false; }
yarp::os::ConstString tag = reader.readTag();
bool direct = (tag=="__direct__");
if (direct) tag = reader.readTag();
while (!reader.isError()) {
// TODO: use quick lookup, this is just a test
if (tag == "get_phase") {
std::string _return;
_return = get_phase();
yarp::os::idl::WireWriter writer(reader);
if (!writer.isNull()) {
if (!writer.writeListHeader(1)) return false;
if (!writer.writeString(_return)) return false;
}
reader.accept();
return true;
}
if (tag == "get_level") {
int32_t _return;
_return = get_level();
yarp::os::idl::WireWriter writer(reader);
if (!writer.isNull()) {
if (!writer.writeListHeader(1)) return false;
if (!writer.writeI32(_return)) return false;
}
reader.accept();
return true;
}
if (tag == "get_robot") {
std::string _return;
_return = get_robot();
yarp::os::idl::WireWriter writer(reader);
if (!writer.isNull()) {
if (!writer.writeListHeader(1)) return false;
if (!writer.writeString(_return)) return false;
}
reader.accept();
return true;
}
if (tag == "is_ready") {
bool _return;
_return = is_ready();
yarp::os::idl::WireWriter writer(reader);
if (!writer.isNull()) {
if (!writer.writeListHeader(1)) return false;
if (!writer.writeBool(_return)) return false;
}
reader.accept();
return true;
}
if (tag == "quit") {
std::string _return;
_return = quit();
yarp::os::idl::WireWriter writer(reader);
if (!writer.isNull()) {
if (!writer.writeListHeader(1)) return false;
if (!writer.writeString(_return)) return false;
}
reader.accept();
return true;
}
if (tag == "bye") {
std::string _return;
_return = bye();
yarp::os::idl::WireWriter writer(reader);
if (!writer.isNull()) {
if (!writer.writeListHeader(1)) return false;
if (!writer.writeString(_return)) return false;
}
reader.accept();
return true;
}
if (tag == "exit") {
std::string _return;
_return = exit();
yarp::os::idl::WireWriter writer(reader);
if (!writer.isNull()) {
if (!writer.writeListHeader(1)) return false;
if (!writer.writeString(_return)) return false;
}
reader.accept();
return true;
}
if (tag == "help") {
std::string functionName;
if (!reader.readString(functionName)) {
functionName = "--all";
}
std::vector<std::string> _return=help(functionName);
yarp::os::idl::WireWriter writer(reader);
if (!writer.isNull()) {
if (!writer.writeListHeader(2)) return false;
if (!writer.writeTag("many",1, 0)) return false;
if (!writer.writeListBegin(BOTTLE_TAG_INT, static_cast<uint32_t>(_return.size()))) return false;
std::vector<std::string> ::iterator _iterHelp;
for (_iterHelp = _return.begin(); _iterHelp != _return.end(); ++_iterHelp)
{
if (!writer.writeString(*_iterHelp)) return false;
}
if (!writer.writeListEnd()) return false;
}
reader.accept();
return true;
}
if (reader.noMore()) { reader.fail(); return false; }
yarp::os::ConstString next_tag = reader.readTag();
if (next_tag=="") break;
tag = tag + "_" + next_tag;
}
return false;
}
static int write_stream_reflections_2_1(FILE *fh, RefList *list,
struct image *image)
{
Reflection *refl;
RefListIterator *iter;
fprintf(fh, " h k l I phase sigma(I) "
" counts fs/px ss/px\n");
for ( refl = first_refl(list, &iter);
refl != NULL;
refl = next_refl(refl, iter) )
{
signed int h, k, l;
double intensity, esd_i, ph;
int red;
double fs, ss;
char phs[16];
int have_phase;
get_indices(refl, &h, &k, &l);
get_detector_pos(refl, &fs, &ss);
intensity = get_intensity(refl);
esd_i = get_esd_intensity(refl);
red = get_redundancy(refl);
ph = get_phase(refl, &have_phase);
/* Reflections with redundancy = 0 are not written */
if ( red == 0 ) continue;
if ( have_phase ) {
snprintf(phs, 16, "%8.2f", rad2deg(ph));
} else {
strncpy(phs, " -", 15);
}
if ( image->det != NULL ) {
struct panel *p;
double write_fs, write_ss;
p = find_orig_panel(image->det, fs, ss);
if ( p == NULL ) {
ERROR("Panel not found\n");
return 1;
}
/* Convert coordinates to match arrangement of panels
* in HDF5 file */
write_fs = fs - p->min_fs + p->orig_min_fs;
write_ss = ss - p->min_ss + p->orig_min_ss;
fprintf(fh, "%3i %3i %3i %10.2f %s %10.2f %7i "
"%6.1f %6.1f\n",
h, k, l, intensity, phs, esd_i, red,
write_fs, write_ss);
} else {
fprintf(fh, "%3i %3i %3i %10.2f %s %10.2f %7i "
"%6.1f %6.1f\n",
h, k, l, intensity, phs, esd_i, red,
fs, ss);
}
}
return 0;
}
