void StartBattleIntroAnim(u8 a)
{
u8 taskId;
if (gBattleTypeFlags & BATTLE_TYPE_LINK)
{
taskId = CreateTask(BattleIntroTask_80E4C34, 0);
}
else if ((gBattleTypeFlags & BATTLE_TYPE_KYOGRE_GROUDON) && gGameVersion != VERSION_RUBY)
{
a = 3;
taskId = CreateTask(BattleIntroTask_FadeScenery, 0);
}
else
{
taskId = CreateTask(sBattleIntroTaskFuncs[a], 0);
}
gTasks[taskId].tState = 0;
gTasks[taskId].data[1] = a;
gTasks[taskId].tBgXOffset = 0;
gTasks[taskId].tFramesUntilBg1Slide = 0;
gTasks[taskId].data[4] = 0;
gTasks[taskId].data[5] = 0;
gTasks[taskId].data[6] = 0;
}
int main()
{
std::vector<int> input{ 1,2,3,4,5,6 };
auto add = CreateTask([](int x, int y) { return x + y; });
auto mul = CreateTask([](int x, int y) { return x * y; });
auto y = input | add(2) | mul(5);
}
void parallel_for(TaskPool& pool,
const DELEGATE_CBK<void, const Task&, U32, U32>& cbk,
U32 count,
U32 partitionSize,
TaskPriority priority,
bool noWait,
bool useCurrentThread)
{
if (count > 0) {
const U32 crtPartitionSize = std::min(partitionSize, count);
const U32 partitionCount = count / crtPartitionSize;
const U32 remainder = count % crtPartitionSize;
U32 adjustedCount = partitionCount;
if (useCurrentThread) {
adjustedCount -= 1;
}
std::atomic_uint jobCount = adjustedCount + (remainder > 0 ? 1 : 0);
for (U32 i = 0; i < adjustedCount; ++i) {
const U32 start = i * crtPartitionSize;
const U32 end = start + crtPartitionSize;
CreateTask(pool,
nullptr,
[&cbk, &jobCount, start, end](const Task& parentTask) {
cbk(parentTask, start, end);
jobCount.fetch_sub(1);
}).startTask(priority);
}
if (remainder > 0) {
CreateTask(pool,
nullptr,
[&cbk, &jobCount, count, remainder](const Task& parentTask) {
cbk(parentTask, count - remainder, count);
jobCount.fetch_sub(1);
}).startTask(priority);
}
if (useCurrentThread) {
TaskHandle threadTask = CreateTask(pool, [](const Task& parentTask) {ACKNOWLEDGE_UNUSED(parentTask); });
const U32 start = adjustedCount * crtPartitionSize;
const U32 end = start + crtPartitionSize;
cbk(*threadTask._task, start, end);
}
if (!noWait) {
while (jobCount.load() > 0) {
pool.threadWaiting();
}
}
}
}
void APP_Start (void) {
//hardware_init();
/* turn off LEDs */
gpio_set_pin_output(LED_RED);
gpio_set_pin_output(LED_GREEN);
gpio_set_pin_output(LED_BLUE);
//gpio_toggle_pin_output(LED_RED);
//gpio_toggle_pin_output(LED_GREEN);
//gpio_toggle_pin_output(LED_BLUE);
/* enable trace */
#if 1
if(RTOSTRC1_uiTraceStart()!=1) {
for(;;){} /* failure? */
}
#endif
/* create tasks */
CreateTask(); /* normal FreeRTOS tasks */
#if USE_SDK_RTOS
SDK_CreateTask(); /* using SDK API */
#endif
/* start the scheduler */
vTaskStartScheduler(); /* does usually not return! */
}
void ItemStorage_ReturnToMenuAfterDeposit(void)
{
Menu_DisplayDialogueFrame();
InitItemStorageMenu(ITEMPC_MENU_DEPOSIT);
CreateTask(ItemStorage_HandleReturnToProcessInput, 0);
pal_fill_black();
}
// called at update check TOD, on each user logout in case update is pending or on demand by admin UI
void check_for_update(update_check_e type, conn_t *conn)
{
bool force = (type != WAIT_UNTIL_NO_USERS);
if (no_net) {
lprintf("UPDATE: not checked because no-network-mode set\n");
return;
}
if (!force && admcfg_bool("update_check", NULL, CFG_REQUIRED) == false) {
lprintf("UPDATE: exiting because admin update check not enabled\n");
return;
}
if (force) {
lprintf("UPDATE: force %s by admin\n", (type == FORCE_CHECK)? "update check" : "build");
assert(conn != NULL);
if (update_task_running) {
lprintf("UPDATE: update task already running\n");
report_result(conn);
return;
} else {
conn->update_check = type;
}
}
if ((force || (update_pending && rx_count_server_conns(EXTERNAL_ONLY) == 0)) && !update_task_running) {
update_task_running = true;
CreateTask(update_task, TO_VOID_PARAM(conn), ADMIN_PRIORITY);
}
}
static void CreateBattleStartTask(u8 transition, u16 song)
{
u8 taskId = CreateTask(Task_BattleStart, 1);
gTasks[taskId].tTransition = transition;
current_map_music_set__default_for_battle(song);
}
tERROR cTmProfile::LockTask()
{
if( m_lockRef++ )
return errOK;
AddRef();
LockTaskReports(true);
tERROR err = errOK;
if( !m_remoteTask )
{
err = CreateTask();
if( PR_SUCC(err) )
err = SetTaskSettings();
if( PR_SUCC(err) && m_taskObj && (m_stateFlags & dfTaskRestarted) )
m_taskObj->SetSettings(m_statistics);
}
else if( !m_bTaskGroup )
err = AttachTask(m_remoteTask);
if( PR_FAIL(err) )
StateChanged(PROFILE_STATE_FAILED, err);
return err;
}
int
main(void)
{
char buf[200];
Task_t *cons;
dos = CreateMutex("dos");
Ready(cons =
CreateTask(consumer, 2000, "consumer", "consumer", DEFAULT_PRIO));
while ( true )
{
EnterMutex(dos);
if ( !kbhit() )
{
LeaveMutex(dos);
continue;
}
gets(buf);
if ( !strlen(buf) )
return 0;
LeaveMutex(dos);
Send(cons, buf, strlen(buf)+1);
}
}
void
SendUsbMsg(tMSG *pMsg)
{
Task *pNewTask;
UsbTxTask *pusbobj;
uint8_t WriteIndex;
uint8_t buffer[255];
uint8_t length = pMsg->Length;
pusbobj = malloc(sizeof(UsbTxTask));
pusbobj->MemProd = 1;
WriteIndex = 0;
WriteIndex += MsgCoding(buffer, (const uint8_t*)pMsg, 5);
WriteIndex += MsgCoding(buffer + WriteIndex, (const uint8_t*)pMsg->pPayload, length);
pusbobj->Len = length = WriteIndex + 4; // for sof and eof
pusbobj->pBuf = malloc(pusbobj->Len);
pusbobj->MemProd++;
memcpy(pusbobj->pBuf + 2, buffer, WriteIndex);
*(pusbobj->pBuf) = 0x10;
*(pusbobj->pBuf + 1) = 0x02;
*(pusbobj->pBuf + length - 2) = 0x10;
*(pusbobj->pBuf + length - 1) = 0x03;
// create task
pNewTask = CreateTask(NORMAL);
pNewTask->Name = USBTRANSMIT;
pNewTask->Status = TASKSTS_ONGOING;
pNewTask->pfn = (TASKSTATUS (*)(void *))UsbTxTaskMgr;
pNewTask->pTaskObj = pusbobj;
}
static struct Task *createCycleTask(void)
{
viewerDisplay.cycleTaskMustStop = FALSE;
viewerDisplay.cycleTaskTerminated = FALSE;
viewerDisplay.cycleModeEnabled = FALSE;
return CreateTask("amiilbmCycleTask", 0, AMI_ILBM_cycleTask, 4000L);
}
int main(void)
{
IOInit();
#if defined UART_AVAILABLE
UARTInit(UART_BAUDRATE); // 9600
#endif // UART_AVAILABLE
InitSysTimer(SYS_TICK_PERIOD); // 500 ms
CreateTask(Task_1, 0, IDLE);
CreateTask(Task_2, 4, SUSPEND);
CreateTask(Task_3, 2, SUSPEND);
while(1) // general cycle
{
Run();
}
}
static void
send_car(DIRECTION dir)
{
static DIRECTION left = LEFTBOUND, right = RIGHTBOUND;
Ready(CreateTask(car, 0, dir == LEFTBOUND ? &left : &right,
"car", DEFAULT_PRIO));
}
void my_taskcreate_Startup() {
CreateMainHeap(0x200000, 0x800000 - 0x20000); // in end of MainHeap - own code - 128 Kb
sub_FFB0FF74();
sub_FFB2E108(0x386D4380);
EnableDispatch();
CreateTask("Startup", 0x19, 0x2000, my_task_Startup, 0);
}
static void ReshowPCMenuAfterHallOfFamePC(void)
{
ScriptContext2_Enable();
Overworld_PlaySpecialMapMusic();
BeginNormalPaletteFade(0xFFFFFFFF, 0, 16, 0, RGB(0, 0, 0));
ScrSpecial_CreatePCMenu();
ScriptMenu_DisplayPCStartupPrompt();
CreateTask(Task_WaitForPaletteFade, 10);
}
bool UmcFramework::Create(apt_dir_layout_t* pDirLayout, apr_pool_t* pool)
{
m_pDirLayout = pDirLayout;
m_pPool = pool;
m_pSessionTable = apr_hash_make(m_pPool);
m_pScenarioTable = apr_hash_make(m_pPool);
return CreateTask();
}
static void sub_80A2198(u8 priority)
{
u8 taskId;
u8 i;
taskId = CreateTask(Task_80A244C, priority);
for (i = 1; i < 16; i++)
gTasks[taskId].data[i] = 0xFFFF;
}
float CreateNewInstance(Station*** stations, Task*** tasks, unsigned int seed)
{
int nbStations;
int nbTasks;
float A = 0; // to calculate the cycle time bound
int i = 0;
int j = 0;
int k = 0;
float timeBound;
srand(seed);
nbStations = (rand() % STATION_NB_VALUES) * STATION_STEP + STATION_MIN;
nbTasks = (rand() % OPERATION_NB_VALUES) * OPERATION_STEP + OPERATION_MIN;
// init stations
free(*stations);
*stations = (Station**)malloc(nbStations * sizeof(Station*));
for (i = 0; i < nbStations; i++)
{
(*stations)[i] = CreateStation(i);
}
// init tasks
free(*tasks);
*tasks = (Task**)malloc(nbTasks * sizeof(Task*));
for (i = 0; i < nbTasks; i++)
{
int processingTime = (rand() % PROC_TIME_NB_VALUES) * PROC_TIME_STEP + PROC_TIME_MIN;
int workersLB = (rand() % WORKERS_LB_NB_VALUES) * WORKERS_LB_STEP + WORKERS_LB_MIN;
int workersUB = workersLB * 2;
(*tasks)[i] = CreateTask(i, (float)processingTime, (*stations)[rand() % nbStations], workersLB, workersUB);
A += processingTime * (workersLB + workersUB) / 2;
}
// init time bound
A /= nbStations;
timeBound = rand() % (int)(0.5 * A) + A;
// init precedences
for (i = 0; i < nbStations; i++)
{
for (j = (*stations)[i]->nbTasks - 1; j >= 0; j--)
{
for (k = j - 1; k >= 0; k--)
{
if (rand() / RAND_MAX <= PRECEDENCE_PROBABILITY)
{
AddPredecessor((*stations)[i]->tasks[j], (*stations)[i]->tasks[k]);
}
}
}
}
return timeBound;
}
void gps_main(int argc, char *argv[])
{
assert(GPS_CHANS <= 16); // verilog limitation, see gps.v: "cmd_chan"
printf("GPS starting..\n");
SearchParams(argc, argv);
SearchInit();
for(int i=0; i<gps_chans; i++) {
char *tname;
asprintf(&tname, "GPSchan-%02d", i+1);
CreateTaskSP(ChanTask, tname, GPS_PRIORITY, (void *) (long) i);
}
CreateTask(SolveTask, GPS_PRIORITY);
if (!background_mode && print_stats) CreateTask(StatTask, GPS_PRIORITY);
}
void
mt_kbd_init(void){
keymap = keymaps[0];
kbd_name = names[0];
scan_mq = CreateMsgQueue("Scan code", KBDBUFSIZE, 1, false, false);
key_mq = CreateMsgQueue("Input key", KBDBUFSIZE, 1, true, false);
Ready(CreateTask(input_task, 0, NULL, "Input task", INPUTPRIO));
mt_set_int_handler(KBDINT, kbdint);
mt_enable_irq(KBDINT);
}
void APP_Start (void) {
hardware_init(); /* initialize the hardware */
/* create tasks */
#if USE_SDK_RTOS
SDK_CreateTask(); /* create a task with the Kinetis SDK API */
OSA_Start();
#else
CreateTask(); /* create a task with the 'traditional' FreeRTOS API */
vTaskStartScheduler(); /* start FreeRTOS scheduler, does usually not return! */
#endif
}
void task_a_8143D04(u8 taskIdA)
{
switch (gMain.state)
{
default:
case 0:
{
u16 i;
ResetSpriteData();
FreeAllSpritePalettes();
gReservedSpritePaletteCount = 8;
LZ77UnCompVram(&gBirchHelpGfx, (void *)VRAM);
LZ77UnCompVram(&gBirchGrassTilemap, (void *)(VRAM + 0x3800));
LoadPalette(gBirchBagGrassPal[0] + 1, 1, 31 * 2);
for (i = 0; i < 0x800; i++)
HALL_OF_FAME_SHEET_0[i] = 0x11;
for (i = 0; i < 0x800; i++)
HALL_OF_FAME_SHEET_1[i] = 0x22;
for (i = 0; i < 0x800; i++)
HALL_OF_FAME_SHEET_2[i] = 0x33;
EWRAM_1F800[0] = 0;
EWRAM_1F800[1] = 0x53FF; // light yellow
EWRAM_1F800[2] = 0x529F; // light red
EWRAM_1F800[3] = 0x7E94; // light blue
LoadSpriteSheet(gUnknown_0840CAA0);
LoadSpritePalette(gUnknown_0840CAB0);
gMain.state += 1;
break;
}
case 1:
gTasks[taskIdA].data[TDA_TASK_D_ID] = CreateTask(task_d_8144514, 0);
gTasks[gTasks[taskIdA].data[TDA_TASK_D_ID]].data[TDD_STATE] = 1;
gTasks[gTasks[taskIdA].data[TDA_TASK_D_ID]].data[TDD_TASK_A_ID] = taskIdA;
gTasks[gTasks[taskIdA].data[TDA_TASK_D_ID]].data[TDD_2] = gTasks[taskIdA].data[TDA_7];
BeginNormalPaletteFade(0xFFFFFFFF, 0, 16, 0, RGB(0, 0, 0));
REG_BG3HOFS = 0;
REG_BG3VOFS = 32;
REG_BG3CNT = BGCNT_PRIORITY(3) | BGCNT_CHARBASE(0) | BGCNT_SCREENBASE(7) | BGCNT_16COLOR | BGCNT_TXT256x256;
REG_DISPCNT = DISPCNT_MODE_0 | DISPCNT_OBJ_1D_MAP | DISPCNT_BG0_ON | DISPCNT_BG3_ON | DISPCNT_OBJ_ON;
gMain.state = 0;
gUnknown_0203935C = 0;
gTasks[taskIdA].func = task_a_8143B38;
break;
}
}
static void sub_810B634(void)
{
u8 taskId;
FieldEffectActiveListRemove(FLDEFF_USE_DIG);
if (ShouldDoBrailleDigEffect())
{
DoBrailleDigEffect();
}
else
{
taskId = CreateTask(task08_080A1C44, 8);
gTasks[taskId].data[0] = 0;
}
}
static void Mailbox_UpdateMailListAfterDeposit(void)
{
u8 taskId = CreateTask(Mailbox_HandleReturnToProcessInput, 0);
u8 oldCount = eMailboxInfo.count;
eMailboxInfo.count = GetMailboxMailCount();
Mailbox_UpdateMailList();
if(oldCount != eMailboxInfo.count && eMailboxInfo.count < eMailboxInfo.pageItems + eMailboxInfo.itemsAbove && eMailboxInfo.itemsAbove != 0) // did the count update?
eMailboxInfo.itemsAbove--;
ItemStorage_SetItemAndMailCount(taskId);
Mailbox_DrawMailboxMenu(taskId);
pal_fill_black();
}
/**
* Create our tasks.
*
* @param mgr
*/
void CreateTasks(AliAnalysisManager* mgr)
{
AliAnalysisTaskSE* task = CreateTask(mgr);
if (!task) {
Fatal("", "Failed to create the task");
return;
}
#if 0
gSystem->RedirectOutput("settings.txt");
Printf("=== Settings for %s train === ", mc ? "mc" : "dt");
task->Dump();
gSystem->RedirectOutput(0);
#endif
}
int
camino_ns_main(int argc, char **argv)
{
bool cursor;
unsigned c;
ncars = 0;
pass_max = argc > 1 ? atoi(argv[1]): PASS_MAX;
mt_cons_clear();
cursor = mt_cons_cursor(false);
init_road();
Ready(ctl = CreateTask(control, 0, NULL, "control", DEFAULT_PRIO));
mprint(OFFSET, MSGLINE, "I: auto hacia la izquierda");
mprint(OFFSET, MSGLINE+1, "D: auto hacia la derecha");
mprint(OFFSET, MSGLINE+2, "S: salir");
do
switch ( c = mgetch() )
{
case 'I':
case 'i':
send_car(LEFTBOUND);
break;
case 'D':
case 'd':
send_car(RIGHTBOUND);
break;
default:
break;
}
while ( c != 's' && c != 'S' );
mprint(OFFSET, MSGLINE + 3, "Esperando que terminen los autos...");
while ( ncars )
Yield();
DeleteTask(ctl);
mt_cons_clear();
mt_cons_cursor(cursor);
return 0;
}
void ParticleSource::emit(const U64 deltaTimeUS, std::shared_ptr<ParticleData> p) {
ParticleData& data = *p;
const F32 dt = Time::MicrosecondsToSeconds<F32>(deltaTimeUS);
const U32 maxNewParticles = to_U32(dt * _emitRate);
const U32 startID = data.aliveCount();
const U32 endID = std::min(startID + maxNewParticles, data.totalCount() - 1);
TaskHandle generateTask = CreateTask(_context.context(), DELEGATE_CBK<void, const Task&>());
for (std::shared_ptr<ParticleGenerator>& gen : _particleGenerators) {
gen->generate(generateTask, deltaTimeUS, data, startID, endID);
}
generateTask.startTask().wait();
for (U32 i = startID; i < endID; ++i) {
p->wake(i);
}
}
void sub_81376B8(void)
{
bool8 r4 = FALSE;
if (gSprites[gHealthboxIDs[gActiveBattler]].callback == SpriteCallbackDummy)
r4 = TRUE;
if (r4 && ewram17810[gActiveBattler].unk1_0 && ewram17810[gActiveBattler ^ 2].unk1_0)
{
ewram17810[gActiveBattler].unk0_7 = 0;
ewram17810[gActiveBattler].unk1_0 = 0;
ewram17810[gActiveBattler ^ 2].unk0_7 = 0;
ewram17810[gActiveBattler ^ 2].unk1_0 = 0;
FreeSpriteTilesByTag(0x27F9);
FreeSpritePaletteByTag(0x27F9);
CreateTask(c3_0802FDF4, 10);
HandleLowHpMusicChange(&gPlayerParty[gBattlerPartyIndexes[gActiveBattler]], gActiveBattler);
WallyBufferExecCompleted();
}
}
void CB2_InitResetRtcScreen(void)
{
REG_DISPCNT = 0;
SetVBlankCallback(NULL);
DmaClear16(3, PLTT, PLTT_SIZE);
DmaFill16Large(3, 0, (u8 *)VRAM, 0x18000, 0x1000);
ResetOamRange(0, 128);
LoadOam();
ScanlineEffect_Stop();
ScanlineEffect_Clear();
ResetSpriteData();
ResetTasks();
ResetPaletteFade();
Text_LoadWindowTemplate(&gMenuTextWindowTemplate);
InitMenuWindow(&gMenuTextWindowTemplate);
REG_DISPCNT = 4352;
SetVBlankCallback(VBlankCB_ResetRtcScreen);
SetMainCallback2(CB2_ResetRtcScreen);
CreateTask(Task_ResetRtcScreen, 80);
}
int
main(void)
{
mon = CreateMonitor("dos");
cond = CreateCondition("key", mon);
Ready(CreateTask(consumer, 2000, "consumer", "consumer", DEFAULT_PRIO));
while ( true )
{
EnterMonitor(mon);
while ( key )
WaitCondition(cond);
key = getch();
if ( key == 'S' || key == 's' )
return 0;
SignalCondition(cond);
LeaveMonitor(mon);
}
}
