#include "generic.h"
#include "lfptypes.h"
#include "define.h"
#include "ml.h"


#ifndef N64
  #include "fontcode.h"
  #include "dbugtxt.h"
#endif

#include "ctrl.h"



#define TEAM (ball_handler<5)



//look up table for player roles
global int player_xlate[5]={
0,1,2,3,4};

global int max_play_dist;

/**/
/**/
/**/

int mid_man = -1;
int left_wing;
int right_wing;
int barge;
int trailer;
int side;

global bool set_flag;

int pick_ctr;
int last_pick;






void check_target_dist(playert *plyr)
{
int tmp;

	tmp = 0x10000;

	for (plyr = player+bhp->base; plyr < player+bhp->base+5; plyr++)
	{
//		plyr->score2 = plyr->play_dist;

		if (plyr->play_dist>tmp)	tmp = plyr->play_dist;
	}
	//status_var1   =
	max_play_dist = tmp;
}







int play_limit(playert *plyr, int f)
{
int r;

	// In 3 point contest, whatever is valid for ballhandler should be good
	if (C3PT)
		return f;

	if (ATTACKING)
	{
		if (!in_play_flag)
		{
			if (plyr->no == ball_handler)	return f;

			r = max_play_dist/(plyr->play_dist);

			switch (r)
			{

			case 0:
			case 1:
				return f;

			case 2:
				if (plyr->play_dist > 0x200000)			return 0xc0;

			default:
			case 3:
				return 0x80;
			}
		}


		if (!fast_break_flag)
		{
			if (bhp->basket_dist < 0xc00000)
			{
				if (plyr->ball_dist > 0x700000)
				{
		   			if (plyr->play_dist<0x400000)
					{
						return 0x80;
					}
				}
			}
			else
			{

				r = max_play_dist/(plyr->play_dist+1);


				switch (r)
				{

				case 0:
					return f;
				case 1:

					if ((plyr->no%5) > 2)
					{
						if (f>0xc0)	f=0xc0;
					}
					return f;

				case 2:
					if (plyr->play_dist > 0x200000)			return 0xc0;

				default:
				case 3:
					return 0x80;
				}
			}
		}
	}
	else
	{
		if (cur_team->dt==plyr)
		{
			if (f > 0xb0) 	return 0xb0;
		}
	}

	return f;
}











void get_lanes(void)
{
playert *plyr, *plyr1;
int score, best_score;

int y_mult;

	if (ball_handler > 4)
	{
		plyr1 = &player[5];
		y_mult = 1;
	}
	else
	{
		plyr1 = &player[0];
		y_mult = -1;
	}

	best_score = abs(plyr1->xco) + (plyr1->yco * y_mult);
	mid_man = plyr1->no;
	//find middle lane
	for (plyr= plyr1+1; plyr<(plyr1+3); plyr++)
	{
		score = abs(plyr->xco)*3 + (plyr->yco * y_mult);
		if (score < best_score)
		{
			best_score = score;
			mid_man    = plyr->no;
		}
	}

	//get left wing
	best_score = 0x7f000000;
	for (plyr= plyr1; plyr<(plyr1+3); plyr++)
	{
		if (plyr->no != mid_man)
		{
			score = abs(plyr->xco - 0x500000);
			if (score < best_score)
			{
				best_score = score;
				left_wing  = plyr->no;
			}
		}
	}

	//get right wing
	for (plyr= plyr1; plyr<(plyr1+3); plyr++)
	{
		if ((plyr->no != mid_man) && (plyr->no != left_wing))
		{
	 		right_wing  = plyr->no;
		}
	}

	barge   = plyr1->no+3;
	trailer = plyr1->no+4;


//	status_var1 = left_wing;
//	status_var2 = mid_man;
//	status_var3 = right_wing;
}






void fast_break_pos(playert *plyr)

