//------------ Begin of function Unit::can_move2 -------------------// // // check a specific location can be walk, taking care that if that location is occupied // by a walking or waiting unit, that location will later on be freed. // // <int> locX - x-coordinate // <int> locY - y-coordinate // // return: <bool> - true if the location ccan be walked to // false otherwise // bool UnitB::can_move2(int locX, int locY) { Location* locPtr; int occRecno; Unit* unitPtr; int i, j; for(i=0; i<obj_loc_width(); i++) { for(j=0; j<obj_loc_height(); j++) { locPtr = world.get_loc(locX+i, locY+j); if(locX+i>= MAX_WORLD_X_LOC || locX+i <0 || locY+j >= MAX_WORLD_Y_LOC || locY+j < 0 ) return false; else if(!locPtr->can_move(mobile_type)) { occRecno = locPtr->unit_recno(mobile_type); if(!occRecno) //not a unit return false; else if(occRecno != sprite_recno) { unitPtr = unit_array[occRecno]; if(unitPtr->cur_action == SPRITE_WAIT || unitPtr->cur_action == SPRITE_MOVE) continue; else return false; } } } } return true; }
//------------Begin of function Unit::checking_who_occupy_the_place_i_want_to_go----------// // // This function checks who occupy the place that the unit wanted to go to // // <int> checkingLocX and checkingLocY ----the coordinate of the tile that the unit wanted to go // // return type <int> ----- the unit record number of the unit that occupys the tile is returned // int UnitB::checking_who_occupy_the_place_i_want_to_go(int checkingLocX, int checkingLocY) { int is, js, occupyingUnitRecordNumber = 0; Unit* theOccupyingStuff; int temperoryCheckingLocX, temperoryCheckingLocY; //return if the checking location is out of boundary if(checkingLocX >= MAX_WORLD_X_LOC || checkingLocX < 0 || checkingLocY >= MAX_WORLD_Y_LOC || checkingLocY <0) return 0; //only found those unit that are of the same nation of the said unit and is not moving // it is because only this type of units should walk away and give out the position // if the occupying unit is moving, no need to consider since the tile will soon be freed is = 0; temperoryCheckingLocX = checkingLocX; while(!occupyingUnitRecordNumber && is<obj_loc_width()) { if(temperoryCheckingLocX >= MAX_WORLD_X_LOC || temperoryCheckingLocX < 0) { is++; temperoryCheckingLocX++; continue; } js=0; temperoryCheckingLocY = checkingLocY; while(!occupyingUnitRecordNumber&& js<obj_loc_height()) { if(temperoryCheckingLocY >= MAX_WORLD_Y_LOC || temperoryCheckingLocY < 0) { js++; temperoryCheckingLocY++; continue; } occupyingUnitRecordNumber = world.get_loc(temperoryCheckingLocX, temperoryCheckingLocY)->unit_recno(mobile_type); if(occupyingUnitRecordNumber && ((occupyingUnitRecordNumber == sprite_recno) || (theOccupyingStuff = unit_array[occupyingUnitRecordNumber])->nation_recno != nation_recno || theOccupyingStuff->cur_action == SPRITE_MOVE || theOccupyingStuff->cur_action == SPRITE_WAIT || theOccupyingStuff->cur_action == SPRITE_ATTACK)) occupyingUnitRecordNumber = 0; js++; temperoryCheckingLocY++; } is++; temperoryCheckingLocX++; } return occupyingUnitRecordNumber; }
//---------- Begin of function UnitB::process_blocked -----// // // retry move to destination if the unit is blocked // void UnitB::process_blocked() { if(number_of_times_being_blocked++ > MAX_UNIT_BLOCKED_TIME || (next_x_loc() == move_to_loc_x && next_y_loc() == move_to_loc_y) || ((abs(move_to_loc_x - next_x_loc()) <= obj_loc_width()) && (abs(move_to_loc_y - next_y_loc()) <= obj_loc_height()) && !can_move(move_to_loc_x, move_to_loc_y) && !checking_who_occupy_the_place_i_want_to_go(move_to_loc_x, move_to_loc_y))) { set_no_longer_blocked(); stop_move(); } else move_to(move_to_loc_x, move_to_loc_y); }
//------------ Begin of function Unit::can_move -------------------// // // check whether a specific location can go walk to // // <int> locX - x-coordinate // <int> locY - y-coordinate // // return: <bool> - return true if the lcoation can be walk // return false if the location cannot be walk bool UnitB::can_move(int locX, int locY) { Location* locPtr; int i, j; for(i=0; i<obj_loc_width(); i++) { for(j=0; j<obj_loc_height(); j++) { locPtr = world.get_loc(locX+i, locY+j); if(locX+i>= MAX_WORLD_X_LOC || locX+i <0 || locY+j >= MAX_WORLD_Y_LOC || locY+j < 0 || (!locPtr->can_move(obj_mobile_type()) && (locPtr->unit_recno(obj_mobile_type()) != sprite_recno))) return false; } } return true; }
//------------ Begin of function UnitB::checking_who_occupy_my_next_tile-------// int UnitB::checking_who_occupy_my_next_tile(int checkingLocX, int checkingLocY) { int is, js, occupyingUnitRecordNumber = 0; int temperoryCheckingLocX, temperoryCheckingLocY; //return if the checking location is out of boundary if(checkingLocX >= MAX_WORLD_X_LOC || checkingLocX < 0 || checkingLocY >= MAX_WORLD_Y_LOC || checkingLocY <0) return 0; //only found those unit that are of the same nation of the said unit and is not moving // it is because only this type of units should walk away and give out the position // if the occupying unit is moving, no need to consider since the tile will soon be freed is = 0; temperoryCheckingLocX = checkingLocX; while(!occupyingUnitRecordNumber && is<obj_loc_width()) { if(temperoryCheckingLocX >= MAX_WORLD_X_LOC || temperoryCheckingLocX < 0) { is++; temperoryCheckingLocX++; continue; } js=0; temperoryCheckingLocY = checkingLocY; while(!occupyingUnitRecordNumber&& js<obj_loc_height()) { if(temperoryCheckingLocY >= MAX_WORLD_Y_LOC || temperoryCheckingLocY < 0) { js++; temperoryCheckingLocY++; continue; } occupyingUnitRecordNumber = world.get_loc(temperoryCheckingLocX, temperoryCheckingLocY)->unit_recno(mobile_type); js++; temperoryCheckingLocY++; } is++; temperoryCheckingLocX++; } return occupyingUnitRecordNumber; }
//--------- Begin of function UnitB::set_next --------// // // set the next coordinates to move to // // <int> newNextX, newNextY - next coordinate to move to // <int> para - used to count the result_path_dist // <int> ignoreBlockCheck - whether ignore blocking check or not // int UnitB::set_next(int newNextX, int newNextY, int para, int ignoreBlockCheck) { static char callingCount=0; int curNextXLoc = next_x_loc(); int curNextYLoc = next_y_loc(); int newNextXLoc = newNextX >> ZOOM_X_SHIFT_COUNT; int newNextYLoc = newNextY >> ZOOM_Y_SHIFT_COUNT; //------begin Juliet 14/10-----// int tempEndX = newNextXLoc+obj_loc_width()-1; int tempEndY = newNextYLoc+obj_loc_height()-1; //------end Juliet 14/10-------// short w, h, x, y; callingCount++; // this function is being called, prevent recursive calling if(curNextXLoc!=newNextXLoc || curNextYLoc!=newNextYLoc) { if(!is_dir_correct()) { set_turn(); return 1; } } //----------- blocking check ---------// if( !ignoreBlockCheck ) { int isBlocked=0; for(h=0, y=newNextYLoc; h<loc_height && !isBlocked ; h++, y++) { for(w=0, x=newNextXLoc; w<loc_width; w++, x++) { Location* locPtr = world.get_loc(x,y); if( locPtr->can_move(mobile_type) ) continue; //--- this location is occupied by the unit itself ---// if( locPtr->unit_recno(mobile_type) == sprite_recno ) continue; isBlocked = 1; break; } } if( isBlocked ) { //----- if we have already reach the destination -----// int rangeX1, rangeY1, rangeX2, rangeY2; get_object_range(move_to_loc_x, move_to_loc_y, rangeX1, rangeY1, rangeX2, rangeY2); if( m.is_touch( rangeX1, rangeY1, rangeX2, rangeY2, newNextXLoc, newNextYLoc, newNextXLoc+loc_width-1, newNextYLoc+loc_height-1 ) ) { stop_move(); } else //------- otherwise wait ---------// { set_wait(); } callingCount--; return 0; } } //--------- set the sprite_recno in new locations -----------// for(h=0, y=curNextYLoc; h<loc_height; h++, y++) { for(w=0, x=curNextXLoc; w<loc_width; w++, x++) world.get_loc(x,y)->remove_unit(mobile_type); } for(h=0, y=newNextYLoc; h<loc_height; h++, y++) { for(w=0, x=newNextXLoc; w<loc_width; w++, x++) world.get_loc(x,y)->set_unit(sprite_recno,mobile_type); } //----- set the new next coordinate ------// next_x = newNextX; next_y = newNextY; callingCount--; if( steps_remaining > 0 ) // steps_remaining can be decreased to negative as set_next() is called when stopping a unit, which is an addition to the steps it is supposed to move steps_remaining--; // --------- explore map ---------// if( cast_to_Unit() ) cast_to_Unit()->explore_on_move(curNextXLoc, curNextYLoc, newNextXLoc, newNextYLoc ); return 1; }
//------------Begin of function Unit::handle_blocking-------------// // //This function function handles blocking situation // return type <bool> - return true if handle successfully // return false if handle unsuccessfully bool UnitB::handle_blocking() { //---------Defining and initializing local variables-----------// int occupyingUnitRecordNumber; Unit* theOccupyingObject=NULL; int occLocX, occLocY; int theMoveToPlaceX, theMoveToPlaceY; bool handleSuccessfully=false; int is, js; //--------------------------------------------------------------// //setting the unit himself as not occupying the tile, otherwise it will found out that //he himself occupying the tile int lX = next_x_loc(); int lY = next_y_loc(); for(is = 0; is<obj_loc_width(); is++) for(js=0; js<obj_loc_height(); js++) world.get_loc(lX+is, lY+js)->remove_unit(mobile_type); //some local variables for use int checkingLocX=lX; int checkingLocY=lY; int directionX=0, directionY=0; int directionAngle; int destX = move_to_loc_x; int destY = move_to_loc_y; //would like to check first the direction of the destination, it makes more sense int diffX = destX-lX; int diffY = destY-lY; int stepSizeX=0, stepSizeY=0; if(diffX >= 0) { if(diffY<=0) { if(diffY >= -diffX) { checkingLocX++; directionX=1; } else { checkingLocY--; directionY=-1; } } else { if(diffY <= diffX) { checkingLocX++; directionX=1; } else { checkingLocY++; directionY =1; } } } else { if(diffY<=0) { if(diffY <= diffX) { checkingLocX--; directionX = -1; } else { checkingLocY--; directionY = -1; } } else { if(diffY <= -diffX) { checkingLocX--; directionX = -1; } else { checkingLocY++; directionY = 1; } } } if(!diffX && !diffY) { lX = next_x_loc(); lY = next_y_loc(); for(is = 0; is< obj_loc_width(); is++) for(js=0; js<obj_loc_height(); js++) world.get_loc(lX+is, lY+js)->set_unit(sprite_recno, mobile_type); return false; } directionAngle = m.angle_lookup(directionX, directionY); int firstTimeAngle = directionAngle; //loop over all the directiion of the blocked unit while(!handleSuccessfully && directionAngle < (firstTimeAngle+360)) { occupyingUnitRecordNumber = checking_who_occupy_the_place_i_want_to_go(checkingLocX, checkingLocY); if(occupyingUnitRecordNumber) theOccupyingObject = unit_array[occupyingUnitRecordNumber]; else theOccupyingObject = NULL; //do it only when it is of the same nationality and is a unit and is not a troop //let the blocking unit to move to the direction of the blocked unit want to go to if(theOccupyingObject && theOccupyingObject->nation_recno == nation_recno) { stepSizeX = obj_loc_width(); stepSizeY = obj_loc_height(); occLocX = theOccupyingObject->next_x_loc(); occLocY = theOccupyingObject->next_y_loc(); stepSizeX *= directionX; stepSizeY *= directionY; theMoveToPlaceX = occLocX+stepSizeX; theMoveToPlaceY = occLocY+stepSizeY; Location* locPtr = world.get_loc(theMoveToPlaceX, theMoveToPlaceY); //if the blocking unit successfully walk away, the blocked unit can then try to find a new path to the destination if( theOccupyingObject->can_move(theMoveToPlaceX, theMoveToPlaceY) || theOccupyingObject->checking_who_occupy_the_place_i_want_to_go(theMoveToPlaceX, theMoveToPlaceY)) { theOccupyingObject->move_to(theMoveToPlaceX, theMoveToPlaceY, false); if(theOccupyingObject->cur_action == SPRITE_MOVE || theOccupyingObject->cur_action == SPRITE_WAIT) { stop_move(); set_first_time_blocked(); handleSuccessfully = true; } } } directionAngle+=45; m.xy_lookup(directionAngle, directionX, directionY); checkingLocX = lX+directionX; checkingLocY = lY+directionY; } //set back the unit to occupy the tile after handling blocking. lX = next_x_loc(); lY = next_y_loc(); for(is = 0; is< obj_loc_width(); is++) for(js=0; js<obj_loc_height(); js++) world.get_loc(lX+is, lY+js)->set_unit(sprite_recno, mobile_type); return handleSuccessfully; }
//--------- Begin of function UnitB::get_object_range ---------// // // Get the full range of the area occupied by the object. // // <int> objXLoc, objYLoc - the location of the object // <int&> rangeX1, rangeY1, rangeX2, rangeY2 - vars for returning the range // void UnitB::get_object_range(int objXLoc, int objYLoc, int &rangeX1, int &rangeY1, int &rangeX2, int &rangeY2) { Location* locPtr; if(can_move(objXLoc, objYLoc)) { rangeX1 = objXLoc; rangeY1 = objYLoc; rangeX2 = objXLoc + loc_width - 1; rangeY2 = objYLoc + loc_height - 1; return; } //---------------------------------------// int* objLocFlag = (int*) mem_add_clear(loc_width*loc_height*sizeof(int)); int* objCargoRecno = (int*) mem_add_clear(loc_width*loc_height*sizeof(int)); int is, js; is = 0; int ind = 0; while(is<obj_loc_width()) { js = 0; while(js < obj_loc_height()) { locPtr = world.get_loc(objXLoc+is, objYLoc+js); ind = is*loc_height+js; if(mobile_type == UNIT_AIR) objCargoRecno[ind] = locPtr->air_cargo_recno; else objCargoRecno[ind] = locPtr->cargo_recno; objLocFlag[ind] = locPtr->loc_flag; if(!objLocFlag[ind] && objCargoRecno[ind] == sprite_recno) //it is myself objCargoRecno[ind] = 0; js++; } is++; } #ifdef DEBUG int checkCargo = 0; int checkFlag = 0; int index = 0; while(!checkCargo && !checkFlag && index < (loc_width*loc_height)) { checkCargo = objCargoRecno[index]; checkFlag = objLocFlag[index]; index++; } err_when(!checkCargo && !checkFlag); #endif //------ scan up -------// if(loc_width == 1 && loc_height == 1) { for( rangeY1=((objYLoc>=1)?(objYLoc-1):0) ; rangeY1>=0 ; rangeY1-- ) { if((world.get_loc(objXLoc, rangeY1)->loc_flag) != objLocFlag[0] || (mobile_type == UNIT_AIR ? (world.get_loc(objXLoc, rangeY1)->air_cargo_recno != objCargoRecno[0]) : (world.get_loc(objXLoc, rangeY1)->cargo_recno != objCargoRecno[0]))) { rangeY1++; // go back to the last one which is valid break; } } //------ scan down -------// for( rangeY2=((objYLoc<MAX_WORLD_Y_LOC-1)?(objYLoc+1):(MAX_WORLD_Y_LOC-1)) ; rangeY2<MAX_WORLD_Y_LOC ; rangeY2++ ) { if((world.get_loc(objXLoc, rangeY2)->loc_flag ) != objLocFlag[0] || (mobile_type == UNIT_AIR ? (world.get_loc(objXLoc, rangeY2)->air_cargo_recno != objCargoRecno[0]) : (world.get_loc(objXLoc, rangeY2)->cargo_recno != objCargoRecno[0]))) { rangeY2--; // go back to the last one which is valid break; } } //------ scan left -------// for( rangeX1=((objXLoc>=1)?(objXLoc-1):0) ; rangeX1>=0 ; rangeX1-- ) { if((world.get_loc(rangeX1, objYLoc)->loc_flag ) != objLocFlag[0] || (mobile_type == UNIT_AIR ? (world.get_loc(rangeX1, objYLoc)->air_cargo_recno != objCargoRecno[0]) : (world.get_loc(rangeX1, objYLoc)->cargo_recno != objCargoRecno[0]))) { rangeX1++; // go back to the last one which is valid break; } } //------ scan right -------// for( rangeX2=((objXLoc<MAX_WORLD_X_LOC-1)?(objXLoc+1):(MAX_WORLD_X_LOC-1)) ; rangeX2<MAX_WORLD_X_LOC ; rangeX2++ ) { if((world.get_loc(rangeX2, objYLoc)->loc_flag ) != objLocFlag[0] || (mobile_type == UNIT_AIR ? (world.get_loc(rangeX2, objYLoc)->air_cargo_recno != objCargoRecno[0]) : (world.get_loc(rangeX2, objYLoc)->cargo_recno != objCargoRecno[0]))) { rangeX2--; // go back to the last one which is valid break; } } } else //2 x 2 BUGHERE: only for 2x2 but not for other size other than 2x2 and 1x1 ( 3x3 may not work) { //it is very hard coded ! //scan up// if(objCargoRecno[0] == objCargoRecno[(loc_width-1)*loc_height] && objLocFlag[0] == objLocFlag[(loc_width-1)*loc_height]) { if(objCargoRecno[0] && (objLocFlag[0] & LOCATE_BLOCK_MASK)) { for(rangeY1=((objYLoc>=1)?(objYLoc-1):0); rangeY1 >= 0; rangeY1--) { if((world.get_loc(objXLoc, rangeY1)->loc_flag ) != objLocFlag[0] || (mobile_type == UNIT_AIR ? (world.get_loc(objXLoc, rangeY1)->air_cargo_recno != objCargoRecno[0]) : (world.get_loc(objXLoc, rangeY1)->cargo_recno != objCargoRecno[0]))) { rangeY1++; break; } } } else rangeY1 = objYLoc; } else { int tmpRangeY1, tmpRangeY2; if(objCargoRecno[0] && (objLocFlag[0] & LOCATE_BLOCK_MASK)) { for(tmpRangeY1=((objYLoc>=1)?(objYLoc-1):0); tmpRangeY1 >= 0; tmpRangeY1--) { if((world.get_loc(objXLoc, tmpRangeY1)->loc_flag ) != objLocFlag[0] || (mobile_type == UNIT_AIR ? (world.get_loc(objXLoc, tmpRangeY1)->air_cargo_recno != objCargoRecno[0]) : (world.get_loc(objXLoc, tmpRangeY1)->cargo_recno != objCargoRecno[0]))) { tmpRangeY1++; break; } } } else tmpRangeY1 = objYLoc; if(objCargoRecno[(loc_width-1)*loc_height] && (objLocFlag[(loc_width-1)*loc_height] & LOCATE_BLOCK_MASK)) { for(tmpRangeY2=((objYLoc>=1)?(objYLoc-1):0); tmpRangeY2 >= 0; tmpRangeY2--) { if((world.get_loc(objXLoc+loc_width-1, tmpRangeY2)->loc_flag ) != objLocFlag[(loc_width-1)*loc_height] || (mobile_type == UNIT_AIR ? (world.get_loc(objXLoc+loc_width-1, tmpRangeY2)->air_cargo_recno != objCargoRecno[(loc_width-1)*loc_height]) : (world.get_loc(objXLoc+loc_width-1, tmpRangeY2)->cargo_recno != objCargoRecno[(loc_width-1)*loc_height]))) { tmpRangeY2++; break; } } } else tmpRangeY2 = objYLoc; rangeY1 = min(tmpRangeY1, tmpRangeY2); } //scan down// if(objCargoRecno[loc_height-1] == objCargoRecno[loc_width*loc_height-1] && objLocFlag[loc_height-1] == objLocFlag[loc_width*loc_height-1]) { if(objCargoRecno[loc_height-1] && (objLocFlag[loc_height-1] & LOCATE_BLOCK_MASK)) { for(rangeY2=((objYLoc+loc_height<MAX_WORLD_Y_LOC)?objYLoc+loc_height:MAX_WORLD_Y_LOC-1); rangeY2<MAX_WORLD_Y_LOC; rangeY2++) { if((world.get_loc(objXLoc, rangeY2)->loc_flag ) != objLocFlag[loc_height-1] || (mobile_type == UNIT_AIR ? (world.get_loc(objXLoc, rangeY2)->air_cargo_recno != objCargoRecno[loc_height-1]) : (world.get_loc(objXLoc, rangeY2)->cargo_recno != objCargoRecno[loc_height-1]))) { rangeY2--; break; } } } else rangeY2 = objYLoc+loc_height-1; } else { int tmpRangeY1, tmpRangeY2; if(objCargoRecno[loc_height-1] && (objLocFlag[loc_height-1] & LOCATE_BLOCK_MASK)) { for(tmpRangeY1=((objYLoc+loc_height<MAX_WORLD_Y_LOC)?objYLoc+loc_height:MAX_WORLD_Y_LOC-1); tmpRangeY1<MAX_WORLD_Y_LOC; tmpRangeY1++) { if((world.get_loc(objXLoc, tmpRangeY1)->loc_flag ) != objLocFlag[loc_height-1] || (mobile_type == UNIT_AIR ? (world.get_loc(objXLoc, tmpRangeY1)->air_cargo_recno != objCargoRecno[loc_height-1]) : (world.get_loc(objXLoc, tmpRangeY1)->cargo_recno != objCargoRecno[loc_height-1]))) { tmpRangeY1--; break; } } } else tmpRangeY1 = objYLoc+loc_height-1; if(objCargoRecno[loc_width*loc_height-1] && (objLocFlag[loc_width*loc_height-1] & LOCATE_BLOCK_MASK)) { for(tmpRangeY2=((objYLoc+loc_height<MAX_WORLD_Y_LOC)?objYLoc+loc_height:MAX_WORLD_Y_LOC-1); tmpRangeY2<MAX_WORLD_Y_LOC; tmpRangeY2++) { if((world.get_loc(objXLoc+loc_width-1, tmpRangeY2)->loc_flag ) != objLocFlag[loc_width*loc_height-1] || (mobile_type == UNIT_AIR ? (world.get_loc(objXLoc+loc_width-1, tmpRangeY2)->air_cargo_recno != objCargoRecno[loc_width*loc_height-1]) : (world.get_loc(objXLoc+loc_width-1, tmpRangeY2)->cargo_recno != objCargoRecno[loc_width*loc_height-1]))) { tmpRangeY2--; break; } } } else tmpRangeY2 = objYLoc+loc_height-1; rangeY2 = max(tmpRangeY1, tmpRangeY2); } //scan left// if(objCargoRecno[0] == objCargoRecno[loc_height-1] && objLocFlag[0] == objLocFlag[loc_height-1]) { if(objCargoRecno[0] && (objLocFlag[0] & LOCATE_BLOCK_MASK)) { for(rangeX1=((objXLoc>=1)?(objXLoc-1):0); rangeX1 >= 0; rangeX1--) { if((world.get_loc(rangeX1, objYLoc)->loc_flag ) != objLocFlag[0] || (mobile_type == UNIT_AIR ? (world.get_loc(rangeX1, objYLoc)->air_cargo_recno != objCargoRecno[0]) : (world.get_loc(rangeX1, objYLoc)->cargo_recno != objCargoRecno[0]))) { rangeX1++; break; } } } else rangeX1 = objXLoc; } else { int tmpRangeX1, tmpRangeX2; if(objCargoRecno[0] && (objLocFlag[0] & LOCATE_BLOCK_MASK)) { for(tmpRangeX1=((objXLoc>=1)?(objXLoc-1):0); tmpRangeX1>=0; tmpRangeX1--) { if((world.get_loc(tmpRangeX1, objYLoc)->loc_flag ) != objLocFlag[0] || (mobile_type == UNIT_AIR ? (world.get_loc(tmpRangeX1, objYLoc)->air_cargo_recno != objCargoRecno[0]): (world.get_loc(tmpRangeX1, objYLoc)->cargo_recno != objCargoRecno[0]))) { tmpRangeX1++; break; } } } else tmpRangeX1 = objXLoc; if(objCargoRecno[loc_height-1] && (objLocFlag[loc_height-1] & LOCATE_BLOCK_MASK)) { for(tmpRangeX2=((objXLoc>=1)?(objXLoc-1):0); tmpRangeX2>=0; tmpRangeX2--) { if((world.get_loc(tmpRangeX2, objYLoc+loc_height-1)->loc_flag ) != objLocFlag[loc_height-1] || (mobile_type == UNIT_AIR ? (world.get_loc(tmpRangeX2, objYLoc+loc_height-1)->air_cargo_recno != objCargoRecno[loc_height-1]):(world.get_loc(tmpRangeX2, objYLoc+loc_height-1)->cargo_recno != objCargoRecno[loc_height-1]))) { tmpRangeX2++; break; } } } else tmpRangeX2 = objXLoc; rangeX1 = min(tmpRangeX1, tmpRangeX2); } //scan right// if(objCargoRecno[(loc_width-1)*loc_height] == objCargoRecno[loc_width*loc_height-1] && objLocFlag[(loc_width-1)*loc_height] == objLocFlag[loc_width*loc_height-1]) { if(objCargoRecno[(loc_width-1)*loc_height] && (objLocFlag[(loc_width-1)*loc_height] & LOCATE_BLOCK_MASK)) { for(rangeX2=((objXLoc+loc_width<MAX_WORLD_X_LOC)?objXLoc+loc_width:MAX_WORLD_X_LOC-1); rangeX2<MAX_WORLD_X_LOC; rangeX2++) { if((world.get_loc(rangeX2, objYLoc)->loc_flag ) != objLocFlag[(loc_width-1)*loc_height] || (mobile_type == UNIT_AIR ? (world.get_loc(rangeX2, objYLoc)->air_cargo_recno != objCargoRecno[(loc_width-1)*loc_height]):(world.get_loc(rangeX2, objYLoc)->cargo_recno != objCargoRecno[(loc_width-1)*loc_height]))) { rangeX2--; break; } } } else rangeX2 = objXLoc+loc_width-1; } else { int tmpRangeX1, tmpRangeX2; if(objCargoRecno[(loc_width-1)*loc_height] && (objLocFlag[(loc_width-1)*loc_height] & LOCATE_BLOCK_MASK)) { for(tmpRangeX1 = ((objXLoc+loc_width<MAX_WORLD_X_LOC)?objXLoc+loc_width:MAX_WORLD_X_LOC-1); tmpRangeX1<MAX_WORLD_X_LOC; tmpRangeX1++) { if((world.get_loc(tmpRangeX1, objYLoc)->loc_flag ) != objLocFlag[(loc_width-1)*loc_height] || (mobile_type == UNIT_AIR ? (world.get_loc(tmpRangeX1, objYLoc)->air_cargo_recno != objCargoRecno[(loc_width-1)*loc_height]):(world.get_loc(tmpRangeX1, objYLoc)->cargo_recno != objCargoRecno[(loc_width-1)*loc_height]))) { tmpRangeX1--; break; } } } else tmpRangeX1 = objXLoc+loc_width-1; if(objCargoRecno[loc_width*loc_height-1] && (objLocFlag[loc_width*loc_height-1] & LOCATE_BLOCK_MASK)) { for(tmpRangeX2 = ((objXLoc+loc_width<MAX_WORLD_X_LOC)?objXLoc+loc_width:MAX_WORLD_X_LOC-1); tmpRangeX2<MAX_WORLD_X_LOC; tmpRangeX2++) { if((world.get_loc(tmpRangeX2, objYLoc+loc_height-1)->loc_flag ) != objLocFlag[loc_width*loc_height-1] || world.get_loc(tmpRangeX2, objYLoc+loc_height-1)->cargo_recno != objCargoRecno[loc_width*loc_height-1]) { tmpRangeX2--; break; } } } else tmpRangeX2 = objXLoc+loc_width-1; rangeX2 = max(tmpRangeX1, tmpRangeX2); } } rangeX1=max(rangeX1, 0); rangeY1=max(rangeY1, 0); rangeX2=min(rangeX2, MAX_WORLD_X_LOC-1); rangeY2=min(rangeY2, MAX_WORLD_Y_LOC-1); err_when((rangeX2-rangeX1+1) > 30); err_when((rangeY2-rangeY1+1) > 30); mem_del(objLocFlag); mem_del(objCargoRecno); }