static gint panel_size_alloc(GtkWidget *widget, GtkAllocation *a, panel *p) { static gint x, y; ENTER; DBG("gtk: size (%d, %d). pos (%d, %d)\n", a->width, a->height, a->x, a->y); DBG("our: size (%d, %d). pos (%d, %d)\n", p->aw, p->ah, p->ax, p->ay); if (p->widthtype == WIDTH_REQUEST) p->width = (p->orientation == ORIENT_HORIZ) ? a->width : a->height; if (p->heighttype == HEIGHT_REQUEST) p->height = (p->orientation == ORIENT_HORIZ) ? a->height : a->width; calculate_position(p); DBG("our: size (%d, %d). pos (%d, %d)\n", p->aw, p->ah, p->ax, p->ay); if (a->width == p->aw && a->height == p->ah && x == p->ax && y == p ->ay) { DBG("actual coords eq to preffered. just returning\n"); RET(TRUE); } x = p->ax; y = p->ay; gtk_window_move(GTK_WINDOW(p->topgwin), p->ax, p->ay); DBG("moving to %d %d\n", p->ax, p->ay); if (p->setstrut) panel_set_wm_strut(p); RET(TRUE); }
/* * Calculate the initial position. */ static void calculate_initial_position (GtkWidget *ardesia_bar_window, gint *x, gint *y, gint w_width, gint w_height, gint position) { gint d_width = gdk_screen_width (); gint d_height = gdk_screen_height (); /* Resize if larger that screen width. */ if (w_width>d_width) { w_width = d_width; gtk_window_resize (GTK_WINDOW (ardesia_bar_window), w_width, w_height); } /* Resize if larger that screen height. */ if (w_height>d_height) { gint tollerance = 15; w_height = d_height - tollerance; gtk_widget_set_size_request (ardesia_bar_window, w_width, w_height); } calculate_position (ardesia_bar_window, d_width, d_height, x, y, w_width, w_height, position); }
void cylinder_inter(t_inter *inter, void *obj, t_ray ray, t_light *light) { t_cylinder cylinder; double dist; t_ray temp; cylinder = *((t_cylinder *)obj); temp = ray; change_frame(&ray, cylinder.inv, vector_inverse(cylinder.trans)); dist = cylinder_distance(ray, cylinder); if (dist > EPS && (inter->dist == NULL || dist < *(inter->dist) - EPS)) { if (inter->dist == NULL) inter->dist = malloc(sizeof(double)); free_light_ray_list(inter); *(inter->dist) = dist; inter->pos = calculate_position(ray, dist); inter->normal = cylinder_normal(inter->pos, cylinder); if (vector_dot_product(inter->normal, ray.dir) > 0) inter->normal = vector_inverse(inter->normal); op_inv(cylinder.trans, cylinder.rot, &(inter->normal), &(inter->pos)); inter->refl = calculate_reflection(temp, inter->normal); inter->color = cylinder.color; create_light_ray_list(inter, light, inter->pos); inter->refl_val = cylinder.refl; } }
static gboolean panel_monitors_changed(GdkScreen* s, panel* p) { ENTER; p->monitor = gdk_screen_get_primary_monitor(s); calculate_position(p, distance,distancefrom); gdk_window_move_resize(p->topgwin->window, p->ax, p->ay, p->aw, p->ah); if (p->setstrut) panel_set_wm_strut(p); RET(TRUE); }
/*Return 0 if command was applied/succesfull, -1 if it was not a valid commando or not possible to apply*/ int set(enum atc_commands cmd, struct atc_plane *plane) { plane->time = get_time(); if(calculate_position( plane, plane->time ) ) { switch (cmd){ case speed_up : if(plane->speed >= 280) { /*maximum plane speed 1000km/h expressed in 28m/s*/ return -1; } else{ plane->speed += 14; return sto_set(&sto_db, plane, plane->id); } break; case speed_down : if( plane->speed <= 42) { /*minimum plane speed 150km/h expressed in m/s*/ return -1; } else{ plane->speed -= 14; return sto_set(&sto_db, plane, plane->id); } break; case climb : if( plane->elevation == 30) { return -1; } else{ plane->elevation = plane->elevation + 10; return sto_set(&sto_db, plane, plane->id); } break; case descend : if( plane->elevation == -30) { return -1; } else{ plane->elevation = plane->elevation - 10; return sto_set(&sto_db, plane, plane->id); } break; case turn_right : if(plane->heading == 0){ plane->heading =360; } plane->heading = (plane->heading -45); return sto_set(&sto_db, plane, plane->id); break; case turn_left: plane->heading = (plane->heading +45) % 360; return sto_set(&sto_db, plane, plane->id); break; default: return -1; } } return 0; }
static gint panel_size_req(GtkWidget *widget, GtkRequisition *req, panel *p) { ENTER; DBG("IN req=(%d, %d)\n", req->width, req->height); if (p->widthtype == WIDTH_REQUEST) p->width = (p->orientation == ORIENT_HORIZ) ? req->width : req->height; if (p->heighttype == HEIGHT_REQUEST) p->height = (p->orientation == ORIENT_HORIZ) ? req->height : req->width; calculate_position(p, distance,distancefrom); req->width = p->aw; req->height = p->ah; DBG("OUT req=(%d, %d)\n", req->width, req->height); RET( TRUE ); }
static void panel_size_req(GtkWidget *widget, GtkRequisition *req, panel *p) { ENTER; DBG("IN req=(%d, %d)\n", req->width, req->height); if (p->widthtype == WIDTH_REQUEST) p->width = (p->orientation == GTK_ORIENTATION_HORIZONTAL) ? req->width : req->height; if (p->heighttype == HEIGHT_REQUEST) p->height = (p->orientation == GTK_ORIENTATION_HORIZONTAL) ? req->height : req->width; calculate_position(p); req->width = p->aw; req->height = p->ah; DBG("OUT req=(%d, %d)\n", req->width, req->height); RET(); }
/*Returns the amount of planes flying currently, which are loaded into the received plane buffer. Also, updates the storage when it detects that a plane has colided or landed, or -1 if there was an error*/ int get_airplanes(struct atc_plane buffer[]) { time_t current_time = get_time(); struct atc_plane plane; int count = 0; int new_plane_flag = 1; struct sto_cursor query; int error_flag = 0; error_flag = sto_query(&query, &sto_db, NULL, NULL); if(error_flag == -1) { atcd_crashed_count = atcd_landed_count = -1; sto_close(&query); return error_flag; } atcd_crashed_count = 0; atcd_landed_count = 0; new_plane_flag = sto_get(&query, &plane, NULL); while( (new_plane_flag > 0) ){ if(plane.status == flying){ if(calculate_position(&plane, current_time) && count < MAX_PLANES){ memcpy(&buffer[count], &plane, sizeof(struct atc_plane)); count++; } } else if(plane.status == crashed){ atcd_crashed_count += 1; } else if(plane.status == landed){ atcd_landed_count += 1; } new_plane_flag = sto_get(&query, &plane, NULL); } if(new_plane_flag == -1){ atcd_crashed_count = atcd_landed_count = -1; sto_close(&query); return -1; } _planes_count = count; sto_close(&query); return count; }
static GstPadProbeReturn buffer_cb (GstPad * pad, GstPadProbeInfo * info, gpointer user_data) { GstVideoOverlayRectangle *rect; GstVideoOverlayComposition *comp; GstVideoFrame frame; GstVideoMeta *vmeta; GstVideoInfo vinfo; GstCaps *caps; gint x, y; caps = gst_pad_get_current_caps (pad); gst_video_info_from_caps (&vinfo, caps); gst_caps_unref (caps); info->data = gst_buffer_make_writable (info->data); vmeta = gst_buffer_get_video_meta (logo_buf); calculate_position (&x, &y, vmeta->width, vmeta->height, ++count); GST_LOG ("%3d, %3d", x, y); rect = gst_video_overlay_rectangle_new_raw (logo_buf, x, y, vmeta->width, vmeta->height, GST_VIDEO_OVERLAY_FORMAT_FLAG_NONE); comp = gst_video_overlay_composition_new (rect); gst_video_overlay_rectangle_unref (rect); gst_video_frame_map (&frame, &vinfo, info->data, GST_MAP_READWRITE); if (!gst_video_overlay_composition_blend (comp, &frame)) g_warning ("Error blending overlay at position (%d,%d)", x, y); gst_video_frame_unmap (&frame); gst_video_overlay_composition_unref (comp); return GST_PAD_PROBE_OK; }
void main() { int x,y; scanf("%d %d",&x, &y); calculate_position(x,y); }
void panel_start_gui(panel *p) { ENTER; //gtk_rc_parse_string(transparent_rc); p->topgwin = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_container_set_border_width(GTK_CONTAINER(p->topgwin), 0); gtk_window_set_resizable(GTK_WINDOW(p->topgwin), FALSE); gtk_window_set_wmclass(GTK_WINDOW(p->topgwin), "panel", "trayer"); gtk_window_set_title(GTK_WINDOW(p->topgwin), "panel"); gtk_window_set_position(GTK_WINDOW(p->topgwin), GTK_WIN_POS_CENTER); g_signal_connect ( G_OBJECT(p->topgwin) , "delete-event" , G_CALLBACK(panel_delete_event) , p); g_signal_connect ( G_OBJECT(p->topgwin) , "destroy-event", G_CALLBACK(panel_destroy_event), p); g_signal_connect ( G_OBJECT (p->topgwin), "size-request" , G_CALLBACK(panel_size_req) , p); g_signal_connect ( G_OBJECT (p->topgwin), "size-allocate", G_CALLBACK(panel_size_alloc), p); if (p->transparent) { g_signal_connect (G_OBJECT (p->topgwin), "configure-event", G_CALLBACK(panel_configure_event), p); g_signal_connect (G_OBJECT (p->topgwin), "style-set", G_CALLBACK( panel_style_set), p); } if (p->on_primary) { GdkDisplay *display = gdk_display_get_default (); GdkScreen *screen = gdk_display_get_screen(display, 0); g_signal_connect ( screen, "monitors-changed", G_CALLBACK(panel_monitors_changed), (gpointer)p ); p->monitor = gdk_screen_get_primary_monitor(screen); } gtk_widget_realize(p->topgwin); gdk_window_set_decorations(p->topgwin->window, 0); gtk_widget_set_app_paintable(p->topgwin, TRUE); p->lbox = p->my_box_new(FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(p->lbox), 0); gtk_container_add(GTK_CONTAINER(p->topgwin), p->lbox); gtk_widget_show(p->lbox); if (p->allign == ALLIGN_RIGHT) { GtkWidget * expander = p->my_box_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(p->lbox), expander, TRUE, TRUE, 0); gtk_widget_show(expander); } p->box = p->my_box_new(FALSE, 1); gtk_container_set_border_width(GTK_CONTAINER(p->box), 1); gtk_box_pack_start(GTK_BOX(p->lbox), p->box, FALSE, TRUE, padding); gtk_widget_show(p->box); // get properties on topgwin p->topGdkWindow = gtk_widget_get_window(p->topgwin); p->topxwin = GDK_WINDOW_XWINDOW(GTK_WIDGET(p->topgwin)->window); bg_init(gdk_helper_display()); /* make our window unfocusable */ gdk_window_set_accept_focus(p->topGdkWindow,False); if (p->setdocktype) { gdk_window_set_type_hint(p->topGdkWindow,GDK_WINDOW_TYPE_HINT_DOCK); } Xclimsg(p->topxwin, a_NET_WM_DESKTOP, 0xFFFFFFFF, 0, 0, 0, 0); /************************/ /* Window Mapping Point */ gtk_widget_show_all(p->topgwin); Xclimsg(p->topxwin, a_NET_WM_DESKTOP, 0xFFFFFFFF, 0, 0, 0, 0); gdk_window_stick ( p->topGdkWindow); gdk_window_set_skip_pager_hint ( p->topGdkWindow, True ); gdk_window_set_skip_taskbar_hint ( p->topGdkWindow, True ); XSelectInput (gdk_helper_display(), GDK_ROOT_WINDOW(), PropertyChangeMask); XSelectInput (gdk_helper_display(), p->topxwin, PropertyChangeMask | FocusChangeMask | StructureNotifyMask); gdk_window_add_filter(gdk_get_default_root_window (), (GdkFilterFunc)panel_wm_events, p); calculate_position(p, distance,distancefrom); gdk_window_move_resize(p->topgwin->window, p->ax, p->ay, p->aw, p->ah); if (p->setstrut) panel_set_wm_strut(p); if (p->lower) XLowerWindow(gdk_helper_display(), p->topxwin); RET(); }
void panel_start_gui(panel *p) { Atom state[3]; XWMHints wmhints; guint32 val; ENTER; // main toplevel window p->topgwin = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_container_set_border_width(GTK_CONTAINER(p->topgwin), 0); gtk_window_set_resizable(GTK_WINDOW(p->topgwin), FALSE); gtk_window_set_wmclass(GTK_WINDOW(p->topgwin), "panel", "fbpanel"); gtk_window_set_title(GTK_WINDOW(p->topgwin), "panel"); gtk_window_set_position(GTK_WINDOW(p->topgwin), GTK_WIN_POS_NONE); gtk_window_set_decorated(GTK_WINDOW(p->topgwin), FALSE); g_signal_connect(G_OBJECT(p->topgwin), "delete-event", G_CALLBACK(panel_delete_event), p); g_signal_connect(G_OBJECT(p->topgwin), "destroy-event", G_CALLBACK(panel_destroy_event), p); g_signal_connect (G_OBJECT (p->topgwin), "size-request", (GCallback) panel_size_req, p); g_signal_connect (G_OBJECT (p->topgwin), "size-allocate", (GCallback) panel_size_alloc, p); g_signal_connect (G_OBJECT (p->topgwin), "configure-event", (GCallback) panel_configure_event, p); g_signal_connect (G_OBJECT (p->topgwin), "realize", (GCallback) panel_realize, p); g_signal_connect (G_OBJECT (p->topgwin), "style-set", (GCallback) panel_style_set, p); gtk_widget_realize(p->topgwin); //gdk_window_set_decorations(p->topgwin->window, 0); gtk_widget_set_app_paintable(p->topgwin, TRUE); // background box all over toplevel p->bbox = gtk_bgbox_new(); gtk_container_add(GTK_CONTAINER(p->topgwin), p->bbox); gtk_widget_show(p->bbox); gtk_container_set_border_width(GTK_CONTAINER(p->bbox), 0); if (p->transparent) { p->bg = fb_bg_get_for_display(); gtk_bgbox_set_background(p->bbox, BG_ROOT, p->tintcolor, p->alpha); } // main layout manager as a single child of background widget box p->lbox = p->my_box_new(FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(p->lbox), 0); gtk_container_add(GTK_CONTAINER(p->bbox), p->lbox); gtk_widget_show(p->lbox); if (p->round_corners) make_round_corners(p); p->box = p->my_box_new(FALSE, p->spacing); gtk_container_set_border_width(GTK_CONTAINER(p->box), 0); gtk_box_pack_start(GTK_BOX(p->lbox), p->box, TRUE, TRUE, 0); gtk_widget_show(p->box); p->topxwin = GDK_WINDOW_XWINDOW(GTK_WIDGET(p->topgwin)->window); DBG("topxwin = %x\n", p->topxwin); /* the settings that should be done before window is mapped */ wmhints.flags = InputHint; wmhints.input = 0; XSetWMHints (GDK_DISPLAY(), p->topxwin, &wmhints); #define WIN_HINTS_SKIP_FOCUS (1<<0) /* "alt-tab" skips this win */ val = WIN_HINTS_SKIP_FOCUS; XChangeProperty(GDK_DISPLAY(), p->topxwin, XInternAtom(GDK_DISPLAY(), "_WIN_HINTS", False), XA_CARDINAL, 32, PropModeReplace, (unsigned char *) &val, 1); if (p->setdocktype) { state[0] = a_NET_WM_WINDOW_TYPE_DOCK; XChangeProperty(GDK_DISPLAY(), p->topxwin, a_NET_WM_WINDOW_TYPE, XA_ATOM, 32, PropModeReplace, (unsigned char *) state, 1); } /* window mapping point */ gtk_widget_show_all(p->topgwin); /* the settings that should be done after window is mapped */ /* send it to running wm */ Xclimsg(p->topxwin, a_NET_WM_DESKTOP, 0xFFFFFFFF, 0, 0, 0, 0); /* and assign it ourself just for case when wm is not running */ val = 0xFFFFFFFF; XChangeProperty(GDK_DISPLAY(), p->topxwin, a_NET_WM_DESKTOP, XA_CARDINAL, 32, PropModeReplace, (unsigned char *) &val, 1); state[0] = a_NET_WM_STATE_SKIP_PAGER; state[1] = a_NET_WM_STATE_SKIP_TASKBAR; state[2] = a_NET_WM_STATE_STICKY; XChangeProperty(GDK_DISPLAY(), p->topxwin, a_NET_WM_STATE, XA_ATOM, 32, PropModeReplace, (unsigned char *) state, 3); XSelectInput (GDK_DISPLAY(), GDK_ROOT_WINDOW(), PropertyChangeMask); gdk_window_add_filter(gdk_get_default_root_window (), (GdkFilterFunc)panel_event_filter, p); calculate_position(p); gdk_window_move_resize(p->topgwin->window, p->ax, p->ay, p->aw, p->ah); if (p->setstrut) panel_set_wm_strut(p); RET(); }
static void panel_start_gui(panel *p) { ENTER; // main toplevel window p->topgwin = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_container_set_border_width(GTK_CONTAINER(p->topgwin), 0); g_signal_connect(G_OBJECT(p->topgwin), "destroy-event", (GCallback) panel_destroy_event, p); g_signal_connect(G_OBJECT(p->topgwin), "size-request", (GCallback) panel_size_req, p); g_signal_connect(G_OBJECT(p->topgwin), "map-event", (GCallback) panel_mapped, p); g_signal_connect(G_OBJECT(p->topgwin), "configure-event", (GCallback) panel_configure_event, p); g_signal_connect(G_OBJECT(p->topgwin), "button-press-event", (GCallback) panel_button_press_event, p); g_signal_connect(G_OBJECT(p->topgwin), "scroll-event", (GCallback) panel_scroll_event, p); gtk_window_set_resizable(GTK_WINDOW(p->topgwin), FALSE); gtk_window_set_wmclass(GTK_WINDOW(p->topgwin), "panel", "fbpanel"); gtk_window_set_title(GTK_WINDOW(p->topgwin), "panel"); gtk_window_set_position(GTK_WINDOW(p->topgwin), GTK_WIN_POS_NONE); gtk_window_set_decorated(GTK_WINDOW(p->topgwin), FALSE); gtk_window_set_accept_focus(GTK_WINDOW(p->topgwin), FALSE); if (p->setdocktype) gtk_window_set_type_hint(GTK_WINDOW(p->topgwin), GDK_WINDOW_TYPE_HINT_DOCK); if (p->layer == LAYER_ABOVE) gtk_window_set_keep_above(GTK_WINDOW(p->topgwin), TRUE); else if (p->layer == LAYER_BELOW) gtk_window_set_keep_below(GTK_WINDOW(p->topgwin), TRUE); gtk_window_stick(GTK_WINDOW(p->topgwin)); gtk_widget_realize(p->topgwin); p->topxwin = GDK_WINDOW_XWINDOW(p->topgwin->window); DBG("topxwin = %lx\n", p->topxwin); /* ensure configure event */ XMoveWindow(GDK_DISPLAY(), p->topxwin, 20, 20); XSync(GDK_DISPLAY(), False); gtk_widget_set_app_paintable(p->topgwin, TRUE); calculate_position(p); gtk_window_move(GTK_WINDOW(p->topgwin), p->ax, p->ay); gtk_window_resize(GTK_WINDOW(p->topgwin), p->aw, p->ah); DBG("move-resize x %d y %d w %d h %d\n", p->ax, p->ay, p->aw, p->ah); //XSync(GDK_DISPLAY(), False); //gdk_flush(); // background box all over toplevel p->bbox = gtk_bgbox_new(); gtk_container_add(GTK_CONTAINER(p->topgwin), p->bbox); gtk_container_set_border_width(GTK_CONTAINER(p->bbox), 0); if (p->transparent) { p->bg = fb_bg_get_for_display(); gtk_bgbox_set_background(p->bbox, BG_ROOT, p->tintcolor, p->alpha); } // main layout manager as a single child of background widget box p->lbox = p->my_box_new(FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(p->lbox), 0); gtk_container_add(GTK_CONTAINER(p->bbox), p->lbox); p->box = p->my_box_new(FALSE, p->spacing); gtk_container_set_border_width(GTK_CONTAINER(p->box), 0); gtk_box_pack_start(GTK_BOX(p->lbox), p->box, TRUE, TRUE, (p->round_corners) ? p->round_corners_radius : 0); if (p->round_corners) { make_round_corners(p); DBG("make_round_corners\n"); } /* start window creation process */ gtk_widget_show_all(p->topgwin); /* .. and hide it from user until everything is done */ gtk_widget_hide(p->topgwin); p->menu = panel_make_menu(p); if (p->setstrut) panel_set_wm_strut(p); XSelectInput(GDK_DISPLAY(), GDK_ROOT_WINDOW(), PropertyChangeMask); gdk_window_add_filter(gdk_get_default_root_window(), (GdkFilterFunc)panel_event_filter, p); //XSync(GDK_DISPLAY(), False); gdk_flush(); RET(); }
void cDlgOptions::create_hardpoints(HTREEITEM item) { HTREEITEM fixed = utf->AddNewNode(tree, item, "Fixed"); HTREEITEM revolute = utf->AddNewNode(tree, item, "Revolute"); // iterate mesh list and create hardpoints list<MMESH *>::iterator i; for (i = meshList->begin(); i != meshList->end(); i ++) { MMESH * m = *i; char * hp_name = 0; // Hardpoint|Fixed|blah or Hardpoint|Revolute|blah if ( !_strnicmp(m->nname, "Hp", 2) ) { HTREEITEM parent = 0; if ( !_strnicmp (m->nname + 3, "Fixed", 5) ) { parent = fixed; hp_name = m->nname + 9; // pointer to name Hp|Fixed|name } else if ( !_strnicmp (m->nname + 3, "Revolute", 8) ) { parent = revolute; hp_name = m->nname + 12; // pointer to name Hp|Revolute|name } else continue; HTREEITEM new_hp = utf->AddNewNode(tree, parent, hp_name); // only revolute hardpoints have these if (parent == revolute) { HTREEITEM axis = utf->AddNewNode(tree, new_hp, "Axis"); float * axis_data = (float *) malloc (12 + 4); *(int *) axis_data = 12; axis_data[1] = 0.0f; axis_data[2] = 1.0f; axis_data[3] = 0.0f; tree->SetItemData(axis, (DWORD_PTR)axis_data); HTREEITEM max = utf->AddNewNode(tree, new_hp, "Max"); float * max_data = (float *) malloc (8 + 4); *(int *) max_data = 8; max_data[1] = 0.785380f; max_data[2] = 0.0f; tree->SetItemData(max, (DWORD_PTR)max_data); HTREEITEM min = utf->AddNewNode(tree, new_hp, "Min"); float * min_data = (float *) malloc (8 + 4); *(int *) min_data = 8; min_data[1] = -0.785400f; min_data[2] = 0.0f; tree->SetItemData(min, (DWORD_PTR)min_data); } // both fixed and revolute hardpoints have Orientation and Position float * position_data = (float *) malloc (12 + 4); *(int *) position_data = 12; calculate_position( position_data + 1, m); float * orientation_data = (float *) malloc (36 + 4); *(int *) orientation_data = 36; calculate_orientation( orientation_data + 1, position_data + 1, hp_name); HTREEITEM orientation = utf->AddNewNode(tree, new_hp, "Orientation"); tree->SetItemData(orientation, (DWORD_PTR) orientation_data); HTREEITEM position = utf->AddNewNode(tree, new_hp, "Position"); tree->SetItemData(position, (DWORD_PTR) position_data); } } }
void VersusScene::calculate_and_send_position() { if ( m_player ) { TEXEngine::Core::Message parameters(3,0,0); parameters.add_integral_data(0,static_cast<TEXEngine::Core::MESSAGE_INTEGRAL_DATA_TYPE>(get_id())); parameters.add_integral_data(1,static_cast<TEXEngine::Core::MESSAGE_INTEGRAL_DATA_TYPE>(0)); parameters.add_integral_data(2,static_cast<TEXEngine::Core::MESSAGE_INTEGRAL_DATA_TYPE>(calculate_position())); trigger_event(PLAYER_POSITION,parameters); } }