{
SW  angle;

	//1st three set up to fill lanes
	if (mid_man == -1)
	{
		get_lanes();
	}

	if (plyr->no == mid_man)
	{
		bool flag;

		angle = LFPAsin(plyr->xco/0x8000);
		if (TEAM)	angle = 0x8000-angle;
		plyr->target_x = plyr->xco - (0x2000 * LFPSin(angle));
		plyr->target_y = plyr->yco - (0x2000 * LFPCos(angle));

		if (TEAM)
		{
			if (plyr->yco > 0x700000)
			{
				plyr->target_x = 0;
				if (blocked_basket_test(plyr)!=0xe)
				{
					plyr->target_y = 0x700000;
				}
				else
				{
					plyr->target_y = current_basket_y;
				}
			}
		}
		else
		{
			if (plyr->yco < -0x700000)
			{
				plyr->target_x = 0;
				if (blocked_basket_test(plyr)!=0xe)
				{
					plyr->target_y = -0x700000;
				}
				else
				{
					plyr->target_y = current_basket_y;
				}
			}
		}

	}
	else if (plyr->no == left_wing)
	{
		if (TEAM)
		{
			if (plyr->yco < 0x700000)
			{
				//fill left lane
				angle = 0x8000-LFPAsin((plyr->xco-0x500000)/0x8000);
				plyr->target_x = plyr->xco - (0x2000 * LFPSin(angle));
				plyr->target_y = plyr->yco - (0x2000 * LFPCos(angle));
			}
			else
			{
				//cut to basket
				plyr->target_x = 0x300000;
				plyr->target_y = current_basket_y;
			}
		}
		else
		{
			if (plyr->yco > -0x700000)
			{
				//fill left lane
				angle = LFPAsin((plyr->xco-0x500000)/0x8000);
				plyr->target_x = plyr->xco - (0x2000 * LFPSin(angle));
				plyr->target_y = plyr->yco - (0x2000 * LFPCos(angle));
			}
			else
			{
				//cut to basket
				plyr->target_x = 0x300000;
				plyr->target_y = current_basket_y;
			}
		}
	}
	else if (plyr->no == right_wing)
	{
		if (TEAM)
		{
			if (plyr->yco < 0x700000)
			{
				//fill right lane
 				angle = 0x8000-LFPAsin((plyr->xco+0x500000)/0x8000);
				plyr->target_x = plyr->xco - (0x2000 * LFPSin(angle));
				plyr->target_y = plyr->yco - (0x2000 * LFPCos(angle));
			}
			else
			{
				//cut to basket
				plyr->target_x = -0x300000;
				plyr->target_y = current_basket_y;
			}
		}
		else
		{
			if (plyr->yco > -0x700000)
			{
				//fill right lane
				angle = LFPAsin((plyr->xco+0x500000)/0x8000);
				plyr->target_x = plyr->xco - (0x2000 * LFPSin(angle));
				plyr->target_y = plyr->yco - (0x2000 * LFPCos(angle));
			}
			else
			{
				//cut to basket
				plyr->target_x = -0x300000;
				plyr->target_y = current_basket_y;
			}
		}
	}
	else if (plyr->no == barge)
	{
		int ty;

		plyr = &player[barge];
		plyr->target_x = (plyr->xco > 0) ? 0x200000: -0x200000;

		ty = player[mid_man].yco + ((TEAM) ? -0x300000:0x300000);
		if (abs(ty) > BASKET_Y)	ty = (ty>0) ? BASKET_Y: -BASKET_Y;
		plyr->target_y = ty;
	}
	else if (plyr->no == trailer)
	{
		int ty;

		plyr = &player[trailer];
		plyr->target_x = (player[barge].xco > 0) ? -0x200000: 0x200000;

		ty = player[mid_man].yco + ((TEAM) ? -0x600000:0x600000);
		if (abs(ty) > BASKET_Y)	ty = (ty>0) ? BASKET_Y: -BASKET_Y;
		plyr->target_y = ty;
	}
}


#if 0
playert *sort_plyr[10];

#ifdef PC
 int __cdecl compare_y(const void *a, const void *b)
#else
 int compare_y(const void *a, const void *b)
#endif
{
playert **pa, **pb;

	pa = (playert **)(a);
	pb = (playert **)(b);

	if( (*pa)->basket_dist < (*pb)->basket_dist)	return(1);
	if( (*pa)->basket_dist > (*pb)->basket_dist)	return(-1);
	else return(0);
}

#endif

#define	LANE_DX		0x280000
#define	BREAK_DY	0

int in_which_lane(playert *plyr)
{
	int	d=(TEAM)? 1 : -1;
	int	x=plyr->xco*d;

	if (x<-LANE_DX)
		return 0;

	if (x>LANE_DX)
		return 2;

	return 1;
}



