static void
event_thread_init(void *drcontext)
{
per_thread_t *data;
/* allocate thread private data */
data = dr_thread_alloc(drcontext, sizeof(per_thread_t));
drmgr_set_tls_field(drcontext, tls_index, data);
data->buf_base = dr_thread_alloc(drcontext, MEM_BUF_SIZE);
data->buf_ptr = data->buf_base;
/* set buf_end to be negative of address of buffer end for the lea later */
data->buf_end = -(ptr_int_t)(data->buf_base + MEM_BUF_SIZE);
data->num_refs = 0;
/* We're going to dump our data to a per-thread file.
* On Windows we need an absolute path so we place it in
* the same directory as our library. We could also pass
* in a path as a client argument.
*/
data->log = log_file_open(client_id, drcontext, NULL /* using client lib path */,
"instrace",
#ifndef WINDOWS
DR_FILE_CLOSE_ON_FORK |
#endif
DR_FILE_ALLOW_LARGE);
#ifdef OUTPUT_TEXT
data->logf = log_stream_from_file(data->log);
fprintf(data->logf, "Format: <instr address>,<opcode>\n");
#endif
}
static void
event_thread_init(void *drcontext)
{
per_thread_t *data = dr_thread_alloc(drcontext, sizeof(per_thread_t));
DR_ASSERT(data != NULL);
drmgr_set_tls_field(drcontext, tls_idx, data);
/* Keep seg_base in a per-thread data structure so we can get the TLS
* slot and find where the pointer points to in the buffer.
*/
data->seg_base = dr_get_dr_segment_base(tls_seg);
data->buf_base =
dr_raw_mem_alloc(MEM_BUF_SIZE, DR_MEMPROT_READ | DR_MEMPROT_WRITE, NULL);
DR_ASSERT(data->seg_base != NULL && data->buf_base != NULL);
/* put buf_base to TLS as starting buf_ptr */
BUF_PTR(data->seg_base) = data->buf_base;
data->num_refs = 0;
/* We're going to dump our data to a per-thread file.
* On Windows we need an absolute path so we place it in
* the same directory as our library. We could also pass
* in a path as a client argument.
*/
data->log =
log_file_open(client_id, drcontext, NULL /* using client lib path */, "memtrace",
#ifndef WINDOWS
DR_FILE_CLOSE_ON_FORK |
#endif
DR_FILE_ALLOW_LARGE);
data->logf = log_stream_from_file(data->log);
fprintf(data->logf, "Format: <data address>: <data size>, <(r)ead/(w)rite/opcode>\n");
}
static void
event_exit(void)
{
file_t f;
/* Display the results! */
char msg[512];
int len;
len = dr_snprintf(msg, sizeof(msg)/sizeof(msg[0]),
"Instrumentation results:\n"
" saw %" STAT_FORMAT_CODE " flops\n", stats->num_flops);
DR_ASSERT(len > 0);
msg[sizeof(msg)/sizeof(msg[0])-1] = '\0';
#ifdef SHOW_RESULTS
DISPLAY_STRING(msg);
#endif /* SHOW_RESULTS */
/* On Windows we need an absolute path so we place it in
* the same directory as our library.
*/
f = log_file_open(my_id, NULL, NULL /* client lib path */, "stats", 0);
DR_ASSERT(f != INVALID_FILE);
dr_fprintf(f, "%s\n", msg);
dr_close_file(f);
shared_memory_exit();
drx_exit();
if (!drmgr_unregister_bb_instrumentation_event(event_analyze_bb))
DR_ASSERT(false);
drmgr_exit();
}
static void
event_thread_init(void *drcontext)
{
file_t log;
log = log_file_open(client_id, drcontext, NULL /* using client lib path */,
"cbrtrace",
#ifndef WINDOWS
DR_FILE_CLOSE_ON_FORK |
#endif
DR_FILE_ALLOW_LARGE);
DR_ASSERT(log != INVALID_FILE);
dr_set_tls_field(drcontext, (void *)(ptr_uint_t)log);
}
void log_message(LOG_LEVEL log_evel, int line, const char *funcname, const char *fmt, ...)
{
struct timespec now;
struct tm *p;
char timep[128] = {0};
char errorinfo[128] = {0};
char str[1024] = {0};
char msg[1024] = {0};
va_list vargs;
if(log_evel < log_filter)
{
return ;
}
pthread_mutex_lock(&log_thread_mutex);
va_start(vargs, fmt);
vsnprintf(str, sizeof(str), fmt, vargs);
/*get time string*/
clock_gettime(CLOCK_REALTIME, &now);
p = localtime(&now.tv_sec);
snprintf(timep, sizeof(timep), "%04d-%02d-%02d %02d:%02d:%02d:%03d", (1900 + p->tm_year), (1 + p->tm_mon), p->tm_mday, p->tm_hour, p->tm_min, p->tm_sec, (int)(now.tv_nsec/1000000));
snprintf(msg, sizeof(msg), "%s: %s : %s:%d : %s\n", timep, log_level_string(log_evel), funcname, line, str);
if (NULL == msg)
goto cleanup;
log_file_open();
if (gLogFd > 0)
{
if (safewrite(gLogFd, msg, strlen(msg)) < 0)
{
print_log_to_syslog(msg);
}
close(gLogFd);
}
else
{
print_log_to_syslog(msg);
}
cleanup:
va_end(vargs);
pthread_mutex_unlock(&log_thread_mutex);
}
static int set_log_file_name(const char *val, void *param)
{
if (locked) {
return 0;
}
if (util_string_set(&log_file_name, val) < 0) {
return 0;
}
if (log_file) {
fclose(log_file);
log_file_open();
}
return 0;
}
int log_init(void)
{
#if 0
/*
* The current calling order in main.c (log_init() after processing
* resources) makes this break if anything in the resource set_*
* functions does a log_open(). On platforms that have no regular
* stdout (e.g win32) no logging will be seen. On win32 startup will
* also be preceeded by a modal error requester. / tlr
*/
if (logs != NULL)
return -1;
#endif
log_file_open();
return log_file == NULL ? -1 : 0;
}
DR_EXPORT void
dr_client_main(client_id_t id, int argc, const char *argv[])
{
/* We need no drreg slots ourselves, but we initialize drreg as we call
* drreg_restore_app_values(), required since drx_insert_counter_update()
* uses drreg when drmgr is used.
*/
drreg_options_t ops = {sizeof(ops)};
dr_set_client_name("DynamoRIO Sample Client 'modxfer'",
"http://dynamorio.org/issues");
if (!drmgr_init() || drreg_init(&ops) != DRREG_SUCCESS)
DR_ASSERT(false);
drx_init();
/* register events */
dr_register_exit_event(event_exit);
if (!drmgr_register_bb_instrumentation_event(event_analyze_bb,
event_insert_instrumentation, NULL))
DR_ASSERT(false);
drmgr_register_module_load_event(event_module_load);
drmgr_register_module_unload_event(event_module_unload);
mod_lock = dr_mutex_create();
logfile = log_file_open(id, NULL /* drcontext */,
NULL/* path */, "modxfer",
#ifndef WINDOWS
DR_FILE_CLOSE_ON_FORK |
#endif
DR_FILE_ALLOW_LARGE);
DR_ASSERT(logfile != INVALID_FILE);
/* make it easy to tell, by looking at log file, which client executed */
dr_log(NULL, LOG_ALL, 1, "Client 'modxfer' initializing\n");
#ifdef SHOW_RESULTS
/* also give notification to stderr */
if (dr_is_notify_on()) {
# ifdef WINDOWS
/* ask for best-effort printing to cmd window. must be called at init. */
dr_enable_console_printing();
# endif
dr_fprintf(STDERR, "Client modxfer is running\n");
}
#endif
}
static void
event_thread_init(void *drcontext)
{
file_t f;
/* We're going to dump our data to a per-thread file.
* On Windows we need an absolute path so we place it in
* the same directory as our library. We could also pass
* in a path and retrieve with dr_get_options().
*/
f = log_file_open(my_id, drcontext, NULL /* client lib path */,
"instrcalls",
#ifndef WINDOWS
DR_FILE_CLOSE_ON_FORK |
#endif
DR_FILE_ALLOW_LARGE);
DR_ASSERT(f != INVALID_FILE);
/* store it in the slot provided in the drcontext */
dr_set_tls_field(drcontext, (void *)(ptr_uint_t)f);
}
int DEFAULT_CC
log_start(struct log_config* l_cfg)
{
if (0 == l_cfg)
{
return LOG_ERROR_MALLOC;
}
/* if logfile is NULL, we use a default logfile */
if (0 == l_cfg->log_file)
{
l_cfg->log_file = g_strdup("./myprogram.log");
}
/* if progname is NULL, we use a default name */
if (0 == l_cfg->program_name)
{
l_cfg->program_name = g_strdup("myprogram");
}
/* open file */
l_cfg->fd = log_file_open(l_cfg->log_file);
if (-1 == l_cfg->fd)
{
return LOG_ERROR_FILE_OPEN;
}
/* if syslog is enabled, open it */
if (l_cfg->enable_syslog)
{
openlog(l_cfg->program_name, LOG_CONS | LOG_PID, LOG_DAEMON);
}
#ifdef LOG_ENABLE_THREAD
pthread_mutexattr_init(&(l_cfg->log_lock_attr));
pthread_mutex_init(&(l_cfg->log_lock), &(l_cfg->log_lock_attr));
#endif
return LOG_STARTUP_OK;
}
static void
event_thread_init(void *drcontext)
{
per_thread_t *data = dr_thread_alloc(drcontext, sizeof(per_thread_t));
DR_ASSERT(data != NULL);
data->reg_addr = DR_REG_NULL;
drmgr_set_tls_field(drcontext, tls_idx, data);
/* We're going to dump our data to a per-thread file.
* On Windows we need an absolute path so we place it in
* the same directory as our library. We could also pass
* in a path as a client argument.
*/
data->log =
log_file_open(client_id, drcontext, NULL /* using client lib path */, "memval",
#ifndef WINDOWS
DR_FILE_CLOSE_ON_FORK |
#endif
DR_FILE_ALLOW_LARGE);
data->logf = log_stream_from_file(data->log);
}
main
( int argc,
char **argv
)
{
int lindex, hindex, index_mod;
log_file logf;
log_gobbled logg;
char *values;
int first, pass;
mc_temp_sched *sch;
mc_temp_state *ts;
mc_iter *it;
char **ap;
double ww;
char *v;
int i;
/* Look at arguments other than log files and ranges. */
if (argc<3) usage();
values = argv[1];
/* Set records sizes required. */
logg.req_size['i'] = sizeof (mc_iter);
logg.req_size['o'] = sizeof (mc_ops);
logg.req_size['t'] = sizeof (mc_traj);
logg.req_size['b'] = sizeof (mc_temp_state);
logg.req_size['m'] = sizeof (mc_temp_sched);
/* Go twice through all the log files and ranges specified. Compute
means the first time, variances the second. */
for (pass = 1; pass<=2; pass++)
{
first = 1;
ap = argv+2;
while (*ap)
{
/* Look at arguments giving log file and range. */
logf.file_name = *ap++;
if (*ap!=0 && strchr(":%0123456789",**ap)!=0)
{ parse_range(*ap,&lindex,&hindex,&index_mod);
if (index_mod<0)
{ fprintf(stderr,"Bad range specification: %s\n",*ap);
exit(1);
}
ap += 1;
}
else
{ lindex = 1;
hindex = -1;
index_mod = 1;
}
if (hindex<0) hindex = 1000000000;
/* Open log file and set up for gobbling. */
log_file_open(&logf,0);
log_gobble_init(&logg,!first);
/* Gobble up records with negative indexes. */
while (logf.header.index<0)
{ log_gobble(&logf,&logg);
}
/* Skip to start of range, gobble up records at start. */
while (!logf.at_end
&& (logf.header.index<lindex || logf.header.index%index_mod!=0))
{ log_file_forward(&logf);
}
if (logf.at_end) continue;
log_gobble(&logf,&logg);
/* Go through all the records in the indicated range. */
for (;;)
{
/* See what's here. */
sch = logg.data['m'];
if (sch==0)
{ fprintf(stderr,"No tempering schedule present\n");
exit(1);
}
ts = logg.data['b']!=0 && logg.index['b']==logg.last_index
? logg.data['b'] : 0;
it = logg.data['i']!=0 && logg.index['i']==logg.last_index
? logg.data['i'] : 0;
/* Look at data for this index, if anything is happening. */
if (ts!=0 || it!=0)
{
if (ts==0)
{ fprintf(stderr,"No tempering state present (%s %d)\n",
logf.file_name, logg.last_index);
exit(1);
}
if (it==0)
{ fprintf(stderr,"No record describing iteration present (%s %d)\n",
logf.file_name, logg.last_index);
exit(1);
}
i = mc_temp_index(sch,ts->inv_temp);
/* Look at data for pass 1. */
if (pass==1)
{
if (n_points[i]==0)
{ w_mean[i] = it->log_weight;
logw_mean[i] = it->log_weight;
}
else
{ w_mean[i] = addlogs (w_mean[i], it->log_weight);
logw_mean[i] = logw_mean[i] + it->log_weight;
}
n_points[i] += 1;
}
/* Look at data for pass 2. */
if (pass==2)
{
ww = exp(it->log_weight-w_mean[i]);
ww_var[i] += (ww-1)*(ww-1);
logw_var[i] += (it->log_weight - logw_mean[i])
* (it->log_weight - logw_mean[i]);
}
}
/* Skip to next desired index, or to end of range. */
while (!logf.at_end && logf.header.index<=hindex
&& logf.header.index%index_mod!=0)
{ log_file_forward(&logf);
}
if (logf.at_end || logf.header.index>hindex)
{ break;
}
/* Gobble up records for next index. */
log_gobble(&logf,&logg);
}
log_file_close(&logf);
first = 0;
}
/* Finish up pass 1. */
if (pass==1)
{ for (i = 0; i<Max_temps; i++)
{ if (n_points[i]>0)
{ w_mean[i] -= log((double)n_points[i]);
logw_mean[i] /= n_points[i];
}
if (sch->sched[i].inv_temp==1) break;
}
}
/* Finish up pass 2. */
if (pass==2)
{ for (i = 0; i<Max_temps; i++)
{ if (n_points[i]>1)
{ ww_var[i] /= (n_points[i]-1);
logw_var[i] /= (n_points[i]-1);
}
if (sch->sched[i].inv_temp==1) break;
}
}
}
/* Print values for each temperature. */
for (i = 0; i<Max_temps; i++)
{
if (n_points[i]>0)
{
for (v = values; *v; v++)
{
switch (*v)
{
case 'I':
{ printf(" %4d",i);
break;
}
case 'i':
{ printf(" %.6f",sch->sched[i].inv_temp);
break;
}
case 'T':
{ printf(" %9.4f",1/sch->sched[i].inv_temp);
break;
}
case 'm':
{ printf(" %.6e",
n_points[i]==0 ? 1 : exp(w_mean[i]));
break;
}
case 'M':
{ printf(" %.6e",
n_points[i]==0 ? 0 : w_mean[i]);
break;
}
case 'F':
{ printf(" %.6e",
n_points[i]==0 ? 0 : -w_mean[i]);
break;
}
case 'v':
{ printf(" %8.3f", n_points[i]>1 ? ww_var[i] : 0);
break;
}
case 'V':
{ printf(" %8.3f", n_points[i]>1 ? logw_var[i] : 0);
break;
}
case 'a':
{ printf(" %9.3f", n_points[i]>1 ? n_points[i]/(1+ww_var[i]) : 0);
break;
}
case 'W':
{ printf(" %9.3f", n_points[i]>1 ? log (1+ww_var[i]) : 0);
break;
}
default:
{ fprintf(stderr,"Invalid value specifier: %c\n",*v);
exit(1);
}
}
}
printf("\n");
}
if (sch->sched[i].inv_temp==1) break;
}
exit(0);
}
int main(int argc, char** argv){
printf("hello world\n");
behaviors_init();
log_file_open("log.txt");
if (SDL_Init(SDL_INIT_EVERYTHING) == -1){
printf("%s\n", SDL_GetError());
return 1;
}
printf("sdl init success\n");
SDL_Renderer *renderer = NULL;
SDL_Window *window = NULL;
//Setup our window and renderer
window = SDL_CreateWindow("Stick Fighter", SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED,
SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);
if (window == NULL){
printf("%s\n", SDL_GetError());
return 2;
}
renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
if (renderer == NULL){
printf("%s\n", SDL_GetError());
return 3;
}
SDL_Texture *background1 = NULL;
SDL_Texture *background2 = NULL;
SDL_Texture *image = NULL;
//background = sprite_load_image(renderer, "res/background_rcr.png");
background1 = sprite_load_image(renderer, "res/background_rcr.png");
background2 = sprite_load_image(renderer, "res/background_new.png");
SDL_Texture* backgrounds[2];
backgrounds[0] = background1;
backgrounds[1] = background2;
SDL_Rect bg;
//Query the texture to get its width and height to use
SDL_QueryTexture(background1, NULL, NULL, &bg.w, &bg.h);
float bg_width = bg.w;
float bg_height = bg.h;
float world_width = bg_width / 10;
float world_height = bg_height / 10;
printf("bg_width: %f bg_height: %f world_width: %f world_height: %f\n", bg_width, bg_height, world_width, world_height);
//printf("bg 1: [%p]\n", backgrounds[0]);
//printf("bg 2: [%p]\n", backgrounds[1]);
image = sprite_load_image(renderer, "res/output.png");
//printf("after sprite load image\n");
//load the meta info
char* filename = "res/animation_meta_info.txt";
DArray meta_info;
darray_init(&meta_info);
sprite_load_meta_file(filename, &meta_info);
darray_print(&meta_info);
float interval = 0.0f;
float start = 0.0f;
int quit = 0;
float delay = 1000.0f / FPS;
Sprite* player = sprite_create(PLAYER, WALK, 200, 300, delay, image);
player->x_speed = 0;
player->y_speed = 0;
Sprite* enemy = sprite_create(ENEMY, WALK, 0, 300, delay, image);
enemy->x_speed = 2;
enemy->y_speed = 2;
enemy->advance_frame = 1;
//set white background
SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
pixel_to_world(bg_width, bg_height, world_width, world_height,
enemy->x, enemy->y, &enemy->location->coords->x, &enemy->location->coords->y);
int dest_x = 0;
int dest_y = 0;
//TODO:
//animations for punch and basic kick
//animation for getting hit
//animations for walk left and run left
//2 more ai behaviors
//health bars above units and health stats
//dying animation
//dying logic
//generate enemies off screen and have them walk on to screen
//redo tornado kick and spinning back kick so stick figure is same size
//figure out how to color stick figure without having to make new sprites on sheet...need to make figures white to set modulation
//add rolling punch move
//add game state which keeps track of game state
//add buy moves screen in between levels
//add a generator which generates guys for 100 levels
int i = 0;
while (!quit){
printf("iteration: %i\n", i);
start = SDL_GetTicks();
quit = player_input(player, &meta_info);
//printf("quit: %i\n", quit);
//log_msg(LOG_DEBUG, "after player input: current frame: %i\n", player->current_frame[HIT]);
//pixel location to world location
pixel_to_world(bg_width, bg_height, world_width, world_height,
player->x, player->y, &player->location->coords->x, &player->location->coords->y);
//world location to pixel location
world_to_pixel(bg_width, bg_height, world_width, world_height,
enemy->location->coords->x, enemy->location->coords->y, &dest_x, &dest_y);
//boundry check
boundry_check(SCREEN_WIDTH, SCREEN_HEIGHT, enemy, &meta_info, &dest_x, &dest_y);
//printf("2nd before moveto = enemy x:%i enemy y:%i dest_x:%i dest_y:%i\n", enemy->x, enemy->y, dest_x, dest_y);
//update enemy sprite by sprite's speed
moveto_coordinates(enemy, dest_x, dest_y);
//are we at the original world location in pixel coordinates?
int arrived = within_coordinates(enemy, dest_x, dest_y);
printf("arrived: %i\n", arrived);
if(arrived == 1) {
//wander(enemy);
// we reached last behavior's destination so do new AI behavior
wander_stall_attack(player, enemy, &meta_info, 3);
}
sprite_update_bounding_box(player, &meta_info);
sprite_update_bounding_box(enemy, &meta_info);
//check collision
int collision = sprite_check_collision(player, enemy);
//printf("collision: %i\n", collision);
if(collision) {
sprite_handle_collision(player, enemy, &meta_info);
}
//handle collision
//if animation is an attack then check frame range that triggers a hit
//check if attack animation triggers a hi or low hit
//if sequence of attacks is within delta time then 4th hit triggers a knockdown
//if attack would make health below 0 then it triggers a knockdown
//handle opposite attack from opposing sprite
//if is in attack animation then check frame range for a hit
//update animation frame
sprite_update(player, &meta_info, renderer);
sprite_update(enemy, &meta_info, renderer);
//Rendering
SDL_RenderClear(renderer);
//printf("player->x: %i\n", player->x);
//printf("moving right: %i\n", player->moving_right);
//printf("moving left: %i\n", player->moving_left);
int current_background = 0;
sprite_draw_background(renderer, backgrounds, 2, ¤t_background, player->x, player->moving_right, player->moving_left, &player->scroll);
sprite_draw_health_bar(renderer, player, &meta_info, 100);
sprite_draw_health_bar(renderer, enemy, &meta_info, 100);
//draw sprite
sprite_render_frame(SCREEN_WIDTH, SCREEN_HEIGHT, player, &meta_info, renderer, 0);
sprite_render_frame(bg_width, bg_height, enemy, &meta_info, renderer, 0);
//Update the screen
SDL_RenderPresent(renderer);
interval = SDL_GetTicks() - start;
if(interval > 0) {
//float fps = 1.0f / (interval / 1000.0f);
//printf("%f fps\n", fps);
}
i++;
}
//SDL_Delay(4000);
//Destroy the various items
sprite_destroy(player);
sprite_destroy(enemy);
darray_destroy(&meta_info);
SDL_DestroyTexture(backgrounds[0]);
SDL_DestroyTexture(backgrounds[1]);
SDL_DestroyTexture(image);
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
printf("after destory text rend win\n");
SDL_Quit();
log_file_close();
return 0;
}