void function_3 ( void )
{
while (1)
{
changePriority ( "fun_one", 4 );
changePriority ( "fun_two", 3 );
changePriority ( "fun_three",5 );
changePriority ( "fun_four", 2 );
printf ( "fun_3\n" );
}
}
static void addToOpenSet (astar_t *astar,
int node,
int nodeFrom)
{
coord_t nodeCoord = getCoord (astar->bounds, node);
coord_t nodeFromCoord = getCoord (astar->bounds, nodeFrom);
if (!exists (astar->open, node)) {
astar->cameFrom[node] = nodeFrom;
astar->gScores[node] = astar->gScores[nodeFrom] +
preciseDistance (nodeFromCoord, nodeCoord);
insert (astar->open, node, astar->gScores[node] +
estimateDistance (nodeCoord,
getCoord (astar->bounds, astar->goal)));
}
else if (astar->gScores[node] >
astar->gScores[nodeFrom] +
preciseDistance (nodeFromCoord, nodeCoord)) {
astar->cameFrom[node] = nodeFrom;
int oldGScore = astar->gScores[node];
astar->gScores[node] = astar->gScores[nodeFrom] +
preciseDistance (nodeFromCoord, nodeCoord);
double newPri = priorityOf (astar->open, node)
- oldGScore
+ astar->gScores[node];
changePriority (astar->open, node, newPri);
}
}
void function_4 ( void )
{
while (1)
{
changePriority ( "fun_one", 2 );
changePriority ( "fun_two", 3 );
changePriority ( "fun_three", 4 );
changePriority ( "fun_four", 5 );
// deleteTask ( "fun_one" );
// deleteTask ( "fun_two" );
deleteTask ( "fun_three" );
deleteTask ( "fun_four" );
printf ( "fun_ffffffoooouuurrrr\n" );
}
}
bool KMCupsJobManager::doPluginAction(int ID, const QPtrList<KMJob>& jobs)
{
switch (ID)
{
case 0:
if (jobs.count() == 1)
return jobIppReport(jobs.getFirst());
break;
case 1:
return changePriority(jobs, true);
case 2:
return changePriority(jobs, false);
case 3:
return editJobAttributes(jobs.getFirst());
}
return false;
}
Thread::Thread( const nc::string& description, SpThreadProc_t threadProc, nc::uint32_t priority )
: nc::generic::thread::Thread( description, threadProc, priority )
, suspendCount_( 0 )
{
//threadを構築する。
pthread_create( &hThread_, NULL, &Thread::functionAdapter, this );
{
nc::thread::ScopedLock< nc::thread::Mutex > lock( mtex_ );
isActive_ = true;
}
changePriority( priority_ );
}
static Htop_Reaction actionLowerPriority(State* st) {
bool changed = changePriority((MainPanel*)st->panel, 1);
return changed ? HTOP_REFRESH : HTOP_OK;
}
static void millisleep(unsigned long millisec) {
struct timespec req = {
.tv_sec = 0,
.tv_nsec = millisec * 1000000L
};
while(nanosleep(&req,&req)==-1) {
continue;
}
}
int main(int argc, char** argv) {
int delay = -1;
bool userOnly = false;
uid_t userId = 0;
int usecolors = 1;
char *argCopy;
char *pid;
Hashtable *pidWhiteList = NULL;
int opt, opti=0;
static struct option long_opts[] =
{
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'v'},
{"delay", required_argument, 0, 'd'},
{"sort-key", required_argument, 0, 's'},
{"user", required_argument, 0, 'u'},
{"no-color", no_argument, 0, 'C'},
{"no-colour",no_argument, 0, 'C'},
{"pid", required_argument, 0, 'p'},
{0,0,0,0}
};
int sortKey = 0;
char *lc_ctype = getenv("LC_CTYPE");
if(lc_ctype != NULL)
setlocale(LC_CTYPE, lc_ctype);
else if ((lc_ctype = getenv("LC_ALL")))
setlocale(LC_CTYPE, lc_ctype);
else
setlocale(LC_CTYPE, "");
/* Parse arguments */
while ((opt = getopt_long(argc, argv, "hvCs:d:u:p:", long_opts, &opti))) {
if (opt == EOF) break;
switch (opt) {
case 'h':
printHelpFlag();
break;
case 'v':
printVersionFlag();
break;
case 's':
if (strcmp(optarg, "help") == 0) {
for (int j = 1; j < LAST_PROCESSFIELD; j++)
printf ("%s\n", Process_fieldNames[j]);
exit(0);
}
sortKey = ColumnsPanel_fieldNameToIndex(optarg);
if (sortKey == -1) {
fprintf(stderr, "Error: invalid column \"%s\".\n", optarg);
exit(1);
}
break;
case 'd':
if (sscanf(optarg, "%16d", &delay) == 1) {
if (delay < 1) delay = 1;
if (delay > 100) delay = 100;
} else {
fprintf(stderr, "Error: invalid delay value \"%s\".\n", optarg);
exit(1);
}
break;
case 'u':
if (!setUserOnly(optarg, &userOnly, &userId)) {
fprintf(stderr, "Error: invalid user \"%s\".\n", optarg);
exit(1);
}
break;
case 'C':
usecolors=0;
break;
case 'p': {
argCopy = strdup(optarg);
char* saveptr;
pid = strtok_r(argCopy, ",", &saveptr);
if( !pidWhiteList ) {
pidWhiteList = Hashtable_new(8, false);
}
while( pid ) {
unsigned int num_pid = atoi(pid);
Hashtable_put(pidWhiteList, num_pid, (void *) 1);
pid = strtok_r(NULL, ",", &saveptr);
}
free(argCopy);
break;
}
default:
exit(1);
}
}
if (access(PROCDIR, R_OK) != 0) {
fprintf(stderr, "Error: could not read procfs (compiled to look in %s).\n", PROCDIR);
exit(1);
}
int quit = 0;
int refreshTimeout = 0;
int resetRefreshTimeout = 5;
bool doRefresh = true;
bool doRecalculate = false;
Settings* settings;
ProcessList* pl = NULL;
UsersTable* ut = UsersTable_new();
#ifdef HAVE_LIBNCURSESW
char *locale = setlocale(LC_ALL, NULL);
if (locale == NULL || locale[0] == '\0')
locale = setlocale(LC_CTYPE, NULL);
if (locale != NULL &&
(strstr(locale, "UTF-8") ||
strstr(locale, "utf-8") ||
strstr(locale, "UTF8") ||
strstr(locale, "utf8")))
CRT_utf8 = true;
else
CRT_utf8 = false;
#endif
pl = ProcessList_new(ut, pidWhiteList);
Process_getMaxPid();
Header* header = Header_new(pl);
settings = Settings_new(pl, header, pl->cpuCount);
int headerHeight = Header_calculateHeight(header);
// FIXME: move delay code to settings
if (delay != -1)
settings->delay = delay;
if (!usecolors)
settings->colorScheme = COLORSCHEME_MONOCHROME;
CRT_init(settings->delay, settings->colorScheme);
Panel* panel = Panel_new(0, headerHeight, COLS, LINES - headerHeight - 2, false, &Process_class);
ProcessList_setPanel(pl, panel);
FunctionBar* defaultBar = FunctionBar_new(defaultFunctions, NULL, NULL);
setTreeView(pl, defaultBar, pl->treeView);
if (sortKey > 0) {
pl->sortKey = sortKey;
setTreeView(pl, defaultBar, false);
pl->direction = 1;
}
ProcessList_printHeader(pl, Panel_getHeader(panel));
IncSet* inc = IncSet_new(defaultBar);
ProcessList_scan(pl);
millisleep(75);
FunctionBar_draw(defaultBar, NULL);
int acc = 0;
bool follow = false;
struct timeval tv;
double oldTime = 0.0;
int ch = ERR;
int closeTimeout = 0;
bool idle = false;
bool collapsed = false;
while (!quit) {
gettimeofday(&tv, NULL);
double newTime = ((double)tv.tv_sec * 10) + ((double)tv.tv_usec / 100000);
bool recalculate = (newTime - oldTime > settings->delay);
int following = follow ? selectedPid(panel) : -1;
if (recalculate) {
Header_draw(header);
oldTime = newTime;
}
if (doRefresh) {
if (recalculate || doRecalculate) {
ProcessList_scan(pl);
doRecalculate = false;
}
if (refreshTimeout == 0 || pl->treeView) {
ProcessList_sort(pl);
refreshTimeout = 1;
}
ProcessList_rebuildPanel(pl, true, following, userOnly, userId, IncSet_filter(inc));
idle = false;
}
doRefresh = true;
if (pl->treeView) {
Process* p = (Process*) Panel_getSelected(panel);
if (p) {
if (!p->showChildren && !collapsed) {
FunctionBar_setLabel(defaultBar, KEY_F(6), "Expand");
FunctionBar_draw(defaultBar, NULL);
} else if (p->showChildren && collapsed) {
FunctionBar_setLabel(defaultBar, KEY_F(6), "Collap");
FunctionBar_draw(defaultBar, NULL);
}
collapsed = !p->showChildren;
}
}
if (!idle) {
Panel_draw(panel, true);
}
int prev = ch;
if (inc->active)
move(LINES-1, CRT_cursorX);
ch = getch();
if (ch == ERR) {
if (!inc->active)
refreshTimeout--;
if (prev == ch && !recalculate) {
closeTimeout++;
if (closeTimeout == 100) {
break;
}
} else
closeTimeout = 0;
idle = true;
continue;
}
idle = false;
if (ch == KEY_MOUSE) {
MEVENT mevent;
int ok = getmouse(&mevent);
if (ok == OK) {
if (mevent.bstate & BUTTON1_CLICKED) {
if (mevent.y == panel->y) {
int x = panel->scrollH + mevent.x + 1;
ProcessField field = ProcessList_keyAt(pl, x);
if (field == pl->sortKey) {
ProcessList_invertSortOrder(pl);
setTreeView(pl, defaultBar, false);
} else {
setSortKey(pl, defaultBar, field, panel, settings);
}
refreshTimeout = 0;
continue;
} else if (mevent.y >= panel->y + 1 && mevent.y < LINES - 1) {
Panel_setSelected(panel, mevent.y - panel->y + panel->scrollV - 1);
doRefresh = false;
refreshTimeout = resetRefreshTimeout;
follow = true;
continue;
} if (mevent.y == LINES - 1) {
ch = FunctionBar_synthesizeEvent(inc->bar, mevent.x);
}
} else if (mevent.bstate & BUTTON4_CLICKED) {
ch = KEY_UP;
#if NCURSES_MOUSE_VERSION > 1
} else if (mevent.bstate & BUTTON5_CLICKED) {
ch = KEY_DOWN;
#endif
}
}
}
if (inc->active) {
doRefresh = IncSet_handleKey(inc, ch, panel, getMainPanelValue, NULL);
continue;
}
if (isdigit((char)ch)) {
if (Panel_size(panel) == 0) continue;
pid_t pid = ch-48 + acc;
for (int i = 0; i < ProcessList_size(pl); i++) {
Panel_setSelected(panel, i);
Process* p = (Process*) Panel_getSelected(panel);
if (p && p->pid == pid) {
break;
}
}
acc = pid * 10;
if (acc > 10000000)
acc = 0;
continue;
} else {
acc = 0;
}
switch (ch) {
case KEY_RESIZE:
Panel_resize(panel, COLS, LINES-headerHeight-1);
IncSet_drawBar(inc);
break;
case 'M':
{
refreshTimeout = 0;
setSortKey(pl, defaultBar, PERCENT_MEM, panel, settings);
break;
}
case 'T':
{
refreshTimeout = 0;
setSortKey(pl, defaultBar, TIME, panel, settings);
break;
}
case 'c':
{
Process* p = (Process*) Panel_getSelected(panel);
if (!p) break;
tagAllChildren(panel, p);
break;
}
case 'U':
{
for (int i = 0; i < Panel_size(panel); i++) {
Process* p = (Process*) Panel_get(panel, i);
p->tag = false;
}
doRefresh = true;
break;
}
case 'P':
{
refreshTimeout = 0;
setSortKey(pl, defaultBar, PERCENT_CPU, panel, settings);
break;
}
case KEY_F(1):
case 'h':
case '?':
{
showHelp(pl);
FunctionBar_draw(defaultBar, NULL);
refreshTimeout = 0;
break;
}
case '\014': // Ctrl+L
{
clear();
FunctionBar_draw(defaultBar, NULL);
refreshTimeout = 0;
break;
}
case ' ':
{
Process* p = (Process*) Panel_getSelected(panel);
if (!p) break;
Process_toggleTag(p);
Panel_onKey(panel, KEY_DOWN);
break;
}
case 's':
{
Process* p = (Process*) Panel_getSelected(panel);
if (!p) break;
TraceScreen* ts = TraceScreen_new(p);
TraceScreen_run(ts);
TraceScreen_delete(ts);
clear();
FunctionBar_draw(defaultBar, NULL);
refreshTimeout = 0;
CRT_enableDelay();
break;
}
case 'l':
{
Process* p = (Process*) Panel_getSelected(panel);
if (!p) break;
OpenFilesScreen* ts = OpenFilesScreen_new(p);
OpenFilesScreen_run(ts);
OpenFilesScreen_delete(ts);
clear();
FunctionBar_draw(defaultBar, NULL);
refreshTimeout = 0;
CRT_enableDelay();
break;
}
case 'S':
case 'C':
case KEY_F(2):
{
Setup_run(settings, header);
// TODO: shouldn't need this, colors should be dynamic
ProcessList_printHeader(pl, Panel_getHeader(panel));
headerHeight = Header_calculateHeight(header);
Panel_move(panel, 0, headerHeight);
Panel_resize(panel, COLS, LINES-headerHeight-1);
FunctionBar_draw(defaultBar, NULL);
refreshTimeout = 0;
break;
}
case 'F':
{
follow = true;
continue;
}
case 'u':
{
Panel* usersPanel = Panel_new(0, 0, 0, 0, true, Class(ListItem));
Panel_setHeader(usersPanel, "Show processes of:");
UsersTable_foreach(ut, addUserToVector, usersPanel);
Vector_insertionSort(usersPanel->items);
ListItem* allUsers = ListItem_new("All users", -1);
Panel_insert(usersPanel, 0, (Object*) allUsers);
const char* fuFunctions[] = {"Show ", "Cancel ", NULL};
ListItem* picked = (ListItem*) pickFromVector(panel, usersPanel, 20, headerHeight, fuFunctions, defaultBar, header);
if (picked) {
if (picked == allUsers) {
userOnly = false;
} else {
setUserOnly(ListItem_getRef(picked), &userOnly, &userId);
}
}
Panel_delete((Object*)usersPanel);
break;
}
case '+':
case '=':
case '-':
{
if (expandCollapse(panel)) {
doRecalculate = true;
refreshTimeout = 0;
}
break;
}
case KEY_F(9):
case 'k':
{
Panel* signalsPanel = (Panel*) SignalsPanel_new();
const char* fuFunctions[] = {"Send ", "Cancel ", NULL};
ListItem* sgn = (ListItem*) pickFromVector(panel, signalsPanel, 15, headerHeight, fuFunctions, defaultBar, header);
if (sgn) {
if (sgn->key != 0) {
Panel_setHeader(panel, "Sending...");
Panel_draw(panel, true);
refresh();
foreachProcess(panel, (ForeachProcessFn) Process_sendSignal, (size_t) sgn->key, NULL);
napms(500);
}
}
ProcessList_printHeader(pl, Panel_getHeader(panel));
Panel_delete((Object*)signalsPanel);
refreshTimeout = 0;
break;
}
#if (HAVE_LIBHWLOC || HAVE_NATIVE_AFFINITY)
case 'a':
{
if (pl->cpuCount == 1)
break;
Process* p = (Process*) Panel_getSelected(panel);
if (!p) break;
Affinity* affinity = Process_getAffinity(p);
if (!affinity) break;
Panel* affinityPanel = AffinityPanel_new(pl, affinity);
Affinity_delete(affinity);
const char* fuFunctions[] = {"Set ", "Cancel ", NULL};
void* set = pickFromVector(panel, affinityPanel, 15, headerHeight, fuFunctions, defaultBar, header);
if (set) {
Affinity* affinity = AffinityPanel_getAffinity(affinityPanel);
bool ok = foreachProcess(panel, (ForeachProcessFn) Process_setAffinity, (size_t) affinity, NULL);
if (!ok) beep();
Affinity_delete(affinity);
}
Panel_delete((Object*)affinityPanel);
ProcessList_printHeader(pl, Panel_getHeader(panel));
refreshTimeout = 0;
break;
}
#endif
case KEY_F(10):
case 'q':
quit = 1;
break;
case '<':
case ',':
case '>':
case '.':
{
sortBy(panel, pl, settings, headerHeight, defaultBar, header);
refreshTimeout = 0;
break;
}
case KEY_F(18):
case KEY_F(6):
{
if (pl->treeView) {
if (expandCollapse(panel)) {
doRecalculate = true;
refreshTimeout = 0;
}
} else {
sortBy(panel, pl, settings, headerHeight, defaultBar, header);
refreshTimeout = 0;
}
break;
}
case 'i':
{
Process* p = (Process*) Panel_getSelected(panel);
if (!p) break;
IOPriority ioprio = p->ioPriority;
Panel* ioprioPanel = IOPriorityPanel_new(ioprio);
const char* fuFunctions[] = {"Set ", "Cancel ", NULL};
void* set = pickFromVector(panel, ioprioPanel, 21, headerHeight, fuFunctions, defaultBar, header);
if (set) {
IOPriority ioprio = IOPriorityPanel_getIOPriority(ioprioPanel);
bool ok = foreachProcess(panel, (ForeachProcessFn) Process_setIOPriority, (size_t) ioprio, NULL);
if (!ok)
beep();
}
Panel_delete((Object*)ioprioPanel);
ProcessList_printHeader(pl, Panel_getHeader(panel));
refreshTimeout = 0;
break;
}
case 'I':
{
refreshTimeout = 0;
settings->changed = true;
ProcessList_invertSortOrder(pl);
break;
}
case KEY_F(8):
case '[':
{
doRefresh = changePriority(panel, 1);
break;
}
case KEY_F(7):
case ']':
{
doRefresh = changePriority(panel, -1);
break;
}
case KEY_F(3):
case '/':
IncSet_activate(inc, INC_SEARCH);
break;
case KEY_F(4):
case '\\':
IncSet_activate(inc, INC_FILTER);
refreshTimeout = 0;
doRefresh = true;
continue;
case 't':
case KEY_F(5):
refreshTimeout = 0;
collapsed = false;
setTreeView(pl, defaultBar, !pl->treeView);
if (pl->treeView) pl->direction = 1;
ProcessList_printHeader(pl, Panel_getHeader(panel));
ProcessList_expandTree(pl);
settings->changed = true;
if (following != -1) continue;
break;
case 'H':
doRecalculate = true;
refreshTimeout = 0;
pl->hideUserlandThreads = !pl->hideUserlandThreads;
pl->hideThreads = pl->hideUserlandThreads;
settings->changed = true;
break;
case 'K':
doRecalculate = true;
refreshTimeout = 0;
pl->hideKernelThreads = !pl->hideKernelThreads;
settings->changed = true;
break;
default:
doRefresh = false;
refreshTimeout = resetRefreshTimeout;
Panel_onKey(panel, ch);
break;
}
follow = false;
}
attron(CRT_colors[RESET_COLOR]);
mvhline(LINES-1, 0, ' ', COLS);
attroff(CRT_colors[RESET_COLOR]);
refresh();
CRT_done();
if (settings->changed)
Settings_write(settings);
Header_delete(header);
ProcessList_delete(pl);
IncSet_delete(inc);
FunctionBar_delete((Object*)defaultBar);
Panel_delete((Object*)panel);
UsersTable_delete(ut);
Settings_delete(settings);
if(pidWhiteList) {
Hashtable_delete(pidWhiteList);
}
return 0;
}
void deleteq (queue *q, int ind)
{
changePriority (q, ind, INT_MIN);
deleteMin (q);
}
void svc(SYSTEM_CALL_DATA *SystemCallData) {
MEMORY_MAPPED_IO mmio;
short call_type;
static short do_print = 10;
INT32 Time;
INT32 Status;
short i;
long* arg0=SystemCallData->Argument[0];
long* arg1=SystemCallData->Argument[1];
long* arg2=SystemCallData->Argument[2];
long* arg3=SystemCallData->Argument[3];
long* arg4=SystemCallData->Argument[4];
long *arg5=SystemCallData->Argument[5];
call_type = (short) SystemCallData->SystemCallNumber;
if (do_print > 0) {
printf("SVC handler: %s\n", call_names[call_type]);
for (i = 0; i < SystemCallData->NumberOfArguments - 1; i++) {
printf("Arg %d: Contents = (Decimal) %8ld, (Hex) %8lX\n", i,
(unsigned long) SystemCallData->Argument[i],
(unsigned long) SystemCallData->Argument[i]);
}
do_print--;
}
switch (call_type) {
// Get time service call
case SYSNUM_GET_TIME_OF_DAY:
mmio.Mode = Z502ReturnValue;
mmio.Field1 = mmio.Field2 = mmio.Field3 = 0;
MEM_READ(Z502Clock, &mmio);//hardware call
Time = mmio.Field1;
(SystemCallData->Argument[0])=(long*)&Time;
//statePrinter(call_type,arg0, arg1, arg2, arg3, arg4);
break;
// get the Timer start and generate idle.
case SYSNUM_SLEEP:
startTimer(arg0);
//statePrinter(call_type,arg0, arg1, arg2, arg3, arg4);
Dispatcher();//call dispatcher
break;
// create process
case SYSNUM_CREATE_PROCESS:
OSCreateProcess(arg0,arg1,arg2,arg3,arg4);
//statePrinter(call_type,arg0, arg1, arg2, arg3, arg4);
break;
// get process id
case SYSNUM_GET_PROCESS_ID:
getProcessID(arg0,arg1,arg2);
//statePrinter(call_type,arg0, arg1, arg2, arg3, arg4);
break;
// suspend process
case SYSNUM_SUSPEND_PROCESS:
suspendProcess(arg0, arg1);
//statePrinter(call_type,arg0, arg1, arg2, arg3, arg4);
break;
// resume the process
case SYSNUM_RESUME_PROCESS:
resumeProcess(arg0, arg1);
//statePrinter(call_type,arg0, arg1, arg2, arg3, arg4);
break;
// change priority;
case SYSNUM_CHANGE_PRIORITY:
changePriority(arg0,arg1,arg2);
//statePrinter(call_type,arg0, arg1, arg2, arg3, arg4);
break;
// terminate system call
case SYSNUM_TERMINATE_PROCESS:
terminateSysProcess(arg0,arg1);
break;
case SYSNUM_SEND_MESSAGE:
Send_message(arg0, arg1, arg2, arg3);
break;
case SYSNUM_RECEIVE_MESSAGE:
ReceiveMessage(arg0, arg1, arg2, arg3, arg4, arg5);
break;
case SYSNUM_DISK_WRITE:
DiskWrite(arg0, arg1, arg2);
break;
case SYSNUM_DISK_READ:
DiskRead(arg0, arg1, arg2);
break;
case SYSNUM_DEFINE_SHARED_AREA:
DefineSharedArea(arg0, arg1, arg2,arg3,arg4);
break;
default:
printf( "ERROR! call_type not recognized!\n" );
printf( "Call_type is - %i\n", call_type);
}
} // End of svc
int release(int numlocks,int ldes1)
{
struct lentry *lptr;
struct pentry *pptr;
int i;
pptr=&proctab[currpid];
if (pptr->deleted[ldes1]==1) //check if the locks has been deleted
{
pptr->deleted[ldes1]==0;
pptr->pwaitret=OK;
//continue;
return (SYSERR);
}
//if bad lock
if(isbadlock(ldes1) || (lptr=&lockarr[ldes1])->lstate==LFREE ||pptr->pwaitret==DELETED)
{ pptr->pwaitret=OK;
return (SYSERR);
}
if (pptr->pinh != 0)
{
pptr->pinh=0;
//chprio(currpid,pptr->prioh);
}
if (lptr->lstate==READ)
{
lptr->holder[currpid]=-1;
pptr->lockdesc[ldes1]=-1;
if (lptr->r_count>0) //if more readers present in the waiting queue
{
lptr->r_count--;
if (lptr->r_count ==0 && !isEmpty(lptr->lhead))
{
}
else
return OK;
}
}
else //change the holder of the process and of the locks
{
lptr->holder[currpid]=-1;
pptr->lockdesc[ldes1]=-1;
}
pptr->pinh=0; //check for the inverted priority
for(i=0;i<50;i++)
{
if (pptr->lockdesc[i]==1)
{
changePriority(i,getlast((&lockarr[i])->ltail));
}
}
pop_3(lptr->lhead,lptr->ltail,ldes1);
//continue;
return OK;
}
int analyzeAndSetPriorities(int gameBoard[BOARD_SIZE][BOARD_SIZE], int priorityArray[BOARD_SIZE][BOARD_SIZE], int player, int enemy, int startingX, int startingY, int XIncrement, int YIncrement){
int x,y;
int cell1X, cell1Y, cell2X, cell2Y, cell3X, cell3Y;
int cell1, cell2, cell3;
int highestPriority = 0;
/* *\
** Definizione celle **
\* */
cell1X = startingX;
cell1Y = startingY;
cell2X = startingX + XIncrement;
cell2Y = startingY + YIncrement;
cell3X = startingX + (2 * XIncrement);
cell3Y = startingY + (2 * YIncrement);
cell1 = gameBoard[cell1X][cell1Y];
cell2 = gameBoard[cell2X][cell2Y];
cell3 = gameBoard[cell3X][cell3Y];
if(isPlayerOrEnemy(cell1, player, enemy)){ //La cella 1 e' piena
if(isPlayerOrEnemy(cell2, player, enemy)){ //La cella 2 e' piena
if(isPlayerOrEnemy(cell3, player, enemy)){ //La cella 3 e' piena
if(areEqual(cell1,cell2,cell3)){ //Le 3 celle appartengono allo stesso giocatore
if(isPlayer(cell1,player)){
return 5;
}
else{
return 6;
}
}
}
else{ //La cella 3 e' vuota
if(cell1 == cell2){
if(isPlayer(cell1,player)){ //Le due celle piene appartengono al giocatore
changePriority(&priorityArray[cell3X][cell3Y], PRIOR_MAX, &highestPriority);
}
else{
changePriority(&priorityArray[cell3X][cell3Y], PRIOR_HIGH, &highestPriority);
}
}
else{ // Le due celle piene sono uguali, mossa inutile.
changePriority(&priorityArray[cell3X][cell3Y], PRIOR_LOW, &highestPriority);
}
}
}
else{ //La cella 2 e' vuota -- La cella 1 e' piena
if(isPlayerOrEnemy(cell3,player,enemy)){ //La cella 3 e' piena
if(cell1 == cell3){
if(isPlayer(cell1,player)){
changePriority(&priorityArray[cell2X][cell2Y], PRIOR_MAX, &highestPriority);
}
else{
changePriority(&priorityArray[cell2X][cell2Y], PRIOR_HIGH, &highestPriority);
}
}
else{ //Le celle piene sono diverse fra loro, mossa inutile
changePriority(&priorityArray[cell2X][cell2Y], PRIOR_LOW, &highestPriority);
}
}
else{ //Le celle 2 e 3 aono vuote -- La cella 1 e' piena
if(isPlayer(cell1,player)){
changePriority(&priorityArray[cell2X][cell2Y], PRIOR_MED, &highestPriority);
changePriority(&priorityArray[cell3X][cell3Y], PRIOR_MED, &highestPriority);
}
else{
changePriority(&priorityArray[cell2X][cell2Y], PRIOR_LOW, &highestPriority);
changePriority(&priorityArray[cell3X][cell3Y], PRIOR_LOW, &highestPriority);
}
}
}
}
else{ //La cella 1 e' vuota
if(isPlayerOrEnemy(cell2,player,enemy)){ //La cella 2 e' piena
if(isPlayerOrEnemy(cell3,player,enemy)){ //La cella 3 e' piena
if(cell2 == cell3){
if(isPlayer(cell2,player)){
changePriority(&priorityArray[cell1X][cell1Y], PRIOR_MAX, &highestPriority);
}
else{
changePriority(&priorityArray[cell1X][cell1Y], PRIOR_HIGH, &highestPriority);
}
}
else{ //Le celle piene sono diverse, mossa inutile.
changePriority(&priorityArray[cell1X][cell1Y], PRIOR_LOW, &highestPriority);
}
}
else{ //Celle 1 e 3 vuote -- Cella 2 piena
if(isPlayer(cell2,player)){
changePriority(&priorityArray[cell1X][cell1Y], PRIOR_MED, &highestPriority);
changePriority(&priorityArray[cell3X][cell3Y], PRIOR_MED, &highestPriority);
}
else{
changePriority(&priorityArray[cell1X][cell1Y], PRIOR_LOW, &highestPriority);
changePriority(&priorityArray[cell3X][cell3Y], PRIOR_LOW, &highestPriority);
}
}
}
else{ //Celle 1 e 2 vuote
if(isPlayerOrEnemy(cell3,player,enemy)){ //Cella 3 piena
if(isPlayer(cell3,player)){
changePriority(&priorityArray[cell2X][cell2Y], PRIOR_MED, &highestPriority);
changePriority(&priorityArray[cell1X][cell1Y], PRIOR_MED, &highestPriority);
}
else{
changePriority(&priorityArray[cell2X][cell2Y], PRIOR_LOW, &highestPriority);
changePriority(&priorityArray[cell1X][cell1Y], PRIOR_LOW, &highestPriority);
}
}
else{ //Tutte le celle sono vuote
changePriority(&priorityArray[cell1X][cell1Y], PRIOR_LOW, &highestPriority);
changePriority(&priorityArray[cell2X][cell2Y], PRIOR_LOW, &highestPriority);
changePriority(&priorityArray[cell3X][cell3Y], PRIOR_LOW, &highestPriority);
}
}
}
return highestPriority;
}