/*
 * is fast break over ?
 */
#define FBD_COVER	0x200000

void fast_break_test(void)
{
	int		i;
	int		lanes[3];	// Number of defenders in intercept position in each lane
	int		lanesY[3];	// Y coordinate to beat for each lane
	int		defY[3];	// Closest defenders in each lane
	int		dir;		// Direction of travel
	playert *plyr;		// Defender whose effect on the fast break is being checked
	playert	*end;		// Pointer indicating end of player list

	if (mid_man==-1)
		return;

	// Initialize data for checking lanes
	if (TEAM)
	{
		dir=1;
		plyr=&player[5];
	}
	else
	{
		dir=-1;
		plyr=&player[0];
	}

	end=plyr+5;
	lanesY[0]=player[left_wing].yco*dir;
	lanesY[1]=player[mid_man].yco*dir;
	lanesY[2]=player[right_wing].yco*dir;
	for (i=0; i<3; i++)
	{
		lanes[i]=0;
		defY[i]=-BASE_LINE;
	}

	if (lanesY[0]>=0 || lanesY[1]>=0 || lanesY[2]>=0)
		lanes[0]=0;

	// Determine lane of defender and check to see if in front (or near) player in that lane
	do
	{
		int	l;
		int	y;

		y=plyr->yco*dir;
		l=in_which_lane(plyr);
		if (lanesY[l]-y<0)
			lanes[l]++;
		if (y>defY[l])
			defY[l]=y;
	} 	while(++plyr<end);

	// If an equal or greater number of defenders is upon the offensive team, quit fask break
	if (lanes[0]+lanes[1]+lanes[2]>=3)
		reset_play();

	// Kill fast break if a player reaches the end of the court & is covered
	for (i=0; i<3; i++)
		if (lanesY[i]>0xB60000)
			if (lanesY[i]-defY[i]<FBD_COVER)
			{
				reset_play();
				break;
			}
}



// ************************************************************************
// picked()
// ************************************************************************
// routine for a player that has set a pick
// ************************************************************************
// Inputs   - ptr to player
// Output   -
// ************************************************************************

void picked(playert *plyr)
{
playert *pickee;
SI x_diff, y_diff;
bool cancel;

	CallChainP(picked);

	if (!project_flag)
	{
		pickee = &player[plyr->pickee];

		x_diff = pickee->xco - plyr->xco;
		y_diff = pickee->yco - plyr->yco;

		plyr->pick_ctr--;

		//save to stop too many picks being called
		last_pick = lp_ctr;
		pick_ctr = 0;

		cancel = FALSE;
		if ((plyr->control) && (current_ctrlr->mctrlr & CTRL_PICK))
		{
			jmask(CTRL_PICK);
			cancel = TRUE;
		}
		
		if (plyr->pick_ctr==ONE_SEC && ReadRnd250()<0xc0)
		{
			plyr->pickee=-1;
			plyr->leg_routine=leg_deflt;
			plyr->top_routine=top_deflt;
			SetMain(picked,plyr,cut_to_basket);
		}

		if ( (cancel) || (MANHATTAN(x_diff, y_diff) > 0x100000) || (!possession_flag) || (plyr->pick_ctr<0))
		{
			plyr->pickee=-1;
			plyr->leg_routine=leg_deflt;
			plyr->top_routine=top_deflt;
			SetMain(picked,plyr,deflt);

			return;
		}
	}
}


// ************************************************************************
// run_screen()
// ************************************************************************
// run screen
// ************************************************************************
// Inputs   - ptr to player
// Output   -
// ************************************************************************

void run_screen(playert *plyr)
{
playert *screener;
int	angle;
int tx, ty;

	CallChainP(run_screen);

	screener = &player[plyr->pickee];

	//how far from target is screener

	if (MANHATTAN(screener->target_x-screener->xco,
				  screener->target_y-screener->yco) < 0x100000)
	{
		 tx = screener->xco;
		 ty = screener->yco;
	}
	else
	{
		 tx = screener->target_x;
		 ty = screener->target_y;
	}

	angle	= plyr->pick_angle;
	plyr->target_x = tx + ((LFPCos(angle) * 0x36));
	plyr->target_y = ty + ((LFPSin(angle) * 0x36));
	home_in4(plyr);
}


