Ejemplo n.º 1
0
static void
import_items(ICalImporterData *icidata)
{
	ESource *source;
	g_return_if_fail (icidata != NULL);

	source = e_source_selector_peek_primary_selection ((ESourceSelector *)icidata->selector);
	g_return_if_fail ( source != NULL);

	icidata->client = auth_new_cal_from_source (source, icidata->source_type);
	e_cal_open (icidata->client, FALSE, NULL);

	switch (icidata->source_type) {
	case E_CAL_SOURCE_TYPE_EVENT:
		prepare_events (icidata->icalcomp, NULL);
		if (!update_objects (icidata->client, icidata->icalcomp))
			/* FIXME: e_error ... */;
		break;
	case E_CAL_SOURCE_TYPE_TODO:
		prepare_tasks (icidata->icalcomp, NULL);
		if (!update_objects (icidata->client, icidata->icalcomp))
			/* FIXME: e_error ... */;
		break;
	default:
		g_assert_not_reached ();
	}
	ical_import_done (icidata);
}
Ejemplo n.º 2
0
static gboolean
ivcal_import_items (gpointer d)
{
	ICalImporter *ici = d;

	switch (ici->source_type) {
	case E_CAL_CLIENT_SOURCE_TYPE_EVENTS:
		prepare_events (ici->icalcomp, NULL);
		update_objects (ici->cal_client, ici->icalcomp, ici->cancellable, ivcal_call_import_done, ici);
		break;
	case E_CAL_CLIENT_SOURCE_TYPE_TASKS:
		prepare_tasks (ici->icalcomp, NULL);
		update_objects (ici->cal_client, ici->icalcomp, ici->cancellable, ivcal_call_import_done, ici);
		break;
	default:
		g_warn_if_reached ();

		ici->idle_id = 0;
		ivcal_import_done (ici);
		return FALSE;
	}

	ici->idle_id = 0;

	return FALSE;
}
Ejemplo n.º 3
0
void setfilename(char *fname)
{
	char *t,*text;
	
	text = &windforms[WIND_CTRL].formtree[CTRL_FILENAME].ob_spec.
		tedinfo->te_ptext[6];
	
	strncpy(text, fname, 8);
	text[8] = '\0';
	if((t=strchr(text, '.')) != NULL)
		*t = '\0';

	update_objects(&windforms[WIND_CTRL],CTRL_FNAME_BOX,0,0);
	update_objects(&windforms[WIND_CTRL],CTRL_FILENAME,0,0);
}
Ejemplo n.º 4
0
int event_exitportal(EVENT_DATA *event)
{
  CHAR_DATA *ch = event->owner.ch;
  OBJECT_DATA *obj = event->victim.obj;
  int args[3];

  args[0] = event->args[0]; /* newx */
  args[1] = event->args[1]; /* newy */
  args[2] = event->args[2]; /* newplane */

  destroy_all_events(ch, EVENT_EXITPORTAL);

  ch->x = args[0];
  ch->y = args[1];
  ch->plane = args[2];
  update_objects(ch);
  act("\nYou jump out of $v and look around.\n", ch, obj, TO_ACTOR + TYPE_ACT_CHAR + TYPE_VIC_OBJ, SENSE_SIGHT);
  act("$a jumps out of $v.", ch, obj, TO_NOTACTVIC + TYPE_ACT_CHAR + TYPE_VIC_OBJ, SENSE_SIGHT);
  do_look(ch, "");

  if (ch->level == LEVEL_MORTAL && (args[2] == PLANE_NEXUS || args[2] == PLANE_HNEXUS))
  {
    send_to_char(ch, "#R+#r------------------------------------------------------------------------#R+\n");
    send_to_char(ch, "#r| #RWARNING:#Y This plane is meant for characters of greater power than you. #r|\n");
    send_to_char(ch, "#r| #YWe recommend that you return to the newbie plane by typing #CENTER BLUE#Y. #r|\n");
    send_to_char(ch, "#R+#r------------------------------------------------------------------------#R+\n");
  }
  return 1;
}
Ejemplo n.º 5
0
static void
gc_import_events (ECalClient *cal_client,
                  const GError *error,
                  ICalIntelligentImporter *ici)
{
	g_return_if_fail (ici != NULL);

	if (error != NULL) {
		g_warning (
			"%s: Failed to open events calendar: %s",
			G_STRFUNC, error->message);
		if (ici->tasks)
			open_default_source (
				ici, E_CAL_CLIENT_SOURCE_TYPE_TASKS,
				gc_import_tasks);
		else
			e_import_complete (ici->ei, ici->target);
		return;
	}

	e_import_status (ici->ei, ici->target, _("Importing..."), 0);

	update_objects (
		cal_client, ici->icalcomp, ici->cancellable,
		ici->tasks ? continue_tasks_cb : continue_done_cb, ici);
}
void RemoteServerProxyUpdater::handle_objects(GameInitMessage *message) {
  if (!new_level_) {
    update_objects(message);
  } else {
    create_objects(message);
    new_level_ = false;
  }
}
Ejemplo n.º 7
0
obj_rnum add_object(struct obj_data *newobj, obj_vnum ovnum)
{
  int found = NOTHING;
  zone_rnum rznum = real_zone_by_thing(ovnum);

  /*
   * Write object to internal tables.
   */
  if ((newobj->item_number = real_object(ovnum)) != NOTHING) {
    copy_object(&obj_proto[newobj->item_number], newobj);
    update_objects(&obj_proto[newobj->item_number]);
    add_to_save_list(zone_table[rznum].number, SL_OBJ);
    return newobj->item_number;
  }

  found = insert_object(newobj, ovnum);
  adjust_objects(found);
  add_to_save_list(zone_table[rznum].number, SL_OBJ);
  return (found);
}
Ejemplo n.º 8
0
/*  process_sync_request
    After the RPC thread recieves a sync response from the server
    we update the object information in the maze, the broken
    walls in the maze and the players in the game
   
    parameter: maze         pointer to the client's local copy of the maze
    parameter: ch           handle to a Proto_Client
    parameter: hdr          pointer to hdr that contains unmarshalled data
    return:    int          return code
*/
int process_sync_request(Maze* maze, Proto_Client_Handle ch, Proto_Msg_Hdr* hdr)
{
    // Variable Declaration
    int* broken_walls_compress;
    int* player_compress;
    int* object_compress;
    int offset;

    //Get number of elements for walls and players
    int num_walls = hdr->pstate.v2.raw;
    int num_players = hdr->pstate.v3.raw;

    //Malloc the variables
    broken_walls_compress = (int*) malloc(num_walls*sizeof(int));
    player_compress = (int*) malloc(num_players*sizeof(int));
    object_compress = (int*) malloc(4*sizeof(int));

    //Get the data from the body of the message
    offset = 0;
    offset = get_compress_from_body(ch, offset, num_walls, broken_walls_compress);
    offset = get_compress_from_body(ch, offset, num_players, player_compress);
    offset = get_compress_from_body(ch, offset, 4, object_compress);
    PixelUpdate pu; //null pointer to get the below to work
    update_objects(4,object_compress,maze, &pu);
    update_walls(num_walls,broken_walls_compress,maze, &pu);

    update_players(num_players,player_compress,maze, &pu);


    //De-allocate the malloced variables
    free(broken_walls_compress);
    free(player_compress);
    free(object_compress);

    if(proto_debug())
    {
    }

    return hdr->gstate.v0.raw;    
}
Ejemplo n.º 9
0
void toggle_object(WINDFORM *wind,int obj_id,int mode)
{
	if((mode==SET_NORMAL) || 
		((mode==TOGGLE) && (wind->formtree[obj_id].ob_state & SELECTED)))
	{
		objc_change(wind->formtree,obj_id,0,wind->form.x,
			wind->form.y,wind->form.w,wind->form.h,
			NORMAL,0);
		wind->formtree[wind->formtree[obj_id].ob_head].ob_x--;
		wind->formtree[wind->formtree[obj_id].ob_head].ob_y--;
	}
	else if((mode==SET_SELECTED) || 
		((mode==TOGGLE) && !(wind->formtree[obj_id].ob_state & SELECTED)))
	{
		objc_change(wind->formtree,obj_id,0,wind->form.x,
			wind->form.y,wind->form.w,wind->form.h,
			SELECTED,0);
		wind->formtree[wind->formtree[obj_id].ob_head].ob_x++;
		wind->formtree[wind->formtree[obj_id].ob_head].ob_y++;
	}
	update_objects(wind,obj_id,1,0);
}
Ejemplo n.º 10
0
static void
gc_import_tasks (ECalClient *cal_client,
                 const GError *error,
                 ICalIntelligentImporter *ici)
{
	g_return_if_fail (ici != NULL);

	if (error != NULL) {
		g_warning (
			"%s: Failed to open tasks: %s",
			G_STRFUNC, error->message);
		e_import_complete (ici->ei, ici->target);
		return;
	}

	e_import_status (ici->ei, ici->target, _("Importing..."), 0);

	prepare_tasks (ici->icalcomp, ici->tasks);

	update_objects (
		cal_client, ici->icalcomp,
		ici->cancellable, continue_done_cb, ici);
}
Ejemplo n.º 11
0
int handle_message(int pipe[8])
{
	static int first_open=0;
	int wnr,error; /* ,avmsg[8]; */
	char *vamsg,*o;

#ifdef DEBUG
	char tmp[128];
#endif

	switch (pipe[0]) {
		case AC_OPEN:
			if (pipe[4] == acc_id)
			{
				if(first_open)
				{
					if(windforms[WIND_CTRL].wind_open)
						wind_set(windforms[WIND_CTRL].whandle,WF_TOP);
					else
						fgbg=FG;
				}
				else
				{
					fg_init(&windforms[WIND_CTRL]);
					fgbg=FG;
					first_open=1;
				}
			}
#ifdef DEBUG
				form_alert(1,"[1][Got AC_OPEN][Ok]");
#endif
			break;
		case AC_CLOSE:
/*			if (pipe[4] == acc_id) */

			{
#ifdef DEBUG
				sprintf(tmp,"[1][Got AC_CLOSE|ACC id: %d|pipe4: %d][Ok]",acc_id,pipe[4]);
				form_alert(1,tmp);
#endif

				if(windforms[WIND_CTRL].wind_open)
				{
					wind_close(windforms[WIND_CTRL].whandle);
					wind_delete(windforms[WIND_CTRL].whandle);
					windforms[WIND_CTRL].wind_open=0;
				}
				if(windforms[WIND_INFO].wind_open)
				{
					wind_close(windforms[WIND_INFO].whandle);
					wind_delete(windforms[WIND_INFO].whandle);
					windforms[WIND_INFO].wind_open=0;
				}
#ifdef DEBUG
				sprintf(tmp,"[1][Filepos: %ld][Ok]",filepos);
				form_alert(1,tmp);
#endif
				file_was_open=file_open;
				if(file_open)
					close_file(fd);
				closed_acc=1;
				return 1;
			}
/*			break; */
			
		case AP_TERM:
			quit=1;
			return 1;
/*			switch(pipe[5])
			{
				case AP_RESCHG:
					printf("Got AP_RESCHG!\n");
				break;
				case AP_TERM:
					printf("Got AP_TERM!");
				break;
				default:
					printf("Got unknown AP_TERM!");
			}
*/
/*			break; */
		case RESCHG_COMPLETED:
/*			printf("Got RESCHG_COMPLETED!"); */
			break;
		
		case WM_REDRAW:
			if((wnr=find_windform(pipe[3]))>=0)
				update_objects(&windforms[wnr],windforms[wnr].firstobj,
					windforms[wnr].objdepth,pipe);
			break;
		case WM_MOVED:
			if((wnr=find_windform(pipe[3]))>=0)
			{
				wind_set(windforms[wnr].whandle,WF_CURRXYWH,pipe[4],pipe[5],pipe[6],pipe[7]);
				windforms[wnr].wind.x=pipe[4];
				windforms[wnr].wind.y=pipe[5];
				windforms[wnr].wind.w=pipe[6];
				windforms[wnr].wind.h=pipe[7];
				wind_calc(WC_WORK,windforms[wnr].windkind,
					windforms[wnr].wind.x,windforms[wnr].wind.y,
					windforms[wnr].wind.w,windforms[wnr].wind.h,
					&windforms[wnr].form.x,&windforms[wnr].form.y,
					&windforms[wnr].form.w,&windforms[wnr].form.h);
				windforms[wnr].formtree[windforms[wnr].firstobj].ob_x=windforms[wnr].form.x;
				windforms[wnr].formtree[windforms[wnr].firstobj].ob_y=windforms[wnr].form.y;
				windforms[wnr].formtree[windforms[wnr].firstobj].ob_width=windforms[wnr].form.w;
				windforms[wnr].formtree[windforms[wnr].firstobj].ob_height=windforms[wnr].form.h;
				if(replay)
					update_time();
			}
			break;
		case WM_CLOSED:
			if((wnr=find_windform(pipe[3]))>=0)
			{
				wind_close(windforms[wnr].whandle);
				windforms[wnr].wind_open=0;
				if(wnr==WIND_CTRL)
				{
					if(windforms[WIND_INFO].wind_open)
					{
						wind_close(windforms[WIND_INFO].whandle);
						windforms[WIND_INFO].wind_open=0;
					}
					return 1;
				}
				else
					wind_delete(windforms[wnr].whandle);
			}
			break;
		case WM_TOPPED:
			if((wnr=find_windform(pipe[3]))>=0)
				wind_set(pipe[3],WF_TOP);
			break;
		case AP_DRAGDROP:
			if(wind_find(pipe[4],pipe[5]) == windforms[WIND_CTRL].whandle)
			{
				if(do_dragdrop(pipe,DD_OK))
				{
					exit_replay();

					if(windforms[WIND_CTRL].formtree[CTRL_FF].ob_state & SELECTED)
						toggle_object(&windforms[WIND_CTRL],CTRL_FF,SET_NORMAL);
					Dsp_Hf1(0);				
					if(windforms[WIND_CTRL].formtree[CTRL_PAUSE].ob_state & SELECTED)
						toggle_object(&windforms[WIND_CTRL],CTRL_PAUSE,SET_NORMAL);
					replay_pause=0;

					filepos=0;
					fd=reopen_file();
					filesize=Fseek(0L,fd,2);
					Fseek(0L,fd,0);
					if((error=getmp2info(fd))==MP2_NOERR)
					{
						update_time();
						setfilename(filename);
						if(!(pipe[6] & K_ALT))
							init_replay();
					}
					else
					{
						exit_replay();
						show_mp2_error(error);
						close_file(fd);
						strcpy(windforms[WIND_CTRL].wind_title,"MPEG");
						wind_set(windforms[WIND_CTRL].whandle,WF_NAME,
							windforms[WIND_CTRL].wind_title);
						setfilename("MPEGFILE");
					}
				}
			}
			else
			{
				do_dragdrop(pipe,DD_NAK);
			}
			break;

		case VA_START:
			vamsg=*((char **)&pipe[3]);
			strcpy(path,vamsg);

/* This *should* be sent to the application
	which sent the VA_START msg, but it seems
	to hang Thing doing it. */
/*
			avmsg[0]=AV_STARTED;
			avmsg[1]=app_id;
			avmsg[2]=0;
			avmsg[3]=pipe[3];
			avmsg[4]=pipe[4];
			appl_write(pipe[1],5*2,avmsg);
*/
			if((o=strchr(path,' '))!=NULL)
				o[0]='\0';
			o=strrchr(path,'\\');
			strcpy(filename,&o[1]);
			o=strrchr(path,'\\');
			strncpy(o,"\\*.MP?",6);
			o[6] = '\0';


			exit_replay();

			if(windforms[WIND_CTRL].formtree[CTRL_FF].ob_state & SELECTED)
				toggle_object(&windforms[WIND_CTRL],CTRL_FF,SET_NORMAL);
			Dsp_Hf1(0);				
			if(windforms[WIND_CTRL].formtree[CTRL_PAUSE].ob_state & SELECTED)
				toggle_object(&windforms[WIND_CTRL],CTRL_PAUSE,SET_NORMAL);
			replay_pause=0;

			filepos=0;
			fd=reopen_file();
			filesize=Fseek(0L,fd,2);
			Fseek(0L,fd,0);
			if((error=getmp2info(fd))==MP2_NOERR)
			{
				update_time();
				setfilename(filename);
				init_replay();
			}
			else
			{
				exit_replay();
				show_mp2_error(error);
				close_file(fd);
				strcpy(windforms[WIND_CTRL].wind_title,"MPEG");
				wind_set(windforms[WIND_CTRL].whandle,WF_NAME,
					windforms[WIND_CTRL].wind_title);
				setfilename("MPEGFILE");
			}
			
			break;
		default:
#ifdef DEBUG
			sprintf(tmp,"[1][Unimplemented| message: %d][Ok]",pipe[0]);
			form_alert(1,tmp);
#endif
			break;
	}
	return 0;
}
Ejemplo n.º 12
0
int ev2_loop(WINDFORM *wind,int mx,int my)
{
	int x,y,kstate,key,clicks,event,state,org_state;
	int obj_id,ev2exit,fgexit=0;
	int pipe[8];
	CORDS t;

	if((obj_id=objc_find(wind->formtree,CTRL_FIRST,1,mx,my))>=0)
	{
		if(wind->formtree[obj_id].ob_flags & SELECTABLE)
		{
			org_state=wind->formtree[obj_id].ob_state & SELECTED;
			toggle_object(wind,obj_id,TOGGLE);

			objc_offset(wind->formtree,obj_id,&t.x,&t.y);
			t.w=wind->formtree[obj_id].ob_width;
			t.h=wind->formtree[obj_id].ob_height;
			ev2exit=0;
			do {
				event = evnt_multi( MU_MESAG | MU_TIMER | MU_BUTTON | MU_M1 | MU_M2,
									1, 0x1, 0x0,
									0, t.x, t.y, t.w, t.h,
									1, t.x, t.y, t.w, t.h,
									pipe,
									time_slice, 0,
									&x, &y, &state, &kstate, &key, &clicks );

				if (event & MU_TIMER)
					if (replay)
					{
						if(first_init)
							checkhang();
						load(1);
						update_time();
					}
			
				if (event & MU_MESAG)
					fgexit=handle_message(pipe);

				if (event & MU_M1) /* Enter area */
				{
					if(org_state==(wind->formtree[obj_id].ob_state & SELECTED))
						toggle_object(wind,obj_id,TOGGLE);
				}
				if (event & MU_M2) /* Leave area */
				{
					if(org_state!=(wind->formtree[obj_id].ob_state & SELECTED))
						toggle_object(wind,obj_id,TOGGLE);
				}
			
				if (event & MU_BUTTON)
				{
					if(obj_id==objc_find(wind->formtree,CTRL_FIRST,1,x,y))
					{
						if(wind->formtree[obj_id].ob_flags & KEEPSELECT)
						{
							if(org_state && (wind->formtree[obj_id].ob_state & SELECTED))
								toggle_object(wind,obj_id,SET_NORMAL);
							if(!org_state && !(wind->formtree[obj_id].ob_state & SELECTED))
								toggle_object(wind,obj_id,SET_SELECTED);
						}
						else if(wind->formtree[obj_id].ob_state & SELECTED)
							toggle_object(wind,obj_id,SET_NORMAL);

						fgexit=do_formstuff(obj_id);
					}
					else
					{
						objc_change(wind->formtree,obj_id,0,wind->form.x,
							wind->form.y,wind->form.w,wind->form.h,org_state,0);
						update_objects(wind,obj_id,1,0);
					}
					ev2exit=1;
				}

		
			} while (((replay || fgbg==FG) && !fgexit) && !ev2exit);
			event=0;
			return 1;
		}
	}
	return 0;
}		
Ejemplo n.º 13
0
void test_update_objects_from_compress(TestContext* tc)
{
   int assertion;
   int red_flag_compress,blue_flag_compress,red_shovel_compress,blue_shovel_compress;
   PixelUpdate pu;
   //Create maze
   Maze maze;
   maze_build_from_file(&maze,"test.map");

   //Initialize a dummy object
   Object* red_flag = object_get(&maze,OBJECT_FLAG,TEAM_RED);
   Object* blue_flag = object_get(&maze,OBJECT_FLAG,TEAM_BLUE);
   Object* red_shovel = object_get(&maze,OBJECT_SHOVEL,TEAM_RED);
   Object* blue_shovel = object_get(&maze,OBJECT_SHOVEL,TEAM_BLUE);
  
   //Position of each object somewhere on the map
   red_flag->cell = &maze.get[50][27];
   blue_flag->cell = &maze.get[99][20];
   red_shovel->cell = &maze.get[34][53];
   blue_shovel->cell = &maze.get[79][22];
  
   //Compress Object 
   compress_object(red_flag,&red_flag_compress);
   compress_object(blue_flag,&blue_flag_compress);
   compress_object(red_shovel,&red_shovel_compress);
   compress_object(blue_shovel,&blue_shovel_compress);

   //Update Maze based on compressed object
   update_objects(1,&red_flag_compress,&maze,&pu);
   update_objects(1,&blue_flag_compress,&maze,&pu);
   update_objects(1,&red_shovel_compress,&maze,&pu);
   update_objects(1,&blue_shovel_compress,&maze,&pu);
   
   //Check if pointer to object from object list points to same object from the cell it occupies
   assertion = (object_get(&maze,OBJECT_FLAG,TEAM_RED)->client_position.x == 50) &&
               (object_get(&maze,OBJECT_FLAG,TEAM_RED)->client_position.y == 27);
   should("correctly update (50,27): RED FLAG",assertion,tc);
   assertion = (object_get(&maze,OBJECT_FLAG,TEAM_BLUE)->client_position.x == 99) &&
               (object_get(&maze,OBJECT_FLAG,TEAM_BLUE)->client_position.y == 20);
   should("correctly update (99,20): BLUE FLAG",assertion,tc);
   assertion = (object_get(&maze,OBJECT_SHOVEL,TEAM_RED)->client_position.x == 34) &&
               (object_get(&maze,OBJECT_SHOVEL,TEAM_RED)->client_position.y == 53);
   should("correctly update (34,53): RED SHOVEL",assertion,tc);
   assertion = (object_get(&maze,OBJECT_SHOVEL,TEAM_BLUE)->client_position.x == 79) &&
               (object_get(&maze,OBJECT_SHOVEL,TEAM_BLUE)->client_position.y == 22);
   should("correctly update (79,22): BLUE SHOVEL",assertion,tc);

   //Position of each object somewhere on the map
   red_flag->cell = &maze.get[11][22];
   blue_flag->cell = &maze.get[52][61];
   red_shovel->cell = &maze.get[20][16];
   blue_shovel->cell = &maze.get[12][28];
  
   //Compress Object 
   compress_object(red_flag,&red_flag_compress);
   compress_object(blue_flag,&blue_flag_compress);
   compress_object(red_shovel,&red_shovel_compress);
   compress_object(blue_shovel,&blue_shovel_compress);

   //Update Maze based on compressed object
   update_objects(1,&red_flag_compress,&maze,&pu);
   update_objects(1,&blue_flag_compress,&maze,&pu);
   update_objects(1,&red_shovel_compress,&maze,&pu);
   update_objects(1,&blue_shovel_compress,&maze,&pu);
   
   //Check if pointer to object from object list points to same object from the cell it occupies
   assertion = (object_get(&maze,OBJECT_FLAG,TEAM_RED)->client_position.x == 11) &&
               (object_get(&maze,OBJECT_FLAG,TEAM_RED)->client_position.y == 22);
   should("correctly update (11,22): RED FLAG",assertion,tc);
   assertion = (object_get(&maze,OBJECT_FLAG,TEAM_BLUE)->client_position.x == 52) &&
               (object_get(&maze,OBJECT_FLAG,TEAM_BLUE)->client_position.y == 61);
   should("correctly update (52,61): BLUE FLAG",assertion,tc);
   assertion = (object_get(&maze,OBJECT_SHOVEL,TEAM_RED)->client_position.x == 20) &&
               (object_get(&maze,OBJECT_SHOVEL,TEAM_RED)->client_position.y == 16);
   should("correctly update (20,16): RED SHOVEL",assertion,tc);
   assertion = (object_get(&maze,OBJECT_SHOVEL,TEAM_BLUE)->client_position.x == 12) &&
               (object_get(&maze,OBJECT_SHOVEL,TEAM_BLUE)->client_position.y == 28);
   should("correctly update (12,28): BLUE SHOVEL",assertion,tc);
}
Ejemplo n.º 14
0
int main ( int argc, char** argv )
{
	std::cout << "Starting\n";
    initalize();

    //TODO add resource load error handling
    add_surface("spaceb", load_surface("gray_space.png",1)   );
    add_surface("spacem", load_surface("gray_space.png",1)   );
    add_surface("spacef", load_surface("gray_space.png",1)   );

    for(int i=-2; i < 20+2; i++)
        meta::objects.push_back(new psrect_static(200*i, 200, 200, 200));
//meta::objects.push_back(new psrect_static(320, 20, 320, 20));

//meta::objects.push_back(new psrect_static(0, -400,1, 1000));
//meta::objects.push_back(new psrect_static(1000, -400, 1, 1000));

    meta::objects.push_back(new rocket(2000,-100, 50,70));

    //load_map("test.json");

    float32 timeStep = 1.0f / 30.0f;
    int32 velocityIterations = 6;
    int32 positionIterations = 2;

    FPSmanager manager;
    SDL_initFramerate(&manager);
    SDL_setFramerate(&manager, 30);

    // program main loop
    bool done = false;
    while (!done)
    {
        SDL_framerateDelay(&manager);

        // message processing loop
        SDL_Event event;
        while (SDL_PollEvent(&event))
        {
            // check for messages
            switch (event.type)
            {
                // exit if the window is closed
            case SDL_QUIT:
                done = true;
                break;

                // check for keypresses
            case SDL_KEYDOWN:
                // exit if ESCAPE is pressed
                if (event.key.keysym.sym == SDLK_ESCAPE)
                    done = true;
                break;


            } // end switch
        } // end of message processing

        // DRAWING STARTS HERE
        // clear screen
        //SDL_FillRect(meta::screen, 0, SDL_MapRGB(meta::screen->format, 0, 0, 0 ));
        SDL_FillRect(meta::screen, 0, SDL_MapRGB(meta::screen->format, meta::background_red , meta::background_green, meta::background_blue ));

        draw_background();

        // Instruct the world to perform a single step of simulation.
        // It is generally best to keep the time step and iterations fixed.
        meta::world.Step(timeStep, velocityIterations, positionIterations);

        update_objects();
        meta::world.DrawDebugData();

        // DRAWING ENDS HERE

        // finally, update the screen :)
        SDL_Flip(meta::screen);
    } // end main loop

    // all is well ;)
    printf("Exited cleanly\n");
    return 0;
}