.. _program_listing_file_include_tests_JUDGE_TESTS_judgeTest.cpp:

Program Listing for File judgeTest.cpp
======================================

|exhale_lsh| :ref:`Return to documentation for file <file_include_tests_JUDGE_TESTS_judgeTest.cpp>` (``include\tests\JUDGE_TESTS\judgeTest.cpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #include "PDJE_Input.hpp"
   #include "PDJE_Judge.hpp"
   #include "PDJE_interface.hpp"
   #include <iostream>
   
   #include "miniaudio.h"
   
   void
   beep_cb(ma_device  *pDevice,
           void       *pOutput,
           const void *pInput,
           ma_uint32   frameCount)
   {
   }
   int
   main()
   {
       auto engine = PDJE("testRoot.db");
       auto td     = engine.SearchTrack("");
   
       engine.InitPlayer(PLAY_MODE::FULL_PRE_RENDER, td.front(), 480);
       // engine.player->Activate();
       // getchar();
       // engine.player->Deactivate();
       // return 0;
       ma_engine beep;
   
       if (ma_engine_init(NULL, &beep) != MA_SUCCESS) {
           std::cerr << "failed to init beep dev" << std::endl;
           return 1;
       }
   
       ma_waveform        wf;
       ma_waveform_config wfConfig =
           ma_waveform_config_init(ma_format_f32,
                                   1,
                                   ma_engine_get_sample_rate(&beep),
                                   ma_waveform_type_sine,
                                   1.0f,
                                   440.0f);
   
       ma_waveform_init(&wfConfig, &wf);
   
       ma_sound bsound;
       ma_sound_init_from_data_source(&beep, &wf, 0, NULL, &bsound);
       ma_sound_set_looping(&bsound, MA_FALSE);
   
       // ma_device_config conf   = ma_device_config_init(ma_device_type_playback);
       // conf.playback.format    = ma_format_f32;
       // conf.playback.channels  = 2;
       // conf.sampleRate         = 48000;
       // conf.periodSizeInFrames = 48;
       // conf.performanceProfile = ma_performance_profile_low_latency;
       // conf.pUserData = nullptr;
       // conf.dataCallback = beep_cb;
   
       // ma_device beep_dev;
       // if(ma_device_init(NULL, &conf, &beep_dev) != MA_SUCCESS){
       //     std::cerr << "failed to init beep dev" <<std::endl;
       //     return 1;
       // }
       auto input = PDJE_Input();
       input.Init();
       auto     devs  = input.GetDevs();
       auto     judge = PDJE_JUDGE::JUDGE();
       DEV_LIST list;
       auto     midis = input.GetMIDIDevs();
   
       for (auto &m : midis) {
   
           judge.inits.SetRail(
               m,
               1,
               static_cast<const uint8_t>(libremidi::message_type::NOTE_ON),
               1,
               48,
               0);
       }
   
       for (auto &d : devs) {
           if (d.Type == PDJE_Dev_Type::KEYBOARD) {
   
               // std::cout << "DEVICE id: " << d.device_specific_id << std::endl;
               // std::cout << "DEVICE NAME: " << d.Name << std::endl;
   
               list.push_back(d);
               judge.inits.SetRail(d, PDJE_KEY::A, 0, 1);
           }
           // if (d.Type == PDJE_Dev_Type::MOUSE) {
   
           //     std::cout << "DEVICE id: " << d.device_specific_id << std::endl;
           //     std::cout << "DEVICE NAME: " << d.Name << std::endl;
   
           //     list.push_back(d);
   
           //     // PDJE_JUDGE::INPUT_CONFIG conf;
   
           //     // conf.Device_ID  = d.Name;
   
           //     // conf.DeviceKey  = PDJE_JUDGE::DEVICE_MOUSE_EVENT::BTN_L;
           //     // conf.MatchRail  = 1;
           //     // conf.offset_microsecond
           //     judge.inits.SetRail(d, PDJE_JUDGE::DEVICE_MOUSE_EVENT::BTN_L, 0,
           //     1);
           // }
       }
       if (!input.Config(list, midis)) {
           std::cout << "config failed" << std::endl;
       }
       auto                iline          = input.PullOutDataLine();
       int                 note_add_count = 0;
       OBJ_SETTER_CALLBACK cb             = [&](const std::string        noteType,
                                    const uint16_t           noteDetail,
                                    const std::string        firstArg,
                                    const std::string        secondArg,
                                    const std::string        thirdArg,
                                    const unsigned long long Y_Axis,
                                    const unsigned long long Y_Axis_2,
                                    const uint64_t           railID) {
           judge.inits.NoteObjectCollector(noteType,
                                           noteDetail,
                                           firstArg,
                                           secondArg,
                                           thirdArg,
                                           Y_Axis,
                                           Y_Axis_2,
                                           railID);
           note_add_count++;
       };
       engine.GetNoteObjects(td.front(), cb);
       std::cout << "notes: " << note_add_count << std::endl;
       judge.inits.SetEventRule(
           { .miss_range_microsecond = 600005, .use_range_microsecond = 600000 });
       judge.inits.SetInputLine(input.PullOutDataLine());
   
       int                       miss_count = 0;
       PDJE_JUDGE::MISS_CALLBACK missed =
           [&miss_count, &bsound, &beep](
               std::unordered_map<uint64_t, PDJE_JUDGE::NOTE_VEC> misses) {
               std::cout << "missed!!!" << miss_count++ << std::endl;
               // ma_uint32 sampleRate = ma_engine_get_sample_rate(&beep);
               // ma_uint64 nowFrames   = ma_engine_get_time_in_pcm_frames(&beep);
               // ma_uint64 durFrames   = (ma_uint64)(0.1f * sampleRate);
               // ma_sound_set_stop_time_in_pcm_frames(&bsound, nowFrames +
               // durFrames); ma_sound_start(&bsound);
           };
       PDJE_JUDGE::USE_CALLBACK used = [&bsound, &beep](uint64_t railid,
                                                        bool     Pressed,
                                                        bool     IsLate,
                                                        uint64_t diff) {
           ma_uint32 sampleRate = ma_engine_get_sample_rate(&beep);
           ma_uint64 nowFrames  = ma_engine_get_time_in_pcm_frames(&beep);
           ma_uint64 durFrames  = (ma_uint64)(0.1f * sampleRate);
           ma_sound_set_stop_time_in_pcm_frames(&bsound, nowFrames + durFrames);
           ma_sound_start(&bsound);
           std::cout << "used!!!" << diff / 1000 << (IsLate ? " late " : " early ")
                     << std::endl;
       };
       PDJE_JUDGE::MOUSE_CUSTOM_PARSE_CALLBACK mouse_parse =
           [](uint64_t                      microSecond,
              const PDJE_JUDGE::P_NOTE_VEC &found_events,
              uint64_t                      railID,
              int                           x,
              int                           y,
              PDJE_Mouse_Axis_Type          axis_type) { return; };
       judge.inits.SetCustomEvents(
           { .missed_event          = missed,
             .used_event            = used,
             .custom_mouse_parse    = mouse_parse,
             .use_event_sleep_time  = std::chrono::milliseconds(1),
             .miss_event_sleep_time = std::chrono::milliseconds(1) });
       judge.inits.SetCoreLine(engine.PullOutDataLine());
       if (judge.Start() != PDJE_JUDGE::JUDGE_STATUS::OK) {
           std::cerr << "Failed to start judge" << std::endl;
       }
       input.Run();
       engine.player->Activate();
   
       // end
       getchar();
       engine.player->Deactivate();
       input.Kill();
       judge.End();
   
       return 0;
   }