void start_set_pick(playert *plyr)
{
playert *plyr2, *target, *op;

	CallChainP(start_set_pick);

	//who are we setting pick for
	if (possession_flag)
	{
		plyr2 = bhp;
	}
	else if (ball.main_routine == pass_ball_move)
	{
		plyr2=player+int_recvr;
		if (plyr2 == plyr)	return;
	}
	else
	{
		return;
	}


	//who are we setting pick on
	target=NULL;
	for (op = player+(plyr->base^5); op < player+(plyr->base^5)+5; op++)
	{
		if (op->markee == plyr2->no)
		{
			//don't set pick on marker a long way from target
			if (MANHATTAN(op->xco-plyr2->xco, op->yco-plyr2->yco) < 0x400000)
			{
				if ((plyr->control==0) || (MANHATTAN(op->xco-plyr->xco, op->yco-plyr->yco) < 0x600000))
				{
					if ((target==NULL) || (markee[op->no]==plyr2->no))	target=op;
				}
			}
		}
	}

	if (target==NULL)	return;

	target->col_flags = -1;

	plyr->pickee     = target->no;

	SetMain(start_set_pick,plyr,set_pick);
	if (plyr->leg_routine == NULL)	plyr->leg_routine = leg_deflt;
	plyr->top_routine = top_deflt;

	plyr->pick_angle = LFPAtn(plyr->xco-(target->xco+LFPCos(bhp->dunk_angle)*16),
							  plyr->yco-(target->yco+LFPSin(bhp->dunk_angle)*16));

	pick_ctr = 2*ONE_SEC;
}


// ************************************************************************
// set_pick()
// ************************************************************************
// routine for a player in process of setting pick
// ************************************************************************
// Inputs   - ptr to player
// Output   -
// ************************************************************************

void set_pick(playert *plyr)
{
playert *pickee;
int	angle;
int x_diff, y_diff;
bool cancel;

	CallChainP(set_pick);

	if (!project_flag)
	{
		cancel = FALSE;

		if (pick_ctr)
			pick_ctr--;
		else
			cancel=TRUE;

		if ((plyr->control) && (current_ctrlr->mctrlr & CTRL_PICK))
		{
			jmask(CTRL_PICK);
			cancel=TRUE;
		}


		if ((cancel) || (!in_play_flag) || (loose_flag) || (ball.main_routine == shot_ball_move))
		{
			pick_ctr = 0;
			plyr->pickee	   = -1;
			SetMain(set_pick,plyr,deflt);
			return;
		}


		pickee = &player[plyr->pickee];

		//how far from markee is pickee
		angle	= plyr->pick_angle;
		plyr->target_x = pickee->xco + ((LFPCos(angle) * 0x20));
		plyr->target_y = pickee->yco + ((LFPSin(angle) * 0x20));

		x_diff = plyr->target_x - plyr->xco;
		y_diff = plyr->target_y - plyr->yco;

		//have I run into pickee or has he run into me?
		if ((plyr->col_flags == plyr->pickee) || (pickee->col_flags == plyr->no) || pickee->markee!=bhp->no)
		{
			//if so stop and turn to face pickee
			plyr->last_speed= 0;
			if	(turn_to (plyr, LFPAtn(pickee->xco - plyr->xco,
									   pickee->yco - plyr->yco)))
			{
				start_blend_anim(plyr, TOP_PICK);
				pickee->col_flags  = plyr->no;
				plyr->main_routine = picked;
				plyr->leg_routine=leg_deflt;
				start_blend_leg_anim(plyr, LEG_RDY);
				plyr->top_routine  = NULL;

				//set ctr to slow pickee down
				pickee->pick_ctr   = ONE_SEC*7/8;
				plyr->pick_ctr     = ONE_SEC*2;

				//made objective
				plyr->play_flag	= TRUE;
				plyr->play_dist = 0;

				if (ai_team[(plyr->no>4) ? 0: 1].controllers[0] == 0)
				{
					switch_markers(bhp, plyr);
				}
			}
		}
		else
		{
			//if not got there yet run towards target
			angle = LFPAtn(x_diff, y_diff);
			plyr->play_dist = MANHATTAN(x_diff, y_diff);

			current_ctrlr->d_angle = angle;
			current_ctrlr->force   = 0xf0;
		}
	}
}


