// A helper method to set settings from command line
void settings_store_setting(int parameter, double value) {
switch(parameter) {
case 0: case 1: case 2: // X, Y, Z
if (value <= 0.0) {
printPgmString(PSTR("Steps/mm must be > 0.0\r\n"));
return;
}
settings.steps_per_mm[parameter] = value;
break;
case 3 : // axe T : linear -> U or V or W, rotary -> A or B or C
if (value <= 0.0) {
#if AXIS_T_TYPE == LINEAR
printPgmString(PSTR("Steps/mm must be > 0.0\r\n"));
#else
printPgmString(PSTR("Steps/degree must be > 0.0\r\n"));
#endif
return;
}
#if AXIS_T_TYPE == LINEAR
settings.steps_per_mm[parameter] = value;
#else
settings.steps_per_degree[parameter] = value;
#endif
break;
case 4:
if (value < 3) {
printPgmString(PSTR("Step pulse must be >= 3 microseconds\r\n"));
return;
}
settings.pulse_microseconds = round(value);
break;
case 5:
settings.default_feed_rate = value;
break;
case 6:
settings.default_seek_rate = value;
break;
case 7:
settings.mm_per_arc_segment = value;
break;
case 8:
settings.invert_mask_stepdir = trunc(value);
break;
case 9:
settings.invert_mask_limit = trunc(value);
break;
case 10:
settings.acceleration = value*60*60;
break; // Convert to mm/min^2 for grbl internal use.
case 11:
settings.junction_deviation = fabs(value);
break;
case 12:
settings.spindle_pwm = value;
break;
case 13:
settings.default_spindle = value;
break;
case 14:
settings.max_spindle = value;
break;
case 1000:
value ? st_enable(): st_disable();
if (!value) {
coolant_stop();
spindle_stop();
}
return;
break;
default:
printPgmString(PSTR("Unknown parameter\r\n"));
return;
}
write_settings();
printPgmString(PSTR("Stored new setting\r\n"));
}
PngyuMainWindow::~PngyuMainWindow()
{
write_settings();
delete ui;
}
//------------------------------------------------------------------------------
// Name: ~Configuration
// Desc: destructor
//------------------------------------------------------------------------------
Configuration::~Configuration() {
write_settings();
}
int updatebin(int idx, char *par, int secs)
{
if (!par || !par[0]) {
logidx(idx, "Not enough parameters.");
return 1;
}
size_t path_siz = strlen(binname) + strlen(par) + 2;
char *path = (char *) my_calloc(1, path_siz);
char *newbin = NULL, buf[DIRMAX] = "";
const char* argv[5];
int i;
strlcpy(path, binname, path_siz);
newbin = strrchr(path, '/');
if (!newbin) {
free(path);
logidx(idx, STR("Don't know current binary name"));
return 1;
}
newbin++;
if (strchr(par, '/')) {
*newbin = 0;
logidx(idx, STR("New binary must be in %s and name must be specified without path information"), path);
free(path);
return 1;
}
strcpy(newbin, par);
if (!strcmp(path, binname)) {
free(path);
logidx(idx, STR("Can't update with the current binary"));
return 1;
}
if (!can_stat(path)) {
logidx(idx, STR("%s can't be accessed"), path);
free(path);
return 1;
}
if (fixmod(path)) {
logidx(idx, STR("Can't set mode 0600 on %s"), path);
free(path);
return 1;
}
/* Check if the new binary is compatible */
int initialized_code = check_bin_initialized(path);
if (initialized_code == 2) {
logidx(idx, STR("New binary is corrupted or the wrong architecture/operating system."));
free(path);
return 1;
} else if (initialized_code == 1 && !check_bin_compat(path)) {
logidx(idx, STR("New binary must be initialized as pack structure has been changed in new version."));
free(path);
return 1;
}
/* make a backup just in case. */
simple_snprintf(buf, sizeof(buf), STR("%s/.bin.old"), conf.datadir);
copyfile(binname, buf);
write_settings(path, -1, 0, initialized_code ? 0 : 1); /* re-write the binary with our packdata */
Tempfile *conffile = new Tempfile("conf");
if (writeconf(NULL, conffile->fd, CONF_ENC)) {
logidx(idx, STR("Failed to write temporary config file for update."));
delete conffile;
return 1;
}
/* The binary should return '2' when ran with -2, if not it's probably corrupt. */
putlog(LOG_DEBUG, "*", STR("Running for update binary test: %s -2"), path);
argv[0] = path;
argv[1] = "-2";
argv[2] = 0;
i = simple_exec(argv);
if (i == -1 || WEXITSTATUS(i) != 2) {
logidx(idx, STR("Couldn't restart new binary (error %d)"), i);
delete conffile;
return i;
}
/* now to send our config to the new binary */
putlog(LOG_DEBUG, "*", STR("Running for update conf: %s -4 %s"), path, conffile->file);
argv[0] = path;
argv[1] = "-4";
argv[2] = conffile->file;
argv[3] = 0;
i = simple_exec(argv);
delete conffile;
if (i == -1 || WEXITSTATUS(i) != 6) { /* 6 for successfull config read/write */
logidx(idx, STR("Couldn't pass config to new binary (error %d)"), i);
return i;
}
if (movefile(path, binname)) {
logidx(idx, STR("Can't rename %s to %s"), path, binname);
free(path);
return 1;
}
if (updating == UPDATE_EXIT) { /* dont restart/kill/spawn bots, just die ! */
printf(STR("* Moved binary to: %s\n"), binname);
fatal(STR("Binary updated."), 0);
}
if (updating == UPDATE_AUTO) {
/* Make all other bots do a soft restart */
conf_checkpids(conf.bots);
conf_killbot(conf.bots, NULL, NULL, SIGHUP);
if (conf.bot->pid)
kill(conf.bot->pid, SIGHUP);
exit(0);
}
if (!conf.bot->hub && secs > 0) {
/* Make all other bots do a soft restart */
conf_checkpids(conf.bots);
conf_killbot(conf.bots, NULL, NULL, SIGHUP);
/* invoked with -u */
if (updating == UPDATE_AUTO) {
if (conf.bot->pid)
kill(conf.bot->pid, SIGHUP);
exit(0);
}
/* this odd statement makes it so specifying 1 sec will restart other bots running
* and then just restart with no delay */
updating = UPDATE_AUTO;
if (secs > 1) {
egg_timeval_t howlong;
howlong.sec = secs;
howlong.usec = 0;
timer_create_complex(&howlong, STR("restarting for update"), (Function) restart, (void *) (long) idx, 0);
} else
restart(idx);
return 0;
} else
restart(idx); /* no timer */
/* this should never be reached */
return 2;
}
gint
yad_print_run (void)
{
GtkWidget *dlg;
GtkWidget *box, *img, *lbl;
gchar *uri, *job_name = NULL;
GtkPrintCapabilities pcap;
GtkPrintOperationAction act = GTK_PRINT_OPERATION_ACTION_PRINT;
gint resp, ret = 0;
GError *err = NULL;
/* check if file is exists */
if (options.common_data.uri && options.common_data.uri[0])
{
if (!g_file_test (options.common_data.uri, G_FILE_TEST_EXISTS))
{
g_printerr (_("File %s not found.\n"), options.common_data.uri);
return 1;
}
}
else
{
g_printerr (_("Filename is not specified.\n"));
return 1;
}
/* create print dialog */
dlg = gtk_print_unix_dialog_new (options.data.dialog_title, NULL);
gtk_window_set_type_hint (GTK_WINDOW (dlg), GDK_WINDOW_TYPE_HINT_NORMAL);
gtk_print_unix_dialog_set_embed_page_setup (GTK_PRINT_UNIX_DIALOG (dlg), TRUE);
pcap = GTK_PRINT_CAPABILITY_PAGE_SET | GTK_PRINT_CAPABILITY_COPIES |
GTK_PRINT_CAPABILITY_COLLATE | GTK_PRINT_CAPABILITY_REVERSE |
GTK_PRINT_CAPABILITY_NUMBER_UP | GTK_PRINT_CAPABILITY_NUMBER_UP_LAYOUT;
if (options.common_data.preview && options.print_data.type != YAD_PRINT_RAW)
pcap |= GTK_PRINT_CAPABILITY_PREVIEW;
gtk_print_unix_dialog_set_manual_capabilities (GTK_PRINT_UNIX_DIALOG (dlg), pcap);
if (!settings.print_settings)
settings.print_settings = gtk_print_unix_dialog_get_settings (GTK_PRINT_UNIX_DIALOG (dlg));
uri = g_build_filename (g_get_current_dir (), "yad.pdf", NULL);
gtk_print_settings_set (settings.print_settings, "output-uri", g_filename_to_uri (uri, NULL, NULL));
g_free (uri);
gtk_print_unix_dialog_set_settings (GTK_PRINT_UNIX_DIALOG (dlg), settings.print_settings);
if (settings.page_setup)
gtk_print_unix_dialog_set_page_setup (GTK_PRINT_UNIX_DIALOG (dlg), settings.page_setup);
/* set window behavior */
gtk_widget_set_name (dlg, "yad-dialog-window");
if (options.data.sticky)
gtk_window_stick (GTK_WINDOW (dlg));
gtk_window_set_resizable (GTK_WINDOW (dlg), !options.data.fixed);
gtk_window_set_keep_above (GTK_WINDOW (dlg), options.data.ontop);
gtk_window_set_decorated (GTK_WINDOW (dlg), !options.data.undecorated);
gtk_window_set_skip_taskbar_hint (GTK_WINDOW (dlg), options.data.skip_taskbar);
gtk_window_set_skip_pager_hint (GTK_WINDOW (dlg), options.data.skip_taskbar);
/* set window size and position */
if (!options.data.geometry)
{
gtk_window_set_default_size (GTK_WINDOW (dlg), options.data.width, options.data.height);
if (options.data.center)
gtk_window_set_position (GTK_WINDOW (dlg), GTK_WIN_POS_CENTER);
else if (options.data.mouse)
gtk_window_set_position (GTK_WINDOW (dlg), GTK_WIN_POS_MOUSE);
}
else
{
/* parse geometry, if given. must be after showing widget */
gtk_widget_realize (dlg);
gtk_window_parse_geometry (GTK_WINDOW (dlg), options.data.geometry);
}
/* create yad's top box */
if (options.data.dialog_text || options.data.dialog_image)
{
#if !GTK_CHECK_VERSION(3,0,0)
box = gtk_hbox_new (FALSE, 0);
#else
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
#endif
if (options.data.dialog_image)
{
GdkPixbuf *pb = NULL;
pb = get_pixbuf (options.data.dialog_image, YAD_BIG_ICON);
img = gtk_image_new_from_pixbuf (pb);
if (pb)
g_object_unref (pb);
gtk_widget_set_name (img, "yad-dialog-image");
gtk_box_pack_start (GTK_BOX (box), img, FALSE, FALSE, 2);
}
if (options.data.dialog_text)
{
gchar *buf = g_strcompress (options.data.dialog_text);
lbl = gtk_label_new (NULL);
if (!options.data.no_markup)
gtk_label_set_markup (GTK_LABEL (lbl), buf);
else
gtk_label_set_text (GTK_LABEL (lbl), buf);
gtk_widget_set_name (lbl, "yad-dialog-label");
gtk_label_set_selectable (GTK_LABEL (lbl), options.data.selectable_labels);
gtk_misc_set_alignment (GTK_MISC (lbl), options.data.text_align, 0.5);
if (options.data.geometry || options.data.width != -1)
gtk_label_set_line_wrap (GTK_LABEL (lbl), TRUE);
gtk_box_pack_start (GTK_BOX (box), lbl, TRUE, TRUE, 2);
g_signal_connect (G_OBJECT (lbl), "size-allocate", G_CALLBACK (size_allocate_cb), NULL);
g_free (buf);
}
/* add tob box to dialog */
gtk_widget_show_all (box);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))), box, TRUE, TRUE, 5);
gtk_box_reorder_child (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))), box, 0);
}
do
{
resp = gtk_dialog_run (GTK_DIALOG (dlg));
switch (resp)
{
case GTK_RESPONSE_APPLY: /* ask for preview */
act = GTK_PRINT_OPERATION_ACTION_PREVIEW;
case GTK_RESPONSE_OK: /* run print */
settings.print_settings = gtk_print_unix_dialog_get_settings (GTK_PRINT_UNIX_DIALOG (dlg));
settings.page_setup = gtk_print_unix_dialog_get_page_setup (GTK_PRINT_UNIX_DIALOG (dlg));
job_name = g_strdup_printf ("yad-%s-%d", g_path_get_basename (options.common_data.uri), getpid ());
if (options.print_data.type != YAD_PRINT_RAW)
{
/* print text or image */
GtkPrintOperation *op = gtk_print_operation_new ();
gtk_print_operation_set_unit (op, GTK_UNIT_POINTS);
gtk_print_operation_set_print_settings (op, settings.print_settings);
gtk_print_operation_set_default_page_setup (op, settings.page_setup);
gtk_print_operation_set_job_name (op, job_name);
switch (options.print_data.type)
{
case YAD_PRINT_TEXT:
g_signal_connect (G_OBJECT (op), "begin-print", G_CALLBACK (begin_print_text), NULL);
g_signal_connect (G_OBJECT (op), "draw-page", G_CALLBACK (draw_page_text), NULL);
break;
case YAD_PRINT_IMAGE:
gtk_print_operation_set_n_pages (op, 1);
g_signal_connect (G_OBJECT (op), "draw-page", G_CALLBACK (draw_page_image), NULL);
break;
default:;
}
if (gtk_print_operation_run (op, act, NULL, &err) == GTK_PRINT_OPERATION_RESULT_ERROR)
{
g_printerr (_("Printing failed: %s\n"), err->message);
ret = 1;
}
}
else
{
/* print raw ps or pdf data */
GtkPrinter *prnt;
GtkPrintJob *job;
prnt = gtk_print_unix_dialog_get_selected_printer (GTK_PRINT_UNIX_DIALOG (dlg));
if (g_str_has_suffix (options.common_data.uri, ".ps"))
{
if (!gtk_printer_accepts_ps (prnt))
{
g_printerr (_("Printer doesn't support ps format.\n"));
ret = 1;
}
}
else if (g_str_has_suffix (options.common_data.uri, ".pdf"))
{
if (!gtk_printer_accepts_pdf (prnt))
{
g_printerr (_("Printer doesn't support pdf format.\n"));
ret = 1;
}
}
else
{
g_printerr (_("This file type is not supported for raw printing.\n"));
ret = 1;
}
if (ret == 1)
break;
job = gtk_print_job_new (job_name, prnt, settings.print_settings, settings.page_setup);
if (gtk_print_job_set_source_file (job, options.common_data.uri, &err))
{
gtk_print_job_send (job, (GtkPrintJobCompleteFunc) raw_print_done, &ret, NULL);
gtk_main ();
}
else
{
g_printerr (_("Load source file failed: %s\n"), err->message);
ret = 1;
}
}
break;
default:
ret = 1;
break;
}
}
while (resp == GTK_RESPONSE_APPLY);
gtk_widget_destroy (dlg);
write_settings ();
return ret;
}
void report_designer_desc::finalize() throw(ch_unknown_exc, ch_module_exc)
{
write_settings();
}
void data_integration_desc::finalize() throw(ch_unknown_exc, ch_module_exc)
{
write_settings();
}
void
Main_GUI::closeEvent(QCloseEvent* event)
{
write_settings();
event->accept();
}
/**
* Change the enabled state of a suite.
*
* @param suiteId ID of the suite
* @param enabled true if the suite is be enabled
*
* @return an error code (ALL_OK if no errors)
*/
static MIDPError
change_enabled_state(SuiteIdType suiteId, jboolean enabled) {
char* pszError;
MIDPError status;
jbyte* pPermissions;
int numberOfPermissions;
jbyte pushInterrupt;
jint pushOptions;
jboolean temp;
lockStorageList* node;
MidletSuiteData* pData;
/*
* This is a public API which can be called without the VM running
* so we need automatically init anything needed, to make the
* caller's code less complex.
*
* Initialization is performed in steps so that we do use any
* extra resources such as the VM for the operation being performed.
*/
if (midpInit(LIST_LEVEL) != 0) {
return OUT_OF_MEMORY;
}
status = midp_suite_exists(suiteId);
if ((status != ALL_OK) && (status != SUITE_CORRUPTED_ERROR)) {
return status;
}
node = find_storage_lock(suiteId);
if (node != NULL) {
if (node->update == KNI_TRUE) {
/* Suite is being updated currently. */
return SUITE_LOCKED;
}
}
status = read_settings(&pszError, suiteId, &temp, &pushInterrupt,
&pushOptions, &pPermissions, &numberOfPermissions);
if (status != ALL_OK) {
storageFreeError(pszError);
return status;
}
status = begin_transaction(TRANSACTION_ENABLE_SUITE, suiteId, NULL);
if (status != ALL_OK) {
return status;
}
status = write_settings(&pszError, suiteId, enabled, pushInterrupt,
pushOptions, pPermissions, numberOfPermissions,
NULL);
pcsl_mem_free(pPermissions);
if (status != ALL_OK) {
storageFreeError(pszError);
/* nothing was written, so nothing to rollback, just finish */
(void)finish_transaction();
return status;
}
/* synchronize the settings in the list of MidletSuiteData structures */
pData = get_suite_data(suiteId);
/*
* We can assert that pData is not NULL because midp_suite_exists()
* was called above to ensure that the suite with the given ID exists.
*/
if (pData != NULL) {
int status;
char* pszError;
pData->isEnabled = enabled;
/* IMPL_NOTE: these settings must be cached and saved on AMS exit. */
status = write_suites_data(&pszError);
storageFreeError(pszError);
if (status != ALL_OK) {
(void)rollback_transaction();
return IO_ERROR;
}
}
(void)finish_transaction();
return ALL_OK;
}
// Update loop
void menu::update(){
//Menu animations
if( animation_pos < 100 && !startClicked)
animation_pos += 4;
if( animation_pos > 0 && startClicked)
animation_pos -= 4;
// Start the game
if( startClicked && animation_pos <= 0)
set_next_state( STATE_GAME);
// Open submenu or start game
if( mini_screen == MINISTATE_MENU){
// Start game with controller
if( joystickListener::buttonPressed[JOY_XBOX_START] || joystickListener::buttonPressed[JOY_XBOX_A]){
startClicked = true;
}
// Buttons
if( mouseListener::mouse_pressed & 1){
// Start game
if( collision( mouseListener::mouse_x, mouseListener::mouse_x, 40, 40 + al_get_bitmap_width(start), mouseListener::mouse_y, mouseListener::mouse_y, 410, 410 + al_get_bitmap_height(start))){
startClicked = true;
}
// Scores
else if( collision( mouseListener::mouse_x, mouseListener::mouse_x, 660, 660 + al_get_bitmap_width(highscores_button), mouseListener::mouse_y, mouseListener::mouse_y, 30, 30 + al_get_bitmap_height(highscores_button))){
updateScores( scores);
mini_screen = MINISTATE_SCORES;
}
// Credits menu
else if( collision( mouseListener::mouse_x, mouseListener::mouse_x, 542, 644, mouseListener::mouse_y, mouseListener::mouse_y, 548, 600)){
mini_screen = MINISTATE_CREDITS;
}
// Controls menu
else if( collision( mouseListener::mouse_x, mouseListener::mouse_x, 644, 696, mouseListener::mouse_y, mouseListener::mouse_y, 548 ,600)){
mini_screen = MINISTATE_CONTROLS;
}
// Help screen
else if( collision( mouseListener::mouse_x, mouseListener::mouse_x, 696, 749, mouseListener::mouse_y, mouseListener::mouse_y, 548, 600)){
mini_screen = MINISTATE_TUTORIAL;
}
// Options menu
else if( collision( mouseListener::mouse_x, mouseListener::mouse_x, 749, 800, mouseListener::mouse_y, mouseListener::mouse_y, 548, 600)){
mini_screen = MINISTATE_OPTIONS;
}
}
}
// Exit menus
else if( mini_screen == MINISTATE_TUTORIAL || mini_screen == MINISTATE_CREDITS || mini_screen == MINISTATE_CONTROLS || mini_screen == MINISTATE_SCORES ){
if( keyListener::lastKeyPressed != -1 || mouseListener::mouse_pressed & 1 || joystickListener::lastButtonPressed != -1){
mini_screen = MINISTATE_MENU;
draw();
}
}
// Options
else if( mini_screen == MINISTATE_OPTIONS && mouseListener::mouse_pressed & 1){
// Particles toggle
if( collision( 280, 360, mouseListener::mouse_x, mouseListener::mouse_x, 400, 480, mouseListener::mouse_y, mouseListener::mouse_y)){
settings[SETTING_PARTICLE_TYPE] = (settings[SETTING_PARTICLE_TYPE] + 1) % 4;
}
// Sound button toggle
else if( collision( 120, 200, mouseListener::mouse_x, mouseListener::mouse_x, 180, 260, mouseListener::mouse_y, mouseListener::mouse_y)){
settings[SETTING_SOUND] = (settings[SETTING_SOUND] + 1) % 2;
}
// Music button toggle
else if( collision( 280, 360, mouseListener::mouse_x, mouseListener::mouse_x, 180, 260, mouseListener::mouse_y, mouseListener::mouse_y)){
settings[SETTING_MUSIC] = (settings[SETTING_MUSIC] + 1) % 2;
if( settings[SETTING_MUSIC] == 0)
al_stop_sample( ¤tMusic);
else
al_play_sample( music_mainmenu, 1.0, 0.0, 1.0, ALLEGRO_PLAYMODE_ONCE, ¤tMusic);
}
// Fullscreen toggle
else if( collision( 120, 200, mouseListener::mouse_x, mouseListener::mouse_x, 400, 480, mouseListener::mouse_y, mouseListener::mouse_y)){
settings[SETTING_FULLSCREEN] = (settings[SETTING_FULLSCREEN] + 1) % 2;
if( settings[SETTING_FULLSCREEN]){
// Fullscreen stuff
al_destroy_display( display);
al_set_new_display_flags(ALLEGRO_FULLSCREEN_WINDOW);
display = al_create_display( SCREEN_W, SCREEN_H);
ALLEGRO_DISPLAY_MODE disp_data;
al_get_display_mode(al_get_num_display_modes() - 1, &disp_data);
float sx = disp_data.width / (float)SCREEN_W;
float sy = disp_data.height / (float)SCREEN_H;
ALLEGRO_TRANSFORM trans;
al_identity_transform(&trans);
al_scale_transform(&trans, sx, sy);
al_use_transform(&trans);
al_hide_mouse_cursor( display);
}
else{
al_destroy_display( display);
al_set_new_display_flags(ALLEGRO_WINDOWED);
display = al_create_display( SCREEN_W, SCREEN_H);
al_hide_mouse_cursor( display);
}
}
//Screen shake
else if( collision( 280, 360, mouseListener::mouse_x, mouseListener::mouse_x, 290, 370, mouseListener::mouse_y, mouseListener::mouse_y)){
settings[SETTING_SCREENSHAKE] = (settings[SETTING_SCREENSHAKE] + 1) % 4;
}
// Control Toggle
else if( collision( 120, 200, mouseListener::mouse_x, mouseListener::mouse_x, 290, 370, mouseListener::mouse_y, mouseListener::mouse_y)){
settings[SETTING_CONTROLMODE] = ((settings[SETTING_CONTROLMODE] + 1) % 3);
}
// Power off
else if( collision( 540, 620, mouseListener::mouse_x, mouseListener::mouse_x, 180, 260, mouseListener::mouse_y, mouseListener::mouse_y)){
write_settings();
set_next_state( STATE_EXIT);
}
// Exit menu
else if( collision( 540, 620, mouseListener::mouse_x, mouseListener::mouse_x, 407, 487, mouseListener::mouse_y, mouseListener::mouse_y)){
mini_screen = MINISTATE_MENU;
write_settings();
}
}
// Update mouse particles
if( settings[SETTING_PARTICLE_TYPE] != 3 && mouse_rocket_up){
for( int i = 0; i < 500; i++){
if( random( 1, 10) == 1){
ALLEGRO_COLOR part_color = al_map_rgb( 255, random(0,255), 0);
if( settings[SETTING_CHRISTMAS]){
int red_or_green = random( 0, 1) * 255;
part_color = al_map_rgb( red_or_green, 255 - red_or_green, 0);
}
particle newParticle( mouseListener::mouse_x, mouseListener::mouse_y + 16, part_color, random( -2, 2), random( 8, 20), 1, settings[SETTING_PARTICLE_TYPE]);
mousePart.push_back( newParticle);
}
}
}
for( unsigned int i = 0; i < mousePart.size(); i++){
mousePart.at(i).logic();
if( random( 0, 10) == 0)
mousePart.erase( mousePart.begin() + i);
}
// Close game
if( keyListener::key[ALLEGRO_KEY_ESCAPE])
set_next_state( STATE_EXIT);
// Check if mouse is going up
mouse_rocket_up = ( mouseListener::mouse_y < mouseMove);
mouseMove = mouseListener::mouse_y;
}