src/bin/performance.c

   1 #include <stdio.h>
   2 #include <Eina.h>
   3 #include <Ecore.h>
   4 #include <Evas.h>
   5 #include <Ecore_Evas.h>
   6 #include <E_DBus.h>
   7 #include <Elementary.h>
   8 #include <time.h>
   9
  10 #define SPECTATOR_MODE 1//in spectator mode messages are send as signals
  11
  12 #define SIZE_W 800
  13 #define SIZE_H 600
  14
  15 #define SHIP_SIZE 50
  16
  17 #define BUS_NAME_SERVER "com.profusion.benchmak.server"
  18 #define PATH_NAME_SERVER "/com/profusion/benchmak/server"
  19 #define IFACE_NAME_SERVER "com.profusion.benchmak.server.game"
  20
  21 #define BUS_NAME_CLIENT "com.profusion.benchmark.client"
  22 #define PATH_NAME_CLIENT "/com/profusion/benchmak/client"
  23 #define IFACE_NAME_CLIENT "com.profusion.benchmark.client.game"
  24
  25 #define MOVEMENT_DELAY 0.01//10ms between movements
  26 #define MOVEMENT_Y 5//increment/decrement ship movement
  27
  28 #define MOVEMENT_BULLET 10
  29 #define BULLET_SIZE_W 100
  30 #define BULLET_SIZE_H 50
  31
  32 #define TIMEOUT -1
  33
  34 E_DBus_Connection *conn;
  35 E_DBus_Object *obj_path;
  36 Evas_Object *client_ship, *server_ship;
  37 char can_join = 1;
  38 char player;
  39 int player_y_start;
  40 int player_y_end;
  41 int player_x;
  42 int action;//1 up, 2 down
  43
  44 Evas_Object *win;
  45
  46 typedef struct _bullet
  47   {
  48      Evas_Object *o;
  49      int x;
  50      int y;
  51      char direction;
  52   } bullet;
  53
  54
  55 typedef struct _EDBus_Method
  56   {
  57      char *member;
  58      char *signature;
  59      char *reply_signature;
  60      E_DBus_Method_Cb func;
  61      char *c_symbol;
  62      int annotations;
  63   } EDBus_Method;
  64
  65 typedef struct _EDBus_Signal
  66   {
  67      char *name;
  68      char *signature;
  69      char *c_symbol;
  70      int annotations;
  71   } EDBus_Signal;
  72
  73 static void obj_register(char *path_name, char *iface_name, EDBus_Method *methods, EDBus_Signal *signals);
  74
  75 static Eina_Bool _move_bullet(void *context)
  76 {
  77    bullet *b = context;
  78
  79    if (b->direction == '+')
  80      {
  81         b->x += MOVEMENT_BULLET;
  82         evas_object_move(b->o, b->x, b->y);
  83         if ((b->x + MOVEMENT_BULLET) < SIZE_W)
  84            return ECORE_CALLBACK_RENEW;
  85      }
  86    else
  87      {
  88         b->x -= MOVEMENT_BULLET;
  89         evas_object_move(b->o, b->x, b->y);
  90         if ((b->x - MOVEMENT_BULLET) > 0)
  91            return ECORE_CALLBACK_RENEW;
  92      }
  93
  94    evas_object_hide(b->o);
  95    evas_object_del(b->o);
  96    free(b);
  97    return ECORE_CALLBACK_CANCEL;
  98 }
  99
 100 static void
 101 _shoot(char _player, int x, int y)
 102 {
 103    bullet *b = malloc(sizeof(bullet));
 104
 105    if (_player == 1) b->direction = '+';
 106    else b->direction = '-';
 107
 108    b->x = x;
 109    b->y = y;
 110
 111    b->o = elm_progressbar_add(win);
 112    elm_progressbar_pulse(b->o, TRUE);
 113    evas_object_resize(b->o, BULLET_SIZE_W, BULLET_SIZE_H);
 114    evas_object_move(b->o, x, y);
 115
 116    evas_object_show(b->o);
 117
 118    ecore_timer_add(0.2, _move_bullet, b);
 119 }
 120
 121 static void
 122 _dbus_error_check(DBusError *error)
 123 {
 124    if (dbus_error_is_set(error))
 125      {
 126         printf("dbus error\nName: %s\nDescription: %s\n", error->name,
 127                error->message);
 128         elm_exit();
 129      }
 130 }
 131
 132 void
 133 create_ship(Evas_Object **_obj, Evas *canvas, char _player)
 134 {
 135    Evas_Object *o;
 136
 137    o = evas_object_polygon_add(canvas);
 138
 139    if (_player == 1)
 140      {
 141         evas_object_polygon_point_add(o, 0, SIZE_H - SHIP_SIZE);
 142         evas_object_polygon_point_add(o, SHIP_SIZE / 2, SIZE_H - (SHIP_SIZE / 2));
 143         evas_object_polygon_point_add(o, 0, SIZE_H);
 144
 145         evas_object_color_set(o, 255, 0, 0, 255);
 146      }
 147    else
 148      {
 149         evas_object_polygon_point_add(o, SIZE_W, 0);
 150         evas_object_polygon_point_add(o, SIZE_W - (SHIP_SIZE / 2), SHIP_SIZE / 2);
 151         evas_object_polygon_point_add(o, SIZE_W, SHIP_SIZE);
 152
 153         evas_object_color_set(o, 0, 0, 255, 255);
 154      }
 155    evas_object_show(o);
 156
 157    *_obj = o;
 158 }
 159
 160 static void
 161 update(char _player, int x, int y)
 162 {
 163    if (_player == 1)
 164       evas_object_move(server_ship, x, y);
 165    else
 166       evas_object_move(client_ship, x, y);
 167 }
 168
 169 static void
 170 _cb_move_ack(void *data, DBusMessage *msg, DBusError *error)
 171 {
 172    _dbus_error_check(error);
 173 }
 174
 175 #if SPECTATOR_MODE == 1
 176 static void
 177 send_my_position()
 178 {
 179    DBusMessage *msg;
 180
 181    if (player == 1)
 182      msg = dbus_message_new_signal(PATH_NAME_SERVER, IFACE_NAME_SERVER,
 183                                    "moveOfServer");
 184    else
 185      msg = dbus_message_new_signal(PATH_NAME_CLIENT, IFACE_NAME_CLIENT,
 186                                    "moveOfClient");
 187
 188    dbus_message_append_args(msg, DBUS_TYPE_INT32, &player_x, DBUS_TYPE_INT32,
 189                             &player_y_start, DBUS_TYPE_INVALID);
 190    e_dbus_message_send(conn, msg, _cb_move_ack, TIMEOUT, NULL);
 191    dbus_message_unref(msg);
 192 }
 193 #else
 194 static void
 195 send_my_position()
 196 {
 197    DBusMessage *msg;
 198
 199    if (player == 1)
 200      msg = dbus_message_new_method_call(BUS_NAME_CLIENT, PATH_NAME_CLIENT,
 201                                         IFACE_NAME_CLIENT, "moveOfServer");
 202    else
 203      msg = dbus_message_new_method_call(BUS_NAME_SERVER, PATH_NAME_SERVER,
 204                                         IFACE_NAME_SERVER, "moveOfClient");
 205
 206    dbus_message_append_args(msg, DBUS_TYPE_INT32, &player_x, DBUS_TYPE_INT32,
 207                             &player_y_start, DBUS_TYPE_INVALID);
 208    e_dbus_message_send(conn, msg, _cb_move_ack, TIMEOUT, NULL);
 209    dbus_message_unref(msg);
 210 }
 211 #endif
 212
 213 static Eina_Bool
 214 _movement(void *data)
 215 {
 216    if (action == 1)
 217      {
 218         if ((player_y_start - MOVEMENT_Y) >= 0)
 219           {
 220              player_y_start -= MOVEMENT_Y;
 221              player_y_end = player_y_start + SHIP_SIZE;
 222              send_my_position();
 223              update(player, player_x, player_y_start);
 224              if ((rand() % 6) == 5)
 225                _shoot(player, player_x, player_y_start);
 226              return ECORE_CALLBACK_RENEW;
 227           }
 228       else
 229         {
 230            action = 2;
 231            return _movement(NULL);
 232         }
 233      }
 234    else
 235      {
 236         if ((player_y_end + MOVEMENT_Y) <= SIZE_H)
 237           {
 238              player_y_end += MOVEMENT_Y;
 239              player_y_start = player_y_end - SHIP_SIZE;
 240              send_my_position();
 241              update(player, player_x, player_y_start);
 242              if ((rand() % 6) == 5)
 243                _shoot(player, player_x, player_y_start);
 244              return ECORE_CALLBACK_RENEW;
 245           }
 246       else
 247         {
 248            action = 1;
 249            return _movement(NULL);
 250         }
 251    }
 252 }
 253
 254 void
 255 create_auto_move_event(char p)
 256 {
 257    player = action = p;
 258    player_y_start = 0;
 259    player_y_end = SHIP_SIZE;
 260
 261    if (player == 1)
 262      {
 263         player_x = 0;
 264         player_y_start = SIZE_H - SHIP_SIZE;
 265         player_y_end = SIZE_H;
 266      }
 267    else
 268      {
 269         player_x = SIZE_W - (SHIP_SIZE / 2);
 270         player_y_start = SIZE_H - SHIP_SIZE;
 271         player_y_end = SIZE_H;
 272
 273         player_y_start = 0;
 274         player_y_end = SHIP_SIZE;
 275      }
 276
 277    ecore_timer_add(MOVEMENT_DELAY, _movement, NULL);
 278 }
 279
 280 static DBusMessage *
 281 _move_(Evas_Object *ship, E_DBus_Object *_obj, DBusMessage *msg)
 282 {
 283    DBusMessage *reply = dbus_message_new_method_return(msg);
 284    int x, y;
 285    DBusError new_err;
 286
 287    dbus_error_init(&new_err);
 288    dbus_message_get_args(msg, &new_err, DBUS_TYPE_INT32, &x, DBUS_TYPE_INT32,
 289                          &y, DBUS_TYPE_INVALID);
 290    _dbus_error_check(&new_err);
 291
 292    evas_object_move(ship, x, y);
 293
 294    return reply;
 295 }
 296
 297 #if SPECTATOR_MODE == 1
 298 static void
 299 _move_client(void *context, DBusMessage *msg)
 300 {
 301    _move_(client_ship, NULL, msg);
 302 }
 303
 304 static void
 305 _move_server(void *context, DBusMessage *msg)
 306 {
 307    _move_(server_ship, NULL, msg);
 308 }
 309 #else
 310 static DBusMessage *
 311 _move_client(E_DBus_Object *obj, DBusMessage *msg)
 312 {
 313    return _move_(client_ship, obj, msg);
 314 }
 315
 316 static DBusMessage *
 317 _move_server(E_DBus_Object *obj, DBusMessage *msg)
 318 {
 319    return _move_(server_ship, obj, msg);
 320 }
 321 #endif
 322
 323 static DBusMessage *
 324 _can_join(E_DBus_Object *_obj, DBusMessage *msg)
 325 {
 326    DBusMessage *reply = dbus_message_new_method_return(msg);
 327
 328    if (can_join)
 329      {
 330         dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &can_join,
 331                                  DBUS_TYPE_INVALID);
 332         can_join = 0;
 333
 334 #if SPECTATOR_MODE == 1
 335         e_dbus_signal_handler_add(conn, BUS_NAME_CLIENT, PATH_NAME_CLIENT,
 336                                   IFACE_NAME_CLIENT, "moveOfClient",
 337                                   _move_client, NULL);
 338 #endif
 339
 340         create_auto_move_event(1);
 341         printf("game started\n");
 342      }
 343    else
 344      {
 345         dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &can_join,
 346                                  DBUS_TYPE_INVALID);
 347      }
 348
 349    return reply;
 350 }
 351
 352 static void
 353 _cb_dbus_request_name_client(void *context, DBusMessage *msg, DBusError *err)
 354 {
 355    DBusError new_err;
 356    int flag;
 357    _dbus_error_check(err);
 358
 359    dbus_error_init(&new_err);
 360    dbus_message_get_args(msg, &new_err, DBUS_TYPE_UINT32, &flag,
 361                          DBUS_TYPE_INVALID);
 362
 363    if (flag == DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER)
 364      {
 365         EDBus_Method table_methods[] =
 366           {
 367 #if SPECTATOR_MODE == 0
 368              { "moveOfServer", "ii", "", _move_server, "move_server", 0},
 369 #endif
 370              { NULL, NULL, NULL, NULL, NULL, 0 }
 371           };
 372
 373         EDBus_Signal table_signal[] =
 374           {
 375 #if SPECTATOR_MODE == 1
 376              { "moveOfClient", "ii", "move_client", 0 },
 377 #endif
 378              { NULL, NULL, NULL, 0 }
 379           };
 380
 381         /*e_dbus_interface_register(conn, PATH_NAME_CLIENT, IFACE_NAME_CLIENT,
 382                                   table, table_signal, NULL, NULL);*/
 383         obj_register(PATH_NAME_CLIENT, IFACE_NAME_CLIENT, table_methods, table_signal);
 384
 385 #if SPECTATOR_MODE == 1
 386         e_dbus_signal_handler_add(conn, BUS_NAME_SERVER, PATH_NAME_SERVER,
 387                                   IFACE_NAME_SERVER, "moveOfServer",
 388                                   _move_server, NULL);
 389 #endif
 390
 391         create_auto_move_event(2);
 392         printf("game started\n");
 393      }
 394    else printf("dbus_request_name fail, the client name was already in use.\n");
 395 }
 396
 397 static void
 398 _cb_can_join(void *data, DBusMessage *msg, DBusError *error)
 399 {
 400    char bool;
 401    DBusError new_err;
 402
 403    _dbus_error_check(error);
 404
 405    dbus_error_init(&new_err);
 406    dbus_message_get_args(msg, &new_err, DBUS_TYPE_BOOLEAN, &bool,
 407                          DBUS_TYPE_INVALID);
 408    _dbus_error_check(&new_err);
 409
 410    if (bool)
 411      {
 412         e_dbus_request_name(conn, BUS_NAME_CLIENT, DBUS_NAME_FLAG_DO_NOT_QUEUE,
 413                             _cb_dbus_request_name_client, NULL);
 414      }
 415    else
 416      {
 417 #if SPECTATOR_MODE == 1
 418         printf("Spectator mode\n");
 419         e_dbus_signal_handler_add(conn, BUS_NAME_SERVER, PATH_NAME_SERVER,
 420                                   IFACE_NAME_SERVER, "moveOfServer",
 421                                   _move_server, NULL);
 422         e_dbus_signal_handler_add(conn, BUS_NAME_CLIENT, PATH_NAME_CLIENT,
 423                                   IFACE_NAME_CLIENT, "moveOfClient",
 424                                   _move_client, NULL);
 425 #else
 426         printf("server full, try later!\n");
 427         elm_exit();
 428 #endif
 429      }
 430 }
 431
 432 static void
 433 _ask_if_can_join()
 434 {
 435    DBusMessage *msg =
 436             dbus_message_new_method_call(BUS_NAME_SERVER, PATH_NAME_SERVER,
 437                                          IFACE_NAME_SERVER, "canJoin");
 438    e_dbus_message_send(conn, msg, _cb_can_join, -1, NULL);
 439    dbus_message_unref(msg);
 440 }
 441
 442 static void
 443 _cb_dbus_request_name_server(void *context, DBusMessage *msg, DBusError *err)
 444 {
 445    DBusError new_err;
 446    int flag = 0;
 447    _dbus_error_check(err);
 448
 449    dbus_error_init(&new_err);
 450    dbus_message_get_args(msg, &new_err, DBUS_TYPE_UINT32, &flag,
 451                          DBUS_TYPE_INVALID);
 452
 453    if (flag == DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER)
 454      {
 455         EDBus_Method table_methods[] =
 456           {
 457              { "canJoin", "", "b", _can_join, "can_join", 0 },
 458 #if SPECTATOR_MODE == 0
 459              { "moveOfClient", "ii", "", _move_client, "move_client", 0},
 460 #endif
 461              { NULL, NULL, NULL, NULL, NULL, 0 }
 462           };
 463
 464        EDBus_Signal table_signal[] =
 465           {
 466 #if SPECTATOR_MODE == 1
 467              { "moveOfServer", "ii", "move_server", 0 },
 468 #endif
 469              { NULL, NULL, NULL, 0 }
 470           };
 471
 472        /*e_dbus_interface_register(conn, PATH_NAME_SERVER, IFACE_NAME_SERVER,
 473                                  table, table_signal, NULL, NULL);*/
 474        obj_register(PATH_NAME_SERVER, IFACE_NAME_SERVER, table_methods, table_signal);
 475
 476        printf("Waiting for another player\n");
 477
 478      }
 479    else _ask_if_can_join();
 480 }
 481
 482 static void
 483 obj_register(char *path_name, char *iface_name, EDBus_Method *methods, EDBus_Signal *signals)
 484 {
 485    obj_path = e_dbus_object_add(conn, path_name, NULL);
 486    E_DBus_Interface *iface = e_dbus_interface_new(iface_name);
 487    const EDBus_Method *_method;
 488    const EDBus_Signal *_signal;
 489
 490    e_dbus_object_interface_attach(obj_path, iface);
 491    e_dbus_interface_unref(iface);
 492
 493    for (_method = methods; _method != NULL && _method->member != NULL; _method++)
 494      e_dbus_interface_method_add(iface, _method->member,
 495                                         _method->signature,
 496                                         _method->reply_signature,
 497                                         _method->func);
 498
 499    for (_signal = signals; _signal != NULL && _signal->name != NULL; _signal++)
 500         e_dbus_interface_signal_add(iface, _signal->name, _signal->signature);
 501 }
 502
 503 static void
 504 obj_unregister()
 505 {
 506    if (!obj_path) return;
 507    e_dbus_object_free(obj_path);
 508 }
 509
 510 static void
 511 _mouse_handler(void *data, Evas *e, Evas_Object *_obj, void *event_info)
 512 {
 513    Evas_Event_Mouse_Move *mouse_info = event_info;
 514    Evas_Object *square = data;
 515
 516    evas_object_move(square, mouse_info->cur.canvas.x, mouse_info->cur.canvas.y);
 517 }
 518
 519 static void
 520 on_done(void *data, Evas_Object *_obj, void *event_info)
 521 {
 522    elm_exit();
 523 }
 524
 525 int
 526 elm_main(int argc, char **argv)
 527 {
 528    Evas *canvas;
 529    Evas_Object *bg, *square;
 530    srand(time(NULL));
 531
 532    e_dbus_init();
 533
 534    win = elm_win_add(NULL, "bg-plain", ELM_WIN_BASIC);
 535    elm_win_title_set(win, "Benchmark");
 536    evas_object_smart_callback_add(win, "delete,request", on_done, NULL);
 537    elm_win_autodel_set(win, EINA_TRUE);
 538    evas_object_resize(win, SIZE_W, SIZE_H);
 539    canvas = evas_object_evas_get(win);
 540
 541    bg = elm_bg_add(win);
 542    evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 543    elm_win_resize_object_add(win, bg);
 544    elm_bg_color_set(bg, 255, 255, 255);
 545    evas_object_show(bg);
 546
 547    square = evas_object_rectangle_add(canvas);
 548    evas_object_resize(square, 30, 30);
 549    evas_object_color_set(square, 0, 255, 0, 255);
 550    evas_object_show(square);
 551    evas_object_event_callback_add(bg, EVAS_CALLBACK_MOUSE_MOVE, _mouse_handler,
 552                                   square);
 553
 554    create_ship(&client_ship, canvas, 2);
 555    create_ship(&server_ship, canvas, 1);
 556
 557    conn = e_dbus_bus_get(DBUS_BUS_SESSION);
 558
 559    e_dbus_request_name(conn, BUS_NAME_SERVER, DBUS_NAME_FLAG_DO_NOT_QUEUE,
 560                        _cb_dbus_request_name_server, NULL);
 561
 562    evas_object_show(win);
 563
 564    elm_run();
 565    elm_shutdown();
 566    /*e_dbus_interface_unregister(conn, PATH_NAME_CLIENT);
 567    e_dbus_interface_unregister(conn, PATH_NAME_SERVER);*/
 568    obj_unregister();
 569    e_dbus_shutdown();
 570
 571    return 0;
 572 }
 573 ELM_MAIN()