bool avoid_plyr(playert *plyr, playert *p2, int tx, int ty)
{

int txd, tyd;
int pxd, pyd;
int pd, td;
SW  pa, ta, a_diff;

	pxd = p2->xco - plyr->xco;
	pyd = p2->yco - plyr->yco;
	pd  = MANHATTAN(pxd, pyd);

	if (pd < 0x300000)
	{
		txd = tx - plyr->xco;
		tyd = ty - plyr->yco;
		td  = MANHATTAN(txd, tyd);

		if (td > pd)
		{
			pa = LFPAtn(pxd, pyd);
			ta = LFPAtn(txd, tyd);

			a_diff = pa - ta;
			a_diff = abs(a_diff);

			if (a_diff > 0x4000)		return FALSE;
			if (a_diff < 0x2000)		goto avoid;
			a_diff -= 0x200000/(td>>12);
			if (a_diff > 0x2000)		return FALSE;

		avoid:

			current_ctrlr->d_angle = ta + (((pa-ta)>0) ? -0x2000:0x2000);

			current_ctrlr->force   = play_limit(plyr, 0xf0);
			return TRUE;
		}
	}

	return FALSE;
}






bool attack_home_in(playert *plyr, SW face_angle)
{
SW  target_direction, a_diff;
int run_cost, shuffle_cost, back_cost;
int target_dist;
int dist_cost;

int x_diff, y_diff;

	if (fast_break_flag	)
	{
		fast_break_pos(plyr);
	}

	x_diff = plyr->target_x - plyr->xco;
	y_diff = plyr->target_y - plyr->yco;


	current_ctrlr->ctrlr = 0;
	current_ctrlr->force = 0;

	target_direction = LFPAtn(x_diff, y_diff);

	plyr->play_dist =
	target_dist     = MANHATTAN(x_diff, y_diff);

	if (BALL_HANDLER)	goto run;


	dist_cost    = target_dist/((4096<<10)/0x10000);	//normalise target_dist so 4m = 360deg

//run cost
	run_cost     = dist_cost + abs((SW)(plyr->angle - target_direction)) + abs((SW)(target_direction - face_angle));

	shuffle_cost = dist_cost*2;
	shuffle_cost += (plyr->shuffle) ? -0x1000: 0x1000;

	back_cost    = ((dist_cost*3)/2) + abs((SW)(plyr->angle - target_direction + 0x8000))
 				  		    	     + abs((SW)(target_direction - face_angle + 0x8000));

	if ((run_cost < shuffle_cost) & (run_cost < back_cost))
	{
run:	//run home in

		if (target_dist > SLOW_ZONE)
		{
			if (!BALL_HANDLER)
			{
				if (target_dist > plyr->ball_dist)
				{
					if (plyr->ball_dist < 0x200000)
					{
						if (avoid_plyr(plyr, bhp, plyr->target_x, plyr->target_y))		return FALSE;
					}
				}
			}

			current_ctrlr->force   = play_limit(plyr, 0xf0);
			current_ctrlr->d_angle = target_direction;
			return FALSE;
		}
		else if (target_dist > STOP_ZONE)
		{
			current_ctrlr->force   = 0x80;
			current_ctrlr->d_angle = target_direction;
			return FALSE;
		}
		else
		{
			return TRUE;
		}
	}
	else if (shuffle_cost < back_cost)
	{
		//shuffle home in
		if (target_dist > SHUFFLE_SLOW_ZONE)
		{
			current_ctrlr->ctrlr  |= CTRL_SHUFFLE;
			current_ctrlr->force   = 0xf0;
			current_ctrlr->d_angle = target_direction;
			return FALSE;
		}
		else if (target_dist > SHUFFLE_STOP_ZONE)
		{
			current_ctrlr->ctrlr  |= CTRL_SHUFFLE;
			current_ctrlr->force   = 0x70;
			current_ctrlr->d_angle = target_direction;
			return FALSE;
		}
		else
		{
			return TRUE;
		}
	}
	else
	{

//		if (abs((SW)(plyr->angle - target_direction - 0x8000)) < 0x1000)
		{
			if (target_dist < BACK_STOP_ZONE)
			{
				current_ctrlr->force   = 0;
				return TRUE;
			}
			else
			{
				current_ctrlr->ctrlr  |= CTRL_BACK;
				current_ctrlr->d_angle = target_direction;
				current_ctrlr->force   = 0xc0;
				return FALSE;
			}
		}
/*
		else
		{
			//turn to face away from target
			current_ctrlr->d_angle = target_direction-0x8000;
			current_ctrlr->force   = 0x10;
			return FALSE;
		}
*/
	}
}









