void Result::Setup()
{
/* win = Texture("res/");
loos = Texture("res/");
*/
loosse = Media("res/Media/BGM/Result/lost.wav");
winse = Media("res/Media/BGM/Result/win.wav");
win_texture = Texture("res/Texture/win.png");
lose_texture = Texture("res/Texture/lose.png");
iswin = !env.isPushKey('1');
}
void s1s2(float *buffer,int num_samples,FILE *ficheiro){
int i,j,pos;
float maior;
float aux=0.0;
for(i=0; i<num_samples-1150; i++){
maior=0;
for(j=0;j<1150; j++){
if((i+j)<=num_samples){
if(maior<buffer[i+j]){
maior=buffer[i+j];
pos=i+j;
}
}
}
if(aux!=maior){
if(maior>Media(buffer,num_samples))
fprintf(ficheiro,"%d,",pos);
}
aux=maior;
}
}
int * s1s2toVector(float *buffer,int num_samples,int *peaks, int *ccc){
int i,j,pos,counter=0;
float maior;
float aux=0.0;
for(i=0; i<num_samples-1150; i++){
maior=0;
for(j=0;j<1150; j++){
if((i+j)<=num_samples){
if(maior<buffer[i+j]){
maior=buffer[i+j];
pos=i+j;
}
}
}
if(aux!=maior){
if(maior>Media(buffer,num_samples)){
peaks=(int*)realloc(peaks,(sizeof(int)*counter)+1);
peaks[counter]=pos;
counter++;
*ccc=counter;
i+=400;
}
}
aux=maior;
}
return peaks;
}
void geraArquivoEstatistico(char* fname) {
FILE* arq = fopen(fname, "w");
int i, j;
double media, dp;
fprintf(arq, "pos.x | pos.y | media | desvio padrão\n\n");
for (i = 0; i < H; i++)
{
#pragma omp parallel for private(media, dp) schedule(dynamic) ordered
for (j = 0; j < L; j++)
{
media = 0;
dp = 0;
if (node[i][j].hist->total > 0) {
media = Media(node[i][j].hist);
dp = DesvioPadrao(node[i][j].hist, media);
#pragma omp ordered
{
fprintf(arq, "%12.7f | %12.7f | %12.7f | %12.7f\n",
node[i][j].pto.x, node[i][j].pto.y, media, dp);
}
}
}
}
fclose(arq);
}
void ending(int& sceen){
Texture message = Texture("res/mese-ji.png");
Texture jijii = Texture("res/jijii.png");
Texture con = Texture("res/kongura.png");
Font font = ("res/meiryo.ttc");
std::string text1 = "いい人生じゃった最後までやってくれて";
std::string text2 = "本当にありがとうございました";
Media clear = Media ("res/se/clear.wav");
clear.play();
while (sceen == 3)
{
if (!env.isOpen()) exit(0);
env.begin();
env.bgColor(Color::black);
if (env.isPushKey(GLFW_KEY_ENTER)){
sceen = 0;
}
drawTextureBox(-1024, -312, 2048, 1024, 0, 0, 2048, 1024, jijii);
drawTextureBox(-1024, -512, 2048, 1024, 0, 0, 2048, 1024, message);
drawTextureBox(-1024, 0, 2048-400, 256-50, 0, 0, 2048, 256, con);
font.size(100);
font.draw(text1, Vec2f(-900, -300), Color::white);
font.draw(text2, Vec2f(-900, -400), Color::white);
font.size(30);
env.end();
}
}
int main(){
int Num1,Num2,Num3,caso;
printf("Escolha uma das opcoes abaixo :");
printf("\n\n MEDIA\n1-Geometrica\n2-Ponderada\n3-Harmonica\n4-Aritimetica\n");
scanf("%d",&caso);
printf("Digite tres numeros inteiros\n");
scanf("%d%d%d",&Num1,&Num2,&Num3);
Media(caso);
}
void StageSelect::loadRes() {
std::string texturepass = "******";
window_tex_ = Texture(texturepass + "Window_UI.png");
background_tex_ = Texture(texturepass + "StageSelect_UI.png");
mouse_tex_ = Texture(texturepass + "MouseP_UI.png");
scroll_tex_ = Texture(texturepass + "Scroll_UI.png");
scrollbar_tex_ = Texture(texturepass + "ScrollBar_UI.png");
dodai_tex_ = Texture(texturepass + "dodai.png");
std::string bgmpass = "******";
bgm_ = Media(bgmpass);
std::string sepass = "******";
mouse_se_ = Media(sepass + "MovingCursol.wav");
start_se_ = Media(sepass + "GameStart.wav");
cyancel_se_ = Media(sepass + "Cansel.wav");
select_se_ = Media(sepass + "Select.wav");
}
Media MediaList::getMedia(PurpleMedia* m)
{
BlockLockMutex lock(this);
vector<Media>::iterator it;
for(it = medias.begin(); it != medias.end() && it->getPurpleMedia() != m; ++it)
;
if(it == medias.end())
return Media();
else
return *it;
}
Ui::Ui(){
font.size(font_size);
tx = Texture("res/Texture/cursol.png");
tx2 = Texture("res/Texture/UI.png");
se = Media("res/Media/button02b.wav");
se2 = Media("res/Media/select02.wav");
animation = 0;
angle = 0;
instruction = 0;
action = false;
attack = false;
skill = false;
dir = false;
command_board.pos = Vec2f(-960, -540);
command_board.size = Vec2f(300, 1080);
status_board.pos = Vec2f(-660, -540);
status_board.size = Vec2f(1660, 300);
command.pos = Vec2f(-950, 430);
command.size = Vec2f(75, 70);
}
void Gamemain::Setup(){
map.Setup();
player.SetPos(map.GetPlayerPos());
count = 0;
enemy_number = 0;
Astar::get().setMap(map.GetStatus());
Astar::get().setup(map.GetEnemyChip(), map.GetPlayerChip());
ui.Setup();
BGM = Media("res/Media/BGM/playnaw.wav");
}
void StageSelect::setup()
{
col_ = (Color(0.0f, 0.0f, 0.0f, 1.0f));
is_Fade_ = (true);
is_Pushed_ = (false);
alpha_ = (1.0f);
is_Bgm_Setup_ = (false);
frame_ = (0);
select_Frame_ = (0);
select_SE_ = (Media("res/sound/selectSE.wav"));
press_Select_Frame_ = (0);
is_Menu_ = (false);
is_Exit_ = (false);
}
//-------------------------------------------------------------
Media & API::getMediaById( string id ){
if ( loadedMedia.count(id) < 1 ){
// build call
map<string,string> args;
args["api_key"] = api_key;
args["photo_id"] = id;
// get frob
string result = makeAPICall( "flickr.photos.getInfo", args, FLICKR_XML );
loadedMedia[id] = Media();
loadedMedia[id].loadFromXML( result );
}
return loadedMedia[id];
}
int main (void)
{
int i;
float vet[N], media;
for (i=0; i<N; i++)
{
printf ("Numero: "); // Números para o cálculo da média
scanf ("%f", &vet[i]); // Leitura dos números e armazenamento no vetor de tamanho N
}
media = Media(vet); // Variável "media" recebe o retorno da função Media
printf ("\n A media dos numeros e %5.2f \n\n", media); // Imprime o resultado
system ("pause");
return 0;
}
int main(void)
{
// 8: 0 1 2 3 4 5 6 7
long a[]= { 92,12,-2,25,57,15,23,-1}; // lista
// long a[]= { 50,50,50,50}; //,50,50,50,50}; // lista
int qtd = 8;
printf("\nRecursive: \n\n");
printArray( a, qtd );
printf("Resultados ---\n");
printf(" Menor : %3d \n", Menor( a, qtd) );
printf(" Maior : %3d \n", Maior( a, qtd) );
printf(" Soma : %3d \n", Soma ( a, qtd) );
printf(" Media : %3d \n", Media( a, qtd) );
return 0;
}
gboolean Media::media_new_cb(PurpleMediaManager *manager, PurpleMedia *media,
PurpleAccount *account, gchar *screenname, gpointer nul)
{
PurpleBuddy *buddy = purple_find_buddy(account, screenname);
const gchar *alias = buddy ?
purple_buddy_get_contact_alias(buddy) : screenname;
b_log[W_INFO] << "Started video with " << alias;
media_list.addMedia(Media(media, Buddy(buddy)));
g_signal_connect(G_OBJECT(media), "error",
G_CALLBACK(minbif_media_error_cb), media);
g_signal_connect(G_OBJECT(media), "state-changed",
G_CALLBACK(minbif_media_state_changed_cb), media);
g_signal_connect(G_OBJECT(media), "stream-info",
G_CALLBACK(minbif_media_stream_info_cb), media);
return TRUE;
}
void Media::minbif_media_state_changed_cb(PurpleMedia *media, PurpleMediaState state,
gchar *sid, gchar *name, void* gtkmedia)
{
if (sid == NULL && name == NULL) {
if (state == PURPLE_MEDIA_STATE_END) {
media_list.removeMedia(Media(media));
b_log[W_INFO] << "The call has been terminated.";
}
} else if (state == PURPLE_MEDIA_STATE_NEW &&
sid != NULL && name != NULL) {
if (purple_media_is_initiator(media, sid, NULL) == FALSE) {
g_timeout_add(500,
(GSourceFunc)Media::minbif_media_ready_cb,
gtkmedia);
purple_media_set_output_window(media, sid,
name, 0);
}
}
}
void Media::got_data(GstElement* object,
GstBuffer* buffer,
GstPad* arg1,
gpointer user_data)
{
try
{
gint w, h;
guint bpp = 0;
GstStructure* structure = gst_caps_get_structure (buffer->caps, 0);
gst_structure_get_int (structure, "width", &w);
gst_structure_get_int (structure, "height", &h);
gst_structure_get_int (structure, "bpp", (int *) &bpp);
if(!bpp)
bpp = 8;
CacaImage img(GST_BUFFER_DATA(buffer), GST_BUFFER_SIZE(buffer), w, h, bpp);
Media::media_list.enqueueBuffer(Media((PurpleMedia*)user_data), img);
}
catch(CacaError& e)
{
}
}
void Story(int& sceen){
Texture message = Texture("res/mese-ji.png");
Texture jijii = Texture("res/jijii.png");
Font font = ("res/meiryo.ttc");
std::string text1 = " ";
std::string text2 = " ";
Media ok = Media("res/se/kettei_.wav");
Media bgm = Media("res/se/sontyou.wav");
int count = 0;
bgm.looping(1);
bgm.play();
ok.play();
while (sceen == 1)
{
if (!env.isOpen()) exit(0);
env.begin();
env.bgColor(Color::black);
if (env.isPushKey(GLFW_KEY_ENTER)){
count++;
ok.play();
if (count == 12){
sceen = 2;
}
}
switch (count)
{
case 0:
break;
case 1:
text1 = "こんばんは";
text2 = "わしはこの村の村長じゃ";
break;
case 2:
text1 = "すまないこの村は今";
text2 = "何もないのじゃ";
break;
case 3:
text1 = "この村は前まではいろんな建物が";
text2 = "あって栄えていたんじゃが";
break;
case 4:
text1 = "数日前にワニに襲われて";
text2 = "村は一気に崩壊してもうたのじゃ";
break;
case 5:
text1 = "えっこの村を救ってくれるのか";
text2 = "本当にありがたいのぉー";
break;
case 6:
text1 = "おぬし名はなんと申す？";
text2 = " ";
break;
case 7:
text1 = "そうか金山かぁ";
text2 = "";
break;
case 8:
text1 = "基本的にWASDとENTERキー";
text2 = "を使用するのじゃ";
break;
case 9:
text1 = "お金を効率的に稼ぐとステータスを";
text2 = "上げることができるじゃ";
break;
case 10:
text1 = "10年ごと40年間、強い敵が来るで";
text2 = "それまでに備えて強くなっておくのじゃ";
break;
case 11:
text1 = "最初はまずわしの家に来て";
text2 = "お金稼ぎじゃ";
break;
}
drawTextureBox(-1024, -312, 2048, 1024, 0, 0, 2048, 1024, jijii);
drawTextureBox(-1024, -512, 2048, 1024, 0, 0, 2048, 1024, message);
font.size(100);
font.draw(text1, Vec2f(-900, -300), Color::white);
font.draw(text2, Vec2f(-900, -400), Color::white);
font.size(30);
font.draw("PUSH ENTER", Vec2f(WIDTH / 2, -HEIGHT / 2+30) - font.drawSize("PSHU ENTER"), Color::white);
env.end();
}
}
// 音楽ファイルの初期化
// TIPS: ゲーム起動時に１回だけ呼ぶ
void mediaDataInit() {
if (is_init_) { return; }
music[bgm::Title] = Media("res/wav/title.wav");
music[bgm::Strategy] = Media("res/wav/politics.wav");
music[bgm::DataSelect] = Media("res/wav/slot_select.wav");
music[bgm::Result_Win] = Media("res/wav/result_win.wav");
music[bgm::Result_Lose] = Media("res/wav/result_lose.wav");
music[bgm::Battle1] = Media("res/wav/battle_normal1.wav");
music[bgm::Battle2] = Media("res/wav/battle_normal2.wav");
music[bgm::Battle3] = Media("res/wav/battle_normal3.wav");
music[bgm::Boss1] = Media("res/wav/battle_boss1.wav");
music[bgm::Boss2] = Media("res/wav/battle_boss2.wav");
for (short i = 0; i < bgm::All_BGM; ++i) {
music[i].gain(0.5f);
music[i].looping(true);
}
se[se::Click] = Media("res/wav/click_1.wav");
se[se::Click_Menu] = Media("res/wav/click_2.wav");
se[se::MouseOn] = Media("res/wav/mouse_on.wav");
for (short i = 0; i < se::All_SE; ++i) { se[i].gain(0.5f); }
is_init_ = true;
}
bool
BNetworkDevice::IsEthernet()
{
return IFM_TYPE(Media()) == IFM_ETHER;
}
NS_IMETHODIMP
StyleSheet::GetMedia(nsIDOMMediaList** aMedia)
{
NS_ADDREF(*aMedia = Media());
return NS_OK;
}
bool
BNetworkDevice::IsWireless()
{
return IFM_TYPE(Media()) == IFM_IEEE80211;
}
//-------------------------------------------------------------
void API::threadedFunction(){
while (isThreadRunning()){
// work through queue in order
if ( APIqueue.size() > 0 ){
lock();
APICall apiCall = APIqueue.front();
APIqueue.erase(APIqueue.begin());
unlock();
string result = "";
string path;
APIEvent args;
switch (apiCall.type) {
case FLICKR_GETMEDIA:
path = buildAPICall( apiCall.method, apiCall.args, apiCall.format, apiCall.bSigned );
try
{
// Get REST style xml as string from flickr
std::auto_ptr<std::istream> pStr(URIStreamOpener::defaultOpener().open( "https://" + api_base + path ));
StreamCopier::copyToString(*pStr.get(), result);
// get frob
loadedMedia[apiCall.args["id"]] = Media();
loadedMedia[apiCall.args["id"]].loadFromXML( result );
args.results.push_back(loadedMedia[apiCall.args["id"]]);
ofNotifyEvent(APIEvent::events, args);
}
catch (Exception &ex)
{
cerr << ex.displayText() << endl;
}
break;
case FLICKR_SEARCH:
path = buildAPICall( apiCall.method, apiCall.args, apiCall.format, apiCall.bSigned );
try
{
// Get REST style xml as string from flickr
std::auto_ptr<std::istream> pStr(URIStreamOpener::defaultOpener().open( "https://" + api_base + path ));
StreamCopier::copyToString(*pStr.get(), result);
ofxXmlSettings xml; xml.loadFromBuffer(result);
xml.pushTag("rsp");{
xml.pushTag("photos"); {
for (int i=0; i<xml.getNumTags("photo"); i++){
Media med;
med.id = xml.getAttribute("photo", "id", "", i);
med.farm = xml.getAttribute("photo", "farm", "", i);
med.secret = xml.getAttribute("photo", "secret", "", i);
med.server = xml.getAttribute("photo", "server", "", i);
med.originalsecret = xml.getAttribute("photo", "originalsecret", "", i);
med.originalformat = xml.getAttribute("photo", "originalformat", "", i);
string t = xml.getAttribute("photo", "media", "", i);
if ( t == "photo"){
med.type = FLICKR_PHOTO;
} else if ( t == "video"){
med.type = FLICKR_VIDEO;
} else {
med.type = FLICKR_UNKNOWN;
}
args.results.push_back(med);
}
} xml.popTag();
} xml.popTag();
ofNotifyEvent(APIEvent::events, args);
}
catch (Exception &ex)
{
cerr << ex.displayText() << endl;
}
break;
case FLICKR_UPLOAD:
args.resultString = doUpload( apiCall.method );
ofNotifyEvent(APIEvent::events, args);
break;
default:
break;
}
}
sleep(20);
}
}
void effectSetup(Media& media,
const std::string& path,
const float gain) {
media = Media(path);
media.gain(gain);
}
Title::Title()
: font_(YuFont("src/whiteblack/Top/yumayoLib/meiryo.ttc"))
{
hyt::g_Title_AND_StageSelect_Bgm = (Media("res/sound/title.wav"));
setup();
}
int
main (int argc, char *argv[])
{
double x = 10.8, y = 89.90;
int val = 2, n = 5;
int vettore[MAX_LEN], tot_elem;
int data = 5;
/* CONCETTI FONDAMENTALI SULLE FUNZIONI
***************************************************************************
* Le funzioni sono essenziali nel contesto di un programma C, poiche'
* aiutano notevolmente nella realizzazione di programmi agili e
* performanti.
*
* La tipica funzione C99 e' cosi' strutturata:
*
* tipo-restituito nome-funzione( parametri )
* {
* dichiarazioni
* istruzioni
* }
*
* Il tipo-restituito e' il valore restituito dalla funzione stessa ed e'
* caratterizzato da alcune regole ben definite:
* - Qualora non dovesse essere prevista la restituzione di un valore, sara'
* specificato il tipo void;
* - Le funzioni non prevedono la restituzione di vettori;
* - (C89) Se si dovesse omettere il tipo-restituito sara' utilizzato il
* tipo di default <int>, in (C99) non e' prevista tale circostanza, ovvero
* deve sempre essere inserito il tipo restituito.
*
* nome-funzione, e' il nome della funzione, c'e' ampia liberta' in tal
* senso, tuttavia e' sempre meglio utilizzare nomi autoesplicativi che
* possano aiutare coloro che leggeranno il programma.
*
* Dopo il nome o ID, tra parentesi, ci sono i parametri, ciascun parametro
* deve essere preceduto da uno specificatore di tipo, tale regola vale
* anche quando ci sono diversi parametri dello stesso tipo; quando la
* funzione comprende diversi parametri ciascuno di essi deve essere
* separato dall'altro mediante una virgola, se invece la funzione non
* prevede parametri si puo' utilizzare void.
*
* Il corpo di una funzione puo' essere caratterizzato sia da dichiarazioni
* sia da istruzioni; le variabili dichiarate all'interno della funzione
* hanno lo scope (ambito di visibilita') all'interno della funzione stessa,
* per cui non sono visibili all'esterno del blocco della funzione. Nel C89
* le variabili dovevano essere dichiarate prima di tutte le altre
* istruzioni, nel C99 questa restrizione non c'e', naturalmente una
* variabile per essere utilizzata deve essere prima dichiarata, questo e'
* ovvio.
*
* Concettualmente appare logico che una funzione dovrebbe essere definita
* prima del main per poter essere utilizzata, poiche' altrimenti sarebbe
* impossibile ottenere le informazioni necessarie per invocare la funzione
* stessa; nel C99 e' possibile ovviare a questo problema dichiarando il
* prototipo della funzione prima che possa essere invocata, tale
* dichiarazione fornisce al compilatore i dettagli relativi al tipo di dato
* e ai parametri, la definizione della stessa invece potra' essere
* implementata successivamente. Tale dichiarazione prende il nome di
* prototipo della funzione, e consta della prima linea della definizione,
* seguito pero' da un punto e virgola finale:
*
* tipo-restituito nome-funzione( parametri );
*
* Il prototipo della funzione naturalmente deve essere fedele alla sua
* definizione, nel prototipo inoltre, per cio' che concerne i parametri,
* non c'e' l'obbligo di inserire il nome ma e' sufficiente il tipo di dato:
*
* <int Somma(int, int);> piuttosto che <int Somma(int x, int y);>
* Questa comunque non e' una regola ma solo una possibilita', che peraltro
* andrebbe presa con le molle e comunque gestita con criterio.
*/
/* L'esempio seguente mostra in estrema sintesi tutto cio' che e' stato
* detto sin'ora. */
printf ("La media di %g + %g = %g\n", x, y, Media (x, y));
/* ARGOMENTI (ARGOMENTI ATTUALI) E PARAMETRI (ARGOMENTI FORMALI)
***************************************************************************
* In genere si indica come parametro (argomento formale) la variabile
* menzionata nell'elenco tra parentesi della definizione di una funzione,
* mentre con argomento (argomento attuale) si indica il valore usato da una
* chiamata di una funzione; nel caso specifico, nella chiamata Media(x,y)
* le variabili x e y sono argomenti o argomenti attuali, mentre val_a e
* val_b sono parametri o argomenti formali. Gli argomenti attuali pertanto
* sono delle espressioni, i parametri sono dei nomi che saranno forniti
* alla funzione allorquando sara' invocata.
*
* Nel C gli argomenti sono passati per valore, cio' vuol dire che quando si
* verifica una chiamata di funzione ogni argomento sara' calcolato e il
* risultato inserito nel corrispondente parametro.
*
* Come si evince dalla funzione si lavora con delle copie, pertanto i
* valori passati come argomenti non saranno modificati.
*/
printf ("Potenza %d^%d = %d\n", val, n, Potenza (val, n));
printf ("Valori degli argomenti nel main val=%d n=%d\n", val, n);
/* VETTORI COME ARGOMENTI
***************************************************************************
* Quando il vettore passato come argomento e' unidimensionale si potrebbe
* anche evitare di fornire la lunghezza, ma questo sara' comunque un
* problema poiche' se dovesse servire la lunghezza del vettore si dovrebbe
* gestire ulteriore codice per calcolarla.
*
* Un vettore unidimensionale puo' essere gestito in una funzione mediante
* due argomenti, il vettore stesso e la lunghezza; nel prototipo e nella
* definizione della funzione vanno inserite le quadre assieme al vettore,
* nell'argomento attuale invece le quadre non sono necessarie; da notare
* che la funzione non ha modo di verificare se la lunghezza fornita del
* vettore sia esatta o meno, porre pertanto particolare attenzione.
*/
tot_elem = SommaElementi (vettore, MAX_LEN);
printf ("Somma elementi vettore = %d\n", tot_elem);
/* Da notare che, mediante la funzione SommaElementi(), ciascun elemento del
* vettore e' stato modificato; ma non si era detto che gli argomenti,
* essendo passati per valore, non possono essere modificati? Certo, ma
* ovviamente ci sono delle eccezioni, vettori e puntatori viaggiano in
* stretto contatto peraltro, per cui e' facilmente intuibile perche' e'
* stato possibile modificare i valori di un vettore. Tale argomento tuttavia
* sara' ampiamente trattato allorquando ci si occupera' di funzioni e
* puntatori.
*/
/* RETURN
***************************************************************************
* Se una funzione non e' stata dichiarata void si deve utilizzare
* l'istruzione return per restituire il risultato, possono essere
* utilizzate anche diverse istruzioni return all'interno dello stesso
* blocco, l'importante e' che logicamente la funzione ritorni solo e
* soltanto una volta; essa e' cosi' strutturata:
*
* return expr;
*
* Spesso e volentieri expr corrisponde ad una costante intera, come il
* valore di ritorno del main, 0 (true) oppure 1 (false); da notare che
* potrebbe essere utilizzata anche in una funzione di tipo void, ad esempio
* per controllare un valore ed eventualmente far terminare la funzione:
*/
StampaGiorno (31); /* L'unico visualizzato */
StampaGiorno (-1);
StampaGiorno (32);
/* L'espressione associata all'istruzione return puo' anche essere gestita
* mediante un'istruzione condizionale (verificare la funzione non il codice
* nel mail):
*/
while (data--)
{
if (VerificaData (data) > 0)
printf ("%d e' una data valida\n", data);
else
printf ("%d non e' una data valida\n", data);
}
/*SommaInterna(100); */
return (EXIT_SUCCESS);
}