void in_place(playert *plyr, SW face_angle, SW target_direction)
{
SW a_diff;

	a_diff = plyr->angle - face_angle;

	if (!plyr->shuffle)
	{

		turn_to(plyr, face_angle);

		/*
		if ((a_diff > 0x80) || (a_diff < -0x80))
		{
			SW fa,ba;	//move angles for pivots


			current_ctrlr->force   = 0x10;
			current_ctrlr->d_angle = face_angle;

			switch (plyr->leg_anim)
			{
				case  LEG_PVTF:
				case -LEG_PVTF:
				pivot_flag2 = FALSE;
				break;

				case  LEG_PVTB:
				case -LEG_PVTB:
				pivot_flag2 = TRUE;
				break;

				default:
				if (a_diff > 0)
				{
					//pivot anti-clockwise
					fa = plyr->angle-0x1000;	//forward, left foot planted
					ba = plyr->angle-0x7000;	//backward, right foot planted
				}
				else
				{
					//pivot clockwise
					fa = plyr->angle+0x1000;	//forward, right foot planted
					ba = plyr->angle+0x7000;	//backward, left foot planted
				}

				fa -= target_direction;
				if (fa < 0)	fa = -fa;
				ba -= target_direction;
				if (ba < 0)	ba = -ba;

				//pivot_flag2   whether to pivot forward or backward

				pivot_flag2 = (ba < fa);
				break;
			}
		}
		*/
	}
}




/* *************************************************************************/
/* home in 4()															   */
/* *************************************************************************/
/* make an attacker move to his target with curve						   */
/* *************************************************************************/
/* Inputs   - ptr to player data,										   */
/* Output   - j_pad														   */
/* *************************************************************************/

bool home_in4(playert *plyr)
{
SI x_diff, y_diff;
SI dist;

	CallChainP(home_in4);

	plyr->play_flag = FALSE;

	x_diff = plyr->target_x - plyr->xco;
	y_diff = plyr->target_y - plyr->yco;

	plyr->play_dist =
	dist			= MANHATTAN(x_diff, y_diff);

	if (dist < 0x100000)
	{
		if ((plyr->no != ball_handler))
		{
			//if not doing anything next phase of play, face ball
			if ((!fast_break_flag))
			{
				//if (plays[offense][play][player_xlate[plyr->no-play_base]-play_base][play_phase+1].move == NOTHING)
				{
					if (attack_home_in(plyr, (SW)plyr->ball_angle))
					{
						in_place(plyr,
								 (SW)plyr->ball_angle,
								 LFPAtn(plyr->target_x - plyr->xco, plyr->target_y - plyr->yco)
								 );
					}

					return TRUE;
				}
			}
		}

		current_ctrlr->force = 0;
		plyr->play_flag		 = TRUE;
		return TRUE;
	}
	else
	{
		dist >>= 13;
		dist *= plyr->target_curve;

		if		(dist > 0x3000)		dist =  0x3000;
		else if (dist < -0x3000)	dist = -0x3000;

		current_ctrlr->d_angle = LFPAtn(x_diff, y_diff) + dist;
		current_ctrlr->force   = play_limit(plyr, 0xf0);
		return FALSE;
	}
}



/* *************************************************************************/
/* move_to_place()														   */
/* *************************************************************************/
/* make an attacker move to his target									   */
/* *************************************************************************/
/* Inputs   - ptr to player data,										   */
/* Output   - j_pad														   */
/* *************************************************************************/

void move_to_place (playert *plyr)
{
SW face_angle;

	CallChainP(move_to_place);

	if ((plyr->no != ball_handler) && (free_throws==0))
	{
		face_angle = LFPAtn(ball.xco-plyr->target_x,
							ball.yco-plyr->target_y);
	}
	else
	{
		face_angle = plyr->basket_angle;
	}


	if (current_ctrlr->mctrlr & CTRL_FOUL)
	{
		if ((in_play_flag) && (DEFENSIVE_FOULS))
		{
			foul_start(plyr);
		}
	}

	if (0)//( ((!fast_break_flag)&&(plyr->target_curve)&&(play_phase>0)&&(!DEFENDING)) || ((plyr->no == ball_handler) && (possession_flag)) )
	{
		home_in4(plyr);
	}
	else
	{
		if (attack_home_in(plyr, face_angle))
		{
			in_place(plyr,
					 face_angle,
					 LFPAtn(plyr->target_x - plyr->xco, plyr->target_y - plyr->yco)
					 );
		}
	}
}



void reset_play(void)
{
	mid_man    = -1;
	fast_break_flag = FALSE;
	side       = -1;

	set_flag = TRUE;
}


void set_fast_break(void)
{
	ten_sec_clock = 0;
	SetHalfFlag(set_fast_break,FALSE);
	fast_break_flag = TRUE;
	in_set_flag=FALSE;
	mid_man   = -1;
	side      = -1;
}


void auto_set(void)
{
int s;

	if (PracticeMode)
		return;

	if (bhp->control && !ICL_ROOKIE(&ctrlrs[bhp->control]))
		return;

	if ((set_flag) && (possession_flag) && (!fast_break_flag) && (PLY(bhp)>0) )
	{
		if (ai_team[ball_handler/5].last_set_change-time_left > ONE_MIN)
		{
			ai_team[ball_handler/5].last_set_change = time_left;
			
			s = (lp_ctr & 1) ? ai_team[ball_handler/5 ].set1: ai_team[ball_handler/5].set2;

			s=ReadRnd250()&0x7;

			if (s != ai_team[ball_handler/5].current_set)
			{
				ai_team[ball_handler/5].current_set = s;
				DC_Play=30;
			
			#ifdef N64
				//SetMsg(ball_handler/5,ai_team[ball_handler/5].current_set);
//old				AudioPlaySfx(SFX_ID_OK,11025,255,7);
			#endif
			}
		}
		set_flag=FALSE;
	}
}



enum SET
{
BOX,
PERIMETER,
HI_POST,
LO_POST,
MOTION,
ISSOLATION,
INSIDE_TRI,
OUTSIDE_TRI
};


int man_set[32]={

#ifdef USA
-1,0,3,-1,		//3
1,-1,-1,-1,		//7

2,-1,-1,-1,
-1,-1,-1,-1,

-1,4,7,-1,		//3
5,-1,-1,-1,		//7

6,-1,-1,-1,
-1,-1,-1,-1,
#endif


#ifdef PAL
-1,0,3,-1,		//3
1,-1,-1,-1,		//7

2,-1,-1,-1,
-1,-1,-1,-1,

-1,4,7,-1,		//3
5,-1,-1,-1,		//7

6,-1,-1,-1,
-1,-1,-1,-1,
#endif




#ifdef JAPAN
-1, HI_POST, LO_POST, -1,		//3
PERIMETER,-1,-1,-1,		//7

BOX,-1,-1,-1,
-1,-1,-1,-1,

-1,ISSOLATION,MOTION,-1,		//3
OUTSIDE_TRI,-1,-1,-1,		//7

INSIDE_TRI,-1,-1,-1,
-1,-1,-1,-1,
#endif


};



void manual_set(void)
{
int c;
static int	tt=0;

	if (ft_flag)
		return;

 	if ((bhp->control) && (possession_flag) && !ICL_ROOKIE(&ctrlrs[bhp->control]))
	{
		c = ctrlrs[bhp->control].ctrlr;
		c >>= 11;
		c &= 0x1f;

		if (c==0x10)
		{
			if (ctrlrs[bhp->control].mctrlr & CTRL_SHOULDER_L)
				ctrlrs[bhp->control].c_mask |= CTRL_SHOULDER_L;

			tt=lp_ctr;
		}
		else if (man_set[c] >= 0)
		{
			if (lp_ctr-tt<5 || ctrlrs[bhp->control].ctrlr&CTRL_SHOULDER_L)
			{
				c|=0x10;
				tt=lp_ctr;
			}

			if(ai_team[ball_handler/5].current_set != man_set[c])
			{
				ai_team[ball_handler/5].last_set_change = time_left;
				ai_team[ball_handler/5].current_set = man_set[c];
				DC_Play=30;
			}
		}
	}
}